gsSolid.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsCore/gsLinearAlgebra.h>
 
#include <gsModeling/gsSolidElement.h>
 
#include <gsModeling/gsSolidHeVertex.h>
#include <gsModeling/gsSolidHalfEdge.h>
#include <gsModeling/gsSolidHalfFace.h>
#include <gsModeling/gsVolumeBlock.h>
#include <gsUtils/gsMesh/gsBoundingBox.h>
 
namespace gismo {
 
template <class T>
class GISMO_EXPORT gsSolid : public gsSolidElement<T>
{
public: 
    typedef memory::shared_ptr<gsSolid> Ptr;
    typedef memory::unique_ptr<gsSolid> uPtr;
 
    typedef gsSolidElement<T> SolidElement;
    typedef typename gsSolidElement<T>::scalar_t scalar_t;    
    typedef typename gsSolidElement<T>::gsSolidHeVertexHandle gsSolidHeVertexHandle;
    typedef typename gsSolidElement<T>::gsSolidHalfEdgeHandle gsSolidHalfEdgeHandle;
    typedef typename gsSolidElement<T>::gsSolidHalfFaceHandle gsSolidHalfFaceHandle;
    typedef typename gsSolidElement<T>::gsVolumeHandle        gsVolumeHandle;
    typedef gsMatrix<T> gsMatrixT;
    
    typedef typename std::vector<gsSolidHalfFaceHandle*>::iterator face_iterator;
    typedef typename std::vector<gsGeometry<T> *>::const_iterator  const_face_iterator;
 
    typedef typename std::vector<gsSolidHalfEdgeHandle*>::iterator       edge_iterator;
    typedef typename std::vector<gsSolidHalfEdgeHandle*>::const_iterator const_edge_iterator;
 
    typedef typename std::vector<gsSolidHeVertexHandle*>::iterator       vertex_iterator;
    typedef typename std::vector<gsSolidHeVertexHandle*>::const_iterator const_vertex_iterator;
 
    typedef typename std::vector<gsVolumeHandle*>::iterator       volume_iterator;
    typedef typename std::vector<gsVolumeHandle*>::const_iterator const_volume_iterator;
 
public:
 
    unsigned numVertices;
    unsigned numHalfEdges;
    unsigned numHalfFaces;
    unsigned numVolumes;
 
    std::vector<gsSolidHeVertexHandle > vertex;
    std::vector<gsSolidHalfEdgeHandle >   edge;
    std::vector<gsSolidHalfFaceHandle >   face;
    std::vector<gsVolumeHandle >        volume;            
    
    bool manifold;
    bool initialized;       
    
protected:
    gsBoundingBox<T> bb;
    bool FaceCCW; // true if vertices of the outer loop of a face are ordered in a CCW fashion when viewing from infinity
 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Constructors
public:
 
    gsSolid(int const & i = 0) : SolidElement(i), initialized(false) 
        {
            numHalfFaces = 0;
            numVertices = 0;
            numVolumes = 0;
            numHalfEdges = 0;             
            manifold = true;
            FaceCCW = true;
        }
 
    virtual ~gsSolid();
 
private:    // disable copying (it can be done but is not implemented)
    gsSolid( const gsSolid& );
    gsSolid& operator=( const gsSolid& );
    
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Accessors= iterators on vertices, faces, edges, boundingbox
public:
    inline int nVolumes()       const { return volume.size();}
 
    inline int nHalfFaces() const { return face.size();}
 
    inline int nVertices()      const { return vertex.size();}
 
    inline size_t nHalfEdges()    const { return edge.size();}
 
    inline bool isFaceCCW()    const { return FaceCCW;}
 
    inline gsSolidHeVertexHandle getVertexFromID(int const & _id) const 
    {return *(vertex.begin()+_id);}
 
    inline gsSolidHalfEdgeHandle getHalfEdgeFromID(int const & _id) const 
    {return *(edge.begin()+_id);}
 
    inline gsSolidHalfFaceHandle getHalfFaceFromID(int const & _id) const 
    {return *(face.begin()+_id);}
 
    gsBoundingBox<T> getBoundingBox() const {return bb;}
    
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Non-constant members
public:
    void addHeVertex(scalar_t const& x, scalar_t const& y, scalar_t const& z=0);
 
    gsSolidHalfFaceHandle addFace(std::vector<gsSolidHeVertexHandle> V);
 
    gsSolidHalfFaceHandle addFace(std::vector<gsSolidHeVertexHandle> V, 
                                  gsTrimSurface<T> * tsurf);
 
    //
    gsSolidHalfFaceHandle addFace(std::vector< std::vector<gsSolidHeVertexHandle> > loopV, 
                                  gsTrimSurface<T> * tsurf);
 
    gsSolidHalfFaceHandle addFace_PlanarPolygon(std::vector<gsSolidHeVertexHandle> V);
 
    gsSolidHalfFaceHandle addFace_4Vertices(gsSolidHeVertexHandle v0,
                                            gsSolidHeVertexHandle v1,
                                            gsSolidHeVertexHandle v2,
                                            gsSolidHeVertexHandle v3)
    {
        std::vector<gsSolidHeVertexHandle> V(4);
        V[0] = v0; V[1] = v1; V[2] = v2; V[3] = v3;
        return addFace(V);
    }
    
    gsSolidHalfFaceHandle splitFace(gsSolidHalfFaceHandle f, 
                                    gsSolidHeVertexHandle startVertex, 
                                    gsSolidHeVertexHandle endVertex, 
                                    gsBSpline<T> *domainSpline);
    
    void addVolume(gsVolumeHandle vol) 
        {
            volume.push_back(vol);
            vol->setId(numVolumes++);
        }
        
    void addVolume(std::vector<gsSolidHalfFaceHandle> hfaces) 
        {
            gsVolumeHandle vol = this->makeVolume(hfaces);
            addVolume(vol);
        }
    
    void setHeMate();    
 
    std::vector<gsSolidHalfEdgeHandle> detectNonConvexEdges(std::vector<int> const & ncEdgeV1, std::vector<int> const & ncEdgeV2);
 
    gsVolumeBlock<T> *newVolume(gsSolidHalfFaceHandle startingFace);
 
    void checkStructure(bool checkVerts = false) const;
 
    gsSolidHalfFace<T> *addFaceWithMate(const std::vector<gsSolidHeVertexHandle> &Verts, gsTrimSurface<T> *surf);
 
    void insertNewVertex(gsSolidHalfEdgeHandle he);
        
    void handleImpedingEdges(gsSolidHalfEdgeHandle he);
 
    //void addPatch(gsPatch<T> *f) { this->addFace(f) ;};
    //void addCurve(gsCurve<T> *f) { this->addEdge(f) ;};      
 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Const members    
public:
    std::vector<gsSolidHalfEdgeHandle> impedingEdges(gsSolidHalfEdgeHandle he) const;
 
    gsMultiPatch<T> plotEdgeGraph();
    
    virtual std::ostream &print(std::ostream &os) const;               
}; 
    
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsSolid.hpp)
#endif