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

shinestacker/_version.py

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

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
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
 from .. core.colors import color_str
+from .. core.core_utils import setup_matplotlib_mode
 from .utils import img_8bit, img_bw_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
+setup_matplotlib_mode()
 
 _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,19 +130,20 @@ 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,
+def check_transform(m, img_shape, transform_type,
                     affine_thresholds, homography_thresholds):
     if transform_type == constants.ALIGN_RIGID:
         return check_affine_matrix(
-            m, img_0.shape, affine_thresholds)
+            m, img_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}'
+            m, img_shape, homography_thresholds)
+    return False, f'invalid transfrom option {transform_type}', None
 
 
 def get_good_matches(des_0, des_ref, matching_config=None):
@@ -247,7 +251,10 @@ def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
                                              confidence=align_confidence / 100.0,
                                              refineIters=refine_iters)
     else:
-        raise InvalidOptionError("transform", transform)
+        raise InvalidOptionError(
+            'transform', method,
+            f". Valid options are: {constants.ALIGN_HOMOGRAPHY}, {constants.ALIGN_RIGID}"
+        )
     return result
 
 
@@ -270,6 +277,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 +334,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,9 +352,11 @@ 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(
-            m, img_0, transform_type,
+        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}")
@@ -397,6 +412,18 @@ class AlignFramesBase(SubAction):
         for k in self.alignment_config:
             if k in kwargs:
                 self.alignment_config[k] = kwargs[k]
+        self._area_ratio = None
+        self._aspect_ratio = None
+        self._max_angle_dev = None
+        self._scale_x = None
+        self._scale_y = None
+        self._translation_x = None
+        self._translation_y = None
+        self._rotation = None
+        self._shear = None
+
+    def relative_transformation(self):
+        return None
 
     def align_images(self, idx, img_ref, img_0):
         pass
@@ -407,6 +434,15 @@ class AlignFramesBase(SubAction):
     def begin(self, process):
         self.process = process
         self._n_good_matches = np.zeros(process.total_action_counts)
+        self._area_ratio = np.ones(process.total_action_counts)
+        self._aspect_ratio = np.ones(process.total_action_counts)
+        self._max_angle_dev = np.zeros(process.total_action_counts)
+        self._scale_x = np.ones(process.total_action_counts)
+        self._scale_y = np.ones(process.total_action_counts)
+        self._translation_x = np.zeros(process.total_action_counts)
+        self._translation_y = np.zeros(process.total_action_counts)
+        self._rotation = np.zeros(process.total_action_counts)
+        self._shear = np.zeros(process.total_action_counts)
 
     def run_frame(self, idx, ref_idx, img_0):
         if idx == self.process.ref_idx:
@@ -422,24 +458,29 @@ class AlignFramesBase(SubAction):
                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_good_matches) + 1, dtype=int)
+
+        def get_coordinates(items):
+            x = np.arange(1, len(items) + 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(items)[no_ref]
             if self.process.ref_idx == 0:
-                y_max = y[1]
+                y_ref = y[1]
             elif self.process.ref_idx >= len(y):
-                y_max = y[-1]
+                y_ref = y[-1]
             else:
-                y_max = (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
+                y_ref = (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
+            return x, y, y_ref
 
+        if self.plot_summary:
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
+            x, y, y_ref = get_coordinates(self._n_good_matches)
             plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
-                     [0, y_max], color='cornflowerblue', linestyle='--', label='reference frame')
+                     [0, y_ref], color='cornflowerblue', linestyle='--', label='reference frame')
             plt.plot([x[0], x[-1]], [self.min_matches, self.min_matches], color='lightgray',
                      linestyle='--', label='min. matches')
             plt.plot(x, y, color='navy', label='matches')
+            plt.title("Number of matches")
             plt.xlabel('frame')
             plt.ylabel('# of matches')
             plt.legend()
@@ -448,19 +489,160 @@ class AlignFramesBase(SubAction):
             plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
                         f"{self.process.name}-matches.pdf"
             save_plot(plot_path)
-            plt.close('all')
             self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
                                   f"{self.process.name}: matches", plot_path)
+            transform = self.alignment_config['transform']
+            title = "Transformation parameters rel. to reference frame"
+            if transform == constants.ALIGN_RIGID:
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._rotation)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [0, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='navy', label='rotation (°)')
+                y_lim = max(abs(y.min()), abs(y.max())) * 1.1
+                plt.ylim(-y_lim, y_lim)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('rotation angle (degrees)')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-rotation.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: rotation", plot_path)
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y_x, y_x_ref = get_coordinates(self._translation_x)
+                x, y_y, y_y_ref = get_coordinates(self._translation_y)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [y_x_ref, y_y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y_x, color='blue', label='translation, x (px)')
+                plt.plot(x, y_y, color='red', label='translation, y (px)')
+                y_lim = max(abs(y_x.min()), abs(y_x.max()), abs(y_y.min()), abs(y_y.max())) * 1.1
+                plt.ylim(-y_lim, y_lim)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('translation (pixels)')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-translation.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: translation", plot_path)
+
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._scale_x)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [1, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [1, 1], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='blue', label='scale factor')
+                d_max = max(abs(y.min() - 1), abs(y.max() - 1)) * 1.1
+                plt.ylim(1.0 - d_max, 1.0 + d_max)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('scale factor')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-scale.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: scale", plot_path)
+            elif transform == constants.ALIGN_HOMOGRAPHY:
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._area_ratio)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [0, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='navy', label='area ratio')
+                d_max = max(abs(y.min() - 1), abs(y.max() - 1)) * 1.1
+                plt.ylim(1.0 - d_max, 1.0 + d_max)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('warped area ratio')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-area-ratio.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: area ratio", plot_path)
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._aspect_ratio)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [0, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='navy', label='aspect ratio')
+                y_min, y_max = y.min(), y.max()
+                delta = y_max - y_min
+                plt.ylim(y_min - 0.05 * delta, y_max + 0.05 * delta)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('aspect ratio')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-aspect-ratio.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: aspect ratio", plot_path)
+                plt.figure(figsize=constants.PLT_FIG_SIZE)
+                x, y, y_ref = get_coordinates(self._max_angle_dev)
+                plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                         [0, y_ref], color='cornflowerblue',
+                         linestyle='--', label='reference frame')
+                plt.plot([x[0], x[-1]], [0, 0], color='cornflowerblue', linestyle='--')
+                plt.plot(x, y, color='navy', label='max. dev. ang. (°)')
+                y_lim = max(abs(y.min()), abs(y.max())) * 1.1
+                plt.ylim(-y_lim, y_lim)
+                plt.title(title)
+                plt.xlabel('frame')
+                plt.ylabel('max deviation angle (degrees)')
+                plt.legend()
+                plt.xlim(x[0], x[-1])
+                plot_path = f"{self.process.working_path}/{self.process.plot_path}/" \
+                            f"{self.process.name}-rotation.pdf"
+                save_plot(plot_path)
+                self.process.callback(constants.CALLBACK_SAVE_PLOT, self.process.id,
+                                      f"{self.process.name}: rotation", plot_path)
+
+    def save_transform_result(self, idx, result):
+        if result is None:
+            return
+        transform = self.alignment_config['transform']
+        if transform == constants.ALIGN_HOMOGRAPHY:
+            area_ratio, aspect_ratio, max_angle_dev = result
+            self._area_ratio[idx] = area_ratio
+            self._aspect_ratio[idx] = aspect_ratio
+            self._max_angle_dev[idx] = max_angle_dev
+        elif transform == constants.ALIGN_RIGID:
+            scale_x, scale_y, translation_x, translation_y, rotation, shear = result
+            self._scale_x[idx] = scale_x
+            self._scale_y[idx] = scale_y
+            self._translation_x[idx] = translation_x
+            self._translation_y[idx] = translation_y
+            self._rotation[idx] = rotation
+            self._shear[idx] = shear
+        else:
+            raise InvalidOptionError(
+                'transform', transform,
+                f". Valid options are: {constants.ALIGN_HOMOGRAPHY}, {constants.ALIGN_RIGID}"
+            )
 
 
 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}'),
@@ -470,11 +652,14 @@ class AlignFrames(AlignFramesBase):
                 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)
+                f"{self.process.name}: matches\nframe {idx_str}", plot_path),
+            'save_transform_result': lambda result: self.save_transform_result(idx, result)
         }
         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()
@@ -496,5 +681,8 @@ class AlignFrames(AlignFramesBase):
             return None
         return img
 
+    def relative_transformation(self):
+        return False
+
     def sequential_processing(self):
         return True

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,18 +33,24 @@ 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)
         self._img_cache = None
+        self._img_shapes = None
         self._img_locks = None
         self._cache_locks = None
         self._target_indices = None
         self._transforms = None
         self._cumulative_transforms = None
         self.step_counter = 0
+        self._kp = None
+        self._des = None
+
+    def relative_transformation(self):
+        return True
 
     def cache_img(self, idx):
         with self._cache_locks[idx]:
@@ -52,6 +60,8 @@ class AlignFramesParallel(AlignFramesBase):
                 if self.bw_matching:
                     img = img_bw(img)
                 self._img_cache[idx] = img
+                if img is not None:
+                    self._img_shapes[idx] = img.shape
             return self._img_cache[idx]
 
     def submit_threads(self, idxs, imgs):
@@ -98,18 +108,25 @@ 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_shapes = [None] * n_frames
         self._img_locks = [0] * n_frames
         self._cache_locks = [threading.Lock() for _ in range(n_frames)]
         self._target_indices = [None] * n_frames
         self._n_good_matches = [0] * n_frames
         self._transforms = [None] * n_frames
         self._cumulative_transforms = [None] * n_frames
+        self._kp = [None] * n_frames
+        self._des = [None] * n_frames
         max_chunck_size = self.max_threads
         ref_idx = self.process.ref_idx
         self.print_message(f"reference: {self.image_str(ref_idx)}")
@@ -125,9 +142,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,10 +171,21 @@ 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
+        thresholds = self.get_transform_thresholds()
         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(
+                    self._cumulative_transforms[i], self._img_shapes[i],
+                    transform_type, *thresholds)
+                if is_valid:
+                    self.save_transform_result(i, result)
+                else:
+                    self._cumulative_transforms[i] = None
             else:
                 missing_transforms += 1
         msg = "feature extaction completed"
@@ -165,6 +195,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 +258,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 +273,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 +285,25 @@ 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.shape, transform_type, *thresholds)
+        # self.save_transform_result(idx, result)
         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