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

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

@@ -7,7 +7,6 @@ import os
 class _Constants:
     APP_TITLE = "Shine Stacker"
     APP_STRING = "ShineStacker"
-    EXTENSIONS = set(["jpeg", "jpg", "png", "tif", "tiff"])
 
     NUM_UINT8 = 256
     NUM_UINT16 = 65536
@@ -89,9 +88,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 +101,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 +137,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 +150,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 +162,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"

shinestacker/config/settings.py

@@ -39,23 +39,26 @@ DEFAULT_SETTINGS = {
     '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
+        'max_threads': constants.DEFAULT_FWK_MAX_THREADS
     },
     'align_frames_params': {
+        'memory_limit': constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB,
         'max_threads': constants.DEFAULT_ALIGN_MAX_THREADS,
         'detector': constants.DEFAULT_DETECTOR,
         'descriptor': constants.DEFAULT_DESCRIPTOR,
         'match_method': constants.DEFAULT_MATCHING_METHOD
     },
     'focus_stack_params': {
+        'memory_limit': constants.DEFAULT_PY_MEMORY_LIMIT_GB,
         'max_threads': constants.DEFAULT_PY_MAX_THREADS
     },
     'focus_stack_bunch_params': {
+        'memory_limit': constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB,
         'max_threads': constants.DEFAULT_PY_MAX_THREADS
     }
 }
 
-CURRENT_VERSION = 1
+CURRENT_SETTINGS_FILE_VERSION = 1
 
 
 class Settings(StdPathFile):
@@ -66,18 +69,30 @@ class Settings(StdPathFile):
         if Settings._instance is not None:
             raise RuntimeError("Settings is a singleton.")
         super().__init__(filename)
-        self.settings = DEFAULT_SETTINGS
+        self.settings = self._deep_copy_defaults()
         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']
+                    file_settings = json_data['settings']
+                    self._deep_merge_settings(file_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}
+
+    def _deep_copy_defaults(self):
+        return json.loads(json.dumps(DEFAULT_SETTINGS))
+
+    def _deep_merge_settings(self, file_settings):
+        for key, value in file_settings.items():
+            if key in self.settings:
+                if isinstance(value, dict) and isinstance(self.settings[key], dict):
+                    for sub_key, sub_value in value.items():
+                        if sub_key in self.settings[key]:
+                            self.settings[key][sub_key] = sub_value
+                else:
+                    self.settings[key] = value
 
     @classmethod
     def instance(cls, filename="shinestacker-settings.txt"):
@@ -99,7 +114,10 @@ class Settings(StdPathFile):
         try:
             config_dir = self.get_config_dir()
             os.makedirs(config_dir, exist_ok=True)
-            json_data = {'version': CURRENT_VERSION, 'settings': self.settings}
+            json_data = {
+                'version': CURRENT_SETTINGS_FILE_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)

shinestacker/core/exceptions.py

@@ -30,7 +30,7 @@ class AlignmentError(FocusStackError):
     def __init__(self, index, details):
         self.index = index
         self.details = details
-        super().__init__(f"Alignment failed for image {index}: {details}")
+        super().__init__(f"Alignment failed for frame {index}: {details}")
 
 
 class BitDepthError(FocusStackError):

shinestacker/core/framework.py

@@ -197,8 +197,8 @@ class Job(TaskBase):
 
 class SequentialTask(TaskBase):
     def __init__(self, name, enabled=True, **kwargs):
-        self.max_threads = kwargs.pop('max_threads', constants.DEFAULT_MAX_FWK_THREADS)
-        self.chunk_submit = kwargs.pop('chunk_submit', constants.DEFAULT_MAX_FWK_CHUNK_SUBMIT)
+        self.max_threads = kwargs.pop('max_threads', constants.DEFAULT_FWK_MAX_THREADS)
+        self.chunk_submit = kwargs.pop('chunk_submit', constants.DEFAULT_FWK_CHUNK_SUBMIT)
         TaskBase.__init__(self, name, enabled, **kwargs)
         self.total_action_counts = None
         self.current_action_count = None