Curve surface okayish implementation

main.py

@@ -7,17 +7,43 @@ import numpy as np
 editor = Editor(buffering=True)
 
 y = 20
-coordinates = [(-854, 87+y, -210), (-770, 99+y, -207), (-736, 85+y, -184)]
+
-resolution, distance = curve.resolution_distance(coordinates, 10)
+# Over the hill
+# coordinates = [(-854, 87+y, -210), (-770, 99+y, -207), (-736, 85+y, -184)]
+
+# Along the river
+# coordinates = [(-456, 69, -283), (-588, 106, -374), (-720, 71, -384), (-775, 67, -289), (-822, 84, -265), (-868, 77, -188), (-927, 96, -127),
+#                (-926, 65, -29), (-906, 98, 42), (-902, 137, 2), (-909, 115, -62), (-924, 76, -6), (-985, 76, 37), (-1043, 76, 28), (-1102, 66, 63)]
+
+# Though the loop
+coordinates = [(-1005, 113, -19), (-896, 113, 7),
+               (-807, 76, 54), (-738, 76, -10), (-678, 76, -86)]
+
+resolution, distance = curve.resolution_distance(coordinates, 6)
 
 curve_points = curve.curve(coordinates, resolution)
-curve_surface = CurveSurface.CurveSurface(curve_points)
+curve_surface = CurveSurface.CurveSurface(coordinates)
 curve_surface.compute_curvature()
-curve_surface.compute_surface(50, curve_surface.curvature, 1)
 
-for line_range in range(len(curve_surface.offset_points[0])):
+curvature = []
-    for coordinate in curve_surface.offset_points[line_range]:
+for i in range(len(curve_surface.curvature)):
-        editor.placeBlock(coordinate, Block("white_concrete"))
+    curvature.append((0, 1, 0))
+
+curve_surface.compute_surface(10, curvature)
+
+# for coordinate in curve_surface.offset_points:
+#     editor.placeBlock(coordinate, Block("white_concrete"))
+
+for coordinate in curve_surface.surface:
+    editor.placeBlock(coordinate, Block("black_concrete"))
+
+for coordinate in curve_surface.curve:
+    editor.placeBlock(coordinate, Block("red_concrete"))
+
+
+# for line_range in range(len(curve_surface.offset_points[0])):
+#     for coordinate in curve_surface.offset_points[line_range]:
+#         editor.placeBlock(coordinate, Block("red_concrete"))
 
 # offset = curve.offset(curve_points, i)
 

networks/Curve.py

@@ -21,7 +21,7 @@ def curve(target_points, resolution=40):
     z = coords[:, 2]
 
     # Compute
-    tck, u = interpolate.splprep([x, y, z], s=2, k=2)
+    tck, u = interpolate.splprep([x, y, z], s=3, k=2)
     x_knots, y_knots, z_knots = interpolate.splev(tck[0], tck)
     u_fine = np.linspace(0, 1, resolution)
     x_fine, y_fine, z_fine = interpolate.splev(u_fine, tck)
@@ -71,7 +71,7 @@ def curvature(curve):
     dT_dt = np.array([[deriv_tangent_x[i], deriv_tangent_y[i], deriv_tangent_z[i]]
                      for i in range(deriv_tangent_x.size)])
     length_dT_dt = np.sqrt(
-        deriv_tangent_x * deriv_tangent_x + deriv_tangent_y * deriv_tangent_y + deriv_tangent_z * deriv_tangent_z)
+        deriv_tangent_x * deriv_tangent_x + deriv_tangent_y * deriv_tangent_y + deriv_tangent_z * deriv_tangent_z + 0.0001)
 
     normal = np.array([1/length_dT_dt]).transpose() * dT_dt
     return normal

networks/CurveSurface.py

@@ -16,15 +16,66 @@ class CurveSurface:
     def compute_curvature(self):
         self.curvature = curve.curvature(self.curve)
 
-    def compute_surface(self, width, normals, resolution):
+    def compute_surface(self, width, normals):
-        self.offset_points = [None] * (width * resolution)
+        self.offset_left = curve.offset(self.curve, width, normals)
+        self.offset_right = curve.offset(self.curve, -width, normals)
+        self.perpendicular_segment = []
+
+        for i in range(len(self.offset_left)):
+            self.perpendicular_segment.append(segment.discrete_segment(
+                self.offset_left[i], self.offset_right[i], pixel_perfect=False))
+
         self.surface = []
-        for line_range in range(width * resolution):
-            self.offset_points[line_range] = curve.offset(
-                self.curve, line_range/resolution, normals)
 
-            for i in range(len(self.offset_points[line_range])-1):
+        for i in range(len(self.perpendicular_segment)-1):
-                self.surface.extend(segment.discrete_segment(
+            for j in range(len(self.perpendicular_segment[i])):
-                    self.offset_points[line_range][i], self.offset_points[line_range][i+1], pixel_perfect=False))
+                # Hypothesis
+                max_length_index = i
+                min_length_index = i+1
+                proportion = len(
+                    self.perpendicular_segment[min_length_index])/len(self.perpendicular_segment[max_length_index])
 
-        print(self.surface)
+                # Reverse order if wrong hypothesis
+                if proportion > 1:
+                    max_length_index = i+1
+                    min_length_index = i
+                    proportion = len(
+                        self.perpendicular_segment[min_length_index])/len(self.perpendicular_segment[max_length_index])
+
+                for k in range(len(self.perpendicular_segment[max_length_index])):
+                    self.surface.extend(segment.discrete_segment(
+                        self.perpendicular_segment[max_length_index][k], self.perpendicular_segment[min_length_index][round(k * proportion)-1], pixel_perfect=False))
+
+        # for i in range(len(self.offset_points)):
+        #     self.perpendicular_segment[i].append(
+        #         segment.discrete_segment(self.offset_points[i], self.curve[i]))
+
+        # for j in range(len(self.offset_points)-1):
+        #     # Hypothesis
+        #     max_length_index = j
+        #     min_length_index = j+1
+        #     proportion = len(
+        #         self.perpendicular_segment[min_length_index])/len(self.perpendicular_segment[max_length_index])
+
+        #     # Reverse order if wrong hypothesis
+        #     if proportion > 1:
+        #         max_length_index = j+1
+        #         min_length_index = j
+        #         proportion = len(
+        #             self.perpendicular_segment[min_length_index])/len(self.perpendicular_segment[max_length_index])
+
+        #     for k in range(len(self.perpendicular_segment[max_length_index])):
+        #         # print(self.perpendicular_segment[max_length_index][k],
+        #         #     self.perpendicular_segment[min_length_index][round(k * proportion)])
+        #         self.surface.extend(segment.discrete_segment(
+        #             self.perpendicular_segment[max_length_index][k], self.perpendicular_segment[min_length_index][round(k * proportion)]))
+
+        # for line_range in range(width * resolution):
+        #     self.offset_points[line_range] = curve.offset(
+        #         self.curve, line_range/resolution, normals)
+
+        #     for i in range(len(self.offset_points[line_range])-1):
+        #         self.surface.extend(segment.discrete_segment(
+        #             self.offset_points[line_range][i], self.offset_points[line_range][i+1], pixel_perfect=False))
+
+        # print(self.surface)

networks/Segment.py

@@ -19,8 +19,11 @@ def parallel(segment, distance, normal=np.array([0, 1, 0])):
 
 def normalized(vector):
     magnitude = np.linalg.norm(vector)
-    normalized_vector = vector / magnitude
+    if magnitude != 0:
-    return normalized_vector
+        normalized_vector = vector / magnitude
+        return normalized_vector
+    else:
+        return [0, 0, 0]
 
 
 def orthogonal(origin, point, distance, normal=np.array([0, 1, 0])):
@@ -47,6 +50,8 @@ def orthogonal(origin, point, distance, normal=np.array([0, 1, 0])):
     orthogonal = np.cross(normalized_vector, normalized_normal)
 
     if np.array_equal(orthogonal, np.zeros((3,))):
+        print(normalized_vector, normalized_normal, orthogonal, normal)
+        print(origin, point, distance)
         raise ValueError("The input vectors are not linearly independent.")
 
     orthogonal = np.round(