PyGEL3D 0.8.0__py3-none-win_amd64.whl

pygel3d/__init__.py

@@ -0,0 +1,389 @@
+""" PyGEL is a collection of classes and functions for geometry processing tasks. 
+Especially tasks that involve 3D polygonal meshes, but there is also a graph component 
+useful e.g. for skeletonization. The PyGEL package is called pygel3d and it contains 
+five modules:
+
+hmesh provides Manifold which is a class that represents polygonal meshes using the
+halfedge representation. hmesh also provides a slew of functions for manipulating
+polygonal meshes and the MeshDistance class which makes it simple to compute the
+distance to a triangle mesh.
+
+graph contains the Graph class which is used for graphs: i.e. collections of
+vertices (in 3D) connected by edges. Unlike a Manifold, a Graph does not have to
+represent a surface. There are also some associated functions which may be useful:
+in particular, there is the LS_skeleton function which computes a curve skeleton
+from a Graph and returns the result as a new Graph.
+
+gl_display provides the Viewer class which makes it simple to visualize meshes and
+graphs.
+
+jupyter_display makes it easy to use PyGEL in the context of a Jupyter Notebook.
+This module contains a function that allows you to create a widget for interactively
+visualizing a mesh or a graph in a Notebook. The feature is based on the Plotly
+library and it is possible to export the resulting notebooks to HTML while preserving
+the interactive 3D graphics in the notebook.
+
+spatial contains the I3DTree class which is simply a kD-tree specialized for mapping
+3D points to integers - typically indices. Of course, scipy.spatial has a more
+generic class, so this is perhaps not the most important part of PyGEL.
+
+PyGEL is based on the C++ GEL library and provides a Python interface for most but not
+all of the functionality of GEL. 
+"""
+def _read_version():
+    from pathlib import Path
+    for parent in list(Path(__file__).resolve().parents)[:6]:
+        vf = parent / "VERSION"
+        if vf.is_file():
+            return vf.read_text(encoding="utf-8").strip()
+    try:
+        from importlib.metadata import version as _pkg_version
+        return _pkg_version("PyGEL3D")
+    except Exception:
+        return "0.0.0"
+
+__version__ = _read_version()
+
+__all__ = ["hmesh", "graph", "gl_display", "jupyter_display", "spatial", "experimental"]
+
+import os
+from sys import platform, prefix
+import ctypes as ct
+import numpy as np
+from numpy.ctypeslib import ndpointer
+
+def _get_script_path():
+    return os.path.dirname(__file__)
+
+def _get_lib_name():
+    if platform == "darwin":
+        return "libPyGEL.dylib"
+    if platform == "win32":
+        return "PyGEL.dll"
+    return "libPyGEL.so"
+
+def _load_library():
+    name = _get_lib_name()
+    path = os.path.join(_get_script_path(), name)
+    if not os.path.isfile(path):
+        raise ImportError(
+            f"pygel3d: native library {name} not found at {path}. "
+            "Reinstall from PyPI (`pip install --force-reinstall PyGEL3D`) "
+            "or build from source."
+        )
+    try:
+        return ct.cdll.LoadLibrary(path)
+    except OSError as exc:
+        hint = ""
+        if platform.startswith("linux"):
+            hint = (
+                " On Linux the library needs system OpenGL "
+                "(e.g. `sudo apt-get install libgl1`)."
+            )
+        raise ImportError(
+            f"pygel3d: failed to load {path}: {exc}.{hint}"
+        ) from exc
+
+# Load PyGEL the Python GEL bridge library
+lib_py_gel = _load_library()
+
+# An InvalidIndex is just a special integer value.
+InvalidIndex = ct.c_size_t.in_dll(lib_py_gel, "InvalidIndex").value
+
+# The following many lines explitize the arguments and return types of the C API
+
+# IntVector
+lib_py_gel.IntVector_new.restype = ct.c_void_p
+lib_py_gel.IntVector_get.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.IntVector_size.argtypes = (ct.c_void_p,)
+lib_py_gel.IntVector_size.restype = ct.c_size_t
+lib_py_gel.IntVector_delete.argtypes = (ct.c_void_p,)
+
+
+# Vec3dVector
+lib_py_gel.Vec3dVector_new.restype = ct.c_void_p
+lib_py_gel.Vec3dVector_get.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Vec3dVector_get.restype = ct.POINTER(ct.c_double)
+lib_py_gel.Vec3dVector_size.argtypes = (ct.c_void_p,)
+lib_py_gel.Vec3dVector_size.restype = ct.c_size_t
+lib_py_gel.Vec3dVector_delete.argtypes = (ct.c_void_p,)
+
+# I3DTree
+lib_py_gel.I3DTree_new.restype = ct.c_void_p
+lib_py_gel.I3DTree_delete.argtypes = (ct.c_void_p,)
+lib_py_gel.I3DTree_insert.argtypes = (ct.c_void_p, ct.c_double, ct.c_double, ct.c_double, ct.c_size_t)
+lib_py_gel.I3DTree_build.argtypes = (ct.c_void_p,)
+lib_py_gel.I3DTree_closest_point.argtypes = (ct.c_void_p, ct.c_double, ct.c_double, ct.c_double, ct.c_double, ct.POINTER(ct.c_double*3), ct.POINTER(ct.c_size_t))
+lib_py_gel.I3DTree_in_sphere.argtypes = (ct.c_void_p, ct.c_double, ct.c_double, ct.c_double, ct.c_double, ct.c_void_p,ct.c_void_p)
+
+# Manifold class
+lib_py_gel.Manifold_from_triangles.argtypes = (ct.c_size_t,ct.c_size_t, ndpointer(np.float64, ndim=2, flags='C'), ndpointer(ct.c_int, ndim=2, flags='C'))
+lib_py_gel.Manifold_from_triangles.restype = ct.c_void_p
+lib_py_gel.Manifold_from_points.argtypes = (ct.c_size_t,ndpointer(np.float64, ndim=2, flags='C'), ndpointer(np.float64, shape=3),ndpointer(np.float64, shape=3))
+lib_py_gel.Manifold_from_points.restype = ct.c_void_p
+lib_py_gel.Manifold_new.restype = ct.c_void_p
+lib_py_gel.Manifold_copy.restype = ct.c_void_p
+lib_py_gel.Manifold_copy.argtypes = (ct.c_void_p,)
+lib_py_gel.Manifold_merge.argtypes = (ct.c_void_p,ct.c_void_p)
+lib_py_gel.Manifold_delete.argtypes = (ct.c_void_p,)
+lib_py_gel.Manifold_positions.restype = ct.c_size_t
+lib_py_gel.Manifold_positions.argtypes = (ct.c_void_p, ct.POINTER(ct.POINTER(ct.c_double)))
+lib_py_gel.Manifold_no_allocated_vertices.restype = ct.c_size_t
+lib_py_gel.Manifold_no_allocated_vertices.argtypes = (ct.c_void_p,)
+lib_py_gel.Manifold_no_allocated_faces.restype = ct.c_size_t
+lib_py_gel.Manifold_no_allocated_faces.argtypes = (ct.c_void_p,)
+lib_py_gel.Manifold_no_allocated_halfedges.restype = ct.c_size_t
+lib_py_gel.Manifold_no_allocated_halfedges.argtypes = (ct.c_void_p,)
+lib_py_gel.Manifold_vertices.restype = ct.c_size_t
+lib_py_gel.Manifold_vertices.argtypes = (ct.c_void_p, ct.c_void_p)
+lib_py_gel.Manifold_faces.restype = ct.c_size_t
+lib_py_gel.Manifold_faces.argtypes = (ct.c_void_p, ct.c_void_p)
+lib_py_gel.Manifold_halfedges.restype = ct.c_size_t
+lib_py_gel.Manifold_halfedges.argtypes = (ct.c_void_p,ct.c_void_p)
+lib_py_gel.Manifold_circulate_vertex.restype = ct.c_size_t
+lib_py_gel.Manifold_circulate_vertex.argtypes = (ct.c_void_p, ct.c_size_t, ct.c_char, ct.c_void_p)
+lib_py_gel.Manifold_circulate_face.restype = ct.c_size_t
+lib_py_gel.Manifold_circulate_face.argtypes = (ct.c_void_p, ct.c_size_t, ct.c_char, ct.c_void_p)
+lib_py_gel.Manifold_add_face.argtypes = (ct.c_void_p, ct.c_size_t, ndpointer(np.float64, ndim=2, flags='C'))
+lib_py_gel.Manifold_remove_face.restype = ct.c_bool
+lib_py_gel.Manifold_remove_face.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Manifold_remove_edge.restype = ct.c_bool
+lib_py_gel.Manifold_remove_edge.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Manifold_remove_vertex.restype = ct.c_bool
+lib_py_gel.Manifold_remove_vertex.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Manifold_vertex_in_use.restype = ct.c_bool
+lib_py_gel.Manifold_vertex_in_use.argtypes = (ct.c_void_p,ct.c_size_t)
+lib_py_gel.Manifold_face_in_use.restype = ct.c_bool
+lib_py_gel.Manifold_face_in_use.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Manifold_halfedge_in_use.restype = ct.c_bool
+lib_py_gel.Manifold_halfedge_in_use.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Manifold_flip_edge.restype =  ct.c_bool
+lib_py_gel.Manifold_flip_edge.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Manifold_collapse_edge.restype = ct.c_bool
+lib_py_gel.Manifold_collapse_edge.argtypes = (ct.c_void_p,ct.c_size_t,ct.c_bool)
+lib_py_gel.Manifold_split_face_by_edge.restype = ct.c_size_t
+lib_py_gel.Manifold_split_face_by_edge.argtypes = (ct.c_void_p, ct.c_size_t,ct.c_size_t,ct.c_size_t)
+lib_py_gel.Manifold_split_face_by_vertex.restype = ct.c_size_t
+lib_py_gel.Manifold_split_face_by_vertex.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Manifold_split_edge.restype = ct.c_size_t
+lib_py_gel.Manifold_split_edge.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Manifold_stitch_boundary_edges.restype = ct.c_bool
+lib_py_gel.Manifold_stitch_boundary_edges.argtypes = (ct.c_void_p, ct.c_size_t,ct.c_size_t)
+lib_py_gel.Manifold_merge_faces.restype = ct.c_bool
+lib_py_gel.Manifold_merge_faces.argtypes = (ct.c_void_p, ct.c_size_t,ct.c_size_t)
+lib_py_gel.Manifold_close_hole.argtypes = (ct.c_void_p,ct.c_size_t)
+lib_py_gel.Manifold_cleanup.argtypes = (ct.c_void_p,)
+
+
+# Walker is a helper class assisting us in navigating a mesh.
+# Not directly expose in PyGEL3D
+lib_py_gel.Walker_next_halfedge.restype = ct.c_size_t
+lib_py_gel.Walker_next_halfedge.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Walker_prev_halfedge.restype = ct.c_size_t
+lib_py_gel.Walker_prev_halfedge.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Walker_opposite_halfedge.restype = ct.c_size_t
+lib_py_gel.Walker_opposite_halfedge.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Walker_incident_face.restype = ct.c_size_t
+lib_py_gel.Walker_incident_face.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Walker_incident_vertex.restype = ct.c_size_t
+lib_py_gel.Walker_incident_vertex.argtypes = (ct.c_void_p, ct.c_size_t)
+
+# A list of helper functions
+lib_py_gel.is_halfedge_at_boundary.restype = ct.c_bool
+lib_py_gel.is_halfedge_at_boundary.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.is_vertex_at_boundary.restype = ct.c_bool
+lib_py_gel.is_vertex_at_boundary.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.length.restype = ct.c_double
+lib_py_gel.length.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.boundary_edge.restype = ct.c_bool
+lib_py_gel.boundary_edge.argtypes = (ct.c_void_p, ct.c_size_t, ct.c_size_t)
+lib_py_gel.valency.restype = ct.c_size_t
+lib_py_gel.valency.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.vertex_normal.argtypes = (ct.c_void_p, ct.c_size_t, ndpointer(dtype=np.float64, shape=(3,)))
+lib_py_gel.connected.restype = ct.c_bool
+lib_py_gel.connected.argtypes = (ct.c_void_p, ct.c_size_t, ct.c_size_t)
+lib_py_gel.no_edges.restype = ct.c_size_t
+lib_py_gel.no_edges.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.face_normal.argtypes = (ct.c_void_p, ct.c_size_t, ndpointer(dtype=np.float64, shape=(3,)))
+lib_py_gel.area.restype = ct.c_double
+lib_py_gel.area.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.one_ring_area.restype = ct.c_double
+lib_py_gel.one_ring_area.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.mixed_area.restype = ct.c_double
+lib_py_gel.mixed_area.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.gaussian_curvature.restype = ct.c_double
+lib_py_gel.gaussian_curvature.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.mean_curvature.restype = ct.c_double
+lib_py_gel.mean_curvature.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.principal_curvatures.argtypes = (ct.c_void_p, ct.c_size_t, ndpointer(dtype=np.float64, shape=(8,)))
+
+
+lib_py_gel.total_area.restype = ct.c_double
+lib_py_gel.total_area.argtypes = (ct.c_void_p,)
+lib_py_gel.volume.restype = ct.c_double
+lib_py_gel.volume.argtypes = (ct.c_void_p,)
+lib_py_gel.perimeter.restype = ct.c_double
+lib_py_gel.perimeter.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.centre.argtypes = (ct.c_void_p, ct.c_size_t, ndpointer(dtype=np.float64, shape=(3,)))
+lib_py_gel.valid.restype = ct.c_bool
+lib_py_gel.valid.argtypes = (ct.c_void_p,)
+lib_py_gel.closed.restype = ct.c_bool
+lib_py_gel.closed.argtypes = (ct.c_void_p,)
+lib_py_gel.bbox.argtypes = (ct.c_void_p, ndpointer(dtype=np.float64, shape=(3,)),ndpointer(dtype=np.float64, shape=(3,)))
+lib_py_gel.bsphere.argtypes = (ct.c_void_p, ndpointer(dtype=np.float64, shape=(3,)), ct.POINTER(ct.c_double))
+lib_py_gel.stitch_mesh.argtypes = (ct.c_void_p,ct.c_double)
+lib_py_gel.stitch_mesh.restype = ct.c_int
+lib_py_gel.obj_save.argtypes = (ct.c_char_p, ct.c_void_p)
+lib_py_gel.off_save.argtypes = (ct.c_char_p, ct.c_void_p)
+lib_py_gel.x3d_save.argtypes = (ct.c_char_p, ct.c_void_p)
+lib_py_gel.obj_load.argtypes = (ct.c_char_p, ct.c_void_p)
+lib_py_gel.off_load.argtypes = (ct.c_char_p, ct.c_void_p)
+lib_py_gel.ply_load.argtypes = (ct.c_char_p, ct.c_void_p)
+lib_py_gel.x3d_load.argtypes = (ct.c_char_p, ct.c_void_p)
+lib_py_gel.rsr_recon.argtypes = (ct.c_void_p, ndpointer(ndim=2, dtype=ct.c_double,flags='F'), ndpointer(ndim=2, dtype=ct.c_double,flags='F'), ct.c_int, ct.c_int, ct.c_bool, ct.c_int, ct.c_int, ct.c_double, ct.c_double, ct.c_int)
+lib_py_gel.hrsr_recon.argtypes = (ct.c_void_p, ndpointer(ndim=2, dtype=ct.c_double,flags='F'), ndpointer(ndim=2, dtype=ct.c_double,flags='F'), ct.c_size_t, ct.c_size_t, ct.c_int, ct.c_bool, ct.c_int, ct.c_int, ct.c_double, ct.c_double, ct.c_int, ct.c_bool)
+lib_py_gel.remove_caps.argtypes = (ct.c_void_p, ct.c_float)
+lib_py_gel.remove_needles.argtypes = (ct.c_void_p, ct.c_float, ct.c_bool)
+lib_py_gel.close_holes.argtypes = (ct.c_void_p,ct.c_int)
+lib_py_gel.flip_orientation.argtypes = (ct.c_void_p,)
+lib_py_gel.merge_coincident_boundary_vertices.argtypes = (ct.c_void_p, ct.c_double)
+lib_py_gel.minimize_curvature.argtypes = (ct.c_void_p,ct.c_bool)
+lib_py_gel.minimize_dihedral_angle.argtypes = (ct.c_void_p, ct.c_int, ct.c_bool, ct.c_bool, ct.c_double)
+lib_py_gel.maximize_min_angle.argtypes = (ct.c_void_p,ct.c_float,ct.c_bool)
+lib_py_gel.optimize_valency.argtypes = (ct.c_void_p,ct.c_bool)
+lib_py_gel.randomize_mesh.argtypes = (ct.c_void_p,ct.c_int)
+lib_py_gel.quadric_simplify.argtypes = (ct.c_void_p,ct.c_double,ct.c_double,ct.c_double)
+lib_py_gel.average_edge_length.argtypes = (ct.c_void_p,)
+lib_py_gel.average_edge_length.restype = ct.c_float
+lib_py_gel.median_edge_length.argtypes = (ct.c_void_p,)
+lib_py_gel.median_edge_length.restype = ct.c_float
+lib_py_gel.refine_edges.argtypes = (ct.c_void_p,ct.c_float)
+lib_py_gel.refine_edges.restype = ct.c_int
+lib_py_gel.cc_split.argtypes = (ct.c_void_p,)
+lib_py_gel.loop_split.argtypes = (ct.c_void_p,)
+lib_py_gel.root3_subdivide.argtypes = (ct.c_void_p,)
+lib_py_gel.rootCC_subdivide.argtypes = (ct.c_void_p,)
+lib_py_gel.butterfly_subdivide.argtypes = (ct.c_void_p,)
+lib_py_gel.cc_smooth.argtypes = (ct.c_void_p,)
+lib_py_gel.volume_preserving_cc_smooth.argtypes = (ct.c_void_p,ct.c_int)
+lib_py_gel.regularize_quads.argtypes = (ct.c_void_p,ct.c_float,ct.c_float,ct.c_int)
+lib_py_gel.loop_smooth.argtypes = (ct.c_void_p,)
+lib_py_gel.ear_clip_triangulate.argtypes = (ct.c_void_p,)
+lib_py_gel.shortest_edge_triangulate.argtypes = (ct.c_void_p,)
+lib_py_gel.graph_to_feq.argtypes = (ct.c_void_p, ct.c_void_p, ndpointer(dtype=np.float64, ndim=1), ct.c_bool, ct.c_bool)
+lib_py_gel.graph_to_feq.restype = ct.c_void_p
+lib_py_gel.non_rigid_registration.argtypes = (ct.c_void_p, ct.c_void_p)
+lib_py_gel.taubin_smooth.argtypes = (ct.c_void_p, ct.c_int)
+lib_py_gel.laplacian_smooth.argtypes = (ct.c_void_p, ct.c_float, ct.c_int)
+lib_py_gel.anisotropic_smooth.argtypes = (ct.c_void_p, ct.c_float, ct.c_int)
+lib_py_gel.volumetric_isocontour.argtypes = (ct.c_void_p, ct.c_int, ct.c_int, ct.c_int, ndpointer(ndim=3, dtype=ct.c_float,flags='F'), ndpointer(dtype=ct.c_double,shape=(3,)), ndpointer(dtype=ct.c_double,shape=(3,)), ct.c_float, ct.c_bool, ct.c_bool, ct.c_bool )
+lib_py_gel.extrude_faces.argtypes = (ct.c_void_p, ndpointer(dtype=ct.c_int, ndim=1), ct.c_int, ct.c_void_p)
+lib_py_gel.kill_face_loop.argtypes = (ct.c_void_p,)
+lib_py_gel.kill_degenerate_face_loops.argtypes = (ct.c_void_p,ct.c_double)
+lib_py_gel.stable_marriage_registration.argtypes = (ct.c_void_p,ct.c_void_p)
+lib_py_gel.stable_marriage_registration.restype = ct.c_int
+lib_py_gel.connected_components.argtypes = (ct.c_void_p,)
+lib_py_gel.connected_components.restype = ct.c_void_p
+lib_py_gel.mesh_vec_size.argtypes = (ct.c_void_p,)
+lib_py_gel.mesh_vec_size.restype = ct.c_size_t
+lib_py_gel.mesh_vec_get.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.mesh_vec_get.restype = ct.c_void_p
+lib_py_gel.mesh_vec_del.argtypes = (ct.c_void_p,)
+lib_py_gel.count_boundary_curves.argtypes = (ct.c_void_p,)
+lib_py_gel.count_boundary_curves.restype = ct.c_int
+lib_py_gel.sphere_delaunay.argtypes = (ct.c_void_p, ndpointer(dtype=ct.c_double, flags='C'), ct.c_int)
+lib_py_gel.sphere_delaunay.restype = ct.c_void_p
+
+# MeshDistance allows us to compute the signed distance to a mesh
+lib_py_gel.MeshDistance_new.restype = ct.c_void_p
+lib_py_gel.MeshDistance_new.argtypes = (ct.c_void_p,)
+lib_py_gel.MeshDistance_signed_distance.argtypes = (ct.c_void_p,ct.c_int, ndpointer(dtype=ct.c_float,flags='C'),ndpointer(dtype=ct.c_float,flags='C',ndim=1),ct.c_float)
+lib_py_gel.MeshDistance_ray_inside_test.argtypes = (ct.c_void_p,ct.c_int, ndpointer(dtype=ct.c_float,flags='C'),ndpointer(dtype=ct.c_int,flags='C',ndim=1),ct.c_int)
+lib_py_gel.MeshDistance_ray_intersect.argtypes = (ct.c_void_p,ndpointer(dtype=ct.c_float,shape=3),ndpointer(dtype=ct.c_float,shape=3),ct.POINTER(ct.c_float))
+lib_py_gel.MeshDistance_ray_intersect.restype = ct.c_bool
+lib_py_gel.MeshDistance_delete.argtypes = (ct.c_void_p,)
+
+# The Graph class
+lib_py_gel.Graph_new.restype = ct.c_void_p
+lib_py_gel.Graph_copy.restype = ct.c_void_p
+lib_py_gel.Graph_copy.argtypes = (ct.c_void_p,)
+lib_py_gel.Graph_delete.argtypes = (ct.c_void_p,)
+lib_py_gel.Graph_clear.argtypes = (ct.c_void_p,)
+lib_py_gel.Graph_cleanup.argtypes = (ct.c_void_p,)
+lib_py_gel.Graph_nodes.argtypes = (ct.c_void_p, ct.c_void_p)
+lib_py_gel.Graph_nodes.restype = ct.c_size_t
+lib_py_gel.Graph_neighbors.restype = ct.c_size_t
+lib_py_gel.Graph_neighbors.argtypes = (ct.c_void_p, ct.c_size_t, ct.c_void_p, ct.c_char)
+lib_py_gel.Graph_positions.argtypes = (ct.c_void_p,ct.POINTER(ct.POINTER(ct.c_double)))
+lib_py_gel.Graph_positions.restype = ct.c_size_t
+lib_py_gel.Graph_average_edge_length.argtypes = (ct.c_void_p,)
+lib_py_gel.Graph_average_edge_length.restype = ct.c_double
+lib_py_gel.Graph_add_node.argtypes = (ct.c_void_p, ndpointer(ct.c_double))
+lib_py_gel.Graph_add_node.restype = ct.c_size_t
+lib_py_gel.Graph_remove_node.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Graph_node_in_use.argtypes = (ct.c_void_p, ct.c_size_t)
+lib_py_gel.Graph_node_in_use.restype = ct.c_bool
+lib_py_gel.Graph_connect_nodes.argtypes = (ct.c_void_p, ct.c_size_t, ct.c_size_t)
+lib_py_gel.Graph_connect_nodes.restype = ct.c_size_t
+lib_py_gel.Graph_disconnect_nodes.argtypes = (ct.c_void_p, ct.c_size_t, ct.c_size_t)
+lib_py_gel.Graph_merge_nodes.argtypes = (ct.c_void_p, ct.c_size_t, ct.c_size_t, ct.c_bool)
+
+# Graph functions
+lib_py_gel.graph_from_mesh.argtypes = (ct.c_void_p, ct.c_void_p)
+lib_py_gel.graph_load.argtypes = (ct.c_void_p, ct.c_char_p)
+lib_py_gel.graph_load.restype = ct.c_void_p
+lib_py_gel.graph_save.argtypes = (ct.c_void_p, ct.c_char_p)
+lib_py_gel.graph_save.restype = ct.c_bool
+lib_py_gel.graph_to_mesh_cyl.argtypes = (ct.c_void_p, ct.c_void_p, ct.c_float)
+lib_py_gel.graph_to_mesh_cyl.restype = ct.c_void_p
+lib_py_gel.graph_to_mesh_iso.argtypes = (ct.c_void_p, ct.c_void_p, ct.c_float, ct.c_int)
+lib_py_gel.graph_to_mesh_iso.restype = ct.c_void_p
+lib_py_gel.graph_smooth.argtypes = (ct.c_void_p, ct.c_int, ct.c_float)
+lib_py_gel.graph_edge_contract.argtypes = (ct.c_void_p, ct.c_double)
+lib_py_gel.graph_prune.argtypes = (ct.c_void_p,)
+lib_py_gel.graph_saturate.argtypes = (ct.c_void_p, ct.c_int, ct.c_double, ct.c_double)
+lib_py_gel.graph_LS_skeleton.argtypes = (ct.c_void_p, ct.c_void_p, ct.c_void_p, ct.c_bool)
+lib_py_gel.graph_MSLS_skeleton.argtypes = (ct.c_void_p, ct.c_void_p, ct.c_void_p, ct.c_int)
+lib_py_gel.graph_front_skeleton.argtypes = (ct.c_void_p, ct.c_void_p, ct.c_void_p, ct.c_int, ndpointer(dtype=np.float64,flags='C'), ct.c_int)
+lib_py_gel.graph_combined_skeleton.argtypes = (ct.c_void_p, ct.c_void_p, ct.c_void_p, ct.c_int, ndpointer(dtype=np.float64,flags='C'), ct.c_int)
+lib_py_gel.graph_minimum_spanning_tree.argtypes = (ct.c_void_p, ct.c_void_p, ct.c_int)
+lib_py_gel.graph_close_chordless_cycles.argtypes = (ct.c_void_p, ct.c_int, ct.c_int, ct.c_double)
+
+class IntVector:
+    """ Vector of integer values.
+    This is a simple class that implements iteration and index based
+    retrieval. Allocation happens in a call to libPyGEL. Since memory
+    is managed by the PyGEL library, the vector can be resized by library
+    functions. Not used directly by PyGEL3D users."""
+    def __init__(self):
+        self.obj = lib_py_gel.IntVector_new(0)
+    def __del__(self):
+        lib_py_gel.IntVector_delete(self.obj)
+    def __len__(self):
+        return int(lib_py_gel.IntVector_size(self.obj))
+    def __getitem__(self, key: int):
+        return lib_py_gel.IntVector_get(self.obj,key)
+    def __iter__(self):
+        n = lib_py_gel.IntVector_size(self.obj)
+        for i in range(0,n):
+            yield lib_py_gel.IntVector_get(self.obj, i)
+
+class Vec3dVector:
+    """ Vector of 3D vectors.
+    This is a simple class that implements iteration and index based
+    retrieval. Allocation happens in a call to libPyGEL. Since memory
+    is managed by the PyGEL library, the vector can be resized by library
+    functions. Not used directly by PyGEL3D users."""
+    def __init__(self):
+        self.obj = lib_py_gel.Vec3dVector_new(0)
+    def __del__(self):
+        lib_py_gel.Vec3dVector_delete(self.obj)
+    def __len__(self):
+        return int(lib_py_gel.Vec3dVector_size(self.obj))
+    def __getitem__(self,key: int):
+        return lib_py_gel.Vec3dVector_get(self.obj,key)
+    def __iter__(self):
+        n = lib_py_gel.Vec3dVector_size(self.obj)
+        for i in range(0,n):
+            data = lib_py_gel.Vec3dVector_get(self.obj, i)
+            yield [data[0], data[1], data[2]]

pygel3d/experimental/__init__.py

@@ -0,0 +1 @@
+__all__ = ["hmesh"]

pygel3d/experimental/hmesh.py

@@ -0,0 +1,32 @@
+import numpy as np
+import ctypes as ct
+from numpy.typing import ArrayLike
+from pygel3d.hmesh import Manifold, _as_vec3_f
+from pygel3d import lib_py_gel
+
+def rsr_recon(verts: ArrayLike,
+              normals: ArrayLike=None,
+              use_Euclidean_distance: bool=False,
+              genus: int=-1,
+              k: int=70,
+              r: float=20,
+              theta: float=60,
+              n: int=50) -> Manifold:
+    """ RsR Reconstruction. The first argument, verts, is the point cloud. The next argument,
+        normals, are the normals associated with the vertices or empty list (default) if normals
+        need to be estimated during reconstruction. use_Euclidean_distance should be true if we
+        can use the Euclidean rather than projected distance. Set to true only for noise free
+        point clouds. genus is used to constrain the genus of the reconstructed object. genus
+        defaults to -1, meaning unknown genus. k is the number of nearest neighbors for each point,
+        r is the maximum distance to farthest neighbor measured in multiples of average distance,
+        theta is the threshold on angles between normals: two points are only connected if the angle
+        between their normals is less than theta. Finally, n is the threshold on the distance between
+        vertices that are connected by handle edges (check paper). For large n, it is harder for
+        the algorithm to add handles. """
+    m = Manifold()
+    verts_data, n_verts = _as_vec3_f(verts)
+    normal_data, n_normal = _as_vec3_f(normals)
+
+    lib_py_gel.rsr_recon_experimental(m.obj, verts_data, normal_data, n_verts, n_normal,
+                         use_Euclidean_distance, genus, k, r, theta, n)
+    return m

pygel3d/gl_display.py

@@ -0,0 +1,127 @@
+""" This modules provides an OpenGL based viewer for graphs and meshes """
+
+from numpy.typing import ArrayLike
+from typing import Self
+from pygel3d import lib_py_gel
+from pygel3d.hmesh import Manifold
+from pygel3d.graph import Graph
+import ctypes as ct
+import numpy as np
+from os import getcwd, chdir
+
+try:
+    lib_py_gel.GLManifoldViewer_new.restype = ct.c_void_p
+    lib_py_gel.GLManifoldViewer_clone_controller.argtypes = (ct.c_void_p, ct.c_void_p)
+    lib_py_gel.GLManifoldViewer_clone_controller.restype = None
+    lib_py_gel.GLManifoldViewer_delete.argtypes = (ct.c_void_p,)
+    lib_py_gel.GLManifoldViewer_display.argtypes = (ct.c_void_p,ct.c_void_p,ct.c_void_p,ct.c_char,ct.c_bool, ct.POINTER(ct.c_float*3), ct.POINTER(ct.c_double),ct.c_bool,ct.c_bool)
+    lib_py_gel.GLManifoldViewer_get_annotation_points.restype = ct.c_size_t
+    lib_py_gel.GLManifoldViewer_get_annotation_points.argtypes = (ct.c_void_p, ct.POINTER(ct.POINTER(ct.c_double)))
+    lib_py_gel.GLManifoldViewer_set_annotation_points.argtypes = (ct.c_void_p, ct.c_int, ct.POINTER(ct.c_double))
+    lib_py_gel.GLManifoldViewer_event_loop.argtypes = (ct.c_bool,)
+    class Viewer:
+        """ An OpenGL Viewer for Manifolds and Graphs. Having created an instance of this
+        class, call display to show a mesh or a graph. The display function is flexible,
+        allowing several types of interactive visualization. Each instance of this
+        class corresponds to a single window, but you can have several
+        GLManifoldViewer and hence also several windows showing different
+        visualizations. """
+        def __init__(self):
+            current_directory = getcwd()
+            self.obj = lib_py_gel.GLManifoldViewer_new()
+            chdir(current_directory) # Necessary because init_glfw changes cwd
+        def __del__(self):
+            lib_py_gel.GLManifoldViewer_delete(self.obj)
+        def clone_controller(self, other: Self):
+            """ Clone the controller from another GLManifoldViewer. This is useful if you
+            want to display a mesh in a different window but keep the same view controller.
+            """
+            if isinstance(other, Viewer):
+                lib_py_gel.GLManifoldViewer_clone_controller(self.obj, other.obj)
+            else:
+                raise TypeError("Argument must be an instance of Viewer")
+        def display(self,
+                    m: Manifold,
+                    g: Graph=None,
+                    mode: str='w',
+                    smooth: bool=True,
+                    bg_col: tuple[float, float, float]=(0.3,0.3,0.3),
+                    data: ArrayLike|None=None,
+                    reset_view: bool=False,
+                    once: bool=False):
+            """ Display a mesh
+
+            Args:
+            ---
+            - m : the Manifold mesh or Graph we want to show.
+            - g : the Graph we want to show. If you only want to show a graph, you
+                can simply pass the graph as m, so the g argument is relevant only if
+                you need to show both a Manifold _and_ a Graph.
+            - mode : a single character that determines how the mesh is visualized:
+                'w' - wireframe,
+                'i' - isophote,
+                'g' - glazed (try it and see),
+                's' - scalar field,
+                'l' - line field,
+                'n' - normal.
+                'x' - xray or ghost rendering. Useful to show Manifold on top of Graph
+            - smooth : if True we use vertex normals. Otherwise, face normals.
+            - bg_col : background color.
+            - data : per vertex data for visualization. scalar or vector field.
+            - reset_view : if False view is as left in the previous display call. If
+                True, the view is reset to the default.
+            - once : if True we immediately exit the event loop and return. However,
+                the window stays and if the event loop is called from this or any
+                other viewer, the window will still be responsive.
+
+            Interactive controls:
+            ---
+            When a viewer window is displayed on the screen, you can naviagate with
+            the mouse: Left mouse button rotates, right mouse button is used for
+            zooming and (if shift is pressed) for panning. If you hold control, any
+            mouse button will pick a point on the 3D model. Up to 19 of these points
+            have unique colors.  If you pick an already placed annotation point it
+            will be removed and can now be placed elsewhere. Hit space bar to clear
+            the annotation points. Hitting ESC exits the event loop causing control
+            to return to the script.
+            """
+            data_ct = np.array(data,dtype=ct.c_double).ctypes
+            data_a = data_ct.data_as(ct.POINTER(ct.c_double))
+            bg_col_ct = np.array(bg_col,dtype=ct.c_float).ctypes
+            bg_col_a = bg_col_ct.data_as(ct.POINTER(ct.c_float*3))
+            if isinstance(m, Graph):
+                g = m
+                m = None
+            if isinstance(m,Manifold) and isinstance(g, Graph):
+                lib_py_gel.GLManifoldViewer_display(self.obj, m.obj, g.obj, ct.c_char(mode.encode('ascii')),smooth,bg_col_a,data_a,reset_view,once)
+            elif isinstance(m,Manifold):
+                lib_py_gel.GLManifoldViewer_display(self.obj, m.obj, 0, ct.c_char(mode.encode('ascii')),smooth,bg_col_a,data_a,reset_view,once)
+            elif isinstance(g,Graph):
+                lib_py_gel.GLManifoldViewer_display(self.obj, 0, g.obj, ct.c_char(mode.encode('ascii')),smooth,bg_col_a,data_a,reset_view,once)
+                
+        def annotation_points(self) -> ArrayLike:
+            """ Retrieve a vector of annotation points. This vector is not a copy,
+            so any changes made to the points will be reflected in the viewer. """
+            pos = ct.POINTER(ct.c_double)()
+            n = lib_py_gel.GLManifoldViewer_get_annotation_points(self.obj, ct.byref(pos))
+            if n == 0:
+                return None
+            return np.ctypeslib.as_array(pos,(n,3))
+        def set_annotation_points(self, pts: ArrayLike):
+            """ Set the annotation points to the given list of points. The points
+            should be given as a flat list or array of size 3n where n is the
+            number of points. """
+            pts_ct = np.array(pts,dtype=ct.c_double).ctypes
+            if pts_ct.size % 3 != 0:
+                raise ValueError("Annotation points must be given as a flat array of size 3n")
+            n = int(pts_ct.size // 3)
+            pts_a = pts_ct.data_as(ct.POINTER(ct.c_double))
+            lib_py_gel.GLManifoldViewer_set_annotation_points(self.obj, n, pts_a)
+        @staticmethod
+        def event_loop():
+            """ Explicit call to the event loop. This function enters the event loop.
+            Call it if you want to turn on interactivity in the currently displayed
+            window."""
+            lib_py_gel.GLManifoldViewer_event_loop(False)
+except AttributeError:
+    pass