docstring updates

Author: tomvanmele

src/compas/geometry/__init__.py

@@ -51,15 +51,13 @@
     mesh_smooth_centroid
     network_parallelise_edges
     network_smooth_centroid
-    network_smooth_resultant
     oriented_bounding_box_numpy
     oriented_bounding_box_xy_numpy
     planarize_faces
     scalarfield_contours_numpy
     smooth_area
     smooth_centroid
     smooth_centerofmass
-    smooth_resultant
 
 
 Classes

src/compas/geometry/algorithms/hull.py

@@ -37,10 +37,6 @@ def convex_hull(points):
         The triangular faces of the convex hull as lists of vertex indices
         referring to the original point coordinates.
 
-    References
-    ----------
-    * https://gist.github.com/anonymous/5184ba0bcab21d3dd19781efd3aae543
-
     Note
     ----
     The algorithm is not optimized and relatively slow on large sets of points.
@@ -80,6 +76,10 @@ def convex_hull(points):
                     show_vertices = False,
                     show_edges = False)
 
+    References
+    ----------
+    * https://gist.github.com/anonymous/5184ba0bcab21d3dd19781efd3aae543
+
     """
     def _normal_face(face):
         u = subtract_vectors(points[face[1]], points[face[0]])

src/compas/geometry/algorithms/interpolation.py

@@ -49,15 +49,22 @@ def discrete_coons_patch(ab, bc, dc, ad):
     faces : list of lists
         List of faces (face = list of vertex indices as integers)
 
-    References
-    ----------
-    * https://en.wikipedia.org/wiki/Coons_patch
-    * https://www.mathcurve.com/surfaces/patchcoons/patchcoons.shtml
+    Examples
+    --------
+    .. code-block:: python
+
+        #
+
 
     See Also
     --------
     * :func:`compas.datastructures.mesh_cull_duplicate_vertices`
 
+    References
+    ----------
+    * https://en.wikipedia.org/wiki/Coons_patch
+    * https://www.mathcurve.com/surfaces/patchcoons/patchcoons.shtml
+
     """
     if not ab:
         ab = [ad[0]] * len(dc)

src/compas/geometry/algorithms/isolines.py

@@ -35,11 +35,6 @@
 def scalarfield_contours_numpy(xy, s, N=50):
     r"""Compute the contour lines of a scalarfield.
 
-    Note
-    ----
-    The computation of the contour lines is based on the `contours function`_
-    available through matplotlib.
-
     Parameters
     ----------
     xy : array-like
@@ -59,6 +54,11 @@ def scalarfield_contours_numpy(xy, s, N=50):
         the contours. The second item in the tuple is a list of contour lines.
         Each contour line is a list of paths, and each path is a list polygons.
 
+    Note
+    ----
+    The computation of the contour lines is based on the `contours function`_
+    available through matplotlib.
+
     Examples
     --------
     .. code-block:: python
@@ -117,7 +117,7 @@ def scalarfield_contours_numpy(xy, s, N=50):
             polygons = path.to_polygons()
             contours[i][j] = [0] * len(polygons)
             for k, polygon in enumerate(iter(polygons)):
-                contours[i][j][k] = polygon.tolist()
+                contours[i][j][k] = polygon
     return levels, contours
 
 
@@ -159,7 +159,7 @@ def mesh_contours_numpy(mesh, N=50):
     """
     xy = [mesh.vertex_coordinates(key, 'xy') for key in mesh.vertices()]
     z = [mesh.vertex_coordinates(key, 'z') for key in mesh.vertices()]
-    return scalarfield_contours(xy, z, N)
+    return scalarfield_contours_numpy(xy, z, N)
 
 
 def mesh_isolines_numpy(mesh, attr_name, N=50):
@@ -186,7 +186,7 @@ def mesh_isolines_numpy(mesh, attr_name, N=50):
     """
     xy = [mesh.vertex_coordinates(key, 'xy') for key in mesh.vertices()]
     s = [mesh.vertex[key][attr_name] for key in mesh.vertices()]
-    return scalarfield_contours(xy, s, N)
+    return scalarfield_contours_numpy(xy, s, N)
 
 
 # ==============================================================================
@@ -195,4 +195,26 @@ def mesh_isolines_numpy(mesh, attr_name, N=50):
 
 if __name__ == "__main__":
 
-    pass
+    import compas
+    from compas.datastructures import Mesh
+    from compas.geometry import centroid_points
+    from compas.geometry import distance_point_point
+    from compas.geometry import scalarfield_contours_numpy
+
+    mesh = Mesh.from_obj(compas.get('faces.obj'))
+
+    points = [mesh.vertex_coordinates(key) for key in mesh.vertices()]
+    centroid = centroid_points(points)
+    distances = [distance_point_point(point, centroid) for point in points]
+
+    xy = [point[0:2] for point in points]
+
+    levels, contours = scalarfield_contours_numpy(xy, distances)
+
+    for i in range(len(contours)):
+        level = levels[i]
+        contour = contours[i]
+        print(level)
+        for path in contour:
+            for polygon in path:
+                print([point.tolist() for point in polygon])

src/compas/geometry/algorithms/planarisation.py

@@ -30,7 +30,7 @@
 ]
 
 
-def flatness(vertices, faces, maxdev=1.0):
+def flatness(vertices, faces, maxdev=0.02):
     """Compute mesh flatness per face.
 
     Parameters
@@ -41,7 +41,7 @@ def flatness(vertices, faces, maxdev=1.0):
         The face vertices.
     maxdev : float, optional
         A maximum value for the allowed deviation from flatness.
-        Default is ``1.0``.
+        Default is ``0.02``.
 
     Returns
     -------
@@ -166,9 +166,14 @@ def mesh_flatness(mesh, maxdev=1.0):
     This function only works as expected for quadrilateral faces.
 
     """
-    vertices = {key: mesh.vertex_coordinates(key) for key in mesh.vertices()}
-    faces = [mesh.face_vertices(fkey) for fkey in mesh.faces()]
-    return flatness(vertices, faces, maxdev=maxdev)
+    dev = []
+    for fkey in mesh.faces():
+        points = mesh.face_coordinates(fkey)
+        lengths = [distance_point_point(a, b) for a, b in window(points + points[0:1], 2)]
+        l = sum(lengths) / len(lengths)
+        d = distance_line_line((points[0], points[2]), (points[1], points[3]))
+        dev.append((d / l) / maxdev)
+    return dev
 
 
 def mesh_planarize_faces(mesh, fixed=None, kmax=100, callback=None, callback_args=None):
@@ -194,6 +199,16 @@ def mesh_planarize_faces(mesh, fixed=None, kmax=100, callback=None, callback_arg
     callback_args : list, optional [None]
         A list of arguments to be passed to the callback function.
 
+    Returns
+    -------
+    None
+
+    Examples
+    --------
+    .. code-block:: python
+
+        #
+
     """
     if callback:
         if not callable(callback):
@@ -202,21 +217,36 @@ def mesh_planarize_faces(mesh, fixed=None, kmax=100, callback=None, callback_arg
     fixed = fixed or []
     fixed = set(fixed)
 
-    vertices = {key: mesh.vertex_coordinates(key) for key in mesh.vertices()}
-    faces = [mesh.face_vertices(fkey) for fkey in mesh.faces()]
-
     for k in range(kmax):
-        planarize_faces(vertices, faces, fixed=fixed, kmax=1)
+
+        positions = {key: [] for key in mesh.vertices()}
+
+        for fkey in mesh.faces():
+            vertices = mesh.face_vertices(fkey)
+            points = [mesh.vertex_coordinates(key) for key in vertices]
+            plane = bestfit_plane(points)
+            projections = project_points_plane(points, plane)
+
+            for index, key in enumerate(vertices):
+                positions[key].append(projections[index])
 
         for key, attr in mesh.vertices(True):
-            attr['x'] = vertices[key][0]
-            attr['y'] = vertices[key][1]
-            attr['z'] = vertices[key][2]
+            if key in fixed:
+                continue
+
+            x, y, z = centroid_points(positions[key])
+            attr['x'] = x
+            attr['y'] = y
+            attr['z'] = z
 
         if callback:
             callback(k, callback_args)
 
 
+def mesh_planarize_faces_numpy(mesh, fixed=None, kmax=100, callback=None, callback_args=None):
+    pass
+
+
 def mesh_planarize_faces_shapeop(mesh,
                                  fixed=None,
                                  kmax=100,
@@ -409,20 +439,17 @@ def mesh_circularize_faces_shapeop(mesh,
     plotter.draw_faces()
     plotter.draw_edges()
 
-    key_index = mesh.key_index()
-    # vertices = mesh.get_vertices_attributes('xyz')
-    # faces = [[key_index[key] for key in mesh.face_vertices(fkey)] for fkey in mesh.faces()]
-    # fixed = [key_index[key] for key in fixed]
-
     def callback(k, args):
-        if k % 10 == 0:
+        print(k)
+
+        if k % 100 == 0:
             dev = mesh_flatness(mesh, maxdev=0.02)
 
             plotter.update_vertices(radius=radius)
             plotter.update_faces(facecolor={fkey: i_to_rgb(dev[fkey]) for fkey in mesh.faces()})
             plotter.update_edges()
             plotter.update()
 
-    mesh_planarize_faces_shapeop(mesh, fixed=fixed, kmax=1000, callback=callback)
+    mesh_planarize_faces_shapeop(mesh, fixed=fixed, kmax=2000, callback=callback)
 
     plotter.show()