Namespaces
namespace	AsyncObjectLoad

namespace	BitSetParallel

namespace	Cuda

namespace	detail

namespace	DistanceMapLoad

namespace	DistanceMapSave

namespace	Features

namespace	FixUndercuts

namespace	FloatGridComponents

namespace	GcodeLoad

namespace	ImageLoad

namespace	ImageSave

namespace	ImGuiMath

namespace	ImGuiMeasurementIndicators

namespace	LinesLoad

namespace	LinesSave

namespace	MeshBuilder
	Building topologies by triangles.

namespace	MeshComponents

namespace	MeshLoad

namespace	MeshSave

namespace	Meta

namespace	ObjectLoad

namespace	ObjectSave

namespace	Parallel

namespace	PlanarTriangulation

namespace	PointCloudComponents

namespace	PointsLoad

namespace	PointsSave

namespace	PolylineComponents

namespace	RenderDimensions

namespace	RenderFeatures

namespace	RenderWrapObject

namespace	SceneLoad

namespace	SelfIntersections

namespace	StyleConsts

namespace	TriangulationHelpers

namespace	UI

namespace	VoxelsLoad

namespace	VoxelsSave

Classes
class	AABBTree

class	AABBTreeBase
	base class for most AABB-trees (except for AABBTreePoints) More...

struct	AABBTreeNode

class	AABBTreeObjects

class	AABBTreePoints
	bounding volume hierarchy for point cloud structure More...

class	AABBTreePolyline
	bounding volume hierarchy for line segments More...

struct	AABBTreeTraits

class	AddCustomThemePlugin

class	AddPointActionPickerPoint

class	AddVisualProperties

struct	AffineXf

struct	AllLocalTriangulations
	triangulations for all points, with easy access by VertId More...

class	AlphaSortGL

class	AncillaryImGuiLabel
	Helper class that draws ImGui label. More...

struct	AncillaryLabel
	Helper class to manage ancillary labels used by plugins. More...

struct	AncillaryLines
	Helper class to manage ancillary visual lines used by plugins. More...

struct	AncillaryMesh
	Helper class to manage ancillary visual mesh used by plugins. More...

struct	AncillaryPoints
	Helper class to manage ancillary visual points used by plugins. More...

class	AngleMeasurementObject

class	AnyVisualizeMaskEnum

struct	ArcInterpolationParams

class	AsyncRequest

class	AsyncTimer

struct	Ball

struct	BaseFitParams

struct	BaseRenderParams
	Common rendering parameters for meshes and UI. More...

struct	BaseShellParameters

struct	BaseTiffParameters

struct	BasicUiRenderTask
	`IRenderObject::renderUi()` can emit zero or more or more of those tasks. They are sorted by depth every frame. More...

class	BasinVolumeCalculator

class	BestFitParabola
	accumulates a number of (x,y) points to find the best-least-squares parabola approximating them More...

class	BestFitPolynomial

struct	BindVertexAttribArraySettings

class	BitSet
	container of bits More...

struct	BMap
	flat map: I -> T More...

struct	BooleanInternalParameters
	Parameters will be useful if specified. More...

struct	BooleanParameters

struct	BooleanPreCutResult

struct	BooleanResult
	Structure contain boolean result. More...

struct	BooleanResultMapper
	Structure to map old mesh BitSets to new. More...

struct	BooleanResultPoints
	vertices and points representing mesh intersection result More...

class	BoundarySelectionWidget

struct	Box
	Box given by its min- and max- corners. More...

struct	BoxedLeaf

class	Buffer
	std::vector<V>-like container that is 1) resized without initialization of its elements, 2) much simplified: no push_back and many other methods More...

class	CameraOrientation

class	CaptureScreenshotMenuItem

class	CaptureScreenshotToClipBoardMenuItem

class	CaptureUIScreenshotMenuItem

class	ChangeActiveBoxAction

class	ChangeBoundarySelectionHistoryAction

class	ChangeColoringType

class	ChangeDualMarchingCubesAction
	Undo action for ObjectVoxels dual/standard marching cubes change. More...

class	ChangeFacesColorMapAction

class	ChangeGridAction

class	ChangeIsoAction
	Undo action for ObjectVoxels iso-value change. More...

class	ChangeLabelAction

class	ChangeLinesColorMapAction

class	ChangeMeshAction
	Undo action for ObjectMesh mesh change. More...

class	ChangeMeshCreasesAction
	Undo action for ObjectMesh creases. More...

class	ChangeMeshEdgeSelectionAction
	Undo action for ObjectMesh edge selection. More...

class	ChangeMeshFaceSelectionAction
	Undo action for ObjectMesh face selection. More...

class	ChangeMeshPointsAction
	Undo action for ObjectMesh points only (not topology) change. More...

class	ChangeMeshTexturePerFaceAction
	Undo action for ObjectMeshHolder texturePerFace change. More...

class	ChangeMeshTopologyAction
	Undo action for ObjectMesh topology only (not points) change. More...

class	ChangeMeshUVCoordsAction
	Undo action for ObjectMeshHolder uvCoords change. More...

class	ChangeNameAction

class	ChangeObjectAction

class	ChangeObjectColorAction

class	ChangeObjectSelectedAction

class	ChangeObjectVisibilityAction

class	ChangePointActionPickerPoint

class	ChangePointCloudAction

class	ChangePointCloudNormalsAction

class	ChangePointCloudPointsAction

class	ChangePointPointSelectionAction
	Undo action for ObjectPoints point selection. More...

class	ChangePolylineAction
	Undo action for ObjectLines polyline change. More...

class	ChangePolylinePointsAction
	Undo action for ObjectLines points only (not topology) change. More...

class	ChangePolylineTopologyAction
	Undo action for ObjectLines topology only (not points) change. More...

class	ChangeSceneAction

class	ChangeSceneObjectsOrder

class	ChangeSurfaceAction

class	ChangeTextureAction

class	ChangeValue

class	ChangeVertsColorMapAction

class	ChangeVisualizePropertyAction

class	ChangeXfAction

class	ChangVoxelSelectionAction
	Undo action for ObjectVoxels face selection. More...

struct	CharPressedListener

class	CircleObject

struct	CloudPartMapping

class	CNCMachineSettings
	class with CNC machine emulation settings More...

struct	Color

class	ColorMapAggregator
	Class for aggregate several color map in one Color maps are aggregated according order. More...

class	ColorTheme

class	CombinedHistoryAction

class	CommandLoop

struct	ComputeSteepestDescentPathSettings

class	Cone3

class	Cone3Approximation

struct	Cone3ApproximationParams

struct	ConeFittingFunctor

class	ConeObject

class	Config

struct	ConnectionHolder

struct	ConstantCuspParams

struct	ContoursDistanceMapOffset
	Structure with parameters for optional offset in `distanceMapFromContours` function. More...

struct	ContoursDistanceMapOptions

struct	ContourToDistanceMapParams
	Structure with parameters to generate DistanceMap by Contours. More...

struct	CoordinateConverters
	this struct contains coordinate converters float-int-float More...

struct	CoordinateConverters2
	this struct contains coordinate converters float-int-float More...

class	CudaAccessor
	The purpose of this class is to access CUDA algorithms without explicit dependency on MRCuda. More...

struct	CursorEntranceListener
	class to subscribe on CursorEntranceSingal More...

struct	CustomButtonParameters

struct	CutMeshParameters
	Parameters of MR::cutMesh. More...

struct	CutMeshResult

class	Cylinder3

class	Cylinder3Approximation

class	CylinderObject

struct	DecimateParallelSettings
	Parameters structure for MR::decimateParallelMesh. More...

struct	DecimatePolylineResult
	Results of MR::decimateContour. More...

struct	DecimatePolylineSettings
	Parameters structure for MR::decimatePolyline. More...

struct	DecimateResult
	Results of MR::decimateMesh. More...

struct	DecimateSettings
	Parameters structure for MR::decimateMesh. More...

class	DefaultSplashWindow

struct	DeloneSettings

class	DemoPlugin

struct	DenoiseViaNormalsSettings

struct	DenseBox

class	DentalId
	This class represents tooth id. More...

struct	DetectTunnelSettings

struct	Dipole

class	DirectionWidget
	Widget for visualizing the direction. More...

struct	Directory

struct	DirectoryIterator
	iterator of directory items that will save any errors in (ec) instead of throwing exceptions More...

struct	DirectoryRecursive

struct	DirectoryRecursiveIterator
	recursive iterator of directory items that will save any errors in (ec) instead of throwing exceptions More...

struct	Dirty

class	DistanceMap

struct	DistanceMapToWorld
	This structure store data to transform distance map to world coordinates. More...

class	DistanceMeasurementObject

struct	DistanceToMeshOptions

struct	DistanceVolumeParams

struct	DividePointCloudOptionalOutput

struct	DividePolylineParameters

struct	DoubleOffsetSettings

struct	DragDropListener

struct	DragEndListener

struct	DragListener

struct	DragStartListener

struct	DrawButtonParams

struct	DrawListener

struct	DrawSceneUiListener

class	EdgePathsAStarBuilder

class	EdgePathsBuilderT
	the class is responsible for finding smallest metric edge paths on a mesh More...

struct	EdgePoint
	encodes a point on an edge of mesh or of polyline More...

struct	EdgePointPair
	two edge-points (e.g. representing collision point of two edges) More...

struct	EdgeSegment
	Represents a segment on one edge. More...

struct	EdgeTri
	edge from one mesh and triangle from another mesh More...

class	EmbeddedPython

struct	EmbeddedStructureParameters

class	EnumNeihbourFaces

class	EnumNeihbourVertices

struct	FaceDistancesSettings

struct	FaceFace

struct	FanRecord
	describes one fan of triangles around a point excluding the point More...

struct	FanRecordWithCenter
	describes one fan of triangles around a point including the point More...

class	FastWindingNumber

class	FeatureObject
	An interface class which allows feature objects to share setters and getters on their main properties, for convenient presentation in the UI. More...

struct	FeatureObjectProjectPointResult

struct	FeatureObjectSharedProperty

class	FewSmallest
	the class stores some number of smallest elements from a larger number of candidates More...

class	File
	the class to open C FILE handle and automatically close it in the destructor More...

struct	FileParameters

struct	FillHoleItem

struct	FillHoleMetric
	Holds metrics for fillHole and buildCylinderBetweenTwoHoles triangulation . More...

struct	FillHoleNicelySettings

struct	FillHoleParams
	Parameters structure for MR::fillHole Structure has some options to control MR::fillHole. More...

struct	FindInnerShellSettings

struct	FindOverhangsSettings
	parameters for MR::findOverhangs More...

struct	FindOverlappingSettings

struct	FitBoxParams

class	FitDataMenuItem

struct	FitDataParams

class	FitSelectedObjectsMenuItem

class	FitSelectedPrimitivesMenuItem

class	FlowAggregator
	this class can track multiple flows and find in each mesh vertex the amount of water reached it More...

struct	FlowOrigin

class	FramebufferData

class	FrameCounter

class	FrameRedrawRequest
	class for requesting frame redraw in some time More...

class	FreeFormBestFit

class	FreeFormDeformer

class	GcodeProcessor

class	GcodeToolsLibrary

struct	GCommand

struct	GeneralOffsetParameters
	allows the user to select in the parameters which offset algorithm to call More...

class	GlBuffer

class	GLStaticHolder

class	GlTexture

class	GlTexture2

class	GlTexture2DArray

class	GlTexture3

class	Graph
	mathematical graph consisting from vertices and undirected edges More...

struct	GridSettings
	settings defining regular grid, where each quadrangular cell is split on two triangles in one of two ways More...

struct	GridToMeshSettings
	parameters of OpenVDB Grid to Mesh conversion using Dual Marching Cubes algorithm More...

class	HashToVectorMappingConverter

class	Heap
	stores map from element id in[0, size) to T; More...

class	Histogram

class	Historian

class	HistoryAction

class	HistoryStore
	This class stores history stack for undo/redo. More...

struct	HoleEdgePoint

struct	HoleFillPlan
	concise representation of proposed hole triangulation More...

struct	IConnectable

class	ICP

struct	ICPGroupPair

struct	ICPGroupPairs

struct	ICPPairData

struct	ICPProperties

class	Id

class	Id< MR::EdgeTag >

class	Id< VoxelTag >

struct	IdRange
	range of indices [beg, end) More...

class	IFastWindingNumber
	Abstract class for fast approximate computation of generalized winding number for a mesh (using its AABB tree) More...

class	IICPTreeIndexer
	structure to find leafs and groups of each in cascade mode More...

struct	Image

class	ImGuiImage

class	ImGuiMenu

struct	ImproveSamplingSettings

struct	InflateSettings

struct	InSphere
	found maximal inscribed sphere touching input point with center along given direction More...

struct	InSphereSearchSettings
	controls the finding of maximal inscribed sphere in mesh More...

struct	InterruptCloseListener

struct	IntersectionPrecomputes

struct	IntersectionPrecomputes2

class	InTreePathBuilder

struct	IOFilter

class	IPluginUpdate

struct	IPointPairs
	Simple interface for pairs holder. More...

class	IPointsToMeshProjector
	Abstract class, computes the closest point on mesh to each of given points. Pure virtual functions must be implemented. More...

class	IRenderObject

class	ISceneSelectionChange

class	ISceneStateCheck

struct	IsVisualizeMaskEnum

struct	IsVisualizeMaskEnum< DimensionsVisualizePropertyType >

struct	IsVisualizeMaskEnum< FeatureVisualizePropertyType >

struct	IsVisualizeMaskEnum< LabelVisualizePropertyType >

struct	IsVisualizeMaskEnum< LinesVisualizePropertyType >

struct	IsVisualizeMaskEnum< MeshVisualizePropertyType >

struct	IsVisualizeMaskEnum< PointsVisualizePropertyType >

struct	IsVisualizeMaskEnum< VisualizeMaskType >

struct	IteratorRange

class	ITransformControls

class	IViewerSettingsManager

struct	KeyDownListener

struct	KeyRepeatListener

struct	KeyUpListener

class	LambdaRibbonItem

class	Laplacian

struct	LaunchParams

struct	Line

struct	Line3Mesh

struct	LineInterpolationParams

class	LineObject

struct	LineSegm

class	Logger
	Make default spd logger. More...

class	LoggingStreambuf
	A custom streambuf that outputs things directly to the default `spdlog` logger. More...

struct	MakeDegenerateBandAroundRegionParams

struct	MakeSignedByWindingNumberSettings

struct	MarchingCubesParams

class	MarkedVoxelSlice
	ImGui visualization of a slice from voxel object and seed marks on it. More...

struct	Matrix

struct	Matrix2

struct	Matrix3

struct	Matrix4

class	MeasurementObject

class	Menu

struct	MenuItemCaptionSize

struct	MenuItemInfo

struct	MergeVolumePartSettings
	Parameters' structure for MR::mergeVolumePart. More...

struct	Mesh

struct	MeshApproxRelaxParams

struct	MeshAttributesToUpdate

class	MeshDiff

struct	MeshDistanceResult

struct	MeshEqualizeTriAreasParams

struct	MeshIntersectionResult

struct	MeshLoadInfo
	information about loading process and mesh construction from primitives More...

struct	MeshLoadSettings
	setting for mesh loading from external format, and locations of optional output data More...

struct	MeshMeshConverter

class	MeshModifier

struct	MeshNormals

class	MeshOnVoxelsT

class	MeshOrPoints

struct	MeshOrPointsXf
	an object and its transformation to global space with other objects More...

struct	MeshPart

struct	MeshPoint
	describes the point of measurement on mesh More...

struct	MeshProjectionResult

struct	MeshRelaxParams

struct	MeshSignedDistanceResult

struct	MeshTexture

struct	MeshToDirectionVolumeParams

struct	MeshToDistanceMapParams

struct	MeshToDistanceVolumeParams

class	MeshTopology

struct	MeshToVolumeParams

struct	MeshTriPoint

struct	MeshVoxelsConverter

struct	MetricToAStarPenalty

struct	ModelBaseRenderParams

struct	ModelPointsData
	structure to contain pointers to model data More...

struct	ModelRenderParams
	Mesh rendering parameters for primary rendering (as opposed to the picker). More...

struct	MouseClickListener

class	MouseController

struct	MouseDownListener

struct	MouseMoveListener

struct	MouseScrollListener

struct	MouseUpListener

struct	MovementBuildBodyParams

struct	MoveMeshToVoxelMaxDerivSettings

class	MoveObjectByMouse

class	MoveObjectByMouseImpl

struct	MultiListener

struct	MultiMeshIntersectionResult

class	MultiwayAligningTransform

class	MultiwayICP

struct	MultiwayICPSamplingParameters
	Parameters that are used for sampling of the MultiwayICP objects. More...

struct	MutexOwner

struct	NameTagClickListener

class	NextEdgeSameLeft

class	NextEdgeSameOrigin

struct	NoCtor

struct	NoCtor< T >

struct	NoDefInit

struct	NoInit

struct	NoiseSettings

struct	NoModelCheck

class	NormalsToPoints

struct	NoVisualRepresentationCheck

struct	NumSum

class	Object
	named object in the data model More...

class	ObjectChildrenHolder

class	ObjectDistanceMap

class	ObjectFactory

class	ObjectFactoryBase

class	ObjectGcode

class	ObjectImGuiLabel

class	ObjectLabel

class	ObjectLines

class	ObjectLinesHolder

class	ObjectMesh

class	ObjectMeshHolder

class	ObjectPoints

class	ObjectPointsHolder

class	ObjectTransformWidget

class	ObjectVoxels

struct	ObjKindTraits
	Various information about different types of objects. More...

struct	ObjKindTraits< FeaturesObjectKind::Circle >

struct	ObjKindTraits< FeaturesObjectKind::Cone >

struct	ObjKindTraits< FeaturesObjectKind::Cylinder >

struct	ObjKindTraits< FeaturesObjectKind::Line >

struct	ObjKindTraits< FeaturesObjectKind::Plane >

struct	ObjKindTraits< FeaturesObjectKind::Point >

struct	ObjKindTraits< FeaturesObjectKind::Sphere >

struct	ObjTreeTraits

struct	ObjVertId

struct	OffsetContourIndex

struct	OffsetContoursOrigins

struct	OffsetContoursParams

struct	OffsetContoursRestoreZParams
	Parameters of restoring Z coordinate of XY offset 3d contours. More...

struct	OffsetParameters

struct	OneMeshContour

struct	OneMeshIntersection

class	OpenDICOMsMenuItem

class	OpenDirectoryMenuItem

class	OpenFilesMenuItem

class	OpenRawVoxelsPlugin

struct	OpenVdbFloatGrid
	this class just hides very complex type of typedef openvdb::FloatGrid More...

struct	OutputFlows

struct	overloaded

struct	PackMapping

class	Palette
	Class to hold one dimension texture with value to UV mapping. More...

class	PalettePresets
	Class to save and load user palette presets. More...

struct	Parabola
	Represents quadratic function f(x) = axx + b*x + c. More...

struct	PartMapping

class	Pdf

struct	PdfParameters
	Parameters of document style. More...

struct	Plane3

class	PlaneAccumulator
	Class to accumulate planes to find then their crossing point. More...

class	PlaneObject

class	PlaneWidget

class	PluginCloseOnChangeMesh

class	PluginCloseOnChangePointCloud

class	PluginCloseOnEscPressed

class	PluginCloseOnSelectedObjectRemove

class	PluginUpdateOnChangeMeshPart

class	PluginUpdateOr

class	PointAccumulator
	Class to accumulate points and make best line / plane approximation. More...

struct	PointCloud

struct	PointCloudApproxRelaxParams

struct	PointCloudRelaxParams

struct	PointInAllSpaces

class	PointObject

struct	PointOnFace

struct	PointOnObject

struct	PointPair
	Stores a pair of points: one samples on the source and the closest to it on the target. More...

struct	PointPairs

struct	PointsLoadSettings

struct	PointsProjectionResult

struct	PointsToDistanceVolumeParams

struct	PointsToMeshParameters

class	PointsToMeshProjector
	Computes the closest point on mesh to each of given points on CPU. More...

class	PointToPlaneAligningTransform

class	PointToPointAligningTransform

struct	Polyline

struct	PolylineIntersectionResult2

struct	PolylineMaker
	simplifies construction of connected polyline in the topology More...

struct	PolylineProjectionResult

struct	PolylineProjectionWithOffsetResult

struct	PolylineSubdivideSettings

class	PolylineTopology

struct	PolylineTraits

struct	PolylineTraits< Vector2f >

struct	PolylineTraits< Vector3f >

class	PolylineUndirectedEdgeIterator

struct	Polynomial

struct	PolynomialWrapper
	This is a unifying interface for a polynomial of some degree, known only in runtime. More...

struct	PositionedText

struct	PostDrawListener

struct	PostFocusListener
	class to subscribe on PostFocusSingal More...

struct	PostRescaleListener

struct	PostResizeListener

class	PrecipitationSimulator
	the class models water increase in the terrain under the rain with constant precipitation More...

struct	PreciseCollisionResult

struct	PreciseVertCoords

struct	PreciseVertCoords2

struct	PreDrawListener

class	ProgressBar

struct	ProgressInterrupter

class	PythonExport

struct	PythonFunctionAdder

struct	QuadraticForm

class	QuadricApprox

class	QuadTextureVertexObject

struct	Quaternion

class	RadiusMeasurementObject

class	RangeCounter
	functor to calculate tile and leaf valid nodes count More...

class	RangeProcessor
	Class to use in tbb::parallel_reduce for openvdb::tree transformation. More...

class	RangeProcessorSingle
	Class to use in tbb::parallel_reduce for tree operations that do not require an output tree. More...

class	RangeProgress

struct	RangeSize

struct	RawTiffOutput

struct	RayOrigin

class	RecentFilesStore

class	RectIndexer
	a class for converting 2D integer coordinates into 1D linear coordinates and backward More...

struct	RefineParameters
	Optional parameters for refineFeatureObject. More...

class	RegisterRenderObjectConstructor

class	RegularMapMesher
	Class for making mesh from regular distance map. More...

struct	RelaxParams

struct	RemeshSettings

class	RemovePointActionPickerPoint

class	RenderAngleObject

class	RenderBufferRef

class	RenderDistanceObject

class	RenderImGuiLabelObject

class	RenderLabelObject

class	RenderLinesObject

class	RenderMeshObject

class	RenderNameObject

class	RenderObjectBuffer

class	RenderObjectCombinator

class	RenderPointsObject

class	RenderRadiusObject

class	RenderResetDirtyComponent

class	RenderVolumeObject

class	ResetSceneMenuItem

struct	ResolveMeshDegenSettings

class	RestoringStreamsSink

class	RibbonButtonDrawer
	class for drawing ribbon menu buttons More...

class	RibbonFontManager

class	RibbonIcons

class	RibbonMenu

class	RibbonMenuItem

class	RibbonMenuItemAdder

class	RibbonMenuItemCall

class	RibbonMenuSearch

struct	RibbonNotification

class	RibbonNotifier

class	RibbonSceneHideAll

class	RibbonSceneObjectsListDrawer
	class for drawing a list of scene objects in RibbonMenu style More...

class	RibbonSceneRemoveSelected

class	RibbonSceneRename

class	RibbonSceneSelectAll

class	RibbonSceneShowAll

class	RibbonSceneShowOnlyNext

class	RibbonSceneShowOnlyPrev

class	RibbonSceneSortByName

class	RibbonSceneUnselectAll

struct	RibbonSchema

class	RibbonSchemaHolder

class	RibbonSchemaLoader

struct	RibbonTab

struct	RigidScaleXf3

struct	RigidXf3

class	RingIterator

class	SaveObjectMenuItem

struct	SaveObjectSettings

class	SaveOnClosePlugin

class	SaveSceneAsMenuItem

class	SaveSceneMenuItem

class	SaveSelectedMenuItem

struct	SaveSettings
	determines how to save points/lines/mesh More...

class	SceneCache

struct	SceneColors

class	SceneObjectsListDrawer
	class for drawing a list of scene objects (and handling interaction with it) More...

class	SceneRoot

class	SceneRootObject
	Object that is parent of all scene. More...

class	SceneSelectionChangeClose

class	SceneSelectionChangeRestart

class	SceneSettings

class	SceneStateAndCheck

class	SceneStateAtLeastCheck

class	SceneStateAtLeastCheck< N, ObjectT, NoModelCheck >

class	SceneStateAtLeastCheck< N, ObjectT, NoVisualRepresentationCheck >

class	SceneStateExactCheck

class	SceneStateExactCheck< N, ObjectT, NoModelCheck >

class	SceneStateExactCheck< N, ObjectT, NoVisualRepresentationCheck >

class	SceneStateOrCheck

class	SceneTextureGL

class	ScopeHistory

struct	SearchPathSettings
	Geo path search settings. More...

struct	SegmEndColors

struct	SegmentSegmentIntersectResult

struct	SegmPoint
	encodes a point inside a line segment using relative distance in [0,1] More...

class	SelectObjectByClick

class	SelectScreenLasso

class	SeparationPointStorage
	storage for points on voxel edges used in Marching Cubes algorithms More...

class	SetBitIteratorT
	iterator to enumerate all indices with set bits in BitSet class or its derivatives More...

class	SetViewportConfigPresetMenuItem

class	SetViewPresetMenuItem

struct	ShaderWarning

class	ShadowsGL

struct	SharpenMarchingCubesMeshSettings

struct	SharpOffsetParameters

struct	ShellVertexInfo
	information about shell vertex More...

class	ShiftTransformer
	functor for shifting voxels More...

struct	ShortcutKey

class	ShortcutManager

struct	Signal

struct	SignedDistanceToMeshResult

struct	SimpleTimeRecord

struct	SkyPatch
	this class represents a portion of the sky, and its radiation More...

struct	SomeLocalTriangulations
	describes a number of local triangulations of some points (e.g. assigned to a thread) More...

struct	SortIntersectionsData

class	SpaceMouseController

struct	SpaceMouseDownListener
	class to subscribe on SpaceMouseDownSgnal More...

class	SpaceMouseHandler
	class to handle spacemouse More...

class	SpaceMouseHandlerHidapi

struct	SpaceMouseMoveListener
	class to subscribe on SpaceMouseMoveSignal More...

struct	SpaceMouseParameters

struct	SpaceMouseUpListener
	class to subscribe on SpaceMouseUpSignal More...

struct	SpacingSettings

struct	Sphere

class	SphereObject

struct	SphereParams

class	SplashWindow

class	StateBasePlugin

class	StateListenerPlugin

struct	StitchHolesParams
	Parameters structure for MR::buildCylinderBetweenTwoHoles Structure has some options to control MR::buildCylinderBetweenTwoHoles. More...

struct	StopOnTrueCombiner

struct	SubdivideSettings

class	SurfaceContoursWidget

class	SurfaceContoursWidgetClearAction

class	SurfaceDistanceBuilder
	this class is responsible for iterative construction of distance map along the surface More...

class	SurfaceManipulationWidget
	widget for surface modifying @detail available 3 modes: add (move surface region in direction of normal) remove (move surface region in opposite direction to normal) relax (relax surface region) More...

class	SurfacePointWidget

class	SwapRootAction

struct	SymbolMeshParams

struct	SymMatrix2

struct	SymMatrix3

struct	SymMatrix4

class	TaggedBitSet
	container of bits representing specific indices (faces, verts or edges) More...

class	TeethMaskToDirectionVolumeConvertor

struct	TerminalVertex

struct	TextMeshAlignParams

struct	ThreadRootTimeRecord

struct	TiffParameters

class	Timer

struct	TimeRecord

class	Toolbar
	class to draw toolbar and toolbar customize windows More...

struct	ToolPathParams

struct	ToolPathResult

struct	TouchEndListener

class	TouchesController

struct	TouchMoveListener

class	TouchpadController

struct	TouchpadParameters

struct	TouchpadRotateGestureBeginListener
	class to subscribe on TouchpadRotateGestureBeginEvent More...

struct	TouchpadRotateGestureEndListener
	class to subscribe on TouchpadRotateGestureEndEvent More...

struct	TouchpadRotateGestureUpdateListener
	class to subscribe on TouchpadRotateGestureUpdateEvent More...

struct	TouchpadSwipeGestureBeginListener
	class to subscribe on TouchpadSwipeGestureBeginEvent More...

struct	TouchpadSwipeGestureEndListener
	class to subscribe on TouchpadSwipeGestureEndEvent More...

struct	TouchpadSwipeGestureUpdateListener
	class to subscribe on TouchpadSwipeGestureUpdateEvent More...

struct	TouchpadZoomGestureBeginListener
	class to subscribe on TouchpadZoomGestureBeginEvent More...

struct	TouchpadZoomGestureEndListener
	class to subscribe on TouchpadZoomGestureEndEvent More...

struct	TouchpadZoomGestureUpdateListener
	class to subscribe on TouchpadZoomGestureUpdateEvent More...

struct	TouchStartListener

class	TransformControls

struct	TransformedMesh
	just stores a mesh and its transformation to some fixed reference frame More...

struct	TriangleSegmentIntersectResult

struct	TriangulationParameters
	Parameters of point cloud triangulation. More...

struct	TriIntersectResult

struct	TriMesh

struct	TrimOptionalOutput

struct	TrimWithPlaneParams

struct	TriPoint
	encodes a point inside a triangle using barycentric coordinates More...

struct	TrivialMetricToPenalty
	the vertices in the queue are ordered by their metric from a start location More...

struct	UiRenderManager

struct	UiRenderParams

class	UndirectedEdgeIterator

struct	UndirectedEdgeUndirectedEdge

struct	UniformSamplingSettings

class	UnionFind
	Simple union find data structure. More...

struct	UniquePtr

class	UniqueTemporaryFolder

class	UniqueThreadSafeOwner

struct	UniteManyMeshesParams

struct	UnitInfo

struct	UnitToStringParams

struct	UnorientedTriangle

struct	VariableEdgeTri

class	Vector
	std::vector<T>-like container that requires specific indexing type, More...

struct	Vector2

struct	Vector3

struct	Vector4

struct	VectorTraits

struct	VectorTraits< ImVec2 >

struct	VectorTraits< ImVec4 >

struct	VectorTraits< Vector2< T > >

struct	VectorTraits< Vector3< T > >

struct	VectorTraits< Vector4< T > >

struct	VertDistance

struct	VertPathInfo
	information associated with each vertex by the paths builder More...

class	VertRenumber
	maps valid points to packed sequential indices More...

class	Viewer

class	ViewerEventQueue
	queue to ignore multiple mouse moves in one frame More...

class	ViewerPlugin

class	ViewerSettingsManager

class	ViewerSettingsPlugin

class	ViewerSetup

class	Viewport

class	ViewportGL

class	ViewportId

class	ViewportIterator
	iterates over all ViewportIds in given ViewportMask More...

struct	ViewportLinesWithColors

class	ViewportMask
	stores mask of viewport unique identifiers More...

class	ViewportParametersAction

struct	ViewportPointsWithColors

class	ViewportProperty

class	VisualObject
	Visual Object. More...

class	VolumeIndexer

struct	VolumeSegmentationParameters
	Parameters for volume segmentation. More...

class	VolumeSegmenter
	Class for voxels segmentation. More...

struct	VolumeToMeshByPartsSettings
	Parameters' structure for MR::volumeToMeshByParts. More...

struct	VoxelLocation
	contains both linear Id and 3D coordinates of the same voxel More...

struct	VoxelMetricParameters
	Parameters for building metric function. More...

struct	VoxelsVolume
	represents a box in 3D space subdivided on voxels stored in T More...

class	VoxelsVolumeAccessor
	helper class for generalized voxel volume data access More...

class	VoxelsVolumeAccessor< VdbVolume >
	VoxelsVolumeAccessor specialization for VDB volume. More...

class	VoxelsVolumeAccessor< VoxelsVolume< VoxelValueGetter< T > > >
	VoxelsVolumeAccessor specialization for value getters. More...

class	VoxelsVolumeAccessor< VoxelsVolumeMinMax< std::vector< T > > >
	VoxelsVolumeAccessor specialization for simple volumes.

class	VoxelsVolumeCachingAccessor

class	VoxelsVolumeInterpolatedAccessor

struct	VoxelsVolumeMinMax

struct	VoxelTraits

struct	VoxelTraits< FloatGrid >

struct	VoxelTraits< std::vector< T > >

struct	VoxelTraits< VoxelValueGetter< T > >

class	WatershedGraph
	graphs representing rain basins on the mesh More...

class	WebRequest

struct	WeightedVertex

struct	Writer

class	XfBasedCache

struct	ZeroOnMove

Concepts
concept	Trivial

concept	HasGetNormalMethod

concept	HasGetDirectionMethod

concept	AnyVisualizeMaskEnumType

concept	UnitEnum

Typedefs
using	FileNamesStack = std::vector<std::filesystem::path>

using	Vector3f = Vector3<float>

using	Vector3i = Vector3<int>

using	Matrix3f = Matrix3 <float>

using	AffineXf3f = AffineXf<Vector3f>

using	Box3f = Box<Vector3f>

using	FaceTreeTraits3 = AABBTreeTraits<FaceTag, Box3f>

template<typename V >
using	LineTreeTraits = AABBTreeTraits<UndirectedEdgeTag, Box<V>>

using	LineTreeTraits2 = LineTreeTraits<Vector2f>

using	LineTreeTraits3 = LineTreeTraits<Vector3f>

template<typename T >
using	AABBTreeNodeVec = Vector<AABBTreeNode<T>, NodeId>

template<size_t degree>
using	Polynomialf = Polynomial<float, degree>

template<size_t degree>
using	Polynomiald = Polynomial<double, degree>

template<typename T >
using	Polynomialx

using	PolynomialWrapperf = PolynomialWrapper<float>

using	PolynomialWrapperd = PolynomialWrapper<double>

template<size_t degree>
using	BestFitPolynomialf = BestFitPolynomial<float, degree>

template<size_t degree>
using	BestFitPolynomiald = BestFitPolynomial<double, degree>

using	OneMeshContours = std::vector<OneMeshContour>
	Special data type for MR::cutMesh.

using	PathMeshEdgePointCallback = std::function<void( const MeshEdgePoint& mep )>

template<class T , class E = std::string>
using	Expected = tl::expected<T, E>

using	VoidOrErrStr = Expected<void>
	return type for a void function that can produce an error string

using	FeaturesPropertyTypesVariant = std::variant<float, Vector3f>

using	MultiObjsSamples = std::vector<ObjVertId>

using	HighPrecisionInt = boost::multiprecision::checked_int128_t

using	Vector2hp = Vector2<HighPrecisionInt>

using	Vector3hp = Vector3<HighPrecisionInt>

using	Vector4hp = Vector4<HighPrecisionInt>

using	Matrix3hp = Matrix3<HighPrecisionInt>

using	Matrix4hp = Matrix4<HighPrecisionInt>

using	HistoryStackFilter = std::function<bool( const std::shared_ptr<HistoryAction>& )>

using	HistoryActionsVector = std::vector<std::shared_ptr<HistoryAction>>

using	ContinuousContour = std::vector<VariableEdgeTri>

using	ContinuousContours = std::vector<ContinuousContour>

using	IOFilters = std::vector<IOFilter>

using	ObjectPtr = std::shared_ptr<Object>

using	IRenderObjectConstructorLambda = std::function<std::unique_ptr<IRenderObject>( const VisualObject& )>

using	TrianglesRepetitions = std::array<int, 4>

using	VoxelPointPositioner = std::function<Vector3f( const Vector3f&, const Vector3f&, float, float, float )>

using	TriangleCallback = std::function<ProcessOneResult( const Vector3f & p, FaceId f, const Vector3f & q, float distSq )>

using	MultipleEdge = VertPair
	finds multiple edges in the mesh

using	EdgePath = std::vector<EdgeId>

using	EdgeLoop = std::vector<EdgeId>

template<typename T >
using	AffineXf3 = AffineXf<Vector3<T>>

template<typename T >
using	Sphere3 = Sphere<Vector3<T>>

template<typename T >
using	Line3 = Line<Vector3<T>>

template<typename T >
using	LineSegm3 = LineSegm<Vector3<T>>

template<typename T >
using	Contour2 = Contour<Vector2<T>>

template<typename T >
using	Contour3 = Contour<Vector3<T>>

using	Contour2d = Contour2<double>

using	Contour2f = Contour2<float>

using	Contour3d = Contour3<double>

using	Contour3f = Contour3<float>

template<typename V >
using	Contours = std::vector<Contour<V>>

template<typename T >
using	Contours2 = Contours<Vector2<T>>

template<typename T >
using	Contours3 = Contours<Vector3<T>>

using	Contours2d = Contours2<double>

using	Contours2f = Contours2<float>

using	Contours3d = Contours3<double>

using	Contours3f = Contours3<float>

template<typename T >
using	Box3 = Box<Vector3<T>>

template<typename T >
using	QuadraticForm3 = QuadraticForm<Vector3<T>>

using	Triangle3i = Triangle3<int>

using	Triangle3f = Triangle3<float>

using	Triangle3d = Triangle3<double>

using	MeshEdgePoint = EdgePoint

using	SurfacePath = std::vector<MeshEdgePoint>

using	SurfacePaths = std::vector<SurfacePath>

using	IsoLine = SurfacePath

using	IsoLines = SurfacePaths

using	PlaneSection = SurfacePath

using	PlaneSections = SurfacePaths

using	VertPair = std::pair<VertId, VertId>

using	FacePair = std::pair<FaceId, FaceId>

using	EdgePair = std::pair<EdgeId, EdgeId>

using	UndirectedEdgePair = std::pair<UndirectedEdgeId, UndirectedEdgeId>

using	UVCoord = Vector2f

using	ThreeVertIds = std::array<VertId, 3>
	three vertex ids describing a triangle topology

using	FacePredicate = std::function<bool( FaceId )>

using	EdgePredicate = std::function<bool( EdgeId )>

using	UndirectedEdgePredicate = std::function<bool( UndirectedEdgeId )>

using	PreCollapseCallback = std::function<bool( EdgeId edgeToCollapse, const Vector3f& newEdgeOrgPos )>

using	OnEdgeSplit = std::function<void( EdgeId e1, EdgeId e )>

using	VertMetric = std::function<float( VertId )>

using	FaceMetric = std::function<float( FaceId )>

using	EdgeMetric = std::function<float( EdgeId )>

using	UndirectedEdgeMetric = std::function<float( UndirectedEdgeId )>

template<typename T , typename Hash = phmap::priv::hash_default_hash<T>, typename Eq = phmap::priv::hash_default_eq<T>>
using	ParallelHashSet = phmap::parallel_flat_hash_set<T, Hash, Eq>

using	FaceHashSet = HashSet<FaceId>

using	VertHashSet = HashSet<VertId>

using	EdgeHashSet = HashSet<EdgeId>

template<typename K , typename V , typename Hash = phmap::priv::hash_default_hash<K>, typename Eq = phmap::priv::hash_default_eq<K>>
using	HashMap = phmap::flat_hash_map<K, V, Hash, Eq>

template<typename K , typename V , typename Hash = phmap::priv::hash_default_hash<K>, typename Eq = phmap::priv::hash_default_eq<K>>
using	ParallelHashMap = phmap::parallel_flat_hash_map<K, V, Hash, Eq>

using	FaceHashMap = HashMap<FaceId, FaceId>

using	VertHashMap = HashMap<VertId, VertId>

using	EdgeHashMap = HashMap<EdgeId, EdgeId>

using	UndirectedEdgeHashMap = HashMap<UndirectedEdgeId, UndirectedEdgeId>

using	WholeEdgeHashMap = HashMap<UndirectedEdgeId, EdgeId>
	mapping of whole edges: map[e]->f, map[e.sym()]->f.sym(), where only map[e] for even edges is stored

using	GcodeSource = std::vector<std::string>

using	FloatGrid = std::shared_ptr<OpenVdbFloatGrid>

typedef std::function< bool(float)>	ProgressCallback

using	Line3fMesh = Line3Mesh<float>

using	Line3dMesh = Line3Mesh<double>

using	MeshIntersectionCallback = std::function<bool(const MeshIntersectionResult &)>

using	FillTriangleMetric = std::function<double( VertId a, VertId b, VertId c )>

using	FillEdgeMetric = std::function<double( VertId a, VertId b, VertId l, VertId r )>

using	FillCombineMetric = std::function<double( double, double )>

using	TriangleCornerNormals = std::array<Vector3f, 3>
	normals in three corner of a triangle

using	ProjectOnAllCallback = std::function<void( ObjId, MeshOrPoints::ProjectionResult )>
	to receive object id + projection result on it

using	FoundTriCallback = std::function<Processing( const MeshProjectionResult & found, Ball & ball )>
	this callback is invoked on every triangle at least partially in the ball, and allows to change the ball

using	MeshOnVoxels = MeshOnVoxelsT<Mesh>

using	MeshOnVoxelsC = MeshOnVoxelsT<const Mesh>

using	ICPObjects = Vector<MeshOrPointsXf, ObjId>

using	ICPLayer = int

using	ICPElementId = Id<ICPElemtTag>

using	ICPElementBitSet = TaggedBitSet<ICPElemtTag>

using	ICPGroupProjector = std::function<void( const Vector3f& p, MeshOrPoints::ProjectionResult& res, ObjId& resId )>

using	ICPPairsGrid = Vector<Vector<ICPGroupPairs, ICPElementId>, ICPElementId>

using	OffsetContoursVertMap = std::vector<OffsetContoursOrigins>

using	OffsetContoursVertMaps = std::vector<OffsetContoursVertMap>

using	ContoursVariableOffset = std::function<float( int, int )>

using	PickedPoint = std::variant<MeshTriPoint, EdgePoint, VertId, int>

using	FoundPointCallback = std::function<void( VertId, const Vector3f& )>

using	DecimatePolylineSettings2 = DecimatePolylineSettings<Vector2f>

using	DecimatePolylineSettings3 = DecimatePolylineSettings<Vector3f>

template<typename V >
using	FoundEdgeCallback = std::function<void( UndirectedEdgeId, const V& closestPt, float distSq )>

using	FoundEdgeCallback2 = FoundEdgeCallback<Vector2f>

using	FoundEdgeCallback3 = FoundEdgeCallback<Vector3f>

using	RegularGridLatticeValidator = std::function<bool( size_t x, size_t y )>

using	RegularGridLatticePositioner = std::function<Vector3f( size_t x, size_t y )>

using	RegularGridMeshFaceValidator

using	OrgRingIterator = RingIterator<NextEdgeSameOrigin>

using	LeftRingIterator = RingIterator<NextEdgeSameLeft>

using	SeparationPointSet = std::array<VertId, size_t( NeighborDir::Count )>

using	SeparationPointMap = HashMap<size_t, SeparationPointSet>

using	FolderCallback = std::function<void( const std::filesystem::path& tempFolderName )>
	this callback will be called before compression on serialization and after decompression on deserialization

using	AllVisualizeProperties = std::vector<ViewportMask>

using	VoxelsMetric = std::function<float( size_t from, size_t to )>

template<typename Volume >
using	VolumePartBuilder = std::function<Expected<Volume> ( int begin, int end, std::optional<Vector3i>& offset )>

using	Time = std::chrono::time_point<std::chrono::system_clock>

using	DisabledWarnings = std::vector<ShaderWarning>

using	TransformModesValidator = std::function<ControlBit( const Vector3f& center, const AffineXf3f& xf, ViewportId )>

using	RenderDefaultUiObject = RenderObjectCombinator<RenderNameObject>

using	RenderDimensionObject = RenderObjectCombinator<RenderDefaultUiObject, RenderResetDirtyComponent>

using	MenuItemsList = std::vector<std::string>

using	SplitCaptionInfo = std::vector<std::pair<std::string_view, float>>

using	ItemMap = HashMap<std::string, MenuItemInfo>

using	TabsGroupsMap = HashMap<std::string, std::vector<std::string>>

using	GroupsItemsMap = TabsGroupsMap

using	MenuItemsListMigration = std::function<void ( MenuItemsList& )>

using	MenuItemsListMigrations = std::map<int, MenuItemsListMigration>

using	VarUnitToStringParams

using	ViewportRectangle = Box2f
	Viewport size.

using	StatePlugin = StateListenerPlugin<>

using	ViewerEventCallback = std::function<void()>


using	VertPathInfoMap = HashMap<VertId, VertPathInfo>

using	EdgePathsBuilder = EdgePathsBuilderT<TrivialMetricToPenalty>

Enumerations
enum class	Axis { X , Y , Z , Count }

enum class	BooleanOperation { BooleanOperation::InsideA , BooleanOperation::InsideB , BooleanOperation::OutsideA , BooleanOperation::OutsideB , BooleanOperation::Union , BooleanOperation::Intersection , BooleanOperation::DifferenceBA , BooleanOperation::DifferenceAB , BooleanOperation::Count }

enum class	ConeFitterType { ApproximationPCM , HemisphereSearchFit , SpecificAxisFit }

enum class	EdgeWeights { Unit = 0 , Cotan , CotanTimesLength , CotanWithAreaEqWeight }
	determines the weight of each edge in applications like Laplacian More...

enum class	Processing : bool { Continue , Stop }
	typically returned from callbacks to control the behavior of main algorithm More...

enum class	OrientNormals { TowardOrigin , AwayFromOrigin , Smart }
	the method how to choose between two opposite normal orientations More...

enum class	FeaturesObjectKind { Point , Line , Plane , Circle , Sphere , Cylinder , Cone , _count }

enum class	FeaturePropertyKind { position , linearDimension , direction , angle , other }

enum class	ICPMethod { Combined = 0 , PointToPoint = 1 , PointToPlane = 2 }
	The method how to update transformation from point pairs. More...

enum class	ICPMode { RigidScale , AnyRigidXf , OrthogonalAxis , FixedAxis , TranslationOnly }
	The group of transformations, each with its own degrees of freedom. More...

enum class	ICPExitType { NotStarted , NotFoundSolution , MaxIterations , MaxBadIterations , StopMsdReached }

enum class	Side { Negative , Positive }

enum class	DepthFunction { Never = 0 , Less = 1 , Equal = 2 , Greater = 4 , LessOrEqual = Less \| Equal , GreaterOrEqual = Greater \| Equal , NotEqual = Less \| Greater , Always = Less \| Equal \| Greater , Default = 8 }

enum	DecimateStrategy { MinimizeError , ShortestEdgeFirst }
	Defines the order of edge collapses inside Decimate algorithm. More...

enum class	UseAABBTree : char { No , Yes , YesIfAlreadyConstructed }

enum class	ProcessOneResult : bool { ProcessOneResult::StopProcessing = false , ProcessOneResult::ContinueProcessing = true }

enum class	FilterType : char { Linear , Discrete }

enum class	WrapType : char { Repeat , Mirror , Clamp }

enum class	Reorder : char { None , Lexicographically , AABBTree }
	determines how points to be ordered More...

enum class	OutEdge2 : signed char { OutEdge2::Invalid = -1 , OutEdge2::PlusY , OutEdge2::MinusY , OutEdge2::PlusX , OutEdge2::MinusX , OutEdge2::Count }

enum class	RelaxApproxType { Planar , Quadric }

enum class	RenderModelPassMask { Opaque = 1 << 0 , Transparent = 1 << 1 , VolumeRendering = 1 << 2 , NoDepthTest = 1 << 3 , All }
	Various passes of the 3D rendering. More...

enum class	NeighborDir { X , Y , Z , Count }

enum class	SignDetectionMode { Unsigned , OpenVDB , ProjectionNormal , WindingRule , HoleWindingRule }
	how to determine the sign of distances from a mesh More...

enum class	PathError { PathError::StartEndNotConnected , PathError::InternalError }

enum class	GeodesicPathApprox : char { GeodesicPathApprox::DijkstraBiDir , GeodesicPathApprox::DijkstraAStar , GeodesicPathApprox::FastMarching }
	the algorithm to compute approximately geodesic path More...

enum class	ExtremeEdgeType { ExtremeEdgeType::Ridge , ExtremeEdgeType::Gorge }

enum class	BypassDirection { Clockwise , CounterClockwise }

enum class	MoveType { None = -1 , FastLinear = 0 , Linear = 1 , ArcCW = 2 , ArcCCW = 3 }

enum class	ArcPlane { None = -1 , XY = 17 , XZ = 18 , YZ = 19 }

enum class	NestedComponenetsMode { Remove , Merge , Union }

enum class	ColoringType { ColoringType::SolidColor , ColoringType::PrimitivesColorMap , ColoringType::FacesColorMap = PrimitivesColorMap , ColoringType::LinesColorMap = PrimitivesColorMap , ColoringType::VertsColorMap }

enum	DirtyFlags { DIRTY_NONE = 0x0000 , DIRTY_POSITION = 0x0001 , DIRTY_UV = 0x0002 , DIRTY_VERTS_RENDER_NORMAL = 0x0004 , DIRTY_FACES_RENDER_NORMAL = 0x0008 , DIRTY_CORNERS_RENDER_NORMAL = 0x0010 , DIRTY_RENDER_NORMALS = DIRTY_VERTS_RENDER_NORMAL \| DIRTY_FACES_RENDER_NORMAL \| DIRTY_CORNERS_RENDER_NORMAL , DIRTY_SELECTION = 0x0020 , DIRTY_TEXTURE = 0x0040 , DIRTY_PRIMITIVES = 0x0080 , DIRTY_FACE = DIRTY_PRIMITIVES , DIRTY_VERTS_COLORMAP = 0x0100 , DIRTY_PRIMITIVE_COLORMAP = 0x0200 , DIRTY_FACES_COLORMAP = DIRTY_PRIMITIVE_COLORMAP , DIRTY_TEXTURE_PER_FACE = 0x0400 , DIRTY_MESH = 0x07FF , DIRTY_BOUNDING_BOX = 0x0800 , DIRTY_BORDER_LINES = 0x1000 , DIRTY_EDGES_SELECTION = 0x2000 , DIRTY_CACHES = DIRTY_BOUNDING_BOX , DIRTY_ALL = 0x3FFF }

enum class	OutEdge : signed char { OutEdge::Invalid = -1 , OutEdge::PlusZ = 0 , OutEdge::MinusZ , OutEdge::PlusY , OutEdge::MinusY , OutEdge::PlusX , OutEdge::MinusX , OutEdge::Count }

enum class	QuarterBit : char { QuarterBit::LeftLeft = 0b1 , QuarterBit::LeftRight = 0b10 , QuarterBit::RightLeft = 0b100 , QuarterBit::RightRight = 0b1000 , QuarterBit::All = 0b1111 }

enum	SlicePlane { YZ , ZX , XY , None }
	Plane of slice in which to find path. More...

enum	AlignType { Left , Center , Right }

enum class	SelectedTypesMask { ObjectBit = 1 << 0 , ObjectPointsHolderBit = 1 << 1 , ObjectLinesHolderBit = 1 << 2 , ObjectMeshHolderBit = 1 << 3 , ObjectLabelBit = 1 << 4 , ObjectMeshBit = 1 << 5 , ObjectFeatureBit = 1 << 6 , ObjectMeasurementBit = 1 << 7 }

enum class	FitMode { Visible , SelectedPrimitives , SelectedObjects , CustomObjectsList }

enum class	MouseButton { Left = 0 , Right = 1 , Middle = 2 , Count , NoButton = Count }

enum class	MouseMode { None , Rotation , Translation , Roll , Count }

enum class	NotificationType { Error , Warning , Info , Count }

enum class	ControlBit { None = 0 , RotX = 0x1 , RotY = 0x2 , RotZ = 0x4 , RotMask = RotX \| RotY \| RotZ , MoveX = 0x8 , MoveY = 0x10 , MoveZ = 0x20 , MoveMask = MoveX \| MoveY \| MoveZ , FullMask = RotMask \| MoveMask }

enum class	RibbonItemType { Button , ButtonWithDrop }

enum class	PathPreference { Geodesic , Convex , Concave }

enum class	ShortcutCategory : char { Info , Edit , View , Scene , Objects , Selection , Count }

enum	SpaceMouseButtons : int { SMB_NO = -1 , SMB_MENU , SMB_ESC , SMB_ENTER , SMB_TAB , SMB_SHIFT , SMB_CTRL , SMB_ALT , SMB_SPACE , SMB_DELETE , SMB_CUSTOM_1 , SMB_CUSTOM_2 , SMB_CUSTOM_3 , SMB_CUSTOM_4 , SMB_CUSTOM_5 , SMB_CUSTOM_6 , SMB_CUSTOM_7 , SMB_CUSTOM_8 , SMB_CUSTOM_9 , SMB_CUSTOM_10 , SMB_CUSTOM_11 , SMB_CUSTOM_12 , SMB_FIT , SMB_TOP , SMB_RIGHT , SMB_FRONT , SMB_ROLL_CW , SMB_LOCK_ROT , SMB_BTN_V1 , SMB_BTN_V2 , SMB_BTN_V3 , SMB_ISO1 , SMB_BUTTON_COUNT }
	enumeration all spacemouse buttons More...

enum class	StatePluginTabs { Basic , Mesh , DistanceMap , PointCloud , Selection , Voxels , Analysis , Test , Other , Count }

enum class	NoUnit { _count }

enum class	LengthUnit { mm , inches , _count }

enum class	AngleUnit { radians , degrees , _count }

enum class	PixelSizeUnit { pixels , _count }

enum class	RatioUnit { factor , percents , _count }

enum class	TimeUnit { seconds , milliseconds , _count }

enum class	MovementSpeedUnit { mmPerSecond , inchesPerSecond , _count }

enum class	AreaUnit { mm2 , inches2 , _count }

enum class	VolumeUnit { mm3 , inches3 , _count }

enum class	InvLengthUnit { inv_mm , inv_inches , _count }

enum class	NumberStyle { normal , distributePrecision , exponential , maybeExponential }

enum class	DegreesMode { degrees , degreesMinutes , degreesMinutesSeconds }

Functions
template<typename T >
Vector3< T >	to3dim (const Vector2< T > &v)

template<typename T >
Vector2< T >	to2dim (const Vector3< T > &v)

template<typename T >
Matrix3< T >	to3dim (const Matrix2< T > &m)

template<typename T >
Matrix2< T >	to2dim (const Matrix3< T > &m)

template<typename T >
AffineXf3< T >	to3dim (const AffineXf2< T > &xf)

template<typename T >
AffineXf2< T >	to2dim (const AffineXf3< T > &xf)

MRMESH_API Expected< std::shared_ptr< Object > >	deserializeObjectTreeFrom3mf (const std::filesystem::path &file, std::string *loadWarn=nullptr, ProgressCallback callback={})

MRMESH_API Expected< std::shared_ptr< Object > >	deserializeObjectTreeFromModel (const std::filesystem::path &file, std::string *loadWarn=nullptr, ProgressCallback callback={})

int	getNumNodes (int numLeaves)
	returns the number of nodes in the binary tree with given number of leaves

template<typename T >
AABBTreeNodeVec< T >	makeAABBTreeNodeVec (Buffer< BoxedLeaf< T > > boxedLeaves)

MRMESH_API VoidOrErrStr	addNoise (VertCoords &points, const VertBitSet &validVerts, NoiseSettings settings)

template<typename T >
AffineXf3< T >	lookAt (const Vector3< T > &center, const Vector3< T > &eye, const Vector3< T > &up)
	computes rigid transformation xf

MRMESH_API void	findAlphaShapeNeiTriangles (const PointCloud &cloud, VertId v, float radius, Triangulation &appendTris, std::vector< VertId > &neis, bool onlyLargerVids)
	if true then two other points must have larger ids (to avoid finding same triangles several times)

MRMESH_API Triangulation	findAlphaShapeAllTriangles (const PointCloud &cloud, float radius)
	find all triangles of alpha-shape with negative alpha = -1/radius

MRMESH_API Mesh	makeArrow (const Vector3f &base, const Vector3f &vert, const float &thickness=0.05f, const float &coneRadius=0.1f, const float coneSize=0.2f, const int qual=32)

MRMESH_API Mesh	makeBasisAxes (const float &size=1.0f, const float &thickness=0.05f, const float &coneRadius=0.1f, const float coneSize=0.2f, const int qual=32)

MRMESH_API std::string	encode64 (const std::uint8_t *data, size_t size)
	encodes binary data into textual Base64 format

MRMESH_API std::vector< std::uint8_t >	decode64 (const std::string &val)
	decodes Base64 format into binary data

MRMESH_API double	computeBasinVolume (const Mesh &mesh, const FaceBitSet &faces, float level)

MRMESH_API void	accumulatePoints (PointAccumulator &accum, const std::vector< Vector3f > &points, const AffineXf3f *xf=nullptr)
	Adds in existing PointAccumulator all given points.

MRMESH_API void	accumulateWeighedPoints (PointAccumulator &accum, const std::vector< Vector3f > &points, const std::vector< float > &weights, const AffineXf3f *xf=nullptr)
	Adds in existing PointAccumulator all given weighed points.

MRMESH_API void	accumulateFaceCenters (PointAccumulator &accum, const MeshPart &mp, const AffineXf3f *xf=nullptr)
	Adds in existing PointAccumulator all mesh face centers with the weight equal to face area.

MRMESH_API void	accumulateLineCenters (PointAccumulator &accum, const Polyline3 &pl, const AffineXf3f *xf=nullptr)
	Adds in existing PointAccumulator all line centers with the weight equal to the length line.

MRMESH_API void	accumulatePoints (PointAccumulator &accum, const PointCloud &pc, const AffineXf3f *xf=nullptr)
	Adds in existing PointAccumulator all points from the cloud with weight 1.

constexpr bool	canSolvePolynomial (auto degree)

constexpr bool	canMinimizePolynomial (auto degree)

MRMESH_API bool	operator== (const BitSet &a, const BitSet &b)
	compare that two bit sets have the same set bits (they can be equal even if sizes are distinct but last bits are off)

template<typename T >
bool	operator== (const TaggedBitSet< T > &a, const TaggedBitSet< T > &b)

template<typename T , typename U >
void	operator== (const TaggedBitSet< T > &a, const TaggedBitSet< U > &b)=delete
	prohibit comparison of unrelated sets

template<typename T >
std::function< bool(Id< T >)>	makePredicate (const TaggedBitSet< T > *bitset)

template<typename T >
std::function< bool(Id< T >)>	makePredicate (const TaggedBitSet< T > &bitset)

template<typename T >
bool	contains (const TaggedBitSet< T > *bitset, Id< T > id)

template<typename T >
bool	contains (const TaggedBitSet< T > &bitset, Id< T > id)

template<typename T >
bool	operator== (const SetBitIteratorT< T > &a, const SetBitIteratorT< T > &b)

template<typename T >
bool	operator!= (const SetBitIteratorT< T > &a, const SetBitIteratorT< T > &b)

auto	begin (const BitSet &a)

auto	end (const BitSet &)

template<typename T >
auto	begin (const TaggedBitSet< T > &a)

template<typename T >
auto	end (const TaggedBitSet< T > &)

template<typename T >
Vector< int, Id< T > >	makeVectorWithSeqNums (const TaggedBitSet< T > &bs)
	creates a Vector where for each set bit of input bitset its sequential number starting from 0 is returned; and -1 for reset bits

template<typename T >
HashMap< Id< T >, int >	makeHashMapWithSeqNums (const TaggedBitSet< T > &bs)
	creates a HashMap where for each set bit of input bitset its sequential number starting from 0 is returned

BitSet	operator& (const BitSet &a, const BitSet &b)

BitSet	operator\| (const BitSet &a, const BitSet &b)

BitSet	operator^ (const BitSet &a, const BitSet &b)

BitSet	operator- (const BitSet &a, const BitSet &b)

template<typename T >
TaggedBitSet< T >	operator& (const TaggedBitSet< T > &a, const TaggedBitSet< T > &b)

template<typename T >
TaggedBitSet< T >	operator\| (const TaggedBitSet< T > &a, const TaggedBitSet< T > &b)

template<typename T >
TaggedBitSet< T >	operator^ (const TaggedBitSet< T > &a, const TaggedBitSet< T > &b)

template<typename T >
TaggedBitSet< T >	operator- (const TaggedBitSet< T > &a, const TaggedBitSet< T > &b)

template<typename BS , typename ... F>
auto	BitSetParallelForAllRanged (const BS &bs, F &&... f)

template<typename BS , typename L , typename ... F>
auto	BitSetParallelForAllRanged (const BS &bs, tbb::enumerable_thread_specific< L > &e, F &&... f)

template<typename BS , typename F , typename ... Cb>
auto	BitSetParallelForAll (const BS &bs, F &&f, Cb &&... cb)

template<typename BS , typename L , typename F , typename ... Cb>
auto	BitSetParallelForAll (const BS &bs, tbb::enumerable_thread_specific< L > &e, F &&f, Cb &&... cb)

template<typename BS , typename F , typename ... Cb>
auto	BitSetParallelFor (const BS &bs, F &&f, Cb &&... cb)

template<typename BS , typename L , typename F , typename ... Cb>
auto	BitSetParallelFor (const BS &bs, tbb::enumerable_thread_specific< L > &e, F &&f, Cb &&... cb)

MRMESH_API Expected< Mesh >	doBooleanOperation (Mesh &&meshACut, Mesh &&meshBCut, const std::vector< EdgePath > &cutEdgesA, const std::vector< EdgePath > &cutEdgesB, BooleanOperation operation, const AffineXf3f rigidB2A=nullptr, BooleanResultMapper mapper=nullptr, bool mergeAllNonIntersectingComponents=false, const BooleanInternalParameters &intParams={})

template<typename T >
std::array< Vector3< T >, 8 >	getCorners (const Box< Vector3< T > > &box)
	returns all corners of given box

template<typename T >
std::array< Vector2< T >, 4 >	getCorners (const Box< Vector2< T > > &box)

template<typename V >
Box< V >	transformed (const Box< V > &box, const AffineXf< V > &xf)
	find the tightest box enclosing this one after transformation

template<typename V >
Box< V >	transformed (const Box< V > &box, const AffineXf< V > *xf)
	this version returns input box as is if pointer to transformation is null

template<typename V >
auto	width (const Box< V > &box)
	returns size along x axis

template<typename V >
auto	height (const Box< V > &box)
	returns size along y axis

template<typename V >
auto	depth (const Box< V > &box)
	returns size along z axis

template<typename T , typename I >
T	getAt (const Buffer< T, I > &bmap, I key)
	given some buffer map and a key, returns the value associated with the key, or default value if key is invalid

template<typename T , typename I >
auto	begin (const Buffer< T, I > &a)

template<typename T , typename I >
auto	begin (Buffer< T, I > &a)

template<typename T , typename I >
auto	end (const Buffer< T, I > &a)

template<typename T , typename I >
auto	end (Buffer< T, I > &a)

template<typename T >
BMap< T, T >	compose (const BMap< T, T > &a, const BMap< T, T > &b)
	computes the composition of two mappings x -> a(b(x))

MRMESH_API std::optional< VertMap >	findSmallestCloseVertices (const Mesh &mesh, float closeDist, const ProgressCallback &cb={})

MRMESH_API std::optional< VertMap >	findSmallestCloseVertices (const PointCloud &cloud, float closeDist, const ProgressCallback &cb={})

MRMESH_API std::optional< VertMap >	findSmallestCloseVertices (const VertCoords &points, float closeDist, const VertBitSet *valid=nullptr, const ProgressCallback &cb={})

MRMESH_API std::optional< VertMap >	findSmallestCloseVerticesUsingTree (const VertCoords &points, float closeDist, const AABBTreePoints &tree, const VertBitSet *valid, const ProgressCallback &cb={})

MRMESH_API std::optional< VertBitSet >	findCloseVertices (const Mesh &mesh, float closeDist, const ProgressCallback &cb={})
	finds all close vertices, where for each vertex there is another one located within given distance

MRMESH_API std::optional< VertBitSet >	findCloseVertices (const PointCloud &cloud, float closeDist, const ProgressCallback &cb={})
	finds all close vertices, where for each vertex there is another one located within given distance

MRMESH_API std::optional< VertBitSet >	findCloseVertices (const VertCoords &points, float closeDist, const VertBitSet *valid=nullptr, const ProgressCallback &cb={})
	finds all close vertices, where for each vertex there is another one located within given distance

MRMESH_API VertBitSet	findCloseVertices (const 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

MRMESH_API std::vector< EdgePair >	findTwinEdgePairs (const Mesh &mesh, float closeDist)
	finds pairs of twin edges (each twin edge will be present at least in one of pairs)

MRMESH_API EdgeBitSet	findTwinEdges (const Mesh &mesh, float closeDist)
	finds all directed twin edges

MRMESH_API EdgeBitSet	findTwinEdges (const std::vector< EdgePair > &pairs)

MRMESH_API UndirectedEdgeBitSet	findTwinUndirectedEdges (const Mesh &mesh, float closeDist)
	finds all undirected twin edges

MRMESH_API UndirectedEdgeBitSet	findTwinUndirectedEdges (const std::vector< EdgePair > &pairs)

MRMESH_API UndirectedEdgeHashMap	findTwinUndirectedEdgeHashMap (const Mesh &mesh, float closeDist)
	provided that each edge has at most one twin, composes bidirectional mapping between twins

MRMESH_API UndirectedEdgeHashMap	findTwinUndirectedEdgeHashMap (const std::vector< EdgePair > &pairs)

bool	operator== (const Color &a, const Color &b)

bool	operator!= (const Color &a, const Color &b)

Color	operator+ (const Color &a, const Color &b)

Color	operator- (const Color &a, const Color &b)

Color	operator* (float a, const Color &b)

Color	operator* (const Color &b, float a)

Color	operator/ (const Color &b, float a)

MRMESH_API Color	blend (const Color &front, const Color &back)

template<typename V >
Box< V >	computeBoundingBox (const Vector< V, VertId > &points, const VertBitSet &region, const AffineXf< V > *toWorld=nullptr)

template<typename V >
Box< V >	computeBoundingBox (const Vector< V, VertId > &points, const VertBitSet region=nullptr, const AffineXf< V > toWorld=nullptr)

MRMESH_API float	voxelizeAndComputeVolume (const std::vector< std::shared_ptr< Mesh > > &meshes, const AffineXf3f &xf, const Vector3f &voxelSize)

template<typename T , typename R = T>
R	calcOrientedArea (const Contour2< T > &contour)

template<typename T , typename R = T>
Vector3< R >	calcOrientedArea (const Contour3< T > &contour)

template<typename To , typename From >
To	copyContour (const From &from)
	copy double-contour to float-contour, or vice versa

template<typename To , typename From >
To	copyContours (const From &from)
	copy double-contours to float-contours, or vice versa

MRMESH_API void	subdivideLoneContours (Mesh &mesh, const OneMeshContours &contours, FaceMap *new2oldMap=nullptr)

MRMESH_API OneMeshContours	getOneMeshIntersectionContours (const Mesh &meshA, const Mesh &meshB, const ContinuousContours &contours, bool getMeshAIntersections, const CoordinateConverters &converters, const AffineXf3f *rigidB2A=nullptr)

MRMESH_API Expected< OneMeshContour, PathError >	convertMeshTriPointsToMeshContour (const Mesh &mesh, const std::vector< MeshTriPoint > &meshTriPoints, SearchPathSettings searchSettings={}, std::vector< int > *pivotIndices=nullptr)
	Makes continuous contour by mesh tri points, if first and last meshTriPoint is the same, makes closed contour.

MRMESH_API Expected< OneMeshContour, PathError >	convertMeshTriPointsToClosedContour (const Mesh &mesh, const std::vector< MeshTriPoint > &meshTriPoints, SearchPathSettings searchSettings={}, std::vector< int > *pivotIndices=nullptr)
	Makes closed continuous contour by mesh tri points, note that first and last meshTriPoint should not be same.

MRMESH_API OneMeshContour	convertSurfacePathWithEndsToMeshContour (const Mesh &mesh, const MeshTriPoint &start, const SurfacePath &surfacePath, const MeshTriPoint &end)
	Converts SurfacePath to OneMeshContours.

MRMESH_API OneMeshContours	convertSurfacePathsToMeshContours (const Mesh &mesh, const std::vector< SurfacePath > &surfacePaths)
	Converts SurfacePaths to OneMeshContours.

MRMESH_API CutMeshResult	cutMesh (Mesh &mesh, const OneMeshContours &contours, const CutMeshParameters &params={})
	Cuts mesh by given contours.

MRMESH_API std::vector< EdgePath >	cutMeshWithPlane (Mesh &mesh, const Plane3f &plane, FaceMap *mapNew2Old=nullptr)
	Simple cut mesh by plane.

MRMESH_API std::vector< FaceBitSet >	separateClosedContour (const Mesh &mesh, const std::vector< Vector3f > &contour, const PathMeshEdgePointCallback &cb={})

MRMESH_API void	stitchContours (MeshTopology &topology, const EdgePath &c0, const EdgePath &c1)

MRMESH_API EdgeLoop	cutAlongEdgeLoop (MeshTopology &topology, const EdgeLoop &c0)

MRMESH_API EdgeLoop	cutAlongEdgeLoop (Mesh &mesh, const EdgeLoop &c0)

MRMESH_API Mesh	makeConvexHull (const VertCoords &points, const VertBitSet &validPoints)

MRMESH_API Mesh	makeConvexHull (const Mesh &in)

MRMESH_API Mesh	makeConvexHull (const PointCloud &in)

MRMESH_API Mesh	makeCube (const Vector3f &size=Vector3f::diagonal(1.0f), const Vector3f &base=Vector3f::diagonal(-0.5f))

MRMESH_API Mesh	makeParallelepiped (const Vector3f side[3], const Vector3f &base)

MRMESH_API Mesh	makeCylinder (float radius=0.1f, float length=1.0f, int resolution=16)

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

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

MRMESH_API Mesh	makeCylinderAdvanced (float radius0=0.1f, float radius1=0.1f, float start_angle=0.0f, float arc_size=2.0f *PI_F, float length=1.0f, int resolution=16)

MRMESH_API Mesh	makeCone (float radius0=0.1f, float length=1.0f, int resolution=32)

MRMESH_API void	calcDipoles (Dipoles &dipoles, const AABBTree &tree, const Mesh &mesh)
	calculates dipoles for given mesh and AABB-tree

MRMESH_API Dipoles	calcDipoles (const AABBTree &tree, const Mesh &mesh)

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

MRMESH_API std::filesystem::path	findPathWithExtension (const std::filesystem::path &pathWithoutExtension)
	given file name without final extension, finds in the same folder an existing file with same stem and any extension

DirectoryIterator	begin (const Directory &sd)

std::filesystem::directory_iterator	end (const Directory &)

bool	operator!= (const DirectoryIterator &a, const std::filesystem::directory_iterator &b)

DirectoryRecursiveIterator	begin (const DirectoryRecursive &sd)

std::filesystem::recursive_directory_iterator	end (const DirectoryRecursive &)

bool	operator!= (const DirectoryRecursiveIterator &a, const std::filesystem::recursive_directory_iterator &b)

MRMESH_API DistanceMap	combineXYderivativeMaps (std::pair< DistanceMap, DistanceMap > XYderivativeMaps)
	fill another distance map pair with gradients across X and Y axes of the argument map

MRMESH_API DistanceMap	computeDistanceMap (const MeshPart &mp, const MeshToDistanceMapParams &params, ProgressCallback cb={}, std::vector< MeshTriPoint > *outSamples=nullptr)

MRMESH_API DistanceMap	computeDistanceMapD (const MeshPart &mp, const MeshToDistanceMapParams &params, ProgressCallback cb={}, std::vector< MeshTriPoint > *outSamples=nullptr)

MRMESH_API DistanceMap	distanceMapFromContours (const Polyline2 &contours, const ContourToDistanceMapParams &params, const ContoursDistanceMapOptions &options={})
	Computes distance of 2d contours according ContourToDistanceMapParams.

MRMESH_API void	distanceMapFromContours (DistanceMap &distMap, const Polyline2 &polyline, const ContourToDistanceMapParams &params, const ContoursDistanceMapOptions &options={})
	Computes distance of 2d contours according ContourToDistanceMapParams.

MRMESH_API std::vector< Vector3f >	edgePointsFromContours (const Polyline2 &polyline, float pixelSize, float threshold)

MRMESH_API Polyline2	distanceMapTo2DIsoPolyline (const DistanceMap &distMap, float isoValue)

MRMESH_API Polyline2	distanceMapTo2DIsoPolyline (const DistanceMap &distMap, const ContourToDistanceMapParams &params, float isoValue)
	iso-lines are created in real space ( plane OXY with parameters according ContourToDistanceMapParams )

MRMESH_API std::pair< Polyline2, AffineXf3f >	distanceMapTo2DIsoPolyline (const DistanceMap &distMap, const AffineXf3f &xf, float isoValue, bool useDepth=false)

MRMESH_API Polyline2	distanceMapTo2DIsoPolyline (const DistanceMap &distMap, float pixelSize, float isoValue)

MRMESH_API Polyline2	polylineOffset (const Polyline2 &polyline, float pixelSize, float offset)
	constructs an offset contour for given polyline

MRMESH_API Polyline2	contourUnion (const Polyline2 &contoursA, const Polyline2 &contoursB, const ContourToDistanceMapParams &params, float offsetInside=0)
	computes the union of the shapes bounded by input 2d contours

MRMESH_API Polyline2	contourIntersection (const Polyline2 &contoursA, const Polyline2 &contoursB, const ContourToDistanceMapParams &params, float offsetInside=0.f)
	computes the intersection of the shapes bounded by input 2d contours

MRMESH_API Polyline2	contourSubtract (const Polyline2 &contoursA, const Polyline2 &contoursB, const ContourToDistanceMapParams &params, float offsetInside=0.f)
	computes the difference between the shapes bounded by contoursA and the shapes bounded by contoursB

MRMESH_API Expected< Mesh >	distanceMapToMesh (const DistanceMap &distMap, const AffineXf3f &toWorld, ProgressCallback cb={})
	converts distance map into mesh and applies a transformation to all points

MRMESH_API Image	convertDistanceMapToImage (const DistanceMap &distMap, float threshold=1.f/255)

MRMESH_API VoidOrErrStr	saveDistanceMapToImage (const DistanceMap &distMap, const std::filesystem::path &filename, float threshold=1.f/255)

MRMESH_API Expected< DistanceMap >	convertImageToDistanceMap (const Image &image, float threshold=1.f/255)

MRMESH_API Expected< DistanceMap >	loadDistanceMapFromImage (const std::filesystem::path &filename, float threshold=1.f/255)

bool	operator== (const UndirectedEdgeIterator &a, const UndirectedEdgeIterator &b)

bool	operator!= (const UndirectedEdgeIterator &a, const UndirectedEdgeIterator &b)

IteratorRange< UndirectedEdgeIterator >	undirectedEdges (const MeshTopology &topology)

MRMESH_API bool	same (const MeshTopology &topology, const EdgePoint &lhs, const EdgePoint &rhs)
	returns true if two edge-points are equal considering different representations

MRMESH_API Expected< Mesh >	embedStructureToTerrain (const Mesh &terrain, const Mesh &structure, const EmbeddedStructureParameters &params)

MRMESH_API VertScalars	computeSpaceDistances (const Mesh &mesh, const PointOnFace &start, float range)

MRMESH_API VertBitSet	findNeighborVerts (const Mesh &mesh, const PointOnFace &start, float range)

MRMESH_API void	expand (const MeshTopology &topology, FaceBitSet &region, int hops=1)
	adds to the region all faces within given number of hops (stars) from the initial region boundary

MRMESH_API FaceBitSet	expand (const MeshTopology &topology, FaceId f, int hops)
	returns the region of all faces within given number of hops (stars) from the initial face

MRMESH_API void	shrink (const MeshTopology &topology, FaceBitSet &region, int hops=1)
	removes from the region all faces within given number of hops (stars) from the initial region boundary

MRMESH_API FaceBitSet	expandFaces (const MeshTopology &topology, const FaceBitSet &region, const UndirectedEdgeBitSet *stopEdges=nullptr)

MRMESH_API FaceBitSet	shrinkFaces (const MeshTopology &topology, const FaceBitSet &region, const UndirectedEdgeBitSet *stopEdges=nullptr)

MRMESH_API FaceBitSet	getBoundaryFaces (const MeshTopology &topology, const FaceBitSet &region)
	returns faces from given region that have at least one neighbor face with shared edge not from the region

template<class E >
auto	unexpected (E &&e)

std::string	stringOperationCanceled ()
	Common operation canceled line for all.

auto	unexpectedOperationCanceled ()
	Returns Expected error with `stringOperationCanceled()`

MRMESH_API IsoLines	extractIsolines (const MeshTopology &topology, const VertMetric &vertValues, const FaceBitSet *region=nullptr)
	extracts all iso-lines from given scalar field and iso-value=0

MRMESH_API bool	hasAnyIsoline (const MeshTopology &topology, const VertMetric &vertValues, const FaceBitSet *region=nullptr)
	quickly returns true if extractIsolines produce not-empty set for the same arguments

MRMESH_API IsoLines	extractIsolines (const MeshTopology &topology, const VertScalars &vertValues, float isoValue, const FaceBitSet *region=nullptr)
	extracts all iso-lines from given scalar field and iso-value

MRMESH_API bool	hasAnyIsoline (const MeshTopology &topology, const VertScalars &vertValues, float isoValue, const FaceBitSet *region=nullptr)
	quickly returns true if extractIsolines produce not-empty set for the same arguments

MRMESH_API PlaneSections	extractPlaneSections (const MeshPart &mp, const Plane3f &plane)
	extracts all plane sections of given mesh

MRMESH_API bool	hasAnyPlaneSection (const MeshPart &mp, const Plane3f &plane)
	quickly returns true if extractPlaneSections produce not-empty set for the same arguments

MRMESH_API PlaneSections	extractXYPlaneSections (const MeshPart &mp, float zLevel)

MRMESH_API bool	hasAnyXYPlaneSection (const MeshPart &mp, float zLevel)
	quickly returns true if extractXYPlaneSections produce not-empty set for the same arguments

MRMESH_API PlaneSection	trackSection (const MeshPart &mp, const MeshTriPoint &start, MeshTriPoint &end, const Vector3f &direction, float distance)

MRMESH_API Contour2f	planeSectionToContour2f (const Mesh &mesh, const PlaneSection &section, const AffineXf3f &meshToPlane)
	converts PlaneSections in 2D contours by computing coordinate of each point, applying given xf to it, and retaining only x and y

MRMESH_API Contours2f	planeSectionsToContours2f (const Mesh &mesh, const PlaneSections &sections, const AffineXf3f &meshToPlane)

MRMESH_API std::optional< FaceScalars >	calcFaceDistances (const MeshTopology &topology, const EdgeMetric &metric, const FaceBitSet &starts, const FaceDistancesSettings &settings={})

template<typename F >
bool	forEachObjectKind (F &&func)
	Calls `func`, which is `( auto kind ) -> bool`, for each known object kind. If it returns true, stops immediately and also returns true.

template<typename ... P>
std::shared_ptr< VisualObject >	makeObjectFromEnum (FeaturesObjectKind kind, P &&... params)
	Allocates an object of type `kind`, passing `params...` to its constructor.

template<typename ... P>
std::shared_ptr< VisualObject >	makeObjectFromClassName (std::string className, P &&... params)
	Allocates an object of type `kind`, passing `params...` to its constructor.

MRMESH_API std::optional< Vector3f >	getFeatureNormal (FeatureObject *feature)

MRMESH_API std::optional< Vector3f >	getFeatureDirection (FeatureObject *feature)

MRMESH_API std::unordered_set< std::string >	getFeaturesTypeWithNormals ()

MRMESH_API std::unordered_set< std::string >	getFeaturesTypeWithDirections ()

MRMESH_API Expected< AffineXf3f >	refineFeatureObject (const FeatureObject &featObj, const Mesh &mesh, const RefineParameters &params={})
	Recalculate the feature object's position so it would better fit with the given mesh.

MRMESH_API Expected< AffineXf3f >	refineFeatureObject (const FeatureObject &featObj, const PointCloud &pointCloud, const RefineParameters &params={})
	Recalculate the feature object's position so it would better fit with the given point cloud.

MRMESH_API FILE *	fopen (const std::filesystem::path &filename, const char *mode)
	this version of fopen unlike std::fopen supports unicode file names on Windows

MRMESH_API FaceBitSet	fillContourLeft (const MeshTopology &topology, const EdgePath &contour)

MRMESH_API FaceBitSet	fillContourLeft (const MeshTopology &topology, const std::vector< EdgePath > &contours)

MRMESH_API FaceBitSet	fillContourLeftByGraphCut (const MeshTopology &topology, const EdgePath &contour, const EdgeMetric &metric)
	Fills region located to the left from given contour, by minimizing the sum of metric over the boundary.

MRMESH_API FaceBitSet	fillContourLeftByGraphCut (const MeshTopology &topology, const std::vector< EdgePath > &contours, const EdgeMetric &metric)
	Fills region located to the left from given contours, by minimizing the sum of metric over the boundary.

MRMESH_API FaceBitSet	segmentByGraphCut (const MeshTopology &topology, const FaceBitSet &source, const FaceBitSet &sink, const EdgeMetric &metric)
	Finds segment that divide mesh on source and sink (source included, sink excluded), by minimizing the sum of metric over the boundary.

MRMESH_API VoidOrErrStr	fillContours2D (Mesh &mesh, const std::vector< EdgeId > &holeRepresentativeEdges)
	fill holes with border in same plane (i.e. after cut by plane)

MRMESH_API AffineXf3f	getXfFromOxyPlane (const Contours3f &contours)

MRMESH_API AffineXf3f	getXfFromOxyPlane (const Mesh &mesh, const std::vector< EdgePath > &paths)

MRMESH_API FaceBitSet	fillHoleNicely (Mesh &mesh, EdgeId holeEdge, const FillHoleNicelySettings &settings)

MRMESH_API void	filterCreaseEdges (const Mesh &mesh, UndirectedEdgeBitSet &creaseEdges, float critLength, bool filterComponents=true, bool filterBranches=false)

MRMESH_API size_t	heapBytes (const FloatGrid &grid)
	returns the amount of heap memory occupied by grid

MRMESH_API FloatGrid	resampled (const FloatGrid &grid, float voxelScale, ProgressCallback cb={})
	resample this grid to fit voxelScale

MRMESH_API FloatGrid	resampled (const FloatGrid &grid, const Vector3f &voxelScale, ProgressCallback cb={})
	resample this grid to fit voxelScale

MRMESH_API FloatGrid	cropped (const FloatGrid &grid, const Box3i &box, ProgressCallback cb={})
	returns cropped grid

MRMESH_API float	getValue (const FloatGrid &grid, const Vector3i &p)
	returns the value at given voxel

MRMESH_API void	setValue (FloatGrid &grid, const VoxelBitSet &region, float value)

MRMESH_API void	setLevelSetType (FloatGrid &grid)
	sets type of this grid as LEVEL SET (for normal flipping)

MRMESH_API FloatGrid	operator+= (FloatGrid &a, const FloatGrid &b)

MRMESH_API FloatGrid	operator-= (FloatGrid &a, const FloatGrid &b)

MRMESH_API FloatGrid	operator*= (FloatGrid &a, const FloatGrid &b)

MRMESH_API std::vector< Vector3f >	makeFreeFormOriginGrid (const Box3f &box, const Vector3i &resolution)
	Returns positions of grid points in given box with given resolution.

MRMESH_API std::vector< Vector3f >	findBestFreeformDeformation (const Box3f &box, const std::vector< Vector3f > &source, const std::vector< Vector3f > &target, const Vector3i &resolution=Vector3i::diagonal(2), const AffineXf3f *samplesToBox=nullptr)

template<typename T >
Vector2< T >	unfoldOnPlane (const Vector3< T > &b, const Vector3< T > &c, const Vector2< T > &d, bool toLeftFrom0d)

template<typename T >
T	shortestPathInQuadrangle (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c, const Vector3< T > &d)

template<typename T >
bool	isUnfoldQuadrangleConvex (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c, const Vector3< T > &d)

MRMESH_API bool	reducePathViaVertex (const Mesh &mesh, const MeshTriPoint &start, VertId v, const MeshTriPoint &end, SurfacePath &outPath, std::vector< Vector2f > &tmp, SurfacePath &cachePath)

MRMESH_API int	reducePath (const Mesh &mesh, const MeshTriPoint &start, SurfacePath &path, const MeshTriPoint &end, int maxIter=5)

MRMESH_API Expected< std::shared_ptr< Object > >	deserializeObjectTreeFromGltf (const std::filesystem::path &file, ProgressCallback callback={})

MRMESH_API VoidOrErrStr	serializeObjectTreeToGltf (const Object &root, const std::filesystem::path &file, ProgressCallback callback={})

MRMESH_API std::optional< VertBitSet >	verticesGridSampling (const MeshPart &mp, float voxelSize, const ProgressCallback &cb={})

MRMESH_API std::optional< VertBitSet >	pointGridSampling (const PointCloud &cloud, float voxelSize, const ProgressCallback &cb={})

MRMESH_API std::optional< MultiObjsSamples >	multiModelGridSampling (const Vector< ModelPointsData, ObjId > &models, float voxelSize, const ProgressCallback &cb={})

template<typename T >
size_t	heapBytes (const std::vector< T > &vec)
	returns the amount of memory given vector occupies on heap

template<typename T , typename U >
size_t	heapBytes (const Vector< T, U > &vec)

template<typename T >
size_t	heapBytes (const std::unique_ptr< T > &ptr)
	returns the amount of memory this smart pointer and its pointed object own together on heap

template<typename T >
size_t	heapBytes (const std::shared_ptr< T > &ptr)
	returns the amount of memory this smart pointer and its pointed object own together on heap

template<typename T >
size_t	heapBytes (const std::function< T > &)
	Needed for generic code, always returns zero.

MRMESH_API std::pair< bool, int >	filterHistoryActionsVector (HistoryActionsVector &historyVector, HistoryStackFilter filteringCondition, size_t firstRedoIndex=0, bool deepFiltering=true)
	Remove actions from history actions vector that match the condition.

size_t	getNumSamples (const IPointPairs &pairs)
	returns the number of samples able to form pairs

MRMESH_API size_t	getNumActivePairs (const IPointPairs &pairs)
	computes the number of active pairs

MRMESH_API NumSum	getSumSqDistToPoint (const IPointPairs &pairs, double *inaccuracy=nullptr)

MRMESH_API NumSum	getSumSqDistToPlane (const IPointPairs &pairs, double *inaccuracy=nullptr)

float	getMeanSqDistToPoint (const IPointPairs &pairs)
	computes root-mean-square deviation between points

float	getMeanSqDistToPlane (const IPointPairs &pairs)
	computes root-mean-square deviation from points to target planes

MRMESH_API std::string	getICPStatusInfo (int iterations, ICPExitType exitType)
	returns status info string

MRMESH_API AffineXf3f	getAligningXf (const PointToPlaneAligningTransform &p2pl, ICPMode mode, float angleLimit, float scaleLimit, const Vector3f &fixedRotationAxis)
	given prepared (p2pl) object, finds the best transformation from it of given type with given limitations on rotation angle and global scale

MRMESH_API size_t	deactivateFarPairs (IPointPairs &pairs, float maxDistSq)
	reset active bit if pair distance is further than maxDistSq

MRMESH_API void	updatePointPairs (PointPairs &pairs, const MeshOrPointsXf &src, const MeshOrPointsXf &tgt, float cosThreshold, float distThresholdSq, bool mutualClosest)
	in each pair updates the target data and performs basic filtering (activation)

template<typename T >
constexpr Id< T >	operator+ (Id< T > id, int a)

template<typename T >
constexpr Id< T >	operator+ (Id< T > id, unsigned int a)

template<typename T >
constexpr Id< T >	operator+ (Id< T > id, size_t a)

template<typename T >
constexpr Id< T >	operator- (Id< T > id, int a)

template<typename T >
constexpr Id< T >	operator- (Id< T > id, unsigned int a)

template<typename T >
constexpr Id< T >	operator- (Id< T > id, size_t a)

constexpr FaceId	operator""_f (unsigned long long i) noexcept

constexpr VertId	operator""_v (unsigned long long i) noexcept

constexpr EdgeId	operator""_e (unsigned long long i) noexcept

constexpr UndirectedEdgeId	operator""_ue (unsigned long long i) noexcept

constexpr VoxelId	operator""_vox (unsigned long long i) noexcept

MRMESH_API bool	improveSampling (const PointCloud &cloud, VertBitSet &samples, const ImproveSamplingSettings &settings)

MRMESH_API ShellVertexInfo	classifyShellVert (const MeshPart &mp, const Vector3f &shellPoint, const FindInnerShellSettings &settings={})

MRMESH_API VertBitSet	findInnerShellVerts (const MeshPart &mp, const Mesh &shell, const FindInnerShellSettings &settings={})

MRMESH_API FaceBitSet	findInnerShellFacesWithSplits (const MeshPart &mp, Mesh &shell, const FindInnerShellSettings &settings={})

template<typename T >
std::optional< Line3< T > >	intersection (const Plane3< T > &plane1, const Plane3< T > &plane2, T errorLimit=std::numeric_limits< T >::epsilon() *T(20))

template<typename T >
std::optional< Vector3< T > >	intersection (const Plane3< T > &plane, const Line3< T > &line, T errorLimit=std::numeric_limits< T >::epsilon() *T(20))

template<typename T >
std::optional< Vector3< T > >	intersection (const Line3< T > &line1, const Line3< T > &line2, T errorLimit=std::numeric_limits< T >::epsilon() *T(20))

std::optional< Vector2f >	intersection (const LineSegm2f &segm1, const LineSegm2f &segm2)

template<typename T >
std::optional< T >	distanceSq (const Plane3< T > &plane1, const Plane3< T > &plane2, T errorLimit=std::numeric_limits< T >::epsilon() *T(20))

template<typename T >
std::optional< T >	distance (const Plane3< T > &plane1, const Plane3< T > &plane2, T errorLimit=std::numeric_limits< T >::epsilon() *T(20))

template<typename T >
std::optional< T >	distance (const Plane3< T > &plane, const Line3< T > &line, T errorLimit=std::numeric_limits< T >::epsilon() *T(20))

template<typename T >
LineSegm3< T >	closestPoints (const Line3< T > &line1, const Line3< T > &line2)

template<typename T >
LineSegm3< T >	closestPoints (const Line3< T > &ln, const LineSegm3< T > &ls)

template<typename T >
LineSegm3< T >	closestPoints (const Line3< T > &line, const Box3< T > &box)
	finds the closest points between a line and a box wireframe (not solid) in 3D

template<typename V >
auto	intersection (const Line< V > &line, const Sphere< V > &sphere)

MRMESH_API ContinuousContours	orderIntersectionContours (const MeshTopology &topologyA, const MeshTopology &topologyB, const PreciseCollisionResult &intersections)

MRMESH_API std::vector< int >	detectLoneContours (const ContinuousContours &contours)

MRMESH_API void	removeLoneDegeneratedContours (const MeshTopology &edgesTopology, OneMeshContours &faceContours, OneMeshContours &edgeContours)

MRMESH_API void	removeLoneContours (ContinuousContours &contours)

template<typename T >
void	findMaxVectorDim (int &dimX, int &dimY, int &dimZ, const Vector3< T > &dir)
	finds index of maximum axis and stores it into dimZ

template<typename T >
void	findMaxVectorDim (int &dimX, int &dimY, const Vector2< T > &dir)
	finds index of maximum axis and stores it into dimY

IOFilters	operator\| (const IOFilters &a, const IOFilters &b)

MRMESH_API std::vector< size_t >	splitByLines (const char *data, size_t size)

MRMESH_API Expected< Buffer< char > >	readCharBuffer (std::istream &in)

template<typename T >
VoidOrErrStr	parseTextCoordinate (const std::string_view &str, Vector3< T > &v, Vector3< T > n=nullptr, Color c=nullptr)

template<typename T >
VoidOrErrStr	parseObjCoordinate (const std::string_view &str, Vector3< T > &v, Vector3< T > *c=nullptr)

template<typename T >
VoidOrErrStr	parsePtsCoordinate (const std::string_view &str, Vector3< T > &v, Color &c)

MRMESH_API VoidOrErrStr	parseFirstNum (const std::string_view &str, int &num)

MRMESH_API VoidOrErrStr	parsePolygon (const std::string_view &str, VertId vertId, int numPoints)

template<typename T >
VoidOrErrStr	parseAscCoordinate (const std::string_view &str, Vector3< T > &v, Vector3< T > n=nullptr, Color c=nullptr)

template<typename T >
VoidOrErrStr	parseSingleNumber (const std::string_view &str, T &num)

MRMESH_API std::unique_ptr< IRenderObject >	createRenderObject (const VisualObject &visObj, const std::type_index &type)

template<typename ObjectType >
std::unique_ptr< IRenderObject >	createRenderObject (const VisualObject &visObj)

template<typename RenderObjType >
IRenderObjectConstructorLambda	makeRenderObjectConstructor ()

bool	isNanFast (float f)
	quickly tests whether given float is not-a-number

MRMESH_API std::optional< VertBitSet >	pointIterativeSampling (const PointCloud &cloud, int numSamples, const ProgressCallback &cb={})

template<typename I >
I	begin (const IteratorRange< I > &range)

template<typename I >
I	end (const IteratorRange< I > &range)

MRMESH_API std::shared_ptr< Object >	makeLevelOfDetails (Mesh &&mesh, int maxDepth)

template<typename V >
bool	operator== (const LineSegm< V > &a, const LineSegm< V > &b)

template<typename V >
V	closestPointOnLineSegm (const V &pt, const LineSegm< V > &l)

template<typename V >
bool	doSegmentsIntersect (const LineSegm< V > &x, const LineSegm< V > &y, typename V::ValueType xPos=nullptr, typename V::ValueType yPos=nullptr)

template<typename V >
bool	doSegmentLineIntersect (const LineSegm< V > &x, const Line< V > &y, typename V::ValueType xPos=nullptr, typename V::ValueType yPos=nullptr)

MRMESH_API std::optional< AllLocalTriangulations >	uniteLocalTriangulations (const std::vector< SomeLocalTriangulations > &in, const ProgressCallback &progress={})

MRMESH_API Vector3f	computeNormal (const AllLocalTriangulations &triangs, const VertCoords &points, VertId v)
	compute normal at point by averaging neighbor triangle normals weighted by triangle's angle at the point

MRMESH_API void	orientLocalTriangulations (AllLocalTriangulations &triangs, const VertCoords &coords, const VertBitSet &region, const VertNormals &targetDir)
	orient neighbors around each point in

MRMESH_API void	orientLocalTriangulations (AllLocalTriangulations &triangs, const VertCoords &coords, const VertBitSet &region, const std::function< Vector3f(VertId)> &targetDir)

MRMESH_API bool	autoOrientLocalTriangulations (const PointCloud &pointCloud, AllLocalTriangulations &triangs, const VertBitSet &region, ProgressCallback progress={}, Triangulation outRep3=nullptr, Triangulation outRep2=nullptr)
	orient neighbors around each point in

MRMESH_API TrianglesRepetitions	computeTrianglesRepetitions (const AllLocalTriangulations &triangs)
	computes statistics about the number of triangle repetitions in local triangulations

MRMESH_API std::vector< UnorientedTriangle >	findRepeatedUnorientedTriangles (const AllLocalTriangulations &triangs, int repetitions)
	from local triangulations returns all unoriented triangles with given number of repetitions each in [1,3]

MRMESH_API Triangulation	findRepeatedOrientedTriangles (const AllLocalTriangulations &triangs, int repetitions)
	from local triangulations returns all oriented triangles with given number of repetitions each in [1,3]

MRMESH_API void	findRepeatedOrientedTriangles (const AllLocalTriangulations &triangs, Triangulation outRep3, Triangulation outRep2)
	optional output with all oriented triangles that appear in exactly two local triangulations

MRMESH_API Mesh	makePlane ()

MRMESH_API AffineXf3d	makeRigidXf (const MeshPart &mp, const AffineXf3d &meshXf)

MRMESH_API AffineXf3f	makeRigidXf (const MeshPart &mp, const AffineXf3f &meshXf)

MRMESH_API Mesh	makeSphere (const SphereParams &params)
	creates a mesh of sphere with irregular triangulation

MRMESH_API Mesh	makeUVSphere (float radius=1.0, int horisontalResolution=16, int verticalResolution=16)
	creates a mesh of sphere with regular triangulation (parallels and meridians)

EdgeId	mapEdge (const WholeEdgeMap &map, EdgeId src)
	given input edge (src), converts its id using given map

EdgeId	mapEdge (const WholeEdgeHashMap &map, EdgeId src)
	given input edge (src), converts its id using given map

UndirectedEdgeId	mapEdge (const UndirectedEdgeBMap &map, UndirectedEdgeId src)
	given input edge (src), converts its id using given map

MRMESH_API UndirectedEdgeBitSet	mapEdges (const WholeEdgeMap &map, const 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

MRMESH_API UndirectedEdgeBitSet	mapEdges (const WholeEdgeHashMap &map, const 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

MRMESH_API UndirectedEdgeBitSet	mapEdges (const UndirectedEdgeBMap &map, const 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

template<typename ValueT , typename IndexT >
void	mapNewToOldVector (const Vector< ValueT, Id< IndexT > > &oldData, const Vector< Id< IndexT >, Id< IndexT > > &newToOld, Vector< ValueT, Id< IndexT > > &newData)

template<typename ValueT , typename IndexT >
void	mapOldToNewVector (const Vector< ValueT, Id< IndexT > > &oldData, const Vector< Id< IndexT >, Id< IndexT > > &newToOld, Vector< ValueT, Id< IndexT > > &newData)

MRMESH_API Expected< Mesh >	marchingCubes (const SimpleVolume &volume, const MarchingCubesParams &params={})

MRMESH_API Expected< TriMesh >	marchingCubesAsTriMesh (const SimpleVolume &volume, const MarchingCubesParams &params={})

MRMESH_API Expected< Mesh >	marchingCubes (const VdbVolume &volume, const MarchingCubesParams &params={})

MRMESH_API Expected< TriMesh >	marchingCubesAsTriMesh (const VdbVolume &volume, const MarchingCubesParams &params={})

MRMESH_API Expected< Mesh >	marchingCubes (const FunctionVolume &volume, const MarchingCubesParams &params={})

MRMESH_API Expected< TriMesh >	marchingCubesAsTriMesh (const FunctionVolume &volume, const MarchingCubesParams &params={})

template<typename T >
void	decomposeMatrix3 (const Matrix3< T > &m, Matrix3< T > &rotation, Matrix3< T > &scaling)
	Decomposes matrix into rotation and scaling matrices.

template<typename T >
bool	isRigid (const Matrix3< T > &m)
	Returns true if matrix scale is identity.

MRMESH_API BooleanResult	boolean (const Mesh &meshA, const Mesh &meshB, BooleanOperation operation, const AffineXf3f rigidB2A, BooleanResultMapper mapper=nullptr, ProgressCallback cb={})
	Performs CSG operation on two meshes.

MRMESH_API BooleanResult	boolean (Mesh &&meshA, Mesh &&meshB, BooleanOperation operation, const AffineXf3f rigidB2A, BooleanResultMapper mapper=nullptr, ProgressCallback cb={})

MRMESH_API BooleanResult	boolean (const Mesh &meshA, const Mesh &meshB, BooleanOperation operation, const BooleanParameters &params={})

MRMESH_API BooleanResult	boolean (Mesh &&meshA, Mesh &&meshB, BooleanOperation operation, const BooleanParameters &params={})

MRMESH_API Expected< BooleanResultPoints, std::string >	getBooleanPoints (const Mesh &meshA, const Mesh &meshB, BooleanOperation operation, const AffineXf3f *rigidB2A=nullptr)
	Returns the points of mesh boolean's result mesh.

MRMESH_API TransformedMesh &	operator+= (TransformedMesh &a, const TransformedMesh &b)
	union operation on two meshes

MRMESH_API TransformedMesh &	operator-= (TransformedMesh &a, const TransformedMesh &b)
	difference operation on two meshes

MRMESH_API TransformedMesh &	operator*= (TransformedMesh &a, const TransformedMesh &b)
	intersection operation on two meshes

MRMESH_API void	straightenBoundary (Mesh &mesh, EdgeId bd, float minNeiNormalsDot, float maxTriAspectRatio, FaceBitSet *newFaces=nullptr)

MRMESH_API std::vector< FaceFace >	findCollidingTriangles (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr, bool firstIntersectionOnly=false)
	finds all pairs of colliding triangles from two meshes or two mesh regions

MRMESH_API std::pair< FaceBitSet, FaceBitSet >	findCollidingTriangleBitsets (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr)
	the same as findCollidingTriangles, but returns one bite set per mesh with colliding triangles

MRMESH_API Expected< bool >	findSelfCollidingTriangles (const MeshPart &mp, std::vector< FaceFace > outCollidingPairs, ProgressCallback cb={}, const Face2RegionMap regionMap=nullptr)
	finds all pairs (or the fact of any self-collision) of colliding triangles from one mesh or a region

MRMESH_API Expected< std::vector< FaceFace > >	findSelfCollidingTriangles (const MeshPart &mp, ProgressCallback cb={}, const Face2RegionMap *regionMap=nullptr)
	finds all pairs of colliding triangles from one mesh or a region

MRMESH_API Expected< FaceBitSet >	findSelfCollidingTrianglesBS (const MeshPart &mp, ProgressCallback cb={}, const Face2RegionMap *regionMap=nullptr)
	the same findSelfCollidingTriangles but returns the union of all self-intersecting faces

MRMESH_API bool	isInside (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr)
	checks that arbitrary mesh part A is inside of closed mesh part B

MRMESH_API bool	isNonIntersectingInside (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr)
	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

bool	operator== (const EdgeTri &a, const EdgeTri &b)

MRMESH_API PreciseCollisionResult	findCollidingEdgeTrisPrecise (const MeshPart &a, const MeshPart &b, ConvertToIntVector conv, const AffineXf3f *rigidB2A=nullptr, bool anyIntersection=false)
	finds all pairs of colliding edges from one mesh and triangle from another mesh

MRMESH_API std::vector< EdgeTri >	findCollidingEdgeTrisPrecise (const Mesh &a, const std::vector< EdgeId > &edgesA, const Mesh &b, const std::vector< FaceId > &facesB, ConvertToIntVector conv, const AffineXf3f *rigidB2A=nullptr)
	finds all intersections between every given edge from A and given triangles from B

MRMESH_API CoordinateConverters	getVectorConverters (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr)
	creates simple converters from Vector3f to Vector3i and back in mesh parts area range

MRMESH_API DecimateResult	decimateMesh (Mesh &mesh, const DecimateSettings &settings={})
	Collapse edges in mesh region according to the settings.

MRMESH_API QuadraticForm3f	computeFormAtVertex (const MeshPart &mp, VertId v, float stabilizer, const UndirectedEdgeBitSet *creases=nullptr)
	Computes quadratic form at given vertex of the initial surface before decimation.

MRMESH_API Vector< QuadraticForm3f, VertId >	computeFormsAtVertices (const MeshPart &mp, float stabilizer, const UndirectedEdgeBitSet *creases=nullptr)
	Computes quadratic forms at every vertex of mesh part before decimation.

MRMESH_API FaceBitSet	getSubdividePart (const FaceBitSet &valids, size_t subdivideParts, size_t myPart)
	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

MRMESH_API bool	resolveMeshDegenerations (Mesh &mesh, const ResolveMeshDegenSettings &settings={})
	Resolves degenerate triangles in given mesh.

MRMESH_API bool	resolveMeshDegenerations (Mesh &mesh, int maxIters, float maxDeviation=0, float maxAngleChange=PI_F/3, float criticalAspectRatio=10000)

MRMESH_API bool	remesh (Mesh &mesh, const RemeshSettings &settings)

template<typename T >
auto	preCollapseVertAttribute (const Mesh &mesh, Vector< T, VertId > &data)

MRMESH_API PreCollapseCallback	meshPreCollapseVertAttribute (const Mesh &mesh, const MeshAttributesToUpdate &params)

MRMESH_API DecimateResult	decimateParallelMesh (Mesh &mesh, const DecimateParallelSettings &settings={})
	Collapse edges in mesh region according to the settings.

MRMESH_API void	deleteTargetFaces (Mesh &obj, const Vector3f &targetCenter)
	deletes object faces with normals pointed to the target geometry center

MRMESH_API void	deleteTargetFaces (Mesh &obj, const Mesh &target)

MRMESH_API bool	checkDeloneQuadrangle (const Vector3d &a, const Vector3d &b, const Vector3d &c, const Vector3d &d, double maxAngleChange=DBL_MAX)

MRMESH_API bool	checkDeloneQuadrangle (const Vector3f &a, const Vector3f &b, const Vector3f &c, const Vector3f &d, float maxAngleChange=FLT_MAX)
	converts arguments in double and calls above function

MRMESH_API bool	checkDeloneQuadrangleInMesh (const Mesh &mesh, EdgeId edge, const DeloneSettings &settings={}, float *deviationSqAfterFlip=nullptr)
	squared surface deviation after flip is written here (at least when the function returns false)

MRMESH_API bool	bestQuadrangleDiagonal (const Vector3f &a, const Vector3f &b, const Vector3f &c, const Vector3f &d)

MRMESH_API int	makeDeloneEdgeFlips (Mesh &mesh, const DeloneSettings &settings={}, int numIters=1, ProgressCallback progressCallback={})

MRMESH_API void	makeDeloneOriginRing (Mesh &mesh, EdgeId e, const DeloneSettings &settings={})
	improves mesh triangulation in a ring of vertices with common origin and represented by edge e

MRMESH_API VertId	findDirMax (const Vector3f &dir, const MeshPart &mp, UseAABBTree u=UseAABBTree::Yes)

MRMESH_API MeshDistanceResult	findDistance (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr, float upDistLimitSq=FLT_MAX)
	computes minimal distance between two meshes or two mesh regions

MRMESH_API MeshSignedDistanceResult	findSignedDistance (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr, float upDistLimitSq=FLT_MAX)
	computes minimal distance between two meshes

MRMESH_API float	findMaxDistanceSqOneWay (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr, float maxDistanceSq=FLT_MAX)
	returns the maximum of the squared distances from each B-mesh vertex to A-mesh

MRMESH_API float	findMaxDistanceSq (const MeshPart &a, const MeshPart &b, const AffineXf3f *rigidB2A=nullptr, float maxDistanceSq=FLT_MAX)
	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)

MRMESH_API void	processCloseTriangles (const MeshPart &mp, const Triangle3f &t, float rangeSq, const TriangleCallback &call)

MRMESH_API MeshTopology	topologyFromEigen (const Eigen::MatrixXi &F)
	constructs mesh topology from N*3 matrix of vertex indices

MRMESH_API Mesh	meshFromEigen (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F)
	constructs mesh from M3 matrix of coordinates and N3 matrix of vertex indices

MRMESH_API void	pointsFromEigen (const Eigen::MatrixXd &V, const VertBitSet &selection, VertCoords &points)
	replace selected points with the values from V

MRMESH_API void	topologyToEigen (const MeshTopology &topology, Eigen::MatrixXi &F)
	converts valid faces from mesh topology into N*3 matrix of vertex indices

MRMESH_API void	meshToEigen (const Mesh &mesh, Eigen::MatrixXd &V, Eigen::MatrixXi &F)
	converts mesh into M3 matrix of coordinates and N3 matrix of vertex indices

MRMESH_API void	makeDegenerateBandAroundRegion (Mesh &mesh, const FaceBitSet &region, const MakeDegenerateBandAroundRegionParams &params={})
	Create a band of degenerate faces along the border of the specified region and the rest of the mesh.

MRMESH_API void	buildCylinderBetweenTwoHoles (Mesh &mesh, EdgeId a, EdgeId b, const StitchHolesParams &params={})
	Stitches two holes in Mesh .

MRMESH_API bool	buildCylinderBetweenTwoHoles (Mesh &mesh, const StitchHolesParams &params={})
	this version finds holes in the mesh by itself and returns false if they are not found

MRMESH_API void	fillHole (Mesh &mesh, EdgeId a, const FillHoleParams &params={})
	Fills hole in mesh .

MRMESH_API void	fillHoles (Mesh &mesh, const std::vector< EdgeId > &as, const FillHoleParams &params={})
	fill all holes given by their representative edges in

MRMESH_API bool	isHoleBd (const MeshTopology &topology, const EdgeLoop &loop)

MRMESH_API HoleFillPlan	getHoleFillPlan (const Mesh &mesh, EdgeId e, const FillHoleParams &params={})

MRMESH_API HoleFillPlan	getPlanarHoleFillPlan (const Mesh &mesh, EdgeId e)

MRMESH_API void	executeHoleFillPlan (Mesh &mesh, EdgeId a0, HoleFillPlan &plan, FaceBitSet *outNewFaces=nullptr)
	quickly triangulates the face or hole to the left of (e) given the plan (quickly compared to fillHole function)

MRMESH_API VertId	fillHoleTrivially (Mesh &mesh, EdgeId a, FaceBitSet *outNewFaces=nullptr)
	Triangulates face of hole in mesh trivially .

MRMESH_API EdgeId	extendHole (Mesh &mesh, EdgeId a, const Plane3f &plane, FaceBitSet *outNewFaces=nullptr)

MRMESH_API std::vector< EdgeId >	extendAllHoles (Mesh &mesh, const Plane3f &plane, FaceBitSet *outNewFaces=nullptr)

MRMESH_API EdgeId	extendHole (Mesh &mesh, EdgeId a, std::function< Vector3f(const Vector3f &)> getVertPos, FaceBitSet *outNewFaces=nullptr)

MRMESH_API EdgeId	buildBottom (Mesh &mesh, EdgeId a, Vector3f dir, float holeExtension, FaceBitSet *outNewFaces=nullptr)

MRMESH_API EdgeId	makeDegenerateBandAroundHole (Mesh &mesh, EdgeId a, FaceBitSet *outNewFaces=nullptr)

MRMESH_API bool	makeBridge (MeshTopology &topology, EdgeId a, EdgeId b, FaceBitSet *outNewFaces=nullptr)

MRMESH_API EdgeId	makeBridgeEdge (MeshTopology &topology, EdgeId a, EdgeId b)

MRMESH_API int	duplicateMultiHoleVertices (Mesh &mesh)
	Duplicates all vertices having more than two boundary edges (and returns the number of duplications);.

MRMESH_API Expected< std::vector< MultipleEdge > >	findMultipleEdges (const MeshTopology &topology, ProgressCallback cb={})

bool	hasMultipleEdges (const MeshTopology &topology)

MRMESH_API void	fixMultipleEdges (Mesh &mesh, const std::vector< MultipleEdge > &multipleEdges)
	resolves given multiple edges, but splitting all but one edge in each group

MRMESH_API void	fixMultipleEdges (Mesh &mesh)
	finds and resolves multiple edges

MRMESH_API Expected< FaceBitSet >	findDegenerateFaces (const MeshPart &mp, float criticalAspectRatio=FLT_MAX, ProgressCallback cb={})
	finds faces having aspect ratio >= criticalAspectRatio

MRMESH_API Expected< UndirectedEdgeBitSet >	findShortEdges (const MeshPart &mp, float criticalLength, ProgressCallback cb={})
	finds edges having length <= criticalLength

MRMESH_API VertBitSet	findNRingVerts (const MeshTopology &topology, int n, const VertBitSet *region=nullptr)
	finds vertices in region with complete ring of N edges

MRMESH_API bool	isEdgeBetweenDoubleTris (const 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

MRMESH_API EdgeId	eliminateDoubleTris (MeshTopology &topology, EdgeId e, FaceBitSet *region=nullptr)

MRMESH_API void	eliminateDoubleTrisAround (MeshTopology &topology, VertId v, FaceBitSet *region=nullptr)

MRMESH_API bool	isDegree3Dest (const MeshTopology &topology, EdgeId e)
	returns true if the destination of given edge has degree 3 and 3 incident triangles

MRMESH_API EdgeId	eliminateDegree3Dest (MeshTopology &topology, EdgeId e, FaceBitSet *region=nullptr)

MRMESH_API int	eliminateDegree3Vertices (MeshTopology &topology, VertBitSet &region, FaceBitSet *fs=nullptr)

MRMESH_API EdgeId	isVertexRepeatedOnHoleBd (const MeshTopology &topology, VertId v)

MRMESH_API VertBitSet	findRepeatedVertsOnHoleBd (const MeshTopology &topology)
	returns set bits for all vertices present on the boundary of a hole several times;

MRMESH_API FaceBitSet	findHoleComplicatingFaces (const Mesh &mesh)

	MR_CANONICAL_TYPEDEFS ((template< typename T > class MRMESH_CLASS), Id,(EdgeId, Id< EdgeTag >)(UndirectedEdgeId, Id< UndirectedEdgeTag >)(FaceId, Id< FaceTag >)(VertId, Id< VertTag >)(PixelId, Id< PixelTag >)(VoxelId, Id< VoxelTag >)(RegionId, Id< RegionTag >)(NodeId, Id< NodeTag >)(ObjId, Id< ObjTag >)(TextureId, Id< TextureTag >)(GraphVertId, Id< GraphVertTag >)(GraphEdgeId, Id< GraphEdgeTag >)) template< typename T

	MR_CANONICAL_TYPEDEFS ((template< typename T > class MRMESH_CLASS), TaggedBitSet,(FaceBitSet, TaggedBitSet< FaceTag >)(VertBitSet, TaggedBitSet< VertTag >)(EdgeBitSet, TaggedBitSet< EdgeTag >)(UndirectedEdgeBitSet, TaggedBitSet< UndirectedEdgeTag >)(PixelBitSet, TaggedBitSet< PixelTag >)(VoxelBitSet, TaggedBitSet< VoxelTag >)(RegionBitSet, TaggedBitSet< RegionTag >)(NodeBitSet, TaggedBitSet< NodeTag >)(ObjBitSet, TaggedBitSet< ObjTag >)(TextureBitSet, TaggedBitSet< TextureTag >)(GraphVertBitSet, TaggedBitSet< GraphVertTag >)(GraphEdgeBitSet, TaggedBitSet< GraphEdgeTag >)) MR_CANONICAL_TYPEDEFS((template< typename T > class MRMESH_CLASS)

	SetBitIteratorT< BitSet > (FaceSetBitIterator, SetBitIteratorT< FaceBitSet >)(VertSetBitIterator

	SetBitIteratorT< VertBitSet > (EdgeSetBitIterator, SetBitIteratorT< EdgeBitSet >)(UndirectedEdgeSetBitIterator

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), MRMESH_CLASS Vector2,(Vector2b, Vector2< bool >)(Vector2i, Vector2< int >)(Vector2ll, Vector2< long long >)(Vector2f, Vector2< float >)(Vector2d, Vector2< double >)) MR_CANONICAL_TYPEDEFS((template< typename T > struct)

MRMESH_CLASS	Vector3< bool > (Vector3i, Vector3< int >)(Vector3ll

MRMESH_CLASS	Vector3< long long > (Vector3f, Vector3< float >)(Vector3d

MRMESH_CLASS Vector3< double >	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), Vector4,(Vector4b, Vector4< bool >)(Vector4i, Vector4< int >)(Vector4ll, Vector4< long long >)(Vector4f, Vector4< float >)(Vector4d, Vector4< double >)) MR_CANONICAL_TYPEDEFS((template< typename T > struct)

MRMESH_CLASS Vector3< double >	Matrix2< bool > (Matrix2i, Matrix2< int >)(Matrix2ll

MRMESH_CLASS Vector3< double >	Matrix2< long long > (Matrix2f, Matrix2< float >)(Matrix2d

MRMESH_CLASS Vector3< double > Matrix2< double >	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), Matrix3,(Matrix3b, Matrix3< bool >)(Matrix3i, Matrix3< int >)(Matrix3ll, Matrix3< long long >)(Matrix3f, Matrix3< float >)(Matrix3d, Matrix3< double >)) MR_CANONICAL_TYPEDEFS((template< typename T > struct)

MRMESH_CLASS Vector3< double > Matrix2< double >	Matrix4< bool > (Matrix4i, Matrix4< int >)(Matrix4ll

MRMESH_CLASS Vector3< double > Matrix2< double >	Matrix4< long long > (Matrix4f, Matrix4< float >)(Matrix4d

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double >	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), SymMatrix2,(SymMatrix2b, SymMatrix2< bool >)(SymMatrix2i, SymMatrix2< int >)(SymMatrix2ll, SymMatrix2< long long >)(SymMatrix2f, SymMatrix2< float >)(SymMatrix2d, SymMatrix2< double >)) MR_CANONICAL_TYPEDEFS((template< typename T > struct)

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double >	SymMatrix3< bool > (SymMatrix3i, SymMatrix3< int >)(SymMatrix3ll

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double >	SymMatrix3< long long > (SymMatrix3f, SymMatrix3< float >)(SymMatrix3d

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double >	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), SymMatrix4,(SymMatrix4b, SymMatrix4< bool >)(SymMatrix4i, SymMatrix4< int >)(SymMatrix4ll, SymMatrix4< long long >)(SymMatrix4f, SymMatrix4< float >)(SymMatrix4d, SymMatrix4< double >)) MR_CANONICAL_TYPEDEFS((template< typename V > struct)

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double >	AffineXf< Vector2< float > > (AffineXf2d, AffineXf< Vector2< double > >)(AffineXf3f

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double >	AffineXf< Vector3< float > > (AffineXf3d, AffineXf< Vector3< double > >)) template< typename T > using AffineXf2

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), RigidXf3,(RigidXf3f, RigidXf3< float >)(RigidXf3d, RigidXf3< double >)) MR_CANONICAL_TYPEDEFS((template< typename T > struct)

	RigidScaleXf3< float > (RigidScaleXf3d, RigidScaleXf3< double >)) class PointToPointAligningTransform

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), Sphere,(Sphere2f, Sphere< Vector2< float > >)(Sphere2d, Sphere< Vector2< double > >)(Sphere3f, Sphere< Vector3< float > >)(Sphere3d, Sphere< Vector3< double > >)) template< typename T > using Sphere2

	MR_CANONICAL_TYPEDEFS ((template< typename V > struct), Line,(Line2f, Line< Vector2< float > >)(Line2d, Line< Vector2< double > >)(Line3f, Line< Vector3< float > >)(Line3d, Line< Vector3< double > >)) template< typename T > using Line2

	MR_CANONICAL_TYPEDEFS ((template< typename V > struct), LineSegm,(LineSegm2f, LineSegm< Vector2< float > >)(LineSegm2d, LineSegm< Vector2< double > >)(LineSegm3f, LineSegm< Vector3< float > >)(LineSegm3d, LineSegm< Vector3< double > >)) template< typename T > using LineSegm2

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), Parabola,(Parabolaf, Parabola< float >)(Parabolad, Parabola< double >)) MR_CANONICAL_TYPEDEFS((template< typename T > class)

	BestFitParabola< float > (BestFitParabolad, BestFitParabola< double >)) MR_CANONICAL_TYPEDEFS((template< typename T > class)

	Cylinder3< float > (Cylinder3d, Cylinder3< double >)) MR_CANONICAL_TYPEDEFS((template< typename T > class)

	Cone3< float > (Cone3d, Cone3< double >)) template< typename V > using Contour

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), Plane3,(Plane3f, Plane3< float >)(Plane3d, Plane3< double >)) MR_CANONICAL_TYPEDEFS((template< typename V > struct)

	Box< Vector2< int > > (Box2ll, Box< Vector2< long long > >)(Box2f

	Box< Vector2< float > > (Box2d, Box< Vector2< double > >)(Box3i

	Box< Vector3< int > > (Box3ll, Box< Vector3< long long > >)(Box3f

	Box< Vector3< float > > (Box3d, Box< Vector3< double > >)) template< typename T > using Box2

	MR_CANONICAL_TYPEDEFS ((template< typename V > struct), QuadraticForm,(QuadraticForm2f, QuadraticForm< Vector2< float > >)(QuadraticForm2d, QuadraticForm< Vector2< double > >)(QuadraticForm3f, QuadraticForm< Vector3< float > >)(QuadraticForm3d, QuadraticForm< Vector3< double > >)) template< typename T > using QuadraticForm2

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), Quaternion,(Quaternionf, Quaternion< float >)(Quaterniond, Quaternion< double >)) template< typename T > using Triangle3

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), SegmPoint,(SegmPointf, SegmPoint< float >)(SegmPointd, SegmPoint< double >)) struct EdgePoint

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), TriPoint,(TriPointf, TriPoint< float >)(TriPointd, TriPoint< double >)) struct PointOnFace

	MR_CANONICAL_TYPEDEFS ((template< typename T, typename I > class MRMESH_CLASS), Vector,(Triangulation, Vector< ThreeVertIds, FaceId >)(Dipoles, Vector< Dipole, NodeId >)(FaceMap, Vector< FaceId, FaceId >)(VertMap, Vector< VertId, VertId >)(EdgeMap, Vector< EdgeId, EdgeId >)(UndirectedEdgeMap, Vector< UndirectedEdgeId, UndirectedEdgeId >)(ObjMap, Vector< ObjId, ObjId >)(WholeEdgeMap, Vector< EdgeId, UndirectedEdgeId >)(UndirectedEdge2RegionMap, Vector< RegionId, UndirectedEdgeId >)(Face2RegionMap, Vector< RegionId, FaceId >)(Vert2RegionMap, Vector< RegionId, VertId >)(VertCoords, Vector< Vector3f, VertId >)(VertNormals, Vector< Vector3f, VertId >)(VertUVCoords, Vector< UVCoord, VertId >)(FaceNormals, Vector< Vector3f, FaceId >)(TexturePerFace, Vector< TextureId, FaceId >)(VertColors, Vector< Color, VertId >)(FaceColors, Vector< Color, FaceId >)(EdgeColors, Vector< Color, EdgeId >)(UndirectedEdgeColors, Vector< Color, UndirectedEdgeId >)(VertScalars, Vector< float, VertId >)(FaceScalars, Vector< float, FaceId >)(EdgeScalars, Vector< float, EdgeId >)(UndirectedEdgeScalars, Vector< float, UndirectedEdgeId >)) using VertPredicate

template<typename T >
bool	contains (const std::function< bool(Id< T >)> &pred, Id< T > id)

	MR_CANONICAL_TYPEDEFS ((template< typename T, typename I > struct MRMESH_CLASS), BMap,(FaceBMap, BMap< FaceId, FaceId >)(VertBMap, BMap< VertId, VertId >)(EdgeBMap, BMap< EdgeId, EdgeId >)(UndirectedEdgeBMap, BMap< UndirectedEdgeId, UndirectedEdgeId >)(WholeEdgeBMap, BMap< EdgeId, UndirectedEdgeId >)) template< typename T

	MR_CANONICAL_TYPEDEFS ((template< typename V > struct), Polyline,(Polyline2, Polyline< Vector2f >)(Polyline3, Polyline< Vector3f >)) MR_CANONICAL_TYPEDEFS((template< typename V > class MRMESH_CLASS)

	AABBTreePolyline< Vector2f > (AABBTreePolyline3, AABBTreePolyline< Vector3f >)) template< typename T > struct IntersectionPrecomputes

	MR_CANONICAL_TYPEDEFS ((template< typename V > struct[[nodiscard]]), PolylineProjectionResult,(PolylineProjectionResult2, PolylineProjectionResult< Vector2f >)(PolylineProjectionResult3, PolylineProjectionResult< Vector3f >)) MR_CANONICAL_TYPEDEFS((template< typename V > struct)

	PolylineProjectionWithOffsetResult< Vector2f > (PolylineProjectionWithOffsetResult3, PolylineProjectionWithOffsetResult< Vector3f >)) class DistanceMap

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), VoxelsVolumeMinMax,(SimpleVolume, VoxelsVolumeMinMax< std::vector< float > >)(SimpleVolumeU16, VoxelsVolumeMinMax< std::vector< uint16_t > >) MRMESH_IF_HAVE_OPENVDB((VdbVolume, VoxelsVolumeMinMax< FloatGrid >))) template< typename T > using VoxelValueGetter

	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), VoxelsVolume,(FunctionVolume, VoxelsVolume< VoxelValueGetter< float > >)(FunctionVolumeU8, VoxelsVolume< VoxelValueGetter< uint8_t > >)) class HistoryAction

	MR_CANONICAL_TYPEDEFS ((template< typename Tag > class MRMESH_CLASS), ColorMapAggregator,(VertColorMapAggregator, ColorMapAggregator< VertTag >)(UndirEdgeColorMapAggregator, ColorMapAggregator< UndirectedEdgeTag >)(FaceColorMapAggregator, ColorMapAggregator< FaceTag >)) template< typename T > class FewSmallest

template<typename T >
constexpr T	sqr (T x) noexcept

template<typename T >
constexpr int	sgn (T x) noexcept

template<class... Ts>
	overloaded (Ts...) -> overloaded< Ts... >

MRMESH_API MeshIntersectionResult	rayMeshIntersect (const MeshPart &meshPart, const Line3f &line, float rayStart=0.0f, float rayEnd=FLT_MAX, const IntersectionPrecomputes< float > *prec=nullptr, bool closestIntersect=true, const FacePredicate &validFaces={})

MRMESH_API MeshIntersectionResult	rayMeshIntersect (const MeshPart &meshPart, const Line3d &line, double rayStart=0.0, double rayEnd=DBL_MAX, const IntersectionPrecomputes< double > *prec=nullptr, bool closestIntersect=true, const FacePredicate &validFaces={})

MRMESH_API MultiMeshIntersectionResult	rayMultiMeshAnyIntersect (const std::vector< Line3fMesh > &lineMeshes, float rayStart=0.0f, float rayEnd=FLT_MAX)

MRMESH_API MultiMeshIntersectionResult	rayMultiMeshAnyIntersect (const std::vector< Line3dMesh > &lineMeshes, double rayStart=0.0, double rayEnd=DBL_MAX)
	Same as rayMultiMeshAnyIntersectF, but use double precision.

MRMESH_API void	rayMeshIntersectAll (const MeshPart &meshPart, const Line3f &line, MeshIntersectionCallback callback, float rayStart=0.0f, float rayEnd=FLT_MAX, const IntersectionPrecomputes< float > *prec=nullptr)

MRMESH_API void	rayMeshIntersectAll (const MeshPart &meshPart, const Line3d &line, MeshIntersectionCallback callback, double rayStart=0.0, double rayEnd=DBL_MAX, const IntersectionPrecomputes< double > *prec=nullptr)
	Same as rayMeshIntersectAllF, but use double precision.

MRMESH_API void	xyPlaneMeshIntersect (const MeshPart &meshPart, float zLevel, FaceBitSet fs, UndirectedEdgeBitSet ues, VertBitSet *vs)

MRMESH_API double	calcCombinedFillMetric (const Mesh &mesh, const FaceBitSet &filledRegion, const FillHoleMetric &metric)
	Computes combined metric after filling a hole.

MRMESH_API FillHoleMetric	getCircumscribedMetric (const Mesh &mesh)

MRMESH_API FillHoleMetric	getPlaneFillMetric (const Mesh &mesh, EdgeId e)

MRMESH_API FillHoleMetric	getPlaneNormalizedFillMetric (const Mesh &mesh, EdgeId e)

MRMESH_API FillHoleMetric	getComplexStitchMetric (const Mesh &mesh)

MRMESH_API FillHoleMetric	getEdgeLengthFillMetric (const Mesh &mesh)
	Simple metric minimizing the sum of all edge lengths.

MRMESH_API FillHoleMetric	getEdgeLengthStitchMetric (const Mesh &mesh)

MRMESH_API FillHoleMetric	getVerticalStitchMetric (const Mesh &mesh, const Vector3f &upDir)

MRMESH_API FillHoleMetric	getComplexFillMetric (const Mesh &mesh, EdgeId e)

MRMESH_API FillHoleMetric	getParallelPlaneFillMetric (const Mesh &mesh, EdgeId e, const Plane3f *plane=nullptr)
	This metric minimizes summary projection of new edges to plane normal, (try do produce edges parallel to plane)

MRMESH_API FillHoleMetric	getMaxDihedralAngleMetric (const Mesh &mesh)

MRMESH_API FillHoleMetric	getUniversalMetric (const Mesh &mesh)

MRMESH_API FillHoleMetric	getMinTriAngleMetric (const Mesh &mesh)
	This metric maximizes the minimal angle among all faces in the triangulation.

MRMESH_API FillHoleMetric	getMinAreaMetric (const Mesh &mesh)

MRMESH_API FaceNormals	computePerFaceNormals (const Mesh &mesh)
	returns a vector with face-normal in every element for valid mesh faces

MRMESH_API void	computePerFaceNormals4 (const Mesh &mesh, Vector4f *faceNormals, size_t size)
	fills buffer with face-normals as Vector4f for valid mesh faces

MRMESH_API VertNormals	computePerVertNormals (const Mesh &mesh)
	returns a vector with vertex normals in every element for valid mesh vertices

MRMESH_API VertNormals	computePerVertPseudoNormals (const Mesh &mesh)

MRMESH_API MeshNormals	computeMeshNormals (const Mesh &mesh)
	computes both per-face and per-vertex normals more efficiently then just calling both previous functions

MRMESH_API Vector< TriangleCornerNormals, FaceId >	computePerCornerNormals (const Mesh &mesh, const UndirectedEdgeBitSet *creases)

MRMESH_API std::optional< MeshOrPoints >	getMeshOrPoints (const VisualObject *obj)
	constructs MeshOrPoints from ObjectMesh or ObjectPoints, otherwise returns nullopt

MRMESH_API void	projectOnAll (const Vector3f &pt, const AABBTreeObjects &tree, float upDistLimitSq, const ProjectOnAllCallback &callback, ObjId skipObjId={})
	finds closest point on every object within given distance

MRMESH_API Expected< std::vector< FaceBitSet > >	findOverhangs (const Mesh &mesh, const FindOverhangsSettings &settings)
	Find face regions that might create overhangs.

MRMESH_API MeshProjectionResult	findProjection (const Vector3f &pt, const MeshPart &mp, float upDistLimitSq=FLT_MAX, const AffineXf3f *xf=nullptr, float loDistLimitSq=0, const FacePredicate &validFaces={}, const std::function< bool(const MeshProjectionResult &)> &validProjections={})
	computes the closest point on mesh (or its region) to given point

MRMESH_API MeshProjectionResult	findProjectionSubtree (const Vector3f &pt, const MeshPart &mp, const AABBTree &tree, float upDistLimitSq=FLT_MAX, const AffineXf3f *xf=nullptr, float loDistLimitSq=0, const FacePredicate &validFaces={}, const std::function< bool(const MeshProjectionResult &)> &validProjections={})
	computes the closest point on mesh (or its region) to given point

MRMESH_API void	findTrisInBall (const MeshPart &mp, Ball ball, const FoundTriCallback &foundCallback, const FacePredicate &validFaces={})

MRMESH_API std::optional< SignedDistanceToMeshResult >	findSignedDistance (const Vector3f &pt, const MeshPart &mp, float upDistLimitSq=FLT_MAX, float loDistLimitSq=0)
	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)

MRMESH_API bool	relax (Mesh &mesh, const MeshRelaxParams &params={}, ProgressCallback cb={})

MRMESH_API Vector3f	vertexPosEqualNeiAreas (const Mesh &mesh, VertId v, bool noShrinkage)

MRMESH_API bool	equalizeTriAreas (Mesh &mesh, const MeshEqualizeTriAreasParams &params={}, ProgressCallback cb={})

MRMESH_API bool	relaxKeepVolume (Mesh &mesh, const MeshRelaxParams &params={}, ProgressCallback cb={})

MRMESH_API bool	relaxApprox (Mesh &mesh, const MeshApproxRelaxParams &params={}, ProgressCallback cb={})

MRMESH_API void	removeSpikes (Mesh &mesh, int maxIterations, float minSumAngle, const VertBitSet *region=nullptr)
	applies at most given number of relaxation iterations the spikes detected by given threshold

MRMESH_API void	smoothRegionBoundary (Mesh &mesh, const FaceBitSet &regionFaces, int numIters=4)

MRMESH_API void	hardSmoothTetrahedrons (Mesh &mesh, const VertBitSet *region=nullptr)
	move all region vertices with exactly three neighbor vertices in the center of the neighbors

MRMESH_API void	replicateZ (Mesh &m, const Mesh &target)
	adjusts z-coordinates of (m) vertices to make adjusted (m) similar to (target)

MRMESH_API int	subdivideMesh (Mesh &mesh, const SubdivideSettings &settings={})

template<typename T >
auto	onEdgeSplitVertAttribute (const Mesh &mesh, Vector< T, VertId > &data)

template<typename T >
auto	onEdgeSplitFaceAttribute (const Mesh &mesh, Vector< T, FaceId > &data)

MRMESH_API OnEdgeSplit	meshOnEdgeSplitAttribute (const Mesh &mesh, const MeshAttributesToUpdate &params)

MRMESH_API OnEdgeSplit	meshOnEdgeSplitVertAttribute (const Mesh &mesh, const MeshAttributesToUpdate &params)

MRMESH_API OnEdgeSplit	meshOnEdgeSplitFaceAttribute (const Mesh &mesh, const MeshAttributesToUpdate &params)

MRMESH_API std::optional< VertScalars >	computeRayThicknessAtVertices (const Mesh &mesh, const ProgressCallback &progress={})
	returns the distance from each vertex along minus normal to the nearest mesh intersection (or FLT_MAX if no intersection found)

MRMESH_API VertScalars	computeThicknessAtVertices (const Mesh &mesh)

MRMESH_API MeshIntersectionResult	rayInsideIntersect (const Mesh &mesh, const MeshPoint &m, float rayEnd=FLT_MAX)
	returns the nearest intersection between the mesh and the ray from given point along minus normal (inside the mesh)

MRMESH_API MeshIntersectionResult	rayInsideIntersect (const Mesh &mesh, VertId v, float rayEnd=FLT_MAX)

MRMESH_API InSphere	findInSphere (const Mesh &mesh, const MeshPoint &m, const InSphereSearchSettings &settings)
	finds maximal sphere inscribed in the mesh touching point (p) with center along the normal at (p)

MRMESH_API InSphere	findInSphere (const Mesh &mesh, VertId v, const InSphereSearchSettings &settings)

MRMESH_API std::optional< VertScalars >	computeInSphereThicknessAtVertices (const Mesh &mesh, const InSphereSearchSettings &settings, const ProgressCallback &progress={})
	returns the thickness at each vertex as the diameter of the maximal inscribed sphere

MRMESH_API std::optional< float >	signedDistanceToMesh (const MeshPart &mp, const Vector3f &p, const DistanceToMeshOptions &op)
	computes signed distance from point (p) to mesh part (mp) following options (op)

MRMESH_API Expected< SimpleVolume >	meshToDistanceVolume (const MeshPart &mp, const MeshToDistanceVolumeParams &params={})
	makes SimpleVolume filled with (signed or unsigned) distances from Mesh with given settings

MRMESH_API FunctionVolume	meshToDistanceFunctionVolume (const MeshPart &mp, const MeshToDistanceVolumeParams &params={})
	makes FunctionVolume representing (signed or unsigned) distances from Mesh with given settings

MRMESH_API Expected< SimpleVolume >	meshRegionToIndicatorVolume (const Mesh &mesh, const FaceBitSet &region, float offset, const DistanceVolumeParams &params)

MRMESH_API Expected< std::array< SimpleVolume, 3 > >	meshToDirectionVolume (const MeshToDirectionVolumeParams &params)

MRMESH_API PointCloud	meshToPointCloud (const Mesh &mesh, bool saveNormals=true, const VertBitSet *verts=nullptr)

template<typename T , typename I >
Vector< T, I >	rearrangeVectorByMap (const Vector< T, I > &oldVector, const BMap< I, I > &map)

MRMESH_API void	loadMeshDll ()

MRMESH_API FaceBitSet	subdivideWithPlane (Mesh &mesh, const Plane3f &plane, FaceHashMap *new2Old=nullptr, float eps=0, std::function< void(EdgeId, EdgeId, float)> onEdgeSplitCallback=nullptr)

MRMESH_API void	trimWithPlane (Mesh &mesh, const Plane3f &plane, UndirectedEdgeBitSet outCutEdges=nullptr, FaceHashMap new2Old=nullptr, float eps=0, std::function< void(EdgeId, EdgeId, float)> onEdgeSplitCallback=nullptr)
	trim mesh by plane

MRMESH_API void	trimWithPlane (Mesh &mesh, const Plane3f &plane, std::vector< EdgeLoop > outCutContours, FaceHashMap new2Old=nullptr, float eps=0, std::function< void(EdgeId, EdgeId, float)> onEdgeSplitCallback=nullptr)
	trim mesh by plane

MRMESH_API void	trimWithPlane (Mesh &mesh, const TrimWithPlaneParams &params, const TrimOptionalOutput &optOut={})
	trim mesh by plane

MRMESH_API Expected< std::shared_ptr< Object > >	fromSceneMison (const std::filesystem::path &path, std::string *loadWarn=nullptr, ProgressCallback callback={})

MRMESH_API Expected< std::shared_ptr< Object > >	fromSceneMison (std::istream &in, std::string *loadWarn=nullptr, ProgressCallback callback={})

MRMESH_API Mesh	makeMovementBuildBody (const Contours3f &body, const Contours3f &trajectory, const MovementBuildBodyParams &params={})

MRMESH_API VertBitSet	moveMeshToVoxelMaxDeriv (Mesh &mesh, const AffineXf3f &meshXf, const VdbVolume &volume, const AffineXf3f &volumeXf, const MoveMeshToVoxelMaxDerivSettings &settings, ProgressCallback callback={})

MRMESH_API void	updateGroupPairs (ICPGroupPairs &pairs, const ICPObjects &objs, ICPGroupProjector srcProjector, ICPGroupProjector tgtProjector, float cosThreshold, float distThresholdSq, bool mutualClosest)
	in each pair updates the target data and performs basic filtering (activation)

MRMESH_API void	denoiseNormals (const Mesh &mesh, FaceNormals &normals, const Vector< float, UndirectedEdgeId > &v, float gamma)

MRMESH_API void	updateIndicator (const Mesh &mesh, Vector< float, UndirectedEdgeId > &v, const FaceNormals &normals, float beta, float gamma)

MRMESH_API void	updateIndicatorFast (const MeshTopology &topology, Vector< float, UndirectedEdgeId > &v, const FaceNormals &normals, float beta, float gamma)

MRMESH_API VoidOrErrStr	meshDenoiseViaNormals (Mesh &mesh, const DenoiseViaNormalsSettings &settings={})

MRMESH_API std::string_view	toString (DimensionsVisualizePropertyType value)

MRMESH_API std::shared_ptr< ObjectLines >	merge (const std::vector< std::shared_ptr< ObjectLines > > &objsLines)
	constructs new ObjectLines containing the union of valid data from all input objects

MRMESH_API std::shared_ptr< ObjectMesh >	merge (const std::vector< std::shared_ptr< ObjectMesh > > &objsMesh)
	constructs new ObjectMesh containing the union of valid data from all input objects

MRMESH_API std::shared_ptr< ObjectMesh >	cloneRegion (const std::shared_ptr< ObjectMesh > &objMesh, const FaceBitSet &region, bool copyTexture=true)

MRMESH_API std::shared_ptr< ObjectPoints >	merge (const std::vector< std::shared_ptr< ObjectPoints > > &objsPoints)
	constructs new ObjectPoints containing the union of valid points from all input objects

MRMESH_API std::shared_ptr< ObjectPoints >	cloneRegion (const std::shared_ptr< ObjectPoints > &objPoints, const VertBitSet &region)

bool	objectHasSelectableChildren (const MR::Object &object)

MRMESH_API float	suggestVoxelSize (const MeshPart &mp, float approxNumVoxels)
	computes size of a cubical voxel to get approximately given number of voxels during rasterization

MRMESH_API Expected< Mesh >	offsetMesh (const MeshPart &mp, float offset, const OffsetParameters &params={})

MRMESH_API Expected< Mesh >	doubleOffsetMesh (const MeshPart &mp, float offsetA, float offsetB, const OffsetParameters &params={})

MRMESH_API Expected< Mesh >	mcOffsetMesh (const MeshPart &mp, float offset, const OffsetParameters &params={}, Vector< VoxelId, FaceId > *outMap=nullptr)

MRMESH_API Expected< Mesh >	mcShellMeshRegion (const Mesh &mesh, const FaceBitSet &region, float offset, const BaseShellParameters &params, Vector< VoxelId, FaceId > *outMap=nullptr)

MRMESH_API Expected< Mesh >	sharpOffsetMesh (const MeshPart &mp, float offset, const SharpOffsetParameters &params={})

MRMESH_API Expected< Mesh >	generalOffsetMesh (const MeshPart &mp, float offset, const GeneralOffsetParameters &params)
	Offsets mesh by converting it to voxels and back using one of three modes specified in the parameters.

MRMESH_API Expected< Mesh >	thickenMesh (const Mesh &mesh, float offset, const GeneralOffsetParameters &params={})

MRMESH_API Expected< Mesh >	offsetPolyline (const Polyline3 &polyline, float offset, const OffsetParameters &params={})

MRMESH_API Expected< Contours2f >	offsetContours (const Contours2f &contours, float offset, const OffsetContoursParams &params={})
	offsets 2d contours in plane

MRMESH_API Expected< Contours2f >	offsetContours (const Contours2f &contours, ContoursVariableOffset offset, const OffsetContoursParams &params={})
	offsets 2d contours in plane

MRMESH_API Expected< Contours3f >	offsetContours (const Contours3f &contours, float offset, const OffsetContoursParams &params={}, const OffsetContoursRestoreZParams &zParmas={})
	offsets 3d contours in XY plane

MRMESH_API Expected< Contours3f >	offsetContours (const Contours3f &contours, ContoursVariableOffset offset, const OffsetContoursParams &params={}, const OffsetContoursRestoreZParams &zParmas={})
	offsets 3d contours in XY plane

template<typename GredT >
void	translateToZero (GredT &grid)

template<typename GridT >
RangeSize	calculateRangeSize (const GridT &grid)

MRMESH_API FaceBMap	getOptimalFaceOrdering (const Mesh &mesh)

MRMESH_API VertBMap	getVertexOrdering (const FaceBMap &faceMap, const MeshTopology &topology)

MRMESH_API UndirectedEdgeBMap	getEdgeOrdering (const FaceBMap &faceMap, const MeshTopology &topology)

MRMESH_API Expected< FaceBitSet >	findOverlappingTris (const MeshPart &mp, const FindOverlappingSettings &settings)
	finds all triangles that have oppositely oriented close triangle in the mesh

template<typename I , typename ... F>
auto	ParallelFor (I begin, I end, F &&... f)

template<typename I , typename L , typename ... F>
auto	ParallelFor (I begin, I end, tbb::enumerable_thread_specific< L > &e, F &&... f)

template<typename T , typename ... F>
auto	ParallelFor (const std::vector< T > &v, F &&... f)

template<typename T , typename I , typename ... F>
auto	ParallelFor (const Vector< T, I > &v, F &&... f)

template<typename T >
std::pair< T, T >	parallelMinMax (const std::vector< T > &vec, const T *topExcluding=nullptr)

template<typename T , typename I >
auto	parallelMinMaxArg (const Vector< T, I > &vec, const T *topExcluding=nullptr)

MRMESH_API Expected< Mesh >	partialOffsetMesh (const MeshPart &mp, float offset, const GeneralOffsetParameters &params={})

MRMESH_API float	findMaxDistanceSqOneWay (const PointCloud &a, const PointCloud &b, const AffineXf3f *rigidB2A=nullptr, float maxDistanceSq=FLT_MAX)
	returns the maximum of the squared distances from each B-point to A-cloud

MRMESH_API float	findMaxDistanceSq (const PointCloud &a, const PointCloud &b, const AffineXf3f *rigidB2A=nullptr, float maxDistanceSq=FLT_MAX)
	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)

MRMESH_API VertBitSet	findHalfSpacePoints (const PointCloud &pc, const Plane3f &plane)

MRMESH_API PointCloud	divideWithPlane (const PointCloud &points, const Plane3f &plane, const DividePointCloudOptionalOutput &optOut={})

MRMESH_API std::optional< VertNormals >	makeUnorientedNormals (const PointCloud &pointCloud, float radius, const ProgressCallback &progress={}, OrientNormals orient=OrientNormals::Smart)
	Makes normals for valid points of given point cloud by directing them along the normal of best plane through the neighbours.

MRMESH_API std::optional< VertNormals >	makeUnorientedNormals (const PointCloud &pointCloud, const AllLocalTriangulations &triangs, const ProgressCallback &progress={}, OrientNormals orient=OrientNormals::Smart)
	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.

MRMESH_API std::optional< VertNormals >	makeUnorientedNormals (const PointCloud &pointCloud, const Buffer< VertId > &closeVerts, int numNei, const ProgressCallback &progress={}, OrientNormals orient=OrientNormals::Smart)
	Makes normals for valid points of given point cloud by directing them along the normal of best plane through the neighbours.

MRMESH_API bool	orientNormals (const PointCloud &pointCloud, VertNormals &normals, float radius, const ProgressCallback &progress={})
	Select orientation of given normals to make directions of close points consistent;.

MRMESH_API bool	orientNormals (const PointCloud &pointCloud, VertNormals &normals, const AllLocalTriangulations &triangs, const ProgressCallback &progress={})
	Select orientation of given normals to make directions of close points consistent;.

MRMESH_API bool	orientNormals (const PointCloud &pointCloud, VertNormals &normals, const Buffer< VertId > &closeVerts, int numNei, const ProgressCallback &progress={})
	Select orientation of given normals to make directions of close points consistent;.

MRMESH_API std::optional< VertNormals >	makeOrientedNormals (const PointCloud &pointCloud, float radius, const ProgressCallback &progress={})
	Makes normals for valid points of given point cloud; directions of close points are selected to be consistent;.

MRMESH_API std::optional< VertNormals >	makeOrientedNormals (const PointCloud &pointCloud, AllLocalTriangulations &triangs, const ProgressCallback &progress={})
	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.

MRMESH_API VertNormals	makeNormals (const PointCloud &pointCloud, int avgNeighborhoodSize=48)
	Makes consistent normals for valid points of given point cloud.

MRMESH_API float	findAvgPointsRadius (const PointCloud &pointCloud, int avgPoints, int samples=1024)
	Finds the radius of ball, so on average that ball contained avgPoints excluding the central point.

MRMESH_API bool	dilateRegion (const PointCloud &pointCloud, VertBitSet &region, float dilation, ProgressCallback cb={}, const AffineXf3f *xf=nullptr)
	expands the region on given euclidian distance. returns false if callback also returns false

MRMESH_API bool	erodeRegion (const PointCloud &pointCloud, VertBitSet &region, float erosion, ProgressCallback cb={}, const AffineXf3f *xf=nullptr)
	shrinks the region on given euclidian distance. returns false if callback also returns false

MRMESH_API bool	relax (PointCloud &pointCloud, const PointCloudRelaxParams &params={}, ProgressCallback cb={})

MRMESH_API bool	relaxKeepVolume (PointCloud &pointCloud, const PointCloudRelaxParams &params={}, ProgressCallback cb={})

MRMESH_API bool	relaxApprox (PointCloud &pointCloud, const PointCloudApproxRelaxParams &params={}, ProgressCallback cb={})

MRMESH_API std::optional< Mesh >	triangulatePointCloud (const PointCloud &pointCloud, const TriangulationParameters &params={}, ProgressCallback progressCb={})
	Creates mesh from given point cloud according params Returns empty optional if was interrupted by progress bar.

MRMESH_API MR::Vector3f	pickedPointToVector3 (const VisualObject *object, const PickedPoint &point)

MRMESH_API PickedPoint	pointOnObjectToPickedPoint (const VisualObject *object, const PointOnObject &pos)

MRMESH_API bool	isPickedPointValid (const VisualObject *object, const PickedPoint &point)

MRMESH_API void	findPointsInBall (const PointCloud &pointCloud, const Vector3f &center, float radius, const FoundPointCallback &foundCallback, const AffineXf3f *xf=nullptr)

MRMESH_API void	findPointsInBall (const Mesh &mesh, const Vector3f &center, float radius, const FoundPointCallback &foundCallback, const AffineXf3f *xf=nullptr)

MRMESH_API void	findPointsInBall (const AABBTreePoints &tree, const Vector3f &center, float radius, const FoundPointCallback &foundCallback, const AffineXf3f *xf=nullptr)

MRMESH_API PointsProjectionResult	findProjectionOnPoints (const Vector3f &pt, const PointCloud &pc, float upDistLimitSq=FLT_MAX, const AffineXf3f *xf=nullptr, float loDistLimitSq=0, VertPredicate skipCb={})
	computes the closest point on point cloud to given point

MRMESH_API void	findFewClosestPoints (const Vector3f &pt, const PointCloud &pc, FewSmallest< PointsProjectionResult > &res, float upDistLimitSq=FLT_MAX, const AffineXf3f *xf=nullptr, float loDistLimitSq=0)
	finds a number of the closest points in the cloud (as configured in

MRMESH_API Buffer< VertId >	findNClosestPointsPerPoint (const PointCloud &pc, int numNei, const ProgressCallback &progress={})
	finds given number of closest points (excluding itself) to each valid point in the cloud;

MRMESH_API VertPair	findTwoClosestPoints (const PointCloud &pc, const ProgressCallback &progress={})
	finds two closest points (first id < second id) in whole point cloud

MRMESH_API Expected< SimpleVolume >	pointsToDistanceVolume (const PointCloud &cloud, const PointsToDistanceVolumeParams &params)
	makes SimpleVolume filled with signed distances to points with normals

MRMESH_API Expected< VertColors >	calcAvgColors (const PointCloud &cloud, const VertColors &colors, const VertCoords &tgtPoints, const VertBitSet &tgtVerts, float sigma, const ProgressCallback &cb={})

MRMESH_API Expected< Mesh >	pointsToMeshFusion (const PointCloud &cloud, const PointsToMeshParameters &params)

MRMESH_API std::vector< EdgePointPair >	findCollidingEdgePairs (const Polyline2 &a, const Polyline2 &b, const AffineXf2f *rigidB2A=nullptr, bool firstIntersectionOnly=false)
	finds all pairs of colliding edges from two 2d polylines

MRMESH_API std::vector< UndirectedEdgeUndirectedEdge >	findCollidingEdges (const Polyline2 &a, const Polyline2 &b, const AffineXf2f *rigidB2A=nullptr, bool firstIntersectionOnly=false)
	finds all pairs of colliding edges from two 2d polylines

MRMESH_API std::pair< UndirectedEdgeBitSet, UndirectedEdgeBitSet >	findCollidingEdgesBitsets (const Polyline2 &a, const Polyline2 &b, const AffineXf2f *rigidB2A=nullptr)
	finds bitset per polyline with colliding edges

MRMESH_API std::vector< EdgePointPair >	findSelfCollidingEdgePairs (const Polyline2 &polyline)
	finds all pairs of colliding edges from 2d polyline

MRMESH_API std::vector< UndirectedEdgeUndirectedEdge >	findSelfCollidingEdges (const Polyline2 &polyline)
	finds all pairs of colliding edges from 2d polyline

MRMESH_API UndirectedEdgeBitSet	findSelfCollidingEdgesBS (const Polyline2 &polyline)
	finds the union of all self-intersecting edges

MRMESH_API bool	isInside (const Polyline2 &a, const Polyline2 &b, const AffineXf2f *rigidB2A=nullptr)
	checks that arbitrary 2d polyline A is inside of closed 2d polyline B

MRMESH_API bool	isPointInsidePolyline (const Polyline2 &polyline, const Vector2f &point)
	detect if given point is inside polyline, by counting ray intersections

MRMESH_API std::optional< PolylineIntersectionResult2 >	rayPolylineIntersect (const Polyline2 &polyline, const Line2f &line, float rayStart=0, float rayEnd=FLT_MAX, const IntersectionPrecomputes2< float > *prec=nullptr, bool closestIntersect=true)

MRMESH_API std::optional< PolylineIntersectionResult2 >	rayPolylineIntersect (const Polyline2 &polyline, const Line2d &line, double rayStart=0, double rayEnd=DBL_MAX, const IntersectionPrecomputes2< double > *prec=nullptr, bool closestIntersect=true)

MRMESH_API DecimatePolylineResult	decimatePolyline (Polyline2 &polyline, const DecimatePolylineSettings2 &settings={})
	Collapse edges in the polyline according to the settings.

MRMESH_API DecimatePolylineResult	decimatePolyline (Polyline3 &polyline, const DecimatePolylineSettings3 &settings={})

MRMESH_API DecimatePolylineResult	decimateContour (Contour2f &contour, const DecimatePolylineSettings2 &settings={})
	Collapse edges in the contour according to the settings.

MRMESH_API DecimatePolylineResult	decimateContour (Contour3f &contour, const DecimatePolylineSettings3 &settings={})

MRMESH_API PolylineProjectionResult2	findProjectionOnPolyline2 (const Vector2f &pt, const Polyline2 &polyline, float upDistLimitSq=FLT_MAX, AffineXf2f *xf=nullptr, float loDistLimitSq=0)
	computes the closest point on polyline to given point

MRMESH_API PolylineProjectionResult3	findProjectionOnPolyline (const Vector3f &pt, const Polyline3 &polyline, float upDistLimitSq=FLT_MAX, AffineXf3f *xf=nullptr, float loDistLimitSq=0)
	computes the closest point on polyline to given point

MRMESH_API PolylineProjectionResult3	findProjectionOnPolyline (const Line3f &ln, const Polyline3 &polyline, float upDistLimitSq=FLT_MAX, AffineXf3f *xf=nullptr, float loDistLimitSq=0)
	computes the closest point on polyline to given straight line

MRMESH_API Polyline2ProjectionWithOffsetResult	findProjectionOnPolyline2WithOffset (const Vector2f &pt, const Polyline2 &polyline, const Vector< float, UndirectedEdgeId > &offsetPerEdge, float upDistLimit=FLT_MAX, AffineXf2f *xf=nullptr, float loDistLimit=0)
	computes the closest point on polyline to given point, respecting each edge offset

MRMESH_API PolylineProjectionWithOffsetResult3	findProjectionOnPolylineWithOffset (const Vector3f &pt, const Polyline3 &polyline, const Vector< float, UndirectedEdgeId > &offsetPerEdge, float upDistLimit=FLT_MAX, AffineXf3f *xf=nullptr, float loDistLimit=0)
	computes the closest point on polyline to given point, respecting each edge offset

MRMESH_API void	findEdgesInBall (const Polyline2 &polyline, const Vector2f &center, float radius, const FoundEdgeCallback2 &foundCallback, AffineXf2f *xf=nullptr)
	Finds all edges of given polyline that cross or touch given ball (center, radius)

MRMESH_API void	findEdgesInBall (const Polyline3 &polyline, const Vector3f &center, float radius, const FoundEdgeCallback3 &foundCallback, AffineXf3f *xf=nullptr)
	Finds all edges of given polyline that cross or touch given ball (center, radius)

MRMESH_API void	findMeshEdgesInBall (const Mesh &mesh, const AABBTreePolyline3 &tree, const Vector3f &center, float radius, const FoundEdgeCallback3 &foundCallback, AffineXf3f *xf=nullptr)
	Finds all edges of given mesh edges (specified by the tree) that cross or touch given ball (center, radius)

MRMESH_API PolylineProjectionResult3	findProjectionOnMeshEdges (const Vector3f &pt, const Mesh &mesh, const AABBTreePolyline3 &tree, float upDistLimitSq=FLT_MAX, AffineXf3f *xf=nullptr, float loDistLimitSq=0)
	computes the closest point on the mesh edges (specified by the tree) to given point

MRMESH_API PolylineProjectionResult3	findProjectionOnMeshEdges (const Line3f &ln, const Mesh &mesh, const AABBTreePolyline3 &tree, float upDistLimitSq=FLT_MAX, AffineXf3f *xf=nullptr, float loDistLimitSq=0)
	computes the closest point on the mesh edges (specified by the tree) to given straight line

template<typename V >
bool	relax (Polyline< V > &polyline, const RelaxParams &params={}, ProgressCallback cb={})

template<typename V >
bool	relaxKeepArea (Polyline< V > &polyline, const RelaxParams &params={}, ProgressCallback cb={})

MRMESH_API int	subdividePolyline (Polyline2 &polyline, const PolylineSubdivideSettings &settings={})

MRMESH_API int	subdividePolyline (Polyline3 &polyline, const PolylineSubdivideSettings &settings={})

MRMESH_API EdgeBitSet	subdividePolylineWithPlane (Polyline3 &polyline, const Plane3f &plane, std::function< void(EdgeId, EdgeId, float)> onEdgeSplitCallback=nullptr)

MRMESH_API void	dividePolylineWithPlane (Polyline3 &polyline, const Plane3f &plane, const DividePolylineParameters &params={})

MRMESH_API std::vector< EdgeSegment >	extractSectionsFromPolyline (const Polyline3 &polyline, const Plane3f &plane, float eps)

MRMESH_API void	positionVertsSmoothly (Mesh &mesh, const VertBitSet &verts, EdgeWeights edgeWeightsType=EdgeWeights::Cotan, const VertBitSet *fixedSharpVertices=nullptr)

MRMESH_API void	positionVertsSmoothlySharpBd (Mesh &mesh, const VertBitSet &verts, const Vector< Vector3f, VertId > vertShifts=nullptr, const VertScalars vertStabilizers=nullptr)

MRMESH_API void	positionVertsWithSpacing (Mesh &mesh, const SpacingSettings &settings)
	Moves given vertices to make the distances between them as specified.

MRMESH_API void	inflate (Mesh &mesh, const VertBitSet &verts, const InflateSettings &settings)

MRMESH_API void	vertMapsComposition (VertMap &a2b, const VertMap &b2c)
	updates a2b map to a2c map using b2c map

MRMESH_API VertMap	vertMapsComposition (const VertMap &a2b, const VertMap &b2c)
	returns map a2c from a2b and b2c maps

MRMESH_API void	edgeMapsComposition (EdgeMap &a2b, const EdgeMap &b2c)
	updates a2b map to a2c map using b2c map

MRMESH_API EdgeMap	edgeMapsComposition (const EdgeMap &a2b, const EdgeMap &b2c)
	returns map a2c from a2b and b2c maps

MRMESH_API void	faceMapsComposition (FaceMap &a2b, const FaceMap &b2c)
	updates a2b map to a2c map using b2c map

MRMESH_API FaceMap	faceMapsComposition (const FaceMap &a2b, const FaceMap &b2c)
	returns map a2c from a2b and b2c maps

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

bool	reportProgress (ProgressCallback cb, float v)
	safely invokes

bool	reportProgress (ProgressCallback cb, float v, size_t counter, int divider)

template<typename F >
bool	reportProgress (ProgressCallback cb, F &&f)

template<typename F >
bool	reportProgress (ProgressCallback cb, F &&f, size_t counter, int divider)

ProgressCallback	subprogress (ProgressCallback cb, float from, float to)
	returns a callback that maps [0,1] linearly into [from,to] in the call to

template<typename F >
ProgressCallback	subprogress (ProgressCallback cb, F &&f)
	returns a callback that maps the value with given function

ProgressCallback	subprogress (ProgressCallback cb, size_t index, size_t count)
	returns a callback that maps [0,1] linearly into [(index+0)/count,(index+1)/count] in the call to

MRMESH_API bool	writeByBlocks (std::ostream &out, const char *data, size_t dataSize, ProgressCallback callback={}, size_t blockSize=(size_t(1)<< 16))
	write dataSize bytes from data to out stream by blocks blockSize bytes

MRMESH_API bool	readByBlocks (std::istream &in, char *data, size_t dataSize, ProgressCallback callback={}, size_t blockSize=(size_t(1)<< 16))
	read dataSize bytes from in stream to data by blocks blockSize bytes

template<typename E >
void	throwExceptionFromExpected (const E &err)

template<typename R , typename E , typename... Args>
auto	decorateExpected (std::function< Expected< R, E >(Args...)> &&f) -> std::function< R(Args...)>

template<typename F >
auto	decorateExpected (F &&f)

template<typename R , typename T , typename... Args>
auto	decorateExpected (R(T::*memFunction)(Args...))

template<typename T >
bool	rayBoxIntersect (const Box3< T > &box, const RayOrigin< T > &rayOrigin, T &t0, T &t1, const IntersectionPrecomputes< T > &prec)

template<typename T = float>
bool	rayBoxIntersect (const Box3< T > &box, const Line3< T > &line, T t0, T t1)

template<typename T >
bool	rayBoxIntersect (const Box2< T > &box, const Vector2< T > &rayOrigin, T &t0, T &t1, const IntersectionPrecomputes2< T > &prec)

template<typename T = float>
bool	rayBoxIntersect (const Box2< T > &box, const Line2< T > &line, T t0, T t1)

OutEdge2	opposite (OutEdge2 e)

MRMESH_API void	expandPixelMask (PixelBitSet &mask, const RectIndexer &indexer, int expansion=1)
	expands PixelBitSet with given number of steps

MRMESH_API void	shrinkPixelMask (PixelBitSet &mask, const RectIndexer &indexer, int shrinkage=1)
	shrinks PixelBitSet with given number of steps

MRMESH_API EdgeLoop	trackLeftBoundaryLoop (const MeshTopology &topology, EdgeId e0, const FaceBitSet *region=nullptr)

EdgeLoop	trackLeftBoundaryLoop (const MeshTopology &topology, const FaceBitSet &region, EdgeId e0)

MRMESH_API EdgeLoop	trackRightBoundaryLoop (const MeshTopology &topology, EdgeId e0, const FaceBitSet *region=nullptr)

EdgeLoop	trackRightBoundaryLoop (const MeshTopology &topology, const FaceBitSet &region, EdgeId e0)

MRMESH_API std::vector< EdgeLoop >	findLeftBoundary (const MeshTopology &topology, const FaceBitSet *region=nullptr)

std::vector< EdgeLoop >	findLeftBoundary (const MeshTopology &topology, const FaceBitSet &region)

MRMESH_API std::vector< EdgeLoop >	findRightBoundary (const MeshTopology &topology, const FaceBitSet *region=nullptr)

std::vector< EdgeLoop >	findRightBoundary (const MeshTopology &topology, const FaceBitSet &region)

MRMESH_API std::vector< EdgeLoop >	delRegionKeepBd (Mesh &mesh, const FaceBitSet *region=nullptr)

std::vector< EdgeLoop >	delRegionKeepBd (Mesh &mesh, const FaceBitSet &region)

MRMESH_API std::vector< EdgePath >	findLeftBoundaryInsideMesh (const MeshTopology &topology, const FaceBitSet &region)

MRMESH_API UndirectedEdgeBitSet	findRegionBoundaryUndirectedEdgesInsideMesh (const MeshTopology &topology, const 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

MRMESH_API FaceBitSet	findRegionOuterFaces (const MeshTopology &topology, const FaceBitSet &region)

MRMESH_API VertBitSet	getIncidentVerts (const MeshTopology &topology, const FaceBitSet &faces)
	composes the set of all vertices incident to given faces

MRMESH_API const VertBitSet &	getIncidentVerts (const MeshTopology &topology, const FaceBitSet *faces, VertBitSet &store)

MRMESH_API VertBitSet	getInnerVerts (const MeshTopology &topology, const FaceBitSet *region=nullptr)
	composes the set of all vertices not on the boundary of a hole and with all their adjacent faces in given set

MRMESH_API VertBitSet	getInnerVerts (const MeshTopology &topology, const FaceBitSet &region)
	composes the set of all vertices not on the boundary of a hole and with all their adjacent faces in given set

MRMESH_API VertBitSet	getBoundaryVerts (const MeshTopology &topology, const FaceBitSet *region=nullptr)
	composes the set of all boundary vertices for given region (or whole mesh if !region)

MRMESH_API VertBitSet	getRegionBoundaryVerts (const MeshTopology &topology, const FaceBitSet &region)

MRMESH_API FaceBitSet	getIncidentFaces (const MeshTopology &topology, const VertBitSet &verts)
	composes the set of all faces incident to given vertices

MRMESH_API FaceBitSet	getInnerFaces (const MeshTopology &topology, const VertBitSet &verts)
	composes the set of all faces with all their vertices in given set

MRMESH_API EdgeBitSet	getRegionEdges (const MeshTopology &topology, const FaceBitSet &faces)
	composes the set of all edges, having a face from given set at the left

MRMESH_API UndirectedEdgeBitSet	getIncidentEdges (const MeshTopology &topology, const FaceBitSet &faces)
	composes the set of all undirected edges, having a face from given set from one of two sides

MRMESH_API UndirectedEdgeBitSet	getIncidentEdges (const MeshTopology &topology, const UndirectedEdgeBitSet &edges)
	composes the set of all undirected edges, having at least one common vertex with an edge from given set

MRMESH_API VertBitSet	getIncidentVerts (const MeshTopology &topology, const UndirectedEdgeBitSet &edges)
	composes the set of all vertices incident to given edges

MRMESH_API FaceBitSet	getIncidentFaces (const MeshTopology &topology, const UndirectedEdgeBitSet &edges)
	composes the set of all faces incident to given edges

MRMESH_API FaceBitSet	getNeighborFaces (const MeshTopology &topology, const UndirectedEdgeBitSet &edges)
	composes the set of all left and right faces of given edges

MRMESH_API UndirectedEdgeBitSet	getInnerEdges (const MeshTopology &topology, const VertBitSet &verts)
	composes the set of all edges with all their vertices in given set

MRMESH_API const VertBitSet &	getIncidentVerts (const MeshTopology &topology, const UndirectedEdgeBitSet *edges, VertBitSet &store)

MRMESH_API VertBitSet	getInnerVerts (const MeshTopology &topology, const UndirectedEdgeBitSet &edges)
	composes the set of all vertices with all their edges in given set

MRMESH_API Expected< Mesh >	makeRegularGridMesh (size_t width, size_t height, const RegularGridLatticeValidator &validator, const RegularGridLatticePositioner &positioner, const RegularGridMeshFaceValidator &faceValidator={}, ProgressCallback cb={})

MRMESH_API Expected< Mesh >	makeRegularGridMesh (VertCoords pc, ProgressCallback cb={})

template<typename V >
V	getLimitedPos (const V &pos, const V &guidePos, typename VectorTraits< V >::BaseType maxGuideDistSq)

MRMESH_API void	redirectSTDStreamsToLogger ()

template<typename N >
bool	operator== (const RingIterator< N > &a, const RingIterator< N > &b)

template<typename N >
bool	operator!= (const RingIterator< N > &a, const RingIterator< N > &b)

IteratorRange< OrgRingIterator >	orgRing (const MeshTopology &topology, EdgeId edge)

IteratorRange< OrgRingIterator >	orgRing0 (const MeshTopology &topology, EdgeId edge)

IteratorRange< LeftRingIterator >	leftRing (const MeshTopology &topology, EdgeId edge)

IteratorRange< LeftRingIterator >	leftRing0 (const MeshTopology &topology, EdgeId edge)

Vector3f	applyFloat (const AffineXf3d *xf, const Vector3f &p)
	returns the point as is or after application of given transform to it in double precision

Vector3f	applyFloat (const Matrix3d *m, const Vector3f &n)
	returns the normal as is or after application of given matrix to it in double precision

Vector3d	applyDouble (const AffineXf3d *xf, const Vector3f &p)
	converts given point in double precision and applies given transformation to it

Vector3d	applyDouble (const Matrix3d *m, const Vector3f &n)
	converts given normal in double precision and applies given matrix to it

MRMESH_API const VertCoords &	transformPoints (const VertCoords &verts, const VertBitSet &validVerts, const AffineXf3d xf, VertCoords &buf, const VertRenumber vertRenumber=nullptr)

MRMESH_API const VertNormals &	transformNormals (const VertNormals &normals, const VertBitSet &validVerts, const Matrix3d *m, VertNormals &buf)

MRMESH_API std::shared_ptr< SceneRootObject >	createRootFormObject (std::shared_ptr< Object > obj)

MRMESH_API Expected< Json::Value >	deserializeJsonValue (std::istream &in)

MRMESH_API Expected< Json::Value >	deserializeJsonValue (const std::string &str)

MRMESH_API Expected< Json::Value >	deserializeJsonValue (const std::filesystem::path &path)

MRMESH_API VoidOrErrStr	serializeObjectTree (const Object &object, const std::filesystem::path &path, ProgressCallback progress={}, FolderCallback preCompress={})
	saves object subtree in given scene file (zip/mru)

MRMESH_API Expected< std::shared_ptr< Object > >	deserializeObjectTree (const std::filesystem::path &path, FolderCallback postDecompress={}, ProgressCallback progressCb={})
	loads objects tree from given scene file (zip/mru)

MRMESH_API Expected< std::shared_ptr< Object > >	deserializeObjectTreeFromFolder (const std::filesystem::path &folder, ProgressCallback progressCb={})
	loads objects tree from given scene folder

MRMESH_API VoidOrErrStr	serializeMesh (const Mesh &mesh, const std::filesystem::path &path, const FaceBitSet selection=nullptr, const char saveMeshFormat=".mrmesh")

MRMESH_API void	serializeToJson (const Vector2i &vec, Json::Value &root)
	saves an object into json value

MRMESH_API void	serializeToJson (const Vector2f &vec, Json::Value &root)

MRMESH_API void	serializeToJson (const Vector3i &vec, Json::Value &root)

MRMESH_API void	serializeToJson (const Vector3f &vec, Json::Value &root)

MRMESH_API void	serializeToJson (const Vector4f &vec, Json::Value &root)

MRMESH_API void	serializeToJson (const Box3i &box, Json::Value &root)

MRMESH_API void	serializeToJson (const Box3f &box, Json::Value &root)

MRMESH_API void	serializeToJson (const Color &col, Json::Value &root)

MRMESH_API void	serializeToJson (const Matrix2f &matrix, Json::Value &root, bool skipIdentity=true)

MRMESH_API void	serializeToJson (const Matrix3f &matrix, Json::Value &root, bool skipIdentity=true)

MRMESH_API void	serializeToJson (const AffineXf2f &xf, Json::Value &root, bool skipIdentity=true)

MRMESH_API void	serializeToJson (const AffineXf3f &xf, Json::Value &root, bool skipIdentity=true)

MRMESH_API void	serializeToJson (const BitSet &bitset, Json::Value &root)

MRMESH_API VoidOrErrStr	serializeToJson (const Mesh &mesh, Json::Value &root)

MRMESH_API void	serializeToJson (const Plane3f &plane, Json::Value &root)

MRMESH_API void	serializeToJson (const TriPointf &tp, Json::Value &root)

MRMESH_API void	serializeToJson (const MeshTexture &texture, Json::Value &root)

MRMESH_API void	serializeToJson (const std::vector< TextureId > &texturePerFace, Json::Value &root)

MRMESH_API void	serializeToJson (const std::vector< UVCoord > &uvCoords, Json::Value &root)

MRMESH_API void	serializeToJson (const std::vector< Color > &colors, Json::Value &root)

MRMESH_API void	serializeToJson (const MeshTriPoint &mtp, const MeshTopology &topology, Json::Value &root)

MRMESH_API void	serializeToJson (const PointOnFace &pf, Json::Value &root)

MRMESH_API void	serializeViaVerticesToJson (const UndirectedEdgeBitSet &edges, const MeshTopology &topology, Json::Value &root)

MRMESH_API void	deserializeViaVerticesFromJson (const Json::Value &root, UndirectedEdgeBitSet &edges, const

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions