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

shinestacker/gui/new_project.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0915, R0902
 import os
 from PySide6.QtWidgets import (QWidget, QLineEdit, QFormLayout, QHBoxLayout, QPushButton,
                                QDialog, QSizePolicy, QFileDialog, QLabel, QCheckBox,
@@ -6,6 +7,7 @@ from PySide6.QtGui import QIcon
 from PySide6.QtCore import Qt
 from .. config.gui_constants import gui_constants
 from .. config.constants import constants
+from .. algorithms.stack import get_bunches
 
 
 class NewProjectDialog(QDialog):
@@ -50,12 +52,14 @@ class NewProjectDialog(QDialog):
         self.layout.addRow(spacer)
         self.input_folder = QLineEdit()
         self.input_folder .setPlaceholderText('input files folder')
+        self.input_folder.textChanged.connect(self.update_bunches_label)
         button = QPushButton("Browse...")
 
         def browse():
             path = QFileDialog.getExistingDirectory(None, "Select input files folder")
             if path:
                 self.input_folder.setText(path)
+
         button.clicked.connect(browse)
         button.setAutoDefault(False)
         layout = QHBoxLayout()
@@ -74,9 +78,9 @@ class NewProjectDialog(QDialog):
         self.align_frames.setChecked(gui_constants.NEW_PROJECT_ALIGN_FRAMES)
         self.balance_frames = QCheckBox()
         self.balance_frames.setChecked(gui_constants.NEW_PROJECT_BALANCE_FRAMES)
+
         self.bunch_stack = QCheckBox()
         self.bunch_stack.setChecked(gui_constants.NEW_PROJECT_BUNCH_STACK)
-        self.bunch_stack.toggled.connect(self.update_bunch_options)
         self.bunch_frames = QSpinBox()
         bunch_frames_range = gui_constants.NEW_PROJECT_BUNCH_FRAMES
         self.bunch_frames.setRange(bunch_frames_range['min'], bunch_frames_range['max'])
@@ -85,7 +89,13 @@ class NewProjectDialog(QDialog):
         bunch_overlap_range = gui_constants.NEW_PROJECT_BUNCH_OVERLAP
         self.bunch_overlap.setRange(bunch_overlap_range['min'], bunch_overlap_range['max'])
         self.bunch_overlap.setValue(constants.DEFAULT_OVERLAP)
+        self.bunches_label = QLabel("")
+
         self.update_bunch_options(gui_constants.NEW_PROJECT_BUNCH_STACK)
+        self.bunch_stack.toggled.connect(self.update_bunch_options)
+        self.bunch_frames.valueChanged.connect(self.update_bunches_label)
+        self.bunch_overlap.valueChanged.connect(self.update_bunches_label)
+
         self.focus_stack_pyramid = QCheckBox()
         self.focus_stack_pyramid.setChecked(gui_constants.NEW_PROJECT_FOCUS_STACK_PYRAMID)
         self.focus_stack_depth_map = QCheckBox()
@@ -103,7 +113,8 @@ class NewProjectDialog(QDialog):
         self.layout.addRow("Balance layers:", self.balance_frames)
         self.layout.addRow("Bunch stack:", self.bunch_stack)
         self.layout.addRow("Bunch frames:", self.bunch_frames)
-        self.layout.addRow("Bunch frames:", self.bunch_overlap)
+        self.layout.addRow("Bunch overlap:", self.bunch_overlap)
+        self.layout.addRow("Number of bunches: ", self.bunches_label)
         if self.expert():
             self.layout.addRow("Focus stack (pyramid):", self.focus_stack_pyramid)
             self.layout.addRow("Focus stack (depth map):", self.focus_stack_depth_map)
@@ -114,6 +125,28 @@ class NewProjectDialog(QDialog):
     def update_bunch_options(self, checked):
         self.bunch_frames.setEnabled(checked)
         self.bunch_overlap.setEnabled(checked)
+        self.update_bunches_label()
+
+    def update_bunches_label(self):
+        if self.bunch_stack.isChecked():
+            def count_image_files(path):
+                if path == '' or not os.path.isdir(path):
+                    return 0
+                extensions = ['jpg', 'jpeg', 'tif', 'tiff']
+                count = 0
+                for filename in os.listdir(path):
+                    if '.' in filename:
+                        ext = filename.lower().split('.')[-1]
+                        if ext in extensions:
+                            count += 1
+                return count
+
+            bunches = get_bunches(list(range(count_image_files(self.input_folder.text()))),
+                                  self.bunch_frames.value(),
+                                  self.bunch_overlap.value())
+            self.bunches_label.setText(f"{len(bunches)}")
+        else:
+            self.bunches_label.setText(" - ")
 
     def accept(self):
         input_folder = self.input_folder.text()

shinestacker/gui/project_converter.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, R0912, R0911, E1101, W0718
 import logging
 import traceback
 from .. config.constants import constants
@@ -64,20 +65,19 @@ class ProjectConverter:
         for j in project.jobs:
             job = self.job(j, logger_name, callbacks)
             if job is None:
-                raise Exception("Job instantiation failed.")
-            else:
-                jobs.append(job)
+                raise RuntimeError("Job instantiation failed.")
+            jobs.append(job)
         return jobs
 
-    def filter_dict_keys(self, dict, prefix):
-        dict_with = {k.replace(prefix, ''): v for (k, v) in dict.items() if k.startswith(prefix)}
-        dict_without = {k: v for (k, v) in dict.items() if not k.startswith(prefix)}
+    def filter_dict_keys(self, k_dict, prefix):
+        dict_with = {k.replace(prefix, ''): v for (k, v) in k_dict.items() if k.startswith(prefix)}
+        dict_without = {k: v for (k, v) in k_dict.items() if not k.startswith(prefix)}
         return dict_with, dict_without
 
     def action(self, action_config):
         if action_config.type_name == constants.ACTION_NOISEDETECTION:
             return NoiseDetection(**action_config.params)
-        elif action_config.type_name == constants.ACTION_COMBO:
+        if action_config.type_name == constants.ACTION_COMBO:
             sub_actions = []
             for sa in action_config.sub_actions:
                 a = self.action(sa)
@@ -85,22 +85,23 @@ class ProjectConverter:
                     sub_actions.append(a)
             a = CombinedActions(**action_config.params, actions=sub_actions)
             return a
-        elif action_config.type_name == constants.ACTION_MASKNOISE:
+        if action_config.type_name == constants.ACTION_MASKNOISE:
             params = {k: v for k, v in action_config.params.items() if k != 'name'}
             return MaskNoise(**params)
-        elif action_config.type_name == constants.ACTION_VIGNETTING:
+        if action_config.type_name == constants.ACTION_VIGNETTING:
             params = {k: v for k, v in action_config.params.items() if k != 'name'}
             return Vignetting(**params)
-        elif action_config.type_name == constants.ACTION_ALIGNFRAMES:
+        if action_config.type_name == constants.ACTION_ALIGNFRAMES:
             params = {k: v for k, v in action_config.params.items() if k != 'name'}
             return AlignFrames(**params)
-        elif action_config.type_name == constants.ACTION_BALANCEFRAMES:
+        if action_config.type_name == constants.ACTION_BALANCEFRAMES:
             params = {k: v for k, v in action_config.params.items() if k != 'name'}
             if 'intensity_interval' in params.keys():
                 i = params['intensity_interval']
                 params['intensity_interval'] = {'min': i[0], 'max': i[1]}
             return BalanceFrames(**params)
-        elif action_config.type_name == constants.ACTION_FOCUSSTACK or action_config.type_name == constants.ACTION_FOCUSSTACKBUNCH:
+        if action_config.type_name in (constants.ACTION_FOCUSSTACK,
+                                       constants.ACTION_FOCUSSTACKBUNCH):
             stacker = action_config.params.get('stacker', constants.STACK_ALGO_DEFAULT)
             if stacker == constants.STACK_ALGO_PYRAMID:
                 algo_dict, module_dict = self.filter_dict_keys(action_config.params, 'pyramid_')
@@ -115,17 +116,17 @@ class ProjectConverter:
                                          f"{constants.STACK_ALGO_DEPTH_MAP}")
             if action_config.type_name == constants.ACTION_FOCUSSTACK:
                 return FocusStack(**module_dict, stack_algo=stack_algo)
-            elif action_config.type_name == constants.ACTION_FOCUSSTACKBUNCH:
+            if action_config.type_name == constants.ACTION_FOCUSSTACKBUNCH:
                 return FocusStackBunch(**module_dict, stack_algo=stack_algo)
-            else:
-                raise InvalidOptionError("stracker", stacker, details="valid values are: Pyramid, Depth map.")
-        elif action_config.type_name == constants.ACTION_MULTILAYER:
-            input_path = list(filter(lambda p: p != '', action_config.params.get('input_path', '').split(";")))
+            raise InvalidOptionError(
+                "stracker", stacker, details="valid values are: Pyramid, Depth map.")
+        if action_config.type_name == constants.ACTION_MULTILAYER:
+            input_path = list(filter(lambda p: p != '',
+                              action_config.params.get('input_path', '').split(";")))
             params = {k: v for k, v in action_config.params.items() if k != 'imput_path'}
             params['input_path'] = [i.strip() for i in input_path]
             return MultiLayer(**params)
-        else:
-            raise Exception(f"Cannot convert action of type {action_config.type_name}.")
+        raise RuntimeError(f"Cannot convert action of type {action_config.type_name}.")
 
     def job(self, action_config: ActionConfig, logger_name=None, callbacks=None):
         try:
@@ -143,6 +144,6 @@ class ProjectConverter:
         except Exception as e:
             msg = str(e)
             logger = self.get_logger(logger_name)
-            logger.error(f"=== can't instantiate job: {name}: {msg} ===")
+            logger.error(msg=f"=== can't instantiate job: {name}: {msg} ===")
             traceback.print_tb(e.__traceback__)
             raise e

shinestacker/gui/project_editor.py

@@ -1,6 +1,8 @@
+# pylint: disable=C0114, C0115, C0116, R0904, R1702, R0917, R0913, R0902, E0611, E1131
 import os
 from dataclasses import dataclass
-from PySide6.QtWidgets import QMainWindow, QListWidget, QMessageBox, QDialog, QListWidgetItem, QLabel
+from PySide6.QtWidgets import (QMainWindow, QListWidget, QMessageBox,
+                               QDialog, QListWidgetItem, QLabel)
 from PySide6.QtCore import Qt
 from .. config.constants import constants
 from .colors import ColorPalette
@@ -28,7 +30,9 @@ class ActionPosition:
 
     @property
     def sub_action(self):
-        return None if self.sub_actions is None or self.sub_action_index == -1 else self.sub_actions[self.sub_action_index]
+        return None if self.sub_actions is None or \
+                       self.sub_action_index == -1 \
+                       else self.sub_actions[self.sub_action_index]
 
 
 def new_row_after_delete(action_row, pos: ActionPosition):
@@ -41,6 +45,8 @@ def new_row_after_delete(action_row, pos: ActionPosition):
             new_row = action_row
         elif pos.action_index == len(pos.actions):
             new_row = action_row - len(pos.actions[pos.action_index - 1].sub_actions) - 1
+        else:
+            new_row = None
     return new_row
 
 
@@ -67,20 +73,25 @@ def new_row_after_paste(action_row, pos: ActionPosition):
 
 def new_row_after_clone(job, action_row, is_sub_action, cloned):
     return action_row + 1 if is_sub_action else \
-        sum(1 + len(action.sub_actions) for action in job.sub_actions[:job.sub_actions.index(cloned)])
+        sum(1 + len(action.sub_actions)
+            for action in job.sub_actions[:job.sub_actions.index(cloned)])
 
 
 class ProjectEditor(QMainWindow):
     def __init__(self):
         super().__init__()
         self._copy_buffer = None
-        self._project_buffer = []
+        self.project_buffer = []
         self.job_list = QListWidget()
         self.action_list = QListWidget()
         self.project = None
         self.job_list_model = None
         self.expert_options = False
         self.script_dir = os.path.dirname(__file__)
+        self.dialog = None
+        self._current_file = None
+        self._current_file_wd = ''
+        self._modified_project = False
 
     def set_project(self, project):
         self.project = project
@@ -105,7 +116,7 @@ class ProjectEditor(QMainWindow):
             constants.ACTION_BALANCEFRAMES: '🌈'
         }
         ico = icon_map.get(action.type_name, '')
-        if is_sub_action:
+        if is_sub_action and indent:
             txt = INDENT_SPACE
             if ico == '':
                 ico = '🟣'
@@ -118,7 +129,9 @@ class ProjectEditor(QMainWindow):
             if html:
                 txt = f"<b>{txt}</b>"
         in_path, out_path = get_action_input_path(action), get_action_output_path(action)
-        return f"{txt} [{ico} {action.type_name}" + (f": 📁 <i>{in_path[0]}</i> → 📂 <i>{out_path[0]}</i>]" if long_name and not is_sub_action else "]")
+        return f"{txt} [{ico} {action.type_name}" + \
+               (f": 📁 <i>{in_path[0]}</i> → 📂 <i>{out_path[0]}</i>]"
+                if long_name and not is_sub_action else "]")
 
     def get_job_at(self, index):
         return None if index < 0 else self.project.jobs[index]
@@ -138,9 +151,11 @@ class ProjectEditor(QMainWindow):
             return (job_row, action_row, None)
         job = self.project.jobs[job_row]
         if sub_action:
-            return (job_row, action_row, ActionPosition(job.sub_actions, action.sub_actions, job.sub_actions.index(action), sub_action_index))
-        else:
-            return (job_row, action_row, ActionPosition(job.sub_actions, None, job.sub_actions.index(action)))
+            return (job_row, action_row,
+                    ActionPosition(job.sub_actions, action.sub_actions,
+                                   job.sub_actions.index(action), sub_action_index))
+        return (job_row, action_row,
+                ActionPosition(job.sub_actions, None, job.sub_actions.index(action)))
 
     def find_action_position(self, job_index, ui_index):
         if not 0 <= job_index < len(self.project.jobs):
@@ -237,9 +252,12 @@ class ProjectEditor(QMainWindow):
             if confirm:
                 reply = QMessageBox.question(
                     self, "Confirm Delete",
-                    f"Are you sure you want to delete job '{self.project.jobs[current_index].params.get('name', '')}'?",
+                    "Are you sure you want to delete job "
+                    f"'{self.project.jobs[current_index].params.get('name', '')}'?",
                     QMessageBox.Yes | QMessageBox.No
                 )
+            else:
+                reply = None
             if not confirm or reply == QMessageBox.Yes:
                 self.job_list.takeItem(current_index)
                 self.mark_as_modified()
@@ -257,9 +275,12 @@ class ProjectEditor(QMainWindow):
                 reply = QMessageBox.question(
                     self,
                     "Confirm Delete",
-                    f"Are you sure you want to delete action '{self.action_text(current_action, pos.is_sub_action, indent=False)}'?",
+                    "Are you sure you want to delete action "
+                    f"'{self.action_text(current_action, pos.is_sub_action, indent=False)}'?",
                     QMessageBox.Yes | QMessageBox.No
                 )
+            else:
+                reply = None
             if not confirm or reply == QMessageBox.Yes:
                 self.mark_as_modified()
                 if pos.is_sub_action:
@@ -282,10 +303,13 @@ class ProjectEditor(QMainWindow):
             self.delete_element_action.setEnabled(True)
         return element
 
+    def action_config_dialog(self, action):
+        return ActionConfigDialog(action, self._current_file_wd, self)
+
     def add_job(self):
         job_action = ActionConfig("Job")
-        dialog = ActionConfigDialog(job_action, self)
-        if dialog.exec() == QDialog.Accepted:
+        self.dialog = self.action_config_dialog(job_action)
+        if self.dialog.exec() == QDialog.Accepted:
             self.mark_as_modified()
             self.project.jobs.append(job_action)
             self.add_list_item(self.job_list, job_action, False)
@@ -305,8 +329,8 @@ class ProjectEditor(QMainWindow):
             type_name = self.action_selector.currentText()
         action = ActionConfig(type_name)
         action.parent = self.get_current_job()
-        dialog = ActionConfigDialog(action, self)
-        if dialog.exec() == QDialog.Accepted:
+        self.dialog = self.action_config_dialog(action)
+        if self.dialog.exec() == QDialog.Accepted:
             self.mark_as_modified()
             self.project.jobs[current_index].add_sub_action(action)
             self.add_list_item(self.action_list, action, False)
@@ -327,30 +351,16 @@ class ProjectEditor(QMainWindow):
         label = QLabel(html_text)
         widget_list.setItemWidget(item, label)
 
-    def add_action_CombinedActions(self):
-        self.add_action(constants.ACTION_COMBO)
-
-    def add_action_NoiseDetection(self):
-        self.add_action(constants.ACTION_NOISEDETECTION)
-
-    def add_action_FocusStack(self):
-        self.add_action(constants.ACTION_FOCUSSTACK)
-
-    def add_action_FocusStackBunch(self):
-        self.add_action(constants.ACTION_FOCUSSTACKBUNCH)
-
-    def add_action_MultiLayer(self):
-        self.add_action(constants.ACTION_MULTILAYER)
-
     def add_sub_action(self, type_name=False):
         current_job_index = self.job_list.currentRow()
         current_action_index = self.action_list.currentRow()
-        if (current_job_index < 0 or current_action_index < 0 or current_job_index >= len(self.project.jobs)):
+        if current_job_index < 0 or current_action_index < 0 or \
+           current_job_index >= len(self.project.jobs):
             return
         job = self.project.jobs[current_job_index]
         action = None
         action_counter = -1
-        for i, act in enumerate(job.sub_actions):
+        for act in job.sub_actions:
             action_counter += 1
             if action_counter == current_action_index:
                 action = act
@@ -361,32 +371,20 @@ class ProjectEditor(QMainWindow):
         if type_name is False:
             type_name = self.sub_action_selector.currentText()
         sub_action = ActionConfig(type_name)
-        dialog = ActionConfigDialog(sub_action, self)
-        if dialog.exec() == QDialog.Accepted:
+        self.dialog = self.action_config_dialog(sub_action)
+        if self.dialog.exec() == QDialog.Accepted:
             self.mark_as_modified()
             action.add_sub_action(sub_action)
             self.on_job_selected(current_job_index)
             self.action_list.setCurrentRow(current_action_index)
 
-    def add_sub_action_MakeNoise(self):
-        self.add_sub_action(constants.ACTION_MASKNOISE)
-
-    def add_sub_action_Vignetting(self):
-        self.add_sub_action(constants.ACTION_VIGNETTING)
-
-    def add_sub_action_AlignFrames(self):
-        self.add_sub_action(constants.ACTION_ALIGNFRAMES)
-
-    def add_sub_action_BalanceFrames(self):
-        self.add_sub_action(constants.ACTION_BALANCEFRAMES)
-
     def copy_job(self):
         current_index = self.job_list.currentRow()
         if 0 <= current_index < len(self.project.jobs):
             self._copy_buffer = self.project.jobs[current_index].clone()
 
     def copy_action(self):
-        job_row, action_row, pos = self.get_current_action()
+        _job_row, _action_row, pos = self.get_current_action()
         if pos.actions is not None:
             self._copy_buffer = pos.sub_action.clone() if pos.is_sub_action else pos.action.clone()
 
@@ -439,8 +437,8 @@ class ProjectEditor(QMainWindow):
     def undo(self):
         job_row = self.job_list.currentRow()
         action_row = self.action_list.currentRow()
-        if len(self._project_buffer) > 0:
-            self.set_project(self._project_buffer.pop())
+        if len(self.project_buffer) > 0:
+            self.set_project(self.project_buffer.pop())
             self.refresh_ui()
             len_jobs = len(self.project.jobs)
             if len_jobs > 0:
@@ -449,8 +447,7 @@ class ProjectEditor(QMainWindow):
                 self.job_list.setCurrentRow(job_row)
                 len_actions = self.action_list.count()
                 if len_actions > 0:
-                    if action_row >= len_actions:
-                        action_row = len_actions
+                    action_row = min(action_row, len_actions)
                     self.action_list.setCurrentRow(action_row)
 
     def set_enabled(self, enabled):
@@ -459,10 +456,12 @@ class ProjectEditor(QMainWindow):
             job_row = self.job_list.currentRow()
             if 0 <= job_row < len(self.project.jobs):
                 current_action = self.project.jobs[job_row]
-                action_row = -1
+            action_row = -1
         elif self.action_list.hasFocus():
             job_row, action_row, pos = self.get_current_action()
             current_action = pos.sub_action if pos.is_sub_action else pos.action
+        else:
+            action_row = -1
         if current_action:
             if current_action.enabled() != enabled:
                 self.mark_as_modified()

shinestacker/gui/project_model.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, R0911
 from copy import deepcopy
 from .. config.constants import constants
 
@@ -28,7 +29,7 @@ class ActionConfig:
         if index < len(self.sub_actions):
             self.sub_actions.pop(index)
         else:
-            raise Exception(f"can't pop sub-action {index}, lenght is {len(self.sub_actions)}")
+            raise RuntimeError(f"can't pop sub-action {index}, lenght is {len(self.sub_actions)}")
 
     def clone(self, name_postfix=''):
         c = ActionConfig(self.type_name, deepcopy(self.params))
@@ -40,13 +41,10 @@ class ActionConfig:
         return c
 
     def to_dict(self):
-        dict = {
-            'type_name': self.type_name,
-            'params': self.params,
-        }
+        project_dict = {'type_name': self.type_name, 'params': self.params}
         if len(self.sub_actions) > 0:
-            dict['sub_actions'] = [a.to_dict() for a in self.sub_actions]
-        return dict
+            project_dict['sub_actions'] = [a.to_dict() for a in self.sub_actions]
+        return project_dict
 
     @classmethod
     def from_dict(cls, data):
@@ -93,8 +91,7 @@ def get_action_working_path(action, get_name=False):
     wp = action.params.get('working_path', '')
     if wp != '':
         return wp, (f" {action.params.get('name', '')} [{action.type_name}]" if get_name else '')
-    else:
-        return get_action_working_path(action.parent, True)
+    return get_action_working_path(action.parent, True)
 
 
 def get_action_output_path(action, get_name=False):
@@ -122,17 +119,12 @@ def get_action_input_path(action, get_name=False):
                 action = action.sub_actions[0]
                 path = action.params.get('input_path', '')
                 return path, f" {action.params.get('name', '')} [{action.type_name}]"
-            else:
-                return '', ''
-        else:
-            actions = action.parent.sub_actions
-            if action in actions:
-                i = actions.index(action)
-                if i == 0:
-                    return get_action_input_path(action.parent, True)
-                else:
-                    return get_action_output_path(actions[i - 1], True)
-            else:
-                return '', ''
-    else:
-        return path, (f" {action.params.get('name', '')} [{action.type_name}]" if get_name else '')
+            return '', ''
+        actions = action.parent.sub_actions
+        if action in actions:
+            i = actions.index(action)
+            if i == 0:
+                return get_action_input_path(action.parent, True)
+            return get_action_output_path(actions[i - 1], True)
+        return '', ''
+    return path, (f" {action.params.get('name', '')} [{action.type_name}]" if get_name else '')

shinestacker/retouch/{filter_base.py → base_filter.py}

@@ -1,5 +1,7 @@
-import numpy as np
+# pylint: disable=C0114, C0115, C0116, E0611, W0718, R0915, R0903
+import traceback
 from abc import ABC, abstractmethod
+import numpy as np
 from PySide6.QtWidgets import QDialog, QVBoxLayout
 from PySide6.QtCore import Signal, QThread, QTimer
 
@@ -62,7 +64,7 @@ class BaseFilter(ABC):
             active_worker.start()
 
         def restore_original():
-            self.editor.layer_collection.master_layer = self.editor.layer_collection.master_layer_copy.copy()
+            self.editor.restore_master_layer()
             self.editor.display_manager.display_master_layer()
             try:
                 dlg.activateWindow()
@@ -109,6 +111,7 @@ class BaseFilter(ABC):
         def run(self):
             try:
                 result = self.func(*self.args, **self.kwargs)
-            except Exception:
-                raise
+            except Exception as e:
+                traceback.print_tb(e.__traceback__)
+                raise RuntimeError("Filter preview failed") from e
             self.finished.emit(result, self.request_id)

shinestacker/retouch/brush.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, R0903
 from .. config.gui_constants import gui_constants
 
 

shinestacker/retouch/brush_gradient.py

@@ -1,12 +1,16 @@
+# pylint: disable=C0114, C0116, R0913, R0917, E0611
 from PySide6.QtGui import QRadialGradient
 from PySide6.QtGui import QColor
 from .. config.gui_constants import gui_constants
 
 
-def create_brush_gradient(center_x, center_y, radius, hardness, inner_color=None, outer_color=None, opacity=100):
+def create_brush_gradient(center_x, center_y, radius, hardness,
+                          inner_color=None, outer_color=None, opacity=100):
     gradient = QRadialGradient(center_x, center_y, float(radius))
-    inner = inner_color if inner_color is not None else QColor(*gui_constants.BRUSH_COLORS['inner'])
-    outer = outer_color if outer_color is not None else QColor(*gui_constants.BRUSH_COLORS['gradient_end'])
+    inner = inner_color if inner_color is not None else \
+        QColor(*gui_constants.BRUSH_COLORS['inner'])
+    outer = outer_color if outer_color is not None else \
+        QColor(*gui_constants.BRUSH_COLORS['gradient_end'])
     inner_with_opacity = QColor(inner)
     inner_with_opacity.setAlpha(int(float(inner.alpha()) * float(opacity) / 100.0))
     if hardness < 100:
@@ -18,3 +22,13 @@ def create_brush_gradient(center_x, center_y, radius, hardness, inner_color=None
         gradient.setColorAt(0.0, inner_with_opacity)
         gradient.setColorAt(1.0, inner_with_opacity)
     return gradient
+
+
+def create_default_brush_gradient(center_x, center_y, radius, brush):
+    return create_brush_gradient(
+        center_x, center_y, radius,
+        brush.hardness,
+        inner_color=QColor(*gui_constants.BRUSH_COLORS['inner']),
+        outer_color=QColor(*gui_constants.BRUSH_COLORS['gradient_end']),
+        opacity=brush.opacity
+    )

shinestacker/retouch/brush_preview.py

@@ -1,7 +1,10 @@
+# pylint: disable=C0114, C0115, C0116, E0611, R0913, R0917, R0914, W0718
+import traceback
 import numpy as np
 from PySide6.QtWidgets import QGraphicsPixmapItem
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QPixmap, QPainter, QImage
+from .layer_collection import LayerCollectionHandler
 
 
 def brush_profile_lower_limited(r, hardness):
@@ -23,7 +26,9 @@ def brush_profile(r, hardness):
         result = 0.5 * (np.cos(np.pi * np.power(np.where(r < 1.0, r, 1.0), k)) + 1.0)
     elif h < 0:
         k = 1.0 / (1.0 + hardness)
-        result = np.where(r < 1.0, 0.5 * (1.0 - np.cos(np.pi * np.power(1.0 - np.where(r < 1.0, r, 1.0), k))), 0.0)
+        result = np.where(
+            r < 1.0,
+            0.5 * (1.0 - np.cos(np.pi * np.power(1.0 - np.where(r < 1.0, r, 1.0), k))), 0.0)
     else:
         result = np.zeros_like(r)
     return result
@@ -39,10 +44,10 @@ def create_brush_mask(size, hardness_percent, opacity_percent):
     return mask
 
 
-class BrushPreviewItem(QGraphicsPixmapItem):
-    def __init__(self):
-        super().__init__()
-        self.layer_collection = None
+class BrushPreviewItem(QGraphicsPixmapItem, LayerCollectionHandler):
+    def __init__(self, layer_collection):
+        QGraphicsPixmapItem.__init__(self)
+        LayerCollectionHandler.__init__(self, layer_collection)
         self.setVisible(False)
         self.setZValue(500)
         self.setTransformationMode(Qt.SmoothTransformation)
@@ -64,10 +69,9 @@ class BrushPreviewItem(QGraphicsPixmapItem):
             area = np.ascontiguousarray(area[..., :3])  # RGB
         if area.dtype == np.uint8:
             return area.astype(np.float32) / 256.0
-        elif area.dtype == np.uint16:
+        if area.dtype == np.uint16:
             return area.astype(np.float32) / 65536.0
-        else:
-            raise Exception("Bitmas is neither 8 bit nor 16, but of type " + area.dtype)
+        raise RuntimeError("Bitmas is neither 8 bit nor 16, but of type " + area.dtype)
 
     def update(self, scene_pos, size):
         try:
@@ -96,7 +100,8 @@ class BrushPreviewItem(QGraphicsPixmapItem):
             mask_area = full_mask[mask_y_start:mask_y_end, mask_x_start:mask_x_end]
             area = (layer_area * mask_area + master_area * (1 - mask_area)) * 255.0
             area = area.astype(np.uint8)
-            qimage = QImage(area.data, area.shape[1], area.shape[0], area.strides[0], QImage.Format_RGB888)
+            qimage = QImage(area.data, area.shape[1], area.shape[0],
+                            area.strides[0], QImage.Format_RGB888)
             mask = QPixmap(w, h)
             mask.fill(Qt.transparent)
             painter = QPainter(mask)
@@ -117,6 +122,5 @@ class BrushPreviewItem(QGraphicsPixmapItem):
             self.setPos(x_start, y_start)
             self.show()
         except Exception:
-            import traceback
             traceback.print_exc()
             self.hide()