shinestacker 1.2.0__tar.gz → 1.3.0__tar.gz

{shinestacker-1.2.0 → shinestacker-1.3.0}/CHANGELOG.md

@@ -2,20 +2,57 @@
 
 This page reports the main releases only and the main changes therein.
 
+
+## [v1.3.0] - 2025-09-05
+**Parallel processing and input flexibility**
+
+### Added
+- Parallel processing in alignment feature extraction
+- Parallel processing of combined actions
+- Job input can now specify a list of files (not only a folder)
+- CPU and memory usage monitor widget for running jobs
+
+### Fixed
+- Path in example project
+- Bug fix in config dialog
+
+### Changed
+- Changes some default parameters for better performances
+- Some GUI restyling
+- Code cleanup
+
+---
+
+## [v1.2.1] - 2025-09-02
+**Bug fixes and minor improvements**
+
+### Changes
+
+* alignment is more tolerant in case of failures: frames are skipped and the running job is not stopped
+* fixed the -x (--expert) option
+* more safety checks prevent crashes for abnormal conditions
+* reference frame index improved with a more consistent treatment, a better numbering scheme and GUI widget 
+* improved project undo action description text
+* some bug fixes and code cleanup
+
+---
+
 ## [v1.2.0] - 2025-08-31
-**Improved pyramid algorithm**
+**Parallel processing and more improvements**
+
+### Changes
 
 * Implemented parallel processing for pyramid stacking algorithm
-* optimized Pyramid algorithm: now a single algorithm selects automatically the best strategy ensuring that all the processing stays approximately within a given memory budget; This avoids memory issues in case many pictures are selected. Explicit configuration is also possible for specific needs.
-* Implemented automatic subsample option for alignment, balancing and vignetting, now default.
+* optimized pyramid algorithm: selects automatically the best within the given memory budget to avoid memory issues in case many pictures are selected. Explicit configuration is also possible for specific needs.
+* Implemented automatic subsample option for alignment, balancing and vignetting, now default
 * HLS and HSV corrections now supported for 16 bit images
 * Added luminosity correction in the LAB color space
 * Alignment module skips frames if transformation parameters are out of a reasonable ranges
-* Multilayer modules sends a warning if the estimated file size is > 1GB
-* "Run all jobs" action is enabled only if more than one job are present.
-* Updated default module names for "new project" dialog.
-* Code refactoring.
-* Some GUI fixes.
+* Multilayer modules sends a warning if the estimated output file size is > 1GB
+* "Run all jobs" action is enabled only if more than one job are present
+* Updated default module names in project genereated by "new project" dialog
+* Code refactoring
+* Some GUI fixes
 
 ---
 

{shinestacker-1.2.0/src/shinestacker.egg-info → shinestacker-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.2.0
+Version: 1.3.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -20,6 +20,7 @@ Requires-Dist: numpy
 Requires-Dist: opencv_python
 Requires-Dist: pillow
 Requires-Dist: psdtags
+Requires-Dist: psutil
 Requires-Dist: PySide6
 Requires-Dist: scipy
 Requires-Dist: tifffile
@@ -69,6 +70,10 @@ The GUI has two main working areas:
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-retouch.png' width="600" referrerpolicy="no-referrer">
 
+# Resources
+
+ 🌍 [Website on WordPress](https://shinestacker.wordpress.com) • 📖 [Main documentation](https://shinestacker.readthedocs.io) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md) 
+
 # Note for macOS users
 
 **The following note is only relevant if you download the application as compressed archive from the [release page](https://github.com/lucalista/shinestacker/releases).**
@@ -88,11 +93,6 @@ xattr -cr ~/Downloads/shinestacker/shinestacker.app
 
 macOS adds a quarantine flag to all files downloaded from the internet. The above command removes that flag while preserving all other application functionality.
 
-# Resources
-
- 🌍 [Website on WordPress](https://shinestacker.wordpress.com) • 📖 [Main documentation](https://shinestacker.readthedocs.io) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md) 
-
-
 # Credits
 
 The first version of the core focus stack algorithm was initially inspired by the [Laplacian pyramids method](https://github.com/sjawhar/focus-stacking) implementation by Sami Jawhar that was used under permission of the author. The implementation in the latest releases was rewritten from the original code.

{shinestacker-1.2.0 → shinestacker-1.3.0}/README.md

@@ -38,6 +38,10 @@ The GUI has two main working areas:
 
 <img src='https://raw.githubusercontent.com/lucalista/shinestacker/main/img/gui-retouch.png' width="600" referrerpolicy="no-referrer">
 
+# Resources
+
+ 🌍 [Website on WordPress](https://shinestacker.wordpress.com) • 📖 [Main documentation](https://shinestacker.readthedocs.io) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md) 
+
 # Note for macOS users
 
 **The following note is only relevant if you download the application as compressed archive from the [release page](https://github.com/lucalista/shinestacker/releases).**
@@ -57,11 +61,6 @@ xattr -cr ~/Downloads/shinestacker/shinestacker.app
 
 macOS adds a quarantine flag to all files downloaded from the internet. The above command removes that flag while preserving all other application functionality.
 
-# Resources
-
- 🌍 [Website on WordPress](https://shinestacker.wordpress.com) • 📖 [Main documentation](https://shinestacker.readthedocs.io) • 📝 [Changelog](https://github.com/lucalista/shinestacker/blob/main/CHANGELOG.md) 
-
-
 # Credits
 
 The first version of the core focus stack algorithm was initially inspired by the [Laplacian pyramids method](https://github.com/sjawhar/focus-stacking) implementation by Sami Jawhar that was used under permission of the author. The implementation in the latest releases was rewritten from the original code.

{shinestacker-1.2.0 → shinestacker-1.3.0}/docs/alignment.md

@@ -93,6 +93,14 @@ alignment_config = {
 * ```plot_matches```  (optional, default: ```False```): if ```True```, for each image matches with reference frame are drawn. May be useful for inspection and debugging.
 * ```enabled``` (optional, default: ```True```): allows to switch on and off this module.
 
+## Parallel processing
+
+A class ```AlignFramesParallel``` implements alignment using parallel processing.
+This class has extra parameters, in addition to the above ones:
+
+* ```max_threads``` (optional, default: ```2```): number of parallel processes allowed. The number of actual threads will not be greater than the number of available CPU cores.
+* ```chunk_submit``` (optional, default: ```True```): submit at most ```max_threads``` parallel processes. If ```chunk_submit``` is greater than ```max_threads``` a moderate performance gain is achieved at the cost of a possibly large memory occupancy.
+* ```bw_matching``` (optional, default: ```False```): perform matches on black and white version of the images in order to save memory. Preliminary tests indicate that the gain with this option is marginal, and this option may be dropped in the future. 
 
 ## Allowed configurations
 

{shinestacker-1.2.0 → shinestacker-1.3.0}/docs/focus_stacking.md

@@ -48,6 +48,7 @@ Arguments for the constructor are, in addition to the ones for ```PyramidStack``
    * ```tile_size``` (optional, default: 512): size of a time
    * ```n_tiled_layers``` (optional, default: 2): number of layers that are tiled. Usually the last one or two are the ones that take more memory.
    * ```max_threads``` (optional, default: number of cores, up to a maximum of 8): maximum number of thread used for parallel processing. The actual number of threads does not exceed the number of available cores. 
+* ```chunk_submit``` (optional, default: ```True```): submit at most ```max_threads``` parallel processes. If ```chunk_submit``` is greater than ```max_threads``` a moderate performance gain is achieved at the cost of a possibly large memory occupancy.
 
 
 ```PyramidAutoStack```, pyramid algorithn with capability to automatically switch from all-in-memory to I/O buffered tiled.

{shinestacker-1.2.0 → shinestacker-1.3.0}/docs/job.md

@@ -41,6 +41,8 @@ Arguments for the constructor of ```CombinedActions``` are for the :
 * ```working_path``` (optional): the directory that contains input and output image subdirectories. If not specified, it is the same as ```job.working_path```.
 * ```plot_path``` (optional, default: ```plots```): the directory within ```working_path``` that contains plots produced by the different actions.
 * ```resample``` (optional, default: 1): take every *n*<sup>th</sup> frame in the selected directory. Default: take all frames.
-* ```ref_idx``` (optional): the index of the image used as reference. Images are numbered starting from zero. If not specified, it is the index of the middle image.
+* ```reference_index``` (optional, default: 0): the index of the image used as reference. Images are numbered starting from one to N. -1 is interpreted as the last image, 0 as the median index.
 * ```step_process``` (optional): if equal to ```True``` (default), each image is processed with respect to the previous or next image, depending if its file is placed in alphabetic order after or befor the reference image.
 * ```enabled``` (optional, default: ```True```): allows to switch on and off this module. 
+* ```max_threads``` (optional, default: ```2```): number of parallel processes allowed. The number of actual threads will not be greater than the number of available CPU cores.
+* ```chunk_submit``` (optional, default: ```True```): submit at most ```max_threads``` parallel processes. If ```chunk_submit``` is greater than ```max_threads``` a moderate performance gain is achieved at the cost of a possibly large memory occupancy.

{shinestacker-1.2.0 → shinestacker-1.3.0}/docs/main.md

@@ -87,7 +87,7 @@ job.run()
 
 ### Core processing
 ```bash
-pip install imagecodecs matplotlib numpy opencv-python pillow psdtags scipy setuptools-scm tifffile tqdm
+pip install imagecodecs matplotlib numpy opencv-python pillow psdtags psutil scipy setuptools-scm tifffile tqdm
 ```
 ## GUI support
 ```bash

{shinestacker-1.2.0 → shinestacker-1.3.0}/pyproject.toml

@@ -26,6 +26,7 @@ dependencies = [
     "opencv_python",
     "pillow",
     "psdtags",
+    "psutil",
     "PySide6",
     "scipy",
     "tifffile",

{shinestacker-1.2.0 → shinestacker-1.3.0}/requirements.txt

@@ -6,6 +6,7 @@ numpy
 opencv_python
 pillow
 psdtags
+psutil
 PySide6
 scipy
 tifffile

shinestacker-1.3.0/src/shinestacker/_version.py

@@ -0,0 +1 @@
+__version__ = '1.3.0'

{shinestacker-1.2.0 → shinestacker-1.3.0}/src/shinestacker/algorithms/align.py

@@ -1,11 +1,12 @@
 # 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
 from .. config.constants import constants
-from .. core.exceptions import AlignmentError, InvalidOptionError
+from .. core.exceptions import InvalidOptionError
 from .. core.colors import color_str
 from .utils import img_8bit, img_bw_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
@@ -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,7 +131,18 @@ def check_homography_distortion(m, img_shape, homography_thresholds=_HOMOGRAPHY_
     return True, "Transformation within acceptable limits"
 
 
-def get_good_matches(des_0, des_1, matching_config=None):
+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']
     good_matches = []
@@ -139,12 +151,12 @@ def get_good_matches(des_0, des_1, matching_config=None):
             {'algorithm': matching_config['flann_idx_kdtree'],
              'trees': matching_config['flann_trees']},
             {'checks': matching_config['flann_checks']})
-        matches = flann.knnMatch(des_0, des_1, k=2)
+        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_1), key=lambda x: x.distance)
+        good_matches = sorted(bf.match(des_0, des_ref), key=lambda x: x.distance)
     else:
         raise InvalidOptionError(
             'match_method', match_method,
@@ -172,39 +184,42 @@ def validate_align_config(detector, descriptor, match_method):
                          " require matching method Hamming distance")
 
 
-def detect_and_compute(img_0, img_1, 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']
     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_1 = img_bw_8bit(img_0), img_bw_8bit(img_1)
-    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
-    }
+    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):
         kp_0, des_0 = detector.detectAndCompute(img_bw_0, None)
-        kp_1, des_1 = detector.detectAndCompute(img_bw_1, None)
+        kp_ref, des_ref = detector.detectAndCompute(img_bw_ref, None)
     else:
         descriptor = descriptor_map[feature_config_descriptor]()
         kp_0, des_0 = descriptor.compute(img_bw_0, detector.detect(img_bw_0, None))
-        kp_1, des_1 = descriptor.compute(img_bw_1, detector.detect(img_bw_1, None))
-    return kp_0, kp_1, get_good_matches(des_0, des_1, matching_config)
+        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 find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
@@ -236,7 +251,26 @@ def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
     return result
 
 
-def align_images(img_1, img_0, feature_config=None, matching_config=None, alignment_config=None,
+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,
                  homography_thresholds=_HOMOGRAPHY_THRESHOLDS):
@@ -250,11 +284,11 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     min_matches = 4 if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
     if callbacks and 'message' in callbacks:
         callbacks['message']()
-    h_ref, w_ref = img_1.shape[:2]
+    h_ref, w_ref = img_ref.shape[:2]
     h0, w0 = img_0.shape[:2]
     subsample = alignment_config['subsample']
     if subsample == 0:
-        img_res = (float(h0) / 1000) * (float(w0) / 1000)
+        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 = alignment_config['fast_subsampling']
@@ -262,11 +296,11 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     while True:
         if subsample > 1:
             img_0_sub = img_subsample(img_0, subsample, fast_subsampling)
-            img_1_sub = img_subsample(img_1, subsample, fast_subsampling)
+            img_ref_sub = img_subsample(img_ref, subsample, fast_subsampling)
         else:
-            img_0_sub, img_1_sub = img_0, img_1
-        kp_0, kp_1, good_matches = detect_and_compute(img_0_sub, img_1_sub,
-                                                      feature_config, matching_config)
+            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)
         n_good_matches = len(good_matches)
         if n_good_matches > min_good_matches or subsample == 1:
             break
@@ -282,7 +316,7 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     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_1[m.trainIdx].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, alignment_config['align_method'],
                                 *(alignment_config[k]
                                   for k in ['rans_threshold', 'max_iters',
@@ -290,47 +324,30 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
         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_1_sub),
-                kp_1, good_matches, None, matchColor=(0, 255, 0),
+                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=(10, 5))
+            plt.figure(figsize=constants.PLT_FIG_SIZE)
             plt.imshow(img_match, 'gray')
             save_plot(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:
-            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']()
         img_mask = np.ones_like(img_0, dtype=np.uint8)
@@ -358,12 +375,12 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     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 {})}
@@ -381,27 +398,78 @@ 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 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_good_matches) + 1, dtype=int)
+            no_ref = x != self.process.ref_idx + 1
+            x = x[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):
+                y_max = y[-1]
+            else:
+                y_max = (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
+
+            plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
+                     [0, y_max], 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.xlabel('frame')
+            plt.ylabel('# of matches')
+            plt.legend()
+            plt.ylim(0)
+            plt.xlim(x[0], x[-1])
+            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)
+
 
-    def align_images(self, idx, img_1, img_0):
+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.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(
+            '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(
-                'save_plot', self.process.id,
+                constants.CALLBACK_SAVE_PLOT, self.process.id,
                 f"{self.process.name}: matches\nframe {idx_str}", plot_path)
         }
         if self.plot_matches:
@@ -409,14 +477,9 @@ class AlignFrames(SubAction):
                 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
+        affine_thresholds, homography_thresholds = self.get_transform_thresholds()
         n_good_matches, _m, img = align_images(
-            img_1, img_0,
+            img_ref, img_0,
             feature_config=self.feature_config,
             matching_config=self.matching_config,
             alignment_config=self.alignment_config,
@@ -425,43 +488,13 @@ class AlignFrames(SubAction):
             affine_thresholds=affine_thresholds,
             homography_thresholds=homography_thresholds
         )
-        self.n_matches[idx] = n_good_matches
+        self._n_good_matches[idx] = n_good_matches
         if n_good_matches < self.min_matches:
-            self.process.sub_message(f": image not aligned, too few matches found: "
-                                     f"{n_good_matches}", level=logging.CRITICAL)
-            raise AlignmentError(idx, f"Image not aligned, too few matches found: "
-                                 f"{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 begin(self, process):
-        self.process = process
-        self.n_matches = np.zeros(process.counts)
-
-    def end(self):
-        if self.plot_summary:
-            plt.figure(figsize=(10, 5))
-            x = np.arange(1, len(self.n_matches) + 1, dtype=int)
-            no_ref = x != self.process.ref_idx + 1
-            x = x[no_ref]
-            y = self.n_matches[no_ref]
-            y_max = y[1] \
-                if self.process.ref_idx == 0 \
-                else y[-1] if self.process.ref_idx == len(y) - 1 \
-                else (y[self.process.ref_idx - 1] + y[self.process.ref_idx]) / 2
-
-            plt.plot([self.process.ref_idx + 1, self.process.ref_idx + 1],
-                     [0, y_max], 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.xlabel('frame')
-            plt.ylabel('# of matches')
-            plt.legend()
-            plt.ylim(0)
-            plt.xlim(x[0], x[-1])
-            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('save_plot', self.process.id,
-                                  f"{self.process.name}: matches", plot_path)
+    def sequential_processing(self):
+        return True