Zoombutton

nion/swift/DocumentController.py

@@ -3292,6 +3292,7 @@ def execute(self, context: Window.ActionContext) -> Window.ActionResult:
 Window.register_action(SetToolModeAction("wedge", _("Wedge"), "wedge_icon.png", _("Wedge tool for creating wedge masks")))
 Window.register_action(SetToolModeAction("ring", _("Ring"), "annular_ring.png", _("Ring tool for creating ring masks")))
 Window.register_action(SetToolModeAction("lattice", _("Lattice"), "lattice_icon.png", _("Lattice tool for creating periodic lattice masks")))
+Window.register_action(SetToolModeAction("zoom", _("Zoom"), "zoom.png", _("Zoom in/out on image")))
 
 
 class WorkspaceChangeSplits(Window.Action):

nion/swift/ImageCanvasItem.py

@@ -639,6 +639,43 @@ async def _reactor_loop(self, r: Stream.ValueChangeStreamReactorInterface[MouseP
                 change_display_properties_task.commit()
 
 
+class ZoomMouseHandler(MouseHandler):
+    def __init__(self, image_canvas_item: ImageCanvasItem, event_loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__(image_canvas_item, event_loop)
+
+    async def _reactor_loop(self, r: Stream.ValueChangeStreamReactorInterface[MousePositionAndModifiers],
+                            image_canvas_item: ImageCanvasItem) -> None:
+        delegate = image_canvas_item.delegate
+        assert delegate
+
+        # get the beginning mouse position
+        value_change = await r.next_value_change()
+        value_change_value = value_change.value
+        assert value_change.is_begin
+        assert value_change_value is not None
+        image_position: typing.Optional[Geometry.FloatPoint] = None
+        mouse_pos, modifiers = value_change_value
+
+        if modifiers.control:
+            is_zooming_in = False
+        else:
+            is_zooming_in = True
+
+        with (delegate.create_change_display_properties_task() as change_display_properties_task):
+            # mouse tracking loop. wait for values and update the image position.
+            while True:
+                value_change = await r.next_value_change()
+                if value_change.is_end:
+                    if value_change.value is not None:
+                        mouse_pos, modifiers = value_change.value
+                        image_canvas_item.apply_fixed_zoom(is_zooming_in, mouse_pos)
+                    break
+
+            # if the image position was set, it means the user moved the image. perform the task.
+            if image_position:
+                change_display_properties_task.commit()
+
+
 class CreateGraphicMouseHandler(MouseHandler):
     def __init__(self, image_canvas_item: ImageCanvasItem, event_loop: asyncio.AbstractEventLoop, graphic_type: str) -> None:
         super().__init__(image_canvas_item, event_loop)
@@ -1073,15 +1110,66 @@ def _update_image_canvas_position(self, widget_delta: Geometry.FloatSize) -> Geo
             self._set_image_canvas_position(new_image_canvas_position)
         return new_image_canvas_position
 
+    def convert_pixel_to_normalised(self, coord: Geometry.IntPoint) -> Geometry.FloatPoint:
+        if coord:
+            widget_mapping = ImageCanvasItemMapping.make(self.__data_shape, self.__composite_canvas_item.canvas_bounds,
+                                                         list())
+            if widget_mapping:
+                mapped = self.map_widget_to_image(coord)
+                if (mapped is not None) and (self.__data_shape is not None):
+                    norm_coord = tuple(ele1 / ele2 for ele1, ele2 in zip(iter(mapped), iter(self.__data_shape)))
+                    return Geometry.FloatPoint(norm_coord[0], norm_coord[1])  # y,x
+        return Geometry.FloatPoint(-1, -1)
+
+    # Apply a zoom factor to the widget, optionally focussed on a specific point
+    def apply_fixed_zoom(self, zoom_in: bool, coord: typing.Optional[Geometry.IntPoint]) -> None:
+        zoom_factor = 0.25
+        if coord:
+            # Coordinate specified, so needing to recenter to that point before we adjust zoom levels
+            widget_mapping = ImageCanvasItemMapping.make(self.__data_shape, self.__composite_canvas_item.canvas_bounds, list())
+            if widget_mapping:
+                # coord is (x,y)
+                mapped = self.map_widget_to_image(coord)  # mapped is (y,x)
+                if mapped is not None and self.__data_shape is not None and self.scroll_area_canvas_item.canvas_size is not None:
+                    mapped_center = self.map_widget_to_image(Geometry.IntPoint(self.scroll_area_canvas_item.canvas_size.height // 2, self.scroll_area_canvas_item.canvas_size.width // 2))
+                    if mapped_center is not None:
+                        mapped_vector = (mapped_center[0] - mapped[0], mapped_center[1] - mapped[1])
+                        if zoom_in:
+                            vector_scaling = zoom_factor / (1 + zoom_factor)
+                        else:
+                            vector_scaling = zoom_factor
+
+                        scaled_mapped_vector = (mapped_vector[0] * vector_scaling, mapped_vector[1] * vector_scaling)
+                        if zoom_in:
+                            new_mapped_center = (mapped_center[0] - scaled_mapped_vector[0], mapped_center[1] - scaled_mapped_vector[1])
+                        else:
+                            new_mapped_center = (mapped_center[0] + scaled_mapped_vector[0], mapped_center[1] + scaled_mapped_vector[1])
+
+                        norm_coord = tuple(ele1 / ele2 for ele1, ele2 in zip(iter(new_mapped_center), iter(self.__data_shape)))
+                        self._set_image_canvas_position(Geometry.FloatPoint(norm_coord[0], norm_coord[1]))
+
+                        # ensure that at least half of the image is always visible
+                        new_image_norm_center_0 = max(min(norm_coord[0], 1.0), 0.0)
+                        new_image_norm_center_1 = max(min(norm_coord[1], 1.0), 0.0)
+                        # save the new image norm center
+                        new_image_canvas_position = Geometry.FloatPoint(new_image_norm_center_0, new_image_norm_center_1)
+                        self._set_image_canvas_position(new_image_canvas_position)
+        if zoom_in:
+            self.zoom_in(1 + zoom_factor)
+        else:
+            self.zoom_out(1 + zoom_factor)
+
     def mouse_clicked(self, x: int, y: int, modifiers: UserInterface.KeyboardModifiers) -> bool:
         if super().mouse_clicked(x, y, modifiers):
             return True
         delegate = self.delegate
         widget_mapping = self.mouse_mapping
+
         if delegate and widget_mapping:
             # now let the image panel handle mouse clicking if desired
             image_position = widget_mapping.map_point_widget_to_image(Geometry.FloatPoint(y, x))
             return delegate.image_clicked(image_position, modifiers)
+
         return False
 
     def mouse_pressed(self, x: int, y: int, modifiers: UserInterface.KeyboardModifiers) -> bool:
@@ -1105,6 +1193,11 @@ def mouse_pressed(self, x: int, y: int, modifiers: UserInterface.KeyboardModifie
             assert self.__event_loop
             self.__mouse_handler = HandMouseHandler(self, self.__event_loop)
             self.__mouse_handler.mouse_pressed(Geometry.IntPoint(y=y, x=x), modifiers)
+        elif delegate.tool_mode == "zoom":
+            assert not self.__mouse_handler
+            assert self.__event_loop
+            self.__mouse_handler = ZoomMouseHandler(self, self.__event_loop)
+            self.__mouse_handler.mouse_pressed(Geometry.IntPoint(y=y, x=x), modifiers)
         elif delegate.tool_mode in graphic_type_map.keys():
             assert not self.__mouse_handler
             assert self.__event_loop
@@ -1115,6 +1208,7 @@ def mouse_pressed(self, x: int, y: int, modifiers: UserInterface.KeyboardModifie
     def mouse_released(self, x: int, y: int, modifiers: UserInterface.KeyboardModifiers) -> bool:
         if super().mouse_released(x, y, modifiers):
             return True
+
         delegate = self.delegate
         widget_mapping = self.mouse_mapping
         if not delegate or not widget_mapping:
@@ -1127,7 +1221,13 @@ def mouse_released(self, x: int, y: int, modifiers: UserInterface.KeyboardModifi
         if self.__mouse_handler:
             self.__mouse_handler.mouse_released(Geometry.IntPoint(y, x), modifiers)
             self.__mouse_handler = None
-        if delegate.tool_mode != "hand":
+
+        # Should probably wrap this into a function of 'Non-Toggle' UI elements
+        if delegate.tool_mode == "hand":
+            pass
+        elif delegate.tool_mode == "zoom":
+            pass
+        else:
             delegate.tool_mode = "pointer"
         return True
 
@@ -1157,6 +1257,7 @@ def mouse_position_changed(self, x: int, y: int, modifiers: UserInterface.Keyboa
         image_position = widget_mapping.map_point_widget_to_image(mouse_pos)
         if delegate.image_mouse_position_changed(image_position, modifiers):
             return True
+
         if delegate.tool_mode == "pointer":
             self.cursor_shape = self.__mouse_handler.cursor_shape if self.__mouse_handler else "arrow"
         elif delegate.tool_mode == "line":
@@ -1177,6 +1278,9 @@ def mouse_position_changed(self, x: int, y: int, modifiers: UserInterface.Keyboa
             self.cursor_shape = "cross"
         elif delegate.tool_mode == "hand":
             self.cursor_shape = "hand"
+        elif delegate.tool_mode == "zoom":
+            self.cursor_shape = "cross"
+
         # x,y already have transform applied
         self.__last_mouse = mouse_pos.to_int_point()
         self.__update_cursor_info()
@@ -1347,11 +1451,13 @@ def set_one_to_one_mode(self) -> None:
     def set_two_to_one_mode(self) -> None:
         self.__apply_display_properties_command({"image_zoom": 0.5, "image_position": (0.5, 0.5), "image_canvas_mode": "2:1"})
 
-    def zoom_in(self) -> None:
-        self.__apply_display_properties_command({"image_zoom": self.__image_zoom * 1.25, "image_canvas_mode": "custom"})
+    def zoom_in(self, factor: float) -> None:
+        self.__apply_display_properties_command({"image_zoom": self.__image_zoom * factor,
+                                                 "image_canvas_mode": "custom"})
 
-    def zoom_out(self) -> None:
-        self.__apply_display_properties_command({"image_zoom": self.__image_zoom / 1.25, "image_canvas_mode": "custom"})
+    def zoom_out(self, factor: float) -> None:
+        self.__apply_display_properties_command({"image_zoom": self.__image_zoom / factor,
+                                                 "image_canvas_mode": "custom"})
 
     def move_left(self, amount: float = 10.0) -> None:
         self.apply_move_command(Geometry.FloatSize(0.0, amount))

nion/swift/test/ImageCanvasItem_test.py

@@ -15,6 +15,7 @@
 from nion.swift.test import TestContext
 from nion.ui import DrawingContext
 from nion.ui import TestUI
+from nion.ui.UserInterface import KeyboardModifiers
 
 
 class TestImageCanvasItemClass(unittest.TestCase):
@@ -291,6 +292,27 @@ def test_hand_tool_on_one_image_of_multiple_displays(self):
             document_controller.tool_mode = "hand"
             display_panel.display_canvas_item.simulate_press((100,125))
 
+    def test_zoom_tool_in_and_out_around_clicked_point(self):
+        # setup
+        with TestContext.create_memory_context() as test_context:
+            document_controller = test_context.create_document_controller()
+            document_model = document_controller.document_model
+            display_panel = document_controller.selected_display_panel
+            data_item = DataItem.DataItem(numpy.zeros((10, 10)))
+            document_model.append_data_item(data_item)
+            display_item = document_model.get_display_item_for_data_item(data_item)
+            copy_display_item = document_model.get_display_item_copy_new(display_item)
+            display_panel.set_display_panel_display_item(copy_display_item)
+            header_height = display_panel.header_canvas_item.header_height
+            display_panel.root_container.layout_immediate((1000 + header_height, 1000))
+            # run test
+            document_controller.tool_mode = "zoom"
+            display_panel.display_canvas_item.simulate_press((100, 125))
+            display_panel.display_canvas_item.simulate_release((100, 125))
+
+            document_controller.tool_mode = "zoom"
+            display_panel.display_canvas_item.simulate_press((125, 100), KeyboardModifiers.control)
+            display_panel.display_canvas_item.simulate_release((125, 100), KeyboardModifiers.control)
 
 if __name__ == '__main__':
     logging.getLogger().setLevel(logging.DEBUG)