shinestacker 1.8.0__py3-none-any.whl → 1.8.1__py3-none-any.whl

shinestacker/algorithms/stack_framework.py

@@ -191,7 +191,8 @@ class ImageSequenceManager:
 
 
 class ReferenceFrameTask(SequentialTask, ImageSequenceManager):
-    def __init__(self, name, enabled=True, reference_index=0, step_process=False, **kwargs):
+    def __init__(self, name, enabled=True, reference_index=0,
+                 step_process=constants.DEFAULT_COMBINED_ACTIONS_STEP_PROCESS, **kwargs):
         ImageSequenceManager.__init__(self, name, **kwargs)
         SequentialTask.__init__(self, name, enabled)
         self.ref_idx = reference_index
@@ -276,7 +277,8 @@ class SubAction:
 
 class CombinedActions(ReferenceFrameTask):
     def __init__(self, name, actions=[], enabled=True, **kwargs):
-        ReferenceFrameTask.__init__(self, name, enabled, **kwargs)
+        step_process = kwargs.pop('step_process', constants.DEFAULT_COMBINED_ACTIONS_STEP_PROCESS)
+        ReferenceFrameTask.__init__(self, name, enabled, step_process=step_process, **kwargs)
         self._actions = actions
         self._metadata = (None, None)
 
@@ -294,11 +296,15 @@ class CombinedActions(ReferenceFrameTask):
         self._metadata = get_img_metadata(img)
         return img
 
+    def frame_str(self, idx=-1):
+        if self.run_sequential():
+            idx = self.current_action_count
+        return f"frame {idx + 1}/{self.total_action_counts}"
+
     def run_frame(self, idx, ref_idx):
         input_path = self.input_filepath(idx)
         self.print_message(
-            color_str(f'read input image '
-                      f'{idx + 1}/{self.total_action_counts}, '
+            color_str(f'read input {self.frame_str(idx)}, '
                       f'{os.path.basename(input_path)}', constants.LOG_COLOR_LEVEL_3))
         img = read_img(input_path)
         validate_image(img, *(self._metadata))
@@ -317,20 +323,19 @@ class CombinedActions(ReferenceFrameTask):
                 if img is not None:
                     img = a.run_frame(idx, ref_idx, img)
                 else:
-                    self.sub_message(
-                        color_str(": null input received, action skipped",
+                    self.print_message(
+                        color_str("null input received, action skipped",
                                   constants.LOG_COLOR_ALERT),
                         level=logging.WARNING)
         if img is not None:
             output_path = os.path.join(self.output_full_path(), os.path.basename(input_path))
             self.print_message(
-                color_str(f'write output image '
-                          f'{idx + 1}/{self.total_action_counts}, '
+                color_str(f'write output {self.frame_str(idx)}, '
                           f'{os.path.basename(output_path)}', constants.LOG_COLOR_LEVEL_3))
             write_img(output_path, img)
             return img
         self.print_message(color_str(
-            f"no output file resulted from processing input file: {os.path.basename(input_path)}",
+            f"no output resulted from processing input file: {os.path.basename(input_path)}",
             constants.LOG_COLOR_ALERT), level=logging.WARNING)
         return None
 

shinestacker/algorithms/vignetting.py

@@ -4,7 +4,7 @@ import traceback
 import logging
 import numpy as np
 import matplotlib.pyplot as plt
-from scipy.optimize import curve_fit, fsolve
+from scipy.optimize import curve_fit, bisect
 import cv2
 from .. core.colors import color_str
 from .. core.core_utils import setup_matplotlib_mode
@@ -181,9 +181,22 @@ class Vignetting(SubAction):
             self.process.callback(
                 constants.CALLBACK_SAVE_PLOT, self.process.id,
                 f"{self.process.name}: intensity\nframe {idx_str}", plot_path)
+
         for i, p in enumerate(self.percentiles):
-            self.corrections[i][idx] = fsolve(lambda x: sigmoid_model(x, *params) /
-                                              self.v0 - p, r0_fit)[0]
+            s1 = sigmoid_model(0, *params) / self.v0
+            s2 = sigmoid_model(self.r_max, *params) / self.v0
+            if s1 > p and s2 < p:
+                try:
+                    c = bisect(lambda x: sigmoid_model(x, *params) / self.v0 - p, 0, self.r_max)
+                except Exception as e:
+                    traceback.print_tb(e.__traceback__)
+                    self.process.sub_message(color_str(f": {str(e).lower()}", "yellow"),
+                                             level=logging.WARNING)
+            elif s1 <= p:
+                c = 0
+            else:
+                c = self.r_max
+            self.corrections[i][idx] = c
         self.process.print_message(
             color_str(f"{self.process.idx_tot_str(idx)}: correct vignetting", "cyan"))
         return correct_vignetting(

shinestacker/app/settings_dialog.py

@@ -1,13 +1,174 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0903, E0611, R0902
+# pylint: disable=C0114, C0115, C0116, E0611, R0913, R0917, E1121
+from abc import ABC, abstractmethod
 from PySide6.QtCore import Signal
-from PySide6.QtWidgets import QFrame, QLabel, QCheckBox, QComboBox, QDoubleSpinBox, QSpinBox
+from PySide6.QtWidgets import QLabel, QCheckBox, QComboBox, QDoubleSpinBox, QSpinBox
 from .. config.settings import Settings
 from .. config.constants import constants
 from .. config.gui_constants import gui_constants
 from .. gui.config_dialog import ConfigDialog
+from .. gui.action_config import add_tab, create_tab_widget
 from .. gui.action_config_dialog import AlignFramesConfigBase
 
 
+class BaseParameter(ABC):
+    def __init__(self, key, label, tooltip=""):
+        self.key = key
+        self.label = label
+        self.tooltip = tooltip
+        self.widget = None
+
+    @abstractmethod
+    def create_widget(self, parent):
+        pass
+
+    @abstractmethod
+    def get_value(self):
+        pass
+
+    @abstractmethod
+    def set_value(self, value):
+        pass
+
+    @abstractmethod
+    def set_default(self):
+        pass
+
+
+class NestedParameter(BaseParameter):
+    def __init__(self, parent_key, key, label, tooltip=""):
+        super().__init__(key, label, tooltip)
+        self.parent_key = parent_key
+
+    def get_nested_value(self, settings):
+        return settings.get(self.parent_key).get(self.key)
+
+    def set_nested_value(self, settings, value):
+        nested_dict = settings.get(self.parent_key).copy()
+        nested_dict[self.key] = value
+        settings.set(self.parent_key, nested_dict)
+
+
+class CheckBoxParameter(BaseParameter):
+    def __init__(self, key, label, default_value, tooltip=""):
+        super().__init__(key, label, tooltip)
+        self.default_value = default_value
+
+    def create_widget(self, parent):
+        self.widget = QCheckBox(parent)
+        if self.tooltip:
+            self.widget.setToolTip(self.tooltip)
+        return self.widget
+
+    def get_value(self):
+        return self.widget.isChecked()
+
+    def set_value(self, value):
+        self.widget.setChecked(value)
+
+    def set_default(self):
+        self.widget.setChecked(self.default_value)
+
+
+class SpinBoxParameter(BaseParameter):
+    def __init__(self, key, label, default_value, min_val, max_val, step=1, tooltip=""):
+        super().__init__(key, label, tooltip)
+        self.default_value = default_value
+        self.min_val = min_val
+        self.max_val = max_val
+        self.step = step
+
+    def create_widget(self, parent):
+        self.widget = QSpinBox(parent)
+        self.widget.setRange(self.min_val, self.max_val)
+        self.widget.setSingleStep(self.step)
+        if self.tooltip:
+            self.widget.setToolTip(self.tooltip)
+        return self.widget
+
+    def get_value(self):
+        return self.widget.value()
+
+    def set_value(self, value):
+        self.widget.setValue(value)
+
+    def set_default(self):
+        self.widget.setValue(self.default_value)
+
+
+class DoubleSpinBoxParameter(SpinBoxParameter):
+    def create_widget(self, parent):
+        self.widget = QDoubleSpinBox(parent)
+        self.widget.setRange(self.min_val, self.max_val)
+        self.widget.setSingleStep(self.step)
+        if self.tooltip:
+            self.widget.setToolTip(self.tooltip)
+        return self.widget
+
+
+class ComboBoxParameter(BaseParameter):
+    def __init__(self, key, label, default_value, options, tooltip=""):
+        super().__init__(key, label, tooltip)
+        self.default_value = default_value
+        self.options = options
+
+    def create_widget(self, parent):
+        self.widget = QComboBox(parent)
+        for display_text, data in self.options:
+            self.widget.addItem(display_text, data)
+        if self.tooltip:
+            self.widget.setToolTip(self.tooltip)
+        return self.widget
+
+    def get_value(self):
+        return self.widget.itemData(self.widget.currentIndex())
+
+    def set_value(self, value):
+        idx = self.widget.findData(value)
+        if idx >= 0:
+            self.widget.setCurrentIndex(idx)
+
+    def set_default(self):
+        idx = self.widget.findData(self.default_value)
+        if idx >= 0:
+            self.widget.setCurrentIndex(idx)
+
+
+class CallbackComboBoxParameter(ComboBoxParameter):
+    def __init__(self, key, label, default_value, options, tooltip="", on_change=None):
+        super().__init__(key, label, default_value, options, tooltip)
+        self.on_change = on_change
+
+    def create_widget(self, parent):
+        widget = super().create_widget(parent)
+        if self.on_change:
+            widget.currentIndexChanged.connect(self.on_change)
+        return widget
+
+
+class NestedSpinBoxParameter(SpinBoxParameter, NestedParameter):
+    def __init__(self, parent_key, key, label, default_value, min_val, max_val, step=1, tooltip=""):
+        SpinBoxParameter.__init__(
+            self, key, label, default_value, min_val, max_val, step, tooltip)
+        NestedParameter.__init__(
+            self, parent_key, key, label, tooltip)
+
+
+class NestedDoubleSpinBoxParameter(DoubleSpinBoxParameter, NestedParameter):
+    def __init__(self, parent_key, key, label, default_value, min_val, max_val, step=1, tooltip=""):
+        DoubleSpinBoxParameter.__init__(
+            self, key, label, default_value, min_val, max_val, step, tooltip)
+        NestedParameter.__init__(
+            self, parent_key, key, label, tooltip)
+
+
+class NestedCallbackComboBoxParameter(CallbackComboBoxParameter, NestedParameter):
+    def __init__(self, parent_key, key, label, default_value,
+                 options, tooltip="", on_change=None):
+        CallbackComboBoxParameter.__init__(
+            self, key, label, default_value, options, tooltip, on_change)
+        NestedParameter.__init__(self, parent_key, key, label, tooltip)
+
+
 class SettingsDialog(ConfigDialog, AlignFramesConfigBase):
     update_project_config_requested = Signal()
     update_retouch_config_requested = Signal()
@@ -17,163 +178,144 @@ class SettingsDialog(ConfigDialog, AlignFramesConfigBase):
         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.detector = None
-        self.descriptor = None
-        self.matching_method = 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
+        self.project_parameters = []
+        self.retouch_parameters = []
+        self._init_parameters()
         super().__init__("Settings", parent)
 
+    def _init_parameters(self):
+        if self.project_settings:
+            self.project_parameters = [
+                CheckBoxParameter(
+                    'expert_options', 'Expert options:',
+                    constants.DEFAULT_EXPERT_OPTIONS),
+                NestedSpinBoxParameter(
+                    'combined_actions_params', 'max_threads',
+                    'Combined actions, max num. of cores:',
+                    constants.DEFAULT_FWK_MAX_THREADS, 0, 64),
+                NestedDoubleSpinBoxParameter(
+                    'align_frames_params', 'memory_limit',
+                    'Align frames, mem. limit (approx., GBytes):',
+                    constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB, 1.0, 64.0, 1.0),
+                NestedSpinBoxParameter(
+                    'align_frames_params', 'max_threads',
+                    'Align frames, max num. of cores:',
+                    constants.DEFAULT_ALIGN_MAX_THREADS, 0, 64),
+                NestedCallbackComboBoxParameter(
+                    'align_frames_params', 'detector', 'Detector:',
+                    constants.DEFAULT_DETECTOR, [(d, d) for d in constants.VALID_DETECTORS],
+                    tooltip=self.DETECTOR_DESCRIPTOR_TOOLTIPS['detector'],
+                    on_change=self.change_match_config_settings),
+                NestedCallbackComboBoxParameter(
+                    'align_frames_params', 'descriptor', 'Descriptor:',
+                    constants.DEFAULT_DESCRIPTOR, [(d, d) for d in constants.VALID_DESCRIPTORS],
+                    tooltip=self.DETECTOR_DESCRIPTOR_TOOLTIPS['descriptor'],
+                    on_change=self.change_match_config_settings),
+                NestedCallbackComboBoxParameter(
+                    'align_frames_params', 'match_method', 'Match method:',
+                    constants.DEFAULT_MATCHING_METHOD,
+                    list(zip(self.MATCHING_METHOD_OPTIONS, constants.VALID_MATCHING_METHODS)),
+                    tooltip=self.DETECTOR_DESCRIPTOR_TOOLTIPS['match_method'],
+                    on_change=self.change_match_config_settings),
+                NestedDoubleSpinBoxParameter(
+                    'focus_stack_params', 'memory_limit',
+                    'Focus stacking, mem. limit (approx., GBytes):',
+                    constants.DEFAULT_PY_MEMORY_LIMIT_GB, 1.0, 64.0, 1.0),
+                NestedSpinBoxParameter(
+                    'focus_stack_params', 'max_threads', 'Focus stacking, max. num. of cores:',
+                    constants.DEFAULT_PY_MAX_THREADS, 0, 64),
+            ]
+        if self.retouch_settings:
+            self.retouch_parameters = [
+                ComboBoxParameter(
+                    'view_strategy', 'View strategy:',
+                    constants.DEFAULT_VIEW_STRATEGY,
+                    [
+                        ("Overlaid", "overlaid"),
+                        ("Side by side", "sidebyside"),
+                        ("Top-Bottom", "topbottom")
+                    ]),
+                DoubleSpinBoxParameter(
+                    'min_mouse_step_brush_fraction', 'Min. mouse step in brush units:',
+                    gui_constants.DEFAULT_MIN_MOUSE_STEP_BRUSH_FRACTION, 0, 1, 0.02),
+                SpinBoxParameter(
+                    'paint_refresh_time', 'Paint refresh time:',
+                    gui_constants.DEFAULT_PAINT_REFRESH_TIME, 0, 1000),
+                SpinBoxParameter(
+                    'display_refresh_time', 'Display refresh time:',
+                    gui_constants.DEFAULT_DISPLAY_REFRESH_TIME, 0, 200),
+                SpinBoxParameter(
+                    'cursor_update_time', 'Cursor refresh time:',
+                    gui_constants.DEFAULT_CURSOR_UPDATE_TIME, 0, 50),
+            ]
+
     def create_form_content(self):
+        self.tab_widget = create_tab_widget(self.container_layout)
         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)
+            project_tab_layout = add_tab(self.tab_widget, "Project Settings")
+            self.create_project_settings(project_tab_layout)
         if self.retouch_settings:
-            self.create_retouch_settings()
+            retouch_tab_layout = add_tab(self.tab_widget, "Retouch Settings")
+            self.create_retouch_settings(retouch_tab_layout)
 
-    def create_project_settings(self):
-        label = QLabel("Project settings")
+    def create_project_settings(self, layout=None):
+        if layout is None:
+            layout = self.container_layout
+        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)
-
-        def change_match_config():
-            self.change_match_config(
-                self.detector, self.descriptor,
-                self. matching_method, self.show_info)
-
-        self.detector = QComboBox()
-        self.detector.addItems(constants.VALID_DETECTORS)
-        self.descriptor = QComboBox()
-        self.descriptor.addItems(constants.VALID_DESCRIPTORS)
-        self.matching_method = QComboBox()
+        layout.addRow(label)
+        for param in self.project_parameters:
+            widget = param.create_widget(self)
+            param.set_value(self._get_current_value(param))
+            layout.addRow(param.label, widget)
         self.info_label = QLabel()
         self.info_label.setStyleSheet("color: orange; font-style: italic;")
-        self.matching_method = QComboBox()
-        for k, v in zip(self.MATCHING_METHOD_OPTIONS, constants.VALID_MATCHING_METHODS):
-            self.matching_method.addItem(k, v)
-        self.detector.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['detector'])
-        self.descriptor.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['descriptor'])
-        self.matching_method.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['match_method'])
-        self.detector.currentIndexChanged.connect(change_match_config)
-        self.descriptor.currentIndexChanged.connect(change_match_config)
-        self.matching_method.currentIndexChanged.connect(change_match_config)
-        self.container_layout.addRow('Detector:', self.detector)
-        self.container_layout.addRow('Descriptor:', self.descriptor)
-        self.container_layout.addRow(self.info_label)
-        self.container_layout.addRow('Match method:', self.matching_method)
-
-        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")
+        layout.addRow(self.info_label)
+
+    def create_retouch_settings(self, layout=None):
+        if layout is None:
+            layout = self.container_layout
+        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)
+        layout.addRow(label)
+        for param in self.retouch_parameters:
+            widget = param.create_widget(self)
+            param.set_value(self._get_current_value(param))
+            layout.addRow(param.label, widget)
+
+    def _get_current_value(self, param):
+        if isinstance(param, NestedParameter):
+            return param.get_nested_value(self.settings)
+        return self.settings.get(param.key)
+
+    def _set_current_value(self, param, value):
+        if isinstance(param, NestedParameter):
+            param.set_nested_value(self.settings, value)
+        else:
+            self.settings.set(param.key, value)
+
+    def change_match_config_settings(self):
+        detector_widget = None
+        descriptor_widget = None
+        matching_method_widget = None
+        for param in self.project_parameters:
+            if (isinstance(param, NestedParameter) and
+                    param.parent_key == 'align_frames_params'):
+                if param.key == 'detector':
+                    detector_widget = param.widget
+                elif param.key == 'descriptor':
+                    descriptor_widget = param.widget
+                elif param.key == 'match_method':
+                    matching_method_widget = param.widget
+        if detector_widget and descriptor_widget and matching_method_widget:
+            self.change_match_config(
+                detector_widget, descriptor_widget, matching_method_widget, self.show_info)
 
     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(),
-                    'detector':
-                        self.descriptor.currentText(),
-                    'descriptor':
-                        self.descriptor.currentText(),
-                    'match_method':
-                        self.matching_method.itemData(self.matching_method.currentIndex())
-                })
-            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())
+        for param in self.project_parameters:
+            self._set_current_value(param, param.get_value())
+        for param in self.retouch_parameters:
+            self._set_current_value(param, param.get_value())
         self.settings.update()
         if self.project_settings:
             self.update_project_config_requested.emit()
@@ -182,32 +324,14 @@ class SettingsDialog(ConfigDialog, AlignFramesConfigBase):
         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.detector.setCurrentText(constants.DEFAULT_DETECTOR)
-            self.descriptor.setCurrentText(constants.DEFAULT_DESCRIPTOR)
-            idx = self.matching_method.findData(constants.DEFAULT_MATCHING_METHOD)
-            if idx >= 0:
-                self.matching_method.setCurrentIndex(idx)
-            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):
+        for param in self.project_parameters:
+            param.set_default()
+        for param in self.retouch_parameters:
+            param.set_default()
+
+
+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)

shinestacker/config/constants.py

@@ -89,9 +89,12 @@ class _Constants:
     DEFAULT_MULTILAYER_FILE_REVERSE_ORDER = True
     MULTILAYER_WARNING_MEM_GB = 1
 
+    DEFAULT_COMBINED_ACTIONS_STEP_PROCESS = True
+
     DEFAULT_PLOTS_PATH = 'plots'
-    DEFAULT_MAX_FWK_THREADS = 8
-    DEFAULT_MAX_FWK_CHUNK_SUBMIT = True
+    DEFAULT_FWK_MEMORY_LIMIT_GB = 8
+    DEFAULT_FWK_MAX_THREADS = 8
+    DEFAULT_FWK_CHUNK_SUBMIT = True
 
     FIELD_SUBSAMPLE_VALUES_1 = [2, 3, 4, 6, 8, 12, 16, 24, 32]
     FIELD_SUBSAMPLE_OPTIONS_1 = [f"1/{n} × 1/{n}" for n in FIELD_SUBSAMPLE_VALUES_1]
@@ -99,7 +102,7 @@ class _Constants:
     FIELD_SUBSAMPLE_OPTIONS = ['Auto', 'Full resolution'] + FIELD_SUBSAMPLE_OPTIONS_1
     FIELD_SUBSAMPLE_DEFAULT = FIELD_SUBSAMPLE_VALUES[0]
 
-    DEFAULT_NOISE_MAP_FILENAME = "noise-map/hot_pixels.png"
+    DEFAULT_NOISE_MAP_FILENAME = "hot_pixels.png"
     DEFAULT_NOISE_MAX_FRAMES = 10
     DEFAULT_MN_KERNEL_SIZE = 3
     INTERPOLATE_MEAN = 'MEAN'
@@ -135,7 +138,7 @@ class _Constants:
     VALID_MATCHING_METHODS = [MATCHING_KNN, MATCHING_NORM_HAMMING]
     VALID_TRANSFORMS = [ALIGN_RIGID, ALIGN_HOMOGRAPHY]
     VALID_BORDER_MODES = [BORDER_CONSTANT, BORDER_REPLICATE, BORDER_REPLICATE_BLUR]
-    VALID_ALIGN_METHODS = [ALIGN_RANSAC, ALIGN_LMEDS]
+    VALID_ESTIMATION_METHODS = [ALIGN_RANSAC, ALIGN_LMEDS]
     NOKNN_METHODS = {'detectors': [DETECTOR_ORB, DETECTOR_SURF, DETECTOR_AKAZE, DETECTOR_BRISK],
                      'descriptors': [DESCRIPTOR_ORB, DESCRIPTOR_AKAZE, DESCRIPTOR_BRISK]}
 
@@ -148,7 +151,7 @@ class _Constants:
     DEFAULT_ALIGN_THRESHOLD = 0.75
     DEFAULT_TRANSFORM = ALIGN_RIGID
     DEFAULT_BORDER_MODE = BORDER_REPLICATE_BLUR
-    DEFAULT_ALIGN_METHOD = 'RANSAC'
+    DEFAULT_ESTIMATION_METHOD = 'RANSAC'
     DEFAULT_RANS_THRESHOLD = 3.0  # px
     DEFAULT_REFINE_ITERS = 100
     DEFAULT_ALIGN_CONFIDENCE = 99.9
@@ -160,12 +163,14 @@ class _Constants:
     DEFAULT_ALIGN_RES_TARGET_MPX = 2
     DEFAULT_ALIGN_FAST_SUBSAMPLING = False
     DEFAULT_ALIGN_MIN_GOOD_MATCHES = 20
+    DEFAULT_PHASE_CORR_FALLBACK = False
     ALIGN_VALID_MODES = ['auto', 'sequential', 'parallel']
     DEFAULT_ALIGN_MODE = 'auto'
     DEFAULT_ALIGN_MEMORY_LIMIT_GB = 8
     DEFAULT_ALIGN_MAX_THREADS = min(os.cpu_count() or 4, 8)
     DEFAULT_ALIGN_CHUNK_SUBMIT = True
     DEFAULT_ALIGN_BW_MATCHING = False
+    DEFAULT_ALIGN_DELTA_MAX = 2
 
     BALANCE_LINEAR = "LINEAR"
     BALANCE_GAMMA = "GAMMA"