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

shinestacker/_version.py

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

shinestacker/algorithms/align.py

@@ -1,6 +1,7 @@
 # pylint: disable=C0114, C0115, C0116, E1101, R0914, R0913, R0917, R0912, R0915, R0902, E1121, W0102
-import logging
+import os
 import math
+import logging
 import numpy as np
 import matplotlib.pyplot as plt
 import cv2
@@ -20,7 +21,7 @@ _DEFAULT_MATCHING_CONFIG = {
     'flann_idx_kdtree': constants.DEFAULT_FLANN_IDX_KDTREE,
     'flann_trees': constants.DEFAULT_FLANN_TREES,
     'flann_checks': constants.DEFAULT_FLANN_CHECKS,
-    'threshold': constants.DEFAULT_ALIGN_THRESHOLD
+    'threshold': constants.DEFAULT_ALIGN_THRESHOLD,
 }
 
 _DEFAULT_ALIGNMENT_CONFIG = {
@@ -130,6 +131,17 @@ def check_homography_distortion(m, img_shape, homography_thresholds=_HOMOGRAPHY_
     return True, "Transformation within acceptable limits"
 
 
+def check_transform(m, img_0, transform_type,
+                    affine_thresholds, homography_thresholds):
+    if transform_type == constants.ALIGN_RIGID:
+        return check_affine_matrix(
+            m, img_0.shape, affine_thresholds)
+    if transform_type == constants.ALIGN_HOMOGRAPHY:
+        return check_homography_distortion(
+            m, img_0.shape, homography_thresholds)
+    return False, f'invalid transfrom option {transform_type}'
+
+
 def get_good_matches(des_0, des_ref, matching_config=None):
     matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
     match_method = matching_config['match_method']
@@ -172,7 +184,23 @@ def validate_align_config(detector, descriptor, match_method):
                          " require matching method Hamming distance")
 
 
-def detect_and_compute(img_0, img_ref, feature_config=None, matching_config=None):
+detector_map = {
+    constants.DETECTOR_SIFT: cv2.SIFT_create,
+    constants.DETECTOR_ORB: cv2.ORB_create,
+    constants.DETECTOR_SURF: cv2.FastFeatureDetector_create,
+    constants.DETECTOR_AKAZE: cv2.AKAZE_create,
+    constants.DETECTOR_BRISK: cv2.BRISK_create
+}
+
+descriptor_map = {
+    constants.DESCRIPTOR_SIFT: cv2.SIFT_create,
+    constants.DESCRIPTOR_ORB: cv2.ORB_create,
+    constants.DESCRIPTOR_AKAZE: cv2.AKAZE_create,
+    constants.DETECTOR_BRISK: cv2.BRISK_create
+}
+
+
+def detect_and_compute_matches(img_ref, img_0, feature_config=None, matching_config=None):
     feature_config = {**_DEFAULT_FEATURE_CONFIG, **(feature_config or {})}
     matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
     feature_config_detector = feature_config['detector']
@@ -180,19 +208,6 @@ def detect_and_compute(img_0, img_ref, feature_config=None, matching_config=None
     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_map = {
-        constants.DETECTOR_SIFT: cv2.SIFT_create,
-        constants.DETECTOR_ORB: cv2.ORB_create,
-        constants.DETECTOR_SURF: cv2.FastFeatureDetector_create,
-        constants.DETECTOR_AKAZE: cv2.AKAZE_create,
-        constants.DETECTOR_BRISK: cv2.BRISK_create
-    }
-    descriptor_map = {
-        constants.DESCRIPTOR_SIFT: cv2.SIFT_create,
-        constants.DESCRIPTOR_ORB: cv2.ORB_create,
-        constants.DESCRIPTOR_AKAZE: cv2.AKAZE_create,
-        constants.DETECTOR_BRISK: cv2.BRISK_create
-    }
     detector = detector_map[feature_config_detector]()
     if feature_config_detector == feature_config_descriptor and \
        feature_config_detector in (constants.DETECTOR_SIFT,
@@ -236,6 +251,25 @@ def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
     return result
 
 
+def rescale_trasnsform(m, w0, h0, w_sub, h_sub, subsample, transform):
+    if transform == constants.ALIGN_HOMOGRAPHY:
+        low_size = np.float32([[0, 0], [0, h_sub], [w_sub, h_sub], [w_sub, 0]])
+        high_size = np.float32([[0, 0], [0, h0], [w0, h0], [w0, 0]])
+        scale_up = cv2.getPerspectiveTransform(low_size, high_size)
+        scale_down = cv2.getPerspectiveTransform(high_size, low_size)
+        m = scale_up @ m @ scale_down
+    elif transform == constants.ALIGN_RIGID:
+        rotation = m[:2, :2]
+        translation = m[:, 2]
+        translation_fullres = translation * subsample
+        m = np.empty((2, 3), dtype=np.float32)
+        m[:2, :2] = rotation
+        m[:, 2] = translation_fullres
+    else:
+        return 0
+    return m
+
+
 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,
@@ -265,8 +299,8 @@ def align_images(img_ref, img_0, feature_config=None, matching_config=None, alig
             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(img_0_sub, img_ref_sub,
-                                                        feature_config, matching_config)
+        kp_0, kp_ref, good_matches = detect_and_compute_matches(
+            img_ref_sub, img_0_sub, feature_config, matching_config)
         n_good_matches = len(good_matches)
         if n_good_matches > min_good_matches or subsample == 1:
             break
@@ -301,34 +335,18 @@ def align_images(img_ref, img_0, feature_config=None, matching_config=None, alig
                 callbacks['save_plot'](plot_path)
         h_sub, w_sub = img_0_sub.shape[:2]
         if subsample > 1:
-            if transform == constants.ALIGN_HOMOGRAPHY:
-                low_size = np.float32([[0, 0], [0, h_sub], [w_sub, h_sub], [w_sub, 0]])
-                high_size = np.float32([[0, 0], [0, h0], [w0, h0], [w0, 0]])
-                scale_up = cv2.getPerspectiveTransform(low_size, high_size)
-                scale_down = cv2.getPerspectiveTransform(high_size, low_size)
-                m = scale_up @ m @ scale_down
-            elif transform == constants.ALIGN_RIGID:
-                rotation = m[:2, :2]
-                translation = m[:, 2]
-                translation_fullres = translation * subsample
-                m = np.empty((2, 3), dtype=np.float32)
-                m[:2, :2] = rotation
-                m[:, 2] = translation_fullres
-            else:
+            m = rescale_trasnsform(m, w0, h0, w_sub, h_sub, subsample, transform)
+            if m is None:
                 raise InvalidOptionError("transform", transform)
-
         transform_type = alignment_config['transform']
-        is_valid = True
-        reason = ""
-        if transform_type == constants.ALIGN_RIGID:
-            is_valid, reason = check_affine_matrix(
-                m, img_0.shape, affine_thresholds)
-        elif transform_type == constants.ALIGN_HOMOGRAPHY:
-            is_valid, reason = check_homography_distortion(
-                m, img_0.shape, homography_thresholds)
+        is_valid, reason = check_transform(
+            m, img_0, transform_type,
+            affine_thresholds, homography_thresholds)
         if not is_valid:
             if callbacks and 'warning' in callbacks:
                 callbacks['warning'](f"invalid transformation: {reason}")
+            if alignment_config['abort_abnormal']:
+                raise RuntimeError("invalid transformation: {reason}")
             return n_good_matches, None, None
         if callbacks and 'align_message' in callbacks:
             callbacks['align_message']()
@@ -357,12 +375,12 @@ def align_images(img_ref, img_0, feature_config=None, matching_config=None, alig
     return n_good_matches, m, img_warp
 
 
-class AlignFrames(SubAction):
+class AlignFramesBase(SubAction):
     def __init__(self, enabled=True, feature_config=None, matching_config=None,
                  alignment_config=None, **kwargs):
         super().__init__(enabled)
         self.process = None
-        self.n_matches = None
+        self._n_good_matches = None
         self.feature_config = {**_DEFAULT_FEATURE_CONFIG, **(feature_config or {})}
         self.matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
         self.alignment_config = {**_DEFAULT_ALIGNMENT_CONFIG, **(alignment_config or {})}
@@ -380,69 +398,36 @@ class AlignFrames(SubAction):
             if k in kwargs:
                 self.alignment_config[k] = kwargs[k]
 
+    def align_images(self, idx, img_ref, img_0):
+        pass
+
+    def print_message(self, msg, color=constants.LOG_COLOR_LEVEL_3, level=logging.INFO):
+        self.process.print_message(color_str(msg, color), level=level)
+
+    def begin(self, process):
+        self.process = process
+        self._n_good_matches = np.zeros(process.total_action_counts)
+
     def run_frame(self, idx, ref_idx, img_0):
         if idx == self.process.ref_idx:
             return img_0
         img_ref = self.process.img_ref(ref_idx)
         return self.align_images(idx, img_ref, img_0)
 
-    def sub_msg(self, msg, color=constants.LOG_COLOR_LEVEL_3):
-        self.process.sub_message_r(color_str(msg, color))
+    def get_transform_thresholds(self):
+        return _AFFINE_THRESHOLDS, _HOMOGRAPHY_THRESHOLDS
 
-    def align_images(self, idx, img_ref, img_0):
-        idx_str = f"{idx:04d}"
-        callbacks = {
-            'message': lambda: self.sub_msg(': find matches'),
-            'matches_message': lambda n: self.sub_msg(f": good matches: {n}"),
-            'align_message': lambda: self.sub_msg(': align images'),
-            'ecc_message': lambda: self.sub_msg(": ecc refinement"),
-            'blur_message': lambda: self.sub_msg(': blur borders'),
-            'warning': lambda msg: self.sub_msg(
-                f': {msg}', constants.LOG_COLOR_WARNING),
-            'save_plot': lambda plot_path: self.process.callback(
-                'save_plot', self.process.id,
-                f"{self.process.name}: matches\nframe {idx_str}", plot_path)
-        }
-        if self.plot_matches:
-            plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
-                f"{self.process.name}-matches-{idx_str}.pdf"
-        else:
-            plot_path = None
-        if self.alignment_config['abort_abnormal']:
-            affine_thresholds = _AFFINE_THRESHOLDS
-            homography_thresholds = _HOMOGRAPHY_THRESHOLDS
-        else:
-            affine_thresholds = None
-            homography_thresholds = None
-        n_good_matches, _m, img = align_images(
-            img_ref, img_0,
-            feature_config=self.feature_config,
-            matching_config=self.matching_config,
-            alignment_config=self.alignment_config,
-            plot_path=plot_path,
-            callbacks=callbacks,
-            affine_thresholds=affine_thresholds,
-            homography_thresholds=homography_thresholds
-        )
-        self.n_matches[idx] = n_good_matches
-        if n_good_matches < self.min_matches:
-            self.process.sub_message(color_str(f": image not aligned, too few matches found: "
-                                     f"{n_good_matches}", constants.LOG_COLOR_WARNING),
-                                     level=logging.WARNING)
-            return None
-        return img
-
-    def begin(self, process):
-        self.process = process
-        self.n_matches = np.zeros(process.total_action_counts)
+    def image_str(self, idx):
+        return f"image: {self.process.idx_tot_str(idx)}, " \
+               f"{os.path.basename(self.process.input_filepath(idx))}"
 
     def end(self):
         if self.plot_summary:
             plt.figure(figsize=constants.PLT_FIG_SIZE)
-            x = np.arange(1, len(self.n_matches) + 1, dtype=int)
+            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_matches[no_ref]
+            y = self._n_good_matches[no_ref]
             if self.process.ref_idx == 0:
                 y_max = y[1]
             elif self.process.ref_idx >= len(y):
@@ -464,5 +449,52 @@ class AlignFrames(SubAction):
                         f"{self.process.name}-matches.pdf"
             save_plot(plot_path)
             plt.close('all')
-            self.process.callback('save_plot', self.process.id,
+            self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
                                   f"{self.process.name}: matches", plot_path)
+
+
+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)
+        callbacks = {
+            'message': lambda: self.print_message(f'{idx_tot_str}: find matches'),
+            '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'),
+            'blur_message': lambda: self.print_message(f'{idx_tot_str}: blur borders'),
+            'warning': lambda msg: self.print_message(
+                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)
+        }
+        if self.plot_matches:
+            plot_path = f"{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()
+        n_good_matches, _m, img = align_images(
+            img_ref, img_0,
+            feature_config=self.feature_config,
+            matching_config=self.matching_config,
+            alignment_config=self.alignment_config,
+            plot_path=plot_path,
+            callbacks=callbacks,
+            affine_thresholds=affine_thresholds,
+            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 sequential_processing(self):
+        return True

shinestacker/algorithms/align_auto.py

@@ -0,0 +1,64 @@
+# pylint: disable=C0114, C0115, C0116, W0718, R0912, R0915, E1101, R0914, R0911, E0606, R0801, R0902
+import os
+from ..config.constants import constants
+from .align import AlignFramesBase, AlignFrames
+from .align_parallel import AlignFramesParallel
+
+
+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.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
+        available_cores = os.cpu_count() or 1
+        self.num_threads = min(self.max_threads, available_cores)
+        self._implementation = None
+
+    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)
+        else:
+            if self.mode == 'parallel':
+                num_threads = self.num_threads
+                chunk_submit = self.chunk_submit
+            else:
+                if self.feature_config is not None:
+                    detector = self.feature_config.get(
+                        'detector', constants.DEFAULT_DETECTOR)
+                    descriptor = self.feature_config.get(
+                        'descriptor', constants.DEFAULT_DESCRIPTOR)
+                else:
+                    detector = constants.DEFAULT_DETECTOR
+                    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)
+                    chunk_submit = True
+                else:
+                    num_threads = self.num_threads
+                    chunk_submit = self.chunk_submit
+            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)
+        self._implementation.begin(process)
+
+    def align_images(self, idx, img_ref, img_0):
+        return self._implementation.align_images(idx, img_ref, img_0)
+
+    def run_frame(self, idx, ref_idx, img_0):
+        return self._implementation.run_frame(idx, ref_idx, img_0)
+
+    def sequential_processing(self):
+        return self._implementation.sequential_processing()
+
+    def end(self):
+        self._implementation.end()

shinestacker/algorithms/align_parallel.py

@@ -0,0 +1,296 @@
+# 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
+from .align import (AlignFramesBase, detect_and_compute_matches, find_transform,
+                    check_transform, _cv2_border_mode_map, rescale_trasnsform)
+
+
+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=True, feature_config=None, matching_config=None,
+                         alignment_config=None, **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
+
+    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)
+        n_frames = self.process.num_input_filepaths()
+        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
+        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
+        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 i in range(n_frames):
+            if self._img_cache[i] is not None:
+                self._img_cache[i] = 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)
+        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 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 = detect_and_compute_matches(
+                img_ref_sub, img_0_sub, self.feature_config, self.matching_config)
+            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)
+            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)
+        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:
+                warning_messages.append(f"invalid option {transform}")
+                self._target_indices[idx] = None
+                self._transforms[idx] = None
+                return info_messages, warning_messages
+        transform_type = self.alignment_config['transform']
+        thresholds = self.get_transform_thresholds()
+        is_valid, reason = check_transform(m, img_0, transform_type, *thresholds)
+        if not is_valid:
+            self.print_message(
+                f"warning: invalid transformation for {self.image_str(idx)}: {reason}",
+                level=logging.WARNING)
+            if self.alignment_config['abort_abnormal']:
+                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
+        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