loop-cgal 0.0.1__tar.gz

loop_cgal-0.0.1/.github/workflows/conda.yml

@@ -0,0 +1,54 @@
+name: "🐍 Build and upload Conda packages"
+on:
+  workflow_dispatch:
+jobs:
+  conda-deploy:
+    name: Building conda package for python ${{ matrix.os }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ${{ fromJSON(vars.PYTHON_VERSIONS)}}
+    steps:
+      - uses: conda-incubator/setup-miniconda@v3
+        with:
+          auto-update-conda: true
+          python-version: ${{ matrix.python-version }}
+      - uses: actions/checkout@v4
+      - name: update submodules
+        run: |
+          git submodule update --init --recursive
+      - name: Conda build
+        env:
+          ANACONDA_API_TOKEN: ${{ secrets.ANACONDA_TOKEN  }}
+        shell: bash -l {0}
+        run: |
+          conda install -c conda-forge "conda-build<25" scikit-build numpy cython anaconda-client conda-libmamba-solver -y
+          conda build -c conda-forge -c loop3d --output-folder conda conda  --python ${{matrix.python-version}}
+          conda convert -p all conda/linux-64/*.tar.bz2 -f -o conda
+      - name: upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: conda-build-${{ matrix.python-version }}
+          path: conda
+  upload_to_conda:
+    runs-on: ubuntu-latest
+    needs: conda-deploy
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ${{ fromJSON(vars.PYTHON_VERSIONS)}}
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: conda-build-${{ matrix.python-version }}
+          path: conda
+      - uses: conda-incubator/setup-miniconda@v3
+      - name: upload all files to conda-forge
+        shell: bash -l {0}
+        env:
+          ANACONDA_API_TOKEN: ${{ secrets.ANACONDA_TOKEN  }}
+        run: |
+          conda install -c anaconda anaconda-client -y
+          anaconda upload --label main conda/*/*.tar.bz2
+  

loop_cgal-0.0.1/.github/workflows/pypi.yml

@@ -0,0 +1,40 @@
+name: Deploy to PYPI
+
+on:
+  workflow_dispatch:
+jobs:
+
+  sdist:
+    name: Build sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      - name: Build sdist
+        run: python -m build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: ./dist/*.tar.gz
+
+  publish:
+    name: Publish wheels to pypi
+    runs-on: ubuntu-latest
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+    needs: sdist
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+          verbose: true
+          packages-dir: dist/

loop_cgal-0.0.1/.github/workflows/release-please.yml

@@ -0,0 +1,42 @@
+on:
+  push:
+    branches:
+      - master
+env:
+    PACKAGE_NAME: loop_cgal
+permissions:
+  contents: write
+  pull-requests: write
+  issues: write
+
+name: release-please
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: GoogleCloudPlatform/release-please-action@v4
+        id: release
+        with:
+          path: loop_cgal
+          
+    outputs:
+      release_created: ${{ steps.release.outputs.releases_created }}
+  package:
+    needs: release-please
+    if: ${{ needs.release-please.outputs.release_created == 'true'}}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger build for pypi and upload
+        run: |
+          curl -X POST \
+          -H "Authorization: token ${{ secrets.GH_PAT }}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/Loop3d/${{env.PACKAGE_NAME}}/actions/workflows/pypi.yml/dispatches \
+          -d '{"ref":"master"}'
+      - name: Trigger build for conda and upload
+        run: |
+          curl -X POST \
+          -H "Authorization: token ${{ secrets.GH_PAT }}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/Loop3d/${{env.PACKAGE_NAME}}/actions/workflows/conda.yml/dispatches \
+          -d '{"ref":"master"}'

loop_cgal-0.0.1/.gitignore

@@ -0,0 +1,42 @@
+# C++ artifacts
+*.o
+*.so
+*.a
+*.lib
+*.dll
+*.dylib
+*.exe
+*.out
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg
+*.egg-info/
+dist/
+build/
+_skbuild/
+*.whl
+
+# IDE and editors
+.vscode/
+.idea/
+*.swp
+*~
+
+# CMake
+CMakeFiles/
+CMakeCache.txt
+cmake_install.cmake
+Makefile
+*.cmake
+!CMakeLists.txt
+
+# Project specific
+_deps/
+external/
+third_party/
+
+# OS specific
+.DS_Store
+Thumbs.db

loop_cgal-0.0.1/CMakeLists.txt

@@ -0,0 +1,40 @@
+# Minimum CMake version
+cmake_minimum_required(VERSION 3.15)
+
+# Project name and version
+project(loop-cgal VERSION 1.0 LANGUAGES CXX)
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Find CGAL package
+find_package(CGAL REQUIRED)
+
+# Add the include directory for your project
+include_directories(${CMAKE_SOURCE_DIR}/src)
+
+# Add the executable for standalone testing
+# add_executable(loop-cgal-exe
+#     src/marching_cubes.cpp
+# )
+
+# Link CGAL to the executable
+# target_link_libraries(loop-cgal-exe PRIVATE CGAL::CGAL)
+
+# Find pybind11
+find_package(pybind11 REQUIRED)
+
+# Add the Python module
+add_library(loop_cgal MODULE
+    loop_cgal/bindings.cpp
+    src/clip.cpp
+    
+)
+target_link_libraries(loop_cgal PRIVATE pybind11::module CGAL::CGAL)
+target_include_directories(loop_cgal PRIVATE ${CMAKE_SOURCE_DIR}/src)
+set_target_properties(loop_cgal PROPERTIES PREFIX "" SUFFIX ".so")
+# Install the Python module to the correct location
+install(TARGETS loop_cgal
+    LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/loop_cgal
+)

loop_cgal-0.0.1/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.2
+Name: loop_cgal
+Version: 0.0.1
+Summary: python bindings for cgal for implicit model meshing
+Author-Email: Lachlan Grose <lachlan.grose@monash.edu>
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+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
+Requires-Python: >=3.7
+Requires-Dist: pyvista
+Description-Content-Type: text/markdown
+
+# Loop-cgal
+
+Loop-cgal is a Python package for mesh processing operations using the  CGAL (Computational Geometry Algorithms Library). It is designed for efficient geometric computations using pyvista objects.
+
+## Features
+
+- Python bindings for CGAL using `pybind11`.
+- Current features:
+    - clipping of 3D triangular surfaces
+- Future features:
+    - Marching cubes algorithm for isosurface extraction
+    - Boolean operations on marching cube meshes.
+
+## Installation
+
+### Prerequisites
+
+- C++17 or later
+- Python 3.11 or later
+- CGAL library
+- Boost library
+- CMake 3.15 or later
+- pybind11
+- scikit-build
+- pyvista
+
+### Build and Install
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/Loop3D/loop-cgal.git
+   cd loop-cgal
+   pip install .
+   ```
+2. Alternatively, you can install it directly from PyPI:
+   ```bash
+   pip install loop-cgal
+   ```

loop_cgal-0.0.1/README.md

@@ -0,0 +1,38 @@
+# Loop-cgal
+
+Loop-cgal is a Python package for mesh processing operations using the  CGAL (Computational Geometry Algorithms Library). It is designed for efficient geometric computations using pyvista objects.
+
+## Features
+
+- Python bindings for CGAL using `pybind11`.
+- Current features:
+    - clipping of 3D triangular surfaces
+- Future features:
+    - Marching cubes algorithm for isosurface extraction
+    - Boolean operations on marching cube meshes.
+
+## Installation
+
+### Prerequisites
+
+- C++17 or later
+- Python 3.11 or later
+- CGAL library
+- Boost library
+- CMake 3.15 or later
+- pybind11
+- scikit-build
+- pyvista
+
+### Build and Install
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/Loop3D/loop-cgal.git
+   cd loop-cgal
+   pip install .
+   ```
+2. Alternatively, you can install it directly from PyPI:
+   ```bash
+   pip install loop-cgal
+   ```

loop_cgal-0.0.1/examples/clip_test.py

@@ -0,0 +1,35 @@
+import loop_cgal
+import numpy as np
+import pyvista as pv
+from LoopStructural.datatypes import BoundingBox
+def test():
+    bb = BoundingBox(np.zeros(3), np.ones(3))
+    grid = bb.structured_grid().vtk()
+    print(grid)
+    grid["scalars"] = grid.points[:,0]
+    surface = grid.contour([.5])
+    surface_1_tri = surface.faces.reshape(-1, 4)[:, 1:].copy()
+    surface_1_verts = surface.points.copy()
+    grid["scalars"] = grid.points[:,1]
+    surface_2 = grid.contour([.5])
+    surface_2_tri = surface_2.faces.reshape(-1, 4)[:, 1:].copy()
+    surface_2_verts = surface_2.points.copy()
+
+    surface_clipped = loop_cgal.clip_pyvista_polydata(
+        surface, surface_2
+    )  # surface_1_tri, surface_1_verts, surface_2_tri, surface_2_verts
+    # )
+    print(surface_clipped)
+    # print(mesh.vertices.shape)
+    # print(surface_1_verts.shape)
+    # print(mesh.triangles)
+    # print(mesh.triangles, mesh.vertices)
+    # surface_clipped = pv.PolyData.from_regular_faces(mesh.vertices, mesh.triangles)
+    p = pv.Plotter()
+    # p.add_mesh(surface)
+    p.add_mesh(surface_2, color="blue", show_edges=True)
+    p.add_mesh(surface_clipped, color="red", show_edges=True)
+    # p.add_points(mesh.vertices, render_points_as_spheres=True, point_size=5)
+    p.show()
+if __name__ == "__main__":
+    test()

loop_cgal-0.0.1/examples/test.py

@@ -0,0 +1,15 @@
+import loop_cgal
+import numpy as np
+def test():
+
+    X,Y,Z = np.meshgrid(np.linspace(0, 1, 10),
+                       np.linspace(0, 1, 10),
+                          np.linspace(0, 1, 10))
+
+    step_vector = np.array([.1, .1, .1])
+    nsteps = np.ones(3)*10
+    points, tri = loop_cgal.generate_mesh_from_numpy(Z,np.zeros(3),step_vector,nsteps,.6)
+    print("tri", tri)
+    print("points", points)
+if __name__ == "__main__":
+    test()

loop_cgal-0.0.1/examples/test2.py

@@ -0,0 +1,20 @@
+import loop_cgal
+import numpy as np
+
+
+def test():
+
+    X, Y, Z = np.meshgrid(
+        np.linspace(0, 1, 10), np.linspace(0, 1, 10), np.linspace(0, 1, 10)
+    )
+
+    step_vector = np.array([0.1, 0.1, 0.1])
+    nsteps = np.ones(3) * 10
+    result = loop_cgal.compute_optimized_intersection(
+        Z,X,0.5,.5,0,0,0,0.1,0.1,0.1
+    )
+    
+
+
+if __name__ == "__main__":
+    test()

loop_cgal-0.0.1/loop_cgal/__init__.py

@@ -0,0 +1,35 @@
+from .loop_cgal import clip_surface, NumpyMesh
+import pyvista as pv
+import numpy as np
+def clip_pyvista_polydata(
+    surface_1: pv.PolyData,
+    surface_2: pv.PolyData,
+) -> pv.PolyData:
+    """
+    Clip two pyvista PolyData objects using the CGAL library.
+
+    Parameters
+    ----------
+    surface_1 : pyvista.PolyData
+        The first surface to be clipped.
+    surface_2 : pyvista.PolyData
+        The second surface to be used for clipping.
+
+    Returns
+    -------
+    pyvista.PolyData
+        The resulting clipped surface.
+    """
+    surface_1 = surface_1.triangulate()
+    surface_2 = surface_2.triangulate()
+    tm = NumpyMesh()
+    tm.vertices = np.array(surface_1.points).copy()
+    tm.triangles = surface_1.faces.reshape(-1, 4)[:, 1:].copy()
+    clipper = NumpyMesh()
+    clipper.vertices = np.array(surface_2.points).copy()
+    clipper.triangles = surface_2.faces.reshape(-1, 4)[:, 1:].copy()
+    mesh = clip_surface(
+        tm,
+        clipper,
+    )
+    return pv.PolyData.from_regular_faces(mesh.vertices, mesh.triangles)

loop_cgal-0.0.1/loop_cgal/bindings.cpp

@@ -0,0 +1,20 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "clip.h" // Include the API implementation
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(loop_cgal, m)
+{
+    
+      m.def("clip_surface", &clip_surface,
+          py::arg("tm"),
+          py::arg("clipper"),
+          "Clip one surface with another.");
+      py::class_<NumpyMesh>(m, "NumpyMesh")
+          .def(py::init<>())
+          .def_readwrite("vertices", &NumpyMesh::vertices)
+          .def_readwrite("triangles", &NumpyMesh::triangles);
+
+}

loop_cgal-0.0.1/pyproject.toml

@@ -0,0 +1,85 @@
+[build-system]
+requires = [
+    "scikit-build-core>=0.3.3",
+    "pybind11>=2.10.0",
+    "oldest-supported-numpy",
+]
+build-backend = "scikit_build_core.build"
+
+
+[project]
+authors = [{ name = "Lachlan Grose", email = "lachlan.grose@monash.edu" }]
+name = "loop_cgal"
+version = "0.0.1"
+description = "python bindings for cgal for implicit model meshing"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.7",
+    "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",
+]
+
+dependencies = ['pyvista']
+
+[tool.scikit-build]
+wheel.expand-macos-universal-tags = true
+
+
+
+[tool.cibuildwheel.pyodide]
+environment.CFLAGS = "-fexceptions"
+environment.LDFLAGS = "-fexceptions"
+build-frontend = { name = "build", args = ["--exports", "whole_archive"] }
+
+[tool.ruff]
+src = ["src"]
+
+[tool.ruff.lint]
+extend-select = [
+    "B",   # flake8-bugbear
+    "I",   # isort
+    "ARG", # flake8-unused-arguments
+    "C4",  # flake8-comprehensions
+    "EM",  # flake8-errmsg
+    "ICN", # flake8-import-conventions
+    "G",   # flake8-logging-format
+    "PGH", # pygrep-hooks
+    "PIE", # flake8-pie
+    "PL",  # pylint
+    "PT",  # flake8-pytest-style
+    "PTH", # flake8-use-pathlib
+    "RET", # flake8-return
+    "RUF", # Ruff-specific
+    "SIM", # flake8-simplify
+    "T20", # flake8-print
+    "UP",  # pyupgrade
+    "YTT", # flake8-2020
+    "EXE", # flake8-executable
+    "NPY", # NumPy specific rules
+    "PD",  # pandas-vet
+]
+ignore = [
+    "PLR09",   # Too many X
+    "PLR2004", # Magic comparison
+]
+isort.required-imports = ["from __future__ import annotations"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["T20"]
+
+[tool.cibuildwheel]
+build = "cp39-* cp310-* cp311-* cp312-* cp313-*"
+skip = "*-win32 *-manylinux_i686 *-musllinux_*"
+
+[tool.cibuildwheel.linux]
+before-all = "yum install python3-devel -y"
+
+[tool.cibuildwheel.macos]
+archs = ["x86_64", "arm64"] 

loop_cgal-0.0.1/src/clip.cpp

@@ -0,0 +1,119 @@
+#include "clip.h"
+#include "numpymesh.h"
+#include <CGAL/Simple_cartesian.h>
+#include <CGAL/Polygon_mesh_processing/clip.h>
+#include <CGAL/Surface_mesh.h>
+
+NumpyMesh clip_surface(NumpyMesh tm, NumpyMesh clipper)
+{
+    auto vertices1_buf = tm.vertices.unchecked<2>();
+    auto triangles1_buf = tm.triangles.unchecked<2>();
+    auto vertices2_buf = clipper.vertices.unchecked<2>();
+    auto triangles2_buf = clipper.triangles.unchecked<2>();
+
+    TriangleMesh _tm;
+    TriangleMesh _clipper;
+    std::vector<TriangleMesh::Vertex_index> vertex_indices;
+    // assemble cgal mesh objects from numpy/pybind11 arrays
+    for (ssize_t i = 0; i < vertices1_buf.shape(0); ++i)
+    {
+        vertex_indices.push_back(_tm.add_vertex(Point(vertices1_buf(i, 0), vertices1_buf(i, 1), vertices1_buf(i, 2))));
+    }
+    for (ssize_t i = 0; i < triangles1_buf.shape(0); ++i)
+    {
+        _tm.add_face(vertex_indices[triangles1_buf(i, 0)], vertex_indices[triangles1_buf(i, 1)], vertex_indices[triangles1_buf(i, 2)]);
+    }
+
+    vertex_indices.clear();
+    for (ssize_t i = 0; i < vertices2_buf.shape(0); ++i)
+    {
+        vertex_indices.push_back(_clipper.add_vertex(Point(vertices2_buf(i, 0), vertices2_buf(i, 1), vertices2_buf(i, 2))));
+    }
+    for (ssize_t i = 0; i < triangles2_buf.shape(0); ++i)
+    {
+        _clipper.add_face(vertex_indices[triangles2_buf(i, 0)], vertex_indices[triangles2_buf(i, 1)], vertex_indices[triangles2_buf(i, 2)]);
+    }
+    for (const auto &vertex : _tm.vertices())
+    {
+        const auto &point = _tm.point(vertex);
+    }
+    for (const auto &vertex : _clipper.vertices())
+    {
+        const auto &point = _clipper.point(vertex);
+    }
+    if (!CGAL::is_valid_polygon_mesh(_tm))
+    {
+        std::cerr << "tm is invalid!" << std::endl;
+    }
+    if (!CGAL::is_valid_polygon_mesh(_clipper))
+    {
+        std::cerr << "clipper is invalid!" << std::endl;
+    }
+    // make sure the meshes actually intersect. If they don't, just return mesh 1
+    bool intersection = CGAL::Polygon_mesh_processing::do_intersect(_tm, _clipper);
+    if (intersection)
+    {
+        // Clip tm with clipper
+        bool flag = CGAL::Polygon_mesh_processing::clip(_tm, _clipper);
+        if (!flag)
+        {
+            std::cerr << "Clipping failed." << std::endl;
+            return {};
+        }
+    }
+    else
+    {
+        std::cout << "Meshes do not intersect. Returning tm." << std::endl;
+    }
+    // store the result in a numpymesh object for sending back to Python
+    std::vector<std::array<double, 3>> vertices;
+    std::vector<std::array<int, 3>> triangles;
+    std::map<TriangleMesh::Vertex_index, int> vertex_index_map;
+    int index = 0;
+    for (const auto &vertex : _tm.vertices())
+
+    {
+        const auto &point = _tm.point(vertex);
+        vertices.push_back({point.x(), point.y(), point.z()});
+        vertex_index_map[vertex] = index++;
+    }
+    for (const auto &face : _tm.faces())
+    {
+        std::array<int, 3> triangle;
+        int i = 0;
+        for (auto halfedge : CGAL::halfedges_around_face(_tm.halfedge(face), _tm))
+        {
+            triangle[i++] = vertex_index_map[CGAL::target(halfedge, _tm)]; // Assuming `idx()` gives the vertex index
+        }
+        triangles.push_back(triangle);
+    }
+    // Convert vertices to a NumPy array
+    pybind11::array_t<double> vertices_array({static_cast<int>(vertices.size()), 3});
+    auto vertices_buf = vertices_array.mutable_unchecked<2>();
+    for (size_t i = 0; i < vertices.size(); ++i)
+    {
+        vertices_buf(i, 0) = vertices[i][0];
+        vertices_buf(i, 1) = vertices[i][1];
+        vertices_buf(i, 2) = vertices[i][2];
+    }
+    // Convert triangles to a NumPy array
+    pybind11::array_t<int> triangles_array({static_cast<int>(triangles.size()), 3});
+    auto triangles_buf = triangles_array.mutable_unchecked<2>();
+    for (size_t i = 0; i < triangles.size(); ++i)
+    {
+        triangles_buf(i, 0) = triangles[i][0];
+        triangles_buf(i, 1) = triangles[i][1];
+        triangles_buf(i, 2) = triangles[i][2];
+    }
+    // Create NumpyMesh object
+    NumpyMesh result;
+    result.vertices = vertices_array;
+    result.triangles = triangles_array;
+    // Return the NumpyMesh object
+    for (const auto &vertex : _tm.vertices())
+    {
+        const auto &point = _tm.point(vertex);
+    }
+    // Return the NumpyMesh object
+    return result;
+}

loop_cgal-0.0.1/src/clip.h

@@ -0,0 +1,15 @@
+#ifndef CLIP_H
+#define CLIP_H
+#include <pybind11/numpy.h>
+#include "numpymesh.h"
+#include <CGAL/Simple_cartesian.h>
+#include <CGAL/Surface_mesh.h>
+
+typedef CGAL::Simple_cartesian<double> Kernel;
+typedef Kernel::Point_3 Point;
+typedef CGAL::Surface_mesh<Point> TriangleMesh;
+NumpyMesh clip_surface(
+    NumpyMesh tm,
+    NumpyMesh clipper
+);
+#endif

loop_cgal-0.0.1/src/numpymesh.h

@@ -0,0 +1,9 @@
+#ifndef NUMPYMESH_H
+#define NUMPYMESH_H
+#include <pybind11/numpy.h>
+struct NumpyMesh
+{
+    pybind11::array_t<double> vertices;
+    pybind11::array_t<int> triangles;
+};
+#endif // NUMPYMESH_H