Classes | |
| struct | _Underlying |
Public Member Functions | |
| virtual void | Dispose () |
| unsafe | Const_DecimateSettings () |
| Constructs an empty (default-constructed) instance. | |
| unsafe | Const_DecimateSettings (MR.DecimateStrategy strategy, float maxError, float maxEdgeLen, float maxBdShift, float maxTriangleAspectRatio, float criticalTriAspectRatio, bool preventNormalFlips, float tinyEdgeLength, float stabilizer, bool angleWeightedDistToPlane, bool optimizeVertexPos, int maxDeletedVertices, int maxDeletedFaces, MR.FaceBitSet? region, MR.UndirectedEdgeBitSet? notFlippable, bool collapseNearNotFlippable, MR.UndirectedEdgeBitSet? edgesToCollapse, MR.Phmap.FlatHashMap_MRUndirectedEdgeId_MRUndirectedEdgeId_PhmapHashMRUndirectedEdgeId_PhmapEqualToMRUndirectedEdgeId_MRAllocatorStdPairConstMRUndirectedEdgeIdMRUndirectedEdgeId? twinMap, bool touchNearBdEdges, bool touchBdVerts, MR.VertBitSet? bdVerts, MR.Const_UndirectedEdgeBitSet? regionEdges, float maxAngleChange, MR.Std._ByValue_Function_Bool_From_MREdgeId_ConstMRVector3fRef preCollapse, MR.Std._ByValue_Function_Void_From_MRUndirectedEdgeId_FloatRef_MRVector3fRef adjustCollapse, MR.Std._ByValue_Function_Void_From_MREdgeId_MREdgeId onEdgeDel, MR.Vector_MRQuadraticForm3f_MRVertId? vertForms, bool packMesh, MR.Std._ByValue_Function_Bool_From_Float progressCallback, int subdivideParts, MR.DecimatePartsMode partsMode, bool decimateBetweenParts, MR.Std.Vector_MRFaceBitSet? partFaces, int minFacesInPart) |
| Constructs MR.DecimateSettings elementwise. | |
| unsafe | Const_DecimateSettings (MR._ByValue_DecimateSettings _other) |
| Generated from constructor MR.DecimateSettings.DecimateSettings. | |
| Const_DecimateSettings (Const_DecimateSettings _other) | |
| Generated from constructor MR.DecimateSettings.DecimateSettings. | |
| Const_DecimateSettings (DecimateSettings _other) | |
| Generated from constructor MR.DecimateSettings.DecimateSettings. | |
Protected Member Functions | |
| virtual unsafe void | Dispose (bool disposing) |
Protected Attributes | |
| unsafe MR.DecimateStrategy * | __ref_storage_strategy |
| unsafe float * | __ref_storage_maxError |
| unsafe float * | __ref_storage_maxEdgeLen |
| unsafe float * | __ref_storage_maxBdShift |
| unsafe float * | __ref_storage_maxTriangleAspectRatio |
| unsafe float * | __ref_storage_criticalTriAspectRatio |
| unsafe bool * | __ref_storage_preventNormalFlips |
| unsafe float * | __ref_storage_tinyEdgeLength |
| unsafe float * | __ref_storage_stabilizer |
| unsafe bool * | __ref_storage_angleWeightedDistToPlane |
| unsafe bool * | __ref_storage_optimizeVertexPos |
| unsafe int * | __ref_storage_maxDeletedVertices |
| unsafe int * | __ref_storage_maxDeletedFaces |
| unsafe MR.FaceBitSet._Underlying ** | __ptr_storage_region |
| unsafe MR.UndirectedEdgeBitSet._Underlying ** | __ptr_storage_notFlippable |
| unsafe bool * | __ref_storage_collapseNearNotFlippable |
| unsafe MR.UndirectedEdgeBitSet._Underlying ** | __ptr_storage_edgesToCollapse |
| unsafe MR.Phmap.FlatHashMap_MRUndirectedEdgeId_MRUndirectedEdgeId_PhmapHashMRUndirectedEdgeId_PhmapEqualToMRUndirectedEdgeId_MRAllocatorStdPairConstMRUndirectedEdgeIdMRUndirectedEdgeId._Underlying ** | __ptr_storage_twinMap |
| unsafe bool * | __ref_storage_touchNearBdEdges |
| unsafe bool * | __ref_storage_touchBdVerts |
| unsafe MR.VertBitSet._Underlying ** | __ptr_storage_bdVerts |
| unsafe MR.Const_UndirectedEdgeBitSet._Underlying ** | __ptr_storage_regionEdges |
| unsafe float * | __ref_storage_maxAngleChange |
| unsafe MR.Vector_MRQuadraticForm3f_MRVertId._Underlying ** | __ptr_storage_vertForms |
| unsafe bool * | __ref_storage_packMesh |
| unsafe int * | __ref_storage_subdivideParts |
| unsafe MR.DecimatePartsMode * | __ref_storage_partsMode |
| unsafe bool * | __ref_storage_decimateBetweenParts |
| unsafe MR.Std.Vector_MRFaceBitSet._Underlying ** | __ptr_storage_partFaces |
| unsafe int * | __ref_storage_minFacesInPart |
Properties | |
| unsafe MR.DecimateStrategy | strategy [get] |
| unsafe float | maxError [get] |
| for DecimateStrategy.MinimizeError: stop the decimation as soon as the estimated distance deviation from the original mesh is more than this value for DecimateStrategy.ShortestEdgeFirst only: stop the decimation as soon as the shortest edge in the mesh is greater than this value | |
| unsafe float | maxEdgeLen [get] |
| Maximal possible edge length created during decimation. | |
| unsafe float | maxBdShift [get] |
| Maximal shift of a boundary during one edge collapse. | |
| unsafe float | maxTriangleAspectRatio [get] |
| Maximal possible aspect ratio of a triangle introduced during decimation. | |
| unsafe float | criticalTriAspectRatio [get] |
| the algorithm will ignore dihedral angle check if one of triangles had aspect ratio equal or more than this value; and the algorithm will permit temporary increase in aspect ratio after collapse, if before collapse one of the triangles had larger aspect ratio | |
| unsafe bool | preventNormalFlips [get] |
| whether to prohibit a collapse if it inverts the normal of a remaining triangle, or folds two triangles onto each other; turning it off (together with maxTriangleAspectRatio = FLT_MAX) makes decimation faster, but some triangles may appear inverted | |
| unsafe float | tinyEdgeLength [get] |
| edges not longer than this value will be collapsed even if it results in appearance of a triangle with high aspect ratio | |
| unsafe float | stabilizer [get] |
| Small stabilizer is important to achieve good results on completely planar mesh parts, if your mesh is not-planer everywhere, then you can set it to zero. | |
| unsafe bool | angleWeightedDistToPlane [get] |
| if false, then quadratic error metric is equal to the sum of distances to the planes of original mesh triangles; if true, then the sum is weighted, and the weight is equal to the angle of adjacent triangle at the vertex divided on PI (to get one after summing all 3 vertices of the triangle) | |
| unsafe bool | optimizeVertexPos [get] |
| if true then after each edge collapse the position of remaining vertex is optimized to minimize local shape change, if false then the edge is collapsed in one of its vertices, which keeps its position | |
| unsafe int | maxDeletedVertices [get] |
| Limit on the number of deleted vertices. | |
| unsafe int | maxDeletedFaces [get] |
| Limit on the number of deleted faces. | |
| unsafe MR.? FaceBitSet | region [get] |
| Region on mesh to be decimated, it is updated during the operation. | |
| unsafe MR.? UndirectedEdgeBitSet | notFlippable [get] |
| Edges specified by this bit-set will never be flipped, but they can be collapsed or replaced during collapse of nearby edges so it is updated during the operation. | |
| unsafe bool | collapseNearNotFlippable [get] |
| Whether to allow collapse of edges incident to notFlippable edges, which can move vertices of notFlippable edges unless they are fixed. | |
| unsafe MR.? UndirectedEdgeBitSet | edgesToCollapse [get] |
| If pointer is not null, then only edges from here can be collapsed (and some nearby edges can disappear); the algorithm updates this map during collapses, removing or replacing elements. | |
| unsafe MR.Phmap.? FlatHashMap_MRUndirectedEdgeId_MRUndirectedEdgeId_PhmapHashMRUndirectedEdgeId_PhmapEqualToMRUndirectedEdgeId_MRAllocatorStdPairConstMRUndirectedEdgeIdMRUndirectedEdgeId | twinMap [get] |
| if an edge present as a key in this map is flipped or collapsed, then same happens to the value-edge (with same collapse position); the algorithm updates this map during collapses, removing or replacing elements | |
| unsafe bool | touchNearBdEdges [get] |
| Whether to allow collapsing or flipping edges having at least one vertex on (region) boundary. | |
| unsafe bool | touchBdVerts [get] |
| touchBdVerts=true: allow moving and eliminating boundary vertices during edge collapses; touchBdVerts=false: allow only collapsing an edge having only one boundary vertex in that vertex, so position and count of boundary vertices do not change; this setting is ignored if touchNearBdEdges=false | |
| unsafe MR.? VertBitSet | bdVerts [get] |
| if touchNearBdEdges=false or touchBdVerts=false then the algorithm needs to know about all boundary vertices; if the pointer is not null then boundary vertices detection is replaced with testing values in this bit-set; the algorithm updates this set if it packs the mesh | |
| unsafe MR.? Const_UndirectedEdgeBitSet | regionEdges [get] |
| if region is not null and this pointer is not null, then it shall contain all edges incident to region faces (as returned by getIncidentEdges( topology, *region )), and the algorithm does not compute them itself | |
| unsafe float | maxAngleChange [get] |
| Permit edge flips (in addition to collapsing) to improve Delone quality of the mesh if it does not change dihedral angle more than on this value (negative value prohibits any edge flips) | |
| unsafe MR.Std.Const_Function_Bool_From_MREdgeId_ConstMRVector3fRef | preCollapse [get, protected set] |
| The user can provide this optional callback that is invoked immediately before edge collapse;. | |
| unsafe MR.Std.Const_Function_Void_From_MRUndirectedEdgeId_FloatRef_MRVector3fRef | adjustCollapse [get, protected set] |
| The user can provide this optional callback for adjusting error introduced by this edge collapse and the collapse position. | |
| unsafe MR.Std.Const_Function_Void_From_MREdgeId_MREdgeId | onEdgeDel [get, protected set] |
| this function is called each time edge (del) is deleted; if valid (rem) is given then dest(del) = dest(rem) and their origins are in different ends of collapsing edge, (rem) shall take the place of (del) | |
| unsafe MR.? Vector_MRQuadraticForm3f_MRVertId | vertForms [get] |
| If not null, then vertex quadratic forms are stored there; if on input the vector is not empty then initialization is skipped in favor of values from there; on output: quadratic form for each remaining vertex is returned there. | |
| unsafe bool | packMesh [get] |
| whether to pack mesh at the end | |
| unsafe MR.Std.Const_Function_Bool_From_Float | progressCallback [get, protected set] |
| callback to report algorithm progress and cancel it by user request | |
| unsafe int | subdivideParts [get] |
| If this value is more than 1, then virtually subdivides the mesh on given number of parts to process them in parallel (using many threads); IMPORTANT: with default partsMode, please call mesh.packOptimally() before calling decimating with subdivideParts > 1, otherwise performance will be bad. | |
| unsafe MR.DecimatePartsMode | partsMode [get] |
| how the parts are found for subdivideParts > 1; ignored if partFaces is given | |
| unsafe bool | decimateBetweenParts [get] |
| Whether to decimate near the borders of individual parts to eliminate small edges there: as soon as two sibling nodes in the binary tree of parts are decimated, their union is decimated in parallel with other nodes, and only the border between two halves of the mesh remains for the final decimation of whole mesh region. | |
| unsafe MR.Std.? Vector_MRFaceBitSet | partFaces [get] |
| if not null, then it contains the faces of each subdivision part on input, which must not overlap, and after decimation of all parts, the region inside each part is put here; decimateBetweenParts=true or packMesh=true are not compatible with this option | |
| unsafe int | minFacesInPart [get] |
| minimum number of faces in one subdivision part for ( subdivideParts > 1 ) mode | |
|
inline |
Constructs an empty (default-constructed) instance.
|
inline |
Constructs MR.DecimateSettings elementwise.
|
inline |
Generated from constructor MR.DecimateSettings.DecimateSettings.
|
inline |
Generated from constructor MR.DecimateSettings.DecimateSettings.
|
inline |
Generated from constructor MR.DecimateSettings.DecimateSettings.
|
inlinevirtual |
|
inlineprotectedvirtual |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
getprotected set |
The user can provide this optional callback for adjusting error introduced by this edge collapse and the collapse position.
On input the callback gets the squared error and position computed by standard means, and callback can modify any of them. The larger the error, the later this edge will be collapsed. This callback can be called from many threads in parallel and must be thread-safe. This callback can be called many times for each edge before real collapsing, and it is important to make the same adjustment.
|
get |
if false, then quadratic error metric is equal to the sum of distances to the planes of original mesh triangles; if true, then the sum is weighted, and the weight is equal to the angle of adjacent triangle at the vertex divided on PI (to get one after summing all 3 vertices of the triangle)
|
get |
if touchNearBdEdges=false or touchBdVerts=false then the algorithm needs to know about all boundary vertices; if the pointer is not null then boundary vertices detection is replaced with testing values in this bit-set; the algorithm updates this set if it packs the mesh
|
get |
Whether to allow collapse of edges incident to notFlippable edges, which can move vertices of notFlippable edges unless they are fixed.
|
get |
the algorithm will ignore dihedral angle check if one of triangles had aspect ratio equal or more than this value; and the algorithm will permit temporary increase in aspect ratio after collapse, if before collapse one of the triangles had larger aspect ratio
|
get |
Whether to decimate near the borders of individual parts to eliminate small edges there: as soon as two sibling nodes in the binary tree of parts are decimated, their union is decimated in parallel with other nodes, and only the border between two halves of the mesh remains for the final decimation of whole mesh region.
|
get |
If pointer is not null, then only edges from here can be collapsed (and some nearby edges can disappear); the algorithm updates this map during collapses, removing or replacing elements.
|
get |
Permit edge flips (in addition to collapsing) to improve Delone quality of the mesh if it does not change dihedral angle more than on this value (negative value prohibits any edge flips)
|
get |
Maximal shift of a boundary during one edge collapse.
|
get |
Limit on the number of deleted faces.
|
get |
Limit on the number of deleted vertices.
|
get |
Maximal possible edge length created during decimation.
|
get |
for DecimateStrategy.MinimizeError: stop the decimation as soon as the estimated distance deviation from the original mesh is more than this value for DecimateStrategy.ShortestEdgeFirst only: stop the decimation as soon as the shortest edge in the mesh is greater than this value
|
get |
Maximal possible aspect ratio of a triangle introduced during decimation.
|
get |
minimum number of faces in one subdivision part for ( subdivideParts > 1 ) mode
|
get |
Edges specified by this bit-set will never be flipped, but they can be collapsed or replaced during collapse of nearby edges so it is updated during the operation.
|
getprotected set |
this function is called each time edge (del) is deleted; if valid (rem) is given then dest(del) = dest(rem) and their origins are in different ends of collapsing edge, (rem) shall take the place of (del)
|
get |
if true then after each edge collapse the position of remaining vertex is optimized to minimize local shape change, if false then the edge is collapsed in one of its vertices, which keeps its position
|
get |
whether to pack mesh at the end
|
get |
if not null, then it contains the faces of each subdivision part on input, which must not overlap, and after decimation of all parts, the region inside each part is put here; decimateBetweenParts=true or packMesh=true are not compatible with this option
|
get |
how the parts are found for subdivideParts > 1; ignored if partFaces is given
|
getprotected set |
The user can provide this optional callback that is invoked immediately before edge collapse;.
It receives the edge being collapsed: its destination vertex will disappear, and its origin vertex will get new position (provided as the second argument) after collapse; If the callback returns false, then the collapse is prohibited
|
get |
whether to prohibit a collapse if it inverts the normal of a remaining triangle, or folds two triangles onto each other; turning it off (together with maxTriangleAspectRatio = FLT_MAX) makes decimation faster, but some triangles may appear inverted
|
getprotected set |
callback to report algorithm progress and cancel it by user request
|
get |
Region on mesh to be decimated, it is updated during the operation.
|
get |
if region is not null and this pointer is not null, then it shall contain all edges incident to region faces (as returned by getIncidentEdges( topology, *region )), and the algorithm does not compute them itself
|
get |
Small stabilizer is important to achieve good results on completely planar mesh parts, if your mesh is not-planer everywhere, then you can set it to zero.
|
get |
|
get |
If this value is more than 1, then virtually subdivides the mesh on given number of parts to process them in parallel (using many threads); IMPORTANT: with default partsMode, please call mesh.packOptimally() before calling decimating with subdivideParts > 1, otherwise performance will be bad.
|
get |
edges not longer than this value will be collapsed even if it results in appearance of a triangle with high aspect ratio
|
get |
touchBdVerts=true: allow moving and eliminating boundary vertices during edge collapses; touchBdVerts=false: allow only collapsing an edge having only one boundary vertex in that vertex, so position and count of boundary vertices do not change; this setting is ignored if touchNearBdEdges=false
|
get |
Whether to allow collapsing or flipping edges having at least one vertex on (region) boundary.
|
get |
if an edge present as a key in this map is flipped or collapsed, then same happens to the value-edge (with same collapse position); the algorithm updates this map during collapses, removing or replacing elements
|
get |
If not null, then vertex quadratic forms are stored there; if on input the vector is not empty then initialization is skipped in favor of values from there; on output: quadratic form for each remaining vertex is returned there.