gsTriMeshToSolid.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsUtils/gsMesh/gsMesh.h>
 
namespace gismo
{
 
template<class T>
class gsTriMeshToSolid
{
public:
    // typedefs
    typedef gsMeshElement<T> MeshElement;
    typedef typename MeshElement::scalar_t scalar_t;
    typedef typename MeshElement::gsVertexHandle VertexHandle;
    typedef typename MeshElement::gsFaceHandle FaceHandle;
    typedef typename MeshElement::gsEdgeHandle EdgeHandle;
    typedef gsEdge<T>                         Edge;
    typedef gsVertex<T>                       Vertex;
 
    // constructors
    gsTriMeshToSolid(gsMesh<T> *sourceMesh):
        mesh(sourceMesh),
        vertex(sourceMesh->m_vertex),
        face(sourceMesh->m_face),
        edge(sourceMesh->m_edge)
    {}
 
    // public functions
 
    void getPatchData(T angle, T innerAngle, T patchAreaWeight, T mergeSmallPatches,
                      std::vector<std::vector<VertexHandle> > & iPoints,
                      std::vector<std::vector<VertexHandle> > & oPoints,
                      std::vector< std::vector<std::vector<VertexHandle> > > & innerBdrys,
                      std::vector< std::vector<Vertex>  > & innerBdrysMassP,
                      std::vector<std::vector<bool> > & oPointsConvexFlag,
                      std::string filenameFeatures,
                      int useFeatures);
 
 
    void getFeatures(T angleGrad,bool& bWarnNonManifold,bool& bWarnBorders);
 
    void calcPatchNumbers();
 
    void setSharpEdges(std::vector< gsEdge<T> > & featEdges, int useFeatures);
 
 
    void storeNeighboringFaces();
 
    void divideAndMergePatches(T innerAngle, T patchAreaWeight, T mergeSmallPatches);
 
    void getFaces(std::vector<std::vector<VertexHandle> > & iPoints, std::vector<std::vector<VertexHandle> > & oPoints,
                  std::vector< std::vector<std::vector<VertexHandle> > > & innerBdrys, std::vector< std::vector<Vertex>  > & innerBdrysMassP,
                  std::vector<std::vector<bool> > & oPointsConvexFlag);
 
 
    void toSolid(gsSolid<T> & sl, std::vector<std::vector<VertexHandle> > & iPoints,
                 std::vector<std::vector<VertexHandle> > & oPoints,
                 std::vector< std::vector<std::vector<VertexHandle> > > & innerBdrys,
                 std::vector< std::vector<Vertex>  > & innerBdrysMassP,
                 std::vector<std::vector<bool> > & oPointsConvexFlag, std::vector<gsMesh<T> *> &paraMeshes,
                 std::vector<gsMesh<T> *> &fitMeshes, std::vector<gsMesh<T> *> &patchMeshes, int kvOuterPoints,
                 int kvAdditionalInnerPoints,
                 bool plot, int meshPoints, bool moreInner=true,
                 T wE=5, T wI=1, int closeBoundary=0, bool noSmooth=false);
 
    gsCurveLoop<T> * calculateLoop(std::vector<Vertex> outerPoints, std::vector<bool > const & isCorner, bool noSmooth = false);
 
 
    static int normalMult(gsVector3d<T> globalNormal,
                          std::vector<FaceHandle> & face, int bigFaceIdx);
 
    static T calcArea(FaceHandle f1);
 
    static T calcWeight(VertexHandle v1,VertexHandle v2,
                        std::set<VertexHandle>
                        const & vertexFaceSet);
 
    static bool approxEqual(const gsEdge<T> & e1,const gsEdge<T> & e2);
 
 
    static T calcAngle(EdgeHandle e1,EdgeHandle e2, int faceNum);
 
 
    static T calcBdryLength(std::vector<VertexHandle > vec);
 
 
    static gsVertex<T> getMassP(std::vector<VertexHandle > vec);
 
 
    static T calcDist(VertexHandle v1,VertexHandle v2);
 
 
    // Documentation guessed by S.K.
    static std::vector<bool> isCorner(std::vector<VertexHandle > const & vertexVec3d);
 
 
    gsBSpline<T> * calcTCurve(Vertex v1,Vertex v2);
 
 
    gsBSpline<T> * calcTCurve(Vertex v1,Vertex v2,Vertex v3);
 
 
    static Vertex giveMidpoint(Vertex v1,Vertex v2);
 
 
    void readEdges( std::string const & fn, std::vector<gsEdge <T> > & edges );
 
 
    // public members
    gsMesh<> *mesh;
 
    int numEdges;
    int numBigFaces;
    std::vector<VertexHandle > &vertex;
    std::vector<FaceHandle > &face;
    gsSortedVector<Edge> &edge;
};
 
}
 
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsTriMeshToSolid.hpp)
#endif