shinestacker 0.2.0.post1.dev1__py3-none-any.whl

shinestacker/gui/new_project.py

@@ -0,0 +1,170 @@
+import os
+from PySide6.QtWidgets import (QWidget, QLineEdit, QFormLayout, QHBoxLayout, QPushButton,
+                               QDialog, QSizePolicy, QFileDialog, 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 .. core.core_utils import get_app_base_path
+
+
+class NewProjectDialog(QDialog):
+    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)
+        self.create_form()
+        button_box = QHBoxLayout()
+        ok_button = QPushButton("OK")
+        ok_button.setFocus()
+        cancel_button = QPushButton("Cancel")
+        button_box.addWidget(ok_button)
+        button_box.addWidget(cancel_button)
+        self.layout.addRow(button_box)
+        ok_button.clicked.connect(self.accept)
+        cancel_button.clicked.connect(self.reject)
+
+    def expert(self):
+        return self.parent().expert_options
+
+    def add_bold_label(self, label):
+        label = QLabel(label)
+        label.setStyleSheet("font-weight: bold")
+        self.layout.addRow(label)
+
+    def create_form(self):
+        icon_path = f'{get_app_base_path()}'
+        if os.path.exists(f'{icon_path}/ico'):
+            icon_path = f'{icon_path}/ico'
+        else:
+            icon_path = f'{icon_path}/../ico'
+        icon_path = f'{icon_path}/shinestacker.png'
+        app_icon = QIcon(icon_path)
+        icon_pixmap = app_icon.pixmap(128, 128)
+        icon_label = QLabel()
+        icon_label.setPixmap(icon_pixmap)
+        icon_label.setAlignment(Qt.AlignCenter)
+        self.layout.addRow(icon_label)
+        spacer = QLabel("")
+        spacer.setFixedHeight(10)
+        self.layout.addRow(spacer)
+        self.input_folder = QLineEdit()
+        self.input_folder .setPlaceholderText('input files folder')
+        button = QPushButton("Browse...")
+
+        def browse():
+            path = QFileDialog.getExistingDirectory(None, "Select input files folder")
+            if path:
+                self.input_folder.setText(path)
+        button.clicked.connect(browse)
+        button.setAutoDefault(False)
+        layout = QHBoxLayout()
+        layout.addWidget(self.input_folder)
+        layout.addWidget(button)
+        layout.setContentsMargins(0, 0, 0, 0)
+        container = QWidget()
+        container.setLayout(layout)
+        container.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+
+        self.noise_detection = QCheckBox()
+        self.noise_detection.setChecked(gui_constants.NEW_PROJECT_NOISE_DETECTION)
+        self.vignetting_correction = QCheckBox()
+        self.vignetting_correction.setChecked(gui_constants.NEW_PROJECT_VIGNETTING_CORRECTION)
+        self.align_frames = QCheckBox()
+        self.align_frames.setChecked(gui_constants.NEW_PROJECT_ALIGN_FRAMES)
+        self.balance_frames = QCheckBox()
+        self.balance_frames.setChecked(gui_constants.NEW_PROJECT_BALANCE_FRAMES)
+        self.bunch_stack = QCheckBox()
+        self.bunch_stack.setChecked(gui_constants.NEW_PROJECT_BUNCH_STACK)
+        self.bunch_stack.toggled.connect(self.update_bunch_options)
+        self.bunch_frames = QSpinBox()
+        bunch_frames_range = gui_constants.NEW_PROJECT_BUNCH_FRAMES
+        self.bunch_frames.setRange(bunch_frames_range['min'], bunch_frames_range['max'])
+        self.bunch_frames.setValue(constants.DEFAULT_FRAMES)
+        self.bunch_overlap = QSpinBox()
+        bunch_overlap_range = gui_constants.NEW_PROJECT_BUNCH_OVERLAP
+        self.bunch_overlap.setRange(bunch_overlap_range['min'], bunch_overlap_range['max'])
+        self.bunch_overlap.setValue(constants.DEFAULT_OVERLAP)
+        self.focus_stack_pyramid = QCheckBox()
+        self.focus_stack_pyramid.setChecked(gui_constants.NEW_PROJECT_FOCUS_STACK_PYRAMID)
+        self.focus_stack_depth_map = QCheckBox()
+        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)
+
+        self.add_bold_label("Select input:")
+        self.layout.addRow("Input folder:", container)
+        self.add_bold_label("Select actions:")
+        if self.expert():
+            self.layout.addRow("Automatic noise detection:", self.noise_detection)
+            self.layout.addRow("Vignetting correction:", self.vignetting_correction)
+        self.layout.addRow("Align layers:", self.align_frames)
+        self.layout.addRow("Balance layers:", self.balance_frames)
+        self.layout.addRow("Bunch stack:", self.bunch_stack)
+        self.layout.addRow("Bunch frames:", self.bunch_frames)
+        self.layout.addRow("Bunch frames:", self.bunch_overlap)
+        if self.expert():
+            self.layout.addRow("Focus stack (pyramid):", self.focus_stack_pyramid)
+            self.layout.addRow("Focus stack (depth map):", self.focus_stack_depth_map)
+        else:
+            self.layout.addRow("Focus stack:", self.focus_stack_pyramid)
+            self.layout.addRow("Save multi layer TIFF:", self.multi_layer)
+
+    def update_bunch_options(self, checked):
+        self.bunch_frames.setEnabled(checked)
+        self.bunch_overlap.setEnabled(checked)
+
+    def accept(self):
+        input_folder = self.input_folder.text()
+        if not input_folder:
+            QMessageBox.warning(self, "Input Required", "Please select an input folder")
+            return
+        if not os.path.exists(input_folder):
+            QMessageBox.warning(self, "Invalid Path", "The specified folder does not exist")
+            return
+        if not os.path.isdir(input_folder):
+            QMessageBox.warning(self, "Invalid Path", "The specified path is not a folder")
+            return
+        if len(input_folder.split('/')) < 2:
+            QMessageBox.warning(self, "Invalid Path", "The path must have a parent folder")
+            return
+        super().accept()
+
+    def get_input_folder(self):
+        return self.input_folder.text()
+
+    def get_noise_detection(self):
+        return self.noise_detection.isChecked()
+
+    def get_vignetting_correction(self):
+        return self.vignetting_correction.isChecked()
+
+    def get_align_frames(self):
+        return self.align_frames.isChecked()
+
+    def get_balance_frames(self):
+        return self.balance_frames.isChecked()
+
+    def get_bunch_stack(self):
+        return self.bunch_stack.isChecked()
+
+    def get_bunch_frames(self):
+        return self.bunch_frames.value()
+
+    def get_bunch_overlap(self):
+        return self.bunch_overlap.value()
+
+    def get_focus_stack_pyramid(self):
+        return self.focus_stack_pyramid.isChecked()
+
+    def get_focus_stack_depth_map(self):
+        return self.focus_stack_depth_map.isChecked()
+
+    def get_multi_layer(self):
+        return self.multi_layer.isChecked()

shinestacker/gui/project_converter.py

@@ -0,0 +1,148 @@
+import logging
+import traceback
+from .. config.constants import constants
+from .. core.exceptions import InvalidOptionError, RunStopException
+from .. algorithms.stack_framework import StackJob, CombinedActions
+from .. algorithms.noise_detection import NoiseDetection, MaskNoise
+from .. algorithms.vignetting import Vignetting
+from .. algorithms.align import AlignFrames
+from .. algorithms.balance import BalanceFrames
+from .. algorithms.stack import FocusStack, FocusStackBunch
+from .. algorithms.pyramid import PyramidStack
+from .. algorithms.depth_map import DepthMapStack
+from .. algorithms.multilayer import MultiLayer
+from .project_model import Project, ActionConfig
+
+
+class ProjectConverter:
+    def get_logger(self, logger_name=None):
+        return logging.getLogger(__name__ if logger_name is None else logger_name)
+
+    def run(self, job, logger):
+        if job.enabled:
+            logger.info(f"=== run job: {job.name} ===")
+        else:
+            logger.warning(f"=== job: {job.name} disabled ===")
+        try:
+            job.run()
+            return constants.RUN_COMPLETED, ''
+        except RunStopException:
+            logger.warning(f"=== job: {job.name} stopped ===")
+            return constants.RUN_STOPPED, ''
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            msg = str(e)
+            logger.error(f"=== job: {job.name} failed: {msg} ===")
+            return constants.RUN_FAILED, msg
+
+    def run_project(self, project: Project, logger_name=None, callbacks=None):
+        logger = self.get_logger(logger_name)
+        try:
+            jobs = self.project(project, logger_name, callbacks)
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            return constants.RUN_FAILED, str(e)
+        status = constants.RUN_COMPLETED, ''
+        for job in jobs:
+            job_status, message = self.run(job, logger)
+            if job_status in [constants.RUN_STOPPED, constants.RUN_FAILED]:
+                return job_status, message
+        return status
+
+    def run_job(self, job: ActionConfig, logger_name=None, callbacks=None):
+        logger = self.get_logger(logger_name)
+        try:
+            job = self.job(job, logger_name, callbacks)
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            return constants.RUN_FAILED, str(e)
+        status = self.run(job, logger)
+        return status
+
+    def project(self, project: Project, logger_name=None, callbacks=None):
+        jobs = []
+        for j in project.jobs:
+            job = self.job(j, logger_name, callbacks)
+            if job is None:
+                raise Exception("Job instantiation failed.")
+            else:
+                jobs.append(job)
+        return jobs
+
+    def filter_dict_keys(self, dict, prefix):
+        dict_with = {k.replace(prefix, ''): v for (k, v) in dict.items() if k.startswith(prefix)}
+        dict_without = {k: v for (k, v) in dict.items() if not k.startswith(prefix)}
+        return dict_with, dict_without
+
+    def action(self, action_config):
+        if action_config.type_name == constants.ACTION_NOISEDETECTION:
+            return NoiseDetection(**action_config.params)
+        elif action_config.type_name == constants.ACTION_COMBO:
+            sub_actions = []
+            for sa in action_config.sub_actions:
+                a = self.action(sa)
+                if a is not None:
+                    sub_actions.append(a)
+            a = CombinedActions(**action_config.params, actions=sub_actions)
+            return a
+        elif action_config.type_name == constants.ACTION_MASKNOISE:
+            params = {k: v for k, v in action_config.params.items() if k != 'name'}
+            return MaskNoise(**params)
+        elif action_config.type_name == constants.ACTION_VIGNETTING:
+            params = {k: v for k, v in action_config.params.items() if k != 'name'}
+            return Vignetting(**params)
+        elif action_config.type_name == constants.ACTION_ALIGNFRAMES:
+            params = {k: v for k, v in action_config.params.items() if k != 'name'}
+            return AlignFrames(**params)
+        elif action_config.type_name == constants.ACTION_BALANCEFRAMES:
+            params = {k: v for k, v in action_config.params.items() if k != 'name'}
+            if 'intensity_interval' in params.keys():
+                i = params['intensity_interval']
+                params['intensity_interval'] = {'min': i[0], 'max': i[1]}
+            return BalanceFrames(**params)
+        elif action_config.type_name == constants.ACTION_FOCUSSTACK or action_config.type_name == constants.ACTION_FOCUSSTACKBUNCH:
+            stacker = action_config.params.get('stacker', constants.STACK_ALGO_DEFAULT)
+            if stacker == constants.STACK_ALGO_PYRAMID:
+                algo_dict, module_dict = self.filter_dict_keys(action_config.params, 'pyramid_')
+                stack_algo = PyramidStack(**algo_dict)
+            elif stacker == constants.STACK_ALGO_DEPTH_MAP:
+                algo_dict, module_dict = self.filter_dict_keys(action_config.params, 'depthmap_')
+                stack_algo = DepthMapStack(**algo_dict)
+            else:
+                raise InvalidOptionError('stacker', stacker, f"valid options are: "
+                                         f"{constants.STACK_ALGO_PYRAMID}, "
+                                         f"{constants.STACK_ALGO_PYRAMID_BLOCK}, "
+                                         f"{constants.STACK_ALGO_DEPTH_MAP}")
+            if action_config.type_name == constants.ACTION_FOCUSSTACK:
+                return FocusStack(**module_dict, stack_algo=stack_algo)
+            elif action_config.type_name == constants.ACTION_FOCUSSTACKBUNCH:
+                return FocusStackBunch(**module_dict, stack_algo=stack_algo)
+            else:
+                raise InvalidOptionError("stracker", stacker, details="valid values are: Pyramid, Depth map.")
+        elif action_config.type_name == constants.ACTION_MULTILAYER:
+            input_path = list(filter(lambda p: p != '', action_config.params.get('input_path', '').split(";")))
+            params = {k: v for k, v in action_config.params.items() if k != 'imput_path'}
+            params['input_path'] = [i.strip() for i in input_path]
+            return MultiLayer(**params)
+        else:
+            raise Exception(f"Cannot convert action of type {action_config.type_name}.")
+
+    def job(self, action_config: ActionConfig, logger_name=None, callbacks=None):
+        try:
+            name = action_config.params.get('name', '')
+            enabled = action_config.params.get('enabled', True)
+            working_path = action_config.params.get('working_path', '')
+            input_path = action_config.params.get('input_path', '')
+            stack_job = StackJob(name, working_path, enabled=enabled, input_path=input_path,
+                                 logger_name=logger_name, callbacks=callbacks)
+            for sub in action_config.sub_actions:
+                action = self.action(sub)
+                if action is not None:
+                    stack_job.add_action(action)
+            return stack_job
+        except Exception as e:
+            msg = str(e)
+            logger = self.get_logger(logger_name)
+            logger.error(f"=== can't instantiate job: {name}: {msg} ===")
+            traceback.print_tb(e.__traceback__)
+            raise e