shinestacker 1.2.1__py3-none-any.whl → 1.3.1__py3-none-any.whl

shinestacker/algorithms/align_parallel.py

@@ -0,0 +1,336 @@
+# pylint: disable=C0114, C0115, C0116, W0718, R0912, R0915, E1101, R0914, R0911, E0606, R0801, R0902
+import gc
+import copy
+import math
+import traceback
+import threading
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import numpy as np
+import cv2
+from ..config.constants import constants
+from .. core.exceptions import InvalidOptionError, RunStopException
+from .. core.colors import color_str
+from .. core.core_utils import make_chunks
+from .utils import read_img, img_subsample, img_bw, img_bw_8bit
+from .align import (AlignFramesBase, find_transform,
+                    check_transform, _cv2_border_mode_map, rescale_trasnsform,
+                    validate_align_config, detector_map, descriptor_map,
+                    get_good_matches)
+
+
+def compose_transforms(t1, t2, transform_type):
+    t1 = t1.astype(np.float64)
+    t2 = t2.astype(np.float64)
+    if transform_type == constants.ALIGN_RIGID:
+        t1_homo = np.vstack([t1, [0, 0, 1]])
+        t2_homo = np.vstack([t2, [0, 0, 1]])
+        result_homo = t2_homo @ t1_homo
+        return result_homo[:2, :]
+    return t2 @ t1
+
+
+class AlignFramesParallel(AlignFramesBase):
+    def __init__(self, enabled=True, feature_config=None, matching_config=None,
+                 alignment_config=None, **kwargs):
+        super().__init__(enabled, feature_config, matching_config,
+                         alignment_config, **kwargs)
+        self.max_threads = kwargs.get('max_threads', constants.DEFAULT_ALIGN_MAX_THREADS)
+        self.chunk_submit = kwargs.get('chunk_submit', constants.DEFAULT_ALIGN_CHUNK_SUBMIT)
+        self.bw_matching = kwargs.get('bw_matching', constants.DEFAULT_ALIGN_BW_MATCHING)
+        self._img_cache = None
+        self._img_locks = None
+        self._cache_locks = None
+        self._target_indices = None
+        self._transforms = None
+        self._cumulative_transforms = None
+        self.step_counter = 0
+        self._kp = None
+        self._des = None
+
+    def cache_img(self, idx):
+        with self._cache_locks[idx]:
+            self._img_locks[idx] += 1
+            if self._img_cache[idx] is None:
+                img = read_img(self.process.input_filepath(idx))
+                if self.bw_matching:
+                    img = img_bw(img)
+                self._img_cache[idx] = img
+            return self._img_cache[idx]
+
+    def submit_threads(self, idxs, imgs):
+        with ThreadPoolExecutor(max_workers=len(imgs)) as executor:
+            future_to_index = {}
+            for idx in idxs:
+                self.print_message(
+                    f"submit alignment matches, {self.image_str(idx)}")
+                future = executor.submit(self.extract_features, idx)
+                future_to_index[future] = idx
+            for future in as_completed(future_to_index):
+                idx = future_to_index[future]
+                try:
+                    info_messages, warning_messages = future.result()
+                    message = f"{self.image_str(idx)}: " \
+                              f"matches found: {self._n_good_matches[idx]}"
+                    if len(info_messages) > 0:
+                        message += ", " + ", ".join(info_messages)
+                    color = constants.LOG_COLOR_LEVEL_3
+                    level = logging.INFO
+                    if len(warning_messages) > 0:
+                        message += ", " + color_str(", ".join(warning_messages), 'yellow')
+                        color = constants.LOG_COLOR_WARNING
+                        level = logging.WARNING
+                    self.print_message(message, color=color, level=level)
+                    self.step_counter += 1
+                    self.process.after_step(self.step_counter)
+                    self.process.check_running()
+                except RunStopException as e:
+                    raise e
+                except Exception as e:
+                    traceback.print_tb(e.__traceback__)
+                    self.print_message(
+                        f"failed processing {self.image_str(idx)}: {str(e)}")
+            cached_images = 0
+            for i in range(self.process.num_input_filepaths()):
+                if self._img_locks[i] >= 2:
+                    self._img_cache[i] = None
+                    self._img_locks[i] = 0
+                elif self._img_cache[i] is not None:
+                    cached_images += 1
+            # self.print_message(f"cached images: {cached_images}")
+        gc.collect()
+
+    def begin(self, process):
+        super().begin(process)
+        if self.plot_matches:
+            self.print_message(
+                "requested plot matches is not supported with parallel processing",
+                color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+        n_frames = self.process.num_input_filepaths()
+        self.print_message(f"preprocess {n_frames} images in parallel, cores: {self.max_threads}")
+        self.process.callback(constants.CALLBACK_STEP_COUNTS,
+                              self.process.id, self.process.name, 2 * n_frames)
+        input_filepaths = self.process.input_filepaths()
+        self._img_cache = [None] * n_frames
+        self._img_locks = [0] * n_frames
+        self._cache_locks = [threading.Lock() for _ in range(n_frames)]
+        self._target_indices = [None] * n_frames
+        self._n_good_matches = [0] * n_frames
+        self._transforms = [None] * n_frames
+        self._cumulative_transforms = [None] * n_frames
+        self._kp = [None] * n_frames
+        self._des = [None] * n_frames
+        max_chunck_size = self.max_threads
+        ref_idx = self.process.ref_idx
+        self.print_message(f"reference: {self.image_str(ref_idx)}")
+        sub_indices = list(range(n_frames))
+        sub_indices.remove(ref_idx)
+        sub_img_filepaths = copy.deepcopy(input_filepaths)
+        sub_img_filepaths.remove(input_filepaths[ref_idx])
+        self.step_counter = 0
+        if self.chunk_submit:
+            img_chunks = make_chunks(sub_img_filepaths, max_chunck_size)
+            idx_chunks = make_chunks(sub_indices, max_chunck_size)
+            for idxs, imgs in zip(idx_chunks, img_chunks):
+                self.submit_threads(idxs, imgs)
+        else:
+            self.submit_threads(sub_indices, sub_img_filepaths)
+        for idx in range(n_frames):
+            if self._img_cache[idx] is not None:
+                self._img_cache[idx] = None
+                self._kp[idx] = None
+                self._des[idx] = None
+        gc.collect()
+        self.print_message("combining transformations")
+        transform_type = self.alignment_config['transform']
+        if transform_type == constants.ALIGN_RIGID:
+            identity = np.array([[1.0, 0.0, 0.0],
+                                 [0.0, 1.0, 0.0]], dtype=np.float64)
+        else:
+            identity = np.eye(3, dtype=np.float64)
+        self._cumulative_transforms[ref_idx] = identity
+        frames_to_process = []
+        for i in range(n_frames):
+            if i != ref_idx:
+                frames_to_process.append((i, abs(i - ref_idx)))
+        frames_to_process.sort(key=lambda x: x[1])
+        for i, _ in frames_to_process:
+            target_idx = self._target_indices[i]
+            if target_idx is not None and self._cumulative_transforms[target_idx] is not None:
+                self._cumulative_transforms[i] = compose_transforms(
+                    self._transforms[i], self._cumulative_transforms[target_idx], transform_type)
+            else:
+                self._cumulative_transforms[i] = None
+                self.print_message(
+                    f"warning: no cumulative transform for {self.image_str(i)}",
+                    color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+        for idx in range(n_frames):
+            self._transforms[idx] = None
+        gc.collect()
+        missing_transforms = 0
+        for i in range(n_frames):
+            if self._cumulative_transforms[i] is not None:
+                self._cumulative_transforms[i] = self._cumulative_transforms[i].astype(np.float32)
+            else:
+                missing_transforms += 1
+        msg = "feature extaction completed"
+        if missing_transforms > 0:
+            msg += ", " + color_str(f"images not matched: {missing_transforms}",
+                                    constants.LOG_COLOR_WARNING)
+        self.print_message(msg)
+        self.process.add_begin_steps(n_frames)
+
+    def detect_and_compute_matches(self, img_ref, ref_idx, img_0, idx):
+        feature_config, matching_config = self.feature_config, self.matching_config
+        feature_config_detector = feature_config['detector']
+        feature_config_descriptor = feature_config['descriptor']
+        match_method = matching_config['match_method']
+        validate_align_config(feature_config_detector, feature_config_descriptor, match_method)
+        img_bw_0, img_bw_ref = img_bw_8bit(img_0), img_bw_8bit(img_ref)
+        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):
+            if self._kp[idx] is None or self._des[idx] is None:
+                kp_0, des_0 = detector.detectAndCompute(img_bw_0, None)
+            else:
+                kp_0, des_0 = self._kp[idx], self._des[idx]
+            if self._kp[ref_idx] is None or self._des[ref_idx] is None:
+                kp_ref, des_ref = detector.detectAndCompute(img_bw_ref, None)
+            else:
+                kp_ref, des_ref = self._kp[ref_idx], self._des[ref_idx]
+        else:
+            descriptor = descriptor_map[feature_config_descriptor]()
+            kp_0, des_0 = descriptor.compute(img_bw_0, detector.detect(img_bw_0, None))
+            kp_ref, des_ref = descriptor.compute(img_bw_ref, detector.detect(img_bw_ref, None))
+        return kp_0, kp_ref, get_good_matches(des_0, des_ref, matching_config)
+
+    def extract_features(self, idx, delta=1):
+        ref_idx = self.process.ref_idx
+        pass_ref_err_msg = "cannot find path to reference frame"
+        if idx < ref_idx:
+            target_idx = idx + delta
+            if target_idx > ref_idx:
+                self._target_indices[idx] = None
+                self._transforms[idx] = None
+                return [], [pass_ref_err_msg]
+        elif idx > ref_idx:
+            target_idx = idx - delta
+            if target_idx < ref_idx:
+                self._target_indices[idx] = None
+                self._transforms[idx] = None
+                return [], [pass_ref_err_msg]
+        else:
+            self._target_indices[idx] = None
+            self._transforms[idx] = None
+            return [], []
+        info_messages = []
+        warning_messages = []
+        img_0 = self.cache_img(idx)
+        img_ref = self.cache_img(target_idx)
+        h0, w0 = img_0.shape[:2]
+        subsample = self.alignment_config['subsample']
+        if subsample == 0:
+            img_res = (float(h0) / constants.ONE_KILO) * (float(w0) / constants.ONE_KILO)
+            target_res = constants.DEFAULT_ALIGN_RES_TARGET_MPX
+            subsample = int(1 + math.floor(img_res / target_res))
+        fast_subsampling = self.alignment_config['fast_subsampling']
+        min_good_matches = self.alignment_config['min_good_matches']
+        while True:
+            if subsample > 1:
+                img_0_sub = img_subsample(img_0, subsample, fast_subsampling)
+                img_ref_sub = img_subsample(img_ref, subsample, fast_subsampling)
+            else:
+                img_0_sub, img_ref_sub = img_0, img_ref
+            kp_0, kp_ref, good_matches = self.detect_and_compute_matches(
+                img_ref_sub, ref_idx, img_0_sub, idx)
+            n_good_matches = len(good_matches)
+            if n_good_matches > min_good_matches or subsample == 1:
+                break
+            subsample = 1
+            warning_messages.append("too few matches, no subsampling applied")
+        self._n_good_matches[idx] = n_good_matches
+        m = None
+        min_matches = 4 if self.alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
+        if n_good_matches < min_matches:
+            self.print_message(
+                f"warning: only {n_good_matches} found for "
+                f"{self.image_str(idx)}, trying next frame",
+                color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+            return self.extract_features(idx, delta + 1)
+        transform = self.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_ref[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+        m, _msk = find_transform(src_pts, dst_pts, transform, self.alignment_config['align_method'],
+                                 *(self.alignment_config[k]
+                                   for k in ['rans_threshold', 'max_iters',
+                                             'align_confidence', 'refine_iters']))
+        h_sub, w_sub = img_0_sub.shape[:2]
+        if subsample > 1:
+            m = rescale_trasnsform(m, w0, h0, w_sub, h_sub, subsample, transform)
+            if m is None:
+                self.print_message(
+                    f"invalid option {transform} "
+                    f"for {self.image_str(idx)}, trying next frame",
+                    color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+                return self.extract_features(idx, delta + 1)
+        transform_type = self.alignment_config['transform']
+        thresholds = self.get_transform_thresholds()
+        is_valid, _reason, _result = check_transform(m, img_0, transform_type, *thresholds)
+        if not is_valid:
+            msg = f"invalid transformation for {self.image_str(idx)}"
+            do_abort = self.alignment_config['abort_abnormal']
+            if not do_abort:
+                msg += ", trying next frame"
+            self.print_message(
+                msg, color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+            if do_abort:
+                raise RuntimeError("invalid transformation: {reason}")
+            return self.extract_features(idx, delta + 1)
+        self._transforms[idx] = m
+        self._target_indices[idx] = target_idx
+        return info_messages, warning_messages
+
+    def align_images(self, idx, img_ref, img_0):
+        m = self._cumulative_transforms[idx]
+        if m is None:
+            self.print_message(
+                f"no transformation for {self.image_str(idx)}, skipping alignment",
+                color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+            return img_0
+        transform_type = self.alignment_config['transform']
+        if transform_type == constants.ALIGN_RIGID and m.shape != (2, 3):
+            self.print_message(f"invalid matrix shape for rigid transform: {m.shape}")
+            return img_0
+        if transform_type == constants.ALIGN_HOMOGRAPHY and m.shape != (3, 3):
+            self.print_message(f"invalid matrix shape for homography: {m.shape}")
+            return img_0
+        self.print_message(f'{self.image_str(idx)}: apply image alignment')
+        try:
+            cv2_border_mode = _cv2_border_mode_map[self.alignment_config['border_mode']]
+        except KeyError as e:
+            raise InvalidOptionError("border_mode", self.alignment_config['border_mode']) from e
+        img_mask = np.ones_like(img_0, dtype=np.uint8)
+        h_ref, w_ref = img_ref.shape[:2]
+        if self.alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY:
+            img_warp = cv2.warpPerspective(
+                img_0, m, (w_ref, h_ref),
+                borderMode=cv2_border_mode, borderValue=self.alignment_config['border_value'])
+            if self.alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
+                mask = cv2.warpPerspective(img_mask, m, (w_ref, h_ref),
+                                           borderMode=cv2.BORDER_CONSTANT, borderValue=0)
+        elif self.alignment_config['transform'] == constants.ALIGN_RIGID:
+            img_warp = cv2.warpAffine(
+                img_0, m, (w_ref, h_ref),
+                borderMode=cv2_border_mode, borderValue=self.alignment_config['border_value'])
+            if self.alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
+                mask = cv2.warpAffine(img_mask, m, (w_ref, h_ref),
+                                      borderMode=cv2.BORDER_CONSTANT, borderValue=0)
+        if self.alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
+            self.print_message(f'{self.image_str(idx)}: blur borders')
+            mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
+            blurred_warp = cv2.GaussianBlur(
+                img_warp, (21, 21), sigmaX=self.alignment_config['border_blur'])
+            img_warp[mask == 0] = blurred_warp[mask == 0]
+        return img_warp

shinestacker/algorithms/balance.py

@@ -609,6 +609,8 @@ class BalanceFrames(SubAction):
 
     def run_frame(self, idx, _ref_idx, image):
         if idx != self.process.ref_idx:
-            self.process.sub_message_r(color_str(': balance image', constants.LOG_COLOR_LEVEL_3))
+            self.process.print_message(
+                color_str(f'{self.process.idx_tot_str(idx)}: balance image',
+                          constants.LOG_COLOR_LEVEL_3))
         image = self.correction.apply_correction(idx, image)
         return image

shinestacker/algorithms/base_stack_algo.py

@@ -1,10 +1,10 @@
-# pylint: disable=C0114, C0115, C0116, E0602, R0903
+# pylint: disable=C0114, C0115, C0116, E0602, R0903, R0902
 import os
 import numpy as np
-from .. core.exceptions import InvalidOptionError, ImageLoadError, RunStopException
+from .. core.exceptions import InvalidOptionError, RunStopException
 from .. config.constants import constants
 from .. core.colors import color_str
-from .utils import read_img, get_img_metadata, validate_image, get_img_file_shape, extension_tif_jpg
+from .utils import read_img, get_img_metadata, get_first_image_file
 
 
 class BaseStackAlgo:
@@ -14,6 +14,9 @@ class BaseStackAlgo:
         self.process = None
         self.filenames = None
         self.shape = None
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
         self.do_step_callback = False
         if float_type == constants.FLOAT_32:
             self.float_type = np.float32
@@ -34,14 +37,23 @@ class BaseStackAlgo:
     def set_do_step_callback(self, enable):
         self.do_step_callback = enable
 
+    def idx_tot_str(self, idx):
+        return f"{idx + 1}/{len(self.filenames)}"
+
+    def image_str(self, idx):
+        return f"image: {self.idx_tot_str(idx)}, " \
+               f"{os.path.basename(self.filenames[idx])}"
+
+    def num_images(self):
+        return len(self.filenames)
+
     def init(self, filenames):
         self.filenames = filenames
-        first_img_file = ''
-        for filename in filenames:
-            if os.path.isfile(filename) and extension_tif_jpg(filename):
-                first_img_file = filename
-                break
-        self.shape = get_img_file_shape(first_img_file)
+        self.shape, self.dtype = get_img_metadata(read_img(get_first_image_file(filenames)))
+        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
 
     def total_steps(self, n_frames):
         return self._steps_per_frame * n_frames
@@ -49,23 +61,14 @@ class BaseStackAlgo:
     def print_message(self, msg):
         self.process.sub_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_3))
 
-    def read_image_and_update_metadata(self, img_path, metadata):
-        img = read_img(img_path)
-        if img is None:
-            raise ImageLoadError(img_path)
-        updated = metadata is None
-        if updated:
-            metadata = get_img_metadata(img)
-        else:
-            validate_image(img, *metadata)
-        return img, metadata, updated
-
     def check_running(self, cleanup_callback=None):
-        if self.process.callback('check_running', self.process.id, self.process.name) is False:
+        if self.process.callback(constants.CALLBACK_CHECK_RUNNING,
+                                 self.process.id, self.process.name) is False:
             if cleanup_callback is not None:
                 cleanup_callback()
             raise RunStopException(self.name)
 
     def after_step(self, step):
         if self.do_step_callback:
-            self.process.callback('after_step', self.process.id, self.process.name, step)
+            self.process.callback(constants.CALLBACK_AFTER_STEP,
+                                  self.process.id, self.process.name, step)

shinestacker/algorithms/depth_map.py

@@ -3,7 +3,7 @@ import numpy as np
 import cv2
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
-from .utils import read_img, img_bw
+from .utils import read_img, read_and_validate_img, img_bw
 from .base_stack_algo import BaseStackAlgo
 
 
@@ -62,19 +62,15 @@ class DepthMapStack(BaseStackAlgo):
                                  f"{constants.DM_MAP_AVERAGE} and {constants.DM_MAP_MAX}.")
 
     def focus_stack(self):
-        gray_images = []
-        metadata = None
+        n_images = len(self.filenames)
+        gray_images = np.empty((n_images, *self.shape), dtype=self.float_type)
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": reading file (1/2) {img_path.split('/')[-1]}")
-
-            img, metadata, _updated = self.read_image_and_update_metadata(img_path, metadata)
-
+            self.print_message(f": reading and validating {self.image_str(i)}")
+            img = read_and_validate_img(img_path, self.shape, self.dtype)
             gray = img_bw(img)
-            gray_images.append(gray)
+            gray_images[i] = gray.astype(self.float_type)
             self.after_step(i)
             self.check_running()
-        dtype = metadata[1]
-        gray_images = np.array(gray_images, dtype=self.float_type)
         if self.energy == constants.DM_ENERGY_SOBEL:
             energies = self.get_sobel_map(gray_images)
         elif self.energy == constants.DM_ENERGY_LAPLACIAN:
@@ -92,7 +88,7 @@ class DepthMapStack(BaseStackAlgo):
         weights = self.get_focus_map(energies)
         blended_pyramid = None
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": reading file (2/2) {img_path.split('/')[-1]}")
+            self.print_message(f": reading {self.image_str(i)}")
             img = read_img(img_path).astype(self.float_type)
             weight = weights[i]
             gp_img = [img]
@@ -109,12 +105,11 @@ class DepthMapStack(BaseStackAlgo):
                              for j in range(self.levels)]
             blended_pyramid = current_blend if blended_pyramid is None \
                 else [np.add(bp, cb) for bp, cb in zip(blended_pyramid, current_blend)]
-            self.after_step(i + len(self.filenames))
+            self.after_step(i + n_images)
             self.check_running()
         result = blended_pyramid[0]
         self.print_message(': blend levels')
         for j in range(1, self.levels):
             size = (blended_pyramid[j].shape[1], blended_pyramid[j].shape[0])
             result = cv2.pyrUp(result, dstsize=size) + blended_pyramid[j]
-        n_values = constants.MAX_UINT8 if dtype == np.uint8 else constants.MAX_UINT16
-        return np.clip(np.absolute(result), 0, n_values).astype(dtype)
+        return np.clip(np.absolute(result), 0, self.num_pixel_values).astype(self.dtype)

shinestacker/algorithms/multilayer.py

@@ -12,9 +12,9 @@ from psdtags import (PsdBlendMode, PsdChannel, PsdChannelId, PsdClippingType, Ps
 from .. config.constants import constants
 from .. config.config import config
 from .. core.colors import color_str
-from .. core.framework import JobBase
+from .. core.framework import TaskBase
 from .utils import EXTENSIONS_TIF, EXTENSIONS_JPG, EXTENSIONS_PNG
-from .stack_framework import FramePaths
+from .stack_framework import ImageSequenceManager
 from .exif import exif_extra_tags_for_tif, get_exif
 
 
@@ -159,10 +159,10 @@ def write_multilayer_tiff_from_images(image_dict, output_file, exif_path='', cal
                      compression=compression, metadata=None, **tiff_tags)
 
 
-class MultiLayer(JobBase, FramePaths):
+class MultiLayer(TaskBase, ImageSequenceManager):
     def __init__(self, name, enabled=True, **kwargs):
-        FramePaths.__init__(self, name, **kwargs)
-        JobBase.__init__(self, name, enabled)
+        ImageSequenceManager.__init__(self, name, **kwargs)
+        TaskBase.__init__(self, name, enabled)
         self.exif_path = kwargs.get('exif_path', '')
         self.reverse_order = kwargs.get(
             'reverse_order',
@@ -170,9 +170,9 @@ class MultiLayer(JobBase, FramePaths):
         )
 
     def init(self, job):
-        FramePaths.init(self, job)
+        ImageSequenceManager.init(self, job)
         if self.exif_path == '':
-            self.exif_path = job.paths[0]
+            self.exif_path = job.action_path(0)
         if self.exif_path != '':
             self.exif_path = self.working_path + "/" + self.exif_path
 
@@ -217,4 +217,4 @@ class MultiLayer(JobBase, FramePaths):
         write_multilayer_tiff(input_files, output_file, labels=None, exif_path=self.exif_path,
                               callbacks=callbacks)
         app = 'internal_retouch_app' if config.COMBINED_APP else f'{constants.RETOUCH_APP}'
-        self.callback('open_app', self.id, self.name, app, output_file)
+        self.callback(constants.CALLBACK_OPEN_APP, self.id, self.name, app, output_file)

shinestacker/algorithms/noise_detection.py

@@ -9,10 +9,10 @@ from .. config.config import config
 from .. config.constants import constants
 from .. core.colors import color_str
 from .. core.exceptions import ImageLoadError
-from .. core.framework import JobBase
+from .. core.framework import TaskBase
 from .. core.core_utils import make_tqdm_bar
 from .. core.exceptions import RunStopException, ShapeError
-from .stack_framework import FramePaths, SubAction
+from .stack_framework import ImageSequenceManager, SubAction
 from .utils import read_img, save_plot, get_img_metadata, validate_image
 
 MAX_NOISY_PIXELS = 1000
@@ -45,10 +45,10 @@ 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(JobBase, FramePaths):
+class NoiseDetection(TaskBase, ImageSequenceManager):
     def __init__(self, name="noise-map", enabled=True, **kwargs):
-        FramePaths.__init__(self, name, **kwargs)
-        JobBase.__init__(self, name, enabled)
+        ImageSequenceManager.__init__(self, name, **kwargs)
+        TaskBase.__init__(self, name, enabled)
         self.max_frames = kwargs.get('max_frames', constants.DEFAULT_NOISE_MAX_FRAMES)
         self.blur_size = kwargs.get('blur_size', constants.DEFAULT_BLUR_SIZE)
         self.file_name = kwargs.get('file_name', constants.DEFAULT_NOISE_MAP_FILENAME)
@@ -65,10 +65,10 @@ class NoiseDetection(JobBase, FramePaths):
         return cv2.threshold(ch, th, 255, cv2.THRESH_BINARY)[1]
 
     def progress(self, i):
-        self.callback('after_step', self.id, self.name, i)
+        self.callback(constants.CALLBACK_AFTER_STEP, self.id, self.name, i)
         if not config.DISABLE_TQDM:
             self.tbar.update(1)
-            if self.callback('check_running', self.id, self.name) is False:
+            if self.callback(constants.CALLBACK_CHECK_RUNNING, self.id, self.name) is False:
                 raise RunStopException(self.name)
 
     def run_core(self):
@@ -78,13 +78,13 @@ class NoiseDetection(JobBase, FramePaths):
         ))
         in_paths = self.input_filepaths()
         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)
+        self.callback(constants.CALLBACK_STEP_COUNTS, self.id, self.name, n_frames)
         if not config.DISABLE_TQDM:
             self.tbar = make_tqdm_bar(self.name, n_frames)
 
         def progress_callback(i):
             self.progress(i)
-            if self.callback('check_running', self.id, self.name) is False:
+            if self.callback(constants.CALLBACK_CHECK_RUNNING, self.id, self.name) is False:
                 raise RunStopException(self.name)
         mean_img = mean_image(
             file_paths=in_paths, max_frames=self.max_frames,
@@ -137,7 +137,7 @@ class NoiseDetection(JobBase, FramePaths):
             plt.ylim(0)
             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)
+            self.callback(constants.CALLBACK_SAVE_PLOT, self.id, f"{self.name}: noise", plot_path)
             plt.close('all')
 
 

shinestacker/algorithms/pyramid.py

@@ -2,7 +2,7 @@
 import numpy as np
 import cv2
 from .. config.constants import constants
-from .utils import read_img
+from .utils import read_and_validate_img
 from .base_stack_algo import BaseStackAlgo
 
 
@@ -11,7 +11,7 @@ class PyramidBase(BaseStackAlgo):
                  kernel_size=constants.DEFAULT_PY_KERNEL_SIZE,
                  gen_kernel=constants.DEFAULT_PY_GEN_KERNEL,
                  float_type=constants.DEFAULT_PY_FLOAT):
-        super().__init__(name, 2, float_type)
+        super().__init__(name, 1, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.pad_amount = (kernel_size - 1) // 2
@@ -30,7 +30,7 @@ class PyramidBase(BaseStackAlgo):
 
     def total_steps(self, n_frames):
         self.n_frames = n_frames
-        return self._steps_per_frame * n_frames + self.n_levels
+        return super().total_steps(n_frames) + self.n_levels
 
     def convolve(self, image):
         return cv2.filter2D(image, -1, self.gen_kernel, borderType=cv2.BORDER_REFLECT101)
@@ -122,22 +122,6 @@ class PyramidBase(BaseStackAlgo):
             fused += np.where(best_d[:, :, np.newaxis] == layer, img, 0)
         return (fused / 2).astype(images.dtype)
 
-    def focus_stack_validate(self, cleanup_callback=None):
-        metadata = None
-        n = len(self.filenames)
-        for i, img_path in enumerate(self.filenames):
-            self.print_message(f": validating file {img_path.split('/')[-1]}, {i + 1}/{n}")
-
-            _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.after_step(i + 1)
-            self.check_running(cleanup_callback)
-
     def single_image_laplacian(self, img, levels):
         pyramid = [img.astype(self.float_type)]
         for _ in range(levels):
@@ -181,14 +165,16 @@ class PyramidStack(PyramidBase):
         return fused[::-1]
 
     def focus_stack(self):
-        n = len(self.filenames)
-        self.focus_stack_validate()
         all_laplacians = []
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": processing file {img_path.split('/')[-1]} ({i + 1}/{n})")
-            img = read_img(img_path)
+            self.print_message(
+                f": reading and validating {self.image_str(i)}")
+            img = read_and_validate_img(img_path, self.shape, self.dtype)
+            self.check_running()
+            self.print_message(
+                f": processing {self.image_str(i)}")
             all_laplacians.append(self.process_single_image(img, self.n_levels))
-            self.after_step(i + n + 1)
+            self.after_step(i + 1)
             self.check_running()
         stacked_image = self.collapse(self.fuse_pyramids(all_laplacians))
         return stacked_image.astype(self.dtype)