update rigidfoils

Author: hiaselhans

openglider/glider/rib/rib.py

@@ -262,11 +262,18 @@ def get_offset_outline(self, margin: Percentage | Length) -> pyfoil.Airfoil:
 
     def get_rigidfoils(self) -> list[RigidFoilBase]:
         if self.sharknose is not None:
-            rigidfoils = self.sharknose.update_rigidfoils(self)
-            for rigid_no, rigid in enumerate(rigidfoils):
+            result: list[RigidFoilBase] = []
+
+            for rigidfoil in self.rigidfoils:
+                rigidfoils_this = self.sharknose.update_rigidfoil(self, rigidfoil)
+                if rigidfoils_this is not None:
+                    result += rigidfoils_this
+                else:
+                    result.append(rigidfoil)
+            for rigid_no, rigid in enumerate(result):
                 rigid.name = self.rigid_naming_scheme.format(rigid_no, rib=self)
 
-            return rigidfoils
+            return result
 
         return self.rigidfoils
 

openglider/glider/rib/rigidfoils.py

@@ -26,17 +26,24 @@ class RigidFoilBase(ABC, BaseModel):
 
     cap_length: Length = Length("2cm")
     tension: Percentage = Percentage("98%")
+    material: str = "Plastic"
+    diameter: Length = Length("2mm")
 
     def get_3d(self, rib: Rib) -> euklid.vector.PolyLine3D:
-        return euklid.vector.PolyLine3D([rib.align(p, scale=False) for p in self.get_flattened(rib)])
+        return euklid.vector.PolyLine3D([rib.align(p, scale=False) for p in self.get_center_line(rib)])
 
     def get_length(self, rib: Rib) -> float:
-        return self.get_flattened(rib).get_length() * self.tension.si
+        return self.get_center_line(rib).get_length() * self.tension.si
 
-    def get_flattened(self, rib: Rib, glider: Glider=None) -> euklid.vector.PolyLine2D:
-        return self._get_flattened(rib, glider).fix_errors()
+    def get_flattened(self, center_line: euklid.vector.PolyLine2D) -> euklid.vector.PolyLine2D:
+        outer_line = center_line.offset(self.diameter.si/2).fix_errors()
+        inner_line = center_line.offset(-self.diameter.si/2).fix_errors()
+
+        outline = euklid.vector.PolyLine2D(outer_line.nodes + inner_line.nodes[::-1]).close()
+
+        return outline
 
-    def _get_flattened(self, rib: Rib, glider: Glider=None) -> euklid.vector.PolyLine2D:
+    def get_center_line(self, rib: Rib, glider: Glider=None) -> euklid.vector.PolyLine2D:
         raise NotImplementedError()
 
     def get_cap_radius(self, start: bool) -> tuple[Length, Percentage]:
@@ -62,7 +69,7 @@ def func(self, pos: float, radius: Percentage) -> float:
     def get_cap_radius(self, start: bool) -> tuple[Length, Percentage]:
         return -self.circle_radius, Percentage(0.35)
 
-    def _get_flattened(self, rib: Rib, glider: Glider=None) -> euklid.vector.PolyLine2D:
+    def get_center_line(self, rib: Rib, glider: Glider=None) -> euklid.vector.PolyLine2D:
         max_segment = 0.005  # 5mm
         profile = rib.get_hull()
         profile_normvectors = profile.normvectors
@@ -90,7 +97,7 @@ def _get_flattened(self, rib: Rib, glider: Glider=None) -> euklid.vector.PolyLin
         indices = [profile(x) for x in point_range]
 
         # convert to unitless percentage (everything is scaled later)
-        distance = rib.convert_to_percentage(self.distance)
+        distance = rib.convert_to_percentage(self.distance) + rib.convert_to_percentage(self.diameter/2)
         radius = rib.convert_to_percentage(self.circle_radius)
 
         nodes = [
@@ -105,13 +112,13 @@ class _RigidFoilCurved(RigidFoilBase):
     append_curve: bool = True
     straight_part: Length = Length(0)
 
-    def _get_flattened(self, rib: Rib, glider: Glider=None) -> euklid.vector.PolyLine2D:
+    def get_center_line(self, rib: Rib, glider: Glider=None) -> euklid.vector.PolyLine2D:
         profile = rib.get_hull()
 
         start = profile.get_ik(self.start.si)
         end = profile.get_ik(self.end.si)
 
-        distance = rib.convert_to_chordlength(self.distance)
+        distance = rib.convert_to_chordlength(self.distance) + self.diameter/2
 
         rigidfoil_curve = (profile.curve.get(start, end) * rib.chord).offset(-distance.si).fix_errors()
         inner_curve = rigidfoil_curve

openglider/glider/rib/sharknose.py

@@ -88,51 +88,46 @@ def get_tangent(ik: float, from_point: euklid.vector.Vector2D, to_point: euklid.
 
         return openglider.airfoil.Profile2D(data)
 
-    def update_rigidfoils(self, rib: Rib) -> list[RigidFoilBase]:
-        result: list[RigidFoilBase] = []
-
-        nearest_position = round(rib.profile_2d.get_ik(self.position))
-        position = Percentage(rib.profile_2d.curve.get(nearest_position)[0])
-
-        for rigidfoil in rib.rigidfoils:
-            if rigidfoil.start < position and rigidfoil.end > position:
-                # split rigidfoil
-                rigid_1 = RigidFoilCurved(
-                    start=rigidfoil.start,
-                    end=position,
-                    distance=rigidfoil.distance,
-                    cap_length=rigidfoil.cap_length,
-                    tension=rigidfoil.tension,
-                    inner_allowance=rigidfoil.inner_allowance
-                )
-                if straight_part := getattr(rigidfoil, "straight_part"):
-                    rigid_1.straight_part = straight_part
-                    
-                radius, amount =  rigidfoil.get_cap_radius(start=True)
-                rigid_1.circle_radius_start = radius
-                rigid_1.circle_amount_start = amount
-                rigid_1.circle_radius_end = self.rigidfoil_circle_radius
-                rigid_1.circle_amount_end = self.rigidfoil_circle_amount
-
-                rigid_2 = RigidFoilCurved(
-                    start=position,
-                    end=rigidfoil.end,
-                    distance=rigidfoil.distance,
-                    cap_length=rigidfoil.cap_length,
-                    tension=rigidfoil.tension,
-                    inner_allowance=rigidfoil.inner_allowance
-                )
-                if straight_part := getattr(rigidfoil, "straight_part"):
-                    rigid_2.straight_part = straight_part
-
-                radius, amount =  rigidfoil.get_cap_radius(start=False)
-                rigid_2.circle_radius_end = radius
-                rigid_2.circle_amount_end = amount
-                rigid_2.circle_radius_start = self.rigidfoil_circle_radius
-                rigid_2.circle_amount_start = self.rigidfoil_circle_amount
-
-                result += [rigid_1, rigid_2]
-            else:
-                result.append(rigidfoil)
-        
-        return result
+    def update_rigidfoil(self, rib: Rib, rigidfoil: RigidFoilBase) -> tuple[RigidFoilCurved, RigidFoilCurved] | None:
+        if rigidfoil.start < self.position and rigidfoil.end > self.position:
+            nearest_position = round(rib.profile_2d.get_ik(self.position))
+            position = Percentage(rib.profile_2d.curve.get(nearest_position)[0])
+
+            # split rigidfoil
+            rigid_1 = RigidFoilCurved(
+                start=rigidfoil.start,
+                end=position,
+                distance=rigidfoil.distance,
+                cap_length=rigidfoil.cap_length,
+                tension=rigidfoil.tension,
+                inner_allowance=rigidfoil.inner_allowance
+            )
+            if straight_part := getattr(rigidfoil, "straight_part", None):
+                rigid_1.straight_part = straight_part
+                
+            radius, amount =  rigidfoil.get_cap_radius(start=True)
+            rigid_1.circle_radius_start = radius
+            rigid_1.circle_amount_start = amount
+            rigid_1.circle_radius_end = self.rigidfoil_circle_radius
+            rigid_1.circle_amount_end = self.rigidfoil_circle_amount
+
+            rigid_2 = RigidFoilCurved(
+                start=position,
+                end=rigidfoil.end,
+                distance=rigidfoil.distance,
+                cap_length=rigidfoil.cap_length,
+                tension=rigidfoil.tension,
+                inner_allowance=rigidfoil.inner_allowance
+            )
+            if straight_part:
+                rigid_2.straight_part = straight_part
+
+            radius, amount =  rigidfoil.get_cap_radius(start=False)
+            rigid_2.circle_radius_end = radius
+            rigid_2.circle_amount_end = amount
+            rigid_2.circle_radius_start = self.rigidfoil_circle_radius
+            rigid_2.circle_amount_start = self.rigidfoil_circle_amount
+
+            return (rigid_1, rigid_2)
+
+        return None

openglider/materials/cloth.csv

@@ -8,6 +8,7 @@ porcher,skytex_32,32,petrol_blue,#01567D
 porcher,skytex_32,32,deep_blue,#243882
 porcher,skytex_32,32,lime_green_500,#96C11E
 porcher,skytex_32,32,lime_green_530,#BCB21F
+porcher,skytex_32,32,green,#00945E
 porcher,skytex_32,32,green_551,#9BBB59
 porcher,skytex_32,32,dragon_red,#E62E39
 porcher,skytex_32,32,sangria,#AE2760

openglider/plots/glider/ribs.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import math
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 from collections.abc import Callable
 
 import euklid
@@ -33,80 +33,109 @@ class RigidFoilPlot:
     rigidfoil: RigidFoilBase
     ribplot: RibPlot
 
+    drawing: PlotPart
     inner_curve: euklid.vector.PolyLine2D | None = None
     outer_curve: euklid.vector.PolyLine2D | None = None
+    center_curve: euklid.vector.PolyLine2D | None = None
 
     def __init__(self, rigidfoil: RigidFoilBase, ribplot: RibPlot) -> None:
         self.rigidfoil = rigidfoil
         self.ribplot = ribplot
+        self.drawing = PlotPart()
 
-    def add_text(self, plotpart: PlotPart) -> None:
-        (_, p1), (_, p2) = self.get_cap(-1, True)
+    def add_text(self) -> None:
+        (_, p1), (_, p2) = self.get_cap("back")
 
-        plotpart.layers[self.ribplot.layer_name_text] += Text(
+        self.drawing.layers[self.ribplot.layer_name_text] += Text(
             self.rigidfoil.name, p1, p2, align="center", valign=0.6
         ).get_vectors()
 
-    def get_cap(self, position: int, rear: bool) -> tuple[tuple[Vector2D, Vector2D], tuple[Vector2D, Vector2D]]:
-        assert self.inner_curve is not None and self.outer_curve is not None
+    def get_cap(self, side: Literal["front", "back"], outer_distance: float | None = None) -> tuple[tuple[Vector2D, Vector2D], tuple[Vector2D, Vector2D]]:
+        if side == "front":
+            position = 0
+            angle = math.pi/2
+        elif side == "back":
+            position = -1
+            angle = -math.pi/2
+        else:
+            raise ValueError("side must be 'front' or 'back'")
+        
+        if self.center_curve is None:
+            raise ValueError("Setup not called")
+
+        if outer_distance is None:
+            outer_distance = self.get_outer_distance().si
+        inner_distance = self.get_inner_distance().si
 
+        center_point = self.center_curve.nodes[position]
+        normal = self.center_curve.normvectors().nodes[position]
+
+        outer_point = center_point + normal * outer_distance
+        inner_point = center_point - normal * inner_distance
         # back cap
-        p1 = self.inner_curve.nodes[position]
-        p2 = self.outer_curve.nodes[position]
-        angle = math.pi/2
-        if rear:
-            angle = -angle
-        diff = euklid.vector.Rotation2D(angle).apply(p1-p2).normalized() * self.rigidfoil.cap_length.si
+        diff = euklid.vector.Rotation2D(angle).apply(inner_point - outer_point).normalized() * self.rigidfoil.cap_length.si
 
         return (
-            (p1, p2),
-            (p1+diff, p2+diff)
+            (inner_point, outer_point),
+            (inner_point+diff, outer_point+diff)
         )
 
-    def _get_inner_outer(self, glider: Glider) -> tuple[euklid.vector.PolyLine2D, euklid.vector.PolyLine2D]:
-        curve = self.rigidfoil.get_flattened(self.ribplot.rib, glider)
-
+    def get_outer_distance(self) -> Length:
         distance = self.ribplot.rib.convert_to_chordlength(self.rigidfoil.distance)
-        d_outer = self.ribplot.rib.seam_allowance.si + distance.si
-
+        return self.ribplot.rib.seam_allowance + distance + self.rigidfoil.diameter/2
+    
+    def get_inner_distance(self) -> Length:
         if self.rigidfoil.inner_allowance:
             allowance = self.rigidfoil.inner_allowance
         else:
             allowance = self.ribplot.rib.seam_allowance
 
-        inner_curve = curve.offset(-(distance+allowance).si).fix_errors()
-        outer_curve = curve.offset(d_outer).fix_errors()
+        return (self.rigidfoil.diameter/2+allowance)
+    
+    def setup(self, glider: Glider) -> tuple[euklid.vector.PolyLine2D, euklid.vector.PolyLine2D, euklid.vector.PolyLine2D]:
+        if any([x is None for x in [self.inner_curve, self.outer_curve, self.center_curve]]):
+            curve = self.rigidfoil.get_center_line(self.ribplot.rib, glider)
+
+            d_outer = self.get_outer_distance()
+            d_inner = self.get_inner_distance()
 
-        return inner_curve, outer_curve
+            
+            self.center_curve = curve
+            self.inner_curve = curve.offset(-d_inner.si)
+            self.outer_curve = curve.offset(d_outer.si)
+
+        return self.center_curve, self.inner_curve, self.outer_curve  # type: ignore
+    
+    def insert_mark(self) -> None:
+        assert self.center_curve is not None
+
+        rigidfoil_outline = self.rigidfoil.get_flattened(self.center_curve)
+
+        self.drawing.layers[self.ribplot.layer_name_marks].append(rigidfoil_outline)
+        self.ribplot.plotpart.layers[self.ribplot.layer_name_rigidfoils].append(rigidfoil_outline)
 
     def flatten(self, glider: Glider) -> PlotPart:
-        plotpart = PlotPart()
+        curve, inner_curve, outer_curve = self.setup(glider)
+        plotpart = self.drawing
 
         controlpoints: list[tuple[float, list[euklid.vector.PolyLine2D]]] = []
         for x in self.ribplot.config.get_controlpoints(self.ribplot.rib):
             for mark in self.ribplot.insert_mark(x, self.ribplot.config.marks_controlpoint, insert=False):
                 controlpoints.append((x, mark))
 
-        curve = self.rigidfoil.get_flattened(self.ribplot.rib, glider)
-
         # add marks into the profile
-        self.ribplot.plotpart.layers[self.ribplot.layer_name_rigidfoils].append(curve)
         self.ribplot.plotpart.layers[self.ribplot.layer_name_laser_dots].append(euklid.vector.PolyLine2D([curve.get(0)]))
         self.ribplot.plotpart.layers[self.ribplot.layer_name_laser_dots].append(euklid.vector.PolyLine2D([curve.get(len(curve)-1)]))
 
-        self.inner_curve, self.outer_curve = self._get_inner_outer(glider)
-
-        plotpart.layers[self.ribplot.layer_name_marks].append(curve)
-
-        back_cap = self.get_cap(-1, True)
+        back_cap = self.get_cap("back")
         plotpart.layers[self.ribplot.layer_name_marks].append(euklid.vector.PolyLine2D(list(back_cap[0])))
 
-        front_cap = self.get_cap(0, False)
+        front_cap = self.get_cap("front")
         plotpart.layers[self.ribplot.layer_name_marks].append(euklid.vector.PolyLine2D(list(front_cap[0])))
 
-        outline = self.inner_curve
+        outline = inner_curve
         outline += euklid.vector.PolyLine2D(list(back_cap[1]))
-        outline += self.outer_curve.reverse()
+        outline += outer_curve.reverse()
         outline += euklid.vector.PolyLine2D(list(front_cap[1])).reverse()
 
         for x, controlpoint in controlpoints:
@@ -117,7 +146,7 @@ def flatten(self, glider: Glider) -> PlotPart:
 
         plotpart.layers[self.ribplot.layer_name_outline].append(outline.fix_errors().close())
 
-        self.add_text(plotpart)
+        self.add_text()
 
         return plotpart