Uv map

openglider/glider/uv_map.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import logging
+import math
+from typing import TYPE_CHECKING, TypeAlias
+import openglider.glider
+import openglider.glider.parametric
+import openglider
+import euklid
+from openglider.vector.drawing import Layout, PlotPart
+from openglider.vector.unit import Percentage
+from openglider.glider.rib.rib import Rib
+from openglider.glider.cell.cell import Cell
+from openglider import glider
+
+if TYPE_CHECKING:
+    from openglider.glider.cell.panel import Panel
+
+
+logger = logging.getLogger(__name__)
+
+
+
+class UVMap:
+    def __init__(self, glider: glider.ParametricGlider) -> None:
+        self.glider = glider
+        self.glider3d = self.glider.get_glider_3d()
+        self.cell_x_values = self.glider.shape.rib_x_values 
+
+
+    def _get_length(self, x: Percentage, rib: Rib):
+        ik_front = rib.profile_2d.get_ik(0)
+        ik = rib.profile_2d.get_ik(x)
+
+        length = rib.profile_2d.curve.get(ik_front, ik).get_length()
+
+        if x.si < 0:
+            length *= -1
+
+        return length * rib.chord
+
+    def _get_panel(self, cell_no: int, cell: Cell, panel: Panel) -> euklid.vector.PolyLine2D:
+        p1 = (self.cell_x_values[cell_no],self._get_length(panel.cut_back.x_left, cell.rib1))
+        p2 = (self.cell_x_values[cell_no+1],self._get_length(panel.cut_back.x_right, cell.rib2))
+        p3 = (self.cell_x_values[cell_no+1],self._get_length(panel.cut_front.x_right, cell.rib2)) 
+        p4 = (self.cell_x_values[cell_no],self._get_length(panel.cut_front.x_left, cell.rib1))
+
+        return euklid.vector.PolyLine2D([p1, p2, p3, p4])
+
+    def get_panels(self) -> dict[Panel, euklid.vector.PolyLine2D] | dict[Panel, euklid.vector.PolyLine2D]:
+        panel_nodes: dict[Panel, euklid.vector.PolyLine2D] = {}
+        panel_nodes_mirror: dict[Panel, euklid.vector.PolyLine2D] = {}
+
+        for cell_no, cell in enumerate(self.glider3d.cells):
+            for panel in cell.panels:
+                nodes = self._get_panel(cell_no, cell, panel)
+                panel_nodes[panel] = nodes
+                if cell_no > 0 or not self.glider3d.has_center_cell:
+                    panel_nodes_mirror[panel] = nodes.mirror()
+
+        return panel_nodes, panel_nodes_mirror  
+
+    def get_layout(self) -> Layout:
+        points: list[euklid.vector.PolyLine2D] = []
+        panel_nodes, panel_nodes_mirror = self.get_panels()
+
+        for panel, panel_points in panel_nodes.items():
+            points.append(panel_points.close())
+
+        for panel, panel_points in panel_nodes_mirror.items():
+            points.append(panel_points.close())
+
+        layout = Layout()
+        layout.parts.append(PlotPart(marks=points))
+        layout = layout.scale(100)
+
+        return layout
+
+

openglider/gui/app/actions.py

@@ -4,13 +4,15 @@
 from openglider.gui.wizzards.base import Wizard
 from openglider.gui.wizzards.input import input_wizzards
 from openglider.gui.wizzards.line_forces import LineForceView
+from openglider.gui.wizzards.uv_map import UVMapView
 
 logger = logging.getLogger(__name__)
 __all__ = ["menu_actions"]
 
 menu_actions: dict[str, list[tuple[type[Wizard], str]]] = {
     "view": [
-        (LineForceView, "Leinen")
+        (LineForceView, "Leinen"),
+        (UVMapView, "UV-Map")
     ],
     "edit": input_wizzards
 }

openglider/gui/views/compare/__init__.py

@@ -13,6 +13,7 @@
 from openglider.gui.views.compare.rib_plots import RibPlotView
 from openglider.gui.views.compare.shape import ShapeView
 from openglider.gui.views.compare.table.lines_diff import GliderLineSetTable
+from openglider.gui.views.compare.table.straps_diff import GliderStrapTable
 
 logger = logging.getLogger(__name__)
 
@@ -36,6 +37,7 @@ def __init__(self, app: GliderApp) -> None:
             "Cells": CellView(app),
             "Table": GliderTable(app),
             "Lines": GliderLineSetTable(app),
+            "Straps": GliderStrapTable(app),
             "3D": Glider3DView(app)
         }
         self.tab_names = list(self.tabs.keys())

openglider/gui/views/compare/table/straps_diff.py

@@ -0,0 +1,82 @@
+import logging
+from openglider.glider.project import GliderProject
+from openglider.gui.qt import QtCore, QtWidgets
+from openglider.gui.qt import QClipboard
+
+from openglider.gui.app.app import GliderApp
+from openglider.utils.table import Table
+from openglider.gui.widgets.table import QTable
+from openglider.gui.state.glider_list import GliderCache
+from openglider.gui.views.compare.base import CompareView
+
+
+
+logger = logging.getLogger(__name__)
+
+
+class StrapsTableCache(GliderCache[Table]):
+    update_on_reference_change = True
+
+    def get_object(self, name: str) -> Table:
+
+        table = Table(name="straps")
+        table[0,0] = name
+        project = self.elements.get_selected()
+        row = 1
+        column = 0
+
+        for cell in project.get_glider_3d().cells:
+            for strap in sorted(cell.straps, key=lambda strap: abs(strap.get_average_x())):
+                table[row, column] = strap.name
+                table[row, column+1] = f"{strap.get_center_length(cell)*1000:.0f}"
+                column +=2
+            row += 1
+            column = 0
+
+
+        return table
+
+
+
+class GliderStrapTable(QtWidgets.QWidget, CompareView):
+    row_indices: list[str] = [
+
+    ]
+    def __init__(self, app: GliderApp, parent: QtWidgets.QWidget=None):
+
+        super().__init__(parent)
+
+        layout = QtWidgets.QVBoxLayout()
+        self.setLayout(layout)
+        self.table_widget = QTable()
+        layout.addWidget(self.table_widget)
+        button_copy = QtWidgets.QPushButton("Copy Table")
+        layout.addWidget(button_copy)
+        button_copy.clicked.connect(self.copy_to_clipboard)
+
+
+        self.cache = StrapsTableCache(app.state.projects)
+        self.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding)
+
+    def update_view(self) -> None:
+        self.table = Table()
+
+        for i, active_project_table in enumerate(self.cache.get_update().active):
+            self.table.append_right(active_project_table)
+
+        self.table_widget.clear()
+        self.table_widget.push_table(self.table)
+        self.table_widget.resizeColumnsToContents()
+
+
+    def copy_to_clipboard(self) -> None:
+        #add contents of table to clipboard.
+        copied = ''
+        for row in range(0, self.table.num_rows):
+            for col in range(0, self.table.num_columns):
+                copied += self.table_widget.item(row, col).text() + '\t'
+            copied = copied[:-1] + '\n'
+
+        clipboard = QClipboard()
+        clipboard.setText(copied)
+

openglider/gui/wizzards/uv_map.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from openglider.glider.project import GliderProject
+
+from openglider.gui.qt import QtWidgets
+from openglider.gui.wizzards.base import Wizard
+from openglider.gui.widgets import QTable
+
+import pyqtgraph
+
+from openglider.gui.app.app import GliderApp
+from openglider.gui.state.glider_list import GliderCache
+from openglider.gui.views_2d.canvas import Canvas, LayoutGraphics
+from openglider.gui.widgets.select import EnumSelection
+from openglider.plots.sketches.shapeplot import ShapePlot, ShapePlotConfig
+from openglider.gui.qt import QtCore, QtWidgets
+
+if TYPE_CHECKING:
+    from openglider.gui.app.main_window import MainWindow
+
+
+class ShapePlotCache(GliderCache[tuple[ShapePlot, ShapePlot, str]]):
+    def get_object(self, element: str) -> tuple[ShapePlot, ShapePlot, str]:
+        project = self.elements[element]
+        return ShapePlot(project.element), ShapePlot(project.element), element
+
+class UVMapView(Wizard):
+    grid = False
+    def __init__(self, app: MainWindow, project: GliderProject):
+        super().__init__(app, project)
+        self.config = ShapePlotConfig()
+
+        self.setLayout(QtWidgets.QVBoxLayout())
+        self.app = app
+        self.cache = ShapePlotCache(app.state.projects)
+        update = self.cache.get_update()
+
+
+        self.plots = Canvas()
+        self.plots = pyqtgraph.GraphicsLayoutWidget()
+        self.plots.setBackground('w')
+        self.plot_upper = Canvas()
+        dwg1 = ShapePlot(self.project)
+
+        self.plot_upper.addItem(LayoutGraphics(dwg1))
+
+        self.layout().addWidget(self.plots)
+
+
+