Merge remote-tracking branch 'origin/master'

Author: andrewtliew

src/compas/datastructures/network/network.py

@@ -31,7 +31,7 @@
 
 from compas.datastructures.network.operations import network_split_edge
 
-# from compas.topology import bfs_traverse
+# from compas.topology import breadth_first_traverse
 
 
 __author__     = 'Tom Van Mele'
@@ -517,7 +517,7 @@ def number_of_halfedges(self):
     #         return False
 
     #     root = self.get_any_vertex()
-    #     nodes = bfs_traverse(self.halfedge, root)
+    #     nodes = breadth_first_traverse(self.halfedge, root)
 
     #     return len(nodes) == self.number_of_vertices()
 

src/compas/geometry/__init__.py

@@ -53,10 +53,10 @@
 .. autosummary::
     :toctree: generated/
 
-    aabb
-    aabb_xy
-    obb_numpy
-    obb_xy_numpy
+    bounding_box
+    bounding_box_xy
+    oriented_bounding_box_numpy
+    oriented_bounding_box_xy_numpy
 
 **fitting**
 
@@ -89,9 +89,9 @@
 .. autosummary::
     :toctree: generated/
 
-    scalarfield_contours
-    mesh_contours
-    mesh_isolines
+    scalarfield_contours_numpy
+    mesh_contours_numpy
+    mesh_isolines_numpy
 
 **parallelisation**
 

src/compas/geometry/algorithms/bbox.py

@@ -10,14 +10,14 @@
 
 
 __all__ = [
-    'aabb',
-    'aabb_xy',
-    'obb_numpy',
-    'obb_xy_numpy',
+    'bounding_box',
+    'bounding_box_xy',
+    'oriented_bounding_box_numpy',
+    'oriented_bounding_box_xy_numpy',
 ]
 
 
-def aabb(points):
+def bounding_box(points):
     """Computes the axis-aligned minimum bounding box of a list of points.
 
     Parameters
@@ -54,7 +54,7 @@ def aabb(points):
             (min_x, max_y, max_z)]
 
 
-def aabb_xy(points):
+def bounding_box_xy(points):
     """Compute the axis-aligned minimum bounding box of a list of points in the XY-plane.
 
     Note
@@ -89,7 +89,7 @@ def aabb_xy(points):
             (min_x, max_y, 0.0)]
 
 
-def obb_numpy(points):
+def oriented_bounding_box_numpy(points):
     """Compute the oriented minimum bounding box of a set of points in 3D space.
 
     Note
@@ -122,7 +122,7 @@ def obb_numpy(points):
         from compas.plotters import create_axes_3d
         from compas.geometry import rotation_matrix
         from compas.geometry import transform
-        from compas.geometry import obb_numpy
+        from compas.geometry import oriented_bounding_box_numpy
 
         clouds = []
 
@@ -167,7 +167,7 @@ def obb_numpy(points):
         bounds.plot(axes)
 
         for cloud in clouds:
-            bbox = obb_numpy(cloud)
+            bbox = oriented_bounding_box_numpy(cloud)
 
             Cloud3D(cloud).plot(axes)
             Box(bbox[1]).plot(axes)
@@ -224,7 +224,7 @@ def obb_numpy(points):
     return hull, bbox, volume
 
 
-def obb_xy_numpy(points):
+def oriented_bounding_box_xy_numpy(points):
     """Compute the oriented minimum bounding box of set of points in the XY plane.
 
     Note

src/compas/geometry/algorithms/isolines.py

@@ -10,9 +10,9 @@
 
 
 __all__ = [
-    'scalarfield_contours',
-    'mesh_contours',
-    'mesh_isolines',
+    'scalarfield_contours_numpy',
+    'mesh_contours_numpy',
+    'mesh_isolines_numpy',
 ]
 
 
@@ -32,7 +32,7 @@
 # ==============================================================================
 
 
-def scalarfield_contours(xy, s, N=50):
+def scalarfield_contours_numpy(xy, s, N=50):
     r"""Compute the contour lines of a scalarfield.
 
     Note
@@ -67,7 +67,7 @@ def scalarfield_contours(xy, s, N=50):
         from compas.datastructures import Mesh
         from compas.geometry import centroid_points
         from compas.geometry import distance_point_point
-        from compas.geometry import scalarfield_contours
+        from compas.geometry import scalarfield_contours_numpy
 
         mesh = Mesh.from_obj(compas.get('faces.obj'))
 
@@ -77,7 +77,7 @@ def scalarfield_contours(xy, s, N=50):
 
         xy = [point[0:2] for point in points]
 
-        levels, contours = scalarfield_contours(xy, distances)
+        levels, contours = scalarfield_contours_numpy(xy, distances)
 
         for i in range(len(contours)):
             level = levels[i]
@@ -121,7 +121,7 @@ def scalarfield_contours(xy, s, N=50):
     return levels, contours
 
 
-def mesh_contours(mesh, N=50):
+def mesh_contours_numpy(mesh, N=50):
     """Compute the contours of the mesh.
 
     Note
@@ -151,18 +151,18 @@ def mesh_contours(mesh, N=50):
 
         import compas
         from compas.datastructures import Mesh
-        from compas.geometry import mesh_contours
+        from compas.geometry import mesh_contours_numpy
 
         mesh = Mesh.from_obj(compas.get('hypar.obj'))
-        print(mesh_contours(mesh))
+        print(mesh_contours_numpy(mesh))
 
     """
     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)
 
 
-def mesh_isolines(mesh, attr_name, N=50):
+def mesh_isolines_numpy(mesh, attr_name, N=50):
     """Compute the isolines of a specified attribute of the vertices of a mesh.
 
     Parameters

src/compas/hpc/numba/drx.py

@@ -13,8 +13,8 @@
 from scipy.sparse import find
 
 from compas.numerical import uvw_lengths
-from compas.numerical.algorithms.drx import _beam_data
-from compas.numerical.algorithms.drx import _create_arrays
+from compas.numerical.algorithms.drx_numpy import _beam_data
+from compas.numerical.algorithms.drx_numpy import _create_arrays
 
 from compas.hpc.numba.geometry import numba_cross
 from compas.hpc.numba.geometry import numba_vdot

src/compas/numerical/__init__.py

@@ -16,7 +16,7 @@
 
     dr
     dr_numpy
-    drx
+    drx_numpy
     fd_numpy
     pca_numpy
 

src/compas/numerical/algorithms/__init__.py

@@ -1,12 +1,12 @@
 from .dr import *
 from .dr_numpy import *
-from .drx import *
+from .drx_numpy import *
 from .fd_numpy import *
 from .pca_numpy import *
 
 from .dr import __all__ as a
 from .dr_numpy import __all__ as b
-from .drx import __all__ as c
+from .drx_numpy import __all__ as c
 from .fd_numpy import __all__ as d
 from .pca_numpy import __all__ as e
 

src/compas/numerical/algorithms/dr.py

@@ -83,8 +83,13 @@ def dr(vertices, edges, fixed, loads, qpre, fpre, lpre, linit, E, radius,
         import compas
         from compas.datastructures import Network
         from compas.plotters import NetworkPlotter
-        from compas.numerical import dr
         from compas.utilities import i_to_rgb
+        from compas.numerical import dr
+
+        # make a network
+        # and set the default vertex and edge attributes
+
+        network = Network.from_obj(compas.get('lines.obj'))
 
         dva = {
             'is_fixed': False,
@@ -108,22 +113,23 @@ def dr(vertices, edges, fixed, loads, qpre, fpre, lpre, linit, E, radius,
             'radius': 0.0,
         }
 
-        network = Network.from_obj(compas.get('lines.obj'))
-
         network.update_default_vertex_attributes(dva)
         network.update_default_edge_attributes(dea)
 
+        # identify the fixed vertices
+        # and assign random prescribed force densities to the edges
+
         for key, attr in network.vertices(True):
             attr['is_fixed'] = network.vertex_degree(key) == 1
 
         for u, v, attr in network.edges(True):
             attr['qpre'] = 1.0 * random.randint(1, 7)
 
-        k_i = network.key_index()
+        # extract numerical data from the datastructure
 
         vertices = network.get_vertices_attributes(('x', 'y', 'z'))
-        edges    = [(k_i[u], k_i[v]) for u, v in network.edges()]
-        fixed    = [k_i[key] for key in network.vertices_where({'is_fixed': True})]
+        edges    = list(network.edges())
+        fixed    = network.vertices_where({'is_fixed': True})
         loads    = network.get_vertices_attributes(('px', 'py', 'pz'))
         qpre     = network.get_edges_attribute('qpre')
         fpre     = network.get_edges_attribute('fpre')
@@ -132,6 +138,11 @@ def dr(vertices, edges, fixed, loads, qpre, fpre, lpre, linit, E, radius,
         E        = network.get_edges_attribute('E')
         radius   = network.get_edges_attribute('radius')
 
+        # make a plotter for (dynamic) visualization
+        # plot the lines of the original configuration of the network as reference
+
+        plotter = NetworkPlotter(network)
+
         lines = []
         for u, v in network.edges():
             lines.append({
@@ -141,26 +152,31 @@ def dr(vertices, edges, fixed, loads, qpre, fpre, lpre, linit, E, radius,
                 'width': 0.5
             })
 
-        plotter = NetworkPlotter(network)
         plotter.draw_lines(lines)
 
-        xyz, q, f, l, r = dr(vertices, edges, fixed, loads,
-                             qpre, fpre, lpre,
-                             linit, E, radius,
+        # run the dynamic relaxation
+        # update vertices and edges
+        # visualize the final geometry
+        # color the edges according to the size of the forces
+        # set the width of the edges proportional to the internal forces
+
+        xyz, q, f, l, r = dr(vertices, edges, fixed, loads, qpre, fpre, lpre, linit, E, radius,
                              kmax=100)
 
         for key, attr in network.vertices(True):
-            index = k_i[key]
-            attr['x'] = xyz[index][0]
-            attr['y'] = xyz[index][1]
-            attr['z'] = xyz[index][2]
+            attr['x'] = xyz[key][0]
+            attr['y'] = xyz[key][1]
+            attr['z'] = xyz[key][2]
 
         for index, (u, v, attr) in enumerate(network.edges(True)):
             attr['f'] = f[index]
             attr['l'] = l[index]
 
         fmax = max(network.get_edges_attribute('f'))
 
+        plotter.clear_vertices()
+        plotter.clear_edges()
+
         plotter.draw_vertices(
             facecolor={key: '#000000' for key in network.vertices_where({'is_fixed': True})}
         )