shinestacker 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

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()
@@ -174,7 +172,12 @@ class ImageEditorUI(ImageEditor):
         self.thumbnail_list.setFixedWidth(gui_constants.THUMB_WIDTH)
         self.thumbnail_list.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
         self.thumbnail_list.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-        self.thumbnail_list.itemClicked.connect(self.change_layer_item)
+
+        def change_layer_item(item):
+            layer_idx = self.thumbnail_list.row(item)
+            self.change_layer(layer_idx)
+
+        self.thumbnail_list.itemClicked.connect(change_layer_item)
         self.thumbnail_list.setStyleSheet("""
             QListWidget {
                 background-color: #f5f5f5;
@@ -225,10 +228,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)
+        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)
+        edit_menu.addAction(self.redo_action)
         edit_menu.addSeparator()
 
         copy_action = QAction("Copy Layer to Master", self)
@@ -314,6 +323,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)
@@ -365,14 +386,22 @@ class ImageEditorUI(ImageEditor):
             self._update_label_in_data(old_label, new_label, i)
 
     def _update_label_in_data(self, old_label, new_label, i):
-        self.current_labels[i] = new_label
+        self.layer_collection.layer_labels[i] = new_label
 
-    def undo_last_brush(self):
-        if self.undo_manager.undo(self.master_layer):
+    def undo(self):
+        if self.undo_manager.undo(self.layer_collection.master_layer):
             self.display_current_view()
+            self.update_master_thumbnail()
             self.mark_as_modified()
             self.statusBar().showMessage("Undo applied", 2000)
 
+    def redo(self):
+        if self.undo_manager.redo(self.layer_collection.master_layer):
+            self.display_current_view()
+            self.update_master_thumbnail()
+            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,391 @@
+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__()
+
+    class PreviewWorker(QThread):
+        finished = Signal(np.ndarray, int)
+
+        def __init__(self, func, args=(), kwargs=None, request_id=0):
+            super().__init__()
+            self.func = func
+            self.args = args
+            self.kwargs = kwargs or {}
+            self.request_id = request_id
+
+        def run(self):
+            try:
+                result = self.func(*self.args, **self.kwargs)
+            except Exception:
+                raise
+            self.finished.emit(result, self.request_id)
+
+    def connect_preview_toggle(self, preview_check, do_preview, restore_original):
+        def on_toggled(checked):
+            if checked:
+                do_preview()
+            else:
+                restore_original()
+        preview_check.toggled.connect(on_toggled)
+
+    def run_filter_with_preview(self, filter_func, get_params, setup_ui, undo_label):
+        if self.layer_collection.master_layer is None:
+            return
+        self.layer_collection.copy_master_layer()
+        dlg = QDialog(self)
+        layout = QVBoxLayout(dlg)
+        active_worker = None
+        last_request_id = 0
+
+        def set_preview(img, request_id, expected_id):
+            if request_id != expected_id:
+                return
+            self.layer_collection.master_layer = img
+            self.display_master_layer()
+            try:
+                dlg.activateWindow()
+            except Exception:
+                pass
+
+        def do_preview():
+            nonlocal active_worker, last_request_id
+            if active_worker and active_worker.isRunning():
+                try:
+                    active_worker.quit()
+                    active_worker.wait()
+                except Exception:
+                    pass
+            last_request_id += 1
+            current_id = last_request_id
+            params = tuple(get_params() or ())
+            worker = self.PreviewWorker(filter_func, args=(self.layer_collection.master_layer_copy, *params), request_id=current_id)
+            active_worker = worker
+            active_worker.finished.connect(lambda img, rid: set_preview(img, rid, current_id))
+            active_worker.start()
+
+        def restore_original():
+            self.layer_collection.master_layer = self.layer_collection.master_layer_copy.copy()
+            self.display_master_layer()
+            try:
+                dlg.activateWindow()
+            except Exception:
+                pass
+
+        setup_ui(dlg, layout, do_preview, restore_original)
+        QTimer.singleShot(0, do_preview)
+        accepted = dlg.exec_() == QDialog.Accepted
+        if accepted:
+            params = tuple(get_params() or ())
+            try:
+                h, w = self.layer_collection.master_layer.shape[:2]
+            except Exception:
+                h, w = self.layer_collection.master_layer_copy.shape[:2]
+            if hasattr(self, "undo_manager"):
+                try:
+                    self.undo_manager.extend_undo_area(0, 0, w, h)
+                    self.undo_manager.save_undo_state(self.layer_collection.master_layer_copy, undo_label)
+                except Exception:
+                    pass
+            final_img = filter_func(self.layer_collection.master_layer_copy, *params)
+            self.layer_collection.master_layer = final_img
+            self.layer_collection.copy_master_layer()
+            self.display_master_layer()
+            self.update_master_thumbnail()
+            self.mark_as_modified()
+        else:
+            restore_original()
+
+    def denoise(self):
+        max_range = 500.0
+        max_value = 10.00
+        initial_value = 2.5
+
+        def get_params():
+            return (max_value * slider.value() / max_range,)
+
+        def setup_ui(dlg, layout, do_preview, restore_original):
+            nonlocal slider
+            dlg.setWindowTitle("Denoise")
+            dlg.setMinimumWidth(600)
+            slider_layout = QHBoxLayout()
+            slider_local = QSlider(Qt.Horizontal)
+            slider_local.setRange(0, max_range)
+            slider_local.setValue(int(initial_value / max_value * max_range))
+            slider_layout.addWidget(slider_local)
+            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)
+            preview_timer = QTimer()
+            preview_timer.setSingleShot(True)
+            preview_timer.setInterval(200)
+
+            def do_preview_delayed():
+                preview_timer.start()
+
+            def slider_changed(val):
+                float_val = max_value * float(val) / max_range
+                value_label.setText(f"{float_val:.2f}")
+                if preview_check.isChecked():
+                    do_preview_delayed()
+
+            preview_timer.timeout.connect(do_preview)
+            slider_local.valueChanged.connect(slider_changed)
+            self.connect_preview_toggle(preview_check, do_preview_delayed, restore_original)
+            button_box.accepted.connect(dlg.accept)
+            button_box.rejected.connect(dlg.reject)
+            slider = slider_local
+
+        slider = None
+        self.run_filter_with_preview(denoise, get_params, setup_ui, 'Denoise')
+
+    def unsharp_mask(self):
+        max_range = 500.0
+        max_radius = 4.0
+        max_amount = 3.0
+        max_threshold = 64.0
+        initial_radius = 1.0
+        initial_amount = 0.5
+        initial_threshold = 0.0
+
+        def get_params():
+            return (
+                max(0.01, max_radius * radius_slider.value() / max_range),
+                max_amount * amount_slider.value() / max_range,
+                max_threshold * threshold_slider.value() / max_range
+            )
+
+        def setup_ui(dlg, layout, do_preview, restore_original):
+            nonlocal radius_slider, amount_slider, threshold_slider
+            dlg.setWindowTitle("Unsharp Mask")
+            dlg.setMinimumWidth(600)
+            params = {
+                "Radius": (max_radius, initial_radius, "{:.2f}"),
+                "Amount": (max_amount, initial_amount, "{:.1%}"),
+                "Threshold": (max_threshold, initial_threshold, "{:.2f}")
+            }
+            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(int(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)
+                if name == "Radius":
+                    radius_slider = slider
+                elif name == "Amount":
+                    amount_slider = slider
+                elif name == "Threshold":
+                    threshold_slider = 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)
+            preview_timer = QTimer()
+            preview_timer.setSingleShot(True)
+            preview_timer.setInterval(200)
+
+            def update_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():
+                    preview_timer.start()
+
+            radius_slider.valueChanged.connect(
+                lambda v: update_value("Radius", v, max_radius, params["Radius"][2]))
+            amount_slider.valueChanged.connect(
+                lambda v: update_value("Amount", v, max_amount, params["Amount"][2]))
+            threshold_slider.valueChanged.connect(
+                lambda v: update_value("Threshold", v, max_threshold, params["Threshold"][2]))
+            preview_timer.timeout.connect(do_preview)
+            self.connect_preview_toggle(preview_check, do_preview, restore_original)
+            button_box.accepted.connect(dlg.accept)
+            button_box.rejected.connect(dlg.reject)
+            QTimer.singleShot(0, do_preview)
+
+        radius_slider = None
+        amount_slider = None
+        threshold_slider = None
+        self.run_filter_with_preview(unsharp_mask, get_params, setup_ui, 'Unsharp Mask')
+
+    def white_balance(self, init_val=False):
+        max_range = 255
+        if init_val is False:
+            init_val = (128, 128, 128)
+        initial_val = {k: v for k, v in zip(["R", "G", "B"], init_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.brush_preview.hide()
+
+        def get_params():
+            return tuple(sliders[n].value() for n in ("R", "G", "B"))
+
+        def setup_ui(dlg, layout, do_preview, restore_original):
+            nonlocal sliders, value_labels, color_preview, preview_timer
+            self.wb_dialog = dlg
+            dlg.setWindowModality(Qt.ApplicationModal)
+            dlg.setWindowFlags(dlg.windowFlags() | Qt.WindowStaysOnTopHint)
+            dlg.setFocusPolicy(Qt.StrongFocus)
+            dlg.setWindowTitle("White Balance")
+            dlg.setMinimumWidth(600)
+            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 = {}
+            for name in ("R", "G", "B"):
+                row = QHBoxLayout()
+                label = QLabel(f"{name}:")
+                row.addWidget(label)
+                slider = QSlider(Qt.Horizontal)
+                slider.setRange(0, max_range)
+                init_val = initial_val[name]
+                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
+            row_layout.addLayout(sliders_layout)
+            layout.addLayout(row_layout)
+            pick_button = QPushButton("Pick Color")
+            layout.addWidget(pick_button)
+            preview_check = QCheckBox("Preview")
+            preview_check.setChecked(True)
+            layout.addWidget(preview_check)
+            button_box = QDialogButtonBox(
+                QDialogButtonBox.Ok | QDialogButtonBox.Reset | QDialogButtonBox.Cancel
+            )
+            layout.addWidget(button_box)
+            preview_timer = QTimer()
+            preview_timer.setSingleShot(True)
+            preview_timer.setInterval(200)
+
+            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():
+                if preview_check.isChecked():
+                    preview_timer.start()
+
+            def on_slider_change():
+                for name in ("R", "G", "B"):
+                    value_labels[name].setText(str(sliders[name].value()))
+                update_preview_color()
+                schedule_preview()
+
+            for slider in sliders.values():
+                slider.valueChanged.connect(on_slider_change)
+
+            preview_timer.timeout.connect(do_preview)
+            self.connect_preview_toggle(preview_check, do_preview, restore_original)
+
+            def start_color_pick():
+                restore_original()
+                dlg.hide()
+                QApplication.setOverrideCursor(QCursor(Qt.CrossCursor))
+                self.image_viewer.setCursor(Qt.CrossCursor)
+                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, radius=int(self.brush.size))
+                    rgb = (bgr[2], bgr[1], bgr[0])
+                    self.white_balance(rgb)
+
+            def reset_rgb():
+                for name, slider in sliders.items():
+                    slider.setValue(initial_val[name])
+
+            pick_button.clicked.connect(start_color_pick)
+            button_box.accepted.connect(dlg.accept)
+            button_box.rejected.connect(dlg.reject)
+            button_box.button(QDialogButtonBox.Reset).clicked.connect(reset_rgb)
+
+            def on_finished():
+                self.image_viewer.set_cursor_style(cursor_style)
+                self.image_viewer.brush_cursor.show()
+                self.brush_preview.show()
+                if hasattr(self, "_original_mouse_press"):
+                    QApplication.restoreOverrideCursor()
+                    self.image_viewer.unsetCursor()
+                    self.image_viewer.mousePressEvent = self._original_mouse_press
+                    delattr(self, "_original_mouse_press")
+                self.wb_dialog = None
+
+            dlg.finished.connect(on_finished)
+            QTimer.singleShot(0, do_preview)
+
+        sliders = {}
+        value_labels = {}
+        color_preview = None
+        preview_timer = None
+        self.run_filter_with_preview(lambda img, r, g, b: white_balance_from_rgb(img, (r, g, b)),
+                                     get_params, setup_ui, 'White Balance')
+
+    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.layer_collection.master_layer.shape[1]) and (0 <= y < self.layer_collection.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.layer_collection.master_layer.shape[1], x + radius + 1)
+                y0 = max(0, y - radius)
+                y1 = min(self.layer_collection.master_layer.shape[0], y + radius + 1)
+                mask = mask[radius - (y - y0): radius + (y1 - y), radius - (x - x0): radius + (x1 - x)]
+                region = self.layer_collection.master_layer[y0:y1, x0:x1]
+                if region.size == 0:
+                    pixel = self.layer_collection.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.layer_collection.master_layer[y, x]
+            if np.isscalar(pixel):
+                pixel = [pixel, pixel, pixel]
+            pixel = [np.float32(x) for x in pixel]
+            if self.layer_collection.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/image_viewer.py

@@ -1,26 +1,10 @@
 import math
 from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
-from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor, QShortcut, QKeySequence, QRadialGradient
-from PySide6.QtCore import Qt, QRectF, QTime, QPoint, Signal
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor, QShortcut, QKeySequence
+from PySide6.QtCore import Qt, QRectF, QTime, QPoint, QPointF, Signal
 from .. config.gui_constants import gui_constants
 from .brush_preview import BrushPreviewItem
-
-
-def create_brush_gradient(center_x, center_y, radius, hardness, inner_color=None, outer_color=None, opacity=100):
-    gradient = QRadialGradient(center_x, center_y, float(radius))
-    inner = inner_color if inner_color is not None else QColor(*gui_constants.BRUSH_COLORS['inner'])
-    outer = outer_color if outer_color is not None else QColor(*gui_constants.BRUSH_COLORS['gradient_end'])
-    inner_with_opacity = QColor(inner)
-    inner_with_opacity.setAlpha(int(float(inner.alpha()) * float(opacity) / 100.0))
-    if hardness < 100:
-        hardness_normalized = float(hardness) / 100.0
-        gradient.setColorAt(0.0, inner_with_opacity)
-        gradient.setColorAt(hardness_normalized, inner_with_opacity)
-        gradient.setColorAt(1.0, outer)
-    else:
-        gradient.setColorAt(0.0, inner_with_opacity)
-        gradient.setColorAt(1.0, inner_with_opacity)
-    return gradient
+from .brush_gradient import create_brush_gradient
 
 
 class ImageViewer(QGraphicsView):
@@ -74,6 +58,8 @@ class ImageViewer(QGraphicsView):
         self.empty = False
         self.setFocus()
         self.activateWindow()
+        self.brush_preview.layer_collection = self.image_editor.layer_collection
+        self.brush_preview.brush = self.brush
 
     def clear_image(self):
         self.scene.clear()
@@ -123,7 +109,7 @@ class ImageViewer(QGraphicsView):
     def mousePressEvent(self, event):
         if self.empty:
             return
-        if event.button() == Qt.LeftButton and self.image_editor.master_layer is not None:
+        if event.button() == Qt.LeftButton and self.image_editor.layer_collection.master_layer is not None:
             if self.space_pressed:
                 self.scrolling = True
                 self.last_mouse_pos = event.position()
@@ -245,7 +231,13 @@ class ImageViewer(QGraphicsView):
         if self.cursor_style == 'preview' and allow_cursor_preview:
             self._setup_outline_style()
             self.brush_cursor.hide()
-            self.brush_preview.update(self.image_editor, QCursor.pos(), int(size))
+            pos = QCursor.pos()
+            if isinstance(pos, QPointF):
+                scene_pos = pos
+            else:
+                cursor_pos = self.image_editor.image_viewer.mapFromGlobal(pos)
+                scene_pos = self.image_editor.image_viewer.mapToScene(cursor_pos)
+            self.brush_preview.update(scene_pos, int(size))
         else:
             self.brush_preview.hide()
             if self.cursor_style == 'outline' or not allow_cursor_preview:

shinestacker/retouch/io_manager.py

@@ -0,0 +1,57 @@
+import cv2
+from .. core.exceptions import ShapeError, BitDepthError
+from .. algorithms.utils import read_img, validate_image, get_img_metadata
+from .. algorithms.exif import get_exif, write_image_with_exif_data
+from .. algorithms.multilayer import write_multilayer_tiff_from_images
+
+
+class IOManager:
+    def __init__(self, layer_collection):
+        self.layer_collection = layer_collection
+        self.current_file_path = ''
+        self.exif_path = ''
+        self.exif_data = None
+
+    def import_frames(self, file_paths):
+        stack = []
+        labels = []
+        master = None
+        shape, dtype = get_img_metadata(self.layer_collection.master_layer)
+        for path in file_paths:
+            try:
+                label = path.split("/")[-1].split(".")[0]
+                img = cv2.cvtColor(read_img(path), cv2.COLOR_BGR2RGB)
+                if shape is not None and dtype is not None:
+                    validate_image(img, shape, dtype)
+                else:
+                    shape, dtype = get_img_metadata(img)
+                label_x = label
+                i = 0
+                while label_x in labels:
+                    i += 1
+                    label_x = f"{label} ({i})"
+                labels.append(label_x)
+                stack.append(img)
+                if master is None:
+                    master = img.copy()
+            except ShapeError as e:
+                raise ShapeError(f"All files must have the same shape.\n{str(e)}")
+            except BitDepthError as e:
+                raise BitDepthError(f"All files must have the same bit depth.\n{str(e)}")
+            except Exception as e:
+                raise RuntimeError(f"Error loading file: {path}.\n{str(e)}")
+        return stack, labels, master
+
+    def save_multilayer(self, path):
+        master_layer = {'Master': self.layer_collection.master_layer}
+        individual_layers = {label: image for label, image in zip(
+            self.layer_collection.layer_labels, self.layer_collection.layer_stack)}
+        write_multilayer_tiff_from_images({**master_layer, **individual_layers}, path, exif_path=self.exif_path)
+
+    def save_master(self, path):
+        img = cv2.cvtColor(self.layer_collection.master_layer, cv2.COLOR_RGB2BGR)
+        write_image_with_exif_data(self.exif_data, img, path)
+
+    def set_exif_data(self, path):
+        self.exif_path = path
+        self.exif_data = get_exif(path)

shinestacker/retouch/layer_collection.py

@@ -0,0 +1,54 @@
+import numpy as np
+
+
+class LayerCollection:
+    def __init__(self):
+        self.master_layer = None
+        self.master_layer_copy = None
+        self.layer_stack = None
+        self.layer_labels = None
+        self.current_layer_idx = 0
+
+    def number_of_layers(self):
+        return len(self.layer_stack)
+
+    def valid_current_layer_idx(self):
+        return 0 <= self.current_layer_idx < self.number_of_layers()
+
+    def current_layer(self):
+        if self.layer_stack is not None and self.valid_current_layer_idx():
+            return self.layer_stack[self.current_layer_idx]
+        return None
+
+    def copy_master_layer(self):
+        self.master_layer_copy = self.master_layer.copy()
+
+    def sort_layers(self, order):
+        master_index = -1
+        master_label = None
+        master_layer = None
+        for i, label in enumerate(self.layer_labels):
+            if label.lower() == "master":
+                master_index = i
+                master_label = self.layer_labels.pop(i)
+                master_layer = self.layer_stack[i]
+                self.layer_stack = np.delete(self.layer_stack, i, axis=0)
+                break
+        if order == 'asc':
+            self.sorted_indices = sorted(range(len(self.layer_labels)),
+                                         key=lambda i: self.layer_labels[i].lower())
+        elif order == 'desc':
+            self.sorted_indices = sorted(range(len(self.layer_labels)),
+                                         key=lambda i: self.layer_labels[i].lower(),
+                                         reverse=True)
+        else:
+            raise ValueError(f"Invalid sorting order: {order}")
+        self.layer_labels = [self.layer_labels[i] for i in self.sorted_indices]
+        self.layer_stack = self.layer_stack[self.sorted_indices]
+        if master_index != -1:
+            self.layer_labels.insert(0, master_label)
+            self.layer_stack = np.insert(self.layer_stack, 0, master_layer, axis=0)
+            self.master_layer = master_layer.copy()
+            self.master_layer.setflags(write=True)
+        if self.current_layer_idx >= self.number_of_layers():
+            self.current_layer_idx = self.number_of_layers() - 1