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

shinestacker/retouch/image_filters.py

@@ -1,463 +1,67 @@
 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)
 
     def denoise(self):
-        max_range = 500.0
-        max_value = 5.00
-        initial_value = 2.5
-        self.master_layer_copy = self.master_layer.copy()
-        dlg = QDialog(self)
-        dlg.setWindowTitle("Denoise")
-        dlg.setMinimumWidth(600)
-        layout = QVBoxLayout(dlg)
-        slider_layout = QHBoxLayout()
-        slider = QSlider(Qt.Horizontal)
-        slider.setRange(0, max_range)
-        slider.setValue(initial_value / max_value * max_range)
-        slider_layout.addWidget(slider)
-        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)
-        last_preview_strength = None
-        preview_timer = QTimer()
-        preview_timer.setSingleShot(True)
-        preview_timer.setInterval(200)
-        active_worker = None
-        last_request_id = 0
-
-        class PreviewWorker(QThread):
-            finished = Signal(np.ndarray, int)
-
-            def __init__(self, image, strength, request_id):
-                super().__init__()
-                self.image = image
-                self.strength = strength
-                self.request_id = request_id
-
-            def run(self):
-                result = denoise(self.image, self.strength)
-                self.finished.emit(result, self.request_id)
-
-        def slider_changed(value):
-            float_value = max_value * value / max_range
-            value_label.setText(f"{float_value:.2f}")
-            if preview_check.isChecked():
-                nonlocal last_preview_strength
-                last_preview_strength = float_value
-                preview_timer.start()
-
-        def do_preview():
-            nonlocal active_worker, last_request_id
-            if last_preview_strength is None:
-                return
-            if active_worker and active_worker.isRunning():
-                active_worker.quit()
-                active_worker.wait()
-            last_request_id += 1
-            current_request_id = last_request_id
-            active_worker = PreviewWorker(
-                self.master_layer_copy.copy(),
-                last_preview_strength,
-                current_request_id
-            )
-            active_worker.finished.connect(
-                lambda img, rid: set_preview(img, rid, current_request_id)
-            )
-            active_worker.start()
-
-        def set_preview(img, request_id, expected_id):
-            if request_id != expected_id:
-                return
-            self.master_layer = img
-            self.display_master_layer()
-            dlg.activateWindow()
-            slider.setFocus()
-
-        def on_preview_toggled(checked):
-            nonlocal last_preview_strength
-            if checked:
-                last_preview_strength = max_value * slider.value() / max_range
-                do_preview()
-            else:
-                self.master_layer = self.master_layer_copy.copy()
-                self.display_master_layer()
-                dlg.activateWindow()
-                slider.setFocus()
-                button_box.setFocus()
-
-        slider.valueChanged.connect(slider_changed)
-        preview_timer.timeout.connect(do_preview)
-        preview_check.stateChanged.connect(on_preview_toggled)
-        button_box.accepted.connect(dlg.accept)
-        button_box.rejected.connect(dlg.reject)
-
-        def run_initial_preview():
-            slider_changed(slider.value())
-
-        QTimer.singleShot(0, run_initial_preview)
-        slider.setFocus()
-        if dlg.exec_() == QDialog.Accepted:
-            strength = max_value * float(slider.value()) / max_range
-            h, w = self.master_layer.shape[:2]
-            self.undo_manager.extend_undo_area(0, 0, w, h)
-            self.undo_manager.save_undo_state(self.master_layer_copy, 'Denoise')
-            self.master_layer = denoise(self.master_layer_copy, strength)
-            self.master_layer_copy = self.master_layer.copy()
-            self.display_master_layer()
-            self.update_master_thumbnail()
-            self.mark_as_modified()
-        else:
-            self.master_layer = self.master_layer_copy.copy()
-            self.display_master_layer()
+        self.filter_manager.apply("denoise")
 
     def unsharp_mask(self):
-        max_range = 500.0
-        max_radius = 4.0
-        max_amount = 3.0
-        max_threshold = 100.0
-        initial_radius = 1.0
-        initial_amount = 0.5
-        initial_threshold = 0.0
-        self.master_layer_copy = self.master_layer.copy()
-        dlg = QDialog(self)
-        dlg.setWindowTitle("Unsharp Mask")
-        dlg.setMinimumWidth(600)
-        layout = QVBoxLayout(dlg)
-        params = {
-            "Radius": (max_radius, initial_radius, "{:.2f}"),
-            "Amount": (max_amount, initial_amount, "{:.2%}"),
-            "Threshold": (max_threshold, initial_threshold, "{:.2f}")
-        }
-        sliders = {}
-        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(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)
-            sliders[name] = 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)
-        last_preview_params = None
-        preview_timer = QTimer()
-        preview_timer.setSingleShot(True)
-        preview_timer.setInterval(200)
-        active_worker = None
-        last_request_id = 0
-
-        class UnsharpWorker(QThread):
-            finished = Signal(np.ndarray, int)
-
-            def __init__(self, image, radius, amount, threshold, request_id):
-                super().__init__()
-                self.image = image
-                self.radius = radius
-                self.amount = amount
-                self.threshold = threshold
-                self.request_id = request_id
+        self.filter_manager.apply("unsharp_mask")
 
-            def run(self):
-                result = unsharp_mask(self.image, max(0.01, self.radius), self.amount, self.threshold)
-                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 update_param_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():
-                nonlocal last_preview_params
-                last_preview_params = (
-                    max_radius * sliders["Radius"].value() / max_range,
-                    max_amount * sliders["Amount"].value() / max_range,
-                    max_threshold * sliders["Threshold"].value() / max_range
-                )
-                preview_timer.start()
-        sliders["Radius"].valueChanged.connect(
-            lambda v: update_param_value("Radius", v, params["Radius"][0], params["Radius"][2]))
-        sliders["Amount"].valueChanged.connect(
-            lambda v: update_param_value("Amount", v, params["Amount"][0], params["Amount"][2]))
-        sliders["Threshold"].valueChanged.connect(
-            lambda v: update_param_value("Threshold", v, params["Threshold"][0], params["Threshold"][2]))
-
-        def do_preview():
-            nonlocal active_worker, last_request_id
-            if last_preview_params is None:
-                return
-            if active_worker and active_worker.isRunning():
-                active_worker.quit()
-                active_worker.wait()
-            last_request_id += 1
-            current_request_id = last_request_id
-            radius, amount, threshold = last_preview_params
-            active_worker = UnsharpWorker(
-                self.master_layer_copy.copy(),
-                radius,
-                amount,
-                threshold,
-                current_request_id
-            )
-            active_worker.finished.connect(lambda img, rid: set_preview(img, rid, current_request_id))
-            active_worker.start()
-
-        def set_preview(img, request_id, expected_id):
-            if request_id != expected_id:
-                return
-            self.master_layer = img
-            self.display_master_layer()
-            dlg.activateWindow()
-            sliders["Radius"].setFocus()
-
-        def on_preview_toggled(checked):
-            nonlocal last_preview_params
+    def connect_preview_toggle(self, preview_check, do_preview, restore_original):
+        def on_toggled(checked):
             if checked:
-                last_preview_params = (
-                    max_radius * sliders["Radius"].value() / max_range,
-                    max_amount * sliders["Amount"].value() / max_range,
-                    max_threshold * sliders["Threshold"].value() / max_range
-                )
                 do_preview()
             else:
-                self.master_layer = self.master_layer_copy.copy()
-                self.display_master_layer()
-                dlg.activateWindow()
-                sliders["Radius"].setFocus()
-
-        preview_timer.timeout.connect(do_preview)
-        preview_check.stateChanged.connect(on_preview_toggled)
-        button_box.accepted.connect(dlg.accept)
-        button_box.rejected.connect(dlg.reject)
-
-        def run_initial_preview():
-            nonlocal last_preview_params
-            last_preview_params = (
-                initial_radius,
-                initial_amount,
-                initial_threshold
-            )
-            do_preview()
-
-        QTimer.singleShot(0, run_initial_preview)
-        sliders["Radius"].setFocus()
-        if dlg.exec_() == QDialog.Accepted:
-            radius = max_radius * sliders["Radius"].value() / max_range
-            amount = max_amount * sliders["Amount"].value() / max_range
-            threshold = max_threshold * sliders["Threshold"].value() / max_range
-            h, w = self.master_layer.shape[:2]
-            self.undo_manager.extend_undo_area(0, 0, w, h)
-            self.undo_manager.save_undo_state(self.master_layer_copy, 'Unsharp Mask')
-            self.master_layer = unsharp_mask(self.master_layer_copy, max(0.01, radius), amount, threshold)
-            self.master_layer_copy = self.master_layer.copy()
-            self.display_master_layer()
-            self.update_master_thumbnail()
-            self.mark_as_modified()
-        else:
-            self.master_layer = self.master_layer_copy.copy()
-            self.display_master_layer()
-
-    def white_balance(self):
-        if hasattr(self, 'wb_dialog') and self.wb_dialog:
-            self.wb_dialog.activateWindow()
-            self.wb_dialog.raise_()
-            return
-        max_range = 255
-        initial_val = 128
-        initial_rgb = (initial_val, initial_val, initial_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.master_layer_copy = self.master_layer.copy()
-        self.brush_preview.hide()
-        self.wb_dialog = dlg = QDialog(self)
-        dlg.setWindowTitle("White Balance")
-        dlg.setMinimumWidth(600)
-        layout = QVBoxLayout(dlg)
-        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 = {}
-        rgb_layouts = {}
-        for name, init_val in zip(("R", "G", "B"), initial_rgb):
-            row = QHBoxLayout()
-            label = QLabel(f"{name}:")
-            row.addWidget(label)
-            slider = QSlider(Qt.Horizontal)
-            slider.setRange(0, max_range)
-            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
-            rgb_layouts[name] = row
-        row_layout.addLayout(sliders_layout)
-        layout.addLayout(row_layout)
-        pick_button = QPushButton("Pick Color")
-        layout.addWidget(pick_button)
-
-        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():
-            nonlocal last_preview_rgb
-            rgb = tuple(sliders[n].value() for n in ("R", "G", "B"))
-            for n in ("R", "G", "B"):
-                value_labels[n].setText(str(sliders[n].value()))
-            update_preview_color()
-            if preview_check.isChecked() and rgb != last_preview_rgb:
-                last_preview_rgb = rgb
-                preview_timer.start(100)
-
-        def apply_preview():
-            rgb = tuple(sliders[n].value() for n in ("R", "G", "B"))
-            processed = white_balance_from_rgb(self.master_layer_copy, rgb)
-            self.master_layer = processed
-            self.display_master_layer()
-            dlg.activateWindow()
-
-        def on_preview_toggled(checked):
-            nonlocal last_preview_rgb
-            if checked:
-                last_preview_rgb = tuple(sliders[n].value() for n in ("R", "G", "B"))
-                preview_timer.start(100)
-            else:
-                self.master_layer = self.master_layer_copy.copy()
-                self.display_master_layer()
-                dlg.activateWindow()
-
-        preview_check = QCheckBox("Preview")
-        preview_check.setChecked(True)
-        preview_check.stateChanged.connect(on_preview_toggled)
-        layout.addWidget(preview_check)
-        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Reset | QDialogButtonBox.Cancel)
-        layout.addWidget(button_box)
-        last_preview_rgb = None
-        preview_timer = QTimer()
-        preview_timer.setSingleShot(True)
-        preview_timer.timeout.connect(apply_preview)
-        for slider in sliders.values():
-            slider.valueChanged.connect(schedule_preview)
-
-        def start_color_pick():
-            dlg.hide()
-            QApplication.setOverrideCursor(QCursor(Qt.CrossCursor))
-            self.image_viewer.setCursor(Qt.CrossCursor)
-            self.master_layer = self.master_layer_copy
-            self.display_master_layer()
-            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)
-                rgb = (bgr[2], bgr[1], bgr[0])
-                for name, val in zip(("R", "G", "B"), rgb):
-                    sliders[name].setValue(val)
-                QApplication.restoreOverrideCursor()
-                self.image_viewer.unsetCursor()
-                if hasattr(self, "_original_mouse_press"):
-                    self.image_viewer.mousePressEvent = self._original_mouse_press
-                dlg.show()
-                dlg.activateWindow()
-                dlg.raise_()
-
-        pick_button.clicked.connect(start_color_pick)
-        button_box.accepted.connect(dlg.accept)
-
-        def cancel_changes():
-            self.master_layer = self.master_layer_copy
-            self.display_master_layer()
-            dlg.reject()
-
-        def reset_rgb():
-            for k, s in sliders.items():
-                s.setValue(initial_val)
-
-        button_box.rejected.connect(cancel_changes)
-        button_box.button(QDialogButtonBox.Reset).clicked.connect(reset_rgb)
-
-        def finish_white_balance(result):
-            if result == QDialog.Accepted:
-                apply_preview()
-                h, w = self.master_layer.shape[:2]
-                self.undo_manager.extend_undo_area(0, 0, w, h)
-                self.undo_manager.save_undo_state(self.master_layer_copy, 'White Balance')
-                self.master_layer_copy = self.master_layer.copy()
-                self.display_master_layer()
-                self.update_master_thumbnail()
-                self.mark_as_modified()
-            self.image_viewer.set_cursor_style(cursor_style)
-            self.wb_dialog = None
-
-        dlg.finished.connect(finish_white_balance)
-        dlg.show()
+                restore_original()
+        preview_check.toggled.connect(on_toggled)
 
     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.master_layer.shape[1]) and (0 <= y < self.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.master_layer.shape[1], x + radius + 1)
+                x1 = min(master_layer.shape[1], x + radius + 1)
                 y0 = max(0, y - radius)
-                y1 = min(self.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.master_layer[y0:y1, x0:x1]
+                region = master_layer[y0:y1, x0:x1]
                 if region.size == 0:
-                    pixel = self.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.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.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)

shinestacker/retouch/image_viewer.py

@@ -1,34 +1,23 @@
 import math
 from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem
-from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QCursor, QShortcut, QKeySequence, QRadialGradient
-from PySide6.QtCore import Qt, QRectF, QTime, QPoint, Signal
+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
-
-
-def create_brush_gradient(center_x, center_y, radius, hardness, inner_color=None, outer_color=None, opacity=100):
-    gradient = QRadialGradient(center_x, center_y, float(radius))
-    inner = inner_color if inner_color is not None else QColor(*gui_constants.BRUSH_COLORS['inner'])
-    outer = outer_color if outer_color is not None else QColor(*gui_constants.BRUSH_COLORS['gradient_end'])
-    inner_with_opacity = QColor(inner)
-    inner_with_opacity.setAlpha(int(float(inner.alpha()) * float(opacity) / 100.0))
-    if hardness < 100:
-        hardness_normalized = float(hardness) / 100.0
-        gradient.setColorAt(0.0, inner_with_opacity)
-        gradient.setColorAt(hardness_normalized, inner_with_opacity)
-        gradient.setColorAt(1.0, outer)
-    else:
-        gradient.setColorAt(0.0, inner_with_opacity)
-        gradient.setColorAt(1.0, inner_with_opacity)
-    return gradient
+from .brush_gradient import create_brush_gradient
 
 
 class ImageViewer(QGraphicsView):
     temp_view_requested = Signal(bool)
+    brush_operation_started = Signal(QPoint)
+    brush_operation_continued = Signal(QPoint)
+    brush_operation_ended = Signal()
+    brush_size_change_requested = Signal(int)  # +1 or -1
 
-    def __init__(self, parent=None):
+    def __init__(self, layer_collection, parent=None):
         super().__init__(parent)
-        self.image_editor = None
+        self.display_manager = None
+        self.layer_collection = layer_collection
         self.brush = None
         self.cursor_style = gui_constants.DEFAULT_CURSOR_STYLE
         self.scene = QGraphicsScene(self)
@@ -55,8 +44,10 @@ class ImageViewer(QGraphicsView):
         self.dragging = False
         self.last_update_time = QTime.currentTime()
         self.brush_preview = BrushPreviewItem()
+        self.layer_collection.add_to(self.brush_preview)
         self.scene.addItem(self.brush_preview)
         self.empty = True
+        self.allow_cursor_preview = True
 
     def set_image(self, qimage):
         pixmap = QPixmap.fromImage(qimage)
@@ -74,6 +65,7 @@ class ImageViewer(QGraphicsView):
         self.empty = False
         self.setFocus()
         self.activateWindow()
+        self.brush_preview.brush = self.brush
 
     def clear_image(self):
         self.scene.clear()
@@ -123,7 +115,7 @@ class ImageViewer(QGraphicsView):
     def mousePressEvent(self, event):
         if self.empty:
             return
-        if event.button() == Qt.LeftButton and self.image_editor.master_layer is not None:
+        if event.button() == Qt.LeftButton and self.layer_collection.has_master_layer():
             if self.space_pressed:
                 self.scrolling = True
                 self.last_mouse_pos = event.position()
@@ -132,7 +124,7 @@ class ImageViewer(QGraphicsView):
                     self.brush_cursor.hide()
             else:
                 self.last_brush_pos = event.position()
-                self.image_editor.begin_copy_brush_area(event.position().toPoint())
+                self.brush_operation_started.emit(event.position().toPoint())
                 self.dragging = True
                 if self.brush_cursor:
                     self.brush_cursor.show()
@@ -159,7 +151,7 @@ class ImageViewer(QGraphicsView):
                     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.image_editor.continue_copy_brush_area(pos)
+                        self.brush_operation_continued.emit(pos)
                     self.last_brush_pos = position
                 self.last_update_time = current_time
         if self.scrolling and event.buttons() & Qt.LeftButton:
@@ -191,17 +183,14 @@ class ImageViewer(QGraphicsView):
                 self.last_mouse_pos = None
             elif hasattr(self, 'dragging') and self.dragging:
                 self.dragging = False
-                self.image_editor.end_copy_brush_area()
+                self.brush_operation_ended.emit()
         super().mouseReleaseEvent(event)
 
     def wheelEvent(self, event):
         if self.empty:
             return
         if self.control_pressed:
-            if event.angleDelta().y() > 0:
-                self.image_editor.decrease_brush_size()
-            else:
-                self.image_editor.increase_brush_size()
+            self.brush_size_change_requested.emit(1 if event.angleDelta().y() > 0 else -1)
         else:
             zoom_in_factor = 1.10
             zoom_out_factor = 1 / zoom_in_factor
@@ -241,11 +230,17 @@ class ImageViewer(QGraphicsView):
         center_y = scene_pos.y()
         radius = size / 2
         self.brush_cursor.setRect(center_x - radius, center_y - radius, size, size)
-        allow_cursor_preview = self.image_editor.allow_cursor_preview()
+        allow_cursor_preview = self.display_manager.allow_cursor_preview()
         if self.cursor_style == 'preview' and allow_cursor_preview:
             self._setup_outline_style()
             self.brush_cursor.hide()
-            self.brush_preview.update(self.image_editor, QCursor.pos(), int(size))
+            pos = QCursor.pos()
+            if isinstance(pos, QPointF):
+                scene_pos = pos
+            else:
+                cursor_pos = self.mapFromGlobal(pos)
+                scene_pos = self.mapToScene(cursor_pos)
+            self.brush_preview.update(scene_pos, int(size))
         else:
             self.brush_preview.hide()
             if self.cursor_style == 'outline' or not allow_cursor_preview:
@@ -354,3 +349,8 @@ class ImageViewer(QGraphicsView):
         self.cursor_style = style
         if self.brush_cursor:
             self.update_brush_cursor()
+
+    def position_on_image(self, pos):
+        scene_pos = self.mapToScene(pos)
+        item_pos = self.pixmap_item.mapFromScene(scene_pos)
+        return item_pos