shinestacker 1.6.1__py3-none-any.whl → 1.8.0__py3-none-any.whl

shinestacker/gui/action_config_dialog.py

@@ -1,5 +1,5 @@
 # pylint: disable=C0114, C0115, C0116, E0611, R0913, R0917, R0915, R0912
-# pylint: disable=E0606, W0718, R1702, W0102, W0221, R0914, C0302
+# pylint: disable=E0606, W0718, R1702, W0102, W0221, R0914, C0302, R0903
 import os
 import traceback
 from PySide6.QtCore import QTimer
@@ -214,7 +214,7 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
             expert=True,
             placeholder='relative to working path')
         self.add_field_to_layout(
-            layout, 'scratch_output_dir', FIELD_BOOL, 'Scratch output dir.',
+            layout, 'scratch_output_dir', FIELD_BOOL, 'Scratch output folder before run',
             required=False, default=True)
 
     def create_algorithm_tab(self, layout):
@@ -366,6 +366,14 @@ class FocusStackBunchConfigurator(FocusStackBaseConfigurator):
         self.add_field_to_layout(
             self.general_tab_layout, 'overlap', FIELD_INT, 'Overlapping frames', required=False,
             default=constants.DEFAULT_OVERLAP, min_val=0, max_val=100)
+        self.add_field_to_layout(
+            self.general_tab_layout, 'scratch_output_dir', FIELD_BOOL,
+            'Scratch output folder before run',
+            required=False, default=True)
+        self.add_field_to_layout(
+            self.general_tab_layout, 'delete_output_at_end', FIELD_BOOL,
+            'Delete output at end of job',
+            required=False, default=False)
         self.add_field_to_layout(
             self.general_tab_layout, 'plot_stack', FIELD_BOOL, 'Plot stack', required=False,
             default=constants.DEFAULT_PLOT_STACK_BUNCH)
@@ -391,7 +399,7 @@ class MultiLayerConfigurator(DefaultActionConfigurator):
             expert=True,
             placeholder='relative to working path')
         self.add_field(
-            'scratch_output_dir', FIELD_BOOL, 'Scratch output dir.',
+            'scratch_output_dir', FIELD_BOOL, 'Scratch output folder before run',
             required=False, default=True)
         self.add_field(
             'reverse_order', FIELD_BOOL, 'Reverse file order', required=False,
@@ -413,8 +421,11 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
             expert=True,
             placeholder='relative to working path')
         self.add_field(
-            'scratch_output_dir', FIELD_BOOL, 'Scratch output dir.',
+            'scratch_output_dir', FIELD_BOOL, 'Scratch output folder before run',
             required=False, default=True)
+        self.add_field(
+            'delete_output_at_end', FIELD_BOOL, 'Delete output at end of job',
+            required=False, default=False)
         self.add_field(
             'plot_path', FIELD_REL_PATH, 'Plots path', required=False,
             expert=True,
@@ -490,22 +501,22 @@ class SubsampleActionConfigurator(DefaultActionConfigurator):
             self.subsample_field.currentText() not in constants.FIELD_SUBSAMPLE_OPTIONS[:2])
 
 
-class AlignFramesConfigurator(SubsampleActionConfigurator):
-    BORDER_MODE_OPTIONS = ['Constant', 'Replicate', 'Replicate and blur']
-    TRANSFORM_OPTIONS = ['Rigid', 'Homography']
-    METHOD_OPTIONS = ['Random Sample Consensus (RANSAC)', 'Least Median (LMEDS)']
+class AlignFramesConfigBase:
     MATCHING_METHOD_OPTIONS = ['K-nearest neighbors', 'Hamming distance']
-    MODE_OPTIONS = ['Auto', 'Sequential', 'Parallel']
+    DETECTOR_DESCRIPTOR_TOOLTIPS = {
+        'detector':
+            "SIFT: Requires SIFT descriptor and K-NN matching\n"
+            "ORB/AKAZE: Work best with Hamming distance",
+        'descriptor':
+            "SIFT: Requires K-NN matching\n"
+            "ORB/AKAZE: Require Hamming distance with ORB/AKAZE detectors",
+        'match_method':
+            "Automatically selected based on detector/descriptor combination"
 
-    def __init__(self, expert, current_wd):
-        super().__init__(expert, current_wd)
-        self.matching_method_field = None
+    }
+
+    def __init__(self):
         self.info_label = None
-        self.detector_field = None
-        self.descriptor_field = None
-        self.matching_method_field = None
-        self.tab_widget = None
-        self.current_tab_layout = None
 
     def show_info(self, message, timeout=3000):
         self.info_label.setText(message)
@@ -514,32 +525,50 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
         timer.timeout.connect(lambda: self.info_label.setText(''))
         timer.start(timeout)
 
-    def change_match_config(self):
-        detector = self.detector_field.currentText()
-        descriptor = self.descriptor_field.currentText()
+    def change_match_config(
+            self, detector_field, descriptor_field, matching_method_field, show_info):
+        detector = detector_field.currentText()
+        descriptor = descriptor_field.currentText()
         match_method = dict(
             zip(self.MATCHING_METHOD_OPTIONS,
-                constants.VALID_MATCHING_METHODS))[self.matching_method_field.currentText()]
+                constants.VALID_MATCHING_METHODS))[matching_method_field.currentText()]
         try:
             validate_align_config(detector, descriptor, match_method)
         except Exception as e:
-            self.show_info(str(e))
+            show_info(str(e))
             if descriptor == constants.DETECTOR_SIFT and \
                match_method == constants.MATCHING_NORM_HAMMING:
-                self.matching_method_field.setCurrentText(self.MATCHING_METHOD_OPTIONS[0])
+                matching_method_field.setCurrentText(self.MATCHING_METHOD_OPTIONS[0])
             if detector == constants.DETECTOR_ORB and descriptor == constants.DESCRIPTOR_AKAZE and \
                     match_method == constants.MATCHING_NORM_HAMMING:
-                self.matching_method_field.setCurrentText(constants.MATCHING_NORM_HAMMING)
+                matching_method_field.setCurrentText(constants.MATCHING_NORM_HAMMING)
             if detector == constants.DETECTOR_BRISK and descriptor == constants.DESCRIPTOR_AKAZE:
-                self.descriptor_field.setCurrentText('BRISK')
+                descriptor_field.setCurrentText('BRISK')
             if detector == constants.DETECTOR_SURF and descriptor == constants.DESCRIPTOR_AKAZE:
-                self.descriptor_field.setCurrentText('SIFT')
+                descriptor_field.setCurrentText('SIFT')
             if detector == constants.DETECTOR_SIFT and descriptor != constants.DESCRIPTOR_SIFT:
-                self.descriptor_field.setCurrentText('SIFT')
+                descriptor_field.setCurrentText('SIFT')
             if detector in constants.NOKNN_METHODS['detectors'] and \
                descriptor in constants.NOKNN_METHODS['descriptors']:
                 if match_method == constants.MATCHING_KNN:
-                    self.matching_method_field.setCurrentText(self.MATCHING_METHOD_OPTIONS[1])
+                    matching_method_field.setCurrentText(self.MATCHING_METHOD_OPTIONS[1])
+
+
+class AlignFramesConfigurator(SubsampleActionConfigurator, AlignFramesConfigBase):
+    BORDER_MODE_OPTIONS = ['Constant', 'Replicate', 'Replicate and blur']
+    TRANSFORM_OPTIONS = ['Rigid', 'Homography']
+    METHOD_OPTIONS = ['Random Sample Consensus (RANSAC)', 'Least Median (LMEDS)']
+    MODE_OPTIONS = ['Auto', 'Sequential', 'Parallel']
+
+    def __init__(self, expert, current_wd):
+        SubsampleActionConfigurator.__init__(self, expert, current_wd)
+        AlignFramesConfigBase.__init__(self)
+        self.matching_method_field = None
+        self.detector_field = None
+        self.descriptor_field = None
+        self.matching_method_field = None
+        self.tab_widget = None
+        self.current_tab_layout = None
 
     def create_form(self, layout, action):
         super().create_form(layout, action)
@@ -557,23 +586,23 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
         self.create_miscellanea_tab(misc_layout)
 
     def create_feature_tab(self, layout):
+
+        def change_match_config():
+            self.change_match_config(
+                self.detector_field, self.descriptor_field,
+                self. matching_method_field, self.show_info)
+
         self.add_bold_label_to_layout(layout, "Feature identification:")
         self.detector_field = self.add_field_to_layout(
             layout, 'detector', FIELD_COMBO, 'Detector', required=False,
-            options=constants.VALID_DETECTORS, default=constants.DEFAULT_DETECTOR)
+            options=constants.VALID_DETECTORS, default=AppConfig.get('detector'))
         self.descriptor_field = self.add_field_to_layout(
             layout, 'descriptor', FIELD_COMBO, 'Descriptor', required=False,
-            options=constants.VALID_DESCRIPTORS, default=constants.DEFAULT_DESCRIPTOR)
-        self.detector_field.setToolTip(
-            "SIFT: Requires SIFT descriptor and K-NN matching\n"
-            "ORB/AKAZE: Work best with Hamming distance"
-        )
-        self.descriptor_field.setToolTip(
-            "SIFT: Requires K-NN matching\n"
-            "ORB/AKAZE: Require Hamming distance with ORB/AKAZE detectors"
-        )
-        self.detector_field.currentIndexChanged.connect(self.change_match_config)
-        self.descriptor_field.currentIndexChanged.connect(self.change_match_config)
+            options=constants.VALID_DESCRIPTORS, default=AppConfig.get('descriptor'))
+        self.detector_field.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['detector'])
+        self.descriptor_field.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['descriptor'])
+        self.detector_field.currentIndexChanged.connect(change_match_config)
+        self.descriptor_field.currentIndexChanged.connect(change_match_config)
         self.info_label = QLabel()
         self.info_label.setStyleSheet("color: orange; font-style: italic;")
         layout.addRow(self.info_label)
@@ -581,11 +610,9 @@ class AlignFramesConfigurator(SubsampleActionConfigurator):
         self.matching_method_field = self.add_field_to_layout(
             layout, 'match_method', FIELD_COMBO, 'Match method', required=False,
             options=self.MATCHING_METHOD_OPTIONS, values=constants.VALID_MATCHING_METHODS,
-            default=constants.DEFAULT_MATCHING_METHOD)
-        self.matching_method_field.setToolTip(
-            "Automatically selected based on detector/descriptor combination"
-        )
-        self.matching_method_field.currentIndexChanged.connect(self.change_match_config)
+            default=AppConfig.get('match_method'))
+        self.matching_method_field.setToolTip(self.DETECTOR_DESCRIPTOR_TOOLTIPS['match_method'])
+        self.matching_method_field.currentIndexChanged.connect(change_match_config)
         self.add_field_to_layout(
             layout, 'flann_idx_kdtree', FIELD_INT, 'Flann idx kdtree', required=False,
             expert=True,

shinestacker/gui/gui_run.py

@@ -215,8 +215,7 @@ class RunWindow(QTextEditLogger):
                 raise RuntimeError(f"Can't visualize file type {os.path.splitext(path)[1]}.")
             self.image_views.append(image_view)
             self.image_layout.addWidget(image_view)
-            max_width = max(pv.size().width() for pv in self.image_views) if self.image_views else 0
-            needed_width = max_width + 20
+            needed_width = gui_constants.GUI_IMG_WIDTH + 20
             self.right_area.setFixedWidth(needed_width)
             self.image_area_widget.setFixedWidth(needed_width)
             self.right_area.updateGeometry()

shinestacker/gui/main_window.py

@@ -3,9 +3,9 @@
 import os
 import subprocess
 from PySide6.QtCore import Qt
-from PySide6.QtGui import QGuiApplication, QAction, QIcon
+from PySide6.QtGui import QGuiApplication, QAction, QPalette
 from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, QMessageBox,
-                               QSplitter, QToolBar, QMenu, QMainWindow)
+                               QSplitter, QToolBar, QMenu, QMainWindow, QApplication)
 from .. config.constants import constants
 from .. config.app_config import AppConfig
 from .. core.core_utils import running_under_windows, running_under_macos
@@ -82,7 +82,9 @@ class MainWindow(QMainWindow, LogManager):
             "Run Job": self.run_job,
             "Run All Jobs": self.run_all_jobs,
         }
-        self.menu_manager = MenuManager(self.menuBar(), actions, self.project_editor, self)
+        dark_theme = self.is_dark_theme()
+        self.menu_manager = MenuManager(
+            self.menuBar(), actions, self.project_editor, dark_theme, self)
         self.script_dir = os.path.dirname(__file__)
         self._windows = []
         self._workers = []
@@ -107,7 +109,7 @@ class MainWindow(QMainWindow, LogManager):
         top_widget = QWidget()
         top_widget.setLayout(h_layout)
         h_splitter.addWidget(top_widget)
-        self.tab_widget = TabWidgetWithPlaceholder()
+        self.tab_widget = TabWidgetWithPlaceholder(dark_theme)
         self.tab_widget.resize(1000, 500)
         h_splitter.addWidget(self.tab_widget)
         self.job_list().currentRowChanged.connect(self.project_editor.on_job_selected)
@@ -128,6 +130,7 @@ class MainWindow(QMainWindow, LogManager):
         layout.addWidget(h_splitter)
         self.central_widget.setLayout(layout)
         self.update_title()
+        QApplication.instance().paletteChanged.connect(self.on_theme_changed)
 
         def handle_modified(modified):
             self.save_actions_set_enabled(modified)
@@ -367,9 +370,6 @@ class MainWindow(QMainWindow, LogManager):
             menu.exec(event.globalPos())
     # pylint: enable=C0103
 
-    def get_icon(self, icon):
-        return QIcon(os.path.join(self.script_dir, f"img/{icon}.png"))
-
     def get_retouch_path(self, job):
         frames_path = [get_action_output_path(action)[0]
                        for action in job.sub_actions
@@ -581,3 +581,16 @@ class MainWindow(QMainWindow, LogManager):
         for action in self.findChildren(QAction):
             if action.property("requires_file"):
                 action.setEnabled(enabled)
+
+    def is_dark_theme(self):
+        palette = QApplication.palette()
+        window_color = palette.color(QPalette.Window)
+        brightness = (window_color.red() * 0.299 +
+                      window_color.green() * 0.587 +
+                      window_color.blue() * 0.114)
+        return brightness < 128
+
+    def on_theme_changed(self):
+        dark_theme = self.is_dark_theme()
+        self.menu_manager.change_theme(dark_theme)
+        self.tab_widget.change_theme(dark_theme)

shinestacker/gui/menu_manager.py

@@ -1,4 +1,4 @@
-# pylint: disable=C0114, C0115, C0116, R0904, E0611, R0902, W0201
+# pylint: disable=C0114, C0115, C0116, R0904, E0611, R0902, W0201, R0913, R0917
 import os
 from functools import partial
 from PySide6.QtCore import Signal, QObject
@@ -12,11 +12,12 @@ from .recent_file_manager import RecentFileManager
 class MenuManager(QObject):
     open_file_requested = Signal(str)
 
-    def __init__(self, menubar, actions, project_editor, parent):
+    def __init__(self, menubar, actions, project_editor, dark_theme, parent):
         super().__init__(parent)
         self.script_dir = os.path.dirname(__file__)
         self._recent_file_manager = RecentFileManager("shinestacker-recent-project-files.txt")
         self.project_editor = project_editor
+        self.dark_theme = dark_theme
         self.parent = parent
         self.menubar = menubar
         self.actions = actions
@@ -58,8 +59,9 @@ class MenuManager(QObject):
             "Run All Jobs": "Run all jobs",
         }
 
-    def get_icon(self, icon):
-        return QIcon(os.path.join(self.script_dir, f"img/{icon}.png"))
+    def get_icon(self, icon_name):
+        icon_dir = 'dark' if self.dark_theme else 'light'
+        return QIcon(os.path.join(self.script_dir, f"img/{icon_dir}/{icon_name}.png"))
 
     def action(self, name, requires_file=False):
         action = QAction(name, self.parent)
@@ -68,9 +70,11 @@ class MenuManager(QObject):
         shortcut = self.shortcuts.get(name, '')
         if shortcut:
             action.setShortcut(shortcut)
-        icon = self.icons.get(name, '')
-        if icon:
-            action.setIcon(self.get_icon(icon))
+        icon_name = self.icons.get(name, '')
+        if icon_name:
+            action.setIcon(self.get_icon(icon_name))
+            action.setProperty('theme_dependent', True)
+            action.setProperty('base_icon_name', icon_name)
         tooltip = self.tooltips.get(name, '')
         if tooltip:
             action.setToolTip(tooltip)
@@ -79,6 +83,13 @@ class MenuManager(QObject):
             action.triggered.connect(action_fun)
         return action
 
+    def change_theme(self, dark_theme):
+        self.dark_theme = dark_theme
+        for action in self.parent.findChildren(QAction):
+            if action.property("theme_dependent"):
+                base_name = action.property("base_icon_name")
+                action.setIcon(self.get_icon(base_name))
+
     def update_recent_files(self):
         self.recent_files_menu.clear()
         recent_files = self._recent_file_manager.get_files_with_display_names()

shinestacker/gui/new_project.py

@@ -169,13 +169,11 @@ class NewProjectDialog(BaseFormDialog):
                 border-radius: 5px;
                 margin-top: 10px;
                 padding-top: 15px;
-                background-color: #f8f8f8;
             }
             QGroupBox::title {
                 subcontrol-origin: margin;
                 left: 10px;
                 padding: 0 5px 0 5px;
-                background-color: #f8f8f8;
             }
         """
         for group in [step1_group, step2_group, step3_group, step4_group]:

shinestacker/gui/tab_widget.py

@@ -3,15 +3,16 @@ 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):
+    def __init__(self, dark_theme, parent=None):
         super().__init__(parent)
+        self.script_dir = os.path.dirname(__file__)
+        self.dark_theme = dark_theme
         self.main_layout = QVBoxLayout(self)
         self.main_layout.setContentsMargins(0, 0, 0, 0)
         self.stacked_widget = QStackedWidget()
@@ -20,10 +21,15 @@ class TabWidgetWithPlaceholder(QWidget):
         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}'
+        self.set_bkg_icon()
+        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 set_bkg_icon(self):
+        icon_dir = 'dark' if self.dark_theme else 'light'
+        icon_path = os.path.join(self.script_dir, f"img/{icon_dir}/shinestacker_bkg.png")
         if os.path.exists(icon_path):
             pixmap = QPixmap(icon_path)
             pixmap = pixmap.scaled(250, 250, Qt.AspectRatioMode.KeepAspectRatio,
@@ -31,10 +37,10 @@ class TabWidgetWithPlaceholder(QWidget):
             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 change_theme(self, dark_theme):
+        self.dark_theme = dark_theme
+        self.set_bkg_icon()
 
     def _on_current_changed(self, index):
         self.currentChanged.emit(index)

shinestacker/retouch/adjustments.py

@@ -0,0 +1,98 @@
+# pylint: disable=C0114, C0115, C0116, E0611, W0221, R0913, R0917, R0902, R0914, E1101
+from abc import abstractmethod
+import math
+import cv2
+from .base_filter import BaseFilter
+from .. algorithms.utils import bgr_to_hls, hls_to_bgr
+from .. algorithms.corrections import gamma_correction, contrast_correction
+
+
+class GammaSCurveFilter(BaseFilter):
+    def __init__(
+            self, name, parent, image_viewer, layer_collection, undo_manager,
+            window_title, gamma_label, scurve_label):
+        super().__init__(name, parent, image_viewer, layer_collection, undo_manager,
+                         preview_at_startup=True)
+        self.window_title = window_title
+        self.gamma_label = gamma_label
+        self.scurve_label = scurve_label
+        self.min_gamma = -1
+        self.max_gamma = +1
+        self.initial_gamma = 0
+        self.min_scurve = -1
+        self.max_scurve = 1
+        self.initial_scurve = 0
+        self.lumi_slider = None
+        self.contrast_slider = None
+
+    @abstractmethod
+    def apply(self, image, *params):
+        pass
+
+    def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
+        dlg.setWindowTitle(self.window_title)
+        dlg.setMinimumWidth(600)
+        params = {
+            self.gamma_label: (self.min_gamma, self.max_gamma, self.initial_gamma, "{:.1%}"),
+            self.scurve_label: (self.min_scurve, self.max_scurve, self.initial_scurve, "{:.1%}"),
+        }
+
+        def set_slider(name, slider):
+            if name == self.gamma_label:
+                self.lumi_slider = slider
+            elif name == self.scurve_label:
+                self.contrast_slider = slider
+
+        value_labels = self.create_sliders(params, dlg, layout, set_slider)
+
+        def update_value(name, slider_value, min_val, max_val, fmt):
+            value = self.value_from_slider(slider_value, min_val, max_val)
+            value_labels[name].setText(fmt.format(value))
+            if self.preview_check.isChecked():
+                self.preview_timer.start()
+
+        self.lumi_slider.valueChanged.connect(
+            lambda v: update_value(
+                self.gamma_label, v, self.min_gamma,
+                self.max_gamma, params[self.gamma_label][3]))
+        self.contrast_slider.valueChanged.connect(
+            lambda v: update_value(
+                self.scurve_label, v, self.min_scurve,
+                self.max_scurve, params[self.scurve_label][3]))
+        self.set_timer(do_preview, restore_original, dlg)
+
+    def get_params(self):
+        return (
+            self.value_from_slider(
+                self.lumi_slider.value(), self.min_gamma, self.max_gamma),
+            self.value_from_slider(
+                self.contrast_slider.value(), self.min_scurve, self.max_scurve)
+        )
+
+
+class LumiContrastFilter(GammaSCurveFilter):
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager):
+        super().__init__(
+            name, parent, image_viewer, layer_collection, undo_manager,
+            "Luminosity, Contrast", "Luminosity", "Constrat")
+
+    def apply(self, image, luminosity, contrast):
+        img_corr = contrast_correction(image, 0.5 * contrast)
+        img_corr = gamma_correction(img_corr, math.exp(0.5 * luminosity))
+        return img_corr
+
+
+class SaturationVibranceFilter(GammaSCurveFilter):
+    def __init__(self, name, parent, image_viewer, layer_collection, undo_manager):
+        super().__init__(
+            name, parent, image_viewer, layer_collection, undo_manager,
+            "Saturation, Vibrance", "Saturation", "Vibrance")
+
+    def apply(self, image, stauration, vibrance):
+        img_corr = bgr_to_hls(image)
+        h, l, s = cv2.split(img_corr)
+        s_corr = contrast_correction(s, - vibrance)
+        s_corr = gamma_correction(s_corr, math.exp(0.5 * stauration))
+        img_corr = cv2.merge([h, l, s_corr])
+        img_corr = hls_to_bgr(img_corr)
+        return img_corr

shinestacker/retouch/base_filter.py

@@ -3,6 +3,7 @@ import traceback
 from abc import abstractmethod
 import numpy as np
 from PySide6.QtCore import Qt, QThread, QTimer, QObject, Signal
+from PySide6.QtGui import QFontMetrics
 from PySide6.QtWidgets import (
     QHBoxLayout, QLabel, QSlider, QDialog, QVBoxLayout, QCheckBox, QDialogButtonBox)
 from .layer_collection import LayerCollectionHandler
@@ -27,6 +28,7 @@ class BaseFilter(QObject, LayerCollectionHandler):
         self.preview_check = None
         self.button_box = None
         self.preview_timer = None
+        self.max_range = 500
 
     @abstractmethod
     def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
@@ -40,6 +42,47 @@ class BaseFilter(QObject, LayerCollectionHandler):
     def apply(self, image, *params):
         pass
 
+    def slider_from_value(self, value, min_val, max_val):
+        return (value - min_val) / (max_val - min_val) * self.max_range
+
+    def value_from_slider(self, slider_value, min_val, max_val):
+        return min_val + (max_val - min_val) * float(slider_value) / self.max_range
+
+    def create_sliders(self, params, dlg, layout, set_slider):
+        value_labels = {}
+        font_metrics = QFontMetrics(dlg.font())
+        max_name_width = 0
+        max_value_width = 0
+        for name, (min_val, max_val, init_val, fmt) in params.items():
+            name_width = font_metrics.horizontalAdvance(f"{name}:")
+            max_name_width = max(max_name_width, name_width)
+            sample_values = [min_val, max_val, init_val]
+            for val in sample_values:
+                value_width = font_metrics.horizontalAdvance(fmt.format(val))
+                max_value_width = max(max_value_width, value_width)
+        max_name_width += 10
+        max_value_width += 10
+        for name, (min_val, max_val, init_val, fmt) in params.items():
+            param_layout = QHBoxLayout()
+            name_label = QLabel(f"{name}:")
+            name_label.setFixedWidth(max_name_width)
+            name_label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            param_layout.addWidget(name_label)
+            slider = QSlider(Qt.Horizontal)
+            slider.setRange(0, self.max_range)
+            slider.setValue(self.slider_from_value(init_val, min_val, max_val))
+            param_layout.addWidget(slider, 1)
+            value_label = QLabel(fmt.format(init_val))
+            value_label.setFixedWidth(max_value_width)
+            value_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
+            param_layout.addWidget(value_label)
+            layout.addLayout(param_layout)
+            set_slider(name, slider)
+            value_labels[name] = value_label
+        self.create_base_widgets(
+            layout, QDialogButtonBox.Ok | QDialogButtonBox.Cancel, 200, dlg)
+        return value_labels
+
     def connect_signals(self, update_master_thumbnail, mark_as_modified, filter_gui_set_enabled):
         self.update_master_thumbnail_requested.connect(update_master_thumbnail)
         self.mark_as_modified_requested.connect(mark_as_modified)
@@ -191,6 +234,13 @@ class BaseFilter(QObject, LayerCollectionHandler):
         self.preview_timer.setSingleShot(True)
         self.preview_timer.setInterval(preview_latency)
 
+    def set_timer(self, do_preview, restore_original, dlg):
+        self.preview_timer.timeout.connect(do_preview)
+        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)
+
     class PreviewWorker(QThread):
         finished = Signal(np.ndarray, int, tuple)
 
@@ -222,14 +272,14 @@ class BaseFilter(QObject, LayerCollectionHandler):
 
 class OneSliderBaseFilter(BaseFilter):
     def __init__(self, name, parent, image_viewer, layer_collection, undo_manager,
-                 max_value, initial_value, title,
+                 min_value, max_value, initial_value, title,
                  allow_partial_preview=True, partial_preview_threshold=0.5,
                  preview_at_startup=True):
         super().__init__(name, parent, image_viewer, layer_collection, undo_manager,
                          allow_partial_preview,
                          partial_preview_threshold, preview_at_startup)
-        self.max_range = 500
         self.max_value = max_value
+        self.min_value = min_value
         self.initial_value = initial_value
         self.slider = None
         self.value_label = None
@@ -239,6 +289,13 @@ class OneSliderBaseFilter(BaseFilter):
     def add_widgets(self, layout, dlg):
         pass
 
+    def slider_from_value_1(self, value):
+        return int((value - self.min_value) / (self.max_value - self.min_value) * self.max_range)
+
+    def value_from_slider_1(self, slider_value):
+        return self.min_value + \
+            (self.max_value - self.min_value) * float(slider_value) / self.max_range
+
     def setup_ui(self, dlg, layout, do_preview, restore_original, **kwargs):
         dlg.setWindowTitle(self.title)
         dlg.setMinimumWidth(600)
@@ -246,7 +303,7 @@ class OneSliderBaseFilter(BaseFilter):
         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_local.setValue(self.slider_from_value_1(self.initial_value))
         slider_layout.addWidget(slider_local)
         self.value_label = QLabel(self.format.format(self.initial_value))
         slider_layout.addWidget(self.value_label)
@@ -254,9 +311,7 @@ class OneSliderBaseFilter(BaseFilter):
         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.connect_preview_toggle(
             self.preview_check, self.do_preview_delayed, restore_original)
@@ -269,7 +324,7 @@ class OneSliderBaseFilter(BaseFilter):
             self.do_preview_delayed()
 
     def config_changed(self, val):
-        float_val = self.max_value * float(val) / self.max_range
+        float_val = self.value_from_slider_1(val)
         self.value_label.setText(self.format.format(float_val))
         self.param_changed(val)
 
@@ -277,7 +332,7 @@ class OneSliderBaseFilter(BaseFilter):
         self.preview_timer.start()
 
     def get_params(self):
-        return (self.max_value * self.slider.value() / self.max_range,)
+        return (self.value_from_slider_1(self.slider.value()),)
 
     def apply(self, image, *params):
         assert False