GraspItSceneManager.h

Go to the documentation of this file.

#ifndef GRASP_PLANNING_GRASPIT_GRASPITSCENEMANAGER_H
#define GRASP_PLANNING_GRASPIT_GRASPITSCENEMANAGER_H

#ifdef DOXYGEN_SHOULD_SKIP_THIS

#endif

#include <string>
#include <map>

#include <QObject>

#include <grasp_planning_graspit/ThreadImpl.h>
#include <grasp_planning_graspit/SharedPtr.h>
#include <grasp_planning_graspit/GraspItTypes.h>


class GraspableBody;
class Hand;
class EGPlanner;
class World;
class GraspitCore;
class SoSensor;
class transf;
class Robot;
class Body;
class GraspableBody;
class WorldElement;


namespace GraspIt
{

class GraspItAccessor;

class GraspItSceneManager
{
    friend class GraspItAccessor;
public:
    GraspItSceneManager();
    virtual ~GraspItSceneManager();

    void initialize();

    void shutdown();

    bool isInitialized() const;

    virtual bool isReady() const = 0;

    virtual void waitUntilReady() const = 0;

    std::vector<std::string> getObjectNames(bool graspable) const;
    std::vector<std::string> getRobotNames() const;


    int loadWorld(const std::string& filename);


    int loadRobot(const std::string& filename, const std::string& robotName,
                  const EigenTransform& worldTransform = EigenTransform::Identity());

    int removeRobot(const std::string& robotName);

    int moveRobot(const std::string& robotName, const EigenTransform& worldTransform);


    int loadObject(const std::string& filename, const std::string& name, const bool asGraspable = true,
                   const EigenTransform& worldTransform = EigenTransform::Identity());

    int removeObject(const std::string& name);

    int moveObject(const std::string& name, const EigenTransform& worldTransform);

    int setCurrentHand(const std::string& robotName);

    int setCurrentGraspableObject(const std::string& objectName);

    int setGraspableObject(const std::string& robotName, const std::string& objectName);

    bool saveGraspItWorld(const std::string& filename, bool createDir = false);

    bool saveInventorWorld(const std::string& filename, bool createDir = false);

    bool saveRobotAsInventor(const std::string& filename, const std::string& robotName,
                                   const bool createDir=false, const bool forceWrite=false);

    bool saveObjectAsInventor(const std::string& filename, const std::string& name,
                              const bool createDir=false, const bool forceWrite=false);

    bool isRobotLoaded(const std::string& name) const;
    bool isObjectLoaded(const std::string& name) const;

protected:
    virtual void initializeCore() = 0;

    virtual void destroyCore() = 0;

    virtual World * createNewGraspitWorld() = 0;

    virtual bool eventThreadRunsQt() const
    {
        return false;
    }



    void processIdleEvent();


    bool isRobotLoaded(const Robot * robot) const;
    bool isObjectLoaded(const Body * body) const;

    unsigned int getNumGraspableBodies() const;

    unsigned int getNumRobots() const;

    unsigned int getNumBodies() const;

    bool tryLockWorld()
    {
        return graspitWorldMtx.try_lock();
    }

    void lockWorld()
    {
        graspitWorldMtx.lock();
    }

    void unlockWorld()
    {
        graspitWorldMtx.unlock();
    }

    UNIQUE_RECURSIVE_LOCK getUniqueWorldLock()
    {
        return UNIQUE_RECURSIVE_LOCK(graspitWorldMtx);
    }

    Hand * getCurrentHand();

    const Hand * readCurrentHand() const;

    GraspableBody * getCurrentGraspableBody();

    const GraspableBody * readCurrentGraspableBody() const;



    Robot * getRobot(const std::string& name);

    const Robot * readRobot(const std::string& name) const;

    Robot * getRobot(const unsigned int i);



    GraspableBody * getGraspableBody(const std::string& name);

    const GraspableBody * readGraspableBody(const std::string& name) const;

    GraspableBody * getGraspableBody(const unsigned int i);


    Body * getBody(const std::string& name);

    const Body * readBody(const std::string& name) const;

    Body * getBody(const unsigned int i);

    bool removeElement(WorldElement* elem, const bool deleteInstance);

    int addRobot(Robot* robot, const EigenTransform& worldTransform);

    int addBody(Body* body, const EigenTransform& worldTransform);

    virtual bool scheduleIdleEvent() = 0;


private:
    GraspItSceneManager(const GraspItSceneManager& o) {}

    GraspableBody * getGraspableBodyNoCheck(const std::string& name);

    const GraspableBody * readGraspableBodyNoCheck(const std::string& name) const;

    GraspableBody * getGraspableBodyNoCheck(const unsigned int i);

    Body * getBodyNoCheck(const unsigned int i);

    Body * getBodyNoCheck(const std::string& name);

    const Body * readBodyNoCheck(const std::string& name) const;

    Robot * getRobotNoCheck(const unsigned int i);

    Robot * getRobotNoCheck(const std::string& name);

    const Robot * readRobotNoCheck(const std::string& name) const;


    int moveObjectNoCheck(const std::string& name, const EigenTransform& worldTransform);

    int moveRobotNoCheck(const std::string& name, const EigenTransform& worldTransform);


    int removeObjectNoCheck(const std::string& name);

    int removeRobotNoCheck(const std::string& name);


    void removeElementNoCheck(WorldElement* elem, const bool deleteInstance);


    bool addIdleListener(GraspItAccessor* s);

    bool removeIdleListener(GraspItAccessor* s);


protected:
    // internally needed object for the inventor stuff.
    GraspitCore * core;

    // This is just a convenience pointer.
    World * graspitWorld;
    mutable RECURSIVE_MUTEX graspitWorldMtx;

private:
    std::map<std::string, GraspItAccessor*> registeredAccessors;
    MUTEX registeredAccessorsMtx;


    // Initialization flag set to true after initialize() was called.
    bool initialized;

    QObject *fakeQObjectParent;
};
}  // namespace GraspIt
#endif  //  GRASP_PLANNING_GRASPIT_GRASPITSCENEMANAGER_H