#include "config.h"
#include <array>
#include <vector>
#include <string>
#include <parallel_hashmap/phmap_fwd_decl.h>
#include <functional>

Go to the source code of this file.

Classes
struct	MR::NoInit

struct	MR::overloaded< Ts >

Namespaces
namespace	MR

namespace	MR::MeshBuilder
	Building topologies by triangles.

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

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

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

#define	MR_UNREACHABLE_NO_RETURN assert( false );

Typedefs
using	MR::EdgeId = Id<EdgeTag>

using	MR::UndirectedEdgeId = Id<UndirectedEdgeTag>

using	MR::FaceId = Id<FaceTag>

using	MR::VertId = Id<VertTag>

using	MR::PixelId = Id<PixelTag>

using	MR::VoxelId = Id<VoxelTag>

using	MR::RegionId = Id<RegionTag>

using	MR::ThreeVertIds = std::array<VertId, 3>
	three vertex ids describing a triangle topology

using	MR::Triangulation = Vector<ThreeVertIds, FaceId>
	mapping from FaceId to a triple of vertex indices

using	MR::EdgePath = std::vector<EdgeId>

using	MR::EdgeLoop = std::vector<EdgeId>

using	MR::FaceBitSet = TaggedBitSet<FaceTag>

using	MR::VertBitSet = TaggedBitSet<VertTag>

using	MR::EdgeBitSet = TaggedBitSet<EdgeTag>

using	MR::UndirectedEdgeBitSet = TaggedBitSet<UndirectedEdgeTag>

using	MR::PixelBitSet = TaggedBitSet<PixelTag>

using	MR::VoxelBitSet = TaggedBitSet<VoxelTag>

using	MR::SetBitIterator = SetBitIteratorT<BitSet>

using	MR::FaceSetBitIterator = SetBitIteratorT<FaceBitSet>

using	MR::VertSetBitIterator = SetBitIteratorT<VertBitSet>

using	MR::EdgeSetBitIterator = SetBitIteratorT<EdgeBitSet>

using	MR::UndirectedEdgeSetBitIterator = SetBitIteratorT<UndirectedEdgeBitSet>

using	MR::Vector2b = Vector2<bool>

using	MR::Vector2i = Vector2<int>

using	MR::Vector2ll = Vector2<long long>

using	MR::Vector2f = Vector2<float>

using	MR::Vector2d = Vector2<double>

using	MR::Vector3b = Vector3<bool>

using	MR::Vector3i = Vector3<int>

using	MR::Vector3ll = Vector3<long long>

using	MR::Vector3f = Vector3<float>

using	MR::Vector3d = Vector3<double>

using	MR::Vector4b = Vector4<bool>

using	MR::Vector4i = Vector4<int>

using	MR::Vector4ll = Vector4<long long>

using	MR::Vector4f = Vector4<float>

using	MR::Vector4d = Vector4<double>

using	MR::Matrix2b = Matrix2<bool>

using	MR::Matrix2i = Matrix2<int>

using	MR::Matrix2ll = Matrix2<long long>

using	MR::Matrix2f = Matrix2<float>

using	MR::Matrix2d = Matrix2<double>

using	MR::Matrix3b = Matrix3<bool>

using	MR::Matrix3i = Matrix3<int>

using	MR::Matrix3ll = Matrix3<long long>

using	MR::Matrix3f = Matrix3<float>

using	MR::Matrix3d = Matrix3<double>

using	MR::Matrix4b = Matrix4<bool>

using	MR::Matrix4i = Matrix4<int>

using	MR::Matrix4ll = Matrix4<long long>

using	MR::Matrix4f = Matrix4<float>

using	MR::Matrix4d = Matrix4<double>

using	MR::SymMatrix2b = SymMatrix2<bool>

using	MR::SymMatrix2i = SymMatrix2<int>

using	MR::SymMatrix2ll = SymMatrix2<long long>

using	MR::SymMatrix2f = SymMatrix2<float>

using	MR::SymMatrix2d = SymMatrix2<double>

using	MR::SymMatrix3b = SymMatrix3<bool>

using	MR::SymMatrix3i = SymMatrix3<int>

using	MR::SymMatrix3ll = SymMatrix3<long long>

using	MR::SymMatrix3f = SymMatrix3<float>

using	MR::SymMatrix3d = SymMatrix3<double>

using	MR::SymMatrix4b = SymMatrix4<bool>

using	MR::SymMatrix4i = SymMatrix4<int>

using	MR::SymMatrix4ll = SymMatrix4<long long>

using	MR::SymMatrix4f = SymMatrix4<float>

using	MR::SymMatrix4d = SymMatrix4<double>

template<typename T >
using	MR::AffineXf2 = AffineXf<Vector2<T>>

using	MR::AffineXf2f = AffineXf2<float>

using	MR::AffineXf2d = AffineXf2<double>

template<typename T >
using	MR::AffineXf3 = AffineXf<Vector3<T>>

using	MR::AffineXf3f = AffineXf3<float>

using	MR::AffineXf3d = AffineXf3<double>

template<typename T >
using	MR::Sphere2 = Sphere<Vector2<T>>

using	MR::Sphere2f = Sphere2<float>

using	MR::Sphere2d = Sphere2<double>

template<typename T >
using	MR::Sphere3 = Sphere<Vector3<T>>

using	MR::Sphere3f = Sphere3<float>

using	MR::Sphere3d = Sphere3<double>

template<typename T >
using	MR::Line2 = Line<Vector2<T>>

using	MR::Line2f = Line2<float>

using	MR::Line2d = Line2<double>

template<typename T >
using	MR::Line3 = Line<Vector3<T>>

using	MR::Line3f = Line3<float>

using	MR::Line3d = Line3<double>

template<typename T >
using	MR::LineSegm2 = LineSegm<Vector2<T>>

using	MR::LineSegm2f = LineSegm2<float>

using	MR::LineSegm2d = LineSegm2<double>

template<typename T >
using	MR::LineSegm3 = LineSegm<Vector3<T>>

using	MR::LineSegm3f = LineSegm3<float>

using	MR::LineSegm3d = LineSegm3<double>

using	MR::Cylinder3f = Cylinder3<float>

using	MR::Cylinder3d = Cylinder3<double>

using	MR::Cone3f = Cone3<float>

using	MR::Cone3d = Cone3<double>

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

template<typename T >
using	MR::Contour2 = Contour<Vector2<T>>

template<typename T >
using	MR::Contour3 = Contour<Vector3<T>>

using	MR::Contour2d = Contour2<double>

using	MR::Contour2f = Contour2<float>

using	MR::Contour3d = Contour3<double>

using	MR::Contour3f = Contour3<float>

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

template<typename T >
using	MR::Contours2 = Contours<Vector2<T>>

template<typename T >
using	MR::Contours3 = Contours<Vector3<T>>

using	MR::Contours2d = Contours2<double>

using	MR::Contours2f = Contours2<float>

using	MR::Contours3d = Contours3<double>

using	MR::Contours3f = Contours3<float>

using	MR::Plane3f = Plane3<float>

using	MR::Plane3d = Plane3<double>

template<typename T >
using	MR::Box2 = Box<Vector2<T>>

using	MR::Box2i = Box2<int>

using	MR::Box2ll = Box2<long long>

using	MR::Box2f = Box2<float>

using	MR::Box2d = Box2<double>

template<typename T >
using	MR::Box3 = Box<Vector3<T>>

using	MR::Box3i = Box3<int>

using	MR::Box3ll = Box3<long long>

using	MR::Box3f = Box3<float>

using	MR::Box3d = Box3<double>

template<typename T >
using	MR::QuadraticForm2 = QuadraticForm<Vector2<T>>

using	MR::QuadraticForm2f = QuadraticForm2<float>

using	MR::QuadraticForm2d = QuadraticForm2<double>

template<typename T >
using	MR::QuadraticForm3 = QuadraticForm<Vector3<T>>

using	MR::QuadraticForm3f = QuadraticForm3<float>

using	MR::QuadraticForm3d = QuadraticForm3<double>

using	MR::Quaternionf = Quaternion<float>

using	MR::Quaterniond = Quaternion<double>

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

using	MR::Triangle3i = Triangle3<int>

using	MR::Triangle3f = Triangle3<float>

using	MR::Triangle3d = Triangle3<double>

using	MR::SegmPointf = SegmPoint<float>

using	MR::SegmPointd = SegmPoint<double>

using	MR::MeshEdgePoint = EdgePoint

using	MR::SurfacePath = std::vector<MeshEdgePoint>

using	MR::SurfacePaths = std::vector<SurfacePath>

using	MR::IsoLine = SurfacePath

using	MR::IsoLines = SurfacePaths

using	MR::PlaneSection = SurfacePath

using	MR::PlaneSections = SurfacePaths

using	MR::TriPointf = TriPoint<float>

using	MR::TriPointd = TriPoint<double>

using	MR::UVCoord = Vector2f

using	MR::FaceMap = Vector<FaceId, FaceId>

using	MR::VertMap = Vector<VertId, VertId>

using	MR::EdgeMap = Vector<EdgeId, EdgeId>

using	MR::UndirectedEdgeMap = Vector<UndirectedEdgeId, UndirectedEdgeId>

using	MR::WholeEdgeMap = Vector<EdgeId, UndirectedEdgeId>
	mapping of whole edges: map[e]->f, map[e.sym()]->f.sym(), where only map[e] for even edges is stored

using	MR::UndirectedEdge2RegionMap = Vector<RegionId, UndirectedEdgeId>

using	MR::Face2RegionMap = Vector<RegionId, FaceId>

using	MR::Vert2RegionMap = Vector<RegionId, VertId>

using	MR::VertCoords = Vector<Vector3f, VertId>

using	MR::VertNormals = Vector<Vector3f, VertId>

using	MR::VertUVCoords = Vector<UVCoord, VertId>

using	MR::FaceNormals = Vector<Vector3f, FaceId>

using	MR::VertColors = Vector<Color, VertId>

using	MR::FaceColors = Vector<Color, FaceId>

using	MR::EdgeColors = Vector<Color, EdgeId>

using	MR::UndirectedEdgeColors = Vector<Color, UndirectedEdgeId>

using	MR::VertScalars = Vector<float, VertId>

using	MR::FaceScalars = Vector<float, FaceId>

using	MR::EdgeScalars = Vector<float, EdgeId>

using	MR::UndirectedEdgeScalars = Vector<float, UndirectedEdgeId>

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

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

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

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

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

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

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

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

using	MR::FaceBMap = BMap<FaceId, FaceId>

using	MR::VertBMap = BMap<VertId, VertId>

using	MR::EdgeBMap = BMap<EdgeId, EdgeId>

using	MR::UndirectedEdgeBMap = BMap<UndirectedEdgeId, UndirectedEdgeId>

using	MR::WholeEdgeBMap = BMap<EdgeId, UndirectedEdgeId>

template<typename T , typename Hash = phmap::priv::hash_default_hash<T>, typename Eq = phmap::priv::hash_default_eq<T>>
using	MR::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	MR::ParallelHashSet = phmap::parallel_flat_hash_set<T, Hash, Eq>

using	MR::FaceHashSet = HashSet<FaceId>

using	MR::VertHashSet = HashSet<VertId>

using	MR::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	MR::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	MR::ParallelHashMap = phmap::parallel_flat_hash_map<K, V, Hash, Eq>

using	MR::FaceHashMap = HashMap<FaceId, FaceId>

using	MR::VertHashMap = HashMap<VertId, VertId>

using	MR::EdgeHashMap = HashMap<EdgeId, EdgeId>

using	MR::UndirectedEdgeHashMap = HashMap<UndirectedEdgeId, UndirectedEdgeId>

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

using	MR::Polyline2 = Polyline<Vector2f>

using	MR::Polyline3 = Polyline<Vector3f>

using	MR::AABBTreePolyline2 = AABBTreePolyline<Vector2f>

using	MR::AABBTreePolyline3 = AABBTreePolyline<Vector3f>

using	MR::PolylineProjectionResult2 = PolylineProjectionResult<Vector2f>

using	MR::PolylineProjectionResult3 = PolylineProjectionResult<Vector3f>

using	MR::Polyline2ProjectionWithOffsetResult = PolylineProjectionWithOffsetResult<Vector2f>

using	MR::PolylineProjectionWithOffsetResult3 = PolylineProjectionWithOffsetResult<Vector3f>

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

using	MR::SimpleVolume = VoxelsVolume<std::vector<float>>

using	MR::SimpleVolumeU16 = VoxelsVolume<std::vector<uint16_t>>

template<typename T >
using	MR::VoxelValueGetter = std::function<T ( const Vector3i& )>

using	MR::FunctionVolume = VoxelsVolume<VoxelValueGetter<float>>

using	MR::FunctionVolumeU8 = VoxelsVolume<VoxelValueGetter<uint8_t>>

using	MR::FloatGrid = std::shared_ptr<OpenVdbFloatGrid>

using	MR::VdbVolume = VoxelsVolume<FloatGrid>

using	MR::VertColorMapAggregator = ColorMapAggregator<VertTag>

using	MR::UndirEdgeColorMapAggregator = ColorMapAggregator<UndirectedEdgeTag>

using	MR::FaceColorMapAggregator = ColorMapAggregator<FaceTag>

using	MR::GraphVertId = Id<GraphVertTag>

using	MR::GraphEdgeId = Id<GraphEdgeTag>

using	MR::GraphVertBitSet = TaggedBitSet<GraphVertTag>

using	MR::GraphEdgeBitSet = TaggedBitSet<GraphEdgeTag>

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

Enumerations
enum class	MR::FilterType : char { MR::Linear , MR::Discrete }

enum class	MR::WrapType : char { MR::Repeat , MR::Mirror , MR::Clamp }

enum class	MR::Reorder : char { MR::None , MR::Lexicographically , MR::AABBTree }
	determines how points to be ordered More...

Functions
template<typename T >
bool	MR::contains (const std::function< bool(Id< T >)> &pred, Id< T > id)

template<typename T >
constexpr T	MR::sqr (T x) noexcept

template<typename T >
constexpr int	MR::sgn (T x) noexcept

template<class... Ts>
	MR::overloaded (Ts...) -> overloaded< Ts... >

Variables
constexpr NoInit	MR::noInit

template<typename T >
struct MRMESH_CLASS	MR::NoDefInit

class MRMESH_CLASS	MR::EdgeTag

class MRMESH_CLASS	MR::UndirectedEdgeTag

class MRMESH_CLASS	MR::FaceTag

class MRMESH_CLASS	MR::VertTag

class MRMESH_CLASS	MR::PixelTag

class MRMESH_CLASS	MR::VoxelTag

class MRMESH_CLASS	MR::RegionTag

template<typename T >
class MRMESH_CLASS	MR::Id

template<typename T , typename I >
class MRMESH_CLASS	MR::Vector

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

class MRMESH_CLASS	MR::BitSet

template<typename T >
class MRMESH_CLASS	MR::TaggedBitSet

template<typename T >
class MRMESH_CLASS	MR::SetBitIteratorT

template<typename T >
struct MRMESH_CLASS	MR::Vector2

template<typename T >
struct MRMESH_CLASS	MR::Vector3

template<typename T , typename I >
struct MRMESH_CLASS	MR::BMap

class MRMESH_CLASS	MR::MeshTopology

struct MRMESH_CLASS	MR::Mesh

struct MRMESH_CLASS	MR::MeshPart

class MRMESH_CLASS	MR::MeshOrPoints

struct MRMESH_CLASS	MR::PointCloud

class MRMESH_CLASS	MR::AABBTree

class MRMESH_CLASS	MR::AABBTreePoints

struct MRMESH_CLASS	MR::CloudPartMapping

struct MRMESH_CLASS	MR::PartMapping

template<typename V >
class MRMESH_CLASS	MR::AABBTreePolyline

class MRMESH_CLASS	MR::ChangeSceneAction

template<typename Tag >
class MRMESH_CLASS	MR::ColorMapAggregator

template<typename... >
constexpr bool	MR::dependent_false = false

Macro Definition Documentation

◆ MR_UNREACHABLE

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

◆ MR_UNREACHABLE_NO_RETURN

#define MR_UNREACHABLE_NO_RETURN assert( false );

◆ MRMESH_API

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

◆ MRMESH_CLASS

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

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ MR_UNREACHABLE

◆ MR_UNREACHABLE_NO_RETURN

◆ MRMESH_API

◆ MRMESH_CLASS