"""Test render window interactor""" from __future__ import annotations import re import time from typing import TYPE_CHECKING import pytest import pyvista as pv from pyvista import _vtk from pyvista.core.errors import PyVistaDeprecationWarning from pyvista.plotting.render_window_interactor import InteractorStyleImage from pyvista.plotting.render_window_interactor import InteractorStyleJoystickActor from pyvista.plotting.render_window_interactor import InteractorStyleJoystickCamera from pyvista.plotting.render_window_interactor import InteractorStyleRubberBand2D from pyvista.plotting.render_window_interactor import InteractorStyleRubberBandPick from pyvista.plotting.render_window_interactor import InteractorStyleTerrain from pyvista.plotting.render_window_interactor import InteractorStyleTrackballActor from pyvista.plotting.render_window_interactor import InteractorStyleTrackballCamera from pyvista.plotting.render_window_interactor import InteractorStyleZoom from tests.plotting.test_plotting import skip_windows_mesa if TYPE_CHECKING: from pytest_mock import MockerFixture def empty_callback(): return @pytest.mark.parametrize('callback', ['foo', 1, object()]) def test_track_click_position_raises(callback): pl = pv.Plotter() match = re.escape( 'Invalid callback provided, it should be either ``None`` or a callable.', ) with pytest.raises(TypeError, match=match): pl.track_click_position(callback=callback) def test_simulate_key_press_raises(): pl = pv.Plotter() with pytest.raises( ValueError, match=re.escape('Only accepts a single key'), ): pl.iren._simulate_keypress(key=['f', 't']) def test_process_events_raises(mocker: MockerFixture): pl = pv.Plotter() m = mocker.patch.object(pl.iren, 'interactor') m.GetInitialized.return_value = False with pytest.raises( RuntimeError, match='Render window interactor must be initialized before processing events.', ): pl.iren.process_events() @pytest.mark.parametrize('picker', ['foo', 1000]) def test_picker_raises(picker, mocker: MockerFixture): pl = pv.Plotter() # patching need to occur after init from pyvista.plotting import render_window_interactor m = mocker.patch.object(render_window_interactor.PickerType, 'from_any') m.return_value = (v := len(list(render_window_interactor.PickerType))) with pytest.raises(KeyError, match=re.escape(f'Picker class `{v}` is unknown.')): pl.iren.picker = picker m.assert_called_once_with(picker) @pytest.mark.needs_vtk_version(9, 1) def test_observers(): pl = pv.Plotter() # Key events with pytest.raises(TypeError): pl.add_key_event('w', 1) # Callback must not have any empty arguments. def callback(a, b, *, c, d=1.0): pass with pytest.raises(TypeError): pl.add_key_event('w', callback) key = 'w' pl.add_key_event(key, empty_callback) assert key in pl.iren._key_press_event_callbacks pl.clear_events_for_key(key) assert key not in pl.iren._key_press_event_callbacks # attempting to clear non-existing events doesn't raise by default pl.clear_events_for_key(key) with pytest.raises(ValueError, match='No events found for key'): pl.clear_events_for_key(key, raise_on_missing=True) # Custom events assert not pl.iren.interactor.HasObserver( 'PickEvent', ), 'Subsequent PickEvent HasObserver tests are wrong if this fails.' # Add different observers obs_move = pl.iren.add_observer(_vtk.vtkCommand.MouseMoveEvent, empty_callback) obs_double1 = pl.iren.add_observer(_vtk.vtkCommand.LeftButtonDoubleClickEvent, empty_callback) obs_double2 = pl.iren.add_observer('LeftButtonDoubleClickEvent', empty_callback) obs_picks = tuple(pl.iren.add_observer('PickEvent', empty_callback) for _ in range(5)) pl.iren.add_observer('SelectionChangedEvent', empty_callback) assert pl.iren._observers[obs_move] == 'MouseMoveEvent' assert pl.iren.interactor.HasObserver('MouseMoveEvent') assert pl.iren._observers[obs_double1] == 'LeftButtonDoubleClickEvent' assert pl.iren._observers[obs_double2] == 'LeftButtonDoubleClickEvent' assert pl.iren.interactor.HasObserver('LeftButtonDoubleClickEvent') assert all(pl.iren._observers[obs_pick] == 'PickEvent' for obs_pick in obs_picks) assert pl.iren.interactor.HasObserver('SelectionChangedEvent') # Remove a specific observer pl.iren.remove_observer(obs_move) assert obs_move not in pl.iren._observers # Remove all observers of a specific event pl.iren.remove_observers(_vtk.vtkCommand.LeftButtonDoubleClickEvent) assert obs_double1 not in pl.iren._observers assert obs_double2 not in pl.iren._observers # Remove all (remaining) observers pl.iren.remove_observers() assert len(pl.iren._observers) == 0 assert not pl.iren.interactor.HasObserver('PickEvent') def test_clear_key_event_callbacks(): pl = pv.Plotter() pl.reset_key_events() @pytest.mark.skip_plotting def test_track_mouse_position(): pl = pv.Plotter() pl.track_mouse_position() pl.show(auto_close=False) assert pl.mouse_position is None x, y = 10, 20 pl.iren._mouse_move(x, y) assert pl.mouse_position == (x, y) pl.iren.untrack_mouse_position() assert 'MouseMoveEvent' not in pl.iren._observers.values() @pytest.mark.skip_plotting def test_track_click_position_multi_render(): points = [] def callback(mouse_point): points.append(mouse_point) pl = pv.Plotter() with pytest.raises(TypeError): pl.track_click_position(side='dark') pl.track_click_position(callback=callback, side='left', viewport=True) pl.show(auto_close=False) x, y = 10, 20 pl.iren._mouse_right_button_click(2 * x, 2 * y) pl.iren._mouse_left_button_click(x, y) assert points[0] == (x, y) # disable and ensure that clicking is no longer being tracked pl.untrack_click_position(side='left') pl.iren._mouse_left_button_click(50, 50) assert len(points) == 1 @pytest.mark.skip_plotting def test_track_click_position(): events = [] def single_click_callback(mouse_position): # noqa: ARG001 events.append('single') def double_click_callback(mouse_position): # noqa: ARG001 events.append('double') pl = pv.Plotter() pl.track_click_position(callback=single_click_callback, side='left', double=False) pl.track_click_position(callback=double_click_callback, side='left', double=True) pl.show(auto_close=False) # Test single and double clicks: pl.iren._mouse_left_button_click(10, 10) assert len(events) == 1 assert events.pop(0) == 'single' pl.iren._mouse_left_button_click(50, 50, count=2) assert len(events) == 2 assert events.pop(1) == 'double' assert events.pop(0) == 'single' # Test triple click behaviour: pl.iren._mouse_left_button_click(10, 10, count=3) assert len(events) == 3 assert events.pop(2) == 'single' assert events.pop(1) == 'double' assert events.pop(0) == 'single' @skip_windows_mesa @pytest.mark.skipif( type(_vtk.vtkRenderWindowInteractor()).__name__ not in ('vtkWin32RenderWindowInteractor', 'vtkXRenderWindowInteractor'), reason='Other RenderWindowInteractors do not invoke TimerEvents during ProcessEvents.', ) @pytest.mark.needs_vtk_version( (9, 2), reason='vtkXRenderWindowInteractor (Linux) does not invoke TimerEvents during ProcessEvents ' 'until VTK9.2.', ) def test_timer(): # Create a normal interactor from the offscreen plotter (not generic, # which is the default for offscreen rendering) pl = pv.Plotter() iren = pv.plotting.render_window_interactor.RenderWindowInteractor(pl) iren.set_render_window(pl.render_window) duration = 50 # Duration of created timers delay = 5 * duration # Extra time we wait for the timers to fire at least once events = [] def on_timer(obj, event): # noqa: ARG001 # TimerEvent callback events.append(event) def process_events(iren, duration): # Helper function to call process_events for the given duration (in milliseconds). t = 1000 * time.time() while 1000 * time.time() - t < duration: iren.process_events() # Setup interactor iren.add_observer('TimerEvent', on_timer) iren.initialize() # Test one-shot timer (only fired once for the extended duration) iren.create_timer(duration, repeating=False) process_events(iren, delay) assert len(events) == 1 # Test repeating timer (fired multiple times for extended duration) repeating_timer = iren.create_timer(duration, repeating=True) process_events(iren, 2 * delay) assert len(events) >= 3 E = len(events) # Test timer destruction (no more events fired) iren.destroy_timer(repeating_timer) process_events(iren, delay) assert len(events) == E def test_add_timer_event(): sphere = pv.Sphere() pl = pv.Plotter() actor = pl.add_mesh(sphere) def callback(step): actor.position = [step / 100.0, step / 100.0, 0] pl.add_timer_event(max_steps=200, duration=500, callback=callback) cpos = [(0.0, 0.0, 10.0), (0.0, 0.0, 0.0), (0.0, 1.0, 0.0)] pl.show(cpos=cpos) @pytest.mark.skip_plotting def test_poked_subplot_loc(): pl = pv.Plotter(shape=(2, 2), window_size=(800, 800)) pl.iren._mouse_left_button_press(200, 600) assert tuple(pl.iren.get_event_subplot_loc()) == (0, 0) pl.iren._mouse_left_button_press(200, 200) assert tuple(pl.iren.get_event_subplot_loc()) == (1, 0) pl.iren._mouse_left_button_press(600, 600) assert tuple(pl.iren.get_event_subplot_loc()) == (0, 1) pl.iren._mouse_left_button_press(600, 200) assert tuple(pl.iren.get_event_subplot_loc()) == (1, 1) pl.close() @pytest.mark.skip_plotting @pytest.mark.usefixtures('verify_image_cache') def test_poked_subplot_context(): pl = pv.Plotter(shape=(2, 2), window_size=(800, 800)) pl.iren._mouse_left_button_press(200, 600) with pl.iren.poked_subplot(): pl.add_mesh(pv.Cone(), color=True) pl.iren._mouse_left_button_press(200, 200) with pl.iren.poked_subplot(): pl.add_mesh(pv.Cube(), color=True) pl.iren._mouse_left_button_press(600, 600) with pl.iren.poked_subplot(): pl.add_mesh(pv.Sphere(), color=True) pl.iren._mouse_left_button_press(600, 200) with pl.iren.poked_subplot(): pl.add_mesh(pv.Arrow(), color=True) pl.show() @pytest.mark.skip_plotting def test_add_pick_observer(): pl = pv.Plotter() with pytest.warns(PyVistaDeprecationWarning, match='`add_pick_obeserver` is deprecated'): pl.iren.add_pick_obeserver(empty_callback) pl = pv.Plotter() pl.iren.add_pick_observer(empty_callback) @pytest.mark.needs_vtk_version(9, 1) @pytest.mark.parametrize('event', ['LeftButtonReleaseEvent', 'RightButtonReleaseEvent']) def test_release_button_observers(event): class CallBack: def __init__(self): self._i = 0 def __call__(self, *_): self._i += 1 cb = CallBack() pl = pv.Plotter() pl.iren.add_observer(event, cb) pl.iren.interactor.GetInteractorStyle().InvokeEvent(event) assert cb._i == 1 pl.iren.interactor.GetInteractorStyle().InvokeEvent(event) assert cb._i == 2 def test_enable_custom_trackball_style(): pl = pv.Plotter() pl.enable_custom_trackball_style() pl.close() pl = pv.Plotter() with pytest.raises(ValueError, match="Action 'not an option' not in the allowed"): pl.enable_custom_trackball_style(left='not an option') def test_enable_2d_style(): pl = pv.Plotter() pl.enable_2d_style() def test_enable_interactors(): mapping = { 'enable_trackball_style': InteractorStyleTrackballCamera, 'enable_custom_trackball_style': InteractorStyleTrackballCamera, 'enable_2d_style': InteractorStyleTrackballCamera, 'enable_trackball_actor_style': InteractorStyleTrackballActor, 'enable_image_style': InteractorStyleImage, 'enable_joystick_style': InteractorStyleJoystickCamera, 'enable_joystick_actor_style': InteractorStyleJoystickActor, 'enable_zoom_style': InteractorStyleZoom, 'enable_terrain_style': InteractorStyleTerrain, 'enable_rubber_band_style': InteractorStyleRubberBandPick, 'enable_rubber_band_2d_style': InteractorStyleRubberBand2D, } pl = pv.Plotter() # check that all "enable_*_style" methods on plotter are in the mapping and vice versa attrs = dir(pl) attrs_enable_style = { attr for attr in attrs if attr.startswith('enable_') and attr.endswith('_style') } check_set = set(mapping.keys()) assert attrs_enable_style == check_set # do the same for methods on the RenderWindowInteractor attrs = dir(pl.iren) attrs_enable_style = { attr for attr in attrs if attr.startswith('enable_') and attr.endswith('_style') } check_set = set(mapping.keys()) assert attrs_enable_style == check_set # check that the method gives the right class for attr, class_ in mapping.items(): print(attr, class_) getattr(pl, attr)() assert isinstance(pl.iren.style, class_) for attr, class_ in mapping.items(): getattr(pl.iren, attr)() assert isinstance(pl.iren.style, class_) def test_setting_custom_style(): pl = pv.Plotter() pl.iren.style = _vtk.vtkInteractorStyleJoystickActor() assert isinstance(pl.iren.style, _vtk.vtkInteractorStyleJoystickActor)