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

shinestacker/retouch/brush_tool.py

@@ -0,0 +1,164 @@
+import numpy as np
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush
+from PySide6.QtCore import Qt, QPoint
+from .brush_gradient import create_brush_gradient
+from .. config.gui_constants import gui_constants
+from .. config.constants import constants
+from .brush_preview import create_brush_mask
+
+
+class BrushTool:
+    def __init__(self):
+        self.brush = None
+        self.brush_preview = None
+        self.image_viewer = None
+        self.size_slider = None
+        self.hardness_slider = None
+        self.opacity_slider = None
+        self.flow_slider = None
+        self._brush_mask_cache = {}
+
+    def setup_ui(self, brush, brush_preview, image_viewer, size_slider, hardness_slider,
+                 opacity_slider, flow_slider):
+        self.brush = brush
+        self.brush_preview = brush_preview
+        self.image_viewer = image_viewer
+        self.size_slider = size_slider
+        self.hardness_slider = hardness_slider
+        self.opacity_slider = opacity_slider
+        self.flow_slider = flow_slider
+        self.size_slider.valueChanged.connect(self.update_brush_size)
+        self.hardness_slider.valueChanged.connect(self.update_brush_hardness)
+        self.opacity_slider.valueChanged.connect(self.update_brush_opacity)
+        self.flow_slider.valueChanged.connect(self.update_brush_flow)
+        self.update_brush_size(self.size_slider.value())
+        self.update_brush_hardness(self.hardness_slider.value())
+        self.update_brush_opacity(self.opacity_slider.value())
+        self.update_brush_flow(self.flow_slider.value())
+
+    def update_brush_size(self, slider_val):
+
+        def slider_to_brush_size(slider_val):
+            normalized = slider_val / gui_constants.BRUSH_SIZE_SLIDER_MAX
+            size = gui_constants.BRUSH_SIZES['min'] + \
+                gui_constants.BRUSH_SIZES['max'] * (normalized ** gui_constants.BRUSH_GAMMA)
+            return max(gui_constants.BRUSH_SIZES['min'], min(gui_constants.BRUSH_SIZES['max'], size))
+
+        self.brush.size = slider_to_brush_size(slider_val)
+        self.update_brush_thumb()
+
+    def increase_brush_size(self, amount=5):
+        val = min(self.size_slider.value() + amount, self.size_slider.maximum())
+        self.size_slider.setValue(val)
+        self.update_brush_size(val)
+
+    def decrease_brush_size(self, amount=5):
+        val = max(self.size_slider.value() - amount, self.size_slider.minimum())
+        self.size_slider.setValue(val)
+        self.update_brush_size(val)
+
+    def increase_brush_hardness(self, amount=2):
+        val = min(self.hardness_slider.value() + amount, self.hardness_slider.maximum())
+        self.hardness_slider.setValue(val)
+        self.update_brush_hardness(val)
+
+    def decrease_brush_hardness(self, amount=2):
+        val = max(self.hardness_slider.value() - amount, self.hardness_slider.minimum())
+        self.hardness_slider.setValue(val)
+        self.update_brush_hardness(val)
+
+    def update_brush_hardness(self, hardness):
+        self.brush.hardness = hardness
+        self.update_brush_thumb()
+
+    def update_brush_opacity(self, opacity):
+        self.brush.opacity = opacity
+        self.update_brush_thumb()
+
+    def update_brush_flow(self, flow):
+        self.brush.flow = flow
+        self.update_brush_thumb()
+
+    def update_brush_thumb(self):
+        width, height = gui_constants.UI_SIZES['brush_preview']
+        pixmap = QPixmap(width, height)
+        pixmap.fill(Qt.transparent)
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.Antialiasing)
+        preview_size = min(self.brush.size, width + 30, height + 30)
+        center_x, center_y = width // 2, height // 2
+        radius = preview_size // 2
+        if self.image_viewer.cursor_style == 'preview':
+            gradient = create_brush_gradient(
+                center_x, center_y, radius,
+                self.brush.hardness,
+                inner_color=QColor(*gui_constants.BRUSH_COLORS['inner']),
+                outer_color=QColor(*gui_constants.BRUSH_COLORS['gradient_end']),
+                opacity=self.brush.opacity
+            )
+            painter.setBrush(QBrush(gradient))
+            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['outer']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+        elif self.image_viewer.cursor_style == 'outline':
+            painter.setBrush(Qt.NoBrush)
+            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['outer']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+        else:
+            painter.setBrush(QBrush(QColor(*gui_constants.BRUSH_COLORS['cursor_inner'])))
+            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+        painter.drawEllipse(QPoint(center_x, center_y), radius, radius)
+        if self.image_viewer.cursor_style == 'preview':
+            painter.setPen(QPen(QColor(0, 0, 160)))
+            painter.drawText(0, 10, f"Size: {int(self.brush.size)}px")
+            painter.drawText(0, 25, f"Hardness: {self.brush.hardness}%")
+            painter.drawText(0, 40, f"Opacity: {self.brush.opacity}%")
+            painter.drawText(0, 55, f"Flow: {self.brush.flow}%")
+        painter.end()
+        self.brush_preview.setPixmap(pixmap)
+        self.image_viewer.update_brush_cursor()
+
+    def apply_brush_operation(self, master_layer, source_layer, dest_layer, mask_layer, view_pos, image_viewer):
+        if master_layer is None or source_layer is None:
+            return False
+        if dest_layer is None:
+            dest_layer = master_layer
+        scene_pos = image_viewer.mapToScene(view_pos)
+        x_center = int(round(scene_pos.x()))
+        y_center = int(round(scene_pos.y()))
+        radius = int(round(self.brush.size // 2))
+        h, w = master_layer.shape[:2]
+        x_start, x_end = max(0, x_center - radius), min(w, x_center + radius + 1)
+        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)
+        if mask is None:
+            return 0, 0, 0, 0
+        master_area = master_layer[y_start:y_end, x_start:x_end]
+        source_area = source_layer[y_start:y_end, x_start:x_end]
+        dest_area = dest_layer[y_start:y_end, x_start:x_end]
+        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)
+        return x_start, y_start, x_end, y_end
+
+    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,
+                                          opacity_percent=self.brush.opacity)
+            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):
+        opacity_factor = float(self.brush.opacity) / 100.0
+        effective_mask = np.clip(mask_area * opacity_factor, 0, 1)
+        dtype = master_area.dtype
+        max_px_value = constants.MAX_UINT16 if dtype == np.uint16 else constants.MAX_UINT8
+        if master_area.ndim == 3:
+            dest_area[:] = np.clip(master_area * (1 - effective_mask[..., np.newaxis]) + source_area * # noqa
+                                   effective_mask[..., np.newaxis], 0, max_px_value).astype(dtype)
+        else:
+            dest_area[:] = np.clip(master_area * (1 - effective_mask) + source_area * effective_mask, 0, max_px_value).astype(dtype)
+
+    def clear_cache(self):
+        self._brush_mask_cache.clear()

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)