update code

Author: tomvanmele

src/compas_triangle/__init__.py

@@ -1,22 +1,4 @@
-"""
-********************************************************************************
-compas_triangle
-********************************************************************************
-
-.. currentmodule:: compas_triangle
-
-
-.. toctree::
-    :maxdepth: 1
-
-
-"""
-
-from __future__ import print_function
-
 import os
-import compas
-
 
 __author__ = ["tom van mele"]
 __copyright__ = "Block Research Group - ETH Zurich"
@@ -32,29 +14,5 @@
 DOCS = os.path.abspath(os.path.join(HOME, "docs"))
 TEMP = os.path.abspath(os.path.join(HOME, "temp"))
 
-
-# Check if package is installed from git
-# If that's the case, try to append the current head's hash to __version__
-try:
-    git_head_file = compas._os.absjoin(HOME, '.git', 'HEAD')
-
-    if os.path.exists(git_head_file):
-        # git head file contains one line that looks like this:
-        # ref: refs/heads/master
-        with open(git_head_file, 'r') as git_head:
-            _, ref_path = git_head.read().strip().split(' ')
-            ref_path = ref_path.split('/')
-
-            git_head_refs_file = compas._os.absjoin(HOME, '.git', *ref_path)
-
-        if os.path.exists(git_head_refs_file):
-            with open(git_head_refs_file, 'r') as git_head_ref:
-                git_commit = git_head_ref.read().strip()
-                __version__ += '-' + git_commit[:8]
-except Exception:
-    pass
-
-
-__all_plugins__ = ['compas_triangle.delaunay']
-
 __all__ = ["HOME", "DATA", "DOCS", "TEMP"]
+__all_plugins__ = ["compas_triangle.delaunay"]

src/compas_triangle/delaunay.py

@@ -1,16 +1,27 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
+from typing import Annotated
+from typing import Optional
 
-from triangle import triangulate
-from compas.utilities import pairwise
-from compas.utilities import geometric_key_xy as geo
 from compas.geometry import centroid_points_xy
-
+from compas.itertools import pairwise
 from compas.plugins import plugin
+from compas.tolerance import TOL
+from triangle import triangulate
+
+geo = TOL.geometric_key_xy
+
 
+Point = Annotated[list[float], 3]
+Polyline = list[Point]
+Polygon = list[Point]
+Segment = tuple[int, int]
+Triangle = tuple[int, int, int]
 
-def _to_vertices_segments_holes(boundary, polylines, polygons):
+
+def _to_vertices_segments_holes(
+    boundary: list[Point],
+    polylines: list[Polyline],
+    polygons: list[Polygon],
+) -> tuple[list[Point], list[Segment], list[Point]]:
     if geo(boundary[0]) != geo(boundary[-1]):
         boundary.append(boundary[0])
 
@@ -47,8 +58,8 @@ def _to_vertices_segments_holes(boundary, polylines, polygons):
     return vertices, segments, holes
 
 
-@plugin(category='triangulation')
-def delaunay_triangulation(points):
+@plugin(category="triangulation")
+def delaunay_triangulation(points: list[Point]) -> tuple[list[Point], list[Triangle]]:
     """Construct a Delaunay triangulation of set of vertices.
 
     Parameters
@@ -62,24 +73,24 @@ def delaunay_triangulation(points):
         * The vertices of the triangulation.
         * The faces of the triangulation.
 
-    Examples
-    --------
-    >>>
-
     References
     ----------
     https://www.cs.cmu.edu/~quake/triangle.delaunay.html
 
     """
-    data = {'vertices': [point[0:2] for point in points]}
-    result = triangulate(data, opts='c')
-    vertices = [[x, y, 0.0] for x, y in result['vertices']]
-    faces = result['triangles']
+    data = {"vertices": [point[0:2] for point in points]}
+    result = triangulate(data, opts="c")
+    vertices = [[x, y, 0.0] for x, y in result["vertices"]]
+    faces = result["triangles"]
     return vertices, faces
 
 
-@plugin(category='triangulation')
-def constrained_delaunay_triangulation(boundary, polylines=None, polygons=None):
+@plugin(category="triangulation")
+def constrained_delaunay_triangulation(
+    boundary: list[Point],
+    polylines: Optional[list[Polyline]] = None,
+    polygons: Optional[list[Polygon]] = None,
+) -> tuple[list[Point], list[Triangle]]:
     """Construct a Delaunay triangulation of set of vertices, constrained to the specified segments.
 
     Parameters
@@ -101,31 +112,33 @@ def constrained_delaunay_triangulation(boundary, polylines=None, polygons=None):
     -----
     No additional points will be inserted in the triangulation.
 
-    Examples
-    --------
-    >>>
-
     References
     ----------
     https://www.cs.cmu.edu/~quake/triangle.delaunay.html
 
     """
     vertices, segments, holes = _to_vertices_segments_holes(boundary, polylines, polygons)
 
-    data = {'vertices': vertices, 'segments': segments}
+    data = {"vertices": vertices, "segments": segments}
 
     if len(holes) > 0:
-        data['holes'] = holes
+        data["holes"] = holes
 
-    result = triangulate(data, opts='p')
+    result = triangulate(data, opts="p")
 
-    vertices = [[x, y, 0.0] for x, y in result['vertices']]
-    faces = result['triangles']
+    vertices = [[x, y, 0.0] for x, y in result["vertices"]]
+    faces = result["triangles"]
     return vertices, faces
 
 
-@plugin(category='triangulation')
-def conforming_delaunay_triangulation(boundary, polylines=None, polygons=None, angle=None, area=None):
+@plugin(category="triangulation")
+def conforming_delaunay_triangulation(
+    boundary: list[Point],
+    polylines: Optional[list[Polyline]] = None,
+    polygons: Optional[list[Polygon]] = None,
+    angle: Optional[float] = None,
+    area: Optional[float] = None,
+) -> tuple[list[Point], list[Triangle]]:
     """Construct a Conforming Delaunay triangulation of set of vertices, constrained to the specified segments.
 
     Parameters
@@ -152,35 +165,31 @@ def conforming_delaunay_triangulation(boundary, polylines=None, polygons=None, a
         * The vertices of the triangulation.
         * The faces of the triangulation.
 
-    Examples
-    --------
-    >>>
-
     References
     ----------
     https://www.cs.cmu.edu/~quake/triangle.delaunay.html
 
     """
     vertices, segments, holes = _to_vertices_segments_holes(boundary, polylines, polygons)
 
-    data = {'vertices': vertices, 'segments': segments}
+    data = {"vertices": vertices, "segments": segments}
 
     if len(holes) > 0:
-        data['holes'] = holes
+        data["holes"] = holes
 
-    opts = 'pq'
+    opts = "pq"
 
     if angle:
-        opts = '{}{}'.format(opts, angle)
+        opts = "{}{}".format(opts, angle)
 
     if area:
-        opts = '{}a{}'.format(opts, area)
+        opts = "{}a{}".format(opts, area)
 
-    if opts == 'pq':
-        opts = 'pq0D'
+    if opts == "pq":
+        opts = "pq0D"
 
     result = triangulate(data, opts=opts)
 
-    vertices = [[x, y, 0.0] for x, y in result['vertices']]
-    faces = result['triangles']
+    vertices = [[x, y, 0.0] for x, y in result["vertices"]]
+    faces = result["triangles"]
     return vertices, faces

src/compas_triangle/rhino.py

@@ -1,31 +1,35 @@
-from __future__ import print_function
-from __future__ import absolute_import
-from __future__ import division
+import compas_rhino.conversions
+import compas_rhino.objects
+import rhinoscriptsyntax as rs  # type: ignore
+from compas.geometry import Curve
 
-import compas_rhino
-from compas_rhino.conversions import RhinoCurve
+
+def guid_to_compas_curve(guid) -> Curve:
+    return compas_rhino.conversions.curveobject_to_compas(compas_rhino.objects.find_object(guid))
 
 
 def discretise_boundary(guids, length):
     boundary = []
     for guid in guids:
-        compas_rhino.rs.EnableRedraw(False)
-        segments = compas_rhino.rs.ExplodeCurves(guid)
+        rs.EnableRedraw(False)
+
+        segments = rs.ExplodeCurves(guid)
         for segment in segments:
-            curve = RhinoCurve.from_guid(segment).to_compas()
+            curve: Curve = guid_to_compas_curve(segment)
             N = int(curve.length() / length)
             _, points = curve.divide_by_count(N, return_points=True)
             boundary.extend(map(list, points))
-        compas_rhino.rs.DeleteObjects(segments)
-        compas_rhino.rs.EnableRedraw(True)
+
+        rs.DeleteObjects(segments)
+        rs.EnableRedraw(True)
     return boundary
 
 
 def discretise_constraints(guids, length):
     polylines = []
     if guids:
         for guid in guids:
-            curve = RhinoCurve.from_guid(guid).to_compas()
+            curve: Curve = guid_to_compas_curve(guid)
             N = int(curve.length() / length)
             _, points = curve.divide_by_count(N, return_points=True)
             polylines.append(map(list, points))