shinestacker 1.5.4__tar.gz → 1.6.0__tar.gz

{shinestacker-1.5.4 → shinestacker-1.6.0}/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v1.6.0] -  2025-09.27
+**Few more features and several fixes**
+
+### Added
+- persistent settings dialog to configure app startup options
+- command-line option ```-n``` to prevent opening the "new project" dialog
+- zoom factor display in the status bar
+
+### Fixed
+- ghost brush gradient no longer appears at cursor transitions
+- action and job names are now correctly set in the input dialog
+- image centering fixed in viewport for double-view modes
+- frame highlight works correctly when clicking on a thumbnail
+- exif data is now correctly inserted into stacked output files
+- bug in the retouch undo has been fixed
+
+### Changed
+- cursor updates are now throttled (~60 fps) to improve responsiveness
+- new projects created via dialog save exif data by default
+
+----
+
 ## [v1.5.4] - 2025-09-23
 **Bug fixes**
 

{shinestacker-1.5.4/src/shinestacker.egg-info → shinestacker-1.6.0}/PKG-INFO

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

shinestacker-1.6.0/src/shinestacker/_version.py

@@ -0,0 +1 @@
+__version__ = '1.6.0'

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/algorithms/multilayer.py

@@ -174,7 +174,7 @@ class MultiLayer(TaskBase, ImageSequenceManager):
         if self.exif_path == '':
             self.exif_path = job.action_path(0)
         if self.exif_path != '':
-            self.exif_path = self.working_path + "/" + self.exif_path
+            self.exif_path = os.path.join(self.working_path, self.exif_path)
 
     def run_core(self):
         if isinstance(self.input_full_path(), str):

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/algorithms/stack.py

@@ -1,6 +1,6 @@
 # pylint: disable=C0114, C0115, C0116, R0913, R0917
 import os
-import numpy as np
+import traceback
 from .. config.constants import constants
 from .. core.framework import TaskBase
 from .. core.colors import color_str
@@ -34,13 +34,19 @@ class FocusStackBase(TaskBase, ImageSequenceManager):
             self.sub_message_r(': denoise image')
             stacked_img = denoise(stacked_img, self.denoise_amount, self.denoise_amount)
         write_img(out_filename, stacked_img)
-        if self.exif_path != '' and stacked_img.dtype == np.uint8:
-            self.sub_message_r(': copy exif data')
-            _dirpath, _, fnames = next(os.walk(self.exif_path))
-            fnames = [name for name in fnames if extension_tif_jpg(name)]
-            exif_filename = f"{self.exif_path}/{fnames[0]}"
-            copy_exif_from_file_to_file(exif_filename, out_filename)
-            self.sub_message_r(' ' * 60)
+        if self.exif_path != '':
+            self.sub_message_r(color_str(': copy exif data', constants.LOG_COLOR_LEVEL_3))
+            if not os.path.exists(self.exif_path):
+                raise RuntimeError(f"Path {self.exif_path} does not exist.")
+            try:
+                _dirpath, _, fnames = next(os.walk(self.exif_path))
+                fnames = [name for name in fnames if extension_tif_jpg(name)]
+                exif_filename = os.path.join(self.exif_path, fnames[0])
+                copy_exif_from_file_to_file(exif_filename, out_filename)
+                self.sub_message_r(' ' * 60)
+            except Exception as e:
+                traceback.print_tb(e.__traceback__)
+                raise RuntimeError("Can't copy EXIF data") from e
         if self.plot_stack:
             idx_str = f"{self.frame_count + 1:04d}" if self.frame_count >= 0 else ''
             name = f"{self.name}: {self.stack_algo.name()}"
@@ -51,11 +57,13 @@ class FocusStackBase(TaskBase, ImageSequenceManager):
             self.frame_count += 1
 
     def init(self, job, working_path=''):
+        if working_path == '':
+            working_path = job.working_path
         ImageSequenceManager.init(self, job)
         if self.exif_path is None:
             self.exif_path = job.action_path(0)
         if self.exif_path != '':
-            self.exif_path = working_path + "/" + self.exif_path
+            self.exif_path = os.path.join(working_path, self.exif_path)
 
 
 def get_bunches(collection, n_frames, n_overlap):

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/app/args_parser_opts.py

@@ -3,6 +3,10 @@
 def add_project_arguments(parser):
     parser.add_argument('-x', '--expert', action='store_true', help='''
 expert options are visible by default.
+''')
+    parser.add_argument('-n', '--no-new-project', dest='new-project',
+                        action='store_false', default=True, help='''
+Do not open new project dialog at startup (default: open).
 ''')
 
 

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/app/gui_utils.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0116, E0611
+# pylint: disable=C0114, C0116, E0611, R0913, R0917
 import os
 import sys
 from PySide6.QtCore import QCoreApplication, QProcess
@@ -6,6 +6,7 @@ from PySide6.QtGui import QAction
 from shinestacker.config.constants import constants
 from shinestacker.config.config import config
 from shinestacker.app.about_dialog import show_about_dialog
+from shinestacker.app.settings_dialog import show_settings_dialog
 
 
 def disable_macos_special_menu_items():
@@ -40,11 +41,18 @@ def disable_macos_special_menu_items():
         QProcess.startDetached("pkill", ["-u", user, "-f", "SystemUIServer"])
 
 
-def fill_app_menu(app, app_menu):
+def fill_app_menu(app, app_menu, project_settings, retouch_settings,
+                  handle_project_config, handle_retouch_config):
     about_action = QAction(f"About {constants.APP_STRING}", app)
     about_action.triggered.connect(lambda: show_about_dialog(app))
     app_menu.addAction(about_action)
     app_menu.addSeparator()
+    settings_action = QAction("Settings", app)
+    settings_action.triggered.connect(lambda: show_settings_dialog(
+        app, project_settings, retouch_settings,
+        handle_project_config, handle_retouch_config))
+    app_menu.addAction(settings_action)
+    app_menu.addSeparator()
     if config.DONT_USE_NATIVE_MENU:
         quit_txt, quit_short = "&Quit", "Ctrl+Q"
     else:

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/app/main.py

@@ -140,7 +140,9 @@ class MainApp(QMainWindow):
         app_menu.addAction(self.switch_to_project_action)
         app_menu.addAction(self.switch_to_retouch_action)
         app_menu.addSeparator()
-        fill_app_menu(self, app_menu)
+        fill_app_menu(self, app_menu, True, True,
+                      self.project_window.handle_config,
+                      self.retouch_window.handle_config)
         return app_menu
 
     def quit(self):
@@ -264,7 +266,8 @@ open retouch window at startup instead of project windows.
             main_app.switch_to_retouch()
         else:
             main_app.switch_to_project()
-            QTimer.singleShot(100, main_app.project_window.project_controller.new_project)
+            if args['new-project']:
+                QTimer.singleShot(100, main_app.project_window.project_controller.new_project)
     QTimer.singleShot(100, main_app.setFocus)
     sys.exit(app.exec())
 

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/app/project.py

@@ -30,7 +30,9 @@ class ProjectApp(MainWindow):
 
     def create_menu(self):
         app_menu = QMenu(constants.APP_STRING)
-        fill_app_menu(self, app_menu)
+        fill_app_menu(self, app_menu, True, False,
+                      self.handle_config,
+                      lambda: None)
         return app_menu
 
     def _retouch_callback(self, filename):
@@ -72,7 +74,7 @@ project filename.
     filename = args['filename']
     if filename:
         QTimer.singleShot(100, lambda: window.project_controller.open_project(filename))
-    else:
+    elif args['new-project']:
         QTimer.singleShot(100, window.project_controller.new_project)
     sys.exit(app.exec())
 

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/app/retouch.py

@@ -25,7 +25,9 @@ class RetouchApp(ImageEditorUI):
 
     def create_menu(self):
         app_menu = QMenu(constants.APP_STRING)
-        fill_app_menu(self, app_menu)
+        fill_app_menu(self, app_menu, False, True,
+                      lambda: None,
+                      self.handle_config)
         return app_menu
 
 

shinestacker-1.6.0/src/shinestacker/app/settings_dialog.py

@@ -0,0 +1,171 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0903, E0611, R0902
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QFrame, QLabel, QCheckBox, QComboBox, QDoubleSpinBox, QSpinBox
+from .. gui.config_dialog import ConfigDialog
+from .. config.settings import Settings
+from .. config.constants import constants
+from .. config.gui_constants import gui_constants
+
+
+class SettingsDialog(ConfigDialog):
+    update_project_config_requested = Signal()
+    update_retouch_config_requested = Signal()
+
+    def __init__(self, parent=None, project_settings=True, retouch_settings=True):
+        self.project_settings = project_settings
+        self.retouch_settings = retouch_settings
+        self.settings = Settings.instance()
+        self.expert_options = None
+        self.combined_actions_max_threads = None
+        self.align_frames_max_threads = None
+        self.focus_stack_max_threads = None
+        self.view_strategy = None
+        self.min_mouse_step_brush_fraction = None
+        self.paint_refresh_time = None
+        self.display_refresh_time = None
+        self.cursor_update_time = None
+        super().__init__("Settings", parent)
+
+    def create_form_content(self):
+        if self.project_settings:
+            self.create_project_settings()
+        separator = QFrame()
+        separator.setFrameShape(QFrame.HLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        separator.setLineWidth(1)
+        self.container_layout.addRow(separator)
+        if self.retouch_settings:
+            self.create_retouch_settings()
+
+    def create_project_settings(self):
+        label = QLabel("Project settings")
+        label.setStyleSheet("font-weight: bold")
+        self.container_layout.addRow(label)
+        self.expert_options = QCheckBox()
+        self.expert_options.setChecked(self.settings.get('expert_options'))
+        self.container_layout.addRow("Expert options:", self.expert_options)
+        self.combined_actions_max_threads = QSpinBox()
+        self.combined_actions_max_threads.setRange(0, 64)
+        self.combined_actions_max_threads.setValue(
+            self.settings.get('combined_actions_params')['max_threads'])
+        self.container_layout.addRow("Max num. of cores, combined actions:",
+                                     self.combined_actions_max_threads)
+
+        self.align_frames_max_threads = QSpinBox()
+        self.align_frames_max_threads.setRange(0, 64)
+        self.align_frames_max_threads.setValue(
+            self.settings.get('align_frames_params')['max_threads'])
+        self.container_layout.addRow("Max num. of cores, align frames:",
+                                     self.align_frames_max_threads)
+
+        self.focus_stack_max_threads = QSpinBox()
+        self.focus_stack_max_threads.setRange(0, 64)
+        self.focus_stack_max_threads.setValue(
+            self.settings.get('align_frames_params')['max_threads'])
+        self.container_layout.addRow("Max num. of cores, focus stacking:",
+                                     self.focus_stack_max_threads)
+
+    def create_retouch_settings(self):
+        label = QLabel("Retouch settings")
+        label.setStyleSheet("font-weight: bold")
+        self.container_layout.addRow(label)
+        self.view_strategy = QComboBox()
+        self.view_strategy.addItem("Overlaid", "overlaid")
+        self.view_strategy.addItem("Side by side", "sidebyside")
+        self.view_strategy.addItem("Top-Bottom", "topbottom")
+        idx = self.view_strategy.findData(self.settings.get('view_strategy'))
+        if idx >= 0:
+            self.view_strategy.setCurrentIndex(idx)
+        self.container_layout.addRow("View strategy:", self.view_strategy)
+        self.min_mouse_step_brush_fraction = QDoubleSpinBox()
+        self.min_mouse_step_brush_fraction.setValue(
+            self.settings.get('min_mouse_step_brush_fraction'))
+        self.min_mouse_step_brush_fraction.setRange(0, 1)
+        self.min_mouse_step_brush_fraction.setDecimals(2)
+        self.min_mouse_step_brush_fraction.setSingleStep(0.02)
+        self.container_layout.addRow("Min. mouse step in brush units:",
+                                     self.min_mouse_step_brush_fraction)
+        self.paint_refresh_time = QSpinBox()
+        self.paint_refresh_time.setRange(0, 1000)
+        self.paint_refresh_time.setValue(
+            self.settings.get('paint_refresh_time'))
+        self.container_layout.addRow("Paint refresh time:",
+                                     self.paint_refresh_time)
+        self.display_refresh_time = QSpinBox()
+        self.display_refresh_time.setRange(0, 200)
+        self.display_refresh_time.setValue(
+            self.settings.get('display_refresh_time'))
+        self.container_layout.addRow("Display refresh time:",
+                                     self.display_refresh_time)
+
+        self.cursor_update_time = QSpinBox()
+        self.cursor_update_time.setRange(0, 50)
+        self.cursor_update_time.setValue(
+            self.settings.get('cursor_update_time'))
+        self.container_layout.addRow("Cursor refresh time:",
+                                     self.cursor_update_time)
+
+    def accept(self):
+        if self.project_settings:
+            self.settings.set(
+                'expert_options', self.expert_options.isChecked())
+            self.settings.set(
+                'combined_actions_params', {
+                    'max_threads': self.combined_actions_max_threads.value()
+                })
+            self.settings.set(
+                'align_frames_params', {
+                    'max_threads': self.align_frames_max_threads.value()
+                })
+            self.settings.set(
+                'focus_stack_params', {
+                    'max_threads': self.focus_stack_max_threads.value()
+                })
+            self.settings.set(
+                'focus_stack_bunch:params', {
+                    'max_threads': self.focus_stack_max_threads.value()
+                })
+        if self.retouch_settings:
+            self.settings.set(
+                'view_strategy', self.view_strategy.itemData(self.view_strategy.currentIndex()))
+            self.settings.set(
+                'min_mouse_step_brush_fraction', self.min_mouse_step_brush_fraction.value())
+            self.settings.set(
+                'paint_refresh_time', self.paint_refresh_time.value())
+            self.settings.set(
+                'display_refresh_time', self.display_refresh_time.value())
+            self.settings.set(
+                'cursor_update_time', self.cursor_update_time.value())
+        self.settings.update()
+        if self.project_settings:
+            self.update_project_config_requested.emit()
+        if self.retouch_settings:
+            self.update_retouch_config_requested.emit()
+        super().accept()
+
+    def reset_to_defaults(self):
+        if self.project_settings:
+            self.expert_options.setChecked(constants.DEFAULT_EXPERT_OPTIONS)
+            self.combined_actions_max_threads.setValue(constants.DEFAULT_MAX_FWK_THREADS)
+            self.align_frames_max_threads.setValue(constants.DEFAULT_ALIGN_MAX_THREADS)
+            self.focus_stack_max_threads.setValue(constants.DEFAULT_PY_MAX_THREADS)
+        if self.retouch_settings:
+            idx = self.view_strategy.findData(constants.DEFAULT_VIEW_STRATEGY)
+            if idx >= 0:
+                self.view_strategy.setCurrentIndex(idx)
+            self.min_mouse_step_brush_fraction.setValue(
+                gui_constants.DEFAULT_MIN_MOUSE_STEP_BRUSH_FRACTION)
+            self.paint_refresh_time.setValue(
+                gui_constants.DEFAULT_PAINT_REFRESH_TIME)
+            self.display_refresh_time.setValue(
+                gui_constants.DEFAULT_DISPLAY_REFRESH_TIME)
+            self.cursor_update_time.setValue(
+                gui_constants.DEFAULT_CURSOR_UPDATE_TIME)
+
+
+def show_settings_dialog(parent, project_settings, retouch_settings,
+                         handle_project_config, handle_retouch_config):
+    dialog = SettingsDialog(parent, project_settings, retouch_settings)
+    dialog.update_project_config_requested.connect(handle_project_config)
+    dialog.update_retouch_config_requested.connect(handle_retouch_config)
+    dialog.exec()

shinestacker-1.6.0/src/shinestacker/config/app_config.py

@@ -0,0 +1,30 @@
+# pylint: disable=C0114, C0115, C0116
+from .settings import Settings
+
+
+class AppConfig:
+    _instance = None
+
+    def __init__(self):
+        if AppConfig._instance is not None:
+            raise RuntimeError("AppConfig is a singleton.")
+        self.config = {}
+        Settings.add_observer(self)
+        self.update(Settings.instance().settings)
+
+    def update(self, settings):
+        self.config = {**self.config, **settings}
+
+    @classmethod
+    def instance(cls):
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    @classmethod
+    def get(cls, key, default=None):
+        return cls.instance().config.get(key, default)
+
+    @classmethod
+    def set(cls, key, value):
+        cls.instance().config[key] = value

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/config/constants.py

@@ -236,6 +236,9 @@ class _Constants:
     DEFAULT_PLOT_STACK_BUNCH = True
     DEFAULT_PLOT_STACK = True
 
+    DEFAULT_EXPERT_OPTIONS = False
+    DEFAULT_VIEW_STRATEGY = 'overlaid'
+
     def __setattr__aux(self, name, value):
         raise AttributeError(f"Can't reassign constant '{name}'")
 

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/config/gui_constants.py

@@ -32,8 +32,10 @@ class _GuiConstants:
         'preview_inner': (255, 255, 255, 150)
     }
 
-    MIN_MOUSE_STEP_BRUSH_FRACTION = 0.25
-    PAINT_REFRESH_TIMER = 50  # milliseconds
+    DEFAULT_MIN_MOUSE_STEP_BRUSH_FRACTION = 0.25
+    DEFAULT_PAINT_REFRESH_TIME = 50  # ms
+    DEFAULT_DISPLAY_REFRESH_TIME = 50  # ms
+    DEFAULT_CURSOR_UPDATE_TIME = 16  # ms
 
     THUMB_WIDTH = 120  # px
     THUMB_HEIGHT = 80  # px

shinestacker-1.6.0/src/shinestacker/config/settings.py

@@ -0,0 +1,110 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0903, E0611
+import os
+import json
+import traceback
+import jsonpickle
+from PySide6.QtCore import QStandardPaths
+from .. config.constants import constants
+from .. config.gui_constants import gui_constants
+
+
+class StdPathFile:
+    def __init__(self, filename):
+        self._config_dir = None
+        self.filename = filename
+
+    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)
+
+
+DEFAULT_SETTINGS = {
+    'expert_options': constants.DEFAULT_EXPERT_OPTIONS,
+    'view_strategy': constants.DEFAULT_VIEW_STRATEGY,
+    'paint_refresh_time': gui_constants.DEFAULT_PAINT_REFRESH_TIME,
+    'display_refresh_time': gui_constants.DEFAULT_DISPLAY_REFRESH_TIME,
+    'cursor_update_time': gui_constants.DEFAULT_CURSOR_UPDATE_TIME,
+    'min_mouse_step_brush_fraction': gui_constants.DEFAULT_MIN_MOUSE_STEP_BRUSH_FRACTION,
+    'combined_actions_params': {
+        'max_threads': constants.DEFAULT_MAX_FWK_THREADS
+    },
+    'align_frames_params': {
+        'max_threads': constants.DEFAULT_ALIGN_MAX_THREADS
+    },
+    'focus_stack_params': {
+        'max_threads': constants.DEFAULT_PY_MAX_THREADS
+    },
+    'focus_stack_bunch_params': {
+        'max_threads': constants.DEFAULT_PY_MAX_THREADS
+    }
+}
+
+CURRENT_VERSION = 1
+
+
+class Settings(StdPathFile):
+    _instance = None
+    _observers = []
+
+    def __init__(self, filename):
+        if Settings._instance is not None:
+            raise RuntimeError("Settings is a singleton.")
+        super().__init__(filename)
+        self.settings = DEFAULT_SETTINGS
+        file_path = self.get_file_path()
+        if os.path.isfile(file_path):
+            try:
+                with open(file_path, 'r', encoding="utf-8") as file:
+                    json_data = json.load(file)
+                    settings = json_data['settings']
+            except Exception as e:
+                traceback.print_tb(e.__traceback__)
+                print(f"Can't read file from path {file_path}. Default settings ignored.")
+                settings = {}
+            self.settings = {**self.settings, **settings}
+
+    @classmethod
+    def instance(cls, filename="shinestacker-settings.txt"):
+        if cls._instance is None:
+            cls._instance = cls(filename)
+        return cls._instance
+
+    @classmethod
+    def add_observer(cls, observer):
+        cls._observers.append(observer)
+
+    def set(self, key, value):
+        self.settings[key] = value
+
+    def get(self, key, default=None):
+        return self.settings.get(key, default)
+
+    def update(self):
+        try:
+            config_dir = self.get_config_dir()
+            os.makedirs(config_dir, exist_ok=True)
+            json_data = {'version': CURRENT_VERSION, 'settings': self.settings}
+            json_obj = jsonpickle.encode(json_data)
+            with open(self.get_file_path(), 'w', encoding="utf-8") as f:
+                f.write(json_obj)
+        except IOError as e:
+            raise e
+        for observer in Settings._observers:
+            observer.update(self.settings)
+
+    @classmethod
+    def reset_instance_only_for_testing(cls):
+        cls._instance = None

{shinestacker-1.5.4 → shinestacker-1.6.0}/src/shinestacker/gui/action_config.py

@@ -49,7 +49,7 @@ class FieldBuilder:
         self.fields = {}
 
     def add_field(self, tag, field_type, label,
-                  required=False, add_to_layout=None, **kwargs):
+                  required=False, add_to_layout=None, do_add=True, **kwargs):
         if field_type == FIELD_TEXT:
             widget = self.create_text_field(tag, **kwargs)
         elif field_type == FIELD_ABS_PATH:
@@ -99,9 +99,10 @@ class FieldBuilder:
             'default_value': default_value,
             **kwargs
         }
-        if add_to_layout is None:
-            add_to_layout = self.main_layout
-        add_to_layout.addRow(f"{label}:", widget)
+        if do_add:
+            if add_to_layout is None:
+                add_to_layout = self.main_layout
+            add_to_layout.addRow(f"{label}:", widget)
         return widget
 
     def reset_to_defaults(self):
@@ -499,7 +500,7 @@ class DefaultActionConfigurator(NoNameActionConfigurator):
         name_row = QHBoxLayout()
         name_row.setContentsMargins(0, 0, 0, 0)
         name_label = QLabel(f"{tag} name:")
-        name_field = self.builder.create_text_field('name', required=True)
+        name_field = self.add_field('name', FIELD_TEXT, f"{tag} name", required=False, do_add=False)
         name_row.addWidget(name_label)
         name_row.addWidget(name_field, 1)
         name_row.addStretch()