MRMesh/MRMesh.h

Go to the documentation of this file.

#pragma once
 
#include "MRMeshBuilderTypes.h"
#include "MRMeshTopology.h"
#include "MRMeshProject.h"
#include "MREdgePoint.h"
#include "MRLineSegm.h"
#include "MRSharedThreadSafeOwner.h"
#include "MRWriter.h"
#include "MRConstants.h"
#include "MRProgressCallback.h"
#include <cfloat>
 
namespace MR
{
 
 
struct [[nodiscard]] Mesh
{
    MeshTopology topology;
    VertCoords points;
 
    [[nodiscard]] MRMESH_API static Mesh fromTriangles(
        VertCoords vertexCoordinates,
        const Triangulation& t, const MeshBuilder::BuildSettings& settings = {}, ProgressCallback cb = {} );
 
    [[nodiscard]] MRMESH_API static Mesh fromTriMesh(
        TriMesh && triMesh, 
        const MeshBuilder::BuildSettings& settings = {}, ProgressCallback cb = {} );
 
    [[nodiscard]] MRMESH_API static Mesh fromTrianglesDuplicatingNonManifoldVertices(
        VertCoords vertexCoordinates,
        Triangulation & t,
        std::vector<MeshBuilder::VertDuplication> * dups = nullptr,
        const MeshBuilder::BuildSettings & settings = {} );
 
    [[nodiscard]] MRMESH_API static Mesh fromFaceSoup(
        VertCoords vertexCoordinates,
        const std::vector<VertId> & verts, const Vector<MeshBuilder::VertSpan, FaceId> & faces,
        const MeshBuilder::BuildSettings& settings = {}, ProgressCallback cb = {} );
 
    [[nodiscard]] MRMESH_API static Mesh fromPointTriples( const std::vector<Triangle3f> & posTriples, bool duplicateNonManifoldVertices );
 
    [[nodiscard]] MRMESH_API bool operator ==( const Mesh & b ) const;
 
    [[nodiscard]] Vector3f orgPnt( EdgeId e ) const { return points[ topology.org( e ) ]; }
 
    [[nodiscard]] Vector3f destPnt( EdgeId e ) const { return points[ topology.dest( e ) ]; }
 
    [[nodiscard]] Vector3f edgeVector( EdgeId e ) const { return destPnt( e ) - orgPnt( e ); }
 
    [[nodiscard]] LineSegm3f edgeSegment( EdgeId e ) const { return { orgPnt( e ), destPnt( e ) }; }
 
    [[nodiscard]] Vector3f edgePoint( EdgeId e, float f ) const { return f * destPnt( e ) + ( 1 - f ) * orgPnt( e ); }
 
    [[nodiscard]] Vector3f edgePoint( const MeshEdgePoint & ep ) const { return edgePoint( ep.e, ep.a ); }
 
    [[nodiscard]] Vector3f edgeCenter( UndirectedEdgeId e ) const { return edgePoint( e, 0.5f ); }
 
    MRMESH_API void getLeftTriPoints( EdgeId e, Vector3f & v0, Vector3f & v1, Vector3f & v2 ) const;
 
    void getLeftTriPoints( EdgeId e, Vector3f (&v)[3] ) const { getLeftTriPoints( e, v[0], v[1], v[2] ); }
 
    [[nodiscard]] Triangle3f getLeftTriPoints( EdgeId e ) const { Triangle3f res; getLeftTriPoints( e, res[0], res[1], res[2] ); return res; }
 
    void getTriPoints( FaceId f, Vector3f & v0, Vector3f & v1, Vector3f & v2 ) const { getLeftTriPoints( topology.edgeWithLeft( f ), v0, v1, v2 ); }
 
    void getTriPoints( FaceId f, Vector3f (&v)[3] ) const { getTriPoints( f, v[0], v[1], v[2] ); }
 
    [[nodiscard]] Triangle3f getTriPoints( FaceId f ) const { Triangle3f res; getTriPoints( f, res[0], res[1], res[2] ); return res; }
 
    [[nodiscard]] MRMESH_API Vector3f triPoint( const MeshTriPoint & p ) const;
 
    [[nodiscard]] MRMESH_API Vector3f triCenter( FaceId f ) const;
 
    [[nodiscard]] MRMESH_API float triangleAspectRatio( FaceId f ) const;
    
    [[nodiscard]] MRMESH_API float circumcircleDiameterSq( FaceId f ) const;
 
    [[nodiscard]] MRMESH_API float circumcircleDiameter( FaceId f ) const;
 
    [[nodiscard]] MRMESH_API MeshTriPoint toTriPoint( VertId v ) const;
 
    [[nodiscard]] MRMESH_API MeshTriPoint toTriPoint( FaceId f, const Vector3f & p ) const;
 
    [[nodiscard]] MRMESH_API MeshTriPoint toTriPoint( const PointOnFace& p ) const;
 
    [[nodiscard]] MRMESH_API MeshEdgePoint toEdgePoint( VertId v ) const;
 
    [[nodiscard]] MRMESH_API MeshEdgePoint toEdgePoint( EdgeId e, const Vector3f & p ) const;
 
    [[nodiscard]] MRMESH_API VertId getClosestVertex( const PointOnFace & p ) const;
 
    [[nodiscard]] VertId getClosestVertex( const MeshTriPoint & p ) const { return getClosestVertex( PointOnFace{ topology.left( p.e ), triPoint( p ) } ); }
 
    [[nodiscard]] MRMESH_API UndirectedEdgeId getClosestEdge( const PointOnFace & p ) const;
 
    [[nodiscard]] UndirectedEdgeId getClosestEdge( const MeshTriPoint & p ) const { return getClosestEdge( PointOnFace{ topology.left( p.e ), triPoint( p ) } ); }
 
    [[nodiscard]] float edgeLength( UndirectedEdgeId e ) const { return edgeVector( e ).length(); }
 
    [[nodiscard]] float edgeLengthSq( UndirectedEdgeId e ) const { return edgeVector( e ).lengthSq(); }
 
    [[nodiscard]] MRMESH_API Vector3f leftDirDblArea( EdgeId e ) const;
 
    [[nodiscard]] Vector3f dirDblArea( FaceId f ) const { return leftDirDblArea( topology.edgeWithLeft( f ) ); }
 
    [[nodiscard]] float dblArea( FaceId f ) const { return dirDblArea( f ).length(); }
 
    [[nodiscard]] float area( FaceId f ) const { return 0.5f * dblArea( f ); }
 
    [[nodiscard]] MRMESH_API double area( const FaceBitSet & fs ) const;
 
    [[nodiscard]] double area( const FaceBitSet * fs = nullptr ) const { return area( topology.getFaceIds( fs ) ); }
 
    [[nodiscard]] MRMESH_API Vector3d dirArea( const FaceBitSet & fs ) const;
 
    [[nodiscard]] Vector3d dirArea( const FaceBitSet * fs = nullptr ) const { return dirArea( topology.getFaceIds( fs ) ); }
 
    [[nodiscard]] MRMESH_API double projArea( const Vector3f & dir, const FaceBitSet & fs ) const;
 
    [[nodiscard]] double projArea( const Vector3f & dir, const FaceBitSet * fs = nullptr ) const { return projArea( dir, topology.getFaceIds( fs ) ); }
 
    [[nodiscard]] MRMESH_API double volume( const FaceBitSet* region = nullptr ) const;
 
    [[nodiscard]] MRMESH_API double holePerimiter( EdgeId e ) const;
 
    [[nodiscard]] MRMESH_API Vector3d holeDirArea( EdgeId e ) const;
 
    [[nodiscard]] MRMESH_API Vector3f leftTangent( EdgeId e ) const;
 
    [[nodiscard]] Vector3f leftNormal( EdgeId e ) const { return leftDirDblArea( e ).normalized(); }
 
    [[nodiscard]] Vector3f normal( FaceId f ) const { return dirDblArea( f ).normalized(); }
 
    [[nodiscard]] MRMESH_API Vector3f dirDblArea( VertId v ) const;
 
    [[nodiscard]] float dblArea( VertId v ) const { return dirDblArea( v ).length(); }
 
    [[nodiscard]] Vector3f normal( VertId v ) const { return dirDblArea( v ).normalized(); }
 
    [[nodiscard]] MRMESH_API Vector3f normal( const MeshTriPoint & p ) const;
 
    [[nodiscard]] MRMESH_API Vector3f pseudonormal( VertId v, const FaceBitSet * region = nullptr ) const;
 
    [[nodiscard]] MRMESH_API Vector3f pseudonormal( UndirectedEdgeId e, const FaceBitSet * region = nullptr ) const;
 
    [[nodiscard]] MRMESH_API Vector3f pseudonormal( const MeshTriPoint & p, const FaceBitSet * region = nullptr ) const;
 
    [[nodiscard]] MRMESH_API float signedDistance( const Vector3f & pt, const MeshProjectionResult & proj, const FaceBitSet * region = nullptr ) const;
    [[deprecated]] MRMESH_API float signedDistance( const Vector3f & pt, const MeshTriPoint & proj, const FaceBitSet * region = nullptr ) const;
 
    [[nodiscard]] MRMESH_API float signedDistance( const Vector3f & pt ) const;
 
    [[nodiscard]] MRMESH_API std::optional<float> signedDistance( const Vector3f & pt, float maxDistSq, const FaceBitSet * region = nullptr ) const;
 
    [[nodiscard]] MRMESH_API float calcFastWindingNumber( const Vector3f & pt, float beta = 2 ) const;
 
    [[nodiscard]] bool isOutside( const Vector3f & pt, float windingNumberThreshold = 0.5f, float beta = 2 ) const { return calcFastWindingNumber( pt, beta ) <= windingNumberThreshold; }
 
    [[nodiscard]] MRMESH_API bool isOutsideByProjNorm( const Vector3f & pt, const MeshProjectionResult & proj, const FaceBitSet * region = nullptr ) const;
 
    [[nodiscard]] MRMESH_API float sumAngles( VertId v, bool * outBoundaryVert = nullptr ) const;
 
    [[nodiscard]] MRMESH_API Expected<VertBitSet> findSpikeVertices( float minSumAngle, const VertBitSet* region = nullptr, ProgressCallback cb = {} ) const;
 
    [[nodiscard]] MRMESH_API float dihedralAngleSin( UndirectedEdgeId e ) const;
 
    [[nodiscard]] MRMESH_API float dihedralAngleCos( UndirectedEdgeId e ) const;
 
    [[nodiscard]] MRMESH_API float dihedralAngle( UndirectedEdgeId e ) const;
 
    [[nodiscard]] MRMESH_API float discreteMeanCurvature( VertId v ) const;
 
    [[nodiscard]] MRMESH_API float discreteMeanCurvature( UndirectedEdgeId e ) const;
 
    [[nodiscard]] float discreteGaussianCurvature( VertId v, bool * outBoundaryVert = nullptr ) const { return 2 * PI_F - sumAngles( v, outBoundaryVert ); }
 
    [[nodiscard]] MRMESH_API UndirectedEdgeBitSet findCreaseEdges( float angleFromPlanar ) const;
 
    [[nodiscard]] MRMESH_API float leftCotan( EdgeId e ) const;
 
    [[nodiscard]] float cotan( UndirectedEdgeId ue ) const { EdgeId e{ ue }; return leftCotan( e ) + leftCotan( e.sym() ); }
 
    [[nodiscard]] MRMESH_API QuadraticForm3f quadraticForm( VertId v, bool angleWeigted,
        const FaceBitSet * region = nullptr, const UndirectedEdgeBitSet * creases = nullptr ) const;
 
    [[nodiscard]] MRMESH_API Box3f computeBoundingBox( const AffineXf3f * toWorld = nullptr ) const;
 
    [[nodiscard]] MRMESH_API Box3f getBoundingBox() const;
 
    [[nodiscard]] MRMESH_API Box3f computeBoundingBox( const FaceBitSet* region, const AffineXf3f* toWorld = nullptr ) const;
 
    [[nodiscard]] MRMESH_API float averageEdgeLength() const;
 
    [[nodiscard]] MRMESH_API Vector3f findCenterFromPoints() const;
 
    [[nodiscard]] MRMESH_API Vector3f findCenterFromFaces() const;
 
    [[nodiscard]] MRMESH_API Vector3f findCenterFromBBox() const;
 
    MRMESH_API void zeroUnusedPoints();
 
    MRMESH_API void transform( const AffineXf3f& xf, const VertBitSet* region = nullptr );
 
    MRMESH_API VertId addPoint( const Vector3f & pos );
 
    MRMESH_API EdgeId addSeparateEdgeLoop(const std::vector<Vector3f>& contourPoints);
 
    MRMESH_API EdgeId addSeparateContours( const Contours3f& contours, const AffineXf3f* xf = nullptr );
 
    MRMESH_API void attachEdgeLoopPart( EdgeId first, EdgeId last, const std::vector<Vector3f>& contourPoints );
 
    MRMESH_API EdgeId splitEdge( EdgeId e, const Vector3f & newVertPos, FaceBitSet * region = nullptr, FaceHashMap * new2Old = nullptr );
    // same, but split given edge on two equal parts
    EdgeId splitEdge( EdgeId e, FaceBitSet * region = nullptr, FaceHashMap * new2Old = nullptr ) { return splitEdge( e, edgeCenter( e ), region, new2Old ); }
 
    MRMESH_API VertId splitFace( FaceId f, const Vector3f & newVertPos, FaceBitSet * region = nullptr, FaceHashMap * new2Old = nullptr );
    // same, putting new vertex in the centroid of original triangle
    VertId splitFace( FaceId f, FaceBitSet * region = nullptr, FaceHashMap * new2Old = nullptr ) { return splitFace( f, triCenter( f ), region, new2Old ); }
 
    MRMESH_API void addMesh( const Mesh & from,
        // optionally returns mappings: from.id -> this.id
        FaceMap * outFmap = nullptr, VertMap * outVmap = nullptr, WholeEdgeMap * outEmap = nullptr, bool rearrangeTriangles = false );
    [[deprecated]] void addPart( const Mesh & from, FaceMap * outFmap = nullptr, VertMap * outVmap = nullptr, WholeEdgeMap * outEmap = nullptr, bool rearrangeTriangles = false )
        { addMesh( from, outFmap, outVmap, outEmap, rearrangeTriangles ); }
 
    MRMESH_API void addMeshPart( const MeshPart & from, const PartMapping & map );
    [[deprecated]] void addPartByMask( const Mesh & from, const FaceBitSet & fromFaces, const PartMapping & map ) { addMeshPart( { from, &fromFaces }, map ); }
 
    MRMESH_API void addMeshPart( const MeshPart & from, bool flipOrientation = false,
        const std::vector<EdgePath> & thisContours = {}, // contours on this mesh that have to be stitched with
        const std::vector<EdgePath> & fromContours = {}, // contours on from mesh during addition
        // optionally returns mappings: from.id -> this.id
        const PartMapping & map = {} );
    [[deprecated]] void addPartByMask( const Mesh & from, const FaceBitSet & fromFaces, bool flipOrientation = false,
        const std::vector<EdgePath> & thisContours = {}, const std::vector<EdgePath> & fromContours = {}, const PartMapping & map = {} )
        { addMeshPart( { from, &fromFaces }, flipOrientation, thisContours, fromContours, map ); }
 
    MRMESH_API void addPartByFaceMap( const Mesh & from, const FaceMap & fromFaces, bool flipOrientation = false,
        const std::vector<EdgePath> & thisContours = {}, // contours on this mesh that have to be stitched with
        const std::vector<EdgePath> & fromContours = {}, // contours on from mesh during addition
        // optionally returns mappings: from.id -> this.id
        const PartMapping & map = {} );
 
    template<typename I>
    MRMESH_API void addPartBy( const Mesh & from, I fbegin, I fend, size_t fcount, bool flipOrientation = false,
        const std::vector<EdgePath> & thisContours = {},
        const std::vector<EdgePath> & fromContours = {},
        PartMapping map = {} );
 
    MRMESH_API Mesh cloneRegion( const FaceBitSet & region, bool flipOrientation = false, const PartMapping & map = {} ) const;
 
    MRMESH_API void pack( FaceMap * outFmap = nullptr, VertMap * outVmap = nullptr, WholeEdgeMap * outEmap = nullptr, bool rearrangeTriangles = false );
 
    MRMESH_API PackMapping packOptimally( bool preserveAABBTree = true );
    MRMESH_API Expected<PackMapping> packOptimally( bool preserveAABBTree, ProgressCallback cb );
 
    MRMESH_API void deleteFaces( const FaceBitSet & fs, const UndirectedEdgeBitSet * keepEdges = nullptr );
 
    [[nodiscard]] MRMESH_API bool projectPoint( const Vector3f& point, PointOnFace& res, float maxDistSq = FLT_MAX, const FaceBitSet* region = nullptr, const AffineXf3f * xf = nullptr ) const;
 
    [[nodiscard]] MRMESH_API bool projectPoint( const Vector3f& point, MeshProjectionResult& res, float maxDistSq = FLT_MAX, const FaceBitSet* region = nullptr, const AffineXf3f * xf = nullptr ) const;
    [[nodiscard]] bool findClosestPoint( const Vector3f& point, MeshProjectionResult& res, float maxDistSq = FLT_MAX, const FaceBitSet* region = nullptr, const AffineXf3f * xf = nullptr ) const { return projectPoint( point, res, maxDistSq, region, xf ); }
 
    [[nodiscard]] MRMESH_API std::optional<MeshProjectionResult> projectPoint( const Vector3f& point, float maxDistSq = FLT_MAX, const FaceBitSet * region = nullptr, const AffineXf3f * xf = nullptr ) const;
    [[nodiscard]] std::optional<MeshProjectionResult> findClosestPoint( const Vector3f& point, float maxDistSq = FLT_MAX, const FaceBitSet * region = nullptr, const AffineXf3f * xf = nullptr ) const { return projectPoint( point, maxDistSq, region, xf ); }
 
    MRMESH_API const AABBTree & getAABBTree() const;
 
    [[nodiscard]] const AABBTree * getAABBTreeNotCreate() const { return AABBTreeOwner_.get(); }
 
    MRMESH_API const AABBTreePoints & getAABBTreePoints() const;
 
    [[nodiscard]] const AABBTreePoints * getAABBTreePointsNotCreate() const { return AABBTreePointsOwner_.get(); }
 
    MRMESH_API const Dipoles & getDipoles() const;
 
    [[nodiscard]] const Dipoles * getDipolesNotCreate() const { return dipolesOwner_.get(); }
 
    MRMESH_API void invalidateCaches( bool pointsChanged = true );
 
    MRMESH_API void updateCaches( const VertBitSet & changedVerts );
 
    // returns the amount of memory this object occupies on heap
    [[nodiscard]] MRMESH_API size_t heapBytes() const;
 
    MRMESH_API void shrinkToFit();
 
    MRMESH_API void mirror( const Plane3f& plane );
 
private:
    mutable SharedThreadSafeOwner<AABBTree> AABBTreeOwner_;
    mutable SharedThreadSafeOwner<AABBTreePoints> AABBTreePointsOwner_;
    mutable SharedThreadSafeOwner<Dipoles> dipolesOwner_;
};
 
} //namespace MR