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

shinestacker/retouch/denoise_filter.py

@@ -0,0 +1,56 @@
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QSlider, QCheckBox, QDialogButtonBox
+from PySide6.QtCore import Qt, QTimer
+from .filter_base import BaseFilter
+
+
+class DenoiseFilter(BaseFilter):
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.max_range = 500.0
+        self.max_value = 10.00
+        self.initial_value = 2.5
+        self.slider = None
+
+    def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
+        dlg.setWindowTitle("Denoise")
+        dlg.setMinimumWidth(600)
+        slider_layout = QHBoxLayout()
+        slider_local = QSlider(Qt.Horizontal)
+        slider_local.setRange(0, self.max_range)
+        slider_local.setValue(int(self.initial_value / self.max_value * self.max_range))
+        slider_layout.addWidget(slider_local)
+        value_label = QLabel(f"{self.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()
+
+        preview_timer.timeout.connect(do_preview)
+
+        def slider_changed(val):
+            float_val = self.max_value * float(val) / self.max_range
+            value_label.setText(f"{float_val:.2f}")
+            if preview_check.isChecked():
+                do_preview_delayed()
+
+        slider_local.valueChanged.connect(slider_changed)
+        self.editor.connect_preview_toggle(preview_check, do_preview_delayed, restore_original)
+        button_box.accepted.connect(dlg.accept)
+        button_box.rejected.connect(dlg.reject)
+        self.slider = slider_local
+
+    def get_params(self):
+        return (self.max_value * self.slider.value() / self.max_range,)
+
+    def apply(self, image, strength):
+        from .. algorithms.denoise import denoise
+        return denoise(image, strength)

shinestacker/retouch/display_manager.py

@@ -0,0 +1,177 @@
+import numpy as np
+from PySide6.QtWidgets import QWidget, QListWidgetItem, QVBoxLayout, QLabel, QInputDialog
+from PySide6.QtGui import QPixmap, QImage
+from PySide6.QtCore import Qt, QObject, QTimer, QSize, Signal
+from .. config.gui_constants import gui_constants
+
+
+class ClickableLabel(QLabel):
+    double_clicked = Signal()
+
+    def __init__(self, text, parent=None):
+        super().__init__(text, parent)
+        self.setMouseTracking(True)
+
+    def mouseDoubleClickEvent(self, event):
+        if event.button() == Qt.LeftButton:
+            self.double_clicked.emit()
+        super().mouseDoubleClickEvent(event)
+
+
+class DisplayManager(QObject):
+    status_message_requested = Signal(str)
+    cursor_preview_state_changed = Signal(bool)
+
+    def __init__(self, layer_collection, image_viewer, master_thumbnail_label,
+                 thumbnail_list, parent=None):
+        super().__init__(parent)
+        layer_collection.add_to(self)
+        self.image_viewer = image_viewer
+        self.master_thumbnail_label = master_thumbnail_label
+        self.thumbnail_list = thumbnail_list
+        self.view_mode = 'master'
+        self.temp_view_individual = False
+        self.needs_update = False
+        self.update_timer = QTimer()
+        self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
+        self.update_timer.timeout.connect(self.process_pending_updates)
+
+    def process_pending_updates(self):
+        if self.needs_update:
+            self.display_master_layer()
+            self.needs_update = False
+
+    def display_image(self, img):
+        if img is None:
+            self.image_viewer.clear_image()
+        else:
+            self.image_viewer.set_image(self.numpy_to_qimage(img))
+
+    def display_current_layer(self):
+        self.display_image(self.current_layer())
+
+    def display_master_layer(self):
+        self.display_image(self.master_layer())
+
+    def display_current_view(self):
+        if self.temp_view_individual or self.view_mode == 'individual':
+            self.display_current_layer()
+        else:
+            self.display_master_layer()
+
+    def create_thumbnail(self, layer):
+        if layer.dtype == np.uint16:
+            layer = (layer // 256).astype(np.uint8)
+        height, width = layer.shape[:2]
+        if layer.ndim == 3 and layer.shape[-1] == 3:
+            qimg = QImage(layer.data, width, height, 3 * width, QImage.Format_RGB888)
+        else:
+            qimg = QImage(layer.data, width, height, width, QImage.Format_Grayscale8)
+        return QPixmap.fromImage(qimg.scaled(*gui_constants.UI_SIZES['thumbnail'], Qt.KeepAspectRatio))
+
+    def update_thumbnails(self):
+        self.update_master_thumbnail()
+        thumbnails = []
+        if self.layer_stack() is None:
+            return
+        for i, (layer, label) in enumerate(zip(self.layer_stack(), self.layer_labels())):
+            thumbnail = self.create_thumbnail(layer)
+            thumbnails.append((thumbnail, label, i, i == self.current_layer_idx()))
+        self._update_thumbnail_list(thumbnails)
+
+    def _update_thumbnail_list(self, thumbnails):
+        self.thumbnail_list.clear()
+        for thumb_data in thumbnails:
+            thumbnail, label, index, is_current = thumb_data
+            self.add_thumbnail_item(thumbnail, label, index, is_current)
+
+    def update_master_thumbnail(self):
+        if self.has_no_master_layer():
+            self._clear_master_thumbnail()
+        else:
+            self._set_master_thumbnail(self.create_thumbnail(self.master_layer()))
+
+    def _clear_master_thumbnail(self):
+        self.master_thumbnail_label.clear()
+
+    def _set_master_thumbnail(self, pixmap):
+        self.master_thumbnail_label.setPixmap(pixmap)
+
+    def add_thumbnail_item(self, thumbnail, label, i, is_current):
+        item_widget = QWidget()
+        layout = QVBoxLayout(item_widget)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        thumbnail_label = QLabel()
+        thumbnail_label.setPixmap(thumbnail)
+        thumbnail_label.setAlignment(Qt.AlignCenter)
+        layout.addWidget(thumbnail_label)
+
+        label_widget = ClickableLabel(label)
+        label_widget.setAlignment(Qt.AlignCenter)
+
+        def rename_label(label_widget, old_label, i):
+            new_label, ok = QInputDialog.getText(self.thumbnail_list, "Rename Label", "New label name:", text=old_label)
+            if ok and new_label and new_label != old_label:
+                label_widget.setText(new_label)
+                self.set_layer_labels(i, new_label)
+
+        label_widget.double_clicked.connect(lambda: rename_label(label_widget, label, i))
+        layout.addWidget(label_widget)
+        item = QListWidgetItem()
+        item.setSizeHint(QSize(gui_constants.IMG_WIDTH, gui_constants.IMG_HEIGHT))
+        self.thumbnail_list.addItem(item)
+        self.thumbnail_list.setItemWidget(item, item_widget)
+
+        if is_current:
+            self.thumbnail_list.setCurrentItem(item)
+
+    def set_view_master(self):
+        if self.has_no_master_layer():
+            return
+        self.view_mode = 'master'
+        self.temp_view_individual = False
+        self.display_master_layer()
+        self.status_message_requested.emit("View mode: Master")
+        self.cursor_preview_state_changed.emit(True)  # True = allow preview
+
+    def set_view_individual(self):
+        if self.has_no_master_layer():
+            return
+        self.view_mode = 'individual'
+        self.temp_view_individual = False
+        self.display_current_layer()
+        self.status_message_requested.emit("View mode: Individual layers")
+        self.cursor_preview_state_changed.emit(False)  # False = no preview
+
+    def start_temp_view(self):
+        if not self.temp_view_individual and self.view_mode == 'master':
+            self.temp_view_individual = True
+            self.image_viewer.update_brush_cursor()
+            self.display_current_layer()
+            self.status_message_requested.emit("Temporary view: Individual layer (hold X)")
+
+    def end_temp_view(self):
+        if self.temp_view_individual:
+            self.temp_view_individual = False
+            self.image_viewer.update_brush_cursor()
+            self.display_master_layer()
+            self.status_message_requested.emit("View mode: Master")
+            self.cursor_preview_state_changed.emit(True)  # Restore preview
+
+    def numpy_to_qimage(self, array):
+        if array.dtype == np.uint16:
+            array = np.right_shift(array, 8).astype(np.uint8)
+        if array.ndim == 2:
+            height, width = array.shape
+            return QImage(memoryview(array), width, height, width, QImage.Format_Grayscale8)
+        if array.ndim == 3:
+            height, width, _ = array.shape
+            if not array.flags['C_CONTIGUOUS']:
+                array = np.ascontiguousarray(array)
+            return QImage(memoryview(array), width, height, 3 * width, QImage.Format_RGB888)
+        return QImage()
+
+    def allow_cursor_preview(self):
+        return self.view_mode == 'master' and not self.temp_view_individual

shinestacker/retouch/exif_data.py

@@ -45,10 +45,11 @@ class ExifData(QDialog):
         shortcuts = {}
         if self.exif is None:
             shortcuts['Warning:'] = 'no EXIF data found'
+            data = {}
         else:
             data = exif_dict(self.exif)
         if len(data) > 0:
-            for k, (t, d) in data.items():
+            for k, (_, d) in data.items():
                 if isinstance(d, IFDRational):
                     d = f"{d.numerator}/{d.denominator}"
                 else:

shinestacker/retouch/filter_base.py

@@ -0,0 +1,114 @@
+import numpy as np
+from abc import ABC, abstractmethod
+from PySide6.QtWidgets import QDialog, QVBoxLayout
+from PySide6.QtCore import Signal, QThread, QTimer
+
+
+class BaseFilter(ABC):
+    def __init__(self, editor):
+        self.editor = editor
+        self.undo_label = self.__class__.__name__
+
+    @abstractmethod
+    def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
+        pass
+
+    @abstractmethod
+    def get_params(self):
+        pass
+
+    @abstractmethod
+    def apply(self, image, *params):
+        pass
+
+    def run_with_preview(self, **kwargs):
+        if self.editor.layer_collection.master_layer is None:
+            return
+
+        self.editor.layer_collection.copy_master_layer()
+        dlg = QDialog(self.editor)
+        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.editor.layer_collection.master_layer = img
+            self.editor.display_manager.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(self.get_params() or ())
+            worker = self.PreviewWorker(
+                self.apply,
+                args=(self.editor.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.editor.layer_collection.master_layer = self.editor.layer_collection.master_layer_copy.copy()
+            self.editor.display_manager.display_master_layer()
+            try:
+                dlg.activateWindow()
+            except Exception:
+                pass
+
+        self.setup_ui(dlg, layout, do_preview, restore_original, **kwargs)
+        QTimer.singleShot(0, do_preview)
+        accepted = dlg.exec_() == QDialog.Accepted
+        if accepted:
+            params = tuple(self.get_params() or ())
+            try:
+                h, w = self.editor.layer_collection.master_layer.shape[:2]
+            except Exception:
+                h, w = self.editor.layer_collection.master_layer_copy.shape[:2]
+            if hasattr(self.editor, "undo_manager"):
+                try:
+                    self.editor.undo_manager.extend_undo_area(0, 0, w, h)
+                    self.editor.undo_manager.save_undo_state(
+                        self.editor.layer_collection.master_layer_copy,
+                        self.undo_label
+                    )
+                except Exception:
+                    pass
+            final_img = self.apply(self.editor.layer_collection.master_layer_copy, *params)
+            self.editor.layer_collection.master_layer = final_img
+            self.editor.layer_collection.copy_master_layer()
+            self.editor.display_manager.display_master_layer()
+            self.editor.display_manager.update_master_thumbnail()
+            self.editor.mark_as_modified()
+        else:
+            restore_original()
+
+    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)

shinestacker/retouch/filter_manager.py

@@ -0,0 +1,14 @@
+class FilterManager:
+    def __init__(self, editor):
+        self.editor = editor
+        self.filters = {}
+
+    def register_filter(self, name, filter_class):
+        self.filters[name] = filter_class(self.editor)
+
+    def get_filter(self, name):
+        return self.filters.get(name)
+
+    def apply(self, name, **kwargs):
+        if name in self.filters:
+            self.filters[name].run_with_preview(**kwargs)