GMSPolyhedron.h

Go to the documentation of this file.

#ifndef PMPL_GMS_POLYHEDRON_H_
#define PMPL_GMS_POLYHEDRON_H_
 
#include "GMSPolygon.h"
 
#include "Geometry/Boundaries/Range.h"
 
#include "Transformation.h"
#include "Vector.h"
 
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/convex_hull_3.h>
 
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
class IModel;
class PQP_Model;
class RAPID_model;
class WorkspaceBoundingBox;
 
using namespace mathtool;
namespace glutils {
  class triangulated_model;
}
 
 
class GMSPolyhedron final {
 
  public:
 
 
    typedef CGAL::Exact_predicates_exact_constructions_kernel CGALKernel;
    typedef CGALKernel::Point_3                               CGALPoint;
    typedef CGAL::Polyhedron_3<CGALKernel>                    CGALPolyhedron;
 
    enum class COMAdjust {COM, Surface, None};
 
 
    GMSPolyhedron();
 
    GMSPolyhedron(const GMSPolyhedron& _p);
 
    GMSPolyhedron(GMSPolyhedron&& _p);
 
    GMSPolyhedron(glutils::triangulated_model&& _t);
 
    ~GMSPolyhedron();
 
 
    GMSPolyhedron& operator=(const GMSPolyhedron& _p);
    GMSPolyhedron& operator=(GMSPolyhedron&& _p);
 
 
    GMSPolyhedron& operator*=(const Transformation& _t);
 
    void Invert();
 
    void Scale(double _scalingFactor);
 
 
    bool operator==(const GMSPolyhedron& _p) const;
    bool operator!=(const GMSPolyhedron& _p) const;
 
 
    Vector3d Read(const std::string& _fileName, COMAdjust _comAdjust);
 
    Vector3d LoadFromIModel(IModel* _imodel, COMAdjust _comAdjust);
 
    void WriteBYU(std::ostream& _os) const;
 
    void WriteObj(std::ostream& _os) const;
 
 
    std::vector<Vector3d>& GetVertexList() noexcept;
    std::vector<GMSPolygon>& GetPolygonList() noexcept;
 
    const std::vector<Vector3d>& GetVertexList() const noexcept;
    const std::vector<GMSPolygon>& GetPolygonList() const noexcept;
 
    const Vector3d& GetCentroid() const;
 
    double GetSurfaceArea() const noexcept;
 
    double GetMaxRadius() const noexcept;
 
    double GetMinRadius() const noexcept;
 
 
    Point3d GetRandPtOnSurface() const;
 
    std::unique_ptr<WorkspaceBoundingBox> ComputeBoundingBox() const;
 
    GMSPolyhedron ComputeConvexHull() const;
 
    CGALPolyhedron CGAL() const;
 
    void UpdateCGALPoints();
 
 
    RAPID_model* GetRapidModel() const noexcept;
 
    PQP_Model* GetPQPModel() const noexcept;
 
    const Vector3d& GetInsidePoint() const noexcept;
 
 
    static GMSPolyhedron MakeBox(const Range<double>& _x,
        const Range<double>& _y, const Range<double>& _z);
 
 
  private:
 
 
    void ComputeCentroid() const;
 
    void OrderFacets();
 
    void ComputeSurfaceArea();
 
    void ComputeRadii();
 
    void ComputeInsidePoint();
 
 
    std::vector<Vector3d> m_vertexList;    
    std::vector<CGALPoint> m_cgalPoints;   
    std::vector<GMSPolygon> m_polygonList; 
 
    double m_area{0};      
    double m_maxRadius{0}; 
    double m_minRadius{0}; 
 
    Vector3d m_centroid;          
    mutable bool m_centroidCached{false}; 
 
 
    mutable std::unique_ptr<RAPID_model> m_rapidModel;  
    mutable std::unique_ptr<PQP_Model> m_pqpModel;      
 
    Vector3d m_insidePoint; 
 
 
};
 
/*----------------------------- Transformation -------------------------------*/
 
GMSPolyhedron
operator*(const Transformation& _t, const GMSPolyhedron& _poly);
 
/*----------------------------------------------------------------------------*/
 
#endif