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

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.5.0'
+__version__ = '1.5.1'

shinestacker/app/args.py

@@ -0,0 +1,23 @@
+# pylint: disable=C0114, C0116
+
+def add_project_arguments(parser):
+    parser.add_argument('-x', '--expert', action='store_true', help='''
+expert options are visible by default.
+''')
+
+
+def add_retouch_arguments(parser):
+    parser.add_argument('-p', '--path', nargs='?', help='''
+import frames from one or more directories.
+Multiple directories can be specified separated by ';'.
+''')
+    view_group = parser.add_mutually_exclusive_group()
+    view_group.add_argument('-v1', '--view-overlaid', action='store_true', help='''
+set overlaid view.
+''')
+    view_group.add_argument('-v2', '--view-side-by-side', action='store_true', help='''
+set side-by-side view.
+''')
+    view_group.add_argument('-v3', '--view-top-bottom', action='store_true', help='''
+set top-bottom view.
+''')

shinestacker/app/main.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, C0413, E0611, R0903, E1121, W0201
+# pylint: disable=C0114, C0115, C0116, C0413, E0611, R0903, E1121, W0201, R0915, R0912
 import sys
 import os
 import logging
@@ -20,6 +20,7 @@ from shinestacker.app.gui_utils import (
     disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 from shinestacker.app.open_frames import open_frames
+from .args import add_project_arguments, add_retouch_arguments
 
 
 class SelectionDialog(QDialog):
@@ -211,19 +212,21 @@ if a single file is specified, it can be either a project or an image.
 Multiple frames can be specified as a list of files.
 Multiple files can be specified separated by ';'.
 ''')
-    parser.add_argument('-p', '--path', nargs='?', help='''
-import frames from one or more directories.
-Multiple directories can be specified separated by ';'.
+    app_group = parser.add_mutually_exclusive_group()
+    app_group.add_argument('-j', '--project', action='store_true', help='''
+open project window at startup instead of project windows (default).
 ''')
-    parser.add_argument('-r', '--retouch', action='store_true', help='''
+    app_group.add_argument('-r', '--retouch', action='store_true', help='''
 open retouch window at startup instead of project windows.
 ''')
-    parser.add_argument('-x', '--expert', action='store_true', help='''
-expert options are visible by default.
-''')
+    add_project_arguments(parser)
+    add_retouch_arguments(parser)
     args = vars(parser.parse_args(sys.argv[1:]))
     filename = args['filename']
     path = args['path']
+    if filename and path:
+        print("can't specify both arguments --filename and --path", file=sys.stderr)
+        sys.exit(1)
     setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True)
     app = Application(sys.argv)
     if config.DONT_USE_NATIVE_MENU:
@@ -239,6 +242,12 @@ expert options are visible by default.
     main_app.activateWindow()
     if args['expert']:
         main_app.project_window.set_expert_options()
+    if args['view_overlaid']:
+        main_app.retouch_window.set_strategy('overlaid')
+    elif args['view_side_by_side']:
+        main_app.retouch_window.set_strategy('sidebyside')
+    elif args['view_top_bottom']:
+        main_app.retouch_window.set_strategy('topbottom')
     if filename:
         filenames = filename.split(';')
         filename = filenames[0]

shinestacker/app/project.py

@@ -17,6 +17,7 @@ from shinestacker.gui.main_window import MainWindow
 from shinestacker.app.gui_utils import (
     disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
+from .args import add_project_arguments
 
 
 class ProjectApp(MainWindow):
@@ -52,9 +53,7 @@ def main():
     parser.add_argument('-f', '--filename', nargs='?', help='''
 project filename.
 ''')
-    parser.add_argument('-x', '--expert', action='store_true', help='''
-expert options are visible by default.
-''')
+    add_project_arguments(parser)
     args = vars(parser.parse_args(sys.argv[1:]))
     setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True)
     app = Application(sys.argv)

shinestacker/app/retouch.py

@@ -13,6 +13,7 @@ from shinestacker.app.gui_utils import (
     disable_macos_special_menu_items, fill_app_menu, set_css_style)
 from shinestacker.app.help_menu import add_help_action
 from shinestacker.app.open_frames import open_frames
+from .args import add_retouch_arguments
 
 
 class RetouchApp(ImageEditorUI):
@@ -44,10 +45,7 @@ def main():
 import frames from files.
 Multiple files can be specified separated by ';'.
 ''')
-    parser.add_argument('-p', '--path', nargs='?', help='''
-import frames from one or more directories.
-Multiple directories can be specified separated by ';'.
-''')
+    add_retouch_arguments(parser)
     args = vars(parser.parse_args(sys.argv[1:]))
     filename = args['filename']
     path = args['path']
@@ -65,6 +63,12 @@ Multiple directories can be specified separated by ';'.
     editor = RetouchApp()
     app.editor = editor
     editor.show()
+    if args['view_overlaid']:
+        editor.set_strategy('overlaid')
+    elif args['view_side_by_side']:
+        editor.set_strategy('sidebyside')
+    elif args['view_top_bottom']:
+        editor.set_strategy('topbottom')
     open_frames(editor, filename, path)
     sys.exit(app.exec())
 

shinestacker/config/gui_constants.py

@@ -26,7 +26,7 @@ class _GuiConstants:
         'outer': (255, 0, 0, 200),
         'inner': (255, 0, 0, 150),
         'gradient_end': (255, 0, 0, 0),
-        'pen': (255, 0, 0, 150),
+        'pen': (255, 0, 0, 200),
         'preview': (255, 180, 180),
         'cursor_inner': (255, 0, 0, 120),
         'preview_inner': (255, 255, 255, 150)
@@ -55,7 +55,7 @@ class _GuiConstants:
     DEFAULT_BRUSH_OPACITY = 100
     DEFAULT_BRUSH_FLOW = 100
     BRUSH_SIZES = {
-        'default': 50,
+        'default': 100,
         'min': 5,
         'mid': 50,
         'max': 1000

shinestacker/gui/new_project.py

@@ -108,17 +108,19 @@ class NewProjectDialog(BaseFormDialog):
             step2_layout.addRow("Vignetting correction:", self.vignetting_correction)
         step2_layout.addRow(
             # f" {constants.ACTION_ICONS[constants.ACTION_ALIGNFRAMES]} "
-            "Align layers:", self.align_frames)
+            "Align frames:", self.align_frames)
         step2_layout.addRow(
             # f" {constants.ACTION_ICONS[constants.ACTION_BALANCEFRAMES]} "
-            "Balance layers:", self.balance_frames)
+            "Balance frames:", self.balance_frames)
         step2_layout.addRow(
             # f" {constants.ACTION_ICONS[constants.ACTION_FOCUSSTACKBUNCH]} "
-            "Bunch stack:", self.bunch_stack)
-        step2_layout.addRow("Bunch frames:", self.bunch_frames)
-        step2_layout.addRow("Bunch overlap:", self.bunch_overlap)
+            "Create bunches:", self.bunch_stack)
+        self.bunch_stack.setToolTip("Combine multiple frames into fewer, high-quality "
+                                    "composite frames for easier retouching")
+        step2_layout.addRow("Frames per bunch:", self.bunch_frames)
+        step2_layout.addRow("Overlap between bunches:", self.bunch_overlap)
         self.bunches_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
-        step2_layout.addRow("Number of bunches: ", self.bunches_label)
+        step2_layout.addRow("Number of resulting bunches: ", self.bunches_label)
         if self.expert():
             step2_layout.addRow(
                 f" {constants.ACTION_ICONS[constants.ACTION_FOCUSSTACK]} "
@@ -133,14 +135,14 @@ class NewProjectDialog(BaseFormDialog):
         if self.expert():
             step2_layout.addRow(
                 f" {constants.ACTION_ICONS[constants.ACTION_MULTILAYER]} "
-                "Save multi layer TIFF:", self.multi_layer)
+                "Export as multilayer TIFF:", self.multi_layer)
         step2_group.setLayout(step2_layout)
         self.form_layout.addRow(step2_group)
         step3_group = QGroupBox("3) Confirm")
         step3_layout = QVBoxLayout()
         step3_layout.setContentsMargins(15, 0, 15, 15)
         step3_layout.addWidget(
-            QLabel("Click 🆗 to confirm and prepare the job."))
+            QLabel("Click 🆗 to create project with these settings."))
         step3_layout.addWidget(
             QLabel("Select: <b>View</b> > <b>Expert options</b> for advanced configuration."))
         step3_group.setLayout(step3_layout)
@@ -149,6 +151,7 @@ class NewProjectDialog(BaseFormDialog):
         step4_layout = QHBoxLayout()
         step4_layout.setContentsMargins(15, 0, 15, 15)
         step4_layout.addWidget(QLabel("Press ▶️ to run your job."))
+        step4_layout.addStretch()
         icon_path = f"{os.path.dirname(__file__)}/ico/shinestacker.png"
         app_icon = QIcon(icon_path)
         icon_pixmap = app_icon.pixmap(80, 80)
@@ -293,12 +296,12 @@ class NewProjectDialog(BaseFormDialog):
                             "Processing may require a significant amount "
                             "of memory or I/O buffering.\n\n"
                             "Continue anyway?")
-                msg.setInformativeText("You may consider to split the processing "
-                                       " using a bunch stack to reduce memory usage.\n\n"
-                                       '✅ Check the option "Bunch stack".\n\n'
-                                       "➡️ Check expert options for the stacking algorithm."
-                                       'Go to "View" > "Expert Options".'
-                                       )
+                msg.setInformativeText('You may consider creating "bunches" to reduce '
+                                       "the number of frames for retouching.\n\n"
+                                       '✅ Check "Create bunches" to combine frames '
+                                       "into manageable composites.\n\n"
+                                       "➡️ Check expert options for the stacking algorithm.\n\n"
+                                       'Go to "View" > "Expert Options".')
                 msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
                 msg.setDefaultButton(QMessageBox.Cancel)
                 if msg.exec_() != QMessageBox.Ok:

shinestacker/retouch/brush_preview.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0913, R0917, R0914, W0718
+# pylint: disable=C0114, C0115, C0116, E0611, R0913, R0917, R0914, W0718, R0915
 import traceback
 import numpy as np
 from PySide6.QtWidgets import QGraphicsPixmapItem
@@ -72,38 +72,52 @@ class BrushPreviewItem(QGraphicsPixmapItem, LayerCollectionHandler):
                 self.hide()
                 return
             radius = size // 2
-            x = int(scene_pos.x() - radius + 0.5)
-            y = int(scene_pos.y() - radius)
+            x_center = int(scene_pos.x() + 0.5)
+            y_center = int(scene_pos.y() + 0.5)
+            x = x_center - radius
+            y = y_center - radius
             w = h = size
             if not self.valid_current_layer_idx():
                 self.hide()
                 return
-            layer_area = self.get_layer_area(self.current_layer(), x, y, w, h)
-            master_area = self.get_layer_area(self.master_layer(), x, y, w, h)
+            height, width = self.current_layer().shape[:2]
+            visible_x = max(0, x)
+            visible_y = max(0, y)
+            visible_w = min(width, x + w) - visible_x
+            visible_h = min(height, y + h) - visible_y
+            if visible_w <= 0 or visible_h <= 0:
+                self.hide()
+                return
+            layer_area = self.get_layer_area(
+                self.current_layer(), visible_x, visible_y, visible_w, visible_h)
+            master_area = self.get_layer_area(
+                self.master_layer(), visible_x, visible_y, visible_w, visible_h)
             if layer_area is None or master_area is None:
                 self.hide()
                 return
-            height, width = self.current_layer().shape[:2]
             full_mask = create_brush_mask(size=size, hardness_percent=self.brush.hardness,
                                           opacity_percent=self.brush.opacity)[:, :, np.newaxis]
-            mask_x_start = max(0, -x) if x < 0 else 0
-            mask_y_start = max(0, -y) if y < 0 else 0
-            mask_x_end = size - (max(0, (x + w) - width)) if (x + w) > width else size
-            mask_y_end = size - (max(0, (y + h) - height)) if (y + h) > height else size
+            mask_x_start = max(0, -x)
+            mask_y_start = max(0, -y)
+            mask_x_end = mask_x_start + visible_w
+            mask_y_end = mask_y_start + visible_h
             mask_area = full_mask[mask_y_start:mask_y_end, mask_x_start:mask_x_end]
             area = (layer_area * mask_area + master_area * (1 - mask_area)) * 255.0
             area = area.astype(np.uint8)
             qimage = QImage(area.data, area.shape[1], area.shape[0],
                             area.strides[0], QImage.Format_RGB888)
-            mask = QPixmap(w, h)
+            mask = QPixmap(visible_w, visible_h)
             mask.fill(Qt.transparent)
             painter = QPainter(mask)
             painter.setPen(Qt.NoPen)
             painter.setBrush(Qt.black)
-            painter.drawEllipse(0, 0, w, h)
+            center_x_in_visible = x_center - visible_x
+            center_y_in_visible = y_center - visible_y
+            painter.drawEllipse(
+                center_x_in_visible - radius, center_y_in_visible - radius, size, size)
             painter.end()
             pixmap = QPixmap.fromImage(qimage)
-            final_pixmap = QPixmap(w, h)
+            final_pixmap = QPixmap(visible_w, visible_h)
             final_pixmap.fill(Qt.transparent)
             painter = QPainter(final_pixmap)
             painter.drawPixmap(0, 0, pixmap)
@@ -111,8 +125,8 @@ class BrushPreviewItem(QGraphicsPixmapItem, LayerCollectionHandler):
             painter.drawPixmap(0, 0, mask)
             painter.end()
             self.setPixmap(final_pixmap)
-            x_start, y_start = max(0, x), max(0, y)
-            self.setPos(x_start, y_start)
+            self.setPos(visible_x, visible_y)
+            self.show()
         except Exception:
             traceback.print_exc()
             self.hide()

shinestacker/retouch/image_editor_ui.py

@@ -49,7 +49,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.filter_manager.register_filter("White Balance", WhiteBalanceFilter)
         self.filter_manager.register_filter("Vignetting Correction", VignettingFilter)
         self.shortcuts_help_dialog = None
-
         self.update_title()
         self.resize(1400, 900)
         center = QGuiApplication.primaryScreen().geometry().center()
@@ -68,18 +67,15 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         side_layout = QVBoxLayout(side_panel)
         side_layout.setContentsMargins(0, 0, 0, 0)
         side_layout.setSpacing(2)
-
         brush_panel = QFrame()
         brush_panel.setFrameShape(QFrame.StyledPanel)
         brush_panel.setContentsMargins(0, 0, 0, 0)
         brush_layout = QVBoxLayout(brush_panel)
         brush_layout.setContentsMargins(0, 0, 0, 0)
         brush_layout.setSpacing(2)
-
         brush_label = QLabel("Brush Size")
         brush_label.setAlignment(Qt.AlignCenter)
         brush_layout.addWidget(brush_label)
-
         self.brush_size_slider = QSlider(Qt.Horizontal)
         self.brush_size_slider.setRange(0, gui_constants.BRUSH_SIZE_SLIDER_MAX)
 
@@ -94,7 +90,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
 
         self.brush_size_slider.setValue(brush_size_to_slider(self.brush.size))
         brush_layout.addWidget(self.brush_size_slider)
-
         hardness_label = QLabel("Brush Hardness")
         hardness_label.setAlignment(Qt.AlignCenter)
         brush_layout.addWidget(hardness_label)
@@ -102,7 +97,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.hardness_slider.setRange(0, 100)
         self.hardness_slider.setValue(self.brush.hardness)
         brush_layout.addWidget(self.hardness_slider)
-
         opacity_label = QLabel("Brush Opacity")
         opacity_label.setAlignment(Qt.AlignCenter)
         brush_layout.addWidget(opacity_label)
@@ -110,7 +104,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.opacity_slider.setRange(0, 100)
         self.opacity_slider.setValue(self.brush.opacity)
         brush_layout.addWidget(self.opacity_slider)
-
         flow_label = QLabel("Brush Flow")
         flow_label.setAlignment(Qt.AlignCenter)
         brush_layout.addWidget(flow_label)
@@ -118,7 +111,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.flow_slider.setRange(1, 100)
         self.flow_slider.setValue(self.brush.flow)
         brush_layout.addWidget(self.flow_slider)
-
         side_layout.addWidget(brush_panel)
         self.brush_preview_widget = QLabel()
         self.brush_preview_widget.setContentsMargins(0, 0, 0, 0)
@@ -135,7 +127,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.brush_preview_widget.setFixedHeight(100)
         brush_layout.addWidget(self.brush_preview_widget)
         side_layout.addWidget(brush_panel)
-
         master_label = QLabel("Master")
         master_label.setStyleSheet("""
             QLabel {
@@ -332,30 +323,20 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         overlaid_mode = self.view_mode_actions['overlaid']
         overlaid_mode.setShortcut("Ctrl+1")
         overlaid_mode.setCheckable(True)
-        overlaid_mode.triggered.connect(lambda: set_strategy('overlaid'))
+        overlaid_mode.triggered.connect(lambda: self.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'))
+        side_by_side_mode.triggered.connect(lambda: self.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'))
+        side_by_side_mode.triggered.connect(lambda: self.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 = {
@@ -432,7 +413,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         view_menu.addAction(self.toggle_view_master_individual_action)
         view_menu.addSeparator()
 
-        set_strategy('overlaid')
+        self.set_strategy('overlaid')
 
         sort_asc_action = QAction("Sort Layers A-Z", self)
         sort_asc_action.triggered.connect(lambda: self.sort_layers('asc'))
@@ -463,6 +444,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         help_menu.setObjectName("Help")
         shortcuts_help_action = QAction("Shortcuts and Mouse", self)
 
+        self.statusBar().showMessage("Shine Stacker ready.", 2000)
+
         def shortcuts_help():
             self.shortcuts_help_dialog = ShortcutsHelp(self)
             self.shortcuts_help_dialog.exec()
@@ -476,6 +459,16 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         next_layer.activated.connect(self.next_layer)
         self.installEventFilter(self)
 
+    def set_strategy(self, 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)
+
     def update_title(self):
         title = constants.APP_TITLE
         if self.io_gui_handler is not None:

shinestacker/retouch/image_viewer.py

@@ -87,9 +87,6 @@ class ImageViewer(QWidget):
     def set_allow_cursor_preview(self, state):
         self.strategy.set_allow_cursor_preview(state)
 
-    def setup_brush_cursor(self):
-        self.strategy.setup_brush_cursor()
-
     def zoom_in(self):
         self.strategy.zoom_in()
 
@@ -109,7 +106,8 @@ class ImageViewer(QWidget):
         return self.strategy.get_cursor_style()
 
     def set_cursor_style(self, style):
-        self.strategy.set_cursor_style(style)
+        for st in self._strategies.values():
+            st.set_cursor_style(style)
 
     def position_on_image(self, pos):
         return self.strategy.position_on_image(pos)

shinestacker/retouch/io_gui_handler.py

@@ -56,8 +56,6 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             self.set_layer_labels(labels)
         self.set_master_layer(master_layer)
         self.image_viewer.set_master_image_np(master_layer)
-        self.image_viewer.show_master()
-        self.image_viewer.update_master_display()
         self.undo_manager.reset()
         self.blank_layer = np.zeros(master_layer.shape[:2])
         self.finish_loading_setup(f"Loaded: {self.current_file_path()}")
@@ -165,7 +163,6 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.display_manager.update_thumbnails()
         self.mark_as_modified_requested.emit(True)
         self.change_layer_requested.emit(0)
-        self.image_viewer.setup_brush_cursor()
         self.status_message_requested.emit(message)
         self.update_title_requested.emit()
         self.add_recent_file_requested.emit(self.current_file_path_master)

shinestacker/retouch/overlaid_view.py

@@ -114,27 +114,31 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             return self.handle_gesture_event(event)
         return super().event(event)
 
-    def set_master_image(self, qimage):
-        self.status.set_master_image(qimage)
-        pixmap = self.status.pixmap_master
+    def setup_scene_image(self, pixmap, pixmap_item):
         self.setSceneRect(QRectF(pixmap.rect()))
         img_width, img_height = pixmap.width(), pixmap.height()
         self.set_max_min_scales(img_width, img_height)
-        self.set_zoom_factor(1.0)
+        view_rect = self.viewport().rect()
+        scale_x = view_rect.width() / img_width
+        scale_y = view_rect.height() / img_height
+        scale_factor = min(scale_x, scale_y)
+        scale_factor = max(self.min_scale(), min(scale_factor, self.max_scale()))
+        self.set_zoom_factor(scale_factor)
         self.resetTransform()
-        self.fitInView(self.pixmap_item_master, Qt.KeepAspectRatio)
-        self.set_zoom_factor(self.get_current_scale())
-        self.set_zoom_factor(max(self.min_scale(), min(self.max_scale(), self.zoom_factor())))
-        self.scale(self.zoom_factor(), self.zoom_factor())
-        self.centerOn(self.pixmap_item_master)
+        self.scale(scale_factor, scale_factor)
+        self.centerOn(pixmap_item)
         self.center_image(self)
         self.update_cursor_pen_width()
 
+    def set_master_image(self, qimage):
+        self.status.set_master_image(qimage)
+        self.setup_scene_image(self.status.pixmap_master, self.pixmap_item_master)
+        self.update_master_display()
+
     def set_current_image(self, qimage):
         self.status.set_current_image(qimage)
         if self.empty():
-            self.setSceneRect(QRectF(self.status.pixmap_current.rect()))
-        self.update_cursor_pen_width()
+            self.setup_scene_image(self.status.pixmap_current, self.pixmap_item_current)
 
     def setup_brush_cursor(self):
         super().setup_brush_cursor()
@@ -144,11 +148,19 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
         self.pixmap_item_master.setVisible(True)
         self.pixmap_item_current.setVisible(False)
         self.brush_preview.show()
+        if self.brush_cursor:
+            self.scene.removeItem(self.brush_cursor)
+            self.brush_cursor = self.create_circle(self.scene)
+            self.update_brush_cursor()
 
     def show_current(self):
         self.pixmap_item_master.setVisible(False)
         self.pixmap_item_current.setVisible(True)
         self.brush_preview.hide()
+        if self.brush_cursor:
+            self.scene.removeItem(self.brush_cursor)
+            self.brush_cursor = self.create_alt_circle(self.scene)
+            self.update_brush_cursor()
 
     def arrange_images(self):
         if self.empty():

shinestacker/retouch/shortcuts_help.py

@@ -39,7 +39,7 @@ class ShortcutsHelp(QDialog):
         ok_button.clicked.connect(self.accept)
 
     def add_bold_label(self, layout, label):
-        label = QLabel(label)
+        label = QLabel(f"{label}:")
         label.setStyleSheet("font-weight: bold")
         layout.addRow(label)
 
@@ -47,21 +47,21 @@ class ShortcutsHelp(QDialog):
         self.main_layout.insertWidget(0, icon_container())
 
         shortcuts = {
-            "M": "show master layer",
-            "L": "show selected layer",
-            "T": "toggle master/selected layer",
-            "X": "temp. toggle between master and source layer",
-            "↑": "select one layer up",
-            "↓": "selcet one layer down",
-            "Ctrl + O": "open file",
-            "Ctrl + S": "save multilayer tiff",
-            "Crtl + Z": "undo brush draw",
-            "Ctrl + M": "copy selected layer to master",
-            "Ctrl + Cmd + F": "full screen mode",
-            "Ctrl + +": "zoom in",
-            "Ctrl + -": "zoom out",
-            "Ctrl + 0": "adapt to screen",
-            "Ctrl + R": "actual size"
+            "M": "Show master layer",
+            "L": "Show selected layer",
+            "T": "Toggle master/selected layer",
+            "X": "Temporarily toggle between master and source layer",
+            "↑": "Select one layer up",
+            "↓": "Select one layer down",
+            "Ctrl + O": "Open file",
+            "Ctrl + S": "Save multilayer tiff",
+            "Ctrl + Z": "Undo brush draw",
+            "Ctrl + M": "Copy selected layer to master",
+            "Ctrl + Cmd + F": "Full screen mode",
+            "Ctrl + +": "Zoom in",
+            "Ctrl + -": "Zoom out",
+            "Ctrl + 0": "Fit to screen",
+            "Ctrl + R": "Actual size"
         }
 
         self.add_bold_label(left_layout, "Keyboard Shortcuts")
@@ -69,13 +69,13 @@ class ShortcutsHelp(QDialog):
             left_layout.addRow(f"<b>{k}</b>", QLabel(v))
 
         shortcuts = {
-            "Ctrl + 1": "view mode: overlaid",
-            "Ctrl + 2": "view mode: side by side",
-            "Ctrl + 3": "view mode: top-bottom",
-            "[": "increase brush size",
-            "]": "decrease brush size",
-            "{": "increase brush hardness",
-            "}": "decrease brush hardness"
+            "Ctrl + 1": "View: overlaid",
+            "Ctrl + 2": "View: side by side",
+            "Ctrl + 3": "View: top-bottom",
+            "[": "Increase brush size",
+            "]": "Decrease brush size",
+            "{": "Increase brush hardness",
+            "}": "Decrease brush hardness"
         }
 
         self.add_bold_label(right_layout, "Keyboard Shortcuts")
@@ -83,22 +83,26 @@ class ShortcutsHelp(QDialog):
             right_layout.addRow(f"<b>{k}</b>", QLabel(v))
 
         mouse_controls = {
-            "Space + Drag": "pan",
-            "Wheel": "zoom in/out",
-            "Ctrl + Wheel": "adjust brush size",
-            "Left Click": "brush action",
+            "Space + Drag": "Move",
+            "Wheel": "Zoom in/out",
+            "Ctrl + Wheel": "Adjust brush size",
+            "Left Click": "Use brush to copy from selected layer to master",
         }
 
+        spacer = QLabel("")
+        spacer.setFixedHeight(10)
+        right_layout.addWidget(spacer)
         self.add_bold_label(right_layout, "Mouse Controls")
         for k, v in mouse_controls.items():
             right_layout.addRow(f"<b>{k}</b>", QLabel(v))
 
         touchpad_controls = {
-            "Two fingers": "pan",
-            "Pinch": "zoom in/out",
-            "Ctrl + two fingers": "zoom in/out",
+            "Two-finger drag": "Move",
+            "Pinch two fingers": "Zoom in/out"
         }
-        self.add_bold_label(right_layout, " ")
+        spacer = QLabel("")
+        spacer.setFixedHeight(10)
+        right_layout.addWidget(spacer)
         self.add_bold_label(right_layout, "Touchpad Controls")
         for k, v in touchpad_controls.items():
             right_layout.addRow(f"<b>{k}</b>", QLabel(v))

shinestacker/retouch/sidebyside_view.py

@@ -1,8 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, R0904, R0915, E0611, R0902, R0911, R0914, E1003
 from PySide6.QtCore import Qt, Signal, QEvent, QRectF
-from PySide6.QtGui import QPen, QColor, QCursor
-from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QFrame, QGraphicsEllipseItem
-from .. config.gui_constants import gui_constants
+from PySide6.QtGui import QCursor
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QFrame
 from .view_strategy import ViewStrategy, ImageGraphicsViewBase, ViewSignals
 
 
@@ -59,7 +58,6 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.current_view.setFocusPolicy(Qt.NoFocus)
         self.master_view.setFocusPolicy(Qt.NoFocus)
         self.current_brush_cursor = None
-        self.setup_current_brush_cursor()
 
     def setup_layout(self):
         raise NotImplementedError("Subclasses must implement setup_layout")
@@ -180,10 +178,11 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
                 self.master_view.setCursor(Qt.OpenHandCursor)
                 self.current_view.setCursor(Qt.OpenHandCursor)
             else:
+                if self.brush_cursor is None or self.current_brush_cursor is None:
+                    self.setup_brush_cursor()
                 self.master_view.setCursor(Qt.BlankCursor)
                 self.current_view.setCursor(Qt.BlankCursor)
-                if self.brush_cursor:
-                    self.brush_cursor.show()
+                self.brush_cursor.show()
         super().enterEvent(event)
 
     def leaveEvent(self, event):
@@ -192,10 +191,10 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.master_view.setCursor(Qt.ArrowCursor)
             self.current_view.setCursor(Qt.ArrowCursor)
         else:
-            if self.brush_cursor is not None:
-                self.brush_cursor.hide()
-            if self.current_brush_cursor is not None:
-                self.current_brush_cursor.hide()
+            if self.brush_cursor is None or self.current_brush_cursor is None:
+                self.setup_brush_cursor()
+            self.brush_cursor.hide()
+            self.current_brush_cursor.hide()
             self.master_view.setCursor(Qt.ArrowCursor)
             self.current_view.setCursor(Qt.ArrowCursor)
         super().leaveEvent(event)
@@ -248,33 +247,12 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     def setup_brush_cursor(self):
         super().setup_brush_cursor()
         self.setup_current_brush_cursor()
-        self.update_cursor_pen_width()
 
     def setup_current_brush_cursor(self):
         if not self.brush:
             return
-        for item in self.current_scene.items():
-            if isinstance(item, QGraphicsEllipseItem) and item != self.brush_preview:
-                self.current_scene.removeItem(item)
-        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
-        pen = QPen(QColor(255, 0, 0), pen_width, Qt.DotLine)
-        brush = Qt.NoBrush
-        self.current_brush_cursor = self.current_scene.addEllipse(
-            0, 0, self.brush.size, self.brush.size, pen, brush)
-        self.current_brush_cursor.setZValue(1000)
-        self.current_brush_cursor.hide()
-
-    def update_current_brush_cursor(self, scene_pos):
-        if not self.current_brush_cursor or not self.isVisible():
-            return
-        size = self.brush.size
-        radius = size / 2
-        self.current_brush_cursor.setRect(
-            scene_pos.x() - radius, scene_pos.y() - radius, size, size)
-        if self.brush_cursor and self.brush_cursor.isVisible():
-            self.current_brush_cursor.show()
-        else:
-            self.current_brush_cursor.hide()
+        self.current_brush_cursor = self.create_alt_circle(
+            self.get_current_scene(), line_style=Qt.SolidLine)
 
     def update_cursor_pen_width(self):
         pen_width = super().update_cursor_pen_width()
@@ -287,23 +265,29 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     def update_brush_cursor(self):
         if self.empty():
             return
+        if self.brush_cursor is None or self.current_brush_cursor is None:
+            self.setup_brush_cursor()
         self.update_cursor_pen_width()
+        if self.space_pressed:
+            cursor_style = Qt.OpenHandCursor if not self.scrolling else Qt.ClosedHandCursor
+            self.master_view.setCursor(cursor_style)
+            self.current_view.setCursor(cursor_style)
+            self.brush_cursor.hide()
+            self.current_brush_cursor.hide()
+            return
+        self.master_view.setCursor(Qt.BlankCursor)
+        self.current_view.setCursor(Qt.BlankCursor)
         mouse_pos_global = QCursor.pos()
         mouse_pos_current = self.current_view.mapFromGlobal(mouse_pos_global)
         mouse_pos_master = self.master_view.mapFromGlobal(mouse_pos_global)
         current_has_mouse = self.current_view.rect().contains(mouse_pos_current)
         master_has_mouse = self.master_view.rect().contains(mouse_pos_master)
+        self.current_brush_cursor.hide()
         if master_has_mouse:
-            self.brush_preview.show()
+            if self.cursor_style == 'preview':
+                self.brush_preview.show()
             super().update_brush_cursor()
             self.sync_current_cursor_with_master()
-            if self.space_pressed:
-                cursor_style = Qt.OpenHandCursor if not self.scrolling else Qt.ClosedHandCursor
-                self.master_view.setCursor(cursor_style)
-                self.current_view.setCursor(cursor_style)
-            else:
-                self.master_view.setCursor(Qt.BlankCursor)
-                self.current_view.setCursor(Qt.BlankCursor)
         elif current_has_mouse:
             self.brush_preview.hide()
             scene_pos = self.current_view.mapToScene(mouse_pos_current)
@@ -312,23 +296,12 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.current_brush_cursor.setRect(
                 scene_pos.x() - radius, scene_pos.y() - radius, size, size)
             self.current_brush_cursor.show()
-            if self.brush_cursor:
-                self.brush_cursor.setRect(
-                    scene_pos.x() - radius, scene_pos.y() - radius, size, size)
-                self.brush_cursor.show()
-            if self.space_pressed:
-                cursor_style = Qt.OpenHandCursor \
-                    if not self.panning_current else Qt.ClosedHandCursor
-                self.current_view.setCursor(cursor_style)
-                self.master_view.setCursor(cursor_style)
-            else:
-                self.current_view.setCursor(Qt.BlankCursor)
-                self.master_view.setCursor(Qt.BlankCursor)
+            self.brush_cursor.setRect(
+                scene_pos.x() - radius, scene_pos.y() - radius, size, size)
+            self.brush_cursor.show()
         else:
-            if self.brush_cursor:
-                self.brush_cursor.hide()
-            if self.current_brush_cursor:
-                self.current_brush_cursor.hide()
+            self.brush_cursor.hide()
+            self.current_brush_cursor.hide()
             self.master_view.setCursor(Qt.ArrowCursor)
             self.current_view.setCursor(Qt.ArrowCursor)
 
@@ -379,12 +352,14 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.pixmap_item_master.setPixmap(pixmap)
         img_width, img_height = pixmap.width(), pixmap.height()
         self.set_max_min_scales(img_width, img_height)
-        self.set_zoom_factor(1.0)
-        self.master_view.fitInView(self.pixmap_item_master, Qt.KeepAspectRatio)
-        self.set_zoom_factor(self.get_current_scale())
-        self.set_zoom_factor(max(self.min_scale(), min(self.max_scale(), self.zoom_factor())))
+        view_rect = self.master_view.viewport().rect()
+        scale_x = view_rect.width() / img_width
+        scale_y = view_rect.height() / img_height
+        scale_factor = min(scale_x, scale_y)
+        scale_factor = max(self.min_scale(), min(scale_factor, self.max_scale()))
+        self.set_zoom_factor(scale_factor)
         self.master_view.resetTransform()
-        self.master_scene.scale(self.zoom_factor(), self.zoom_factor())
+        self.master_view.scale(scale_factor, scale_factor)
         self.master_view.centerOn(self.pixmap_item_master)
         center = self.master_scene.sceneRect().center()
         self.brush_preview.setPos(max(0, min(center.x(), img_width)),
@@ -399,10 +374,9 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.current_scene.setSceneRect(QRectF(pixmap.rect()))
         self.pixmap_item_current.setPixmap(pixmap)
         self.current_view.resetTransform()
-        self.current_scene.scale(self.zoom_factor(), self.zoom_factor())
+        self.master_view.scale(self.zoom_factor(), self.zoom_factor())
         self.current_scene.setSceneRect(QRectF(self.pixmap_item_current.boundingRect()))
         self.center_image(self.current_view)
-        self.update_cursor_pen_width()
 
     def arrange_images(self):
         if self.status.empty():
@@ -415,13 +389,6 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.center_image(self.master_view)
         self.apply_zoom()
 
-    def set_brush(self, brush):
-        super().set_brush(brush)
-        if self.brush_cursor:
-            self.master_scene.removeItem(self.brush_cursor)
-        self.setup_brush_cursor()
-        self.setup_current_brush_cursor()
-
     def clear_image(self):
         super().clear_image()
         self.setCursor(Qt.ArrowCursor)
@@ -439,10 +406,8 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         size = self.brush.size
         radius = size / 2
         self.current_brush_cursor.setRect(
-            scene_pos.x() - radius,
-            scene_pos.y() - radius,
-            size, size
-        )
+            scene_pos.x() - radius, scene_pos.y() - radius,
+            size, size)
         if self.brush_cursor.isVisible():
             self.current_brush_cursor.show()
         else:

shinestacker/retouch/view_strategy.py

@@ -1,17 +1,79 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0904, R0903, R0902, E1101, R0914
+# pylint: disable=C0114, C0115, C0116, E0611, R0904, R0903, R0902, E1101, R0914, R0913, R0917
 import math
 from abc import abstractmethod
 import numpy as np
 from PySide6.QtCore import Qt, QPointF, QTime, QPoint, Signal, QRectF
-from PySide6.QtGui import QImage, QPainter, QColor, QBrush, QPen, QCursor, QPixmap
+from PySide6.QtGui import QImage, QPainter, QColor, QBrush, QPen, QCursor, QPixmap, QPainterPath
 from PySide6.QtWidgets import (
-    QGraphicsEllipseItem, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem)
+    QGraphicsEllipseItem, QGraphicsView, QGraphicsScene, QGraphicsPixmapItem,
+    QGraphicsItemGroup, QGraphicsPathItem)
 from .. config.gui_constants import gui_constants
 from .layer_collection import LayerCollectionHandler
 from .brush_gradient import create_default_brush_gradient
 from .brush_preview import BrushPreviewItem
 
 
+class BrushCursor(QGraphicsItemGroup):
+    def __init__(self, x0, y0, size, pen, brush):
+        super().__init__()
+        self._pen = pen
+        self._radius = size / 2
+        self._brush = brush
+        self._rect = QRectF(x0 - self._radius, y0 - self._radius, size, size)
+        self._arc_items = []
+        self._create_arcs()
+
+    def _point_on_circle(self, phi_deg):
+        phi = phi_deg / 180.0 * math.pi
+        x0 = self._rect.x() + self._radius
+        y0 = self._rect.y() + self._radius
+        return x0 + self._radius * math.cos(phi), y0 - self._radius * math.sin(phi)
+
+    def _create_arcs(self):
+        for item in self._arc_items:
+            self.removeFromGroup(item)
+            if item.scene():
+                item.scene().removeItem(item)
+        self._arc_items = []
+        half_gap = 20
+        arcs = [half_gap, 90 + half_gap, 180 + half_gap, 270 + half_gap]
+        span_angle = 90 - 2 * half_gap
+        for start_angle in arcs:
+            path = QPainterPath()
+            path.moveTo(*self._point_on_circle(start_angle))
+            path.arcTo(self._rect, start_angle, span_angle)
+            arc_item = QGraphicsPathItem(path)
+            arc_item.setPen(self._pen)
+            arc_item.setBrush(Qt.NoBrush)
+            self.addToGroup(arc_item)
+            self._arc_items.append(arc_item)
+
+    # pylint: disable=C0103
+    def setPen(self, pen):
+        self._pen = pen
+        for item in self._arc_items:
+            item.setPen(pen)
+
+    def pen(self):
+        return self._pen
+
+    def setBrush(self, brush):
+        self._brush = brush
+        for item in self._arc_items:
+            item.setBrush(Qt.NoBrush)
+
+    def brush(self):
+        return self._brush
+
+    def setRect(self, x, y, w, h):
+        self._rect = QRectF(x, y, w, h)
+        self._create_arcs()
+
+    def rect(self):
+        return self._rect
+    # pylint: enable=C0103
+
+
 class ViewSignals:
     temp_view_requested = Signal(bool)
     brush_operation_started = Signal(QPoint)
@@ -141,12 +203,12 @@ class ViewStrategy(LayerCollectionHandler):
                 self.arrange_images()
 
     def update_cursor_pen_width(self):
-        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
+        width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
         if self.brush_cursor is not None:
-            master_pen = self.brush_cursor.pen()
-            master_pen.setWidthF(pen_width)
-            self.brush_cursor.setPen(master_pen)
-        return pen_width
+            pen = self.brush_cursor.pen()
+            pen.setWidthF(width)
+            self.brush_cursor.setPen(pen)
+        return width
 
     def set_allow_cursor_preview(self, state):
         self.allow_cursor_preview = state
@@ -217,6 +279,9 @@ class ViewStrategy(LayerCollectionHandler):
 
     def set_master_image_np(self, img):
         self.set_master_image(self.numpy_to_qimage(img))
+        if self.brush_cursor is None:
+            self.setup_brush_cursor()
+        self.show_master()
 
     def numpy_to_qimage(self, array):
         if array is None:
@@ -319,33 +384,51 @@ class ViewStrategy(LayerCollectionHandler):
         self.update_brush_cursor()
         self.update_cursor_pen_width()
 
-    def setup_outline_style(self):
-        self.brush_cursor.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
-                                      gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()))
-        self.brush_cursor.setBrush(Qt.NoBrush)
-
     def setup_simple_brush_style(self, center_x, center_y, radius):
         gradient = create_default_brush_gradient(center_x, center_y, radius, self.brush)
         self.brush_cursor.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
                                       gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()))
         self.brush_cursor.setBrush(QBrush(gradient))
 
-    def setup_brush_cursor(self):
-        if not self.brush:
-            return
-        scene = self.get_master_scene()
+    def create_circle(self, scene, line_style=Qt.SolidLine):
         for item in scene.items():
             if isinstance(item, QGraphicsEllipseItem) and item != self.brush_preview:
                 scene.removeItem(item)
-        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), 1)
+        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
+        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), pen_width, line_style)
+        brush = Qt.NoBrush
+        scene_center = scene.sceneRect().center()
+        brush_cursor = scene.addEllipse(
+            scene_center.x(), scene_center.y(),
+            self.brush.size, self.brush.size, pen, brush)
+        brush_cursor.setZValue(1000)
+        brush_cursor.hide()
+        return brush_cursor
+
+    def create_alt_circle(self, scene, line_style=Qt.SolidLine):
+        for item in scene.items():
+            if isinstance(item, BrushCursor) and item != self.brush_preview:
+                scene.removeItem(item)
+        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
+        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), pen_width, line_style)
         brush = Qt.NoBrush
-        self.brush_cursor = scene.addEllipse(
-            0, 0, self.brush.size, self.brush.size, pen, brush)
-        self.brush_cursor.setZValue(1000)
-        self.brush_cursor.hide()
+        scene_center = scene.sceneRect().center()
+        brush_cursor = BrushCursor(
+            scene_center.x(), scene_center.y(),
+            self.brush.size, pen, brush
+        )
+        brush_cursor.setZValue(1000)
+        brush_cursor.hide()
+        scene.addItem(brush_cursor)
+        return brush_cursor
+
+    def setup_brush_cursor(self):
+        if not self.brush:
+            return
+        self.brush_cursor = self.create_circle(self.get_master_scene())
 
     def update_brush_cursor(self):
-        if self.empty() or not self.brush_cursor or not self.isVisible():
+        if self.empty() or self.brush_cursor is None or not self.isVisible():
             return
         self.update_cursor_pen_width()
         master_view = self.get_master_view()
@@ -359,7 +442,6 @@ class ViewStrategy(LayerCollectionHandler):
         self.brush_cursor.setRect(scene_pos.x() - radius, scene_pos.y() - radius, size, size)
         allow_cursor_preview = self.display_manager.allow_cursor_preview()
         if self.cursor_style == 'preview':
-            self.setup_outline_style()
             if allow_cursor_preview:
                 self.brush_cursor.hide()
                 pos = QCursor.pos()
@@ -371,9 +453,7 @@ class ViewStrategy(LayerCollectionHandler):
                 self.brush_preview.update(scene_pos, int(size))
         else:
             self.brush_preview.hide()
-            if self.cursor_style == 'outline':
-                self.setup_outline_style()
-            else:
+            if self.cursor_style != 'outline':
                 self.setup_simple_brush_style(scene_pos.x(), scene_pos.y(), radius)
         if not self.brush_cursor.isVisible():
             self.brush_cursor.show()
@@ -427,7 +507,6 @@ class ViewStrategy(LayerCollectionHandler):
     def keyReleaseEvent(self, event):
         if self.empty():
             return
-        self.update_brush_cursor()
         if event.key() == Qt.Key_Space:
             self.space_pressed = False
             if not self.scrolling:

{shinestacker-1.5.0.dist-info → shinestacker-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.5.0
+Version: 1.5.1
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0

{shinestacker-1.5.0.dist-info → shinestacker-1.5.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 shinestacker/__init__.py,sha256=uq2fjAw2z_6TpH3mOcWFZ98GoEPRsNhTAK8N0MMm_e8,448
-shinestacker/_version.py,sha256=XyInpe-Rlf1hgwkiRXtR0uPYm4ZwRFpgchjcpZZ9Pms,21
+shinestacker/_version.py,sha256=oU1lLCdhmPP8CUfgzMFfhCPjCfk4eDfd8WSwOfXNBOk,21
 shinestacker/algorithms/__init__.py,sha256=1FwVJ3w9GGbFFkjYJRUedTvcdE4j0ieSgaH9RC9iCY4,877
 shinestacker/algorithms/align.py,sha256=mb44u-YxZI1TTSHz81nRpX_2c8awlOhnGrK0LyfTQeQ,33543
 shinestacker/algorithms/align_auto.py,sha256=pJetw6zZEWQLouzcelkI8gD4cPiOp887ePXzVbm0E6Q,3800
@@ -22,16 +22,17 @@ shinestacker/algorithms/vignetting.py,sha256=gJOv-FN3GnTgaVn70W_6d-qbw3WmqinDiO9
 shinestacker/algorithms/white_balance.py,sha256=PMKsBtxOSn5aRr_Gkx1StHS4eN6kBN2EhNnhg4UG24g,501
 shinestacker/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shinestacker/app/about_dialog.py,sha256=pkH7nnxUP8yc0D3vRGd1jRb5cwi1nDVbQRk_OC9yLk8,4144
+shinestacker/app/args.py,sha256=TlfMR5GBd6Zz9wZNrN7CGJ1_hm1FnLZn5EoP5mkRHrk,776
 shinestacker/app/gui_utils.py,sha256=fSpkwPXTON_l676UHdAnJNrGq7BPbSlPOiHpOF_LZaI,2519
 shinestacker/app/help_menu.py,sha256=g8lKG_xZmXtNQaC3SIRzyROKVWva_PLEgZsQWh6zUcQ,499
-shinestacker/app/main.py,sha256=JRfobAg_stqk7FZbGWNQChfdQHRzMXqFzVXe1gOci_I,10459
+shinestacker/app/main.py,sha256=dcitc5vwIIyIXeDfZwQnC7KHRCdd3FaVJWyaU8mK86c,10935
 shinestacker/app/open_frames.py,sha256=bsu32iJSYJQLe_tQQbvAU5DuMDVX6MRuNdE7B5lojZc,1488
-shinestacker/app/project.py,sha256=oopOiqU6bOK1cQdpot88z49KbKrlB-LAz_q4-8Iui0U,2819
-shinestacker/app/retouch.py,sha256=dpSozNWSxL6wIO0SMjoviDbXZbbfRN_rVLjeL324c54,2527
+shinestacker/app/project.py,sha256=X98pK_mMtE_NefTUZfebEaP1YCsVY97hcQD4bSxuNyY,2777
+shinestacker/app/retouch.py,sha256=wlk-tHaei5YAFinGZWyzBopUhUqyxMT6jSH-4DMEwo8,2659
 shinestacker/config/__init__.py,sha256=aXxi-LmAvXd0daIFrVnTHE5OCaYeK1uf1BKMr7oaXQs,197
 shinestacker/config/config.py,sha256=eBko2D3ADhLTIm9X6hB_a_WsIjwgfE-qmBVkhP1XSvc,1636
 shinestacker/config/constants.py,sha256=EEdr7pZg4JpbIjUWaP7kJQfTuBB85FN739myDNAfn8A,8301
-shinestacker/config/gui_constants.py,sha256=YigJ5pRKjzjQKAN-ulosS6zLfnTj2BQESvVIvqXNzjA,2786
+shinestacker/config/gui_constants.py,sha256=Aqan-AdUjtlARXpsefQvWW2uKVv1tvwc0gfKyo7xud4,2787
 shinestacker/core/__init__.py,sha256=IUEIx6SQ3DygDEHN3_E6uKpHjHtUa4a_U_1dLd_8yEU,484
 shinestacker/core/colors.py,sha256=kr_tJA1iRsdck2JaYDb2lS-codZ4Ty9gdu3kHfiWvuM,1340
 shinestacker/core/core_utils.py,sha256=1LYj19Dfc9jZN9-4dlf1paximDH5WZYa7DXvKr7R7QY,1719
@@ -50,7 +51,7 @@ shinestacker/gui/gui_logging.py,sha256=kiZcrC2AFYCWgPZo0O5SKw-E5cFrezwf4anS3HjPu
 shinestacker/gui/gui_run.py,sha256=zr7x4BVmM0n_ZRsSEaJVVKvHSWHuwhftgkUvgeg90gU,15767
 shinestacker/gui/main_window.py,sha256=5k_9TiZT9idKCmovUFYpUTSEQQj-DMQrlyq9dAgY1MU,24800
 shinestacker/gui/menu_manager.py,sha256=b5Cxh6uddOlio8i7fRISbGDJI-oe0ds6LIF5dWM7leI,11263
-shinestacker/gui/new_project.py,sha256=VSUaq1xm9CR0gimKHRKfCdQOQ-ErE1sxGmu6x14nlAQ,16113
+shinestacker/gui/new_project.py,sha256=z8e3EhRMB-KtoPwYQSiKLSOQ2dS0-Okm7zVw21B7zy8,16391
 shinestacker/gui/project_controller.py,sha256=W4sbBGEPVtfF9F1rC-6Y0oKLq_y94HuFBvZRj87xNKQ,16272
 shinestacker/gui/project_converter.py,sha256=Gmna0HwbvACcXiX74TaQYumif8ZV8sZ2APLTMM-L1mU,7436
 shinestacker/gui/project_editor.py,sha256=lSgQ42IoaobHs-NQQWT88Qhg5l7nu5ejxAO5VgIupr8,25498
@@ -73,7 +74,7 @@ shinestacker/retouch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 shinestacker/retouch/base_filter.py,sha256=gvRGvhOhhWS05jKOXyNdMnia3b7rscQqR8-xnySIWFc,10260
 shinestacker/retouch/brush.py,sha256=dzD2FzSpBIPdJRmTZobcrQ1FrVd3tF__ZPnUplNE72s,357
 shinestacker/retouch/brush_gradient.py,sha256=F5SFhyzl8YTMqjJU3jK8BrIlLCYLUvITd5wz3cQE4xk,1453
-shinestacker/retouch/brush_preview.py,sha256=03x7Hh-5g4JEQgBCK5mGUtVDtiOnJPOdU1JgeUJhGaA,4945
+shinestacker/retouch/brush_preview.py,sha256=cOFVMCbEsgR_alzmr_-LLghtGU_unrE-hAjLHcvrZAY,5484
 shinestacker/retouch/brush_tool.py,sha256=8uVncTA375uC3Nhp2YM0eZjpOR-nN47i2eGjN8tJzOU,8714
 shinestacker/retouch/denoise_filter.py,sha256=TDUHzhRKlKvCa3D5SCYCZKTpjcl81kGwmONsgSDtO1k,440
 shinestacker/retouch/display_manager.py,sha256=wwbX4n7ulg53fM3E5QL5YEb5IFV0jN8za6yfYc74anA,8624
@@ -81,24 +82,24 @@ shinestacker/retouch/exif_data.py,sha256=LF-fRXW-reMq-xJ_QRE5j8DC2LVGKIlC6MR3QbC
 shinestacker/retouch/file_loader.py,sha256=z02-A8_uDZxayI1NFTxT2GVUvEBWStchX9hlN1o5-0U,4784
 shinestacker/retouch/filter_manager.py,sha256=SdYIZkZBUvuB6wDG0moGWav5sfEvIcB9ioUJR5wJFts,388
 shinestacker/retouch/icon_container.py,sha256=6gw1HO1bC2FrdB4dc_iH81DQuLjzuvRGksZ2hKLT9yA,585
-shinestacker/retouch/image_editor_ui.py,sha256=0EW-jnKrQz9Z_xLS51AltWul7lHst4fAvubiWNH-g2o,33456
+shinestacker/retouch/image_editor_ui.py,sha256=ifrlHafXdELwCXoVfUiSM7jcz3O6qH7z2WjNpNPEmUs,33505
 shinestacker/retouch/image_view_status.py,sha256=bdIhsXiYXm7eyjkTGWkw5PRShzaF_by-g7daqgmhwjM,1858
-shinestacker/retouch/image_viewer.py,sha256=jkFVuBxWxoZqtaOS8N1R8iZ9WnyGfKGdczEdET2KTWU,4452
-shinestacker/retouch/io_gui_handler.py,sha256=Upt8VWwDUrB-UnqCI54SQQwfR4w9kfznCdRL2UwupWQ,12010
+shinestacker/retouch/image_viewer.py,sha256=D7feFlaZkR2nzJ9VcKcVg8lYPS7AMjA_uxJs9L099kQ,4412
+shinestacker/retouch/io_gui_handler.py,sha256=BRQ5eSt1tCMDYtOqxfdYGhx2BLCrncfNrNLGuWIy5Rk,11873
 shinestacker/retouch/io_manager.py,sha256=JUAA--AK0mVa1PTErJTnBFjaXIle5Qs7Ow0Wkd8at0o,2437
 shinestacker/retouch/layer_collection.py,sha256=fZlGrkm9-Ycc7AOzFSpImhafiTieBeCZRk-UlvlFHbo,5819
-shinestacker/retouch/overlaid_view.py,sha256=NoFEwokTqbx41xnzYEHS0xhprHEAd2pRlH5NRAHxc2Y,7960
-shinestacker/retouch/shortcuts_help.py,sha256=EDxwR7MZwUC9NHLjvqAlh5iEHT9g3g8Tzl18VUGErI4,4130
-shinestacker/retouch/sidebyside_view.py,sha256=d9Pc2P_apTd0krsERIuEVc8RYBxiXs5tC7X9__t8TBc,18883
+shinestacker/retouch/overlaid_view.py,sha256=0V6Y0wVmf7vPzhB4O9BSF8UwBnw0RdBdYCt_tHD4vls,8478
+shinestacker/retouch/shortcuts_help.py,sha256=BFWTT5QvodqMhqa_9LI25hZqjICfckgyWG4fGrGzvnM,4283
+shinestacker/retouch/sidebyside_view.py,sha256=We4hY_ZGwINPVPHACPGYFPaiU3Khpax7Sf9Xur317FA,17358
 shinestacker/retouch/transformation_manager.py,sha256=NSHGUF-JFv4Y81gSvizjQCTp49TLo1so7c0WoUElO08,1812
 shinestacker/retouch/undo_manager.py,sha256=cKUkqnJtnJ-Hq-LQs5Bv49FC6qkG6XSw9oCVySJ8jS0,4312
 shinestacker/retouch/unsharp_mask_filter.py,sha256=uFnth8fpZFGhdIgJCnS8x5v6lBQgJ3hX0CBke9pFXeM,3510
-shinestacker/retouch/view_strategy.py,sha256=ex_bNym9pBXk9GDcpZr1vh4sJXx4ytrzavLRkHzeEXc,21234
+shinestacker/retouch/view_strategy.py,sha256=5AiSYH_FkeIhaUMtQwZ3v1_8r6KckvOYPFoufEtw12Y,23877
 shinestacker/retouch/vignetting_filter.py,sha256=MA97rQkSL0D-Nh-n2L4AiPR064RoTROkvza4tw84g9U,3658
 shinestacker/retouch/white_balance_filter.py,sha256=glMBYlmrF-i_OrB3sGUpjZE6X4FQdyLC4GBy2bWtaFc,6056
-shinestacker-1.5.0.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
-shinestacker-1.5.0.dist-info/METADATA,sha256=FXzUo0Sa94vwqOVxvbUHFIeRrjRvGgNMqnmUgooYcIY,6978
-shinestacker-1.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shinestacker-1.5.0.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
-shinestacker-1.5.0.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
-shinestacker-1.5.0.dist-info/RECORD,,
+shinestacker-1.5.1.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
+shinestacker-1.5.1.dist-info/METADATA,sha256=FrhfVRsmH4sx7-cQxDajn-zZinLt-UIhhHf2xYZNzvM,6978
+shinestacker-1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shinestacker-1.5.1.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
+shinestacker-1.5.1.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
+shinestacker-1.5.1.dist-info/RECORD,,