molde 0.1.0__py3-none-any.whl

molde/interactor_styles/arcball_camera_style.py

@@ -0,0 +1,272 @@
+import numpy as np
+from vtkmodules.vtkCommonTransforms import vtkTransform
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
+from vtkmodules.vtkRenderingCore import vtkPropPicker
+
+from molde.actors import RoundPointsActor
+
+
+class ArcballCameraInteractorStyle(vtkInteractorStyleTrackballCamera):
+    """
+    Interactor style that rotates and zooms around the cursor.
+    """
+
+    def __init__(self):
+        self.center_of_rotation = None
+        self.default_center_of_rotation = None
+
+        self.is_left_clicked = False
+        self.is_right_clicked = False
+        self.is_mid_clicked = False
+
+        self.is_rotating = False
+        self.is_panning = False
+
+        # cor = center of rotation
+        self.cor_actor = self._make_default_cor_actor()
+        self._create_observers()
+
+    def set_default_center_of_rotation(self, center):
+        self.default_center_of_rotation = center
+
+    def set_cor_actor(self, actor):
+        self.cor_actor = actor
+
+    def _create_observers(self):
+        self.AddObserver("LeftButtonPressEvent", self._left_button_press_event)
+        self.AddObserver("LeftButtonReleaseEvent", self._left_button_release_event)
+        self.AddObserver("RightButtonPressEvent", self._right_button_press_event)
+        self.AddObserver("RightButtonReleaseEvent", self._right_button_release_event)
+        self.AddObserver("MouseMoveEvent", self._mouse_move_event)
+        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
+        )
+
+    def _left_button_press_event(self, obj, event):
+        # Implemented to stop the superclass movement
+        self.is_left_clicked = True
+
+    def _left_button_release_event(self, obj, event):
+        # Implemented to stop the superclass movement
+        self.is_left_clicked = False
+
+    def _right_button_press_event(self, obj, event):
+        self.is_right_clicked = True
+        self.is_rotating = True
+
+        cursor = self.GetInteractor().GetEventPosition()
+        self.FindPokedRenderer(cursor[0], cursor[1])
+
+        renderer = self.GetCurrentRenderer() or self.GetDefaultRenderer()
+        camera = renderer.GetActiveCamera()
+
+        if renderer is None:
+            return
+
+        picker = vtkPropPicker()
+        picker.Pick(cursor[0], cursor[1], 0, renderer)
+        pos = picker.GetPickPosition()
+
+        if pos != (0, 0, 0):
+            self.center_of_rotation = pos
+
+        elif self.default_center_of_rotation is not None:
+            self.center_of_rotation = self.default_center_of_rotation
+
+        else:
+            x0, x1, y0, y1, z0, z1 = renderer.ComputeVisiblePropBounds()
+            self.center_of_rotation = [(x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2]
+
+        dx, dy, dz = np.array(camera.GetPosition()) - np.array(camera.GetFocalPoint())
+        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)
+        )
+        renderer.AddActor(self.cor_actor)
+
+    def _right_button_release_event(self, obj, event):
+        self.is_right_clicked = False
+        self.is_rotating = False
+        renderer = self.GetDefaultRenderer() or self.GetCurrentRenderer()
+        renderer.RemoveActor(self.cor_actor)
+        self.GetInteractor().Render()
+        self.EndDolly()
+
+    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])
+
+    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:
+            self.rotate()
+
+        if self.is_panning:
+            self.Pan()
+
+        self.OnMouseMove()
+
+    def _mouse_wheel_forward_event(self, obj, event):
+        int_pos = self.GetInteractor().GetEventPosition()
+
+        self.FindPokedRenderer(int_pos[0], int_pos[1])
+
+        if self.GetCurrentRenderer() is None:
+            return
+
+        motion_factor = 10
+        mouse_motion_factor = 1
+
+        factor = motion_factor * 0.2 * mouse_motion_factor
+
+        self.dolly(1.1**factor)
+
+        self.ReleaseFocus()
+
+    def _mouse_wheel_backward_event(self, obj, event):
+        int_pos = self.GetInteractor().GetEventPosition()
+
+        self.FindPokedRenderer(int_pos[0], int_pos[1])
+
+        if self.GetCurrentRenderer() is None:
+            return
+
+        motion_factor = 10
+        mouse_motion_factor = 1
+
+        factor = motion_factor * -0.2 * mouse_motion_factor
+
+        self.dolly(1.1**factor)
+
+        self.ReleaseFocus()
+
+    def rotate(self):
+        renderer = self.GetDefaultRenderer() or self.GetCurrentRenderer()
+        if renderer is None:
+            return
+
+        rwi = self.GetInteractor()
+        delta_mouse = np.array(rwi.GetEventPosition()) - np.array(
+            rwi.GetLastEventPosition()
+        )
+        size = np.array(renderer.GetRenderWindow().GetSize())
+        motion_factor = 10
+        elevation_azimuth = -20 / size
+        rotation_factor = delta_mouse * motion_factor * elevation_azimuth
+
+        camera = renderer.GetActiveCamera()
+
+        self.rotate_around_center(rotation_factor[0], rotation_factor[1])
+
+        camera.OrthogonalizeViewUp()
+
+        renderer.ResetCameraClippingRange()
+
+        if rwi.GetLightFollowCamera():
+            renderer.UpdateLightsGeometryToFollowCamera()
+
+        rwi.Render()
+
+    def rotate_around_center(self, anglex, angley):
+        renderer = self.GetDefaultRenderer() or self.GetCurrentRenderer()
+        camera = renderer.GetActiveCamera()
+
+        transform_camera = vtkTransform()
+        transform_camera.Identity()
+
+        axis = [
+            -camera.GetViewTransformObject().GetMatrix().GetElement(0, 0),
+            -camera.GetViewTransformObject().GetMatrix().GetElement(0, 1),
+            -camera.GetViewTransformObject().GetMatrix().GetElement(0, 2),
+        ]
+
+        saved_view_up = camera.GetViewUp()
+        transform_camera.RotateWXYZ(angley, axis)
+        new_view_up = transform_camera.TransformPoint(camera.GetViewUp())
+        camera.SetViewUp(new_view_up)
+        transform_camera.Identity()
+
+        cor = self.center_of_rotation
+
+        transform_camera.Translate(+cor[0], +cor[1], +cor[2])
+        transform_camera.RotateWXYZ(anglex, camera.GetViewUp())
+        transform_camera.RotateWXYZ(angley, axis)
+        transform_camera.Translate(-cor[0], -cor[1], -cor[2])
+
+        new_camera_position = transform_camera.TransformPoint(camera.GetPosition())
+        camera.SetPosition(new_camera_position)
+
+        new_focal_point = transform_camera.TransformPoint(camera.GetFocalPoint())
+        camera.SetFocalPoint(new_focal_point)
+
+        camera.SetViewUp(saved_view_up)
+
+        camera.Modified()
+
+    def dolly(self, factor):
+        renderer = self.GetDefaultRenderer() or self.GetCurrentRenderer()
+        camera = renderer.GetActiveCamera()
+        cursor = self.GetInteractor().GetEventPosition()
+
+        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,
+        )
+
+        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)
+
+        if camera.GetParallelProjection():
+            camera.SetParallelScale(camera.GetParallelScale() / factor)
+        else:
+            camera.Dolly(factor)
+            if self.GetAutoAdjustCameraClippingRange():
+                renderer.ResetCameraClippingRange()
+
+        if self.GetInteractor().GetLightFollowCamera():
+            renderer.UpdateLightsGeometryToFollowCamera()
+
+        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
+
+        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 / renderer.GetSize()[1]
+        return cursor_to_center * scale * (1 - 1 / factor)
+
+    def _make_default_cor_actor(self):
+        actor = RoundPointsActor([(0, 0, 0)])
+        actor.appear_in_front(True)
+        actor.GetProperty().SetColor(1, 0, 0)
+        actor.GetProperty().SetPointSize(10)
+        return actor

molde/interactor_styles/box_selection_style.py

@@ -0,0 +1,70 @@
+import numpy as np
+from vtkmodules.vtkCommonCore import vtkUnsignedCharArray
+
+from .arcball_camera_style import ArcballCameraInteractorStyle
+
+
+class BoxSelectionInteractorStyle(ArcballCameraInteractorStyle):
+    def __init__(self) -> None:
+        ArcballCameraInteractorStyle.__init__(self)
+
+        self.is_selecting = False
+        self._click_position = (0, 0)
+        self._mouse_position = (0, 0)
+        self._saved_pixels = vtkUnsignedCharArray()
+        self.selection_color = (255, 0, 0, 255)
+
+    def _left_button_press_event(self, obj, event):
+        super()._left_button_press_event(obj, event)
+        self._click_position = self.GetInteractor().GetEventPosition()
+        self.start_selection()
+
+    def _left_button_release_event(self, obj, event):
+        super()._left_button_release_event(obj, event)
+        self.stop_selection()
+
+    def _mouse_move_event(self, obj, event):
+        super()._mouse_move_event(obj, event)
+        self._mouse_position = self.GetInteractor().GetEventPosition()
+        self.update_selection()
+
+    def start_selection(self):
+        self.is_selecting = True
+
+        size = self.GetInteractor().GetSize()
+        render_window = self.GetInteractor().GetRenderWindow()
+        render_window.Render()
+        # Save the current screen state
+        render_window.GetRGBACharPixelData(
+            0, 0, size[0] - 1, size[1] - 1, 0, self._saved_pixels
+        )
+
+    def update_selection(self):
+        if not self.is_selecting:
+            return
+
+        size = self.GetInteractor().GetSize()
+        min_x, max_x = sorted([self._click_position[0], self._mouse_position[0]])
+        min_y, max_y = sorted([self._click_position[1], self._mouse_position[1]])
+        min_x, max_x = np.clip([min_x, max_x], 0, size[0])
+        min_y, max_y = np.clip([min_y, max_y], 0, size[1])
+
+        # Copy the saved screen state and draw over it
+        selected_pixels = vtkUnsignedCharArray()
+        selected_pixels.DeepCopy(self._saved_pixels)
+
+        for x in range(min_x, max_x, 2):
+            for y in range(min_y, max_y, 2):
+                pixel = y * size[0] + x
+                selected_pixels.SetTuple(pixel, self.selection_color)
+
+        renderWindow = self.GetInteractor().GetRenderWindow()
+        renderWindow.SetRGBACharPixelData(
+            0, 0, size[0] - 1, size[1] - 1, selected_pixels, 0
+        )
+        renderWindow.Frame()
+
+    def stop_selection(self):
+        self.is_selecting = False
+        render_window = self.GetInteractor().GetRenderWindow()
+        render_window.Render()

molde/pickers/__init__.py

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

molde/pickers/cell_area_picker.py

@@ -0,0 +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)

molde/pickers/cell_property_area_picker.py

@@ -0,0 +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)

molde/poly_data/__init__.py

@@ -0,0 +1,2 @@
+from .lines_data import LinesData
+from .vertices_data import VerticesData

molde/poly_data/lines_data.py

@@ -0,0 +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)

molde/poly_data/vertices_data.py

@@ -0,0 +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)

molde/render_widgets/__init__.py

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