shinestacker 0.3.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

shinestacker/retouch/image_editor_ui.py

@@ -23,6 +23,7 @@ def brush_size_to_slider(size):
 
 class ImageEditorUI(ImageFilters):
     def __init__(self):
+        self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
         super().__init__()
         self.brush = Brush()
         self.setup_ui()
@@ -125,17 +126,21 @@ class ImageEditorUI(ImageFilters):
             }
         """)
         master_label.setAlignment(Qt.AlignCenter)
-        master_label.setFixedHeight(gui_constants.LABEL_HEIGHT)
+        master_label.setFixedHeight(gui_constants.UI_SIZES['label_height'])
         side_layout.addWidget(master_label)
         self.master_thumbnail_frame = QFrame()
+        self.master_thumbnail_frame.setObjectName("thumbnailContainer")
+        self.master_thumbnail_frame.setStyleSheet(
+            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
         self.master_thumbnail_frame.setFrameShape(QFrame.StyledPanel)
         master_thumbnail_layout = QVBoxLayout(self.master_thumbnail_frame)
-        master_thumbnail_layout.setContentsMargins(2, 2, 2, 2)
+        master_thumbnail_layout.setContentsMargins(8, 8, 8, 8)
         self.master_thumbnail_label = QLabel()
         self.master_thumbnail_label.setAlignment(Qt.AlignCenter)
-        self.master_thumbnail_label.setFixedSize(
-            gui_constants.THUMB_WIDTH, gui_constants.THUMB_HEIGHT)
-        self.master_thumbnail_label.mousePressEvent = lambda e: self.set_view_master()
+        self.master_thumbnail_label.setFixedWidth(
+            gui_constants.UI_SIZES['thumbnail_width'])
+        self.master_thumbnail_label.mousePressEvent = \
+            lambda e: self.display_manager.set_view_master()
         master_thumbnail_layout.addWidget(self.master_thumbnail_label)
         side_layout.addWidget(self.master_thumbnail_frame)
         side_layout.addSpacing(10)
@@ -151,7 +156,7 @@ class ImageEditorUI(ImageFilters):
             }
         """)
         layers_label.setAlignment(Qt.AlignCenter)
-        layers_label.setFixedHeight(gui_constants.LABEL_HEIGHT)
+        layers_label.setFixedHeight(gui_constants.UI_SIZES['label_height'])
         side_layout.addWidget(layers_label)
         self.thumbnail_list = QListWidget()
         self.thumbnail_list.setFocusPolicy(Qt.StrongFocus)
@@ -203,18 +208,29 @@ class ImageEditorUI(ImageFilters):
         layout.setSpacing(2)
         super().setup_ui()
 
+    def highlight_master_thumbnail(self):
+        self.master_thumbnail_frame.setStyleSheet(
+            f"#thumbnailContainer{{ border: 2px solid {self.thumbnail_highlight}; }}")
+
     def setup_menu(self):
         menubar = self.menuBar()
         file_menu = menubar.addMenu("&File")
         file_menu.addAction("&Open...", self.io_gui_handler.open_file, "Ctrl+O")
-        file_menu.addAction("&Save", self.io_gui_handler.save_file, "Ctrl+S")
-        file_menu.addAction("Save &As...", self.io_gui_handler.save_file_as, "Ctrl+Shift+S")
-        self.save_master_only = QAction("Save Master &Only", self)
-        self.save_master_only.setCheckable(True)
-        self.save_master_only.setChecked(True)
-        file_menu.addAction(self.save_master_only)
-
-        file_menu.addAction("&Close", self.io_gui_handler.close_file, "Ctrl+W")
+        self.save_action = QAction("&Save", self)
+        self.save_action.setShortcut("Ctrl+S")
+        self.save_action.triggered.connect(self.io_gui_handler.save_file)
+        file_menu.addAction(self.save_action)
+        self.save_as_action = QAction("Save &As...", self)
+        self.save_as_action.setShortcut("Ctrl+Shift+S")
+        self.save_as_action.triggered.connect(self.io_gui_handler.save_file_as)
+        file_menu.addAction(self.save_as_action)
+        self.io_gui_handler.save_master_only = QAction("Save Master &Only", self)
+        self.io_gui_handler.save_master_only.setCheckable(True)
+        self.io_gui_handler.save_master_only.setChecked(True)
+        file_menu.addAction(self.io_gui_handler.save_master_only)
+        self.save_actions_set_enabled(False)
+
+        file_menu.addAction("&Close", self.close_file, "Ctrl+W")
         file_menu.addSeparator()
         file_menu.addAction("&Import frames", self.io_gui_handler.import_frames)
         file_menu.addAction("Import &EXIF data", self.io_gui_handler.select_exif_path)
@@ -270,12 +286,12 @@ class ImageEditorUI(ImageFilters):
 
         view_master_action = QAction("View Master", self)
         view_master_action.setShortcut("M")
-        view_master_action.triggered.connect(self.display_manager.set_view_master)
+        view_master_action.triggered.connect(self.set_view_master)
         view_menu.addAction(view_master_action)
 
         view_individual_action = QAction("View Individual", self)
         view_individual_action.setShortcut("L")
-        view_individual_action.triggered.connect(self.display_manager.set_view_individual)
+        view_individual_action.triggered.connect(self.set_view_individual)
         view_menu.addAction(view_individual_action)
         view_menu.addSeparator()
 
@@ -333,6 +349,25 @@ class ImageEditorUI(ImageFilters):
         shortcuts_help_action.triggered.connect(self.shortcuts_help)
         help_menu.addAction(shortcuts_help_action)
 
+    def save_actions_set_enabled(self, enabled):
+        self.save_action.setEnabled(enabled)
+        self.save_as_action.setEnabled(enabled)
+        self.io_gui_handler.save_master_only.setEnabled(enabled)
+
+    def close_file(self):
+        self.io_gui_handler.close_file()
+        self.save_actions_set_enabled(False)
+
+    def set_view_master(self):
+        self.display_manager.set_view_master()
+        self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
+        self.highlight_master_thumbnail()
+
+    def set_view_individual(self):
+        self.display_manager.set_view_individual()
+        self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
+        self.highlight_master_thumbnail()
+
     def shortcuts_help(self):
         self._dialog = ShortcutsHelp(self)
         self._dialog.exec()
@@ -364,8 +399,12 @@ class ImageEditorUI(ImageFilters):
     def handle_temp_view(self, start):
         if start:
             self.display_manager.start_temp_view()
+            self.thumbnail_highlight = gui_constants.THUMB_MASTER_LO_COLOR
+            self.highlight_master_thumbnail()
         else:
             self.display_manager.end_temp_view()
+            self.thumbnail_highlight = gui_constants.THUMB_MASTER_HI_COLOR
+            self.highlight_master_thumbnail()
 
     def handle_brush_size_change(self, delta):
         if delta > 0:

shinestacker/retouch/image_viewer.py

@@ -1,8 +1,8 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0904, R0902, R0914
+# pylint: disable=C0114, C0115, C0116, E0611, R0904, R0902, R0914, R0912
 import math
 from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
 from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor, QShortcut, QKeySequence
-from PySide6.QtCore import Qt, QRectF, QTime, QPoint, QPointF, Signal
+from PySide6.QtCore import Qt, QRectF, QTime, QPoint, QPointF, Signal, QEvent
 from .. config.gui_constants import gui_constants
 from .brush_preview import BrushPreviewItem
 from .brush_gradient import create_default_brush_gradient
@@ -52,6 +52,13 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         self.empty = True
         self.allow_cursor_preview = True
         self.last_brush_pos = None
+        self.grabGesture(Qt.PanGesture)
+        self.grabGesture(Qt.PinchGesture)
+        self.pinch_start_scale = 1.0
+        self.last_scroll_pos = QPointF()
+        self.gesture_active = False
+        self.pinch_center_view = None
+        self.pinch_center_scene = None
 
     def set_image(self, qimage):
         pixmap = QPixmap.fromImage(qimage)
@@ -193,25 +200,44 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         super().mouseReleaseEvent(event)
 
     def wheelEvent(self, event):
-        if self.empty:
+        if self.empty or self.gesture_active:
             return
-        if self.control_pressed:
-            self.brush_size_change_requested.emit(1 if event.angleDelta().y() > 0 else -1)
-        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()
+        if event.source() == Qt.MouseEventNotSynthesized:  # Physical mouse
+            if self.control_pressed:
+                self.brush_size_change_requested.emit(1 if event.angleDelta().y() > 0 else -1)
+            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()
+        else:  # Touchpad event - fallback for systems without gesture recognition
+            # Handle touchpad panning (two-finger scroll)
+            if not self.control_pressed:
+                delta = event.pixelDelta() or event.angleDelta() / 8
+                if delta:
+                    self.horizontalScrollBar().setValue(
+                        self.horizontalScrollBar().value() - delta.x()
+                    )
+                    self.verticalScrollBar().setValue(
+                        self.verticalScrollBar().value() - delta.y()
+                    )
+            else:  # Control + touchpad scroll for zoom
+                zoom_in = event.angleDelta().y() > 0
+                if zoom_in:
+                    self.zoom_in()
+                else:
+                    self.zoom_out()
+        event.accept()
 
     def enterEvent(self, event):
         self.activateWindow()
@@ -230,6 +256,64 @@ class ImageViewer(QGraphicsView, LayerCollectionHandler):
         super().leaveEvent(event)
     # pylint: enable=C0103
 
+    def event(self, event):
+        if event.type() == QEvent.Gesture:
+            return self.handle_gesture_event(event)
+        return super().event(event)
+
+    def handle_gesture_event(self, event):
+        handled = False
+        pan_gesture = event.gesture(Qt.PanGesture)
+        if pan_gesture:
+            self.handle_pan_gesture(pan_gesture)
+            handled = True
+        pinch_gesture = event.gesture(Qt.PinchGesture)
+        if pinch_gesture:
+            self.handle_pinch_gesture(pinch_gesture)
+            handled = True
+        if handled:
+            event.accept()
+            return True
+        return False
+
+    def handle_pan_gesture(self, pan_gesture):
+        if pan_gesture.state() == Qt.GestureStarted:
+            self.last_scroll_pos = pan_gesture.delta()
+            self.gesture_active = True
+        elif pan_gesture.state() == Qt.GestureUpdated:
+            delta = pan_gesture.delta() - self.last_scroll_pos
+            self.last_scroll_pos = pan_gesture.delta()
+            zoom_factor = self.get_current_scale()
+            scaled_delta = delta * (1.0 / zoom_factor)
+            self.horizontalScrollBar().setValue(
+                self.horizontalScrollBar().value() - int(scaled_delta.x())
+            )
+            self.verticalScrollBar().setValue(
+                self.verticalScrollBar().value() - int(scaled_delta.y())
+            )
+        elif pan_gesture.state() == Qt.GestureFinished:
+            self.gesture_active = False
+
+    def handle_pinch_gesture(self, pinch):
+        if pinch.state() == Qt.GestureStarted:
+            self.pinch_start_scale = self.get_current_scale()
+            self.pinch_center_view = pinch.centerPoint()
+            self.pinch_center_scene = self.mapToScene(self.pinch_center_view.toPoint())
+            self.gesture_active = True
+        elif pinch.state() == Qt.GestureUpdated:
+            new_scale = self.pinch_start_scale * pinch.totalScaleFactor()
+            new_scale = max(self.min_scale, min(new_scale, self.max_scale))
+            if abs(new_scale - self.get_current_scale()) > 0.01:
+                self.resetTransform()
+                self.scale(new_scale, new_scale)
+                self.zoom_factor = new_scale
+                new_center = self.mapToScene(self.pinch_center_view.toPoint())
+                delta = self.pinch_center_scene - new_center
+                self.translate(delta.x(), delta.y())
+                self.update_brush_cursor()
+        elif pinch.state() in (Qt.GestureFinished, Qt.GestureCanceled):
+            self.gesture_active = False
+
     def setup_brush_cursor(self):
         self.setCursor(Qt.BlankCursor)
         pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), 1)

shinestacker/retouch/io_gui_handler.py

@@ -1,4 +1,5 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902, W0718
+import os
 import traceback
 import numpy as np
 from PySide6.QtWidgets import QFileDialog, QMessageBox, QVBoxLayout, QLabel, QDialog, QApplication
@@ -6,7 +7,7 @@ from PySide6.QtGui import QGuiApplication, QCursor
 from PySide6.QtCore import Qt, QObject, QTimer, Signal
 from .file_loader import FileLoader
 from .exif_data import ExifData
-from .io_manager import IOManager
+from .io_manager import IOManager, FileMultilayerSaver
 from .layer_collection import LayerCollectionHandler
 
 
@@ -23,11 +24,19 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.loader_thread = None
         self.display_manager = None
         self.image_viewer = None
-        self.modified = None
         self.blank_layer = None
         self.loading_dialog = None
         self.loading_timer = None
         self.exif_dialog = None
+        self.saver_thread = None
+        self.saving_dialog = None
+        self.saving_timer = None
+        self.current_file_path_master = ''
+        self.current_file_path_multi = ''
+
+    def current_file_path(self):
+        return self.current_file_path_master if self.save_master_only.isChecked() \
+            else self.current_file_path_multi
 
     def setup_ui(self, display_manager, image_viewer):
         self.display_manager = display_manager
@@ -43,16 +52,18 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         else:
             self.set_layer_labels(labels)
         self.set_master_layer(master_layer)
-        self.modified = False
         self.undo_manager.reset()
         self.blank_layer = np.zeros(master_layer.shape[:2])
         self.display_manager.update_thumbnails()
         self.image_viewer.setup_brush_cursor()
-        self.parent().change_layer(0)
         self.image_viewer.reset_zoom()
-        self.status_message_requested.emit(f"Loaded: {self.io_manager.current_file_path}")
-        self.parent().thumbnail_list.setFocus()
+        self.status_message_requested.emit(f"Loaded: {self.current_file_path()}")
         self.update_title_requested.emit()
+        self.current_file_path_master = ''
+        self.current_file_path_multi = ''
+        self.parent().mark_as_modified()
+        self.parent().change_layer(0)
+        self.parent().thumbnail_list.setFocus()
 
     def on_file_error(self, error_msg):
         QApplication.restoreOverrideCursor()
@@ -60,7 +71,23 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.loading_dialog.accept()
         self.loading_dialog.deleteLater()
         QMessageBox.critical(self.parent(), "Error", error_msg)
-        self.status_message_requested.emit(f"Error loading: {self.io_manager.current_file_path}")
+        self.status_message_requested.emit(f"Error loading: {self.current_file_path()}")
+
+    def on_multilayer_save_success(self):
+        QApplication.restoreOverrideCursor()
+        self.saving_timer.stop()
+        self.saving_dialog.hide()
+        self.saving_dialog.deleteLater()
+        self.parent().modified = False
+        self.update_title_requested.emit()
+        self.status_message_requested.emit(f"Saved multilayer to: {self.current_file_path_multi}")
+
+    def on_multilayer_save_error(self, error_msg):
+        QApplication.restoreOverrideCursor()
+        self.saving_timer.stop()
+        self.saving_dialog.hide()
+        self.saving_dialog.deleteLater()
+        QMessageBox.critical(self.parent(), "Save Error", f"Could not save file: {error_msg}")
 
     def open_file(self, file_paths=None):
         if file_paths is None:
@@ -76,7 +103,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             self.import_frames_from_files(file_paths)
             return
         path = file_paths[0] if isinstance(file_paths, list) else file_paths
-        self.io_manager.current_file_path = path
+        self.current_file_path_master = os.path.abspath(path)
+        self.current_file_path_multi = os.path.abspath(path)
         QGuiApplication.setOverrideCursor(QCursor(Qt.BusyCursor))
         self.loading_dialog = QDialog(self.parent())
         self.loading_dialog.setWindowTitle("Loading")
@@ -128,13 +156,13 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.display_manager.update_thumbnails()
 
     def save_file(self):
-        if self.parent().save_master_only.isChecked():
+        if self.save_master_only.isChecked():
             self.save_master()
         else:
             self.save_multilayer()
 
     def save_file_as(self):
-        if self.parent().save_master_only.isChecked():
+        if self.save_master_only.isChecked():
             self.save_master_as()
         else:
             self.save_multilayer_as()
@@ -142,11 +170,13 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     def save_multilayer(self):
         if self.layer_stack() is None:
             return
-        if self.io_manager.current_file_path != '':
-            extension = self.io_manager.current_file_path.split('.')[-1]
+        if self.current_file_path_multi != '':
+            extension = self.current_file_path_multi.split('.')[-1]
             if extension in ['tif', 'tiff']:
-                self.save_multilayer_to_path(self.io_manager.current_file_path)
+                self.save_multilayer_to_path(self.current_file_path_multi)
                 return
+        else:
+            self.save_multilayer_as()
 
     def save_multilayer_as(self):
         if self.layer_stack() is None:
@@ -160,11 +190,30 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
 
     def save_multilayer_to_path(self, path):
         try:
-            self.io_manager.save_multilayer(path)
-            self.io_manager.current_file_path = path
-            self.modified = False
-            self.update_title_requested.emit()
-            self.status_message_requested.emit(f"Saved multilayer to: {path}")
+            master_layer = {'Master': self.master_layer().copy()}
+            individual_layers = dict(zip(
+                self.layer_labels(),
+                [layer.copy() for layer in self.layer_stack()]
+            ))
+            images_dict = {**master_layer, **individual_layers}
+            self.saver_thread = FileMultilayerSaver(
+                images_dict, path, exif_path=self.io_manager.exif_path)
+            self.saver_thread.finished.connect(self.on_multilayer_save_success)
+            self.saver_thread.error.connect(self.on_multilayer_save_error)
+            QGuiApplication.setOverrideCursor(QCursor(Qt.BusyCursor))
+            self.saving_dialog = QDialog(self.parent())
+            self.saving_dialog.setWindowTitle("Saving")
+            self.saving_dialog.setWindowFlags(Qt.Window | Qt.FramelessWindowHint)
+            self.saving_dialog.setModal(True)
+            layout = QVBoxLayout()
+            layout.addWidget(QLabel("Saving file..."))
+            self.saving_dialog.setLayout(layout)
+            self.saving_timer = QTimer()
+            self.saving_timer.setSingleShot(True)
+            self.saving_timer.timeout.connect(self.saving_dialog.show)
+            self.saving_timer.start(100)
+            self.saver_thread.start()
+
         except Exception as e:
             traceback.print_tb(e.__traceback__)
             QMessageBox.critical(self.parent(), "Save Error", f"Could not save file: {str(e)}")
@@ -172,8 +221,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     def save_master(self):
         if self.master_layer() is None:
             return
-        if self.io_manager.current_file_path != '':
-            self.save_master_to_path(self.io_manager.current_file_path)
+        if self.current_file_path_master != '':
+            self.save_master_to_path(self.current_file_path_master)
             return
         self.save_master_as()
 
@@ -189,8 +238,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     def save_master_to_path(self, path):
         try:
             self.io_manager.save_master(path)
-            self.io_manager.current_file_path = path
-            self.modified = False
+            self.current_file_path_master = os.path.abspath(path)
+            self.parent().modified = False
             self.update_title_requested.emit()
             self.status_message_requested.emit(f"Saved master layer to: {path}")
         except Exception as e:
@@ -210,8 +259,9 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             self.set_master_layer(None)
             self.blank_layer = None
             self.layer_collection.reset()
-            self.io_manager.current_file_path = ''
-            self.modified = False
+            self.current_file_path_master = ''
+            self.current_file_path_multi = ''
+            self.parent().modified = False
             self.undo_manager.reset()
             self.image_viewer.clear_image()
             self.display_manager.thumbnail_list.clear()

shinestacker/retouch/io_manager.py

@@ -1,15 +1,36 @@
-# pylint: disable=E1101, C0114, C0115, C0116
+# pylint: disable=E1101, C0114, C0115, C0116, E0611, W0718, R0903
+import traceback
 import cv2
+from PySide6.QtCore import QThread, Signal
 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
 from .layer_collection import LayerCollectionHandler
 
 
+class FileMultilayerSaver(QThread):
+    finished = Signal()
+    error = Signal(str)
+
+    def __init__(self, images_dict, path, exif_path=None):
+        super().__init__()
+        self.images_dict = images_dict
+        self.path = path
+        self.exif_path = exif_path
+
+    def run(self):
+        try:
+            write_multilayer_tiff_from_images(
+                self.images_dict, self.path, exif_path=self.exif_path)
+            self.finished.emit()
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            self.error.emit(str(e))
+
+
 class IOManager(LayerCollectionHandler):
     def __init__(self, layer_collection):
         super().__init__(layer_collection)
-        self.current_file_path = ''
         self.exif_path = ''
         self.exif_data = None
 
@@ -39,12 +60,6 @@ class IOManager(LayerCollectionHandler):
                 raise RuntimeError(f"Error loading file: {path}.\n{str(e)}") from e
         return stack, labels, master
 
-    def save_multilayer(self, path):
-        master_layer = {'Master': self.master_layer()}
-        individual_layers = dict(zip(self.layer_labels(), self.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.master_layer(), cv2.COLOR_RGB2BGR)
         write_image_with_exif_data(self.exif_data, img, path)

shinestacker/retouch/layer_collection.py

@@ -80,7 +80,8 @@ class LayerCollection:
         master_label = None
         master_layer = None
         for i, label in enumerate(self.layer_labels):
-            if label.lower() == "master":
+            label_lower = label.lower()
+            if "master" in label_lower or "stack" in label_lower:
                 master_index = i
                 master_label = self.layer_labels.pop(i)
                 master_layer = self.layer_stack[i]

{shinestacker-0.3.6.dist-info → shinestacker-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 0.3.6
+Version: 0.5.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -37,10 +37,10 @@ Dynamic: license-file
 [![PyPI version](https://img.shields.io/pypi/v/shinestacker?color=success)](https://pypi.org/project/shinestacker/)
 [![Python Versions](https://img.shields.io/pypi/pyversions/shinestacker)](https://pypi.org/project/shinestacker/)
 [![Qt Versions](https://img.shields.io/badge/Qt-6-blue.svg?&logo=Qt&logoWidth=18&logoColor=white)](https://www.qt.io/qt-for-python)
-[![pylint](https://img.shields.io/badge/PyLint-9.98-yellow?logo=python&logoColor=white)](https://github.com/lucalista/shinestacker/blob/main/.github/workflows/pylint.yml)
+[![pylint](https://img.shields.io/badge/PyLint-10.00-brightgreen?logo=python&logoColor=white)](https://github.com/lucalista/shinestacker/blob/main/.github/workflows/pylint.yml)
 [![codecov](https://codecov.io/github/lucalista/shinestacker/graph/badge.svg?token=Y5NKW6VH5G)](https://codecov.io/github/lucalista/shinestacker)
 [![Documentation Status](https://readthedocs.org/projects/shinestacker/badge/?version=latest)](https://shinestacker.readthedocs.io/en/latest/?badge=latest)
-
+ [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies.gif' width="400" referrerpolicy="no-referrer">  <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/flies_stack.jpg' width="400" referrerpolicy="no-referrer">
 
@@ -83,7 +83,8 @@ Pyramid methods in image processing
 
 # License
 
-The software is provided as is under the [GNU Lesser General Public License v3.0](https://choosealicense.com/licenses/lgpl-3.0/).
+<img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
+The software is provided as is under the [GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html). See [LICENSE](https://github.com/lucalista/shinestacker/blob/main/LICENSE) for details.
 
 # Attribution request
 📸 If you publish images created with Shine Stacker, please consider adding a note such as: