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

shinestacker/retouch/io_gui_handler.py

@@ -0,0 +1,208 @@
+import traceback
+import numpy as np
+from PySide6.QtWidgets import QFileDialog, QMessageBox, QVBoxLayout, QLabel, QDialog, QApplication
+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
+
+
+class IOGuiHandler(QObject):
+    status_message_requested = Signal(str)
+    update_title_requested = Signal()
+
+    def __init__(self, layer_collection, undo_manager, parent):
+        super().__init__(parent)
+        self.io_manager = IOManager(layer_collection)
+        self.undo_manager = undo_manager
+        layer_collection.add_to(self)
+        self.loader_thread = None
+
+    def setup_ui(self, display_manager, image_viewer):
+        self.display_manager = display_manager
+        self.image_viewer = image_viewer
+
+    def on_file_loaded(self, stack, labels, master_layer):
+        QApplication.restoreOverrideCursor()
+        self.loading_timer.stop()
+        self.loading_dialog.hide()
+        self.set_layer_stack(stack)
+        if labels is None:
+            self.set_layer_labels([f'Layer {i:03d}' for i in range(len(stack))])
+        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.update_title_requested.emit()
+
+    def on_file_error(self, error_msg):
+        QApplication.restoreOverrideCursor()
+        self.loading_timer.stop()
+        self.loading_dialog.accept()
+        self.loading_dialog.deleteLater()
+        QMessageBox.critical(self, "Error", error_msg)
+        self.status_message_requested.emit(f"Error loading: {self.io_manager.current_file_path}")
+
+    def open_file(self, file_paths=None):
+        if file_paths is None:
+            file_paths, _ = QFileDialog.getOpenFileNames(
+                self.parent(), "Open Image", "", "Images (*.tif *.tiff *.jpg *.jpeg);;All Files (*)")
+        if not file_paths:
+            return
+        if self.loader_thread and self.loader_thread.isRunning():
+            if not self.loader_thread.wait(10000):
+                raise RuntimeError("Loading timeout error.")
+        if isinstance(file_paths, list) and len(file_paths) > 1:
+            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
+        QGuiApplication.setOverrideCursor(QCursor(Qt.BusyCursor))
+        self.loading_dialog = QDialog(self.parent())
+        self.loading_dialog.setWindowTitle("Loading")
+        self.loading_dialog.setWindowFlags(Qt.Window | Qt.FramelessWindowHint)
+        self.loading_dialog.setModal(True)
+        layout = QVBoxLayout()
+        layout.addWidget(QLabel("File loading..."))
+        self.loading_dialog.setLayout(layout)
+        self.loading_timer = QTimer()
+        self.loading_timer.setSingleShot(True)
+        self.loading_timer.timeout.connect(self.loading_dialog.show)
+        self.loading_timer.start(100)
+        self.loader_thread = FileLoader(path)
+        self.loader_thread.finished.connect(self.on_file_loaded)
+        self.loader_thread.error.connect(self.on_file_error)
+        self.loader_thread.start()
+
+    def import_frames(self):
+        file_paths, _ = QFileDialog.getOpenFileNames(self.parent(), "Select frames", "",
+                                                     "Images Images (*.tif *.tiff *.jpg *.jpeg);;All Files (*)")
+        if file_paths:
+            self.import_frames_from_files(file_paths)
+        self.status_message_requested.emit("Imported selected frames")
+
+    def import_frames_from_files(self, file_paths):
+        try:
+            stack, labels, master = self.io_manager.import_frames(file_paths)
+        except Exception as e:
+            msg = QMessageBox()
+            msg.setIcon(QMessageBox.Critical)
+            msg.setWindowTitle("Import error")
+            msg.setText(str(e))
+            msg.exec()
+            return
+        if self.layer_stack() is None and len(stack) > 0:
+            self.set_layer_stack(np.array(stack))
+            self.set_layer_labels(labels)
+            self.set_master_layer(master)
+            self.blank_layer = np.zeros(master.shape[:2])
+        else:
+            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()
+
+    def save_file(self):
+        if self.parent().save_master_only.isChecked():
+            self.save_master()
+        else:
+            self.save_multilayer()
+
+    def save_file_as(self):
+        if self.parent().save_master_only.isChecked():
+            self.save_master_as()
+        else:
+            self.save_multilayer_as()
+
+    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 extension in ['tif', 'tiff']:
+                self.save_multilayer_to_path(self.io_manager.current_file_path)
+                return
+
+    def save_multilayer_as(self):
+        if self.layer_stack() is None:
+            return
+        path, _ = QFileDialog.getSaveFileName(self.parent(), "Save Image", "",
+                                              "TIFF Files (*.tif *.tiff);;All Files (*)")
+        if path:
+            if not path.lower().endswith(('.tif', '.tiff')):
+                path += '.tif'
+            self.save_multilayer_to_path(path)
+
+    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}")
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            QMessageBox.critical(self.parent(), "Save Error", f"Could not save file: {str(e)}")
+
+    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)
+            return
+        self.save_master_as()
+
+    def save_master_as(self):
+        if self.layer_stack() is None:
+            return
+        path, _ = QFileDialog.getSaveFileName(self.parent(), "Save Image", "",
+                                              "TIFF Files (*.tif *.tiff);;JPEG Files (*.jpg *.jpeg);;All Files (*)")
+        if path:
+            self.save_master_to_path(path)
+
+    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.update_title_requested.emit()
+            self.status_message_requested.emit(f"Saved master layer to: {path}")
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            QMessageBox.critical(self.parent(), "Save Error", f"Could not save file: {str(e)}")
+
+    def select_exif_path(self):
+        path, _ = QFileDialog.getOpenFileName(None, "Select file with exif data")
+        if path:
+            self.io_manager.set_exif_data(path)
+            self.status_message_requested.emit(f"EXIF data extracted from {path}.")
+        self._exif_dialog = ExifData(self.io_manager.exif_data, self.parent())
+        self._exif_dialog.exec()
+
+    def close_file(self):
+        if self.parent()._check_unsaved_changes():
+            self.set_master_layer(None)
+            self.blank_layer = None
+            self.current_stack = None
+            self.layer_collection.reset()
+            self.io_manager.current_file_path = ''
+            self.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")

shinestacker/retouch/io_manager.py

@@ -0,0 +1,53 @@
+# pylint: disable=E1101, C0114, C0115, C0116
+import cv2
+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
+
+
+class IOManager:
+    def __init__(self, layer_collection):
+        layer_collection.add_to(self)
+        self.current_file_path = ''
+        self.exif_path = ''
+        self.exif_data = None
+
+    def import_frames(self, file_paths):
+        stack = []
+        labels = []
+        master = None
+        shape, dtype = get_img_metadata(self.master_layer())
+        for path in file_paths:
+            try:
+                label = path.split("/")[-1].split(".")[0]
+                img = cv2.cvtColor(read_img(path), cv2.COLOR_BGR2RGB)
+                if shape is not None and dtype is not None:
+                    validate_image(img, shape, dtype)
+                else:
+                    shape, dtype = get_img_metadata(img)
+                label_x = label
+                i = 0
+                while label_x in labels:
+                    i += 1
+                    label_x = f"{label} ({i})"
+                labels.append(label_x)
+                stack.append(img)
+                if master is None:
+                    master = img.copy()
+            except Exception as e:
+                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)
+
+    def set_exif_data(self, path):
+        self.exif_path = path
+        self.exif_data = get_exif(path)

shinestacker/retouch/layer_collection.py

@@ -0,0 +1,118 @@
+import numpy as np
+
+
+class LayerCollection:
+    def add_to(self, obj):
+        obj.layer_collection = self
+        obj.master_layer = lambda: obj.layer_collection.master_layer
+        obj.current_layer = lambda: obj.layer_collection.current_layer()
+        obj.layer_stack = lambda: obj.layer_collection.layer_stack
+        obj.layer_labels = lambda: obj.layer_collection.layer_labels
+        obj.set_layer_label = lambda i, val: obj.layer_collection.set_layer_label(i, val)
+        obj.set_layer_labels = lambda labels: obj.layer_collection.set_layer_labels(labels)
+        obj.current_layer_idx = lambda: obj.layer_collection.current_layer_idx
+        obj.has_no_master_layer = lambda: obj.layer_collection.has_no_master_layer()
+        obj.has_master_layer = lambda: obj.layer_collection.has_master_layer()
+        obj.set_layer_stack = lambda stk: obj.layer_collection.set_layer_stack(stk)
+        obj.set_master_layer = lambda img: obj.layer_collection.set_master_layer(img)
+        obj.add_layer_label = lambda label: obj.layer_collection.add_layer_label(label)
+        obj.add_layer = lambda img: obj.layer_collection.add_layer(img)
+        obj.master_layer_copy = lambda: obj.layer_collection.master_layer_copy
+        obj.copy_master_layer = lambda: obj.layer_collection.copy_master_layer()
+        obj.set_current_layer_idx = lambda idx: obj.layer_collection.set_current_layer_idx(idx)
+        obj.sort_layers = lambda order: obj.layer_collection.sort_layers(order)
+        obj.number_of_layers = lambda: obj.layer_collection.number_of_layers()
+        obj.valid_current_layer_idx = lambda: obj.layer_collection.valid_current_layer_idx()
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.master_layer = None
+        self.master_layer_copy = None
+        self.layer_stack = None
+        self.layer_labels = []
+        self.current_layer_idx = 0
+
+    def has_master_layer(self):
+        return self.master_layer is not None
+
+    def has_no_master_layer(self):
+        return self.master_layer is None
+
+    def has_master_layer_copy(self):
+        return self.master_layer_copy is not None
+
+    def has_no_master_layer_copy(self):
+        return self.master_layer_copy is None
+
+    def number_of_layers(self):
+        return len(self.layer_stack)
+
+    def layer_label(self, i):
+        return self.layer_labels[i]
+
+    def set_layer_label(self, i, val):
+        self.layer_labels[i] = val
+
+    def set_layer_labels(self, labels):
+        self.layer_labels = labels
+
+    def set_layer_stack(self, stk):
+        self.layer_stack = stk
+
+    def set_current_layer_idx(self, idx):
+        self.current_layer_idx = idx
+
+    def valid_current_layer_idx(self):
+        return 0 <= self.current_layer_idx < self.number_of_layers()
+
+    def current_layer(self):
+        if self.layer_stack is not None and self.valid_current_layer_idx():
+            return self.layer_stack[self.current_layer_idx]
+        return None
+
+    def set_master_layer(self, img):
+        self.master_layer = img
+
+    def copy_master_layer(self):
+        self.master_layer_copy = self.master_layer.copy()
+
+    def add_layer_label(self, label):
+        if self.layer_labels is None:
+            self.layer_labels = [label]
+        else:
+            self.layer_labels.append(label)
+
+    def add_layer(self, img):
+        self.layer_stack = np.append(self.layer_stack, [img], axis=0)
+
+    def sort_layers(self, order):
+        master_index = -1
+        master_label = None
+        master_layer = None
+        for i, label in enumerate(self.layer_labels):
+            if label.lower() == "master":
+                master_index = i
+                master_label = self.layer_labels.pop(i)
+                master_layer = self.layer_stack[i]
+                self.layer_stack = np.delete(self.layer_stack, i, axis=0)
+                break
+        if order == 'asc':
+            self.sorted_indices = sorted(range(len(self.layer_labels)),
+                                         key=lambda i: self.layer_labels[i].lower())
+        elif order == 'desc':
+            self.sorted_indices = sorted(range(len(self.layer_labels)),
+                                         key=lambda i: self.layer_labels[i].lower(),
+                                         reverse=True)
+        else:
+            raise ValueError(f"Invalid sorting order: {order}")
+        self.layer_labels = [self.layer_labels[i] for i in self.sorted_indices]
+        self.layer_stack = self.layer_stack[self.sorted_indices]
+        if master_index != -1:
+            self.layer_labels.insert(0, master_label)
+            self.layer_stack = np.insert(self.layer_stack, 0, master_layer, axis=0)
+            self.master_layer = master_layer.copy()
+            self.master_layer.setflags(write=True)
+        if self.current_layer_idx >= self.number_of_layers():
+            self.current_layer_idx = self.number_of_layers() - 1

shinestacker/retouch/unsharp_mask_filter.py

@@ -0,0 +1,84 @@
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QSlider, QCheckBox, QDialogButtonBox
+from PySide6.QtCore import Qt, QTimer
+from .filter_base import BaseFilter
+
+
+class UnsharpMaskFilter(BaseFilter):
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.max_range = 500.0
+        self.max_radius = 4.0
+        self.max_amount = 3.0
+        self.max_threshold = 64.0
+        self.initial_radius = 1.0
+        self.initial_amount = 0.5
+        self.initial_threshold = 0.0
+        self.radius_slider = None
+        self.amount_slider = None
+        self.threshold_slider = None
+
+    def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
+        dlg.setWindowTitle("Unsharp Mask")
+        dlg.setMinimumWidth(600)
+        params = {
+            "Radius": (self.max_radius, self.initial_radius, "{:.2f}"),
+            "Amount": (self.max_amount, self.initial_amount, "{:.1%}"),
+            "Threshold": (self.max_threshold, self.initial_threshold, "{:.2f}")
+        }
+        value_labels = {}
+        for name, (max_val, init_val, fmt) in params.items():
+            param_layout = QHBoxLayout()
+            name_label = QLabel(f"{name}:")
+            param_layout.addWidget(name_label)
+            slider = QSlider(Qt.Horizontal)
+            slider.setRange(0, self.max_range)
+            slider.setValue(int(init_val / max_val * self.max_range))
+            param_layout.addWidget(slider)
+            value_label = QLabel(fmt.format(init_val))
+            param_layout.addWidget(value_label)
+            layout.addLayout(param_layout)
+            if name == "Radius":
+                self.radius_slider = slider
+            elif name == "Amount":
+                self.amount_slider = slider
+            elif name == "Threshold":
+                self.threshold_slider = slider
+            value_labels[name] = value_label
+
+        preview_check = QCheckBox("Preview")
+        preview_check.setChecked(True)
+        layout.addWidget(preview_check)
+        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        layout.addWidget(button_box)
+        preview_timer = QTimer()
+        preview_timer.setSingleShot(True)
+        preview_timer.setInterval(200)
+
+        def 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()
+
+        self.radius_slider.valueChanged.connect(
+            lambda v: update_value("Radius", v, self.max_radius, params["Radius"][2]))
+        self.amount_slider.valueChanged.connect(
+            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)
+        QTimer.singleShot(0, do_preview)
+
+    def get_params(self):
+        return (
+            max(0.01, self.max_radius * self.radius_slider.value() / self.max_range),
+            self.max_amount * self.amount_slider.value() / self.max_range,
+            self.max_threshold * self.threshold_slider.value() / self.max_range
+        )
+
+    def apply(self, image, radius, amount, threshold):
+        from .. algorithms.sharpen import unsharp_mask
+        return unsharp_mask(image, radius, amount, threshold)

shinestacker/retouch/white_balance_filter.py

@@ -0,0 +1,111 @@
+from PySide6.QtWidgets import (QHBoxLayout,
+                               QPushButton, QFrame, QVBoxLayout, QLabel, QDialog, QApplication, QSlider,
+                               QCheckBox, QDialogButtonBox)
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtGui import QCursor
+from .filter_base import BaseFilter
+
+
+class WhiteBalanceFilter(BaseFilter):
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.max_range = 255
+        self.initial_val = (128, 128, 128)
+        self.sliders = {}
+        self.value_labels = {}
+        self.color_preview = None
+        self.preview_timer = None
+
+    def setup_ui(self, dlg, layout, do_preview, restore_original, init_val=None):
+        if init_val:
+            self.initial_val = init_val
+        dlg.setWindowTitle("White Balance")
+        dlg.setMinimumWidth(600)
+        row_layout = QHBoxLayout()
+        self.color_preview = QFrame()
+        self.color_preview.setFixedHeight(80)
+        self.color_preview.setFixedWidth(80)
+        self.color_preview.setStyleSheet(f"background-color: rgb{self.initial_val};")
+        row_layout.addWidget(self.color_preview)
+        sliders_layout = QVBoxLayout()
+        for name in ("R", "G", "B"):
+            row = QHBoxLayout()
+            label = QLabel(f"{name}:")
+            row.addWidget(label)
+            slider = QSlider(Qt.Horizontal)
+            slider.setRange(0, self.max_range)
+            slider.setValue(self.initial_val[["R", "G", "B"].index(name)])
+            row.addWidget(slider)
+            val_label = QLabel(str(self.initial_val[["R", "G", "B"].index(name)]))
+            row.addWidget(val_label)
+            sliders_layout.addLayout(row)
+            self.sliders[name] = slider
+            self.value_labels[name] = val_label
+        row_layout.addLayout(sliders_layout)
+        layout.addLayout(row_layout)
+        pick_button = QPushButton("Pick Color")
+        layout.addWidget(pick_button)
+        preview_check = QCheckBox("Preview")
+        preview_check.setChecked(True)
+        layout.addWidget(preview_check)
+        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Reset | QDialogButtonBox.Cancel)
+        layout.addWidget(button_box)
+        self.preview_timer = QTimer()
+        self.preview_timer.setSingleShot(True)
+        self.preview_timer.setInterval(200)
+        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)
+        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)
+        QTimer.singleShot(0, do_preview)
+
+    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()
+
+    def start_color_pick(self):
+        for widget in QApplication.topLevelWidgets():
+            if isinstance(widget, QDialog) and widget.isVisible():
+                widget.hide()
+                widget.reject()
+                break
+        self.editor.image_viewer.set_cursor_style('outline')
+        if self.editor.image_viewer.brush_cursor:
+            self.editor.image_viewer.brush_cursor.hide()
+        self.editor.brush_preview.hide()
+        QApplication.setOverrideCursor(QCursor(Qt.CrossCursor))
+        self.editor.image_viewer.setCursor(Qt.CrossCursor)
+        self.original_mouse_press = self.editor.image_viewer.mousePressEvent
+        self.editor.image_viewer.mousePressEvent = self.pick_color_from_click
+
+    def pick_color_from_click(self, event):
+        if event.button() == Qt.LeftButton:
+            pos = event.pos()
+            bgr = self.editor.get_pixel_color_at(pos, radius=int(self.editor.brush.size))
+            rgb = (bgr[2], bgr[1], bgr[0])
+            QApplication.restoreOverrideCursor()
+            self.editor.image_viewer.unsetCursor()
+            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.run_with_preview(init_val=rgb)
+
+    def reset_rgb(self):
+        for name, slider in self.sliders.items():
+            slider.setValue(self.initial_val[["R", "G", "B"].index(name)])
+
+    def get_params(self):
+        return tuple(self.sliders[n].value() for n in ("R", "G", "B"))
+
+    def apply(self, image, r, g, b):
+        from .. algorithms.white_balance import white_balance_from_rgb
+        return white_balance_from_rgb(image, (r, g, b))

{shinestacker-0.3.0.dist-info → shinestacker-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 0.3.0
+Version: 0.3.2
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -41,6 +41,7 @@ Dynamic: license-file
 
 <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">
 
+<img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/coins.gif' width="400" referrerpolicy="no-referrer">  <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/coins_stack.jpg' width="400" referrerpolicy="no-referrer">
 > **Focus stacking** for microscopy, macro photography, and computational imaging
 
 ## Key Features
@@ -58,7 +59,7 @@ The GUI has two main working areas:
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-project-run.png' width="600" referrerpolicy="no-referrer">
 
-* *Retouch*: interactive final refinements to final blended image from individual frames.
+* *Retouch*: select interactively details from individual frames and apply final filters to the blended image.
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-retouch.png' width="600" referrerpolicy="no-referrer">