shinestacker 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

shinestacker/retouch/display_manager.py

@@ -44,26 +44,21 @@ class DisplayManager(QObject, LayerCollectionHandler):
 
     def process_pending_updates(self):
         if self.needs_update:
-            self.display_master_layer()
+            self.refresh_master_view()
             self.needs_update = False
 
-    def display_image(self, img):
-        if img is None:
-            self.image_viewer.clear_image()
-        else:
-            self.image_viewer.set_image(self.numpy_to_qimage(img))
-
-    def display_current_layer(self):
-        self.display_image(self.current_layer())
-
-    def display_master_layer(self):
-        self.display_image(self.master_layer())
+    def refresh_master_view(self):
+        if self.has_no_master_layer():
+            return
+        self.image_viewer.update_master_display()
+        self.update_master_thumbnail()
+        self.image_viewer.refresh_display()
 
-    def display_current_view(self):
-        if self.temp_view_individual or self.view_mode == 'individual':
-            self.display_current_layer()
-        else:
-            self.display_master_layer()
+    def refresh_current_view(self):
+        if self.number_of_layers() == 0:
+            return
+        self.image_viewer.update_current_display()
+        self.image_viewer.refresh_display()
 
     def create_thumbnail(self, layer):
         source_layer = (layer // 256).astype(np.uint8) if layer.dtype == np.uint16 else layer
@@ -167,22 +162,22 @@ class DisplayManager(QObject, LayerCollectionHandler):
             return
         self.view_mode = 'master'
         self.temp_view_individual = False
-        self.display_master_layer()
+        self.refresh_master_view()
         self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
         self.highlight_thumbnail(self.current_layer_idx())
         self.status_message_requested.emit("View mode: Master")
-        self.cursor_preview_state_changed.emit(True)  # True = allow preview
+        self.cursor_preview_state_changed.emit(True)
 
     def set_view_individual(self):
         if self.has_no_master_layer():
             return
         self.view_mode = 'individual'
         self.temp_view_individual = False
-        self.display_current_layer()
+        self.refresh_current_view()
         self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
         self.highlight_thumbnail(self.current_layer_idx())
         self.status_message_requested.emit("View mode: Individual layers")
-        self.cursor_preview_state_changed.emit(False)  # False = no preview
+        self.cursor_preview_state_changed.emit(False)
 
     def start_temp_view(self):
         if not self.temp_view_individual and self.view_mode == 'master':
@@ -190,7 +185,8 @@ class DisplayManager(QObject, LayerCollectionHandler):
             self.image_viewer.update_brush_cursor()
             self.thumbnail_highlight = gui_constants.THUMB_HI_COLOR
             self.highlight_thumbnail(self.current_layer_idx())
-            self.display_current_layer()
+            self.image_viewer.show_current()
+            self.refresh_current_view()
             self.status_message_requested.emit("Temporary view: Individual layer (hold X)")
 
     def end_temp_view(self):
@@ -199,22 +195,10 @@ class DisplayManager(QObject, LayerCollectionHandler):
             self.image_viewer.update_brush_cursor()
             self.thumbnail_highlight = gui_constants.THUMB_LO_COLOR
             self.highlight_thumbnail(self.current_layer_idx())
-            self.display_master_layer()
+            self.image_viewer.show_master()
+            self.refresh_master_view()
             self.status_message_requested.emit("View mode: Master")
-            self.cursor_preview_state_changed.emit(True)  # Restore preview
-
-    def numpy_to_qimage(self, array):
-        if array.dtype == np.uint16:
-            array = np.right_shift(array, 8).astype(np.uint8)
-        if array.ndim == 2:
-            height, width = array.shape
-            return QImage(memoryview(array), width, height, width, QImage.Format_Grayscale8)
-        if array.ndim == 3:
-            height, width, _ = array.shape
-            if not array.flags['C_CONTIGUOUS']:
-                array = np.ascontiguousarray(array)
-            return QImage(memoryview(array), width, height, 3 * width, QImage.Format_RGB888)
-        return QImage()
+            self.cursor_preview_state_changed.emit(True)
 
     def allow_cursor_preview(self):
         return self.view_mode == 'master' and not self.temp_view_individual

shinestacker/retouch/image_editor_ui.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904
+from functools import partial
 import numpy as np
-from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel,
+from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel, QMenu,
                                QListWidget, QSlider, QMainWindow, QMessageBox)
 from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
 from PySide6.QtCore import Qt
@@ -21,12 +22,14 @@ from .denoise_filter import DenoiseFilter
 from .unsharp_mask_filter import UnsharpMaskFilter
 from .white_balance_filter import WhiteBalanceFilter
 from .vignetting_filter import VignettingFilter
+from .. gui.recent_file_manager import RecentFileManager
 
 
 class ImageEditorUI(QMainWindow, LayerCollectionHandler):
     def __init__(self):
         QMainWindow.__init__(self)
         LayerCollectionHandler.__init__(self, LayerCollection())
+        self._recent_file_manager = RecentFileManager("shinestacker-recent-images-files.txt")
         self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
         self.undo_manager = UndoManager()
         self.undo_action = None
@@ -53,12 +56,12 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.setCentralWidget(central_widget)
         layout = QHBoxLayout(central_widget)
         self.image_viewer = ImageViewer(self.layer_collection)
-        self.image_viewer.temp_view_requested.connect(self.handle_temp_view)
-        self.image_viewer.brush_operation_started.connect(self.begin_copy_brush_area)
-        self.image_viewer.brush_operation_continued.connect(self.continue_copy_brush_area)
-        self.image_viewer.brush_operation_ended.connect(self.end_copy_brush_area)
-        self.image_viewer.brush_size_change_requested.connect(self.handle_brush_size_change)
-        self.image_viewer.setFocusPolicy(Qt.StrongFocus)
+        self.image_viewer.connect_signals(
+            self.handle_temp_view,
+            self.begin_copy_brush_area,
+            self.continue_copy_brush_area,
+            self.end_copy_brush_area,
+            self.handle_brush_size_change)
         side_panel = QWidget()
         side_layout = QVBoxLayout(side_panel)
         side_layout.setContentsMargins(0, 0, 0, 0)
@@ -115,9 +118,9 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         brush_layout.addWidget(self.flow_slider)
 
         side_layout.addWidget(brush_panel)
-        self.brush_preview = QLabel()
-        self.brush_preview.setContentsMargins(0, 0, 0, 0)
-        self.brush_preview.setStyleSheet("""
+        self.brush_preview_widget = QLabel()
+        self.brush_preview_widget.setContentsMargins(0, 0, 0, 0)
+        self.brush_preview_widget.setStyleSheet("""
             QLabel {
                 background-color: #f0f0f0;
                 border: 1px solid #ccc;
@@ -126,9 +129,9 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
                 margin: 0px;
             }
         """)
-        self.brush_preview.setAlignment(Qt.AlignCenter)
-        self.brush_preview.setFixedHeight(100)
-        brush_layout.addWidget(self.brush_preview)
+        self.brush_preview_widget.setAlignment(Qt.AlignCenter)
+        self.brush_preview_widget.setFixedHeight(100)
+        brush_layout.addWidget(self.brush_preview_widget)
         side_layout.addWidget(brush_panel)
 
         master_label = QLabel("Master")
@@ -236,22 +239,27 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         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.image_viewer.set_allow_cursor_preview)
         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.io_gui_handler.add_recent_file_requested.connect(self.add_recent_file)
+        self.brush_tool.setup_ui(self.brush, self.brush_preview_widget, 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.image_viewer.set_brush(self.brush_tool.brush)
+        self.image_viewer.set_preview_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
+        self.image_viewer.set_display_manager(self.display_manager)
 
         menubar = self.menuBar()
         file_menu = menubar.addMenu("&File")
         file_menu.addAction("&Open...", self.io_gui_handler.open_file, "Ctrl+O")
+        self.recent_files_menu = QMenu("Open &Recent", file_menu)
+        file_menu.addMenu(self.recent_files_menu)
+        self.update_recent_files()
         self.save_action = QAction("&Save", self)
         self.save_action.setShortcut("Ctrl+S")
         self.save_action.triggered.connect(self.io_gui_handler.save_file)
@@ -300,6 +308,69 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         view_menu.addSeparator()
 
+        view_strategy_menu = QMenu("View &Mode", view_menu)
+
+        self.view_action_modes = {
+            'overlaid': QAction("Overlaid", self),
+            'sidebyside': QAction("Side By Side", self),
+            'topbottom': QAction("Top-Bottom", self)
+        }
+        overlaid_mode = self.view_action_modes['overlaid']
+        overlaid_mode.setShortcut("Ctrl+1")
+        overlaid_mode.setCheckable(True)
+        overlaid_mode.triggered.connect(lambda: set_strategy('overlaid'))
+        view_strategy_menu.addAction(overlaid_mode)
+        side_by_side_mode = self.view_action_modes['sidebyside']
+        side_by_side_mode.setShortcut("Ctrl+2")
+        side_by_side_mode.setCheckable(True)
+        side_by_side_mode.triggered.connect(lambda: set_strategy('sidebyside'))
+        view_strategy_menu.addAction(side_by_side_mode)
+        side_by_side_mode = self.view_action_modes['topbottom']
+        side_by_side_mode.setShortcut("Ctrl+3")
+        side_by_side_mode.setCheckable(True)
+        side_by_side_mode.triggered.connect(lambda: set_strategy('topbottom'))
+        view_strategy_menu.addAction(side_by_side_mode)
+        view_menu.addMenu(view_strategy_menu)
+
+        def set_strategy(strategy):
+            self.image_viewer.set_strategy(strategy)
+            enable_shortcuts = strategy == 'overlaid'
+            self.view_master_action.setEnabled(enable_shortcuts)
+            self.view_individual_action.setEnabled(enable_shortcuts)
+            self.toggle_view_master_individual_action.setEnabled(enable_shortcuts)
+            for label, mode in self.view_action_modes.items():
+                mode.setEnabled(label != strategy)
+                mode.setChecked(label == strategy)
+
+        cursor_menu = view_menu.addMenu("Cursor Style")
+
+        cursor_stype = self.image_viewer.get_cursor_style()
+        brush_action = QAction("Simple Brush", self)
+        brush_action.setCheckable(True)
+        brush_action.setChecked(cursor_stype == 'brush')
+        brush_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('brush'))
+        cursor_menu.addAction(brush_action)
+
+        preview_action = QAction("Brush Preview", self)
+        preview_action.setCheckable(True)
+        preview_action.setChecked(cursor_stype == 'preview')
+        preview_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('preview'))
+        cursor_menu.addAction(preview_action)
+
+        outline_action = QAction("Outline Only", self)
+        outline_action.setCheckable(True)
+        outline_action.setChecked(cursor_stype == 'outline')
+        outline_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('outline'))
+        cursor_menu.addAction(outline_action)
+
+        cursor_group = QActionGroup(self)
+        cursor_group.addAction(preview_action)
+        cursor_group.addAction(outline_action)
+        cursor_group.addAction(brush_action)
+        cursor_group.setExclusive(True)
+
+        view_menu.addSeparator()
+
         zoom_in_action = QAction("Zoom In", self)
         zoom_in_action.setShortcut("Ctrl++")
         zoom_in_action.triggered.connect(self.image_viewer.zoom_in)
@@ -316,27 +387,30 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         view_menu.addAction(adapt_action)
 
         actual_size_action = QAction("Actual Size", self)
-        actual_size_action.setShortcut("Ctrl+=")
+        actual_size_action.setShortcut("Ctrl+R")
         actual_size_action.triggered.connect(self.image_viewer.actual_size)
         view_menu.addAction(actual_size_action)
         view_menu.addSeparator()
 
-        view_master_action = QAction("View Master", self)
-        view_master_action.setShortcut("M")
-        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.set_view_individual)
-        view_menu.addAction(view_individual_action)
-
-        toggle_view_master_individual_action = QAction("Toggle Master/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)
+        self.view_master_action = QAction("View Master", self)
+        self.view_master_action.setShortcut("M")
+        self.view_master_action.triggered.connect(self.set_view_master)
+        view_menu.addAction(self.view_master_action)
+
+        self.view_individual_action = QAction("View Individual", self)
+        self.view_individual_action.setShortcut("L")
+        self.view_individual_action.triggered.connect(self.set_view_individual)
+        view_menu.addAction(self.view_individual_action)
+
+        self.toggle_view_master_individual_action = QAction("Toggle Master/Individual", self)
+        self.toggle_view_master_individual_action.setShortcut("T")
+        self.toggle_view_master_individual_action.triggered.connect(
+            self.toggle_view_master_individual)
+        view_menu.addAction(self.toggle_view_master_individual_action)
         view_menu.addSeparator()
 
+        set_strategy('overlaid')
+
         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)
@@ -347,32 +421,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         view_menu.addSeparator()
 
-        cursor_menu = view_menu.addMenu("Cursor Style")
-
-        brush_action = QAction("Simple Brush", self)
-        brush_action.setCheckable(True)
-        brush_action.setChecked(self.image_viewer.cursor_style == 'brush')
-        brush_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('brush'))
-        cursor_menu.addAction(brush_action)
-
-        preview_action = QAction("Brush Preview", self)
-        preview_action.setCheckable(True)
-        preview_action.setChecked(self.image_viewer.cursor_style == 'preview')
-        preview_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('preview'))
-        cursor_menu.addAction(preview_action)
-
-        outline_action = QAction("Outline Only", self)
-        outline_action.setCheckable(True)
-        outline_action.setChecked(self.image_viewer.cursor_style == 'outline')
-        outline_action.triggered.connect(lambda: self.image_viewer.set_cursor_style('outline'))
-        cursor_menu.addAction(outline_action)
-
-        cursor_group = QActionGroup(self)
-        cursor_group.addAction(preview_action)
-        cursor_group.addAction(outline_action)
-        cursor_group.addAction(brush_action)
-        cursor_group.setExclusive(True)
-
         filter_menu = menubar.addMenu("&Filter")
         filter_menu.setObjectName("Filter")
         denoise_action = QAction("Denoise", self)
@@ -415,6 +463,19 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
                     title += " *"
         self.window().setWindowTitle(title)
 
+    def update_recent_files(self):
+        self.recent_files_menu.clear()
+        recent_files = self._recent_file_manager.get_files_with_display_names()
+        for file_path, display_name in recent_files.items():
+            action = self.recent_files_menu.addAction(display_name)
+            action.setData(file_path)
+            action.triggered.connect(partial(self.io_gui_handler.open_file, file_path))
+        self.recent_files_menu.setEnabled(len(recent_files) > 0)
+
+    def add_recent_file(self, file_path):
+        self._recent_file_manager.add_file(file_path)
+        self.update_recent_files()
+
     def show_status_message(self, message):
         self.statusBar().showMessage(message)
 
@@ -440,7 +501,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     # pylint: disable=C0103
     def keyPressEvent(self, event):
-        if self.image_viewer.empty:
+        if self.image_viewer.empty():
             return
         if event.text() == '[':
             self.brush_tool.decrease_brush_size()
@@ -467,14 +528,12 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     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.display_manager.refresh_current_view()
             self.thumbnail_list.setCurrentRow(layer_idx)
             self.thumbnail_list.setFocus()
             self.image_viewer.update_brush_cursor()
-            self.image_viewer.setFocus()
+            self.image_viewer.strategy.setFocus()
 
     def prev_layer(self):
         if self.layer_stack() is not None:
@@ -503,8 +562,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         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.display_manager.refresh_master_view()
             self.mark_as_modified()
             self.statusBar().showMessage(f"Copied layer {self.current_layer_idx() + 1} to master")
 
@@ -540,8 +598,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     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.display_manager.refresh_master_view()
             self.undo_manager.save_undo_state(self.master_layer_copy(), 'Brush Stroke')
             self.display_manager.update_timer.stop()
             self.mark_as_modified()
@@ -629,17 +686,20 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     def close_file(self):
         if self.check_unsaved_changes():
+            self.image_viewer.reset_zoom()
             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.display_manager.refresh_master_view()
         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.display_manager.refresh_current_view()
         self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
         self.highlight_master_thumbnail()
 
@@ -663,15 +723,13 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
     def undo(self):
         if self.undo_manager.undo(self.master_layer()):
-            self.display_manager.display_current_view()
-            self.display_manager.update_master_thumbnail()
+            self.display_manager.refresh_master_view()
             self.mark_as_modified()
             self.statusBar().showMessage("Undo applied", 2000)
 
     def redo(self):
         if self.undo_manager.redo(self.master_layer()):
-            self.display_manager.display_current_view()
-            self.display_manager.update_master_thumbnail()
+            self.display_manager.refresh_master_view()
             self.mark_as_modified()
             self.statusBar().showMessage("Redo applied", 2000)
 

shinestacker/retouch/image_view_status.py

@@ -0,0 +1,61 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0902
+from PySide6.QtCore import QObject, QRectF
+from PySide6.QtGui import QPixmap
+
+
+class ImageViewStatus(QObject):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.pixmap_master = QPixmap()
+        self.pixmap_current = QPixmap()
+        self.zoom_factor = 1.0
+        self.min_scale = 0.0
+        self.max_scale = 0.0
+        self.h_scroll = 0
+        self.v_scroll = 0
+        self.scene_rect = QRectF()
+
+    def empty(self):
+        return self.pixmap_master.isNull()
+
+    def set_master_image(self, qimage):
+        pixmap = QPixmap.fromImage(qimage)
+        self.pixmap_master = pixmap
+        if not self.empty():
+            self.scene_rect = QRectF(pixmap.rect())
+
+    def set_current_image(self, qimage):
+        pixmap = QPixmap.fromImage(qimage)
+        self.pixmap_current = pixmap
+
+    def clear(self):
+        self.pixmap_master = QPixmap()
+        self.pixmap_current = QPixmap()
+        self.zoom_factor = 1.0
+        self.min_scale = 0.0
+        self.max_scale = 0.0
+        self.h_scroll = 0
+        self.v_scroll = 0
+        self.scene_rect = QRectF()
+
+    def get_state(self):
+        return {
+            'zoom': self.zoom_factor,
+            'h_scroll': self.h_scroll,
+            'v_scroll': self.v_scroll
+        }
+
+    def set_state(self, state):
+        if state:
+            self.zoom_factor = state['zoom']
+            self.h_scroll = state['h_scroll']
+            self.v_scroll = state['v_scroll']
+
+    def set_zoom_factor(self, zoom_factor):
+        self.zoom_factor = zoom_factor
+
+    def set_min_scale(self, min_scale):
+        self.min_scale = min_scale
+
+    def set_max_scale(self, min_scale):
+        self.max_scale = min_scale