shinestacker 0.5.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

shinestacker/gui/menu_manager.py

@@ -0,0 +1,236 @@
+# pylint: disable=C0114, C0115, C0116, R0904, E0611, R0902, W0201
+import os
+from PySide6.QtGui import QAction, QIcon
+from PySide6.QtWidgets import QMenu, QComboBox
+from .. config.constants import constants
+
+
+class MenuManager:
+    def __init__(self, menubar, actions, project_editor, parent):
+        self.script_dir = os.path.dirname(__file__)
+        self.project_editor = project_editor
+        self.parent = parent
+        self.menubar = menubar
+        self.actions = actions
+        self.action_selector = None
+        self.sub_action_selector = None
+        self.shortcuts = {
+            "&New...": "Ctrl+N",
+            "&Open...": "Ctrl+O",
+            "&Close": "Ctrl+W",
+            "&Save": "Ctrl+S",
+            "Save &As...": "Ctrl+Shift+S",
+            "&Undo": "Ctrl+Z",
+            "&Cut": "Ctrl+X",
+            "Cop&y": "Ctrl+C",
+            "&Paste": "Ctrl+V",
+            "Duplicate": "Ctrl+D",
+            "Delete": "Del",
+            "Move &Up": "Ctrl+Up",
+            "Move &Down": "Ctrl+Down",
+            "E&nable": "Ctrl+E",
+            "Di&sable": "Ctrl+B",
+            "Enable All": "Ctrl+Shift+E",
+            "Disable All": "Ctrl+Shift+B",
+            "Expert Options": "Ctrl+Shift+X",
+            "Add Job": "Ctrl+P",
+            "Run Job": "Ctrl+J",
+            "Run All Jobs": "Ctrl+Shift+J"
+        }
+        self.icons = {
+            "Delete": "close-round-line-icon",
+            "Add Job": "plus-round-line-icon",
+            "Run Job": "play-button-round-icon",
+            "Run All Jobs": "forward-button-icon",
+        }
+        self.tooltips = {
+            "Delete": "Delete",
+            "Add Job": "Add job",
+            "Run Job": "Run job",
+            "Run All Jobs": "Run all jobs",
+        }
+
+    def get_icon(self, icon):
+        return QIcon(os.path.join(self.script_dir, f"img/{icon}.png"))
+
+    def action(self, name):
+        action = QAction(name, self.parent)
+        shortcut = self.shortcuts.get(name, '')
+        if shortcut:
+            action.setShortcut(shortcut)
+        icon = self.icons.get(name, '')
+        if icon:
+            action.setIcon(self.get_icon(icon))
+        tooltip = self.tooltips.get(name, '')
+        if tooltip:
+            action.setToolTip(tooltip)
+        action_fun = self.actions.get(name, None)
+        if action_fun is not None:
+            action.triggered.connect(action_fun)
+        return action
+
+    def add_file_menu(self):
+        menu = self.menubar.addMenu("&File")
+        for name in ["&New...", "&Open...", "&Close"]:
+            menu.addAction(self.action(name))
+        menu.addSeparator()
+        self.save_action = self.action("&Save")
+        menu.addAction(self.save_action)
+        self.save_as_action = self.action("Save &As...")
+        menu.addAction(self.save_as_action)
+        self.save_actions_set_enabled(False)
+
+    def add_edit_menu(self):
+        menu = self.menubar.addMenu("&Edit")
+        for name in ["&Undo", "&Cut", "Cop&y", "&Paste", "Duplicate"]:
+            menu.addAction(self.action(name))
+        self.delete_element_action = self.action("Delete")
+        self.delete_element_action.setEnabled(False)
+        menu.addAction(self.delete_element_action)
+        menu.addSeparator()
+        for name in ["Move &Up", "Move &Down"]:
+            menu.addAction(self.action(name))
+        menu.addSeparator()
+        self.enable_action = self.action("E&nable")
+        menu.addAction(self.enable_action)
+        self.disable_action = self.action("Di&sable")
+        menu.addAction(self.disable_action)
+        for name in ["Enable All", "Disable All"]:
+            menu.addAction(self.action(name))
+
+    def add_view_menu(self):
+        menu = self.menubar.addMenu("&View")
+        self.expert_options_action = self.action("Expert Options")
+        self.expert_options_action.setCheckable(True)
+        menu.addAction(self.expert_options_action)
+
+    def add_job_menu(self):
+        menu = self.menubar.addMenu("&Jobs")
+        self.add_job_action = self.action("Add Job")
+        menu.addAction(self.add_job_action)
+        menu.addSeparator()
+        self.run_job_action = self.action("Run Job")
+        self.run_job_action.setEnabled(False)
+        menu.addAction(self.run_job_action)
+        self.run_all_jobs_action = self.action("Run All Jobs")
+        self.run_all_jobs_action.setEnabled(False)
+        menu.addAction(self.run_all_jobs_action)
+
+    def add_actions_menu(self):
+        menu = self.menubar.addMenu("&Actions")
+        add_action_menu = QMenu("Add Action", self.parent)
+        for action in constants.ACTION_TYPES:
+            entry_action = QAction(action, self.parent)
+            entry_action.triggered.connect({
+                constants.ACTION_COMBO: self.add_action_combined_actions,
+                constants.ACTION_NOISEDETECTION: self.add_action_noise_detection,
+                constants.ACTION_FOCUSSTACK: self.add_action_focus_stack,
+                constants.ACTION_FOCUSSTACKBUNCH: self.add_action_focus_stack_bunch,
+                constants.ACTION_MULTILAYER: self.add_action_multilayer
+            }[action])
+            add_action_menu.addAction(entry_action)
+        menu.addMenu(add_action_menu)
+        add_sub_action_menu = QMenu("Add Sub Action", self.parent)
+        self.sub_action_menu_entries = []
+        for action in constants.SUB_ACTION_TYPES:
+            entry_action = QAction(action, self.parent)
+            entry_action.triggered.connect({
+                constants.ACTION_MASKNOISE: self.add_sub_action_make_noise,
+                constants.ACTION_VIGNETTING: self.add_sub_action_vignetting,
+                constants.ACTION_ALIGNFRAMES: self.add_sub_action_align_frames,
+                constants.ACTION_BALANCEFRAMES: self.add_sub_action_balance_frames
+            }[action])
+            entry_action.setEnabled(False)
+            self.sub_action_menu_entries.append(entry_action)
+            add_sub_action_menu.addAction(entry_action)
+        menu.addMenu(add_sub_action_menu)
+
+    def add_help_menu(self):
+        menu = self.menubar.addMenu("&Help")
+        menu.setObjectName("Help")
+
+    def add_menus(self):
+        self.add_file_menu()
+        self.add_edit_menu()
+        self.add_view_menu()
+        self.add_job_menu()
+        self.add_actions_menu()
+        self.add_help_menu()
+
+    def add_action(self, type_name=False):
+        if type_name is False:
+            type_name = self.action_selector.currentText()
+        self.project_editor.add_action(type_name)
+
+    def add_sub_action(self, type_name=False):
+        if type_name is False:
+            type_name = self.sub_action_selector.currentText()
+        self.project_editor.add_sub_action(type_name)
+
+    def save_actions_set_enabled(self, enabled):
+        self.save_action.setEnabled(enabled)
+        self.save_as_action.setEnabled(enabled)
+
+    def add_action_combined_actions(self):
+        self.add_action(constants.ACTION_COMBO)
+
+    def add_action_noise_detection(self):
+        self.add_action(constants.ACTION_NOISEDETECTION)
+
+    def add_action_focus_stack(self):
+        self.add_action(constants.ACTION_FOCUSSTACK)
+
+    def add_action_focus_stack_bunch(self):
+        self.add_action(constants.ACTION_FOCUSSTACKBUNCH)
+
+    def add_action_multilayer(self):
+        self.add_action(constants.ACTION_MULTILAYER)
+
+    def add_sub_action_make_noise(self):
+        self.add_sub_action(constants.ACTION_MASKNOISE)
+
+    def add_sub_action_vignetting(self):
+        self.add_sub_action(constants.ACTION_VIGNETTING)
+
+    def add_sub_action_align_frames(self):
+        self.add_sub_action(constants.ACTION_ALIGNFRAMES)
+
+    def add_sub_action_balance_frames(self):
+        self.add_sub_action(constants.ACTION_BALANCEFRAMES)
+
+    def fill_toolbar(self, toolbar):
+        toolbar.addAction(self.add_job_action)
+        toolbar.addSeparator()
+        self.action_selector = QComboBox()
+        self.action_selector.addItems(constants.ACTION_TYPES)
+        self.action_selector.setEnabled(False)
+        toolbar.addWidget(self.action_selector)
+        self.add_action_entry_action = QAction("Add Action", self.parent)
+        self.add_action_entry_action.setIcon(
+            QIcon(os.path.join(self.script_dir, "img/plus-round-line-icon.png")))
+        self.add_action_entry_action.setToolTip("Add action")
+        self.add_action_entry_action.triggered.connect(self.add_action)
+        self.add_action_entry_action.setEnabled(False)
+        toolbar.addAction(self.add_action_entry_action)
+        self.sub_action_selector = QComboBox()
+        self.sub_action_selector.addItems(constants.SUB_ACTION_TYPES)
+        self.sub_action_selector.setEnabled(False)
+        toolbar.addWidget(self.sub_action_selector)
+        self.add_sub_action_entry_action = QAction("Add Sub Action", self.parent)
+        self.add_sub_action_entry_action.setIcon(
+            QIcon(os.path.join(self.script_dir, "img/plus-round-line-icon.png")))
+        self.add_sub_action_entry_action.setToolTip("Add sub action")
+        self.add_sub_action_entry_action.triggered.connect(self.add_sub_action)
+        self.add_sub_action_entry_action.setEnabled(False)
+        toolbar.addAction(self.add_sub_action_entry_action)
+        toolbar.addSeparator()
+        toolbar.addAction(self.delete_element_action)
+        toolbar.addSeparator()
+        toolbar.addAction(self.run_job_action)
+        toolbar.addAction(self.run_all_jobs_action)
+
+    def set_enabled_sub_actions_gui(self, enabled):
+        self.add_sub_action_entry_action.setEnabled(enabled)
+        self.sub_action_selector.setEnabled(enabled)
+        for a in self.sub_action_menu_entries:
+            a.setEnabled(enabled)

shinestacker/gui/new_project.py

@@ -1,27 +1,24 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0915, R0902
 import os
-from PySide6.QtWidgets import (QFormLayout, QHBoxLayout, QPushButton,
-                               QDialog, QLabel, QCheckBox, QSpinBox, QMessageBox)
+import numpy as np
+from PySide6.QtWidgets import (QHBoxLayout, QPushButton, QLabel, QCheckBox, QSpinBox,
+                               QMessageBox)
 from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
 from .. config.gui_constants import gui_constants
 from .. config.constants import constants
+from .. algorithms.utils import read_img
 from .. algorithms.stack import get_bunches
 from .select_path_widget import create_select_file_paths_widget
+from .base_form_dialog import BaseFormDialog
 
 DEFAULT_NO_COUNT_LABEL = " - "
+EXTENSIONS = ['jpg', 'jpeg', 'tif', 'tiff']
 
 
-class NewProjectDialog(QDialog):
+class NewProjectDialog(BaseFormDialog):
     def __init__(self, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle("New Project")
-        self.resize(500, self.height())
-        self.layout = QFormLayout(self)
-        self.layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
-        self.layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
-        self.layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
-        self.layout.setLabelAlignment(Qt.AlignLeft)
+        super().__init__("New Project", parent)
         self.create_form()
         button_box = QHBoxLayout()
         ok_button = QPushButton("OK")
@@ -29,9 +26,10 @@ class NewProjectDialog(QDialog):
         cancel_button = QPushButton("Cancel")
         button_box.addWidget(ok_button)
         button_box.addWidget(cancel_button)
-        self.layout.addRow(button_box)
+        self.add_row_to_layout(button_box)
         ok_button.clicked.connect(self.accept)
         cancel_button.clicked.connect(self.reject)
+        self.n_image_files = 0
 
     def expert(self):
         return self.parent().expert_options
@@ -41,6 +39,10 @@ class NewProjectDialog(QDialog):
         label.setStyleSheet("font-weight: bold")
         self.layout.addRow(label)
 
+    def add_label(self, label):
+        label = QLabel(label)
+        self.layout.addRow(label)
+
     def create_form(self):
         icon_path = f"{os.path.dirname(__file__)}/ico/shinestacker.png"
         app_icon = QIcon(icon_path)
@@ -90,10 +92,11 @@ class NewProjectDialog(QDialog):
         self.multi_layer = QCheckBox()
         self.multi_layer.setChecked(gui_constants.NEW_PROJECT_MULTI_LAYER)
 
-        self.add_bold_label("Select input:")
+        self.add_bold_label("1️⃣ Select input folder, all images therein will be merged. ")
         self.layout.addRow("Input folder:", container)
         self.layout.addRow("Number of frames: ", self.frames_label)
-        self.add_bold_label("Select actions:")
+        self.add_label("")
+        self.add_bold_label("2️⃣ Select basic options.")
         if self.expert():
             self.layout.addRow("Automatic noise detection:", self.noise_detection)
             self.layout.addRow("Vignetting correction:", self.vignetting_correction)
@@ -109,6 +112,12 @@ class NewProjectDialog(QDialog):
         else:
             self.layout.addRow("Focus stack:", self.focus_stack_pyramid)
             self.layout.addRow("Save multi layer TIFF:", self.multi_layer)
+        self.add_label("")
+        self.add_bold_label("3️⃣ Push 🆗 for further options, then press ▶️ to run.")
+        self.add_label("")
+        self.add_label("4️⃣ "
+                       "Select: <b>View</b> > <b>Expert options</b> "
+                       "to unlock advanced configuration.")
 
     def update_bunch_options(self, checked):
         self.bunch_frames.setEnabled(checked)
@@ -122,23 +131,22 @@ class NewProjectDialog(QDialog):
         def count_image_files(path):
             if path == '' or not os.path.isdir(path):
                 return 0
-            extensions = ['jpg', 'jpeg', 'tif', 'tiff']
             count = 0
             for filename in os.listdir(path):
                 if '.' in filename:
                     ext = filename.lower().split('.')[-1]
-                    if ext in extensions:
+                    if ext in EXTENSIONS:
                         count += 1
             return count
 
-        n_image_files = count_image_files(self.input_folder.text())
-        if n_image_files == 0:
+        self.n_image_files = count_image_files(self.input_folder.text())
+        if self.n_image_files == 0:
             self.bunches_label.setText(DEFAULT_NO_COUNT_LABEL)
             self.frames_label.setText(DEFAULT_NO_COUNT_LABEL)
             return
-        self.frames_label.setText(f"{n_image_files}")
+        self.frames_label.setText(f"{self.n_image_files}")
         if self.bunch_stack.isChecked():
-            bunches = get_bunches(list(range(n_image_files)),
+            bunches = get_bunches(list(range(self.n_image_files)),
                                   self.bunch_frames.value(),
                                   self.bunch_overlap.value())
             self.bunches_label.setText(f"{len(bunches)}")
@@ -159,6 +167,53 @@ class NewProjectDialog(QDialog):
         if len(input_folder.split('/')) < 2:
             QMessageBox.warning(self, "Invalid Path", "The path must have a parent folder")
             return
+        if self.n_image_files > 0 and not self.bunch_stack.isChecked():
+            path = self.input_folder.text()
+            files = os.listdir(path)
+            file_path = None
+            for filename in files:
+                full_path = os.path.join(path, filename)
+                if os.path.isfile(full_path):
+                    ext = full_path.split(".")[-1].lower()
+                    if ext in EXTENSIONS:
+                        file_path = full_path
+                        break
+            if file_path is None:
+                QMessageBox.warning(
+                    self, "Invalid input", "Could not find images now in the selected path")
+                return
+            img = read_img(file_path)
+            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_mbytes = float(n_bytes * height * width * self.n_image_files) / 10**6
+            if n_mbytes > 500 and not self.bunch_stack.isChecked():
+                msg = QMessageBox()
+                msg.setStyleSheet("""
+                    QMessageBox {
+                        min-width: 600px;
+                        font-weight: bold;
+                        font-size: 14px;
+                    }
+                    QMessageBox QLabel#qt_msgbox_informativelabel {
+                        font-weight: normal;
+                        font-size: 14px;
+                        color: #555555;
+                    }
+                """)
+                msg.setIcon(QMessageBox.Warning)
+                msg.setWindowTitle("Too many frames")
+                msg.setText(f"You selected {self.n_image_files} images "
+                            f"with resolution {width}×{height} pixels, {n_bits} bits depth. "
+                            "Processing may require a significant amount of memory.\n\n"
+                            "Continue anyway?")
+                msg.setInformativeText("You may consider to split the processing "
+                                       " using a bunch stack to reduce memory usage.\n\n"
+                                       '✅ Check the option "Bunch stack".')
+                msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
+                msg.setDefaultButton(QMessageBox.Cancel)
+                if msg.exec_() != QMessageBox.Ok:
+                    return
         super().accept()
 
     def get_input_folder(self):