mrmeshpy Namespace Reference

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	Ball1d
class	Ball1f
class	Ball2d
class	Ball2f
class	Ball3d
class	Ball3f
class	BaseRenderParams
class	BaseShellParameters
class	BaseTiffParameters
class	BasicUiRenderTask
class	BasinVolumeCalculator
class	BestFitParabolad
class	BestFitParabolaf
class	BitSet
class	BMap_FaceId_unsigned_long_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_long
class	BMap_VertId_unsigned_long_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	ChangeScaleAction
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	CompensateRadiusParams
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	EdgeTri
class	EdgeWeights
class	EmbeddedStructureParameters
class	EnumNeihbourFaces
class	EnumNeihbourVertices
class	expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid_std_string
class	expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_vector_float_std_string
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	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	FindOutliersParams
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_PointCloud_PointsToDistanceVolumeParams
class	func_bool_from_std_shared_ptr_HistoryAction
class	func_bool_from_unsigned_long_long_unsigned_long_long
class	func_bool_from_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_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
class	func_float_from_int_int
class	func_float_from_std_vector_std_vector_Vector2_float_OffsetContourIndex_OffsetContoursOrigins
class	func_float_from_unsigned_long_long
class	func_float_from_unsigned_long_long_unsigned_long_long
class	func_float_from_Vector3_int
class	func_MeshOrPoints_ProjectionResult_from_Vector3_float
class	func_MeshTriPoint_from_unsigned_long_long
class	func_Processing_from_MeshProjectionResult_Ball_Vector3_float
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_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_long_unsigned_long_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_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	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	MakeBridgeResult
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_FunctionVolume
class	MeshOnVoxelsT_const_Mesh_SimpleVolumeMinMax
class	MeshOnVoxelsT_const_Mesh_VdbVolume
class	MeshOnVoxelsT_Mesh_FunctionVolume
class	MeshOnVoxelsT_Mesh_SimpleVolumeMinMax
class	MeshOnVoxelsT_Mesh_VdbVolume
class	MeshOrPoints
class	MeshOrPointsXf
class	MeshPart
class	MeshPoint
class	MeshProjectionParameters
class	MeshProjectionResult
class	MeshProjectionTransforms
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	OutlierParams
class	OutliersDetector
class	OutlierTypeMask
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_long_std_array_Id_VertTag_3
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	ProccessMemoryInfo
class	Processing
class	ProcessOneResult
class	ProjectAttributeParams
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	SetNew
class	SharpenMarchingCubesMeshSettings
class	SharpOffsetParameters
class	ShellVertexInfo
class	Side
class	SignDetectionMode
class	SignDetectionModeShort
class	SignedDistanceToMeshOptions
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_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6
class	std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6
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_LineSegm_Vector3_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_3
class	std_vector_std_array_std_filesystem_path_4
class	std_vector_std_array_Vector3_float_3
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_long_unsigned_long_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_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_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid_std_string
class	std_vector_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_vector_float_std_string
class	std_vector_TriPoint_float
class	std_vector_UndirectedEdgeUndirectedEdge
class	std_vector_UnorientedTriangle
class	std_vector_unsigned_char
class	std_vector_unsigned_long_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	TransformVdbVolumeResult
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	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	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_long_FaceId
class	Vector_unsigned_long_long_GraphVertId
class	Vector_unsigned_long_long_UndirectedEdgeId
class	Vector_unsigned_long_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	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_FunctionVolume
class	VoxelsVolumeAccessor_SimpleVolume
class	VoxelsVolumeAccessor_SimpleVolumeMinMax
class	VoxelsVolumeAccessor_VdbVolume
class	VoxelsVolumeInterpolatedAccessor_VoxelsVolumeAccessor_FunctionVolume
class	VoxelsVolumeInterpolatedAccessor_VoxelsVolumeAccessor_SimpleVolumeMinMax
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_long

Functions
str	GetCpuId ()
str	GetDetailedOSName ()
pathlib.Path	GetEmbeddedPythonDirectory ()
pathlib.Path	GetExeDirectory ()
pathlib.Path	GetFontsDirectory ()
pathlib.Path	GetHomeDirectory ()
pathlib.Path	GetLibsDirectory ()
str	GetMRVersionString ()
pathlib.Path	GetResourcesDirectory ()
pathlib.Path	GetTempDirectory ()
pathlib.Path	GetWindowsInstallDirectory ()
bool	OpenDocument (os.PathLike|str|bytes 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)
str	Utf16ToUtf8 (str utf16)
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)
None	addLeftBand (MeshTopology topology, std_vector_Id_EdgeTag loop, FaceBitSet addHere)
None	addNoise (VertCoords points, VertBitSet validVerts, NoiseSettings settings)
None	addNoise (Mesh mesh, VertBitSet region=None, 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='{}', Triangulation outRep3=None, Triangulation outRep2=None)
ViewportIterator	begin (ViewportMask mask)
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='{}')
BooleanResult	boolean (Mesh meshA, Mesh meshB, BooleanOperation operation, BooleanParameters params='{}')
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='{}')
bool	buildCylinderBetweenTwoHoles (Mesh mesh, StitchHolesParams params='{}')
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_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_unsigned_long_long	buildSmallestMetricPath (VdbVolume voxels, func_float_from_unsigned_long_long_unsigned_long_long metric, int start, int finish, func_bool_from_float cb='{}')
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='{}')
str	bytesString (int size)
VertColors	calcAvgColors (PointCloud cloud, VertColors colors, VertCoords tgtPoints, VertBitSet tgtVerts, float sigma, func_bool_from_float cb='{}')
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='{}')
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='{}', float_output deviationSqAfterFlip=None)
ShellVertexInfo	classifyShellVert (MeshPart mp, Vector3f shellPoint, FindInnerShellSettings settings='{}')
ObjectMesh	cloneRegion (ObjectMesh objMesh, FaceBitSet region, bool copyTexture=True)
ObjectPoints	cloneRegion (ObjectPoints objPoints, VertBitSet region)
DistanceMap	combineXYderivativeMaps (tuple[DistanceMap, DistanceMap] XYderivativeMaps)
str	commonFilesName (std_vector_std_filesystem_path files)
None	compensateRadius (Mesh mesh, CompensateRadiusParams params)
None	compressZip (os.PathLike|str|bytes zipFile, os.PathLike|str|bytes sourceFolder, std_vector_std_filesystem_path excludeFiles='{}', str password=None, func_bool_from_float cb='{}')
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='{}', std_vector_MeshTriPoint outSamples=None)
DistanceMap	computeDistanceMapD (MeshPart mp, MeshToDistanceMapParams params, func_bool_from_float cb='{}', 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, bool angleWeigted, UndirectedEdgeBitSet creases=None)
Vector_QuadraticForm3f_VertId	computeFormsAtVertices (MeshPart mp, float stabilizer, bool angleWeigted, 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='{}')
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='{}')
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='{}')
None	computeSteepestDescentPath (MeshPart mp, VertScalars field, MeshTriPoint start, std_vector_EdgePoint outPath, ComputeSteepestDescentPathSettings settings='{}')
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	convertMeshTriPointsSurfaceOffsetToMeshContours (Mesh mesh, std_vector_MeshTriPoint surfaceLine, float offset, SearchPathSettings searchSettings='{}')
std_vector_OneMeshContour	convertMeshTriPointsSurfaceOffsetToMeshContours (Mesh mesh, std_vector_MeshTriPoint surfaceLine, func_float_from_int offsetAtPoint, SearchPathSettings searchSettings='{}')
OneMeshContour	convertMeshTriPointsToClosedContour (Mesh mesh, std_vector_MeshTriPoint surfaceLine, SearchPathSettings searchSettings='{}', std_vector_int pivotIndices=None)
OneMeshContour	convertMeshTriPointsToMeshContour (Mesh mesh, std_vector_MeshTriPoint surfaceLine, SearchPathSettings searchSettings='{}', 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_)
Mesh	copySubdividePackMesh (MeshPart mp, float voxelSize, func_bool_from_float cb='{}')
Object	createObject (str className)
MeshProjectionTransforms	createProjectionTransforms (AffineXf3f storageXf, AffineXf3f pointXf, AffineXf3f treeXf)
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='{}')
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='{}')
int	deactivateFarPairs (IPointPairs pairs, float maxDistSq)
DecimatePolylineResult	decimateContour (std_vector_Vector2_float contour, DecimatePolylineSettings_Vector2f settings='{}')
DecimatePolylineResult	decimateContour (std_vector_Vector3_float contour, DecimatePolylineSettings_Vector3f settings='{}')
DecimateResult	decimateMesh (Mesh mesh, DecimateSettings settings='{}')
DecimatePolylineResult	decimatePolyline (Polyline2 polyline, DecimatePolylineSettings_Vector2f settings='{}')
DecimatePolylineResult	decimatePolyline (Polyline3 polyline, DecimatePolylineSettings_Vector3f settings='{}')
std_vector_unsigned_char	decode64 (str val)
None	decompressZip (os.PathLike|str|bytes zipFile, os.PathLike|str|bytes targetFolder, str password=None)
None	decompressZip (typing.Any zipStream, os.PathLike|str|bytes targetFolder, str password=None)
str	defaultSerializeMeshFormat ()
str	defaultSerializePointsFormat ()
str	defaultSerializeVoxelsFormat ()
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|str|bytes path, func_void_from_std_filesystem_path postDecompress='{}', func_bool_from_float progressCb='{}')
LoadedObjectT	deserializeObjectTreeFrom3mf (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
LoadedObjectT	deserializeObjectTreeFromFolder (os.PathLike|str|bytes folder, func_bool_from_float progressCb='{}')
Object	deserializeObjectTreeFromGltf (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
LoadedObjectT	deserializeObjectTreeFromModel (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
std_vector_std_vector_Id_EdgeTag	detectBasisTunnels (MeshPart mp, func_float_from_Id_EdgeTag metric='{}', func_bool_from_float progressCallback='{}')
std_vector_int	detectLoneContours (std_vector_std_vector_VariableEdgeTri contours)
FaceBitSet	detectTunnelFaces (MeshPart mp, DetectTunnelSettings settings='{}')
bool	dilateRegion (Mesh mesh, FaceBitSet region, float dilation, func_bool_from_float callback='{}')
bool	dilateRegion (Mesh mesh, VertBitSet region, float dilation, func_bool_from_float callback='{}')
bool	dilateRegion (Mesh mesh, UndirectedEdgeBitSet region, float dilation, func_bool_from_float callback='{}')
bool	dilateRegion (PointCloud pointCloud, VertBitSet region, float dilation, func_bool_from_float cb='{}', AffineXf3f xf=None)
bool	dilateRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, FaceBitSet region, float dilation, func_bool_from_float callback='{}')
bool	dilateRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertBitSet region, float dilation, func_bool_from_float callback='{}')
bool	dilateRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, UndirectedEdgeBitSet region, float dilation, func_bool_from_float callback='{}')
func_float_from_Id_EdgeTag	discreteAbsMeanCurvatureMetric (Mesh mesh)
func_float_from_Id_EdgeTag	discreteMinusAbsMeanCurvatureMetric (Mesh mesh)
DistanceMap	distanceMapFromContours (Polyline2 contours, ContourToDistanceMapParams params, ContoursDistanceMapOptions options='{}')
None	distanceMapFromContours (DistanceMap distMap, Polyline2 polyline, ContourToDistanceMapParams params, ContoursDistanceMapOptions options='{}')
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='{}')
None	dividePolylineWithPlane (Polyline3 polyline, Plane3f plane, DividePolylineParameters params='{}')
PointCloud	divideWithPlane (PointCloud points, Plane3f plane, DividePointCloudOptionalOutput optOut='{}')
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='{}')
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='{}')
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='{}', func_bool_from_float cb='{}')
bool	erodeRegion (Mesh mesh, FaceBitSet region, float dilation, func_bool_from_float callback='{}')
bool	erodeRegion (Mesh mesh, VertBitSet region, float dilation, func_bool_from_float callback='{}')
bool	erodeRegion (Mesh mesh, UndirectedEdgeBitSet region, float dilation, func_bool_from_float callback='{}')
bool	erodeRegion (PointCloud pointCloud, VertBitSet region, float erosion, func_bool_from_float cb='{}', AffineXf3f xf=None)
bool	erodeRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, FaceBitSet region, float dilation, func_bool_from_float callback='{}')
bool	erodeRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertBitSet region, float dilation, func_bool_from_float callback='{}')
bool	erodeRegionByMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric, UndirectedEdgeBitSet region, float dilation, func_bool_from_float callback='{}')
None	evalGridMinMax (OpenVdbFloatGrid grid, float_output min, float_output max)
None	executeHoleFillPlan (Mesh mesh, Id_EdgeTag a0, HoleFillPlan plan, FaceBitSet outNewFaces=None)
VertBitSet	expand (MeshTopology topology, VertId v, int hops)
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)
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, EdgeBitSet edges)
std_vector_std_vector_Id_EdgeTag	extractClosedLoops (MeshTopology topology, std_vector_Id_EdgeTag inEdges, EdgeBitSet outNotLoopEdges=None)
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_Vector3_float	extractMeshContours (std_vector_OneMeshContour meshContours)
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='{}')
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='{}')
None	fillPlanarHole (ObjectMesh obj, std_vector_std_vector_Id_EdgeTag holeContours)
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='{}')
VertBitSet	findCloseVertices (PointCloud cloud, float closeDist, func_bool_from_float cb='{}')
VertBitSet	findCloseVertices (VertCoords points, float closeDist, VertBitSet valid=None, func_bool_from_float cb='{}')
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='{}')
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='{}')
VertBitSet	findInnerShellVerts (MeshPart mp, Mesh shell, FindInnerShellSettings settings='{}')
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='{}')
Buffer_VertId	findNClosestPointsPerPoint (PointCloud pc, int numNei, func_bool_from_float progress='{}')
VertBitSet	findNRingVerts (MeshTopology topology, int n, VertBitSet region=None)
VertBitSet	findNeighborVerts (Mesh mesh, PointOnFace start, float range)
VertBitSet	findOutliers (PointCloud pc, FindOutliersParams params)
std_vector_TaggedBitSet_FaceTag	findOverhangs (Mesh mesh, FindOverhangsSettings settings)
FaceBitSet	findOverlappingTris (MeshPart mp, FindOverlappingSettings settings)
None	findPointsInBall (PointCloud pointCloud, Ball3f ball, func_void_from_Id_VertTag_Vector3_float foundCallback, AffineXf3f xf=None)
None	findPointsInBall (PointCloud pointCloud, Vector3f center, float radius, func_void_from_Id_VertTag_Vector3_float foundCallback, AffineXf3f xf=None)
None	findPointsInBall (Mesh mesh, Ball3f ball, 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, Ball3f ball, 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)
None	findPointsInBox (PointCloud pointCloud, Box3f box, func_void_from_Id_VertTag_Vector3_float foundCallback, AffineXf3f xf=None)
None	findPointsInBox (Mesh mesh, Box3f box, func_void_from_Id_VertTag_Vector3_float foundCallback, AffineXf3f xf=None)
None	findPointsInBox (AABBTreePoints tree, Box3f box, 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='{}', func_bool_from_MeshProjectionResult validProjections='{}')
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='{}')
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='{}', func_bool_from_MeshProjectionResult validProjections='{}')
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='{}', Face2RegionMap regionMap=None)
std_vector_FaceFace	findSelfCollidingTriangles (MeshPart mp, func_bool_from_float cb='{}', Face2RegionMap regionMap=None)
FaceBitSet	findSelfCollidingTrianglesBS (MeshPart mp, func_bool_from_float cb='{}', Face2RegionMap regionMap=None)
UndirectedEdgeBitSet	findShortEdges (MeshPart mp, float criticalLength, func_bool_from_float cb='{}')
MeshMeshSignedDistanceResult	findSignedDistance (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None, float upDistLimitSq=3.4028234663852886e+38)
SignedDistanceToMeshResult	findSignedDistance (Vector3f pt, MeshPart mp, float upDistLimitSq=3.4028234663852886e+38, float loDistLimitSq=0)
VertScalars	findSignedDistances (Mesh refMesh, VertCoords testPoints, VertBitSet validTestPoints='{}', MeshProjectionParameters params='{}', IPointsToMeshProjector projector='{}')
VertScalars	findSignedDistances (Mesh refMesh, Mesh mesh, MeshProjectionParameters params='{}', IPointsToMeshProjector projector='{}')
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='{}')
VertMap	findSmallestCloseVertices (PointCloud cloud, float closeDist, func_bool_from_float cb='{}')
VertMap	findSmallestCloseVertices (VertCoords points, float closeDist, VertBitSet valid=None, func_bool_from_float cb='{}')
VertMap	findSmallestCloseVerticesUsingTree (VertCoords points, float closeDist, AABBTreePoints tree, VertBitSet valid, func_bool_from_float cb='{}')
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)
std_vector_LineSegm_Vector3_float	findTriangleSectionsByXYPlane (MeshPart mp, float zLevel, std_vector_Id_FaceTag faces=None, UseAABBTree u='UseAABBTree::Yes')
Vector3f	findTriangleSegmentIntersectionPrecise (Vector3f a, Vector3f b, Vector3f c, Vector3f d, Vector3f e, CoordinateConverters converters)
None	findTrisInBall (MeshPart mp, Ball3f ball, func_Processing_from_MeshProjectionResult_Ball_Vector3_float foundCallback, func_bool_from_Id_FaceTag validFaces='{}')
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 (Mesh mesh, float closeDist)
phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag	findTwinUndirectedEdgeHashMap (std_vector_std_pair_Id_EdgeTag_Id_EdgeTag pairs)
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='{}')
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|str|bytes path, func_bool_from_float callback='{}')
LoadedObjectT	fromSceneMison (typing.Any in_, func_bool_from_float callback='{}')
SimpleVolumeMinMax	functionVolumeToSimpleVolume (FunctionVolume volume, func_bool_from_float callback='{}')
VdbVolume	functionVolumeToVdbVolume (FunctionVolume functoinVolume, func_bool_from_float cb='{}')
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='{}')
tuple[std_vector_TaggedBitSet_FaceTag, int]	getAllComponents (MeshPart meshPart, int maxComponentCount, MeshComponents.FaceIncidence incidence='FaceIncidence::PerEdge', func_bool_from_Id_UndirectedEdgeTag isCompBd='{}')
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_='{}')
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|str|bytes 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)
FaceBitSet	getCrossedFaces (MeshTopology topology, std_vector_EdgePoint isoline)
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='{}')
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)
ProccessMemoryInfo	getProccessMemoryInfo ()
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='{}')
NumSum	getSumSqDistToPoint (IPointPairs pairs, std_optional_double inaccuracy='{}')
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)
pathlib.Path	getUserConfigDir ()
pathlib.Path	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)
std_vector_Id_VertTag	getVertexOrdering (MeshTopology topology, VertBitSet region)
VertBMap	getVertexOrdering (FaceBMap faceMap, MeshTopology topology)
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_long (std_vector_unsigned_long_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	isConsistentlyOriented (MeshTopology topology, std_vector_EdgePoint isoline)
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|str|bytes folder)
bool	isTIFFFile (os.PathLike|str|bytes path)
Id_EdgeTag	isVertexRepeatedOnHoleBd (MeshTopology topology, VertId v)
ToolPathResult	lacingToolPath (MeshPart mp, ToolPathParams params, Axis cutDirection)
IteratorRange_RingIterator_NextEdgeSameLeft	leftRing (MeshTopology topology, Id_EdgeTag edge)
IteratorRange_RingIterator_NextEdgeSameLeft	leftRing (MeshTopology topology, FaceId f)
IteratorRange_RingIterator_NextEdgeSameLeft	leftRing0 (MeshTopology topology, Id_EdgeTag edge)
Mesh	loadASCIIStl (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadASCIIStl (typing.Any in_, MeshLoadSettings settings='{}')
Mesh	loadBinaryStl (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadBinaryStl (typing.Any in_, MeshLoadSettings settings='{}')
DistanceMap	loadDistanceMapFromImage (os.PathLike|str|bytes filename, float threshold=0.003921568859368563)
Mesh	loadDxf (os.PathLike|str|bytes path, MeshLoadSettings settings='{}')
Mesh	loadDxf (typing.Any in_, MeshLoadSettings settings='{}')
None	loadIOExtras ()
Polyline3	loadLines (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
Polyline3	loadLines (typing.Any in_, str extension, func_bool_from_float callback='{}')
Mesh	loadMesh (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadMesh (typing.Any in_, str extension, MeshLoadSettings settings='{}')
None	loadMeshDll ()
Mesh	loadMrmesh (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadMrmesh (typing.Any in_, MeshLoadSettings settings='{}')
Mesh	loadObj (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadObj (typing.Any in_, MeshLoadSettings settings='{}')
LoadedObjects	loadObjectFromFile (os.PathLike|str|bytes filename, func_bool_from_float callback='{}')
Mesh	loadOff (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadOff (typing.Any in_, MeshLoadSettings settings='{}')
Mesh	loadPly (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadPly (typing.Any in_, MeshLoadSettings settings='{}')
PointCloud	loadPoints (os.PathLike|str|bytes file, PointsLoadSettings settings='{}')
PointCloud	loadPoints (typing.Any in_, str extension, PointsLoadSettings settings='{}')
LoadedObjectT	loadSceneFromAnySupportedFormat (os.PathLike|str|bytes path, func_bool_from_float callback='{}')
Object	loadSceneObject (os.PathLike|str|bytes path, func_bool_from_float callback='{}')
Mesh	loadStl (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadStl (typing.Any in_, MeshLoadSettings settings='{}')
std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid	loadVoxels (os.PathLike|str|bytes file, func_bool_from_float cb='{}')
VdbVolume	loadVoxelsGav (os.PathLike|str|bytes file, func_bool_from_float cb='{}')
VdbVolume	loadVoxelsGav (typing.Any in_, func_bool_from_float cb='{}')
VdbVolume	loadVoxelsRaw (os.PathLike|str|bytes file, VoxelsLoad.RawParameters params, func_bool_from_float cb='{}')
VdbVolume	loadVoxelsRaw (os.PathLike|str|bytes file, func_bool_from_float cb='{}')
VdbVolume	loadVoxelsRaw (typing.Any in_, VoxelsLoad.RawParameters params, func_bool_from_float cb='{}')
FaceBitSet	localFindSelfIntersections (Mesh mesh, func_bool_from_float cb='{}')
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)
MakeBridgeResult	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='{}')
int	makeDeloneEdgeFlips (Mesh mesh, DeloneSettings settings='{}', int numIters=1, func_bool_from_float progressCallback='{}')
None	makeDeloneOriginRing (Mesh mesh, Id_EdgeTag e, DeloneSettings settings='{}')
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='{}')
VertCoords	makeNormals (PointCloud pointCloud, int avgNeighborhoodSize=48)
ObjectDistanceMap	makeObjectDistanceMapFromFile (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
LoadedObjectT	makeObjectFromMeshFile (os.PathLike|str|bytes file, func_bool_from_float cb='{}', bool returnOnlyMesh=False)
LoadedObjects	makeObjectFromVoxelsFile (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
ObjectGcode	makeObjectGcodeFromFile (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
ObjectLines	makeObjectLinesFromFile (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
LoadedObjectT_ObjectMesh	makeObjectMeshFromFile (os.PathLike|str|bytes file, func_bool_from_float cb='{}')
ObjectPoints	makeObjectPointsFromFile (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
std_vector_std_shared_ptr_ObjectVoxels	makeObjectVoxelsFromFile (os.PathLike|str|bytes file, func_bool_from_float callback='{}')
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='{}')
VertCoords	makeOrientedNormals (PointCloud pointCloud, AllLocalTriangulations triangs, func_bool_from_float progress='{}')
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)
MakeBridgeResult	makeQuadBridge (MeshTopology topology, Id_EdgeTag a, Id_EdgeTag b, FaceBitSet outNewFaces=None)
Mesh	makeRegularGridMesh (int width, int height, func_bool_from_unsigned_long_long_unsigned_long_long validator, func_Vector3_float_from_unsigned_long_long_unsigned_long_long positioner, func_bool_from_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_long faceValidator='{}', func_bool_from_float cb='{}')
Mesh	makeRegularGridMesh (VertCoords pc, func_bool_from_float cb='{}')
AffineXf3d	makeRigidXf (MeshPart mp, AffineXf3d meshXf)
AffineXf3f	makeRigidXf (MeshPart mp, AffineXf3f meshXf)
None	makeSignedByWindingNumber (OpenVdbFloatGrid grid, Vector3f voxelSize, Mesh refMesh, MakeSignedByWindingNumberSettings settings)
MakeBridgeResult	makeSmoothBridge (Mesh mesh, Id_EdgeTag a, Id_EdgeTag b, float samplingStep, FaceBitSet outNewFaces=None)
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='{}', OrientNormals orient='OrientNormals::Smart')
VertCoords	makeUnorientedNormals (PointCloud pointCloud, AllLocalTriangulations triangs, func_bool_from_float progress='{}', OrientNormals orient='OrientNormals::Smart')
VertCoords	makeUnorientedNormals (PointCloud pointCloud, Buffer_VertId closeVerts, int numNei, func_bool_from_float progress='{}', OrientNormals orient='OrientNormals::Smart')
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 (SimpleVolume volume, MarchingCubesParams params='{}')
Mesh	marchingCubes (SimpleVolumeMinMax volume, MarchingCubesParams params='{}')
Mesh	marchingCubes (VdbVolume volume, MarchingCubesParams params='{}')
Mesh	marchingCubes (FunctionVolume volume, MarchingCubesParams params='{}')
TriMesh	marchingCubesAsTriMesh (SimpleVolume volume, MarchingCubesParams params='{}')
TriMesh	marchingCubesAsTriMesh (SimpleVolumeMinMax volume, MarchingCubesParams params='{}')
TriMesh	marchingCubesAsTriMesh (VdbVolume volume, MarchingCubesParams params='{}')
TriMesh	marchingCubesAsTriMesh (FunctionVolume volume, MarchingCubesParams params='{}')
MarkedContour3f	markedContour (std_vector_Vector3_float in_)
MarkedContour3f	markedFirstLast (std_vector_Vector3_float in_)
Mesh	mcOffsetMesh (MeshPart mp, float offset, OffsetParameters params='{}', Vector_Id_VoxelTag_FaceId outMap=None)
Mesh	mcShellMeshRegion (Mesh mesh, FaceBitSet region, float offset, BaseShellParameters params, Vector_Id_VoxelTag_FaceId outMap=None)
ObjectMesh	merge (std_vector_std_shared_ptr_ObjectMesh objsMesh)
ObjectPoints	merge (std_vector_std_shared_ptr_ObjectPoints objsPoints)
ObjectLines	merge (std_vector_std_shared_ptr_ObjectLines objsLines)
Mesh	mergeMeshes (std_vector_std_shared_ptr_Mesh meshes)
None	meshDenoiseViaNormals (Mesh mesh, DenoiseViaNormalsSettings settings='{}')
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='{}')
FunctionVolume	meshToDistanceFunctionVolume (MeshPart mp, MeshToDistanceVolumeParams params='{}')
VdbVolume	meshToDistanceVdbVolume (MeshPart mp, MeshToVolumeParams params='{}')
SimpleVolumeMinMax	meshToDistanceVolume (MeshPart mp, MeshToDistanceVolumeParams params='{}')
OpenVdbFloatGrid	meshToLevelSet (MeshPart mp, AffineXf3f xf, Vector3f voxelSize, float surfaceOffset=3, func_bool_from_float cb='{}')
PointCloud	meshToPointCloud (Mesh mesh, bool saveNormals=True, VertBitSet verts=None)
VdbVolume	meshToVolume (MeshPart mp, MeshToVolumeParams params='{}')
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='{}')
VertBitSet	moveMeshToVoxelMaxDeriv (Mesh mesh, AffineXf3f meshXf, SimpleVolumeMinMax volume, AffineXf3f volumeXf, MoveMeshToVoxelMaxDerivSettings settings, func_bool_from_float callback='{}')
VertBitSet	moveMeshToVoxelMaxDeriv (Mesh mesh, AffineXf3f meshXf, FunctionVolume volume, AffineXf3f volumeXf, MoveMeshToVoxelMaxDerivSettings settings, func_bool_from_float callback='{}')
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='{}')
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='{}')
bool	objectHasSelectableChildren (Object object)
None	objectSave (Object object, os.PathLike|str|bytes file, func_bool_from_float callback='{}')
std_vector_std_vector_Vector2_float	offsetContours (std_vector_std_vector_Vector2_float contours, float offset, OffsetContoursParams params='{}')
std_vector_std_vector_Vector2_float	offsetContours (std_vector_std_vector_Vector2_float contours, func_float_from_int_int offset, OffsetContoursParams params='{}')
std_vector_std_vector_Vector3_float	offsetContours (std_vector_std_vector_Vector3_float contours, float offset, OffsetContoursParams params='{}', OffsetContoursRestoreZParams zParmas='{}')
std_vector_std_vector_Vector3_float	offsetContours (std_vector_std_vector_Vector3_float contours, func_float_from_int_int offset, OffsetContoursParams params='{}', OffsetContoursRestoreZParams zParmas='{}')
Mesh	offsetMesh (MeshPart mp, float offset, OffsetParameters params='{}')
Mesh	offsetOneDirection (MeshPart mp, float offset, GeneralOffsetParameters params='{}')
Mesh	offsetPolyline (Polyline3 polyline, float offset, OffsetParameters params='{}')
std_vector_std_vector_Vector3_float	offsetSurfaceLine (Mesh mesh, std_vector_MeshTriPoint surfaceLine, float offset)
std_vector_std_vector_Vector3_float	offsetSurfaceLine (Mesh mesh, std_vector_MeshTriPoint surfaceLine, func_float_from_int offsetAtPoint)
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, float radius, func_bool_from_float progress='{}')
bool	orientNormals (PointCloud pointCloud, VertCoords normals, AllLocalTriangulations triangs, func_bool_from_float progress='{}')
bool	orientNormals (PointCloud pointCloud, VertCoords normals, Buffer_VertId closeVerts, int numNei, func_bool_from_float progress='{}')
ObjectPoints	pack (ObjectPoints pts, Reorder reorder, VertBitSet newValidVerts=None, func_bool_from_float cb='{}')
None	parseFirstNum (str str, int_output num)
None	parsePolygon (str str, VertId vertId, int_output numPoints)
Mesh	partialOffsetMesh (MeshPart mp, float offset, GeneralOffsetParameters params='{}')
pathlib.Path	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='{}')
VertBitSet	pointIterativeSampling (PointCloud cloud, int numSamples, func_bool_from_float cb='{}')
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='{}')
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='{}')
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='{}')
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='{}', int blockSize=65536)
None	readRawTiff (os.PathLike|str|bytes path, RawTiffOutput output)
str	readString (typing.Any in_)
TiffParameters	readTiffParameters (os.PathLike|str|bytes 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='{}')
AffineXf3f	refineFeatureObject (FeatureObject featObj, PointCloud pointCloud, RefineParameters params='{}')
bool	relax (Mesh mesh, MeshRelaxParams params='{}', func_bool_from_float cb='{}')
bool	relax (PointCloud pointCloud, PointCloudRelaxParams params='{}', func_bool_from_float cb='{}')
bool	relaxApprox (Mesh mesh, MeshApproxRelaxParams params='{}', func_bool_from_float cb='{}')
bool	relaxApprox (PointCloud pointCloud, PointCloudApproxRelaxParams params='{}', func_bool_from_float cb='{}')
bool	relaxKeepVolume (Mesh mesh, MeshRelaxParams params='{}', func_bool_from_float cb='{}')
bool	relaxKeepVolume (PointCloud pointCloud, PointCloudRelaxParams params='{}', func_bool_from_float cb='{}')
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='{}')
OpenVdbFloatGrid	resampled (OpenVdbFloatGrid grid, Vector3f voxelScale, func_bool_from_float cb='{}')
bool	resolveMeshDegenerations (Mesh mesh, ResolveMeshDegenSettings settings='{}')
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|str|bytes filename, float threshold=0.003921568859368563)
None	saveLines (Polyline3 polyline, os.PathLike|str|bytes file, SaveSettings settings='{}')
None	saveLines (Polyline3 polyline, str extension, typing.Any out, SaveSettings settings='{}')
None	saveMesh (Mesh mesh, os.PathLike|str|bytes file, SaveSettings settings='{}')
None	saveMesh (Mesh mesh, str extension, typing.Any out, SaveSettings settings='{}')
None	saveObjectVoxelsToFile (Object object, os.PathLike|str|bytes path, func_bool_from_float callback='{}')
None	savePoints (PointCloud points, os.PathLike|str|bytes file, SaveSettings settings='{}')
None	savePoints (PointCloud points, str extension, typing.Any out, SaveSettings settings='{}')
None	saveSliceToImage (os.PathLike|str|bytes path, VdbVolume vdbVolume, SlicePlane slicePlain, int sliceNumber, func_bool_from_float callback='{}')
None	saveVoxels (VdbVolume vdbVolume, os.PathLike|str|bytes file, func_bool_from_float callback='{}')
None	saveVoxelsGav (VdbVolume vdbVolume, os.PathLike|str|bytes file, func_bool_from_float callback='{}')
None	saveVoxelsGav (SimpleVolumeMinMax simpleVolumeMinMax, os.PathLike|str|bytes file, func_bool_from_float callback='{}')
None	saveVoxelsGav (SimpleVolume simpleVolume, os.PathLike|str|bytes file, func_bool_from_float callback='{}')
None	saveVoxelsGav (VdbVolume vdbVolume, typing.Any out, func_bool_from_float callback='{}')
None	saveVoxelsGav (SimpleVolumeMinMax simpleVolumeMinMax, typing.Any out, func_bool_from_float callback='{}')
None	saveVoxelsGav (SimpleVolume simpleVolume, typing.Any out, func_bool_from_float callback='{}')
None	saveVoxelsRaw (VdbVolume vdbVolume, os.PathLike|str|bytes file, func_bool_from_float callback='{}')
None	saveVoxelsRaw (SimpleVolume simpleVolume, os.PathLike|str|bytes file, func_bool_from_float callback='{}')
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='{}')
std_vector_Mesh	segmentVoxelMaskToInstances (VdbVolume mask, int minSize=100, func_bool_from_float cb='{}')
std_vector_TaggedBitSet_FaceTag	separateClosedContour (Mesh mesh, std_vector_Vector3_float contour, func_void_from_EdgePoint cb='{}')
None	serializeMesh (Mesh mesh, os.PathLike|str|bytes path, FaceBitSet selection=None, str serializeFormat='".mrmesh"')
None	serializeObjectTree (Object object, os.PathLike|str|bytes path, func_bool_from_float progress, func_void_from_std_filesystem_path preCompress)
None	serializeObjectTree (Object object, os.PathLike|str|bytes path, func_bool_from_float progress='{}')
None	serializeObjectTreeToGltf (Object root, os.PathLike|str|bytes file, func_bool_from_float callback='{}')
None	setDefaultSerializeMeshFormat (str newFormat)
None	setDefaultSerializePointsFormat (str newFormat)
None	setDefaultSerializeVoxelsFormat (str newFormat)
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='{}')
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, SignedDistanceToMeshOptions op)
OpenVdbFloatGrid	simpleVolumeToDenseGrid (SimpleVolume simpleVolume, float background=0.0, func_bool_from_float cb='{}')
VdbVolume	simpleVolumeToVdbVolume (SimpleVolumeMinMax simpleVolume, func_bool_from_float cb='{}')
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_long	splitByLines (str data, int size)
std_vector_std_vector_Id_EdgeTag	splitOnSimpleLoops (MeshTopology topology, std_vector_std_vector_Id_EdgeTag loops)
None	splitQuad (MeshTopology topology, Id_EdgeTag a, FaceBitSet outNewFaces=None)
float	sqr (Vector3f a)
float	sqr (Vector3d a)
int	sqr (Vector3i a)
float	sqr (Vector2f a)
float	sqr (Vector2d a)
int	sqr (Vector2i a)
float	sqr (float x)
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='{}')
int	subdividePolyline (Polyline2 polyline, PolylineSubdivideSettings settings='{}')
int	subdividePolyline (Polyline3 polyline, PolylineSubdivideSettings settings='{}')
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='{}')
Mesh	terrainTriangulation (std_vector_Vector3_float points, func_bool_from_float cb='{}')
Mesh	thickenMesh (Mesh mesh, float offset, GeneralOffsetParameters params='{}')
str	toLower (str str)
str	toString (PathError error)
str	toString (DimensionsVisualizePropertyType value)
MeshTopology	topologyFromTriangles (Triangulation t, MeshBuilder.BuildSettings settings='{}', func_bool_from_float progressCb='{}')
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 planePoint, bool ccw)
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)
TransformVdbVolumeResult	transformVdbVolume (VdbVolume volume, AffineXf3f xf, bool fixBox=False, Box3f box='{}')
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='{}', func_bool_from_float progressCb='{}')
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='{}')
IteratorRange_PolylineUndirectedEdgeIterator	undirectedEdges (PolylineTopology topology)
IteratorRange_UndirectedEdgeIterator	undirectedEdges (MeshTopology 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='{}')
Mesh	uniteManyMeshes (std_vector_Mesh_const meshes, UniteManyMeshesParams params='{}')
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|str|bytes path)
SimpleVolumeMinMax	vdbVolumeToSimpleVolume (VdbVolume vdbVolume, Box3i activeBox='MR::Box3i()', func_bool_from_float cb='{}')
SimpleVolumeMinMax	vdbVolumeToSimpleVolumeNorm (VdbVolume vdbVolume, Box3i activeBox='MR::Box3i()', std_optional_Box_float sourceScale='{}', func_bool_from_float cb='{}')
SimpleVolumeMinMaxU16	vdbVolumeToSimpleVolumeU16 (VdbVolume vdbVolume, Box3i activeBox='MR::Box3i()', std_optional_Box_float sourceScale='{}', func_bool_from_float cb='{}')
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='{}')
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)
bool	voxelsApplyTransform (ObjectVoxels obj, AffineXf3f xf, bool fixBox)
func_float_from_unsigned_long_long_unsigned_long_long	voxelsExponentMetric (VdbVolume voxels, VoxelMetricParameters parameters, float modifier=-1.0)
func_float_from_unsigned_long_long_unsigned_long_long	voxelsSumDiffsMetric (VdbVolume voxels, VoxelMetricParameters parameters)
str	wideToUtf8 (str wide)
bool	writeByBlocks (typing.Any out, str data, int dataSize, func_bool_from_float callback='{}', int blockSize=65536)
None	writeRawTiff (int bytes, os.PathLike|str|bytes 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
	AABBTreeNode_AABBTreeBase_ObjTreeTraits_Traits = AABBTreeNode_ObjTreeTraits
	AffineXf_Vector2d_M = Matrix2d
	AffineXf_Vector2f_M = Matrix2f
	AffineXf_Vector3d_M = Matrix3d
	AffineXf_Vector3f_M = Matrix3f
	AllVisualizeProperties = std_vector_ViewportMask
	BMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = BMap_Id_ICPElemtTag_Id_ICPElemtTag
	BMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = BMap_Id_VoxelTag_Id_VoxelTag
	Ball_Vector2d_VTraits = VectorTraits_Vector2d
	Ball_Vector2f_VTraits = VectorTraits_Vector2f
	Ball_Vector3d_VTraits = VectorTraits_Vector3d
	Ball_Vector3f_VTraits = VectorTraits_Vector3f
	Ball_double_VTraits = VectorTraits_double
	Ball_float_VTraits = VectorTraits_float
	BooleanResMapObj = BooleanResultMapper.MapObject
	Box_Vector2d_VTraits = VectorTraits_Vector2d
	Box_Vector2f_VTraits = VectorTraits_Vector2f
	Box_Vector2i_VTraits = VectorTraits_Vector2i
	Box_Vector2ll_VTraits = VectorTraits_Vector2ll
	Box_Vector3d_VTraits = VectorTraits_Vector3d
	Box_Vector3f_VTraits = VectorTraits_Vector3f
	Box_Vector3i_VTraits = VectorTraits_Vector3i
	Box_Vector3ll_VTraits = VectorTraits_Vector3ll
	Box_double_VTraits = VectorTraits_double
	Box_float_VTraits = VectorTraits_float
	Box_int_VTraits = VectorTraits_int
	Box_long_long_VTraits = VectorTraits_long_long
	ColorMapAggregator_FaceTag_ColorMap = FaceColors
	ColorMapAggregator_FaceTag_ElementBitSet = FaceBitSet
	ColorMapAggregator_UndirectedEdgeTag_ColorMap = UndirectedEdgeColors
	ColorMapAggregator_UndirectedEdgeTag_ElementBitSet = UndirectedEdgeBitSet
	ColorMapAggregator_VertTag_ColorMap = VertColors
	ColorMapAggregator_VertTag_ElementBitSet = VertBitSet
	ContinuousContour = std_vector_VariableEdgeTri
	ContinuousContours = std_vector_std_vector_VariableEdgeTri
	Contour2d = std_vector_Vector2_double
	Contour2f = std_vector_Vector2_float
	Contour3d = std_vector_Vector3_double
	Contour3f = std_vector_Vector3_float
	Contours2d = std_vector_std_vector_Vector2_double
	Contours2f = std_vector_std_vector_Vector2_float
	Contours3d = std_vector_std_vector_Vector3_double
	Contours3f = std_vector_std_vector_Vector3_float
	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_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
	HashMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = phmap_flat_hash_map_Id_ICPElemtTag_Id_ICPElemtTag
	HashMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag
	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
	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
	Line3dMesh = Line3Mesh_double
	Line3fMesh = Line3Mesh_float
	LineTreeTraits2 = AABBTreeTraits_UndirectedEdgeTag_Box2f
	LineTreeTraits3 = AABBTreeTraits_UndirectedEdgeTag_Box3f
	LoadedObject = LoadedObjectT
	LoadedObjectLines = LoadedObjectT_ObjectLines
	LoadedObjectMesh = LoadedObjectT_ObjectMesh
	LoadedObjectPoints = LoadedObjectT_ObjectPoints
	LoadedObjectT_Object = LoadedObjectT
	LoadedObjectVoxels = LoadedObjectT_ObjectVoxels
	Matrix2_bool_VectorType = Vector2b
	Matrix2_double_VectorType = Vector2d
	Matrix2_float_VectorType = Vector2f
	Matrix2_int_VectorType = Vector2i
	Matrix2_long_long_VectorType = Vector2ll
	Matrix3_bool_VectorType = Vector3b
	Matrix3_double_VectorType = Vector3d
	Matrix3_float_VectorType = Vector3f
	Matrix3_int_VectorType = Vector3i
	Matrix3_long_long_VectorType = Vector3ll
	Matrix4_bool_VectorType = Vector4b
	Matrix4_double_VectorType = Vector4d
	Matrix4_float_VectorType = Vector4f
	Matrix4_int_VectorType = Vector4i
	Matrix4_long_long_VectorType = Vector4ll
	MeshBuilderSettings = MeshBuilder.BuildSettings
	MeshDistanceResult = MeshMeshDistanceResult
	MeshEdgePoint = EdgePoint
	MeshLabel = PositionedText
	MeshOnVoxelsFunction = MeshOnVoxelsT_Mesh_FunctionVolume
	MeshOnVoxelsFunctionC = MeshOnVoxelsT_const_Mesh_FunctionVolume
	MeshOnVoxelsSimple = MeshOnVoxelsT_Mesh_SimpleVolumeMinMax
	MeshOnVoxelsSimpleC = MeshOnVoxelsT_const_Mesh_SimpleVolumeMinMax
	MeshOnVoxelsVdb = MeshOnVoxelsT_Mesh_VdbVolume
	MeshOnVoxelsVdbC = MeshOnVoxelsT_const_Mesh_VdbVolume
	MeshSignedDistanceResult = MeshMeshSignedDistanceResult
	MeshToVolumeParamsType = MeshToVolumeParams.Type
	MinMax_VoxelsVolume_std_vector_unsigned_short_ValueType = Box_unsigned_short
	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
	PickedPoint = std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int
	PlaneSection = std_vector_EdgePoint
	PlaneSections = std_vector_std_vector_EdgePoint
	PolynomialWrapperd = PolynomialWrapper_double
	PolynomialWrapperf = PolynomialWrapper_float
	Polynomial_double_0ULL_0_0_0ULL_minus_1 = Polynomial_double_0
	Polynomial_double_1ULL_0_0_1ULL_minus_1 = Polynomial_double_0
	Polynomial_double_2ULL_0_0_2ULL_minus_1 = Polynomial_double_1
	Polynomial_double_3ULL_0_0_3ULL_minus_1 = Polynomial_double_2
	Polynomial_double_4ULL_0_0_4ULL_minus_1 = Polynomial_double_3
	Polynomial_double_5ULL_0_0_5ULL_minus_1 = Polynomial_double_4
	Polynomial_double_6ULL_0_0_6ULL_minus_1 = Polynomial_double_5
	Polynomial_float_0ULL_0_0_0ULL_minus_1 = Polynomial_float_0
	Polynomial_float_1ULL_0_0_1ULL_minus_1 = Polynomial_float_0
	Polynomial_float_2ULL_0_0_2ULL_minus_1 = Polynomial_float_1
	Polynomial_float_3ULL_0_0_3ULL_minus_1 = Polynomial_float_2
	Polynomial_float_4ULL_0_0_4ULL_minus_1 = Polynomial_float_3
	Polynomial_float_5ULL_0_0_5ULL_minus_1 = Polynomial_float_4
	Polynomial_float_6ULL_0_0_6ULL_minus_1 = Polynomial_float_5
	Polynomialx_double = std_variant_Polynomial_double_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6
	Polynomialx_float = std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6
	QuadraticForm_Vector2d_SM = SymMatrix2d
	QuadraticForm_Vector2f_SM = SymMatrix2f
	QuadraticForm_Vector3d_SM = SymMatrix3d
	QuadraticForm_Vector3f_SM = SymMatrix3f
	RigidScaleXf3_double_V = Vector3d
	RigidScaleXf3_float_V = Vector3f
	RigidXf3_double_V = Vector3d
	RigidXf3_float_V = Vector3f
	SeparationPointMap = phmap_flat_hash_map_unsigned_long_long_std_array_Id_VertTag_3
	SeparationPointSet = std_array_Id_VertTag_3
	SurfacePath = std_vector_EdgePoint
	SurfacePaths = std_vector_std_vector_EdgePoint
	TaggedBitSet_EdgeTag_IndexType = Id_EdgeTag
	TaggedBitSet_FaceTag_IndexType = FaceId
	TaggedBitSet_GraphEdgeTag_IndexType = GraphEdgeId
	TaggedBitSet_GraphVertTag_IndexType = GraphVertId
	TaggedBitSet_NodeTag_IndexType = NodeId
	TaggedBitSet_ObjTag_IndexType = ObjId
	TaggedBitSet_PixelTag_IndexType = PixelId
	TaggedBitSet_RegionTag_IndexType = RegionId
	TaggedBitSet_TextureTag_IndexType = TextureId
	TaggedBitSet_UndirectedEdgeTag_IndexType = UndirectedEdgeId
	TaggedBitSet_VertTag_IndexType = VertId
	TaggedBitSet_VoxelTag_IndexType = Id_VoxelTag
	TextAlignParams = TextMeshAlignParams
	ThreePoints = std_array_Vector3_float_3
	ThreeVertIds = std_array_Id_VertTag_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_MatrixType = Matrix2b
	Vector2_bool_SymMatrixType = SymMatrix2b
	Vector2_double_MatrixType = Matrix2d
	Vector2_double_SymMatrixType = SymMatrix2d
	Vector2_float_MatrixType = Matrix2f
	Vector2_float_SymMatrixType = SymMatrix2f
	Vector2_int_MatrixType = Matrix2i
	Vector2_int_SymMatrixType = SymMatrix2i
	Vector2_long_long_MatrixType = Matrix2ll
	Vector2_long_long_SymMatrixType = SymMatrix2ll
	Vector3_bool_MatrixType = Matrix3b
	Vector3_bool_SymMatrixType = SymMatrix3b
	Vector3_double_MatrixType = Matrix3d
	Vector3_double_SymMatrixType = SymMatrix3d
	Vector3_float_MatrixType = Matrix3f
	Vector3_float_SymMatrixType = SymMatrix3f
	Vector3_int_MatrixType = Matrix3i
	Vector3_int_SymMatrixType = SymMatrix3i
	Vector3_long_long_MatrixType = Matrix3ll
	Vector3_long_long_SymMatrixType = SymMatrix3ll
	Vector4_bool_MatrixType = Matrix4b
	Vector4_bool_SymMatrixType = SymMatrix4b
	Vector4_double_MatrixType = Matrix4d
	Vector4_double_SymMatrixType = SymMatrix4d
	Vector4_float_MatrixType = Matrix4f
	Vector4_float_SymMatrixType = SymMatrix4f
	Vector4_int_MatrixType = Matrix4i
	Vector4_int_SymMatrixType = SymMatrix4i
	Vector4_long_long_MatrixType = Matrix4ll
	Vector4_long_long_SymMatrixType = SymMatrix4ll
	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_UndirectedEdgeId_const_reference = Color
	Vector_Color_UndirectedEdgeId_reference = Color
	Vector_Color_UndirectedEdgeId_value_type = Color
	Vector_Color_VertId_const_reference = Color
	Vector_Color_VertId_reference = Color
	Vector_Color_VertId_value_type = Color
	Vector_Dipole_NodeId_const_reference = Dipole
	Vector_Dipole_NodeId_reference = Dipole
	Vector_Dipole_NodeId_value_type = Dipole
	Vector_FaceId_FaceId_const_reference = FaceId
	Vector_FaceId_FaceId_reference = FaceId
	Vector_FaceId_FaceId_value_type = FaceId
	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_const_reference = ObjId
	Vector_ObjId_ObjId_reference = ObjId
	Vector_ObjId_ObjId_value_type = ObjId
	Vector_RegionId_FaceId_const_reference = RegionId
	Vector_RegionId_FaceId_reference = RegionId
	Vector_RegionId_FaceId_value_type = RegionId
	Vector_RegionId_UndirectedEdgeId_const_reference = RegionId
	Vector_RegionId_UndirectedEdgeId_reference = RegionId
	Vector_RegionId_UndirectedEdgeId_value_type = RegionId
	Vector_RegionId_VertId_const_reference = RegionId
	Vector_RegionId_VertId_reference = RegionId
	Vector_RegionId_VertId_value_type = RegionId
	Vector_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = Vector_Id_ICPElemtTag_Id_ICPElemtTag
	Vector_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = Vector_Id_VoxelTag_Id_VoxelTag
	Vector_TextureId_FaceId_const_reference = TextureId
	Vector_TextureId_FaceId_reference = TextureId
	Vector_TextureId_FaceId_value_type = TextureId
	Vector_UndirectedEdgeId_UndirectedEdgeId_const_reference = UndirectedEdgeId
	Vector_UndirectedEdgeId_UndirectedEdgeId_reference = UndirectedEdgeId
	Vector_UndirectedEdgeId_UndirectedEdgeId_value_type = UndirectedEdgeId
	Vector_Vector2f_VertId_const_reference = Vector2f
	Vector_Vector2f_VertId_reference = Vector2f
	Vector_Vector2f_VertId_value_type = Vector2f
	Vector_Vector3f_FaceId_const_reference = Vector3f
	Vector_Vector3f_FaceId_reference = Vector3f
	Vector_Vector3f_FaceId_value_type = Vector3f
	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_const_reference = VertId
	Vector_VertId_VertId_reference = VertId
	Vector_VertId_VertId_value_type = VertId
	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
	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_long_std_array_VertId_3_phmap_Hash_uint64_t = phmap_flat_hash_map_unsigned_long_long_std_array_Id_VertTag_3
	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_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_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_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_variant_FaceId_Id_EdgeTag_VertId = std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag
	std_variant_MeshTriPoint_EdgePoint_VertId_int = std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int
	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_UndirectedEdgeTag_Box2f = std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector2_float
	std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f = std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector3_float
	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_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_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_FaceId = std_vector_Id_FaceTag
	std_vector_FanRecord_const_reference = FanRecord
	std_vector_FanRecord_reference = FanRecord
	std_vector_FanRecord_value_type = FanRecord
	std_vector_GraphEdgeId = std_vector_Id_GraphEdgeTag
	std_vector_GraphVertId = std_vector_Id_GraphVertTag
	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_LineSegm3f = std_vector_LineSegm_Vector3_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_NodeId = std_vector_Id_NodeTag
	std_vector_ObjId = std_vector_Id_ObjTag
	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_PlanarTriangulation_ContourIdMap = std_vector_std_vector_PlanarTriangulation_IntersectionInfo
	std_vector_Polyline3 = std_vector_Polyline_Vector3_float
	std_vector_QuadraticForm2f = std_vector_QuadraticForm_Vector2_float
	std_vector_QuadraticForm3f = std_vector_QuadraticForm_Vector3_float
	std_vector_RegionId = std_vector_Id_RegionTag
	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_4
	std_vector_TextureId = std_vector_Id_TextureTag
	std_vector_TriPointf = std_vector_TriPoint_float
	std_vector_UndirectedEdgeBitSet = std_vector_TaggedBitSet_UndirectedEdgeTag
	std_vector_UndirectedEdgeId = std_vector_Id_UndirectedEdgeTag
	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_Vector3d = std_vector_Vector3_double
	std_vector_Vector3f = std_vector_Vector3_float
	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_VertId = std_vector_Id_VertTag
	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_long
	std_vector_std_array_Vector3f_3 = std_vector_std_array_Vector3_float_3
	std_vector_std_array_VertId_3 = std_vector_std_array_Id_VertTag_3
	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_long_unsigned_long_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_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_tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string = std_vector_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid_std_string
	std_vector_tl_expected_VoxelsLoad_DicomVolume_std_string = std_vector_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_vector_float_std_string
	std_vector_uint8_t = std_vector_unsigned_char
	tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string = expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid_std_string
	tl_expected_VoxelsLoad_DicomVolume_std_string = expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_vector_float_std_string
	vectorConstMeshPtr = std_vector_Mesh_const
	vectorEdges = std_vector_Id_EdgeTag

Function Documentation

accumulateFaceCenters()

None 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 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 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 mrmeshpy.accumulatePoints	(	PointAccumulator	accum,
		std_vector_Vector3_float	points,
		AffineXf3f	xf = None )

Adds in existing PointAccumulator all given points

accumulateWeighedPoints()

None 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 mrmeshpy.addBaseToPlanarMesh	(	Mesh	mesh,
		float	zOffset )

given a planar mesh with boundary on input located in plane XY, packs and extends it along Z on zOffset (along -Z if zOffset is negative) to make a volumetric closed mesh

addLeftBand()

None 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() [1/2]

None mrmeshpy.addNoise	(	Mesh	mesh,
		VertBitSet	region = None,
		NoiseSettings	settings = '{}' )

addNoise() [2/2]

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

Adds noise to the points, using a normal distribution

alignTextToMesh()

Mesh mrmeshpy.alignTextToMesh	(	Mesh	mesh,
		TextMeshAlignParams	params )

Creates symbol mesh and aligns it to given surface

angle() [1/6]

float mrmeshpy.angle	(	Vector2d	a,
		Vector2d	b )

angle in radians between two vectors

angle() [2/6]

float mrmeshpy.angle	(	Vector2f	a,
		Vector2f	b )

angle in radians between two vectors

angle() [3/6]

int mrmeshpy.angle	(	Vector2i	a,
		Vector2i	b )

angle in radians between two vectors

angle() [4/6]

float 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 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 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 mrmeshpy.appendObjectFromTreeRecursive	(	Object	obj,
		std_vector_std_shared_ptr_Object	res,
		ObjectSelectivityType	type )

appendObjectFromTreeRecursive() [2/10]

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

appendObjectFromTreeRecursive() [3/10]

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

appendObjectFromTreeRecursive() [4/10]

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

appendObjectFromTreeRecursive() [5/10]

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

appendObjectFromTreeRecursive() [6/10]

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

appendObjectFromTreeRecursive() [7/10]

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

appendObjectFromTreeRecursive() [8/10]

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

appendObjectFromTreeRecursive() [9/10]

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

appendObjectFromTreeRecursive() [10/10]

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

applyDouble() [1/2]

Vector3d mrmeshpy.applyDouble	(	AffineXf3d	xf,
		Vector3f	p )

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

applyDouble() [2/2]

Vector3d mrmeshpy.applyDouble	(	Matrix3d	m,
		Vector3f	n )

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

applyFloat() [1/2]

Vector3f 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 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 mrmeshpy.asSelectivityType_Object	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_ObjectDistanceMap()

ObjectDistanceMap mrmeshpy.asSelectivityType_ObjectDistanceMap	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_ObjectLines()

ObjectLines mrmeshpy.asSelectivityType_ObjectLines	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_ObjectLinesHolder()

ObjectLinesHolder mrmeshpy.asSelectivityType_ObjectLinesHolder	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_ObjectMesh()

ObjectMesh mrmeshpy.asSelectivityType_ObjectMesh	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_ObjectMeshHolder()

ObjectMeshHolder mrmeshpy.asSelectivityType_ObjectMeshHolder	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_ObjectPoints()

ObjectPoints mrmeshpy.asSelectivityType_ObjectPoints	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_ObjectPointsHolder()

ObjectPointsHolder mrmeshpy.asSelectivityType_ObjectPointsHolder	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_ObjectVoxels()

ObjectVoxels mrmeshpy.asSelectivityType_ObjectVoxels	(	Object	obj,
		ObjectSelectivityType	type )

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

asSelectivityType_VisualObject()

VisualObject mrmeshpy.asSelectivityType_VisualObject	(	Object	obj,
		ObjectSelectivityType	type )

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

asString() [1/2]

str mrmeshpy.asString

(

SignDetectionMode

m

)

returns string representation of enum values

asString() [2/2]

str mrmeshpy.asString

(

str

s

)

asU8String()

str mrmeshpy.asU8String

(

str

s

)

autoOrientLocalTriangulations()

bool mrmeshpy.autoOrientLocalTriangulations	(	PointCloud	pointCloud,
		AllLocalTriangulations	triangs,
		VertBitSet	region,
		func_bool_from_float	progress = '{}',
		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/2]

RingIterator_NextEdgeSameOrigin mrmeshpy.begin

(

IteratorRange_RingIterator_NextEdgeSameOrigin

range

)

begin() [2/2]

ViewportIterator mrmeshpy.begin

(

ViewportMask

mask

)

bestQuadrangleDiagonal()

bool 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 mrmeshpy.blend	(	Color	front,
		Color	back )

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

boolean() [1/2]

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

\\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 mrmeshpy.boolean	(	Mesh	meshA,
		Mesh	meshB,
		BooleanOperation	operation,
		BooleanParameters	params = '{}' )

buildBottom()

Id_EdgeTag 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 mrmeshpy.buildCylinderBetweenTwoHoles	(	Mesh	mesh,
		Id_EdgeTag	a,
		Id_EdgeTag	b,
		StitchHolesParams	params = '{}' )

\\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 mrmeshpy.buildCylinderBetweenTwoHoles	(	Mesh	mesh,
		StitchHolesParams	params = '{}' )

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

buildShortestPath() [1/2]

std_vector_Id_EdgeTag 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 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 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 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 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 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 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 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_long mrmeshpy.buildSmallestMetricPath	(	VdbVolume	voxels,
		func_float_from_unsigned_long_long_unsigned_long_long	metric,
		int	start,
		int	finish,
		func_bool_from_float	cb = '{}' )

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 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 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 mrmeshpy.buildUnitedLocalTriangulations	(	PointCloud	cloud,
		TriangulationHelpers.Settings	settings,
		func_bool_from_float	progress = '{}' )

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

bytesString()

str 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 mrmeshpy.calcAvgColors	(	PointCloud	cloud,
		VertColors	colors,
		VertCoords	tgtPoints,
		VertBitSet	tgtVerts,
		float	sigma,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.calcCombinedFillMetric	(	Mesh	mesh,
		FaceBitSet	filledRegion,
		FillHoleMetric	metric )

Computes combined metric after filling a hole

calcDamerauLevenshteinDistance()

int 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 mrmeshpy.calcDipoles	(	AABBTree	tree,
		Mesh	mesh )

calcDipoles() [2/2]

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

calculates dipoles for given mesh and AABB-tree

calcFaceDistances()

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

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 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 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 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 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 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 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 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 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 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 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 mrmeshpy.calcOriginAndDimensions	(	Box3f	box,
		float	voxelSize )

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

calcPathLength()

float mrmeshpy.calcPathLength	(	std_vector_Id_EdgeTag	path,
		Mesh	mesh )

calcPathMetric()

float mrmeshpy.calcPathMetric	(	std_vector_Id_EdgeTag	path,
		func_float_from_Id_EdgeTag	metric )

computes summed metric of all edges in the path

canMinimizePolynomial()

bool mrmeshpy.canMinimizePolynomial

(

int

degree

)

canSolvePolynomial()

bool mrmeshpy.canSolvePolynomial

(

int

degree

)

ccw() [1/4]

bool mrmeshpy.ccw

(

PreciseVertCoords2

vs

)

ccw() [2/4]

bool 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 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 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 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 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 mrmeshpy.checkDeloneQuadrangleInMesh	(	Mesh	mesh,
		Id_EdgeTag	edge,
		DeloneSettings	settings = '{}',
		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 mrmeshpy.classifyShellVert	(	MeshPart	mp,
		Vector3f	shellPoint,
		FindInnerShellSettings	settings = '{}' )

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 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 mrmeshpy.cloneRegion	(	ObjectPoints	objPoints,
		VertBitSet	region )

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

combineXYderivativeMaps()

DistanceMap mrmeshpy.combineXYderivativeMaps

(

tuple[DistanceMap, DistanceMap]

XYderivativeMaps

)

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

commonFilesName()

str 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"

compensateRadius()

None mrmeshpy.compensateRadius	(	Mesh	mesh,
		CompensateRadiusParams	params )

compensate spherical milling tool radius in given mesh region making it possible to mill it
please note that it will change topology inside region
also please note that boundaries of the region are fixed

compressZip()

None mrmeshpy.compressZip	(	os.PathLike | str | bytes	zipFile,
		os.PathLike | str | bytes	sourceFolder,
		std_vector_std_filesystem_path	excludeFiles = '{}',
		str	password = None,
		func_bool_from_float	cb = '{}' )

 \\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 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 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 mrmeshpy.computeDistanceMap	(	MeshPart	mp,
		MeshToDistanceMapParams	params,
		func_bool_from_float	cb = '{}',
		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 mrmeshpy.computeDistanceMapD	(	MeshPart	mp,
		MeshToDistanceMapParams	params,
		func_bool_from_float	cb = '{}',
		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 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 mrmeshpy.computeFormAtVertex	(	MeshPart	mp,
		VertId	v,
		float	stabilizer,
		bool	angleWeigted,
		UndirectedEdgeBitSet	creases = None )

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

computeFormsAtVertices()

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

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

computeGeodesicPath()

std_vector_EdgePoint 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 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 mrmeshpy.computeInSphereThicknessAtVertices	(	Mesh	mesh,
		InSphereSearchSettings	settings,
		func_bool_from_float	progress = '{}' )

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

computeMeshNormals()

MeshNormals mrmeshpy.computeMeshNormals

(

Mesh

mesh

)

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

computeNormal()

Vector3f 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 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 mrmeshpy.computePerFaceNormals

(

Mesh

mesh

)

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

computePerFaceNormals4()

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

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

computePerVertNormals()

VertCoords mrmeshpy.computePerVertNormals

(

Mesh

mesh

)

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

computePerVertPseudoNormals()

VertCoords 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 mrmeshpy.computeRayThicknessAtVertices	(	Mesh	mesh,
		func_bool_from_float	progress = '{}' )

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

computeSkyViewFactor()

VertScalars 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 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 mrmeshpy.computeSteepestDescentPath	(	MeshPart	mp,
		VertScalars	field,
		MeshTriPoint	start,
		ComputeSteepestDescentPathSettings	settings = '{}' )

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 mrmeshpy.computeSteepestDescentPath	(	MeshPart	mp,
		VertScalars	field,
		MeshTriPoint	start,
		std_vector_EdgePoint	outPath,
		ComputeSteepestDescentPathSettings	settings = '{}' )

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 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 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 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 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 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 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 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 mrmeshpy.computeThicknessAtVertices

(

Mesh

mesh

)

computeTrianglesRepetitions()

std_array_int_4 mrmeshpy.computeTrianglesRepetitions

(

AllLocalTriangulations

triangs

)

computes statistics about the number of triangle repetitions in local triangulations

constantCuspToolPath()

ToolPathResult 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 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 mrmeshpy.contains	(	FaceBitSet	bitset,
		FaceId	id )

contourIntersection()

Polyline2 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 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 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 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 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

convertMeshTriPointsSurfaceOffsetToMeshContours() [1/2]

std_vector_OneMeshContour mrmeshpy.convertMeshTriPointsSurfaceOffsetToMeshContours	(	Mesh	mesh,
		std_vector_MeshTriPoint	surfaceLine,
		float	offset,
		SearchPathSettings	searchSettings = '{}' )

\\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 surfaceLine and build offset contour on surface for MR::cutMesh input
\\param offset amount of offset form given point, note that absolute value is used and isoline in both direction returned
\\param searchSettings settings for search geodesic path

convertMeshTriPointsSurfaceOffsetToMeshContours() [2/2]

std_vector_OneMeshContour mrmeshpy.convertMeshTriPointsSurfaceOffsetToMeshContours	(	Mesh	mesh,
		std_vector_MeshTriPoint	surfaceLine,
		func_float_from_int	offsetAtPoint,
		SearchPathSettings	searchSettings = '{}' )

\\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 surfaceLine and build offset contour on surface for MR::cutMesh input
\\param offsetAtPoint functor that returns amount of offset form arg point, note that absolute value is used and isoline in both direction returned
\\param searchSettings settings for search geodesic path

convertMeshTriPointsToClosedContour()

OneMeshContour mrmeshpy.convertMeshTriPointsToClosedContour	(	Mesh	mesh,
		std_vector_MeshTriPoint	surfaceLine,
		SearchPathSettings	searchSettings = '{}',
		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 surfaceLine and build closed contour MR::cutMesh input
\\param pivotIndices optional output indices of given surfaceLine in result OneMeshContour
\\note better use convertMeshTriPointsToMeshContour(...) instead, note that it requires same front and back MeshTriPoints for closed contour

convertMeshTriPointsToMeshContour()

OneMeshContour mrmeshpy.convertMeshTriPointsToMeshContour	(	Mesh	mesh,
		std_vector_MeshTriPoint	surfaceLine,
		SearchPathSettings	searchSettings = '{}',
		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 surfaceLine and build contour MR::cutMesh input
\\param searchSettings settings for search geo path 
\\param pivotIndices optional output indices of given surfaceLine in result OneMeshContour

convertSurfacePathsToMeshContours()

std_vector_OneMeshContour 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 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 mrmeshpy.copyContour

(

std_vector_Vector2_double

from_

)

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

copyContour() [2/4]

std_vector_Vector2_double mrmeshpy.copyContour

(

std_vector_Vector2_float

from_

)

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

copyContour() [3/4]

std_vector_Vector3_float mrmeshpy.copyContour

(

std_vector_Vector3_double

from_

)

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

copyContour() [4/4]

std_vector_Vector3_double mrmeshpy.copyContour

(

std_vector_Vector3_float

from_

)

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

copySubdividePackMesh()

Mesh mrmeshpy.copySubdividePackMesh	(	MeshPart	mp,
		float	voxelSize,
		func_bool_from_float	cb = '{}' )

creates a copy of given mesh part, subdivides it to get rid of too long edges compared with voxelSize, then packs resulting mesh,
this is called typically in preparation for 3D space sampling with voxelSize step, and subdivision is important for making leaves of AABB tree not too big compared with voxelSize

createObject()

Object mrmeshpy.createObject

(

str

className

)

the function to create new object instance by registered class name

createProjectionTransforms()

MeshProjectionTransforms mrmeshpy.createProjectionTransforms	(	AffineXf3f	storageXf,
		AffineXf3f	pointXf,
		AffineXf3f	treeXf )

<summary>
Creates structure with simplified transforms for projection functions, with `rigidXfPoint` applied to point, and `nonRigidXfTree` applied to tree
</summary>
<param name="storageXf">this argument will hold modified transfrom</param>
<param name="pointXf">transform for points to be projected</param>
<param name="treeXf">transform for tree's boxes</param>
<returns>structure with simplified transforms</returns>

createRootFormObject()

SceneRootObject 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 mrmeshpy.createSymbolContours

(

SymbolMeshParams

params

)

converts text string into set of contours

createSymbolsMesh()

Mesh mrmeshpy.createSymbolsMesh

(

SymbolMeshParams

params

)

converts text string into Z-facing symbol mesh

cropped()

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

returns cropped grid

cross() [1/6]

float mrmeshpy.cross	(	Vector2d	a,
		Vector2d	b )

cross product

cross() [2/6]

float mrmeshpy.cross	(	Vector2f	a,
		Vector2f	b )

cross product

cross() [3/6]

int mrmeshpy.cross	(	Vector2i	a,
		Vector2i	b )

cross product

cross() [4/6]

Vector3d mrmeshpy.cross	(	Vector3d	a,
		Vector3d	b )

cross product

cross() [5/6]

Vector3f mrmeshpy.cross	(	Vector3f	a,
		Vector3f	b )

cross product

cross() [6/6]

Vector3i mrmeshpy.cross	(	Vector3i	a,
		Vector3i	b )

cross product

cutAlongEdgeLoop() [1/2]

std_vector_Id_EdgeTag 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 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 mrmeshpy.cutMesh	(	Mesh	mesh,
		std_vector_OneMeshContour	contours,
		CutMeshParameters	params = '{}' )

\\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 mrmeshpy.deactivateFarPairs	(	IPointPairs	pairs,
		float	maxDistSq )

reset active bit if pair distance is further than maxDistSq

decimateContour() [1/2]

DecimatePolylineResult mrmeshpy.decimateContour	(	std_vector_Vector2_float	contour,
		DecimatePolylineSettings_Vector2f	settings = '{}' )

 \\brief Collapse edges in the contour according to the settings
 \\ingroup DecimateGroup

decimateContour() [2/2]

DecimatePolylineResult mrmeshpy.decimateContour	(	std_vector_Vector3_float	contour,
		DecimatePolylineSettings_Vector3f	settings = '{}' )

decimateMesh()

DecimateResult mrmeshpy.decimateMesh	(	Mesh	mesh,
		DecimateSettings	settings = '{}' )

 \\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 mrmeshpy.decimatePolyline	(	Polyline2	polyline,
		DecimatePolylineSettings_Vector2f	settings = '{}' )

 \\brief Collapse edges in the polyline according to the settings
 \\ingroup DecimateGroup

decimatePolyline() [2/2]

DecimatePolylineResult mrmeshpy.decimatePolyline	(	Polyline3	polyline,
		DecimatePolylineSettings_Vector3f	settings = '{}' )

decode64()

std_vector_unsigned_char mrmeshpy.decode64

(

str

val

)

decodes Base64 format into binary data

decompressZip() [1/2]

None mrmeshpy.decompressZip	(	os.PathLike | str | bytes	zipFile,
		os.PathLike | str | bytes	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 mrmeshpy.decompressZip	(	typing.Any	zipStream,
		os.PathLike | str | bytes	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

defaultSerializeMeshFormat()

str mrmeshpy.defaultSerializeMeshFormat

(

)

returns file extension used to serialize ObjectMeshHolder by default (if not overridden in specific object),
the string starts with '.'

defaultSerializePointsFormat()

str mrmeshpy.defaultSerializePointsFormat

(

)

returns file extension used to serialize ObjectPointsHolder by default (if not overridden in specific object),
the string starts with '.'

defaultSerializeVoxelsFormat()

str mrmeshpy.defaultSerializeVoxelsFormat

(

)

returns file extension used to serialize ObjectVoxels by default (if not overridden in specific object),
the string starts with '.'

deleteTargetFaces() [1/2]

None mrmeshpy.deleteTargetFaces	(	Mesh	obj,
		Mesh	target )

deleteTargetFaces() [2/2]

None mrmeshpy.deleteTargetFaces	(	Mesh	obj,
		Vector3f	targetCenter )

deletes object faces with normals pointed to the target geometry center

delRegionKeepBd()

std_vector_std_vector_Id_EdgeTag 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 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 mrmeshpy.deserializeObjectTree	(	os.PathLike | str | bytes	path,
		func_void_from_std_filesystem_path	postDecompress = '{}',
		func_bool_from_float	progressCb = '{}' )

 \\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 mrmeshpy.deserializeObjectTreeFrom3mf	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

loads scene from 3MF file in a new container object

deserializeObjectTreeFromFolder()

LoadedObjectT mrmeshpy.deserializeObjectTreeFromFolder	(	os.PathLike | str | bytes	folder,
		func_bool_from_float	progressCb = '{}' )

 \\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 mrmeshpy.deserializeObjectTreeFromGltf	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

loads scene from glTF file in a new container object

deserializeObjectTreeFromModel()

LoadedObjectT mrmeshpy.deserializeObjectTreeFromModel	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

loads scene from .model file in a new container object

detectBasisTunnels()

std_vector_std_vector_Id_EdgeTag mrmeshpy.detectBasisTunnels	(	MeshPart	mp,
		func_float_from_Id_EdgeTag	metric = '{}',
		func_bool_from_float	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 mrmeshpy.detectLoneContours

(

std_vector_std_vector_VariableEdgeTri

contours

)

Detects contours that fully lay inside one triangle
returns they indices in contours

detectTunnelFaces()

FaceBitSet mrmeshpy.detectTunnelFaces	(	MeshPart	mp,
		DetectTunnelSettings	settings = '{}' )

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 mrmeshpy.dilateRegion	(	Mesh	mesh,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

expands the region (of faces or vertices) on given value (in meters). returns false if callback also returns false

dilateRegion() [2/4]

bool mrmeshpy.dilateRegion	(	Mesh	mesh,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

dilateRegion() [3/4]

bool mrmeshpy.dilateRegion	(	Mesh	mesh,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

dilateRegion() [4/4]

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

expands the region on given euclidian distance. returns false if callback also returns false

dilateRegionByMetric() [1/3]

bool mrmeshpy.dilateRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

expands the region (of faces or vertices) on given metric value. returns false if callback also returns false

dilateRegionByMetric() [2/3]

bool mrmeshpy.dilateRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

dilateRegionByMetric() [3/3]

bool mrmeshpy.dilateRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

discreteAbsMeanCurvatureMetric()

func_float_from_Id_EdgeTag 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 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 mrmeshpy.distanceMapFromContours	(	DistanceMap	distMap,
		Polyline2	polyline,
		ContourToDistanceMapParams	params,
		ContoursDistanceMapOptions	options = '{}' )

 \\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 mrmeshpy.distanceMapFromContours	(	Polyline2	contours,
		ContourToDistanceMapParams	params,
		ContoursDistanceMapOptions	options = '{}' )

 \\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] 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 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 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 mrmeshpy.distanceMapTo2DIsoPolyline	(	DistanceMap	distMap,
		float	pixelSize,
		float	isoValue )

distanceMapToMesh()

Mesh mrmeshpy.distanceMapToMesh	(	DistanceMap	distMap,
		AffineXf3f	toWorld,
		func_bool_from_float	cb = '{}' )

converts distance map into mesh and applies a transformation to all points

dividePolylineWithPlane()

None mrmeshpy.dividePolylineWithPlane	(	Polyline3	polyline,
		Plane3f	plane,
		DividePolylineParameters	params = '{}' )

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 mrmeshpy.divideWithPlane	(	PointCloud	points,
		Plane3f	plane,
		DividePointCloudOptionalOutput	optOut = '{}' )

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 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 = '{}' )

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 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 mrmeshpy.dot	(	Vector2d	a,
		Vector2d	b )

dot product

dot() [2/6]

float mrmeshpy.dot	(	Vector2f	a,
		Vector2f	b )

dot product

dot() [3/6]

int mrmeshpy.dot	(	Vector2i	a,
		Vector2i	b )

dot product

dot() [4/6]

float mrmeshpy.dot	(	Vector3d	a,
		Vector3d	b )

dot product

dot() [5/6]

float mrmeshpy.dot	(	Vector3f	a,
		Vector3f	b )

dot product

dot() [6/6]

int mrmeshpy.dot	(	Vector3i	a,
		Vector3i	b )

dot product

doTriangleSegmentIntersect()

TriangleSegmentIntersectResult 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 mrmeshpy.doubleOffsetMesh	(	MeshPart	mp,
		float	offsetA,
		float	offsetB,
		OffsetParameters	params = '{}' )

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 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 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 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 mrmeshpy.edgeLengthMetric

(

Mesh

mesh

)

returns edge's length as a metric;
this metric is symmetric: m(e) == m(e.sym())

edgeMapsComposition()

EdgeMap 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 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 mrmeshpy.edgeTableMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric )

edgeTableSymMetric()

func_float_from_Id_EdgeTag 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 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 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 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 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 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 mrmeshpy.encode64	(	int	data,
		int	size )

encodes binary data into textual Base64 format

end() [1/2]

ViewportIterator mrmeshpy.end	(	*	args,
		**	kwargs )

end() [2/2]

RingIterator_NextEdgeSameOrigin mrmeshpy.end

(

IteratorRange_RingIterator_NextEdgeSameOrigin

range

)

equalizeTriAreas()

bool mrmeshpy.equalizeTriAreas	(	Mesh	mesh,
		MeshEqualizeTriAreasParams	params = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.erodeRegion	(	Mesh	mesh,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

shrinks the region (of faces or vertices) on given value (in meters). returns false if callback also returns false

erodeRegion() [2/4]

bool mrmeshpy.erodeRegion	(	Mesh	mesh,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

erodeRegion() [3/4]

bool mrmeshpy.erodeRegion	(	Mesh	mesh,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

erodeRegion() [4/4]

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

shrinks the region on given euclidian distance. returns false if callback also returns false

erodeRegionByMetric() [1/3]

bool mrmeshpy.erodeRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

shrinks the region (of faces or vertices) on given metric value. returns false if callback also returns false

erodeRegionByMetric() [2/3]

bool mrmeshpy.erodeRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

erodeRegionByMetric() [3/3]

bool mrmeshpy.erodeRegionByMetric	(	MeshTopology	topology,
		func_float_from_Id_EdgeTag	metric,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

evalGridMinMax()

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

eval min max value from FloatGrid

executeHoleFillPlan()

None 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 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 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 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 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 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 mrmeshpy.expandPixelMask	(	PixelBitSet	mask,
		RectIndexer	indexer,
		int	expansion = 1 )

expands PixelBitSet with given number of steps

expandVoxelsMask()

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

expands VoxelBitSet with given number of steps

exportToolPathToGCode()

ObjectGcode mrmeshpy.exportToolPathToGCode

(

std_vector_GCommand

commands

)

generates G-Code for milling tool

extendAllHoles()

std_vector_Id_EdgeTag 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 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 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 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 mrmeshpy.extractClosedLoops	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	inEdges,
		EdgeBitSet	outNotLoopEdges = None )

extractIntersectionContours()

std_vector_std_vector_Vector3_float 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 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 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 mrmeshpy.extractLongestClosedLoop	(	Mesh	mesh,
		std_vector_Id_EdgeTag	inEdges )

extractMeshContours()

std_vector_std_vector_Vector3_float mrmeshpy.extractMeshContours

(

std_vector_OneMeshContour

meshContours

)

Converts OneMeshContours contours representation to Contours3f: set of coordinates

extractPlaneSections()

std_vector_std_vector_EdgePoint mrmeshpy.extractPlaneSections	(	MeshPart	mp,
		Plane3f	plane )

extracts all plane sections of given mesh

extractSectionsFromPolyline()

std_vector_EdgeSegment 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 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 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 mrmeshpy.fillContourLeft	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	contour )

fill region located to the left from given edges

fillContourLeft() [2/2]

FaceBitSet mrmeshpy.fillContourLeft	(	MeshTopology	topology,
		std_vector_std_vector_Id_EdgeTag	contours )

fillContourLeftByGraphCut() [1/2]

FaceBitSet 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 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 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 mrmeshpy.fillHole	(	Mesh	mesh,
		Id_EdgeTag	a,
		FillHoleParams	params = '{}' )

\\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 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 mrmeshpy.fillHoles	(	Mesh	mesh,
		std_vector_Id_EdgeTag	as_,
		FillHoleParams	params = '{}' )

fill all holes given by their representative edges in \\param as

fillHoleTrivially()

VertId 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

fillPlanarHole()

None mrmeshpy.fillPlanarHole	(	ObjectMesh	obj,
		std_vector_std_vector_Id_EdgeTag	holeContours )

given an ObjectMesh and the contours of a planar hole in it,
fills the hole using fillContours2D function and updates object's attributes;
if some contours were not closed on input, then closes them by adding a bridge edge in each

filterCreaseEdges()

None 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] 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 mrmeshpy.findAlphaShapeAllTriangles	(	PointCloud	cloud,
		float	radius )

find all triangles of alpha-shape with negative alpha = -1/radius

findAlphaShapeNeiTriangles()

None 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 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 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 mrmeshpy.findCloseVertices	(	Mesh	mesh,
		float	closeDist,
		func_bool_from_float	cb = '{}' )

finds all close vertices, where for each vertex there is another one located within given distance

findCloseVertices() [2/4]

VertBitSet mrmeshpy.findCloseVertices	(	PointCloud	cloud,
		float	closeDist,
		func_bool_from_float	cb = '{}' )

finds all close vertices, where for each vertex there is another one located within given distance

findCloseVertices() [3/4]

VertBitSet mrmeshpy.findCloseVertices	(	VertCoords	points,
		float	closeDist,
		VertBitSet	valid = None,
		func_bool_from_float	cb = '{}' )

finds all close vertices, where for each vertex there is another one located within given distance

findCloseVertices() [4/4]

VertBitSet 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 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 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] 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 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 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 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] 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 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 mrmeshpy.findDegenerateFaces	(	MeshPart	mp,
		float	criticalAspectRatio = 3.4028234663852886e+38,
		func_bool_from_float	cb = '{}' )

finds faces having aspect ratio >= criticalAspectRatio

findDirMax()

VertId 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 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 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 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 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 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 mrmeshpy.findFilter	(	std_vector_IOFilter	filters,
		str	extension )

find a corresponding filter for a given extension

findHalfSpacePoints()

VertBitSet 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 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 mrmeshpy.findInnerShellFacesWithSplits	(	MeshPart	mp,
		Mesh	shell,
		FindInnerShellSettings	settings = '{}' )

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 mrmeshpy.findInnerShellVerts	(	MeshPart	mp,
		Mesh	shell,
		FindInnerShellSettings	settings = '{}' )

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 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 mrmeshpy.findInSphere	(	Mesh	mesh,
		VertId	v,
		InSphereSearchSettings	settings )

findIntersectionContours()

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

returns intersection contours of given meshes

findLeftBoundary()

std_vector_std_vector_Id_EdgeTag 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 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 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 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 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 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 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 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 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 mrmeshpy.findMultipleEdges	(	MeshTopology	topology,
		func_bool_from_float	cb = '{}' )

findNClosestPointsPerPoint()

Buffer_VertId mrmeshpy.findNClosestPointsPerPoint	(	PointCloud	pc,
		int	numNei,
		func_bool_from_float	progress = '{}' )

 \\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 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 mrmeshpy.findNRingVerts	(	MeshTopology	topology,
		int	n,
		VertBitSet	region = None )

finds vertices in region with complete ring of N edges

findOutliers()

VertBitSet mrmeshpy.findOutliers	(	PointCloud	pc,
		FindOutliersParams	params )

Finding outlier points

findOverhangs()

std_vector_TaggedBitSet_FaceTag 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 mrmeshpy.findOverlappingTris	(	MeshPart	mp,
		FindOverlappingSettings	settings )

finds all triangles that have oppositely oriented close triangle in the mesh

findPointsInBall() [1/6]

None mrmeshpy.findPointsInBall	(	AABBTreePoints	tree,
		Ball3f	ball,
		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
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

findPointsInBall() [2/6]

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

findPointsInBall() [3/6]

None mrmeshpy.findPointsInBall	(	Mesh	mesh,
		Ball3f	ball,
		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
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

findPointsInBall() [4/6]

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

findPointsInBall() [5/6]

None mrmeshpy.findPointsInBall	(	PointCloud	pointCloud,
		Ball3f	ball,
		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
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

findPointsInBall() [6/6]

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

findPointsInBox() [1/3]

None mrmeshpy.findPointsInBox	(	AABBTreePoints	tree,
		Box3f	box,
		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 box
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

findPointsInBox() [2/3]

None mrmeshpy.findPointsInBox	(	Mesh	mesh,
		Box3f	box,
		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 box
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

findPointsInBox() [3/3]

None mrmeshpy.findPointsInBox	(	PointCloud	pointCloud,
		Box3f	box,
		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 box
\\ingroup AABBTreeGroup
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

findProjection()

MeshProjectionResult mrmeshpy.findProjection	(	Vector3f	pt,
		MeshPart	mp,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0,
		func_bool_from_Id_FaceTag	validFaces = '{}',
		func_bool_from_MeshProjectionResult	validProjections = '{}' )

 \\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 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 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 mrmeshpy.findProjectionOnPoints	(	Vector3f	pt,
		PointCloud	pc,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0,
		func_bool_from_Id_VertTag	skipCb = '{}' )

 \\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 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 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 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 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 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 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 = '{}',
		func_bool_from_MeshProjectionResult	validProjections = '{}' )

 \\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 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 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 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 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 mrmeshpy.findRepeatedUnorientedTriangles	(	AllLocalTriangulations	triangs,
		int	repetitions )

from local triangulations returns all unoriented triangles with given number of repetitions each in [1,3]

findRepeatedVertsOnHoleBd()

VertBitSet 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 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 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 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 mrmeshpy.findSelfCollidingEdgePairs

(

Polyline2

polyline

)

finds all pairs of colliding edges from 2d polyline

findSelfCollidingEdges()

std_vector_UndirectedEdgeUndirectedEdge mrmeshpy.findSelfCollidingEdges

(

Polyline2

polyline

)

finds all pairs of colliding edges from 2d polyline

findSelfCollidingEdgesBS()

UndirectedEdgeBitSet mrmeshpy.findSelfCollidingEdgesBS

(

Polyline2

polyline

)

finds the union of all self-intersecting edges

findSelfCollidingTriangles() [1/2]

std_vector_FaceFace mrmeshpy.findSelfCollidingTriangles	(	MeshPart	mp,
		func_bool_from_float	cb = '{}',
		Face2RegionMap	regionMap = None )

finds all pairs of colliding triangles from one mesh or a region

findSelfCollidingTriangles() [2/2]

bool mrmeshpy.findSelfCollidingTriangles	(	MeshPart	mp,
		std_vector_FaceFace	outCollidingPairs,
		func_bool_from_float	cb = '{}',
		Face2RegionMap	regionMap = None )

finds all pairs (or the fact of any self-collision) of colliding triangles from one mesh or a region

findSelfCollidingTrianglesBS()

FaceBitSet mrmeshpy.findSelfCollidingTrianglesBS	(	MeshPart	mp,
		func_bool_from_float	cb = '{}',
		Face2RegionMap	regionMap = None )

the same \\ref findSelfCollidingTriangles but returns the union of all self-intersecting faces

findShortEdges()

UndirectedEdgeBitSet mrmeshpy.findShortEdges	(	MeshPart	mp,
		float	criticalLength,
		func_bool_from_float	cb = '{}' )

finds edges having length <= criticalLength

findSignedDistance() [1/2]

MeshMeshSignedDistanceResult 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 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

findSignedDistances() [1/2]

VertScalars mrmeshpy.findSignedDistances	(	Mesh	refMesh,
		Mesh	mesh,
		MeshProjectionParameters	params = '{}',
		IPointsToMeshProjector	projector = '{}' )

Computes signed distances from valid vertices of test mesh to the closest point on the reference mesh:
positive value - outside reference mesh, negative - inside reference mesh;
this method can return wrong sign if the closest point is located on self-intersecting part of the mesh

findSignedDistances() [2/2]

VertScalars mrmeshpy.findSignedDistances	(	Mesh	refMesh,
		VertCoords	testPoints,
		VertBitSet	validTestPoints = '{}',
		MeshProjectionParameters	params = '{}',
		IPointsToMeshProjector	projector = '{}' )

Computes signed distances from given test points to the closest point on the reference mesh:
positive value - outside reference mesh, negative - inside reference mesh;
this method can return wrong sign if the closest point is located on self-intersecting part of the mesh

findSkyRays()

BitSet 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 mrmeshpy.findSmallestCloseVertices	(	Mesh	mesh,
		float	closeDist,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.findSmallestCloseVertices	(	PointCloud	cloud,
		float	closeDist,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.findSmallestCloseVertices	(	VertCoords	points,
		float	closeDist,
		VertBitSet	valid = None,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.findSmallestCloseVerticesUsingTree	(	VertCoords	points,
		float	closeDist,
		AABBTreePoints	tree,
		VertBitSet	valid,
		func_bool_from_float	cb = '{}' )

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 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 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 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 mrmeshpy.findSubstringCaseInsensitive	(	str	string,
		str	substring )

 Finds the substring in the string.
 \\return position, npos if not found
 \\ingroup BasicGroup

findTriangleSectionsByXYPlane()

std_vector_LineSegm_Vector3_float mrmeshpy.findTriangleSectionsByXYPlane	(	MeshPart	mp,
		float	zLevel,
		std_vector_Id_FaceTag	faces = None,
		UseAABBTree	u = 'UseAABBTree::Yes' )

finds all intersected triangles by the plane z=zLevel
\\return the section's line segment within each such triangle;
\\param faces optional output of the same size as return, where for each line segment one can find its triangle's id
\\details this function must be faster than
extractXYPlaneSections function when connecting continuous contours take most of the time

findTriangleSegmentIntersectionPrecise()

Vector3f 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 mrmeshpy.findTrisInBall	(	MeshPart	mp,
		Ball3f	ball,
		func_Processing_from_MeshProjectionResult_Ball_Vector3_float	foundCallback,
		func_bool_from_Id_FaceTag	validFaces = '{}' )

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 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 mrmeshpy.findTwinEdges	(	Mesh	mesh,
		float	closeDist )

finds all directed twin edges

findTwinEdges() [2/2]

EdgeBitSet mrmeshpy.findTwinEdges

(

std_vector_std_pair_Id_EdgeTag_Id_EdgeTag

pairs

)

findTwinUndirectedEdgeHashMap() [1/2]

phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag 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 mrmeshpy.findTwinUndirectedEdgeHashMap

(

std_vector_std_pair_Id_EdgeTag_Id_EdgeTag

pairs

)

findTwinUndirectedEdges() [1/2]

UndirectedEdgeBitSet mrmeshpy.findTwinUndirectedEdges	(	Mesh	mesh,
		float	closeDist )

finds all undirected twin edges

findTwinUndirectedEdges() [2/2]

UndirectedEdgeBitSet mrmeshpy.findTwinUndirectedEdges

(

std_vector_std_pair_Id_EdgeTag_Id_EdgeTag

pairs

)

findTwoClosestPoints()

tuple[VertId, VertId] mrmeshpy.findTwoClosestPoints	(	PointCloud	pc,
		func_bool_from_float	progress = '{}' )

finds two closest points (first id < second id) in whole point cloud

findUndercuts() [1/3]

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

Adds to \\param outUndercuts undercut faces

findUndercuts() [2/3]

float 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 mrmeshpy.findUndercuts	(	Mesh	mesh,
		Vector3f	upDirection,
		VertBitSet	outUndercuts )

Adds to \\param outUndercuts undercut vertices

fixMultipleEdges() [1/2]

None mrmeshpy.fixMultipleEdges

(

Mesh

mesh

)

finds and resolves multiple edges

fixMultipleEdges() [2/2]

None 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 mrmeshpy.fixSelfIntersections	(	Mesh	mesh,
		float	voxelSize )

Fix self-intersections by converting to voxels and back.

fixUndercuts() [1/2]

None 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 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 mrmeshpy.floatGridToVdbVolume

(

OpenVdbFloatGrid

grid

)

fills VdbVolume data from FloatGrid (does not fill voxels size, cause we expect it outside)

formatNoTrailingZeros()

str 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 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 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 mrmeshpy.fromSceneMison	(	os.PathLike | str | bytes	path,
		func_bool_from_float	callback = '{}' )

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 mrmeshpy.fromSceneMison	(	typing.Any	in_,
		func_bool_from_float	callback = '{}' )

functionVolumeToSimpleVolume()

SimpleVolumeMinMax mrmeshpy.functionVolumeToSimpleVolume	(	FunctionVolume	volume,
		func_bool_from_float	callback = '{}' )

converts function volume into simple volume

functionVolumeToVdbVolume()

VdbVolume mrmeshpy.functionVolumeToVdbVolume	(	FunctionVolume	functoinVolume,
		func_bool_from_float	cb = '{}' )

make VdbVolume from FunctionVolume
make copy of data
set minimum value as the background value

generalOffsetMesh()

Mesh 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 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 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] mrmeshpy.getAllComponents	(	MeshPart	meshPart,
		int	maxComponentCount,
		MeshComponents.FaceIncidence	incidence = 'FaceIncidence::PerEdge',
		func_bool_from_Id_UndirectedEdgeTag	isCompBd = '{}' )

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 mrmeshpy.getAllComponents	(	MeshPart	meshPart,
		MeshComponents.FaceIncidence	incidence = 'FaceIncidence::PerEdge',
		func_bool_from_Id_UndirectedEdgeTag	isCompBd = '{}' )

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 mrmeshpy.getAllComponentsVerts	(	Mesh	mesh,
		VertBitSet	region = None )

gets all connected components of mesh part

getAllFilters()

std_vector_IOFilter mrmeshpy.getAllFilters

(

)

returns filters for all supported file formats for all types of objects

getAllObjectsInTree_Object()

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

getAllObjectsInTree_ObjectDistanceMap()

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

getAllObjectsInTree_ObjectLines()

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

getAllObjectsInTree_ObjectLinesHolder()

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

getAllObjectsInTree_ObjectMesh()

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

getAllObjectsInTree_ObjectMeshHolder()

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

getAllObjectsInTree_ObjectPoints()

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

getAllObjectsInTree_ObjectPointsHolder()

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

getAllObjectsInTree_ObjectVoxels()

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

getAllObjectsInTree_VisualObject()

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

getAt()

UndirectedEdgeId mrmeshpy.getAt	(	Buffer_UndirectedEdgeId_UndirectedEdgeId	bmap,
		UndirectedEdgeId	key,
		UndirectedEdgeId	def_ = '{}' )

given some buffer map and a key, returns the value associated with the key, or default value if key is invalid

getBooleanPoints()

BooleanResultPoints 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 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 mrmeshpy.getBoundaryVerts	(	MeshTopology	topology,
		FaceBitSet	region = None )

composes the set of all boundary vertices for given region (or whole mesh if !region)

getCancelMessage()

str mrmeshpy.getCancelMessage

(

os.PathLike | str | bytes

path

)

Returns message showed when loading is canceled

getCircumscribedMetric()

FillHoleMetric 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 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 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 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 mrmeshpy.GetCpuId

(

)

returns string identification of the CPU

getCrossedFaces()

FaceBitSet mrmeshpy.getCrossedFaces	(	MeshTopology	topology,
		std_vector_EdgePoint	isoline )

for a consistently oriented isoline, returns all faces it goes inside

getCurrentStacktrace()

str mrmeshpy.getCurrentStacktrace

(

)

returns string representation of the current stacktrace

getCurrentStacktraceInline()

str 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 mrmeshpy.getDepthFirstObject_Object	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_ObjectDistanceMap()

ObjectDistanceMap mrmeshpy.getDepthFirstObject_ObjectDistanceMap	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_ObjectLines()

ObjectLines mrmeshpy.getDepthFirstObject_ObjectLines	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_ObjectLinesHolder()

ObjectLinesHolder mrmeshpy.getDepthFirstObject_ObjectLinesHolder	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_ObjectMesh()

ObjectMesh mrmeshpy.getDepthFirstObject_ObjectMesh	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_ObjectMeshHolder()

ObjectMeshHolder mrmeshpy.getDepthFirstObject_ObjectMeshHolder	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_ObjectPoints()

ObjectPoints mrmeshpy.getDepthFirstObject_ObjectPoints	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_ObjectPointsHolder()

ObjectPointsHolder mrmeshpy.getDepthFirstObject_ObjectPointsHolder	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_ObjectVoxels()

ObjectVoxels mrmeshpy.getDepthFirstObject_ObjectVoxels	(	Object	root,
		ObjectSelectivityType	type )

getDepthFirstObject_VisualObject()

VisualObject mrmeshpy.getDepthFirstObject_VisualObject	(	Object	root,
		ObjectSelectivityType	type )

GetDetailedOSName()

str mrmeshpy.GetDetailedOSName

(

)

returns string with OS name with details

getEdgeLengthFillMetric()

FillHoleMetric mrmeshpy.getEdgeLengthFillMetric

(

Mesh

mesh

)

Simple metric minimizing the sum of all edge lengths

getEdgeLengthStitchMetric()

FillHoleMetric mrmeshpy.getEdgeLengthStitchMetric

(

Mesh

mesh

)

Forbids connecting vertices from the same hole \\n
Simple metric minimizing edge length

getEdgeOrdering()

UndirectedEdgeBMap 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()

pathlib.Path mrmeshpy.GetEmbeddedPythonDirectory

(

)

returns path of embedded python modules files directory
.dll .so files

GetExeDirectory()

pathlib.Path mrmeshpy.GetExeDirectory

(

)

returns path of current exe directory

getFacesByMinEdgeLength()

FaceBitSet mrmeshpy.getFacesByMinEdgeLength	(	Mesh	mesh,
		float	minLength )

Return faces with at least one edge longer than the specified length.

getFeatureDirection()

Vector3f mrmeshpy.getFeatureDirection

(

FeatureObject

feature

)

Using forEachObjectKind the template collects a list of features for which the method ...->getDirection() is available

getFeatureNormal()

Vector3f 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 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 mrmeshpy.getFeaturesTypeWithNormals

(

)

Try to getNormal from specific feature using forEachObjectKind template. Returns nullopt is ...->getNormal() is not available for given feature type.

GetFontsDirectory()

pathlib.Path mrmeshpy.GetFontsDirectory

(

)

returns path of font files directory
.ttf files

getHoleFillPlan()

HoleFillPlan mrmeshpy.getHoleFillPlan	(	Mesh	mesh,
		Id_EdgeTag	e,
		FillHoleParams	params = '{}' )

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()

pathlib.Path mrmeshpy.GetHomeDirectory

(

)

returns home directory

getICPStatusInfo()

str mrmeshpy.getICPStatusInfo	(	int	iterations,
		ICPExitType	exitType )

returns status info string

getIncidentEdges() [1/2]

UndirectedEdgeBitSet 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 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 mrmeshpy.getIncidentFaces	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all faces incident to given edges

getIncidentFaces() [2/2]

FaceBitSet mrmeshpy.getIncidentFaces	(	MeshTopology	topology,
		VertBitSet	verts )

composes the set of all faces incident to given vertices

getIncidentVerts() [1/4]

VertBitSet mrmeshpy.getIncidentVerts	(	MeshTopology	topology,
		FaceBitSet	faces )

composes the set of all vertices incident to given faces

getIncidentVerts() [2/4]

VertBitSet 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 mrmeshpy.getIncidentVerts	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all vertices incident to given edges

getIncidentVerts() [4/4]

VertBitSet 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 mrmeshpy.getInnerEdges	(	MeshTopology	topology,
		FaceBitSet	region )

composes the set of all edges having both left and right in given region

getInnerEdges() [2/2]

UndirectedEdgeBitSet mrmeshpy.getInnerEdges	(	MeshTopology	topology,
		VertBitSet	verts )

composes the set of all edges with all their vertices in given set

getInnerFaces()

FaceBitSet mrmeshpy.getInnerFaces	(	MeshTopology	topology,
		VertBitSet	verts )

composes the set of all faces with all their vertices in given set

getInnerVerts() [1/2]

VertBitSet 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 mrmeshpy.getInnerVerts	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all vertices with all their edges in given set

GetLibsDirectory()

pathlib.Path mrmeshpy.GetLibsDirectory

(

)

returns path of lib files directory
.dll .so files

getMaxDihedralAngleMetric()

FillHoleMetric mrmeshpy.getMaxDihedralAngleMetric

(

Mesh

mesh

)

This metric minimizes the maximal dihedral angle between the faces in the triangulation
and on its boundary

getMeanSqDistToPlane()

float mrmeshpy.getMeanSqDistToPlane

(

IPointPairs

pairs

)

computes root-mean-square deviation from points to target planes

getMeanSqDistToPoint()

float mrmeshpy.getMeanSqDistToPoint

(

IPointPairs

pairs

)

computes root-mean-square deviation between points

getMeshOrPoints()

MeshOrPoints mrmeshpy.getMeshOrPoints

(

VisualObject

obj

)

constructs MeshOrPoints from ObjectMesh or ObjectPoints, otherwise returns nullopt

getMinAreaMetric()

FillHoleMetric 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 mrmeshpy.getMinTriAngleMetric

(

Mesh

mesh

)

This metric maximizes the minimal angle among all faces in the triangulation

GetMRVersionString()

str mrmeshpy.GetMRVersionString

(

)

returns version of MR

getNeighborFaces()

FaceBitSet mrmeshpy.getNeighborFaces	(	MeshTopology	topology,
		UndirectedEdgeBitSet	edges )

composes the set of all left and right faces of given edges

getNumActivePairs()

int mrmeshpy.getNumActivePairs

(

IPointPairs

pairs

)

computes the number of active pairs

getNumNodes()

int mrmeshpy.getNumNodes

(

int

numLeaves

)

returns the number of nodes in the binary tree with given number of leaves

getNumSamples()

int mrmeshpy.getNumSamples

(

IPointPairs

pairs

)

returns the number of samples able to form pairs

getOneMeshIntersectionContours()

std_vector_OneMeshContour 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 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 mrmeshpy.getOSNoSpaces

(

)

returns string identification of the OS

getParallelPlaneFillMetric()

FillHoleMetric 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 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 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 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 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 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.

getProccessMemoryInfo()

ProccessMemoryInfo mrmeshpy.getProccessMemoryInfo

(

)

getRegionBoundaryVerts()

VertBitSet 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 mrmeshpy.getRegionEdges	(	MeshTopology	topology,
		FaceBitSet	faces )

composes the set of all edges, having a face from given set at the left

GetResourcesDirectory()

pathlib.Path mrmeshpy.GetResourcesDirectory

(

)

returns path of resource files directory
.json and .png files

getStreamSize()

int mrmeshpy.getStreamSize

(

typing.Any

in_

)

get the size of the remaining data in the input stream

getSubdividePart()

FaceBitSet 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 mrmeshpy.getSumSqDistToPlane	(	IPointPairs	pairs,
		std_optional_double	inaccuracy = '{}' )

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 mrmeshpy.getSumSqDistToPoint	(	IPointPairs	pairs,
		std_optional_double	inaccuracy = '{}' )

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 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 mrmeshpy.getSystemMemory

(

)

return information about memory available in the system

GetTempDirectory()

pathlib.Path mrmeshpy.GetTempDirectory

(

)

returns temp directory

getToFloatConverter()

func_Vector3_float_from_Vector3_int 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 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 mrmeshpy.getTopmostVisibleObjects_Object	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable' )

getTopmostVisibleObjects_ObjectDistanceMap()

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

getTopmostVisibleObjects_ObjectLines()

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

getTopmostVisibleObjects_ObjectLinesHolder()

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

getTopmostVisibleObjects_ObjectMesh()

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

getTopmostVisibleObjects_ObjectMeshHolder()

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

getTopmostVisibleObjects_ObjectPoints()

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

getTopmostVisibleObjects_ObjectPointsHolder()

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

getTopmostVisibleObjects_ObjectVoxels()

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

getTopmostVisibleObjects_VisualObject()

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

getTypeConverter()

func_float_from_char_const 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 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()

pathlib.Path mrmeshpy.getUserConfigDir

(

)

return path to the folder with user config file(s)

getUserConfigFilePath()

pathlib.Path mrmeshpy.getUserConfigFilePath

(

)

returns path of config file in APPDATA

getValue()

float mrmeshpy.getValue	(	OpenVdbFloatGrid	grid,
		Vector3i	p )

returns the value at given voxel

getVectorConverters()

CoordinateConverters 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 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 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 mrmeshpy.getVertexOrdering	(	MeshTopology	topology,
		VertBitSet	region )

returns all vertices from given region ordered in each connected component in breadth-first way

getVerticalStitchMetric()

FillHoleMetric mrmeshpy.getVerticalStitchMetric	(	Mesh	mesh,
		Vector3f	upDir )

Forbids connecting vertices from the same hole \\n
All new faces should be parallel to given direction

GetWindowsInstallDirectory()

pathlib.Path mrmeshpy.GetWindowsInstallDirectory

(

)

returns the folder where Windows installed, typically "C:\\Windows"

getXfFromOxyPlane() [1/2]

AffineXf3f mrmeshpy.getXfFromOxyPlane	(	Mesh	mesh,
		std_vector_std_vector_Id_EdgeTag	paths )

getXfFromOxyPlane() [2/2]

AffineXf3f 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 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 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 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 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 mrmeshpy.hasAnyPlaneSection	(	MeshPart	mp,
		Plane3f	plane )

quickly returns true if extractPlaneSections produce not-empty set for the same arguments

hasAnyXYPlaneSection()

bool mrmeshpy.hasAnyXYPlaneSection	(	MeshPart	mp,
		float	zLevel )

quickly returns true if extractXYPlaneSections produce not-empty set for the same arguments

hasMultipleEdges()

bool mrmeshpy.hasMultipleEdges

(

MeshTopology

topology

)

hasProhibitedChars()

bool mrmeshpy.hasProhibitedChars

(

str

line

)

returns true if line contains any of OS prohibited chars ('?', '*', '/', '\\', '"', '<', '>')

heapBytes()

int mrmeshpy.heapBytes

(

OpenVdbFloatGrid

grid

)

returns the amount of heap memory occupied by grid

heapBytes_Color()

int mrmeshpy.heapBytes_Color

(

std_vector_Color

vec

)

returns the amount of memory given vector occupies on heap

heapBytes_float()

int mrmeshpy.heapBytes_float

(

std_vector_float

vec

)

returns the amount of memory given vector occupies on heap

heapBytes_Mesh()

int 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 mrmeshpy.heapBytes_MeshTexture_TextureId

(

Vector_MeshTexture_TextureId

vec

)

heapBytes_Object()

int mrmeshpy.heapBytes_Object

(

Object

ptr

)

returns the amount of memory this smart pointer and its pointed object own together on heap

heapBytes_OpenVdbFloatGrid()

int mrmeshpy.heapBytes_OpenVdbFloatGrid

(

OpenVdbFloatGrid

ptr

)

returns the amount of memory this smart pointer and its pointed object own together on heap

heapBytes_PointCloud()

int mrmeshpy.heapBytes_PointCloud

(

PointCloud

ptr

)

returns the amount of memory this smart pointer and its pointed object own together on heap

heapBytes_Polyline3()

int 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 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_long()

int mrmeshpy.heapBytes_unsigned_long_long

(

std_vector_unsigned_long_long

vec

)

returns the amount of memory given vector occupies on heap

identityMetric()

func_float_from_Id_EdgeTag mrmeshpy.identityMetric

(

)

metric returning 1 for every edge

improveSampling()

bool 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 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 mrmeshpy.interpolateArcs	(	std_vector_GCommand	commands,
		ArcInterpolationParams	params,
		Axis	axis )

interpolates given path with arcs

interpolateLines()

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

interpolates several points lying on the same straight line with one move

intersection()

Vector2f 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 mrmeshpy.isClosed

(

std_vector_Vector3_float

c

)

isConsistentlyOriented()

bool mrmeshpy.isConsistentlyOriented	(	MeshTopology	topology,
		std_vector_EdgePoint	isoline )

returns true if left(isoline[i].e) == right(isoline[i+1].e) and valid for all i;
all above functions produce consistently oriented lines

isDegree3Dest()

bool mrmeshpy.isDegree3Dest	(	MeshTopology	topology,
		Id_EdgeTag	e )

returns true if the destination of given edge has degree 3 and 3 incident triangles

isEdgeBetweenDoubleTris()

bool 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 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 mrmeshpy.isEdgePath	(	MeshTopology	topology,
		std_vector_Id_EdgeTag	edges )

returns true if every next edge starts where previous edge ends

isHoleBd()

bool 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 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 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 mrmeshpy.isNanFast

(

float

f

)

quickly tests whether given float is not-a-number

isNonIntersectingInside() [1/2]

bool 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 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 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 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 mrmeshpy.isSupportedFileInSubfolders

(

os.PathLike | str | bytes

folder

)

check if there are any supported files folder and subfolders

isTIFFFile()

bool mrmeshpy.isTIFFFile

(

os.PathLike | str | bytes

path

)

returns true if given file is tiff

isVertexRepeatedOnHoleBd()

Id_EdgeTag 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 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 mrmeshpy.leftRing	(	MeshTopology	topology,
		FaceId	f )

leftRing() [2/2]

IteratorRange_RingIterator_NextEdgeSameLeft 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 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 mrmeshpy.loadASCIIStl	(	os.PathLike | str | bytes	file,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in textual .STL format

loadASCIIStl() [2/2]

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

loads mesh from stream in textual .STL format

loadBinaryStl() [1/2]

Mesh mrmeshpy.loadBinaryStl	(	os.PathLike | str | bytes	file,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in binary .STL format

loadBinaryStl() [2/2]

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

loads mesh from stream in binary .STL format;
important on Windows: in stream must be open in binary mode

loadDistanceMapFromImage()

DistanceMap mrmeshpy.loadDistanceMapFromImage	(	os.PathLike | str | bytes	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 mrmeshpy.loadDxf	(	os.PathLike | str | bytes	path,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in .DXF format;

loadDxf() [2/2]

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

loads mesh from stream in .DXF format;

loadIOExtras()

None mrmeshpy.loadIOExtras

(

)

loadLines() [1/2]

Polyline3 mrmeshpy.loadLines	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

detects the format from file extension and loads polyline from it

loadLines() [2/2]

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

extension in `*.ext` format

loadMesh() [1/2]

Mesh mrmeshpy.loadMesh	(	os.PathLike | str | bytes	file,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in the format detected from file extension

loadMesh() [2/2]

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

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 mrmeshpy.loadMeshDll

(

)

loadMrmesh() [1/2]

Mesh mrmeshpy.loadMrmesh	(	os.PathLike | str | bytes	file,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in internal MeshLib format

loadMrmesh() [2/2]

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

loads mesh from stream in internal MeshLib format;
important on Windows: in stream must be open in binary mode

loadObj() [1/2]

Mesh mrmeshpy.loadObj	(	os.PathLike | str | bytes	file,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in .OBJ format

loadObj() [2/2]

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

loads mesh from stream in .OBJ format;
important on Windows: in stream must be open in binary mode

loadObjectFromFile()

LoadedObjects mrmeshpy.loadObjectFromFile	(	os.PathLike | str | bytes	filename,
		func_bool_from_float	callback = '{}' )

 \\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 mrmeshpy.loadOff	(	os.PathLike | str | bytes	file,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in .OFF format

loadOff() [2/2]

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

loads mesh from stream in .OFF format

loadPly() [1/2]

Mesh mrmeshpy.loadPly	(	os.PathLike | str | bytes	file,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in .PLY format;

loadPly() [2/2]

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

loads mesh from stream in .PLY format;
important on Windows: in stream must be open in binary mode

loadPoints() [1/2]

PointCloud mrmeshpy.loadPoints	(	os.PathLike | str | bytes	file,
		PointsLoadSettings	settings = '{}' )

detects the format from file extension and loads points from it

loadPoints() [2/2]

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

extension in `*.ext` format

loadSceneFromAnySupportedFormat()

LoadedObjectT mrmeshpy.loadSceneFromAnySupportedFormat	(	os.PathLike | str | bytes	path,
		func_bool_from_float	callback = '{}' )

tries to load scene from every format listed in SceneFormatFilters

loadSceneObject()

Object mrmeshpy.loadSceneObject	(	os.PathLike | str | bytes	path,
		func_bool_from_float	callback = '{}' )

Detects the format from file extension and loads scene object from it.

loadStl() [1/2]

Mesh mrmeshpy.loadStl	(	os.PathLike | str | bytes	file,
		MeshLoadSettings	settings = '{}' )

loads mesh from file in any .STL format: both binary and ASCII

loadStl() [2/2]

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

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 mrmeshpy.loadVoxels	(	os.PathLike | str | bytes	file,
		func_bool_from_float	cb = '{}' )

Detects the format from file extension and loads voxels from it

loadVoxelsGav() [1/2]

VdbVolume mrmeshpy.loadVoxelsGav	(	os.PathLike | str | bytes	file,
		func_bool_from_float	cb = '{}' )

Load voxel from Gav-file with micro CT reconstruction

loadVoxelsGav() [2/2]

VdbVolume mrmeshpy.loadVoxelsGav	(	typing.Any	in_,
		func_bool_from_float	cb = '{}' )

Load voxel from Gav-stream with micro CT reconstruction

loadVoxelsRaw() [1/3]

VdbVolume mrmeshpy.loadVoxelsRaw	(	os.PathLike | str | bytes	file,
		func_bool_from_float	cb = '{}' )

Load raw voxels file, parsing parameters from name 

loadVoxelsRaw() [2/3]

VdbVolume mrmeshpy.loadVoxelsRaw	(	os.PathLike | str | bytes	file,
		VoxelsLoad.RawParameters	params,
		func_bool_from_float	cb = '{}' )

Load raw voxels from file with provided parameters

loadVoxelsRaw() [3/3]

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

Load raw voxels from stream with provided parameters;
important on Windows: in stream must be open in binary mode

localFindSelfIntersections()

FaceBitSet mrmeshpy.localFindSelfIntersections	(	Mesh	mesh,
		func_bool_from_float	cb = '{}' )

Find all self-intersections faces component-wise

localFixSelfIntersections()

None mrmeshpy.localFixSelfIntersections	(	Mesh	mesh,
		SelfIntersections.Settings	settings )

Finds and fixes self-intersections per component:

makeArrow()

Mesh 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 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()

MakeBridgeResult 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 MakeBridgeResult evaluating to false if bridge cannot be created because otherwise multiple edges appear

makeBridgeEdge()

Id_EdgeTag 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 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 mrmeshpy.makeConvexHull

(

Mesh

in_

)

makeConvexHull() [2/3]

Mesh mrmeshpy.makeConvexHull

(

PointCloud

in_

)

makeConvexHull() [3/3]

Mesh mrmeshpy.makeConvexHull	(	VertCoords	points,
		VertBitSet	validPoints )

computes the mesh of convex hull from given input points

makeCube()

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

Base is "lower" corner of the cube coordinates

makeCylinder()

Mesh 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 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 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 mrmeshpy.makeDegenerateBandAroundRegion	(	Mesh	mesh,
		FaceBitSet	region,
		MakeDegenerateBandAroundRegionParams	params = '{}' )

 \\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 mrmeshpy.makeDeloneEdgeFlips	(	Mesh	mesh,
		DeloneSettings	settings = '{}',
		int	numIters = 1,
		func_bool_from_float	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 mrmeshpy.makeDeloneOriginRing	(	Mesh	mesh,
		Id_EdgeTag	e,
		DeloneSettings	settings = '{}' )

improves mesh triangulation in a ring of vertices with common origin and represented by edge e

makeFreeFormOriginGrid()

std_vector_Vector3_float mrmeshpy.makeFreeFormOriginGrid	(	Box3f	box,
		Vector3i	resolution )

Returns positions of grid points in given box with given resolution 

makeLevelOfDetails()

Object 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 mrmeshpy.makeMovementBuildBody	(	std_vector_std_vector_Vector3_float	body,
		std_vector_std_vector_Vector3_float	trajectory,
		MovementBuildBodyParams	params = '{}' )

makes mesh by moving `body` along `trajectory`
if allowRotation rotate it in corners

makeNormals()

VertCoords 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 mrmeshpy.makeObjectDistanceMapFromFile	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

loads distance map from given file in new object

makeObjectFromMeshFile()

LoadedObjectT mrmeshpy.makeObjectFromMeshFile	(	os.PathLike | str | bytes	file,
		func_bool_from_float	cb = '{}',
		bool	returnOnlyMesh = False )

loads data from given file and makes either ObjectMesh or ObjectPoints (if the file has points but not faces)

makeObjectFromVoxelsFile()

LoadedObjects mrmeshpy.makeObjectFromVoxelsFile	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

makeObjectGcodeFromFile()

ObjectGcode mrmeshpy.makeObjectGcodeFromFile	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

loads gcode from given file in new object

makeObjectLinesFromFile()

ObjectLines mrmeshpy.makeObjectLinesFromFile	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

loads lines from given file in new object

makeObjectMeshFromFile()

LoadedObjectT_ObjectMesh mrmeshpy.makeObjectMeshFromFile	(	os.PathLike | str | bytes	file,
		func_bool_from_float	cb = '{}' )

loads mesh from given file in new object

makeObjectPointsFromFile()

ObjectPoints mrmeshpy.makeObjectPointsFromFile	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

loads points from given file in new object

makeObjectVoxelsFromFile()

std_vector_std_shared_ptr_ObjectVoxels mrmeshpy.makeObjectVoxelsFromFile	(	os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

loads voxels from given file in new object

makeOpenCone()

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

A hollow cone.

makeOpenCylinder()

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

A hollow cylinder.

makeOrientedNormals() [1/2]

VertCoords mrmeshpy.makeOrientedNormals	(	PointCloud	pointCloud,
		AllLocalTriangulations	triangs,
		func_bool_from_float	progress = '{}' )

\\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 mrmeshpy.makeOrientedNormals	(	PointCloud	pointCloud,
		float	radius,
		func_bool_from_float	progress = '{}' )

\\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 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 mrmeshpy.makeParallelepiped	(	Vector3f	side,
		Vector3f	base )

makePlane()

Mesh mrmeshpy.makePlane

(

)

Makes square plane 1x1 size with center at (0,0,0) and (0,0,1) normal

makePrism()

Mesh 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

makeQuadBridge()

MakeBridgeResult mrmeshpy.makeQuadBridge	(	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 one quadrangle in general (beware that it cannot be rendered) 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

makeRegularGridMesh() [1/2]

Mesh mrmeshpy.makeRegularGridMesh	(	int	width,
		int	height,
		func_bool_from_unsigned_long_long_unsigned_long_long	validator,
		func_Vector3_float_from_unsigned_long_long_unsigned_long_long	positioner,
		func_bool_from_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_long_unsigned_long_long	faceValidator = '{}',
		func_bool_from_float	cb = '{}' )

Creates regular mesh with points in valid grid lattice

makeRegularGridMesh() [2/2]

Mesh mrmeshpy.makeRegularGridMesh	(	VertCoords	pc,
		func_bool_from_float	cb = '{}' )

Creates regular mesh from monotone (connects point with closed x, y neighbors) points

makeRigidXf() [1/2]

AffineXf3d 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 mrmeshpy.makeRigidXf	(	MeshPart	mp,
		AffineXf3f	meshXf )

makeSignedByWindingNumber()

None 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

makeSmoothBridge()

MakeBridgeResult mrmeshpy.makeSmoothBridge	(	Mesh	mesh,
		Id_EdgeTag	a,
		Id_EdgeTag	b,
		float	samplingStep,
		FaceBitSet	outNewFaces = None )

creates a bridge between two boundary edges a and b (both having no valid left face);
bridge consists of strip of quadrangles (each consisting of two triangles) in general or of some triangles if a and b are neighboring edges on the boundary;
the bridge is made as smooth as possible with small angles in between its links and on the boundary with existed triangles;
\\param samplingStep boundaries of the bridge will be subdivided until the distance between neighbor points becomes less than this distance
\\return MakeBridgeResult evaluating to false if bridge cannot be created because otherwise multiple edges appear

makeSphere()

Mesh mrmeshpy.makeSphere

(

SphereParams

params

)

creates a mesh of sphere with irregular triangulation

makeSpline() [1/2]

MarkedContour3f 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 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 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 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 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 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 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 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 mrmeshpy.makeUnorientedNormals	(	PointCloud	pointCloud,
		AllLocalTriangulations	triangs,
		func_bool_from_float	progress = '{}',
		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 mrmeshpy.makeUnorientedNormals	(	PointCloud	pointCloud,
		Buffer_VertId	closeVerts,
		int	numNei,
		func_bool_from_float	progress = '{}',
		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 mrmeshpy.makeUnorientedNormals	(	PointCloud	pointCloud,
		float	radius,
		func_bool_from_float	progress = '{}',
		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 mrmeshpy.makeUVSphere	(	float	radius = 1.0,
		int	horisontalResolution = 16,
		int	verticalResolution = 16 )

creates a mesh of sphere with regular triangulation (parallels and meridians)

mapEdge() [1/3]

Id_EdgeTag 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 mrmeshpy.mapEdge	(	UndirectedEdgeBMap	map,
		UndirectedEdgeId	src )

given input edge (src), converts its id using given map

mapEdge() [3/3]

Id_EdgeTag mrmeshpy.mapEdge	(	WholeEdgeMap	map,
		Id_EdgeTag	src )

given input edge (src), converts its id using given map

mapEdges() [1/3]

UndirectedEdgeBitSet 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 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 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 mrmeshpy.marchingCubes	(	FunctionVolume	volume,
		MarchingCubesParams	params = '{}' )

makes Mesh from FunctionVolume with given settings using Marching Cubes algorithm

marchingCubes() [2/4]

Mesh mrmeshpy.marchingCubes	(	SimpleVolume	volume,
		MarchingCubesParams	params = '{}' )

makes Mesh from SimpleVolume with given settings using Marching Cubes algorithm

marchingCubes() [3/4]

Mesh mrmeshpy.marchingCubes	(	SimpleVolumeMinMax	volume,
		MarchingCubesParams	params = '{}' )

makes Mesh from SimpleVolumeMinMax with given settings using Marching Cubes algorithm

marchingCubes() [4/4]

Mesh mrmeshpy.marchingCubes	(	VdbVolume	volume,
		MarchingCubesParams	params = '{}' )

makes Mesh from VdbVolume with given settings using Marching Cubes algorithm

marchingCubesAsTriMesh() [1/4]

TriMesh mrmeshpy.marchingCubesAsTriMesh	(	FunctionVolume	volume,
		MarchingCubesParams	params = '{}' )

marchingCubesAsTriMesh() [2/4]

TriMesh mrmeshpy.marchingCubesAsTriMesh	(	SimpleVolume	volume,
		MarchingCubesParams	params = '{}' )

marchingCubesAsTriMesh() [3/4]

TriMesh mrmeshpy.marchingCubesAsTriMesh	(	SimpleVolumeMinMax	volume,
		MarchingCubesParams	params = '{}' )

marchingCubesAsTriMesh() [4/4]

TriMesh mrmeshpy.marchingCubesAsTriMesh	(	VdbVolume	volume,
		MarchingCubesParams	params = '{}' )

markedContour()

MarkedContour3f mrmeshpy.markedContour

(

std_vector_Vector3_float

in_

)

\\return marked contour with all points from (in) marked

markedFirstLast()

MarkedContour3f mrmeshpy.markedFirstLast

(

std_vector_Vector3_float

in_

)

\\return marked contour with only first and last points from (in) marked

mcOffsetMesh()

Mesh mrmeshpy.mcOffsetMesh	(	MeshPart	mp,
		float	offset,
		OffsetParameters	params = '{}',
		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 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 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 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 mrmeshpy.merge

(

std_vector_std_shared_ptr_ObjectPoints

objsPoints

)

constructs new ObjectPoints containing the union of valid points from all input objects

mergeMeshes()

Mesh mrmeshpy.mergeMeshes

(

std_vector_std_shared_ptr_Mesh

meshes

)

Merge a list of meshes to one mesh.

meshDenoiseViaNormals()

None mrmeshpy.meshDenoiseViaNormals	(	Mesh	mesh,
		DenoiseViaNormalsSettings	settings = '{}' )

Reduces noise in given mesh,
see the article "Mesh Denoising via a Novel Mumford-Shah Framework"

meshFromVoxelsMask()

Mesh 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 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 mrmeshpy.meshOnEdgeSplitFaceAttribute	(	Mesh	mesh,
		MeshAttributesToUpdate	params )

meshOnEdgeSplitVertAttribute()

func_void_from_Id_EdgeTag_Id_EdgeTag mrmeshpy.meshOnEdgeSplitVertAttribute	(	Mesh	mesh,
		MeshAttributesToUpdate	params )

meshPreCollapseVertAttribute()

func_bool_from_Id_EdgeTag_Vector3_float 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 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 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 mrmeshpy.meshToDistanceField	(	MeshPart	mp,
		AffineXf3f	xf,
		Vector3f	voxelSize,
		float	surfaceOffset = 3,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.meshToDistanceFunctionVolume	(	MeshPart	mp,
		MeshToDistanceVolumeParams	params = '{}' )

makes FunctionVolume representing (signed or unsigned) distances from Mesh with given settings

meshToDistanceVdbVolume()

VdbVolume mrmeshpy.meshToDistanceVdbVolume	(	MeshPart	mp,
		MeshToVolumeParams	params = '{}' )

converts mesh (or its part) into a volume filled with signed or unsigned distances to mesh using OpenVDB library;
for signed distances the mesh must be closed;
*params.outXf is untouched

meshToDistanceVolume()

SimpleVolumeMinMax mrmeshpy.meshToDistanceVolume	(	MeshPart	mp,
		MeshToDistanceVolumeParams	params = '{}' )

makes SimpleVolume filled with (signed or unsigned) distances from Mesh with given settings

meshToLevelSet()

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

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 mrmeshpy.meshToPointCloud	(	Mesh	mesh,
		bool	saveNormals = True,
		VertBitSet	verts = None )

Mesh to PointCloud
\\ingroup MeshAlgorithmGroup

meshToVolume()

VdbVolume mrmeshpy.meshToVolume	(	MeshPart	mp,
		MeshToVolumeParams	params = '{}' )

converts mesh (or its part) into a volume filled with signed or unsigned distances to mesh using OpenVDB library;
for signed distances the mesh must be closed;
prior to conversion, world space is shifted to ensure that the bounding box of offset mesh is in positive quarter-space,
and the shift is written in *params.outXf

mixed() [1/3]

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

mixed product

mixed() [2/3]

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

mixed product

mixed() [3/3]

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

mixed product

moveMeshToVoxelMaxDeriv() [1/3]

VertBitSet mrmeshpy.moveMeshToVoxelMaxDeriv	(	Mesh	mesh,
		AffineXf3f	meshXf,
		FunctionVolume	volume,
		AffineXf3f	volumeXf,
		MoveMeshToVoxelMaxDerivSettings	settings,
		func_bool_from_float	callback = '{}' )

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

moveMeshToVoxelMaxDeriv() [2/3]

VertBitSet mrmeshpy.moveMeshToVoxelMaxDeriv	(	Mesh	mesh,
		AffineXf3f	meshXf,
		SimpleVolumeMinMax	volume,
		AffineXf3f	volumeXf,
		MoveMeshToVoxelMaxDerivSettings	settings,
		func_bool_from_float	callback = '{}' )

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

moveMeshToVoxelMaxDeriv() [3/3]

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

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 mrmeshpy.mult	(	Vector2d	a,
		Vector2d	b )

per component multiplication

mult() [2/6]

Vector2f mrmeshpy.mult	(	Vector2f	a,
		Vector2f	b )

per component multiplication

mult() [3/6]

Vector2i mrmeshpy.mult	(	Vector2i	a,
		Vector2i	b )

per component multiplication

mult() [4/6]

Vector3d mrmeshpy.mult	(	Vector3d	a,
		Vector3d	b )

per component multiplication

mult() [5/6]

Vector3f mrmeshpy.mult	(	Vector3f	a,
		Vector3f	b )

per component multiplication

mult() [6/6]

Vector3i mrmeshpy.mult	(	Vector3i	a,
		Vector3i	b )

per component multiplication

multiModelGridSampling()

std_vector_ObjVertId mrmeshpy.multiModelGridSampling	(	Vector_ModelPointsData_ObjId	models,
		float	voxelSize,
		func_bool_from_float	cb = '{}' )

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 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 = '{}' )

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 mrmeshpy.objectHasSelectableChildren

(

Object

object

)

\\}

objectSave()

None mrmeshpy.objectSave	(	Object	object,
		os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

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 mrmeshpy.offsetContours	(	std_vector_std_vector_Vector2_float	contours,
		float	offset,
		OffsetContoursParams	params = '{}' )

offsets 2d contours in plane

offsetContours() [2/4]

std_vector_std_vector_Vector2_float mrmeshpy.offsetContours	(	std_vector_std_vector_Vector2_float	contours,
		func_float_from_int_int	offset,
		OffsetContoursParams	params = '{}' )

offsets 2d contours in plane

offsetContours() [3/4]

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

offsets 3d contours in XY plane

offsetContours() [4/4]

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

offsets 3d contours in XY plane

offsetMesh()

Mesh mrmeshpy.offsetMesh	(	MeshPart	mp,
		float	offset,
		OffsetParameters	params = '{}' )

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 mrmeshpy.offsetOneDirection	(	MeshPart	mp,
		float	offset,
		GeneralOffsetParameters	params = '{}' )

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 mrmeshpy.offsetPolyline	(	Polyline3	polyline,
		float	offset,
		OffsetParameters	params = '{}' )

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)

offsetSurfaceLine() [1/2]

std_vector_std_vector_Vector3_float mrmeshpy.offsetSurfaceLine	(	Mesh	mesh,
		std_vector_MeshTriPoint	surfaceLine,
		float	offset )

<summary>
Returns contours in \\p mesh space that are offset from \\p surfaceLine on \\p offset amount in all directions
</summary>
<param name="mesh">mesh to perform offset on</param>
<param name="surfaceLine">surface line to perofrm offset from</param>
<param name="offset">amount of offset, note that absolute value is used</param>
<returns>resulting offset contours or error if something goes wrong</returns>

offsetSurfaceLine() [2/2]

std_vector_std_vector_Vector3_float mrmeshpy.offsetSurfaceLine	(	Mesh	mesh,
		std_vector_MeshTriPoint	surfaceLine,
		func_float_from_int	offsetAtPoint )

<summary>
Returns contours in \\p mesh space that are offset from \\p surfaceLine on \\p offsetAtPoint amount in all directions
</summary>
<param name="mesh">mesh to perform offset on</param>
<param name="surfaceLine">surface line to perofrm offset from</param>
<param name="offsetAtPoint">function that can return different amount of offset in different point (argument is index of point in \\p surfaceLine), note that absolute value is used</param>
<returns>resulting offset contours or error if something goes wrong</returns>

OpenDocument()

bool mrmeshpy.OpenDocument

(

os.PathLike | str | bytes

path

)

Opens given file (or directory) in associated application

OpenLink()

None mrmeshpy.OpenLink

(

str

url

)

Opens given link in default browser

operator()

bool mrmeshpy.operator	(	VertDistance	a,
		VertDistance	b )

smaller distance to be the first

opposite() [1/2]

OutEdge mrmeshpy.opposite

(

OutEdge

e

)

opposite() [2/2]

OutEdge2 mrmeshpy.opposite

(

OutEdge2

e

)

orderIntersectionContours()

std_vector_std_vector_VariableEdgeTri 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 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 mrmeshpy.orgRing	(	MeshTopology	topology,
		VertId	v )

orgRing0()

IteratorRange_RingIterator_NextEdgeSameOrigin 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 mrmeshpy.orient3d

(

PreciseVertCoords

vs

)

orient3d() [2/4]

bool 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 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 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 mrmeshpy.orientLocalTriangulations	(	AllLocalTriangulations	triangs,
		VertCoords	coords,
		VertBitSet	region,
		func_Vector3_float_from_Id_VertTag	targetDir )

orientLocalTriangulations() [2/2]

None 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 mrmeshpy.orientNormals	(	PointCloud	pointCloud,
		VertCoords	normals,
		AllLocalTriangulations	triangs,
		func_bool_from_float	progress = '{}' )

\\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 mrmeshpy.orientNormals	(	PointCloud	pointCloud,
		VertCoords	normals,
		Buffer_VertId	closeVerts,
		int	numNei,
		func_bool_from_float	progress = '{}' )

\\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 mrmeshpy.orientNormals	(	PointCloud	pointCloud,
		VertCoords	normals,
		float	radius,
		func_bool_from_float	progress = '{}' )

\\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 mrmeshpy.pack	(	ObjectPoints	pts,
		Reorder	reorder,
		VertBitSet	newValidVerts = None,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.parseFirstNum	(	str	str,
		int_output	num )

reads the first integer number in the line

parsePolygon()

None 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 mrmeshpy.partialOffsetMesh	(	MeshPart	mp,
		float	offset,
		GeneralOffsetParameters	params = '{}' )

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()

pathlib Path mrmeshpy.pathFromUtf8

(

str

s

)

pickedPointToVector3()

Vector3f 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 mrmeshpy.planeSectionsToContours2f	(	Mesh	mesh,
		std_vector_std_vector_EdgePoint	sections,
		AffineXf3f	meshToPlane )

planeSectionToContour2f()

std_vector_Vector2_float 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 mrmeshpy.pointGridSampling	(	PointCloud	cloud,
		float	voxelSize,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.pointIterativeSampling	(	PointCloud	cloud,
		int	numSamples,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.pointOnObjectToPickedPoint	(	VisualObject	object,
		PointOnObject	pos )

Converts PointOnObject coordinates depending on the object type to the PickedPoint variant

pointsToDistanceFunctionVolume()

FunctionVolume mrmeshpy.pointsToDistanceFunctionVolume	(	PointCloud	cloud,
		PointsToDistanceVolumeParams	params )

makes FunctionVolume representing signed distances to points with normals

pointsToDistanceVolume()

SimpleVolume mrmeshpy.pointsToDistanceVolume	(	PointCloud	cloud,
		PointsToDistanceVolumeParams	params )

makes SimpleVolume filled with signed distances to points with normals

pointsToMeshFusion()

Mesh 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 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 mrmeshpy.polylineOffset	(	Polyline2	polyline,
		float	pixelSize,
		float	offset )

constructs an offset contour for given polyline

positionVertsSmoothly()

None 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 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 mrmeshpy.positionVertsWithSpacing	(	Mesh	mesh,
		SpacingSettings	settings )

Moves given vertices to make the distances between them as specified

printCurrentTimerBranch()

None mrmeshpy.printCurrentTimerBranch

(

)

prints current timer branch

printStacktraceOnCrash()

None mrmeshpy.printStacktraceOnCrash

(

)

Print stacktrace on application crash

printTimingTree()

None 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 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 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 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 mrmeshpy.projectOnAll	(	Vector3f	pt,
		AABBTreeObjects	tree,
		float	upDistLimitSq,
		func_void_from_Id_ObjTag_MeshOrPoints_ProjectionResult	callback,
		ObjId	skipObjId = '{}' )

finds closest point on every object within given distance

putScanFileNameInZ()

None mrmeshpy.putScanFileNameInZ	(	std_vector_std_filesystem_path	scans,
		std_vector_SliceInfo	zOrder )

Read layer heights from given scan file names

rayBoxIntersect()

bool 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 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 mrmeshpy.rayInsideIntersect	(	Mesh	mesh,
		VertId	v,
		float	rayEnd = 3.4028234663852886e+38 )

rayMeshIntersect() [1/2]

MeshIntersectionResult 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 = '{}' )

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 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 = '{}' )

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 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 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 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 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 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 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 mrmeshpy.rayTriangleIntersect	(	Vector3d	oriA,
		Vector3d	oriB,
		Vector3d	oriC,
		IntersectionPrecomputes_double	prec )

rayTriangleIntersect() [2/4]

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

rayTriangleIntersect() [3/4]

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

rayTriangleIntersect() [4/4]

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

rayTriangleIntersect_() [1/2]

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

rayTriangleIntersect_() [2/2]

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

readByBlocks()

bool mrmeshpy.readByBlocks	(	typing.Any	in_,
		char_output	data,
		int	dataSize,
		func_bool_from_float	callback = '{}',
		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 mrmeshpy.readRawTiff	(	os.PathLike | str | bytes	path,
		RawTiffOutput	output )

load values from tiff to ouput.data

readString()

str mrmeshpy.readString

(

typing.Any

in_

)

reads input stream to string

readTiffParameters()

TiffParameters mrmeshpy.readTiffParameters

(

os.PathLike | str | bytes

path

)

reads parameters of tiff file

rebuildMesh()

Mesh 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 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 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 mrmeshpy.refineFeatureObject	(	FeatureObject	featObj,
		Mesh	mesh,
		RefineParameters	params = '{}' )

Recalculate the feature object's position so it would better fit with the given mesh

refineFeatureObject() [2/2]

AffineXf3f mrmeshpy.refineFeatureObject	(	FeatureObject	featObj,
		PointCloud	pointCloud,
		RefineParameters	params = '{}' )

Recalculate the feature object's position so it would better fit with the given point cloud

relax() [1/2]

bool mrmeshpy.relax	(	Mesh	mesh,
		MeshRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.relax	(	PointCloud	pointCloud,
		PointCloudRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.relaxApprox	(	Mesh	mesh,
		MeshApproxRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.relaxApprox	(	PointCloud	pointCloud,
		PointCloudApproxRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.relaxKeepVolume	(	Mesh	mesh,
		MeshRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.relaxKeepVolume	(	PointCloud	pointCloud,
		PointCloudRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.remesh	(	Mesh	mesh,
		RemeshSettings	settings )

Splits too long and eliminates too short edges from the mesh

removeLoneContours()

None mrmeshpy.removeLoneContours

(

std_vector_std_vector_VariableEdgeTri

contours

)

Removes contours that fully lay inside one triangle from the contours

removeLoneDegeneratedContours()

None 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 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 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 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 mrmeshpy.replaceProhibitedChars	(	str	line,
		str	replacement = '_' )

replace OS prohibited chars ('?', '*', '/', '\\', '"', '<', '>') with `replacement` char

replicateZ()

None mrmeshpy.replicateZ	(	Mesh	m,
		Mesh	target )

adjusts z-coordinates of (m) vertices to make adjusted (m) similar to (target)

reportProgress() [1/2]

bool 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 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 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 mrmeshpy.resampled	(	OpenVdbFloatGrid	grid,
		float	voxelScale,
		func_bool_from_float	cb = '{}' )

resample this grid to fit voxelScale

resampled() [2/2]

OpenVdbFloatGrid mrmeshpy.resampled	(	OpenVdbFloatGrid	grid,
		Vector3f	voxelScale,
		func_bool_from_float	cb = '{}' )

resample this grid to fit voxelScale

resolveMeshDegenerations() [1/2]

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

resolveMeshDegenerations() [2/2]

bool mrmeshpy.resolveMeshDegenerations	(	Mesh	mesh,
		ResolveMeshDegenSettings	settings = '{}' )

 \\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 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 mrmeshpy.reverse

(

std_vector_std_vector_Id_EdgeTag

paths

)

reverse every path in the vector

roundToPrecision()

float mrmeshpy.roundToPrecision	(	float	v,
		int	precision )

returns given value rounded to given number of decimal digits

same() [1/2]

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

returns true if two edge-points are equal considering different representations

same() [2/2]

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

returns true if two points are equal considering different representations

sampleHalfSphere()

std_vector_Vector3_float mrmeshpy.sampleHalfSphere

(

)

returns quasi-uniform 145 samples on unit half-sphere z>0

saveAllSlicesToImage()

None 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 mrmeshpy.saveDistanceMapToImage	(	DistanceMap	distMap,
		os.PathLike | str | bytes	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 mrmeshpy.saveLines	(	Polyline3	polyline,
		os.PathLike | str | bytes	file,
		SaveSettings	settings = '{}' )

detects the format from file extension and saves polyline in it

saveLines() [2/2]

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

extension in `*.ext` format

saveMesh() [1/2]

None mrmeshpy.saveMesh	(	Mesh	mesh,
		os.PathLike | str | bytes	file,
		SaveSettings	settings = '{}' )

detects the format from file extension and save mesh to it

saveMesh() [2/2]

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

extension in `*.ext` format

saveObjectVoxelsToFile()

None mrmeshpy.saveObjectVoxelsToFile	(	Object	object,
		os.PathLike | str | bytes	path,
		func_bool_from_float	callback = '{}' )

savePoints() [1/2]

None mrmeshpy.savePoints	(	PointCloud	points,
		os.PathLike | str | bytes	file,
		SaveSettings	settings = '{}' )

detects the format from file extension and save points to it

savePoints() [2/2]

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

extension in `*.ext` format

saveSliceToImage()

None mrmeshpy.saveSliceToImage	(	os.PathLike | str | bytes	path,
		VdbVolume	vdbVolume,
		SlicePlane	slicePlain,
		int	sliceNumber,
		func_bool_from_float	callback = '{}' )

save the slice by the active plane through the sliceNumber to an image file

saveVoxels()

None mrmeshpy.saveVoxels	(	VdbVolume	vdbVolume,
		os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

Saves voxels in a file, detecting the format from file extension

saveVoxelsGav() [1/6]

None mrmeshpy.saveVoxelsGav	(	SimpleVolume	simpleVolume,
		os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

saveVoxelsGav() [2/6]

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

saveVoxelsGav() [3/6]

None mrmeshpy.saveVoxelsGav	(	SimpleVolumeMinMax	simpleVolumeMinMax,
		os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

saveVoxelsGav() [4/6]

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

saveVoxelsGav() [5/6]

None mrmeshpy.saveVoxelsGav	(	VdbVolume	vdbVolume,
		os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

Save voxels in Gav-format in given destination

saveVoxelsGav() [6/6]

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

saveVoxelsRaw() [1/2]

None mrmeshpy.saveVoxelsRaw	(	SimpleVolume	simpleVolume,
		os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

saveVoxelsRaw() [2/2]

None mrmeshpy.saveVoxelsRaw	(	VdbVolume	vdbVolume,
		os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

Save raw voxels file, writing parameters in file name

segmentByGraphCut()

FaceBitSet 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 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 mrmeshpy.segmentVolumeByGraphCut	(	SimpleVolume	densityVolume,
		float	k,
		VoxelBitSet	sourceSeeds,
		VoxelBitSet	sinkSeeds,
		func_bool_from_float	cb = '{}' )

 \\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

segmentVoxelMaskToInstances()

std_vector_Mesh mrmeshpy.segmentVoxelMaskToInstances	(	VdbVolume	mask,
		int	minSize = 100,
		func_bool_from_float	cb = '{}' )

Given voxel mask, separate it into components using mincut algorithm
@param minSize Minimum size of a segment (in voxels)

SegPoints()

None 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 mrmeshpy.separateClosedContour	(	Mesh	mesh,
		std_vector_Vector3_float	contour,
		func_void_from_EdgePoint	cb = '{}' )

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 mrmeshpy.serializeMesh	(	Mesh	mesh,
		os.PathLike | str | bytes	path,
		FaceBitSet	selection = None,
		str	serializeFormat = '".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 mrmeshpy.serializeObjectTree	(	Object	object,
		os.PathLike | str | bytes	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 mrmeshpy.serializeObjectTree	(	Object	object,
		os.PathLike | str | bytes	path,
		func_bool_from_float	progress = '{}' )

serializeObjectTreeToGltf()

None mrmeshpy.serializeObjectTreeToGltf	(	Object	root,
		os.PathLike | str | bytes	file,
		func_bool_from_float	callback = '{}' )

saves scene to a glTF file

SetCurrentThreadName()

None mrmeshpy.SetCurrentThreadName

(

str

name

)

sets debug name for the current thread

setDefaultSerializeMeshFormat()

None mrmeshpy.setDefaultSerializeMeshFormat

(

str

newFormat

)

sets file extension used to serialize serialize ObjectMeshHolder by default (if not overridden in specific object),
the string must start from '.';
serialization falls back to the PLY format if given format support is available
NOTE: CTM format support is available in the MRIOExtras library; make sure to load it if you prefer CTM

setDefaultSerializePointsFormat()

None mrmeshpy.setDefaultSerializePointsFormat

(

str

newFormat

)

sets file extension used to serialize serialize ObjectPointsHolder by default (if not overridden in specific object),
the string must start from '.';
serialization falls back to the PLY format if given format support is available
NOTE: CTM format support is available in the MRIOExtras library; make sure to load it if you prefer CTM

setDefaultSerializeVoxelsFormat()

None mrmeshpy.setDefaultSerializeVoxelsFormat

(

str

newFormat

)

sets file extension used to serialize serialize ObjectVoxels by default (if not overridden in specific object),
the string must start from '.'

setLevelSetType()

None mrmeshpy.setLevelSetType

(

OpenVdbFloatGrid

grid

)

sets type of this grid as LEVEL SET (for normal flipping)

setNewHandlerIfNeeded()

None mrmeshpy.setNewHandlerIfNeeded

(

)

sets new handler for operator new if needed for some platforms

setupLoggerByDefault()

None 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 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 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 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 mrmeshpy.sharpOffsetMesh	(	MeshPart	mp,
		float	offset,
		SharpOffsetParameters	params = '{}' )

Offsets mesh by converting it to voxels and back
post process result using reference mesh to sharpen features

shrink() [1/2]

None 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 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 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 mrmeshpy.shrinkPixelMask	(	PixelBitSet	mask,
		RectIndexer	indexer,
		int	shrinkage = 1 )

shrinks PixelBitSet with given number of steps

shrinkVoxelsMask()

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

shrinks VoxelBitSet with given number of steps

signedDistanceToMesh()

float mrmeshpy.signedDistanceToMesh	(	MeshPart	mp,
		Vector3f	p,
		SignedDistanceToMeshOptions	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 mrmeshpy.simpleVolumeToDenseGrid	(	SimpleVolume	simpleVolume,
		float	background = 0.0,
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.simpleVolumeToVdbVolume	(	SimpleVolumeMinMax	simpleVolume,
		func_bool_from_float	cb = '{}' )

set the simpleVolume.min as the background value

smoothRegionBoundary()

None 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 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 mrmeshpy.sortPathsByLength	(	std_vector_std_vector_Id_EdgeTag	paths,
		Mesh	mesh )

sortPathsByMetric()

None 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 mrmeshpy.sortScanFilesByName

(

std_vector_std_filesystem_path

scans

)

Sort scan files in given vector by names (respect numbers in it)

sortScansByOrder()

None 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 mrmeshpy.split	(	str	string,
		str	delimiter )

 Splits given string by delimiter.
 \\return vector of split strings
 \\ingroup BasicGroup

splitByLines()

std_vector_unsigned_long_long mrmeshpy.splitByLines	(	str	data,
		int	size )

returns offsets for each new line in monolith char block

splitOnSimpleLoops()

std_vector_std_vector_Id_EdgeTag 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

splitQuad()

None mrmeshpy.splitQuad	(	MeshTopology	topology,
		Id_EdgeTag	a,
		FaceBitSet	outNewFaces = None )

given quadrangle face to the left of a, splits it in two triangles with new diagonal edge via dest(a)

sqr() [1/7]

float mrmeshpy.sqr

(

float

x

)

sqr() [2/7]

float mrmeshpy.sqr

(

Vector2d

a

)

squared length

sqr() [3/7]

float mrmeshpy.sqr

(

Vector2f

a

)

squared length

sqr() [4/7]

int mrmeshpy.sqr

(

Vector2i

a

)

squared length

sqr() [5/7]

float mrmeshpy.sqr

(

Vector3d

a

)

squared length

sqr() [6/7]

float mrmeshpy.sqr

(

Vector3f

a

)

squared length

sqr() [7/7]

int mrmeshpy.sqr

(

Vector3i

a

)

squared length

stitchContours()

None 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 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 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 mrmeshpy.subdivideMesh	(	Mesh	mesh,
		SubdivideSettings	settings = '{}' )

splits edges in mesh region according to the settings;\\n
\\return The total number of edge splits performed

subdividePolyline() [1/2]

int mrmeshpy.subdividePolyline	(	Polyline2	polyline,
		PolylineSubdivideSettings	settings = '{}' )

Split edges in polyline according to the settings;\\n
\\return The total number of edge splits performed

subdividePolyline() [2/2]

int mrmeshpy.subdividePolyline	(	Polyline3	polyline,
		PolylineSubdivideSettings	settings = '{}' )

subdividePolylineWithPlane()

EdgeBitSet 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 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 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 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 mrmeshpy.suggestVoxelSize	(	MeshPart	mp,
		float	approxNumVoxels )

computes size of a cubical voxel to get approximately given number of voxels during rasterization

surfacePathLength()

float mrmeshpy.surfacePathLength	(	Mesh	mesh,
		std_vector_EdgePoint	surfacePath )

computes the length of surface path

surfacePathsToContours3f()

std_vector_std_vector_Vector3_float mrmeshpy.surfacePathsToContours3f	(	Mesh	mesh,
		std_vector_std_vector_EdgePoint	lines )

surfacePathToContour3f()

std_vector_Vector3_float 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 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 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 mrmeshpy.systemToUtf8

(

str

system

)

converts system encoded string to UTF8-encoded string

teethMaskToDirectionVolume()

std_array_VoxelsVolumeMinMax_std_vector_float_3 mrmeshpy.teethMaskToDirectionVolume	(	VdbVolume	volume,
		std_vector_int	additionalIds = '{}' )

A shortcut for \\ref TeethMaskToDirectionVolumeConvertor::create and \\ref TeethMaskToDirectionVolumeConvertor::convertAll

terrainTriangulation()

Mesh mrmeshpy.terrainTriangulation	(	std_vector_Vector3_float	points,
		func_bool_from_float	cb = '{}' )

Creates Delaunay triangulation using only XY components of points 
points will be changed inside this function take argument by value

thickenMesh()

Mesh mrmeshpy.thickenMesh	(	Mesh	mesh,
		float	offset,
		GeneralOffsetParameters	params = '{}' )

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 mrmeshpy.toLower

(

str

str

)

return a copy of the string with all alphabetic characters replaced with upper-case variants

topologyFromTriangles()

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

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 mrmeshpy.toString

(

DimensionsVisualizePropertyType

value

)

toString() [2/2]

str mrmeshpy.toString

(

PathError

error

)

trackLeftBoundaryLoop() [1/2]

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

trackLeftBoundaryLoop() [2/2]

std_vector_Id_EdgeTag 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 mrmeshpy.trackRightBoundaryLoop	(	MeshTopology	topology,
		FaceBitSet	region,
		Id_EdgeTag	e0 )

trackRightBoundaryLoop() [2/2]

std_vector_Id_EdgeTag 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() [1/2]

std_vector_EdgePoint 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)

trackSection() [2/2]

std_vector_EdgePoint mrmeshpy.trackSection	(	MeshPart	mp,
		MeshTriPoint	start,
		MeshTriPoint	end,
		Vector3f	planePoint,
		bool	ccw )

track section of plane set by start point, end point and planePoint
from start to end
\\param ccw - if true use start->end->planePoint plane, otherwise use start->planePoint->end (changes direction of plane tracking)
returns track on surface without end point (return error if path was looped or reached boundary)

transformNormals()

VertCoords 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 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()

TransformVdbVolumeResult mrmeshpy.transformVdbVolume	(	VdbVolume	volume,
		AffineXf3f	xf,
		bool	fixBox = False,
		Box3f	box = '{}' )

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 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 mrmeshpy.triangulateContours	(	std_vector_std_vector_Vector2_float	contours,
		std_vector_std_vector_Id_VertTag	holeVertsIds = None )

triangulatePointCloud()

Mesh mrmeshpy.triangulatePointCloud	(	PointCloud	pointCloud,
		TriangulationParameters	params = '{}',
		func_bool_from_float	progressCb = '{}' )

 \\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 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 mrmeshpy.trimRight

(

str

str

)

Removes all whitespace character (detected by std::isspace) at the end of string view

trimWithPlane() [1/3]

None 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 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 mrmeshpy.trimWithPlane	(	Mesh	mesh,
		TrimWithPlaneParams	params,
		TrimOptionalOutput	optOut = '{}' )

\\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 mrmeshpy.undirectedEdges

(

MeshTopology

topology

)

undirectedEdges() [2/2]

IteratorRange_PolylineUndirectedEdgeIterator mrmeshpy.undirectedEdges

(

PolylineTopology

topology

)

uniteCloseVertices()

int 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 mrmeshpy.uniteLocalTriangulations	(	std_vector_SomeLocalTriangulations	in_,
		func_bool_from_float	progress = '{}' )

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 mrmeshpy.uniteManyMeshes	(	std_vector_Mesh_const	meshes,
		UniteManyMeshesParams	params = '{}' )

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 mrmeshpy.unitVector3_double	(	float	azimuth,
		float	altitude )

returns a point on unit sphere given two angles

unitVector3_float()

Vector3f mrmeshpy.unitVector3_float	(	float	azimuth,
		float	altitude )

returns a point on unit sphere given two angles

updateGroupPairs()

None 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 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 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 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)

Utf16ToUtf8()

str mrmeshpy.Utf16ToUtf8

(

str

utf16

)

converts UTF16-encoded string to UTF8-encoded string

utf8string()

str mrmeshpy.utf8string

(

os.PathLike | str | bytes

path

)

utf8ToSystem()

str mrmeshpy.utf8ToSystem

(

str

utf8

)

converts UTF8-encoded string to system encoded string,
returns empty string if such conversion cannot be made

utf8ToWide()

str mrmeshpy.utf8ToWide

(

str

utf8

)

converts UTF8-encoded string into UTF16-encoded string

vdbVolumeToSimpleVolume()

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

make SimpleVolume from VdbVolume
make copy of data

vdbVolumeToSimpleVolumeNorm()

SimpleVolumeMinMax mrmeshpy.vdbVolumeToSimpleVolumeNorm	(	VdbVolume	vdbVolume,
		Box3i	activeBox = 'MR::Box3i()',
		std_optional_Box_float	sourceScale = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.vdbVolumeToSimpleVolumeU16	(	VdbVolume	vdbVolume,
		Box3i	activeBox = 'MR::Box3i()',
		std_optional_Box_float	sourceScale = '{}',
		func_bool_from_float	cb = '{}' )

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 mrmeshpy.vertexAttributeGradient	(	Mesh	mesh,
		VertScalars	vertexAttribute )

Calculates gradient for each vertex in mesh, based on vertexAttribute

vertexPosEqualNeiAreas()

Vector3f 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 mrmeshpy.verticesGridSampling	(	MeshPart	mp,
		float	voxelSize,
		func_bool_from_float	cb = '{}' )

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 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 mrmeshpy.voxelBooleanIntersect	(	Mesh	mesh1,
		Mesh	mesh2,
		float	voxelSize )

Intersect mesh A and mesh B.

voxelBooleanSubtract()

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

Subtract mesh B from mesh A.

voxelBooleanUnite()

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

Unite mesh A and mesh B.

voxelFilter()

VdbVolume 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 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()

bool 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_long_unsigned_long_long mrmeshpy.voxelsExponentMetric	(	VdbVolume	voxels,
		VoxelMetricParameters	parameters,
		float	modifier = -1.0 )

e^(modifier*(dens1+dens2))

voxelsSumDiffsMetric()

func_float_from_unsigned_long_long_unsigned_long_long mrmeshpy.voxelsSumDiffsMetric	(	VdbVolume	voxels,
		VoxelMetricParameters	parameters )

sum of dense differences with start and stop voxels

wideToUtf8()

str mrmeshpy.wideToUtf8

(

str

wide

)

converts wide null terminating string to UTF8-encoded string

writeByBlocks()

bool mrmeshpy.writeByBlocks	(	typing.Any	out,
		str	data,
		int	dataSize,
		func_bool_from_float	callback = '{}',
		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 mrmeshpy.writeRawTiff	(	int	bytes,
		os.PathLike | str | bytes	path,
		BaseTiffParameters	params )

writes bytes to tiff file

xyPlaneMeshIntersect()

None 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 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 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

AABBTreeNode_AABBTreeBase_ObjTreeTraits_Traits

mrmeshpy.AABBTreeNode_AABBTreeBase_ObjTreeTraits_Traits = AABBTreeNode_ObjTreeTraits

AffineXf_Vector2d_M

mrmeshpy.AffineXf_Vector2d_M = Matrix2d

AffineXf_Vector2f_M

mrmeshpy.AffineXf_Vector2f_M = Matrix2f

AffineXf_Vector3d_M

mrmeshpy.AffineXf_Vector3d_M = Matrix3d

AffineXf_Vector3f_M

mrmeshpy.AffineXf_Vector3f_M = Matrix3f

AllVisualizeProperties

mrmeshpy.AllVisualizeProperties = std_vector_ViewportMask

Ball_double_VTraits

mrmeshpy.Ball_double_VTraits = VectorTraits_double

Ball_float_VTraits

mrmeshpy.Ball_float_VTraits = VectorTraits_float

Ball_Vector2d_VTraits

mrmeshpy.Ball_Vector2d_VTraits = VectorTraits_Vector2d

Ball_Vector2f_VTraits

mrmeshpy.Ball_Vector2f_VTraits = VectorTraits_Vector2f

Ball_Vector3d_VTraits

mrmeshpy.Ball_Vector3d_VTraits = VectorTraits_Vector3d

Ball_Vector3f_VTraits

mrmeshpy.Ball_Vector3f_VTraits = VectorTraits_Vector3f

BMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType

mrmeshpy.BMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = BMap_Id_ICPElemtTag_Id_ICPElemtTag

BMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType

mrmeshpy.BMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = BMap_Id_VoxelTag_Id_VoxelTag

BooleanResMapObj

mrmeshpy.BooleanResMapObj = BooleanResultMapper.MapObject

Box_double_VTraits

mrmeshpy.Box_double_VTraits = VectorTraits_double

Box_float_VTraits

mrmeshpy.Box_float_VTraits = VectorTraits_float

Box_int_VTraits

mrmeshpy.Box_int_VTraits = VectorTraits_int

Box_long_long_VTraits

mrmeshpy.Box_long_long_VTraits = VectorTraits_long_long

Box_Vector2d_VTraits

mrmeshpy.Box_Vector2d_VTraits = VectorTraits_Vector2d

Box_Vector2f_VTraits

mrmeshpy.Box_Vector2f_VTraits = VectorTraits_Vector2f

Box_Vector2i_VTraits

mrmeshpy.Box_Vector2i_VTraits = VectorTraits_Vector2i

Box_Vector2ll_VTraits

mrmeshpy.Box_Vector2ll_VTraits = VectorTraits_Vector2ll

Box_Vector3d_VTraits

mrmeshpy.Box_Vector3d_VTraits = VectorTraits_Vector3d

Box_Vector3f_VTraits

mrmeshpy.Box_Vector3f_VTraits = VectorTraits_Vector3f

Box_Vector3i_VTraits

mrmeshpy.Box_Vector3i_VTraits = VectorTraits_Vector3i

Box_Vector3ll_VTraits

mrmeshpy.Box_Vector3ll_VTraits = VectorTraits_Vector3ll

ColorMapAggregator_FaceTag_ColorMap

mrmeshpy.ColorMapAggregator_FaceTag_ColorMap = FaceColors

ColorMapAggregator_FaceTag_ElementBitSet

mrmeshpy.ColorMapAggregator_FaceTag_ElementBitSet = FaceBitSet

ColorMapAggregator_UndirectedEdgeTag_ColorMap

mrmeshpy.ColorMapAggregator_UndirectedEdgeTag_ColorMap = UndirectedEdgeColors

ColorMapAggregator_UndirectedEdgeTag_ElementBitSet

mrmeshpy.ColorMapAggregator_UndirectedEdgeTag_ElementBitSet = UndirectedEdgeBitSet

ColorMapAggregator_VertTag_ColorMap

mrmeshpy.ColorMapAggregator_VertTag_ColorMap = VertColors

ColorMapAggregator_VertTag_ElementBitSet

mrmeshpy.ColorMapAggregator_VertTag_ElementBitSet = VertBitSet

ContinuousContour

mrmeshpy.ContinuousContour = std_vector_VariableEdgeTri

ContinuousContours

mrmeshpy.ContinuousContours = std_vector_std_vector_VariableEdgeTri

Contour2d

mrmeshpy.Contour2d = std_vector_Vector2_double

Contour2f

mrmeshpy.Contour2f = std_vector_Vector2_float

Contour3d

mrmeshpy.Contour3d = std_vector_Vector3_double

Contour3f

mrmeshpy.Contour3f = std_vector_Vector3_float

Contours2d

mrmeshpy.Contours2d = std_vector_std_vector_Vector2_double

Contours2f

mrmeshpy.Contours2f = std_vector_std_vector_Vector2_float

Contours3d

mrmeshpy.Contours3d = std_vector_std_vector_Vector3_double

Contours3f

mrmeshpy.Contours3f = std_vector_std_vector_Vector3_float

copyMesh

mrmeshpy.copyMesh = Mesh

DecimatePolylineSettings2

mrmeshpy.DecimatePolylineSettings2 = DecimatePolylineSettings_Vector2f

DecimatePolylineSettings3

mrmeshpy.DecimatePolylineSettings3 = DecimatePolylineSettings_Vector3f

EdgeHashMap

mrmeshpy.EdgeHashMap = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

EdgeId

mrmeshpy.EdgeId = Id_EdgeTag

EdgeLoop

mrmeshpy.EdgeLoop = std_vector_Id_EdgeTag

EdgeLoops

mrmeshpy.EdgeLoops = std_vector_std_vector_Id_EdgeTag

EdgePath

mrmeshpy.EdgePath = std_vector_Id_EdgeTag

EdgePathsBuilder

mrmeshpy.EdgePathsBuilder = EdgePathsBuilderT_TrivialMetricToPenalty

FaceHashMap

mrmeshpy.FaceHashMap = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

FaceTreeTraits3

mrmeshpy.FaceTreeTraits3 = AABBTreeTraits_FaceTag_Box3f

FeaturesPropertyTypesVariant

mrmeshpy.FeaturesPropertyTypesVariant = std_variant_float_Vector3_float

FileNamesStack

mrmeshpy.FileNamesStack = std_vector_std_filesystem_path

FixSelfIntersectionMethod

mrmeshpy.FixSelfIntersectionMethod = SelfIntersections.Settings.Method

FixSelfIntersectionSettings

mrmeshpy.FixSelfIntersectionSettings = SelfIntersections.Settings

FloatGrid

mrmeshpy.FloatGrid = OpenVdbFloatGrid

GcodeSource

mrmeshpy.GcodeSource = std_vector_std_string

GeneralOffsetParametersMode

mrmeshpy.GeneralOffsetParametersMode = OffsetMode

HashMap_EdgeId_EdgeId

mrmeshpy.HashMap_EdgeId_EdgeId = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

HashMap_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType

mrmeshpy.HashMap_TaggedBitSet_EdgeTag_IndexType_TaggedBitSet_EdgeTag_IndexType = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

HashMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType

mrmeshpy.HashMap_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = phmap_flat_hash_map_Id_ICPElemtTag_Id_ICPElemtTag

HashMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType

mrmeshpy.HashMap_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag

HistoryActionsVector

mrmeshpy.HistoryActionsVector = std_vector_std_shared_ptr_HistoryAction

ICPElementBitSet

mrmeshpy.ICPElementBitSet = TaggedBitSet_ICPElemtTag

ICPElementId

mrmeshpy.ICPElementId = Id_ICPElemtTag

ICPObjects

mrmeshpy.ICPObjects = Vector_MeshOrPointsXf_ObjId

ICPPairsGrid

mrmeshpy.ICPPairsGrid = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

IOFilters

mrmeshpy.IOFilters = std_vector_IOFilter

IsoLine

mrmeshpy.IsoLine = std_vector_EdgePoint

IsoLines

mrmeshpy.IsoLines = std_vector_std_vector_EdgePoint

IteratorRange_LeftRingIterator

mrmeshpy.IteratorRange_LeftRingIterator = IteratorRange_RingIterator_NextEdgeSameLeft

IteratorRange_OrgRingIterator

mrmeshpy.IteratorRange_OrgRingIterator = IteratorRange_RingIterator_NextEdgeSameOrigin

LaplacianEdgeWeightsParam

mrmeshpy.LaplacianEdgeWeightsParam = EdgeWeights

LeftRingIterator

mrmeshpy.LeftRingIterator = RingIterator_NextEdgeSameLeft

Line3dMesh

mrmeshpy.Line3dMesh = Line3Mesh_double

Line3fMesh

mrmeshpy.Line3fMesh = Line3Mesh_float

LineTreeTraits2

mrmeshpy.LineTreeTraits2 = AABBTreeTraits_UndirectedEdgeTag_Box2f

LineTreeTraits3

mrmeshpy.LineTreeTraits3 = AABBTreeTraits_UndirectedEdgeTag_Box3f

LoadedObject

mrmeshpy.LoadedObject = LoadedObjectT

LoadedObjectLines

mrmeshpy.LoadedObjectLines = LoadedObjectT_ObjectLines

LoadedObjectMesh

mrmeshpy.LoadedObjectMesh = LoadedObjectT_ObjectMesh

LoadedObjectPoints

mrmeshpy.LoadedObjectPoints = LoadedObjectT_ObjectPoints

LoadedObjectT_Object

mrmeshpy.LoadedObjectT_Object = LoadedObjectT

LoadedObjectVoxels

mrmeshpy.LoadedObjectVoxels = LoadedObjectT_ObjectVoxels

Matrix2_bool_VectorType

mrmeshpy.Matrix2_bool_VectorType = Vector2b

Matrix2_double_VectorType

mrmeshpy.Matrix2_double_VectorType = Vector2d

Matrix2_float_VectorType

mrmeshpy.Matrix2_float_VectorType = Vector2f

Matrix2_int_VectorType

mrmeshpy.Matrix2_int_VectorType = Vector2i

Matrix2_long_long_VectorType

mrmeshpy.Matrix2_long_long_VectorType = Vector2ll

Matrix3_bool_VectorType

mrmeshpy.Matrix3_bool_VectorType = Vector3b

Matrix3_double_VectorType

mrmeshpy.Matrix3_double_VectorType = Vector3d

Matrix3_float_VectorType

mrmeshpy.Matrix3_float_VectorType = Vector3f

Matrix3_int_VectorType

mrmeshpy.Matrix3_int_VectorType = Vector3i

Matrix3_long_long_VectorType

mrmeshpy.Matrix3_long_long_VectorType = Vector3ll

Matrix4_bool_VectorType

mrmeshpy.Matrix4_bool_VectorType = Vector4b

Matrix4_double_VectorType

mrmeshpy.Matrix4_double_VectorType = Vector4d

Matrix4_float_VectorType

mrmeshpy.Matrix4_float_VectorType = Vector4f

Matrix4_int_VectorType

mrmeshpy.Matrix4_int_VectorType = Vector4i

Matrix4_long_long_VectorType

mrmeshpy.Matrix4_long_long_VectorType = Vector4ll

MeshBuilderSettings

mrmeshpy.MeshBuilderSettings = MeshBuilder.BuildSettings

MeshDistanceResult

mrmeshpy.MeshDistanceResult = MeshMeshDistanceResult

MeshEdgePoint

mrmeshpy.MeshEdgePoint = EdgePoint

MeshLabel

mrmeshpy.MeshLabel = PositionedText

MeshOnVoxelsFunction

mrmeshpy.MeshOnVoxelsFunction = MeshOnVoxelsT_Mesh_FunctionVolume

MeshOnVoxelsFunctionC

mrmeshpy.MeshOnVoxelsFunctionC = MeshOnVoxelsT_const_Mesh_FunctionVolume

MeshOnVoxelsSimple

mrmeshpy.MeshOnVoxelsSimple = MeshOnVoxelsT_Mesh_SimpleVolumeMinMax

MeshOnVoxelsSimpleC

mrmeshpy.MeshOnVoxelsSimpleC = MeshOnVoxelsT_const_Mesh_SimpleVolumeMinMax

MeshOnVoxelsVdb

mrmeshpy.MeshOnVoxelsVdb = MeshOnVoxelsT_Mesh_VdbVolume

MeshOnVoxelsVdbC

mrmeshpy.MeshOnVoxelsVdbC = MeshOnVoxelsT_const_Mesh_VdbVolume

MeshSignedDistanceResult

mrmeshpy.MeshSignedDistanceResult = MeshMeshSignedDistanceResult

MeshToVolumeParamsType

mrmeshpy.MeshToVolumeParamsType = MeshToVolumeParams.Type

MinMax_VoxelsVolume_std_vector_unsigned_short_ValueType

mrmeshpy.MinMax_VoxelsVolume_std_vector_unsigned_short_ValueType = Box_unsigned_short

MinMaxd

mrmeshpy.MinMaxd = Box1d

MinMaxf

mrmeshpy.MinMaxf = Box1f

MultiObjsSamples

mrmeshpy.MultiObjsSamples = std_vector_ObjVertId

ObjectPtr

mrmeshpy.ObjectPtr = Object

OffsetContoursVertMap

mrmeshpy.OffsetContoursVertMap = std_vector_OffsetContoursOrigins

OffsetContoursVertMaps

mrmeshpy.OffsetContoursVertMaps = std_vector_std_vector_OffsetContoursOrigins

OneMeshContours

mrmeshpy.OneMeshContours = std_vector_OneMeshContour

OrgRingIterator

mrmeshpy.OrgRingIterator = RingIterator_NextEdgeSameOrigin

phmap_flat_hash_map_FaceId_FaceId

mrmeshpy.phmap_flat_hash_map_FaceId_FaceId = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

phmap_flat_hash_map_GraphEdgeId_GraphEdgeId

mrmeshpy.phmap_flat_hash_map_GraphEdgeId_GraphEdgeId = phmap_flat_hash_map_Id_GraphEdgeTag_Id_GraphEdgeTag

phmap_flat_hash_map_GraphVertId_GraphVertId

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

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

mrmeshpy.phmap_flat_hash_map_NodeId_NodeId = phmap_flat_hash_map_Id_NodeTag_Id_NodeTag

phmap_flat_hash_map_ObjId_ObjId

mrmeshpy.phmap_flat_hash_map_ObjId_ObjId = phmap_flat_hash_map_Id_ObjTag_Id_ObjTag

phmap_flat_hash_map_PixelId_PixelId

mrmeshpy.phmap_flat_hash_map_PixelId_PixelId = phmap_flat_hash_map_Id_PixelTag_Id_PixelTag

phmap_flat_hash_map_RegionId_RegionId

mrmeshpy.phmap_flat_hash_map_RegionId_RegionId = phmap_flat_hash_map_Id_RegionTag_Id_RegionTag

phmap_flat_hash_map_TextureId_TextureId

mrmeshpy.phmap_flat_hash_map_TextureId_TextureId = phmap_flat_hash_map_Id_TextureTag_Id_TextureTag

phmap_flat_hash_map_UndirectedEdgeId_Id_EdgeTag

mrmeshpy.phmap_flat_hash_map_UndirectedEdgeId_Id_EdgeTag = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

phmap_flat_hash_map_UndirectedEdgeId_int

mrmeshpy.phmap_flat_hash_map_UndirectedEdgeId_int = phmap_flat_hash_map_Id_UndirectedEdgeTag_int

phmap_flat_hash_map_UndirectedEdgeId_UndirectedEdgeId

mrmeshpy.phmap_flat_hash_map_UndirectedEdgeId_UndirectedEdgeId = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

phmap_flat_hash_map_unsigned_long_long_std_array_VertId_3_phmap_Hash_uint64_t

mrmeshpy.phmap_flat_hash_map_unsigned_long_long_std_array_VertId_3_phmap_Hash_uint64_t = phmap_flat_hash_map_unsigned_long_long_std_array_Id_VertTag_3

phmap_flat_hash_map_VertId_float

mrmeshpy.phmap_flat_hash_map_VertId_float = phmap_flat_hash_map_Id_VertTag_float

phmap_flat_hash_map_VertId_FlowAggregator_Flows

mrmeshpy.phmap_flat_hash_map_VertId_FlowAggregator_Flows = phmap_flat_hash_map_Id_VertTag_FlowAggregator_Flows

phmap_flat_hash_map_VertId_VertId

mrmeshpy.phmap_flat_hash_map_VertId_VertId = phmap_flat_hash_map_Id_VertTag_Id_VertTag

phmap_flat_hash_map_VertId_VertPathInfo

mrmeshpy.phmap_flat_hash_map_VertId_VertPathInfo = phmap_flat_hash_map_Id_VertTag_VertPathInfo

PickedPoint

mrmeshpy.PickedPoint = std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int

PlaneSection

mrmeshpy.PlaneSection = std_vector_EdgePoint

PlaneSections

mrmeshpy.PlaneSections = std_vector_std_vector_EdgePoint

Polynomial_double_0ULL_0_0_0ULL_minus_1

mrmeshpy.Polynomial_double_0ULL_0_0_0ULL_minus_1 = Polynomial_double_0

Polynomial_double_1ULL_0_0_1ULL_minus_1

mrmeshpy.Polynomial_double_1ULL_0_0_1ULL_minus_1 = Polynomial_double_0

Polynomial_double_2ULL_0_0_2ULL_minus_1

mrmeshpy.Polynomial_double_2ULL_0_0_2ULL_minus_1 = Polynomial_double_1

Polynomial_double_3ULL_0_0_3ULL_minus_1

mrmeshpy.Polynomial_double_3ULL_0_0_3ULL_minus_1 = Polynomial_double_2

Polynomial_double_4ULL_0_0_4ULL_minus_1

mrmeshpy.Polynomial_double_4ULL_0_0_4ULL_minus_1 = Polynomial_double_3

Polynomial_double_5ULL_0_0_5ULL_minus_1

mrmeshpy.Polynomial_double_5ULL_0_0_5ULL_minus_1 = Polynomial_double_4

Polynomial_double_6ULL_0_0_6ULL_minus_1

mrmeshpy.Polynomial_double_6ULL_0_0_6ULL_minus_1 = Polynomial_double_5

Polynomial_float_0ULL_0_0_0ULL_minus_1

mrmeshpy.Polynomial_float_0ULL_0_0_0ULL_minus_1 = Polynomial_float_0

Polynomial_float_1ULL_0_0_1ULL_minus_1

mrmeshpy.Polynomial_float_1ULL_0_0_1ULL_minus_1 = Polynomial_float_0

Polynomial_float_2ULL_0_0_2ULL_minus_1

mrmeshpy.Polynomial_float_2ULL_0_0_2ULL_minus_1 = Polynomial_float_1

Polynomial_float_3ULL_0_0_3ULL_minus_1

mrmeshpy.Polynomial_float_3ULL_0_0_3ULL_minus_1 = Polynomial_float_2

Polynomial_float_4ULL_0_0_4ULL_minus_1

mrmeshpy.Polynomial_float_4ULL_0_0_4ULL_minus_1 = Polynomial_float_3

Polynomial_float_5ULL_0_0_5ULL_minus_1

mrmeshpy.Polynomial_float_5ULL_0_0_5ULL_minus_1 = Polynomial_float_4

Polynomial_float_6ULL_0_0_6ULL_minus_1

mrmeshpy.Polynomial_float_6ULL_0_0_6ULL_minus_1 = Polynomial_float_5

PolynomialWrapperd

mrmeshpy.PolynomialWrapperd = PolynomialWrapper_double

PolynomialWrapperf

mrmeshpy.PolynomialWrapperf = PolynomialWrapper_float

Polynomialx_double

mrmeshpy.Polynomialx_double = std_variant_Polynomial_double_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6

Polynomialx_float

mrmeshpy.Polynomialx_float = std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6

QuadraticForm_Vector2d_SM

mrmeshpy.QuadraticForm_Vector2d_SM = SymMatrix2d

QuadraticForm_Vector2f_SM

mrmeshpy.QuadraticForm_Vector2f_SM = SymMatrix2f

QuadraticForm_Vector3d_SM

mrmeshpy.QuadraticForm_Vector3d_SM = SymMatrix3d

QuadraticForm_Vector3f_SM

mrmeshpy.QuadraticForm_Vector3f_SM = SymMatrix3f

RigidScaleXf3_double_V

mrmeshpy.RigidScaleXf3_double_V = Vector3d

RigidScaleXf3_float_V

mrmeshpy.RigidScaleXf3_float_V = Vector3f

RigidXf3_double_V

mrmeshpy.RigidXf3_double_V = Vector3d

RigidXf3_float_V

mrmeshpy.RigidXf3_float_V = Vector3f

SeparationPointMap

mrmeshpy.SeparationPointMap = phmap_flat_hash_map_unsigned_long_long_std_array_Id_VertTag_3

SeparationPointSet

mrmeshpy.SeparationPointSet = std_array_Id_VertTag_3

std_array_AffineXf3d_4

mrmeshpy.std_array_AffineXf3d_4 = std_array_AffineXf_Vector3_double_4

std_array_AffineXf3f_4

mrmeshpy.std_array_AffineXf3f_4 = std_array_AffineXf_Vector3_float_4

std_array_BooleanResultMapper_Maps_size_t_MapObject_Count

mrmeshpy.std_array_BooleanResultMapper_Maps_size_t_MapObject_Count = std_array_BooleanResultMapper_Maps_2

std_array_SimpleVolumeMinMax_3

mrmeshpy.std_array_SimpleVolumeMinMax_3 = std_array_VoxelsVolumeMinMax_std_vector_float_3

std_array_std_filesystem_path_size_t_SystemFontType_Count

mrmeshpy.std_array_std_filesystem_path_size_t_SystemFontType_Count = std_array_std_filesystem_path_4

std_array_Vector3d_3

mrmeshpy.std_array_Vector3d_3 = std_array_Vector3_double_3

std_array_Vector3f_3

mrmeshpy.std_array_Vector3f_3 = std_array_Vector3_float_3

std_array_Vector3i_3

mrmeshpy.std_array_Vector3i_3 = std_array_Vector3_int_3

std_array_VertId_3

mrmeshpy.std_array_VertId_3 = std_array_Id_VertTag_3

std_optional_Box1f

mrmeshpy.std_optional_Box1f = std_optional_Box_float

std_optional_Box3f

mrmeshpy.std_optional_Box3f = std_optional_Box_Vector3_float

std_optional_Vector2f

mrmeshpy.std_optional_Vector2f = std_optional_Vector2_float

std_optional_Vector3f

mrmeshpy.std_optional_Vector3f = std_optional_Vector3_float

std_shared_ptr_ChangeActiveBoxAction_Obj

mrmeshpy.std_shared_ptr_ChangeActiveBoxAction_Obj = ObjectVoxels

std_shared_ptr_ChangeDualMarchingCubesAction_Obj

mrmeshpy.std_shared_ptr_ChangeDualMarchingCubesAction_Obj = ObjectVoxels

std_shared_ptr_ChangeGridAction_Obj

mrmeshpy.std_shared_ptr_ChangeGridAction_Obj = ObjectVoxels

std_shared_ptr_ChangeIsoAction_Obj

mrmeshpy.std_shared_ptr_ChangeIsoAction_Obj = ObjectVoxels

std_shared_ptr_ChangeSurfaceAction_Obj

mrmeshpy.std_shared_ptr_ChangeSurfaceAction_Obj = ObjectVoxels

std_shared_ptr_ChangVoxelSelectionAction_Obj

mrmeshpy.std_shared_ptr_ChangVoxelSelectionAction_Obj = ObjectVoxels

std_shared_ptr_GcodeSource

mrmeshpy.std_shared_ptr_GcodeSource = std_vector_std_string

std_unique_ptr_NoDefInit_Id_EdgeTag_pointer

mrmeshpy.std_unique_ptr_NoDefInit_Id_EdgeTag_pointer = NoDefInit_Id_EdgeTag

std_unique_ptr_NoDefInit_Id_ICPElemtTag_pointer

mrmeshpy.std_unique_ptr_NoDefInit_Id_ICPElemtTag_pointer = NoDefInit_Id_ICPElemtTag

std_unique_ptr_NoDefInit_Id_VoxelTag_pointer

mrmeshpy.std_unique_ptr_NoDefInit_Id_VoxelTag_pointer = NoDefInit_Id_VoxelTag

std_variant_FaceId_Id_EdgeTag_VertId

mrmeshpy.std_variant_FaceId_Id_EdgeTag_VertId = std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag

std_variant_float_Vector3f

mrmeshpy.std_variant_float_Vector3f = std_variant_float_Vector3_float

std_variant_MeshTriPoint_EdgePoint_VertId_int

mrmeshpy.std_variant_MeshTriPoint_EdgePoint_VertId_int = std_variant_MeshTriPoint_EdgePoint_Id_VertTag_int

std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane

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

mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box3f = std_vector_AABBTreeNode_AABBTreeTraits_FaceTag_Box_Vector3_float

std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f

mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box2f = std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector2_float

std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f

mrmeshpy.std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box3f = std_vector_AABBTreeNode_AABBTreeTraits_UndirectedEdgeTag_Box_Vector3_float

std_vector_AABBTreeNode_ObjTreeTraits_const_reference

mrmeshpy.std_vector_AABBTreeNode_ObjTreeTraits_const_reference = AABBTreeNode_ObjTreeTraits

std_vector_AABBTreeNode_ObjTreeTraits_reference

mrmeshpy.std_vector_AABBTreeNode_ObjTreeTraits_reference = AABBTreeNode_ObjTreeTraits

std_vector_AABBTreeNode_ObjTreeTraits_value_type

mrmeshpy.std_vector_AABBTreeNode_ObjTreeTraits_value_type = AABBTreeNode_ObjTreeTraits

std_vector_AABBTreePoints_Node_const_reference

mrmeshpy.std_vector_AABBTreePoints_Node_const_reference = AABBTreePoints.Node

std_vector_AABBTreePoints_Node_reference

mrmeshpy.std_vector_AABBTreePoints_Node_reference = AABBTreePoints.Node

std_vector_AABBTreePoints_Node_value_type

mrmeshpy.std_vector_AABBTreePoints_Node_value_type = AABBTreePoints.Node

std_vector_AffineXf3f

mrmeshpy.std_vector_AffineXf3f = std_vector_AffineXf_Vector3_float

std_vector_Color_const_reference

mrmeshpy.std_vector_Color_const_reference = Color

std_vector_Color_reference

mrmeshpy.std_vector_Color_reference = Color

std_vector_Color_value_type

mrmeshpy.std_vector_Color_value_type = Color

std_vector_const_Mesh

mrmeshpy.std_vector_const_Mesh = std_vector_Mesh_const

std_vector_ContinuousContour

mrmeshpy.std_vector_ContinuousContour = std_vector_std_vector_VariableEdgeTri

std_vector_Dipole_const_reference

mrmeshpy.std_vector_Dipole_const_reference = Dipole

std_vector_Dipole_reference

mrmeshpy.std_vector_Dipole_reference = Dipole

std_vector_Dipole_value_type

mrmeshpy.std_vector_Dipole_value_type = Dipole

std_vector_EdgeBitSet

mrmeshpy.std_vector_EdgeBitSet = std_vector_TaggedBitSet_EdgeTag

std_vector_EdgeId

mrmeshpy.std_vector_EdgeId = std_vector_Id_EdgeTag

std_vector_EdgeLoop

mrmeshpy.std_vector_EdgeLoop = std_vector_std_vector_Id_EdgeTag

std_vector_EdgePair

mrmeshpy.std_vector_EdgePair = std_vector_std_pair_Id_EdgeTag_Id_EdgeTag

std_vector_EdgePath

mrmeshpy.std_vector_EdgePath = std_vector_std_vector_Id_EdgeTag

std_vector_FaceBitSet

mrmeshpy.std_vector_FaceBitSet = std_vector_TaggedBitSet_FaceTag

std_vector_FaceId

mrmeshpy.std_vector_FaceId = std_vector_Id_FaceTag

std_vector_FanRecord_const_reference

mrmeshpy.std_vector_FanRecord_const_reference = FanRecord

std_vector_FanRecord_reference

mrmeshpy.std_vector_FanRecord_reference = FanRecord

std_vector_FanRecord_value_type

mrmeshpy.std_vector_FanRecord_value_type = FanRecord

std_vector_Graph_EndVertices_const_reference

mrmeshpy.std_vector_Graph_EndVertices_const_reference = Graph.EndVertices

std_vector_Graph_EndVertices_reference

mrmeshpy.std_vector_Graph_EndVertices_reference = Graph.EndVertices

std_vector_Graph_EndVertices_value_type

mrmeshpy.std_vector_Graph_EndVertices_value_type = Graph.EndVertices

std_vector_GraphEdgeId

mrmeshpy.std_vector_GraphEdgeId = std_vector_Id_GraphEdgeTag

std_vector_GraphVertId

mrmeshpy.std_vector_GraphVertId = std_vector_Id_GraphVertTag

std_vector_Heap_float_GraphVertId_std_greater_float_Element

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

mrmeshpy.std_vector_ICPGroupPairs_const_reference = ICPGroupPairs

std_vector_ICPGroupPairs_reference

mrmeshpy.std_vector_ICPGroupPairs_reference = ICPGroupPairs

std_vector_ICPGroupPairs_value_type

mrmeshpy.std_vector_ICPGroupPairs_value_type = ICPGroupPairs

std_vector_Id_EdgeTag_const_reference

mrmeshpy.std_vector_Id_EdgeTag_const_reference = Id_EdgeTag

std_vector_Id_EdgeTag_reference

mrmeshpy.std_vector_Id_EdgeTag_reference = Id_EdgeTag

std_vector_Id_EdgeTag_value_type

mrmeshpy.std_vector_Id_EdgeTag_value_type = Id_EdgeTag

std_vector_Id_ICPElemtTag_const_reference

mrmeshpy.std_vector_Id_ICPElemtTag_const_reference = Id_ICPElemtTag

std_vector_Id_ICPElemtTag_reference

mrmeshpy.std_vector_Id_ICPElemtTag_reference = Id_ICPElemtTag

std_vector_Id_ICPElemtTag_value_type

mrmeshpy.std_vector_Id_ICPElemtTag_value_type = Id_ICPElemtTag

std_vector_Id_VoxelTag_const_reference

mrmeshpy.std_vector_Id_VoxelTag_const_reference = Id_VoxelTag

std_vector_Id_VoxelTag_reference

mrmeshpy.std_vector_Id_VoxelTag_reference = Id_VoxelTag

std_vector_Id_VoxelTag_value_type

mrmeshpy.std_vector_Id_VoxelTag_value_type = Id_VoxelTag

std_vector_Line3dMesh

mrmeshpy.std_vector_Line3dMesh = std_vector_Line3Mesh_double

std_vector_Line3fMesh

mrmeshpy.std_vector_Line3fMesh = std_vector_Line3Mesh_float

std_vector_LineSegm3f

mrmeshpy.std_vector_LineSegm3f = std_vector_LineSegm_Vector3_float

std_vector_MeshBuilder_VertSpan_const_reference

mrmeshpy.std_vector_MeshBuilder_VertSpan_const_reference = MeshBuilder.VertSpan

std_vector_MeshBuilder_VertSpan_reference

mrmeshpy.std_vector_MeshBuilder_VertSpan_reference = MeshBuilder.VertSpan

std_vector_MeshBuilder_VertSpan_value_type

mrmeshpy.std_vector_MeshBuilder_VertSpan_value_type = MeshBuilder.VertSpan

std_vector_MeshEdgePoint

mrmeshpy.std_vector_MeshEdgePoint = std_vector_EdgePoint

std_vector_MeshOrPointsXf_const_reference

mrmeshpy.std_vector_MeshOrPointsXf_const_reference = MeshOrPointsXf

std_vector_MeshOrPointsXf_reference

mrmeshpy.std_vector_MeshOrPointsXf_reference = MeshOrPointsXf

std_vector_MeshOrPointsXf_value_type

mrmeshpy.std_vector_MeshOrPointsXf_value_type = MeshOrPointsXf

std_vector_MeshTexture_const_reference

mrmeshpy.std_vector_MeshTexture_const_reference = MeshTexture

std_vector_MeshTexture_reference

mrmeshpy.std_vector_MeshTexture_reference = MeshTexture

std_vector_MeshTexture_value_type

mrmeshpy.std_vector_MeshTexture_value_type = MeshTexture

std_vector_ModelPointsData_const_reference

mrmeshpy.std_vector_ModelPointsData_const_reference = ModelPointsData

std_vector_ModelPointsData_reference

mrmeshpy.std_vector_ModelPointsData_reference = ModelPointsData

std_vector_ModelPointsData_value_type

mrmeshpy.std_vector_ModelPointsData_value_type = ModelPointsData

std_vector_NodeId

mrmeshpy.std_vector_NodeId = std_vector_Id_NodeTag

std_vector_ObjectPtr

mrmeshpy.std_vector_ObjectPtr = std_vector_std_shared_ptr_Object

std_vector_ObjId

mrmeshpy.std_vector_ObjId = std_vector_Id_ObjTag

std_vector_OffsetContoursVertMap

mrmeshpy.std_vector_OffsetContoursVertMap = std_vector_std_vector_OffsetContoursOrigins

std_vector_PixelId

mrmeshpy.std_vector_PixelId = std_vector_Id_PixelTag

std_vector_PlanarTriangulation_ContourIdMap

mrmeshpy.std_vector_PlanarTriangulation_ContourIdMap = std_vector_std_vector_PlanarTriangulation_IntersectionInfo

std_vector_Polyline3

mrmeshpy.std_vector_Polyline3 = std_vector_Polyline_Vector3_float

std_vector_QuadraticForm2f

mrmeshpy.std_vector_QuadraticForm2f = std_vector_QuadraticForm_Vector2_float

std_vector_QuadraticForm3f

mrmeshpy.std_vector_QuadraticForm3f = std_vector_QuadraticForm_Vector3_float

std_vector_RegionId

mrmeshpy.std_vector_RegionId = std_vector_Id_RegionTag

std_vector_RigidXf3d

mrmeshpy.std_vector_RigidXf3d = std_vector_RigidXf3_double

std_vector_size_t

mrmeshpy.std_vector_size_t = std_vector_unsigned_long_long

std_vector_std_array_Vector3f_3

mrmeshpy.std_vector_std_array_Vector3f_3 = std_vector_std_array_Vector3_float_3

std_vector_std_array_VertId_3

mrmeshpy.std_vector_std_array_VertId_3 = std_vector_std_array_Id_VertTag_3

std_vector_std_pair_size_t_size_t

mrmeshpy.std_vector_std_pair_size_t_size_t = std_vector_std_pair_unsigned_long_long_unsigned_long_long

std_vector_std_pair_Vector3f_Vector3f

mrmeshpy.std_vector_std_pair_Vector3f_Vector3f = std_vector_std_pair_Vector3_float_Vector3_float

std_vector_std_pair_VertId_VertId

mrmeshpy.std_vector_std_pair_VertId_VertId = std_vector_std_pair_Id_VertTag_Id_VertTag

std_vector_std_shared_ptr_const_Object

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

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

mrmeshpy.std_vector_std_vector_EdgePoint_const_reference = std_vector_EdgePoint

std_vector_std_vector_EdgePoint_reference

mrmeshpy.std_vector_std_vector_EdgePoint_reference = std_vector_EdgePoint

std_vector_std_vector_EdgePoint_value_type

mrmeshpy.std_vector_std_vector_EdgePoint_value_type = std_vector_EdgePoint

std_vector_std_vector_GraphEdgeId

mrmeshpy.std_vector_std_vector_GraphEdgeId = std_vector_std_vector_Id_GraphEdgeTag

std_vector_std_vector_ObjVertId_const_reference

mrmeshpy.std_vector_std_vector_ObjVertId_const_reference = std_vector_ObjVertId

std_vector_std_vector_ObjVertId_reference

mrmeshpy.std_vector_std_vector_ObjVertId_reference = std_vector_ObjVertId

std_vector_std_vector_ObjVertId_value_type

mrmeshpy.std_vector_std_vector_ObjVertId_value_type = std_vector_ObjVertId

std_vector_std_vector_Vector2d

mrmeshpy.std_vector_std_vector_Vector2d = std_vector_std_vector_Vector2_double

std_vector_std_vector_Vector2f

mrmeshpy.std_vector_std_vector_Vector2f = std_vector_std_vector_Vector2_float

std_vector_std_vector_Vector3d

mrmeshpy.std_vector_std_vector_Vector3d = std_vector_std_vector_Vector3_double

std_vector_std_vector_Vector3f

mrmeshpy.std_vector_std_vector_Vector3f = std_vector_std_vector_Vector3_float

std_vector_std_vector_VertId

mrmeshpy.std_vector_std_vector_VertId = std_vector_std_vector_Id_VertTag

std_vector_SurfacePath

mrmeshpy.std_vector_SurfacePath = std_vector_std_vector_EdgePoint

std_vector_SystemPath_SystemFontPaths

mrmeshpy.std_vector_SystemPath_SystemFontPaths = std_vector_std_array_std_filesystem_path_4

std_vector_TextureId

mrmeshpy.std_vector_TextureId = std_vector_Id_TextureTag

std_vector_tl_expected_VoxelsLoad_DicomVolume_std_string

mrmeshpy.std_vector_tl_expected_VoxelsLoad_DicomVolume_std_string = std_vector_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_vector_float_std_string

std_vector_tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string

mrmeshpy.std_vector_tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string = std_vector_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid_std_string

std_vector_TriPointf

mrmeshpy.std_vector_TriPointf = std_vector_TriPoint_float

std_vector_uint8_t

mrmeshpy.std_vector_uint8_t = std_vector_unsigned_char

std_vector_UndirectedEdgeBitSet

mrmeshpy.std_vector_UndirectedEdgeBitSet = std_vector_TaggedBitSet_UndirectedEdgeTag

std_vector_UndirectedEdgeId

mrmeshpy.std_vector_UndirectedEdgeId = std_vector_Id_UndirectedEdgeTag

std_vector_VdbVolume

mrmeshpy.std_vector_VdbVolume = std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid

std_vector_Vector2d

mrmeshpy.std_vector_Vector2d = std_vector_Vector2_double

std_vector_Vector2f

mrmeshpy.std_vector_Vector2f = std_vector_Vector2_float

std_vector_Vector3d

mrmeshpy.std_vector_Vector3d = std_vector_Vector3_double

std_vector_Vector3f

mrmeshpy.std_vector_Vector3f = std_vector_Vector3_float

std_vector_Vector3i

mrmeshpy.std_vector_Vector3i = std_vector_Vector3_int

std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_const_reference

mrmeshpy.std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_const_reference = Vector_ICPGroupPairs_Id_ICPElemtTag

std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_reference

mrmeshpy.std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_reference = Vector_ICPGroupPairs_Id_ICPElemtTag

std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_value_type

mrmeshpy.std_vector_Vector_ICPGroupPairs_Id_ICPElemtTag_value_type = Vector_ICPGroupPairs_Id_ICPElemtTag

std_vector_Vector_std_vector_ObjVertId_Id_ICPElemtTag_const_reference

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

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

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

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

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

mrmeshpy.std_vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_value_type = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

std_vector_VertBitSet

mrmeshpy.std_vector_VertBitSet = std_vector_TaggedBitSet_VertTag

std_vector_VertId

mrmeshpy.std_vector_VertId = std_vector_Id_VertTag

std_vector_VoxelBitSet

mrmeshpy.std_vector_VoxelBitSet = std_vector_TaggedBitSet_VoxelTag

std_vector_WatershedGraph_BasinInfo_const_reference

mrmeshpy.std_vector_WatershedGraph_BasinInfo_const_reference = WatershedGraph.BasinInfo

std_vector_WatershedGraph_BasinInfo_reference

mrmeshpy.std_vector_WatershedGraph_BasinInfo_reference = WatershedGraph.BasinInfo

std_vector_WatershedGraph_BasinInfo_value_type

mrmeshpy.std_vector_WatershedGraph_BasinInfo_value_type = WatershedGraph.BasinInfo

std_vector_WatershedGraph_BdInfo_const_reference

mrmeshpy.std_vector_WatershedGraph_BdInfo_const_reference = WatershedGraph.BdInfo

std_vector_WatershedGraph_BdInfo_reference

mrmeshpy.std_vector_WatershedGraph_BdInfo_reference = WatershedGraph.BdInfo

std_vector_WatershedGraph_BdInfo_value_type

mrmeshpy.std_vector_WatershedGraph_BdInfo_value_type = WatershedGraph.BdInfo

SurfacePath

mrmeshpy.SurfacePath = std_vector_EdgePoint

SurfacePaths

mrmeshpy.SurfacePaths = std_vector_std_vector_EdgePoint

TaggedBitSet_EdgeTag_IndexType

mrmeshpy.TaggedBitSet_EdgeTag_IndexType = Id_EdgeTag

TaggedBitSet_FaceTag_IndexType

mrmeshpy.TaggedBitSet_FaceTag_IndexType = FaceId

TaggedBitSet_GraphEdgeTag_IndexType

mrmeshpy.TaggedBitSet_GraphEdgeTag_IndexType = GraphEdgeId

TaggedBitSet_GraphVertTag_IndexType

mrmeshpy.TaggedBitSet_GraphVertTag_IndexType = GraphVertId

TaggedBitSet_NodeTag_IndexType

mrmeshpy.TaggedBitSet_NodeTag_IndexType = NodeId

TaggedBitSet_ObjTag_IndexType

mrmeshpy.TaggedBitSet_ObjTag_IndexType = ObjId

TaggedBitSet_PixelTag_IndexType

mrmeshpy.TaggedBitSet_PixelTag_IndexType = PixelId

TaggedBitSet_RegionTag_IndexType

mrmeshpy.TaggedBitSet_RegionTag_IndexType = RegionId

TaggedBitSet_TextureTag_IndexType

mrmeshpy.TaggedBitSet_TextureTag_IndexType = TextureId

TaggedBitSet_UndirectedEdgeTag_IndexType

mrmeshpy.TaggedBitSet_UndirectedEdgeTag_IndexType = UndirectedEdgeId

TaggedBitSet_VertTag_IndexType

mrmeshpy.TaggedBitSet_VertTag_IndexType = VertId

TaggedBitSet_VoxelTag_IndexType

mrmeshpy.TaggedBitSet_VoxelTag_IndexType = Id_VoxelTag

TextAlignParams

mrmeshpy.TextAlignParams = TextMeshAlignParams

ThreePoints

mrmeshpy.ThreePoints = std_array_Vector3_float_3

ThreeVertIds

mrmeshpy.ThreeVertIds = std_array_Id_VertTag_3

tl_expected_VoxelsLoad_DicomVolume_std_string

mrmeshpy.tl_expected_VoxelsLoad_DicomVolume_std_string = expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_vector_float_std_string

tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string

mrmeshpy.tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string = expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid_std_string

Triangle3d

mrmeshpy.Triangle3d = std_array_Vector3_double_3

Triangle3f

mrmeshpy.Triangle3f = std_array_Vector3_float_3

Triangle3i

mrmeshpy.Triangle3i = std_array_Vector3_int_3

TriangleCornerNormals

mrmeshpy.TriangleCornerNormals = std_array_Vector3_float_3

TrianglesRepetitions

mrmeshpy.TrianglesRepetitions = std_array_int_4

TriangulationHelpersSettings

mrmeshpy.TriangulationHelpersSettings = TriangulationHelpers.Settings

UndirectedEdgeHashMap

mrmeshpy.UndirectedEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

UVCoord

mrmeshpy.UVCoord = Vector2f

VdbVolumes

mrmeshpy.VdbVolumes = std_vector_VoxelsVolumeMinMax_std_shared_ptr_OpenVdbFloatGrid

Vector2_bool_MatrixType

mrmeshpy.Vector2_bool_MatrixType = Matrix2b

Vector2_bool_SymMatrixType

mrmeshpy.Vector2_bool_SymMatrixType = SymMatrix2b

Vector2_double_MatrixType

mrmeshpy.Vector2_double_MatrixType = Matrix2d

Vector2_double_SymMatrixType

mrmeshpy.Vector2_double_SymMatrixType = SymMatrix2d

Vector2_float_MatrixType

mrmeshpy.Vector2_float_MatrixType = Matrix2f

Vector2_float_SymMatrixType

mrmeshpy.Vector2_float_SymMatrixType = SymMatrix2f

Vector2_int_MatrixType

mrmeshpy.Vector2_int_MatrixType = Matrix2i

Vector2_int_SymMatrixType

mrmeshpy.Vector2_int_SymMatrixType = SymMatrix2i

Vector2_long_long_MatrixType

mrmeshpy.Vector2_long_long_MatrixType = Matrix2ll

Vector2_long_long_SymMatrixType

mrmeshpy.Vector2_long_long_SymMatrixType = SymMatrix2ll

Vector3_bool_MatrixType

mrmeshpy.Vector3_bool_MatrixType = Matrix3b

Vector3_bool_SymMatrixType

mrmeshpy.Vector3_bool_SymMatrixType = SymMatrix3b

Vector3_double_MatrixType

mrmeshpy.Vector3_double_MatrixType = Matrix3d

Vector3_double_SymMatrixType

mrmeshpy.Vector3_double_SymMatrixType = SymMatrix3d

Vector3_float_MatrixType

mrmeshpy.Vector3_float_MatrixType = Matrix3f

Vector3_float_SymMatrixType

mrmeshpy.Vector3_float_SymMatrixType = SymMatrix3f

Vector3_int_MatrixType

mrmeshpy.Vector3_int_MatrixType = Matrix3i

Vector3_int_SymMatrixType

mrmeshpy.Vector3_int_SymMatrixType = SymMatrix3i

Vector3_long_long_MatrixType

mrmeshpy.Vector3_long_long_MatrixType = Matrix3ll

Vector3_long_long_SymMatrixType

mrmeshpy.Vector3_long_long_SymMatrixType = SymMatrix3ll

Vector4_bool_MatrixType

mrmeshpy.Vector4_bool_MatrixType = Matrix4b

Vector4_bool_SymMatrixType

mrmeshpy.Vector4_bool_SymMatrixType = SymMatrix4b

Vector4_double_MatrixType

mrmeshpy.Vector4_double_MatrixType = Matrix4d

Vector4_double_SymMatrixType

mrmeshpy.Vector4_double_SymMatrixType = SymMatrix4d

Vector4_float_MatrixType

mrmeshpy.Vector4_float_MatrixType = Matrix4f

Vector4_float_SymMatrixType

mrmeshpy.Vector4_float_SymMatrixType = SymMatrix4f

Vector4_int_MatrixType

mrmeshpy.Vector4_int_MatrixType = Matrix4i

Vector4_int_SymMatrixType

mrmeshpy.Vector4_int_SymMatrixType = SymMatrix4i

Vector4_long_long_MatrixType

mrmeshpy.Vector4_long_long_MatrixType = Matrix4ll

Vector4_long_long_SymMatrixType

mrmeshpy.Vector4_long_long_SymMatrixType = SymMatrix4ll

Vector_Color_FaceId_const_reference

mrmeshpy.Vector_Color_FaceId_const_reference = Color

Vector_Color_FaceId_reference

mrmeshpy.Vector_Color_FaceId_reference = Color

Vector_Color_FaceId_value_type

mrmeshpy.Vector_Color_FaceId_value_type = Color

Vector_Color_Id_EdgeTag_const_reference

mrmeshpy.Vector_Color_Id_EdgeTag_const_reference = Color

Vector_Color_Id_EdgeTag_reference

mrmeshpy.Vector_Color_Id_EdgeTag_reference = Color

Vector_Color_Id_EdgeTag_value_type

mrmeshpy.Vector_Color_Id_EdgeTag_value_type = Color

Vector_Color_UndirectedEdgeId_const_reference

mrmeshpy.Vector_Color_UndirectedEdgeId_const_reference = Color

Vector_Color_UndirectedEdgeId_reference

mrmeshpy.Vector_Color_UndirectedEdgeId_reference = Color

Vector_Color_UndirectedEdgeId_value_type

mrmeshpy.Vector_Color_UndirectedEdgeId_value_type = Color

Vector_Color_VertId_const_reference

mrmeshpy.Vector_Color_VertId_const_reference = Color

Vector_Color_VertId_reference

mrmeshpy.Vector_Color_VertId_reference = Color

Vector_Color_VertId_value_type

mrmeshpy.Vector_Color_VertId_value_type = Color

Vector_Dipole_NodeId_const_reference

mrmeshpy.Vector_Dipole_NodeId_const_reference = Dipole

Vector_Dipole_NodeId_reference

mrmeshpy.Vector_Dipole_NodeId_reference = Dipole

Vector_Dipole_NodeId_value_type

mrmeshpy.Vector_Dipole_NodeId_value_type = Dipole

Vector_FaceId_FaceId_const_reference

mrmeshpy.Vector_FaceId_FaceId_const_reference = FaceId

Vector_FaceId_FaceId_reference

mrmeshpy.Vector_FaceId_FaceId_reference = FaceId

Vector_FaceId_FaceId_value_type

mrmeshpy.Vector_FaceId_FaceId_value_type = FaceId

Vector_ICPPairsGrid_ICPLayer

mrmeshpy.Vector_ICPPairsGrid_ICPLayer = Vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_int

Vector_Id_EdgeTag_Id_EdgeTag_const_reference

mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_const_reference = Id_EdgeTag

Vector_Id_EdgeTag_Id_EdgeTag_reference

mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_reference = Id_EdgeTag

Vector_Id_EdgeTag_Id_EdgeTag_value_type

mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_value_type = Id_EdgeTag

Vector_Id_EdgeTag_UndirectedEdgeId_const_reference

mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_const_reference = Id_EdgeTag

Vector_Id_EdgeTag_UndirectedEdgeId_reference

mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_reference = Id_EdgeTag

Vector_Id_EdgeTag_UndirectedEdgeId_value_type

mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_value_type = Id_EdgeTag

Vector_ObjId_ObjId_const_reference

mrmeshpy.Vector_ObjId_ObjId_const_reference = ObjId

Vector_ObjId_ObjId_reference

mrmeshpy.Vector_ObjId_ObjId_reference = ObjId

Vector_ObjId_ObjId_value_type

mrmeshpy.Vector_ObjId_ObjId_value_type = ObjId

Vector_RegionId_FaceId_const_reference

mrmeshpy.Vector_RegionId_FaceId_const_reference = RegionId

Vector_RegionId_FaceId_reference

mrmeshpy.Vector_RegionId_FaceId_reference = RegionId

Vector_RegionId_FaceId_value_type

mrmeshpy.Vector_RegionId_FaceId_value_type = RegionId

Vector_RegionId_UndirectedEdgeId_const_reference

mrmeshpy.Vector_RegionId_UndirectedEdgeId_const_reference = RegionId

Vector_RegionId_UndirectedEdgeId_reference

mrmeshpy.Vector_RegionId_UndirectedEdgeId_reference = RegionId

Vector_RegionId_UndirectedEdgeId_value_type

mrmeshpy.Vector_RegionId_UndirectedEdgeId_value_type = RegionId

Vector_RegionId_VertId_const_reference

mrmeshpy.Vector_RegionId_VertId_const_reference = RegionId

Vector_RegionId_VertId_reference

mrmeshpy.Vector_RegionId_VertId_reference = RegionId

Vector_RegionId_VertId_value_type

mrmeshpy.Vector_RegionId_VertId_value_type = RegionId

Vector_std_array_VertId_3_FaceId_const_reference

mrmeshpy.Vector_std_array_VertId_3_FaceId_const_reference = std_array_Id_VertTag_3

Vector_std_array_VertId_3_FaceId_reference

mrmeshpy.Vector_std_array_VertId_3_FaceId_reference = std_array_Id_VertTag_3

Vector_std_array_VertId_3_FaceId_value_type

mrmeshpy.Vector_std_array_VertId_3_FaceId_value_type = std_array_Id_VertTag_3

Vector_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType

mrmeshpy.Vector_TaggedBitSet_ICPElemtTag_IndexType_TaggedBitSet_ICPElemtTag_IndexType = Vector_Id_ICPElemtTag_Id_ICPElemtTag

Vector_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType

mrmeshpy.Vector_TaggedBitSet_VoxelTag_IndexType_TaggedBitSet_VoxelTag_IndexType = Vector_Id_VoxelTag_Id_VoxelTag

Vector_TextureId_FaceId_const_reference

mrmeshpy.Vector_TextureId_FaceId_const_reference = TextureId

Vector_TextureId_FaceId_reference

mrmeshpy.Vector_TextureId_FaceId_reference = TextureId

Vector_TextureId_FaceId_value_type

mrmeshpy.Vector_TextureId_FaceId_value_type = TextureId

Vector_UndirectedEdgeId_UndirectedEdgeId_const_reference

mrmeshpy.Vector_UndirectedEdgeId_UndirectedEdgeId_const_reference = UndirectedEdgeId

Vector_UndirectedEdgeId_UndirectedEdgeId_reference

mrmeshpy.Vector_UndirectedEdgeId_UndirectedEdgeId_reference = UndirectedEdgeId

Vector_UndirectedEdgeId_UndirectedEdgeId_value_type

mrmeshpy.Vector_UndirectedEdgeId_UndirectedEdgeId_value_type = UndirectedEdgeId

Vector_Vector2f_VertId_const_reference

mrmeshpy.Vector_Vector2f_VertId_const_reference = Vector2f

Vector_Vector2f_VertId_reference

mrmeshpy.Vector_Vector2f_VertId_reference = Vector2f

Vector_Vector2f_VertId_value_type

mrmeshpy.Vector_Vector2f_VertId_value_type = Vector2f

Vector_Vector3f_FaceId_const_reference

mrmeshpy.Vector_Vector3f_FaceId_const_reference = Vector3f

Vector_Vector3f_FaceId_reference

mrmeshpy.Vector_Vector3f_FaceId_reference = Vector3f

Vector_Vector3f_FaceId_value_type

mrmeshpy.Vector_Vector3f_FaceId_value_type = Vector3f

Vector_Vector3f_VertId_const_reference

mrmeshpy.Vector_Vector3f_VertId_const_reference = Vector3f

Vector_Vector3f_VertId_reference

mrmeshpy.Vector_Vector3f_VertId_reference = Vector3f

Vector_Vector3f_VertId_value_type

mrmeshpy.Vector_Vector3f_VertId_value_type = Vector3f

Vector_Vector_ICPGroupPairs_ICPElementId_ICPElementId

mrmeshpy.Vector_Vector_ICPGroupPairs_ICPElementId_ICPElementId = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

Vector_VertId_VertId_const_reference

mrmeshpy.Vector_VertId_VertId_const_reference = VertId

Vector_VertId_VertId_reference

mrmeshpy.Vector_VertId_VertId_reference = VertId

Vector_VertId_VertId_value_type

mrmeshpy.Vector_VertId_VertId_value_type = VertId

vectorConstMeshPtr

mrmeshpy.vectorConstMeshPtr = std_vector_Mesh_const

vectorEdges

mrmeshpy.vectorEdges = std_vector_Id_EdgeTag

VertHashMap

mrmeshpy.VertHashMap = phmap_flat_hash_map_Id_VertTag_Id_VertTag

VertNormals

mrmeshpy.VertNormals = VertCoords

VertPathInfoMap

mrmeshpy.VertPathInfoMap = phmap_flat_hash_map_Id_VertTag_VertPathInfo

ViewportProperty_uint8_t

mrmeshpy.ViewportProperty_uint8_t = ViewportProperty_unsigned_char

VoxelId

mrmeshpy.VoxelId = Id_VoxelTag

VoxelsSaveSavingSettings

mrmeshpy.VoxelsSaveSavingSettings = VoxelsSave.SavingSettings

WholeEdgeHashMap

mrmeshpy.WholeEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag