shinestacker 1.5.4__py3-none-any.whl → 1.6.0__py3-none-any.whl

shinestacker/gui/action_config_dialog.py

@@ -2,87 +2,29 @@
 # pylint: disable=E0606, W0718, R1702, W0102, W0221, R0914, C0302
 import os
 import traceback
-from PySide6.QtCore import Qt, QTimer
-from PySide6.QtWidgets import (QWidget, QPushButton, QHBoxLayout, QLabel, QScrollArea, QMessageBox,
-                               QStackedWidget, QFormLayout, QDialog)
+from PySide6.QtCore import QTimer
+from PySide6.QtWidgets import QWidget, QLabel, QMessageBox, QStackedWidget
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. algorithms.align import validate_align_config
-from .base_form_dialog import create_form_layout
 from . action_config import (
     DefaultActionConfigurator,
     FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
     FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO, FIELD_REF_IDX
 )
 from .folder_file_selection import FolderFileSelectionWidget
+from .config_dialog import ConfigDialog
 
 
-class ActionConfigDialog(QDialog):
+class ActionConfigDialog(ConfigDialog):
     def __init__(self, action, current_wd, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle(f"Configure {action.type_name}")
-        self.form_layout = create_form_layout(self)
-        self.current_wd = current_wd
         self.action = action
-        scroll_area = QScrollArea()
-        scroll_area.setWidgetResizable(True)
-        container_widget = QWidget()
-        self.container_layout = QFormLayout(container_widget)
-        self.container_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
-        self.container_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
-        self.container_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
-        self.container_layout.setLabelAlignment(Qt.AlignLeft)
-        self.configurator = self.get_configurator(action.type_name)
-        self.configurator.create_form(self.container_layout, action)
-        scroll_area.setWidget(container_widget)
-        button_box = QHBoxLayout()
-        ok_button = QPushButton("OK")
-        ok_button.setFocus()
-        cancel_button = QPushButton("Cancel")
-        reset_button = QPushButton("Reset")
-        button_box.addWidget(ok_button)
-        button_box.addWidget(cancel_button)
-        button_box.addWidget(reset_button)
-        reset_button.clicked.connect(self.reset_to_defaults)
-        self.form_layout.addRow(scroll_area)
-        self.form_layout.addRow(button_box)
-        QTimer.singleShot(0, self.adjust_dialog_size)
-        ok_button.clicked.connect(self.accept)
-        cancel_button.clicked.connect(self.reject)
-
-    def adjust_dialog_size(self):
-        screen_geometry = self.screen().availableGeometry()
-        screen_height = screen_geometry.height()
-        screen_width = screen_geometry.width()
-        scroll_area = self.findChild(QScrollArea)
-        container_widget = scroll_area.widget()
-        container_size = container_widget.sizeHint()
-        container_height = container_size.height()
-        container_width = container_size.width()
-        button_row_height = 50  # Approx height of button row
-        margins_height = 40  # Approx. height of margins
-        total_height_needed = container_height + button_row_height + margins_height
-        if total_height_needed < screen_height * 0.8:
-            width = max(container_width + 40, 600)
-            height = total_height_needed
-            self.resize(width, height)
-            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        else:
-            max_height = int(screen_height * 0.9)
-            width = max(container_width + 40, 600)
-            width = min(width, int(screen_width * 0.9))
-            self.resize(width, max_height)
-            self.setMaximumHeight(max_height)
-            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-            self.setMinimumHeight(min(max_height, 500))
-            self.setMinimumWidth(width)
-        self.center_on_screen()
-
-    def center_on_screen(self):
-        screen_geometry = self.screen().availableGeometry()
-        center_point = screen_geometry.center()
-        frame_geometry = self.frameGeometry()
-        frame_geometry.moveCenter(center_point)
-        self.move(frame_geometry.topLeft())
+        self.current_wd = current_wd
+        super().__init__(f"Configure {action.type_name}", parent)
+
+    def create_form_content(self):
+        self.configurator = self.get_configurator(self.action.type_name)
+        self.configurator.create_form(self.container_layout, self.action)
 
     def get_configurator(self, action_type):
         configurators = {
@@ -102,7 +44,8 @@ class ActionConfigDialog(QDialog):
 
     def accept(self):
         if self.configurator.update_params(self.action.params):
-            self.parent().mark_as_modified(True, "Modify Configuration")
+            if hasattr(self.parent(), 'mark_as_modified'):
+                self.parent().mark_as_modified(True, "Modify Configuration")
             super().accept()
 
     def reset_to_defaults(self):
@@ -111,7 +54,7 @@ class ActionConfigDialog(QDialog):
             builder.reset_to_defaults()
 
     def expert(self):
-        return self.parent().expert_options
+        return AppConfig.get('expert_options')
 
 
 class JobConfigurator(DefaultActionConfigurator):
@@ -329,7 +272,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
         max_threads = self.add_field_to_layout(
             q_pyramid.layout(), 'pyramid_max_threads', FIELD_INT, 'Max num. of cores',
             expert=True,
-            required=False, default=constants.DEFAULT_PY_MAX_THREADS,
+            required=False, default=AppConfig.get('focus_stack_params')['max_threads'],
             min_val=1, max_val=64)
         tile_size = self.add_field_to_layout(
             q_pyramid.layout(), 'pyramid_tile_size', FIELD_INT, 'Tile size (px)',
@@ -490,7 +433,7 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
             default=True)
         self.add_field(
             'max_threads', FIELD_INT, 'Max num. of cores',
-            required=False, default=constants.DEFAULT_MAX_FWK_THREADS,
+            required=False, default=AppConfig.get('combined_actions_params')['max_threads'],
             expert=True,
             min_val=1, max_val=64)
         self.add_field(
@@ -757,7 +700,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
             min_val=1.0, max_val=64.0)
         max_threads = self.add_field_to_layout(
             layout, 'max_threads', FIELD_INT, 'Max num. of cores',
-            required=False, default=constants.DEFAULT_ALIGN_MAX_THREADS,
+            required=False, default=AppConfig.get('align_frames_params')['max_threads'],
             min_val=1, max_val=64)
         chunk_submit = self.add_field_to_layout(
             layout, 'chunk_submit', FIELD_BOOL, 'Submit in chunks',

shinestacker/gui/config_dialog.py

@@ -0,0 +1,78 @@
+# pylint: disable=C0114, C0115, C0116, E0611
+from abc import abstractmethod
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtWidgets import QWidget, QPushButton, QHBoxLayout, QScrollArea, QFormLayout, QDialog
+from .base_form_dialog import create_form_layout
+
+
+class ConfigDialog(QDialog):
+    def __init__(self, title, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        self.form_layout = create_form_layout(self)
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+        container_widget = QWidget()
+        self.container_layout = QFormLayout(container_widget)
+        self.container_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        self.container_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+        self.container_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.container_layout.setLabelAlignment(Qt.AlignLeft)
+        scroll_area.setWidget(container_widget)
+        button_box = QHBoxLayout()
+        self.ok_button = QPushButton("OK")
+        self.ok_button.setFocus()
+        self.cancel_button = QPushButton("Cancel")
+        self.reset_button = QPushButton("Reset")
+        button_box.addWidget(self.ok_button)
+        button_box.addWidget(self.cancel_button)
+        button_box.addWidget(self.reset_button)
+        self.reset_button.clicked.connect(self.reset_to_defaults)
+        self.ok_button.clicked.connect(self.accept)
+        self.cancel_button.clicked.connect(self.reject)
+        self.form_layout.addRow(scroll_area)
+        self.form_layout.addRow(button_box)
+        QTimer.singleShot(0, self.adjust_dialog_size)
+        self.create_form_content()
+
+    @abstractmethod
+    def create_form_content(self):
+        pass
+
+    def adjust_dialog_size(self):
+        screen_geometry = self.screen().availableGeometry()
+        screen_height = screen_geometry.height()
+        screen_width = screen_geometry.width()
+        scroll_area = self.findChild(QScrollArea)
+        container_widget = scroll_area.widget()
+        container_size = container_widget.sizeHint()
+        container_height = container_size.height()
+        container_width = container_size.width()
+        button_row_height = 50  # Approx height of button row
+        margins_height = 40  # Approx. height of margins
+        total_height_needed = container_height + button_row_height + margins_height
+        if total_height_needed < screen_height * 0.8:
+            width = max(container_width + 40, 600)
+            height = total_height_needed
+            self.resize(width, height)
+            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
+        else:
+            max_height = int(screen_height * 0.9)
+            width = max(container_width + 40, 600)
+            width = min(width, int(screen_width * 0.9))
+            self.resize(width, max_height)
+            self.setMaximumHeight(max_height)
+            scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+            self.setMinimumHeight(min(max_height, 500))
+            self.setMinimumWidth(width)
+        self.center_on_screen()
+
+    def center_on_screen(self):
+        screen_geometry = self.screen().availableGeometry()
+        center_point = screen_geometry.center()
+        frame_geometry = self.frameGeometry()
+        frame_geometry.moveCenter(center_point)
+        self.move(frame_geometry.topLeft())
+
+    def reset_to_defaults(self):
+        pass

shinestacker/gui/main_window.py

@@ -7,6 +7,7 @@ from PySide6.QtGui import QGuiApplication, QAction, QIcon
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, QMessageBox,
                                QSplitter, QToolBar, QMenu, QMainWindow)
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. core.core_utils import running_under_windows, running_under_macos
 from .colors import ColorPalette
 from .project_model import Project
@@ -86,7 +87,6 @@ class MainWindow(QMainWindow, LogManager):
         self._windows = []
         self._workers = []
         self.retouch_callback = None
-        self.expert_options = False
         self.job_list().setStyleSheet(LIST_STYLE_SHEET)
         self.action_list().setStyleSheet(LIST_STYLE_SHEET)
         self.menu_manager.add_menus()
@@ -441,12 +441,12 @@ class MainWindow(QMainWindow, LogManager):
             return True
         return False
 
-    def toggle_expert_options(self):
-        self.expert_options = self.menu_manager.expert_options_action.isChecked()
+    def handle_config(self):
+        self.menu_manager.expert_options_action.setChecked(
+            AppConfig.get('expert_options'))
 
-    def set_expert_options(self):
-        self.menu_manager.expert_options_action.setChecked(True)
-        self.expert_options = True
+    def toggle_expert_options(self):
+        AppConfig.set('expert_options', self.menu_manager.expert_options_action.isChecked())
 
     def before_thread_begins(self):
         self.menu_manager.run_job_action.setEnabled(False)

shinestacker/gui/menu_manager.py

@@ -5,6 +5,7 @@ from PySide6.QtCore import Signal, QObject
 from PySide6.QtGui import QAction, QIcon
 from PySide6.QtWidgets import QMenu, QComboBox
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .recent_file_manager import RecentFileManager
 
 
@@ -131,6 +132,7 @@ class MenuManager(QObject):
         menu = self.menubar.addMenu("&View")
         self.expert_options_action = self.action("Expert Options")
         self.expert_options_action.setCheckable(True)
+        self.expert_options_action.setChecked(AppConfig.get('expert_options'))
         menu.addAction(self.expert_options_action)
 
     def add_job_menu(self):

shinestacker/gui/new_project.py

@@ -7,6 +7,7 @@ from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
 from .. config.gui_constants import gui_constants
 from .. config.constants import constants
+from .. config.app_config import AppConfig
 from .. algorithms.utils import read_img, extension_tif_jpg
 from .. algorithms.stack import get_bunches
 from .folder_file_selection import FolderFileSelectionWidget
@@ -31,7 +32,7 @@ class NewProjectDialog(BaseFormDialog):
         self.selected_filenames = []
 
     def expert(self):
-        return self.parent().expert_options
+        return AppConfig.get('expert_options')
 
     def add_bold_label(self, label):
         label = QLabel(label)

shinestacker/gui/project_controller.py

@@ -155,9 +155,9 @@ class ProjectController(QObject):
         if dialog.exec() == QDialog.Accepted:
             self.save_actions_set_enabled(True)
             self.project_editor.reset_undo()
-            input_folder = dialog.get_input_folder().split('/')
-            working_path = '/'.join(input_folder[:-1])
-            input_path = input_folder[-1]
+            input_folder = dialog.get_input_folder()
+            working_path = os.path.dirname(input_folder)
+            input_path = os.path.basename(input_folder)
             selected_filenames = dialog.get_selected_filenames()
             if dialog.get_noise_detection():
                 job_noise = ActionConfig(
@@ -210,13 +210,15 @@ class ProjectController(QObject):
                 focus_pyramid_name = f'{input_path}-focus-stack-pyramid'
                 focus_pyramid = ActionConfig(constants.ACTION_FOCUSSTACK,
                                              {'name': focus_pyramid_name,
-                                              'stacker': constants.STACK_ALGO_PYRAMID})
+                                              'stacker': constants.STACK_ALGO_PYRAMID,
+                                              'exif_path': input_path})
                 job.add_sub_action(focus_pyramid)
             if dialog.get_focus_stack_depth_map():
                 focus_depth_map_name = f'{input_path}-focus-stack-depth-map'
                 focus_depth_map = ActionConfig(constants.ACTION_FOCUSSTACK,
                                                {'name': focus_depth_map_name,
-                                                'stacker': constants.STACK_ALGO_DEPTH_MAP})
+                                                'stacker': constants.STACK_ALGO_DEPTH_MAP,
+                                                'exif_path': input_path})
                 job.add_sub_action(focus_depth_map)
             if dialog.get_multi_layer():
                 multi_input_path = []
@@ -231,7 +233,7 @@ class ProjectController(QObject):
                 multi_layer = ActionConfig(
                     constants.ACTION_MULTILAYER,
                     {'name': f'{input_path}-multi-layer',
-                        'input_path': constants.PATH_SEPARATOR.join(multi_input_path)})
+                     'input_path': constants.PATH_SEPARATOR.join(multi_input_path)})
                 job.add_sub_action(multi_layer)
             self.add_job_to_project(job)
             self.project_editor.set_modified(True)

shinestacker/gui/project_model.py

@@ -1,12 +1,27 @@
 # pylint: disable=C0114, C0115, C0116, R0911
 from copy import deepcopy
 from .. config.constants import constants
+from .. config.app_config import AppConfig
+
+
+TYPE_NAME_APP_CONFIG_MAP = {
+    constants.ACTION_COMBO: 'combined_actions_params',
+    constants.ACTION_ALIGNFRAMES: 'align_frames_params',
+    constants.ACTION_FOCUSSTACK: 'focus_stack_params',
+    constants.ACTION_FOCUSSTACKBUNCH: 'focus_stack_bunch_params'
+}
 
 
 class ActionConfig:
     def __init__(self, type_name: str, params=None, parent=None):
         self.type_name = type_name
-        self.params = params or {}
+        app_config_params_key = TYPE_NAME_APP_CONFIG_MAP.get(type_name, '')
+        if app_config_params_key != '':
+            self.params = AppConfig.get(app_config_params_key, {})
+        else:
+            self.params = {}
+        if params:
+            self.params = {**self.params, **params}
         self.parent = parent
         self.sub_actions: list[ActionConfig] = []
 

shinestacker/gui/recent_file_manager.py

@@ -1,30 +1,12 @@
 # pylint: disable=C0114, C0115, C0116, E0611
 import os
-from PySide6.QtCore import QStandardPaths
+from .. config.settings import StdPathFile
 
 
-class RecentFileManager:
+class RecentFileManager(StdPathFile):
     def __init__(self, filename, max_entries=10):
-        self.filename = filename
+        super().__init__(filename)
         self.max_entries = max_entries
-        self._config_dir = None
-
-    def get_config_dir(self):
-        if self._config_dir is None:
-            config_dir = QStandardPaths.writableLocation(QStandardPaths.AppConfigLocation)
-            if not config_dir:
-                if os.name == 'nt':  # Windows
-                    config_dir = os.path.join(os.environ.get('APPDATA', ''), 'ShineStacker')
-                elif os.name == 'posix':  # macOS and Linux
-                    config_dir = os.path.expanduser('~/.config/shinestacker')
-                else:
-                    config_dir = os.path.join(os.path.expanduser('~'), '.shinestacker')
-            os.makedirs(config_dir, exist_ok=True)
-            self._config_dir = config_dir
-        return self._config_dir
-
-    def get_file_path(self):
-        return os.path.join(self.get_config_dir(), self.filename)
 
     def get_files(self):
         file_path = self.get_file_path()

shinestacker/retouch/display_manager.py

@@ -3,8 +3,9 @@ import numpy as np
 from PySide6.QtWidgets import (QWidget, QListWidgetItem, QVBoxLayout, QLabel, QInputDialog,
                                QAbstractItemView)
 from PySide6.QtGui import QPixmap, QImage
-from PySide6.QtCore import Qt, QObject, QTimer, QSize, Signal
+from PySide6.QtCore import Qt, QObject, QTimer, QSize, Signal, QThread
 from .. config.gui_constants import gui_constants
+from .. config.app_config import AppConfig
 from .layer_collection import LayerCollectionHandler
 
 
@@ -23,6 +24,32 @@ class ClickableLabel(QLabel):
     # pylint: enable=C0103
 
 
+class ThumbnailWorker(QThread):
+    thumbnail_ready = Signal(object)
+
+    def __init__(self, layer_data):
+        super().__init__()
+        self.layer_data = layer_data
+
+    def run(self):
+        if self.layer_data is None:
+            self.thumbnail_ready.emit(None)
+            return
+        source_layer = (self.layer_data // 256).astype(np.uint8) \
+            if self.layer_data.dtype == np.uint16 else self.layer_data
+        if not source_layer.flags.c_contiguous:
+            source_layer = np.ascontiguousarray(source_layer)
+        height, width = source_layer.shape[:2]
+        if self.layer_data.ndim == 3 and source_layer.shape[-1] == 3:
+            qimg = QImage(source_layer.data, width, height, 3 * width, QImage.Format_RGB888)
+        else:
+            qimg = QImage(source_layer.data, width, height, width, QImage.Format_Grayscale8)
+        thumbnail = QPixmap.fromImage(
+            qimg.scaledToWidth(
+                gui_constants.UI_SIZES['thumbnail_width'], Qt.SmoothTransformation))
+        self.thumbnail_ready.emit(thumbnail)
+
+
 class DisplayManager(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
 
@@ -36,8 +63,10 @@ class DisplayManager(QObject, LayerCollectionHandler):
         self.view_mode = 'master'
         self.needs_update = False
         self.update_timer = QTimer()
-        self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
+        self.update_timer.setInterval(AppConfig.get('display_refresh_time'))
         self.update_timer.timeout.connect(self.process_pending_updates)
+        self.thumbnail_worker = None
+        self.thumbnail_update_pending = False
 
     def process_pending_updates(self):
         if self.needs_update:
@@ -77,7 +106,22 @@ class DisplayManager(QObject, LayerCollectionHandler):
         if self.has_no_master_layer():
             self._clear_master_thumbnail()
         else:
-            self._set_master_thumbnail(self.create_thumbnail(self.master_layer()))
+            self._start_async_thumbnail_generation()
+
+    def _start_async_thumbnail_generation(self):
+        if self.thumbnail_worker and self.thumbnail_worker.isRunning():
+            self.thumbnail_update_pending = True
+            return
+        self.thumbnail_worker = ThumbnailWorker(self.master_layer())
+        self.thumbnail_worker.thumbnail_ready.connect(self._on_thumbnail_ready)
+        self.thumbnail_worker.start()
+
+    def _on_thumbnail_ready(self, thumbnail):
+        if thumbnail is not None:
+            self._set_master_thumbnail(thumbnail)
+        if self.thumbnail_update_pending:
+            self.thumbnail_update_pending = False
+            self._start_async_thumbnail_generation()
 
     def _clear_master_thumbnail(self):
         self.master_thumbnail_label.clear()
@@ -172,14 +216,12 @@ class DisplayManager(QObject, LayerCollectionHandler):
         if self.has_no_master_layer():
             return
         self.image_viewer.update_master_display()
-        self.image_viewer.refresh_display()
         self.update_master_thumbnail()
 
     def refresh_current_view(self):
         if self.number_of_layers() == 0:
             return
         self.image_viewer.update_current_display()
-        self.image_viewer.refresh_display()
 
     def start_temp_view(self):
         if self.view_mode == 'master':

shinestacker/retouch/image_editor_ui.py

@@ -6,6 +6,7 @@ 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.app_config import AppConfig
 from .. config.gui_constants import gui_constants
 from .. gui.recent_file_manager import RecentFileManager
 from .image_viewer import ImageViewer
@@ -184,6 +185,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         def change_layer_item(item):
             layer_idx = self.thumbnail_list.row(item)
             self.change_layer(layer_idx)
+            self.display_manager.highlight_thumbnail(layer_idx)
 
         self.thumbnail_list.itemClicked.connect(change_layer_item)
         self.thumbnail_list.setStyleSheet("""
@@ -236,6 +238,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
                                  self.flow_slider)
         self.image_viewer.set_brush(self.brush_tool.brush)
         self.image_viewer.set_preview_brush(self.brush_tool.brush)
+        self.image_viewer.status.set_zoom_factor_requested.connect(self.handle_set_zoom_factor)
         self.brush_tool.update_brush_thumb()
         self.io_gui_handler.setup_ui(self.display_manager, self.image_viewer)
         menubar = self.menuBar()
@@ -434,7 +437,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         view_menu.addAction(self.toggle_view_master_individual_action)
         view_menu.addSeparator()
 
-        self.set_strategy('overlaid')
+        self.set_strategy(AppConfig.get('view_strategy'))
 
         sort_asc_action = QAction("Sort Layers A-Z", self)
         sort_asc_action.setProperty("requires_file", True)
@@ -471,6 +474,8 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         help_menu.setObjectName("Help")
         shortcuts_help_action = QAction("Shortcuts and Mouse", self)
 
+        self.zoom_factor_label = QLabel("")
+        self.statusBar().addPermanentWidget(self.zoom_factor_label)
         self.statusBar().showMessage("Shine Stacker ready.", 2000)
 
         def shortcuts_help():
@@ -488,6 +493,10 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.set_enabled_file_open_close_actions(False)
         self.installEventFilter(self)
 
+    def handle_config(self):
+        self.set_strategy(AppConfig.get('view_strategy'))
+        self.display_manager.update_timer.setInterval(AppConfig.get('display_refresh_time'))
+
     def set_enabled_view_toggles(self, enabled):
         self.view_master_action.setEnabled(enabled)
         self.view_individual_action.setEnabled(enabled)
@@ -700,6 +709,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.io_gui_handler.close_file()
             self.set_master_layer(None)
             self.mark_as_modified(False)
+            self.zoom_factor_label.setText("")
 
     def set_view_master(self):
         self.display_manager.set_view_master()
@@ -752,3 +762,6 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.brush_tool.increase_brush_size()
         else:
             self.brush_tool.decrease_brush_size()
+
+    def handle_set_zoom_factor(self, zoom_factor):
+        self.zoom_factor_label.setText(f"zoom: {zoom_factor:.1%}")

shinestacker/retouch/image_view_status.py

@@ -1,9 +1,11 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902
-from PySide6.QtCore import QObject, QRectF
+from PySide6.QtCore import QObject, QRectF, Signal
 from PySide6.QtGui import QPixmap
 
 
 class ImageViewStatus(QObject):
+    set_zoom_factor_requested = Signal(float)
+
     def __init__(self, parent=None):
         super().__init__(parent)
         self.pixmap_master = QPixmap()
@@ -53,6 +55,7 @@ class ImageViewStatus(QObject):
 
     def set_zoom_factor(self, zoom_factor):
         self.zoom_factor = zoom_factor
+        self.set_zoom_factor_requested.emit(zoom_factor)
 
     def set_min_scale(self, min_scale):
         self.min_scale = min_scale

shinestacker/retouch/sidebyside_view.py

@@ -61,6 +61,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.master_view.setFocusPolicy(Qt.NoFocus)
         self.current_brush_cursor = None
         self.last_color_update_time_current = 0
+        self._updating_scrollbars = False
 
     def setup_layout(self):
         raise NotImplementedError("Subclasses must implement setup_layout")
@@ -78,14 +79,25 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.master_view.mouse_moved.connect(self.handle_master_mouse_move)
         self.master_view.mouse_released.connect(self.handle_master_mouse_release)
         self.master_view.gesture_event.connect(self.handle_gesture_event)
+
+        def sync_scrollbars(source, target):
+            if not self._updating_scrollbars:
+                self._updating_scrollbars = True
+                target.setValue(source.value())
+                self._updating_scrollbars = False
+
         self.current_view.horizontalScrollBar().valueChanged.connect(
-            self.master_view.horizontalScrollBar().setValue)
+            lambda value: sync_scrollbars(self.current_view.horizontalScrollBar(),
+                                          self.master_view.horizontalScrollBar()))
         self.current_view.verticalScrollBar().valueChanged.connect(
-            self.master_view.verticalScrollBar().setValue)
+            lambda value: sync_scrollbars(self.current_view.verticalScrollBar(),
+                                          self.master_view.verticalScrollBar()))
         self.master_view.horizontalScrollBar().valueChanged.connect(
-            self.current_view.horizontalScrollBar().setValue)
+            lambda value: sync_scrollbars(self.master_view.horizontalScrollBar(),
+                                          self.current_view.horizontalScrollBar()))
         self.master_view.verticalScrollBar().valueChanged.connect(
-            self.current_view.verticalScrollBar().setValue)
+            lambda value: sync_scrollbars(self.master_view.verticalScrollBar(),
+                                          self.current_view.verticalScrollBar()))
         self.current_view.wheel_event.connect(self.handle_wheel_event)
         self.master_view.wheel_event.connect(self.handle_wheel_event)
         # pylint: disable=C0103, W0201
@@ -377,28 +389,32 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
     def set_master_image(self, qimage):
         self.status.set_master_image(qimage)
         pixmap = self.status.pixmap_master
-        self.master_view.setSceneRect(QRectF(pixmap.rect()))
+        pixmap_rect = QRectF(pixmap.rect())
+        self.pixmap_item_master.setPos(0, 0)
+        self.master_view.setSceneRect(pixmap_rect)
+        self.master_scene.setSceneRect(pixmap_rect)
         self.pixmap_item_master.setPixmap(pixmap)
-        img_width, img_height, scale_factor = self.setup_view_image(self.master_view, pixmap)
+        _img_width, _img_height, scale_factor = self.setup_view_image(self.master_view, pixmap)
         self.master_view.resetTransform()
         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)),
-                                  max(0, min(center.y(), img_height)))
-        self.master_scene.setSceneRect(QRectF(self.pixmap_item_master.boundingRect()))
         self.center_image(self.master_view)
         self.update_cursor_pen_width()
 
     def set_current_image(self, qimage):
         self.status.set_current_image(qimage)
         pixmap = self.status.pixmap_current
-        self.current_scene.setSceneRect(QRectF(pixmap.rect()))
+        pixmap_rect = QRectF(pixmap.rect())
+        self.pixmap_item_current.setPos(0, 0)
+        self.current_view.setSceneRect(pixmap_rect)
+        self.current_scene.setSceneRect(pixmap_rect)
         self.pixmap_item_current.setPixmap(pixmap)
+        _img_width, _img_height, scale_factor = self.setup_view_image(self.current_view, pixmap)
         self.current_view.resetTransform()
-        self.master_view.scale(self.zoom_factor(), self.zoom_factor())
-        self.current_scene.setSceneRect(QRectF(self.pixmap_item_current.boundingRect()))
+        self.current_view.scale(scale_factor, scale_factor)
+        self.current_view.centerOn(self.pixmap_item_current)
         self.center_image(self.current_view)
+        self.update_cursor_pen_width()
 
     def arrange_images(self):
         if self.status.empty():

shinestacker/retouch/transformation_manager.py

@@ -26,7 +26,6 @@ class TransfromationManager(LayerCollectionHandler):
         self.copy_master_layer()
         self.editor.image_viewer.update_master_display()
         self.editor.image_viewer.update_current_display()
-        self.editor.image_viewer.refresh_display()
         self.editor.display_manager.update_thumbnails()
         self.editor.mark_as_modified()