pytetwild 0.1.dev1__tar.gz → 0.1.1__tar.gz

{pytetwild-0.1.dev1 → pytetwild-0.1.1}/.github/workflows/build-and-deploy.yml

@@ -19,21 +19,21 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest]
+        os: [ubuntu-latest, windows-latest, macos-15-intel, macos-15]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           submodules: true
 
       - name: Setup Miniconda (Windows)
         if: runner.os == 'Windows'
-        uses: conda-incubator/setup-miniconda@v3.0.3
+        uses: conda-incubator/setup-miniconda@v3.2.0
 
       - name: Install Dependencies (Windows)
         if: runner.os == 'Windows'
         shell: powershell
-        run: conda install -c conda-forge mpir -y
+        run: conda install -c conda-forge mpir zlib -y
 
       - name: Set env (Windows)
         if: runner.os == 'Windows'
@@ -43,12 +43,15 @@ jobs:
           echo "GMP_LIB=C:\Miniconda\envs\test\Library\lib" >> ${env:GITHUB_ENV}
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v2.16.5
+        uses: pypa/cibuildwheel@v3.3.0
+        env:
+          CIBW_ENVIRONMENT_MACOS: 'MACOSX_DEPLOYMENT_TARGET="15.0"'
+          CIBW_ARCHS_MACOS: "auto"
 
       - name: List generated wheels
         run: ls ./wheelhouse/*
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v5
         with:
           path: ./wheelhouse/*.whl
           name: pytetwild-wheel-${{ matrix.os }}
@@ -57,7 +60,7 @@ jobs:
     name: Build source distribution
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           submodules: true
 
@@ -71,7 +74,6 @@ jobs:
           libboost-thread-dev \
           libglu1-mesa-dev \
           libsuitesparse-dev \
-          xorg-dev \
           ccache
 
       - name: Build source distribution
@@ -107,7 +109,7 @@ jobs:
     permissions:
       id-token: write  # this permission is mandatory for trusted publishing
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v6
       - name: Flatten directory structure
         run: |
           mkdir -p dist/

{pytetwild-0.1.dev1 → pytetwild-0.1.1}/.gitignore

@@ -45,10 +45,13 @@ venv/
 
 # skbuild
 _skbuild/
+.skbuild-info.json
+compile_commands.json
 
 # cmake
 .ninja_deps
 .ninja_log
+.cmake
 CMakeCache.txt
 CMakeFiles/
 CMakeInit.txt
@@ -72,6 +75,8 @@ fTetWildWrapper.sln
 x64/
 Release/
 mpir.dll
+_deps
+appleclang*
 
 # cibuildwheel
 wheelhouse

{pytetwild-0.1.dev1 → pytetwild-0.1.1}/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.1.11
+  rev: v0.14.4
   hooks:
     - id: ruff
       args: [--fix, --exit-non-zero-on-fix]
@@ -8,19 +8,19 @@ repos:
     - id: ruff-format
 
 - repo: https://github.com/keewis/blackdoc
-  rev: v0.3.9
+  rev: v0.4.5
   hooks:
   - id: blackdoc
     exclude: README.rst
 
 - repo: https://github.com/numpy/numpydoc
-  rev: v1.6.0
+  rev: v1.9.0
   hooks:
   - id: numpydoc-validation
     files: ^src/pytetwild
 
 - repo: https://github.com/codespell-project/codespell
-  rev: v2.2.6
+  rev: v2.4.1
   hooks:
   - id: codespell
     args: ["--skip=*.vt*"]
@@ -33,14 +33,14 @@ repos:
     files: ^src/pytetwild/.*\.py
 
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.5.0
+  rev: v6.0.0
   hooks:
   - id: check-merge-conflict
   - id: debug-statements
   - id: trailing-whitespace
 
 - repo: https://github.com/pre-commit/mirrors-clang-format
-  rev: v17.0.6
+  rev: v21.1.5
   hooks:
   - id: clang-format
     files: |
@@ -49,7 +49,7 @@ repos:
       )$
 
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v1.7.0
+  rev: v1.18.2
   hooks:
   - id: mypy
     exclude: ^(docs/|tests)
@@ -61,6 +61,6 @@ repos:
   ]
 
 - repo: https://github.com/python-jsonschema/check-jsonschema
-  rev: 0.27.3
+  rev: 0.34.1
   hooks:
     - id: check-github-workflows

{pytetwild-0.1.dev1 → pytetwild-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pytetwild
-Version: 0.1.dev1
+Version: 0.1.1
 Summary: Python wrapper of fTetWild
 Author-Email: Alex Kaszynski <akascap@gmail.com>
 Classifier: Development Status :: 3 - Alpha
@@ -10,20 +10,19 @@ Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: MacOS
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: numpy
+Provides-Extra: all
 Requires-Dist: pyvista; extra == "all"
+Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pyvista; extra == "dev"
 Requires-Dist: scipy; extra == "dev"
 Requires-Dist: meshio; extra == "dev"
-Provides-Extra: all
-Provides-Extra: dev
 Description-Content-Type: text/x-rst
 
 pytetwild
@@ -74,7 +73,7 @@ To tetrahedralize a surface mesh from `PyVista <https://docs.pyvista.org>`_:
 
    # Convert the surface mesh to a tetrahedral mesh. For this example let's
    # use a coarse mesh
-   tetrahedral_mesh = pytetwild.tetrahedralize_pv(surface_mesh, edge_length_fac=1))
+   tetrahedral_mesh = pytetwild.tetrahedralize_pv(surface_mesh, edge_length_fac=1)
 
    # Visualize the tetrahedral mesh in an "exploded" view
    tetrahedral_mesh.explode(1).plot(show_edges=True)
@@ -83,7 +82,7 @@ To tetrahedralize a surface mesh from `PyVista <https://docs.pyvista.org>`_:
 
 You can also work with raw arrays. Here's a simple cube that we turn into tetrahedra.
 
-.. code:: pycon
+.. code:: py
 
    import numpy as np
 
@@ -122,7 +121,7 @@ We've surfaced a handful of parameters to each of our interfaces
     Additional Parameters
     ---------------------
     edge_length_fac : float, default: 0.05
-        Tetrahedral edge length as a function of bounding box diagional. The
+        Tetrahedral edge length as a function of bounding box diagonal. The
         default ideal edge length is bb/20 (bounding box divided by 20).
     optimize : bool
         Improve the minimum scaled Jacobean for each cell. This leads to higher

{pytetwild-0.1.dev1 → pytetwild-0.1.1}/README.rst

@@ -46,7 +46,7 @@ To tetrahedralize a surface mesh from `PyVista <https://docs.pyvista.org>`_:
 
    # Convert the surface mesh to a tetrahedral mesh. For this example let's
    # use a coarse mesh
-   tetrahedral_mesh = pytetwild.tetrahedralize_pv(surface_mesh, edge_length_fac=1))
+   tetrahedral_mesh = pytetwild.tetrahedralize_pv(surface_mesh, edge_length_fac=1)
 
    # Visualize the tetrahedral mesh in an "exploded" view
    tetrahedral_mesh.explode(1).plot(show_edges=True)
@@ -55,7 +55,7 @@ To tetrahedralize a surface mesh from `PyVista <https://docs.pyvista.org>`_:
 
 You can also work with raw arrays. Here's a simple cube that we turn into tetrahedra.
 
-.. code:: pycon
+.. code:: py
 
    import numpy as np
 
@@ -94,7 +94,7 @@ We've surfaced a handful of parameters to each of our interfaces
     Additional Parameters
     ---------------------
     edge_length_fac : float, default: 0.05
-        Tetrahedral edge length as a function of bounding box diagional. The
+        Tetrahedral edge length as a function of bounding box diagonal. The
         default ideal edge length is bb/20 (bounding box divided by 20).
     optimize : bool
         Improve the minimum scaled Jacobean for each cell. This leads to higher

{pytetwild-0.1.dev1 → pytetwild-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "pytetwild"
-version = "0.1.dev1"
+version = "0.1.1"
 description = "Python wrapper of fTetWild"
 readme = { file = "README.rst", content-type = "text/x-rst" }
 authors = [{ name = "Alex Kaszynski", email = "akascap@gmail.com" }]
@@ -17,41 +17,57 @@ classifiers = [
     'Operating System :: Microsoft :: Windows',
     'Operating System :: POSIX',
     'Operating System :: MacOS',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
 ]
-include = ["src/pytetwild/py.typed"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["pytetwild*"]
+
+[tool.setuptools.package-data]
+pytetwild = ["py.typed"]
 
 [project.optional-dependencies]
 all = ['pyvista']
 dev = ["pytest", "pre-commit", "pyvista", "scipy", "meshio"]
 
 [tool.scikit-build]
-cmake.build-type = "Release"
 build-dir = "./build"
 editable.mode = "inplace"
 
+[tool.scikit-build.cmake]
+args = [
+    "-DCMAKE_BUILD_TYPE=Release",
+    "-DCMAKE_CXX_STANDARD=17",
+    "-DBUILD_SHARED_LIBS=OFF",
+]
+
 [tool.pytest.ini_options]
 testpaths = 'tests'
 
 [tool.cibuildwheel]
 archs = ["auto64"]  # 64-bit only
-build = "cp38-* cp39-* cp310-* cp311-* cp312-*"  # Only build Python 3.8-3.12 wheels
-skip = ["pp*", "*musllinux*"]  # disable PyPy and musl-based wheels
+build = "cp310-* cp311-* cp312-* cp313-*"  # Only build Python 3.10-3.14 wheels
+skip = ["*musllinux*"]  # disable PyPy and musl-based wheels
 test-requires = "pytest pyvista scipy meshio"
 test-command = "pytest {project}/tests -v"
 
 [tool.cibuildwheel.linux]
-before-all = "yum install gmp gmp-devel -y"
+manylinux-x86_64-image = "manylinux_2_28"
+before-all = "dnf install -y gmp-devel"
+before-build = "pip install cmake==3.29.0"
 environment = "USE_MAVX='true'"
 environment-pass = ["USE_MAVX"]
 
+[tool.cibuildwheel.macos]
+before-build = "pip install cmake==3.29.0"
+
 # pip install delvewheel &&
 [tool.cibuildwheel.windows]
-before-build = "pip install delvewheel && python -c \"import os; file_path = 'build/CMakeCache.txt'; os.remove(file_path) if os.path.exists(file_path) else None\""
+before-build = "pip install cmake==3.29.0 delvewheel && python -c \"import os; file_path = 'build/CMakeCache.txt'; os.remove(file_path) if os.path.exists(file_path) else None\""
 repair-wheel-command = "python -c \"import shutil, os; shutil.copy(os.path.join(os.getenv('GMP_LIB'), '..', 'bin', 'mpir.dll'), '.')\" && delvewheel repair -w {dest_dir} {wheel} --add-path ."
 
 
@@ -147,4 +163,3 @@ extend-select = [
     "RUF010",
     "RUF100",
 ]
-

{pytetwild-0.1.dev1 → pytetwild-0.1.1}/src/FTetWildWrapper.cpp

@@ -1,10 +1,14 @@
 #include <floattetwild/AABBWrapper.h>
+#include <floattetwild/CSGTreeParser.hpp>
 #include <floattetwild/FloatTetDelaunay.h>
+#include <floattetwild/Logger.hpp>
 #include <floattetwild/Mesh.hpp>
 #include <floattetwild/MeshIO.hpp>
 #include <floattetwild/MeshImprovement.h>
 #include <floattetwild/Simplification.h>
 #include <floattetwild/TriangleInsertion.h>
+#include <floattetwild/Types.hpp>
+#include <oneapi/tbb/global_control.h>
 #include <thread>
 
 #include <Eigen/Dense>
@@ -27,6 +31,16 @@ namespace py = pybind11;
 #include <geogram/mesh/mesh_repair.h>
 #include <geogram/numerics/predicates.h>
 
+#include "igl/default_num_threads.h"
+
+using floatTetWild::AABBWrapper;
+using floatTetWild::boolean_operation;
+using floatTetWild::CSGTreeParser;
+using floatTetWild::FloatTetDelaunay;
+using floatTetWild::json;
+using floatTetWild::Vector3;
+using floatTetWild::Vector3i;
+
 std::pair<std::vector<std::array<float, 3>>, std::vector<std::array<int, 4>>>
 extractMeshData(const floatTetWild::Mesh &mesh) {
   std::vector<std::array<float, 3>> vertices;
@@ -263,4 +277,176 @@ PYBIND11_MODULE(PyfTetWildWrapper, m) {
       },
       "Tetrahedralizes a mesh given vertices and faces arrays, returning numpy "
       "arrays of tetrahedra and points.");
+
+  m.def(
+      "tetrahedralize_csg",
+      [](const std::string &csg_file, float epsilon, float edge_length_r,
+         float stop_energy, bool coarsen, int num_threads, int log_level) {
+        GEO::initialize();
+
+        // Initialize mesh and parameters
+        floatTetWild::Mesh mesh;
+        floatTetWild::Parameters &params = mesh.params;
+        params.eps_rel = epsilon;
+        params.ideal_edge_length_rel = edge_length_r;
+        params.stop_energy = stop_energy;
+        params.coarsen = coarsen;
+        // params.use_general_wn = true;
+
+        // Set up threading
+        if (num_threads == 0) {
+          num_threads = std::thread::hardware_concurrency();
+        }
+        // IGL has issues with a nested for loop and oversubscription, see
+        // https://github.com/libigl/libigl/issues/2412
+        igl::default_num_threads(std::ceil(std::sqrt(num_threads)));
+        params.num_threads = num_threads;
+        const size_t MB = 1024 * 1024;
+        const size_t stack_size = 64 * MB;
+        std::cout << "TBB threads " << num_threads << std::endl;
+        tbb::global_control parallelism_limit(
+            tbb::global_control::max_allowed_parallelism, num_threads);
+        tbb::global_control stack_size_limit(
+            tbb::global_control::thread_stack_size, stack_size);
+
+        floatTetWild::Logger::init(!params.is_quiet, params.log_path);
+        params.log_level = log_level;
+        spdlog::set_level(
+            static_cast<spdlog::level::level_enum>(params.log_level));
+        spdlog::flush_every(std::chrono::seconds(3));
+
+        // Load CSG tree
+        json csg_tree = json({});
+        std::ifstream file(csg_file);
+        if (file.is_open()) {
+          file >> csg_tree;
+          file.close();
+        } else {
+          throw std::runtime_error("Unable to open CSG file: " + csg_file);
+        }
+
+        // Load and merge meshes from CSG tree
+        json tree_with_ids;
+        std::vector<std::string> meshes;
+        CSGTreeParser::get_meshes(csg_tree, meshes, tree_with_ids);
+
+        // Pre-check all input meshes for non-finite (NaN/Inf) coordinates.
+        py::print("Pre-checking CSG input meshes for NaN/Inf values...");
+        for (const auto &mesh_file : meshes) {
+          std::vector<Vector3> temp_vertices;
+          std::vector<Vector3i> temp_faces;
+          std::vector<int> temp_tags;
+          GEO::Mesh temp_sf_mesh; // Dummy, but load_and_merge requires it
+
+          // We use load_and_merge with a single-item list
+          if (!CSGTreeParser::load_and_merge(
+                  {mesh_file}, // Load just this one file
+                  temp_vertices, temp_faces, temp_sf_mesh, temp_tags)) {
+            throw std::runtime_error("Failed to pre-load mesh for checking: " +
+                                     mesh_file);
+          }
+
+          // The check for NaN/Inf
+          for (const auto &v : temp_vertices) {
+            if (!std::isfinite(v.x()) || !std::isfinite(v.y()) ||
+                !std::isfinite(v.z())) {
+              throw std::runtime_error(
+                  "FATAL: Input mesh file contains non-finite (NaN/Inf) vertex "
+                  "coordinates: " +
+                  mesh_file);
+            }
+          }
+        }
+        py::print("All input meshes passed check.");
+
+        std::vector<Vector3> input_vertices;
+        std::vector<Vector3i> input_faces;
+        std::vector<int> input_tags;
+        GEO::Mesh sf_mesh;
+        if (!CSGTreeParser::load_and_merge(meshes, input_vertices, input_faces,
+                                           sf_mesh, input_tags))
+          throw std::runtime_error(
+              "Failed to load and merge meshes from CSG tree");
+
+        // Initialize AABBWrapper
+        AABBWrapper tree(sf_mesh);
+        if (!params.init(tree.get_sf_diag())) {
+          throw std::runtime_error("Parameters initialization failed");
+        }
+
+        // Preprocessing
+        bool skip_simplify = false;
+        simplify(input_vertices, input_faces, input_tags, tree, params,
+                 skip_simplify);
+        tree.init_b_mesh_and_tree(input_vertices, input_faces, mesh);
+
+        // Tetrahedralization
+        std::vector<bool> is_face_inserted(input_faces.size(), false);
+        FloatTetDelaunay::tetrahedralize(input_vertices, input_faces, tree,
+                                         mesh, is_face_inserted);
+
+        // Insert triangles and optimize
+        insert_triangles(input_vertices, input_faces, input_tags, mesh,
+                         is_face_inserted, tree, false);
+        optimization(input_vertices, input_faces, input_tags, is_face_inserted,
+                     mesh, tree, {{1, 1, 1, 1}});
+
+        std::cout << "optimization finished" << std::endl;
+        // Correct surface orientation
+        correct_tracked_surface_orientation(mesh, tree);
+        std::cout << "correct surface orientation finished" << std::endl;
+
+        // Apply Boolean operations
+        boolean_operation(mesh, tree_with_ids, meshes);
+        std::cout << "boolean operation finished " << std::endl;
+
+        // Extract data
+        auto result = extractMeshData(mesh);
+        auto vertices = result.first;
+        auto cells = result.second;
+
+        // Extract marker
+        std::vector<int> marker;
+        for (const auto &tet : mesh.tets) {
+          if (!tet.is_removed) {
+            marker.push_back(tet.scalar);
+          }
+        }
+        // Convert to numpy arrays
+        size_t num_vertices = vertices.size();
+        size_t num_cells = cells.size();
+
+        size_t v_shape[2] = {num_vertices, 3};
+        auto np_vertices = py::array_t<float>(v_shape);
+        auto v_access = np_vertices.mutable_unchecked<2>();
+        for (size_t i = 0; i < num_vertices; ++i) {
+          for (size_t j = 0; j < 3; ++j) {
+            v_access(i, j) = vertices[i][j];
+          }
+        }
+
+        size_t c_shape[2] = {num_cells, 4};
+        auto np_cells = py::array_t<int>(c_shape);
+        auto c_access = np_cells.mutable_unchecked<2>();
+        for (size_t i = 0; i < num_cells; ++i) {
+          for (size_t j = 0; j < 4; ++j) {
+            c_access(i, j) = cells[i][j];
+          }
+        }
+
+        size_t m_shape[1] = {num_cells};
+        auto np_markers = py::array_t<int>(m_shape);
+        auto m_access = np_markers.mutable_unchecked<1>();
+        for (size_t i = 0; i < num_cells; ++i) {
+          m_access(i) = marker[i];
+        }
+        py::print(
+            "Tetrahedralization process from CSG completed successfully.");
+        return std::make_tuple(np_vertices, np_cells, np_markers);
+      },
+      "Tetrahedralizes a CSG tree from a JSON file, returning numpy arrays of "
+      "vertices, cells, and markers.",
+      py::arg("csg_file"), py::arg("epsilon"), py::arg("edge_length_r"),
+      py::arg("stop_energy"), py::arg("coarsen"), py::arg("num_threads"),
+      py::arg("log_level"));
 }

pytetwild-0.1.1/src/fTetWild/.github/workflows/continuous.yml

@@ -0,0 +1,116 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+env:
+  CTEST_OUTPUT_ON_FAILURE: ON
+  CTEST_PARALLEL_LEVEL: 2
+
+defaults:
+  run:
+    shell: bash -el {0}
+
+jobs:
+  ####################
+  # Linux / macOS
+  ####################
+
+  Unix:
+    name: ${{ matrix.name }}-${{ matrix.envelope }} (${{ matrix.config }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, ubuntu-latest, macOS-15, macOS-14, macOS-latest, windows-2022]
+        config: [Debug, Release]
+        envelope: [OFF]
+        include:
+          - os: ubuntu-22.04
+            name: ubuntu-22.04
+          - os: ubuntu-latest
+            name: ubuntu-latest
+          - os: macos-13
+            name: macOS-13
+          - os: macos-14
+            name: macOS-14 ARM64
+          - os: macos-latest
+            name: macOS-latest ARM64     
+          - os: windows-2022
+            name: Windows
+            
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 10
+          submodules: "recursive"
+          
+      - name: Setup tmate session
+        uses: mxschmitt/action-tmate@v3
+        timeout-minutes: 20
+        with:
+          detached: true
+    
+      - name: Setup NMake (Windows)
+        if: runner.os == 'Windows'
+        uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Setup Conda
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          channels: conda-forge
+          python-version: ${{ matrix.python-version }}
+          channel-priority: true
+          activate-environment: test-env
+
+      - name: Install Dependencies
+        run: conda install cmake=3.29 git -y
+
+      - name: Install Dependencies  (Windows)
+        if: runner.os == 'Windows'
+        run: conda install mpir zlib -y
+
+      - name: Envs (Windows)
+        if: runner.os == 'Windows'
+        run: echo "CMAKE_GENERATOR=NMake Makefiles" >> $GITHUB_ENV
+
+      - name: Configure ssl certificate
+        if : runner.os == 'Windows'
+        run: git config --global http.sslBackend schannel
+
+      - name: Configure
+        run: |
+          mkdir -p build
+          cd build
+          cmake .. \
+            -DCMAKE_PREFIX_PATH=$CONDA_PREFIX \
+            -DCMAKE_BUILD_TYPE=${{ matrix.config }} \
+            -DFLOAT_TETWILD_WITH_EXACT_ENVELOPE=${{ matrix.envelope }}
+
+      - name: Build
+        run: cd build; conda run -n test-env cmake --build . --parallel 2
+        
+      - name: Tests
+        run: cd build; ctest --verbose --output-on-failure
+
+      - name: Run Example (Unix)
+        if: runner.os != 'Windows'
+        run: cd build; ./FloatTetwild_bin --input ../tests/bunny.off --level 0 --stop-energy 100
+
+      - name: Run Example (Windows)
+        if: runner.os == 'Windows'
+        shell: cmd
+        run: |
+          cd build
+          rem Find the msvc_* directory automatically and copy the DLL
+          for /d %%d in (msvc_*) do copy "%%d\tbb*.dll" .
+          rem Copy the other DLL
+          copy C:\Miniconda\envs\test-env\Library\bin\mpir.dll .
+          rem Run the executable
+          FloatTetwild_bin.exe --input ..\tests\bunny.off --level 0 --stop-energy 100