@@ -13,8 +12,8 @@
The first part of this video shows MeshLib Python Installation process on Windows
-When `pip` is done, confirm the result with \ref PythonSetupVerify "Verify the installation" — one command, with the output to expect.
-If a step fails, see \ref PythonSetupTroubleshooting "Troubleshooting" at the end of the Installation Process section.
+When `pip` is done, confirm the result with [Verify the installation](\ref PythonSetupVerify) — one command, with the output to expect.
+If a step fails, see [Troubleshooting](\ref PythonSetupTroubleshooting) at the end of the Installation Process section.
## Prerequisites {#PythonSetupPrerequisites}
Before installing MeshLib SDK for Python, ensure you have the following:
@@ -25,12 +24,12 @@ Python 3.8 (end-of-life since October 2024) and 3.9 (end-of-life since October 2
no longer receive security updates, and remain listed only because the published
wheels still install on them.
- - On \b Windows: 3.8 to 3.14 on x64, and 3.11 to 3.14 on ARM64. There is no
+ - On **Windows:** 3.8 to 3.14 on x64, and 3.11 to 3.14 on ARM64. There is no
32-bit wheel. ARM64 starts at 3.11 because python.org publishes no earlier
win-arm64 installer; on ARM64 with an older Python, use the x64 build instead.
- - On \b macOS: 3.8 to 3.14, on macOS 12 or newer. Both arm64 (Apple Silicon)
+ - On **macOS:** 3.8 to 3.14, on macOS 12 or newer. Both arm64 (Apple Silicon)
and x86_64 (Intel) are supported.
- - On \b Linux: 3.8 to 3.14 for distributions
+ - On **Linux:** 3.8 to 3.14 for distributions
with glibc 2.28 or newer (manylinux_2_28) — e.g. Ubuntu 20.04+, Debian 10+,
RHEL/Rocky/AlmaLinux 8+, Fedora 29+. Both x86_64 and aarch64 are supported.
@@ -51,39 +50,39 @@ and PyCharm offer completion and signature help for the MeshLib API with no extr
## Installation Process {#PythonSetupInstall}
MeshLib is available on [PyPI](https://pypi.org/project/meshlib/) for Windows, macOS, and Linux:
-\code{.sh}
+```sh
pip install meshlib
-\endcode
+```
It installs two packages: `meshlib-core` — the headless core with `mrmeshpy`, `mrmeshnumpy`
and `mrcudapy` — and the `meshlib` wheel on top of it, adding the interactive viewer
(`mrviewerpy`) with its UI resources. `numpy` (>= 1.19) is the only external dependency.
-On \b Windows that command works as written. A virtual environment is still worth using once you
+On **Windows** that command works as written. A virtual environment is still worth using once you
have more than one project, so their dependencies cannot collide:
-\code{.bat}
+```bat
py -m venv .venv
.venv\Scripts\activate
pip install meshlib
-\endcode
+```
-On \b Linux, and on \b macOS with Homebrew Python, the plain command is refused before it
+On **Linux**, and on **macOS** with Homebrew Python, the plain command is refused before it
downloads anything — `error: externally-managed-environment` — because pip will not install into
an interpreter the system package manager owns (PEP 668); Apple's Command Line Tools Python
instead accepts it quietly into a per-user directory you did not choose. There, install into a
virtual environment:
-\code{.sh}
+```sh
python3 -m venv .venv
source .venv/bin/activate
pip install meshlib
-\endcode
+```
### Headless installation {#PythonSetupHeadless}
On servers, in docker images, and in CI — anywhere the interactive viewer is never opened —
install just the core:
-\code{.sh}
+```sh
pip install meshlib-core
-\endcode
+```
The download is about 30% smaller and provides everything except `meshlib.mrviewerpy`; every other
import (`from meshlib import mrmeshpy`, `mrmeshnumpy`, `mrcudapy`) works exactly as with the full
package. Installing `meshlib` later adds the viewer on top, and `pip uninstall meshlib` removes
@@ -92,43 +91,43 @@ requires exactly `meshlib-core` of the same version.
### Verify the installation {#PythonSetupVerify}
`pip install` reporting success is not the same as a working install: the wheel is tens of megabytes of prebuilt native code, and it can install cleanly and still fail to load. This one command covers the whole chain — import the package, load the native module, run a real geometry call:
-\code{.sh}
+```sh
python -c "from meshlib import mrmeshpy as mm; m = mm.makeCube(); print(mm.__file__); print(m.topology.numValidVerts(), 'verts', m.topology.numValidFaces(), 'faces')"
-\endcode
+```
Expected output — the path is yours and ends in `mrmeshpy.pyd` on Windows, while the two counts are fixed:
-\code{.txt}
+```unparsed
/path/to/.venv/lib/python3.12/site-packages/meshlib/mrmeshpy.so
8 verts 12 faces
-\endcode
+```
-If it prints those two lines and exits `0`, the installation is working. Anything else — a traceback, a loader error, no output — means it is not: see \ref PythonSetupTroubleshooting "Troubleshooting" below. The printed path is worth a glance too, since it names the environment that actually received the package.
+If it prints those two lines and exits `0`, the installation is working. Anything else — a traceback, a loader error, no output — means it is not: see [Troubleshooting](\ref PythonSetupTroubleshooting) below. The printed path is worth a glance too, since it names the environment that actually received the package.
### Your first script
With the install confirmed, the same call is the starting point of a real script — this one also writes the cube to a file:
-\code{.py}
+```py
from meshlib import mrmeshpy as mm
mesh = mm.makeCube()
print(mesh.topology.numValidVerts(), "vertices", mesh.topology.numValidFaces(), "faces")
mm.saveMesh(mesh, "cube.stl")
-\endcode
+```
Output:
-\code{.txt}
+```unparsed
8 vertices 12 faces
-\endcode
+```
### Troubleshooting {#PythonSetupTroubleshooting}
-The failures new installations actually hit, with the message each one produces. One of them leaves `pip install` reporting success, which is what \ref PythonSetupVerify "Verify the installation" is for.
+The failures new installations actually hit, with the message each one produces. One of them leaves `pip install` reporting success, which is what [Verify the installation](\ref PythonSetupVerify) is for.
| Path | Symptom | Cause | Fix |
|------|---------|-------|-----|
-| Linux distribution Python, Homebrew Python on macOS | `pip install meshlib` stops before downloading anything with `error: externally-managed-environment`, then `× This environment is externally managed`. | Not a MeshLib problem: pip 23.0 and newer refuse to install any package into an interpreter the OS package manager owns (PEP 668, marked by a `EXTERNALLY-MANAGED` file next to the standard library). | Install into a virtual environment, as \ref PythonSetupInstall "Installation Process" above shows. `pip install --break-system-packages meshlib` also installs, but into the system interpreter — prefer the virtual environment. |
-| Any | `ERROR: Could not find a version that satisfies the requirement meshlib (from versions: none)`, then `ERROR: No matching distribution found for meshlib`. | No published wheel matches this interpreter: the Python version is outside the range in \ref PythonSetupPrerequisites "Prerequisites" above, the interpreter is 32-bit, or the platform has no wheel at all — on ARM64 Windows the wheels start at Python 3.11, so an older interpreter there needs the x64 build. | Check what pip is matching against — `python -c "import sys, sysconfig; print(sys.version, sysconfig.get_platform())"` — and install a Python listed in \ref PythonSetupPrerequisites "Prerequisites". |
-| Any | Install and import both succeed, but a documented function is missing — `AttributeError: module 'meshlib.mrmeshpy' has no attribute ...` — or `pip show meshlib` prints a version well behind the latest. | The package requires Python 3.8 or newer overall, but each release's wheel tags are narrower than that and change over time. When no wheel of the newest release matches your interpreter, pip does not fail: it silently installs the newest *older* release that does. | `pip show meshlib`, and compare with the version on the [PyPI page](https://pypi.org/project/meshlib/). If it is behind, move to a Python version listed in \ref PythonSetupPrerequisites "Prerequisites" and reinstall with `pip install --upgrade --force-reinstall meshlib`. |
+| Linux distribution Python, Homebrew Python on macOS | `pip install meshlib` stops before downloading anything with `error: externally-managed-environment`, then `× This environment is externally managed`. | Not a MeshLib problem: pip 23.0 and newer refuse to install any package into an interpreter the OS package manager owns (PEP 668, marked by a `EXTERNALLY-MANAGED` file next to the standard library). | Install into a virtual environment, as [Installation Process](\ref PythonSetupInstall) above shows. `pip install --break-system-packages meshlib` also installs, but into the system interpreter — prefer the virtual environment. |
+| Any | `ERROR: Could not find a version that satisfies the requirement meshlib (from versions: none)`, then `ERROR: No matching distribution found for meshlib`. | No published wheel matches this interpreter: the Python version is outside the range in [Prerequisites](\ref PythonSetupPrerequisites) above, the interpreter is 32-bit, or the platform has no wheel at all — on ARM64 Windows the wheels start at Python 3.11, so an older interpreter there needs the x64 build. | Check what pip is matching against — `python -c "import sys, sysconfig; print(sys.version, sysconfig.get_platform())"` — and install a Python listed in [Prerequisites](\ref PythonSetupPrerequisites). |
+| Any | Install and import both succeed, but a documented function is missing — ``AttributeError: module 'meshlib.mrmeshpy' has no attribute ...`` — or `pip show meshlib` prints a version well behind the latest. | The package requires Python 3.8 or newer overall, but each release's wheel tags are narrower than that and change over time. When no wheel of the newest release matches your interpreter, pip does not fail: it silently installs the newest *older* release that does. | `pip show meshlib`, and compare with the version on the [PyPI page](https://pypi.org/project/meshlib/). If it is behind, move to a Python version listed in [Prerequisites](\ref PythonSetupPrerequisites) and reinstall with `pip install --upgrade --force-reinstall meshlib`. |
Anything not listed here: please open an issue at [MeshLib Issues](https://github.com/MeshInspector/MeshLib/issues), quoting the full `pip` output or traceback.
@@ -145,8 +144,9 @@ The `meshlib` package ships four importable modules:
Import them from the package, for example `from meshlib import mrmeshpy`.
-\note `mrcudapy` imports on any machine, including one without a GPU, but its routines
-need an NVIDIA GPU with a working CUDA driver at runtime.
+> [!NOTE]
+> `mrcudapy` imports on any machine, including one without a GPU, but its routines
+> need an NVIDIA GPU with a working CUDA driver at runtime.
### Predefined Functions and Example Scripts
MeshLib provides a set of example scripts that are available [here](\ref Examples).
@@ -162,5 +162,3 @@ After installing MeshLib, a great way to start exploring its capabilities is thr
- **On macOS**, the interactive Viewer is not supported yet. The `meshlib.mrviewerpy` module installs and imports, but `mrviewerpy.launch()` raises `RuntimeError: MeshLib Viewer is not supported on macOS yet` — and in releases before 3.1.3.566 it terminated the Python process outright, with no exception — so the [**Viewer example**](\ref ExampleViewer) will not run. Start with the [**mesh loading and saving example**](\ref ExampleMeshLoadSave) instead, which demonstrates how to work with mesh files programmatically.
These examples are a great entry point for integrating MeshLib into your workflow, regardless of your operating system.
-
-*/
\ No newline at end of file
diff --git a/doxygen/general_pages/Spaces.dox b/doxygen/general_pages/Spaces.dox
deleted file mode 100644
index 0a831f42f4c0..000000000000
--- a/doxygen/general_pages/Spaces.dox
+++ /dev/null
@@ -1,9 +0,0 @@
-namespace MR {
-
-/** \page SpacesHelp Spaces and Transformations
-
-\image html transformationsAndSpaces.png
-
-*/
-
-}
\ No newline at end of file
diff --git a/doxygen/general_pages/Spaces.md b/doxygen/general_pages/Spaces.md
new file mode 100644
index 000000000000..c50c80f44520
--- /dev/null
+++ b/doxygen/general_pages/Spaces.md
@@ -0,0 +1,3 @@
+# Spaces and Transformations {#SpacesHelp}
+
+
diff --git a/doxygen/general_pages/StatePluginsHelp.dox b/doxygen/general_pages/StatePluginsHelp.md
similarity index 64%
rename from doxygen/general_pages/StatePluginsHelp.dox
rename to doxygen/general_pages/StatePluginsHelp.md
index c703c4dcf49a..8a87b68872ae 100644
--- a/doxygen/general_pages/StatePluginsHelp.dox
+++ b/doxygen/general_pages/StatePluginsHelp.md
@@ -1,40 +1,37 @@
-namespace MR {
-
-/** \page StatePluginsHelp State Plugins Overview
+# State Plugins Overview {#StatePluginsHelp}
## Base Functions
-\b State \b plugins is simple objects to work with MeshLib scene and/or objects. It is one of possible inheritance of \ref RibbonMenuItem
+**State plugins** is simple objects to work with MeshLib scene and/or objects. It is one of possible inheritance of \ref MR::RibbonMenuItem
It has base functions:
-\b Available \b function - \ref ISceneStateCheck interface function that block plugin in UI
+**Available function** - \ref MR::ISceneStateCheck interface function that block plugin in UI
-\parblock
-\note This fuction can be inherited from some helper classes \ref SceneStateExactCheck \ref SceneStateAtLeastCheck \ref SceneStateAtMostCheck \ref SceneStateOrCheck \ref SceneStateAndCheck
-\endparblock
+> [!NOTE]
+> This fuction can be inherited from some helper classes \ref MR::SceneStateExactCheck \ref MR::SceneStateAtLeastCheck \ref MR::SceneStateAtMostCheck \ref MR::SceneStateOrCheck \ref MR::SceneStateAndCheck
-\code
+```cpp
// return empty string if all requirements are satisfied, otherwise return first unsatisfied requirement
virtual std::string isAvailable( const std::vector
>& ) const { return ""; }
-\endcode
-\b On \b Enable \b function - will be called if user enables plugin (only possible if `isAvailable` has returned true), if \c onEnable_ function returns false plugin will not be enabled (useful for some expensive checks, not to do them in each frame \c available function)
-\code
+```
+**On Enable function** - will be called if user enables plugin (only possible if `isAvailable` has returned true), if `onEnable_` function returns false plugin will not be enabled (useful for some expensive checks, not to do them in each frame `available` function)
+```cpp
MRVIEWER_API virtual bool onEnable_();
-\endcode
-\b On \b Disable \b function - will be called if user disable plugin, it is necessary to clear all plugin data
-\code
+```
+**On Disable function** - will be called if user disable plugin, it is necessary to clear all plugin data
+```cpp
MRVIEWER_API virtual bool onDisable_();
-\endcode
-\b Draw \b Dialog \b function - this function is called in each frame, only if plugin is enabled (will not be called after \c onDisable_ function). It is necessary to show plugin custom UI.
-\code
+```
+**Draw Dialog function** - this function is called in each frame, only if plugin is enabled (will not be called after `onDisable_` function). It is necessary to show plugin custom UI.
+```cpp
MRVIEWER_API virtual void drawDialog( ImGuiContext* ctx );
-\endcode
+```
## How to make your first plugin
-To create you plugin you need to inherit class from MR::StatePlugin or MR::StateListenerPlugin (in case you need to get some events)\n
+To create you plugin you need to inherit class from MR::StatePlugin or MR::StateListenerPlugin (in case you need to get some events)
Example:
-\code
+```cpp
class MyOwnPlugin : public MR::StatePlugin
{
public:
@@ -79,25 +76,21 @@ private:
return true;
}
}
-\endcode
+```
Register your plugin with
-\code
+```cpp
MR_REGISTER_RIBBON_ITEM( MyOwnPlugin )
-\endcode
+```
To show this item on Ribbon menu, it should be present in MenuSchema.ui.json file (special page about these files are coming soon)
-\n
-\ref StateListenerPlugin is more simple way to make plugin listen to some events:
-\code
+
+\ref MR::StateListenerPlugin is more simple way to make plugin listen to some events:
+```cpp
// This plugin will listen to mouse move and mouse down, also isAvailable function will be imlemented with SceneStateExactCheck
class MyListenerPlugin : public StateListenerPlugin, public SceneStateExactCheck<1, ObjectMesh>
-\endcode
+```
Find more:
-\ref RibbonMenuItem
-\ref StateBasePlugin
-\ref StateListenerPlugin
-
-*/
-
-}
+\ref MR::RibbonMenuItem
+\ref MR::StateBasePlugin
+\ref MR::StateListenerPlugin
diff --git a/doxygen/general_pages/SupportGeneratorTutorial.dox b/doxygen/general_pages/SupportGeneratorTutorial.md
similarity index 91%
rename from doxygen/general_pages/SupportGeneratorTutorial.dox
rename to doxygen/general_pages/SupportGeneratorTutorial.md
index 12e634631123..6b79435a1003 100644
--- a/doxygen/general_pages/SupportGeneratorTutorial.dox
+++ b/doxygen/general_pages/SupportGeneratorTutorial.md
@@ -1,5 +1,4 @@
-/**
-\page SupportGeneratorTutorial Building a Support Generator Plugin Using MeshLib C++ on Windows
+# Building a Support Generator Plugin Using MeshLib C++ on Windows {#SupportGeneratorTutorial}
\htmlonly
@@ -9,7 +8,7 @@
### Overview
-This tutorial demonstrates how to create a practical support generator for 3D printing using the \b MeshLib \b SDK.
+This tutorial demonstrates how to create a practical support generator for 3D printing using the **MeshLib SDK**.
You will learn how to connect the dialog UI, handle user input, apply geometric algorithms (including mesh booleans), and render the result in one coherent workflow inside the MeshLib Viewer.
## Prerequisites
@@ -37,5 +36,3 @@ https://meshlib.io/building_support_generator
By the end of this tutorial, you will understand how to combine user interaction, geometry processing, and rendering into one cohesive workflow using the MeshLib SDK.
This foundation enables development of more advanced 3D tools and plugins for MeshLib and MeshInspector.
-
-*/
\ No newline at end of file
diff --git a/doxygen/general_pages/SwitchingFromOtherLibraries.dox b/doxygen/general_pages/SwitchingFromOtherLibraries.md
similarity index 94%
rename from doxygen/general_pages/SwitchingFromOtherLibraries.dox
rename to doxygen/general_pages/SwitchingFromOtherLibraries.md
index f08c4e17ad7a..ef0300955522 100644
--- a/doxygen/general_pages/SwitchingFromOtherLibraries.dox
+++ b/doxygen/general_pages/SwitchingFromOtherLibraries.md
@@ -1,8 +1,6 @@
-/**
+# Switching from Other Libraries to MeshLib {#SwitchingFromOtherLibraries}
-\page SwitchingFromOtherLibraries Switching from Other Libraries to MeshLib
-
-\tableofcontents
+[TOC]
MeshLib is a C++/Python geometry library focused on robust boolean operations, offsets, voxel-based reconstruction, decimation and remeshing.
If you already work with CGAL, libigl, Open3D, PCL or VTK, the pairs below show the equivalent MeshLib code for the operations users most often port over.
@@ -18,7 +16,7 @@ Every C++ snippet has a one-to-one equivalent in our Python bindings.
## Boolean union of two triangle meshes
CGAL:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -31,10 +29,10 @@ PMP::IO::read_polygon_mesh("a.off", a);
PMP::IO::read_polygon_mesh("b.off", b);
PMP::corefine_and_compute_union(a, b, out);
CGAL::IO::write_polygon_mesh("out.off", out);
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -43,12 +41,12 @@ auto a = MR::MeshLoad::fromAnySupportedFormat("a.off").value();
auto b = MR::MeshLoad::fromAnySupportedFormat("b.off").value();
auto res = MR::boolean(a, b, MR::BooleanOperation::Union);
MR::MeshSave::toAnySupportedFormat(res.mesh, "out.off");
-\endcode
+```
## Connected components of a mesh
CGAL:
-\code{.cpp}
+```cpp
#include
namespace PMP = CGAL::Polygon_mesh_processing;
using face_descriptor = boost::graph_traits::face_descriptor;
@@ -56,22 +54,22 @@ using face_descriptor = boost::graph_traits::face_descriptor;
auto fccmap = mesh.add_property_map("f:CC").first;
std::size_t n = PMP::connected_components(mesh, fccmap);
// fccmap[f] = component id
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
auto [labels, n] = MR::MeshComponents::getAllComponentsMap(mesh);
// labels[face] = component id
-\endcode
+```
# libigl
## Decimate a mesh to half its faces
libigl:
-\code{.cpp}
+```cpp
#include
#include
@@ -80,10 +78,10 @@ Eigen::MatrixXi F, G;
Eigen::VectorXi J, I;
igl::read_triangle_mesh("in.obj", V, F);
igl::decimate(V, F, F.rows() / 2, U, G, J, I);
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -92,35 +90,35 @@ auto mesh = MR::MeshLoad::fromAnySupportedFormat("in.obj").value();
MR::DecimateSettings s;
s.maxDeletedFaces = int(mesh.topology.numValidFaces() / 2);
MR::decimateMesh(mesh, s);
-\endcode
+```
## Signed distance from a point to a mesh
libigl:
-\code{.cpp}
+```cpp
#include
Eigen::VectorXd S;
Eigen::VectorXi I;
Eigen::MatrixXd C, N;
igl::signed_distance(P, V, F, igl::SIGNED_DISTANCE_TYPE_PSEUDONORMAL, S, I, C, N);
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
#include
auto sd = MR::findSignedDistance(point, mesh);
float dist = sd->dist;
-\endcode
+```
# Open3D
## Point-to-point ICP registration
Open3D:
-\code{.cpp}
+```cpp
#include
using namespace open3d;
@@ -131,10 +129,10 @@ auto result = pipelines::registration::RegistrationICP(
Eigen::Matrix4d::Identity(),
pipelines::registration::TransformationEstimationPointToPoint());
Eigen::Matrix4d xf = result.transformation_;
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -143,12 +141,12 @@ auto src = MR::PointsLoad::fromAnySupportedFormat("src.ply").value();
auto tgt = MR::PointsLoad::fromAnySupportedFormat("tgt.ply").value();
MR::ICP icp( {src}, {tgt}, MR::AffineXf3f{}, MR::AffineXf3f{}, /*samplingVoxel=*/0.05f );
auto xf = icp.calculateTransformation();
-\endcode
+```
## Point cloud to mesh (surface reconstruction)
Open3D (Ball Pivoting):
-\code{.cpp}
+```cpp
#include
using namespace open3d;
@@ -156,10 +154,10 @@ auto pcd = io::CreatePointCloudFromFile("cloud.ply");
pcd->EstimateNormals();
std::vector radii = {0.005, 0.01, 0.02, 0.04};
auto mesh = geometry::TriangleMesh::CreateFromPointCloudBallPivoting(*pcd, radii);
-\endcode
+```
MeshLib (voxel fusion):
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -169,14 +167,14 @@ auto cloud = MR::PointsLoad::fromAnySupportedFormat("cloud.ply").value();
MR::PointsToMeshParameters p;
p.voxelSize = cloud.computeBoundingBox().diagonal() * 1e-2f;
MR::Mesh mesh = MR::pointsToMeshFusion(cloud, p).value();
-\endcode
+```
# PCL
## Voxel-grid downsampling of a point cloud
PCL:
-\code{.cpp}
+```cpp
#include
#include
@@ -187,10 +185,10 @@ vg.setInputCloud(cloud);
vg.setLeafSize(0.05f, 0.05f, 0.05f);
pcl::PointCloud::Ptr out(new pcl::PointCloud);
vg.filter(*out);
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -200,12 +198,12 @@ auto cloud = MR::PointsLoad::fromAnySupportedFormat("cloud.ply").value();
MR::UniformSamplingSettings s;
s.distance = 0.05f;
MR::PointCloud out = MR::makeUniformSampledCloud(cloud, s).value();
-\endcode
+```
## Estimate point-cloud normals
PCL:
-\code{.cpp}
+```cpp
#include
pcl::NormalEstimation ne;
@@ -215,15 +213,15 @@ ne.setSearchMethod(tree);
ne.setKSearch(20);
pcl::PointCloud::Ptr normals(new pcl::PointCloud);
ne.compute(*normals);
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
auto normals = MR::makeNormals(cloud, /*avgNeighborhoodSize=*/20);
cloud.normals = normals;
-\endcode
+```
# VTK
@@ -233,7 +231,7 @@ In Python the bridge is even shorter: vtkPolyData arrays go straight into MeshLi
## Decimate a mesh
VTK:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -248,10 +246,10 @@ dec->SetInputData(reader->GetOutput());
dec->SetTargetReduction(0.5);
dec->Update();
vtkPolyData* out = dec->GetOutput();
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -261,12 +259,12 @@ auto mesh = MR::MeshLoad::fromAnySupportedFormat("in.stl").value();
MR::DecimateSettings s;
s.maxDeletedFaces = int(mesh.topology.numValidFaces() / 2);
MR::decimateMesh(mesh, s);
-\endcode
+```
## Boolean union of two meshes
VTK:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -280,10 +278,10 @@ boolOp->SetInputData(0, ra->GetOutput());
boolOp->SetInputData(1, rb->GetOutput());
boolOp->Update();
vtkPolyData* out = boolOp->GetOutput();
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
#include
@@ -292,12 +290,12 @@ auto a = MR::MeshLoad::fromAnySupportedFormat("a.stl").value();
auto b = MR::MeshLoad::fromAnySupportedFormat("b.stl").value();
auto res = MR::boolean(a, b, MR::BooleanOperation::Union);
MR::Mesh out = res.mesh;
-\endcode
+```
## Read and write mesh files
VTK:
-\code{.cpp}
+```cpp
#include
#include
#include
@@ -310,21 +308,21 @@ auto writer = vtkSmartPointer::New();
writer->SetFileName("out.obj");
writer->SetInputData(reader->GetOutput());
writer->Write();
-\endcode
+```
MeshLib:
-\code{.cpp}
+```cpp
#include
#include
auto mesh = MR::MeshLoad::fromAnySupportedFormat("in.stl").value();
MR::MeshSave::toAnySupportedFormat(mesh, "out.obj");
-\endcode
+```
## Moving data in memory (Python)
In Python no files are needed: vtkPolyData arrays go straight into MeshLib via numpy and back.
-\code{.py}
+```py
from vtk.util.numpy_support import vtk_to_numpy
from meshlib import mrmeshpy, mrmeshnumpy
@@ -338,11 +336,9 @@ mesh = mrmeshnumpy.meshFromFacesVerts(faces, verts)
# MeshLib -> numpy (rebuild vtkPolyData with numpy_to_vtk)
out_verts = mrmeshnumpy.getNumpyVerts(mesh)
out_faces = mrmeshnumpy.getNumpyFaces(mesh.topology)
-\endcode
+```
# Missing your case?
Don't see your library or your operation?
[Open an issue](https://github.com/MeshInspector/MeshLib/issues) or [start a GitHub Discussion](https://github.com/MeshInspector/MeshLib/discussions) — we'll add the snippet.
-
-*/
diff --git a/doxygen/general_pages/ThirdpartyList.dox b/doxygen/general_pages/ThirdpartyList.md
similarity index 93%
rename from doxygen/general_pages/ThirdpartyList.dox
rename to doxygen/general_pages/ThirdpartyList.md
index e710f7ed42e2..8468aa2b82d0 100644
--- a/doxygen/general_pages/ThirdpartyList.dox
+++ b/doxygen/general_pages/ThirdpartyList.md
@@ -1,6 +1,4 @@
-namespace MR {
-
-/** \page ThirdParty Third-Party Dependencies
+# Third-Party Dependencies {#ThirdParty}
# List of dependencies
@@ -22,7 +20,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRMesh
-\b MRMesh is our core module, handling geometry operations. Since it is mandatory, its dependencies are required for every build.
+**MRMesh** is our core module, handling geometry operations. Since it is mandatory, its dependencies are required for every build.
|Name |Description |License |
|---------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|-------------------------------|
@@ -43,7 +41,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRIOExtras
-\b MRIOExtras adds support for the input and output of additional file formats (e.g., glTF, STEP, PDF). It requires MRMesh and includes:
+**MRIOExtras** adds support for the input and output of additional file formats (e.g., glTF, STEP, PDF). It requires MRMesh and includes:
|Name |Description |License |
|------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|-------------------------------------------|
@@ -60,7 +58,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRSymbolMesh
-\b MRSymbolMesh is our module responsible for text-to-mesh conversion operations. As such, it requires MRMesh plus:
+**MRSymbolMesh** is our module responsible for text-to-mesh conversion operations. As such, it requires MRMesh plus:
|Name |Description |License |
|-----------------------------------------------------------|-----------------------------------------------------------------------------|-------------------------------------------|
@@ -68,7 +66,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRPython
-\b MRPython enables Python bindings and embedded Python scripting for MeshLib. It depends on MRMesh and:
+**MRPython** enables Python bindings and embedded Python scripting for MeshLib. It depends on MRMesh and:
|Name |Description |License |
|-------------------------------------------------------------------------|-----------------------------------------------------------------------------|-------------------------------------------|
@@ -78,7 +76,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRVoxels
-\b MRVoxels provides functionality for volumetric operations. It depends on MRMesh plus:
+**MRVoxels** provides functionality for volumetric operations. It depends on MRMesh plus:
|Name |Description |License |
|------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|--------------------|
@@ -88,7 +86,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRCuda
-\b MRCuda enables GPU-accelerated algorithms using NVIDIA CUDA. Here, you need MRMesh, MRVoxels, and:
+**MRCuda** enables GPU-accelerated algorithms using NVIDIA CUDA. Here, you need MRMesh, MRVoxels, and:
|Name |Description |License |
|----------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|-----------------------------------------------------|
@@ -97,7 +95,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRViewer
-\b MRViewer is MeshLib’s module for rendering and UI. It handles window creation, input, and GUI elements. It needs MRMesh, MRVoxels, MRSymbolMesh, MRIOExtras, and:
+**MRViewer** is MeshLib’s module for rendering and UI. It handles window creation, input, and GUI elements. It needs MRMesh, MRVoxels, MRSymbolMesh, MRIOExtras, and:
|Name |Description |License |
|---------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|-----------------------------|
@@ -113,7 +111,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRMcp
-\b MRMcp exposes MeshLib functionality through the Model Context Protocol (HTTP + SSE) and a parallel REST API. It depends on MRMesh and:
+**MRMcp** exposes MeshLib functionality through the Model Context Protocol (HTTP + SSE) and a parallel REST API. It depends on MRMesh and:
|Name |Description |License |
|------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|-------------------------------------------|
@@ -123,7 +121,7 @@ Below is a summary of all modules and their dependencies, so you can see what ea
### MRMCPGateway
-\b MRMCPGateway is a small standalone executable (`McpGateway[.exe]`) that proxies stdio-based MCP clients onto the HTTP MCP server hosted by MeshInspector. It has no MeshLib dependencies and pulls in:
+**MRMCPGateway** is a small standalone executable (`McpGateway[.exe]`) that proxies stdio-based MCP clients onto the HTTP MCP server hosted by MeshInspector. It has no MeshLib dependencies and pulls in:
|Name |Description |License |
|------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|-------------------------------------------|
@@ -137,7 +135,3 @@ The Windows distribution ships its executables (MeshViewer, meshconv, MRTest) wi
|Name |Description |License |
|-----------------------------------------------------------------------------------|-----------------------------------------------------------------------------|-------------------------------------------|
|mimalloc |a compact general purpose allocator with excellent performance |MIT |
-
-*/
-
-}
\ No newline at end of file
diff --git a/doxygen/general_pages/Tutorials.dox b/doxygen/general_pages/Tutorials.md
similarity index 89%
rename from doxygen/general_pages/Tutorials.dox
rename to doxygen/general_pages/Tutorials.md
index b5d2792b1f3f..0cd098f30ab8 100644
--- a/doxygen/general_pages/Tutorials.dox
+++ b/doxygen/general_pages/Tutorials.md
@@ -1,5 +1,4 @@
-/**
-\page Tutorials MeshLib SDK Tutorials
+# MeshLib SDK Tutorials {#Tutorials}
Welcome to the MeshLib SDK Tutorials! Here you'll find guides, examples, and step-by-step instructions to help you get started with MeshLib and explore its features.
@@ -13,13 +12,11 @@ You can also try these operations in the browser: the [live demo](https://demo.m
In just a few minutes, you'll learn how to set up your development environment, write your first plugin, and get it running with MeshLib.
This tutorial will help you establish a solid foundation for more advanced plugin development.
-\ref FirstPluginTutorial "Start Tutorial"
+[Start Tutorial](\ref FirstPluginTutorial)
### Building a Support Generator Plugin Using MeshLib C++ on Windows
In this extended tutorial, you'll learn how to expand MeshLib's capabilities by developing custom tools.
Through a practical, hands-on session, you'll build a fully functional support generator that combines user interaction, geometric processing, and real-time visualization within the MeshLib Viewer.
-\ref SupportGeneratorTutorial "Support Generator Tutorial"
-
-*/
+[Support Generator Tutorial](\ref SupportGeneratorTutorial)