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

shinestacker/retouch/image_editor_ui.py

@@ -1,11 +1,12 @@
-from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel, QListWidget, QListWidgetItem, QSlider, QInputDialog
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QFrame, QLabel, QListWidget, QSlider
 from PySide6.QtGui import QShortcut, QKeySequence, QAction, QActionGroup
-from PySide6.QtCore import Qt, QSize, Signal
+from PySide6.QtCore import Qt
 from PySide6.QtGui import QGuiApplication
 from .. config.gui_constants import gui_constants
 from .image_filters import ImageFilters
 from .image_viewer import ImageViewer
 from .shortcuts_help import ShortcutsHelp
+from .brush import Brush
 
 
 def brush_size_to_slider(size):
@@ -17,22 +18,10 @@ def brush_size_to_slider(size):
     return int(normalized * gui_constants.BRUSH_SIZE_SLIDER_MAX)
 
 
-class ClickableLabel(QLabel):
-    doubleClicked = Signal()
-
-    def __init__(self, text, parent=None):
-        super().__init__(text, parent)
-        self.setMouseTracking(True)
-
-    def mouseDoubleClickEvent(self, event):
-        if event.button() == Qt.LeftButton:
-            self.doubleClicked.emit()
-        super().mouseDoubleClickEvent(event)
-
-
 class ImageEditorUI(ImageFilters):
     def __init__(self):
         super().__init__()
+        self.brush = Brush()
         self.setup_ui()
         self.setup_menu()
         self.setup_shortcuts()
@@ -51,10 +40,12 @@ class ImageEditorUI(ImageFilters):
         central_widget = QWidget()
         self.setCentralWidget(central_widget)
         layout = QHBoxLayout(central_widget)
-        self.image_viewer = ImageViewer()
+        self.image_viewer = ImageViewer(self.layer_collection)
         self.image_viewer.temp_view_requested.connect(self.handle_temp_view)
-        self.image_viewer.image_editor = self
-        self.image_viewer.brush = self.brush_controller.brush
+        self.image_viewer.brush_operation_started.connect(self.begin_copy_brush_area)
+        self.image_viewer.brush_operation_continued.connect(self.continue_copy_brush_area)
+        self.image_viewer.brush_operation_ended.connect(self.end_copy_brush_area)
+        self.image_viewer.brush_size_change_requested.connect(self.handle_brush_size_change)
         self.image_viewer.setFocusPolicy(Qt.StrongFocus)
         side_panel = QWidget()
         side_layout = QVBoxLayout(side_panel)
@@ -75,7 +66,6 @@ class ImageEditorUI(ImageFilters):
         self.brush_size_slider = QSlider(Qt.Horizontal)
         self.brush_size_slider.setRange(0, gui_constants.BRUSH_SIZE_SLIDER_MAX)
         self.brush_size_slider.setValue(brush_size_to_slider(self.brush.size))
-        self.brush_size_slider.valueChanged.connect(self.update_brush_size)
         brush_layout.addWidget(self.brush_size_slider)
 
         hardness_label = QLabel("Brush Hardness")
@@ -84,7 +74,6 @@ class ImageEditorUI(ImageFilters):
         self.hardness_slider = QSlider(Qt.Horizontal)
         self.hardness_slider.setRange(0, 100)
         self.hardness_slider.setValue(self.brush.hardness)
-        self.hardness_slider.valueChanged.connect(self.update_brush_hardness)
         brush_layout.addWidget(self.hardness_slider)
 
         opacity_label = QLabel("Brush Opacity")
@@ -93,7 +82,6 @@ class ImageEditorUI(ImageFilters):
         self.opacity_slider = QSlider(Qt.Horizontal)
         self.opacity_slider.setRange(0, 100)
         self.opacity_slider.setValue(self.brush.opacity)
-        self.opacity_slider.valueChanged.connect(self.update_brush_opacity)
         brush_layout.addWidget(self.opacity_slider)
 
         flow_label = QLabel("Brush Flow")
@@ -102,7 +90,6 @@ class ImageEditorUI(ImageFilters):
         self.flow_slider = QSlider(Qt.Horizontal)
         self.flow_slider.setRange(1, 100)
         self.flow_slider.setValue(self.brush.flow)
-        self.flow_slider.valueChanged.connect(self.update_brush_flow)
         brush_layout.addWidget(self.flow_slider)
 
         side_layout.addWidget(brush_panel)
@@ -119,7 +106,6 @@ class ImageEditorUI(ImageFilters):
         """)
         self.brush_preview.setAlignment(Qt.AlignCenter)
         self.brush_preview.setFixedHeight(100)
-        self.update_brush_thumb()
         brush_layout.addWidget(self.brush_preview)
         side_layout.addWidget(brush_panel)
 
@@ -210,22 +196,23 @@ class ImageEditorUI(ImageFilters):
         layout.addWidget(control_panel, 0)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(2)
+        super().setup_ui()
 
     def setup_menu(self):
         menubar = self.menuBar()
         file_menu = menubar.addMenu("&File")
-        file_menu.addAction("&Open...", self.open_file, "Ctrl+O")
-        file_menu.addAction("&Save", self.save_file, "Ctrl+S")
-        file_menu.addAction("Save &As...", self.save_file_as, "Ctrl+Shift+S")
+        file_menu.addAction("&Open...", self.io_gui_handler.open_file, "Ctrl+O")
+        file_menu.addAction("&Save", self.io_gui_handler.save_file, "Ctrl+S")
+        file_menu.addAction("Save &As...", self.io_gui_handler.save_file_as, "Ctrl+Shift+S")
         self.save_master_only = QAction("Save Master &Only", self)
         self.save_master_only.setCheckable(True)
         self.save_master_only.setChecked(True)
         file_menu.addAction(self.save_master_only)
 
-        file_menu.addAction("&Close", self.close_file, "Ctrl+W")
+        file_menu.addAction("&Close", self.io_gui_handler.close_file, "Ctrl+W")
         file_menu.addSeparator()
-        file_menu.addAction("&Import frames", self.import_frames)
-        file_menu.addAction("Import &EXIF data", self.select_exif_path)
+        file_menu.addAction("&Import frames", self.io_gui_handler.import_frames)
+        file_menu.addAction("Import &EXIF data", self.io_gui_handler.select_exif_path)
 
         edit_menu = menubar.addMenu("&Edit")
         self.undo_action = QAction("Undo", self)
@@ -278,12 +265,12 @@ class ImageEditorUI(ImageFilters):
 
         view_master_action = QAction("View Master", self)
         view_master_action.setShortcut("M")
-        view_master_action.triggered.connect(self.set_view_master)
+        view_master_action.triggered.connect(self.display_manager.set_view_master)
         view_menu.addAction(view_master_action)
 
         view_individual_action = QAction("View Individual", self)
         view_individual_action.setShortcut("L")
-        view_individual_action.triggered.connect(self.set_view_individual)
+        view_individual_action.triggered.connect(self.display_manager.set_view_individual)
         view_menu.addAction(view_individual_action)
         view_menu.addSeparator()
 
@@ -355,55 +342,28 @@ class ImageEditorUI(ImageFilters):
         if self._check_unsaved_changes():
             self.close()
 
-    def _add_thumbnail_item(self, thumbnail, label, i, is_current):
-        item_widget = QWidget()
-        layout = QVBoxLayout(item_widget)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(0)
-
-        thumbnail_label = QLabel()
-        thumbnail_label.setPixmap(thumbnail)
-        thumbnail_label.setAlignment(Qt.AlignCenter)
-        layout.addWidget(thumbnail_label)
-
-        label_widget = ClickableLabel(label)
-        label_widget.setAlignment(Qt.AlignCenter)
-        label_widget.doubleClicked.connect(lambda: self._rename_label(label_widget, label, i))
-        layout.addWidget(label_widget)
-
-        item = QListWidgetItem()
-        item.setSizeHint(QSize(gui_constants.IMG_WIDTH, gui_constants.IMG_HEIGHT))
-        self.thumbnail_list.addItem(item)
-        self.thumbnail_list.setItemWidget(item, item_widget)
-
-        if is_current:
-            self.thumbnail_list.setCurrentItem(item)
-
-    def _rename_label(self, label_widget, old_label, i):
-        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._update_label_in_data(old_label, new_label, i)
-
-    def _update_label_in_data(self, old_label, new_label, i):
-        self.layer_collection.layer_labels[i] = new_label
-
     def undo(self):
-        if self.undo_manager.undo(self.layer_collection.master_layer):
-            self.display_current_view()
-            self.update_master_thumbnail()
+        if self.undo_manager.undo(self.master_layer()):
+            self.display_manager.display_current_view()
+            self.display_manager.update_master_thumbnail()
             self.mark_as_modified()
             self.statusBar().showMessage("Undo applied", 2000)
 
     def redo(self):
-        if self.undo_manager.redo(self.layer_collection.master_layer):
-            self.display_current_view()
-            self.update_master_thumbnail()
+        if self.undo_manager.redo(self.master_layer()):
+            self.display_manager.display_current_view()
+            self.display_manager.update_master_thumbnail()
             self.mark_as_modified()
             self.statusBar().showMessage("Redo applied", 2000)
 
     def handle_temp_view(self, start):
         if start:
-            self.start_temp_view()
+            self.display_manager.start_temp_view()
+        else:
+            self.display_manager.end_temp_view()
+
+    def handle_brush_size_change(self, delta):
+        if delta > 0:
+            self.brush_tool.increase_brush_size()
         else:
-            self.end_temp_view()
+            self.brush_tool.decrease_brush_size()

shinestacker/retouch/image_filters.py

@@ -1,35 +1,27 @@
 import numpy as np
-from PySide6.QtWidgets import (QHBoxLayout,
-                               QPushButton, QFrame, QVBoxLayout, QLabel, QDialog, QApplication, QSlider,
-                               QCheckBox, QDialogButtonBox)
-from PySide6.QtGui import QCursor
-from PySide6.QtCore import Qt, QTimer, QThread, Signal
-from .. algorithms.denoise import denoise
-from .. algorithms.sharpen import unsharp_mask
-from .. algorithms.white_balance import white_balance_from_rgb
 from .image_editor import ImageEditor
+from .filter_manager import FilterManager
+from .denoise_filter import DenoiseFilter
+from .unsharp_mask_filter import UnsharpMaskFilter
+from .white_balance_filter import WhiteBalanceFilter
 
 
 class ImageFilters(ImageEditor):
     def __init__(self):
         super().__init__()
+        self.filter_manager = FilterManager(self)
+        self.filter_manager.register_filter("denoise", DenoiseFilter)
+        self.filter_manager.register_filter("unsharp_mask", UnsharpMaskFilter)
+        self.filter_manager.register_filter("white_balance", WhiteBalanceFilter)
 
-    class PreviewWorker(QThread):
-        finished = Signal(np.ndarray, int)
+    def denoise(self):
+        self.filter_manager.apply("denoise")
 
-        def __init__(self, func, args=(), kwargs=None, request_id=0):
-            super().__init__()
-            self.func = func
-            self.args = args
-            self.kwargs = kwargs or {}
-            self.request_id = request_id
+    def unsharp_mask(self):
+        self.filter_manager.apply("unsharp_mask")
 
-        def run(self):
-            try:
-                result = self.func(*self.args, **self.kwargs)
-            except Exception:
-                raise
-            self.finished.emit(result, self.request_id)
+    def white_balance(self, init_val=None):
+        self.filter_manager.apply("white_balance", init_val=init_val or (128, 128, 128))
 
     def connect_preview_toggle(self, preview_check, do_preview, restore_original):
         def on_toggled(checked):
@@ -39,353 +31,37 @@ class ImageFilters(ImageEditor):
                 restore_original()
         preview_check.toggled.connect(on_toggled)
 
-    def run_filter_with_preview(self, filter_func, get_params, setup_ui, undo_label):
-        if self.layer_collection.master_layer is None:
-            return
-        self.layer_collection.copy_master_layer()
-        dlg = QDialog(self)
-        layout = QVBoxLayout(dlg)
-        active_worker = None
-        last_request_id = 0
-
-        def set_preview(img, request_id, expected_id):
-            if request_id != expected_id:
-                return
-            self.layer_collection.master_layer = img
-            self.display_master_layer()
-            try:
-                dlg.activateWindow()
-            except Exception:
-                pass
-
-        def do_preview():
-            nonlocal active_worker, last_request_id
-            if active_worker and active_worker.isRunning():
-                try:
-                    active_worker.quit()
-                    active_worker.wait()
-                except Exception:
-                    pass
-            last_request_id += 1
-            current_id = last_request_id
-            params = tuple(get_params() or ())
-            worker = self.PreviewWorker(filter_func, args=(self.layer_collection.master_layer_copy, *params), request_id=current_id)
-            active_worker = worker
-            active_worker.finished.connect(lambda img, rid: set_preview(img, rid, current_id))
-            active_worker.start()
-
-        def restore_original():
-            self.layer_collection.master_layer = self.layer_collection.master_layer_copy.copy()
-            self.display_master_layer()
-            try:
-                dlg.activateWindow()
-            except Exception:
-                pass
-
-        setup_ui(dlg, layout, do_preview, restore_original)
-        QTimer.singleShot(0, do_preview)
-        accepted = dlg.exec_() == QDialog.Accepted
-        if accepted:
-            params = tuple(get_params() or ())
-            try:
-                h, w = self.layer_collection.master_layer.shape[:2]
-            except Exception:
-                h, w = self.layer_collection.master_layer_copy.shape[:2]
-            if hasattr(self, "undo_manager"):
-                try:
-                    self.undo_manager.extend_undo_area(0, 0, w, h)
-                    self.undo_manager.save_undo_state(self.layer_collection.master_layer_copy, undo_label)
-                except Exception:
-                    pass
-            final_img = filter_func(self.layer_collection.master_layer_copy, *params)
-            self.layer_collection.master_layer = final_img
-            self.layer_collection.copy_master_layer()
-            self.display_master_layer()
-            self.update_master_thumbnail()
-            self.mark_as_modified()
-        else:
-            restore_original()
-
-    def denoise(self):
-        max_range = 500.0
-        max_value = 10.00
-        initial_value = 2.5
-
-        def get_params():
-            return (max_value * slider.value() / max_range,)
-
-        def setup_ui(dlg, layout, do_preview, restore_original):
-            nonlocal slider
-            dlg.setWindowTitle("Denoise")
-            dlg.setMinimumWidth(600)
-            slider_layout = QHBoxLayout()
-            slider_local = QSlider(Qt.Horizontal)
-            slider_local.setRange(0, max_range)
-            slider_local.setValue(int(initial_value / max_value * max_range))
-            slider_layout.addWidget(slider_local)
-            value_label = QLabel(f"{max_value:.2f}")
-            slider_layout.addWidget(value_label)
-            layout.addLayout(slider_layout)
-            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 do_preview_delayed():
-                preview_timer.start()
-
-            def slider_changed(val):
-                float_val = max_value * float(val) / max_range
-                value_label.setText(f"{float_val:.2f}")
-                if preview_check.isChecked():
-                    do_preview_delayed()
-
-            preview_timer.timeout.connect(do_preview)
-            slider_local.valueChanged.connect(slider_changed)
-            self.connect_preview_toggle(preview_check, do_preview_delayed, restore_original)
-            button_box.accepted.connect(dlg.accept)
-            button_box.rejected.connect(dlg.reject)
-            slider = slider_local
-
-        slider = None
-        self.run_filter_with_preview(denoise, get_params, setup_ui, 'Denoise')
-
-    def unsharp_mask(self):
-        max_range = 500.0
-        max_radius = 4.0
-        max_amount = 3.0
-        max_threshold = 64.0
-        initial_radius = 1.0
-        initial_amount = 0.5
-        initial_threshold = 0.0
-
-        def get_params():
-            return (
-                max(0.01, max_radius * radius_slider.value() / max_range),
-                max_amount * amount_slider.value() / max_range,
-                max_threshold * threshold_slider.value() / max_range
-            )
-
-        def setup_ui(dlg, layout, do_preview, restore_original):
-            nonlocal radius_slider, amount_slider, threshold_slider
-            dlg.setWindowTitle("Unsharp Mask")
-            dlg.setMinimumWidth(600)
-            params = {
-                "Radius": (max_radius, initial_radius, "{:.2f}"),
-                "Amount": (max_amount, initial_amount, "{:.1%}"),
-                "Threshold": (max_threshold, 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, max_range)
-                slider.setValue(int(init_val / max_val * 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":
-                    radius_slider = slider
-                elif name == "Amount":
-                    amount_slider = slider
-                elif name == "Threshold":
-                    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 / max_range
-                value_labels[name].setText(fmt.format(float_value))
-                if preview_check.isChecked():
-                    preview_timer.start()
-
-            radius_slider.valueChanged.connect(
-                lambda v: update_value("Radius", v, max_radius, params["Radius"][2]))
-            amount_slider.valueChanged.connect(
-                lambda v: update_value("Amount", v, max_amount, params["Amount"][2]))
-            threshold_slider.valueChanged.connect(
-                lambda v: update_value("Threshold", v, max_threshold, params["Threshold"][2]))
-            preview_timer.timeout.connect(do_preview)
-            self.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)
-
-        radius_slider = None
-        amount_slider = None
-        threshold_slider = None
-        self.run_filter_with_preview(unsharp_mask, get_params, setup_ui, 'Unsharp Mask')
-
-    def white_balance(self, init_val=False):
-        max_range = 255
-        if init_val is False:
-            init_val = (128, 128, 128)
-        initial_val = {k: v for k, v in zip(["R", "G", "B"], init_val)}
-        cursor_style = self.image_viewer.cursor_style
-        self.image_viewer.set_cursor_style('outline')
-        if self.image_viewer.brush_cursor:
-            self.image_viewer.brush_cursor.hide()
-        self.brush_preview.hide()
-
-        def get_params():
-            return tuple(sliders[n].value() for n in ("R", "G", "B"))
-
-        def setup_ui(dlg, layout, do_preview, restore_original):
-            nonlocal sliders, value_labels, color_preview, preview_timer
-            self.wb_dialog = dlg
-            dlg.setWindowModality(Qt.ApplicationModal)
-            dlg.setWindowFlags(dlg.windowFlags() | Qt.WindowStaysOnTopHint)
-            dlg.setFocusPolicy(Qt.StrongFocus)
-            dlg.setWindowTitle("White Balance")
-            dlg.setMinimumWidth(600)
-            row_layout = QHBoxLayout()
-            color_preview = QFrame()
-            color_preview.setFixedHeight(80)
-            color_preview.setFixedWidth(80)
-            color_preview.setStyleSheet("background-color: rgb(128,128,128);")
-            row_layout.addWidget(color_preview)
-            sliders_layout = QVBoxLayout()
-            sliders = {}
-            value_labels = {}
-            for name in ("R", "G", "B"):
-                row = QHBoxLayout()
-                label = QLabel(f"{name}:")
-                row.addWidget(label)
-                slider = QSlider(Qt.Horizontal)
-                slider.setRange(0, max_range)
-                init_val = initial_val[name]
-                slider.setValue(init_val)
-                row.addWidget(slider)
-                val_label = QLabel(str(init_val))
-                row.addWidget(val_label)
-                sliders_layout.addLayout(row)
-                sliders[name] = slider
-                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)
-            preview_timer = QTimer()
-            preview_timer.setSingleShot(True)
-            preview_timer.setInterval(200)
-
-            def update_preview_color():
-                rgb = tuple(sliders[n].value() for n in ("R", "G", "B"))
-                color_preview.setStyleSheet(f"background-color: rgb{rgb};")
-
-            def schedule_preview():
-                if preview_check.isChecked():
-                    preview_timer.start()
-
-            def on_slider_change():
-                for name in ("R", "G", "B"):
-                    value_labels[name].setText(str(sliders[name].value()))
-                update_preview_color()
-                schedule_preview()
-
-            for slider in sliders.values():
-                slider.valueChanged.connect(on_slider_change)
-
-            preview_timer.timeout.connect(do_preview)
-            self.connect_preview_toggle(preview_check, do_preview, restore_original)
-
-            def start_color_pick():
-                restore_original()
-                dlg.hide()
-                QApplication.setOverrideCursor(QCursor(Qt.CrossCursor))
-                self.image_viewer.setCursor(Qt.CrossCursor)
-                self._original_mouse_press = self.image_viewer.mousePressEvent
-                self.image_viewer.mousePressEvent = pick_color_from_click
-
-            def pick_color_from_click(event):
-                if event.button() == Qt.LeftButton:
-                    pos = event.pos()
-                    bgr = self.get_pixel_color_at(pos, radius=int(self.brush.size))
-                    rgb = (bgr[2], bgr[1], bgr[0])
-                    self.white_balance(rgb)
-
-            def reset_rgb():
-                for name, slider in sliders.items():
-                    slider.setValue(initial_val[name])
-
-            pick_button.clicked.connect(start_color_pick)
-            button_box.accepted.connect(dlg.accept)
-            button_box.rejected.connect(dlg.reject)
-            button_box.button(QDialogButtonBox.Reset).clicked.connect(reset_rgb)
-
-            def on_finished():
-                self.image_viewer.set_cursor_style(cursor_style)
-                self.image_viewer.brush_cursor.show()
-                self.brush_preview.show()
-                if hasattr(self, "_original_mouse_press"):
-                    QApplication.restoreOverrideCursor()
-                    self.image_viewer.unsetCursor()
-                    self.image_viewer.mousePressEvent = self._original_mouse_press
-                    delattr(self, "_original_mouse_press")
-                self.wb_dialog = None
-
-            dlg.finished.connect(on_finished)
-            QTimer.singleShot(0, do_preview)
-
-        sliders = {}
-        value_labels = {}
-        color_preview = None
-        preview_timer = None
-        self.run_filter_with_preview(lambda img, r, g, b: white_balance_from_rgb(img, (r, g, b)),
-                                     get_params, setup_ui, 'White Balance')
-
     def get_pixel_color_at(self, pos, radius=None):
-        scene_pos = self.image_viewer.mapToScene(pos)
-        item_pos = self.image_viewer.pixmap_item.mapFromScene(scene_pos)
+        item_pos = self.image_viewer.position_on_image(pos)
         x = int(item_pos.x())
         y = int(item_pos.y())
-        if (0 <= x < self.layer_collection.master_layer.shape[1]) and (0 <= y < self.layer_collection.master_layer.shape[0]):
+        master_layer = self.master_layer()
+        if (0 <= x < self.master_layer().shape[1]) and \
+           (0 <= y < self.master_layer().shape[0]):
             if radius is None:
                 radius = int(self.brush.size)
             if radius > 0:
                 y_indices, x_indices = np.ogrid[-radius:radius + 1, -radius:radius + 1]
                 mask = x_indices**2 + y_indices**2 <= radius**2
                 x0 = max(0, x - radius)
-                x1 = min(self.layer_collection.master_layer.shape[1], x + radius + 1)
+                x1 = min(master_layer.shape[1], x + radius + 1)
                 y0 = max(0, y - radius)
-                y1 = min(self.layer_collection.master_layer.shape[0], y + radius + 1)
+                y1 = min(master_layer.shape[0], y + radius + 1)
                 mask = mask[radius - (y - y0): radius + (y1 - y), radius - (x - x0): radius + (x1 - x)]
-                region = self.layer_collection.master_layer[y0:y1, x0:x1]
+                region = master_layer[y0:y1, x0:x1]
                 if region.size == 0:
-                    pixel = self.layer_collection.master_layer[y, x]
+                    pixel = master_layer[y, x]
                 else:
                     if region.ndim == 3:
                         pixel = [region[:, :, c][mask].mean() for c in range(region.shape[2])]
                     else:
                         pixel = region[mask].mean()
             else:
-                pixel = self.layer_collection.master_layer[y, x]
+                pixel = self.master_layer()[y, x]
             if np.isscalar(pixel):
                 pixel = [pixel, pixel, pixel]
             pixel = [np.float32(x) for x in pixel]
-            if self.layer_collection.master_layer.dtype == np.uint16:
+            if master_layer.dtype == np.uint16:
                 pixel = [x / 256.0 for x in pixel]
             return tuple(int(v) for v in pixel)
-        else:
-            return (0, 0, 0)
+        return (0, 0, 0)