vedo.interactor_modes

   1#!/usr/bin/env python
   2# -*- coding: utf-8 -*-
   3from dataclasses import dataclass
   4import numpy as np
   5
   6try:
   7    import vedo.vtkclasses as vtk
   8except ImportError:
   9    import vtkmodules.all as vtk
  10
  11__docformat__ = "google"
  12
  13__doc__ = """Submodule to customize interaction modes."""
  14
  15
  16class MousePan(vtk.vtkInteractorStyleUser):
  17    """
  18    Interaction mode to pan the scene by dragging the mouse.
  19
  20    Controls:
  21    - Left mouse button will pan the scene.
  22    - Mouse middle button up/down is elevation, and left and right is azimuth.
  23    - Right mouse button is rotate (left/right movement) and zoom in/out
  24      (up/down movement)
  25    - Mouse scroll wheel is zoom in/out
  26    """
  27
  28    def __init__(self):
  29
  30        super().__init__()
  31
  32        self.left = False
  33        self.middle = False
  34        self.right = False
  35
  36        self.interactor = None
  37        self.renderer = None
  38        self.camera = None
  39
  40        self.oldpickD = []
  41        self.newpickD = []
  42        self.oldpickW = np.array([0, 0, 0, 0], dtype=float)
  43        self.newpickW = np.array([0, 0, 0, 0], dtype=float)
  44        self.fpD = np.array([0, 0, 0], dtype=float)
  45        self.fpW = np.array([0, 0, 0], dtype=float)
  46        self.posW = np.array([0, 0, 0], dtype=float)
  47        self.motionD = np.array([0, 0], dtype=float)
  48        self.motionW = np.array([0, 0, 0], dtype=float)
  49
  50        self.AddObserver("LeftButtonPressEvent", self._left_down)
  51        self.AddObserver("LeftButtonReleaseEvent", self._left_up)
  52        self.AddObserver("MiddleButtonPressEvent", self._middle_down)
  53        self.AddObserver("MiddleButtonReleaseEvent", self._middle_up)
  54        self.AddObserver("RightButtonPressEvent", self._right_down)
  55        self.AddObserver("RightButtonReleaseEvent", self._right_up)
  56        self.AddObserver("MouseWheelForwardEvent", self._wheel_forward)
  57        self.AddObserver("MouseWheelBackwardEvent", self._wheel_backward)
  58        self.AddObserver("MouseMoveEvent", self._mouse_move)
  59
  60    def _get_motion(self):
  61        self.oldpickD = np.array(self.interactor.GetLastEventPosition())
  62        self.newpickD = np.array(self.interactor.GetEventPosition())
  63        self.motionD = (self.newpickD - self.oldpickD) / 4
  64        self.camera = self.renderer.GetActiveCamera()
  65        self.fpW = self.camera.GetFocalPoint()
  66        self.posW = self.camera.GetPosition()
  67        self.ComputeWorldToDisplay(self.renderer, self.fpW[0], self.fpW[1], self.fpW[2], self.fpD)
  68        focaldepth = self.fpD[2]
  69        self.ComputeDisplayToWorld(
  70            self.renderer, self.oldpickD[0], self.oldpickD[1], focaldepth, self.oldpickW
  71        )
  72        self.ComputeDisplayToWorld(
  73            self.renderer, self.newpickD[0], self.newpickD[1], focaldepth, self.newpickW
  74        )
  75        self.motionW[:3] = self.oldpickW[:3] - self.newpickW[:3]
  76
  77    def _mouse_left_move(self):
  78        self._get_motion()
  79        self.camera.SetFocalPoint(self.fpW[:3] + self.motionW[:3])
  80        self.camera.SetPosition(self.posW[:3] + self.motionW[:3])
  81        self.interactor.Render()
  82
  83    def _mouse_middle_move(self):
  84        self._get_motion()
  85        if abs(self.motionD[0]) > abs(self.motionD[1]):
  86            self.camera.Azimuth(-2 * self.motionD[0])
  87        else:
  88            self.camera.Elevation(-self.motionD[1])
  89        self.interactor.Render()
  90
  91    def _mouse_right_move(self):
  92        self._get_motion()
  93        if abs(self.motionD[0]) > abs(self.motionD[1]):
  94            self.camera.Azimuth(-2.0 * self.motionD[0])
  95        else:
  96            self.camera.Zoom(1 + self.motionD[1] / 100)
  97        self.interactor.Render()
  98
  99    def _mouse_wheel_forward(self):
 100        self.camera = self.renderer.GetActiveCamera()
 101        self.camera.Zoom(1.1)
 102        self.interactor.Render()
 103
 104    def _mouse_wheel_backward(self):
 105        self.camera = self.renderer.GetActiveCamera()
 106        self.camera.Zoom(0.9)
 107        self.interactor.Render()
 108
 109    def _left_down(self, w, e):
 110        self.left = True
 111
 112    def _left_up(self, w, e):
 113        self.left = False
 114
 115    def _middle_down(self, w, e):
 116        self.middle = True
 117
 118    def _middle_up(self, w, e):
 119        self.middle = False
 120
 121    def _right_down(self, w, e):
 122        self.right = True
 123
 124    def _right_up(self, w, e):
 125        self.right = False
 126
 127    def _wheel_forward(self, w, e):
 128        self._mouse_wheel_forward()
 129
 130    def _wheel_backward(self, w, e):
 131        self._mouse_wheel_backward()
 132
 133    def _mouse_move(self, w, e):
 134        if self.left:
 135            self._mouse_left_move()
 136        if self.middle:
 137            self._mouse_middle_move()
 138        if self.right:
 139            self._mouse_right_move()
 140
 141
 142###################################################################################
 143@dataclass
 144class _BlenderStyleDragInfo:
 145    """Data structure containing the data required to execute dragging a node"""
 146
 147    # Scene related
 148    dragged_node = None  # Node
 149
 150    # VTK related
 151    actors_dragging: list
 152    dragged_actors_original_positions: list  # original VTK positions
 153    start_position_3d = np.array((0, 0, 0))  # start position of the cursor
 154
 155    delta = np.array((0, 0, 0))
 156
 157    def __init__(self):
 158        self.actors_dragging = []
 159        self.dragged_actors_original_positions = []
 160
 161
 162###############################################
 163class BlenderStyle(vtk.vtkInteractorStyleUser):
 164    """
 165    Create an interaction style using the Blender default key-bindings.
 166
 167    Camera action code is largely a translation of
 168    [this](https://github.com/Kitware/VTK/blob/master/Interaction/Style/vtkInteractorStyleTrackballCamera.cxx)
 169    Rubber band code
 170    [here](https://gitlab.kitware.com/updega2/vtk/-/blob/d324b2e898b0da080edee76159c2f92e6f71abe2/Rendering/vtkInteractorStyleRubberBandZoom.cxx)
 171
 172    Interaction:
 173
 174    Left button: Sections
 175    ----------------------
 176    Left button: select
 177
 178    Left button drag: rubber band select or line select, depends on the dragged distance
 179
 180    Middle button: Navigation
 181    --------------------------
 182    Middle button: rotate
 183
 184    Middle button + shift : pan
 185
 186    Middle button + ctrl  : zoom
 187
 188    Middle button + alt : center view on picked point
 189
 190    OR
 191
 192    Middle button + alt   : zoom rubber band
 193
 194    Mouse wheel : zoom
 195
 196    Right button : context
 197    -----------------------
 198    Right key click: reserved for context-menu
 199
 200
 201    Keys
 202    ----
 203
 204    2 or 3 : toggle perspective view
 205
 206    a      : zoom all
 207
 208    x,y,z  : view direction (toggles positive and negative)
 209
 210    left/right arrows: rotate 45 deg clockwise/ccw about z-axis, snaps to nearest 45 deg
 211    b      : box zoom
 212
 213    m      : mouse middle lock (toggles)
 214
 215    space  : same as middle mouse button
 216
 217    g      : grab (move actors)
 218
 219    enter  : accept drag
 220
 221    esc    : cancel drag, call callbackEscape
 222
 223
 224    LAPTOP MODE
 225    -----------
 226    Use space or `m` as replacement for middle button
 227    (`m` is sticky, space is not)
 228
 229    callbacks / overriding keys:
 230
 231    if `callback_any_key` is assigned then this function is called on every key press.
 232    If this function returns True then further processing of events is stopped.
 233
 234
 235    Moving actors
 236    --------------
 237    Actors can be moved interactively by the user.
 238    To support custom groups of actors to be moved as a whole the following system
 239    is implemented:
 240
 241    When 'g' is pressed (grab) then a `_BlenderStyleDragInfo` dataclass object is assigned
 242    to style to `style.draginfo`.
 243
 244    `_BlenderStyleDragInfo` includes a list of all the actors that are being dragged.
 245    By default this is the selection, but this may be altered.
 246    Drag is accepted using enter, click, or g. Drag is cancelled by esc
 247
 248    Events
 249    ------
 250    `callback_start_drag` is called when initializing the drag.
 251    This is when to assign actors and other data to draginfo.
 252
 253    `callback_end_drag` is called when the drag is accepted.
 254
 255    Responding to other events
 256    --------------------------
 257    `callback_camera_direction_changed` : executed when camera has rotated but before re-rendering
 258
 259    .. note::
 260        This class is based on R. de Bruin's
 261        [DAVE](https://github.com/RubendeBruin/DAVE/blob/master/src/DAVE/visual_helpers/vtkBlenderLikeInteractionStyle.py)
 262        implementation as discussed in this
 263        [issue](https://github.com/marcomusy/vedo/discussions/788).
 264
 265    Example:
 266        ```python
 267        from vedo import *
 268        settings.enable_default_keyboard_callbacks = False
 269        settings.enable_default_mouse_callbacks = False
 270        mesh = Mesh(dataurl+"cow.vtk")
 271        mode = interactor_modes.BlenderStyle()
 272        plt = Plotter().user_mode(mode)
 273        plt.show(mesh, axes=1)
 274        ```
 275
 276        - [interaction_modes2.py](https://github.com/marcomusy/vedo/blob/master/examples/basic/interaction_modes2.py)
 277    """
 278
 279    def __init__(self):
 280
 281        super().__init__()
 282
 283        self.interactor = None
 284        self.renderer = None
 285
 286        # callback_select is called whenever one or mode props are selected.
 287        # callback will be called with a list of props of which the first entry
 288        # is prop closest to the camera.
 289        self.callback_select = None
 290        self.callback_start_drag = None
 291        self.callback_end_drag = None
 292        self.callback_escape_key = None
 293        self.callback_delete_key = None
 294        self.callback_focus_key = None
 295        self.callback_any_key = None
 296        self.callback_measure = None  # callback with argument float (meters)
 297        self.callback_camera_direction_changed = None
 298
 299        # active drag
 300        # assigned to a _BlenderStyleDragInfo object when dragging is active
 301        self.draginfo: _BlenderStyleDragInfo or None = None
 302
 303        # picking
 304        self.picked_props = []  # will be filled by latest pick
 305
 306        # settings
 307        self.mouse_motion_factor = 20
 308        self.mouse_wheel_motion_factor = 0.1
 309        self.zoom_motion_factor = 0.25
 310
 311        # internals
 312        self.start_x = 0  # start of a drag
 313        self.start_y = 0
 314        self.end_x = 0
 315        self.end_y = 0
 316
 317        self.middle_mouse_lock = False
 318        self.middle_mouse_lock_actor = None  # will be created when required
 319
 320        # Special Modes
 321        self._is_box_zooming = False
 322
 323        # holds an image of the renderer output at the start of a drawing event
 324        self._pixel_array = vtk.vtkUnsignedCharArray()
 325
 326        self._upside_down = False
 327
 328        self._left_button_down = False
 329        self._middle_button_down = False
 330
 331        self.AddObserver("RightButtonPressEvent", self.RightButtonPress)
 332        self.AddObserver("RightButtonReleaseEvent", self.RightButtonRelease)
 333        self.AddObserver("MiddleButtonPressEvent", self.MiddleButtonPress)
 334        self.AddObserver("MiddleButtonReleaseEvent", self.MiddleButtonRelease)
 335        self.AddObserver("MouseWheelForwardEvent", self.MouseWheelForward)
 336        self.AddObserver("MouseWheelBackwardEvent", self.MouseWheelBackward)
 337        self.AddObserver("LeftButtonPressEvent", self.LeftButtonPress)
 338        self.AddObserver("LeftButtonReleaseEvent", self.LeftButtonRelease)
 339        self.AddObserver("MouseMoveEvent", self.MouseMove)
 340        self.AddObserver("WindowResizeEvent", self.WindowResized)
 341        # ^does not seem to fire!
 342        self.AddObserver("KeyPressEvent", self.KeyPress)
 343        self.AddObserver("KeyReleaseEvent", self.KeyRelease)
 344
 345    def RightButtonPress(self, obj, event):
 346        pass
 347
 348    def RightButtonRelease(self, obj, event):
 349        pass
 350
 351    def MiddleButtonPress(self, obj, event):
 352        self._middle_button_down = True
 353
 354    def MiddleButtonRelease(self, obj, event):
 355        self._middle_button_down = False
 356
 357        # perform middle button focus event if ALT is down
 358        if self.GetInteractor().GetAltKey():
 359            # print("Middle button released while ALT is down")
 360
 361            # try to pick an object at the current mouse position
 362            rwi = self.GetInteractor()
 363            self.start_x, self.start_y = rwi.GetEventPosition()
 364            props = self.PerformPickingOnSelection()
 365
 366            if props:
 367                self.FocusOn(props[0])
 368
 369    def MouseWheelBackward(self, obj, event):
 370        self.MoveMouseWheel(-1)
 371
 372    def MouseWheelForward(self, obj, event):
 373        self.MoveMouseWheel(1)
 374
 375    def MouseMove(self, obj, event):
 376
 377        interactor = self.GetInteractor()
 378
 379        # Find the renderer that is active below the current mouse position
 380        x, y = interactor.GetEventPosition()
 381        self.FindPokedRenderer(x, y)
 382        # sets the current renderer
 383        # [this->SetCurrentRenderer(this->Interactor->FindPokedRenderer(x, y));]
 384
 385        Shift = interactor.GetShiftKey()
 386        Ctrl = interactor.GetControlKey()
 387        Alt = interactor.GetAltKey()
 388
 389        MiddleButton = self._middle_button_down or self.middle_mouse_lock
 390
 391        # start with the special modes
 392        if self._is_box_zooming:
 393            self.DrawDraggedSelection()
 394        elif MiddleButton and not Shift and not Ctrl and not Alt:
 395            self.Rotate()
 396        elif MiddleButton and Shift and not Ctrl and not Alt:
 397            self.Pan()
 398        elif MiddleButton and Ctrl and not Shift and not Alt:
 399            self.Zoom()  # Dolly
 400        elif self.draginfo is not None:
 401            self.ExecuteDrag()
 402        elif self._left_button_down and Ctrl and Shift:
 403            self.DrawMeasurement()
 404        elif self._left_button_down:
 405            self.DrawDraggedSelection()
 406
 407        self.InvokeEvent("InteractionEvent", None)
 408
 409    def MoveMouseWheel(self, direction):
 410        rwi = self.GetInteractor()
 411
 412        # Find the renderer that is active below the current mouse position
 413        x, y = rwi.GetEventPosition()
 414        self.FindPokedRenderer(x, y)
 415        # sets the current renderer
 416        # [this->SetCurrentRenderer(this->Interactor->FindPokedRenderer(x, y));]
 417
 418        # The movement
 419
 420        CurrentRenderer = self.GetCurrentRenderer()
 421
 422        #   // Calculate the focal depth since we'll be using it a lot
 423        camera = CurrentRenderer.GetActiveCamera()
 424        viewFocus = camera.GetFocalPoint()
 425
 426        temp_out = [0, 0, 0]
 427        self.ComputeWorldToDisplay(
 428            CurrentRenderer, viewFocus[0], viewFocus[1], viewFocus[2], temp_out
 429        )
 430        focalDepth = temp_out[2]
 431
 432        newPickPoint = [0, 0, 0, 0]
 433        x, y = rwi.GetEventPosition()
 434        self.ComputeDisplayToWorld(CurrentRenderer, x, y, focalDepth, newPickPoint)
 435
 436        #   // Has to recalc old mouse point since the viewport has moved,
 437        #   // so can't move it outside the loop
 438
 439        oldPickPoint = [0, 0, 0, 0]
 440        # xp, yp = rwi.GetLastEventPosition()
 441
 442        # find the center of the window
 443        size = rwi.GetRenderWindow().GetSize()
 444        xp = size[0] / 2
 445        yp = size[1] / 2
 446
 447        self.ComputeDisplayToWorld(CurrentRenderer, xp, yp, focalDepth, oldPickPoint)
 448        #
 449        #   // Camera motion is reversed
 450        #
 451        move_factor = -1 * self.zoom_motion_factor * direction
 452
 453        motionVector = (
 454            move_factor * (oldPickPoint[0] - newPickPoint[0]),
 455            move_factor * (oldPickPoint[1] - newPickPoint[1]),
 456            move_factor * (oldPickPoint[2] - newPickPoint[2]),
 457        )
 458
 459        viewFocus = camera.GetFocalPoint()  # do we need to do this again? Already did this
 460        viewPoint = camera.GetPosition()
 461
 462        camera.SetFocalPoint(
 463            motionVector[0] + viewFocus[0],
 464            motionVector[1] + viewFocus[1],
 465            motionVector[2] + viewFocus[2],
 466        )
 467        camera.SetPosition(
 468            motionVector[0] + viewPoint[0],
 469            motionVector[1] + viewPoint[1],
 470            motionVector[2] + viewPoint[2],
 471        )
 472
 473        # the Zooming
 474        factor = self.mouse_motion_factor * self.mouse_wheel_motion_factor
 475        self.ZoomByStep(direction * factor)
 476
 477    def ZoomByStep(self, step):
 478        CurrentRenderer = self.GetCurrentRenderer()
 479
 480        if CurrentRenderer:
 481            self.StartDolly()
 482            self.Dolly(pow(1.1, step))
 483            self.EndDolly()
 484
 485    def LeftButtonPress(self, obj, event):
 486
 487        if self._is_box_zooming:
 488            return
 489        if self.draginfo:
 490            return
 491
 492        self._left_button_down = True
 493
 494        interactor = self.GetInteractor()
 495        Shift = interactor.GetShiftKey()
 496        Ctrl = interactor.GetControlKey()
 497
 498        if Shift and Ctrl:
 499            if not self.GetCurrentRenderer().GetActiveCamera().GetParallelProjection():
 500                self.ToggleParallelProjection()
 501
 502        rwi = self.GetInteractor()
 503        self.start_x, self.start_y = rwi.GetEventPosition()
 504        self.end_x = self.start_x
 505        self.end_y = self.start_y
 506
 507        self.InitializeScreenDrawing()
 508
 509    def LeftButtonRelease(self, obj, event):
 510        # print("LeftButtonRelease")
 511        if self._is_box_zooming:
 512            self._is_box_zooming = False
 513            self.ZoomBox(self.start_x, self.start_y, self.end_x, self.end_y)
 514            return
 515
 516        if self.draginfo:
 517            self.FinishDrag()
 518            return
 519
 520        self._left_button_down = False
 521
 522        interactor = self.GetInteractor()
 523
 524        Shift = interactor.GetShiftKey()
 525        Ctrl = interactor.GetControlKey()
 526        # Alt = interactor.GetAltKey()
 527
 528        if Ctrl and Shift:
 529            pass  # we were drawing the measurement
 530
 531        else:
 532            if self.callback_select:
 533                props = self.PerformPickingOnSelection()
 534
 535                if props:  # only call back if anything was selected
 536                    self.picked_props = tuple(props)
 537                    self.callback_select(props)
 538
 539        # remove the selection rubber band / line
 540        self.GetInteractor().Render()
 541
 542    def KeyPress(self, obj, event):
 543
 544        key = obj.GetKeySym()
 545        KEY = key.upper()
 546
 547        # logging.info(f"Key Press: {key}")
 548        if self.callback_any_key:
 549            if self.callback_any_key(key):
 550                return
 551
 552        if KEY == "M":
 553            self.middle_mouse_lock = not self.middle_mouse_lock
 554            self.UpdateMiddleMouseButtonLockActor()
 555        elif KEY == "G":
 556            if self.draginfo is not None:
 557                self.FinishDrag()
 558            else:
 559                if self.callback_start_drag:
 560                    self.callback_start_drag()
 561                else:
 562                    self.StartDrag()
 563                    # internally calls end-drag if drag is already active
 564        elif KEY == "ESCAPE":
 565            if self.callback_escape_key:
 566                self.callback_escape_key()
 567            if self.draginfo is not None:
 568                self.CancelDrag()
 569        elif KEY == "DELETE":
 570            if self.callback_delete_key:
 571                self.callback_delete_key()
 572        elif KEY == "RETURN":
 573            if self.draginfo:
 574                self.FinishDrag()
 575        elif KEY == "SPACE":
 576            self.middle_mouse_lock = True
 577            # self.UpdateMiddleMouseButtonLockActor()
 578            # self.GrabFocus("MouseMoveEvent", self)
 579            # # TODO: grab and release focus; possible from python?
 580        elif KEY == "B":
 581            self._is_box_zooming = True
 582            rwi = self.GetInteractor()
 583            self.start_x, self.start_y = rwi.GetEventPosition()
 584            self.end_x = self.start_x
 585            self.end_y = self.start_y
 586            self.InitializeScreenDrawing()
 587        elif KEY in ('2', '3'):
 588            self.ToggleParallelProjection()
 589
 590        elif KEY == "A":
 591            self.ZoomFit()
 592        elif KEY == "X":
 593            self.SetViewX()
 594        elif KEY == "Y":
 595            self.SetViewY()
 596        elif KEY == "Z":
 597            self.SetViewZ()
 598        elif KEY == "LEFT":
 599            self.RotateDiscreteStep(1)
 600        elif KEY == "RIGHT":
 601            self.RotateDiscreteStep(-1)
 602        elif KEY == "UP":
 603            self.RotateTurtableBy(0, 10)
 604        elif KEY == "DOWN":
 605            self.RotateTurtableBy(0, -10)
 606        elif KEY == "PLUS":
 607            self.ZoomByStep(2)
 608        elif KEY == "MINUS":
 609            self.ZoomByStep(-2)
 610        elif KEY == "F":
 611            if self.callback_focus_key:
 612                self.callback_focus_key()
 613
 614        self.InvokeEvent("InteractionEvent", None)
 615
 616    def KeyRelease(self, obj, event):
 617
 618        key = obj.GetKeySym()
 619        KEY = key.upper()
 620
 621        # print(f"Key release: {key}")
 622
 623        if KEY == "SPACE":
 624            if self.middle_mouse_lock:
 625                self.middle_mouse_lock = False
 626                self.UpdateMiddleMouseButtonLockActor()
 627
 628    def WindowResized(self):
 629        # print("window resized")
 630        self.InitializeScreenDrawing()
 631
 632    def RotateDiscreteStep(self, movement_direction, step=22.5):
 633        """Rotates CW or CCW to the nearest 45 deg angle
 634        - includes some fuzzyness to determine about which axis"""
 635
 636        CurrentRenderer = self.GetCurrentRenderer()
 637        camera = CurrentRenderer.GetActiveCamera()
 638
 639        step = np.deg2rad(step)
 640
 641        direction = -np.array(camera.GetViewPlaneNormal())  # current camera direction
 642
 643        if abs(direction[2]) < 0.7:
 644            # horizontal view, rotate camera position about Z-axis
 645            angle = np.arctan2(direction[1], direction[0])
 646
 647            # find the nearest angle that is an integer number of steps
 648            if movement_direction > 0:
 649                angle = step * np.floor((angle + 0.1 * step) / step) + step
 650            else:
 651                angle = -step * np.floor(-(angle - 0.1 * step) / step) - step
 652
 653            dist = np.linalg.norm(direction[:2])
 654
 655            direction[0] = np.cos(angle) * dist
 656            direction[1] = np.sin(angle) * dist
 657
 658            self.SetCameraDirection(direction)
 659
 660        else:  # Top or bottom like view - rotate camera "up" direction
 661
 662            up = np.array(camera.GetViewUp())
 663
 664            angle = np.arctan2(up[1], up[0])
 665
 666            # find the nearest angle that is an integer number of steps
 667            if movement_direction > 0:
 668                angle = step * np.floor((angle + 0.1 * step) / step) + step
 669            else:
 670                angle = -step * np.floor(-(angle - 0.1 * step) / step) - step
 671
 672            dist = np.linalg.norm(up[:2])
 673
 674            up[0] = np.cos(angle) * dist
 675            up[1] = np.sin(angle) * dist
 676
 677            camera.SetViewUp(up)
 678            camera.OrthogonalizeViewUp()
 679
 680            self.GetInteractor().Render()
 681
 682    def ToggleParallelProjection(self):
 683        renderer = self.GetCurrentRenderer()
 684        camera = renderer.GetActiveCamera()
 685        camera.SetParallelProjection(not bool(camera.GetParallelProjection()))
 686        self.GetInteractor().Render()
 687
 688    def SetViewX(self):
 689        self.SetCameraPlaneDirection((1, 0, 0))
 690
 691    def SetViewY(self):
 692        self.SetCameraPlaneDirection((0, 1, 0))
 693
 694    def SetViewZ(self):
 695        self.SetCameraPlaneDirection((0, 0, 1))
 696
 697    def ZoomFit(self):
 698        self.GetCurrentRenderer().ResetCamera()
 699        self.GetInteractor().Render()
 700
 701    def SetCameraPlaneDirection(self, direction):
 702        """Sets the camera to display a plane of which direction is the normal
 703        - includes logic to reverse the direction if benificial"""
 704
 705        CurrentRenderer = self.GetCurrentRenderer()
 706        camera = CurrentRenderer.GetActiveCamera()
 707
 708        direction = np.array(direction)
 709
 710        normal = camera.GetViewPlaneNormal()
 711        # can not set the normal, need to change the position to do that
 712
 713        current_alignment = np.dot(normal, -direction)
 714        # print(f"Current alignment = {current_alignment}")
 715
 716        if abs(current_alignment) > 0.9999:
 717            # print("toggling")
 718            direction = -np.array(normal)
 719        elif current_alignment > 0:  # find the nearest plane
 720            # print("reversing to find nearest")
 721            direction = -direction
 722
 723        self.SetCameraDirection(-direction)
 724
 725    def SetCameraDirection(self, direction):
 726        """Sets the camera to this direction, sets view up if horizontal enough"""
 727        direction = np.array(direction)
 728
 729        CurrentRenderer = self.GetCurrentRenderer()
 730        camera = CurrentRenderer.GetActiveCamera()
 731        rwi = self.GetInteractor()
 732
 733        pos = np.array(camera.GetPosition())
 734        focal = np.array(camera.GetFocalPoint())
 735        dist = np.linalg.norm(pos - focal)
 736
 737        pos = focal - dist * direction
 738        camera.SetPosition(pos)
 739
 740        if abs(direction[2]) < 0.9:
 741            camera.SetViewUp(0, 0, 1)
 742        elif direction[2] > 0.9:
 743            camera.SetViewUp(0, -1, 0)
 744        else:
 745            camera.SetViewUp(0, 1, 0)
 746
 747        camera.OrthogonalizeViewUp()
 748
 749        if self.GetAutoAdjustCameraClippingRange():
 750            CurrentRenderer.ResetCameraClippingRange()
 751
 752        if rwi.GetLightFollowCamera():
 753            CurrentRenderer.UpdateLightsGeometryToFollowCamera()
 754
 755        if self.callback_camera_direction_changed:
 756            self.callback_camera_direction_changed()
 757
 758        self.GetInteractor().Render()
 759
 760    def PerformPickingOnSelection(self):
 761        """Preforms prop3d picking on the current dragged selection
 762
 763        If the distance between the start and endpoints is less than the threshold
 764        then a SINGLE prop3d is picked along the line
 765
 766        the selection area is drawn by the rubber band and is defined by
 767        self.start_x, self.start_y, self.end_x, self.end_y
 768        """
 769        renderer = self.GetCurrentRenderer()
 770
 771        assemblyPath = renderer.PickProp(self.start_x, self.start_y, self.end_x, self.end_y)
 772
 773        # re-pick in larger area if nothing is returned
 774        if not assemblyPath:
 775            self.start_x -= 2
 776            self.end_x += 2
 777            self.start_y -= 2
 778            self.end_y += 2
 779            assemblyPath = renderer.PickProp(self.start_x, self.start_y, self.end_x, self.end_y)
 780
 781        # The nearest prop (by Z-value)
 782        if assemblyPath:
 783            assert (
 784                assemblyPath.GetNumberOfItems() == 1
 785            ), "Wrong assumption on number of returned nodes when picking"
 786            nearest_prop = assemblyPath.GetItemAsObject(0).GetViewProp()
 787
 788            # all props
 789            collection = renderer.GetPickResultProps()
 790            props = [collection.GetItemAsObject(i) for i in range(collection.GetNumberOfItems())]
 791
 792            props.remove(nearest_prop)
 793            props.insert(0, nearest_prop)
 794
 795            return props
 796
 797        else:
 798            return []
 799
 800    # ----------- actor dragging ------------
 801
 802    def StartDrag(self):
 803        if self.callback_start_drag:
 804            # print("Calling callback_start_drag")
 805            self.callback_start_drag()
 806            return
 807        else:  # grab the current selection
 808            if self.picked_props:
 809                self.StartDragOnProps(self.picked_props)
 810            else:
 811                pass
 812                # print('Can not start drag, nothing selected and callback_start_drag not assigned')
 813
 814    def FinishDrag(self):
 815        # print('Finished drag')
 816        if self.callback_end_drag:
 817            # reset actor positions as actors positions will be controlled by called functions
 818            for pos0, actor in zip(
 819                self.draginfo.dragged_actors_original_positions, self.draginfo.actors_dragging
 820            ):
 821                actor.SetPosition(pos0)
 822            self.callback_end_drag(self.draginfo)
 823
 824        self.draginfo = None
 825
 826    def StartDragOnProps(self, props):
 827        """Starts drag on the provided props (actors) by filling self.draginfo"""
 828        if self.draginfo is not None:
 829            self.FinishDrag()
 830            return
 831
 832        # print('Starting drag')
 833
 834        # create and fill drag-info
 835        draginfo = _BlenderStyleDragInfo()
 836
 837        #
 838        # draginfo.dragged_node = node
 839        #
 840        # # find all actors and outlines corresponding to this node
 841        # actors = [*self.actor_from_node(node).actors.values()]
 842        # outlines = [ol.outline_actor for ol in self.node_outlines if ol.parent_vp_actor in actors]
 843
 844        draginfo.actors_dragging = props  # [*actors, *outlines]
 845
 846        for a in draginfo.actors_dragging:
 847            draginfo.dragged_actors_original_positions.append(a.GetPosition())  # numpy ndarray
 848
 849        # Get the start position of the drag in 3d
 850
 851        rwi = self.GetInteractor()
 852        CurrentRenderer = self.GetCurrentRenderer()
 853        camera = CurrentRenderer.GetActiveCamera()
 854        viewFocus = camera.GetFocalPoint()
 855
 856        temp_out = [0, 0, 0]
 857        self.ComputeWorldToDisplay(
 858            CurrentRenderer, viewFocus[0], viewFocus[1], viewFocus[2], temp_out
 859        )
 860        focalDepth = temp_out[2]
 861
 862        newPickPoint = [0, 0, 0, 0]
 863        x, y = rwi.GetEventPosition()
 864        self.ComputeDisplayToWorld(CurrentRenderer, x, y, focalDepth, newPickPoint)
 865
 866        mouse_pos_3d = np.array(newPickPoint[:3])
 867
 868        draginfo.start_position_3d = mouse_pos_3d
 869
 870        self.draginfo = draginfo
 871
 872    def ExecuteDrag(self):
 873
 874        rwi = self.GetInteractor()
 875        CurrentRenderer = self.GetCurrentRenderer()
 876
 877        camera = CurrentRenderer.GetActiveCamera()
 878        viewFocus = camera.GetFocalPoint()
 879
 880        # Get the picked point in 3d
 881
 882        temp_out = [0, 0, 0]
 883        self.ComputeWorldToDisplay(
 884            CurrentRenderer, viewFocus[0], viewFocus[1], viewFocus[2], temp_out
 885        )
 886        focalDepth = temp_out[2]
 887
 888        newPickPoint = [0, 0, 0, 0]
 889        x, y = rwi.GetEventPosition()
 890        self.ComputeDisplayToWorld(CurrentRenderer, x, y, focalDepth, newPickPoint)
 891
 892        mouse_pos_3d = np.array(newPickPoint[:3])
 893
 894        # compute the delta and execute
 895
 896        delta = np.array(mouse_pos_3d) - self.draginfo.start_position_3d
 897        # print(f'Delta = {delta}')
 898        view_normal = np.array(self.GetCurrentRenderer().GetActiveCamera().GetViewPlaneNormal())
 899
 900        delta_inplane = delta - view_normal * np.dot(delta, view_normal)
 901        # print(f'delta_inplane = {delta_inplane}')
 902
 903        for pos0, actor in zip(
 904            self.draginfo.dragged_actors_original_positions, 
 905            self.draginfo.actors_dragging
 906        ):
 907            m = actor.GetUserMatrix()
 908            if m:
 909                print("UserMatrices/transforms not supported")
 910                # m.Invert() #inplace
 911                # rotated = m.MultiplyFloatPoint([*delta_inplane, 1])
 912                # actor.SetPosition(pos0 + np.array(rotated[:3]))
 913            actor.SetPosition(pos0 + delta_inplane)
 914
 915        # print(f'Set position to {pos0 + delta_inplane}')
 916        self.draginfo.delta = delta_inplane  # store the current delta
 917
 918        self.GetInteractor().Render()
 919
 920    def CancelDrag(self):
 921        """Cancels the drag and restored the original positions of all dragged actors"""
 922        for pos0, actor in zip(
 923            self.draginfo.dragged_actors_original_positions, 
 924            self.draginfo.actors_dragging
 925        ):
 926            actor.SetPosition(pos0)
 927        self.draginfo = None
 928        self.GetInteractor().Render()
 929
 930    # ----------- end dragging --------------
 931
 932    def Zoom(self):
 933        rwi = self.GetInteractor()
 934        x, y = rwi.GetEventPosition()
 935        xp, yp = rwi.GetLastEventPosition()
 936
 937        direction = y - yp
 938        self.MoveMouseWheel(direction / 10)
 939
 940    def Pan(self):
 941
 942        CurrentRenderer = self.GetCurrentRenderer()
 943
 944        if CurrentRenderer:
 945
 946            rwi = self.GetInteractor()
 947
 948            #   // Calculate the focal depth since we'll be using it a lot
 949            camera = CurrentRenderer.GetActiveCamera()
 950            viewFocus = camera.GetFocalPoint()
 951
 952            temp_out = [0, 0, 0]
 953            self.ComputeWorldToDisplay(
 954                CurrentRenderer, viewFocus[0], viewFocus[1], viewFocus[2], temp_out
 955            )
 956            focalDepth = temp_out[2]
 957
 958            newPickPoint = [0, 0, 0, 0]
 959            x, y = rwi.GetEventPosition()
 960            self.ComputeDisplayToWorld(CurrentRenderer, x, y, focalDepth, newPickPoint)
 961
 962            #   // Has to recalc old mouse point since the viewport has moved,
 963            #   // so can't move it outside the loop
 964
 965            oldPickPoint = [0, 0, 0, 0]
 966            xp, yp = rwi.GetLastEventPosition()
 967            self.ComputeDisplayToWorld(CurrentRenderer, xp, yp, focalDepth, oldPickPoint)
 968            #
 969            #   // Camera motion is reversed
 970            #
 971            motionVector = (
 972                oldPickPoint[0] - newPickPoint[0],
 973                oldPickPoint[1] - newPickPoint[1],
 974                oldPickPoint[2] - newPickPoint[2],
 975            )
 976
 977            viewFocus = camera.GetFocalPoint()  # do we need to do this again? Already did this
 978            viewPoint = camera.GetPosition()
 979
 980            camera.SetFocalPoint(
 981                motionVector[0] + viewFocus[0],
 982                motionVector[1] + viewFocus[1],
 983                motionVector[2] + viewFocus[2],
 984            )
 985            camera.SetPosition(
 986                motionVector[0] + viewPoint[0],
 987                motionVector[1] + viewPoint[1],
 988                motionVector[2] + viewPoint[2],
 989            )
 990
 991            if rwi.GetLightFollowCamera():
 992                CurrentRenderer.UpdateLightsGeometryToFollowCamera()
 993
 994            self.GetInteractor().Render()
 995
 996    def Rotate(self):
 997
 998        CurrentRenderer = self.GetCurrentRenderer()
 999
1000        if CurrentRenderer:
1001
1002            rwi = self.GetInteractor()
1003            dx = rwi.GetEventPosition()[0] - rwi.GetLastEventPosition()[0]
1004            dy = rwi.GetEventPosition()[1] - rwi.GetLastEventPosition()[1]
1005
1006            size = CurrentRenderer.GetRenderWindow().GetSize()
1007            delta_elevation = -20.0 / size[1]
1008            delta_azimuth = -20.0 / size[0]
1009
1010            rxf = dx * delta_azimuth * self.mouse_motion_factor
1011            ryf = dy * delta_elevation * self.mouse_motion_factor
1012
1013            self.RotateTurtableBy(rxf, ryf)
1014
1015    def RotateTurtableBy(self, rxf, ryf):
1016
1017        CurrentRenderer = self.GetCurrentRenderer()
1018        rwi = self.GetInteractor()
1019
1020        # rfx is rotation about the global Z vector (turn-table mode)
1021        # rfy is rotation about the side vector
1022
1023        camera = CurrentRenderer.GetActiveCamera()
1024        campos = np.array(camera.GetPosition())
1025        focal = np.array(camera.GetFocalPoint())
1026        up = camera.GetViewUp()
1027        upside_down_factor = -1 if up[2] < 0 else 1
1028
1029        # rotate about focal point
1030
1031        P = campos - focal  # camera position
1032
1033        # Rotate left/right about the global Z axis
1034        H = np.linalg.norm(P[:2])  # horizontal distance of camera to focal point
1035        elev = np.arctan2(P[2], H)  # elevation
1036
1037        # if the camera is near the poles, then derive the azimuth from the up-vector
1038        sin_elev = np.sin(elev)
1039        if abs(sin_elev) < 0.8:
1040            azi = np.arctan2(P[1], P[0])  # azimuth from camera position
1041        else:
1042            if sin_elev < -0.8:
1043                azi = np.arctan2(upside_down_factor * up[1], upside_down_factor * up[0])
1044            else:
1045                azi = np.arctan2(-upside_down_factor * up[1], -upside_down_factor * up[0])
1046
1047        D = np.linalg.norm(P)  # distance from focal point to camera
1048
1049        # apply the change in azimuth and elevation
1050        azi_new = azi + rxf / 60
1051
1052        elev_new = elev + upside_down_factor * ryf / 60
1053
1054        # the changed elevation changes H (D stays the same)
1055        Hnew = D * np.cos(elev_new)
1056
1057        # calculate new camera position relative to focal point
1058        Pnew = np.array((Hnew * np.cos(azi_new), Hnew * np.sin(azi_new), D * np.sin(elev_new)))
1059
1060        # calculate the up-direction of the camera
1061        up_z = upside_down_factor * np.cos(elev_new)  # z follows directly from elevation
1062        up_h = upside_down_factor * np.sin(elev_new)  # horizontal component
1063        #
1064        # if upside_down:
1065        #     up_z = -up_z
1066        #     up_h = -up_h
1067
1068        up = (-up_h * np.cos(azi_new), -up_h * np.sin(azi_new), up_z)
1069
1070        new_pos = focal + Pnew
1071
1072        camera.SetViewUp(up)
1073        camera.SetPosition(new_pos)
1074
1075        camera.OrthogonalizeViewUp()
1076
1077        # Update
1078
1079        if self.GetAutoAdjustCameraClippingRange():
1080            CurrentRenderer.ResetCameraClippingRange()
1081
1082        if rwi.GetLightFollowCamera():
1083            CurrentRenderer.UpdateLightsGeometryToFollowCamera()
1084
1085        if self.callback_camera_direction_changed:
1086            self.callback_camera_direction_changed()
1087
1088        self.GetInteractor().Render()
1089
1090    def ZoomBox(self, x1, y1, x2, y2):
1091        """Zooms to a box"""
1092        # int width, height;
1093        #   width = abs(this->EndPosition[0] - this->StartPosition[0]);
1094        #   height = abs(this->EndPosition[1] - this->StartPosition[1]);
1095
1096        if x1 > x2:
1097            _ = x1
1098            x1 = x2
1099            x2 = _
1100        if y1 > y2:
1101            _ = y1
1102            y1 = y2
1103            y2 = _
1104
1105        width = x2 - x1
1106        height = y2 - y1
1107
1108        #   int *size = this->CurrentRenderer->GetSize();
1109        CurrentRenderer = self.GetCurrentRenderer()
1110        size = CurrentRenderer.GetSize()
1111        origin = CurrentRenderer.GetOrigin()
1112        camera = CurrentRenderer.GetActiveCamera()
1113
1114        # Assuming we're drawing the band on the view-plane
1115        rbcenter = (x1 + width / 2, y1 + height / 2, 0)
1116
1117        CurrentRenderer.SetDisplayPoint(rbcenter)
1118        CurrentRenderer.DisplayToView()
1119        CurrentRenderer.ViewToWorld()
1120
1121        worldRBCenter = CurrentRenderer.GetWorldPoint()
1122
1123        invw = 1.0 / worldRBCenter[3]
1124        worldRBCenter = [c * invw for c in worldRBCenter]
1125        winCenter = [origin[0] + 0.5 * size[0], origin[1] + 0.5 * size[1], 0]
1126
1127        CurrentRenderer.SetDisplayPoint(winCenter)
1128        CurrentRenderer.DisplayToView()
1129        CurrentRenderer.ViewToWorld()
1130
1131        worldWinCenter = CurrentRenderer.GetWorldPoint()
1132        invw = 1.0 / worldWinCenter[3]
1133        worldWinCenter = [c * invw for c in worldWinCenter]
1134
1135        translation = [
1136            worldRBCenter[0] - worldWinCenter[0],
1137            worldRBCenter[1] - worldWinCenter[1],
1138            worldRBCenter[2] - worldWinCenter[2],
1139        ]
1140
1141        pos = camera.GetPosition()
1142        fp = camera.GetFocalPoint()
1143        #
1144        pos = [pos[i] + translation[i] for i in range(3)]
1145        fp = [fp[i] + translation[i] for i in range(3)]
1146
1147        #
1148        camera.SetPosition(pos)
1149        camera.SetFocalPoint(fp)
1150
1151        if width > height:
1152            if width:
1153                camera.Zoom(size[0] / width)
1154        else:
1155            if height:
1156                camera.Zoom(size[1] / height)
1157
1158        self.GetInteractor().Render()
1159
1160    def FocusOn(self, prop3D):
1161        """Move the camera to focus on this particular prop3D"""
1162
1163        position = prop3D.GetPosition()
1164
1165        # print(f"Focus on {position}")
1166
1167        CurrentRenderer = self.GetCurrentRenderer()
1168        camera = CurrentRenderer.GetActiveCamera()
1169
1170        fp = camera.GetFocalPoint()
1171        pos = camera.GetPosition()
1172
1173        camera.SetFocalPoint(position)
1174        camera.SetPosition(
1175            position[0] - fp[0] + pos[0],
1176            position[1] - fp[1] + pos[1],
1177            position[2] - fp[2] + pos[2],
1178        )
1179
1180        if self.GetAutoAdjustCameraClippingRange():
1181            CurrentRenderer.ResetCameraClippingRange()
1182
1183        rwi = self.GetInteractor()
1184        if rwi.GetLightFollowCamera():
1185            CurrentRenderer.UpdateLightsGeometryToFollowCamera()
1186
1187        self.GetInteractor().Render()
1188
1189    def Dolly(self, factor):
1190        CurrentRenderer = self.GetCurrentRenderer()
1191
1192        if CurrentRenderer:
1193            camera = CurrentRenderer.GetActiveCamera()
1194
1195            if camera.GetParallelProjection():
1196                camera.SetParallelScale(camera.GetParallelScale() / factor)
1197            else:
1198                camera.Dolly(factor)
1199                if self.GetAutoAdjustCameraClippingRange():
1200                    CurrentRenderer.ResetCameraClippingRange()
1201
1202            # if not do_not_update:
1203            #     rwi = self.GetInteractor()
1204            #     if rwi.GetLightFollowCamera():
1205            #         CurrentRenderer.UpdateLightsGeometryToFollowCamera()
1206            #     # rwi.Render()
1207
1208    def DrawMeasurement(self):
1209        rwi = self.GetInteractor()
1210        self.end_x, self.end_y = rwi.GetEventPosition()
1211        self.DrawLine(self.start_x, self.end_x, self.start_y, self.end_y)
1212
1213    def DrawDraggedSelection(self):
1214        rwi = self.GetInteractor()
1215        self.end_x, self.end_y = rwi.GetEventPosition()
1216        self.DrawRubberBand(self.start_x, self.end_x, self.start_y, self.end_y)
1217
1218    def InitializeScreenDrawing(self):
1219        # make an image of the currently rendered image
1220
1221        rwi = self.GetInteractor()
1222        rwin = rwi.GetRenderWindow()
1223
1224        size = rwin.GetSize()
1225
1226        self._pixel_array.Initialize()
1227        self._pixel_array.SetNumberOfComponents(4)
1228        self._pixel_array.SetNumberOfTuples(size[0] * size[1])
1229
1230        front = 1  # what does this do?
1231        rwin.GetRGBACharPixelData(0, 0, size[0] - 1, size[1] - 1, front, self._pixel_array)
1232
1233    def DrawRubberBand(self, x1, x2, y1, y2):
1234        rwi = self.GetInteractor()
1235        rwin = rwi.GetRenderWindow()
1236
1237        size = rwin.GetSize()
1238
1239        tempPA = vtk.vtkUnsignedCharArray()
1240        tempPA.DeepCopy(self._pixel_array)
1241
1242        # check size, viewport may have been resized in the mean-time
1243        if tempPA.GetNumberOfTuples() != size[0] * size[1]:
1244            # print(
1245            #     "Starting new screen-image - viewport has resized without us knowing"
1246            # )
1247            self.InitializeScreenDrawing()
1248            self.DrawRubberBand(x1, x2, y1, y2)
1249            return
1250
1251        x2 = min(x2, size[0] - 1)
1252        y2 = min(y2, size[1] - 1)
1253
1254        x2 = max(x2, 0)
1255        y2 = max(y2, 0)
1256
1257        # Modify the pixel array
1258        width = abs(x2 - x1)
1259        height = abs(y2 - y1)
1260        minx = min(x2, x1)
1261        miny = min(y2, y1)
1262
1263        # draw top and bottom
1264        for i in range(width):
1265
1266            # c = round((10*i % 254)/254) * 254  # find some alternating color
1267            c = 0
1268
1269            idx = (miny * size[0]) + minx + i
1270            tempPA.SetTuple(idx, (c, c, c, 1))
1271
1272            idx = ((miny + height) * size[0]) + minx + i
1273            tempPA.SetTuple(idx, (c, c, c, 1))
1274
1275        # draw left and right
1276        for i in range(height):
1277            # c = round((10 * i % 254) / 254) * 254  # find some alternating color
1278            c = 0
1279
1280            idx = ((miny + i) * size[0]) + minx
1281            tempPA.SetTuple(idx, (c, c, c, 1))
1282
1283            idx = idx + width
1284            tempPA.SetTuple(idx, (c, c, c, 1))
1285
1286        # and Copy back to the window
1287        rwin.SetRGBACharPixelData(0, 0, size[0] - 1, size[1] - 1, tempPA, 0)
1288        rwin.Frame()
1289
1290    def LineToPixels(self, x1, x2, y1, y2):
1291        """Returns the x and y values of the pixels on a line between x1,y1 and x2,y2.
1292        If start and end are identical then a single point is returned"""
1293
1294        dx = x2 - x1
1295        dy = y2 - y1
1296
1297        if dx == 0 and dy == 0:
1298            return [x1], [y1]
1299
1300        if abs(dx) > abs(dy):
1301            dhdw = dy / dx
1302            r = range(0, dx, int(dx / abs(dx)))
1303            x = [x1 + i for i in r]
1304            y = [round(y1 + dhdw * i) for i in r]
1305        else:
1306            dwdh = dx / dy
1307            r = range(0, dy, int(dy / abs(dy)))
1308            y = [y1 + i for i in r]
1309            x = [round(x1 + i * dwdh) for i in r]
1310
1311        return x, y
1312
1313    def DrawLine(self, x1, x2, y1, y2):
1314        rwi = self.GetInteractor()
1315        rwin = rwi.GetRenderWindow()
1316
1317        size = rwin.GetSize()
1318
1319        x1 = min(max(x1, 0), size[0])
1320        x2 = min(max(x2, 0), size[0])
1321        y1 = min(max(y1, 0), size[1])
1322        y2 = min(max(y2, 0), size[1])
1323
1324        tempPA = vtk.vtkUnsignedCharArray()
1325        tempPA.DeepCopy(self._pixel_array)
1326
1327        xs, ys = self.LineToPixels(x1, x2, y1, y2)
1328        for x, y in zip(xs, ys):
1329            idx = (y * size[0]) + x
1330            tempPA.SetTuple(idx, (0, 0, 0, 1))
1331
1332        # and Copy back to the window
1333        rwin.SetRGBACharPixelData(0, 0, size[0] - 1, size[1] - 1, tempPA, 0)
1334
1335        camera = self.GetCurrentRenderer().GetActiveCamera()
1336        scale = camera.GetParallelScale()
1337
1338        # Set/Get the scaling used for a parallel projection, i.e.
1339        #
1340        # the half of the height of the viewport in world-coordinate distances.
1341        # The default is 1. Note that the "scale" parameter works as an "inverse scale"
1342        #  larger numbers produce smaller images.
1343        # This method has no effect in perspective projection mode
1344
1345        half_height = size[1] / 2
1346        # half_height [px] = scale [world-coordinates]
1347
1348        length = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
1349        meters_per_pixel = scale / half_height
1350        meters = length * meters_per_pixel
1351
1352        if camera.GetParallelProjection():
1353            print(f"Line length = {length} px = {meters} m")
1354        else:
1355            print("Need to be in non-perspective mode to measure. Press 2 or 3 to get there")
1356
1357        if self.callback_measure:
1358            self.callback_measure(meters)
1359
1360        #
1361        # # can we add something to the window here?
1362        # freeType = vtk.vtkFreeTypeTools.GetInstance()
1363        # textProperty = vtk.vtkTextProperty()
1364        # textProperty.SetJustificationToLeft()
1365        # textProperty.SetFontSize(24)
1366        # textProperty.SetOrientation(25)
1367        #
1368        # textImage = vtk.vtkImageData()
1369        # freeType.RenderString(textProperty, "a somewhat longer text", 72, textImage)
1370        # # this does not give an error, assume it works
1371        # #
1372        # textImage.GetDimensions()
1373        # textImage.GetExtent()
1374        #
1375        # # # Now put the textImage in the RenderWindow
1376        # rwin.SetRGBACharPixelData(0, 0, size[0] - 1, size[1] - 1, textImage, 0)
1377
1378        rwin.Frame()
1379
1380    def UpdateMiddleMouseButtonLockActor(self):
1381
1382        if self.middle_mouse_lock_actor is None:
1383            # create the actor
1384            # Create a text on the top-rightcenter
1385            textMapper = vtk.vtkTextMapper()
1386            textMapper.SetInput("Middle mouse lock [m or space] active")
1387            textProp = textMapper.GetTextProperty()
1388            textProp.SetFontSize(12)
1389            textProp.SetFontFamilyToTimes()
1390            textProp.BoldOff()
1391            textProp.ItalicOff()
1392            textProp.ShadowOff()
1393            textProp.SetVerticalJustificationToTop()
1394            textProp.SetJustificationToCentered()
1395            textProp.SetColor((0, 0, 0))
1396
1397            self.middle_mouse_lock_actor = vtk.vtkActor2D()
1398            self.middle_mouse_lock_actor.SetMapper(textMapper)
1399            self.middle_mouse_lock_actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
1400            self.middle_mouse_lock_actor.GetPositionCoordinate().SetValue(0.5, 0.98)
1401
1402            self.GetCurrentRenderer().AddActor(self.middle_mouse_lock_actor)
1403
1404        self.middle_mouse_lock_actor.SetVisibility(self.middle_mouse_lock)
1405        self.GetInteractor().Render()