PyGEL3D 0.8.0__tar.gz

pygel3d-0.8.0/CMakeLists.txt

@@ -0,0 +1,223 @@
+cmake_minimum_required(VERSION 3.25)
+if(APPLE)
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "11.0" CACHE STRING
+        "Minimum macOS version" FORCE)
+endif()
+file(READ "${CMAKE_CURRENT_SOURCE_DIR}/VERSION" GEL_VERSION)
+string(STRIP "${GEL_VERSION}" GEL_VERSION)
+project(GEL VERSION ${GEL_VERSION} LANGUAGES C CXX)
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+# Default to a user-local prefix so headers and libraries land in
+# ~/.local/{include,lib} without sudo. Override with -DCMAKE_INSTALL_PREFIX.
+if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND NOT WIN32
+        AND DEFINED ENV{HOME} AND NOT "$ENV{HOME}" STREQUAL "")
+    set(CMAKE_INSTALL_PREFIX "$ENV{HOME}/.local" CACHE PATH
+        "Install path prefix, prepended onto install directories." FORCE)
+endif()
+
+find_package(Threads REQUIRED)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    set(CMAKE_OSX_ARCHITECTURES "arm64;x86_64" CACHE STRING "Build architectures for MacOS" FORCE)
+endif ()
+
+option(Use_GLGraphics "Compile the OpenGL Viewer" ON)
+if (Use_GLGraphics)
+    if (UNIX AND NOT APPLE)
+        # libGL.so.1 is a manylinux-allowed driver interface. GLVND's
+        # libOpenGL.so / libGLdispatch.so are not portable in a wheel.
+        set(OpenGL_GL_PREFERENCE "LEGACY" CACHE STRING
+            "Prefer libGL.so.1 over GLVND libOpenGL" FORCE)
+    endif ()
+    find_package(OpenGL REQUIRED)
+    include(FetchContent)
+    set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
+    set(GLFW_INSTALL OFF CACHE BOOL "" FORCE)
+    FetchContent_Declare(
+        glfw
+        GIT_REPOSITORY https://github.com/glfw/glfw.git
+        GIT_TAG 3.3.10
+    )
+    FetchContent_MakeAvailable(glfw)
+    if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+        SET(CMAKE_INSTALL_RPATH "@loader_path/")
+        # SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+    endif ()
+endif ()
+
+# Define the GEL library
+add_library(GEL STATIC)
+add_library(GEL::GEL ALIAS GEL)
+
+target_compile_features(GEL PUBLIC cxx_std_20)
+
+# Consumers include headers as <GEL/HMesh/Manifold.h>, so the include root
+# is src/ in the build tree and ${CMAKE_INSTALL_INCLUDEDIR} after install.
+target_include_directories(GEL
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+# Define source lists for GEL library
+file(GLOB_RECURSE CGLA_SRC_LIST_CPP ./src/GEL/CGLA/*.cpp)
+file(GLOB_RECURSE CGLA_SRC_LIST_C ./src/GEL/CGLA/*.c)
+list(APPEND CGLA_SRC_LIST ${CGLA_SRC_LIST_CPP} ${CGLA_SRC_LIST_C})
+
+file(GLOB_RECURSE GEO_SRC_LIST_CPP ./src/GEL/Geometry/*.cpp)
+file(GLOB_RECURSE GEO_SRC_LIST_C ./src/GEL/Geometry/*.c)
+list(APPEND GEO_SRC_LIST ${GEO_SRC_LIST_CPP} ${GEO_SRC_LIST_C})
+
+file(GLOB_RECURSE MESH_SRC_LIST_CPP ./src/GEL/HMesh/*.cpp)
+file(GLOB_RECURSE MESH_SRC_LIST_C ./src/GEL/HMesh/*.c)
+list(APPEND MESH_SRC_LIST ${MESH_SRC_LIST_CPP} ${MESH_SRC_LIST_C})
+
+file(GLOB_RECURSE UTIL_SRC_LIST_CPP ./src/GEL/Util/*.cpp)
+file(GLOB_RECURSE UTIL_SRC_LIST_C ./src/GEL/Util/*.c)
+list(APPEND UTIL_SRC_LIST ${UTIL_SRC_LIST_CPP} ${UTIL_SRC_LIST_C})
+
+
+# Add source files to GEL library (depending on use of GLGraphics)
+if (Use_GLGraphics)
+    file(GLOB_RECURSE GL_SRC_LIST_CPP ./src/GEL/GL/*.cpp)
+    file(GLOB_RECURSE GL_SRC_LIST_C ./src/GEL/GL/*.c)
+    list(APPEND GL_SRC_LIST ${GL_SRC_LIST_CPP} ${GL_SRC_LIST_C})
+
+    file(GLOB_RECURSE GLG_SRC_LIST_CPP ./src/GEL/GLGraphics/*.cpp)
+    file(GLOB_RECURSE GLG_SRC_LIST_C ./src/GEL/GLGraphics/*.c)
+    list(APPEND GLG_SRC_LIST ${GLG_SRC_LIST_CPP} ${GLG_SRC_LIST_C})
+    target_sources(GEL PRIVATE ${GL_SRC_LIST} ${GLG_SRC_LIST} ${CGLA_SRC_LIST} ${GEO_SRC_LIST} ${MESH_SRC_LIST} ${UTIL_SRC_LIST})
+    target_link_libraries(GEL PUBLIC Threads::Threads OpenGL::GLU OpenGL::GL)
+    if (APPLE)
+        target_link_libraries(GEL PUBLIC "-framework Cocoa")
+        target_compile_definitions(GEL PUBLIC GL_SILENCE_DEPRECATION)
+    endif ()
+    if (NOT APPLE)
+        # Match the previous Linux/Windows GLEW build; consumers that include
+        # <GEL/GL/glew.h> need the same definition.
+        target_compile_definitions(GEL PUBLIC GLEW_STATIC)
+    endif ()
+else ()
+    target_sources(GEL PRIVATE ${CGLA_SRC_LIST} ${GEO_SRC_LIST} ${MESH_SRC_LIST} ${UTIL_SRC_LIST})
+    target_link_libraries(GEL PUBLIC Threads::Threads)
+endif ()
+
+# Locate the sources for PyGEL
+file(GLOB_RECURSE PYG_SRC_LIST ./src/PyGEL/*.cpp)
+
+# Define the PyGEL library. Again two versions depending on use of GLGraphics
+if (Use_GLGraphics)
+    add_library(PyGEL SHARED ${PYG_SRC_LIST})
+    target_include_directories(PyGEL PRIVATE ./src)
+    if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+        target_include_directories(PyGEL PRIVATE ${glfw_SOURCE_DIR}/include)
+    endif ()
+    target_link_libraries(PyGEL PRIVATE GEL glfw ${GLFW_LIBRARIES})
+else ()
+    list(FILTER PYG_SRC_LIST EXCLUDE REGEX ".*/Viewer\\.cpp$")
+    add_library(PyGEL SHARED ${PYG_SRC_LIST})
+    target_include_directories(PyGEL PRIVATE ./src)
+    target_link_libraries(PyGEL PRIVATE GEL)
+endif ()
+
+if (APPLE)
+    set_target_properties(PyGEL PROPERTIES
+        BUILD_RPATH "@loader_path"
+        INSTALL_RPATH "@loader_path"
+        BUILD_WITH_INSTALL_RPATH TRUE)
+elseif (UNIX)
+    set_target_properties(PyGEL PROPERTIES
+        BUILD_RPATH "$ORIGIN"
+        INSTALL_RPATH "$ORIGIN"
+        BUILD_WITH_INSTALL_RPATH TRUE)
+endif ()
+
+# TODO: this one needs to be specifically modified so we do not install it globally, but rather
+# TODO: inside our own directories. It should probably live in include/GEL/Util/phmap
+## Include the parallel-hashmap library
+#include(FetchContent)
+## Our headers depend on it, so we need to it alongside GEL
+#set(PHMAP_INSTALL TRUE CACHE INTERNAL "Install parallel_hashmap")
+#FetchContent_Declare(
+#    parallel-hashmap
+#    GIT_REPOSITORY https://github.com/greg7mdp/parallel-hashmap.git
+#    GIT_TAG        v2.0.0    # adjust tag/branch/commit as needed
+#)
+#FetchContent_MakeAvailable(parallel-hashmap)
+## Pass the directory to GEL during a build
+#target_include_directories(
+#    GEL PUBLIC
+#    $<BUILD_INTERFACE:${parallel-hashmap_SOURCE_DIR}>
+#    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+#    )
+
+
+# ---------------------------------------------------------------------------
+# Install GEL as a CMake package (find_package(GEL))
+# ---------------------------------------------------------------------------
+set(GEL_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/GEL")
+
+install(TARGETS GEL
+    EXPORT GELTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/src/GEL
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    FILES_MATCHING PATTERN "*.h"
+    )
+
+install(EXPORT GELTargets
+    FILE GELTargets.cmake
+    NAMESPACE GEL::
+    DESTINATION ${GEL_INSTALL_CMAKEDIR}
+)
+
+configure_package_config_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/GELConfig.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/GELConfig.cmake"
+    INSTALL_DESTINATION ${GEL_INSTALL_CMAKEDIR}
+)
+
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/GELConfigVersion.cmake"
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+
+install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/GELConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/GELConfigVersion.cmake"
+    DESTINATION ${GEL_INSTALL_CMAKEDIR}
+)
+
+# Also export a build-tree package so find_package(GEL) works with
+# -DCMAKE_PREFIX_PATH=<build-dir> before a full install.
+export(EXPORT GELTargets
+    FILE "${CMAKE_CURRENT_BINARY_DIR}/GELTargets.cmake"
+    NAMESPACE GEL::
+)
+
+# Add test projects
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
+    include(CTest)
+endif()
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING)
+    add_subdirectory(src/test)
+endif()
+
+
+# No install instructions for PyGEL. It is left in the build directory and
+# included in the wheel package.

pygel3d-0.8.0/LICENSE.md

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2025 Andreas Bærentzen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+**Acknowledgment**: Contributions to this project are documented in the CONTRIBUTORS.md file.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+**Note**: This project was previously licensed under a different license that was functionally equivalent to the MIT License. The change to the MIT License was made on February 23, 2025.

pygel3d-0.8.0/MANIFEST.in

@@ -0,0 +1,15 @@
+include VERSION
+include CMakeLists.txt
+include LICENSE.md
+include README.md
+include pyproject.toml
+recursive-include cmake *
+recursive-include src/GEL *
+recursive-include src/PyGEL *.cpp *.h *.py
+
+global-exclude *.pyc
+global-exclude libPyGEL.so libPyGEL.dylib PyGEL.dll
+global-exclude .DS_Store
+prune **/__pycache__
+prune **/.ipynb_checkpoints
+prune **/*.egg-info

pygel3d-0.8.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: PyGEL3D
+Version: 0.8.0
+Summary: PyGEL 3D (Python Bindings for GEL) contains tools for polygonal mesh based geometry processing
+Author-email: Andreas Baerentzen <janba@dtu.dk>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/janba/GEL
+Project-URL: Repository, https://github.com/janba/GEL
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+Requires-Dist: plotly<6,>=5.24.1
+Requires-Dist: scipy
+Dynamic: license-file
+
+# GEL
+GEL is a C++ library of geometry processing tools mostly intended for computer graphics applications. Python bindings for GEL are found in the included PyGEL library which is also available from PyPI under the package name PyGEL3D.
+![inverse skeletonized structure created using diffusion limited aggregation](./doc/teaser.png)
+
+GEL contains 
+- a fairly mature half-edge based polygonal mesh data structure which includes functions for traversing a mesh and a rich library of methods for modifying meshes, 
+- a graph data structure which is also specialized for spatial graphs,
+- voxel grid data structures, 
+- spatial data structures for triangles and points: BSP tree, bounding box hierarchy, and a kD-Tree in particular, 
+- a linear algebra library for small vectors and matrices (2D, 3D, and 4D),
+- tools for visualization based on OpenGL and tools based on Plotly for visualization in Jupyter notebooks, and
+- various utilities.
+
+Unique functionality includes
+- Local Separator Skeletonization: our graph-based skeletonization method that works on both meshes, voxel data, and point clouds, although you need to specify the connectivity for the latter two.
+- Inverse skeletonization: Face extrusion quad meshes (FEQ) from graphs.
+- Rotation System Reconstruction: a combinatorial method for reconstruction from point clouds.
+
+There are several less unique but important features:
+- Garland-Heckbert simplification of triangle meshes, 
+- signed distance field (SDF) computation from triangle meshes, 
+- iso-surface polygonization for regular voxel grids: can produce both dual and primal connectivity, 
+- edge flipping-based optimization for triangle meshes, 
+- mesh smoothing: we include anisotropic smoothing, Taubin smoohing, and more.
+- topological analysis: a single (Python) function splits a mesh into components and analyses each.
+
+GEL requires a recent C++ compiler but has very few dependencies. For visualization, OpenGL and GLFW are required, but these dependencies can be omitted if visualization is not needed. The basic philosophy is that GEL should have few dependencies itself since it is better that projects which use GEL can choose for themselves, say, which linear algebra package to use. 
+
+### PyGEL
+PyGEL is a set of Python bindings for a _subset_ of the features in GEL. In particular, PyGEL covers almost all the mesh features. In addition PyGEL has its own viewer based on OpenGL, and PyGEL can be used from Jupyter notebooks. In this case, it is possible to visualize meshes using a plotly widget. A significant benefit here is that when the notebook is exported to HTML, the 3D view comes along. In fact, this makes PyGEL a useful tool for teaching geometry processing since work can be carried out in a Jupyter notebook and assignments submitted as HTML files. Moreover, PyGEL works in Google [colab](https://colab.research.google.com) notebooks.
+
+## DOCUMENTATION
+Some installation instructions below. But for more documentation please see the doc directory. There is a doxygen script for creating a reference manual and a latex file intro.tex which explains the basics. Please doxygen or pdflatex your documentation. A license is also found in the intro document.
+
+## INSTALLING PYGEL WITH PIP
+
+PyGEL is on PyPI and can be installed with pip. For most potential users, there is no reason to look further than:
+```
+pip install PyGEL3D
+```
+The PyPI package is called PyGEL3D and not PyGEL. pip installs a wheel for your platform:
+
+- Linux x86_64 and ARM64 (manylinux, glibc 2.28+: Ubuntu 20.04, Debian 10, RHEL 8, Fedora, Colab, and similar)
+- macOS 11+ (universal2: Intel and Apple Silicon)
+- 64-bit Windows
+
+The compiled library links against OpenGL (`libGL`). A normal desktop already has this. A minimal Linux system (container, CI, server, Colab) usually does not, and `import pygel3d` will then fail even though pip succeeded.
+
+On Ubuntu/Debian install the OpenGL runtime:
+```
+sudo apt-get install libgl1
+```
+`libgl1` is a virtual package. Apt will pull in whatever implementation the distribution ships — typically Mesa. That is not a request to use software rendering; your GPU driver still provides the actual OpenGL implementation.
+
+On Google Colab, use this as the first cell:
+```
+!apt-get install libgl1
+!pip install PyGEL3D
+```
+If there is no wheel for your platform (for example Alpine/musl), build from source as discussed below.
+
+## BUILDING AND INSTALLING GEL AND PYGEL
+
+If you need or wish to build GEL/PyGEL from source, please download or clone it from [https://github.com/janba/GEL](https://github.com/janba/GEL). Below you will find instructions for how to build and create a package for PyGEL that can be installed via pip. If you look around you will find some other build options for Windows, Mac and Linux. Since GEL is primarily developed on Mac OS, the Xcode projects are actively maintained and cover everything. **The two last build options are not actively maintained**. However, they may prove of some use and hence not removed.
+
+### Building with CMake
+If you are using a unix-like command line, build and install with
+```
+cmake -S . -B build
+cmake --build build -j 8
+cmake --install build
+```
+This installs the GEL library, headers, and a CMake package config into
+`~/.local` (`~/.local/include/GEL`, `~/.local/lib`) so other projects can
+locate GEL with `find_package(GEL)`. No sudo is required. Override the
+location with `-DCMAKE_INSTALL_PREFIX=<prefix>` if needed.
+
+Note that this process is automated by the `build_install.sh` script.
+
+### Using GEL from CMake
+After installing GEL, a consumer project only needs:
+
+```cmake
+find_package(GEL REQUIRED HINTS "$ENV{HOME}/.local")
+target_link_libraries(my_app PRIVATE GEL::GEL)
+```
+
+If GEL is not in `~/.local` or another default search path, point CMake at
+the install (or build) tree:
+
+```
+cmake -S . -B build -DCMAKE_PREFIX_PATH=<gel-install-prefix>
+```
+### Creating a PyGEL3D package and installing it
+From a source checkout, build a **platform** wheel (it compiles `libPyGEL` with CMake and tags the wheel for this OS/architecture):
+```
+python -m build --wheel
+pip install dist/pygel3d-*.whl
+```
+You need CMake ≥ 3.25, a C++20 compiler, and the Python packages `build` and `setuptools`. Isolated builds also pull in the `cmake` and `ninja` packages automatically.
+
+Alternatively,
+```
+pip install .
+```
+or the one-stop script
+```
+sh build_install.sh
+```
+builds GEL, installs the C++ library to `~/.local`, and pip-installs a local PyGEL3D wheel (replacing any previous install).
+
+PyPI releases are produced by GitHub Actions (`.github/workflows/wheels.yml`). Pushing a tag `v*` builds manylinux, macOS, and Windows wheels plus an sdist and publishes them. There is no local step of downloading binaries from CI.
+
+## Compilation of Demos and Tests
+
+GEL comes with some test scripts and also demos. You can find these in `GEL/src/test` and `GEL/src/demo`. Tests are optional and built with the main project when `BUILD_TESTING` is on.
+
+The philosophy behind the demos is that they require GEL and PyGEL3D (for the Python demos) have been installed and do not try to find header files, binaries, or Python packages in the GEL source tree.
+
+In fact, the C++ demos are standalone CMake projects. They call `find_package(GEL)` and therefore expect an installed GEL package rather than a library sitting in the source tree. After a standard install to `~/.local`:
+
+```
+cmake -S src/demo/MeshDistance -B src/demo/MeshDistance/build
+cmake --build src/demo/MeshDistance/build
+```
+
+All C++ demos can also be configured together from `src/demo` and there is a script `run_demos.py` that runs all of them. Since many are interactive, you will frequently need to hit escape or quit a program if you run this script.
+
+
+## Practical Issues
+Compiling both GEL and PyGEL requires that you have OpenGL installed unless you choose not to compile graphics support which you can do by setting `Use_GLGraphics` to `OFF` in the CMake file. GLFW is also needed, but CMake fetches GLFW from github and compiles it along with the GEL code. If you compile in some of the other ways (e.g. using XCode, Visual Studio) there is no simple way to avoid the dependency on graphics libraries. Thus, if you need to avoid the OpenGL requirements, CMake is the way to go.
+
+GEL comes with a few demo applications. In addition to the requirements above, several of these also require GLUT to be installed. Going forward, we should remove the GLUT dependency and move to GLFW for the applications.
+
+PyGEL has a module called `jupyter_display` which produces graphics suitable for Jupyter notebooks. This module is based on `plotly` which must then be installed for it to work. You will also need `numpy`. However, if you use `pip`, these required libraries will be downloaded automatically when you install PyGEL.

pygel3d-0.8.0/README.md

@@ -0,0 +1,135 @@
+# GEL
+GEL is a C++ library of geometry processing tools mostly intended for computer graphics applications. Python bindings for GEL are found in the included PyGEL library which is also available from PyPI under the package name PyGEL3D.
+![inverse skeletonized structure created using diffusion limited aggregation](./doc/teaser.png)
+
+GEL contains 
+- a fairly mature half-edge based polygonal mesh data structure which includes functions for traversing a mesh and a rich library of methods for modifying meshes, 
+- a graph data structure which is also specialized for spatial graphs,
+- voxel grid data structures, 
+- spatial data structures for triangles and points: BSP tree, bounding box hierarchy, and a kD-Tree in particular, 
+- a linear algebra library for small vectors and matrices (2D, 3D, and 4D),
+- tools for visualization based on OpenGL and tools based on Plotly for visualization in Jupyter notebooks, and
+- various utilities.
+
+Unique functionality includes
+- Local Separator Skeletonization: our graph-based skeletonization method that works on both meshes, voxel data, and point clouds, although you need to specify the connectivity for the latter two.
+- Inverse skeletonization: Face extrusion quad meshes (FEQ) from graphs.
+- Rotation System Reconstruction: a combinatorial method for reconstruction from point clouds.
+
+There are several less unique but important features:
+- Garland-Heckbert simplification of triangle meshes, 
+- signed distance field (SDF) computation from triangle meshes, 
+- iso-surface polygonization for regular voxel grids: can produce both dual and primal connectivity, 
+- edge flipping-based optimization for triangle meshes, 
+- mesh smoothing: we include anisotropic smoothing, Taubin smoohing, and more.
+- topological analysis: a single (Python) function splits a mesh into components and analyses each.
+
+GEL requires a recent C++ compiler but has very few dependencies. For visualization, OpenGL and GLFW are required, but these dependencies can be omitted if visualization is not needed. The basic philosophy is that GEL should have few dependencies itself since it is better that projects which use GEL can choose for themselves, say, which linear algebra package to use. 
+
+### PyGEL
+PyGEL is a set of Python bindings for a _subset_ of the features in GEL. In particular, PyGEL covers almost all the mesh features. In addition PyGEL has its own viewer based on OpenGL, and PyGEL can be used from Jupyter notebooks. In this case, it is possible to visualize meshes using a plotly widget. A significant benefit here is that when the notebook is exported to HTML, the 3D view comes along. In fact, this makes PyGEL a useful tool for teaching geometry processing since work can be carried out in a Jupyter notebook and assignments submitted as HTML files. Moreover, PyGEL works in Google [colab](https://colab.research.google.com) notebooks.
+
+## DOCUMENTATION
+Some installation instructions below. But for more documentation please see the doc directory. There is a doxygen script for creating a reference manual and a latex file intro.tex which explains the basics. Please doxygen or pdflatex your documentation. A license is also found in the intro document.
+
+## INSTALLING PYGEL WITH PIP
+
+PyGEL is on PyPI and can be installed with pip. For most potential users, there is no reason to look further than:
+```
+pip install PyGEL3D
+```
+The PyPI package is called PyGEL3D and not PyGEL. pip installs a wheel for your platform:
+
+- Linux x86_64 and ARM64 (manylinux, glibc 2.28+: Ubuntu 20.04, Debian 10, RHEL 8, Fedora, Colab, and similar)
+- macOS 11+ (universal2: Intel and Apple Silicon)
+- 64-bit Windows
+
+The compiled library links against OpenGL (`libGL`). A normal desktop already has this. A minimal Linux system (container, CI, server, Colab) usually does not, and `import pygel3d` will then fail even though pip succeeded.
+
+On Ubuntu/Debian install the OpenGL runtime:
+```
+sudo apt-get install libgl1
+```
+`libgl1` is a virtual package. Apt will pull in whatever implementation the distribution ships — typically Mesa. That is not a request to use software rendering; your GPU driver still provides the actual OpenGL implementation.
+
+On Google Colab, use this as the first cell:
+```
+!apt-get install libgl1
+!pip install PyGEL3D
+```
+If there is no wheel for your platform (for example Alpine/musl), build from source as discussed below.
+
+## BUILDING AND INSTALLING GEL AND PYGEL
+
+If you need or wish to build GEL/PyGEL from source, please download or clone it from [https://github.com/janba/GEL](https://github.com/janba/GEL). Below you will find instructions for how to build and create a package for PyGEL that can be installed via pip. If you look around you will find some other build options for Windows, Mac and Linux. Since GEL is primarily developed on Mac OS, the Xcode projects are actively maintained and cover everything. **The two last build options are not actively maintained**. However, they may prove of some use and hence not removed.
+
+### Building with CMake
+If you are using a unix-like command line, build and install with
+```
+cmake -S . -B build
+cmake --build build -j 8
+cmake --install build
+```
+This installs the GEL library, headers, and a CMake package config into
+`~/.local` (`~/.local/include/GEL`, `~/.local/lib`) so other projects can
+locate GEL with `find_package(GEL)`. No sudo is required. Override the
+location with `-DCMAKE_INSTALL_PREFIX=<prefix>` if needed.
+
+Note that this process is automated by the `build_install.sh` script.
+
+### Using GEL from CMake
+After installing GEL, a consumer project only needs:
+
+```cmake
+find_package(GEL REQUIRED HINTS "$ENV{HOME}/.local")
+target_link_libraries(my_app PRIVATE GEL::GEL)
+```
+
+If GEL is not in `~/.local` or another default search path, point CMake at
+the install (or build) tree:
+
+```
+cmake -S . -B build -DCMAKE_PREFIX_PATH=<gel-install-prefix>
+```
+### Creating a PyGEL3D package and installing it
+From a source checkout, build a **platform** wheel (it compiles `libPyGEL` with CMake and tags the wheel for this OS/architecture):
+```
+python -m build --wheel
+pip install dist/pygel3d-*.whl
+```
+You need CMake ≥ 3.25, a C++20 compiler, and the Python packages `build` and `setuptools`. Isolated builds also pull in the `cmake` and `ninja` packages automatically.
+
+Alternatively,
+```
+pip install .
+```
+or the one-stop script
+```
+sh build_install.sh
+```
+builds GEL, installs the C++ library to `~/.local`, and pip-installs a local PyGEL3D wheel (replacing any previous install).
+
+PyPI releases are produced by GitHub Actions (`.github/workflows/wheels.yml`). Pushing a tag `v*` builds manylinux, macOS, and Windows wheels plus an sdist and publishes them. There is no local step of downloading binaries from CI.
+
+## Compilation of Demos and Tests
+
+GEL comes with some test scripts and also demos. You can find these in `GEL/src/test` and `GEL/src/demo`. Tests are optional and built with the main project when `BUILD_TESTING` is on.
+
+The philosophy behind the demos is that they require GEL and PyGEL3D (for the Python demos) have been installed and do not try to find header files, binaries, or Python packages in the GEL source tree.
+
+In fact, the C++ demos are standalone CMake projects. They call `find_package(GEL)` and therefore expect an installed GEL package rather than a library sitting in the source tree. After a standard install to `~/.local`:
+
+```
+cmake -S src/demo/MeshDistance -B src/demo/MeshDistance/build
+cmake --build src/demo/MeshDistance/build
+```
+
+All C++ demos can also be configured together from `src/demo` and there is a script `run_demos.py` that runs all of them. Since many are interactive, you will frequently need to hit escape or quit a program if you run this script.
+
+
+## Practical Issues
+Compiling both GEL and PyGEL requires that you have OpenGL installed unless you choose not to compile graphics support which you can do by setting `Use_GLGraphics` to `OFF` in the CMake file. GLFW is also needed, but CMake fetches GLFW from github and compiles it along with the GEL code. If you compile in some of the other ways (e.g. using XCode, Visual Studio) there is no simple way to avoid the dependency on graphics libraries. Thus, if you need to avoid the OpenGL requirements, CMake is the way to go.
+
+GEL comes with a few demo applications. In addition to the requirements above, several of these also require GLUT to be installed. Going forward, we should remove the GLUT dependency and move to GLFW for the applications.
+
+PyGEL has a module called `jupyter_display` which produces graphics suitable for Jupyter notebooks. This module is based on `plotly` which must then be installed for it to work. You will also need `numpy`. However, if you use `pip`, these required libraries will be downloaded automatically when you install PyGEL.

pygel3d-0.8.0/VERSION

@@ -0,0 +1 @@
+0.8.0

pygel3d-0.8.0/cmake/GELConfig.cmake.in

@@ -0,0 +1,13 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+# GEL PUBLIC-links these, so consumers need the same imported targets.
+find_dependency(Threads)
+if(@Use_GLGraphics@)
+    find_dependency(OpenGL)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/GELTargets.cmake")
+
+check_required_components(GEL)

pygel3d-0.8.0/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["setuptools>=77", "cmake>=3.25", "ninja"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PyGEL3D"
+dynamic = ["version"]
+description = "PyGEL 3D (Python Bindings for GEL) contains tools for polygonal mesh based geometry processing"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE.md"]
+authors = [
+    {name = "Andreas Baerentzen", email = "janba@dtu.dk"},
+]
+dependencies = [
+    "numpy",
+    "plotly>=5.24.1,<6",
+    "scipy",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+]
+
+[project.urls]
+Homepage = "https://github.com/janba/GEL"
+Repository = "https://github.com/janba/GEL"
+
+[tool.setuptools]
+# Do not pull package-data from MANIFEST.in: that file excludes the native
+# library from the sdist (it is compiled during the wheel build).
+include-package-data = false
+
+[tool.setuptools.dynamic]
+version = {file = "VERSION"}
+
+[tool.setuptools.packages.find]
+where = ["src/PyGEL"]
+include = ["pygel3d*"]
+
+[tool.cibuildwheel]
+# ctypes library: one py3-none-<platform> wheel, tested on each CPython.
+build = ["cp311-*", "cp312-*", "cp313-*", "cp314-*"]
+skip = ["pp*", "cp3??t-*", "*-win32", "*-win_arm64", "*_i686", "*musllinux*"]
+build-verbosity = 1
+test-command = "python {project}/tools/cibw_smoke.py"
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+before-all = "dnf install -y mesa-libGL-devel mesa-libGLU-devel libX11-devel libXcursor-devel libXi-devel libXinerama-devel libXrandr-devel libXxf86vm-devel libXfixes-devel libXrender-devel"
+# Vendor X11 helpers and libGLU; libGL must come from the system/driver.
+repair-wheel-command = "auditwheel repair --exclude libGL.so.1 -w {dest_dir} {wheel}"
+
+[tool.cibuildwheel.macos]
+archs = ["universal2"]
+environment = { MACOSX_DEPLOYMENT_TARGET = "11.0" }
+
+[tool.cibuildwheel.windows]
+# delvewheel (cibuildwheel default) bundles extra DLLs; OpenGL32/glu32 stay system.

pygel3d-0.8.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+