molde 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

molde/pickers/__init__.py

@@ -1,2 +1,2 @@
-from .cell_area_picker import CellAreaPicker
-from .cell_property_area_picker import CellPropertyAreaPicker
+from .cell_area_picker import CellAreaPicker
+from .cell_property_area_picker import CellPropertyAreaPicker

molde/pickers/cell_area_picker.py

@@ -1,61 +1,61 @@
-from vtkmodules.vtkCommonDataModel import vtkPolyData
-from vtkmodules.vtkFiltersGeneral import vtkExtractSelectedFrustum
-from vtkmodules.vtkRenderingCore import (
-    vtkActor,
-    vtkAreaPicker,
-    vtkCellPicker,
-    vtkPropPicker,
-    vtkRenderer,
-)
-
-
-class CellAreaPicker(vtkPropPicker):
-    def __init__(self) -> None:
-        super().__init__()
-        self._picked_cells = []
-        self._picked_actors = []
-        self._picked = dict()
-
-        self._area_picker = vtkAreaPicker()
-        self._cell_picker = vtkCellPicker()
-        self._cell_picker.SetTolerance(0.01)
-
-    def pick(self, x: float, y: float, z: float, renderer: vtkRenderer):
-        self._picked.clear()
-        self._cell_picker.Pick(x, y, z, renderer)
-        self._picked[self._cell_picker.GetActor()] = [self._cell_picker.GetCellId()]
-
-        # # select a small area around the mouse click
-        # delta = 10
-        # self.area_pick(x-delta, y-delta, x+delta, y+delta, renderer)
-
-        # # keep at most a single cell selected for every picked actor
-        # for actor, selection in self._picked.items():
-        #     self._picked[actor] = selection[:1]
-
-    def area_pick(
-        self, x0: float, y0: float, x1: float, y1: float, renderer: vtkRenderer
-    ):
-        self._picked.clear()
-        self._area_picker.AreaPick(x0, y0, x1, y1, renderer)
-        extractor = vtkExtractSelectedFrustum()
-        extractor.SetFrustum(self._area_picker.GetFrustum())
-
-        for actor in self._area_picker.GetProp3Ds():
-            if not isinstance(actor, vtkActor):
-                continue
-
-            data: vtkPolyData = actor.GetMapper().GetInput()
-            if data is None:
-                continue
-
-            cells = []
-            for i in range(data.GetNumberOfCells()):
-                bounds = [0, 0, 0, 0, 0, 0]
-                data.GetCellBounds(i, bounds)
-                if extractor.OverallBoundsTest(bounds):
-                    cells.append(i)
-            self._picked[actor] = cells
-
-    def get_picked(self):
-        return dict(self._picked)
+from vtkmodules.vtkCommonDataModel import vtkPolyData
+from vtkmodules.vtkFiltersGeneral import vtkExtractSelectedFrustum
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkAreaPicker,
+    vtkCellPicker,
+    vtkPropPicker,
+    vtkRenderer,
+)
+
+
+class CellAreaPicker(vtkPropPicker):
+    def __init__(self) -> None:
+        super().__init__()
+        self._picked_cells = []
+        self._picked_actors = []
+        self._picked = dict()
+
+        self._area_picker = vtkAreaPicker()
+        self._cell_picker = vtkCellPicker()
+        self._cell_picker.SetTolerance(0.01)
+
+    def pick(self, x: float, y: float, z: float, renderer: vtkRenderer):
+        self._picked.clear()
+        self._cell_picker.Pick(x, y, z, renderer)
+        self._picked[self._cell_picker.GetActor()] = [self._cell_picker.GetCellId()]
+
+        # # select a small area around the mouse click
+        # delta = 10
+        # self.area_pick(x-delta, y-delta, x+delta, y+delta, renderer)
+
+        # # keep at most a single cell selected for every picked actor
+        # for actor, selection in self._picked.items():
+        #     self._picked[actor] = selection[:1]
+
+    def area_pick(
+        self, x0: float, y0: float, x1: float, y1: float, renderer: vtkRenderer
+    ):
+        self._picked.clear()
+        self._area_picker.AreaPick(x0, y0, x1, y1, renderer)
+        extractor = vtkExtractSelectedFrustum()
+        extractor.SetFrustum(self._area_picker.GetFrustum())
+
+        for actor in self._area_picker.GetProp3Ds():
+            if not isinstance(actor, vtkActor):
+                continue
+
+            data: vtkPolyData = actor.GetMapper().GetInput()
+            if data is None:
+                continue
+
+            cells = []
+            for i in range(data.GetNumberOfCells()):
+                bounds = [0, 0, 0, 0, 0, 0]
+                data.GetCellBounds(i, bounds)
+                if extractor.OverallBoundsTest(bounds):
+                    cells.append(i)
+            self._picked[actor] = cells
+
+    def get_picked(self):
+        return dict(self._picked)

molde/pickers/cell_property_area_picker.py

@@ -1,84 +1,84 @@
-from vtkmodules.vtkCommonDataModel import vtkPolyData
-from vtkmodules.vtkFiltersGeneral import vtkExtractSelectedFrustum
-from vtkmodules.vtkRenderingCore import (
-    vtkActor,
-    vtkAreaPicker,
-    vtkCellPicker,
-    vtkPropPicker,
-    vtkRenderer,
-)
-
-
-class CellPropertyAreaPicker(vtkPropPicker):
-    def __init__(self, property_name: str, desired_actor: vtkActor) -> None:
-        super().__init__()
-
-        self.property_name = property_name
-        self.desired_actor = desired_actor
-        self._picked = set()
-
-        self._cell_picker = vtkCellPicker()
-        self._area_picker = vtkAreaPicker()
-        self._cell_picker.SetTolerance(0.005)
-
-    def pick(self, x: float, y: float, z: float, renderer: vtkRenderer):
-        # maybe a behaviour like the one implemented in CellAreaPicker
-        # would fit nicely here
-        self._picked.clear()
-        self._cell_picker.Pick(x, y, z, renderer)
-
-        if self.desired_actor != self._cell_picker.GetActor():
-            return self.get_picked()
-
-        data: vtkPolyData = self.desired_actor.GetMapper().GetInput()
-        if data is None:
-            return self.get_picked()
-
-        property_array = data.GetCellData().GetArray(self.property_name)
-        if property_array is None:
-            return self.get_picked()
-
-        cell = self._cell_picker.GetCellId()
-        property_val = property_array.GetValue(cell)
-        self._picked.add(property_val)
-        return self.get_picked()
-
-    def area_pick(
-        self, x0: float, y0: float, x1: float, y1: float, renderer: vtkRenderer
-    ):
-        self._picked.clear()
-        self._area_picker.AreaPick(x0, y0, x1, y1, renderer)
-        extractor = vtkExtractSelectedFrustum()
-        extractor.SetFrustum(self._area_picker.GetFrustum())
-
-        if self.desired_actor not in self._area_picker.GetProp3Ds():
-            return self.get_picked()
-
-        data: vtkPolyData = self.desired_actor.GetMapper().GetInput()
-        if data is None:
-            return self.get_picked()
-
-        property_array = data.GetCellData().GetArray(self.property_name)
-        if property_array is None:
-            return self.get_picked()
-
-        if property_array.GetNumberOfValues() < data.GetNumberOfCells():
-            return self.get_picked()
-
-        for cell in range(data.GetNumberOfCells()):
-            property_val = property_array.GetValue(cell)
-
-            # if the property was already picked
-            # we don't even need to check if the cell
-            # is inside the selection box
-            if property_val in self._picked:
-                continue
-
-            bounds = [0, 0, 0, 0, 0, 0]
-            data.GetCellBounds(cell, bounds)
-            if extractor.OverallBoundsTest(bounds):
-                self._picked.add(property_val)
-        return self.get_picked()
-
-    def get_picked(self):
-        return set(self._picked)
+from vtkmodules.vtkCommonDataModel import vtkPolyData
+from vtkmodules.vtkFiltersGeneral import vtkExtractSelectedFrustum
+from vtkmodules.vtkRenderingCore import (
+    vtkActor,
+    vtkAreaPicker,
+    vtkCellPicker,
+    vtkPropPicker,
+    vtkRenderer,
+)
+
+
+class CellPropertyAreaPicker(vtkPropPicker):
+    def __init__(self, property_name: str, desired_actor: vtkActor) -> None:
+        super().__init__()
+
+        self.property_name = property_name
+        self.desired_actor = desired_actor
+        self._picked = set()
+
+        self._cell_picker = vtkCellPicker()
+        self._area_picker = vtkAreaPicker()
+        self._cell_picker.SetTolerance(0.005)
+
+    def pick(self, x: float, y: float, z: float, renderer: vtkRenderer):
+        # maybe a behaviour like the one implemented in CellAreaPicker
+        # would fit nicely here
+        self._picked.clear()
+        self._cell_picker.Pick(x, y, z, renderer)
+
+        if self.desired_actor != self._cell_picker.GetActor():
+            return self.get_picked()
+
+        data: vtkPolyData = self.desired_actor.GetMapper().GetInput()
+        if data is None:
+            return self.get_picked()
+
+        property_array = data.GetCellData().GetArray(self.property_name)
+        if property_array is None:
+            return self.get_picked()
+
+        cell = self._cell_picker.GetCellId()
+        property_val = property_array.GetValue(cell)
+        self._picked.add(property_val)
+        return self.get_picked()
+
+    def area_pick(
+        self, x0: float, y0: float, x1: float, y1: float, renderer: vtkRenderer
+    ):
+        self._picked.clear()
+        self._area_picker.AreaPick(x0, y0, x1, y1, renderer)
+        extractor = vtkExtractSelectedFrustum()
+        extractor.SetFrustum(self._area_picker.GetFrustum())
+
+        if self.desired_actor not in self._area_picker.GetProp3Ds():
+            return self.get_picked()
+
+        data: vtkPolyData = self.desired_actor.GetMapper().GetInput()
+        if data is None:
+            return self.get_picked()
+
+        property_array = data.GetCellData().GetArray(self.property_name)
+        if property_array is None:
+            return self.get_picked()
+
+        if property_array.GetNumberOfValues() < data.GetNumberOfCells():
+            return self.get_picked()
+
+        for cell in range(data.GetNumberOfCells()):
+            property_val = property_array.GetValue(cell)
+
+            # if the property was already picked
+            # we don't even need to check if the cell
+            # is inside the selection box
+            if property_val in self._picked:
+                continue
+
+            bounds = [0, 0, 0, 0, 0, 0]
+            data.GetCellBounds(cell, bounds)
+            if extractor.OverallBoundsTest(bounds):
+                self._picked.add(property_val)
+        return self.get_picked()
+
+    def get_picked(self):
+        return set(self._picked)

molde/poly_data/__init__.py

@@ -1,2 +1,19 @@
-from .lines_data import LinesData
-from .vertices_data import VerticesData
+from .lines_data import LinesData
+from .vertices_data import VerticesData
+from .arrows import (
+    create_arrow_source,
+    create_long_arrow_source,
+    create_double_arrow_source,
+    create_outwards_arrow_source,
+)
+
+from .simple_shapes import (
+    create_cone_source,
+    create_cube_source,
+)
+
+from .complex_shapes import (
+    create_spring_source,
+    create_damper_source,
+    create_mass_source,
+)

molde/poly_data/arrows.py

@@ -0,0 +1,54 @@
+from vtkmodules.vtkFiltersSources import vtkArrowSource
+from vtkmodules.vtkFiltersCore import vtkAppendPolyData
+from vibra.utils.polydata_utils import transform_polydata
+
+
+def create_arrow_source():
+    source = vtkArrowSource()
+    source.SetTipLength(0.25)
+    source.Update()
+
+    return transform_polydata(
+        source.GetOutput(),
+        position=(-1, 0, 0),
+    )
+
+
+def create_long_arrow_source():
+    source = vtkArrowSource()
+    source.SetTipResolution(4)
+    source.SetShaftResolution(4)
+    source.SetTipLength(0.85)
+    source.Update()
+
+    return transform_polydata(
+        source.GetOutput(),
+        position=(-1, 0, 0),
+    )
+
+
+def create_double_arrow_source():
+    arrow1 = vtkArrowSource()
+    arrow1.SetTipLength(0.45)
+    arrow1.Update()
+
+    arrow2 = vtkArrowSource()
+    arrow2.SetTipLength(0.3)
+    arrow2.Update()
+
+    source = vtkAppendPolyData()
+    source.AddInputData(arrow1.GetOutput())
+    source.AddInputData(arrow2.GetOutput())
+    source.Update()
+
+    return transform_polydata(
+        source.GetOutput(),
+        position=(-1, 0, 0),
+    )
+
+
+def create_outwards_arrow_source():
+    source = vtkArrowSource()
+    source.SetTipLength(0.25)
+    source.Update()
+    return source.GetOutput()

molde/poly_data/complex_shapes.py

@@ -0,0 +1,26 @@
+from vibra import SYMBOLS_DIR
+from vibra.utils.polydata_utils import read_obj_file, read_stl_file, transform_polydata
+
+
+def create_spring_source():
+    polydata = read_stl_file(SYMBOLS_DIR / "stl_files/spring_symbol.STL")
+    return transform_polydata(
+        polydata,
+        position=(-1.25, -0.18, 0.18),
+        rotation=(0, 90, 0),
+    )
+
+
+def create_damper_source():
+    polydata = read_obj_file(SYMBOLS_DIR / "structural/lumped_damper.obj")
+    return transform_polydata(
+        polydata,
+        position=(-0.145, 0, 0),
+    )
+
+
+def create_mass_source():
+    return transform_polydata(
+        read_obj_file(SYMBOLS_DIR / "structural/new_lumped_mass.obj"),
+        rotation=(0, -90, 0),
+    )

molde/poly_data/lines_data.py

@@ -1,23 +1,23 @@
-from vtkmodules.vtkCommonCore import vtkPoints
-from vtkmodules.vtkCommonDataModel import VTK_LINE, vtkPolyData
-
-
-class LinesData(vtkPolyData):
-    def __init__(self, lines_list) -> None:
-        super().__init__()
-
-        self.lines_list = lines_list
-        self.build()
-
-    def build(self):
-        points = vtkPoints()
-        self.Allocate(len(self.lines_list))
-
-        current_point = 0
-        for x0, y0, z0, x1, y1, z1 in self.lines_list:
-            points.InsertPoint(current_point, x0, y0, z0)
-            points.InsertPoint(current_point + 1, x1, y1, z1)
-            self.InsertNextCell(VTK_LINE, 2, [current_point, current_point + 1])
-            current_point += 2
-
-        self.SetPoints(points)
+from vtkmodules.vtkCommonCore import vtkPoints
+from vtkmodules.vtkCommonDataModel import VTK_LINE, vtkPolyData
+
+
+class LinesData(vtkPolyData):
+    def __init__(self, lines_list) -> None:
+        super().__init__()
+
+        self.lines_list = lines_list
+        self.build()
+
+    def build(self):
+        points = vtkPoints()
+        self.Allocate(len(self.lines_list))
+
+        current_point = 0
+        for x0, y0, z0, x1, y1, z1 in self.lines_list:
+            points.InsertPoint(current_point, x0, y0, z0)
+            points.InsertPoint(current_point + 1, x1, y1, z1)
+            self.InsertNextCell(VTK_LINE, 2, [current_point, current_point + 1])
+            current_point += 2
+
+        self.SetPoints(points)

molde/poly_data/simple_shapes.py

@@ -0,0 +1,22 @@
+from vibra.utils.polydata_utils import transform_polydata
+from vtkmodules.vtkFiltersSources import (
+    vtkConeSource,
+    vtkCubeSource,
+)
+
+def create_cone_source():
+    source = vtkConeSource()
+    source.SetHeight(1)
+    source.SetRadius(0.5)
+    source.SetResolution(12)
+    source.Update()
+    return transform_polydata(
+        source.GetOutput(),
+        position=(-0.5, 0, 0),
+    )
+
+def create_cube_source():
+    source = vtkCubeSource()
+    source.SetBounds(0, 1, 0, 1, 0, 1)
+    source.Update()
+    return source.GetOutput()

molde/poly_data/vertices_data.py

@@ -1,24 +1,24 @@
-from vtkmodules.vtkCommonCore import vtkPoints
-from vtkmodules.vtkCommonDataModel import VTK_VERTEX, vtkPolyData
-
-
-class VerticesData(vtkPolyData):
-    """
-    This class describes a polydata composed by a set of points.
-    """
-
-    def __init__(self, points_list: list[tuple[int, int, int]]) -> None:
-        super().__init__()
-
-        self.points_list = points_list
-        self.build()
-
-    def build(self):
-        points = vtkPoints()
-        self.Allocate(len(self.points_list))
-
-        for i, (x, y, z) in enumerate(self.points_list):
-            points.InsertNextPoint(x, y, z)
-            self.InsertNextCell(VTK_VERTEX, 1, [i])
-
-        self.SetPoints(points)
+from vtkmodules.vtkCommonCore import vtkPoints
+from vtkmodules.vtkCommonDataModel import VTK_VERTEX, vtkPolyData
+
+
+class VerticesData(vtkPolyData):
+    """
+    This class describes a polydata composed by a set of points.
+    """
+
+    def __init__(self, points_list: list[tuple[int, int, int]]) -> None:
+        super().__init__()
+
+        self.points_list = points_list
+        self.build()
+
+    def build(self):
+        points = vtkPoints()
+        self.Allocate(len(self.points_list))
+
+        for i, (x, y, z) in enumerate(self.points_list):
+            points.InsertNextPoint(x, y, z)
+            self.InsertNextCell(VTK_VERTEX, 1, [i])
+
+        self.SetPoints(points)

molde/render_widgets/__init__.py

@@ -1,2 +1,2 @@
-from .animated_render_widget import AnimatedRenderWidget
-from .common_render_widget import CommonRenderWidget
+from .animated_render_widget import AnimatedRenderWidget
+from .common_render_widget import CommonRenderWidget