Robot.h

Go to the documentation of this file.

#ifndef PMPL_ROBOT_H_
#define PMPL_ROBOT_H_
 
#include "Control.h"
 
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <unordered_map>
 
class Actuator;
class Body;
class Boundary;
class Cfg;
class CSpaceBoundingBox;
class MPProblem;
class MultiBody;
class XMLNode;
 
 
class Robot final {
 
 
  MPProblem* m_problem{nullptr};              
 
  std::unique_ptr<MultiBody> m_multibody;  
 
  std::unordered_map<std::string, std::unique_ptr<Actuator>> m_actuators;
  std::unique_ptr<CSpaceBoundingBox> m_cspace;    
  std::unique_ptr<CSpaceBoundingBox> m_vspace;    
 
  std::string m_label;             
  bool m_virtual{false};           
  bool m_nonholonomic{false};      
  bool m_carlike{false};           
  double m_maxLinearVelocity{10};  
  double m_maxAngularVelocity{1};  
  std::string m_capability;        
  bool m_fixed{false};             
  bool m_manipulator{false};       
  std::string m_defaultStrategyLabel; 
 
  struct EndEffector {
    EndEffector() {}
    EndEffector(XMLNode& _node, MultiBody* const _mb);
 
    Body* effectorBody{nullptr};
 
    mathtool::Vector3d contactPoint;
 
    mathtool::Vector3d centerToContactDir;
  };
 
  EndEffector m_endEffector;  
 
 
  public:
 
 
    Robot(MPProblem* const _p, XMLNode& _node);
 
    Robot(MPProblem* const _p, std::unique_ptr<MultiBody>&& _mb,
          const std::string& _label);
 
    Robot(MPProblem* const _p, const Robot& _r);
 
    ~Robot() noexcept;
 
 
    Robot(const Robot&) = delete;
    Robot(Robot&&) = delete;
 
    Robot& operator=(const Robot&) = delete;
    Robot& operator=(Robot&&) = delete;
 
 
  protected:
 
 
    void ReadXMLFile(const std::string& _filename);
 
    void ReadXMLNode(XMLNode& _node);
 
    void ReadMultiBodyXML(XMLNode& _node);
 
    void ReadMultibodyFile(const std::string& _filename);
 
 
  public:
 
 
    void InitializePlanningSpaces();
 
    const CSpaceBoundingBox* GetCSpace() const noexcept;
 
    const CSpaceBoundingBox* GetVSpace() const noexcept;
 
    MPProblem* GetMPProblem() const noexcept;
 
 
    MultiBody* GetMultiBody() noexcept;
    const MultiBody* GetMultiBody() const noexcept;
 
    const EndEffector& GetEndEffector() const noexcept;
 
 
    Actuator* GetActuator(const std::string& _label) noexcept;
    const std::unordered_map<std::string, std::unique_ptr<Actuator>>&
        GetActuators() const noexcept;
 
 
    bool IsVirtual() const noexcept;
 
    void SetVirtual(const bool _v) noexcept;
 
    bool IsNonholonomic() const noexcept;
 
    bool IsCarlike() const noexcept;
 
    double GetMaxLinearVelocity() const noexcept;
 
    double GetMaxAngularVelocity() const noexcept;
 
    const std::string& GetLabel() const noexcept;
 
    const std::string& GetDefaultStrategyLabel() const noexcept;
 
    const std::string& GetCapability() const noexcept;
 
    void SetCapability(const std::string& _capability);
 
    bool IsManipulator() const noexcept;
 
    bool IsFixed() const noexcept;
 
        Cfg GetInitialCfg();
        void SetInitialCfg(Cfg _cfg);
 
 
};
 
/*----------------------------------- Debug ----------------------------------*/
 
std::ostream& operator<<(std::ostream&, const Robot&);
 
/*----------------------------------------------------------------------------*/
 
#endif