scene.h

Go to the documentation of this file.

/* Author: Constantinos Chamzas  */

#ifndef SE2EZ_CORE_SCENE_
#define SE2EZ_CORE_SCENE_

#include <map>
#include <vector>

#include <se2ez/core/class_forward.h>
#include <se2ez/core/math.h>

namespace se2ez
{
    /** \cond IGNORE */
    SE2EZ_CLASS_FORWARD(State)
    SE2EZ_CLASS_FORWARD(Robot)
    /** \endcond */

    /** \cond IGNORE */
    SE2EZ_CLASS_FORWARD(Scene)
    /** \endcond */

    /** \class se2ez::ScenePtr
        \brief A shared pointer wrapper for se2ez::Scene. */

    /** \class se2ez::SceneConstPtr
        \brief A const shared pointer wrapper for se2ez::Scene. */

    /** \brief A representation of a Scene (in this case, one active robot and multiple passive robots (with
     * all joints fixed representing the obstacles).
     */
    class Scene
    {
    public:
        struct RobotData
        {
            const RobotPtr robot;  ///< Underlying robot.
            const StatePtr state;  ///< Underlying state of the robot.

            /** \brief Constructor.
             *  \param[in] r Robot to store.
             *  \param[in] s State associated with robot.
             */
            RobotData(const RobotPtr &r, const StatePtr &s);
        };

        /** \brief Constructor. Nothing interesting right now.
         */
        Scene(const RobotPtr &arobot);

        // non-copyable
        Scene(const Scene &) = delete;
        Scene(Scene &&) = delete;

        /** \name Scene Management
            \{ */

        /** \brief Attach a robot as passive to the scene at a zero state.
         *  \param[in] robot Robot to attach.
         *  \param[in] name Name of the robot.
         */
        void addRobot(const RobotPtr &robot, const std::string &name);

        /** \brief Attach a robot as passive to the scene with given  state
         *  \param[in] robot Robot to attach.
         *  \param[in] name Name of the robot.
         *  \param[in] state State of the attached Frame.
         */
        void addRobot(const RobotPtr &robot, const std::string &name, const StatePtr &state);

        /** \brief creates the scene, is called after a robot is added.
         */
        void compileScene();

        /** \brief Removes the specific robot from the Scene.
         */
        void removeRobot(const std::string &name);

        /** \brief Completely clears internal structures, a brand new scene!
         */
        void clear();

        /** \brief Completely clears the passive robots!
         */
        void clearPassive();

        /** \} */

        /** \name Getters and Setters
            \{ */

        /** \brief Returns a the active robot.
         *  \return Active Robot.
         */
        const RobotPtr &getActiveRobot();

        /** \brief Returns a new aggregated robot including all the passive and active robots
         *  \return MegaRobot.
         */
        const RobotPtr &getSceneRobot();

        /** \brief Returns the mrobot signature.
         *  \return signature of the mega-robot.
         */
        const std::string &getSignature();

        /** \brief Returns robot the robot named name, throws error otherwise.
         *  \return RobotPtr to that robot.
         */
        const RobotPtr &getRobot(const std::string &name);

        /** \brief Gets the all the names of the robots active and passive.
         *  \return Vector of all robots in the Scene.
         */
        const std::vector<std::string> getRobotNames();

        /** \brief Sets a state for a robot.
         *  \param[in] name Name of state to set.
         *  \param[in] state State to set named state to.
         */
        void setRobotState(const std::string &name, const StatePtr &state);

        /** \brief Sets every passive robot to a random state.
         */
        void setRandom();

        /** \brief get  the state for a robot.
         *  \param[in] name Name of state to set.
         *  \param[in] state State to set named state to.
         */
        void getNamedRobot(const std::string &name, const StatePtr &state);

        /** \} */

        bool dirty{false};  ///< Does the scene robot need updating?

    private:
        std::map<std::string, RobotData> robots_;  ///< Map of robots and their names.
        const RobotPtr arobot_;                    ///< Active Robot
        RobotPtr mrobot_;                          ///< Mega Robot
    };
}  // namespace se2ez

#endif