Zoombutton

nion/swift/DocumentController.py

@@ -3285,6 +3285,7 @@ def execute(self, context: Window.ActionContext) -> Window.ActionResult:
 
 Window.register_action(SetToolModeAction("pointer", _("Pointer"), "pointer_icon.png", _("Pointer tool for selecting graphics")))
 Window.register_action(SetToolModeAction("hand", _("Hand"), "hand_icon.png", _("Hand tool for dragging images within panel")))
+Window.register_action(SetToolModeAction("zoom", _("Zoom"), "zoom.png", _("Zoom in/out on image")))
 Window.register_action(SetToolModeAction("line", _("Line"), "line_icon.png", _("Line tool for making line regions on images")))
 Window.register_action(SetToolModeAction("ellipse", _("Ellipse"), "ellipse_icon.png", _("Ellipse tool for making ellipse regions on images")))
 Window.register_action(SetToolModeAction("rectangle", _("Rectangle"), "rectangle_icon.png", _("Rectangle tool for making rectangle regions on images")))

nion/swift/ImageCanvasItem.py

@@ -801,6 +801,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.alt:
+            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)
@@ -1232,15 +1269,67 @@ 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(mapped_coord / shape_dim for mapped_coord, shape_dim 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 focused on a specific point
+    def apply_fixed_zoom(self, zoom_in: bool, coord: typing.Optional[Geometry.IntPoint]) -> None:
+        zoom_factor = 0.25
+        self.set_custom_mode() # Put us into custom canvas mode
+        if coord and zoom_in:
+            # 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 (y,x) IntPoint
+                mapped = self.map_widget_to_image(coord)  # mapped is (y,x) IntPoint
+                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(new_mapped_coord / shape_dim for new_mapped_coord, shape_dim 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_y = max(min(norm_coord[0], 1.0), 0.0)
+                        new_image_norm_center_x = 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_y, new_image_norm_center_x)
+                        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:
@@ -1264,6 +1353,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
@@ -1274,6 +1368,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:
@@ -1286,7 +1381,12 @@ 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":
+
+        if delegate.tool_mode == "hand":
+            pass
+        elif delegate.tool_mode == "zoom":
+            pass
+        else:
             delegate.tool_mode = "pointer"
         return True
 
@@ -1336,6 +1436,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()
@@ -1476,11 +1579,44 @@ 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_out(self) -> None:
-        self.__apply_display_properties_command({"image_zoom": self.__image_zoom / 1.25, "image_canvas_mode": "custom"})
+    def set_custom_mode(self) -> None:
+        if self.image_canvas_mode != "custom" and self.canvas_bounds and self.__data_shape:
+            new_zoom = 1.0
+            if self.image_canvas_mode == "fit":
+                # defaults to zoom of 1
+                pass
+            elif self.image_canvas_mode == "fill":
+                # needs to be zoomed in a bit
+                x_zoom = self.canvas_bounds.width / self.__data_shape[1]
+                y_zoom = self.canvas_bounds.height / self.__data_shape[0]
+                new_zoom = max(y_zoom, x_zoom)
+                pass
+            elif self.image_canvas_mode == "1:1":
+                # noticably less than 1.0, zoomed out a bit
+                x_zoom = self.__data_shape[1] / self.canvas_bounds.width
+                y_zoom = self.__data_shape[0] / self.canvas_bounds.height
+                new_zoom = max(y_zoom, x_zoom)
+            elif self.image_canvas_mode == "2:1":
+                # zoomed out a lot
+                x_zoom = self.canvas_bounds.width / self.__data_shape[1]
+                y_zoom = self.canvas_bounds.height / self.__data_shape[0]
+                new_zoom = max(y_zoom, x_zoom)
+                new_zoom /= 2
+
+            self.__apply_display_properties_command({"image_zoom": new_zoom, "image_canvas_mode": "custom"})
+
+
+    def zoom_in(self, factor: typing.Optional[float] = None) -> None:
+        if factor is None:
+            factor = 1.25
+        self.__apply_display_properties_command({"image_zoom": self.__image_zoom * factor,
+                                                 "image_canvas_mode": "custom"})
+
+    def zoom_out(self, factor: typing.Optional[float] = None) -> None:
+        if factor is None:
+            factor = 1.25
+        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/ToolbarPanel.py

@@ -68,6 +68,9 @@ def __init__(self, *, document_controller: DocumentController.DocumentController
             else:
                 bottom_row_items.append(radio_button)
 
+        if len(tool_actions) % 2 == 1:
+            bottom_row_items.append(u.create_spacing(32))
+
         top_row = u.create_row(*top_row_items)
         bottom_row = u.create_row(*bottom_row_items)
 

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)