shinestacker 1.8.0__py3-none-any.whl → 1.9.3__py3-none-any.whl

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.8.0'
+__version__ = '1.9.3'

shinestacker/algorithms/align.py

@@ -1,4 +1,5 @@
-# pylint: disable=C0114, C0115, C0116, E1101, R0914, R0913, R0917, R0912, R0915, R0902, E1121, W0102
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, R0913
+# pylint: disable=R0917, R0912, R0915, R0902, E1121, W0102, W0718
 import os
 import math
 import logging
@@ -28,18 +29,19 @@ _DEFAULT_MATCHING_CONFIG = {
 
 _DEFAULT_ALIGNMENT_CONFIG = {
     'transform': constants.DEFAULT_TRANSFORM,
-    'align_method': constants.DEFAULT_ALIGN_METHOD,
+    'align_method': constants.DEFAULT_ESTIMATION_METHOD,
     'rans_threshold': constants.DEFAULT_RANS_THRESHOLD,
     'refine_iters': constants.DEFAULT_REFINE_ITERS,
     'align_confidence': constants.DEFAULT_ALIGN_CONFIDENCE,
     'max_iters': constants.DEFAULT_ALIGN_MAX_ITERS,
-    'abort_abnormal': constants.DEFAULT_ALIGN_ABORT_ABNORMAL,
     'border_mode': constants.DEFAULT_BORDER_MODE,
     'border_value': constants.DEFAULT_BORDER_VALUE,
     'border_blur': constants.DEFAULT_BORDER_BLUR,
     'subsample': constants.DEFAULT_ALIGN_SUBSAMPLE,
     'fast_subsampling': constants.DEFAULT_ALIGN_FAST_SUBSAMPLING,
-    'min_good_matches': constants.DEFAULT_ALIGN_MIN_GOOD_MATCHES
+    'min_good_matches': constants.DEFAULT_ALIGN_MIN_GOOD_MATCHES,
+    'phase_corr_fallback': constants.DEFAULT_PHASE_CORR_FALLBACK,
+    'abort_abnormal': constants.DEFAULT_ALIGN_ABORT_ABNORMAL
 }
 
 
@@ -63,6 +65,20 @@ _HOMOGRAPHY_THRESHOLDS = {
     'max_aspect_ratio': 2.0,  # max aspect ratio change
 }
 
+_AFFINE_THRESHOLDS_LARGE = {
+    'max_rotation': 20.0,  # degrees
+    'min_scale': 0.5,
+    'max_scale': 1.5,
+    'max_shear': 10.0,  # degrees
+    'max_translation_ratio': 0.2,  # 20% of image dimension
+}
+
+_HOMOGRAPHY_THRESHOLDS_LARGE = {
+    'max_skew': 12.0,  # degrees
+    'max_scale_change': 2.0,  # max area change ratio
+    'max_aspect_ratio': 4.0,  # max aspect ratio change
+}
+
 
 def decompose_affine_matrix(m):
     a, b, tx = m[0, 0], m[0, 1], m[0, 2]
@@ -146,22 +162,29 @@ def check_transform(m, img_shape, transform_type,
     return False, f'invalid transfrom option {transform_type}', None
 
 
-def get_good_matches(des_0, des_ref, matching_config=None):
+def get_good_matches(des_0, des_ref, matching_config=None, callbacks=None):
     matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
     match_method = matching_config['match_method']
     good_matches = []
-    if match_method == constants.MATCHING_KNN:
-        flann = cv2.FlannBasedMatcher(
-            {'algorithm': matching_config['flann_idx_kdtree'],
-             'trees': matching_config['flann_trees']},
-            {'checks': matching_config['flann_checks']})
-        matches = flann.knnMatch(des_0, des_ref, k=2)
-        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_ref), key=lambda x: x.distance)
-    else:
+    invalid_option = False
+    try:
+        if match_method == constants.MATCHING_KNN:
+            flann = cv2.FlannBasedMatcher(
+                {'algorithm': matching_config['flann_idx_kdtree'],
+                 'trees': matching_config['flann_trees']},
+                {'checks': matching_config['flann_checks']})
+            matches = flann.knnMatch(des_0, des_ref, k=2)
+            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_ref), key=lambda x: x.distance)
+        else:
+            invalid_option = True
+    except Exception:
+        if callbacks and 'warning' in callbacks:
+            callbacks['warning']("failed to compute matches")
+    if invalid_option:
         raise InvalidOptionError(
             'match_method', match_method,
             f". Valid options are: {constants.MATCHING_KNN}, {constants.MATCHING_NORM_HAMMING}"
@@ -204,7 +227,8 @@ descriptor_map = {
 }
 
 
-def detect_and_compute_matches(img_ref, img_0, feature_config=None, matching_config=None):
+def detect_and_compute_matches(img_ref, img_0, feature_config=None, matching_config=None,
+                               callbacks=None):
     feature_config = {**_DEFAULT_FEATURE_CONFIG, **(feature_config or {})}
     matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
     feature_config_detector = feature_config['detector']
@@ -223,11 +247,11 @@ def detect_and_compute_matches(img_ref, img_0, feature_config=None, matching_con
         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)
+    return kp_0, kp_ref, get_good_matches(des_0, des_ref, matching_config, callbacks)
 
 
 def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
-                   method=constants.DEFAULT_ALIGN_METHOD,
+                   method=constants.DEFAULT_ESTIMATION_METHOD,
                    rans_threshold=constants.DEFAULT_RANS_THRESHOLD,
                    max_iters=constants.DEFAULT_ALIGN_MAX_ITERS,
                    align_confidence=constants.DEFAULT_ALIGN_CONFIDENCE,
@@ -289,6 +313,76 @@ def plot_matches(msk, img_ref_sub, img_0_sub, kp_ref, kp_0, good_matches, plot_p
     save_plot(plot_path)
 
 
+def find_transform_phase_correlation(img_ref, img_0):
+    if len(img_ref.shape) == 3:
+        ref_gray = cv2.cvtColor(img_ref, cv2.COLOR_BGR2GRAY)
+        mov_gray = cv2.cvtColor(img_0, cv2.COLOR_BGR2GRAY)
+    else:
+        ref_gray = img_ref
+        mov_gray = img_0
+    h, w = ref_gray.shape
+    window_y = np.hanning(h)
+    window_x = np.hanning(w)
+    window = np.outer(window_y, window_x)
+    ref_win = ref_gray.astype(np.float32) * window
+    mov_win = mov_gray.astype(np.float32) * window
+    ref_fft = np.fft.fft2(ref_win)
+    mov_fft = np.fft.fft2(mov_win)
+    ref_mag = np.fft.fftshift(np.abs(ref_fft))
+    mov_mag = np.fft.fftshift(np.abs(mov_fft))
+    center = (w // 2, h // 2)
+    radius = min(center[0], center[1])
+    y, x = np.ogrid[:h, :w]
+    dist_from_center = np.sqrt((x - center[0])**2 + (y - center[1])**2)
+    log_r_bins = np.logspace(0, np.log10(radius), 50, endpoint=False)
+    ref_profile = []
+    mov_profile = []
+    for i in range(len(log_r_bins) - 1):
+        mask = (dist_from_center >= log_r_bins[i]) & (dist_from_center < log_r_bins[i + 1])
+        if np.any(mask):
+            ref_profile.append(np.mean(ref_mag[mask]))
+            mov_profile.append(np.mean(mov_mag[mask]))
+    if len(ref_profile) < 5:
+        scale = 1.0
+    else:
+        ref_prof = np.array(ref_profile)
+        mov_prof = np.array(mov_profile)
+        ref_prof = (ref_prof - np.mean(ref_prof)) / (np.std(ref_prof) + 1e-8)
+        mov_prof = (mov_prof - np.mean(mov_prof)) / (np.std(mov_prof) + 1e-8)
+        correlation = np.correlate(ref_prof, mov_prof, mode='full')
+        shift_idx = np.argmax(correlation) - len(ref_prof) + 1
+        scale = np.exp(shift_idx * 0.1)  # Empirical scaling factor
+        scale = np.clip(scale, 0.9, 1.1)  # Limit to small scale changes
+    if abs(scale - 1.0) > 0.01:
+        scaled_size = (int(w * scale), int(h * scale))
+        mov_scaled = cv2.resize(img_0, scaled_size)
+        new_h, new_w = mov_scaled.shape[:2]
+        start_x = (w - new_w) // 2
+        start_y = (h - new_h) // 2
+        mov_centered = np.zeros_like(img_0)
+        mov_centered[start_y:start_y + new_h, start_x:start_x + new_w] = mov_scaled
+    else:
+        mov_centered = img_0
+        scale = 1.0
+    if len(img_ref.shape) == 3:
+        ref_gray_trans = cv2.cvtColor(img_ref, cv2.COLOR_BGR2GRAY)
+        mov_gray_trans = cv2.cvtColor(mov_centered, cv2.COLOR_BGR2GRAY)
+    else:
+        ref_gray_trans = img_ref
+        mov_gray_trans = mov_centered
+    ref_win_trans = ref_gray_trans.astype(np.float32) * window
+    mov_win_trans = mov_gray_trans.astype(np.float32) * window
+    shift, _response = cv2.phaseCorrelate(ref_win_trans, mov_win_trans)
+    m = np.float32([[scale, 0, shift[0]], [0, scale, shift[1]]])
+    return m
+
+
+def align_images_phase_correlation(img_ref, img_0):
+    m = find_transform_phase_correlation(img_ref, img_0)
+    img_warp = cv2.warpAffine(img_0, m, img_ref.shape[:2])
+    return m, img_warp
+
+
 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,
@@ -319,74 +413,103 @@ def align_images(img_ref, img_0, feature_config=None, matching_config=None, alig
         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, feature_config, matching_config)
+            img_ref_sub, img_0_sub, feature_config, matching_config, callbacks)
         n_good_matches = len(good_matches)
-        if n_good_matches > min_good_matches or subsample == 1:
+        if n_good_matches >= min_good_matches or subsample == 1:
             break
         subsample = 1
         if callbacks and 'warning' in callbacks:
+            s_str = 'es' if n_good_matches != 1 else ''
             callbacks['warning'](
-                f"only {n_good_matches} < {min_good_matches} matches found, "
+                f"only {n_good_matches} < {min_good_matches} match{s_str} found, "
                 "retrying without subsampling")
-    if callbacks and 'matches_message' in callbacks:
-        callbacks['matches_message'](n_good_matches)
+        else:
+            n_good_matches = 0
+            break
+    phase_corr_fallback = alignment_config['phase_corr_fallback']
+    phase_corr_called = False
     img_warp = None
     m = None
+    transform_type = alignment_config['transform']
     if n_good_matches >= min_matches:
-        transform = alignment_config['transform']
         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:
+        m, msk = find_transform(
+            src_pts, dst_pts, transform_type, alignment_config['align_method'],
+            *(alignment_config[k]
+              for k in ['rans_threshold', 'max_iters',
+                        'align_confidence', 'refine_iters']))
+        if m is not None and plot_path is not None:
             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]
-        if subsample > 1:
-            m = rescale_trasnsform(m, w0, h0, w_sub, h_sub, subsample, transform)
+    if m is None or n_good_matches < min_matches:
+        if phase_corr_fallback:
+            if callbacks and 'warning' in callbacks:
+                callbacks['warning'](
+                    f"only {n_good_matches} < {min_good_matches} matches found"
+                    ", using phase correlation as fallback")
+            n_good_matches = 0
+            m = find_transform_phase_correlation(img_ref_sub, img_0_sub)
+            phase_corr_called = True
             if m is None:
-                raise InvalidOptionError("transform", transform)
-        transform_type = alignment_config['transform']
-        is_valid, reason, result = check_transform(
-            m, img_0.shape, transform_type,
-            affine_thresholds, homography_thresholds)
-        if callbacks and 'save_transform_result' in callbacks:
-            callbacks['save_transform_result'](result)
-        if not is_valid:
+                return n_good_matches, None, None
+        else:
+            if callbacks and 'warning' in callbacks:
+                msg = ""
+                if n_good_matches < min_matches:
+                    msg = f"only {n_good_matches} < {min_good_matches} matches found, " \
+                        "alignment failed"
+                elif m is None:
+                    msg = "no transformation found, alignment falied"
+                callbacks['warning'](msg)
+            return n_good_matches, None, None
+    h_sub, w_sub = img_0_sub.shape[:2]
+    if subsample > 1:
+        m = rescale_trasnsform(m, w0, h0, w_sub, h_sub, subsample, transform_type)
+        if m is None:
             if callbacks and 'warning' in callbacks:
-                callbacks['warning'](f"invalid transformation: {reason}")
-            if alignment_config['abort_abnormal']:
-                raise RuntimeError("invalid transformation: {reason}")
+                callbacks['warning']("can't rescale transformation matrix, alignment failed")
             return n_good_matches, None, None
-        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_ref, h_ref),
-                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_ref, h_ref),
-                                           borderMode=cv2.BORDER_CONSTANT, borderValue=0)
-        elif alignment_config['transform'] == constants.ALIGN_RIGID:
-            img_warp = cv2.warpAffine(
-                img_0, m, (w_ref, h_ref),
-                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_ref, h_ref),
-                                      borderMode=cv2.BORDER_CONSTANT, borderValue=0)
+    is_valid, reason, result = check_transform(
+        m, img_0.shape, transform_type,
+        affine_thresholds, homography_thresholds)
+    if callbacks and 'save_transform_result' in callbacks:
+        callbacks['save_transform_result'](result)
+    if not is_valid:
+        if callbacks and 'warning' in callbacks:
+            callbacks['warning'](f"invalid transformation: {reason}, alignment failed")
+        if alignment_config['abort_abnormal']:
+            raise RuntimeError("invalid transformation: {reason}, alignment failed")
+        return n_good_matches, None, None
+    if not phase_corr_called and callbacks and 'matches_message' in callbacks:
+        callbacks['matches_message'](n_good_matches)
+    if callbacks and 'estimation_message' in callbacks:
+        callbacks['estimation_message']()
+    img_mask = np.ones_like(img_0, dtype=np.uint8)
+    if transform_type == constants.ALIGN_HOMOGRAPHY:
+        img_warp = cv2.warpPerspective(
+            img_0, m, (w_ref, h_ref),
+            borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
         if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-            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'])
-            img_warp[mask == 0] = blurred_warp[mask == 0]
+            mask = cv2.warpPerspective(img_mask, m, (w_ref, h_ref),
+                                       borderMode=cv2.BORDER_CONSTANT, borderValue=0)
+    elif transform_type == constants.ALIGN_RIGID:
+        img_warp = cv2.warpAffine(
+            img_0, m, (w_ref, h_ref),
+            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_ref, h_ref),
+                                  borderMode=cv2.BORDER_CONSTANT, borderValue=0)
+    if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
+        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'])
+        img_warp[mask == 0] = blurred_warp[mask == 0]
     return n_good_matches, m, img_warp
 
 
@@ -425,7 +548,7 @@ class AlignFramesBase(SubAction):
     def relative_transformation(self):
         return None
 
-    def align_images(self, idx, img_ref, img_0):
+    def align_images(self, _idx, _img_ref, _img_0):
         pass
 
     def print_message(self, msg, color=constants.LOG_COLOR_LEVEL_3, level=logging.INFO):
@@ -453,8 +576,11 @@ class AlignFramesBase(SubAction):
     def get_transform_thresholds(self):
         return _AFFINE_THRESHOLDS, _HOMOGRAPHY_THRESHOLDS
 
+    def get_transform_thresholds_large(self):
+        return _AFFINE_THRESHOLDS_LARGE, _HOMOGRAPHY_THRESHOLDS_LARGE
+
     def image_str(self, idx):
-        return f"image: {self.process.idx_tot_str(idx)}, " \
+        return f"{self.process.frame_str(idx)}, " \
                f"{os.path.basename(self.process.input_filepath(idx))}"
 
     def end(self):
@@ -641,15 +767,15 @@ class AlignFramesBase(SubAction):
 class AlignFrames(AlignFramesBase):
     def align_images(self, idx, img_ref, img_0):
         idx_str = f"{idx:04d}"
-        idx_tot_str = self.process.idx_tot_str(idx)
-
+        idx_tot_str = self.process.frame_str(idx)
         callbacks = {
-            'message': lambda: self.print_message(f'{idx_tot_str}: find matches'),
+            'message': lambda: self.print_message(
+                f'{idx_tot_str}: estimate transform using feature matching'),
             'matches_message': lambda n: self.print_message(f'{idx_tot_str}: good matches: {n}'),
-            'align_message': lambda: self.print_message(f'{idx_tot_str}: align images'),
+            'estimation_message': lambda: self.print_message(f'{idx_tot_str}: align images'),
             'blur_message': lambda: self.print_message(f'{idx_tot_str}: blur borders'),
             'warning': lambda msg: self.print_message(
-                f': {msg}', constants.LOG_COLOR_WARNING),
+                f'{msg}', constants.LOG_COLOR_WARNING),
             'save_plot': lambda plot_path: self.process.callback(
                 constants.CALLBACK_SAVE_PLOT, self.process.id,
                 f"{self.process.name}: matches\nframe {idx_str}", plot_path),
@@ -662,7 +788,7 @@ class AlignFrames(AlignFramesBase):
                 f"{self.process.name}-matches-{idx_str}.pdf")
         else:
             plot_path = None
-        affine_thresholds, homography_thresholds = self.get_transform_thresholds()
+        affine_thresholds, homography_thresholds = self.get_transform_thresholds_large()
         n_good_matches, _m, img = align_images(
             img_ref, img_0,
             feature_config=self.feature_config,
@@ -674,11 +800,6 @@ class AlignFrames(AlignFramesBase):
             homography_thresholds=homography_thresholds
         )
         self._n_good_matches[idx] = n_good_matches
-        if n_good_matches < self.min_matches:
-            self.process.print_message(
-                f"{self.image_str(idx)} not aligned, too few matches found: "
-                f"{n_good_matches}")
-            return None
         return img
 
     def relative_transformation(self):

shinestacker/algorithms/align_auto.py

@@ -22,12 +22,11 @@ class AlignFramesAuto(AlignFramesBase):
         self.num_threads = min(self.max_threads, available_cores)
         self._implementation = None
         self.overhead = 30.0
+        self.mem_per_gpx_sift = 0.1
 
     def begin(self, process):
         if self.mode == 'sequential' or self.num_threads == 1:
-            self._implementation = AlignFrames(
-                self.enabled, self.feature_config, self.matching_config, self.alignment_config,
-                **self.kwargs)
+            num_threads = 1
         else:
             if self.mode == 'parallel':
                 num_threads = self.num_threads
@@ -43,24 +42,27 @@ 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):
-                    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))
+                    shape, dtype = get_img_metadata(read_img(
+                        get_first_image_file(process.input_filepaths())))
+                    img_pxls = shape[0] * shape[1]
+                    mem_gb = img_pxls / constants.ONE_MEGA * self.mem_per_gpx_sift * \
+                        np.dtype(dtype).itemsize
+                    num_threads = min(self.num_threads, int(self.memory_limit / mem_gb))
                     num_threads = min(num_threads, self.num_threads)
                     chunk_submit = True
                 else:
                     num_threads = self.num_threads
                     chunk_submit = self.chunk_submit
+        if num_threads > 1:
             self._implementation = AlignFramesParallel(
                 self.enabled, self.feature_config, self.matching_config, self.alignment_config,
                 max_threads=num_threads, chunk_submit=chunk_submit,
                 bw_matching=self.bw_matching,
                 **self.kwargs)
+        else:
+            self._implementation = AlignFrames(
+                self.enabled, self.feature_config, self.matching_config, self.alignment_config,
+                **self.kwargs)
         self._implementation.begin(process)
 
     def align_images(self, idx, img_ref, img_0):

shinestacker/algorithms/align_parallel.py

@@ -13,7 +13,7 @@ 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,
+from .align import (AlignFramesBase, find_transform, find_transform_phase_correlation,
                     check_transform, _cv2_border_mode_map, rescale_trasnsform,
                     validate_align_config, detector_map, descriptor_map,
                     get_good_matches)
@@ -38,6 +38,7 @@ class AlignFramesParallel(AlignFramesBase):
         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.delta_max = kwargs.get('delta_max', constants.DEFAULT_ALIGN_DELTA_MAX)
         self._img_cache = None
         self._img_shapes = None
         self._img_locks = None
@@ -70,7 +71,7 @@ class AlignFramesParallel(AlignFramesBase):
             for idx in idxs:
                 self.print_message(
                     f"submit alignment matches, {self.image_str(idx)}")
-                future = executor.submit(self.extract_features, idx)
+                future = executor.submit(self.find_transform, idx)
                 future_to_index[future] = idx
             for future in as_completed(future_to_index):
                 idx = future_to_index[future]
@@ -83,7 +84,7 @@ class AlignFramesParallel(AlignFramesBase):
                     color = constants.LOG_COLOR_LEVEL_3
                     level = logging.INFO
                     if len(warning_messages) > 0:
-                        message += ", " + color_str(", ".join(warning_messages), 'yellow')
+                        message += "; " + color_str("; ".join(warning_messages), 'yellow')
                         color = constants.LOG_COLOR_WARNING
                         level = logging.WARNING
                     self.print_message(message, color=color, level=level)
@@ -103,7 +104,6 @@ class AlignFramesParallel(AlignFramesBase):
                     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):
@@ -175,17 +175,22 @@ class AlignFramesParallel(AlignFramesBase):
             self._transforms[idx] = None
         gc.collect()
         missing_transforms = 0
-        thresholds = self.get_transform_thresholds()
+        thresholds = self.get_transform_thresholds_large()
         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)
-                is_valid, _reason, result = check_transform(
+                is_valid, reason, result = check_transform(
                     self._cumulative_transforms[i], self._img_shapes[i],
                     transform_type, *thresholds)
                 if is_valid:
                     self.save_transform_result(i, result)
                 else:
+                    self.print_message(
+                        f"invalid cumulative transform for {self.image_str(i)}",
+                        color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+                if self.alignment_config['abort_abnormal']:
                     self._cumulative_transforms[i] = None
+                    raise RuntimeError(f"invalid cumulative transformation: {reason}")
             else:
                 missing_transforms += 1
         msg = "feature extaction completed"
@@ -221,8 +226,14 @@ class AlignFramesParallel(AlignFramesBase):
             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):
+    def find_transform(self, idx, delta=1):
         ref_idx = self.process.ref_idx
+        if delta > self.delta_max:
+            if self.delta_max > 1:
+                msg = f"next {self.delta_max} frames not matched, frame skipped"
+            else:
+                msg = "next frame not matched, frame skipped"
+            return [], [msg]
         pass_ref_err_msg = "cannot find path to reference frame"
         if idx < ref_idx:
             target_idx = idx + delta
@@ -264,23 +275,41 @@ class AlignFramesParallel(AlignFramesBase):
             if n_good_matches > min_good_matches or subsample == 1:
                 break
             subsample = 1
-            warning_messages.append("too few matches, no subsampling applied")
+            s_str = 'es' if n_good_matches != 1 else ''
+            msg = f"{self.image_str(idx)}: only {n_good_matches} < {min_good_matches} " \
+                f"match{s_str} found with {self.image_str(target_idx)}, " \
+                "retrying without subsampling"
+            self.print_message(msg, color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+            warning_messages.append("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)
+            if self.alignment_config['phase_corr_fallback']:
+                s_str = 'es' if n_good_matches != 1 else ''
+                msg = f"{self.image_str(idx)}: only {n_good_matches} good matches found " \
+                    f" with {self.image_str(target_idx)}, using phase correlation as fallback"
+                self.print_message(msg, color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+                warning_messages.append("used phase correlation as fallback")
+                n_good_matches = 0
+                m = find_transform_phase_correlation(img_ref_sub, img_0_sub)
+                self._transforms[idx] = m
+                self._target_indices[idx] = target_idx
+                return info_messages, warning_messages
+            s_str = 'es' if n_good_matches != 1 else ''
+            msg = f"{self.image_str(idx)}: only {n_good_matches} good match{s_str} found, " \
+                  f" with {self.image_str(target_idx)}, trying next frame"
+            self.print_message(msg, color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+            warning_messages.append(msg)
+            return self.find_transform(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']))
+        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)
@@ -289,7 +318,7 @@ class AlignFramesParallel(AlignFramesBase):
                     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)
+                return self.find_transform(idx, delta + 1)
         transform_type = self.alignment_config['transform']
         thresholds = self.get_transform_thresholds()
         is_valid, _reason, _result = check_transform(m, img_0.shape, transform_type, *thresholds)
@@ -303,7 +332,7 @@ class AlignFramesParallel(AlignFramesBase):
                 msg, color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
             if do_abort:
                 raise RuntimeError("invalid transformation: {reason}")
-            return self.extract_features(idx, delta + 1)
+            return self.find_transform(idx, delta + 1)
         self._transforms[idx] = m
         self._target_indices[idx] = target_idx
         return info_messages, warning_messages
@@ -312,9 +341,9 @@ class AlignFramesParallel(AlignFramesBase):
         m = self._cumulative_transforms[idx]
         if m is None:
             self.print_message(
-                f"no transformation for {self.image_str(idx)}, skipping alignment",
+                f"no transformation for {self.image_str(idx)}, image skipped",
                 color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
-            return img_0
+            return None
         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}")

shinestacker/algorithms/balance.py

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

shinestacker/algorithms/base_stack_algo.py

@@ -41,7 +41,7 @@ class BaseStackAlgo:
         return f"{idx + 1}/{len(self.filenames)}"
 
     def image_str(self, idx):
-        return f"image: {self.idx_tot_str(idx)}, " \
+        return f"frame {self.idx_tot_str(idx)}, " \
                f"{os.path.basename(self.filenames[idx])}"
 
     def num_images(self):