shinestacker 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

shinestacker/gui/action_config_dialog.py

@@ -1,8 +1,8 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0913, R0917, R0915, R0912
-# pylint: disable=E0606, W0718, R1702, W0102, W0221
+# pylint: disable=E0606, W0718, R1702, W0102, W0221, R0914
+import os
 import traceback
-from typing import Dict, Any
-from PySide6.QtWidgets import (QWidget, QPushButton, QHBoxLayout, QLabel, QScrollArea,
+from PySide6.QtWidgets import (QWidget, QPushButton, QHBoxLayout, QLabel, QScrollArea, QSizePolicy,
                                QMessageBox, QStackedWidget, QFormLayout, QDialog)
 from PySide6.QtCore import Qt, QTimer
 from .. config.constants import constants
@@ -14,6 +14,7 @@ from . action_config import (
     FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
     FIELD_INT, FIELD_INT_TUPLE, FIELD_BOOL, FIELD_COMBO, FIELD_REF_IDX
 )
+from .folder_file_selection import FolderFileSelectionWidget
 
 
 class ActionConfigDialog(QDialog):
@@ -104,8 +105,6 @@ class ActionConfigDialog(QDialog):
         if self.configurator.update_params(self.action.params):
             self.parent().mark_as_modified(True, "Modify Configuration")
             super().accept()
-        else:
-            self.parent().project_editor.pop_undo()
 
     def reset_to_defaults(self):
         builder = self.configurator.get_builder()
@@ -124,7 +123,7 @@ class NoNameActionConfigurator(ActionConfigurator):
     def get_builder(self):
         return self.builder
 
-    def update_params(self, params: Dict[str, Any]) -> bool:
+    def update_params(self, params):
         return self.builder.update_params(params)
 
     def add_bold_label(self, label):
@@ -139,6 +138,24 @@ class NoNameActionConfigurator(ActionConfigurator):
                   required=False, add_to_layout=None, **kwargs):
         return self.builder.add_field(tag, field_type, label, required, add_to_layout, **kwargs)
 
+    def labelled_widget(self, label, widget):
+        row = QWidget()
+        layout = QHBoxLayout()
+        layout.setContentsMargins(2, 2, 2, 2)
+        layout.setSpacing(8)
+        label_widget = QLabel(label)
+        label_widget.setFixedWidth(120)
+        label_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
+        layout.addWidget(label_widget)
+        layout.addWidget(widget)
+        layout.setStretch(0, 1)
+        layout.setStretch(1, 3)
+        row.setLayout(layout)
+        return row
+
+    def add_labelled_row(self, label, widget):
+        self.add_row(self.labelled_widget(label, widget))
+
 
 class DefaultActionConfigurator(NoNameActionConfigurator):
     def create_form(self, layout, action, tag='Action'):
@@ -148,13 +165,98 @@ class DefaultActionConfigurator(NoNameActionConfigurator):
 
 
 class JobConfigurator(DefaultActionConfigurator):
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
+        self.working_path_label = None
+        self.input_path_label = None
+        self.frames_label = None
+        self.input_widget = None
+
     def create_form(self, layout, action):
         super().create_form(layout, action, "Job")
-        self.add_field(
-            'working_path', FIELD_ABS_PATH, 'Working path', required=True)
-        self.add_field(
-            'input_path', FIELD_REL_PATH, 'Input path', required=False,
-            must_exist=True, placeholder='relative to working path')
+        self.input_widget = FolderFileSelectionWidget()
+        self.frames_label = QLabel("0")
+        working_path = action.params.get('working_path', '')
+        input_path = action.params.get('input_path', '')
+        input_filepaths = action.params.get('input_filepaths', [])
+        if isinstance(input_filepaths, str) and input_filepaths:
+            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")
+        has_existing_data = working_path or input_path or input_filepaths
+        if input_filepaths:
+            self.input_widget.files_mode_radio.setChecked(True)
+            self.input_widget.selected_files = input_filepaths
+            if input_filepaths:
+                parent_dir = os.path.dirname(input_filepaths[0])
+                self.input_widget.path_edit.setText(parent_dir)
+        elif input_path and working_path:
+            self.input_widget.folder_mode_radio.setChecked(True)
+            input_fullpath = os.path.join(working_path, input_path)
+            self.input_widget.path_edit.setText(input_fullpath)
+        elif input_path:
+            self.input_widget.folder_mode_radio.setChecked(True)
+            self.input_widget.path_edit.setText(input_path)
+        self.input_widget.text_changed_connect(self.update_paths_and_frames)
+        self.input_widget.folder_mode_radio.toggled.connect(self.update_paths_and_frames)
+        self.input_widget.files_mode_radio.toggled.connect(self.update_paths_and_frames)
+        self.add_bold_label("Input Selection:")
+        self.add_row(self.input_widget)
+        self.add_labelled_row("Number of frames: ", self.frames_label)
+        self.add_bold_label("Derived Paths:")
+        self.add_labelled_row("Working path: ", self.working_path_label)
+        self.add_labelled_row("Input path:", self.input_path_label)
+        if not has_existing_data:
+            self.update_paths_and_frames()
+        else:
+            self.update_frames_count()
+
+    def update_frames_count(self):
+        if self.input_widget.get_selection_mode() == 'files':
+            count = len(self.input_widget.get_selected_files())
+        else:
+            count = self.count_image_files(self.input_widget.get_path())
+        self.frames_label.setText(str(count))
+
+    def update_paths_and_frames(self):
+        self.update_frames_count()
+        selection_mode = self.input_widget.get_selection_mode()
+        selected_files = self.input_widget.get_selected_files()
+        input_path = self.input_widget.get_path()
+        if selection_mode == 'files' and selected_files:
+            input_path = os.path.dirname(selected_files[0])
+        input_path_value = os.path.basename(os.path.normpath(input_path)) if input_path else ""
+        working_path_value = os.path.dirname(input_path) if input_path else ""
+        self.input_path_label.setText(input_path_value or "Not set")
+        self.working_path_label.setText(working_path_value or "Not set")
+
+    def count_image_files(self, path):
+        if not path or not os.path.isdir(path):
+            return 0
+        count = 0
+        for filename in os.listdir(path):
+            if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.tif', '.tiff')):
+                count += 1
+        return count
+
+    def update_params(self, params):
+        if not super().update_params(params):
+            return False
+        selection_mode = self.input_widget.get_selection_mode()
+        selected_files = self.input_widget.get_selected_files()
+        input_path = self.input_widget.get_path()
+        if selection_mode == 'files' and selected_files:
+            params['input_filepaths'] = self.input_widget.get_selected_filenames()
+            params['input_path'] = os.path.dirname(selected_files[0])
+        else:
+            params['input_filepaths'] = []
+            params['input_path'] = input_path
+        if 'working_path' not in params or not params['working_path']:
+            if params['input_path']:
+                params['working_path'] = os.path.dirname(params['input_path'])
+            else:
+                params['working_path'] = ''
+        return True
 
 
 class NoiseDetectionConfigurator(DefaultActionConfigurator):
@@ -435,6 +537,13 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
             self.add_field(
                 'step_process', FIELD_BOOL, 'Step process', required=False,
                 default=True)
+            self.add_field(
+                'max_threads', FIELD_INT, 'Max num. of cores',
+                required=False, default=constants.DEFAULT_MAX_FWK_THREADS,
+                min_val=1, max_val=64)
+            self.add_field(
+                'chunk_submit', FIELD_BOOL, 'Submit in chunks',
+                required=False, default=constants.DEFAULT_MAX_FWK_CHUNK_SUBMIT)
 
 
 class MaskNoiseConfigurator(DefaultActionConfigurator):
@@ -484,6 +593,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
     TRANSFORM_OPTIONS = ['Rigid', 'Homography']
     METHOD_OPTIONS = ['Random Sample Consensus (RANSAC)', 'Least Median (LMEDS)']
     MATCHING_METHOD_OPTIONS = ['K-nearest neighbors', 'Hamming distance']
+    MODE_OPTIONS = ['Auto', 'Sequential', 'Parallel']
 
     def __init__(self, expert, current_wd):
         super().__init__(expert, current_wd)
@@ -650,6 +760,36 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
                 default=constants.DEFAULT_BORDER_BLUR,
                 min_val=0, max_val=1000, step=1)
         self.add_bold_label("Miscellanea:")
+        if self.expert:
+            mode = self.add_field(
+                'mode', FIELD_COMBO, 'Mode',
+                required=False, options=self.MODE_OPTIONS, values=constants.ALIGN_VALID_MODES,
+                default=dict(zip(constants.ALIGN_VALID_MODES,
+                                 self.MODE_OPTIONS))[constants.DEFAULT_ALIGN_MODE])
+            memory_limit = self.add_field(
+                'memory_limit', FIELD_FLOAT, 'Memory limit (approx., GBytes)',
+                required=False, default=constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB,
+                min_val=1.0, max_val=64.0)
+            max_threads = self.add_field(
+                'max_threads', FIELD_INT, 'Max num. of cores',
+                required=False, default=constants.DEFAULT_ALIGN_MAX_THREADS,
+                min_val=1, max_val=64)
+            chunk_submit = self.add_field(
+                'chunk_submit', FIELD_BOOL, 'Submit in chunks',
+                required=False, default=constants.DEFAULT_ALIGN_CHUNK_SUBMIT)
+            bw_matching = self.add_field(
+                'bw_matching', FIELD_BOOL, 'Match using black & white',
+                required=False, default=constants.DEFAULT_ALIGN_BW_MATCHING)
+
+            def change_mode():
+                text = mode.currentText()
+                enabled = text != self.MODE_OPTIONS[1]
+                memory_limit.setEnabled(enabled)
+                max_threads.setEnabled(enabled)
+                chunk_submit.setEnabled(enabled)
+                bw_matching.setEnabled(enabled)
+
+            mode.currentIndexChanged.connect(change_mode)
         self.add_field(
             'plot_summary', FIELD_BOOL, 'Plot summary',
             required=False, default=False)
@@ -657,7 +797,7 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
             'plot_matches', FIELD_BOOL, 'Plot matches',
             required=False, default=False)
 
-    def update_params(self, params: Dict[str, Any]) -> bool:
+    def update_params(self, params):
         if self.detector_field and self.descriptor_field and self.matching_method_field:
             try:
                 detector = self.detector_field.currentText()

shinestacker/gui/base_form_dialog.py

@@ -13,10 +13,10 @@ def create_form_layout(parent):
 
 
 class BaseFormDialog(QDialog):
-    def __init__(self, title, parent=None):
+    def __init__(self, title, width=500, parent=None):
         super().__init__(parent)
         self.setWindowTitle(title)
-        self.resize(500, self.height())
+        self.resize(width, self.height())
         self.form_layout = create_form_layout(self)
 
     def add_row_to_layout(self, item):

shinestacker/gui/folder_file_selection.py

@@ -0,0 +1,101 @@
+# pylint: disable=C0114, C0115, C0116, E0611
+import os
+from PySide6.QtWidgets import (QWidget, QRadioButton, QButtonGroup, QLineEdit,
+                               QPushButton, QHBoxLayout, QVBoxLayout, QFileDialog, QMessageBox)
+from PySide6.QtCore import Qt
+
+
+class FolderFileSelectionWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.selection_mode = 'folder'  # 'folder' or 'files'
+        self.selected_files = []
+        self.setup_ui()
+
+    def setup_ui(self):
+        self.mode_group = QButtonGroup(self)
+        self.folder_mode_radio = QRadioButton("Select Folder")
+        self.folder_mode_radio.setMaximumWidth(100)
+        self.files_mode_radio = QRadioButton("Select Files")
+        self.files_mode_radio.setMaximumWidth(100)
+        self.folder_mode_radio.setChecked(True)
+        self.mode_group.addButton(self.folder_mode_radio)
+        self.mode_group.addButton(self.files_mode_radio)
+        self.path_edit = QLineEdit()
+        self.path_edit.setPlaceholderText("input files folder")
+        self.browse_button = QPushButton("Browse Folder...")
+        self.browse_button.setFixedWidth(120)
+        main_layout = QVBoxLayout()
+        main_layout.setSpacing(10)
+        main_layout.setAlignment(Qt.AlignLeft)
+        mode_layout = QHBoxLayout()
+        mode_layout.setContentsMargins(2, 2, 2, 2)
+        mode_layout.setSpacing(20)
+        mode_layout.addWidget(self.folder_mode_radio)
+        mode_layout.addWidget(self.files_mode_radio)
+        mode_layout.addStretch()
+        main_layout.addLayout(mode_layout)
+        input_layout = QHBoxLayout()
+        input_layout.setContentsMargins(2, 2, 2, 2)
+        input_layout.setSpacing(8)
+        input_layout.setAlignment(Qt.AlignLeft)
+        input_layout.addWidget(self.path_edit)
+        input_layout.addWidget(self.browse_button)
+        main_layout.addLayout(input_layout)
+        self.setLayout(main_layout)
+        self.folder_mode_radio.toggled.connect(self.update_selection_mode)
+        self.files_mode_radio.toggled.connect(self.update_selection_mode)
+        self.browse_button.clicked.connect(self.handle_browse)
+
+    def update_selection_mode(self):
+        if self.folder_mode_radio.isChecked():
+            self.selection_mode = 'folder'
+            self.browse_button.setText("Browse Folder...")
+            # self.path_edit.setPlaceholderText("input files folder")
+        else:
+            self.selection_mode = 'files'
+            self.browse_button.setText("Browse Files...")
+            # self.path_edit.setPlaceholderText("input files")
+
+    def handle_browse(self):
+        if self.selection_mode == 'folder':
+            self.browse_folder()
+        else:
+            self.browse_files()
+
+    def browse_folder(self):
+        path = QFileDialog.getExistingDirectory(self, "Select Input Folder")
+        if path:
+            self.selected_files = []
+            self.path_edit.setText(path)
+
+    def browse_files(self):
+        files, _ = QFileDialog.getOpenFileNames(
+            self, "Select Input Files", "",
+            "Image files (*.png *.jpg *.jpeg *.tif *.tiff)"
+        )
+        if files:
+            parent_dir = os.path.dirname(files[0])
+            if all(os.path.dirname(f) == parent_dir for f in files):
+                self.selected_files = files
+                self.path_edit.setText(parent_dir)
+            else:
+                QMessageBox.warning(
+                    self, "Invalid Selection",
+                    "All files must be in the same directory."
+                )
+
+    def get_selection_mode(self):
+        return self.selection_mode
+
+    def get_selected_files(self):
+        return self.selected_files
+
+    def get_selected_filenames(self):
+        return [os.path.basename(file_path) for file_path in self.selected_files]
+
+    def get_path(self):
+        return self.path_edit.text()
+
+    def text_changed_connect(self, callback):
+        self.path_edit.textChanged.connect(callback)

shinestacker/gui/gui_run.py

@@ -18,6 +18,7 @@ from .colors import (
     ACTION_STOPPED_COLOR, ACTION_FAILED_COLOR)
 from .time_progress_bar import TimerProgressBar
 from .flow_layout import FlowLayout
+from .sys_mon import StatusBarSystemMonitor
 
 
 class ColorButton(QPushButton):
@@ -96,7 +97,8 @@ class RunWindow(QTextEditLogger):
         self.right_area.setMaximumWidth(0)
         self.image_area_widget.setFixedWidth(0)
         layout.addLayout(output_layout)
-
+        self.system_monitor = StatusBarSystemMonitor(self)
+        self.status_bar.addPermanentWidget(self.system_monitor)
         n_paths = len(self.retouch_paths) if self.retouch_paths else 0
         if n_paths == 1:
             self.retouch_widget = QPushButton(f"Retouch {self.retouch_paths[0][0]}")
@@ -284,15 +286,15 @@ class RunWorker(LogWorker):
         self.id_str = id_str
         self.status = constants.STATUS_RUNNING
         self.callbacks = {
-            'before_action': self.before_action,
-            'after_action': self.after_action,
-            'step_counts': self.step_counts,
-            'begin_steps': self.begin_steps,
-            'end_steps': self.end_steps,
-            'after_step': self.after_step,
-            'save_plot': self.save_plot,
-            'check_running': self.check_running,
-            'open_app': self.open_app
+            constants.CALLBACK_BEFORE_ACTION: self.before_action,
+            constants.CALLBACK_AFTER_ACTION: self.after_action,
+            constants.CALLBACK_STEP_COUNTS: self.step_counts,
+            constants.CALLBACK_BEGIN_STEPS: self.begin_steps,
+            constants.CALLBACK_END_STEPS: self.end_steps,
+            constants.CALLBACK_AFTER_STEP: self.after_step,
+            constants.CALLBACK_CHECK_RUNNING: self.check_running,
+            constants.CALLBACK_SAVE_PLOT: self.save_plot,
+            constants.CALLBACK_OPEN_APP: self.open_app
         }
         self.tag = ""
 

shinestacker/gui/main_window.py

@@ -43,7 +43,10 @@ class ProjectLogWorker(RunWorker):
 
 LIST_STYLE_SHEET = f"""
     QListWidget::item:selected {{
-        background-color: #{ColorPalette.LIGHT_BLUE.hex()};;
+        background-color: #{ColorPalette.LIGHT_BLUE.hex()};
+    }}
+    QListWidget::item:hover {{
+        background-color: #F0F0F0;
     }}
 """
 
@@ -421,6 +424,8 @@ class MainWindow(QMainWindow, LogManager):
             for worker in self._workers:
                 worker.stop()
             self.close()
+            return True
+        return False
 
     def toggle_expert_options(self):
         self.expert_options = self.menu_manager.expert_options_action.isChecked()