molde 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

molde/__init__.py

@@ -3,3 +3,4 @@ from pathlib import Path
 from .colors import Color
 
 MOLDE_DIR = Path(__file__).parent
+UI_DIR = MOLDE_DIR / "ui_files/"

molde/__main__.py

@@ -5,6 +5,9 @@ from PyQt5 import uic
 from PyQt5.QtCore import Qt
 from time import time
 
+from vtkmodules.vtkFiltersSources import vtkCylinderSource
+from vtkmodules.vtkRenderingCore import vtkPolyDataMapper, vtkActor
+
 from molde import MOLDE_DIR
 from molde import stylesheets
 from molde.render_widgets.common_render_widget import CommonRenderWidget
@@ -23,6 +26,14 @@ class Example(QMainWindow):
         self.render_widget.create_color_bar()
         self.render_widget.set_info_text("Hola\nque\ntal?")
 
+        cylinder = vtkCylinderSource()
+        cylinder.SetResolution(8)
+        cylinder_mapper = vtkPolyDataMapper()
+        cylinder_mapper.SetInputConnection(cylinder.GetOutputPort())
+        cylinder_actor = vtkActor()
+        cylinder_actor.SetMapper(cylinder_mapper)
+        self.render_widget.add_actors(cylinder_actor)
+
         self.botao1 = QPushButton()
         self.label = QLabel("Olha o sapooo")
         self.botao1.setText("Olha a faca")

molde/actors/__init__.py

@@ -2,3 +2,4 @@ from .ghost_actor import GhostActor
 from .lines_actor import LinesActor
 from .round_points_actor import RoundPointsActor
 from .square_points_actor import SquarePointsActor
+from .common_symbols_actor import CommonSymbolsActorFixedSize, CommonSymbolsActorVariableSize

molde/actors/common_symbols_actor.py

@@ -0,0 +1,164 @@
+from dataclasses import dataclass
+
+from molde import Color
+from molde.utils import transform_polydata
+from vtkmodules.vtkCommonCore import (
+    vtkDoubleArray,
+    vtkIntArray,
+    vtkPoints,
+    vtkUnsignedCharArray,
+)
+from vtkmodules.vtkCommonDataModel import vtkPolyData
+from vtkmodules.vtkRenderingCore import vtkActor, vtkDistanceToCamera, vtkGlyph3DMapper, vtkRenderer
+
+Triple = tuple[float, float, float]
+
+
+@dataclass
+class Symbol:
+    shape_name: str
+    position: Triple
+    orientation: Triple
+    color: Color
+    scale: float
+
+
+class CommonSymbolsActor(vtkActor):
+    def __init__(self, *args, **kwargs):
+        self._shapes: dict[str, vtkPolyData] = dict()
+        self._symbols: list[Symbol] = list()
+
+    def register_shape(
+        self,
+        name: str,
+        shape: vtkPolyData,
+        position: Triple = (0, 0, 0),
+        rotation: Triple = (0, 0, 0),
+        scale: Triple = (1, 1, 1),
+    ):
+        self._shapes[name] = transform_polydata(
+            shape,
+            position,
+            rotation,
+            scale,
+        )
+
+    def add_symbol(
+        self,
+        shape_name: str,
+        position: Triple,
+        orientation: Triple,
+        color: Triple,
+        scale: float = 1,
+    ):
+        symbol = Symbol(
+            shape_name,
+            position,
+            orientation,
+            color,
+            scale,
+        )
+        self._symbols.append(symbol)
+
+    def clear_shapes(self):
+        self._shapes.clear()
+
+    def clear_symbols(self):
+        self._symbols.clear()
+
+    def clear_all(self):
+        self.clear_shapes()
+        self.clear_symbols()
+
+    def common_build(self):
+        self.data = vtkPolyData()
+        points = vtkPoints()
+
+        self.mapper: vtkGlyph3DMapper = vtkGlyph3DMapper()
+        self.SetMapper(self.mapper)
+
+        sources = vtkIntArray()
+        sources.SetName("sources")
+
+        rotations = vtkDoubleArray()
+        rotations.SetNumberOfComponents(3)
+        rotations.SetName("rotations")
+
+        scales = vtkDoubleArray()
+        scales.SetName("scales")
+
+        colors = vtkUnsignedCharArray()
+        colors.SetNumberOfComponents(3)
+        colors.SetName("colors")
+
+        shape_name_to_index = dict()
+        for index, (name, shape) in enumerate(self._shapes.items()):
+            shape_name_to_index[name] = index
+            self.mapper.SetSourceData(index, shape)
+
+        for symbol in self._symbols:
+            points.InsertNextPoint(symbol.position)
+            rotations.InsertNextTuple(symbol.orientation)
+            colors.InsertNextTuple(symbol.color.to_rgb())
+            scales.InsertNextValue(symbol.scale)
+            sources.InsertNextValue(shape_name_to_index[symbol.shape_name])
+
+        self.data.SetPoints(points)
+        self.data.GetPointData().AddArray(sources)
+        self.data.GetPointData().AddArray(rotations)
+        self.data.GetPointData().AddArray(scales)
+        self.data.GetPointData().SetScalars(colors)
+
+    def set_zbuffer_offsets(self, factor: float, units: float):
+        """
+        This functions is usefull to make a object appear in front of the others.
+        If the object should never be hidden, the parameters should be set to
+        factor = 1 and offset = -66000.
+        """
+        self.mapper.SetResolveCoincidentTopologyToPolygonOffset()
+        self.mapper.SetRelativeCoincidentTopologyLineOffsetParameters(factor, units)
+        self.mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(factor, units)
+        self.mapper.SetRelativeCoincidentTopologyPointOffsetParameter(units)
+        self.mapper.Update()
+
+
+class CommonSymbolsActorFixedSize(CommonSymbolsActor):
+    def build(self):
+        self.common_build()
+
+        self.mapper.SetInputData(self.data)
+        self.mapper.SetSourceIndexArray("sources")
+        self.mapper.SetOrientationArray("rotations")
+        self.mapper.SetScaleArray("scales")
+        self.mapper.SourceIndexingOn()
+        self.mapper.ScalarVisibilityOn()
+        self.mapper.SetScaleModeToScaleByMagnitude()
+        self.mapper.SetScalarModeToUsePointData()
+        self.mapper.SetOrientationModeToDirection()
+        self.mapper.Update()
+
+
+class CommonSymbolsActorVariableSize(CommonSymbolsActor):
+    def __init__(self, renderer: vtkRenderer):
+        super().__init__()
+        self.renderer = renderer
+
+    def build(self):
+        self.common_build()
+
+        distance_to_camera = vtkDistanceToCamera()
+        distance_to_camera.SetInputData(self.data)
+        distance_to_camera.SetScreenSize(40)
+        distance_to_camera.SetRenderer(self.renderer)
+
+        self.mapper.SetInputConnection(distance_to_camera.GetOutputPort())
+        self.mapper.SetSourceIndexArray("sources")
+        self.mapper.SetOrientationArray("rotations")
+        self.mapper.SetScaleArray("DistanceToCamera")
+        self.mapper.SourceIndexingOn()
+        self.mapper.ScalarVisibilityOn()
+        self.mapper.SetScaleModeToScaleByMagnitude()
+        self.mapper.SetScalarModeToUsePointData()
+        self.mapper.SetOrientationModeToDirection()
+
+        self.mapper.Update()

molde/interactor_styles/arcball_camera_style.py

@@ -22,6 +22,7 @@ class ArcballCameraInteractorStyle(vtkInteractorStyleTrackballCamera):
         self.is_rotating = False
         self.is_panning = False
 
+        self.mid_button_click_position = (0, 0)
         # cor = center of rotation
         self.cor_actor = self._make_default_cor_actor()
         self._create_observers()
@@ -41,9 +42,7 @@ class ArcballCameraInteractorStyle(vtkInteractorStyleTrackballCamera):
         self.AddObserver("MouseWheelForwardEvent", self._mouse_wheel_forward_event)
         self.AddObserver("MouseWheelBackwardEvent", self._mouse_wheel_backward_event)
         self.AddObserver("MiddleButtonPressEvent", self._click_mid_button_press_event)
-        self.AddObserver(
-            "MiddleButtonReleaseEvent", self._click_mid_button_release_event
-        )
+        self.AddObserver("MiddleButtonReleaseEvent", self._click_mid_button_release_event)
 
     def _left_button_press_event(self, obj, event):
         # Implemented to stop the superclass movement
@@ -84,9 +83,7 @@ class ArcballCameraInteractorStyle(vtkInteractorStyleTrackballCamera):
         distance_factor = np.sqrt(dx**2 + dy**2 + dz**2)
 
         self.cor_actor.SetPosition(self.center_of_rotation)
-        self.cor_actor.SetScale(
-            (distance_factor / 3.5, distance_factor / 3.5, distance_factor / 3.5)
-        )
+        self.cor_actor.SetScale((distance_factor / 3.5, distance_factor / 3.5, distance_factor / 3.5))
         renderer.AddActor(self.cor_actor)
 
     def _right_button_release_event(self, obj, event):
@@ -100,18 +97,36 @@ class ArcballCameraInteractorStyle(vtkInteractorStyleTrackballCamera):
     def _click_mid_button_press_event(self, obj, event):
         self.is_mid_clicked = True
         self.is_panning = True
-        int_pos = self.GetInteractor().GetEventPosition()
-        self.FindPokedRenderer(int_pos[0], int_pos[1])
+        cursor = self.GetInteractor().GetEventPosition()
+        self.mid_button_click_position = cursor
+        self.FindPokedRenderer(cursor[0], cursor[1])
 
     def _click_mid_button_release_event(self, obj, event):
         self.is_mid_clicked = False
         self.is_panning = False
 
     def _mouse_move_event(self, obj, event):
-        if self.is_rotating:
+        zoom = self.is_mid_clicked and self.GetInteractor().GetControlKey()
+
+        if zoom and not self.is_zooming:
+            self.is_zooming = True
+
+        if not zoom:
+            self.is_zooming = False
+
+        if self.is_zooming:
+            # Implementation based on this link
+            # https://github.com/Kitware/VTK/blob/4c4cd48244eaf1a74e0b096aae773c5498f7a782/Interaction/Style/vtkInteractorStyleTrackballCamera.cxx#L352
+            y0 = self.GetInteractor().GetLastEventPosition()[1]
+            y1 = self.GetInteractor().GetEventPosition()[1]
+            dyf = 10 * (y1 - y0) / self.GetCurrentRenderer().GetCenter()[1]
+            factor = 1.1 ** dyf
+            self.dolly_on_point(factor, *self.mid_button_click_position)
+
+        elif self.is_rotating:
             self.rotate()
 
-        if self.is_panning:
+        elif self.is_panning:
             self.Pan()
 
         self.OnMouseMove()
@@ -156,9 +171,7 @@ class ArcballCameraInteractorStyle(vtkInteractorStyleTrackballCamera):
             return
 
         rwi = self.GetInteractor()
-        delta_mouse = np.array(rwi.GetEventPosition()) - np.array(
-            rwi.GetLastEventPosition()
-        )
+        delta_mouse = np.array(rwi.GetEventPosition()) - np.array(rwi.GetLastEventPosition())
         size = np.array(renderer.GetRenderWindow().GetSize())
         motion_factor = 10
         elevation_azimuth = -20 / size
@@ -214,29 +227,17 @@ class ArcballCameraInteractorStyle(vtkInteractorStyleTrackballCamera):
         camera.Modified()
 
     def dolly(self, factor):
-        renderer = self.GetDefaultRenderer() or self.GetCurrentRenderer()
-        camera = renderer.GetActiveCamera()
         cursor = self.GetInteractor().GetEventPosition()
+        self.dolly_on_point(factor, *cursor)
 
-        if factor <= 0:
-            return
-
-        cam_up = np.array(camera.GetViewUp())
-        cam_in = np.array(camera.GetDirectionOfProjection())
-        cam_side = np.cross(cam_in, cam_up)
-
-        displacements = self.get_dolly_displacements(
-            factor,
-            cursor,
-            camera,
-            renderer,
-        )
+    def dolly_on_point(self, factor, x, y):
+        renderer = self.GetDefaultRenderer() or self.GetCurrentRenderer()
+        camera = renderer.GetActiveCamera()
 
-        camera_position = np.array(camera.GetPosition())
-        focal_point = np.array(camera.GetFocalPoint())
-        rotated_displacements = cam_side * displacements[0] + cam_up * displacements[1]
-        camera.SetPosition(camera_position + rotated_displacements)
-        camera.SetFocalPoint(focal_point + rotated_displacements)
+        view_center = np.array(renderer.GetSize()) / 2
+        distance_to_center = (x, y) - view_center
+        dx, dy = distance_to_center * (1 - 1 / factor)
+        self.move_viewport(dx, dy)
 
         if camera.GetParallelProjection():
             camera.SetParallelScale(camera.GetParallelScale() / factor)
@@ -250,19 +251,34 @@ class ArcballCameraInteractorStyle(vtkInteractorStyleTrackballCamera):
 
         self.GetInteractor().Render()
 
-    def get_dolly_displacements(self, factor, cursor, camera, renderer):
-        cursor = np.array(cursor)
-        view_center = np.array(renderer.GetSize()) / 2
-        cursor_to_center = cursor - view_center
+    def move_viewport(self, dx, dy):
+        """
+        Moves the viewport in view coordinates by some amount of pixels.
+
+        Further explanations on this link:
+        https://github.com/open-pulse/OpenPulse/blob/5f7bd4719527383b2d3ea078e5f29f214f35128d/doc/code_explanation/move_viewport.pdf
+        """
+
+        renderer = self.GetDefaultRenderer() or self.GetCurrentRenderer()
+        camera = renderer.GetActiveCamera()
+        width, heigth = renderer.GetSize()
 
         if camera.GetParallelProjection():
             view_height = 2 * camera.GetParallelScale()
         else:
             correction = camera.GetDistance()
             view_height = 2 * correction * np.tan(0.5 * camera.GetViewAngle() / 57.296)
+        scale = view_height / heigth
+
+        focal_point = np.array(camera.GetFocalPoint())
+        camera_position = np.array(camera.GetPosition())
+        camera_up = np.array(camera.GetViewUp())
+        camera_in = np.array(camera.GetDirectionOfProjection())
+        camera_right = np.cross(camera_in, camera_up)
 
-        scale = view_height / renderer.GetSize()[1]
-        return cursor_to_center * scale * (1 - 1 / factor)
+        camera_displacement = scale * (camera_right * dx + camera_up * dy)
+        camera.SetPosition(camera_position + camera_displacement)
+        camera.SetFocalPoint(focal_point + camera_displacement)
 
     def _make_default_cor_actor(self):
         actor = RoundPointsActor([(0, 0, 0)])