Refactor: adding Loft's side edges

Author: FranzBangar

src/classy_blocks/construct/operations/operation.py

@@ -6,7 +6,7 @@
 from classy_blocks.base.element import ElementBase
 from classy_blocks.base.exceptions import EdgeCreationError
 from classy_blocks.base.transforms import Mirror
-from classy_blocks.construct.edges import EdgeData, Line, Project
+from classy_blocks.construct.edges import Arc, EdgeData, Line, Project, Spline
 from classy_blocks.construct.flat.face import Face
 from classy_blocks.construct.point import Point
 from classy_blocks.grading.chop import Chop
@@ -323,3 +323,40 @@ def transform(self, transforms):
             )
 
         return super().transform(transforms)
+
+    @classmethod
+    def from_series(cls, faces: List[Face]) -> "Operation":
+        """Creates a Loft from a list of faces.
+        At least two are required.
+        From faces in between, side edges are created:
+        - 2 faces: no side edges
+        - 3: Arcs
+        - 4 or more: Splines"""
+        if len(faces) < 2:
+            raise ValueError("Provide at least two faces!")
+
+        loft = cls(faces[0], faces[-1])
+
+        if len(faces) == 2:
+            return loft
+
+        edge_points: List[List[NPPointType]] = []
+
+        # collect points for splines on each side
+        for i in range(4):
+            points = []
+
+            for face in faces[1:-1]:
+                points.append(face.points[i].position)
+
+            edge_points.append(points)
+
+        # add edges according to collected points
+        for i in range(4):
+            if len(edge_points[i]) == 1:
+                loft.add_side_edge(i, Arc(edge_points[i][0]))
+                continue
+
+            loft.add_side_edge(i, Spline(edge_points[i]))
+
+        return loft

src/classy_blocks/construct/shape.py

@@ -6,12 +6,11 @@
 import numpy as np
 
 from classy_blocks.base.element import ElementBase
-from classy_blocks.construct.edges import Angle, Arc, Spline
+from classy_blocks.construct.edges import Angle
 from classy_blocks.construct.flat.sketch import Sketch, SketchT
 from classy_blocks.construct.operations.loft import Loft
 from classy_blocks.construct.operations.operation import Operation
 from classy_blocks.types import AxisType, NPPointType, VectorType
-from classy_blocks.util import constants
 from classy_blocks.util import functions as f
 
 ShapeT = TypeVar("ShapeT", bound="Shape")
@@ -83,51 +82,8 @@ def __init__(
             for j, face_1 in enumerate(list_1):
                 face_2 = self.sketch_2.grid[i][j]
 
-                loft = Loft(face_1, face_2)
-
-                # add edges, if applicable
-                if len(sketch_mid) > 0:
-                    # Create arc from sketch_mid if only one present
-                    if len(self.sketch_mid) == 1:
-                        face_mid = self.sketch_mid[0].grid[i][j]
-                        for k, point in enumerate(face_mid.points):
-                            sketch_1_point = self.sketch_1.grid[i][j].points[k].position
-                            sketch_2_point = self.sketch_2.grid[i][j].points[k].position
-                            # If not linear, make arc
-                            if (
-                                abs(
-                                    abs(
-                                        np.dot(sketch_1_point - point.position, sketch_1_point - sketch_2_point)
-                                        / f.norm(sketch_1_point - point.position)
-                                    )
-                                    - 1
-                                )
-                                > constants.TOL
-                            ):
-                                loft.add_side_edge(k, Arc(point.position))
-
-                    # Create spline from multiple sketch_mid
-                    else:
-                        face_mid = [sketch_mid_i.grid[i][j] for sketch_mid_i in self.sketch_mid]
-                        for k in range(len(face_mid[0].points)):
-                            sketch_1_point = self.sketch_1.grid[i][j].points[k].position
-                            sketch_2_point = self.sketch_2.grid[i][j].points[k].position
-                            points = [face_mid_i.points[k].position for face_mid_i in face_mid]
-                            # If not linear, make spline
-                            if any(
-                                [
-                                    abs(
-                                        abs(
-                                            np.dot(sketch_1_point - p, sketch_1_point - sketch_2_point)
-                                            / f.norm(sketch_1_point - p)
-                                        )
-                                        - 1
-                                    )
-                                    > constants.TOL
-                                    for p in points
-                                ]
-                            ):
-                                loft.add_side_edge(k, Spline(points))
+                mid_faces = [sketch.grid[i][j] for sketch in sketch_mid]
+                loft = Loft.from_series([face_1, *mid_faces, face_2])
 
                 self.lofts[-1].append(loft)
 

tests/test_construct/test_operation/test_operation.py

@@ -5,7 +5,7 @@
 
 from classy_blocks.base.exceptions import EdgeCreationError
 from classy_blocks.base.transforms import Mirror
-from classy_blocks.construct.edges import Arc, Project
+from classy_blocks.construct.edges import Arc, Project, Spline
 from classy_blocks.construct.flat.face import Face
 from classy_blocks.construct.operations.extrude import Extrude
 from classy_blocks.construct.operations.loft import Loft
@@ -154,6 +154,40 @@ def test_get_normal_face(self, point, orient):
 
         np.testing.assert_array_equal(normal_face.center, self.loft.get_face(orient).center)
 
+    def test_from_series_error(self):
+        """Raise an error when creating from a single face"""
+        with self.assertRaises(ValueError):
+            Loft.from_series([self.loft.top_face])
+
+    def test_from_series_2(self):
+        loft_1 = self.loft
+        loft_2 = Loft.from_series([loft_1.bottom_face, loft_1.top_face])
+
+        np.testing.assert_equal(loft_1.center, loft_2.center)
+
+    def test_from_series_3(self):
+        loft = self.loft
+        faces = [loft.bottom_face, loft.bottom_face.copy().translate([0, 0, 0.5]), loft.top_face]
+
+        new_loft = Loft.from_series(faces)
+
+        for i in range(4):
+            self.assertIsInstance(new_loft.side_edges[i], Arc)
+
+    def test_from_series_4(self):
+        loft = self.loft
+        faces = [
+            loft.bottom_face,
+            loft.bottom_face.copy().translate([0, 0, 0.33]),
+            loft.bottom_face.copy().translate([0, 0, 0.66]),
+            loft.top_face,
+        ]
+
+        new_loft = Loft.from_series(faces)
+
+        for i in range(4):
+            self.assertIsInstance(new_loft.side_edges[i], Spline)
+
 
 class OperationProjectionTests(BlockTestCase):
     """Operation: projections"""