shinestacker 1.7.0__py3-none-any.whl → 1.8.1__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

@@ -1,5 +1,5 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0913, R0917, R0915, R0912
-# pylint: disable=E0606, W0718, R1702, W0102, W0221, R0914, C0302
+# pylint: disable=E0606, W0718, R1702, W0102, W0221, R0914, C0302, R0903
 import os
 import traceback
 from PySide6.QtCore import QTimer
@@ -8,7 +8,7 @@ from .. config.constants import constants
 from .. config.app_config import AppConfig
 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 +76,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)
@@ -195,10 +200,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):
@@ -214,7 +219,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
             expert=True,
             placeholder='relative to working path')
         self.add_field_to_layout(
-            layout, 'scratch_output_dir', FIELD_BOOL, 'Scratch output dir.',
+            layout, 'scratch_output_dir', FIELD_BOOL, 'Scratch output folder before run',
             required=False, default=True)
 
     def create_algorithm_tab(self, layout):
@@ -225,7 +230,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 +272,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,6 +371,14 @@ 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',
+            required=False, default=False)
         self.add_field_to_layout(
             self.general_tab_layout, 'plot_stack', FIELD_BOOL, 'Plot stack', required=False,
             default=constants.DEFAULT_PLOT_STACK_BUNCH)
@@ -391,7 +404,7 @@ class MultiLayerConfigurator(DefaultActionConfigurator):
             expert=True,
             placeholder='relative to working path')
         self.add_field(
-            'scratch_output_dir', FIELD_BOOL, 'Scratch output dir.',
+            'scratch_output_dir', FIELD_BOOL, 'Scratch output folder before run',
             required=False, default=True)
         self.add_field(
             'reverse_order', FIELD_BOOL, 'Reverse file order', required=False,
@@ -413,8 +426,11 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
             expert=True,
             placeholder='relative to working path')
         self.add_field(
-            'scratch_output_dir', FIELD_BOOL, 'Scratch output dir.',
+            'scratch_output_dir', FIELD_BOOL, 'Scratch output folder before run',
             required=False, default=True)
+        self.add_field(
+            'delete_output_at_end', FIELD_BOOL, 'Delete output at end of job',
+            required=False, default=False)
         self.add_field(
             'plot_path', FIELD_REL_PATH, 'Plots path', required=False,
             expert=True,
@@ -429,8 +445,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'],
@@ -439,7 +454,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):
@@ -490,22 +505,22 @@ class SubsampleActionConfigurator(DefaultActionConfigurator):
             self.subsample_field.currentText() not in constants.FIELD_SUBSAMPLE_OPTIONS[:2])
 
 
-class AlignFramesConfigurator(SubsampleActionConfigurator):
-    BORDER_MODE_OPTIONS = ['Constant', 'Replicate', 'Replicate and blur']
-    TRANSFORM_OPTIONS = ['Rigid', 'Homography']
-    METHOD_OPTIONS = ['Random Sample Consensus (RANSAC)', 'Least Median (LMEDS)']
+class AlignFramesConfigBase:
     MATCHING_METHOD_OPTIONS = ['K-nearest neighbors', 'Hamming distance']
-    MODE_OPTIONS = ['Auto', 'Sequential', 'Parallel']
+    DETECTOR_DESCRIPTOR_TOOLTIPS = {
+        'detector':
+            "SIFT: Requires SIFT descriptor and K-NN matching\n"
+            "ORB/AKAZE: Work best with Hamming distance",
+        'descriptor':
+            "SIFT: Requires K-NN matching\n"
+            "ORB/AKAZE: Require Hamming distance with ORB/AKAZE detectors",
+        'match_method':
+            "Automatically selected based on detector/descriptor combination"
 
-    def __init__(self, expert, current_wd):
-        super().__init__(expert, current_wd)
-        self.matching_method_field = None
+    }
+
+    def __init__(self):
         self.info_label = None
-        self.detector_field = None
-        self.descriptor_field = None
-        self.matching_method_field = None
-        self.tab_widget = None
-        self.current_tab_layout = None
 
     def show_info(self, message, timeout=3000):
         self.info_label.setText(message)
@@ -514,66 +529,83 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
         timer.timeout.connect(lambda: self.info_label.setText(''))
         timer.start(timeout)
 
-    def change_match_config(self):
-        detector = self.detector_field.currentText()
-        descriptor = self.descriptor_field.currentText()
+    def change_match_config(
+            self, detector_field, descriptor_field, matching_method_field, show_info):
+        detector = detector_field.currentText()
+        descriptor = descriptor_field.currentText()
         match_method = dict(
             zip(self.MATCHING_METHOD_OPTIONS,
-                constants.VALID_MATCHING_METHODS))[self.matching_method_field.currentText()]
+                constants.VALID_MATCHING_METHODS))[matching_method_field.currentText()]
         try:
             validate_align_config(detector, descriptor, match_method)
         except Exception as e:
-            self.show_info(str(e))
+            show_info(str(e))
             if descriptor == constants.DETECTOR_SIFT and \
                match_method == constants.MATCHING_NORM_HAMMING:
-                self.matching_method_field.setCurrentText(self.MATCHING_METHOD_OPTIONS[0])
+                matching_method_field.setCurrentText(self.MATCHING_METHOD_OPTIONS[0])
             if detector == constants.DETECTOR_ORB and descriptor == constants.DESCRIPTOR_AKAZE and \
                     match_method == constants.MATCHING_NORM_HAMMING:
-                self.matching_method_field.setCurrentText(constants.MATCHING_NORM_HAMMING)
+                matching_method_field.setCurrentText(constants.MATCHING_NORM_HAMMING)
             if detector == constants.DETECTOR_BRISK and descriptor == constants.DESCRIPTOR_AKAZE:
-                self.descriptor_field.setCurrentText('BRISK')
+                descriptor_field.setCurrentText('BRISK')
             if detector == constants.DETECTOR_SURF and descriptor == constants.DESCRIPTOR_AKAZE:
-                self.descriptor_field.setCurrentText('SIFT')
+                descriptor_field.setCurrentText('SIFT')
             if detector == constants.DETECTOR_SIFT and descriptor != constants.DESCRIPTOR_SIFT:
-                self.descriptor_field.setCurrentText('SIFT')
+                descriptor_field.setCurrentText('SIFT')
             if detector in constants.NOKNN_METHODS['detectors'] and \
                descriptor in constants.NOKNN_METHODS['descriptors']:
                 if match_method == constants.MATCHING_KNN:
-                    self.matching_method_field.setCurrentText(self.MATCHING_METHOD_OPTIONS[1])
+                    matching_method_field.setCurrentText(self.MATCHING_METHOD_OPTIONS[1])
+
+
+class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase):
+    BORDER_MODE_OPTIONS = ['Constant', 'Replicate', 'Replicate and blur']
+    TRANSFORM_OPTIONS = ['Rigid', 'Homography']
+    METHOD_OPTIONS = ['Random Sample Consensus (RANSAC)', 'Least Median (LMEDS)']
+    MODE_OPTIONS = ['Auto', 'Sequential', 'Parallel']
+
+    def __init__(self, expert, current_wd):
+        SubsampleActionConfigurator.__init__(self, expert, current_wd)
+        AlignFramesConfigBase.__init__(self)
+        self.matching_method_field = None
+        self.detector_field = None
+        self.descriptor_field = None
+        self.matching_method_field = None
+        self.tab_widget = None
+        self.current_tab_layout = None
 
     def create_form(self, layout, action):
         super().create_form(layout, action)
         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):
+
+        def change_match_config():
+            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,
-            options=constants.VALID_DETECTORS, default=constants.DEFAULT_DETECTOR)
+            options=constants.VALID_DETECTORS, default=AppConfig.get('detector'))
         self.descriptor_field = self.add_field_to_layout(
             layout, 'descriptor', FIELD_COMBO, 'Descriptor', required=False,
-            options=constants.VALID_DESCRIPTORS, default=constants.DEFAULT_DESCRIPTOR)
-        self.detector_field.setToolTip(
-            "SIFT: Requires SIFT descriptor and K-NN matching\n"
-            "ORB/AKAZE: Work best with Hamming distance"
-        )
-        self.descriptor_field.setToolTip(
-            "SIFT: Requires K-NN matching\n"
-            "ORB/AKAZE: Require Hamming distance with ORB/AKAZE detectors"
-        )
-        self.detector_field.currentIndexChanged.connect(self.change_match_config)
-        self.descriptor_field.currentIndexChanged.connect(self.change_match_config)
+            options=constants.VALID_DESCRIPTORS, default=AppConfig.get('descriptor'))
+        self.detector_field.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['detector'])
+        self.descriptor_field.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['descriptor'])
+        self.detector_field.currentIndexChanged.connect(change_match_config)
+        self.descriptor_field.currentIndexChanged.connect(change_match_config)
         self.info_label = QLabel()
         self.info_label.setStyleSheet("color: orange; font-style: italic;")
         layout.addRow(self.info_label)
@@ -581,11 +613,9 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
         self.matching_method_field = self.add_field_to_layout(
             layout, 'match_method', FIELD_COMBO, 'Match method', required=False,
             options=self.MATCHING_METHOD_OPTIONS, values=constants.VALID_MATCHING_METHODS,
-            default=constants.DEFAULT_MATCHING_METHOD)
-        self.matching_method_field.setToolTip(
-            "Automatically selected based on detector/descriptor combination"
-        )
-        self.matching_method_field.currentIndexChanged.connect(self.change_match_config)
+            default=AppConfig.get('match_method'))
+        self.matching_method_field.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['match_method'])
+        self.matching_method_field.currentIndexChanged.connect(change_match_config)
         self.add_field_to_layout(
             layout, 'flann_idx_kdtree', FIELD_INT, 'Flann idx kdtree', required=False,
             expert=True,
@@ -615,9 +645,9 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
             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,
@@ -662,6 +692,14 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
 
         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,
@@ -696,7 +734,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
                              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',
@@ -710,6 +748,10 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
             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()
@@ -718,6 +760,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
             max_threads.setEnabled(enabled)
             chunk_submit.setEnabled(enabled)
             bw_matching.setEnabled(enabled)
+            delta_max.setEnabled(enabled)
 
         mode.currentIndexChanged.connect(change_mode)
 

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

@@ -215,8 +215,7 @@ class RunWindow(QTextEditLogger):
                 raise RuntimeError(f"Can't visualize file type {os.path.splitext(path)[1]}.")
             self.image_views.append(image_view)
             self.image_layout.addWidget(image_view)
-            max_width = max(pv.size().width() for pv in self.image_views) if self.image_views else 0
-            needed_width = max_width + 20
+            needed_width = gui_constants.GUI_IMG_WIDTH + 20
             self.right_area.setFixedWidth(needed_width)
             self.image_area_widget.setFixedWidth(needed_width)
             self.right_area.updateGeometry()

shinestacker/gui/main_window.py

@@ -3,9 +3,9 @@
 import os
 import subprocess
 from PySide6.QtCore import Qt
-from PySide6.QtGui import QGuiApplication, QAction, QIcon
+from PySide6.QtGui import QGuiApplication, QAction, QPalette
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, QMessageBox,
-                               QSplitter, QToolBar, QMenu, QMainWindow)
+                               QSplitter, QToolBar, QMenu, QMainWindow, QApplication)
 from .. config.constants import constants
 from .. config.app_config import AppConfig
 from .. core.core_utils import running_under_windows, running_under_macos
@@ -82,7 +82,9 @@ class MainWindow(QMainWindow, LogManager):
             "Run Job": self.run_job,
             "Run All Jobs": self.run_all_jobs,
         }
-        self.menu_manager = MenuManager(self.menuBar(), actions, self.project_editor, self)
+        dark_theme = self.is_dark_theme()
+        self.menu_manager = MenuManager(
+            self.menuBar(), actions, self.project_editor, dark_theme, self)
         self.script_dir = os.path.dirname(__file__)
         self._windows = []
         self._workers = []
@@ -107,7 +109,7 @@ class MainWindow(QMainWindow, LogManager):
         top_widget = QWidget()
         top_widget.setLayout(h_layout)
         h_splitter.addWidget(top_widget)
-        self.tab_widget = TabWidgetWithPlaceholder()
+        self.tab_widget = TabWidgetWithPlaceholder(dark_theme)
         self.tab_widget.resize(1000, 500)
         h_splitter.addWidget(self.tab_widget)
         self.job_list().currentRowChanged.connect(self.project_editor.on_job_selected)
@@ -128,6 +130,7 @@ class MainWindow(QMainWindow, LogManager):
         layout.addWidget(h_splitter)
         self.central_widget.setLayout(layout)
         self.update_title()
+        QApplication.instance().paletteChanged.connect(self.on_theme_changed)
 
         def handle_modified(modified):
             self.save_actions_set_enabled(modified)
@@ -367,9 +370,6 @@ class MainWindow(QMainWindow, LogManager):
             menu.exec(event.globalPos())
     # pylint: enable=C0103
 
-    def get_icon(self, icon):
-        return QIcon(os.path.join(self.script_dir, f"img/{icon}.png"))
-
     def get_retouch_path(self, job):
         frames_path = [get_action_output_path(action)[0]
                        for action in job.sub_actions
@@ -581,3 +581,16 @@ class MainWindow(QMainWindow, LogManager):
         for action in self.findChildren(QAction):
             if action.property("requires_file"):
                 action.setEnabled(enabled)
+
+    def is_dark_theme(self):
+        palette = QApplication.palette()
+        window_color = palette.color(QPalette.Window)
+        brightness = (window_color.red() * 0.299 +
+                      window_color.green() * 0.587 +
+                      window_color.blue() * 0.114)
+        return brightness < 128
+
+    def on_theme_changed(self):
+        dark_theme = self.is_dark_theme()
+        self.menu_manager.change_theme(dark_theme)
+        self.tab_widget.change_theme(dark_theme)

shinestacker/gui/menu_manager.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, R0904, E0611, R0902, W0201
+# pylint: disable=C0114, C0115, C0116, R0904, E0611, R0902, W0201, R0913, R0917
 import os
 from functools import partial
 from PySide6.QtCore import Signal, QObject
@@ -12,11 +12,12 @@ from .recent_file_manager import RecentFileManager
 class MenuManager(QObject):
     open_file_requested = Signal(str)
 
-    def __init__(self, menubar, actions, project_editor, parent):
+    def __init__(self, menubar, actions, project_editor, dark_theme, parent):
         super().__init__(parent)
         self.script_dir = os.path.dirname(__file__)
         self._recent_file_manager = RecentFileManager("shinestacker-recent-project-files.txt")
         self.project_editor = project_editor
+        self.dark_theme = dark_theme
         self.parent = parent
         self.menubar = menubar
         self.actions = actions
@@ -58,8 +59,9 @@ class MenuManager(QObject):
             "Run All Jobs": "Run all jobs",
         }
 
-    def get_icon(self, icon):
-        return QIcon(os.path.join(self.script_dir, f"img/{icon}.png"))
+    def get_icon(self, icon_name):
+        icon_dir = 'dark' if self.dark_theme else 'light'
+        return QIcon(os.path.join(self.script_dir, f"img/{icon_dir}/{icon_name}.png"))
 
     def action(self, name, requires_file=False):
         action = QAction(name, self.parent)
@@ -68,9 +70,11 @@ class MenuManager(QObject):
         shortcut = self.shortcuts.get(name, '')
         if shortcut:
             action.setShortcut(shortcut)
-        icon = self.icons.get(name, '')
-        if icon:
-            action.setIcon(self.get_icon(icon))
+        icon_name = self.icons.get(name, '')
+        if icon_name:
+            action.setIcon(self.get_icon(icon_name))
+            action.setProperty('theme_dependent', True)
+            action.setProperty('base_icon_name', icon_name)
         tooltip = self.tooltips.get(name, '')
         if tooltip:
             action.setToolTip(tooltip)
@@ -79,6 +83,13 @@ class MenuManager(QObject):
             action.triggered.connect(action_fun)
         return action
 
+    def change_theme(self, dark_theme):
+        self.dark_theme = dark_theme
+        for action in self.parent.findChildren(QAction):
+            if action.property("theme_dependent"):
+                base_name = action.property("base_icon_name")
+                action.setIcon(self.get_icon(base_name))
+
     def update_recent_files(self):
         self.recent_files_menu.clear()
         recent_files = self._recent_file_manager.get_files_with_display_names()

shinestacker/gui/new_project.py

@@ -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")
@@ -169,13 +180,11 @@ class NewProjectDialog(BaseFormDialog):
                 border-radius: 5px;
                 margin-top: 10px;
                 padding-top: 15px;
-                background-color: #f8f8f8;
             }
             QGroupBox::title {
                 subcontrol-origin: margin;
                 left: 10px;
                 padding: 0 5px 0 5px;
-                background-color: #f8f8f8;
             }
         """
         for group in [step1_group, step2_group, step3_group, step4_group]: