shinestacker 1.6.0__py3-none-any.whl → 1.6.1__py3-none-any.whl

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.6.0'
+__version__ = '1.6.1'

shinestacker/app/main.py

@@ -13,6 +13,7 @@ from PySide6.QtCore import Qt, QEvent, QTimer, Signal
 from shinestacker.config.config import config
 config.init(DISABLE_TQDM=True, COMBINED_APP=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
+from shinestacker.config.settings import StdPathFile
 from shinestacker.core.logging import setup_logging
 from shinestacker.gui.main_window import MainWindow
 from shinestacker.retouch.image_editor_ui import ImageEditorUI
@@ -229,7 +230,8 @@ open retouch window at startup instead of project windows.
     if filename and path:
         print("can't specify both arguments --filename and --path", file=sys.stderr)
         sys.exit(1)
-    setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True)
+    setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True,
+                  log_file=StdPathFile('shinestacker.log').get_file_path())
     app = Application(sys.argv)
     if config.DONT_USE_NATIVE_MENU:
         app.setAttribute(Qt.AA_DontUseNativeMenuBar)

shinestacker/app/project.py

@@ -12,6 +12,7 @@ from PySide6.QtCore import Qt, QTimer, QEvent
 from shinestacker.config.config import config
 config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
+from shinestacker.config.settings import StdPathFile
 from shinestacker.core.logging import setup_logging
 from shinestacker.gui.main_window import MainWindow
 from shinestacker.app.gui_utils import (
@@ -57,7 +58,8 @@ project filename.
 ''')
     add_project_arguments(parser)
     args = vars(parser.parse_args(sys.argv[1:]))
-    setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True)
+    setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True,
+                  log_file=StdPathFile('shinestacker.log').get_file_path())
     app = Application(sys.argv)
     if config.DONT_USE_NATIVE_MENU:
         app.setAttribute(Qt.AA_DontUseNativeMenuBar)

shinestacker/app/retouch.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, C0413, E0611, R0903, E1121, W0201
 import os
 import sys
+import logging
 import argparse
 from PySide6.QtWidgets import QApplication, QMenu
 from PySide6.QtGui import QIcon
@@ -8,6 +9,8 @@ from PySide6.QtCore import Qt, QEvent
 from shinestacker.config.config import config
 config.init(DISABLE_TQDM=True, DONT_USE_NATIVE_MENU=True)
 from shinestacker.config.constants import constants
+from shinestacker.config.settings import StdPathFile
+from shinestacker.core.logging import setup_logging
 from shinestacker.retouch.image_editor_ui import ImageEditorUI
 from shinestacker.app.gui_utils import (
     disable_macos_special_menu_items, fill_app_menu, set_css_style)
@@ -54,6 +57,8 @@ Multiple files can be specified separated by ';'.
     if filename and path:
         print("can't specify both arguments --filename and --path", file=sys.stderr)
         sys.exit(1)
+    setup_logging(console_level=logging.DEBUG, file_level=logging.DEBUG, disable_console=True,
+                  log_file=StdPathFile('shinestacker.log').get_file_path())
     app = Application(sys.argv)
     if config.DONT_USE_NATIVE_MENU:
         app.setAttribute(Qt.AA_DontUseNativeMenuBar)

shinestacker/core/core_utils.py

@@ -26,19 +26,10 @@ def make_tqdm_bar(name, size, ncols=80):
 
 
 def get_app_base_path():
-    sep = '\\' if (platform.system() == 'Windows') else '/'
     if getattr(sys, 'frozen', False):
-        path = os.path.dirname(os.path.realpath(sys.executable))
-        dirs = path.split(sep)
-        last = -1
-        for i in range(len(dirs) - 1, -1, -1):
-            if dirs[i] == 'shinestacker':
-                last = i
-                break
-        path = sep.join(dirs if last == 1 else dirs[:last + 1])
-    elif __file__:
-        path = sep.join(os.path.dirname(os.path.abspath(__file__)).split(sep)[:-3])
-    return path
+        return os.path.dirname(os.path.abspath(sys.executable))
+    else:
+        return os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
 def running_under_windows() -> bool:

shinestacker/core/logging.py

@@ -1,4 +1,5 @@
 # pylint: disable=C0114, C0115, C0116
+import os
 import logging
 import sys
 from pathlib import Path
@@ -64,8 +65,8 @@ def setup_logging(console_level=logging.INFO, file_level=logging.DEBUG, log_file
         if log_file == '':
             today = datetime.date.today().strftime("%Y-%m-%d")
             log_file = f"logs/{constants.APP_STRING.lower()}-{today}.log"
-        if log_file[0] != '/':
-            log_file = f'{get_app_base_path()}/{log_file}'
+        if not os.path.isabs(log_file):
+            log_file = os.path.join(get_app_base_path(), {log_file})
         Path(log_file).parent.mkdir(parents=True, exist_ok=True)
         file_handler = logging.FileHandler(log_file)
         file_handler.setLevel(file_level)

shinestacker/retouch/base_filter.py

@@ -157,7 +157,7 @@ class BaseFilter(QObject, LayerCollectionHandler):
             except Exception:
                 h, w = self.master_layer_copy().shape[:2]
             try:
-                self.undo_manager.extend_undo_area(0, 0, w, h)
+                self.undo_manager.set_paint_area(0, 0, w, h)
                 self.undo_manager.save_undo_state(
                     self.master_layer_copy(),
                     self.name

shinestacker/retouch/display_manager.py

@@ -215,7 +215,7 @@ class DisplayManager(QObject, LayerCollectionHandler):
     def refresh_master_view(self):
         if self.has_no_master_layer():
             return
-        self.image_viewer.update_master_display()
+        self.image_viewer.update_master_display_area()
         self.update_master_thumbnail()
 
     def refresh_current_view(self):
@@ -229,7 +229,6 @@ class DisplayManager(QObject, LayerCollectionHandler):
             self.status_message_requested.emit("Temporary view: Individual layer.")
         else:
             self._master_refresh_and_thumb()
-            self.image_viewer.strategy.brush_preview.hide()
             self.status_message_requested.emit("Temporary view: Master.")
 
     def end_temp_view(self):

shinestacker/retouch/image_editor_ui.py

@@ -14,6 +14,7 @@ from .shortcuts_help import ShortcutsHelp
 from .brush import Brush
 from .brush_tool import BrushTool
 from .layer_collection import LayerCollectionHandler
+from .paint_area_manager import PaintAreaManager
 from .undo_manager import UndoManager
 from .layer_collection import LayerCollection
 from .io_gui_handler import IOGuiHandler
@@ -35,9 +36,9 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         self.brush = Brush()
         self.brush_tool = BrushTool()
         self.modified = False
-        self.mask_layer = None
         self.transformation_manager = TransfromationManager(self)
-        self.undo_manager = UndoManager(self.transformation_manager)
+        self.paint_area_manager = PaintAreaManager()
+        self.undo_manager = UndoManager(self.transformation_manager, self.paint_area_manager)
         self.undo_action = None
         self.redo_action = None
         self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
@@ -49,13 +50,13 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
         layout = QHBoxLayout(central_widget)
-        self.image_viewer = ImageViewer(self.layer_collection)
+        self.image_viewer = ImageViewer(
+            self.layer_collection, self.brush_tool, self.paint_area_manager)
         self.image_viewer.connect_signals(
             self.handle_temp_view,
-            self.begin_copy_brush_area,
-            self.continue_copy_brush_area,
             self.end_copy_brush_area,
-            self.handle_brush_size_change)
+            self.handle_brush_size_change,
+            self.handle_needs_update)
         side_panel = QWidget()
         side_layout = QVBoxLayout(side_panel)
         side_layout.setContentsMargins(0, 0, 0, 0)
@@ -629,35 +630,11 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.mark_as_modified()
             self.statusBar().showMessage(f"Copied layer {self.current_layer_idx() + 1} to master")
 
-    def copy_brush_area_to_master(self, view_pos):
-        if self.layer_stack() is None or self.number_of_layers() == 0 \
-           or self.display_manager.view_mode != 'master':
-            return
-        area = self.brush_tool.apply_brush_operation(
-            self.master_layer_copy(),
-            self.current_layer(),
-            self.master_layer(), self.mask_layer,
-            view_pos)
-        self.undo_manager.extend_undo_area(*area)
-
-    def begin_copy_brush_area(self, pos):
-        if self.display_manager.view_mode == 'master':
-            self.mask_layer = self.io_gui_handler.blank_layer.copy()
-            self.copy_master_layer()
-            self.undo_manager.reset_undo_area()
-            self.copy_brush_area_to_master(pos)
-            self.display_manager.needs_update = True
-            if not self.display_manager.update_timer.isActive():
-                self.display_manager.update_timer.start()
-            self.mark_as_modified()
-
-    def continue_copy_brush_area(self, pos):
-        if self.display_manager.view_mode == 'master':
-            self.copy_brush_area_to_master(pos)
-            self.display_manager.needs_update = True
-            if not self.display_manager.update_timer.isActive():
-                self.display_manager.update_timer.start()
-            self.mark_as_modified()
+    def handle_needs_update(self):
+        self.display_manager.needs_update = True
+        if not self.display_manager.update_timer.isActive():
+            self.display_manager.update_timer.start()
+        self.mark_as_modified()
 
     def end_copy_brush_area(self):
         if self.display_manager.update_timer.isActive():
@@ -667,6 +644,7 @@ class ImageEditorUI(QMainWindow, LayerCollectionHandler):
             self.mark_as_modified()
 
     def update_undo_redo_actions(self, has_undo, undo_desc, has_redo, redo_desc):
+        self.image_viewer.update_brush_cursor()
         if self.undo_action:
             if has_undo:
                 self.undo_action.setText(f"Undo {undo_desc}")

shinestacker/retouch/image_viewer.py

@@ -7,13 +7,16 @@ from .sidebyside_view import SideBySideView, TopBottomView
 
 
 class ImageViewer(QWidget):
-    def __init__(self, layer_collection, parent=None):
+    def __init__(self, layer_collection, brush_tool, paint_area_manager, parent=None):
         super().__init__(parent)
         self.status = ImageViewStatus()
         self._strategies = {
-            'overlaid': OverlaidView(layer_collection, self.status, self),
-            'sidebyside': SideBySideView(layer_collection, self.status, self),
-            'topbottom': TopBottomView(layer_collection, self.status, self)
+            'overlaid':
+                OverlaidView(layer_collection, self.status, brush_tool, paint_area_manager, self),
+            'sidebyside':
+                SideBySideView(layer_collection, self.status, brush_tool, paint_area_manager, self),
+            'topbottom':
+                TopBottomView(layer_collection, self.status, brush_tool, paint_area_manager, self)
         }
         for strategy in self._strategies.values():
             strategy.hide()
@@ -48,12 +51,18 @@ class ImageViewer(QWidget):
     def set_master_image_np(self, img):
         self.strategy.set_master_image_np(img)
 
+    def arrange_images(self):
+        self.strategy.arrange_images()
+
     def show_master(self):
         self.strategy.show_master()
 
     def show_current(self):
         self.strategy.show_current()
 
+    def update_master_display_area(self):
+        self.strategy.update_master_display_area()
+
     def update_master_display(self):
         self.strategy.update_master_display()
 
@@ -122,12 +131,11 @@ class ImageViewer(QWidget):
             st.set_cursor_style(style)
 
     def connect_signals(
-            self, handle_temp_view, begin_copy_brush_area, continue_copy_brush_area,
-            end_copy_brush_area, handle_brush_size_change):
+            self, handle_temp_view, end_copy_brush_area,
+            handle_brush_size_change, handle_needs_update):
         for st in self._strategies.values():
             st.temp_view_requested.connect(handle_temp_view)
-            st.brush_operation_started.connect(begin_copy_brush_area)
-            st.brush_operation_continued.connect(continue_copy_brush_area)
-            st.brush_operation_ended.connect(end_copy_brush_area)
+            st.end_copy_brush_area_requested.connect(end_copy_brush_area)
             st.brush_size_change_requested.connect(handle_brush_size_change)
+            st.needs_update_requested.connect(handle_needs_update)
             st.setFocusPolicy(Qt.StrongFocus)

shinestacker/retouch/io_gui_handler.py

@@ -1,13 +1,16 @@
-# pylint: disable=C0114, C0115, C0116, E0611, R0902, W0718
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, W0718, R0904, E1101
 import os
 import traceback
 import numpy as np
-from PySide6.QtWidgets import QFileDialog, QMessageBox, QVBoxLayout, QLabel, QDialog, QApplication
+import cv2
+from PySide6.QtWidgets import (QFileDialog, QMessageBox, QVBoxLayout, QLabel, QDialog,
+                               QApplication, QProgressBar)
 from PySide6.QtGui import QGuiApplication, QCursor
 from PySide6.QtCore import Qt, QObject, QTimer, Signal
+from .. algorithms.exif import get_exif, write_image_with_exif_data
 from .file_loader import FileLoader
 from .exif_data import ExifData
-from .io_manager import IOManager, FileMultilayerSaver
+from .io_threads import FileMultilayerSaver, FrameImporter
 from .layer_collection import LayerCollectionHandler
 
 
@@ -22,13 +25,11 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     def __init__(self, layer_collection, undo_manager, parent):
         QObject.__init__(self, parent)
         LayerCollectionHandler.__init__(self)
-        self.io_manager = IOManager(layer_collection)
         self.undo_manager = undo_manager
         self.set_layer_collection(layer_collection)
         self.loader_thread = None
         self.display_manager = None
         self.image_viewer = None
-        self.blank_layer = None
         self.loading_dialog = None
         self.loading_timer = None
         self.exif_dialog = None
@@ -37,6 +38,13 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.saving_timer = None
         self.current_file_path_master = ''
         self.current_file_path_multi = ''
+        self.frame_importer_thread = None
+        self.frame_loading_dialog = None
+        self.frame_loading_timer = None
+        self.progress_label = None
+        self.progress_bar = None
+        self.exif_data = None
+        self.exif_path = ''
 
     def current_file_path(self):
         return self.current_file_path_master if self.save_master_only.isChecked() \
@@ -57,8 +65,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             self.set_layer_labels(labels)
         self.set_master_layer(master_layer)
         self.image_viewer.set_master_image_np(master_layer)
+        self.set_blank_layer()
         self.undo_manager.reset()
-        self.blank_layer = np.zeros(master_layer.shape[:2])
         self.finish_loading_setup(f"Loaded: {self.current_file_path()}")
         self.image_viewer.reset_zoom()
 
@@ -72,7 +80,40 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.current_file_path_multi = ''
         self.status_message_requested.emit(f"Error loading: {self.current_file_path()}")
 
-    def on_multilayer_save_success(self):
+    def on_frames_imported(self, stack, labels, master):
+        QApplication.restoreOverrideCursor()
+        self.frame_loading_timer.stop()
+        self.frame_loading_dialog.hide()
+        self.frame_loading_dialog.deleteLater()
+        empty_viewer = self.image_viewer.empty()
+        self.image_viewer.set_master_image_np(master)
+        if self.layer_stack() is None and len(stack) > 0:
+            self.set_layer_stack(np.array(stack))
+            if labels is None:
+                labels = self.layer_labels()
+            else:
+                self.set_layer_labels(labels)
+            self.set_master_layer(master)
+            self.set_blank_layer()
+        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.finish_loading_setup("Selected frames imported")
+        if empty_viewer:
+            self.image_viewer.update_master_display()
+
+    def on_frames_import_error(self, error_msg):
+        QApplication.restoreOverrideCursor()
+        self.frame_loading_timer.stop()
+        self.frame_loading_dialog.hide()
+        self.frame_loading_dialog.deleteLater()
+        QMessageBox.critical(self.parent(), "Import Error", error_msg)
+        self.status_message_requested.emit("Error importing frames")
+
+    def on_multilayer_saved(self):
         QApplication.restoreOverrideCursor()
         self.saving_timer.stop()
         self.saving_dialog.hide()
@@ -90,6 +131,7 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         QMessageBox.critical(self.parent(), "Save Error", f"Could not save file: {error_msg}")
 
     def open_file(self, file_paths=None):
+        self.cleanup_old_threads()
         if file_paths is None:
             file_paths, _ = QFileDialog.getOpenFileNames(
                 self.parent(), "Open Image", "",
@@ -128,37 +170,37 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             "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):
-        empty_viewer = self.image_viewer.empty()
-        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
-        self.image_viewer.set_master_image_np(master)
-        if self.layer_stack() is None and len(stack) > 0:
-            self.set_layer_stack(np.array(stack))
-            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.finish_loading_setup("Selected frames imported")
-        if empty_viewer:
-            self.image_viewer.reset_zoom()
+        self.cleanup_old_threads()
+        QGuiApplication.setOverrideCursor(QCursor(Qt.BusyCursor))
+        self.frame_loading_dialog = QDialog(self.parent())
+        self.frame_loading_dialog.setWindowTitle("Loading Frames")
+        self.frame_loading_dialog.setWindowFlags(Qt.Window | Qt.FramelessWindowHint)
+        self.frame_loading_dialog.setModal(True)
+        layout = QVBoxLayout()
+        self.progress_label = QLabel("Frames loading...")
+        layout.addWidget(self.progress_label)
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setRange(0, 100)
+        self.progress_bar.setValue(0)
+        layout.addWidget(self.progress_bar)
+        self.frame_loading_dialog.setLayout(layout)
+        self.frame_loading_timer = QTimer()
+        self.frame_loading_timer.setSingleShot(True)
+        self.frame_loading_timer.timeout.connect(self.frame_loading_dialog.show)
+        self.frame_loading_timer.start(100)
+        self.frame_importer_thread = FrameImporter(file_paths, self.master_layer())
+        self.frame_importer_thread.finished.connect(self.on_frames_imported)
+        self.frame_importer_thread.error.connect(self.on_frames_import_error)
+        self.frame_importer_thread.progress.connect(self.update_import_progress)
+        self.frame_importer_thread.start()
+
+    def update_import_progress(self, percent, filename):
+        if hasattr(self, 'progress_bar'):
+            self.progress_bar.setValue(percent)
+        if hasattr(self, 'progress_label'):
+            self.progress_label.setText(f"Loading: {filename} ({percent}%)")
 
     def finish_loading_setup(self, message):
         self.display_manager.update_thumbnails()
@@ -203,6 +245,7 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             self.save_multilayer_to_path(path)
 
     def save_multilayer_to_path(self, path):
+        self.cleanup_old_threads()
         try:
             master_layer = {'Master': self.master_layer().copy()}
             individual_layers = dict(zip(
@@ -211,8 +254,8 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
             ))
             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)
+                images_dict, path, exif_path=self.exif_path)
+            self.saver_thread.finished.connect(self.on_multilayer_saved)
             self.saver_thread.error.connect(self.on_multilayer_save_error)
             QGuiApplication.setOverrideCursor(QCursor(Qt.BusyCursor))
             self.saving_dialog = QDialog(self.parent())
@@ -250,12 +293,13 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
 
     def save_master_to_path(self, path):
         try:
-            self.io_manager.save_master(path)
+            img = cv2.cvtColor(self.master_layer(), cv2.COLOR_RGB2BGR)
+            write_image_with_exif_data(self.exif_data, img, path)
             self.current_file_path_master = os.path.abspath(path)
-            self.mark_as_modified_requested.emit(False)
+            # self.mark_as_modified_requested.emit(False)
             self.update_title_requested.emit()
-            self.status_message_requested.emit(f"Saved master layer to: {path}")
             self.add_recent_file_requested.emit(self.current_file_path_master)
+            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)}")
@@ -263,14 +307,14 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
     def select_exif_path(self):
         path, _ = QFileDialog.getOpenFileName(None, "Select file with exif data")
         if path:
-            self.io_manager.set_exif_data(path)
+            self.exif_path = path
+            self.exif_data = get_exif(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 = ExifData(self.exif_data, self.parent())
         self.exif_dialog.exec()
 
     def close_file(self):
         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 = ''
@@ -281,3 +325,11 @@ class IOGuiHandler(QObject, LayerCollectionHandler):
         self.update_title_requested.emit()
         self.set_enabled_file_open_close_actions_requested.emit(False)
         self.status_message_requested.emit("File closed")
+
+    def cleanup_old_threads(self):
+        if self.loader_thread and self.loader_thread.isFinished():
+            self.loader_thread = None
+        if self.frame_importer_thread and self.frame_importer_thread.isFinished():
+            self.frame_importer_thread = None
+        if self.saver_thread and self.saver_thread.isFinished():
+            self.saver_thread = None

shinestacker/retouch/io_threads.py

@@ -0,0 +1,78 @@
+# pylint: disable=C0114, C0115, C0116, E0611, E1101, W0718, R0903, R0914
+
+# import time
+import os
+import traceback
+import cv2
+from PySide6.QtCore import QThread, Signal
+from .. algorithms.utils import read_img, validate_image, get_img_metadata
+from .. algorithms.multilayer import write_multilayer_tiff_from_images
+
+
+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 FrameImporter(QThread):
+    finished = Signal(object, object, object)
+    error = Signal(str)
+    progress = Signal(int, str)
+
+    def __init__(self, file_paths, master_layer):
+        super().__init__()
+        self.file_paths = file_paths
+        self.master_layer = master_layer
+
+    def run(self):
+        try:
+            stack = []
+            labels = []
+            master = None
+            current_master = self.master_layer
+            shape, dtype = None, None
+            if current_master is not None:
+                shape, dtype = get_img_metadata(current_master)
+            total_files = len(self.file_paths)
+            for i, path in enumerate(self.file_paths):
+                progress_percent = int((i / total_files) * 100)
+                self.progress.emit(progress_percent, os.path.basename(path))
+                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
+                    counter = 0
+                    while label_x in labels:
+                        counter += 1
+                        label_x = f"{label} ({counter})"
+                    labels.append(label_x)
+                    stack.append(img)
+                    if master is None:
+                        master = img.copy()
+                    # Add delay for testing
+                    # time.sleep(0.2)
+                except Exception as e:
+                    raise RuntimeError(f"Error loading file: {path}.\n{str(e)}") from e
+            self.progress.emit(100, "Complete")
+            self.finished.emit(stack, labels, master)
+        except Exception as e:
+            self.error.emit(str(e))

shinestacker/retouch/layer_collection.py

@@ -7,6 +7,7 @@ class LayerCollection:
         self.master_layer = None
         self.master_layer_copy = None
         self.layer_stack = None
+        self.blank_layer = None
         self.layer_labels = []
         self.current_layer_idx = 0
         self.sorted_indices = None
@@ -15,6 +16,7 @@ class LayerCollection:
         self.master_layer = None
         self.master_layer_copy = None
         self.layer_stack = None
+        self.blank_layer = None
         self.layer_labels = []
         self.current_layer_idx = 0
         self.sorted_indices = None
@@ -62,6 +64,10 @@ class LayerCollection:
     def set_master_layer(self, img):
         self.master_layer = img
 
+    def set_blank_layer(self):
+        if self.master_layer is not None:
+            self.blank_layer = np.zeros(self.master_layer.shape[:2])
+
     def restore_master_layer(self):
         self.master_layer = self.master_layer_copy.copy()
 
@@ -122,6 +128,9 @@ class LayerCollectionHandler:
     def current_layer(self):
         return self.layer_collection.current_layer()
 
+    def blank_layer(self):
+        return self.layer_collection.blank_layer
+
     def layer_stack(self):
         return self.layer_collection.layer_stack
 
@@ -152,6 +161,9 @@ class LayerCollectionHandler:
     def set_master_layer(self, img):
         self.layer_collection.set_master_layer(img)
 
+    def set_blank_layer(self):
+        self.layer_collection.set_blank_layer()
+
     def add_layer_label(self, label):
         self.layer_collection.add_layer_label(label)
 

shinestacker/retouch/overlaid_view.py

@@ -1,11 +1,11 @@
-# pylint: disable=C0114, C0115, C0116, E0611, E1101, R0904, R0912, R0914, R0902, E0202
+# pylint: disable=C0114, C0115, C0116, E0611, E1101, R0904, R0912, R0914, R0902, E0202, R0913, R0917
 from PySide6.QtCore import Qt, QPointF, QEvent, QRectF
 from .view_strategy import ViewStrategy, ImageGraphicsViewBase, ViewSignals
 
 
 class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
-    def __init__(self, layer_collection, status, parent):
-        ViewStrategy.__init__(self, layer_collection, status)
+    def __init__(self, layer_collection, status, brush_tool, paint_area_manager, parent):
+        ViewStrategy.__init__(self, layer_collection, status, brush_tool, paint_area_manager)
         ImageGraphicsViewBase.__init__(self, parent)
         self.scene = self.create_scene(self)
         self.create_pixmaps()
@@ -121,6 +121,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
         self.pixmap_item_master.setVisible(True)
         self.pixmap_item_current.setVisible(False)
         self.show_brush_preview()
+        self.enable_paint = True
         if self.brush_cursor:
             self.scene.removeItem(self.brush_cursor)
             self.brush_cursor = self.create_circle(self.scene)
@@ -130,21 +131,28 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
         self.pixmap_item_master.setVisible(False)
         self.pixmap_item_current.setVisible(True)
         self.hide_brush_preview()
+        self.enable_paint = False
         if self.brush_cursor:
             self.scene.removeItem(self.brush_cursor)
             self.brush_cursor = self.create_alt_circle(self.scene)
             self.update_brush_cursor()
 
+    def master_is_visible(self):
+        return self.pixmap_item_master.isVisible()
+
+    def current_is_visible(self):
+        return self.pixmap_item_current.isVisible()
+
     def arrange_images(self):
         if self.empty():
             return
-        if self.pixmap_item_master.isVisible():
+        if self.master_is_visible():
             pixmap = self.pixmap_item_master.pixmap()
             if not pixmap.isNull():
                 self.setSceneRect(QRectF(pixmap.rect()))
                 self.centerOn(self.pixmap_item_master)
                 self.center_image(self)
-        elif self.pixmap_item_current.isVisible():
+        elif self.current_is_visible():
             pixmap = self.pixmap_item_current.pixmap()
             if not pixmap.isNull():
                 self.setSceneRect(QRectF(pixmap.rect()))

shinestacker/retouch/paint_area_manager.py

@@ -0,0 +1,30 @@
+# pylint: disable=C0114, C0115, C0116
+from .. config.gui_constants import gui_constants
+
+
+class PaintAreaManager:
+    def __init__(self):
+        self.x_start = None
+        self.y_start = None
+        self.x_end = None
+        self.y_end = None
+        self.reset()
+
+    def reset(self):
+        self.x_end = self.y_end = 0
+        self.x_start = self.y_start = gui_constants.MAX_UNDO_SIZE
+
+    def extend(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 area(self):
+        return self.x_start, self.y_start, self.x_end, self.y_end
+
+    def set_area(self, x_start, y_start, x_end, y_end):
+        self.x_start = x_start
+        self.y_start = y_start
+        self.x_end = x_end
+        self.y_end = y_end

shinestacker/retouch/sidebyside_view.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, R0904, R0915, E0611, R0902, R0911, R0914, E1003
+# pylint: disable=C0114, C0115, C0116, R0904, R0915, E0611, R0902, R0911, R0914, E1003, R0913, R0917
 import time
 from PySide6.QtCore import Qt, Signal, QEvent, QRectF
 from PySide6.QtGui import QCursor
@@ -39,8 +39,8 @@ class ImageGraphicsView(ImageGraphicsViewBase):
 
 
 class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
-    def __init__(self, layer_collection, status, parent):
-        ViewStrategy.__init__(self, layer_collection, status)
+    def __init__(self, layer_collection, status, brush_tool, paint_area_manager, parent):
+        ViewStrategy.__init__(self, layer_collection, status, brush_tool, paint_area_manager)
         QWidget.__init__(self, parent)
         self.current_view = ImageGraphicsView(parent)
         self.master_view = ImageGraphicsView(parent)

shinestacker/retouch/transformation_manager.py

@@ -16,8 +16,7 @@ class TransfromationManager(LayerCollectionHandler):
         if undoable:
             try:
                 undo = self.editor.undo_manager
-                undo.x_start, undo.x_stop = 0, 1
-                undo.y_start, undo.y_stop = 0, 1
+                undo.set_paint_area(0, 1, 0, 1)
                 undo.save_undo_state(self.editor.master_layer(), label)
             except Exception as e:
                 traceback.print_tb(e.__traceback__)

shinestacker/retouch/undo_manager.py

@@ -6,13 +6,10 @@ from .. config.gui_constants import gui_constants
 class UndoManager(QObject):
     stack_changed = Signal(bool, str, bool, str)
 
-    def __init__(self, transformation_manager):
+    def __init__(self, transformation_manager, paint_area_manager):
         super().__init__()
         self.transformation_manager = transformation_manager
-        self.x_start = None
-        self.y_start = None
-        self.x_end = None
-        self.y_end = None
+        self.paint_area_manager = paint_area_manager
         self.undo_stack = None
         self.redo_stack = None
         self.reset()
@@ -24,22 +21,25 @@ class UndoManager(QObject):
         self.stack_changed.emit(False, "", False, "")
 
     def reset_undo_area(self):
-        self.x_end = self.y_end = 0
-        self.x_start = self.y_start = gui_constants.MAX_UNDO_SIZE
+        self.paint_area_manager.reset()
 
     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)
+        self.paint_area_manager.extend(x_start, y_start, x_end, y_end)
+
+    def paint_area(self):
+        return self.paint_area_manager.area()
+
+    def set_paint_area(self, x_start, y_start, x_end, y_end):
+        self.paint_area_manager.set_area(x_start, y_start, x_end, y_end)
 
     def save_undo_state(self, layer, description):
         if layer is None:
             return
         self.redo_stack = []
+        x_start, y_start, x_end, y_end = self.paint_area()
         undo_state = {
-            'master': layer[self.y_start:self.y_end, self.x_start:self.x_end].copy(),
-            'area': (self.x_start, self.y_start, self.x_end, self.y_end),
+            'master': layer[y_start:y_end, x_start:x_end].copy(),
+            'area': (x_start, y_start, x_end, y_end),
             'description': description
         }
         if len(self.undo_stack) >= gui_constants.MAX_UNDO_SIZE:
@@ -54,6 +54,7 @@ class UndoManager(QObject):
             return False
         undo_state = self.undo_stack.pop()
         x_start, y_start, x_end, y_end = undo_state['area']
+        self.set_paint_area(x_start, y_start, x_end, y_end)
         redo_state = {
             'master': layer[y_start:y_end, x_start:x_end].copy(),
             'area': (x_start, y_start, x_end, y_end),
@@ -80,6 +81,7 @@ class UndoManager(QObject):
             return False
         redo_state = self.redo_stack.pop()
         x_start, y_start, x_end, y_end = redo_state['area']
+        self.set_paint_area(x_start, y_start, x_end, y_end)
         undo_state = {
             'master': layer[y_start:y_end, x_start:x_end].copy(),
             'area': (x_start, y_start, x_end, y_end),

shinestacker/retouch/view_strategy.py

@@ -79,10 +79,9 @@ class BrushCursor(QGraphicsItemGroup):
 
 class ViewSignals:
     temp_view_requested = Signal(bool)
-    brush_operation_started = Signal(QPoint)
-    brush_operation_continued = Signal(QPoint)
-    brush_operation_ended = Signal()
+    end_copy_brush_area_requested = Signal()
     brush_size_change_requested = Signal(int)  # +1 or -1
+    needs_update_requested = Signal()
 
 
 class ImageGraphicsViewBase(QGraphicsView):
@@ -103,9 +102,12 @@ class ImageGraphicsViewBase(QGraphicsView):
 
 
 class ViewStrategy(LayerCollectionHandler):
-    def __init__(self, layer_collection, status):
+    def __init__(self, layer_collection, status, brush_tool, paint_area_manager):
         LayerCollectionHandler.__init__(self, layer_collection)
         self.status = status
+        self.brush_tool = brush_tool
+        self.paint_area_manager = paint_area_manager
+        self.mask_layer = None
         self.brush = None
         self.brush_cursor = None
         self.brush_preview = BrushPreviewItem(layer_collection)
@@ -123,6 +125,7 @@ class ViewStrategy(LayerCollectionHandler):
         self.last_update_time = QTime.currentTime()
         self.last_color_update_time = 0
         self.last_cursor_update_time = 0
+        self.enable_paint = True
 
     @abstractmethod
     def create_pixmaps(self):
@@ -274,6 +277,25 @@ class ViewStrategy(LayerCollectionHandler):
             view.verticalScrollBar().setValue(self.status.v_scroll)
             self.arrange_images()
 
+    def update_master_display_area(self):
+        if self.empty():
+            return
+        x_start, y_start, x_end, y_end = self.paint_area_manager.area()
+        dirty_region = self.master_layer()[y_start:y_end, x_start:x_end]
+        qimage = self.numpy_to_qimage(dirty_region)
+        if not qimage:
+            return
+        pixmap = QPixmap.fromImage(qimage)
+        master_pixmap_item = self.get_master_pixmap()
+        current_pixmap = master_pixmap_item.pixmap()
+        if current_pixmap.isNull():
+            self.update_master_display()
+            return
+        painter = QPainter(current_pixmap)
+        painter.drawPixmap(x_start, y_start, pixmap)
+        painter.end()
+        master_pixmap_item.setPixmap(current_pixmap)
+
     def update_master_display(self):
         self.update_view_display(
             self.master_layer(),
@@ -698,6 +720,42 @@ class ViewStrategy(LayerCollectionHandler):
         self.status.set_scroll(view.horizontalScrollBar().value(),
                                view.verticalScrollBar().value())
 
+    def copy_brush_area_to_master(self, view_pos):
+        if self.layer_stack() is None or self.number_of_layers() == 0:
+            return
+        area = self.brush_tool.apply_brush_operation(
+            self.master_layer_copy(),
+            self.current_layer(),
+            self.master_layer(), self.mask_layer,
+            view_pos)
+        self.paint_area_manager.extend(*area)
+
+    def begin_copy_brush_area(self, pos):
+        self.mask_layer = self.blank_layer().copy()
+        self.copy_master_layer()
+        self.paint_area_manager.reset()
+        self.copy_brush_area_to_master(pos)
+        self.needs_update_requested.emit()
+
+    def continue_copy_brush_area(self, pos):
+        self.copy_brush_area_to_master(pos)
+        self.needs_update_requested.emit()
+
+    def mouse_press_event(self, event):
+        if self.empty():
+            return
+        if self.enable_paint and event.button() & Qt.LeftButton and self.has_master_layer():
+            if self.space_pressed:
+                self.scrolling = True
+                self.last_mouse_pos = event.position()
+                self.setCursor(Qt.ClosedHandCursor)
+            else:
+                self.last_brush_pos = event.position()
+                self.begin_copy_brush_area(event.position().toPoint())
+                self.dragging = True
+            if not self.scrolling:
+                self.show_brush_cursor()
+
     def mouse_move_event(self, event):
         if self.empty():
             return
@@ -710,7 +768,7 @@ class ViewStrategy(LayerCollectionHandler):
         brush_size = self.brush.size
         if not self.space_pressed:
             self.update_brush_cursor()
-        if self.dragging and event.buttons() & Qt.LeftButton:
+        if self.enable_paint and self.dragging and event.buttons() & Qt.LeftButton:
             current_time = QTime.currentTime()
             paint_refresh_time = AppConfig.get('paint_refresh_time')
             if self.last_update_time.msecsTo(current_time) >= paint_refresh_time:
@@ -726,7 +784,7 @@ class ViewStrategy(LayerCollectionHandler):
                     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.brush_operation_continued.emit(pos)
+                        self.continue_copy_brush_area(pos)
                     self.last_brush_pos = position
                 self.last_update_time = current_time
         if self.scrolling and event.buttons() & Qt.LeftButton:
@@ -738,21 +796,6 @@ class ViewStrategy(LayerCollectionHandler):
             self.last_mouse_pos = position
             self.scroll_view(master_view, delta.x(), delta.y())
 
-    def mouse_press_event(self, event):
-        if self.empty():
-            return
-        if event.button() == Qt.LeftButton and self.has_master_layer():
-            if self.space_pressed:
-                self.scrolling = True
-                self.last_mouse_pos = event.position()
-                self.setCursor(Qt.ClosedHandCursor)
-            else:
-                self.last_brush_pos = event.position()
-                self.brush_operation_started.emit(event.position().toPoint())
-                self.dragging = True
-            if not self.scrolling:
-                self.show_brush_cursor()
-
     def mouse_release_event(self, event):
         if self.empty():
             return
@@ -769,4 +812,4 @@ class ViewStrategy(LayerCollectionHandler):
                 self.last_mouse_pos = None
             elif self.dragging:
                 self.dragging = False
-                self.brush_operation_ended.emit()
+                self.end_copy_brush_area_requested.emit()

{shinestacker-1.6.0.dist-info → shinestacker-1.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.6.0
+Version: 1.6.1
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0

{shinestacker-1.6.0.dist-info → shinestacker-1.6.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 shinestacker/__init__.py,sha256=uq2fjAw2z_6TpH3mOcWFZ98GoEPRsNhTAK8N0MMm_e8,448
-shinestacker/_version.py,sha256=aWnRnF5TUBHC_2RdGczq36VyxBiPAviva2RjtMVjCFg,21
+shinestacker/_version.py,sha256=DH87PU9LcZeI_uvttoH-lyhGyb55UShgeFtsG2qIZgE,21
 shinestacker/algorithms/__init__.py,sha256=1FwVJ3w9GGbFFkjYJRUedTvcdE4j0ieSgaH9RC9iCY4,877
 shinestacker/algorithms/align.py,sha256=mb44u-YxZI1TTSHz81nRpX_2c8awlOhnGrK0LyfTQeQ,33543
 shinestacker/algorithms/align_auto.py,sha256=pJetw6zZEWQLouzcelkI8gD4cPiOp887ePXzVbm0E6Q,3800
@@ -25,10 +25,10 @@ shinestacker/app/about_dialog.py,sha256=pkH7nnxUP8yc0D3vRGd1jRb5cwi1nDVbQRk_OC9y
 shinestacker/app/args_parser_opts.py,sha256=c6IUXOI0SJIFckPWPXYnwmBmdNnOcrtvU5S8hUDU_AQ,979
 shinestacker/app/gui_utils.py,sha256=EGZejp0XZXRLVa_Wd_2VYAwK3oe9hMSoZzNgT7NUNRw,2986
 shinestacker/app/help_menu.py,sha256=g8lKG_xZmXtNQaC3SIRzyROKVWva_PLEgZsQWh6zUcQ,499
-shinestacker/app/main.py,sha256=l9O9J7nICTi3wnW2uJpKfLV7HWDEi-r_xoOrbywJv_s,11129
+shinestacker/app/main.py,sha256=OQwPJvhrsAThv9kmiqtX7CX-smfwXdFXagQmGsQdmuU,11258
 shinestacker/app/open_frames.py,sha256=bsu32iJSYJQLe_tQQbvAU5DuMDVX6MRuNdE7B5lojZc,1488
-shinestacker/app/project.py,sha256=8hjKkZqBsumS7McHXRZdGvyHgopPHeHznrnIdXajp_w,2916
-shinestacker/app/retouch.py,sha256=pks7aoXmYyRoeTzOA-D2Uy5f4RKoEDh25OQtkcOE_9c,2778
+shinestacker/app/project.py,sha256=jn4LlMTMxrJeAyQQrR5nVS4Di1rOrjiOJ8LOg0CZbwE,3045
+shinestacker/app/retouch.py,sha256=fyk74fgpeoBqY1mRJiXWf1hRzSeG7xXFx4V-Sphr3Kg,3069
 shinestacker/app/settings_dialog.py,sha256=0P3nqqZEiTIFgidW1_e3Q_zE7NbAouNsuj-yNsU41vk,8192
 shinestacker/config/__init__.py,sha256=aXxi-LmAvXd0daIFrVnTHE5OCaYeK1uf1BKMr7oaXQs,197
 shinestacker/config/app_config.py,sha256=rM1Rndk1GDa5c0AhcVNEN9zSAzxPZixzQYfjODbJUwE,771
@@ -38,10 +38,10 @@ shinestacker/config/gui_constants.py,sha256=PNxzwmVEppJ2mV_vwp68NhWzJOEitVy1Pk9S
 shinestacker/config/settings.py,sha256=4p4r6wKOCbttzfH9tyHQSTd-iv-GfgCd1LxI3C7WIjU,3861
 shinestacker/core/__init__.py,sha256=IUEIx6SQ3DygDEHN3_E6uKpHjHtUa4a_U_1dLd_8yEU,484
 shinestacker/core/colors.py,sha256=kr_tJA1iRsdck2JaYDb2lS-codZ4Ty9gdu3kHfiWvuM,1340
-shinestacker/core/core_utils.py,sha256=1LYj19Dfc9jZN9-4dlf1paximDH5WZYa7DXvKr7R7QY,1719
+shinestacker/core/core_utils.py,sha256=wmpu9_idDRe866JFEylMvGPJRT8lSVhikK9PljcbPSI,1392
 shinestacker/core/exceptions.py,sha256=2-noG-ORAGdvDhL8jBQFs0xxZS4fI6UIkMqrWekgk2c,1618
 shinestacker/core/framework.py,sha256=QaTfnzEUHwzlbyFG7KzeyteckTSWHWEEJE4d5Tc8H18,11015
-shinestacker/core/logging.py,sha256=9SuSSy9Usbh7zqmLYMqkmy-VBkOJW000lwqAR0XQs30,3067
+shinestacker/core/logging.py,sha256=T-ZTGYjN2n2_5Vu2mBJ2id9qj1c9NA79OD2H2w-W0nM,3096
 shinestacker/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shinestacker/gui/action_config.py,sha256=Xv7SGbhPl1F_dUnU04VBt_E-wIItnN_q6QuhU_d9GfI,25929
 shinestacker/gui/action_config_dialog.py,sha256=QN95FiVPYL6uin2sYO5F7tq6G5rBWh9yRkeTVvwKrwU,38341
@@ -75,35 +75,36 @@ shinestacker/gui/img/forward-button-icon.png,sha256=lNw86T4TOEd_uokHYF8myGSGUXzd
 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/base_filter.py,sha256=zpedVvTpof8BsENWdDeu9PDul7Uw0UAXUSsyLZjbcpg,11265
+shinestacker/retouch/base_filter.py,sha256=ObrAcwZv9YJbIhWMHcryHEEj41oAk9hfHmE4phEd1gE,11263
 shinestacker/retouch/brush.py,sha256=dzD2FzSpBIPdJRmTZobcrQ1FrVd3tF__ZPnUplNE72s,357
 shinestacker/retouch/brush_gradient.py,sha256=F5SFhyzl8YTMqjJU3jK8BrIlLCYLUvITd5wz3cQE4xk,1453
 shinestacker/retouch/brush_preview.py,sha256=cOFVMCbEsgR_alzmr_-LLghtGU_unrE-hAjLHcvrZAY,5484
 shinestacker/retouch/brush_tool.py,sha256=8uVncTA375uC3Nhp2YM0eZjpOR-nN47i2eGjN8tJzOU,8714
 shinestacker/retouch/denoise_filter.py,sha256=UpNKbFs7uArdglEej8AUHan7oCVYV5E7HNzkovj7XMQ,571
-shinestacker/retouch/display_manager.py,sha256=iRPcXWb3h3OVJy-S4xny--SB-rUfU4Qc4YSVu3XstWE,10236
+shinestacker/retouch/display_manager.py,sha256=fTZTGbvmX5DXagexuvbNgOF5GiH2Vv-stLUQQwoglp8,10181
 shinestacker/retouch/exif_data.py,sha256=LF-fRXW-reMq-xJ_QRE5j8DC2LVGKIlC6MR3QbC1cdg,1896
 shinestacker/retouch/file_loader.py,sha256=z02-A8_uDZxayI1NFTxT2GVUvEBWStchX9hlN1o5-0U,4784
 shinestacker/retouch/filter_manager.py,sha256=tOGIWj5HjViL1-iXHkd91X-sZ1c1G531pDmLO0x6zx0,866
 shinestacker/retouch/icon_container.py,sha256=6gw1HO1bC2FrdB4dc_iH81DQuLjzuvRGksZ2hKLT9yA,585
-shinestacker/retouch/image_editor_ui.py,sha256=vPfLuHdRZTGNbmX3ZXYoJ9Q2_dCDbFJHUxB41hrOD6k,34117
+shinestacker/retouch/image_editor_ui.py,sha256=r2S4Fgyi3xQi2XeqlVYTUxZ9YlPZe2rMaIpvIak8Aog,33181
 shinestacker/retouch/image_view_status.py,sha256=2rWi2ugdyjMhWCtRJkwOnb7-tCtVfnGfCY_54qpZhwM,1970
-shinestacker/retouch/image_viewer.py,sha256=H8w-ORug1aKf7X3FeSX4lQV-a0IewZ9OVG1-50BK4cE,4452
-shinestacker/retouch/io_gui_handler.py,sha256=UOnrFT00s0075Ng_yJACJX9TP8UT9mQOWXwQwNAfpMw,12079
-shinestacker/retouch/io_manager.py,sha256=JUAA--AK0mVa1PTErJTnBFjaXIle5Qs7Ow0Wkd8at0o,2437
-shinestacker/retouch/layer_collection.py,sha256=fZlGrkm9-Ycc7AOzFSpImhafiTieBeCZRk-UlvlFHbo,5819
-shinestacker/retouch/overlaid_view.py,sha256=KBwuzC2OQsK7rdtFAKrSvXrHrEV1SiOoZhxPCQLGkvg,6734
+shinestacker/retouch/image_viewer.py,sha256=xf1vYZRPb9ClCQbqrqAFhPubdqIIpku7DgcY8O5bvYU,4694
+shinestacker/retouch/io_gui_handler.py,sha256=tyHMmR6_uE_IEI-CIcJibVhupxarKYHzX2fuhnesHaI,14616
+shinestacker/retouch/io_threads.py,sha256=r0X4it2PfwnmiAU7eStniIfcHhPvuaqdqf5VlnvjZ-4,2832
+shinestacker/retouch/layer_collection.py,sha256=xx8INSLCXIeTQn_nxfCo4QljAmQK1qukSYO1Zk4rqqo,6183
+shinestacker/retouch/overlaid_view.py,sha256=QTTdegUWs99YBZZPlIRdPI5O80U3t_c3HnyegbRqNbA,7029
+shinestacker/retouch/paint_area_manager.py,sha256=ilK6uQT7lzNyvdc8uNv4xTHHHAbk5hGEClJRNmiA4P8,894
 shinestacker/retouch/shortcuts_help.py,sha256=BFWTT5QvodqMhqa_9LI25hZqjICfckgyWG4fGrGzvnM,4283
-shinestacker/retouch/sidebyside_view.py,sha256=iwnIENV_YrR2fogXqKNdCcAQBROWkQxOnh8G4tU5bqA,18829
-shinestacker/retouch/transformation_manager.py,sha256=T2ewDsEKn1FBxapQ1kR7KqFwrF7spUu-KZ43bKpfBo8,1761
-shinestacker/retouch/undo_manager.py,sha256=_qTpwjGsznc-Sz-sfWEDv3IxJNmrYU0qi7yJelg58DU,4319
+shinestacker/retouch/sidebyside_view.py,sha256=4sNa_IUMbNH18iECO7eDO9S_ls3v2ENwP1AWrBFhofI,18907
+shinestacker/retouch/transformation_manager.py,sha256=QFYCL-l9V6qlhw3y7tcs0saWWClNPsh7F9pTBkfPbRU,1711
+shinestacker/retouch/undo_manager.py,sha256=J4hEAnv9bKLQ0N1wllWswjJBhgRgasCnBoMT5LEw-dM,4453
 shinestacker/retouch/unsharp_mask_filter.py,sha256=Iapc8UmSVpj3V0LcJq_38P5qerRqTevMynbbk5Rk6iE,3634
-shinestacker/retouch/view_strategy.py,sha256=l_Fuh6vmTLv7S400XAP1fDO61Dv7U8GaOrNTvjKKjvc,28521
+shinestacker/retouch/view_strategy.py,sha256=jZxB_vX3_0notH0ClxKkLzbdtx4is3vQiYoIP-sDv3M,30216
 shinestacker/retouch/vignetting_filter.py,sha256=JhFr6OVIripQzSJrZEG4lxq7wBsmpofLqJQ-aP2bKw8,3789
 shinestacker/retouch/white_balance_filter.py,sha256=UaH4yxG3fU4vPutBAkV5oTXIQyUTN09x0uTywAzv3sY,8286
-shinestacker-1.6.0.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
-shinestacker-1.6.0.dist-info/METADATA,sha256=0sCC4ubrLH2wabRFJaCx9_Kaj3K4HDIdM6vULEj2iJA,6978
-shinestacker-1.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shinestacker-1.6.0.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
-shinestacker-1.6.0.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
-shinestacker-1.6.0.dist-info/RECORD,,
+shinestacker-1.6.1.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
+shinestacker-1.6.1.dist-info/METADATA,sha256=9sevPHbXS-yaj-wYc-42q28V34PNOdnPlntqNzlsgOo,6978
+shinestacker-1.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shinestacker-1.6.1.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
+shinestacker-1.6.1.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
+shinestacker-1.6.1.dist-info/RECORD,,

shinestacker/retouch/io_manager.py

@@ -1,69 +0,0 @@
-# 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.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_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)