shinestacker 0.4.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

shinestacker/gui/project_model.py

@@ -4,7 +4,7 @@ from .. config.constants import constants
 
 
 class ActionConfig:
-    def __init__(self, type_name: str, params: dict=None, parent=None): # noqa
+    def __init__(self, type_name: str, params=None, parent=None):
         self.type_name = type_name
         self.params = params or {}
         self.parent = parent
@@ -58,12 +58,7 @@ class ActionConfig:
 
 class Project:
     def __init__(self):
-        self.jobs: list[ActionConfig] = []
-
-    def run_all(self):
-        for job in self.jobs:
-            stack_job = job.to_stack_job()
-            stack_job.run()
+        self.jobs = []
 
     def clone(self):
         c = Project()

shinestacker/gui/tab_widget.py

@@ -0,0 +1,81 @@
+# pylint: disable=C0114, C0115, C0116, E0611
+import os
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QPixmap
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QTabWidget, QLabel, QStackedWidget
+from .. core.core_utils import get_app_base_path
+
+
+class TabWidgetWithPlaceholder(QWidget):
+    currentChanged = Signal(int)
+    tabCloseRequested = Signal(int)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.layout = QVBoxLayout(self)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.stacked_widget = QStackedWidget()
+        self.layout.addWidget(self.stacked_widget)
+        self.tab_widget = QTabWidget()
+        self.stacked_widget.addWidget(self.tab_widget)
+        self.placeholder = QLabel()
+        self.placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        rel_path = 'ico/focus_stack_bkg.png'
+        icon_path = f'{get_app_base_path()}/{rel_path}'
+        if not os.path.exists(icon_path):
+            icon_path = f'{get_app_base_path()}/../{rel_path}'
+        if os.path.exists(icon_path):
+            pixmap = QPixmap(icon_path)
+            pixmap = pixmap.scaled(250, 250, Qt.AspectRatioMode.KeepAspectRatio,
+                                   Qt.TransformationMode.SmoothTransformation)
+            self.placeholder.setPixmap(pixmap)
+        else:
+            self.placeholder.setText("Run logs will appear here.")
+        self.stacked_widget.addWidget(self.placeholder)
+        self.tab_widget.currentChanged.connect(self._on_current_changed)
+        self.tab_widget.tabCloseRequested.connect(self._on_tab_close_requested)
+        self.update_placeholder_visibility()
+
+    def _on_current_changed(self, index):
+        self.currentChanged.emit(index)
+        self.update_placeholder_visibility()
+
+    def _on_tab_close_requested(self, index):
+        self.tabCloseRequested.emit(index)
+        self.update_placeholder_visibility()
+
+    def update_placeholder_visibility(self):
+        if self.tab_widget.count() == 0:
+            self.stacked_widget.setCurrentIndex(1)
+        else:
+            self.stacked_widget.setCurrentIndex(0)
+
+    # pylint: disable=C0103
+    def addTab(self, widget, label):
+        result = self.tab_widget.addTab(widget, label)
+        self.update_placeholder_visibility()
+        return result
+
+    def removeTab(self, index):
+        result = self.tab_widget.removeTab(index)
+        self.update_placeholder_visibility()
+        return result
+
+    def count(self):
+        return self.tab_widget.count()
+
+    def setCurrentIndex(self, index):
+        return self.tab_widget.setCurrentIndex(index)
+
+    def currentIndex(self):
+        return self.tab_widget.currentIndex()
+
+    def currentWidget(self):
+        return self.tab_widget.currentWidget()
+
+    def widget(self, index):
+        return self.tab_widget.widget(index)
+
+    def indexOf(self, widget):
+        return self.tab_widget.indexOf(widget)
+    # pylint: enable=C0103

shinestacker/gui/time_progress_bar.py

@@ -0,0 +1,95 @@
+# pylint: disable=C0114, C0115, C0116, E0611
+import time
+from PySide6.QtWidgets import QProgressBar
+from .colors import ColorPalette, ACTION_RUNNING_COLOR, ACTION_COMPLETED_COLOR
+
+
+class TimerProgressBar(QProgressBar):
+    light_background_color = ColorPalette.LIGHT_BLUE
+    border_color = ColorPalette.DARK_BLUE
+    text_color = ColorPalette.DARK_BLUE
+
+    def __init__(self):
+        super().__init__()
+        super().setRange(0, 10)
+        super().setValue(0)
+        self.set_running_style()
+        self._start_time = -1
+        self._current_time = -1
+        self.elapsed_str = ''
+
+    def set_style(self, bar_color=None):
+        if bar_color is None:
+            bar_color = ColorPalette.MEDIUM_BLUE
+        self.setStyleSheet(f"""
+        QProgressBar {{
+          border: 2px solid #{self.border_color.hex()};
+          border-radius: 8px;
+          text-align: center;
+          font-weight: bold;
+          font-size: 12px;
+          background-color: #{self.light_background_color.hex()};
+          color: #{self.text_color.hex()};
+          min-height: 1px;
+        }}
+        QProgressBar::chunk {{
+          border-radius: 6px;
+          background-color: #{bar_color.hex()};
+        }}
+        """)
+
+    def time_str(self, secs):
+        ss = int(secs)
+        x = secs - ss
+        s = ss % 60
+        mm = ss // 60
+        m = mm % 60
+        h = mm // 60
+        t_str = f"{s:02d}" + f"{x:.1f}s".lstrip('0')
+        if m > 0:
+            t_str = f"{m:02d}:{t_str}"
+        if h > 0:
+            t_str = f"{h:02d}:{t_str}"
+        if m > 0 or h > 0:
+            t_str = t_str.lstrip('0')
+        elif 0 < s < 10:
+            t_str = t_str.lstrip('0')
+        elif s == 0:
+            t_str = t_str[1:]
+        return t_str
+
+    def check_time(self, val):
+        if self._start_time < 0:
+            raise RuntimeError("Start and must be called before setValue and stop")
+        self._current_time = time.time()
+        elapsed_time = self._current_time - self._start_time
+        self.elapsed_str = self.time_str(elapsed_time)
+        fmt = f"Progress: %p% - %v of %m - elapsed: {self.elapsed_str}"
+        if 0 < val < self.maximum():
+            time_per_iter = float(elapsed_time) / float(val)
+            estimated_time = time_per_iter * self.maximum()
+            remaining_time = max(0, estimated_time - elapsed_time)
+            remaining_str = self.time_str(remaining_time)
+            fmt += f", {remaining_str} remaining"
+        self.setFormat(fmt)
+
+    def start(self, steps):
+        super().setMaximum(steps)
+        self._start_time = time.time()
+        self.setValue(0)
+
+    def stop(self):
+        self.check_time(self.maximum())
+        self.setValue(self.maximum())
+
+    # pylint: disable=C0103
+    def setValue(self, val):
+        self.check_time(val)
+        super().setValue(val)
+    # pylint: enable=C0103
+
+    def set_running_style(self):
+        self.set_style(ACTION_RUNNING_COLOR)
+
+    def set_done_style(self):
+        self.set_style(ACTION_COMPLETED_COLOR)

shinestacker/retouch/base_filter.py

@@ -1,15 +1,23 @@
-# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0915, R0903
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0915, R0903, R0913, R0917, R0902, R0914
 import traceback
 from abc import ABC, abstractmethod
 import numpy as np
-from PySide6.QtWidgets import QDialog, QVBoxLayout, QCheckBox, QDialogButtonBox
-from PySide6.QtCore import Signal, QThread, QTimer
+from PySide6.QtWidgets import (
+    QHBoxLayout, QLabel, QSlider, QDialog, QVBoxLayout, QCheckBox, QDialogButtonBox)
+from PySide6.QtCore import Qt, Signal, QThread, QTimer
 
 
 class BaseFilter(ABC):
-    def __init__(self, editor):
+    def __init__(self, name, editor, allow_partial_preview=True,
+                 partial_preview_threshold=0.75, preview_at_startup=False):
         self.editor = editor
-        self.undo_label = self.__class__.__name__
+        self.name = name
+        self.allow_partial_preview = allow_partial_preview
+        self.partial_preview_threshold = partial_preview_threshold
+        self.preview_at_startup = preview_at_startup
+        self.preview_check = None
+        self.button_box = None
+        self.preview_timer = None
 
     @abstractmethod
     def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
@@ -24,20 +32,40 @@ class BaseFilter(ABC):
         pass
 
     def run_with_preview(self, **kwargs):
-        if self.editor.layer_collection.master_layer is None:
+        if self.editor.has_no_master_layer():
             return
 
-        self.editor.layer_collection.copy_master_layer()
+        self.editor.copy_master_layer()
         dlg = QDialog(self.editor)
         layout = QVBoxLayout(dlg)
         active_worker = None
         last_request_id = 0
+        initial_timer = QTimer(dlg)
+        initial_timer.setSingleShot(True)
+        dialog_closed = False
 
-        def set_preview(img, request_id, expected_id):
-            if request_id != expected_id:
-                return
-            self.editor.layer_collection.master_layer = img
+        def cleanup():
+            nonlocal active_worker, dialog_closed  # noqa
+            dialog_closed = True
+            self.editor.restore_master_layer()
             self.editor.display_manager.display_master_layer()
+            if active_worker and active_worker.isRunning():
+                active_worker.wait()
+            initial_timer.stop()
+
+        dlg.finished.connect(cleanup)
+
+        def set_preview(img, request_id, expected_id, region=None):
+            if dialog_closed or request_id != expected_id:
+                return
+            if region:
+                current_region = self.editor.image_viewer.get_visible_image_portion()[1]
+                if current_region == region:
+                    self.editor.set_master_layer(img)
+                    self.editor.display_manager.display_master_layer()
+            else:
+                self.editor.set_master_layer(img)
+                self.editor.display_manager.display_master_layer()
             try:
                 dlg.activateWindow()
             except Exception:
@@ -45,6 +73,8 @@ class BaseFilter(ABC):
 
         def do_preview():
             nonlocal active_worker, last_request_id
+            if not dlg.isVisible():
+                return
             if active_worker and active_worker.isRunning():
                 try:
                     active_worker.quit()
@@ -53,14 +83,44 @@ class BaseFilter(ABC):
                     pass
             last_request_id += 1
             current_id = last_request_id
-            params = tuple(self.get_params() or ())
-            worker = self.PreviewWorker(
-                self.apply,
-                args=(self.editor.layer_collection.master_layer_copy, *params),
-                request_id=current_id
-            )
+            visible_region = None
+            if kwargs.get('partial_preview', self.allow_partial_preview):
+                visible_data = self.editor.image_viewer.get_visible_image_portion()
+                if visible_data:
+                    visible_img, visible_region = visible_data
+                    master_img = self.editor.master_layer_copy()
+                    if visible_img.size < master_img.size * self.partial_preview_threshold:
+                        params = tuple(self.get_params() or ())
+                        worker = self.PreviewWorker(
+                            self.apply,
+                            args=(master_img, *params),
+                            request_id=current_id,
+                            region=visible_region
+                        )
+                    else:
+                        params = tuple(self.get_params() or ())
+                        worker = self.PreviewWorker(
+                            self.apply,
+                            args=(master_img, *params),
+                            request_id=current_id
+                        )
+                else:
+                    params = tuple(self.get_params() or ())
+                    worker = self.PreviewWorker(
+                        self.apply,
+                        args=(self.editor.master_layer_copy(), *params),
+                        request_id=current_id
+                    )
+            else:
+                params = tuple(self.get_params() or ())
+                worker = self.PreviewWorker(
+                    self.apply,
+                    args=(self.editor.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.finished.connect(
+                lambda img, rid, region: set_preview(img, rid, current_id, region))
             active_worker.start()
 
         def restore_original():
@@ -72,57 +132,130 @@ class BaseFilter(ABC):
                 pass
 
         self.setup_ui(dlg, layout, do_preview, restore_original, **kwargs)
-        QTimer.singleShot(0, do_preview)
+        if self.preview_check.isChecked():
+            initial_timer.timeout.connect(do_preview)
+            initial_timer.start(0)
         accepted = dlg.exec_() == QDialog.Accepted
+        cleanup()
         if accepted:
             params = tuple(self.get_params() or ())
             try:
-                h, w = self.editor.layer_collection.master_layer.shape[:2]
+                h, w = self.editor.master_layer().shape[:2]
             except Exception:
-                h, w = self.editor.layer_collection.master_layer_copy.shape[:2]
+                h, w = self.editor.master_layer_copy().shape[:2]
             if hasattr(self.editor, "undo_manager"):
                 try:
                     self.editor.undo_manager.extend_undo_area(0, 0, w, h)
                     self.editor.undo_manager.save_undo_state(
-                        self.editor.layer_collection.master_layer_copy,
-                        self.undo_label
+                        self.editor.master_layer_copy(),
+                        self.name
                     )
                 except Exception:
                     pass
-            final_img = self.apply(self.editor.layer_collection.master_layer_copy, *params)
-            self.editor.layer_collection.master_layer = final_img
-            self.editor.layer_collection.copy_master_layer()
+            final_img = self.apply(self.editor.master_layer_copy(), *params)
+            self.editor.set_master_layer(final_img)
+            self.editor.copy_master_layer()
             self.editor.display_manager.display_master_layer()
             self.editor.display_manager.update_master_thumbnail()
             self.editor.mark_as_modified()
         else:
             restore_original()
 
-    def create_base_widgets(self, layout, buttons, preview_latency):
-        preview_check = QCheckBox("Preview")
-        preview_check.setChecked(True)
-        layout.addWidget(preview_check)
-        button_box = QDialogButtonBox(buttons)
-        layout.addWidget(button_box)
-        preview_timer = QTimer()
-        preview_timer.setSingleShot(True)
-        preview_timer.setInterval(preview_latency)
-        return preview_check, preview_timer, button_box
+    def create_base_widgets(self, layout, buttons, preview_latency, parent):
+        self.preview_check = QCheckBox("Preview")
+        self.preview_check.setChecked(self.preview_at_startup)
+        layout.addWidget(self.preview_check)
+        self.button_box = QDialogButtonBox(buttons)
+        layout.addWidget(self.button_box)
+        self.preview_timer = QTimer(parent)
+        self.preview_timer.setSingleShot(True)
+        self.preview_timer.setInterval(preview_latency)
 
     class PreviewWorker(QThread):
-        finished = Signal(np.ndarray, int)
+        finished = Signal(np.ndarray, int, tuple)
 
-        def __init__(self, func, args=(), kwargs=None, request_id=0):
+        def __init__(self, func, args=(), kwargs=None, request_id=0, region=None):
             super().__init__()
             self.func = func
             self.args = args
             self.kwargs = kwargs or {}
             self.request_id = request_id
+            self.region = region
 
         def run(self):
             try:
-                result = self.func(*self.args, **self.kwargs)
+                if self.region:
+                    x, y, w, h = self.region
+                    image = self.args[0]
+                    region_img = image[y:y + h, x:x + w]
+                    region_args = (region_img,) + self.args[1:]
+                    region_result = self.func(*region_args, **self.kwargs)
+                    result = image.copy()
+                    result[y:y + h, x:x + w] = region_result
+                else:
+                    result = self.func(*self.args, **self.kwargs)
+                self.finished.emit(result, self.request_id, self.region)
             except Exception as e:
                 traceback.print_tb(e.__traceback__)
                 raise RuntimeError("Filter preview failed") from e
-            self.finished.emit(result, self.request_id)
+
+
+class OneSliderBaseFilter(BaseFilter):
+    def __init__(self, name, editor, max_value, initial_value, title,
+                 allow_partial_preview=True, partial_preview_threshold=0.5,
+                 preview_at_startup=True):
+        super().__init__(name, editor, allow_partial_preview,
+                         partial_preview_threshold, preview_at_startup)
+        self.max_range = 500
+        self.max_value = max_value
+        self.initial_value = initial_value
+        self.slider = None
+        self.value_label = None
+        self.title = title
+        self.format = "{:.2f}"
+
+    def add_widgets(self, layout, dlg):
+        pass
+
+    def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
+        dlg.setWindowTitle(self.title)
+        dlg.setMinimumWidth(600)
+        slider_layout = QHBoxLayout()
+        slider_layout.addWidget(QLabel("Amount:"))
+        slider_local = QSlider(Qt.Horizontal)
+        slider_local.setRange(0, self.max_range)
+        slider_local.setValue(int(self.initial_value / self.max_value * self.max_range))
+        slider_layout.addWidget(slider_local)
+        self.value_label = QLabel(self.format.format(self.initial_value))
+        slider_layout.addWidget(self.value_label)
+        layout.addLayout(slider_layout)
+        self.add_widgets(layout, dlg)
+        self.create_base_widgets(
+            layout, QDialogButtonBox.Ok | QDialogButtonBox.Cancel, 200, dlg)
+
+        self.preview_timer.timeout.connect(do_preview)
+
+        slider_local.valueChanged.connect(self.config_changed)
+        self.editor.connect_preview_toggle(
+            self.preview_check, self.do_preview_delayed, restore_original)
+        self.button_box.accepted.connect(dlg.accept)
+        self.button_box.rejected.connect(dlg.reject)
+        self.slider = slider_local
+
+    def param_changed(self, _val):
+        if self.preview_check.isChecked():
+            self.do_preview_delayed()
+
+    def config_changed(self, val):
+        float_val = self.max_value * float(val) / self.max_range
+        self.value_label.setText(self.format.format(float_val))
+        self.param_changed(val)
+
+    def do_preview_delayed(self):
+        self.preview_timer.start()
+
+    def get_params(self):
+        return (self.max_value * self.slider.value() / self.max_range,)
+
+    def apply(self, image, *params):
+        assert False

shinestacker/retouch/brush_preview.py

@@ -7,16 +7,6 @@ from PySide6.QtGui import QPixmap, QPainter, QImage
 from .layer_collection import LayerCollectionHandler
 
 
-def brush_profile_lower_limited(r, hardness):
-    if hardness >= 1.0:
-        result = np.where(r < 1.0, 1.0, 0.0)
-    else:
-        r_lim = np.where(r < 1.0, r, 1.0)
-        k = 1.0 / (1.0 - hardness)
-        result = 0.5 * (np.cos(np.pi * np.power(r_lim, k)) + 1.0)
-    return result
-
-
 def brush_profile(r, hardness):
     h = 2.0 * hardness - 1.0
     if h >= 1.0:

shinestacker/retouch/brush_tool.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0902, R0913, R0917, R0914
 import numpy as np
-from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush
+from PySide6.QtWidgets import QApplication, QLabel
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush, QFont
 from PySide6.QtCore import Qt, QPoint
 from .brush_gradient import create_default_brush_gradient
 from .. config.gui_constants import gui_constants
@@ -18,11 +19,16 @@ class BrushTool:
         self.opacity_slider = None
         self.flow_slider = None
         self._brush_mask_cache = {}
+        self.brush_text = None
 
     def setup_ui(self, brush, brush_preview, image_viewer, size_slider, hardness_slider,
                  opacity_slider, flow_slider):
         self.brush = brush
         self.brush_preview = brush_preview
+        self.brush_text = QLabel(brush_preview.parent())
+        self.brush_text.setStyleSheet("color: navy; background: transparent;")
+        self.brush_text.setAlignment(Qt.AlignLeft | Qt.AlignTop)
+        self.brush_text.raise_()
         self.image_viewer = image_viewer
         self.size_slider = size_slider
         self.hardness_slider = hardness_slider
@@ -86,7 +92,7 @@ class BrushTool:
         pixmap = QPixmap(width, height)
         pixmap.fill(Qt.transparent)
         painter = QPainter(pixmap)
-        painter.setRenderHint(QPainter.Antialiasing)
+        painter.setRenderHint(QPainter.TextAntialiasing, True)
         preview_size = min(self.brush.size, width + 30, height + 30)
         center_x, center_y = width // 2, height // 2
         radius = preview_size // 2
@@ -109,21 +115,32 @@ class BrushTool:
         painter.drawEllipse(QPoint(center_x, center_y), radius, radius)
         if self.image_viewer.cursor_style == 'preview':
             painter.setPen(QPen(QColor(0, 0, 160)))
-            painter.drawText(0, 10, f"Size: {int(self.brush.size)}px")
-            painter.drawText(0, 25, f"Hardness: {self.brush.hardness}%")
-            painter.drawText(0, 40, f"Opacity: {self.brush.opacity}%")
-            painter.drawText(0, 55, f"Flow: {self.brush.flow}%")
+            font = QApplication.font()
+            painter.setFont(font)
+            font.setHintingPreference(QFont.PreferFullHinting)
+            painter.setFont(font)
+            self.brush_text.setText(
+                f"Size: {int(self.brush.size)}px\n"
+                f"Hardness: {self.brush.hardness}%\n"
+                f"Opacity: {self.brush.opacity}%\n"
+                f"Flow: {self.brush.flow}%"
+            )
+            self.brush_text.adjustSize()
+            self.brush_text.move(10, self.brush_preview.height() // 2 + 125)
+            self.brush_text.show()
+        else:
+            self.brush_text.hide()
         painter.end()
         self.brush_preview.setPixmap(pixmap)
         self.image_viewer.update_brush_cursor()
 
     def apply_brush_operation(self, master_layer, source_layer, dest_layer, mask_layer,
-                              view_pos, image_viewer):
+                              view_pos):
         if master_layer is None or source_layer is None:
             return False
         if dest_layer is None:
             dest_layer = master_layer
-        scene_pos = image_viewer.mapToScene(view_pos)
+        scene_pos = self.image_viewer.mapToScene(view_pos)
         x_center = int(round(scene_pos.x()))
         y_center = int(round(scene_pos.y()))
         radius = int(round(self.brush.size // 2))
@@ -168,6 +185,3 @@ class BrushTool:
             dest_area[:] = np.clip(
                 master_area * (1 - effective_mask) + source_area * effective_mask, 0,
                 max_px_value).astype(dtype)
-
-    def clear_cache(self):
-        self._brush_mask_cache.clear()

shinestacker/retouch/denoise_filter.py

@@ -1,51 +1,12 @@
 # pylint: disable=C0114, C0115, C0116, E0611, W0221
-from PySide6.QtWidgets import QHBoxLayout, QLabel, QSlider, QDialogButtonBox
-from PySide6.QtCore import Qt
-from .base_filter import BaseFilter
+from .base_filter import OneSliderBaseFilter
 from .. algorithms.denoise import denoise
 
 
-class DenoiseFilter(BaseFilter):
-    def __init__(self, editor):
-        super().__init__(editor)
-        self.max_range = 500.0
-        self.max_value = 10.00
-        self.initial_value = 2.5
-        self.slider = None
-
-    def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
-        dlg.setWindowTitle("Denoise")
-        dlg.setMinimumWidth(600)
-        slider_layout = QHBoxLayout()
-        slider_local = QSlider(Qt.Horizontal)
-        slider_local.setRange(0, self.max_range)
-        slider_local.setValue(int(self.initial_value / self.max_value * self.max_range))
-        slider_layout.addWidget(slider_local)
-        value_label = QLabel(f"{self.max_value:.2f}")
-        slider_layout.addWidget(value_label)
-        layout.addLayout(slider_layout)
-        preview_check, preview_timer, button_box = self.create_base_widgets(
-            layout, QDialogButtonBox.Ok | QDialogButtonBox.Cancel, 200)
-
-        def do_preview_delayed():
-            preview_timer.start()
-
-        preview_timer.timeout.connect(do_preview)
-
-        def slider_changed(val):
-            float_val = self.max_value * float(val) / self.max_range
-            value_label.setText(f"{float_val:.2f}")
-            if preview_check.isChecked():
-                do_preview_delayed()
-
-        slider_local.valueChanged.connect(slider_changed)
-        self.editor.connect_preview_toggle(preview_check, do_preview_delayed, restore_original)
-        button_box.accepted.connect(dlg.accept)
-        button_box.rejected.connect(dlg.reject)
-        self.slider = slider_local
-
-    def get_params(self):
-        return (self.max_value * self.slider.value() / self.max_range,)
+class DenoiseFilter(OneSliderBaseFilter):
+    def __init__(self, name, editor):
+        super().__init__(name, editor, 10.0, 2.5, "Denoise",
+                         allow_partial_preview=True, preview_at_startup=False)
 
     def apply(self, image, strength):
         return denoise(image, strength)