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

shinestacker/retouch/image_viewer.py

@@ -0,0 +1,356 @@
+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 .. 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
+
+
+class ImageViewer(QGraphicsView):
+    temp_view_requested = Signal(bool)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.image_editor = None
+        self.brush = None
+        self.cursor_style = gui_constants.DEFAULT_CURSOR_STYLE
+        self.scene = QGraphicsScene(self)
+        self.setScene(self.scene)
+        self.pixmap_item = QGraphicsPixmapItem()
+        self.scene.addItem(self.pixmap_item)
+        self.pixmap_item.setPixmap(QPixmap())
+        self.scene.setBackgroundBrush(QBrush(QColor(120, 120, 120)))
+        self.zoom_factor = 1.0
+        self.min_scale = 0.0
+        self.max_scale = 0.0
+        self.last_mouse_pos = None
+        self.setRenderHint(QPainter.Antialiasing)
+        self.setRenderHint(QPainter.SmoothPixmapTransform)
+        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
+        self.setResizeAnchor(QGraphicsView.AnchorUnderMouse)
+        self.setDragMode(QGraphicsView.ScrollHandDrag)
+        self.brush_cursor = None
+        self.setMouseTracking(True)
+        self.space_pressed = False
+        self.control_pressed = False
+        self.setDragMode(QGraphicsView.NoDrag)
+        self.scrolling = False
+        self.dragging = False
+        self.last_update_time = QTime.currentTime()
+        self.brush_preview = BrushPreviewItem()
+        self.scene.addItem(self.brush_preview)
+        self.empty = True
+
+    def set_image(self, qimage):
+        pixmap = QPixmap.fromImage(qimage)
+        self.pixmap_item.setPixmap(pixmap)
+        self.setSceneRect(QRectF(pixmap.rect()))
+        img_width = pixmap.width()
+        self.min_scale = gui_constants.MIN_ZOOMED_IMG_WIDTH / img_width
+        self.max_scale = gui_constants.MAX_ZOOMED_IMG_PX_SIZE
+        if self.zoom_factor == 1.0:
+            self.fitInView(self.pixmap_item, Qt.KeepAspectRatio)
+            self.zoom_factor = self.get_current_scale()
+            self.zoom_factor = max(self.min_scale, min(self.max_scale, self.zoom_factor))
+            self.resetTransform()
+            self.scale(self.zoom_factor, self.zoom_factor)
+        self.empty = False
+        self.setFocus()
+        self.activateWindow()
+
+    def clear_image(self):
+        self.scene.clear()
+        self.pixmap_item = QGraphicsPixmapItem()
+        self.scene.addItem(self.pixmap_item)
+        self.zoom_factor = 1.0
+        self.setup_brush_cursor()
+        self.brush_preview = BrushPreviewItem()
+        self.scene.addItem(self.brush_preview)
+        self.setCursor(Qt.ArrowCursor)
+        self.brush_cursor.hide()
+        self.empty = True
+
+    def keyPressEvent(self, event):
+        if self.empty:
+            return
+        if event.key() == Qt.Key_Space and not self.scrolling:
+            self.space_pressed = True
+            self.setCursor(Qt.OpenHandCursor)
+            if self.brush_cursor:
+                self.brush_cursor.hide()
+        elif event.key() == Qt.Key_X:
+            self.temp_view_requested.emit(True)
+            self.update_brush_cursor()
+            return
+        if event.key() == Qt.Key_Control and not self.scrolling:
+            self.control_pressed = True
+        super().keyPressEvent(event)
+
+    def keyReleaseEvent(self, event):
+        if self.empty:
+            return
+        self.update_brush_cursor()
+        if event.key() == Qt.Key_Space:
+            self.space_pressed = False
+            if not self.scrolling:
+                self.setCursor(Qt.BlankCursor)
+                if self.brush_cursor:
+                    self.brush_cursor.show()
+        elif event.key() == Qt.Key_X:
+            self.temp_view_requested.emit(False)
+            return
+        if event.key() == Qt.Key_Control:
+            self.control_pressed = False
+        super().keyReleaseEvent(event)
+
+    def mousePressEvent(self, event):
+        if self.empty:
+            return
+        if event.button() == Qt.LeftButton and self.image_editor.master_layer is not None:
+            if self.space_pressed:
+                self.scrolling = True
+                self.last_mouse_pos = event.position()
+                self.setCursor(Qt.ClosedHandCursor)
+                if self.brush_cursor:
+                    self.brush_cursor.hide()
+            else:
+                self.last_brush_pos = event.position()
+                self.image_editor.begin_copy_brush_area(event.position().toPoint())
+                self.dragging = True
+                if self.brush_cursor:
+                    self.brush_cursor.show()
+        super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event):
+        if self.empty:
+            return
+        position = event.position()
+        brush_size = self.brush.size
+        if not self.space_pressed:
+            self.update_brush_cursor()
+        if self.dragging and event.buttons() & Qt.LeftButton:
+            current_time = QTime.currentTime()
+            if self.last_update_time.msecsTo(current_time) >= gui_constants.PAINT_REFRESH_TIMER:
+                min_step = brush_size * gui_constants.MIN_MOUSE_STEP_BRUSH_FRACTION * self.zoom_factor
+                x, y = position.x(), position.y()
+                xp, yp = self.last_brush_pos.x(), self.last_brush_pos.y()
+                distance = math.sqrt((x - xp)**2 + (y - yp)**2)
+                n_steps = int(float(distance) / min_step)
+                if n_steps > 0:
+                    delta_x = (position.x() - self.last_brush_pos.x()) / n_steps
+                    delta_y = (position.y() - self.last_brush_pos.y()) / n_steps
+                    for i in range(0, n_steps + 1):
+                        pos = QPoint(self.last_brush_pos.x() + i * delta_x,
+                                     self.last_brush_pos.y() + i * delta_y)
+                        self.image_editor.continue_copy_brush_area(pos)
+                    self.last_brush_pos = position
+                self.last_update_time = current_time
+        if self.scrolling and event.buttons() & Qt.LeftButton:
+            if self.space_pressed:
+                self.setCursor(Qt.ClosedHandCursor)
+                if self.brush_cursor:
+                    self.brush_cursor.hide()
+            delta = position - self.last_mouse_pos
+            self.last_mouse_pos = position
+            self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() - delta.x())
+            self.verticalScrollBar().setValue(self.verticalScrollBar().value() - delta.y())
+        else:
+            super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event):
+        if self.empty:
+            return
+        if self.space_pressed:
+            self.setCursor(Qt.OpenHandCursor)
+            if self.brush_cursor:
+                self.brush_cursor.hide()
+        else:
+            self.setCursor(Qt.BlankCursor)
+            if self.brush_cursor:
+                self.brush_cursor.show()
+        if event.button() == Qt.LeftButton:
+            if self.scrolling:
+                self.scrolling = False
+                self.last_mouse_pos = None
+            elif hasattr(self, 'dragging') and self.dragging:
+                self.dragging = False
+                self.image_editor.end_copy_brush_area()
+        super().mouseReleaseEvent(event)
+
+    def wheelEvent(self, event):
+        if self.empty:
+            return
+        if self.control_pressed:
+            if event.angleDelta().y() > 0:
+                self.image_editor.decrease_brush_size()
+            else:
+                self.image_editor.increase_brush_size()
+        else:
+            zoom_in_factor = 1.10
+            zoom_out_factor = 1 / zoom_in_factor
+            current_scale = self.get_current_scale()
+            if event.angleDelta().y() > 0:  # Zoom in
+                new_scale = current_scale * zoom_in_factor
+                if new_scale <= self.max_scale:
+                    self.scale(zoom_in_factor, zoom_in_factor)
+                    self.zoom_factor = new_scale
+            else:  # Zoom out
+                new_scale = current_scale * zoom_out_factor
+                if new_scale >= self.min_scale:
+                    self.scale(zoom_out_factor, zoom_out_factor)
+                    self.zoom_factor = new_scale
+        self.update_brush_cursor()
+
+    def setup_brush_cursor(self):
+        self.setCursor(Qt.BlankCursor)
+        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), 1)
+        brush = QBrush(QColor(*gui_constants.BRUSH_COLORS['cursor_inner']))
+        self.brush_cursor = self.scene.addEllipse(0, 0, self.brush.size, self.brush.size, pen, brush)
+        self.brush_cursor.setZValue(1000)
+        self.brush_cursor.hide()
+
+    def update_brush_cursor(self):
+        if self.empty:
+            return
+        if not self.brush_cursor or not self.isVisible():
+            return
+        size = self.brush.size
+        mouse_pos = self.mapFromGlobal(QCursor.pos())
+        if not self.rect().contains(mouse_pos):
+            self.brush_cursor.hide()
+            return
+        scene_pos = self.mapToScene(mouse_pos)
+        center_x = scene_pos.x()
+        center_y = scene_pos.y()
+        radius = size / 2
+        self.brush_cursor.setRect(center_x - radius, center_y - radius, size, size)
+        allow_cursor_preview = self.image_editor.allow_cursor_preview()
+        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))
+        else:
+            self.brush_preview.hide()
+            if self.cursor_style == 'outline' or not allow_cursor_preview:
+                self._setup_outline_style()
+            else:
+                self._setup_simple_brush_style(center_x, center_y, radius)
+        if not self.brush_cursor.isVisible():
+            self.brush_cursor.show()
+
+    def _setup_outline_style(self):
+        self.brush_cursor.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
+                                      gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor))
+        self.brush_cursor.setBrush(Qt.NoBrush)
+
+    def _setup_simple_brush_style(self, center_x, center_y, radius):
+        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
+        )
+        self.brush_cursor.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
+                                      gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor))
+        self.brush_cursor.setBrush(QBrush(gradient))
+
+    def enterEvent(self, event):
+        self.activateWindow()
+        self.setFocus()
+        if not self.empty:
+            self.setCursor(Qt.BlankCursor)
+            if self.brush_cursor:
+                self.brush_cursor.show()
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        if not self.empty:
+            self.setCursor(Qt.ArrowCursor)
+            if self.brush_cursor:
+                self.brush_cursor.hide()
+        super().leaveEvent(event)
+
+    def setup_shortcuts(self):
+        prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
+        prev_layer.activated.connect(self.prev_layer)
+        next_layer = QShortcut(QKeySequence(Qt.Key_Down), self, context=Qt.ApplicationShortcut)
+        next_layer.activated.connect(self.next_layer)
+
+    def zoom_in(self):
+        if self.empty:
+            return
+        current_scale = self.get_current_scale()
+        new_scale = current_scale * gui_constants.ZOOM_IN_FACTOR
+        if new_scale <= self.max_scale:
+            self.scale(gui_constants.ZOOM_IN_FACTOR, gui_constants.ZOOM_IN_FACTOR)
+            self.zoom_factor = new_scale
+            self.update_brush_cursor()
+
+    def zoom_out(self):
+        if self.empty:
+            return
+        current_scale = self.get_current_scale()
+        new_scale = current_scale * gui_constants.ZOOM_OUT_FACTOR
+        if new_scale >= self.min_scale:
+            self.scale(gui_constants.ZOOM_OUT_FACTOR, gui_constants.ZOOM_OUT_FACTOR)
+            self.zoom_factor = new_scale
+            self.update_brush_cursor()
+
+    def reset_zoom(self):
+        if self.empty:
+            return
+        self.fitInView(self.pixmap_item, Qt.KeepAspectRatio)
+        self.zoom_factor = self.get_current_scale()
+        self.zoom_factor = max(self.min_scale, min(self.max_scale, self.zoom_factor))
+        self.resetTransform()
+        self.scale(self.zoom_factor, self.zoom_factor)
+        self.update_brush_cursor()
+
+    def actual_size(self):
+        if self.empty:
+            return
+        self.zoom_factor = max(self.min_scale, min(self.max_scale, 1.0))
+        self.resetTransform()
+        self.scale(self.zoom_factor, self.zoom_factor)
+        self.update_brush_cursor()
+
+    def get_current_scale(self):
+        return self.transform().m11()
+
+    def get_view_state(self):
+        return {
+            'zoom': self.zoom_factor,
+            'h_scroll': self.horizontalScrollBar().value(),
+            'v_scroll': self.verticalScrollBar().value()
+        }
+
+    def set_view_state(self, state):
+        if state:
+            self.resetTransform()
+            self.scale(state['zoom'], state['zoom'])
+            self.horizontalScrollBar().setValue(state['h_scroll'])
+            self.verticalScrollBar().setValue(state['v_scroll'])
+            self.zoom_factor = state['zoom']
+
+    def set_cursor_style(self, style):
+        self.cursor_style = style
+        if self.brush_cursor:
+            self.update_brush_cursor()

shinestacker/retouch/shortcuts_help.py

@@ -0,0 +1,98 @@
+import os
+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):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Shortcut Help")
+        self.resize(600, self.height())
+        self.layout = QVBoxLayout(self)
+        main_widget = QWidget()
+        main_layout = QHBoxLayout(main_widget)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        left_column = QWidget()
+        left_layout = QFormLayout(left_column)
+        left_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        left_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+        left_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+        left_layout.setLabelAlignment(Qt.AlignLeft)
+        right_column = QWidget()
+        right_layout = QFormLayout(right_column)
+        right_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        right_layout.setRowWrapPolicy(QFormLayout.DontWrapRows)
+        right_layout.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
+        right_layout.setLabelAlignment(Qt.AlignLeft)
+        main_layout.addWidget(left_column)
+        main_layout.addWidget(right_column)
+        self.layout.addWidget(main_widget)
+        self.create_form(left_layout, right_layout)
+        button_box = QHBoxLayout()
+        ok_button = QPushButton("OK")
+        ok_button.setFocus()
+        button_box.addWidget(ok_button)
+        self.layout.addLayout(button_box)
+        ok_button.clicked.connect(self.accept)
+
+    def add_bold_label(self, layout, label):
+        label = QLabel(label)
+        label.setStyleSheet("font-weight: bold")
+        layout.addRow(label)
+
+    def create_form(self, left_layout, right_layout):
+        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)
+        icon_container = QWidget()
+        icon_container_layout = QHBoxLayout(icon_container)
+        icon_container_layout.addWidget(icon_label)
+        icon_container_layout.setAlignment(Qt.AlignCenter)
+        self.layout.insertWidget(0, icon_container)
+
+        shortcuts = {
+            "M": "show master layer",
+            "L": "show selected layer",
+            "X": "temp. toggle between master and source layer",
+            "↑": "select one layer up",
+            "↓": "selcet one layer down",
+            "Ctrl + O": "open file",
+            "Ctrl + S": "save multilayer tiff",
+            "Crtl + Z": "undo brush draw",
+            "Ctrl + M": "copy selected layer to master",
+            "Ctrl + Cmd + F": "full screen mode",
+            "Ctrl + +": "zoom in",
+            "Ctrl + -": "zoom out",
+            "Ctrl + 0": "adapt to screen",
+            "Ctrl + =": "actual size",
+            "[": "increase brush size",
+            "]": "decrease brush size",
+            "{": "increase brush hardness",
+            "}": "decrease brush hardness"
+        }
+
+        self.add_bold_label(left_layout, "Keyboard Shortcuts")
+        for k, v in shortcuts.items():
+            left_layout.addRow(f"<b>{k}</b>", QLabel(v))
+
+        mouse_controls = {
+            "Space + Drag": "pan",
+            "Wheel": "zoom in/out",
+            "Ctrl + Wheel": "adjust brush size",
+            "Left Click": "brush action",
+        }
+
+        self.add_bold_label(right_layout, "Mouse Controls")
+        for k, v in mouse_controls.items():
+            right_layout.addRow(f"<b>{k}</b>", QLabel(v))

shinestacker/retouch/undo_manager.py

@@ -0,0 +1,38 @@
+from .. config.gui_constants import gui_constants
+
+
+class UndoManager:
+    def __init__(self):
+        self.undo_stack = []
+        self.max_undo_steps = gui_constants.MAX_UNDO_STEPS
+        self.reset_undo_area()
+
+    def reset_undo_area(self):
+        self.x_end = self.y_end = 0
+        self.x_start = self.y_start = gui_constants.MAX_UNDO_SIZE
+
+    def extend_undo_area(self, x_start, y_start, x_end, y_end):
+        self.x_start = min(self.x_start, x_start)
+        self.y_start = min(self.y_start, y_start)
+        self.x_end = max(self.x_end, x_end)
+        self.y_end = max(self.y_end, y_end)
+
+    def save_undo_state(self, layer):
+        if layer is None:
+            return
+        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)
+        }
+        if len(self.undo_stack) >= self.max_undo_steps:
+            self.undo_stack.pop(0)
+        self.undo_stack.append(undo_state)
+
+    def undo(self, layer):
+        if layer is None or not self.undo_stack or len(self.undo_stack) == 0:
+            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

shinestacker-0.2.0.post1.dev1.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: shinestacker
+Version: 0.2.0.post1.dev1
+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)
+
+<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/).
+

shinestacker-0.2.0.post1.dev1.dist-info/RECORD

@@ -0,0 +1,67 @@
+shinestacker/__init__.py,sha256=ZZ2O_m9OFJm18AxMSuYJt4UjSuSqyJlYRaZMoets498,61
+shinestacker/_version.py,sha256=8SnsniWXGASAhyv0_iGZNz3rdNxykDCUL9eNy-R71E4,32
+shinestacker/algorithms/__init__.py,sha256=XKMSOCBqcpeXng5PJ88wLhxhvSIwBJ6xuBFHfjda4ow,519
+shinestacker/algorithms/align.py,sha256=93szP69KN6BVRmMlU4TsNwBMgpYxEU9fxNzoK07n0Rw,16575
+shinestacker/algorithms/balance.py,sha256=UOmyUPJVBswUYWvYIB8WdlfTAxUAahZrnxQUSrYJ3I4,15649
+shinestacker/algorithms/core_utils.py,sha256=u1aw2-cdA1-RiALxA4rnj38oN2pe2s3BP3T_flvuKMQ,550
+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/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
+shinestacker/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shinestacker/app/about_dialog.py,sha256=G_2hRQFpo96q0H8z02fMZ0Jl_2-PpnwNxqISY7Xn5Kg,885
+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=jh53KYyQ6SG9hsPqBpm64LmSxDWWwd7SkXbSSIjKHEk,7101
+shinestacker/app/open_frames.py,sha256=uqUihAkP1K2p4bQ8LAQK02XwVddkRJUPy_vzwUgI8jc,1356
+shinestacker/app/project.py,sha256=xsBoPlrZOVVScxiF1ITxnGzrEdfapjiMc_Jf94o3kIg,3254
+shinestacker/app/retouch.py,sha256=cHPV1LhEBk1ggvLl2Cqfn6kRDVZIPlsSuE36COHRVIM,3022
+shinestacker/config/__init__.py,sha256=l9Cg0Rp9sUsY_F7gR2kznuVBkQ-arO7ZOcjS1FoWPtM,121
+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/colors.py,sha256=f4_iaNgDYpHfLaoooCsltDxem5fI950GPZlw2lFPqYM,1330
+shinestacker/core/core_utils.py,sha256=EkDJY8g3zLdAqT9hTRZ2_jh3jo8GMF2L6ZBINyG6L6Y,1398
+shinestacker/core/exceptions.py,sha256=TzguZ88XxjgbPs5jMFdrXV2cQRkl5mFfXZin9GRMSRY,1555
+shinestacker/core/framework.py,sha256=7N7awCefwT-SUsUE97eM9DBCCbNnrHk1Yab-DGE5iNI,6871
+shinestacker/core/logging.py,sha256=YkKqCduU9FVYCBi26izHKmjyxlGMbwwpYbfn9AY1KeI,3155
+shinestacker/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shinestacker/gui/action_config.py,sha256=v-BWr-en11nyp0bFKoPqUQnVfSv9Ov14KW7oEaVJ9I8,47690
+shinestacker/gui/actions_window.py,sha256=DTMyi2WTugJxqliD6QdKcui_nhtaq0Pq-0SHuLBJGh0,13136
+shinestacker/gui/colors.py,sha256=Af4ccwKfiElzA2poyx2QSU2xvxOdA5fFz0Y2YIqTj9Y,1292
+shinestacker/gui/gui_images.py,sha256=3HySCrldbYhUyxO0B1ckC2TLVg5nq94bBXjqsQzCyCA,5546
+shinestacker/gui/gui_logging.py,sha256=sN82OsGhMcZdgFMY4z-VbUYiRIsReN-ICaxi31M1J6E,8147
+shinestacker/gui/gui_run.py,sha256=LpBi1V91NrJpVpgS098lSgLtiege0aqcWIGwSbB8cL4,15701
+shinestacker/gui/main_window.py,sha256=O7eydSmYa1ijzUHrYeeVUp9x4YGuHwhDGZQ1PxH1MJI,27101
+shinestacker/gui/new_project.py,sha256=-2d9ts4bcPnEo_qufKwLgRYupsx3EBs_5_u4Wz2pwX4,7226
+shinestacker/gui/project_converter.py,sha256=d66pbBzaBgANpudJLW0tGUSfSy0PXNhs1M6R2o_Fd5E,7390
+shinestacker/gui/project_editor.py,sha256=i3vPOWNtJ4zkOQ4y0EIgv30DlpTv3tWEQC9DBnGmXcY,21791
+shinestacker/gui/project_model.py,sha256=buzpxppLuoNWao7M2_FOPVpCBex2WgEcvqyq9dxvrz8,4524
+shinestacker/gui/img/close-round-line-icon.png,sha256=9HZwCjgni1s_JGUPUb_MoOfoe4tRZgM5OWzk92XFZlE,8019
+shinestacker/gui/img/forward-button-icon.png,sha256=lNw86T4TOEd_uokHYF8myGSGUXzdsHvmDAjlbE18Pgo,4788
+shinestacker/gui/img/play-button-round-icon.png,sha256=9j6Ks9mOGa-2cXyRFpimepAAvSaHzqJKBfxShRb4_dE,4595
+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_preview.py,sha256=ePyoZPdSY4ytK4uXV-eByQgfsqvhHJqXpleycSxshDg,5247
+shinestacker/retouch/exif_data.py,sha256=eNrkhe9WA_1LPkaoxLHeM4k8s5HJinD0-O79Ik4xMRU,2451
+shinestacker/retouch/file_loader.py,sha256=TbPjiD9Vv-i3LCsPVcumYJ2DxgnLmQA6xYCiLCqbEcg,4565
+shinestacker/retouch/image_editor.py,sha256=WNJGUpWV14Q5kJQ5fcHAqVx_mb3vK27gfVztwHLYtOc,27637
+shinestacker/retouch/image_editor_ui.py,sha256=wKHqNhcjrPB_qm4zKsTQUw_rXIWzWO3uQUDZvhsbnys,15752
+shinestacker/retouch/image_viewer.py,sha256=5t7JRNoNwSgS7btn7zWmSXPPzXvZKbWBiZMm-YA7Xhg,14827
+shinestacker/retouch/shortcuts_help.py,sha256=yR4KqkCG3-X62KCQWAR_Tyv8aRbonTsiK753DkplehY,3966
+shinestacker/retouch/undo_manager.py,sha256=R7O0fbdGFRK2ZZMVpbOcqB5stJLpFa-o2p7Kto8daSI,1355
+shinestacker-0.2.0.post1.dev1.dist-info/licenses/LICENSE,sha256=cBN0P3F6BWFkfOabkhuTxwJnK1B0v50jmmzZJjGGous,80
+shinestacker-0.2.0.post1.dev1.dist-info/METADATA,sha256=1k3Te_FPd1jRkcASiGH0E9Ul0JlV0Ka1EFVgIm2M7Sg,2447
+shinestacker-0.2.0.post1.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shinestacker-0.2.0.post1.dev1.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
+shinestacker-0.2.0.post1.dev1.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
+shinestacker-0.2.0.post1.dev1.dist-info/RECORD,,

shinestacker-0.2.0.post1.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

shinestacker-0.2.0.post1.dev1.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+shinestacker = shinestacker.app.main:main
+shinestacker-project = shinestacker.app.project:main
+shinestacker-retouch = shinestacker.app.retouch:main

shinestacker-0.2.0.post1.dev1.dist-info/licenses/LICENSE

@@ -0,0 +1 @@
+The software is provided as is under the GNU Lesser General Public License v3.0.

shinestacker-0.2.0.post1.dev1.dist-info/top_level.txt

@@ -0,0 +1 @@
+shinestacker