shinestacker 1.3.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

shinestacker/retouch/image_editor_ui.py

@@ -1,12 +1,14 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915, R0904, W0108
+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
 from PySide6.QtGui import QGuiApplication
 from .. config.constants import constants
 from .. config.gui_constants import gui_constants
+from .. gui.recent_file_manager import RecentFileManager
 from .image_viewer import ImageViewer
 from .shortcuts_help import ShortcutsHelp
 from .brush import Brush
@@ -21,23 +23,26 @@ from .denoise_filter import DenoiseFilter
 from .unsharp_mask_filter import UnsharpMaskFilter
 from .white_balance_filter import WhiteBalanceFilter
 from .vignetting_filter import VignettingFilter
+from .transformation_manager import TransfromationManager
 
 
 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
-        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.brush_tool = BrushTool()
         self.modified = False
         self.mask_layer = None
+        self.transformation_manager = TransfromationManager(self)
+        self.undo_manager = UndoManager(self.transformation_manager)
+        self.undo_action = None
+        self.redo_action = None
+        self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
         self.filter_manager = FilterManager(self)
         self.filter_manager.register_filter("Denoise", DenoiseFilter)
         self.filter_manager.register_filter("Unsharp Mask", UnsharpMaskFilter)
@@ -53,12 +58,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 +120,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 +131,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")
@@ -235,23 +240,26 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             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.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)
@@ -269,8 +277,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         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)
+        file_menu.addAction("&Import Frames", self.io_gui_handler.import_frames)
+        file_menu.addAction("Import &EXIF Data", self.io_gui_handler.select_exif_path)
 
         edit_menu = menubar.addMenu("&Edit")
         self.undo_action = QAction("Undo", self)
@@ -285,7 +293,21 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         edit_menu.addAction(self.redo_action)
         edit_menu.addSeparator()
 
-        copy_action = QAction("Copy Layer to Master", self)
+        transf_menu = QMenu("&Transform")
+        rotate_90_cw_action = QAction(gui_constants.ROTATE_90_CW_LABEL, self)
+        transf_menu.addAction(rotate_90_cw_action)
+        rotate_90_cw_action.triggered.connect(lambda: self.transformation_manager.rotate_90_cw())
+        rotate_90_ccw_action = QAction(gui_constants.ROTATE_90_CCW_LABEL, self)
+        transf_menu.addAction(rotate_90_ccw_action)
+        rotate_90_ccw_action.triggered.connect(lambda: self.transformation_manager.rotate_90_ccw())
+        rotate_180_action = QAction(gui_constants.ROTATE_180_LABEL, self)
+        rotate_180_action.triggered.connect(lambda: self.transformation_manager.rotate_180())
+        transf_menu.addAction(rotate_180_action)
+        edit_menu.addMenu(transf_menu)
+
+        edit_menu.addSeparator()
+
+        copy_action = QAction("Copy Current Layer to Master", self)
         copy_action.setShortcut("Ctrl+M")
         copy_action.triggered.connect(self.copy_layer_to_master)
         edit_menu.addAction(copy_action)
@@ -300,6 +322,78 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         view_menu.addSeparator()
 
+        view_strategy_menu = QMenu("View &Mode", view_menu)
+
+        self.view_mode_actions = {
+            'overlaid': QAction("Overlaid", self),
+            'sidebyside': QAction("Side by Side", self),
+            'topbottom': QAction("Top-Bottom", self)
+        }
+        overlaid_mode = self.view_mode_actions['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_mode_actions['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_mode_actions['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_mode_actions.items():
+                mode.setEnabled(label != strategy)
+                mode.setChecked(label == strategy)
+
+        cursor_menu = view_menu.addMenu("Cursor Style")
+
+        self.cursor_style_actions = {
+            'brush': QAction("Simple Brush", self),
+            'preview': QAction("Brush Preview", self),
+            'outline': QAction("Outline Only", self)
+        }
+        brush_action = self.cursor_style_actions['brush']
+        brush_action.setCheckable(True)
+        brush_action.triggered.connect(lambda: set_cursor_style('brush'))
+        cursor_menu.addAction(brush_action)
+
+        preview_action = self.cursor_style_actions['preview']
+        preview_action.setCheckable(True)
+        preview_action.triggered.connect(lambda: set_cursor_style('preview'))
+        cursor_menu.addAction(preview_action)
+
+        outline_action = self.cursor_style_actions['outline']
+        outline_action.setCheckable(True)
+        outline_action.triggered.connect(lambda: set_cursor_style('outline'))
+        cursor_menu.addAction(outline_action)
+
+        def set_cursor_style(cursor_style):
+            self.image_viewer.set_cursor_style(cursor_style)
+            for label, style in self.cursor_style_actions.items():
+                style.setEnabled(label != cursor_style)
+                style.setChecked(label == cursor_style)
+
+        set_cursor_style(self.image_viewer.get_cursor_style())
+
+        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 +410,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 +444,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)
@@ -384,13 +455,13 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         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 = 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 = QAction("Shortcuts and Mouse", self)
 
         def shortcuts_help():
             self.shortcuts_help_dialog = ShortcutsHelp(self)
@@ -415,6 +486,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 +524,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 +551,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 +585,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 +621,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,6 +709,7 @@ 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)
@@ -663,15 +744,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,65 @@
+# 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
+
+    def set_scroll(self, h_scroll, v_scroll):
+        self.h_scroll = h_scroll
+        self.v_scroll = v_scroll