Merge remote-tracking branch 'origin/master'

Author: andrewtliew

.gitignore

@@ -4,7 +4,7 @@ __pycache__/
 *$py.class
 
 # C extensions
-*.so
+# *.so
 
 # Distribution / packaging
 .Python

src/compas/geometry/algorithms/_smoothing_cpp/smoothing.so

@@ -0,0 +1,70 @@
+import compas
+from compas.datastructures import Mesh
+from compas.plotters import MeshPlotter
+from compas.geometry import smooth_centroid_cpp
+
+kmax = 50
+
+# make a mesh
+# and set the default vertex and edge attributes
+
+mesh = Mesh.from_obj(compas.get('faces.obj'))
+
+# extract numerical data from the datastructure
+
+vertices  = mesh.get_vertices_attributes(('x', 'y', 'z'))
+adjacency = [mesh.vertex_neighbours(key) for key in mesh.vertices()]
+fixed     = [int(mesh.vertex_degree(key) == 2) for key in mesh.vertices()]
+
+slider = list(mesh.vertices_where({'x': (-0.1, 0.1), 'y': (9.9, 10.1)}))[0]
+
+# make a plotter for (dynamic) visualization
+# and define a callback function
+# for plotting the intermediate configurations
+
+plotter = MeshPlotter(mesh, figsize=(10, 7))
+
+def callback(k, xyz):
+    print(k)
+
+    if k < kmax - 1:
+        xyz[slider][0] = 0.1 * (k + 1)
+
+    plotter.update_vertices()
+    plotter.update_edges()
+    plotter.update(pause=0.001)
+
+    for key, attr in mesh.vertices(True):
+        attr['x'] = xyz[key][0]
+        attr['y'] = xyz[key][1]
+        attr['z'] = xyz[key][2]
+
+# plot the lines of the original configuration of the mesh
+# as a reference
+
+lines = []
+for u, v in mesh.edges():
+    lines.append({
+        'start': mesh.vertex_coordinates(u, 'xy'),
+        'end'  : mesh.vertex_coordinates(v, 'xy'),
+        'color': '#cccccc',
+        'width': 0.5
+    })
+
+plotter.draw_lines(lines)
+
+# draw the vertices and edges in the starting configuration
+# and pause for a second before starting the dynamic visualization
+
+plotter.draw_vertices(facecolor={key: '#000000' for key in mesh.vertices() if mesh.vertex_degree(key) == 2})
+plotter.draw_edges()
+
+plotter.update(pause=0.5)
+
+# run the smoother
+
+xyz = smooth_centroid_cpp(vertices, adjacency, fixed, kmax=kmax, callback=callback)
+
+# keep the plot alive
+
+plotter.show()

src/compas/geometry/algorithms/_smoothing_cpp/smoothing_cpp_test.py

@@ -0,0 +1,78 @@
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+
+from ctypes import c_double
+import compas
+import compas_rhino
+
+from compas.datastructures import Mesh
+from compas.geometry import smooth_centroid_cpp
+
+from compas_rhino.helpers import MeshArtist
+from compas_rhino.conduits import PointsConduit
+from compas_rhino.conduits import LinesConduit
+
+kmax = 50
+
+# make a mesh
+# and set the default vertex and edge attributes
+
+mesh = Mesh.from_obj(compas.get('faces.obj'))
+
+edges = list(mesh.edges())
+
+# extract numerical data from the datastructure
+
+vertices  = mesh.get_vertices_attributes(('x', 'y', 'z'))
+adjacency = [mesh.vertex_neighbours(key) for key in mesh.vertices()]
+fixed     = [int(mesh.vertex_degree(key) == 2) for key in mesh.vertices()]
+
+# make a artist for (dynamic) visualization
+# and define a callback function
+# for plotting the intermediate configurations
+
+slider = list(mesh.vertices_where({'x': (-0.1, 0.1), 'y': (9.9, 10.1)}))[0]
+
+artist = MeshArtist(mesh, layer='SmoothMesh')
+artist.clear_layer()
+
+
+def callback(k, xyz):
+    compas_rhino.wait()
+
+    print(k)
+
+    if k < kmax - 1:
+        xyz[slider][0] = c_double(0.1 * (k + 1))
+
+    pointsconduit.points = [mesh.vertex_coordinates(key) for key in mesh.vertices()]
+    linesconduit.lines = [mesh.edge_coordinates(u, v) for u, v in edges]
+
+    pointsconduit.redraw(k)
+    linesconduit.redraw(k)
+
+    for key, attr in mesh.vertices(True):
+        attr['x'] = float(xyz[key][0])
+        attr['y'] = float(xyz[key][1])
+        attr['z'] = float(xyz[key][2])
+
+
+pointsconduit = PointsConduit(radius=10, refreshrate=5)
+linesconduit = LinesConduit(refreshrate=5)
+
+
+with pointsconduit.enabled():
+    with linesconduit.enabled():
+        xyz = smooth_centroid_cpp(vertices, adjacency, fixed, kmax=kmax, callback=callback)
+
+
+for key, attr in mesh.vertices(True):
+    attr['x'] = xyz[key][0]
+    attr['y'] = xyz[key][1]
+    attr['z'] = xyz[key][2]
+
+artist.clear_edges()
+artist.draw_vertices()
+artist.draw_edges()
+artist.redraw()

src/compas/geometry/algorithms/_smoothing_cpp/smoothing_cpp_test_rhino.py

@@ -3,8 +3,6 @@
 // cd _smoothing_cpp
 // g++ -shared -fPIC src/main.cpp -o smoothing.so
 
-using namespace std;
-
 extern "C"
 {
     typedef void callback(int k);
@@ -19,7 +17,7 @@ void smooth_centroid(int v, int *nbrs, int *fixed, double **vertices, int **neig
     int j, n;
     double cx, cy, cz;
 
-    vector< vector<double> > xyz(v, vector<double>(3, 0.0));
+    std::vector< std::vector<double> > xyz(v, std::vector<double>(3, 0.0));
 
     for (k = 0; k < kmax; k++) {
 

src/compas/geometry/algorithms/_smoothing_cpp/src/main.cpp

@@ -2,12 +2,14 @@
 from .dr_numpy import *
 from .drx_numpy import *
 from .fd_numpy import *
+from .fd_cpp import *
 from .pca_numpy import *
 
 from .dr import __all__ as a
 from .dr_numpy import __all__ as b
 from .drx_numpy import __all__ as c
 from .fd_numpy import __all__ as d
-from .pca_numpy import __all__ as e
+from .fd_cpp import __all__ as e
+from .pca_numpy import __all__ as f
 
-__all__ = a + b + c + d + e
+__all__ = a + b + c + d + e + f

src/compas/interop/core/cpp/_test/test.so

@@ -0,0 +1,72 @@
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+
+import ctypes
+import compas
+
+from compas.datastructures import Network
+from compas.plotters import NetworkPlotter
+from compas.utilities import i_to_red
+
+from compas.interop.core.cpp.xdarray import Array2D
+from compas.interop.core.cpp.xdarray import Array1D
+
+lib = ctypes.cdll.LoadLibrary('fd.so')
+
+network = Network.from_obj(compas.get('saddle.obj'))
+
+vertices = network.get_vertices_attributes('xyz')
+loads = network.get_vertices_attributes(('px', 'py', 'pz'), (0.0, 0.0, 0.0))
+edges = list(network.edges())
+fixed = network.leaves()
+free = [i for i in range(len(vertices)) if i not in fixed]
+q = network.get_edges_attribute('q', 1.0)
+
+cvertices = Array2D(vertices, 'double')
+cedges = Array2D(edges, 'int')
+cloads = Array2D(loads, 'double')
+cq = Array1D(q, 'double')
+cfixed = Array1D(fixed, 'int')
+cfree = Array1D(free, 'int')
+
+lib.fd.argtypes = [
+    ctypes.c_int,
+    ctypes.c_int,
+    ctypes.c_int,
+    cvertices.ctype,
+    cedges.ctype,
+    cloads.ctype,
+    cq.ctype,
+    cfixed.ctype,
+    cfree.ctype
+]
+
+lib.fd(
+    ctypes.c_int(len(vertices)),
+    ctypes.c_int(len(edges)),
+    ctypes.c_int(len(fixed)),
+    cvertices.cdata,
+    cedges.cdata,
+    cloads.cdata,
+    cq.cdata,
+    cfixed.cdata,
+    cfree.cdata
+)
+
+xyz = cvertices.pydata
+
+for key, attr in network.vertices(True):
+    attr['x'] = float(xyz[key][0])
+    attr['y'] = float(xyz[key][1])
+    attr['z'] = float(xyz[key][2])
+
+
+zmax = max(network.get_vertices_attribute('z'))
+
+plotter = NetworkPlotter(network, figsize=(10, 7))
+plotter.draw_vertices(
+    facecolor={key: i_to_red(attr['z'] / zmax) for key, attr in network.vertices(True)}
+)
+plotter.draw_edges()
+plotter.show()