MR Namespace Reference

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	SceneSave
namespace	SelfIntersections
namespace	StyleConsts
namespace	TriangulationHelpers
namespace	UI
namespace	UnitSettings
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	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	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	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	FileDialogSignals
	This structure contains global signals for file dialogs, that are called on valid selection of file or folder. More...
struct	FileLoadOptions
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
struct	FlatTree
class	FlowAggregator
	this class can track multiple flows and find in each mesh vertex the amount of water reached it More...
struct	FlowOrigin
class	FormatRegistry
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
class	MarchingCubesByParts
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	MeshAttributes
struct	MeshAttributesToUpdate
class	MeshDiff
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
struct	MeshMeshDistanceResult
struct	MeshMeshSignedDistanceResult
class	MeshModifier
struct	MeshNormals
class	MeshOnVoxelsT
class	MeshOrPoints
struct	MeshOrPointsXf
	an object and its transformation to global space with other objects More...
struct	MeshPoint
	describes the point of measurement on mesh More...
struct	MeshProjectionResult
struct	MeshRegion
struct	MeshRelaxParams
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
struct	MultiRayMeshIntersectResult
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	NotificationTags
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	OriginAndDimensions
	shift of zero voxel in 3D space and dimensions of voxel-grid 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) = a*x*x + 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
struct	RebuildMeshSettings
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	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...
struct	SceneReorder
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	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	SliceInfo
struct	SliceInfoBase
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	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
struct	SystemMemory
class	SystemPath
	system directory path manager More...
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	TypedFlatTree
struct	UiRenderManager
struct	UiRenderParams
class	UndirectedEdgeIterator
struct	UndirectedEdgeUndirectedEdge
class	UnifiedPythonStream
struct	UniformSamplingSettings
class	UnionFind
	Simple union find data structure. More...
struct	UniquePtr
class	UniqueTemporaryFolder
	helper class to create a temporary folder; the folder will be removed on the object's destruction More...
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< std::vector< T > > >
	VoxelsVolumeAccessor specialization for simple volumes.
class	VoxelsVolumeAccessor< VoxelsVolume< VoxelValueGetter< T > > >
	VoxelsVolumeAccessor specialization for value getters. More...
class	VoxelsVolumeAccessor< VoxelsVolumeMinMax< std::vector< T > > >
	VoxelsVolumeAccessor specialization for simple volumes with min/max.
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	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	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	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>
using	EdgeLoops = std::vector<EdgeLoop>
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>
using	MinMaxf = MinMax<float>
using	MinMaxd = MinMax<double>
template<typename T >
using	Box1 = Box<T>
template<typename T >
using	Box2 = Box<Vector2<T>>
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>
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	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	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	NotificationTagMask = unsigned
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	VoxelPointPositioner = std::function<Vector3f( const Vector3f&, const Vector3f&, float, float, float )>
using	MeshOnVoxels = MeshOnVoxelsT<Mesh>
using	MeshOnVoxelsC = MeshOnVoxelsT<const Mesh>
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	FloatGrid = std::shared_ptr<OpenVdbFloatGrid>
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	OffsetMode : int { Smooth , Standard , Sharpening }
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	SignDetectionModeShort { Auto , HoleWindingNumber , ProjectionNormal }
	how to determine the sign of distances from a mesh, short version including auto-detection 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	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	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 , Time ,   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	RibbonLayoutMode { None , SceneTree , All }
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 , meters , 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 , metersPerSecond , inchesPerSecond , _count }
enum class	AreaUnit { mm2 , meters2 , inches2 , _count }
enum class	VolumeUnit { mm3 , meters3 , inches3 , _count }
enum class	InvLengthUnit { inv_mm , inv_meters , inv_inches , _count }
enum class	NumberStyle { normal , distributePrecision , exponential , maybeExponential }
enum class	DegreesMode { degrees , degreesMinutes , degreesMinutesSeconds , _count }
enum class	ScalarType {   UInt8 , Int8 , UInt16 , Int16 ,   UInt32 , Int32 , UInt64 , Int64 ,   Float32 , Float64 , Float32_4 , Unknown ,   Count }
	scalar value's binary format type More...
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	VoxelFilterType : int { Median , Mean , Gaussian }
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...

Functions
MRIOEXTRAS_API Expected< std::shared_ptr< Object > >	deserializeObjectTreeFrom3mf (const std::filesystem::path &file, std::string *loadWarn=nullptr, ProgressCallback callback={})
MRIOEXTRAS_API Expected< std::shared_ptr< Object > >	deserializeObjectTreeFromModel (const std::filesystem::path &file, std::string *loadWarn=nullptr, ProgressCallback callback={})
MRIOEXTRAS_API Expected< std::shared_ptr< Object > >	deserializeObjectTreeFromGltf (const std::filesystem::path &file, ProgressCallback callback={})
MRIOEXTRAS_API Expected< void >	serializeObjectTreeToGltf (const Object &root, const std::filesystem::path &file, ProgressCallback callback={})
MRIOEXTRAS_API void	loadIOExtras ()
MRIOEXTRAS_API Expected< void >	zlibCompressStream (std::istream &in, std::ostream &out, int level=-1)
	compress the input data using the Deflate algorithm
MRIOEXTRAS_API Expected< void >	zlibDecompressStream (std::istream &in, std::ostream &out)
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)
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 Expected< void >	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<size_t I, typename V >
constexpr const V &	get (const Box< V > &box) noexcept
	get<0> returns min, get<1> returns max
template<size_t I, typename V >
constexpr V &	get (Box< V > &box) noexcept
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, VertId firstVert, VertId lastVert, const VertBitSet *region=nullptr, 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)
template<typename V >
Box< V >	computeBoundingBox (const Vector< V, VertId > &points, const VertBitSet &region, const AffineXf< V > *toWorld=nullptr)
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 Expected< DistanceMap >	convertImageToDistanceMap (const Image &image, 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	expand (const MeshTopology &topology, VertBitSet &region, int hops=1)
MRMESH_API VertBitSet	expand (const MeshTopology &topology, VertId v, int hops)
	returns the region of all vertices within given number of hops (stars) from the initial vertex
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 void	shrink (const MeshTopology &topology, VertBitSet &region, int hops=1)
	removes from the region all vertices 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 >
MR_BIND_IGNORE auto	unexpected (E &&e)
MR_BIND_IGNORE std::string	stringOperationCanceled ()
	Common operation canceled line for all.
MR_BIND_IGNORE 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.
MR_BIND_IGNORE 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 Expected< void >	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 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 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
MRMESH_API IOFilters	operator| (const IOFilters &a, const IOFilters &b)
	returns union of input filters
MRMESH_API std::optional< IOFilter >	findFilter (const IOFilters &filters, const std::string &extension)
	find a corresponding filter for a given extension
MRMESH_API std::vector< size_t >	splitByLines (const char *data, size_t size)
MRMESH_API std::streamoff	getStreamSize (std::istream &in)
MRMESH_API Expected< std::string >	readString (std::istream &in)
MR_BIND_IGNORE MRMESH_API Expected< Buffer< char > >	readCharBuffer (std::istream &in)
template<typename T >
Expected< void >	parseTextCoordinate (const std::string_view &str, Vector3< T > &v, Vector3< T > *n=nullptr, Color *c=nullptr)
template<typename T >
Expected< void >	parseObjCoordinate (const std::string_view &str, Vector3< T > &v, Vector3< T > *c=nullptr)
template<typename T >
Expected< void >	parsePtsCoordinate (const std::string_view &str, Vector3< T > &v, Color &c)
MRMESH_API Expected< void >	parseFirstNum (const std::string_view &str, int &num)
MRMESH_API Expected< void >	parsePolygon (const std::string_view &str, VertId *vertId, int *numPoints)
template<typename T >
Expected< void >	parseAscCoordinate (const std::string_view &str, Vector3< T > &v, Vector3< T > *n=nullptr, Color *c=nullptr)
template<typename T >
Expected< void >	parseSingleNumber (const std::string_view &str, T &num)
MR_BIND_IGNORE MRMESH_API std::unique_ptr< IRenderObject >	createRenderObject (const VisualObject &visObj, const std::type_index &type)
template<typename ObjectType >
MR_BIND_IGNORE std::unique_ptr< IRenderObject >	createRenderObject (const VisualObject &visObj)
template<typename RenderObjType >
MR_BIND_IGNORE 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)
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 std::vector< EdgeTri >	findCollidingEdgeTrisPrecise (const Mesh &a, const std::vector< FaceId > &facesA, const Mesh &b, const std::vector< EdgeId > &edgesB, ConvertToIntVector conv, const AffineXf3f *rigidB2A=nullptr)
	finds all intersections between every given triangle from A and given edge 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 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 void	processCloseTriangles (const MeshPart &mp, const Triangle3f &t, float rangeSq, const TriangleCallback &call)
MRMESH_API std::optional< float >	signedDistanceToMesh (const MeshPart &mp, const Vector3f &p, const DistanceToMeshOptions &op)
MR_BIND_IGNORE MRMESH_API MeshTopology	topologyFromEigen (const Eigen::MatrixXi &F)
	constructs mesh topology from N*3 matrix of vertex indices
MR_BIND_IGNORE MRMESH_API Mesh	meshFromEigen (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F)
	constructs mesh from M*3 matrix of coordinates and N*3 matrix of vertex indices
MR_BIND_IGNORE MRMESH_API void	pointsFromEigen (const Eigen::MatrixXd &V, const VertBitSet &selection, VertCoords &points)
	replace selected points with the values from V
MR_BIND_IGNORE MRMESH_API void	topologyToEigen (const MeshTopology &topology, Eigen::MatrixXi &F)
	converts valid faces from mesh topology into N*3 matrix of vertex indices
MR_BIND_IGNORE MRMESH_API void	meshToEigen (const Mesh &mesh, Eigen::MatrixXd &V, Eigen::MatrixXi &F)
	converts mesh into M*3 matrix of coordinates and N*3 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 MRMESH_CLASS)
	Box< int > (Box1ll, Box< long long >)(Box1f
	Box< float > (Box1d, Box< double >)(Box2i
	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 MinMax
	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 T > struct), MRMESH_CLASS MeshRegion,(MeshPart, MeshRegion< FaceTag >)(MeshVertPart, MeshRegion< VertTag >)) template< typename T > class UniqueThreadSafeOwner
	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 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 void	multiRayMeshIntersect (const MeshPart &meshPart, const std::vector< Vector3f > &origins, const std::vector< Vector3f > &dirs, const MultiRayMeshIntersectResult &result, float rayStart=0.0f, float rayEnd=FLT_MAX, 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 MeshMeshDistanceResult	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 MeshMeshSignedDistanceResult	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 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 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 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 Expected< void >	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)
MRMESH_API std::shared_ptr< ObjectPoints >	pack (const ObjectPoints &pts, Reorder reorder, VertBitSet *newValidVerts=nullptr, const ProgressCallback &cb={})
bool	objectHasSelectableChildren (const MR::Object &object)
MRMESH_API Expected< void >	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< void >	serializeObjectTree (const Object &object, const std::filesystem::path &path, ProgressCallback progress={})
MRMESH_API Contours2f	offsetContours (const Contours2f &contours, float offset, const OffsetContoursParams &params={})
	offsets 2d contours in plane
MRMESH_API Contours2f	offsetContours (const Contours2f &contours, ContoursVariableOffset offset, const OffsetContoursParams &params={})
	offsets 2d contours in plane
MRMESH_API Contours3f	offsetContours (const Contours3f &contours, float offset, const OffsetContoursParams &params={}, const OffsetContoursRestoreZParams &zParmas={})
	offsets 3d contours in XY plane
MRMESH_API Contours3f	offsetContours (const Contours3f &contours, ContoursVariableOffset offset, const OffsetContoursParams &params={}, const OffsetContoursRestoreZParams &zParmas={})
	offsets 3d contours in XY plane
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 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 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 F >
bool	projectVertAttribute (const MeshVertPart &mp, const Mesh &oldMesh, F &&func, ProgressCallback progressCb)
template<typename F >
bool	projectFaceAttribute (const MeshPart &mp, const Mesh &oldMesh, F &&func, ProgressCallback progressCb)
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 UndirectedEdgeBitSet	getInnerEdges (const MeshTopology &topology, const FaceBitSet &region)
	composes the set of all edges having both left and right in given region
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 >	orgRing (const MeshTopology &topology, VertId v)
IteratorRange< OrgRingIterator >	orgRing0 (const MeshTopology &topology, EdgeId edge)
IteratorRange< LeftRingIterator >	leftRing (const MeshTopology &topology, EdgeId edge)
IteratorRange< LeftRingIterator >	leftRing (const MeshTopology &topology, FaceId f)
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 Expected< void >	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 Expected< void >	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 MeshTopology &topology)
MRMESH_API void	deserializeFromJson (const Json::Value &root, Vector2i &vec)
	loads an object from json value
MRMESH_API void	deserializeFromJson (const Json::Value &root, Vector2f &vec)
MRMESH_API void	deserializeFromJson (const Json::Value &root, Vector3i &vec)
MRMESH_API void	deserializeFromJson (const Json::Value &root, Vector3f &vec)
MRMESH_API void	deserializeFromJson (const Json::Value &root, Vector4f &vec)
MRMESH_API void	deserializeFromJson (const Json::Value &root, Color &col)
MRMESH_API void	deserializeFromJson (const Json::Value &root, Matrix2f &matrix)
MRMESH_API void	deserializeFromJson (const Json::Value &root, Matrix3f &matrix)
MRMESH_API void	deserializeFromJson (const Json::Value &root, AffineXf2f &xf)
MRMESH_API void	deserializeFromJson (const Json::Value &root, AffineXf3f &xf)
MRMESH_API void	deserializeFromJson (const Json::Value &root, BitSet &bitset)
MRMESH_API Expected< Mesh >	deserializeFromJson (const Json::Value &root, VertColors *colors=nullptr)
MRMESH_API void	deserializeFromJson (const Json::Value &root, Plane3f &plane)
MRMESH_API void	deserializeFromJson (const Json::Value &root, TriPointf &tp)
MRMESH_API void	deserializeFromJson (const Json::Value &root, MeshTexture &texture)
MRMESH_API void	deserializeFromJson (const Json::Value &root, std::vector< TextureId > &texturePerFace)
MRMESH_API void	deserializeFromJson (const Json::Value &root, std::vector< UVCoord > &uvCoords)
MRMESH_API void	deserializeFromJson (const Json::Value &root, std::vector< Color > &colors)
MRMESH_API void	deserializeFromJson (const Json::Value &root, MeshTriPoint &mtp, const MeshTopology &topology)
MRMESH_API void	deserializeFromJson (const Json::Value &root, PointOnFace &pf)
MRMESH_API void	sharpenMarchingCubesMesh (const MeshPart &ref, Mesh &vox, Vector< VoxelId, FaceId > &face2voxel, const SharpenMarchingCubesMeshSettings &settings)
MRMESH_API const char *	asString (SignDetectionMode m)
	returns string representation of enum values
MRMESH_API std::vector< Vector3f >	sampleHalfSphere ()
	returns quasi-uniform 145 samples on unit half-sphere z>0
MRMESH_API VertScalars	computeSkyViewFactor (const Mesh &terrain, const VertCoords &samples, const VertBitSet &validSamples, const std::vector< SkyPatch > &skyPatches, BitSet *outSkyRays=nullptr, std::vector< MeshIntersectionResult > *outIntersections=nullptr)
MRMESH_API BitSet	findSkyRays (const Mesh &terrain, const VertCoords &samples, const VertBitSet &validSamples, const std::vector< SkyPatch > &skyPatches, std::vector< MeshIntersectionResult > *outIntersections=nullptr)
std::string	getCurrentStacktraceInline ()
MRMESH_API void	printStacktraceOnCrash ()
	Print stacktrace on application crash.
template<typename T >
std::ostream &	operator<< (std::ostream &s, const Vector2< T > &vec)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const Vector3< T > &vec)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const Vector4< T > &vec)
template<typename T >
std::istream &	operator>> (std::istream &s, Vector2< T > &vec)
template<typename T >
std::istream &	operator>> (std::istream &s, Vector3< T > &vec)
template<typename T >
std::istream &	operator>> (std::istream &s, Vector4< T > &vec)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const Matrix3< T > &mat)
template<typename T >
std::istream &	operator>> (std::istream &s, Matrix3< T > &mat)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const Matrix4< T > &mat)
template<typename T >
std::istream &	operator>> (std::istream &s, Matrix4< T > &mat)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const Plane3< T > &pl)
template<typename T >
std::istream &	operator>> (std::istream &s, Plane3< T > &pl)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const Line3< T > &l)
template<typename T >
std::istream &	operator>> (std::istream &s, Line3< T > &l)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const TriPoint< T > &tp)
template<typename T >
std::istream &	operator>> (std::istream &s, TriPoint< T > &tp)
template<typename T >
std::ostream &	operator<< (std::ostream &s, const AffineXf3< T > &xf)
template<typename T >
std::istream &	operator>> (std::istream &s, AffineXf3< T > &xf)
std::ostream &	operator<< (std::ostream &s, const PointOnFace &pof)
std::istream &	operator>> (std::istream &s, PointOnFace &pof)
template<typename V >
std::ostream &	operator<< (std::ostream &s, const Box< V > &box)
template<typename V >
std::istream &	operator>> (std::istream &s, Box< V > &box)
MRMESH_API size_t	findSubstringCaseInsensitive (const std::string &string, const std::string &substring)
MRMESH_API int	calcDamerauLevenshteinDistance (const std::string &stringA, const std::string &stringB, bool caseSensitive=true, int *outLeftRightAddition=nullptr)
MRMESH_API std::vector< std::string >	split (const std::string &string, const std::string &delimiter)
template<typename F >
bool	split (std::string_view str, std::string_view sep, F &&func)
MRMESH_API std::string	replace (std::string target, std::string_view from, std::string_view to)
	Returns.
MRMESH_API void	replaceInplace (std::string &target, std::string_view from, std::string_view to)
	Replaces.
MRMESH_API std::string_view	trimRight (std::string_view str)
	Removes all whitespace character (detected by std::isspace) at the end of string view.
MRMESH_API std::wstring	utf8ToWide (const char *utf8)
	converts UTF8-encoded string into UTF16-encoded string
MRMESH_API std::string	systemToUtf8 (const std::string &system)
	converts system encoded string to UTF8-encoded string
MRMESH_API std::string	utf8ToSystem (const std::string &utf8)
MRMESH_API std::string	wideToUtf8 (const wchar_t *wide)
	converts wide null terminating string to UTF8-encoded string
const std::string &	asString (const std::string &s)
const std::string &	asU8String (const std::string &s)
std::string	asString (std::string &&s)
std::string	asU8String (std::string &&s)
std::filesystem::path	pathFromUtf8 (const std::string &s)
std::filesystem::path	pathFromUtf8 (const char *s)
std::string	utf8string (const std::filesystem::path &path)
	returns filename as UTF8-encoded string
MRMESH_API std::string	bytesString (size_t size)
MRMESH_API bool	hasProhibitedChars (const std::string &line)
	returns true if line contains any of OS prohibited chars ('?', '*', '/', '\', '"', '<', '>')
MRMESH_API std::string	replaceProhibitedChars (const std::string &line, char replacement='_')
	replace OS prohibited chars ('?', '*', '/', '\', '"', '<', '>') with replacement char
template<typename T >
Expected< T >	addFileNameInError (Expected< T > v, const std::filesystem::path &file)
	if (v) contains an error, then appends given file name to that error
MRMESH_API std::string	commonFilesName (const std::vector< std::filesystem::path > &files)
MRMESH_API char *	formatNoTrailingZeros (char *fmt, double v, int digitsAfterPoint, int precision=6)
MRMESH_API double	roundToPrecision (double v, int precision)
	returns given value rounded to given number of decimal digits
float	roundToPrecision (float v, int precision)
	returns given value rounded to given number of decimal digits
std::string	getCancelMessage (const std::filesystem::path &path)
MRMESH_API std::string	toLower (std::string str)
	return a copy of the string with all alphabetic characters replaced with upper-case variants
MRMESH_API VertScalars	computeSurfaceDistances (const Mesh &mesh, const VertBitSet &startVertices, float maxDist=FLT_MAX, const VertBitSet *region=nullptr, int maxVertUpdates=3)
MRMESH_API VertScalars	computeSurfaceDistances (const Mesh &mesh, const VertBitSet &startVertices, const VertBitSet &targetVertices, float maxDist=FLT_MAX, const VertBitSet *region=nullptr, int maxVertUpdates=3)
MRMESH_API VertScalars	computeSurfaceDistances (const Mesh &mesh, const HashMap< VertId, float > &startVertices, float maxDist=FLT_MAX, const VertBitSet *region=nullptr, int maxVertUpdates=3)
MRMESH_API VertScalars	computeSurfaceDistances (const Mesh &mesh, const MeshTriPoint &start, const MeshTriPoint &end, const VertBitSet *region=nullptr, bool *endReached=nullptr, int maxVertUpdates=3)
MRMESH_API VertScalars	computeSurfaceDistances (const Mesh &mesh, const MeshTriPoint &start, float maxDist=FLT_MAX, const VertBitSet *region=nullptr, int maxVertUpdates=3)
MRMESH_API VertScalars	computeSurfaceDistances (const Mesh &mesh, const std::vector< MeshTriPoint > &starts, float maxDist=FLT_MAX, const VertBitSet *region=nullptr, int maxVertUpdates=3)
bool	operator< (const VertDistance &a, const VertDistance &b)
	smaller distance to be the first
std::string	toString (PathError error)
MRMESH_API Expected< SurfacePath, PathError >	computeSurfacePath (const MeshPart &mp, const MeshTriPoint &start, const MeshTriPoint &end, int maxGeodesicIters=5, const VertBitSet *vertRegion=nullptr, VertScalars *outSurfaceDistances=nullptr)
MRMESH_API Expected< SurfacePath, PathError >	computeGeodesicPath (const Mesh &mesh, const MeshTriPoint &start, const MeshTriPoint &end, GeodesicPathApprox atype, int maxGeodesicIters=100)
	the maximum number of iterations to reduce approximate path length and convert it in geodesic path
MRMESH_API Expected< SurfacePath, PathError >	computeGeodesicPathApprox (const Mesh &mesh, const MeshTriPoint &start, const MeshTriPoint &end, GeodesicPathApprox atype)
MRMESH_API Expected< SurfacePath, PathError >	computeFastMarchingPath (const MeshPart &mp, const MeshTriPoint &start, const MeshTriPoint &end, const VertBitSet *vertRegion=nullptr, VertScalars *outSurfaceDistances=nullptr)
MRMESH_API SurfacePath	computeSteepestDescentPath (const MeshPart &mp, const VertScalars &field, const MeshTriPoint &start, const ComputeSteepestDescentPathSettings &settings={})
MRMESH_API void	computeSteepestDescentPath (const MeshPart &mp, const VertScalars &field, const MeshTriPoint &start, SurfacePath *outPath, const ComputeSteepestDescentPathSettings &settings={})
MRMESH_API MeshEdgePoint	findSteepestDescentPoint (const MeshPart &mp, const VertScalars &field, VertId v)
	finds the point along minus maximal gradient on the boundary of first ring boundary around given vertex
MRMESH_API MeshEdgePoint	findSteepestDescentPoint (const MeshPart &mp, const VertScalars &field, const MeshEdgePoint &ep)
	finds the point along minus maximal gradient on the boundary of triangles around given point (the boundary of left and right edge triangles' union in case (ep) is inner edge point)
MRMESH_API MeshEdgePoint	findSteepestDescentPoint (const MeshPart &mp, const VertScalars &field, const MeshTriPoint &tp)
	finds the point along minus maximal gradient on the boundary of triangles around given point (the boundary of the triangle itself in case (tp) is inner triangle point)
MRMESH_API UndirectedEdgeBitSet	findExtremeEdges (const Mesh &mesh, const VertScalars &field, ExtremeEdgeType type)
	computes all edges in the mesh, where the field not-increases both in left and right triangles
MRMESH_API HashMap< VertId, VertId >	computeClosestSurfacePathTargets (const Mesh &mesh, const VertBitSet &starts, const VertBitSet &ends, const VertBitSet *vertRegion=nullptr, VertScalars *outSurfaceDistances=nullptr)
MRMESH_API SurfacePaths	getSurfacePathsViaVertices (const Mesh &mesh, const VertBitSet &vs)
MRMESH_API float	surfacePathLength (const Mesh &mesh, const SurfacePath &surfacePath)
	computes the length of surface path
MRMESH_API Contour3f	surfacePathToContour3f (const Mesh &mesh, const SurfacePath &line)
	converts lines on mesh in 3D contours by computing coordinate of each point
MRMESH_API Contours3f	surfacePathsToContours3f (const Mesh &mesh, const SurfacePaths &lines)
MRMESH_API Expected< EdgeLoop >	surroundingContour (const Mesh &mesh, std::vector< EdgeId > includeEdges, const EdgeMetric &edgeMetric, const Vector3f &dir)
	Find the best closed edge loop passing through given edges, which minimizes the sum of given edge metric.
MRMESH_API Expected< EdgeLoop >	surroundingContour (const Mesh &mesh, std::vector< VertId > keyVertices, const EdgeMetric &edgeMetric, const Vector3f &dir)
	Find the best closed edge loop passing through given vertices, which minimizes the sum of given edge metric.
MRMESH_API void	SetCurrentThreadName (const char *name)
MRMESH_API std::filesystem::path	GetExeDirectory ()
MRMESH_API std::filesystem::path	GetResourcesDirectory ()
MRMESH_API std::filesystem::path	GetFontsDirectory ()
MRMESH_API std::filesystem::path	GetLibsDirectory ()
MRMESH_API std::filesystem::path	GetEmbeddedPythonDirectory ()
MRMESH_API std::filesystem::path	getUserConfigDir ()
MRMESH_API std::filesystem::path	getUserConfigFilePath ()
MRMESH_API std::filesystem::path	GetTempDirectory ()
MRMESH_API std::filesystem::path	GetHomeDirectory ()
MRMESH_API std::string	GetMRVersionString ()
MRMESH_API void	OpenLink (const std::string &url)
MRMESH_API bool	OpenDocument (const std::filesystem::path &path)
MRMESH_API std::string	GetCpuId ()
MRMESH_API std::string	GetDetailedOSName ()
MRMESH_API std::string	getOSNoSpaces ()
MRMESH_API void	setNewHandlerIfNeeded ()
MRMESH_API std::string	getCurrentStacktrace ()
	returns string representation of the current stacktrace
MRMESH_API SystemMemory	getSystemMemory ()
	return information about memory available in the system
MRMESH_API void	setupLoggerByDefault ()
MRMESH_API Expected< Mesh >	terrainTriangulation (std::vector< Vector3f > points, ProgressCallback cb={})
MRMESH_API bool	isTIFFFile (const std::filesystem::path &path)
MRMESH_API Expected< TiffParameters >	readTiffParameters (const std::filesystem::path &path)
MRMESH_API Expected< void >	readRawTiff (const std::filesystem::path &path, RawTiffOutput &output)
MRMESH_API Expected< void >	writeRawTiff (const uint8_t *bytes, const std::filesystem::path &path, const BaseTiffParameters &params)
MRMESH_API void	printTimingTreeAtEnd (bool on, double minTimeSec=0.1)
MRMESH_API void	printCurrentTimerBranch ()
	prints current timer branch
MRMESH_API void	printTimingTreeAndStop (double minTimeSec=0.1)
MR_BIND_IGNORE MRMESH_API void	registerThreadRootTimeRecord (ThreadRootTimeRecord &root)
	installs given record in the current thread (no record must be installed before)
MR_BIND_IGNORE MRMESH_API void	unregisterThreadRootTimeRecord (ThreadRootTimeRecord &root)
	un-installs given record in the current thread
MRMESH_API Mesh	makeTorus (float primaryRadius=1.0f, float secondaryRadius=0.1f, int primaryResolution=16, int secondaryResolution=16, std::vector< Vector3f > *points=nullptr)
MRMESH_API Mesh	makeOuterHalfTorus (float primaryRadius=1.0f, float secondaryRadius=0.1f, int primaryResolution=16, int secondaryResolution=16, std::vector< Vector3f > *points=nullptr)
MRMESH_API Mesh	makeTorusWithUndercut (float primaryRadius=1.0f, float secondaryRadiusInner=0.1f, float secondaryRadiusOuter=0.2f, int primaryResolution=16, int secondaryResolution=16, std::vector< Vector3f > *points=nullptr)
MRMESH_API Mesh	makeTorusWithSpikes (float primaryRadius=1.0f, float secondaryRadiusInner=0.1f, float secondaryRadiusOuter=0.5f, int primaryResolution=16, int secondaryResolution=16, std::vector< Vector3f > *points=nullptr)
MRMESH_API Mesh	makeTorusWithComponents (float primaryRadius=1.0f, float secondaryRadius=0.1f, int primaryResolution=16, int secondaryResolution=16, std::vector< Vector3f > *points=nullptr)
MRMESH_API Mesh	makeTorusWithSelfIntersections (float primaryRadius=1.0f, float secondaryRadius=0.1f, int primaryResolution=16, int secondaryResolution=16, std::vector< Vector3f > *points=nullptr)
template<typename T >
bool	doTrianglesIntersect (Vector3< T > a, Vector3< T > b, Vector3< T > c, Vector3< T > d, Vector3< T > e, Vector3< T > f)
template<typename T >
bool	doesEdgeXySeparate (const Vector3< T > &x, const Vector3< T > &y, const Vector3< T > &z, const Vector3< T > &u, const Vector3< T > &v, const Vector3< T > &w, Vector3< T > d)
	returns true if a plane containing edge XY separates point Z from triangle UVW
template<typename T >
bool	doTrianglesIntersectExt (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c, const Vector3< T > &d, const Vector3< T > &e, const Vector3< T > &f)
template<typename T >
bool	doTriangleLineIntersect (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c, const Vector3< T > &d, const Vector3< T > &e)
	checks whether triangle ABC and infinite line DE intersect
template<typename T >
bool	doTriangleSegmentIntersect (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c, const Vector3< T > &d, const Vector3< T > &e)
	checks whether triangle ABC and segment DE intersect
template<typename T >
Vector3< T >	findTriangleSegmentIntersection (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c, const Vector3< T > &d, const Vector3< T > &e)
	this function input should have intersection
template<typename T >
std::optional< TriIntersectResult >	rayTriangleIntersect_ (const Vector3< T > &oriA, const Vector3< T > &oriB, const Vector3< T > &oriC, const IntersectionPrecomputes< T > &prec)
std::optional< TriIntersectResult >	rayTriangleIntersect (const Vector3f &oriA, const Vector3f &oriB, const Vector3f &oriC, const IntersectionPrecomputes< float > &prec)
std::optional< TriIntersectResult >	rayTriangleIntersect (const Vector3f &oriA, const Vector3f &oriB, const Vector3f &oriC, const Vector3f &dir)
std::optional< TriIntersectResult >	rayTriangleIntersect (const Vector3d &oriA, const Vector3d &oriB, const Vector3d &oriC, const IntersectionPrecomputes< double > &prec)
std::optional< TriIntersectResult >	rayTriangleIntersect (const Vector3d &oriA, const Vector3d &oriB, const Vector3d &oriC, const Vector3d &dir)
MRMESH_API float	TriDist (Vector3f &p, Vector3f &q, const Vector3f s[3], const Vector3f t[3])
	computes the closest points on two triangles, and returns the squared distance between them.
MRMESH_API void	SegPoints (Vector3f &VEC, Vector3f &X, Vector3f &Y, const Vector3f &P, const Vector3f &A, const Vector3f &Q, const Vector3f &B)
	Returns closest points between an segment pair.
template<typename T >
T	circumcircleDiameterSq (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c)
template<typename T >
T	circumcircleDiameter (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c)
template<typename T >
Vector3< T >	circumcircleCenter (const Vector3< T > &a, const Vector3< T > &b)
	Computes the center of the the triangle's 0AB circumcircle.
template<typename T >
Vector3< T >	circumcircleCenter (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c)
	Computes the center of the the triangle's ABC circumcircle.
template<typename T >
bool	circumballCenters (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c, T radius, Vector3< T > &centerPos, Vector3< T > &centerNeg)
template<typename T >
T	minTriangleAngleSin (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c)
template<typename T >
T	minTriangleAngle (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c)
template<typename T >
T	triangleAspectRatio (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &c)
template<typename T >
Vector3< T >	dirDblArea (const Triangle3< T > &t)
	computes directed double area of given triangle
template<typename T >
Vector3< T >	dirDblArea (const Vector3< T > &p, const Vector3< T > &q, const Vector3< T > &r)
	computes directed double area of given triangle
template<typename T >
Vector3< T >	normal (const Vector3< T > &p, const Vector3< T > &q, const Vector3< T > &r)
	computes unitNormal of given triangle
template<typename T >
T	dblAreaSq (const Vector3< T > &p, const Vector3< T > &q, const Vector3< T > &r)
	computes the square of double area of given triangle
template<typename T >
T	dblArea (const Vector3< T > &p, const Vector3< T > &q, const Vector3< T > &r)
	computes twice the area of given triangle
template<typename T >
T	area (const Vector3< T > &p, const Vector3< T > &q, const Vector3< T > &r)
	computes twice the area of given triangle
template<typename T >
T	dblArea (const Vector2< T > &p, const Vector2< T > &q, const Vector2< T > &r)
	computes twice the area of given triangle
template<typename T >
T	area (const Vector2< T > &p, const Vector2< T > &q, const Vector2< T > &r)
	computes twice the area of given triangle
template<typename T >
Triangle3< T >	makeDegenerate (const Triangle3< T > &t)
	make degenerate triangle (all 3 points on a line) that maximally resembles the input one and has the same centroid
template<typename T >
Triangle3< T >	triangleWithNormal (const Triangle3< T > &t, const Vector3< T > &n)
template<typename T >
T	dihedralAngleSin (const Vector3< T > &leftNorm, const Vector3< T > &rightNorm, const Vector3< T > &edgeVec)
template<typename T >
T	dihedralAngleCos (const Vector3< T > &leftNorm, const Vector3< T > &rightNorm)
template<typename T >
T	dihedralAngle (const Vector3< T > &leftNorm, const Vector3< T > &rightNorm, const Vector3< T > &edgeVec)
template<typename T >
std::optional< Vector2< T > >	posFromTriEdgeLengths (T a, T b, T c)
template<typename T >
std::optional< T >	quadrangleOtherDiagonal (T a, T b, T c, T a1, T b1)
MRMESH_API Expected< std::vector< EdgeLoop > >	detectBasisTunnels (const MeshPart &mp, EdgeMetric metric={}, ProgressCallback progressCallback={})
MRMESH_API Expected< FaceBitSet >	detectTunnelFaces (const MeshPart &mp, const DetectTunnelSettings &settings={})
template<size_t I, typename T >
constexpr const T &	get (const Vector2< T > &v) noexcept
template<size_t I, typename T >
constexpr T &	get (Vector2< T > &v) noexcept
template<size_t I, typename T >
constexpr const T &	get (const Vector3< T > &v) noexcept
template<size_t I, typename T >
constexpr T &	get (Vector3< T > &v) noexcept
template<size_t I, typename T >
constexpr const T &	get (const Vector4< T > &v) noexcept
template<size_t I, typename T >
constexpr T &	get (Vector4< T > &v) noexcept
template<size_t I, typename T >
constexpr const Matrix2< T >::VectorType &	get (const Matrix2< T > &m) noexcept
template<size_t I, typename T >
constexpr Matrix2< T >::VectorType &	get (Matrix2< T > &m) noexcept
template<size_t I, typename T >
constexpr const Matrix3< T >::VectorType &	get (const Matrix3< T > &m) noexcept
template<size_t I, typename T >
constexpr Matrix3< T >::VectorType &	get (Matrix3< T > &m) noexcept
template<size_t I, typename T >
constexpr const Matrix4< T >::VectorType &	get (const Matrix4< T > &m) noexcept
template<size_t I, typename T >
constexpr Matrix4< T >::VectorType &	get (Matrix4< T > &m) noexcept
template<size_t I, typename V >
constexpr const std::tuple_element< I, AffineXf< V > >::type &	get (const AffineXf< V > &m) noexcept
template<size_t I, typename V >
constexpr std::tuple_element< I, AffineXf< V > >::type &	get (AffineXf< V > &m) noexcept
template<size_t I, typename T >
constexpr int	get (const MR::Id< T > &id) noexcept
template<size_t I, typename T >
constexpr int &	get (MR::Id< T > &id) noexcept
template<size_t I>
constexpr const uint8_t &	get (const Color &c) noexcept
template<size_t I>
constexpr uint8_t &	get (Color &c) noexcept
MRMESH_API std::optional< VertBitSet >	pointUniformSampling (const PointCloud &pointCloud, const UniformSamplingSettings &settings)
MRMESH_API std::optional< PointCloud >	makeUniformSampledCloud (const PointCloud &pointCloud, const UniformSamplingSettings &settings)
MRMESH_API Expected< Mesh >	uniteManyMeshes (const std::vector< const Mesh * > &meshes, const UniteManyMeshesParams &params={})
template<typename T , typename I >
MR_BIND_IGNORE auto	begin (const Vector< T, I > &a)
template<typename T , typename I >
MR_BIND_IGNORE auto	begin (Vector< T, I > &a)
template<typename T , typename I >
MR_BIND_IGNORE auto	end (const Vector< T, I > &a)
template<typename T , typename I >
MR_BIND_IGNORE auto	end (Vector< T, I > &a)
template<typename T , typename I >
T	getAt (const Vector< T, I > &a, I id, T def={})
	given some Vector and a key, returns the value associated with the key, or default value if key is invalid or outside the Vector
MRMESH_API Vector< Vector3f, VertId >	vertexAttributeGradient (const Mesh &mesh, const VertScalars &vertexAttribute)
	Calculates gradient for each vertex in mesh, based on vertexAttribute.
ViewportMask	operator& (ViewportMask a, ViewportMask b)
ViewportMask	operator| (ViewportMask a, ViewportMask b)
ViewportMask	operator^ (ViewportMask a, ViewportMask b)
bool	operator== (const ViewportIterator &a, const ViewportIterator &b)
auto	begin (ViewportMask mask)
auto	end (ViewportMask)
OutEdge	opposite (OutEdge e)
MRMESH_API void	expandVoxelsMask (VoxelBitSet &mask, const VolumeIndexer &indexer, int expansion=1)
	expands VoxelBitSet with given number of steps
MRMESH_API void	shrinkVoxelsMask (VoxelBitSet &mask, const VolumeIndexer &indexer, int shrinkage=1)
	shrinks VoxelBitSet with given number of steps
MRMESH_API Expected< void >	decompressZip (const std::filesystem::path &zipFile, const std::filesystem::path &targetFolder, const char *password=nullptr)
	decompresses given zip-file into given folder
MRMESH_API Expected< void >	decompressZip (std::istream &zipStream, const std::filesystem::path &targetFolder, const char *password=nullptr)
	decompresses given binary stream (containing the data of a zip file only) into given folder
MRMESH_API Expected< void >	compressZip (const std::filesystem::path &zipFile, const std::filesystem::path &sourceFolder, const std::vector< std::filesystem::path > &excludeFiles={}, const char *password=nullptr, ProgressCallback cb={})
	compresses given folder in given zip-file
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...))
MRSYMBOLMESH_API Expected< Mesh >	alignTextToMesh (const Mesh &mesh, const TextMeshAlignParams &params)
MRSYMBOLMESH_API Expected< Contours2f >	createSymbolContours (const SymbolMeshParams &params)
MRSYMBOLMESH_API void	addBaseToPlanarMesh (Mesh &mesh, float zOffset=1.0f)
MRSYMBOLMESH_API Expected< Mesh >	createSymbolsMesh (const SymbolMeshParams &params)
MRVIEWER_API void	reserveKeyEvent (ImGuiKey key)
template<class HistoryActionType , typename... Args>
void	AppendHistory (Args &&... args)
template<class HistoryActionType >
void	AppendHistory (std::shared_ptr< HistoryActionType > action)
MRVIEWER_API void	FilterHistoryByCondition (HistoryStackFilter filteringCondition, bool deepFiltering=true)
MRVIEWER_API Expected< std::string >	GetClipboardText ()
MRVIEWER_API Expected< void >	SetClipboardText (const std::string &text)
MRVIEWER_API void	createShader (const std::string &shader_name, const std::string &vert_source, const std::string &frag_source, GLuint &prog_id, const DisabledWarnings &suppressedWarns={})
MRVIEWER_API void	destroyShader (GLuint id)
MRVIEWER_API std::filesystem::path	openFileDialog (const FileParameters &params={})
MRVIEWER_API void	openFileDialogAsync (std::function< void(const std::filesystem::path &)> callback, const FileParameters &params={})
MRVIEWER_API std::vector< std::filesystem::path >	openFilesDialog (const FileParameters &params={})
MRVIEWER_API void	openFilesDialogAsync (std::function< void(const std::vector< std::filesystem::path > &)> callback, const FileParameters &params={})
MRVIEWER_API std::filesystem::path	openFolderDialog (std::filesystem::path baseFolder={})
MRVIEWER_API void	openFolderDialogAsync (std::function< void(const std::filesystem::path &)> callback, std::filesystem::path baseFolder={})
MRVIEWER_API std::vector< std::filesystem::path >	openFoldersDialog (std::filesystem::path baseFolder={})
MRVIEWER_API std::filesystem::path	saveFileDialog (const FileParameters &params={})
MRVIEWER_API void	saveFileDialogAsync (std::function< void(const std::filesystem::path &)> callback, const FileParameters &params={})
MRVIEWER_API Json::Value	GetSystemInfoJson ()
int	loadGL ()
MRVIEWER_API void	setTextureWrapType (WrapType wrapType, GLenum type=GL_TEXTURE_2D)
MRVIEWER_API void	setTextureFilterType (FilterType filterType, GLenum type=GL_TEXTURE_2D)
MRVIEWER_API std::string	getLinesVertexShader ()
MRVIEWER_API std::string	getLinesFragmentShader (bool alphaSort)
MRVIEWER_API std::string	getLinesJointVertexShader ()
MRVIEWER_API std::string	getLinesJointFragmentShader ()
MRVIEWER_API std::string	getLinesPickerVertexShader ()
MRVIEWER_API std::string	getLinesJointPickerVertexShader ()
MRVIEWER_API std::string	getMeshVerticesShader ()
MRVIEWER_API std::string	getMeshFragmentShader (bool gl4, bool alphaSort, bool msaaEnabled)
MRVIEWER_API std::string	getMeshFragmentShaderArgumetsBlock ()
MRVIEWER_API std::string	getMeshFragmentShaderColoringBlock ()
std::string	getMouseModeString (MouseMode mode)
MRVIEWER_API void	excludeLoneEdgesWithHistory (const std::shared_ptr< ObjectMesh > &objMesh)
MRVIEWER_API void	excludeAllEdgesWithHistory (const std::shared_ptr< ObjectMesh > &objMesh)
MRVIEWER_API void	mapEdgesWithHistory (const std::shared_ptr< ObjectMesh > &objMesh, const WholeEdgeMap &emap)
MRVIEWER_API void	mapEdgesWithHistory (const std::shared_ptr< ObjectMesh > &objMesh, const WholeEdgeHashMap &emap)
MRVIEWER_API void	mapEdgesWithHistory (const std::shared_ptr< ObjectMesh > &objMesh, const UndirectedEdgeBMap &emap)
MRVIEWER_API void	packPointsWithHistory (const std::shared_ptr< ObjectPoints > &objPoints, Reorder reoder)
MRVIEWER_API void	packPointsWithHistory (const std::shared_ptr< ObjectPoints > &objPoints, Reorder reoder, VertBitSet newValidVerts)
MRVIEWER_API HoleEdgePoint	findClosestToMouseHoleEdge (const Vector2i &mousePos, const std::shared_ptr< ObjectMeshHolder > &objMesh, const std::vector< EdgeId > &holeRepresentativeEdges, float accuracy=5.5f, bool attractToVert=false, float cornerAccuracy=10.5f)
MRVIEWER_API HoleEdgePoint	findClosestToMouseEdge (const Vector2i &mousePos, const std::vector< std::shared_ptr< ObjectLinesHolder > > &objsLines, float accuracy=5.5f)
HoleEdgePoint	findClosestToMouseEdge (const Vector2i &mousePos, const std::vector< std::shared_ptr< ObjectLines > > &objsLines, float accuracy=5.5f)
MRVIEWER_API std::string	getPointsVertexShader ()
MRVIEWER_API std::string	getPointsFragmentShader (bool alphaSort)
MRVIEWER_API std::optional< MeshAttributes >	projectMeshAttributes (const ObjectMesh &oldMeshObj, const MeshPart &newMeshPart, ProgressCallback cb={})
MRVIEWER_API void	emplaceMeshAttributes (std::shared_ptr< ObjectMesh > objectMesh, MeshAttributes &&newAttribute)
	set new mesh attributes and saving the history of changing mesh attributes
template<typename F , typename... Args>
void	pythonAppendOrRun (F func, Args &&... args)
template<typename R , typename... Args>
auto	pythonRunFromGUIThread (std::function< R(Args...)> &&f) -> std::function< void(Args...)>
template<typename F >
auto	pythonRunFromGUIThread (F &&f)
template<typename R , typename T , typename... Args>
auto	pythonRunFromGUIThread (R(T::*memFunction)(Args...))
MRVIEWER_API GLint	bindVertexAttribArray (const BindVertexAttribArraySettings &settings)
template<typename T , template< typename, typename... > class C, typename... args>
GLint	bindVertexAttribArray (const GLuint program_shader, const char *name, GlBuffer &buf, const C< T, args... > &V, int baseTypeElementsNumber, bool refresh, bool forceUse=false)
template<typename T , std::size_t N>
GLint	bindVertexAttribArray (const GLuint program_shader, const char *name, GlBuffer &buf, const std::array< T, N > &V, int baseTypeElementsNumber, bool refresh, bool forceUse=false)
int	getDepthFunctionLess (DepthFunction funcType)
int	getDepthFunctionLEqual (DepthFunction funcType)
MRVIEWER_API Vector2i	calcTextureRes (int bufferSize, int maxTextWidth)
MRVIEWER_API const Vector2f &	GetAvailableLineWidthRange ()
MRVIEWER_API void	pushNotification (const RibbonNotification &notification)
MRVIEWER_API std::vector< FlatTree >	getFlatSubtrees (const std::vector< std::shared_ptr< Object > > &objs)
MRVIEWER_API void	mergeSubtree (TypedFlatTree subtree)
	merge objects of same type in the object tree
MRVIEWER_API void	mergeSubtree (std::shared_ptr< Object > rootObj)
template<typename ObjectT >
std::string	getNObjectsLine (unsigned n)
template<typename ObjectT , bool visualRepresentationCheck, bool modelCheck>
std::string	sceneSelectedExactly (const std::vector< std::shared_ptr< const Object > > &objs, unsigned n)
template<typename ObjectT , bool visualRepresentationCheck, bool modelCheck>
std::string	sceneSelectedAtLeast (const std::vector< std::shared_ptr< const Object > > &objs, unsigned n)
float MRVIEWER_API	SelectCurvaturePreference (PathPreference *pp, float menuScaling)
MRVIEWER_API BitSet	calculateSelectedPixelsInsidePolygon (const Contour2f &screenPoints)
MRVIEWER_API BitSet	calculateSelectedPixelsNearPolygon (const Contour2f &screenPoints, float radiusPix)
MRVIEWER_API FaceBitSet	findIncidentFaces (const Viewport &viewport, const BitSet &pixBs, const ObjectMesh &obj, bool onlyVisible=false, bool includeBackfaces=true, const std::vector< ObjectMesh * > *occludingMeshes=nullptr)
MRVIEWER_API void	appendGPUVisibleFaces (const Viewport &viewport, const BitSet &pixBs, const std::vector< std::shared_ptr< ObjectMesh > > &objects, std::vector< FaceBitSet > &visibleFaces, bool includeBackfaces=true)
MRVIEWER_API VertBitSet	findVertsInViewportArea (const Viewport &viewport, const BitSet &bsVec, const ObjectPoints &obj, bool includeBackfaces=true, bool onlyVisible=false)
MRVIEWER_API std::string	getPickerFragmentShader (bool points, bool cornerMode=true)
MRVIEWER_API std::string	getFragmentShaderClippingBlock ()
MRVIEWER_API std::string	getFragmentShaderPointSizeBlock ()
MRVIEWER_API std::string	getFragmentShaderOnlyOddBlock (bool sampleMask)
MRVIEWER_API std::string	getFragmentShaderHeaderBlock (bool gl4, bool alphaSort)
MRVIEWER_API std::string	getFragmentShaderEndBlock (bool alphaSort)
MRVIEWER_API std::string	getShaderMainBeginBlock ()
MRVIEWER_API void	showModal (const std::string &error, NotificationType type)
	Check if menu is available and if it is, shows modal window.
void	showError (const std::string &error)
template<UnitEnum E>
const UnitInfo &	getUnitInfo (E unit)=delete
template<UnitEnum E>
bool	unitsAreEquivalent (E a, E b)
template<UnitEnum E>
bool	unitsAreEquivalent (const std::optional< E > &a, const std::optional< E > &b)
template<UnitEnum E, typename T >
detail::Units::MakeFloatingPoint< T >	convertUnits (E from, E to, const T &value)
template<UnitEnum E, typename T >
detail::Units::MakeFloatingPoint< T >	convertUnits (const std::optional< E > &from, const std::optional< E > &to, const T &value)
template<UnitEnum E>
const UnitToStringParams< E > &	getDefaultUnitParams ()
template<UnitEnum E>
void	setDefaultUnitParams (const UnitToStringParams< E > &newParams)
MRVIEWER_API std::string_view	toString (DegreesMode mode)
template<UnitEnum E, detail::Units::Scalar T>
MRVIEWER_API std::string	valueToString (T value, const UnitToStringParams< E > &params=getDefaultUnitParams< E >())
template<detail::Units::Scalar T>
MRVIEWER_API std::string	valueToString (T value, const VarUnitToStringParams &params)
template<detail::Units::Scalar T>
MRVIEWER_API int	guessPrecision (T value)
template<detail::Units::Scalar T>
MRVIEWER_API int	guessPrecision (T min, T max)
template<typename T > requires (VectorTraits<T>::size > 1 && detail::Units::Scalar<typename VectorTraits<T>::BaseType>)
int	guessPrecision (T value)
template<typename T > requires (VectorTraits<T>::size > 1 && detail::Units::Scalar<typename VectorTraits<T>::BaseType>)
int	guessPrecision (T min, T max)
template<UnitEnum E, detail::Units::Scalar T>
MRVIEWER_API std::string	valueToImGuiFormatString (T value, const UnitToStringParams< E > &params=getDefaultUnitParams< E >())
template<detail::Units::Scalar T>
MRVIEWER_API std::string	valueToImGuiFormatString (T value, const VarUnitToStringParams &params)
MRVIEWER_API int	launchDefaultViewer (const Viewer::LaunchParams &params, const ViewerSetup &setup)
MRVIEWER_API void	loadMRViewerDll ()
MRVIEWER_API Viewer &	getViewerInstance ()
	returns global instance of Viewer class
MRVIEWER_API void	incrementForceRedrawFrames (int i=1, bool swapOnLastOnly=false)
MRVIEWER_API Expected< void >	saveObjectToFile (const Object &obj, const std::filesystem::path &filename, const SaveObjectSettings &settings={})
	save visual object (mesh, lines, points or voxels) to file
ImVec2	position (const ViewportRectangle &rect)
ImVec2	size (const ViewportRectangle &rect)
template<typename T >
Vector4< T >	toVec4 (const ViewportRectangle &rect)
bool	operator== (const SegmEndColors &a, const SegmEndColors &b)
bool	operator== (const ViewportPointsWithColors &a, const ViewportPointsWithColors &b)
bool	operator== (const ViewportLinesWithColors &a, const ViewportLinesWithColors &b)
MRVIEWER_API std::string	getTrivialVertexShader ()
MRVIEWER_API std::string	getVolumeFragmentShader ()
MRVIEWER_API std::string	getVolumePickerFragmentShader ()
MRVIEWER_API Expected< Json::Value >	parseResponse (const Json::Value &response)
bool	sceneReorderWithUndo (const SceneReorder &task)
OriginAndDimensions	calcOriginAndDimensions (const Box3f &box, float voxelSize)
	computes origin and dimensions of voxel-grid to cover given 3D box with given spacing (voxelSize)
MRVOXELS_API float	voxelizeAndComputeVolume (const std::vector< std::shared_ptr< Mesh > > &meshes, const AffineXf3f &xf, const Vector3f &voxelSize)
MRVOXELS_API size_t	heapBytes (const FloatGrid &grid)
	returns the amount of heap memory occupied by grid
MRVOXELS_API FloatGrid	resampled (const FloatGrid &grid, float voxelScale, ProgressCallback cb={})
	resample this grid to fit voxelScale
MRVOXELS_API FloatGrid	resampled (const FloatGrid &grid, const Vector3f &voxelScale, ProgressCallback cb={})
	resample this grid to fit voxelScale
MRVOXELS_API FloatGrid	cropped (const FloatGrid &grid, const Box3i &box, ProgressCallback cb={})
	returns cropped grid
MRVOXELS_API float	getValue (const FloatGrid &grid, const Vector3i &p)
	returns the value at given voxel
MRVOXELS_API void	setValue (FloatGrid &grid, const VoxelBitSet &region, float value)
MRVOXELS_API void	setLevelSetType (FloatGrid &grid)
	sets type of this grid as LEVEL SET (for normal flipping)
MRVOXELS_API FloatGrid	operator+= (FloatGrid &a, const FloatGrid &b)
MRVOXELS_API FloatGrid	operator-= (FloatGrid &a, const FloatGrid &b)
MRVOXELS_API FloatGrid	operator*= (FloatGrid &a, const FloatGrid &b)
MRVOXELS_API Expected< Mesh >	marchingCubes (const SimpleVolume &volume, const MarchingCubesParams &params={})
MRVOXELS_API Expected< TriMesh >	marchingCubesAsTriMesh (const SimpleVolume &volume, const MarchingCubesParams &params={})
MRVOXELS_API Expected< Mesh >	marchingCubes (const SimpleVolumeMinMax &volume, const MarchingCubesParams &params={})
MRVOXELS_API Expected< TriMesh >	marchingCubesAsTriMesh (const SimpleVolumeMinMax &volume, const MarchingCubesParams &params={})
MRVOXELS_API Expected< Mesh >	marchingCubes (const VdbVolume &volume, const MarchingCubesParams &params={})
MRVOXELS_API Expected< TriMesh >	marchingCubesAsTriMesh (const VdbVolume &volume, const MarchingCubesParams &params={})
MRVOXELS_API Expected< Mesh >	marchingCubes (const FunctionVolume &volume, const MarchingCubesParams &params={})
MRVOXELS_API Expected< TriMesh >	marchingCubesAsTriMesh (const FunctionVolume &volume, const MarchingCubesParams &params={})
MRVOXELS_API Expected< SimpleVolumeMinMax >	meshToDistanceVolume (const MeshPart &mp, const MeshToDistanceVolumeParams &params={})
	makes SimpleVolume filled with (signed or unsigned) distances from Mesh with given settings
MRVOXELS_API FunctionVolume	meshToDistanceFunctionVolume (const MeshPart &mp, const MeshToDistanceVolumeParams &params={})
	makes FunctionVolume representing (signed or unsigned) distances from Mesh with given settings
MRVOXELS_API Expected< SimpleVolumeMinMax >	meshRegionToIndicatorVolume (const Mesh &mesh, const FaceBitSet &region, float offset, const DistanceVolumeParams &params)
MRVOXELS_API Expected< std::array< SimpleVolumeMinMax, 3 > >	meshToDirectionVolume (const MeshToDirectionVolumeParams &params)
MRVOXELS_API Expected< VertBitSet >	moveMeshToVoxelMaxDeriv (Mesh &mesh, const AffineXf3f &meshXf, const VdbVolume &volume, const AffineXf3f &volumeXf, const MoveMeshToVoxelMaxDerivSettings &settings, ProgressCallback callback={})
MRVOXELS_API float	suggestVoxelSize (const MeshPart &mp, float approxNumVoxels)
	computes size of a cubical voxel to get approximately given number of voxels during rasterization
MRVOXELS_API Expected< Mesh >	offsetMesh (const MeshPart &mp, float offset, const OffsetParameters &params={})
MRVOXELS_API Expected< Mesh >	doubleOffsetMesh (const MeshPart &mp, float offsetA, float offsetB, const OffsetParameters &params={})
MRVOXELS_API Expected< Mesh >	mcOffsetMesh (const MeshPart &mp, float offset, const OffsetParameters &params={}, Vector< VoxelId, FaceId > *outMap=nullptr)
MRVOXELS_API Expected< Mesh >	mcShellMeshRegion (const Mesh &mesh, const FaceBitSet &region, float offset, const BaseShellParameters &params, Vector< VoxelId, FaceId > *outMap=nullptr)
MRVOXELS_API Expected< Mesh >	sharpOffsetMesh (const MeshPart &mp, float offset, const SharpOffsetParameters &params={})
MRVOXELS_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.
MRVOXELS_API Expected< Mesh >	thickenMesh (const Mesh &mesh, float offset, const GeneralOffsetParameters &params={})
MRVOXELS_API Expected< Mesh >	offsetOneDirection (const MeshPart &mp, float offset, const GeneralOffsetParameters &params={})
MRVOXELS_API Expected< Mesh >	offsetPolyline (const Polyline3 &polyline, float offset, const OffsetParameters &params={})
template<typename GredT >
void	translateToZero (GredT &grid)
template<typename GridT >
RangeSize	calculateRangeSize (const GridT &grid)
MRVOXELS_API Expected< Mesh >	partialOffsetMesh (const MeshPart &mp, float offset, const GeneralOffsetParameters &params={})
MRVOXELS_API Expected< SimpleVolume >	pointsToDistanceVolume (const PointCloud &cloud, const PointsToDistanceVolumeParams &params)
	makes SimpleVolume filled with signed distances to points with normals
MRVOXELS_API FunctionVolume	pointsToDistanceFunctionVolume (const PointCloud &cloud, const PointsToDistanceVolumeParams &params)
	makes FunctionVolume representing signed distances to points with normals
MRVOXELS_API Expected< VertColors >	calcAvgColors (const PointCloud &cloud, const VertColors &colors, const VertCoords &tgtPoints, const VertBitSet &tgtVerts, float sigma, const ProgressCallback &cb={})
MRVOXELS_API Expected< Mesh >	pointsToMeshFusion (const PointCloud &cloud, const PointsToMeshParameters &params)
MRVOXELS_API Expected< Mesh >	rebuildMesh (const MeshPart &mp, const RebuildMeshSettings &settings)
MRVOXELS_API std::function< float(const char *)>	getTypeConverter (ScalarType scalarType, uint64_t range, int64_t min)
template<typename F >
std::invoke_result_t< F, int >	visitScalarType (F &&f, ScalarType scalarType, const char *c)
	More general template to pass a single value of specified format scalarType to a generic function f.
MRVOXELS_API void	sortScansByOrder (std::vector< std::filesystem::path > &scans, std::vector< SliceInfo > &zOrder)
	Sort scan files in given vector by given slice information.
MRVOXELS_API void	putScanFileNameInZ (const std::vector< std::filesystem::path > &scans, std::vector< SliceInfo > &zOrder)
	Read layer heights from given scan file names.
MRVOXELS_API void	sortScanFilesByName (std::vector< std::filesystem::path > &scans)
	Sort scan files in given vector by names (respect numbers in it)
MRVOXELS_API Expected< std::array< SimpleVolumeMinMax, 3 > >	teethMaskToDirectionVolume (const VdbVolume &volume, const std::vector< int > &additionalIds={})
	A shortcut for TeethMaskToDirectionVolumeConvertor::create and TeethMaskToDirectionVolumeConvertor::convertAll.
MRVOXELS_API Expected< ToolPathResult >	constantZToolPath (const MeshPart &mp, const ToolPathParams &params)
MRVOXELS_API Expected< ToolPathResult >	lacingToolPath (const MeshPart &mp, const ToolPathParams &params, Axis cutDirection)
MRVOXELS_API Expected< ToolPathResult >	constantCuspToolPath (const MeshPart &mp, const ConstantCuspParams &params)
MRVOXELS_API std::shared_ptr< ObjectGcode >	exportToolPathToGCode (const std::vector< GCommand > &commands)
MRVOXELS_API Expected< void >	interpolateLines (std::vector< GCommand > &commands, const LineInterpolationParams &params, Axis axis)
MRVOXELS_API Expected< void >	interpolateArcs (std::vector< GCommand > &commands, const ArcInterpolationParams &params, Axis axis)
MRVOXELS_API FaceBitSet	smoothSelection (Mesh &mesh, const FaceBitSet &region, float expandOffset, float shrinkOffset)
MRVOXELS_API FloatGrid	meshToLevelSet (const MeshPart &mp, const AffineXf3f &xf, const Vector3f &voxelSize, float surfaceOffset=3, ProgressCallback cb={})
MRVOXELS_API FloatGrid	meshToDistanceField (const MeshPart &mp, const AffineXf3f &xf, const Vector3f &voxelSize, float surfaceOffset=3, ProgressCallback cb={})
MRVOXELS_API void	evalGridMinMax (const FloatGrid &grid, float &min, float &max)
MRVOXELS_API Expected< VdbVolume >	meshToVolume (const Mesh &mesh, const MeshToVolumeParams &params={})
MRVOXELS_API VdbVolume	floatGridToVdbVolume (FloatGrid grid)
MRVOXELS_API FloatGrid	simpleVolumeToDenseGrid (const SimpleVolume &simpleVolume, float background=0.0f, ProgressCallback cb={})
MRVOXELS_API VdbVolume	simpleVolumeToVdbVolume (const SimpleVolumeMinMax &simpleVolume, ProgressCallback cb={})
MRVOXELS_API void	putSimpleVolumeInDenseGrid (FloatGrid &grid, const Vector3i &minCoord, const SimpleVolume &simpleVolume, ProgressCallback cb={})
	Copy given simpleVolume into the grid, starting at minCoord.
MRVOXELS_API Expected< SimpleVolumeMinMax >	vdbVolumeToSimpleVolume (const VdbVolume &vdbVolume, const Box3i &activeBox=Box3i(), ProgressCallback cb={})
MRVOXELS_API Expected< SimpleVolumeMinMax >	vdbVolumeToSimpleVolumeNorm (const VdbVolume &vdbVolume, const Box3i &activeBox=Box3i(), std::optional< MinMaxf > sourceScale={}, ProgressCallback cb={})
MRVOXELS_API Expected< SimpleVolumeMinMaxU16 >	vdbVolumeToSimpleVolumeU16 (const VdbVolume &vdbVolume, const Box3i &activeBox=Box3i(), std::optional< MinMaxf > sourceScale={}, ProgressCallback cb={})
MRVOXELS_API Expected< Mesh >	gridToMesh (const FloatGrid &grid, const GridToMeshSettings &settings)
	converts OpenVDB Grid into mesh using Dual Marching Cubes algorithm
MRVOXELS_API Expected< Mesh >	gridToMesh (FloatGrid &&grid, const GridToMeshSettings &settings)
MRVOXELS_API Expected< void >	makeSignedByWindingNumber (FloatGrid &grid, const Vector3f &voxelSize, const Mesh &refMesh, const MakeSignedByWindingNumberSettings &settings)
	set signs for unsigned distance field grid using generalized winding number computed at voxel grid point from refMesh
MRVOXELS_API Expected< Mesh >	doubleOffsetVdb (const MeshPart &mp, const DoubleOffsetSettings &settings)
MR_BIND_IGNORE openvdb::FloatGrid &	ovdb (OpenVdbFloatGrid &v)
MR_BIND_IGNORE const openvdb::FloatGrid &	ovdb (const OpenVdbFloatGrid &v)
MR_BIND_IGNORE FloatGrid	MakeFloatGrid (openvdb::FloatGrid::Ptr &&p)
	makes MR::FloatGrid shared pointer taking the contents of the input pointer
MR_BIND_IGNORE Vector3i	fromVdb (const openvdb::Coord &v)
MR_BIND_IGNORE openvdb::Coord	toVdb (const Vector3i &v)
template<typename Accessor >
SimpleVolumeMinMax	resampleVolumeByInterpolation (const typename Accessor::VolumeType &volume, const Accessor &accessor, const Vector3f &newVoxelSize)
	sample function that resamples the voxel volume using interpolating accessor
MRVOXELS_API Expected< MR::Mesh >	meshFromVoxelsMask (const VdbVolume &volume, const VoxelBitSet &mask)
	Creates mesh from voxels mask.
MRVOXELS_API Expected< MR::Mesh >	segmentVolume (const VdbVolume &volume, const std::vector< std::pair< Vector3f, Vector3f > > &pairs, const VolumeSegmentationParameters &params=VolumeSegmentationParameters())
	Simple segment volume.
MRVOXELS_API VdbVolume	voxelFilter (const VdbVolume &volume, VoxelFilterType type, int width)
MRVOXELS_API Expected< VoxelBitSet >	segmentVolumeByGraphCut (const SimpleVolume &densityVolume, float k, const VoxelBitSet &sourceSeeds, const VoxelBitSet &sinkSeeds, ProgressCallback cb={})
	Segment voxels of given volume on two sets using graph-cut, returning source set.
MRVOXELS_API VoxelsMetric	voxelsExponentMetric (const VdbVolume &voxels, const VoxelMetricParameters &parameters, float modifier=-1.0f)
	e^(modifier*(dens1+dens2))
MRVOXELS_API VoxelsMetric	voxelsSumDiffsMetric (const VdbVolume &voxels, const VoxelMetricParameters &parameters)
	sum of dense differences with start and stop voxels
MRVOXELS_API std::vector< size_t >	buildSmallestMetricPath (const VdbVolume &voxels, const VoxelsMetric &metric, size_t start, size_t finish, ProgressCallback cb={})
	builds shortest path in given metric from start to finish voxels; if no path can be found then empty path is returned
MRVOXELS_API VdbVolume	transformVdbVolume (const VdbVolume &volume, const AffineXf3f &xf, bool fixBox=false, const Box3f &box={})
MRVOXELS_API void	voxelsApplyTransform (ObjectVoxels &obj, const AffineXf3f &xf, bool fixBox)
template<typename Volume >
Expected< void >	mergeVolumePart (Mesh &mesh, std::vector< EdgePath > &cutContours, Volume &&volume, float leftCutPosition, float rightCutPosition, const MergeVolumePartSettings &settings={})
	Merge one mesh with another generated from a voxel volume part.
template<typename Volume >
Expected< Mesh >	volumeToMeshByParts (const VolumePartBuilder< Volume > &builder, const Vector3i &dimensions, const Vector3f &voxelSize, const VolumeToMeshByPartsSettings &settings={}, const MergeVolumePartSettings &mergeSettings={})
	converts a voxel volume into a mesh without full memory loading
	MR_CANONICAL_TYPEDEFS ((template< typename T > struct), VoxelsVolumeMinMax,(SimpleVolumeMinMax, VoxelsVolumeMinMax< std::vector< float > >)(SimpleVolumeMinMaxU16, VoxelsVolumeMinMax< std::vector< uint16_t > >)(VdbVolume, VoxelsVolumeMinMax< FloatGrid >)) template< typename T > using VoxelValueGetter
MRVOXELS_API Expected< std::vector< std::shared_ptr< ObjectVoxels > > >	makeObjectVoxelsFromFile (const std::filesystem::path &file, ProgressCallback callback={})
	loads voxels from given file in new object
MRVOXELS_API Expected< std::vector< std::shared_ptr< Object > > >	makeObjectFromVoxelsFile (const std::filesystem::path &file, std::string *warnings=nullptr, ProgressCallback callback={})
MRVOXELS_API Expected< void >	saveObjectVoxelsToFile (const Object &object, const std::filesystem::path &path, const ProgressCallback &callback={})
MRVOXELS_API Expected< SimpleVolumeMinMax >	functionVolumeToSimpleVolume (const FunctionVolume &volume, const ProgressCallback &callback={})
	converts function volume into simple volume
MRMESH_API EdgeMetric	identityMetric ()
	metric returning 1 for every edge
MRMESH_API EdgeMetric	edgeLengthMetric (const Mesh &mesh)
MRMESH_API EdgeMetric	discreteAbsMeanCurvatureMetric (const Mesh &mesh)
MRMESH_API EdgeMetric	discreteMinusAbsMeanCurvatureMetric (const Mesh &mesh)
MRMESH_API EdgeMetric	edgeCurvMetric (const Mesh &mesh, float angleSinFactor=2, float angleSinForBoundary=0)
MRMESH_API EdgeMetric	edgeTableSymMetric (const MeshTopology &topology, const EdgeMetric &metric)
EdgeMetric	edgeTableMetric (const MeshTopology &topology, const EdgeMetric &metric)
MRMESH_API bool	isEdgePath (const MeshTopology &topology, const std::vector< EdgeId > &edges)
	returns true if every next edge starts where previous edge ends
MRMESH_API bool	isEdgeLoop (const MeshTopology &topology, const std::vector< EdgeId > &edges)
	returns true if every next edge starts where previous edge ends, and start vertex coincides with finish vertex
MRMESH_API std::vector< EdgeLoop >	splitOnSimpleLoops (const MeshTopology &topology, std::vector< EdgeLoop > &&loops)
	given a number of edge loops, splits every loop that passes via a vertex more than once on smaller loops without self-intersections
MRMESH_API void	reverse (EdgePath &path)
MRMESH_API void	reverse (std::vector< EdgePath > &paths)
	reverse every path in the vector
MRMESH_API double	calcPathMetric (const EdgePath &path, EdgeMetric metric)
	computes summed metric of all edges in the path
double	calcPathLength (const EdgePath &path, const Mesh &mesh)
MRMESH_API Vector3d	calcOrientedArea (const EdgeLoop &loop, const Mesh &mesh)
MRMESH_API void	sortPathsByMetric (std::vector< EdgePath > &paths, EdgeMetric metric)
	sorts given paths in ascending order of their metrics
void	sortPathsByLength (std::vector< EdgePath > &paths, const Mesh &mesh)
MRMESH_API void	addLeftBand (const MeshTopology &topology, const EdgeLoop &loop, FaceBitSet &addHere)
	adds all faces incident to loop vertices and located to the left from the loop to given FaceBitSet
MRMESH_API EdgePath	buildShortestPath (const Mesh &mesh, VertId start, VertId finish, float maxPathLen=FLT_MAX)
MRMESH_API EdgePath	buildShortestPathBiDir (const Mesh &mesh, VertId start, VertId finish, float maxPathLen=FLT_MAX)
MRMESH_API EdgePath	buildShortestPathBiDir (const Mesh &mesh, const MeshTriPoint &start, const MeshTriPoint &finish, VertId *outPathStart=nullptr, VertId *outPathFinish=nullptr, float maxPathLen=FLT_MAX)
MRMESH_API EdgePath	buildShortestPathAStar (const Mesh &mesh, VertId start, VertId finish, float maxPathLen=FLT_MAX)
MRMESH_API EdgePath	buildShortestPathAStar (const Mesh &mesh, const MeshTriPoint &start, const MeshTriPoint &finish, VertId *outPathStart=nullptr, VertId *outPathFinish=nullptr, float maxPathLen=FLT_MAX)
MRMESH_API EdgePath	buildShortestPath (const Mesh &mesh, VertId start, const VertBitSet &finish, float maxPathLen=FLT_MAX)
	builds shortest path in euclidean metric from start to finish vertices; if no path can be found then empty path is returned
MRMESH_API EdgePath	buildSmallestMetricPath (const MeshTopology &topology, const EdgeMetric &metric, VertId start, VertId finish, float maxPathMetric=FLT_MAX)
	builds shortest path in given metric from start to finish vertices; if no path can be found then empty path is returned
MRMESH_API EdgePath	buildSmallestMetricPathBiDir (const MeshTopology &topology, const EdgeMetric &metric, VertId start, VertId finish, float maxPathMetric=FLT_MAX)
MRMESH_API EdgePath	buildSmallestMetricPathBiDir (const MeshTopology &topology, const EdgeMetric &metric, const TerminalVertex *starts, int numStarts, const TerminalVertex *finishes, int numFinishes, VertId *outPathStart=nullptr, VertId *outPathFinish=nullptr, float maxPathMetric=FLT_MAX)
MRMESH_API EdgePath	buildSmallestMetricPath (const MeshTopology &topology, const EdgeMetric &metric, VertId start, const VertBitSet &finish, float maxPathMetric=FLT_MAX)
	builds shortest path in given metric from start to finish vertices; if no path can be found then empty path is returned
MRMESH_API std::vector< VertId >	getVertexOrdering (const MeshTopology &topology, VertBitSet region)
	returns all vertices from given region ordered in each connected component in breadth-first way
MRMESH_API std::vector< EdgeLoop >	extractClosedLoops (const MeshTopology &topology, EdgeBitSet &edges)
	finds all closed loops from given edges and removes them from edges
MRMESH_API std::vector< EdgeLoop >	extractClosedLoops (const MeshTopology &topology, const std::vector< EdgeId > &inEdges, EdgeBitSet *outNotLoopEdges=nullptr)
MRMESH_API EdgeLoop	extractLongestClosedLoop (const Mesh &mesh, const std::vector< EdgeId > &inEdges)
MRMESH_API bool	dilateRegionByMetric (const MeshTopology &topology, const EdgeMetric &metric, FaceBitSet &region, float dilation, ProgressCallback callback={})
	expands the region (of faces or vertices) on given metric value. returns false if callback also returns false
MRMESH_API bool	dilateRegionByMetric (const MeshTopology &topology, const EdgeMetric &metric, VertBitSet &region, float dilation, ProgressCallback callback={})
MRMESH_API bool	dilateRegionByMetric (const MeshTopology &topology, const EdgeMetric &metric, UndirectedEdgeBitSet &region, float dilation, ProgressCallback callback={})
MRMESH_API bool	erodeRegionByMetric (const MeshTopology &topology, const EdgeMetric &metric, FaceBitSet &region, float dilation, ProgressCallback callback={})
	shrinks the region (of faces or vertices) on given metric value. returns false if callback also returns false
MRMESH_API bool	erodeRegionByMetric (const MeshTopology &topology, const EdgeMetric &metric, VertBitSet &region, float dilation, ProgressCallback callback={})
MRMESH_API bool	erodeRegionByMetric (const MeshTopology &topology, const EdgeMetric &metric, UndirectedEdgeBitSet &region, float dilation, ProgressCallback callback={})
MRMESH_API bool	dilateRegion (const Mesh &mesh, FaceBitSet &region, float dilation, ProgressCallback callback={})
	expands the region (of faces or vertices) on given value (in meters). returns false if callback also returns false
MRMESH_API bool	dilateRegion (const Mesh &mesh, VertBitSet &region, float dilation, ProgressCallback callback={})
MRMESH_API bool	dilateRegion (const Mesh &mesh, UndirectedEdgeBitSet &region, float dilation, ProgressCallback callback={})
MRMESH_API bool	erodeRegion (const Mesh &mesh, FaceBitSet &region, float dilation, ProgressCallback callback={})
	shrinks the region (of faces or vertices) on given value (in meters). returns false if callback also returns false
MRMESH_API bool	erodeRegion (const Mesh &mesh, VertBitSet &region, float dilation, ProgressCallback callback={})
MRMESH_API bool	erodeRegion (const Mesh &mesh, UndirectedEdgeBitSet &region, float dilation, ProgressCallback callback={})
MRMESH_API int	getPathPlaneIntersections (const Mesh &mesh, const EdgePath &path, const Plane3f &plane, std::vector< MeshEdgePoint > *outIntersections=nullptr)
	finds all intersection points between given path and plane, adds them in outIntersections and returns their number
MRMESH_API int	getPathEdgesInPlane (const Mesh &mesh, const EdgePath &path, const Plane3f &plane, float tolerance=0.0f, std::vector< EdgeId > *outInPlaneEdges=nullptr)
	finds all path edges located in given plane with given tolerance, adds them in outInPlaneEdges and returns their number
MRMESH_API Expected< ObjectMesh >	makeObjectMeshFromFile (const std::filesystem::path &file, const MeshLoadInfo &info={})
	loads mesh from given file in new object
MRMESH_API Expected< std::shared_ptr< Object > >	makeObjectFromMeshFile (const std::filesystem::path &file, const MeshLoadInfo &info={}, bool returnOnlyMesh=false)
	loads mesh from given file and makes either ObjectMesh or ObjectPoints (if the file has points but not faces)
MRMESH_API Expected< ObjectLines >	makeObjectLinesFromFile (const std::filesystem::path &file, ProgressCallback callback={})
	loads lines from given file in new object
MRMESH_API Expected< ObjectPoints >	makeObjectPointsFromFile (const std::filesystem::path &file, ProgressCallback callback={})
	loads points from given file in new object
MRMESH_API Expected< ObjectDistanceMap >	makeObjectDistanceMapFromFile (const std::filesystem::path &file, ProgressCallback callback={})
	loads distance map from given file in new object
MRMESH_API Expected< ObjectGcode >	makeObjectGcodeFromFile (const std::filesystem::path &file, ProgressCallback callback={})
	loads gcode from given file in new object
MRMESH_API Expected< std::vector< std::shared_ptr< Object > > >	loadObjectFromFile (const std::filesystem::path &filename, std::string *loadWarn=nullptr, ProgressCallback callback={})
	load object (mesh, lines, points, voxels or scene) from file
MRMESH_API bool	isSupportedFileInSubfolders (const std::filesystem::path &folder)
MRMESH_API Expected< Object >	makeObjectTreeFromFolder (const std::filesystem::path &folder, std::string *loadWarn=nullptr, ProgressCallback callback={})
	loads meshes from given folder in new container object
MRMESH_API Expected< std::shared_ptr< Object > >	loadSceneFromAnySupportedFormat (const std::filesystem::path &path, std::string *loadWarn=nullptr, ProgressCallback callback={})
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
template<typename T >
Vector2< T >	fromEigen (const Eigen::Matrix< T, 2, 1 > &ev)
template<typename T >
Eigen::Matrix< T, 2, 1 >	toEigen (const Vector2< T > &v)
template<typename T >
Eigen::Matrix< T, 2, 2 >	toEigen (const SymMatrix2< T > &m)
template<typename T >
Eigen::Matrix< T, 2, 2 >	toEigen (const Matrix2< T > &m)
template<typename T >
Matrix2< T >	fromEigen (const Eigen::Matrix< T, 2, 2 > &m)
template<typename T >
Vector3< T >	fromEigen (const Eigen::Matrix< T, 3, 1 > &ev)
template<typename T >
Eigen::Matrix< T, 3, 1 >	toEigen (const Vector3< T > &v)
template<typename T >
Eigen::Matrix< T, 3, 3 >	toEigen (const SymMatrix3< T > &m)
template<typename T >
Eigen::Matrix< T, 3, 3 >	toEigen (const Matrix3< T > &m)
template<typename T >
Matrix3< T >	fromEigen (const Eigen::Matrix< T, 3, 3 > &m)
template<typename T >
Eigen::Matrix< T, 4, 4 >	toEigen (const SymMatrix4< T > &m)
template<typename T >
Eigen::Matrix< T, 4, 4 >	toEigen (const Matrix4< T > &m)
template<typename T >
Matrix4< T >	fromEigen (const Eigen::Matrix< T, 4, 4 > &m)
template<typename T >
Vector4< T >	fromEigen (const Eigen::Matrix< T, 4, 1 > &ev)
template<typename T >
Eigen::Matrix< T, 4, 1 >	toEigen (const Vector4< T > &v)
template<typename T >
Eigen::Matrix< T, 4, 1 >	toEigen (const Vector3< T > &v, T w)
template<typename T >
Quaternion< T >	fromEigen (const Eigen::Quaternion< T > &eq)
template<typename T >
Eigen::Quaternion< T >	toEigen (const Quaternion< T > &q)

Variables
MRMESH_API const IOFilters	AllFilter
constexpr float	cQuietNan = std::numeric_limits<float>::quiet_NaN()
constexpr int	cQuietNanBits = std::bit_cast< int >( cQuietNan )
constexpr NoInit	noInit
template<typename T >
struct MRMESH_CLASS	NoDefInit
class MRMESH_CLASS	EdgeTag
class MRMESH_CLASS	UndirectedEdgeTag
class MRMESH_CLASS	FaceTag
class MRMESH_CLASS	VertTag
class MRMESH_CLASS	PixelTag
class MRMESH_CLASS	VoxelTag
class MRMESH_CLASS	RegionTag
class MRMESH_CLASS	NodeTag
class MRMESH_CLASS	ObjTag
class MRMESH_CLASS	TextureTag
class MRMESH_CLASS	GraphVertTag
class MRMESH_CLASS	GraphEdgeTag
	I = size_t> class MRMESH_CLASS Buffer
class MRMESH_CLASS	BitSet
	SetBitIteratorT
	SetBitIterator
MRMESH_CLASS	Vector3
MRMESH_CLASS	Vector3b
MRMESH_CLASS Vector3< double >	Matrix2
MRMESH_CLASS Vector3< double >	Matrix2b
MRMESH_CLASS Vector3< double > Matrix2< double >	Matrix4
MRMESH_CLASS Vector3< double > Matrix2< double >	Matrix4b
MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double >	SymMatrix3
MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double >	SymMatrix3b
MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double >	AffineXf
MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double >	AffineXf2f
	RigidScaleXf3
	RigidScaleXf3f
	BestFitParabola
	BestFitParabolaf
	Cylinder3
	Cylinder3f
	Cone3
	Cone3f
	Box
	Box1i
struct MRMESH_CLASS	Dipole
	Hash = phmap::priv::hash_default_hash<T>
	Eq
class MRMESH_CLASS	MeshTopology
struct MRMESH_CLASS	Mesh
class MRMESH_CLASS	MeshOrPoints
struct MRMESH_CLASS	PointCloud
class MRMESH_CLASS	AABBTree
class MRMESH_CLASS	AABBTreePoints
class MRMESH_CLASS	AABBTreeObjects
struct MRMESH_CLASS	CloudPartMapping
struct MRMESH_CLASS	PartMapping
	AABBTreePolyline
	AABBTreePolyline2
	PolylineProjectionWithOffsetResult
	Polyline2ProjectionWithOffsetResult
class MRMESH_CLASS	ChangeSceneAction
template<typename... >
constexpr bool	dependent_false = false
MRMESH_API const double	BadTriangulationMetric
constexpr Vector3i	neiPosDelta [OutEdgeCount]
MRVIEWER_API DemoPlugin	DemoPluginInstance
constexpr float	cGradientButtonFramePadding = 7.5f
constexpr float	cTabYOffset = 4.0f
constexpr float	cTabsInterval = 8.0f
constexpr float	cTabFrameRounding = 5.0f
constexpr float	cTabMinimumWidth = 68.0f
constexpr float	cTabHeight = 28.0f
constexpr float	cTabLabelMinPadding = 12.0f
constexpr float	cTopPanelScrollStep = 50.0f
constexpr float	cTopPanelScrollBtnSize = 20.0f
constexpr float	cTopPanelAditionalButtonSize = cTabHeight - cTabYOffset
constexpr float	cSeparateBlocksSpacing = 12.0f
constexpr float	cSeparatorIndentMultiplier = 0.67f
constexpr float	cRibbonItemInterval = 4.0f
constexpr float	cRibbonItemMinWidth = 86.0f
constexpr float	cRibbonButtonWindowPaddingX = 6.0f
constexpr float	cRibbonButtonWindowPaddingY = 4.0f
constexpr float	cCheckboxPadding = 2.0f
constexpr float	cButtonPadding = 8.0f
constexpr float	cInputPadding = 9.0f
constexpr float	cDefaultItemSpacing = 8.0f
constexpr float	cDefaultInnerSpacing = 8.0f
constexpr float	cDefaultWindowPaddingX = 8.0f
constexpr float	cDefaultWindowPaddingY = 12.0f
constexpr float	cItemInfoIndent = 16.0f
constexpr float	cSmallItemDropSizeModifier = 0.5f
constexpr float	cHeaderQuickAccessFrameRounding = 3.0f
constexpr float	cHeaderQuickAccessXSpacing = 12.0f
constexpr float	cHeaderQuickAccessIconSize = 14.0f
constexpr float	cHeaderQuickAccessFrameSize = 24.0f
constexpr float	cMiddleIconSize = 15.0f
constexpr float	cSmallIconSize = 10.0f
constexpr float	cQuickAccessBarHeight = 40.0f
constexpr float	cScrollBarSize = 10.0f
constexpr float	cBigIconSize = 20.0f
constexpr int	cSmallFontSize = 11
constexpr int	cDefaultFontSize = 13
constexpr int	cBigFontSize = 15
constexpr int	cHeadlineFontSize = 20
constexpr float	cRadioButtonSize = 20.0f
constexpr float	cModalWindowWidth = 368.0f
constexpr float	cModalWindowPaddingX = 28.0f
constexpr float	cModalWindowPaddingY = 20.0f
constexpr float	cModalButtonWidth = 104.0f
const float	cRadioInnerSpacingX = 12.f
enum class	ObjectSelectivityType { ObjectSelectivityType::Selectable , ObjectSelectivityType::Selected , ObjectSelectivityType::Any }
template<typename ObjectT = Object>
std::shared_ptr< ObjectT >	asSelectivityType (std::shared_ptr< Object > obj, const ObjectSelectivityType &type)
	if input object is of given type then returns another pointer on it
template<typename ObjectT = Object>
std::vector< std::shared_ptr< ObjectT > >	getAllObjectsInTree (Object *root, const ObjectSelectivityType &type=ObjectSelectivityType::Selectable)
template<typename ObjectT = Object>
std::vector< std::shared_ptr< ObjectT > >	getAllObjectsInTree (Object &root, const ObjectSelectivityType &type=ObjectSelectivityType::Selectable)
template<typename ObjectT = Object>
std::vector< std::shared_ptr< ObjectT > >	getTopmostVisibleObjects (Object *root, const ObjectSelectivityType &type=ObjectSelectivityType::Selectable)
	Returns all topmost visible objects of given type (if an object is returned, its children are not) excluding root.
template<typename ObjectT = Object>
std::vector< std::shared_ptr< ObjectT > >	getTopmostVisibleObjects (Object &root, const ObjectSelectivityType &type=ObjectSelectivityType::Selectable)
template<typename ObjectT = Object>
std::shared_ptr< ObjectT >	getDepthFirstObject (Object *root, const ObjectSelectivityType &type)
	return first object of given type in depth-first traverse order excluding root
template<typename ObjectT = Object>
std::shared_ptr< ObjectT >	getDepthFirstObject (Object &root, const ObjectSelectivityType &type)
using	ObjectMakerFunc = std::shared_ptr<Object>()
MRMESH_API std::shared_ptr< Object >	createObject (const std::string &className)
	the function to create new object instance by registered class name
using	ConvertToIntVector2 = std::function<Vector2i( const Vector2f& )>
	float-to-int coordinate converter
using	ConvertToFloatVector2 = std::function<Vector2f( const Vector2i& )>
	int-to-float coordinate converter
MRMESH_API bool	ccw (const Vector2i &a, const Vector2i &b)
bool	ccw (const Vector2i &a, const Vector2i &b, const Vector2i &c)
MRMESH_API bool	ccw (const std::array< PreciseVertCoords2, 3 > &vs)
	first sorts the indices in ascending order, then calls the predicate for sorted points
MRMESH_API bool	ccw (const PreciseVertCoords2 *vs)
MRMESH_API SegmentSegmentIntersectResult	doSegmentSegmentIntersect (const std::array< PreciseVertCoords2, 4 > &vs)
MRMESH_API Vector2i	findSegmentSegmentIntersectionPrecise (const Vector2i &a, const Vector2i &b, const Vector2i &c, const Vector2i &d)
MRMESH_API Vector2f	findSegmentSegmentIntersectionPrecise (const Vector2f &a, const Vector2f &b, const Vector2f &c, const Vector2f &d, CoordinateConverters2 converters)
using	ConvertToIntVector = std::function<Vector3i( const Vector3f& )>
	float-to-int coordinate converter
using	ConvertToFloatVector = std::function<Vector3f( const Vector3i& )>
	int-to-float coordinate converter
MRMESH_API bool	orient3d (const Vector3i &a, const Vector3i &b, const Vector3i &c)
bool	orient3d (const Vector3i &a, const Vector3i &b, const Vector3i &c, const Vector3i &d)
MRMESH_API bool	orient3d (const std::array< PreciseVertCoords, 4 > &vs)
	first sorts the indices in ascending order, then calls the predicate for sorted points
MRMESH_API bool	orient3d (const PreciseVertCoords *vs)
MRMESH_API TriangleSegmentIntersectResult	doTriangleSegmentIntersect (const std::array< PreciseVertCoords, 5 > &vs)
MRMESH_API ConvertToIntVector	getToIntConverter (const Box3d &box)
	creates converter from Vector3f to Vector3i in Box range (int diapason is mapped to box range)
MRMESH_API ConvertToFloatVector	getToFloatConverter (const Box3d &box)
	creates converter from Vector3i to Vector3f in Box range (int diapason is mapped to box range)
MRMESH_API Vector3f	findTriangleSegmentIntersectionPrecise (const Vector3f &a, const Vector3f &b, const Vector3f &c, const Vector3f &d, const Vector3f &e, CoordinateConverters converters)

Detailed Description

we have C++/CLI project MRMeshDotNet which doesn't support std::expected So we have to wrap tl::expected with this class in std namespace for correct linking

Typedef Documentation

AffineXf3

template<typename T >

using MR::AffineXf3 = AffineXf<Vector3<T>>

BestFitPolynomiald

template<size_t degree>

using MR::BestFitPolynomiald = BestFitPolynomial<double, degree>

BestFitPolynomialf

template<size_t degree>

using MR::BestFitPolynomialf = BestFitPolynomial<float, degree>

Box1

template<typename T >

using MR::Box1 = Box<T>

Box2

template<typename T >

using MR::Box2 = Box<Vector2<T>>

Box3

template<typename T >

using MR::Box3 = Box<Vector3<T>>

ContinuousContour

using MR::ContinuousContour = std::vector<VariableEdgeTri>

ContinuousContours

using MR::ContinuousContours = std::vector<ContinuousContour>

Contour2

template<typename T >

using MR::Contour2 = Contour<Vector2<T>>

Contour2d

using MR::Contour2d = Contour2<double>

Contour2f

using MR::Contour2f = Contour2<float>

Contour3

template<typename T >

using MR::Contour3 = Contour<Vector3<T>>

Contour3d

typedef Contour3< double > MR::Contour3d = Contour3<double>

Contour3f

typedef Contour3< float > MR::Contour3f = Contour3<float>

Contours

template<typename V >

using MR::Contours = std::vector<Contour<V>>

Contours2

template<typename T >

using MR::Contours2 = Contours<Vector2<T>>

Contours2d

using MR::Contours2d = Contours2<double>

Contours2f

using MR::Contours2f = Contours2<float>

Contours3

template<typename T >

using MR::Contours3 = Contours<Vector3<T>>

Contours3d

typedef std::vector< Contour3d > MR::Contours3d = Contours3<double>

Contours3f

typedef std::vector< Contour3f > MR::Contours3f = Contours3<float>

ContoursVariableOffset

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

ConvertToFloatVector

using MR::ConvertToFloatVector = std::function<Vector3f( const Vector3i& )>

int-to-float coordinate converter

ConvertToFloatVector2

using MR::ConvertToFloatVector2 = std::function<Vector2f( const Vector2i& )>

int-to-float coordinate converter

ConvertToIntVector

using MR::ConvertToIntVector = std::function<Vector3i( const Vector3f& )>

float-to-int coordinate converter

ConvertToIntVector2

using MR::ConvertToIntVector2 = std::function<Vector2i( const Vector2f& )>

float-to-int coordinate converter

DecimatePolylineSettings2

using MR::DecimatePolylineSettings2 = DecimatePolylineSettings<Vector2f>

DecimatePolylineSettings3

using MR::DecimatePolylineSettings3 = DecimatePolylineSettings<Vector3f>

DisabledWarnings

using MR::DisabledWarnings = std::vector<ShaderWarning>

EdgeHashMap

using MR::EdgeHashMap = HashMap<EdgeId, EdgeId>

EdgeHashSet

using MR::EdgeHashSet = HashSet<EdgeId>

EdgeLoop

using MR::EdgeLoop = std::vector<EdgeId>

EdgeLoops

using MR::EdgeLoops = std::vector<EdgeLoop>

EdgeMetric

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

EdgePair

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

EdgePath

using MR::EdgePath = std::vector<EdgeId>

EdgePathsBuilder

using MR::EdgePathsBuilder = EdgePathsBuilderT<TrivialMetricToPenalty>

EdgePredicate

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

Expected

template<class T , class E = std::string>

using MR::Expected = tl::expected<T, E>

FaceHashMap

using MR::FaceHashMap = HashMap<FaceId, FaceId>

FaceHashSet

using MR::FaceHashSet = HashSet<FaceId>

FaceMetric

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

FacePair

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

FacePredicate

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

FeaturesPropertyTypesVariant

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

FileNamesStack

typedef std::vector< std::filesystem::path > MR::FileNamesStack = std::vector<std::filesystem::path>

FloatGrid

using MR::FloatGrid = std::shared_ptr<OpenVdbFloatGrid>

FolderCallback

using MR::FolderCallback = std::function<void( const std::filesystem::path& tempFolderName )>

this callback will be called before compression on serialization and after decompression on deserialization

FoundPointCallback

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

GcodeSource

typedef std::vector< std::string > MR::GcodeSource = std::vector<std::string>

GroupsItemsMap

using MR::GroupsItemsMap = TabsGroupsMap

HashMap

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

using MR::HashMap = phmap::flat_hash_map<K, V, Hash, Eq>

HistoryActionsVector

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

HistoryStackFilter

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

ICPElementBitSet

using MR::ICPElementBitSet = TaggedBitSet<ICPElemtTag>

ICPElementId

using MR::ICPElementId = Id<ICPElemtTag>

ICPGroupProjector

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

ICPLayer

using MR::ICPLayer = int

ICPObjects

using MR::ICPObjects = Vector<MeshOrPointsXf, ObjId>

ICPPairsGrid

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

IRenderObjectConstructorLambda

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

IsoLine

using MR::IsoLine = SurfacePath

IsoLines

using MR::IsoLines = SurfacePaths

ItemMap

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

LeftRingIterator

using MR::LeftRingIterator = RingIterator<NextEdgeSameLeft>

Line3

template<typename T >

using MR::Line3 = Line<Vector3<T>>

LineSegm3

template<typename T >

using MR::LineSegm3 = LineSegm<Vector3<T>>

MenuItemsList

typedef std::vector< std::string > MR::MenuItemsList = std::vector<std::string>

MenuItemsListMigration

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

MenuItemsListMigrations

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

MeshEdgePoint

using MR::MeshEdgePoint = EdgePoint

MeshOnVoxels

using MR::MeshOnVoxels = MeshOnVoxelsT<Mesh>

MeshOnVoxelsC

using MR::MeshOnVoxelsC = MeshOnVoxelsT<const Mesh>

MinMaxd

using MR::MinMaxd = MinMax<double>

MinMaxf

using MR::MinMaxf = MinMax<float>

MultiObjsSamples

using MR::MultiObjsSamples = std::vector<ObjVertId>

NotificationTagMask

using MR::NotificationTagMask = unsigned

ObjectMakerFunc

using MR::ObjectMakerFunc = std::shared_ptr<Object>()

ObjectPtr

using MR::ObjectPtr = std::shared_ptr<Object>

OffsetContoursVertMap

using MR::OffsetContoursVertMap = std::vector<OffsetContoursOrigins>

OffsetContoursVertMaps

using MR::OffsetContoursVertMaps = std::vector<OffsetContoursVertMap>

OnEdgeSplit

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

OrgRingIterator

using MR::OrgRingIterator = RingIterator<NextEdgeSameOrigin>

ParallelHashMap

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

using MR::ParallelHashMap = phmap::parallel_flat_hash_map<K, V, Hash, Eq>

ParallelHashSet

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

using MR::ParallelHashSet = phmap::parallel_flat_hash_set<T, Hash, Eq>

PathMeshEdgePointCallback

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

PickedPoint

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

PlaneSection

using MR::PlaneSection = SurfacePath

PlaneSections

using MR::PlaneSections = SurfacePaths

Polynomiald

template<size_t degree>

using MR::Polynomiald = Polynomial<double, degree>

Polynomialf

template<size_t degree>

using MR::Polynomialf = Polynomial<float, degree>

PolynomialWrapperd

using MR::PolynomialWrapperd = PolynomialWrapper<double>

PolynomialWrapperf

using MR::PolynomialWrapperf = PolynomialWrapper<float>

Polynomialx

template<typename T >

using MR::Polynomialx

Initial value:

 std::variant
    < Polynomial<T, 0>
    , Polynomial<T, 1>
    , Polynomial<T, 2>
    , Polynomial<T, 3>
    , Polynomial<T, 4>
    , Polynomial<T, 5>
    , Polynomial<T, 6>
    >

PreCollapseCallback

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

ProjectOnAllCallback

using MR::ProjectOnAllCallback = std::function<void( ObjId, MeshOrPoints::ProjectionResult )>

to receive object id + projection result on it

QuadraticForm3

template<typename T >

using MR::QuadraticForm3 = QuadraticForm<Vector3<T>>

RegularGridLatticePositioner

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

RegularGridLatticeValidator

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

RegularGridMeshFaceValidator

using MR::RegularGridMeshFaceValidator

Initial value:

 
        std::function<bool( size_t x0, size_t y0, size_t x1, size_t y1, size_t x2, size_t y2 )>

RenderDefaultUiObject

using MR::RenderDefaultUiObject = RenderObjectCombinator<RenderNameObject>

RenderDimensionObject

using MR::RenderDimensionObject = RenderObjectCombinator<RenderDefaultUiObject, RenderResetDirtyComponent>

SeparationPointMap

using MR::SeparationPointMap = HashMap<size_t, SeparationPointSet>

SeparationPointSet

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

Sphere3

template<typename T >

using MR::Sphere3 = Sphere<Vector3<T>>

SplitCaptionInfo

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

StatePlugin

using MR::StatePlugin = StateListenerPlugin<>

SurfacePath

using MR::SurfacePath = std::vector<MeshEdgePoint>

SurfacePaths

using MR::SurfacePaths = std::vector<SurfacePath>

TabsGroupsMap

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

ThreeVertIds

using MR::ThreeVertIds = std::array<VertId, 3>

three vertex ids describing a triangle topology

Time

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

TransformModesValidator

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

Triangle3d

using MR::Triangle3d = Triangle3<double>

Triangle3f

using MR::Triangle3f = Triangle3<float>

Triangle3i

using MR::Triangle3i = Triangle3<int>

TrianglesRepetitions

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

TrianglesRepetitions[0] contains the number of triangles that appear in different local triangulations with opposite orientations TrianglesRepetitions[1] contains the number of unoriented triangles that appear in one local triangulation only TrianglesRepetitions[2] contains the number of unoriented triangles that appear in exactly two local triangulations TrianglesRepetitions[3] contains the number of unoriented triangles that appear in three local triangulations

UndirectedEdgeHashMap

using MR::UndirectedEdgeHashMap = HashMap<UndirectedEdgeId, UndirectedEdgeId>

UndirectedEdgeMetric

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

UndirectedEdgePair

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

UndirectedEdgePredicate

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

UVCoord

using MR::UVCoord = Vector2f

Coordinates on texture

Parameters

x,y	should be in range [0..1], otherwise result depends on wrap type of texture (no need to clamp it, it is done on GPU if wrap type is "Clamp" )

VarUnitToStringParams

using MR::VarUnitToStringParams

Initial value:

 std::variant<
 
 
 
 
>

VertHashMap

using MR::VertHashMap = HashMap<VertId, VertId>

VertHashSet

using MR::VertHashSet = HashSet<VertId>

VertMetric

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

VertPair

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

VertPathInfoMap

using MR::VertPathInfoMap = HashMap<VertId, VertPathInfo>

ViewerEventCallback

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

ViewportRectangle

using MR::ViewportRectangle = Box2f

Viewport size.

VolumePartBuilder

template<typename Volume >

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

functor returning a voxel volume part within the specified range, or an error string on failure the offset parameter is also required for SimpleVolume parts

VoxelPointPositioner

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

WholeEdgeHashMap

using MR::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

Enumeration Type Documentation

AlignType

enum MR::AlignType

Enumerator
Left
Center
Right

AngleUnit

enum class MR::AngleUnit

strong

Enumerator
radians
degrees
_count

ArcPlane

enum class MR::ArcPlane

strong

Enumerator
None
XY
XZ
YZ

AreaUnit

enum class MR::AreaUnit

strong

Enumerator
mm2
meters2
inches2
_count

Axis

enum class MR::Axis

strong

Enumerator
X
Y
Z
Count

BypassDirection

enum class MR::BypassDirection

strong

Enumerator
Clockwise
CounterClockwise

ConeFitterType

enum class MR::ConeFitterType

strong

Enumerator
ApproximationPCM
HemisphereSearchFit
SpecificAxisFit

ControlBit

enum class MR::ControlBit

strong

Enumerator
None
RotX
RotY
RotZ
RotMask
MoveX
MoveY
MoveZ
MoveMask
FullMask

DecimateStrategy

enum MR::DecimateStrategy

Defines the order of edge collapses inside Decimate algorithm.

Enumerator
MinimizeError
ShortestEdgeFirst

DegreesMode

enum class MR::DegreesMode

strong

Enumerator
degrees
degreesMinutes
degreesMinutesSeconds
_count

DepthFunction

enum class MR::DepthFunction

strong

Enumerator
Never
Less
Equal
Greater
LessOrEqual
GreaterOrEqual
NotEqual
Always
Default

EdgeWeights

enum class MR::EdgeWeights

strong

determines the weight of each edge in applications like Laplacian

Enumerator
Unit	all edges have same weight=1
Cotan	edge weight depends on local geometry and uses cotangent values
CotanTimesLength	[deprecated] edge weight is equal to edge length times cotangent weight
CotanWithAreaEqWeight	cotangent edge weights and equation weights inversely proportional to square root of local area

FeaturePropertyKind

enum class MR::FeaturePropertyKind

strong

Enumerator
position
linearDimension
direction
angle
other

FeaturesObjectKind

enum class MR::FeaturesObjectKind

strong

Which object type we're adding. Update ObjKindTraits if you change this enum.

Enumerator
Point
Line
Plane
Circle
Sphere
Cylinder
Cone
_count

FilterType

enum class MR::FilterType : char

strong

Enumerator
Linear
Discrete

FitMode

enum class MR::FitMode

strong

Enumerator
Visible
SelectedPrimitives
SelectedObjects
CustomObjectsList

ICPExitType

enum class MR::ICPExitType

strong

Enumerator
NotStarted
NotFoundSolution
MaxIterations
MaxBadIterations
StopMsdReached

ICPMethod

enum class MR::ICPMethod

strong

The method how to update transformation from point pairs.

Enumerator
Combined	PointToPoint for the first 2 iterations, and PointToPlane for the remaining iterations.
PointToPoint	it is the safest approach but can converge slowly select transformation that minimizes mean squared distance between two points in each pair,
PointToPlane	converge much faster than PointToPoint in case of many good (with not all points/normals in one plane) pairs select transformation that minimizes mean squared distance between a point and a plane via the other point in each pair,

ICPMode

enum class MR::ICPMode

strong

The group of transformations, each with its own degrees of freedom.

Enumerator
RigidScale	rigid body transformation with uniform scaling (7 degrees of freedom)
AnyRigidXf	rigid body transformation (6 degrees of freedom)
OrthogonalAxis	rigid body transformation with rotation except argument axis (5 degrees of freedom)
FixedAxis	rigid body transformation with rotation around given axis only (4 degrees of freedom)
TranslationOnly	only translation (3 degrees of freedom)

InvLengthUnit

enum class MR::InvLengthUnit

strong

Enumerator
inv_mm
inv_meters
inv_inches
_count

LengthUnit

enum class MR::LengthUnit

strong

Enumerator
mm
meters
inches
_count

MouseButton

enum class MR::MouseButton

strong

Enumerator
Left
Right
Middle
Count
NoButton

MouseMode

enum class MR::MouseMode

strong

Enumerator
None
Rotation
Translation
Roll
Count

MovementSpeedUnit

enum class MR::MovementSpeedUnit

strong

Enumerator
mmPerSecond
metersPerSecond
inchesPerSecond
_count

MoveType

enum class MR::MoveType

strong

Enumerator
None
FastLinear
Linear
ArcCW
ArcCCW

NeighborDir

enum class MR::NeighborDir

strong

Enumerator
X
Y
Z
Count

NestedComponenetsMode

enum class MR::NestedComponenetsMode

strong

Enumerator
Remove
Merge
Union

NotificationType

enum class MR::NotificationType

strong

Enumerator
Error
Warning
Info
Time
Count

NoUnit

enum class MR::NoUnit

strong

Enumerator
_count

NumberStyle

enum class MR::NumberStyle

strong

Enumerator
normal
distributePrecision
exponential
maybeExponential

OffsetMode

enum class MR::OffsetMode : int

strong

Enumerator
Smooth	create mesh using dual marching cubes from OpenVDB library
Standard	create mesh using standard marching cubes implemented in MeshLib
Sharpening	create mesh using standard marching cubes with additional sharpening implemented in MeshLib

OrientNormals

enum class MR::OrientNormals

strong

the method how to choose between two opposite normal orientations

Enumerator
TowardOrigin
AwayFromOrigin
Smart

PathPreference

enum class MR::PathPreference

strong

Enumerator
Geodesic
Convex
Concave

PixelSizeUnit

enum class MR::PixelSizeUnit

strong

Enumerator
pixels
_count

Processing

enum class MR::Processing : bool

strong

typically returned from callbacks to control the behavior of main algorithm

Enumerator
Continue
Stop

RatioUnit

enum class MR::RatioUnit

strong

Enumerator
factor
percents
_count

RelaxApproxType

enum class MR::RelaxApproxType

strong

Enumerator
Planar
Quadric

RenderModelPassMask

enum class MR::RenderModelPassMask

strong

Various passes of the 3D rendering.

Enumerator
Opaque
Transparent
VolumeRendering
NoDepthTest
All

Reorder

enum class MR::Reorder : char

strong

determines how points to be ordered

Enumerator
None	the order is not changed
Lexicographically	the order is determined by lexicographical sorting by coordinates (optimal for uniform sampling)
AABBTree	the order is determined so to put close in space points in close indices (optimal for compression)

RibbonItemType

enum class MR::RibbonItemType

strong

Enumerator
Button
ButtonWithDrop

RibbonLayoutMode

enum class MR::RibbonLayoutMode

strong

Enumerator
None
SceneTree
All

ScalarType

enum class MR::ScalarType

strong

scalar value's binary format type

Enumerator
UInt8
Int8
UInt16
Int16
UInt32
Int32
UInt64
Int64
Float32
Float64
Float32_4	the last value from float[4]
Unknown
Count

SelectedTypesMask

enum class MR::SelectedTypesMask

strong

Enumerator
ObjectBit
ObjectPointsHolderBit
ObjectLinesHolderBit
ObjectMeshHolderBit
ObjectLabelBit
ObjectMeshBit
ObjectFeatureBit
ObjectMeasurementBit

ShortcutCategory

enum class MR::ShortcutCategory : char

strong

Enumerator
Info
Edit
View
Scene
Objects
Selection
Count

Side

enum class MR::Side

strong

Enumerator
Negative
Positive

SignDetectionMode

enum class MR::SignDetectionMode

strong

how to determine the sign of distances from a mesh

Enumerator
Unsigned	unsigned distance, useful for bidirectional Shell offset
OpenVDB	sign detection from OpenVDB library, which is good and fast if input geometry is closed
ProjectionNormal	the sign is determined based on pseudonormal in closest mesh point (unsafe in case of self-intersections)
WindingRule	ray intersection counter, significantly slower than ProjectionNormal and does not support holes in mesh
HoleWindingRule	computes winding number generalization with support of holes in mesh, slower than WindingRule

SignDetectionModeShort

enum class MR::SignDetectionModeShort

strong

how to determine the sign of distances from a mesh, short version including auto-detection

Enumerator
Auto	automatic selection of the fastest method among safe options for the current mesh
HoleWindingNumber	detects sign from the winding number generalization with support for holes and self-intersections in mesh
ProjectionNormal	detects sign from the pseudonormal in closest mesh point, which is fast but unsafe in the presence of holes and self-intersections in mesh

SpaceMouseButtons

enum MR::SpaceMouseButtons : int

enumeration all spacemouse buttons

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

StatePluginTabs

enum class MR::StatePluginTabs

strong

Enumerator
Basic
Mesh
DistanceMap
PointCloud
Selection
Voxels
Analysis
Test
Other
Count

TimeUnit

enum class MR::TimeUnit

strong

Enumerator
seconds
milliseconds
_count

UseAABBTree

enum class MR::UseAABBTree : char

strong

Enumerator
No
Yes
YesIfAlreadyConstructed

VolumeUnit

enum class MR::VolumeUnit

strong

Enumerator
mm3
meters3
inches3
_count

VoxelFilterType

enum class MR::VoxelFilterType : int

strong

Enumerator
Median
Mean
Gaussian

WrapType

enum class MR::WrapType : char

strong

Enumerator
Repeat
Mirror
Clamp

Function Documentation

AABBTreePolyline< Vector2f >()

MR::AABBTreePolyline< Vector2f >	(	AABBTreePolyline3	,
		AABBTreePolyline< Vector3f >	)

addBaseToPlanarMesh()

MRSYMBOLMESH_API void MR::addBaseToPlanarMesh	(	Mesh &	mesh,
		float	zOffset = 1.0f )

addFileNameInError()

template<typename T >

Expected< T > MR::addFileNameInError ( Expected< T > v, const std::filesystem::path & file )

inlinenodiscard

if (v) contains an error, then appends given file name to that error

addNoise()

MRMESH_API Expected< void > MR::addNoise	(	VertCoords &	points,
		const VertBitSet &	validVerts,
		NoiseSettings	settings )

AffineXf< Vector2< float > >()

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

AffineXf< Vector3< float > >()

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double > MR::AffineXf< Vector3< float > >	(	AffineXf3d	,
		AffineXf< Vector3< double > >	)

alignTextToMesh()

MRSYMBOLMESH_API Expected< Mesh > MR::alignTextToMesh	(	const Mesh &	mesh,
		const TextMeshAlignParams &	params )

appendGPUVisibleFaces()

MRVIEWER_API void MR::appendGPUVisibleFaces	(	const Viewport &	viewport,
		const BitSet &	pixBs,
		const std::vector< std::shared_ptr< ObjectMesh > > &	objects,
		std::vector< FaceBitSet > &	visibleFaces,
		bool	includeBackfaces = true )

appends viewport visible faces (in pixBs) to visibleFaces

Parameters

pixBs	the matrix of pixels (in local space of viewport) belonging selected area
objects	of interest
visibleFaces	vector that correspond to objects and will be updated in this function
includeBackfaces	get also faces from back side of object

AppendHistory() [1/2]

template<class HistoryActionType , typename... Args>

void MR::AppendHistory

(

Args &&...

args

)

AppendHistory() [2/2]

template<class HistoryActionType >

void MR::AppendHistory

(

std::shared_ptr< HistoryActionType >

action

)

applyDouble() [1/2]

Vector3d MR::applyDouble ( const AffineXf3d * xf, const Vector3f & p )

inline

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

applyDouble() [2/2]

Vector3d MR::applyDouble ( const Matrix3d * m, const Vector3f & n )

inline

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

applyFloat() [1/2]

Vector3f MR::applyFloat ( const AffineXf3d * xf, const Vector3f & p )

inline

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

applyFloat() [2/2]

Vector3f MR::applyFloat ( const Matrix3d * m, const Vector3f & n )

inline

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

area() [1/2]

template<typename T >

T MR::area ( const Vector2< T > & p, const Vector2< T > & q, const Vector2< T > & r )

inlinenodiscard

computes twice the area of given triangle

area() [2/2]

template<typename T >

T MR::area ( const Vector3< T > & p, const Vector3< T > & q, const Vector3< T > & r )

inlinenodiscard

computes twice the area of given triangle

asString()

MRMESH_API const char * MR::asString ( SignDetectionMode m )

nodiscard

returns string representation of enum values

autoOrientLocalTriangulations()

MRMESH_API bool MR::autoOrientLocalTriangulations	(	const PointCloud &	pointCloud,
		AllLocalTriangulations &	triangs,
		const VertBitSet &	region,
		ProgressCallback	progress = {},
		Triangulation *	outRep3 = nullptr,
		Triangulation *	outRep2 = nullptr )

orient neighbors around each point in

Parameters

region

so there will be as many triangles with same (and not opposite) orientation as possible optional output with all oriented triangles that appear in exactly two local triangulations

Parameters

outRep3

optional output with all oriented triangles that appear in three local triangulations

begin() [1/6]

template<typename T , typename I >

auto MR::begin ( Buffer< T, I > & a )

inlinenodiscard

begin() [2/6]

template<typename T , typename I >

auto MR::begin ( const Buffer< T, I > & a )

inlinenodiscard

begin() [3/6]

DirectoryIterator MR::begin ( const Directory & sd )

inlinenodiscard

begin() [4/6]

DirectoryRecursiveIterator MR::begin ( const DirectoryRecursive & sd )

inlinenodiscard

begin() [5/6]

template<typename T , typename I >

MR_BIND_IGNORE auto MR::begin ( const Vector< T, I > & a )

inlinenodiscard

begin() [6/6]

template<typename T , typename I >

MR_BIND_IGNORE auto MR::begin ( Vector< T, I > & a )

inlinenodiscard

BestFitParabola< float >()

MR::BestFitParabola< float >	(	BestFitParabolad	,
		BestFitParabola< double >	)

bindVertexAttribArray() [1/3]

MRVIEWER_API GLint MR::bindVertexAttribArray

(

const BindVertexAttribArraySettings &

settings

)

bindVertexAttribArray() [2/3]

template<typename T , template< typename, typename... > class C, typename... args>

GLint MR::bindVertexAttribArray ( const GLuint program_shader, const char * name, GlBuffer & buf, const C< T, args... > & V, int baseTypeElementsNumber, bool refresh, bool forceUse = false )

inline

bindVertexAttribArray() [3/3]

template<typename T , std::size_t N>

GLint MR::bindVertexAttribArray ( const GLuint program_shader, const char * name, GlBuffer & buf, const std::array< T, N > & V, int baseTypeElementsNumber, bool refresh, bool forceUse = false )

inline

blend()

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

Blend two colors together

Note

This operation is not commutative

boolean() [1/3]

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

boolean() [2/3]

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

boolean() [3/3]

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

Box< float >()

MR::Box< float >	(	Box1d	,
		Box< double >	)

Box< int >()

MR::Box< int >	(	Box1ll	,
		Box< long long >	)

Box< Vector2< float > >()

MR::Box< Vector2< float > >	(	Box2d	,
		Box< Vector2< double > >	)

Box< Vector2< int > >()

MR::Box< Vector2< int > >	(	Box2ll	,
		Box< Vector2< long long > >	)

Box< Vector3< float > >()

MR::Box< Vector3< float > >	(	Box3d	,
		Box< Vector3< double > >	)

Box< Vector3< int > >()

MR::Box< Vector3< int > >	(	Box3ll	,
		Box< Vector3< long long > >	)

bytesString()

MRMESH_API std::string MR::bytesString ( size_t size )

nodiscard

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

calcAvgColors()

MRVOXELS_API Expected< VertColors > MR::calcAvgColors ( const PointCloud & cloud, const VertColors & colors, const VertCoords & tgtPoints, const VertBitSet & tgtVerts, float sigma, const ProgressCallback & cb = {} )

nodiscard

given

Parameters

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

calcDipoles() [1/2]

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

nodiscard

calcDipoles() [2/2]

MRMESH_API void MR::calcDipoles	(	Dipoles &	dipoles,
		const AABBTree &	tree,
		const Mesh &	mesh )

calculates dipoles for given mesh and AABB-tree

calcFaceDistances()

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

nodiscard

computes and returns the distance of traveling from one of start faces to all other reachable faces on the mesh; all unreachable faces will get FLT_MAX value;

Parameters

starts	all start faces will get value 0 in the result;
metric	metric(e) says the distance of traveling from left(e) to right(e)

calcFastWindingNumber()

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

nodiscard

compute approximate winding number at

Parameters

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

calcOriginAndDimensions()

OriginAndDimensions MR::calcOriginAndDimensions ( const Box3f & box, float voxelSize )

inline

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

calcTextureRes()

MRVIEWER_API Vector2i MR::calcTextureRes	(	int	bufferSize,
		int	maxTextWidth )

calculateRangeSize()

template<typename GridT >

RangeSize MR::calculateRangeSize

(

const GridT &

grid

)

calculateSelectedPixelsInsidePolygon()

MRVIEWER_API BitSet MR::calculateSelectedPixelsInsidePolygon

(

const Contour2f &

screenPoints

)

calculate area on screen that is inside of closed contour given by screen points.

return the matrix of pixels (in local space of active viewport) belonging selected area

calculateSelectedPixelsNearPolygon()

MRVIEWER_API BitSet MR::calculateSelectedPixelsNearPolygon	(	const Contour2f &	screenPoints,
		float	radiusPix )

calculate area on screen that is near to open contour given by screen points.

return the matrix of pixels (in local space of active viewport) belonging selected area

canMinimizePolynomial()

bool MR::canMinimizePolynomial ( auto degree )

constexpr

canSolvePolynomial()

bool MR::canSolvePolynomial ( auto degree )

constexpr

ccw() [1/3]

MRMESH_API bool MR::ccw

(

const PreciseVertCoords2 *

vs

)

ccw() [2/3]

MRMESH_API bool MR::ccw

(

const std::array< PreciseVertCoords2, 3 > &

vs

)

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

ccw() [3/3]

bool MR::ccw ( const Vector2i & a, const Vector2i & b, const Vector2i & c )

inline

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

circumballCenters()

template<typename T >

bool MR::circumballCenters ( const Vector3< T > & a, const Vector3< T > & b, const Vector3< T > & c, T radius, Vector3< T > & centerPos, Vector3< T > & centerNeg )

nodiscard

Given triangle ABC and ball radius, finds two centers of balls each touching all 3 triangle's vertices;

Returns

false if such balls do not exist (radius is smaller that circumcircle radius)

circumcircleCenter() [1/2]

template<typename T >

Vector3< T > MR::circumcircleCenter ( const Vector3< T > & a, const Vector3< T > & b )

nodiscard

Computes the center of the the triangle's 0AB circumcircle.

circumcircleCenter() [2/2]

template<typename T >

Vector3< T > MR::circumcircleCenter ( const Vector3< T > & a, const Vector3< T > & b, const Vector3< T > & c )

inlinenodiscard

Computes the center of the the triangle's ABC circumcircle.

classifyShellVert()

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

nodiscard

Tests

Parameters

shellPoint	from bidirectional shell constructed for an open
mp;

Returns

whether the distance from given point to given mesh part is of same sign as settings.side, if useWindingNumber = false, returns false for all points projecting on mesh boundary

cloneRegion() [1/2]

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

nodiscard

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

cloneRegion() [2/2]

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

nodiscard

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

closestPointOnLineSegm()

template<typename V >

V MR::closestPointOnLineSegm ( const V & pt, const LineSegm< V > & l )

nodiscard

commonFilesName()

MRMESH_API std::string MR::commonFilesName ( const std::vector< std::filesystem::path > & files )

nodiscard

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

compose()

template<typename T >

BMap< T, T > MR::compose	(	const BMap< T, T > &	a,
		const BMap< T, T > &	b )

computes the composition of two mappings x -> a(b(x))

computeBasinVolume()

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

nodiscard

computes the volume of given mesh basin below given water level;

Parameters

faces

shall include all basin faces at least partially below the water level

computeInSphereThicknessAtVertices()

MRMESH_API std::optional< VertScalars > MR::computeInSphereThicknessAtVertices ( const Mesh & mesh, const InSphereSearchSettings & settings, const ProgressCallback & progress = {} )

nodiscard

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

computeNormal()

MRMESH_API Vector3f MR::computeNormal ( const AllLocalTriangulations & triangs, const VertCoords & points, VertId v )

nodiscard

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

computeRayThicknessAtVertices()

MRMESH_API std::optional< VertScalars > MR::computeRayThicknessAtVertices ( const Mesh & mesh, const ProgressCallback & progress = {} )

nodiscard

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

computeSkyViewFactor()

MRMESH_API VertScalars MR::computeSkyViewFactor ( const Mesh & terrain, const VertCoords & samples, const VertBitSet & validSamples, const std::vector< SkyPatch > & skyPatches, BitSet * outSkyRays = nullptr, std::vector< MeshIntersectionResult > * outIntersections = nullptr )

nodiscard

computes relative radiation in each valid sample point by emitting rays from that point in the sky: the radiation is 1.0f if all rays reach the sky not hitting the terrain; the radiation is 0.0f if all rays do not reach the sky because they are intercepted by the terrain;

Parameters

outSkyRays	- optional output bitset where for every valid sample #i its rays are stored at indices [i*numPatches; (i+1)*numPatches), 0s for occluded rays (hitting the terrain) and 1s for the ones which don't hit anything and reach the sky
outIntersections	- optional output vector of MeshIntersectionResult for every valid sample point

computeSpaceDistances()

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

nodiscard

computes Euclidean 3D distances from given start point to all neighbor vertices within given

Parameters

range

and to first vertices with the distance more or equal than range

computeThicknessAtVertices()

MRMESH_API VertScalars MR::computeThicknessAtVertices

(

const Mesh &

mesh

)

computeTrianglesRepetitions()

MRMESH_API TrianglesRepetitions MR::computeTrianglesRepetitions ( const AllLocalTriangulations & triangs )

nodiscard

computes statistics about the number of triangle repetitions in local triangulations

Cone3< float >()

MR::Cone3< float >	(	Cone3d	,
		Cone3< double >	)

constantCuspToolPath()

MRVOXELS_API Expected< ToolPathResult > MR::constantCuspToolPath	(	const MeshPart &	mp,
		const ConstantCuspParams &	params )

constantZToolPath()

MRVOXELS_API Expected< ToolPathResult > MR::constantZToolPath	(	const MeshPart &	mp,
		const ToolPathParams &	params )

contains()

template<typename T >

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

inlinenodiscard

convertUnits() [1/2]

template<UnitEnum E, typename T >

detail::Units::MakeFloatingPoint< T > MR::convertUnits ( const std::optional< E > & from, const std::optional< E > & to, const T & value )

nodiscard

convertUnits() [2/2]

template<UnitEnum E, typename T >

detail::Units::MakeFloatingPoint< T > MR::convertUnits ( E from, E to, const T & value )

nodiscard

createRenderObject() [1/2]

template<typename ObjectType >

MR_BIND_IGNORE std::unique_ptr< IRenderObject > MR::createRenderObject

(

const VisualObject &

visObj

)

createRenderObject() [2/2]

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

createRootFormObject()

MRMESH_API std::shared_ptr< SceneRootObject > MR::createRootFormObject

(

std::shared_ptr< Object >

obj

)

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

createShader()

MRVIEWER_API void MR::createShader	(	const std::string &	shader_name,
		const std::string &	vert_source,
		const std::string &	frag_source,
		GLuint &	prog_id,
		const DisabledWarnings &	suppressedWarns = {} )

createSymbolContours()

MRSYMBOLMESH_API Expected< Contours2f > MR::createSymbolContours

(

const SymbolMeshParams &

params

)

createSymbolsMesh()

MRSYMBOLMESH_API Expected< Mesh > MR::createSymbolsMesh

(

const SymbolMeshParams &

params

)

cutAlongEdgeLoop() [1/2]

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

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

cutAlongEdgeLoop() [2/2]

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

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

Cylinder3< float >()

MR::Cylinder3< float >	(	Cylinder3d	,
		Cylinder3< double >	)

dblArea() [1/2]

template<typename T >

T MR::dblArea ( const Vector2< T > & p, const Vector2< T > & q, const Vector2< T > & r )

inlinenodiscard

computes twice the area of given triangle

dblArea() [2/2]

template<typename T >

T MR::dblArea ( const Vector3< T > & p, const Vector3< T > & q, const Vector3< T > & r )

inlinenodiscard

computes twice the area of given triangle

dblAreaSq()

template<typename T >

T MR::dblAreaSq ( const Vector3< T > & p, const Vector3< T > & q, const Vector3< T > & r )

inlinenodiscard

computes the square of double area of given triangle

deactivateFarPairs()

MRMESH_API size_t MR::deactivateFarPairs	(	IPointPairs &	pairs,
		float	maxDistSq )

reset active bit if pair distance is further than maxDistSq

decimateContour()

MRMESH_API DecimatePolylineResult MR::decimateContour	(	Contour3f &	contour,
		const DecimatePolylineSettings3 &	settings = {} )

decimatePolyline()

MRMESH_API DecimatePolylineResult MR::decimatePolyline	(	Polyline3 &	polyline,
		const DecimatePolylineSettings3 &	settings = {} )

decomposeMatrix3()

template<typename T >

void MR::decomposeMatrix3	(	const Matrix3< T > &	m,
		Matrix3< T > &	rotation,
		Matrix3< T > &	scaling )

Decomposes matrix into rotation and scaling matrices.

decorateExpected() [1/3]

template<typename F >

auto MR::decorateExpected

(

F &&

f

)

decorateExpected() [2/3]

template<typename R , typename T , typename... Args>

auto MR::decorateExpected

(

R(T::*

memFunction )(Args...)

)

decorateExpected() [3/3]

template<typename R , typename E , typename... Args>

auto MR::decorateExpected

(

std::function< Expected< R, E >(Args...)> &&

f

)

-> std::function<R( Args... )>

delRegionKeepBd() [1/2]

std::vector< EdgeLoop > MR::delRegionKeepBd ( Mesh & mesh, const FaceBitSet & region )

inline

delRegionKeepBd() [2/2]

MRMESH_API std::vector< EdgeLoop > MR::delRegionKeepBd	(	Mesh &	mesh,
		const FaceBitSet *	region = nullptr )

deletes all region faces, inner edges and vertices, but keeps boundary edges and vertices of the region (or whole mesh if region is null); returns edge loops, each having deleted region faces on the left, and not-region faces or holes on the right

denoiseNormals()

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

Smooth face normals, given

Parameters

mesh	contains topology information and coordinates for equation weights
normals	input noisy normals and output smooth normals
v	edge indicator function (1 - smooth edge, 0 - crease edge)
gamma	the amount of smoothing: 0 - no smoothing, 1 - average smoothing, ... see the article "Mesh Denoising via a Novel Mumford-Shah Framework", equation (19)

deserializeObjectTree()

MRMESH_API Expected< std::shared_ptr< Object > > MR::deserializeObjectTree	(	const std::filesystem::path &	path,
		FolderCallback	postDecompress = {},
		ProgressCallback	progressCb = {} )

loads objects tree from given scene file (zip/mru)

format specification: children are saved under folder with name of their parent object all objects parameters are saved in one JSON file in the root folder

if postDecompress is set, it is called after decompression loading is controlled with Object::deserializeModel_ and Object::deserializeFields_

deserializeObjectTreeFrom3mf()

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

deserializeObjectTreeFromFolder()

MRMESH_API Expected< std::shared_ptr< Object > > MR::deserializeObjectTreeFromFolder	(	const std::filesystem::path &	folder,
		ProgressCallback	progressCb = {} )

loads objects tree from given scene folder

format specification: children are saved under folder with name of their parent object all objects parameters are saved in one JSON file in the root folder

loading is controlled with Object::deserializeModel_ and Object::deserializeFields_

deserializeObjectTreeFromGltf()

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

deserializeObjectTreeFromModel()

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

destroyShader()

MRVIEWER_API void MR::destroyShader

(

GLuint

id

)

detectLoneContours()

MRMESH_API std::vector< int > MR::detectLoneContours

(

const ContinuousContours &

contours

)

dilateRegion()

MRMESH_API bool MR::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

dirDblArea() [1/2]

template<typename T >

Vector3< T > MR::dirDblArea ( const Triangle3< T > & t )

inlinenodiscard

computes directed double area of given triangle

dirDblArea() [2/2]

template<typename T >

Vector3< T > MR::dirDblArea ( const Vector3< T > & p, const Vector3< T > & q, const Vector3< T > & r )

inlinenodiscard

computes directed double area of given triangle

dividePolylineWithPlane()

MRMESH_API void MR::dividePolylineWithPlane	(	Polyline3 &	polyline,
		const Plane3f &	plane,
		const DividePolylineParameters &	params = {} )

This function divides polyline with a plane

Parameters

polyline	Input polyline that will be cut by the plane
plane	Input plane to cut polyline with
params	parameters of the function, contains optional output

divideWithPlane()

MRMESH_API PointCloud MR::divideWithPlane	(	const PointCloud &	points,
		const Plane3f &	plane,
		const DividePointCloudOptionalOutput &	optOut = {} )

This function cuts a point cloud with a plane, leaving only the part of mesh that lay in positive direction of normal

Returns

Point cloud object with vertices on the positive side of the plane

Parameters

pc	Input point cloud that will be cut by the plane
plane	Input plane to cut point cloud with
optOut	optional output of the function

doSegmentLineIntersect()

template<typename V >

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

nodiscard

returns true if 2D line segment and 2D line intersect, optionally outputs intersection point as a parameter on both

doSegmentSegmentIntersect()

MRMESH_API SegmentSegmentIntersectResult MR::doSegmentSegmentIntersect ( const std::array< PreciseVertCoords2, 4 > & vs )

nodiscard

checks whether the segments AB (indices 01) and segments CD (indices 23) intersect; uses simulation-of-simplicity to avoid edge-segment intersections and co-planarity

doSegmentsIntersect()

template<typename V >

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

nodiscard

returns true if two 2D segments intersect, optionally outputs intersection point as a parameter on both segments

doTriangleSegmentIntersect()

MRMESH_API TriangleSegmentIntersectResult MR::doTriangleSegmentIntersect ( const std::array< PreciseVertCoords, 5 > & vs )

nodiscard

checks whether triangle ABC (indices 012) and segment DE (indices 34) intersect uses simulation-of-simplicity to avoid edge-segment intersections and co-planarity

doubleOffsetMesh()

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

nodiscard

Offsets mesh by converting it to voxels and back two times only closed meshes allowed (only Offset mode) typically offsetA and offsetB have distinct signs

doubleOffsetVdb()

MRVOXELS_API Expected< Mesh > MR::doubleOffsetVdb	(	const MeshPart &	mp,
		const DoubleOffsetSettings &	settings )

performs convention from mesh to voxel grid and back with offsetA, and than same with offsetB; if input mesh is not closed then the sign of distance field will be obtained using generalized winding number computation

embedStructureToTerrain()

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

nodiscard

emplaceMeshAttributes()

MRVIEWER_API void MR::emplaceMeshAttributes	(	std::shared_ptr< ObjectMesh >	objectMesh,
		MeshAttributes &&	newAttribute )

set new mesh attributes and saving the history of changing mesh attributes

end() [1/6]

template<typename T , typename I >

auto MR::end ( Buffer< T, I > & a )

inlinenodiscard

end() [2/6]

template<typename T , typename I >

auto MR::end ( const Buffer< T, I > & a )

inlinenodiscard

end() [3/6]

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

inlinenodiscard

end() [4/6]

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

inlinenodiscard

end() [5/6]

template<typename T , typename I >

MR_BIND_IGNORE auto MR::end ( const Vector< T, I > & a )

inlinenodiscard

end() [6/6]

template<typename T , typename I >

MR_BIND_IGNORE auto MR::end ( Vector< T, I > & a )

inlinenodiscard

erodeRegion()

MRMESH_API bool MR::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

evalGridMinMax()

MRVOXELS_API void MR::evalGridMinMax	(	const FloatGrid &	grid,
		float &	min,
		float &	max )

excludeAllEdgesWithHistory()

MRVIEWER_API void MR::excludeAllEdgesWithHistory

(

const std::shared_ptr< ObjectMesh > &

objMesh

)

removes all edges from edge selection and from creases and adds history records for that; it is a good idea to make SCOPED_HISTORY before calling this function

excludeLoneEdgesWithHistory()

MRVIEWER_API void MR::excludeLoneEdgesWithHistory

(

const std::shared_ptr< ObjectMesh > &

objMesh

)

removes deleted edges from edge selection and from creases and adds history records for that; it is a good idea to make SCOPED_HISTORY before calling this function

expand() [1/4]

MRMESH_API void MR::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

expand() [2/4]

MRMESH_API FaceBitSet MR::expand ( const MeshTopology & topology, FaceId f, int hops )

nodiscard

returns the region of all faces within given number of hops (stars) from the initial face

expand() [3/4]

MRMESH_API void MR::expand	(	const MeshTopology &	topology,
		VertBitSet &	region,
		int	hops = 1 )

expand() [4/4]

MRMESH_API VertBitSet MR::expand ( const MeshTopology & topology, VertId v, int hops )

nodiscard

returns the region of all vertices within given number of hops (stars) from the initial vertex

expandFaces()

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

nodiscard

returns given region with all faces sharing an edge with a region face;

Parameters

stopEdges

- neighborhood via this edges will be ignored

exportToolPathToGCode()

MRVOXELS_API std::shared_ptr< ObjectGcode > MR::exportToolPathToGCode

(

const std::vector< GCommand > &

commands

)

extractIsolines() [1/2]

MRMESH_API IsoLines MR::extractIsolines ( const MeshTopology & topology, const VertMetric & vertValues, const FaceBitSet * region = nullptr )

nodiscard

extracts all iso-lines from given scalar field and iso-value=0

extractIsolines() [2/2]

MRMESH_API IsoLines MR::extractIsolines ( const MeshTopology & topology, const VertScalars & vertValues, float isoValue, const FaceBitSet * region = nullptr )

nodiscard

extracts all iso-lines from given scalar field and iso-value

extractPlaneSections()

MRMESH_API PlaneSections MR::extractPlaneSections ( const MeshPart & mp, const Plane3f & plane )

nodiscard

extracts all plane sections of given mesh

extractSectionsFromPolyline()

MRMESH_API std::vector< EdgeSegment > MR::extractSectionsFromPolyline	(	const Polyline3 &	polyline,
		const Plane3f &	plane,
		float	eps )

This function cuts polyline with a plane

Returns

Edge segments tha are closer to the plane than

Parameters

eps
polyline	Input polyline that will be cut by the plane
plane	Input plane to cut polyline with
eps	Maximal distance from the plane

extractXYPlaneSections()

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

nodiscard

extracts all sections of given mesh with the plane z=zLevel; this function works faster than general extractPlaneSections(...) for the same plane if the sections cross relatively small number of mesh triangles and AABB tree has already been constructed

fillContourLeft() [1/2]

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

fillContourLeft() [2/2]

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

fillContours2D()

MRMESH_API Expected< void > MR::fillContours2D	(	Mesh &	mesh,
		const std::vector< EdgeId > &	holeRepresentativeEdges )

fill holes with border in same plane (i.e. after cut by plane)

Parameters

mesh	- mesh with holes
holeRepresentativeEdges	- each edge here represents a hole borders that should be filled should be not empty edges should have invalid left face (FaceId == -1)

Returns

Expected with has_value()=true if holes filled, otherwise - string error

fillHoleNicely()

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

fills a hole in mesh specified by one of its edge, optionally subdivides new patch on smaller triangles, optionally make smooth connection with existing triangles outside the hole

Returns

triangles of the patch

Parameters

holeEdge

left of this edge must not have a face and it will be filled

filterCreaseEdges()

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

filters given edges using the following criteria: if

Parameters

filterComponents	is true then connected components with summary length of their edges less than
critLength	will be excluded if
filterBranches	is true then branches shorter than
critLength	will be excluded

filterHistoryActionsVector()

MRMESH_API std::pair< bool, int > MR::filterHistoryActionsVector	(	HistoryActionsVector &	historyVector,
		HistoryStackFilter	filteringCondition,
		size_t	firstRedoIndex = 0,
		bool	deepFiltering = true )

Remove actions from history actions vector that match the condition.

Parameters

firstRedoIndex	- set redo index for calculate how many actions removed before it
deepFiltering	- filter actions into combined actions

Returns

pair (anything removed, how many removed before firstRedoIndex)

FilterHistoryByCondition()

MRVIEWER_API void MR::FilterHistoryByCondition	(	HistoryStackFilter	filteringCondition,
		bool	deepFiltering = true )

Remove actions from global history (if it is enabled) that match the condition

Parameters

deepFiltering

- filter actions into combined actions

findAlphaShapeAllTriangles()

MRMESH_API Triangulation MR::findAlphaShapeAllTriangles ( const PointCloud & cloud, float radius )

nodiscard

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

findAlphaShapeNeiTriangles()

MRMESH_API void MR::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)

find all triangles of alpha-shape with negative alpha = -1/radius, where each triangle contains point #v and two other points

Parameters

appendTris	found triangles will be appended here
neis	temporary storage to avoid memory allocations, it will be filled with all neighbours within 2*radius

findBestFreeformDeformation()

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

findClosestToMouseEdge() [1/2]

HoleEdgePoint MR::findClosestToMouseEdge ( const Vector2i & mousePos, const std::vector< std::shared_ptr< ObjectLines > > & objsLines, float accuracy = 5.5f )

inline

findClosestToMouseEdge() [2/2]

MRVIEWER_API HoleEdgePoint MR::findClosestToMouseEdge	(	const Vector2i &	mousePos,
		const std::vector< std::shared_ptr< ObjectLinesHolder > > &	objsLines,
		float	accuracy = 5.5f )

find closest to mouse edge from polylines

Parameters

mousePos	mouse position in screen
accuracy	maximum distances from mouse position to line in viewport (screen) space

Returns

pair closest edge and according index of polyline

findClosestToMouseHoleEdge()

MRVIEWER_API HoleEdgePoint MR::findClosestToMouseHoleEdge	(	const Vector2i &	mousePos,
		const std::shared_ptr< ObjectMeshHolder > &	objMesh,
		const std::vector< EdgeId > &	holeRepresentativeEdges,
		float	accuracy = 5.5f,
		bool	attractToVert = false,
		float	cornerAccuracy = 10.5f )

find closest to mouse edge from hole borders

Parameters

mousePos	mouse position in screen
accuracy,cornerAccuracy	maximum distances from mouse position to line / corner in viewport (screen) space

Returns

pair closest edge and according index of hole in holeRepresentativeEdges

findCloseVertices() [1/4]

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

nodiscard

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

findCloseVertices() [2/4]

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

nodiscard

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

findCloseVertices() [3/4]

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

nodiscard

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

findCloseVertices() [4/4]

MRMESH_API VertBitSet MR::findCloseVertices ( const VertMap & smallestMap )

nodiscard

finds all close vertices, where for each vertex there is another one located within given distance; smallestMap is the result of findSmallestCloseVertices function call

findHalfSpacePoints()

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

Returns

All vertices on the positive side of the plane

Parameters

pc	Input point cloud that will be cut by the plane
plane	Input plane to cut point cloud with

findIncidentFaces()

MRVIEWER_API FaceBitSet MR::findIncidentFaces	(	const Viewport &	viewport,
		const BitSet &	pixBs,
		const ObjectMesh &	obj,
		bool	onlyVisible = false,
		bool	includeBackfaces = true,
		const std::vector< ObjectMesh * > *	occludingMeshes = nullptr )

get faces ids of object located in selected area on viewport

Parameters

pixBs	the matrix of pixels (in local space of viewport) belonging selected area
onlyVisible	get only visible faces (that no covered another faces)
includeBackfaces	get also faces from back side of object

findInnerShellFacesWithSplits()

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

nodiscard

Finds inner-shell faces on bidirectional

Parameters

shell	constructed for an open
mp;	The function will return all shell faces (after some subdivision) that have distance to mesh of same sign as settings.side

findInnerShellVerts()

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

nodiscard

Finds inner-shell vertices on bidirectional

Parameters

shell	constructed for an open
mp;	The function will return all shell vertices that have distance to mesh of same sign as settings.side

findInSphere() [1/2]

MRMESH_API InSphere MR::findInSphere ( const Mesh & mesh, const MeshPoint & m, const InSphereSearchSettings & settings )

nodiscard

finds maximal sphere inscribed in the mesh touching point (p) with center along the normal at (p)

findInSphere() [2/2]

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

nodiscard

findLeftBoundary() [1/2]

std::vector< EdgeLoop > MR::findLeftBoundary ( const MeshTopology & topology, const FaceBitSet & region )

inlinenodiscard

findLeftBoundary() [2/2]

MRMESH_API std::vector< EdgeLoop > MR::findLeftBoundary ( const MeshTopology & topology, const FaceBitSet * region = nullptr )

nodiscard

returns all region boundary loops; every loop has region faces on the left, and not-region faces or holes on the right

findLeftBoundaryInsideMesh()

MRMESH_API std::vector< EdgePath > MR::findLeftBoundaryInsideMesh ( const MeshTopology & topology, const FaceBitSet & region )

nodiscard

returns all region boundary paths; every path has region faces on the left, and valid not-region faces on the right

findMaxDistanceSq()

MRMESH_API float MR::findMaxDistanceSq ( const PointCloud & a, const PointCloud & b, const AffineXf3f * rigidB2A = nullptr, float maxDistanceSq = FLT_MAX )

nodiscard

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)

Parameters

rigidB2A	rigid transformation from B-cloud space to A-cloud space, nullptr considered as identity transformation
maxDistanceSq	upper limit on the positive distance in question, if the real distance is larger than the function exists returning maxDistanceSq

findMaxDistanceSqOneWay()

MRMESH_API float MR::findMaxDistanceSqOneWay ( const PointCloud & a, const PointCloud & b, const AffineXf3f * rigidB2A = nullptr, float maxDistanceSq = FLT_MAX )

nodiscard

returns the maximum of the squared distances from each B-point to A-cloud

Parameters

rigidB2A	rigid transformation from B-cloud space to A-cloud space, nullptr considered as identity transformation
maxDistanceSq	upper limit on the positive distance in question, if the real distance is larger than the function exists returning maxDistanceSq

findNeighborVerts()

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

nodiscard

calculates all neighbor vertices within a given

Parameters

range

and to first vertices with the distance more or equal than range

findOverhangs()

MRMESH_API Expected< std::vector< FaceBitSet > > MR::findOverhangs	(	const Mesh &	mesh,
		const FindOverhangsSettings &	settings )

Find face regions that might create overhangs.

Parameters

mesh	- source mesh
settings	- parameters

Returns

face regions

findOverlappingTris()

MRMESH_API Expected< FaceBitSet > MR::findOverlappingTris ( const MeshPart & mp, const FindOverlappingSettings & settings )

nodiscard

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

findPathWithExtension()

MRMESH_API std::filesystem::path MR::findPathWithExtension ( const std::filesystem::path & pathWithoutExtension )

nodiscard

given file name without final extension, finds in the same folder an existing file with same stem and any extension

findRegionBoundaryUndirectedEdgesInsideMesh()

MRMESH_API UndirectedEdgeBitSet MR::findRegionBoundaryUndirectedEdgesInsideMesh ( const MeshTopology & topology, const FaceBitSet & region )

nodiscard

returns all region boundary edges, where each edge has a region face on one side, and a valid not-region face on another side

findRegionOuterFaces()

MRMESH_API FaceBitSet MR::findRegionOuterFaces ( const MeshTopology & topology, const FaceBitSet & region )

nodiscard

Returns

All out of region faces that have a common edge with at least one region face

findRepeatedOrientedTriangles() [1/2]

MRMESH_API Triangulation MR::findRepeatedOrientedTriangles ( const AllLocalTriangulations & triangs, int repetitions )

nodiscard

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

findRepeatedOrientedTriangles() [2/2]

MRMESH_API void MR::findRepeatedOrientedTriangles	(	const AllLocalTriangulations &	triangs,
		Triangulation *	outRep3,
		Triangulation *	outRep2 )

optional output with all oriented triangles that appear in exactly two local triangulations

from local triangulations returns all oriented triangles with 3 or 2 repetitions each; if both outRep3 and outRep2 are necessary then it is faster to call this function than above one

Parameters

outRep3

optional output with all oriented triangles that appear in three local triangulations

findRepeatedUnorientedTriangles()

MRMESH_API std::vector< UnorientedTriangle > MR::findRepeatedUnorientedTriangles ( const AllLocalTriangulations & triangs, int repetitions )

nodiscard

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

findRightBoundary() [1/2]

std::vector< EdgeLoop > MR::findRightBoundary ( const MeshTopology & topology, const FaceBitSet & region )

inlinenodiscard

findRightBoundary() [2/2]

MRMESH_API std::vector< EdgeLoop > MR::findRightBoundary ( const MeshTopology & topology, const FaceBitSet * region = nullptr )

nodiscard

returns all region boundary loops; every loop has region faces on the right, and not-region faces or holes on the left

findSegmentSegmentIntersectionPrecise() [1/2]

MRMESH_API Vector2f MR::findSegmentSegmentIntersectionPrecise ( const Vector2f & a, const Vector2f & b, const Vector2f & c, const Vector2f & d, CoordinateConverters2 converters )

nodiscard

finds intersection precise, using high precision int inside this function input should have intersection

findSegmentSegmentIntersectionPrecise() [2/2]

MRMESH_API Vector2i MR::findSegmentSegmentIntersectionPrecise ( const Vector2i & a, const Vector2i & b, const Vector2i & c, const Vector2i & d )

nodiscard

finds intersection precise, using high precision int inside this function input should have intersection

findSkyRays()

MRMESH_API BitSet MR::findSkyRays ( const Mesh & terrain, const VertCoords & samples, const VertBitSet & validSamples, const std::vector< SkyPatch > & skyPatches, std::vector< MeshIntersectionResult > * outIntersections = nullptr )

nodiscard

In each valid sample point tests the rays from that point in the sky;

Returns

bitset where for every valid sample #i its rays are stored at indices [i*numPatches; (i+1)*numPatches), 0s for occluded rays (hitting the terrain) and 1s for the ones which don't hit anything and reach the sky

Parameters

outIntersections

- optional output vector of MeshIntersectionResult for every valid sample point

findSmallestCloseVertices() [1/3]

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

nodiscard

returns a map where each valid vertex is mapped to the smallest valid vertex Id located within given distance (including itself), and this smallest vertex is mapped to itself, each vertex not from valid set is mapped to itself

findSmallestCloseVertices() [2/3]

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

nodiscard

returns a map where each valid vertex is mapped to the smallest valid vertex Id located within given distance (including itself), and this smallest vertex is mapped to itself, each vertex not from valid set is mapped to itself

findSmallestCloseVertices() [3/3]

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

nodiscard

returns a map where each valid vertex is mapped to the smallest valid vertex Id located within given distance (including itself), and this smallest vertex is mapped to itself, each vertex not from valid set is mapped to itself; the search tree is constructe inside

findSmallestCloseVerticesUsingTree()

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

nodiscard

returns a map where each valid vertex is mapped to the smallest valid vertex Id located within given distance (including itself), and this smallest vertex is mapped to itself, each vertex not from valid set is mapped to itself; given tree is used as is

findTriangleSegmentIntersectionPrecise()

MRMESH_API Vector3f MR::findTriangleSegmentIntersectionPrecise ( const Vector3f & a, const Vector3f & b, const Vector3f & c, const Vector3f & d, const Vector3f & e, CoordinateConverters converters )

nodiscard

finds intersection precise, using high precision int inside this function input should have intersection

findTwinEdgePairs()

MRMESH_API std::vector< EdgePair > MR::findTwinEdgePairs ( const Mesh & mesh, float closeDist )

nodiscard

finds pairs of twin edges (each twin edge will be present at least in one of pairs)

findTwinEdges() [1/2]

MRMESH_API EdgeBitSet MR::findTwinEdges ( const Mesh & mesh, float closeDist )

nodiscard

finds all directed twin edges

findTwinEdges() [2/2]

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

nodiscard

findTwinUndirectedEdgeHashMap() [1/2]

MRMESH_API UndirectedEdgeHashMap MR::findTwinUndirectedEdgeHashMap ( const Mesh & mesh, float closeDist )

nodiscard

provided that each edge has at most one twin, composes bidirectional mapping between twins

findTwinUndirectedEdgeHashMap() [2/2]

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

nodiscard

findTwinUndirectedEdges() [1/2]

MRMESH_API UndirectedEdgeBitSet MR::findTwinUndirectedEdges ( const Mesh & mesh, float closeDist )

nodiscard

finds all undirected twin edges

findTwinUndirectedEdges() [2/2]

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

nodiscard

findVertsInViewportArea()

MRVIEWER_API VertBitSet MR::findVertsInViewportArea	(	const Viewport &	viewport,
		const BitSet &	bsVec,
		const ObjectPoints &	obj,
		bool	includeBackfaces = true,
		bool	onlyVisible = false )

get vertex ids of object located in selected area on viewport

Parameters

bsVec	the matrix of pixels (in local space of viewport) belonging to selected area
includeBackfaces	get also vertices with normals not toward the camera
onlyVisible	get only visible vertices (that no covered with clipping plane)

floatGridToVdbVolume()

MRVOXELS_API VdbVolume MR::floatGridToVdbVolume

(

FloatGrid

grid

)

fopen()

MR_BIND_IGNORE MRMESH_API FILE * MR::fopen	(	const std::filesystem::path &	filename,
		const char *	mode )

this version of fopen unlike std::fopen supports unicode file names on Windows

forEachObjectKind()

template<typename F >

bool MR::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.

formatNoTrailingZeros()

MRMESH_API char * MR::formatNoTrailingZeros	(	char *	fmt,
		double	v,
		int	digitsAfterPoint,
		int	precision = 6 )

returns printf-format for floating-point value in decimal notation with given precision in digits and without trailing zeros after the decimal point

Parameters

fmt	preallocated buffer of 5 bytes
v	value to print
digitsAfterPoint	maximal number of digits after decimal point
precision	maximal number of not-zero decimal digits

fromSceneMison() [1/2]

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

load scene from MISON file
JSON file with array named "Objects" or root array:
element fields:
"Filename" : required full path to file for loading object "XF": optional xf for loaded object "Name": optional name for loaded object

fromSceneMison() [2/2]

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

functionVolumeToSimpleVolume()

MRVOXELS_API Expected< SimpleVolumeMinMax > MR::functionVolumeToSimpleVolume	(	const FunctionVolume &	volume,
		const ProgressCallback &	callback = {} )

converts function volume into simple volume

generalOffsetMesh()

MRVOXELS_API Expected< Mesh > MR::generalOffsetMesh ( const MeshPart & mp, float offset, const GeneralOffsetParameters & params )

nodiscard

Offsets mesh by converting it to voxels and back using one of three modes specified in the parameters.

get() [1/18]

template<size_t I, typename V >

std::tuple_element< I, AffineXf< V > >::type & MR::get ( AffineXf< V > & m )

constexprnoexcept

get() [2/18]

template<size_t I>

uint8_t & MR::get ( Color & c )

constexprnoexcept

get() [3/18]

template<size_t I, typename V >

const std::tuple_element< I, AffineXf< V > >::type & MR::get ( const AffineXf< V > & m )

constexprnoexcept

get() [4/18]

template<size_t I>

const uint8_t & MR::get ( const Color & c )

constexprnoexcept

get() [5/18]

template<size_t I, typename T >

const Matrix2< T >::VectorType & MR::get ( const Matrix2< T > & m )

constexprnoexcept

get() [6/18]

template<size_t I, typename T >

const Matrix3< T >::VectorType & MR::get ( const Matrix3< T > & m )

constexprnoexcept

get() [7/18]

template<size_t I, typename T >

const Matrix4< T >::VectorType & MR::get ( const Matrix4< T > & m )

constexprnoexcept

get() [8/18]

template<size_t I, typename T >

int MR::get ( const MR::Id< T > & id )

constexprnoexcept

get() [9/18]

template<size_t I, typename T >

const T & MR::get ( const Vector2< T > & v )

constexprnoexcept

get() [10/18]

template<size_t I, typename T >

const T & MR::get ( const Vector3< T > & v )

constexprnoexcept

get() [11/18]

template<size_t I, typename T >

const T & MR::get ( const Vector4< T > & v )

constexprnoexcept

get() [12/18]

template<size_t I, typename T >

Matrix2< T >::VectorType & MR::get ( Matrix2< T > & m )

constexprnoexcept

get() [13/18]

template<size_t I, typename T >

Matrix3< T >::VectorType & MR::get ( Matrix3< T > & m )

constexprnoexcept

get() [14/18]

template<size_t I, typename T >

Matrix4< T >::VectorType & MR::get ( Matrix4< T > & m )

constexprnoexcept

get() [15/18]

template<size_t I, typename T >

int & MR::get ( MR::Id< T > & id )

constexprnoexcept

get() [16/18]

template<size_t I, typename T >

T & MR::get ( Vector2< T > & v )

constexprnoexcept

get() [17/18]

template<size_t I, typename T >

T & MR::get ( Vector3< T > & v )

constexprnoexcept

get() [18/18]

template<size_t I, typename T >

T & MR::get ( Vector4< T > & v )

constexprnoexcept

getAligningXf()

MRMESH_API AffineXf3f MR::getAligningXf ( const PointToPlaneAligningTransform & p2pl, ICPMode mode, float angleLimit, float scaleLimit, const Vector3f & fixedRotationAxis )

nodiscard

given prepared (p2pl) object, finds the best transformation from it of given type with given limitations on rotation angle and global scale

getAt() [1/2]

template<typename T , typename I >

T MR::getAt ( const Buffer< T, I > & bmap, I key )

inline

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

getAt() [2/2]

template<typename T , typename I >

T MR::getAt ( const Vector< T, I > & a, I id, T def = {} )

inlinenodiscard

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

GetAvailableLineWidthRange()

MRVIEWER_API const Vector2f & MR::GetAvailableLineWidthRange

(

)

getBoundaryFaces()

MRMESH_API FaceBitSet MR::getBoundaryFaces ( const MeshTopology & topology, const FaceBitSet & region )

nodiscard

returns faces from given region that have at least one neighbor face with shared edge not from the region

getBoundaryVerts()

MRMESH_API VertBitSet MR::getBoundaryVerts ( const MeshTopology & topology, const FaceBitSet * region = nullptr )

nodiscard

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

getCancelMessage()

std::string MR::getCancelMessage ( const std::filesystem::path & path )

inlinenodiscard

GetClipboardText()

MRVIEWER_API Expected< std::string > MR::GetClipboardText ( )

nodiscard

GetCpuId()

MRMESH_API std::string MR::GetCpuId ( )

nodiscard

getCurrentStacktrace()

MRMESH_API std::string MR::getCurrentStacktrace ( )

nodiscard

returns string representation of the current stacktrace

getCurrentStacktraceInline()

std::string MR::getCurrentStacktraceInline ( )

inlinenodiscard

returns string representation of the current stacktrace; the function is inlined, to put the code in any shared library; if std::stacktrace is first called from MRMesh.dll then it is not unloaded propely

getDefaultUnitParams()

template<UnitEnum E>

const UnitToStringParams< E > & MR::getDefaultUnitParams ( )

nodiscard

getDepthFunctionLEqual()

int MR::getDepthFunctionLEqual ( DepthFunction funcType )

inline

getDepthFunctionLess()

int MR::getDepthFunctionLess ( DepthFunction funcType )

inline

GetDetailedOSName()

MRMESH_API std::string MR::GetDetailedOSName ( )

nodiscard

getEdgeOrdering()

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

nodiscard

compute the order of edges given the order of faces: edges near first faces also appear first;

Parameters

faceMap

old face id -> new face id

GetEmbeddedPythonDirectory()

MRMESH_API std::filesystem::path MR::GetEmbeddedPythonDirectory ( )

nodiscard

GetExeDirectory()

MRMESH_API std::filesystem::path MR::GetExeDirectory ( )

nodiscard

getFeatureDirection()

MRMESH_API std::optional< Vector3f > MR::getFeatureDirection

(

FeatureObject *

feature

)

getFeatureNormal()

MRMESH_API std::optional< Vector3f > MR::getFeatureNormal

(

FeatureObject *

feature

)

getFeaturesTypeWithDirections()

MRMESH_API std::unordered_set< std::string > MR::getFeaturesTypeWithDirections

(

)

getFeaturesTypeWithNormals()

MRMESH_API std::unordered_set< std::string > MR::getFeaturesTypeWithNormals

(

)

getFlatSubtrees()

MRVIEWER_API std::vector< FlatTree > MR::getFlatSubtrees

(

const std::vector< std::shared_ptr< Object > > &

objs

)

get list of subtrees satisfying any of the following rules:

• all the subtree elements are present in the given object list
• only the subtree's root element is present in the given object list TODO: optional predicate to ignore insignificant objects (non-visual objects, ancillary objects, etc.)

GetFontsDirectory()

MRMESH_API std::filesystem::path MR::GetFontsDirectory ( )

nodiscard

getFragmentShaderClippingBlock()

MRVIEWER_API std::string MR::getFragmentShaderClippingBlock

(

)

getFragmentShaderEndBlock()

MRVIEWER_API std::string MR::getFragmentShaderEndBlock

(

bool

alphaSort

)

getFragmentShaderHeaderBlock()

MRVIEWER_API std::string MR::getFragmentShaderHeaderBlock	(	bool	gl4,
		bool	alphaSort )

getFragmentShaderOnlyOddBlock()

MRVIEWER_API std::string MR::getFragmentShaderOnlyOddBlock

(

bool

sampleMask

)

getFragmentShaderPointSizeBlock()

MRVIEWER_API std::string MR::getFragmentShaderPointSizeBlock

(

)

GetHomeDirectory()

MRMESH_API std::filesystem::path MR::GetHomeDirectory ( )

nodiscard

getICPStatusInfo()

MRMESH_API std::string MR::getICPStatusInfo ( int iterations, ICPExitType exitType )

nodiscard

returns status info string

getIncidentEdges() [1/2]

MRMESH_API UndirectedEdgeBitSet MR::getIncidentEdges ( const MeshTopology & topology, const FaceBitSet & faces )

nodiscard

composes the set of all undirected edges, having a face from given set from one of two sides

getIncidentEdges() [2/2]

MRMESH_API UndirectedEdgeBitSet MR::getIncidentEdges ( const MeshTopology & topology, const UndirectedEdgeBitSet & edges )

nodiscard

composes the set of all undirected edges, having at least one common vertex with an edge from given set

getIncidentFaces() [1/2]

MRMESH_API FaceBitSet MR::getIncidentFaces ( const MeshTopology & topology, const UndirectedEdgeBitSet & edges )

nodiscard

composes the set of all faces incident to given edges

getIncidentFaces() [2/2]

MRMESH_API FaceBitSet MR::getIncidentFaces ( const MeshTopology & topology, const VertBitSet & verts )

nodiscard

composes the set of all faces incident to given vertices

getIncidentVerts() [1/4]

MRMESH_API VertBitSet MR::getIncidentVerts ( const MeshTopology & topology, const FaceBitSet & faces )

nodiscard

composes the set of all vertices incident to given faces

getIncidentVerts() [2/4]

MRMESH_API const VertBitSet & MR::getIncidentVerts ( const MeshTopology & topology, const FaceBitSet * faces, VertBitSet & store )

nodiscard

if faces-parameter is null pointer then simply returns the reference on all valid vertices; otherwise performs store = getIncidentVerts( topology, *faces ) and returns reference on store

getIncidentVerts() [3/4]

MRMESH_API VertBitSet MR::getIncidentVerts ( const MeshTopology & topology, const UndirectedEdgeBitSet & edges )

nodiscard

composes the set of all vertices incident to given edges

getIncidentVerts() [4/4]

MRMESH_API const VertBitSet & MR::getIncidentVerts ( const MeshTopology & topology, const UndirectedEdgeBitSet * edges, VertBitSet & store )

nodiscard

if edges-parameter is null pointer then simply returns the reference on all valid vertices; otherwise performs store = getIncidentVerts( topology, *edges ) and returns reference on store

getInnerEdges() [1/2]

MRMESH_API UndirectedEdgeBitSet MR::getInnerEdges ( const MeshTopology & topology, const FaceBitSet & region )

nodiscard

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

getInnerEdges() [2/2]

MRMESH_API UndirectedEdgeBitSet MR::getInnerEdges ( const MeshTopology & topology, const VertBitSet & verts )

nodiscard

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

getInnerFaces()

MRMESH_API FaceBitSet MR::getInnerFaces ( const MeshTopology & topology, const VertBitSet & verts )

nodiscard

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

getInnerVerts() [1/3]

MRMESH_API VertBitSet MR::getInnerVerts ( const MeshTopology & topology, const FaceBitSet & region )

nodiscard

composes the set of all vertices not on the boundary of a hole and with all their adjacent faces in given set

getInnerVerts() [2/3]

MRMESH_API VertBitSet MR::getInnerVerts ( const MeshTopology & topology, const FaceBitSet * region = nullptr )

nodiscard

composes the set of all vertices not on the boundary of a hole and with all their adjacent faces in given set

getInnerVerts() [3/3]

MRMESH_API VertBitSet MR::getInnerVerts ( const MeshTopology & topology, const UndirectedEdgeBitSet & edges )

nodiscard

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

GetLibsDirectory()

MRMESH_API std::filesystem::path MR::GetLibsDirectory ( )

nodiscard

getLimitedPos()

template<typename V >

V MR::getLimitedPos ( const V & pos, const V & guidePos, typename VectorTraits< V >::BaseType maxGuideDistSq )

inlinenodiscard

if (pos) is within the ball with the center at (guidePos) and squared radius (maxGuideDistSq), then returns (pos); otherwise returns the point on the ball's border closest to (pos)

getLinesFragmentShader()

MRVIEWER_API std::string MR::getLinesFragmentShader

(

bool

alphaSort

)

getLinesJointFragmentShader()

MRVIEWER_API std::string MR::getLinesJointFragmentShader

(

)

getLinesJointPickerVertexShader()

MRVIEWER_API std::string MR::getLinesJointPickerVertexShader

(

)

getLinesJointVertexShader()

MRVIEWER_API std::string MR::getLinesJointVertexShader

(

)

getLinesPickerVertexShader()

MRVIEWER_API std::string MR::getLinesPickerVertexShader

(

)

getLinesVertexShader()

MRVIEWER_API std::string MR::getLinesVertexShader

(

)

getMeanSqDistToPlane()

float MR::getMeanSqDistToPlane ( const IPointPairs & pairs )

inlinenodiscard

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

getMeanSqDistToPoint()

float MR::getMeanSqDistToPoint ( const IPointPairs & pairs )

inlinenodiscard

computes root-mean-square deviation between points

getMeshFragmentShader()

MRVIEWER_API std::string MR::getMeshFragmentShader	(	bool	gl4,
		bool	alphaSort,
		bool	msaaEnabled )

getMeshFragmentShaderArgumetsBlock()

MRVIEWER_API std::string MR::getMeshFragmentShaderArgumetsBlock

(

)

getMeshFragmentShaderColoringBlock()

MRVIEWER_API std::string MR::getMeshFragmentShaderColoringBlock

(

)

getMeshOrPoints()

MRMESH_API std::optional< MeshOrPoints > MR::getMeshOrPoints ( const VisualObject * obj )

nodiscard

constructs MeshOrPoints from ObjectMesh or ObjectPoints, otherwise returns nullopt

getMeshVerticesShader()

MRVIEWER_API std::string MR::getMeshVerticesShader

(

)

getMouseModeString()

std::string MR::getMouseModeString ( MouseMode mode )

inline

GetMRVersionString()

MRMESH_API std::string MR::GetMRVersionString ( )

nodiscard

getNeighborFaces()

MRMESH_API FaceBitSet MR::getNeighborFaces ( const MeshTopology & topology, const UndirectedEdgeBitSet & edges )

nodiscard

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

getNObjectsLine()

template<typename ObjectT >

std::string MR::getNObjectsLine

(

unsigned

n

)

getNumActivePairs()

MRMESH_API size_t MR::getNumActivePairs ( const IPointPairs & pairs )

nodiscard

computes the number of active pairs

getNumSamples()

size_t MR::getNumSamples ( const IPointPairs & pairs )

inlinenodiscard

returns the number of samples able to form pairs

getOneMeshIntersectionContours()

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

nodiscard

getOptimalFaceOrdering()

MRMESH_API FaceBMap MR::getOptimalFaceOrdering ( const Mesh & mesh )

nodiscard

computes optimal order of faces: old face id -> new face id, the order is similar as in AABB tree, but faster to compute

getOSNoSpaces()

MRMESH_API std::string MR::getOSNoSpaces ( )

nodiscard

getPickerFragmentShader()

MRVIEWER_API std::string MR::getPickerFragmentShader	(	bool	points,
		bool	cornerMode = true )

getPointsFragmentShader()

MRVIEWER_API std::string MR::getPointsFragmentShader

(

bool

alphaSort

)

getPointsVertexShader()

MRVIEWER_API std::string MR::getPointsVertexShader

(

)

getRegionBoundaryVerts()

MRMESH_API VertBitSet MR::getRegionBoundaryVerts ( const MeshTopology & topology, const FaceBitSet & region )

nodiscard

composes the set of all boundary vertices for given region, unlike getBoundaryVerts the vertices of mesh boundary having no incident not-region faces are not returned

getRegionEdges()

MRMESH_API EdgeBitSet MR::getRegionEdges ( const MeshTopology & topology, const FaceBitSet & faces )

nodiscard

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

GetResourcesDirectory()

MRMESH_API std::filesystem::path MR::GetResourcesDirectory ( )

nodiscard

getShaderMainBeginBlock()

MRVIEWER_API std::string MR::getShaderMainBeginBlock

(

)

getStreamSize()

MRMESH_API std::streamoff MR::getStreamSize

(

std::istream &

in

)

getSumSqDistToPlane()

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

nodiscard

computes the number of active pairs and the sum of squared deviation from points to target planes or the difference between the squared distances between points to target planes and inaccuracy

getSumSqDistToPoint()

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

nodiscard

computes the number of active pairs and the sum of squared distances between points or the difference between the squared distances between points and inaccuracy

GetSystemInfoJson()

MRVIEWER_API Json::Value MR::GetSystemInfoJson

(

)

getSystemMemory()

MRMESH_API SystemMemory MR::getSystemMemory ( )

nodiscard

return information about memory available in the system

GetTempDirectory()

MRMESH_API std::filesystem::path MR::GetTempDirectory ( )

nodiscard

getToFloatConverter()

MRMESH_API ConvertToFloatVector MR::getToFloatConverter

(

const Box3d &

box

)

creates converter from Vector3i to Vector3f in Box range (int diapason is mapped to box range)

getToIntConverter()

MRMESH_API ConvertToIntVector MR::getToIntConverter

(

const Box3d &

box

)

creates converter from Vector3f to Vector3i in Box range (int diapason is mapped to box range)

getTrivialVertexShader()

MRVIEWER_API std::string MR::getTrivialVertexShader

(

)

getTypeConverter()

MRVOXELS_API std::function< float(const char *)> MR::getTypeConverter	(	ScalarType	scalarType,
		uint64_t	range,
		int64_t	min )

get a function to convert binary data of specified format type to a scalar value

Parameters

scalarType	- binary format type
range	- (for integer types only) the range of possible values
min	- (for integer types only) the minimal value

getUnitInfo()

template<UnitEnum E>

const UnitInfo & MR::getUnitInfo ( E unit )

nodiscarddelete

getUserConfigDir()

MRMESH_API std::filesystem::path MR::getUserConfigDir ( )

nodiscard

getUserConfigFilePath()

MRMESH_API std::filesystem::path MR::getUserConfigFilePath ( )

nodiscard

getVertexOrdering()

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

nodiscard

compute the order of vertices given the order of faces: vertices near first faces also appear first;

Parameters

faceMap

old face id -> new face id

getViewerInstance()

MRVIEWER_API Viewer & MR::getViewerInstance ( )

nodiscard

returns global instance of Viewer class

getVolumeFragmentShader()

MRVIEWER_API std::string MR::getVolumeFragmentShader

(

)

getVolumePickerFragmentShader()

MRVIEWER_API std::string MR::getVolumePickerFragmentShader

(

)

getXfFromOxyPlane() [1/2]

MRMESH_API AffineXf3f MR::getXfFromOxyPlane

(

const Contours3f &

contours

)

computes the transformation that maps O into center mass of contours' points OXY into best plane containing the points

getXfFromOxyPlane() [2/2]

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

gridToMesh() [1/2]

MRVOXELS_API Expected< Mesh > MR::gridToMesh	(	const FloatGrid &	grid,
		const GridToMeshSettings &	settings )

converts OpenVDB Grid into mesh using Dual Marching Cubes algorithm

gridToMesh() [2/2]

MRVOXELS_API Expected< Mesh > MR::gridToMesh	(	FloatGrid &&	grid,
		const GridToMeshSettings &	settings )

converts OpenVDB Grid into mesh using Dual Marching Cubes algorithm; deletes grid in the middle to reduce peak memory consumption

guessPrecision() [1/4]

template<detail::Units::Scalar T>

MRVIEWER_API int MR::guessPrecision ( T min, T max )

nodiscard

guessPrecision() [2/4]

template<typename T >
requires (VectorTraits<T>::size > 1 && detail::Units::Scalar<typename VectorTraits<T>::BaseType>)

int MR::guessPrecision ( T min, T max )

nodiscard

guessPrecision() [3/4]

template<detail::Units::Scalar T>

MRVIEWER_API int MR::guessPrecision ( T value )

nodiscard

guessPrecision() [4/4]

template<typename T >
requires (VectorTraits<T>::size > 1 && detail::Units::Scalar<typename VectorTraits<T>::BaseType>)

int MR::guessPrecision ( T value )

nodiscard

hasAnyIsoline() [1/2]

MRMESH_API bool MR::hasAnyIsoline ( const MeshTopology & topology, const VertMetric & vertValues, const FaceBitSet * region = nullptr )

nodiscard

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

hasAnyIsoline() [2/2]

MRMESH_API bool MR::hasAnyIsoline ( const MeshTopology & topology, const VertScalars & vertValues, float isoValue, const FaceBitSet * region = nullptr )

nodiscard

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

hasAnyPlaneSection()

MRMESH_API bool MR::hasAnyPlaneSection ( const MeshPart & mp, const Plane3f & plane )

nodiscard

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

hasAnyXYPlaneSection()

MRMESH_API bool MR::hasAnyXYPlaneSection ( const MeshPart & mp, float zLevel )

nodiscard

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

hasProhibitedChars()

MRMESH_API bool MR::hasProhibitedChars ( const std::string & line )

nodiscard

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

incrementForceRedrawFrames()

MRVIEWER_API void MR::incrementForceRedrawFrames	(	int	i = 1,
		bool	swapOnLastOnly = false )

Increment number of forced frames to redraw in event loop if swapOnLastOnly only last forced frame will be present on screen and all previous will not

inflate()

MRMESH_API void MR::inflate	(	Mesh &	mesh,
		const VertBitSet &	verts,
		const InflateSettings &	settings )

Inflates (in one of two sides) given mesh region, putting given vertices in such positions to make smooth surface inside verts-region, but sharp on its boundary;

Parameters

verts

must not include all vertices of a mesh connected component

interpolateArcs()

MRVOXELS_API Expected< void > MR::interpolateArcs	(	std::vector< GCommand > &	commands,
		const ArcInterpolationParams &	params,
		Axis	axis )

interpolateLines()

MRVOXELS_API Expected< void > MR::interpolateLines	(	std::vector< GCommand > &	commands,
		const LineInterpolationParams &	params,
		Axis	axis )

isNanFast()

bool MR::isNanFast ( float f )

inline

quickly tests whether given float is not-a-number

isPickedPointValid()

MRMESH_API bool MR::isPickedPointValid	(	const VisualObject *	object,
		const PickedPoint &	point )

isRigid()

template<typename T >

bool MR::isRigid

(

const Matrix3< T > &

m

)

Returns true if matrix scale is identity.

isSupportedFileInSubfolders()

MRMESH_API bool MR::isSupportedFileInSubfolders

(

const std::filesystem::path &

folder

)

isTIFFFile()

MRMESH_API bool MR::isTIFFFile

(

const std::filesystem::path &

path

)

lacingToolPath()

MRVOXELS_API Expected< ToolPathResult > MR::lacingToolPath	(	const MeshPart &	mp,
		const ToolPathParams &	params,
		Axis	cutDirection )

launchDefaultViewer()

MRVIEWER_API int MR::launchDefaultViewer	(	const Viewer::LaunchParams &	params,
		const ViewerSetup &	setup )

leftRing() [1/2]

IteratorRange< LeftRingIterator > MR::leftRing ( const MeshTopology & topology, EdgeId edge )

inline

leftRing() [2/2]

IteratorRange< LeftRingIterator > MR::leftRing ( const MeshTopology & topology, FaceId f )

inline

leftRing0()

IteratorRange< LeftRingIterator > MR::leftRing0 ( const MeshTopology & topology, EdgeId edge )

inline

loadGL()

int MR::loadGL ( )

inline

loadIOExtras()

MRIOEXTRAS_API void MR::loadIOExtras

(

)

loadMeshDll()

MRMESH_API void MR::loadMeshDll

(

)

loadMRViewerDll()

MRVIEWER_API void MR::loadMRViewerDll

(

)

loadObjectFromFile()

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

load object (mesh, lines, points, voxels or scene) from file

Parameters

loadWarn	- string that collect warning messages
callback	- callback function to set progress (for progress bar)

Returns

empty string if no error or error text

loadSceneFromAnySupportedFormat()

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

makeArrow()

MRMESH_API Mesh MR::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 )

makeBasisAxes()

MRMESH_API Mesh MR::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 )

makeCone()

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

makeConvexHull() [1/3]

MRMESH_API Mesh MR::makeConvexHull

(

const Mesh &

in

)

makeConvexHull() [2/3]

MRMESH_API Mesh MR::makeConvexHull

(

const PointCloud &

in

)

makeConvexHull() [3/3]

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

makeCube()

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

makeCylinder()

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

makeCylinderAdvanced()

MRMESH_API Mesh MR::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 )

makeDegenerate()

template<typename T >

Triangle3< T > MR::makeDegenerate ( const Triangle3< T > & t )

nodiscard

make degenerate triangle (all 3 points on a line) that maximally resembles the input one and has the same centroid

makeDegenerateBandAroundRegion()

MRMESH_API void MR::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.

The function is useful for extruding the region without changing the existing faces and creating holes

Parameters

mesh	- the target mesh
region	- the region required to be separated by a band of degenerate faces
params	- optional output parameters

makeFreeFormOriginGrid()

MRMESH_API std::vector< Vector3f > MR::makeFreeFormOriginGrid	(	const Box3f &	box,
		const Vector3i &	resolution )

Returns positions of grid points in given box with given resolution.

makeLevelOfDetails()

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

nodiscard

divides given mesh into hierarchy of mesh objects: the deepest level of the hierarchy has all details from the original mesh; top levels have progressively less number of objects and less details in each; the number of faces in any object on any level is about the same.

makeMovementBuildBody()

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

nodiscard

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

makeObjectDistanceMapFromFile()

MRMESH_API Expected< ObjectDistanceMap > MR::makeObjectDistanceMapFromFile	(	const std::filesystem::path &	file,
		ProgressCallback	callback = {} )

loads distance map from given file in new object

makeObjectFromClassName()

template<typename ... P>

std::shared_ptr< VisualObject > MR::makeObjectFromClassName ( std::string className, P &&... params )

nodiscard

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

makeObjectFromEnum()

template<typename ... P>

std::shared_ptr< VisualObject > MR::makeObjectFromEnum ( FeaturesObjectKind kind, P &&... params )

nodiscard

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

makeObjectFromMeshFile()

MRMESH_API Expected< std::shared_ptr< Object > > MR::makeObjectFromMeshFile	(	const std::filesystem::path &	file,
		const MeshLoadInfo &	info = {},
		bool	returnOnlyMesh = false )

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

if true the function can return only ObjectMesh and never ObjectPoints

makeObjectFromVoxelsFile()

MRVOXELS_API Expected< std::vector< std::shared_ptr< Object > > > MR::makeObjectFromVoxelsFile	(	const std::filesystem::path &	file,
		std::string *	warnings = nullptr,
		ProgressCallback	callback = {} )

makeObjectGcodeFromFile()

MRMESH_API Expected< ObjectGcode > MR::makeObjectGcodeFromFile	(	const std::filesystem::path &	file,
		ProgressCallback	callback = {} )

loads gcode from given file in new object

makeObjectLinesFromFile()

MRMESH_API Expected< ObjectLines > MR::makeObjectLinesFromFile	(	const std::filesystem::path &	file,
		ProgressCallback	callback = {} )

loads lines from given file in new object

makeObjectMeshFromFile()

MRMESH_API Expected< ObjectMesh > MR::makeObjectMeshFromFile	(	const std::filesystem::path &	file,
		const MeshLoadInfo &	info = {} )

loads mesh from given file in new object

makeObjectPointsFromFile()

MRMESH_API Expected< ObjectPoints > MR::makeObjectPointsFromFile	(	const std::filesystem::path &	file,
		ProgressCallback	callback = {} )

loads points from given file in new object

makeObjectTreeFromFolder()

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

loads meshes from given folder in new container object

makeObjectVoxelsFromFile()

MRVOXELS_API Expected< std::vector< std::shared_ptr< ObjectVoxels > > > MR::makeObjectVoxelsFromFile	(	const std::filesystem::path &	file,
		ProgressCallback	callback = {} )

loads voxels from given file in new object

makeOpenCone()

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

makeOpenCylinder()

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

makeOuterHalfTorus()

MRMESH_API Mesh MR::makeOuterHalfTorus	(	float	primaryRadius = 1.0f,
		float	secondaryRadius = 0.1f,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std::vector< Vector3f > *	points = nullptr )

makeParallelepiped()

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

makePlane()

MRMESH_API Mesh MR::makePlane

(

)

makePrism()

MRMESH_API Mesh MR::makePrism	(	float	baseLength,
		float	leftAngle,
		float	rightAngle,
		float	height = 1.0f )

makeRegularGridMesh() [1/2]

MRMESH_API Expected< Mesh > MR::makeRegularGridMesh	(	size_t	width,
		size_t	height,
		const RegularGridLatticeValidator &	validator,
		const RegularGridLatticePositioner &	positioner,
		const RegularGridMeshFaceValidator &	faceValidator = {},
		ProgressCallback	cb = {} )

makeRegularGridMesh() [2/2]

MRMESH_API Expected< Mesh > MR::makeRegularGridMesh	(	VertCoords	pc,
		ProgressCallback	cb = {} )

makeRenderObjectConstructor()

template<typename RenderObjType >

MR_BIND_IGNORE IRenderObjectConstructorLambda MR::makeRenderObjectConstructor

(

)

makeRigidXf()

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

nodiscard

makeSignedByWindingNumber()

MRVOXELS_API Expected< void > MR::makeSignedByWindingNumber	(	FloatGrid &	grid,
		const Vector3f &	voxelSize,
		const Mesh &	refMesh,
		const MakeSignedByWindingNumberSettings &	settings )

set signs for unsigned distance field grid using generalized winding number computed at voxel grid point from refMesh

makeSphere()

MRMESH_API Mesh MR::makeSphere

(

const SphereParams &

params

)

creates a mesh of sphere with irregular triangulation

makeTorus()

MRMESH_API Mesh MR::makeTorus	(	float	primaryRadius = 1.0f,
		float	secondaryRadius = 0.1f,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std::vector< Vector3f > *	points = nullptr )

makeTorusWithComponents()

MRMESH_API Mesh MR::makeTorusWithComponents	(	float	primaryRadius = 1.0f,
		float	secondaryRadius = 0.1f,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std::vector< Vector3f > *	points = nullptr )

makeTorusWithSelfIntersections()

MRMESH_API Mesh MR::makeTorusWithSelfIntersections	(	float	primaryRadius = 1.0f,
		float	secondaryRadius = 0.1f,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std::vector< Vector3f > *	points = nullptr )

makeTorusWithSpikes()

MRMESH_API Mesh MR::makeTorusWithSpikes	(	float	primaryRadius = 1.0f,
		float	secondaryRadiusInner = 0.1f,
		float	secondaryRadiusOuter = 0.5f,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std::vector< Vector3f > *	points = nullptr )

makeTorusWithUndercut()

MRMESH_API Mesh MR::makeTorusWithUndercut	(	float	primaryRadius = 1.0f,
		float	secondaryRadiusInner = 0.1f,
		float	secondaryRadiusOuter = 0.2f,
		int	primaryResolution = 16,
		int	secondaryResolution = 16,
		std::vector< Vector3f > *	points = nullptr )

makeUVSphere()

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

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

mapEdge() [1/3]

UndirectedEdgeId MR::mapEdge ( const UndirectedEdgeBMap & map, UndirectedEdgeId src )

inlinenodiscard

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

mapEdge() [2/3]

EdgeId MR::mapEdge ( const WholeEdgeHashMap & map, EdgeId src )

inlinenodiscard

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

mapEdge() [3/3]

EdgeId MR::mapEdge ( const WholeEdgeMap & map, EdgeId src )

inlinenodiscard

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

mapEdges() [1/3]

MRMESH_API UndirectedEdgeBitSet MR::mapEdges ( const UndirectedEdgeBMap & map, const UndirectedEdgeBitSet & src )

nodiscard

given input bit-set (src), converts each id corresponding to set bit using given map, and sets its bit in the resulting bit set

mapEdges() [2/3]

MRMESH_API UndirectedEdgeBitSet MR::mapEdges ( const WholeEdgeHashMap & map, const UndirectedEdgeBitSet & src )

nodiscard

given input bit-set (src), converts each id corresponding to set bit using given map, and sets its bit in the resulting bit set

mapEdges() [3/3]

MRMESH_API UndirectedEdgeBitSet MR::mapEdges ( const WholeEdgeMap & map, const UndirectedEdgeBitSet & src )

nodiscard

given input bit-set (src), converts each id corresponding to set bit using given map, and sets its bit in the resulting bit set

mapEdgesWithHistory() [1/3]

MRVIEWER_API void MR::mapEdgesWithHistory	(	const std::shared_ptr< ObjectMesh > &	objMesh,
		const UndirectedEdgeBMap &	emap )

mapEdgesWithHistory() [2/3]

MRVIEWER_API void MR::mapEdgesWithHistory	(	const std::shared_ptr< ObjectMesh > &	objMesh,
		const WholeEdgeHashMap &	emap )

mapEdgesWithHistory() [3/3]

MRVIEWER_API void MR::mapEdgesWithHistory	(	const std::shared_ptr< ObjectMesh > &	objMesh,
		const WholeEdgeMap &	emap )

maps edge selection and creases and adds history records for that; it is a good idea to make SCOPED_HISTORY before calling this function

mapNewToOldVector()

template<typename ValueT , typename IndexT >

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

mapOldToNewVector()

template<typename ValueT , typename IndexT >

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

marchingCubes() [1/4]

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

marchingCubes() [2/4]

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

marchingCubes() [3/4]

MRVOXELS_API Expected< Mesh > MR::marchingCubes	(	const SimpleVolumeMinMax &	volume,
		const MarchingCubesParams &	params = {} )

marchingCubes() [4/4]

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

marchingCubesAsTriMesh() [1/4]

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

marchingCubesAsTriMesh() [2/4]

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

marchingCubesAsTriMesh() [3/4]

MRVOXELS_API Expected< TriMesh > MR::marchingCubesAsTriMesh	(	const SimpleVolumeMinMax &	volume,
		const MarchingCubesParams &	params = {} )

marchingCubesAsTriMesh() [4/4]

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

Matrix2< bool >()

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

Matrix2< long long >()

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

Matrix4< bool >()

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

Matrix4< long long >()

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

mcOffsetMesh()

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

nodiscard

Offsets mesh by converting it to distance field in voxels (using OpenVDB library if SignDetectionMode::OpenVDB or our implementation otherwise) and back using standard Marching Cubes, as opposed to Dual Marching Cubes in offsetMesh(...)

mcShellMeshRegion()

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

nodiscard

Constructs a shell around selected mesh region with the properties that every point on the shall must

1. be located not further than given distance from selected mesh part,
2. be located not closer to not-selected mesh part than to selected mesh part.

merge() [1/3]

MRMESH_API std::shared_ptr< ObjectLines > MR::merge ( const std::vector< std::shared_ptr< ObjectLines > > & objsLines )

nodiscard

constructs new ObjectLines containing the union of valid data from all input objects

merge() [2/3]

MRMESH_API std::shared_ptr< ObjectMesh > MR::merge ( const std::vector< std::shared_ptr< ObjectMesh > > & objsMesh )

nodiscard

constructs new ObjectMesh containing the union of valid data from all input objects

merge() [3/3]

MRMESH_API std::shared_ptr< ObjectPoints > MR::merge ( const std::vector< std::shared_ptr< ObjectPoints > > & objsPoints )

nodiscard

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

mergeSubtree() [1/2]

MRVIEWER_API void MR::mergeSubtree

(

std::shared_ptr< Object >

rootObj

)

mergeSubtree() [2/2]

MRVIEWER_API void MR::mergeSubtree

(

TypedFlatTree

subtree

)

merge objects of same type in the object tree

mergeVolumePart()

template<typename Volume >

Expected< void > MR::mergeVolumePart	(	Mesh &	mesh,
		std::vector< EdgePath > &	cutContours,
		Volume &&	volume,
		float	leftCutPosition,
		float	rightCutPosition,
		const MergeVolumePartSettings &	settings = {} )

Merge one mesh with another generated from a voxel volume part.

The helper function for generating a mesh from a voxel volume without full memory loading. It performs several actions:

• converts the voxel volume part into a mesh;
• cuts it to make its sides accurate;
• appends to the result mesh with the matching side cut contours. The functions has requirements for the input parameters:
• the result mesh must have side contours on leftCutPosition;
• the voxel volume part must have enough data to generate a mesh with correct cut contours. The usual way is to make an overlap for each volume part.

See also

volumeToMeshByParts

Parameters

mesh	- result mesh to which the generated mesh will be attached
cutContours	- cut contours of the result mesh; must be placed at leftCutPosition
volume	- voxel volume part
leftCutPosition	- position on X axis where the left side of the generated mesh is cut; pass -FLT_MAX to omit a cut here
rightCutPosition	- position on X axis where the right side of the generated mesh is cut; pass +FLT_MAX to omit a cut here
settings	- additional parameters; see MergeVolumePartSettings

Returns

nothing if succeeds, an error string otherwise

meshDenoiseViaNormals()

MRMESH_API Expected< void > MR::meshDenoiseViaNormals	(	Mesh &	mesh,
		const DenoiseViaNormalsSettings &	settings = {} )

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

meshOnEdgeSplitAttribute()

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

auto uvCoords = obj_->getUVCoords(); auto texturePerFace = obj_->getTexturePerFace(); MeshAttributesToUpdate meshParams; if ( !uvCoords.empty() ) meshParams.uvCoords = &uvCoords; if ( !texturePerFace.empty() ) meshParams.texturePerFace = &texturePerFace; subs.onEdgeSplit = meshOnEdgeSplitAttribute( *obj_->varMesh(), meshParams ); subdivideMesh( *obj_->varMesh(), subs );

meshOnEdgeSplitFaceAttribute()

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

meshOnEdgeSplitVertAttribute()

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

meshPreCollapseVertAttribute()

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

Please use this callback when you decimate a mesh with associated data with each vertex recalculate texture coordinates and mesh vertex colors for vertices moved during decimation usage example MeshAttributesToUpdate meshParams; auto uvCoords = obj->getUVCoords(); auto colorMap = obj->getVertsColorMap(); if ( needUpdateUV ) meshParams.uvCoords = &uvCoords; if ( needUpdateColorMap ) meshParams.colorMap = &colorMap; auto preCollapse = meshPreCollapseVertAttribute( mesh, meshParams ); decimateMesh( mesh, DecimateSettings{ .preCollapse = preCollapse } );

meshRegionToIndicatorVolume()

MRVOXELS_API Expected< SimpleVolumeMinMax > MR::meshRegionToIndicatorVolume	(	const Mesh &	mesh,
		const FaceBitSet &	region,
		float	offset,
		const DistanceVolumeParams &	params )

returns a volume filled with the values: v < 0: this point is within offset distance to region-part of mesh and it is closer to region-part than to not-region-part

meshToDirectionVolume()

MRVOXELS_API Expected< std::array< SimpleVolumeMinMax, 3 > > MR::meshToDirectionVolume

(

const MeshToDirectionVolumeParams &

params

)

Converts mesh into 4d voxels, so that each cell in 3d space holds the direction from the closest point on mesh to the cell position. Resulting volume is encoded by 3 separate 3d volumes, corresponding to x, y and z components of vectors respectively.

Parameters

params

Expected to have valid (not null) projector, with invoked method IPointsToMeshProjector::updateMeshData

meshToDistanceField()

MRVOXELS_API FloatGrid MR::meshToDistanceField	(	const MeshPart &	mp,
		const AffineXf3f &	xf,
		const Vector3f &	voxelSize,
		float	surfaceOffset = 3,
		ProgressCallback	cb = {} )

meshToDistanceFunctionVolume()

MRVOXELS_API FunctionVolume MR::meshToDistanceFunctionVolume	(	const MeshPart &	mp,
		const MeshToDistanceVolumeParams &	params = {} )

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

meshToDistanceVolume()

MRVOXELS_API Expected< SimpleVolumeMinMax > MR::meshToDistanceVolume	(	const MeshPart &	mp,
		const MeshToDistanceVolumeParams &	params = {} )

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

meshToLevelSet()

MRVOXELS_API FloatGrid MR::meshToLevelSet	(	const MeshPart &	mp,
		const AffineXf3f &	xf,
		const Vector3f &	voxelSize,
		float	surfaceOffset = 3,
		ProgressCallback	cb = {} )

meshToVolume()

MRVOXELS_API Expected< VdbVolume > MR::meshToVolume	(	const Mesh &	mesh,
		const MeshToVolumeParams &	params = {} )

minTriangleAngle()

template<typename T >

T MR::minTriangleAngle ( const Vector3< T > & a, const Vector3< T > & b, const Vector3< T > & c )

nodiscard

moveMeshToVoxelMaxDeriv()

MRVOXELS_API Expected< VertBitSet > MR::moveMeshToVoxelMaxDeriv	(	Mesh &	mesh,
		const AffineXf3f &	meshXf,
		const VdbVolume &	volume,
		const AffineXf3f &	volumeXf,
		const MoveMeshToVoxelMaxDerivSettings &	settings,
		ProgressCallback	callback = {} )

Moves each vertex along its normal to the minimize (with sign, i.e. maximize the absolute value with negative sign) the derivative of voxels.

Returns

Vertices that were moved by the algorithm

MR_CANONICAL_TYPEDEFS() [1/24]

MR::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 >)	)

MR_CANONICAL_TYPEDEFS() [2/24]

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

MRMESH_CLASS Vector3< double > Matrix2< double > MR::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() [4/24]

MR::MR_CANONICAL_TYPEDEFS	(	(template< typename T > struct)	,
		MRMESH_CLASS	MeshRegion,
		(MeshPart, MeshRegion< FaceTag >)(MeshVertPart, MeshRegion< VertTag >)	)

MR_CANONICAL_TYPEDEFS() [5/24]

MR::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() [6/24]

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

MR_CANONICAL_TYPEDEFS() [7/24]

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

MR_CANONICAL_TYPEDEFS() [8/24]

MR::MR_CANONICAL_TYPEDEFS	(	(template< typename T > struct)	,
		Quaternion	,
		(Quaternionf, Quaternion< float >)(Quaterniond, Quaternion< double >)	)

MR_CANONICAL_TYPEDEFS() [9/24]

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

MR_CANONICAL_TYPEDEFS() [10/24]

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

MR_CANONICAL_TYPEDEFS() [11/24]

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

MR_CANONICAL_TYPEDEFS() [12/24]

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > MR::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() [13/24]

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double > MR::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() [14/24]

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

MR_CANONICAL_TYPEDEFS() [15/24]

MRMESH_CLASS Vector3< double > MR::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() [16/24]

MR::MR_CANONICAL_TYPEDEFS	(	(template< typename T > struct)	,
		VoxelsVolumeMinMax	,
		(SimpleVolumeMinMax, VoxelsVolumeMinMax< std::vector< float > >)(SimpleVolumeMinMaxU16, VoxelsVolumeMinMax< std::vector< uint16_t > >)(VdbVolume, VoxelsVolumeMinMax< FloatGrid >)	)

MR_CANONICAL_TYPEDEFS() [17/24]

MR::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 >)	)

MR_CANONICAL_TYPEDEFS() [18/24]

MR::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 >)	)

MR_CANONICAL_TYPEDEFS() [19/24]

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

MR_CANONICAL_TYPEDEFS() [20/24]

MR::MR_CANONICAL_TYPEDEFS	(	(template< typename V > struct)	,
		Line	,
		(Line2f, Line< Vector2< float > >)(Line2d, Line< Vector2< double > >)(Line3f, Line< Vector3< float > >)(Line3d, Line< Vector3< double > >)	)

MR_CANONICAL_TYPEDEFS() [21/24]

MR::MR_CANONICAL_TYPEDEFS	(	(template< typename V > struct)	,
		LineSegm	,
		(LineSegm2f, LineSegm< Vector2< float > >)(LineSegm2d, LineSegm< Vector2< double > >)(LineSegm3f, LineSegm< Vector3< float > >)(LineSegm3d, LineSegm< Vector3< double > >)	)

MR_CANONICAL_TYPEDEFS() [22/24]

MR::MR_CANONICAL_TYPEDEFS	(	(template< typename V > struct)	,
		Polyline	,
		(Polyline2, Polyline< Vector2f >)(Polyline3, Polyline< Vector3f >)	)

MR_CANONICAL_TYPEDEFS() [23/24]

MR::MR_CANONICAL_TYPEDEFS	(	(template< typename V > struct)	,
		QuadraticForm	,
		(QuadraticForm2f, QuadraticForm< Vector2< float > >)(QuadraticForm2d, QuadraticForm< Vector2< double > >)(QuadraticForm3f, QuadraticForm< Vector3< float > >)(QuadraticForm3d, QuadraticForm< Vector3< double > >)	)

MR_CANONICAL_TYPEDEFS() [24/24]

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

nodiscard

multiModelGridSampling()

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

performs sampling of several models respecting their world transformations subdivides models bounding box on voxels of approximately given size and returns at most one point per voxel; returns std::nullopt if it was terminated by the callback

normal()

template<typename T >

Vector3< T > MR::normal ( const Vector3< T > & p, const Vector3< T > & q, const Vector3< T > & r )

inlinenodiscard

computes unitNormal of given triangle

objectHasSelectableChildren()

bool MR::objectHasSelectableChildren ( const MR::Object & object )

inline

offsetContours() [1/4]

MRMESH_API Contours2f MR::offsetContours ( const Contours2f & contours, ContoursVariableOffset offset, const OffsetContoursParams & params = {} )

nodiscard

offsets 2d contours in plane

offsetContours() [2/4]

MRMESH_API Contours2f MR::offsetContours ( const Contours2f & contours, float offset, const OffsetContoursParams & params = {} )

nodiscard

offsets 2d contours in plane

offsetContours() [3/4]

MRMESH_API Contours3f MR::offsetContours ( const Contours3f & contours, ContoursVariableOffset offset, const OffsetContoursParams & params = {}, const OffsetContoursRestoreZParams & zParmas = {} )

nodiscard

offsets 3d contours in XY plane

offsetContours() [4/4]

MRMESH_API Contours3f MR::offsetContours ( const Contours3f & contours, float offset, const OffsetContoursParams & params = {}, const OffsetContoursRestoreZParams & zParmas = {} )

nodiscard

offsets 3d contours in XY plane

offsetMesh()

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

nodiscard

Offsets mesh by converting it to distance field in voxels using OpenVDB library, signDetectionMode = Unsigned(from OpenVDB) | OpenVDB | HoleWindingRule, and then converts back using OpenVDB library (dual marching cubes), so result mesh is always closed

offsetOneDirection()

MRVOXELS_API Expected< Mesh > MR::offsetOneDirection ( const MeshPart & mp, float offset, const GeneralOffsetParameters & params = {} )

nodiscard

offsets given MeshPart in one direction only (positive or negative) if your input mesh is open then please specify params.signDetectionMode = SignDetectionMode::Unsigned if your input mesh is closed this function is equivalent to generalOffsetMesh, but in SignDetectionMode::Unsigned mode it will only keep one side (just like for open mesh) unlike thickenMesh this functions does not keep original mesh in result

offsetPolyline()

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

nodiscard

Offsets polyline by converting it to voxels and building iso-surface do offset in all directions so result mesh is always closed params.signDetectionMode is ignored (always assumed SignDetectionMode::Unsigned)

onEdgeSplitFaceAttribute()

template<typename T >

auto MR::onEdgeSplitFaceAttribute	(	const Mesh &	mesh,
		Vector< T, FaceId > &	data )

onEdgeSplitVertAttribute()

template<typename T >

auto MR::onEdgeSplitVertAttribute	(	const Mesh &	mesh,
		Vector< T, VertId > &	data )

OpenDocument()

MRMESH_API bool MR::OpenDocument

(

const std::filesystem::path &

path

)

openFileDialog()

MRVIEWER_API std::filesystem::path MR::openFileDialog

(

const FileParameters &

params = {}

)

openFileDialogAsync()

MRVIEWER_API void MR::openFileDialogAsync	(	std::function< void(const std::filesystem::path &)>	callback,
		const FileParameters &	params = {} )

openFilesDialog()

MRVIEWER_API std::vector< std::filesystem::path > MR::openFilesDialog

(

const FileParameters &

params = {}

)

openFilesDialogAsync()

MRVIEWER_API void MR::openFilesDialogAsync	(	std::function< void(const std::vector< std::filesystem::path > &)>	callback,
		const FileParameters &	params = {} )

openFolderDialog()

MRVIEWER_API std::filesystem::path MR::openFolderDialog

(

std::filesystem::path

baseFolder = {}

)

openFolderDialogAsync()

MRVIEWER_API void MR::openFolderDialogAsync	(	std::function< void(const std::filesystem::path &)>	callback,
		std::filesystem::path	baseFolder = {} )

openFoldersDialog()

MRVIEWER_API std::vector< std::filesystem::path > MR::openFoldersDialog

(

std::filesystem::path

baseFolder = {}

)

OpenLink()

MRMESH_API void MR::OpenLink

(

const std::string &

url

)

operator!=() [1/5]

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

inline

operator!=() [2/5]

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

inlinenodiscard

operator!=() [3/5]

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

inlinenodiscard

operator!=() [4/5]

template<typename N >

bool MR::operator!= ( const RingIterator< N > & a, const RingIterator< N > & b )

inline

operator!=() [5/5]

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

inline

operator""_e()

EdgeId MR::operator""_e ( unsigned long long i )

inlineconstexprnoexcept

operator""_f()

FaceId MR::operator""_f ( unsigned long long i )

inlineconstexprnoexcept

operator""_ue()

UndirectedEdgeId MR::operator""_ue ( unsigned long long i )

inlineconstexprnoexcept

operator""_v()

VertId MR::operator""_v ( unsigned long long i )

inlineconstexprnoexcept

operator""_vox()

VoxelId MR::operator""_vox ( unsigned long long i )

inlineconstexprnoexcept

operator*() [1/2]

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

inline

operator*() [2/2]

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

inline

operator*=()

MRMESH_API TransformedMesh & MR::operator*=	(	TransformedMesh &	a,
		const TransformedMesh &	b )

intersection operation on two meshes

operator+() [1/4]

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

inline

operator+() [2/4]

template<typename T >

Id< T > MR::operator+ ( Id< T > id, int a )

inlineconstexpr

operator+() [3/4]

template<typename T >

Id< T > MR::operator+ ( Id< T > id, size_t a )

inlineconstexpr

operator+() [4/4]

template<typename T >

Id< T > MR::operator+ ( Id< T > id, unsigned int a )

inlineconstexpr

operator+=()

MRMESH_API TransformedMesh & MR::operator+=	(	TransformedMesh &	a,
		const TransformedMesh &	b )

union operation on two meshes

operator-() [1/4]

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

inline

operator-() [2/4]

template<typename T >

Id< T > MR::operator- ( Id< T > id, int a )

inlineconstexpr

operator-() [3/4]

template<typename T >

Id< T > MR::operator- ( Id< T > id, size_t a )

inlineconstexpr

operator-() [4/4]

template<typename T >

Id< T > MR::operator- ( Id< T > id, unsigned int a )

inlineconstexpr

operator-=()

MRMESH_API TransformedMesh & MR::operator-=	(	TransformedMesh &	a,
		const TransformedMesh &	b )

difference operation on two meshes

operator/()

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

inline

operator<<() [1/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const AffineXf3< T > & xf )

inline

operator<<() [2/11]

template<typename V >

std::ostream & MR::operator<< ( std::ostream & s, const Box< V > & box )

inline

operator<<() [3/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const Line3< T > & l )

inline

operator<<() [4/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const Matrix3< T > & mat )

inline

operator<<() [5/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const Matrix4< T > & mat )

inline

operator<<() [6/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const Plane3< T > & pl )

inline

operator<<() [7/11]

std::ostream & MR::operator<< ( std::ostream & s, const PointOnFace & pof )

inline

operator<<() [8/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const TriPoint< T > & tp )

inline

operator<<() [9/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const Vector2< T > & vec )

inline

operator<<() [10/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const Vector3< T > & vec )

inline

operator<<() [11/11]

template<typename T >

std::ostream & MR::operator<< ( std::ostream & s, const Vector4< T > & vec )

inline

operator==() [1/7]

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

inline

operator==() [2/7]

template<typename V >

bool MR::operator== ( const LineSegm< V > & a, const LineSegm< V > & b )

inlinenodiscard

operator==() [3/7]

template<typename N >

bool MR::operator== ( const RingIterator< N > & a, const RingIterator< N > & b )

inline

operator==() [4/7]

bool MR::operator== ( const SegmEndColors & a, const SegmEndColors & b )

inline

operator==() [5/7]

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

inline

operator==() [6/7]

bool MR::operator== ( const ViewportLinesWithColors & a, const ViewportLinesWithColors & b )

inline

operator==() [7/7]

bool MR::operator== ( const ViewportPointsWithColors & a, const ViewportPointsWithColors & b )

inline

operator>>() [1/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, AffineXf3< T > & xf )

inline

operator>>() [2/11]

template<typename V >

std::istream & MR::operator>> ( std::istream & s, Box< V > & box )

inline

operator>>() [3/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, Line3< T > & l )

inline

operator>>() [4/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, Matrix3< T > & mat )

inline

operator>>() [5/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, Matrix4< T > & mat )

inline

operator>>() [6/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, Plane3< T > & pl )

inline

operator>>() [7/11]

std::istream & MR::operator>> ( std::istream & s, PointOnFace & pof )

inline

operator>>() [8/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, TriPoint< T > & tp )

inline

operator>>() [9/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, Vector2< T > & vec )

inline

operator>>() [10/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, Vector3< T > & vec )

inline

operator>>() [11/11]

template<typename T >

std::istream & MR::operator>> ( std::istream & s, Vector4< T > & vec )

inline

orderIntersectionContours()

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

orgRing() [1/2]

IteratorRange< OrgRingIterator > MR::orgRing ( const MeshTopology & topology, EdgeId edge )

inline

orgRing() [2/2]

IteratorRange< OrgRingIterator > MR::orgRing ( const MeshTopology & topology, VertId v )

inline

orgRing0()

IteratorRange< OrgRingIterator > MR::orgRing0 ( const MeshTopology & topology, EdgeId edge )

inline

orient3d() [1/3]

MRMESH_API bool MR::orient3d

(

const PreciseVertCoords *

vs

)

orient3d() [2/3]

MRMESH_API bool MR::orient3d

(

const std::array< PreciseVertCoords, 4 > &

vs

)

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

orient3d() [3/3]

bool MR::orient3d ( const Vector3i & a, const Vector3i & b, const Vector3i & c, const Vector3i & d )

inline

returns true if the plane with orientated triangle ABC has D point at the left; uses simulation-of-simplicity to avoid "D is exactly on plane"

orientLocalTriangulations() [1/2]

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

orientLocalTriangulations() [2/2]

MRMESH_API void MR::orientLocalTriangulations	(	AllLocalTriangulations &	triangs,
		const VertCoords &	coords,
		const VertBitSet &	region,
		const VertNormals &	targetDir )

orient neighbors around each point in

Parameters

region

so they will be in clockwise order if look from the tip of target direction

overloaded()

template<class... Ts>

MR::overloaded

(

Ts...

)

-> overloaded< Ts... >

pack()

MRMESH_API std::shared_ptr< ObjectPoints > MR::pack ( const ObjectPoints & pts, Reorder reorder, VertBitSet * newValidVerts = nullptr, const ProgressCallback & cb = {} )

nodiscard

constructs new ObjectPoints containing the packed version of input points,

Parameters

newValidVerts

if given, then use them instead of valid points from pts

Returns

nullptr if the operation was cancelled

packPointsWithHistory() [1/2]

MRVIEWER_API void MR::packPointsWithHistory	(	const std::shared_ptr< ObjectPoints > &	objPoints,
		Reorder	reoder )

packs ObjectPoints optimally updating colors and adds history records for that; it is a good idea to make SCOPED_HISTORY before calling this function

packPointsWithHistory() [2/2]

MRVIEWER_API void MR::packPointsWithHistory	(	const std::shared_ptr< ObjectPoints > &	objPoints,
		Reorder	reoder,
		VertBitSet	newValidVerts )

sets new valid vertices then packs ObjectPoints optimally updating colors and adds history records for that; it is a good idea to make SCOPED_HISTORY before calling this function

parseAscCoordinate()

template<typename T >

Expected< void > MR::parseAscCoordinate	(	const std::string_view &	str,
		Vector3< T > &	v,
		Vector3< T > *	n = nullptr,
		Color *	c = nullptr )

parseFirstNum()

MRMESH_API Expected< void > MR::parseFirstNum	(	const std::string_view &	str,
		int &	num )

parseObjCoordinate()

template<typename T >

Expected< void > MR::parseObjCoordinate	(	const std::string_view &	str,
		Vector3< T > &	v,
		Vector3< T > *	c = nullptr )

parsePolygon()

MRMESH_API Expected< void > MR::parsePolygon	(	const std::string_view &	str,
		VertId *	vertId,
		int *	numPoints )

parsePtsCoordinate()

template<typename T >

Expected< void > MR::parsePtsCoordinate	(	const std::string_view &	str,
		Vector3< T > &	v,
		Color &	c )

parseResponse()

MRVIEWER_API Expected< Json::Value > MR::parseResponse

(

const Json::Value &

response

)

parseSingleNumber()

template<typename T >

Expected< void > MR::parseSingleNumber	(	const std::string_view &	str,
		T &	num )

parseTextCoordinate()

template<typename T >

Expected< void > MR::parseTextCoordinate	(	const std::string_view &	str,
		Vector3< T > &	v,
		Vector3< T > *	n = nullptr,
		Color *	c = nullptr )

partialOffsetMesh()

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

Offsets mesh part by converting it to voxels and back and unite it with original mesh (via boolean) note: only OffsetParameters.signDetectionMode = SignDetectionMode::Unsigned will work in this function

pickedPointToVector3()

MRMESH_API MR::Vector3f MR::pickedPointToVector3	(	const VisualObject *	object,
		const PickedPoint &	point )

planeSectionsToContours2f()

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

nodiscard

planeSectionToContour2f()

MRMESH_API Contour2f MR::planeSectionToContour2f ( const Mesh & mesh, const PlaneSection & section, const AffineXf3f & meshToPlane )

nodiscard

converts PlaneSections in 2D contours by computing coordinate of each point, applying given xf to it, and retaining only x and y

pointGridSampling()

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

performs sampling of cloud points; subdivides point cloud bounding box on voxels of approximately given size and returns at most one point per voxel; returns std::nullopt if it was terminated by the callback

pointIterativeSampling()

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

performs sampling of cloud points by iteratively removing one point with minimal metric (describing distance to the closest point and previous nearby removals), thus allowing stopping at any given number of samples; returns std::nullopt if it was terminated by the callback

pointOnObjectToPickedPoint()

MRMESH_API PickedPoint MR::pointOnObjectToPickedPoint	(	const VisualObject *	object,
		const PointOnObject &	pos )

pointsToDistanceFunctionVolume()

MRVOXELS_API FunctionVolume MR::pointsToDistanceFunctionVolume ( const PointCloud & cloud, const PointsToDistanceVolumeParams & params )

nodiscard

makes FunctionVolume representing signed distances to points with normals

pointsToDistanceVolume()

MRVOXELS_API Expected< SimpleVolume > MR::pointsToDistanceVolume ( const PointCloud & cloud, const PointsToDistanceVolumeParams & params )

nodiscard

makes SimpleVolume filled with signed distances to points with normals

pointsToMeshFusion()

MRVOXELS_API Expected< Mesh > MR::pointsToMeshFusion ( const PointCloud & cloud, const PointsToMeshParameters & params )

nodiscard

makes mesh from points with normals by constructing intermediate volume with signed distances and then using marching cubes algorithm to extract the surface from there

PolylineProjectionWithOffsetResult< Vector2f >()

MR::PolylineProjectionWithOffsetResult< Vector2f >	(	PolylineProjectionWithOffsetResult3	,
		PolylineProjectionWithOffsetResult< Vector3f >	)

posFromTriEdgeLengths()

template<typename T >

std::optional< Vector2< T > > MR::posFromTriEdgeLengths ( T a, T b, T c )

nodiscard

given the lengths of 3 edges of triangle ABC, and assuming that point B has coordinates (0,0); point A - (0,c); computes the coordinates of point C (where c.x >= 0) or returns std::nullopt if input lengths are invalid for a triangle

position()

ImVec2 MR::position ( const ViewportRectangle & rect )

inline

positionVertsSmoothly()

MRMESH_API void MR::positionVertsSmoothly	(	Mesh &	mesh,
		const VertBitSet &	verts,
		EdgeWeights	edgeWeightsType = EdgeWeights::Cotan,
		const VertBitSet *	fixedSharpVertices = nullptr )

Puts given vertices in such positions to make smooth surface both inside verts-region and on its boundary;

Parameters

verts	must not include all vertices of a mesh connected component
fixedSharpVertices	in these vertices the surface can be not-smooth

positionVertsSmoothlySharpBd()

MRMESH_API void MR::positionVertsSmoothlySharpBd	(	Mesh &	mesh,
		const VertBitSet &	verts,
		const Vector< Vector3f, VertId > *	vertShifts = nullptr,
		const VertScalars *	vertStabilizers = nullptr )

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

Parameters

verts	must not include all vertices of a mesh connected component unless vertStabilizers are given
vertShifts	optional additional shifts of each vertex relative to smooth position
vertStabilizers	optional per-vertex stabilizers: the more the value, the bigger vertex attraction to its original position

positionVertsWithSpacing()

MRMESH_API void MR::positionVertsWithSpacing	(	Mesh &	mesh,
		const SpacingSettings &	settings )

Moves given vertices to make the distances between them as specified.

preCollapseVertAttribute()

template<typename T >

auto MR::preCollapseVertAttribute	(	const Mesh &	mesh,
		Vector< T, VertId > &	data )

printStacktraceOnCrash()

MRMESH_API void MR::printStacktraceOnCrash

(

)

Print stacktrace on application crash.

projectFaceAttribute()

template<typename F >

bool MR::projectFaceAttribute	(	const MeshPart &	mp,
		const Mesh &	oldMesh,
		F &&	func,
		ProgressCallback	progressCb )

projectMeshAttributes()

MRVIEWER_API std::optional< MeshAttributes > MR::projectMeshAttributes ( const ObjectMesh & oldMeshObj, const MeshPart & newMeshPart, ProgressCallback cb = {} )

nodiscard

finds attributes of new mesh part by projecting region's faces/vertices on old mesh returns nullopt if canceled by progress bar

projectOnAll()

MRMESH_API void MR::projectOnAll	(	const Vector3f &	pt,
		const AABBTreeObjects &	tree,
		float	upDistLimitSq,
		const ProjectOnAllCallback &	callback,
		ObjId	skipObjId = {} )

finds closest point on every object within given distance

projection on given object will be skipped

Parameters

pt	target point in world coordinates
tree	contains a set of objects to search closest points on each of them
upDistLimitSq	upper limit on the distance in question
callback	each found closest point within given distance will be returned via this callback

projectVertAttribute()

template<typename F >

bool MR::projectVertAttribute	(	const MeshVertPart &	mp,
		const Mesh &	oldMesh,
		F &&	func,
		ProgressCallback	progressCb )

pushNotification()

MRVIEWER_API void MR::pushNotification

(

const RibbonNotification &

notification

)

putScanFileNameInZ()

MRVOXELS_API void MR::putScanFileNameInZ	(	const std::vector< std::filesystem::path > &	scans,
		std::vector< SliceInfo > &	zOrder )

Read layer heights from given scan file names.

putSimpleVolumeInDenseGrid()

MRVOXELS_API void MR::putSimpleVolumeInDenseGrid	(	FloatGrid &	grid,
		const Vector3i &	minCoord,
		const SimpleVolume &	simpleVolume,
		ProgressCallback	cb = {} )

Copy given simpleVolume into the grid, starting at minCoord.

pythonAppendOrRun()

template<typename F , typename... Args>

void MR::pythonAppendOrRun	(	F	func,
		Args &&...	args )

pythonRunFromGUIThread() [1/3]

template<typename F >

auto MR::pythonRunFromGUIThread ( F && f )

nodiscard

pythonRunFromGUIThread() [2/3]

template<typename R , typename T , typename... Args>

auto MR::pythonRunFromGUIThread

(

R(T::*

memFunction )(Args...)

)

pythonRunFromGUIThread() [3/3]

template<typename R , typename... Args>

auto MR::pythonRunFromGUIThread ( std::function< R(Args...)> && f ) -> std::function<void( Args... )>

nodiscard

quadrangleOtherDiagonal()

template<typename T >

std::optional< T > MR::quadrangleOtherDiagonal ( T a, T b, T c, T a1, T b1 )

nodiscard

given the lengths of 4 edges of a quadrangle, and one of its diagonals (c); returns the length of the other diagonal if the quadrangle is valid and convex or std::nullopt otherwise

rayBoxIntersect() [1/2]

template<typename T = float>

bool MR::rayBoxIntersect	(	const Box2< T > &	box,
		const Line2< T > &	line,
		T	t0,
		T	t1 )

rayBoxIntersect() [2/2]

template<typename T >

bool MR::rayBoxIntersect	(	const Box2< T > &	box,
		const Vector2< T > &	rayOrigin,
		T &	t0,
		T &	t1,
		const IntersectionPrecomputes2< T > &	prec )

rayInsideIntersect() [1/2]

MRMESH_API MeshIntersectionResult MR::rayInsideIntersect ( const Mesh & mesh, const MeshPoint & m, float rayEnd = FLT_MAX )

nodiscard

returns the nearest intersection between the mesh and the ray from given point along minus normal (inside the mesh)

rayInsideIntersect() [2/2]

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

nodiscard

rayPolylineIntersect() [1/2]

MRMESH_API std::optional< PolylineIntersectionResult2 > MR::rayPolylineIntersect ( const Polyline2 & polyline, const Line2d & line, double rayStart = 0, double rayEnd = DBL_MAX, const IntersectionPrecomputes2< double > * prec = nullptr, bool closestIntersect = true )

nodiscard

Finds ray and polyline intersection in double-precision. rayStart and rayEnd define the interval on the ray to detect an intersection. prec can be specified to reuse some precomputations (e.g. for checking many parallel rays). Finds the closest to ray origin intersection (or any intersection for better performance if !closestIntersect).

rayPolylineIntersect() [2/2]

MRMESH_API std::optional< PolylineIntersectionResult2 > MR::rayPolylineIntersect ( const Polyline2 & polyline, const Line2f & line, float rayStart = 0, float rayEnd = FLT_MAX, const IntersectionPrecomputes2< float > * prec = nullptr, bool closestIntersect = true )

nodiscard

Finds ray and polyline intersection in float-precision. rayStart and rayEnd define the interval on the ray to detect an intersection. prec can be specified to reuse some precomputations (e.g. for checking many parallel rays). Finds the closest to ray origin intersection (or any intersection for better performance if !closestIntersect).

readByBlocks()

MRMESH_API bool MR::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

if progress callback is not set, read all data by one block

Returns

false if process was canceled (callback is set and return false )

readCharBuffer()

MR_BIND_IGNORE MRMESH_API Expected< Buffer< char > > MR::readCharBuffer

(

std::istream &

in

)

readRawTiff()

MRMESH_API Expected< void > MR::readRawTiff	(	const std::filesystem::path &	path,
		RawTiffOutput &	output )

readString()

MRMESH_API Expected< std::string > MR::readString

(

std::istream &

in

)

readTiffParameters()

MRMESH_API Expected< TiffParameters > MR::readTiffParameters

(

const std::filesystem::path &

path

)

rearrangeVectorByMap()

template<typename T , typename I >

Vector< T, I > MR::rearrangeVectorByMap ( const Vector< T, I > & oldVector, const BMap< I, I > & map )

nodiscard

rebuildMesh()

MRVOXELS_API Expected< Mesh > MR::rebuildMesh ( const MeshPart & mp, const RebuildMeshSettings & settings )

nodiscard

fixes all types of issues in input mesh (degenerations, holes, self-intersections, etc.) by first converting mesh in voxel representation, and then backward

refineFeatureObject() [1/2]

MRMESH_API Expected< AffineXf3f > MR::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.

refineFeatureObject() [2/2]

MRMESH_API Expected< AffineXf3f > MR::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.

remesh()

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

removeLoneContours()

MRMESH_API void MR::removeLoneContours

(

ContinuousContours &

contours

)

removeLoneDegeneratedContours()

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

replace()

MRMESH_API std::string MR::replace ( std::string target, std::string_view from, std::string_view to )

nodiscard

Returns.

Parameters

target	with all
from	replaced with
to,zero	or more times.

replaceInplace()

MRMESH_API void MR::replaceInplace	(	std::string &	target,
		std::string_view	from,
		std::string_view	to )

Replaces.

Parameters

from	with
to	in
target	(in-place), zero or more times.

replaceProhibitedChars()

MRMESH_API std::string MR::replaceProhibitedChars ( const std::string & line, char replacement = '_' )

nodiscard

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

replicateZ()

MRMESH_API void MR::replicateZ	(	Mesh &	m,
		const Mesh &	target )

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

reportProgress() [1/4]

template<typename F >

bool MR::reportProgress ( ProgressCallback cb, F && f )

inline

safely invokes

Parameters

cb	with the value produced by given functor; just returning true for empty callback and not evaluating the function

reportProgress() [2/4]

template<typename F >

bool MR::reportProgress ( ProgressCallback cb, F && f, size_t counter, int divider )

inline

safely invokes

Parameters

cb	with the value produced by given functor if
counter	is divisible by
divider	(preferably a power of 2); just returning true for empty callback and not evaluating the function

reportProgress() [3/4]

bool MR::reportProgress ( ProgressCallback cb, float v )

inline

safely invokes

Parameters

cb	with given value; just returning true for empty callback

reportProgress() [4/4]

bool MR::reportProgress ( ProgressCallback cb, float v, size_t counter, int divider )

inline

safely invokes

Parameters

cb	with given value if
counter	is divisible by
divider	(preferably a power of 2); just returning true for empty callback

resampleVolumeByInterpolation()

template<typename Accessor >

SimpleVolumeMinMax MR::resampleVolumeByInterpolation	(	const typename Accessor::VolumeType &	volume,
		const Accessor &	accessor,
		const Vector3f &	newVoxelSize )

sample function that resamples the voxel volume using interpolating accessor

reserveKeyEvent()

MRVIEWER_API void MR::reserveKeyEvent

(

ImGuiKey

key

)

resolveMeshDegenerations()

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

RigidScaleXf3< float >()

MR::RigidScaleXf3< float >	(	RigidScaleXf3d	,
		RigidScaleXf3< double >	)

roundToPrecision() [1/2]

MRMESH_API double MR::roundToPrecision ( double v, int precision )

nodiscard

returns given value rounded to given number of decimal digits

roundToPrecision() [2/2]

float MR::roundToPrecision ( float v, int precision )

inlinenodiscard

returns given value rounded to given number of decimal digits

same()

MRMESH_API bool MR::same ( const MeshTopology & topology, const EdgePoint & lhs, const EdgePoint & rhs )

nodiscard

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

sampleHalfSphere()

MRMESH_API std::vector< Vector3f > MR::sampleHalfSphere ( )

nodiscard

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

saveFileDialog()

MRVIEWER_API std::filesystem::path MR::saveFileDialog

(

const FileParameters &

params = {}

)

saveFileDialogAsync()

MRVIEWER_API void MR::saveFileDialogAsync	(	std::function< void(const std::filesystem::path &)>	callback,
		const FileParameters &	params = {} )

saveObjectToFile()

MRVIEWER_API Expected< void > MR::saveObjectToFile	(	const Object &	obj,
		const std::filesystem::path &	filename,
		const SaveObjectSettings &	settings = {} )

save visual object (mesh, lines, points or voxels) to file

Returns

empty string if no error or error text

saveObjectVoxelsToFile()

MRVOXELS_API Expected< void > MR::saveObjectVoxelsToFile	(	const Object &	object,
		const std::filesystem::path &	path,
		const ProgressCallback &	callback = {} )

sceneReorderWithUndo()

bool MR::sceneReorderWithUndo

(

const SceneReorder &

task

)

moves objects in scene as prescribed by (task), preserving world location of each object;

Returns

false if the move failed

sceneSelectedAtLeast()

template<typename ObjectT , bool visualRepresentationCheck, bool modelCheck>

std::string MR::sceneSelectedAtLeast	(	const std::vector< std::shared_ptr< const Object > > &	objs,
		unsigned	n )

sceneSelectedExactly()

template<typename ObjectT , bool visualRepresentationCheck, bool modelCheck>

std::string MR::sceneSelectedExactly	(	const std::vector< std::shared_ptr< const Object > > &	objs,
		unsigned	n )

SegPoints()

MRMESH_API void MR::SegPoints	(	Vector3f &	VEC,
		Vector3f &	X,
		Vector3f &	Y,
		const Vector3f &	P,
		const Vector3f &	A,
		const Vector3f &	Q,
		const Vector3f &	B )

Returns closest points between an segment pair.

SelectCurvaturePreference()

float MRVIEWER_API MR::SelectCurvaturePreference	(	PathPreference *	pp,
		float	menuScaling )

draws a Combo with three PathPreference options returns multiplier before dihedral angle sine in edge metric calculation (positive to prefer concave angles, negative - convex)

Parameters

pp	is passed by pointer because in can be changed inside

separateClosedContour()

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

serializeObjectTree() [1/2]

MRMESH_API Expected< void > MR::serializeObjectTree	(	const Object &	object,
		const std::filesystem::path &	path,
		ProgressCallback	progress,
		FolderCallback	preCompress )

saves object subtree in given scene file (zip/mru)

format specification: children are saved under folder with name of their parent object all objects parameters are saved in one JSON file in the root folder

if preCompress is set, it is called before compression saving is controlled with Object::serializeModel_ and Object::serializeFields_

serializeObjectTree() [2/2]

MRMESH_API Expected< void > MR::serializeObjectTree	(	const Object &	object,
		const std::filesystem::path &	path,
		ProgressCallback	progress = {} )

serializeObjectTreeToGltf()

MRIOEXTRAS_API Expected< void > MR::serializeObjectTreeToGltf	(	const Object &	root,
		const std::filesystem::path &	file,
		ProgressCallback	callback = {} )

SetBitIteratorT< BitSet >()

MR::SetBitIteratorT< BitSet >	(	FaceSetBitIterator	,
		SetBitIteratorT< FaceBitSet >	)

SetBitIteratorT< VertBitSet >()

MR::SetBitIteratorT< VertBitSet >	(	EdgeSetBitIterator	,
		SetBitIteratorT< EdgeBitSet >	)

SetClipboardText()

MRVIEWER_API Expected< void > MR::SetClipboardText

(

const std::string &

text

)

SetCurrentThreadName()

MRMESH_API void MR::SetCurrentThreadName

(

const char *

name

)

setDefaultUnitParams()

template<UnitEnum E>

void MR::setDefaultUnitParams

(

const UnitToStringParams< E > &

newParams

)

setNewHandlerIfNeeded()

MRMESH_API void MR::setNewHandlerIfNeeded

(

)

setTextureFilterType()

MRVIEWER_API void MR::setTextureFilterType	(	FilterType	filterType,
		GLenum	type = GL_TEXTURE_2D )

setTextureWrapType()

MRVIEWER_API void MR::setTextureWrapType	(	WrapType	wrapType,
		GLenum	type = GL_TEXTURE_2D )

setupLoggerByDefault()

MRMESH_API void MR::setupLoggerByDefault

(

)

Setups logger: 1) makes stdout sink 2) makes file sink (MRLog.txt) 3) redirect std streams to logger 4) print stacktrace on crash (not in wasm) log level - trace

sgn()

template<typename T >

int MR::sgn ( T x )

inlineconstexprnoexcept

sharpenMarchingCubesMesh()

MRMESH_API void MR::sharpenMarchingCubesMesh	(	const MeshPart &	ref,
		Mesh &	vox,
		Vector< VoxelId, FaceId > &	face2voxel,
		const SharpenMarchingCubesMeshSettings &	settings )

adjust the mesh

Parameters

vox	produced by marching cubes method (NOT dual marching cubes) by 1) correcting positions of all vertices to given offset relative to
ref	mesh (if correctOldVertPos == true); 2) introducing new vertices in the voxels where the normals change abruptly.
face2voxel	mapping from Face Id to Voxel Id where it is located

sharpOffsetMesh()

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

nodiscard

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

showError()

void MR::showError ( const std::string & error )

inline

showModal()

MRVIEWER_API void MR::showModal	(	const std::string &	error,
		NotificationType	type )

Check if menu is available and if it is, shows modal window.

shrink() [1/2]

MRMESH_API void MR::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

shrink() [2/2]

MRMESH_API void MR::shrink	(	const MeshTopology &	topology,
		VertBitSet &	region,
		int	hops = 1 )

removes from the region all vertices within given number of hops (stars) from the initial region boundary

shrinkFaces()

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

nodiscard

returns given region without all faces sharing an edge with not-region face;

Parameters

stopEdges

- neighborhood via this edges will be ignored

simpleVolumeToDenseGrid()

MRVOXELS_API FloatGrid MR::simpleVolumeToDenseGrid	(	const SimpleVolume &	simpleVolume,
		float	background = 0.0f,
		ProgressCallback	cb = {} )

simpleVolumeToVdbVolume()

MRVOXELS_API VdbVolume MR::simpleVolumeToVdbVolume	(	const SimpleVolumeMinMax &	simpleVolume,
		ProgressCallback	cb = {} )

size()

ImVec2 MR::size ( const ViewportRectangle & rect )

inline

smoothSelection()

MRVOXELS_API FaceBitSet MR::smoothSelection	(	Mesh &	mesh,
		const FaceBitSet &	region,
		float	expandOffset,
		float	shrinkOffset )

sortScanFilesByName()

MRVOXELS_API void MR::sortScanFilesByName

(

std::vector< std::filesystem::path > &

scans

)

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

sortScansByOrder()

MRVOXELS_API void MR::sortScansByOrder	(	std::vector< std::filesystem::path > &	scans,
		std::vector< SliceInfo > &	zOrder )

Sort scan files in given vector by given slice information.

split()

template<typename F >

bool MR::split	(	std::string_view	str,
		std::string_view	sep,
		F &&	func )

splitByLines()

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

sqr()

template<typename T >

T MR::sqr ( T x )

inlineconstexprnoexcept

stitchContours()

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

given two contours: 1) of equal size; 2) all edges of c0 have no left faces; 3) all edges of c1 have no right faces; merge the surface along corresponding edges of two contours, and deletes all vertices and edges from c1

stringOperationCanceled()

MR_BIND_IGNORE std::string MR::stringOperationCanceled ( )

inline

Common operation canceled line for all.

subdivideLoneContours()

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

subdividePolylineWithPlane()

MRMESH_API EdgeBitSet MR::subdividePolylineWithPlane	(	Polyline3 &	polyline,
		const Plane3f &	plane,
		std::function< void(EdgeId, EdgeId, float)>	onEdgeSplitCallback = nullptr )

This function splits edges intersected by the plane

Returns

New edges with origin on the plane and oriented to the positive direction

Parameters

polyline	Input polyline that will be cut by the plane
plane	Input plane to cut polyline with
onEdgeSplitCallback	is invoked each time when an edge is split. Receives edge ID before split, edge ID after split, and weight of the origin vertex

subdivideWithPlane()

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

subdivides all triangles intersected by given plane, leaving smaller triangles that only touch the plane;

Returns

all triangles on the positive side of the plane

Parameters

new2Old	receive mapping from newly appeared triangle to its original triangle (part to full)
eps	if existing vertex is within eps distance from the plane, then move the vertex not introducing new ones
onEdgeSplitCallback	is invoked each time when an edge is split. Receives edge ID before split, edge ID after split, and weight of the origin vertex

subprogress() [1/3]

template<typename F >

ProgressCallback MR::subprogress ( ProgressCallback cb, F && f )

inline

returns a callback that maps the value with given function

Parameters

f	before calling
cb	(which can be empty)

subprogress() [2/3]

ProgressCallback MR::subprogress ( ProgressCallback cb, float from, float to )

inline

returns a callback that maps [0,1] linearly into [from,to] in the call to

Parameters

cb	(which can be empty)

subprogress() [3/3]

ProgressCallback MR::subprogress ( ProgressCallback cb, size_t index, size_t count )

inline

returns a callback that maps [0,1] linearly into [(index+0)/count,(index+1)/count] in the call to

Parameters

cb	(which can be empty)

suggestVoxelSize()

MRVOXELS_API float MR::suggestVoxelSize ( const MeshPart & mp, float approxNumVoxels )

nodiscard

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

SymMatrix3< bool >()

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

SymMatrix3< long long >()

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

teethMaskToDirectionVolume()

MRVOXELS_API Expected< std::array< SimpleVolumeMinMax, 3 > > MR::teethMaskToDirectionVolume	(	const VdbVolume &	volume,
		const std::vector< int > &	additionalIds = {} )

A shortcut for TeethMaskToDirectionVolumeConvertor::create and TeethMaskToDirectionVolumeConvertor::convertAll.

terrainTriangulation()

MRMESH_API Expected< Mesh > MR::terrainTriangulation ( std::vector< Vector3f > points, ProgressCallback cb = {} )

nodiscard

thickenMesh()

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

nodiscard

in case of positive offset, returns the mesh consisting of offset mesh merged with inversed original mesh (thickening mode); in case of negative offset, returns the mesh consisting of inversed offset mesh merged with original mesh (hollowing mode); if your input mesh is open then please specify params.signDetectionMode = SignDetectionMode::Unsigned, and you will get open mesh (with several components) on output if your input mesh is closed then please specify another sign detection mode, and you will get closed mesh (with several components) on output;

throwExceptionFromExpected()

template<typename E >

void MR::throwExceptionFromExpected

(

const E &

err

)

toLower()

MRMESH_API std::string MR::toLower ( std::string str )

nodiscard

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

toString() [1/2]

MRVIEWER_API std::string_view MR::toString ( DegreesMode mode )

nodiscard

toString() [2/2]

MRMESH_API std::string_view MR::toString ( DimensionsVisualizePropertyType value )

nodiscard

toVec4()

template<typename T >

Vector4< T > MR::toVec4 ( const ViewportRectangle & rect )

inline

trackLeftBoundaryLoop() [1/2]

EdgeLoop MR::trackLeftBoundaryLoop ( const MeshTopology & topology, const FaceBitSet & region, EdgeId e0 )

inlinenodiscard

trackLeftBoundaryLoop() [2/2]

MRMESH_API EdgeLoop MR::trackLeftBoundaryLoop ( const MeshTopology & topology, EdgeId e0, const FaceBitSet * region = nullptr )

nodiscard

returns closed loop of region boundary starting from given region boundary edge (region faces on the left, and not-region faces or holes on the right); if more than two boundary edges connect in one vertex, then the function makes the most abrupt turn to right

trackRightBoundaryLoop() [1/2]

EdgeLoop MR::trackRightBoundaryLoop ( const MeshTopology & topology, const FaceBitSet & region, EdgeId e0 )

inlinenodiscard

trackRightBoundaryLoop() [2/2]

MRMESH_API EdgeLoop MR::trackRightBoundaryLoop ( const MeshTopology & topology, EdgeId e0, const FaceBitSet * region = nullptr )

nodiscard

returns closed loop of region boundary starting from given region boundary edge (region faces on the right, and not-region faces or holes on the left); if more than two boundary edges connect in one vertex, then the function makes the most abrupt turn to left

trackSection()

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

nodiscard

track section of plane set by start point, direction and surface normal in start point in given direction while given distance or mesh boundary is not reached, or track looped negative distance means moving in opposite direction returns track on surface and end point (same as start if path has looped)

transformNormals()

MRMESH_API const VertNormals & MR::transformNormals	(	const VertNormals &	normals,
		const VertBitSet &	validVerts,
		const Matrix3d *	m,
		VertNormals &	buf )

if (m) is null then just returns (normals); otherwise copies transformed normals in (buf) and returns it

transformPoints()

MRMESH_API const VertCoords & MR::transformPoints	(	const VertCoords &	verts,
		const VertBitSet &	validVerts,
		const AffineXf3d *	xf,
		VertCoords &	buf,
		const VertRenumber *	vertRenumber = nullptr )

if (xf) is null then just returns (verts); otherwise copies transformed points in (buf) and returns it

transformVdbVolume()

MRVOXELS_API VdbVolume MR::transformVdbVolume	(	const VdbVolume &	volume,
		const AffineXf3f &	xf,
		bool	fixBox = false,
		const Box3f &	box = {} )

Transform volume

Parameters

volume	Volume to transform
xf	The transformation
fixBox	If true, and if box is valid and represents the bounding box of the volume, then the result will be shifted so that no data has negative coordinate by any of dimensions

translateToZero()

template<typename GredT >

void MR::translateToZero

(

GredT &

grid

)

triangleWithNormal()

template<typename T >

Triangle3< T > MR::triangleWithNormal ( const Triangle3< T > & t, const Vector3< T > & n )

nodiscard

project given triangle on a plane passing via its centroid and having unit normal (n); if after projection triangle normal turns out to be inversed, then collapses the triangle into degenerate line segment

TriDist()

MRMESH_API float MR::TriDist	(	Vector3f &	p,
		Vector3f &	q,
		const Vector3f	s[3],
		const Vector3f	t[3] )

computes the closest points on two triangles, and returns the squared distance between them.

Parameters

s,t	are the triangles, stored tri[point][dimension].

If the triangles are disjoint, p and q give the closest points of s and t respectively. However, if the triangles overlap, p and q are basically a random pair of points from the triangles, not coincident points on the intersection of the triangles, as might be expected.

trimRight()

MRMESH_API std::string_view MR::trimRight ( std::string_view str )

nodiscard

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

trimWithPlane() [1/3]

MRMESH_API void MR::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

This function cuts mesh with plane, leaving only part of mesh that lay in positive direction of normal

Parameters

mesh	Input mesh that will be cut
plane	Input plane to cut mesh with
outCutContours	optionally return newly appeared hole contours where each edge does not have right face
new2Old	receive mapping from newly appeared triangle to its original triangle (part to full)
eps	if existing vertex is within eps distance from the plane, then move the vertex not introducing new ones
onEdgeSplitCallback	is invoked each time when an edge is split. Receives edge ID before split, edge ID after split, and weight of the origin vertex

trimWithPlane() [2/3]

MRMESH_API void MR::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

This function cuts mesh with plane, leaving only part of mesh that lay in positive direction of normal

Parameters

mesh	Input mesh that will be cut
plane	Input plane to cut mesh with
outCutEdges	optionally return newly appeared hole boundary edges
new2Old	receive mapping from newly appeared triangle to its original triangle (part to full)
eps	if existing vertex is within eps distance from the plane, then move the vertex not introducing new ones
onEdgeSplitCallback	is invoked each time when an edge is split. Receives edge ID before split, edge ID after split, and weight of the origin vertex

trimWithPlane() [3/3]

MRMESH_API void MR::trimWithPlane	(	Mesh &	mesh,
		const TrimWithPlaneParams &	params,
		const TrimOptionalOutput &	optOut = {} )

trim mesh by plane

This function cuts mesh with plane, leaving only part of mesh that lay in positive direction of normal

Parameters

mesh	Input mesh that will be cut
params	stores basic params for trimWithPlane function
optOut	stores optional output params for trimWithPlane function

undirectedEdges()

IteratorRange< UndirectedEdgeIterator > MR::undirectedEdges ( const MeshTopology & topology )

inline

unexpected()

template<class E >

MR_BIND_IGNORE auto MR::unexpected ( E && e )

inline

unexpectedOperationCanceled()

MR_BIND_IGNORE auto MR::unexpectedOperationCanceled ( )

inline

Returns Expected error with stringOperationCanceled()

uniteLocalTriangulations()

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

nodiscard

converts a set of SomeLocalTriangulations containing local triangulations of all points arbitrary distributed among them into one AllLocalTriangulations with records for all points

uniteManyMeshes()

MRMESH_API Expected< Mesh > MR::uniteManyMeshes	(	const std::vector< const Mesh * > &	meshes,
		const UniteManyMeshesParams &	params = {} )

unitsAreEquivalent() [1/2]

template<UnitEnum E>

bool MR::unitsAreEquivalent ( const std::optional< E > & a, const std::optional< E > & b )

nodiscard

unitsAreEquivalent() [2/2]

template<UnitEnum E>

bool MR::unitsAreEquivalent ( E a, E b )

nodiscard

updateGroupPairs()

MRMESH_API void MR::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)

updateIndicator()

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

Compute edge indicator function (1 - smooth edge, 0 - crease edge) by solving large system of linear equations

Parameters

mesh	contains topology information and coordinates for equation weights
normals	per-face normals
beta	0.001 - sharp edges, 0.01 - moderate edges, 0.1 - smooth edges
gamma	the amount of smoothing: 0 - no smoothing, 1 - average smoothing, ... see the article "Mesh Denoising via a Novel Mumford-Shah Framework", equation (20)

updateIndicatorFast()

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

Compute edge indicator function (1 - smooth edge, 0 - crease edge) by approximation without solving the system of linear equations

Parameters

normals	per-face normals
beta	0.001 - sharp edges, 0.01 - moderate edges, 0.1 - smooth edges
gamma	the amount of smoothing: 0 - no smoothing, 1 - average smoothing, ... see the article "Mesh Denoising via a Novel Mumford-Shah Framework", equation (20)

updatePointPairs()

MRMESH_API void MR::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)

valueToImGuiFormatString() [1/2]

template<UnitEnum E, detail::Units::Scalar T>

MRVIEWER_API std::string MR::valueToImGuiFormatString ( T value, const UnitToStringParams< E > & params = getDefaultUnitParams< E >() )

nodiscard

valueToImGuiFormatString() [2/2]

template<detail::Units::Scalar T>

MRVIEWER_API std::string MR::valueToImGuiFormatString ( T value, const VarUnitToStringParams & params )

nodiscard

valueToString() [1/2]

template<UnitEnum E, detail::Units::Scalar T>

MRVIEWER_API std::string MR::valueToString ( T value, const UnitToStringParams< E > & params = getDefaultUnitParams< E >() )

nodiscard

valueToString() [2/2]

template<detail::Units::Scalar T>

MRVIEWER_API std::string MR::valueToString ( T value, const VarUnitToStringParams & params )

nodiscard

vdbVolumeToSimpleVolume()

MRVOXELS_API Expected< SimpleVolumeMinMax > MR::vdbVolumeToSimpleVolume	(	const VdbVolume &	vdbVolume,
		const Box3i &	activeBox = Box3i(),
		ProgressCallback	cb = {} )

vdbVolumeToSimpleVolumeNorm()

MRVOXELS_API Expected< SimpleVolumeMinMax > MR::vdbVolumeToSimpleVolumeNorm	(	const VdbVolume &	vdbVolume,
		const Box3i &	activeBox = Box3i(),
		std::optional< MinMaxf >	sourceScale = {},
		ProgressCallback	cb = {} )

Makes normalized SimpleVolume from VdbVolume Normalisation consist of scaling values linearly from the source scale to the interval [0;1]

Note

Makes copy of data

Parameters

sourceScale

if specified, defines the initial scale of voxels. If not specified, it is estimated as min. and max. values from the voxels

vdbVolumeToSimpleVolumeU16()

MRVOXELS_API Expected< SimpleVolumeMinMaxU16 > MR::vdbVolumeToSimpleVolumeU16	(	const VdbVolume &	vdbVolume,
		const Box3i &	activeBox = Box3i(),
		std::optional< MinMaxf >	sourceScale = {},
		ProgressCallback	cb = {} )

Makes SimpleVolumeU16 from VdbVolume Values are linearly scaled from the source scale to the range corresponding to uint16_t

Note

Makes copy of data

Parameters

sourceScale

if specified, defines the initial scale of voxels. If not specified, it is estimated as min. and max. values from the voxels

Vector3< bool >()

MRMESH_CLASS MR::Vector3< bool >	(	Vector3i	,
		Vector3< int >	)

Vector3< long long >()

MRMESH_CLASS MR::Vector3< long long >	(	Vector3f	,
		Vector3< float >	)

vertexAttributeGradient()

MRMESH_API Vector< Vector3f, VertId > MR::vertexAttributeGradient	(	const Mesh &	mesh,
		const VertScalars &	vertexAttribute )

Calculates gradient for each vertex in mesh, based on vertexAttribute.

verticesGridSampling()

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

performs sampling of mesh vertices; subdivides mesh bounding box on voxels of approximately given size and returns at most one vertex per voxel; returns std::nullopt if it was terminated by the callback

visitScalarType()

template<typename F >

std::invoke_result_t< F, int > MR::visitScalarType	(	F &&	f,
		ScalarType	scalarType,
		const char *	c )

More general template to pass a single value of specified format scalarType to a generic function f.

volumeToMeshByParts()

template<typename Volume >

Expected< Mesh > MR::volumeToMeshByParts	(	const VolumePartBuilder< Volume > &	builder,
		const Vector3i &	dimensions,
		const Vector3f &	voxelSize,
		const VolumeToMeshByPartsSettings &	settings = {},
		const MergeVolumePartSettings &	mergeSettings = {} )

converts a voxel volume into a mesh without full memory loading

See also

mergeVolumePart

Parameters

builder	- functor returning a voxel volume part within the specified range
dimensions	- full voxel volume dimensions
voxelSize	- voxel size used for mesh generation
settings	- additional parameters; see VolumeToMeshByPartsSettings
mergeSettings	- additional parameters for merging function; see MergeVolumePartSettings

Returns

a generated mesh or an error string

voxelFilter()

MRVOXELS_API VdbVolume MR::voxelFilter	(	const VdbVolume &	volume,
		VoxelFilterType	type,
		int	width )

Performs voxels filtering.

Parameters

type	Type of fitler
width	Width of the filtering window, must be an odd number greater or equal to 1.

voxelizeAndComputeVolume()

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

voxelsApplyTransform()

MRVOXELS_API void MR::voxelsApplyTransform	(	ObjectVoxels &	obj,
		const AffineXf3f &	xf,
		bool	fixBox )

Same as above but for the SceneObject

Returns

true, if fixBox is true and the box was "fixed" (see parameter fixBox of transformVdbVolume)

writeByBlocks()

MRMESH_API bool MR::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

if progress callback is not set, write all data by one block

Returns

false if process was canceled (callback is set and return false )

writeRawTiff()

MRMESH_API Expected< void > MR::writeRawTiff	(	const uint8_t *	bytes,
		const std::filesystem::path &	path,
		const BaseTiffParameters &	params )

zlibCompressStream()

MRIOEXTRAS_API Expected< void > MR::zlibCompressStream	(	std::istream &	in,
		std::ostream &	out,
		int	level = -1 )

compress the input data using the Deflate algorithm

Parameters

in	- input data stream
out	- output data stream
level	- compression level (0 - no compression, 1 - the fastest but the most inefficient compression, 9 - the most efficient but the slowest compression)

Returns

nothing or error string

zlibDecompressStream()

MRIOEXTRAS_API Expected< void > MR::zlibDecompressStream	(	std::istream &	in,
		std::ostream &	out )

/brief decompress the input data compressed using the Deflate algorithm

Parameters

in	- input data stream
out	- output data stream

Returns

nothing or error string

Variable Documentation

AABBTree

class MRMESH_CLASS MR::AABBTree

AABBTreeObjects

class MRMESH_CLASS MR::AABBTreeObjects

AABBTreePoints

class MRMESH_CLASS MR::AABBTreePoints

AABBTreePolyline

MR::AABBTreePolyline

AABBTreePolyline2

MR::AABBTreePolyline2

AffineXf

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double > MR::AffineXf

AffineXf2f

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > SymMatrix3< double > MR::AffineXf2f

AllFilter

MRMESH_API const IOFilters MR::AllFilter

extern

BestFitParabola

MR::BestFitParabola

BestFitParabolaf

MR::BestFitParabolaf

BitSet

class MRMESH_CLASS MR::BitSet

Box

MR::Box

Box1i

MR::Box1i

cBigFontSize

int MR::cBigFontSize = 15

constexpr

cBigIconSize

float MR::cBigIconSize = 20.0f

constexpr

cButtonPadding

float MR::cButtonPadding = 8.0f

constexpr

cCheckboxPadding

float MR::cCheckboxPadding = 2.0f

constexpr

cDefaultFontSize

int MR::cDefaultFontSize = 13

constexpr

cDefaultInnerSpacing

float MR::cDefaultInnerSpacing = 8.0f

constexpr

cDefaultItemSpacing

float MR::cDefaultItemSpacing = 8.0f

constexpr

cDefaultWindowPaddingX

float MR::cDefaultWindowPaddingX = 8.0f

constexpr

cDefaultWindowPaddingY

float MR::cDefaultWindowPaddingY = 12.0f

constexpr

cGradientButtonFramePadding

float MR::cGradientButtonFramePadding = 7.5f

constexpr

ChangeSceneAction

class MRMESH_CLASS MR::ChangeSceneAction

cHeaderQuickAccessFrameRounding

float MR::cHeaderQuickAccessFrameRounding = 3.0f

constexpr

cHeaderQuickAccessFrameSize

float MR::cHeaderQuickAccessFrameSize = 24.0f

constexpr

cHeaderQuickAccessIconSize

float MR::cHeaderQuickAccessIconSize = 14.0f

constexpr

cHeaderQuickAccessXSpacing

float MR::cHeaderQuickAccessXSpacing = 12.0f

constexpr

cHeadlineFontSize

int MR::cHeadlineFontSize = 20

constexpr

cInputPadding

float MR::cInputPadding = 9.0f

constexpr

cItemInfoIndent

float MR::cItemInfoIndent = 16.0f

constexpr

CloudPartMapping

struct MRMESH_CLASS MR::CloudPartMapping

cMiddleIconSize

float MR::cMiddleIconSize = 15.0f

constexpr

cModalButtonWidth

float MR::cModalButtonWidth = 104.0f

constexpr

cModalWindowPaddingX

float MR::cModalWindowPaddingX = 28.0f

constexpr

cModalWindowPaddingY

float MR::cModalWindowPaddingY = 20.0f

constexpr

cModalWindowWidth

float MR::cModalWindowWidth = 368.0f

constexpr

Cone3

MR::Cone3

Cone3f

MR::Cone3f

cQuickAccessBarHeight

float MR::cQuickAccessBarHeight = 40.0f

constexpr

cQuietNan

float MR::cQuietNan = std::numeric_limits<float>::quiet_NaN()

constexpr

cQuietNanBits

int MR::cQuietNanBits = std::bit_cast< int >( cQuietNan )

constexpr

cRadioButtonSize

float MR::cRadioButtonSize = 20.0f

constexpr

cRadioInnerSpacingX

const float MR::cRadioInnerSpacingX = 12.f

cRibbonButtonWindowPaddingX

float MR::cRibbonButtonWindowPaddingX = 6.0f

constexpr

cRibbonButtonWindowPaddingY

float MR::cRibbonButtonWindowPaddingY = 4.0f

constexpr

cRibbonItemInterval

float MR::cRibbonItemInterval = 4.0f

constexpr

cRibbonItemMinWidth

float MR::cRibbonItemMinWidth = 86.0f

constexpr

cScrollBarSize

float MR::cScrollBarSize = 10.0f

constexpr

cSeparateBlocksSpacing

float MR::cSeparateBlocksSpacing = 12.0f

constexpr

cSeparatorIndentMultiplier

float MR::cSeparatorIndentMultiplier = 0.67f

constexpr

cSmallFontSize

int MR::cSmallFontSize = 11

constexpr

cSmallIconSize

float MR::cSmallIconSize = 10.0f

constexpr

cSmallItemDropSizeModifier

float MR::cSmallItemDropSizeModifier = 0.5f

constexpr

cTabFrameRounding

float MR::cTabFrameRounding = 5.0f

constexpr

cTabHeight

float MR::cTabHeight = 28.0f

constexpr

cTabLabelMinPadding

float MR::cTabLabelMinPadding = 12.0f

constexpr

cTabMinimumWidth

float MR::cTabMinimumWidth = 68.0f

constexpr

cTabsInterval

float MR::cTabsInterval = 8.0f

constexpr

cTabYOffset

float MR::cTabYOffset = 4.0f

constexpr

cTopPanelAditionalButtonSize

float MR::cTopPanelAditionalButtonSize = cTabHeight - cTabYOffset

constexpr

cTopPanelScrollBtnSize

float MR::cTopPanelScrollBtnSize = 20.0f

constexpr

cTopPanelScrollStep

float MR::cTopPanelScrollStep = 50.0f

constexpr

Cylinder3

MR::Cylinder3

Cylinder3f

MR::Cylinder3f

DemoPluginInstance

MRVIEWER_API DemoPlugin MR::DemoPluginInstance

extern

dependent_false

template<typename... >

bool MR::dependent_false = false

inlineconstexpr

Dipole

struct MRMESH_CLASS MR::Dipole

EdgeTag

class MRMESH_CLASS MR::EdgeTag

Eq

MR::Eq

Initial value:

= phmap::priv::hash_default_eq<T>>
using HashSet = phmap::flat_hash_set<T, Hash, Eq>

FaceTag

class MRMESH_CLASS MR::FaceTag

GraphEdgeTag

class MRMESH_CLASS MR::GraphEdgeTag

GraphVertTag

class MRMESH_CLASS MR::GraphVertTag

Hash

MR::Hash = phmap::priv::hash_default_hash<T>

I

MR::I = size_t> class MRMESH_CLASS Buffer

Matrix2

MRMESH_CLASS Vector3< double > MR::Matrix2

Matrix2b

MRMESH_CLASS Vector3< double > MR::Matrix2b

Matrix4

MRMESH_CLASS Vector3< double > Matrix2< double > MR::Matrix4

Matrix4b

MRMESH_CLASS Vector3< double > Matrix2< double > MR::Matrix4b

Mesh

struct MRMESH_CLASS MR::Mesh

MeshOrPoints

class MRMESH_CLASS MR::MeshOrPoints

MeshTopology

class MRMESH_CLASS MR::MeshTopology

NoDefInit

template<typename T >

struct MRMESH_CLASS MR::NoDefInit

NodeTag

class MRMESH_CLASS MR::NodeTag

noInit

NoInit MR::noInit

inlineconstexpr

ObjTag

class MRMESH_CLASS MR::ObjTag

PartMapping

struct MRMESH_CLASS MR::PartMapping

PixelTag

class MRMESH_CLASS MR::PixelTag

PointCloud

struct MRMESH_CLASS MR::PointCloud

Polyline2ProjectionWithOffsetResult

MR::Polyline2ProjectionWithOffsetResult

PolylineProjectionWithOffsetResult

MR::PolylineProjectionWithOffsetResult

RegionTag

class MRMESH_CLASS MR::RegionTag

RigidScaleXf3

MR::RigidScaleXf3

RigidScaleXf3f

MR::RigidScaleXf3f

SetBitIterator

MR::SetBitIterator

SetBitIteratorT

MR::SetBitIteratorT

SymMatrix3

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > MR::SymMatrix3

SymMatrix3b

MRMESH_CLASS Vector3< double > Matrix2< double > Matrix4< double > MR::SymMatrix3b

TextureTag

class MRMESH_CLASS MR::TextureTag

UndirectedEdgeTag

class MRMESH_CLASS MR::UndirectedEdgeTag

Vector3

MRMESH_CLASS MR::Vector3

Vector3b

MRMESH_CLASS MR::Vector3b

VertTag

class MRMESH_CLASS MR::VertTag

VoxelTag

class MRMESH_CLASS MR::VoxelTag