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	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
class	BMap_GraphEdgeId_GraphEdgeId
class	BMap_GraphVertId_GraphVertId
class	BMap_Id_ICPElemtTag_Id_ICPElemtTag
class	BMap_NodeId_NodeId
class	BMap_ObjId_ObjId
class	BMap_PixelId_PixelId
class	BMap_RegionId_RegionId
class	BMap_TextureId_TextureId
class	BMap_UndirectedEdgeId_unsigned_long
class	BMap_VertId_unsigned_long
class	BMap_VoxelId_VoxelId
class	bool_output
class	BooleanInternalParameters
class	BooleanOperation
class	BooleanParameters
class	BooleanPreCutResult
class	BooleanResult
class	BooleanResultMapper
class	BooleanResultPoints
class	Box1d
class	Box1f
class	Box1i
class	Box1i64
class	Box2d
class	Box2f
class	Box2i
class	Box2i64
class	Box3d
class	Box3f
class	Box3i
class	Box3i64
class	Box_unsigned_short
class	Buffer_char
class	Buffer_EdgeId_EdgeId
class	Buffer_EdgeId_UndirectedEdgeId
class	Buffer_FaceId
class	Buffer_FaceId_FaceId
class	Buffer_GraphEdgeId_GraphEdgeId
class	Buffer_GraphVertId_GraphVertId
class	Buffer_Id_ICPElemtTag_Id_ICPElemtTag
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	Buffer_VoxelId_VoxelId
class	BypassDirection
class	ChangeActiveBoxAction
class	ChangeColoringType
class	ChangeDualMarchingCubesAction
class	ChangeFacesColorMapAction
class	ChangeGridAction
class	ChangeIsoAction
class	ChangeLabelAction
class	ChangeLinesColorMapAction
class	ChangeMeshAction
class	ChangeMeshCreasesAction
class	ChangeMeshDataAction
class	ChangeMeshEdgeSelectionAction
class	ChangeMeshFaceSelectionAction
class	ChangeMeshPointsAction
class	ChangeMeshTexturePerFaceAction
class	ChangeMeshTopologyAction
class	ChangeMeshUVCoordsAction
class	ChangeNameAction
class	ChangeObjectAction
class	ChangeObjectColorAction
class	ChangeObjectSelectedAction
class	ChangeObjectVisibilityAction
class	ChangeOneNormalInCloudAction
class	ChangeOnePointInCloudAction
class	ChangeOnePointInPolylineAction
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	ChangeVisualizePropertyAction
class	ChangeXfAction
class	ChangVoxelSelectionAction
class	char_output
class	Chunk
class	ChunkIterator
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	ComputeSweptVolumeParameters
class	Cone3ApproximationParams
class	Cone3d
class	Cone3f
class	ConeFitterType
class	ConeObject
class	ConstantCuspParams
class	ContoursDistanceMapOffset
class	ContoursDistanceMapOptions
class	ContoursMeshAlignParams
class	ContourToDistanceMapParams
class	CoordinateConverters
class	CoordinateConverters2
class	CubicBezierCurve2d
class	CubicBezierCurve2f
class	CubicBezierCurve3d
class	CubicBezierCurve3f
class	CutByProjectionSettings
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	DistanceFromWeightedPointsComputeParams
class	DistanceFromWeightedPointsParams
class	DistanceMap
class	DistanceMapLoad
class	DistanceMapLoadSettings
class	DistanceMapSave
class	DistanceMapSaveSettings
class	DistanceMapToWorld
class	DistanceMeasurementObject
class	DistanceToMeshOptions
class	DistanceVolumeParams
class	DividePointCloudOptionalOutput
class	DividePolylineParameters
class	double_output
class	DoubleOffsetSettings
class	EdgeBitSet
class	EdgeBMap
class	EdgeColors
class	EdgeId
class	EdgeLengthMesh
class	EdgeMap
class	EdgePathsAStarBuilder
class	EdgePathsBuilderT_MetricToAStarPenalty
class	EdgePathsBuilderT_TrivialMetricToPenalty
class	EdgePoint
class	EdgePointPair
class	Edges
class	EdgeScalars
class	EdgeSegment
class	EdgeTri
class	EdgeWeights
class	EmbeddedStructureParameters
class	EndMillCutter
class	EndMillTool
class	EnumNeihbourFaces
class	EnumNeihbourVertices
class	expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_FloatGrid_std_string
class	expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_Vector_float_Id_VoxelTag_std_string
class	ExtremeEdgeType
class	Face2RegionMap
class	FaceBitSet
class	FaceBMap
class	FaceColorMapAggregator
class	FaceColors
class	FaceDistancesSettings
class	FaceFace
class	FaceFaceFace
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	FillingSurface
class	FilterType
class	FindDisorientationParams
class	FindInnerShellSettings
class	FindOutliersParams
class	FindOverhangsSettings
class	FindOverlappingSettings
class	FindProjectionOnPointsSettings
class	FixCreasesParams
class	FixMeshDegeneraciesParams
class	FixUndercuts
class	FlipEdge
class	float_output
class	FloatGrid
class	FloatGridComponents
class	FlowAggregator
class	FlowOrigin
class	FreeFormBestFit
class	FreeFormDeformer
class	func_AABBTree
class	func_AABBTreePoints
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_VertTag
class	func_bool_from_MeshIntersectionResult
class	func_bool_from_MeshProjectionResult
class	func_bool_from_Object
class	func_bool_from_std_shared_ptr_HistoryAction
class	func_bool_from_unsigned_long_unsigned_long
class	func_bool_from_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long
class	func_bool_from_Vector3_float_MeshOrPoints_ProjectionResult
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_TypedBitSet_Id_FaceTag_FixUndercuts_FindParams
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
class	func_float_from_unsigned_long_unsigned_long
class	func_float_from_Vector3_int
class	func_MeshOrPoints_ProjectionResult_from_Vector3_float
class	func_MeshTriPoint_from_unsigned_long
class	func_Pdf_CellCustomParams_from_int_int_std_string
class	func_Processing_from_EdgePoint_double_double_double
class	func_Processing_from_EdgePoint_float_float_float
class	func_Processing_from_Id_FaceTag_Ball_Vector3_float
class	func_Processing_from_MeshProjectionResult_Ball_Vector3_float
class	func_Processing_from_PointsProjectionResult_Vector3_float_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_tl_expected_void_std_string_from_std_vector_float_Vector3_int_int
class	func_TypedBitSet_Id_FaceTag_const_from_unsigned_long
class	func_unsigned_char_from_Vector3_int
class	func_Vector2_float_from_Vector2_int
class	func_Vector2_int_from_Vector2_float
class	func_Vector3_float_from_Id_VertTag
class	func_Vector3_float_from_unsigned_long_unsigned_long
class	func_Vector3_float_from_Vector3_float
class	func_Vector3_float_from_Vector3_float_Vector3_float_float_float_float
class	func_Vector3_float_from_Vector3_int
class	func_Vector3_int_from_Vector3_float
class	func_void
class	func_void_from_AABBTree
class	func_void_from_AABBTreePoints
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_Pdf
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_Id_ObjTag
class	func_VoxelsVolume_std_function_float_Vector3_int_const_from_Mesh_WeightedShell_DistanceVolumeCreationParams
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	Heap_float_GraphVertId_std_greater_float
class	Histogram
class	HistoryAction
class	HoleFillPlan
class	IComputeToolDistance
class	ICP
class	ICPExitType
class	ICPGroupPair
class	ICPGroupPairs
class	ICPMethod
class	ICPMode
class	ICPPairData
class	ICPProperties
class	Id_ICPElemtTag
class	IFastWindingNumber
class	IFastWindingNumberByParts
class	IICPTreeIndexer
class	Image
class	ImageLoad
class	ImageSave
class	ImageTransform
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	IntrinsicDeloneSettings
class	IOFilter
class	IPointPairs
class	IPointsProjector
class	IPointsToMeshProjector
class	IRenderObject
class	IsVisualizeMaskEnum_AnyVisualizeMaskEnum
class	IsVisualizeMaskEnum_DimensionsVisualizePropertyType
class	IsVisualizeMaskEnum_FeatureVisualizePropertyType
class	IsVisualizeMaskEnum_LabelVisualizePropertyType
class	IsVisualizeMaskEnum_LinesVisualizePropertyType
class	IsVisualizeMaskEnum_MeshVisualizePropertyType
class	IsVisualizeMaskEnum_PointMeasurementVisualizePropertyType
class	IsVisualizeMaskEnum_PointsVisualizePropertyType
class	IsVisualizeMaskEnum_VisualizeMaskType
class	IteratorRange_ChunkIterator
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	LinesLoadSettings
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	MapOrHashMap_EdgeId_EdgeId
class	MapOrHashMap_FaceId_FaceId
class	MapOrHashMap_UndirectedEdgeId_EdgeId
class	MapOrHashMap_UndirectedEdgeId_UndirectedEdgeId
class	MapOrHashMap_VertId_VertId
class	MarchingCubesByParts
class	MarchingCubesParams
class	MarkedContour3f
class	Matrix2b
class	Matrix2d
class	Matrix2f
class	Matrix2i
class	Matrix2i64
class	Matrix3_bool_QR
class	Matrix3_double_QR
class	Matrix3_float_QR
class	Matrix3_int_QR
class	Matrix3_long_QR
class	Matrix3_unsigned_char
class	Matrix3b
class	Matrix3d
class	Matrix3f
class	Matrix3i
class	Matrix3i64
class	Matrix4_unsigned_char
class	Matrix4b
class	Matrix4d
class	Matrix4f
class	Matrix4i
class	Matrix4i64
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	MeshOrPointsObject
class	MeshOrPointsXf
class	MeshPart
class	MeshPoint
class	MeshPointAndDistance
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	MinMaxArg_float_VertId
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_EdgeId
class	NoCtor_FaceId
class	NoCtor_GraphEdgeId
class	NoCtor_GraphVertId
class	NoCtor_Id_ICPElemtTag
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	NoCtor_VoxelId
class	NodeBitSet
class	NoDefInit_EdgeId
class	NoDefInit_FaceId
class	NoDefInit_GraphEdgeId
class	NoDefInit_GraphVertId
class	NoDefInit_Id_ICPElemtTag
class	NoDefInit_NodeId
class	NoDefInit_ObjId
class	NoDefInit_PixelId
class	NoDefInit_RegionId
class	NoDefInit_TextureId
class	NoDefInit_UndirectedEdgeId
class	NoDefInit_VertId
class	NoDefInit_VoxelId
class	NodeId
class	NodeNode
class	NoInit
class	NoInitNodeId
class	NoiseSettings
class	NormalsToPoints
class	NumSum
class	ObjBitSet
class	Object
class	ObjectChildrenHolder
class	ObjectComparableWithReference
class	ObjectDistanceMap
class	ObjectFactoryBase
class	ObjectGcode
class	ObjectLabel
class	ObjectLines
class	ObjectLinesHolder
class	ObjectMesh
class	ObjectMeshData
class	ObjectMeshHolder
class	ObjectPoints
class	ObjectPointsHolder
class	ObjectSave
class	ObjectSelectivityType
class	ObjectTagEventDispatcher
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	PdfBuildinFont
class	PdfParameters
class	phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
class	phmap_flat_hash_map_Id_FaceTag_Id_FaceTag
class	phmap_flat_hash_map_Id_GraphEdgeTag_Id_GraphEdgeTag
class	phmap_flat_hash_map_Id_GraphVertTag_Id_GraphVertTag
class	phmap_flat_hash_map_Id_ICPElemtTag_Id_ICPElemtTag
class	phmap_flat_hash_map_Id_NodeTag_Id_NodeTag
class	phmap_flat_hash_map_Id_ObjTag_Id_ObjTag
class	phmap_flat_hash_map_Id_PixelTag_Id_PixelTag
class	phmap_flat_hash_map_Id_RegionTag_Id_RegionTag
class	phmap_flat_hash_map_Id_TextureTag_Id_TextureTag
class	phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag
class	phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag
class	phmap_flat_hash_map_Id_UndirectedEdgeTag_int
class	phmap_flat_hash_map_Id_VertTag_float
class	phmap_flat_hash_map_Id_VertTag_FlowAggregator_Flows
class	phmap_flat_hash_map_Id_VertTag_Id_VertTag
class	phmap_flat_hash_map_Id_VertTag_VertPathInfo
class	phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag
class	phmap_flat_hash_map_int_Box_Vector3_int
class	phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul
class	PixelBitSet
class	PixelId
class	PlanarTriangulation
class	Plane3d
class	Plane3f
class	PlaneAccumulator
class	PlaneObject
class	PlyLoadParams
class	PointAccumulator
class	PointAndDistance
class	PointCloud
class	PointCloudApproxRelaxParams
class	PointCloudComponents
class	PointCloudPart
class	PointCloudRelaxParams
class	PointMeasurementObject
class	PointMeasurementVisualizePropertyType
class	PointObject
class	PointOnFace
class	PointOnObject
class	PointPair
class	PointPairs
class	PointsLoad
class	PointsLoadSettings
class	PointsProjectionResult
class	PointsProjector
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	PolylineProjectionResult3Arg
class	PolylineProjectionWithOffsetResult3
class	PolylineSubdivideSettings
class	PolylineToDistanceVolumeParams
class	PolylineTopology
class	PolylineToVolumeParams
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	PositionVertsSmoothlyParams
class	PrecipitationSimulator
class	PreciseVertCoord
class	PreciseVertCoords
class	PreciseVertCoords2
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	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	SimpleBinaryVolume
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	Src2TgtMaps
class	std_array_AffineXf_Vector3_double_4
class	std_array_AffineXf_Vector3_float_4
class	std_array_BooleanResultMapper_Maps_2
class	std_array_double_4
class	std_array_float_4
class	std_array_Id_VertTag_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_PreciseVertCoords2_6
class	std_array_PreciseVertCoords_4
class	std_array_PreciseVertCoords_5
class	std_array_PreciseVertCoords_8
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_Vector_float_Id_VoxelTag_3
class	std_array_WeightedVertex_3
class	std_greater_float
class	std_monostate
class	std_optional_Box_float
class	std_optional_Box_Vector3_float
class	std_optional_Color
class	std_optional_double
class	std_optional_float
class	std_optional_ObjectComparableWithReference_ComparisonTolerance
class	std_optional_std_string
class	std_optional_std_variant_float_Vector3_float
class	std_optional_Vector2_float
class	std_optional_Vector3_float
class	std_optional_Vector_std_array_Id_VertTag_2ul_Id_UndirectedEdgeTag
class	std_optional_Vector_std_array_Id_VertTag_3ul_Id_FaceTag
class	std_set_std_string
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_int_float_bool_std_string_Pdf_Cell_Empty
class	std_variant_PdfBuildinFont_std_filesystem_path
class	std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul
class	std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul
class	std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane
class	std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag
class	std_variant_std_reference_wrapper_FillingSurface_TPMS_MeshParams_const_std_reference_wrapper_FillingSurface_CellularSurface_Params_const
class	std_variant_std_reference_wrapper_FillingSurface_TPMS_MeshParams_std_reference_wrapper_FillingSurface_CellularSurface_Params
class	std_variant_Vector_Id_EdgeTag_Id_EdgeTag_phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
class	std_variant_Vector_Id_EdgeTag_Id_UndirectedEdgeTag_phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag
class	std_variant_Vector_Id_FaceTag_Id_FaceTag_phmap_flat_hash_map_Id_FaceTag_Id_FaceTag
class	std_variant_Vector_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag_phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag
class	std_variant_Vector_Id_VertTag_Id_VertTag_phmap_flat_hash_map_Id_VertTag_Id_VertTag
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_FaceFaceFace
class	std_vector_FanRecord
class	std_vector_FanRecordWithCenter
class	std_vector_FeatureObjectSharedProperty
class	std_vector_FillHoleItem
class	std_vector_float
class	std_vector_FloatGrid
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_HoleFillPlan
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_Pdf_Cell
class	std_vector_Pdf_PaletteRowStats
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_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_2ul
class	std_vector_std_array_Id_VertTag_3ul
class	std_vector_std_array_std_filesystem_path_4ul
class	std_vector_std_array_Vector3_float_3ul
class	std_vector_std_filesystem_path
class	std_vector_std_pair_double_int
class	std_vector_std_pair_Id_EdgeTag_Id_EdgeTag
class	std_vector_std_pair_Id_VertTag_Id_VertTag
class	std_vector_std_pair_std_string_float
class	std_vector_std_pair_unsigned_long_unsigned_long
class	std_vector_std_pair_Vector3_float_Vector3_float
class	std_vector_std_shared_ptr_BasicUiRenderTask
class	std_vector_std_shared_ptr_HistoryAction
class	std_vector_std_shared_ptr_Mesh
class	std_vector_std_shared_ptr_Object
class	std_vector_std_shared_ptr_Object_const
class	std_vector_std_shared_ptr_ObjectDistanceMap
class	std_vector_std_shared_ptr_ObjectLines
class	std_vector_std_shared_ptr_ObjectLinesHolder
class	std_vector_std_shared_ptr_ObjectMesh
class	std_vector_std_shared_ptr_ObjectMeshHolder
class	std_vector_std_shared_ptr_ObjectPoints
class	std_vector_std_shared_ptr_ObjectPointsHolder
class	std_vector_std_shared_ptr_ObjectVoxels
class	std_vector_std_shared_ptr_VisualObject
class	std_vector_std_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_VarEdgeTri
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_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_FloatGrid_std_string
class	std_vector_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_Vector_float_Id_VoxelTag_std_string
class	std_vector_TriPoint_float
class	std_vector_TypedBitSet_Id_EdgeTag
class	std_vector_TypedBitSet_Id_FaceTag
class	std_vector_TypedBitSet_Id_UndirectedEdgeTag
class	std_vector_TypedBitSet_Id_VertTag
class	std_vector_TypedBitSet_Id_VoxelTag
class	std_vector_UndirectedEdgeUndirectedEdge
class	std_vector_UnorientedTriangle
class	std_vector_unsigned_char
class	std_vector_unsigned_long
class	std_vector_unsigned_short
class	std_vector_VarEdgeTri
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_FloatGrid
class	std_vector_WatershedGraph_BasinInfo
class	std_vector_WatershedGraph_BdInfo
class	std_vector_WatershedGraph_OverflowPoint
class	std_vector_WeightedShell_ParametersRegions_Region
class	StitchHolesParams
class	SubdivideSettings
class	SurfaceDistanceBuilder
class	SymbolMeshParams
class	SymMatrix2b
class	SymMatrix2d
class	SymMatrix2f
class	SymMatrix2i
class	SymMatrix2i64
class	SymMatrix3_unsigned_char
class	SymMatrix3b
class	SymMatrix3d
class	SymMatrix3f
class	SymMatrix3i
class	SymMatrix3i64
class	SymMatrix4_unsigned_char
class	SymMatrix4b
class	SymMatrix4d
class	SymMatrix4f
class	SymMatrix4i
class	SymMatrix4i64
class	SystemMemory
class	SystemPath
class	TeethMaskToDirectionVolumeConvertor
class	TerminalVertex
class	TextMeshAlignParams
class	TextureBitSet
class	TextureId
class	TexturePerFace
class	Tgt2SrcMaps
class	ThickenParams
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	TypedBitSet_Id_ICPElemtTag
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	UniteManyMeshesParams
class	UnorientedTriangle
class	unsigned_char_output
class	UseAABBTree
class	VarEdgeTri
class	VdbVolume
class	Vector2b
class	Vector2d
class	Vector2f
class	Vector2i
class	Vector2i64
class	Vector3_unsigned_char
class	Vector3b
class	Vector3d
class	Vector3f
class	Vector3i
class	Vector3i64
class	Vector4_unsigned_char
class	Vector4b
class	Vector4d
class	Vector4f
class	Vector4i
class	Vector4i64
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_EdgeId_FaceId
class	Vector_EdgeId_VertId
class	Vector_FaceBitSet_GraphVertId
class	Vector_FanRecord_VertId
class	Vector_float_VoxelId
class	Vector_Graph_EndVertices_GraphEdgeId
class	Vector_GraphEdgeId_GraphEdgeId
class	Vector_GraphVertId_GraphVertId
class	Vector_ICPGroupPairs_Id_ICPElemtTag
class	Vector_Id_ICPElemtTag_Id_ICPElemtTag
class	Vector_int_FaceId
class	Vector_int_UndirectedEdgeId
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_GraphVertId
class	Vector_unsigned_short_VoxelId
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_VertId_EdgeId
class	Vector_VoxelId_FaceId
class	Vector_VoxelId_VoxelId
class	Vector_WatershedGraph_BasinInfo_GraphVertId
class	Vector_WatershedGraph_BdInfo_GraphEdgeId
class	Vert2RegionMap
class	VertBitSet
class	VertBMap
class	VertColorMapAggregator
class	VertColors
class	VertCoords
class	VertCoords2
class	VertCoordsDiff
class	VertDistance
class	VertexMass
class	VertId
class	VertMap
class	VertPathInfo
class	VertRenumber
class	VertScalars
class	ViewportId
class	ViewportIterator
class	ViewportMask
class	ViewportProperty_AffineXf3f
class	ViewportProperty_Color
class	ViewportProperty_Matrix3f
class	ViewportProperty_unsigned_char
class	ViewportProperty_Vector4_unsigned_char
class	ViewportProperty_XfBasedCache_Box3f
class	VisualizeMaskType
class	VisualObject
class	VolumeIndexer
class	VolumeSegmentationParameters
class	VolumeSegmenter
class	VolumeToMeshByPartsSettings
class	VoxelBitSet
class	VoxelFilterType
class	VoxelId
class	VoxelLocation
class	VoxelMetricParameters
class	VoxelsLoad
class	VoxelsSave
class	VoxelsVolume_FloatGrid
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_FloatGrid
class	VoxelTraits_std_function_float_const_Vector3i
class	VoxelTraits_std_function_unsigned_char_const_Vector3i
class	VoxelTraits_Vector_float_VoxelId
class	VoxelTraits_Vector_unsigned_short_VoxelId
class	VoxelTraits_VoxelBitSet
class	WatershedGraph
class	WeightedShell
class	WeightedVertex
class	WholeEdgeBMap
class	WholeEdgeMap
class	WrapType
class	XfBasedCache_Box3f
class	ZCompensateParams
class	ZeroOnMove_unsigned_long

Functions
str	GetCpuId ()
str	GetDetailedOSName ()
pathlib.Path	GetHomeDirectory ()
str	GetMRVersionString ()
pathlib.Path	GetTempDirectory ()
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)
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, PointCloudPart pcp, 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	alignContoursToMesh (Mesh mesh, std_vector_std_vector_Vector2_float contours, ContoursMeshAlignParams params)
Mesh	alignTextToMesh (Mesh mesh, TextMeshAlignParams params)
float	angle (Vector2d a, Vector2d b)
int	angle (Vector2i a, Vector2i b)
float	angle (Vector3f a, Vector3f b)
float	angle (Vector3d a, Vector3d b)
int	angle (Vector3i a, Vector3i b)
float	angle (Vector2f a, Vector2f 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)
float	area (MeshTopology topology, VertCoords points, FaceId f)
float	area (MeshTopology topology, VertCoords points, FaceBitSet fs)
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 (SignDetectionMode m)
str	asString (ColoringType ct)
bool	autoOrientLocalTriangulations (PointCloud pointCloud, AllLocalTriangulations triangs, VertBitSet region, func_bool_from_float progress='{}', Triangulation outRep3=None, Triangulation outRep2=None)
float	averageEdgeLength (MeshTopology topology, VertCoords points)
ViewportIterator	begin (ViewportMask mask)
RingIterator_NextEdgeSameOrigin	begin (IteratorRange_RingIterator_NextEdgeSameOrigin range)
RingIterator_NextEdgeSameLeft	begin (IteratorRange_RingIterator_NextEdgeSameLeft range)
ChunkIterator	begin (IteratorRange_ChunkIterator range)
UndirectedEdgeIterator	begin (IteratorRange_UndirectedEdgeIterator range)
PolylineUndirectedEdgeIterator	begin (IteratorRange_PolylineUndirectedEdgeIterator 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='{}')
EdgeId	buildBottom (Mesh mesh, EdgeId a, Vector3f dir, float holeExtension, FaceBitSet outNewFaces=None)
None	buildCylinderBetweenTwoHoles (Mesh mesh, EdgeId a, EdgeId 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_unsigned_long	buildSmallestMetricPath (VdbVolume voxels, func_float_from_unsigned_long_unsigned_long metric, int start, int finish, func_bool_from_float cb='{}')
std_vector_Id_EdgeTag	buildSmallestMetricPath (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertId start, VertId finish, float maxPathMetric=3.4028234663852886e+38)
std_vector_Id_EdgeTag	buildSmallestMetricPath (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertId start, VertBitSet finish, float maxPathMetric=3.4028234663852886e+38)
std_vector_Id_EdgeTag	buildSmallestMetricPathBiDir (MeshTopology topology, func_float_from_Id_EdgeTag metric, VertId start, VertId finish, float maxPathMetric=3.4028234663852886e+38)
std_vector_Id_EdgeTag	buildSmallestMetricPathBiDir (MeshTopology topology, func_float_from_Id_EdgeTag metric, TerminalVertex starts, int numStarts, TerminalVertex finishes, int numFinishes, VertId outPathStart=None, VertId outPathFinish=None, float maxPathMetric=3.4028234663852886e+38)
AllLocalTriangulations	buildUnitedLocalTriangulations (PointCloud cloud, TriangulationHelpers.Settings settings, func_bool_from_float progress='{}')
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)
FlipEdge	canFlipEdge (MeshTopology topology, EdgeId edge, FaceBitSet region=None, UndirectedEdgeBitSet notFlippable=None, VertBitSet vertRegion=None)
bool	canMinimizePolynomial (int degree)
bool	canSolvePolynomial (int degree)
bool	ccw (std_array_PreciseVertCoords2_3 vs)
bool	ccw (PreciseVertCoords2 vs)
bool	ccw (Vector2i a, Vector2i b)
bool	ccw (Vector2i a, Vector2i b, Vector2i c)
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, EdgeId edge, DeloneSettings settings='{}', float_output deviationSqAfterFlip=None)
bool	checkDeloneQuadrangleInMesh (MeshTopology topology, VertCoords points, EdgeId edge, DeloneSettings settings='{}', float_output deviationSqAfterFlip=None)
int	chunkCount (int totalSize, int chunkSize, int overlap=0)
float	circumcircleDiameter (MeshTopology topology, VertCoords points, FaceId f)
float	circumcircleDiameterSq (MeshTopology topology, VertCoords points, FaceId f)
ShellVertexInfo	classifyShellVert (MeshPart mp, Vector3f shellPoint, FindInnerShellSettings settings='{}')
ObjectLines	cloneRegion (ObjectLines objLines, UndirectedEdgeBitSet region)
ObjectPoints	cloneRegion (ObjectPoints objPoints, VertBitSet region)
ObjectMesh	cloneRegion (ObjectMesh objMesh, FaceBitSet region, bool copyTexture=True)
DistanceMap	combineXYderivativeMaps (tuple[DistanceMap, DistanceMap] XYderivativeMaps)
str	commonFilesName (std_vector_std_filesystem_path files)
None	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)
Box3f	computeBoundingBox (MeshTopology topology, VertCoords points, FaceBitSet region, AffineXf3f toWorld=None)
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)
Box3i	computeGridBox (Box3f workArea, float voxelSize)
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)
Mesh	computeSweptVolumeWithCustomToolDistance (IComputeToolDistance comp, ComputeSweptVolumeParameters params)
Mesh	computeSweptVolumeWithDistanceVolume (ComputeSweptVolumeParameters params)
Mesh	computeSweptVolumeWithMeshMovement (ComputeSweptVolumeParameters params)
std_array_int_4	computeTrianglesRepetitions (AllLocalTriangulations triangs)
Box3f	computeWorkArea (Polyline3 toolpath, MeshPart tool)
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)
std_vector_Vector2_double	convertContourTo2d (std_vector_Vector2_float from_)
std_vector_Vector2_double	convertContourTo2d (std_vector_Vector2_double from_)
std_vector_Vector2_double	convertContourTo2d (std_vector_Vector3_float from_)
std_vector_Vector2_double	convertContourTo2d (std_vector_Vector3_double from_)
std_vector_Vector2_float	convertContourTo2f (std_vector_Vector2_float from_)
std_vector_Vector2_float	convertContourTo2f (std_vector_Vector2_double from_)
std_vector_Vector2_float	convertContourTo2f (std_vector_Vector3_float from_)
std_vector_Vector2_float	convertContourTo2f (std_vector_Vector3_double from_)
std_vector_Vector3_double	convertContourTo3d (std_vector_Vector2_float from_)
std_vector_Vector3_double	convertContourTo3d (std_vector_Vector2_double from_)
std_vector_Vector3_double	convertContourTo3d (std_vector_Vector3_float from_)
std_vector_Vector3_double	convertContourTo3d (std_vector_Vector3_double from_)
std_vector_Vector3_float	convertContourTo3f (std_vector_Vector2_float from_)
std_vector_Vector3_float	convertContourTo3f (std_vector_Vector2_double from_)
std_vector_Vector3_float	convertContourTo3f (std_vector_Vector3_float from_)
std_vector_Vector3_float	convertContourTo3f (std_vector_Vector3_double from_)
std_vector_std_vector_Vector2_double	convertContoursTo2d (std_vector_std_vector_Vector2_float from_)
std_vector_std_vector_Vector2_double	convertContoursTo2d (std_vector_std_vector_Vector2_double from_)
std_vector_std_vector_Vector2_double	convertContoursTo2d (std_vector_std_vector_Vector3_float from_)
std_vector_std_vector_Vector2_double	convertContoursTo2d (std_vector_std_vector_Vector3_double from_)
std_vector_std_vector_Vector2_float	convertContoursTo2f (std_vector_std_vector_Vector3_double from_)
std_vector_std_vector_Vector2_float	convertContoursTo2f (std_vector_std_vector_Vector2_float from_)
std_vector_std_vector_Vector2_float	convertContoursTo2f (std_vector_std_vector_Vector2_double from_)
std_vector_std_vector_Vector2_float	convertContoursTo2f (std_vector_std_vector_Vector3_float from_)
std_vector_std_vector_Vector3_double	convertContoursTo3d (std_vector_std_vector_Vector2_float from_)
std_vector_std_vector_Vector3_double	convertContoursTo3d (std_vector_std_vector_Vector2_double from_)
std_vector_std_vector_Vector3_double	convertContoursTo3d (std_vector_std_vector_Vector3_float from_)
std_vector_std_vector_Vector3_double	convertContoursTo3d (std_vector_std_vector_Vector3_double from_)
std_vector_std_vector_Vector3_float	convertContoursTo3f (std_vector_std_vector_Vector2_float from_)
std_vector_std_vector_Vector3_float	convertContoursTo3f (std_vector_std_vector_Vector2_double from_)
std_vector_std_vector_Vector3_float	convertContoursTo3f (std_vector_std_vector_Vector3_float from_)
std_vector_std_vector_Vector3_float	convertContoursTo3f (std_vector_std_vector_Vector3_double from_)
Image	convertDistanceMapToImage (DistanceMap distMap, float threshold=0.003921568859368563)
DistanceMap	convertImageToDistanceMap (Image image, float threshold=0.003921568859368563, bool invert=True)
None	convertIntFloatAllVerts (Mesh mesh, CoordinateConverters conv)
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)
Mesh	copySubdividePackMesh (MeshPart mp, float voxelSize, func_bool_from_float cb='{}')
float	cotan (MeshTopology topology, VertCoords points, UndirectedEdgeId ue)
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)
FloatGrid	cropped (FloatGrid 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='{}')
FaceBitSet	cutMeshByContour (Mesh mesh, std_vector_Vector3_float contour, AffineXf3f xf='{}')
FaceBitSet	cutMeshByContours (Mesh mesh, std_vector_std_vector_Vector3_float contours, AffineXf3f xf='{}')
std_vector_std_vector_Id_EdgeTag	cutMeshByProjection (Mesh mesh, std_vector_std_vector_Vector3_float contours, CutByProjectionSettings settings)
float	dblArea (MeshTopology topology, VertCoords points, VertId v)
float	dblArea (MeshTopology topology, VertCoords points, FaceId f)
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='{}')
DecimateResult	decimateObjectMeshData (ObjectMeshData data, 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, bool keepLoneHoles=False)
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='{}')
Vector3f	destPnt (MeshTopology topology, VertCoords points, EdgeId e)
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_VarEdgeTri contours, bool ignoreOpen=False)
FaceBitSet	detectTunnelFaces (MeshPart mp, DetectTunnelSettings settings='{}')
float	dihedralAngle (MeshTopology topology, VertCoords points, UndirectedEdgeId e)
float	dihedralAngleCos (MeshTopology topology, VertCoords points, UndirectedEdgeId e)
float	dihedralAngleSin (MeshTopology topology, VertCoords points, UndirectedEdgeId e)
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 (MeshTopology topology, VertCoords points, FaceBitSet region, float dilation, func_bool_from_float callback='{}')
bool	dilateRegion (MeshTopology topology, VertCoords points, VertBitSet region, float dilation, func_bool_from_float callback='{}')
bool	dilateRegion (MeshTopology topology, VertCoords points, 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='{}')
Vector3d	dirArea (MeshTopology topology, VertCoords points, FaceBitSet fs)
Vector3f	dirDblArea (MeshTopology topology, VertCoords points, VertId v)
Vector3f	dirDblArea (MeshTopology topology, VertCoords points, FaceId f)
VertCoords	dirDblAreas (MeshTopology topology, VertCoords points, VertBitSet region=None)
func_float_from_Id_EdgeTag	discreteAbsMeanCurvatureMetric (Mesh mesh)
func_float_from_Id_EdgeTag	discreteAbsMeanCurvatureMetric (MeshTopology topology, VertCoords points)
float	discreteGaussianCurvature (MeshTopology topology, VertCoords points, VertId v, bool_output outBoundaryVert=None)
float	discreteMeanCurvature (MeshTopology topology, VertCoords points, VertId v)
float	discreteMeanCurvature (MeshTopology topology, VertCoords points, UndirectedEdgeId e)
func_float_from_Id_EdgeTag	discreteMinusAbsMeanCurvatureMetric (Mesh mesh)
func_float_from_Id_EdgeTag	discreteMinusAbsMeanCurvatureMetric (MeshTopology topology, VertCoords points)
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='{}')
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)
int	dot (Vector4b a, Vector4b b)
int	dot (Vector4i a, Vector4i b)
int	dot (Vector4i64 a, Vector4i64 b)
float	dot (Vector4f a, Vector4f b)
float	dot (Vector4d a, Vector4d b)
int	dot (Vector4_unsigned_char a, Vector4_unsigned_char b)
float	dot (Vector3f a, Vector3f b)
float	dot (Vector3d a, Vector3d b)
int	dot (Vector3i a, Vector3i b)
int	dot (Vector3b a, Vector3b b)
int	dot (Vector3i64 a, Vector3i64 b)
int	dot (Vector3_unsigned_char a, Vector3_unsigned_char b)
float	dot (Vector2f a, Vector2f b)
float	dot (Vector2d a, Vector2d b)
int	dot (Vector2i a, Vector2i b)
int	dot (Vector2b a, Vector2b b)
int	dot (Vector2i64 a, Vector2i64 b)
Mesh	doubleOffsetMesh (MeshPart mp, float offsetA, float offsetB, OffsetParameters params='{}')
Mesh	doubleOffsetVdb (MeshPart mp, DoubleOffsetSettings settings)
int	duplicateMultiHoleVertices (Mesh mesh)
Vector3f	edgeCenter (MeshTopology topology, VertCoords points, UndirectedEdgeId e)
func_float_from_Id_EdgeTag	edgeCurvMetric (Mesh mesh, float angleSinFactor=2, float angleSinForBoundary=0)
func_float_from_Id_EdgeTag	edgeCurvMetric (MeshTopology topology, VertCoords points, float angleSinFactor=2, float angleSinForBoundary=0)
float	edgeLength (MeshTopology topology, VertCoords points, UndirectedEdgeId e)
func_float_from_Id_EdgeTag	edgeLengthMetric (Mesh mesh)
func_float_from_Id_EdgeTag	edgeLengthMetric (MeshTopology topology, VertCoords points)
float	edgeLengthSq (MeshTopology topology, VertCoords points, UndirectedEdgeId e)
UndirectedEdgeScalars	edgeLengths (MeshTopology topology, VertCoords points)
None	edgeMapsComposition (EdgeMap a2b, EdgeMap b2c)
Vector3f	edgePoint (MeshTopology topology, VertCoords points, EdgeId e, float f)
Vector3f	edgePoint (MeshTopology topology, VertCoords points, EdgePoint ep)
std_vector_Vector3_float	edgePointsFromContours (Polyline2 polyline, float pixelSize, float threshold)
LineSegm3f	edgeSegment (MeshTopology topology, VertCoords points, EdgeId e)
func_float_from_Id_EdgeTag	edgeTableSymMetric (MeshTopology topology, func_float_from_Id_EdgeTag metric)
Vector3f	edgeVector (MeshTopology topology, VertCoords points, EdgeId e)
EdgeId	eliminateDegree3Dest (MeshTopology topology, EdgeId e, FaceBitSet region=None)
int	eliminateDegree3Vertices (MeshTopology topology, VertBitSet region, FaceBitSet fs=None)
EdgeId	eliminateDoubleTris (MeshTopology topology, EdgeId 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)
RingIterator_NextEdgeSameLeft	end (IteratorRange_RingIterator_NextEdgeSameLeft range)
ChunkIterator	end (IteratorRange_ChunkIterator range)
UndirectedEdgeIterator	end (IteratorRange_UndirectedEdgeIterator range)
PolylineUndirectedEdgeIterator	end (IteratorRange_PolylineUndirectedEdgeIterator range)
bool	equalizeTriAreas (Mesh mesh, MeshEqualizeTriAreasParams params='{}', func_bool_from_float cb='{}')
bool	equalizeTriAreas (MeshTopology topology, VertCoords points, 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 (MeshTopology topology, VertCoords points, FaceBitSet region, float dilation, func_bool_from_float callback='{}')
bool	erodeRegion (MeshTopology topology, VertCoords points, VertBitSet region, float dilation, func_bool_from_float callback='{}')
bool	erodeRegion (MeshTopology topology, VertCoords points, 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 (FloatGrid grid, float_output min, float_output max)
None	executeHoleFillPlan (Mesh mesh, EdgeId a0, HoleFillPlan plan, FaceBitSet outNewFaces=None)
None	expand (MeshTopology topology, FaceBitSet region, int hops=1)
FaceBitSet	expand (MeshTopology topology, FaceId f, int hops)
None	expand (MeshTopology topology, VertBitSet region, int hops=1)
VertBitSet	expand (MeshTopology topology, VertId v, int hops)
FaceBitSet	expandFaces (MeshTopology topology, FaceBitSet region, UndirectedEdgeBitSet stopEdges=None)
None	expandPixelMask (PixelBitSet mask, RectIndexer indexer, int expansion=1)
None	expandVoxelsMask (VoxelBitSet mask, VolumeIndexer indexer, int expansion=1)
ObjectGcode	exportToolPathToGCode (std_vector_GCommand commands)
std_vector_Id_EdgeTag	extendAllHoles (Mesh mesh, Plane3f plane, FaceBitSet outNewFaces=None)
EdgeId	extendHole (Mesh mesh, EdgeId a, Plane3f plane, FaceBitSet outNewFaces=None)
EdgeId	extendHole (Mesh mesh, EdgeId 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_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, UseAABBTree u='UseAABBTree::Yes')
std_vector_EdgeSegment	extractSectionsFromPolyline (Polyline3 polyline, Plane3f plane, float eps, UndirectedEdgeBitSet positiveEdges='{}')
std_vector_std_vector_EdgePoint	extractXYPlaneSections (MeshPart mp, float zLevel, UseAABBTree u='UseAABBTree::Yes')
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, func_bool_from_float progress='{}')
FaceBitSet	fillContourLeftByGraphCut (MeshTopology topology, std_vector_std_vector_Id_EdgeTag contours, func_float_from_Id_EdgeTag metric, func_bool_from_float progress='{}')
None	fillContours2D (Mesh mesh, std_vector_Id_EdgeTag holeRepresentativeEdges)
None	fillHole (Mesh mesh, EdgeId a, FillHoleParams params='{}')
FaceBitSet	fillHoleNicely (Mesh mesh, EdgeId holeEdge, FillHoleNicelySettings settings)
VertId	fillHoleTrivially (Mesh mesh, EdgeId a, FaceBitSet outNewFaces=None)
None	fillHoles (Mesh mesh, std_vector_Id_EdgeTag as_, FillHoleParams params='{}')
None	fillPlanarHole (ObjectMeshData data, 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)
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)
None	findBoxedTrisInBall (MeshPart mp, Ball3f ball, func_Processing_from_Id_FaceTag_Ball_Vector3_float foundCallback)
Vector3f	findCenterFromBBox (MeshTopology topology, VertCoords points)
Vector3f	findCenterFromFaces (MeshTopology topology, VertCoords points)
Vector3f	findCenterFromPoints (MeshTopology topology, VertCoords points)
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)
MeshPointAndDistance	findClosestWeightedMeshPoint (Vector3f loc, Mesh mesh, DistanceFromWeightedPointsComputeParams params)
PointAndDistance	findClosestWeightedPoint (Vector3f loc, AABBTreePoints tree, DistanceFromWeightedPointsComputeParams params)
std_vector_EdgePointPair	findCollidingEdgePairs (Polyline2 a, Polyline2 b, AffineXf2f rigidB2A=None, bool firstIntersectionOnly=False)
std_vector_VarEdgeTri	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)
UndirectedEdgeBitSet	findCreaseEdges (MeshTopology topology, VertCoords points, float angleFromPlanar)
FaceBitSet	findDegenerateFaces (MeshPart mp, float criticalAspectRatio=3.4028234663852886e+38, func_bool_from_float cb='{}')
VertId	findDirMax (Vector3f dir, Mesh m, UseAABBTree u='UseAABBTree::Yes')
VertId	findDirMax (Vector3f dir, MeshPart mp, UseAABBTree u='UseAABBTree::Yes')
VertId	findDirMax (Vector3f dir, MeshVertPart mp, UseAABBTree u='UseAABBTree::Yes')
VertId	findDirMax (Vector3f dir, Polyline3 polyline, UseAABBTree u='UseAABBTree::Yes')
VertId	findDirMax (Vector2f dir, Polyline2 polyline, UseAABBTree u='UseAABBTree::Yes')
VertId	findDirMax (Vector3f dir, PointCloud cloud, VertBitSet region=None, UseAABBTree u='UseAABBTree::Yes')
VertId	findDirMax (Vector3f dir, AABBTreePoints tree, VertBitSet region=None)
VertId	findDirMaxBruteForce (Vector3f dir, VertCoords points, VertBitSet region=None)
VertId	findDirMaxBruteForce (Vector2f dir, VertCoords2 points, VertBitSet region=None)
VertId	findDirMaxBruteForce (Vector3f dir, PointCloud cloud, VertBitSet region=None)
VertId	findDirMaxBruteForce (Vector3f dir, Polyline3 polyline)
VertId	findDirMaxBruteForce (Vector2f dir, Polyline2 polyline)
VertId	findDirMaxBruteForce (Vector3f dir, MeshPart mp)
VertId	findDirMaxBruteForce (Vector3f dir, MeshVertPart mp)
MinMaxArg_float_VertId	findDirMinMaxBruteForce (Vector3f dir, VertCoords points, VertBitSet region=None)
MinMaxArg_float_VertId	findDirMinMaxBruteForce (Vector2f dir, VertCoords2 points, VertBitSet region=None)
MinMaxArg_float_VertId	findDirMinMaxBruteForce (Vector3f dir, PointCloud cloud, VertBitSet region=None)
MinMaxArg_float_VertId	findDirMinMaxBruteForce (Vector3f dir, Polyline3 polyline)
MinMaxArg_float_VertId	findDirMinMaxBruteForce (Vector2f dir, Polyline2 polyline)
MinMaxArg_float_VertId	findDirMinMaxBruteForce (Vector3f dir, MeshPart mp)
MinMaxArg_float_VertId	findDirMinMaxBruteForce (Vector3f dir, MeshVertPart mp)
FaceBitSet	findDisorientedFaces (Mesh mesh, FindDisorientationParams params='{}')
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)
PolylineProjectionResult3Arg	findMaxProjectionOnPolyline (VertCoords points, Polyline3 polyline, VertBitSet pointsRegion=None, AffineXf3f xf=None, float loDistLimitSq=0)
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 rangeSq)
FaceBitSet	findOuterLayer (Mesh mesh)
VertBitSet	findOutliers (PointCloud pc, FindOutliersParams params)
std_vector_TypedBitSet_Id_FaceTag	findOverhangs (Mesh mesh, FindOverhangsSettings settings)
FaceBitSet	findOverlappingTris (MeshPart mp, FindOverlappingSettings settings)
None	findPointsInBall (PointCloud pointCloud, Ball3f ball, func_Processing_from_PointsProjectionResult_Vector3_float_Ball_Vector3_float foundCallback, AffineXf3f xf=None)
None	findPointsInBall (Mesh mesh, Ball3f ball, func_Processing_from_PointsProjectionResult_Vector3_float_Ball_Vector3_float foundCallback, AffineXf3f xf=None)
None	findPointsInBall (AABBTreePoints tree, Ball3f ball, func_Processing_from_PointsProjectionResult_Vector3_float_Ball_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, PointCloudPart pcp, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0, func_bool_from_Id_VertTag skipCb='{}')
PointsProjectionResult	findProjectionOnPoints (Vector3f pt, AABBTreePoints tree, float upDistLimitSq=3.4028234663852886e+38, AffineXf3f xf=None, float loDistLimitSq=0, VertBitSet region=None, 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_EdgeTri	findSelfCollidingEdgeTrisPrecise (MeshPart mp, func_Vector3_int_from_Vector3_float conv, bool anyIntersection=False, AffineXf3f rigidB2A=None, int aVertSizes=0)
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, bool touchIsIntersection=False)
std_vector_FaceFace	findSelfCollidingTriangles (MeshPart mp, func_bool_from_float cb='{}', Face2RegionMap regionMap=None, bool touchIsIntersection=False)
FaceBitSet	findSelfCollidingTrianglesBS (MeshPart mp, func_bool_from_float cb='{}', Face2RegionMap regionMap=None, bool touchIsIntersection=False)
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='{}')
VertBitSet	findSpikeVertices (MeshTopology topology, VertCoords points, float minSumAngle, VertBitSet region=None, func_bool_from_float cb='{}')
EdgePoint	findSteepestDescentPoint (MeshPart mp, VertScalars field, EdgePoint ep)
EdgePoint	findSteepestDescentPoint (MeshPart mp, VertScalars field, MeshTriPoint tp)
EdgePoint	findSteepestDescentPoint (MeshPart mp, VertScalars field, VertId v)
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)
std_vector_FaceFaceFace	findTripleFaceIntersections (MeshTopology topology, std_vector_std_vector_VarEdgeTri selfContours)
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='{}')
Vector3i	findTwoSegmentsIntersection (Vector3i ai, Vector3i bi, Vector3i ci, Vector3i di)
VertCoords	findZcompensatedPositions (Mesh mesh, ZCompensateParams params)
VertScalars	findZcompensationShifts (Mesh mesh, ZCompensateParams params)
None	fixMeshCreases (Mesh mesh, FixCreasesParams params='{}')
None	fixMeshDegeneracies (Mesh mesh, FixMeshDegeneraciesParams params)
None	fixMultipleEdges (Mesh mesh, std_vector_std_pair_Id_VertTag_Id_VertTag multipleEdges)
None	fixMultipleEdges (Mesh mesh)
None	fixSelfIntersections (Mesh mesh, float voxelSize)
VdbVolume	floatGridToVdbVolume (FloatGrid grid)
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='{}')
None	gaussianFilter (FloatGrid grid, int width, int iters, func_bool_from_float cb='{}')
FloatGrid	gaussianFiltered (FloatGrid grid, int width, int iters, 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_TypedBitSet_Id_FaceTag	getAllComponents (MeshPart meshPart, MeshComponents.FaceIncidence incidence='FaceIncidence::PerEdge', UndirectedEdgeBitSet isCompBd='{}')
tuple[std_vector_TypedBitSet_Id_FaceTag, int]	getAllComponents (MeshPart meshPart, int maxComponentCount, MeshComponents.FaceIncidence incidence='FaceIncidence::PerEdge', UndirectedEdgeBitSet isCompBd='{}')
std_vector_TypedBitSet_Id_FaceTag	getAllComponents (Face2RegionMap componentsMap, int componentsCount, FaceBitSet region, int maxComponentCount)
std_vector_TypedBitSet_Id_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)
UndirectedEdgeId	getClosestEdge (MeshTopology topology, VertCoords points, PointOnFace p)
UndirectedEdgeId	getClosestEdge (MeshTopology topology, VertCoords points, MeshTriPoint p)
VertId	getClosestVertex (MeshTopology topology, VertCoords points, PointOnFace p)
VertId	getClosestVertex (MeshTopology topology, VertCoords points, MeshTriPoint p)
FillHoleMetric	getComplexFillMetric (Mesh mesh, EdgeId 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, EdgeId e, FillHoleParams params='{}')
std_vector_HoleFillPlan	getHoleFillPlans (Mesh mesh, std_vector_Id_EdgeTag holeRepresentativeEdges, 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, UndirectedEdgeBitSet edges, VertBitSet store)
VertBitSet	getIncidentVerts (MeshTopology topology, FaceBitSet faces)
VertBitSet	getIncidentVerts (MeshTopology topology, FaceBitSet faces, VertBitSet store)
VertBitSet	getIncidentVerts (MeshTopology topology, UndirectedEdgeBitSet edges)
UndirectedEdgeBitSet	getInnerEdges (MeshTopology topology, VertBitSet verts)
UndirectedEdgeBitSet	getInnerEdges (MeshTopology topology, FaceBitSet region)
FaceBitSet	getInnerFaces (MeshTopology topology, VertBitSet verts)
VertBitSet	getInnerVerts (MeshTopology topology, UndirectedEdgeBitSet edges)
VertBitSet	getInnerVerts (MeshTopology topology, FaceBitSet region=None)
None	getLeftTriPoints (MeshTopology topology, VertCoords points, EdgeId e, Vector3f v0, Vector3f v1, Vector3f v2)
std_array_Vector3_float_3	getLeftTriPoints (MeshTopology topology, VertCoords points, EdgeId e)
FillHoleMetric	getMaxDihedralAngleMetric (Mesh mesh)
float	getMeanSqDistToPlane (IPointPairs pairs)
float	getMeanSqDistToPoint (IPointPairs pairs)
MeshOrPoints	getMeshOrPoints (Object obj)
MeshOrPointsXf	getMeshOrPointsXf (Object obj)
FillHoleMetric	getMinAreaMetric (Mesh mesh)
FillHoleMetric	getMinTriAngleMetric (Mesh mesh)
FaceBitSet	getNeighborFaces (MeshTopology topology, UndirectedEdgeBitSet edges)
int	getNumActivePairs (IPointPairs pairs)
int	getNumNodes (int numLeaves)
int	getNumNodesPoints (int numPoints)
int	getNumSamples (IPointPairs pairs)
str	getOSNoSpaces ()
None	getOneMeshIntersectionContours (Mesh meshA, Mesh meshB, std_vector_std_vector_VarEdgeTri contours, std_vector_OneMeshContour outA, std_vector_OneMeshContour outB, CoordinateConverters converters, AffineXf3f rigidB2A=None, std_vector_std_vector_Vector3_float outPtsA=None, bool addSelfyTerminalVerts=False)
std_vector_OneMeshContour	getOneMeshSelfIntersectionContours (Mesh mesh, std_vector_std_vector_VarEdgeTri contours, CoordinateConverters converters, AffineXf3f rigidB2A=None)
FaceBMap	getOptimalFaceOrdering (Mesh mesh)
FillHoleMetric	getParallelPlaneFillMetric (Mesh mesh, EdgeId 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)
Vector3f	getPickedPointNormal (VisualObject object, std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag point)
Vector3f	getPickedPointPosition (VisualObject object, std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag point)
HoleFillPlan	getPlanarHoleFillPlan (Mesh mesh, EdgeId e)
std_vector_HoleFillPlan	getPlanarHoleFillPlans (Mesh mesh, std_vector_Id_EdgeTag holeRepresentativeEdges)
Plane3d	getPlane3d (MeshTopology topology, VertCoords points, FaceId f)
Plane3f	getPlane3f (MeshTopology topology, VertCoords points, FaceId f)
FillHoleMetric	getPlaneFillMetric (Mesh mesh, EdgeId e)
FillHoleMetric	getPlaneNormalizedFillMetric (Mesh mesh, EdgeId e)
VertBitSet	getRegionBoundaryVerts (MeshTopology topology, FaceBitSet region)
EdgeBitSet	getRegionEdges (MeshTopology topology, FaceBitSet faces)
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	getTopmostObjects_Object (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_ObjectDistanceMap	getTopmostObjects_ObjectDistanceMap (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_ObjectLines	getTopmostObjects_ObjectLines (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_ObjectLinesHolder	getTopmostObjects_ObjectLinesHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_ObjectMesh	getTopmostObjects_ObjectMesh (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_ObjectMeshHolder	getTopmostObjects_ObjectMeshHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_ObjectPoints	getTopmostObjects_ObjectPoints (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_ObjectPointsHolder	getTopmostObjects_ObjectPointsHolder (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_ObjectVoxels	getTopmostObjects_ObjectVoxels (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
std_vector_std_shared_ptr_VisualObject	getTopmostObjects_VisualObject (Object root, ObjectSelectivityType type='ObjectSelectivityType::Selectable', bool visibilityCheck=False)
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')
None	getTriPoints (MeshTopology topology, VertCoords points, FaceId f, Vector3f v0, Vector3f v1, Vector3f v2)
std_array_Vector3_float_3	getTriPoints (MeshTopology topology, VertCoords points, FaceId f)
func_float_from_char_const	getTypeConverter (ScalarType scalarType, int range, int min)
FillHoleMetric	getUniversalMetric (Mesh mesh)
pathlib.Path	getUserConfigDir ()
pathlib.Path	getUserConfigFilePath ()
float	getValue (FloatGrid grid, Vector3i p)
CoordinateConverters	getVectorConverters (MeshPart a)
CoordinateConverters	getVectorConverters (MeshPart a, MeshPart b, AffineXf3f rigidB2A=None)
MeshTriPoint	getVertexAsMeshTriPoint (MeshTopology topology, EdgeId e, VertId v)
VertBMap	getVertexOrdering (FaceBMap faceMap, MeshTopology topology)
std_vector_Id_VertTag	getVertexOrdering (MeshTopology topology, VertBitSet region)
FillHoleMetric	getVerticalStitchMetric (Mesh mesh, Vector3f upDir)
AffineXf3f	getXfFromOxyPlane (std_vector_std_vector_Vector3_float contours)
AffineXf3f	getXfFromOxyPlane (Mesh mesh, std_vector_std_vector_Id_EdgeTag paths)
Mesh	gridToMesh (FloatGrid grid, GridToMeshSettings settings)
None	hardSmoothTetrahedrons (Mesh mesh, VertBitSet region=None)
None	hardSmoothTetrahedrons (MeshTopology topology, VertCoords points, 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, UseAABBTree u='UseAABBTree::Yes')
bool	hasAnyXYPlaneSection (MeshPart mp, float zLevel, UseAABBTree u='UseAABBTree::Yes')
bool	hasFormatPlaceholders (str str)
bool	hasMultipleEdges (MeshTopology topology)
bool	hasProhibitedChars (str line)
int	heapBytes (FloatGrid grid)
int	heapBytes (std_vector_Color vec)
int	heapBytes (std_vector_float vec)
int	heapBytes (std_vector_unsigned_long vec)
int	heapBytes (std_vector_std_shared_ptr_Object vec)
int	heapBytes (Vector_MeshTexture_TextureId vec)
int	heapBytes (Polyline3 ptr)
int	heapBytes (PointCloud ptr)
int	heapBytes (Mesh ptr)
int	heapBytes (Object ptr)
int	heapBytes (BitSet bs)
Vector3d	holeDirArea (MeshTopology topology, VertCoords points, EdgeId e)
float	holePerimiter (MeshTopology topology, VertCoords points, EdgeId e)
func_float_from_Id_EdgeTag	identityMetric ()
bool	improveSampling (PointCloud cloud, VertBitSet samples, ImproveSamplingSettings settings)
bool	inCircle (std_array_PreciseVertCoords2_4 vs)
bool	inCircle (PreciseVertCoords2 vs)
None	inflate (Mesh mesh, VertBitSet verts, InflateSettings settings)
None	inflate (MeshTopology topology, VertCoords points, VertBitSet verts, InflateSettings settings)
None	inflate1 (MeshTopology topology, VertCoords points, VertBitSet verts, float pressure)
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	isClosed (std_vector_VarEdgeTri contour)
bool	isConsistentlyOriented (MeshTopology topology, std_vector_EdgePoint isoline)
bool	isDegree3Dest (MeshTopology topology, EdgeId e)
bool	isEdgeBetweenDoubleTris (MeshTopology topology, EdgeId 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	isPointInsidePolyline (Polyline2 polyline, Vector2f point)
bool	isSupportedFileInSubfolders (os.PathLike|str|bytes folder)
bool	isTIFFFile (os.PathLike|str|bytes path)
EdgeId	isVertexRepeatedOnHoleBd (MeshTopology topology, VertId v)
ToolPathResult	lacingToolPath (MeshPart mp, ToolPathParams params, Axis cutDirection)
float	leftCotan (MeshTopology topology, VertCoords points, EdgeId e)
Vector3f	leftDirDblArea (MeshTopology topology, VertCoords points, EdgeId e)
Vector3f	leftNormal (MeshTopology topology, VertCoords points, EdgeId e)
IteratorRange_RingIterator_NextEdgeSameLeft	leftRing (MeshTopology topology, EdgeId edge)
IteratorRange_RingIterator_NextEdgeSameLeft	leftRing (MeshTopology topology, FaceId f)
IteratorRange_RingIterator_NextEdgeSameLeft	leftRing0 (MeshTopology topology, EdgeId edge)
Vector3f	leftTangent (MeshTopology topology, VertCoords points, EdgeId e)
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, LinesLoadSettings settings='{}')
Polyline3	loadLines (typing.Any in_, str extension, LinesLoadSettings settings='{}')
Mesh	loadMesh (os.PathLike|str|bytes file, MeshLoadSettings settings='{}')
Mesh	loadMesh (typing.Any in_, str extension, MeshLoadSettings settings='{}')
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='{}')
VertCoords	loadPly (typing.Any in_, PlyLoadParams params)
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_FloatGrid	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, bool touchIsIntersection=True, 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)
Mesh	makeBoxMesh (Box3f box)
MakeBridgeResult	makeBridge (MeshTopology topology, EdgeId a, EdgeId b, FaceBitSet outNewFaces=None)
EdgeId	makeBridgeEdge (MeshTopology topology, EdgeId a, EdgeId 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_)
std_vector_Vector2_float	makeConvexHull (std_vector_Vector2_float points)
Mesh	makeCube (Vector3f size='Vector3f::diagonal(1.F)', Vector3f base='Vector3f::diagonal(-0.5F)')
MeshTopology	makeCubeTopology ()
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)
ObjectMeshData	makeDecimatedObjectMeshData (ObjectMesh obj, DecimateSettings settings, DecimateResult outRes=None)
EdgeId	makeDegenerateBandAroundHole (Mesh mesh, EdgeId 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='{}')
int	makeDeloneEdgeFlips (MeshTopology topology, VertCoords points, DeloneSettings settings='{}', int numIters=1, func_bool_from_float progressCallback='{}')
int	makeDeloneEdgeFlips (EdgeLengthMesh mesh, IntrinsicDeloneSettings settings='{}', int numIters=1, func_bool_from_float progressCallback='{}')
None	makeDeloneOriginRing (MeshTopology topology, VertCoords points, EdgeId e, DeloneSettings settings='{}')
None	makeDeloneOriginRing (Mesh mesh, EdgeId 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='{}')
VisualObject	makeObjectFromClassName (str className)
VisualObject	makeObjectFromEnum (FeaturesObjectKind kind)
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, EdgeId a, EdgeId b, FaceBitSet outNewFaces=None)
Mesh	makeRegularGridMesh (int width, int height, func_bool_from_unsigned_long_unsigned_long validator, func_Vector3_float_from_unsigned_long_unsigned_long positioner, func_bool_from_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long faceValidator='{}', 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 (FloatGrid grid, Vector3f voxelSize, Mesh refMesh, MakeSignedByWindingNumberSettings settings)
MakeBridgeResult	makeSmoothBridge (Mesh mesh, EdgeId a, EdgeId b, float samplingStep, FaceBitSet outNewFaces=None)
Mesh	makeSolidOfRevolution (std_vector_Vector2_float profile, int resolution=16)
Mesh	makeSphere (SphereParams params)
MarkedContour3f	makeSpline (MarkedContour3f in_, float markStability=1, std_vector_Vector3_float normals=None)
MarkedContour3f	makeSpline (MarkedContour3f in_, std_vector_Vector3_float normals, float markStability=1)
MarkedContour3f	makeSpline (std_vector_Vector3_float controlPoints, SplineSettings settings)
ObjectMeshData	makeSubdividedObjectMeshData (ObjectMesh obj, SubdivideSettings settings)
Mesh	makeThickMesh (Mesh m, ThickenParams params)
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')
UndirectedEdgeId	mapEdge (MapOrHashMap_UndirectedEdgeId_EdgeId m, UndirectedEdgeId src)
UndirectedEdgeId	mapEdge (UndirectedEdgeBMap map, UndirectedEdgeId src)
EdgeId	mapEdge (WholeEdgeMap map, EdgeId src)
UndirectedEdgeId	mapEdge (WholeEdgeMap map, UndirectedEdgeId src)
EdgeId	mapEdge (phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag map, EdgeId src)
UndirectedEdgeId	mapEdge (phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag map, UndirectedEdgeId src)
EdgeId	mapEdge (MapOrHashMap_UndirectedEdgeId_EdgeId m, EdgeId 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='{}')
Mesh	marchingCubes (SimpleBinaryVolume 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='{}')
TriMesh	marchingCubesAsTriMesh (SimpleBinaryVolume 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_VoxelId_FaceId outMap=None)
Mesh	mcShellMeshRegion (Mesh mesh, FaceBitSet region, float offset, BaseShellParameters params, Vector_VoxelId_FaceId outMap=None)
ObjectLines	merge (std_vector_std_shared_ptr_ObjectLines objsLines)
ObjectPoints	merge (std_vector_std_shared_ptr_ObjectPoints objsPoints)
ObjectMesh	merge (std_vector_std_shared_ptr_ObjectMesh objsMesh)
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_Vector_float_Id_VoxelTag_3	meshToDirectionVolume (MeshToDirectionVolumeParams params)
FloatGrid	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='{}')
FloatGrid	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='{}')
Vector3f	normal (MeshTopology topology, VertCoords points, VertId v)
Vector3f	normal (MeshTopology topology, VertCoords points, MeshTriPoint p)
Vector3f	normal (MeshTopology topology, VertCoords points, FaceId f)
bool	objectHasSelectableChildren (Object object, bool recurse=False)
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	offsetVerts (Mesh mesh, func_float_from_Id_VertTag offset, func_bool_from_float cb='{}')
bool	operator (VertDistance a, VertDistance b)
OutEdge2	opposite (OutEdge2 e)
OutEdge	opposite (OutEdge e)
std_vector_std_vector_VarEdgeTri	orderIntersectionContours (MeshTopology topologyA, MeshTopology topologyB, std_vector_VarEdgeTri intersections)
std_vector_std_vector_VarEdgeTri	orderSelfIntersectionContours (MeshTopology topology, std_vector_EdgeTri intersections)
Vector3f	orgPnt (MeshTopology topology, VertCoords points, EdgeId e)
IteratorRange_RingIterator_NextEdgeSameOrigin	orgRing (MeshTopology topology, EdgeId edge)
IteratorRange_RingIterator_NextEdgeSameOrigin	orgRing (MeshTopology topology, VertId v)
IteratorRange_RingIterator_NextEdgeSameOrigin	orgRing0 (MeshTopology topology, EdgeId 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='{}')
bool	orientParaboloid3d (Vector2i a, Vector2i b, Vector2i c)
bool	orientParaboloid3d (Vector2i a, Vector2i b, Vector2i c, Vector2i d)
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='{}')
None	planeMeshIntersect (MeshPart meshPart, Plane3f plane, FaceBitSet fs, UndirectedEdgeBitSet ues, VertBitSet vs, std_vector_Id_FaceTag fsVec=None)
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 (PointCloudPart pcp, float voxelSize, func_bool_from_float cb='{}')
VertBitSet	pointIterativeSampling (PointCloud cloud, int numSamples, func_bool_from_float cb='{}')
std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag	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)
FloatGrid	polylineToDistanceField (Polyline3 polyline, PolylineToDistanceVolumeParams params)
FunctionVolume	polylineToFunctionVolume (Polyline3 polyline, PolylineToVolumeParams params)
SimpleVolume	polylineToSimpleVolume (Polyline3 polyline, PolylineToVolumeParams params)
VdbVolume	polylineToVdbVolume (Polyline3 polyline, PolylineToDistanceVolumeParams params)
None	positionVertsSmoothly (Mesh mesh, VertBitSet verts, EdgeWeights edgeWeights='EdgeWeights::Cotan', VertexMass vmass='VertexMass::Unit', VertBitSet fixedSharpVertices=None)
None	positionVertsSmoothly (MeshTopology topology, VertCoords points, VertBitSet verts, EdgeWeights edgeWeights='EdgeWeights::Cotan', VertexMass vmass='VertexMass::Unit', VertBitSet fixedSharpVertices=None)
None	positionVertsSmoothlySharpBd (Mesh mesh, PositionVertsSmoothlyParams params)
None	positionVertsSmoothlySharpBd (MeshTopology topology, VertCoords points, PositionVertsSmoothlyParams params)
None	positionVertsSmoothlySharpBd (Mesh mesh, VertBitSet verts)
None	positionVertsWithSpacing (Mesh mesh, SpacingSettings settings)
None	positionVertsWithSpacing (MeshTopology topology, VertCoords points, 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)
float	projArea (MeshTopology topology, VertCoords points, Vector3f dir, FaceBitSet fs)
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='{}')
MeshOrPoints.ProjectionResult	projectWorldPointOntoObject (Vector3f p, Object obj)
MeshOrPoints.ProjectionResult	projectWorldPointOntoObjectsRecursive (Vector3f p, Object root=None, func_bool_from_Object projectPred=None, func_bool_from_Object recursePred=None)
Vector3f	pseudonormal (MeshTopology topology, VertCoords points, VertId v, FaceBitSet region=None)
Vector3f	pseudonormal (MeshTopology topology, VertCoords points, UndirectedEdgeId e, FaceBitSet region=None)
Vector3f	pseudonormal (MeshTopology topology, VertCoords points, MeshTriPoint p, FaceBitSet region=None)
None	putScanFileNameInZ (std_vector_std_filesystem_path scans, std_vector_SliceInfo zOrder)
QuadraticForm3f	quadraticForm (MeshTopology topology, VertCoords points, VertId v, bool angleWeigted, FaceBitSet region=None, UndirectedEdgeBitSet creases=None)
bool	rayBoxIntersect (Box2f box, Line2f line, float t0, float t1)
bool	rayBoxIntersect (Box3f box, Line3f line, float t0, float t1)
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)
None	rayPolylineIntersectAll (Polyline2 polyline, Line2f line, func_Processing_from_EdgePoint_float_float_float callback, float rayStart=0.0, float rayEnd=3.4028234663852886e+38, IntersectionPrecomputes2_float prec=None)
None	rayPolylineIntersectAll (Polyline2 polyline, Line2d line, func_Processing_from_EdgePoint_double_double_double callback, float rayStart=0.0, float rayEnd=1.7976931348623157e+308, IntersectionPrecomputes2_double prec=None)
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)
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 (MeshTopology topology, VertCoords points, 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 (MeshTopology topology, VertCoords points, 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 (MeshTopology topology, VertCoords points, 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_VarEdgeTri contours, bool ignoreOpen=False)
None	removeLoneDegeneratedContours (MeshTopology edgesTopology, std_vector_OneMeshContour faceContours, std_vector_OneMeshContour edgeContours)
None	removeSpikes (Mesh mesh, int maxIterations, float minSumAngle, VertBitSet region=None)
None	removeSpikes (MeshTopology topology, VertCoords points, 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)
FloatGrid	resampled (FloatGrid grid, float voxelScale, func_bool_from_float cb='{}')
FloatGrid	resampled (FloatGrid grid, Vector3f voxelScale, func_bool_from_float cb='{}')
bool	resolveMeshDegenerations (Mesh mesh, ResolveMeshDegenSettings settings='{}')
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, func_bool_from_float progress='{}')
bool	segmentIntersectionOrder (std_array_PreciseVertCoords2_6 vs)
bool	segmentIntersectionOrder (std_array_PreciseVertCoords_8 vs)
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='{}')
Mesh	selfBoolean (Mesh mesh)
std_vector_TypedBitSet_Id_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 (FloatGrid grid)
None	setNewHandlerIfNeeded ()
None	setValue (FloatGrid grid, Vector3i p, float value)
None	setValue (FloatGrid grid, VoxelBitSet region, float value)
None	setupLoggerByDefault ()
Mesh	sharpOffsetMesh (MeshPart mp, float offset, SharpOffsetParameters params='{}')
None	sharpenMarchingCubesMesh (MeshPart ref, Mesh vox, Vector_VoxelId_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)
FloatGrid	simpleVolumeToDenseGrid (SimpleVolume simpleVolume, float background=0.0, func_bool_from_float cb='{}')
VdbVolume	simpleVolumeToVdbVolume (SimpleVolumeMinMax simpleVolume, func_bool_from_float cb='{}')
bool	smaller (PreciseVertCoord l, PreciseVertCoord r)
bool	smaller2 (std_array_PreciseVertCoords2_4 vs)
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)
IteratorRange_ChunkIterator	splitByChunks (int totalSize, int chunkSize, int overlap=0)
std_vector_unsigned_long	splitByLines (str data, int size)
std_vector_std_vector_Id_EdgeTag	splitOnSimpleLoops (MeshTopology topology, std_vector_std_vector_Id_EdgeTag loops)
None	splitQuad (MeshTopology topology, EdgeId 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)
None	stitchContours (MeshTopology topology, std_vector_Id_EdgeTag c0, std_vector_Id_EdgeTag c1)
None	straightenBoundary (Mesh mesh, EdgeId 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	subdivideMesh (ObjectMeshData data, SubdivideSettings settings)
int	subdividePolyline (Polyline2 polyline, PolylineSubdivideSettings settings='{}')
int	subdividePolyline (Polyline3 polyline, PolylineSubdivideSettings settings='{}')
UndirectedEdgeBitSet	subdivideWithPlane (Polyline3 polyline, Plane3f plane, EdgeBitSet newPositiveEdges='{}', func_void_from_Id_EdgeTag_Id_EdgeTag_float onEdgeSplitCallback='{}')
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	sumAngles (MeshTopology topology, VertCoords points, VertId v, bool_output outBoundaryVert=None)
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_VertTag keyVertices, func_float_from_Id_EdgeTag edgeMetric, Vector3f dir)
std_vector_Id_EdgeTag	surroundingContour (Mesh mesh, std_vector_Id_EdgeTag includeEdges, func_float_from_Id_EdgeTag edgeMetric, Vector3f dir)
str	systemToUtf8 (str system)
std_array_VoxelsVolumeMinMax_Vector_float_Id_VoxelTag_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='{}', PartMapping map='{}')
EdgePoint	toEdgePoint (MeshTopology topology, VertCoords points, EdgeId e, Vector3f p)
str	toLower (str str)
str	toString (DimensionsVisualizePropertyType value)
str	toString (PathError error)
MeshTriPoint	toTriPoint (MeshTopology topology, VertCoords points, FaceId f, Vector3f p)
MeshTriPoint	toTriPoint (MeshTopology topology, VertCoords points, PointOnFace p)
MeshTopology	topologyFromTriangles (Triangulation t, MeshBuilder.BuildSettings settings='{}', func_bool_from_float progressCb='{}')
std_vector_Id_EdgeTag	trackLeftBoundaryLoop (MeshTopology topology, EdgeId e0, FaceBitSet region=None)
std_vector_Id_EdgeTag	trackLeftBoundaryLoop (MeshTopology topology, FaceBitSet region, EdgeId e0)
std_vector_Id_EdgeTag	trackRightBoundaryLoop (MeshTopology topology, EdgeId e0, FaceBitSet region=None)
std_vector_Id_EdgeTag	trackRightBoundaryLoop (MeshTopology topology, FaceBitSet region, EdgeId e0)
std_vector_EdgePoint	trackSection (MeshPart mp, MeshTriPoint start, MeshTriPoint end, Vector3f direction, float distance)
std_vector_EdgePoint	trackSection (MeshPart mp, MeshTriPoint start, MeshTriPoint end, Vector3f planePoint, bool ccw)
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='{}')
Vector3f	triCenter (MeshTopology topology, VertCoords points, FaceId f)
Vector3f	triPoint (MeshTopology topology, VertCoords points, MeshTriPoint p)
float	triangleAspectRatio (MeshTopology topology, VertCoords points, FaceId f)
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	trim (str str)
str	trimLeft (str str)
str	trimRight (str str)
None	trimWithPlane (Polyline3 polyline, Plane3f plane, DividePolylineParameters params='{}')
None	trimWithPlane (Mesh mesh, TrimWithPlaneParams params, TrimOptionalOutput optOut='{}')
IteratorRange_UndirectedEdgeIterator	undirectedEdges (MeshTopology topology)
IteratorRange_PolylineUndirectedEdgeIterator	undirectedEdges (PolylineTopology topology)
Vector3d	unitVector3_double (float azimuth, float altitude)
Vector3f	unitVector3_float (float azimuth, float altitude)
int	uniteCloseVertices (Mesh mesh, float closeDist, bool uniteOnlyBd=True, VertMap optionalVertOldToNew=None)
int	uniteCloseVertices (Mesh mesh, MeshBuilder.UniteCloseParams params='{}')
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	utf8string (os.PathLike|str|bytes path)
str	utf8substr (str s, int pos, int count)
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)
Vector3f	vertexPosEqualNeiAreas (Mesh mesh, VertId v, bool noShrinkage)
Vector3f	vertexPosEqualNeiAreas (MeshTopology topology, VertCoords points, VertId v, bool noShrinkage)
VertBitSet	verticesGridSampling (MeshPart mp, float voxelSize, func_bool_from_float cb='{}')
float	volume (MeshTopology topology, VertCoords points, FaceBitSet region=None)
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_unsigned_long	voxelsExponentMetric (VdbVolume voxels, VoxelMetricParameters parameters, float modifier=-1.0)
func_float_from_unsigned_long_unsigned_long	voxelsSumDiffsMetric (VdbVolume voxels, VoxelMetricParameters parameters)
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, std_vector_Id_FaceTag fsVec=None)
bool	zCompensate (Mesh mesh, ZCompensateParams params)
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_Id_VoxelTag_Id_VoxelTag = BMap_VoxelId_VoxelId
	BMap_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType = BMap_Id_ICPElemtTag_Id_ICPElemtTag
	BMap_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType = BMap_VoxelId_VoxelId
	BooleanResMapObj = BooleanResultMapper.MapObject
	Box_Vector2d_Vb = Vector2b
	Box_Vector2f_Vb = Vector2b
	Box_Vector2i64_Vb = Vector2b
	Box_Vector2i_Vb = Vector2b
	Box_Vector3d_Vb = Vector3b
	Box_Vector3f_Vb = Vector3b
	Box_Vector3i64_Vb = Vector3b
	Box_Vector3i_Vb = Vector3b
	Buffer_Id_EdgeTag_Id_EdgeTag = Buffer_EdgeId_EdgeId
	Buffer_Id_EdgeTag_Id_EdgeTag_T = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_Id_EdgeTag_const_iterator = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_Id_EdgeTag_const_reference = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_Id_EdgeTag_iterator = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_Id_EdgeTag_reference = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_UndirectedEdgeId_T = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_UndirectedEdgeId_const_iterator = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_UndirectedEdgeId_const_reference = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_UndirectedEdgeId_iterator = NoDefInit_EdgeId
	Buffer_Id_EdgeTag_UndirectedEdgeId_reference = NoDefInit_EdgeId
	Buffer_Id_VoxelTag_Id_VoxelTag = Buffer_VoxelId_VoxelId
	Buffer_Id_VoxelTag_Id_VoxelTag_T = NoDefInit_VoxelId
	Buffer_Id_VoxelTag_Id_VoxelTag_const_iterator = NoDefInit_VoxelId
	Buffer_Id_VoxelTag_Id_VoxelTag_const_reference = NoDefInit_VoxelId
	Buffer_Id_VoxelTag_Id_VoxelTag_iterator = NoDefInit_VoxelId
	Buffer_Id_VoxelTag_Id_VoxelTag_reference = NoDefInit_VoxelId
	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_VarEdgeTri
	ContinuousContours = std_vector_std_vector_VarEdgeTri
	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
	DashPattern = Vector4_unsigned_char
	DecimatePolylineSettings2 = DecimatePolylineSettings_Vector2f
	DecimatePolylineSettings3 = DecimatePolylineSettings_Vector3f
	EdgeHashMap = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
	EdgeLoop = std_vector_Id_EdgeTag
	EdgeLoops = std_vector_std_vector_Id_EdgeTag
	EdgeMapOrHashMap = MapOrHashMap_EdgeId_EdgeId
	EdgePath = std_vector_Id_EdgeTag
	EdgePathsBuilder = EdgePathsBuilderT_TrivialMetricToPenalty
	FaceHashMap = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag
	FaceMapOrHashMap = MapOrHashMap_FaceId_FaceId
	FaceTreeTraits3 = AABBTreeTraits_FaceTag_Box3f
	FeaturesPropertyTypesVariant = std_variant_float_Vector3_float
	FileNamesStack = std_vector_std_filesystem_path
	FixSelfIntersectionMethod = SelfIntersections.Settings.Method
	FixSelfIntersectionSettings = SelfIntersections.Settings
	GcodeSource = std_vector_std_string
	GeneralOffsetParametersMode = OffsetMode
	HashMap_EdgeId_EdgeId = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
	HashMap_Id_EdgeTag_Id_EdgeTag = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
	HashMap_TypedBitSet_Id_EdgeTag_IndexType_TypedBitSet_Id_EdgeTag_IndexType = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
	HashMap_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType = phmap_flat_hash_map_Id_ICPElemtTag_Id_ICPElemtTag
	HashMap_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType = phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag
	HistoryActionsVector = std_vector_std_shared_ptr_HistoryAction
	ICPElementBitSet = TypedBitSet_Id_ICPElemtTag
	ICPElementId = Id_ICPElemtTag
	ICPObjects = Vector_MeshOrPointsXf_ObjId
	ICPPairsGrid = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag
	IOFilters = std_vector_IOFilter
	Id_EdgeTag = EdgeId
	Id_VoxelTag = VoxelId
	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
	MapOrHashMap_Id_EdgeTag_Id_EdgeTag = MapOrHashMap_EdgeId_EdgeId
	MapOrHashMap_Id_EdgeTag_Id_EdgeTag_Dense = EdgeMap
	MapOrHashMap_Id_EdgeTag_Id_EdgeTag_Hash = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
	MapOrHashMap_UndirectedEdgeId_Id_EdgeTag_Dense = WholeEdgeMap
	MapOrHashMap_UndirectedEdgeId_Id_EdgeTag_Hash = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag
	Matrix2_bool_VectorType = Vector2b
	Matrix2_double_VectorType = Vector2d
	Matrix2_float_VectorType = Vector2f
	Matrix2_int_VectorType = Vector2i
	Matrix2_long_VectorType = Vector2i64
	Matrix3_bool_VectorType = Vector3b
	Matrix3_double_VectorType = Vector3d
	Matrix3_float_VectorType = Vector3f
	Matrix3_int_VectorType = Vector3i
	Matrix3_long_VectorType = Vector3i64
	Matrix4_bool_VectorType = Vector4b
	Matrix4_double_VectorType = Vector4d
	Matrix4_float_VectorType = Vector4f
	Matrix4_int_VectorType = Vector4i
	Matrix4_long_VectorType = Vector4i64
	MeshBuilderSettings = MeshBuilder.BuildSettings
	MeshEdgePoint = EdgePoint
	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
	MeshToVolumeParamsType = MeshToVolumeParams.Type
	MinMax_VoxelsVolume_Vector_unsigned_short_Id_VoxelTag_ValueType = Box_unsigned_short
	MinMaxd = Box1d
	MinMaxf = Box1f
	MinMaxi = Box1i
	MultiObjsSamples = std_vector_ObjVertId
	NoCtor_Id_EdgeTag = NoCtor_EdgeId
	NoCtor_Id_EdgeTag_type = NoDefInit_EdgeId
	NoCtor_Id_VoxelTag = NoCtor_VoxelId
	NoCtor_Id_VoxelTag_type = NoDefInit_VoxelId
	NoDefInit_Id_EdgeTag = NoDefInit_EdgeId
	NoDefInit_Id_VoxelTag = NoDefInit_VoxelId
	ObjectPtr = Object
	OffsetContoursVertMap = std_vector_OffsetContoursOrigins
	OffsetContoursVertMaps = std_vector_std_vector_OffsetContoursOrigins
	OneMeshContours = std_vector_OneMeshContour
	OrgRingIterator = RingIterator_NextEdgeSameOrigin
	PdfGeneralFont = std_variant_PdfBuildinFont_std_filesystem_path
	PickedPoint = std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag
	PlaneSection = std_vector_EdgePoint
	PlaneSections = std_vector_std_vector_EdgePoint
	PolynomialWrapperd = PolynomialWrapper_double
	PolynomialWrapperf = PolynomialWrapper_float
	Polynomial_double_0ul_0_0_0ulminus1 = Polynomial_double_0
	Polynomial_double_1ul_0_0_1ulminus1 = Polynomial_double_0
	Polynomial_double_2ul_0_0_2ulminus1 = Polynomial_double_1
	Polynomial_double_3ul_0_0_3ulminus1 = Polynomial_double_2
	Polynomial_double_4ul_0_0_4ulminus1 = Polynomial_double_3
	Polynomial_double_5ul_0_0_5ulminus1 = Polynomial_double_4
	Polynomial_double_6ul_0_0_6ulminus1 = Polynomial_double_5
	Polynomial_float_0ul_0_0_0ulminus1 = Polynomial_float_0
	Polynomial_float_1ul_0_0_1ulminus1 = Polynomial_float_0
	Polynomial_float_2ul_0_0_2ulminus1 = Polynomial_float_1
	Polynomial_float_3ul_0_0_3ulminus1 = Polynomial_float_2
	Polynomial_float_4ul_0_0_4ulminus1 = Polynomial_float_3
	Polynomial_float_5ul_0_0_5ulminus1 = Polynomial_float_4
	Polynomial_float_6ul_0_0_6ulminus1 = Polynomial_float_5
	Polynomialx_double = std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul
	Polynomialx_float = std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul
	PreciseCollisionResult = std_vector_VarEdgeTri
	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_std_array_Id_VertTag_3ul
	SeparationPointSet = std_array_Id_VertTag_3
	SurfacePath = std_vector_EdgePoint
	SurfacePaths = std_vector_std_vector_EdgePoint
	TaggedBitSet_ICPElemtTag = TypedBitSet_Id_ICPElemtTag
	TextAlignParams = TextMeshAlignParams
	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
	TwoVertIds = std_array_Id_VertTag_2
	TypedBitSet_FaceId_IndexType = FaceId
	TypedBitSet_FaceId_base = BitSet
	TypedBitSet_GraphEdgeId_IndexType = GraphEdgeId
	TypedBitSet_GraphEdgeId_base = BitSet
	TypedBitSet_GraphVertId_IndexType = GraphVertId
	TypedBitSet_GraphVertId_base = BitSet
	TypedBitSet_Id_EdgeTag_IndexType = EdgeId
	TypedBitSet_Id_EdgeTag_base = BitSet
	TypedBitSet_Id_VoxelTag_IndexType = VoxelId
	TypedBitSet_Id_VoxelTag_base = BitSet
	TypedBitSet_NodeId_IndexType = NodeId
	TypedBitSet_NodeId_base = BitSet
	TypedBitSet_ObjId_IndexType = ObjId
	TypedBitSet_ObjId_base = BitSet
	TypedBitSet_PixelId_IndexType = PixelId
	TypedBitSet_PixelId_base = BitSet
	TypedBitSet_RegionId_IndexType = RegionId
	TypedBitSet_RegionId_base = BitSet
	TypedBitSet_TextureId_IndexType = TextureId
	TypedBitSet_TextureId_base = BitSet
	TypedBitSet_UndirectedEdgeId_IndexType = UndirectedEdgeId
	TypedBitSet_UndirectedEdgeId_base = BitSet
	TypedBitSet_VertId_IndexType = VertId
	TypedBitSet_VertId_base = BitSet
	UVCoord = Vector2f
	UndirectedEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag
	UndirectedEdgeMapOrHashMap = MapOrHashMap_UndirectedEdgeId_UndirectedEdgeId
	VdbVolumes = std_vector_VoxelsVolumeMinMax_FloatGrid
	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_MatrixType = Matrix2i64
	Vector2_long_SymMatrixType = SymMatrix2i64
	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_MatrixType = Matrix3i64
	Vector3_long_SymMatrixType = SymMatrix3i64
	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_MatrixType = Matrix4i64
	Vector4_long_SymMatrixType = SymMatrix4i64
	Vector4_uint8_t = Vector4_unsigned_char
	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_FaceId_const_reference = EdgeId
	Vector_Id_EdgeTag_FaceId_reference = EdgeId
	Vector_Id_EdgeTag_FaceId_value_type = EdgeId
	Vector_Id_EdgeTag_Id_EdgeTag_const_reference = EdgeId
	Vector_Id_EdgeTag_Id_EdgeTag_reference = EdgeId
	Vector_Id_EdgeTag_Id_EdgeTag_value_type = EdgeId
	Vector_Id_EdgeTag_UndirectedEdgeId_const_reference = EdgeId
	Vector_Id_EdgeTag_UndirectedEdgeId_reference = EdgeId
	Vector_Id_EdgeTag_UndirectedEdgeId_value_type = EdgeId
	Vector_Id_EdgeTag_VertId_const_reference = EdgeId
	Vector_Id_EdgeTag_VertId_reference = EdgeId
	Vector_Id_EdgeTag_VertId_value_type = EdgeId
	Vector_Id_VoxelTag_FaceId_const_reference = VoxelId
	Vector_Id_VoxelTag_FaceId_reference = VoxelId
	Vector_Id_VoxelTag_FaceId_value_type = VoxelId
	Vector_Id_VoxelTag_Id_VoxelTag = Vector_VoxelId_VoxelId
	Vector_Id_VoxelTag_Id_VoxelTag_const_reference = VoxelId
	Vector_Id_VoxelTag_Id_VoxelTag_reference = VoxelId
	Vector_Id_VoxelTag_Id_VoxelTag_value_type = VoxelId
	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_TextureId_FaceId_const_reference = TextureId
	Vector_TextureId_FaceId_reference = TextureId
	Vector_TextureId_FaceId_value_type = TextureId
	Vector_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType = Vector_Id_ICPElemtTag_Id_ICPElemtTag
	Vector_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType = Vector_VoxelId_VoxelId
	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_Id_EdgeTag_const_reference = VertId
	Vector_VertId_Id_EdgeTag_reference = VertId
	Vector_VertId_Id_EdgeTag_value_type = VertId
	Vector_VertId_VertId_const_reference = VertId
	Vector_VertId_VertId_reference = VertId
	Vector_VertId_VertId_value_type = VertId
	Vector_float_Id_VoxelTag = Vector_float_VoxelId
	Vector_std_array_VertId_2_UndirectedEdgeId_const_reference = std_array_Id_VertTag_2
	Vector_std_array_VertId_2_UndirectedEdgeId_reference = std_array_Id_VertTag_2
	Vector_std_array_VertId_2_UndirectedEdgeId_value_type = std_array_Id_VertTag_2
	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
	Vector_unsigned_short_Id_VoxelTag = Vector_unsigned_short_VoxelId
	VertHashMap = phmap_flat_hash_map_Id_VertTag_Id_VertTag
	VertMapOrHashMap = MapOrHashMap_VertId_VertId
	VertNormals = VertCoords
	VertPathInfoMap = phmap_flat_hash_map_Id_VertTag_VertPathInfo
	VertUVCoords = VertCoords2
	ViewportProperty_uint8_t = ViewportProperty_unsigned_char
	VoxelTraits_Vector_float_Id_VoxelTag = VoxelTraits_Vector_float_VoxelId
	VoxelTraits_Vector_unsigned_short_Id_VoxelTag = VoxelTraits_Vector_unsigned_short_VoxelId
	VoxelsSaveSavingSettings = VoxelsSave.SavingSettings
	WholeEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag
	WholeEdgeMapOrHashMap = MapOrHashMap_UndirectedEdgeId_EdgeId
	copyMesh = Mesh
	phmap_flat_hash_map_EdgeId_EdgeId = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
	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_EdgeId = 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_VoxelId_VoxelId = phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag
	phmap_flat_hash_map_int_Box3i_phmap_Hash_int32_t = phmap_flat_hash_map_int_Box_Vector3_int
	phmap_flat_hash_map_unsigned_long_std_array_VertId_3_phmap_Hash_uint64_t = phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul
	std_array_AffineXf3d_4 = std_array_AffineXf_Vector3_double_4
	std_array_AffineXf3f_4 = std_array_AffineXf_Vector3_float_4
	std_array_BooleanResultMapper_Maps_size_t_MapObject_Count = std_array_BooleanResultMapper_Maps_2
	std_array_CubicBezierCurve_Vector2d_T_4 = std_array_double_4
	std_array_CubicBezierCurve_Vector2f_T_4 = std_array_float_4
	std_array_CubicBezierCurve_Vector3d_T_4 = std_array_double_4
	std_array_CubicBezierCurve_Vector3f_T_4 = std_array_float_4
	std_array_SimpleVolumeMinMax_3 = std_array_VoxelsVolumeMinMax_Vector_float_Id_VoxelTag_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_2 = std_array_Id_VertTag_2
	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_Edges = std_optional_Vector_std_array_Id_VertTag_2ul_Id_UndirectedEdgeTag
	std_optional_Triangulation = std_optional_Vector_std_array_Id_VertTag_3ul_Id_FaceTag
	std_optional_Vector2f = std_optional_Vector2_float
	std_optional_Vector3f = std_optional_Vector3_float
	std_optional_std_variant_float_Vector3f = std_optional_std_variant_float_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_DistanceMap = DistanceMap
	std_shared_ptr_GcodeSource = std_vector_std_string
	std_shared_ptr_Mesh = Mesh
	std_shared_ptr_Object = Object
	std_shared_ptr_ObjectLines = ObjectLines
	std_shared_ptr_ObjectLinesHolder = ObjectLinesHolder
	std_shared_ptr_ObjectMesh = ObjectMesh
	std_shared_ptr_ObjectMeshHolder = ObjectMeshHolder
	std_shared_ptr_ObjectPoints = ObjectPoints
	std_shared_ptr_ObjectVoxels = ObjectVoxels
	std_shared_ptr_PointCloud = PointCloud
	std_shared_ptr_Polyline3 = Polyline3
	std_shared_ptr_VisualObject = VisualObject
	std_shared_ptr_const_Mesh = Mesh
	std_shared_ptr_const_PointCloud = PointCloud
	std_shared_ptr_const_Polyline3 = Polyline3
	std_shared_ptr_std_vector_std_string = std_vector_std_string
	std_unique_ptr_NoDefInit_Id_EdgeTag_pointer = NoDefInit_EdgeId
	std_unique_ptr_NoDefInit_Id_ICPElemtTag_pointer = NoDefInit_Id_ICPElemtTag
	std_unique_ptr_NoDefInit_Id_VoxelTag_pointer = NoDefInit_VoxelId
	std_variant_EdgeMap_phmap_flat_hash_map_EdgeId_EdgeId = std_variant_Vector_Id_EdgeTag_Id_EdgeTag_phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag
	std_variant_FaceId_EdgeId_VertId = std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag
	std_variant_FaceMap_phmap_flat_hash_map_FaceId_FaceId = std_variant_Vector_Id_FaceTag_Id_FaceTag_phmap_flat_hash_map_Id_FaceTag_Id_FaceTag
	std_variant_Polynomial_double_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6 = std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul
	std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6 = std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul
	std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane
	std_variant_UndirectedEdgeMap_phmap_flat_hash_map_UndirectedEdgeId_UndirectedEdgeId = std_variant_Vector_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag_phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag
	std_variant_VertMap_phmap_flat_hash_map_VertId_VertId = std_variant_Vector_Id_VertTag_Id_VertTag_phmap_flat_hash_map_Id_VertTag_Id_VertTag
	std_variant_WholeEdgeMap_phmap_flat_hash_map_UndirectedEdgeId_EdgeId = std_variant_Vector_Id_EdgeTag_Id_UndirectedEdgeTag_phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag
	std_variant_float_Vector3f = std_variant_float_Vector3_float
	std_variant_std_monostate_MeshTriPoint_EdgePoint_VertId = std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag
	std_variant_std_reference_wrapper_const_FillingSurface_TPMS_MeshParams_std_reference_wrapper_const_FillingSurface_CellularSurface_Params = std_variant_std_reference_wrapper_FillingSurface_TPMS_MeshParams_const_std_reference_wrapper_FillingSurface_CellularSurface_Params_const
	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_VarEdgeTri
	std_vector_Dipole_const_reference = Dipole
	std_vector_Dipole_reference = Dipole
	std_vector_Dipole_value_type = Dipole
	std_vector_EdgeBitSet = std_vector_TypedBitSet_Id_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_TypedBitSet_Id_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 = EdgeId
	std_vector_Id_EdgeTag_reference = EdgeId
	std_vector_Id_EdgeTag_value_type = EdgeId
	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 = VoxelId
	std_vector_Id_VoxelTag_reference = VoxelId
	std_vector_Id_VoxelTag_value_type = VoxelId
	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_4ul
	std_vector_TextureId = std_vector_Id_TextureTag
	std_vector_TriPointf = std_vector_TriPoint_float
	std_vector_UndirectedEdgeBitSet = std_vector_TypedBitSet_Id_UndirectedEdgeTag
	std_vector_UndirectedEdgeId = std_vector_Id_UndirectedEdgeTag
	std_vector_VdbVolume = std_vector_VoxelsVolumeMinMax_FloatGrid
	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_TypedBitSet_Id_VertTag
	std_vector_VertId = std_vector_Id_VertTag
	std_vector_VoxelBitSet = std_vector_TypedBitSet_Id_VoxelTag
	std_vector_VoxelId = std_vector_Id_VoxelTag
	std_vector_WatershedGraph_BasinInfo_const_reference = WatershedGraph.BasinInfo
	std_vector_WatershedGraph_BasinInfo_reference = WatershedGraph.BasinInfo
	std_vector_WatershedGraph_BasinInfo_value_type = WatershedGraph.BasinInfo
	std_vector_WatershedGraph_BdInfo_const_reference = WatershedGraph.BdInfo
	std_vector_WatershedGraph_BdInfo_reference = WatershedGraph.BdInfo
	std_vector_WatershedGraph_BdInfo_value_type = WatershedGraph.BdInfo
	std_vector_const_Mesh = std_vector_Mesh_const
	std_vector_size_t = std_vector_unsigned_long
	std_vector_std_array_Vector3f_3 = std_vector_std_array_Vector3_float_3ul
	std_vector_std_array_VertId_2 = std_vector_std_array_Id_VertTag_2ul
	std_vector_std_array_VertId_3 = std_vector_std_array_Id_VertTag_3ul
	std_vector_std_array_std_filesystem_path_4 = std_vector_std_array_std_filesystem_path_4ul
	std_vector_std_pair_EdgeId_EdgeId = std_vector_std_pair_Id_EdgeTag_Id_EdgeTag
	std_vector_std_pair_Vector3f_Vector3f = std_vector_std_pair_Vector3_float_Vector3_float
	std_vector_std_pair_VertId_VertId = std_vector_std_pair_Id_VertTag_Id_VertTag
	std_vector_std_pair_size_t_size_t = std_vector_std_pair_unsigned_long_unsigned_long
	std_vector_std_shared_ptr_const_Object = std_vector_std_shared_ptr_Object_const
	std_vector_std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_vector_std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane
	std_vector_std_vector_EdgeId = std_vector_std_vector_Id_EdgeTag
	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_FloatGrid_std_string
	std_vector_tl_expected_VoxelsLoad_DicomVolume_std_string = std_vector_tl_expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_Vector_float_Id_VoxelTag_std_string
	std_vector_uint8_t = std_vector_unsigned_char
	tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string = expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_FloatGrid_std_string
	tl_expected_VoxelsLoad_DicomVolume_std_string = expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_Vector_float_Id_VoxelTag_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,
		PointCloudPart	pcp,
		AffineXf3f	xf = None )

Adds in existing PointAccumulator all points from the cloud (region) 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
note that this function also packs the 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

alignContoursToMesh()

Mesh mrmeshpy.alignContoursToMesh	(	Mesh	mesh,
		std_vector_std_vector_Vector2_float	contours,
		ContoursMeshAlignParams	params )

Creates planar mesh out of given contour and aligns it to given surface

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

area() [1/2]

float mrmeshpy.area	(	MeshTopology	topology,
		VertCoords	points,
		FaceBitSet	fs = None )

computes the area of given face-region

computes the area of given face-region (or whole mesh)

area() [2/2]

float mrmeshpy.area	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

returns the area of given face

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

(

ColoringType

ct

)

returns string representation of enum values

asString() [2/2]

str mrmeshpy.asString

(

SignDetectionMode

m

)

returns string representation of enum values

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

averageEdgeLength()

float mrmeshpy.averageEdgeLength	(	MeshTopology	topology,
		VertCoords	points )

computes average length of an edge in the mesh given by (topology, points)

begin() [1/6]

ChunkIterator mrmeshpy.begin

(

IteratorRange_ChunkIterator

range

)

begin() [2/6]

PolylineUndirectedEdgeIterator mrmeshpy.begin

(

IteratorRange_PolylineUndirectedEdgeIterator

range

)

begin() [3/6]

RingIterator_NextEdgeSameLeft mrmeshpy.begin

(

IteratorRange_RingIterator_NextEdgeSameLeft

range

)

begin() [4/6]

RingIterator_NextEdgeSameOrigin mrmeshpy.begin

(

IteratorRange_RingIterator_NextEdgeSameOrigin

range

)

begin() [5/6]

UndirectedEdgeIterator mrmeshpy.begin

(

IteratorRange_UndirectedEdgeIterator

range

)

begin() [6/6]

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

Makes new mesh - result of boolean operation on mesh `A` and mesh `B`
\\snippet cpp-examples/MeshBoolean.dox.cpp 0

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

EdgeId mrmeshpy.buildBottom	(	Mesh	mesh,
		EdgeId	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,
		EdgeId	a,
		EdgeId	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

\\snippet cpp-examples/MeshStitchHole.dox.cpp 0

\\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 mrmeshpy.buildSmallestMetricPath	(	VdbVolume	voxels,
		func_float_from_unsigned_long_unsigned_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

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

canFlipEdge()

FlipEdge mrmeshpy.canFlipEdge	(	MeshTopology	topology,
		EdgeId	edge,
		FaceBitSet	region = None,
		UndirectedEdgeBitSet	notFlippable = None,
		VertBitSet	vertRegion = None )

consider topology and constraints to decide about flip possibility

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

)

return true if the smallest rotation from vector (vs[0]-vs[2]) to vector (vs[1]-vs[2]) is in counter-clock-wise direction;
uses simulation-of-simplicity (assuming larger perturbations of points with smaller id) to avoid "vectors are collinear"

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 (assuming perturbations a >> b) 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 (assuming perturbations a >> b >> c) 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() [1/2]

bool mrmeshpy.checkDeloneQuadrangleInMesh	(	Mesh	mesh,
		EdgeId	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)

checkDeloneQuadrangleInMesh() [2/2]

bool mrmeshpy.checkDeloneQuadrangleInMesh	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	edge,
		DeloneSettings	settings = '{}',
		float_output	deviationSqAfterFlip = None )

chunkCount()

int mrmeshpy.chunkCount	(	int	totalSize,
		int	chunkSize,
		int	overlap = 0 )

returns the amount of chunks of given size required to cover the full array

circumcircleDiameter()

float mrmeshpy.circumcircleDiameter	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

returns circumcircle diameter of given mesh triangle

circumcircleDiameterSq()

float mrmeshpy.circumcircleDiameterSq	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

returns squared circumcircle diameter of given mesh triangle

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/3]

ObjectLines mrmeshpy.cloneRegion	(	ObjectLines	objLines,
		UndirectedEdgeBitSet	region )

constructs new ObjectLines containing the region of data from input object

cloneRegion() [2/3]

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() [3/3]

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
note that tool milling outer surface of the mesh
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

computeBoundingBox()

Box3f mrmeshpy.computeBoundingBox	(	MeshTopology	topology,
		VertCoords	points,
		FaceBitSet	region,
		AffineXf3f	toWorld = None )

passes through all given faces (or whole mesh if region == null) and finds the minimal bounding box containing all of them
if toWorld transformation is given then returns minimal bounding box in world space

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

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

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

computeGridBox()

Box3i mrmeshpy.computeGridBox	(	Box3f	workArea,
		float	voxelSize )

Compute required voxel volume's dimensions for given work area

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

computeSweptVolumeWithCustomToolDistance()

Mesh mrmeshpy.computeSweptVolumeWithCustomToolDistance	(	IComputeToolDistance	comp,
		ComputeSweptVolumeParameters	params )

Compute swept volume for given toolpath and tool
Creates a distance-to-tool volume using custom tool distance computation object and converts it to mesh using
the marching cubes algorithm

computeSweptVolumeWithDistanceVolume()

Mesh mrmeshpy.computeSweptVolumeWithDistanceVolume

(

ComputeSweptVolumeParameters

params

)

Compute swept volume for given toolpath and tool
Creates a distance-to-tool volume and converts it to mesh using the marching cubes algorithm

computeSweptVolumeWithMeshMovement()

Mesh mrmeshpy.computeSweptVolumeWithMeshMovement

(

ComputeSweptVolumeParameters

params

)

Compute swept volume for given toolpath and tool
Builds mesh for each tool movement and joins them using voxel boolean

computeTrianglesRepetitions()

std_array_int_4 mrmeshpy.computeTrianglesRepetitions

(

AllLocalTriangulations

triangs

)

computes statistics about the number of triangle repetitions in local triangulations

computeWorkArea()

Box3f mrmeshpy.computeWorkArea	(	Polyline3	toolpath,
		MeshPart	tool )

Compute bounding box for swept volume for given tool and toolpath

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

convertContoursTo2d() [1/4]

std_vector_std_vector_Vector2_double mrmeshpy.convertContoursTo2d

(

std_vector_std_vector_Vector2_double

from_

)

convertContoursTo2d() [2/4]

std_vector_std_vector_Vector2_double mrmeshpy.convertContoursTo2d

(

std_vector_std_vector_Vector2_float

from_

)

convertContoursTo2d() [3/4]

std_vector_std_vector_Vector2_double mrmeshpy.convertContoursTo2d

(

std_vector_std_vector_Vector3_double

from_

)

convertContoursTo2d() [4/4]

std_vector_std_vector_Vector2_double mrmeshpy.convertContoursTo2d

(

std_vector_std_vector_Vector3_float

from_

)

convertContoursTo2f() [1/4]

std_vector_std_vector_Vector2_float mrmeshpy.convertContoursTo2f

(

std_vector_std_vector_Vector2_double

from_

)

convertContoursTo2f() [2/4]

std_vector_std_vector_Vector2_float mrmeshpy.convertContoursTo2f

(

std_vector_std_vector_Vector2_float

from_

)

convertContoursTo2f() [3/4]

std_vector_std_vector_Vector2_float mrmeshpy.convertContoursTo2f

(

std_vector_std_vector_Vector3_double

from_

)

convertContoursTo2f() [4/4]

std_vector_std_vector_Vector2_float mrmeshpy.convertContoursTo2f

(

std_vector_std_vector_Vector3_float

from_

)

convertContoursTo3d() [1/4]

std_vector_std_vector_Vector3_double mrmeshpy.convertContoursTo3d

(

std_vector_std_vector_Vector2_double

from_

)

convertContoursTo3d() [2/4]

std_vector_std_vector_Vector3_double mrmeshpy.convertContoursTo3d

(

std_vector_std_vector_Vector2_float

from_

)

convertContoursTo3d() [3/4]

std_vector_std_vector_Vector3_double mrmeshpy.convertContoursTo3d

(

std_vector_std_vector_Vector3_double

from_

)

convertContoursTo3d() [4/4]

std_vector_std_vector_Vector3_double mrmeshpy.convertContoursTo3d

(

std_vector_std_vector_Vector3_float

from_

)

convertContoursTo3f() [1/4]

std_vector_std_vector_Vector3_float mrmeshpy.convertContoursTo3f

(

std_vector_std_vector_Vector2_double

from_

)

convertContoursTo3f() [2/4]

std_vector_std_vector_Vector3_float mrmeshpy.convertContoursTo3f

(

std_vector_std_vector_Vector2_float

from_

)

convertContoursTo3f() [3/4]

std_vector_std_vector_Vector3_float mrmeshpy.convertContoursTo3f

(

std_vector_std_vector_Vector3_double

from_

)

convertContoursTo3f() [4/4]

std_vector_std_vector_Vector3_float mrmeshpy.convertContoursTo3f

(

std_vector_std_vector_Vector3_float

from_

)

convertContourTo2d() [1/4]

std_vector_Vector2_double mrmeshpy.convertContourTo2d

(

std_vector_Vector2_double

from_

)

convertContourTo2d() [2/4]

std_vector_Vector2_double mrmeshpy.convertContourTo2d

(

std_vector_Vector2_float

from_

)

convertContourTo2d() [3/4]

std_vector_Vector2_double mrmeshpy.convertContourTo2d

(

std_vector_Vector3_double

from_

)

convertContourTo2d() [4/4]

std_vector_Vector2_double mrmeshpy.convertContourTo2d

(

std_vector_Vector3_float

from_

)

convertContourTo2f() [1/4]

std_vector_Vector2_float mrmeshpy.convertContourTo2f

(

std_vector_Vector2_double

from_

)

Instantiate the templates when generating bindings.

convertContourTo2f() [2/4]

std_vector_Vector2_float mrmeshpy.convertContourTo2f

(

std_vector_Vector2_float

from_

)

Instantiate the templates when generating bindings.

convertContourTo2f() [3/4]

std_vector_Vector2_float mrmeshpy.convertContourTo2f

(

std_vector_Vector3_double

from_

)

Instantiate the templates when generating bindings.

convertContourTo2f() [4/4]

std_vector_Vector2_float mrmeshpy.convertContourTo2f

(

std_vector_Vector3_float

from_

)

Instantiate the templates when generating bindings.

convertContourTo3d() [1/4]

std_vector_Vector3_double mrmeshpy.convertContourTo3d

(

std_vector_Vector2_double

from_

)

convertContourTo3d() [2/4]

std_vector_Vector3_double mrmeshpy.convertContourTo3d

(

std_vector_Vector2_float

from_

)

convertContourTo3d() [3/4]

std_vector_Vector3_double mrmeshpy.convertContourTo3d

(

std_vector_Vector3_double

from_

)

convertContourTo3d() [4/4]

std_vector_Vector3_double mrmeshpy.convertContourTo3d

(

std_vector_Vector3_float

from_

)

convertContourTo3f() [1/4]

std_vector_Vector3_float mrmeshpy.convertContourTo3f

(

std_vector_Vector2_double

from_

)

convertContourTo3f() [2/4]

std_vector_Vector3_float mrmeshpy.convertContourTo3f

(

std_vector_Vector2_float

from_

)

convertContourTo3f() [3/4]

std_vector_Vector3_float mrmeshpy.convertContourTo3f

(

std_vector_Vector3_double

from_

)

convertContourTo3f() [4/4]

std_vector_Vector3_float mrmeshpy.convertContourTo3f

(

std_vector_Vector3_float

from_

)

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,
		bool	invert = True )

load distance map from a grayscale image:
\\param threshold - threshold of valid values [0.; 1.]. pixel with color less then threshold set invalid
\\param invert - whether to invert values (min is white) or leave them as is (min is block)

convertIntFloatAllVerts()

None mrmeshpy.convertIntFloatAllVerts	(	Mesh	mesh,
		CoordinateConverters	conv )

converts all vertices of the mesh first in integer-coordinates, and then back in float-coordinates;
this is necessary to avoid small self-intersections near newly introduced vertices on cut-contours;
this actually sligntly moves only small perentage of vertices near x=0 or y=0 or z=0 planes, where float-precision is higher than int-precision;
newly introduced vertices on cut-contours are also converted, but we expected that they remain unchanged due to idempotent property of the conversion

convertMeshTriPointsSurfaceOffsetToMeshContours() [1/2]

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

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

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

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

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

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

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

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

cotan()

float mrmeshpy.cotan	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	ue )

computes sum of cotangents of the angle in the left and right triangles opposite to given edge,
consider cotangents zero for not existing triangles

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

FloatGrid mrmeshpy.cropped	(	FloatGrid	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 = '{}' )

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

cutMeshByContour()

FaceBitSet mrmeshpy.cutMeshByContour	(	Mesh	mesh,
		std_vector_Vector3_float	contour,
		AffineXf3f	xf = '{}' )

Cuts \\p mesh by \\p contour by projecting all the points
\\param xf transformation from the CSYS of \\p contour to the CSYS of \\p mesh
\\note \\p mesh is modified, see \\ref cutMesh for info
\\note it might be useful to subdivide mesh before cut, to avoid issues related to lone contours
\\return Faces to the left of the polyline

cutMeshByContours()

FaceBitSet mrmeshpy.cutMeshByContours	(	Mesh	mesh,
		std_vector_std_vector_Vector3_float	contours,
		AffineXf3f	xf = '{}' )

Cuts \\p mesh by \\p contours by projecting all the points
\\param xf transformation from the CSYS of \\p contour to the CSYS of \\p mesh
\\note \\p mesh is modified, see \\ref cutMesh for info
\\note it might be useful to subdivide mesh before cut, to avoid issues related to lone contours
\\return Faces to the left of the polyline

cutMeshByProjection()

std_vector_std_vector_Id_EdgeTag mrmeshpy.cutMeshByProjection	(	Mesh	mesh,
		std_vector_std_vector_Vector3_float	contours,
		CutByProjectionSettings	settings )

<summary>
Performs orthographic projection with of given contours to mesh and cut result lines, 
fails if any point of contours has missed mesh on projection stage or cut contours contains self-intersections
\\note it might be useful to subdivide mesh before cut, to avoid issues related to lone contours
</summary>
<param name="mesh"> for cutting, it will be changed</param>
<param name="contours"> for projection onto mesh</param>
<param name="settings"> to specify direction and \\p contours to \\p mesh space transformation</param>
<returns>newly appeared edges on the mesh after cut or error</returns>

dblArea() [1/2]

float mrmeshpy.dblArea	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

returns twice the area of given face

dblArea() [2/2]

float mrmeshpy.dblArea	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v )

computes the length of summed directed double areas of all triangles around given vertex

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

decimateContour() [2/2]

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

decimateMesh()

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

 \\brief Performs mesh simplification in mesh region according to the settings
 \\snippet cpp-examples/MeshDecimate.dox.cpp 0

 \\image html decimate/decimate_before.png "Before" width = 350cm
 \\image html decimate/decimate_after.png "After" width = 350cm

decimateObjectMeshData()

DecimateResult mrmeshpy.decimateObjectMeshData	(	ObjectMeshData	data,
		DecimateSettings	settings )

Performs mesh simplification with per-element attributes according to given settings;
\\detail settings.region must be null, and real simplification region will be data face selection (or whole mesh if no face selection)

decimatePolyline() [1/2]

DecimatePolylineResult mrmeshpy.decimatePolyline	(	Polyline2	polyline,
		DecimatePolylineSettings_Vector2f	settings = '{}' )

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

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,
		bool	keepLoneHoles = False )

deletes all region faces, inner edges and vertices, but keeps boundary edges and vertices of the region (or whole mesh if region is null);
if `keepLoneHoles` is set - keeps boundary even if it has no valid faces on other side
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

destPnt()

Vector3f mrmeshpy.destPnt	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

returns coordinates of the edge destination

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_VarEdgeTri	contours,
		bool	ignoreOpen = False )

Detects contours that fully lay inside one triangle
if `ignoreOpen` then do not mark non-closed contours as lone, even if they really are
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

dihedralAngle()

float mrmeshpy.dihedralAngle	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	e )

given an edge between two triangular faces, computes the dihedral angle between them:
0 if both faces are in the same plane,
positive if the faces form convex surface,
negative if the faces form concave surface;
please consider the usage of faster dihedralAngleSin(e) and dihedralAngleCos(e)

dihedralAngleCos()

float mrmeshpy.dihedralAngleCos	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	e )

given an edge between two triangular faces, computes cosine of dihedral angle between them:
1 if both faces are in the same plane,
0 if the surface makes right angle turn at the edge,
-1 if the faces overlap one another

dihedralAngleSin()

float mrmeshpy.dihedralAngleSin	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	e )

given an edge between two triangular faces, computes sine of dihedral angle between them:
0 if both faces are in the same plane,
positive if the faces form convex surface,
negative if the faces form concave surface

dilateRegion() [1/7]

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/7]

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

dilateRegion() [3/7]

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

dilateRegion() [4/7]

bool mrmeshpy.dilateRegion	(	MeshTopology	topology,
		VertCoords	points,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

dilateRegion() [5/7]

bool mrmeshpy.dilateRegion	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

dilateRegion() [6/7]

bool mrmeshpy.dilateRegion	(	MeshTopology	topology,
		VertCoords	points,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

dilateRegion() [7/7]

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

dirArea()

Vector3d mrmeshpy.dirArea	(	MeshTopology	topology,
		VertCoords	points,
		FaceBitSet	fs = None )

computes the sum of directed areas for faces from given region

computes the sum of directed areas for faces from given region (or whole mesh)

dirDblArea() [1/2]

Vector3f mrmeshpy.dirDblArea	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

computes directed double area for a triangular face from its vertices

dirDblArea() [2/2]

Vector3f mrmeshpy.dirDblArea	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v )

computes sum of directed double areas of all triangles around given vertex

dirDblAreas()

VertCoords mrmeshpy.dirDblAreas	(	MeshTopology	topology,
		VertCoords	points,
		VertBitSet	region = None )

computes and returns the directed double area for every (region) vertex in the mesh

discreteAbsMeanCurvatureMetric() [1/2]

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

discreteAbsMeanCurvatureMetric() [2/2]

func_float_from_Id_EdgeTag mrmeshpy.discreteAbsMeanCurvatureMetric	(	MeshTopology	topology,
		VertCoords	points )

discreteGaussianCurvature()

float mrmeshpy.discreteGaussianCurvature	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v,
		bool_output	outBoundaryVert = None )

computes discrete Gaussian curvature (or angle defect) at given vertex,
which 0 in inner vertices on planar mesh parts and reaches 2*pi on needle's tip, see http://math.uchicago.edu/~may/REU2015/REUPapers/Upadhyay.pdf
optionally returns whether the vertex is on boundary

discreteMeanCurvature() [1/2]

float mrmeshpy.discreteMeanCurvature	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	e )

computes discrete mean curvature in given edge, measures in length^-1;
0 for planar regions, positive for convex surface, negative for concave surface

discreteMeanCurvature() [2/2]

float mrmeshpy.discreteMeanCurvature	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v )

computes discrete mean curvature in given vertex, measures in length^-1;
0 for planar regions, positive for convex surface, negative for concave surface

discreteMinusAbsMeanCurvatureMetric() [1/2]

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

discreteMinusAbsMeanCurvatureMetric() [2/2]

func_float_from_Id_EdgeTag mrmeshpy.discreteMinusAbsMeanCurvatureMetric	(	MeshTopology	topology,
		VertCoords	points )

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

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/17]

int mrmeshpy.dot	(	Vector2b	a,
		Vector2b	b )

dot product

dot() [2/17]

float mrmeshpy.dot	(	Vector2d	a,
		Vector2d	b )

dot product

dot() [3/17]

float mrmeshpy.dot	(	Vector2f	a,
		Vector2f	b )

dot product

dot() [4/17]

int mrmeshpy.dot	(	Vector2i	a,
		Vector2i	b )

dot product

dot() [5/17]

int mrmeshpy.dot	(	Vector2i64	a,
		Vector2i64	b )

dot product

dot() [6/17]

int mrmeshpy.dot	(	Vector3_unsigned_char	a,
		Vector3_unsigned_char	b )

dot product

dot() [7/17]

int mrmeshpy.dot	(	Vector3b	a,
		Vector3b	b )

dot product

dot() [8/17]

float mrmeshpy.dot	(	Vector3d	a,
		Vector3d	b )

dot product

dot() [9/17]

float mrmeshpy.dot	(	Vector3f	a,
		Vector3f	b )

dot product

dot() [10/17]

int mrmeshpy.dot	(	Vector3i	a,
		Vector3i	b )

dot product

dot() [11/17]

int mrmeshpy.dot	(	Vector3i64	a,
		Vector3i64	b )

dot product

dot() [12/17]

int mrmeshpy.dot	(	Vector4_unsigned_char	a,
		Vector4_unsigned_char	b )

dot product

dot() [13/17]

int mrmeshpy.dot	(	Vector4b	a,
		Vector4b	b )

dot product

dot() [14/17]

float mrmeshpy.dot	(	Vector4d	a,
		Vector4d	b )

dot product

dot() [15/17]

float mrmeshpy.dot	(	Vector4f	a,
		Vector4f	b )

dot product

dot() [16/17]

int mrmeshpy.dot	(	Vector4i	a,
		Vector4i	b )

dot product

dot() [17/17]

int mrmeshpy.dot	(	Vector4i64	a,
		Vector4i64	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);

edgeCenter()

Vector3f mrmeshpy.edgeCenter	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	e )

computes the center of given edge

edgeCurvMetric() [1/2]

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

edgeCurvMetric() [2/2]

func_float_from_Id_EdgeTag mrmeshpy.edgeCurvMetric	(	MeshTopology	topology,
		VertCoords	points,
		float	angleSinFactor = 2,
		float	angleSinForBoundary = 0 )

edgeLength()

float mrmeshpy.edgeLength	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	e )

returns Euclidean length of the edge

edgeLengthMetric() [1/2]

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

edgeLengthMetric() [2/2]

func_float_from_Id_EdgeTag mrmeshpy.edgeLengthMetric	(	MeshTopology	topology,
		VertCoords	points )

edgeLengths()

UndirectedEdgeScalars mrmeshpy.edgeLengths	(	MeshTopology	topology,
		VertCoords	points )

computes and returns the lengths of all edges in the mesh

edgeLengthSq()

float mrmeshpy.edgeLengthSq	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	e )

returns squared Euclidean length of the edge (faster to compute than length)

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

edgePoint() [1/2]

Vector3f mrmeshpy.edgePoint	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e,
		float	f )

returns a point on the edge: origin point for f=0 and destination point for f=1

edgePoint() [2/2]

Vector3f mrmeshpy.edgePoint	(	MeshTopology	topology,
		VertCoords	points,
		EdgePoint	ep )

computes coordinates of point given as edge and relative position on it

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

edgeSegment()

LineSegm3f mrmeshpy.edgeSegment	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

returns line segment of given edge

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

edgeVector()

Vector3f mrmeshpy.edgeVector	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

returns vector equal to edge destination point minus edge origin point

eliminateDegree3Dest()

EdgeId mrmeshpy.eliminateDegree3Dest	(	MeshTopology	topology,
		EdgeId	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()

EdgeId mrmeshpy.eliminateDoubleTris	(	MeshTopology	topology,
		EdgeId	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/6]

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

end() [2/6]

ChunkIterator mrmeshpy.end

(

IteratorRange_ChunkIterator

range

)

end() [3/6]

PolylineUndirectedEdgeIterator mrmeshpy.end

(

IteratorRange_PolylineUndirectedEdgeIterator

range

)

end() [4/6]

RingIterator_NextEdgeSameLeft mrmeshpy.end

(

IteratorRange_RingIterator_NextEdgeSameLeft

range

)

end() [5/6]

RingIterator_NextEdgeSameOrigin mrmeshpy.end

(

IteratorRange_RingIterator_NextEdgeSameOrigin

range

)

end() [6/6]

UndirectedEdgeIterator mrmeshpy.end

(

IteratorRange_UndirectedEdgeIterator

range

)

equalizeTriAreas() [1/2]

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.

equalizeTriAreas() [2/2]

bool mrmeshpy.equalizeTriAreas	(	MeshTopology	topology,
		VertCoords	points,
		MeshEqualizeTriAreasParams	params = '{}',
		func_bool_from_float	cb = '{}' )

erodeRegion() [1/7]

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/7]

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

erodeRegion() [3/7]

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

erodeRegion() [4/7]

bool mrmeshpy.erodeRegion	(	MeshTopology	topology,
		VertCoords	points,
		FaceBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

erodeRegion() [5/7]

bool mrmeshpy.erodeRegion	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

erodeRegion() [6/7]

bool mrmeshpy.erodeRegion	(	MeshTopology	topology,
		VertCoords	points,
		VertBitSet	region,
		float	dilation,
		func_bool_from_float	callback = '{}' )

erodeRegion() [7/7]

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	(	FloatGrid	grid,
		float_output	min,
		float_output	max )

eval min max value from FloatGrid

executeHoleFillPlan()

None mrmeshpy.executeHoleFillPlan	(	Mesh	mesh,
		EdgeId	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]

EdgeId mrmeshpy.extendHole	(	Mesh	mesh,
		EdgeId	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]

EdgeId mrmeshpy.extendHole	(	Mesh	mesh,
		EdgeId	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 )

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,
		UseAABBTree	u = 'UseAABBTree::Yes' )

extracts all plane sections of given mesh

extractSectionsFromPolyline()

std_vector_EdgeSegment mrmeshpy.extractSectionsFromPolyline	(	Polyline3	polyline,
		Plane3f	plane,
		float	eps,
		UndirectedEdgeBitSet	positiveEdges = '{}' )

This function cuts polyline with a plane
\\details plane cuts an edge if one end of the edge is below the plane and the other is not
\\return Edge segments that are closer to the plane than \\param eps. Segments are oriented according by plane normal ( segment.a <= segment.b)
\\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
\\param positiveEdges Edges in a positive half-space relative to the plane or on the plane itself (only adds bits to the existing ones)

extractXYPlaneSections()

std_vector_std_vector_EdgePoint mrmeshpy.extractXYPlaneSections	(	MeshPart	mp,
		float	zLevel,
		UseAABBTree	u = 'UseAABBTree::Yes' )

extracts all sections of given mesh with the plane z=zLevel

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

 \\brief Fills region located to the left from given contour, by minimizing the sum of metric over the boundary
 If the computations are terminated by \\p progress, then returns the best approximation found by the moment of termination

fillContourLeftByGraphCut() [2/2]

FaceBitSet mrmeshpy.fillContourLeftByGraphCut	(	MeshTopology	topology,
		std_vector_std_vector_Id_EdgeTag	contours,
		func_float_from_Id_EdgeTag	metric,
		func_bool_from_float	progress = '{}' )

 \\brief Fills region located to the left from given contours, by minimizing the sum of metric over the boundary
 If the computations are terminated by \\p progress, then returns the best approximation found by the moment of termination

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,
		EdgeId	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,
		EdgeId	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,
		EdgeId	a,
		FaceBitSet	outNewFaces = None )

\\brief Triangulates face of hole in mesh trivially\\n

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	(	ObjectMeshData	data,
		std_vector_std_vector_Id_EdgeTag	holeContours )

given an ObjectMeshData and the contours of a planar hole in it,
fills the hole using fillContours2D function and updates all per-element attributes;
if some contours were not closed on input, then it 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)

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

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

findBoxedTrisInBall()

None mrmeshpy.findBoxedTrisInBall	(	MeshPart	mp,
		Ball3f	ball,
		func_Processing_from_Id_FaceTag_Ball_Vector3_float	foundCallback )

enumerates all triangles with bounding boxes at least partially in the ball (the triangles themselves can be fully out of ball)
until callback returns Stop;
the ball during enumeration can shrink (new ball is always within the previous one) but never expand

findCenterFromBBox()

Vector3f mrmeshpy.findCenterFromBBox	(	MeshTopology	topology,
		VertCoords	points )

computes bounding box and returns its center

findCenterFromFaces()

Vector3f mrmeshpy.findCenterFromFaces	(	MeshTopology	topology,
		VertCoords	points )

computes center of mass considering that density of all triangles is the same

findCenterFromPoints()

Vector3f mrmeshpy.findCenterFromPoints	(	MeshTopology	topology,
		VertCoords	points )

computes average position of all valid mesh vertices

findClosestWeightedMeshPoint()

MeshPointAndDistance mrmeshpy.findClosestWeightedMeshPoint	(	Vector3f	loc,
		Mesh	mesh,
		DistanceFromWeightedPointsComputeParams	params )

consider a mesh where each vertex has additive weight, and this weight is linearly interpolated in mesh triangles,
and the distance to a point is considered equal to (euclidean distance - weight),
finds the point on given mesh with minimal distance to given 3D location

findClosestWeightedPoint()

PointAndDistance mrmeshpy.findClosestWeightedPoint	(	Vector3f	loc,
		AABBTreePoints	tree,
		DistanceFromWeightedPointsComputeParams	params )

consider a point cloud where each point has additive weight,
and the distance to a point is considered equal to (euclidean distance - weight),
finds the point with minimal distance to given 3D location

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]

std_vector_VarEdgeTri 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

findCreaseEdges()

UndirectedEdgeBitSet mrmeshpy.findCreaseEdges	(	MeshTopology	topology,
		VertCoords	points,
		float	angleFromPlanar )

finds all mesh edges where dihedral angle is distinct from planar PI angle on at least given value

findDegenerateFaces()

FaceBitSet mrmeshpy.findDegenerateFaces	(	MeshPart	mp,
		float	criticalAspectRatio = 3.4028234663852886e+38,
		func_bool_from_float	cb = '{}' )

finds faces having aspect ratio >= criticalAspectRatio

findDirMax() [1/7]

VertId mrmeshpy.findDirMax	(	Vector2f	dir,
		Polyline2	polyline,
		UseAABBTree	u = 'UseAABBTree::Yes' )

finds the vertex in the polyline having the largest projection on given direction,
optionally uses aabb-tree inside for faster computation

findDirMax() [2/7]

VertId mrmeshpy.findDirMax	(	Vector3f	dir,
		AABBTreePoints	tree,
		VertBitSet	region = None )

finds the point in the tree having the largest projection on given direction

findDirMax() [3/7]

VertId mrmeshpy.findDirMax	(	Vector3f	dir,
		Mesh	m,
		UseAABBTree	u = 'UseAABBTree::Yes' )

finds the vertex in the mesh part having the largest projection on given direction,
optionally uses aabb-tree inside for faster computation

findDirMax() [4/7]

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,
optionally uses aabb-tree inside for faster computation

findDirMax() [5/7]

VertId mrmeshpy.findDirMax	(	Vector3f	dir,
		MeshVertPart	mp,
		UseAABBTree	u = 'UseAABBTree::Yes' )

finds the vertex in the mesh part having the largest projection on given direction,
optionally uses aabb-points-tree inside for faster computation

findDirMax() [6/7]

VertId mrmeshpy.findDirMax	(	Vector3f	dir,
		PointCloud	cloud,
		VertBitSet	region = None,
		UseAABBTree	u = 'UseAABBTree::Yes' )

finds the point in the cloud having the largest projection on given direction,
optionally uses aabb-tree inside for faster computation

findDirMax() [7/7]

VertId mrmeshpy.findDirMax	(	Vector3f	dir,
		Polyline3	polyline,
		UseAABBTree	u = 'UseAABBTree::Yes' )

finds the vertex in the polyline having the largest projection on given direction,
optionally uses aabb-tree inside for faster computation

findDirMaxBruteForce() [1/7]

VertId mrmeshpy.findDirMaxBruteForce	(	Vector2f	dir,
		Polyline2	polyline )

finds the vertex in the polyline having the largest projection on given direction by traversing all valid vertices

findDirMaxBruteForce() [2/7]

VertId mrmeshpy.findDirMaxBruteForce	(	Vector2f	dir,
		VertCoords2	points,
		VertBitSet	region = None )

finds the point having the largest projection on given direction by traversing all region points

findDirMaxBruteForce() [3/7]

VertId mrmeshpy.findDirMaxBruteForce	(	Vector3f	dir,
		MeshPart	mp )

finds the vertex in the mesh part having the largest projection on given direction by traversing all (region) faces

findDirMaxBruteForce() [4/7]

VertId mrmeshpy.findDirMaxBruteForce	(	Vector3f	dir,
		MeshVertPart	mp )

finds the vertex in the mesh part having the largest projection on given direction by traversing all (region) vertices

findDirMaxBruteForce() [5/7]

VertId mrmeshpy.findDirMaxBruteForce	(	Vector3f	dir,
		PointCloud	cloud,
		VertBitSet	region = None )

finds the point in the cloud having the largest projection on given direction by traversing all valid points

findDirMaxBruteForce() [6/7]

VertId mrmeshpy.findDirMaxBruteForce	(	Vector3f	dir,
		Polyline3	polyline )

finds the vertex in the polyline having the largest projection on given direction by traversing all valid vertices

findDirMaxBruteForce() [7/7]

VertId mrmeshpy.findDirMaxBruteForce	(	Vector3f	dir,
		VertCoords	points,
		VertBitSet	region = None )

finds the point having the largest projection on given direction by traversing all region points

findDirMinMaxBruteForce() [1/7]

MinMaxArg_float_VertId mrmeshpy.findDirMinMaxBruteForce	(	Vector2f	dir,
		Polyline2	polyline )

finds the vertex in the polyline having the smallest and the largest projections on given direction by traversing all valid vertices

findDirMinMaxBruteForce() [2/7]

MinMaxArg_float_VertId mrmeshpy.findDirMinMaxBruteForce	(	Vector2f	dir,
		VertCoords2	points,
		VertBitSet	region = None )

finds the points having the smallest and the largest projections on given direction by traversing all region points

findDirMinMaxBruteForce() [3/7]

MinMaxArg_float_VertId mrmeshpy.findDirMinMaxBruteForce	(	Vector3f	dir,
		MeshPart	mp )

finds the vertices in the mesh part having the smallest and the largest projections on given direction by traversing all (region) faces

findDirMinMaxBruteForce() [4/7]

MinMaxArg_float_VertId mrmeshpy.findDirMinMaxBruteForce	(	Vector3f	dir,
		MeshVertPart	mp )

finds the vertices in the mesh part having the smallest and the largest projections on given direction by traversing all (region) vertices

findDirMinMaxBruteForce() [5/7]

MinMaxArg_float_VertId mrmeshpy.findDirMinMaxBruteForce	(	Vector3f	dir,
		PointCloud	cloud,
		VertBitSet	region = None )

finds the points in the cloud having the smallest and the largest projections on given direction by traversing all valid points

findDirMinMaxBruteForce() [6/7]

MinMaxArg_float_VertId mrmeshpy.findDirMinMaxBruteForce	(	Vector3f	dir,
		Polyline3	polyline )

finds the vertex in the polyline having the smallest and the largest projections on given direction by traversing all valid vertices

findDirMinMaxBruteForce() [7/7]

MinMaxArg_float_VertId mrmeshpy.findDirMinMaxBruteForce	(	Vector3f	dir,
		VertCoords	points,
		VertBitSet	region = None )

finds the points having the smallest and the largest projections on given direction by traversing all region points

findDisorientedFaces()

FaceBitSet mrmeshpy.findDisorientedFaces	(	Mesh	mesh,
		FindDisorientationParams	params = '{}' )

returns all faces that are oriented inconsistently, based on number of ray intersections

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

findMaxProjectionOnPolyline()

PolylineProjectionResult3Arg mrmeshpy.findMaxProjectionOnPolyline	(	VertCoords	points,
		Polyline3	polyline,
		VertBitSet	pointsRegion = None,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0 )

 \\brief for each of points (pointsRegion) computes the closest point on polyline and returns the point for which maximum distance is reached,
 \\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

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

calculates all neighbor vertices within a given \\param range
and to first vertices with the distance more than range
\\param rangeSq square of range

findNRingVerts()

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

finds vertices in region with complete ring of N edges

findOuterLayer()

FaceBitSet mrmeshpy.findOuterLayer

(

Mesh

mesh

)

given a double-layer mesh with one layer having normals outside and the other layer - inside,
finds all faces of the outer layer;
the algorithm first detects some seed faces of each layer by casting a ray from triangle's center in both directions along the normal;
then remaining faces are redistributed toward the closest seed face

findOutliers()

VertBitSet mrmeshpy.findOutliers	(	PointCloud	pc,
		FindOutliersParams	params )

Finding outlier points

findOverhangs()

std_vector_TypedBitSet_Id_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/3]

None mrmeshpy.findPointsInBall	(	AABBTreePoints	tree,
		Ball3f	ball,
		func_Processing_from_PointsProjectionResult_Vector3_float_Ball_Vector3_float	foundCallback,
		AffineXf3f	xf = None )

Finds all points in tree that are inside or on the surface of given ball until callback returns Stop;
the ball can shrink (new ball is always within the previous one) during the search but never expand
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

findPointsInBall() [2/3]

None mrmeshpy.findPointsInBall	(	Mesh	mesh,
		Ball3f	ball,
		func_Processing_from_PointsProjectionResult_Vector3_float_Ball_Vector3_float	foundCallback,
		AffineXf3f	xf = None )

Finds all valid vertices of the mesh that are inside or on the surface of given ball until callback returns Stop;
the ball can shrink (new ball is always within the previous one) during the search but never expand
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

findPointsInBall() [3/3]

None mrmeshpy.findPointsInBall	(	PointCloud	pointCloud,
		Ball3f	ball,
		func_Processing_from_PointsProjectionResult_Vector3_float_Ball_Vector3_float	foundCallback,
		AffineXf3f	xf = None )

Finds all valid points of pointCloud that are inside or on the surface of given ball until callback returns Stop;
the ball can shrink (new ball is always within the previous one) during the search but never expand
\\param xf points-to-center transformation, if not specified then identity transformation is assumed

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
\\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
\\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
\\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 then the function exists returning upDistLimitSq and no valid point or edge
 \\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 then the function exists returning upDistLimitSq and no valid point or edge
 \\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() [1/2]

PointsProjectionResult mrmeshpy.findProjectionOnPoints	(	Vector3f	pt,
		AABBTreePoints	tree,
		float	upDistLimitSq = 3.4028234663852886e+38,
		AffineXf3f	xf = None,
		float	loDistLimitSq = 0,
		VertBitSet	region = None,
		func_bool_from_Id_VertTag	skipCb = '{}' )

 \\brief computes the closest point on AABBTreePoints 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 region if not nullptr, all points not from the given region will be ignored
 \\param skipCb callback to discard VertId projection candidate

findProjectionOnPoints() [2/2]

PointsProjectionResult mrmeshpy.findProjectionOnPoints	(	Vector3f	pt,
		PointCloudPart	pcp,
		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 then the function exists returning upDistLimitSq and no valid point or edge
 \\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 then the function exists returning upDistLimitSq and no valid point or edge
 \\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 then the function exists returning upDistLimitSq and no valid point or edge
 \\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 then the function exists returning upDistLimit and no valid point or edge
 \\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 then the function exists returning upDistLimit and no valid point or edge
 \\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

findSelfCollidingEdgeTrisPrecise()

std_vector_EdgeTri mrmeshpy.findSelfCollidingEdgeTrisPrecise	(	MeshPart	mp,
		func_Vector3_int_from_Vector3_float	conv,
		bool	anyIntersection = False,
		AffineXf3f	rigidB2A = None,
		int	aVertSizes = 0 )

 \\brief finds all pairs of colliding edges and triangle within one mesh
 \\param anyIntersection if true then the function returns as fast as it finds any intersection
 \\param rigidB2A rigid transformation from B-mesh space to A mesh space, nullptr considered as identity transformation, might be useful to obtain same result as in boolean operation would for mesh B
 \\param aVertsSize used in float to int conversion, might be useful to obtain same result as in boolean operation would for mesh B

findSelfCollidingTriangles() [1/2]

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

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,
		bool	touchIsIntersection = False )

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,
		bool	touchIsIntersection = False )

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

findSpikeVertices()

VertBitSet mrmeshpy.findSpikeVertices	(	MeshTopology	topology,
		VertCoords	points,
		float	minSumAngle,
		VertBitSet	region = None,
		func_bool_from_float	cb = '{}' )

returns vertices where the sum of triangle angles is below given threshold

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

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

findTripleFaceIntersections()

std_vector_FaceFaceFace mrmeshpy.findTripleFaceIntersections	(	MeshTopology	topology,
		std_vector_std_vector_VarEdgeTri	selfContours )

given all self-intersection contours on a mesh, finds all intersecting triangle triples (every two triangles from a triple intersect);
please note that not all such triples will have a common point

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

findTwoSegmentsIntersection()

Vector3i mrmeshpy.findTwoSegmentsIntersection	(	Vector3i	ai,
		Vector3i	bi,
		Vector3i	ci,
		Vector3i	di )

given two line segments AB and CD located in one plane,
finds whether they intersect and if yes, computes their common point using integer-only arithmetic

findZcompensatedPositions()

VertCoords mrmeshpy.findZcompensatedPositions	(	Mesh	mesh,
		ZCompensateParams	params )

finds vertices positions of the mesh after z-compensation without modifying the mesh

findZcompensationShifts()

VertScalars mrmeshpy.findZcompensationShifts	(	Mesh	mesh,
		ZCompensateParams	params )

finds the shift along z-axis for each vertex without modifying the mesh

fixMeshCreases()

None mrmeshpy.fixMeshCreases	(	Mesh	mesh,
		FixCreasesParams	params = '{}' )

Finds creases edges and re-triangulates planar areas around them, useful to fix double faces

fixMeshDegeneracies()

None mrmeshpy.fixMeshDegeneracies	(	Mesh	mesh,
		FixMeshDegeneraciesParams	params )

Fixes degenerate faces and short edges in mesh (changes topology)

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.

floatGridToVdbVolume()

VdbVolume mrmeshpy.floatGridToVdbVolume

(

FloatGrid

grid

)

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

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

gaussianFilter()

None mrmeshpy.gaussianFilter	(	FloatGrid	grid,
		int	width,
		int	iters,
		func_bool_from_float	cb = '{}' )

returns grid with gaussian filter applied

gaussianFiltered()

FloatGrid mrmeshpy.gaussianFiltered	(	FloatGrid	grid,
		int	width,
		int	iters,
		func_bool_from_float	cb = '{}' )

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
\\snippet cpp-examples/MeshOffset.dox.cpp 0

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_TypedBitSet_Id_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_TypedBitSet_Id_FaceTag, int] mrmeshpy.getAllComponents	(	MeshPart	meshPart,
		int	maxComponentCount,
		MeshComponents.FaceIncidence	incidence = 'FaceIncidence::PerEdge',
		UndirectedEdgeBitSet	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_TypedBitSet_Id_FaceTag mrmeshpy.getAllComponents	(	MeshPart	meshPart,
		MeshComponents.FaceIncidence	incidence = 'FaceIncidence::PerEdge',
		UndirectedEdgeBitSet	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_TypedBitSet_Id_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

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.

getClosestEdge() [1/2]

UndirectedEdgeId mrmeshpy.getClosestEdge	(	MeshTopology	topology,
		VertCoords	points,
		MeshTriPoint	p )

returns one of three face edges, closest to given point

getClosestEdge() [2/2]

UndirectedEdgeId mrmeshpy.getClosestEdge	(	MeshTopology	topology,
		VertCoords	points,
		PointOnFace	p )

returns one of three face edges, closest to given point

getClosestVertex() [1/2]

VertId mrmeshpy.getClosestVertex	(	MeshTopology	topology,
		VertCoords	points,
		MeshTriPoint	p )

returns one of three face vertices, closest to given point

getClosestVertex() [2/2]

VertId mrmeshpy.getClosestVertex	(	MeshTopology	topology,
		VertCoords	points,
		PointOnFace	p )

returns one of three face vertices, closest to given point

getComplexFillMetric()

FillHoleMetric mrmeshpy.getComplexFillMetric	(	Mesh	mesh,
		EdgeId	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

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.

getHoleFillPlan()

HoleFillPlan mrmeshpy.getHoleFillPlan	(	Mesh	mesh,
		EdgeId	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

getHoleFillPlans()

std_vector_HoleFillPlan mrmeshpy.getHoleFillPlans	(	Mesh	mesh,
		std_vector_Id_EdgeTag	holeRepresentativeEdges,
		FillHoleParams	params = '{}' )

prepares the plans how to triangulate the faces or holes, each given by a boundary edge (with filling target to the left),
the plans are prepared in parallel with minimal memory allocation compared to manual calling of several getHoleFillPlan(), but it can inefficient when some holes are very complex

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

getLeftTriPoints() [1/2]

std_array_Vector3_float_3 mrmeshpy.getLeftTriPoints	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

returns three points of left face of e: res[0] = orgPnt( e ), res[1] = destPnt( e )

getLeftTriPoints() [2/2]

None mrmeshpy.getLeftTriPoints	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e,
		Vector3f	v0,
		Vector3f	v1,
		Vector3f	v2 )

returns three points of left face of e: v0 = orgPnt( e ), v1 = destPnt( e )

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

(

Object

obj

)

constructs MeshOrPoints from ObjectMesh or ObjectPoints, otherwise returns nullopt

getMeshOrPointsXf()

MeshOrPointsXf mrmeshpy.getMeshOrPointsXf

(

Object

obj

)

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

getNumNodesPoints()

int mrmeshpy.getNumNodesPoints

(

int

numPoints

)

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

getNumSamples()

int mrmeshpy.getNumSamples

(

IPointPairs

pairs

)

returns the number of samples able to form pairs

getOneMeshIntersectionContours()

None mrmeshpy.getOneMeshIntersectionContours	(	Mesh	meshA,
		Mesh	meshB,
		std_vector_std_vector_VarEdgeTri	contours,
		std_vector_OneMeshContour	outA,
		std_vector_OneMeshContour	outB,
		CoordinateConverters	converters,
		AffineXf3f	rigidB2A = None,
		std_vector_std_vector_Vector3_float	outPtsA = None,
		bool	addSelfyTerminalVerts = False )

Converts contours given in topological terms as the intersections of one mesh's edge and another mesh's triangle (ContinuousContours),
into contours of meshA and/or meshB given as a sequence of (primitiveId and Cartesian coordinates);
converters are required for better precision in case of degenerations;
note that contours should not have intersections

getOneMeshSelfIntersectionContours()

std_vector_OneMeshContour mrmeshpy.getOneMeshSelfIntersectionContours	(	Mesh	mesh,
		std_vector_std_vector_VarEdgeTri	contours,
		CoordinateConverters	converters,
		AffineXf3f	rigidB2A = None )

Converts ordered continuous self contours of single meshes to OneMeshContours
converters are required for better precision in case of degenerations

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,
		EdgeId	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

getPickedPointNormal()

Vector3f mrmeshpy.getPickedPointNormal	(	VisualObject	object,
		std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag	point )

Returns object normal in local coordinates at given point,
returns std::nullopt if object or point is invalid, or if it is ObjectLines or ObjectPoints without normals

getPickedPointPosition()

Vector3f mrmeshpy.getPickedPointPosition	(	VisualObject	object,
		std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag	point )

Converts given point into local coordinates of its object,
returns std::nullopt if object or point is invalid, or if it does not present in the object's topology

getPlanarHoleFillPlan()

HoleFillPlan mrmeshpy.getPlanarHoleFillPlan	(	Mesh	mesh,
		EdgeId	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

getPlanarHoleFillPlans()

std_vector_HoleFillPlan mrmeshpy.getPlanarHoleFillPlans	(	Mesh	mesh,
		std_vector_Id_EdgeTag	holeRepresentativeEdges )

prepares the plans how to triangulate the planar faces or holes, each given by a boundary edge (with filling target to the left),
the plans are prepared in parallel with minimal memory allocation compared to manual calling of several getPlanarHoleFillPlan(), but it can inefficient when some holes are very complex

getPlane3d()

Plane3d mrmeshpy.getPlane3d	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

getPlane3f()

Plane3f mrmeshpy.getPlane3f	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

returns the plane containing given triangular face with normal looking outwards

getPlaneFillMetric()

FillHoleMetric mrmeshpy.getPlaneFillMetric	(	Mesh	mesh,
		EdgeId	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,
		EdgeId	e )

Similar to getPlaneFillMetric with extra penalty for the triangles having
normals looking in the opposite side of plane containing left of (e),
but the metric minimizes the sum of circumcircle radius times aspect ratio for all triangles in the triangulation.

getRegionBoundaryVerts()

VertBitSet 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

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

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)

getTopmostObjects_Object()

std_vector_std_shared_ptr_Object mrmeshpy.getTopmostObjects_Object	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_ObjectDistanceMap()

std_vector_std_shared_ptr_ObjectDistanceMap mrmeshpy.getTopmostObjects_ObjectDistanceMap	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_ObjectLines()

std_vector_std_shared_ptr_ObjectLines mrmeshpy.getTopmostObjects_ObjectLines	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_ObjectLinesHolder()

std_vector_std_shared_ptr_ObjectLinesHolder mrmeshpy.getTopmostObjects_ObjectLinesHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_ObjectMesh()

std_vector_std_shared_ptr_ObjectMesh mrmeshpy.getTopmostObjects_ObjectMesh	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_ObjectMeshHolder()

std_vector_std_shared_ptr_ObjectMeshHolder mrmeshpy.getTopmostObjects_ObjectMeshHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_ObjectPoints()

std_vector_std_shared_ptr_ObjectPoints mrmeshpy.getTopmostObjects_ObjectPoints	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_ObjectPointsHolder()

std_vector_std_shared_ptr_ObjectPointsHolder mrmeshpy.getTopmostObjects_ObjectPointsHolder	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_ObjectVoxels()

std_vector_std_shared_ptr_ObjectVoxels mrmeshpy.getTopmostObjects_ObjectVoxels	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostObjects_VisualObject()

std_vector_std_shared_ptr_VisualObject mrmeshpy.getTopmostObjects_VisualObject	(	Object	root,
		ObjectSelectivityType	type = 'ObjectSelectivityType::Selectable',
		bool	visibilityCheck = False )

Returns all topmost objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_Object()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_ObjectDistanceMap()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_ObjectLines()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_ObjectLinesHolder()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_ObjectMesh()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_ObjectMeshHolder()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_ObjectPoints()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_ObjectPointsHolder()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_ObjectVoxels()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTopmostVisibleObjects_VisualObject()

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

Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root

getTriPoints() [1/2]

std_array_Vector3_float_3 mrmeshpy.getTriPoints	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

returns three points of given face

getTriPoints() [2/2]

None mrmeshpy.getTriPoints	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f,
		Vector3f	v0,
		Vector3f	v1,
		Vector3f	v2 )

returns three points of given face

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 consists of two parts
1) for each triangle: it is the circumcircle diameter,
   this avoids the appearance of degenerate triangles;
2) for each edge: square root of double total area of triangles to its left and right
   times the factor depending extensionally on absolute dihedral angle between left and right triangles,
   this makes visually triangulated surface as smooth as possible.
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	(	FloatGrid	grid,
		Vector3i	p )

returns the value at given voxel

getVectorConverters() [1/2]

CoordinateConverters mrmeshpy.getVectorConverters

(

MeshPart

a

)

 \\brief creates simple converters from Vector3f to Vector3i and back in mesh part area range

getVectorConverters() [2/2]

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,
		EdgeId	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

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

None mrmeshpy.hardSmoothTetrahedrons	(	Mesh	mesh,
		VertBitSet	region = None )

move all region vertices with exactly three neighbor vertices in the center of the neighbors

hardSmoothTetrahedrons() [2/2]

None mrmeshpy.hardSmoothTetrahedrons	(	MeshTopology	topology,
		VertCoords	points,
		VertBitSet	region = None )

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,
		UseAABBTree	u = 'UseAABBTree::Yes' )

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

hasAnyXYPlaneSection()

bool mrmeshpy.hasAnyXYPlaneSection	(	MeshPart	mp,
		float	zLevel,
		UseAABBTree	u = 'UseAABBTree::Yes' )

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

hasFormatPlaceholders()

bool mrmeshpy.hasFormatPlaceholders

(

str

str

)

Returns true if `str` has at least one `{...}` formatting placeholder.

hasMultipleEdges()

bool mrmeshpy.hasMultipleEdges

(

MeshTopology

topology

)

hasProhibitedChars()

bool mrmeshpy.hasProhibitedChars

(

str

line

)

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

heapBytes() [1/11]

int mrmeshpy.heapBytes

(

BitSet

bs

)

returns the amount of memory given BitSet occupies on heap

heapBytes() [2/11]

int mrmeshpy.heapBytes

(

FloatGrid

grid

)

returns the amount of heap memory occupied by grid

heapBytes() [3/11]

int mrmeshpy.heapBytes

(

Mesh

ptr

)

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

heapBytes() [4/11]

int mrmeshpy.heapBytes

(

Object

ptr

)

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

heapBytes() [5/11]

int mrmeshpy.heapBytes

(

PointCloud

ptr

)

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

heapBytes() [6/11]

int mrmeshpy.heapBytes

(

Polyline3

ptr

)

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

heapBytes() [7/11]

int mrmeshpy.heapBytes

(

std_vector_Color

vec

)

returns the amount of memory given vector occupies on heap

heapBytes() [8/11]

int mrmeshpy.heapBytes

(

std_vector_float

vec

)

returns the amount of memory given vector occupies on heap

heapBytes() [9/11]

int mrmeshpy.heapBytes

(

std_vector_std_shared_ptr_Object

vec

)

returns the amount of memory given vector occupies on heap

heapBytes() [10/11]

int mrmeshpy.heapBytes

(

std_vector_unsigned_long

vec

)

returns the amount of memory given vector occupies on heap

heapBytes() [11/11]

int mrmeshpy.heapBytes

(

Vector_MeshTexture_TextureId

vec

)

holeDirArea()

Vector3d mrmeshpy.holeDirArea	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

computes directed area of the hole specified by one of its edges with no valid left face (left is hole);
if the hole is planar then returned vector is orthogonal to the plane pointing outside and its magnitude is equal to hole area

holePerimiter()

float mrmeshpy.holePerimiter	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

computes the perimeter of the hole specified by one of its edges with no valid left face (left is hole)

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

inCircle() [1/2]

bool mrmeshpy.inCircle

(

PreciseVertCoords2

vs

)

inCircle() [2/2]

bool mrmeshpy.inCircle

(

std_array_PreciseVertCoords2_4

vs

)

return true if 4th point in array lays inside circumcircle of first 3 points based triangle

inflate() [1/2]

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

inflate() [2/2]

None mrmeshpy.inflate	(	MeshTopology	topology,
		VertCoords	points,
		VertBitSet	verts,
		InflateSettings	settings )

inflate1()

None mrmeshpy.inflate1	(	MeshTopology	topology,
		VertCoords	points,
		VertBitSet	verts,
		float	pressure )

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;
this function makes just 1 iteration of inflation and is used inside inflate(...)

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

bool mrmeshpy.isClosed

(

std_vector_VarEdgeTri

contour

)

returns true if contour is closed

isClosed() [2/2]

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,
		EdgeId	e )

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

isEdgeBetweenDoubleTris()

bool mrmeshpy.isEdgeBetweenDoubleTris	(	MeshTopology	topology,
		EdgeId	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

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

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

leftCotan()

float mrmeshpy.leftCotan	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

computes cotangent of the angle in the left( e ) triangle opposite to e,
and returns 0 if left face does not exist

leftDirDblArea()

Vector3f mrmeshpy.leftDirDblArea	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

computes directed double area of left triangular face of given edge

leftNormal()

Vector3f mrmeshpy.leftNormal	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

computes triangular face normal from its vertices

leftRing() [1/2]

IteratorRange_RingIterator_NextEdgeSameLeft mrmeshpy.leftRing	(	MeshTopology	topology,
		EdgeId	edge )

to iterate over all edges with same left face as firstEdge (INCLUDING firstEdge)
for ( Edge e : leftRing( topology, firstEdge ) ) ...

leftRing() [2/2]

IteratorRange_RingIterator_NextEdgeSameLeft mrmeshpy.leftRing	(	MeshTopology	topology,
		FaceId	f )

leftRing0()

IteratorRange_RingIterator_NextEdgeSameLeft mrmeshpy.leftRing0	(	MeshTopology	topology,
		EdgeId	edge )

to iterate over all edges with same left face as firstEdge (EXCLUDING firstEdge)
for ( Edge e : leftRing0( topology, firstEdge ) ) ...

leftTangent()

Vector3f mrmeshpy.leftTangent	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

computes unit vector that is both orthogonal to given edge and to the normal of its left triangle, the vector is directed inside left triangle

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

loads polyline from file in the format detected from file extension

loadLines() [2/2]

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

loads polyline from stream in the format detected from given extension-string (`*.ext`);
important on Windows: in stream must be open in binary mode

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

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/3]

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

loads mesh from file in .PLY format;

loadPly() [2/3]

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

loadPly() [3/3]

VertCoords mrmeshpy.loadPly	(	typing.Any	in_,
		PlyLoadParams	params )

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_FloatGrid 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,
		bool	touchIsIntersection = True,
		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

makeBoxMesh()

Mesh mrmeshpy.makeBoxMesh

(

Box3f

box

)

creates mesh visualizing a box

makeBridge()

MakeBridgeResult mrmeshpy.makeBridge	(	MeshTopology	topology,
		EdgeId	a,
		EdgeId	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()

EdgeId mrmeshpy.makeBridgeEdge	(	MeshTopology	topology,
		EdgeId	a,
		EdgeId	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/4]

Mesh mrmeshpy.makeConvexHull

(

Mesh

in_

)

makeConvexHull() [2/4]

Mesh mrmeshpy.makeConvexHull

(

PointCloud

in_

)

makeConvexHull() [3/4]

std_vector_Vector2_float mrmeshpy.makeConvexHull

(

std_vector_Vector2_float

points

)

computes the contour of convex hull from given input points

makeConvexHull() [4/4]

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

creates box mesh with given min-corner (base) and given size in every dimension;
with default parameters, creates unit cube mesh with the centroid in (0,0,0)

makeCubeTopology()

MeshTopology mrmeshpy.makeCubeTopology

(

)

creates cube's topology with 8 vertices, 12 triangular faces, 18 undirected edges.
The order of vertices:
  0_v: x=min, y=min, z=min
  1_v: x=min, y=max, z=min
  2_v: x=max, y=max, z=min
  3_v: x=max, y=min, z=min
  4_v: x=min, y=min, z=max
  5_v: x=min, y=max, z=max
  6_v: x=max, y=max, z=max
  7_v: x=max, y=min, z=max

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 )

makeDecimatedObjectMeshData()

ObjectMeshData mrmeshpy.makeDecimatedObjectMeshData	(	ObjectMesh	obj,
		DecimateSettings	settings,
		DecimateResult	outRes = None )

returns the data of decimated mesh given ObjectMesh (which remains unchanged) and decimation parameters

makeDegenerateBandAroundHole()

EdgeId mrmeshpy.makeDegenerateBandAroundHole	(	Mesh	mesh,
		EdgeId	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() [1/3]

int mrmeshpy.makeDeloneEdgeFlips	(	EdgeLengthMesh	mesh,
		IntrinsicDeloneSettings	settings = '{}',
		int	numIters = 1,
		func_bool_from_float	progressCallback = '{}' )

improves mesh triangulation by performing flipping of edges to satisfy Intrinsic Delaunay local property,
consider every edge at most numIters times,
\\return the number of flips done
\\param numIters Maximal iteration count
\\param progressCallback Callback to report algorithm progress and cancel it by user request
see "An Algorithm for the Construction of Intrinsic Delaunay Triangulations with Applications to Digital Geometry Processing". https://page.math.tu-berlin.de/~bobenko/papers/InDel.pdf

makeDeloneEdgeFlips() [2/3]

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

makeDeloneEdgeFlips() [3/3]

int mrmeshpy.makeDeloneEdgeFlips	(	MeshTopology	topology,
		VertCoords	points,
		DeloneSettings	settings = '{}',
		int	numIters = 1,
		func_bool_from_float	progressCallback = '{}' )

makeDeloneOriginRing() [1/2]

None mrmeshpy.makeDeloneOriginRing	(	Mesh	mesh,
		EdgeId	e,
		DeloneSettings	settings = '{}' )

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

makeDeloneOriginRing() [2/2]

None mrmeshpy.makeDeloneOriginRing	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e,
		DeloneSettings	settings = '{}' )

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

makeObjectFromClassName()

VisualObject mrmeshpy.makeObjectFromClassName

(

str

className

)

Allocates an object of type `kind`, passing `params...` to its constructor.

makeObjectFromEnum()

VisualObject mrmeshpy.makeObjectFromEnum

(

FeaturesObjectKind

kind

)

Allocates an object of type `kind`, passing `params...` to its constructor.

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, ObjectLines or ObjectPoints (if the file has points or edges 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

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

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 )

creates parallelepiped mesh with given min-corner \\p base and given directional vectors \\p size

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,
		EdgeId	a,
		EdgeId	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_unsigned_long	validator,
		func_Vector3_float_from_unsigned_long_unsigned_long	positioner,
		func_bool_from_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long_unsigned_long	faceValidator = '{}',
		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

makeRigidXf() [2/2]

AffineXf3f mrmeshpy.makeRigidXf	(	MeshPart	mp,
		AffineXf3f	meshXf )

makeSignedByWindingNumber()

None mrmeshpy.makeSignedByWindingNumber	(	FloatGrid	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,
		EdgeId	a,
		EdgeId	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

makeSolidOfRevolution()

Mesh mrmeshpy.makeSolidOfRevolution	(	std_vector_Vector2_float	profile,
		int	resolution = 16 )

Makes a solid-of-revolution mesh. The resulting mesh is symmetrical about the z-axis.
The profile points must be in the format { distance to the z-axis; z value }.

makeSphere()

Mesh mrmeshpy.makeSphere

(

SphereParams

params

)

creates a mesh of sphere with irregular triangulation

makeSpline() [1/3]

MarkedContour3f mrmeshpy.makeSpline	(	MarkedContour3f	in_,
		float	markStability = 1,
		std_vector_Vector3_float	normals = None )

\\param in input marked contour
\\param markStability a positive value, the more the value the closer marked points will be to their original positions
\\param normals if provided the curve at marked points will try to be orthogonal to given normal there
\\return contour with same number of points and same marked, where each return point tries to be on a smooth curve

makeSpline() [2/3]

MarkedContour3f mrmeshpy.makeSpline	(	MarkedContour3f	in_,
		std_vector_Vector3_float	normals,
		float	markStability = 1 )

\\param in input marked contour
\\param normals the curve at marked points will try to be orthogonal to given normal there
\\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() [3/3]

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

makeSubdividedObjectMeshData()

ObjectMeshData mrmeshpy.makeSubdividedObjectMeshData	(	ObjectMesh	obj,
		SubdivideSettings	settings )

returns the data of subdivided mesh given ObjectMesh (which remains unchanged) and subdivision parameters

makeThickMesh()

Mesh mrmeshpy.makeThickMesh	(	Mesh	m,
		ThickenParams	params )

given a mesh \\p m, representing a surface,
creates new closed mesh by cloning mirrored mesh, and shifting original part and cloned part in different directions according to \\p params,
if original mesh was open then stitches corresponding boundaries of two parts

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

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

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

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

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/7]

EdgeId mrmeshpy.mapEdge	(	MapOrHashMap_UndirectedEdgeId_EdgeId	m,
		EdgeId	src )

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

mapEdge() [2/7]

UndirectedEdgeId mrmeshpy.mapEdge	(	MapOrHashMap_UndirectedEdgeId_EdgeId	m,
		UndirectedEdgeId	src )

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

mapEdge() [3/7]

EdgeId mrmeshpy.mapEdge	(	phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag	map,
		EdgeId	src )

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

mapEdge() [4/7]

UndirectedEdgeId mrmeshpy.mapEdge	(	phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag	map,
		UndirectedEdgeId	src )

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

mapEdge() [5/7]

UndirectedEdgeId mrmeshpy.mapEdge	(	UndirectedEdgeBMap	map,
		UndirectedEdgeId	src )

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

mapEdge() [6/7]

EdgeId mrmeshpy.mapEdge	(	WholeEdgeMap	map,
		EdgeId	src )

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

mapEdge() [7/7]

UndirectedEdgeId mrmeshpy.mapEdge	(	WholeEdgeMap	map,
		UndirectedEdgeId	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/5]

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

makes Mesh from FunctionVolume with given settings using Marching Cubes algorithm

marchingCubes() [2/5]

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

makes Mesh from SimpleBinaryVolume with given settings using Marching Cubes algorithm

marchingCubes() [3/5]

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

makes Mesh from SimpleVolume with given settings using Marching Cubes algorithm

marchingCubes() [4/5]

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

makes Mesh from SimpleVolumeMinMax with given settings using Marching Cubes algorithm

marchingCubes() [5/5]

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

makes Mesh from VdbVolume with given settings using Marching Cubes algorithm

marchingCubesAsTriMesh() [1/5]

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

marchingCubesAsTriMesh() [2/5]

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

marchingCubesAsTriMesh() [3/5]

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

marchingCubesAsTriMesh() [4/5]

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

marchingCubesAsTriMesh() [5/5]

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

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

FloatGrid 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

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

normal() [1/3]

Vector3f mrmeshpy.normal	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

computes triangular face normal from its vertices

normal() [2/3]

Vector3f mrmeshpy.normal	(	MeshTopology	topology,
		VertCoords	points,
		MeshTriPoint	p )

computes normal in three vertices of p's triangle, then interpolates them using barycentric coordinates and normalizes again;
this is the same normal as in rendering with smooth shading

normal() [3/3]

Vector3f mrmeshpy.normal	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v )

computes normal in a vertex using sum of directed areas of neighboring triangles

objectHasSelectableChildren()

bool mrmeshpy.objectHasSelectableChildren	(	Object	object,
		bool	recurse = False )

returns whether the object has selectable children
\\param recurse - if true, look up for selectable children at any depth

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>

offsetVerts()

bool mrmeshpy.offsetVerts	(	Mesh	mesh,
		func_float_from_Id_VertTag	offset,
		func_bool_from_float	cb = '{}' )

Modifies \\p mesh shifting each vertex along its pseudonormal by the corresponding \\p offset
@return false if cancelled.

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_VarEdgeTri mrmeshpy.orderIntersectionContours	(	MeshTopology	topologyA,
		MeshTopology	topologyB,
		std_vector_VarEdgeTri	intersections )

Combines unordered input intersections (and flips orientation of intersected edges from mesh B) into ordered oriented contours with the properties:
1. Each contour is
   a. either closed (then its first and last elements are equal),
   b. or open (then its first and last intersected edges are boundary edges).
2. Next intersection in a contour is located to the left of the current intersected edge:
   a. if the current and next intersected triangles are the same, then next intersected edge is either next( curr.edge ) or prev( curr.edge.sym() ).sym(),
   b. otherwise next intersected triangle is left( curr.edge ) and next intersected edge is one of the edges having the current intersected triangle to the right.
3. Orientation of intersected edges in each pair of (intersected edge, intersected triangle):
   a. the intersected edge of mesh A is directed from negative half-space of the intersected triangle from mesh B to its positive half-space,
   b. the intersected edge of mesh B is directed from positive half-space of the intersected triangle from mesh A to its negative half-space.
4. Orientation of contours:
   a. left  of contours on mesh A is inside of mesh B (consequence of 3a),
   b. right of contours on mesh B is inside of mesh A (consequence of 3b).

orderSelfIntersectionContours()

std_vector_std_vector_VarEdgeTri mrmeshpy.orderSelfIntersectionContours	(	MeshTopology	topology,
		std_vector_EdgeTri	intersections )

Combines unordered input self-intersections (and flips orientation of some intersected edges) into ordered oriented contours with the properties:
1. Each contour is
   a. either closed (then its first and last elements are equal),
   b. or open if terminal intersection is on mesh boundary or if self-intersection terminates in a vertex.
2. Next intersection in a contour is located to the left of the current intersected edge:
   a. if the current and next intersected triangles are the same, then next intersected edge is either next( curr.edge ) or prev( curr.edge.sym() ).sym(),
   b. otherwise next intersected triangle is left( curr.edge ) and next intersected edge is one of the edges having the current intersected triangle to the right.
3. Orientation of intersected edges in each pair of (intersected edge, intersected triangle):
   a. isEdgeATriB() = true:  the intersected edge is directed from negative half-space of the intersected triangle to its positive half-space,
   b. isEdgeATriB() = false: the intersected edge is directed from positive half-space of the intersected triangle to its negative half-space.
4. Contours [2*i] and [2*i+1]
   a. have equal lengths and pass via the same intersections but in opposite order,
   b. each intersection is present in two contours with different values of isEdgeATriB() flag, and opposite directions of the intersected edge.
5. Orientation of contours:
   a. first element of even (0,2,...) contours has isEdgeATriB() = true, left of even contours goes inside (consequence of 3a),
   b. first element of odd (1,3,...) contours has isEdgeATriB() = false, right of odd contours goes inside (consequence of 3b).

orgPnt()

Vector3f mrmeshpy.orgPnt	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e )

returns coordinates of the edge origin

orgRing() [1/2]

IteratorRange_RingIterator_NextEdgeSameOrigin mrmeshpy.orgRing	(	MeshTopology	topology,
		EdgeId	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,
		EdgeId	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.

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

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

orientParaboloid3d() [1/2]

bool mrmeshpy.orientParaboloid3d	(	Vector2i	a,
		Vector2i	b,
		Vector2i	c )

considers 3D points obtained from 2D inputs by moving each point on paraboloid: z = x*x+y*y;
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"

orientParaboloid3d() [2/2]

bool mrmeshpy.orientParaboloid3d	(	Vector2i	a,
		Vector2i	b,
		Vector2i	c,
		Vector2i	d )

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

planeMeshIntersect()

None mrmeshpy.planeMeshIntersect	(	MeshPart	meshPart,
		Plane3f	plane,
		FaceBitSet	fs,
		UndirectedEdgeBitSet	ues,
		VertBitSet	vs,
		std_vector_Id_FaceTag	fsVec = None )

given mesh part and arbitrary plane, outputs
\\param fs  triangles from boxes crossed or touched by the plane
\\param ues edges of these triangles
\\param vs  vertices of these triangles
\\param fsVec triangles from boxes crossed or touched by the plane in unspecified order

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	(	PointCloudPart	pcp,
		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_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag 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

polylineOffset()

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

constructs an offset contour for given polyline

polylineToDistanceField()

FloatGrid mrmeshpy.polylineToDistanceField	(	Polyline3	polyline,
		PolylineToDistanceVolumeParams	params )

convert polyline to voxels distance field

polylineToFunctionVolume()

FunctionVolume mrmeshpy.polylineToFunctionVolume	(	Polyline3	polyline,
		PolylineToVolumeParams	params )

convert polyline to function volume

polylineToSimpleVolume()

SimpleVolume mrmeshpy.polylineToSimpleVolume	(	Polyline3	polyline,
		PolylineToVolumeParams	params )

convert polyline to simple volume

polylineToVdbVolume()

VdbVolume mrmeshpy.polylineToVdbVolume	(	Polyline3	polyline,
		PolylineToDistanceVolumeParams	params )

convert polyline to VDB volume

positionVertsSmoothly() [1/2]

None mrmeshpy.positionVertsSmoothly	(	Mesh	mesh,
		VertBitSet	verts,
		EdgeWeights	edgeWeights = 'EdgeWeights::Cotan',
		VertexMass	vmass = 'VertexMass::Unit',
		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

positionVertsSmoothly() [2/2]

None mrmeshpy.positionVertsSmoothly	(	MeshTopology	topology,
		VertCoords	points,
		VertBitSet	verts,
		EdgeWeights	edgeWeights = 'EdgeWeights::Cotan',
		VertexMass	vmass = 'VertexMass::Unit',
		VertBitSet	fixedSharpVertices = None )

positionVertsSmoothlySharpBd() [1/3]

None mrmeshpy.positionVertsSmoothlySharpBd	(	Mesh	mesh,
		PositionVertsSmoothlyParams	params )

Puts given vertices in such positions to make smooth surface inside verts-region, but sharp on its boundary;

positionVertsSmoothlySharpBd() [2/3]

None mrmeshpy.positionVertsSmoothlySharpBd	(	Mesh	mesh,
		VertBitSet	verts )

positionVertsSmoothlySharpBd() [3/3]

None mrmeshpy.positionVertsSmoothlySharpBd	(	MeshTopology	topology,
		VertCoords	points,
		PositionVertsSmoothlyParams	params )

positionVertsWithSpacing() [1/2]

None mrmeshpy.positionVertsWithSpacing	(	Mesh	mesh,
		SpacingSettings	settings )

Moves given vertices to make the distances between them as specified

positionVertsWithSpacing() [2/2]

None mrmeshpy.positionVertsWithSpacing	(	MeshTopology	topology,
		VertCoords	points,
		SpacingSettings	settings )

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

projArea()

float mrmeshpy.projArea	(	MeshTopology	topology,
		VertCoords	points,
		Vector3f	dir,
		FaceBitSet	fs = None )

computes the sum of absolute projected area of faces from given region as visible if look from given direction

computes the sum of absolute projected area of faces from given region (or whole mesh) as visible if look from given direction

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

projectWorldPointOntoObject()

MeshOrPoints.ProjectionResult mrmeshpy.projectWorldPointOntoObject	(	Vector3f	p,
		Object	obj )

Projects a point onto an object, in world space. Returns `.valid() == false` if this object type isn't projectable onto.

projectWorldPointOntoObjectsRecursive()

MeshOrPoints.ProjectionResult mrmeshpy.projectWorldPointOntoObjectsRecursive	(	Vector3f	p,
		Object	root = None,
		func_bool_from_Object	projectPred = None,
		func_bool_from_Object	recursePred = None )

Recursively visits the objects and projects the point on each one. Returns the closest projection.
If `root` is null, the scene root is used. Not passing `SceneRoot::get()` directly to avoid including that header.
If `projectPred` is specified and false, will not project onto this object.
If `recursePred` is specified and false, will not visit the children of this object.

pseudonormal() [1/3]

Vector3f mrmeshpy.pseudonormal	(	MeshTopology	topology,
		VertCoords	points,
		MeshTriPoint	p,
		FaceBitSet	region = None )

returns pseudonormal in corresponding face/edge/vertex for signed distance calculation
as suggested in the article "Signed Distance Computation Using the Angle Weighted Pseudonormal" by J. Andreas Baerentzen and Henrik Aanaes,
https://backend.orbit.dtu.dk/ws/portalfiles/portal/3977815/B_rentzen.pdf
unlike normal( const MeshTriPoint & p ), this is not a smooth function

pseudonormal() [2/3]

Vector3f mrmeshpy.pseudonormal	(	MeshTopology	topology,
		VertCoords	points,
		UndirectedEdgeId	e,
		FaceBitSet	region = None )

computes normalized half sum of face normals sharing given edge (only (region) faces will be considered);

pseudonormal() [3/3]

Vector3f mrmeshpy.pseudonormal	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v,
		FaceBitSet	region = None )

computes angle-weighted sum of normals of incident faces of given vertex (only (region) faces will be considered);
the sum is normalized before returning

putScanFileNameInZ()

None mrmeshpy.putScanFileNameInZ	(	std_vector_std_filesystem_path	scans,
		std_vector_SliceInfo	zOrder )

Read layer heights from given scan file names

quadraticForm()

QuadraticForm3f mrmeshpy.quadraticForm	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v,
		bool	angleWeigted,
		FaceBitSet	region = None,
		UndirectedEdgeBitSet	creases = None )

computes quadratic form in the vertex as the sum of squared distances from
1) planes of adjacent triangles, with the weight equal to the angle of adjacent triangle at this vertex divided on PI in case of angleWeigted=true;
2) lines of adjacent boundary and crease edges

rayBoxIntersect() [1/2]

bool mrmeshpy.rayBoxIntersect	(	Box2f	box,
		Line2f	line,
		float	t0,
		float	t1 )

rayBoxIntersect() [2/2]

bool mrmeshpy.rayBoxIntersect	(	Box3f	box,
		Line3f	line,
		float	t0,
		float	t1 )

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 intersection to ray origin (line param=0)
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 intersection to ray origin (line param=0)
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 intersection to ray origin (line param=0)
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 intersection to ray origin (line param=0)
or any intersection for better performance if \\p !closestIntersect.

rayPolylineIntersectAll() [1/2]

None mrmeshpy.rayPolylineIntersectAll	(	Polyline2	polyline,
		Line2d	line,
		func_Processing_from_EdgePoint_double_double_double	callback,
		float	rayStart = 0.0,
		float	rayEnd = 1.7976931348623157e+308,
		IntersectionPrecomputes2_double	prec = None )

Intersects 2D ray and polyline in double-precision.
Reports all intersections via given callback with the tendency to do it from ray start to ray end, but without guarantee of exact order.

rayPolylineIntersectAll() [2/2]

None mrmeshpy.rayPolylineIntersectAll	(	Polyline2	polyline,
		Line2f	line,
		func_Processing_from_EdgePoint_float_float_float	callback,
		float	rayStart = 0.0,
		float	rayEnd = 3.4028234663852886e+38,
		IntersectionPrecomputes2_float	prec = None )

Intersects 2D ray and polyline in single-precision.
Reports all intersections via given callback with the tendency to do it from ray start to ray end, but without guarantee of exact order.

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

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/3]

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/3]

bool mrmeshpy.relax	(	MeshTopology	topology,
		VertCoords	points,
		MeshRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

relax() [3/3]

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/3]

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/3]

bool mrmeshpy.relaxApprox	(	MeshTopology	topology,
		VertCoords	points,
		MeshApproxRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

relaxApprox() [3/3]

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/3]

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/3]

bool mrmeshpy.relaxKeepVolume	(	MeshTopology	topology,
		VertCoords	points,
		MeshRelaxParams	params = '{}',
		func_bool_from_float	cb = '{}' )

relaxKeepVolume() [3/3]

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_VarEdgeTri	contours,
		bool	ignoreOpen = False )

Removes contours that fully lay inside one triangle from the contours
if `ignoreOpen` then do not consider non-closed contours as lone, even if they really are

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

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

removeSpikes() [2/2]

None mrmeshpy.removeSpikes	(	MeshTopology	topology,
		VertCoords	points,
		int	maxIterations,
		float	minSumAngle,
		VertBitSet	region = None )

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]

FloatGrid mrmeshpy.resampled	(	FloatGrid	grid,
		float	voxelScale,
		func_bool_from_float	cb = '{}' )

resample this grid to fit voxelScale

resampled() [2/2]

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

resample this grid to fit voxelScale

resolveMeshDegenerations()

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

 \\brief Removes degenerate triangles in a mesh by calling decimateMesh function with appropriate settings
 \\details consider using \\ref fixMeshDegeneracies for more complex cases
 \\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 = '{}' )

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

 \\brief Finds segment that divide mesh on source and sink (source included, sink excluded), by minimizing the sum of metric over the boundary
 If the computations are terminated by \\p progress, then returns the best approximation found by the moment of termination

segmentIntersectionOrder() [1/2]

bool mrmeshpy.segmentIntersectionOrder

(

std_array_PreciseVertCoords2_6

vs

)

given line segment s=01 and two other segments sa=23, sb=45 known to intersect it, finds the order of intersection using precise predicates:
true:  s[0], s ^ sa, s ^ sb, s[1]
false: s[0], s ^ sb, s ^ sa, s[1]
segments sa and sb can have at most one shared point, all other points must be unique

segmentIntersectionOrder() [2/2]

bool mrmeshpy.segmentIntersectionOrder

(

std_array_PreciseVertCoords_8

vs

)

given line segment s=01 and two triangles ta=234, tb=567 known to intersect it, finds the order of intersection using precise predicates:
true:  s[0], s ^ ta, s ^ tb, s[1]
false: s[0], s ^ tb, s ^ ta, s[1]
segments ta and tb can have at most two shared points, all other points must be unique

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

selfBoolean()

Mesh mrmeshpy.selfBoolean

(

Mesh

mesh

)

performs boolean operation on mesh with itself, cutting simple intersections contours and flipping their connectivity
this function is experimental and likely to change signature and/or behavior in future 

separateClosedContour()

std_vector_TypedBitSet_Id_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

(

FloatGrid

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

FloatGrid 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

smaller()

bool mrmeshpy.smaller	(	PreciseVertCoord	l,
		PreciseVertCoord	r )

return true if l is smaller than r,
uses simulation-of-simplicity (assuming larger perturbations of points with smaller id) to avoid "coordinates are the same"

smaller2()

bool mrmeshpy.smaller2

(

std_array_PreciseVertCoords2_4

vs

)

given the line passing via points vs[0] and vs[1], which defines linear signed scalar distance field:
zero on the line, positive for x where ccw(vs[0], vs[1], x) == true, and negative for x where ccw(vs[0], vs[1], x) == false
finds whether sdistance(vs[2]) < sdistance(vs[3]);
avoids equality of signed distances using simulation-of-simplicity approach (assuming larger perturbations of points with smaller id)

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

splitByChunks()

IteratorRange_ChunkIterator mrmeshpy.splitByChunks	(	int	totalSize,
		int	chunkSize,
		int	overlap = 0 )

returns a pair of iterators for chunks covering the array of given size

splitByLines()

std_vector_unsigned_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,
		EdgeId	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/6]

float mrmeshpy.sqr

(

Vector2d

a

)

squared length

sqr() [2/6]

float mrmeshpy.sqr

(

Vector2f

a

)

squared length

sqr() [3/6]

int mrmeshpy.sqr

(

Vector2i

a

)

squared length

sqr() [4/6]

float mrmeshpy.sqr

(

Vector3d

a

)

squared length

sqr() [5/6]

float mrmeshpy.sqr

(

Vector3f

a

)

squared length

sqr() [6/6]

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,
		EdgeId	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.

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

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

subdivideMesh() [2/2]

int mrmeshpy.subdivideMesh	(	ObjectMeshData	data,
		SubdivideSettings	settings )

subdivides mesh with per-element attributes according to given settings;
\\detail if settings.region is not null, then given region must be a subset of current face selection or face selection must absent
\\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 = '{}' )

subdivideWithPlane() [1/2]

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

subdivideWithPlane() [2/2]

UndirectedEdgeBitSet mrmeshpy.subdivideWithPlane	(	Polyline3	polyline,
		Plane3f	plane,
		EdgeBitSet	newPositiveEdges = '{}',
		func_void_from_Id_EdgeTag_Id_EdgeTag_float	onEdgeSplitCallback = '{}' )

This function splits edges intersected by the plane
\\return edges located above the plane (in direction of normal to plane)
\\param polyline Input polyline that will be cut by the plane
\\param plane Input plane to cut polyline with
\\param newPositiveEdges edges with origin on the plane and oriented to the positive direction (only adds bits to the existing 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

sumAngles()

float mrmeshpy.sumAngles	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v,
		bool_output	outBoundaryVert = None )

computes the sum of triangle angles at given vertex; optionally returns whether the vertex is on boundary

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.
 
 \\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, the resulting loop will be oriented clockwise if look from the direction's tip

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.
 
 \\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, the resulting loop will be oriented clockwise if look from the direction's tip

systemToUtf8()

str mrmeshpy.systemToUtf8

(

str

system

)

converts system encoded string to UTF8-encoded string

teethMaskToDirectionVolume()

std_array_VoxelsVolumeMinMax_Vector_float_Id_VoxelTag_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 = '{}',
		PartMapping	map = '{}' )

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;

toEdgePoint()

EdgePoint mrmeshpy.toEdgePoint	(	MeshTopology	topology,
		VertCoords	points,
		EdgeId	e,
		Vector3f	p )

converts edge and 3d point into edge-point representation

toLower()

str mrmeshpy.toLower

(

str

str

)

return a copy of the string with all alphabetic ASCII 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

)

toTriPoint() [1/2]

MeshTriPoint mrmeshpy.toTriPoint	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f,
		Vector3f	p )

converts face id and 3d point into barycentric representation

toTriPoint() [2/2]

MeshTriPoint mrmeshpy.toTriPoint	(	MeshTopology	topology,
		VertCoords	points,
		PointOnFace	p )

converts face id and 3d point into barycentric representation

trackLeftBoundaryLoop() [1/2]

std_vector_Id_EdgeTag mrmeshpy.trackLeftBoundaryLoop	(	MeshTopology	topology,
		EdgeId	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

trackLeftBoundaryLoop() [2/2]

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

trackRightBoundaryLoop() [1/2]

std_vector_Id_EdgeTag mrmeshpy.trackRightBoundaryLoop	(	MeshTopology	topology,
		EdgeId	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

trackRightBoundaryLoop() [2/2]

std_vector_Id_EdgeTag mrmeshpy.trackRightBoundaryLoop	(	MeshTopology	topology,
		FaceBitSet	region,
		EdgeId	e0 )

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

triangleAspectRatio()

float mrmeshpy.triangleAspectRatio	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

returns aspect ratio of given mesh triangle equal to the ratio of the circum-radius to twice its in-radius

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

triCenter()

Vector3f mrmeshpy.triCenter	(	MeshTopology	topology,
		VertCoords	points,
		FaceId	f )

returns the centroid of given triangle

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.

trim()

str mrmeshpy.trim

(

str

str

)

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

trimLeft()

str mrmeshpy.trimLeft

(

str

str

)

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

trimRight()

str mrmeshpy.trimRight

(

str

str

)

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

trimWithPlane() [1/2]

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

trimWithPlane() [2/2]

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

This function divides polyline with a plane, leaving only part of polyline that lies in positive direction of normal
\\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, containing optional output

triPoint()

Vector3f mrmeshpy.triPoint	(	MeshTopology	topology,
		VertCoords	points,
		MeshTriPoint	p )

computes coordinates of point given as face and barycentric representation

undirectedEdges() [1/2]

IteratorRange_UndirectedEdgeIterator mrmeshpy.undirectedEdges

(

MeshTopology

topology

)

undirectedEdges() [2/2]

IteratorRange_PolylineUndirectedEdgeIterator mrmeshpy.undirectedEdges

(

PolylineTopology

topology

)

uniteCloseVertices() [1/2]

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

uniteCloseVertices() [2/2]

int mrmeshpy.uniteCloseVertices	(	Mesh	mesh,
		MeshBuilder.UniteCloseParams	params = '{}' )

the function finds groups of mesh vertices located closer to each other than \\param params.closeDist, and unites such vertices in one;
then the mesh is rebuilt from the remaining triangles
\\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)

utf8string()

str mrmeshpy.utf8string

(

os.PathLike | str | bytes

path

)

utf8substr()

str mrmeshpy.utf8substr	(	str	s,
		int	pos,
		int	count )

given on input a valid utf8-encoded string, returns its substring starting at \\p pos unicode symbol,
and containing at most \\p count unicode symbols (but res.size() can be more than \\p count since a unicode symbol can be represented by more than 1 byte)

utf8ToSystem()

str mrmeshpy.utf8ToSystem

(

str

utf8

)

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

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

vertexPosEqualNeiAreas() [1/2]

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

vertexPosEqualNeiAreas() [2/2]

Vector3f mrmeshpy.vertexPosEqualNeiAreas	(	MeshTopology	topology,
		VertCoords	points,
		VertId	v,
		bool	noShrinkage )

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

volume()

float mrmeshpy.volume	(	MeshTopology	topology,
		VertCoords	points,
		FaceBitSet	region = None )

returns volume of the object surrounded by given region (or whole mesh if (region) is nullptr);
if the region has holes then each hole will be virtually filled by adding triangles for each edge and the hole's geometrical center

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

e^(modifier*(dens1+dens2))

voxelsSumDiffsMetric()

func_float_from_unsigned_long_unsigned_long mrmeshpy.voxelsSumDiffsMetric	(	VdbVolume	voxels,
		VoxelMetricParameters	parameters )

sum of dense differences with start and stop voxels

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,
		std_vector_Id_FaceTag	fsVec = None )

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
\\param fsVec triangles crossed or touched by the plane in unspecified order

zCompensate()

bool mrmeshpy.zCompensate	(	Mesh	mesh,
		ZCompensateParams	params )

For 3D printers: shifts every vertex with normal having negative projection on Z-axis, along Z-axis;
mesh's topology is preserved unchanged
@return false if cancelled.

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

BMap_Id_VoxelTag_Id_VoxelTag

mrmeshpy.BMap_Id_VoxelTag_Id_VoxelTag = BMap_VoxelId_VoxelId

BMap_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType

mrmeshpy.BMap_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType = BMap_Id_ICPElemtTag_Id_ICPElemtTag

BMap_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType

mrmeshpy.BMap_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType = BMap_VoxelId_VoxelId

BooleanResMapObj

mrmeshpy.BooleanResMapObj = BooleanResultMapper.MapObject

Box_Vector2d_Vb

mrmeshpy.Box_Vector2d_Vb = Vector2b

Box_Vector2f_Vb

mrmeshpy.Box_Vector2f_Vb = Vector2b

Box_Vector2i64_Vb

mrmeshpy.Box_Vector2i64_Vb = Vector2b

Box_Vector2i_Vb

mrmeshpy.Box_Vector2i_Vb = Vector2b

Box_Vector3d_Vb

mrmeshpy.Box_Vector3d_Vb = Vector3b

Box_Vector3f_Vb

mrmeshpy.Box_Vector3f_Vb = Vector3b

Box_Vector3i64_Vb

mrmeshpy.Box_Vector3i64_Vb = Vector3b

Box_Vector3i_Vb

mrmeshpy.Box_Vector3i_Vb = Vector3b

Buffer_Id_EdgeTag_Id_EdgeTag

mrmeshpy.Buffer_Id_EdgeTag_Id_EdgeTag = Buffer_EdgeId_EdgeId

Buffer_Id_EdgeTag_Id_EdgeTag_const_iterator

mrmeshpy.Buffer_Id_EdgeTag_Id_EdgeTag_const_iterator = NoDefInit_EdgeId

Buffer_Id_EdgeTag_Id_EdgeTag_const_reference

mrmeshpy.Buffer_Id_EdgeTag_Id_EdgeTag_const_reference = NoDefInit_EdgeId

Buffer_Id_EdgeTag_Id_EdgeTag_iterator

mrmeshpy.Buffer_Id_EdgeTag_Id_EdgeTag_iterator = NoDefInit_EdgeId

Buffer_Id_EdgeTag_Id_EdgeTag_reference

mrmeshpy.Buffer_Id_EdgeTag_Id_EdgeTag_reference = NoDefInit_EdgeId

Buffer_Id_EdgeTag_Id_EdgeTag_T

mrmeshpy.Buffer_Id_EdgeTag_Id_EdgeTag_T = NoDefInit_EdgeId

Buffer_Id_EdgeTag_UndirectedEdgeId_const_iterator

mrmeshpy.Buffer_Id_EdgeTag_UndirectedEdgeId_const_iterator = NoDefInit_EdgeId

Buffer_Id_EdgeTag_UndirectedEdgeId_const_reference

mrmeshpy.Buffer_Id_EdgeTag_UndirectedEdgeId_const_reference = NoDefInit_EdgeId

Buffer_Id_EdgeTag_UndirectedEdgeId_iterator

mrmeshpy.Buffer_Id_EdgeTag_UndirectedEdgeId_iterator = NoDefInit_EdgeId

Buffer_Id_EdgeTag_UndirectedEdgeId_reference

mrmeshpy.Buffer_Id_EdgeTag_UndirectedEdgeId_reference = NoDefInit_EdgeId

Buffer_Id_EdgeTag_UndirectedEdgeId_T

mrmeshpy.Buffer_Id_EdgeTag_UndirectedEdgeId_T = NoDefInit_EdgeId

Buffer_Id_VoxelTag_Id_VoxelTag

mrmeshpy.Buffer_Id_VoxelTag_Id_VoxelTag = Buffer_VoxelId_VoxelId

Buffer_Id_VoxelTag_Id_VoxelTag_const_iterator

mrmeshpy.Buffer_Id_VoxelTag_Id_VoxelTag_const_iterator = NoDefInit_VoxelId

Buffer_Id_VoxelTag_Id_VoxelTag_const_reference

mrmeshpy.Buffer_Id_VoxelTag_Id_VoxelTag_const_reference = NoDefInit_VoxelId

Buffer_Id_VoxelTag_Id_VoxelTag_iterator

mrmeshpy.Buffer_Id_VoxelTag_Id_VoxelTag_iterator = NoDefInit_VoxelId

Buffer_Id_VoxelTag_Id_VoxelTag_reference

mrmeshpy.Buffer_Id_VoxelTag_Id_VoxelTag_reference = NoDefInit_VoxelId

Buffer_Id_VoxelTag_Id_VoxelTag_T

mrmeshpy.Buffer_Id_VoxelTag_Id_VoxelTag_T = NoDefInit_VoxelId

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_VarEdgeTri

ContinuousContours

mrmeshpy.ContinuousContours = std_vector_std_vector_VarEdgeTri

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

DashPattern

mrmeshpy.DashPattern = Vector4_unsigned_char

DecimatePolylineSettings2

mrmeshpy.DecimatePolylineSettings2 = DecimatePolylineSettings_Vector2f

DecimatePolylineSettings3

mrmeshpy.DecimatePolylineSettings3 = DecimatePolylineSettings_Vector3f

EdgeHashMap

mrmeshpy.EdgeHashMap = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

EdgeLoop

mrmeshpy.EdgeLoop = std_vector_Id_EdgeTag

EdgeLoops

mrmeshpy.EdgeLoops = std_vector_std_vector_Id_EdgeTag

EdgeMapOrHashMap

mrmeshpy.EdgeMapOrHashMap = MapOrHashMap_EdgeId_EdgeId

EdgePath

mrmeshpy.EdgePath = std_vector_Id_EdgeTag

EdgePathsBuilder

mrmeshpy.EdgePathsBuilder = EdgePathsBuilderT_TrivialMetricToPenalty

FaceHashMap

mrmeshpy.FaceHashMap = phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

FaceMapOrHashMap

mrmeshpy.FaceMapOrHashMap = MapOrHashMap_FaceId_FaceId

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

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_Id_EdgeTag_Id_EdgeTag

mrmeshpy.HashMap_Id_EdgeTag_Id_EdgeTag = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

HashMap_TypedBitSet_Id_EdgeTag_IndexType_TypedBitSet_Id_EdgeTag_IndexType

mrmeshpy.HashMap_TypedBitSet_Id_EdgeTag_IndexType_TypedBitSet_Id_EdgeTag_IndexType = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

HashMap_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType

mrmeshpy.HashMap_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType = phmap_flat_hash_map_Id_ICPElemtTag_Id_ICPElemtTag

HashMap_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType

mrmeshpy.HashMap_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType = phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag

HistoryActionsVector

mrmeshpy.HistoryActionsVector = std_vector_std_shared_ptr_HistoryAction

ICPElementBitSet

mrmeshpy.ICPElementBitSet = TypedBitSet_Id_ICPElemtTag

ICPElementId

mrmeshpy.ICPElementId = Id_ICPElemtTag

ICPObjects

mrmeshpy.ICPObjects = Vector_MeshOrPointsXf_ObjId

ICPPairsGrid

mrmeshpy.ICPPairsGrid = Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag

Id_EdgeTag

mrmeshpy.Id_EdgeTag = EdgeId

Id_VoxelTag

mrmeshpy.Id_VoxelTag = VoxelId

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

MapOrHashMap_Id_EdgeTag_Id_EdgeTag

mrmeshpy.MapOrHashMap_Id_EdgeTag_Id_EdgeTag = MapOrHashMap_EdgeId_EdgeId

MapOrHashMap_Id_EdgeTag_Id_EdgeTag_Dense

mrmeshpy.MapOrHashMap_Id_EdgeTag_Id_EdgeTag_Dense = EdgeMap

MapOrHashMap_Id_EdgeTag_Id_EdgeTag_Hash

mrmeshpy.MapOrHashMap_Id_EdgeTag_Id_EdgeTag_Hash = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

MapOrHashMap_UndirectedEdgeId_Id_EdgeTag_Dense

mrmeshpy.MapOrHashMap_UndirectedEdgeId_Id_EdgeTag_Dense = WholeEdgeMap

MapOrHashMap_UndirectedEdgeId_Id_EdgeTag_Hash

mrmeshpy.MapOrHashMap_UndirectedEdgeId_Id_EdgeTag_Hash = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

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_VectorType

mrmeshpy.Matrix2_long_VectorType = Vector2i64

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_VectorType

mrmeshpy.Matrix3_long_VectorType = Vector3i64

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_VectorType

mrmeshpy.Matrix4_long_VectorType = Vector4i64

MeshBuilderSettings

mrmeshpy.MeshBuilderSettings = MeshBuilder.BuildSettings

MeshEdgePoint

mrmeshpy.MeshEdgePoint = EdgePoint

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

MeshToVolumeParamsType

mrmeshpy.MeshToVolumeParamsType = MeshToVolumeParams.Type

MinMax_VoxelsVolume_Vector_unsigned_short_Id_VoxelTag_ValueType

mrmeshpy.MinMax_VoxelsVolume_Vector_unsigned_short_Id_VoxelTag_ValueType = Box_unsigned_short

MinMaxd

mrmeshpy.MinMaxd = Box1d

MinMaxf

mrmeshpy.MinMaxf = Box1f

MinMaxi

mrmeshpy.MinMaxi = Box1i

MultiObjsSamples

mrmeshpy.MultiObjsSamples = std_vector_ObjVertId

NoCtor_Id_EdgeTag

mrmeshpy.NoCtor_Id_EdgeTag = NoCtor_EdgeId

NoCtor_Id_EdgeTag_type

mrmeshpy.NoCtor_Id_EdgeTag_type = NoDefInit_EdgeId

NoCtor_Id_VoxelTag

mrmeshpy.NoCtor_Id_VoxelTag = NoCtor_VoxelId

NoCtor_Id_VoxelTag_type

mrmeshpy.NoCtor_Id_VoxelTag_type = NoDefInit_VoxelId

NoDefInit_Id_EdgeTag

mrmeshpy.NoDefInit_Id_EdgeTag = NoDefInit_EdgeId

NoDefInit_Id_VoxelTag

mrmeshpy.NoDefInit_Id_VoxelTag = NoDefInit_VoxelId

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

PdfGeneralFont

mrmeshpy.PdfGeneralFont = std_variant_PdfBuildinFont_std_filesystem_path

phmap_flat_hash_map_EdgeId_EdgeId

mrmeshpy.phmap_flat_hash_map_EdgeId_EdgeId = phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

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_EdgeId

mrmeshpy.phmap_flat_hash_map_UndirectedEdgeId_EdgeId = 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_std_array_VertId_3_phmap_Hash_uint64_t

mrmeshpy.phmap_flat_hash_map_unsigned_long_std_array_VertId_3_phmap_Hash_uint64_t = phmap_flat_hash_map_unsigned_long_std_array_Id_VertTag_3ul

phmap_flat_hash_map_VertId_float

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

phmap_flat_hash_map_VoxelId_VoxelId

mrmeshpy.phmap_flat_hash_map_VoxelId_VoxelId = phmap_flat_hash_map_Id_VoxelTag_Id_VoxelTag

PickedPoint

mrmeshpy.PickedPoint = std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag

PlaneSection

mrmeshpy.PlaneSection = std_vector_EdgePoint

PlaneSections

mrmeshpy.PlaneSections = std_vector_std_vector_EdgePoint

Polynomial_double_0ul_0_0_0ulminus1

mrmeshpy.Polynomial_double_0ul_0_0_0ulminus1 = Polynomial_double_0

Polynomial_double_1ul_0_0_1ulminus1

mrmeshpy.Polynomial_double_1ul_0_0_1ulminus1 = Polynomial_double_0

Polynomial_double_2ul_0_0_2ulminus1

mrmeshpy.Polynomial_double_2ul_0_0_2ulminus1 = Polynomial_double_1

Polynomial_double_3ul_0_0_3ulminus1

mrmeshpy.Polynomial_double_3ul_0_0_3ulminus1 = Polynomial_double_2

Polynomial_double_4ul_0_0_4ulminus1

mrmeshpy.Polynomial_double_4ul_0_0_4ulminus1 = Polynomial_double_3

Polynomial_double_5ul_0_0_5ulminus1

mrmeshpy.Polynomial_double_5ul_0_0_5ulminus1 = Polynomial_double_4

Polynomial_double_6ul_0_0_6ulminus1

mrmeshpy.Polynomial_double_6ul_0_0_6ulminus1 = Polynomial_double_5

Polynomial_float_0ul_0_0_0ulminus1

mrmeshpy.Polynomial_float_0ul_0_0_0ulminus1 = Polynomial_float_0

Polynomial_float_1ul_0_0_1ulminus1

mrmeshpy.Polynomial_float_1ul_0_0_1ulminus1 = Polynomial_float_0

Polynomial_float_2ul_0_0_2ulminus1

mrmeshpy.Polynomial_float_2ul_0_0_2ulminus1 = Polynomial_float_1

Polynomial_float_3ul_0_0_3ulminus1

mrmeshpy.Polynomial_float_3ul_0_0_3ulminus1 = Polynomial_float_2

Polynomial_float_4ul_0_0_4ulminus1

mrmeshpy.Polynomial_float_4ul_0_0_4ulminus1 = Polynomial_float_3

Polynomial_float_5ul_0_0_5ulminus1

mrmeshpy.Polynomial_float_5ul_0_0_5ulminus1 = Polynomial_float_4

Polynomial_float_6ul_0_0_6ulminus1

mrmeshpy.Polynomial_float_6ul_0_0_6ulminus1 = Polynomial_float_5

PolynomialWrapperd

mrmeshpy.PolynomialWrapperd = PolynomialWrapper_double

PolynomialWrapperf

mrmeshpy.PolynomialWrapperf = PolynomialWrapper_float

Polynomialx_double

mrmeshpy.Polynomialx_double = std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul

Polynomialx_float

mrmeshpy.Polynomialx_float = std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul

PreciseCollisionResult

mrmeshpy.PreciseCollisionResult = std_vector_VarEdgeTri

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_std_array_Id_VertTag_3ul

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_CubicBezierCurve_Vector2d_T_4

mrmeshpy.std_array_CubicBezierCurve_Vector2d_T_4 = std_array_double_4

std_array_CubicBezierCurve_Vector2f_T_4

mrmeshpy.std_array_CubicBezierCurve_Vector2f_T_4 = std_array_float_4

std_array_CubicBezierCurve_Vector3d_T_4

mrmeshpy.std_array_CubicBezierCurve_Vector3d_T_4 = std_array_double_4

std_array_CubicBezierCurve_Vector3f_T_4

mrmeshpy.std_array_CubicBezierCurve_Vector3f_T_4 = std_array_float_4

std_array_SimpleVolumeMinMax_3

mrmeshpy.std_array_SimpleVolumeMinMax_3 = std_array_VoxelsVolumeMinMax_Vector_float_Id_VoxelTag_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_2

mrmeshpy.std_array_VertId_2 = std_array_Id_VertTag_2

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_Edges

mrmeshpy.std_optional_Edges = std_optional_Vector_std_array_Id_VertTag_2ul_Id_UndirectedEdgeTag

std_optional_std_variant_float_Vector3f

mrmeshpy.std_optional_std_variant_float_Vector3f = std_optional_std_variant_float_Vector3_float

std_optional_Triangulation

mrmeshpy.std_optional_Triangulation = std_optional_Vector_std_array_Id_VertTag_3ul_Id_FaceTag

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_const_Mesh

mrmeshpy.std_shared_ptr_const_Mesh = Mesh

std_shared_ptr_const_PointCloud

mrmeshpy.std_shared_ptr_const_PointCloud = PointCloud

std_shared_ptr_const_Polyline3

mrmeshpy.std_shared_ptr_const_Polyline3 = Polyline3

std_shared_ptr_DistanceMap

mrmeshpy.std_shared_ptr_DistanceMap = DistanceMap

std_shared_ptr_GcodeSource

mrmeshpy.std_shared_ptr_GcodeSource = std_vector_std_string

std_shared_ptr_Mesh

mrmeshpy.std_shared_ptr_Mesh = Mesh

std_shared_ptr_Object

mrmeshpy.std_shared_ptr_Object = Object

std_shared_ptr_ObjectLines

mrmeshpy.std_shared_ptr_ObjectLines = ObjectLines

std_shared_ptr_ObjectLinesHolder

mrmeshpy.std_shared_ptr_ObjectLinesHolder = ObjectLinesHolder

std_shared_ptr_ObjectMesh

mrmeshpy.std_shared_ptr_ObjectMesh = ObjectMesh

std_shared_ptr_ObjectMeshHolder

mrmeshpy.std_shared_ptr_ObjectMeshHolder = ObjectMeshHolder

std_shared_ptr_ObjectPoints

mrmeshpy.std_shared_ptr_ObjectPoints = ObjectPoints

std_shared_ptr_ObjectVoxels

mrmeshpy.std_shared_ptr_ObjectVoxels = ObjectVoxels

std_shared_ptr_PointCloud

mrmeshpy.std_shared_ptr_PointCloud = PointCloud

std_shared_ptr_Polyline3

mrmeshpy.std_shared_ptr_Polyline3 = Polyline3

std_shared_ptr_std_vector_std_string

mrmeshpy.std_shared_ptr_std_vector_std_string = std_vector_std_string

std_shared_ptr_VisualObject

mrmeshpy.std_shared_ptr_VisualObject = VisualObject

std_unique_ptr_NoDefInit_Id_EdgeTag_pointer

mrmeshpy.std_unique_ptr_NoDefInit_Id_EdgeTag_pointer = NoDefInit_EdgeId

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_VoxelId

std_variant_EdgeMap_phmap_flat_hash_map_EdgeId_EdgeId

mrmeshpy.std_variant_EdgeMap_phmap_flat_hash_map_EdgeId_EdgeId = std_variant_Vector_Id_EdgeTag_Id_EdgeTag_phmap_flat_hash_map_Id_EdgeTag_Id_EdgeTag

std_variant_FaceId_EdgeId_VertId

mrmeshpy.std_variant_FaceId_EdgeId_VertId = std_variant_Id_FaceTag_Id_EdgeTag_Id_VertTag

std_variant_FaceMap_phmap_flat_hash_map_FaceId_FaceId

mrmeshpy.std_variant_FaceMap_phmap_flat_hash_map_FaceId_FaceId = std_variant_Vector_Id_FaceTag_Id_FaceTag_phmap_flat_hash_map_Id_FaceTag_Id_FaceTag

std_variant_float_Vector3f

mrmeshpy.std_variant_float_Vector3f = std_variant_float_Vector3_float

std_variant_Polynomial_double_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6

mrmeshpy.std_variant_Polynomial_double_0_Polynomial_double_1_Polynomial_double_2_Polynomial_double_3_Polynomial_double_4_Polynomial_double_5_Polynomial_double_6 = std_variant_Polynomial_double_0ul_Polynomial_double_1ul_Polynomial_double_2ul_Polynomial_double_3ul_Polynomial_double_4ul_Polynomial_double_5ul_Polynomial_double_6ul

std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6

mrmeshpy.std_variant_Polynomial_float_0_Polynomial_float_1_Polynomial_float_2_Polynomial_float_3_Polynomial_float_4_Polynomial_float_5_Polynomial_float_6 = std_variant_Polynomial_float_0ul_Polynomial_float_1ul_Polynomial_float_2ul_Polynomial_float_3ul_Polynomial_float_4ul_Polynomial_float_5ul_Polynomial_float_6ul

std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane

mrmeshpy.std_variant_Sphere3f_Features_Primitives_ConeSegment_Features_Primitives_Plane = std_variant_Sphere_Vector3_float_Features_Primitives_ConeSegment_Features_Primitives_Plane

std_variant_std_monostate_MeshTriPoint_EdgePoint_VertId

mrmeshpy.std_variant_std_monostate_MeshTriPoint_EdgePoint_VertId = std_variant_std_monostate_MeshTriPoint_EdgePoint_Id_VertTag

std_variant_std_reference_wrapper_const_FillingSurface_TPMS_MeshParams_std_reference_wrapper_const_FillingSurface_CellularSurface_Params

mrmeshpy.std_variant_std_reference_wrapper_const_FillingSurface_TPMS_MeshParams_std_reference_wrapper_const_FillingSurface_CellularSurface_Params = std_variant_std_reference_wrapper_FillingSurface_TPMS_MeshParams_const_std_reference_wrapper_FillingSurface_CellularSurface_Params_const

std_variant_UndirectedEdgeMap_phmap_flat_hash_map_UndirectedEdgeId_UndirectedEdgeId

mrmeshpy.std_variant_UndirectedEdgeMap_phmap_flat_hash_map_UndirectedEdgeId_UndirectedEdgeId = std_variant_Vector_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag_phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

std_variant_VertMap_phmap_flat_hash_map_VertId_VertId

mrmeshpy.std_variant_VertMap_phmap_flat_hash_map_VertId_VertId = std_variant_Vector_Id_VertTag_Id_VertTag_phmap_flat_hash_map_Id_VertTag_Id_VertTag

std_variant_WholeEdgeMap_phmap_flat_hash_map_UndirectedEdgeId_EdgeId

mrmeshpy.std_variant_WholeEdgeMap_phmap_flat_hash_map_UndirectedEdgeId_EdgeId = std_variant_Vector_Id_EdgeTag_Id_UndirectedEdgeTag_phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

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_VarEdgeTri

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_TypedBitSet_Id_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_TypedBitSet_Id_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 = EdgeId

std_vector_Id_EdgeTag_reference

mrmeshpy.std_vector_Id_EdgeTag_reference = EdgeId

std_vector_Id_EdgeTag_value_type

mrmeshpy.std_vector_Id_EdgeTag_value_type = EdgeId

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 = VoxelId

std_vector_Id_VoxelTag_reference

mrmeshpy.std_vector_Id_VoxelTag_reference = VoxelId

std_vector_Id_VoxelTag_value_type

mrmeshpy.std_vector_Id_VoxelTag_value_type = VoxelId

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

std_vector_std_array_std_filesystem_path_4

mrmeshpy.std_vector_std_array_std_filesystem_path_4 = std_vector_std_array_std_filesystem_path_4ul

std_vector_std_array_Vector3f_3

mrmeshpy.std_vector_std_array_Vector3f_3 = std_vector_std_array_Vector3_float_3ul

std_vector_std_array_VertId_2

mrmeshpy.std_vector_std_array_VertId_2 = std_vector_std_array_Id_VertTag_2ul

std_vector_std_array_VertId_3

mrmeshpy.std_vector_std_array_VertId_3 = std_vector_std_array_Id_VertTag_3ul

std_vector_std_pair_EdgeId_EdgeId

mrmeshpy.std_vector_std_pair_EdgeId_EdgeId = std_vector_std_pair_Id_EdgeTag_Id_EdgeTag

std_vector_std_pair_size_t_size_t

mrmeshpy.std_vector_std_pair_size_t_size_t = std_vector_std_pair_unsigned_long_unsigned_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_EdgeId

mrmeshpy.std_vector_std_vector_EdgeId = std_vector_std_vector_Id_EdgeTag

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_4ul

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_Vector_float_Id_VoxelTag_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_FloatGrid_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_TypedBitSet_Id_UndirectedEdgeTag

std_vector_UndirectedEdgeId

mrmeshpy.std_vector_UndirectedEdgeId = std_vector_Id_UndirectedEdgeTag

std_vector_VdbVolume

mrmeshpy.std_vector_VdbVolume = std_vector_VoxelsVolumeMinMax_FloatGrid

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_TypedBitSet_Id_VertTag

std_vector_VertId

mrmeshpy.std_vector_VertId = std_vector_Id_VertTag

std_vector_VoxelBitSet

mrmeshpy.std_vector_VoxelBitSet = std_vector_TypedBitSet_Id_VoxelTag

std_vector_VoxelId

mrmeshpy.std_vector_VoxelId = std_vector_Id_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_ICPElemtTag

mrmeshpy.TaggedBitSet_ICPElemtTag = TypedBitSet_Id_ICPElemtTag

TextAlignParams

mrmeshpy.TextAlignParams = TextMeshAlignParams

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_Vector_float_Id_VoxelTag_std_string

tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string

mrmeshpy.tl_expected_VoxelsLoad_DicomVolumeAsVdb_std_string = expected_VoxelsLoad_DicomVolumeT_VoxelsVolumeMinMax_FloatGrid_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

TwoVertIds

mrmeshpy.TwoVertIds = std_array_Id_VertTag_2

TypedBitSet_FaceId_base

mrmeshpy.TypedBitSet_FaceId_base = BitSet

TypedBitSet_FaceId_IndexType

mrmeshpy.TypedBitSet_FaceId_IndexType = FaceId

TypedBitSet_GraphEdgeId_base

mrmeshpy.TypedBitSet_GraphEdgeId_base = BitSet

TypedBitSet_GraphEdgeId_IndexType

mrmeshpy.TypedBitSet_GraphEdgeId_IndexType = GraphEdgeId

TypedBitSet_GraphVertId_base

mrmeshpy.TypedBitSet_GraphVertId_base = BitSet

TypedBitSet_GraphVertId_IndexType

mrmeshpy.TypedBitSet_GraphVertId_IndexType = GraphVertId

TypedBitSet_Id_EdgeTag_base

mrmeshpy.TypedBitSet_Id_EdgeTag_base = BitSet

TypedBitSet_Id_EdgeTag_IndexType

mrmeshpy.TypedBitSet_Id_EdgeTag_IndexType = EdgeId

TypedBitSet_Id_VoxelTag_base

mrmeshpy.TypedBitSet_Id_VoxelTag_base = BitSet

TypedBitSet_Id_VoxelTag_IndexType

mrmeshpy.TypedBitSet_Id_VoxelTag_IndexType = VoxelId

TypedBitSet_NodeId_base

mrmeshpy.TypedBitSet_NodeId_base = BitSet

TypedBitSet_NodeId_IndexType

mrmeshpy.TypedBitSet_NodeId_IndexType = NodeId

TypedBitSet_ObjId_base

mrmeshpy.TypedBitSet_ObjId_base = BitSet

TypedBitSet_ObjId_IndexType

mrmeshpy.TypedBitSet_ObjId_IndexType = ObjId

TypedBitSet_PixelId_base

mrmeshpy.TypedBitSet_PixelId_base = BitSet

TypedBitSet_PixelId_IndexType

mrmeshpy.TypedBitSet_PixelId_IndexType = PixelId

TypedBitSet_RegionId_base

mrmeshpy.TypedBitSet_RegionId_base = BitSet

TypedBitSet_RegionId_IndexType

mrmeshpy.TypedBitSet_RegionId_IndexType = RegionId

TypedBitSet_TextureId_base

mrmeshpy.TypedBitSet_TextureId_base = BitSet

TypedBitSet_TextureId_IndexType

mrmeshpy.TypedBitSet_TextureId_IndexType = TextureId

TypedBitSet_UndirectedEdgeId_base

mrmeshpy.TypedBitSet_UndirectedEdgeId_base = BitSet

TypedBitSet_UndirectedEdgeId_IndexType

mrmeshpy.TypedBitSet_UndirectedEdgeId_IndexType = UndirectedEdgeId

TypedBitSet_VertId_base

mrmeshpy.TypedBitSet_VertId_base = BitSet

TypedBitSet_VertId_IndexType

mrmeshpy.TypedBitSet_VertId_IndexType = VertId

UndirectedEdgeHashMap

mrmeshpy.UndirectedEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_UndirectedEdgeTag

UndirectedEdgeMapOrHashMap

mrmeshpy.UndirectedEdgeMapOrHashMap = MapOrHashMap_UndirectedEdgeId_UndirectedEdgeId

UVCoord

mrmeshpy.UVCoord = Vector2f

VdbVolumes

mrmeshpy.VdbVolumes = std_vector_VoxelsVolumeMinMax_FloatGrid

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_MatrixType

mrmeshpy.Vector2_long_MatrixType = Matrix2i64

Vector2_long_SymMatrixType

mrmeshpy.Vector2_long_SymMatrixType = SymMatrix2i64

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_MatrixType

mrmeshpy.Vector3_long_MatrixType = Matrix3i64

Vector3_long_SymMatrixType

mrmeshpy.Vector3_long_SymMatrixType = SymMatrix3i64

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_MatrixType

mrmeshpy.Vector4_long_MatrixType = Matrix4i64

Vector4_long_SymMatrixType

mrmeshpy.Vector4_long_SymMatrixType = SymMatrix4i64

Vector4_uint8_t

mrmeshpy.Vector4_uint8_t = Vector4_unsigned_char

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_float_Id_VoxelTag

mrmeshpy.Vector_float_Id_VoxelTag = Vector_float_VoxelId

Vector_ICPPairsGrid_ICPLayer

mrmeshpy.Vector_ICPPairsGrid_ICPLayer = Vector_Vector_Vector_ICPGroupPairs_Id_ICPElemtTag_Id_ICPElemtTag_int

Vector_Id_EdgeTag_FaceId_const_reference

mrmeshpy.Vector_Id_EdgeTag_FaceId_const_reference = EdgeId

Vector_Id_EdgeTag_FaceId_reference

mrmeshpy.Vector_Id_EdgeTag_FaceId_reference = EdgeId

Vector_Id_EdgeTag_FaceId_value_type

mrmeshpy.Vector_Id_EdgeTag_FaceId_value_type = EdgeId

Vector_Id_EdgeTag_Id_EdgeTag_const_reference

mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_const_reference = EdgeId

Vector_Id_EdgeTag_Id_EdgeTag_reference

mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_reference = EdgeId

Vector_Id_EdgeTag_Id_EdgeTag_value_type

mrmeshpy.Vector_Id_EdgeTag_Id_EdgeTag_value_type = EdgeId

Vector_Id_EdgeTag_UndirectedEdgeId_const_reference

mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_const_reference = EdgeId

Vector_Id_EdgeTag_UndirectedEdgeId_reference

mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_reference = EdgeId

Vector_Id_EdgeTag_UndirectedEdgeId_value_type

mrmeshpy.Vector_Id_EdgeTag_UndirectedEdgeId_value_type = EdgeId

Vector_Id_EdgeTag_VertId_const_reference

mrmeshpy.Vector_Id_EdgeTag_VertId_const_reference = EdgeId

Vector_Id_EdgeTag_VertId_reference

mrmeshpy.Vector_Id_EdgeTag_VertId_reference = EdgeId

Vector_Id_EdgeTag_VertId_value_type

mrmeshpy.Vector_Id_EdgeTag_VertId_value_type = EdgeId

Vector_Id_VoxelTag_FaceId_const_reference

mrmeshpy.Vector_Id_VoxelTag_FaceId_const_reference = VoxelId

Vector_Id_VoxelTag_FaceId_reference

mrmeshpy.Vector_Id_VoxelTag_FaceId_reference = VoxelId

Vector_Id_VoxelTag_FaceId_value_type

mrmeshpy.Vector_Id_VoxelTag_FaceId_value_type = VoxelId

Vector_Id_VoxelTag_Id_VoxelTag

mrmeshpy.Vector_Id_VoxelTag_Id_VoxelTag = Vector_VoxelId_VoxelId

Vector_Id_VoxelTag_Id_VoxelTag_const_reference

mrmeshpy.Vector_Id_VoxelTag_Id_VoxelTag_const_reference = VoxelId

Vector_Id_VoxelTag_Id_VoxelTag_reference

mrmeshpy.Vector_Id_VoxelTag_Id_VoxelTag_reference = VoxelId

Vector_Id_VoxelTag_Id_VoxelTag_value_type

mrmeshpy.Vector_Id_VoxelTag_Id_VoxelTag_value_type = VoxelId

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_2_UndirectedEdgeId_const_reference

mrmeshpy.Vector_std_array_VertId_2_UndirectedEdgeId_const_reference = std_array_Id_VertTag_2

Vector_std_array_VertId_2_UndirectedEdgeId_reference

mrmeshpy.Vector_std_array_VertId_2_UndirectedEdgeId_reference = std_array_Id_VertTag_2

Vector_std_array_VertId_2_UndirectedEdgeId_value_type

mrmeshpy.Vector_std_array_VertId_2_UndirectedEdgeId_value_type = std_array_Id_VertTag_2

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_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_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType

mrmeshpy.Vector_TypedBitSet_Id_ICPElemtTag_IndexType_TypedBitSet_Id_ICPElemtTag_IndexType = Vector_Id_ICPElemtTag_Id_ICPElemtTag

Vector_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType

mrmeshpy.Vector_TypedBitSet_Id_VoxelTag_IndexType_TypedBitSet_Id_VoxelTag_IndexType = Vector_VoxelId_VoxelId

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_unsigned_short_Id_VoxelTag

mrmeshpy.Vector_unsigned_short_Id_VoxelTag = Vector_unsigned_short_VoxelId

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_Id_EdgeTag_const_reference

mrmeshpy.Vector_VertId_Id_EdgeTag_const_reference = VertId

Vector_VertId_Id_EdgeTag_reference

mrmeshpy.Vector_VertId_Id_EdgeTag_reference = VertId

Vector_VertId_Id_EdgeTag_value_type

mrmeshpy.Vector_VertId_Id_EdgeTag_value_type = VertId

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

VertMapOrHashMap

mrmeshpy.VertMapOrHashMap = MapOrHashMap_VertId_VertId

VertNormals

mrmeshpy.VertNormals = VertCoords

VertPathInfoMap

mrmeshpy.VertPathInfoMap = phmap_flat_hash_map_Id_VertTag_VertPathInfo

VertUVCoords

mrmeshpy.VertUVCoords = VertCoords2

ViewportProperty_uint8_t

mrmeshpy.ViewportProperty_uint8_t = ViewportProperty_unsigned_char

VoxelsSaveSavingSettings

mrmeshpy.VoxelsSaveSavingSettings = VoxelsSave.SavingSettings

VoxelTraits_Vector_float_Id_VoxelTag

mrmeshpy.VoxelTraits_Vector_float_Id_VoxelTag = VoxelTraits_Vector_float_VoxelId

VoxelTraits_Vector_unsigned_short_Id_VoxelTag

mrmeshpy.VoxelTraits_Vector_unsigned_short_Id_VoxelTag = VoxelTraits_Vector_unsigned_short_VoxelId

WholeEdgeHashMap

mrmeshpy.WholeEdgeHashMap = phmap_flat_hash_map_Id_UndirectedEdgeTag_Id_EdgeTag

WholeEdgeMapOrHashMap

mrmeshpy.WholeEdgeMapOrHashMap = MapOrHashMap_UndirectedEdgeId_EdgeId