use the c++ polyline in patterns

Author: hiaselhans

openglider/glider/cell/cell.py

@@ -487,16 +487,13 @@ def get_point(p1, p2, l_0, l_l, l_r, left=True):
             #right_bal.append(get_point(p2, p1, l_0, d_r, get_length(i, i+1), left=False))
 
         ballooned = [
-            # TODO: C++
-            PolyLine2D(left_bal),
-            PolyLine2D(right_bal)
+            euklid.PolyLine2D(left_bal),
+            euklid.PolyLine2D(right_bal)
         ]
 
         inner = []
         for x in openglider.utils.linspace(0, 1, numribs + 2):
-            l1 = ballooned[0] * (1-x)
-            l2 = ballooned[1] * x
-            inner.append(l1.add(l2))
+            inner.append(ballooned[0].mix(ballooned[1], x))
 
         #ballooned = [left_bal, right_bal]
 

openglider/glider/cell/elements.py

@@ -32,6 +32,7 @@
 from openglider.vector.projection import flatten_list
 from openglider.utils import Config
 
+from openglider_cpp import euklid
 
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
@@ -118,9 +119,9 @@ def get_list(rib, cut_front, cut_back):
                 side = -cut_front[1]  # -1 -> lower, 1->upper
                 front = rib.profile_2d(cut_front[0] * side)
                 back = rib.profile_2d(cut_back[0] * side)
-                return rib.profile_3d[front:back]
+                return euklid.PolyLine3D(rib.profile_3d[front:back].data.tolist())
             else:
-                return PolyLine([rib.align(rib.profile_2d.align(p) + [0]) for p in (cut_front, cut_back)])
+                return euklid.PolyLine3D([rib.align(rib.profile_2d.align(p) + [0]) for p in (cut_front, cut_back)])
 
         left = get_list(cell.rib1, self.left_front, self.left_back)
         right = get_list(cell.rib2, self.right_front, self.right_back)
@@ -190,7 +191,7 @@ def get_mesh(self, cell, insert_points=4, project_3d=False):
             polygon = [range(len(vertices))]
             return Mesh.from_indexed(vertices, {"diagonals": polygon})
 
-    def get_flattened(self, cell, ribs_flattened=None) -> Tuple[PolyLine2D, PolyLine2D]:
+    def get_flattened(self, cell, ribs_flattened=None):
         first, second = self.get_3d(cell)
         left, right = flatten_list(first, second)
         return left, right
@@ -525,28 +526,17 @@ def _get_ik_values(self, cell: "openglider.glider.cell.Cell", numribs=0, exact=T
         if exact:
             ik_values_new = []
             inner = cell.get_flattened_cell(numribs)["inner"]
-            p_front_left = inner[0][ik_left_front]
-            p_front_right = inner[-1][ik_right_front]
-            p_back_left = inner[0][ik_left_back]
-            p_back_right = inner[-1][ik_right_back]
+            p_front_left = inner[0].get(ik_left_front)
+            p_front_right = inner[-1].get(ik_right_front)
+            p_back_left = inner[0].get(ik_left_back)
+            p_back_right = inner[-1].get(ik_right_back)
 
             for i, ik in enumerate(ik_values):
                 ik_front, ik_back = ik
-                line: openglider.vector.PolyLine2D = inner[i]
-
-                _cut_front = line.cut(p_front_left, p_front_right, ik_front, True)
-                _cut_back = line.cut(p_back_left, p_back_right, ik_back, True)
-
-                try:
-                    _ik_front = next(_cut_front)[0]
-                except StopIteration:
-                    _ik_front = ik_front
-                    logging.warning(f"panel_ik_failure: {ik_front} {cell}/{self}/back")
-                try:
-                    _ik_back = next(_cut_back)[0]
-                except StopIteration:
-                    _ik_back = ik_back
-                    logging.warning(f"panel_ik_failure: {ik_front} {cell}/{self}/back")
+                line: euklid.PolyLine2D = inner[i]
+
+                _ik_front, _ = line.cut(p_front_left, p_front_right, ik_front)
+                _ik_back, _ = line.cut(p_back_left, p_back_right, ik_back)
 
                 ik_values_new.append((_ik_front, _ik_back))
 
@@ -594,7 +584,7 @@ def integrate_3d_shaping(self, cell: "Cell", sigma, inner_2d, midribs=None):
 
         for rib_no in range(numribs + 2):
             x1, x2 = positions[rib_no]
-            rib_2d = inner_2d[rib_no][x1:x2]
+            rib_2d = inner_2d[rib_no].get(x1,x2)
             rib_3d = ribs[rib_no][x1:x2]
 
             lengthes_2d = rib_2d.get_segment_lengthes()
@@ -682,7 +672,7 @@ def __json__(self):
     def _get_flattened_line(self, cell):
         flattened_cell = cell.get_flattened_cell()
         left, right = flattened_cell["ballooned"]
-        line = (left * (1-self.y)).add(right * self.y)
+        line = left.mix(right, self.y)
 
         ik_front = (cell.rib1.profile_2d(self.x_start) + cell.rib2.profile_2d(self.x_start))/2
         ik_back = (cell.rib1.profile_2d(self.x_end) + cell.rib2.profile_2d(self.x_end))/2
@@ -699,18 +689,20 @@ def draw_panel_marks(self, cell, panel):
         stop = min(ik_back, ik_interpolation_back(self.y))
 
         if start < stop:
-            return line[start:stop]
+            return line.get(start, stop)
 
         return None
 
     def get_flattened(self, cell):
         line, ik_front, ik_back = self._get_flattened_line(cell)
 
-        left = line.copy().add_stuff(-self.channel_width/2)
-        right = line.copy().add_stuff(self.channel_width/2)
+        left = line.offset(-self.channel_width/2)
+        right = line.offset(self.channel_width/2)
+
+        contour = left.get(ik_front, ik_back) + right.get(ik_back, ik_front)
 
-        contour = left[ik_front:ik_back] + right[ik_back:ik_front]
-        contour.close()
+        # todo!
+        #contour.close()
 
         marks = []
 
@@ -723,7 +715,7 @@ def get_flattened(self, cell):
 
         for ik in panel_iks:
             if ik_front < ik < ik_back:
-                marks.append(openglider.vector.PolyLine2D([
+                marks.append(openglider_cpp.euklid.PolyLine2D([
                     left[ik],
                     right[ik]
                 ]))

openglider/lines/elements.py

@@ -183,7 +183,7 @@ def length_with_sag(self):
         if self.sag_par_1 is None or self.sag_par_2 is None:
             raise ValueError('Sag not yet calculated!')
 
-        return euklid.PolyLine(self.get_line_points(numpoints=100)).get_length()
+        return euklid.PolyLine3D(self.get_line_points(numpoints=100)).get_length()
 
     def get_stretched_length(self, pre_load=50, sag=True):
         """