MRMesh/MRContoursCut.h

Go to the documentation of this file.

#pragma once
 
#include "MRVector3.h"
#include "MRAffineXf3.h"
#include "MRId.h"
#include "MRBitSet.h"
#include "MRIntersectionContour.h"
#include "MRExtractIsolines.h"
#include "MRMeshCollidePrecise.h"
#include "MRSurfacePath.h"
#include <variant>
 
namespace MR
{
 
// Special data to sort intersections more accurate
struct SortIntersectionsData
{
    const Mesh& otherMesh;
    const ContinuousContours& contours;
    ConvertToIntVector converter;
    const AffineXf3f* rigidB2A{nullptr};
    size_t meshAVertsNum;
    bool isOtherA{false};
};
 
// Simple point on mesh, represented by primitive id and coordinate in mesh space
struct OneMeshIntersection
{
    enum VariantIndex { Face, Edge, Vertex };
    std::variant<FaceId, EdgeId, VertId> primitiveId;
 
    Vector3f coordinate;
};
 
// One contour on mesh
struct OneMeshContour
{
    std::vector<OneMeshIntersection> intersections;
    bool closed{false};
};
using OneMeshContours = std::vector<OneMeshContour>;
 
// Divides faces that fully own contours into 3 parts with center in center mass of one of the face contours
// if there is more than one contour on face it guarantee to subdivide at least one lone contour on this face
MRMESH_API void subdivideLoneContours( Mesh& mesh, const OneMeshContours& contours, FaceHashMap* new2oldMap = nullptr );
 
// Converts ordered continuous contours of two meshes to OneMeshContours
// converters are required for better precision in case of degenerations
// note that contours should not have intersections
[[nodiscard]]
MRMESH_API OneMeshContours getOneMeshIntersectionContours( const Mesh& meshA, const Mesh& meshB, const ContinuousContours& contours, bool getMeshAIntersections,
    const CoordinateConverters& converters, const AffineXf3f* rigidB2A = nullptr );
 
// Converts ordered continuous self contours of single meshes to OneMeshContours
// converters are required for better precision in case of degenerations
[[nodiscard]]
MRMESH_API OneMeshContours getOneMeshSelfIntersectionContours( const Mesh& mesh, const ContinuousContours& contours,
    const CoordinateConverters& converters, const AffineXf3f* rigidB2A = nullptr );
 
// Converts OneMeshContours contours representation to Contours3f: set of coordinates
[[nodiscard]]
MRMESH_API Contours3f extractMeshContours( const OneMeshContours& meshContours );
 
using MeshTriPointsConnector = std::function<Expected<SurfacePath>( const MeshTriPoint& start, const MeshTriPoint& end, int startIndex, int endIndex )>;
[[nodiscard]]
MR_BIND_IGNORE MRMESH_API Expected<OneMeshContour> convertMeshTriPointsToMeshContour( const Mesh& mesh, const std::vector<MeshTriPoint>& surfaceLine,
    MeshTriPointsConnector connectorFn, std::vector<int>* pivotIndices = nullptr );
 
struct SearchPathSettings
{
    GeodesicPathApprox geodesicPathApprox{ GeodesicPathApprox::DijkstraAStar }; 
    int maxReduceIters{ 100 }; 
};
 
[[nodiscard]]
MRMESH_API Expected<OneMeshContour> convertMeshTriPointsToMeshContour( const Mesh& mesh, const std::vector<MeshTriPoint>& surfaceLine,
    SearchPathSettings searchSettings = {}, std::vector<int>* pivotIndices = nullptr );
 
[[nodiscard]]
MRMESH_API Expected<OneMeshContours> convertMeshTriPointsSurfaceOffsetToMeshContours( const Mesh& mesh, const std::vector<MeshTriPoint>& surfaceLine,
    float offset, SearchPathSettings searchSettings = {} );
 
[[nodiscard]]
MRMESH_API Expected<OneMeshContours> convertMeshTriPointsSurfaceOffsetToMeshContours( const Mesh& mesh, const std::vector<MeshTriPoint>& surfaceLine,
    const std::function<float(int)>& offsetAtPoint, SearchPathSettings searchSettings = {});
 
[[nodiscard]]
MRMESH_API Expected<OneMeshContour> convertMeshTriPointsToClosedContour( const Mesh& mesh, const std::vector<MeshTriPoint>& surfaceLine,
    SearchPathSettings searchSettings = {}, std::vector<int>* pivotIndices = nullptr );
 
[[nodiscard]]
MRMESH_API OneMeshContour convertSurfacePathWithEndsToMeshContour( const Mesh& mesh, 
                                                                          const MeshTriPoint& start, 
                                                                          const SurfacePath& surfacePath, 
                                                                          const MeshTriPoint& end );
 
[[nodiscard]]
MRMESH_API OneMeshContours convertSurfacePathsToMeshContours( const Mesh& mesh, const std::vector<SurfacePath>& surfacePaths );
 
struct NewEdgesMap
{
    UndirectedEdgeBitSet splitEdges;
 
    HashMap<UndirectedEdgeId, int> map;
};
 
struct CutMeshParameters
{
    const SortIntersectionsData* sortData{nullptr};
    FaceMap* new2OldMap{nullptr};
    enum class ForceFill
    {
        None, //< if bad faces occur does not fill anything
        Good, //< fills all faces except bad ones
        All   //< fills all faces with bad ones, but on bad faces triangulation can also be bad (may have self-intersections or tunnels)
    } forceFillMode{ ForceFill::None };
 
    NewEdgesMap* new2oldEdgesMap{ nullptr };
};
 
struct CutMeshResult
{
    std::vector<EdgePath> resultCut;
    FaceBitSet fbsWithCountourIntersections;
};
 
MRMESH_API CutMeshResult cutMesh( Mesh& mesh, const OneMeshContours& contours, const CutMeshParameters& params = {} );
 
 
MRMESH_API Expected<FaceBitSet> cutMeshByContour( Mesh& mesh, const Contour3f& contour, const AffineXf3f& xf = {} );
 
} //namespace MR