shinestacker 0.3.0__py3-none-any.whl → 0.3.2__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.0'
+__version__ = '0.3.2'

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/algorithms/utils.py

@@ -47,10 +47,14 @@ def img_bw(img):
 
 
 def get_img_metadata(img):
+    if img is None:
+        return None, None
     return img.shape[:2], img.dtype
 
 
 def validate_image(img, expected_shape=None, expected_dtype=None):
+    if img is None:
+        raise RuntimeError("Image is None")
     shape, dtype = get_img_metadata(img)
     if expected_shape and shape[:2] != expected_shape[:2]:
         raise ShapeError(expected_shape, shape)

shinestacker/algorithms/white_balance.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+def white_balance_from_rgb(img, target_rgb):
+    img_float = img.astype(np.float64)
+    target_bgr = (target_rgb[2], target_rgb[1], target_rgb[0])
+    target_gray = sum(target_bgr) / 3.0
+    scales = [target_gray / val if val != 0 else 1.0 for val in target_bgr]
+    for c in range(3):
+        img_float[..., c] *= scales[c]
+    max_val = np.iinfo(img.dtype).max
+    img_float = np.clip(img_float, 0, max_val)
+    return img_float.astype(img.dtype)

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/gui/new_project.py

@@ -85,6 +85,7 @@ 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.update_bunch_options(gui_constants.NEW_PROJECT_BUNCH_STACK)
         self.focus_stack_pyramid = QCheckBox()
         self.focus_stack_pyramid.setChecked(gui_constants.NEW_PROJECT_FOCUS_STACK_PYRAMID)
         self.focus_stack_depth_map = QCheckBox()

shinestacker/retouch/brush_gradient.py

@@ -0,0 +1,20 @@
+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):
+    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_with_opacity = QColor(inner)
+    inner_with_opacity.setAlpha(int(float(inner.alpha()) * float(opacity) / 100.0))
+    if hardness < 100:
+        hardness_normalized = float(hardness) / 100.0
+        gradient.setColorAt(0.0, inner_with_opacity)
+        gradient.setColorAt(hardness_normalized, inner_with_opacity)
+        gradient.setColorAt(1.0, outer)
+    else:
+        gradient.setColorAt(0.0, inner_with_opacity)
+        gradient.setColorAt(1.0, inner_with_opacity)
+    return gradient

shinestacker/retouch/brush_preview.py

@@ -1,6 +1,6 @@
 import numpy as np
 from PySide6.QtWidgets import QGraphicsPixmapItem
-from PySide6.QtCore import Qt, QPointF
+from PySide6.QtCore import Qt
 from PySide6.QtGui import QPixmap, QPainter, QImage
 
 
@@ -42,6 +42,7 @@ def create_brush_mask(size, hardness_percent, opacity_percent):
 class BrushPreviewItem(QGraphicsPixmapItem):
     def __init__(self):
         super().__init__()
+        self.layer_collection = None
         self.setVisible(False)
         self.setZValue(500)
         self.setTransformationMode(Qt.SmoothTransformation)
@@ -68,31 +69,26 @@ class BrushPreviewItem(QGraphicsPixmapItem):
         else:
             raise Exception("Bitmas is neither 8 bit nor 16, but of type " + area.dtype)
 
-    def update(self, editor, pos, size):
+    def update(self, scene_pos, size):
         try:
-            if editor.current_stack is None or not hasattr(editor, 'image_viewer') or size <= 0:
+            if self.layer_collection is None or self.number_of_layers() == 0 or size <= 0:
                 self.hide()
                 return
             radius = size // 2
-            if isinstance(pos, QPointF):
-                scene_pos = pos
-            else:
-                cursor_pos = editor.image_viewer.mapFromGlobal(pos)
-                scene_pos = editor.image_viewer.mapToScene(cursor_pos)
             x = int(scene_pos.x() - radius + 0.5)
             y = int(scene_pos.y() - radius)
             w = h = size
-            if editor.current_layer < 0 or editor.current_layer >= len(editor.current_stack):
+            if not self.valid_current_layer_idx():
                 self.hide()
                 return
-            layer_area = self.get_layer_area(editor.current_stack[editor.current_layer], x, y, w, h)
-            master_area = self.get_layer_area(editor.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 = editor.current_stack[editor.current_layer].shape[:2]
-            full_mask = create_brush_mask(size=size, hardness_percent=editor.brush.hardness,
-                                          opacity_percent=editor.brush.opacity)[:, :, np.newaxis]
+            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
             mask_y_start = max(0, -y) if y < 0 else 0
             mask_x_end = size - (max(0, (x + w) - width)) if (x + w) > width else size