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

shinestacker/retouch/brush_controller.py

@@ -0,0 +1,57 @@
+import numpy as np
+from .. config.constants import constants
+from .brush_preview import create_brush_mask
+
+
+class BrushController:
+    def __init__(self, brush):
+        self._brush_mask_cache = {}
+        self.brush = brush
+
+    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/brush_preview.py

@@ -0,0 +1,126 @@
+import numpy as np
+from PySide6.QtWidgets import QGraphicsPixmapItem
+from PySide6.QtCore import Qt, QPointF
+from PySide6.QtGui import QPixmap, QPainter, QImage
+
+
+def brush_profile_lower_limited(r, hardness):
+    if hardness >= 1.0:
+        result = np.where(r < 1.0, 1.0, 0.0)
+    else:
+        r_lim = np.where(r < 1.0, r, 1.0)
+        k = 1.0 / (1.0 - hardness)
+        result = 0.5 * (np.cos(np.pi * np.power(r_lim, k)) + 1.0)
+    return result
+
+
+def brush_profile(r, hardness):
+    h = 2.0 * hardness - 1.0
+    if h >= 1.0:
+        result = np.where(r < 1.0, 1.0, 0.0)
+    elif h >= 0:
+        k = 1.0 / (1.0 - hardness)
+        result = 0.5 * (np.cos(np.pi * np.power(np.where(r < 1.0, r, 1.0), k)) + 1.0)
+    elif h < 0:
+        k = 1.0 / (1.0 + hardness)
+        result = np.where(r < 1.0, 0.5 * (1.0 - np.cos(np.pi * np.power(1.0 - np.where(r < 1.0, r, 1.0), k))), 0.0)
+    else:
+        result = np.zeros_like(r)
+    return result
+
+
+def create_brush_mask(size, hardness_percent, opacity_percent):
+    radius = size / 2.0
+    center = (size - 1) / 2.0
+    h, o = hardness_percent / 100.0, opacity_percent / 100.0
+    y, x = np.ogrid[:size, :size]
+    r = np.sqrt((x - center)**2 + (y - center)**2) / radius
+    mask = np.clip(brush_profile(r, h), 0.0, 1.0) * o
+    return mask
+
+
+class BrushPreviewItem(QGraphicsPixmapItem):
+    def __init__(self):
+        super().__init__()
+        self.setVisible(False)
+        self.setZValue(500)
+        self.setTransformationMode(Qt.SmoothTransformation)
+
+    def get_layer_area(self, layer, x, y, w, h):
+        if not isinstance(layer, np.ndarray):
+            self.hide()
+            return None
+        height, width = layer.shape[:2]
+        x_start, y_start = max(0, x), max(0, y)
+        x_end, y_end = min(width, x + w), min(height, y + h)
+        if x_end <= x_start or y_end <= y_start:
+            self.hide()
+            return None
+        area = np.ascontiguousarray(layer[y_start:y_end, x_start:x_end])
+        if area.ndim == 2:  # grayscale
+            area = np.ascontiguousarray(np.stack([area] * 3, axis=-1))
+        elif area.shape[2] == 4:  # RGBA
+            area = np.ascontiguousarray(area[..., :3])  # RGB
+        if area.dtype == np.uint8:
+            return area.astype(np.float32) / 256.0
+        elif area.dtype == np.uint16:
+            return area.astype(np.float32) / 65536.0
+        else:
+            raise Exception("Bitmas is neither 8 bit nor 16, but of type " + area.dtype)
+
+    def update(self, editor, pos, size):
+        try:
+            if editor.current_stack is None or not hasattr(editor, 'image_viewer') or size <= 0:
+                self.hide()
+                return
+            radius = size // 2
+            if isinstance(pos, QPointF):
+                scene_pos = pos
+            else:
+                cursor_pos = editor.image_viewer.mapFromGlobal(pos)
+                scene_pos = editor.image_viewer.mapToScene(cursor_pos)
+            x = int(scene_pos.x() - radius + 0.5)
+            y = int(scene_pos.y() - radius)
+            w = h = size
+            if editor.current_layer < 0 or editor.current_layer >= len(editor.current_stack):
+                self.hide()
+                return
+            layer_area = self.get_layer_area(editor.current_stack[editor.current_layer], x, y, w, h)
+            master_area = self.get_layer_area(editor.master_layer, x, y, w, h)
+            if layer_area is None or master_area is None:
+                self.hide()
+                return
+            height, width = editor.current_stack[editor.current_layer].shape[:2]
+            full_mask = create_brush_mask(size=size, hardness_percent=editor.brush.hardness,
+                                          opacity_percent=editor.brush.opacity)[:, :, np.newaxis]
+            mask_x_start = max(0, -x) if x < 0 else 0
+            mask_y_start = max(0, -y) if y < 0 else 0
+            mask_x_end = size - (max(0, (x + w) - width)) if (x + w) > width else size
+            mask_y_end = size - (max(0, (y + h) - height)) if (y + h) > height else size
+            mask_area = full_mask[mask_y_start:mask_y_end, mask_x_start:mask_x_end]
+            area = (layer_area * mask_area + master_area * (1 - mask_area)) * 255.0
+            area = area.astype(np.uint8)
+            qimage = QImage(area.data, area.shape[1], area.shape[0], area.strides[0], QImage.Format_RGB888)
+            mask = QPixmap(w, h)
+            mask.fill(Qt.transparent)
+            painter = QPainter(mask)
+            painter.setPen(Qt.NoPen)
+            painter.setBrush(Qt.black)
+            painter.drawEllipse(0, 0, w, h)
+            painter.end()
+            pixmap = QPixmap.fromImage(qimage)
+            final_pixmap = QPixmap(w, h)
+            final_pixmap.fill(Qt.transparent)
+            painter = QPainter(final_pixmap)
+            painter.drawPixmap(0, 0, pixmap)
+            painter.setCompositionMode(QPainter.CompositionMode_DestinationIn)
+            painter.drawPixmap(0, 0, mask)
+            painter.end()
+            self.setPixmap(final_pixmap)
+            x_start, y_start = max(0, x), max(0, y)
+            self.setPos(x_start, y_start)
+            self.show()
+        except Exception:
+            import traceback
+            traceback.print_exc()
+            self.hide()

shinestacker/retouch/exif_data.py

@@ -0,0 +1,65 @@
+import os
+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
+
+
+class ExifData(QDialog):
+    def __init__(self, exif, parent=None):
+        super().__init__(parent)
+        self.exif = exif
+        self.setWindowTitle("EXIF data")
+        self.resize(500, self.height())
+        self.layout = QFormLayout(self)
+        self.layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        self.layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+        self.layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.layout.setLabelAlignment(Qt.AlignLeft)
+        self.create_form()
+        button_box = QHBoxLayout()
+        ok_button = QPushButton("OK")
+        ok_button.setFocus()
+        button_box.addWidget(ok_button)
+        self.layout.addRow(button_box)
+        ok_button.clicked.connect(self.accept)
+
+    def add_bold_label(self, label):
+        label = QLabel(label)
+        label.setStyleSheet("font-weight: bold")
+        self.layout.addRow(label)
+
+    def create_form(self):
+        icon_path = f'{get_app_base_path()}'
+        if os.path.exists(f'{icon_path}/ico'):
+            icon_path = f'{icon_path}/ico'
+        else:
+            icon_path = f'{icon_path}/../ico'
+        icon_path = f'{icon_path}/shinestacker.png'
+        app_icon = QIcon(icon_path)
+        icon_pixmap = app_icon.pixmap(128, 128)
+        icon_label = QLabel()
+        icon_label.setPixmap(icon_pixmap)
+        icon_label.setAlignment(Qt.AlignCenter)
+        self.layout.addRow(icon_label)
+        spacer = QLabel("")
+        spacer.setFixedHeight(10)
+        self.layout.addRow(spacer)
+        self.add_bold_label("EXIF data")
+        shortcuts = {}
+        if self.exif is None:
+            shortcuts['Warning:'] = 'no EXIF data found'
+        else:
+            data = exif_dict(self.exif)
+        if len(data) > 0:
+            for k, (t, d) in data.items():
+                if isinstance(d, IFDRational):
+                    d = f"{d.numerator}/{d.denominator}"
+                else:
+                    d = f"{d}"
+                if "<<<" not in d and k != 'IPTCNAA':
+                    self.layout.addRow(f"<b>{k}:</b>", QLabel(d))
+        else:
+            self.layout.addRow("-", QLabel("Empty EXIF dictionary"))

shinestacker/retouch/file_loader.py

@@ -0,0 +1,104 @@
+import numpy as np
+import traceback
+import cv2
+import os
+from psdtags import PsdChannelId
+from PySide6.QtCore import QThread, Signal
+from .. algorithms.utils import read_img
+from .. algorithms.multilayer import read_multilayer_tiff
+
+
+class FileLoader(QThread):
+    finished = Signal(object, object, object)
+    error = Signal(str)
+
+    def __init__(self, path):
+        super().__init__()
+        self.path = path
+
+    def run(self):
+        try:
+            current_stack, current_labels = self.load_stack(self.path)
+            if current_stack is None or len(current_stack) == 0:
+                self.error.emit("Empty or invalid stack")
+                return
+            if current_labels:
+                master_indices = [i for i, label in enumerate(current_labels) if label.lower() == "master"]
+            else:
+                master_indices = []
+            master_index = -1 if len(master_indices) == 0 else master_indices[0]
+            if master_index == -1:
+                master_layer = current_stack[0].copy()
+            else:
+                current_labels.pop(master_index)
+                master_layer = current_stack[master_index].copy()
+                indices = list(range(len(current_stack)))
+                indices.remove(master_index)
+                current_stack = current_stack[indices]
+            master_layer.setflags(write=True)
+            if current_labels is None:
+                current_labels = [f"Layer {i + 1}" for i in range(len(current_stack))]
+            self.finished.emit(current_stack, current_labels, master_layer)
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            self.error.emit(f"Error loading file:\n{str(e)}")
+
+    def load_stack(self, path):
+        if not os.path.exists(path):
+            raise RuntimeError(f"Path {path} does not exist.")
+        if not os.path.isfile(path):
+            raise RuntimeError(f"Path {path} is not a file.")
+        extension = path.split('.')[-1]
+        if extension in ['jpg', 'jpeg']:
+            try:
+                stack = np.array([cv2.cvtColor(read_img(path), cv2.COLOR_BGR2RGB)])
+                return stack, [path.split('/')[-1].split('.')[0]]
+            except Exception as e:
+                traceback.print_tb(e.__traceback__)
+                return None, None
+        elif extension in ['tif', 'tiff']:
+            try:
+                psd_data = read_multilayer_tiff(path)
+                layers = []
+                labels = []
+                for layer in reversed(psd_data.layers.layers):
+                    channels = {}
+                    for channel in layer.channels:
+                        channels[channel.channelid] = channel.data
+                    if PsdChannelId.CHANNEL0 in channels:
+                        img = np.stack([
+                            channels[PsdChannelId.CHANNEL0],
+                            channels[PsdChannelId.CHANNEL1],
+                            channels[PsdChannelId.CHANNEL2]
+                        ], axis=-1)
+                        layers.append(img)
+                        labels.append(layer.name)
+                if layers:
+                    stack = np.array(layers)
+                    if labels:
+                        master_indices = [i for i, label in enumerate(labels) if label.lower() == "master"]
+                        if master_indices:
+                            master_index = master_indices[0]
+                            master_label = labels.pop(master_index)
+                            master_layer = stack[master_index]
+                            stack = np.delete(stack, master_index, axis=0)
+                            labels.insert(0, master_label)
+                            stack = np.insert(stack, 0, master_layer, axis=0)
+                        return stack, labels
+                    return stack, labels
+            except ValueError as e:
+                if str(e) == "TIFF file contains no ImageSourceData tag":
+                    try:
+                        stack = np.array([cv2.cvtColor(read_img(path), cv2.COLOR_BGR2RGB)])
+                        return stack, [path.split('/')[-1].split('.')[0]]
+                    except Exception as e:
+                        traceback.print_tb(e.__traceback__)
+                        return None, None
+                else:
+                    traceback.print_tb(e.__traceback__)
+                    raise e
+            except Exception as e:
+                traceback.print_tb(e.__traceback__)
+                return None, None
+        else:
+            return None, None