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

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.3.0'
+__version__ = '1.3.1'

shinestacker/algorithms/align.py

@@ -3,13 +3,15 @@ import os
 import math
 import logging
 import numpy as np
-import matplotlib.pyplot as plt
 import cv2
+import matplotlib.pyplot as plt
+import matplotlib
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
 from .. core.colors import color_str
 from .utils import img_8bit, img_bw_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
+matplotlib.use('Agg')
 
 _DEFAULT_FEATURE_CONFIG = {
     'detector': constants.DEFAULT_DETECTOR,
@@ -75,7 +77,7 @@ def decompose_affine_matrix(m):
 
 def check_affine_matrix(m, img_shape, affine_thresholds=_AFFINE_THRESHOLDS):
     if affine_thresholds is None:
-        return True, "No thresholds provided"
+        return True, "No thresholds provided", None
     (scale_x, scale_y), rotation, shear, (tx, ty) = decompose_affine_matrix(m)
     h, w = img_shape[:2]
     reasons = []
@@ -94,13 +96,14 @@ def check_affine_matrix(m, img_shape, affine_thresholds=_AFFINE_THRESHOLDS):
     if abs(ty) > max_ty:
         reasons.append(f"y-translation too large (|{ty:.1f}| > {max_ty:.1f})")
     if reasons:
-        return False, "; ".join(reasons)
-    return True, "Transformation within acceptable limits"
+        return False, "; ".join(reasons), None
+    return True, "Transformation within acceptable limits", \
+        (scale_x, scale_y, tx, ty, rotation, shear)
 
 
 def check_homography_distortion(m, img_shape, homography_thresholds=_HOMOGRAPHY_THRESHOLDS):
     if homography_thresholds is None:
-        return True, "No thresholds provided"
+        return True, "No thresholds provided", None
     h, w = img_shape[:2]
     corners = np.array([[0, 0], [w, 0], [w, h], [0, h]], dtype=np.float32)
     transformed = cv2.perspectiveTransform(corners.reshape(1, -1, 2), m).reshape(-1, 2)
@@ -127,8 +130,9 @@ def check_homography_distortion(m, img_shape, homography_thresholds=_HOMOGRAPHY_
     if max_angle_dev > homography_thresholds['max_skew']:
         reasons.append(f"angle distortion too large ({max_angle_dev:.1f}°)")
     if reasons:
-        return False, "; ".join(reasons)
-    return True, "Transformation within acceptable limits"
+        return False, "; ".join(reasons), None
+    return True, "Transformation within acceptable limits", \
+        (area_ratio, aspect_ratio, max_angle_dev)
 
 
 def check_transform(m, img_0, transform_type,
@@ -139,7 +143,7 @@ def check_transform(m, img_0, transform_type,
     if transform_type == constants.ALIGN_HOMOGRAPHY:
         return check_homography_distortion(
             m, img_0.shape, homography_thresholds)
-    return False, f'invalid transfrom option {transform_type}'
+    return False, f'invalid transfrom option {transform_type}', None
 
 
 def get_good_matches(des_0, des_ref, matching_config=None):
@@ -270,6 +274,18 @@ def rescale_trasnsform(m, w0, h0, w_sub, h_sub, subsample, transform):
     return m
 
 
+def plot_matches(msk, img_ref_sub, img_0_sub, kp_ref, kp_0, good_matches, plot_path):
+    matches_mask = msk.ravel().tolist()
+    img_match = cv2.cvtColor(cv2.drawMatches(
+        img_8bit(img_0_sub), kp_0, img_8bit(img_ref_sub),
+        kp_ref, good_matches, None, matchColor=(0, 255, 0),
+        singlePointColor=None, matchesMask=matches_mask,
+        flags=2), cv2.COLOR_BGR2RGB)
+    plt.figure(figsize=constants.PLT_FIG_SIZE)
+    plt.imshow(img_match, 'gray')
+    save_plot(plot_path)
+
+
 def align_images(img_ref, img_0, feature_config=None, matching_config=None, alignment_config=None,
                  plot_path=None, callbacks=None,
                  affine_thresholds=_AFFINE_THRESHOLDS,
@@ -315,22 +331,16 @@ def align_images(img_ref, img_0, feature_config=None, matching_config=None, alig
     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_ref[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+        src_pts = np.float32(
+            [kp_0[match.queryIdx].pt for match in good_matches]).reshape(-1, 1, 2)
+        dst_pts = np.float32(
+            [kp_ref[match.trainIdx].pt for match in good_matches]).reshape(-1, 1, 2)
         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_ref_sub),
-                kp_ref, good_matches, None, matchColor=(0, 255, 0),
-                singlePointColor=None, matchesMask=matches_mask,
-                flags=2), cv2.COLOR_BGR2RGB)
-            plt.figure(figsize=constants.PLT_FIG_SIZE)
-            plt.imshow(img_match, 'gray')
-            save_plot(plot_path)
+            plot_matches(msk, img_ref_sub, img_0_sub, kp_ref, kp_0, good_matches, plot_path)
             if callbacks and 'save_plot' in callbacks:
                 callbacks['save_plot'](plot_path)
         h_sub, w_sub = img_0_sub.shape[:2]
@@ -339,7 +349,7 @@ def align_images(img_ref, img_0, feature_config=None, matching_config=None, alig
             if m is None:
                 raise InvalidOptionError("transform", transform)
         transform_type = alignment_config['transform']
-        is_valid, reason = check_transform(
+        is_valid, reason, _result = check_transform(
             m, img_0, transform_type,
             affine_thresholds, homography_thresholds)
         if not is_valid:
@@ -427,7 +437,7 @@ class AlignFramesBase(SubAction):
             x = np.arange(1, len(self._n_good_matches) + 1, dtype=int)
             no_ref = x != self.process.ref_idx + 1
             x = x[no_ref]
-            y = self._n_good_matches[no_ref]
+            y = np.array(self._n_good_matches)[no_ref]
             if self.process.ref_idx == 0:
                 y_max = y[1]
             elif self.process.ref_idx >= len(y):
@@ -454,10 +464,6 @@ class AlignFramesBase(SubAction):
 
 
 class AlignFrames(AlignFramesBase):
-    def __init__(self, enabled=True, feature_config=None, matching_config=None,
-                 alignment_config=None, **kwargs):
-        super().__init__(enabled)
-
     def align_images(self, idx, img_ref, img_0):
         idx_str = f"{idx:04d}"
         idx_tot_str = self.process.idx_tot_str(idx)
@@ -473,8 +479,10 @@ class AlignFrames(AlignFramesBase):
                 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}/" \
-                f"{self.process.name}-matches-{idx_str}.pdf"
+            plot_path = os.path.join(
+                self.process.working_path,
+                self.process.plot_path,
+                f"{self.process.name}-matches-{idx_str}.pdf")
         else:
             plot_path = None
         affine_thresholds, homography_thresholds = self.get_transform_thresholds()

shinestacker/algorithms/align_auto.py

@@ -1,23 +1,27 @@
 # pylint: disable=C0114, C0115, C0116, W0718, R0912, R0915, E1101, R0914, R0911, E0606, R0801, R0902
 import os
+import numpy as np
 from ..config.constants import constants
 from .align import AlignFramesBase, AlignFrames
 from .align_parallel import AlignFramesParallel
+from .utils import get_first_image_file, get_img_metadata, read_img
 
 
 class AlignFramesAuto(AlignFramesBase):
     def __init__(self, enabled=True, feature_config=None, matching_config=None,
                  alignment_config=None, **kwargs):
-        super().__init__(enabled=True, feature_config=None, matching_config=None,
-                         alignment_config=None, **kwargs)
         self.mode = kwargs.pop('mode', constants.DEFAULT_ALIGN_MODE)
+        self.memory_limit = kwargs.pop('memory_limit', constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB)
         self.max_threads = kwargs.pop('max_threads', constants.DEFAULT_ALIGN_MAX_THREADS)
         self.chunk_submit = kwargs.pop('chunk_submit', constants.DEFAULT_ALIGN_CHUNK_SUBMIT)
         self.bw_matching = kwargs.pop('bw_matching', constants.DEFAULT_ALIGN_BW_MATCHING)
         self.kwargs = kwargs
+        super().__init__(enabled=True, feature_config=None, matching_config=None,
+                         alignment_config=None, **kwargs)
         available_cores = os.cpu_count() or 1
         self.num_threads = min(self.max_threads, available_cores)
         self._implementation = None
+        self.overhead = 30.0
 
     def begin(self, process):
         if self.mode == 'sequential' or self.num_threads == 1:
@@ -39,7 +43,15 @@ class AlignFramesAuto(AlignFramesBase):
                     descriptor = constants.DEFAULT_DESCRIPTOR
                 if detector in (constants.DETECTOR_SIFT, constants.DETECTOR_AKAZE) or \
                         descriptor in (constants.DESCRIPTOR_SIFT, constants.DESCRIPTOR_AKAZE):
-                    num_threads = min(3, self.num_threads)
+                    shape, dtype = get_img_metadata(
+                        read_img(get_first_image_file(process.input_filepaths())))
+                    bytes_per_pixel = 3 * np.dtype(dtype).itemsize
+                    img_memory = bytes_per_pixel * float(shape[0]) * float(shape[1]) * \
+                        self.overhead / constants.ONE_GIGA
+                    num_threads = max(
+                        1,
+                        int(round(self.memory_limit) / img_memory))
+                    num_threads = min(num_threads, self.num_threads)
                     chunk_submit = True
                 else:
                     num_threads = self.num_threads

shinestacker/algorithms/align_parallel.py

@@ -12,9 +12,11 @@ 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
-from .align import (AlignFramesBase, detect_and_compute_matches, find_transform,
-                    check_transform, _cv2_border_mode_map, rescale_trasnsform)
+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):
@@ -31,8 +33,8 @@ def compose_transforms(t1, t2, transform_type):
 class AlignFramesParallel(AlignFramesBase):
     def __init__(self, enabled=True, feature_config=None, matching_config=None,
                  alignment_config=None, **kwargs):
-        super().__init__(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)
@@ -43,6 +45,8 @@ class AlignFramesParallel(AlignFramesBase):
         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]:
@@ -98,10 +102,14 @@ class AlignFramesParallel(AlignFramesBase):
 
     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)
-        self.print_message(f"preprocess {n_frames} images in parallel, cores: {self.max_threads}")
         input_filepaths = self.process.input_filepaths()
         self._img_cache = [None] * n_frames
         self._img_locks = [0] * n_frames
@@ -110,6 +118,8 @@ class AlignFramesParallel(AlignFramesBase):
         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)}")
@@ -125,9 +135,11 @@ class AlignFramesParallel(AlignFramesBase):
                 self.submit_threads(idxs, imgs)
         else:
             self.submit_threads(sub_indices, sub_img_filepaths)
-        for i in range(n_frames):
-            if self._img_cache[i] is not None:
-                self._img_cache[i] = None
+        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']
@@ -152,6 +164,9 @@ class AlignFramesParallel(AlignFramesBase):
                 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:
@@ -165,6 +180,32 @@ class AlignFramesParallel(AlignFramesBase):
         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"
@@ -202,8 +243,8 @@ class AlignFramesParallel(AlignFramesBase):
                 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 = detect_and_compute_matches(
-                img_ref_sub, img_0_sub, self.feature_config, self.matching_config)
+            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
@@ -217,8 +258,6 @@ class AlignFramesParallel(AlignFramesBase):
                 f"warning: only {n_good_matches} found for "
                 f"{self.image_str(idx)}, trying next frame",
                 color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
-            self._target_indices[idx] = None
-            self._transforms[idx] = None
             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)
@@ -231,23 +270,24 @@ class AlignFramesParallel(AlignFramesBase):
         if subsample > 1:
             m = rescale_trasnsform(m, w0, h0, w_sub, h_sub, subsample, transform)
             if m is None:
-                warning_messages.append(f"invalid option {transform}")
-                self._target_indices[idx] = None
-                self._transforms[idx] = None
-                return info_messages, warning_messages
+                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 = check_transform(m, img_0, transform_type, *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(
-                f"warning: invalid transformation for {self.image_str(idx)}: {reason}",
-                level=logging.WARNING)
-            if self.alignment_config['abort_abnormal']:
+                msg, color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+            if do_abort:
                 raise RuntimeError("invalid transformation: {reason}")
-            warning_messages.append(f"invalid transformation found: {reason}")
-            self._target_indices[idx] = None
-            self._transforms[idx] = None
-            return info_messages, warning_messages
+            return self.extract_features(idx, delta + 1)
         self._transforms[idx] = m
         self._target_indices[idx] = target_idx
         return info_messages, warning_messages

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
@@ -41,14 +44,16 @@ class BaseStackAlgo:
         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
@@ -56,17 +61,6 @@ 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(constants.CALLBACK_CHECK_RUNNING,
                                  self.process.id, self.process.name) is False:

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/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,21 +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
-        for i, img_path in enumerate(self.filenames):
-            self.print_message(
-                f": validating file {self.image_str(i)}")
-            _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):
@@ -180,15 +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": 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)}")
-            img = read_img(img_path)
             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)

shinestacker/algorithms/pyramid_auto.py

@@ -2,7 +2,6 @@
 import os
 import numpy as np
 from .. config.constants import constants
-from .utils import extension_tif_jpg
 from .base_stack_algo import BaseStackAlgo
 from .pyramid import PyramidStack
 from .pyramid_tiles import PyramidTilesStack
@@ -21,7 +20,7 @@ class PyramidAutoStack(BaseStackAlgo):
                  min_tile_size=constants.DEFAULT_PY_MIN_TILE_SIZE,
                  min_n_tiled_layers=constants.DEFAULT_PY_MIN_N_TILED_LAYERS,
                  mode='auto'):
-        super().__init__("auto_pyramid", 2, float_type)
+        super().__init__("auto_pyramid", 1, float_type)
         self.min_size = min_size
         self.kernel_size = kernel_size
         self.gen_kernel = gen_kernel
@@ -47,15 +46,7 @@ class PyramidAutoStack(BaseStackAlgo):
         self.overhead = constants.PY_MEMORY_OVERHEAD
 
     def init(self, filenames):
-        first_img_file = None
-        for filename in filenames:
-            if os.path.isfile(filename) and extension_tif_jpg(filename):
-                first_img_file = filename
-                break
-        if first_img_file is None:
-            raise ValueError("No valid image files found")
-        _img, metadata, _ = self.read_image_and_update_metadata(first_img_file, None)
-        self.shape, self.dtype = metadata
+        super().init(filenames)
         self.n_levels = int(np.log2(min(self.shape) / self.min_size))
         self.n_frames = len(filenames)
         memory_required_memory = self._estimate_memory_memory()
@@ -79,9 +70,9 @@ class PyramidAutoStack(BaseStackAlgo):
                 n_tiled_layers=optimal_params['n_tiled_layers'],
                 max_threads=self.num_threads
             )
-            self.print_message(f": using tile-based pyramid stacking "
-                               f"(tile_size: {optimal_params['tile_size']}, "
-                               f"n_tiled_layers: {optimal_params['n_tiled_layers']}), "
+            self.print_message(f": using tile-based pyramid stacking, "
+                               f"tile size: {optimal_params['tile_size']}, "
+                               f"n. tiled layers: {optimal_params['n_tiled_layers']}, "
                                f"{self.num_threads} cores.")
         self._implementation.init(filenames)
         self._implementation.set_do_step_callback(self.do_step_callback)