shinestacker 1.5.1__py3-none-any.whl → 1.5.2__py3-none-any.whl

shinestacker/retouch/overlaid_view.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E0611, E1101, R0904, R0912, R0914, R0902
+# pylint: disable=C0114, C0115, C0116, E0611, E1101, R0904, R0912, R0914, R0902, E0202
 from PySide6.QtCore import Qt, QPointF, QEvent, QRectF
 from .. config.gui_constants import gui_constants
 from .view_strategy import ViewStrategy, ImageGraphicsViewBase, ViewSignals
@@ -107,6 +107,16 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             if self.brush_cursor:
                 self.brush_cursor.show()
         super().enterEvent(event)
+
+    def get_mouse_callbacks(self):
+        return self.mousePressEvent
+
+    def set_mouse_callbacks(self, callbacks):
+        self.mousePressEvent = callbacks
+
+    def show(self):
+        self.show_master()
+        super().show()
     # pylint: enable=C0103
 
     def event(self, event):
@@ -147,7 +157,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
     def show_master(self):
         self.pixmap_item_master.setVisible(True)
         self.pixmap_item_current.setVisible(False)
-        self.brush_preview.show()
+        self.show_brush_preview()
         if self.brush_cursor:
             self.scene.removeItem(self.brush_cursor)
             self.brush_cursor = self.create_circle(self.scene)
@@ -156,7 +166,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
     def show_current(self):
         self.pixmap_item_master.setVisible(False)
         self.pixmap_item_current.setVisible(True)
-        self.brush_preview.hide()
+        self.hide_brush_preview()
         if self.brush_cursor:
             self.scene.removeItem(self.brush_cursor)
             self.brush_cursor = self.create_alt_circle(self.scene)
@@ -211,8 +221,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
             handled = True
         if handled:
             event.accept()
-            return True
-        return False
+        return handled
 
     def handle_pan_gesture(self, pan_gesture):
         if pan_gesture.state() == Qt.GestureStarted:
@@ -221,7 +230,7 @@ class OverlaidView(ViewStrategy, ImageGraphicsViewBase, ViewSignals):
         elif pan_gesture.state() == Qt.GestureUpdated:
             delta = pan_gesture.delta() - self.last_scroll_pos
             self.last_scroll_pos = pan_gesture.delta()
-            scaled_delta = delta * (1.0 / self.get_current_scale())
+            scaled_delta = delta / self.get_current_scale()
             self.scroll_view(self, int(scaled_delta.x()), int(scaled_delta.y()))
         elif pan_gesture.state() == Qt.GestureFinished:
             self.gesture_active = False

shinestacker/retouch/sidebyside_view.py

@@ -146,6 +146,14 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             self.pixmap_item_current: self.current_view
         }
 
+    def hide_brush_cursor(self):
+        super().hide_brush_cursor()
+        self.current_brush_cursor.hide()
+
+    def show_brush_cursor(self):
+        super().show_brush_cursor()
+        self.current_brush_cursor.show()
+
     # pylint: disable=C0103
     def focusInEvent(self, event):
         super().focusInEvent(event)
@@ -193,8 +201,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         else:
             if self.brush_cursor is None or self.current_brush_cursor is None:
                 self.setup_brush_cursor()
-            self.brush_cursor.hide()
-            self.current_brush_cursor.hide()
+            self.hide_brush_cursor()
             self.master_view.setCursor(Qt.ArrowCursor)
             self.current_view.setCursor(Qt.ArrowCursor)
         super().leaveEvent(event)
@@ -208,6 +215,16 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         super().keyReleaseEvent(event)
         if event.key() == Qt.Key_Space:
             self.update_brush_cursor()
+
+    def get_mouse_callbacks(self):
+        return self.master_view.mousePressEvent, self.current_view.mousePressEvent
+
+    def set_mouse_callbacks(self, callbacks):
+        if isinstance(callbacks, tuple):
+            self.master_view.mousePressEvent, self.current_view.mousePressEvent = callbacks
+        else:
+            self.master_view.mousePressEvent = callbacks
+            self.current_view.mousePressEvent = callbacks
     # pylint: enable=C0103
 
     # pylint: enable=R0801
@@ -272,8 +289,7 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
             cursor_style = Qt.OpenHandCursor if not self.scrolling else Qt.ClosedHandCursor
             self.master_view.setCursor(cursor_style)
             self.current_view.setCursor(cursor_style)
-            self.brush_cursor.hide()
-            self.current_brush_cursor.hide()
+            self.hide_brush_cursor()
             return
         self.master_view.setCursor(Qt.BlankCursor)
         self.current_view.setCursor(Qt.BlankCursor)
@@ -285,11 +301,11 @@ class DoubleViewBase(ViewStrategy, QWidget, ViewSignals):
         self.current_brush_cursor.hide()
         if master_has_mouse:
             if self.cursor_style == 'preview':
-                self.brush_preview.show()
+                self.show_brush_preview()
             super().update_brush_cursor()
             self.sync_current_cursor_with_master()
         elif current_has_mouse:
-            self.brush_preview.hide()
+            self.hide_brush_preview()
             scene_pos = self.current_view.mapToScene(mouse_pos_current)
             size = self.brush.size
             radius = size / 2

shinestacker/retouch/unsharp_mask_filter.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0902, R0914
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0902, R0914, R0913, R0917
 from PySide6.QtWidgets import QHBoxLayout, QLabel, QSlider, QDialogButtonBox
 from PySide6.QtCore import Qt, QTimer
 from .. algorithms.sharpen import unsharp_mask
@@ -6,8 +6,9 @@ from .base_filter import BaseFilter
 
 
 class UnsharpMaskFilter(BaseFilter):
-    def __init__(self, name, editor):
-        super().__init__(name, editor, preview_at_startup=True)
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager):
+        super().__init__(name, parent, image_viewer, layer_collection, undo_manager,
+                         preview_at_startup=True)
         self.max_range = 500.0
         self.max_radius = 4.0
         self.max_amount = 3.0
@@ -62,7 +63,7 @@ class UnsharpMaskFilter(BaseFilter):
         self.threshold_slider.valueChanged.connect(
             lambda v: update_value("Threshold", v, self.max_threshold, params["Threshold"][2]))
         self.preview_timer.timeout.connect(do_preview)
-        self.editor.connect_preview_toggle(self.preview_check, do_preview, restore_original)
+        self.connect_preview_toggle(self.preview_check, do_preview, restore_original)
         self.button_box.accepted.connect(dlg.accept)
         self.button_box.rejected.connect(dlg.reject)
         QTimer.singleShot(0, do_preview)

shinestacker/retouch/view_strategy.py

@@ -100,14 +100,11 @@ class ImageGraphicsViewBase(QGraphicsView):
 class ViewStrategy(LayerCollectionHandler):
     def __init__(self, layer_collection, status):
         LayerCollectionHandler.__init__(self, layer_collection)
-        self.display_manager = None
         self.status = status
         self.brush = None
         self.brush_cursor = None
-        self.display_manager = None
         self.brush_preview = BrushPreviewItem(layer_collection)
         self.cursor_style = gui_constants.DEFAULT_CURSOR_STYLE
-        self.allow_cursor_preview = True
         self.control_pressed = False
         self.space_pressed = False
         self.gesture_active = False
@@ -180,38 +177,32 @@ class ViewStrategy(LayerCollectionHandler):
     def arrange_images(self):
         pass
 
-    def update_master_display(self):
-        if not self.empty():
-            master_qimage = self.numpy_to_qimage(self.master_layer())
-            if master_qimage:
-                pixmap = QPixmap.fromImage(master_qimage)
-                self.get_master_pixmap().setPixmap(pixmap)
-                self.get_master_scene().setSceneRect(QRectF(pixmap.rect()))
-                self.get_master_view().horizontalScrollBar().setValue(self.status.h_scroll)
-                self.get_master_view().verticalScrollBar().setValue(self.status.v_scroll)
-                self.arrange_images()
+    @abstractmethod
+    def get_mouse_callbacks(self):
+        pass
 
-    def update_current_display(self):
-        if not self.empty() and self.number_of_layers() > 0:
-            current_qimage = self.numpy_to_qimage(self.current_layer())
-            if current_qimage:
-                pixmap = QPixmap.fromImage(current_qimage)
-                self.get_current_pixmap().setPixmap(pixmap)
-                self.get_current_scene().setSceneRect(QRectF(pixmap.rect()))
-                self.get_current_view().horizontalScrollBar().setValue(self.status.h_scroll)
-                self.get_current_view().verticalScrollBar().setValue(self.status.v_scroll)
-                self.arrange_images()
+    @abstractmethod
+    def set_mouse_callbacks(self, callbacks):
+        pass
 
-    def update_cursor_pen_width(self):
-        width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
-        if self.brush_cursor is not None:
-            pen = self.brush_cursor.pen()
-            pen.setWidthF(width)
-            self.brush_cursor.setPen(pen)
-        return width
+    def hide_brush_cursor(self):
+        if self.brush_cursor:
+            self.brush_cursor.hide()
+
+    def show_brush_cursor(self):
+        if self.brush_cursor:
+            self.brush_cursor.show()
+
+    def hide_brush_preview(self):
+        if self.brush_preview:
+            self.brush_preview.hide()
+
+    def show_brush_preview(self):
+        if self.brush_preview:
+            self.brush_preview.show()
 
-    def set_allow_cursor_preview(self, state):
-        self.allow_cursor_preview = state
+    def current_line_width(self):
+        return gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
 
     def zoom_factor(self):
         return self.status.zoom_factor
@@ -243,13 +234,9 @@ class ViewStrategy(LayerCollectionHandler):
     def set_preview_brush(self, brush):
         self.brush_preview.brush = brush
 
-    def set_display_manager(self, dm):
-        self.display_manager = dm
-
     def set_cursor_style(self, style):
         self.cursor_style = style
-        if self.brush_cursor:
-            self.update_brush_cursor()
+        self.update_brush_cursor()
 
     def get_cursor_style(self):
         return self.cursor_style
@@ -260,6 +247,42 @@ class ViewStrategy(LayerCollectionHandler):
     def handle_key_release_event(self, _event):
         return True
 
+    def update_view_display(self, layer, pixmap_item, scene, view):
+        if self.empty():
+            return
+        qimage = self.numpy_to_qimage(layer)
+        if qimage:
+            pixmap = QPixmap.fromImage(qimage)
+            pixmap_item.setPixmap(pixmap)
+            scene.setSceneRect(QRectF(pixmap.rect()))
+            view.horizontalScrollBar().setValue(self.status.h_scroll)
+            view.verticalScrollBar().setValue(self.status.v_scroll)
+            self.arrange_images()
+
+    def update_master_display(self):
+        self.update_view_display(
+            self.master_layer(),
+            self.get_master_pixmap(),
+            self.get_master_scene(),
+            self.get_master_view())
+
+    def update_current_display(self):
+        if self.number_of_layers() <= 0:
+            return
+        self.update_view_display(
+            self.current_layer(),
+            self.get_current_pixmap(),
+            self.get_current_view(),
+            self.get_current_view())
+
+    def update_cursor_pen_width(self):
+        width = self.current_line_width()
+        if self.brush_cursor is not None:
+            pen = self.brush_cursor.pen()
+            pen.setWidthF(width)
+            self.brush_cursor.setPen(pen)
+        return width
+
     def clear_image(self):
         for scene in self.get_scenes():
             scene.clear()
@@ -269,13 +292,7 @@ class ViewStrategy(LayerCollectionHandler):
         self.brush_preview = BrushPreviewItem(self.layer_collection)
         self.get_master_scene().addItem(self.brush_preview)
         self.setCursor(Qt.ArrowCursor)
-        if self.brush_cursor:
-            self.brush_cursor.hide()
-
-    def cleanup_brush_preview(self):
-        if self.brush_cursor:
-            self.brush_cursor.hide()
-        self.brush_preview.hide()
+        self.hide_brush_cursor()
 
     def set_master_image_np(self, img):
         self.set_master_image(self.numpy_to_qimage(img))
@@ -387,15 +404,15 @@ class ViewStrategy(LayerCollectionHandler):
     def setup_simple_brush_style(self, center_x, center_y, radius):
         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.current_line_width()))
         self.brush_cursor.setBrush(QBrush(gradient))
 
     def create_circle(self, scene, line_style=Qt.SolidLine):
         for item in scene.items():
             if isinstance(item, QGraphicsEllipseItem) and item != self.brush_preview:
                 scene.removeItem(item)
-        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
-        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), pen_width, line_style)
+        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
+                   self.current_line_width(), line_style)
         brush = Qt.NoBrush
         scene_center = scene.sceneRect().center()
         brush_cursor = scene.addEllipse(
@@ -409,8 +426,8 @@ class ViewStrategy(LayerCollectionHandler):
         for item in scene.items():
             if isinstance(item, BrushCursor) and item != self.brush_preview:
                 scene.removeItem(item)
-        pen_width = gui_constants.BRUSH_LINE_WIDTH / self.zoom_factor()
-        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), pen_width, line_style)
+        pen = QPen(QColor(*gui_constants.BRUSH_COLORS['pen']),
+                   self.current_line_width(), line_style)
         brush = Qt.NoBrush
         scene_center = scene.sceneRect().center()
         brush_cursor = BrushCursor(
@@ -434,16 +451,15 @@ class ViewStrategy(LayerCollectionHandler):
         master_view = self.get_master_view()
         mouse_pos = master_view.mapFromGlobal(QCursor.pos())
         if not master_view.rect().contains(mouse_pos):
-            self.brush_cursor.hide()
+            self.hide_brush_cursor()
             return
         scene_pos = master_view.mapToScene(mouse_pos)
         size = self.brush.size
         radius = size / 2
         self.brush_cursor.setRect(scene_pos.x() - radius, scene_pos.y() - radius, size, size)
-        allow_cursor_preview = self.display_manager.allow_cursor_preview()
         if self.cursor_style == 'preview':
-            if allow_cursor_preview:
-                self.brush_cursor.hide()
+            if self.brush_preview.isVisible():
+                self.hide_brush_cursor()
                 pos = QCursor.pos()
                 if isinstance(pos, QPointF):
                     scene_pos = pos
@@ -452,11 +468,10 @@ class ViewStrategy(LayerCollectionHandler):
                     scene_pos = master_view.mapToScene(cursor_pos)
                 self.brush_preview.update(scene_pos, int(size))
         else:
-            self.brush_preview.hide()
+            self.hide_brush_preview()
             if self.cursor_style != 'outline':
                 self.setup_simple_brush_style(scene_pos.x(), scene_pos.y(), radius)
-        if not self.brush_cursor.isVisible():
-            self.brush_cursor.show()
+        self.show_brush_cursor()
 
     def position_on_image(self, pos):
         master_view = self.get_master_view()
@@ -497,8 +512,7 @@ class ViewStrategy(LayerCollectionHandler):
         if event.key() == Qt.Key_Space and not self.scrolling:
             self.space_pressed = True
             self.get_master_view().setCursor(Qt.OpenHandCursor)
-            if self.brush_cursor:
-                self.brush_cursor.hide()
+            self.hide_brush_cursor()
         if self.handle_key_press_event(event):
             if event.key() == Qt.Key_Control and not self.scrolling:
                 self.control_pressed = True
@@ -511,8 +525,7 @@ class ViewStrategy(LayerCollectionHandler):
             self.space_pressed = False
             if not self.scrolling:
                 self.get_master_view().setCursor(Qt.BlankCursor)
-                if self.brush_cursor:
-                    self.brush_cursor.show()
+                self.show_brush_cursor()
         if self.handle_key_release_event(event):
             if event.key() == Qt.Key_Control:
                 self.control_pressed = False
@@ -523,8 +536,7 @@ class ViewStrategy(LayerCollectionHandler):
             self.setCursor(Qt.ArrowCursor)
         else:
             self.get_master_view().setCursor(Qt.ArrowCursor)
-            if self.brush_cursor:
-                self.brush_cursor.hide()
+            self.hide_brush_cursor()
         super().leaveEvent(event)
     # pylint: enable=C0103
 
@@ -569,8 +581,7 @@ class ViewStrategy(LayerCollectionHandler):
             master_view = self.get_master_view()
             if self.space_pressed:
                 master_view.setCursor(Qt.ClosedHandCursor)
-                if self.brush_cursor:
-                    self.brush_cursor.hide()
+                self.hide_brush_cursor()
             delta = position - self.last_mouse_pos
             self.last_mouse_pos = position
             self.scroll_view(master_view, delta.x(), delta.y())
@@ -587,8 +598,7 @@ class ViewStrategy(LayerCollectionHandler):
                 self.last_brush_pos = event.position()
                 self.brush_operation_started.emit(event.position().toPoint())
                 self.dragging = True
-            if self.brush_cursor:
-                self.brush_cursor.show()
+            self.show_brush_cursor()
 
     def mouse_release_event(self, event):
         if self.empty():
@@ -596,12 +606,10 @@ class ViewStrategy(LayerCollectionHandler):
         master_view = self.get_master_view()
         if self.space_pressed:
             master_view.setCursor(Qt.OpenHandCursor)
-            if self.brush_cursor:
-                self.brush_cursor.hide()
+            self.hide_brush_cursor()
         else:
             master_view.setCursor(Qt.BlankCursor)
-            if self.brush_cursor:
-                self.brush_cursor.show()
+            self.show_brush_cursor()
         if event.button() == Qt.LeftButton:
             if self.scrolling:
                 self.scrolling = False

shinestacker/retouch/vignetting_filter.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0902
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0902, R0913, R0917
 from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QSpinBox, QCheckBox, QLabel, QHBoxLayout, QSlider, QComboBox
 from .. config.constants import constants
@@ -7,8 +7,9 @@ from .base_filter import OneSliderBaseFilter
 
 
 class VignettingFilter(OneSliderBaseFilter):
-    def __init__(self, name, editor):
-        super().__init__(name, editor, 1.0, 0.90, "Vignetting correction",
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager):
+        super().__init__(name, parent, image_viewer, layer_collection, undo_manager,
+                         1.0, 0.90, "Vignetting correction",
                          allow_partial_preview=False, preview_at_startup=False)
         self.subsample_box = None
         self.fast_subsampling_check = None

shinestacker/retouch/white_balance_filter.py

@@ -1,4 +1,5 @@
 # pylint: disable=C0114, C0115, C0116, E0611, W0221, R0913, R0914, R0917, R0902
+import numpy as np
 from PySide6.QtWidgets import (QHBoxLayout, QPushButton, QFrame, QVBoxLayout, QLabel, QDialog,
                                QApplication, QSlider, QDialogButtonBox, QLineEdit)
 from PySide6.QtCore import Qt, QTimer
@@ -8,8 +9,9 @@ from .base_filter import BaseFilter
 
 
 class WhiteBalanceFilter(BaseFilter):
-    def __init__(self, name, editor):
-        super().__init__(name, editor, preview_at_startup=True)
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager):
+        super().__init__(name, parent, image_viewer, layer_collection, undo_manager,
+                         preview_at_startup=True)
         self.max_range = 255
         self.initial_val = (128, 128, 128)
         self.sliders = {}
@@ -18,6 +20,7 @@ class WhiteBalanceFilter(BaseFilter):
         self.color_preview = None
         self.preview_timer = None
         self.original_mouse_press = None
+        self.original_cursor_style = None
 
     def setup_ui(self, dlg, layout, do_preview, restore_original, init_val=None):
         if init_val:
@@ -65,7 +68,7 @@ class WhiteBalanceFilter(BaseFilter):
         for slider in self.sliders.values():
             slider.valueChanged.connect(self.on_slider_change)
         self.preview_timer.timeout.connect(do_preview)
-        self.editor.connect_preview_toggle(self.preview_check, do_preview, restore_original)
+        self.connect_preview_toggle(self.preview_check, do_preview, restore_original)
         pick_button.clicked.connect(self.start_color_pick)
         self.button_box.accepted.connect(dlg.accept)
         self.button_box.rejected.connect(dlg.reject)
@@ -107,27 +110,33 @@ class WhiteBalanceFilter(BaseFilter):
                 widget.hide()
                 widget.reject()
                 break
-        self.editor.image_viewer.set_cursor_style('outline')
-        if self.editor.image_viewer.brush_cursor:
-            self.editor.image_viewer.brush_cursor.hide()
-        self.editor.brush_preview.hide()
+        self.original_cursor_style = self.image_viewer.get_cursor_style()
+        self.image_viewer.set_cursor_style('outline')
+        self.image_viewer.hide_brush_cursor()
+        self.image_viewer.hide_brush_preview()
         QApplication.setOverrideCursor(QCursor(Qt.CrossCursor))
-        self.editor.image_viewer.setCursor(Qt.CrossCursor)
-        self.original_mouse_press = self.editor.image_viewer.mousePressEvent
-        self.editor.image_viewer.mousePressEvent = self.pick_color_from_click
+        self.image_viewer.strategy.setCursor(Qt.CrossCursor)
+        self.original_mouse_press = self.image_viewer.strategy.get_mouse_callbacks()
+        self.image_viewer.strategy.set_mouse_callbacks(self.pick_color_from_click)
+        self.filter_gui_set_enabled_requested.emit(False)
 
     def pick_color_from_click(self, event):
         if event.button() == Qt.LeftButton:
             pos = event.pos()
-            bgr = self.editor.get_pixel_color_at(pos, radius=int(self.editor.brush.size))
+            bgr = self.get_pixel_color_at(
+                pos, radius=int(self.image_viewer.get_brush().size))
             rgb = (bgr[2], bgr[1], bgr[0])
-            QApplication.restoreOverrideCursor()
-            self.editor.image_viewer.unsetCursor()
-            self.editor.image_viewer.mousePressEvent = self.original_mouse_press
-            self.editor.image_viewer.brush_cursor.show()
-            self.editor.brush_preview.show()
-            new_filter = WhiteBalanceFilter(self.name, self.editor)
+            new_filter = WhiteBalanceFilter(
+                self.name, self.parent(), self.image_viewer, self.layer_collection,
+                self.undo_manager)
             new_filter.run_with_preview(init_val=rgb)
+            QApplication.restoreOverrideCursor()
+            self.image_viewer.unsetCursor()
+            self.image_viewer.strategy.set_mouse_callbacks(self.original_mouse_press)
+            self.image_viewer.set_cursor_style(self.original_cursor_style)
+            self.image_viewer.show_brush_cursor()
+            self.image_viewer.show_brush_preview()
+            self.filter_gui_set_enabled_requested.emit(True)
 
     def reset_rgb(self):
         for name, slider in self.sliders.items():
@@ -138,3 +147,39 @@ class WhiteBalanceFilter(BaseFilter):
 
     def apply(self, image, r, g, b):
         return white_balance_from_rgb(image, (r, g, b))
+
+    def get_pixel_color_at(self, pos, radius=None):
+        item_pos = self.image_viewer.strategy.position_on_image(pos)
+        x = int(item_pos.x())
+        y = int(item_pos.y())
+        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(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)]
+                region = master_layer[y0:y1, x0:x1]
+                if region.size == 0:
+                    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]
+            if np.isscalar(pixel):
+                pixel = [pixel, pixel, pixel]
+            pixel = [np.float32(x) for x in pixel]
+            if master_layer.dtype == np.uint16:
+                pixel = [x / 256.0 for x in pixel]
+            return tuple(int(v) for v in pixel)
+        return (0, 0, 0)

{shinestacker-1.5.1.dist-info → shinestacker-1.5.2.dist-info}/METADATA

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

{shinestacker-1.5.1.dist-info → shinestacker-1.5.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 shinestacker/__init__.py,sha256=uq2fjAw2z_6TpH3mOcWFZ98GoEPRsNhTAK8N0MMm_e8,448
-shinestacker/_version.py,sha256=oU1lLCdhmPP8CUfgzMFfhCPjCfk4eDfd8WSwOfXNBOk,21
+shinestacker/_version.py,sha256=7jrl0OaiREGeLqi1Vco5z6ma0w6Mxq8kDBXuswywlc8,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
@@ -71,35 +71,35 @@ 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=gvRGvhOhhWS05jKOXyNdMnia3b7rscQqR8-xnySIWFc,10260
+shinestacker/retouch/base_filter.py,sha256=zpedVvTpof8BsENWdDeu9PDul7Uw0UAXUSsyLZjbcpg,11265
 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=TDUHzhRKlKvCa3D5SCYCZKTpjcl81kGwmONsgSDtO1k,440
-shinestacker/retouch/display_manager.py,sha256=wwbX4n7ulg53fM3E5QL5YEb5IFV0jN8za6yfYc74anA,8624
+shinestacker/retouch/denoise_filter.py,sha256=UpNKbFs7uArdglEej8AUHan7oCVYV5E7HNzkovj7XMQ,571
+shinestacker/retouch/display_manager.py,sha256=vRmaSfHP47rYQrqvJ3flx_GgMJnMZDfQO4PXTfKcpqE,8505
 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=SdYIZkZBUvuB6wDG0moGWav5sfEvIcB9ioUJR5wJFts,388
+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=ifrlHafXdELwCXoVfUiSM7jcz3O6qH7z2WjNpNPEmUs,33505
+shinestacker/retouch/image_editor_ui.py,sha256=wvsYmS7cXt61KJlv7b3X9EbymMLgdUfeEOzi8jEuR3g,31662
 shinestacker/retouch/image_view_status.py,sha256=bdIhsXiYXm7eyjkTGWkw5PRShzaF_by-g7daqgmhwjM,1858
-shinestacker/retouch/image_viewer.py,sha256=D7feFlaZkR2nzJ9VcKcVg8lYPS7AMjA_uxJs9L099kQ,4412
+shinestacker/retouch/image_viewer.py,sha256=H8w-ORug1aKf7X3FeSX4lQV-a0IewZ9OVG1-50BK4cE,4452
 shinestacker/retouch/io_gui_handler.py,sha256=BRQ5eSt1tCMDYtOqxfdYGhx2BLCrncfNrNLGuWIy5Rk,11873
 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=0V6Y0wVmf7vPzhB4O9BSF8UwBnw0RdBdYCt_tHD4vls,8478
+shinestacker/retouch/overlaid_view.py,sha256=uIMolD1984uQPWXpd27tMvGBTcSrYT-4vxO0pWVlEO4,8686
 shinestacker/retouch/shortcuts_help.py,sha256=BFWTT5QvodqMhqa_9LI25hZqjICfckgyWG4fGrGzvnM,4283
-shinestacker/retouch/sidebyside_view.py,sha256=We4hY_ZGwINPVPHACPGYFPaiU3Khpax7Sf9Xur317FA,17358
+shinestacker/retouch/sidebyside_view.py,sha256=dN5uDG0ioFvYcbmZbx97slh4cOLmJ2T14jtTshg5F9w,17918
 shinestacker/retouch/transformation_manager.py,sha256=NSHGUF-JFv4Y81gSvizjQCTp49TLo1so7c0WoUElO08,1812
 shinestacker/retouch/undo_manager.py,sha256=cKUkqnJtnJ-Hq-LQs5Bv49FC6qkG6XSw9oCVySJ8jS0,4312
-shinestacker/retouch/unsharp_mask_filter.py,sha256=uFnth8fpZFGhdIgJCnS8x5v6lBQgJ3hX0CBke9pFXeM,3510
-shinestacker/retouch/view_strategy.py,sha256=5AiSYH_FkeIhaUMtQwZ3v1_8r6KckvOYPFoufEtw12Y,23877
-shinestacker/retouch/vignetting_filter.py,sha256=MA97rQkSL0D-Nh-n2L4AiPR064RoTROkvza4tw84g9U,3658
-shinestacker/retouch/white_balance_filter.py,sha256=glMBYlmrF-i_OrB3sGUpjZE6X4FQdyLC4GBy2bWtaFc,6056
-shinestacker-1.5.1.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
-shinestacker-1.5.1.dist-info/METADATA,sha256=FrhfVRsmH4sx7-cQxDajn-zZinLt-UIhhHf2xYZNzvM,6978
-shinestacker-1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shinestacker-1.5.1.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
-shinestacker-1.5.1.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
-shinestacker-1.5.1.dist-info/RECORD,,
+shinestacker/retouch/unsharp_mask_filter.py,sha256=Iapc8UmSVpj3V0LcJq_38P5qerRqTevMynbbk5Rk6iE,3634
+shinestacker/retouch/view_strategy.py,sha256=_Zo-SU2hlVVSv1g5eWgp72njcmfMpAlkkPggd89XJFo,23326
+shinestacker/retouch/vignetting_filter.py,sha256=JhFr6OVIripQzSJrZEG4lxq7wBsmpofLqJQ-aP2bKw8,3789
+shinestacker/retouch/white_balance_filter.py,sha256=QlMnzWmBYqUQqckY8XTH3dWPdqo7mz4gTwTZafxldPw,8237
+shinestacker-1.5.2.dist-info/licenses/LICENSE,sha256=pWgb-bBdsU2Gd2kwAXxketnm5W_2u8_fIeWEgojfrxs,7651
+shinestacker-1.5.2.dist-info/METADATA,sha256=AuETmZdF7h5LSior9SUBcdWaiSmCxenl_9bECasvSLk,6978
+shinestacker-1.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shinestacker-1.5.2.dist-info/entry_points.txt,sha256=SY6g1LqtMmp23q1DGwLUDT_dhLX9iss8DvWkiWLyo_4,166
+shinestacker-1.5.2.dist-info/top_level.txt,sha256=MhijwnBVX5psfsyX8JZjqp3SYiWPsKe69f3Gnyze4Fw,13
+shinestacker-1.5.2.dist-info/RECORD,,