documentation/Cpp/MRMeshFwd_8h_source.html

#pragma once


#include "config.h"


#include "MRMesh/MRCanonicalTypedefs.h"

#include "MRPch/MRBindingMacros.h"


#if defined _MSC_VER

    #if !defined _ITERATOR_DEBUG_LEVEL

        #define _ITERATOR_DEBUG_LEVEL 0

    #endif

    #if !defined MR_ITERATOR_DEBUG_LEVEL

        #define MR_ITERATOR_DEBUG_LEVEL 0

    #endif

    #if _ITERATOR_DEBUG_LEVEL != MR_ITERATOR_DEBUG_LEVEL

        #error _ITERATOR_DEBUG_LEVEL is inconsistent with MeshLib

    #endif

#endif


#ifdef _MSC_VER

#define MR_CPP_STANDARD_DATE _MSVC_LANG

#else

#define MR_CPP_STANDARD_DATE __cplusplus

#endif

#if MR_CPP_STANDARD_DATE < 201709 && !defined(__CUDACC__)

#error Must enable C++20 or newer!

#endif


#if defined(__GNUC__) && (__GNUC__ >= 13 && __GNUC__ <= 15)

  #pragma GCC diagnostic push

  #pragma GCC diagnostic ignored "-Warray-bounds"

  #pragma GCC diagnostic ignored "-Wstringop-overflow"

#endif


#include <array>


#if defined(__GNUC__) && (__GNUC__ >= 13 && __GNUC__ <= 15)

  #pragma GCC diagnostic pop

#endif


#include <vector>

#include <string>

#include <parallel_hashmap/phmap_fwd_decl.h>

#include <functional>


#ifdef _WIN32

#   ifdef MRMesh_EXPORTS

#       define MRMESH_API __declspec(dllexport)

#   else

#       define MRMESH_API __declspec(dllimport)

#   endif

#   define MRMESH_CLASS

#else

#   define MRMESH_API   __attribute__((visibility("default")))

#   ifdef __clang__

#       define MRMESH_CLASS __attribute__((type_visibility("default")))

#   else

#       define MRMESH_CLASS __attribute__((visibility("default")))

#   endif

#endif


namespace MR

{


struct NoInit {};

inline constexpr NoInit noInit;

template <typename T> struct MRMESH_CLASS NoDefInit;


class MRMESH_CLASS EdgeTag;

class MRMESH_CLASS UndirectedEdgeTag;

class MRMESH_CLASS FaceTag;

class MRMESH_CLASS VertTag;

class MRMESH_CLASS PixelTag;

class MRMESH_CLASS VoxelTag;

class MRMESH_CLASS RegionTag;

class MRMESH_CLASS NodeTag;

class MRMESH_CLASS ObjTag;

class MRMESH_CLASS TextureTag;

class MRMESH_CLASS GraphVertTag;

class MRMESH_CLASS GraphEdgeTag;

class MRMESH_CLASS LocaleDomainTag;


MR_CANONICAL_TYPEDEFS( (template <typename T> class MRMESH_CLASS), Id,

    ( EdgeId,           Id<EdgeTag>           )

    ( UndirectedEdgeId, Id<UndirectedEdgeTag> )

    ( FaceId,           Id<FaceTag>           )

    ( VertId,           Id<VertTag>           )

    ( PixelId,          Id<PixelTag>          )

    ( VoxelId,          Id<VoxelTag>          )

    ( RegionId,         Id<RegionTag>         )

    ( NodeId,           Id<NodeTag>           )

    ( ObjId,            Id<ObjTag>            )

    ( TextureId,        Id<TextureTag>        )

    ( GraphVertId,      Id<GraphVertTag>      )

    ( GraphEdgeId,      Id<GraphEdgeTag>      )

    ( LocaleDomainId,   Id<LocaleDomainTag>   )

)

template <> class MR_BIND_PREFERRED_NAME(MR::EdgeId) Id<EdgeTag>;

template <> class MR_BIND_PREFERRED_NAME(MR::VoxelId) Id<VoxelTag>;


MR_CANONICAL_TYPEDEFS( (template <typename T> class MRMESH_CLASS), NoInitId,

    ( NoInitNodeId, NoInitId<NodeTag> )

)


template <typename T, typename I = size_t> class MRMESH_CLASS Buffer;

struct PackMapping;


class ViewportId;

class ViewportMask;


struct UnorientedTriangle;

struct SomeLocalTriangulations;

struct AllLocalTriangulations;


using EdgePath = std::vector<EdgeId>;

using EdgeLoop = std::vector<EdgeId>;

using EdgeLoops = std::vector<EdgeLoop>;


class MRMESH_CLASS BitSet;


MR_CANONICAL_TYPEDEFS( (template <typename I> class MRMESH_CLASS), TypedBitSet,

    ( FaceBitSet,           TypedBitSet<FaceId>           )

    ( VertBitSet,           TypedBitSet<VertId>           )

    ( EdgeBitSet,           TypedBitSet<EdgeId>           )

    ( UndirectedEdgeBitSet, TypedBitSet<UndirectedEdgeId> )

    ( PixelBitSet,          TypedBitSet<PixelId>          )

    ( VoxelBitSet,          TypedBitSet<VoxelId>          )

    ( RegionBitSet,         TypedBitSet<RegionId>         )

    ( NodeBitSet,           TypedBitSet<NodeId>           )

    ( ObjBitSet,            TypedBitSet<ObjId>            )

    ( TextureBitSet,        TypedBitSet<TextureId>        )

    ( GraphVertBitSet,      TypedBitSet<GraphVertId>      )

    ( GraphEdgeBitSet,      TypedBitSet<GraphEdgeId>      )

)


template<typename T>

using TaggedBitSet = TypedBitSet<Id<T>>;


MR_CANONICAL_TYPEDEFS( (template <typename T> class MRMESH_CLASS), SetBitIteratorT,

    ( SetBitIterator,               SetBitIteratorT<BitSet>               )

    ( FaceSetBitIterator,           SetBitIteratorT<FaceBitSet>           )

    ( VertSetBitIterator,           SetBitIteratorT<VertBitSet>           )

    ( EdgeSetBitIterator,           SetBitIteratorT<EdgeBitSet>           )

    ( UndirectedEdgeSetBitIterator, SetBitIteratorT<UndirectedEdgeBitSet> )

)


struct Color;


#ifdef __APPLE__

using Int64 = std::ptrdiff_t;

using Uint64 = std::size_t;

static_assert(sizeof(Int64) == 8);

static_assert(sizeof(Uint64) == 8);

#else

using Int64 = std::int64_t;

using Uint64 = std::uint64_t;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), MRMESH_CLASS Vector2,

    ( Vector2b,   Vector2<bool>   )

    ( Vector2i,   Vector2<int>    )

    ( Vector2i64, Vector2<Int64>  )

    ( Vector2f,   Vector2<float>  )

    ( Vector2d,   Vector2<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using Vector2ll [[deprecated("Use `Vector2i64` instead.")]] = Vector2<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), MRMESH_CLASS Vector3,

    ( Vector3b,   Vector3<bool>   )

    ( Vector3i,   Vector3<int>    )

    ( Vector3i64, Vector3<Int64>  )

    ( Vector3f,   Vector3<float>  )

    ( Vector3d,   Vector3<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using Vector3ll [[deprecated("Use `Vector3i64` instead.")]] = Vector3<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), Vector4,

    ( Vector4b,   Vector4<bool>   )

    ( Vector4i,   Vector4<int>    )

    ( Vector4i64, Vector4<Int64>  )

    ( Vector4f,   Vector4<float>  )

    ( Vector4d,   Vector4<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using Vector4ll [[deprecated("Use `Vector4i64` instead.")]] = Vector4<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), Matrix2,

    ( Matrix2b,   Matrix2<bool>   )

    ( Matrix2i,   Matrix2<int>    )

    ( Matrix2i64, Matrix2<Int64>  )

    ( Matrix2f,   Matrix2<float>  )

    ( Matrix2d,   Matrix2<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using Matrix2ll [[deprecated("Use `Matrix2i64` instead.")]] = Matrix2<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), Matrix3,

    ( Matrix3b,   Matrix3<bool>   )

    ( Matrix3i,   Matrix3<int>    )

    ( Matrix3i64, Matrix3<Int64>  )

    ( Matrix3f,   Matrix3<float>  )

    ( Matrix3d,   Matrix3<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using Matrix3ll [[deprecated("Use `Matrix3i64` instead.")]] = Matrix3<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), Matrix4,

    ( Matrix4b,   Matrix4<bool>   )

    ( Matrix4i,   Matrix4<int>    )

    ( Matrix4i64, Matrix4<Int64>  )

    ( Matrix4f,   Matrix4<float>  )

    ( Matrix4d,   Matrix4<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using Matrix4ll [[deprecated("Use `Matrix4i64` instead.")]] = Matrix4<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), SymMatrix2,

    ( SymMatrix2b,   SymMatrix2<bool>   )

    ( SymMatrix2i,   SymMatrix2<int>    )

    ( SymMatrix2i64, SymMatrix2<Int64>  )

    ( SymMatrix2f,   SymMatrix2<float>  )

    ( SymMatrix2d,   SymMatrix2<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using SymMatrix2ll [[deprecated("Use `SymMatrix2i64` instead.")]] = SymMatrix2<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), SymMatrix3,

    ( SymMatrix3b,   SymMatrix3<bool>   )

    ( SymMatrix3i,   SymMatrix3<int>    )

    ( SymMatrix3i64, SymMatrix3<Int64>  )

    ( SymMatrix3f,   SymMatrix3<float>  )

    ( SymMatrix3d,   SymMatrix3<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using SymMatrix3ll [[deprecated("Use `SymMatrix3i64` instead.")]] = SymMatrix3<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), SymMatrix4,

    ( SymMatrix4b,   SymMatrix4<bool>   )

    ( SymMatrix4i,   SymMatrix4<int>    )

    ( SymMatrix4i64, SymMatrix4<Int64>  )

    ( SymMatrix4f,   SymMatrix4<float>  )

    ( SymMatrix4d,   SymMatrix4<double> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using SymMatrix4ll [[deprecated("Use `SymMatrix4i64` instead.")]] = SymMatrix4<long long>;

#endif


MR_CANONICAL_TYPEDEFS( (template <typename V> struct), AffineXf,

    ( AffineXf2f, AffineXf<Vector2<float>>  )

    ( AffineXf2d, AffineXf<Vector2<double>> )

    ( AffineXf3f, AffineXf<Vector3<float>>  )

    ( AffineXf3d, AffineXf<Vector3<double>> )

)

template <typename T> using AffineXf2 = AffineXf<Vector2<T>>;

template <typename T> using AffineXf3 = AffineXf<Vector3<T>>;


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), RigidXf3,

    ( RigidXf3f, RigidXf3<float>  )

    ( RigidXf3d, RigidXf3<double> )

)


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), RigidScaleXf3,

    ( RigidScaleXf3f, RigidScaleXf3<float>  )

    ( RigidScaleXf3d, RigidScaleXf3<double> )

)


class PointToPointAligningTransform;

class PointToPlaneAligningTransform;


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), Sphere,

    ( Sphere2f, Sphere<Vector2<float>>  )

    ( Sphere2d, Sphere<Vector2<double>> )

    ( Sphere3f, Sphere<Vector3<float>>  )

    ( Sphere3d, Sphere<Vector3<double>> )

)

template <typename T> using Sphere2 = Sphere<Vector2<T>>;

template <typename T> using Sphere3 = Sphere<Vector3<T>>;


MR_CANONICAL_TYPEDEFS( (template <typename V> struct), Line,

    ( Line2f, Line<Vector2<float>>  )

    ( Line2d, Line<Vector2<double>> )

    ( Line3f, Line<Vector3<float>>  )

    ( Line3d, Line<Vector3<double>> )

)

template <typename T> using Line2 = Line<Vector2<T>>;

template <typename T> using Line3 = Line<Vector3<T>>;


MR_CANONICAL_TYPEDEFS( (template <typename V> struct), LineSegm,

    ( LineSegm2f, LineSegm<Vector2<float>>  )

    ( LineSegm2d, LineSegm<Vector2<double>> )

    ( LineSegm3f, LineSegm<Vector3<float>>  )

    ( LineSegm3d, LineSegm<Vector3<double>> )

)

template <typename T> using LineSegm2 = LineSegm<Vector2<T>>;

template <typename T> using LineSegm3 = LineSegm<Vector3<T>>;


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), Parabola,

    ( Parabolaf, Parabola<float>  )

    ( Parabolad, Parabola<double> )

)


MR_CANONICAL_TYPEDEFS( (template <typename T> class), BestFitParabola,

    ( BestFitParabolaf, BestFitParabola<float>  )

    ( BestFitParabolad, BestFitParabola<double> )

)


MR_CANONICAL_TYPEDEFS( (template <typename T> class), Cylinder3,

    ( Cylinder3f, Cylinder3<float>  )

    ( Cylinder3d, Cylinder3<double> )

)


MR_CANONICAL_TYPEDEFS( (template <typename T> class), Cone3,

    ( Cone3f, Cone3<float>  )

    ( Cone3d, Cone3<double> )

)


template <typename V> using Contour = std::vector<V>;

template <typename T> using Contour2 = Contour<Vector2<T>>;

template <typename T> using Contour3 = Contour<Vector3<T>>;

using Contour2d = Contour2<double>;

using Contour2f = Contour2<float>;

using Contour3d = Contour3<double>;

using Contour3f = Contour3<float>;


template <typename V> using Contours = std::vector<Contour<V>>;

template <typename T> using Contours2 = Contours<Vector2<T>>;

template <typename T> using Contours3 = Contours<Vector3<T>>;

using Contours2d = Contours2<double>;

using Contours2f = Contours2<float>;

using Contours3d = Contours3<double>;

using Contours3f = Contours3<float>;


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), Plane3,

    ( Plane3f, Plane3<float>  )

    ( Plane3d, Plane3<double> )

)


MR_CANONICAL_TYPEDEFS( (template <typename V> struct MRMESH_CLASS), Box,

    ( Box1i,   Box<int>             )

    ( Box1i64, Box<Int64>           )

    ( Box1f,   Box<float>           )

    ( Box1d,   Box<double>          )

    ( Box2i,   Box<Vector2<int>>    )

    ( Box2i64, Box<Vector2<Int64>>  )

    ( Box2f,   Box<Vector2<float>>  )

    ( Box2d,   Box<Vector2<double>> )

    ( Box3i,   Box<Vector3<int>>    )

    ( Box3i64, Box<Vector3<Int64>>  )

    ( Box3f,   Box<Vector3<float>>  )

    ( Box3d,   Box<Vector3<double>> )

)

#if !MR_PARSING_FOR_ANY_BINDINGS

using Box1ll [[deprecated("Use `Box1i64` instead.")]] = Box<long long>;

using Box2ll [[deprecated("Use `Box2i64` instead.")]] = Box<Vector2<long long>>;

using Box3ll [[deprecated("Use `Box3i64` instead.")]] = Box<Vector3<long long>>;

#endif


template <typename T> using MinMax = Box<T>;

using MinMaxf = MinMax<float>;

using MinMaxd = MinMax<double>;

using MinMaxi = MinMax<int>;


template <typename T> using Box1 = Box<T>;

template <typename T> using Box2 = Box<Vector2<T>>;

template <typename T> using Box3 = Box<Vector3<T>>;


template<typename T, typename I> struct MinArg;

template<typename T, typename I> struct MaxArg;

template<typename T, typename I> struct MinMaxArg;


MR_CANONICAL_TYPEDEFS( (template <typename V> struct MRMESH_CLASS), Ball,

    ( Ball1f,  Ball<float>              )

    ( Ball1d,  Ball<double>             )

    ( Ball2f,  Ball<Vector2<float>>     )

    ( Ball2d,  Ball<Vector2<double>>    )

    ( Ball3f,  Ball<Vector3<float>>     )

    ( Ball3d,  Ball<Vector3<double>>    )

)

template <typename T> using Ball1 = Ball<T>;

template <typename T> using Ball2 = Ball<Vector2<T>>;

template <typename T> using Ball3 = Ball<Vector3<T>>;


MR_CANONICAL_TYPEDEFS( (template <typename V> struct MRMESH_CLASS), CubicBezierCurve,

    ( CubicBezierCurve2f,  CubicBezierCurve<Vector2<float>>     )

    ( CubicBezierCurve2d,  CubicBezierCurve<Vector2<double>>    )

    ( CubicBezierCurve3f,  CubicBezierCurve<Vector3<float>>     )

    ( CubicBezierCurve3d,  CubicBezierCurve<Vector3<double>>    )

)

template <typename T> using CubicBezierCurve2 = CubicBezierCurve<Vector2<T>>;

template <typename T> using CubicBezierCurve3 = CubicBezierCurve<Vector3<T>>;


MR_CANONICAL_TYPEDEFS( (template <typename V> struct), QuadraticForm,

    ( QuadraticForm2f, QuadraticForm<Vector2<float>>  )

    ( QuadraticForm2d, QuadraticForm<Vector2<double>> )

    ( QuadraticForm3f, QuadraticForm<Vector3<float>>  )

    ( QuadraticForm3d, QuadraticForm<Vector3<double>> )

)

template <typename T> using QuadraticForm2 = QuadraticForm<Vector2<T>>;

template <typename T> using QuadraticForm3 = QuadraticForm<Vector3<T>>;


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), Quaternion,

    ( Quaternionf, Quaternion<float>  )

    ( Quaterniond, Quaternion<double> )

)


template <typename T> using Triangle3 = std::array<Vector3<T>, 3>;

using Triangle3i = Triangle3<int>;

using Triangle3f = Triangle3<float>;

using Triangle3d = Triangle3<double>;


class PointAccumulator;


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), SegmPoint,

    ( SegmPointf, SegmPoint<float>  )

    ( SegmPointd, SegmPoint<double> )

)


struct EdgePoint;

struct EdgeSegment;

using MeshEdgePoint = EdgePoint;

using SurfacePath = std::vector<MeshEdgePoint>;

using SurfacePaths = std::vector<SurfacePath>;

using IsoLine = SurfacePath;

using IsoLines = SurfacePaths;

using PlaneSection = SurfacePath;

using PlaneSections = SurfacePaths;

struct EdgePointPair;

struct GeodesicPath;

class Laplacian;


using VertPair = std::pair<VertId, VertId>;

using FacePair = std::pair<FaceId, FaceId>;

using EdgePair = std::pair<EdgeId, EdgeId>;

using UndirectedEdgePair = std::pair<UndirectedEdgeId, UndirectedEdgeId>;


MR_CANONICAL_TYPEDEFS( (template <typename T> struct), TriPoint,

    ( TriPointf, TriPoint<float>  )

    ( TriPointd, TriPoint<double> )

)


struct FaceFace;

struct UndirectedEdgeUndirectedEdge;

struct PointOnFace;

struct PointOnObject;

struct MeshTriPoint;

struct MeshProjectionResult;

struct MeshIntersectionResult;

struct PointsProjectionResult;

template <typename T> struct IntersectionPrecomputes;


template <typename I> struct IteratorRange;


using UVCoord = Vector2f;


using TwoVertIds = std::array<VertId, 2>;


using ThreeVertIds = std::array<VertId, 3>;


using ThreeUVCoords = std::array<UVCoord, 3>;


struct MRMESH_CLASS Dipole;


MR_CANONICAL_TYPEDEFS( (template <typename T, typename I> class MRMESH_CLASS), Vector,

    ( Edges,    Vector<TwoVertIds, UndirectedEdgeId> )


    ( Triangulation,  Vector<ThreeVertIds, FaceId> )


    ( TriCornerUVCoords, Vector<ThreeUVCoords, FaceId> )


    ( Dipoles,  Vector<Dipole, NodeId> )


    ( FaceMap,  Vector<FaceId, FaceId> )

    ( VertMap,  Vector<VertId, VertId> )

    ( EdgeMap,  Vector<EdgeId, EdgeId> )

    ( UndirectedEdgeMap,  Vector<UndirectedEdgeId, UndirectedEdgeId> )

    ( ObjMap,  Vector<ObjId, ObjId> )


    ( WholeEdgeMap,  Vector<EdgeId, UndirectedEdgeId> )

    ( UndirectedEdge2RegionMap,  Vector<RegionId, UndirectedEdgeId> )

    ( Face2RegionMap,  Vector<RegionId, FaceId> )

    ( Vert2RegionMap,  Vector<RegionId, VertId> )


    ( VertCoords,  Vector<Vector3f, VertId> )

    ( VertCoords2, Vector<Vector2f, VertId> )

    ( VertNormals,  Vector<Vector3f, VertId> )

    ( VertUVCoords,  Vector<UVCoord, VertId> )

    ( FaceNormals,  Vector<Vector3f, FaceId> )


    ( TexturePerFace,  Vector<TextureId, FaceId> )

    ( VertColors,  Vector<Color, VertId> )

    ( FaceColors,  Vector<Color, FaceId> )

    ( EdgeColors,  Vector<Color, EdgeId> )

    ( UndirectedEdgeColors,  Vector<Color, UndirectedEdgeId> )


    ( VertScalars,  Vector<float, VertId> )

    ( FaceScalars,  Vector<float, FaceId> )

    ( EdgeScalars,  Vector<float, EdgeId> )

    ( UndirectedEdgeScalars,  Vector<float, UndirectedEdgeId> )

)


using VertPredicate = std::function<bool( VertId )>;

using FacePredicate = std::function<bool( FaceId )>;

using EdgePredicate = std::function<bool( EdgeId )>;

using UndirectedEdgePredicate = std::function<bool( UndirectedEdgeId )>;


using PreCollapseCallback = std::function<bool( EdgeId edgeToCollapse, const Vector3f& newEdgeOrgPos )>;

using OnEdgeSplit = std::function<void( EdgeId e1, EdgeId e )>;


template <typename T>


[[nodiscard]] inline bool contains( const std::function<bool( Id<T> )> & pred, Id<T> id )

{

    return id.valid() && ( !pred || pred( id ) );

}


using VertMetric = std::function<float( VertId )>;

using FaceMetric = std::function<float( FaceId )>;

using EdgeMetric = std::function<float( EdgeId )>;

using UndirectedEdgeMetric = std::function<float( UndirectedEdgeId )>;


MR_CANONICAL_TYPEDEFS( (template <typename T, typename I> struct MRMESH_CLASS), BMap,

    ( FaceBMap, BMap<FaceId, FaceId> )

    ( VertBMap, BMap<VertId, VertId> )

    ( EdgeBMap, BMap<EdgeId, EdgeId> )

    ( UndirectedEdgeBMap, BMap<UndirectedEdgeId, UndirectedEdgeId> )

    ( WholeEdgeBMap, BMap<EdgeId, UndirectedEdgeId> )

)


template <typename T, typename Hash = phmap::priv::hash_default_hash<T>, typename Eq = phmap::priv::hash_default_eq<T>>

using HashSet = phmap::flat_hash_set<T, Hash, Eq>;

template <typename T, typename Hash = phmap::priv::hash_default_hash<T>, typename Eq = phmap::priv::hash_default_eq<T>>

using ParallelHashSet = phmap::parallel_flat_hash_set<T, Hash, Eq>;


using FaceHashSet = HashSet<FaceId>;

using VertHashSet = HashSet<VertId>;

using EdgeHashSet = HashSet<EdgeId>;


template <typename K, typename V, typename Hash = phmap::priv::hash_default_hash<K>, typename Eq = phmap::priv::hash_default_eq<K>>

using HashMap = phmap::flat_hash_map<K, V, Hash, Eq>;

template <typename K, typename V, typename Hash = phmap::priv::hash_default_hash<K>, typename Eq = phmap::priv::hash_default_eq<K>>

using ParallelHashMap = phmap::parallel_flat_hash_map<K, V, Hash, Eq>;


using FaceHashMap = HashMap<FaceId, FaceId>;

using VertHashMap = HashMap<VertId, VertId>;

using EdgeHashMap = HashMap<EdgeId, EdgeId>;

using UndirectedEdgeHashMap = HashMap<UndirectedEdgeId, UndirectedEdgeId>;

using WholeEdgeHashMap = HashMap<UndirectedEdgeId, EdgeId>;


template <typename K, typename V>

struct MapOrHashMap;


using FaceMapOrHashMap = MapOrHashMap<FaceId, FaceId>;

using VertMapOrHashMap = MapOrHashMap<VertId, VertId>;

using EdgeMapOrHashMap = MapOrHashMap<EdgeId, EdgeId>;

using UndirectedEdgeMapOrHashMap = MapOrHashMap<UndirectedEdgeId, UndirectedEdgeId>;

using WholeEdgeMapOrHashMap = MapOrHashMap<UndirectedEdgeId, EdgeId>;


template <typename I> class UnionFind;

template <typename T, typename I, typename P> class Heap;


class MRMESH_CLASS MeshTopology;

struct MRMESH_CLASS Mesh;

struct MRMESH_CLASS EdgeLengthMesh;

class MRMESH_CLASS MeshOrPoints;

struct MRMESH_CLASS PointCloud;

struct MRMESH_CLASS PointCloudPart;

class MRMESH_CLASS AABBTree;

class MRMESH_CLASS AABBTreePoints;

class MRMESH_CLASS AABBTreeObjects;

struct MRMESH_CLASS CloudPartMapping;

struct MRMESH_CLASS PartMapping;

struct MeshOrPointsXf;

struct MeshTexture;

struct GridSettings;

struct FillHoleParams;

struct FillHoleNicelySettings;

struct TriMesh;


MR_CANONICAL_TYPEDEFS( ( template <typename T> struct ), MRMESH_CLASS MeshRegion,

    ( MeshPart, MeshRegion<FaceTag> )

    ( MeshVertPart, MeshRegion<VertTag> )

)


template<typename T> class UniqueThreadSafeOwner;

template<typename T> class SharedThreadSafeOwner;


class PolylineTopology;


MR_CANONICAL_TYPEDEFS( (template<typename V> struct), Polyline,

    ( Polyline2, Polyline<Vector2f> )

    ( Polyline3, Polyline<Vector3f> )

)


MR_CANONICAL_TYPEDEFS( (template <typename V> class MRMESH_CLASS), AABBTreePolyline,

    ( AABBTreePolyline2, AABBTreePolyline<Vector2f> )

    ( AABBTreePolyline3, AABBTreePolyline<Vector3f> )

)


template<typename T> struct IntersectionPrecomputes;

template<typename T> struct IntersectionPrecomputes2;


MR_CANONICAL_TYPEDEFS( (template<typename V> struct [[nodiscard]]), PolylineProjectionResult,

    ( PolylineProjectionResult2, PolylineProjectionResult<Vector2f> )

    ( PolylineProjectionResult3, PolylineProjectionResult<Vector3f> )

)


MR_CANONICAL_TYPEDEFS( (template<typename V> struct [[nodiscard]]), PolylineProjectionWithOffsetResult,

    ( Polyline2ProjectionWithOffsetResult, PolylineProjectionWithOffsetResult<Vector2f> )

    ( PolylineProjectionWithOffsetResult3, PolylineProjectionWithOffsetResult<Vector3f> )

)


class DistanceMap;

struct DistanceToMeshOptions;

struct SignedDistanceToMeshOptions;


using GcodeSource = std::vector<std::string>;


class Object;

class SceneRootObject;

class VisualObject;

class ObjectMeshHolder;

class ObjectMesh;

struct ObjectMeshData;

struct LoadedMeshData;

class ObjectPointsHolder;

class ObjectPoints;

class ObjectLinesHolder;

class ObjectLines;

class ObjectDistanceMap;

class ObjectLabel;

class ObjectGcode;

class PointObject;

class LineObject;

class CircleObject;

class PlaneObject;

class SphereObject;

class CylinderObject;

class ConeObject;


struct LoadedObjects;


struct Image;

class AnyVisualizeMaskEnum;


class HistoryAction;

class ChangeObjectAction;

class MRMESH_CLASS ChangeSceneAction;

class ChangeMeshFaceSelectionAction;

class ChangeMeshEdgeSelectionAction;

class ChangeMeshCreasesAction;

class ChangePointPointSelectionAction;

class ChangeMeshAction;

class ChangeMeshDataAction;

class ChangeMeshPointsAction;

class ChangeMeshTopologyAction;

class PartialChangeMeshAction;

class PartialChangeMeshPointsAction;

class PartialChangeMeshTopologyAction;

class VersatileChangeMeshPointsAction;

class ChangeXfAction;

class CombinedHistoryAction;

class SwapRootAction;


MR_CANONICAL_TYPEDEFS( (template <typename Tag> class MRMESH_CLASS), ColorMapAggregator,

    ( VertColorMapAggregator, ColorMapAggregator<VertTag> )

    ( UndirEdgeColorMapAggregator, ColorMapAggregator<UndirectedEdgeTag> )

    ( FaceColorMapAggregator, ColorMapAggregator<FaceTag> )

)


template<typename T>

class FewSmallest;


class Graph;

class WatershedGraph;


struct TbbTaskArenaAndGroup;


struct SaveSettings;

namespace SceneSave  { struct Settings; }

namespace ObjectSave { struct Settings; }


typedef std::function<bool( float )> ProgressCallback;


enum class FilterType : char;

enum class WrapType : char;

enum class Reorder : char;


struct TransparencyMode;


template <typename T>

constexpr inline T sqr( T x ) noexcept { return x * x; }


template <typename T>

constexpr inline int sgn( T x ) noexcept { return x > 0 ? 1 : ( x < 0 ? -1 : 0 ); }


template <typename T>

constexpr inline T distance( T x, T y ) noexcept { return x >= y ? x - y : y - x; }


template <typename T>

constexpr inline T distanceSq( T x, T y ) noexcept { return sqr( x - y ); }


template <typename V, typename T>

constexpr inline auto lerp( V v0, V v1, T t ) noexcept { return ( 1 - t ) * v0 + t * v1; }


template<typename...>

inline constexpr bool dependent_false = false;


template<class... Ts>

struct overloaded : Ts... { using Ts::operator()...; };


template<class... Ts>

overloaded(Ts...) -> overloaded<Ts...>;


class IFastWindingNumber;

class IPointsToMeshProjector;

class IPointsProjector;


namespace MeshBuilder

{


struct BuildSettings;

struct Triangle;

struct VertDuplication;


}


namespace Locale

{


constexpr inline auto translate_noop( const char* str ) noexcept { return str; }

constexpr inline auto translate_noop( const char* ctx, const char* str ) noexcept { (void)ctx; return str; }

constexpr inline auto translate_noop( const char* single, const char* plural, Int64 n ) noexcept { return n == 1 ? single : plural; }

constexpr inline auto translate_noop( const char* ctx, const char* single, const char* plural, Int64 n ) noexcept { (void)ctx; return n == 1 ? single : plural; }


}


}


#ifdef __cpp_lib_unreachable

#   define MR_UNREACHABLE std::unreachable();

#   define MR_UNREACHABLE_NO_RETURN std::unreachable();

#else

#   ifdef __GNUC__

#       define MR_UNREACHABLE __builtin_unreachable();

#       define MR_UNREACHABLE_NO_RETURN __builtin_unreachable();

#   else

#       include <cassert>

#       define MR_UNREACHABLE { assert( false ); return {}; }

#       define MR_UNREACHABLE_NO_RETURN assert( false );

#   endif

#endif


#ifndef MR_NO_I18N_MACROS

#define _t( ... ) MR::Locale::translate_noop( __VA_ARGS__ )

#endif

MRCanonicalTypedefs.h

MR_CANONICAL_TYPEDEFS
#define MR_CANONICAL_TYPEDEFS(type_, name_, aliases_)
Definition MRCanonicalTypedefs.h:23

MRMESH_CLASS
#define MRMESH_CLASS
Definition MRMeshFwd.h:87

config.h

MR::AABBTreeObjects
Definition MRAABBTreeObjects.h:22

MR::AABBTreePoints
bounding volume hierarchy for point cloud structure
Definition MRAABBTreePoints.h:16

MR::AABBTreePolyline
bounding volume hierarchy for line segments
Definition MRAABBTreePolyline.h:30

MR::AABBTree
Definition MRAABBTree.h:16

MR::AnyVisualizeMaskEnum
Definition MRVisualObject.h:53

MR::BitSet
Definition MRBitSet.h:69

MR::Buffer
std::vector<V>-like container that is 1) resized without initialization of its elements,...
Definition MRBuffer.h:58

MR::ChangeMeshAction
Undo action for ObjectMesh mesh change.
Definition MRChangeMeshAction.h:16

MR::ChangeMeshCreasesAction
Undo action for ObjectMesh creases.
Definition MRChangeSelectionAction.h:122

MR::ChangeMeshDataAction
Undo action for ObjectMeshData change.
Definition MRChangeMeshDataAction.h:14

MR::ChangeMeshEdgeSelectionAction
Undo action for ObjectMesh edge selection.
Definition MRChangeSelectionAction.h:68

MR::ChangeMeshFaceSelectionAction
Undo action for ObjectMesh face selection.
Definition MRChangeSelectionAction.h:14

MR::ChangeMeshPointsAction
Undo action for ObjectMesh points only (not topology) change.
Definition MRChangeMeshAction.h:190

MR::ChangeMeshTopologyAction
Undo action for ObjectMesh topology only (not points) change.
Definition MRChangeMeshAction.h:254

MR::ChangeObjectAction
Definition MRChangeObjectAction.h:17

MR::ChangePointPointSelectionAction
Undo action for ObjectPoints point selection.
Definition MRChangeSelectionAction.h:176

MR::ChangeSceneAction
Definition MRChangeSceneAction.h:16

MR::ChangeXfAction
Definition MRChangeXfAction.h:16

MR::CircleObject
Definition MRCircleObject.h:17

MR::ColorMapAggregator
Class for aggregate several color map in one Color maps are aggregated according order.
Definition MRColorMapAggregator.h:20

MR::CombinedHistoryAction
Definition MRCombinedHistoryAction.h:15

MR::ConeObject
Definition MRConeObject.h:22

MR::CylinderObject
Definition MRCylinderObject.h:21

MR::DistanceMap
Definition MRDistanceMap.h:24

MR::FewSmallest
the class stores some number of smallest elements from a larger number of candidates
Definition MRFewSmallest.h:17

MR::Graph
mathematical graph consisting from vertices and undirected edges
Definition MRGraph.h:17

MR::Heap
stores map from element id in[0, size) to T;
Definition MRHeap.h:23

MR::HistoryAction
Definition MRHistoryAction.h:15

MR::IFastWindingNumber
Abstract class for fast approximate computation of generalized winding number for a mesh (using its A...
Definition MRFastWindingNumber.h:15

MR::IPointsProjector
abstract class for computing the closest points of point clouds
Definition MRPointsProject.h:93

MR::IPointsToMeshProjector
Abstract class, computes the closest point on mesh to each of given points. Pure virtual functions mu...
Definition MRPointsToMeshProjector.h:16

MR::Id
stores index of some element, it is made as template class to avoid mixing faces, edges and vertices
Definition MRId.h:19

MR::Laplacian
Definition MRLaplacian.h:24

MR::LineObject
Definition MRLineObject.h:16

MR::MeshOrPoints
Definition MRMeshOrPoints.h:21

MR::MeshTopology
Definition MRMeshTopology.h:23

MR::ObjectDistanceMap
Definition MRObjectDistanceMap.h:16

MR::ObjectGcode
Definition MRObjectGcode.h:17

MR::ObjectLabel
Definition MRObjectLabel.h:29

MR::ObjectLinesHolder
Definition MRObjectLinesHolder.h:30

MR::ObjectLines
Definition MRObjectLines.h:14

MR::ObjectMeshHolder
Definition MRObjectMeshHolder.h:35

MR::ObjectMesh
Definition MRObjectMesh.h:14

MR::ObjectPointsHolder
Definition MRObjectPointsHolder.h:24

MR::ObjectPoints
Definition MRObjectPoints.h:14

MR::Object
named object in the data model
Definition MRObject.h:62

MR::PartialChangeMeshAction
Undo action for efficiently storage of partial change in mesh (e.g. a modification of small region)
Definition MRPartialChangeMeshAction.h:25

MR::PartialChangeMeshPointsAction
Undo action for efficiently storage of partial change in mesh points (e.g. a modification of small re...
Definition MRPartialChangeMeshAction.h:85

MR::PartialChangeMeshTopologyAction
Undo action for efficiently storage of partial change in mesh topology (e.g. a modification of small ...
Definition MRPartialChangeMeshAction.h:151

MR::PlaneObject
Definition MRPlaneObject.h:15

MR::PointAccumulator
Class to accumulate points and make best line / plane approximation.
Definition MRBestFit.h:20

MR::PointObject
Definition MRPointObject.h:17

MR::PointToPlaneAligningTransform
Definition MRPointToPlaneAligningTransform.h:20

MR::PointToPointAligningTransform
Definition MRPointToPointAligningTransform.h:16

MR::PolylineTopology
Definition MRPolylineTopology.h:18

MR::SceneRootObject
Object that is parent of all scene.
Definition MRSceneRoot.h:14

MR::SharedThreadSafeOwner
Definition MRSharedThreadSafeOwner.h:19

MR::SphereObject
Definition MRSphereObject.h:18

MR::SwapRootAction
Definition MRSwapRootAction.h:16

MR::TypedBitSet
Definition MRBitSet.h:277

MR::UnionFind
Union-find data structure for representing disjoin sets of elements with few very quick operations: 1...
Definition MRUnionFind.h:23

MR::UniqueThreadSafeOwner
Definition MRUniqueThreadSafeOwner.h:18

MR::VersatileChangeMeshPointsAction
Definition MRVersatileChangeMeshAction.h:14

MR::ViewportId
Definition MRViewportId.h:16

MR::ViewportMask
stores mask of viewport unique identifiers
Definition MRViewportId.h:42

MR::VisualObject
Visual Object.
Definition MRVisualObject.h:115

MR::WatershedGraph
graphs representing rain basins on the mesh
Definition MRWatershedGraph.h:15

MR::contains
bool contains(const TypedBitSet< I > *bitset, I id)
Definition MRBitSet.h:405

MR::ProgressCallback
std::function< bool(float)> ProgressCallback
Definition MRMeshFwd.h:758

MR::CubicBezierCurve2
CubicBezierCurve< Vector2< T > > CubicBezierCurve2
Definition MRMeshFwd.h:450

MR::VertMetric
std::function< float(VertId)> VertMetric
Definition MRMeshFwd.h:586

MR::ParallelHashMap
phmap::parallel_flat_hash_map< K, V, Hash, Eq > ParallelHashMap
Definition MRMeshFwd.h:612

MR::EdgeLoop
std::vector< EdgeId > EdgeLoop
Definition MRMeshFwd.h:150

MR::GcodeSource
std::vector< std::string > GcodeSource
Definition MRMeshFwd.h:689

MR::WrapType
WrapType
Definition MREnums.h:18

MR::struct
struct
Definition MRMeshFwd.h:206

Contour
Contour
Definition MRObjectLabel.h:20

MR::TwoVertIds
std::array< VertId, 2 > TwoVertIds
two vertex ids describing an edge with the ends in vertices given by their ids
Definition MRMeshFwd.h:520

MR::SurfacePaths
std::vector< SurfacePath > SurfacePaths
Definition MRMeshFwd.h:484

MR::EdgeLoops
std::vector< EdgeLoop > EdgeLoops
Definition MRMeshFwd.h:151

MR::Contour3f
Contour3< float > Contour3f
Definition MRMeshFwd.h:384

MR::UndirectedEdgeTag
class MRMESH_CLASS UndirectedEdgeTag
Definition MRMeshFwd.h:102

MR::sqr
constexpr T sqr(T x) noexcept
squared value
Definition MRMeshFwd.h:768

MR::AABBTreePolyline2
AABBTreePolyline2
Definition MRMeshFwd.h:668

MR::LineSegm3
LineSegm< Vector3< T > > LineSegm3
Definition MRMeshFwd.h:355

MR::FaceMapOrHashMap
MapOrHashMap< FaceId, FaceId > FaceMapOrHashMap
Definition MRMeshFwd.h:624

MR::ObjTag
class MRMESH_CLASS ObjTag
Definition MRMeshFwd.h:109

MR::CubicBezierCurve3
CubicBezierCurve< Vector3< T > > CubicBezierCurve3
Definition MRMeshFwd.h:451

MR::MinMax
Box< T > MinMax
Definition MRMeshFwd.h:419

MR::FacePredicate
std::function< bool(FaceId)> FacePredicate
Definition MRMeshFwd.h:573

MR::MinMaxf
MinMax< float > MinMaxf
Definition MRMeshFwd.h:420

MR::Contour2d
Contour2< double > Contour2d
Definition MRMeshFwd.h:381

MR::Eq
struct MRMESH_CLASS Eq
Definition MRMeshFwd.h:599

MR::NodeTag
class MRMESH_CLASS NodeTag
Definition MRMeshFwd.h:108

MR::Box3
Box< Vector3< T > > Box3
Definition MRMeshFwd.h:426

MR::VertHashSet
HashSet< VertId > VertHashSet
Definition MRMeshFwd.h:606

MR::EdgePredicate
std::function< bool(EdgeId)> EdgePredicate
Definition MRMeshFwd.h:574

MR::Contour2f
Contour2< float > Contour2f
Definition MRMeshFwd.h:382

MR::ThreeUVCoords
std::array< UVCoord, 3 > ThreeUVCoords
three UV-coordinates describing texturing of a triangle
Definition MRMeshFwd.h:526

MR::Contours2d
Contours2< double > Contours2d
Definition MRMeshFwd.h:389

MR::Contours3f
Contours3< float > Contours3f
Definition MRMeshFwd.h:392

MR::Uint64
std::uint64_t Uint64
Definition MRMeshFwd.h:203

MR::UndirectedEdgePredicate
std::function< bool(UndirectedEdgeId)> UndirectedEdgePredicate
Definition MRMeshFwd.h:575

MR::Ball2
Ball< Vector2< T > > Ball2
Definition MRMeshFwd.h:441

MR::VertMapOrHashMap
MapOrHashMap< VertId, VertId > VertMapOrHashMap
Definition MRMeshFwd.h:625

MR::Contours3d
Contours3< double > Contours3d
Definition MRMeshFwd.h:391

MR::PlaneSections
SurfacePaths PlaneSections
Definition MRMeshFwd.h:488

MR::EdgeMapOrHashMap
MapOrHashMap< EdgeId, EdgeId > EdgeMapOrHashMap
Definition MRMeshFwd.h:626

MR::VertHashMap
HashMap< VertId, VertId > VertHashMap
Definition MRMeshFwd.h:615

MR::QuadraticForm3
QuadraticForm< Vector3< T > > QuadraticForm3
Definition MRMeshFwd.h:460

MR::VoxelTag
class MRMESH_CLASS VoxelTag
Definition MRMeshFwd.h:106

MR::Ball1
Ball< T > Ball1
Definition MRMeshFwd.h:440

MR::FilterType
FilterType
Definition MREnums.h:12

MR::IsoLine
SurfacePath IsoLine
Definition MRMeshFwd.h:485

MR::UVCoord
Vector2f UVCoord
Definition MRMeshFwd.h:517

MR::Triangle3i
Triangle3< int > Triangle3i
Definition MRMeshFwd.h:469

MR::Ball3
Ball< Vector3< T > > Ball3
Definition MRMeshFwd.h:442

MR::Sphere3
Sphere< Vector3< T > > Sphere3
Definition MRMeshFwd.h:337

MR::SurfacePath
std::vector< MeshEdgePoint > SurfacePath
Definition MRMeshFwd.h:483

MR::WholeEdgeHashMap
HashMap< UndirectedEdgeId, EdgeId > WholeEdgeHashMap
mapping of whole edges: map[e]->f, map[e.sym()]->f.sym(), where only map[e] for even edges is stored
Definition MRMeshFwd.h:619

MR::FaceTag
class MRMESH_CLASS FaceTag
Definition MRMeshFwd.h:103

MR::TextureTag
class MRMESH_CLASS TextureTag
Definition MRMeshFwd.h:110

MR::I
class MRMESH_CLASS I
Definition MRMeshFwd.h:139

MR::PixelTag
class MRMESH_CLASS PixelTag
Definition MRMeshFwd.h:105

MR::Line3
Line< Vector3< T > > Line3
Definition MRMeshFwd.h:346

MR::Contours2
Contours< Vector2< T > > Contours2
Definition MRMeshFwd.h:387

MR::overloaded
overloaded(Ts...) -> overloaded< Ts... >
explicit deduction guide (not needed as of C++20, but still needed in Clang)

MR::sgn
constexpr int sgn(T x) noexcept
sign of given value in { -1, 0, 1 }
Definition MRMeshFwd.h:772

MR::Contours2f
Contours2< float > Contours2f
Definition MRMeshFwd.h:390

MR::EdgeMetric
std::function< float(EdgeId)> EdgeMetric
Definition MRMeshFwd.h:588

MR::MinMaxd
MinMax< double > MinMaxd
Definition MRMeshFwd.h:421

MR::Box2
Box< Vector2< T > > Box2
Definition MRMeshFwd.h:425

MR::PreCollapseCallback
std::function< bool(EdgeId edgeToCollapse, const Vector3f &newEdgeOrgPos)> PreCollapseCallback
Definition MRMeshFwd.h:577

MR::MinMaxi
MinMax< int > MinMaxi
Definition MRMeshFwd.h:422

MR::MeshEdgePoint
EdgePoint MeshEdgePoint
Definition MRMeshFwd.h:482

MR::Box1
Box< T > Box1
Definition MRMeshFwd.h:424

MR::Contour2
Contour< Vector2< T > > Contour2
Definition MRMeshFwd.h:379

MR::Contour3d
Contour3< double > Contour3d
Definition MRMeshFwd.h:383

MR::TaggedBitSet
TypedBitSet< Id< T > > TaggedBitSet
Definition MRMeshFwd.h:171

MR::PlaneSection
SurfacePath PlaneSection
Definition MRMeshFwd.h:487

MR::FaceHashMap
HashMap< FaceId, FaceId > FaceHashMap
Definition MRMeshFwd.h:614

MR::FaceMetric
std::function< float(FaceId)> FaceMetric
Definition MRMeshFwd.h:587

MR::LocaleDomainTag
class MRMESH_CLASS LocaleDomainTag
Definition MRMeshFwd.h:113

MR::WholeEdgeMapOrHashMap
MapOrHashMap< UndirectedEdgeId, EdgeId > WholeEdgeMapOrHashMap
mapping of whole edges: map[e]->f, map[e.sym()]->f.sym(), where only map[e] for even edges is stored
Definition MRMeshFwd.h:629

MR::Polyline2
Polyline2
Definition MRMeshFwd.h:663

MR::Triangle3d
Triangle3< double > Triangle3d
Definition MRMeshFwd.h:471

MR::Contour3
Contour< Vector3< T > > Contour3
Definition MRMeshFwd.h:380

MR::FaceHashSet
HashSet< FaceId > FaceHashSet
No canonical typedefs because phmap::... is not under our control.
Definition MRMeshFwd.h:605

MR::EdgePath
std::vector< EdgeId > EdgePath
Definition MRMeshFwd.h:149

MR::ThreeVertIds
std::array< VertId, 3 > ThreeVertIds
three vertex ids describing a triangle with the corners in vertices given by their ids
Definition MRMeshFwd.h:523

MR::VertTag
class MRMESH_CLASS VertTag
Definition MRMeshFwd.h:104

MR::FacePair
std::pair< FaceId, FaceId > FacePair
Definition MRMeshFwd.h:494

MR::noInit
constexpr NoInit noInit
Definition MRMeshFwd.h:98

MR::EdgeHashSet
HashSet< EdgeId > EdgeHashSet
Definition MRMeshFwd.h:607

MR::UndirectedEdgePair
std::pair< UndirectedEdgeId, UndirectedEdgeId > UndirectedEdgePair
Definition MRMeshFwd.h:496

MR::EdgePair
std::pair< EdgeId, EdgeId > EdgePair
Definition MRMeshFwd.h:495

MR::Int64
std::int64_t Int64
Definition MRMeshFwd.h:202

MR::OnEdgeSplit
std::function< void(EdgeId e1, EdgeId e)> OnEdgeSplit
Definition MRMeshFwd.h:578

MR::UndirectedEdgeMetric
std::function< float(UndirectedEdgeId)> UndirectedEdgeMetric
Definition MRMeshFwd.h:589

MR::lerp
constexpr auto lerp(V v0, V v1, T t) noexcept
Linear interpolation: returns v0 when t==0 and v1 when t==1.
Definition MRMeshFwd.h:784

MR::dependent_false
constexpr bool dependent_false
Definition MRMeshFwd.h:787

MR::Triangle3f
Triangle3< float > Triangle3f
Definition MRMeshFwd.h:470

MR::IsoLines
SurfacePaths IsoLines
Definition MRMeshFwd.h:486

MR::Locale::translate_noop
constexpr auto translate_noop(const char *str) noexcept
special no-op inline functions to mark string literal as translatable
Definition MRMeshFwd.h:813

MR::EdgeTag
class MRMESH_CLASS EdgeTag
Definition MRMeshFwd.h:101

MR::AffineXf3
AffineXf< Vector3< T > > AffineXf3
Definition MRMeshFwd.h:315

MR::Contours
std::vector< Contour< V > > Contours
Definition MRMeshFwd.h:386

MR::Polyline2ProjectionWithOffsetResult
Polyline2ProjectionWithOffsetResult
Definition MRMeshFwd.h:681

MR::EdgeHashMap
HashMap< EdgeId, EdgeId > EdgeHashMap
Definition MRMeshFwd.h:616

MR::Hash
struct MRMESH_CLASS Hash
Definition MRMeshFwd.h:599

MR::ParallelHashSet
phmap::parallel_flat_hash_set< T, Hash, Eq > ParallelHashSet
Definition MRMeshFwd.h:602

MR::UndirectedEdgeMapOrHashMap
MapOrHashMap< UndirectedEdgeId, UndirectedEdgeId > UndirectedEdgeMapOrHashMap
Definition MRMeshFwd.h:627

MR::VertPair
std::pair< VertId, VertId > VertPair
Definition MRMeshFwd.h:493

MR::UndirectedEdgeHashMap
HashMap< UndirectedEdgeId, UndirectedEdgeId > UndirectedEdgeHashMap
Definition MRMeshFwd.h:617

MR::Contours3
Contours< Vector3< T > > Contours3
Definition MRMeshFwd.h:388

MR::RegionTag
class MRMESH_CLASS RegionTag
Definition MRMeshFwd.h:107

MR::GraphVertTag
class MRMESH_CLASS GraphVertTag
Definition MRMeshFwd.h:111

MR::HashMap
phmap::flat_hash_map< K, V, Hash, Eq > HashMap
Definition MRMeshFwd.h:610

MR::GraphEdgeTag
class MRMESH_CLASS GraphEdgeTag
Definition MRMeshFwd.h:112

MR::Reorder
Reorder
determines how points to be ordered
Definition MREnums.h:26

MR::distanceSq
std::optional< T > distanceSq(const Plane3< T > &plane1, const Plane3< T > &plane2, T errorLimit=std::numeric_limits< T >::epsilon() *T(20))
Definition MRIntersection.h:90

MR::distance
std::optional< T > distance(const Plane3< T > &plane1, const Plane3< T > &plane2, T errorLimit=std::numeric_limits< T >::epsilon() *T(20))
Definition MRIntersection.h:104

MR::Locale
Definition MRMeshFwd.h:810

MR::MeshBuilder
Building topologies by triangles.
Definition MRIdentifyVertices.h:16

MR::SceneSave
Definition MRIOFormatsRegistry.h:361

MR
only for bindings generation
Definition MRCameraOrientationPlugin.h:8

MR::AffineXf
Definition MRAffineXf.h:26

MR::AllLocalTriangulations
triangulations for all points, with easy access by VertId
Definition MRLocalTriangulations.h:51

MR::BMap
flat map: I -> T
Definition MRBuffer.h:136

MR::Ball
a ball = points surrounded by a sphere in arbitrary space with vector type V
Definition MRBall.h:15

MR::Box
Box given by its min- and max- corners.
Definition MRBox.h:27

MR::CloudPartMapping
mapping among elements of source point cloud, from which a part is taken, and target (this) point clo...
Definition MRCloudPartMapping.h:13

MR::Color
Definition MRColor.h:12

MR::CubicBezierCurve
Cubic Bezier curve.
Definition MRBezier.h:16

MR::Dipole
Definition MRDipole.h:14

MR::DistanceToMeshOptions
options determining computation of distance from a point to a mesh
Definition MRDistanceToMeshOptions.h:14

MR::EdgeLengthMesh
Definition MREdgeLengthMesh.h:16

MR::EdgePointPair
two edge-points (e.g. representing collision point of two edges)
Definition MREdgePoint.h:53

MR::EdgePoint
encodes a point on an edge of mesh or of polyline
Definition MREdgePoint.h:14

MR::EdgeSegment
Represents a segment on one edge.
Definition MREdgePoint.h:64

MR::FaceFace
a pair of faces
Definition MRFaceFace.h:14

MR::FillHoleNicelySettings
Definition MRFillHoleNicely.h:59

MR::FillHoleParams
Parameters structure for MR::fillHole Structure has some options to control MR::fillHole.
Definition MRMeshFillHole.h:26

MR::GeodesicPath
Definition MRSurfacePath.h:20

MR::GridSettings
settings defining regular grid, where each quadrangular cell is split on two triangles in one of two ...
Definition MRGridSettings.h:14

MR::Image
Definition MRImage.h:19

MR::IntersectionPrecomputes2
Definition MRIntersectionPrecomputes2.h:35

MR::IntersectionPrecomputes
Definition MRIntersectionPrecomputes.h:117

MR::IteratorRange
Definition MRIteratorRange.h:13

MR::LineSegm
a segment of straight dimensional line
Definition MRLineSegm.h:15

MR::Line
Definition MRLine.h:16

MR::LoadedMeshData
ObjectMeshData and additional information from mesh importer.
Definition MRLoadedMeshData.h:15

MR::LoadedObjects
result of loading (e.g. from a file) as a number of objects
Definition MRLoadedObjects.h:36

MR::MapOrHashMap
Definition MRMapOrHashMap.h:19

MR::Matrix2
Definition MRMatrix2.h:24

MR::Matrix3
Definition MRMatrix3.h:24

MR::Matrix4
Definition MRMatrix4.h:25

MR::MaxArg
Definition MRMinMaxArg.h:49

MR::MeshIntersectionResult
Definition MRMeshIntersect.h:18

MR::MeshOrPointsXf
an object and its transformation to global space with other objects
Definition MRMeshOrPoints.h:109

MR::MeshProjectionResult
Definition MRMeshProject.h:18

MR::MeshRegion
Definition MRMeshPart.h:15

MR::MeshTexture
Definition MRMeshTexture.h:13

MR::MeshTriPoint
Definition MRMeshTriPoint.h:26

MR::Mesh
Definition MRMesh.h:23

MR::MinArg
Definition MRMinMaxArg.h:16

MR::MinMaxArg
Definition MRMinMaxArg.h:82

MR::NoDefInit
this class is similar to T, but does not make default initialization of the fields for best performan...
Definition MRNoDefInit.h:14

MR::NoInit
Definition MRMeshFwd.h:97

MR::ObjectMeshData
mesh and its per-element attributes for ObjectMeshHolder
Definition MRObjectMeshData.h:17

MR::PackMapping
Definition MRBuffer.h:144

MR::PartMapping
mapping among elements of source mesh, from which a part is taken, and target mesh
Definition MRPartMapping.h:13

MR::PointCloudPart
represents full point cloud (if region is nullptr) or some portion of point cloud (if region pointer ...
Definition MRPointCloudPart.h:13

MR::PointCloud
Definition MRPointCloud.h:17

MR::PointOnFace
a point located on some mesh's face
Definition MRPointOnFace.h:16

MR::PointOnObject
Definition MRPointOnObject.h:21

MR::PointsProjectionResult
Definition MRPointsProject.h:15

MR::PolylineProjectionResult
Definition MRPolylineProject.h:15

MR::PolylineProjectionWithOffsetResult
Definition MRPolylineProject.h:73

MR::Polyline
Definition MRPolyline.h:18

MR::QuadraticForm
Definition MRQuadraticForm.h:16

MR::SaveSettings
determines how to save points/lines/mesh
Definition MRSaveSettings.h:20

MR::SignedDistanceToMeshOptions
options determining computation of signed distance from a point to a mesh
Definition MRDistanceToMeshOptions.h:40

MR::SomeLocalTriangulations
describes a number of local triangulations of some points (e.g. assigned to a thread)
Definition MRLocalTriangulations.h:43

MR::Sphere
Definition MRSphere.h:14

MR::SymMatrix2
Definition MRSymMatrix2.h:17

MR::SymMatrix3
Definition MRSymMatrix3.h:18

MR::SymMatrix4
Definition MRSymMatrix4.h:16

MR::TbbTaskArenaAndGroup
Definition MRTbbTaskArenaAndGroup.h:16

MR::TransparencyMode
struct to determine transparent rendering mode
Definition MRRenderModelParameters.h:13

MR::TriMesh
Definition MRTriMesh.h:16

MR::UndirectedEdgeUndirectedEdge
a pair of undirected edges
Definition MRFaceFace.h:24

MR::UnorientedTriangle
Definition MRUnorientedTriangle.h:16

MR::Vector2
Definition MRVector2.h:29

MR::Vector3
Definition MRVector3.h:33

MR::Vector4
Definition MRVector4.h:26

MR::overloaded
Definition MRMeshFwd.h:790