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

shinestacker/algorithms/noise_detection.py

@@ -1,9 +1,10 @@
+# pylint: disable=C0114, C0115, C0116, E1101, W0718, R0914, R0915
+import os
+import errno
+import logging
 import cv2
 import numpy as np
 import matplotlib.pyplot as plt
-import logging
-import os
-import errno
 from .. config.config import config
 from .. config.constants import constants
 from .. core.colors import color_str
@@ -21,7 +22,7 @@ def mean_image(file_paths, max_frames=-1, message_callback=None, progress_callba
     mean_img = None
     counter = 0
     for i, path in enumerate(file_paths):
-        if max_frames >= 1 and i > max_frames:
+        if 1 <= max_frames < i:
             break
         if message_callback:
             message_callback(path)
@@ -31,7 +32,7 @@ def mean_image(file_paths, max_frames=-1, message_callback=None, progress_callba
             img = read_img(path)
         except Exception:
             logger = logging.getLogger(__name__)
-            logger.error("Can't open file: " + path)
+            logger.error(msg=f"Can't open file: {path}")
         if mean_img is None:
             metadata = get_img_metadata(img)
             mean_img = img.astype(np.float64)
@@ -44,7 +45,7 @@ def mean_image(file_paths, max_frames=-1, message_callback=None, progress_callba
     return None if mean_img is None else (mean_img / counter).astype(np.uint8)
 
 
-class NoiseDetection(FrameMultiDirectory, JobBase):
+class NoiseDetection(JobBase, FrameMultiDirectory):
     def __init__(self, name="noise-map", enabled=True, **kwargs):
         FrameMultiDirectory.__init__(self, name, **kwargs)
         JobBase.__init__(self, name, enabled)
@@ -53,9 +54,12 @@ class NoiseDetection(FrameMultiDirectory, JobBase):
         self.file_name = kwargs.get('file_name', constants.DEFAULT_NOISE_MAP_FILENAME)
         if self.file_name == '':
             self.file_name = constants.DEFAULT_NOISE_MAP_FILENAME
-        self.channel_thresholds = kwargs.get('channel_thresholds', constants.DEFAULT_CHANNEL_THRESHOLDS)
+        self.channel_thresholds = kwargs.get(
+            'channel_thresholds', constants.DEFAULT_CHANNEL_THRESHOLDS
+        )
         self.plot_range = kwargs.get('plot_range', constants.DEFAULT_NOISE_PLOT_RANGE)
         self.plot_histograms = kwargs.get('plot_histograms', False)
+        self.tbar = None
 
     def hot_map(self, ch, th):
         return cv2.threshold(ch, th, 255, cv2.THRESH_BINARY)[1]
@@ -63,18 +67,20 @@ class NoiseDetection(FrameMultiDirectory, JobBase):
     def progress(self, i):
         self.callback('after_step', self.id, self.name, i)
         if not config.DISABLE_TQDM:
-            self.bar.update(1)
+            self.tbar.update(1)
             if self.callback('check_running', self.id, self.name) is False:
                 raise RunStopException(self.name)
 
     def run_core(self):
-        self.print_message(color_str("map noisy pixels from frames in " + self.folder_list_str(), "blue"))
+        self.print_message(color_str(
+            f"map noisy pixels from frames in {self.folder_list_str()}", "blue"
+        ))
         files = self.folder_filelist()
         in_paths = [self.working_path + "/" + f for f in files]
         n_frames = min(len(in_paths), self.max_frames) if self.max_frames > 0 else len(in_paths)
         self.callback('step_counts', self.id, self.name, n_frames)
         if not config.DISABLE_TQDM:
-            self.bar = make_tqdm_bar(self.name, n_frames)
+            self.tbar = make_tqdm_bar(self.name, n_frames)
 
         def progress_callback(i):
             self.progress(i)
@@ -82,10 +88,12 @@ class NoiseDetection(FrameMultiDirectory, JobBase):
                 raise RunStopException(self.name)
         mean_img = mean_image(
             file_paths=in_paths, max_frames=self.max_frames,
-            message_callback=lambda path: self.print_message_r(color_str(f"reading frame: {path.split('/')[-1]}", "blue")),
+            message_callback=lambda path: self.print_message_r(
+                color_str(f"reading frame: {path.split('/')[-1]}", "blue")
+            ),
             progress_callback=progress_callback)
         if not config.DISABLE_TQDM:
-            self.bar.close()
+            self.tbar.close()
         if mean_img is None:
             raise RuntimeError("Mean image is None")
         blurred = cv2.GaussianBlur(mean_img, (self.blur_size, self.blur_size), 0)
@@ -95,15 +103,14 @@ class NoiseDetection(FrameMultiDirectory, JobBase):
         hot_rgb = cv2.bitwise_or(hot_px[0], cv2.bitwise_or(hot_px[1], hot_px[2]))
         msg = []
         for ch, hot in zip(['rgb', *constants.RGB_LABELS], [hot_rgb] + hot_px):
-            msg.append("{}: {}".format(ch, np.count_nonzero(hot > 0)))
+            msg.append(f"{ch}: {np.count_nonzero(hot > 0)}")
         self.print_message("hot pixels: " + ", ".join(msg))
         path = "/".join(self.file_name.split("/")[:-1])
-        if not os.path.exists(self.working_path + '/' + path):
-            self.print_message("create directory: " + path)
-            os.mkdir(self.working_path + '/' + path)
-
-        self.print_message("writing hot pixels map file: " + self.file_name)
-        cv2.imwrite(self.working_path + '/' + self.file_name, hot)
+        if not os.path.exists(f"{self.working_path}/{path}"):
+            self.print_message(f"create directory: {path}")
+            os.mkdir(f"{self.working_path}/{path}")
+        self.print_message(f"writing hot pixels map file: {self.file_name}")
+        cv2.imwrite(f"{self.working_path}/{self.file_name}", hot_rgb)
         plot_range = self.plot_range
         min_th, max_th = min(self.channel_thresholds), max(self.channel_thresholds)
         if min_th < plot_range[0]:
@@ -114,7 +121,8 @@ class NoiseDetection(FrameMultiDirectory, JobBase):
         if self.plot_histograms:
             plt.figure(figsize=(10, 5))
             x = np.array(list(th_range))
-            ys = [[np.count_nonzero(self.hot_map(ch, th) > 0) for th in th_range] for ch in channels]
+            ys = [[np.count_nonzero(self.hot_map(ch, th) > 0)
+                  for th in th_range] for ch in channels]
             for i, ch, y in zip(range(3), constants.RGB_LABELS, ys):
                 plt.plot(x, y, c=ch, label=ch)
                 plt.plot([self.channel_thresholds[i], self.channel_thresholds[i]],
@@ -124,7 +132,7 @@ class NoiseDetection(FrameMultiDirectory, JobBase):
             plt.legend()
             plt.xlim(x[0], x[-1])
             plt.ylim(0)
-            plot_path = self.working_path + "/" + self.plot_path + "/" + self.name + "-hot-pixels.pdf"
+            plot_path = f"{self.working_path}/{self.plot_path}/{self.name}-hot-pixels.pdf"
             save_plot(plot_path)
             self.callback('save_plot', self.id, f"{self.name}: noise", plot_path)
             plt.close('all')
@@ -132,13 +140,16 @@ class NoiseDetection(FrameMultiDirectory, JobBase):
 
 class MaskNoise(SubAction):
     def __init__(self, noise_mask=constants.DEFAULT_NOISE_MAP_FILENAME,
-                 kernel_size=constants.DEFAULT_MN_KERNEL_SIZE, method=constants.INTERPOLATE_MEAN, **kwargs):
+                 kernel_size=constants.DEFAULT_MN_KERNEL_SIZE,
+                 method=constants.INTERPOLATE_MEAN, **kwargs):
         super().__init__(**kwargs)
         self.noise_mask = noise_mask if noise_mask != '' else constants.DEFAULT_NOISE_MAP_FILENAME
         self.kernel_size = kernel_size
         self.ks2 = self.kernel_size // 2
         self.ks2_1 = self.ks2 + 1
         self.method = method
+        self.process = None
+        self.noise_mask_img = None
 
     def begin(self, process):
         self.process = process
@@ -154,7 +165,7 @@ class MaskNoise(SubAction):
     def end(self):
         pass
 
-    def run_frame(self, idx, ref_idx, image):
+    def run_frame(self, _idx, _ref_idx, image):
         self.process.sub_message_r(': mask noisy pixels')
         if len(image.shape) == 3:
             corrected = image.copy()

shinestacker/algorithms/pyramid.py

@@ -1,32 +1,25 @@
+# pylint: disable=C0114, C0115, C0116, E1101
 import numpy as np
 import cv2
 from .. config.constants import constants
-from .. core.colors import color_str
-from .. core.exceptions import RunStopException, ImageLoadError, InvalidOptionError
-from .utils import read_img, get_img_metadata, validate_image
+from .. core.exceptions import RunStopException
+from .utils import read_img
+from .base_stack_algo import BaseStackAlgo
 
 
-class PyramidBase:
-    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE, kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
-                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL, float_type=constants.DEFAULT_PY_FLOAT):
+class PyramidBase(BaseStackAlgo):
+    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
+                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
+                 float_type=constants.DEFAULT_PY_FLOAT):
+        super().__init__("pyramid", 1, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.pad_amount = (kernel_size - 1) // 2
         self.do_step_callback = False
-        kernel = np.array([0.25 - gen_kernel / 2.0, 0.25, gen_kernel, 0.25, 0.25 - gen_kernel / 2.0])
+        kernel = np.array([0.25 - gen_kernel / 2.0, 0.25,
+                           gen_kernel, 0.25, 0.25 - gen_kernel / 2.0])
         self.gen_kernel = np.outer(kernel, kernel)
-        if float_type == constants.FLOAT_32:
-            self.float_type = np.float32
-        elif float_type == constants.FLOAT_64:
-            self.float_type = np.float64
-        else:
-            raise InvalidOptionError("float_type", float_type, details=" valid values are FLOAT_32 and FLOAT_64")
-
-    def print_message(self, msg):
-        self.process.sub_message_r(color_str(msg, "light_blue"))
-
-    def steps_per_frame(self):
-        return 1
 
     def convolve(self, image):
         return cv2.filter2D(image, -1, self.gen_kernel, borderType=cv2.BORDER_REFLECT101)
@@ -34,7 +27,8 @@ class PyramidBase:
     def reduce_layer(self, layer):
         if len(layer.shape) == 2:
             return self.convolve(layer)[::2, ::2]
-        reduced_channels = [self.reduce_layer(layer[:, :, channel]) for channel in range(layer.shape[2])]
+        reduced_channels = [self.reduce_layer(layer[:, :, channel])
+                            for channel in range(layer.shape[2])]
         return np.stack(reduced_channels, axis=-1)
 
     def expand_layer(self, layer):
@@ -83,7 +77,9 @@ class PyramidBase:
         return self.float_type(-1. * (levels * np.log(probabilities[levels])).sum())
 
     def get_pad(self, padded_image, row, column):
-        return padded_image[row + self.pad_amount + self.offset[:, np.newaxis], column + self.pad_amount + self.offset]
+        return padded_image[row + self.pad_amount +
+                            self.offset[:, np.newaxis], column +
+                            self.pad_amount + self.offset]
 
     def area_deviation(self, area):
         return np.square(area - np.average(area).astype(self.float_type)).sum() / area.size
@@ -92,15 +88,17 @@ class PyramidBase:
         padded_image = cv2.copyMakeBorder(image, self.pad_amount, self.pad_amount, self.pad_amount,
                                           self.pad_amount, cv2.BORDER_REFLECT101)
         return np.fromfunction(
-            np.vectorize(lambda row, column: self.area_deviation(self.get_pad(padded_image, row, column))),
+            np.vectorize(lambda row, column:
+                         self.area_deviation(self.get_pad(padded_image, row, column))),
             image.shape[:2], dtype=int)
 
     def get_fused_base(self, images):
-        layers, height, width, _ = images.shape
+        layers = images.shape[0]
         entropies = np.zeros(images.shape[:3], dtype=self.float_type)
         deviations = np.copy(entropies)
-        gray_images = np.array([cv2.cvtColor(images[layer].astype(np.float32),
-                                             cv2.COLOR_BGR2GRAY).astype(self.dtype) for layer in range(layers)])
+        gray_images = np.array([cv2.cvtColor(
+            images[layer].astype(np.float32),
+            cv2.COLOR_BGR2GRAY).astype(self.dtype) for layer in range(layers)])
         entropies = np.array([self.entropy(img) for img in gray_images])
         deviations = np.array([self.deviation(img) for img in gray_images])
         best_e = np.argmax(entropies, axis=0)
@@ -114,13 +112,15 @@ class PyramidBase:
 
 
 class PyramidStack(PyramidBase):
-    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE, kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
-                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL, float_type=constants.DEFAULT_PY_FLOAT):
+    def __init__(self, min_size=constants.DEFAULT_PY_MIN_SIZE,
+                 kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
+                 gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
+                 float_type=constants.DEFAULT_PY_FLOAT):
         super().__init__(min_size, kernel_size, gen_kernel, float_type)
         self.offset = np.arange(-self.pad_amount, self.pad_amount + 1)
-
-    def name(self):
-        return "pyramid"
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
 
     def process_single_image(self, img, levels):
         pyramid = [img.astype(self.float_type)]
@@ -141,7 +141,7 @@ class PyramidStack(PyramidBase):
     def fuse_pyramids(self, all_laplacians):
         fused = [self.get_fused_base(np.stack([p[-1] for p in all_laplacians], axis=0))]
         for layer in range(len(all_laplacians[0]) - 2, -1, -1):
-            self.print_message(': fusing pyramids, layer: {}'.format(layer + 1))
+            self.print_message(f': fusing pyramids, layer: {layer + 1}')
             laplacians = np.stack([p[layer] for p in all_laplacians], axis=0)
             fused.append(self.fuse_laplacian(laplacians))
         self.print_message(': pyramids fusion completed')
@@ -152,24 +152,24 @@ class PyramidStack(PyramidBase):
         all_laplacians = []
         levels = None
         for i, img_path in enumerate(filenames):
-            self.print_message(': validating file {}'.format(img_path.split('/')[-1]))
-            img = read_img(img_path)
-            if img is None:
-                raise ImageLoadError(img_path)
-            if metadata is None:
-                metadata = get_img_metadata(img)
+            self.print_message(f": validating file {img_path.split('/')[-1]}")
+
+            img, metadata, updated = self.read_image_and_update_metadata(img_path, metadata)
+
+            if updated:
                 self.dtype = metadata[1]
-                self.num_pixel_values = constants.NUM_UINT8 if self.dtype == np.uint8 else constants.NUM_UINT16
-                self.max_pixel_value = constants.MAX_UINT8 if self.dtype == np.uint8 else constants.MAX_UINT16
+                self.num_pixel_values = constants.NUM_UINT8 \
+                    if self.dtype == np.uint8 else constants.NUM_UINT16
+                self.max_pixel_value = constants.MAX_UINT8 \
+                    if self.dtype == np.uint8 else constants.MAX_UINT16
                 levels = int(np.log2(min(img.shape[:2]) / self.min_size))
-            else:
-                validate_image(img, *metadata)
+
             if self.do_step_callback:
                 self.process.callback('after_step', self.process.id, self.process.name, i)
             if self.process.callback('check_running', self.process.id, self.process.name) is False:
                 raise RunStopException(self.name)
         for img_path in filenames:
-            self.print_message(': processing file {}'.format(img_path.split('/')[-1]))
+            self.print_message(f": processing file {img_path.split('/')[-1]}")
             img = read_img(img_path)
             all_laplacians.append(self.process_single_image(img, levels))
         stacked_image = self.collapse(self.fuse_pyramids(all_laplacians))

shinestacker/algorithms/sharpen.py

@@ -1,3 +1,4 @@
+# pylint: disable=C0114, C0116, E1101
 import cv2
 import numpy as np
 

shinestacker/algorithms/stack.py

@@ -1,5 +1,6 @@
-import numpy as np
+# pylint: disable=C0114, C0115, C0116, R0913, R0917
 import os
+import numpy as np
 from .. config.constants import constants
 from .. core.colors import color_str
 from .. core.framework import JobBase
@@ -10,15 +11,15 @@ from .exif import copy_exif_from_file_to_file
 from .denoise import denoise
 
 
-class FocusStackBase:
-    def __init__(self, stack_algo, exif_path='',
-                 prefix=constants.DEFAULT_STACK_PREFIX,
-                 denoise=0, plot_stack=False):
+class FocusStackBase(JobBase, FrameDirectory):
+    def __init__(self, name, stack_algo, enabled=True, **kwargs):
+        FrameDirectory.__init__(self, name, **kwargs)
+        JobBase.__init__(self, name, enabled)
         self.stack_algo = stack_algo
-        self.exif_path = exif_path
-        self.prefix = prefix if prefix != '' else constants.DEFAULT_STACK_PREFIX
-        self.denoise = denoise
-        self.plot_stack = plot_stack
+        self.exif_path = kwargs.pop('exif_path', '')
+        self.prefix = kwargs.pop('prefix', constants.DEFAULT_STACK_PREFIX)
+        self.denoise_amount = kwargs.pop('denoise_amount', 0)
+        self.plot_stack = kwargs.pop('plot_stack', constants.DEFAULT_PLOT_STACK)
         self.stack_algo.process = self
         self.frame_count = -1
 
@@ -27,20 +28,22 @@ class FocusStackBase:
         img_files = sorted([os.path.join(self.input_full_path, name) for name in filenames])
         stacked_img = self.stack_algo.focus_stack(img_files)
         in_filename = filenames[0].split(".")
-        out_filename = f"{self.output_dir}/{self.prefix}{in_filename[0]}." + '.'.join(in_filename[1:])
-        if self.denoise > 0:
+        out_filename = f"{self.output_dir}/{self.prefix}{in_filename[0]}." + \
+            '.'.join(in_filename[1:])
+        if self.denoise_amount > 0:
             self.sub_message_r(': denoise image')
-            stacked_img = denoise(stacked_img, self.denoise, self.denoise)
+            stacked_img = denoise(stacked_img, self.denoise_amount, self.denoise_amount)
         write_img(out_filename, stacked_img)
         if self.exif_path != '' and stacked_img.dtype == np.uint8:
             self.sub_message_r(': copy exif data')
-            dirpath, _, fnames = next(os.walk(self.exif_path))
-            fnames = [name for name in fnames if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
+            _dirpath, _, fnames = next(os.walk(self.exif_path))
+            fnames = [name for name in fnames
+                      if os.path.splitext(name)[-1][1:].lower() in constants.EXTENSIONS]
             exif_filename = f"{self.exif_path}/{fnames[0]}"
             copy_exif_from_file_to_file(exif_filename, out_filename)
             self.sub_message_r(' ' * 60)
         if self.plot_stack:
-            idx_str = "{:04d}".format(self.frame_count) if self.frame_count >= 0 else ''
+            idx_str = f"{self.frame_count:04d}" if self.frame_count >= 0 else ''
             name = f"{self.name}: {self.stack_algo.name()}"
             if idx_str != '':
                 name += f"\nbunch: {idx_str}"
@@ -48,65 +51,63 @@ class FocusStackBase:
         if self.frame_count >= 0:
             self.frame_count += 1
 
-    def init(self, job, working_path):
+    def init(self, job, working_path=''):
         if self.exif_path is None:
             self.exif_path = job.paths[0]
         if self.exif_path != '':
             self.exif_path = working_path + "/" + self.exif_path
 
 
-class FocusStackBunch(FocusStackBase, FrameDirectory, ActionList):
+def get_bunches(collection, n_frames, n_overlap):
+    bunches = [collection[x:x + n_frames]
+               for x in range(0, len(collection) - n_overlap, n_frames - n_overlap)]
+    return bunches
+
+
+class FocusStackBunch(ActionList, FocusStackBase):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
-        FocusStackBase.__init__(self, stack_algo,
-                                exif_path=kwargs.pop('exif_path', ''),
-                                prefix=kwargs.pop('prefix', constants.DEFAULT_STACK_PREFIX),
-                                denoise=kwargs.pop('denoise', 0),
-                                plot_stack=kwargs.pop('plot_stack', constants.DEFAULT_PLOT_STACK_BUNCH))
-        FrameDirectory.__init__(self, name, **kwargs)
         ActionList.__init__(self, name, enabled)
+        FocusStackBase.__init__(self, name, stack_algo, enabled, **kwargs)
+        self._chunks = None
         self.frame_count = 0
         self.frames = kwargs.get('frames', constants.DEFAULT_FRAMES)
         self.overlap = kwargs.get('overlap', constants.DEFAULT_OVERLAP)
-        self.denoise = kwargs.get('denoise', 0)
+        self.denoise_amount = kwargs.get('denoise_amount', 0)
         self.stack_algo.do_step_callback = False
         if self.overlap >= self.frames:
-            raise InvalidOptionError("overlap", self.overlap, "overlap must be smaller than batch size")
+            raise InvalidOptionError("overlap", self.overlap,
+                                     "overlap must be smaller than batch size")
 
-    def init(self, job):
+    def init(self, job, _working_path=''):
         FrameDirectory.init(self, job)
         FocusStackBase.init(self, job, self.working_path)
 
     def begin(self):
         ActionList.begin(self)
-        fnames = self.folder_filelist(self.input_full_path)
-        self.__chunks = [fnames[x:x + self.frames] for x in range(0, len(fnames) - self.overlap, self.frames - self.overlap)]
-        self.set_counts(len(self.__chunks))
+        fnames = self.folder_filelist()
+        self._chunks = get_bunches(fnames, self.frames, self.overlap)
+        self.set_counts(len(self._chunks))
 
     def end(self):
         ActionList.end(self)
 
     def run_step(self):
-        self.print_message_r(color_str("fusing bunch: {}".format(self.count), "blue"))
-        self.focus_stack(self.__chunks[self.count - 1])
+        self.print_message_r(color_str(f"fusing bunch: {self.count}", "blue"))
+        self.focus_stack(self._chunks[self.count - 1])
         self.callback('after_step', self.id, self.name, self.count)
 
 
-class FocusStack(FocusStackBase, FrameDirectory, JobBase):
+class FocusStack(FocusStackBase):
     def __init__(self, name, stack_algo, enabled=True, **kwargs):
-        FocusStackBase.__init__(self, stack_algo,
-                                exif_path=kwargs.pop('exif_path', ''),
-                                prefix=kwargs.pop('prefix', constants.DEFAULT_STACK_PREFIX),
-                                denoise=kwargs.pop('denoise', 0),
-                                plot_stack=kwargs.pop('plot_stack', constants.DEFAULT_PLOT_STACK))
-        FrameDirectory.__init__(self, name, **kwargs)
-        JobBase.__init__(self, name, enabled)
+        super().__init__(name, stack_algo, enabled, **kwargs)
         self.stack_algo.do_step_callback = True
 
     def run_core(self):
         self.set_filelist()
-        self.callback('step_counts', self.id, self.name, self.stack_algo.steps_per_frame() * len(self.filenames))
+        self.callback('step_counts', self.id, self.name,
+                      self.stack_algo.steps_per_frame() * len(self.filenames))
         self.focus_stack(self.filenames)
 
-    def init(self, job):
+    def init(self, job, _working_path=''):
         FrameDirectory.init(self, job)
         FocusStackBase.init(self, job, self.working_path)