DefaultScoreContainer.hpp

Go to the documentation of this file.

#ifndef DEFAULTSCORECONTAINER_HPP_
#define DEFAULTSCORECONTAINER_HPP_

#include <map>
#include <boost/make_shared.hpp>
#include "next_best_view/rating/BaseScoreContainer.hpp"

namespace next_best_view {
        struct DefaultScoreContainer : public BaseScoreContainer {
        private:

        // The costs if the robot must drive around
        float mMovementCostsBaseTranslation;
        // The costs to rotate the robot (change it orientation)
        float mMovementCostsBaseRotation;
        // Cost for move the PTU.
        float mMovementCostsPTU;
        // The Cost for calculate a new recognition
        float mRecognitionCosts;
        // this is the UNnormalized utility, while the BaseScoreContainer contains the normalized utility
        float mUtility;
        // the utility for each object type
        std::map<std::string, float> mObjectUtilities;
        float mUtilityNormalization;

        public:

        DefaultScoreContainer();

        virtual ~DefaultScoreContainer();

        void setUnweightedInverseMovementCostsBaseTranslation(float value) {
            mMovementCostsBaseTranslation = value;
        }

        float getUnweightedInverseMovementCostsBaseTranslation() const {
            return mMovementCostsBaseTranslation;
        }

        void setUnweightedInverseMovementCostsBaseRotation(float value) {
            mMovementCostsBaseRotation = value;
        }

        float getUnweightedInverseMovementCostsBaseRotation() const {
            return mMovementCostsBaseRotation;
        }

        void setUnweightedInverseMovementCostsPTU(float value) {
            mMovementCostsPTU = value;
        }

        float getUnweightedInverseMovementCostsPTU() const {
            return mMovementCostsPTU;
        }

        void setUnweightedInverseRecognitionCosts(float value) {
            mRecognitionCosts = value;
        }

        float getUnweightedInverseRecognitionCosts() const {
            return mRecognitionCosts;
        }

        void setUnweightedUnnormalizedUtility(float value) {
            mUtility = value;
        }

        float getUnweightedUnnormalizedUtility() const {
            return mUtility;
        }

        void setUnweightedUnnormalizedObjectUtilitiy(std::string objectType, float value) {
            mObjectUtilities[objectType] = value;
        }

        float getUnweightedUnnormalizedObjectUtility(std::string objectType) const {
            if (mObjectUtilities.count(objectType) == 0) {
                return 0;
            }
            return mObjectUtilities.at(objectType);
        }

        void setUtilityNormalization(float value) {
            mUtilityNormalization = value;
        }

        float getUtilityNormalization() const {
            return mUtilityNormalization;
        }

        boost::shared_ptr<std::vector<boost::shared_ptr<std::string>>> getObjectTypes() const {
            auto objectTypes = boost::make_shared<std::vector<boost::shared_ptr<std::string>>>();
            if (mObjectUtilities.size() == 0)
                return objectTypes;
            for (auto object : mObjectUtilities) {
                auto objectType = boost::shared_ptr<std::string>(new std::string(object.first));
                objectTypes->push_back(objectType);
            }
            return objectTypes;
        }
        };

        typedef boost::shared_ptr<DefaultScoreContainer> DefaultScoreContainerPtr;

    std::ostream& operator<<(std::ostream &strm, const next_best_view::DefaultScoreContainer &score);
    std::ostream& operator<<(std::ostream &strm, const next_best_view::DefaultScoreContainerPtr &score);
}


#endif /* DEFAULTSCORECONTAINER_HPP_ */