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

shinestacker/gui/action_config.py

@@ -416,6 +416,29 @@ class FieldBuilder:
         return checkbox
 
 
+def create_tab_layout():
+    tab_layout = QFormLayout()
+    tab_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+    tab_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+    tab_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+    tab_layout.setLabelAlignment(Qt.AlignLeft)
+    return tab_layout
+
+
+def add_tab(tab_widget, title):
+    tab = QWidget()
+    tab_layout = create_tab_layout()
+    tab.setLayout(tab_layout)
+    tab_widget.addTab(tab, title)
+    return tab_layout
+
+
+def create_tab_widget(main_layout):
+    tab_widget = QTabWidget()
+    main_layout.addRow(tab_widget)
+    return tab_widget
+
+
 class NoNameActionConfigurator(ActionConfigurator):
     def __init__(self, current_wd):
         super().__init__(current_wd)
@@ -457,26 +480,6 @@ class NoNameActionConfigurator(ActionConfigurator):
     def add_labelled_row(self, label, widget):
         self.add_row(self.labelled_widget(label, widget))
 
-    def create_tab_widget(self, main_layout):
-        tab_widget = QTabWidget()
-        main_layout.addRow(tab_widget)
-        return tab_widget
-
-    def create_tab_layout(self):
-        tab_layout = QFormLayout()
-        tab_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
-        tab_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
-        tab_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
-        tab_layout.setLabelAlignment(Qt.AlignLeft)
-        return tab_layout
-
-    def add_tab(self, tab_widget, title):
-        tab = QWidget()
-        tab_layout = self.create_tab_layout()
-        tab.setLayout(tab_layout)
-        tab_widget.addTab(tab, title)
-        return tab_layout
-
     def add_field_to_layout(self, main_layout, tag, field_type, label, required=False, **kwargs):
         return self.add_field(tag, field_type, label, required, add_to_layout=main_layout, **kwargs)
 

shinestacker/gui/action_config_dialog.py

@@ -6,9 +6,10 @@ 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.utils import EXTENSIONS_SUPPORTED
 from .. algorithms.align import validate_align_config
 from . action_config import (
-    DefaultActionConfigurator,
+    DefaultActionConfigurator, add_tab, create_tab_layout, create_tab_widget,
     FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
     FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO, FIELD_REF_IDX
 )
@@ -76,10 +77,15 @@ class JobConfigurator(DefaultActionConfigurator):
             input_filepaths = input_filepaths.split(constants.PATH_SEPARATOR)
         self.working_path_label = QLabel(working_path or "Not set")
         self.input_path_label = QLabel(input_path or "Not set")
-        self.input_widget.path_edit.setText('')
         if input_filepaths:
+            full_input_dir = os.path.join(working_path, input_path)
+            self.input_widget.selected_files = [os.path.join(full_input_dir, f)
+                                                for f in input_filepaths]
+            self.input_widget.path_edit.setText(full_input_dir)
             self.input_widget.files_mode_radio.setChecked(True)
         else:
+            full_input_dir = os.path.join(working_path, input_path)
+            self.input_widget.path_edit.setText(full_input_dir)
             self.input_widget.folder_mode_radio.setChecked(False)
         self.input_widget.text_changed_connect(self.update_paths_and_frames)
         self.input_widget.folder_mode_radio.toggled.connect(self.update_paths_and_frames)
@@ -117,7 +123,7 @@ class JobConfigurator(DefaultActionConfigurator):
             return 0
         count = 0
         for filename in os.listdir(path):
-            if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.tif', '.tiff')):
+            if os.path.splitext(filename)[-1][1:].lower() in EXTENSIONS_SUPPORTED:
                 count += 1
         return count
 
@@ -195,10 +201,10 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
 
     def create_form(self, layout, action):
         super().create_form(layout, action)
-        self.tab_widget = self.create_tab_widget(layout)
-        self.general_tab_layout = self.add_tab(self.tab_widget, "General Parameters")
+        self.tab_widget = create_tab_widget(layout)
+        self.general_tab_layout = add_tab(self.tab_widget, "General Parameters")
         self.create_general_tab(self.general_tab_layout)
-        self.algorithm_tab_layout = self.add_tab(self.tab_widget, "Stacking Algorithm")
+        self.algorithm_tab_layout = add_tab(self.tab_widget, "Stacking Algorithm")
         self.create_algorithm_tab(self.algorithm_tab_layout)
 
     def create_general_tab(self, layout):
@@ -225,7 +231,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
             default=constants.STACK_ALGO_DEFAULT)
         q_pyramid, q_depthmap = QWidget(), QWidget()
         for q in [q_pyramid, q_depthmap]:
-            q.setLayout(self.create_tab_layout())
+            q.setLayout(create_tab_layout())
         stacked = QStackedWidget()
         stacked.addWidget(q_pyramid)
         stacked.addWidget(q_depthmap)
@@ -267,7 +273,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
             q_pyramid.layout(), 'pyramid_memory_limit', FIELD_FLOAT,
             'Memory limit (approx., GBytes)',
             expert=True,
-            required=False, default=constants.DEFAULT_PY_MEMORY_LIMIT_GB,
+            required=False, default=AppConfig.get('focus_stack_params')['memory_limit'],
             min_val=1.0, max_val=64.0)
         max_threads = self.add_field_to_layout(
             q_pyramid.layout(), 'pyramid_max_threads', FIELD_INT, 'Max num. of cores',
@@ -366,10 +372,6 @@ class FocusStackBunchConfigurator(FocusStackBaseConfigurator):
         self.add_field_to_layout(
             self.general_tab_layout, 'overlap', FIELD_INT, 'Overlapping frames', required=False,
             default=constants.DEFAULT_OVERLAP, min_val=0, max_val=100)
-        self.add_field_to_layout(
-            self.general_tab_layout, 'scratch_output_dir', FIELD_BOOL,
-            'Scratch output folder before run',
-            required=False, default=True)
         self.add_field_to_layout(
             self.general_tab_layout, 'delete_output_at_end', FIELD_BOOL,
             'Delete output at end of job',
@@ -440,8 +442,7 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
             default=0)
         self.add_field(
             'step_process', FIELD_BOOL, 'Step process', required=False,
-            expert=True,
-            default=True)
+            expert=True, default=constants.DEFAULT_COMBINED_ACTIONS_STEP_PROCESS)
         self.add_field(
             'max_threads', FIELD_INT, 'Max num. of cores',
             required=False, default=AppConfig.get('combined_actions_params')['max_threads'],
@@ -450,7 +451,7 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
         self.add_field(
             'chunk_submit', FIELD_BOOL, 'Submit in chunks',
             expert=True,
-            required=False, default=constants.DEFAULT_MAX_FWK_CHUNK_SUBMIT)
+            required=False, default=constants.DEFAULT_FWK_CHUNK_SUBMIT)
 
 
 class MaskNoiseConfigurator(DefaultActionConfigurator):
@@ -575,14 +576,14 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
         self.detector_field = None
         self.descriptor_field = None
         self.matching_method_field = None
-        self.tab_widget = self.create_tab_widget(layout)
-        feature_layout = self.add_tab(self.tab_widget, "Feature extraction")
+        self.tab_widget = create_tab_widget(layout)
+        feature_layout = add_tab(self.tab_widget, "Feature extraction")
         self.create_feature_tab(feature_layout)
-        transform_layout = self.add_tab(self.tab_widget, "Transform")
+        transform_layout = add_tab(self.tab_widget, "Transform")
         self.create_transform_tab(transform_layout)
-        border_layout = self.add_tab(self.tab_widget, "Border")
+        border_layout = add_tab(self.tab_widget, "Border")
         self.create_border_tab(border_layout)
-        misc_layout = self.add_tab(self.tab_widget, "Miscellanea")
+        misc_layout = add_tab(self.tab_widget, "Miscellanea")
         self.create_miscellanea_tab(misc_layout)
 
     def create_feature_tab(self, layout):
@@ -591,7 +592,6 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
             self.change_match_config(
                 self.detector_field, self.descriptor_field,
                 self. matching_method_field, self.show_info)
-
         self.add_bold_label_to_layout(layout, "Feature identification:")
         self.detector_field = self.add_field_to_layout(
             layout, 'detector', FIELD_COMBO, 'Detector', required=False,
@@ -642,9 +642,9 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
             options=self.TRANSFORM_OPTIONS, values=constants.VALID_TRANSFORMS,
             default=constants.DEFAULT_TRANSFORM)
         method = self.add_field_to_layout(
-            layout, 'align_method', FIELD_COMBO, 'Align method', required=False,
-            options=self.METHOD_OPTIONS, values=constants.VALID_ALIGN_METHODS,
-            default=constants.DEFAULT_ALIGN_METHOD)
+            layout, 'align_method', FIELD_COMBO, 'Estimation method', required=False,
+            options=self.METHOD_OPTIONS, values=constants.VALID_ESTIMATION_METHODS,
+            default=constants.DEFAULT_ESTIMATION_METHOD)
         rans_threshold = self.add_field_to_layout(
             layout, 'rans_threshold', FIELD_FLOAT, 'RANSAC threshold (px)', required=False,
             expert=True,
@@ -689,6 +689,14 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
 
         transform.currentIndexChanged.connect(change_transform)
         change_transform()
+        phase_corr_fallback = self.add_field_to_layout(
+            layout, 'phase_corr_fallback', FIELD_BOOL, "Phase correlation as fallback",
+            required=False, expert=True, default=constants.DEFAULT_PHASE_CORR_FALLBACK)
+        phase_corr_fallback.setToolTip(
+            "Align using phase correlation algorithm if the number of matches\n"
+            "is too low to determine the transformation.\n"
+            "This algorithm is not very precise,\n"
+            "and may help only in case of blurred images.")
         self.add_field_to_layout(
             layout, 'abort_abnormal', FIELD_BOOL, 'Abort on abnormal transf.',
             expert=True,
@@ -723,7 +731,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
                              self.MODE_OPTIONS))[constants.DEFAULT_ALIGN_MODE])
         memory_limit = self.add_field_to_layout(
             layout, 'memory_limit', FIELD_FLOAT, 'Memory limit (approx., GBytes)',
-            required=False, default=constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB,
+            required=False, default=AppConfig.get('align_frames_params')['memory_limit'],
             min_val=1.0, max_val=64.0)
         max_threads = self.add_field_to_layout(
             layout, 'max_threads', FIELD_INT, 'Max num. of cores',
@@ -737,6 +745,10 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
             layout, 'bw_matching', FIELD_BOOL, 'Match using black & white',
             expert=True,
             required=False, default=constants.DEFAULT_ALIGN_BW_MATCHING)
+        delta_max = self.add_field_to_layout(
+            layout, 'delta_max', FIELD_INT, 'Max frames skip',
+            required=False, default=constants.DEFAULT_ALIGN_DELTA_MAX,
+            min_val=1, max_val=128)
 
         def change_mode():
             text = mode.currentText()
@@ -745,6 +757,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase
             max_threads.setEnabled(enabled)
             chunk_submit.setEnabled(enabled)
             bw_matching.setEnabled(enabled)
+            delta_max.setEnabled(enabled)
 
         mode.currentIndexChanged.connect(change_mode)
 

shinestacker/gui/config_dialog.py

@@ -12,6 +12,7 @@ class ConfigDialog(QDialog):
         self.form_layout = create_form_layout(self)
         scroll_area = QScrollArea()
         scroll_area.setWidgetResizable(True)
+        scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
         container_widget = QWidget()
         self.container_layout = QFormLayout(container_widget)
         self.container_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
@@ -19,19 +20,19 @@ class ConfigDialog(QDialog):
         self.container_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
         self.container_layout.setLabelAlignment(Qt.AlignLeft)
         scroll_area.setWidget(container_widget)
-        button_box = QHBoxLayout()
+        self.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.button_box.addWidget(self.ok_button)
+        self.button_box.addWidget(self.cancel_button)
+        self.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)
+        self.form_layout.addRow(self.button_box)
         QTimer.singleShot(0, self.adjust_dialog_size)
         self.create_form_content()
 

shinestacker/gui/folder_file_selection.py

@@ -1,8 +1,9 @@
 # pylint: disable=C0114, C0115, C0116, E0611
 import os
+from PySide6.QtCore import Qt
 from PySide6.QtWidgets import (QWidget, QRadioButton, QButtonGroup, QLineEdit,
                                QPushButton, QHBoxLayout, QVBoxLayout, QFileDialog, QMessageBox)
-from PySide6.QtCore import Qt
+from .. algorithms.utils import EXTENSIONS_GUI_STR
 
 
 class FolderFileSelectionWidget(QWidget):
@@ -73,7 +74,7 @@ class FolderFileSelectionWidget(QWidget):
     def browse_files(self):
         files, _ = QFileDialog.getOpenFileNames(
             self, "Select Input Files", "",
-            "Image files (*.png *.jpg *.jpeg *.tif *.tiff)"
+            f"Image files ({EXTENSIONS_GUI_STR})"
         )
         if files:
             parent_dir = os.path.dirname(files[0])

shinestacker/gui/gui_images.py

@@ -1,14 +1,17 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0718, E1101, C0103
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, E1101, C0103, R0914
 import webbrowser
 import subprocess
 import os
+import numpy as np
+import cv2
 from PySide6.QtWidgets import QSizePolicy, QVBoxLayout, QWidget, QLabel, QStackedWidget
 from PySide6.QtPdf import QPdfDocument
 from PySide6.QtPdfWidgets import QPdfView
 from PySide6.QtCore import Qt, QMargins
-from PySide6.QtGui import QPixmap
+from PySide6.QtGui import QPixmap, QImage
 from .. config.gui_constants import gui_constants
 from .. core.core_utils import running_under_windows, running_under_macos
+from .. algorithms.utils import read_img
 
 
 def open_file(file_path):
@@ -74,7 +77,28 @@ class GuiImageView(QWidget):
         self.image_label.setAlignment(Qt.AlignCenter)
         self.main_layout.addWidget(self.image_label)
         self.setLayout(self.main_layout)
-        pixmap = QPixmap(file_path)
+        try:
+            img = read_img(file_path)
+            height, width = img.shape[:2]
+            scale_factor = gui_constants.GUI_IMG_WIDTH / width
+            new_height = int(height * scale_factor)
+            img = cv2.resize(img, (gui_constants.GUI_IMG_WIDTH, new_height),
+                             interpolation=cv2.INTER_LINEAR)
+        except Exception as e:
+            raise RuntimeError(f"Can't load file: {file_path}.") from e
+        if img.dtype == np.uint16:
+            img = (img // 256).astype(np.uint8)
+        if len(img.shape) == 3:
+            h, w, ch = img.shape
+            bytes_per_line = ch * w
+            rgb_image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            q_img = QImage(rgb_image.data, w, h, bytes_per_line, QImage.Format_RGB888)
+        else:
+            h, w = img.shape
+            bytes_per_line = w
+            q_img = QImage(img.data, w, h, bytes_per_line, QImage.Format_Grayscale8)
+        pixmap = QPixmap.fromImage(q_img)
+        self.image_label.setPixmap(pixmap)
         if pixmap:
             scaled_pixmap = pixmap.scaledToWidth(
                 gui_constants.GUI_IMG_WIDTH, Qt.SmoothTransformation)

shinestacker/gui/gui_run.py

@@ -9,7 +9,7 @@ from PySide6.QtCore import Signal, Slot
 from .. config.constants import constants
 from .. config.gui_constants import gui_constants
 from .colors import RED_BUTTON_STYLE, BLUE_BUTTON_STYLE, BLUE_COMBO_STYLE
-from .. algorithms.utils import extension_jpg_tif_png, extension_pdf
+from .. algorithms.utils import extension_supported, extension_pdf
 from .gui_logging import LogWorker, QTextEditLogger
 from .gui_images import GuiPdfView, GuiImageView, GuiOpenApp
 from .colors import (
@@ -209,7 +209,7 @@ class RunWindow(QTextEditLogger):
         try:
             if extension_pdf(path):
                 image_view = GuiPdfView(path, self)
-            elif extension_jpg_tif_png(path):
+            elif extension_supported(path):
                 image_view = GuiImageView(path, self)
             else:
                 raise RuntimeError(f"Can't visualize file type {os.path.splitext(path)[1]}.")

shinestacker/gui/main_window.py

@@ -318,6 +318,12 @@ class MainWindow(QMainWindow, LogManager):
             edit_config_action.triggered.connect(self.edit_current_action)
             menu.addAction(edit_config_action)
             menu.addSeparator()
+            menu.addAction(self.menu_manager.cut_action)
+            menu.addAction(self.menu_manager.copy_action)
+            menu.addAction(self.menu_manager.paste_action)
+            menu.addAction(self.menu_manager.duplicate_action)
+            menu.addAction(self.menu_manager.delete_element_action)
+            menu.addSeparator()
             menu.addAction(self.menu_manager.run_job_action)
             menu.addAction(self.menu_manager.run_all_jobs_action)
             menu.addSeparator()

shinestacker/gui/menu_manager.py

@@ -123,8 +123,14 @@ class MenuManager(QObject):
         self.undo_action = self.action("&Undo")
         self.undo_action.setEnabled(False)
         menu.addAction(self.undo_action)
-        for name in ["&Cut", "Cop&y", "&Paste", "Duplicate"]:
-            menu.addAction(self.action(name, requires_file=True))
+        self.cut_action = self.action("&Cut", requires_file=True)
+        menu.addAction(self.cut_action)
+        self.copy_action = self.action("Cop&y", requires_file=True)
+        menu.addAction(self.copy_action)
+        self.paste_action = self.action("&Paste", requires_file=True)
+        menu.addAction(self.paste_action)
+        self.duplicate_action = self.action("Duplicate", requires_file=True)
+        menu.addAction(self.duplicate_action)
         self.delete_element_action = self.action("Delete", requires_file=True)
         self.delete_element_action.setEnabled(False)
         menu.addAction(self.delete_element_action)

shinestacker/gui/new_project.py

@@ -8,7 +8,7 @@ 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.utils import read_img, extension_supported
 from .. algorithms.stack import get_bunches
 from .folder_file_selection import FolderFileSelectionWidget
 from .base_form_dialog import BaseFormDialog
@@ -76,21 +76,32 @@ class NewProjectDialog(BaseFormDialog):
         self.focus_stack_depth_map.setChecked(gui_constants.NEW_PROJECT_FOCUS_STACK_DEPTH_MAP)
         self.multi_layer = QCheckBox()
         self.multi_layer.setChecked(gui_constants.NEW_PROJECT_MULTI_LAYER)
+
         step1_group = QGroupBox("1) Select Input")
         step1_layout = QVBoxLayout()
         step1_layout.setContentsMargins(15, 0, 15, 15)
         step1_layout.addWidget(
             QLabel("Select a folder containing "
                    "all your images, or specific image files."))
-        input_form = QFormLayout()
-        input_form.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
-        input_form.setFormAlignment(Qt.AlignLeft)
-        input_form.setLabelAlignment(Qt.AlignLeft)
+        input_layout = QHBoxLayout()
+        input_layout.setContentsMargins(0, 0, 0, 0)
+        input_layout.setSpacing(10)
+        input_label = QLabel("Input:")
+        input_label.setFixedWidth(60)
         self.input_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
+        input_layout.addWidget(input_label)
+        input_layout.addWidget(self.input_widget)
+        frames_layout = QHBoxLayout()
+        frames_layout.setContentsMargins(0, 0, 0, 0)
+        frames_layout.setSpacing(10)
+        frames_label = QLabel("Number of selected frames:")
+        frames_label.setFixedWidth(180)
         self.frames_label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
-        input_form.addRow("Input:", self.input_widget)
-        input_form.addRow("Number of frames: ", self.frames_label)
-        step1_layout.addLayout(input_form)
+        frames_layout.addWidget(frames_label)
+        frames_layout.addWidget(self.frames_label)
+        frames_layout.addStretch()
+        step1_layout.addLayout(input_layout)
+        step1_layout.addLayout(frames_layout)
         step1_group.setLayout(step1_layout)
         self.form_layout.addRow(step1_group)
         step2_group = QGroupBox("2) Basic Options")
@@ -197,7 +208,7 @@ class NewProjectDialog(BaseFormDialog):
                 return 0
             count = 0
             for filename in os.listdir(path):
-                if extension_tif_jpg(filename):
+                if extension_supported(filename):
                     count += 1
             return count
         if self.input_widget.get_selection_mode() == 'files' and \
@@ -262,7 +273,7 @@ class NewProjectDialog(BaseFormDialog):
                 file_path = None
                 for filename in files:
                     full_path = os.path.join(path, filename)
-                    if extension_tif_jpg(full_path):
+                    if extension_supported(full_path):
                         file_path = full_path
                         break
             if file_path is None:
@@ -273,8 +284,8 @@ class NewProjectDialog(BaseFormDialog):
             height, width = img.shape[:2]
             n_bytes = 1 if img.dtype == np.uint8 else 2
             n_bits = 8 if img.dtype == np.uint8 else 16
-            n_gbytes = float(n_bytes * height * width * self.n_image_files) / constants.ONE_GIGA
-            if n_gbytes > 1 and not self.bunch_stack.isChecked():
+            n_gbytes = 3.0 * n_bytes * height * width * self.n_image_files / constants.ONE_GIGA
+            if n_gbytes > 4 and not self.bunch_stack.isChecked():
                 msg = QMessageBox()
                 msg.setStyleSheet("""
                     QMessageBox {

shinestacker/gui/project_controller.py

@@ -14,6 +14,9 @@ from .project_model import Project
 from .project_editor import ProjectEditor
 
 
+CURRENT_PROJECT_FILE_VERSION = 1
+
+
 class ProjectController(QObject):
     update_title_requested = Signal()
     refresh_ui_requested = Signal(int, int)
@@ -162,14 +165,15 @@ class ProjectController(QObject):
             if dialog.get_noise_detection():
                 job_noise = ActionConfig(
                     constants.ACTION_JOB,
-                    {'name': f'{input_path}-detect-noise', 'working_path': working_path,
+                    {'name': f'{input_path}-noise-job', 'working_path': working_path,
                      'input_path': input_path})
+                noise_detection_name = f'{input_path}-detect-noise'
                 noise_detection = ActionConfig(constants.ACTION_NOISEDETECTION,
-                                               {'name': f'{input_path}-detect-noise'})
+                                               {'name': noise_detection_name})
                 job_noise.add_sub_action(noise_detection)
                 self.add_job_to_project(job_noise)
             job_params = {
-                'name': f'{input_path}-focus-stack',
+                'name': f'{input_path}-stack-job',
                 'working_path': working_path,
                 'input_path': input_path
             }
@@ -184,7 +188,10 @@ class ProjectController(QObject):
                     constants.ACTION_COMBO, {'name': preprocess_name})
                 if dialog.get_noise_detection():
                     mask_noise = ActionConfig(
-                        constants.ACTION_MASKNOISE, {'name': 'mask-noise'})
+                        constants.ACTION_MASKNOISE,
+                        {'name': 'mask-noise',
+                         'noise_mask': os.path.join(noise_detection_name,
+                                                    constants.DEFAULT_NOISE_MAP_FILENAME)})
                     combo_action.add_sub_action(mask_noise)
                 if dialog.get_vignetting_correction():
                     vignetting = ActionConfig(
@@ -238,6 +245,7 @@ class ProjectController(QObject):
             self.add_job_to_project(job)
             self.project_editor.set_modified(True)
             self.refresh_ui(0, -1)
+        self.set_enabled_file_open_close_actions_requested.emit(True)
 
     def open_project(self, file_path=False):
         if not self.check_unsaved_changes():
@@ -251,7 +259,7 @@ class ProjectController(QObject):
                 self.set_current_file_path(file_path)
                 with open(self.current_file_path(), 'r', encoding="utf-8") as file:
                     json_obj = json.load(file)
-                project = Project.from_dict(json_obj['project'])
+                project = Project.from_dict(json_obj['project'], json_obj['version'])
                 if project is None:
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
                 self.set_enabled_file_open_close_actions_requested.emit(True)
@@ -313,7 +321,7 @@ class ProjectController(QObject):
     def do_save(self, file_path):
         try:
             json_obj = jsonpickle.encode({
-                'project': self.project().to_dict(), 'version': 1
+                'project': self.project().to_dict(), 'version': CURRENT_PROJECT_FILE_VERSION
             })
             with open(file_path, 'w', encoding="utf-8") as f:
                 f.write(json_obj)

shinestacker/gui/project_editor.py

@@ -1,8 +1,9 @@
 # pylint: disable=C0114, C0115, C0116, R0903, R0904, R1702, R0917, R0913, R0902, E0611, E1131, E1121
 import os
 from dataclasses import dataclass
-from PySide6.QtWidgets import QListWidget, QMessageBox, QDialog, QListWidgetItem, QLabel
-from PySide6.QtCore import Qt, QObject, Signal, QEvent
+from PySide6.QtWidgets import (QListWidget, QMessageBox, QDialog, QListWidgetItem, QLabel,
+                               QSizePolicy)
+from PySide6.QtCore import Qt, QObject, Signal, QEvent, QSize
 from .. config.constants import constants
 from .colors import ColorPalette
 from .action_config_dialog import ActionConfigDialog
@@ -105,6 +106,8 @@ class HandCursorListWidget(QListWidget):
         super().__init__(parent)
         self.setMouseTracking(True)
         self.viewport().setMouseTracking(True)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        self.setWordWrap(False)
 
     def event(self, event):
         if event.type() == QEvent.HoverMove:
@@ -503,6 +506,13 @@ class ProjectEditor(QObject):
                     if action.enabled() \
                     else f"🚫 <span style='color:#{ColorPalette.DARK_RED.hex()};'>{text}</span>"
         label = QLabel(html_text)
+        label.setTextFormat(Qt.RichText)
+        label.setWordWrap(False)
+        label.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
+        label.adjustSize()
+        ideal_width = label.sizeHint().width()
+        widget_list.setItemWidget(item, label)
+        item.setSizeHint(QSize(ideal_width, label.sizeHint().height()))
         widget_list.setItemWidget(item, label)
 
     def add_sub_action(self, type_name):

shinestacker/gui/project_model.py

@@ -62,10 +62,10 @@ class ActionConfig:
         return project_dict
 
     @classmethod
-    def from_dict(cls, data):
+    def from_dict(cls, data, version):
         a = ActionConfig(data['type_name'], data['params'])
         if 'sub_actions' in data.keys():
-            a.sub_actions = [ActionConfig.from_dict(s) for s in data['sub_actions']]
+            a.sub_actions = [ActionConfig.from_dict(s, version) for s in data['sub_actions']]
             for s in a.sub_actions:
                 s.parent = a
         return a
@@ -84,9 +84,9 @@ class Project:
         return [j.to_dict() for j in self.jobs]
 
     @classmethod
-    def from_dict(cls, data):
+    def from_dict(cls, data, version):
         p = Project()
-        p.jobs = [ActionConfig.from_dict(j) for j in data]
+        p.jobs = [ActionConfig.from_dict(j, version) for j in data]
         for j in p.jobs:
             for s in j.sub_actions:
                 s.parent = j

shinestacker/retouch/brush_tool.py

@@ -75,6 +75,26 @@ class BrushTool:
         self.hardness_slider.setValue(val)
         self.update_brush_hardness(val)
 
+    def increase_brush_opacity(self, amount=2):
+        val = min(self.opacity_slider.value() + amount, self.opacity_slider.maximum())
+        self.opacity_slider.setValue(val)
+        self.update_brush_opacity(val)
+
+    def decrease_brush_opacity(self, amount=2):
+        val = max(self.opacity_slider.value() - amount, self.opacity_slider.minimum())
+        self.opacity_slider.setValue(val)
+        self.update_brush_opacity(val)
+
+    def increase_brush_flow(self, amount=2):
+        val = min(self.flow_slider.value() + amount, self.flow_slider.maximum())
+        self.flow_slider.setValue(val)
+        self.update_brush_flow(val)
+
+    def decrease_brush_flow(self, amount=2):
+        val = max(self.flow_slider.value() - amount, self.flow_slider.minimum())
+        self.flow_slider.setValue(val)
+        self.update_brush_flow(val)
+
     def update_brush_hardness(self, hardness):
         self.brush.hardness = hardness
         self.update_brush_thumb()