Classes
class	AABBTree

class	AABBTreeBase_AABBTreeTraits_FaceTag_Box3f

class	AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f

class	AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f

class	AABBTreeBase_ObjTreeTraits

class	AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

class	AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

class	AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

class	AABBTreeNode_ObjTreeTraits

class	AABBTreeObjects

class	AABBTreePoints

class	AABBTreePolyline2

class	AABBTreePolyline3

class	AABBTreeTraits_FaceTag_Box3f

class	AABBTreeTraits_UndirectedEdgeTag_Box2f

class	AABBTreeTraits_UndirectedEdgeTag_Box3f

class	AddVisualProperties_FeatureObject_DimensionsVisualizePropertyType_diameter

class	AddVisualProperties_FeatureObject_DimensionsVisualizePropertyType_diameter_DimensionsVisualizePropertyType_angle_DimensionsVisualizePropertyType_length

class	AddVisualProperties_FeatureObject_DimensionsVisualizePropertyType_diameter_DimensionsVisualizePropertyType_length

class	AffineXf2d

class	AffineXf2f

class	AffineXf3d

class	AffineXf3f

class	AffineXf_Vector3b

class	AffineXf_Vector3i

class	AffineXf_Vector3ll

class	AlignType

class	AllLocalTriangulations

class	AngleMeasurementObject

class	AnyVisualizeMaskEnum

class	ArcInterpolationParams

class	ArcPlane

class	Axis

class	Ball

class	BaseRenderParams

class	BaseShellParameters

class	BaseTiffParameters

class	BasicUiRenderTask

class	BasinVolumeCalculator

class	BestFitParabolad

class	BestFitParabolaf

class	BitSet

class	BMap_FaceId_unsigned_long

class	BMap_GraphEdgeId_GraphEdgeId

class	BMap_GraphVertId_GraphVertId

class	BMap_Id_ICPElemtTag_Id_ICPElemtTag

class	BMap_Id_VoxelTag_Id_VoxelTag

class	BMap_NodeId_NodeId

class	BMap_ObjId_ObjId

class	BMap_PixelId_PixelId

class	BMap_RegionId_RegionId

class	BMap_TextureId_TextureId

class	BMap_UndirectedEdgeId_unsigned_long

class	BMap_VertId_unsigned_long

class	bool_output

class	BooleanInternalParameters

class	BooleanOperation

class	BooleanParameters

class	BooleanPreCutResult

class	BooleanResult

class	BooleanResultMapper

class	BooleanResultPoints

class	Box1d

class	Box1f

class	Box1i

class	Box1ll

class	Box2d

class	Box2f

class	Box2i

class	Box2ll

class	Box3d

class	Box3f

class	Box3i

class	Box3ll

class	Box_unsigned_short

class	Buffer_char

class	Buffer_FaceId

class	Buffer_FaceId_FaceId

class	Buffer_GraphEdgeId_GraphEdgeId

class	Buffer_GraphVertId_GraphVertId

class	Buffer_Id_EdgeTag_Id_EdgeTag

class	Buffer_Id_EdgeTag_UndirectedEdgeId

class	Buffer_Id_ICPElemtTag_Id_ICPElemtTag

class	Buffer_Id_VoxelTag_Id_VoxelTag

class	Buffer_NodeId_NodeId

class	Buffer_ObjId_ObjId

class	Buffer_PixelId_PixelId

class	Buffer_RegionId_RegionId

class	Buffer_TextureId_TextureId

class	Buffer_UndirectedEdgeId

class	Buffer_UndirectedEdgeId_UndirectedEdgeId

class	Buffer_unsigned_char

class	Buffer_VertId

class	Buffer_VertId_VertId

class	BypassDirection

class	ChangeActiveBoxAction

class	ChangeColoringType

class	ChangeDualMarchingCubesAction

class	ChangeFacesColorMapAction

class	ChangeGridAction

class	ChangeIsoAction

class	ChangeLabelAction

class	ChangeLinesColorMapAction

class	ChangeMeshAction

class	ChangeMeshCreasesAction

class	ChangeMeshEdgeSelectionAction

class	ChangeMeshFaceSelectionAction

class	ChangeMeshPointsAction

class	ChangeMeshTexturePerFaceAction

class	ChangeMeshTopologyAction

class	ChangeMeshUVCoordsAction

class	ChangeNameAction

class	ChangeObjectAction

class	ChangeObjectColorAction

class	ChangeObjectSelectedAction

class	ChangeObjectVisibilityAction

class	ChangePointCloudAction

class	ChangePointCloudNormalsAction

class	ChangePointCloudPointsAction

class	ChangePointPointSelectionAction

class	ChangePolylineAction

class	ChangePolylinePointsAction

class	ChangePolylineTopologyAction

class	ChangeSceneAction

class	ChangeSceneObjectsOrder

class	ChangeSurfaceAction

class	ChangeTextureAction

class	ChangeVertsColorMapAction

class	ChangeVisualizePropertyAction

class	ChangeXfAction

class	ChangVoxelSelectionAction

class	char_output

class	CircleObject

class	CloudPartMapping

class	CmpOld

class	CNCMachineSettings

class	Color

class	ColoringType

class	ColorMapAggregator_FaceTag_AggregateMode

class	ColorMapAggregator_FaceTag_PartialColorMap

class	ColorMapAggregator_UndirectedEdgeTag_AggregateMode

class	ColorMapAggregator_UndirectedEdgeTag_PartialColorMap

class	ColorMapAggregator_VertTag_AggregateMode

class	ColorMapAggregator_VertTag_PartialColorMap

class	CombinedHistoryAction

class	ComputeSteepestDescentPathSettings

class	Cone3ApproximationParams

class	Cone3d

class	Cone3f

class	ConeFitterType

class	ConeObject

class	ConstantCuspParams

class	ContoursDistanceMapOffset

class	ContoursDistanceMapOptions

class	ContourToDistanceMapParams

class	CoordinateConverters

class	CoordinateConverters2

class	CutMeshParameters

class	CutMeshResult

class	Cylinder3d

class	Cylinder3f

class	CylinderObject

class	DecimatePolylineResult

class	DecimatePolylineSettings_Vector2f

class	DecimatePolylineSettings_Vector3f

class	DecimateResult

class	DecimateSettings

class	DecimateStrategy

class	DeloneSettings

class	DenoiseViaNormalsSettings

class	DenseBox

class	DentalId

class	DepthFunction

class	DetectTunnelSettings

class	DimensionsVisualizePropertyType

class	Dipole

class	Dipoles

class	Dirty

class	DirtyFlags

class	DistanceMap

class	DistanceMapLoad

class	DistanceMapSave

class	DistanceMapToWorld

class	DistanceMeasurementObject

class	DistanceToMeshOptions

class	DistanceVolumeParams

class	DividePointCloudOptionalOutput

class	DividePolylineParameters

class	DoubleOffsetSettings

class	EdgeBitSet

class	EdgeBMap

class	EdgeColors

class	EdgeMap

class	EdgePathsAStarBuilder

class	EdgePathsBuilderT_MetricToAStarPenalty

class	EdgePathsBuilderT_TrivialMetricToPenalty

class	EdgePoint

class	EdgePointPair

class	EdgeScalars

class	EdgeSegment

class	EdgeSetBitIterator

class	EdgeTri

class	EdgeWeights

class	EmbeddedStructureParameters

class	EnumNeihbourFaces

class	EnumNeihbourVertices

class	ExtremeEdgeType

class	Face2RegionMap

class	FaceBitSet

class	FaceBMap

class	FaceColorMapAggregator

class	FaceColors

class	FaceDistancesSettings

class	FaceFace

class	FaceId

class	FaceMap

class	FaceNormals

class	FaceScalars

class	FaceSetBitIterator

class	FanRecord

class	FanRecordWithCenter

class	FastWindingNumber

class	FeatureObject

class	FeatureObjectProjectPointResult

class	FeatureObjectSharedProperty

class	FeaturePropertyKind

class	Features

class	FeaturesObjectKind

class	FeatureVisualizePropertyType

class	FewSmallest_PointsProjectionResult

class	FillHoleItem

class	FillHoleMetric

class	FillHoleNicelySettings

class	FillHoleParams

class	FilterType

class	FindInnerShellSettings

class	FindOverhangsSettings

class	FindOverlappingSettings

class	FixUndercuts

class	float_output

class	FloatGridComponents

class	FlowAggregator

class	FlowOrigin

class	FreeFormBestFit

class	FreeFormDeformer

class	func_AABBTree

class	func_AABBTreePoints

class	func_AABBTreePolyline_Vector2_float

class	func_AABBTreePolyline_Vector3_float

class	func_bool_from_float

class	func_bool_from_Id_EdgeTag

class	func_bool_from_Id_EdgeTag_Vector2_float

class	func_bool_from_Id_EdgeTag_Vector3_float

class	func_bool_from_Id_FaceTag

class	func_bool_from_Id_UndirectedEdgeTag

class	func_bool_from_Id_VertTag

class	func_bool_from_MeshIntersectionResult

class	func_bool_from_MeshProjectionResult

class	func_bool_from_std_shared_ptr_HistoryAction

class	func_bool_from_unsigned_long_unsigned_long

class	func_bool_from_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long

class	func_double_from_double_double

class	func_double_from_Id_VertTag_Id_VertTag_Id_VertTag

class	func_double_from_Id_VertTag_Id_VertTag_Id_VertTag_Id_VertTag

class	func_double_from_TaggedBitSet_FaceTag_Vector3_float

class	func_float_from_char_const

class	func_float_from_Id_EdgeTag

class	func_float_from_Id_UndirectedEdgeTag

class	func_float_from_Id_VertTag

class	func_float_from_int_int

class	func_float_from_std_vector_std_vector_Vector2_float_OffsetContourIndex_OffsetContoursOrigins

class	func_float_from_unsigned_long

class	func_float_from_unsigned_long_unsigned_long

class	func_float_from_Vector3_int

class	func_MeshOrPoints_ProjectionResult_from_Vector3_float

class	func_MeshTriPoint_from_unsigned_long

class	func_Processing_from_MeshProjectionResult_Ball

class	func_ProcessOneResult_from_Vector3_float_Id_FaceTag_Vector3_float_float

class	func_std_variant_float_Vector3_float_from_FeatureObject_const_ViewportId

class	func_std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane_from_std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

class	func_TaggedBitSet_FaceTag_const_from_unsigned_long

class	func_tl_expected_VoxelsVolumeMinMax_std_vector_float_std_string_from_PointCloud_PointsToDistanceVolumeParams

class	func_unsigned_char_from_Vector3_int

class	func_Vector2_float_from_Vector2_int

class	func_Vector2_int_from_Vector2_float

class	func_Vector3_float_from_Id_VertTag

class	func_Vector3_float_from_unsigned_long_unsigned_long

class	func_Vector3_float_from_Vector3_float

class	func_Vector3_float_from_Vector3_float_Vector3_float_float_float_float

class	func_Vector3_float_from_Vector3_int

class	func_Vector3_int_from_Vector3_float

class	func_Vector_Dipole_Id_NodeTag

class	func_void

class	func_void_from_AABBTree

class	func_void_from_AABBTreePoints

class	func_void_from_AABBTreePolyline_Vector2_float

class	func_void_from_AABBTreePolyline_Vector3_float

class	func_void_from_EdgePoint

class	func_void_from_Features_SubfeatureInfo

class	func_void_from_Id_EdgeTag_Id_EdgeTag

class	func_void_from_Id_EdgeTag_Id_EdgeTag_float

class	func_void_from_Id_GraphEdgeTag_Id_GraphEdgeTag

class	func_void_from_Id_ObjTag_MeshOrPoints_ProjectionResult

class	func_void_from_Id_UndirectedEdgeTag_float_Vector2_float

class	func_void_from_Id_UndirectedEdgeTag_float_Vector3_float

class	func_void_from_Id_UndirectedEdgeTag_Vector2_float_float

class	func_void_from_Id_UndirectedEdgeTag_Vector3_float_float

class	func_void_from_Id_VertTag

class	func_void_from_Id_VertTag_Vector3_float

class	func_void_from_int

class	func_void_from_Mesh

class	func_void_from_Mesh_float_float

class	func_void_from_Mesh_PartMapping

class	func_void_from_SceneLoad_SceneLoadResult

class	func_void_from_SignDetectionMode

class	func_void_from_std_filesystem_path

class	func_void_from_std_variant_float_Vector3_float_FeatureObject_ViewportId

class	func_void_from_Vector3_float_MeshOrPoints_ProjectionResult

class	func_void_from_Vector3_float_MeshOrPoints_ProjectionResult_Id_ObjTag

class	func_void_from_Vector_Dipole_Id_NodeTag

class	FunctionVolume

class	FunctionVolumeU8

class	GcodeLoad

class	GcodeProcessor

class	GCommand

class	GeneralOffsetParameters

class	GeodesicPathApprox

class	Graph

class	GraphEdgeBitSet

class	GraphEdgeId

class	GraphVertBitSet

class	GraphVertId

class	GridSettings

class	GridToMeshSettings

class	HashToVectorMappingConverter

class	Heap_float_GraphVertId_std_greater_float

class	Histogram

class	HistoryAction

class	HoleFillPlan

class	ICP

class	ICPExitType

class	ICPGroupPair

class	ICPGroupPairs

class	ICPMethod

class	ICPMode

class	ICPPairData

class	ICPProperties

class	Id_EdgeTag

class	Id_ICPElemtTag

class	Id_VoxelTag

class	IFastWindingNumber

class	IICPTreeIndexer

class	Image

class	ImageLoad

class	ImageSave

class	ImproveSamplingSettings

class	InflateSettings

class	InSphere

class	InSphereSearchSettings

class	int_output

class	IntersectionPrecomputes2_double

class	IntersectionPrecomputes2_float

class	IntersectionPrecomputes_double

class	IntersectionPrecomputes_float

class	InTreePathBuilder

class	IOFilter

class	IPointPairs

class	IPointsToMeshProjector

class	IRenderObject

class	IsVisualizeMaskEnum_AnyVisualizeMaskEnum

class	IsVisualizeMaskEnum_DimensionsVisualizePropertyType

class	IsVisualizeMaskEnum_FeatureVisualizePropertyType

class	IsVisualizeMaskEnum_LabelVisualizePropertyType

class	IsVisualizeMaskEnum_LinesVisualizePropertyType

class	IsVisualizeMaskEnum_MeshVisualizePropertyType

class	IsVisualizeMaskEnum_PointsVisualizePropertyType

class	IsVisualizeMaskEnum_VisualizeMaskType

class	IteratorRange_PolylineUndirectedEdgeIterator

class	IteratorRange_RingIterator_NextEdgeSameLeft

class	IteratorRange_RingIterator_NextEdgeSameOrigin

class	IteratorRange_UndirectedEdgeIterator

class	LabelVisualizePropertyType

class	Laplacian

class	Line2d

class	Line2f

class	Line3d

class	Line3f

class	Line3Mesh_double

class	Line3Mesh_float

class	LineInterpolationParams

class	LineObject

class	LineSegm2d

class	LineSegm2f

class	LineSegm3d

class	LineSegm3f

class	LinesLoad

class	LinesSave

class	LinesVisualizePropertyType

class	LoadedObjects

class	LoadedObjectT

class	LoadedObjectT_ObjectLines

class	LoadedObjectT_ObjectMesh

class	LoadedObjectT_ObjectPoints

class	LoadedObjectT_ObjectVoxels

class	MakeDegenerateBandAroundRegionParams

class	MakeSignedByWindingNumberSettings

class	MarchingCubesByParts

class	MarchingCubesParams

class	MarkedContour3f

class	Matrix2b

class	Matrix2d

class	Matrix2f

class	Matrix2i

class	Matrix2ll

class	Matrix3_bool_QR

class	Matrix3_double_QR

class	Matrix3_float_QR

class	Matrix3_int_QR

class	Matrix3_long_long_QR

class	Matrix3b

class	Matrix3d

class	Matrix3f

class	Matrix3i

class	Matrix3ll

class	Matrix4b

class	Matrix4d

class	Matrix4f

class	Matrix4i

class	Matrix4ll

class	Matrix_float

class	MeasurementObject

class	MergeVolumePartSettings

class	Mesh

class	MeshApproxRelaxParams

class	MeshAttributesToUpdate

class	MeshBuilder

class	MeshComponents

class	MeshDiff

class	MeshEqualizeTriAreasParams

class	MeshIntersectionResult

class	MeshLoad

class	MeshLoadSettings

class	MeshMeshConverter

class	MeshMeshDistanceResult

class	MeshMeshSignedDistanceResult

class	MeshNormals

class	MeshOnVoxelsT_const_Mesh

class	MeshOnVoxelsT_Mesh

class	MeshOrPoints

class	MeshOrPointsXf

class	MeshPart

class	MeshPoint

class	MeshProjectionResult

class	MeshRelaxParams

class	MeshSave

class	MeshTexture

class	MeshToDirectionVolumeParams

class	MeshToDistanceMapParams

class	MeshToDistanceVolumeParams

class	MeshTopology

class	MeshTopologyDiff

class	MeshToVolumeParams

class	MeshTriPoint

class	MeshVertPart

class	MeshVisualizePropertyType

class	MeshVoxelsConverter

class	MetricToAStarPenalty

class	ModelBaseRenderParams

class	ModelPointsData

class	ModelRenderParams

class	MovementBuildBodyParams

class	MoveMeshToVoxelMaxDerivSettings

class	MoveType

class	MultiMeshIntersectionResult

class	MultiRayMeshIntersectResult

class	MultiwayAligningTransform

class	MultiwayICP

class	MultiwayICPSamplingParameters

class	MutexOwner

class	NeighborDir

class	NestedComponenetsMode

class	NewEdgesMap

class	NextEdgeSameLeft

class	NextEdgeSameOrigin

class	NoCtor_char

class	NoCtor_FaceId

class	NoCtor_GraphEdgeId

class	NoCtor_GraphVertId

class	NoCtor_Id_EdgeTag

class	NoCtor_Id_ICPElemtTag

class	NoCtor_Id_VoxelTag

class	NoCtor_NodeId

class	NoCtor_ObjId

class	NoCtor_PixelId

class	NoCtor_RegionId

class	NoCtor_TextureId

class	NoCtor_UndirectedEdgeId

class	NoCtor_unsigned_char

class	NoCtor_VertId

class	NodeBitSet

class	NoDefInit_FaceId

class	NoDefInit_GraphEdgeId

class	NoDefInit_GraphVertId

class	NoDefInit_Id_EdgeTag

class	NoDefInit_Id_ICPElemtTag

class	NoDefInit_Id_VoxelTag

class	NoDefInit_NodeId

class	NoDefInit_ObjId

class	NoDefInit_PixelId

class	NoDefInit_RegionId

class	NoDefInit_TextureId

class	NoDefInit_UndirectedEdgeId

class	NoDefInit_VertId

class	NodeId

class	NoInit

class	NoiseSettings

class	NormalsToPoints

class	NumSum

class	ObjBitSet

class	Object

class	ObjectChildrenHolder

class	ObjectDistanceMap

class	ObjectFactoryBase

class	ObjectGcode

class	ObjectLabel

class	ObjectLines

class	ObjectLinesHolder

class	ObjectMesh

class	ObjectMeshHolder

class	ObjectPoints

class	ObjectPointsHolder

class	ObjectSave

class	ObjectSelectivityType

class	ObjectVoxels

class	ObjId

class	ObjKindTraits_FeaturesObjectKind_Circle

class	ObjKindTraits_FeaturesObjectKind_Cone

class	ObjKindTraits_FeaturesObjectKind_Cylinder

class	ObjKindTraits_FeaturesObjectKind_Line

class	ObjKindTraits_FeaturesObjectKind_Plane

class	ObjKindTraits_FeaturesObjectKind_Point

class	ObjKindTraits_FeaturesObjectKind_Sphere

class	ObjMap

class	ObjTreeTraits

class	ObjVertId

class	OffsetContourIndex

class	OffsetContoursOrigins

class	OffsetContoursParams

class	OffsetContoursRestoreZParams

class	OffsetMode

class	OffsetParameters

class	OneMeshContour

class	OneMeshIntersection

class	OpenVdbFloatGrid

class	OrientNormals

class	OriginAndDimensions

class	OutEdge

class	OutEdge2

class	OutputFlows

class	PackMapping

class	Parabolad

class	Parabolaf

class	Parallel

class	PartialChangeMeshAction

class	PartialChangeMeshPointsAction

class	PartialChangeMeshTopologyAction

class	PartMapping

class	PathError

class	Pdf

class	PdfParameters

class	phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

class	phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

class	phmap_flat_hash_map_Id_GraphEdgeTag_Id_GraphEdgeTag

class	phmap_flat_hash_map_Id_GraphVertTag_Id_GraphVertTag

class	phmap_flat_hash_map_Id_ICPElemtTag_Id_ICPElemtTag

class	phmap_flat_hash_map_Id_NodeTag_Id_NodeTag

class	phmap_flat_hash_map_Id_ObjTag_Id_ObjTag

class	phmap_flat_hash_map_Id_PixelTag_Id_PixelTag

class	phmap_flat_hash_map_Id_RegionTag_Id_RegionTag

class	phmap_flat_hash_map_Id_TextureTag_Id_TextureTag

class	phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

class	phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

class	phmap_flat_hash_map_Id_UndirectedEdgeTag_int

class	phmap_flat_hash_map_Id_VertTag_float

class	phmap_flat_hash_map_Id_VertTag_FlowAggregator_Flows

class	phmap_flat_hash_map_Id_VertTag_Id_VertTag

class	phmap_flat_hash_map_Id_VertTag_VertPathInfo

class	phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag

class	phmap_flat_hash_map_int_Box_Vector3_int

class	phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul

class	PixelBitSet

class	PixelId

class	PlanarTriangulation

class	Plane3d

class	Plane3f

class	PlaneAccumulator

class	PlaneObject

class	PointAccumulator

class	PointCloud

class	PointCloudApproxRelaxParams

class	PointCloudComponents

class	PointCloudRelaxParams

class	PointObject

class	PointOnFace

class	PointOnObject

class	PointPair

class	PointPairs

class	PointsLoad

class	PointsLoadSettings

class	PointsProjectionResult

class	PointsSave

class	PointsToDistanceVolumeParams

class	PointsToMeshParameters

class	PointsToMeshProjector

class	PointsVisualizePropertyType

class	PointToPlaneAligningTransform

class	PointToPointAligningTransform

class	Polyline2

class	Polyline2ProjectionWithOffsetResult

class	Polyline3

class	PolylineComponents

class	PolylineIntersectionResult2

class	PolylineMaker

class	PolylineProjectionResult2

class	PolylineProjectionResult3

class	PolylineProjectionWithOffsetResult3

class	PolylineSubdivideSettings

class	PolylineTopology

class	PolylineTraits_Vector2f

class	PolylineTraits_Vector3f

class	PolylineUndirectedEdgeIterator

class	Polynomial_double_0

class	Polynomial_double_1

class	Polynomial_double_2

class	Polynomial_double_3

class	Polynomial_double_4

class	Polynomial_double_5

class	Polynomial_double_6

class	Polynomial_float_0

class	Polynomial_float_1

class	Polynomial_float_2

class	Polynomial_float_3

class	Polynomial_float_4

class	Polynomial_float_5

class	Polynomial_float_6

class	PolynomialWrapper_double

class	PolynomialWrapper_float

class	PositionedText

class	PrecipitationSimulator

class	PreciseCollisionResult

class	PreciseVertCoords

class	PreciseVertCoords2

class	Processing

class	ProcessOneResult

class	QuadraticForm2d

class	QuadraticForm2f

class	QuadraticForm3d

class	QuadraticForm3f

class	QuadricApprox

class	QuarterBit

class	Quaterniond

class	Quaternionf

class	RadiusMeasurementObject

class	RawTiffOutput

class	RayOrigin_float

class	RebuildMeshSettings

class	RectIndexer

class	RefineParameters

class	RegionBitSet

class	RegionId

class	RegularMapMesher

class	RelaxApproxType

class	RelaxParams

class	RemeshSettings

class	RenderModelPassMask

class	Reorder

class	ResolveMeshDegenSettings

class	RigidScaleXf3d

class	RigidScaleXf3f

class	RigidXf3d

class	RigidXf3f

class	RingIterator_NextEdgeSameLeft

class	RingIterator_NextEdgeSameOrigin

class	SaveSettings

class	ScalarType

class	SceneColors

class	SceneLoad

class	SceneRoot

class	SceneRootObject

class	SceneSettings

class	SearchPathSettings

class	SegmentSegmentIntersectResult

class	SegmPointd

class	SegmPointf

class	SelfIntersections

class	SeparationPointStorage

class	SetBitIterator

class	SetNew

class	SharpenMarchingCubesMeshSettings

class	SharpOffsetParameters

class	ShellVertexInfo

class	Side

class	SignDetectionMode

class	SignDetectionModeShort

class	SignedDistanceToMeshResult

class	SimpleVolume

class	SimpleVolumeMinMax

class	SimpleVolumeMinMaxU16

class	SimpleVolumeU16

class	SkyPatch

class	SliceInfo

class	SliceInfoBase

class	SlicePlane

class	SomeLocalTriangulations

class	SortIntersectionsData

class	SpacingSettings

class	Sphere2d

class	Sphere2f

class	Sphere3d

class	Sphere3f

class	SphereObject

class	SphereParams

class	SplineSettings

class	std_array_AffineXf_Vector3_double_4

class	std_array_AffineXf_Vector3_float_4

class	std_array_BooleanResultMapper_Maps_2

class	std_array_Id_VertTag_3

class	std_array_int_4

class	std_array_PreciseVertCoords2_3

class	std_array_PreciseVertCoords2_4

class	std_array_PreciseVertCoords_4

class	std_array_PreciseVertCoords_5

class	std_array_std_filesystem_path_4

class	std_array_Vector3_double_3

class	std_array_Vector3_float_3

class	std_array_Vector3_int_3

class	std_array_VoxelsVolumeMinMax_std_vector_float_3

class	std_array_WeightedVertex_3

class	std_greater_float

class	std_optional_Box_float

class	std_optional_Box_Vector3_float

class	std_optional_Color

class	std_optional_double

class	std_optional_Vector2_float

class	std_optional_Vector3_float

class	std_string_output

class	std_unordered_set_std_string

class	std_variant_float_Vector3_float

class	std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag

class	std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int

class	std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul

class	std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul

class	std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

class	std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box_Vector3_float

class	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector2_float

class	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector3_float

class	std_vector_AABBTreeNode_ObjTreeTraits

class	std_vector_AABBTreePoints_Node

class	std_vector_AABBTreePoints_Point

class	std_vector_AffineXf_Vector3_float

class	std_vector_char

class	std_vector_CNCMachineSettings_RotationAxisName

class	std_vector_Color

class	std_vector_Dipole

class	std_vector_DistanceMap

class	std_vector_double

class	std_vector_EdgePoint

class	std_vector_EdgePointPair

class	std_vector_EdgeSegment

class	std_vector_EdgeTri

class	std_vector_FaceFace

class	std_vector_FanRecord

class	std_vector_FanRecordWithCenter

class	std_vector_FeatureObjectSharedProperty

class	std_vector_FillHoleItem

class	std_vector_float

class	std_vector_FlowOrigin

class	std_vector_GcodeProcessor_Command

class	std_vector_GcodeProcessor_MoveAction

class	std_vector_GCommand

class	std_vector_Graph_EndVertices

class	std_vector_Heap_float_Id_GraphVertTag_std_greater_float_Element

class	std_vector_ICPGroupPair

class	std_vector_ICPGroupPairs

class	std_vector_Id_EdgeTag

class	std_vector_Id_FaceTag

class	std_vector_Id_GraphEdgeTag

class	std_vector_Id_GraphVertTag

class	std_vector_Id_ICPElemtTag

class	std_vector_Id_NodeTag

class	std_vector_Id_ObjTag

class	std_vector_Id_PixelTag

class	std_vector_Id_RegionTag

class	std_vector_Id_TextureTag

class	std_vector_Id_UndirectedEdgeTag

class	std_vector_Id_VertTag

class	std_vector_Id_VoxelTag

class	std_vector_int

class	std_vector_IOFilter

class	std_vector_Line3Mesh_double

class	std_vector_Line3Mesh_float

class	std_vector_Mesh

class	std_vector_Mesh_const

class	std_vector_MeshBuilder_MeshPiece

class	std_vector_MeshBuilder_VertDuplication

class	std_vector_MeshBuilder_VertSpan

class	std_vector_MeshIntersectionResult

class	std_vector_MeshLoad_NamedMesh

class	std_vector_MeshOrPointsXf

class	std_vector_MeshProjectionResult

class	std_vector_MeshSave_NamedXfMesh

class	std_vector_MeshTexture

class	std_vector_MeshTriPoint

class	std_vector_ModelPointsData

class	std_vector_ObjVertId

class	std_vector_OffsetContoursOrigins

class	std_vector_OneMeshContour

class	std_vector_OneMeshIntersection

class	std_vector_PlanarTriangulation_IntersectionInfo

class	std_vector_PointCloud

class	std_vector_PointPair

class	std_vector_PointsLoad_NamedCloud

class	std_vector_PointsProjectionResult

class	std_vector_Polyline_Vector3_float

class	std_vector_PositionedText

class	std_vector_QuadraticForm_Vector2_float

class	std_vector_QuadraticForm_Vector3_float

class	std_vector_RigidXf3_double

class	std_vector_SkyPatch

class	std_vector_SliceInfo

class	std_vector_SomeLocalTriangulations

class	std_vector_std_array_Id_VertTag_3ul

class	std_vector_std_array_std_filesystem_path_4ul

class	std_vector_std_array_Vector3_float_3ul

class	std_vector_std_filesystem_path

class	std_vector_std_pair_double_int

class	std_vector_std_pair_double_std_string

class	std_vector_std_pair_Id_EdgeTag_Id_EdgeTag

class	std_vector_std_pair_Id_VertTag_Id_VertTag

class	std_vector_std_pair_unsigned_long_unsigned_long

class	std_vector_std_pair_Vector3_float_Vector3_float

class	std_vector_std_shared_ptr_BasicUiRenderTask

class	std_vector_std_shared_ptr_HistoryAction

class	std_vector_std_shared_ptr_Mesh

class	std_vector_std_shared_ptr_Object

class	std_vector_std_shared_ptr_Object_const

class	std_vector_std_shared_ptr_ObjectDistanceMap

class	std_vector_std_shared_ptr_ObjectLines

class	std_vector_std_shared_ptr_ObjectLinesHolder

class	std_vector_std_shared_ptr_ObjectMesh

class	std_vector_std_shared_ptr_ObjectMeshHolder

class	std_vector_std_shared_ptr_ObjectPoints

class	std_vector_std_shared_ptr_ObjectPointsHolder

class	std_vector_std_shared_ptr_ObjectVoxels

class	std_vector_std_shared_ptr_VisualObject

class	std_vector_std_shared_ptr_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid

class	std_vector_std_string

class	std_vector_std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

class	std_vector_std_vector_EdgePoint

class	std_vector_std_vector_Id_EdgeTag

class	std_vector_std_vector_Id_GraphEdgeTag

class	std_vector_std_vector_Id_VertTag

class	std_vector_std_vector_ObjVertId

class	std_vector_std_vector_OffsetContoursOrigins

class	std_vector_std_vector_PlanarTriangulation_IntersectionInfo

class	std_vector_std_vector_VariableEdgeTri

class	std_vector_std_vector_Vector2_double

class	std_vector_std_vector_Vector2_float

class	std_vector_std_vector_Vector3_double

class	std_vector_std_vector_Vector3_float

class	std_vector_TaggedBitSet_EdgeTag

class	std_vector_TaggedBitSet_FaceTag

class	std_vector_TaggedBitSet_UndirectedEdgeTag

class	std_vector_TaggedBitSet_VertTag

class	std_vector_TaggedBitSet_VoxelTag

class	std_vector_TriPoint_float

class	std_vector_UndirectedEdgeUndirectedEdge

class	std_vector_UnorientedTriangle

class	std_vector_unsigned_char

class	std_vector_unsigned_long

class	std_vector_unsigned_short

class	std_vector_VariableEdgeTri

class	std_vector_Vector2_double

class	std_vector_Vector2_float

class	std_vector_Vector3_double

class	std_vector_Vector3_float

class	std_vector_Vector3_int

class	std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag

class	std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag

class	std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

class	std_vector_ViewportMask

class	std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid

class	std_vector_WatershedGraph_BasinInfo

class	std_vector_WatershedGraph_BdInfo

class	std_vector_WatershedGraph_OverflowPoint

class	StitchHolesParams

class	SubdivideSettings

class	SurfaceDistanceBuilder

class	SymbolMeshParams

class	SymMatrix2b

class	SymMatrix2d

class	SymMatrix2f

class	SymMatrix2i

class	SymMatrix2ll

class	SymMatrix3b

class	SymMatrix3d

class	SymMatrix3f

class	SymMatrix3i

class	SymMatrix3ll

class	SymMatrix4b

class	SymMatrix4d

class	SymMatrix4f

class	SymMatrix4i

class	SymMatrix4ll

class	SystemMemory

class	SystemPath

class	TaggedBitSet_ICPElemtTag

class	TeethMaskToDirectionVolumeConvertor

class	TerminalVertex

class	TextMeshAlignParams

class	TextureBitSet

class	TextureId

class	TexturePerFace

class	TiffParameters

class	ToolPathParams

class	ToolPathResult

class	TransformedMesh

class	TriangleSegmentIntersectResult

class	Triangulation

class	TriangulationHelpers

class	TriangulationParameters

class	TriIntersectResult

class	TriMesh

class	TrimOptionalOutput

class	TrimWithPlaneParams

class	TriPointd

class	TriPointf

class	TrivialMetricToPenalty

class	UiRenderManager

class	UiRenderParams

class	UndirectedEdge2RegionMap

class	UndirectedEdgeBitSet

class	UndirectedEdgeBMap

class	UndirectedEdgeColors

class	UndirectedEdgeId

class	UndirectedEdgeIterator

class	UndirectedEdgeMap

class	UndirectedEdgeScalars

class	UndirectedEdgeSetBitIterator

class	UndirectedEdgeUndirectedEdge

class	UndirEdgeColorMapAggregator

class	UniformSamplingSettings

class	UnionFind_FaceId

class	UnionFind_UndirectedEdgeId

class	UnionFind_VertId

class	UniqueTemporaryFolder

class	UniqueThreadSafeOwner_AABBTree

class	UniqueThreadSafeOwner_AABBTreePoints

class	UniqueThreadSafeOwner_AABBTreePolyline2

class	UniqueThreadSafeOwner_AABBTreePolyline3

class	UniqueThreadSafeOwner_Dipoles

class	UniteManyMeshesParams

class	UnorientedTriangle

class	unsigned_char_output

class	UseAABBTree

class	VariableEdgeTri

class	VdbVolume

class	Vector2b

class	Vector2d

class	Vector2f

class	Vector2i

class	Vector2ll

class	Vector3b

class	Vector3d

class	Vector3f

class	Vector3i

class	Vector3ll

class	Vector4b

class	Vector4d

class	Vector4f

class	Vector4i

class	Vector4ll

class	Vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_NodeId

class	Vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_NodeId

class	Vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_NodeId

class	Vector_AABBTreeNode_ObjTreeTraits_NodeId

class	Vector_AABBTreePoints_Node_NodeId

class	Vector_AffineXf3f_ObjId

class	Vector_char_VertId

class	Vector_double_RegionId

class	Vector_FaceBitSet_GraphVertId

class	Vector_FanRecord_VertId

class	Vector_Graph_EndVertices_GraphEdgeId

class	Vector_GraphEdgeId_GraphEdgeId

class	Vector_GraphVertId_GraphVertId

class	Vector_ICPGroupPairs_Id_ICPElemtTag

class	Vector_Id_EdgeTag_FaceId

class	Vector_Id_EdgeTag_VertId

class	Vector_Id_ICPElemtTag_Id_ICPElemtTag

class	Vector_Id_VoxelTag_FaceId

class	Vector_Id_VoxelTag_Id_VoxelTag

class	Vector_int_FaceId

class	Vector_int_VertId

class	Vector_MeshBuilder_VertSpan_FaceId

class	Vector_MeshOrPointsXf_ObjId

class	Vector_MeshTexture_TextureId

class	Vector_ModelPointsData_ObjId

class	Vector_NodeId_NodeId

class	Vector_PixelId_PixelId

class	Vector_QuadraticForm2f_VertId

class	Vector_QuadraticForm3f_VertId

class	Vector_RegionId_RegionId

class	Vector_std_array_Vector3f_3_FaceId

class	Vector_std_filesystem_path_TextureId

class	Vector_std_vector_EdgePoint_VertId

class	Vector_std_vector_GraphEdgeId_GraphVertId

class	Vector_std_vector_ObjVertId_Id_ICPElemtTag

class	Vector_TextureId_TextureId

class	Vector_unsigned_long_FaceId

class	Vector_unsigned_long_GraphVertId

class	Vector_unsigned_long_UndirectedEdgeId

class	Vector_unsigned_long_VertId

class	Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

class	Vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_int

class	Vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_int

class	Vector_VertBitSet_ObjId

class	Vector_WatershedGraph_BasinInfo_GraphVertId

class	Vector_WatershedGraph_BdInfo_GraphEdgeId

class	VectorTraits_double

class	VectorTraits_float

class	VectorTraits_int

class	VectorTraits_long_long

class	VectorTraits_unsigned_short

class	VectorTraits_Vector2d

class	VectorTraits_Vector2f

class	VectorTraits_Vector2i

class	VectorTraits_Vector2ll

class	VectorTraits_Vector3d

class	VectorTraits_Vector3f

class	VectorTraits_Vector3i

class	VectorTraits_Vector3ll

class	Vert2RegionMap

class	VertBitSet

class	VertBMap

class	VertColorMapAggregator

class	VertColors

class	VertCoords

class	VertCoordsDiff

class	VertDistance

class	VertId

class	VertMap

class	VertPathInfo

class	VertRenumber

class	VertScalars

class	VertSetBitIterator

class	VertUVCoords

class	ViewportId

class	ViewportIterator

class	ViewportMask

class	ViewportProperty_AffineXf3f

class	ViewportProperty_Color

class	ViewportProperty_Matrix3f

class	ViewportProperty_unsigned_char

class	ViewportProperty_XfBasedCache_Box3f

class	VisualizeMaskType

class	VisualObject

class	VolumeIndexer

class	VolumeSegmentationParameters

class	VolumeSegmenter

class	VolumeToMeshByPartsSettings

class	VoxelBitSet

class	VoxelFilterType

class	VoxelLocation

class	VoxelMetricParameters

class	VoxelsLoad

class	VoxelsSave

class	VoxelsVolume_std_shared_ptr_OpenVdbFloatGrid

class	VoxelsVolumeAccessor_VdbVolume

class	VoxelsVolumeInterpolatedAccessor_VoxelsVolumeAccessor_VdbVolume

class	VoxelTraits_std_function_float_const_Vector3i

class	VoxelTraits_std_function_unsigned_char_const_Vector3i

class	VoxelTraits_std_shared_ptr_OpenVdbFloatGrid

class	VoxelTraits_std_vector_float

class	VoxelTraits_std_vector_unsigned_short

class	WatershedGraph

class	WeightedVertex

class	WholeEdgeBMap

class	WholeEdgeMap

class	WrapType

class	XfBasedCache_Box3f

class	ZeroOnMove_unsigned_long

Functions
str	GetCpuId ()

str	GetDetailedOSName ()

os.PathLike	GetEmbeddedPythonDirectory ()

os.PathLike	GetExeDirectory ()

os.PathLike	GetFontsDirectory ()

os.PathLike	GetHomeDirectory ()

os.PathLike	GetLibsDirectory ()

str	GetMRVersionString ()

os.PathLike	GetResourcesDirectory ()

os.PathLike	GetTempDirectory ()

bool	OpenDocument (os.PathLike path)

None	OpenLink (str url)

None	SegPoints (Vector3f VEC, Vector3f X, Vector3f Y, Vector3f P, Vector3f A, Vector3f Q, Vector3f B)

None	SetCurrentThreadName (str name)

float	TriDist (Vector3f p, Vector3f q, Vector3f s, Vector3f t)

None	accumulateFaceCenters (PointAccumulator accum, MeshPart mp, AffineXf3f xf=None)

None	accumulateLineCenters (PointAccumulator accum, Polyline3 pl, AffineXf3f xf=None)

None	accumulatePoints (PointAccumulator accum, std_vector_Vector3_float points, AffineXf3f xf=None)

None	accumulatePoints (PointAccumulator accum, PointCloud pc, AffineXf3f xf=None)

None	accumulateWeighedPoints (PointAccumulator accum, std_vector_Vector3_float points, std_vector_float weights, AffineXf3f xf=None)

None	addBaseToPlanarMesh (Mesh mesh, float zOffset=1.0)

None	addLeftBand (MeshTopology topology, std_vector_Id_EdgeTag loop, FaceBitSet addHere)

None	addNoise (VertCoords points, VertBitSet validVerts, NoiseSettings settings)

Mesh	alignTextToMesh (Mesh mesh, TextMeshAlignParams params)

float	angle (Vector3f a, Vector3f b)

float	angle (Vector3d a, Vector3d b)

int	angle (Vector3i a, Vector3i b)

float	angle (Vector2f a, Vector2f b)

float	angle (Vector2d a, Vector2d b)

int	angle (Vector2i a, Vector2i b)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_Object res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_VisualObject res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_ObjectPoints res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_ObjectPointsHolder res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_ObjectLines res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_ObjectLinesHolder res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_ObjectMesh res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_ObjectMeshHolder res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_ObjectDistanceMap res, ObjectSelectivityType type)

None	appendObjectFromTreeRecursive (Object obj, std_vector_std_shared_ptr_ObjectVoxels res, ObjectSelectivityType type)

Vector3d	applyDouble (AffineXf3d xf, Vector3f p)

Vector3d	applyDouble (Matrix3d m, Vector3f n)

Vector3f	applyFloat (AffineXf3d xf, Vector3f p)

Vector3f	applyFloat (Matrix3d m, Vector3f n)

Object	asSelectivityType_Object (Object obj, ObjectSelectivityType type)

ObjectDistanceMap	asSelectivityType_ObjectDistanceMap (Object obj, ObjectSelectivityType type)

ObjectLines	asSelectivityType_ObjectLines (Object obj, ObjectSelectivityType type)

ObjectLinesHolder	asSelectivityType_ObjectLinesHolder (Object obj, ObjectSelectivityType type)

ObjectMesh	asSelectivityType_ObjectMesh (Object obj, ObjectSelectivityType type)

ObjectMeshHolder	asSelectivityType_ObjectMeshHolder (Object obj, ObjectSelectivityType type)

ObjectPoints	asSelectivityType_ObjectPoints (Object obj, ObjectSelectivityType type)

ObjectPointsHolder	asSelectivityType_ObjectPointsHolder (Object obj, ObjectSelectivityType type)

ObjectVoxels	asSelectivityType_ObjectVoxels (Object obj, ObjectSelectivityType type)

VisualObject	asSelectivityType_VisualObject (Object obj, ObjectSelectivityType type)

str	asString (str s)

str	asString (SignDetectionMode m)

str	asU8String (str s)

bool	autoOrientLocalTriangulations (PointCloud pointCloud, AllLocalTriangulations triangs, VertBitSet region, func_bool_from_float progress='MR::ProgressCallback{}', Triangulation outRep3=None, Triangulation outRep2=None)

ViewportIterator	begin (ViewportMask mask)

SetBitIterator	begin (BitSet a)

UndirectedEdgeSetBitIterator	begin (UndirectedEdgeBitSet a)

RingIterator_NextEdgeSameOrigin	begin (IteratorRange_RingIterator_NextEdgeSameOrigin range)

bool	bestQuadrangleDiagonal (Vector3f a, Vector3f b, Vector3f c, Vector3f d)

Color	blend (Color front, Color back)

BooleanResult	boolean (Mesh meshA, Mesh meshB, BooleanOperation operation, AffineXf3f rigidB2A, BooleanResultMapper mapper=None, func_bool_from_float cb='MR::ProgressCallback{}')

BooleanResult	boolean (Mesh meshA, Mesh meshB, BooleanOperation operation, BooleanParameters params='MR::BooleanParameters{}')

Id_EdgeTag	buildBottom (Mesh mesh, Id_EdgeTag a, Vector3f dir, float holeExtension, FaceBitSet outNewFaces=None)

None	buildCylinderBetweenTwoHoles (Mesh mesh, Id_EdgeTag a, Id_EdgeTag b, StitchHolesParams params='MR::StitchHolesParams{}')

bool	buildCylinderBetweenTwoHoles (Mesh mesh, StitchHolesParams params='MR::StitchHolesParams{}')

std_vector_Id_EdgeTag	buildShortestPath (Mesh mesh, VertId start, VertId finish, float maxPathLen=3.4028234663852886e+38)

std_vector_Id_EdgeTag	buildShortestPath (Mesh mesh, VertId start, VertBitSet finish, float maxPathLen=3.4028234663852886e+38)

std_vector_Id_EdgeTag	buildShortestPathAStar (Mesh mesh, VertId start, VertId finish, float maxPathLen=3.4028234663852886e+38)

std_vector_Id_EdgeTag	buildShortestPathAStar (Mesh mesh, MeshTriPoint start, MeshTriPoint finish, VertId outPathStart=None, VertId outPathFinish=None, float maxPathLen=3.4028234663852886e+38)

std_vector_Id_EdgeTag	buildShortestPathBiDir (Mesh mesh, VertId start, VertId finish, float maxPathLen=3.4028234663852886e+38)

std_vector_Id_EdgeTag	buildShortestPathBiDir (Mesh mesh, MeshTriPoint start, MeshTriPoint finish, VertId outPathStart=None, VertId outPathFinish=None, float maxPathLen=3.4028234663852886e+38)

std_vector_unsigned_long	buildSmallestMetricPath (VdbVolume voxels, func_float_from_unsigned_long_unsigned_long metric, int start, int finish, func_bool_from_float cb='MR::ProgressCallback{}')

std_vector_Id_EdgeTag	buildSmallestMetricPath (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertId start, VertId finish, float maxPathMetric=3.4028234663852886e+38)

std_vector_Id_EdgeTag	buildSmallestMetricPath (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertId start, VertBitSet finish, float maxPathMetric=3.4028234663852886e+38)

std_vector_Id_EdgeTag	buildSmallestMetricPathBiDir (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertId start, VertId finish, float maxPathMetric=3.4028234663852886e+38)

std_vector_Id_EdgeTag	buildSmallestMetricPathBiDir (MeshTopology topology, func_float_from_Id_EdgeTag metric, TerminalVertex starts, int numStarts, TerminalVertex finishes, int numFinishes, VertId outPathStart=None, VertId outPathFinish=None, float maxPathMetric=3.4028234663852886e+38)

AllLocalTriangulations	buildUnitedLocalTriangulations (PointCloud cloud, TriangulationHelpers.Settings settings, func_bool_from_float progress='MR::ProgressCallback{}')

str	bytesString (int size)

VertColors	calcAvgColors (PointCloud cloud, VertColors colors, VertCoords tgtPoints, VertBitSet tgtVerts, float sigma, func_bool_from_float cb='MR::ProgressCallback{}')

float	calcCombinedFillMetric (Mesh mesh, FaceBitSet filledRegion, FillHoleMetric metric)

int	calcDamerauLevenshteinDistance (str stringA, str stringB, bool caseSensitive=True, int_output outLeftRightAddition=None)

None	calcDipoles (Dipoles dipoles, AABBTree tree, Mesh mesh)

Dipoles	calcDipoles (AABBTree tree, Mesh mesh)

FaceScalars	calcFaceDistances (MeshTopology topology, func_float_from_Id_EdgeTag metric, FaceBitSet starts, FaceDistancesSettings settings='MR::FaceDistancesSettings{}')

float	calcFastWindingNumber (Dipoles dipoles, AABBTree tree, Mesh mesh, Vector3f q, float beta, FaceId skipFace)

float	calcLength (std_vector_Vector2_float contour)

float	calcLength (std_vector_Vector2_double contour)

float	calcLength (std_vector_Vector3_float contour)

float	calcLength (std_vector_Vector3_double contour)

float	calcOrientedArea (std_vector_Vector2_float contour)

float	calcOrientedArea (std_vector_Vector2_double contour)

Vector3f	calcOrientedArea (std_vector_Vector3_float contour)

Vector3d	calcOrientedArea (std_vector_Vector3_double contour)

Vector3d	calcOrientedArea (std_vector_Id_EdgeTag loop, Mesh mesh)

OriginAndDimensions	calcOriginAndDimensions (Box3f box, float voxelSize)

float	calcPathLength (std_vector_Id_EdgeTag path, Mesh mesh)

float	calcPathMetric (std_vector_Id_EdgeTag path, func_float_from_Id_EdgeTag metric)

bool	canMinimizePolynomial (int degree)

bool	canSolvePolynomial (int degree)

bool	ccw (Vector2i a, Vector2i b)

bool	ccw (Vector2i a, Vector2i b, Vector2i c)

bool	ccw (std_array_PreciseVertCoords2_3 vs)

bool	ccw (PreciseVertCoords2 vs)

bool	checkDeloneQuadrangle (Vector3d a, Vector3d b, Vector3d c, Vector3d d, float maxAngleChange=1.7976931348623157e+308)

bool	checkDeloneQuadrangle (Vector3f a, Vector3f b, Vector3f c, Vector3f d, float maxAngleChange=3.4028234663852886e+38)

bool	checkDeloneQuadrangleInMesh (Mesh mesh, Id_EdgeTag edge, DeloneSettings settings='MR::DeloneSettings{}', float_output deviationSqAfterFlip=None)

ShellVertexInfo	classifyShellVert (MeshPart mp, Vector3f shellPoint, FindInnerShellSettings settings='MR::FindInnerShellSettings{}')

ObjectPoints	cloneRegion (ObjectPoints objPoints, VertBitSet region)

ObjectMesh	cloneRegion (ObjectMesh objMesh, FaceBitSet region, bool copyTexture=True)

DistanceMap	combineXYderivativeMaps (tuple[DistanceMap, DistanceMap] XYderivativeMaps)

str	commonFilesName (std_vector_std_filesystem_path files)

None	compressZip (os.PathLike zipFile, os.PathLike sourceFolder, std_vector_std_filesystem_path excludeFiles='std::vector< std::filesystem::path >{}', str password=None, func_bool_from_float cb='MR::ProgressCallback{}')

float	computeBasinVolume (Mesh mesh, FaceBitSet faces, float level)

phmap_flat_hash_map_Id_VertTag_Id_VertTag	computeClosestSurfacePathTargets (Mesh mesh, VertBitSet starts, VertBitSet ends, VertBitSet vertRegion=None, VertScalars outSurfaceDistances=None)

DistanceMap	computeDistanceMap (MeshPart mp, MeshToDistanceMapParams params, func_bool_from_float cb='MR::ProgressCallback{}', std_vector_MeshTriPoint outSamples=None)

DistanceMap	computeDistanceMapD (MeshPart mp, MeshToDistanceMapParams params, func_bool_from_float cb='MR::ProgressCallback{}', std_vector_MeshTriPoint outSamples=None)

std_vector_EdgePoint	computeFastMarchingPath (MeshPart mp, MeshTriPoint start, MeshTriPoint end, VertBitSet vertRegion=None, VertScalars outSurfaceDistances=None)

QuadraticForm3f	computeFormAtVertex (MeshPart mp, VertId v, float stabilizer, UndirectedEdgeBitSet creases=None)

Vector_QuadraticForm3f_VertId	computeFormsAtVertices (MeshPart mp, float stabilizer, UndirectedEdgeBitSet creases=None)

std_vector_EdgePoint	computeGeodesicPath (Mesh mesh, MeshTriPoint start, MeshTriPoint end, GeodesicPathApprox atype='GeodesicPathApprox::FastMarching', int maxGeodesicIters=100)

std_vector_EdgePoint	computeGeodesicPathApprox (Mesh mesh, MeshTriPoint start, MeshTriPoint end, GeodesicPathApprox atype)

VertScalars	computeInSphereThicknessAtVertices (Mesh mesh, InSphereSearchSettings settings, func_bool_from_float progress='MR::ProgressCallback{}')

MeshNormals	computeMeshNormals (Mesh mesh)

Vector3f	computeNormal (AllLocalTriangulations triangs, VertCoords points, VertId v)

Vector_std_array_Vector3f_3_FaceId	computePerCornerNormals (Mesh mesh, UndirectedEdgeBitSet creases)

FaceNormals	computePerFaceNormals (Mesh mesh)

None	computePerFaceNormals4 (Mesh mesh, Vector4f faceNormals, int size)

VertCoords	computePerVertNormals (Mesh mesh)

VertCoords	computePerVertPseudoNormals (Mesh mesh)

VertScalars	computeRayThicknessAtVertices (Mesh mesh, func_bool_from_float progress='MR::ProgressCallback{}')

VertScalars	computeSkyViewFactor (Mesh terrain, VertCoords samples, VertBitSet validSamples, std_vector_SkyPatch skyPatches, BitSet outSkyRays=None, std_vector_MeshIntersectionResult outIntersections=None)

VertScalars	computeSpaceDistances (Mesh mesh, PointOnFace start, float range)

std_vector_EdgePoint	computeSteepestDescentPath (MeshPart mp, VertScalars field, MeshTriPoint start, ComputeSteepestDescentPathSettings settings='MR::ComputeSteepestDescentPathSettings{}')

None	computeSteepestDescentPath (MeshPart mp, VertScalars field, MeshTriPoint start, std_vector_EdgePoint outPath, ComputeSteepestDescentPathSettings settings='MR::ComputeSteepestDescentPathSettings{}')

VertScalars	computeSurfaceDistances (Mesh mesh, VertBitSet startVertices, float maxDist=3.4028234663852886e+38, VertBitSet region=None, int maxVertUpdates=3)

VertScalars	computeSurfaceDistances (Mesh mesh, VertBitSet startVertices, VertBitSet targetVertices, float maxDist=3.4028234663852886e+38, VertBitSet region=None, int maxVertUpdates=3)

VertScalars	computeSurfaceDistances (Mesh mesh, phmap_flat_hash_map_Id_VertTag_float startVertices, float maxDist=3.4028234663852886e+38, VertBitSet region=None, int maxVertUpdates=3)

VertScalars	computeSurfaceDistances (Mesh mesh, MeshTriPoint start, MeshTriPoint end, VertBitSet region=None, bool_output endReached=None, int maxVertUpdates=3)

VertScalars	computeSurfaceDistances (Mesh mesh, MeshTriPoint start, float maxDist=3.4028234663852886e+38, VertBitSet region=None, int maxVertUpdates=3)

VertScalars	computeSurfaceDistances (Mesh mesh, std_vector_MeshTriPoint starts, float maxDist=3.4028234663852886e+38, VertBitSet region=None, int maxVertUpdates=3)

std_vector_EdgePoint	computeSurfacePath (MeshPart mp, MeshTriPoint start, MeshTriPoint end, int maxGeodesicIters=5, VertBitSet vertRegion=None, VertScalars outSurfaceDistances=None)

VertScalars	computeThicknessAtVertices (Mesh mesh)

std_array_int_4	computeTrianglesRepetitions (AllLocalTriangulations triangs)

ToolPathResult	constantCuspToolPath (MeshPart mp, ConstantCuspParams params)

ToolPathResult	constantZToolPath (MeshPart mp, ToolPathParams params)

bool	contains (FaceBitSet bitset, FaceId id)

Polyline2	contourIntersection (Polyline2 contoursA, Polyline2 contoursB, ContourToDistanceMapParams params, float offsetInside=0.0)

Polyline2	contourSubtract (Polyline2 contoursA, Polyline2 contoursB, ContourToDistanceMapParams params, float offsetInside=0.0)

Polyline2	contourUnion (Polyline2 contoursA, Polyline2 contoursB, ContourToDistanceMapParams params, float offsetInside=0)

Image	convertDistanceMapToImage (DistanceMap distMap, float threshold=0.003921568859368563)

DistanceMap	convertImageToDistanceMap (Image image, float threshold=0.003921568859368563)

std_vector_OneMeshContour	convertMeshTriPointsIsoLineToMeshContour (Mesh mesh, std_vector_MeshTriPoint meshTriPoints, float isoValue, SearchPathSettings searchSettings='MR::SearchPathSettings{}')

OneMeshContour	convertMeshTriPointsToClosedContour (Mesh mesh, std_vector_MeshTriPoint meshTriPoints, SearchPathSettings searchSettings='MR::SearchPathSettings{}', std_vector_int pivotIndices=None)

OneMeshContour	convertMeshTriPointsToMeshContour (Mesh mesh, std_vector_MeshTriPoint meshTriPoints, SearchPathSettings searchSettings='MR::SearchPathSettings{}', std_vector_int pivotIndices=None)

OneMeshContour	convertSurfacePathWithEndsToMeshContour (Mesh mesh, MeshTriPoint start, std_vector_EdgePoint surfacePath, MeshTriPoint end)

std_vector_OneMeshContour	convertSurfacePathsToMeshContours (Mesh mesh, std_vector_std_vector_EdgePoint surfacePaths)

std_vector_Vector2_float	copyContour (std_vector_Vector2_double from_)

std_vector_Vector3_float	copyContour (std_vector_Vector3_double from_)

std_vector_Vector2_double	copyContour (std_vector_Vector2_float from_)

std_vector_Vector3_double	copyContour (std_vector_Vector3_float from_)

Object	createObject (str className)

SceneRootObject	createRootFormObject (Object obj)

std_vector_std_vector_Vector2_float	createSymbolContours (SymbolMeshParams params)

Mesh	createSymbolsMesh (SymbolMeshParams params)

OpenVdbFloatGrid	cropped (OpenVdbFloatGrid grid, Box3i box, func_bool_from_float cb='MR::ProgressCallback{}')

Vector3f	cross (Vector3f a, Vector3f b)

Vector3d	cross (Vector3d a, Vector3d b)

Vector3i	cross (Vector3i a, Vector3i b)

float	cross (Vector2f a, Vector2f b)

float	cross (Vector2d a, Vector2d b)

int	cross (Vector2i a, Vector2i b)

std_vector_Id_EdgeTag	cutAlongEdgeLoop (MeshTopology topology, std_vector_Id_EdgeTag c0)

std_vector_Id_EdgeTag	cutAlongEdgeLoop (Mesh mesh, std_vector_Id_EdgeTag c0)

CutMeshResult	cutMesh (Mesh mesh, std_vector_OneMeshContour contours, CutMeshParameters params='MR::CutMeshParameters{}')

int	deactivateFarPairs (IPointPairs pairs, float maxDistSq)

DecimatePolylineResult	decimateContour (std_vector_Vector2_float contour, DecimatePolylineSettings_Vector2f settings='MR::DecimatePolylineSettings2{}')

DecimatePolylineResult	decimateContour (std_vector_Vector3_float contour, DecimatePolylineSettings_Vector3f settings='MR::DecimatePolylineSettings3{}')

DecimateResult	decimateMesh (Mesh mesh, DecimateSettings settings='MR::DecimateSettings{}')

DecimatePolylineResult	decimatePolyline (Polyline2 polyline, DecimatePolylineSettings_Vector2f settings='MR::DecimatePolylineSettings2{}')

DecimatePolylineResult	decimatePolyline (Polyline3 polyline, DecimatePolylineSettings_Vector3f settings='MR::DecimatePolylineSettings3{}')

std_vector_unsigned_char	decode64 (str val)

None	decompressZip (os.PathLike zipFile, os.PathLike targetFolder, str password=None)

None	decompressZip (typing.Any zipStream, os.PathLike targetFolder, str password=None)

std_vector_std_vector_Id_EdgeTag	delRegionKeepBd (Mesh mesh, FaceBitSet region=None)

None	deleteTargetFaces (Mesh obj, Vector3f targetCenter)

None	deleteTargetFaces (Mesh obj, Mesh target)

None	denoiseNormals (Mesh mesh, FaceNormals normals, UndirectedEdgeScalars v, float gamma)

LoadedObjectT	deserializeObjectTree (os.PathLike path, func_void_from_std_filesystem_path postDecompress='MR::FolderCallback{}', func_bool_from_float progressCb='MR::ProgressCallback{}')

LoadedObjectT	deserializeObjectTreeFrom3mf (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

LoadedObjectT	deserializeObjectTreeFromFolder (os.PathLike folder, func_bool_from_float progressCb='MR::ProgressCallback{}')

Object	deserializeObjectTreeFromGltf (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

LoadedObjectT	deserializeObjectTreeFromModel (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

std_vector_std_vector_Id_EdgeTag	detectBasisTunnels (MeshPart mp, func_float_from_Id_EdgeTag metric='MR::EdgeMetric{}', func_bool_from_float progressCallback='MR::ProgressCallback{}')

std_vector_int	detectLoneContours (std_vector_std_vector_VariableEdgeTri contours)

FaceBitSet	detectTunnelFaces (MeshPart mp, DetectTunnelSettings settings='MR::DetectTunnelSettings{}')

bool	dilateRegion (Mesh mesh, FaceBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	dilateRegion (Mesh mesh, VertBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	dilateRegion (Mesh mesh, UndirectedEdgeBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	dilateRegion (PointCloud pointCloud, VertBitSet region, float dilation, func_bool_from_float cb='MR::ProgressCallback{}', AffineXf3f xf=None)

bool	dilateRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, FaceBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	dilateRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	dilateRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, UndirectedEdgeBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

func_float_from_Id_EdgeTag	discreteAbsMeanCurvatureMetric (Mesh mesh)

func_float_from_Id_EdgeTag	discreteMinusAbsMeanCurvatureMetric (Mesh mesh)

DistanceMap	distanceMapFromContours (Polyline2 contours, ContourToDistanceMapParams params, ContoursDistanceMapOptions options='MR::ContoursDistanceMapOptions{}')

None	distanceMapFromContours (DistanceMap distMap, Polyline2 polyline, ContourToDistanceMapParams params, ContoursDistanceMapOptions options='MR::ContoursDistanceMapOptions{}')

Polyline2	distanceMapTo2DIsoPolyline (DistanceMap distMap, float isoValue)

Polyline2	distanceMapTo2DIsoPolyline (DistanceMap distMap, ContourToDistanceMapParams params, float isoValue)

tuple[Polyline2, AffineXf3f]	distanceMapTo2DIsoPolyline (DistanceMap distMap, AffineXf3f xf, float isoValue, bool useDepth=False)

Polyline2	distanceMapTo2DIsoPolyline (DistanceMap distMap, float pixelSize, float isoValue)

Mesh	distanceMapToMesh (DistanceMap distMap, AffineXf3f toWorld, func_bool_from_float cb='MR::ProgressCallback{}')

None	dividePolylineWithPlane (Polyline3 polyline, Plane3f plane, DividePolylineParameters params='MR::DividePolylineParameters{}')

PointCloud	divideWithPlane (PointCloud points, Plane3f plane, DividePointCloudOptionalOutput optOut='MR::DividePointCloudOptionalOutput{}')

Mesh	doBooleanOperation (Mesh meshACut, Mesh meshBCut, std_vector_std_vector_Id_EdgeTag cutEdgesA, std_vector_std_vector_Id_EdgeTag cutEdgesB, BooleanOperation operation, AffineXf3f rigidB2A=None, BooleanResultMapper mapper=None, bool mergeAllNonIntersectingComponents=False, BooleanInternalParameters intParams='MR::BooleanInternalParameters{}')

SegmentSegmentIntersectResult	doSegmentSegmentIntersect (std_array_PreciseVertCoords2_4 vs)

TriangleSegmentIntersectResult	doTriangleSegmentIntersect (std_array_PreciseVertCoords_5 vs)

float	dot (Vector3f a, Vector3f b)

float	dot (Vector3d a, Vector3d b)

int	dot (Vector3i a, Vector3i b)

float	dot (Vector2f a, Vector2f b)

float	dot (Vector2d a, Vector2d b)

int	dot (Vector2i a, Vector2i b)

Mesh	doubleOffsetMesh (MeshPart mp, float offsetA, float offsetB, OffsetParameters params='MR::OffsetParameters{}')

Mesh	doubleOffsetVdb (MeshPart mp, DoubleOffsetSettings settings)

int	duplicateMultiHoleVertices (Mesh mesh)

func_float_from_Id_EdgeTag	edgeCurvMetric (Mesh mesh, float angleSinFactor=2, float angleSinForBoundary=0)

func_float_from_Id_EdgeTag	edgeLengthMetric (Mesh mesh)

None	edgeMapsComposition (EdgeMap a2b, EdgeMap b2c)

std_vector_Vector3_float	edgePointsFromContours (Polyline2 polyline, float pixelSize, float threshold)

func_float_from_Id_EdgeTag	edgeTableMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric)

func_float_from_Id_EdgeTag	edgeTableSymMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric)

Id_EdgeTag	eliminateDegree3Dest (MeshTopology topology, Id_EdgeTag e, FaceBitSet region=None)

int	eliminateDegree3Vertices (MeshTopology topology, VertBitSet region, FaceBitSet fs=None)

Id_EdgeTag	eliminateDoubleTris (MeshTopology topology, Id_EdgeTag e, FaceBitSet region=None)

None	eliminateDoubleTrisAround (MeshTopology topology, VertId v, FaceBitSet region=None)

Mesh	embedStructureToTerrain (Mesh terrain, Mesh structure, EmbeddedStructureParameters params)

str	encode64 (int data, int size)

ViewportIterator	end (args, *kwargs)

RingIterator_NextEdgeSameOrigin	end (IteratorRange_RingIterator_NextEdgeSameOrigin range)

bool	equalizeTriAreas (Mesh mesh, MeshEqualizeTriAreasParams params='MR::MeshEqualizeTriAreasParams{}', func_bool_from_float cb='MR::ProgressCallback{}')

bool	erodeRegion (Mesh mesh, FaceBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	erodeRegion (Mesh mesh, VertBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	erodeRegion (Mesh mesh, UndirectedEdgeBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	erodeRegion (PointCloud pointCloud, VertBitSet region, float erosion, func_bool_from_float cb='MR::ProgressCallback{}', AffineXf3f xf=None)

bool	erodeRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, FaceBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	erodeRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

bool	erodeRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, UndirectedEdgeBitSet region, float dilation, func_bool_from_float callback='MR::ProgressCallback{}')

None	evalGridMinMax (OpenVdbFloatGrid grid, float_output min, float_output max)

None	executeHoleFillPlan (Mesh mesh, Id_EdgeTag a0, HoleFillPlan plan, FaceBitSet outNewFaces=None)

None	expand (MeshTopology topology, FaceBitSet region, int hops=1)

FaceBitSet	expand (MeshTopology topology, FaceId f, int hops)

None	expand (MeshTopology topology, VertBitSet region, int hops=1)

VertBitSet	expand (MeshTopology topology, VertId v, int hops)

FaceBitSet	expandFaces (MeshTopology topology, FaceBitSet region, UndirectedEdgeBitSet stopEdges=None)

None	expandPixelMask (PixelBitSet mask, RectIndexer indexer, int expansion=1)

None	expandVoxelsMask (VoxelBitSet mask, VolumeIndexer indexer, int expansion=1)

ObjectGcode	exportToolPathToGCode (std_vector_GCommand commands)

std_vector_Id_EdgeTag	extendAllHoles (Mesh mesh, Plane3f plane, FaceBitSet outNewFaces=None)

Id_EdgeTag	extendHole (Mesh mesh, Id_EdgeTag a, Plane3f plane, FaceBitSet outNewFaces=None)

Id_EdgeTag	extendHole (Mesh mesh, Id_EdgeTag a, func_Vector3_float_from_Vector3_float getVertPos, FaceBitSet outNewFaces=None)

std_vector_std_vector_Id_EdgeTag	extractClosedLoops (MeshTopology topology, std_vector_Id_EdgeTag inEdges, EdgeBitSet outNotLoopEdges=None)

std_vector_std_vector_Id_EdgeTag	extractClosedLoops (MeshTopology topology, EdgeBitSet edges)

std_vector_std_vector_Vector3_float	extractIntersectionContours (Mesh meshA, Mesh meshB, std_vector_std_vector_VariableEdgeTri orientedContours, CoordinateConverters converters, AffineXf3f rigidB2A=None)

std_vector_std_vector_EdgePoint	extractIsolines (MeshTopology topology, func_float_from_Id_VertTag vertValues, FaceBitSet region=None)

std_vector_std_vector_EdgePoint	extractIsolines (MeshTopology topology, VertScalars vertValues, float isoValue, FaceBitSet region=None)

std_vector_Id_EdgeTag	extractLongestClosedLoop (Mesh mesh, std_vector_Id_EdgeTag inEdges)

std_vector_std_vector_EdgePoint	extractPlaneSections (MeshPart mp, Plane3f plane)

std_vector_EdgeSegment	extractSectionsFromPolyline (Polyline3 polyline, Plane3f plane, float eps)

std_vector_std_vector_EdgePoint	extractXYPlaneSections (MeshPart mp, float zLevel)

None	faceMapsComposition (FaceMap a2b, FaceMap b2c)

FaceBitSet	fillContourLeft (MeshTopology topology, std_vector_Id_EdgeTag contour)

FaceBitSet	fillContourLeft (MeshTopology topology, std_vector_std_vector_Id_EdgeTag contours)

FaceBitSet	fillContourLeftByGraphCut (MeshTopology topology, std_vector_Id_EdgeTag contour, func_float_from_Id_EdgeTag metric)

FaceBitSet	fillContourLeftByGraphCut (MeshTopology topology, std_vector_std_vector_Id_EdgeTag contours, func_float_from_Id_EdgeTag metric)

None	fillContours2D (Mesh mesh, std_vector_Id_EdgeTag holeRepresentativeEdges)

None	fillHole (Mesh mesh, Id_EdgeTag a, FillHoleParams params='MR::FillHoleParams{}')

FaceBitSet	fillHoleNicely (Mesh mesh, Id_EdgeTag holeEdge, FillHoleNicelySettings settings)

VertId	fillHoleTrivially (Mesh mesh, Id_EdgeTag a, FaceBitSet outNewFaces=None)

None	fillHoles (Mesh mesh, std_vector_Id_EdgeTag as_, FillHoleParams params='MR::FillHoleParams{}')

None	filterCreaseEdges (Mesh mesh, UndirectedEdgeBitSet creaseEdges, float critLength, bool filterComponents=True, bool filterBranches=False)

tuple[bool, int]	filterHistoryActionsVector (std_vector_std_shared_ptr_HistoryAction historyVector, func_bool_from_std_shared_ptr_HistoryAction filteringCondition, int firstRedoIndex=0, bool deepFiltering=True)

Triangulation	findAlphaShapeAllTriangles (PointCloud cloud, float radius)

None	findAlphaShapeNeiTriangles (PointCloud cloud, VertId v, float radius, Triangulation appendTris, std_vector_Id_VertTag neis, bool onlyLargerVids)

float	findAvgPointsRadius (PointCloud pointCloud, int avgPoints, int samples=1024)

std_vector_Vector3_float	findBestFreeformDeformation (Box3f box, std_vector_Vector3_float source, std_vector_Vector3_float target, Vector3i resolution='Vector3i::diagonal(2)', AffineXf3f samplesToBox=None)

VertBitSet	findCloseVertices (Mesh mesh, float closeDist, func_bool_from_float cb='MR::ProgressCallback{}')

VertBitSet	findCloseVertices (PointCloud cloud, float closeDist, func_bool_from_float cb='MR::ProgressCallback{}')

VertBitSet	findCloseVertices (VertCoords points, float closeDist, VertBitSet valid=None, func_bool_from_float cb='MR::ProgressCallback{}')

VertBitSet	findCloseVertices (VertMap smallestMap)

std_vector_EdgePointPair	findCollidingEdgePairs (Polyline2 a, Polyline2 b, AffineXf2f rigidB2A=None, bool firstIntersectionOnly=False)

PreciseCollisionResult	findCollidingEdgeTrisPrecise (MeshPart a, MeshPart b, func_Vector3_int_from_Vector3_float conv, AffineXf3f rigidB2A=None, bool anyIntersection=False)

std_vector_EdgeTri	findCollidingEdgeTrisPrecise (Mesh a, std_vector_Id_EdgeTag edgesA, Mesh b, std_vector_Id_FaceTag facesB, func_Vector3_int_from_Vector3_float conv, AffineXf3f rigidB2A=None)

std_vector_EdgeTri	findCollidingEdgeTrisPrecise (Mesh a, std_vector_Id_FaceTag facesA, Mesh b, std_vector_Id_EdgeTag edgesB, func_Vector3_int_from_Vector3_float conv, AffineXf3f rigidB2A=None)

std_vector_UndirectedEdgeUndirectedEdge	findCollidingEdges (Polyline2 a, Polyline2 b, AffineXf2f rigidB2A=None, bool firstIntersectionOnly=False)

tuple[UndirectedEdgeBitSet, UndirectedEdgeBitSet]	findCollidingEdgesBitsets (Polyline2 a, Polyline2 b, AffineXf2f rigidB2A=None)

tuple[FaceBitSet, FaceBitSet]	findCollidingTriangleBitsets (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None)

std_vector_FaceFace	findCollidingTriangles (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None, bool firstIntersectionOnly=False)

FaceBitSet	findDegenerateFaces (MeshPart mp, float criticalAspectRatio=3.4028234663852886e+38, func_bool_from_float cb='MR::ProgressCallback{}')

VertId	findDirMax (Vector3f dir, MeshPart mp, UseAABBTree u='UseAABBTree::Yes')

MeshMeshDistanceResult	findDistance (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None, float upDistLimitSq=3.4028234663852886e+38)

None	findEdgesInBall (Polyline2 polyline, Vector2f center, float radius, func_void_from_Id_UndirectedEdgeTag_Vector2_float_float foundCallback, AffineXf2f xf=None)

None	findEdgesInBall (Polyline3 polyline, Vector3f center, float radius, func_void_from_Id_UndirectedEdgeTag_Vector3_float_float foundCallback, AffineXf3f xf=None)

UndirectedEdgeBitSet	findExtremeEdges (Mesh mesh, VertScalars field, ExtremeEdgeType type)

None	findFewClosestPoints (Vector3f pt, PointCloud pc, FewSmallest_PointsProjectionResult res, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0)

IOFilter	findFilter (std_vector_IOFilter filters, str extension)

VertBitSet	findHalfSpacePoints (PointCloud pc, Plane3f plane)

FaceBitSet	findHoleComplicatingFaces (Mesh mesh)

InSphere	findInSphere (Mesh mesh, MeshPoint m, InSphereSearchSettings settings)

InSphere	findInSphere (Mesh mesh, VertId v, InSphereSearchSettings settings)

FaceBitSet	findInnerShellFacesWithSplits (MeshPart mp, Mesh shell, FindInnerShellSettings settings='MR::FindInnerShellSettings{}')

VertBitSet	findInnerShellVerts (MeshPart mp, Mesh shell, FindInnerShellSettings settings='MR::FindInnerShellSettings{}')

std_vector_std_vector_Vector3_float	findIntersectionContours (Mesh meshA, Mesh meshB, AffineXf3f rigidB2A=None)

std_vector_std_vector_Id_EdgeTag	findLeftBoundary (MeshTopology topology, FaceBitSet region=None)

std_vector_std_vector_Id_EdgeTag	findLeftBoundaryInsideMesh (MeshTopology topology, FaceBitSet region)

float	findMaxDistanceSq (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None, float maxDistanceSq=3.4028234663852886e+38)

float	findMaxDistanceSq (PointCloud a, PointCloud b, AffineXf3f rigidB2A=None, float maxDistanceSq=3.4028234663852886e+38)

float	findMaxDistanceSqOneWay (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None, float maxDistanceSq=3.4028234663852886e+38)

float	findMaxDistanceSqOneWay (PointCloud a, PointCloud b, AffineXf3f rigidB2A=None, float maxDistanceSq=3.4028234663852886e+38)

None	findMaxVectorDim (int_output dimX, int_output dimY, int_output dimZ, Vector3f dir)

None	findMaxVectorDim (int_output dimX, int_output dimY, int_output dimZ, Vector3d dir)

None	findMeshEdgesInBall (Mesh mesh, AABBTreePolyline3 tree, Vector3f center, float radius, func_void_from_Id_UndirectedEdgeTag_Vector3_float_float foundCallback, AffineXf3f xf=None)

std_vector_std_pair_Id_VertTag_Id_VertTag	findMultipleEdges (MeshTopology topology, func_bool_from_float cb='MR::ProgressCallback{}')

Buffer_VertId	findNClosestPointsPerPoint (PointCloud pc, int numNei, func_bool_from_float progress='MR::ProgressCallback{}')

VertBitSet	findNRingVerts (MeshTopology topology, int n, VertBitSet region=None)

VertBitSet	findNeighborVerts (Mesh mesh, PointOnFace start, float range)

std_vector_TaggedBitSet_FaceTag	findOverhangs (Mesh mesh, FindOverhangsSettings settings)

FaceBitSet	findOverlappingTris (MeshPart mp, FindOverlappingSettings settings)

None	findPointsInBall (PointCloud pointCloud, Vector3f center, float radius, func_void_from_Id_VertTag_Vector3_float foundCallback, AffineXf3f xf=None)

None	findPointsInBall (Mesh mesh, Vector3f center, float radius, func_void_from_Id_VertTag_Vector3_float foundCallback, AffineXf3f xf=None)

None	findPointsInBall (AABBTreePoints tree, Vector3f center, float radius, func_void_from_Id_VertTag_Vector3_float foundCallback, AffineXf3f xf=None)

MeshProjectionResult	findProjection (Vector3f pt, MeshPart mp, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0, func_bool_from_Id_FaceTag validFaces='MR::FacePredicate{}', func_bool_from_MeshProjectionResult validProjections='std::function< bool(const MR::MeshProjectionResult &)>{}')

PolylineProjectionResult3	findProjectionOnMeshEdges (Vector3f pt, Mesh mesh, AABBTreePolyline3 tree, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0)

PolylineProjectionResult3	findProjectionOnMeshEdges (Line3f ln, Mesh mesh, AABBTreePolyline3 tree, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0)

PointsProjectionResult	findProjectionOnPoints (Vector3f pt, PointCloud pc, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0, func_bool_from_Id_VertTag skipCb='MR::VertPredicate{}')

PolylineProjectionResult3	findProjectionOnPolyline (Vector3f pt, Polyline3 polyline, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0)

PolylineProjectionResult3	findProjectionOnPolyline (Line3f ln, Polyline3 polyline, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0)

PolylineProjectionResult2	findProjectionOnPolyline2 (Vector2f pt, Polyline2 polyline, float upDistLimitSq=3.4028234663852886e+38, AffineXf2f xf=None, float loDistLimitSq=0)

Polyline2ProjectionWithOffsetResult	findProjectionOnPolyline2WithOffset (Vector2f pt, Polyline2 polyline, UndirectedEdgeScalars offsetPerEdge, float upDistLimit=3.4028234663852886e+38, AffineXf2f xf=None, float loDistLimit=0)

PolylineProjectionWithOffsetResult3	findProjectionOnPolylineWithOffset (Vector3f pt, Polyline3 polyline, UndirectedEdgeScalars offsetPerEdge, float upDistLimit=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimit=0)

MeshProjectionResult	findProjectionSubtree (Vector3f pt, MeshPart mp, AABBTree tree, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0, func_bool_from_Id_FaceTag validFaces='MR::FacePredicate{}', func_bool_from_MeshProjectionResult validProjections='std::function< bool(const MR::MeshProjectionResult &)>{}')

UndirectedEdgeBitSet	findRegionBoundaryUndirectedEdgesInsideMesh (MeshTopology topology, FaceBitSet region)

FaceBitSet	findRegionOuterFaces (MeshTopology topology, FaceBitSet region)

Triangulation	findRepeatedOrientedTriangles (AllLocalTriangulations triangs, int repetitions)

None	findRepeatedOrientedTriangles (AllLocalTriangulations triangs, Triangulation outRep3, Triangulation outRep2)

std_vector_UnorientedTriangle	findRepeatedUnorientedTriangles (AllLocalTriangulations triangs, int repetitions)

VertBitSet	findRepeatedVertsOnHoleBd (MeshTopology topology)

std_vector_std_vector_Id_EdgeTag	findRightBoundary (MeshTopology topology, FaceBitSet region=None)

Vector2i	findSegmentSegmentIntersectionPrecise (Vector2i a, Vector2i b, Vector2i c, Vector2i d)

Vector2f	findSegmentSegmentIntersectionPrecise (Vector2f a, Vector2f b, Vector2f c, Vector2f d, CoordinateConverters2 converters)

std_vector_EdgePointPair	findSelfCollidingEdgePairs (Polyline2 polyline)

std_vector_UndirectedEdgeUndirectedEdge	findSelfCollidingEdges (Polyline2 polyline)

UndirectedEdgeBitSet	findSelfCollidingEdgesBS (Polyline2 polyline)

bool	findSelfCollidingTriangles (MeshPart mp, std_vector_FaceFace outCollidingPairs, func_bool_from_float cb='MR::ProgressCallback{}', Face2RegionMap regionMap=None)

std_vector_FaceFace	findSelfCollidingTriangles (MeshPart mp, func_bool_from_float cb='MR::ProgressCallback{}', Face2RegionMap regionMap=None)

FaceBitSet	findSelfCollidingTrianglesBS (MeshPart mp, func_bool_from_float cb='MR::ProgressCallback{}', Face2RegionMap regionMap=None)

UndirectedEdgeBitSet	findShortEdges (MeshPart mp, float criticalLength, func_bool_from_float cb='MR::ProgressCallback{}')

SignedDistanceToMeshResult	findSignedDistance (Vector3f pt, MeshPart mp, float upDistLimitSq=3.4028234663852886e+38, float loDistLimitSq=0)

MeshMeshSignedDistanceResult	findSignedDistance (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None, float upDistLimitSq=3.4028234663852886e+38)

BitSet	findSkyRays (Mesh terrain, VertCoords samples, VertBitSet validSamples, std_vector_SkyPatch skyPatches, std_vector_MeshIntersectionResult outIntersections=None)

VertMap	findSmallestCloseVertices (Mesh mesh, float closeDist, func_bool_from_float cb='MR::ProgressCallback{}')

VertMap	findSmallestCloseVertices (PointCloud cloud, float closeDist, func_bool_from_float cb='MR::ProgressCallback{}')

VertMap	findSmallestCloseVertices (VertCoords points, float closeDist, VertBitSet valid=None, func_bool_from_float cb='MR::ProgressCallback{}')

VertMap	findSmallestCloseVerticesUsingTree (VertCoords points, float closeDist, AABBTreePoints tree, VertBitSet valid, func_bool_from_float cb='MR::ProgressCallback{}')

EdgePoint	findSteepestDescentPoint (MeshPart mp, VertScalars field, VertId v)

EdgePoint	findSteepestDescentPoint (MeshPart mp, VertScalars field, EdgePoint ep)

EdgePoint	findSteepestDescentPoint (MeshPart mp, VertScalars field, MeshTriPoint tp)

int	findSubstringCaseInsensitive (str string, str substring)

Vector3f	findTriangleSegmentIntersectionPrecise (Vector3f a, Vector3f b, Vector3f c, Vector3f d, Vector3f e, CoordinateConverters converters)

None	findTrisInBall (MeshPart mp, Ball ball, func_Processing_from_MeshProjectionResult_Ball foundCallback, func_bool_from_Id_FaceTag validFaces='MR::FacePredicate{}')

std_vector_std_pair_Id_EdgeTag_Id_EdgeTag	findTwinEdgePairs (Mesh mesh, float closeDist)

EdgeBitSet	findTwinEdges (Mesh mesh, float closeDist)

EdgeBitSet	findTwinEdges (std_vector_std_pair_Id_EdgeTag_Id_EdgeTag pairs)

phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag	findTwinUndirectedEdgeHashMap (std_vector_std_pair_Id_EdgeTag_Id_EdgeTag pairs)

phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag	findTwinUndirectedEdgeHashMap (Mesh mesh, float closeDist)

UndirectedEdgeBitSet	findTwinUndirectedEdges (Mesh mesh, float closeDist)

UndirectedEdgeBitSet	findTwinUndirectedEdges (std_vector_std_pair_Id_EdgeTag_Id_EdgeTag pairs)

tuple[VertId, VertId]	findTwoClosestPoints (PointCloud pc, func_bool_from_float progress='MR::ProgressCallback{}')

None	findUndercuts (Mesh mesh, Vector3f upDirection, FaceBitSet outUndercuts)

None	findUndercuts (Mesh mesh, Vector3f upDirection, VertBitSet outUndercuts)

float	findUndercuts (Mesh mesh, Vector3f upDirection, FaceBitSet outUndercuts, func_double_from_TaggedBitSet_FaceTag_Vector3_float metric)

None	fixMultipleEdges (Mesh mesh, std_vector_std_pair_Id_VertTag_Id_VertTag multipleEdges)

None	fixMultipleEdges (Mesh mesh)

None	fixSelfIntersections (Mesh mesh, float voxelSize)

None	fixUndercuts (Mesh mesh, Vector3f upDirection, float voxelSize=0.0, float bottomExtension=0.0)

None	fixUndercuts (Mesh mesh, FaceBitSet selectedArea, Vector3f upDirection, float voxelSize=0.0, float bottomExtension=0.0)

VdbVolume	floatGridToVdbVolume (OpenVdbFloatGrid grid)

str	formatNoTrailingZeros (char_output fmt, float v, int digitsAfterPoint, int precision=6)

bool	fromSameTriangle (MeshTopology topology, EdgePoint a, EdgePoint b)

bool	fromSameTriangle (MeshTopology topology, MeshTriPoint a, MeshTriPoint b)

LoadedObjectT	fromSceneMison (os.PathLike path, func_bool_from_float callback='MR::ProgressCallback{}')

LoadedObjectT	fromSceneMison (typing.Any in_, func_bool_from_float callback='MR::ProgressCallback{}')

SimpleVolumeMinMax	functionVolumeToSimpleVolume (FunctionVolume volume, func_bool_from_float callback='MR::ProgressCallback{}')

Mesh	generalOffsetMesh (MeshPart mp, float offset, GeneralOffsetParameters params)

AffineXf3f	getAligningXf (PointToPlaneAligningTransform p2pl, ICPMode mode, float angleLimit, float scaleLimit, Vector3f fixedRotationAxis)

std_vector_TaggedBitSet_FaceTag	getAllComponents (MeshPart meshPart, MeshComponents.FaceIncidence incidence='FaceIncidence::PerEdge', func_bool_from_Id_UndirectedEdgeTag isCompBd='MR::UndirectedEdgePredicate{}')

tuple[std_vector_TaggedBitSet_FaceTag, int]	getAllComponents (MeshPart meshPart, int maxComponentCount, MeshComponents.FaceIncidence incidence='FaceIncidence::PerEdge', func_bool_from_Id_UndirectedEdgeTag isCompBd='MR::UndirectedEdgePredicate{}')

std_vector_TaggedBitSet_FaceTag	getAllComponents (Face2RegionMap componentsMap, int componentsCount, FaceBitSet region, int maxComponentCount)

std_vector_TaggedBitSet_VertTag	getAllComponentsVerts (Mesh mesh, VertBitSet region=None)

std_vector_IOFilter	getAllFilters ()

std_vector_std_shared_ptr_Object	getAllObjectsInTree_Object (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectDistanceMap	getAllObjectsInTree_ObjectDistanceMap (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectLines	getAllObjectsInTree_ObjectLines (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectLinesHolder	getAllObjectsInTree_ObjectLinesHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectMesh	getAllObjectsInTree_ObjectMesh (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectMeshHolder	getAllObjectsInTree_ObjectMeshHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectPoints	getAllObjectsInTree_ObjectPoints (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectPointsHolder	getAllObjectsInTree_ObjectPointsHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectVoxels	getAllObjectsInTree_ObjectVoxels (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_VisualObject	getAllObjectsInTree_VisualObject (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

UndirectedEdgeId	getAt (Buffer_UndirectedEdgeId_UndirectedEdgeId bmap, UndirectedEdgeId key, UndirectedEdgeId def_='MR::UndirectedEdgeId{}')

BooleanResultPoints	getBooleanPoints (Mesh meshA, Mesh meshB, BooleanOperation operation, AffineXf3f rigidB2A=None)

FaceBitSet	getBoundaryFaces (MeshTopology topology, FaceBitSet region)

VertBitSet	getBoundaryVerts (MeshTopology topology, FaceBitSet region=None)

str	getCancelMessage (os.PathLike path)

FillHoleMetric	getCircumscribedMetric (Mesh mesh)

FillHoleMetric	getComplexFillMetric (Mesh mesh, Id_EdgeTag e)

FillHoleMetric	getComplexStitchMetric (Mesh mesh)

int	getContourPlaneIntersections (std_vector_Vector3_float path, Plane3f plane, std_vector_Vector3_float outIntersections=None)

str	getCurrentStacktrace ()

str	getCurrentStacktraceInline ()

Object	getDepthFirstObject_Object (Object root, ObjectSelectivityType type)

ObjectDistanceMap	getDepthFirstObject_ObjectDistanceMap (Object root, ObjectSelectivityType type)

ObjectLines	getDepthFirstObject_ObjectLines (Object root, ObjectSelectivityType type)

ObjectLinesHolder	getDepthFirstObject_ObjectLinesHolder (Object root, ObjectSelectivityType type)

ObjectMesh	getDepthFirstObject_ObjectMesh (Object root, ObjectSelectivityType type)

ObjectMeshHolder	getDepthFirstObject_ObjectMeshHolder (Object root, ObjectSelectivityType type)

ObjectPoints	getDepthFirstObject_ObjectPoints (Object root, ObjectSelectivityType type)

ObjectPointsHolder	getDepthFirstObject_ObjectPointsHolder (Object root, ObjectSelectivityType type)

ObjectVoxels	getDepthFirstObject_ObjectVoxels (Object root, ObjectSelectivityType type)

VisualObject	getDepthFirstObject_VisualObject (Object root, ObjectSelectivityType type)

FillHoleMetric	getEdgeLengthFillMetric (Mesh mesh)

FillHoleMetric	getEdgeLengthStitchMetric (Mesh mesh)

UndirectedEdgeBMap	getEdgeOrdering (FaceBMap faceMap, MeshTopology topology)

FaceBitSet	getFacesByMinEdgeLength (Mesh mesh, float minLength)

Vector3f	getFeatureDirection (FeatureObject feature)

Vector3f	getFeatureNormal (FeatureObject feature)

std_unordered_set_std_string	getFeaturesTypeWithDirections ()

std_unordered_set_std_string	getFeaturesTypeWithNormals ()

HoleFillPlan	getHoleFillPlan (Mesh mesh, Id_EdgeTag e, FillHoleParams params='MR::FillHoleParams{}')

str	getICPStatusInfo (int iterations, ICPExitType exitType)

UndirectedEdgeBitSet	getIncidentEdges (MeshTopology topology, FaceBitSet faces)

UndirectedEdgeBitSet	getIncidentEdges (MeshTopology topology, UndirectedEdgeBitSet edges)

FaceBitSet	getIncidentFaces (MeshTopology topology, VertBitSet verts)

FaceBitSet	getIncidentFaces (MeshTopology topology, UndirectedEdgeBitSet edges)

VertBitSet	getIncidentVerts (MeshTopology topology, FaceBitSet faces)

VertBitSet	getIncidentVerts (MeshTopology topology, FaceBitSet faces, VertBitSet store)

VertBitSet	getIncidentVerts (MeshTopology topology, UndirectedEdgeBitSet edges)

VertBitSet	getIncidentVerts (MeshTopology topology, UndirectedEdgeBitSet edges, VertBitSet store)

UndirectedEdgeBitSet	getInnerEdges (MeshTopology topology, VertBitSet verts)

UndirectedEdgeBitSet	getInnerEdges (MeshTopology topology, FaceBitSet region)

FaceBitSet	getInnerFaces (MeshTopology topology, VertBitSet verts)

VertBitSet	getInnerVerts (MeshTopology topology, FaceBitSet region=None)

VertBitSet	getInnerVerts (MeshTopology topology, UndirectedEdgeBitSet edges)

FillHoleMetric	getMaxDihedralAngleMetric (Mesh mesh)

float	getMeanSqDistToPlane (IPointPairs pairs)

float	getMeanSqDistToPoint (IPointPairs pairs)

MeshOrPoints	getMeshOrPoints (VisualObject obj)

FillHoleMetric	getMinAreaMetric (Mesh mesh)

FillHoleMetric	getMinTriAngleMetric (Mesh mesh)

FaceBitSet	getNeighborFaces (MeshTopology topology, UndirectedEdgeBitSet edges)

int	getNumActivePairs (IPointPairs pairs)

int	getNumNodes (int numLeaves)

int	getNumSamples (IPointPairs pairs)

str	getOSNoSpaces ()

std_vector_OneMeshContour	getOneMeshIntersectionContours (Mesh meshA, Mesh meshB, std_vector_std_vector_VariableEdgeTri contours, bool getMeshAIntersections, CoordinateConverters converters, AffineXf3f rigidB2A=None)

FaceBMap	getOptimalFaceOrdering (Mesh mesh)

FillHoleMetric	getParallelPlaneFillMetric (Mesh mesh, Id_EdgeTag e, Plane3f plane=None)

int	getPathEdgesInPlane (Mesh mesh, std_vector_Id_EdgeTag path, Plane3f plane, float tolerance=0.0, std_vector_Id_EdgeTag outInPlaneEdges=None)

int	getPathPlaneIntersections (Mesh mesh, std_vector_Id_EdgeTag path, Plane3f plane, std_vector_EdgePoint outIntersections=None)

HoleFillPlan	getPlanarHoleFillPlan (Mesh mesh, Id_EdgeTag e)

FillHoleMetric	getPlaneFillMetric (Mesh mesh, Id_EdgeTag e)

FillHoleMetric	getPlaneNormalizedFillMetric (Mesh mesh, Id_EdgeTag e)

VertBitSet	getRegionBoundaryVerts (MeshTopology topology, FaceBitSet region)

EdgeBitSet	getRegionEdges (MeshTopology topology, FaceBitSet faces)

int	getStreamSize (typing.Any in_)

FaceBitSet	getSubdividePart (FaceBitSet valids, int subdivideParts, int myPart)

NumSum	getSumSqDistToPlane (IPointPairs pairs, std_optional_double inaccuracy='std::optional< double >{}')

NumSum	getSumSqDistToPoint (IPointPairs pairs, std_optional_double inaccuracy='std::optional< double >{}')

std_vector_std_vector_EdgePoint	getSurfacePathsViaVertices (Mesh mesh, VertBitSet vs)

SystemMemory	getSystemMemory ()

func_Vector3_float_from_Vector3_int	getToFloatConverter (Box3d box)

func_Vector3_int_from_Vector3_float	getToIntConverter (Box3d box)

std_vector_std_shared_ptr_Object	getTopmostVisibleObjects_Object (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectDistanceMap	getTopmostVisibleObjects_ObjectDistanceMap (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectLines	getTopmostVisibleObjects_ObjectLines (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectLinesHolder	getTopmostVisibleObjects_ObjectLinesHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectMesh	getTopmostVisibleObjects_ObjectMesh (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectMeshHolder	getTopmostVisibleObjects_ObjectMeshHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectPoints	getTopmostVisibleObjects_ObjectPoints (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectPointsHolder	getTopmostVisibleObjects_ObjectPointsHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_ObjectVoxels	getTopmostVisibleObjects_ObjectVoxels (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

std_vector_std_shared_ptr_VisualObject	getTopmostVisibleObjects_VisualObject (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable')

func_float_from_char_const	getTypeConverter (ScalarType scalarType, int range, int min)

FillHoleMetric	getUniversalMetric (Mesh mesh)

os.PathLike	getUserConfigDir ()

os.PathLike	getUserConfigFilePath ()

float	getValue (OpenVdbFloatGrid grid, Vector3i p)

CoordinateConverters	getVectorConverters (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None)

MeshTriPoint	getVertexAsMeshTriPoint (MeshTopology topology, Id_EdgeTag e, VertId v)

VertBMap	getVertexOrdering (FaceBMap faceMap, MeshTopology topology)

std_vector_Id_VertTag	getVertexOrdering (MeshTopology topology, VertBitSet region)

FillHoleMetric	getVerticalStitchMetric (Mesh mesh, Vector3f upDir)

AffineXf3f	getXfFromOxyPlane (std_vector_std_vector_Vector3_float contours)

AffineXf3f	getXfFromOxyPlane (Mesh mesh, std_vector_std_vector_Id_EdgeTag paths)

Mesh	gridToMesh (OpenVdbFloatGrid grid, GridToMeshSettings settings)

None	hardSmoothTetrahedrons (Mesh mesh, VertBitSet region=None)

bool	hasAnyIsoline (MeshTopology topology, func_float_from_Id_VertTag vertValues, FaceBitSet region=None)

bool	hasAnyIsoline (MeshTopology topology, VertScalars vertValues, float isoValue, FaceBitSet region=None)

bool	hasAnyPlaneSection (MeshPart mp, Plane3f plane)

bool	hasAnyXYPlaneSection (MeshPart mp, float zLevel)

bool	hasMultipleEdges (MeshTopology topology)

bool	hasProhibitedChars (str line)

int	heapBytes (OpenVdbFloatGrid grid)

int	heapBytes_Color (std_vector_Color vec)

int	heapBytes_Mesh (Mesh ptr)

int	heapBytes_MeshTexture_TextureId (Vector_MeshTexture_TextureId vec)

int	heapBytes_Object (Object ptr)

int	heapBytes_OpenVdbFloatGrid (OpenVdbFloatGrid ptr)

int	heapBytes_PointCloud (PointCloud ptr)

int	heapBytes_Polyline3 (Polyline3 ptr)

int	heapBytes_float (std_vector_float vec)

int	heapBytes_std_shared_ptr_Object (std_vector_std_shared_ptr_Object vec)

int	heapBytes_unsigned_long (std_vector_unsigned_long vec)

func_float_from_Id_EdgeTag	identityMetric ()

bool	improveSampling (PointCloud cloud, VertBitSet samples, ImproveSamplingSettings settings)

None	inflate (Mesh mesh, VertBitSet verts, InflateSettings settings)

None	interpolateArcs (std_vector_GCommand commands, ArcInterpolationParams params, Axis axis)

None	interpolateLines (std_vector_GCommand commands, LineInterpolationParams params, Axis axis)

Vector2f	intersection (LineSegm2f segm1, LineSegm2f segm2)

bool	isClosed (std_vector_Vector3_float c)

bool	isDegree3Dest (MeshTopology topology, Id_EdgeTag e)

bool	isEdgeBetweenDoubleTris (MeshTopology topology, Id_EdgeTag e)

bool	isEdgeLoop (MeshTopology topology, std_vector_Id_EdgeTag edges)

bool	isEdgePath (MeshTopology topology, std_vector_Id_EdgeTag edges)

bool	isHoleBd (MeshTopology topology, std_vector_Id_EdgeTag loop)

bool	isInside (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None)

bool	isInside (Polyline2 a, Polyline2 b, AffineXf2f rigidB2A=None)

bool	isNanFast (float f)

bool	isNonIntersectingInside (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None)

bool	isNonIntersectingInside (Mesh a, FaceId partFace, MeshPart b, AffineXf3f rigidB2A=None)

bool	isPickedPointValid (VisualObject object, std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int point)

bool	isPointInsidePolyline (Polyline2 polyline, Vector2f point)

bool	isSupportedFileInSubfolders (os.PathLike folder)

bool	isTIFFFile (os.PathLike path)

Id_EdgeTag	isVertexRepeatedOnHoleBd (MeshTopology topology, VertId v)

ToolPathResult	lacingToolPath (MeshPart mp, ToolPathParams params, Axis cutDirection)

IteratorRange_RingIterator_NextEdgeSameLeft	leftRing (MeshTopology topology, FaceId f)

IteratorRange_RingIterator_NextEdgeSameLeft	leftRing (MeshTopology topology, Id_EdgeTag edge)

IteratorRange_RingIterator_NextEdgeSameLeft	leftRing0 (MeshTopology topology, Id_EdgeTag edge)

Mesh	loadASCIIStl (os.PathLike file, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadASCIIStl (typing.Any in_, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadBinaryStl (os.PathLike file, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadBinaryStl (typing.Any in_, MeshLoadSettings settings='MR::MeshLoadSettings{}')

DistanceMap	loadDistanceMapFromImage (os.PathLike filename, float threshold=0.003921568859368563)

Mesh	loadDxf (os.PathLike path, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadDxf (typing.Any in_, MeshLoadSettings settings='MR::MeshLoadSettings{}')

None	loadIOExtras ()

Polyline3	loadLines (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

Polyline3	loadLines (typing.Any in_, str extension, func_bool_from_float callback='MR::ProgressCallback{}')

Mesh	loadMesh (os.PathLike file, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadMesh (typing.Any in_, str extension, MeshLoadSettings settings='MR::MeshLoadSettings{}')

None	loadMeshDll ()

Mesh	loadMrmesh (os.PathLike file, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadMrmesh (typing.Any in_, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadObj (os.PathLike file, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadObj (typing.Any in_, MeshLoadSettings settings='MR::MeshLoadSettings{}')

LoadedObjects	loadObjectFromFile (os.PathLike filename, func_bool_from_float callback='MR::ProgressCallback{}')

Mesh	loadOff (os.PathLike file, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadOff (typing.Any in_, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadPly (os.PathLike file, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadPly (typing.Any in_, MeshLoadSettings settings='MR::MeshLoadSettings{}')

PointCloud	loadPoints (os.PathLike file, PointsLoadSettings settings='MR::PointsLoadSettings{}')

PointCloud	loadPoints (typing.Any in_, str extension, PointsLoadSettings settings='MR::PointsLoadSettings{}')

LoadedObjectT	loadSceneFromAnySupportedFormat (os.PathLike path, func_bool_from_float callback='MR::ProgressCallback{}')

Object	loadSceneObject (os.PathLike path, func_bool_from_float callback='MR::ProgressCallback{}')

Mesh	loadStl (os.PathLike file, MeshLoadSettings settings='MR::MeshLoadSettings{}')

Mesh	loadStl (typing.Any in_, MeshLoadSettings settings='MR::MeshLoadSettings{}')

std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid	loadVoxels (os.PathLike file, func_bool_from_float cb='MR::ProgressCallback{}')

VdbVolume	loadVoxelsGav (os.PathLike file, func_bool_from_float cb='MR::ProgressCallback{}')

VdbVolume	loadVoxelsGav (typing.Any in_, func_bool_from_float cb='MR::ProgressCallback{}')

VdbVolume	loadVoxelsRaw (os.PathLike file, VoxelsLoad.RawParameters params, func_bool_from_float cb='MR::ProgressCallback{}')

VdbVolume	loadVoxelsRaw (os.PathLike file, func_bool_from_float cb='MR::ProgressCallback{}')

VdbVolume	loadVoxelsRaw (typing.Any in_, VoxelsLoad.RawParameters params, func_bool_from_float cb='MR::ProgressCallback{}')

FaceBitSet	localFindSelfIntersections (Mesh mesh, func_bool_from_float cb='MR::ProgressCallback{}')

None	localFixSelfIntersections (Mesh mesh, SelfIntersections.Settings settings)

Mesh	makeArrow (Vector3f base, Vector3f vert, float thickness=0.05000000074505806, float coneRadius=0.10000000149011612, float coneSize=0.20000000298023224, int qual=32)

Mesh	makeBasisAxes (float size=1.0, float thickness=0.05000000074505806, float coneRadius=0.10000000149011612, float coneSize=0.20000000298023224, int qual=32)

bool	makeBridge (MeshTopology topology, Id_EdgeTag a, Id_EdgeTag b, FaceBitSet outNewFaces=None)

Id_EdgeTag	makeBridgeEdge (MeshTopology topology, Id_EdgeTag a, Id_EdgeTag b)

Mesh	makeCone (float radius0=0.10000000149011612, float length=1.0, int resolution=32)

Mesh	makeConvexHull (VertCoords points, VertBitSet validPoints)

Mesh	makeConvexHull (Mesh in_)

Mesh	makeConvexHull (PointCloud in_)

Mesh	makeCube (Vector3f size='Vector3f::diagonal(1.F)', Vector3f base='Vector3f::diagonal(-0.5F)')

Mesh	makeCylinder (float radius=0.10000000149011612, float length=1.0, int resolution=16)

Mesh	makeCylinderAdvanced (float radius0=0.10000000149011612, float radius1=0.10000000149011612, float start_angle=0.0, float arc_size=6.2831854820251465, float length=1.0, int resolution=16)

Id_EdgeTag	makeDegenerateBandAroundHole (Mesh mesh, Id_EdgeTag a, FaceBitSet outNewFaces=None)

None	makeDegenerateBandAroundRegion (Mesh mesh, FaceBitSet region, MakeDegenerateBandAroundRegionParams params='MR::MakeDegenerateBandAroundRegionParams{}')

int	makeDeloneEdgeFlips (Mesh mesh, DeloneSettings settings='MR::DeloneSettings{}', int numIters=1, func_bool_from_float progressCallback='MR::ProgressCallback{}')

None	makeDeloneOriginRing (Mesh mesh, Id_EdgeTag e, DeloneSettings settings='MR::DeloneSettings{}')

std_vector_Vector3_float	makeFreeFormOriginGrid (Box3f box, Vector3i resolution)

Object	makeLevelOfDetails (Mesh mesh, int maxDepth)

Mesh	makeMovementBuildBody (std_vector_std_vector_Vector3_float body, std_vector_std_vector_Vector3_float trajectory, MovementBuildBodyParams params='MR::MovementBuildBodyParams{}')

VertCoords	makeNormals (PointCloud pointCloud, int avgNeighborhoodSize=48)

ObjectDistanceMap	makeObjectDistanceMapFromFile (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

LoadedObjectT	makeObjectFromMeshFile (os.PathLike file, func_bool_from_float cb='MR::ProgressCallback{}', bool returnOnlyMesh=False)

LoadedObjects	makeObjectFromVoxelsFile (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

ObjectGcode	makeObjectGcodeFromFile (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

ObjectLines	makeObjectLinesFromFile (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

LoadedObjectT_ObjectMesh	makeObjectMeshFromFile (os.PathLike file, func_bool_from_float cb='MR::ProgressCallback{}')

ObjectPoints	makeObjectPointsFromFile (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

std_vector_std_shared_ptr_ObjectVoxels	makeObjectVoxelsFromFile (os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

Mesh	makeOpenCone (float radius=1, float zApex=0, float zBase=1, int numCircleSegments=16)

Mesh	makeOpenCylinder (float radius=1, float z1=-1, float z2=1, int numCircleSegments=16)

VertCoords	makeOrientedNormals (PointCloud pointCloud, float radius, func_bool_from_float progress='MR::ProgressCallback{}')

VertCoords	makeOrientedNormals (PointCloud pointCloud, AllLocalTriangulations triangs, func_bool_from_float progress='MR::ProgressCallback{}')

Mesh	makeOuterHalfTorus (float primaryRadius=1.0, float secondaryRadius=0.10000000149011612, int primaryResolution=16, int secondaryResolution=16, std_vector_Vector3_float points=None)

Mesh	makeParallelepiped (Vector3f side, Vector3f base)

Mesh	makePlane ()

Mesh	makePrism (float baseLength, float leftAngle, float rightAngle, float height=1.0)

Mesh	makeRegularGridMesh (int width, int height, func_bool_from_unsigned_long_unsigned_long validator, func_Vector3_float_from_unsigned_long_unsigned_long positioner, func_bool_from_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long faceValidator='MR::RegularGridMeshFaceValidator{}', func_bool_from_float cb='MR::ProgressCallback{}')

Mesh	makeRegularGridMesh (VertCoords pc, func_bool_from_float cb='MR::ProgressCallback{}')

AffineXf3d	makeRigidXf (MeshPart mp, AffineXf3d meshXf)

AffineXf3f	makeRigidXf (MeshPart mp, AffineXf3f meshXf)

None	makeSignedByWindingNumber (OpenVdbFloatGrid grid, Vector3f voxelSize, Mesh refMesh, MakeSignedByWindingNumberSettings settings)

Mesh	makeSphere (SphereParams params)

MarkedContour3f	makeSpline (MarkedContour3f in_, float markStability=1)

MarkedContour3f	makeSpline (std_vector_Vector3_float controlPoints, SplineSettings settings)

Mesh	makeTorus (float primaryRadius=1.0, float secondaryRadius=0.10000000149011612, int primaryResolution=16, int secondaryResolution=16, std_vector_Vector3_float points=None)

Mesh	makeTorusWithComponents (float primaryRadius=1.0, float secondaryRadius=0.10000000149011612, int primaryResolution=16, int secondaryResolution=16, std_vector_Vector3_float points=None)

Mesh	makeTorusWithSelfIntersections (float primaryRadius=1.0, float secondaryRadius=0.10000000149011612, int primaryResolution=16, int secondaryResolution=16, std_vector_Vector3_float points=None)

Mesh	makeTorusWithSpikes (float primaryRadius=1.0, float secondaryRadiusInner=0.10000000149011612, float secondaryRadiusOuter=0.5, int primaryResolution=16, int secondaryResolution=16, std_vector_Vector3_float points=None)

Mesh	makeTorusWithUndercut (float primaryRadius=1.0, float secondaryRadiusInner=0.10000000149011612, float secondaryRadiusOuter=0.20000000298023224, int primaryResolution=16, int secondaryResolution=16, std_vector_Vector3_float points=None)

Mesh	makeUVSphere (float radius=1.0, int horisontalResolution=16, int verticalResolution=16)

PointCloud	makeUniformSampledCloud (PointCloud pointCloud, UniformSamplingSettings settings)

VertCoords	makeUnorientedNormals (PointCloud pointCloud, float radius, func_bool_from_float progress='MR::ProgressCallback{}', OrientNormals orient='OrientNormals::Smart')

VertCoords	makeUnorientedNormals (PointCloud pointCloud, AllLocalTriangulations triangs, func_bool_from_float progress='MR::ProgressCallback{}', OrientNormals orient='OrientNormals::Smart')

VertCoords	makeUnorientedNormals (PointCloud pointCloud, Buffer_VertId closeVerts, int numNei, func_bool_from_float progress='MR::ProgressCallback{}', OrientNormals orient='OrientNormals::Smart')

None	makeVdbTopologyDense (VdbVolume volume)

Id_EdgeTag	mapEdge (WholeEdgeMap map, Id_EdgeTag src)

Id_EdgeTag	mapEdge (phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag map, Id_EdgeTag src)

UndirectedEdgeId	mapEdge (UndirectedEdgeBMap map, UndirectedEdgeId src)

UndirectedEdgeBitSet	mapEdges (WholeEdgeMap map, UndirectedEdgeBitSet src)

UndirectedEdgeBitSet	mapEdges (phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag map, UndirectedEdgeBitSet src)

UndirectedEdgeBitSet	mapEdges (UndirectedEdgeBMap map, UndirectedEdgeBitSet src)

Mesh	marchingCubes (FunctionVolume volume, MarchingCubesParams params='MR::MarchingCubesParams{}')

Mesh	marchingCubes (SimpleVolume volume, MarchingCubesParams params='MR::MarchingCubesParams{}')

Mesh	marchingCubes (SimpleVolumeMinMax volume, MarchingCubesParams params='MR::MarchingCubesParams{}')

Mesh	marchingCubes (VdbVolume volume, MarchingCubesParams params='MR::MarchingCubesParams{}')

TriMesh	marchingCubesAsTriMesh (FunctionVolume volume, MarchingCubesParams params='MR::MarchingCubesParams{}')

TriMesh	marchingCubesAsTriMesh (SimpleVolume volume, MarchingCubesParams params='MR::MarchingCubesParams{}')

TriMesh	marchingCubesAsTriMesh (SimpleVolumeMinMax volume, MarchingCubesParams params='MR::MarchingCubesParams{}')

TriMesh	marchingCubesAsTriMesh (VdbVolume volume, MarchingCubesParams params='MR::MarchingCubesParams{}')

MarkedContour3f	markedContour (std_vector_Vector3_float in_)

MarkedContour3f	markedFirstLast (std_vector_Vector3_float in_)

Mesh	mcOffsetMesh (MeshPart mp, float offset, OffsetParameters params='MR::OffsetParameters{}', Vector_Id_VoxelTag_FaceId outMap=None)

Mesh	mcShellMeshRegion (Mesh mesh, FaceBitSet region, float offset, BaseShellParameters params, Vector_Id_VoxelTag_FaceId outMap=None)

ObjectPoints	merge (std_vector_std_shared_ptr_ObjectPoints objsPoints)

ObjectLines	merge (std_vector_std_shared_ptr_ObjectLines objsLines)

ObjectMesh	merge (std_vector_std_shared_ptr_ObjectMesh objsMesh)

Mesh	mergeMeshes (std_vector_std_shared_ptr_Mesh meshes)

None	meshDenoiseViaNormals (Mesh mesh, DenoiseViaNormalsSettings settings='MR::DenoiseViaNormalsSettings{}')

Mesh	meshFromVoxelsMask (VdbVolume volume, VoxelBitSet mask)

func_void_from_Id_EdgeTag_Id_EdgeTag	meshOnEdgeSplitAttribute (Mesh mesh, MeshAttributesToUpdate params)

func_void_from_Id_EdgeTag_Id_EdgeTag	meshOnEdgeSplitFaceAttribute (Mesh mesh, MeshAttributesToUpdate params)

func_void_from_Id_EdgeTag_Id_EdgeTag	meshOnEdgeSplitVertAttribute (Mesh mesh, MeshAttributesToUpdate params)

func_bool_from_Id_EdgeTag_Vector3_float	meshPreCollapseVertAttribute (Mesh mesh, MeshAttributesToUpdate params)

SimpleVolumeMinMax	meshRegionToIndicatorVolume (Mesh mesh, FaceBitSet region, float offset, DistanceVolumeParams params)

std_array_VoxelsVolumeMinMax_std_vector_float_3	meshToDirectionVolume (MeshToDirectionVolumeParams params)

OpenVdbFloatGrid	meshToDistanceField (MeshPart mp, AffineXf3f xf, Vector3f voxelSize, float surfaceOffset=3, func_bool_from_float cb='MR::ProgressCallback{}')

FunctionVolume	meshToDistanceFunctionVolume (MeshPart mp, MeshToDistanceVolumeParams params='MR::MeshToDistanceVolumeParams{}')

SimpleVolumeMinMax	meshToDistanceVolume (MeshPart mp, MeshToDistanceVolumeParams params='MR::MeshToDistanceVolumeParams{}')

OpenVdbFloatGrid	meshToLevelSet (MeshPart mp, AffineXf3f xf, Vector3f voxelSize, float surfaceOffset=3, func_bool_from_float cb='MR::ProgressCallback{}')

PointCloud	meshToPointCloud (Mesh mesh, bool saveNormals=True, VertBitSet verts=None)

VdbVolume	meshToVolume (Mesh mesh, MeshToVolumeParams params='MR::MeshToVolumeParams{}')

float	mixed (Vector3f a, Vector3f b, Vector3f c)

float	mixed (Vector3d a, Vector3d b, Vector3d c)

int	mixed (Vector3i a, Vector3i b, Vector3i c)

VertBitSet	moveMeshToVoxelMaxDeriv (Mesh mesh, AffineXf3f meshXf, VdbVolume volume, AffineXf3f volumeXf, MoveMeshToVoxelMaxDerivSettings settings, func_bool_from_float callback='MR::ProgressCallback{}')

Vector3f	mult (Vector3f a, Vector3f b)

Vector3d	mult (Vector3d a, Vector3d b)

Vector3i	mult (Vector3i a, Vector3i b)

Vector2f	mult (Vector2f a, Vector2f b)

Vector2d	mult (Vector2d a, Vector2d b)

Vector2i	mult (Vector2i a, Vector2i b)

std_vector_ObjVertId	multiModelGridSampling (Vector_ModelPointsData_ObjId models, float voxelSize, func_bool_from_float cb='MR::ProgressCallback{}')

None	multiRayMeshIntersect (MeshPart meshPart, std_vector_Vector3_float origins, std_vector_Vector3_float dirs, MultiRayMeshIntersectResult result, float rayStart=0.0, float rayEnd=3.4028234663852886e+38, bool closestIntersect=True, func_bool_from_Id_FaceTag validFaces='MR::FacePredicate{}')

bool	objectHasSelectableChildren (Object object)

None	objectSave (Object object, os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

std_vector_std_vector_Vector2_float	offsetContours (std_vector_std_vector_Vector2_float contours, float offset, OffsetContoursParams params='MR::OffsetContoursParams{}')

std_vector_std_vector_Vector2_float	offsetContours (std_vector_std_vector_Vector2_float contours, func_float_from_int_int offset, OffsetContoursParams params='MR::OffsetContoursParams{}')

std_vector_std_vector_Vector3_float	offsetContours (std_vector_std_vector_Vector3_float contours, float offset, OffsetContoursParams params='MR::OffsetContoursParams{}', OffsetContoursRestoreZParams zParmas='MR::OffsetContoursRestoreZParams{}')

std_vector_std_vector_Vector3_float	offsetContours (std_vector_std_vector_Vector3_float contours, func_float_from_int_int offset, OffsetContoursParams params='MR::OffsetContoursParams{}', OffsetContoursRestoreZParams zParmas='MR::OffsetContoursRestoreZParams{}')

Mesh	offsetMesh (MeshPart mp, float offset, OffsetParameters params='MR::OffsetParameters{}')

Mesh	offsetOneDirection (MeshPart mp, float offset, GeneralOffsetParameters params='MR::GeneralOffsetParameters{}')

Mesh	offsetPolyline (Polyline3 polyline, float offset, OffsetParameters params='MR::OffsetParameters{}')

bool	operator (VertDistance a, VertDistance b)

OutEdge	opposite (OutEdge e)

OutEdge2	opposite (OutEdge2 e)

std_vector_std_vector_VariableEdgeTri	orderIntersectionContours (MeshTopology topologyA, MeshTopology topologyB, PreciseCollisionResult intersections)

IteratorRange_RingIterator_NextEdgeSameOrigin	orgRing (MeshTopology topology, Id_EdgeTag edge)

IteratorRange_RingIterator_NextEdgeSameOrigin	orgRing (MeshTopology topology, VertId v)

IteratorRange_RingIterator_NextEdgeSameOrigin	orgRing0 (MeshTopology topology, Id_EdgeTag edge)

bool	orient3d (Vector3i a, Vector3i b, Vector3i c)

bool	orient3d (Vector3i a, Vector3i b, Vector3i c, Vector3i d)

bool	orient3d (std_array_PreciseVertCoords_4 vs)

bool	orient3d (PreciseVertCoords vs)

None	orientLocalTriangulations (AllLocalTriangulations triangs, VertCoords coords, VertBitSet region, VertCoords targetDir)

None	orientLocalTriangulations (AllLocalTriangulations triangs, VertCoords coords, VertBitSet region, func_Vector3_float_from_Id_VertTag targetDir)

bool	orientNormals (PointCloud pointCloud, VertCoords normals, AllLocalTriangulations triangs, func_bool_from_float progress='MR::ProgressCallback{}')

bool	orientNormals (PointCloud pointCloud, VertCoords normals, Buffer_VertId closeVerts, int numNei, func_bool_from_float progress='MR::ProgressCallback{}')

bool	orientNormals (PointCloud pointCloud, VertCoords normals, float radius, func_bool_from_float progress='MR::ProgressCallback{}')

ObjectPoints	pack (ObjectPoints pts, Reorder reorder, VertBitSet newValidVerts=None, func_bool_from_float cb='MR::ProgressCallback{}')

None	parseFirstNum (str str, int_output num)

None	parsePolygon (str str, VertId vertId, int_output numPoints)

Mesh	partialOffsetMesh (MeshPart mp, float offset, GeneralOffsetParameters params='MR::GeneralOffsetParameters{}')

os.PathLike	pathFromUtf8 (str s)

Vector3f	pickedPointToVector3 (VisualObject object, std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int point)

std_vector_Vector2_float	planeSectionToContour2f (Mesh mesh, std_vector_EdgePoint section, AffineXf3f meshToPlane)

std_vector_std_vector_Vector2_float	planeSectionsToContours2f (Mesh mesh, std_vector_std_vector_EdgePoint sections, AffineXf3f meshToPlane)

VertBitSet	pointGridSampling (PointCloud cloud, float voxelSize, func_bool_from_float cb='MR::ProgressCallback{}')

VertBitSet	pointIterativeSampling (PointCloud cloud, int numSamples, func_bool_from_float cb='MR::ProgressCallback{}')

std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int	pointOnObjectToPickedPoint (VisualObject object, PointOnObject pos)

VertBitSet	pointUniformSampling (PointCloud pointCloud, UniformSamplingSettings settings)

FunctionVolume	pointsToDistanceFunctionVolume (PointCloud cloud, PointsToDistanceVolumeParams params)

SimpleVolume	pointsToDistanceVolume (PointCloud cloud, PointsToDistanceVolumeParams params)

Mesh	pointsToMeshFusion (PointCloud cloud, PointsToMeshParameters params)

Polyline2	polylineOffset (Polyline2 polyline, float pixelSize, float offset)

None	positionVertsSmoothly (Mesh mesh, VertBitSet verts, EdgeWeights edgeWeightsType='EdgeWeights::Cotan', VertBitSet fixedSharpVertices=None)

None	positionVertsSmoothlySharpBd (Mesh mesh, VertBitSet verts, VertCoords vertShifts=None, VertScalars vertStabilizers=None)

None	positionVertsWithSpacing (Mesh mesh, SpacingSettings settings)

None	printCurrentTimerBranch ()

None	printStacktraceOnCrash ()

None	printTimingTree (float minTimeSec=0.1)

None	printTimingTreeAtEnd (bool on, float minTimeSec=0.1)

None	processCloseTriangles (MeshPart mp, std_array_Vector3_float_3 t, float rangeSq, func_ProcessOneResult_from_Vector3_float_Id_FaceTag_Vector3_float_float call)

VertScalars	projectAllMeshVertices (Mesh refMesh, Mesh mesh, AffineXf3f refXf=None, AffineXf3f xf=None, float upDistLimitSq=3.4028234663852886e+38, float loDistLimitSq=0.0)

None	projectOnAll (Vector3f pt, AABBTreeObjects tree, float upDistLimitSq, func_void_from_Id_ObjTag_MeshOrPoints_ProjectionResult callback, ObjId skipObjId='MR::ObjId{}')

None	putScanFileNameInZ (std_vector_std_filesystem_path scans, std_vector_SliceInfo zOrder)

bool	rayBoxIntersect (Box3f box, RayOrigin_float rayOrigin, float_output t0, float_output t1, IntersectionPrecomputes_float prec)

MeshIntersectionResult	rayInsideIntersect (Mesh mesh, MeshPoint m, float rayEnd=3.4028234663852886e+38)

MeshIntersectionResult	rayInsideIntersect (Mesh mesh, VertId v, float rayEnd=3.4028234663852886e+38)

MeshIntersectionResult	rayMeshIntersect (MeshPart meshPart, Line3f line, float rayStart=0.0, float rayEnd=3.4028234663852886e+38, IntersectionPrecomputes_float prec=None, bool closestIntersect=True, func_bool_from_Id_FaceTag validFaces='MR::FacePredicate{}')

MeshIntersectionResult	rayMeshIntersect (MeshPart meshPart, Line3d line, float rayStart=0.0, float rayEnd=1.7976931348623157e+308, IntersectionPrecomputes_double prec=None, bool closestIntersect=True, func_bool_from_Id_FaceTag validFaces='MR::FacePredicate{}')

None	rayMeshIntersectAll (MeshPart meshPart, Line3f line, func_bool_from_MeshIntersectionResult callback, float rayStart=0.0, float rayEnd=3.4028234663852886e+38, IntersectionPrecomputes_float prec=None)

None	rayMeshIntersectAll (MeshPart meshPart, Line3d line, func_bool_from_MeshIntersectionResult callback, float rayStart=0.0, float rayEnd=1.7976931348623157e+308, IntersectionPrecomputes_double prec=None)

MultiMeshIntersectionResult	rayMultiMeshAnyIntersect (std_vector_Line3Mesh_float lineMeshes, float rayStart=0.0, float rayEnd=3.4028234663852886e+38)

MultiMeshIntersectionResult	rayMultiMeshAnyIntersect (std_vector_Line3Mesh_double lineMeshes, float rayStart=0.0, float rayEnd=1.7976931348623157e+308)

PolylineIntersectionResult2	rayPolylineIntersect (Polyline2 polyline, Line2f line, float rayStart=0, float rayEnd=3.4028234663852886e+38, IntersectionPrecomputes2_float prec=None, bool closestIntersect=True)

PolylineIntersectionResult2	rayPolylineIntersect (Polyline2 polyline, Line2d line, float rayStart=0, float rayEnd=1.7976931348623157e+308, IntersectionPrecomputes2_double prec=None, bool closestIntersect=True)

TriIntersectResult	rayTriangleIntersect (Vector3f oriA, Vector3f oriB, Vector3f oriC, IntersectionPrecomputes_float prec)

TriIntersectResult	rayTriangleIntersect (Vector3f oriA, Vector3f oriB, Vector3f oriC, Vector3f dir)

TriIntersectResult	rayTriangleIntersect (Vector3d oriA, Vector3d oriB, Vector3d oriC, IntersectionPrecomputes_double prec)

TriIntersectResult	rayTriangleIntersect (Vector3d oriA, Vector3d oriB, Vector3d oriC, Vector3d dir)

TriIntersectResult	rayTriangleIntersect_ (Vector3f oriA, Vector3f oriB, Vector3f oriC, IntersectionPrecomputes_float prec)

TriIntersectResult	rayTriangleIntersect_ (Vector3d oriA, Vector3d oriB, Vector3d oriC, IntersectionPrecomputes_double prec)

bool	readByBlocks (typing.Any in_, char_output data, int dataSize, func_bool_from_float callback='MR::ProgressCallback{}', int blockSize=65536)

None	readRawTiff (os.PathLike path, RawTiffOutput output)

str	readString (typing.Any in_)

TiffParameters	readTiffParameters (os.PathLike path)

Mesh	rebuildMesh (MeshPart mp, RebuildMeshSettings settings)

int	reducePath (Mesh mesh, MeshTriPoint start, std_vector_EdgePoint path, MeshTriPoint end, int maxIter=5)

bool	reducePathViaVertex (Mesh mesh, MeshTriPoint start, VertId v, MeshTriPoint end, std_vector_EdgePoint outPath, std_vector_Vector2_float tmp, std_vector_EdgePoint cachePath)

AffineXf3f	refineFeatureObject (FeatureObject featObj, Mesh mesh, RefineParameters params='MR::RefineParameters{}')

AffineXf3f	refineFeatureObject (FeatureObject featObj, PointCloud pointCloud, RefineParameters params='MR::RefineParameters{}')

bool	relax (PointCloud pointCloud, PointCloudRelaxParams params='MR::PointCloudRelaxParams{}', func_bool_from_float cb='MR::ProgressCallback{}')

bool	relax (Mesh mesh, MeshRelaxParams params='MR::MeshRelaxParams{}', func_bool_from_float cb='MR::ProgressCallback{}')

bool	relaxApprox (PointCloud pointCloud, PointCloudApproxRelaxParams params='MR::PointCloudApproxRelaxParams{}', func_bool_from_float cb='MR::ProgressCallback{}')

bool	relaxApprox (Mesh mesh, MeshApproxRelaxParams params='MR::MeshApproxRelaxParams{}', func_bool_from_float cb='MR::ProgressCallback{}')

bool	relaxKeepVolume (PointCloud pointCloud, PointCloudRelaxParams params='MR::PointCloudRelaxParams{}', func_bool_from_float cb='MR::ProgressCallback{}')

bool	relaxKeepVolume (Mesh mesh, MeshRelaxParams params='MR::MeshRelaxParams{}', func_bool_from_float cb='MR::ProgressCallback{}')

bool	remesh (Mesh mesh, RemeshSettings settings)

None	removeLoneContours (std_vector_std_vector_VariableEdgeTri contours)

None	removeLoneDegeneratedContours (MeshTopology edgesTopology, std_vector_OneMeshContour faceContours, std_vector_OneMeshContour edgeContours)

None	removeSpikes (Mesh mesh, int maxIterations, float minSumAngle, VertBitSet region=None)

str	replace (str target, str from_, str to)

None	replaceInplace (std_string_output target, str from_, str to)

str	replaceProhibitedChars (str line, str replacement='_')

None	replicateZ (Mesh m, Mesh target)

bool	reportProgress (func_bool_from_float cb, float v)

bool	reportProgress (func_bool_from_float cb, float v, int counter, int divider)

MarkedContour3f	resample (MarkedContour3f in_, float minStep, std_vector_Vector3_float normals=None)

OpenVdbFloatGrid	resampled (OpenVdbFloatGrid grid, float voxelScale, func_bool_from_float cb='MR::ProgressCallback{}')

OpenVdbFloatGrid	resampled (OpenVdbFloatGrid grid, Vector3f voxelScale, func_bool_from_float cb='MR::ProgressCallback{}')

bool	resolveMeshDegenerations (Mesh mesh, ResolveMeshDegenSettings settings='MR::ResolveMeshDegenSettings{}')

bool	resolveMeshDegenerations (Mesh mesh, int maxIters, float maxDeviation=0, float maxAngleChange=1.0471975803375244, float criticalAspectRatio=10000)

None	reverse (std_vector_Id_EdgeTag path)

None	reverse (std_vector_std_vector_Id_EdgeTag paths)

float	roundToPrecision (float v, int precision)

bool	same (MeshTopology topology, EdgePoint lhs, EdgePoint rhs)

bool	same (MeshTopology topology, MeshTriPoint lhs, MeshTriPoint rhs)

std_vector_Vector3_float	sampleHalfSphere ()

None	saveAllSlicesToImage (VdbVolume vdbVolume, VoxelsSave.SavingSettings settings)

None	saveDistanceMapToImage (DistanceMap distMap, os.PathLike filename, float threshold=0.003921568859368563)

None	saveLines (Polyline3 polyline, os.PathLike file, SaveSettings settings='MR::SaveSettings{}')

None	saveLines (Polyline3 polyline, str extension, typing.Any out, SaveSettings settings='MR::SaveSettings{}')

None	saveMesh (Mesh mesh, os.PathLike file, SaveSettings settings='MR::SaveSettings{}')

None	saveMesh (Mesh mesh, str extension, typing.Any out, SaveSettings settings='MR::SaveSettings{}')

None	saveObjectVoxelsToFile (Object object, os.PathLike path, func_bool_from_float callback='MR::ProgressCallback{}')

None	savePoints (PointCloud points, os.PathLike file, SaveSettings settings='MR::SaveSettings{}')

None	savePoints (PointCloud points, str extension, typing.Any out, SaveSettings settings='MR::SaveSettings{}')

None	saveSliceToImage (os.PathLike path, VdbVolume vdbVolume, SlicePlane slicePlain, int sliceNumber, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxels (VdbVolume vdbVolume, os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxelsGav (SimpleVolumeMinMax simpleVolumeMinMax, os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxelsGav (SimpleVolume simpleVolume, os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxelsGav (VdbVolume vdbVolume, os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxelsGav (SimpleVolumeMinMax simpleVolumeMinMax, typing.Any out, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxelsGav (SimpleVolume simpleVolume, typing.Any out, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxelsGav (VdbVolume vdbVolume, typing.Any out, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxelsRaw (VdbVolume vdbVolume, os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

None	saveVoxelsRaw (SimpleVolume simpleVolume, os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

FaceBitSet	segmentByGraphCut (MeshTopology topology, FaceBitSet source, FaceBitSet sink, func_float_from_Id_EdgeTag metric)

Mesh	segmentVolume (VdbVolume volume, std_vector_std_pair_Vector3_float_Vector3_float pairs, VolumeSegmentationParameters params='MR::VolumeSegmentationParameters()')

VoxelBitSet	segmentVolumeByGraphCut (SimpleVolume densityVolume, float k, VoxelBitSet sourceSeeds, VoxelBitSet sinkSeeds, func_bool_from_float cb='MR::ProgressCallback{}')

std_vector_TaggedBitSet_FaceTag	separateClosedContour (Mesh mesh, std_vector_Vector3_float contour, func_void_from_EdgePoint cb='MR::PathMeshEdgePointCallback{}')

None	serializeMesh (Mesh mesh, os.PathLike path, FaceBitSet selection=None, str saveMeshFormat='".mrmesh"')

None	serializeObjectTree (Object object, os.PathLike path, func_bool_from_float progress, func_void_from_std_filesystem_path preCompress)

None	serializeObjectTree (Object object, os.PathLike path, func_bool_from_float progress='MR::ProgressCallback{}')

None	serializeObjectTreeToGltf (Object root, os.PathLike file, func_bool_from_float callback='MR::ProgressCallback{}')

None	setLevelSetType (OpenVdbFloatGrid grid)

None	setNewHandlerIfNeeded ()

None	setValue (OpenVdbFloatGrid grid, Vector3i p, float value)

None	setValue (OpenVdbFloatGrid grid, VoxelBitSet region, float value)

None	setupLoggerByDefault ()

Mesh	sharpOffsetMesh (MeshPart mp, float offset, SharpOffsetParameters params='MR::SharpOffsetParameters{}')

None	sharpenMarchingCubesMesh (MeshPart ref, Mesh vox, Vector_Id_VoxelTag_FaceId face2voxel, SharpenMarchingCubesMeshSettings settings)

None	shrink (MeshTopology topology, FaceBitSet region, int hops=1)

None	shrink (MeshTopology topology, VertBitSet region, int hops=1)

FaceBitSet	shrinkFaces (MeshTopology topology, FaceBitSet region, UndirectedEdgeBitSet stopEdges=None)

None	shrinkPixelMask (PixelBitSet mask, RectIndexer indexer, int shrinkage=1)

None	shrinkVoxelsMask (VoxelBitSet mask, VolumeIndexer indexer, int shrinkage=1)

float	signedDistanceToMesh (MeshPart mp, Vector3f p, DistanceToMeshOptions op)

OpenVdbFloatGrid	simpleVolumeToDenseGrid (SimpleVolume simpleVolume, float background=0.0, func_bool_from_float cb='MR::ProgressCallback{}')

VdbVolume	simpleVolumeToVdbVolume (SimpleVolumeMinMax simpleVolume, func_bool_from_float cb='MR::ProgressCallback{}')

None	smoothRegionBoundary (Mesh mesh, FaceBitSet regionFaces, int numIters=4)

FaceBitSet	smoothSelection (Mesh mesh, FaceBitSet region, float expandOffset, float shrinkOffset)

None	sortPathsByLength (std_vector_std_vector_Id_EdgeTag paths, Mesh mesh)

None	sortPathsByMetric (std_vector_std_vector_Id_EdgeTag paths, func_float_from_Id_EdgeTag metric)

None	sortScanFilesByName (std_vector_std_filesystem_path scans)

None	sortScansByOrder (std_vector_std_filesystem_path scans, std_vector_SliceInfo zOrder)

std_vector_std_string	split (str string, str delimiter)

std_vector_unsigned_long	splitByLines (str data, int size)

std_vector_std_vector_Id_EdgeTag	splitOnSimpleLoops (MeshTopology topology, std_vector_std_vector_Id_EdgeTag loops)

float	sqr (Vector3f a)

float	sqr (Vector3d a)

int	sqr (Vector3i a)

float	sqr (Vector2f a)

float	sqr (Vector2d a)

int	sqr (Vector2i a)

None	stitchContours (MeshTopology topology, std_vector_Id_EdgeTag c0, std_vector_Id_EdgeTag c1)

None	straightenBoundary (Mesh mesh, Id_EdgeTag bd, float minNeiNormalsDot, float maxTriAspectRatio, FaceBitSet newFaces=None)

None	subdivideLoneContours (Mesh mesh, std_vector_OneMeshContour contours, phmap_flat_hash_map_Id_FaceTag_Id_FaceTag new2oldMap=None)

int	subdivideMesh (Mesh mesh, SubdivideSettings settings='MR::SubdivideSettings{}')

int	subdividePolyline (Polyline2 polyline, PolylineSubdivideSettings settings='MR::PolylineSubdivideSettings{}')

int	subdividePolyline (Polyline3 polyline, PolylineSubdivideSettings settings='MR::PolylineSubdivideSettings{}')

EdgeBitSet	subdividePolylineWithPlane (Polyline3 polyline, Plane3f plane, func_void_from_Id_EdgeTag_Id_EdgeTag_float onEdgeSplitCallback=None)

FaceBitSet	subdivideWithPlane (Mesh mesh, Plane3f plane, phmap_flat_hash_map_Id_FaceTag_Id_FaceTag new2Old=None, float eps=0, func_void_from_Id_EdgeTag_Id_EdgeTag_float onEdgeSplitCallback=None)

func_bool_from_float	subprogress (func_bool_from_float cb, float from_, float to)

func_bool_from_float	subprogress (func_bool_from_float cb, int index, int count)

float	suggestVoxelSize (MeshPart mp, float approxNumVoxels)

float	surfacePathLength (Mesh mesh, std_vector_EdgePoint surfacePath)

std_vector_Vector3_float	surfacePathToContour3f (Mesh mesh, std_vector_EdgePoint line)

std_vector_std_vector_Vector3_float	surfacePathsToContours3f (Mesh mesh, std_vector_std_vector_EdgePoint lines)

std_vector_Id_EdgeTag	surroundingContour (Mesh mesh, std_vector_Id_EdgeTag includeEdges, func_float_from_Id_EdgeTag edgeMetric, Vector3f dir)

std_vector_Id_EdgeTag	surroundingContour (Mesh mesh, std_vector_Id_VertTag keyVertices, func_float_from_Id_EdgeTag edgeMetric, Vector3f dir)

str	systemToUtf8 (str system)

std_array_VoxelsVolumeMinMax_std_vector_float_3	teethMaskToDirectionVolume (VdbVolume volume, std_vector_int additionalIds='std::vector< int >{}')

Mesh	terrainTriangulation (std_vector_Vector3_float points, func_bool_from_float cb='MR::ProgressCallback{}')

Mesh	thickenMesh (Mesh mesh, float offset, GeneralOffsetParameters params='MR::GeneralOffsetParameters{}')

str	toLower (str str)

str	toString (DimensionsVisualizePropertyType value)

str	toString (PathError error)

MeshTopology	topologyFromTriangles (Triangulation t, MeshBuilder.BuildSettings settings='MR::MeshBuilder::BuildSettings{}', func_bool_from_float progressCb='MR::ProgressCallback{}')

std_vector_Id_EdgeTag	trackLeftBoundaryLoop (MeshTopology topology, Id_EdgeTag e0, FaceBitSet region=None)

std_vector_Id_EdgeTag	trackLeftBoundaryLoop (MeshTopology topology, FaceBitSet region, Id_EdgeTag e0)

std_vector_Id_EdgeTag	trackRightBoundaryLoop (MeshTopology topology, Id_EdgeTag e0, FaceBitSet region=None)

std_vector_Id_EdgeTag	trackRightBoundaryLoop (MeshTopology topology, FaceBitSet region, Id_EdgeTag e0)

std_vector_EdgePoint	trackSection (MeshPart mp, MeshTriPoint start, MeshTriPoint end, Vector3f direction, float distance)

VertCoords	transformNormals (VertCoords normals, VertBitSet validVerts, Matrix3d m, VertCoords buf)

VertCoords	transformPoints (VertCoords verts, VertBitSet validVerts, AffineXf3d xf, VertCoords buf, VertRenumber vertRenumber=None)

VdbVolume	transformVdbVolume (VdbVolume volume, AffineXf3f xf, bool fixBox=False, Box3f box='MR::Box3f{}')

Mesh	triangulateContours (std_vector_std_vector_Vector2_double contours, std_vector_std_vector_Id_VertTag holeVertsIds=None)

Mesh	triangulateContours (std_vector_std_vector_Vector2_float contours, std_vector_std_vector_Id_VertTag holeVertsIds=None)

Mesh	triangulatePointCloud (PointCloud pointCloud, TriangulationParameters params='MR::TriangulationParameters{}', func_bool_from_float progressCb='MR::ProgressCallback{}')

str	trimRight (str str)

None	trimWithPlane (Mesh mesh, Plane3f plane, UndirectedEdgeBitSet outCutEdges=None, phmap_flat_hash_map_Id_FaceTag_Id_FaceTag new2Old=None, float eps=0, func_void_from_Id_EdgeTag_Id_EdgeTag_float onEdgeSplitCallback=None)

None	trimWithPlane (Mesh mesh, Plane3f plane, std_vector_std_vector_Id_EdgeTag outCutContours, phmap_flat_hash_map_Id_FaceTag_Id_FaceTag new2Old=None, float eps=0, func_void_from_Id_EdgeTag_Id_EdgeTag_float onEdgeSplitCallback=None)

None	trimWithPlane (Mesh mesh, TrimWithPlaneParams params, TrimOptionalOutput optOut='MR::TrimOptionalOutput{}')

IteratorRange_UndirectedEdgeIterator	undirectedEdges (MeshTopology topology)

IteratorRange_PolylineUndirectedEdgeIterator	undirectedEdges (PolylineTopology topology)

Vector3d	unitVector3_double (float azimuth, float altitude)

Vector3f	unitVector3_float (float azimuth, float altitude)

int	uniteCloseVertices (Mesh mesh, float closeDist, bool uniteOnlyBd=True, VertMap optionalVertOldToNew=None)

AllLocalTriangulations	uniteLocalTriangulations (std_vector_SomeLocalTriangulations in_, func_bool_from_float progress='MR::ProgressCallback{}')

Mesh	uniteManyMeshes (std_vector_Mesh_const meshes, UniteManyMeshesParams params='MR::UniteManyMeshesParams{}')

None	updateGroupPairs (ICPGroupPairs pairs, Vector_MeshOrPointsXf_ObjId objs, func_void_from_Vector3_float_MeshOrPoints_ProjectionResult_Id_ObjTag srcProjector, func_void_from_Vector3_float_MeshOrPoints_ProjectionResult_Id_ObjTag tgtProjector, float cosThreshold, float distThresholdSq, bool mutualClosest)

None	updateIndicator (Mesh mesh, UndirectedEdgeScalars v, FaceNormals normals, float beta, float gamma)

None	updateIndicatorFast (MeshTopology topology, UndirectedEdgeScalars v, FaceNormals normals, float beta, float gamma)

None	updatePointPairs (PointPairs pairs, MeshOrPointsXf src, MeshOrPointsXf tgt, float cosThreshold, float distThresholdSq, bool mutualClosest)

str	utf8ToSystem (str utf8)

str	utf8ToWide (str utf8)

str	utf8string (os.PathLike path)

SimpleVolumeMinMax	vdbVolumeToSimpleVolume (VdbVolume vdbVolume, Box3i activeBox='MR::Box3i()', func_bool_from_float cb='MR::ProgressCallback{}')

SimpleVolumeMinMax	vdbVolumeToSimpleVolumeNorm (VdbVolume vdbVolume, Box3i activeBox='MR::Box3i()', std_optional_Box_float sourceScale='std::optional< MR::MinMaxf >{}', func_bool_from_float cb='MR::ProgressCallback{}')

SimpleVolumeMinMaxU16	vdbVolumeToSimpleVolumeU16 (VdbVolume vdbVolume, Box3i activeBox='MR::Box3i()', std_optional_Box_float sourceScale='std::optional< MR::MinMaxf >{}', func_bool_from_float cb='MR::ProgressCallback{}')

None	vertMapsComposition (VertMap a2b, VertMap b2c)

VertCoords	vertexAttributeGradient (Mesh mesh, VertScalars vertexAttribute)

Vector3f	vertexPosEqualNeiAreas (Mesh mesh, VertId v, bool noShrinkage)

VertBitSet	verticesGridSampling (MeshPart mp, float voxelSize, func_bool_from_float cb='MR::ProgressCallback{}')

Mesh	voxelBooleanIntersect (Mesh mesh1, Mesh mesh2, float voxelSize)

Mesh	voxelBooleanSubtract (Mesh mesh1, Mesh mesh2, float voxelSize)

Mesh	voxelBooleanUnite (Mesh mesh1, Mesh mesh2, float voxelSize)

VdbVolume	voxelFilter (VdbVolume volume, VoxelFilterType type, int width)

float	voxelizeAndComputeVolume (std_vector_std_shared_ptr_Mesh meshes, AffineXf3f xf, Vector3f voxelSize)

None	voxelsApplyTransform (ObjectVoxels obj, AffineXf3f xf, bool fixBox)

func_float_from_unsigned_long_unsigned_long	voxelsExponentMetric (VdbVolume voxels, VoxelMetricParameters parameters, float modifier=-1.0)

func_float_from_unsigned_long_unsigned_long	voxelsSumDiffsMetric (VdbVolume voxels, VoxelMetricParameters parameters)

str	wideToUtf8 (str wide)

bool	writeByBlocks (typing.Any out, str data, int dataSize, func_bool_from_float callback='MR::ProgressCallback{}', int blockSize=65536)

None	writeRawTiff (int bytes, os.PathLike path, BaseTiffParameters params)

None	xyPlaneMeshIntersect (MeshPart meshPart, float zLevel, FaceBitSet fs, UndirectedEdgeBitSet ues, VertBitSet vs)

None	zlibCompressStream (typing.Any in_, typing.Any out, int level=-1)

None	zlibDecompressStream (typing.Any in_, typing.Any out)

Variables
	AABBTreeBase_FaceTreeTraits3 = AABBTreeBase_AABBTreeTraits_FaceTag_Box3f

	AABBTreeBase_LineTreeTraits_Vector2f = AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f

	AABBTreeBase_LineTreeTraits_Vector3f = AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f

	AABBTreeNode_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_Traits = AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

	AABBTreeNode_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_Traits = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

	AABBTreeNode_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_Traits = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

	AABBTreeNode_AABBTreeBase_ObjTreeTraits_Traits = AABBTreeNode_ObjTreeTraits

	AABBTreePolyline_Vector2f = AABBTreePolyline2

	AABBTreePolyline_Vector3f = AABBTreePolyline3

	AffineXf3_double = AffineXf3d

	AffineXf3_float = AffineXf3f

	AffineXf_Vector2_double = AffineXf2d

	AffineXf_Vector2_float = AffineXf2f

	AffineXf_Vector2d = AffineXf2d

	AffineXf_Vector2d_M = Matrix2d

	AffineXf_Vector2f = AffineXf2f

	AffineXf_Vector2f_M = Matrix2f

	AffineXf_Vector3_double = AffineXf3d

	AffineXf_Vector3_float = AffineXf3f

	AffineXf_Vector3d = AffineXf3d

	AffineXf_Vector3d_M = Matrix3d

	AffineXf_Vector3f = AffineXf3f

	AffineXf_Vector3f_M = Matrix3f

	AllVisualizeProperties = std_vector_ViewportMask

	BMap_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafId_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafId = FaceBMap

	BMap_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafId_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafId = UndirectedEdgeBMap

	BMap_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafId_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafId = UndirectedEdgeBMap

	BMap_AABBTreeBase_ObjTreeTraits_LeafId_AABBTreeBase_ObjTreeTraits_LeafId = BMap_ObjId_ObjId

	BMap_EdgeId_EdgeId = EdgeBMap

	BMap_EdgeId_UndirectedEdgeId = WholeEdgeBMap

	BMap_FaceId_FaceId = FaceBMap

	BMap_FaceId_size_t = BMap_FaceId_unsigned_long

	BMap_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType = EdgeBMap

	BMap_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType = FaceBMap

	BMap_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType = BMap_GraphEdgeId_GraphEdgeId

	BMap_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType = BMap_GraphVertId_GraphVertId

	BMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = BMap_Id_ICPElemtTag_Id_ICPElemtTag

	BMap_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType = BMap_NodeId_NodeId

	BMap_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType = BMap_ObjId_ObjId

	BMap_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType = BMap_PixelId_PixelId

	BMap_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType = BMap_RegionId_RegionId

	BMap_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType = BMap_TextureId_TextureId

	BMap_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType = UndirectedEdgeBMap

	BMap_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType = VertBMap

	BMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = BMap_Id_VoxelTag_Id_VoxelTag

	BMap_UndirectedEdgeId_UndirectedEdgeId = UndirectedEdgeBMap

	BMap_UndirectedEdgeId_size_t = BMap_UndirectedEdgeId_unsigned_long

	BMap_VertId_VertId = VertBMap

	BMap_VertId_size_t = BMap_VertId_unsigned_long

	BestFitParabola_double = BestFitParabolad

	BestFitParabola_float = BestFitParabolaf

	BooleanResMapObj = BooleanResultMapper.MapObject

	Box_Vector2_double = Box2d

	Box_Vector2_float = Box2f

	Box_Vector2_int = Box2i

	Box_Vector2_long_long = Box2ll

	Box_Vector2d_VTraits = VectorTraits_Vector2d

	Box_Vector2f = Box2f

	Box_Vector2f_VTraits = VectorTraits_Vector2f

	Box_Vector2i_VTraits = VectorTraits_Vector2i

	Box_Vector2ll_VTraits = VectorTraits_Vector2ll

	Box_Vector3_double = Box3d

	Box_Vector3_float = Box3f

	Box_Vector3_int = Box3i

	Box_Vector3_long_long = Box3ll

	Box_Vector3d = Box3d

	Box_Vector3d_VTraits = VectorTraits_Vector3d

	Box_Vector3f = Box3f

	Box_Vector3f_VTraits = VectorTraits_Vector3f

	Box_Vector3i = Box3i

	Box_Vector3i_VTraits = VectorTraits_Vector3i

	Box_Vector3ll_VTraits = VectorTraits_Vector3ll

	Box_double = Box1d

	Box_double_VTraits = VectorTraits_double

	Box_float = Box1f

	Box_float_VTraits = VectorTraits_float

	Box_int = Box1i

	Box_int_VTraits = VectorTraits_int

	Box_long_long = Box1ll

	Box_long_long_VTraits = VectorTraits_long_long

	Buffer_FaceId_unsigned_long = Buffer_FaceId

	Buffer_UndirectedEdgeId_unsigned_long = Buffer_UndirectedEdgeId

	Buffer_VertId_unsigned_long = Buffer_VertId

	ColorMapAggregator_FaceTag = FaceColorMapAggregator

	ColorMapAggregator_FaceTag_ColorMap = FaceColors

	ColorMapAggregator_FaceTag_ElementBitSet = FaceBitSet

	ColorMapAggregator_UndirectedEdgeTag = UndirEdgeColorMapAggregator

	ColorMapAggregator_UndirectedEdgeTag_ColorMap = UndirectedEdgeColors

	ColorMapAggregator_UndirectedEdgeTag_ElementBitSet = UndirectedEdgeBitSet

	ColorMapAggregator_VertTag = VertColorMapAggregator

	ColorMapAggregator_VertTag_ColorMap = VertColors

	ColorMapAggregator_VertTag_ElementBitSet = VertBitSet

	Cone3_double = Cone3d

	Cone3_float = Cone3f

	ContinuousContour = std_vector_VariableEdgeTri

	ContinuousContours = std_vector_std_vector_VariableEdgeTri

	Contour2_double = std_vector_Vector2_double

	Contour2_float = std_vector_Vector2_float

	Contour2d = std_vector_Vector2_double

	Contour2f = std_vector_Vector2_float

	Contour3_double = std_vector_Vector3_double

	Contour3_float = std_vector_Vector3_float

	Contour3d = std_vector_Vector3_double

	Contour3f = std_vector_Vector3_float

	Contour_Vector2d = std_vector_Vector2_double

	Contour_Vector2f = std_vector_Vector2_float

	Contour_Vector3d = std_vector_Vector3_double

	Contour_Vector3f = std_vector_Vector3_float

	Contours2_double = std_vector_std_vector_Vector2_double

	Contours2_float = std_vector_std_vector_Vector2_float

	Contours2d = std_vector_std_vector_Vector2_double

	Contours2f = std_vector_std_vector_Vector2_float

	Contours3_double = std_vector_std_vector_Vector3_double

	Contours3_float = std_vector_std_vector_Vector3_float

	Contours3d = std_vector_std_vector_Vector3_double

	Contours3f = std_vector_std_vector_Vector3_float

	Contours_Vector2f = std_vector_std_vector_Vector2_float

	Contours_Vector3f = std_vector_std_vector_Vector3_float

	Cylinder3_double = Cylinder3d

	Cylinder3_float = Cylinder3f

	DecimatePolylineSettings2 = DecimatePolylineSettings_Vector2f

	DecimatePolylineSettings3 = DecimatePolylineSettings_Vector3f

	EdgeHashMap = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

	EdgeId = Id_EdgeTag

	EdgeLoop = std_vector_Id_EdgeTag

	EdgeLoops = std_vector_std_vector_Id_EdgeTag

	EdgePath = std_vector_Id_EdgeTag

	EdgePathsBuilder = EdgePathsBuilderT_TrivialMetricToPenalty

	FaceHashMap = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

	FaceTreeTraits3 = AABBTreeTraits_FaceTag_Box3f

	FeaturesPropertyTypesVariant = std_variant_float_Vector3_float

	FileNamesStack = std_vector_std_filesystem_path

	FixSelfIntersectionMethod = SelfIntersections.Settings.Method

	FixSelfIntersectionSettings = SelfIntersections.Settings

	FloatGrid = OpenVdbFloatGrid

	GcodeSource = std_vector_std_string

	GeneralOffsetParametersMode = OffsetMode

	HashMap_EdgeId_EdgeId = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

	HashMap_FaceId_FaceId = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

	HashMap_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

	HashMap_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

	HashMap_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType = phmap_flat_hash_map_Id_GraphEdgeTag_Id_GraphEdgeTag

	HashMap_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType = phmap_flat_hash_map_Id_GraphVertTag_Id_GraphVertTag

	HashMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = phmap_flat_hash_map_Id_ICPElemtTag_Id_ICPElemtTag

	HashMap_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType = phmap_flat_hash_map_Id_NodeTag_Id_NodeTag

	HashMap_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType = phmap_flat_hash_map_Id_ObjTag_Id_ObjTag

	HashMap_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType = phmap_flat_hash_map_Id_PixelTag_Id_PixelTag

	HashMap_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType = phmap_flat_hash_map_Id_RegionTag_Id_RegionTag

	HashMap_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType = phmap_flat_hash_map_Id_TextureTag_Id_TextureTag

	HashMap_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

	HashMap_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType = phmap_flat_hash_map_Id_VertTag_Id_VertTag

	HashMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag

	HashMap_UndirectedEdgeId_EdgeId = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

	HashMap_UndirectedEdgeId_UndirectedEdgeId = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

	HashMap_UndirectedEdgeId_int = phmap_flat_hash_map_Id_UndirectedEdgeTag_int

	HashMap_VertId_FlowAggregator_Flows = phmap_flat_hash_map_Id_VertTag_FlowAggregator_Flows

	HashMap_VertId_VertId = phmap_flat_hash_map_Id_VertTag_Id_VertTag

	HashMap_VertId_VertPathInfo = phmap_flat_hash_map_Id_VertTag_VertPathInfo

	HashMap_VertId_float = phmap_flat_hash_map_Id_VertTag_float

	HashMap_int_Box3i = phmap_flat_hash_map_int_Box_Vector3_int

	HashMap_size_t_SeparationPointSet = phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul

	HistoryActionsVector = std_vector_std_shared_ptr_HistoryAction

	ICPElementBitSet = TaggedBitSet_ICPElemtTag

	ICPElementId = Id_ICPElemtTag

	ICPObjects = Vector_MeshOrPointsXf_ObjId

	ICPPairsGrid = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

	IOFilters = std_vector_IOFilter

	Id_FaceTag = FaceId

	Id_GraphEdgeTag = GraphEdgeId

	Id_GraphVertTag = GraphVertId

	Id_NodeTag = NodeId

	Id_ObjTag = ObjId

	Id_PixelTag = PixelId

	Id_RegionTag = RegionId

	Id_TextureTag = TextureId

	Id_UndirectedEdgeTag = UndirectedEdgeId

	Id_VertTag = VertId

	IsoLine = std_vector_EdgePoint

	IsoLines = std_vector_std_vector_EdgePoint

	IteratorRange_LeftRingIterator = IteratorRange_RingIterator_NextEdgeSameLeft

	IteratorRange_OrgRingIterator = IteratorRange_RingIterator_NextEdgeSameOrigin

	LaplacianEdgeWeightsParam = EdgeWeights

	LeftRingIterator = RingIterator_NextEdgeSameLeft

	Line3_double = Line3d

	Line3_float = Line3f

	Line3dMesh = Line3Mesh_double

	Line3fMesh = Line3Mesh_float

	LineSegm_Vector2_double = LineSegm2d

	LineSegm_Vector2_float = LineSegm2f

	LineSegm_Vector2f = LineSegm2f

	LineSegm_Vector3_double = LineSegm3d

	LineSegm_Vector3_float = LineSegm3f

	LineSegm_Vector3f = LineSegm3f

	LineTreeTraits2 = AABBTreeTraits_UndirectedEdgeTag_Box2f

	LineTreeTraits3 = AABBTreeTraits_UndirectedEdgeTag_Box3f

	LineTreeTraits_Vector2f = AABBTreeTraits_UndirectedEdgeTag_Box2f

	LineTreeTraits_Vector3f = AABBTreeTraits_UndirectedEdgeTag_Box3f

	Line_Vector2_double = Line2d

	Line_Vector2_float = Line2f

	Line_Vector3_double = Line3d

	Line_Vector3_float = Line3f

	Line_Vector3d = Line3d

	LoadedObject = LoadedObjectT

	LoadedObjectLines = LoadedObjectT_ObjectLines

	LoadedObjectMesh = LoadedObjectT_ObjectMesh

	LoadedObjectPoints = LoadedObjectT_ObjectPoints

	LoadedObjectT_Object = LoadedObjectT

	LoadedObjectVoxels = LoadedObjectT_ObjectVoxels

	Matrix2_bool = Matrix2b

	Matrix2_bool_VectorType = Vector2b

	Matrix2_double = Matrix2d

	Matrix2_double_VectorType = Vector2d

	Matrix2_float = Matrix2f

	Matrix2_float_VectorType = Vector2f

	Matrix2_int = Matrix2i

	Matrix2_int_VectorType = Vector2i

	Matrix2_long_long = Matrix2ll

	Matrix2_long_long_VectorType = Vector2ll

	Matrix3_bool = Matrix3b

	Matrix3_bool_VectorType = Vector3b

	Matrix3_double = Matrix3d

	Matrix3_double_VectorType = Vector3d

	Matrix3_float = Matrix3f

	Matrix3_float_VectorType = Vector3f

	Matrix3_int = Matrix3i

	Matrix3_int_VectorType = Vector3i

	Matrix3_long_long = Matrix3ll

	Matrix3_long_long_VectorType = Vector3ll

	Matrix4_bool = Matrix4b

	Matrix4_bool_VectorType = Vector4b

	Matrix4_double = Matrix4d

	Matrix4_double_VectorType = Vector4d

	Matrix4_float = Matrix4f

	Matrix4_float_VectorType = Vector4f

	Matrix4_int = Matrix4i

	Matrix4_int_VectorType = Vector4i

	Matrix4_long_long = Matrix4ll

	Matrix4_long_long_VectorType = Vector4ll

	MeshBuilderSettings = MeshBuilder.BuildSettings

	MeshDistanceResult = MeshMeshDistanceResult

	MeshEdgePoint = EdgePoint

	MeshLabel = PositionedText

	MeshOnVoxels = MeshOnVoxelsT_Mesh

	MeshOnVoxelsC = MeshOnVoxelsT_const_Mesh

	MeshRegion_FaceTag = MeshPart

	MeshRegion_VertTag = MeshVertPart

	MeshSignedDistanceResult = MeshMeshSignedDistanceResult

	MeshToVolumeParamsType = MeshToVolumeParams.Type

	MinMax_VoxelsVolume_std_shared_ptr_OpenVdbFloatGrid_ValueType = Box1f

	MinMax_VoxelsVolume_std_vector_float_ValueType = Box1f

	MinMax_VoxelsVolume_std_vector_unsigned_short_ValueType = Box_unsigned_short

	MinMax_double = Box1d

	MinMax_float = Box1f

	MinMaxd = Box1d

	MinMaxf = Box1f

	MultiObjsSamples = std_vector_ObjVertId

	ObjectPtr = Object

	OffsetContoursVertMap = std_vector_OffsetContoursOrigins

	OffsetContoursVertMaps = std_vector_std_vector_OffsetContoursOrigins

	OneMeshContours = std_vector_OneMeshContour

	OrgRingIterator = RingIterator_NextEdgeSameOrigin

	Parabola_double = Parabolad

	Parabola_float = Parabolaf

	PickedPoint = std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int

	Plane3_double = Plane3d

	Plane3_float = Plane3f

	PlaneSection = std_vector_EdgePoint

	PlaneSections = std_vector_std_vector_EdgePoint

	PolylineProjectionResult_Vector2f = PolylineProjectionResult2

	PolylineProjectionResult_Vector3f = PolylineProjectionResult3

	PolylineProjectionWithOffsetResult_Vector2f = Polyline2ProjectionWithOffsetResult

	PolylineProjectionWithOffsetResult_Vector3f = PolylineProjectionWithOffsetResult3

	Polyline_Vector2f = Polyline2

	Polyline_Vector3f = Polyline3

	PolynomialWrapperd = PolynomialWrapper_double

	PolynomialWrapperf = PolynomialWrapper_float

	Polynomial_double_0UL_0_0_0UL_minus_1 = Polynomial_double_0

	Polynomial_double_1UL_0_0_1UL_minus_1 = Polynomial_double_0

	Polynomial_double_2UL_0_0_2UL_minus_1 = Polynomial_double_1

	Polynomial_double_3UL_0_0_3UL_minus_1 = Polynomial_double_2

	Polynomial_double_4UL_0_0_4UL_minus_1 = Polynomial_double_3

	Polynomial_double_5UL_0_0_5UL_minus_1 = Polynomial_double_4

	Polynomial_double_6UL_0_0_6UL_minus_1 = Polynomial_double_5

	Polynomial_float_0UL_0_0_0UL_minus_1 = Polynomial_float_0

	Polynomial_float_1UL_0_0_1UL_minus_1 = Polynomial_float_0

	Polynomial_float_2UL_0_0_2UL_minus_1 = Polynomial_float_1

	Polynomial_float_3UL_0_0_3UL_minus_1 = Polynomial_float_2

	Polynomial_float_4UL_0_0_4UL_minus_1 = Polynomial_float_3

	Polynomial_float_5UL_0_0_5UL_minus_1 = Polynomial_float_4

	Polynomial_float_6UL_0_0_6UL_minus_1 = Polynomial_float_5

	Polynomialx_double = std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul

	Polynomialx_float = std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul

	QuadraticForm_Vector2_double = QuadraticForm2d

	QuadraticForm_Vector2_float = QuadraticForm2f

	QuadraticForm_Vector2d_SM = SymMatrix2d

	QuadraticForm_Vector2f_SM = SymMatrix2f

	QuadraticForm_Vector3_double = QuadraticForm3d

	QuadraticForm_Vector3_float = QuadraticForm3f

	QuadraticForm_Vector3d_SM = SymMatrix3d

	QuadraticForm_Vector3f_SM = SymMatrix3f

	Quaternion_double = Quaterniond

	Quaternion_float = Quaternionf

	RigidScaleXf3_double = RigidScaleXf3d

	RigidScaleXf3_double_V = Vector3d

	RigidScaleXf3_float = RigidScaleXf3f

	RigidScaleXf3_float_V = Vector3f

	RigidXf3_double = RigidXf3d

	RigidXf3_double_V = Vector3d

	RigidXf3_float = RigidXf3f

	RigidXf3_float_V = Vector3f

	SegmPoint_double = SegmPointd

	SegmPoint_float = SegmPointf

	SeparationPointMap = phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul

	SeparationPointSet = std_array_Id_VertTag_3

	SetBitIteratorT_BitSet = SetBitIterator

	SetBitIteratorT_EdgeBitSet = EdgeSetBitIterator

	SetBitIteratorT_EdgeBitSet_IndexType = Id_EdgeTag

	SetBitIteratorT_EdgeBitSet_pointer = Id_EdgeTag

	SetBitIteratorT_EdgeBitSet_reference = Id_EdgeTag

	SetBitIteratorT_EdgeBitSet_value_type = Id_EdgeTag

	SetBitIteratorT_FaceBitSet = FaceSetBitIterator

	SetBitIteratorT_FaceBitSet_IndexType = FaceId

	SetBitIteratorT_FaceBitSet_pointer = FaceId

	SetBitIteratorT_FaceBitSet_reference = FaceId

	SetBitIteratorT_FaceBitSet_value_type = FaceId

	SetBitIteratorT_TaggedBitSet_UndirectedEdgeTag = UndirectedEdgeSetBitIterator

	SetBitIteratorT_UndirectedEdgeBitSet = UndirectedEdgeSetBitIterator

	SetBitIteratorT_UndirectedEdgeBitSet_IndexType = UndirectedEdgeId

	SetBitIteratorT_UndirectedEdgeBitSet_pointer = UndirectedEdgeId

	SetBitIteratorT_UndirectedEdgeBitSet_reference = UndirectedEdgeId

	SetBitIteratorT_UndirectedEdgeBitSet_value_type = UndirectedEdgeId

	SetBitIteratorT_VertBitSet = VertSetBitIterator

	SetBitIteratorT_VertBitSet_IndexType = VertId

	SetBitIteratorT_VertBitSet_pointer = VertId

	SetBitIteratorT_VertBitSet_reference = VertId

	SetBitIteratorT_VertBitSet_value_type = VertId

	Sphere3_float = Sphere3f

	Sphere_Vector2_double = Sphere2d

	Sphere_Vector2_float = Sphere2f

	Sphere_Vector3_double = Sphere3d

	Sphere_Vector3_float = Sphere3f

	Sphere_Vector3f = Sphere3f

	SurfacePath = std_vector_EdgePoint

	SurfacePaths = std_vector_std_vector_EdgePoint

	SymMatrix2_bool = SymMatrix2b

	SymMatrix2_double = SymMatrix2d

	SymMatrix2_float = SymMatrix2f

	SymMatrix2_int = SymMatrix2i

	SymMatrix2_long_long = SymMatrix2ll

	SymMatrix3_bool = SymMatrix3b

	SymMatrix3_double = SymMatrix3d

	SymMatrix3_float = SymMatrix3f

	SymMatrix3_int = SymMatrix3i

	SymMatrix3_long_long = SymMatrix3ll

	SymMatrix4_bool = SymMatrix4b

	SymMatrix4_double = SymMatrix4d

	SymMatrix4_float = SymMatrix4f

	SymMatrix4_int = SymMatrix4i

	SymMatrix4_long_long = SymMatrix4ll

	TaggedBitSet_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafTag = FaceBitSet

	TaggedBitSet_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafTag = UndirectedEdgeBitSet

	TaggedBitSet_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafTag = UndirectedEdgeBitSet

	TaggedBitSet_AABBTreeBase_ObjTreeTraits_LeafTag = ObjBitSet

	TaggedBitSet_EdgeTag = EdgeBitSet

	TaggedBitSet_EdgeTag_IndexType = Id_EdgeTag

	TaggedBitSet_FaceTag = FaceBitSet

	TaggedBitSet_FaceTag_IndexType = FaceId

	TaggedBitSet_GraphEdgeTag = GraphEdgeBitSet

	TaggedBitSet_GraphEdgeTag_IndexType = GraphEdgeId

	TaggedBitSet_GraphVertTag = GraphVertBitSet

	TaggedBitSet_GraphVertTag_IndexType = GraphVertId

	TaggedBitSet_NodeTag = NodeBitSet

	TaggedBitSet_NodeTag_IndexType = NodeId

	TaggedBitSet_ObjTag = ObjBitSet

	TaggedBitSet_ObjTag_IndexType = ObjId

	TaggedBitSet_PixelTag = PixelBitSet

	TaggedBitSet_PixelTag_IndexType = PixelId

	TaggedBitSet_RegionTag = RegionBitSet

	TaggedBitSet_RegionTag_IndexType = RegionId

	TaggedBitSet_TextureTag = TextureBitSet

	TaggedBitSet_TextureTag_IndexType = TextureId

	TaggedBitSet_UndirectedEdgeTag = UndirectedEdgeBitSet

	TaggedBitSet_UndirectedEdgeTag_IndexType = UndirectedEdgeId

	TaggedBitSet_VertTag = VertBitSet

	TaggedBitSet_VertTag_IndexType = VertId

	TaggedBitSet_VoxelTag = VoxelBitSet

	TaggedBitSet_VoxelTag_IndexType = Id_VoxelTag

	TextAlignParams = TextMeshAlignParams

	ThreePoints = std_array_Vector3_float_3

	ThreeVertIds = std_array_Id_VertTag_3

	TriPoint_double = TriPointd

	TriPoint_float = TriPointf

	Triangle3_double = std_array_Vector3_double_3

	Triangle3_float = std_array_Vector3_float_3

	Triangle3_int = std_array_Vector3_int_3

	Triangle3d = std_array_Vector3_double_3

	Triangle3f = std_array_Vector3_float_3

	Triangle3i = std_array_Vector3_int_3

	TriangleCornerNormals = std_array_Vector3_float_3

	TrianglesRepetitions = std_array_int_4

	TriangulationHelpersSettings = TriangulationHelpers.Settings

	UVCoord = Vector2f

	UndirectedEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

	VdbVolumes = std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid

	Vector2_bool = Vector2b

	Vector2_bool_MatrixType = Matrix2b

	Vector2_bool_SymMatrixType = SymMatrix2b

	Vector2_double = Vector2d

	Vector2_double_MatrixType = Matrix2d

	Vector2_double_SymMatrixType = SymMatrix2d

	Vector2_float = Vector2f

	Vector2_float_MatrixType = Matrix2f

	Vector2_float_SymMatrixType = SymMatrix2f

	Vector2_int = Vector2i

	Vector2_int_MatrixType = Matrix2i

	Vector2_int_SymMatrixType = SymMatrix2i

	Vector2_long_long = Vector2ll

	Vector2_long_long_MatrixType = Matrix2ll

	Vector2_long_long_SymMatrixType = SymMatrix2ll

	Vector3_bool = Vector3b

	Vector3_bool_MatrixType = Matrix3b

	Vector3_bool_SymMatrixType = SymMatrix3b

	Vector3_double = Vector3d

	Vector3_double_MatrixType = Matrix3d

	Vector3_double_SymMatrixType = SymMatrix3d

	Vector3_float = Vector3f

	Vector3_float_MatrixType = Matrix3f

	Vector3_float_SymMatrixType = SymMatrix3f

	Vector3_int = Vector3i

	Vector3_int_MatrixType = Matrix3i

	Vector3_int_SymMatrixType = SymMatrix3i

	Vector3_long_long = Vector3ll

	Vector3_long_long_MatrixType = Matrix3ll

	Vector3_long_long_SymMatrixType = SymMatrix3ll

	Vector4_bool = Vector4b

	Vector4_bool_MatrixType = Matrix4b

	Vector4_bool_SymMatrixType = SymMatrix4b

	Vector4_double = Vector4d

	Vector4_double_MatrixType = Matrix4d

	Vector4_double_SymMatrixType = SymMatrix4d

	Vector4_float = Vector4f

	Vector4_float_MatrixType = Matrix4f

	Vector4_float_SymMatrixType = SymMatrix4f

	Vector4_int = Vector4i

	Vector4_int_MatrixType = Matrix4i

	Vector4_int_SymMatrixType = SymMatrix4i

	Vector4_long_long = Vector4ll

	Vector4_long_long_MatrixType = Matrix4ll

	Vector4_long_long_SymMatrixType = SymMatrix4ll

	Vector_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_Node_NodeId = Vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_NodeId

	Vector_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_Node_NodeId = Vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_NodeId

	Vector_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_Node_NodeId = Vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_NodeId

	Vector_AABBTreeBase_ObjTreeTraits_Node_NodeId = Vector_AABBTreeNode_ObjTreeTraits_NodeId

	Vector_Color_EdgeId = EdgeColors

	Vector_Color_FaceId = FaceColors

	Vector_Color_FaceId_const_reference = Color

	Vector_Color_FaceId_reference = Color

	Vector_Color_FaceId_value_type = Color

	Vector_Color_Id_EdgeTag_const_reference = Color

	Vector_Color_Id_EdgeTag_reference = Color

	Vector_Color_Id_EdgeTag_value_type = Color

	Vector_Color_Id_FaceTag = FaceColors

	Vector_Color_Id_UndirectedEdgeTag = UndirectedEdgeColors

	Vector_Color_Id_VertTag = VertColors

	Vector_Color_UndirectedEdgeId = UndirectedEdgeColors

	Vector_Color_UndirectedEdgeId_const_reference = Color

	Vector_Color_UndirectedEdgeId_reference = Color

	Vector_Color_UndirectedEdgeId_value_type = Color

	Vector_Color_VertId = VertColors

	Vector_Color_VertId_const_reference = Color

	Vector_Color_VertId_reference = Color

	Vector_Color_VertId_value_type = Color

	Vector_Dipole_NodeId = Dipoles

	Vector_Dipole_NodeId_const_reference = Dipole

	Vector_Dipole_NodeId_reference = Dipole

	Vector_Dipole_NodeId_value_type = Dipole

	Vector_EdgeId_EdgeId = EdgeMap

	Vector_EdgeId_FaceId = Vector_Id_EdgeTag_FaceId

	Vector_EdgeId_UndirectedEdgeId = WholeEdgeMap

	Vector_EdgeId_VertId = Vector_Id_EdgeTag_VertId

	Vector_FaceBitSet_Graph_VertId = Vector_FaceBitSet_GraphVertId

	Vector_FaceId_FaceId = FaceMap

	Vector_FaceId_FaceId_const_reference = FaceId

	Vector_FaceId_FaceId_reference = FaceId

	Vector_FaceId_FaceId_value_type = FaceId

	Vector_Graph_EndVertices_Graph_EdgeId = Vector_Graph_EndVertices_GraphEdgeId

	Vector_Graph_Neighbours_Graph_VertId = Vector_std_vector_GraphEdgeId_GraphVertId

	Vector_Graph_VertId_Graph_VertId = Vector_GraphVertId_GraphVertId

	Vector_ICPPairsGrid_ICPLayer = Vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_int

	Vector_Id_EdgeTag_Id_EdgeTag_const_reference = Id_EdgeTag

	Vector_Id_EdgeTag_Id_EdgeTag_reference = Id_EdgeTag

	Vector_Id_EdgeTag_Id_EdgeTag_value_type = Id_EdgeTag

	Vector_Id_EdgeTag_UndirectedEdgeId_const_reference = Id_EdgeTag

	Vector_Id_EdgeTag_UndirectedEdgeId_reference = Id_EdgeTag

	Vector_Id_EdgeTag_UndirectedEdgeId_value_type = Id_EdgeTag

	Vector_ObjId_ObjId = ObjMap

	Vector_ObjId_ObjId_const_reference = ObjId

	Vector_ObjId_ObjId_reference = ObjId

	Vector_ObjId_ObjId_value_type = ObjId

	Vector_QuadraticForm_Vector2f_VertId = Vector_QuadraticForm2f_VertId

	Vector_QuadraticForm_Vector3f_VertId = Vector_QuadraticForm3f_VertId

	Vector_RegionId_FaceId = Face2RegionMap

	Vector_RegionId_FaceId_const_reference = RegionId

	Vector_RegionId_FaceId_reference = RegionId

	Vector_RegionId_FaceId_value_type = RegionId

	Vector_RegionId_UndirectedEdgeId = UndirectedEdge2RegionMap

	Vector_RegionId_UndirectedEdgeId_const_reference = RegionId

	Vector_RegionId_UndirectedEdgeId_reference = RegionId

	Vector_RegionId_UndirectedEdgeId_value_type = RegionId

	Vector_RegionId_VertId = Vert2RegionMap

	Vector_RegionId_VertId_const_reference = RegionId

	Vector_RegionId_VertId_reference = RegionId

	Vector_RegionId_VertId_value_type = RegionId

	Vector_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType = EdgeMap

	Vector_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType = FaceMap

	Vector_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType = Vector_GraphEdgeId_GraphEdgeId

	Vector_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType = Vector_GraphVertId_GraphVertId

	Vector_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = Vector_Id_ICPElemtTag_Id_ICPElemtTag

	Vector_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType = Vector_NodeId_NodeId

	Vector_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType = ObjMap

	Vector_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType = Vector_PixelId_PixelId

	Vector_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType = Vector_RegionId_RegionId

	Vector_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType = Vector_TextureId_TextureId

	Vector_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType = UndirectedEdgeMap

	Vector_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType = VertMap

	Vector_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = Vector_Id_VoxelTag_Id_VoxelTag

	Vector_TextureId_FaceId = TexturePerFace

	Vector_TextureId_FaceId_const_reference = TextureId

	Vector_TextureId_FaceId_reference = TextureId

	Vector_TextureId_FaceId_value_type = TextureId

	Vector_ThreeVertIds_FaceId = Triangulation

	Vector_TriangleCornerNormals_FaceId = Vector_std_array_Vector3f_3_FaceId

	Vector_UVCoord_VertId = VertUVCoords

	Vector_UndirectedEdgeId_UndirectedEdgeId = UndirectedEdgeMap

	Vector_UndirectedEdgeId_UndirectedEdgeId_const_reference = UndirectedEdgeId

	Vector_UndirectedEdgeId_UndirectedEdgeId_reference = UndirectedEdgeId

	Vector_UndirectedEdgeId_UndirectedEdgeId_value_type = UndirectedEdgeId

	Vector_Vector2f_VertId = VertUVCoords

	Vector_Vector2f_VertId_const_reference = Vector2f

	Vector_Vector2f_VertId_reference = Vector2f

	Vector_Vector2f_VertId_value_type = Vector2f

	Vector_Vector3f_FaceId = FaceNormals

	Vector_Vector3f_FaceId_const_reference = Vector3f

	Vector_Vector3f_FaceId_reference = Vector3f

	Vector_Vector3f_FaceId_value_type = Vector3f

	Vector_Vector3f_VertId = VertCoords

	Vector_Vector3f_VertId_const_reference = Vector3f

	Vector_Vector3f_VertId_reference = Vector3f

	Vector_Vector3f_VertId_value_type = Vector3f

	Vector_Vector_ICPGroupPairs_ICPElementId_ICPElementId = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

	Vector_VertId_VertId = VertMap

	Vector_VertId_VertId_const_reference = VertId

	Vector_VertId_VertId_reference = VertId

	Vector_VertId_VertId_value_type = VertId

	Vector_VoxelId_FaceId = Vector_Id_VoxelTag_FaceId

	Vector_float_EdgeId = EdgeScalars

	Vector_float_FaceId = FaceScalars

	Vector_float_UndirectedEdgeId = UndirectedEdgeScalars

	Vector_float_VertId = VertScalars

	Vector_std_array_VertId_3_FaceId_const_reference = std_array_Id_VertTag_3

	Vector_std_array_VertId_3_FaceId_reference = std_array_Id_VertTag_3

	Vector_std_array_VertId_3_FaceId_value_type = std_array_Id_VertTag_3

	VertHashMap = phmap_flat_hash_map_Id_VertTag_Id_VertTag

	VertNormals = VertCoords

	VertPathInfoMap = phmap_flat_hash_map_Id_VertTag_VertPathInfo

	ViewportProperty_uint8_t = ViewportProperty_unsigned_char

	VoxelId = Id_VoxelTag

	VoxelsSaveSavingSettings = VoxelsSave.SavingSettings

	VoxelsVolumeMinMax_FloatGrid = VdbVolume

	VoxelsVolumeMinMax_std_vector_float = SimpleVolumeMinMax

	VoxelsVolumeMinMax_std_vector_uint16_t = SimpleVolumeMinMaxU16

	VoxelsVolume_VoxelValueGetter_float = FunctionVolume

	VoxelsVolume_VoxelValueGetter_uint8_t = FunctionVolumeU8

	VoxelsVolume_std_vector_float = SimpleVolume

	VoxelsVolume_std_vector_uint16_t = SimpleVolumeU16

	VoxelsVolume_std_vector_unsigned_short = SimpleVolumeU16

	WholeEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

	copyMesh = Mesh

	phmap_flat_hash_map_FaceId_FaceId = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

	phmap_flat_hash_map_GraphEdgeId_GraphEdgeId = phmap_flat_hash_map_Id_GraphEdgeTag_Id_GraphEdgeTag

	phmap_flat_hash_map_GraphVertId_GraphVertId = phmap_flat_hash_map_Id_GraphVertTag_Id_GraphVertTag

	phmap_flat_hash_map_NodeId_NodeId = phmap_flat_hash_map_Id_NodeTag_Id_NodeTag

	phmap_flat_hash_map_ObjId_ObjId = phmap_flat_hash_map_Id_ObjTag_Id_ObjTag

	phmap_flat_hash_map_PixelId_PixelId = phmap_flat_hash_map_Id_PixelTag_Id_PixelTag

	phmap_flat_hash_map_RegionId_RegionId = phmap_flat_hash_map_Id_RegionTag_Id_RegionTag

	phmap_flat_hash_map_TextureId_TextureId = phmap_flat_hash_map_Id_TextureTag_Id_TextureTag

	phmap_flat_hash_map_UndirectedEdgeId_Id_EdgeTag = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

	phmap_flat_hash_map_UndirectedEdgeId_UndirectedEdgeId = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

	phmap_flat_hash_map_UndirectedEdgeId_int = phmap_flat_hash_map_Id_UndirectedEdgeTag_int

	phmap_flat_hash_map_VertId_FlowAggregator_Flows = phmap_flat_hash_map_Id_VertTag_FlowAggregator_Flows

	phmap_flat_hash_map_VertId_VertId = phmap_flat_hash_map_Id_VertTag_Id_VertTag

	phmap_flat_hash_map_VertId_VertPathInfo = phmap_flat_hash_map_Id_VertTag_VertPathInfo

	phmap_flat_hash_map_VertId_float = phmap_flat_hash_map_Id_VertTag_float

	phmap_flat_hash_map_int_Box3i_phmap_Hash_int32_t = phmap_flat_hash_map_int_Box_Vector3_int

	phmap_flat_hash_map_unsigned_long_std_array_VertId_3_phmap_Hash_uint64_t = phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul

	std_array_AffineXf3d_4 = std_array_AffineXf_Vector3_double_4

	std_array_AffineXf3f_4 = std_array_AffineXf_Vector3_float_4

	std_array_BooleanResultMapper_Maps_size_t_MapObject_Count = std_array_BooleanResultMapper_Maps_2

	std_array_SimpleVolumeMinMax_3 = std_array_VoxelsVolumeMinMax_std_vector_float_3

	std_array_Vector3d_3 = std_array_Vector3_double_3

	std_array_Vector3f_3 = std_array_Vector3_float_3

	std_array_Vector3i_3 = std_array_Vector3_int_3

	std_array_VertId_3 = std_array_Id_VertTag_3

	std_array_VertId_size_t_NeighborDir_Count = std_array_Id_VertTag_3

	std_array_std_filesystem_path_size_t_SystemFontType_Count = std_array_std_filesystem_path_4

	std_optional_Box1f = std_optional_Box_float

	std_optional_Box3f = std_optional_Box_Vector3_float

	std_optional_MinMaxf = std_optional_Box_float

	std_optional_Vector2f = std_optional_Vector2_float

	std_optional_Vector3f = std_optional_Vector3_float

	std_shared_ptr_ChangVoxelSelectionAction_Obj = ObjectVoxels

	std_shared_ptr_ChangeActiveBoxAction_Obj = ObjectVoxels

	std_shared_ptr_ChangeDualMarchingCubesAction_Obj = ObjectVoxels

	std_shared_ptr_ChangeGridAction_Obj = ObjectVoxels

	std_shared_ptr_ChangeIsoAction_Obj = ObjectVoxels

	std_shared_ptr_ChangeSurfaceAction_Obj = ObjectVoxels

	std_shared_ptr_GcodeSource = std_vector_std_string

	std_unique_ptr_NoDefInit_FaceId_pointer = NoDefInit_FaceId

	std_unique_ptr_NoDefInit_GraphEdgeId_pointer = NoDefInit_GraphEdgeId

	std_unique_ptr_NoDefInit_GraphVertId_pointer = NoDefInit_GraphVertId

	std_unique_ptr_NoDefInit_Id_EdgeTag_pointer = NoDefInit_Id_EdgeTag

	std_unique_ptr_NoDefInit_Id_ICPElemtTag_pointer = NoDefInit_Id_ICPElemtTag

	std_unique_ptr_NoDefInit_Id_VoxelTag_pointer = NoDefInit_Id_VoxelTag

	std_unique_ptr_NoDefInit_NodeId_pointer = NoDefInit_NodeId

	std_unique_ptr_NoDefInit_ObjId_pointer = NoDefInit_ObjId

	std_unique_ptr_NoDefInit_PixelId_pointer = NoDefInit_PixelId

	std_unique_ptr_NoDefInit_RegionId_pointer = NoDefInit_RegionId

	std_unique_ptr_NoDefInit_TextureId_pointer = NoDefInit_TextureId

	std_unique_ptr_NoDefInit_UndirectedEdgeId_pointer = NoDefInit_UndirectedEdgeId

	std_unique_ptr_NoDefInit_VertId_pointer = NoDefInit_VertId

	std_variant_FaceId_EdgeId_VertId = std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag

	std_variant_FaceId_Id_EdgeTag_VertId = std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag

	std_variant_Features_Primitives_Sphere_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

	std_variant_MeshTriPoint_EdgePoint_VertId_int = std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int

	std_variant_Polynomial_double_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6 = std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul

	std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6 = std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul

	std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

	std_variant_float_Vector3f = std_variant_float_Vector3_float

	std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f = std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box_Vector3_float

	std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_const_reference = AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

	std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_reference = AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

	std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_value_type = AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f = std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector2_float

	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_const_reference = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_reference = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_value_type = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f = std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector3_float

	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_const_reference = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_reference = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_value_type = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

	std_vector_AABBTreeNode_ObjTreeTraits_const_reference = AABBTreeNode_ObjTreeTraits

	std_vector_AABBTreeNode_ObjTreeTraits_reference = AABBTreeNode_ObjTreeTraits

	std_vector_AABBTreeNode_ObjTreeTraits_value_type = AABBTreeNode_ObjTreeTraits

	std_vector_AABBTreePoints_Node_const_reference = AABBTreePoints.Node

	std_vector_AABBTreePoints_Node_reference = AABBTreePoints.Node

	std_vector_AABBTreePoints_Node_value_type = AABBTreePoints.Node

	std_vector_AffineXf3f = std_vector_AffineXf_Vector3_float

	std_vector_AffineXf3f_const_reference = AffineXf3f

	std_vector_AffineXf3f_reference = AffineXf3f

	std_vector_AffineXf3f_value_type = AffineXf3f

	std_vector_Color_const_reference = Color

	std_vector_Color_reference = Color

	std_vector_Color_value_type = Color

	std_vector_ContinuousContour = std_vector_std_vector_VariableEdgeTri

	std_vector_Contour3d = std_vector_std_vector_Vector3_double

	std_vector_Contour3f = std_vector_std_vector_Vector3_float

	std_vector_Dipole_const_reference = Dipole

	std_vector_Dipole_reference = Dipole

	std_vector_Dipole_value_type = Dipole

	std_vector_EdgeBitSet = std_vector_TaggedBitSet_EdgeTag

	std_vector_EdgeId = std_vector_Id_EdgeTag

	std_vector_EdgeLoop = std_vector_std_vector_Id_EdgeTag

	std_vector_EdgePair = std_vector_std_pair_Id_EdgeTag_Id_EdgeTag

	std_vector_EdgePath = std_vector_std_vector_Id_EdgeTag

	std_vector_FaceBitSet = std_vector_TaggedBitSet_FaceTag

	std_vector_FaceBitSet_const_reference = FaceBitSet

	std_vector_FaceBitSet_reference = FaceBitSet

	std_vector_FaceBitSet_value_type = FaceBitSet

	std_vector_FaceId = std_vector_Id_FaceTag

	std_vector_FaceId_const_reference = FaceId

	std_vector_FaceId_reference = FaceId

	std_vector_FaceId_value_type = FaceId

	std_vector_FanRecord_const_reference = FanRecord

	std_vector_FanRecord_reference = FanRecord

	std_vector_FanRecord_value_type = FanRecord

	std_vector_Features_Primitives_Variant = std_vector_std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

	std_vector_GraphEdgeId = std_vector_Id_GraphEdgeTag

	std_vector_GraphEdgeId_const_reference = GraphEdgeId

	std_vector_GraphEdgeId_reference = GraphEdgeId

	std_vector_GraphEdgeId_value_type = GraphEdgeId

	std_vector_GraphVertId = std_vector_Id_GraphVertTag

	std_vector_GraphVertId_const_reference = GraphVertId

	std_vector_GraphVertId_reference = GraphVertId

	std_vector_GraphVertId_value_type = GraphVertId

	std_vector_Graph_EdgeId = std_vector_Id_GraphEdgeTag

	std_vector_Graph_EndVertices_const_reference = Graph.EndVertices

	std_vector_Graph_EndVertices_reference = Graph.EndVertices

	std_vector_Graph_EndVertices_value_type = Graph.EndVertices

	std_vector_Heap_float_GraphVertId_std_greater_float_Element = std_vector_Heap_float_Id_GraphVertTag_std_greater_float_Element

	std_vector_ICPGroupPairs_const_reference = ICPGroupPairs

	std_vector_ICPGroupPairs_reference = ICPGroupPairs

	std_vector_ICPGroupPairs_value_type = ICPGroupPairs

	std_vector_Id_EdgeTag_const_reference = Id_EdgeTag

	std_vector_Id_EdgeTag_reference = Id_EdgeTag

	std_vector_Id_EdgeTag_value_type = Id_EdgeTag

	std_vector_Id_ICPElemtTag_const_reference = Id_ICPElemtTag

	std_vector_Id_ICPElemtTag_reference = Id_ICPElemtTag

	std_vector_Id_ICPElemtTag_value_type = Id_ICPElemtTag

	std_vector_Id_VoxelTag_const_reference = Id_VoxelTag

	std_vector_Id_VoxelTag_reference = Id_VoxelTag

	std_vector_Id_VoxelTag_value_type = Id_VoxelTag

	std_vector_Line3dMesh = std_vector_Line3Mesh_double

	std_vector_Line3fMesh = std_vector_Line3Mesh_float

	std_vector_MeshBuilder_VertSpan_const_reference = MeshBuilder.VertSpan

	std_vector_MeshBuilder_VertSpan_reference = MeshBuilder.VertSpan

	std_vector_MeshBuilder_VertSpan_value_type = MeshBuilder.VertSpan

	std_vector_MeshEdgePoint = std_vector_EdgePoint

	std_vector_MeshOrPointsXf_const_reference = MeshOrPointsXf

	std_vector_MeshOrPointsXf_reference = MeshOrPointsXf

	std_vector_MeshOrPointsXf_value_type = MeshOrPointsXf

	std_vector_MeshTexture_const_reference = MeshTexture

	std_vector_MeshTexture_reference = MeshTexture

	std_vector_MeshTexture_value_type = MeshTexture

	std_vector_ModelPointsData_const_reference = ModelPointsData

	std_vector_ModelPointsData_reference = ModelPointsData

	std_vector_ModelPointsData_value_type = ModelPointsData

	std_vector_MultipleEdge = std_vector_std_pair_Id_VertTag_Id_VertTag

	std_vector_NodeId = std_vector_Id_NodeTag

	std_vector_NodeId_const_reference = NodeId

	std_vector_NodeId_reference = NodeId

	std_vector_NodeId_value_type = NodeId

	std_vector_ObjId = std_vector_Id_ObjTag

	std_vector_ObjId_const_reference = ObjId

	std_vector_ObjId_reference = ObjId

	std_vector_ObjId_value_type = ObjId

	std_vector_ObjectPtr = std_vector_std_shared_ptr_Object

	std_vector_OffsetContoursVertMap = std_vector_std_vector_OffsetContoursOrigins

	std_vector_PixelId = std_vector_Id_PixelTag

	std_vector_PixelId_const_reference = PixelId

	std_vector_PixelId_reference = PixelId

	std_vector_PixelId_value_type = PixelId

	std_vector_PlanarTriangulation_ContourIdMap = std_vector_std_vector_PlanarTriangulation_IntersectionInfo

	std_vector_PlanarTriangulation_HoleVertIds = std_vector_std_vector_Id_VertTag

	std_vector_Polyline3 = std_vector_Polyline_Vector3_float

	std_vector_QuadraticForm2f = std_vector_QuadraticForm_Vector2_float

	std_vector_QuadraticForm2f_const_reference = QuadraticForm2f

	std_vector_QuadraticForm2f_reference = QuadraticForm2f

	std_vector_QuadraticForm2f_value_type = QuadraticForm2f

	std_vector_QuadraticForm3f = std_vector_QuadraticForm_Vector3_float

	std_vector_QuadraticForm3f_const_reference = QuadraticForm3f

	std_vector_QuadraticForm3f_reference = QuadraticForm3f

	std_vector_QuadraticForm3f_value_type = QuadraticForm3f

	std_vector_RegionId = std_vector_Id_RegionTag

	std_vector_RegionId_const_reference = RegionId

	std_vector_RegionId_reference = RegionId

	std_vector_RegionId_value_type = RegionId

	std_vector_RigidXf3d = std_vector_RigidXf3_double

	std_vector_SurfacePath = std_vector_std_vector_EdgePoint

	std_vector_SystemPath_SystemFontPaths = std_vector_std_array_std_filesystem_path_4ul

	std_vector_TextureId = std_vector_Id_TextureTag

	std_vector_TextureId_const_reference = TextureId

	std_vector_TextureId_reference = TextureId

	std_vector_TextureId_value_type = TextureId

	std_vector_ThreeVertIds = std_vector_std_array_Id_VertTag_3ul

	std_vector_TriPointf = std_vector_TriPoint_float

	std_vector_Triangle3f = std_vector_std_array_Vector3_float_3ul

	std_vector_UVCoord = std_vector_Vector2_float

	std_vector_UndirectedEdgeBitSet = std_vector_TaggedBitSet_UndirectedEdgeTag

	std_vector_UndirectedEdgeId = std_vector_Id_UndirectedEdgeTag

	std_vector_UndirectedEdgeId_const_reference = UndirectedEdgeId

	std_vector_UndirectedEdgeId_reference = UndirectedEdgeId

	std_vector_UndirectedEdgeId_value_type = UndirectedEdgeId

	std_vector_VdbVolume = std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid

	std_vector_Vector2d = std_vector_Vector2_double

	std_vector_Vector2f = std_vector_Vector2_float

	std_vector_Vector2f_const_reference = Vector2f

	std_vector_Vector2f_reference = Vector2f

	std_vector_Vector2f_value_type = Vector2f

	std_vector_Vector3d = std_vector_Vector3_double

	std_vector_Vector3f = std_vector_Vector3_float

	std_vector_Vector3f_const_reference = Vector3f

	std_vector_Vector3f_reference = Vector3f

	std_vector_Vector3f_value_type = Vector3f

	std_vector_Vector3i = std_vector_Vector3_int

	std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_const_reference = Vector_ICPGroupPairs_Id_ICPElemtTag

	std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_reference = Vector_ICPGroupPairs_Id_ICPElemtTag

	std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_value_type = Vector_ICPGroupPairs_Id_ICPElemtTag

	std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_const_reference = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

	std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_reference = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

	std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_value_type = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

	std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_const_reference = Vector_std_vector_ObjVertId_Id_ICPElemtTag

	std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_reference = Vector_std_vector_ObjVertId_Id_ICPElemtTag

	std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_value_type = Vector_std_vector_ObjVertId_Id_ICPElemtTag

	std_vector_VertBitSet = std_vector_TaggedBitSet_VertTag

	std_vector_VertBitSet_const_reference = VertBitSet

	std_vector_VertBitSet_reference = VertBitSet

	std_vector_VertBitSet_value_type = VertBitSet

	std_vector_VertId = std_vector_Id_VertTag

	std_vector_VertId_const_reference = VertId

	std_vector_VertId_reference = VertId

	std_vector_VertId_value_type = VertId

	std_vector_VoxelBitSet = std_vector_TaggedBitSet_VoxelTag

	std_vector_WatershedGraph_BasinInfo_const_reference = WatershedGraph.BasinInfo

	std_vector_WatershedGraph_BasinInfo_reference = WatershedGraph.BasinInfo

	std_vector_WatershedGraph_BasinInfo_value_type = WatershedGraph.BasinInfo

	std_vector_WatershedGraph_BdInfo_const_reference = WatershedGraph.BdInfo

	std_vector_WatershedGraph_BdInfo_reference = WatershedGraph.BdInfo

	std_vector_WatershedGraph_BdInfo_value_type = WatershedGraph.BdInfo

	std_vector_const_Mesh = std_vector_Mesh_const

	std_vector_size_t = std_vector_unsigned_long

	std_vector_std_array_Vector3f_3 = std_vector_std_array_Vector3_float_3ul

	std_vector_std_array_Vector3f_3_const_reference = std_array_Vector3_float_3

	std_vector_std_array_Vector3f_3_reference = std_array_Vector3_float_3

	std_vector_std_array_Vector3f_3_value_type = std_array_Vector3_float_3

	std_vector_std_array_VertId_3 = std_vector_std_array_Id_VertTag_3ul

	std_vector_std_array_VertId_3_const_reference = std_array_Id_VertTag_3

	std_vector_std_array_VertId_3_reference = std_array_Id_VertTag_3

	std_vector_std_array_VertId_3_value_type = std_array_Id_VertTag_3

	std_vector_std_array_std_filesystem_path_4 = std_vector_std_array_std_filesystem_path_4ul

	std_vector_std_pair_Vector3f_Vector3f = std_vector_std_pair_Vector3_float_Vector3_float

	std_vector_std_pair_VertId_VertId = std_vector_std_pair_Id_VertTag_Id_VertTag

	std_vector_std_pair_size_t_size_t = std_vector_std_pair_unsigned_long_unsigned_long

	std_vector_std_shared_ptr_const_Object = std_vector_std_shared_ptr_Object_const

	std_vector_std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_vector_std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

	std_vector_std_vector_EdgePoint_const_reference = std_vector_EdgePoint

	std_vector_std_vector_EdgePoint_reference = std_vector_EdgePoint

	std_vector_std_vector_EdgePoint_value_type = std_vector_EdgePoint

	std_vector_std_vector_GraphEdgeId = std_vector_std_vector_Id_GraphEdgeTag

	std_vector_std_vector_GraphEdgeId_const_reference = std_vector_Id_GraphEdgeTag

	std_vector_std_vector_GraphEdgeId_reference = std_vector_Id_GraphEdgeTag

	std_vector_std_vector_GraphEdgeId_value_type = std_vector_Id_GraphEdgeTag

	std_vector_std_vector_ObjVertId_const_reference = std_vector_ObjVertId

	std_vector_std_vector_ObjVertId_reference = std_vector_ObjVertId

	std_vector_std_vector_ObjVertId_value_type = std_vector_ObjVertId

	std_vector_std_vector_Vector2d = std_vector_std_vector_Vector2_double

	std_vector_std_vector_Vector2f = std_vector_std_vector_Vector2_float

	std_vector_std_vector_Vector3d = std_vector_std_vector_Vector3_double

	std_vector_std_vector_Vector3f = std_vector_std_vector_Vector3_float

	std_vector_std_vector_VertId = std_vector_std_vector_Id_VertTag

	std_vector_uint8_t = std_vector_unsigned_char

	vectorConstMeshPtr = std_vector_Mesh_const

	vectorEdges = std_vector_Id_EdgeTag

Function Documentation

◆ accumulateFaceCenters()

None meshlib.mrmeshpy.accumulateFaceCenters	(	PointAccumulator	accum,
		MeshPart	mp,
		AffineXf3f	xf = None )

Adds in existing PointAccumulator all mesh face centers with the weight equal to face area

◆ accumulateLineCenters()

None meshlib.mrmeshpy.accumulateLineCenters	(	PointAccumulator	accum,
		Polyline3	pl,
		AffineXf3f	xf = None )

Adds in existing PointAccumulator all line centers with the weight equal to the length line

◆ accumulatePoints() [1/2]

None meshlib.mrmeshpy.accumulatePoints	(	PointAccumulator	accum,
		PointCloud	pc,
		AffineXf3f	xf = None )

Adds in existing PointAccumulator all points from the cloud with weight 1

◆ accumulatePoints() [2/2]

None meshlib.mrmeshpy.accumulatePoints	(	PointAccumulator	accum,
		std_vector_Vector3_float	points,
		AffineXf3f	xf = None )

Adds in existing PointAccumulator all given points

◆ accumulateWeighedPoints()

None meshlib.mrmeshpy.accumulateWeighedPoints	(	PointAccumulator	accum,
		std_vector_Vector3_float	points,
		std_vector_float	weights,
		AffineXf3f	xf = None )

Adds in existing PointAccumulator all given weighed points

◆ addBaseToPlanarMesh()

None meshlib.mrmeshpy.addBaseToPlanarMesh	(	Mesh	mesh,
		float	zOffset = 1.0 )

given a planar mesh with boundary on input located in plane XY, packs and extends it along Z on zOffset to make a volumetric closed mesh
zOffset should be > 0

◆ addLeftBand()

None meshlib.mrmeshpy.addLeftBand	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	loop,
		FaceBitSet	addHere )

adds all faces incident to loop vertices and located to the left from the loop to given FaceBitSet

◆ addNoise()

None meshlib.mrmeshpy.addNoise	(	VertCoords	points,
		VertBitSet	validVerts,
		NoiseSettings	settings )

Adds noise to the points, using a normal distribution

◆ alignTextToMesh()

Mesh meshlib.mrmeshpy.alignTextToMesh	(	Mesh	mesh,
		TextMeshAlignParams	params )

Creates symbol mesh and aligns it to given surface

◆ angle() [1/6]

float meshlib.mrmeshpy.angle	(	Vector2d	a,
		Vector2d	b )

angle in radians between two vectors

◆ angle() [2/6]

float meshlib.mrmeshpy.angle	(	Vector2f	a,
		Vector2f	b )

angle in radians between two vectors

◆ angle() [3/6]

int meshlib.mrmeshpy.angle	(	Vector2i	a,
		Vector2i	b )

angle in radians between two vectors

◆ angle() [4/6]

float meshlib.mrmeshpy.angle	(	Vector3d	a,
		Vector3d	b )

computes minimal angle in [0,pi] between two vectors;
the function is symmetric: angle( a, b ) == angle( b, a )

◆ angle() [5/6]

float meshlib.mrmeshpy.angle	(	Vector3f	a,
		Vector3f	b )

computes minimal angle in [0,pi] between two vectors;
the function is symmetric: angle( a, b ) == angle( b, a )

◆ angle() [6/6]

int meshlib.mrmeshpy.angle	(	Vector3i	a,
		Vector3i	b )

computes minimal angle in [0,pi] between two vectors;
the function is symmetric: angle( a, b ) == angle( b, a )

◆ appendObjectFromTreeRecursive() [1/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_Object	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [2/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_ObjectDistanceMap	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [3/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_ObjectLines	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [4/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_ObjectLinesHolder	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [5/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_ObjectMesh	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [6/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_ObjectMeshHolder	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [7/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_ObjectPoints	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [8/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_ObjectPointsHolder	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [9/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_ObjectVoxels	res,
		ObjectSelectivityType	type )

◆ appendObjectFromTreeRecursive() [10/10]

None meshlib.mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_VisualObject	res,
		ObjectSelectivityType	type )

◆ applyDouble() [1/2]

Vector3d meshlib.mrmeshpy.applyDouble	(	AffineXf3d	xf,
		Vector3f	p )

converts given point in double precision and applies given transformation to it

◆ applyDouble() [2/2]

Vector3d meshlib.mrmeshpy.applyDouble	(	Matrix3d	m,
		Vector3f	n )

converts given normal in double precision and applies given matrix to it

◆ applyFloat() [1/2]

Vector3f meshlib.mrmeshpy.applyFloat	(	AffineXf3d	xf,
		Vector3f	p )

returns the point as is or after application of given transform to it in double precision

◆ applyFloat() [2/2]

Vector3f meshlib.mrmeshpy.applyFloat	(	Matrix3d	m,
		Vector3f	n )

returns the normal as is or after application of given matrix to it in double precision

◆ asSelectivityType_Object()

Object meshlib.mrmeshpy.asSelectivityType_Object	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_ObjectDistanceMap()

ObjectDistanceMap meshlib.mrmeshpy.asSelectivityType_ObjectDistanceMap	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_ObjectLines()

ObjectLines meshlib.mrmeshpy.asSelectivityType_ObjectLines	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_ObjectLinesHolder()

ObjectLinesHolder meshlib.mrmeshpy.asSelectivityType_ObjectLinesHolder	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_ObjectMesh()

ObjectMesh meshlib.mrmeshpy.asSelectivityType_ObjectMesh	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_ObjectMeshHolder()

ObjectMeshHolder meshlib.mrmeshpy.asSelectivityType_ObjectMeshHolder	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_ObjectPoints()

ObjectPoints meshlib.mrmeshpy.asSelectivityType_ObjectPoints	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_ObjectPointsHolder()

ObjectPointsHolder meshlib.mrmeshpy.asSelectivityType_ObjectPointsHolder	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_ObjectVoxels()

ObjectVoxels meshlib.mrmeshpy.asSelectivityType_ObjectVoxels	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asSelectivityType_VisualObject()

VisualObject meshlib.mrmeshpy.asSelectivityType_VisualObject	(	Object	obj,
		ObjectSelectivityType	type )

if input object is of given type then returns another pointer on it

◆ asString() [1/2]

str meshlib.mrmeshpy.asString ( SignDetectionMode m )

returns string representation of enum values

◆ asString() [2/2]

str meshlib.mrmeshpy.asString ( str s )

◆ asU8String()

str meshlib.mrmeshpy.asU8String ( str s )

◆ autoOrientLocalTriangulations()

bool meshlib.mrmeshpy.autoOrientLocalTriangulations	(	PointCloud	pointCloud,
		AllLocalTriangulations	triangs,
		VertBitSet	region,
		func_bool_from_float	progress = 'MR::ProgressCallback{}',
		Triangulation	outRep3 = None,
		Triangulation	outRep2 = None )

orient neighbors around each point in \\param region so there will be as many triangles with same (and not opposite) orientation as possible

◆ begin() [1/4]

SetBitIterator meshlib.mrmeshpy.begin ( BitSet a )

◆ begin() [2/4]

RingIterator_NextEdgeSameOrigin meshlib.mrmeshpy.begin ( IteratorRange_RingIterator_NextEdgeSameOrigin range )

◆ begin() [3/4]

UndirectedEdgeSetBitIterator meshlib.mrmeshpy.begin ( UndirectedEdgeBitSet a )

◆ begin() [4/4]

ViewportIterator meshlib.mrmeshpy.begin ( ViewportMask mask )

◆ bestQuadrangleDiagonal()

bool meshlib.mrmeshpy.bestQuadrangleDiagonal	(	Vector3f	a,
		Vector3f	b,
		Vector3f	c,
		Vector3f	d )

given quadrangle ABCD, selects how to best triangulate it:
  false = by introducing BD diagonal and splitting ABCD on triangles ABD and DBC,
  true  = by introducing AC diagonal and splitting ABCD on triangles ABC and ACD

◆ blend()

Color meshlib.mrmeshpy.blend	(	Color	front,
		Color	back )

Blend two colors together
\\note This operation is not commutative

◆ boolean() [1/2]

BooleanResult meshlib.mrmeshpy.boolean	(	Mesh	meshA,
		Mesh	meshB,
		BooleanOperation	operation,
		AffineXf3f	rigidB2A,
		BooleanResultMapper	mapper = None,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

\\brief Performs CSG operation on two meshes

\\ingroup BooleanGroup
Makes new mesh - result of boolean operation on mesh `A` and mesh `B`
\\param meshA Input mesh `A`
\\param meshB Input mesh `B`
\\param operation CSG operation to perform
\\param rigidB2A Transform from mesh `B` space to mesh `A` space
\\param mapper Optional output structure to map mesh `A` and mesh `B` topology to result mesh topology

\\note Input meshes should have no self-intersections in intersecting zone
\\note If meshes are not closed in intersecting zone some boolean operations are not allowed (as far as input meshes interior and exterior cannot be determined)

◆ boolean() [2/2]

BooleanResult meshlib.mrmeshpy.boolean	(	Mesh	meshA,
		Mesh	meshB,
		BooleanOperation	operation,
		BooleanParameters	params = 'MR::BooleanParameters{}' )

◆ buildBottom()

Id_EdgeTag meshlib.mrmeshpy.buildBottom	(	Mesh	mesh,
		Id_EdgeTag	a,
		Vector3f	dir,
		float	holeExtension,
		FaceBitSet	outNewFaces = None )

adds cylindrical extension of given hole represented by one of its edges (having no valid left face)
by adding new vertices located in lowest point of the hole -dir*holeExtension and 2 * number_of_hole_edge triangles;
\\return the edge of new hole opposite to input edge (a)

◆ buildCylinderBetweenTwoHoles() [1/2]

None meshlib.mrmeshpy.buildCylinderBetweenTwoHoles	(	Mesh	mesh,
		Id_EdgeTag	a,
		Id_EdgeTag	b,
		StitchHolesParams	params = 'MR::StitchHolesParams{}' )

\\brief Stitches two holes in Mesh\\n

Build cylindrical patch to fill space between two holes represented by one of their edges each,\\n
default metric: ComplexStitchMetric

\\image html fill/before_stitch.png "Before" width = 250cm
\\image html fill/stitch.png "After" width = 250cm

Next picture show, how newly generated faces can be smoothed
\\ref MR::positionVertsSmoothly
\\ref MR::subdivideMesh
\\image html fill/stitch_smooth.png "Stitch with smooth" width = 250cm

\\param mesh mesh with hole
\\param a EdgeId which represents 1st hole (should not have valid left FaceId)
\\param b EdgeId which represents 2nd hole (should not have valid left FaceId)
\\param params parameters of holes stitching

\\sa \\ref fillHole
\\sa \\ref StitchHolesParams

◆ buildCylinderBetweenTwoHoles() [2/2]

bool meshlib.mrmeshpy.buildCylinderBetweenTwoHoles	(	Mesh	mesh,
		StitchHolesParams	params = 'MR::StitchHolesParams{}' )

this version finds holes in the mesh by itself and returns false if they are not found

◆ buildShortestPath() [1/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildShortestPath	(	Mesh	mesh,
		VertId	start,
		VertBitSet	finish,
		float	maxPathLen = 3.4028234663852886e+38 )

builds shortest path in euclidean metric from start to finish vertices; if no path can be found then empty path is returned

◆ buildShortestPath() [2/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildShortestPath	(	Mesh	mesh,
		VertId	start,
		VertId	finish,
		float	maxPathLen = 3.4028234663852886e+38 )

finds the shortest path in euclidean metric from start to finish vertices using Dijkstra algorithm;
if no path can be found then empty path is returned

◆ buildShortestPathAStar() [1/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildShortestPathAStar	(	Mesh	mesh,
		MeshTriPoint	start,
		MeshTriPoint	finish,
		VertId	outPathStart = None,
		VertId	outPathFinish = None,
		float	maxPathLen = 3.4028234663852886e+38 )

finds the path from a vertex in start-triangle to a vertex in finish-triangle,
so that the length start-first_vertex-...-last_vertex-finish is shortest in euclidean metric;
using A* modification of Dijkstra algorithm, which is faster for near linear path;
if no path can be found then empty path is returned

◆ buildShortestPathAStar() [2/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildShortestPathAStar	(	Mesh	mesh,
		VertId	start,
		VertId	finish,
		float	maxPathLen = 3.4028234663852886e+38 )

finds the shortest path in euclidean metric from start to finish vertices using A* modification of Dijkstra algorithm,
which is faster for near linear path;
if no path can be found then empty path is returned

◆ buildShortestPathBiDir() [1/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildShortestPathBiDir	(	Mesh	mesh,
		MeshTriPoint	start,
		MeshTriPoint	finish,
		VertId	outPathStart = None,
		VertId	outPathFinish = None,
		float	maxPathLen = 3.4028234663852886e+38 )

finds the path from a vertex in start-triangle to a vertex in finish-triangle,
so that the length start-first_vertex-...-last_vertex-finish is shortest in euclidean metric;
using bidirectional modification of Dijkstra algorithm, constructing the path simultaneously from both start and finish, which is faster for long paths;
if no path can be found then empty path is returned

◆ buildShortestPathBiDir() [2/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildShortestPathBiDir	(	Mesh	mesh,
		VertId	start,
		VertId	finish,
		float	maxPathLen = 3.4028234663852886e+38 )

finds the shortest path in euclidean metric from start to finish vertices using bidirectional modification of Dijkstra algorithm,
constructing the path simultaneously from both start and finish, which is faster for long paths;
if no path can be found then empty path is returned

◆ buildSmallestMetricPath() [1/3]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildSmallestMetricPath	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		VertId	start,
		VertBitSet	finish,
		float	maxPathMetric = 3.4028234663852886e+38 )

builds shortest path in given metric from start to finish vertices; if no path can be found then empty path is returned

◆ buildSmallestMetricPath() [2/3]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildSmallestMetricPath	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		VertId	start,
		VertId	finish,
		float	maxPathMetric = 3.4028234663852886e+38 )

builds shortest path in given metric from start to finish vertices; if no path can be found then empty path is returned

◆ buildSmallestMetricPath() [3/3]

std_vector_unsigned_long meshlib.mrmeshpy.buildSmallestMetricPath	(	VdbVolume	voxels,
		func_float_from_unsigned_long_unsigned_long	metric,
		int	start,
		int	finish,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

builds shortest path in given metric from start to finish voxels; if no path can be found then empty path is returned

◆ buildSmallestMetricPathBiDir() [1/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildSmallestMetricPathBiDir	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		TerminalVertex	starts,
		int	numStarts,
		TerminalVertex	finishes,
		int	numFinishes,
		VertId	outPathStart = None,
		VertId	outPathFinish = None,
		float	maxPathMetric = 3.4028234663852886e+38 )

finds the smallest metric path from one of start vertices to one of the finish vertices,
using bidirectional modification of Dijkstra algorithm, constructing the path simultaneously from both starts and finishes, which is faster for long paths;
if no path can be found then empty path is returned

◆ buildSmallestMetricPathBiDir() [2/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.buildSmallestMetricPathBiDir	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		VertId	start,
		VertId	finish,
		float	maxPathMetric = 3.4028234663852886e+38 )

finds the smallest metric path from start vertex to finish vertex,
using bidirectional modification of Dijkstra algorithm, constructing the path simultaneously from both start and finish, which is faster for long paths;
if no path can be found then empty path is returned

◆ buildUnitedLocalTriangulations()

AllLocalTriangulations meshlib.mrmeshpy.buildUnitedLocalTriangulations	(	PointCloud	cloud,
		TriangulationHelpers.Settings	settings,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

/ computes local triangulations of all points in the cloud united in one struct

◆ bytesString()

str meshlib.mrmeshpy.bytesString ( int size )

converts given size in string:
[0,1024) -> nnn bytes
[1024,1024*1024) -> nnn.nn Kb
[1024*1024,1024*1024*1024) -> nnn.nn Mb
...

◆ calcAvgColors()

VertColors meshlib.mrmeshpy.calcAvgColors	(	PointCloud	cloud,
		VertColors	colors,
		VertCoords	tgtPoints,
		VertBitSet	tgtVerts,
		float	sigma,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

given
\\param cloud      a point cloud
\\param colors     colors of each point in the cloud
\\param tgtPoints  some target points
\\param tgtVerts   mask of valid target points
\\param sigma      the distance of highest influence of a point
\\param cb         progress callback
computes the colors in valid target points by averaging the colors from the point cloud

◆ calcCombinedFillMetric()

float meshlib.mrmeshpy.calcCombinedFillMetric	(	Mesh	mesh,
		FaceBitSet	filledRegion,
		FillHoleMetric	metric )

Computes combined metric after filling a hole

◆ calcDamerauLevenshteinDistance()

int meshlib.mrmeshpy.calcDamerauLevenshteinDistance	(	str	stringA,
		str	stringB,
		bool	caseSensitive = True,
		int_output	outLeftRightAddition = None )

 Calculates Damerau-Levenshtein distance between to strings
 \\param outLeftRightAddition if provided return amount of insertions to the left and to the right
 \\ingroup BasicGroup

◆ calcDipoles() [1/2]

Dipoles meshlib.mrmeshpy.calcDipoles	(	AABBTree	tree,
		Mesh	mesh )

◆ calcDipoles() [2/2]

None meshlib.mrmeshpy.calcDipoles	(	Dipoles	dipoles,
		AABBTree	tree,
		Mesh	mesh )

calculates dipoles for given mesh and AABB-tree

◆ calcFaceDistances()

FaceScalars meshlib.mrmeshpy.calcFaceDistances	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		FaceBitSet	starts,
		FaceDistancesSettings	settings = 'MR::FaceDistancesSettings{}' )

computes and returns the distance of traveling from one of start faces to all other reachable faces on the mesh;
all unreachable faces will get FLT_MAX value;
\\param starts all start faces will get value 0 in the result;
\\param metric metric(e) says the distance of traveling from left(e) to right(e)

◆ calcFastWindingNumber()

float meshlib.mrmeshpy.calcFastWindingNumber	(	Dipoles	dipoles,
		AABBTree	tree,
		Mesh	mesh,
		Vector3f	q,
		float	beta,
		FaceId	skipFace )

compute approximate winding number at \\param q;
\\param beta determines the precision of the approximation: the more the better, recommended value 2 or more;
if distance from q to the center of some triangle group is more than beta times the distance from the center to most distance triangle in the group then we use approximate formula
\\param skipFace this triangle (if it is close to \\param q) will be skipped from summation

◆ calcLength() [1/4]

float meshlib.mrmeshpy.calcLength ( std_vector_Vector2_double contour )

returns sum length of the given contour
\\tparam R is the type for the accumulation and for result

◆ calcLength() [2/4]

float meshlib.mrmeshpy.calcLength ( std_vector_Vector2_float contour )

returns sum length of the given contour
\\tparam R is the type for the accumulation and for result

◆ calcLength() [3/4]

float meshlib.mrmeshpy.calcLength ( std_vector_Vector3_double contour )

returns sum length of the given contour
\\tparam R is the type for the accumulation and for result

◆ calcLength() [4/4]

float meshlib.mrmeshpy.calcLength ( std_vector_Vector3_float contour )

returns sum length of the given contour
\\tparam R is the type for the accumulation and for result

◆ calcOrientedArea() [1/5]

Vector3d meshlib.mrmeshpy.calcOrientedArea	(	std_vector_Id_EdgeTag	loop,
		Mesh	mesh )

returns the vector with the magnitude equal to the area surrounded by the loop (if the loop is planar),
and directed to see the loop in ccw order from the vector tip

◆ calcOrientedArea() [2/5]

float meshlib.mrmeshpy.calcOrientedArea ( std_vector_Vector2_double contour )

>0 for clockwise loop, < 0 for CCW loop
\\tparam R is the type for the accumulation and for result

◆ calcOrientedArea() [3/5]

float meshlib.mrmeshpy.calcOrientedArea ( std_vector_Vector2_float contour )

>0 for clockwise loop, < 0 for CCW loop
\\tparam R is the type for the accumulation and for result

◆ calcOrientedArea() [4/5]

Vector3d meshlib.mrmeshpy.calcOrientedArea ( std_vector_Vector3_double contour )

returns the vector with the magnitude equal to contour area, and directed to see the contour
in ccw order from the vector tip
\\tparam R is the type for the accumulation and for result

◆ calcOrientedArea() [5/5]

Vector3f meshlib.mrmeshpy.calcOrientedArea ( std_vector_Vector3_float contour )

returns the vector with the magnitude equal to contour area, and directed to see the contour
in ccw order from the vector tip
\\tparam R is the type for the accumulation and for result

◆ calcOriginAndDimensions()

OriginAndDimensions meshlib.mrmeshpy.calcOriginAndDimensions	(	Box3f	box,
		float	voxelSize )

computes origin and dimensions of voxel-grid to cover given 3D box with given spacing (voxelSize)

◆ calcPathLength()

float meshlib.mrmeshpy.calcPathLength	(	std_vector_Id_EdgeTag	path,
		Mesh	mesh )

◆ calcPathMetric()

float meshlib.mrmeshpy.calcPathMetric	(	std_vector_Id_EdgeTag	path,
		func_float_from_Id_EdgeTag	metric )

computes summed metric of all edges in the path

◆ canMinimizePolynomial()

bool meshlib.mrmeshpy.canMinimizePolynomial ( int degree )

◆ canSolvePolynomial()

bool meshlib.mrmeshpy.canSolvePolynomial ( int degree )

◆ ccw() [1/4]

bool meshlib.mrmeshpy.ccw ( PreciseVertCoords2 vs )

◆ ccw() [2/4]

bool meshlib.mrmeshpy.ccw ( std_array_PreciseVertCoords2_3 vs )

first sorts the indices in ascending order, then calls the predicate for sorted points

◆ ccw() [3/4]

bool meshlib.mrmeshpy.ccw	(	Vector2i	a,
		Vector2i	b )

return true if the smallest rotation from vector (a) to vector (b) is in counter-clock-wise direction;
uses simulation-of-simplicity to avoid "vectors are collinear"

◆ ccw() [4/4]

bool meshlib.mrmeshpy.ccw	(	Vector2i	a,
		Vector2i	b,
		Vector2i	c )

return true if the smallest rotation from vector (a-c) to vector (b-c) is in counter-clock-wise direction;
uses simulation-of-simplicity to avoid "vectors are collinear"

◆ checkDeloneQuadrangle() [1/2]

bool meshlib.mrmeshpy.checkDeloneQuadrangle	(	Vector3d	a,
		Vector3d	b,
		Vector3d	c,
		Vector3d	d,
		float	maxAngleChange = 1.7976931348623157e+308 )

given quadrangle ABCD, checks whether its edge AC satisfies Delone's condition;
if dihedral angles
  1) between triangles ABD and DBC and
  2) between triangles ABC and ACD
differ more than on maxAngleChange then also returns true to prevent flipping from 1) to 2)

◆ checkDeloneQuadrangle() [2/2]

bool meshlib.mrmeshpy.checkDeloneQuadrangle	(	Vector3f	a,
		Vector3f	b,
		Vector3f	c,
		Vector3f	d,
		float	maxAngleChange = 3.4028234663852886e+38 )

converts arguments in double and calls above function

◆ checkDeloneQuadrangleInMesh()

bool meshlib.mrmeshpy.checkDeloneQuadrangleInMesh	(	Mesh	mesh,
		Id_EdgeTag	edge,
		DeloneSettings	settings = 'MR::DeloneSettings{}',
		float_output	deviationSqAfterFlip = None )

consider quadrangle formed by left and right triangles of given edge, and
checks whether this edge satisfies Delone's condition in the quadrangle;
\\return false otherwise if flipping the edge does not introduce too large surface deviation (can be returned only for inner edge of the region)

◆ classifyShellVert()

ShellVertexInfo meshlib.mrmeshpy.classifyShellVert	(	MeshPart	mp,
		Vector3f	shellPoint,
		FindInnerShellSettings	settings = 'MR::FindInnerShellSettings{}' )

Tests \\param shellPoint from bidirectional shell constructed for an open \\param mp;
\\return whether the distance from given point to given mesh part is of same sign as settings.side,
if useWindingNumber = false, returns false for all points projecting on mesh boundary

◆ cloneRegion() [1/2]

ObjectMesh meshlib.mrmeshpy.cloneRegion	(	ObjectMesh	objMesh,
		FaceBitSet	region,
		bool	copyTexture = True )

constructs new ObjectMesh containing the region of data from input object
does not copy selection

◆ cloneRegion() [2/2]

ObjectPoints meshlib.mrmeshpy.cloneRegion	(	ObjectPoints	objPoints,
		VertBitSet	region )

constructs new ObjectPoints containing the region of data from input object
does not copy selection

◆ combineXYderivativeMaps()

DistanceMap meshlib.mrmeshpy.combineXYderivativeMaps ( tuple[DistanceMap, DistanceMap] XYderivativeMaps )

fill another distance map pair with gradients across X and Y axes of the argument map

◆ commonFilesName()

str meshlib.mrmeshpy.commonFilesName ( std_vector_std_filesystem_path files )

in case of empty vector, returns "Empty"
in case of single input file.ext, returns ".EXT"
in case of multiple files with same extension, returns ".EXTs"
otherwise returns "Files"

◆ compressZip()

None meshlib.mrmeshpy.compressZip	(	os.PathLike	zipFile,
		os.PathLike	sourceFolder,
		std_vector_std_filesystem_path	excludeFiles = 'std::vector<std::filesystem::path>{}',
		str	password = None,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

 \\brief compresses given folder in given zip-file
 \\param excludeFiles files that should not be included to result zip 
 \\param password if password is given then the archive will be encrypted
 \\param cb an option to get progress notifications and cancel the operation

◆ computeBasinVolume()

float meshlib.mrmeshpy.computeBasinVolume	(	Mesh	mesh,
		FaceBitSet	faces,
		float	level )

computes the volume of given mesh basin below given water level;
\\param faces shall include all basin faces at least partially below the water level

◆ computeClosestSurfacePathTargets()

phmap_flat_hash_map_Id_VertTag_Id_VertTag meshlib.mrmeshpy.computeClosestSurfacePathTargets	(	Mesh	mesh,
		VertBitSet	starts,
		VertBitSet	ends,
		VertBitSet	vertRegion = None,
		VertScalars	outSurfaceDistances = None )

for each vertex from (starts) finds the closest vertex from (ends) in geodesic sense
\\param vertRegion consider paths going in this region only

◆ computeDistanceMap()

DistanceMap meshlib.mrmeshpy.computeDistanceMap	(	MeshPart	mp,
		MeshToDistanceMapParams	params,
		func_bool_from_float	cb = 'MR::ProgressCallback{}',
		std_vector_MeshTriPoint	outSamples = None )

computes distance (height) map for given projection parameters
using float-precision for finding ray-mesh intersections, which is faster but less reliable

◆ computeDistanceMapD()

DistanceMap meshlib.mrmeshpy.computeDistanceMapD	(	MeshPart	mp,
		MeshToDistanceMapParams	params,
		func_bool_from_float	cb = 'MR::ProgressCallback{}',
		std_vector_MeshTriPoint	outSamples = None )

computes distance (height) map for given projection parameters
using double-precision for finding ray-mesh intersections, which is slower but more reliable

◆ computeFastMarchingPath()

std_vector_EdgePoint meshlib.mrmeshpy.computeFastMarchingPath	(	MeshPart	mp,
		MeshTriPoint	start,
		MeshTriPoint	end,
		VertBitSet	vertRegion = None,
		VertScalars	outSurfaceDistances = None )

computes by Fast Marching method and returns intermediate points of approximately geodesic path from start to end, where it crosses mesh edges;
the path can be limited to given region: in face-format inside mp, or in vert-format in vertRegion argument

◆ computeFormAtVertex()

QuadraticForm3f meshlib.mrmeshpy.computeFormAtVertex	(	MeshPart	mp,
		VertId	v,
		float	stabilizer,
		UndirectedEdgeBitSet	creases = None )

 \\brief Computes quadratic form at given vertex of the initial surface before decimation
 \\ingroup DecimateGroup

◆ computeFormsAtVertices()

Vector_QuadraticForm3f_VertId meshlib.mrmeshpy.computeFormsAtVertices	(	MeshPart	mp,
		float	stabilizer,
		UndirectedEdgeBitSet	creases = None )

 \\brief Computes quadratic forms at every vertex of mesh part before decimation
 \\ingroup DecimateGroup

◆ computeGeodesicPath()

std_vector_EdgePoint meshlib.mrmeshpy.computeGeodesicPath	(	Mesh	mesh,
		MeshTriPoint	start,
		MeshTriPoint	end,
		GeodesicPathApprox	atype = 'GeodesicPathApprox::FastMarching',
		int	maxGeodesicIters = 100 )

returns intermediate points of the geodesic path from start to end, where it crosses mesh edges;
It is the same as calling computeGeodesicPathApprox() then reducePath()

◆ computeGeodesicPathApprox()

std_vector_EdgePoint meshlib.mrmeshpy.computeGeodesicPathApprox	(	Mesh	mesh,
		MeshTriPoint	start,
		MeshTriPoint	end,
		GeodesicPathApprox	atype )

computes by given method and returns intermediate points of approximately geodesic path from start to end,
every next point is located in the same triangle with the previous point

◆ computeInSphereThicknessAtVertices()

VertScalars meshlib.mrmeshpy.computeInSphereThicknessAtVertices	(	Mesh	mesh,
		InSphereSearchSettings	settings,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

returns the thickness at each vertex as the diameter of the maximal inscribed sphere

◆ computeMeshNormals()

MeshNormals meshlib.mrmeshpy.computeMeshNormals ( Mesh mesh )

computes both per-face and per-vertex normals more efficiently then just calling both previous functions

◆ computeNormal()

Vector3f meshlib.mrmeshpy.computeNormal	(	AllLocalTriangulations	triangs,
		VertCoords	points,
		VertId	v )

compute normal at point by averaging neighbor triangle normals weighted by triangle's angle at the point

◆ computePerCornerNormals()

Vector_std_array_Vector3f_3_FaceId meshlib.mrmeshpy.computePerCornerNormals	(	Mesh	mesh,
		UndirectedEdgeBitSet	creases )

returns a vector with corner normals in every element for valid mesh faces;
corner normals of adjacent triangles are equal, unless they are separated by crease edges

◆ computePerFaceNormals()

FaceNormals meshlib.mrmeshpy.computePerFaceNormals ( Mesh mesh )

returns a vector with face-normal in every element for valid mesh faces

◆ computePerFaceNormals4()

None meshlib.mrmeshpy.computePerFaceNormals4	(	Mesh	mesh,
		Vector4f	faceNormals,
		int	size )

fills buffer with face-normals as Vector4f for valid mesh faces

◆ computePerVertNormals()

VertCoords meshlib.mrmeshpy.computePerVertNormals ( Mesh mesh )

returns a vector with vertex normals in every element for valid mesh vertices

◆ computePerVertPseudoNormals()

VertCoords meshlib.mrmeshpy.computePerVertPseudoNormals ( Mesh mesh )

returns a vector with vertex pseudonormals in every element for valid mesh vertices
see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.107.9173&rep=rep1&type=pdf

◆ computeRayThicknessAtVertices()

VertScalars meshlib.mrmeshpy.computeRayThicknessAtVertices	(	Mesh	mesh,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

returns the distance from each vertex along minus normal to the nearest mesh intersection (or FLT_MAX if no intersection found)

◆ computeSkyViewFactor()

VertScalars meshlib.mrmeshpy.computeSkyViewFactor	(	Mesh	terrain,
		VertCoords	samples,
		VertBitSet	validSamples,
		std_vector_SkyPatch	skyPatches,
		BitSet	outSkyRays = None,
		std_vector_MeshIntersectionResult	outIntersections = None )

computes relative radiation in each valid sample point by emitting rays from that point in the sky:
the radiation is 1.0f if all rays reach the sky not hitting the terrain;
the radiation is 0.0f if all rays do not reach the sky because they are intercepted by the terrain;
\\param outSkyRays - optional output bitset where for every valid sample #i its rays are stored at indices [i*numPatches; (i+1)*numPatches),
                    0s for occluded rays (hitting the terrain) and 1s for the ones which don't hit anything and reach the sky
\\param outIntersections - optional output vector of MeshIntersectionResult for every valid sample point

◆ computeSpaceDistances()

VertScalars meshlib.mrmeshpy.computeSpaceDistances	(	Mesh	mesh,
		PointOnFace	start,
		float	range )

computes Euclidean 3D distances from given start point to all neighbor vertices within given \\param range
and to first vertices with the distance more or equal than range

◆ computeSteepestDescentPath() [1/2]

std_vector_EdgePoint meshlib.mrmeshpy.computeSteepestDescentPath	(	MeshPart	mp,
		VertScalars	field,
		MeshTriPoint	start,
		ComputeSteepestDescentPathSettings	settings = 'MR::ComputeSteepestDescentPathSettings{}' )

computes the path (edge points crossed by the path) staring in given point
and moving in each triangle in minus gradient direction of given field;
the path stops when it reaches a local minimum in the field or one of stop conditions in settings

◆ computeSteepestDescentPath() [2/2]

None meshlib.mrmeshpy.computeSteepestDescentPath	(	MeshPart	mp,
		VertScalars	field,
		MeshTriPoint	start,
		std_vector_EdgePoint	outPath,
		ComputeSteepestDescentPathSettings	settings = 'MR::ComputeSteepestDescentPathSettings{}' )

computes the path (edge points crossed by the path) staring in given point
and moving in each triangle in minus gradient direction of given field,
and outputs the path in \\param outPath if requested;
the path stops when it reaches a local minimum in the field or one of stop conditions in settings

◆ computeSurfaceDistances() [1/6]

VertScalars meshlib.mrmeshpy.computeSurfaceDistances	(	Mesh	mesh,
		MeshTriPoint	start,
		float	maxDist = 3.4028234663852886e+38,
		VertBitSet	region = None,
		int	maxVertUpdates = 3 )

computes path distances in mesh vertices from given start point, stopping when maxDist is reached;
considered paths can go either along edges or straightly within triangles

◆ computeSurfaceDistances() [2/6]

VertScalars meshlib.mrmeshpy.computeSurfaceDistances	(	Mesh	mesh,
		MeshTriPoint	start,
		MeshTriPoint	end,
		VertBitSet	region = None,
		bool_output	endReached = None,
		int	maxVertUpdates = 3 )

computes path distance in mesh vertices from given start point, stopping when all vertices in the face where end is located are reached;
\\details considered paths can go either along edges or straightly within triangles
\\param endReached if pointer provided it will receive where a path from start to end exists

◆ computeSurfaceDistances() [3/6]

VertScalars meshlib.mrmeshpy.computeSurfaceDistances	(	Mesh	mesh,
		phmap_flat_hash_map_Id_VertTag_float	startVertices,
		float	maxDist = 3.4028234663852886e+38,
		VertBitSet	region = None,
		int	maxVertUpdates = 3 )

computes path distances in mesh vertices from given start vertices with values in them, stopping when maxDist is reached;
considered paths can go either along edges or straightly within triangles

◆ computeSurfaceDistances() [4/6]

VertScalars meshlib.mrmeshpy.computeSurfaceDistances	(	Mesh	mesh,
		std_vector_MeshTriPoint	starts,
		float	maxDist = 3.4028234663852886e+38,
		VertBitSet	region = None,
		int	maxVertUpdates = 3 )

computes path distances in mesh vertices from given start points, stopping when maxDist is reached;
considered paths can go either along edges or straightly within triangles

◆ computeSurfaceDistances() [5/6]

VertScalars meshlib.mrmeshpy.computeSurfaceDistances	(	Mesh	mesh,
		VertBitSet	startVertices,
		float	maxDist = 3.4028234663852886e+38,
		VertBitSet	region = None,
		int	maxVertUpdates = 3 )

computes path distances in mesh vertices from given start vertices, stopping when maxDist is reached;
considered paths can go either along edges or straightly within triangles

◆ computeSurfaceDistances() [6/6]

VertScalars meshlib.mrmeshpy.computeSurfaceDistances	(	Mesh	mesh,
		VertBitSet	startVertices,
		VertBitSet	targetVertices,
		float	maxDist = 3.4028234663852886e+38,
		VertBitSet	region = None,
		int	maxVertUpdates = 3 )

computes path distances in mesh vertices from given start vertices, stopping when all targetVertices or maxDist is reached;
considered paths can go either along edges or straightly within triangles

◆ computeSurfacePath()

std_vector_EdgePoint meshlib.mrmeshpy.computeSurfacePath	(	MeshPart	mp,
		MeshTriPoint	start,
		MeshTriPoint	end,
		int	maxGeodesicIters = 5,
		VertBitSet	vertRegion = None,
		VertScalars	outSurfaceDistances = None )

returns intermediate points of the geodesic path from start to end, where it crosses mesh edges;
the path can be limited to given region: in face-format inside mp, or in vert-format in vertRegion argument.
It is the same as calling computeFastMarchingPath() then reducePath()

◆ computeThicknessAtVertices()

VertScalars meshlib.mrmeshpy.computeThicknessAtVertices ( Mesh mesh )

◆ computeTrianglesRepetitions()

std_array_int_4 meshlib.mrmeshpy.computeTrianglesRepetitions ( AllLocalTriangulations triangs )

computes statistics about the number of triangle repetitions in local triangulations

◆ constantCuspToolPath()

ToolPathResult meshlib.mrmeshpy.constantCuspToolPath	(	MeshPart	mp,
		ConstantCuspParams	params )

compute path of the milling tool for the given mesh with parameters ( direction of milling is from up to down along Z-direction )
this toolpath is built from geodesic parallels divercing from the given start point or from the bounaries of selected areas
if neither is specified, the lowest section by XY plane will be used as a start contour
mesh can be transformed using xf parameter

◆ constantZToolPath()

ToolPathResult meshlib.mrmeshpy.constantZToolPath	(	MeshPart	mp,
		ToolPathParams	params )

compute path of the milling tool for the given mesh with parameters ( direction of milling is from up to down along Z-direction )
this toolpath is built from the parallel sections along Z-axis
mesh can be transformed using xf parameter

◆ contains()

bool meshlib.mrmeshpy.contains	(	FaceBitSet	bitset,
		FaceId	id )

◆ contourIntersection()

Polyline2 meshlib.mrmeshpy.contourIntersection	(	Polyline2	contoursA,
		Polyline2	contoursB,
		ContourToDistanceMapParams	params,
		float	offsetInside = 0.0 )

 \\brief computes the intersection of the shapes bounded by input 2d contours
 \\return the boundary of the intersection
 \\details input contours must be closed within the area of distance map and be consistently oriented (clockwise, that is leaving the bounded shapes from the left).
 the value of params.withSign must be true (checked with assert() inside the function)
 \\note that polyline topology should be consistently oriented

◆ contourSubtract()

Polyline2 meshlib.mrmeshpy.contourSubtract	(	Polyline2	contoursA,
		Polyline2	contoursB,
		ContourToDistanceMapParams	params,
		float	offsetInside = 0.0 )

 \\brief computes the difference between the shapes bounded by contoursA and the shapes bounded by contoursB
 \\return the boundary of the difference
 \\details input contours must be closed within the area of distance map and be consistently oriented (clockwise, that is leaving the bounded shapes from the left).
 the value of params.withSign must be true (checked with assert() inside the function)
 \\note that polyline topology should be consistently oriented

◆ contourUnion()

Polyline2 meshlib.mrmeshpy.contourUnion	(	Polyline2	contoursA,
		Polyline2	contoursB,
		ContourToDistanceMapParams	params,
		float	offsetInside = 0 )

 \\brief computes the union of the shapes bounded by input 2d contours
 \\return the boundary of the union
 \\details input contours must be closed within the area of distance map and be consistently oriented (clockwise, that is leaving the bounded shapes from the left).
 the value of params.withSign must be true (checked with assert() inside the function)
 \\note that polyline topology should be consistently oriented

◆ convertDistanceMapToImage()

Image meshlib.mrmeshpy.convertDistanceMapToImage	(	DistanceMap	distMap,
		float	threshold = 0.003921568859368563 )

export distance map to a grayscale image
\\param threshold - threshold of valid values [0.; 1.]. pixel with color less then threshold set invalid

◆ convertImageToDistanceMap()

DistanceMap meshlib.mrmeshpy.convertImageToDistanceMap	(	Image	image,
		float	threshold = 0.003921568859368563 )

load distance map from a grayscale image:
\\param threshold - threshold of valid values [0.; 1.]. pixel with color less then threshold set invalid

◆ convertMeshTriPointsIsoLineToMeshContour()

std_vector_OneMeshContour meshlib.mrmeshpy.convertMeshTriPointsIsoLineToMeshContour	(	Mesh	mesh,
		std_vector_MeshTriPoint	meshTriPoints,
		float	isoValue,
		SearchPathSettings	searchSettings = 'MR::SearchPathSettings{}' )

\\ingroup BooleanGroup
\\brief Makes continuous contour by iso-line from mesh tri points, if first and last meshTriPoint is the same, makes closed contour

Finds shortest paths between neighbor \\p meshTriPoints and build contour MR::cutMesh input
\\param isoValue amount of offset form given point, note that absolute value is used and isoline in both direction returned
\\param searchSettings settings for search geo path

◆ convertMeshTriPointsToClosedContour()

OneMeshContour meshlib.mrmeshpy.convertMeshTriPointsToClosedContour	(	Mesh	mesh,
		std_vector_MeshTriPoint	meshTriPoints,
		SearchPathSettings	searchSettings = 'MR::SearchPathSettings{}',
		std_vector_int	pivotIndices = None )

\\ingroup BooleanGroup
\\brief Makes closed continuous contour by mesh tri points, note that first and last meshTriPoint should not be same

Finds shortest paths between neighbor \\p meshTriPoints and build closed contour MR::cutMesh input
\\param pivotIndices optional output indices of given meshTriPoints in result OneMeshContour
\\note better use convertMeshTriPointsToMeshContour(...) instead, note that it requires same front and back MeshTriPoints for closed contour

◆ convertMeshTriPointsToMeshContour()

OneMeshContour meshlib.mrmeshpy.convertMeshTriPointsToMeshContour	(	Mesh	mesh,
		std_vector_MeshTriPoint	meshTriPoints,
		SearchPathSettings	searchSettings = 'MR::SearchPathSettings{}',
		std_vector_int	pivotIndices = None )

\\ingroup BooleanGroup
\\brief Makes continuous contour by mesh tri points, if first and last meshTriPoint is the same, makes closed contour

Finds shortest paths between neighbor \\p meshTriPoints and build contour MR::cutMesh input
\\param searchSettings settings for search geo path 
\\param pivotIndices optional output indices of given meshTriPoints in result OneMeshContour

◆ convertSurfacePathsToMeshContours()

std_vector_OneMeshContour meshlib.mrmeshpy.convertSurfacePathsToMeshContours	(	Mesh	mesh,
		std_vector_std_vector_EdgePoint	surfacePaths )

\\ingroup BooleanGroup
\\brief Converts SurfacePaths to OneMeshContours

Creates MR::OneMeshContours object from given surface paths for MR::cutMesh input

◆ convertSurfacePathWithEndsToMeshContour()

OneMeshContour meshlib.mrmeshpy.convertSurfacePathWithEndsToMeshContour	(	Mesh	mesh,
		MeshTriPoint	start,
		std_vector_EdgePoint	surfacePath,
		MeshTriPoint	end )

\\ingroup BooleanGroup
\\brief Converts SurfacePath to OneMeshContours

Creates MR::OneMeshContour object from given surface path with ends for MR::cutMesh input
`start` and surfacePath.front() should be from same face
surfacePath.back() and `end` should be from same face

note that whole path (including `start` and `end`) should not have self-intersections
also following case is not supported (vertex -> edge (incident with vertex)):

vert path  edge point path     edge end
o----------o-  --  --  --  --  O
 \\          \\                /
      \\      \\          /
           \\  \\     /
              \\\\/
                o path

◆ copyContour() [1/4]

std_vector_Vector2_float meshlib.mrmeshpy.copyContour ( std_vector_Vector2_double from_ )

copy double-contour to float-contour, or vice versa

◆ copyContour() [2/4]

std_vector_Vector2_double meshlib.mrmeshpy.copyContour ( std_vector_Vector2_float from_ )

copy double-contour to float-contour, or vice versa

◆ copyContour() [3/4]

std_vector_Vector3_float meshlib.mrmeshpy.copyContour ( std_vector_Vector3_double from_ )

copy double-contour to float-contour, or vice versa

◆ copyContour() [4/4]

std_vector_Vector3_double meshlib.mrmeshpy.copyContour ( std_vector_Vector3_float from_ )

copy double-contour to float-contour, or vice versa

◆ createObject()

Object meshlib.mrmeshpy.createObject ( str className )

the function to create new object instance by registered class name

◆ createRootFormObject()

SceneRootObject meshlib.mrmeshpy.createRootFormObject ( Object obj )

Removes all `obj` children and attaches it to newly created `SceneRootObject`
note that it does not respect `obj` xf

◆ createSymbolContours()

std_vector_std_vector_Vector2_float meshlib.mrmeshpy.createSymbolContours ( SymbolMeshParams params )

converts text string into set of contours

◆ createSymbolsMesh()

Mesh meshlib.mrmeshpy.createSymbolsMesh ( SymbolMeshParams params )

converts text string into Z-facing symbol mesh

◆ cropped()

OpenVdbFloatGrid meshlib.mrmeshpy.cropped	(	OpenVdbFloatGrid	grid,
		Box3i	box,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

returns cropped grid

◆ cross() [1/6]

float meshlib.mrmeshpy.cross	(	Vector2d	a,
		Vector2d	b )

cross product

◆ cross() [2/6]

float meshlib.mrmeshpy.cross	(	Vector2f	a,
		Vector2f	b )

cross product

◆ cross() [3/6]

int meshlib.mrmeshpy.cross	(	Vector2i	a,
		Vector2i	b )

cross product

◆ cross() [4/6]

Vector3d meshlib.mrmeshpy.cross	(	Vector3d	a,
		Vector3d	b )

cross product

◆ cross() [5/6]

Vector3f meshlib.mrmeshpy.cross	(	Vector3f	a,
		Vector3f	b )

cross product

◆ cross() [6/6]

Vector3i meshlib.mrmeshpy.cross	(	Vector3i	a,
		Vector3i	b )

cross product

◆ cutAlongEdgeLoop() [1/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.cutAlongEdgeLoop	(	Mesh	mesh,
		std_vector_Id_EdgeTag	c0 )

given a closed loop of edges, splits the surface along that loop so that after return:
1) returned loop has the same size as input, with corresponding edges in same indexed elements of both;
2) all edges of c0 have no left faces;
3) all returned edges have no right faces;
4) vertices of the given mesh are updated

◆ cutAlongEdgeLoop() [2/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.cutAlongEdgeLoop	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	c0 )

given a closed loop of edges, splits the surface along that loop so that after return:
1) returned loop has the same size as input, with corresponding edges in same indexed elements of both;
2) all edges of c0 have no left faces;
3) all returned edges have no right faces;

◆ cutMesh()

CutMeshResult meshlib.mrmeshpy.cutMesh	(	Mesh	mesh,
		std_vector_OneMeshContour	contours,
		CutMeshParameters	params = 'MR::CutMeshParameters{}' )

\\ingroup BooleanGroup
\\brief Cuts mesh by given contours

This function cuts mesh making new edges paths on place of input contours
\\param mesh Input mesh that will be cut
\\param contours Input contours to cut mesh with, find more \\ref MR::OneMeshContours
\\param params Parameters describing some cut options, find more \\ref MR::CutMeshParameters
\\return New edges that correspond to given contours, find more \\ref MR::CutMeshResult
\\parblock
\\warning Input contours should have no intersections, faces where contours intersects (`bad faces`) will not be allowed for fill
\\endparblock
\\parblock
\\warning Input mesh will be changed in any case, if `bad faces` are in mesh, mesh will be spoiled, \\n
so if you cannot guarantee contours without intersections better make copy of mesh, before using this function
\\endparblock

◆ deactivateFarPairs()

int meshlib.mrmeshpy.deactivateFarPairs	(	IPointPairs	pairs,
		float	maxDistSq )

reset active bit if pair distance is further than maxDistSq

◆ decimateContour() [1/2]

DecimatePolylineResult meshlib.mrmeshpy.decimateContour	(	std_vector_Vector2_float	contour,
		DecimatePolylineSettings_Vector2f	settings = 'MR::DecimatePolylineSettings2{}' )

 \\brief Collapse edges in the contour according to the settings
 \\ingroup DecimateGroup

◆ decimateContour() [2/2]

DecimatePolylineResult meshlib.mrmeshpy.decimateContour	(	std_vector_Vector3_float	contour,
		DecimatePolylineSettings_Vector3f	settings = 'MR::DecimatePolylineSettings3{}' )

◆ decimateMesh()

DecimateResult meshlib.mrmeshpy.decimateMesh	(	Mesh	mesh,
		DecimateSettings	settings = 'MR::DecimateSettings{}' )

 \\brief Collapse edges in mesh region according to the settings
 \\ingroup DecimateGroup
 \\details Have version for parallel computing - \\ref decimateParallelMesh

 \\image html decimate/decimate_before.png "Before" width = 350cm
 \\image html decimate/decimate_after.png "After" width = 350cm

 \\sa \\ref decimateParallelMesh
 \\sa \\ref resolveMeshDegenerations

◆ decimatePolyline() [1/2]

DecimatePolylineResult meshlib.mrmeshpy.decimatePolyline	(	Polyline2	polyline,
		DecimatePolylineSettings_Vector2f	settings = 'MR::DecimatePolylineSettings2{}' )

 \\brief Collapse edges in the polyline according to the settings
 \\ingroup DecimateGroup

◆ decimatePolyline() [2/2]

DecimatePolylineResult meshlib.mrmeshpy.decimatePolyline	(	Polyline3	polyline,
		DecimatePolylineSettings_Vector3f	settings = 'MR::DecimatePolylineSettings3{}' )

◆ decode64()

std_vector_unsigned_char meshlib.mrmeshpy.decode64 ( str val )

decodes Base64 format into binary data

◆ decompressZip() [1/2]

None meshlib.mrmeshpy.decompressZip	(	os.PathLike	zipFile,
		os.PathLike	targetFolder,
		str	password = None )

 \\brief decompresses given zip-file into given folder
 \\param password if password is given then it will be used to decipher encrypted archive

◆ decompressZip() [2/2]

None meshlib.mrmeshpy.decompressZip	(	typing.Any	zipStream,
		os.PathLike	targetFolder,
		str	password = None )

 \\brief decompresses given binary stream (containing the data of a zip file only) into given folder
 \\param password if password is given then it will be used to decipher encrypted archive

◆ deleteTargetFaces() [1/2]

None meshlib.mrmeshpy.deleteTargetFaces	(	Mesh	obj,
		Mesh	target )

◆ deleteTargetFaces() [2/2]

None meshlib.mrmeshpy.deleteTargetFaces	(	Mesh	obj,
		Vector3f	targetCenter )

deletes object faces with normals pointed to the target geometry center

◆ delRegionKeepBd()

std_vector_std_vector_Id_EdgeTag meshlib.mrmeshpy.delRegionKeepBd	(	Mesh	mesh,
		FaceBitSet	region = None )

deletes all region faces, inner edges and vertices, but keeps boundary edges and vertices of the region (or whole mesh if region is null);
returns edge loops, each having deleted region faces on the left, and not-region faces or holes on the right

◆ denoiseNormals()

None meshlib.mrmeshpy.denoiseNormals	(	Mesh	mesh,
		FaceNormals	normals,
		UndirectedEdgeScalars	v,
		float	gamma )

Smooth face normals, given
\\param mesh contains topology information and coordinates for equation weights
\\param normals input noisy normals and output smooth normals
\\param v edge indicator function (1 - smooth edge, 0 - crease edge)
\\param gamma the amount of smoothing: 0 - no smoothing, 1 - average smoothing, ...
see the article "Mesh Denoising via a Novel Mumford-Shah Framework", equation (19)

◆ deserializeObjectTree()

LoadedObjectT meshlib.mrmeshpy.deserializeObjectTree	(	os.PathLike	path,
		func_void_from_std_filesystem_path	postDecompress = 'MR::FolderCallback{}',
		func_bool_from_float	progressCb = 'MR::ProgressCallback{}' )

 \\brief loads objects tree from given scene file (zip/mru)
 \\details format specification:
  children are saved under folder with name of their parent object
  all objects parameters are saved in one JSON file in the root folder

 if postDecompress is set, it is called after decompression
 loading is controlled with Object::deserializeModel_ and Object::deserializeFields_

◆ deserializeObjectTreeFrom3mf()

LoadedObjectT meshlib.mrmeshpy.deserializeObjectTreeFrom3mf	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

loads scene from 3MF file in a new container object

◆ deserializeObjectTreeFromFolder()

LoadedObjectT meshlib.mrmeshpy.deserializeObjectTreeFromFolder	(	os.PathLike	folder,
		func_bool_from_float	progressCb = 'MR::ProgressCallback{}' )

 \\brief loads objects tree from given scene folder
 \\details format specification:
  children are saved under folder with name of their parent object
  all objects parameters are saved in one JSON file in the root folder

 loading is controlled with Object::deserializeModel_ and Object::deserializeFields_

◆ deserializeObjectTreeFromGltf()

Object meshlib.mrmeshpy.deserializeObjectTreeFromGltf	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

loads scene from glTF file in a new container object

◆ deserializeObjectTreeFromModel()

LoadedObjectT meshlib.mrmeshpy.deserializeObjectTreeFromModel	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

loads scene from .model file in a new container object

◆ detectBasisTunnels()

std_vector_std_vector_Id_EdgeTag meshlib.mrmeshpy.detectBasisTunnels	(	MeshPart	mp,
		func_float_from_Id_EdgeTag	metric = 'MR::EdgeMetric{}',
		func_bool_from_float	progressCallback = 'MR::ProgressCallback{}' )

detects all not-contractible-in-point and not-equivalent tunnel loops on the mesh;
trying to include in the loops the edges with the smallest metric;
if no metric is given then discreteMinusAbsMeanCurvatureMetric will be used

◆ detectLoneContours()

std_vector_int meshlib.mrmeshpy.detectLoneContours ( std_vector_std_vector_VariableEdgeTri contours )

Detects contours that fully lay inside one triangle
returns they indices in contours

◆ detectTunnelFaces()

FaceBitSet meshlib.mrmeshpy.detectTunnelFaces	(	MeshPart	mp,
		DetectTunnelSettings	settings = 'MR::DetectTunnelSettings{}' )

returns tunnels as a number of faces;
if you remove these faces and patch every boundary with disk, then the surface will be topology equivalent to sphere

◆ dilateRegion() [1/4]

bool meshlib.mrmeshpy.dilateRegion	(	Mesh	mesh,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

expands the region (of faces or vertices) on given value (in meters). returns false if callback also returns false

◆ dilateRegion() [2/4]

bool meshlib.mrmeshpy.dilateRegion	(	Mesh	mesh,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ dilateRegion() [3/4]

bool meshlib.mrmeshpy.dilateRegion	(	Mesh	mesh,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ dilateRegion() [4/4]

bool meshlib.mrmeshpy.dilateRegion	(	PointCloud	pointCloud,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	cb = 'MR::ProgressCallback{}',
		AffineXf3f	xf = None )

expands the region on given euclidian distance. returns false if callback also returns false

◆ dilateRegionByMetric() [1/3]

bool meshlib.mrmeshpy.dilateRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

expands the region (of faces or vertices) on given metric value. returns false if callback also returns false

◆ dilateRegionByMetric() [2/3]

bool meshlib.mrmeshpy.dilateRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ dilateRegionByMetric() [3/3]

bool meshlib.mrmeshpy.dilateRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ discreteAbsMeanCurvatureMetric()

func_float_from_Id_EdgeTag meshlib.mrmeshpy.discreteAbsMeanCurvatureMetric ( Mesh mesh )

returns edge's absolute discrete mean curvature as a metric;
the metric is minimal in the planar regions of mesh;
this metric is symmetric: m(e) == m(e.sym())

◆ discreteMinusAbsMeanCurvatureMetric()

func_float_from_Id_EdgeTag meshlib.mrmeshpy.discreteMinusAbsMeanCurvatureMetric ( Mesh mesh )

returns minus of edge's absolute discrete mean curvature as a metric;
the metric is minimal in the most curved regions of mesh;
this metric is symmetric: m(e) == m(e.sym())

◆ distanceMapFromContours() [1/2]

None meshlib.mrmeshpy.distanceMapFromContours	(	DistanceMap	distMap,
		Polyline2	polyline,
		ContourToDistanceMapParams	params,
		ContoursDistanceMapOptions	options = 'MR::ContoursDistanceMapOptions{}' )

 \\brief Computes distance of 2d contours according ContourToDistanceMapParams
 \\param distMap - preallocated distance map
 \\param options - optional input and output options for distance map calculation, find more \\ref ContoursDistanceMapOptions

◆ distanceMapFromContours() [2/2]

DistanceMap meshlib.mrmeshpy.distanceMapFromContours	(	Polyline2	contours,
		ContourToDistanceMapParams	params,
		ContoursDistanceMapOptions	options = 'MR::ContoursDistanceMapOptions{}' )

 \\brief Computes distance of 2d contours according ContourToDistanceMapParams
 \\param options - optional input and output options for distance map calculation, find more \\ref ContoursDistanceMapOptions

◆ distanceMapTo2DIsoPolyline() [1/4]

tuple[Polyline2, AffineXf3f] meshlib.mrmeshpy.distanceMapTo2DIsoPolyline	(	DistanceMap	distMap,
		AffineXf3f	xf,
		float	isoValue,
		bool	useDepth = False )

computes iso-lines of distance map corresponding to given iso-value;
in second returns the transformation from 0XY plane to world;
\\param useDepth true - the isolines will be located on distance map surface, false - isolines for any iso-value will be located on the common plane xf(0XY)

◆ distanceMapTo2DIsoPolyline() [2/4]

Polyline2 meshlib.mrmeshpy.distanceMapTo2DIsoPolyline	(	DistanceMap	distMap,
		ContourToDistanceMapParams	params,
		float	isoValue )

iso-lines are created in real space ( plane OXY with parameters according ContourToDistanceMapParams )

◆ distanceMapTo2DIsoPolyline() [3/4]

Polyline2 meshlib.mrmeshpy.distanceMapTo2DIsoPolyline	(	DistanceMap	distMap,
		float	isoValue )

converts distance map to 2d iso-lines:
iso-lines are created in space DistanceMap ( plane OXY with pixelSize = (1, 1) )

◆ distanceMapTo2DIsoPolyline() [4/4]

Polyline2 meshlib.mrmeshpy.distanceMapTo2DIsoPolyline	(	DistanceMap	distMap,
		float	pixelSize,
		float	isoValue )

◆ distanceMapToMesh()

Mesh meshlib.mrmeshpy.distanceMapToMesh	(	DistanceMap	distMap,
		AffineXf3f	toWorld,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

converts distance map into mesh and applies a transformation to all points

◆ dividePolylineWithPlane()

None meshlib.mrmeshpy.dividePolylineWithPlane	(	Polyline3	polyline,
		Plane3f	plane,
		DividePolylineParameters	params = 'MR::DividePolylineParameters{}' )

This function divides polyline with a plane
\\param polyline Input polyline that will be cut by the plane
\\param plane Input plane to cut polyline with
\\param params parameters of the function, contains optional output

◆ divideWithPlane()

PointCloud meshlib.mrmeshpy.divideWithPlane	(	PointCloud	points,
		Plane3f	plane,
		DividePointCloudOptionalOutput	optOut = 'MR::DividePointCloudOptionalOutput{}' )

This function cuts a point cloud with a plane, leaving only the part of mesh that lay in positive direction of normal
\\return Point cloud object with vertices on the positive side of the plane
\\param pc Input point cloud that will be cut by the plane
\\param plane Input plane to cut point cloud with
\\param optOut optional output of the function

◆ doBooleanOperation()

Mesh meshlib.mrmeshpy.doBooleanOperation	(	Mesh	meshACut,
		Mesh	meshBCut,
		std_vector_std_vector_Id_EdgeTag	cutEdgesA,
		std_vector_std_vector_Id_EdgeTag	cutEdgesB,
		BooleanOperation	operation,
		AffineXf3f	rigidB2A = None,
		BooleanResultMapper	mapper = None,
		bool	mergeAllNonIntersectingComponents = False,
		BooleanInternalParameters	intParams = 'MR::BooleanInternalParameters{}' )

Perform boolean operation on cut meshes
\\return mesh in space of meshA or error.
\\note: actually this function is meant to be internal, use "boolean" instead

◆ doSegmentSegmentIntersect()

SegmentSegmentIntersectResult meshlib.mrmeshpy.doSegmentSegmentIntersect ( std_array_PreciseVertCoords2_4 vs )

checks whether the segments AB (indices 01) and segments CD (indices 23) intersect;
uses simulation-of-simplicity to avoid edge-segment intersections and co-planarity

◆ dot() [1/6]

float meshlib.mrmeshpy.dot	(	Vector2d	a,
		Vector2d	b )

dot product

◆ dot() [2/6]

float meshlib.mrmeshpy.dot	(	Vector2f	a,
		Vector2f	b )

dot product

◆ dot() [3/6]

int meshlib.mrmeshpy.dot	(	Vector2i	a,
		Vector2i	b )

dot product

◆ dot() [4/6]

float meshlib.mrmeshpy.dot	(	Vector3d	a,
		Vector3d	b )

dot product

◆ dot() [5/6]

float meshlib.mrmeshpy.dot	(	Vector3f	a,
		Vector3f	b )

dot product

◆ dot() [6/6]

int meshlib.mrmeshpy.dot	(	Vector3i	a,
		Vector3i	b )

dot product

◆ doTriangleSegmentIntersect()

TriangleSegmentIntersectResult meshlib.mrmeshpy.doTriangleSegmentIntersect ( std_array_PreciseVertCoords_5 vs )

checks whether triangle ABC (indices 012) and segment DE (indices 34) intersect
uses simulation-of-simplicity to avoid edge-segment intersections and co-planarity

◆ doubleOffsetMesh()

Mesh meshlib.mrmeshpy.doubleOffsetMesh	(	MeshPart	mp,
		float	offsetA,
		float	offsetB,
		OffsetParameters	params = 'MR::OffsetParameters{}' )

Offsets mesh by converting it to voxels and back two times
only closed meshes allowed (only Offset mode)
typically offsetA and offsetB have distinct signs

◆ doubleOffsetVdb()

Mesh meshlib.mrmeshpy.doubleOffsetVdb	(	MeshPart	mp,
		DoubleOffsetSettings	settings )

performs convention from mesh to voxel grid and back with offsetA, and than same with offsetB;
if input mesh is not closed then the sign of distance field will be obtained using generalized winding number computation

◆ duplicateMultiHoleVertices()

int meshlib.mrmeshpy.duplicateMultiHoleVertices ( Mesh mesh )

Duplicates all vertices having more than two boundary edges (and returns the number of duplications);

◆ edgeCurvMetric()

func_float_from_Id_EdgeTag meshlib.mrmeshpy.edgeCurvMetric	(	Mesh	mesh,
		float	angleSinFactor = 2,
		float	angleSinForBoundary = 0 )

returns edge's metric that depends both on edge's length and on the angle between its left and right faces
\\param angleSinFactor multiplier before dihedral angle sine in edge metric calculation (positive to prefer concave angles, negative - convex)
\\param angleSinForBoundary consider this dihedral angle sine for boundary edges;
this metric is symmetric: m(e) == m(e.sym())

◆ edgeLengthMetric()

func_float_from_Id_EdgeTag meshlib.mrmeshpy.edgeLengthMetric ( Mesh mesh )

returns edge's length as a metric;
this metric is symmetric: m(e) == m(e.sym())

◆ edgeMapsComposition()

EdgeMap meshlib.mrmeshpy.edgeMapsComposition	(	EdgeMap	a2b,
		EdgeMap	b2c )

updates a2b map to a2c map using b2c map

returns map a2c from a2b and b2c maps

◆ edgePointsFromContours()

std_vector_Vector3_float meshlib.mrmeshpy.edgePointsFromContours	(	Polyline2	polyline,
		float	pixelSize,
		float	threshold )

Makes distance map and filter out pixels with large (>threshold) distance between closest points on contour in neighbor pixels
Converts such points back in 3d space and return
\\note that polyline topology should be consistently oriented

◆ edgeTableMetric()

func_float_from_Id_EdgeTag meshlib.mrmeshpy.edgeTableMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric )

◆ edgeTableSymMetric()

func_float_from_Id_EdgeTag meshlib.mrmeshpy.edgeTableSymMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric )

pre-computes the metric for all mesh edges to quickly return it later for any edge;
input metric must be symmetric: metric(e) == metric(e.sym())

◆ eliminateDegree3Dest()

Id_EdgeTag meshlib.mrmeshpy.eliminateDegree3Dest	(	MeshTopology	topology,
		Id_EdgeTag	e,
		FaceBitSet	region = None )

if the destination of given edge has degree 3 and 3 incident triangles,
then eliminates the destination vertex with all its edges and all but one faces, and returns valid remaining edge with same origin as e;
if region is provided then eliminated triangles are excluded from it;
otherwise returns invalid edge

◆ eliminateDegree3Vertices()

int meshlib.mrmeshpy.eliminateDegree3Vertices	(	MeshTopology	topology,
		VertBitSet	region,
		FaceBitSet	fs = None )

eliminates from the mesh all vertices having degree 3 and 3 incident triangles from given region (which is updated);
if \\param fs is provided then eliminated triangles are excluded from it;
\\return the number of vertices eliminated

◆ eliminateDoubleTris()

Id_EdgeTag meshlib.mrmeshpy.eliminateDoubleTris	(	MeshTopology	topology,
		Id_EdgeTag	e,
		FaceBitSet	region = None )

if the edge e has both left and right triangular faces and the degree of dest( e ) is 2,
then eliminates left( e ), right( e ), e, e.sym(), next( e ), dest( e ), and returns prev( e );
if region is provided then eliminated faces are excluded from it;
otherwise returns invalid edge

◆ eliminateDoubleTrisAround()

None meshlib.mrmeshpy.eliminateDoubleTrisAround	(	MeshTopology	topology,
		VertId	v,
		FaceBitSet	region = None )

eliminates all double triangles around given vertex preserving vertex valid;
if region is provided then eliminated triangles are excluded from it

◆ embedStructureToTerrain()

Mesh meshlib.mrmeshpy.embedStructureToTerrain	(	Mesh	terrain,
		Mesh	structure,
		EmbeddedStructureParameters	params )

Returns terrain mesh with structure embedded to it, or error string
terrain - mesh with +Z normal (not-closed mesh is expected)
structure - mesh with one open contour and +Z normal, that will be embedded in terrain

◆ encode64()

str meshlib.mrmeshpy.encode64	(	int	data,
		int	size )

encodes binary data into textual Base64 format

◆ end() [1/2]

ViewportIterator meshlib.mrmeshpy.end	(	*	args,
		**	kwargs )

◆ end() [2/2]

RingIterator_NextEdgeSameOrigin meshlib.mrmeshpy.end ( IteratorRange_RingIterator_NextEdgeSameOrigin range )

◆ equalizeTriAreas()

bool meshlib.mrmeshpy.equalizeTriAreas	(	Mesh	mesh,
		MeshEqualizeTriAreasParams	params = 'MR::MeshEqualizeTriAreasParams{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

applies given number of iterations with movement toward vertexPosEqualNeiAreas() to the whole mesh ( or some region if it is specified )
\\return true if the operation completed successfully, and false if it was interrupted by the progress callback.

◆ erodeRegion() [1/4]

bool meshlib.mrmeshpy.erodeRegion	(	Mesh	mesh,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

shrinks the region (of faces or vertices) on given value (in meters). returns false if callback also returns false

◆ erodeRegion() [2/4]

bool meshlib.mrmeshpy.erodeRegion	(	Mesh	mesh,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ erodeRegion() [3/4]

bool meshlib.mrmeshpy.erodeRegion	(	Mesh	mesh,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ erodeRegion() [4/4]

bool meshlib.mrmeshpy.erodeRegion	(	PointCloud	pointCloud,
		VertBitSet	region,
		float	erosion,
		func_bool_from_float	cb = 'MR::ProgressCallback{}',
		AffineXf3f	xf = None )

shrinks the region on given euclidian distance. returns false if callback also returns false

◆ erodeRegionByMetric() [1/3]

bool meshlib.mrmeshpy.erodeRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

shrinks the region (of faces or vertices) on given metric value. returns false if callback also returns false

◆ erodeRegionByMetric() [2/3]

bool meshlib.mrmeshpy.erodeRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ erodeRegionByMetric() [3/3]

bool meshlib.mrmeshpy.erodeRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ evalGridMinMax()

None meshlib.mrmeshpy.evalGridMinMax	(	OpenVdbFloatGrid	grid,
		float_output	min,
		float_output	max )

eval min max value from FloatGrid

◆ executeHoleFillPlan()

None meshlib.mrmeshpy.executeHoleFillPlan	(	Mesh	mesh,
		Id_EdgeTag	a0,
		HoleFillPlan	plan,
		FaceBitSet	outNewFaces = None )

quickly triangulates the face or hole to the left of (e) given the plan (quickly compared to fillHole function)

◆ expand() [1/4]

None meshlib.mrmeshpy.expand	(	MeshTopology	topology,
		FaceBitSet	region,
		int	hops = 1 )

adds to the region all faces within given number of hops (stars) from the initial region boundary

◆ expand() [2/4]

FaceBitSet meshlib.mrmeshpy.expand	(	MeshTopology	topology,
		FaceId	f,
		int	hops )

returns the region of all faces within given number of hops (stars) from the initial face

◆ expand() [3/4]

None meshlib.mrmeshpy.expand	(	MeshTopology	topology,
		VertBitSet	region,
		int	hops = 1 )

adds to the region all vertices within given number of hops (stars) from the initial region boundary

◆ expand() [4/4]

VertBitSet meshlib.mrmeshpy.expand	(	MeshTopology	topology,
		VertId	v,
		int	hops )

returns the region of all vertices within given number of hops (stars) from the initial vertex

◆ expandFaces()

FaceBitSet meshlib.mrmeshpy.expandFaces	(	MeshTopology	topology,
		FaceBitSet	region,
		UndirectedEdgeBitSet	stopEdges = None )

returns given region with all faces sharing an edge with a region face;
\\param stopEdges - neighborhood via this edges will be ignored

◆ expandPixelMask()

None meshlib.mrmeshpy.expandPixelMask	(	PixelBitSet	mask,
		RectIndexer	indexer,
		int	expansion = 1 )

expands PixelBitSet with given number of steps

◆ expandVoxelsMask()

None meshlib.mrmeshpy.expandVoxelsMask	(	VoxelBitSet	mask,
		VolumeIndexer	indexer,
		int	expansion = 1 )

expands VoxelBitSet with given number of steps

◆ exportToolPathToGCode()

ObjectGcode meshlib.mrmeshpy.exportToolPathToGCode ( std_vector_GCommand commands )

generates G-Code for milling tool

◆ extendAllHoles()

std_vector_Id_EdgeTag meshlib.mrmeshpy.extendAllHoles	(	Mesh	mesh,
		Plane3f	plane,
		FaceBitSet	outNewFaces = None )

adds cylindrical extension of too all holes of the mesh by calling extendHole(...);
\\return representative edges of one per every hole after extension

◆ extendHole() [1/2]

Id_EdgeTag meshlib.mrmeshpy.extendHole	(	Mesh	mesh,
		Id_EdgeTag	a,
		func_Vector3_float_from_Vector3_float	getVertPos,
		FaceBitSet	outNewFaces = None )

adds extension of given hole represented by one of its edges (having no valid left face)
by adding new vertices located at getVertPos( existing vertex position );
\\return the edge of new hole opposite to input edge (a)

◆ extendHole() [2/2]

Id_EdgeTag meshlib.mrmeshpy.extendHole	(	Mesh	mesh,
		Id_EdgeTag	a,
		Plane3f	plane,
		FaceBitSet	outNewFaces = None )

adds cylindrical extension of given hole represented by one of its edges (having no valid left face)
by adding new vertices located in given plane and 2 * number_of_hole_edge triangles;
\\return the edge of new hole opposite to input edge (a)

◆ extractClosedLoops() [1/2]

std_vector_std_vector_Id_EdgeTag meshlib.mrmeshpy.extractClosedLoops	(	MeshTopology	topology,
		EdgeBitSet	edges )

finds all closed loops from given edges and removes them from edges

◆ extractClosedLoops() [2/2]

std_vector_std_vector_Id_EdgeTag meshlib.mrmeshpy.extractClosedLoops	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	inEdges,
		EdgeBitSet	outNotLoopEdges = None )

◆ extractIntersectionContours()

std_vector_std_vector_Vector3_float meshlib.mrmeshpy.extractIntersectionContours	(	Mesh	meshA,
		Mesh	meshB,
		std_vector_std_vector_VariableEdgeTri	orientedContours,
		CoordinateConverters	converters,
		AffineXf3f	rigidB2A = None )

extracts coordinates from two meshes intersection contours

◆ extractIsolines() [1/2]

std_vector_std_vector_EdgePoint meshlib.mrmeshpy.extractIsolines	(	MeshTopology	topology,
		func_float_from_Id_VertTag	vertValues,
		FaceBitSet	region = None )

extracts all iso-lines from given scalar field and iso-value=0

◆ extractIsolines() [2/2]

std_vector_std_vector_EdgePoint meshlib.mrmeshpy.extractIsolines	(	MeshTopology	topology,
		VertScalars	vertValues,
		float	isoValue,
		FaceBitSet	region = None )

extracts all iso-lines from given scalar field and iso-value

◆ extractLongestClosedLoop()

std_vector_Id_EdgeTag meshlib.mrmeshpy.extractLongestClosedLoop	(	Mesh	mesh,
		std_vector_Id_EdgeTag	inEdges )

◆ extractPlaneSections()

std_vector_std_vector_EdgePoint meshlib.mrmeshpy.extractPlaneSections	(	MeshPart	mp,
		Plane3f	plane )

extracts all plane sections of given mesh

◆ extractSectionsFromPolyline()

std_vector_EdgeSegment meshlib.mrmeshpy.extractSectionsFromPolyline	(	Polyline3	polyline,
		Plane3f	plane,
		float	eps )

This function cuts polyline with a plane
\\return Edge segments tha are closer to the plane than \\param eps
\\param polyline Input polyline that will be cut by the plane
\\param plane Input plane to cut polyline with
\\param eps Maximal distance from the plane

◆ extractXYPlaneSections()

std_vector_std_vector_EdgePoint meshlib.mrmeshpy.extractXYPlaneSections	(	MeshPart	mp,
		float	zLevel )

extracts all sections of given mesh with the plane z=zLevel;
this function works faster than general extractPlaneSections(...) for the same plane
if the sections cross relatively small number of mesh triangles and AABB tree has already been constructed

◆ faceMapsComposition()

FaceMap meshlib.mrmeshpy.faceMapsComposition	(	FaceMap	a2b,
		FaceMap	b2c )

updates a2b map to a2c map using b2c map

returns map a2c from a2b and b2c maps

◆ fillContourLeft() [1/2]

FaceBitSet meshlib.mrmeshpy.fillContourLeft	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	contour )

fill region located to the left from given edges

◆ fillContourLeft() [2/2]

FaceBitSet meshlib.mrmeshpy.fillContourLeft	(	MeshTopology	topology,
		std_vector_std_vector_Id_EdgeTag	contours )

◆ fillContourLeftByGraphCut() [1/2]

FaceBitSet meshlib.mrmeshpy.fillContourLeftByGraphCut	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	contour,
		func_float_from_Id_EdgeTag	metric )

 \\brief Fills region located to the left from given contour, by minimizing the sum of metric over the boundary
 \\ingroup MeshSegmentationGroup

◆ fillContourLeftByGraphCut() [2/2]

FaceBitSet meshlib.mrmeshpy.fillContourLeftByGraphCut	(	MeshTopology	topology,
		std_vector_std_vector_Id_EdgeTag	contours,
		func_float_from_Id_EdgeTag	metric )

 \\brief Fills region located to the left from given contours, by minimizing the sum of metric over the boundary
 \\ingroup MeshSegmentationGroup

◆ fillContours2D()

None meshlib.mrmeshpy.fillContours2D	(	Mesh	mesh,
		std_vector_Id_EdgeTag	holeRepresentativeEdges )

 @brief fill holes with border in same plane (i.e. after cut by plane)
 @param mesh - mesh with holes
 @param holeRepresentativeEdges - each edge here represents a hole borders that should be filled
 should be not empty
 edges should have invalid left face (FaceId == -1)
 @return Expected with has_value()=true if holes filled, otherwise - string error

◆ fillHole()

None meshlib.mrmeshpy.fillHole	(	Mesh	mesh,
		Id_EdgeTag	a,
		FillHoleParams	params = 'MR::FillHoleParams{}' )

\\brief Fills hole in mesh\\n

Fills given hole represented by one of its edges (having no valid left face),\\n
uses fillHoleTrivially if cannot fill hole without multiple edges,\\n
default metric: CircumscribedFillMetric

\\image html fill/before_fill.png "Before" width = 250cm
\\image html fill/fill.png "After" width = 250cm

Next picture show, how newly generated faces can be smoothed
\\ref MR::positionVertsSmoothly
\\ref MR::subdivideMesh
\\image html fill/fill_smooth.png "Fill with smooth" width = 250cm

\\param mesh mesh with hole
\\param a EdgeId which represents hole (should not have valid left FaceId)
\\param params parameters of hole filling

\\sa \\ref buildCylinderBetweenTwoHoles
\\sa \\ref fillHoleTrivially
\\sa \\ref FillHoleParams

◆ fillHoleNicely()

FaceBitSet meshlib.mrmeshpy.fillHoleNicely	(	Mesh	mesh,
		Id_EdgeTag	holeEdge,
		FillHoleNicelySettings	settings )

fills a hole in mesh specified by one of its edge,
optionally subdivides new patch on smaller triangles,
optionally make smooth connection with existing triangles outside the hole
\\return triangles of the patch

◆ fillHoles()

None meshlib.mrmeshpy.fillHoles	(	Mesh	mesh,
		std_vector_Id_EdgeTag	as_,
		FillHoleParams	params = 'MR::FillHoleParams{}' )

fill all holes given by their representative edges in \\param as

◆ fillHoleTrivially()

VertId meshlib.mrmeshpy.fillHoleTrivially	(	Mesh	mesh,
		Id_EdgeTag	a,
		FaceBitSet	outNewFaces = None )

\\brief Triangulates face of hole in mesh trivially\\n
\\ingroup FillHoleGroup

Fills given hole represented by one of its edges (having no valid left face)\\n
by creating one new vertex in the centroid of boundary vertices and connecting new vertex with all boundary vertices.

\\image html fill/before_fill.png "Before" width = 250cm
\\image html fill/fill_triv.png "After" width = 250cm

Next picture show, how newly generated faces can be smoothed
\\ref MR::positionVertsSmoothly
\\ref MR::subdivideMesh
\\image html fill/fill_triv_smooth.png "Trivial fill with smooth" width = 250cm

\\param mesh mesh with hole
\\param a EdgeId points on the face or hole to the left that will be triangulated
\\param outNewFaces optional output newly generated faces
\\return new vertex

\\sa \\ref fillHole

◆ filterCreaseEdges()

None meshlib.mrmeshpy.filterCreaseEdges	(	Mesh	mesh,
		UndirectedEdgeBitSet	creaseEdges,
		float	critLength,
		bool	filterComponents = True,
		bool	filterBranches = False )

filters given edges using the following criteria:
if \\param filterComponents is true then connected components with summary length of their edges less than \\param critLength will be excluded
if \\param filterBranches is true then branches shorter than \\param critLength will be excluded

◆ filterHistoryActionsVector()

tuple[bool, int] meshlib.mrmeshpy.filterHistoryActionsVector	(	std_vector_std_shared_ptr_HistoryAction	historyVector,
		func_bool_from_std_shared_ptr_HistoryAction	filteringCondition,
		int	firstRedoIndex = 0,
		bool	deepFiltering = True )

 \\brief Remove actions from history actions vector that match the condition
 \\param firstRedoIndex - set redo index for calculate how many actions removed before it
 \\param deepFiltering - filter actions into combined actions
 \\return pair (anything removed, how many removed before firstRedoIndex)

◆ findAlphaShapeAllTriangles()

Triangulation meshlib.mrmeshpy.findAlphaShapeAllTriangles	(	PointCloud	cloud,
		float	radius )

find all triangles of alpha-shape with negative alpha = -1/radius

◆ findAlphaShapeNeiTriangles()

None meshlib.mrmeshpy.findAlphaShapeNeiTriangles	(	PointCloud	cloud,
		VertId	v,
		float	radius,
		Triangulation	appendTris,
		std_vector_Id_VertTag	neis,
		bool	onlyLargerVids )

find all triangles of alpha-shape with negative alpha = -1/radius,
where each triangle contains point #v and two other points

◆ findAvgPointsRadius()

float meshlib.mrmeshpy.findAvgPointsRadius	(	PointCloud	pointCloud,
		int	avgPoints,
		int	samples = 1024 )

\\brief Finds the radius of ball, so on average that ball contained avgPoints excluding the central point
\\param samples the number of test points to find given number of samples in each
\\ingroup PointCloudGroup

◆ findBestFreeformDeformation()

std_vector_Vector3_float meshlib.mrmeshpy.findBestFreeformDeformation	(	Box3f	box,
		std_vector_Vector3_float	source,
		std_vector_Vector3_float	target,
		Vector3i	resolution = 'Vector3i::diagonal(2)',
		AffineXf3f	samplesToBox = None )

Calculates best Free Form transform to fit given source->target deformation
origin ref grid as box corners ( resolution parameter specifies how to divide box )
samplesToBox - if set used to transform source and target points to box space
returns new positions of ref grid

◆ findCloseVertices() [1/4]

VertBitSet meshlib.mrmeshpy.findCloseVertices	(	Mesh	mesh,
		float	closeDist,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

finds all close vertices, where for each vertex there is another one located within given distance

◆ findCloseVertices() [2/4]

VertBitSet meshlib.mrmeshpy.findCloseVertices	(	PointCloud	cloud,
		float	closeDist,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

finds all close vertices, where for each vertex there is another one located within given distance

◆ findCloseVertices() [3/4]

VertBitSet meshlib.mrmeshpy.findCloseVertices	(	VertCoords	points,
		float	closeDist,
		VertBitSet	valid = None,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

finds all close vertices, where for each vertex there is another one located within given distance

◆ findCloseVertices() [4/4]

VertBitSet meshlib.mrmeshpy.findCloseVertices ( VertMap smallestMap )

finds all close vertices, where for each vertex there is another one located within given distance; smallestMap is the result of findSmallestCloseVertices function call

◆ findCollidingEdgePairs()

std_vector_EdgePointPair meshlib.mrmeshpy.findCollidingEdgePairs	(	Polyline2	a,
		Polyline2	b,
		AffineXf2f	rigidB2A = None,
		bool	firstIntersectionOnly = False )

 \\brief finds all pairs of colliding edges from two 2d polylines
 \\param rigidB2A rigid transformation from B-polyline space to A polyline space, nullptr considered as identity transformation
 \\param firstIntersectionOnly if true then the function returns at most one pair of intersecting edges and returns faster

◆ findCollidingEdges()

std_vector_UndirectedEdgeUndirectedEdge meshlib.mrmeshpy.findCollidingEdges	(	Polyline2	a,
		Polyline2	b,
		AffineXf2f	rigidB2A = None,
		bool	firstIntersectionOnly = False )

 \\brief finds all pairs of colliding edges from two 2d polylines
 \\param rigidB2A rigid transformation from B-polyline space to A polyline space, nullptr considered as identity transformation
 \\param firstIntersectionOnly if true then the function returns at most one pair of intersecting edges and returns faster

◆ findCollidingEdgesBitsets()

tuple[UndirectedEdgeBitSet, UndirectedEdgeBitSet] meshlib.mrmeshpy.findCollidingEdgesBitsets	(	Polyline2	a,
		Polyline2	b,
		AffineXf2f	rigidB2A = None )

 \\brief finds bitset per polyline with colliding edges
 \\param rigidB2A rigid transformation from B-polyline space to A polyline space, nullptr considered as identity transformation

◆ findCollidingEdgeTrisPrecise() [1/3]

std_vector_EdgeTri meshlib.mrmeshpy.findCollidingEdgeTrisPrecise	(	Mesh	a,
		std_vector_Id_EdgeTag	edgesA,
		Mesh	b,
		std_vector_Id_FaceTag	facesB,
		func_Vector3_int_from_Vector3_float	conv,
		AffineXf3f	rigidB2A = None )

finds all intersections between every given edge from A and given triangles from B

◆ findCollidingEdgeTrisPrecise() [2/3]

std_vector_EdgeTri meshlib.mrmeshpy.findCollidingEdgeTrisPrecise	(	Mesh	a,
		std_vector_Id_FaceTag	facesA,
		Mesh	b,
		std_vector_Id_EdgeTag	edgesB,
		func_Vector3_int_from_Vector3_float	conv,
		AffineXf3f	rigidB2A = None )

finds all intersections between every given triangle from A and given edge from B

◆ findCollidingEdgeTrisPrecise() [3/3]

PreciseCollisionResult meshlib.mrmeshpy.findCollidingEdgeTrisPrecise	(	MeshPart	a,
		MeshPart	b,
		func_Vector3_int_from_Vector3_float	conv,
		AffineXf3f	rigidB2A = None,
		bool	anyIntersection = False )

 \\brief finds all pairs of colliding edges from one mesh and triangle from another mesh
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
 \\param anyIntersection if true then the function returns as fast as it finds any intersection

◆ findCollidingTriangleBitsets()

tuple[FaceBitSet, FaceBitSet] meshlib.mrmeshpy.findCollidingTriangleBitsets	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None )

the same as \\ref findCollidingTriangles, but returns one bite set per mesh with colliding triangles

◆ findCollidingTriangles()

std_vector_FaceFace meshlib.mrmeshpy.findCollidingTriangles	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None,
		bool	firstIntersectionOnly = False )

 \\brief finds all pairs of colliding triangles from two meshes or two mesh regions
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
 \\param firstIntersectionOnly if true then the function returns at most one pair of intersecting triangles and returns faster

◆ findDegenerateFaces()

FaceBitSet meshlib.mrmeshpy.findDegenerateFaces	(	MeshPart	mp,
		float	criticalAspectRatio = 3.4028234663852886e+38,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

finds faces having aspect ratio >= criticalAspectRatio

◆ findDirMax()

VertId meshlib.mrmeshpy.findDirMax	(	Vector3f	dir,
		MeshPart	mp,
		UseAABBTree	u = 'UseAABBTree::Yes' )

finds the vertex in the mesh part having the largest projection on given direction,
uses aabb-tree inside for faster computation
\\ingroup AABBTreeGroup

◆ findDistance()

MeshMeshDistanceResult meshlib.mrmeshpy.findDistance	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None,
		float	upDistLimitSq = 3.4028234663852886e+38 )

 \\brief computes minimal distance between two meshes or two mesh regions
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exists returning upDistLimitSq and no valid points

◆ findEdgesInBall() [1/2]

None meshlib.mrmeshpy.findEdgesInBall	(	Polyline2	polyline,
		Vector2f	center,
		float	radius,
		func_void_from_Id_UndirectedEdgeTag_Vector2_float_float	foundCallback,
		AffineXf2f	xf = None )

Finds all edges of given polyline that cross or touch given ball (center, radius)

◆ findEdgesInBall() [2/2]

None meshlib.mrmeshpy.findEdgesInBall	(	Polyline3	polyline,
		Vector3f	center,
		float	radius,
		func_void_from_Id_UndirectedEdgeTag_Vector3_float_float	foundCallback,
		AffineXf3f	xf = None )

Finds all edges of given polyline that cross or touch given ball (center, radius)

◆ findExtremeEdges()

UndirectedEdgeBitSet meshlib.mrmeshpy.findExtremeEdges	(	Mesh	mesh,
		VertScalars	field,
		ExtremeEdgeType	type )

computes all edges in the mesh, where the field not-increases both in left and right triangles

◆ findFewClosestPoints()

None meshlib.mrmeshpy.findFewClosestPoints	(	Vector3f	pt,
		PointCloud	pc,
		FewSmallest_PointsProjectionResult	res,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0 )

 \\brief finds a number of the closest points in the cloud (as configured in \\param res) to given point
 \\param upDistLimitSq upper limit on the distance in question, points with larger distance than it will not be returned
 \\param xf pointcloud-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, the algorithm can return given number of points within this distance even skipping closer ones

◆ findFilter()

IOFilter meshlib.mrmeshpy.findFilter	(	std_vector_IOFilter	filters,
		str	extension )

find a corresponding filter for a given extension

◆ findHalfSpacePoints()

VertBitSet meshlib.mrmeshpy.findHalfSpacePoints	(	PointCloud	pc,
		Plane3f	plane )

\\return All vertices on the positive side of the plane
\\param pc Input point cloud that will be cut by the plane
\\param plane Input plane to cut point cloud with

◆ findHoleComplicatingFaces()

FaceBitSet meshlib.mrmeshpy.findHoleComplicatingFaces ( Mesh mesh )

returns all faces that complicate one of mesh holes;
hole is complicated if it passes via one vertex more than once;
deleting such faces simplifies the holes and makes them easier to fill

◆ findInnerShellFacesWithSplits()

FaceBitSet meshlib.mrmeshpy.findInnerShellFacesWithSplits	(	MeshPart	mp,
		Mesh	shell,
		FindInnerShellSettings	settings = 'MR::FindInnerShellSettings{}' )

Finds inner-shell faces on bidirectional \\param shell constructed for an open \\param mp;
The function will return all shell faces (after some subdivision) that have distance to mesh of same sign as settings.side

◆ findInnerShellVerts()

VertBitSet meshlib.mrmeshpy.findInnerShellVerts	(	MeshPart	mp,
		Mesh	shell,
		FindInnerShellSettings	settings = 'MR::FindInnerShellSettings{}' )

Finds inner-shell vertices on bidirectional \\param shell constructed for an open \\param mp;
The function will return all shell vertices that have distance to mesh of same sign as settings.side

◆ findInSphere() [1/2]

InSphere meshlib.mrmeshpy.findInSphere	(	Mesh	mesh,
		MeshPoint	m,
		InSphereSearchSettings	settings )

finds maximal sphere inscribed in the mesh touching point (p) with center along the normal at (p)

◆ findInSphere() [2/2]

InSphere meshlib.mrmeshpy.findInSphere	(	Mesh	mesh,
		VertId	v,
		InSphereSearchSettings	settings )

◆ findIntersectionContours()

std_vector_std_vector_Vector3_float meshlib.mrmeshpy.findIntersectionContours	(	Mesh	meshA,
		Mesh	meshB,
		AffineXf3f	rigidB2A = None )

returns intersection contours of given meshes

◆ findLeftBoundary()

std_vector_std_vector_Id_EdgeTag meshlib.mrmeshpy.findLeftBoundary	(	MeshTopology	topology,
		FaceBitSet	region = None )

returns all region boundary loops;
every loop has region faces on the left, and not-region faces or holes on the right

◆ findLeftBoundaryInsideMesh()

std_vector_std_vector_Id_EdgeTag meshlib.mrmeshpy.findLeftBoundaryInsideMesh	(	MeshTopology	topology,
		FaceBitSet	region )

returns all region boundary paths;
every path has region faces on the left, and valid not-region faces on the right

◆ findMaxDistanceSq() [1/2]

float meshlib.mrmeshpy.findMaxDistanceSq	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None,
		float	maxDistanceSq = 3.4028234663852886e+38 )

 \\brief returns the squared Hausdorff distance between two meshes, that is
          the maximum of squared distances from each mesh vertex to the other mesh (in both directions)
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
 \\param maxDistanceSq upper limit on the positive distance in question, if the real distance is larger than the function exists returning maxDistanceSq

◆ findMaxDistanceSq() [2/2]

float meshlib.mrmeshpy.findMaxDistanceSq	(	PointCloud	a,
		PointCloud	b,
		AffineXf3f	rigidB2A = None,
		float	maxDistanceSq = 3.4028234663852886e+38 )

 \\brief returns the squared Hausdorff distance between two point clouds, that is
          the maximum of squared distances from each point to the other cloud (in both directions)
 \\param rigidB2A rigid transformation from B-cloud space to A-cloud space, nullptr considered as identity transformation
 \\param maxDistanceSq upper limit on the positive distance in question, if the real distance is larger than the function exists returning maxDistanceSq

◆ findMaxDistanceSqOneWay() [1/2]

float meshlib.mrmeshpy.findMaxDistanceSqOneWay	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None,
		float	maxDistanceSq = 3.4028234663852886e+38 )

 \\brief returns the maximum of the squared distances from each B-mesh vertex to A-mesh
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
 \\param maxDistanceSq upper limit on the positive distance in question, if the real distance is larger than the function exists returning maxDistanceSq

◆ findMaxDistanceSqOneWay() [2/2]

float meshlib.mrmeshpy.findMaxDistanceSqOneWay	(	PointCloud	a,
		PointCloud	b,
		AffineXf3f	rigidB2A = None,
		float	maxDistanceSq = 3.4028234663852886e+38 )

 \\brief returns the maximum of the squared distances from each B-point to A-cloud
 \\param rigidB2A rigid transformation from B-cloud space to A-cloud space, nullptr considered as identity transformation
 \\param maxDistanceSq upper limit on the positive distance in question, if the real distance is larger than the function exists returning maxDistanceSq

◆ findMaxVectorDim() [1/2]

None meshlib.mrmeshpy.findMaxVectorDim	(	int_output	dimX,
		int_output	dimY,
		int_output	dimZ,
		Vector3d	dir )

 \\brief finds index of maximum axis and stores it into dimZ
 \\details http://jcgt.org/published/0002/01/05/paper.pdf
 Example input: dir = (1,1,-2). Result: dimZ = 2, dimX = 1, dimY = 0.
 \\param[out] dimX are filled by right-hand rule from dimZ
 \\param[out] dimY are filled by right-hand rule from dimZ
 \\param[out] dimZ index of maximum axis

◆ findMaxVectorDim() [2/2]

None meshlib.mrmeshpy.findMaxVectorDim	(	int_output	dimX,
		int_output	dimY,
		int_output	dimZ,
		Vector3f	dir )

 \\brief finds index of maximum axis and stores it into dimZ
 \\details http://jcgt.org/published/0002/01/05/paper.pdf
 Example input: dir = (1,1,-2). Result: dimZ = 2, dimX = 1, dimY = 0.
 \\param[out] dimX are filled by right-hand rule from dimZ
 \\param[out] dimY are filled by right-hand rule from dimZ
 \\param[out] dimZ index of maximum axis

◆ findMeshEdgesInBall()

None meshlib.mrmeshpy.findMeshEdgesInBall	(	Mesh	mesh,
		AABBTreePolyline3	tree,
		Vector3f	center,
		float	radius,
		func_void_from_Id_UndirectedEdgeTag_Vector3_float_float	foundCallback,
		AffineXf3f	xf = None )

Finds all edges of given mesh edges (specified by the tree) that cross or touch given ball (center, radius)

◆ findMultipleEdges()

std_vector_std_pair_Id_VertTag_Id_VertTag meshlib.mrmeshpy.findMultipleEdges	(	MeshTopology	topology,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

◆ findNClosestPointsPerPoint()

Buffer_VertId meshlib.mrmeshpy.findNClosestPointsPerPoint	(	PointCloud	pc,
		int	numNei,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

 \\brief finds given number of closest points (excluding itself) to each valid point in the cloud;
 \\param numNei the number of closest points to find for each point
 \\return a buffer where for every valid point with index `i` its neighbours are stored at indices [i*numNei; (i+1)*numNei)

◆ findNeighborVerts()

VertBitSet meshlib.mrmeshpy.findNeighborVerts	(	Mesh	mesh,
		PointOnFace	start,
		float	range )

calculates all neighbor vertices within a given \\param range
and to first vertices with the distance more or equal than range

◆ findNRingVerts()

VertBitSet meshlib.mrmeshpy.findNRingVerts	(	MeshTopology	topology,
		int	n,
		VertBitSet	region = None )

finds vertices in region with complete ring of N edges

◆ findOverhangs()

std_vector_TaggedBitSet_FaceTag meshlib.mrmeshpy.findOverhangs	(	Mesh	mesh,
		FindOverhangsSettings	settings )

\\brief Find face regions that might create overhangs
\\param mesh - source mesh
\\param settings - parameters
\\return face regions

◆ findOverlappingTris()

FaceBitSet meshlib.mrmeshpy.findOverlappingTris	(	MeshPart	mp,
		FindOverlappingSettings	settings )

finds all triangles that have oppositely oriented close triangle in the mesh

◆ findPointsInBall() [1/3]

None meshlib.mrmeshpy.findPointsInBall	(	AABBTreePoints	tree,
		Vector3f	center,
		float	radius,
		func_void_from_Id_VertTag_Vector3_float	foundCallback,
		AffineXf3f	xf = None )

Finds all points in tree that are inside or on the surface of given ball (center, radius)
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

◆ findPointsInBall() [2/3]

None meshlib.mrmeshpy.findPointsInBall	(	Mesh	mesh,
		Vector3f	center,
		float	radius,
		func_void_from_Id_VertTag_Vector3_float	foundCallback,
		AffineXf3f	xf = None )

Finds all valid vertices of the mesh that are inside or on the surface of given ball (center, radius)
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

◆ findPointsInBall() [3/3]

None meshlib.mrmeshpy.findPointsInBall	(	PointCloud	pointCloud,
		Vector3f	center,
		float	radius,
		func_void_from_Id_VertTag_Vector3_float	foundCallback,
		AffineXf3f	xf = None )

Finds all valid points of pointCloud that are inside or on the surface of given ball (center, radius)
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

◆ findProjection()

MeshProjectionResult meshlib.mrmeshpy.findProjection	(	Vector3f	pt,
		MeshPart	mp,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0,
		func_bool_from_Id_FaceTag	validFaces = 'MR::FacePredicate{}',
		func_bool_from_MeshProjectionResult	validProjections = 'std::function<bool (const MR::MeshProjectionResult &)>{}' )

 \\brief computes the closest point on mesh (or its region) to given point
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exits returning upDistLimitSq and no valid point
 \\param xf mesh-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one
 \\param validFaces if provided then only faces from there will be considered as projections
 \\param validProjections if provided then only projections passed this test can be returned

◆ findProjectionOnMeshEdges() [1/2]

PolylineProjectionResult3 meshlib.mrmeshpy.findProjectionOnMeshEdges	(	Line3f	ln,
		Mesh	mesh,
		AABBTreePolyline3	tree,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0 )

 \\brief computes the closest point on the mesh edges (specified by the tree) to given straight line
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exists returning upDistLimitSq and no valid point
 \\param xf polyline-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one

◆ findProjectionOnMeshEdges() [2/2]

PolylineProjectionResult3 meshlib.mrmeshpy.findProjectionOnMeshEdges	(	Vector3f	pt,
		Mesh	mesh,
		AABBTreePolyline3	tree,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0 )

 \\brief computes the closest point on the mesh edges (specified by the tree) to given point
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exists returning upDistLimitSq and no valid point
 \\param xf polyline-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one

◆ findProjectionOnPoints()

PointsProjectionResult meshlib.mrmeshpy.findProjectionOnPoints	(	Vector3f	pt,
		PointCloud	pc,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0,
		func_bool_from_Id_VertTag	skipCb = 'MR::VertPredicate{}' )

 \\brief computes the closest point on point cloud to given point
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exits returning upDistLimitSq and no valid point
 \\param xf pointcloud-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one
 \\param skipCb callback to discard VertId projection candidate

◆ findProjectionOnPolyline() [1/2]

PolylineProjectionResult3 meshlib.mrmeshpy.findProjectionOnPolyline	(	Line3f	ln,
		Polyline3	polyline,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0 )

 \\brief computes the closest point on polyline to given straight line
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exists returning upDistLimitSq and no valid point
 \\param xf polyline-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one

◆ findProjectionOnPolyline() [2/2]

PolylineProjectionResult3 meshlib.mrmeshpy.findProjectionOnPolyline	(	Vector3f	pt,
		Polyline3	polyline,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0 )

 \\brief computes the closest point on polyline to given point
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exists returning upDistLimitSq and no valid point
 \\param xf polyline-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one

◆ findProjectionOnPolyline2()

PolylineProjectionResult2 meshlib.mrmeshpy.findProjectionOnPolyline2	(	Vector2f	pt,
		Polyline2	polyline,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf2f	xf = None,
		float	loDistLimitSq = 0 )

 \\brief computes the closest point on polyline to given point
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exists returning upDistLimitSq and no valid point
 \\param xf polyline-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one

◆ findProjectionOnPolyline2WithOffset()

Polyline2ProjectionWithOffsetResult meshlib.mrmeshpy.findProjectionOnPolyline2WithOffset	(	Vector2f	pt,
		Polyline2	polyline,
		UndirectedEdgeScalars	offsetPerEdge,
		float	upDistLimit = 3.4028234663852886e+38,
		AffineXf2f	xf = None,
		float	loDistLimit = 0 )

 \\brief computes the closest point on polyline to given point, respecting each edge offset
 \\param offsetPerEdge offset for each edge of polyline
 \\param upDistLimit upper limit on the distance in question, if the real distance is larger than the function exists returning upDistLimit and no valid point
 \\param xf polyline-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimit low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one

◆ findProjectionOnPolylineWithOffset()

PolylineProjectionWithOffsetResult3 meshlib.mrmeshpy.findProjectionOnPolylineWithOffset	(	Vector3f	pt,
		Polyline3	polyline,
		UndirectedEdgeScalars	offsetPerEdge,
		float	upDistLimit = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimit = 0 )

 \\brief computes the closest point on polyline to given point, respecting each edge offset
 \\param offsetPerEdge offset for each edge of polyline
 \\param upDistLimit upper limit on the distance in question, if the real distance is larger than the function exists returning upDistLimit and no valid point
 \\param xf polyline-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimit low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one

◆ findProjectionSubtree()

MeshProjectionResult meshlib.mrmeshpy.findProjectionSubtree	(	Vector3f	pt,
		MeshPart	mp,
		AABBTree	tree,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0,
		func_bool_from_Id_FaceTag	validFaces = 'MR::FacePredicate{}',
		func_bool_from_MeshProjectionResult	validProjections = 'std::function<bool (const MR::MeshProjectionResult &)>{}' )

 \\brief computes the closest point on mesh (or its region) to given point
 \\param tree explicitly given BVH-tree for whole mesh or part of mesh we are searching projection on,
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger than the function exits returning upDistLimitSq and no valid point
 \\param xf mesh-to-point transformation, if not specified then identity transformation is assumed
 \\param loDistLimitSq low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one
 \\param validFaces if provided then only faces from there will be considered as projections
 \\param validProjections if provided then only projections passed this test can be returned

◆ findRegionBoundaryUndirectedEdgesInsideMesh()

UndirectedEdgeBitSet meshlib.mrmeshpy.findRegionBoundaryUndirectedEdgesInsideMesh	(	MeshTopology	topology,
		FaceBitSet	region )

returns all region boundary edges, where each edge has a region face on one side, and a valid not-region face on another side

◆ findRegionOuterFaces()

FaceBitSet meshlib.mrmeshpy.findRegionOuterFaces	(	MeshTopology	topology,
		FaceBitSet	region )

\\returns All out of region faces that have a common edge with at least one region face

◆ findRepeatedOrientedTriangles() [1/2]

Triangulation meshlib.mrmeshpy.findRepeatedOrientedTriangles	(	AllLocalTriangulations	triangs,
		int	repetitions )

from local triangulations returns all oriented triangles with given number of repetitions each in [1,3]

◆ findRepeatedOrientedTriangles() [2/2]

None meshlib.mrmeshpy.findRepeatedOrientedTriangles	(	AllLocalTriangulations	triangs,
		Triangulation	outRep3,
		Triangulation	outRep2 )

from local triangulations returns all oriented triangles with 3 or 2 repetitions each;
if both outRep3 and outRep2 are necessary then it is faster to call this function than above one

◆ findRepeatedUnorientedTriangles()

std_vector_UnorientedTriangle meshlib.mrmeshpy.findRepeatedUnorientedTriangles	(	AllLocalTriangulations	triangs,
		int	repetitions )

from local triangulations returns all unoriented triangles with given number of repetitions each in [1,3]

◆ findRepeatedVertsOnHoleBd()

VertBitSet meshlib.mrmeshpy.findRepeatedVertsOnHoleBd ( MeshTopology topology )

returns set bits for all vertices present on the boundary of a hole several times;

◆ findRightBoundary()

std_vector_std_vector_Id_EdgeTag meshlib.mrmeshpy.findRightBoundary	(	MeshTopology	topology,
		FaceBitSet	region = None )

returns all region boundary loops;
every loop has region faces on the right, and not-region faces or holes on the left

◆ findSegmentSegmentIntersectionPrecise() [1/2]

Vector2f meshlib.mrmeshpy.findSegmentSegmentIntersectionPrecise	(	Vector2f	a,
		Vector2f	b,
		Vector2f	c,
		Vector2f	d,
		CoordinateConverters2	converters )

finds intersection precise, using high precision int inside
this function input should have intersection

◆ findSegmentSegmentIntersectionPrecise() [2/2]

Vector2i meshlib.mrmeshpy.findSegmentSegmentIntersectionPrecise	(	Vector2i	a,
		Vector2i	b,
		Vector2i	c,
		Vector2i	d )

finds intersection precise, using high precision int inside
this function input should have intersection

◆ findSelfCollidingEdgePairs()

std_vector_EdgePointPair meshlib.mrmeshpy.findSelfCollidingEdgePairs ( Polyline2 polyline )

finds all pairs of colliding edges from 2d polyline

◆ findSelfCollidingEdges()

std_vector_UndirectedEdgeUndirectedEdge meshlib.mrmeshpy.findSelfCollidingEdges ( Polyline2 polyline )

finds all pairs of colliding edges from 2d polyline

◆ findSelfCollidingEdgesBS()

UndirectedEdgeBitSet meshlib.mrmeshpy.findSelfCollidingEdgesBS ( Polyline2 polyline )

finds the union of all self-intersecting edges

◆ findSelfCollidingTriangles() [1/2]

std_vector_FaceFace meshlib.mrmeshpy.findSelfCollidingTriangles	(	MeshPart	mp,
		func_bool_from_float	cb = 'MR::ProgressCallback{}',
		Face2RegionMap	regionMap = None )

finds all pairs of colliding triangles from one mesh or a region

◆ findSelfCollidingTriangles() [2/2]

bool meshlib.mrmeshpy.findSelfCollidingTriangles	(	MeshPart	mp,
		std_vector_FaceFace	outCollidingPairs,
		func_bool_from_float	cb = 'MR::ProgressCallback{}',
		Face2RegionMap	regionMap = None )

finds all pairs (or the fact of any self-collision) of colliding triangles from one mesh or a region

◆ findSelfCollidingTrianglesBS()

FaceBitSet meshlib.mrmeshpy.findSelfCollidingTrianglesBS	(	MeshPart	mp,
		func_bool_from_float	cb = 'MR::ProgressCallback{}',
		Face2RegionMap	regionMap = None )

the same \\ref findSelfCollidingTriangles but returns the union of all self-intersecting faces

◆ findShortEdges()

UndirectedEdgeBitSet meshlib.mrmeshpy.findShortEdges	(	MeshPart	mp,
		float	criticalLength,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

finds edges having length <= criticalLength

◆ findSignedDistance() [1/2]

MeshMeshSignedDistanceResult meshlib.mrmeshpy.findSignedDistance	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None,
		float	upDistLimitSq = 3.4028234663852886e+38 )

 \\brief computes minimal distance between two meshes
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation
 \\param upDistLimitSq upper limit on the positive distance in question, if the real distance is larger than the function exists returning upDistLimitSq and no valid points

◆ findSignedDistance() [2/2]

SignedDistanceToMeshResult meshlib.mrmeshpy.findSignedDistance	(	Vector3f	pt,
		MeshPart	mp,
		float	upDistLimitSq = 3.4028234663852886e+38,
		float	loDistLimitSq = 0 )

 \\brief computes the closest point on mesh (or its region) to given point,
 and finds the distance with sign to it (positive - outside, negative - inside the mesh)
 \\param upDistLimitSq upper limit on the distance in question, if the real distance is larger then the function exits returning nullopt
 \\param loDistLimitSq low limit on the distance in question, if the real distance smaller then the function exits returning nullopt

◆ findSkyRays()

BitSet meshlib.mrmeshpy.findSkyRays	(	Mesh	terrain,
		VertCoords	samples,
		VertBitSet	validSamples,
		std_vector_SkyPatch	skyPatches,
		std_vector_MeshIntersectionResult	outIntersections = None )

In each valid sample point tests the rays from that point in the sky;
\\return bitset where for every valid sample #i its rays are stored at indices [i*numPatches; (i+1)*numPatches),
        0s for occluded rays (hitting the terrain) and 1s for the ones which don't hit anything and reach the sky
\\param outIntersections - optional output vector of MeshIntersectionResult for every valid sample point

◆ findSmallestCloseVertices() [1/3]

VertMap meshlib.mrmeshpy.findSmallestCloseVertices	(	Mesh	mesh,
		float	closeDist,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

returns a map where each valid vertex is mapped to the smallest valid vertex Id located within given distance (including itself), and this smallest vertex is mapped to itself,
each vertex not from valid set is mapped to itself

◆ findSmallestCloseVertices() [2/3]

VertMap meshlib.mrmeshpy.findSmallestCloseVertices	(	PointCloud	cloud,
		float	closeDist,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

returns a map where each valid vertex is mapped to the smallest valid vertex Id located within given distance (including itself), and this smallest vertex is mapped to itself,
each vertex not from valid set is mapped to itself

◆ findSmallestCloseVertices() [3/3]

VertMap meshlib.mrmeshpy.findSmallestCloseVertices	(	VertCoords	points,
		float	closeDist,
		VertBitSet	valid = None,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

returns a map where each valid vertex is mapped to the smallest valid vertex Id located within given distance (including itself), and this smallest vertex is mapped to itself,
each vertex not from valid set is mapped to itself; the search tree is constructe inside

◆ findSmallestCloseVerticesUsingTree()

VertMap meshlib.mrmeshpy.findSmallestCloseVerticesUsingTree	(	VertCoords	points,
		float	closeDist,
		AABBTreePoints	tree,
		VertBitSet	valid,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

returns a map where each valid vertex is mapped to the smallest valid vertex Id located within given distance (including itself), and this smallest vertex is mapped to itself,
each vertex not from valid set is mapped to itself; given tree is used as is

◆ findSteepestDescentPoint() [1/3]

EdgePoint meshlib.mrmeshpy.findSteepestDescentPoint	(	MeshPart	mp,
		VertScalars	field,
		EdgePoint	ep )

finds the point along minus maximal gradient on the boundary of triangles around given point (the boundary of left and right edge triangles' union in case (ep) is inner edge point)

◆ findSteepestDescentPoint() [2/3]

EdgePoint meshlib.mrmeshpy.findSteepestDescentPoint	(	MeshPart	mp,
		VertScalars	field,
		MeshTriPoint	tp )

finds the point along minus maximal gradient on the boundary of triangles around given point (the boundary of the triangle itself in case (tp) is inner triangle point)

◆ findSteepestDescentPoint() [3/3]

EdgePoint meshlib.mrmeshpy.findSteepestDescentPoint	(	MeshPart	mp,
		VertScalars	field,
		VertId	v )

finds the point along minus maximal gradient on the boundary of first ring boundary around given vertex

◆ findSubstringCaseInsensitive()

int meshlib.mrmeshpy.findSubstringCaseInsensitive	(	str	string,
		str	substring )

 Finds the substring in the string.
 \\return position, npos if not found
 \\ingroup BasicGroup

◆ findTriangleSegmentIntersectionPrecise()

Vector3f meshlib.mrmeshpy.findTriangleSegmentIntersectionPrecise	(	Vector3f	a,
		Vector3f	b,
		Vector3f	c,
		Vector3f	d,
		Vector3f	e,
		CoordinateConverters	converters )

finds intersection precise, using high precision int inside
this function input should have intersection

◆ findTrisInBall()

None meshlib.mrmeshpy.findTrisInBall	(	MeshPart	mp,
		Ball	ball,
		func_Processing_from_MeshProjectionResult_Ball	foundCallback,
		func_bool_from_Id_FaceTag	validFaces = 'MR::FacePredicate{}' )

enumerates all triangles within the ball until callback returns Stop;
the ball during enumeration can shrink (new ball is always within the previous one) but never expand

◆ findTwinEdgePairs()

std_vector_std_pair_Id_EdgeTag_Id_EdgeTag meshlib.mrmeshpy.findTwinEdgePairs	(	Mesh	mesh,
		float	closeDist )

finds pairs of twin edges (each twin edge will be present at least in one of pairs)

◆ findTwinEdges() [1/2]

EdgeBitSet meshlib.mrmeshpy.findTwinEdges	(	Mesh	mesh,
		float	closeDist )

finds all directed twin edges

◆ findTwinEdges() [2/2]

EdgeBitSet meshlib.mrmeshpy.findTwinEdges ( std_vector_std_pair_Id_EdgeTag_Id_EdgeTag pairs )

◆ findTwinUndirectedEdgeHashMap() [1/2]

phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag meshlib.mrmeshpy.findTwinUndirectedEdgeHashMap	(	Mesh	mesh,
		float	closeDist )

provided that each edge has at most one twin, composes bidirectional mapping between twins

◆ findTwinUndirectedEdgeHashMap() [2/2]

phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag meshlib.mrmeshpy.findTwinUndirectedEdgeHashMap ( std_vector_std_pair_Id_EdgeTag_Id_EdgeTag pairs )

◆ findTwinUndirectedEdges() [1/2]

UndirectedEdgeBitSet meshlib.mrmeshpy.findTwinUndirectedEdges	(	Mesh	mesh,
		float	closeDist )

finds all undirected twin edges

◆ findTwinUndirectedEdges() [2/2]

UndirectedEdgeBitSet meshlib.mrmeshpy.findTwinUndirectedEdges ( std_vector_std_pair_Id_EdgeTag_Id_EdgeTag pairs )

◆ findTwoClosestPoints()

tuple[VertId, VertId] meshlib.mrmeshpy.findTwoClosestPoints	(	PointCloud	pc,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

finds two closest points (first id < second id) in whole point cloud

◆ findUndercuts() [1/3]

None meshlib.mrmeshpy.findUndercuts	(	Mesh	mesh,
		Vector3f	upDirection,
		FaceBitSet	outUndercuts )

Adds to \\param outUndercuts undercut faces

◆ findUndercuts() [2/3]

float meshlib.mrmeshpy.findUndercuts	(	Mesh	mesh,
		Vector3f	upDirection,
		FaceBitSet	outUndercuts,
		func_double_from_TaggedBitSet_FaceTag_Vector3_float	metric )

Adds to \\param outUndercuts undercut faces
Returns summary metric of undercut faces

◆ findUndercuts() [3/3]

None meshlib.mrmeshpy.findUndercuts	(	Mesh	mesh,
		Vector3f	upDirection,
		VertBitSet	outUndercuts )

Adds to \\param outUndercuts undercut vertices

◆ fixMultipleEdges() [1/2]

None meshlib.mrmeshpy.fixMultipleEdges ( Mesh mesh )

finds and resolves multiple edges

◆ fixMultipleEdges() [2/2]

None meshlib.mrmeshpy.fixMultipleEdges	(	Mesh	mesh,
		std_vector_std_pair_Id_VertTag_Id_VertTag	multipleEdges )

resolves given multiple edges, but splitting all but one edge in each group

◆ fixSelfIntersections()

None meshlib.mrmeshpy.fixSelfIntersections	(	Mesh	mesh,
		float	voxelSize )

Fix self-intersections by converting to voxels and back.

◆ fixUndercuts() [1/2]

None meshlib.mrmeshpy.fixUndercuts	(	Mesh	mesh,
		FaceBitSet	selectedArea,
		Vector3f	upDirection,
		float	voxelSize = 0.0,
		float	bottomExtension = 0.0 )

Changes mesh:
Fills all holes first, then:
fixes undercuts (in selected area) via prolonging widest points down
Requires to update RenderObject after using
upDirection is in mesh space
voxelSize -  size of voxel in mesh rasterization, precision grows with lower voxelSize
bottomExtension - this parameter specifies how long should bottom prolongation be, if (bottomExtension <= 0) bottomExtension = 2*voxelSize
  if mesh is not closed this is used to prolong hole and make bottom

if voxelSize == 0.0f it will be counted automaticly

◆ fixUndercuts() [2/2]

None meshlib.mrmeshpy.fixUndercuts	(	Mesh	mesh,
		Vector3f	upDirection,
		float	voxelSize = 0.0,
		float	bottomExtension = 0.0 )

Changes mesh:
Fills all holes first, then:
fixes undercuts via prolonging widest points down
Requires to update RenderObject after using
upDirection is in mesh space
voxelSize -  size of voxel in mesh rasterization, precision grows with lower voxelSize
bottomExtension - this parameter specifies how long should bottom prolongation be, if (bottomExtension <= 0) bottomExtension = 2*voxelSize
  if mesh is not closed this is used to prolong hole and make bottom

if voxelSize == 0.0f it will be counted automaticly

◆ floatGridToVdbVolume()

VdbVolume meshlib.mrmeshpy.floatGridToVdbVolume ( OpenVdbFloatGrid grid )

fills VdbVolume data from FloatGrid (does not fill voxels size, cause we expect it outside)

◆ formatNoTrailingZeros()

str meshlib.mrmeshpy.formatNoTrailingZeros	(	char_output	fmt,
		float	v,
		int	digitsAfterPoint,
		int	precision = 6 )

returns printf-format for floating-point value in decimal notation with given precision in digits
and without trailing zeros after the decimal point
\\param fmt       preallocated buffer of 5 bytes
\\param v         value to print
\\param digitsAfterPoint  maximal number of digits after decimal point
\\param precision         maximal number of not-zero decimal digits

◆ fromSameTriangle() [1/2]

bool meshlib.mrmeshpy.fromSameTriangle	(	MeshTopology	topology,
		EdgePoint	a,
		EdgePoint	b )

returns true if points a and b are located on a boundary of the same triangle;
\\details if true a.e and b.e are updated to have that triangle on the left
\\related EdgePoint

◆ fromSameTriangle() [2/2]

bool meshlib.mrmeshpy.fromSameTriangle	(	MeshTopology	topology,
		MeshTriPoint	a,
		MeshTriPoint	b )

returns true if points a and b are located insides or on a boundary of the same triangle;
if true a.e and b.e are updated to have that triangle on the left

◆ fromSceneMison() [1/2]

LoadedObjectT meshlib.mrmeshpy.fromSceneMison	(	os.PathLike	path,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

load scene from MISON file \\n
JSON file with array named "Objects" or root array: \\n
element fields:\\n
   "Filename" : required full path to file for loading object
   "XF": optional xf for loaded object
   "Name": optional name for loaded object

◆ fromSceneMison() [2/2]

LoadedObjectT meshlib.mrmeshpy.fromSceneMison	(	typing.Any	in_,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ functionVolumeToSimpleVolume()

SimpleVolumeMinMax meshlib.mrmeshpy.functionVolumeToSimpleVolume	(	FunctionVolume	volume,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

converts function volume into simple volume

◆ generalOffsetMesh()

Mesh meshlib.mrmeshpy.generalOffsetMesh	(	MeshPart	mp,
		float	offset,
		GeneralOffsetParameters	params )

Offsets mesh by converting it to voxels and back using one of three modes specified in the parameters

◆ getAligningXf()

AffineXf3f meshlib.mrmeshpy.getAligningXf	(	PointToPlaneAligningTransform	p2pl,
		ICPMode	mode,
		float	angleLimit,
		float	scaleLimit,
		Vector3f	fixedRotationAxis )

given prepared (p2pl) object, finds the best transformation from it of given type with given limitations on rotation angle and global scale

◆ getAllComponents() [1/3]

std_vector_TaggedBitSet_FaceTag meshlib.mrmeshpy.getAllComponents	(	Face2RegionMap	componentsMap,
		int	componentsCount,
		FaceBitSet	region,
		int	maxComponentCount )

gets all connected components from components map ( FaceId => RegionId )
\\detail if components  number more than the maxComponentCount, they will be combined into groups of the same size (this similarly changes componentsMap)
\\param maxComponentCount should be more then 1
\\return components bitsets vector

◆ getAllComponents() [2/3]

tuple[std_vector_TaggedBitSet_FaceTag, int] meshlib.mrmeshpy.getAllComponents	(	MeshPart	meshPart,
		int	maxComponentCount,
		MeshComponents.FaceIncidence	incidence = 'FaceIncidence::PerEdge',
		func_bool_from_Id_UndirectedEdgeTag	isCompBd = 'MR::UndirectedEdgePredicate{}' )

gets all connected components of mesh part
\\detail if components  number more than the maxComponentCount, they will be combined into groups of the same size
\\param maxComponentCount should be more then 1
\\return pair components bitsets vector and number components in one group if components number more than maxComponentCount

◆ getAllComponents() [3/3]

std_vector_TaggedBitSet_FaceTag meshlib.mrmeshpy.getAllComponents	(	MeshPart	meshPart,
		MeshComponents.FaceIncidence	incidence = 'FaceIncidence::PerEdge',
		func_bool_from_Id_UndirectedEdgeTag	isCompBd = 'MR::UndirectedEdgePredicate{}' )

gets all connected components of mesh part
\\note be careful, if mesh is large enough and has many components, the memory overflow will occur

◆ getAllComponentsVerts()

std_vector_TaggedBitSet_VertTag meshlib.mrmeshpy.getAllComponentsVerts	(	Mesh	mesh,
		VertBitSet	region = None )

gets all connected components of mesh part

◆ getAllFilters()

std_vector_IOFilter meshlib.mrmeshpy.getAllFilters ( )

returns filters for all supported file formats for all types of objects

◆ getAllObjectsInTree_Object()

std_vector_std_shared_ptr_Object meshlib.mrmeshpy.getAllObjectsInTree_Object	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_ObjectDistanceMap()

std_vector_std_shared_ptr_ObjectDistanceMap meshlib.mrmeshpy.getAllObjectsInTree_ObjectDistanceMap	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_ObjectLines()

std_vector_std_shared_ptr_ObjectLines meshlib.mrmeshpy.getAllObjectsInTree_ObjectLines	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_ObjectLinesHolder()

std_vector_std_shared_ptr_ObjectLinesHolder meshlib.mrmeshpy.getAllObjectsInTree_ObjectLinesHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_ObjectMesh()

std_vector_std_shared_ptr_ObjectMesh meshlib.mrmeshpy.getAllObjectsInTree_ObjectMesh	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_ObjectMeshHolder()

std_vector_std_shared_ptr_ObjectMeshHolder meshlib.mrmeshpy.getAllObjectsInTree_ObjectMeshHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_ObjectPoints()

std_vector_std_shared_ptr_ObjectPoints meshlib.mrmeshpy.getAllObjectsInTree_ObjectPoints	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_ObjectPointsHolder()

std_vector_std_shared_ptr_ObjectPointsHolder meshlib.mrmeshpy.getAllObjectsInTree_ObjectPointsHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_ObjectVoxels()

std_vector_std_shared_ptr_ObjectVoxels meshlib.mrmeshpy.getAllObjectsInTree_ObjectVoxels	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAllObjectsInTree_VisualObject()

std_vector_std_shared_ptr_VisualObject meshlib.mrmeshpy.getAllObjectsInTree_VisualObject	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getAt()

UndirectedEdgeId meshlib.mrmeshpy.getAt	(	Buffer_UndirectedEdgeId_UndirectedEdgeId	bmap,
		UndirectedEdgeId	key,
		UndirectedEdgeId	def_ = 'MR::UndirectedEdgeId{}' )

given some buffer map and a key, returns the value associated with the key, or default value if key is invalid

◆ getBooleanPoints()

BooleanResultPoints meshlib.mrmeshpy.getBooleanPoints	(	Mesh	meshA,
		Mesh	meshB,
		BooleanOperation	operation,
		AffineXf3f	rigidB2A = None )

\\brief Returns the points of mesh boolean's result mesh

\\ingroup BooleanGroup
Returns vertices and intersection points of mesh that is result of boolean operation of mesh `A` and mesh `B`.
Can be used as fast alternative for cases where the mesh topology can be ignored (bounding box, convex hull, etc.)
\\param meshA Input mesh `A`
\\param meshB Input mesh `B`
\\param operation Boolean operation to perform
\\param rigidB2A Transform from mesh `B` space to mesh `A` space

◆ getBoundaryFaces()

FaceBitSet meshlib.mrmeshpy.getBoundaryFaces	(	MeshTopology	topology,
		FaceBitSet	region )

returns faces from given region that have at least one neighbor face with shared edge not from the region

◆ getBoundaryVerts()

VertBitSet meshlib.mrmeshpy.getBoundaryVerts	(	MeshTopology	topology,
		FaceBitSet	region = None )

composes the set of all boundary vertices for given region (or whole mesh if !region)

◆ getCancelMessage()

str meshlib.mrmeshpy.getCancelMessage ( os.PathLike path )

Returns message showed when loading is canceled

◆ getCircumscribedMetric()

FillHoleMetric meshlib.mrmeshpy.getCircumscribedMetric ( Mesh mesh )

This metric minimizes the sum of circumcircle radii for all triangles in the triangulation.
It is rather fast to calculate, and it results in typically good triangulations.

◆ getComplexFillMetric()

FillHoleMetric meshlib.mrmeshpy.getComplexFillMetric	(	Mesh	mesh,
		Id_EdgeTag	e )

This metric minimizes the sum of triangleMetric for all triangles in the triangulation
plus the sum edgeMetric for all edges inside and on the boundary of the triangulation.\\n
Where\\n
triangleMetric is proportional to weighted triangle area and triangle aspect ratio\\n
edgeMetric grows with angle between triangles as ( ( 1 - cos( x ) ) / ( 1 + cos( x ) ) ) ^ 4.

◆ getComplexStitchMetric()

FillHoleMetric meshlib.mrmeshpy.getComplexStitchMetric ( Mesh mesh )

This metric minimizes the sum of triangleMetric for all triangles in the triangulation
plus the sum edgeMetric for all edges inside and on the boundary of the triangulation.\\n
Where\\n
triangleMetric is proportional to triangle aspect ratio\\n
edgeMetric is proportional to ( 1 - dihedralAngleCos )

◆ getContourPlaneIntersections()

int meshlib.mrmeshpy.getContourPlaneIntersections	(	std_vector_Vector3_float	path,
		Plane3f	plane,
		std_vector_Vector3_float	outIntersections = None )

finds all intersection points between given contour and plane, adds them in outIntersections and returns their number

◆ GetCpuId()

str meshlib.mrmeshpy.GetCpuId ( )

returns string identification of the CPU

◆ getCurrentStacktrace()

str meshlib.mrmeshpy.getCurrentStacktrace ( )

returns string representation of the current stacktrace

◆ getCurrentStacktraceInline()

str meshlib.mrmeshpy.getCurrentStacktraceInline ( )

returns string representation of the current stacktrace;
the function is inlined, to put the code in any shared library;
if std::stacktrace is first called from MRMesh.dll then it is not unloaded propely

◆ getDepthFirstObject_Object()

Object meshlib.mrmeshpy.getDepthFirstObject_Object	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_ObjectDistanceMap()

ObjectDistanceMap meshlib.mrmeshpy.getDepthFirstObject_ObjectDistanceMap	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_ObjectLines()

ObjectLines meshlib.mrmeshpy.getDepthFirstObject_ObjectLines	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_ObjectLinesHolder()

ObjectLinesHolder meshlib.mrmeshpy.getDepthFirstObject_ObjectLinesHolder	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_ObjectMesh()

ObjectMesh meshlib.mrmeshpy.getDepthFirstObject_ObjectMesh	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_ObjectMeshHolder()

ObjectMeshHolder meshlib.mrmeshpy.getDepthFirstObject_ObjectMeshHolder	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_ObjectPoints()

ObjectPoints meshlib.mrmeshpy.getDepthFirstObject_ObjectPoints	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_ObjectPointsHolder()

ObjectPointsHolder meshlib.mrmeshpy.getDepthFirstObject_ObjectPointsHolder	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_ObjectVoxels()

ObjectVoxels meshlib.mrmeshpy.getDepthFirstObject_ObjectVoxels	(	Object	root,
		ObjectSelectivityType	type )

◆ getDepthFirstObject_VisualObject()

VisualObject meshlib.mrmeshpy.getDepthFirstObject_VisualObject	(	Object	root,
		ObjectSelectivityType	type )

◆ GetDetailedOSName()

str meshlib.mrmeshpy.GetDetailedOSName ( )

returns string with OS name with details

◆ getEdgeLengthFillMetric()

FillHoleMetric meshlib.mrmeshpy.getEdgeLengthFillMetric ( Mesh mesh )

Simple metric minimizing the sum of all edge lengths

◆ getEdgeLengthStitchMetric()

FillHoleMetric meshlib.mrmeshpy.getEdgeLengthStitchMetric ( Mesh mesh )

Forbids connecting vertices from the same hole \\n
Simple metric minimizing edge length

◆ getEdgeOrdering()

UndirectedEdgeBMap meshlib.mrmeshpy.getEdgeOrdering	(	FaceBMap	faceMap,
		MeshTopology	topology )

compute the order of edges given the order of faces:
edges near first faces also appear first;
\\param faceMap old face id -> new face id

◆ GetEmbeddedPythonDirectory()

os.PathLike meshlib.mrmeshpy.GetEmbeddedPythonDirectory ( )

returns path of embedded python modules files directory
.dll .so files

◆ GetExeDirectory()

os.PathLike meshlib.mrmeshpy.GetExeDirectory ( )

returns path of current exe directory

◆ getFacesByMinEdgeLength()

FaceBitSet meshlib.mrmeshpy.getFacesByMinEdgeLength	(	Mesh	mesh,
		float	minLength )

Return faces with at least one edge longer than the specified length.

◆ getFeatureDirection()

Vector3f meshlib.mrmeshpy.getFeatureDirection ( FeatureObject feature )

Using forEachObjectKind the template collects a list of features for which the method ...->getDirection() is available

◆ getFeatureNormal()

Vector3f meshlib.mrmeshpy.getFeatureNormal ( FeatureObject feature )

Using forEachObjectKind the template collects a list of features for which the method ...->getNormal() is available

◆ getFeaturesTypeWithDirections()

std_unordered_set_std_string meshlib.mrmeshpy.getFeaturesTypeWithDirections ( )

Try to getDirection from specific feature using forEachObjectKind template. Returns nullopt is ...->getDirection() is not available for given feature type.

◆ getFeaturesTypeWithNormals()

std_unordered_set_std_string meshlib.mrmeshpy.getFeaturesTypeWithNormals ( )

Try to getNormal from specific feature using forEachObjectKind template. Returns nullopt is ...->getNormal() is not available for given feature type.

◆ GetFontsDirectory()

os.PathLike meshlib.mrmeshpy.GetFontsDirectory ( )

returns path of font files directory
.ttf files

◆ getHoleFillPlan()

HoleFillPlan meshlib.mrmeshpy.getHoleFillPlan	(	Mesh	mesh,
		Id_EdgeTag	e,
		FillHoleParams	params = 'MR::FillHoleParams{}' )

prepares the plan how to triangulate the face or hole to the left of (e) (not filling it immediately),
several getHoleFillPlan can work in parallel

◆ GetHomeDirectory()

os.PathLike meshlib.mrmeshpy.GetHomeDirectory ( )

returns home directory

◆ getICPStatusInfo()

str meshlib.mrmeshpy.getICPStatusInfo	(	int	iterations,
		ICPExitType	exitType )

returns status info string

◆ getIncidentEdges() [1/2]

UndirectedEdgeBitSet meshlib.mrmeshpy.getIncidentEdges	(	MeshTopology	topology,
		FaceBitSet	faces )

composes the set of all undirected edges, having a face from given set from one of two sides

◆ getIncidentEdges() [2/2]

UndirectedEdgeBitSet meshlib.mrmeshpy.getIncidentEdges	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all undirected edges, having at least one common vertex with an edge from given set

◆ getIncidentFaces() [1/2]

FaceBitSet meshlib.mrmeshpy.getIncidentFaces	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all faces incident to given edges

◆ getIncidentFaces() [2/2]

FaceBitSet meshlib.mrmeshpy.getIncidentFaces	(	MeshTopology	topology,
		VertBitSet	verts )

composes the set of all faces incident to given vertices

◆ getIncidentVerts() [1/4]

VertBitSet meshlib.mrmeshpy.getIncidentVerts	(	MeshTopology	topology,
		FaceBitSet	faces )

composes the set of all vertices incident to given faces

◆ getIncidentVerts() [2/4]

VertBitSet meshlib.mrmeshpy.getIncidentVerts	(	MeshTopology	topology,
		FaceBitSet	faces,
		VertBitSet	store )

if faces-parameter is null pointer then simply returns the reference on all valid vertices;
otherwise performs store = getIncidentVerts( topology, *faces ) and returns reference on store

◆ getIncidentVerts() [3/4]

VertBitSet meshlib.mrmeshpy.getIncidentVerts	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all vertices incident to given edges

◆ getIncidentVerts() [4/4]

VertBitSet meshlib.mrmeshpy.getIncidentVerts	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges,
		VertBitSet	store )

if edges-parameter is null pointer then simply returns the reference on all valid vertices;
otherwise performs store = getIncidentVerts( topology, *edges ) and returns reference on store

◆ getInnerEdges() [1/2]

UndirectedEdgeBitSet meshlib.mrmeshpy.getInnerEdges	(	MeshTopology	topology,
		FaceBitSet	region )

composes the set of all edges having both left and right in given region

◆ getInnerEdges() [2/2]

UndirectedEdgeBitSet meshlib.mrmeshpy.getInnerEdges	(	MeshTopology	topology,
		VertBitSet	verts )

composes the set of all edges with all their vertices in given set

◆ getInnerFaces()

FaceBitSet meshlib.mrmeshpy.getInnerFaces	(	MeshTopology	topology,
		VertBitSet	verts )

composes the set of all faces with all their vertices in given set

◆ getInnerVerts() [1/2]

VertBitSet meshlib.mrmeshpy.getInnerVerts	(	MeshTopology	topology,
		FaceBitSet	region = None )

composes the set of all vertices not on the boundary of a hole and with all their adjacent faces in given set

◆ getInnerVerts() [2/2]

VertBitSet meshlib.mrmeshpy.getInnerVerts	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all vertices with all their edges in given set

◆ GetLibsDirectory()

os.PathLike meshlib.mrmeshpy.GetLibsDirectory ( )

returns path of lib files directory
.dll .so files

◆ getMaxDihedralAngleMetric()

FillHoleMetric meshlib.mrmeshpy.getMaxDihedralAngleMetric ( Mesh mesh )

This metric minimizes the maximal dihedral angle between the faces in the triangulation
and on its boundary

◆ getMeanSqDistToPlane()

float meshlib.mrmeshpy.getMeanSqDistToPlane ( IPointPairs pairs )

computes root-mean-square deviation from points to target planes

◆ getMeanSqDistToPoint()

float meshlib.mrmeshpy.getMeanSqDistToPoint ( IPointPairs pairs )

computes root-mean-square deviation between points

◆ getMeshOrPoints()

MeshOrPoints meshlib.mrmeshpy.getMeshOrPoints ( VisualObject obj )

constructs MeshOrPoints from ObjectMesh or ObjectPoints, otherwise returns nullopt

◆ getMinAreaMetric()

FillHoleMetric meshlib.mrmeshpy.getMinAreaMetric ( Mesh mesh )

This metric is for triangulation construction with minimal summed area of triangles.
Warning: this metric can produce degenerated triangles

◆ getMinTriAngleMetric()

FillHoleMetric meshlib.mrmeshpy.getMinTriAngleMetric ( Mesh mesh )

This metric maximizes the minimal angle among all faces in the triangulation

◆ GetMRVersionString()

str meshlib.mrmeshpy.GetMRVersionString ( )

returns version of MR

◆ getNeighborFaces()

FaceBitSet meshlib.mrmeshpy.getNeighborFaces	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all left and right faces of given edges

◆ getNumActivePairs()

int meshlib.mrmeshpy.getNumActivePairs ( IPointPairs pairs )

computes the number of active pairs

◆ getNumNodes()

int meshlib.mrmeshpy.getNumNodes ( int numLeaves )

returns the number of nodes in the binary tree with given number of leaves

◆ getNumSamples()

int meshlib.mrmeshpy.getNumSamples ( IPointPairs pairs )

returns the number of samples able to form pairs

◆ getOneMeshIntersectionContours()

std_vector_OneMeshContour meshlib.mrmeshpy.getOneMeshIntersectionContours	(	Mesh	meshA,
		Mesh	meshB,
		std_vector_std_vector_VariableEdgeTri	contours,
		bool	getMeshAIntersections,
		CoordinateConverters	converters,
		AffineXf3f	rigidB2A = None )

Converts ordered continuous contours of two meshes to OneMeshContours
converters is required for better precision in case of degenerations
note that contours should not have intersections

◆ getOptimalFaceOrdering()

FaceBMap meshlib.mrmeshpy.getOptimalFaceOrdering ( Mesh mesh )

computes optimal order of faces: old face id -> new face id,
the order is similar as in AABB tree, but faster to compute

◆ getOSNoSpaces()

str meshlib.mrmeshpy.getOSNoSpaces ( )

returns string identification of the OS

◆ getParallelPlaneFillMetric()

FillHoleMetric meshlib.mrmeshpy.getParallelPlaneFillMetric	(	Mesh	mesh,
		Id_EdgeTag	e,
		Plane3f	plane = None )

This metric minimizes summary projection of new edges to plane normal, (try do produce edges parallel to plane)

◆ getPathEdgesInPlane()

int meshlib.mrmeshpy.getPathEdgesInPlane	(	Mesh	mesh,
		std_vector_Id_EdgeTag	path,
		Plane3f	plane,
		float	tolerance = 0.0,
		std_vector_Id_EdgeTag	outInPlaneEdges = None )

finds all path edges located in given plane with given tolerance, adds them in outInPlaneEdges and returns their number

◆ getPathPlaneIntersections()

int meshlib.mrmeshpy.getPathPlaneIntersections	(	Mesh	mesh,
		std_vector_Id_EdgeTag	path,
		Plane3f	plane,
		std_vector_EdgePoint	outIntersections = None )

finds all intersection points between given path and plane, adds them in outIntersections and returns their number

◆ getPlanarHoleFillPlan()

HoleFillPlan meshlib.mrmeshpy.getPlanarHoleFillPlan	(	Mesh	mesh,
		Id_EdgeTag	e )

prepares the plan how to triangulate the planar face or planar hole to the left of (e) (not filling it immediately),
several getPlanarHoleFillPlan can work in parallel

◆ getPlaneFillMetric()

FillHoleMetric meshlib.mrmeshpy.getPlaneFillMetric	(	Mesh	mesh,
		Id_EdgeTag	e )

Same as getCircumscribedFillMetric, but with extra penalty for the triangles having
normals looking in the opposite side of plane containing left of (e).

◆ getPlaneNormalizedFillMetric()

FillHoleMetric meshlib.mrmeshpy.getPlaneNormalizedFillMetric	(	Mesh	mesh,
		Id_EdgeTag	e )

Similar to getPlaneFillMetric with extra penalty for the triangles having
normals looking in the opposite side of plane containing left of (e),
but the metric minimizes the sum of circumcircle radius times aspect ratio for all triangles in the triangulation.

◆ getRegionBoundaryVerts()

VertBitSet meshlib.mrmeshpy.getRegionBoundaryVerts	(	MeshTopology	topology,
		FaceBitSet	region )

composes the set of all boundary vertices for given region,
unlike getBoundaryVerts the vertices of mesh boundary having no incident not-region faces are not returned

◆ getRegionEdges()

EdgeBitSet meshlib.mrmeshpy.getRegionEdges	(	MeshTopology	topology,
		FaceBitSet	faces )

composes the set of all edges, having a face from given set at the left

◆ GetResourcesDirectory()

os.PathLike meshlib.mrmeshpy.GetResourcesDirectory ( )

returns path of resource files directory
.json and .png files

◆ getStreamSize()

int meshlib.mrmeshpy.getStreamSize ( typing.Any in_ )

get the size of the remaining data in the input stream

◆ getSubdividePart()

FaceBitSet meshlib.mrmeshpy.getSubdividePart	(	FaceBitSet	valids,
		int	subdivideParts,
		int	myPart )

 \\brief returns given subdivision part of all valid faces;
 parallel threads shall be able to safely modify these bits because they do not share any block with other parts
 \\ingroup DecimateGroup

◆ getSumSqDistToPlane()

NumSum meshlib.mrmeshpy.getSumSqDistToPlane	(	IPointPairs	pairs,
		std_optional_double	inaccuracy = 'std::optional<double>{}' )

computes the number of active pairs and the sum of squared deviation from points to target planes
or the difference between the squared distances between points to target planes and inaccuracy

◆ getSumSqDistToPoint()

NumSum meshlib.mrmeshpy.getSumSqDistToPoint	(	IPointPairs	pairs,
		std_optional_double	inaccuracy = 'std::optional<double>{}' )

computes the number of active pairs and the sum of squared distances between points
or the difference between the squared distances between points and inaccuracy

◆ getSurfacePathsViaVertices()

std_vector_std_vector_EdgePoint meshlib.mrmeshpy.getSurfacePathsViaVertices	(	Mesh	mesh,
		VertBitSet	vs )

returns a set of mesh lines passing via most of given vertices in auto-selected order;
the lines try to avoid sharp turns in the vertices

◆ getSystemMemory()

SystemMemory meshlib.mrmeshpy.getSystemMemory ( )

return information about memory available in the system

◆ GetTempDirectory()

os.PathLike meshlib.mrmeshpy.GetTempDirectory ( )

returns temp directory

◆ getToFloatConverter()

func_Vector3_float_from_Vector3_int meshlib.mrmeshpy.getToFloatConverter ( Box3d box )

creates converter from Vector3i to Vector3f in Box range (int diapason is mapped to box range)

◆ getToIntConverter()

func_Vector3_int_from_Vector3_float meshlib.mrmeshpy.getToIntConverter ( Box3d box )

creates converter from Vector3f to Vector3i in Box range (int diapason is mapped to box range)

◆ getTopmostVisibleObjects_Object()

std_vector_std_shared_ptr_Object meshlib.mrmeshpy.getTopmostVisibleObjects_Object	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_ObjectDistanceMap()

std_vector_std_shared_ptr_ObjectDistanceMap meshlib.mrmeshpy.getTopmostVisibleObjects_ObjectDistanceMap	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_ObjectLines()

std_vector_std_shared_ptr_ObjectLines meshlib.mrmeshpy.getTopmostVisibleObjects_ObjectLines	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_ObjectLinesHolder()

std_vector_std_shared_ptr_ObjectLinesHolder meshlib.mrmeshpy.getTopmostVisibleObjects_ObjectLinesHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_ObjectMesh()

std_vector_std_shared_ptr_ObjectMesh meshlib.mrmeshpy.getTopmostVisibleObjects_ObjectMesh	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_ObjectMeshHolder()

std_vector_std_shared_ptr_ObjectMeshHolder meshlib.mrmeshpy.getTopmostVisibleObjects_ObjectMeshHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_ObjectPoints()

std_vector_std_shared_ptr_ObjectPoints meshlib.mrmeshpy.getTopmostVisibleObjects_ObjectPoints	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_ObjectPointsHolder()

std_vector_std_shared_ptr_ObjectPointsHolder meshlib.mrmeshpy.getTopmostVisibleObjects_ObjectPointsHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_ObjectVoxels()

std_vector_std_shared_ptr_ObjectVoxels meshlib.mrmeshpy.getTopmostVisibleObjects_ObjectVoxels	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTopmostVisibleObjects_VisualObject()

std_vector_std_shared_ptr_VisualObject meshlib.mrmeshpy.getTopmostVisibleObjects_VisualObject	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

◆ getTypeConverter()

func_float_from_char_const meshlib.mrmeshpy.getTypeConverter	(	ScalarType	scalarType,
		int	range,
		int	min )

get a function to convert binary data of specified format type to a scalar value
\\param scalarType - binary format type
\\param range - (for integer types only) the range of possible values
\\param min - (for integer types only) the minimal value

◆ getUniversalMetric()

FillHoleMetric meshlib.mrmeshpy.getUniversalMetric ( Mesh mesh )

This metric minimizes the maximal dihedral angle between the faces in the triangulation
and on its boundary, and it avoids creating too degenerate triangles;
 for planar holes it is the same as getCircumscribedMetric

◆ getUserConfigDir()

os.PathLike meshlib.mrmeshpy.getUserConfigDir ( )

return path to the folder with user config file(s)

◆ getUserConfigFilePath()

os.PathLike meshlib.mrmeshpy.getUserConfigFilePath ( )

returns path of config file in APPDATA

◆ getValue()

float meshlib.mrmeshpy.getValue	(	OpenVdbFloatGrid	grid,
		Vector3i	p )

returns the value at given voxel

◆ getVectorConverters()

CoordinateConverters meshlib.mrmeshpy.getVectorConverters	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None )

 \\brief creates simple converters from Vector3f to Vector3i and back in mesh parts area range
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation

◆ getVertexAsMeshTriPoint()

MeshTriPoint meshlib.mrmeshpy.getVertexAsMeshTriPoint	(	MeshTopology	topology,
		Id_EdgeTag	e,
		VertId	v )

returns MeshTriPoint representation of given vertex with given edge field; or invalid MeshTriPoint if it is not possible

◆ getVertexOrdering() [1/2]

VertBMap meshlib.mrmeshpy.getVertexOrdering	(	FaceBMap	faceMap,
		MeshTopology	topology )

compute the order of vertices given the order of faces:
vertices near first faces also appear first;
\\param faceMap old face id -> new face id

◆ getVertexOrdering() [2/2]

std_vector_Id_VertTag meshlib.mrmeshpy.getVertexOrdering	(	MeshTopology	topology,
		VertBitSet	region )

returns all vertices from given region ordered in each connected component in breadth-first way

◆ getVerticalStitchMetric()

FillHoleMetric meshlib.mrmeshpy.getVerticalStitchMetric	(	Mesh	mesh,
		Vector3f	upDir )

Forbids connecting vertices from the same hole \\n
All new faces should be parallel to given direction

◆ getXfFromOxyPlane() [1/2]

AffineXf3f meshlib.mrmeshpy.getXfFromOxyPlane	(	Mesh	mesh,
		std_vector_std_vector_Id_EdgeTag	paths )

◆ getXfFromOxyPlane() [2/2]

AffineXf3f meshlib.mrmeshpy.getXfFromOxyPlane ( std_vector_std_vector_Vector3_float contours )

computes the transformation that maps
O into center mass of contours' points
OXY into best plane containing the points

◆ gridToMesh()

Mesh meshlib.mrmeshpy.gridToMesh	(	OpenVdbFloatGrid	grid,
		GridToMeshSettings	settings )

converts OpenVDB Grid into mesh using Dual Marching Cubes algorithm

converts OpenVDB Grid into mesh using Dual Marching Cubes algorithm;
deletes grid in the middle to reduce peak memory consumption

◆ hardSmoothTetrahedrons()

None meshlib.mrmeshpy.hardSmoothTetrahedrons	(	Mesh	mesh,
		VertBitSet	region = None )

move all region vertices with exactly three neighbor vertices in the center of the neighbors

◆ hasAnyIsoline() [1/2]

bool meshlib.mrmeshpy.hasAnyIsoline	(	MeshTopology	topology,
		func_float_from_Id_VertTag	vertValues,
		FaceBitSet	region = None )

quickly returns true if extractIsolines produce not-empty set for the same arguments

◆ hasAnyIsoline() [2/2]

bool meshlib.mrmeshpy.hasAnyIsoline	(	MeshTopology	topology,
		VertScalars	vertValues,
		float	isoValue,
		FaceBitSet	region = None )

quickly returns true if extractIsolines produce not-empty set for the same arguments

◆ hasAnyPlaneSection()

bool meshlib.mrmeshpy.hasAnyPlaneSection	(	MeshPart	mp,
		Plane3f	plane )

quickly returns true if extractPlaneSections produce not-empty set for the same arguments

◆ hasAnyXYPlaneSection()

bool meshlib.mrmeshpy.hasAnyXYPlaneSection	(	MeshPart	mp,
		float	zLevel )

quickly returns true if extractXYPlaneSections produce not-empty set for the same arguments

◆ hasMultipleEdges()

bool meshlib.mrmeshpy.hasMultipleEdges ( MeshTopology topology )

◆ hasProhibitedChars()

bool meshlib.mrmeshpy.hasProhibitedChars ( str line )

returns true if line contains any of OS prohibited chars ('?', '*', '/', '\\', '"', '<', '>')

◆ heapBytes()

int meshlib.mrmeshpy.heapBytes ( OpenVdbFloatGrid grid )

returns the amount of heap memory occupied by grid

◆ heapBytes_Color()

int meshlib.mrmeshpy.heapBytes_Color ( std_vector_Color vec )

returns the amount of memory given vector occupies on heap

◆ heapBytes_float()

int meshlib.mrmeshpy.heapBytes_float ( std_vector_float vec )

returns the amount of memory given vector occupies on heap

◆ heapBytes_Mesh()

int meshlib.mrmeshpy.heapBytes_Mesh ( Mesh ptr )

returns the amount of memory this smart pointer and its pointed object own together on heap

◆ heapBytes_MeshTexture_TextureId()

int meshlib.mrmeshpy.heapBytes_MeshTexture_TextureId ( Vector_MeshTexture_TextureId vec )

◆ heapBytes_Object()

int meshlib.mrmeshpy.heapBytes_Object ( Object ptr )

returns the amount of memory this smart pointer and its pointed object own together on heap

◆ heapBytes_OpenVdbFloatGrid()

int meshlib.mrmeshpy.heapBytes_OpenVdbFloatGrid ( OpenVdbFloatGrid ptr )

returns the amount of memory this smart pointer and its pointed object own together on heap

◆ heapBytes_PointCloud()

int meshlib.mrmeshpy.heapBytes_PointCloud ( PointCloud ptr )

returns the amount of memory this smart pointer and its pointed object own together on heap

◆ heapBytes_Polyline3()

int meshlib.mrmeshpy.heapBytes_Polyline3 ( Polyline3 ptr )

returns the amount of memory this smart pointer and its pointed object own together on heap

◆ heapBytes_std_shared_ptr_Object()

int meshlib.mrmeshpy.heapBytes_std_shared_ptr_Object ( std_vector_std_shared_ptr_Object vec )

returns the amount of memory given vector occupies on heap

◆ heapBytes_unsigned_long()

int meshlib.mrmeshpy.heapBytes_unsigned_long ( std_vector_unsigned_long vec )

returns the amount of memory given vector occupies on heap

◆ identityMetric()

func_float_from_Id_EdgeTag meshlib.mrmeshpy.identityMetric ( )

metric returning 1 for every edge

◆ improveSampling()

bool meshlib.mrmeshpy.improveSampling	(	PointCloud	cloud,
		VertBitSet	samples,
		ImproveSamplingSettings	settings )

Finds more representative sampling starting from a given one following k-means method;
\\param samples input and output selected sample points from \\param cloud;
\\return false if it was terminated by the callback
\\ingroup PointCloudGroup

◆ inflate()

None meshlib.mrmeshpy.inflate	(	Mesh	mesh,
		VertBitSet	verts,
		InflateSettings	settings )

Inflates (in one of two sides) given mesh region,
putting given vertices in such positions to make smooth surface inside verts-region, but sharp on its boundary;
\\param verts must not include all vertices of a mesh connected component

◆ interpolateArcs()

None meshlib.mrmeshpy.interpolateArcs	(	std_vector_GCommand	commands,
		ArcInterpolationParams	params,
		Axis	axis )

interpolates given path with arcs

◆ interpolateLines()

None meshlib.mrmeshpy.interpolateLines	(	std_vector_GCommand	commands,
		LineInterpolationParams	params,
		Axis	axis )

interpolates several points lying on the same straight line with one move

◆ intersection()

Vector2f meshlib.mrmeshpy.intersection	(	LineSegm2f	segm1,
		LineSegm2f	segm2 )

finds an intersection between a segm1 and a segm2
\\return nullopt if they don't intersect (even if they match)

◆ isClosed()

bool meshlib.mrmeshpy.isClosed ( std_vector_Vector3_float c )

◆ isDegree3Dest()

bool meshlib.mrmeshpy.isDegree3Dest	(	MeshTopology	topology,
		Id_EdgeTag	e )

returns true if the destination of given edge has degree 3 and 3 incident triangles

◆ isEdgeBetweenDoubleTris()

bool meshlib.mrmeshpy.isEdgeBetweenDoubleTris	(	MeshTopology	topology,
		Id_EdgeTag	e )

returns true if the edge e has both left and right triangular faces and the degree of dest( e ) is 2

◆ isEdgeLoop()

bool meshlib.mrmeshpy.isEdgeLoop	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	edges )

returns true if every next edge starts where previous edge ends, and start vertex coincides with finish vertex

◆ isEdgePath()

bool meshlib.mrmeshpy.isEdgePath	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	edges )

returns true if every next edge starts where previous edge ends

◆ isHoleBd()

bool meshlib.mrmeshpy.isHoleBd	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	loop )

returns true if given loop is a boundary of one hole in given mesh topology:
* every edge in the loop does not have left face,
* next/prev edges in the loop are related as follows: next = topology.prev( prev.sym() )
if the function returns true, then any edge from the loop passed to \\ref fillHole will fill the same hole

◆ isInside() [1/2]

bool meshlib.mrmeshpy.isInside	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None )

 \\brief checks that arbitrary mesh part A is inside of closed mesh part B
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation

◆ isInside() [2/2]

bool meshlib.mrmeshpy.isInside	(	Polyline2	a,
		Polyline2	b,
		AffineXf2f	rigidB2A = None )

 \\brief checks that arbitrary 2d polyline A is inside of closed 2d polyline B
 \\param rigidB2A rigid transformation from B-polyline space to A polyline space, nullptr considered as identity transformation

◆ isNanFast()

bool meshlib.mrmeshpy.isNanFast ( float f )

quickly tests whether given float is not-a-number

◆ isNonIntersectingInside() [1/2]

bool meshlib.mrmeshpy.isNonIntersectingInside	(	Mesh	a,
		FaceId	partFace,
		MeshPart	b,
		AffineXf3f	rigidB2A = None )

 \\brief checks that arbitrary mesh A part (whole part is represented by one face `partFace`) is inside of closed mesh part B
 The version of `isInside` without collision check; it is user's responsibility to guarantee that the meshes don't collide
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation

◆ isNonIntersectingInside() [2/2]

bool meshlib.mrmeshpy.isNonIntersectingInside	(	MeshPart	a,
		MeshPart	b,
		AffineXf3f	rigidB2A = None )

 \\brief checks that arbitrary mesh part A is inside of closed mesh part B
 The version of `isInside` without collision check; it is user's responsibility to guarantee that the meshes don't collide
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation

◆ isPickedPointValid()

bool meshlib.mrmeshpy.isPickedPointValid	(	VisualObject	object,
		std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int	point )

Checks that the picked point presents in the object's topology

◆ isPointInsidePolyline()

bool meshlib.mrmeshpy.isPointInsidePolyline	(	Polyline2	polyline,
		Vector2f	point )

 \\brief detect if given point is inside polyline, by counting ray intersections
 \\param polyline input polyline
 \\param point input point

◆ isSupportedFileInSubfolders()

bool meshlib.mrmeshpy.isSupportedFileInSubfolders ( os.PathLike folder )

check if there are any supported files folder and subfolders

◆ isTIFFFile()

bool meshlib.mrmeshpy.isTIFFFile ( os.PathLike path )

returns true if given file is tiff

◆ isVertexRepeatedOnHoleBd()

Id_EdgeTag meshlib.mrmeshpy.isVertexRepeatedOnHoleBd	(	MeshTopology	topology,
		VertId	v )

if given vertex is present on the boundary of some hole several times then returns an edge of this hole (without left);
returns invalid edge otherwise (not a boundary vertex, or it is present only once on the boundary of each hole it pertains to)

◆ lacingToolPath()

ToolPathResult meshlib.mrmeshpy.lacingToolPath	(	MeshPart	mp,
		ToolPathParams	params,
		Axis	cutDirection )

Slices are built along the axis defined by cutDirection argument (can be Axis::X or Axis::Y)

◆ leftRing() [1/2]

IteratorRange_RingIterator_NextEdgeSameLeft meshlib.mrmeshpy.leftRing	(	MeshTopology	topology,
		FaceId	f )

◆ leftRing() [2/2]

IteratorRange_RingIterator_NextEdgeSameLeft meshlib.mrmeshpy.leftRing	(	MeshTopology	topology,
		Id_EdgeTag	edge )

to iterate over all edges with same left face as firstEdge (INCLUDING firstEdge)
for ( Edge e : leftRing( topology, firstEdge ) ) ...

◆ leftRing0()

IteratorRange_RingIterator_NextEdgeSameLeft meshlib.mrmeshpy.leftRing0	(	MeshTopology	topology,
		Id_EdgeTag	edge )

to iterate over all edges with same left face as firstEdge (EXCLUDING firstEdge)
for ( Edge e : leftRing0( topology, firstEdge ) ) ...

◆ loadASCIIStl() [1/2]

Mesh meshlib.mrmeshpy.loadASCIIStl	(	os.PathLike	file,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in textual .STL format

◆ loadASCIIStl() [2/2]

Mesh meshlib.mrmeshpy.loadASCIIStl	(	typing.Any	in_,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in textual .STL format

◆ loadBinaryStl() [1/2]

Mesh meshlib.mrmeshpy.loadBinaryStl	(	os.PathLike	file,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in binary .STL format

◆ loadBinaryStl() [2/2]

Mesh meshlib.mrmeshpy.loadBinaryStl	(	typing.Any	in_,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in binary .STL format;
important on Windows: in stream must be open in binary mode

◆ loadDistanceMapFromImage()

DistanceMap meshlib.mrmeshpy.loadDistanceMapFromImage	(	os.PathLike	filename,
		float	threshold = 0.003921568859368563 )

load distance map from a grayscale image file
    threshold - threshold of valid values [0.; 1.]. pixel with color less then threshold set invalid

◆ loadDxf() [1/2]

Mesh meshlib.mrmeshpy.loadDxf	(	os.PathLike	path,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in .DXF format;

◆ loadDxf() [2/2]

Mesh meshlib.mrmeshpy.loadDxf	(	typing.Any	in_,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in .DXF format;

◆ loadIOExtras()

None meshlib.mrmeshpy.loadIOExtras ( )

◆ loadLines() [1/2]

Polyline3 meshlib.mrmeshpy.loadLines	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

detects the format from file extension and loads polyline from it

◆ loadLines() [2/2]

Polyline3 meshlib.mrmeshpy.loadLines	(	typing.Any	in_,
		str	extension,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

extension in `*.ext` format

◆ loadMesh() [1/2]

Mesh meshlib.mrmeshpy.loadMesh	(	os.PathLike	file,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in the format detected from file extension

◆ loadMesh() [2/2]

Mesh meshlib.mrmeshpy.loadMesh	(	typing.Any	in_,
		str	extension,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in the format detected from given extension-string (`*.ext`);
important on Windows: in stream must be open in binary mode

◆ loadMeshDll()

None meshlib.mrmeshpy.loadMeshDll ( )

◆ loadMrmesh() [1/2]

Mesh meshlib.mrmeshpy.loadMrmesh	(	os.PathLike	file,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in internal MeshLib format

◆ loadMrmesh() [2/2]

Mesh meshlib.mrmeshpy.loadMrmesh	(	typing.Any	in_,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in internal MeshLib format;
important on Windows: in stream must be open in binary mode

◆ loadObj() [1/2]

Mesh meshlib.mrmeshpy.loadObj	(	os.PathLike	file,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in .OBJ format

◆ loadObj() [2/2]

Mesh meshlib.mrmeshpy.loadObj	(	typing.Any	in_,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in .OBJ format;
important on Windows: in stream must be open in binary mode

◆ loadObjectFromFile()

LoadedObjects meshlib.mrmeshpy.loadObjectFromFile	(	os.PathLike	filename,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

 \\brief load all objects (or any type: mesh, lines, points, voxels or scene) from file
 \\param callback - callback function to set progress (for progress bar)

◆ loadOff() [1/2]

Mesh meshlib.mrmeshpy.loadOff	(	os.PathLike	file,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in .OFF format

◆ loadOff() [2/2]

Mesh meshlib.mrmeshpy.loadOff	(	typing.Any	in_,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in .OFF format

◆ loadPly() [1/2]

Mesh meshlib.mrmeshpy.loadPly	(	os.PathLike	file,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in .PLY format;

◆ loadPly() [2/2]

Mesh meshlib.mrmeshpy.loadPly	(	typing.Any	in_,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in .PLY format;
important on Windows: in stream must be open in binary mode

◆ loadPoints() [1/2]

PointCloud meshlib.mrmeshpy.loadPoints	(	os.PathLike	file,
		PointsLoadSettings	settings = 'MR::PointsLoadSettings{}' )

detects the format from file extension and loads points from it

◆ loadPoints() [2/2]

PointCloud meshlib.mrmeshpy.loadPoints	(	typing.Any	in_,
		str	extension,
		PointsLoadSettings	settings = 'MR::PointsLoadSettings{}' )

extension in `*.ext` format

◆ loadSceneFromAnySupportedFormat()

LoadedObjectT meshlib.mrmeshpy.loadSceneFromAnySupportedFormat	(	os.PathLike	path,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

tries to load scene from every format listed in SceneFormatFilters

◆ loadSceneObject()

Object meshlib.mrmeshpy.loadSceneObject	(	os.PathLike	path,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

Detects the format from file extension and loads scene object from it.

◆ loadStl() [1/2]

Mesh meshlib.mrmeshpy.loadStl	(	os.PathLike	file,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from file in any .STL format: both binary and ASCII

◆ loadStl() [2/2]

Mesh meshlib.mrmeshpy.loadStl	(	typing.Any	in_,
		MeshLoadSettings	settings = 'MR::MeshLoadSettings{}' )

loads mesh from stream in any .STL format: both binary and ASCII;
important on Windows: in stream must be open in binary mode

◆ loadVoxels()

std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid meshlib.mrmeshpy.loadVoxels	(	os.PathLike	file,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Detects the format from file extension and loads voxels from it

◆ loadVoxelsGav() [1/2]

VdbVolume meshlib.mrmeshpy.loadVoxelsGav	(	os.PathLike	file,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Load voxel from Gav-file with micro CT reconstruction

◆ loadVoxelsGav() [2/2]

VdbVolume meshlib.mrmeshpy.loadVoxelsGav	(	typing.Any	in_,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Load voxel from Gav-stream with micro CT reconstruction

◆ loadVoxelsRaw() [1/3]

VdbVolume meshlib.mrmeshpy.loadVoxelsRaw	(	os.PathLike	file,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Load raw voxels file, parsing parameters from name

◆ loadVoxelsRaw() [2/3]

VdbVolume meshlib.mrmeshpy.loadVoxelsRaw	(	os.PathLike	file,
		VoxelsLoad.RawParameters	params,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Load raw voxels from file with provided parameters

◆ loadVoxelsRaw() [3/3]

VdbVolume meshlib.mrmeshpy.loadVoxelsRaw	(	typing.Any	in_,
		VoxelsLoad.RawParameters	params,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Load raw voxels from stream with provided parameters;
important on Windows: in stream must be open in binary mode

◆ localFindSelfIntersections()

FaceBitSet meshlib.mrmeshpy.localFindSelfIntersections	(	Mesh	mesh,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Find all self-intersections faces component-wise

◆ localFixSelfIntersections()

None meshlib.mrmeshpy.localFixSelfIntersections	(	Mesh	mesh,
		SelfIntersections.Settings	settings )

Finds and fixes self-intersections per component:

◆ makeArrow()

Mesh meshlib.mrmeshpy.makeArrow	(	Vector3f	base,
		Vector3f	vert,
		float	thickness = 0.05000000074505806,
		float	coneRadius = 0.10000000149011612,
		float	coneSize = 0.20000000298023224,
		int	qual = 32 )

creates hollow arrow from the 'base' to the 'vert'. Number of points on the circle 'qual' is between 3 and 256

◆ makeBasisAxes()

Mesh meshlib.mrmeshpy.makeBasisAxes	(	float	size = 1.0,
		float	thickness = 0.05000000074505806,
		float	coneRadius = 0.10000000149011612,
		float	coneSize = 0.20000000298023224,
		int	qual = 32 )

creates the mesh with 3 axis arrows

◆ makeBridge()

bool meshlib.mrmeshpy.makeBridge	(	MeshTopology	topology,
		Id_EdgeTag	a,
		Id_EdgeTag	b,
		FaceBitSet	outNewFaces = None )

creates a bridge between two boundary edges a and b (both having no valid left face);
bridge consists of two triangles in general or of one triangle if a and b are neighboring edges on the boundary;
\\return false if bridge cannot be created because otherwise multiple edges appear

◆ makeBridgeEdge()

Id_EdgeTag meshlib.mrmeshpy.makeBridgeEdge	(	MeshTopology	topology,
		Id_EdgeTag	a,
		Id_EdgeTag	b )

creates a new bridge edge between origins of two boundary edges a and b (both having no valid left face);
\\return invalid id if bridge cannot be created because otherwise multiple edges appear

◆ makeCone()

Mesh meshlib.mrmeshpy.makeCone	(	float	radius0 = 0.10000000149011612,
		float	length = 1.0,
		int	resolution = 32 )

Makes cone mesh by calling makeCylinderAdvanced with the top radius 0.

◆ makeConvexHull() [1/3]

Mesh meshlib.mrmeshpy.makeConvexHull ( Mesh in_ )

◆ makeConvexHull() [2/3]

Mesh meshlib.mrmeshpy.makeConvexHull ( PointCloud in_ )

◆ makeConvexHull() [3/3]

Mesh meshlib.mrmeshpy.makeConvexHull	(	VertCoords	points,
		VertBitSet	validPoints )

computes the mesh of convex hull from given input points

◆ makeCube()

Mesh meshlib.mrmeshpy.makeCube	(	Vector3f	size = 'Vector3f::diagonal(1.F)',
		Vector3f	base = 'Vector3f::diagonal(-0.5F)' )

Base is "lower" corner of the cube coordinates

◆ makeCylinder()

Mesh meshlib.mrmeshpy.makeCylinder	(	float	radius = 0.10000000149011612,
		float	length = 1.0,
		int	resolution = 16 )

Draws cylinder with radius 'radius', height - 'length', its base have 'resolution' sides

◆ makeCylinderAdvanced()

Mesh meshlib.mrmeshpy.makeCylinderAdvanced	(	float	radius0 = 0.10000000149011612,
		float	radius1 = 0.10000000149011612,
		float	start_angle = 0.0,
		float	arc_size = 6.2831854820251465,
		float	length = 1.0,
		int	resolution = 16 )

◆ makeDegenerateBandAroundHole()

Id_EdgeTag meshlib.mrmeshpy.makeDegenerateBandAroundHole	(	Mesh	mesh,
		Id_EdgeTag	a,
		FaceBitSet	outNewFaces = None )

creates a band of degenerate triangles around given hole;
\\return the edge of new hole opposite to input edge (a)

◆ makeDegenerateBandAroundRegion()

None meshlib.mrmeshpy.makeDegenerateBandAroundRegion	(	Mesh	mesh,
		FaceBitSet	region,
		MakeDegenerateBandAroundRegionParams	params = 'MR::MakeDegenerateBandAroundRegionParams{}' )

 \\brief Create a band of degenerate faces along the border of the specified region and the rest of the mesh
 \\details The function is useful for extruding the region without changing the existing faces and creating holes

 @param mesh - the target mesh
 @param region - the region required to be separated by a band of degenerate faces
 @param params - optional output parameters

◆ makeDeloneEdgeFlips()

int meshlib.mrmeshpy.makeDeloneEdgeFlips	(	Mesh	mesh,
		DeloneSettings	settings = 'MR::DeloneSettings{}',
		int	numIters = 1,
		func_bool_from_float	progressCallback = 'MR::ProgressCallback{}' )

improves mesh triangulation by performing flipping of edges to satisfy Delone local property,
consider every edge at most numIters times, and allow surface deviation at most on given value during every individual flip,
\\return the number of flips done
\\param numIters Maximal iteration count
\\param progressCallback Callback to report algorithm progress and cancel it by user request

◆ makeDeloneOriginRing()

None meshlib.mrmeshpy.makeDeloneOriginRing	(	Mesh	mesh,
		Id_EdgeTag	e,
		DeloneSettings	settings = 'MR::DeloneSettings{}' )

improves mesh triangulation in a ring of vertices with common origin and represented by edge e

◆ makeFreeFormOriginGrid()

std_vector_Vector3_float meshlib.mrmeshpy.makeFreeFormOriginGrid	(	Box3f	box,
		Vector3i	resolution )

Returns positions of grid points in given box with given resolution

◆ makeLevelOfDetails()

Object meshlib.mrmeshpy.makeLevelOfDetails	(	Mesh	mesh,
		int	maxDepth )

divides given mesh into hierarchy of mesh objects:
the deepest level of the hierarchy has all details from the original mesh;
top levels have progressively less number of objects and less details in each;
the number of faces in any object on any level is about the same.

◆ makeMovementBuildBody()

Mesh meshlib.mrmeshpy.makeMovementBuildBody	(	std_vector_std_vector_Vector3_float	body,
		std_vector_std_vector_Vector3_float	trajectory,
		MovementBuildBodyParams	params = 'MR::MovementBuildBodyParams{}' )

makes mesh by moving `body` along `trajectory`
if allowRotation rotate it in corners

◆ makeNormals()

VertCoords meshlib.mrmeshpy.makeNormals	(	PointCloud	pointCloud,
		int	avgNeighborhoodSize = 48 )

\\brief Makes consistent normals for valid points of given point cloud
\\param avgNeighborhoodSize avg num of neighbors of each individual point
\\ingroup PointCloudGroup
[[deprecated( "use makeOrientedNormals(...) instead" )]]

◆ makeObjectDistanceMapFromFile()

ObjectDistanceMap meshlib.mrmeshpy.makeObjectDistanceMapFromFile	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

loads distance map from given file in new object

◆ makeObjectFromMeshFile()

LoadedObjectT meshlib.mrmeshpy.makeObjectFromMeshFile	(	os.PathLike	file,
		func_bool_from_float	cb = 'MR::ProgressCallback{}',
		bool	returnOnlyMesh = False )

loads data from given file and makes either ObjectMesh or ObjectPoints (if the file has points but not faces)

◆ makeObjectFromVoxelsFile()

LoadedObjects meshlib.mrmeshpy.makeObjectFromVoxelsFile	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ makeObjectGcodeFromFile()

ObjectGcode meshlib.mrmeshpy.makeObjectGcodeFromFile	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

loads gcode from given file in new object

◆ makeObjectLinesFromFile()

ObjectLines meshlib.mrmeshpy.makeObjectLinesFromFile	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

loads lines from given file in new object

◆ makeObjectMeshFromFile()

LoadedObjectT_ObjectMesh meshlib.mrmeshpy.makeObjectMeshFromFile	(	os.PathLike	file,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

loads mesh from given file in new object

◆ makeObjectPointsFromFile()

ObjectPoints meshlib.mrmeshpy.makeObjectPointsFromFile	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

loads points from given file in new object

◆ makeObjectVoxelsFromFile()

std_vector_std_shared_ptr_ObjectVoxels meshlib.mrmeshpy.makeObjectVoxelsFromFile	(	os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

loads voxels from given file in new object

◆ makeOpenCone()

Mesh meshlib.mrmeshpy.makeOpenCone	(	float	radius = 1,
		float	zApex = 0,
		float	zBase = 1,
		int	numCircleSegments = 16 )

A hollow cone.

◆ makeOpenCylinder()

Mesh meshlib.mrmeshpy.makeOpenCylinder	(	float	radius = 1,
		float	z1 = -1,
		float	z2 = 1,
		int	numCircleSegments = 16 )

A hollow cylinder.

◆ makeOrientedNormals() [1/2]

VertCoords meshlib.mrmeshpy.makeOrientedNormals	(	PointCloud	pointCloud,
		AllLocalTriangulations	triangs,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

\\brief Makes normals for valid points of given point cloud; directions of close points are selected to be consistent;
\\triangs triangulation neighbours of each point, which are oriented during the call as well
\\return nullopt if progress returned false
\\ingroup PointCloudGroup

◆ makeOrientedNormals() [2/2]

VertCoords meshlib.mrmeshpy.makeOrientedNormals	(	PointCloud	pointCloud,
		float	radius,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

\\brief Makes normals for valid points of given point cloud; directions of close points are selected to be consistent;
\\param radius of neighborhood to consider
\\return nullopt if progress returned false
\\ingroup PointCloudGroup

◆ makeOuterHalfTorus()

Mesh meshlib.mrmeshpy.makeOuterHalfTorus	(	float	primaryRadius = 1.0,
		float	secondaryRadius = 0.10000000149011612,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std_vector_Vector3_float	points = None )

creates torus without inner half faces
main application - testing fillHole and Stitch

◆ makeParallelepiped()

Mesh meshlib.mrmeshpy.makeParallelepiped	(	Vector3f	side,
		Vector3f	base )

◆ makePlane()

Mesh meshlib.mrmeshpy.makePlane ( )

Makes square plane 1x1 size with center at (0,0,0) and (0,0,1) normal

◆ makePrism()

Mesh meshlib.mrmeshpy.makePrism	(	float	baseLength,
		float	leftAngle,
		float	rightAngle,
		float	height = 1.0 )

Creates a triangular prism. One edge of its base lies on 'x' axis and has 'baseLength' in length. 
'leftAngle' and 'rightAngle' specify two adjacent angles
 axis of a prism is parallel to 'z' axis

◆ makeRegularGridMesh() [1/2]

Mesh meshlib.mrmeshpy.makeRegularGridMesh	(	int	width,
		int	height,
		func_bool_from_unsigned_long_unsigned_long	validator,
		func_Vector3_float_from_unsigned_long_unsigned_long	positioner,
		func_bool_from_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long	faceValidator = 'MR::RegularGridMeshFaceValidator{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Creates regular mesh with points in valid grid lattice

◆ makeRegularGridMesh() [2/2]

Mesh meshlib.mrmeshpy.makeRegularGridMesh	(	VertCoords	pc,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Creates regular mesh from monotone (connects point with closed x, y neighbors) points

◆ makeRigidXf() [1/2]

AffineXf3d meshlib.mrmeshpy.makeRigidXf	(	MeshPart	mp,
		AffineXf3d	meshXf )

given a mesh part and its arbitrary transformation, computes and returns
the rigid transformation that best approximates meshXf
\\ingroup MathGroup

◆ makeRigidXf() [2/2]

AffineXf3f meshlib.mrmeshpy.makeRigidXf	(	MeshPart	mp,
		AffineXf3f	meshXf )

◆ makeSignedByWindingNumber()

None meshlib.mrmeshpy.makeSignedByWindingNumber	(	OpenVdbFloatGrid	grid,
		Vector3f	voxelSize,
		Mesh	refMesh,
		MakeSignedByWindingNumberSettings	settings )

set signs for unsigned distance field grid using generalized winding number computed at voxel grid point from refMesh

◆ makeSphere()

Mesh meshlib.mrmeshpy.makeSphere ( SphereParams params )

creates a mesh of sphere with irregular triangulation

◆ makeSpline() [1/2]

MarkedContour3f meshlib.mrmeshpy.makeSpline	(	MarkedContour3f	in_,
		float	markStability = 1 )

\\param in input marked contour
\\param markStability a positive value, the more the value the closer marked points will be to their original positions
\\return contour with same number of points and same marked, where each return point tries to be on a smooth curve

◆ makeSpline() [2/2]

MarkedContour3f meshlib.mrmeshpy.makeSpline	(	std_vector_Vector3_float	controlPoints,
		SplineSettings	settings )

\\param controlPoints ordered point the spline to interpolate
\\return spline contour with same or more points than initially given, marks field highlights the points corresponding to input ones

◆ makeTorus()

Mesh meshlib.mrmeshpy.makeTorus	(	float	primaryRadius = 1.0,
		float	secondaryRadius = 0.10000000149011612,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std_vector_Vector3_float	points = None )

Z is symmetry axis of this torus
points - optional out points of main circle

◆ makeTorusWithComponents()

Mesh meshlib.mrmeshpy.makeTorusWithComponents	(	float	primaryRadius = 1.0,
		float	secondaryRadius = 0.10000000149011612,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std_vector_Vector3_float	points = None )

creates torus with empty sectors
main application - testing Components

◆ makeTorusWithSelfIntersections()

Mesh meshlib.mrmeshpy.makeTorusWithSelfIntersections	(	float	primaryRadius = 1.0,
		float	secondaryRadius = 0.10000000149011612,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std_vector_Vector3_float	points = None )

creates torus with empty sectors
main application - testing Components

◆ makeTorusWithSpikes()

Mesh meshlib.mrmeshpy.makeTorusWithSpikes	(	float	primaryRadius = 1.0,
		float	secondaryRadiusInner = 0.10000000149011612,
		float	secondaryRadiusOuter = 0.5,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std_vector_Vector3_float	points = None )

creates torus with some handed-up points
main application - testing fixSpikes and Relax

◆ makeTorusWithUndercut()

Mesh meshlib.mrmeshpy.makeTorusWithUndercut	(	float	primaryRadius = 1.0,
		float	secondaryRadiusInner = 0.10000000149011612,
		float	secondaryRadiusOuter = 0.20000000298023224,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std_vector_Vector3_float	points = None )

creates torus with inner protruding half as undercut
main application - testing fixUndercuts

◆ makeUniformSampledCloud()

PointCloud meshlib.mrmeshpy.makeUniformSampledCloud	(	PointCloud	pointCloud,
		UniformSamplingSettings	settings )

Composes new point cloud consisting of uniform samples of original point cloud;
returns std::nullopt if it was terminated by the callback
\\ingroup PointCloudGroup

◆ makeUnorientedNormals() [1/3]

VertCoords meshlib.mrmeshpy.makeUnorientedNormals	(	PointCloud	pointCloud,
		AllLocalTriangulations	triangs,
		func_bool_from_float	progress = 'MR::ProgressCallback{}',
		OrientNormals	orient = 'OrientNormals::Smart' )

\\brief Makes normals for valid points of given point cloud by averaging neighbor triangle normals weighted by triangle's angle
\\triangs triangulation neighbours of each point
\\param orient OrientNormals::Smart here means orientation from normals of neigbour triangles
\\return nullopt if progress returned false
\\ingroup PointCloudGroup

◆ makeUnorientedNormals() [2/3]

VertCoords meshlib.mrmeshpy.makeUnorientedNormals	(	PointCloud	pointCloud,
		Buffer_VertId	closeVerts,
		int	numNei,
		func_bool_from_float	progress = 'MR::ProgressCallback{}',
		OrientNormals	orient = 'OrientNormals::Smart' )

\\brief Makes normals for valid points of given point cloud by directing them along the normal of best plane through the neighbours
\\param closeVerts a buffer where for every valid point #i its neighbours are stored at indices [i*numNei; (i+1)*numNei)
\\param orient OrientNormals::Smart here means orientation from best fit plane
\\return nullopt if progress returned false
\\ingroup PointCloudGroup

◆ makeUnorientedNormals() [3/3]

VertCoords meshlib.mrmeshpy.makeUnorientedNormals	(	PointCloud	pointCloud,
		float	radius,
		func_bool_from_float	progress = 'MR::ProgressCallback{}',
		OrientNormals	orient = 'OrientNormals::Smart' )

\\brief Makes normals for valid points of given point cloud by directing them along the normal of best plane through the neighbours
\\param radius of neighborhood to consider
\\param orient OrientNormals::Smart here means orientation from best fit plane
\\return nullopt if progress returned false
\\ingroup PointCloudGroup

◆ makeUVSphere()

Mesh meshlib.mrmeshpy.makeUVSphere	(	float	radius = 1.0,
		int	horisontalResolution = 16,
		int	verticalResolution = 16 )

creates a mesh of sphere with regular triangulation (parallels and meridians)

◆ makeVdbTopologyDense()

None meshlib.mrmeshpy.makeVdbTopologyDense ( VdbVolume volume )

Make \\p volume dense without setting any values

◆ mapEdge() [1/3]

Id_EdgeTag meshlib.mrmeshpy.mapEdge	(	phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag	map,
		Id_EdgeTag	src )

given input edge (src), converts its id using given map

◆ mapEdge() [2/3]

UndirectedEdgeId meshlib.mrmeshpy.mapEdge	(	UndirectedEdgeBMap	map,
		UndirectedEdgeId	src )

given input edge (src), converts its id using given map

◆ mapEdge() [3/3]

Id_EdgeTag meshlib.mrmeshpy.mapEdge	(	WholeEdgeMap	map,
		Id_EdgeTag	src )

given input edge (src), converts its id using given map

◆ mapEdges() [1/3]

UndirectedEdgeBitSet meshlib.mrmeshpy.mapEdges	(	phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag	map,
		UndirectedEdgeBitSet	src )

given input bit-set (src), converts each id corresponding to set bit using given map, and sets its bit in the resulting bit set

◆ mapEdges() [2/3]

UndirectedEdgeBitSet meshlib.mrmeshpy.mapEdges	(	UndirectedEdgeBMap	map,
		UndirectedEdgeBitSet	src )

given input bit-set (src), converts each id corresponding to set bit using given map, and sets its bit in the resulting bit set

◆ mapEdges() [3/3]

UndirectedEdgeBitSet meshlib.mrmeshpy.mapEdges	(	WholeEdgeMap	map,
		UndirectedEdgeBitSet	src )

given input bit-set (src), converts each id corresponding to set bit using given map, and sets its bit in the resulting bit set

◆ marchingCubes() [1/4]

Mesh meshlib.mrmeshpy.marchingCubes	(	FunctionVolume	volume,
		MarchingCubesParams	params = 'MR::MarchingCubesParams{}' )

makes Mesh from FunctionVolume with given settings using Marching Cubes algorithm

◆ marchingCubes() [2/4]

Mesh meshlib.mrmeshpy.marchingCubes	(	SimpleVolume	volume,
		MarchingCubesParams	params = 'MR::MarchingCubesParams{}' )

makes Mesh from SimpleVolume with given settings using Marching Cubes algorithm

◆ marchingCubes() [3/4]

Mesh meshlib.mrmeshpy.marchingCubes	(	SimpleVolumeMinMax	volume,
		MarchingCubesParams	params = 'MR::MarchingCubesParams{}' )

makes Mesh from SimpleVolumeMinMax with given settings using Marching Cubes algorithm

◆ marchingCubes() [4/4]

Mesh meshlib.mrmeshpy.marchingCubes	(	VdbVolume	volume,
		MarchingCubesParams	params = 'MR::MarchingCubesParams{}' )

makes Mesh from VdbVolume with given settings using Marching Cubes algorithm

◆ marchingCubesAsTriMesh() [1/4]

TriMesh meshlib.mrmeshpy.marchingCubesAsTriMesh	(	FunctionVolume	volume,
		MarchingCubesParams	params = 'MR::MarchingCubesParams{}' )

◆ marchingCubesAsTriMesh() [2/4]

TriMesh meshlib.mrmeshpy.marchingCubesAsTriMesh	(	SimpleVolume	volume,
		MarchingCubesParams	params = 'MR::MarchingCubesParams{}' )

◆ marchingCubesAsTriMesh() [3/4]

TriMesh meshlib.mrmeshpy.marchingCubesAsTriMesh	(	SimpleVolumeMinMax	volume,
		MarchingCubesParams	params = 'MR::MarchingCubesParams{}' )

◆ marchingCubesAsTriMesh() [4/4]

TriMesh meshlib.mrmeshpy.marchingCubesAsTriMesh	(	VdbVolume	volume,
		MarchingCubesParams	params = 'MR::MarchingCubesParams{}' )

◆ markedContour()

MarkedContour3f meshlib.mrmeshpy.markedContour ( std_vector_Vector3_float in_ )

\\return marked contour with all points from (in) marked

◆ markedFirstLast()

MarkedContour3f meshlib.mrmeshpy.markedFirstLast ( std_vector_Vector3_float in_ )

\\return marked contour with only first and last points from (in) marked

◆ mcOffsetMesh()

Mesh meshlib.mrmeshpy.mcOffsetMesh	(	MeshPart	mp,
		float	offset,
		OffsetParameters	params = 'MR::OffsetParameters{}',
		Vector_Id_VoxelTag_FaceId	outMap = None )

Offsets mesh by converting it to distance field in voxels (using OpenVDB library if SignDetectionMode::OpenVDB or our implementation otherwise)
and back using standard Marching Cubes, as opposed to Dual Marching Cubes in offsetMesh(...)

◆ mcShellMeshRegion()

Mesh meshlib.mrmeshpy.mcShellMeshRegion	(	Mesh	mesh,
		FaceBitSet	region,
		float	offset,
		BaseShellParameters	params,
		Vector_Id_VoxelTag_FaceId	outMap = None )

Constructs a shell around selected mesh region with the properties that every point on the shall must
 1. be located not further than given distance from selected mesh part,
 2. be located not closer to not-selected mesh part than to selected mesh part.

◆ merge() [1/3]

ObjectLines meshlib.mrmeshpy.merge ( std_vector_std_shared_ptr_ObjectLines objsLines )

constructs new ObjectLines containing the union of valid data from all input objects

◆ merge() [2/3]

ObjectMesh meshlib.mrmeshpy.merge ( std_vector_std_shared_ptr_ObjectMesh objsMesh )

constructs new ObjectMesh containing the union of valid data from all input objects

◆ merge() [3/3]

ObjectPoints meshlib.mrmeshpy.merge ( std_vector_std_shared_ptr_ObjectPoints objsPoints )

constructs new ObjectPoints containing the union of valid points from all input objects

◆ mergeMeshes()

Mesh meshlib.mrmeshpy.mergeMeshes ( std_vector_std_shared_ptr_Mesh meshes )

Merge a list of meshes to one mesh.

◆ meshDenoiseViaNormals()

None meshlib.mrmeshpy.meshDenoiseViaNormals	(	Mesh	mesh,
		DenoiseViaNormalsSettings	settings = 'MR::DenoiseViaNormalsSettings{}' )

Reduces noise in given mesh,
see the article "Mesh Denoising via a Novel Mumford-Shah Framework"

◆ meshFromVoxelsMask()

Mesh meshlib.mrmeshpy.meshFromVoxelsMask	(	VdbVolume	volume,
		VoxelBitSet	mask )

 \\brief Creates mesh from voxels mask
 \\param mask in space of whole volume
  density inside mask is expected to be higher then outside

◆ meshOnEdgeSplitAttribute()

func_void_from_Id_EdgeTag_Id_EdgeTag meshlib.mrmeshpy.meshOnEdgeSplitAttribute	(	Mesh	mesh,
		MeshAttributesToUpdate	params )

 auto uvCoords = obj_->getUVCoords();
 auto texturePerFace = obj_->getTexturePerFace();
 MeshAttributesToUpdate meshParams;
 if ( !uvCoords.empty() )
     meshParams.uvCoords = &uvCoords;
 if ( !texturePerFace.empty() )
     meshParams.texturePerFace = &texturePerFace;
 subs.onEdgeSplit = meshOnEdgeSplitAttribute( *obj_->varMesh(), meshParams );
 subdivideMesh( *obj_->varMesh(), subs );

◆ meshOnEdgeSplitFaceAttribute()

func_void_from_Id_EdgeTag_Id_EdgeTag meshlib.mrmeshpy.meshOnEdgeSplitFaceAttribute	(	Mesh	mesh,
		MeshAttributesToUpdate	params )

◆ meshOnEdgeSplitVertAttribute()

func_void_from_Id_EdgeTag_Id_EdgeTag meshlib.mrmeshpy.meshOnEdgeSplitVertAttribute	(	Mesh	mesh,
		MeshAttributesToUpdate	params )

◆ meshPreCollapseVertAttribute()

func_bool_from_Id_EdgeTag_Vector3_float meshlib.mrmeshpy.meshPreCollapseVertAttribute	(	Mesh	mesh,
		MeshAttributesToUpdate	params )

 Please use this callback when you decimate a mesh with associated data with each vertex
 recalculate texture coordinates and mesh vertex colors for vertices moved during decimation
 usage example
   MeshAttributesToUpdate meshParams;
   auto uvCoords = obj->getUVCoords();
   auto colorMap = obj->getVertsColorMap();
   if ( needUpdateUV )
       meshParams.uvCoords = &uvCoords;
   if ( needUpdateColorMap )
       meshParams.colorMap = &colorMap;
   auto preCollapse = meshPreCollapseVertAttribute( mesh, meshParams );
   decimateMesh( mesh, DecimateSettings{ .preCollapse = preCollapse } );

◆ meshRegionToIndicatorVolume()

SimpleVolumeMinMax meshlib.mrmeshpy.meshRegionToIndicatorVolume	(	Mesh	mesh,
		FaceBitSet	region,
		float	offset,
		DistanceVolumeParams	params )

returns a volume filled with the values:
v < 0: this point is within offset distance to region-part of mesh and it is closer to region-part than to not-region-part

◆ meshToDirectionVolume()

std_array_VoxelsVolumeMinMax_std_vector_float_3 meshlib.mrmeshpy.meshToDirectionVolume ( MeshToDirectionVolumeParams params )

Converts mesh into 4d voxels, so that each cell in 3d space holds the direction from the closest point on mesh to the cell position.
Resulting volume is encoded by 3 separate 3d volumes, corresponding to `x`, `y` and `z` components of vectors respectively.
\\param params Expected to have valid (not null) projector, with invoked method \\ref IPointsToMeshProjector::updateMeshData

◆ meshToDistanceField()

OpenVdbFloatGrid meshlib.mrmeshpy.meshToDistanceField	(	MeshPart	mp,
		AffineXf3f	xf,
		Vector3f	voxelSize,
		float	surfaceOffset = 3,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

does not require closed surface, resulting grid cannot be used for boolean operations,
surfaceOffset - the number of voxels around surface to calculate distance in (should be positive)
returns null if was canceled by progress callback

◆ meshToDistanceFunctionVolume()

FunctionVolume meshlib.mrmeshpy.meshToDistanceFunctionVolume	(	MeshPart	mp,
		MeshToDistanceVolumeParams	params = 'MR::MeshToDistanceVolumeParams{}' )

makes FunctionVolume representing (signed or unsigned) distances from Mesh with given settings

◆ meshToDistanceVolume()

SimpleVolumeMinMax meshlib.mrmeshpy.meshToDistanceVolume	(	MeshPart	mp,
		MeshToDistanceVolumeParams	params = 'MR::MeshToDistanceVolumeParams{}' )

makes SimpleVolume filled with (signed or unsigned) distances from Mesh with given settings

◆ meshToLevelSet()

OpenVdbFloatGrid meshlib.mrmeshpy.meshToLevelSet	(	MeshPart	mp,
		AffineXf3f	xf,
		Vector3f	voxelSize,
		float	surfaceOffset = 3,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

closed surface is required
surfaceOffset - number voxels around surface to calculate distance in (should be positive)
returns null if was canceled by progress callback

◆ meshToPointCloud()

PointCloud meshlib.mrmeshpy.meshToPointCloud	(	Mesh	mesh,
		bool	saveNormals = True,
		VertBitSet	verts = None )

Mesh to PointCloud
\\ingroup MeshAlgorithmGroup

◆ meshToVolume()

VdbVolume meshlib.mrmeshpy.meshToVolume	(	Mesh	mesh,
		MeshToVolumeParams	params = 'MR::MeshToVolumeParams{}' )

convert mesh to volume in (0,0,0)-(dim.x,dim.y,dim.z) grid box

◆ mixed() [1/3]

float meshlib.mrmeshpy.mixed	(	Vector3d	a,
		Vector3d	b,
		Vector3d	c )

mixed product

◆ mixed() [2/3]

float meshlib.mrmeshpy.mixed	(	Vector3f	a,
		Vector3f	b,
		Vector3f	c )

mixed product

◆ mixed() [3/3]

int meshlib.mrmeshpy.mixed	(	Vector3i	a,
		Vector3i	b,
		Vector3i	c )

mixed product

◆ moveMeshToVoxelMaxDeriv()

VertBitSet meshlib.mrmeshpy.moveMeshToVoxelMaxDeriv	(	Mesh	mesh,
		AffineXf3f	meshXf,
		VdbVolume	volume,
		AffineXf3f	volumeXf,
		MoveMeshToVoxelMaxDerivSettings	settings,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

Moves each vertex along its normal to the minimize (with sign, i.e. maximize the absolute value with negative sign) the derivative
of voxels.
\\ingroup SubvoxelMeshCorrection
@return Vertices that were moved by the algorithm

◆ mult() [1/6]

Vector2d meshlib.mrmeshpy.mult	(	Vector2d	a,
		Vector2d	b )

per component multiplication

◆ mult() [2/6]

Vector2f meshlib.mrmeshpy.mult	(	Vector2f	a,
		Vector2f	b )

per component multiplication

◆ mult() [3/6]

Vector2i meshlib.mrmeshpy.mult	(	Vector2i	a,
		Vector2i	b )

per component multiplication

◆ mult() [4/6]

Vector3d meshlib.mrmeshpy.mult	(	Vector3d	a,
		Vector3d	b )

per component multiplication

◆ mult() [5/6]

Vector3f meshlib.mrmeshpy.mult	(	Vector3f	a,
		Vector3f	b )

per component multiplication

◆ mult() [6/6]

Vector3i meshlib.mrmeshpy.mult	(	Vector3i	a,
		Vector3i	b )

per component multiplication

◆ multiModelGridSampling()

std_vector_ObjVertId meshlib.mrmeshpy.multiModelGridSampling	(	Vector_ModelPointsData_ObjId	models,
		float	voxelSize,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

performs sampling of several models respecting their world transformations
subdivides models bounding box on voxels of approximately given size and returns at most one point per voxel;
returns std::nullopt if it was terminated by the callback

◆ multiRayMeshIntersect()

None meshlib.mrmeshpy.multiRayMeshIntersect	(	MeshPart	meshPart,
		std_vector_Vector3_float	origins,
		std_vector_Vector3_float	dirs,
		MultiRayMeshIntersectResult	result,
		float	rayStart = 0.0,
		float	rayEnd = 3.4028234663852886e+38,
		bool	closestIntersect = True,
		func_bool_from_Id_FaceTag	validFaces = 'MR::FacePredicate{}' )

Finds intersections between a mesh and multiple rays in parallel (in float-precision).
\\p rayStart and \\p rayEnd define the interval on all rays to detect an intersection.
\\p vadidFaces if given then all faces for which false is returned will be skipped

◆ objectHasSelectableChildren()

bool meshlib.mrmeshpy.objectHasSelectableChildren ( Object object )

\\}

◆ objectSave()

None meshlib.mrmeshpy.objectSave	(	Object	object,
		os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

save a scene object to a given file
if the file format is scene-capable, saves all the object's entities
otherwise, saves only merged entities of the corresponding type (mesh, polyline, point cloud, etc.)

◆ offsetContours() [1/4]

std_vector_std_vector_Vector2_float meshlib.mrmeshpy.offsetContours	(	std_vector_std_vector_Vector2_float	contours,
		float	offset,
		OffsetContoursParams	params = 'MR::OffsetContoursParams{}' )

offsets 2d contours in plane

◆ offsetContours() [2/4]

std_vector_std_vector_Vector2_float meshlib.mrmeshpy.offsetContours	(	std_vector_std_vector_Vector2_float	contours,
		func_float_from_int_int	offset,
		OffsetContoursParams	params = 'MR::OffsetContoursParams{}' )

offsets 2d contours in plane

◆ offsetContours() [3/4]

std_vector_std_vector_Vector3_float meshlib.mrmeshpy.offsetContours	(	std_vector_std_vector_Vector3_float	contours,
		float	offset,
		OffsetContoursParams	params = 'MR::OffsetContoursParams{}',
		OffsetContoursRestoreZParams	zParmas = 'MR::OffsetContoursRestoreZParams{}' )

offsets 3d contours in XY plane

◆ offsetContours() [4/4]

std_vector_std_vector_Vector3_float meshlib.mrmeshpy.offsetContours	(	std_vector_std_vector_Vector3_float	contours,
		func_float_from_int_int	offset,
		OffsetContoursParams	params = 'MR::OffsetContoursParams{}',
		OffsetContoursRestoreZParams	zParmas = 'MR::OffsetContoursRestoreZParams{}' )

offsets 3d contours in XY plane

◆ offsetMesh()

Mesh meshlib.mrmeshpy.offsetMesh	(	MeshPart	mp,
		float	offset,
		OffsetParameters	params = 'MR::OffsetParameters{}' )

Offsets mesh by converting it to distance field in voxels using OpenVDB library,
signDetectionMode = Unsigned(from OpenVDB) | OpenVDB | HoleWindingRule,
and then converts back using OpenVDB library (dual marching cubes),
so result mesh is always closed

◆ offsetOneDirection()

Mesh meshlib.mrmeshpy.offsetOneDirection	(	MeshPart	mp,
		float	offset,
		GeneralOffsetParameters	params = 'MR::GeneralOffsetParameters{}' )

offsets given MeshPart in one direction only (positive or negative)
if your input mesh is open then please specify params.signDetectionMode = SignDetectionMode::Unsigned
if your input mesh is closed this function is equivalent to `generalOffsetMesh`, but in SignDetectionMode::Unsigned mode it will only keep one side (just like for open mesh)
unlike `thickenMesh` this functions does not keep original mesh in result

◆ offsetPolyline()

Mesh meshlib.mrmeshpy.offsetPolyline	(	Polyline3	polyline,
		float	offset,
		OffsetParameters	params = 'MR::OffsetParameters{}' )

Offsets polyline by converting it to voxels and building iso-surface
do offset in all directions
so result mesh is always closed
params.signDetectionMode is ignored (always assumed SignDetectionMode::Unsigned)

◆ OpenDocument()

bool meshlib.mrmeshpy.OpenDocument ( os.PathLike path )

Opens given file (or directory) in associated application

◆ OpenLink()

None meshlib.mrmeshpy.OpenLink ( str url )

Opens given link in default browser

◆ operator()

bool meshlib.mrmeshpy.operator	(	VertDistance	a,
		VertDistance	b )

smaller distance to be the first

◆ opposite() [1/2]

OutEdge meshlib.mrmeshpy.opposite ( OutEdge e )

◆ opposite() [2/2]

OutEdge2 meshlib.mrmeshpy.opposite ( OutEdge2 e )

◆ orderIntersectionContours()

std_vector_std_vector_VariableEdgeTri meshlib.mrmeshpy.orderIntersectionContours	(	MeshTopology	topologyA,
		MeshTopology	topologyB,
		PreciseCollisionResult	intersections )

Combines individual intersections into ordered contours with the properties:
a. left  of contours on mesh A is inside of mesh B,
b. right of contours on mesh B is inside of mesh A,
c. each intersected edge has origin inside meshes intersection and destination outside of it

◆ orgRing() [1/2]

IteratorRange_RingIterator_NextEdgeSameOrigin meshlib.mrmeshpy.orgRing	(	MeshTopology	topology,
		Id_EdgeTag	edge )

to iterate over all edges with same origin vertex  as firstEdge (INCLUDING firstEdge)
for ( Edge e : orgRing( topology, firstEdge ) ) ...

◆ orgRing() [2/2]

IteratorRange_RingIterator_NextEdgeSameOrigin meshlib.mrmeshpy.orgRing	(	MeshTopology	topology,
		VertId	v )

◆ orgRing0()

IteratorRange_RingIterator_NextEdgeSameOrigin meshlib.mrmeshpy.orgRing0	(	MeshTopology	topology,
		Id_EdgeTag	edge )

to iterate over all edges with same origin vertex as firstEdge (EXCLUDING firstEdge)
for ( Edge e : orgRing0( topology, firstEdge ) ) ...

◆ orient3d() [1/4]

bool meshlib.mrmeshpy.orient3d ( PreciseVertCoords vs )

◆ orient3d() [2/4]

bool meshlib.mrmeshpy.orient3d ( std_array_PreciseVertCoords_4 vs )

first sorts the indices in ascending order, then calls the predicate for sorted points

◆ orient3d() [3/4]

bool meshlib.mrmeshpy.orient3d	(	Vector3i	a,
		Vector3i	b,
		Vector3i	c )

returns true if the plane with orientated triangle ABC has 0 point at the left;
uses simulation-of-simplicity to avoid "0 is exactly on plane"

◆ orient3d() [4/4]

bool meshlib.mrmeshpy.orient3d	(	Vector3i	a,
		Vector3i	b,
		Vector3i	c,
		Vector3i	d )

returns true if the plane with orientated triangle ABC has D point at the left;
uses simulation-of-simplicity to avoid "D is exactly on plane"

◆ orientLocalTriangulations() [1/2]

None meshlib.mrmeshpy.orientLocalTriangulations	(	AllLocalTriangulations	triangs,
		VertCoords	coords,
		VertBitSet	region,
		func_Vector3_float_from_Id_VertTag	targetDir )

◆ orientLocalTriangulations() [2/2]

None meshlib.mrmeshpy.orientLocalTriangulations	(	AllLocalTriangulations	triangs,
		VertCoords	coords,
		VertBitSet	region,
		VertCoords	targetDir )

orient neighbors around each point in \\param region so they will be in clockwise order if look from the tip of target direction

◆ orientNormals() [1/3]

bool meshlib.mrmeshpy.orientNormals	(	PointCloud	pointCloud,
		VertCoords	normals,
		AllLocalTriangulations	triangs,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

\\brief Select orientation of given normals to make directions of close points consistent;
\\param radius of neighborhood to consider
\\return false if progress returned false
Unlike simple orientNormals this method constructs local triangulations around each point
(with most neighbours within given radius and all neighbours within 2*radius)
and considers all triangulation neighbors and not other points from the ball around each point.
\\ingroup PointCloudGroup

◆ orientNormals() [2/3]

bool meshlib.mrmeshpy.orientNormals	(	PointCloud	pointCloud,
		VertCoords	normals,
		Buffer_VertId	closeVerts,
		int	numNei,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

\\brief Select orientation of given normals to make directions of close points consistent;
\\param closeVerts a buffer where for every valid point #i its neighbours are stored at indices [i*numNei; (i+1)*numNei)
\\return false if progress returned false
\\ingroup PointCloudGroup

◆ orientNormals() [3/3]

bool meshlib.mrmeshpy.orientNormals	(	PointCloud	pointCloud,
		VertCoords	normals,
		float	radius,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

\\brief Select orientation of given normals to make directions of close points consistent;
\\param radius of neighborhood to consider
\\return false if progress returned false
\\ingroup PointCloudGroup

◆ pack()

ObjectPoints meshlib.mrmeshpy.pack	(	ObjectPoints	pts,
		Reorder	reorder,
		VertBitSet	newValidVerts = None,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

constructs new ObjectPoints containing the packed version of input points,
\\param newValidVerts if given, then use them instead of valid points from pts
\\return nullptr if the operation was cancelled

◆ parseFirstNum()

None meshlib.mrmeshpy.parseFirstNum	(	str	str,
		int_output	num )

reads the first integer number in the line

◆ parsePolygon()

None meshlib.mrmeshpy.parsePolygon	(	str	str,
		VertId	vertId,
		int_output	numPoints )

reads the polygon points and optional number of polygon points
example
N vertex0 vertex1 ... vertexN

◆ partialOffsetMesh()

Mesh meshlib.mrmeshpy.partialOffsetMesh	(	MeshPart	mp,
		float	offset,
		GeneralOffsetParameters	params = 'MR::GeneralOffsetParameters{}' )

Offsets mesh part by converting it to voxels and back
and unite it with original mesh (via boolean)
note: only OffsetParameters.signDetectionMode = SignDetectionMode::Unsigned will work in this function

◆ pathFromUtf8()

os PathLike meshlib.mrmeshpy.pathFromUtf8 ( str s )

◆ pickedPointToVector3()

Vector3f meshlib.mrmeshpy.pickedPointToVector3	(	VisualObject	object,
		std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int	point )

Converts pickedPoint coordinates depending on the object type into a 3D Vector3

◆ planeSectionsToContours2f()

std_vector_std_vector_Vector2_float meshlib.mrmeshpy.planeSectionsToContours2f	(	Mesh	mesh,
		std_vector_std_vector_EdgePoint	sections,
		AffineXf3f	meshToPlane )

◆ planeSectionToContour2f()

std_vector_Vector2_float meshlib.mrmeshpy.planeSectionToContour2f	(	Mesh	mesh,
		std_vector_EdgePoint	section,
		AffineXf3f	meshToPlane )

converts PlaneSections in 2D contours by computing coordinate of each point, applying given xf to it, and retaining only x and y

◆ pointGridSampling()

VertBitSet meshlib.mrmeshpy.pointGridSampling	(	PointCloud	cloud,
		float	voxelSize,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

performs sampling of cloud points;
subdivides point cloud bounding box on voxels of approximately given size and returns at most one point per voxel;
returns std::nullopt if it was terminated by the callback

◆ pointIterativeSampling()

VertBitSet meshlib.mrmeshpy.pointIterativeSampling	(	PointCloud	cloud,
		int	numSamples,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

performs sampling of cloud points by iteratively removing one point with minimal metric (describing distance to the closest point and previous nearby removals),
thus allowing stopping at any given number of samples;
returns std::nullopt if it was terminated by the callback

◆ pointOnObjectToPickedPoint()

std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int meshlib.mrmeshpy.pointOnObjectToPickedPoint	(	VisualObject	object,
		PointOnObject	pos )

Converts PointOnObject coordinates depending on the object type to the PickedPoint variant

◆ pointsToDistanceFunctionVolume()

FunctionVolume meshlib.mrmeshpy.pointsToDistanceFunctionVolume	(	PointCloud	cloud,
		PointsToDistanceVolumeParams	params )

makes FunctionVolume representing signed distances to points with normals

◆ pointsToDistanceVolume()

SimpleVolume meshlib.mrmeshpy.pointsToDistanceVolume	(	PointCloud	cloud,
		PointsToDistanceVolumeParams	params )

makes SimpleVolume filled with signed distances to points with normals

◆ pointsToMeshFusion()

Mesh meshlib.mrmeshpy.pointsToMeshFusion	(	PointCloud	cloud,
		PointsToMeshParameters	params )

makes mesh from points with normals by constructing intermediate volume with signed distances
and then using marching cubes algorithm to extract the surface from there

◆ pointUniformSampling()

VertBitSet meshlib.mrmeshpy.pointUniformSampling	(	PointCloud	pointCloud,
		UniformSamplingSettings	settings )

Sample vertices, removing ones that are too close;
returns std::nullopt if it was terminated by the callback
\\ingroup PointCloudGroup

◆ polylineOffset()

Polyline2 meshlib.mrmeshpy.polylineOffset	(	Polyline2	polyline,
		float	pixelSize,
		float	offset )

constructs an offset contour for given polyline

◆ positionVertsSmoothly()

None meshlib.mrmeshpy.positionVertsSmoothly	(	Mesh	mesh,
		VertBitSet	verts,
		EdgeWeights	edgeWeightsType = 'EdgeWeights::Cotan',
		VertBitSet	fixedSharpVertices = None )

Puts given vertices in such positions to make smooth surface both inside verts-region and on its boundary;
\\param verts must not include all vertices of a mesh connected component
\\param fixedSharpVertices in these vertices the surface can be not-smooth

◆ positionVertsSmoothlySharpBd()

None meshlib.mrmeshpy.positionVertsSmoothlySharpBd	(	Mesh	mesh,
		VertBitSet	verts,
		VertCoords	vertShifts = None,
		VertScalars	vertStabilizers = None )

Puts given vertices in such positions to make smooth surface inside verts-region, but sharp on its boundary;
\\param verts must not include all vertices of a mesh connected component unless vertStabilizers are given
\\param vertShifts optional additional shifts of each vertex relative to smooth position
\\param vertStabilizers optional per-vertex stabilizers: the more the value, the bigger vertex attraction to its original position

◆ positionVertsWithSpacing()

None meshlib.mrmeshpy.positionVertsWithSpacing	(	Mesh	mesh,
		SpacingSettings	settings )

Moves given vertices to make the distances between them as specified

◆ printCurrentTimerBranch()

None meshlib.mrmeshpy.printCurrentTimerBranch ( )

prints current timer branch

◆ printStacktraceOnCrash()

None meshlib.mrmeshpy.printStacktraceOnCrash ( )

Print stacktrace on application crash

◆ printTimingTree()

None meshlib.mrmeshpy.printTimingTree ( float minTimeSec = 0.1 )

prints the current timing tree
\\param minTimeSec omit printing records with time spent less than given value in seconds

◆ printTimingTreeAtEnd()

None meshlib.mrmeshpy.printTimingTreeAtEnd	(	bool	on,
		float	minTimeSec = 0.1 )

enables or disables printing of timing tree when application terminates
\\param minTimeSec omit printing records with time spent less than given value in seconds

◆ processCloseTriangles()

None meshlib.mrmeshpy.processCloseTriangles	(	MeshPart	mp,
		std_array_Vector3_float_3	t,
		float	rangeSq,
		func_ProcessOneResult_from_Vector3_float_Id_FaceTag_Vector3_float_float	call )

invokes given callback for all triangles from given mesh part located not further than
given squared distance from t-triangle

◆ projectAllMeshVertices()

VertScalars meshlib.mrmeshpy.projectAllMeshVertices	(	Mesh	refMesh,
		Mesh	mesh,
		AffineXf3f	refXf = None,
		AffineXf3f	xf = None,
		float	upDistLimitSq = 3.4028234663852886e+38,
		float	loDistLimitSq = 0.0 )

Computes signed distances from all mesh points to refMesh.
`refMesh` - all points will me projected to this mesh
`mesh` - this mesh points will be projected
`refXf` - world transform for refMesh
`upDistLimitSq` - upper limit on the distance in question, if the real distance is larger than the returning upDistLimit
`loDistLimitSq` - low limit on the distance in question, if a point is found within this distance then it is immediately returned without searching for a closer one

◆ projectOnAll()

None meshlib.mrmeshpy.projectOnAll	(	Vector3f	pt,
		AABBTreeObjects	tree,
		float	upDistLimitSq,
		func_void_from_Id_ObjTag_MeshOrPoints_ProjectionResult	callback,
		ObjId	skipObjId = 'MR::ObjId{}' )

finds closest point on every object within given distance

◆ putScanFileNameInZ()

None meshlib.mrmeshpy.putScanFileNameInZ	(	std_vector_std_filesystem_path	scans,
		std_vector_SliceInfo	zOrder )

Read layer heights from given scan file names

◆ rayBoxIntersect()

bool meshlib.mrmeshpy.rayBoxIntersect	(	Box3f	box,
		RayOrigin_float	rayOrigin,
		float_output	t0,
		float_output	t1,
		IntersectionPrecomputes_float	prec )

finds intersection between the Ray and the Box.
Precomputed values could be useful for several calls with the same direction,
see "An Efficient and Robust Ray-Box Intersection Algorithm" at https://people.csail.mit.edu/amy/papers/box-jgt.pdf

◆ rayInsideIntersect() [1/2]

MeshIntersectionResult meshlib.mrmeshpy.rayInsideIntersect	(	Mesh	mesh,
		MeshPoint	m,
		float	rayEnd = 3.4028234663852886e+38 )

returns the nearest intersection between the mesh and the ray from given point along minus normal (inside the mesh)

◆ rayInsideIntersect() [2/2]

MeshIntersectionResult meshlib.mrmeshpy.rayInsideIntersect	(	Mesh	mesh,
		VertId	v,
		float	rayEnd = 3.4028234663852886e+38 )

◆ rayMeshIntersect() [1/2]

MeshIntersectionResult meshlib.mrmeshpy.rayMeshIntersect	(	MeshPart	meshPart,
		Line3d	line,
		float	rayStart = 0.0,
		float	rayEnd = 1.7976931348623157e+308,
		IntersectionPrecomputes_double	prec = None,
		bool	closestIntersect = True,
		func_bool_from_Id_FaceTag	validFaces = 'MR::FacePredicate{}' )

Finds ray and mesh intersection in double-precision.
\\p rayStart and \\p rayEnd define the interval on the ray to detect an intersection.
\\p prec can be specified to reuse some precomputations (e.g. for checking many parallel rays).
\\p vadidFaces if given then all faces for which false is returned will be skipped
Finds the closest to ray origin intersection (or any intersection for better performance if \\p !closestIntersect).

◆ rayMeshIntersect() [2/2]

MeshIntersectionResult meshlib.mrmeshpy.rayMeshIntersect	(	MeshPart	meshPart,
		Line3f	line,
		float	rayStart = 0.0,
		float	rayEnd = 3.4028234663852886e+38,
		IntersectionPrecomputes_float	prec = None,
		bool	closestIntersect = True,
		func_bool_from_Id_FaceTag	validFaces = 'MR::FacePredicate{}' )

Finds ray and mesh intersection in float-precision.
\\p rayStart and \\p rayEnd define the interval on the ray to detect an intersection.
\\p prec can be specified to reuse some precomputations (e.g. for checking many parallel rays).
\\p vadidFaces if given then all faces for which false is returned will be skipped
Finds the closest to ray origin intersection (or any intersection for better performance if \\p !closestIntersect).

◆ rayMeshIntersectAll() [1/2]

None meshlib.mrmeshpy.rayMeshIntersectAll	(	MeshPart	meshPart,
		Line3d	line,
		func_bool_from_MeshIntersectionResult	callback,
		float	rayStart = 0.0,
		float	rayEnd = 1.7976931348623157e+308,
		IntersectionPrecomputes_double	prec = None )

Same as \\ref rayMeshIntersectAllF, but use double precision

◆ rayMeshIntersectAll() [2/2]

None meshlib.mrmeshpy.rayMeshIntersectAll	(	MeshPart	meshPart,
		Line3f	line,
		func_bool_from_MeshIntersectionResult	callback,
		float	rayStart = 0.0,
		float	rayEnd = 3.4028234663852886e+38,
		IntersectionPrecomputes_float	prec = None )

Intersects ray with mesh. Finds all intersections
\\anchor rayMeshIntersectAllF

◆ rayMultiMeshAnyIntersect() [1/2]

MultiMeshIntersectionResult meshlib.mrmeshpy.rayMultiMeshAnyIntersect	(	std_vector_Line3Mesh_double	lineMeshes,
		float	rayStart = 0.0,
		float	rayEnd = 1.7976931348623157e+308 )

Same as \\ref rayMultiMeshAnyIntersectF, but use double precision

◆ rayMultiMeshAnyIntersect() [2/2]

MultiMeshIntersectionResult meshlib.mrmeshpy.rayMultiMeshAnyIntersect	(	std_vector_Line3Mesh_float	lineMeshes,
		float	rayStart = 0.0,
		float	rayEnd = 3.4028234663852886e+38 )

Intersects ray with many meshes. Finds any intersection (not the closest)
\\anchor rayMultiMeshAnyIntersectF

◆ rayPolylineIntersect() [1/2]

PolylineIntersectionResult2 meshlib.mrmeshpy.rayPolylineIntersect	(	Polyline2	polyline,
		Line2d	line,
		float	rayStart = 0,
		float	rayEnd = 1.7976931348623157e+308,
		IntersectionPrecomputes2_double	prec = None,
		bool	closestIntersect = True )

Finds ray and polyline intersection in double-precision.
\\p rayStart and \\p rayEnd define the interval on the ray to detect an intersection.
\\p prec can be specified to reuse some precomputations (e.g. for checking many parallel rays).
Finds the closest to ray origin intersection (or any intersection for better performance if \\p !closestIntersect).

◆ rayPolylineIntersect() [2/2]

PolylineIntersectionResult2 meshlib.mrmeshpy.rayPolylineIntersect	(	Polyline2	polyline,
		Line2f	line,
		float	rayStart = 0,
		float	rayEnd = 3.4028234663852886e+38,
		IntersectionPrecomputes2_float	prec = None,
		bool	closestIntersect = True )

Finds ray and polyline intersection in float-precision.
\\p rayStart and \\p rayEnd define the interval on the ray to detect an intersection.
\\p prec can be specified to reuse some precomputations (e.g. for checking many parallel rays).
Finds the closest to ray origin intersection (or any intersection for better performance if \\p !closestIntersect).

◆ rayTriangleIntersect() [1/4]

TriIntersectResult meshlib.mrmeshpy.rayTriangleIntersect	(	Vector3d	oriA,
		Vector3d	oriB,
		Vector3d	oriC,
		IntersectionPrecomputes_double	prec )

◆ rayTriangleIntersect() [2/4]

TriIntersectResult meshlib.mrmeshpy.rayTriangleIntersect	(	Vector3d	oriA,
		Vector3d	oriB,
		Vector3d	oriC,
		Vector3d	dir )

◆ rayTriangleIntersect() [3/4]

TriIntersectResult meshlib.mrmeshpy.rayTriangleIntersect	(	Vector3f	oriA,
		Vector3f	oriB,
		Vector3f	oriC,
		IntersectionPrecomputes_float	prec )

◆ rayTriangleIntersect() [4/4]

TriIntersectResult meshlib.mrmeshpy.rayTriangleIntersect	(	Vector3f	oriA,
		Vector3f	oriB,
		Vector3f	oriC,
		Vector3f	dir )

◆ rayTriangleIntersect_() [1/2]

TriIntersectResult meshlib.mrmeshpy.rayTriangleIntersect_	(	Vector3d	oriA,
		Vector3d	oriB,
		Vector3d	oriC,
		IntersectionPrecomputes_double	prec )

◆ rayTriangleIntersect_() [2/2]

TriIntersectResult meshlib.mrmeshpy.rayTriangleIntersect_	(	Vector3f	oriA,
		Vector3f	oriB,
		Vector3f	oriC,
		IntersectionPrecomputes_float	prec )

◆ readByBlocks()

bool meshlib.mrmeshpy.readByBlocks	(	typing.Any	in_,
		char_output	data,
		int	dataSize,
		func_bool_from_float	callback = 'MR::ProgressCallback{}',
		int	blockSize = 65536 )

 \\brief read dataSize bytes from in stream to data by blocks blockSize bytes
 \\details if progress callback is not set, read all data by one block
 \\return false if process was canceled (callback is set and return false )

◆ readRawTiff()

None meshlib.mrmeshpy.readRawTiff	(	os.PathLike	path,
		RawTiffOutput	output )

load values from tiff to ouput.data

◆ readString()

str meshlib.mrmeshpy.readString ( typing.Any in_ )

reads input stream to string

◆ readTiffParameters()

TiffParameters meshlib.mrmeshpy.readTiffParameters ( os.PathLike path )

reads parameters of tiff file

◆ rebuildMesh()

Mesh meshlib.mrmeshpy.rebuildMesh	(	MeshPart	mp,
		RebuildMeshSettings	settings )

fixes all types of issues in input mesh (degenerations, holes, self-intersections, etc.)
by first converting mesh in voxel representation, and then backward

◆ reducePath()

int meshlib.mrmeshpy.reducePath	(	Mesh	mesh,
		MeshTriPoint	start,
		std_vector_EdgePoint	path,
		MeshTriPoint	end,
		int	maxIter = 5 )

converts any input surface path into geodesic path (so reduces its length): start-path-end;
returns actual number of iterations performed

◆ reducePathViaVertex()

bool meshlib.mrmeshpy.reducePathViaVertex	(	Mesh	mesh,
		MeshTriPoint	start,
		VertId	v,
		MeshTriPoint	end,
		std_vector_EdgePoint	outPath,
		std_vector_Vector2_float	tmp,
		std_vector_EdgePoint	cachePath )

given path s-v-e, tries to decrease its length by moving away from v
\\param outPath intermediate locations between s and e will be added here
\\param tmp elements will be temporary allocated here
\\param cachePath as far as we need two sides unfold, cache one to reduce allocations

◆ refineFeatureObject() [1/2]

AffineXf3f meshlib.mrmeshpy.refineFeatureObject	(	FeatureObject	featObj,
		Mesh	mesh,
		RefineParameters	params = 'MR::RefineParameters{}' )

Recalculate the feature object's position so it would better fit with the given mesh

◆ refineFeatureObject() [2/2]

AffineXf3f meshlib.mrmeshpy.refineFeatureObject	(	FeatureObject	featObj,
		PointCloud	pointCloud,
		RefineParameters	params = 'MR::RefineParameters{}' )

Recalculate the feature object's position so it would better fit with the given point cloud

◆ relax() [1/2]

bool meshlib.mrmeshpy.relax	(	Mesh	mesh,
		MeshRelaxParams	params = 'MR::MeshRelaxParams{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

applies given number of relaxation iterations to the whole mesh ( or some region if it is specified )
\\return true if was finished successfully, false if was interrupted by progress callback

◆ relax() [2/2]

bool meshlib.mrmeshpy.relax	(	PointCloud	pointCloud,
		PointCloudRelaxParams	params = 'MR::PointCloudRelaxParams{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

applies given number of relaxation iterations to the whole pointCloud ( or some region if it is specified )
\\return true if was finished successfully, false if was interrupted by progress callback

◆ relaxApprox() [1/2]

bool meshlib.mrmeshpy.relaxApprox	(	Mesh	mesh,
		MeshApproxRelaxParams	params = 'MR::MeshApproxRelaxParams{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

applies given number of relaxation iterations to the whole mesh ( or some region if it is specified )
approx neighborhoods
\\return true if the operation completed successfully, and false if it was interrupted by the progress callback.

◆ relaxApprox() [2/2]

bool meshlib.mrmeshpy.relaxApprox	(	PointCloud	pointCloud,
		PointCloudApproxRelaxParams	params = 'MR::PointCloudApproxRelaxParams{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

applies given number of relaxation iterations to the whole pointCloud ( or some region if it is specified )
approx neighborhoods
\\return true if was finished successfully, false if was interrupted by progress callback

◆ relaxKeepVolume() [1/2]

bool meshlib.mrmeshpy.relaxKeepVolume	(	Mesh	mesh,
		MeshRelaxParams	params = 'MR::MeshRelaxParams{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

applies given number of relaxation iterations to the whole mesh ( or some region if it is specified ) \\n
do not really keeps volume but tries hard
\\return true if the operation completed successfully, and false if it was interrupted by the progress callback.

◆ relaxKeepVolume() [2/2]

bool meshlib.mrmeshpy.relaxKeepVolume	(	PointCloud	pointCloud,
		PointCloudRelaxParams	params = 'MR::PointCloudRelaxParams{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

applies given number of relaxation iterations to the whole pointCloud ( or some region if it is specified )
do not really keeps volume but tries hard
\\return true if was finished successfully, false if was interrupted by progress callback

◆ remesh()

bool meshlib.mrmeshpy.remesh	(	Mesh	mesh,
		RemeshSettings	settings )

Splits too long and eliminates too short edges from the mesh

◆ removeLoneContours()

None meshlib.mrmeshpy.removeLoneContours ( std_vector_std_vector_VariableEdgeTri contours )

Removes contours that fully lay inside one triangle from the contours

◆ removeLoneDegeneratedContours()

None meshlib.mrmeshpy.removeLoneDegeneratedContours	(	MeshTopology	edgesTopology,
		std_vector_OneMeshContour	faceContours,
		std_vector_OneMeshContour	edgeContours )

Removes contours with zero area (do not remove if contour is handle on topology)
edgesTopology - topology on which contours are represented with edges
faceContours - lone contours represented by faces (all intersections are in same mesh A face)
edgeContours - lone contours represented by edges (all intersections are in mesh B edges, edgesTopology: meshB.topology)

◆ removeSpikes()

None meshlib.mrmeshpy.removeSpikes	(	Mesh	mesh,
		int	maxIterations,
		float	minSumAngle,
		VertBitSet	region = None )

applies at most given number of relaxation iterations the spikes detected by given threshold

◆ replace()

str meshlib.mrmeshpy.replace	(	str	target,
		str	from_,
		str	to )

Returns \\param target with all \\param from replaced with \\param to, zero or more times.

◆ replaceInplace()

None meshlib.mrmeshpy.replaceInplace	(	std_string_output	target,
		str	from_,
		str	to )

Replaces \\param from with \\param to in \\param target (in-place), zero or more times.

◆ replaceProhibitedChars()

str meshlib.mrmeshpy.replaceProhibitedChars	(	str	line,
		str	replacement = '_' )

replace OS prohibited chars ('?', '*', '/', '\\', '"', '<', '>') with `replacement` char

◆ replicateZ()

None meshlib.mrmeshpy.replicateZ	(	Mesh	m,
		Mesh	target )

adjusts z-coordinates of (m) vertices to make adjusted (m) similar to (target)

◆ reportProgress() [1/2]

bool meshlib.mrmeshpy.reportProgress	(	func_bool_from_float	cb,
		float	v )

safely invokes \\param cb with given value; just returning true for empty callback

◆ reportProgress() [2/2]

bool meshlib.mrmeshpy.reportProgress	(	func_bool_from_float	cb,
		float	v,
		int	counter,
		int	divider )

safely invokes \\param cb with given value if \\param counter is divisible by \\param divider (preferably a power of 2);
just returning true for empty callback

◆ resample()

MarkedContour3f meshlib.mrmeshpy.resample	(	MarkedContour3f	in_,
		float	minStep,
		std_vector_Vector3_float	normals = None )

keeps all marked points from input contour and adds/removes other points to have them as many as possible,
but at the distance along the input line not shorter than (minStep) from their neighbor points
\\param normals optional parameter with the normals of input points that will be resampled to become normals of output points

◆ resampled() [1/2]

OpenVdbFloatGrid meshlib.mrmeshpy.resampled	(	OpenVdbFloatGrid	grid,
		float	voxelScale,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

resample this grid to fit voxelScale

◆ resampled() [2/2]

OpenVdbFloatGrid meshlib.mrmeshpy.resampled	(	OpenVdbFloatGrid	grid,
		Vector3f	voxelScale,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

resample this grid to fit voxelScale

◆ resolveMeshDegenerations() [1/2]

bool meshlib.mrmeshpy.resolveMeshDegenerations	(	Mesh	mesh,
		int	maxIters,
		float	maxDeviation = 0,
		float	maxAngleChange = 1.0471975803375244,
		float	criticalAspectRatio = 10000 )

◆ resolveMeshDegenerations() [2/2]

bool meshlib.mrmeshpy.resolveMeshDegenerations	(	Mesh	mesh,
		ResolveMeshDegenSettings	settings = 'MR::ResolveMeshDegenSettings{}' )

 \\brief Resolves degenerate triangles in given mesh
 \\details This function performs decimation, so it can affect topology
 \\ingroup DecimateGroup
 \\return true if the mesh has been changed

 \\sa \\ref decimateMesh

◆ reverse() [1/2]

None meshlib.mrmeshpy.reverse ( std_vector_Id_EdgeTag path )

reverses the order of edges and flips each edge orientation, thus
making the opposite directed edge path

◆ reverse() [2/2]

None meshlib.mrmeshpy.reverse ( std_vector_std_vector_Id_EdgeTag paths )

reverse every path in the vector

◆ roundToPrecision()

float meshlib.mrmeshpy.roundToPrecision	(	float	v,
		int	precision )

returns given value rounded to given number of decimal digits

◆ same() [1/2]

bool meshlib.mrmeshpy.same	(	MeshTopology	topology,
		EdgePoint	lhs,
		EdgePoint	rhs )

returns true if two edge-points are equal considering different representations

◆ same() [2/2]

bool meshlib.mrmeshpy.same	(	MeshTopology	topology,
		MeshTriPoint	lhs,
		MeshTriPoint	rhs )

returns true if two points are equal considering different representations

◆ sampleHalfSphere()

std_vector_Vector3_float meshlib.mrmeshpy.sampleHalfSphere ( )

returns quasi-uniform 145 samples on unit half-sphere z>0

◆ saveAllSlicesToImage()

None meshlib.mrmeshpy.saveAllSlicesToImage	(	VdbVolume	vdbVolume,
		VoxelsSave.SavingSettings	settings )

save all slices by the active plane through all voxel planes along the active axis to an image file

◆ saveDistanceMapToImage()

None meshlib.mrmeshpy.saveDistanceMapToImage	(	DistanceMap	distMap,
		os.PathLike	filename,
		float	threshold = 0.003921568859368563 )

saves distance map to a grayscale image file
    threshold - threshold of maximum values [0.; 1.]. invalid pixel set as 0. (black)
minimum (close): 1.0 (white)
maximum (far): threshold
invalid (infinity): 0.0 (black)

◆ saveLines() [1/2]

None meshlib.mrmeshpy.saveLines	(	Polyline3	polyline,
		os.PathLike	file,
		SaveSettings	settings = 'MR::SaveSettings{}' )

detects the format from file extension and saves polyline in it

◆ saveLines() [2/2]

None meshlib.mrmeshpy.saveLines	(	Polyline3	polyline,
		str	extension,
		typing.Any	out,
		SaveSettings	settings = 'MR::SaveSettings{}' )

extension in `*.ext` format

◆ saveMesh() [1/2]

None meshlib.mrmeshpy.saveMesh	(	Mesh	mesh,
		os.PathLike	file,
		SaveSettings	settings = 'MR::SaveSettings{}' )

detects the format from file extension and save mesh to it

◆ saveMesh() [2/2]

None meshlib.mrmeshpy.saveMesh	(	Mesh	mesh,
		str	extension,
		typing.Any	out,
		SaveSettings	settings = 'MR::SaveSettings{}' )

extension in `*.ext` format

◆ saveObjectVoxelsToFile()

None meshlib.mrmeshpy.saveObjectVoxelsToFile	(	Object	object,
		os.PathLike	path,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ savePoints() [1/2]

None meshlib.mrmeshpy.savePoints	(	PointCloud	points,
		os.PathLike	file,
		SaveSettings	settings = 'MR::SaveSettings{}' )

detects the format from file extension and save points to it

◆ savePoints() [2/2]

None meshlib.mrmeshpy.savePoints	(	PointCloud	points,
		str	extension,
		typing.Any	out,
		SaveSettings	settings = 'MR::SaveSettings{}' )

extension in `*.ext` format

◆ saveSliceToImage()

None meshlib.mrmeshpy.saveSliceToImage	(	os.PathLike	path,
		VdbVolume	vdbVolume,
		SlicePlane	slicePlain,
		int	sliceNumber,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

save the slice by the active plane through the sliceNumber to an image file

◆ saveVoxels()

None meshlib.mrmeshpy.saveVoxels	(	VdbVolume	vdbVolume,
		os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

Saves voxels in a file, detecting the format from file extension

◆ saveVoxelsGav() [1/6]

None meshlib.mrmeshpy.saveVoxelsGav	(	SimpleVolume	simpleVolume,
		os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ saveVoxelsGav() [2/6]

None meshlib.mrmeshpy.saveVoxelsGav	(	SimpleVolume	simpleVolume,
		typing.Any	out,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ saveVoxelsGav() [3/6]

None meshlib.mrmeshpy.saveVoxelsGav	(	SimpleVolumeMinMax	simpleVolumeMinMax,
		os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ saveVoxelsGav() [4/6]

None meshlib.mrmeshpy.saveVoxelsGav	(	SimpleVolumeMinMax	simpleVolumeMinMax,
		typing.Any	out,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ saveVoxelsGav() [5/6]

None meshlib.mrmeshpy.saveVoxelsGav	(	VdbVolume	vdbVolume,
		os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

Save voxels in Gav-format in given destination

◆ saveVoxelsGav() [6/6]

None meshlib.mrmeshpy.saveVoxelsGav	(	VdbVolume	vdbVolume,
		typing.Any	out,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ saveVoxelsRaw() [1/2]

None meshlib.mrmeshpy.saveVoxelsRaw	(	SimpleVolume	simpleVolume,
		os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

◆ saveVoxelsRaw() [2/2]

None meshlib.mrmeshpy.saveVoxelsRaw	(	VdbVolume	vdbVolume,
		os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

Save raw voxels file, writing parameters in file name

◆ segmentByGraphCut()

FaceBitSet meshlib.mrmeshpy.segmentByGraphCut	(	MeshTopology	topology,
		FaceBitSet	source,
		FaceBitSet	sink,
		func_float_from_Id_EdgeTag	metric )

 \\brief Finds segment that divide mesh on source and sink (source included, sink excluded), by minimizing the sum of metric over the boundary
 \\ingroup MeshSegmentationGroup

◆ segmentVolume()

Mesh meshlib.mrmeshpy.segmentVolume	(	VdbVolume	volume,
		std_vector_std_pair_Vector3_float_Vector3_float	pairs,
		VolumeSegmentationParameters	params = 'MR::VolumeSegmentationParameters()' )

 \\brief Simple segment volume
 \\details
 1. Build paths between points pairs \\n
 2. Mark paths as inside part seeds \\n
 3. Mark volume part edges as outside part seeds \\n
 4. Return mesh from segmented inside part

◆ segmentVolumeByGraphCut()

VoxelBitSet meshlib.mrmeshpy.segmentVolumeByGraphCut	(	SimpleVolume	densityVolume,
		float	k,
		VoxelBitSet	sourceSeeds,
		VoxelBitSet	sinkSeeds,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

 \\brief Segment voxels of given volume on two sets using graph-cut, returning source set
 \\ingroup VoxelGroup
 \\param k - coefficient in the exponent of the metric affecting edge capacity:\\n
        increasing k you force to find a higher steps in the density on the boundary, decreasing k you ask for smoother boundary
 \\param sourceSeeds - these voxels will be included in the result
 \\param sinkSeeds - these voxels will be excluded from the result
 
 \\sa \\ref VolumeSegmenter

◆ SegPoints()

None meshlib.mrmeshpy.SegPoints	(	Vector3f	VEC,
		Vector3f	X,
		Vector3f	Y,
		Vector3f	P,
		Vector3f	A,
		Vector3f	Q,
		Vector3f	B )

Returns closest points between an segment pair.

◆ separateClosedContour()

std_vector_TaggedBitSet_FaceTag meshlib.mrmeshpy.separateClosedContour	(	Mesh	mesh,
		std_vector_Vector3_float	contour,
		func_void_from_EdgePoint	cb = 'MR::PathMeshEdgePointCallback{}' )

Separates mesh into disconnected by contour components (independent components are not returned),
faces that are intersected by contour does not belong to any component.
Calls callback for each MeshEdgePoint in contour respecting order, 
ignoring MeshTriPoints (if projection of input point lay inside face)

◆ serializeMesh()

None meshlib.mrmeshpy.serializeMesh	(	Mesh	mesh,
		os.PathLike	path,
		FaceBitSet	selection = None,
		str	saveMeshFormat = '".mrmesh"' )

saves mesh with optional selection to mru format;
this is very convenient for saving intermediate states during algorithm debugging;
".mrmesh" save mesh format is not space efficient, but guaranties no changes in the topology after loading

◆ serializeObjectTree() [1/2]

None meshlib.mrmeshpy.serializeObjectTree	(	Object	object,
		os.PathLike	path,
		func_bool_from_float	progress,
		func_void_from_std_filesystem_path	preCompress )

 \\brief saves object subtree in given scene file (zip/mru)
 \\details format specification:
  children are saved under folder with name of their parent object
  all objects parameters are saved in one JSON file in the root folder

 if preCompress is set, it is called before compression
 saving is controlled with Object::serializeModel_ and Object::serializeFields_

◆ serializeObjectTree() [2/2]

None meshlib.mrmeshpy.serializeObjectTree	(	Object	object,
		os.PathLike	path,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

◆ serializeObjectTreeToGltf()

None meshlib.mrmeshpy.serializeObjectTreeToGltf	(	Object	root,
		os.PathLike	file,
		func_bool_from_float	callback = 'MR::ProgressCallback{}' )

saves scene to a glTF file

◆ SetCurrentThreadName()

None meshlib.mrmeshpy.SetCurrentThreadName ( str name )

sets debug name for the current thread

◆ setLevelSetType()

None meshlib.mrmeshpy.setLevelSetType ( OpenVdbFloatGrid grid )

sets type of this grid as LEVEL SET (for normal flipping)

◆ setNewHandlerIfNeeded()

None meshlib.mrmeshpy.setNewHandlerIfNeeded ( )

sets new handler for operator new if needed for some platforms

◆ setupLoggerByDefault()

None meshlib.mrmeshpy.setupLoggerByDefault ( )

Setups logger:
1) makes stdout sink
2) makes file sink (MRLog.txt)
3) redirect std streams to logger
4) print stacktrace on crash (not in wasm)
log level - trace

◆ setValue() [1/2]

None meshlib.mrmeshpy.setValue	(	OpenVdbFloatGrid	grid,
		Vector3i	p,
		float	value )

sets given region voxels value
\\note region is in grid space (0 voxel id is minimum active voxel in grid)

◆ setValue() [2/2]

None meshlib.mrmeshpy.setValue	(	OpenVdbFloatGrid	grid,
		VoxelBitSet	region,
		float	value )

sets given region voxels value
\\note region is in grid space (0 voxel id is minimum active voxel in grid)

◆ sharpenMarchingCubesMesh()

None meshlib.mrmeshpy.sharpenMarchingCubesMesh	(	MeshPart	ref,
		Mesh	vox,
		Vector_Id_VoxelTag_FaceId	face2voxel,
		SharpenMarchingCubesMeshSettings	settings )

adjust the mesh \\param vox produced by marching cubes method (NOT dual marching cubes) by
1) correcting positions of all vertices to given offset relative to \\param ref mesh (if correctOldVertPos == true);
2) introducing new vertices in the voxels where the normals change abruptly.
\\param face2voxel mapping from Face Id to Voxel Id where it is located

◆ sharpOffsetMesh()

Mesh meshlib.mrmeshpy.sharpOffsetMesh	(	MeshPart	mp,
		float	offset,
		SharpOffsetParameters	params = 'MR::SharpOffsetParameters{}' )

Offsets mesh by converting it to voxels and back
post process result using reference mesh to sharpen features

◆ shrink() [1/2]

None meshlib.mrmeshpy.shrink	(	MeshTopology	topology,
		FaceBitSet	region,
		int	hops = 1 )

removes from the region all faces within given number of hops (stars) from the initial region boundary

◆ shrink() [2/2]

None meshlib.mrmeshpy.shrink	(	MeshTopology	topology,
		VertBitSet	region,
		int	hops = 1 )

removes from the region all vertices within given number of hops (stars) from the initial region boundary

◆ shrinkFaces()

FaceBitSet meshlib.mrmeshpy.shrinkFaces	(	MeshTopology	topology,
		FaceBitSet	region,
		UndirectedEdgeBitSet	stopEdges = None )

returns given region without all faces sharing an edge with not-region face;
\\param stopEdges - neighborhood via this edges will be ignored

◆ shrinkPixelMask()

None meshlib.mrmeshpy.shrinkPixelMask	(	PixelBitSet	mask,
		RectIndexer	indexer,
		int	shrinkage = 1 )

shrinks PixelBitSet with given number of steps

◆ shrinkVoxelsMask()

None meshlib.mrmeshpy.shrinkVoxelsMask	(	VoxelBitSet	mask,
		VolumeIndexer	indexer,
		int	shrinkage = 1 )

shrinks VoxelBitSet with given number of steps

◆ signedDistanceToMesh()

float meshlib.mrmeshpy.signedDistanceToMesh	(	MeshPart	mp,
		Vector3f	p,
		DistanceToMeshOptions	op )

computes signed distance from point (p) to mesh part (mp) following options (op);
returns std::nullopt if distance is smaller than op.minDist or larger than op.maxDist (except for op.signMode == HoleWindingRule)

◆ simpleVolumeToDenseGrid()

OpenVdbFloatGrid meshlib.mrmeshpy.simpleVolumeToDenseGrid	(	SimpleVolume	simpleVolume,
		float	background = 0.0,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

make FloatGrid from SimpleVolume
make copy of data
background - the new background value for FloatGrid
grid can be used to make iso-surface later with gridToMesh function

◆ simpleVolumeToVdbVolume()

VdbVolume meshlib.mrmeshpy.simpleVolumeToVdbVolume	(	SimpleVolumeMinMax	simpleVolume,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

set the simpleVolume.min as the background value

◆ smoothRegionBoundary()

None meshlib.mrmeshpy.smoothRegionBoundary	(	Mesh	mesh,
		FaceBitSet	regionFaces,
		int	numIters = 4 )

given a region of faces on the mesh, moves boundary vertices of the region
to make the region contour much smoother with minor optimization of mesh topology near region boundary;
\\param numIters >= 1 how many times to run the algorithm to achieve a better quality,
solution is typically oscillates back and forth so even number of iterations is recommended

◆ smoothSelection()

FaceBitSet meshlib.mrmeshpy.smoothSelection	(	Mesh	mesh,
		FaceBitSet	region,
		float	expandOffset,
		float	shrinkOffset )

makes the given selection more smooth with shifthing a boundary of the selection outside and back. Input mesh is changed because we have to cut new edges along the new boundaries
\\param expandOffset defines how much the boundary is expanded
\\param expandOffset defines how much the boundary is shrinked after that

◆ sortPathsByLength()

None meshlib.mrmeshpy.sortPathsByLength	(	std_vector_std_vector_Id_EdgeTag	paths,
		Mesh	mesh )

◆ sortPathsByMetric()

None meshlib.mrmeshpy.sortPathsByMetric	(	std_vector_std_vector_Id_EdgeTag	paths,
		func_float_from_Id_EdgeTag	metric )

sorts given paths in ascending order of their metrics

◆ sortScanFilesByName()

None meshlib.mrmeshpy.sortScanFilesByName ( std_vector_std_filesystem_path scans )

Sort scan files in given vector by names (respect numbers in it)

◆ sortScansByOrder()

None meshlib.mrmeshpy.sortScansByOrder	(	std_vector_std_filesystem_path	scans,
		std_vector_SliceInfo	zOrder )

Sort scan files in given vector by given slice information

◆ split()

std_vector_std_string meshlib.mrmeshpy.split	(	str	string,
		str	delimiter )

 Splits given string by delimiter.
 \\return vector of split strings
 \\ingroup BasicGroup

◆ splitByLines()

std_vector_unsigned_long meshlib.mrmeshpy.splitByLines	(	str	data,
		int	size )

returns offsets for each new line in monolith char block

◆ splitOnSimpleLoops()

std_vector_std_vector_Id_EdgeTag meshlib.mrmeshpy.splitOnSimpleLoops	(	MeshTopology	topology,
		std_vector_std_vector_Id_EdgeTag	loops )

given a number of edge loops, splits every loop that passes via a vertex more than once on smaller loops without self-intersections

◆ sqr() [1/6]

float meshlib.mrmeshpy.sqr ( Vector2d a )

squared length

◆ sqr() [2/6]

float meshlib.mrmeshpy.sqr ( Vector2f a )

squared length

◆ sqr() [3/6]

int meshlib.mrmeshpy.sqr ( Vector2i a )

squared length

◆ sqr() [4/6]

float meshlib.mrmeshpy.sqr ( Vector3d a )

squared length

◆ sqr() [5/6]

float meshlib.mrmeshpy.sqr ( Vector3f a )

squared length

◆ sqr() [6/6]

int meshlib.mrmeshpy.sqr ( Vector3i a )

squared length

◆ stitchContours()

None meshlib.mrmeshpy.stitchContours	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	c0,
		std_vector_Id_EdgeTag	c1 )

given two contours:
1) of equal size;
2) all edges of c0 have no left faces;
3) all edges of c1 have no right faces;
merge the surface along corresponding edges of two contours, and deletes all vertices and edges from c1

◆ straightenBoundary()

None meshlib.mrmeshpy.straightenBoundary	(	Mesh	mesh,
		Id_EdgeTag	bd,
		float	minNeiNormalsDot,
		float	maxTriAspectRatio,
		FaceBitSet	newFaces = None )

adds triangles along the boundary to straighten it;
\\details new triangle is added only if 
 1) aspect ratio of the new triangle is at most maxTriAspectRatio,
 2) dot product of its normal with neighbor triangles is at least minNeiNormalsDot.
\\ingroup MeshAlgorithmGroup

◆ subdivideLoneContours()

None meshlib.mrmeshpy.subdivideLoneContours	(	Mesh	mesh,
		std_vector_OneMeshContour	contours,
		phmap_flat_hash_map_Id_FaceTag_Id_FaceTag	new2oldMap = None )

Divides faces that fully own contours into 3 parts with center in center mass of one of the face contours
if there is more than one contour on face it guarantee to subdivide at least one lone contour on this face

◆ subdivideMesh()

int meshlib.mrmeshpy.subdivideMesh	(	Mesh	mesh,
		SubdivideSettings	settings = 'MR::SubdivideSettings{}' )

Split edges in mesh region according to the settings;\\n
\\return The total number of edge splits performed

◆ subdividePolyline() [1/2]

int meshlib.mrmeshpy.subdividePolyline	(	Polyline2	polyline,
		PolylineSubdivideSettings	settings = 'MR::PolylineSubdivideSettings{}' )

Split edges in polyline according to the settings;\\n
\\return The total number of edge splits performed

◆ subdividePolyline() [2/2]

int meshlib.mrmeshpy.subdividePolyline	(	Polyline3	polyline,
		PolylineSubdivideSettings	settings = 'MR::PolylineSubdivideSettings{}' )

◆ subdividePolylineWithPlane()

EdgeBitSet meshlib.mrmeshpy.subdividePolylineWithPlane	(	Polyline3	polyline,
		Plane3f	plane,
		func_void_from_Id_EdgeTag_Id_EdgeTag_float	onEdgeSplitCallback = None )

This function splits edges intersected by the plane
\\return New edges with origin on the plane and oriented to the positive direction
\\param polyline Input polyline that will be cut by the plane
\\param plane Input plane to cut polyline with
\\param onEdgeSplitCallback is invoked each time when an edge is split. Receives edge ID before split, edge ID after split, and weight of the origin vertex

◆ subdivideWithPlane()

FaceBitSet meshlib.mrmeshpy.subdivideWithPlane	(	Mesh	mesh,
		Plane3f	plane,
		phmap_flat_hash_map_Id_FaceTag_Id_FaceTag	new2Old = None,
		float	eps = 0,
		func_void_from_Id_EdgeTag_Id_EdgeTag_float	onEdgeSplitCallback = None )

subdivides all triangles intersected by given plane, leaving smaller triangles that only touch the plane;
\\return all triangles on the positive side of the plane
\\param new2Old receive mapping from newly appeared triangle to its original triangle (part to full)
\\param eps if existing vertex is within eps distance from the plane, then move the vertex not introducing new ones
\\param onEdgeSplitCallback is invoked each time when an edge is split. Receives edge ID before split, edge ID after split, and weight of the origin vertex

◆ subprogress() [1/2]

func_bool_from_float meshlib.mrmeshpy.subprogress	(	func_bool_from_float	cb,
		float	from_,
		float	to )

returns a callback that maps [0,1] linearly into [from,to] in the call to \\param cb (which can be empty)

◆ subprogress() [2/2]

func_bool_from_float meshlib.mrmeshpy.subprogress	(	func_bool_from_float	cb,
		int	index,
		int	count )

returns a callback that maps [0,1] linearly into [(index+0)/count,(index+1)/count] in the call to \\param cb (which can be empty)

◆ suggestVoxelSize()

float meshlib.mrmeshpy.suggestVoxelSize	(	MeshPart	mp,
		float	approxNumVoxels )

computes size of a cubical voxel to get approximately given number of voxels during rasterization

◆ surfacePathLength()

float meshlib.mrmeshpy.surfacePathLength	(	Mesh	mesh,
		std_vector_EdgePoint	surfacePath )

computes the length of surface path

◆ surfacePathsToContours3f()

std_vector_std_vector_Vector3_float meshlib.mrmeshpy.surfacePathsToContours3f	(	Mesh	mesh,
		std_vector_std_vector_EdgePoint	lines )

◆ surfacePathToContour3f()

std_vector_Vector3_float meshlib.mrmeshpy.surfacePathToContour3f	(	Mesh	mesh,
		std_vector_EdgePoint	line )

converts lines on mesh in 3D contours by computing coordinate of each point

◆ surroundingContour() [1/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.surroundingContour	(	Mesh	mesh,
		std_vector_Id_EdgeTag	includeEdges,
		func_float_from_Id_EdgeTag	edgeMetric,
		Vector3f	dir )

 \\brief Find the best closed edge loop passing through given edges, which minimizes the sum of given edge metric.
 The algorithm assumes that input edges can be projected on the plane orthogonal to given direction,
 then the center point of all input edges is found, and each segment of the searched loop is within infinite pie sector
 with this center and the borders passing via two sorted input edges.
 \\ingroup MeshSegmentationGroup
 
 \\param includeEdges contain all edges in arbitrary order that must be present in the returned loop, probably with reversed direction (should have at least 2 elements)
 \\param edgeMetric returned loop will minimize the sum of this metric
 \\param dir direction approximately orthogonal to the loop

◆ surroundingContour() [2/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.surroundingContour	(	Mesh	mesh,
		std_vector_Id_VertTag	keyVertices,
		func_float_from_Id_EdgeTag	edgeMetric,
		Vector3f	dir )

 \\brief Find the best closed edge loop passing through given vertices, which minimizes the sum of given edge metric.
 The algorithm assumes that input vertices can be projected on the plane orthogonal to given direction,
 then the center point of all input vertices is found, and each segment of the searched loop is within infinite pie sector
 with this center and the borders passing via two sorted input vertices.
 \\ingroup MeshSegmentationGroup
 
 \\param keyVertices contain all vertices in arbitrary order that returned loop must pass (should have at least 2 elements)
 \\param edgeMetric returned loop will minimize the sum of this metric
 \\param dir direction approximately orthogonal to the loop

◆ systemToUtf8()

str meshlib.mrmeshpy.systemToUtf8 ( str system )

converts system encoded string to UTF8-encoded string

◆ teethMaskToDirectionVolume()

std_array_VoxelsVolumeMinMax_std_vector_float_3 meshlib.mrmeshpy.teethMaskToDirectionVolume	(	VdbVolume	volume,
		std_vector_int	additionalIds = 'std::vector<int>{}' )

A shortcut for \\ref TeethMaskToDirectionVolumeConvertor::create and \\ref TeethMaskToDirectionVolumeConvertor::convertAll

◆ terrainTriangulation()

Mesh meshlib.mrmeshpy.terrainTriangulation	(	std_vector_Vector3_float	points,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Creates Delaunay triangulation using only XY components of points 
points will be changed inside this function take argument by value

◆ thickenMesh()

Mesh meshlib.mrmeshpy.thickenMesh	(	Mesh	mesh,
		float	offset,
		GeneralOffsetParameters	params = 'MR::GeneralOffsetParameters{}' )

in case of positive offset, returns the mesh consisting of offset mesh merged with inversed original mesh (thickening mode);
in case of negative offset, returns the mesh consisting of inversed offset mesh merged with original mesh (hollowing mode);
if your input mesh is open then please specify params.signDetectionMode = SignDetectionMode::Unsigned, and you will get open mesh (with several components) on output
if your input mesh is closed then please specify another sign detection mode, and you will get closed mesh (with several components) on output;

◆ toLower()

str meshlib.mrmeshpy.toLower ( str str )

return a copy of the string with all alphabetic characters replaced with upper-case variants

◆ topologyFromTriangles()

MeshTopology meshlib.mrmeshpy.topologyFromTriangles	(	Triangulation	t,
		MeshBuilder.BuildSettings	settings = 'MR::MeshBuilder::BuildSettings{}',
		func_bool_from_float	progressCb = 'MR::ProgressCallback{}' )

construct mesh topology from a set of triangles with given ids;
if skippedTris is given then it receives all input triangles not added in the resulting topology

◆ toString() [1/2]

str meshlib.mrmeshpy.toString ( DimensionsVisualizePropertyType value )

◆ toString() [2/2]

str meshlib.mrmeshpy.toString ( PathError error )

◆ trackLeftBoundaryLoop() [1/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.trackLeftBoundaryLoop	(	MeshTopology	topology,
		FaceBitSet	region,
		Id_EdgeTag	e0 )

◆ trackLeftBoundaryLoop() [2/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.trackLeftBoundaryLoop	(	MeshTopology	topology,
		Id_EdgeTag	e0,
		FaceBitSet	region = None )

returns closed loop of region boundary starting from given region boundary edge (region faces on the left, and not-region faces or holes on the right);
if more than two boundary edges connect in one vertex, then the function makes the most abrupt turn to right

◆ trackRightBoundaryLoop() [1/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.trackRightBoundaryLoop	(	MeshTopology	topology,
		FaceBitSet	region,
		Id_EdgeTag	e0 )

◆ trackRightBoundaryLoop() [2/2]

std_vector_Id_EdgeTag meshlib.mrmeshpy.trackRightBoundaryLoop	(	MeshTopology	topology,
		Id_EdgeTag	e0,
		FaceBitSet	region = None )

returns closed loop of region boundary starting from given region boundary edge (region faces on the right, and not-region faces or holes on the left);
if more than two boundary edges connect in one vertex, then the function makes the most abrupt turn to left

◆ trackSection()

std_vector_EdgePoint meshlib.mrmeshpy.trackSection	(	MeshPart	mp,
		MeshTriPoint	start,
		MeshTriPoint	end,
		Vector3f	direction,
		float	distance )

track section of plane set by start point, direction and surface normal in start point 
in given direction while given distance or
mesh boundary is not reached, or track looped
negative distance means moving in opposite direction
returns track on surface and end point (same as start if path has looped)

◆ transformNormals()

VertCoords meshlib.mrmeshpy.transformNormals	(	VertCoords	normals,
		VertBitSet	validVerts,
		Matrix3d	m,
		VertCoords	buf )

if (m) is null then just returns (normals);
otherwise copies transformed normals in (buf) and returns it

◆ transformPoints()

VertCoords meshlib.mrmeshpy.transformPoints	(	VertCoords	verts,
		VertBitSet	validVerts,
		AffineXf3d	xf,
		VertCoords	buf,
		VertRenumber	vertRenumber = None )

if (xf) is null then just returns (verts);
otherwise copies transformed points in (buf) and returns it

◆ transformVdbVolume()

VdbVolume meshlib.mrmeshpy.transformVdbVolume	(	VdbVolume	volume,
		AffineXf3f	xf,
		bool	fixBox = False,
		Box3f	box = 'MR::Box3f{}' )

Transform volume
@param volume Volume to transform
@param xf The transformation
@param fixBox If true, and if \\p box is valid and represents the bounding box of the \\p volume, then
              the result will be shifted so that no data has negative coordinate by any of dimensions

◆ triangulateContours() [1/2]

Mesh meshlib.mrmeshpy.triangulateContours	(	std_vector_std_vector_Vector2_double	contours,
		std_vector_std_vector_Id_VertTag	holeVertsIds = None )

 @brief triangulate 2d contours
 only closed contours are allowed (first point of each contour should be the same as last point of the contour)
 @param holeVertsIds if set merge only points with same vertex id, otherwise merge all points with same coordinates
 @return return created mesh

◆ triangulateContours() [2/2]

Mesh meshlib.mrmeshpy.triangulateContours	(	std_vector_std_vector_Vector2_float	contours,
		std_vector_std_vector_Id_VertTag	holeVertsIds = None )

◆ triangulatePointCloud()

Mesh meshlib.mrmeshpy.triangulatePointCloud	(	PointCloud	pointCloud,
		TriangulationParameters	params = 'MR::TriangulationParameters{}',
		func_bool_from_float	progressCb = 'MR::ProgressCallback{}' )

 \\brief Creates mesh from given point cloud according params
 Returns empty optional if was interrupted by progress bar
 \\ingroup PointCloudTriangulationGroup
    <table border=0>
        <caption id="triangulatePointCloud_examples"></caption>
        <tr>
            <td> \\image html triangulate/triangulate_0.png "Before" width = 350cm </td>
            <td> \\image html triangulate/triangulate_3.png "After" width = 350cm </td>
        </tr>
    </table>

◆ TriDist()

float meshlib.mrmeshpy.TriDist	(	Vector3f	p,
		Vector3f	q,
		Vector3f	s,
		Vector3f	t )

\\brief computes the closest points on two triangles, and returns the 
squared distance between them.

\\param s,t are the triangles, stored tri[point][dimension].

\\details If the triangles are disjoint, p and q give the closest points of 
s and t respectively. However, if the triangles overlap, p and q 
are basically a random pair of points from the triangles, not 
coincident points on the intersection of the triangles, as might 
be expected.

◆ trimRight()

str meshlib.mrmeshpy.trimRight ( str str )

Removes all whitespace character (detected by std::isspace) at the end of string view

◆ trimWithPlane() [1/3]

None meshlib.mrmeshpy.trimWithPlane	(	Mesh	mesh,
		Plane3f	plane,
		std_vector_std_vector_Id_EdgeTag	outCutContours,
		phmap_flat_hash_map_Id_FaceTag_Id_FaceTag	new2Old = None,
		float	eps = 0,
		func_void_from_Id_EdgeTag_Id_EdgeTag_float	onEdgeSplitCallback = None )

\\brief trim mesh by plane

This function cuts mesh with plane, leaving only part of mesh that lay in positive direction of normal
\\param mesh Input mesh that will be cut
\\param plane Input plane to cut mesh with
\\param outCutContours optionally return newly appeared hole contours where each edge does not have right face
\\param new2Old receive mapping from newly appeared triangle to its original triangle (part to full)
\\param eps if existing vertex is within eps distance from the plane, then move the vertex not introducing new ones
\\param onEdgeSplitCallback is invoked each time when an edge is split. Receives edge ID before split, edge ID after split, and weight of the origin vertex

◆ trimWithPlane() [2/3]

None meshlib.mrmeshpy.trimWithPlane	(	Mesh	mesh,
		Plane3f	plane,
		UndirectedEdgeBitSet	outCutEdges = None,
		phmap_flat_hash_map_Id_FaceTag_Id_FaceTag	new2Old = None,
		float	eps = 0,
		func_void_from_Id_EdgeTag_Id_EdgeTag_float	onEdgeSplitCallback = None )

\\brief trim mesh by plane

This function cuts mesh with plane, leaving only part of mesh that lay in positive direction of normal
\\param mesh Input mesh that will be cut
\\param plane Input plane to cut mesh with
\\param outCutEdges optionally return newly appeared hole boundary edges
\\param new2Old receive mapping from newly appeared triangle to its original triangle (part to full)
\\param eps if existing vertex is within eps distance from the plane, then move the vertex not introducing new ones
\\param onEdgeSplitCallback is invoked each time when an edge is split. Receives edge ID before split, edge ID after split, and weight of the origin vertex

◆ trimWithPlane() [3/3]

None meshlib.mrmeshpy.trimWithPlane	(	Mesh	mesh,
		TrimWithPlaneParams	params,
		TrimOptionalOutput	optOut = 'MR::TrimOptionalOutput{}' )

\\brief trim mesh by plane

This function cuts mesh with plane, leaving only part of mesh that lay in positive direction of normal
\\param mesh Input mesh that will be cut
\\param params stores basic params for trimWithPlane function
\\param optOut stores optional output params for trimWithPlane function

◆ undirectedEdges() [1/2]

IteratorRange_UndirectedEdgeIterator meshlib.mrmeshpy.undirectedEdges ( MeshTopology topology )

◆ undirectedEdges() [2/2]

IteratorRange_PolylineUndirectedEdgeIterator meshlib.mrmeshpy.undirectedEdges ( PolylineTopology topology )

◆ uniteCloseVertices()

int meshlib.mrmeshpy.uniteCloseVertices	(	Mesh	mesh,
		float	closeDist,
		bool	uniteOnlyBd = True,
		VertMap	optionalVertOldToNew = None )

the function finds groups of mesh vertices located closer to each other than \\param closeDist, and unites such vertices in one;
then the mesh is rebuilt from the remaining triangles
\\param optionalVertOldToNew is the mapping of vertices: before -> after
\\param uniteOnlyBd if true then only boundary vertices can be united, all internal vertices (even close ones) will remain
\\return the number of vertices united, 0 means no change in the mesh

◆ uniteLocalTriangulations()

AllLocalTriangulations meshlib.mrmeshpy.uniteLocalTriangulations	(	std_vector_SomeLocalTriangulations	in_,
		func_bool_from_float	progress = 'MR::ProgressCallback{}' )

converts a set of SomeLocalTriangulations containing local triangulations of all points arbitrary distributed among them
into one AllLocalTriangulations with records for all points

◆ uniteManyMeshes()

Mesh meshlib.mrmeshpy.uniteManyMeshes	(	std_vector_Mesh_const	meshes,
		UniteManyMeshesParams	params = 'MR::UniteManyMeshesParams{}' )

Computes the surface of objects' union each of which is defined by its own surface mesh
- merge non intersecting meshes first
- unite merged groups

◆ unitVector3_double()

Vector3d meshlib.mrmeshpy.unitVector3_double	(	float	azimuth,
		float	altitude )

returns a point on unit sphere given two angles

◆ unitVector3_float()

Vector3f meshlib.mrmeshpy.unitVector3_float	(	float	azimuth,
		float	altitude )

returns a point on unit sphere given two angles

◆ updateGroupPairs()

None meshlib.mrmeshpy.updateGroupPairs	(	ICPGroupPairs	pairs,
		Vector_MeshOrPointsXf_ObjId	objs,
		func_void_from_Vector3_float_MeshOrPoints_ProjectionResult_Id_ObjTag	srcProjector,
		func_void_from_Vector3_float_MeshOrPoints_ProjectionResult_Id_ObjTag	tgtProjector,
		float	cosThreshold,
		float	distThresholdSq,
		bool	mutualClosest )

in each pair updates the target data and performs basic filtering (activation)

◆ updateIndicator()

None meshlib.mrmeshpy.updateIndicator	(	Mesh	mesh,
		UndirectedEdgeScalars	v,
		FaceNormals	normals,
		float	beta,
		float	gamma )

Compute edge indicator function (1 - smooth edge, 0 - crease edge) by solving large system of linear equations
\\param mesh contains topology information and coordinates for equation weights
\\param normals per-face normals
\\param beta 0.001 - sharp edges, 0.01 - moderate edges, 0.1 - smooth edges
\\param gamma the amount of smoothing: 0 - no smoothing, 1 - average smoothing, ...
see the article "Mesh Denoising via a Novel Mumford-Shah Framework", equation (20)

◆ updateIndicatorFast()

None meshlib.mrmeshpy.updateIndicatorFast	(	MeshTopology	topology,
		UndirectedEdgeScalars	v,
		FaceNormals	normals,
		float	beta,
		float	gamma )

Compute edge indicator function (1 - smooth edge, 0 - crease edge) by approximation without solving the system of linear equations
\\param normals per-face normals
\\param beta 0.001 - sharp edges, 0.01 - moderate edges, 0.1 - smooth edges
\\param gamma the amount of smoothing: 0 - no smoothing, 1 - average smoothing, ...
see the article "Mesh Denoising via a Novel Mumford-Shah Framework", equation (20)

◆ updatePointPairs()

None meshlib.mrmeshpy.updatePointPairs	(	PointPairs	pairs,
		MeshOrPointsXf	src,
		MeshOrPointsXf	tgt,
		float	cosThreshold,
		float	distThresholdSq,
		bool	mutualClosest )

in each pair updates the target data and performs basic filtering (activation)

◆ utf8string()

str meshlib.mrmeshpy.utf8string ( os.PathLike path )

◆ utf8ToSystem()

str meshlib.mrmeshpy.utf8ToSystem ( str utf8 )

converts UTF8-encoded string to system encoded string,
returns empty string if such conversion cannot be made

◆ utf8ToWide()

str meshlib.mrmeshpy.utf8ToWide ( str utf8 )

converts UTF8-encoded string into UTF16-encoded string

◆ vdbVolumeToSimpleVolume()

SimpleVolumeMinMax meshlib.mrmeshpy.vdbVolumeToSimpleVolume	(	VdbVolume	vdbVolume,
		Box3i	activeBox = 'MR::Box3i()',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

make SimpleVolume from VdbVolume
make copy of data

◆ vdbVolumeToSimpleVolumeNorm()

SimpleVolumeMinMax meshlib.mrmeshpy.vdbVolumeToSimpleVolumeNorm	(	VdbVolume	vdbVolume,
		Box3i	activeBox = 'MR::Box3i()',
		std_optional_Box_float	sourceScale = 'std::optional<MR::MinMaxf>{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Makes normalized SimpleVolume from VdbVolume
Normalisation consist of scaling values linearly from the source scale to the interval [0;1]
@note Makes copy of data
@param sourceScale if specified, defines the initial scale of voxels.
    If not specified, it is estimated as min. and max. values from the voxels

◆ vdbVolumeToSimpleVolumeU16()

SimpleVolumeMinMaxU16 meshlib.mrmeshpy.vdbVolumeToSimpleVolumeU16	(	VdbVolume	vdbVolume,
		Box3i	activeBox = 'MR::Box3i()',
		std_optional_Box_float	sourceScale = 'std::optional<MR::MinMaxf>{}',
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

Makes SimpleVolumeU16 from VdbVolume
Values are linearly scaled from the source scale to the range corresponding to uint16_t
@note Makes copy of data
@param sourceScale if specified, defines the initial scale of voxels.
    If not specified, it is estimated as min. and max. values from the voxels

◆ vertexAttributeGradient()

VertCoords meshlib.mrmeshpy.vertexAttributeGradient	(	Mesh	mesh,
		VertScalars	vertexAttribute )

Calculates gradient for each vertex in mesh, based on vertexAttribute

◆ vertexPosEqualNeiAreas()

Vector3f meshlib.mrmeshpy.vertexPosEqualNeiAreas	(	Mesh	mesh,
		VertId	v,
		bool	noShrinkage )

computes position of a vertex, when all neighbor triangles have almost equal areas,
more precisely it minimizes sum_i (area_i)^2 by adjusting the position of this vertex only

◆ verticesGridSampling()

VertBitSet meshlib.mrmeshpy.verticesGridSampling	(	MeshPart	mp,
		float	voxelSize,
		func_bool_from_float	cb = 'MR::ProgressCallback{}' )

performs sampling of mesh vertices;
subdivides mesh bounding box on voxels of approximately given size and returns at most one vertex per voxel;
returns std::nullopt if it was terminated by the callback

◆ vertMapsComposition()

VertMap meshlib.mrmeshpy.vertMapsComposition	(	VertMap	a2b,
		VertMap	b2c )

updates a2b map to a2c map using b2c map

returns map a2c from a2b and b2c maps

◆ voxelBooleanIntersect()

Mesh meshlib.mrmeshpy.voxelBooleanIntersect	(	Mesh	mesh1,
		Mesh	mesh2,
		float	voxelSize )

Intersect mesh A and mesh B.

◆ voxelBooleanSubtract()

Mesh meshlib.mrmeshpy.voxelBooleanSubtract	(	Mesh	mesh1,
		Mesh	mesh2,
		float	voxelSize )

Subtract mesh B from mesh A.

◆ voxelBooleanUnite()

Mesh meshlib.mrmeshpy.voxelBooleanUnite	(	Mesh	mesh1,
		Mesh	mesh2,
		float	voxelSize )

Unite mesh A and mesh B.

◆ voxelFilter()

VdbVolume meshlib.mrmeshpy.voxelFilter	(	VdbVolume	volume,
		VoxelFilterType	type,
		int	width )

Performs voxels filtering.
@param type Type of fitler
@param width Width of the filtering window, must be an odd number greater or equal to 1.

◆ voxelizeAndComputeVolume()

float meshlib.mrmeshpy.voxelizeAndComputeVolume	(	std_vector_std_shared_ptr_Mesh	meshes,
		AffineXf3f	xf,
		Vector3f	voxelSize )

Computes summary volume of given meshes converting it to voxels of given size
note that each mesh should have closed topology
speed and precision depends on voxelSize (smaller voxel - faster, less precise; bigger voxel - slower, more precise)

◆ voxelsApplyTransform()

None meshlib.mrmeshpy.voxelsApplyTransform	(	ObjectVoxels	obj,
		AffineXf3f	xf,
		bool	fixBox )

Same as above but for the SceneObject
@return true, if \\p fixBox is true and the box was "fixed" (see parameter `fixBox` of \\ref transformVdbVolume)

◆ voxelsExponentMetric()

func_float_from_unsigned_long_unsigned_long meshlib.mrmeshpy.voxelsExponentMetric	(	VdbVolume	voxels,
		VoxelMetricParameters	parameters,
		float	modifier = -1.0 )

e^(modifier*(dens1+dens2))

◆ voxelsSumDiffsMetric()

func_float_from_unsigned_long_unsigned_long meshlib.mrmeshpy.voxelsSumDiffsMetric	(	VdbVolume	voxels,
		VoxelMetricParameters	parameters )

sum of dense differences with start and stop voxels

◆ wideToUtf8()

str meshlib.mrmeshpy.wideToUtf8 ( str wide )

converts wide null terminating string to UTF8-encoded string

◆ writeByBlocks()

bool meshlib.mrmeshpy.writeByBlocks	(	typing.Any	out,
		str	data,
		int	dataSize,
		func_bool_from_float	callback = 'MR::ProgressCallback{}',
		int	blockSize = 65536 )

 \\brief write dataSize bytes from data to out stream by blocks blockSize bytes
 \\details if progress callback is not set, write all data by one block
 \\return false if process was canceled (callback is set and return false )

◆ writeRawTiff()

None meshlib.mrmeshpy.writeRawTiff	(	int	bytes,
		os.PathLike	path,
		BaseTiffParameters	params )

writes bytes to tiff file

◆ xyPlaneMeshIntersect()

None meshlib.mrmeshpy.xyPlaneMeshIntersect	(	MeshPart	meshPart,
		float	zLevel,
		FaceBitSet	fs,
		UndirectedEdgeBitSet	ues,
		VertBitSet	vs )

given mesh part and plane z=zLevel, outputs
\\param fs  triangles crossed or touched by the plane
\\param ues edges of these triangles
\\param vs  vertices of these triangles

◆ zlibCompressStream()

None meshlib.mrmeshpy.zlibCompressStream	(	typing.Any	in_,
		typing.Any	out,
		int	level = -1 )

 @brief compress the input data using the Deflate algorithm
 @param in - input data stream
 @param out - output data stream
 @param level - compression level (0 - no compression, 1 - the fastest but the most inefficient compression, 9 - the most efficient but the slowest compression)
 @return nothing or error string

◆ zlibDecompressStream()

None meshlib.mrmeshpy.zlibDecompressStream	(	typing.Any	in_,
		typing.Any	out )

 /brief decompress the input data compressed using the Deflate algorithm
 @param in - input data stream
 @param out - output data stream
 @return nothing or error string

Variable Documentation

◆ AABBTreeBase_FaceTreeTraits3

meshlib.mrmeshpy.AABBTreeBase_FaceTreeTraits3 = AABBTreeBase_AABBTreeTraits_FaceTag_Box3f

◆ AABBTreeBase_LineTreeTraits_Vector2f

meshlib.mrmeshpy.AABBTreeBase_LineTreeTraits_Vector2f = AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f

◆ AABBTreeBase_LineTreeTraits_Vector3f

meshlib.mrmeshpy.AABBTreeBase_LineTreeTraits_Vector3f = AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f

◆ AABBTreeNode_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_Traits

meshlib.mrmeshpy.AABBTreeNode_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_Traits = AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

◆ AABBTreeNode_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_Traits

meshlib.mrmeshpy.AABBTreeNode_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_Traits = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

◆ AABBTreeNode_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_Traits

meshlib.mrmeshpy.AABBTreeNode_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_Traits = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

◆ AABBTreeNode_AABBTreeBase_ObjTreeTraits_Traits

meshlib.mrmeshpy.AABBTreeNode_AABBTreeBase_ObjTreeTraits_Traits = AABBTreeNode_ObjTreeTraits

◆ AABBTreePolyline_Vector2f

meshlib.mrmeshpy.AABBTreePolyline_Vector2f = AABBTreePolyline2

◆ AABBTreePolyline_Vector3f

meshlib.mrmeshpy.AABBTreePolyline_Vector3f = AABBTreePolyline3

◆ AffineXf3_double

meshlib.mrmeshpy.AffineXf3_double = AffineXf3d

◆ AffineXf3_float

meshlib.mrmeshpy.AffineXf3_float = AffineXf3f

◆ AffineXf_Vector2_double

meshlib.mrmeshpy.AffineXf_Vector2_double = AffineXf2d

◆ AffineXf_Vector2_float

meshlib.mrmeshpy.AffineXf_Vector2_float = AffineXf2f

◆ AffineXf_Vector2d

meshlib.mrmeshpy.AffineXf_Vector2d = AffineXf2d

◆ AffineXf_Vector2d_M

meshlib.mrmeshpy.AffineXf_Vector2d_M = Matrix2d

◆ AffineXf_Vector2f

meshlib.mrmeshpy.AffineXf_Vector2f = AffineXf2f

◆ AffineXf_Vector2f_M

meshlib.mrmeshpy.AffineXf_Vector2f_M = Matrix2f

◆ AffineXf_Vector3_double

meshlib.mrmeshpy.AffineXf_Vector3_double = AffineXf3d

◆ AffineXf_Vector3_float

meshlib.mrmeshpy.AffineXf_Vector3_float = AffineXf3f

◆ AffineXf_Vector3d

meshlib.mrmeshpy.AffineXf_Vector3d = AffineXf3d

◆ AffineXf_Vector3d_M

meshlib.mrmeshpy.AffineXf_Vector3d_M = Matrix3d

◆ AffineXf_Vector3f

meshlib.mrmeshpy.AffineXf_Vector3f = AffineXf3f

◆ AffineXf_Vector3f_M

meshlib.mrmeshpy.AffineXf_Vector3f_M = Matrix3f

◆ AllVisualizeProperties

meshlib.mrmeshpy.AllVisualizeProperties = std_vector_ViewportMask

◆ BestFitParabola_double

meshlib.mrmeshpy.BestFitParabola_double = BestFitParabolad

◆ BestFitParabola_float

meshlib.mrmeshpy.BestFitParabola_float = BestFitParabolaf

◆ BMap_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafId_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafId

meshlib.mrmeshpy.BMap_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafId_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafId = FaceBMap

◆ BMap_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafId_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafId

meshlib.mrmeshpy.BMap_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafId_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafId = UndirectedEdgeBMap

◆ BMap_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafId_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafId

meshlib.mrmeshpy.BMap_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafId_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafId = UndirectedEdgeBMap

◆ BMap_AABBTreeBase_ObjTreeTraits_LeafId_AABBTreeBase_ObjTreeTraits_LeafId

meshlib.mrmeshpy.BMap_AABBTreeBase_ObjTreeTraits_LeafId_AABBTreeBase_ObjTreeTraits_LeafId = BMap_ObjId_ObjId

◆ BMap_EdgeId_EdgeId

meshlib.mrmeshpy.BMap_EdgeId_EdgeId = EdgeBMap

◆ BMap_EdgeId_UndirectedEdgeId

meshlib.mrmeshpy.BMap_EdgeId_UndirectedEdgeId = WholeEdgeBMap

◆ BMap_FaceId_FaceId

meshlib.mrmeshpy.BMap_FaceId_FaceId = FaceBMap

◆ BMap_FaceId_size_t

meshlib.mrmeshpy.BMap_FaceId_size_t = BMap_FaceId_unsigned_long

◆ BMap_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType = EdgeBMap

◆ BMap_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType = FaceBMap

◆ BMap_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType = BMap_GraphEdgeId_GraphEdgeId

◆ BMap_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType = BMap_GraphVertId_GraphVertId

◆ BMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = BMap_Id_ICPElemtTag_Id_ICPElemtTag

◆ BMap_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType = BMap_NodeId_NodeId

◆ BMap_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType = BMap_ObjId_ObjId

◆ BMap_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType = BMap_PixelId_PixelId

◆ BMap_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType = BMap_RegionId_RegionId

◆ BMap_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType = BMap_TextureId_TextureId

◆ BMap_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType = UndirectedEdgeBMap

◆ BMap_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType = VertBMap

◆ BMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType

meshlib.mrmeshpy.BMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = BMap_Id_VoxelTag_Id_VoxelTag

◆ BMap_UndirectedEdgeId_size_t

meshlib.mrmeshpy.BMap_UndirectedEdgeId_size_t = BMap_UndirectedEdgeId_unsigned_long

◆ BMap_UndirectedEdgeId_UndirectedEdgeId

meshlib.mrmeshpy.BMap_UndirectedEdgeId_UndirectedEdgeId = UndirectedEdgeBMap

◆ BMap_VertId_size_t

meshlib.mrmeshpy.BMap_VertId_size_t = BMap_VertId_unsigned_long

◆ BMap_VertId_VertId

meshlib.mrmeshpy.BMap_VertId_VertId = VertBMap

◆ BooleanResMapObj

meshlib.mrmeshpy.BooleanResMapObj = BooleanResultMapper.MapObject

◆ Box_double

meshlib.mrmeshpy.Box_double = Box1d

◆ Box_double_VTraits

meshlib.mrmeshpy.Box_double_VTraits = VectorTraits_double

◆ Box_float

meshlib.mrmeshpy.Box_float = Box1f

◆ Box_float_VTraits

meshlib.mrmeshpy.Box_float_VTraits = VectorTraits_float

◆ Box_int

meshlib.mrmeshpy.Box_int = Box1i

◆ Box_int_VTraits

meshlib.mrmeshpy.Box_int_VTraits = VectorTraits_int

◆ Box_long_long

meshlib.mrmeshpy.Box_long_long = Box1ll

◆ Box_long_long_VTraits

meshlib.mrmeshpy.Box_long_long_VTraits = VectorTraits_long_long

◆ Box_Vector2_double

meshlib.mrmeshpy.Box_Vector2_double = Box2d

◆ Box_Vector2_float

meshlib.mrmeshpy.Box_Vector2_float = Box2f

◆ Box_Vector2_int

meshlib.mrmeshpy.Box_Vector2_int = Box2i

◆ Box_Vector2_long_long

meshlib.mrmeshpy.Box_Vector2_long_long = Box2ll

◆ Box_Vector2d_VTraits

meshlib.mrmeshpy.Box_Vector2d_VTraits = VectorTraits_Vector2d

◆ Box_Vector2f

meshlib.mrmeshpy.Box_Vector2f = Box2f

◆ Box_Vector2f_VTraits

meshlib.mrmeshpy.Box_Vector2f_VTraits = VectorTraits_Vector2f

◆ Box_Vector2i_VTraits

meshlib.mrmeshpy.Box_Vector2i_VTraits = VectorTraits_Vector2i

◆ Box_Vector2ll_VTraits

meshlib.mrmeshpy.Box_Vector2ll_VTraits = VectorTraits_Vector2ll

◆ Box_Vector3_double

meshlib.mrmeshpy.Box_Vector3_double = Box3d

◆ Box_Vector3_float

meshlib.mrmeshpy.Box_Vector3_float = Box3f

◆ Box_Vector3_int

meshlib.mrmeshpy.Box_Vector3_int = Box3i

◆ Box_Vector3_long_long

meshlib.mrmeshpy.Box_Vector3_long_long = Box3ll

◆ Box_Vector3d

meshlib.mrmeshpy.Box_Vector3d = Box3d

◆ Box_Vector3d_VTraits

meshlib.mrmeshpy.Box_Vector3d_VTraits = VectorTraits_Vector3d

◆ Box_Vector3f

meshlib.mrmeshpy.Box_Vector3f = Box3f

◆ Box_Vector3f_VTraits

meshlib.mrmeshpy.Box_Vector3f_VTraits = VectorTraits_Vector3f

◆ Box_Vector3i

meshlib.mrmeshpy.Box_Vector3i = Box3i

◆ Box_Vector3i_VTraits

meshlib.mrmeshpy.Box_Vector3i_VTraits = VectorTraits_Vector3i

◆ Box_Vector3ll_VTraits

meshlib.mrmeshpy.Box_Vector3ll_VTraits = VectorTraits_Vector3ll

◆ Buffer_FaceId_unsigned_long

meshlib.mrmeshpy.Buffer_FaceId_unsigned_long = Buffer_FaceId

◆ Buffer_UndirectedEdgeId_unsigned_long

meshlib.mrmeshpy.Buffer_UndirectedEdgeId_unsigned_long = Buffer_UndirectedEdgeId

◆ Buffer_VertId_unsigned_long

meshlib.mrmeshpy.Buffer_VertId_unsigned_long = Buffer_VertId

◆ ColorMapAggregator_FaceTag

meshlib.mrmeshpy.ColorMapAggregator_FaceTag = FaceColorMapAggregator

◆ ColorMapAggregator_FaceTag_ColorMap

meshlib.mrmeshpy.ColorMapAggregator_FaceTag_ColorMap = FaceColors

◆ ColorMapAggregator_FaceTag_ElementBitSet

meshlib.mrmeshpy.ColorMapAggregator_FaceTag_ElementBitSet = FaceBitSet

◆ ColorMapAggregator_UndirectedEdgeTag

meshlib.mrmeshpy.ColorMapAggregator_UndirectedEdgeTag = UndirEdgeColorMapAggregator

◆ ColorMapAggregator_UndirectedEdgeTag_ColorMap

meshlib.mrmeshpy.ColorMapAggregator_UndirectedEdgeTag_ColorMap = UndirectedEdgeColors

◆ ColorMapAggregator_UndirectedEdgeTag_ElementBitSet

meshlib.mrmeshpy.ColorMapAggregator_UndirectedEdgeTag_ElementBitSet = UndirectedEdgeBitSet

◆ ColorMapAggregator_VertTag

meshlib.mrmeshpy.ColorMapAggregator_VertTag = VertColorMapAggregator

◆ ColorMapAggregator_VertTag_ColorMap

meshlib.mrmeshpy.ColorMapAggregator_VertTag_ColorMap = VertColors

◆ ColorMapAggregator_VertTag_ElementBitSet

meshlib.mrmeshpy.ColorMapAggregator_VertTag_ElementBitSet = VertBitSet

◆ Cone3_double

meshlib.mrmeshpy.Cone3_double = Cone3d

◆ Cone3_float

meshlib.mrmeshpy.Cone3_float = Cone3f

◆ ContinuousContour

meshlib.mrmeshpy.ContinuousContour = std_vector_VariableEdgeTri

◆ ContinuousContours

meshlib.mrmeshpy.ContinuousContours = std_vector_std_vector_VariableEdgeTri

◆ Contour2_double

meshlib.mrmeshpy.Contour2_double = std_vector_Vector2_double

◆ Contour2_float

meshlib.mrmeshpy.Contour2_float = std_vector_Vector2_float

◆ Contour2d

meshlib.mrmeshpy.Contour2d = std_vector_Vector2_double

◆ Contour2f

meshlib.mrmeshpy.Contour2f = std_vector_Vector2_float

◆ Contour3_double

meshlib.mrmeshpy.Contour3_double = std_vector_Vector3_double

◆ Contour3_float

meshlib.mrmeshpy.Contour3_float = std_vector_Vector3_float

◆ Contour3d

meshlib.mrmeshpy.Contour3d = std_vector_Vector3_double

◆ Contour3f

meshlib.mrmeshpy.Contour3f = std_vector_Vector3_float

◆ Contour_Vector2d

meshlib.mrmeshpy.Contour_Vector2d = std_vector_Vector2_double

◆ Contour_Vector2f

meshlib.mrmeshpy.Contour_Vector2f = std_vector_Vector2_float

◆ Contour_Vector3d

meshlib.mrmeshpy.Contour_Vector3d = std_vector_Vector3_double

◆ Contour_Vector3f

meshlib.mrmeshpy.Contour_Vector3f = std_vector_Vector3_float

◆ Contours2_double

meshlib.mrmeshpy.Contours2_double = std_vector_std_vector_Vector2_double

◆ Contours2_float

meshlib.mrmeshpy.Contours2_float = std_vector_std_vector_Vector2_float

◆ Contours2d

meshlib.mrmeshpy.Contours2d = std_vector_std_vector_Vector2_double

◆ Contours2f

meshlib.mrmeshpy.Contours2f = std_vector_std_vector_Vector2_float

◆ Contours3_double

meshlib.mrmeshpy.Contours3_double = std_vector_std_vector_Vector3_double

◆ Contours3_float

meshlib.mrmeshpy.Contours3_float = std_vector_std_vector_Vector3_float

◆ Contours3d

meshlib.mrmeshpy.Contours3d = std_vector_std_vector_Vector3_double

◆ Contours3f

meshlib.mrmeshpy.Contours3f = std_vector_std_vector_Vector3_float

◆ Contours_Vector2f

meshlib.mrmeshpy.Contours_Vector2f = std_vector_std_vector_Vector2_float

◆ Contours_Vector3f

meshlib.mrmeshpy.Contours_Vector3f = std_vector_std_vector_Vector3_float

◆ copyMesh

meshlib.mrmeshpy.copyMesh = Mesh

◆ Cylinder3_double

meshlib.mrmeshpy.Cylinder3_double = Cylinder3d

◆ Cylinder3_float

meshlib.mrmeshpy.Cylinder3_float = Cylinder3f

◆ DecimatePolylineSettings2

meshlib.mrmeshpy.DecimatePolylineSettings2 = DecimatePolylineSettings_Vector2f

◆ DecimatePolylineSettings3

meshlib.mrmeshpy.DecimatePolylineSettings3 = DecimatePolylineSettings_Vector3f

◆ EdgeHashMap

meshlib.mrmeshpy.EdgeHashMap = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

◆ EdgeId

meshlib.mrmeshpy.EdgeId = Id_EdgeTag

◆ EdgeLoop

meshlib.mrmeshpy.EdgeLoop = std_vector_Id_EdgeTag

◆ EdgeLoops

meshlib.mrmeshpy.EdgeLoops = std_vector_std_vector_Id_EdgeTag

◆ EdgePath

meshlib.mrmeshpy.EdgePath = std_vector_Id_EdgeTag

◆ EdgePathsBuilder

meshlib.mrmeshpy.EdgePathsBuilder = EdgePathsBuilderT_TrivialMetricToPenalty

◆ FaceHashMap

meshlib.mrmeshpy.FaceHashMap = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

◆ FaceTreeTraits3

meshlib.mrmeshpy.FaceTreeTraits3 = AABBTreeTraits_FaceTag_Box3f

◆ FeaturesPropertyTypesVariant

meshlib.mrmeshpy.FeaturesPropertyTypesVariant = std_variant_float_Vector3_float

◆ FileNamesStack

meshlib.mrmeshpy.FileNamesStack = std_vector_std_filesystem_path

◆ FixSelfIntersectionMethod

meshlib.mrmeshpy.FixSelfIntersectionMethod = SelfIntersections.Settings.Method

◆ FixSelfIntersectionSettings

meshlib.mrmeshpy.FixSelfIntersectionSettings = SelfIntersections.Settings

◆ FloatGrid

meshlib.mrmeshpy.FloatGrid = OpenVdbFloatGrid

◆ GcodeSource

meshlib.mrmeshpy.GcodeSource = std_vector_std_string

◆ GeneralOffsetParametersMode

meshlib.mrmeshpy.GeneralOffsetParametersMode = OffsetMode

◆ HashMap_EdgeId_EdgeId

meshlib.mrmeshpy.HashMap_EdgeId_EdgeId = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

◆ HashMap_FaceId_FaceId

meshlib.mrmeshpy.HashMap_FaceId_FaceId = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

◆ HashMap_int_Box3i

meshlib.mrmeshpy.HashMap_int_Box3i = phmap_flat_hash_map_int_Box_Vector3_int

◆ HashMap_size_t_SeparationPointSet

meshlib.mrmeshpy.HashMap_size_t_SeparationPointSet = phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul

◆ HashMap_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

◆ HashMap_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

◆ HashMap_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType = phmap_flat_hash_map_Id_GraphEdgeTag_Id_GraphEdgeTag

◆ HashMap_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType = phmap_flat_hash_map_Id_GraphVertTag_Id_GraphVertTag

◆ HashMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = phmap_flat_hash_map_Id_ICPElemtTag_Id_ICPElemtTag

◆ HashMap_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType = phmap_flat_hash_map_Id_NodeTag_Id_NodeTag

◆ HashMap_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType = phmap_flat_hash_map_Id_ObjTag_Id_ObjTag

◆ HashMap_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType = phmap_flat_hash_map_Id_PixelTag_Id_PixelTag

◆ HashMap_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType = phmap_flat_hash_map_Id_RegionTag_Id_RegionTag

◆ HashMap_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType = phmap_flat_hash_map_Id_TextureTag_Id_TextureTag

◆ HashMap_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

◆ HashMap_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType = phmap_flat_hash_map_Id_VertTag_Id_VertTag

◆ HashMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType

meshlib.mrmeshpy.HashMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag

◆ HashMap_UndirectedEdgeId_EdgeId

meshlib.mrmeshpy.HashMap_UndirectedEdgeId_EdgeId = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

◆ HashMap_UndirectedEdgeId_int

meshlib.mrmeshpy.HashMap_UndirectedEdgeId_int = phmap_flat_hash_map_Id_UndirectedEdgeTag_int

◆ HashMap_UndirectedEdgeId_UndirectedEdgeId

meshlib.mrmeshpy.HashMap_UndirectedEdgeId_UndirectedEdgeId = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

◆ HashMap_VertId_float

meshlib.mrmeshpy.HashMap_VertId_float = phmap_flat_hash_map_Id_VertTag_float

◆ HashMap_VertId_FlowAggregator_Flows

meshlib.mrmeshpy.HashMap_VertId_FlowAggregator_Flows = phmap_flat_hash_map_Id_VertTag_FlowAggregator_Flows

◆ HashMap_VertId_VertId

meshlib.mrmeshpy.HashMap_VertId_VertId = phmap_flat_hash_map_Id_VertTag_Id_VertTag

◆ HashMap_VertId_VertPathInfo

meshlib.mrmeshpy.HashMap_VertId_VertPathInfo = phmap_flat_hash_map_Id_VertTag_VertPathInfo

◆ HistoryActionsVector

meshlib.mrmeshpy.HistoryActionsVector = std_vector_std_shared_ptr_HistoryAction

◆ ICPElementBitSet

meshlib.mrmeshpy.ICPElementBitSet = TaggedBitSet_ICPElemtTag

◆ ICPElementId

meshlib.mrmeshpy.ICPElementId = Id_ICPElemtTag

◆ ICPObjects

meshlib.mrmeshpy.ICPObjects = Vector_MeshOrPointsXf_ObjId

◆ ICPPairsGrid

meshlib.mrmeshpy.ICPPairsGrid = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

◆ Id_FaceTag

meshlib.mrmeshpy.Id_FaceTag = FaceId

◆ Id_GraphEdgeTag

meshlib.mrmeshpy.Id_GraphEdgeTag = GraphEdgeId

◆ Id_GraphVertTag

meshlib.mrmeshpy.Id_GraphVertTag = GraphVertId

◆ Id_NodeTag

meshlib.mrmeshpy.Id_NodeTag = NodeId

◆ Id_ObjTag

meshlib.mrmeshpy.Id_ObjTag = ObjId

◆ Id_PixelTag

meshlib.mrmeshpy.Id_PixelTag = PixelId

◆ Id_RegionTag

meshlib.mrmeshpy.Id_RegionTag = RegionId

◆ Id_TextureTag

meshlib.mrmeshpy.Id_TextureTag = TextureId

◆ Id_UndirectedEdgeTag

meshlib.mrmeshpy.Id_UndirectedEdgeTag = UndirectedEdgeId

◆ Id_VertTag

meshlib.mrmeshpy.Id_VertTag = VertId

◆ IOFilters

meshlib.mrmeshpy.IOFilters = std_vector_IOFilter

◆ IsoLine

meshlib.mrmeshpy.IsoLine = std_vector_EdgePoint

◆ IsoLines

meshlib.mrmeshpy.IsoLines = std_vector_std_vector_EdgePoint

◆ IteratorRange_LeftRingIterator

meshlib.mrmeshpy.IteratorRange_LeftRingIterator = IteratorRange_RingIterator_NextEdgeSameLeft

◆ IteratorRange_OrgRingIterator

meshlib.mrmeshpy.IteratorRange_OrgRingIterator = IteratorRange_RingIterator_NextEdgeSameOrigin

◆ LaplacianEdgeWeightsParam

meshlib.mrmeshpy.LaplacianEdgeWeightsParam = EdgeWeights

◆ LeftRingIterator

meshlib.mrmeshpy.LeftRingIterator = RingIterator_NextEdgeSameLeft

◆ Line3_double

meshlib.mrmeshpy.Line3_double = Line3d

◆ Line3_float

meshlib.mrmeshpy.Line3_float = Line3f

◆ Line3dMesh

meshlib.mrmeshpy.Line3dMesh = Line3Mesh_double

◆ Line3fMesh

meshlib.mrmeshpy.Line3fMesh = Line3Mesh_float

◆ Line_Vector2_double

meshlib.mrmeshpy.Line_Vector2_double = Line2d

◆ Line_Vector2_float

meshlib.mrmeshpy.Line_Vector2_float = Line2f

◆ Line_Vector3_double

meshlib.mrmeshpy.Line_Vector3_double = Line3d

◆ Line_Vector3_float

meshlib.mrmeshpy.Line_Vector3_float = Line3f

◆ Line_Vector3d

meshlib.mrmeshpy.Line_Vector3d = Line3d

◆ LineSegm_Vector2_double

meshlib.mrmeshpy.LineSegm_Vector2_double = LineSegm2d

◆ LineSegm_Vector2_float

meshlib.mrmeshpy.LineSegm_Vector2_float = LineSegm2f

◆ LineSegm_Vector2f

meshlib.mrmeshpy.LineSegm_Vector2f = LineSegm2f

◆ LineSegm_Vector3_double

meshlib.mrmeshpy.LineSegm_Vector3_double = LineSegm3d

◆ LineSegm_Vector3_float

meshlib.mrmeshpy.LineSegm_Vector3_float = LineSegm3f

◆ LineSegm_Vector3f

meshlib.mrmeshpy.LineSegm_Vector3f = LineSegm3f

◆ LineTreeTraits2

meshlib.mrmeshpy.LineTreeTraits2 = AABBTreeTraits_UndirectedEdgeTag_Box2f

◆ LineTreeTraits3

meshlib.mrmeshpy.LineTreeTraits3 = AABBTreeTraits_UndirectedEdgeTag_Box3f

◆ LineTreeTraits_Vector2f

meshlib.mrmeshpy.LineTreeTraits_Vector2f = AABBTreeTraits_UndirectedEdgeTag_Box2f

◆ LineTreeTraits_Vector3f

meshlib.mrmeshpy.LineTreeTraits_Vector3f = AABBTreeTraits_UndirectedEdgeTag_Box3f

◆ LoadedObject

meshlib.mrmeshpy.LoadedObject = LoadedObjectT

◆ LoadedObjectLines

meshlib.mrmeshpy.LoadedObjectLines = LoadedObjectT_ObjectLines

◆ LoadedObjectMesh

meshlib.mrmeshpy.LoadedObjectMesh = LoadedObjectT_ObjectMesh

◆ LoadedObjectPoints

meshlib.mrmeshpy.LoadedObjectPoints = LoadedObjectT_ObjectPoints

◆ LoadedObjectT_Object

meshlib.mrmeshpy.LoadedObjectT_Object = LoadedObjectT

◆ LoadedObjectVoxels

meshlib.mrmeshpy.LoadedObjectVoxels = LoadedObjectT_ObjectVoxels

◆ Matrix2_bool

meshlib.mrmeshpy.Matrix2_bool = Matrix2b

◆ Matrix2_bool_VectorType

meshlib.mrmeshpy.Matrix2_bool_VectorType = Vector2b

◆ Matrix2_double

meshlib.mrmeshpy.Matrix2_double = Matrix2d

◆ Matrix2_double_VectorType

meshlib.mrmeshpy.Matrix2_double_VectorType = Vector2d

◆ Matrix2_float

meshlib.mrmeshpy.Matrix2_float = Matrix2f

◆ Matrix2_float_VectorType

meshlib.mrmeshpy.Matrix2_float_VectorType = Vector2f

◆ Matrix2_int

meshlib.mrmeshpy.Matrix2_int = Matrix2i

◆ Matrix2_int_VectorType

meshlib.mrmeshpy.Matrix2_int_VectorType = Vector2i

◆ Matrix2_long_long

meshlib.mrmeshpy.Matrix2_long_long = Matrix2ll

◆ Matrix2_long_long_VectorType

meshlib.mrmeshpy.Matrix2_long_long_VectorType = Vector2ll

◆ Matrix3_bool

meshlib.mrmeshpy.Matrix3_bool = Matrix3b

◆ Matrix3_bool_VectorType

meshlib.mrmeshpy.Matrix3_bool_VectorType = Vector3b

◆ Matrix3_double

meshlib.mrmeshpy.Matrix3_double = Matrix3d

◆ Matrix3_double_VectorType

meshlib.mrmeshpy.Matrix3_double_VectorType = Vector3d

◆ Matrix3_float

meshlib.mrmeshpy.Matrix3_float = Matrix3f

◆ Matrix3_float_VectorType

meshlib.mrmeshpy.Matrix3_float_VectorType = Vector3f

◆ Matrix3_int

meshlib.mrmeshpy.Matrix3_int = Matrix3i

◆ Matrix3_int_VectorType

meshlib.mrmeshpy.Matrix3_int_VectorType = Vector3i

◆ Matrix3_long_long

meshlib.mrmeshpy.Matrix3_long_long = Matrix3ll

◆ Matrix3_long_long_VectorType

meshlib.mrmeshpy.Matrix3_long_long_VectorType = Vector3ll

◆ Matrix4_bool

meshlib.mrmeshpy.Matrix4_bool = Matrix4b

◆ Matrix4_bool_VectorType

meshlib.mrmeshpy.Matrix4_bool_VectorType = Vector4b

◆ Matrix4_double

meshlib.mrmeshpy.Matrix4_double = Matrix4d

◆ Matrix4_double_VectorType

meshlib.mrmeshpy.Matrix4_double_VectorType = Vector4d

◆ Matrix4_float

meshlib.mrmeshpy.Matrix4_float = Matrix4f

◆ Matrix4_float_VectorType

meshlib.mrmeshpy.Matrix4_float_VectorType = Vector4f

◆ Matrix4_int

meshlib.mrmeshpy.Matrix4_int = Matrix4i

◆ Matrix4_int_VectorType

meshlib.mrmeshpy.Matrix4_int_VectorType = Vector4i

◆ Matrix4_long_long

meshlib.mrmeshpy.Matrix4_long_long = Matrix4ll

◆ Matrix4_long_long_VectorType

meshlib.mrmeshpy.Matrix4_long_long_VectorType = Vector4ll

◆ MeshBuilderSettings

meshlib.mrmeshpy.MeshBuilderSettings = MeshBuilder.BuildSettings

◆ MeshDistanceResult

meshlib.mrmeshpy.MeshDistanceResult = MeshMeshDistanceResult

◆ MeshEdgePoint

meshlib.mrmeshpy.MeshEdgePoint = EdgePoint

◆ MeshLabel

meshlib.mrmeshpy.MeshLabel = PositionedText

◆ MeshOnVoxels

meshlib.mrmeshpy.MeshOnVoxels = MeshOnVoxelsT_Mesh

◆ MeshOnVoxelsC

meshlib.mrmeshpy.MeshOnVoxelsC = MeshOnVoxelsT_const_Mesh

◆ MeshRegion_FaceTag

meshlib.mrmeshpy.MeshRegion_FaceTag = MeshPart

◆ MeshRegion_VertTag

meshlib.mrmeshpy.MeshRegion_VertTag = MeshVertPart

◆ MeshSignedDistanceResult

meshlib.mrmeshpy.MeshSignedDistanceResult = MeshMeshSignedDistanceResult

◆ MeshToVolumeParamsType

meshlib.mrmeshpy.MeshToVolumeParamsType = MeshToVolumeParams.Type

◆ MinMax_double

meshlib.mrmeshpy.MinMax_double = Box1d

◆ MinMax_float

meshlib.mrmeshpy.MinMax_float = Box1f

◆ MinMax_VoxelsVolume_std_shared_ptr_OpenVdbFloatGrid_ValueType

meshlib.mrmeshpy.MinMax_VoxelsVolume_std_shared_ptr_OpenVdbFloatGrid_ValueType = Box1f

◆ MinMax_VoxelsVolume_std_vector_float_ValueType

meshlib.mrmeshpy.MinMax_VoxelsVolume_std_vector_float_ValueType = Box1f

◆ MinMax_VoxelsVolume_std_vector_unsigned_short_ValueType

meshlib.mrmeshpy.MinMax_VoxelsVolume_std_vector_unsigned_short_ValueType = Box_unsigned_short

◆ MinMaxd

meshlib.mrmeshpy.MinMaxd = Box1d

◆ MinMaxf

meshlib.mrmeshpy.MinMaxf = Box1f

◆ MultiObjsSamples

meshlib.mrmeshpy.MultiObjsSamples = std_vector_ObjVertId

◆ ObjectPtr

meshlib.mrmeshpy.ObjectPtr = Object

◆ OffsetContoursVertMap

meshlib.mrmeshpy.OffsetContoursVertMap = std_vector_OffsetContoursOrigins

◆ OffsetContoursVertMaps

meshlib.mrmeshpy.OffsetContoursVertMaps = std_vector_std_vector_OffsetContoursOrigins

◆ OneMeshContours

meshlib.mrmeshpy.OneMeshContours = std_vector_OneMeshContour

◆ OrgRingIterator

meshlib.mrmeshpy.OrgRingIterator = RingIterator_NextEdgeSameOrigin

◆ Parabola_double

meshlib.mrmeshpy.Parabola_double = Parabolad

◆ Parabola_float

meshlib.mrmeshpy.Parabola_float = Parabolaf

◆ phmap_flat_hash_map_FaceId_FaceId

meshlib.mrmeshpy.phmap_flat_hash_map_FaceId_FaceId = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

◆ phmap_flat_hash_map_GraphEdgeId_GraphEdgeId

meshlib.mrmeshpy.phmap_flat_hash_map_GraphEdgeId_GraphEdgeId = phmap_flat_hash_map_Id_GraphEdgeTag_Id_GraphEdgeTag

◆ phmap_flat_hash_map_GraphVertId_GraphVertId

meshlib.mrmeshpy.phmap_flat_hash_map_GraphVertId_GraphVertId = phmap_flat_hash_map_Id_GraphVertTag_Id_GraphVertTag

◆ phmap_flat_hash_map_int_Box3i_phmap_Hash_int32_t

meshlib.mrmeshpy.phmap_flat_hash_map_int_Box3i_phmap_Hash_int32_t = phmap_flat_hash_map_int_Box_Vector3_int

◆ phmap_flat_hash_map_NodeId_NodeId

meshlib.mrmeshpy.phmap_flat_hash_map_NodeId_NodeId = phmap_flat_hash_map_Id_NodeTag_Id_NodeTag

◆ phmap_flat_hash_map_ObjId_ObjId

meshlib.mrmeshpy.phmap_flat_hash_map_ObjId_ObjId = phmap_flat_hash_map_Id_ObjTag_Id_ObjTag

◆ phmap_flat_hash_map_PixelId_PixelId

meshlib.mrmeshpy.phmap_flat_hash_map_PixelId_PixelId = phmap_flat_hash_map_Id_PixelTag_Id_PixelTag

◆ phmap_flat_hash_map_RegionId_RegionId

meshlib.mrmeshpy.phmap_flat_hash_map_RegionId_RegionId = phmap_flat_hash_map_Id_RegionTag_Id_RegionTag

◆ phmap_flat_hash_map_TextureId_TextureId

meshlib.mrmeshpy.phmap_flat_hash_map_TextureId_TextureId = phmap_flat_hash_map_Id_TextureTag_Id_TextureTag

◆ phmap_flat_hash_map_UndirectedEdgeId_Id_EdgeTag

meshlib.mrmeshpy.phmap_flat_hash_map_UndirectedEdgeId_Id_EdgeTag = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

◆ phmap_flat_hash_map_UndirectedEdgeId_int

meshlib.mrmeshpy.phmap_flat_hash_map_UndirectedEdgeId_int = phmap_flat_hash_map_Id_UndirectedEdgeTag_int

◆ phmap_flat_hash_map_UndirectedEdgeId_UndirectedEdgeId

meshlib.mrmeshpy.phmap_flat_hash_map_UndirectedEdgeId_UndirectedEdgeId = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

◆ phmap_flat_hash_map_unsigned_long_std_array_VertId_3_phmap_Hash_uint64_t

meshlib.mrmeshpy.phmap_flat_hash_map_unsigned_long_std_array_VertId_3_phmap_Hash_uint64_t = phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul

◆ phmap_flat_hash_map_VertId_float

meshlib.mrmeshpy.phmap_flat_hash_map_VertId_float = phmap_flat_hash_map_Id_VertTag_float

◆ phmap_flat_hash_map_VertId_FlowAggregator_Flows

meshlib.mrmeshpy.phmap_flat_hash_map_VertId_FlowAggregator_Flows = phmap_flat_hash_map_Id_VertTag_FlowAggregator_Flows

◆ phmap_flat_hash_map_VertId_VertId

meshlib.mrmeshpy.phmap_flat_hash_map_VertId_VertId = phmap_flat_hash_map_Id_VertTag_Id_VertTag

◆ phmap_flat_hash_map_VertId_VertPathInfo

meshlib.mrmeshpy.phmap_flat_hash_map_VertId_VertPathInfo = phmap_flat_hash_map_Id_VertTag_VertPathInfo

◆ PickedPoint

meshlib.mrmeshpy.PickedPoint = std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int

◆ Plane3_double

meshlib.mrmeshpy.Plane3_double = Plane3d

◆ Plane3_float

meshlib.mrmeshpy.Plane3_float = Plane3f

◆ PlaneSection

meshlib.mrmeshpy.PlaneSection = std_vector_EdgePoint

◆ PlaneSections

meshlib.mrmeshpy.PlaneSections = std_vector_std_vector_EdgePoint

◆ Polyline_Vector2f

meshlib.mrmeshpy.Polyline_Vector2f = Polyline2

◆ Polyline_Vector3f

meshlib.mrmeshpy.Polyline_Vector3f = Polyline3

◆ PolylineProjectionResult_Vector2f

meshlib.mrmeshpy.PolylineProjectionResult_Vector2f = PolylineProjectionResult2

◆ PolylineProjectionResult_Vector3f

meshlib.mrmeshpy.PolylineProjectionResult_Vector3f = PolylineProjectionResult3

◆ PolylineProjectionWithOffsetResult_Vector2f

meshlib.mrmeshpy.PolylineProjectionWithOffsetResult_Vector2f = Polyline2ProjectionWithOffsetResult

◆ PolylineProjectionWithOffsetResult_Vector3f

meshlib.mrmeshpy.PolylineProjectionWithOffsetResult_Vector3f = PolylineProjectionWithOffsetResult3

◆ Polynomial_double_0UL_0_0_0UL_minus_1

meshlib.mrmeshpy.Polynomial_double_0UL_0_0_0UL_minus_1 = Polynomial_double_0

◆ Polynomial_double_1UL_0_0_1UL_minus_1

meshlib.mrmeshpy.Polynomial_double_1UL_0_0_1UL_minus_1 = Polynomial_double_0

◆ Polynomial_double_2UL_0_0_2UL_minus_1

meshlib.mrmeshpy.Polynomial_double_2UL_0_0_2UL_minus_1 = Polynomial_double_1

◆ Polynomial_double_3UL_0_0_3UL_minus_1

meshlib.mrmeshpy.Polynomial_double_3UL_0_0_3UL_minus_1 = Polynomial_double_2

◆ Polynomial_double_4UL_0_0_4UL_minus_1

meshlib.mrmeshpy.Polynomial_double_4UL_0_0_4UL_minus_1 = Polynomial_double_3

◆ Polynomial_double_5UL_0_0_5UL_minus_1

meshlib.mrmeshpy.Polynomial_double_5UL_0_0_5UL_minus_1 = Polynomial_double_4

◆ Polynomial_double_6UL_0_0_6UL_minus_1

meshlib.mrmeshpy.Polynomial_double_6UL_0_0_6UL_minus_1 = Polynomial_double_5

◆ Polynomial_float_0UL_0_0_0UL_minus_1

meshlib.mrmeshpy.Polynomial_float_0UL_0_0_0UL_minus_1 = Polynomial_float_0

◆ Polynomial_float_1UL_0_0_1UL_minus_1

meshlib.mrmeshpy.Polynomial_float_1UL_0_0_1UL_minus_1 = Polynomial_float_0

◆ Polynomial_float_2UL_0_0_2UL_minus_1

meshlib.mrmeshpy.Polynomial_float_2UL_0_0_2UL_minus_1 = Polynomial_float_1

◆ Polynomial_float_3UL_0_0_3UL_minus_1

meshlib.mrmeshpy.Polynomial_float_3UL_0_0_3UL_minus_1 = Polynomial_float_2

◆ Polynomial_float_4UL_0_0_4UL_minus_1

meshlib.mrmeshpy.Polynomial_float_4UL_0_0_4UL_minus_1 = Polynomial_float_3

◆ Polynomial_float_5UL_0_0_5UL_minus_1

meshlib.mrmeshpy.Polynomial_float_5UL_0_0_5UL_minus_1 = Polynomial_float_4

◆ Polynomial_float_6UL_0_0_6UL_minus_1

meshlib.mrmeshpy.Polynomial_float_6UL_0_0_6UL_minus_1 = Polynomial_float_5

◆ PolynomialWrapperd

meshlib.mrmeshpy.PolynomialWrapperd = PolynomialWrapper_double

◆ PolynomialWrapperf

meshlib.mrmeshpy.PolynomialWrapperf = PolynomialWrapper_float

◆ Polynomialx_double

meshlib.mrmeshpy.Polynomialx_double = std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul

◆ Polynomialx_float

meshlib.mrmeshpy.Polynomialx_float = std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul

◆ QuadraticForm_Vector2_double

meshlib.mrmeshpy.QuadraticForm_Vector2_double = QuadraticForm2d

◆ QuadraticForm_Vector2_float

meshlib.mrmeshpy.QuadraticForm_Vector2_float = QuadraticForm2f

◆ QuadraticForm_Vector2d_SM

meshlib.mrmeshpy.QuadraticForm_Vector2d_SM = SymMatrix2d

◆ QuadraticForm_Vector2f_SM

meshlib.mrmeshpy.QuadraticForm_Vector2f_SM = SymMatrix2f

◆ QuadraticForm_Vector3_double

meshlib.mrmeshpy.QuadraticForm_Vector3_double = QuadraticForm3d

◆ QuadraticForm_Vector3_float

meshlib.mrmeshpy.QuadraticForm_Vector3_float = QuadraticForm3f

◆ QuadraticForm_Vector3d_SM

meshlib.mrmeshpy.QuadraticForm_Vector3d_SM = SymMatrix3d

◆ QuadraticForm_Vector3f_SM

meshlib.mrmeshpy.QuadraticForm_Vector3f_SM = SymMatrix3f

◆ Quaternion_double

meshlib.mrmeshpy.Quaternion_double = Quaterniond

◆ Quaternion_float

meshlib.mrmeshpy.Quaternion_float = Quaternionf

◆ RigidScaleXf3_double

meshlib.mrmeshpy.RigidScaleXf3_double = RigidScaleXf3d

◆ RigidScaleXf3_double_V

meshlib.mrmeshpy.RigidScaleXf3_double_V = Vector3d

◆ RigidScaleXf3_float

meshlib.mrmeshpy.RigidScaleXf3_float = RigidScaleXf3f

◆ RigidScaleXf3_float_V

meshlib.mrmeshpy.RigidScaleXf3_float_V = Vector3f

◆ RigidXf3_double

meshlib.mrmeshpy.RigidXf3_double = RigidXf3d

◆ RigidXf3_double_V

meshlib.mrmeshpy.RigidXf3_double_V = Vector3d

◆ RigidXf3_float

meshlib.mrmeshpy.RigidXf3_float = RigidXf3f

◆ RigidXf3_float_V

meshlib.mrmeshpy.RigidXf3_float_V = Vector3f

◆ SegmPoint_double

meshlib.mrmeshpy.SegmPoint_double = SegmPointd

◆ SegmPoint_float

meshlib.mrmeshpy.SegmPoint_float = SegmPointf

◆ SeparationPointMap

meshlib.mrmeshpy.SeparationPointMap = phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul

◆ SeparationPointSet

meshlib.mrmeshpy.SeparationPointSet = std_array_Id_VertTag_3

◆ SetBitIteratorT_BitSet

meshlib.mrmeshpy.SetBitIteratorT_BitSet = SetBitIterator

◆ SetBitIteratorT_EdgeBitSet

meshlib.mrmeshpy.SetBitIteratorT_EdgeBitSet = EdgeSetBitIterator

◆ SetBitIteratorT_EdgeBitSet_IndexType

meshlib.mrmeshpy.SetBitIteratorT_EdgeBitSet_IndexType = Id_EdgeTag

◆ SetBitIteratorT_EdgeBitSet_pointer

meshlib.mrmeshpy.SetBitIteratorT_EdgeBitSet_pointer = Id_EdgeTag

◆ SetBitIteratorT_EdgeBitSet_reference

meshlib.mrmeshpy.SetBitIteratorT_EdgeBitSet_reference = Id_EdgeTag

◆ SetBitIteratorT_EdgeBitSet_value_type

meshlib.mrmeshpy.SetBitIteratorT_EdgeBitSet_value_type = Id_EdgeTag

◆ SetBitIteratorT_FaceBitSet

meshlib.mrmeshpy.SetBitIteratorT_FaceBitSet = FaceSetBitIterator

◆ SetBitIteratorT_FaceBitSet_IndexType

meshlib.mrmeshpy.SetBitIteratorT_FaceBitSet_IndexType = FaceId

◆ SetBitIteratorT_FaceBitSet_pointer

meshlib.mrmeshpy.SetBitIteratorT_FaceBitSet_pointer = FaceId

◆ SetBitIteratorT_FaceBitSet_reference

meshlib.mrmeshpy.SetBitIteratorT_FaceBitSet_reference = FaceId

◆ SetBitIteratorT_FaceBitSet_value_type

meshlib.mrmeshpy.SetBitIteratorT_FaceBitSet_value_type = FaceId

◆ SetBitIteratorT_TaggedBitSet_UndirectedEdgeTag

meshlib.mrmeshpy.SetBitIteratorT_TaggedBitSet_UndirectedEdgeTag = UndirectedEdgeSetBitIterator

◆ SetBitIteratorT_UndirectedEdgeBitSet

meshlib.mrmeshpy.SetBitIteratorT_UndirectedEdgeBitSet = UndirectedEdgeSetBitIterator

◆ SetBitIteratorT_UndirectedEdgeBitSet_IndexType

meshlib.mrmeshpy.SetBitIteratorT_UndirectedEdgeBitSet_IndexType = UndirectedEdgeId

◆ SetBitIteratorT_UndirectedEdgeBitSet_pointer

meshlib.mrmeshpy.SetBitIteratorT_UndirectedEdgeBitSet_pointer = UndirectedEdgeId

◆ SetBitIteratorT_UndirectedEdgeBitSet_reference

meshlib.mrmeshpy.SetBitIteratorT_UndirectedEdgeBitSet_reference = UndirectedEdgeId

◆ SetBitIteratorT_UndirectedEdgeBitSet_value_type

meshlib.mrmeshpy.SetBitIteratorT_UndirectedEdgeBitSet_value_type = UndirectedEdgeId

◆ SetBitIteratorT_VertBitSet

meshlib.mrmeshpy.SetBitIteratorT_VertBitSet = VertSetBitIterator

◆ SetBitIteratorT_VertBitSet_IndexType

meshlib.mrmeshpy.SetBitIteratorT_VertBitSet_IndexType = VertId

◆ SetBitIteratorT_VertBitSet_pointer

meshlib.mrmeshpy.SetBitIteratorT_VertBitSet_pointer = VertId

◆ SetBitIteratorT_VertBitSet_reference

meshlib.mrmeshpy.SetBitIteratorT_VertBitSet_reference = VertId

◆ SetBitIteratorT_VertBitSet_value_type

meshlib.mrmeshpy.SetBitIteratorT_VertBitSet_value_type = VertId

◆ Sphere3_float

meshlib.mrmeshpy.Sphere3_float = Sphere3f

◆ Sphere_Vector2_double

meshlib.mrmeshpy.Sphere_Vector2_double = Sphere2d

◆ Sphere_Vector2_float

meshlib.mrmeshpy.Sphere_Vector2_float = Sphere2f

◆ Sphere_Vector3_double

meshlib.mrmeshpy.Sphere_Vector3_double = Sphere3d

◆ Sphere_Vector3_float

meshlib.mrmeshpy.Sphere_Vector3_float = Sphere3f

◆ Sphere_Vector3f

meshlib.mrmeshpy.Sphere_Vector3f = Sphere3f

◆ std_array_AffineXf3d_4

meshlib.mrmeshpy.std_array_AffineXf3d_4 = std_array_AffineXf_Vector3_double_4

◆ std_array_AffineXf3f_4

meshlib.mrmeshpy.std_array_AffineXf3f_4 = std_array_AffineXf_Vector3_float_4

◆ std_array_BooleanResultMapper_Maps_size_t_MapObject_Count

meshlib.mrmeshpy.std_array_BooleanResultMapper_Maps_size_t_MapObject_Count = std_array_BooleanResultMapper_Maps_2

◆ std_array_SimpleVolumeMinMax_3

meshlib.mrmeshpy.std_array_SimpleVolumeMinMax_3 = std_array_VoxelsVolumeMinMax_std_vector_float_3

◆ std_array_std_filesystem_path_size_t_SystemFontType_Count

meshlib.mrmeshpy.std_array_std_filesystem_path_size_t_SystemFontType_Count = std_array_std_filesystem_path_4

◆ std_array_Vector3d_3

meshlib.mrmeshpy.std_array_Vector3d_3 = std_array_Vector3_double_3

◆ std_array_Vector3f_3

meshlib.mrmeshpy.std_array_Vector3f_3 = std_array_Vector3_float_3

◆ std_array_Vector3i_3

meshlib.mrmeshpy.std_array_Vector3i_3 = std_array_Vector3_int_3

◆ std_array_VertId_3

meshlib.mrmeshpy.std_array_VertId_3 = std_array_Id_VertTag_3

◆ std_array_VertId_size_t_NeighborDir_Count

meshlib.mrmeshpy.std_array_VertId_size_t_NeighborDir_Count = std_array_Id_VertTag_3

◆ std_optional_Box1f

meshlib.mrmeshpy.std_optional_Box1f = std_optional_Box_float

◆ std_optional_Box3f

meshlib.mrmeshpy.std_optional_Box3f = std_optional_Box_Vector3_float

◆ std_optional_MinMaxf

meshlib.mrmeshpy.std_optional_MinMaxf = std_optional_Box_float

◆ std_optional_Vector2f

meshlib.mrmeshpy.std_optional_Vector2f = std_optional_Vector2_float

◆ std_optional_Vector3f

meshlib.mrmeshpy.std_optional_Vector3f = std_optional_Vector3_float

◆ std_shared_ptr_ChangeActiveBoxAction_Obj

meshlib.mrmeshpy.std_shared_ptr_ChangeActiveBoxAction_Obj = ObjectVoxels

◆ std_shared_ptr_ChangeDualMarchingCubesAction_Obj

meshlib.mrmeshpy.std_shared_ptr_ChangeDualMarchingCubesAction_Obj = ObjectVoxels

◆ std_shared_ptr_ChangeGridAction_Obj

meshlib.mrmeshpy.std_shared_ptr_ChangeGridAction_Obj = ObjectVoxels

◆ std_shared_ptr_ChangeIsoAction_Obj

meshlib.mrmeshpy.std_shared_ptr_ChangeIsoAction_Obj = ObjectVoxels

◆ std_shared_ptr_ChangeSurfaceAction_Obj

meshlib.mrmeshpy.std_shared_ptr_ChangeSurfaceAction_Obj = ObjectVoxels

◆ std_shared_ptr_ChangVoxelSelectionAction_Obj

meshlib.mrmeshpy.std_shared_ptr_ChangVoxelSelectionAction_Obj = ObjectVoxels

◆ std_shared_ptr_GcodeSource

meshlib.mrmeshpy.std_shared_ptr_GcodeSource = std_vector_std_string

◆ std_unique_ptr_NoDefInit_FaceId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_FaceId_pointer = NoDefInit_FaceId

◆ std_unique_ptr_NoDefInit_GraphEdgeId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_GraphEdgeId_pointer = NoDefInit_GraphEdgeId

◆ std_unique_ptr_NoDefInit_GraphVertId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_GraphVertId_pointer = NoDefInit_GraphVertId

◆ std_unique_ptr_NoDefInit_Id_EdgeTag_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_Id_EdgeTag_pointer = NoDefInit_Id_EdgeTag

◆ std_unique_ptr_NoDefInit_Id_ICPElemtTag_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_Id_ICPElemtTag_pointer = NoDefInit_Id_ICPElemtTag

◆ std_unique_ptr_NoDefInit_Id_VoxelTag_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_Id_VoxelTag_pointer = NoDefInit_Id_VoxelTag

◆ std_unique_ptr_NoDefInit_NodeId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_NodeId_pointer = NoDefInit_NodeId

◆ std_unique_ptr_NoDefInit_ObjId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_ObjId_pointer = NoDefInit_ObjId

◆ std_unique_ptr_NoDefInit_PixelId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_PixelId_pointer = NoDefInit_PixelId

◆ std_unique_ptr_NoDefInit_RegionId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_RegionId_pointer = NoDefInit_RegionId

◆ std_unique_ptr_NoDefInit_TextureId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_TextureId_pointer = NoDefInit_TextureId

◆ std_unique_ptr_NoDefInit_UndirectedEdgeId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_UndirectedEdgeId_pointer = NoDefInit_UndirectedEdgeId

◆ std_unique_ptr_NoDefInit_VertId_pointer

meshlib.mrmeshpy.std_unique_ptr_NoDefInit_VertId_pointer = NoDefInit_VertId

◆ std_variant_FaceId_EdgeId_VertId

meshlib.mrmeshpy.std_variant_FaceId_EdgeId_VertId = std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag

◆ std_variant_FaceId_Id_EdgeTag_VertId

meshlib.mrmeshpy.std_variant_FaceId_Id_EdgeTag_VertId = std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag

◆ std_variant_Features_Primitives_Sphere_Features_Primitives_ConeSegment_Features_Primitives_Plane

meshlib.mrmeshpy.std_variant_Features_Primitives_Sphere_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

◆ std_variant_float_Vector3f

meshlib.mrmeshpy.std_variant_float_Vector3f = std_variant_float_Vector3_float

◆ std_variant_MeshTriPoint_EdgePoint_VertId_int

meshlib.mrmeshpy.std_variant_MeshTriPoint_EdgePoint_VertId_int = std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int

◆ std_variant_Polynomial_double_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6

meshlib.mrmeshpy.std_variant_Polynomial_double_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6 = std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul

◆ std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6

meshlib.mrmeshpy.std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6 = std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul

◆ std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane

meshlib.mrmeshpy.std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

◆ std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f = std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box_Vector3_float

◆ std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_const_reference

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_const_reference = AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

◆ std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_reference

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_reference = AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

◆ std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_value_type

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_value_type = AABBTreeNode_AABBTreeTraits_FaceTag_Box3f

◆ std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f = std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector2_float

◆ std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_const_reference

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_const_reference = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

◆ std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_reference

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_reference = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

◆ std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_value_type

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_value_type = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

◆ std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f = std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector3_float

◆ std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_const_reference

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_const_reference = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

◆ std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_reference

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_reference = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

◆ std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_value_type

meshlib.mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_value_type = AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

◆ std_vector_AABBTreeNode_ObjTreeTraits_const_reference

meshlib.mrmeshpy.std_vector_AABBTreeNode_ObjTreeTraits_const_reference = AABBTreeNode_ObjTreeTraits

◆ std_vector_AABBTreeNode_ObjTreeTraits_reference

meshlib.mrmeshpy.std_vector_AABBTreeNode_ObjTreeTraits_reference = AABBTreeNode_ObjTreeTraits

◆ std_vector_AABBTreeNode_ObjTreeTraits_value_type

meshlib.mrmeshpy.std_vector_AABBTreeNode_ObjTreeTraits_value_type = AABBTreeNode_ObjTreeTraits

◆ std_vector_AABBTreePoints_Node_const_reference

meshlib.mrmeshpy.std_vector_AABBTreePoints_Node_const_reference = AABBTreePoints.Node

◆ std_vector_AABBTreePoints_Node_reference

meshlib.mrmeshpy.std_vector_AABBTreePoints_Node_reference = AABBTreePoints.Node

◆ std_vector_AABBTreePoints_Node_value_type

meshlib.mrmeshpy.std_vector_AABBTreePoints_Node_value_type = AABBTreePoints.Node

◆ std_vector_AffineXf3f

meshlib.mrmeshpy.std_vector_AffineXf3f = std_vector_AffineXf_Vector3_float

◆ std_vector_AffineXf3f_const_reference

meshlib.mrmeshpy.std_vector_AffineXf3f_const_reference = AffineXf3f

◆ std_vector_AffineXf3f_reference

meshlib.mrmeshpy.std_vector_AffineXf3f_reference = AffineXf3f

◆ std_vector_AffineXf3f_value_type

meshlib.mrmeshpy.std_vector_AffineXf3f_value_type = AffineXf3f

◆ std_vector_Color_const_reference

meshlib.mrmeshpy.std_vector_Color_const_reference = Color

◆ std_vector_Color_reference

meshlib.mrmeshpy.std_vector_Color_reference = Color

◆ std_vector_Color_value_type

meshlib.mrmeshpy.std_vector_Color_value_type = Color

◆ std_vector_const_Mesh

meshlib.mrmeshpy.std_vector_const_Mesh = std_vector_Mesh_const

◆ std_vector_ContinuousContour

meshlib.mrmeshpy.std_vector_ContinuousContour = std_vector_std_vector_VariableEdgeTri

◆ std_vector_Contour3d

meshlib.mrmeshpy.std_vector_Contour3d = std_vector_std_vector_Vector3_double

◆ std_vector_Contour3f

meshlib.mrmeshpy.std_vector_Contour3f = std_vector_std_vector_Vector3_float

◆ std_vector_Dipole_const_reference

meshlib.mrmeshpy.std_vector_Dipole_const_reference = Dipole

◆ std_vector_Dipole_reference

meshlib.mrmeshpy.std_vector_Dipole_reference = Dipole

◆ std_vector_Dipole_value_type

meshlib.mrmeshpy.std_vector_Dipole_value_type = Dipole

◆ std_vector_EdgeBitSet

meshlib.mrmeshpy.std_vector_EdgeBitSet = std_vector_TaggedBitSet_EdgeTag

◆ std_vector_EdgeId

meshlib.mrmeshpy.std_vector_EdgeId = std_vector_Id_EdgeTag

◆ std_vector_EdgeLoop

meshlib.mrmeshpy.std_vector_EdgeLoop = std_vector_std_vector_Id_EdgeTag

◆ std_vector_EdgePair

meshlib.mrmeshpy.std_vector_EdgePair = std_vector_std_pair_Id_EdgeTag_Id_EdgeTag

◆ std_vector_EdgePath

meshlib.mrmeshpy.std_vector_EdgePath = std_vector_std_vector_Id_EdgeTag

◆ std_vector_FaceBitSet

meshlib.mrmeshpy.std_vector_FaceBitSet = std_vector_TaggedBitSet_FaceTag

◆ std_vector_FaceBitSet_const_reference

meshlib.mrmeshpy.std_vector_FaceBitSet_const_reference = FaceBitSet

◆ std_vector_FaceBitSet_reference

meshlib.mrmeshpy.std_vector_FaceBitSet_reference = FaceBitSet

◆ std_vector_FaceBitSet_value_type

meshlib.mrmeshpy.std_vector_FaceBitSet_value_type = FaceBitSet

◆ std_vector_FaceId

meshlib.mrmeshpy.std_vector_FaceId = std_vector_Id_FaceTag

◆ std_vector_FaceId_const_reference

meshlib.mrmeshpy.std_vector_FaceId_const_reference = FaceId

◆ std_vector_FaceId_reference

meshlib.mrmeshpy.std_vector_FaceId_reference = FaceId

◆ std_vector_FaceId_value_type

meshlib.mrmeshpy.std_vector_FaceId_value_type = FaceId

◆ std_vector_FanRecord_const_reference

meshlib.mrmeshpy.std_vector_FanRecord_const_reference = FanRecord

◆ std_vector_FanRecord_reference

meshlib.mrmeshpy.std_vector_FanRecord_reference = FanRecord

◆ std_vector_FanRecord_value_type

meshlib.mrmeshpy.std_vector_FanRecord_value_type = FanRecord

◆ std_vector_Features_Primitives_Variant

meshlib.mrmeshpy.std_vector_Features_Primitives_Variant = std_vector_std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

◆ std_vector_Graph_EdgeId

meshlib.mrmeshpy.std_vector_Graph_EdgeId = std_vector_Id_GraphEdgeTag

◆ std_vector_Graph_EndVertices_const_reference

meshlib.mrmeshpy.std_vector_Graph_EndVertices_const_reference = Graph.EndVertices

◆ std_vector_Graph_EndVertices_reference

meshlib.mrmeshpy.std_vector_Graph_EndVertices_reference = Graph.EndVertices

◆ std_vector_Graph_EndVertices_value_type

meshlib.mrmeshpy.std_vector_Graph_EndVertices_value_type = Graph.EndVertices

◆ std_vector_GraphEdgeId

meshlib.mrmeshpy.std_vector_GraphEdgeId = std_vector_Id_GraphEdgeTag

◆ std_vector_GraphEdgeId_const_reference

meshlib.mrmeshpy.std_vector_GraphEdgeId_const_reference = GraphEdgeId

◆ std_vector_GraphEdgeId_reference

meshlib.mrmeshpy.std_vector_GraphEdgeId_reference = GraphEdgeId

◆ std_vector_GraphEdgeId_value_type

meshlib.mrmeshpy.std_vector_GraphEdgeId_value_type = GraphEdgeId

◆ std_vector_GraphVertId

meshlib.mrmeshpy.std_vector_GraphVertId = std_vector_Id_GraphVertTag

◆ std_vector_GraphVertId_const_reference

meshlib.mrmeshpy.std_vector_GraphVertId_const_reference = GraphVertId

◆ std_vector_GraphVertId_reference

meshlib.mrmeshpy.std_vector_GraphVertId_reference = GraphVertId

◆ std_vector_GraphVertId_value_type

meshlib.mrmeshpy.std_vector_GraphVertId_value_type = GraphVertId

◆ std_vector_Heap_float_GraphVertId_std_greater_float_Element

meshlib.mrmeshpy.std_vector_Heap_float_GraphVertId_std_greater_float_Element = std_vector_Heap_float_Id_GraphVertTag_std_greater_float_Element

◆ std_vector_ICPGroupPairs_const_reference

meshlib.mrmeshpy.std_vector_ICPGroupPairs_const_reference = ICPGroupPairs

◆ std_vector_ICPGroupPairs_reference

meshlib.mrmeshpy.std_vector_ICPGroupPairs_reference = ICPGroupPairs

◆ std_vector_ICPGroupPairs_value_type

meshlib.mrmeshpy.std_vector_ICPGroupPairs_value_type = ICPGroupPairs

◆ std_vector_Id_EdgeTag_const_reference

meshlib.mrmeshpy.std_vector_Id_EdgeTag_const_reference = Id_EdgeTag

◆ std_vector_Id_EdgeTag_reference

meshlib.mrmeshpy.std_vector_Id_EdgeTag_reference = Id_EdgeTag

◆ std_vector_Id_EdgeTag_value_type

meshlib.mrmeshpy.std_vector_Id_EdgeTag_value_type = Id_EdgeTag

◆ std_vector_Id_ICPElemtTag_const_reference

meshlib.mrmeshpy.std_vector_Id_ICPElemtTag_const_reference = Id_ICPElemtTag

◆ std_vector_Id_ICPElemtTag_reference

meshlib.mrmeshpy.std_vector_Id_ICPElemtTag_reference = Id_ICPElemtTag

◆ std_vector_Id_ICPElemtTag_value_type

meshlib.mrmeshpy.std_vector_Id_ICPElemtTag_value_type = Id_ICPElemtTag

◆ std_vector_Id_VoxelTag_const_reference

meshlib.mrmeshpy.std_vector_Id_VoxelTag_const_reference = Id_VoxelTag

◆ std_vector_Id_VoxelTag_reference

meshlib.mrmeshpy.std_vector_Id_VoxelTag_reference = Id_VoxelTag

◆ std_vector_Id_VoxelTag_value_type

meshlib.mrmeshpy.std_vector_Id_VoxelTag_value_type = Id_VoxelTag

◆ std_vector_Line3dMesh

meshlib.mrmeshpy.std_vector_Line3dMesh = std_vector_Line3Mesh_double

◆ std_vector_Line3fMesh

meshlib.mrmeshpy.std_vector_Line3fMesh = std_vector_Line3Mesh_float

◆ std_vector_MeshBuilder_VertSpan_const_reference

meshlib.mrmeshpy.std_vector_MeshBuilder_VertSpan_const_reference = MeshBuilder.VertSpan

◆ std_vector_MeshBuilder_VertSpan_reference

meshlib.mrmeshpy.std_vector_MeshBuilder_VertSpan_reference = MeshBuilder.VertSpan

◆ std_vector_MeshBuilder_VertSpan_value_type

meshlib.mrmeshpy.std_vector_MeshBuilder_VertSpan_value_type = MeshBuilder.VertSpan

◆ std_vector_MeshEdgePoint

meshlib.mrmeshpy.std_vector_MeshEdgePoint = std_vector_EdgePoint

◆ std_vector_MeshOrPointsXf_const_reference

meshlib.mrmeshpy.std_vector_MeshOrPointsXf_const_reference = MeshOrPointsXf

◆ std_vector_MeshOrPointsXf_reference

meshlib.mrmeshpy.std_vector_MeshOrPointsXf_reference = MeshOrPointsXf

◆ std_vector_MeshOrPointsXf_value_type

meshlib.mrmeshpy.std_vector_MeshOrPointsXf_value_type = MeshOrPointsXf

◆ std_vector_MeshTexture_const_reference

meshlib.mrmeshpy.std_vector_MeshTexture_const_reference = MeshTexture

◆ std_vector_MeshTexture_reference

meshlib.mrmeshpy.std_vector_MeshTexture_reference = MeshTexture

◆ std_vector_MeshTexture_value_type

meshlib.mrmeshpy.std_vector_MeshTexture_value_type = MeshTexture

◆ std_vector_ModelPointsData_const_reference

meshlib.mrmeshpy.std_vector_ModelPointsData_const_reference = ModelPointsData

◆ std_vector_ModelPointsData_reference

meshlib.mrmeshpy.std_vector_ModelPointsData_reference = ModelPointsData

◆ std_vector_ModelPointsData_value_type

meshlib.mrmeshpy.std_vector_ModelPointsData_value_type = ModelPointsData

◆ std_vector_MultipleEdge

meshlib.mrmeshpy.std_vector_MultipleEdge = std_vector_std_pair_Id_VertTag_Id_VertTag

◆ std_vector_NodeId

meshlib.mrmeshpy.std_vector_NodeId = std_vector_Id_NodeTag

◆ std_vector_NodeId_const_reference

meshlib.mrmeshpy.std_vector_NodeId_const_reference = NodeId

◆ std_vector_NodeId_reference

meshlib.mrmeshpy.std_vector_NodeId_reference = NodeId

◆ std_vector_NodeId_value_type

meshlib.mrmeshpy.std_vector_NodeId_value_type = NodeId

◆ std_vector_ObjectPtr

meshlib.mrmeshpy.std_vector_ObjectPtr = std_vector_std_shared_ptr_Object

◆ std_vector_ObjId

meshlib.mrmeshpy.std_vector_ObjId = std_vector_Id_ObjTag

◆ std_vector_ObjId_const_reference

meshlib.mrmeshpy.std_vector_ObjId_const_reference = ObjId

◆ std_vector_ObjId_reference

meshlib.mrmeshpy.std_vector_ObjId_reference = ObjId

◆ std_vector_ObjId_value_type

meshlib.mrmeshpy.std_vector_ObjId_value_type = ObjId

◆ std_vector_OffsetContoursVertMap

meshlib.mrmeshpy.std_vector_OffsetContoursVertMap = std_vector_std_vector_OffsetContoursOrigins

◆ std_vector_PixelId

meshlib.mrmeshpy.std_vector_PixelId = std_vector_Id_PixelTag

◆ std_vector_PixelId_const_reference

meshlib.mrmeshpy.std_vector_PixelId_const_reference = PixelId

◆ std_vector_PixelId_reference

meshlib.mrmeshpy.std_vector_PixelId_reference = PixelId

◆ std_vector_PixelId_value_type

meshlib.mrmeshpy.std_vector_PixelId_value_type = PixelId

◆ std_vector_PlanarTriangulation_ContourIdMap

meshlib.mrmeshpy.std_vector_PlanarTriangulation_ContourIdMap = std_vector_std_vector_PlanarTriangulation_IntersectionInfo

◆ std_vector_PlanarTriangulation_HoleVertIds

meshlib.mrmeshpy.std_vector_PlanarTriangulation_HoleVertIds = std_vector_std_vector_Id_VertTag

◆ std_vector_Polyline3

meshlib.mrmeshpy.std_vector_Polyline3 = std_vector_Polyline_Vector3_float

◆ std_vector_QuadraticForm2f

meshlib.mrmeshpy.std_vector_QuadraticForm2f = std_vector_QuadraticForm_Vector2_float

◆ std_vector_QuadraticForm2f_const_reference

meshlib.mrmeshpy.std_vector_QuadraticForm2f_const_reference = QuadraticForm2f

◆ std_vector_QuadraticForm2f_reference

meshlib.mrmeshpy.std_vector_QuadraticForm2f_reference = QuadraticForm2f

◆ std_vector_QuadraticForm2f_value_type

meshlib.mrmeshpy.std_vector_QuadraticForm2f_value_type = QuadraticForm2f

◆ std_vector_QuadraticForm3f

meshlib.mrmeshpy.std_vector_QuadraticForm3f = std_vector_QuadraticForm_Vector3_float

◆ std_vector_QuadraticForm3f_const_reference

meshlib.mrmeshpy.std_vector_QuadraticForm3f_const_reference = QuadraticForm3f

◆ std_vector_QuadraticForm3f_reference

meshlib.mrmeshpy.std_vector_QuadraticForm3f_reference = QuadraticForm3f

◆ std_vector_QuadraticForm3f_value_type

meshlib.mrmeshpy.std_vector_QuadraticForm3f_value_type = QuadraticForm3f

◆ std_vector_RegionId

meshlib.mrmeshpy.std_vector_RegionId = std_vector_Id_RegionTag

◆ std_vector_RegionId_const_reference

meshlib.mrmeshpy.std_vector_RegionId_const_reference = RegionId

◆ std_vector_RegionId_reference

meshlib.mrmeshpy.std_vector_RegionId_reference = RegionId

◆ std_vector_RegionId_value_type

meshlib.mrmeshpy.std_vector_RegionId_value_type = RegionId

◆ std_vector_RigidXf3d

meshlib.mrmeshpy.std_vector_RigidXf3d = std_vector_RigidXf3_double

◆ std_vector_size_t

meshlib.mrmeshpy.std_vector_size_t = std_vector_unsigned_long

◆ std_vector_std_array_std_filesystem_path_4

meshlib.mrmeshpy.std_vector_std_array_std_filesystem_path_4 = std_vector_std_array_std_filesystem_path_4ul

◆ std_vector_std_array_Vector3f_3

meshlib.mrmeshpy.std_vector_std_array_Vector3f_3 = std_vector_std_array_Vector3_float_3ul

◆ std_vector_std_array_Vector3f_3_const_reference

meshlib.mrmeshpy.std_vector_std_array_Vector3f_3_const_reference = std_array_Vector3_float_3

◆ std_vector_std_array_Vector3f_3_reference

meshlib.mrmeshpy.std_vector_std_array_Vector3f_3_reference = std_array_Vector3_float_3

◆ std_vector_std_array_Vector3f_3_value_type

meshlib.mrmeshpy.std_vector_std_array_Vector3f_3_value_type = std_array_Vector3_float_3

◆ std_vector_std_array_VertId_3

meshlib.mrmeshpy.std_vector_std_array_VertId_3 = std_vector_std_array_Id_VertTag_3ul

◆ std_vector_std_array_VertId_3_const_reference

meshlib.mrmeshpy.std_vector_std_array_VertId_3_const_reference = std_array_Id_VertTag_3

◆ std_vector_std_array_VertId_3_reference

meshlib.mrmeshpy.std_vector_std_array_VertId_3_reference = std_array_Id_VertTag_3

◆ std_vector_std_array_VertId_3_value_type

meshlib.mrmeshpy.std_vector_std_array_VertId_3_value_type = std_array_Id_VertTag_3

◆ std_vector_std_pair_size_t_size_t

meshlib.mrmeshpy.std_vector_std_pair_size_t_size_t = std_vector_std_pair_unsigned_long_unsigned_long

◆ std_vector_std_pair_Vector3f_Vector3f

meshlib.mrmeshpy.std_vector_std_pair_Vector3f_Vector3f = std_vector_std_pair_Vector3_float_Vector3_float

◆ std_vector_std_pair_VertId_VertId

meshlib.mrmeshpy.std_vector_std_pair_VertId_VertId = std_vector_std_pair_Id_VertTag_Id_VertTag

◆ std_vector_std_shared_ptr_const_Object

meshlib.mrmeshpy.std_vector_std_shared_ptr_const_Object = std_vector_std_shared_ptr_Object_const

◆ std_vector_std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane

meshlib.mrmeshpy.std_vector_std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_vector_std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

◆ std_vector_std_vector_EdgePoint_const_reference

meshlib.mrmeshpy.std_vector_std_vector_EdgePoint_const_reference = std_vector_EdgePoint

◆ std_vector_std_vector_EdgePoint_reference

meshlib.mrmeshpy.std_vector_std_vector_EdgePoint_reference = std_vector_EdgePoint

◆ std_vector_std_vector_EdgePoint_value_type

meshlib.mrmeshpy.std_vector_std_vector_EdgePoint_value_type = std_vector_EdgePoint

◆ std_vector_std_vector_GraphEdgeId

meshlib.mrmeshpy.std_vector_std_vector_GraphEdgeId = std_vector_std_vector_Id_GraphEdgeTag

◆ std_vector_std_vector_GraphEdgeId_const_reference

meshlib.mrmeshpy.std_vector_std_vector_GraphEdgeId_const_reference = std_vector_Id_GraphEdgeTag

◆ std_vector_std_vector_GraphEdgeId_reference

meshlib.mrmeshpy.std_vector_std_vector_GraphEdgeId_reference = std_vector_Id_GraphEdgeTag

◆ std_vector_std_vector_GraphEdgeId_value_type

meshlib.mrmeshpy.std_vector_std_vector_GraphEdgeId_value_type = std_vector_Id_GraphEdgeTag

◆ std_vector_std_vector_ObjVertId_const_reference

meshlib.mrmeshpy.std_vector_std_vector_ObjVertId_const_reference = std_vector_ObjVertId

◆ std_vector_std_vector_ObjVertId_reference

meshlib.mrmeshpy.std_vector_std_vector_ObjVertId_reference = std_vector_ObjVertId

◆ std_vector_std_vector_ObjVertId_value_type

meshlib.mrmeshpy.std_vector_std_vector_ObjVertId_value_type = std_vector_ObjVertId

◆ std_vector_std_vector_Vector2d

meshlib.mrmeshpy.std_vector_std_vector_Vector2d = std_vector_std_vector_Vector2_double

◆ std_vector_std_vector_Vector2f

meshlib.mrmeshpy.std_vector_std_vector_Vector2f = std_vector_std_vector_Vector2_float

◆ std_vector_std_vector_Vector3d

meshlib.mrmeshpy.std_vector_std_vector_Vector3d = std_vector_std_vector_Vector3_double

◆ std_vector_std_vector_Vector3f

meshlib.mrmeshpy.std_vector_std_vector_Vector3f = std_vector_std_vector_Vector3_float

◆ std_vector_std_vector_VertId

meshlib.mrmeshpy.std_vector_std_vector_VertId = std_vector_std_vector_Id_VertTag

◆ std_vector_SurfacePath

meshlib.mrmeshpy.std_vector_SurfacePath = std_vector_std_vector_EdgePoint

◆ std_vector_SystemPath_SystemFontPaths

meshlib.mrmeshpy.std_vector_SystemPath_SystemFontPaths = std_vector_std_array_std_filesystem_path_4ul

◆ std_vector_TextureId

meshlib.mrmeshpy.std_vector_TextureId = std_vector_Id_TextureTag

◆ std_vector_TextureId_const_reference

meshlib.mrmeshpy.std_vector_TextureId_const_reference = TextureId

◆ std_vector_TextureId_reference

meshlib.mrmeshpy.std_vector_TextureId_reference = TextureId

◆ std_vector_TextureId_value_type

meshlib.mrmeshpy.std_vector_TextureId_value_type = TextureId

◆ std_vector_ThreeVertIds

meshlib.mrmeshpy.std_vector_ThreeVertIds = std_vector_std_array_Id_VertTag_3ul

◆ std_vector_Triangle3f

meshlib.mrmeshpy.std_vector_Triangle3f = std_vector_std_array_Vector3_float_3ul

◆ std_vector_TriPointf

meshlib.mrmeshpy.std_vector_TriPointf = std_vector_TriPoint_float

◆ std_vector_uint8_t

meshlib.mrmeshpy.std_vector_uint8_t = std_vector_unsigned_char

◆ std_vector_UndirectedEdgeBitSet

meshlib.mrmeshpy.std_vector_UndirectedEdgeBitSet = std_vector_TaggedBitSet_UndirectedEdgeTag

◆ std_vector_UndirectedEdgeId

meshlib.mrmeshpy.std_vector_UndirectedEdgeId = std_vector_Id_UndirectedEdgeTag

◆ std_vector_UndirectedEdgeId_const_reference

meshlib.mrmeshpy.std_vector_UndirectedEdgeId_const_reference = UndirectedEdgeId

◆ std_vector_UndirectedEdgeId_reference

meshlib.mrmeshpy.std_vector_UndirectedEdgeId_reference = UndirectedEdgeId

◆ std_vector_UndirectedEdgeId_value_type

meshlib.mrmeshpy.std_vector_UndirectedEdgeId_value_type = UndirectedEdgeId

◆ std_vector_UVCoord

meshlib.mrmeshpy.std_vector_UVCoord = std_vector_Vector2_float

◆ std_vector_VdbVolume

meshlib.mrmeshpy.std_vector_VdbVolume = std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid

◆ std_vector_Vector2d

meshlib.mrmeshpy.std_vector_Vector2d = std_vector_Vector2_double

◆ std_vector_Vector2f

meshlib.mrmeshpy.std_vector_Vector2f = std_vector_Vector2_float

◆ std_vector_Vector2f_const_reference

meshlib.mrmeshpy.std_vector_Vector2f_const_reference = Vector2f

◆ std_vector_Vector2f_reference

meshlib.mrmeshpy.std_vector_Vector2f_reference = Vector2f

◆ std_vector_Vector2f_value_type

meshlib.mrmeshpy.std_vector_Vector2f_value_type = Vector2f

◆ std_vector_Vector3d

meshlib.mrmeshpy.std_vector_Vector3d = std_vector_Vector3_double

◆ std_vector_Vector3f

meshlib.mrmeshpy.std_vector_Vector3f = std_vector_Vector3_float

◆ std_vector_Vector3f_const_reference

meshlib.mrmeshpy.std_vector_Vector3f_const_reference = Vector3f

◆ std_vector_Vector3f_reference

meshlib.mrmeshpy.std_vector_Vector3f_reference = Vector3f

◆ std_vector_Vector3f_value_type

meshlib.mrmeshpy.std_vector_Vector3f_value_type = Vector3f

◆ std_vector_Vector3i

meshlib.mrmeshpy.std_vector_Vector3i = std_vector_Vector3_int

◆ std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_const_reference

meshlib.mrmeshpy.std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_const_reference = Vector_ICPGroupPairs_Id_ICPElemtTag

◆ std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_reference

meshlib.mrmeshpy.std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_reference = Vector_ICPGroupPairs_Id_ICPElemtTag

◆ std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_value_type

meshlib.mrmeshpy.std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_value_type = Vector_ICPGroupPairs_Id_ICPElemtTag

◆ std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_const_reference

meshlib.mrmeshpy.std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_const_reference = Vector_std_vector_ObjVertId_Id_ICPElemtTag

◆ std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_reference

meshlib.mrmeshpy.std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_reference = Vector_std_vector_ObjVertId_Id_ICPElemtTag

◆ std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_value_type

meshlib.mrmeshpy.std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_value_type = Vector_std_vector_ObjVertId_Id_ICPElemtTag

◆ std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_const_reference

meshlib.mrmeshpy.std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_const_reference = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

◆ std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_reference

meshlib.mrmeshpy.std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_reference = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

◆ std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_value_type

meshlib.mrmeshpy.std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_value_type = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

◆ std_vector_VertBitSet

meshlib.mrmeshpy.std_vector_VertBitSet = std_vector_TaggedBitSet_VertTag

◆ std_vector_VertBitSet_const_reference

meshlib.mrmeshpy.std_vector_VertBitSet_const_reference = VertBitSet

◆ std_vector_VertBitSet_reference

meshlib.mrmeshpy.std_vector_VertBitSet_reference = VertBitSet

◆ std_vector_VertBitSet_value_type

meshlib.mrmeshpy.std_vector_VertBitSet_value_type = VertBitSet

◆ std_vector_VertId

meshlib.mrmeshpy.std_vector_VertId = std_vector_Id_VertTag

◆ std_vector_VertId_const_reference

meshlib.mrmeshpy.std_vector_VertId_const_reference = VertId

◆ std_vector_VertId_reference

meshlib.mrmeshpy.std_vector_VertId_reference = VertId

◆ std_vector_VertId_value_type

meshlib.mrmeshpy.std_vector_VertId_value_type = VertId

◆ std_vector_VoxelBitSet

meshlib.mrmeshpy.std_vector_VoxelBitSet = std_vector_TaggedBitSet_VoxelTag

◆ std_vector_WatershedGraph_BasinInfo_const_reference

meshlib.mrmeshpy.std_vector_WatershedGraph_BasinInfo_const_reference = WatershedGraph.BasinInfo

◆ std_vector_WatershedGraph_BasinInfo_reference

meshlib.mrmeshpy.std_vector_WatershedGraph_BasinInfo_reference = WatershedGraph.BasinInfo

◆ std_vector_WatershedGraph_BasinInfo_value_type

meshlib.mrmeshpy.std_vector_WatershedGraph_BasinInfo_value_type = WatershedGraph.BasinInfo

◆ std_vector_WatershedGraph_BdInfo_const_reference

meshlib.mrmeshpy.std_vector_WatershedGraph_BdInfo_const_reference = WatershedGraph.BdInfo

◆ std_vector_WatershedGraph_BdInfo_reference

meshlib.mrmeshpy.std_vector_WatershedGraph_BdInfo_reference = WatershedGraph.BdInfo

◆ std_vector_WatershedGraph_BdInfo_value_type

meshlib.mrmeshpy.std_vector_WatershedGraph_BdInfo_value_type = WatershedGraph.BdInfo

◆ SurfacePath

meshlib.mrmeshpy.SurfacePath = std_vector_EdgePoint

◆ SurfacePaths

meshlib.mrmeshpy.SurfacePaths = std_vector_std_vector_EdgePoint

◆ SymMatrix2_bool

meshlib.mrmeshpy.SymMatrix2_bool = SymMatrix2b

◆ SymMatrix2_double

meshlib.mrmeshpy.SymMatrix2_double = SymMatrix2d

◆ SymMatrix2_float

meshlib.mrmeshpy.SymMatrix2_float = SymMatrix2f

◆ SymMatrix2_int

meshlib.mrmeshpy.SymMatrix2_int = SymMatrix2i

◆ SymMatrix2_long_long

meshlib.mrmeshpy.SymMatrix2_long_long = SymMatrix2ll

◆ SymMatrix3_bool

meshlib.mrmeshpy.SymMatrix3_bool = SymMatrix3b

◆ SymMatrix3_double

meshlib.mrmeshpy.SymMatrix3_double = SymMatrix3d

◆ SymMatrix3_float

meshlib.mrmeshpy.SymMatrix3_float = SymMatrix3f

◆ SymMatrix3_int

meshlib.mrmeshpy.SymMatrix3_int = SymMatrix3i

◆ SymMatrix3_long_long

meshlib.mrmeshpy.SymMatrix3_long_long = SymMatrix3ll

◆ SymMatrix4_bool

meshlib.mrmeshpy.SymMatrix4_bool = SymMatrix4b

◆ SymMatrix4_double

meshlib.mrmeshpy.SymMatrix4_double = SymMatrix4d

◆ SymMatrix4_float

meshlib.mrmeshpy.SymMatrix4_float = SymMatrix4f

◆ SymMatrix4_int

meshlib.mrmeshpy.SymMatrix4_int = SymMatrix4i

◆ SymMatrix4_long_long

meshlib.mrmeshpy.SymMatrix4_long_long = SymMatrix4ll

◆ TaggedBitSet_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafTag

meshlib.mrmeshpy.TaggedBitSet_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_LeafTag = FaceBitSet

◆ TaggedBitSet_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafTag

meshlib.mrmeshpy.TaggedBitSet_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_LeafTag = UndirectedEdgeBitSet

◆ TaggedBitSet_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafTag

meshlib.mrmeshpy.TaggedBitSet_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_LeafTag = UndirectedEdgeBitSet

◆ TaggedBitSet_AABBTreeBase_ObjTreeTraits_LeafTag

meshlib.mrmeshpy.TaggedBitSet_AABBTreeBase_ObjTreeTraits_LeafTag = ObjBitSet

◆ TaggedBitSet_EdgeTag

meshlib.mrmeshpy.TaggedBitSet_EdgeTag = EdgeBitSet

◆ TaggedBitSet_EdgeTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_EdgeTag_IndexType = Id_EdgeTag

◆ TaggedBitSet_FaceTag

meshlib.mrmeshpy.TaggedBitSet_FaceTag = FaceBitSet

◆ TaggedBitSet_FaceTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_FaceTag_IndexType = FaceId

◆ TaggedBitSet_GraphEdgeTag

meshlib.mrmeshpy.TaggedBitSet_GraphEdgeTag = GraphEdgeBitSet

◆ TaggedBitSet_GraphEdgeTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_GraphEdgeTag_IndexType = GraphEdgeId

◆ TaggedBitSet_GraphVertTag

meshlib.mrmeshpy.TaggedBitSet_GraphVertTag = GraphVertBitSet

◆ TaggedBitSet_GraphVertTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_GraphVertTag_IndexType = GraphVertId

◆ TaggedBitSet_NodeTag

meshlib.mrmeshpy.TaggedBitSet_NodeTag = NodeBitSet

◆ TaggedBitSet_NodeTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_NodeTag_IndexType = NodeId

◆ TaggedBitSet_ObjTag

meshlib.mrmeshpy.TaggedBitSet_ObjTag = ObjBitSet

◆ TaggedBitSet_ObjTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_ObjTag_IndexType = ObjId

◆ TaggedBitSet_PixelTag

meshlib.mrmeshpy.TaggedBitSet_PixelTag = PixelBitSet

◆ TaggedBitSet_PixelTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_PixelTag_IndexType = PixelId

◆ TaggedBitSet_RegionTag

meshlib.mrmeshpy.TaggedBitSet_RegionTag = RegionBitSet

◆ TaggedBitSet_RegionTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_RegionTag_IndexType = RegionId

◆ TaggedBitSet_TextureTag

meshlib.mrmeshpy.TaggedBitSet_TextureTag = TextureBitSet

◆ TaggedBitSet_TextureTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_TextureTag_IndexType = TextureId

◆ TaggedBitSet_UndirectedEdgeTag

meshlib.mrmeshpy.TaggedBitSet_UndirectedEdgeTag = UndirectedEdgeBitSet

◆ TaggedBitSet_UndirectedEdgeTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_UndirectedEdgeTag_IndexType = UndirectedEdgeId

◆ TaggedBitSet_VertTag

meshlib.mrmeshpy.TaggedBitSet_VertTag = VertBitSet

◆ TaggedBitSet_VertTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_VertTag_IndexType = VertId

◆ TaggedBitSet_VoxelTag

meshlib.mrmeshpy.TaggedBitSet_VoxelTag = VoxelBitSet

◆ TaggedBitSet_VoxelTag_IndexType

meshlib.mrmeshpy.TaggedBitSet_VoxelTag_IndexType = Id_VoxelTag

◆ TextAlignParams

meshlib.mrmeshpy.TextAlignParams = TextMeshAlignParams

◆ ThreePoints

meshlib.mrmeshpy.ThreePoints = std_array_Vector3_float_3

◆ ThreeVertIds

meshlib.mrmeshpy.ThreeVertIds = std_array_Id_VertTag_3

◆ Triangle3_double

meshlib.mrmeshpy.Triangle3_double = std_array_Vector3_double_3

◆ Triangle3_float

meshlib.mrmeshpy.Triangle3_float = std_array_Vector3_float_3

◆ Triangle3_int

meshlib.mrmeshpy.Triangle3_int = std_array_Vector3_int_3

◆ Triangle3d

meshlib.mrmeshpy.Triangle3d = std_array_Vector3_double_3

◆ Triangle3f

meshlib.mrmeshpy.Triangle3f = std_array_Vector3_float_3

◆ Triangle3i

meshlib.mrmeshpy.Triangle3i = std_array_Vector3_int_3

◆ TriangleCornerNormals

meshlib.mrmeshpy.TriangleCornerNormals = std_array_Vector3_float_3

◆ TrianglesRepetitions

meshlib.mrmeshpy.TrianglesRepetitions = std_array_int_4

◆ TriangulationHelpersSettings

meshlib.mrmeshpy.TriangulationHelpersSettings = TriangulationHelpers.Settings

◆ TriPoint_double

meshlib.mrmeshpy.TriPoint_double = TriPointd

◆ TriPoint_float

meshlib.mrmeshpy.TriPoint_float = TriPointf

◆ UndirectedEdgeHashMap

meshlib.mrmeshpy.UndirectedEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

◆ UVCoord

meshlib.mrmeshpy.UVCoord = Vector2f

◆ VdbVolumes

meshlib.mrmeshpy.VdbVolumes = std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid

◆ Vector2_bool

meshlib.mrmeshpy.Vector2_bool = Vector2b

◆ Vector2_bool_MatrixType

meshlib.mrmeshpy.Vector2_bool_MatrixType = Matrix2b

◆ Vector2_bool_SymMatrixType

meshlib.mrmeshpy.Vector2_bool_SymMatrixType = SymMatrix2b

◆ Vector2_double

meshlib.mrmeshpy.Vector2_double = Vector2d

◆ Vector2_double_MatrixType

meshlib.mrmeshpy.Vector2_double_MatrixType = Matrix2d

◆ Vector2_double_SymMatrixType

meshlib.mrmeshpy.Vector2_double_SymMatrixType = SymMatrix2d

◆ Vector2_float

meshlib.mrmeshpy.Vector2_float = Vector2f

◆ Vector2_float_MatrixType

meshlib.mrmeshpy.Vector2_float_MatrixType = Matrix2f

◆ Vector2_float_SymMatrixType

meshlib.mrmeshpy.Vector2_float_SymMatrixType = SymMatrix2f

◆ Vector2_int

meshlib.mrmeshpy.Vector2_int = Vector2i

◆ Vector2_int_MatrixType

meshlib.mrmeshpy.Vector2_int_MatrixType = Matrix2i

◆ Vector2_int_SymMatrixType

meshlib.mrmeshpy.Vector2_int_SymMatrixType = SymMatrix2i

◆ Vector2_long_long

meshlib.mrmeshpy.Vector2_long_long = Vector2ll

◆ Vector2_long_long_MatrixType

meshlib.mrmeshpy.Vector2_long_long_MatrixType = Matrix2ll

◆ Vector2_long_long_SymMatrixType

meshlib.mrmeshpy.Vector2_long_long_SymMatrixType = SymMatrix2ll

◆ Vector3_bool

meshlib.mrmeshpy.Vector3_bool = Vector3b

◆ Vector3_bool_MatrixType

meshlib.mrmeshpy.Vector3_bool_MatrixType = Matrix3b

◆ Vector3_bool_SymMatrixType

meshlib.mrmeshpy.Vector3_bool_SymMatrixType = SymMatrix3b

◆ Vector3_double

meshlib.mrmeshpy.Vector3_double = Vector3d

◆ Vector3_double_MatrixType

meshlib.mrmeshpy.Vector3_double_MatrixType = Matrix3d

◆ Vector3_double_SymMatrixType

meshlib.mrmeshpy.Vector3_double_SymMatrixType = SymMatrix3d

◆ Vector3_float

meshlib.mrmeshpy.Vector3_float = Vector3f

◆ Vector3_float_MatrixType

meshlib.mrmeshpy.Vector3_float_MatrixType = Matrix3f

◆ Vector3_float_SymMatrixType

meshlib.mrmeshpy.Vector3_float_SymMatrixType = SymMatrix3f

◆ Vector3_int

meshlib.mrmeshpy.Vector3_int = Vector3i

◆ Vector3_int_MatrixType

meshlib.mrmeshpy.Vector3_int_MatrixType = Matrix3i

◆ Vector3_int_SymMatrixType

meshlib.mrmeshpy.Vector3_int_SymMatrixType = SymMatrix3i

◆ Vector3_long_long

meshlib.mrmeshpy.Vector3_long_long = Vector3ll

◆ Vector3_long_long_MatrixType

meshlib.mrmeshpy.Vector3_long_long_MatrixType = Matrix3ll

◆ Vector3_long_long_SymMatrixType

meshlib.mrmeshpy.Vector3_long_long_SymMatrixType = SymMatrix3ll

◆ Vector4_bool

meshlib.mrmeshpy.Vector4_bool = Vector4b

◆ Vector4_bool_MatrixType

meshlib.mrmeshpy.Vector4_bool_MatrixType = Matrix4b

◆ Vector4_bool_SymMatrixType

meshlib.mrmeshpy.Vector4_bool_SymMatrixType = SymMatrix4b

◆ Vector4_double

meshlib.mrmeshpy.Vector4_double = Vector4d

◆ Vector4_double_MatrixType

meshlib.mrmeshpy.Vector4_double_MatrixType = Matrix4d

◆ Vector4_double_SymMatrixType

meshlib.mrmeshpy.Vector4_double_SymMatrixType = SymMatrix4d

◆ Vector4_float

meshlib.mrmeshpy.Vector4_float = Vector4f

◆ Vector4_float_MatrixType

meshlib.mrmeshpy.Vector4_float_MatrixType = Matrix4f

◆ Vector4_float_SymMatrixType

meshlib.mrmeshpy.Vector4_float_SymMatrixType = SymMatrix4f

◆ Vector4_int

meshlib.mrmeshpy.Vector4_int = Vector4i

◆ Vector4_int_MatrixType

meshlib.mrmeshpy.Vector4_int_MatrixType = Matrix4i

◆ Vector4_int_SymMatrixType

meshlib.mrmeshpy.Vector4_int_SymMatrixType = SymMatrix4i

◆ Vector4_long_long

meshlib.mrmeshpy.Vector4_long_long = Vector4ll

◆ Vector4_long_long_MatrixType

meshlib.mrmeshpy.Vector4_long_long_MatrixType = Matrix4ll

◆ Vector4_long_long_SymMatrixType

meshlib.mrmeshpy.Vector4_long_long_SymMatrixType = SymMatrix4ll

◆ Vector_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_Node_NodeId

meshlib.mrmeshpy.Vector_AABBTreeBase_AABBTreeTraits_FaceTag_Box3f_Node_NodeId = Vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f_NodeId

◆ Vector_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_Node_NodeId

meshlib.mrmeshpy.Vector_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box2f_Node_NodeId = Vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f_NodeId

◆ Vector_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_Node_NodeId

meshlib.mrmeshpy.Vector_AABBTreeBase_AABBTreeTraits_UndirectedEdgeTag_Box3f_Node_NodeId = Vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f_NodeId

◆ Vector_AABBTreeBase_ObjTreeTraits_Node_NodeId

meshlib.mrmeshpy.Vector_AABBTreeBase_ObjTreeTraits_Node_NodeId = Vector_AABBTreeNode_ObjTreeTraits_NodeId

◆ Vector_Color_EdgeId

meshlib.mrmeshpy.Vector_Color_EdgeId = EdgeColors

◆ Vector_Color_FaceId

meshlib.mrmeshpy.Vector_Color_FaceId = FaceColors

◆ Vector_Color_FaceId_const_reference

meshlib.mrmeshpy.Vector_Color_FaceId_const_reference = Color

◆ Vector_Color_FaceId_reference

meshlib.mrmeshpy.Vector_Color_FaceId_reference = Color

◆ Vector_Color_FaceId_value_type

meshlib.mrmeshpy.Vector_Color_FaceId_value_type = Color

◆ Vector_Color_Id_EdgeTag_const_reference

meshlib.mrmeshpy.Vector_Color_Id_EdgeTag_const_reference = Color

◆ Vector_Color_Id_EdgeTag_reference

meshlib.mrmeshpy.Vector_Color_Id_EdgeTag_reference = Color

◆ Vector_Color_Id_EdgeTag_value_type

meshlib.mrmeshpy.Vector_Color_Id_EdgeTag_value_type = Color

◆ Vector_Color_Id_FaceTag

meshlib.mrmeshpy.Vector_Color_Id_FaceTag = FaceColors

◆ Vector_Color_Id_UndirectedEdgeTag

meshlib.mrmeshpy.Vector_Color_Id_UndirectedEdgeTag = UndirectedEdgeColors

◆ Vector_Color_Id_VertTag

meshlib.mrmeshpy.Vector_Color_Id_VertTag = VertColors

◆ Vector_Color_UndirectedEdgeId

meshlib.mrmeshpy.Vector_Color_UndirectedEdgeId = UndirectedEdgeColors

◆ Vector_Color_UndirectedEdgeId_const_reference

meshlib.mrmeshpy.Vector_Color_UndirectedEdgeId_const_reference = Color

◆ Vector_Color_UndirectedEdgeId_reference

meshlib.mrmeshpy.Vector_Color_UndirectedEdgeId_reference = Color

◆ Vector_Color_UndirectedEdgeId_value_type

meshlib.mrmeshpy.Vector_Color_UndirectedEdgeId_value_type = Color

◆ Vector_Color_VertId

meshlib.mrmeshpy.Vector_Color_VertId = VertColors

◆ Vector_Color_VertId_const_reference

meshlib.mrmeshpy.Vector_Color_VertId_const_reference = Color

◆ Vector_Color_VertId_reference

meshlib.mrmeshpy.Vector_Color_VertId_reference = Color

◆ Vector_Color_VertId_value_type

meshlib.mrmeshpy.Vector_Color_VertId_value_type = Color

◆ Vector_Dipole_NodeId

meshlib.mrmeshpy.Vector_Dipole_NodeId = Dipoles

◆ Vector_Dipole_NodeId_const_reference

meshlib.mrmeshpy.Vector_Dipole_NodeId_const_reference = Dipole

◆ Vector_Dipole_NodeId_reference

meshlib.mrmeshpy.Vector_Dipole_NodeId_reference = Dipole

◆ Vector_Dipole_NodeId_value_type

meshlib.mrmeshpy.Vector_Dipole_NodeId_value_type = Dipole

◆ Vector_EdgeId_EdgeId

meshlib.mrmeshpy.Vector_EdgeId_EdgeId = EdgeMap

◆ Vector_EdgeId_FaceId

meshlib.mrmeshpy.Vector_EdgeId_FaceId = Vector_Id_EdgeTag_FaceId

◆ Vector_EdgeId_UndirectedEdgeId

meshlib.mrmeshpy.Vector_EdgeId_UndirectedEdgeId = WholeEdgeMap

◆ Vector_EdgeId_VertId

meshlib.mrmeshpy.Vector_EdgeId_VertId = Vector_Id_EdgeTag_VertId

◆ Vector_FaceBitSet_Graph_VertId

meshlib.mrmeshpy.Vector_FaceBitSet_Graph_VertId = Vector_FaceBitSet_GraphVertId

◆ Vector_FaceId_FaceId

meshlib.mrmeshpy.Vector_FaceId_FaceId = FaceMap

◆ Vector_FaceId_FaceId_const_reference

meshlib.mrmeshpy.Vector_FaceId_FaceId_const_reference = FaceId

◆ Vector_FaceId_FaceId_reference

meshlib.mrmeshpy.Vector_FaceId_FaceId_reference = FaceId

◆ Vector_FaceId_FaceId_value_type

meshlib.mrmeshpy.Vector_FaceId_FaceId_value_type = FaceId

◆ Vector_float_EdgeId

meshlib.mrmeshpy.Vector_float_EdgeId = EdgeScalars

◆ Vector_float_FaceId

meshlib.mrmeshpy.Vector_float_FaceId = FaceScalars

◆ Vector_float_UndirectedEdgeId

meshlib.mrmeshpy.Vector_float_UndirectedEdgeId = UndirectedEdgeScalars

◆ Vector_float_VertId

meshlib.mrmeshpy.Vector_float_VertId = VertScalars

◆ Vector_Graph_EndVertices_Graph_EdgeId

meshlib.mrmeshpy.Vector_Graph_EndVertices_Graph_EdgeId = Vector_Graph_EndVertices_GraphEdgeId

◆ Vector_Graph_Neighbours_Graph_VertId

meshlib.mrmeshpy.Vector_Graph_Neighbours_Graph_VertId = Vector_std_vector_GraphEdgeId_GraphVertId

◆ Vector_Graph_VertId_Graph_VertId

meshlib.mrmeshpy.Vector_Graph_VertId_Graph_VertId = Vector_GraphVertId_GraphVertId

◆ Vector_ICPPairsGrid_ICPLayer

meshlib.mrmeshpy.Vector_ICPPairsGrid_ICPLayer = Vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_int

◆ Vector_Id_EdgeTag_Id_EdgeTag_const_reference

meshlib.mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_const_reference = Id_EdgeTag

◆ Vector_Id_EdgeTag_Id_EdgeTag_reference

meshlib.mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_reference = Id_EdgeTag

◆ Vector_Id_EdgeTag_Id_EdgeTag_value_type

meshlib.mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_value_type = Id_EdgeTag

◆ Vector_Id_EdgeTag_UndirectedEdgeId_const_reference

meshlib.mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_const_reference = Id_EdgeTag

◆ Vector_Id_EdgeTag_UndirectedEdgeId_reference

meshlib.mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_reference = Id_EdgeTag

◆ Vector_Id_EdgeTag_UndirectedEdgeId_value_type

meshlib.mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_value_type = Id_EdgeTag

◆ Vector_ObjId_ObjId

meshlib.mrmeshpy.Vector_ObjId_ObjId = ObjMap

◆ Vector_ObjId_ObjId_const_reference

meshlib.mrmeshpy.Vector_ObjId_ObjId_const_reference = ObjId

◆ Vector_ObjId_ObjId_reference

meshlib.mrmeshpy.Vector_ObjId_ObjId_reference = ObjId

◆ Vector_ObjId_ObjId_value_type

meshlib.mrmeshpy.Vector_ObjId_ObjId_value_type = ObjId

◆ Vector_QuadraticForm_Vector2f_VertId

meshlib.mrmeshpy.Vector_QuadraticForm_Vector2f_VertId = Vector_QuadraticForm2f_VertId

◆ Vector_QuadraticForm_Vector3f_VertId

meshlib.mrmeshpy.Vector_QuadraticForm_Vector3f_VertId = Vector_QuadraticForm3f_VertId

◆ Vector_RegionId_FaceId

meshlib.mrmeshpy.Vector_RegionId_FaceId = Face2RegionMap

◆ Vector_RegionId_FaceId_const_reference

meshlib.mrmeshpy.Vector_RegionId_FaceId_const_reference = RegionId

◆ Vector_RegionId_FaceId_reference

meshlib.mrmeshpy.Vector_RegionId_FaceId_reference = RegionId

◆ Vector_RegionId_FaceId_value_type

meshlib.mrmeshpy.Vector_RegionId_FaceId_value_type = RegionId

◆ Vector_RegionId_UndirectedEdgeId

meshlib.mrmeshpy.Vector_RegionId_UndirectedEdgeId = UndirectedEdge2RegionMap

◆ Vector_RegionId_UndirectedEdgeId_const_reference

meshlib.mrmeshpy.Vector_RegionId_UndirectedEdgeId_const_reference = RegionId

◆ Vector_RegionId_UndirectedEdgeId_reference

meshlib.mrmeshpy.Vector_RegionId_UndirectedEdgeId_reference = RegionId

◆ Vector_RegionId_UndirectedEdgeId_value_type

meshlib.mrmeshpy.Vector_RegionId_UndirectedEdgeId_value_type = RegionId

◆ Vector_RegionId_VertId

meshlib.mrmeshpy.Vector_RegionId_VertId = Vert2RegionMap

◆ Vector_RegionId_VertId_const_reference

meshlib.mrmeshpy.Vector_RegionId_VertId_const_reference = RegionId

◆ Vector_RegionId_VertId_reference

meshlib.mrmeshpy.Vector_RegionId_VertId_reference = RegionId

◆ Vector_RegionId_VertId_value_type

meshlib.mrmeshpy.Vector_RegionId_VertId_value_type = RegionId

◆ Vector_std_array_VertId_3_FaceId_const_reference

meshlib.mrmeshpy.Vector_std_array_VertId_3_FaceId_const_reference = std_array_Id_VertTag_3

◆ Vector_std_array_VertId_3_FaceId_reference

meshlib.mrmeshpy.Vector_std_array_VertId_3_FaceId_reference = std_array_Id_VertTag_3

◆ Vector_std_array_VertId_3_FaceId_value_type

meshlib.mrmeshpy.Vector_std_array_VertId_3_FaceId_value_type = std_array_Id_VertTag_3

◆ Vector_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType = EdgeMap

◆ Vector_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_FaceTag_IndexType_TaggedBitSet_FaceTag_IndexType = FaceMap

◆ Vector_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_GraphEdgeTag_IndexType_TaggedBitSet_GraphEdgeTag_IndexType = Vector_GraphEdgeId_GraphEdgeId

◆ Vector_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_GraphVertTag_IndexType_TaggedBitSet_GraphVertTag_IndexType = Vector_GraphVertId_GraphVertId

◆ Vector_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = Vector_Id_ICPElemtTag_Id_ICPElemtTag

◆ Vector_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_NodeTag_IndexType_TaggedBitSet_NodeTag_IndexType = Vector_NodeId_NodeId

◆ Vector_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_ObjTag_IndexType_TaggedBitSet_ObjTag_IndexType = ObjMap

◆ Vector_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_PixelTag_IndexType_TaggedBitSet_PixelTag_IndexType = Vector_PixelId_PixelId

◆ Vector_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_RegionTag_IndexType_TaggedBitSet_RegionTag_IndexType = Vector_RegionId_RegionId

◆ Vector_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_TextureTag_IndexType_TaggedBitSet_TextureTag_IndexType = Vector_TextureId_TextureId

◆ Vector_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_UndirectedEdgeTag_IndexType_TaggedBitSet_UndirectedEdgeTag_IndexType = UndirectedEdgeMap

◆ Vector_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_VertTag_IndexType_TaggedBitSet_VertTag_IndexType = VertMap

◆ Vector_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType

meshlib.mrmeshpy.Vector_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = Vector_Id_VoxelTag_Id_VoxelTag

◆ Vector_TextureId_FaceId

meshlib.mrmeshpy.Vector_TextureId_FaceId = TexturePerFace

◆ Vector_TextureId_FaceId_const_reference

meshlib.mrmeshpy.Vector_TextureId_FaceId_const_reference = TextureId

◆ Vector_TextureId_FaceId_reference

meshlib.mrmeshpy.Vector_TextureId_FaceId_reference = TextureId

◆ Vector_TextureId_FaceId_value_type

meshlib.mrmeshpy.Vector_TextureId_FaceId_value_type = TextureId

◆ Vector_ThreeVertIds_FaceId

meshlib.mrmeshpy.Vector_ThreeVertIds_FaceId = Triangulation

◆ Vector_TriangleCornerNormals_FaceId

meshlib.mrmeshpy.Vector_TriangleCornerNormals_FaceId = Vector_std_array_Vector3f_3_FaceId

◆ Vector_UndirectedEdgeId_UndirectedEdgeId

meshlib.mrmeshpy.Vector_UndirectedEdgeId_UndirectedEdgeId = UndirectedEdgeMap

◆ Vector_UndirectedEdgeId_UndirectedEdgeId_const_reference

meshlib.mrmeshpy.Vector_UndirectedEdgeId_UndirectedEdgeId_const_reference = UndirectedEdgeId

◆ Vector_UndirectedEdgeId_UndirectedEdgeId_reference

meshlib.mrmeshpy.Vector_UndirectedEdgeId_UndirectedEdgeId_reference = UndirectedEdgeId

◆ Vector_UndirectedEdgeId_UndirectedEdgeId_value_type

meshlib.mrmeshpy.Vector_UndirectedEdgeId_UndirectedEdgeId_value_type = UndirectedEdgeId

◆ Vector_UVCoord_VertId

meshlib.mrmeshpy.Vector_UVCoord_VertId = VertUVCoords

◆ Vector_Vector2f_VertId

meshlib.mrmeshpy.Vector_Vector2f_VertId = VertUVCoords

◆ Vector_Vector2f_VertId_const_reference

meshlib.mrmeshpy.Vector_Vector2f_VertId_const_reference = Vector2f

◆ Vector_Vector2f_VertId_reference

meshlib.mrmeshpy.Vector_Vector2f_VertId_reference = Vector2f

◆ Vector_Vector2f_VertId_value_type

meshlib.mrmeshpy.Vector_Vector2f_VertId_value_type = Vector2f

◆ Vector_Vector3f_FaceId

meshlib.mrmeshpy.Vector_Vector3f_FaceId = FaceNormals

◆ Vector_Vector3f_FaceId_const_reference

meshlib.mrmeshpy.Vector_Vector3f_FaceId_const_reference = Vector3f

◆ Vector_Vector3f_FaceId_reference

meshlib.mrmeshpy.Vector_Vector3f_FaceId_reference = Vector3f

◆ Vector_Vector3f_FaceId_value_type

meshlib.mrmeshpy.Vector_Vector3f_FaceId_value_type = Vector3f

◆ Vector_Vector3f_VertId

meshlib.mrmeshpy.Vector_Vector3f_VertId = VertCoords

◆ Vector_Vector3f_VertId_const_reference

meshlib.mrmeshpy.Vector_Vector3f_VertId_const_reference = Vector3f

◆ Vector_Vector3f_VertId_reference

meshlib.mrmeshpy.Vector_Vector3f_VertId_reference = Vector3f

◆ Vector_Vector3f_VertId_value_type

meshlib.mrmeshpy.Vector_Vector3f_VertId_value_type = Vector3f

◆ Vector_Vector_ICPGroupPairs_ICPElementId_ICPElementId

meshlib.mrmeshpy.Vector_Vector_ICPGroupPairs_ICPElementId_ICPElementId = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

◆ Vector_VertId_VertId

meshlib.mrmeshpy.Vector_VertId_VertId = VertMap

◆ Vector_VertId_VertId_const_reference

meshlib.mrmeshpy.Vector_VertId_VertId_const_reference = VertId

◆ Vector_VertId_VertId_reference

meshlib.mrmeshpy.Vector_VertId_VertId_reference = VertId

◆ Vector_VertId_VertId_value_type

meshlib.mrmeshpy.Vector_VertId_VertId_value_type = VertId

◆ Vector_VoxelId_FaceId

meshlib.mrmeshpy.Vector_VoxelId_FaceId = Vector_Id_VoxelTag_FaceId

◆ vectorConstMeshPtr

meshlib.mrmeshpy.vectorConstMeshPtr = std_vector_Mesh_const

◆ vectorEdges

meshlib.mrmeshpy.vectorEdges = std_vector_Id_EdgeTag

◆ VertHashMap

meshlib.mrmeshpy.VertHashMap = phmap_flat_hash_map_Id_VertTag_Id_VertTag

◆ VertNormals

meshlib.mrmeshpy.VertNormals = VertCoords

◆ VertPathInfoMap

meshlib.mrmeshpy.VertPathInfoMap = phmap_flat_hash_map_Id_VertTag_VertPathInfo

◆ ViewportProperty_uint8_t

meshlib.mrmeshpy.ViewportProperty_uint8_t = ViewportProperty_unsigned_char

◆ VoxelId

meshlib.mrmeshpy.VoxelId = Id_VoxelTag

◆ VoxelsSaveSavingSettings

meshlib.mrmeshpy.VoxelsSaveSavingSettings = VoxelsSave.SavingSettings

◆ VoxelsVolume_std_vector_float

meshlib.mrmeshpy.VoxelsVolume_std_vector_float = SimpleVolume

◆ VoxelsVolume_std_vector_uint16_t

meshlib.mrmeshpy.VoxelsVolume_std_vector_uint16_t = SimpleVolumeU16

◆ VoxelsVolume_std_vector_unsigned_short

meshlib.mrmeshpy.VoxelsVolume_std_vector_unsigned_short = SimpleVolumeU16

◆ VoxelsVolume_VoxelValueGetter_float

meshlib.mrmeshpy.VoxelsVolume_VoxelValueGetter_float = FunctionVolume

◆ VoxelsVolume_VoxelValueGetter_uint8_t

meshlib.mrmeshpy.VoxelsVolume_VoxelValueGetter_uint8_t = FunctionVolumeU8

◆ VoxelsVolumeMinMax_FloatGrid

meshlib.mrmeshpy.VoxelsVolumeMinMax_FloatGrid = VdbVolume

◆ VoxelsVolumeMinMax_std_vector_float

meshlib.mrmeshpy.VoxelsVolumeMinMax_std_vector_float = SimpleVolumeMinMax

◆ VoxelsVolumeMinMax_std_vector_uint16_t

meshlib.mrmeshpy.VoxelsVolumeMinMax_std_vector_uint16_t = SimpleVolumeMinMaxU16

◆ WholeEdgeHashMap

meshlib.mrmeshpy.WholeEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

Classes

Functions

Variables