shinestacker 0.4.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

shinestacker/retouch/image_editor_ui.py

@@ -1,42 +1,50 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904
+import numpy as np
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel,
-                               QListWidget, QSlider)
+                               QListWidget, QSlider, QMainWindow, QMessageBox)
 from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QGuiApplication
+from .. config.constants import constants
 from .. config.gui_constants import gui_constants
-from .image_filters import ImageFilters
 from .image_viewer import ImageViewer
 from .shortcuts_help import ShortcutsHelp
 from .brush import Brush
-
-
-def brush_size_to_slider(size):
-    if size <= gui_constants.BRUSH_SIZES['min']:
-        return 0
-    if size >= gui_constants.BRUSH_SIZES['max']:
-        return gui_constants.BRUSH_SIZE_SLIDER_MAX
-    normalized = ((size - gui_constants.BRUSH_SIZES['min']) /
-                  gui_constants.BRUSH_SIZES['max']) ** (1 / gui_constants.BRUSH_GAMMA)
-    return int(normalized * gui_constants.BRUSH_SIZE_SLIDER_MAX)
-
-
-class ImageEditorUI(ImageFilters):
+from .brush_tool import BrushTool
+from .layer_collection import LayerCollectionHandler
+from .undo_manager import UndoManager
+from .layer_collection import LayerCollection
+from .io_gui_handler import IOGuiHandler
+from .display_manager import DisplayManager
+from .filter_manager import FilterManager
+from .denoise_filter import DenoiseFilter
+from .unsharp_mask_filter import UnsharpMaskFilter
+from .white_balance_filter import WhiteBalanceFilter
+from .vignetting_filter import VignettingFilter
+
+
+class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def __init__(self):
-        super().__init__()
+        QMainWindow.__init__(self)
+        LayerCollectionHandler.__init__(self, LayerCollection())
+        self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
+        self.undo_manager = UndoManager()
+        self.undo_action = None
+        self.redo_action = None
+        self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
+        self.io_gui_handler = None
+        self.display_manager = None
         self.brush = Brush()
-        self.setup_ui()
-        self.setup_menu()
-        self.setup_shortcuts()
-        self._dialog = None
-
-    def setup_shortcuts(self):
-        prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
-        prev_layer.activated.connect(self.prev_layer)
-        next_layer = QShortcut(QKeySequence(Qt.Key_Down), self, context=Qt.ApplicationShortcut)
-        next_layer.activated.connect(self.next_layer)
+        self.brush_tool = BrushTool()
+        self.modified = False
+        self.mask_layer = None
+        self.filter_manager = FilterManager(self)
+        self.filter_manager.register_filter("Denoise", DenoiseFilter)
+        self.filter_manager.register_filter("Unsharp Mask", UnsharpMaskFilter)
+        self.filter_manager.register_filter("White Balance", WhiteBalanceFilter)
+        self.filter_manager.register_filter("Vignetting Correction", VignettingFilter)
+        self.shortcuts_help_dialog = None
 
-    def setup_ui(self):
         self.update_title()
         self.resize(1400, 900)
         center = QGuiApplication.primaryScreen().geometry().center()
@@ -69,6 +77,16 @@ class ImageEditorUI(ImageFilters):
 
         self.brush_size_slider = QSlider(Qt.Horizontal)
         self.brush_size_slider.setRange(0, gui_constants.BRUSH_SIZE_SLIDER_MAX)
+
+        def brush_size_to_slider(size):
+            if size <= gui_constants.BRUSH_SIZES['min']:
+                return 0
+            if size >= gui_constants.BRUSH_SIZES['max']:
+                return gui_constants.BRUSH_SIZE_SLIDER_MAX
+            normalized = ((size - gui_constants.BRUSH_SIZES['min']) /
+                          gui_constants.BRUSH_SIZES['max']) ** (1 / gui_constants.BRUSH_GAMMA)
+            return int(normalized * gui_constants.BRUSH_SIZE_SLIDER_MAX)
+
         self.brush_size_slider.setValue(brush_size_to_slider(self.brush.size))
         brush_layout.addWidget(self.brush_size_slider)
 
@@ -125,18 +143,28 @@ class ImageEditorUI(ImageFilters):
             }
         """)
         master_label.setAlignment(Qt.AlignCenter)
-        master_label.setFixedHeight(gui_constants.LABEL_HEIGHT)
+        master_label.setFixedHeight(gui_constants.UI_SIZES['label_height'])
         side_layout.addWidget(master_label)
         self.master_thumbnail_frame = QFrame()
+        self.master_thumbnail_frame.setObjectName("thumbnailContainer")
+        self.master_thumbnail_frame.setStyleSheet(
+            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
         self.master_thumbnail_frame.setFrameShape(QFrame.StyledPanel)
         master_thumbnail_layout = QVBoxLayout(self.master_thumbnail_frame)
-        master_thumbnail_layout.setContentsMargins(2, 2, 2, 2)
+        master_thumbnail_layout.setContentsMargins(8, 8, 8, 8)
         self.master_thumbnail_label = QLabel()
         self.master_thumbnail_label.setAlignment(Qt.AlignCenter)
-        self.master_thumbnail_label.setFixedSize(
-            gui_constants.THUMB_WIDTH, gui_constants.THUMB_HEIGHT)
+        self.master_thumbnail_label.setFixedWidth(
+            gui_constants.UI_SIZES['thumbnail_width'])
         self.master_thumbnail_label.mousePressEvent = \
             lambda e: self.display_manager.set_view_master()
+        self.master_thumbnail_label.setMouseTracking(True)
+
+        def label_clicked(event):
+            if event.button() == Qt.LeftButton:
+                self.toggle_view_master_individual()
+
+        self.master_thumbnail_label.mousePressEvent = label_clicked
         master_thumbnail_layout.addWidget(self.master_thumbnail_label)
         side_layout.addWidget(self.master_thumbnail_frame)
         side_layout.addSpacing(10)
@@ -152,7 +180,7 @@ class ImageEditorUI(ImageFilters):
             }
         """)
         layers_label.setAlignment(Qt.AlignCenter)
-        layers_label.setFixedHeight(gui_constants.LABEL_HEIGHT)
+        layers_label.setFixedHeight(gui_constants.UI_SIZES['label_height'])
         side_layout.addWidget(layers_label)
         self.thumbnail_list = QListWidget()
         self.thumbnail_list.setFocusPolicy(Qt.StrongFocus)
@@ -202,20 +230,44 @@ class ImageEditorUI(ImageFilters):
         layout.addWidget(control_panel, 0)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(2)
-        super().setup_ui()
+        self.display_manager = DisplayManager(
+            self.layer_collection, self.image_viewer,
+            self.master_thumbnail_label, self.thumbnail_list, parent=self)
+        self.io_gui_handler = IOGuiHandler(self.layer_collection, self.undo_manager, parent=self)
+        self.display_manager.status_message_requested.connect(self.show_status_message)
+        self.display_manager.cursor_preview_state_changed.connect(
+            lambda state: setattr(self.image_viewer, 'allow_cursor_preview', state))
+        self.io_gui_handler.status_message_requested.connect(self.show_status_message)
+        self.io_gui_handler.update_title_requested.connect(self.update_title)
+        self.io_gui_handler.mark_as_modified_requested.connect(self.mark_as_modified)
+        self.io_gui_handler.change_layer_requested.connect(self.change_layer)
+        self.brush_tool.setup_ui(self.brush, self.brush_preview, self.image_viewer,
+                                 self.brush_size_slider, self.hardness_slider, self.opacity_slider,
+                                 self.flow_slider)
+        self.image_viewer.brush = self.brush_tool.brush
+        self.brush_tool.update_brush_thumb()
+        self.io_gui_handler.setup_ui(self.display_manager, self.image_viewer)
+        self.image_viewer.display_manager = self.display_manager
 
-    def setup_menu(self):
         menubar = self.menuBar()
         file_menu = menubar.addMenu("&File")
         file_menu.addAction("&Open...", self.io_gui_handler.open_file, "Ctrl+O")
-        file_menu.addAction("&Save", self.io_gui_handler.save_file, "Ctrl+S")
-        file_menu.addAction("Save &As...", self.io_gui_handler.save_file_as, "Ctrl+Shift+S")
-        self.save_master_only = QAction("Save Master &Only", self)
-        self.save_master_only.setCheckable(True)
-        self.save_master_only.setChecked(True)
-        file_menu.addAction(self.save_master_only)
-
-        file_menu.addAction("&Close", self.io_gui_handler.close_file, "Ctrl+W")
+        self.save_action = QAction("&Save", self)
+        self.save_action.setShortcut("Ctrl+S")
+        self.save_action.triggered.connect(self.io_gui_handler.save_file)
+        file_menu.addAction(self.save_action)
+        self.save_as_action = QAction("Save &As...", self)
+        self.save_as_action.setShortcut("Ctrl+Shift+S")
+        self.save_as_action.triggered.connect(self.io_gui_handler.save_file_as)
+        file_menu.addAction(self.save_as_action)
+        self.io_gui_handler.save_master_only = QAction("Save Master &Only", self)
+        self.io_gui_handler.save_master_only.setCheckable(True)
+        self.io_gui_handler.save_master_only.setChecked(True)
+        self.io_gui_handler.save_master_only.triggered.connect(self.save_master_only)
+        file_menu.addAction(self.io_gui_handler.save_master_only)
+        self.save_actions_set_enabled(False)
+
+        file_menu.addAction("&Close", self.close_file, "Ctrl+W")
         file_menu.addSeparator()
         file_menu.addAction("&Import frames", self.io_gui_handler.import_frames)
         file_menu.addAction("Import &EXIF data", self.io_gui_handler.select_exif_path)
@@ -271,15 +323,21 @@ class ImageEditorUI(ImageFilters):
 
         view_master_action = QAction("View Master", self)
         view_master_action.setShortcut("M")
-        view_master_action.triggered.connect(self.display_manager.set_view_master)
+        view_master_action.triggered.connect(self.set_view_master)
         view_menu.addAction(view_master_action)
 
         view_individual_action = QAction("View Individual", self)
         view_individual_action.setShortcut("L")
-        view_individual_action.triggered.connect(self.display_manager.set_view_individual)
+        view_individual_action.triggered.connect(self.set_view_individual)
         view_menu.addAction(view_individual_action)
         view_menu.addSeparator()
 
+        toggle_view_master_individual_action = QAction("View Individual", self)
+        toggle_view_master_individual_action.setShortcut("T")
+        toggle_view_master_individual_action.triggered.connect(self.toggle_view_master_individual)
+        view_menu.addAction(toggle_view_master_individual_action)
+        view_menu.addSeparator()
+
         sort_asc_action = QAction("Sort Layers A-Z", self)
         sort_asc_action.triggered.connect(lambda: self.sort_layers('asc'))
         view_menu.addAction(sort_asc_action)
@@ -327,16 +385,270 @@ class ImageEditorUI(ImageFilters):
         white_balance_action = QAction("White Balance", self)
         white_balance_action.triggered.connect(self.white_balance)
         filter_menu.addAction(white_balance_action)
+        vignetting_action = QAction("Vignetting correction", self)
+        vignetting_action.triggered.connect(self.vignetting_correction)
+        filter_menu.addAction(vignetting_action)
 
         help_menu = menubar.addMenu("&Help")
         help_menu.setObjectName("Help")
         shortcuts_help_action = QAction("Shortcuts and mouse", self)
-        shortcuts_help_action.triggered.connect(self.shortcuts_help)
+
+        def shortcuts_help():
+            self.shortcuts_help_dialog = ShortcutsHelp(self)
+            self.shortcuts_help_dialog.exec()
+
+        shortcuts_help_action.triggered.connect(shortcuts_help)
         help_menu.addAction(shortcuts_help_action)
 
-    def shortcuts_help(self):
-        self._dialog = ShortcutsHelp(self)
-        self._dialog.exec()
+        prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
+        prev_layer.activated.connect(self.prev_layer)
+        next_layer = QShortcut(QKeySequence(Qt.Key_Down), self, context=Qt.ApplicationShortcut)
+        next_layer.activated.connect(self.next_layer)
+        self.installEventFilter(self)
+
+    def update_title(self):
+        title = constants.APP_TITLE
+        if self.io_gui_handler is not None:
+            path = self.io_gui_handler.current_file_path()
+            if path != '':
+                title += f" - {path.split('/')[-1]}"
+                if self.modified:
+                    title += " *"
+        self.window().setWindowTitle(title)
+
+    def show_status_message(self, message):
+        self.statusBar().showMessage(message)
+
+    def mark_as_modified(self, value=True):
+        self.modified = value
+        self.save_actions_set_enabled(value)
+        self.update_title()
+
+    def check_unsaved_changes(self) -> bool:
+        if self.modified:
+            reply = QMessageBox.question(
+                self, "Unsaved Changes",
+                "The image stack has unsaved changes. Do you want to continue?",
+                QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel
+            )
+            if reply == QMessageBox.Save:
+                self.io_gui_handler.save_file()
+                return True
+            if reply == QMessageBox.Discard:
+                return True
+            return False
+        return True
+
+    # pylint: disable=C0103
+    def keyPressEvent(self, event):
+        if self.image_viewer.empty:
+            return
+        if event.text() == '[':
+            self.brush_tool.decrease_brush_size()
+            return
+        if event.text() == ']':
+            self.brush_tool.increase_brush_size()
+            return
+        if event.text() == '{':
+            self.brush_tool.decrease_brush_hardness()
+            return
+        if event.text() == '}':
+            self.brush_tool.increase_brush_hardness()
+            return
+        super().keyPressEvent(event)
+    # pylint: enable=C0103
+
+    def save_master_only(self, _checked):
+        self.update_title()
+
+    def sort_layers(self, order):
+        self.sort_layers(order)
+        self.display_manager.update_thumbnails()
+        self.change_layer(self.current_layer())
+
+    def change_layer(self, layer_idx):
+        if 0 <= layer_idx < self.number_of_layers():
+            view_state = self.image_viewer.get_view_state()
+            self.set_current_layer_idx(layer_idx)
+            self.display_manager.display_current_view()
+            self.image_viewer.set_view_state(view_state)
+            self.thumbnail_list.setCurrentRow(layer_idx)
+            self.thumbnail_list.setFocus()
+            self.image_viewer.update_brush_cursor()
+            self.image_viewer.setFocus()
+
+    def prev_layer(self):
+        if self.layer_stack() is not None:
+            new_idx = max(0, self.current_layer_idx() - 1)
+            if new_idx != self.current_layer_idx():
+                self.change_layer(new_idx)
+                self.display_manager.highlight_thumbnail(new_idx)
+
+    def next_layer(self):
+        if self.layer_stack() is not None:
+            new_idx = min(self.number_of_layers() - 1, self.current_layer_idx() + 1)
+            if new_idx != self.current_layer_idx():
+                self.change_layer(new_idx)
+                self.display_manager.highlight_thumbnail(new_idx)
+
+    def copy_layer_to_master(self):
+        if self.layer_stack() is None or self.master_layer() is None:
+            return
+        reply = QMessageBox.question(
+            self,
+            "Confirm Copy",
+            "Warning: the current master layer will be erased.\n\nDo you want to continue?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No
+        )
+        if reply == QMessageBox.Yes:
+            self.set_master_layer(self.current_layer().copy())
+            self.master_layer().setflags(write=True)
+            self.display_manager.display_current_view()
+            self.display_manager.update_thumbnails()
+            self.mark_as_modified()
+            self.statusBar().showMessage(f"Copied layer {self.current_layer_idx() + 1} to master")
+
+    def copy_brush_area_to_master(self, view_pos):
+        if self.layer_stack() is None or self.number_of_layers() == 0 \
+           or not self.display_manager.allow_cursor_preview():
+            return
+        area = self.brush_tool.apply_brush_operation(
+            self.master_layer_copy(),
+            self.current_layer(),
+            self.master_layer(), self.mask_layer,
+            view_pos)
+        self.undo_manager.extend_undo_area(*area)
+
+    def begin_copy_brush_area(self, pos):
+        if self.display_manager.allow_cursor_preview():
+            self.mask_layer = self.io_gui_handler.blank_layer.copy()
+            self.copy_master_layer()
+            self.undo_manager.reset_undo_area()
+            self.copy_brush_area_to_master(pos)
+            self.display_manager.needs_update = True
+            if not self.display_manager.update_timer.isActive():
+                self.display_manager.update_timer.start()
+            self.mark_as_modified()
+
+    def continue_copy_brush_area(self, pos):
+        if self.display_manager.allow_cursor_preview():
+            self.copy_brush_area_to_master(pos)
+            self.display_manager.needs_update = True
+            if not self.display_manager.update_timer.isActive():
+                self.display_manager.update_timer.start()
+            self.mark_as_modified()
+
+    def end_copy_brush_area(self):
+        if self.display_manager.update_timer.isActive():
+            self.display_manager.display_master_layer()
+            self.display_manager.update_master_thumbnail()
+            self.undo_manager.save_undo_state(self.master_layer_copy(), 'Brush Stroke')
+            self.display_manager.update_timer.stop()
+            self.mark_as_modified()
+
+    def update_undo_redo_actions(self, has_undo, undo_desc, has_redo, redo_desc):
+        if self.undo_action:
+            if has_undo:
+                self.undo_action.setText(f"Undo {undo_desc}")
+                self.undo_action.setEnabled(True)
+            else:
+                self.undo_action.setText("Undo")
+                self.undo_action.setEnabled(False)
+        if self.redo_action:
+            if has_redo:
+                self.redo_action.setText(f"Redo {redo_desc}")
+                self.redo_action.setEnabled(True)
+            else:
+                self.redo_action.setText("Redo")
+                self.redo_action.setEnabled(False)
+
+    def denoise_filter(self):
+        self.filter_manager.apply("Denoise")
+
+    def unsharp_mask(self):
+        self.filter_manager.apply("Unsharp Mask")
+
+    def white_balance(self, init_val=None):
+        self.filter_manager.apply("White Balance", init_val=init_val or (128, 128, 128))
+
+    def vignetting_correction(self):
+        self.filter_manager.apply("Vignetting Correction")
+
+    def connect_preview_toggle(self, preview_check, do_preview, restore_original):
+        def on_toggled(checked):
+            if checked:
+                do_preview()
+            else:
+                restore_original()
+        preview_check.toggled.connect(on_toggled)
+
+    def get_pixel_color_at(self, pos, radius=None):
+        item_pos = self.image_viewer.position_on_image(pos)
+        x = int(item_pos.x())
+        y = int(item_pos.y())
+        master_layer = self.master_layer()
+        if (0 <= x < self.master_layer().shape[1]) and \
+           (0 <= y < self.master_layer().shape[0]):
+            if radius is None:
+                radius = int(self.brush.size)
+            if radius > 0:
+                y_indices, x_indices = np.ogrid[-radius:radius + 1, -radius:radius + 1]
+                mask = x_indices**2 + y_indices**2 <= radius**2
+                x0 = max(0, x - radius)
+                x1 = min(master_layer.shape[1], x + radius + 1)
+                y0 = max(0, y - radius)
+                y1 = min(master_layer.shape[0], y + radius + 1)
+                mask = mask[radius - (y - y0): radius + (y1 - y),
+                            radius - (x - x0): radius + (x1 - x)]
+                region = master_layer[y0:y1, x0:x1]
+                if region.size == 0:
+                    pixel = master_layer[y, x]
+                else:
+                    if region.ndim == 3:
+                        pixel = [region[:, :, c][mask].mean() for c in range(region.shape[2])]
+                    else:
+                        pixel = region[mask].mean()
+            else:
+                pixel = self.master_layer()[y, x]
+            if np.isscalar(pixel):
+                pixel = [pixel, pixel, pixel]
+            pixel = [np.float32(x) for x in pixel]
+            if master_layer.dtype == np.uint16:
+                pixel = [x / 256.0 for x in pixel]
+            return tuple(int(v) for v in pixel)
+        return (0, 0, 0)
+
+    def highlight_master_thumbnail(self):
+        self.master_thumbnail_frame.setStyleSheet(
+            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+
+    def save_actions_set_enabled(self, enabled):
+        self.save_action.setEnabled(enabled)
+        self.save_as_action.setEnabled(enabled)
+        self.io_gui_handler.save_master_only.setEnabled(enabled)
+
+    def close_file(self):
+        if self.check_unsaved_changes():
+            self.io_gui_handler.close_file()
+            self.set_master_layer(None)
+            self.mark_as_modified(False)
+
+    def set_view_master(self):
+        self.display_manager.set_view_master()
+        self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
+        self.highlight_master_thumbnail()
+
+    def set_view_individual(self):
+        self.display_manager.set_view_individual()
+        self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
+        self.highlight_master_thumbnail()
+
+    def toggle_view_master_individual(self):
+        if self.display_manager.view_mode == 'master':
+            self.set_view_individual()
+        else:
+            self.set_view_master()
 
     def toggle_fullscreen(self, checked):
         if checked:
@@ -365,8 +677,12 @@ class ImageEditorUI(ImageFilters):
     def handle_temp_view(self, start):
         if start:
             self.display_manager.start_temp_view()
+            self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
+            self.highlight_master_thumbnail()
         else:
             self.display_manager.end_temp_view()
+            self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
+            self.highlight_master_thumbnail()
 
     def handle_brush_size_change(self, delta):
         if delta > 0:

shinestacker/retouch/image_viewer.py

@@ -1,7 +1,8 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0904, R0902, R0914, R0912
 import math
-from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
-from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor, QShortcut, QKeySequence
+from PySide6.QtWidgets import (QGraphicsView, QGraphicsScene, QGraphicsPixmapItem,
+                               QGraphicsEllipseItem)
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor
 from PySide6.QtCore import Qt, QRectF, QTime, QPoint, QPointF, Signal, QEvent
 from .. config.gui_constants import gui_constants
 from .brush_preview import BrushPreviewItem
@@ -64,8 +65,9 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         pixmap = QPixmap.fromImage(qimage)
         self.pixmap_item.setPixmap(pixmap)
         self.setSceneRect(QRectF(pixmap.rect()))
-        img_width = pixmap.width()
-        self.min_scale = gui_constants.MIN_ZOOMED_IMG_WIDTH / img_width
+        img_width, img_height = pixmap.width(), pixmap.height()
+        self.min_scale = min(gui_constants.MIN_ZOOMED_IMG_WIDTH / img_width,
+                             gui_constants.MIN_ZOOMED_IMG_HEIGHT / img_height)
         self.max_scale = gui_constants.MAX_ZOOMED_IMG_PX_SIZE
         if self.zoom_factor == 1.0:
             self.fitInView(self.pixmap_item, Qt.KeepAspectRatio)
@@ -221,7 +223,6 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
                         self.zoom_factor = new_scale
             self.update_brush_cursor()
         else:  # Touchpad event - fallback for systems without gesture recognition
-            # Handle touchpad panning (two-finger scroll)
             if not self.control_pressed:
                 delta = event.pixelDelta() or event.angleDelta() / 8
                 if delta:
@@ -318,6 +319,9 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         self.setCursor(Qt.BlankCursor)
         pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), 1)
         brush = QBrush(QColor(*gui_constants.BRUSH_COLORS['cursor_inner']))
+        for item in self.scene.items():
+            if isinstance(item, QGraphicsEllipseItem):
+                self.scene.removeItem(item)
         self.brush_cursor = self.scene.addEllipse(
             0, 0, self.brush.size, self.brush.size, pen, brush)
         self.brush_cursor.setZValue(1000)
@@ -369,12 +373,6 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
                                       gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor))
         self.brush_cursor.setBrush(QBrush(gradient))
 
-    def setup_shortcuts(self):
-        prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
-        prev_layer.activated.connect(self.prev_layer)
-        next_layer = QShortcut(QKeySequence(Qt.Key_Down), self, context=Qt.ApplicationShortcut)
-        next_layer.activated.connect(self.next_layer)
-
     def zoom_in(self):
         if self.empty:
             return
@@ -398,6 +396,11 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
     def reset_zoom(self):
         if self.empty:
             return
+        self.pinch_start_scale = 1.0
+        self.last_scroll_pos = QPointF()
+        self.gesture_active = False
+        self.pinch_center_view = None
+        self.pinch_center_scene = None
         self.fitInView(self.pixmap_item, Qt.KeepAspectRatio)
         self.zoom_factor = self.get_current_scale()
         self.zoom_factor = max(self.min_scale, min(self.max_scale, self.zoom_factor))
@@ -440,3 +443,23 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         scene_pos = self.mapToScene(pos)
         item_pos = self.pixmap_item.mapFromScene(scene_pos)
         return item_pos
+
+    def get_visible_image_region(self):
+        if self.empty:
+            return None
+        view_rect = self.viewport().rect()
+        scene_rect = self.mapToScene(view_rect).boundingRect()
+        image_rect = self.pixmap_item.mapFromScene(scene_rect).boundingRect()
+        image_rect = image_rect.intersected(self.pixmap_item.boundingRect().toRect())
+        return image_rect
+
+    def get_visible_image_portion(self):
+        if self.has_no_master_layer():
+            return None
+        visible_rect = self.get_visible_image_region()
+        if not visible_rect:
+            return self.master_layer()
+        x, y = int(visible_rect.x()), int(visible_rect.y())
+        w, h = int(visible_rect.width()), int(visible_rect.height())
+        master_img = self.master_layer()
+        return master_img[y:y + h, x:x + w], (x, y, w, h)