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

shinestacker/__init__.py

@@ -3,14 +3,14 @@ from ._version import __version__
 from . import config
 from . import core
 from . import algorithms
-from .config import __all__
-from .core import __all__
-from .algorithms import __all__
+from .config import __all__ as config_all
+from .core import __all__ as core_all
+from .algorithms import __all__ as algorithms_all
 from .config import *
 from .core import *
 from .algorithms import *
 
 __all__ = ['__version__']
-#__all__ += config.__all__
-#__all__ += core.__all__
-#__all__ += algorithms.__all__
+__all__ += config_all
+__all__ += core_all
+__all__ += algorithms_all

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '0.3.1'
+__version__ = '0.3.3'

shinestacker/algorithms/balance.py

@@ -133,17 +133,16 @@ class Correction:
         self.corrections = np.ones((size, self.channels))
 
     def calc_hist_1ch(self, image):
+        img_subsample = image if self.subsample == 1 else image[::self.subsample, ::self.subsample]
         if self.mask_size == 0:
-            image_sel = image
+            image_sel = img_subsample
         else:
-            height, width = image.shape[:2]
+            height, width = img_subsample.shape[:2]
             xv, yv = np.meshgrid(np.linspace(0, width - 1, width), np.linspace(0, height - 1, height))
             mask_radius = (min(width, height) * self.mask_size / 2)
-            image_sel = image[(xv - width / 2) ** 2 + (yv - height / 2) ** 2 <= mask_radius ** 2]
-        hist, bins = np.histogram((image_sel if self.subsample == 1
-                                   else image_sel[::self.subsample, ::self.subsample]),
-                                  bins=np.linspace(-0.5, self.num_pixel_values - 0.5,
-                                                   self.num_pixel_values + 1))
+            image_sel = img_subsample[(xv - width / 2) ** 2 + (yv - height / 2) ** 2 <= mask_radius ** 2]
+        hist, bins = np.histogram(image_sel, bins=np.linspace(-0.5, self.num_pixel_values - 0.5,
+                                                               self.num_pixel_values + 1))
         return hist
 
     def balance(self, image, idx):

shinestacker/algorithms/noise_detection.py

@@ -86,6 +86,8 @@ class NoiseDetection(FrameMultiDirectory, JobBase):
             progress_callback=progress_callback)
         if not config.DISABLE_TQDM:
             self.bar.close()
+        if mean_img is None:
+            raise RuntimeError("Mean image is None")
         blurred = cv2.GaussianBlur(mean_img, (self.blur_size, self.blur_size), 0)
         diff = cv2.absdiff(mean_img, blurred)
         channels = cv2.split(diff)

shinestacker/app/open_frames.py

@@ -5,15 +5,17 @@ from PySide6.QtCore import QTimer
 
 def open_files(editor, filenames):
     if len(filenames) == 1:
-        QTimer.singleShot(100, lambda: editor.open_file(filenames[0]))
+        QTimer.singleShot(100, lambda: editor.io_gui_handler.open_file(filenames[0]))
     else:
         def check_thread():
-            if editor.loader_thread is None or editor.loader_thread.isRunning():
+            thread = editor.io_gui_handler.loader_thread
+            if thread is None or thread.isRunning():
                 QTimer.singleShot(100, check_thread)
             else:
-                editor.import_frames_from_files(filenames[1:])
+                editor.io_gui_handler.import_frames_from_files(filenames[1:])
+
         QTimer.singleShot(100, lambda: (
-            editor.open_file(filenames[0]),
+            editor.io_gui_handler.open_file(filenames[0]),
             QTimer.singleShot(100, check_thread)
         ))
 

shinestacker/config/__init__.py

@@ -1,6 +1,7 @@
 # flake8: noqa F401
+# pylint: disable=C0114
 from .config import config
 from .constants import constants
 from .gui_constants import gui_constants
 
-__all__ = ['config', 'constants', 'gui_constants']
+__all__ = ['config', 'constants', 'gui_constants']

shinestacker/config/config.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, C0103, R0903, W0718, W0104, W0201, E0602
 class _Config:
     _initialized = False
     _instance = None

shinestacker/config/constants.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, C0103, R0903
 import sys
 import re
 

shinestacker/config/gui_constants.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, C0103, R0903
 import math
 
 

shinestacker/core/__init__.py

@@ -1,11 +1,12 @@
 # flake8: noqa F401
+# pylint: disable=C0114
 from .logging import setup_logging
-from .exceptions import (FocusStackError, InvalidOptionError, ImageLoadError, ImageSaveError, AlignmentError,
-                         BitDepthError, ShapeError, RunStopException)
+from .exceptions import (FocusStackError, InvalidOptionError, ImageLoadError, ImageSaveError,
+                         AlignmentError, BitDepthError, ShapeError, RunStopException)
 from .framework import Job
 
 __all__ = [
     'setup_logging',
     'FocusStackError', 'InvalidOptionError', 'ImageLoadError', 'ImageSaveError',
     'AlignmentError','BitDepthError', 'ShapeError', 'RunStopException',
-    'Job']
+    'Job']

shinestacker/core/colors.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0116, C0201
 COLORS = {
     "black": 30,
     "red": 31,

shinestacker/core/core_utils.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0116, C0201
 import os
 import sys
 import platform
@@ -10,18 +11,17 @@ if not config.DISABLE_TQDM:
 
 def check_path_exists(path):
     if not os.path.exists(path):
-        raise Exception('Path does not exist: ' + path)
+        raise RuntimeError('Path does not exist: ' + path)
 
 
 def make_tqdm_bar(name, size, ncols=80):
     if not config.DISABLE_TQDM:
         if config.JUPYTER_NOTEBOOK:
-            bar = tqdm_notebook(desc=name, total=size)
+            tbar = tqdm_notebook(desc=name, total=size)
         else:
-            bar = tqdm(desc=name, total=size, ncols=ncols)
-        return bar
-    else:
-        return None
+            tbar = tqdm(desc=name, total=size, ncols=ncols)
+        return tbar
+    return None
 
 
 def get_app_base_path():

shinestacker/core/exceptions.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0301
 class FocusStackError(Exception):
     pass
 

shinestacker/core/framework.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116
 import time
 import logging
 from .. config.config import config
@@ -57,7 +58,7 @@ def elapsed_time_str(start):
     ss = dt - mm * 60
     hh = mm // 60
     mm -= hh * 60
-    return ("{:02d}:{:02d}:{:05.2f}s".format(hh, mm, ss))
+    return "{:02d}:{:02d}:{:05.2f}s".format(hh, mm, ss)
 
 
 class JobBase:

shinestacker/gui/action_config.py

@@ -22,8 +22,9 @@ FIELD_TYPES = [FIELD_TEXT, FIELD_ABS_PATH, FIELD_REL_PATH, FIELD_FLOAT,
 
 
 class ActionConfigurator(ABC):
-    def __init__(self, expert=False):
+    def __init__(self, expert, current_wd):
         self.expert = expert
+        self.current_wd = current_wd
 
     @abstractmethod
     def create_form(self, layout: QFormLayout, params: Dict[str, Any]):
@@ -35,9 +36,10 @@ class ActionConfigurator(ABC):
 
 
 class FieldBuilder:
-    def __init__(self, layout, action):
+    def __init__(self, layout, action, current_wd):
         self.layout = layout
         self.action = action
+        self.current_wd = current_wd
         self.fields = {}
 
     def add_field(self, tag: str, field_type: str, label: str,
@@ -159,6 +161,9 @@ class FieldBuilder:
             if field['type'] == FIELD_REL_PATH and 'working_path' in params:
                 try:
                     working_path = self.get_working_path()
+                    working_path_abs = os.path.isabs(working_path)
+                    if not working_path_abs:
+                        working_path = os.path.join(self.current_wd, working_path)
                     abs_path = os.path.normpath(os.path.join(working_path, params[tag]))
                     if not abs_path.startswith(os.path.normpath(working_path)):
                         QMessageBox.warning(None, "Invalid Path",
@@ -370,8 +375,9 @@ class FieldBuilder:
 
 
 class ActionConfigDialog(QDialog):
-    def __init__(self, action: ActionConfig, parent=None):
+    def __init__(self, action: ActionConfig, current_wd, parent=None):
         super().__init__(parent)
+        self.current_wd = current_wd
         self.action = action
         self.setWindowTitle(f"Configure {action.type_name}")
         self.resize(500, self.height())
@@ -397,18 +403,18 @@ class ActionConfigDialog(QDialog):
 
     def get_configurator(self, action_type: str) -> ActionConfigurator:
         configurators = {
-            constants.ACTION_JOB: JobConfigurator(self.expert()),
-            constants.ACTION_COMBO: CombinedActionsConfigurator(self.expert()),
-            constants.ACTION_NOISEDETECTION: NoiseDetectionConfigurator(self.expert()),
-            constants.ACTION_FOCUSSTACK: FocusStackConfigurator(self.expert()),
-            constants.ACTION_FOCUSSTACKBUNCH: FocusStackBunchConfigurator(self.expert()),
-            constants.ACTION_MULTILAYER: MultiLayerConfigurator(self.expert()),
-            constants.ACTION_MASKNOISE: MaskNoiseConfigurator(self.expert()),
-            constants.ACTION_VIGNETTING: VignettingConfigurator(self.expert()),
-            constants.ACTION_ALIGNFRAMES: AlignFramesConfigurator(self.expert()),
-            constants.ACTION_BALANCEFRAMES: BalanceFramesConfigurator(self.expert()),
+            constants.ACTION_JOB: JobConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_COMBO: CombinedActionsConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_NOISEDETECTION: NoiseDetectionConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_FOCUSSTACK: FocusStackConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_FOCUSSTACKBUNCH: FocusStackBunchConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_MULTILAYER: MultiLayerConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_MASKNOISE: MaskNoiseConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_VIGNETTING: VignettingConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_ALIGNFRAMES: AlignFramesConfigurator(self.expert(), self.current_wd),
+            constants.ACTION_BALANCEFRAMES: BalanceFramesConfigurator(self.expert(), self.current_wd),
         }
-        return configurators.get(action_type, DefaultActionConfigurator(self.expert()))
+        return configurators.get(action_type, DefaultActionConfigurator(self.expert(), self.current_wd))
 
     def accept(self):
         self.parent()._project_buffer.append(self.parent().project.clone())
@@ -428,8 +434,8 @@ class ActionConfigDialog(QDialog):
 
 
 class NoNameActionConfigurator(ActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def get_builder(self):
         return self.builder
@@ -444,17 +450,17 @@ class NoNameActionConfigurator(ActionConfigurator):
 
 
 class DefaultActionConfigurator(NoNameActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action, tag='Action'):
-        self.builder = FieldBuilder(layout, action)
+        self.builder = FieldBuilder(layout, action, self.current_wd)
         self.builder.add_field('name', FIELD_TEXT, f'{tag} name', required=True)
 
 
 class JobConfigurator(DefaultActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         super().create_form(layout, action, "Job")
@@ -464,8 +470,8 @@ class JobConfigurator(DefaultActionConfigurator):
 
 
 class NoiseDetectionConfigurator(DefaultActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         super().create_form(layout, action)
@@ -492,8 +498,8 @@ class NoiseDetectionConfigurator(DefaultActionConfigurator):
 
 
 class FocusStackBaseConfigurator(DefaultActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     ENERGY_OPTIONS = ['Laplacian', 'Sobel']
     MAP_TYPE_OPTIONS = ['Average', 'Maximum']
@@ -583,8 +589,8 @@ class FocusStackBaseConfigurator(DefaultActionConfigurator):
 
 
 class FocusStackConfigurator(FocusStackBaseConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         super().create_form(layout, action)
@@ -599,8 +605,8 @@ class FocusStackConfigurator(FocusStackBaseConfigurator):
 
 
 class FocusStackBunchConfigurator(FocusStackBaseConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         super().create_form(layout, action)
@@ -614,8 +620,8 @@ class FocusStackBunchConfigurator(FocusStackBaseConfigurator):
 
 
 class MultiLayerConfigurator(DefaultActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         super().create_form(layout, action)
@@ -635,8 +641,8 @@ class MultiLayerConfigurator(DefaultActionConfigurator):
 
 
 class CombinedActionsConfigurator(DefaultActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         DefaultActionConfigurator.create_form(self, layout, action)
@@ -659,8 +665,8 @@ class CombinedActionsConfigurator(DefaultActionConfigurator):
 
 
 class MaskNoiseConfigurator(NoNameActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         DefaultActionConfigurator.create_form(self, layout, action)
@@ -675,8 +681,8 @@ class MaskNoiseConfigurator(NoNameActionConfigurator):
 
 
 class VignettingConfigurator(NoNameActionConfigurator):
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         DefaultActionConfigurator.create_form(self, layout, action)
@@ -699,8 +705,8 @@ class AlignFramesConfigurator(NoNameActionConfigurator):
     METHOD_OPTIONS = ['Random Sample Consensus (RANSAC)', 'Least Median (LMEDS)']
     MATCHING_METHOD_OPTIONS = ['K-nearest neighbors', 'Hamming distance']
 
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def show_info(self, message, timeout=3000):
         self.info_label.setText(message)
@@ -713,7 +719,6 @@ class AlignFramesConfigurator(NoNameActionConfigurator):
         match_method = {k: v for k, v in zip(self.MATCHING_METHOD_OPTIONS,
                                              constants.VALID_MATCHING_METHODS)}[self.matching_method_field.currentText()]
         try:
-            print(detector, descriptor, match_method)
             validate_align_config(detector, descriptor, match_method)
         except Exception as e:
             self.show_info(str(e))
@@ -855,8 +860,8 @@ class BalanceFramesConfigurator(NoNameActionConfigurator):
     CORRECTION_MAP_OPTIONS = ['Linear', 'Gamma', 'Match histograms']
     CHANNEL_OPTIONS = ['Luminosity', 'RGB', 'HSV', 'HLS']
 
-    def __init__(self, expert=False):
-        super().__init__(expert)
+    def __init__(self, expert, current_wd):
+        super().__init__(expert, current_wd)
 
     def create_form(self, layout, action):
         DefaultActionConfigurator.create_form(self, layout, action)

shinestacker/gui/actions_window.py

@@ -126,7 +126,11 @@ class ActionsWindow(ProjectEditor):
             file_path, _ = QFileDialog.getOpenFileName(self, "Open Project", "", "Project Files (*.fsp);;All Files (*)")
         if file_path:
             try:
-                self._current_file_wd = '' if os.path.isabs(file_path) else os.getcwd()
+                self._current_file = file_path
+                self._current_file_wd = '' if os.path.isabs(file_path) else os.path.dirname(file_path)
+                if not os.path.isabs(self._current_file_wd):
+                    self._current_file_wd = os.path.abspath(self._current_file_wd)
+                    self._current_file = os.path.basename(self._current_file)
                 file = open(file_path, 'r')
                 pp = file_path.split('/')
                 if len(pp) > 1:
@@ -137,7 +141,6 @@ class ActionsWindow(ProjectEditor):
                     raise RuntimeError(f"Project from file {file_path} produced a null project.")
                 self.set_project(project)
                 self._modified_project = False
-                self._current_file = file_path
                 self.update_title()
                 self.refresh_ui(0, -1)
                 if self.job_list.count() > 0:
@@ -223,7 +226,7 @@ class ActionsWindow(ProjectEditor):
         index = self.job_list.row(item)
         if 0 <= index < len(self.project.jobs):
             job = self.project.jobs[index]
-            dialog = ActionConfigDialog(job, self)
+            dialog = ActionConfigDialog(job, self._current_file_wd, self)
             if dialog.exec() == QDialog.Accepted:
                 current_row = self.job_list.currentRow()
                 if current_row >= 0:
@@ -255,7 +258,7 @@ class ActionsWindow(ProjectEditor):
             if current_action:
                 if not is_sub_action:
                     self.set_enabled_sub_actions_gui(current_action.type_name == constants.ACTION_COMBO)
-                dialog = ActionConfigDialog(current_action, self)
+                dialog = ActionConfigDialog(current_action, self._current_file_wd, self)
                 if dialog.exec() == QDialog.Accepted:
                     self.on_job_selected(job_index)
                     self.refresh_ui()
@@ -277,7 +280,7 @@ class ActionsWindow(ProjectEditor):
             self.edit_action(current_action)
 
     def edit_action(self, action):
-        dialog = ActionConfigDialog(action, self)
+        dialog = ActionConfigDialog(action, self._current_file_wd, self)
         if dialog.exec() == QDialog.Accepted:
             self.on_job_selected(self.job_list.currentRow())
             self.mark_as_modified()

shinestacker/retouch/brush_preview.py

@@ -43,7 +43,6 @@ class BrushPreviewItem(QGraphicsPixmapItem):
     def __init__(self):
         super().__init__()
         self.layer_collection = None
-        self.brush = None
         self.setVisible(False)
         self.setZValue(500)
         self.setTransformationMode(Qt.SmoothTransformation)
@@ -72,22 +71,22 @@ class BrushPreviewItem(QGraphicsPixmapItem):
 
     def update(self, scene_pos, size):
         try:
-            if self.layer_collection.layer_stack is None or size <= 0:
+            if self.layer_collection is None or self.number_of_layers() == 0 or size <= 0:
                 self.hide()
                 return
             radius = size // 2
             x = int(scene_pos.x() - radius + 0.5)
             y = int(scene_pos.y() - radius)
             w = h = size
-            if not self.layer_collection.valid_current_layer_idx():
+            if not self.valid_current_layer_idx():
                 self.hide()
                 return
-            layer_area = self.get_layer_area(self.layer_collection.current_layer(), x, y, w, h)
-            master_area = self.get_layer_area(self.layer_collection.master_layer, x, y, w, h)
+            layer_area = self.get_layer_area(self.current_layer(), x, y, w, h)
+            master_area = self.get_layer_area(self.master_layer(), x, y, w, h)
             if layer_area is None or master_area is None:
                 self.hide()
                 return
-            height, width = self.layer_collection.current_layer().shape[:2]
+            height, width = self.current_layer().shape[:2]
             full_mask = create_brush_mask(size=size, hardness_percent=self.brush.hardness,
                                           opacity_percent=self.brush.opacity)[:, :, np.newaxis]
             mask_x_start = max(0, -x) if x < 0 else 0

shinestacker/retouch/brush_tool.py

@@ -0,0 +1,164 @@
+import numpy as np
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush
+from PySide6.QtCore import Qt, QPoint
+from .brush_gradient import create_brush_gradient
+from .. config.gui_constants import gui_constants
+from .. config.constants import constants
+from .brush_preview import create_brush_mask
+
+
+class BrushTool:
+    def __init__(self):
+        self.brush = None
+        self.brush_preview = None
+        self.image_viewer = None
+        self.size_slider = None
+        self.hardness_slider = None
+        self.opacity_slider = None
+        self.flow_slider = None
+        self._brush_mask_cache = {}
+
+    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.image_viewer = image_viewer
+        self.size_slider = size_slider
+        self.hardness_slider = hardness_slider
+        self.opacity_slider = opacity_slider
+        self.flow_slider = flow_slider
+        self.size_slider.valueChanged.connect(self.update_brush_size)
+        self.hardness_slider.valueChanged.connect(self.update_brush_hardness)
+        self.opacity_slider.valueChanged.connect(self.update_brush_opacity)
+        self.flow_slider.valueChanged.connect(self.update_brush_flow)
+        self.update_brush_size(self.size_slider.value())
+        self.update_brush_hardness(self.hardness_slider.value())
+        self.update_brush_opacity(self.opacity_slider.value())
+        self.update_brush_flow(self.flow_slider.value())
+
+    def update_brush_size(self, slider_val):
+
+        def slider_to_brush_size(slider_val):
+            normalized = slider_val / gui_constants.BRUSH_SIZE_SLIDER_MAX
+            size = gui_constants.BRUSH_SIZES['min'] + \
+                gui_constants.BRUSH_SIZES['max'] * (normalized ** gui_constants.BRUSH_GAMMA)
+            return max(gui_constants.BRUSH_SIZES['min'], min(gui_constants.BRUSH_SIZES['max'], size))
+
+        self.brush.size = slider_to_brush_size(slider_val)
+        self.update_brush_thumb()
+
+    def increase_brush_size(self, amount=5):
+        val = min(self.size_slider.value() + amount, self.size_slider.maximum())
+        self.size_slider.setValue(val)
+        self.update_brush_size(val)
+
+    def decrease_brush_size(self, amount=5):
+        val = max(self.size_slider.value() - amount, self.size_slider.minimum())
+        self.size_slider.setValue(val)
+        self.update_brush_size(val)
+
+    def increase_brush_hardness(self, amount=2):
+        val = min(self.hardness_slider.value() + amount, self.hardness_slider.maximum())
+        self.hardness_slider.setValue(val)
+        self.update_brush_hardness(val)
+
+    def decrease_brush_hardness(self, amount=2):
+        val = max(self.hardness_slider.value() - amount, self.hardness_slider.minimum())
+        self.hardness_slider.setValue(val)
+        self.update_brush_hardness(val)
+
+    def update_brush_hardness(self, hardness):
+        self.brush.hardness = hardness
+        self.update_brush_thumb()
+
+    def update_brush_opacity(self, opacity):
+        self.brush.opacity = opacity
+        self.update_brush_thumb()
+
+    def update_brush_flow(self, flow):
+        self.brush.flow = flow
+        self.update_brush_thumb()
+
+    def update_brush_thumb(self):
+        width, height = gui_constants.UI_SIZES['brush_preview']
+        pixmap = QPixmap(width, height)
+        pixmap.fill(Qt.transparent)
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.Antialiasing)
+        preview_size = min(self.brush.size, width + 30, height + 30)
+        center_x, center_y = width // 2, height // 2
+        radius = preview_size // 2
+        if self.image_viewer.cursor_style == 'preview':
+            gradient = create_brush_gradient(
+                center_x, center_y, radius,
+                self.brush.hardness,
+                inner_color=QColor(*gui_constants.BRUSH_COLORS['inner']),
+                outer_color=QColor(*gui_constants.BRUSH_COLORS['gradient_end']),
+                opacity=self.brush.opacity
+            )
+            painter.setBrush(QBrush(gradient))
+            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['outer']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+        elif self.image_viewer.cursor_style == 'outline':
+            painter.setBrush(Qt.NoBrush)
+            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['outer']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+        else:
+            painter.setBrush(QBrush(QColor(*gui_constants.BRUSH_COLORS['cursor_inner'])))
+            painter.setPen(QPen(QColor(*gui_constants.BRUSH_COLORS['pen']), gui_constants.BRUSH_PREVIEW_LINE_WIDTH))
+        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}%")
+        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):
+        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)
+        x_center = int(round(scene_pos.x()))
+        y_center = int(round(scene_pos.y()))
+        radius = int(round(self.brush.size // 2))
+        h, w = master_layer.shape[:2]
+        x_start, x_end = max(0, x_center - radius), min(w, x_center + radius + 1)
+        y_start, y_end = max(0, y_center - radius), min(h, y_center + radius + 1)
+        if x_start >= x_end or y_start >= y_end:
+            return 0, 0, 0, 0
+        mask = self.get_brush_mask(radius)
+        if mask is None:
+            return 0, 0, 0, 0
+        master_area = master_layer[y_start:y_end, x_start:x_end]
+        source_area = source_layer[y_start:y_end, x_start:x_end]
+        dest_area = dest_layer[y_start:y_end, x_start:x_end]
+        mask_layer_area = mask_layer[y_start:y_end, x_start:x_end]
+        mask_area = mask[y_start - (y_center - radius):y_end - (y_center - radius), x_start - (x_center - radius):x_end - (x_center - radius)]
+        mask_layer_area[:] = np.clip(mask_layer_area + mask_area * self.brush.flow / 100.0, 0.0, 1.0)  # np.maximum(mask_layer_area, mask_area)
+        self.apply_mask(master_area, source_area, mask_layer_area, dest_area)
+        return x_start, y_start, x_end, y_end
+
+    def get_brush_mask(self, radius):
+        mask_key = (radius, self.brush.hardness)
+        if mask_key not in self._brush_mask_cache.keys():
+            full_mask = create_brush_mask(size=radius * 2 + 1, hardness_percent=self.brush.hardness,
+                                          opacity_percent=self.brush.opacity)
+            self._brush_mask_cache[mask_key] = full_mask
+        return self._brush_mask_cache[mask_key]
+
+    def apply_mask(self, master_area, source_area, mask_area, dest_area):
+        opacity_factor = float(self.brush.opacity) / 100.0
+        effective_mask = np.clip(mask_area * opacity_factor, 0, 1)
+        dtype = master_area.dtype
+        max_px_value = constants.MAX_UINT16 if dtype == np.uint16 else constants.MAX_UINT8
+        if master_area.ndim == 3:
+            dest_area[:] = np.clip(master_area * (1 - effective_mask[..., np.newaxis]) + source_area * # noqa
+                                   effective_mask[..., np.newaxis], 0, max_px_value).astype(dtype)
+        else:
+            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()