|
| using | MR::EdgePath = std::vector<EdgeId> |
| using | MR::EdgeLoop = std::vector<EdgeId> |
| using | MR::EdgeLoops = std::vector<EdgeLoop> |
| template<typename T> |
| using | MR::AffineXf3 = AffineXf<Vector3<T>> |
| template<typename T> |
| using | MR::AffineXf2OrPlaceholder = typename detail::AffineXf3f::TypeOrPlaceholder<Vector2<T>>::type |
| template<typename T> |
| using | MR::AffineXf3OrPlaceholder = typename detail::AffineXf3f::TypeOrPlaceholder<Vector3<T>>::type |
| template<typename T> |
| using | MR::Sphere3 = Sphere<Vector3<T>> |
| template<typename T> |
| using | MR::Line3 = Line<Vector3<T>> |
| template<typename T> |
| using | MR::LineSegm3 = LineSegm<Vector3<T>> |
| 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> |
| template<typename T> |
| using | MR::MinMax = Box<T> |
| using | MR::MinMaxf = MinMax<float> |
| using | MR::MinMaxd = MinMax<double> |
| using | MR::MinMaxi = MinMax<int> |
| template<typename T> |
| using | MR::Box1 = Box<T> |
| template<typename T> |
| using | MR::Box2 = Box<Vector2<T>> |
| template<typename T> |
| using | MR::Box3 = Box<Vector3<T>> |
| template<typename T> |
| using | MR::Ball2 = Ball<Vector2<T>> |
| template<typename T> |
| using | MR::Ball3 = Ball<Vector3<T>> |
| template<typename T> |
| using | MR::CubicBezierCurve3 = CubicBezierCurve<Vector3<T>> |
| template<typename T> |
| using | MR::QuadraticForm3 = QuadraticForm<Vector3<T>> |
| using | MR::Triangle3i = Triangle3<int> |
| using | MR::Triangle3f = Triangle3<float> |
| using | MR::Triangle3d = Triangle3<double> |
| using | MR::EdgeSegmentf = EdgeSegmentT<float> |
| using | MR::MeshEdgePoint = EdgePoint |
| template<typename T> |
| using | MR::MeshEdgePointT = EdgePointT<T> |
| using | MR::MeshEdgePointf = EdgePointf |
| using | MR::MeshEdgePointd = EdgePointd |
| 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::VertPair = std::pair<VertId, VertId> |
| using | MR::FacePair = std::pair<FaceId, FaceId> |
| using | MR::EdgePair = std::pair<EdgeId, EdgeId> |
| using | MR::UndirectedEdgePair = std::pair<UndirectedEdgeId, UndirectedEdgeId> |
| using | MR::UVCoord = Vector2f |
| using | MR::TwoVertIds = std::array<VertId, 2> |
| | two vertex ids describing an edge with the ends in vertices given by their ids
|
| using | MR::ThreeVertIds = std::array<VertId, 3> |
| | three vertex ids describing a triangle with the corners in vertices given by their ids
|
| using | MR::ThreeUVCoords = std::array<UVCoord, 3> |
| | three UV-coordinates describing texturing of a triangle
|
| using | MR::FacePredicate = std::function<bool( FaceId )> |
| using | MR::EdgePredicate = std::function<bool( EdgeId )> |
| using | MR::UndirectedEdgePredicate = std::function<bool( UndirectedEdgeId )> |
| using | MR::PreCollapseCallback = std::function<bool( EdgeId edgeToCollapse, const Vector3f& newEdgeOrgPos )> |
| using | MR::OnEdgeSplit = std::function<void( EdgeId e1, EdgeId e )> |
| 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 )> |
| 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, Allocator<T>> |
| 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, Allocator<T>> |
| using | MR::FaceHashSet = HashSet<FaceId> |
| | No canonical typedefs because phmap::... is not under our control.
|
| 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, Allocator<std::pair<const K, V>>> |
| 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, Allocator<std::pair<const K, V>>> |
| 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::FaceMapOrHashMap = MapOrHashMap<FaceId, FaceId> |
| using | MR::VertMapOrHashMap = MapOrHashMap<VertId, VertId> |
| using | MR::EdgeMapOrHashMap = MapOrHashMap<EdgeId, EdgeId> |
| using | MR::UndirectedEdgeMapOrHashMap = MapOrHashMap<UndirectedEdgeId, UndirectedEdgeId> |
| using | MR::WholeEdgeMapOrHashMap = MapOrHashMap<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::GcodeSource = std::vector<std::string> |
| typedef std::function< bool(float)> | MR::ProgressCallback |
|
| | MR::Id< EdgeTag > (UndirectedEdgeId, Id< UndirectedEdgeTag >)(FaceId |
| | MR::Id< FaceTag > (VertId, Id< VertTag >)(PixelId |
| | MR::Id< PixelTag > (VoxelId, Id< VoxelTag >)(RegionId |
| | MR::Id< RegionTag > (NodeId, Id< NodeTag >)(ObjId |
| | MR::Id< ObjTag > (TextureId, Id< TextureTag >)(GraphVertId |
| | MR::Id< GraphVertTag > (GraphEdgeId, Id< GraphEdgeTag >)(LocaleDomainId |
| | MR::TypedBitSet< FaceId > (VertBitSet, TypedBitSet< VertId >)(EdgeBitSet |
| | MR::TypedBitSet< EdgeId > (UndirectedEdgeBitSet, TypedBitSet< UndirectedEdgeId >)(PixelBitSet |
| | MR::TypedBitSet< PixelId > (VoxelBitSet, TypedBitSet< VoxelId >)(RegionBitSet |
| | MR::TypedBitSet< RegionId > (NodeBitSet, TypedBitSet< NodeId >)(ObjBitSet |
| | MR::TypedBitSet< ObjId > (TextureBitSet, TypedBitSet< TextureId >)(GraphVertBitSet |
| | MR::TypedBitSet< GraphVertId > (GraphEdgeBitSet, TypedBitSet< GraphEdgeId >)) template< typename T > using TaggedBitSet |
| | MR::SetBitIteratorT< BitSet > (FaceSetBitIterator, SetBitIteratorT< FaceBitSet >)(VertSetBitIterator |
| | MR::SetBitIteratorT< VertBitSet > (EdgeSetBitIterator, SetBitIteratorT< EdgeBitSet >)(UndirectedEdgeSetBitIterator |
| | MR::Vector2< bool > (Vector2i, Vector2< int >)(Vector2i64 |
| | MR::Vector2< double > ((template< typename T > struct), Vector3,(Vector3b, Vector3< bool >)(Vector3i, Vector3< int >)(Vector3i64, Vector3< std::int64_t >)(Vector3f, Vector3< float >)(Vector3d, Vector3< double >)) 1((template< typename T > struct) |
| | MR::Vector4< bool > (Vector4i, Vector4< int >)(Vector4i64 |
| | MR::Matrix2< bool > (Matrix2i, Matrix2< int >)(Matrix2i64 |
| | MR::Matrix3< bool > (Matrix3i, Matrix3< int >)(Matrix3i64 |
| | MR::Matrix4< bool > (Matrix4i, Matrix4< int >)(Matrix4i64 |
| | MR::SymMatrix2< bool > (SymMatrix2i, SymMatrix2< int >)(SymMatrix2i64 |
| | MR::SymMatrix3< bool > (SymMatrix3i, SymMatrix3< int >)(SymMatrix3i64 |
| | MR::SymMatrix4< bool > (SymMatrix4i, SymMatrix4< int >)(SymMatrix4i64 |
| | MR::AffineXf< Vector2< float > > (AffineXf2d, AffineXf< Vector2< double > >)(AffineXf3f |
| | MR::AffineXf< Vector3< float > > (AffineXf3d, AffineXf< Vector3< double > >)) template< typename T > using AffineXf2 |
| | MR::RigidXf3< float > (RigidXf3d, RigidXf3< double >)) 1((template< typename T > struct) |
| | MR::RigidScaleXf3< float > (RigidScaleXf3d, RigidScaleXf3< double >)) class PointToPointAligningTransform |
| | MR::Sphere< Vector2< float > > (Sphere2d, Sphere< Vector2< double > >)(Sphere3f |
| | MR::Sphere< Vector3< float > > (Sphere3d, Sphere< Vector3< double > >)) template< typename T > using Sphere2 |
| | MR::Line< Vector2< float > > (Line2d, Line< Vector2< double > >)(Line3f |
| | MR::Line< Vector3< float > > (Line3d, Line< Vector3< double > >)) template< typename T > using Line2 |
| | MR::LineSegm< Vector2< float > > (LineSegm2d, LineSegm< Vector2< double > >)(LineSegm3f |
| | MR::LineSegm< Vector3< float > > (LineSegm3d, LineSegm< Vector3< double > >)) template< typename T > using LineSegm2 |
| | MR::Parabola< float > (Parabolad, Parabola< double >)) 1((template< typename T > class) |
| | MR::BestFitParabola< float > (BestFitParabolad, BestFitParabola< double >)) 1((template< typename T > class) |
| | MR::Cylinder3< float > (Cylinder3d, Cylinder3< double >)) 1((template< typename T > class) |
| | MR::Cone3< float > (Cone3d, Cone3< double >)) template< typename V > using Contour |
| | No canonical typedefs here, because those ultimately boil to std::vector, which isn't under our control.
|
| | MR::Plane3< float > (Plane3d, Plane3< double >)) 1((template< typename V > struct) |
| | MR::Box< int > (Box1i64, Box< std::int64_t >)(Box1f |
| | MR::Box< float > (Box1d, Box< double >)(Box2i |
| | MR::Box< Vector2< int > > (Box2i64, Box< Vector2< std::int64_t > >)(Box2f |
| | MR::Box< Vector2< float > > (Box2d, Box< Vector2< double > >)(Box3i |
| | MR::Box< Vector3< int > > (Box3i64, Box< Vector3< std::int64_t > >)(Box3f |
| | MR::Box< Vector3< float > > (Box3d, Box< Vector3< double > >)) using Box1ll |
| | MR::Ball< float > (Ball1d, Ball< double >)(Ball2f |
| | MR::Ball< Vector2< float > > (Ball2d, Ball< Vector2< double > >)(Ball3f |
| | MR::Ball< Vector3< float > > (Ball3d, Ball< Vector3< double > >)) template< typename T > using Ball1 |
| | MR::CubicBezierCurve< Vector2< float > > (CubicBezierCurve2d, CubicBezierCurve< Vector2< double > >)(CubicBezierCurve3f |
| | MR::CubicBezierCurve< Vector3< float > > (CubicBezierCurve3d, CubicBezierCurve< Vector3< double > >)) template< typename T > using CubicBezierCurve2 |
| | MR::QuadraticForm< Vector2< float > > (QuadraticForm2d, QuadraticForm< Vector2< double > >)(QuadraticForm3f |
| | MR::QuadraticForm< Vector3< float > > (QuadraticForm3d, QuadraticForm< Vector3< double > >)) template< typename T > using QuadraticForm2 |
| | MR::Quaternion< float > (Quaterniond, Quaternion< double >)) template< typename T > using Triangle3 |
| | No canonical typedefs because std::array is not under our control.
|
| | MR::SegmPoint< float > (SegmPointd, SegmPoint< double >)) 1((template< typename T > struct) |
| | MR::EdgePointT< float > (EdgePointd, EdgePointT< double >)) 1((template< typename T > struct) |
| | MR::EdgeSegmentT< float > (EdgeSegmentd, EdgeSegmentT< double >)) using EdgePointf |
| | MR::TriPoint< float > (TriPointd, TriPoint< double >)) struct FaceFace |
| | MR::MeshTriPointT< float > (MeshTriPointd, MeshTriPointT< double >)) using MeshTriPointf |
| | MR::WeightedVertexT< float > (WeightedVertexd, WeightedVertexT< double >)) using WeightedVertexf |
| | MR::Vector< TwoVertIds, UndirectedEdgeId > (Triangulation, Vector< ThreeVertIds, FaceId >)(TriCornerUVCoords |
| | mapping from FaceId to a triple of vertex indices
|
| | MR::Vector< ThreeUVCoords, FaceId > (Dipoles, Vector< Dipole, NodeId >)(FaceMap |
| | MR::Vector< FaceId, FaceId > (VertMap, Vector< VertId, VertId >)(EdgeMap |
| | MR::Vector< EdgeId, EdgeId > (UndirectedEdgeMap, Vector< UndirectedEdgeId, UndirectedEdgeId >)(ObjMap |
| | MR::Vector< ObjId, ObjId > (WholeEdgeMap, Vector< EdgeId, UndirectedEdgeId >)(UndirectedEdge2RegionMap |
| | mapping of whole edges: map[e]->f, map[e.sym()]->f.sym(), where only map[e] for even edges is stored
|
| | MR::Vector< RegionId, UndirectedEdgeId > (Face2RegionMap, Vector< RegionId, FaceId >)(Vert2RegionMap |
| | MR::Vector< RegionId, VertId > (VertCoords, Vector< Vector3f, VertId >)(VertCoords2 |
| | MR::Vector< Vector2f, VertId > (VertNormals, Vector< Vector3f, VertId >)(VertUVCoords |
| | MR::Vector< UVCoord, VertId > (FaceNormals, Vector< Vector3f, FaceId >)(TexturePerFace |
| | MR::Vector< TextureId, FaceId > (VertColors, Vector< Color, VertId >)(FaceColors |
| | MR::Vector< Color, FaceId > (EdgeColors, Vector< Color, EdgeId >)(UndirectedEdgeColors |
| | MR::Vector< Color, UndirectedEdgeId > (VertScalars, Vector< float, VertId >)(FaceScalars |
| | MR::Vector< float, FaceId > (EdgeScalars, Vector< float, EdgeId >)(UndirectedEdgeScalars |
| | MR::Vector< float, UndirectedEdgeId > (VoxelScalars, Vector< float, VoxelId >)) using VertPredicate |
| template<typename T> |
| bool | MR::contains (const std::function< bool(Id< T >)> &pred, Id< T > id) |
| | MR::BMap< FaceId, FaceId > (VertBMap, BMap< VertId, VertId >)(EdgeBMap |
| | MR::BMap< EdgeId, EdgeId > (UndirectedEdgeBMap, BMap< UndirectedEdgeId, UndirectedEdgeId >)(WholeEdgeBMap |
| | MR::MeshRegion< FaceTag > (MeshVertPart, MeshRegion< VertTag >)) template< typename T > class UniqueThreadSafeOwner |
| | MR::Polyline< Vector2f > (Polyline3, Polyline< Vector3f >)) 1((template< typename V > class) |
| | MR::AABBTreePolyline< Vector2f > (AABBTreePolyline3, AABBTreePolyline< Vector3f >)) template< typename T > struct IntersectionPrecomputes |
| | MR::PolylineProjectionResult< Vector2f > (PolylineProjectionResult3, PolylineProjectionResult< Vector3f >)) 1((template< typename V > struct) |
| | MR::PolylineProjectionWithOffsetResult< Vector2f > (PolylineProjectionWithOffsetResult3, PolylineProjectionWithOffsetResult< Vector3f >)) class DistanceMap |
| | MR::ColorMapAggregator< VertTag > (UndirEdgeColorMapAggregator, ColorMapAggregator< UndirectedEdgeTag >)(FaceColorMapAggregator |
| template<typename T> |
| constexpr auto | MR::sqr (T x) noexcept -> decltype(x *x) |
| | squared value; the result type is the type of x*x, which is int for small integer types (char, short)
|
| template<typename T> |
| constexpr int | MR::sgn (T x) noexcept |
| | sign of given value in { -1, 0, 1 }
|
| template<typename T> |
| constexpr T | MR::distance (T x, T y) noexcept |
| | absolute difference between two value
|
| template<typename T> |
| constexpr auto | MR::distanceSq (T x, T y) noexcept -> decltype((x - y) *(x - y)) |
| template<typename V, typename T> |
| constexpr auto | MR::lerp (V v0, V v1, T t) noexcept |
| | Linear interpolation: returns v0 when t==0 and v1 when t==1.
|
| template<class... Ts> |
| | MR::overloaded (Ts...) -> overloaded< Ts... > |
| | explicit deduction guide (not needed as of C++20, but still needed in Clang)
|
| constexpr auto | MR::Locale::translate_noop (const char *str) noexcept |
| | special no-op inline functions to mark string literal as translatable
|
| constexpr auto | MR::Locale::translate_noop (const char *ctx, const char *str) noexcept |
| constexpr auto | MR::Locale::translate_noop (const char *single, const char *plural, std::int64_t n) noexcept |
| constexpr auto | MR::Locale::translate_noop (const char *ctx, const char *single, const char *plural, std::int64_t n) noexcept |