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

shinestacker/retouch/image_viewer.py

@@ -9,10 +9,15 @@ 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)
@@ -39,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)
@@ -58,7 +65,6 @@ class ImageViewer(QGraphicsView):
         self.empty = False
         self.setFocus()
         self.activateWindow()
-        self.brush_preview.layer_collection = self.image_editor.layer_collection
         self.brush_preview.brush = self.brush
 
     def clear_image(self):
@@ -109,7 +115,7 @@ class ImageViewer(QGraphicsView):
     def mousePressEvent(self, event):
         if self.empty:
             return
-        if event.button() == Qt.LeftButton and self.image_editor.layer_collection.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()
@@ -118,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()
@@ -145,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:
@@ -177,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
@@ -227,7 +230,7 @@ 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()
@@ -235,8 +238,8 @@ class ImageViewer(QGraphicsView):
             if isinstance(pos, QPointF):
                 scene_pos = pos
             else:
-                cursor_pos = self.image_editor.image_viewer.mapFromGlobal(pos)
-                scene_pos = self.image_editor.image_viewer.mapToScene(cursor_pos)
+                cursor_pos = self.mapFromGlobal(pos)
+                scene_pos = self.mapToScene(cursor_pos)
             self.brush_preview.update(scene_pos, int(size))
         else:
             self.brush_preview.hide()
@@ -346,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

shinestacker/retouch/io_gui_handler.py

@@ -0,0 +1,208 @@
+import traceback
+import numpy as np
+from PySide6.QtWidgets import QFileDialog, QMessageBox, QVBoxLayout, QLabel, QDialog, QApplication
+from PySide6.QtGui import QGuiApplication, QCursor
+from PySide6.QtCore import Qt, QObject, QTimer, Signal
+from .file_loader import FileLoader
+from .exif_data import ExifData
+from .io_manager import IOManager
+
+
+class IOGuiHandler(QObject):
+    status_message_requested = Signal(str)
+    update_title_requested = Signal()
+
+    def __init__(self, layer_collection, undo_manager, parent):
+        super().__init__(parent)
+        self.io_manager = IOManager(layer_collection)
+        self.undo_manager = undo_manager
+        layer_collection.add_to(self)
+        self.loader_thread = None
+
+    def setup_ui(self, display_manager, image_viewer):
+        self.display_manager = display_manager
+        self.image_viewer = image_viewer
+
+    def on_file_loaded(self, stack, labels, master_layer):
+        QApplication.restoreOverrideCursor()
+        self.loading_timer.stop()
+        self.loading_dialog.hide()
+        self.set_layer_stack(stack)
+        if labels is None:
+            self.set_layer_labels([f'Layer {i:03d}' for i in range(len(stack))])
+        else:
+            self.set_layer_labels(labels)
+        self.set_master_layer(master_layer)
+        self.modified = False
+        self.undo_manager.reset()
+        self.blank_layer = np.zeros(master_layer.shape[:2])
+        self.display_manager.update_thumbnails()
+        self.image_viewer.setup_brush_cursor()
+        self.parent().change_layer(0)
+        self.image_viewer.reset_zoom()
+        self.status_message_requested.emit(f"Loaded: {self.io_manager.current_file_path}")
+        self.parent().thumbnail_list.setFocus()
+        self.update_title_requested.emit()
+
+    def on_file_error(self, error_msg):
+        QApplication.restoreOverrideCursor()
+        self.loading_timer.stop()
+        self.loading_dialog.accept()
+        self.loading_dialog.deleteLater()
+        QMessageBox.critical(self, "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 (*)")
+        if not file_paths:
+            return
+        if self.loader_thread and self.loader_thread.isRunning():
+            if not self.loader_thread.wait(10000):
+                raise RuntimeError("Loading timeout error.")
+        if isinstance(file_paths, list) and len(file_paths) > 1:
+            self.import_frames_from_files(file_paths)
+            return
+        path = file_paths[0] if isinstance(file_paths, list) else file_paths
+        self.io_manager.current_file_path = path
+        QGuiApplication.setOverrideCursor(QCursor(Qt.BusyCursor))
+        self.loading_dialog = QDialog(self.parent())
+        self.loading_dialog.setWindowTitle("Loading")
+        self.loading_dialog.setWindowFlags(Qt.Window | Qt.FramelessWindowHint)
+        self.loading_dialog.setModal(True)
+        layout = QVBoxLayout()
+        layout.addWidget(QLabel("File loading..."))
+        self.loading_dialog.setLayout(layout)
+        self.loading_timer = QTimer()
+        self.loading_timer.setSingleShot(True)
+        self.loading_timer.timeout.connect(self.loading_dialog.show)
+        self.loading_timer.start(100)
+        self.loader_thread = FileLoader(path)
+        self.loader_thread.finished.connect(self.on_file_loaded)
+        self.loader_thread.error.connect(self.on_file_error)
+        self.loader_thread.start()
+
+    def import_frames(self):
+        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")
+
+    def import_frames_from_files(self, file_paths):
+        try:
+            stack, labels, master = self.io_manager.import_frames(file_paths)
+        except Exception as e:
+            msg = QMessageBox()
+            msg.setIcon(QMessageBox.Critical)
+            msg.setWindowTitle("Import error")
+            msg.setText(str(e))
+            msg.exec()
+            return
+        if self.layer_stack() is None and len(stack) > 0:
+            self.set_layer_stack(np.array(stack))
+            self.set_layer_labels(labels)
+            self.set_master_layer(master)
+            self.blank_layer = np.zeros(master.shape[:2])
+        else:
+            for img, label in zip(stack, labels):
+                self.add_layer_label(label)
+                self.add_layer(img)
+        self.parent().mark_as_modified()
+        self.parent().change_layer(0)
+        self.image_viewer.reset_zoom()
+        self.parent().thumbnail_list.setFocus()
+        self.display_manager.update_thumbnails()
+
+    def save_file(self):
+        if self.parent().save_master_only.isChecked():
+            self.save_master()
+        else:
+            self.save_multilayer()
+
+    def save_file_as(self):
+        if self.parent().save_master_only.isChecked():
+            self.save_master_as()
+        else:
+            self.save_multilayer_as()
+
+    def save_multilayer(self):
+        if self.layer_stack() is None:
+            return
+        if self.io_manager.current_file_path != '':
+            extension = self.io_manager.current_file_path.split('.')[-1]
+            if extension in ['tif', 'tiff']:
+                self.save_multilayer_to_path(self.io_manager.current_file_path)
+                return
+
+    def save_multilayer_as(self):
+        if self.layer_stack() is None:
+            return
+        path, _ = QFileDialog.getSaveFileName(self.parent(), "Save Image", "",
+                                              "TIFF Files (*.tif *.tiff);;All Files (*)")
+        if path:
+            if not path.lower().endswith(('.tif', '.tiff')):
+                path += '.tif'
+            self.save_multilayer_to_path(path)
+
+    def save_multilayer_to_path(self, path):
+        try:
+            self.io_manager.save_multilayer(path)
+            self.io_manager.current_file_path = path
+            self.modified = False
+            self.update_title_requested.emit()
+            self.status_message_requested.emit(f"Saved multilayer to: {path}")
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            QMessageBox.critical(self.parent(), "Save Error", f"Could not save file: {str(e)}")
+
+    def save_master(self):
+        if self.master_layer() is None:
+            return
+        if self.io_manager.current_file_path != '':
+            self.save_master_to_path(self.io_manager.current_file_path)
+            return
+        self.save_master_as()
+
+    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 (*)")
+        if path:
+            self.save_master_to_path(path)
+
+    def save_master_to_path(self, path):
+        try:
+            self.io_manager.save_master(path)
+            self.io_manager.current_file_path = path
+            self.modified = False
+            self.update_title_requested.emit()
+            self.status_message_requested.emit(f"Saved master layer to: {path}")
+        except Exception as e:
+            traceback.print_tb(e.__traceback__)
+            QMessageBox.critical(self.parent(), "Save Error", f"Could not save file: {str(e)}")
+
+    def select_exif_path(self):
+        path, _ = QFileDialog.getOpenFileName(None, "Select file with exif data")
+        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()
+
+    def close_file(self):
+        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
+            self.undo_manager.reset()
+            self.image_viewer.clear_image()
+            self.display_manager.thumbnail_list.clear()
+            self.display_manager.update_thumbnails()
+            self.update_title_requested.emit()
+            self.status_message_requested.emit("File closed")

shinestacker/retouch/io_manager.py

@@ -1,5 +1,5 @@
+# pylint: disable=E1101, C0114, C0115, C0116
 import cv2
-from .. core.exceptions import ShapeError, BitDepthError
 from .. algorithms.utils import read_img, validate_image, get_img_metadata
 from .. algorithms.exif import get_exif, write_image_with_exif_data
 from .. algorithms.multilayer import write_multilayer_tiff_from_images
@@ -7,7 +7,7 @@ from .. algorithms.multilayer import write_multilayer_tiff_from_images
 
 class IOManager:
     def __init__(self, layer_collection):
-        self.layer_collection = layer_collection
+        layer_collection.add_to(self)
         self.current_file_path = ''
         self.exif_path = ''
         self.exif_data = None
@@ -16,7 +16,7 @@ class IOManager:
         stack = []
         labels = []
         master = None
-        shape, dtype = get_img_metadata(self.layer_collection.master_layer)
+        shape, dtype = get_img_metadata(self.master_layer())
         for path in file_paths:
             try:
                 label = path.split("/")[-1].split(".")[0]
@@ -34,22 +34,18 @@ class IOManager:
                 stack.append(img)
                 if master is None:
                     master = img.copy()
-            except ShapeError as e:
-                raise ShapeError(f"All files must have the same shape.\n{str(e)}")
-            except BitDepthError as e:
-                raise BitDepthError(f"All files must have the same bit depth.\n{str(e)}")
             except Exception as e:
-                raise RuntimeError(f"Error loading file: {path}.\n{str(e)}")
+                raise RuntimeError(f"Error loading file: {path}.\n{str(e)}") from e
         return stack, labels, master
 
     def save_multilayer(self, path):
-        master_layer = {'Master': self.layer_collection.master_layer}
-        individual_layers = {label: image for label, image in zip(
-            self.layer_collection.layer_labels, self.layer_collection.layer_stack)}
-        write_multilayer_tiff_from_images({**master_layer, **individual_layers}, path, exif_path=self.exif_path)
+        master_layer = {'Master': self.master_layer()}
+        individual_layers = dict(zip(self.layer_labels(), self.layer_stack()))
+        write_multilayer_tiff_from_images({**master_layer, **individual_layers},
+                                          path, exif_path=self.exif_path)
 
     def save_master(self, path):
-        img = cv2.cvtColor(self.layer_collection.master_layer, cv2.COLOR_RGB2BGR)
+        img = cv2.cvtColor(self.master_layer(), cv2.COLOR_RGB2BGR)
         write_image_with_exif_data(self.exif_data, img, path)
 
     def set_exif_data(self, path):

shinestacker/retouch/layer_collection.py

@@ -2,16 +2,68 @@ import numpy as np
 
 
 class LayerCollection:
+    def add_to(self, obj):
+        obj.layer_collection = self
+        obj.master_layer = lambda: obj.layer_collection.master_layer
+        obj.current_layer = lambda: obj.layer_collection.current_layer()
+        obj.layer_stack = lambda: obj.layer_collection.layer_stack
+        obj.layer_labels = lambda: obj.layer_collection.layer_labels
+        obj.set_layer_label = lambda i, val: obj.layer_collection.set_layer_label(i, val)
+        obj.set_layer_labels = lambda labels: obj.layer_collection.set_layer_labels(labels)
+        obj.current_layer_idx = lambda: obj.layer_collection.current_layer_idx
+        obj.has_no_master_layer = lambda: obj.layer_collection.has_no_master_layer()
+        obj.has_master_layer = lambda: obj.layer_collection.has_master_layer()
+        obj.set_layer_stack = lambda stk: obj.layer_collection.set_layer_stack(stk)
+        obj.set_master_layer = lambda img: obj.layer_collection.set_master_layer(img)
+        obj.add_layer_label = lambda label: obj.layer_collection.add_layer_label(label)
+        obj.add_layer = lambda img: obj.layer_collection.add_layer(img)
+        obj.master_layer_copy = lambda: obj.layer_collection.master_layer_copy
+        obj.copy_master_layer = lambda: obj.layer_collection.copy_master_layer()
+        obj.set_current_layer_idx = lambda idx: obj.layer_collection.set_current_layer_idx(idx)
+        obj.sort_layers = lambda order: obj.layer_collection.sort_layers(order)
+        obj.number_of_layers = lambda: obj.layer_collection.number_of_layers()
+        obj.valid_current_layer_idx = lambda: obj.layer_collection.valid_current_layer_idx()
+
     def __init__(self):
+        self.reset()
+
+    def reset(self):
         self.master_layer = None
         self.master_layer_copy = None
         self.layer_stack = None
-        self.layer_labels = None
+        self.layer_labels = []
         self.current_layer_idx = 0
 
+    def has_master_layer(self):
+        return self.master_layer is not None
+
+    def has_no_master_layer(self):
+        return self.master_layer is None
+
+    def has_master_layer_copy(self):
+        return self.master_layer_copy is not None
+
+    def has_no_master_layer_copy(self):
+        return self.master_layer_copy is None
+
     def number_of_layers(self):
         return len(self.layer_stack)
 
+    def layer_label(self, i):
+        return self.layer_labels[i]
+
+    def set_layer_label(self, i, val):
+        self.layer_labels[i] = val
+
+    def set_layer_labels(self, labels):
+        self.layer_labels = labels
+
+    def set_layer_stack(self, stk):
+        self.layer_stack = stk
+
+    def set_current_layer_idx(self, idx):
+        self.current_layer_idx = idx
+
     def valid_current_layer_idx(self):
         return 0 <= self.current_layer_idx < self.number_of_layers()
 
@@ -20,9 +72,21 @@ class LayerCollection:
             return self.layer_stack[self.current_layer_idx]
         return None
 
+    def set_master_layer(self, img):
+        self.master_layer = img
+
     def copy_master_layer(self):
         self.master_layer_copy = self.master_layer.copy()
 
+    def add_layer_label(self, label):
+        if self.layer_labels is None:
+            self.layer_labels = [label]
+        else:
+            self.layer_labels.append(label)
+
+    def add_layer(self, img):
+        self.layer_stack = np.append(self.layer_stack, [img], axis=0)
+
     def sort_layers(self, order):
         master_index = -1
         master_label = None

shinestacker/retouch/unsharp_mask_filter.py

@@ -0,0 +1,84 @@
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QSlider, QCheckBox, QDialogButtonBox
+from PySide6.QtCore import Qt, QTimer
+from .filter_base import BaseFilter
+
+
+class UnsharpMaskFilter(BaseFilter):
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.max_range = 500.0
+        self.max_radius = 4.0
+        self.max_amount = 3.0
+        self.max_threshold = 64.0
+        self.initial_radius = 1.0
+        self.initial_amount = 0.5
+        self.initial_threshold = 0.0
+        self.radius_slider = None
+        self.amount_slider = None
+        self.threshold_slider = None
+
+    def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
+        dlg.setWindowTitle("Unsharp Mask")
+        dlg.setMinimumWidth(600)
+        params = {
+            "Radius": (self.max_radius, self.initial_radius, "{:.2f}"),
+            "Amount": (self.max_amount, self.initial_amount, "{:.1%}"),
+            "Threshold": (self.max_threshold, self.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, self.max_range)
+            slider.setValue(int(init_val / max_val * self.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":
+                self.radius_slider = slider
+            elif name == "Amount":
+                self.amount_slider = slider
+            elif name == "Threshold":
+                self.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 / self.max_range
+            value_labels[name].setText(fmt.format(float_value))
+            if preview_check.isChecked():
+                preview_timer.start()
+
+        self.radius_slider.valueChanged.connect(
+            lambda v: update_value("Radius", v, self.max_radius, params["Radius"][2]))
+        self.amount_slider.valueChanged.connect(
+            lambda v: update_value("Amount", v, self.max_amount, params["Amount"][2]))
+        self.threshold_slider.valueChanged.connect(
+            lambda v: update_value("Threshold", v, self.max_threshold, params["Threshold"][2]))
+        preview_timer.timeout.connect(do_preview)
+        self.editor.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)
+
+    def get_params(self):
+        return (
+            max(0.01, self.max_radius * self.radius_slider.value() / self.max_range),
+            self.max_amount * self.amount_slider.value() / self.max_range,
+            self.max_threshold * self.threshold_slider.value() / self.max_range
+        )
+
+    def apply(self, image, radius, amount, threshold):
+        from .. algorithms.sharpen import unsharp_mask
+        return unsharp_mask(image, radius, amount, threshold)

shinestacker/retouch/white_balance_filter.py

@@ -0,0 +1,111 @@
+from PySide6.QtWidgets import (QHBoxLayout,
+                               QPushButton, QFrame, QVBoxLayout, QLabel, QDialog, QApplication, QSlider,
+                               QCheckBox, QDialogButtonBox)
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtGui import QCursor
+from .filter_base import BaseFilter
+
+
+class WhiteBalanceFilter(BaseFilter):
+    def __init__(self, editor):
+        super().__init__(editor)
+        self.max_range = 255
+        self.initial_val = (128, 128, 128)
+        self.sliders = {}
+        self.value_labels = {}
+        self.color_preview = None
+        self.preview_timer = None
+
+    def setup_ui(self, dlg, layout, do_preview, restore_original, init_val=None):
+        if init_val:
+            self.initial_val = init_val
+        dlg.setWindowTitle("White Balance")
+        dlg.setMinimumWidth(600)
+        row_layout = QHBoxLayout()
+        self.color_preview = QFrame()
+        self.color_preview.setFixedHeight(80)
+        self.color_preview.setFixedWidth(80)
+        self.color_preview.setStyleSheet(f"background-color: rgb{self.initial_val};")
+        row_layout.addWidget(self.color_preview)
+        sliders_layout = QVBoxLayout()
+        for name in ("R", "G", "B"):
+            row = QHBoxLayout()
+            label = QLabel(f"{name}:")
+            row.addWidget(label)
+            slider = QSlider(Qt.Horizontal)
+            slider.setRange(0, self.max_range)
+            slider.setValue(self.initial_val[["R", "G", "B"].index(name)])
+            row.addWidget(slider)
+            val_label = QLabel(str(self.initial_val[["R", "G", "B"].index(name)]))
+            row.addWidget(val_label)
+            sliders_layout.addLayout(row)
+            self.sliders[name] = slider
+            self.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)
+        self.preview_timer = QTimer()
+        self.preview_timer.setSingleShot(True)
+        self.preview_timer.setInterval(200)
+        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(preview_check, do_preview, restore_original)
+        pick_button.clicked.connect(self.start_color_pick)
+        button_box.accepted.connect(dlg.accept)
+        button_box.rejected.connect(dlg.reject)
+        button_box.button(QDialogButtonBox.Reset).clicked.connect(self.reset_rgb)
+        QTimer.singleShot(0, do_preview)
+
+    def on_slider_change(self):
+        for name in ("R", "G", "B"):
+            self.value_labels[name].setText(str(self.sliders[name].value()))
+        rgb = tuple(self.sliders[n].value() for n in ("R", "G", "B"))
+        self.color_preview.setStyleSheet(f"background-color: rgb{rgb};")
+        if self.preview_timer:
+            self.preview_timer.start()
+
+    def start_color_pick(self):
+        for widget in QApplication.topLevelWidgets():
+            if isinstance(widget, QDialog) and widget.isVisible():
+                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()
+        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
+
+    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))
+            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.editor)
+            new_filter.run_with_preview(init_val=rgb)
+
+    def reset_rgb(self):
+        for name, slider in self.sliders.items():
+            slider.setValue(self.initial_val[["R", "G", "B"].index(name)])
+
+    def get_params(self):
+        return tuple(self.sliders[n].value() for n in ("R", "G", "B"))
+
+    def apply(self, image, r, g, b):
+        from .. algorithms.white_balance import white_balance_from_rgb
+        return white_balance_from_rgb(image, (r, g, b))