shinestacker 0.4.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

shinestacker/retouch/io_gui_handler.py

@@ -7,13 +7,15 @@ 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
 
 
 class IOGuiHandler(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
     update_title_requested = Signal()
+    mark_as_modified_requested = Signal(bool)
+    change_layer_requested = Signal(int)
 
     def __init__(self, layer_collection, undo_manager, parent):
         QObject.__init__(self, parent)
@@ -28,7 +30,15 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.loading_dialog = None
         self.loading_timer = None
         self.exif_dialog = None
-        self.current_file_path = ''
+        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
@@ -44,16 +54,10 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         else:
             self.set_layer_labels(labels)
         self.set_master_layer(master_layer)
-        self.parent().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.current_file_path}")
-        self.parent().thumbnail_list.setFocus()
-        self.update_title_requested.emit()
+        self.finish_loading_setup(stack, None, master_layer,
+                                  f"Loaded: {self.current_file_path()}")
 
     def on_file_error(self, error_msg):
         QApplication.restoreOverrideCursor()
@@ -61,7 +65,25 @@ 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.current_file_path}")
+        self.current_file_path_master = ''
+        self.current_file_path_multi = ''
+        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.mark_as_modified_requested.emit(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:
@@ -77,7 +99,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.current_file_path = os.path.abspath(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")
@@ -113,29 +136,39 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             msg.setText(str(e))
             msg.exec()
             return
+        self.finish_loading_setup(stack, labels, master, "Selected frames imported")
+
+    def finish_loading_setup(self, stack, labels, master, message):
         if self.layer_stack() is None and len(stack) > 0:
             self.set_layer_stack(np.array(stack))
-            self.set_layer_labels(labels)
+            if labels is None:
+                labels = self.layer_labels()
+            else:
+                self.set_layer_labels(labels)
             self.set_master_layer(master)
             self.blank_layer = np.zeros(master.shape[:2])
         else:
+            if labels is None:
+                labels = self.layer_labels()
             for img, label in zip(stack, labels):
                 self.add_layer_label(label)
                 self.add_layer(img)
-        self.parent().mark_as_modified()
-        self.parent().change_layer(0)
-        self.image_viewer.reset_zoom()
-        self.parent().thumbnail_list.setFocus()
         self.display_manager.update_thumbnails()
+        self.mark_as_modified_requested.emit(True)
+        self.change_layer_requested.emit(0)
+        self.image_viewer.setup_brush_cursor()
+        self.image_viewer.reset_zoom()
+        self.status_message_requested.emit(message)
+        self.update_title_requested.emit()
 
     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()
@@ -143,11 +176,13 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     def save_multilayer(self):
         if self.layer_stack() is None:
             return
-        if self.current_file_path != '':
-            extension = self.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.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:
@@ -161,11 +196,30 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
 
     def save_multilayer_to_path(self, path):
         try:
-            self.io_manager.save_multilayer(path)
-            self.current_file_path = os.path.abspath(path)
-            self.parent().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)}")
@@ -173,8 +227,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     def save_master(self):
         if self.master_layer() is None:
             return
-        if self.current_file_path != '':
-            self.save_master_to_path(self.current_file_path)
+        if self.current_file_path_master != '':
+            self.save_master_to_path(self.current_file_path_master)
             return
         self.save_master_as()
 
@@ -190,8 +244,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     def save_master_to_path(self, path):
         try:
             self.io_manager.save_master(path)
-            self.current_file_path = os.path.abspath(path)
-            self.parent().modified = False
+            self.current_file_path_master = os.path.abspath(path)
+            self.mark_as_modified_requested.emit(False)
             self.update_title_requested.emit()
             self.status_message_requested.emit(f"Saved master layer to: {path}")
         except Exception as e:
@@ -207,15 +261,14 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.exif_dialog.exec()
 
     def close_file(self):
-        if self.parent().check_unsaved_changes():
-            self.set_master_layer(None)
-            self.blank_layer = None
-            self.layer_collection.reset()
-            self.current_file_path = ''
-            self.parent().modified = False
-            self.undo_manager.reset()
-            self.image_viewer.clear_image()
-            self.display_manager.thumbnail_list.clear()
-            self.display_manager.update_thumbnails()
-            self.update_title_requested.emit()
-            self.status_message_requested.emit("File closed")
+        self.mark_as_modified_requested.emit(False)
+        self.blank_layer = None
+        self.layer_collection.reset()
+        self.current_file_path_master = ''
+        self.current_file_path_multi = ''
+        self.undo_manager.reset()
+        self.image_viewer.clear_image()
+        self.display_manager.thumbnail_list.clear()
+        self.display_manager.update_thumbnails()
+        self.update_title_requested.emit()
+        self.status_message_requested.emit("File closed")

shinestacker/retouch/io_manager.py

@@ -1,11 +1,33 @@
-# 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)
@@ -38,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

@@ -32,6 +32,8 @@ class LayerCollection:
         return self.master_layer_copy is None
 
     def number_of_layers(self):
+        if self.layer_stack is None:
+            return 0
         return len(self.layer_stack)
 
     def layer_label(self, i):

shinestacker/retouch/shortcuts_help.py

@@ -32,6 +32,7 @@ class ShortcutsHelp(QDialog):
         self.create_form(left_layout, right_layout)
         button_box = QHBoxLayout()
         ok_button = QPushButton("OK")
+        ok_button.setFixedWidth(100)
         ok_button.setFocus()
         button_box.addWidget(ok_button)
         self.layout.addLayout(button_box)
@@ -48,6 +49,7 @@ class ShortcutsHelp(QDialog):
         shortcuts = {
             "M": "show master layer",
             "L": "show selected layer",
+            "T": "toggle master/selected layer",
             "X": "temp. toggle between master and source layer",
             "↑": "select one layer up",
             "↓": "selcet one layer down",
@@ -80,3 +82,13 @@ class ShortcutsHelp(QDialog):
         self.add_bold_label(right_layout, "Mouse Controls")
         for k, v in mouse_controls.items():
             right_layout.addRow(f"<b>{k}</b>", QLabel(v))
+
+        touchpad_controls = {
+            "Two fingers": "pan",
+            "Pinch": "zoom in/out",
+            "Ctrl + two fingers": "zoom in/out",
+        }
+        self.add_bold_label(right_layout, " ")
+        self.add_bold_label(right_layout, "Touchpad Controls")
+        for k, v in touchpad_controls.items():
+            right_layout.addRow(f"<b>{k}</b>", QLabel(v))

shinestacker/retouch/unsharp_mask_filter.py

@@ -6,8 +6,8 @@ from .base_filter import BaseFilter
 
 
 class UnsharpMaskFilter(BaseFilter):
-    def __init__(self, editor):
-        super().__init__(editor)
+    def __init__(self, name, editor):
+        super().__init__(name, editor, preview_at_startup=True)
         self.max_range = 500.0
         self.max_radius = 4.0
         self.max_amount = 3.0
@@ -46,14 +46,14 @@ class UnsharpMaskFilter(BaseFilter):
             elif name == "Threshold":
                 self.threshold_slider = slider
             value_labels[name] = value_label
-        preview_check, preview_timer, button_box = self.create_base_widgets(
-            layout, QDialogButtonBox.Ok | QDialogButtonBox.Cancel, 200)
+        self.create_base_widgets(
+            layout, QDialogButtonBox.Ok | QDialogButtonBox.Cancel, 200, dlg)
 
         def update_value(name, value, max_val, fmt):
             float_value = max_val * value / self.max_range
             value_labels[name].setText(fmt.format(float_value))
-            if preview_check.isChecked():
-                preview_timer.start()
+            if self.preview_check.isChecked():
+                self.preview_timer.start()
 
         self.radius_slider.valueChanged.connect(
             lambda v: update_value("Radius", v, self.max_radius, params["Radius"][2]))
@@ -61,10 +61,10 @@ class UnsharpMaskFilter(BaseFilter):
             lambda v: update_value("Amount", v, self.max_amount, params["Amount"][2]))
         self.threshold_slider.valueChanged.connect(
             lambda v: update_value("Threshold", v, self.max_threshold, params["Threshold"][2]))
-        preview_timer.timeout.connect(do_preview)
-        self.editor.connect_preview_toggle(preview_check, do_preview, restore_original)
-        button_box.accepted.connect(dlg.accept)
-        button_box.rejected.connect(dlg.reject)
+        self.preview_timer.timeout.connect(do_preview)
+        self.editor.connect_preview_toggle(self.preview_check, do_preview, restore_original)
+        self.button_box.accepted.connect(dlg.accept)
+        self.button_box.rejected.connect(dlg.reject)
         QTimer.singleShot(0, do_preview)
 
     def get_params(self):

shinestacker/retouch/vignetting_filter.py

@@ -0,0 +1,69 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0902
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QSpinBox, QCheckBox, QLabel, QHBoxLayout, QSlider
+from .. config.constants import constants
+from .. algorithms.vignetting import correct_vignetting
+from .base_filter import OneSliderBaseFilter
+
+
+class VignettingFilter(OneSliderBaseFilter):
+    def __init__(self, name, editor):
+        super().__init__(name, editor, 1.0, 0.90, "Vignetting correction",
+                         allow_partial_preview=False, preview_at_startup=False)
+        self.subsample_box = None
+        self.fast_subsampling_check = None
+        self.r_steps_box = None
+        self.threshold_slider = None
+        self.threshold_label = None
+        self.threshold_max_range = 500
+        self.threshold_max_value = 128.0
+        self.threshold_initial_value = constants.DEFAULT_BLACK_THRESHOLD
+        self.threshold_format = "{:.1f}"
+
+    def apply(self, image, strength):
+        return correct_vignetting(image, max_correction=strength,
+                                  black_threshold=self.threshold_slider.value(),
+                                  r_steps=self.r_steps_box.value(),
+                                  subsample=self.subsample_box.value(),
+                                  fast_subsampling=True)
+
+    def add_widgets(self, layout, dlg):
+        threshold_layout = QHBoxLayout()
+        threshold_layout.addWidget(QLabel("Threshold:"))
+        self.threshold_slider = QSlider(Qt.Horizontal)
+        self.threshold_slider.setRange(0, self.threshold_max_range)
+        self.threshold_slider.setValue(
+            int(self.threshold_initial_value /
+                self.threshold_max_value * self.threshold_max_range))
+        self.threshold_slider.valueChanged.connect(self.threshold_changed)
+        self.threshold_label = QLabel(self.threshold_format.format(self.threshold_initial_value))
+        threshold_layout.addWidget(self.threshold_slider)
+        threshold_layout.addWidget(self.threshold_label)
+        layout.addLayout(threshold_layout)
+        subsample_layout = QHBoxLayout()
+        subsample_label = QLabel("Subsample:")
+        self.subsample_box = QSpinBox()
+        self.subsample_box.setFixedWidth(50)
+        self.subsample_box.setRange(1, 50)
+        self.subsample_box.setValue(constants.DEFAULT_VIGN_SUBSAMPLE)
+        self.subsample_box.valueChanged.connect(self.threshold_changed)
+        self.fast_subsampling_check = QCheckBox("Fast subsampling")
+        self.fast_subsampling_check.setChecked(constants.DEFAULT_VIGN_FAST_SUBSAMPLING)
+        r_steps_label = QLabel("Radial steps:")
+        self.r_steps_box = QSpinBox()
+        self.r_steps_box.setFixedWidth(50)
+        self.r_steps_box.setRange(1, 200)
+        self.r_steps_box.setValue(constants.DEFAULT_R_STEPS)
+        self.r_steps_box.valueChanged.connect(self.param_changed)
+        subsample_layout.addWidget(subsample_label)
+        subsample_layout.addWidget(self.subsample_box)
+        subsample_layout.addWidget(r_steps_label)
+        subsample_layout.addWidget(self.r_steps_box)
+        subsample_layout.addStretch(1)
+        layout.addLayout(subsample_layout)
+        layout.addWidget(self.fast_subsampling_check)
+
+    def threshold_changed(self, val):
+        float_val = self.threshold_max_value * float(val) / self.threshold_max_range
+        self.threshold_label.setText(self.threshold_format.format(float_val))
+        self.param_changed(val)

shinestacker/retouch/white_balance_filter.py

@@ -1,6 +1,6 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0913, R0914, R0917
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0913, R0914, R0917, R0902
 from PySide6.QtWidgets import (QHBoxLayout, QPushButton, QFrame, QVBoxLayout, QLabel, QDialog,
-                               QApplication, QSlider, QDialogButtonBox)
+                               QApplication, QSlider, QDialogButtonBox, QLineEdit)
 from PySide6.QtCore import Qt, QTimer
 from PySide6.QtGui import QCursor
 from .. algorithms.white_balance import white_balance_from_rgb
@@ -8,12 +8,13 @@ from .base_filter import BaseFilter
 
 
 class WhiteBalanceFilter(BaseFilter):
-    def __init__(self, editor):
-        super().__init__(editor)
+    def __init__(self, name, editor):
+        super().__init__(name, editor, preview_at_startup=True)
         self.max_range = 255
         self.initial_val = (128, 128, 128)
         self.sliders = {}
         self.value_labels = {}
+        self.rgb_hex = None
         self.color_preview = None
         self.preview_timer = None
         self.original_mouse_press = None
@@ -45,29 +46,60 @@ class WhiteBalanceFilter(BaseFilter):
             self.value_labels[name] = val_label
         row_layout.addLayout(sliders_layout)
         layout.addLayout(row_layout)
+
+        rbg_layout = QHBoxLayout()
+        rbg_layout.addWidget(QLabel("RBG hex:"))
+        self.rgb_hex = QLineEdit(self.hex_color(self.initial_val))
+        self.rgb_hex.setFixedWidth(60)
+        self.rgb_hex.textChanged.connect(self.on_rgb_change)
+        rbg_layout.addWidget(self.rgb_hex)
+        rbg_layout.addStretch(1)
+        layout.addLayout(rbg_layout)
+
         pick_button = QPushButton("Pick Color")
         layout.addWidget(pick_button)
-        preview_check, self.preview_timer, button_box = self.create_base_widgets(
+        self.create_base_widgets(
             layout,
             QDialogButtonBox.Ok | QDialogButtonBox.Reset | QDialogButtonBox.Cancel,
-            200)
+            200, dlg)
         for slider in self.sliders.values():
             slider.valueChanged.connect(self.on_slider_change)
         self.preview_timer.timeout.connect(do_preview)
-        self.editor.connect_preview_toggle(preview_check, do_preview, restore_original)
+        self.editor.connect_preview_toggle(self.preview_check, do_preview, restore_original)
         pick_button.clicked.connect(self.start_color_pick)
-        button_box.accepted.connect(dlg.accept)
-        button_box.rejected.connect(dlg.reject)
-        button_box.button(QDialogButtonBox.Reset).clicked.connect(self.reset_rgb)
+        self.button_box.accepted.connect(dlg.accept)
+        self.button_box.rejected.connect(dlg.reject)
+        self.button_box.button(QDialogButtonBox.Reset).clicked.connect(self.reset_rgb)
         QTimer.singleShot(0, do_preview)
 
+    def hex_color(self, val):
+        return "".join([f"{int(c):0>2X}" for c in val])
+
+    def apply_preview(self, rgb):
+        self.color_preview.setStyleSheet(f"background-color: rgb{tuple(rgb)};")
+        if self.preview_timer:
+            self.preview_timer.start()
+
     def on_slider_change(self):
         for name in ("R", "G", "B"):
             self.value_labels[name].setText(str(self.sliders[name].value()))
         rgb = tuple(self.sliders[n].value() for n in ("R", "G", "B"))
-        self.color_preview.setStyleSheet(f"background-color: rgb{rgb};")
-        if self.preview_timer:
-            self.preview_timer.start()
+        self.rgb_hex.blockSignals(True)
+        self.rgb_hex.setText(self.hex_color(rgb))
+        self.rgb_hex.blockSignals(False)
+        self.apply_preview(rgb)
+
+    def on_rgb_change(self):
+        txt = self.rgb_hex.text()
+        if len(txt) != 6:
+            return
+        rgb = [int(txt[i:i + 2], 16) for i in range(0, 6, 2)]
+        for name, c in zip(("R", "G", "B"), rgb):
+            self.sliders[name].blockSignals(True)
+            self.sliders[name].setValue(c)
+            self.sliders[name].blockSignals(False)
+            self.value_labels[name].setText(str(c))
+        self.apply_preview(rgb)
 
     def start_color_pick(self):
         for widget in QApplication.topLevelWidgets():
@@ -94,7 +126,7 @@ class WhiteBalanceFilter(BaseFilter):
             self.editor.image_viewer.mousePressEvent = self.original_mouse_press
             self.editor.image_viewer.brush_cursor.show()
             self.editor.brush_preview.show()
-            new_filter = WhiteBalanceFilter(self.editor)
+            new_filter = WhiteBalanceFilter(self.name, self.editor)
             new_filter.run_with_preview(init_val=rgb)
 
     def reset_rgb(self):

{shinestacker-0.4.0.dist-info → shinestacker-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 0.4.0
+Version: 1.0.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -41,6 +41,7 @@ Dynamic: license-file
 [![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)
+[![PyPI Downloads](https://static.pepy.tech/badge/shinestacker)](https://pepy.tech/projects/shinestacker)
 
 <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">
 
@@ -75,6 +76,14 @@ The GUI has two main working areas:
 
 The first version of the core focus stack algorithm was initially inspired by the [Laplacian pyramids method](https://github.com/sjawhar/focus-stacking) implementation by Sami Jawhar that was used under permission of the author. The implementation in the latest releases was rewritten from the original code.
 
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/src/shinestacker/gui/ico/shinestacker.png' width="256" referrerpolicy="no-referrer" alt="Shine Stacker Logo">
+
+## Logo attribution
+
+The Shine Stacker logo was designed by [Alessandro Lista](https://linktr.ee/alelista).  
+Copyright © Alessandro Lista. All rights reserved.  
+The logo is not covered by the LGPL-3.0 license of this project.
+
 # 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
@@ -83,8 +92,11 @@ Pyramid methods in image processing
 
 # License
 
-<img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
+- **Code**: <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.
+- **Logo**: The Shine Stacker logo was designed by [Alessandro Lista](https://linktr.ee/alelista).  
+  Copyright © Alessandro Lista. All rights reserved.  
+  The logo is not covered by the LGPL-3.0 license of this project.
 
 # Attribution request
 📸 If you publish images created with Shine Stacker, please consider adding a note such as: