set xcb plugin only on windows, some updates to export meshes

Author: hiaselhans

openglider/glider/ballooning/new.py

@@ -139,6 +139,14 @@ def __imul__(self, factor: float) -> BallooningBezierNeu:  # TODO: Check consist
         self.scale(factor)
         self.apply_splines()
         return self
+    
+    def close_trailing_edge(self, start_x: float) -> None:
+        cp = self.controlpoints.nodes[:]
+        cp[0][1] = 0
+        cp[-1][1] = 0
+        self.controlpoints = euklid.vector.PolyLine2D(cp)
+        
+        return super().close_trailing_edge(start_x)
 
     @property
     def controlpoints(self) -> euklid.vector.PolyLine2D:

openglider/glider/glider.py

@@ -165,6 +165,33 @@ def get_mesh_hull(self, num_midribs: int=0, ballooning: bool=True) -> Mesh:
         ribs_flat = [p for rib in ribs for p in rib]
 
         return Mesh.from_indexed(ribs_flat, {"hull": polygons}, boundary)
+    
+    def get_mesh_all(self, numribs: int=10) -> Mesh:
+
+        mesh = Mesh()
+
+        for i, cell in enumerate(self.cells):
+            cell_mesh = Mesh()
+            for panel in cell.panels:
+                cell_mesh += panel.get_mesh(cell, numribs=numribs)
+            for strap in cell.straps:
+                cell_mesh += strap.get_mesh(cell)
+            for diagonal in cell.diagonals:
+                cell_mesh += diagonal.get_mesh(cell)
+
+            if not (i == 0 and self.has_center_cell):
+                cell_mesh += cell_mesh.copy().mirror("y")
+            
+            mesh += cell_mesh
+
+        for i, rib in enumerate(self.ribs):
+            rib_mesh = rib.get_mesh(hole_num=30, filled=True)
+            if not (i == 0 and not self.has_center_cell):
+                rib_mesh += rib_mesh.copy().mirror("y")
+            
+            mesh += rib_mesh
+        
+        return mesh
 
     def return_ribs(self, num_midribs: int=0, ballooning: bool=True) -> list[list[euklid.vector.Vector3D]]:
         """

openglider/glider/parametric/glider.py

@@ -3,7 +3,8 @@
 import copy
 import logging
 import math
-from typing import TYPE_CHECKING
+import random
+from typing import TYPE_CHECKING, Self
 from collections.abc import Callable
 
 import euklid
@@ -95,6 +96,55 @@ def get_geomentry_table(self) -> Table:
             table[1+rib_no, 10] = 0
 
         return table
+    
+    def randomize(self) -> ParametricGlider:
+        new = self.copy()
+
+        def get_factor(spread: float) -> float:
+            return 1 + 2 * spread * (-0.5 + random.random())
+
+        # change profiles
+        for i, foil in enumerate(self.profiles):
+            foil.set_camber(foil.camber * get_factor(0.1))
+            foil.set_thickness(foil.thickness * get_factor(0.1))
+
+        def randomize_nodes(
+                curve: euklid.vector.PolyLine2D, 
+                factor: float,
+                change_first: tuple[bool, bool]=(False, True),
+                change_last: tuple[bool, bool]=(False, True)) -> euklid.vector.PolyLine2D:
+            assert len(curve) > 0
+            new_curve = curve.nodes[:]
+
+            if change_first[0]:
+                new_curve[0][0] *= get_factor(factor) # change x[0] for 2%
+            if change_first[1]:
+                new_curve[0][1] *= get_factor(factor) # change x[0] for 2%
+
+            for p in new_curve[1:-1]:
+                p[0] *= get_factor(factor)
+                p[1] *= get_factor(factor)
+
+            if change_last[0]:
+                new_curve[-1][0] *= get_factor(factor) # change x[0] for 2%
+            if change_last[1]:
+                new_curve[-1][1] *= get_factor(factor) # change x[0] for 2%
+
+            return euklid.vector.PolyLine2D(new_curve)
+            
+
+        # change arc
+        new.arc.curve.controlpoints = randomize_nodes(new.arc.curve.controlpoints, 0.02)
+
+        # change shape
+        new.shape.front_curve.controlpoints = randomize_nodes(new.shape.front_curve.controlpoints, 0.02)
+        new.shape.back_curve.controlpoints = randomize_nodes(new.shape.back_curve.controlpoints, 0.02)
+
+        new.shape.rib_dist_controlpoints = randomize_nodes(new.shape.rib_dist_controlpoints, 0.02, (True, True), (True, True)).nodes
+
+        new.aoa.controlpoints = randomize_nodes(new.aoa.controlpoints, 0.1, (False, True), (False, True))
+
+        return new
 
     def get_arc_angles(self) -> list[float]:
         """

openglider/glider/parametric/shape.py

@@ -102,7 +102,7 @@ def rib_dist_controlpoints(self) -> euklid.vector.PolyLine2D:
         return euklid.vector.PolyLine2D(self.rib_distribution.controlpoints.nodes[1:-1])
 
     @rib_dist_controlpoints.setter
-    def rib_dist_controlpoints(self, arr: list[list[float]]) -> None:
+    def rib_dist_controlpoints(self, arr: list[list[float]] | list[euklid.vector.Vector2D]) -> None:
 
         self.rib_distribution.controlpoints = euklid.vector.PolyLine2D([[0., 0.]] + arr + [[1., 1.]])
 

openglider/glider/rib/rib.py

@@ -240,7 +240,7 @@ def get_mesh(self, hole_num: int=10, filled: bool=False, max_area: float=None) -
             points = self.align_all(euklid.vector.PolyLine2D(mesh.points))
             boundaries = {self.name: list(range(len(mesh.points)))}
 
-            rib_mesh = Mesh.from_indexed(points.nodes, polygons={self.name: [(tri, {}) for tri in mesh.elements]} , boundaries=boundaries)
+            rib_mesh = Mesh.from_indexed(points.nodes, polygons={f"ribs_{self.material}": [(tri, {}) for tri in mesh.elements]} , boundaries=boundaries)
 
             for hole in self.holes:
                 if hole_mesh := hole.get_mesh(self):

openglider/gui/__init__.py

@@ -4,7 +4,9 @@
 
 os.environ["FORCE_QT_API"] = "pyside6"
 os.environ["QT_API"] = "pyside6"
-os.environ["QT_QPA_PLATFORM"] = "xcb"
+
+if sys.platform.startswith("linux"):
+    os.environ["QT_QPA_PLATFORM"] = "xcb"
 
 
 def start_main_window() -> None: