Environment.h

Go to the documentation of this file.

#ifndef PMPL_ENVIRONMENT_H_
#define PMPL_ENVIRONMENT_H_
 
#include "ConfigurationSpace/Cfg.h"
#include "Geometry/Boundaries/Boundary.h"
#include "Utilities/MPUtils.h"
 
#include "Transformation.h"
#include "glutils/color.h"
 
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include <unordered_map>
 
class CollisionDetectionMethod;
class MultiBody;
 
class Robot;
class WorkspaceDecomposition;
class XMLNode;
 
 
class Terrain {
 
  public:
 
 
    enum Axis {X, Y, Z};
 
 
 
    Terrain();
 
    Terrain(XMLNode& _node);
 
    Terrain(const Terrain& _terrain);
 
    
    Terrain& operator=(const Terrain& _terrain);
 
 
    const glutils::color& Color() const noexcept;
 
    Boundary* GetBoundary() const noexcept;
 
        const std::vector<std::unique_ptr<Boundary>>& GetBoundaries() const noexcept;
 
    double GetPerimeter();
 
        bool InTerrain(const Point3d _p) const noexcept;
 
 
        bool InTerrain(const Cfg _cfg) const noexcept;
 
    bool IsNeighbor(const Terrain& _terrain);
 
        bool IsVirtual() const noexcept;
 
    bool IsWired() const noexcept;
 
 
  private:
 
    bool IsTouching(Boundary* _bound1, Boundary* _bound2, Axis& _type);
 
    double Overlap(Boundary* _b1, Boundary* _b2);
 
 
    glutils::color m_color{glutils::color::green}; 
    std::unique_ptr<Boundary> m_boundary;          
 
        std::vector<std::unique_ptr<Boundary>> m_boundaries; 
 
        bool m_virtual{false}; 
 
    bool m_wire{true};
 
};
 
 
class Environment {
 
  public:
 
 
    typedef std::unordered_map<std::string, std::vector<Terrain>>
        TerrainMap;
 
 
    Environment();
 
    explicit Environment(XMLNode& _node);
 
    Environment(const Environment& _other); 
    Environment(Environment&& _other);      
 
    virtual ~Environment();
 
 
    Environment& operator=(const Environment& _other); 
    Environment& operator=(Environment&& _other);      
 
 
    const std::string& GetEnvFileName() const noexcept;
 
    void ReadXMLOptions(XMLNode& _node);
 
    void ReadXML(XMLNode& _node);
 
    void Read(std::string _filename);
 
    void Print(std::ostream& _os) const;
 
    void Write(std::ostream& _os);
 
 
    void ComputeResolution(const std::vector<std::unique_ptr<Robot>>& _robots);
 
    double GetPositionRes() const noexcept;
    void SetPositionRes(double _res) noexcept;
 
    double GetOrientationRes() const noexcept;
    void SetOrientationRes(double _res) noexcept;
 
    double GetTimeRes() const noexcept;
 
 
    Boundary* GetBoundary() const noexcept;
 
    void SetBoundary(std::unique_ptr<Boundary>&& _b) noexcept;
 
 
    size_t NumObstacles() const noexcept;
 
    MultiBody* GetObstacle(size_t _index) const;
 
    MultiBody* GetRandomObstacle() const;
 
    size_t AddObstacle(const std::string& _dir, const std::string& _filename,
        const mathtool::Transformation& _t = mathtool::Transformation());
 
    void RemoveObstacle(const size_t _position);
 
    void RemoveObstacle(MultiBody* const _obst);
 
    std::map<mathtool::Vector3d, std::vector<size_t>> ComputeObstacleVertexMap()
        const;
 
    bool UsingBoundaryObstacle() const noexcept;
 
 
    double GetFrictionCoefficient() const noexcept;
 
    const mathtool::Vector3d& GetGravity() const noexcept;
 
 
    const TerrainMap& GetTerrains() const noexcept;
 
 
    const mathtool::Transformation& GetInitialCameraTransformation() const
        noexcept;
 
 
    bool IsolateTerrain(Cfg start, Cfg goal);
 
        bool SameTerrain(Cfg _start, Cfg _goal);
 
    void RestoreBoundary();
 
    void SaveBoundary();
 
    std::unique_ptr<Boundary> m_originalBoundary;
 
  protected:
 
 
    void InitializeBoundary(std::string _type, const std::string _where);
 
    void CreateBoundaryObstacle();
 
 
    std::string m_filename;     
    std::string m_modelDataDir; 
 
 
    double m_positionRes{-1.};       
    double m_orientationRes{.05};    
    double m_timeRes{.05};           
 
 
    std::unique_ptr<Boundary> m_boundary;               
    std::vector<std::unique_ptr<MultiBody>> m_obstacles;
    bool m_boundaryObstacle{false}; 
 
 
    double m_frictionCoefficient{0}; 
    mathtool::Vector3d m_gravity;    
 
 
    TerrainMap m_terrains; 
 
 
    mathtool::Transformation m_initialCameraTransform; 
 
 
};
 
#endif