4 static holes in miniribs

Author: NikolausKurcz

openglider/glider/rib/minirib.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 import euklid
 import logging
 
 from openglider.airfoil import Profile3D
 from openglider.utils.dataclass import dataclass, Field
-
 from openglider.mesh import Mesh, triangulate
 from openglider.vector.unit import Length, Percentage
 
@@ -20,12 +19,17 @@ class MiniRib:
     yvalue: float
     front_cut: float
     back_cut: float | None=None
+    chord: float = 0.3
     name: str="unnamed_minirib"
     material_code: str="unnamed_material"
     seam_allowance: Length = Length("10mm")
     trailing_edge_cut: Length = Length("20mm")
     mrib_num: int = 0
     function: euklid.vector.Interpolation = Field(default_factory=lambda: euklid.vector.Interpolation([]))
+    hole_num: int=4
+    hole_border_side :float=0.2
+    hole_border_front_back: float=0.15
+
 
     class Config:
         arbitrary_types_allowed = True
@@ -58,6 +62,30 @@ def get_multiplier(self, x: float) -> float:
             return min(1, max(0, self.function.get_value(abs(x))))
         else:
             return 1.
+        
+    def convert_to_percentage(self, value: Percentage | Length) -> Percentage:
+        if isinstance(value, Percentage):
+            return value
+        
+        return Percentage(value.si/self.chord)
+    
+    def get_offset_outline(self, cell:Cell, margin: Percentage | Length) -> pyfoil.Airfoil:
+        profile_3d = self.get_profile_3d(cell)
+        self.profile_2d = profile_3d.flatten()
+        if margin == 0.:
+            return self.profile_2d
+        else:
+            if isinstance(margin, Percentage):
+                margin = margin/self.chord
+            
+            envelope = self.profile_2d.curve.offset(-margin.si, simple=False).nodes
+            
+            return pyfoil.Airfoil(envelope)
+        
+    def get_flattened(self, cell:Cell) -> euklid.vector.PolyLine2D:
+        profile_3d = self.get_profile_3d(cell)
+        return profile_3d.flatten().curve
+   
 
     def get_profile_3d(self, cell: Cell) -> Profile3D:
 
@@ -115,6 +143,11 @@ def get_nodes(self, cell: Cell) -> tuple[euklid.vector.PolyLine2D, euklid.vector
 
         return nodes_top, nodes_bottom
 
+    def rename_parts(self) -> None:
+        for hole_no, hole in enumerate(self.holes):
+            hole.name = self.hole_naming_scheme.format(hole_no, rib=self)
+
+
     def get_hull(self, cell: Cell) -> euklid.vector.PolyLine2D:
         """returns the outer contour of the normalized mesh in form
            of a Polyline"""
@@ -136,10 +169,22 @@ def align_all(self, cell: Cell, data: euklid.vector.PolyLine2D) -> euklid.vector
 
         return euklid.vector.PolyLine3D(nodes_3d)
 
-    def get_mesh(self, cell: Cell, filled: bool=True, max_area: float=None) -> Mesh:
+
+    def get_mesh(self, cell:Cell, filled: bool=True, max_area: float=None, hole_res: int = 40) -> Mesh:
         vertices = [(p[0], p[1]) for p in self.get_hull(cell).nodes[:-1]]
         boundary = [list(range(len(vertices))) + [0]]
-        hole_centers: list[tuple[float, float]] = []
+        
+
+        holes, hole_centers = self.get_holes(cell, hole_res)
+
+        for curve in holes:
+            start_index = len(vertices)
+            hole_vertices = curve.tolist()[:-1]
+            hole_indices = list(range(len(hole_vertices))) + [0]
+            vertices+= hole_vertices
+            boundary.append([start_index + i for i in hole_indices])
+
+
 
         if not filled:
             segments = []
@@ -163,12 +208,77 @@ def get_mesh(self, cell: Cell, filled: bool=True, max_area: float=None) -> Mesh:
 
 
             minirib_mesh = Mesh.from_indexed(points.nodes, polygons={"miniribs": [(tri, {}) for tri in mesh.elements]} , boundaries=boundaries)
-            
-            #for hole in self.holes:
-            #    if hole_mesh := hole.get_mesh(self):
-            #        rib_mesh += hole_mesh
+ 
 
         return minirib_mesh
 
 
-    
+    def get_holes(self, cell: Cell, points: int=40) -> tuple[list[euklid.vector.PolyLine2D], list[euklid.vector.Vector2D]]:
+        
+        nodes_top, nodes_bottom = self.get_nodes(cell)
+
+        len_top=nodes_top.get_length()
+        len_bot=nodes_bottom.get_length()
+
+        def get_point(x: float, y: float) -> euklid.vector.Vector2D:
+            p1 = nodes_top.get(nodes_top.walk(0, len_top*x))
+            p2 = nodes_bottom.get(nodes_bottom.walk(0, len_bot*(1-x)))
+
+            return p1 + (p2-p1)*y
+        
+        holes = []
+        centers = []
+        
+        if self.hole_num == 4:
+            holes = [
+                euklid.spline.BSplineCurve([
+                    get_point(0.9,0.9),
+                    get_point(0.85,0.9),
+                    get_point(0.85,0.1),
+                    get_point(0.95,0.1),
+                    get_point(0.95,0.9),
+                    get_point(0.9,0.9),   
+                ]).get_sequence(points),
+                
+                euklid.spline.BSplineCurve([
+                    get_point(0.75,0.9),
+                    get_point(0.7,0.9),
+                    get_point(0.7,0.1),
+                    get_point(0.8,0.1),
+                    get_point(0.8,0.9),
+                    get_point(0.75,0.9),   
+                ]).get_sequence(points),
+
+                euklid.spline.BSplineCurve([
+                    get_point(0.625,0.9),
+                    get_point(0.575,0.9),
+                    get_point(0.575,0.1),
+                    get_point(0.65,0.1),
+                    get_point(0.65,0.9),
+                    get_point(0.625,0.9),   
+                ]).get_sequence(points),
+
+                euklid.spline.BSplineCurve([
+                    get_point(0.5,0.9),
+                    get_point(0.475,0.9),
+                    get_point(0.475,0.1),
+                    get_point(0.525,0.1),
+                    get_point(0.525,0.9),
+                    get_point(0.5,0.9),   
+                ]).get_sequence(points),
+
+
+                
+
+            ]
+
+            centers = [
+
+                get_point(0.9, 0.5),
+                get_point(0.75, 0.5),
+                get_point(0.625, 0.5),
+                get_point(0.5, 0.5),
+            ]
+
+        return holes, centers
+

openglider/plots/glider/minirib.py

@@ -144,16 +144,14 @@ def get_material_usage(self) -> MaterialUsage:
 
         curves = dwg.layers["cuts"].polylines
         usage = MaterialUsage()
-        material = cloth.get(dwg.material_code) #Material(weight=38, name="mribs")
+        material = cloth.get(dwg.material_code)
 
         if curves:
             area = curves[0].get_area()
 
-        #to do implement holes for miniribs
-        #
-        #    for curve in self.mrib.get_holes(self.cell)[0]:
-        #        area -= curve.get_area()
-        #        
+        #to do implement holes for miniribs--> check if its working!!
+            for curve in self.minirib.get_holes(self.cell)[0]:
+                area -= curve.get_area()      
             usage.consume(material, area)
 
         return usage
@@ -178,6 +176,9 @@ def flatten(self) -> PlotPart:
 
         plotpart.layers[self.layer_name_outline].append(envelope)
 
+        for curve in self.minirib.get_holes(self.cell)[0]:
+            plotpart.layers["cuts"].append(curve)
+
         self.add_text(plotpart)
 
         self.plotpart = plotpart