removed dr_cpp import

Author: tomvanmele

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

@@ -1,8 +1,3 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <time.h>
-#include <array>
 #include <vector>
 
 // cd _smoothing_cpp
@@ -19,13 +14,14 @@ extern "C"
 
 void smooth_centroid(int v, int *nbrs, int *fixed, double **vertices, int **neighbours, int kmax, callback_smoothing func) 
 {
-    int i, j, n, k;
+    int k;
+    int i;
+    int j, n;
     double cx, cy, cz;
     double c;
 
     vector< vector<double> > xyz(v, vector<double>(3, 0.0));
 
-
     for (k = 0; k < kmax; k++) {
 
         for (i = 0; i < v; i++) {
@@ -35,27 +31,26 @@ void smooth_centroid(int v, int *nbrs, int *fixed, double **vertices, int **neig
         }
 
         for (i = 0; i < v; i++) {
+
+            if (fixed[i]) {
+                continue;
+            }
+
             cx = 0.0;
             cy = 0.0;
             cz = 0.0;
 
-            c = 0.0;
-
             for (j = 0; j < nbrs[i]; j++) {
                 n = neighbours[i][j];
 
                 cx += xyz[n][0];
                 cy += xyz[n][1];
                 cz += xyz[n][2];
-
-                c += 1.0;
             }
 
-            if (! fixed[i]) {
-                vertices[i][0] = cx / c;
-                vertices[i][1] = cy / c;
-                vertices[i][2] = cz / c;
-            }
+            vertices[i][0] = cx / nbrs[i];
+            vertices[i][1] = cy / nbrs[i];
+            vertices[i][2] = cz / nbrs[i];
         }
 
         func(k);

src/compas/geometry/algorithms/planarisation.py

@@ -279,6 +279,8 @@ def mesh_planarize_faces_shapeop(mesh,
         vertex = key_index[key]
         solver.add_closeness_constraint(vertex, 1.0)
 
+    solver.init()
+
     for k in range(kmax):
         # solve
         solver.solve(1)
@@ -360,10 +362,12 @@ def mesh_circularize_faces_shapeop(mesh,
         vertex = key_index[key]
         solver.add_closeness_constraint(vertex, 1.0)
 
+    solver.init()
+
     for k in range(kmax):
         # solve
         solver.solve(1)
-        # update the points array
+        # # update the points array
         points = solver.get_points()
         # update
         for index, (key, attr) in enumerate(mesh.vertices(True)):

src/compas/geometry/algorithms/smoothing_cpp.py

@@ -60,7 +60,8 @@ def smooth_centroid_cpp(vertices, adjacency, fixed, kmax=100, callback=None, cal
 
     def wrapper(k):
         print(k)
-        c_vertices.cdata[18][0] = 0.01 * k
+        if k < kmax - 1:
+            c_vertices.cdata[18][0] = 0.1 * (k + 1)
         callback(c_vertices.pydata)
 
     smooth_centroid.smooth_centroid.argtypes = [
@@ -119,13 +120,11 @@ def wrapper(k):
     fixed     = list(mesh.vertices_where({'is_fixed': True}))
     adjacency = [mesh.vertex_neighbours(key) for key in mesh.vertices()]
 
-    print(fixed)
-
     # make a plotter for (dynamic) visualization
     # and define a callback function
     # for plotting the intermediate configurations
 
-    plotter = MeshPlotter(mesh, figsize=(10, 6))
+    plotter = MeshPlotter(mesh, figsize=(10, 7))
 
     def callback(xyz):
         plotter.update_vertices()

src/compas/hpc/geometry/basic.py

@@ -18,7 +18,7 @@
 
 
 __all__ = [
-    'sum_vectors_numba',
+    # 'sum_vectors_numba',
     'norm_vector_numba',
     'norm_vectors_numba',
     'length_vector_numba',
@@ -69,18 +69,19 @@
 
 # ==============================================================================
 
-@jit(float64[:](float64[:, :], int64), nogil=True, nopython=True)
-def sum_vectors_numba(a, axis=0):
-    """ Calculate the sum of an array of vectors along the specified axis.
 
-    Parameters:
-        a (array): Array of vectors (m x 3).
-        axis (int): Dimension to sum through.
+# @jit(float64[:](float64[:, :], int64), nogil=True, nopython=True)
+# def sum_vectors_numba(a, axis=0):
+#     """ Calculate the sum of an array of vectors along the specified axis.
 
-    Returns:
-        array: The summed values according to the axis of choice.
-    """
-    return sum(a, axis=axis)
+#     Parameters:
+#         a (array): Array of vectors (m x 3).
+#         axis (int): Dimension to sum through.
+
+#     Returns:
+#         array: The summed values according to the axis of choice.
+#     """
+#     return sum(a, axis=axis)
 
 
 @jit(float64(float64[:]), nogil=True, nopython=True)
@@ -167,6 +168,7 @@ def length_vector_sqrd_xy_numba(a):
 
 # ==============================================================================
 
+
 @jit(float64[:](float64[:], float64), nogil=True, nopython=True)
 def scale_vector_numba(a, factor):
     """ Scale a vector by a given factor.
@@ -356,6 +358,7 @@ def square_vectors_numba(a):
 
 # ==============================================================================
 
+
 @jit(float64[:](float64[:], float64[:]), nogil=True, nopython=True)
 def add_vectors_numba(u, v):
     """ Add two vectors.
@@ -470,6 +473,7 @@ def divide_vectors_xy_numba(u, v):
 
 # ==============================================================================
 
+
 @jit(float64[:](float64[:], float64[:]), nogil=True, nopython=True)
 def cross_vectors_numba(u, v):
     """ Compute the cross product of two vectors.
@@ -532,6 +536,7 @@ def dot_vectors_xy_numba(u, v):
 
 # ==============================================================================
 
+
 @jit(float64[:, :](float64[:, :], float64[:, :]), nogil=True, nopython=True)
 def multiply_matrices_numba(A, B):
     """ The multiplication of matrices.
@@ -585,7 +590,7 @@ def multiply_matrix_vector_numba(A, b):
     e = array([[1., 2.], [0., 2.]])
     f = array([[4., 5.], [1., 2.]])
 
-    print(sum_vectors_numba(c, axis=1))
+    # print(sum_vectors_numba(c, axis=1))
     print(norm_vector_numba(u))
     print(norm_vectors_numba(c))
     print(length_vector_numba(u))

src/compas/interop/shapeop/_shapeop.py

@@ -71,7 +71,6 @@ def delete(self):
 
     def solve(self, kmax=1):
         self.kmax = kmax
-        self.init()
         shapeopPython.shapeop_solve(self.solver, self.kmax)
 
     def set_points(self, xyz):
@@ -85,18 +84,15 @@ def get_points(self):
 
     def add_plane_constraint(self, vertices, weight):
         vertices_array = int_array(vertices)
-        constraint_id = shapeopPython.shapeop_addConstraint(self.solver, 'Plane', vertices_array, len(vertices), weight)
-        return constraint_id
+        return shapeopPython.shapeop_addConstraint(self.solver, 'Plane', vertices_array, len(vertices), weight)
 
     def add_circle_constraint(self, vertices, weight):
         vertices_array = int_array(vertices)
-        constraint_id = shapeopPython.shapeop_addConstraint(self.solver, 'Circle', vertices_array, len(vertices), weight)
-        return constraint_id
+        return shapeopPython.shapeop_addConstraint(self.solver, 'Circle', vertices_array, len(vertices), weight)
 
     def add_closeness_constraint(self, vertex, weight):
         vertices_array = int_array([vertex])
-        constraint_id = shapeopPython.shapeop_addConstraint(self.solver, 'Closeness', vertices_array, 1, weight)
-        return constraint_id
+        return shapeopPython.shapeop_addConstraint(self.solver, 'Closeness', vertices_array, 1, weight)
 
 
 # ==============================================================================

src/compas/numerical/__init__.py

@@ -29,7 +29,7 @@
     :nosignatures:
 
     descent
-    devo
+    devo_numpy
     ga
     lma
     mma

src/compas/numerical/algorithms/__init__.py

@@ -1,15 +1,13 @@
 from .dr import *
-from .dr_cpp import *
 from .dr_numpy import *
 from .drx_numpy import *
 from .fd_numpy import *
 from .pca_numpy import *
 
 from .dr import __all__ as a
-from .dr_cpp import __all__ as b
-from .dr_numpy import __all__ as c
-from .drx_numpy import __all__ as d
-from .fd_numpy import __all__ as e
-from .pca_numpy import __all__ as f
+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
 
-__all__ = a + b + c + d + e + f
+__all__ = a + b + c + d + e