shinestacker 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

shinestacker/retouch/brush_tool.py

@@ -1,7 +1,8 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0913, R0917, R0914
 import numpy as np
 from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush
 from PySide6.QtCore import Qt, QPoint
-from .brush_gradient import create_brush_gradient
+from .brush_gradient import create_default_brush_gradient
 from .. config.gui_constants import gui_constants
 from .. config.constants import constants
 from .brush_preview import create_brush_mask
@@ -42,7 +43,8 @@ class BrushTool:
             normalized = slider_val / gui_constants.BRUSH_SIZE_SLIDER_MAX
             size = gui_constants.BRUSH_SIZES['min'] + \
                 gui_constants.BRUSH_SIZES['max'] * (normalized ** gui_constants.BRUSH_GAMMA)
-            return max(gui_constants.BRUSH_SIZES['min'], min(gui_constants.BRUSH_SIZES['max'], size))
+            return max(gui_constants.BRUSH_SIZES['min'],
+                       min(gui_constants.BRUSH_SIZES['max'], size))
 
         self.brush.size = slider_to_brush_size(slider_val)
         self.update_brush_thumb()
@@ -89,21 +91,21 @@ class BrushTool:
         center_x, center_y = width // 2, height // 2
         radius = preview_size // 2
         if self.image_viewer.cursor_style == 'preview':
-            gradient = create_brush_gradient(
-                center_x, center_y, radius,
-                self.brush.hardness,
-                inner_color=QColor(*gui_constants.BRUSH_COLORS['inner']),
-                outer_color=QColor(*gui_constants.BRUSH_COLORS['gradient_end']),
-                opacity=self.brush.opacity
-            )
+            gradient = create_default_brush_gradient(center_x, center_y, radius, self.brush)
             painter.setBrush(QBrush(gradient))
-            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['outer']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+            painter.setPen(
+                QPen(QColor(*gui_constants.BRUSH_COLORS['outer']),
+                     gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
         elif self.image_viewer.cursor_style == 'outline':
             painter.setBrush(Qt.NoBrush)
-            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['outer']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+            painter.setPen(
+                QPen(QColor(*gui_constants.BRUSH_COLORS['outer']),
+                     gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
         else:
             painter.setBrush(QBrush(QColor(*gui_constants.BRUSH_COLORS['cursor_inner'])))
-            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+            painter.setPen(
+                QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
+                     gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
         painter.drawEllipse(QPoint(center_x, center_y), radius, radius)
         if self.image_viewer.cursor_style == 'preview':
             painter.setPen(QPen(QColor(0, 0, 160)))
@@ -115,7 +117,8 @@ class BrushTool:
         self.brush_preview.setPixmap(pixmap)
         self.image_viewer.update_brush_cursor()
 
-    def apply_brush_operation(self, master_layer, source_layer, dest_layer, mask_layer, view_pos, image_viewer):
+    def apply_brush_operation(self, master_layer, source_layer, dest_layer, mask_layer,
+                              view_pos, image_viewer):
         if master_layer is None or source_layer is None:
             return False
         if dest_layer is None:
@@ -136,14 +139,17 @@ class BrushTool:
         source_area = source_layer[y_start:y_end, x_start:x_end]
         dest_area = dest_layer[y_start:y_end, x_start:x_end]
         mask_layer_area = mask_layer[y_start:y_end, x_start:x_end]
-        mask_area = mask[y_start - (y_center - radius):y_end - (y_center - radius), x_start - (x_center - radius):x_end - (x_center - radius)]
-        mask_layer_area[:] = np.clip(mask_layer_area + mask_area * self.brush.flow / 100.0, 0.0, 1.0)  # np.maximum(mask_layer_area, mask_area)
+        mask_area = mask[y_start - (y_center - radius):y_end - (y_center - radius),
+                         x_start - (x_center - radius):x_end - (x_center - radius)]
+        mask_layer_area[:] = np.clip(
+            mask_layer_area + mask_area * self.brush.flow / 100.0, 0.0,
+            1.0)
         self.apply_mask(master_area, source_area, mask_layer_area, dest_area)
         return x_start, y_start, x_end, y_end
 
     def get_brush_mask(self, radius):
         mask_key = (radius, self.brush.hardness)
-        if mask_key not in self._brush_mask_cache.keys():
+        if mask_key not in self._brush_mask_cache:
             full_mask = create_brush_mask(size=radius * 2 + 1, hardness_percent=self.brush.hardness,
                                           opacity_percent=self.brush.opacity)
             self._brush_mask_cache[mask_key] = full_mask
@@ -155,10 +161,13 @@ class BrushTool:
         dtype = master_area.dtype
         max_px_value = constants.MAX_UINT16 if dtype == np.uint16 else constants.MAX_UINT8
         if master_area.ndim == 3:
-            dest_area[:] = np.clip(master_area * (1 - effective_mask[..., np.newaxis]) + source_area * # noqa
-                                   effective_mask[..., np.newaxis], 0, max_px_value).astype(dtype)
+            dest_area[:] = np.clip(
+                master_area * (1 - effective_mask[..., np.newaxis]) +
+                source_area * effective_mask[..., np.newaxis], 0, max_px_value).astype(dtype)
         else:
-            dest_area[:] = np.clip(master_area * (1 - effective_mask) + source_area * effective_mask, 0, max_px_value).astype(dtype)
+            dest_area[:] = np.clip(
+                master_area * (1 - effective_mask) + source_area * effective_mask, 0,
+                max_px_value).astype(dtype)
 
     def clear_cache(self):
         self._brush_mask_cache.clear()

shinestacker/retouch/denoise_filter.py

@@ -1,6 +1,8 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0221
 from PySide6.QtWidgets import QHBoxLayout, QLabel, QSlider, QCheckBox, QDialogButtonBox
 from PySide6.QtCore import Qt, QTimer
-from .filter_base import BaseFilter
+from .base_filter import BaseFilter
+from .. algorithms.denoise import denoise
 
 
 class DenoiseFilter(BaseFilter):
@@ -52,5 +54,4 @@ class DenoiseFilter(BaseFilter):
         return (self.max_value * self.slider.value() / self.max_range,)
 
     def apply(self, image, strength):
-        from .. algorithms.denoise import denoise
         return denoise(image, strength)

shinestacker/retouch/display_manager.py

@@ -1,8 +1,10 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0903, R0913, R0917, E1121
 import numpy as np
 from PySide6.QtWidgets import QWidget, QListWidgetItem, QVBoxLayout, QLabel, QInputDialog
 from PySide6.QtGui import QPixmap, QImage
 from PySide6.QtCore import Qt, QObject, QTimer, QSize, Signal
 from .. config.gui_constants import gui_constants
+from .layer_collection import LayerCollectionHandler
 
 
 class ClickableLabel(QLabel):
@@ -12,20 +14,22 @@ class ClickableLabel(QLabel):
         super().__init__(text, parent)
         self.setMouseTracking(True)
 
+    # pylint: disable=C0103
     def mouseDoubleClickEvent(self, event):
         if event.button() == Qt.LeftButton:
             self.double_clicked.emit()
         super().mouseDoubleClickEvent(event)
+    # pylint: enable=C0103
 
 
-class DisplayManager(QObject):
+class DisplayManager(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
     cursor_preview_state_changed = Signal(bool)
 
     def __init__(self, layer_collection, image_viewer, master_thumbnail_label,
                  thumbnail_list, parent=None):
-        super().__init__(parent)
-        layer_collection.add_to(self)
+        QObject.__init__(self, parent)
+        LayerCollectionHandler.__init__(self, layer_collection)
         self.image_viewer = image_viewer
         self.master_thumbnail_label = master_thumbnail_label
         self.thumbnail_list = thumbnail_list
@@ -67,7 +71,8 @@ class DisplayManager(QObject):
             qimg = QImage(layer.data, width, height, 3 * width, QImage.Format_RGB888)
         else:
             qimg = QImage(layer.data, width, height, width, QImage.Format_Grayscale8)
-        return QPixmap.fromImage(qimg.scaled(*gui_constants.UI_SIZES['thumbnail'], Qt.KeepAspectRatio))
+        return QPixmap.fromImage(
+            qimg.scaled(*gui_constants.UI_SIZES['thumbnail'], Qt.KeepAspectRatio))
 
     def update_thumbnails(self):
         self.update_master_thumbnail()
@@ -112,7 +117,8 @@ class DisplayManager(QObject):
         label_widget.setAlignment(Qt.AlignCenter)
 
         def rename_label(label_widget, old_label, i):
-            new_label, ok = QInputDialog.getText(self.thumbnail_list, "Rename Label", "New label name:", text=old_label)
+            new_label, ok = QInputDialog.getText(
+                self.thumbnail_list, "Rename Label", "New label name:", text=old_label)
             if ok and new_label and new_label != old_label:
                 label_widget.setText(new_label)
                 self.set_layer_labels(i, new_label)

shinestacker/retouch/exif_data.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E0611
 import os
 from PIL.TiffImagePlugin import IFDRational
 from PySide6.QtWidgets import QFormLayout, QHBoxLayout, QPushButton, QDialog, QLabel

shinestacker/retouch/file_loader.py

@@ -1,7 +1,8 @@
-import numpy as np
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0914, E1101, R0911, R0912
+import os
 import traceback
+import numpy as np
 import cv2
-import os
 from psdtags import PsdChannelId
 from PySide6.QtCore import QThread, Signal
 from .. algorithms.utils import read_img
@@ -20,10 +21,11 @@ class FileLoader(QThread):
         try:
             current_stack, current_labels = self.load_stack(self.path)
             if current_stack is None or len(current_stack) == 0:
-                self.error.emit("Empty or invalid stack")
+                self.error.emit(f"The file {self.path} does not contain a valid image.")
                 return
             if current_labels:
-                master_indices = [i for i, label in enumerate(current_labels) if label.lower() == "master"]
+                master_indices = [i for i, label in enumerate(current_labels)
+                                  if label.lower() == "master"]
             else:
                 master_indices = []
             master_index = -1 if len(master_indices) == 0 else master_indices[0]
@@ -76,7 +78,8 @@ class FileLoader(QThread):
                 if layers:
                     stack = np.array(layers)
                     if labels:
-                        master_indices = [i for i, label in enumerate(labels) if label.lower() == "master"]
+                        master_indices = [i for i, label in enumerate(labels)
+                                          if label.lower() == "master"]
                         if master_indices:
                             master_index = master_indices[0]
                             master_label = labels.pop(master_index)
@@ -86,8 +89,9 @@ class FileLoader(QThread):
                             stack = np.insert(stack, 0, master_layer, axis=0)
                         return stack, labels
                     return stack, labels
-            except ValueError as e:
-                if str(e) == "TIFF file contains no ImageSourceData tag":
+                return None, None
+            except ValueError as val_err:
+                if str(val_err) == "TIFF file contains no ImageSourceData tag":
                     try:
                         stack = np.array([cv2.cvtColor(read_img(path), cv2.COLOR_BGR2RGB)])
                         return stack, [path.split('/')[-1].split('.')[0]]
@@ -95,8 +99,8 @@ class FileLoader(QThread):
                         traceback.print_tb(e.__traceback__)
                         return None, None
                 else:
-                    traceback.print_tb(e.__traceback__)
-                    raise e
+                    traceback.print_tb(val_err.__traceback__)
+                    raise val_err
             except Exception as e:
                 traceback.print_tb(e.__traceback__)
                 return None, None

shinestacker/retouch/filter_manager.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116
 class FilterManager:
     def __init__(self, editor):
         self.editor = editor

shinestacker/retouch/image_editor.py

@@ -1,21 +1,18 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0902
 from PySide6.QtWidgets import QMainWindow, QMessageBox, QAbstractItemView
-from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush
-from PySide6.QtCore import Qt, QPoint
 from .. config.constants import constants
-from .. config.gui_constants import gui_constants
 from .undo_manager import UndoManager
 from .layer_collection import LayerCollection
 from .io_gui_handler import IOGuiHandler
-from .brush_gradient import create_brush_gradient
 from .display_manager import DisplayManager
 from .brush_tool import BrushTool
+from .layer_collection import LayerCollectionHandler
 
 
-class ImageEditor(QMainWindow):
+class ImageEditor(QMainWindow, LayerCollectionHandler):
     def __init__(self):
-        super().__init__()
-        layer_collection = LayerCollection()
-        layer_collection.add_to(self)
+        QMainWindow.__init__(self)
+        LayerCollectionHandler.__init__(self, LayerCollection())
         self.undo_manager = UndoManager()
         self.undo_action = None
         self.redo_action = None
@@ -25,10 +22,12 @@ class ImageEditor(QMainWindow):
         self.brush_tool = BrushTool()
         self.modified = False
         self.installEventFilter(self)
+        self.mask_layer = None
 
     def setup_ui(self):
-        self.display_manager = DisplayManager(self.layer_collection, self.image_viewer,
-                                              self.master_thumbnail_label, self.thumbnail_list, parent=self)
+        self.display_manager = DisplayManager(
+            self.layer_collection, self.image_viewer,
+            self.master_thumbnail_label, self.thumbnail_list, parent=self)
         self.io_gui_handler = IOGuiHandler(self.layer_collection, self.undo_manager, parent=self)
         self.display_manager.status_message_requested.connect(self.show_status_message)
         self.display_manager.cursor_preview_state_changed.connect(
@@ -46,6 +45,7 @@ class ImageEditor(QMainWindow):
     def show_status_message(self, message):
         self.statusBar().showMessage(message)
 
+    # pylint: disable=C0103
     def keyPressEvent(self, event):
         if self.image_viewer.empty:
             return
@@ -62,8 +62,9 @@ class ImageEditor(QMainWindow):
             self.brush_tool.increase_brush_hardness()
             return
         super().keyPressEvent(event)
+    # pylint: enable=C0103
 
-    def _check_unsaved_changes(self) -> bool:
+    def check_unsaved_changes(self) -> bool:
         if self.modified:
             reply = QMessageBox.question(
                 self, "Unsaved Changes",
@@ -124,7 +125,8 @@ class ImageEditor(QMainWindow):
 
     def highlight_thumbnail(self, index):
         self.thumbnail_list.setCurrentRow(index)
-        self.thumbnail_list.scrollToItem(self.thumbnail_list.item(index), QAbstractItemView.PositionAtCenter)
+        self.thumbnail_list.scrollToItem(
+            self.thumbnail_list.item(index), QAbstractItemView.PositionAtCenter)
 
     def copy_layer_to_master(self):
         if self.layer_stack() is None or self.master_layer() is None:
@@ -155,42 +157,6 @@ class ImageEditor(QMainWindow):
             view_pos, self.image_viewer)
         self.undo_manager.extend_undo_area(*area)
 
-    def update_brush_thumb(self):
-        width, height = gui_constants.UI_SIZES['brush_preview']
-        pixmap = QPixmap(width, height)
-        pixmap.fill(Qt.transparent)
-        painter = QPainter(pixmap)
-        painter.setRenderHint(QPainter.Antialiasing)
-        preview_size = min(self.brush.size, width + 30, height + 30)
-        center_x, center_y = width // 2, height // 2
-        radius = preview_size // 2
-        if self.image_viewer.cursor_style == 'preview':
-            gradient = create_brush_gradient(
-                center_x, center_y, radius,
-                self.brush.hardness,
-                inner_color=QColor(*gui_constants.BRUSH_COLORS['inner']),
-                outer_color=QColor(*gui_constants.BRUSH_COLORS['gradient_end']),
-                opacity=self.brush.opacity
-            )
-            painter.setBrush(QBrush(gradient))
-            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['outer']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
-        elif self.image_viewer.cursor_style == 'outline':
-            painter.setBrush(Qt.NoBrush)
-            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['outer']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
-        else:
-            painter.setBrush(QBrush(QColor(*gui_constants.BRUSH_COLORS['cursor_inner'])))
-            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
-        painter.drawEllipse(QPoint(center_x, center_y), radius, radius)
-        if self.image_viewer.cursor_style == 'preview':
-            painter.setPen(QPen(QColor(0, 0, 160)))
-            painter.drawText(0, 10, f"Size: {int(self.brush.size)}px")
-            painter.drawText(0, 25, f"Hardness: {self.brush.hardness}%")
-            painter.drawText(0, 40, f"Opacity: {self.brush.opacity}%")
-            painter.drawText(0, 55, f"Flow: {self.brush.flow}%")
-        painter.end()
-        self.brush_preview.setPixmap(pixmap)
-        self.image_viewer.update_brush_cursor()
-
     def begin_copy_brush_area(self, pos):
         if self.display_manager.allow_cursor_preview():
             self.mask_layer = self.io_gui_handler.blank_layer.copy()

shinestacker/retouch/image_editor_ui.py

@@ -1,4 +1,6 @@
-from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel, QListWidget, QSlider
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, R0914, R0915
+from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel,
+                               QListWidget, QSlider)
 from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QGuiApplication
@@ -14,7 +16,8 @@ def brush_size_to_slider(size):
         return 0
     if size >= gui_constants.BRUSH_SIZES['max']:
         return gui_constants.BRUSH_SIZE_SLIDER_MAX
-    normalized = ((size - gui_constants.BRUSH_SIZES['min']) / gui_constants.BRUSH_SIZES['max']) ** (1 / gui_constants.BRUSH_GAMMA)
+    normalized = ((size - gui_constants.BRUSH_SIZES['min']) /
+                  gui_constants.BRUSH_SIZES['max']) ** (1 / gui_constants.BRUSH_GAMMA)
     return int(normalized * gui_constants.BRUSH_SIZE_SLIDER_MAX)
 
 
@@ -25,6 +28,7 @@ class ImageEditorUI(ImageFilters):
         self.setup_ui()
         self.setup_menu()
         self.setup_shortcuts()
+        self._dialog = None
 
     def setup_shortcuts(self):
         prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
@@ -129,7 +133,8 @@ class ImageEditorUI(ImageFilters):
         master_thumbnail_layout.setContentsMargins(2, 2, 2, 2)
         self.master_thumbnail_label = QLabel()
         self.master_thumbnail_label.setAlignment(Qt.AlignCenter)
-        self.master_thumbnail_label.setFixedSize(gui_constants.THUMB_WIDTH, gui_constants.THUMB_HEIGHT)
+        self.master_thumbnail_label.setFixedSize(
+            gui_constants.THUMB_WIDTH, gui_constants.THUMB_HEIGHT)
         self.master_thumbnail_label.mousePressEvent = lambda e: self.set_view_master()
         master_thumbnail_layout.addWidget(self.master_thumbnail_label)
         side_layout.addWidget(self.master_thumbnail_frame)
@@ -313,7 +318,7 @@ class ImageEditorUI(ImageFilters):
         filter_menu = menubar.addMenu("&Filter")
         filter_menu.setObjectName("Filter")
         denoise_action = QAction("Denoise", self)
-        denoise_action.triggered.connect(self.denoise)
+        denoise_action.triggered.connect(self.denoise_filter)
         filter_menu.addAction(denoise_action)
         unsharp_mask_action = QAction("Unsharp Mask", self)
         unsharp_mask_action.triggered.connect(self.unsharp_mask)
@@ -339,7 +344,7 @@ class ImageEditorUI(ImageFilters):
             self.window().showNormal()
 
     def quit(self):
-        if self._check_unsaved_changes():
+        if self.check_unsaved_changes():
             self.close()
 
     def undo(self):

shinestacker/retouch/image_filters.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, R0914
 import numpy as np
 from .image_editor import ImageEditor
 from .filter_manager import FilterManager
@@ -14,7 +15,7 @@ class ImageFilters(ImageEditor):
         self.filter_manager.register_filter("unsharp_mask", UnsharpMaskFilter)
         self.filter_manager.register_filter("white_balance", WhiteBalanceFilter)
 
-    def denoise(self):
+    def denoise_filter(self):
         self.filter_manager.apply("denoise")
 
     def unsharp_mask(self):
@@ -47,7 +48,8 @@ class ImageFilters(ImageEditor):
                 x1 = min(master_layer.shape[1], x + radius + 1)
                 y0 = max(0, y - radius)
                 y1 = min(master_layer.shape[0], y + radius + 1)
-                mask = mask[radius - (y - y0): radius + (y1 - y), radius - (x - x0): radius + (x1 - x)]
+                mask = mask[radius - (y - y0): radius + (y1 - y),
+                            radius - (x - x0): radius + (x1 - x)]
                 region = master_layer[y0:y1, x0:x1]
                 if region.size == 0:
                     pixel = master_layer[y, x]

shinestacker/retouch/image_viewer.py

@@ -1,13 +1,15 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0904, R0902, R0914
 import math
 from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
 from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor, QShortcut, QKeySequence
 from PySide6.QtCore import Qt, QRectF, QTime, QPoint, QPointF, Signal
 from .. config.gui_constants import gui_constants
 from .brush_preview import BrushPreviewItem
-from .brush_gradient import create_brush_gradient
+from .brush_gradient import create_default_brush_gradient
+from .layer_collection import LayerCollectionHandler
 
 
-class ImageViewer(QGraphicsView):
+class ImageViewer(QGraphicsView, LayerCollectionHandler):
     temp_view_requested = Signal(bool)
     brush_operation_started = Signal(QPoint)
     brush_operation_continued = Signal(QPoint)
@@ -15,7 +17,8 @@ class ImageViewer(QGraphicsView):
     brush_size_change_requested = Signal(int)  # +1 or -1
 
     def __init__(self, layer_collection, parent=None):
-        super().__init__(parent)
+        QGraphicsView.__init__(self, parent)
+        LayerCollectionHandler.__init__(self)
         self.display_manager = None
         self.layer_collection = layer_collection
         self.brush = None
@@ -43,11 +46,12 @@ class ImageViewer(QGraphicsView):
         self.scrolling = False
         self.dragging = False
         self.last_update_time = QTime.currentTime()
-        self.brush_preview = BrushPreviewItem()
-        self.layer_collection.add_to(self.brush_preview)
+        self.set_layer_collection(layer_collection)
+        self.brush_preview = BrushPreviewItem(self.layer_collection)
         self.scene.addItem(self.brush_preview)
         self.empty = True
         self.allow_cursor_preview = True
+        self.last_brush_pos = None
 
     def set_image(self, qimage):
         pixmap = QPixmap.fromImage(qimage)
@@ -73,12 +77,13 @@ class ImageViewer(QGraphicsView):
         self.scene.addItem(self.pixmap_item)
         self.zoom_factor = 1.0
         self.setup_brush_cursor()
-        self.brush_preview = BrushPreviewItem()
+        self.brush_preview = BrushPreviewItem(self.layer_collection)
         self.scene.addItem(self.brush_preview)
         self.setCursor(Qt.ArrowCursor)
         self.brush_cursor.hide()
         self.empty = True
 
+    # pylint: disable=C0103
     def keyPressEvent(self, event):
         if self.empty:
             return
@@ -140,7 +145,8 @@ class ImageViewer(QGraphicsView):
         if self.dragging and event.buttons() & Qt.LeftButton:
             current_time = QTime.currentTime()
             if self.last_update_time.msecsTo(current_time) >= gui_constants.PAINT_REFRESH_TIMER:
-                min_step = brush_size * gui_constants.MIN_MOUSE_STEP_BRUSH_FRACTION * self.zoom_factor
+                min_step = brush_size * \
+                    gui_constants.MIN_MOUSE_STEP_BRUSH_FRACTION * self.zoom_factor
                 x, y = position.x(), position.y()
                 xp, yp = self.last_brush_pos.x(), self.last_brush_pos.y()
                 distance = math.sqrt((x - xp)**2 + (y - yp)**2)
@@ -207,11 +213,29 @@ class ImageViewer(QGraphicsView):
                     self.zoom_factor = new_scale
         self.update_brush_cursor()
 
+    def enterEvent(self, event):
+        self.activateWindow()
+        self.setFocus()
+        if not self.empty:
+            self.setCursor(Qt.BlankCursor)
+            if self.brush_cursor:
+                self.brush_cursor.show()
+        super().enterEvent(event)
+
+    def leaveEvent(self, event):
+        if not self.empty:
+            self.setCursor(Qt.ArrowCursor)
+            if self.brush_cursor:
+                self.brush_cursor.hide()
+        super().leaveEvent(event)
+    # pylint: enable=C0103
+
     def setup_brush_cursor(self):
         self.setCursor(Qt.BlankCursor)
         pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), 1)
         brush = QBrush(QColor(*gui_constants.BRUSH_COLORS['cursor_inner']))
-        self.brush_cursor = self.scene.addEllipse(0, 0, self.brush.size, self.brush.size, pen, brush)
+        self.brush_cursor = self.scene.addEllipse(
+            0, 0, self.brush.size, self.brush.size, pen, brush)
         self.brush_cursor.setZValue(1000)
         self.brush_cursor.hide()
 
@@ -256,33 +280,11 @@ class ImageViewer(QGraphicsView):
         self.brush_cursor.setBrush(Qt.NoBrush)
 
     def _setup_simple_brush_style(self, center_x, center_y, radius):
-        gradient = create_brush_gradient(
-            center_x, center_y, radius,
-            self.brush.hardness,
-            inner_color=QColor(*gui_constants.BRUSH_COLORS['inner']),
-            outer_color=QColor(*gui_constants.BRUSH_COLORS['gradient_end']),
-            opacity=self.brush.opacity
-        )
+        gradient = create_default_brush_gradient(center_x, center_y, radius, self.brush)
         self.brush_cursor.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
                                       gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor))
         self.brush_cursor.setBrush(QBrush(gradient))
 
-    def enterEvent(self, event):
-        self.activateWindow()
-        self.setFocus()
-        if not self.empty:
-            self.setCursor(Qt.BlankCursor)
-            if self.brush_cursor:
-                self.brush_cursor.show()
-        super().enterEvent(event)
-
-    def leaveEvent(self, event):
-        if not self.empty:
-            self.setCursor(Qt.ArrowCursor)
-            if self.brush_cursor:
-                self.brush_cursor.hide()
-        super().leaveEvent(event)
-
     def setup_shortcuts(self):
         prev_layer = QShortcut(QKeySequence(Qt.Key_Up), self, context=Qt.ApplicationShortcut)
         prev_layer.activated.connect(self.prev_layer)

shinestacker/retouch/io_gui_handler.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0902, W0718
 import traceback
 import numpy as np
 from PySide6.QtWidgets import QFileDialog, QMessageBox, QVBoxLayout, QLabel, QDialog, QApplication
@@ -6,18 +7,27 @@ from PySide6.QtCore import Qt, QObject, QTimer, Signal
 from .file_loader import FileLoader
 from .exif_data import ExifData
 from .io_manager import IOManager
+from .layer_collection import LayerCollectionHandler
 
 
-class IOGuiHandler(QObject):
+class IOGuiHandler(QObject, LayerCollectionHandler):
     status_message_requested = Signal(str)
     update_title_requested = Signal()
 
     def __init__(self, layer_collection, undo_manager, parent):
-        super().__init__(parent)
+        QObject.__init__(self, parent)
+        LayerCollectionHandler.__init__(self)
         self.io_manager = IOManager(layer_collection)
         self.undo_manager = undo_manager
-        layer_collection.add_to(self)
+        self.set_layer_collection(layer_collection)
         self.loader_thread = None
+        self.display_manager = None
+        self.image_viewer = None
+        self.modified = None
+        self.blank_layer = None
+        self.loading_dialog = None
+        self.loading_timer = None
+        self.exif_dialog = None
 
     def setup_ui(self, display_manager, image_viewer):
         self.display_manager = display_manager
@@ -49,13 +59,14 @@ class IOGuiHandler(QObject):
         self.loading_timer.stop()
         self.loading_dialog.accept()
         self.loading_dialog.deleteLater()
-        QMessageBox.critical(self, "Error", error_msg)
+        QMessageBox.critical(self.parent(), "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 (*)")
+                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():
@@ -84,8 +95,9 @@ class IOGuiHandler(QObject):
         self.loader_thread.start()
 
     def import_frames(self):
-        file_paths, _ = QFileDialog.getOpenFileNames(self.parent(), "Select frames", "",
-                                                     "Images Images (*.tif *.tiff *.jpg *.jpeg);;All Files (*)")
+        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")
@@ -168,8 +180,9 @@ class IOGuiHandler(QObject):
     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 (*)")
+        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)
 
@@ -189,14 +202,13 @@ class IOGuiHandler(QObject):
         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()
+        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():
+        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