shinestacker 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

shinestacker/__init__.py

@@ -1,4 +1,5 @@
 # flake8: noqa F401 F403
+# pylint: disable=C0114, E0401
 from ._version import __version__
 from . import config
 from . import core
@@ -13,4 +14,4 @@ from .algorithms import *
 __all__ = ['__version__']
 __all__ += config_all
 __all__ += core_all
-__all__ += algorithms_all
+__all__ += algorithms_all

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '0.3.2'
+__version__ = '0.3.4'

shinestacker/algorithms/__init__.py

@@ -1,4 +1,6 @@
 # flake8: noqa F401
+# pylint: disable=C0114
+import logging
 from .. config.constants import constants
 from .stack_framework import StackJob, CombinedActions
 from .align import AlignFrames
@@ -9,11 +11,10 @@ from .pyramid import PyramidStack
 from .multilayer import MultiLayer
 from .noise_detection import NoiseDetection, MaskNoise
 from .vignetting import Vignetting
-import logging
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
 
 __all__ = [
 	'StackJob', 'CombinedActions', 'AlignFrames', 'BalanceFrames', 'FocusStackBunch', 'FocusStack',
 	'DepthMapStack', 'PyramidStack', 'MultiLayer', 'NoiseDetection', 'MaskNoise', 'Vignetting'
-]
+]

shinestacker/algorithms/align.py

@@ -1,7 +1,8 @@
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, R0913, R0917, R0912, R0915, R0902
+import logging
+import numpy as np
 import matplotlib.pyplot as plt
 import cv2
-import numpy as np
-import logging
 from .. config.constants import constants
 from .. core.exceptions import AlignmentError, InvalidOptionError
 from .utils import img_8bit, img_bw_8bit, save_plot
@@ -49,15 +50,20 @@ def get_good_matches(des_0, des_1, matching_config=None):
     good_matches = []
     if match_method == constants.MATCHING_KNN:
         flann = cv2.FlannBasedMatcher(
-            dict(algorithm=matching_config['flann_idx_kdtree'], trees=matching_config['flann_trees']),
-            dict(checks=matching_config['flann_checks']))
+            {'algorithm': matching_config['flann_idx_kdtree'],
+             'trees': matching_config['flann_trees']},
+            {'checks': matching_config['flann_checks']})
         matches = flann.knnMatch(des_0, des_1, k=2)
-        good_matches = [m for m, n in matches if m.distance < matching_config['threshold'] * n.distance]
+        good_matches = [m for m, n in matches
+                        if m.distance < matching_config['threshold'] * n.distance]
     elif match_method == constants.MATCHING_NORM_HAMMING:
         bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
         good_matches = sorted(bf.match(des_0, des_1), key=lambda x: x.distance)
     else:
-        raise InvalidOptionError('match_method', match_method, f". Valid options are: {constants.MATCHING_KNN}, {constants.MATCHING_NORM_HAMMING}")
+        raise InvalidOptionError(
+            'match_method', match_method,
+            f". Valid options are: {constants.MATCHING_KNN}, {constants.MATCHING_NORM_HAMMING}"
+        )
     return good_matches
 
 
@@ -73,9 +79,11 @@ def validate_align_config(detector, descriptor, match_method):
         raise ValueError("Detector SURF is incompatible with descriptor AKAZE")
     if detector == constants.DETECTOR_SIFT and descriptor != constants.DESCRIPTOR_SIFT:
         raise ValueError("Detector SIFT requires descriptor SIFT")
-    if detector in constants.NOKNN_METHODS['detectors'] and descriptor in constants.NOKNN_METHODS['descriptors'] and \
-            match_method != constants.MATCHING_NORM_HAMMING:
-        raise ValueError(f"Detector {detector} and descriptor {descriptor} require matching method Hamming distance")
+    if detector in constants.NOKNN_METHODS['detectors'] and \
+       descriptor in constants.NOKNN_METHODS['descriptors'] and \
+       match_method != constants.MATCHING_NORM_HAMMING:
+        raise ValueError(f"Detector {detector} and descriptor {descriptor}"
+                         " require matching method Hamming distance")
 
 
 def detect_and_compute(img_0, img_1, feature_config=None, matching_config=None):
@@ -101,7 +109,9 @@ def detect_and_compute(img_0, img_1, feature_config=None, matching_config=None):
     }
     detector = detector_map[feature_config_detector]()
     if feature_config_detector == feature_config_descriptor and \
-       feature_config_detector in (constants.DETECTOR_SIFT, constants.DETECTOR_AKAZE, constants.DETECTOR_BRISK):
+       feature_config_detector in (constants.DETECTOR_SIFT,
+                                   constants.DETECTOR_AKAZE,
+                                   constants.DETECTOR_BRISK):
         kp_0, des_0 = detector.detectAndCompute(img_bw_0, None)
         kp_1, des_1 = detector.detectAndCompute(img_bw_1, None)
     else:
@@ -122,7 +132,10 @@ def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
     elif method == 'LMEDS':
         cv2_method = cv2.LMEDS
     else:
-        raise InvalidOptionError('align_method', method, f". Valid options are: {constants.ALIGN_RANSAC}, {constants.ALIGN_LMEDS}")
+        raise InvalidOptionError(
+            'align_method', method,
+            f". Valid options are: {constants.ALIGN_RANSAC}, {constants.ALIGN_LMEDS}"
+        )
     if transform == constants.ALIGN_HOMOGRAPHY:
         result = cv2.findHomography(src_pts, dst_pts, method=cv2_method,
                                     ransacReprojThreshold=rans_threshold,
@@ -144,44 +157,51 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     alignment_config = {**_DEFAULT_ALIGNMENT_CONFIG, **(alignment_config or {})}
     try:
         cv2_border_mode = _cv2_border_mode_map[alignment_config['border_mode']]
-    except KeyError:
-        raise InvalidOptionError("border_mode", alignment_config['border_mode'])
+    except KeyError as e:
+        raise InvalidOptionError("border_mode", alignment_config['border_mode']) from e
     min_matches = 4 if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
     validate_image(img_0, *get_img_metadata(img_1))
-    if callbacks and 'message' in callbacks.keys():
+    if callbacks and 'message' in callbacks:
         callbacks['message']()
     subsample = alignment_config['subsample']
     if subsample > 1:
         if alignment_config['fast_subsampling']:
             img_0_sub, img_1_sub = img_0[::subsample, ::subsample], img_1[::subsample, ::subsample]
         else:
-            img_0_sub = cv2.resize(img_0, (0, 0), fx=1 / subsample, fy=1 / subsample, interpolation=cv2.INTER_AREA)
-            img_1_sub = cv2.resize(img_1, (0, 0), fx=1 / subsample, fy=1 / subsample, interpolation=cv2.INTER_AREA)
+            img_0_sub = cv2.resize(img_0, (0, 0),
+                                   fx=1 / subsample, fy=1 / subsample,
+                                   interpolation=cv2.INTER_AREA)
+            img_1_sub = cv2.resize(img_1, (0, 0),
+                                   fx=1 / subsample, fy=1 / subsample,
+                                   interpolation=cv2.INTER_AREA)
     else:
         img_0_sub, img_1_sub = img_0, img_1
-    kp_0, kp_1, good_matches = detect_and_compute(img_0_sub, img_1_sub, feature_config, matching_config)
+    kp_0, kp_1, good_matches = detect_and_compute(img_0_sub, img_1_sub,
+                                                  feature_config, matching_config)
     n_good_matches = len(good_matches)
-    if callbacks and 'matches_message' in callbacks.keys():
+    if callbacks and 'matches_message' in callbacks:
         callbacks['matches_message'](n_good_matches)
     img_warp = None
-    M = None
+    m = None
     if n_good_matches >= min_matches:
         transform = alignment_config['transform']
         src_pts = np.float32([kp_0[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
         dst_pts = np.float32([kp_1[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
-        M, msk = find_transform(src_pts, dst_pts, transform, alignment_config['align_method'],
-                                alignment_config['rans_threshold'], alignment_config['max_iters'],
-                                alignment_config['align_confidence'], alignment_config['refine_iters'])
+        m, msk = find_transform(src_pts, dst_pts, transform, alignment_config['align_method'],
+                                *(alignment_config[k]
+                                  for k in ['rans_threshold', 'max_iters',
+                                            'align_confidence', 'refine_iters']))
         if plot_path is not None:
             matches_mask = msk.ravel().tolist()
-            img_match = cv2.cvtColor(cv2.drawMatches(img_8bit(img_0_sub), kp_0, img_8bit(img_1_sub),
-                                                     kp_1, good_matches, None, matchColor=(0, 255, 0),
-                                                     singlePointColor=None, matchesMask=matches_mask,
-                                                     flags=2), cv2.COLOR_BGR2RGB)
+            img_match = cv2.cvtColor(cv2.drawMatches(
+                img_8bit(img_0_sub), kp_0, img_8bit(img_1_sub),
+                kp_1, good_matches, None, matchColor=(0, 255, 0),
+                singlePointColor=None, matchesMask=matches_mask,
+                flags=2), cv2.COLOR_BGR2RGB)
             plt.figure(figsize=(10, 5))
             plt.imshow(img_match, 'gray')
             plt.savefig(plot_path)
-            if callbacks and 'save_plot' in callbacks.keys():
+            if callbacks and 'save_plot' in callbacks:
                 callbacks['save_plot'](plot_path)
         h, w = img_0.shape[:2]
         h_sub, w_sub = img_0_sub.shape[:2]
@@ -191,57 +211,64 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
                 high_size = np.float32([[0, 0], [0, h], [w, h], [w, 0]])
                 scale_up = cv2.getPerspectiveTransform(low_size, high_size)
                 scale_down = cv2.getPerspectiveTransform(high_size, low_size)
-                M = scale_up @ M @ scale_down
+                m = scale_up @ m @ scale_down
             elif transform == constants.ALIGN_RIGID:
-                rotation = M[:2, :2]
-                translation = M[:, 2]
+                rotation = m[:2, :2]
+                translation = m[:, 2]
                 translation_fullres = translation * subsample
-                M = np.empty((2, 3), dtype=np.float32)
-                M[:2, :2] = rotation
-                M[:, 2] = translation_fullres
+                m = np.empty((2, 3), dtype=np.float32)
+                m[:2, :2] = rotation
+                m[:, 2] = translation_fullres
             else:
                 raise InvalidOptionError("transform", transform)
-        if callbacks and 'align_message' in callbacks.keys():
+        if callbacks and 'align_message' in callbacks:
             callbacks['align_message']()
         img_mask = np.ones_like(img_0, dtype=np.uint8)
         if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY:
-            img_warp = cv2.warpPerspective(img_0, M, (w, h),
-                                           borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
+            img_warp = cv2.warpPerspective(
+                img_0, m, (w, h),
+                borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
             if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-                mask = cv2.warpPerspective(img_mask, M, (w, h),
+                mask = cv2.warpPerspective(img_mask, m, (w, h),
                                            borderMode=cv2.BORDER_CONSTANT, borderValue=0)
         elif alignment_config['transform'] == constants.ALIGN_RIGID:
-            img_warp = cv2.warpAffine(img_0, M, (w, h),
-                                      borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
+            img_warp = cv2.warpAffine(
+                img_0, m, (w, h),
+                borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
             if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-                mask = cv2.warpAffine(img_mask, M, (w, h),
+                mask = cv2.warpAffine(img_mask, m, (w, h),
                                       borderMode=cv2.BORDER_CONSTANT, borderValue=0)
         if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-            if callbacks and 'blur_message' in callbacks.keys():
+            if callbacks and 'blur_message' in callbacks:
                 callbacks['blur_message']()
             mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-            blurred_warp = cv2.GaussianBlur(img_warp, (21, 21), sigmaX=alignment_config['border_blur'])
+            blurred_warp = cv2.GaussianBlur(
+                img_warp, (21, 21), sigmaX=alignment_config['border_blur'])
             img_warp[mask == 0] = blurred_warp[mask == 0]
-    return n_good_matches, M, img_warp
+    return n_good_matches, m, img_warp
 
 
 class AlignFrames(SubAction):
-    def __init__(self, enabled=True, feature_config=None, matching_config=None, alignment_config=None, **kwargs):
+    def __init__(self, enabled=True, feature_config=None, matching_config=None,
+                 alignment_config=None, **kwargs):
         super().__init__(enabled)
+        self.process = None
+        self.n_matches = None
         self.feature_config = {**_DEFAULT_FEATURE_CONFIG, **(feature_config or {})}
         self.matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
         self.alignment_config = {**_DEFAULT_ALIGNMENT_CONFIG, **(alignment_config or {})}
-        self.min_matches = 4 if self.alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
+        self.min_matches = 4 \
+            if self.alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
         self.plot_summary = kwargs.get('plot_summary', False)
         self.plot_matches = kwargs.get('plot_matches', False)
-        for k in self.feature_config.keys():
-            if k in kwargs.keys():
+        for k in self.feature_config:
+            if k in kwargs:
                 self.feature_config[k] = kwargs[k]
-        for k in self.matching_config.keys():
-            if k in kwargs.keys():
+        for k in self.matching_config:
+            if k in kwargs:
                 self.matching_config[k] = kwargs[k]
-        for k in self.alignment_config.keys():
-            if k in kwargs.keys():
+        for k in self.alignment_config:
+            if k in kwargs:
                 self.alignment_config[k] = kwargs[k]
 
     def run_frame(self, idx, ref_idx, img_0):
@@ -251,21 +278,23 @@ class AlignFrames(SubAction):
         return self.align_images(idx, img_ref, img_0)
 
     def align_images(self, idx, img_1, img_0):
-        idx_str = "{:04d}".format(idx)
+        idx_str = f"{idx:04d}"
         callbacks = {
             'message': lambda: self.process.sub_message_r(': find matches'),
             'matches_message': lambda n: self.process.sub_message_r(f": matches: {n}"),
             'align_message': lambda: self.process.sub_message_r(': align images'),
             'ecc_message': lambda: self.process.sub_message_r(": ecc refinement"),
             'blur_message': lambda: self.process.sub_message_r(': blur borders'),
-            'save_plot': lambda plot_path: self.process.callback('save_plot', self.process.id,
-                                                                 f"{self.process.name}: matches\nframe {idx_str}", plot_path)
+            'save_plot': lambda plot_path: self.process.callback(
+                'save_plot', self.process.id,
+                f"{self.process.name}: matches\nframe {idx_str}", plot_path)
         }
         if self.plot_matches:
-            plot_path = f"{self.process.working_path}/{self.process.plot_path}/{self.process.name}-matches-{idx_str}.pdf"
+            plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                f"{self.process.name}-matches-{idx_str}.pdf"
         else:
             plot_path = None
-        n_good_matches, M, img = align_images(
+        n_good_matches, _m, img = align_images(
             img_1, img_0,
             feature_config=self.feature_config,
             matching_config=self.matching_config,
@@ -275,8 +304,10 @@ class AlignFrames(SubAction):
         )
         self.n_matches[idx] = n_good_matches
         if n_good_matches < self.min_matches:
-            self.process.sub_message(f": image not aligned, too few matches found: {n_good_matches}", level=logging.CRITICAL)
-            raise AlignmentError(idx, f"too few matches found: {n_good_matches} < {self.min_matches}")
+            self.process.sub_message(f": image not aligned, too few matches found: "
+                                     f"{n_good_matches}", level=logging.CRITICAL)
+            raise AlignmentError(idx, f"too few matches found: "
+                                 f"{n_good_matches} < {self.min_matches}")
         return img
 
     def begin(self, process):
@@ -287,20 +318,27 @@ class AlignFrames(SubAction):
         if self.plot_summary:
             plt.figure(figsize=(10, 5))
             x = np.arange(1, len(self.n_matches) + 1, dtype=int)
-            no_ref = (x != self.process.ref_idx + 1)
+            no_ref = x != self.process.ref_idx + 1
             x = x[no_ref]
             y = self.n_matches[no_ref]
-            y_max = y[1] if self.process.ref_idx == 0 else y[-1] if self.process.ref_idx == len(y) - 1 else (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2 # noqa
+            y_max = y[1] \
+                if self.process.ref_idx == 0 \
+                else y[-1] if self.process.ref_idx == len(y) - 1 \
+                else (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
 
-            plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1], [0, y_max], color='cornflowerblue', linestyle='--', label='reference frame')
-            plt.plot([x[0], x[-1]], [self.min_matches, self.min_matches], color='lightgray', linestyle='--', label='min. matches')
+            plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                     [0, y_max], color='cornflowerblue', linestyle='--', label='reference frame')
+            plt.plot([x[0], x[-1]], [self.min_matches, self.min_matches], color='lightgray',
+                     linestyle='--', label='min. matches')
             plt.plot(x, y, color='navy', label='matches')
             plt.xlabel('frame')
             plt.ylabel('# of matches')
             plt.legend()
             plt.ylim(0)
             plt.xlim(x[0], x[-1])
-            plot_path = f"{self.process.working_path}/{self.process.plot_path}/{self.process.name}-matches.pdf"
+            plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                        f"{self.process.name}-matches.pdf"
             save_plot(plot_path)
             plt.close('all')
-            self.process.callback('save_plot', self.process.id, f"{self.process.name}: matches", plot_path)
+            self.process.callback('save_plot', self.process.id,
+                                  f"{self.process.name}: matches", plot_path)

shinestacker/algorithms/balance.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0115, C0116, E1101, R0902, E1128, E0606, W0640, R0913, R0917
 import numpy as np
 import cv2
 import matplotlib.pyplot as plt
@@ -22,8 +23,8 @@ class CorrectionMapBase:
         self.channels = len(ref_hist)
         self.reference = None
 
-    def lut(self, correction, reference):
-        assert False, 'abstract method'
+    def lut(self, _correction, _reference):
+        return None
 
     def apply_lut(self, correction, reference, img):
         lut = self.lut(correction, reference)
@@ -32,13 +33,18 @@ class CorrectionMapBase:
     def adjust(self, image, correction):
         if self.channels == 1:
             return self.apply_lut(correction[0], self.reference[0], image)
-        else:
-            chans = cv2.split(image)
-            if self.channels == 2:
-                ch_out = [chans[0]] + [self.apply_lut(correction[c - 1], self.reference[c - 1], chans[c]) for c in range(1, 3)]
-            elif self.channels == 3:
-                ch_out = [self.apply_lut(correction[c], self.reference[c], chans[c]) for c in range(3)]
-            return cv2.merge(ch_out)
+        chans = cv2.split(image)
+        if self.channels == 2:
+            ch_out = [chans[0]] + [self.apply_lut(
+                correction[c - 1],
+                self.reference[c - 1], chans[c]
+            ) for c in range(1, 3)]
+        elif self.channels == 3:
+            ch_out = [self.apply_lut(
+                correction[c],
+                self.reference[c], chans[c]
+            ) for c in range(3)]
+        return cv2.merge(ch_out)
 
     def correction_size(self, correction):
         return correction
@@ -64,7 +70,10 @@ class MatchHist(CorrectionMapBase):
             i0, i1 = self.id_lut[lut == l0], self.id_lut[lut == l1]
             i0_max = i0.max()
             lut[lut == l0] = (i0 / i0_max * l_min) if i0_max > 0 else 0
-            lut[lut == l1] = i1 + (i1 - self.max_pixel_value) * (self.max_pixel_value - l_max) / float(i1.size) if i1.size > 0 else self.max_pixel_value
+            lut[lut == l1] = i1 + \
+                (i1 - self.max_pixel_value) * \
+                (self.max_pixel_value - l_max) / \
+                float(i1.size) if i1.size > 0 else self.max_pixel_value
         return lut.astype(self.dtype)
 
     def correction(self, hist):
@@ -88,26 +97,31 @@ class GammaMap(CorrectionMap):
         CorrectionMap.__init__(self, dtype, ref_hist, intensity_interval)
 
     def correction(self, hist):
-        return [bisect(lambda x: self.mid_val(self.lut(x), h) - r, 0.1, 5) for h, r in zip(hist, self.reference)]
+        return [bisect(lambda x: self.mid_val(self.lut(x), h) - r, 0.1, 5)
+                for h, r in zip(hist, self.reference)]
 
-    def lut(self, correction, reference=None):
+    def lut(self, correction, _reference=None):
         gamma_inv = 1.0 / correction
-        return (((np.arange(0, self.num_pixel_values) / self.max_pixel_value) ** gamma_inv) * self.max_pixel_value).astype(self.dtype)
+        ar = np.arange(0, self.num_pixel_values)
+        corr_lut = ((ar / self.max_pixel_value) ** gamma_inv) * self.max_pixel_value
+        return corr_lut.astype(self.dtype)
 
 
 class LinearMap(CorrectionMap):
     def __init__(self, dtype, ref_hist, intensity_interval=None):
         CorrectionMap.__init__(self, dtype, ref_hist, intensity_interval)
 
-    def lut(self, correction, reference=None):
-        return np.clip(np.arange(0, self.num_pixel_values) * correction, 0, self.max_pixel_value).astype(self.dtype)
+    def lut(self, correction, _reference=None):
+        ar = np.arange(0, self.num_pixel_values)
+        return np.clip(ar * correction, 0, self.max_pixel_value).astype(self.dtype)
 
     def correction(self, hist):
         return [r / self.mid_val(self.id_lut, h) for h, r in zip(hist, self.reference)]
 
 
 class Correction:
-    def __init__(self, channels, mask_size=0, intensity_interval=None, subsample=-1, corr_map=constants.DEFAULT_CORR_MAP,
+    def __init__(self, channels, mask_size=0, intensity_interval=None,
+                 subsample=-1, corr_map=constants.DEFAULT_CORR_MAP,
                  plot_histograms=False, plot_summary=False):
         self.mask_size = mask_size
         self.intensity_interval = intensity_interval
@@ -116,10 +130,16 @@ class Correction:
         self.subsample = constants.DEFAULT_BALANCE_SUBSAMPLE if subsample == -1 else subsample
         self.corr_map = corr_map
         self.channels = channels
+        self.dtype = None
+        self.num_pixel_values = None
+        self. max_pixel_value = None
+        self.corrections = None
+        self.process = None
 
     def begin(self, ref_image, size, ref_idx):
         self.dtype = ref_image.dtype
-        self.num_pixel_values = constants.NUM_UINT8 if ref_image.dtype == np.uint8 else constants.NUM_UINT16
+        self.num_pixel_values = constants.NUM_UINT8 if ref_image.dtype == np.uint8 \
+            else constants.NUM_UINT16
         self.max_pixel_value = self.num_pixel_values - 1
         hist = self.get_hist(self.preprocess(ref_image), ref_idx)
         if self.corr_map == constants.BALANCE_LINEAR:
@@ -138,22 +158,30 @@ class Correction:
             image_sel = img_subsample
         else:
             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 = 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))
+            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 = 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):
         correction = self.corr_map.correction(self.get_hist(image, idx))
         return correction, self.corr_map.adjust(image, correction)
 
-    def get_hist(self, image, idx):
-        assert False, 'abstract method'
+    def get_hist(self, _image, _idx):
+        return None
 
-    def end(self):
-        assert False, 'abstract method'
+    def end(self, _ref_idx):
+        pass
 
     def apply_correction(self, idx, image):
         image = self.preprocess(image)
@@ -176,17 +204,26 @@ class Correction:
         ax.plot(hist, color=color, alpha=alpha)
 
     def save_plot(self, idx):
-        idx_str = "{:04d}".format(idx)
-        plot_path = f"{self.process.working_path}/{self.process.plot_path}/{self.process.name}-hist-{idx_str}.pdf"
+        idx_str = f"{idx:04d}"
+        plot_path = f"{self.process.working_path}/" \
+            f"{self.process.plot_path}/{self.process.name}-hist-{idx_str}.pdf"
         save_plot(plot_path)
         plt.close('all')
-        self.process.callback('save_plot', self.process.id, f"{self.process.name}: balance\nframe {idx_str}", plot_path)
+        self.process.callback(
+            'save_plot',
+            self.process.id, f"{self.process.name}: balance\nframe {idx_str}",
+            plot_path
+        )
 
     def save_summary_plot(self, name='balance'):
-        plot_path = f"{self.process.working_path}/{self.process.plot_path}/{self.process.name}-{name}.pdf"
+        plot_path = f"{self.process.working_path}/" \
+            f"{self.process.plot_path}/{self.process.name}-{name}.pdf"
         save_plot(plot_path)
         plt.close('all')
-        self.process.callback('save_plot', self.process.id, f"{self.process.name}: {name}", plot_path)
+        self.process.callback(
+            'save_plot', self.process.id,
+            f"{self.process.name}: {name}", plot_path
+        )
 
 
 class LumiCorrection(Correction):
@@ -198,7 +235,7 @@ class LumiCorrection(Correction):
         chans = cv2.split(image)
         colors = ("r", "g", "b")
         if self.plot_histograms:
-            fig, axs = plt.subplots(1, 2, figsize=(10, 5), sharey=True)
+            _fig, axs = plt.subplots(1, 2, figsize=(10, 5), sharey=True)
             self.histo_plot(axs[0], hist, "pixel luminosity", 'black')
             for (chan, color) in zip(chans, colors):
                 hist_col = self.calc_hist_1ch(chan)
@@ -212,8 +249,10 @@ class LumiCorrection(Correction):
             plt.figure(figsize=(10, 5))
             x = np.arange(1, len(self.corrections) + 1, dtype=int)
             y = self.corrections
-            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue', linestyle='--', label='reference frame')
-            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--', label='no correction')
+            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue',
+                     linestyle='--', label='reference frame')
+            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--',
+                     label='no correction')
             plt.plot(x, y, color='navy', label='luminosity correction')
             plt.xlabel('frame')
             plt.ylabel('correction')
@@ -231,7 +270,7 @@ class RGBCorrection(Correction):
         hist = [self.calc_hist_1ch(chan) for chan in cv2.split(image)]
         colors = ("r", "g", "b")
         if self.plot_histograms:
-            fig, axs = plt.subplots(1, 3, figsize=(10, 5), sharey=True)
+            _fig, axs = plt.subplots(1, 3, figsize=(10, 5), sharey=True)
             for c in [2, 1, 0]:
                 self.histo_plot(axs[c], hist[c], colors[c] + " luminosity", colors[c])
             plt.xlim(0, self.max_pixel_value)
@@ -243,8 +282,10 @@ class RGBCorrection(Correction):
             plt.figure(figsize=(10, 5))
             x = np.arange(1, len(self.corrections) + 1, dtype=int)
             y = self.corrections
-            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue', linestyle='--', label='reference frame')
-            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--', label='no correction')
+            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue',
+                     linestyle='--', label='reference frame')
+            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--',
+                     label='no correction')
             plt.plot(x, y[:, 0], color='r', label='R correction')
             plt.plot(x, y[:, 1], color='g', label='G correction')
             plt.plot(x, y[:, 2], color='b', label='B correction')
@@ -269,7 +310,7 @@ class Ch2Correction(Correction):
     def get_hist(self, image, idx):
         hist = [self.calc_hist_1ch(chan) for chan in cv2.split(image)]
         if self.plot_histograms:
-            fig, axs = plt.subplots(1, 3, figsize=(10, 5), sharey=True)
+            _fig, axs = plt.subplots(1, 3, figsize=(10, 5), sharey=True)
             for c in range(3):
                 self.histo_plot(axs[c], hist[c], self.labels[c], self.colors[c])
             plt.xlim(0, self.max_pixel_value)
@@ -281,8 +322,10 @@ class Ch2Correction(Correction):
             plt.figure(figsize=(10, 5))
             x = np.arange(1, len(self.corrections) + 1, dtype=int)
             y = self.corrections
-            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue', linestyle='--', label='reference frame')
-            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--', label='no correction')
+            plt.plot([ref_idx + 1, ref_idx + 1], [0, 1], color='cornflowerblue',
+                     linestyle='--', label='reference frame')
+            plt.plot([x[0], x[-1]], [1, 1], color='lightgray', linestyle='--',
+                     label='no correction')
             plt.plot(x, y[:, 0], color=self.colors[1], label=self.labels[1] + ' correction')
             plt.plot(x, y[:, 1], color=self.colors[2], label=self.labels[2] + ' correction')
             plt.xlabel('frame')
@@ -322,10 +365,14 @@ class LSCorrection(Ch2Correction):
 class BalanceFrames(SubAction):
     def __init__(self, enabled=True, **kwargs):
         super().__init__(enabled=enabled)
+        self.process = None
+        self.shape = None
         corr_map = kwargs.get('corr_map', constants.DEFAULT_CORR_MAP)
         subsample = kwargs.get('subsample', constants.DEFAULT_BALANCE_SUBSAMPLE)
         channel = kwargs.pop('channel', constants.DEFAULT_CHANNEL)
-        kwargs['subsample'] = (1 if corr_map == constants.BALANCE_MATCH_HIST else constants.DEFAULT_BALANCE_SUBSAMPLE) if subsample == -1 else subsample
+        kwargs['subsample'] = (
+            1 if corr_map == constants.BALANCE_MATCH_HIST
+            else constants.DEFAULT_BALANCE_SUBSAMPLE) if subsample == -1 else subsample
         self.mask_size = kwargs.get('mask_size', 0)
         self.plot_summary = kwargs.get('plot_summary', False)
         if channel == constants.BALANCE_LUMI:
@@ -359,7 +406,7 @@ class BalanceFrames(SubAction):
             plt.imshow(img, 'gray')
             self.correction.save_summary_plot("mask")
 
-    def run_frame(self, idx, ref_idx, image):
+    def run_frame(self, idx, _ref_idx, image):
         if idx != self.process.ref_idx:
             self.process.sub_message_r(': balance image')
             image = self.correction.apply_correction(idx, image)