shinestacker 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

shinestacker/__init__.py

@@ -1,3 +1,16 @@
+# flake8: noqa F401 F403
 from ._version import __version__
+from . import config
+from . import core
+from . import algorithms
+from .config import __all__
+from .core import __all__
+from .algorithms import __all__
+from .config import *
+from .core import *
+from .algorithms import *
 
 __all__ = ['__version__']
+#__all__ += config.__all__
+#__all__ += core.__all__
+#__all__ += algorithms.__all__

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '0.2.1'
+__version__ = '0.3.0'

shinestacker/algorithms/__init__.py

@@ -12,3 +12,8 @@ from .vignetting import Vignetting
 import logging
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
+
+__all__ = [
+	'StackJob', 'CombinedActions', 'AlignFrames', 'BalanceFrames', 'FocusStackBunch', 'FocusStack',
+	'DepthMapStack', 'PyramidStack', 'MultiLayer', 'NoiseDetection', 'MaskNoise', 'Vignetting'
+]

shinestacker/algorithms/align.py

@@ -62,7 +62,6 @@ def get_good_matches(des_0, des_1, matching_config=None):
 
 
 def validate_align_config(detector, descriptor, match_method):
-    print(detector, descriptor, match_method)
     if descriptor == constants.DESCRIPTOR_SIFT and match_method == constants.MATCHING_NORM_HAMMING:
         raise ValueError("Descriptor SIFT requires matching method KNN")
     if detector == constants.DETECTOR_ORB and descriptor == constants.DESCRIPTOR_AKAZE and \

shinestacker/algorithms/core_utils.py

@@ -1,5 +1,5 @@
 import os
-from config.config import config
+from ..config.config import config
 
 if not config.DISABLE_TQDM:
     from tqdm import tqdm

shinestacker/algorithms/denoise.py

@@ -0,0 +1,9 @@
+import cv2
+import numpy as np
+
+
+def denoise(image, h_luminance, template_window_size=7, search_window_size=21):
+    norm_type = cv2.NORM_L2 if image.dtype == np.uint8 else cv2.NORM_L1
+    if image.dtype == np.uint16:
+        h_luminance = h_luminance * 256
+    return cv2.fastNlMeansDenoising(image, [h_luminance], None, template_window_size, search_window_size, norm_type)

shinestacker/algorithms/sharpen.py

@@ -0,0 +1,22 @@
+import cv2
+import numpy as np
+
+
+def unsharp_mask(image, radius=1.0, amount=1.0, threshold=0.0):
+    if image.dtype == np.uint16:
+        threshold = threshold * 256
+    blurred = cv2.GaussianBlur(image, (0, 0), radius)
+    if threshold == 0:
+        sharpened = cv2.addWeighted(image, 1.0 + amount, blurred, -amount, 0)
+    else:
+        image_float = image.astype(np.float32)
+        blurred_float = blurred.astype(np.float32)
+        diff = image_float - blurred_float
+        mask = np.abs(diff) > threshold
+        sharpened_float = np.where(mask, image_float + amount * diff, image_float)
+        if np.issubdtype(image.dtype, np.integer):
+            min_val, max_val = np.iinfo(image.dtype).min, np.iinfo(image.dtype).max
+            sharpened = np.clip(sharpened_float, min_val, max_val).astype(image.dtype)
+        else:
+            sharpened = sharpened_float.astype(image.dtype)
+    return sharpened

shinestacker/algorithms/stack.py

@@ -1,5 +1,4 @@
 import numpy as np
-import cv2
 import os
 from .. config.constants import constants
 from .. core.colors import color_str
@@ -8,6 +7,7 @@ from .. core.exceptions import InvalidOptionError
 from .utils import write_img
 from .stack_framework import FrameDirectory, ActionList
 from .exif import copy_exif_from_file_to_file
+from .denoise import denoise
 
 
 class FocusStackBase:
@@ -30,7 +30,7 @@ class FocusStackBase:
         out_filename = f"{self.output_dir}/{self.prefix}{in_filename[0]}." + '.'.join(in_filename[1:])
         if self.denoise > 0:
             self.sub_message_r(': denoise image')
-            stacked_img = cv2.fastNlMeansDenoisingColored(stacked_img, None, self.denoise, self.denoise, 7, 21)
+            stacked_img = denoise(stacked_img, self.denoise, self.denoise)
         write_img(out_filename, stacked_img)
         if self.exif_path != '' and stacked_img.dtype == np.uint8:
             self.sub_message_r(': copy exif data')

shinestacker/app/main.py

@@ -12,7 +12,6 @@ from shinestacker.config.config import config
 config.init(DISABLE_TQDM=True, COMBINED_APP=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
 from shinestacker.core.logging import setup_logging
-from shinestacker.core.core_utils import get_app_base_path
 from shinestacker.gui.main_window import MainWindow
 from shinestacker.retouch.image_editor_ui import ImageEditorUI
 from shinestacker.app.gui_utils import disable_macos_special_menu_items

shinestacker/app/project.py

@@ -12,7 +12,6 @@ from shinestacker.config.config import config
 config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
 from shinestacker.core.logging import setup_logging
-from shinestacker.core.core_utils import get_app_base_path
 from shinestacker.gui.main_window import MainWindow
 from shinestacker.app.gui_utils import disable_macos_special_menu_items
 from shinestacker.app.help_menu import add_help_action

shinestacker/app/retouch.py

@@ -6,7 +6,6 @@ from PySide6.QtGui import QIcon, QAction
 from PySide6.QtCore import Qt, QEvent
 from shinestacker.config.config import config
 config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
-from shinestacker.core.core_utils import get_app_base_path
 from shinestacker.config.config import config
 from shinestacker.config.constants import constants
 from shinestacker.retouch.image_editor_ui import ImageEditorUI

shinestacker/config/__init__.py

@@ -2,3 +2,5 @@
 from .config import config
 from .constants import constants
 from .gui_constants import gui_constants
+
+__all__ = ['config', 'constants', 'gui_constants']

shinestacker/core/__init__.py

@@ -1,5 +1,11 @@
 # flake8: noqa F401
-from .logging import setup_logging, console_logging_overwrite, console_logging_newline
-from .exceptions import (FocusStackError, InvalidOptionError, ImageLoadError, AlignmentError,
-                                    BitDepthError, ShapeError)
-from .framework import TqdmCallbacks
+from .logging import setup_logging
+from .exceptions import (FocusStackError, InvalidOptionError, ImageLoadError, ImageSaveError, AlignmentError,
+                         BitDepthError, ShapeError, RunStopException)
+from .framework import Job
+
+__all__ = [
+    'setup_logging',
+    'FocusStackError', 'InvalidOptionError', 'ImageLoadError', 'ImageSaveError',
+    'AlignmentError','BitDepthError', 'ShapeError', 'RunStopException',
+    'Job']

shinestacker/gui/new_project.py

@@ -6,7 +6,6 @@ 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):

shinestacker/gui/project_editor.py

@@ -1,7 +1,6 @@
 import os
 from dataclasses import dataclass
 from PySide6.QtWidgets import QMainWindow, QListWidget, QMessageBox, QDialog, QListWidgetItem, QLabel
-from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
 from .. config.constants import constants
 from .colors import ColorPalette

shinestacker/retouch/brush_controller.py

@@ -22,7 +22,7 @@ class BrushController:
         y_start, y_end = max(0, y_center - radius), min(h, y_center + radius + 1)
         if x_start >= x_end or y_start >= y_end:
             return 0, 0, 0, 0
-        mask = self._get_brush_mask(radius)
+        mask = self.get_brush_mask(radius)
         if mask is None:
             return 0, 0, 0, 0
         master_area = master_layer[y_start:y_end, x_start:x_end]
@@ -31,10 +31,10 @@ class BrushController:
         mask_layer_area = mask_layer[y_start:y_end, x_start:x_end]
         mask_area = mask[y_start - (y_center - radius):y_end - (y_center - radius), x_start - (x_center - radius):x_end - (x_center - radius)]
         mask_layer_area[:] = np.clip(mask_layer_area + mask_area * self.brush.flow / 100.0, 0.0, 1.0)  # np.maximum(mask_layer_area, mask_area)
-        self._apply_mask(master_area, source_area, mask_layer_area, dest_area)
+        self.apply_mask(master_area, source_area, mask_layer_area, dest_area)
         return x_start, y_start, x_end, y_end
 
-    def _get_brush_mask(self, radius):
+    def get_brush_mask(self, radius):
         mask_key = (radius, self.brush.hardness)
         if mask_key not in self._brush_mask_cache.keys():
             full_mask = create_brush_mask(size=radius * 2 + 1, hardness_percent=self.brush.hardness,
@@ -42,7 +42,7 @@ class BrushController:
             self._brush_mask_cache[mask_key] = full_mask
         return self._brush_mask_cache[mask_key]
 
-    def _apply_mask(self, master_area, source_area, mask_area, dest_area):
+    def apply_mask(self, master_area, source_area, mask_area, dest_area):
         opacity_factor = float(self.brush.opacity) / 100.0
         effective_mask = np.clip(mask_area * opacity_factor, 0, 1)
         dtype = master_area.dtype

shinestacker/retouch/exif_data.py

@@ -3,7 +3,6 @@ from PIL.TiffImagePlugin import IFDRational
 from PySide6.QtWidgets import QFormLayout, QHBoxLayout, QPushButton, QDialog, QLabel
 from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
-from .. core.core_utils import get_app_base_path
 from .. algorithms.exif import exif_dict
 
 

shinestacker/retouch/image_editor.py

@@ -65,6 +65,9 @@ class ImageEditor(QMainWindow):
         self.brush = Brush()
         self.brush_controller = BrushController(self.brush)
         self.undo_manager = UndoManager()
+        self.undo_action = None
+        self.redo_action = None
+        self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
         self.loader_thread = None
 
     def keyPressEvent(self, event):
@@ -201,6 +204,7 @@ class ImageEditor(QMainWindow):
         self.shape = np.array(master_layer).shape
         self.dtype = master_layer.dtype
         self.modified = False
+        self.undo_manager.reset()
         self.blank_layer = np.zeros(master_layer.shape[:2])
         self.update_thumbnails()
         self.image_viewer.setup_brush_cursor()
@@ -381,6 +385,7 @@ class ImageEditor(QMainWindow):
             self.current_layer = 0
             self.current_file_path = ''
             self.modified = False
+            self.undo_manager.reset()
             self.image_viewer.clear_image()
             self.update_thumbnails()
             self.update_title()
@@ -644,6 +649,22 @@ class ImageEditor(QMainWindow):
         if self.update_timer.isActive():
             self.display_master_layer()
             self.update_master_thumbnail()
-            self.undo_manager.save_undo_state(self.master_layer_copy)
+            self.undo_manager.save_undo_state(self.master_layer_copy, 'Brush Stroke')
             self.update_timer.stop()
             self.mark_as_modified()
+
+    def update_undo_redo_actions(self, has_undo, undo_desc, has_redo, redo_desc):
+        if self.undo_action:
+            if has_undo:
+                self.undo_action.setText(f"Undo {undo_desc}")
+                self.undo_action.setEnabled(True)
+            else:
+                self.undo_action.setText("Undo")
+                self.undo_action.setEnabled(False)
+        if self.redo_action:
+            if has_redo:
+                self.redo_action.setText(f"Redo {redo_desc}")
+                self.redo_action.setEnabled(True)
+            else:
+                self.redo_action.setText("Redo")
+                self.redo_action.setEnabled(False)

shinestacker/retouch/image_editor_ui.py

@@ -3,7 +3,7 @@ from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
 from PySide6.QtCore import Qt, QSize, Signal
 from PySide6.QtGui import QGuiApplication
 from .. config.gui_constants import gui_constants
-from .image_editor import ImageEditor
+from .image_filters import ImageFilters
 from .image_viewer import ImageViewer
 from .shortcuts_help import ShortcutsHelp
 
@@ -18,21 +18,19 @@ def brush_size_to_slider(size):
 
 
 class ClickableLabel(QLabel):
-    """QLabel personalizzata che emette un segnale quando viene doppio-clickata"""
-    doubleClicked = Signal()  # PySide6 usa Signal invece di pyqtSignal
+    doubleClicked = Signal()
 
     def __init__(self, text, parent=None):
         super().__init__(text, parent)
         self.setMouseTracking(True)
 
     def mouseDoubleClickEvent(self, event):
-        """Override del doppio click"""
         if event.button() == Qt.LeftButton:
             self.doubleClicked.emit()
         super().mouseDoubleClickEvent(event)
 
 
-class ImageEditorUI(ImageEditor):
+class ImageEditorUI(ImageFilters):
     def __init__(self):
         super().__init__()
         self.setup_ui()
@@ -225,10 +223,16 @@ class ImageEditorUI(ImageEditor):
         file_menu.addAction("Import &EXIF data", self.select_exif_path)
 
         edit_menu = menubar.addMenu("&Edit")
-        undo_action = QAction("Undo Brush", self)
-        undo_action.setShortcut("Ctrl+Z")
-        undo_action.triggered.connect(self.undo_last_brush)
-        edit_menu.addAction(undo_action)
+        self.undo_action = QAction("Undo", self)
+        self.undo_action.setEnabled(False)
+        self.undo_action.setShortcut("Ctrl+Z")
+        self.undo_action.triggered.connect(self.undo_last_brush)
+        edit_menu.addAction(self.undo_action)
+        self.redo_action = QAction("Redo", self)
+        self.redo_action.setEnabled(False)
+        self.redo_action.setShortcut("Ctrl+Y")
+        self.redo_action.triggered.connect(self.redo_last_brush)
+        edit_menu.addAction(self.redo_action)
         edit_menu.addSeparator()
 
         copy_action = QAction("Copy Layer to Master", self)
@@ -314,6 +318,18 @@ class ImageEditorUI(ImageEditor):
         cursor_group.addAction(brush_action)
         cursor_group.setExclusive(True)
 
+        filter_menu = menubar.addMenu("&Filter")
+        filter_menu.setObjectName("Filter")
+        denoise_action = QAction("Denoise", self)
+        denoise_action.triggered.connect(self.denoise)
+        filter_menu.addAction(denoise_action)
+        unsharp_mask_action = QAction("Unsharp Mask", self)
+        unsharp_mask_action.triggered.connect(self.unsharp_mask)
+        filter_menu.addAction(unsharp_mask_action)
+        white_balance_action = QAction("White Balance", self)
+        white_balance_action.triggered.connect(self.white_balance)
+        filter_menu.addAction(white_balance_action)
+
         help_menu = menubar.addMenu("&Help")
         help_menu.setObjectName("Help")
         shortcuts_help_action = QAction("Shortcuts and mouse", self)
@@ -373,6 +389,12 @@ class ImageEditorUI(ImageEditor):
             self.mark_as_modified()
             self.statusBar().showMessage("Undo applied", 2000)
 
+    def redo_last_brush(self):
+        if self.undo_manager.redo(self.master_layer):
+            self.display_current_view()
+            self.mark_as_modified()
+            self.statusBar().showMessage("Redo applied", 2000)
+
     def handle_temp_view(self, start):
         if start:
             self.start_temp_view()

shinestacker/retouch/image_filters.py

@@ -0,0 +1,463 @@
+import numpy as np
+from PySide6.QtWidgets import (QHBoxLayout,
+                               QPushButton, QFrame, QVBoxLayout, QLabel, QDialog, QApplication, QSlider,
+                               QCheckBox, QDialogButtonBox)
+from PySide6.QtGui import QCursor
+from PySide6.QtCore import Qt, QTimer, QThread, Signal
+from .. algorithms.denoise import denoise
+from .. algorithms.sharpen import unsharp_mask
+from .. algorithms.white_balance import white_balance_from_rgb
+from .image_editor import ImageEditor
+
+
+class ImageFilters(ImageEditor):
+    def __init__(self):
+        super().__init__()
+
+    def denoise(self):
+        max_range = 500.0
+        max_value = 5.00
+        initial_value = 2.5
+        self.master_layer_copy = self.master_layer.copy()
+        dlg = QDialog(self)
+        dlg.setWindowTitle("Denoise")
+        dlg.setMinimumWidth(600)
+        layout = QVBoxLayout(dlg)
+        slider_layout = QHBoxLayout()
+        slider = QSlider(Qt.Horizontal)
+        slider.setRange(0, max_range)
+        slider.setValue(initial_value / max_value * max_range)
+        slider_layout.addWidget(slider)
+        value_label = QLabel(f"{max_value:.2f}")
+        slider_layout.addWidget(value_label)
+        layout.addLayout(slider_layout)
+        preview_check = QCheckBox("Preview")
+        preview_check.setChecked(True)
+        layout.addWidget(preview_check)
+        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        layout.addWidget(button_box)
+        last_preview_strength = None
+        preview_timer = QTimer()
+        preview_timer.setSingleShot(True)
+        preview_timer.setInterval(200)
+        active_worker = None
+        last_request_id = 0
+
+        class PreviewWorker(QThread):
+            finished = Signal(np.ndarray, int)
+
+            def __init__(self, image, strength, request_id):
+                super().__init__()
+                self.image = image
+                self.strength = strength
+                self.request_id = request_id
+
+            def run(self):
+                result = denoise(self.image, self.strength)
+                self.finished.emit(result, self.request_id)
+
+        def slider_changed(value):
+            float_value = max_value * value / max_range
+            value_label.setText(f"{float_value:.2f}")
+            if preview_check.isChecked():
+                nonlocal last_preview_strength
+                last_preview_strength = float_value
+                preview_timer.start()
+
+        def do_preview():
+            nonlocal active_worker, last_request_id
+            if last_preview_strength is None:
+                return
+            if active_worker and active_worker.isRunning():
+                active_worker.quit()
+                active_worker.wait()
+            last_request_id += 1
+            current_request_id = last_request_id
+            active_worker = PreviewWorker(
+                self.master_layer_copy.copy(),
+                last_preview_strength,
+                current_request_id
+            )
+            active_worker.finished.connect(
+                lambda img, rid: set_preview(img, rid, current_request_id)
+            )
+            active_worker.start()
+
+        def set_preview(img, request_id, expected_id):
+            if request_id != expected_id:
+                return
+            self.master_layer = img
+            self.display_master_layer()
+            dlg.activateWindow()
+            slider.setFocus()
+
+        def on_preview_toggled(checked):
+            nonlocal last_preview_strength
+            if checked:
+                last_preview_strength = max_value * slider.value() / max_range
+                do_preview()
+            else:
+                self.master_layer = self.master_layer_copy.copy()
+                self.display_master_layer()
+                dlg.activateWindow()
+                slider.setFocus()
+                button_box.setFocus()
+
+        slider.valueChanged.connect(slider_changed)
+        preview_timer.timeout.connect(do_preview)
+        preview_check.stateChanged.connect(on_preview_toggled)
+        button_box.accepted.connect(dlg.accept)
+        button_box.rejected.connect(dlg.reject)
+
+        def run_initial_preview():
+            slider_changed(slider.value())
+
+        QTimer.singleShot(0, run_initial_preview)
+        slider.setFocus()
+        if dlg.exec_() == QDialog.Accepted:
+            strength = max_value * float(slider.value()) / max_range
+            h, w = self.master_layer.shape[:2]
+            self.undo_manager.extend_undo_area(0, 0, w, h)
+            self.undo_manager.save_undo_state(self.master_layer_copy, 'Denoise')
+            self.master_layer = denoise(self.master_layer_copy, strength)
+            self.master_layer_copy = self.master_layer.copy()
+            self.display_master_layer()
+            self.update_master_thumbnail()
+            self.mark_as_modified()
+        else:
+            self.master_layer = self.master_layer_copy.copy()
+            self.display_master_layer()
+
+    def unsharp_mask(self):
+        max_range = 500.0
+        max_radius = 4.0
+        max_amount = 3.0
+        max_threshold = 100.0
+        initial_radius = 1.0
+        initial_amount = 0.5
+        initial_threshold = 0.0
+        self.master_layer_copy = self.master_layer.copy()
+        dlg = QDialog(self)
+        dlg.setWindowTitle("Unsharp Mask")
+        dlg.setMinimumWidth(600)
+        layout = QVBoxLayout(dlg)
+        params = {
+            "Radius": (max_radius, initial_radius, "{:.2f}"),
+            "Amount": (max_amount, initial_amount, "{:.2%}"),
+            "Threshold": (max_threshold, initial_threshold, "{:.2f}")
+        }
+        sliders = {}
+        value_labels = {}
+        for name, (max_val, init_val, fmt) in params.items():
+            param_layout = QHBoxLayout()
+            name_label = QLabel(f"{name}:")
+            param_layout.addWidget(name_label)
+            slider = QSlider(Qt.Horizontal)
+            slider.setRange(0, max_range)
+            slider.setValue(init_val / max_val * max_range)
+            param_layout.addWidget(slider)
+            value_label = QLabel(fmt.format(init_val))
+            param_layout.addWidget(value_label)
+            layout.addLayout(param_layout)
+            sliders[name] = slider
+            value_labels[name] = value_label
+        preview_check = QCheckBox("Preview")
+        preview_check.setChecked(True)
+        layout.addWidget(preview_check)
+        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        layout.addWidget(button_box)
+        last_preview_params = None
+        preview_timer = QTimer()
+        preview_timer.setSingleShot(True)
+        preview_timer.setInterval(200)
+        active_worker = None
+        last_request_id = 0
+
+        class UnsharpWorker(QThread):
+            finished = Signal(np.ndarray, int)
+
+            def __init__(self, image, radius, amount, threshold, request_id):
+                super().__init__()
+                self.image = image
+                self.radius = radius
+                self.amount = amount
+                self.threshold = threshold
+                self.request_id = request_id
+
+            def run(self):
+                result = unsharp_mask(self.image, max(0.01, self.radius), self.amount, self.threshold)
+                self.finished.emit(result, self.request_id)
+
+        def update_param_value(name, value, max_val, fmt):
+            float_value = max_val * value / max_range
+            value_labels[name].setText(fmt.format(float_value))
+            if preview_check.isChecked():
+                nonlocal last_preview_params
+                last_preview_params = (
+                    max_radius * sliders["Radius"].value() / max_range,
+                    max_amount * sliders["Amount"].value() / max_range,
+                    max_threshold * sliders["Threshold"].value() / max_range
+                )
+                preview_timer.start()
+        sliders["Radius"].valueChanged.connect(
+            lambda v: update_param_value("Radius", v, params["Radius"][0], params["Radius"][2]))
+        sliders["Amount"].valueChanged.connect(
+            lambda v: update_param_value("Amount", v, params["Amount"][0], params["Amount"][2]))
+        sliders["Threshold"].valueChanged.connect(
+            lambda v: update_param_value("Threshold", v, params["Threshold"][0], params["Threshold"][2]))
+
+        def do_preview():
+            nonlocal active_worker, last_request_id
+            if last_preview_params is None:
+                return
+            if active_worker and active_worker.isRunning():
+                active_worker.quit()
+                active_worker.wait()
+            last_request_id += 1
+            current_request_id = last_request_id
+            radius, amount, threshold = last_preview_params
+            active_worker = UnsharpWorker(
+                self.master_layer_copy.copy(),
+                radius,
+                amount,
+                threshold,
+                current_request_id
+            )
+            active_worker.finished.connect(lambda img, rid: set_preview(img, rid, current_request_id))
+            active_worker.start()
+
+        def set_preview(img, request_id, expected_id):
+            if request_id != expected_id:
+                return
+            self.master_layer = img
+            self.display_master_layer()
+            dlg.activateWindow()
+            sliders["Radius"].setFocus()
+
+        def on_preview_toggled(checked):
+            nonlocal last_preview_params
+            if checked:
+                last_preview_params = (
+                    max_radius * sliders["Radius"].value() / max_range,
+                    max_amount * sliders["Amount"].value() / max_range,
+                    max_threshold * sliders["Threshold"].value() / max_range
+                )
+                do_preview()
+            else:
+                self.master_layer = self.master_layer_copy.copy()
+                self.display_master_layer()
+                dlg.activateWindow()
+                sliders["Radius"].setFocus()
+
+        preview_timer.timeout.connect(do_preview)
+        preview_check.stateChanged.connect(on_preview_toggled)
+        button_box.accepted.connect(dlg.accept)
+        button_box.rejected.connect(dlg.reject)
+
+        def run_initial_preview():
+            nonlocal last_preview_params
+            last_preview_params = (
+                initial_radius,
+                initial_amount,
+                initial_threshold
+            )
+            do_preview()
+
+        QTimer.singleShot(0, run_initial_preview)
+        sliders["Radius"].setFocus()
+        if dlg.exec_() == QDialog.Accepted:
+            radius = max_radius * sliders["Radius"].value() / max_range
+            amount = max_amount * sliders["Amount"].value() / max_range
+            threshold = max_threshold * sliders["Threshold"].value() / max_range
+            h, w = self.master_layer.shape[:2]
+            self.undo_manager.extend_undo_area(0, 0, w, h)
+            self.undo_manager.save_undo_state(self.master_layer_copy, 'Unsharp Mask')
+            self.master_layer = unsharp_mask(self.master_layer_copy, max(0.01, radius), amount, threshold)
+            self.master_layer_copy = self.master_layer.copy()
+            self.display_master_layer()
+            self.update_master_thumbnail()
+            self.mark_as_modified()
+        else:
+            self.master_layer = self.master_layer_copy.copy()
+            self.display_master_layer()
+
+    def white_balance(self):
+        if hasattr(self, 'wb_dialog') and self.wb_dialog:
+            self.wb_dialog.activateWindow()
+            self.wb_dialog.raise_()
+            return
+        max_range = 255
+        initial_val = 128
+        initial_rgb = (initial_val, initial_val, initial_val)
+        cursor_style = self.image_viewer.cursor_style
+        self.image_viewer.set_cursor_style('outline')
+        if self.image_viewer.brush_cursor:
+            self.image_viewer.brush_cursor.hide()
+        self.master_layer_copy = self.master_layer.copy()
+        self.brush_preview.hide()
+        self.wb_dialog = dlg = QDialog(self)
+        dlg.setWindowTitle("White Balance")
+        dlg.setMinimumWidth(600)
+        layout = QVBoxLayout(dlg)
+        row_layout = QHBoxLayout()
+        color_preview = QFrame()
+        color_preview.setFixedHeight(80)
+        color_preview.setFixedWidth(80)
+        color_preview.setStyleSheet("background-color: rgb(128,128,128);")
+        row_layout.addWidget(color_preview)
+        sliders_layout = QVBoxLayout()
+        sliders = {}
+        value_labels = {}
+        rgb_layouts = {}
+        for name, init_val in zip(("R", "G", "B"), initial_rgb):
+            row = QHBoxLayout()
+            label = QLabel(f"{name}:")
+            row.addWidget(label)
+            slider = QSlider(Qt.Horizontal)
+            slider.setRange(0, max_range)
+            slider.setValue(init_val)
+            row.addWidget(slider)
+            val_label = QLabel(str(init_val))
+            row.addWidget(val_label)
+            sliders_layout.addLayout(row)
+            sliders[name] = slider
+            value_labels[name] = val_label
+            rgb_layouts[name] = row
+        row_layout.addLayout(sliders_layout)
+        layout.addLayout(row_layout)
+        pick_button = QPushButton("Pick Color")
+        layout.addWidget(pick_button)
+
+        def update_preview_color():
+            rgb = tuple(sliders[n].value() for n in ("R", "G", "B"))
+            color_preview.setStyleSheet(f"background-color: rgb{rgb};")
+
+        def schedule_preview():
+            nonlocal last_preview_rgb
+            rgb = tuple(sliders[n].value() for n in ("R", "G", "B"))
+            for n in ("R", "G", "B"):
+                value_labels[n].setText(str(sliders[n].value()))
+            update_preview_color()
+            if preview_check.isChecked() and rgb != last_preview_rgb:
+                last_preview_rgb = rgb
+                preview_timer.start(100)
+
+        def apply_preview():
+            rgb = tuple(sliders[n].value() for n in ("R", "G", "B"))
+            processed = white_balance_from_rgb(self.master_layer_copy, rgb)
+            self.master_layer = processed
+            self.display_master_layer()
+            dlg.activateWindow()
+
+        def on_preview_toggled(checked):
+            nonlocal last_preview_rgb
+            if checked:
+                last_preview_rgb = tuple(sliders[n].value() for n in ("R", "G", "B"))
+                preview_timer.start(100)
+            else:
+                self.master_layer = self.master_layer_copy.copy()
+                self.display_master_layer()
+                dlg.activateWindow()
+
+        preview_check = QCheckBox("Preview")
+        preview_check.setChecked(True)
+        preview_check.stateChanged.connect(on_preview_toggled)
+        layout.addWidget(preview_check)
+        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Reset | QDialogButtonBox.Cancel)
+        layout.addWidget(button_box)
+        last_preview_rgb = None
+        preview_timer = QTimer()
+        preview_timer.setSingleShot(True)
+        preview_timer.timeout.connect(apply_preview)
+        for slider in sliders.values():
+            slider.valueChanged.connect(schedule_preview)
+
+        def start_color_pick():
+            dlg.hide()
+            QApplication.setOverrideCursor(QCursor(Qt.CrossCursor))
+            self.image_viewer.setCursor(Qt.CrossCursor)
+            self.master_layer = self.master_layer_copy
+            self.display_master_layer()
+            self._original_mouse_press = self.image_viewer.mousePressEvent
+            self.image_viewer.mousePressEvent = pick_color_from_click
+
+        def pick_color_from_click(event):
+            if event.button() == Qt.LeftButton:
+                pos = event.pos()
+                bgr = self.get_pixel_color_at(pos)
+                rgb = (bgr[2], bgr[1], bgr[0])
+                for name, val in zip(("R", "G", "B"), rgb):
+                    sliders[name].setValue(val)
+                QApplication.restoreOverrideCursor()
+                self.image_viewer.unsetCursor()
+                if hasattr(self, "_original_mouse_press"):
+                    self.image_viewer.mousePressEvent = self._original_mouse_press
+                dlg.show()
+                dlg.activateWindow()
+                dlg.raise_()
+
+        pick_button.clicked.connect(start_color_pick)
+        button_box.accepted.connect(dlg.accept)
+
+        def cancel_changes():
+            self.master_layer = self.master_layer_copy
+            self.display_master_layer()
+            dlg.reject()
+
+        def reset_rgb():
+            for k, s in sliders.items():
+                s.setValue(initial_val)
+
+        button_box.rejected.connect(cancel_changes)
+        button_box.button(QDialogButtonBox.Reset).clicked.connect(reset_rgb)
+
+        def finish_white_balance(result):
+            if result == QDialog.Accepted:
+                apply_preview()
+                h, w = self.master_layer.shape[:2]
+                self.undo_manager.extend_undo_area(0, 0, w, h)
+                self.undo_manager.save_undo_state(self.master_layer_copy, 'White Balance')
+                self.master_layer_copy = self.master_layer.copy()
+                self.display_master_layer()
+                self.update_master_thumbnail()
+                self.mark_as_modified()
+            self.image_viewer.set_cursor_style(cursor_style)
+            self.wb_dialog = None
+
+        dlg.finished.connect(finish_white_balance)
+        dlg.show()
+
+    def get_pixel_color_at(self, pos, radius=None):
+        scene_pos = self.image_viewer.mapToScene(pos)
+        item_pos = self.image_viewer.pixmap_item.mapFromScene(scene_pos)
+        x = int(item_pos.x())
+        y = int(item_pos.y())
+        if (0 <= x < self.master_layer.shape[1]) and (0 <= y < self.master_layer.shape[0]):
+            if radius is None:
+                radius = int(self.brush.size)
+            if radius > 0:
+                y_indices, x_indices = np.ogrid[-radius:radius + 1, -radius:radius + 1]
+                mask = x_indices**2 + y_indices**2 <= radius**2
+                x0 = max(0, x - radius)
+                x1 = min(self.master_layer.shape[1], x + radius + 1)
+                y0 = max(0, y - radius)
+                y1 = min(self.master_layer.shape[0], y + radius + 1)
+                mask = mask[radius - (y - y0): radius + (y1 - y), radius - (x - x0): radius + (x1 - x)]
+                region = self.master_layer[y0:y1, x0:x1]
+                if region.size == 0:
+                    pixel = self.master_layer[y, x]
+                else:
+                    if region.ndim == 3:
+                        pixel = [region[:, :, c][mask].mean() for c in range(region.shape[2])]
+                    else:
+                        pixel = region[mask].mean()
+            else:
+                pixel = self.master_layer[y, x]
+            if np.isscalar(pixel):
+                pixel = [pixel, pixel, pixel]
+            pixel = [np.float32(x) for x in pixel]
+            if self.master_layer.dtype == np.uint16:
+                pixel = [x / 256.0 for x in pixel]
+            return tuple(int(v) for v in pixel)
+        else:
+            return (0, 0, 0)

shinestacker/retouch/shortcuts_help.py

@@ -3,7 +3,6 @@ from PySide6.QtWidgets import (QFormLayout, QHBoxLayout, QPushButton, QDialog,
                                QLabel, QVBoxLayout, QWidget)
 from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
-from .. core.core_utils import get_app_base_path
 
 
 class ShortcutsHelp(QDialog):

shinestacker/retouch/undo_manager.py

@@ -1,11 +1,19 @@
+from PySide6.QtCore import QObject, Signal
 from .. config.gui_constants import gui_constants
 
 
-class UndoManager:
+class UndoManager(QObject):
+    stack_changed = Signal(bool, str, bool, str)
+
     def __init__(self):
+        super().__init__()
+        self.reset()
+
+    def reset(self):
         self.undo_stack = []
-        self.max_undo_steps = gui_constants.MAX_UNDO_STEPS
+        self.redo_stack = []
         self.reset_undo_area()
+        self.stack_changed.emit(False, "", False, "")
 
     def reset_undo_area(self):
         self.x_end = self.y_end = 0
@@ -17,22 +25,52 @@ class UndoManager:
         self.x_end = max(self.x_end, x_end)
         self.y_end = max(self.y_end, y_end)
 
-    def save_undo_state(self, layer):
+    def save_undo_state(self, layer, description):
         if layer is None:
             return
+        self.redo_stack = []
         undo_state = {
             'master': layer[self.y_start:self.y_end, self.x_start:self.x_end],
-            'area': (self.x_start, self.y_start, self.x_end, self.y_end)
+            'area': (self.x_start, self.y_start, self.x_end, self.y_end),
+            'description': description
         }
-        if len(self.undo_stack) >= self.max_undo_steps:
+        if len(self.undo_stack) >= gui_constants.MAX_UNDO_SIZE:
             self.undo_stack.pop(0)
         self.undo_stack.append(undo_state)
+        undo_desc = description
+        redo_desc = self.redo_stack[-1]['description'] if self.redo_stack else ""
+        self.stack_changed.emit(bool(self.undo_stack), undo_desc, bool(self.redo_stack), redo_desc)
 
     def undo(self, layer):
-        if layer is None or not self.undo_stack or len(self.undo_stack) == 0:
+        if layer is None or not self.undo_stack:
+            return False
+        undo_state = self.undo_stack.pop()
+        x_start, y_start, x_end, y_end = undo_state['area']
+        redo_state = {
+            'master': layer[y_start:y_end, x_start:x_end].copy(),
+            'area': (x_start, y_start, x_end, y_end),
+            'description': undo_state['description']
+        }
+        self.redo_stack.append(redo_state)
+        layer[y_start:y_end, x_start:x_end] = undo_state['master']
+        undo_desc = self.undo_stack[-1]['description'] if self.undo_stack else ""
+        redo_desc = redo_state['description']
+        self.stack_changed.emit(bool(self.undo_stack), undo_desc, bool(self.redo_stack), redo_desc)
+        return True
+
+    def redo(self, layer):
+        if layer is None or not self.redo_stack:
             return False
-        else:
-            undo_state = self.undo_stack.pop()
-            x_start, y_start, x_end, y_end = undo_state['area']
-            layer[y_start:y_end, x_start:x_end] = undo_state['master']
-            return True
+        redo_state = self.redo_stack.pop()
+        x_start, y_start, x_end, y_end = redo_state['area']
+        undo_state = {
+            'master': layer[y_start:y_end, x_start:x_end].copy(),
+            'area': (x_start, y_start, x_end, y_end),
+            'description': redo_state['description']
+        }
+        self.undo_stack.append(undo_state)
+        layer[y_start:y_end, x_start:x_end] = redo_state['master']
+        undo_desc = undo_state['description']
+        redo_desc = self.redo_stack[-1]['description'] if self.redo_stack else ""
+        self.stack_changed.emit(bool(self.undo_stack), undo_desc, bool(self.redo_stack), redo_desc)
+        return True

shinestacker-0.3.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: shinestacker
+Version: 0.3.0
+Summary: ShineStacker
+Author-email: Luca Lista <luka.lista@gmail.com>
+License-Expression: LGPL-3.0
+Project-URL: Homepage, https://github.com/lucalista/shinestacker
+Project-URL: Documentation, https://shinestacker.readthedocs.io/
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argparse
+Requires-Dist: imagecodecs
+Requires-Dist: ipywidgets
+Requires-Dist: jsonpickle
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: opencv_python
+Requires-Dist: pillow
+Requires-Dist: psdtags
+Requires-Dist: PySide6
+Requires-Dist: scipy
+Requires-Dist: tifffile
+Requires-Dist: tqdm
+Requires-Dist: setuptools-scm
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# Shine Stacker
+
+## Focus Stacking Processing Framework and GUI
+
+[![CI multiplatform](https://github.com/lucalista/shinestacker/actions/workflows/ci-multiplatform.yml/badge.svg)](https://github.com/lucalista/shinestacker/actions/workflows/ci-multiplatform.yml)
+[![PyPI version](https://img.shields.io/pypi/v/shinestacker?color=success)](https://pypi.org/project/shinestacker/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/shinestacker)](https://pypi.org/project/shinestacker/)
+[![codecov](https://codecov.io/github/lucalista/shinestacker/graph/badge.svg?token=Y5NKW6VH5G)](https://codecov.io/github/lucalista/shinestacker)
+[![Documentation Status](https://readthedocs.org/projects/shinestacker/badge/?version=latest)](https://shinestacker.readthedocs.io/en/latest/?badge=latest)
+
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies.gif' width="400" referrerpolicy="no-referrer">  <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies_stack.jpg' width="400" referrerpolicy="no-referrer">
+
+> **Focus stacking** for microscopy, macro photography, and computational imaging
+
+## Key Features
+- 🚀 **Batch Processing**: Align, balance, and stack hundreds of images
+- 🎨 **Hybrid Workflows**: Combine Python scripting with GUI refinement
+- 🧩 **Modular Architecture**: Mix-and-match processing modules
+- 🖌️ **Non-Destructive Editing**: Save multilayer TIFFs for retouching
+- 📊 **Jupyter Integration**: Reproducible research notebooks
+
+## Interactive GUI
+
+The GUI has two main working areas: 
+
+* *Project*: manage and run focus stacking workflows in a flexible and configurable way, with optional intermediate batch stacking.
+
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-project-run.png' width="600" referrerpolicy="no-referrer">
+
+* *Retouch*: interactive final refinements to final blended image from individual frames.
+
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-retouch.png' width="600" referrerpolicy="no-referrer">
+
+# Documentation
+
+📖 [Main documentation](https://github.com/lucalista/shinestacker/blob/main/docs/main.md) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md)
+
+
+# Credits
+
+The main pyramid stack algorithm was initially inspired by the [Laplacian pyramids method](https://github.com/sjawhar/focus-stacking) implementation by Sami Jawhar that was used under permission of the author for initial versions of this package. The implementation in the latest releases was rewritten from the original code.
+
+# Resources
+
+* [Pyramid Methods in Image Processing](https://www.researchgate.net/publication/246727904_Pyramid_Methods_in_Image_Processing), E. H. Adelson, C. H. Anderson,  J. R. Bergen, P. J. Burt, J. M. Ogden, RCA Engineer, 29-6, Nov/Dec 1984
+Pyramid methods in image processing
+* [A Multi-focus Image Fusion Method Based on Laplacian Pyramid](http://www.jcomputers.us/vol6/jcp0612-07.pdf), Wencheng Wang, Faliang Chang, Journal of Computers 6 (12), 2559, December 2011
+* Another [original implementation on GitHub](https://github.com/bznick98/Focus_Stacking) by Zongnan Bao
+
+# License
+
+The software is provided as is under the [GNU Lesser General Public License v3.0](https://choosealicense.com/licenses/lgpl-3.0/).
+

{shinestacker-0.2.1.dist-info → shinestacker-0.3.0.dist-info}/RECORD

@@ -1,15 +1,17 @@
-shinestacker/__init__.py,sha256=ZZ2O_m9OFJm18AxMSuYJt4UjSuSqyJlYRaZMoets498,61
-shinestacker/_version.py,sha256=nx8uT9NOkkA2KzjU9Q36cvZlTi-7bCHVPIkXCQkwZf8,21
-shinestacker/algorithms/__init__.py,sha256=XKMSOCBqcpeXng5PJ88wLhxhvSIwBJ6xuBFHfjda4ow,519
-shinestacker/algorithms/align.py,sha256=93szP69KN6BVRmMlU4TsNwBMgpYxEU9fxNzoK07n0Rw,16575
+shinestacker/__init__.py,sha256=sxG9J11a6Qpu_VcqsARRqGSPByHtDvQqR5ozWYjHfZU,387
+shinestacker/_version.py,sha256=gTggO06fb2c9XKEwlQYUSPlUfy82yVlM9pzLMOUqVcY,21
+shinestacker/algorithms/__init__.py,sha256=X9nwToaB13GAACoaE-K0o9R1Jt7g9xSzeJI8Ra2GcL8,722
+shinestacker/algorithms/align.py,sha256=As7MIfjoJc_1vJ058iwP7b_PnDnfYsBQ1JNZ4GX5ZU4,16529
 shinestacker/algorithms/balance.py,sha256=UOmyUPJVBswUYWvYIB8WdlfTAxUAahZrnxQUSrYJ3I4,15649
-shinestacker/algorithms/core_utils.py,sha256=u1aw2-cdA1-RiALxA4rnj38oN2pe2s3BP3T_flvuKMQ,550
+shinestacker/algorithms/core_utils.py,sha256=3mvJVDDfzMOboP724iM_5WT-pLFFoGAhwcXsQN8dBYo,552
+shinestacker/algorithms/denoise.py,sha256=C59la4DEh6uPZIDgmaZIqgxdxDYBxXRxgQBLLBvSlBA,374
 shinestacker/algorithms/depth_map.py,sha256=hx6yyCjLKiu3Wi5uZFXiixEfOBxfieNQ9xH9cp5zD0Y,7844
 shinestacker/algorithms/exif.py,sha256=VS3qbLRVlbZ8_z8hYgGVV4BSmwWzR0reN_G0XV3hzAI,9364
 shinestacker/algorithms/multilayer.py,sha256=Fm-WZqH4DAEOAyC0QpPaMH3VaG5cEPX9rqKsAyWpELs,8694
 shinestacker/algorithms/noise_detection.py,sha256=ra4mkprxPcb5WqHsOdKFUflAmIJ4_nQegYv1EhwH7ts,8280
 shinestacker/algorithms/pyramid.py,sha256=iUbgRI0p0uzEXcZetAm3hgzwiXhF4mIaNxYMUUpJFeE,8589
-shinestacker/algorithms/stack.py,sha256=kEaV2tTYcLbCv_rClYrD_VEQpKy-v-vlQEhu7OLervg,5213
+shinestacker/algorithms/sharpen.py,sha256=KtTDIytJW7z4Oj-E1FcxKvhzz27xLX2CCSwJAG_QRUY,911
+shinestacker/algorithms/stack.py,sha256=EZm2SIuoh8c7hgySB2tQGydKYQjJa2hEqR8YNzIeRuQ,5194
 shinestacker/algorithms/stack_framework.py,sha256=aJBjkQFxiPNjnsnZyoF8lXKR17tm0rTO7puEu_ZvASU,10928
 shinestacker/algorithms/utils.py,sha256=TV3NaGe6_2JTgGdFe4kKNzgihjt6vcK-SLy-HHnbts0,2054
 shinestacker/algorithms/vignetting.py,sha256=EiD4O8GJPGOqByjDAfFj-de4cb64Qf685RujqlBgvX0,6774
@@ -18,15 +20,15 @@ shinestacker/app/about_dialog.py,sha256=G_2hRQFpo96q0H8z02fMZ0Jl_2-PpnwNxqISY7Xn
 shinestacker/app/app_config.py,sha256=tQ1JBTG2gtHO1UbJYJjjYUBCakmtZpafvMUTHb5OyUo,1117
 shinestacker/app/gui_utils.py,sha256=C5ehbYyoIcBweFTfdQcjsILAcWpMPrVLMbYz0ZM-EcM,1571
 shinestacker/app/help_menu.py,sha256=ofFhZMPTz7lQ-_rsu30yAxbLA-Zq_kkRGXxPMukaG08,476
-shinestacker/app/main.py,sha256=cB2uTswNTdKv4Fx8p4CCnSSPp1nPCe7XBzG3PcN1Q-M,6953
+shinestacker/app/main.py,sha256=insz1oxeDlZQWNKo7DGaLmRrc8PZVD7brPRrWE1SWvk,6894
 shinestacker/app/open_frames.py,sha256=uqUihAkP1K2p4bQ8LAQK02XwVddkRJUPy_vzwUgI8jc,1356
-shinestacker/app/project.py,sha256=HjLEDkMXzFL-wXEEnXfHmO317TNhbk8NQfANvISWImk,3293
-shinestacker/app/retouch.py,sha256=rSl-oLeM9a90MH_HrqnKs9EwnDQyCrhN2iuhfdR3xOI,3071
-shinestacker/config/__init__.py,sha256=l9Cg0Rp9sUsY_F7gR2kznuVBkQ-arO7ZOcjS1FoWPtM,121
+shinestacker/app/project.py,sha256=xtuA8SRoWINpHcLTApBL3RYRd0ADrczrAaq_xtT3cZI,3234
+shinestacker/app/retouch.py,sha256=6Sa3ngUqj_Wn5gZBJNZeM-JxeGvXWmJZAa2Jj99t-xk,3012
+shinestacker/config/__init__.py,sha256=gMotpjZz5KyGdytdHhudCVlSKONw8kqMYNRACmlWUw0,172
 shinestacker/config/config.py,sha256=Vif1_-zFZQhI6KW1CAX3Yt-cgwXMJ7YDwDJrzoGVE48,1459
 shinestacker/config/constants.py,sha256=yOt1L7LiJyBPrGezIW-Vx_1I4r1Os0rPibfqroN30nk,5724
 shinestacker/config/gui_constants.py,sha256=PtizNIsLHM_P_GdkrhsSVZuuS5abxOETXozu5eSRt9w,2440
-shinestacker/core/__init__.py,sha256=1Iyzh0CXNlRQhpBJg1QR5Ip3bVS0e1hlOBhTDyrTUBw,301
+shinestacker/core/__init__.py,sha256=tZOPV21QOxH6bEZG21fLxIdGNu9UbbwkFWHgSJkReRk,459
 shinestacker/core/colors.py,sha256=f4_iaNgDYpHfLaoooCsltDxem5fI950GPZlw2lFPqYM,1330
 shinestacker/core/core_utils.py,sha256=EkDJY8g3zLdAqT9hTRZ2_jh3jo8GMF2L6ZBINyG6L6Y,1398
 shinestacker/core/exceptions.py,sha256=TzguZ88XxjgbPs5jMFdrXV2cQRkl5mFfXZin9GRMSRY,1555
@@ -40,9 +42,9 @@ shinestacker/gui/gui_images.py,sha256=3HySCrldbYhUyxO0B1ckC2TLVg5nq94bBXjqsQzCyC
 shinestacker/gui/gui_logging.py,sha256=sN82OsGhMcZdgFMY4z-VbUYiRIsReN-ICaxi31M1J6E,8147
 shinestacker/gui/gui_run.py,sha256=LpBi1V91NrJpVpgS098lSgLtiege0aqcWIGwSbB8cL4,15701
 shinestacker/gui/main_window.py,sha256=KtMe6Hm74xk-lP3qcUsWAw0dzT7CynpdbZA_H651XN0,27203
-shinestacker/gui/new_project.py,sha256=YIWjvxzvWsPoU5_xFJjrs7ceyjxoQtGO3JTLxM3xaoI,7051
+shinestacker/gui/new_project.py,sha256=kGTt8zf24w5o8wUOc0QgXVDbvi4XcM4ia0CZftUImOc,7002
 shinestacker/gui/project_converter.py,sha256=d66pbBzaBgANpudJLW0tGUSfSy0PXNhs1M6R2o_Fd5E,7390
-shinestacker/gui/project_editor.py,sha256=LpopXgw1dPcnH8XulJ7BKpzv9LKoAYUEZ7-d7sEe2tk,21689
+shinestacker/gui/project_editor.py,sha256=s0IU3l3xO_JGovazOHhKkT1rraUWNVzyAua1dsUqJyg,21657
 shinestacker/gui/project_model.py,sha256=buzpxppLuoNWao7M2_FOPVpCBex2WgEcvqyq9dxvrz8,4524
 shinestacker/gui/ico/focus_stack_bkg.png,sha256=Q86TgqvKEi_IzKI8m6aZB2a3T40UkDtexf2PdeBM9XE,163151
 shinestacker/gui/ico/shinestacker.icns,sha256=m_6WQBx8sE9jQKwIRa_B5oa7_VcNn6e2TyijeQXPjwM,337563
@@ -54,18 +56,19 @@ shinestacker/gui/img/play-button-round-icon.png,sha256=9j6Ks9mOGa-2cXyRFpimepAAv
 shinestacker/gui/img/plus-round-line-icon.png,sha256=LS068Hlu-CeBvJuB3dwwdJg1lZq6D5MUIv53lu1yKJA,7534
 shinestacker/retouch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shinestacker/retouch/brush.py,sha256=49YNdZp1dbfowh6HmLfxuHKz7Py9wkFQsN9-pH38P7Q,319
-shinestacker/retouch/brush_controller.py,sha256=M1vXrgL8ETJheT9PJ8EVIHlMqiVRLePvL5GlEcEaZW4,2949
+shinestacker/retouch/brush_controller.py,sha256=R_pWs7Cf_5sC07TkkqqHnX3L_vV5j9CP8S3TkoxYbvs,2945
 shinestacker/retouch/brush_preview.py,sha256=ePyoZPdSY4ytK4uXV-eByQgfsqvhHJqXpleycSxshDg,5247
-shinestacker/retouch/exif_data.py,sha256=MC5kWBpqFXDgRXg15umWrURU_L2gDREjG0wzVaL4qm4,2283
+shinestacker/retouch/exif_data.py,sha256=cYl0ZAAEOmimh2O0REtY0fU_1Y_4uIUtk9orpVLyQKY,2234
 shinestacker/retouch/file_loader.py,sha256=TbPjiD9Vv-i3LCsPVcumYJ2DxgnLmQA6xYCiLCqbEcg,4565
-shinestacker/retouch/image_editor.py,sha256=ehOJgGqvvUOriKyL8s-G0Y-CSYStLo4WCcPzsRy_sys,27579
-shinestacker/retouch/image_editor_ui.py,sha256=wKHqNhcjrPB_qm4zKsTQUw_rXIWzWO3uQUDZvhsbnys,15752
+shinestacker/retouch/image_editor.py,sha256=j-IMm8vWrUgI8XROWgGWDpeQ2HKK5MgrC_BPIr4uijI,28461
+shinestacker/retouch/image_editor_ui.py,sha256=-N_ZSuzC6AjDgf0t04un-WStBQcH3c3-C-6uJjHsXCw,16723
+shinestacker/retouch/image_filters.py,sha256=un1CxlMdfzlBEQ1x7RHPLrb5iDsyUihDYel2uyk40qA,19129
 shinestacker/retouch/image_viewer.py,sha256=5t7JRNoNwSgS7btn7zWmSXPPzXvZKbWBiZMm-YA7Xhg,14827
-shinestacker/retouch/shortcuts_help.py,sha256=femx0BT03XVYVOEyIL0OGVGw00_q0E7zCe8wMA-lQlU,3798
-shinestacker/retouch/undo_manager.py,sha256=R7O0fbdGFRK2ZZMVpbOcqB5stJLpFa-o2p7Kto8daSI,1355
-shinestacker-0.2.1.dist-info/licenses/LICENSE,sha256=cBN0P3F6BWFkfOabkhuTxwJnK1B0v50jmmzZJjGGous,80
-shinestacker-0.2.1.dist-info/METADATA,sha256=Y2fygrS6lSd31sPnpTjhdEdrW5u2i3QdjgCUfeqSPrw,2651
-shinestacker-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shinestacker-0.2.1.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
-shinestacker-0.2.1.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
-shinestacker-0.2.1.dist-info/RECORD,,
+shinestacker/retouch/shortcuts_help.py,sha256=iYwD7YGV2epNDwOBVDc99zqB9bbxLR_IUtanMJ-abPQ,3749
+shinestacker/retouch/undo_manager.py,sha256=5jWPsaERSh7TuWV5EbvqL6EsRS88Ct6VmM7FHxYzufs,3042
+shinestacker-0.3.0.dist-info/licenses/LICENSE,sha256=cBN0P3F6BWFkfOabkhuTxwJnK1B0v50jmmzZJjGGous,80
+shinestacker-0.3.0.dist-info/METADATA,sha256=lqCr530LfhBtToLsuwCNx2LUN37n0pq4QMDgI4LbETE,4219
+shinestacker-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shinestacker-0.3.0.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
+shinestacker-0.3.0.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
+shinestacker-0.3.0.dist-info/RECORD,,

shinestacker-0.2.1.dist-info/METADATA

@@ -1,57 +0,0 @@
-Metadata-Version: 2.4
-Name: shinestacker
-Version: 0.2.1
-Summary: ShineStacker
-Author-email: Luca Lista <luka.lista@gmail.com>
-License-Expression: LGPL-3.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: argparse
-Requires-Dist: imagecodecs
-Requires-Dist: ipywidgets
-Requires-Dist: jsonpickle
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: opencv_python
-Requires-Dist: pillow
-Requires-Dist: psdtags
-Requires-Dist: PySide6
-Requires-Dist: scipy
-Requires-Dist: tifffile
-Requires-Dist: tqdm
-Requires-Dist: setuptools-scm
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Dynamic: license-file
-
-# Shine Stacker Processing Framework
-
-[![CI multiplatform](https://github.com/lucalista/shinestacker/actions/workflows/ci-multiplatform.yml/badge.svg)](https://github.com/lucalista/shinestacker/actions/workflows/ci-multiplatform.yml)
-[![PyPI version](https://badge.fury.io/py/shinestacker.svg)](https://pypi.org/project/shinestacker/)
-[![Python Versions](https://img.shields.io/pypi/pyversions/shinestacker)](https://pypi.org/project/shinestacker/)
-
-<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies.gif' width="400">  <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies_stack.jpg' width="400">
-
-## Documentation
-
-📖 [Main documentation](https://github.com/lucalista/shinestacker/blob/main/docs/main.md) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md)
-
-
-# Credits:
-
-The main pyramid stack algorithm was inspired by the [Laplacian pyramids method](https://github.com/sjawhar/focus-stacking) implementation by Sami Jawhar. The latest implementation was rewritten from the original code that was used under permission of the author for initial versions of this package.
-
-# Resources
-
-* [Pyramid Methods in Image Processing](https://www.researchgate.net/publication/246727904_Pyramid_Methods_in_Image_Processing), E. H. Adelson, C. H. Anderson,  J. R. Bergen, P. J. Burt, J. M. Ogden, RCA Engineer, 29-6, Nov/Dec 1984
-Pyramid methods in image processing
-* [A Multi-focus Image Fusion Method Based on Laplacian Pyramid](http://www.jcomputers.us/vol6/jcp0612-07.pdf), Wencheng Wang, Faliang Chang, Journal of Computers 6 (12), 2559, December 2011
-* Another [original implementation on GitHub](https://github.com/bznick98/Focus_Stacking) by Zongnan Bao
-
-# License
-
-The software is provided as is under the [GNU Lesser General Public License v3.0](https://choosealicense.com/licenses/lgpl-3.0/).
-