shinestacker 1.2.1__tar.gz → 1.3.0__tar.gz

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

@@ -2,8 +2,32 @@
 
 This page reports the main releases only and the main changes therein.
 
-## [v1.2.1] - 2025-09-01
+
+## [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
@@ -16,6 +40,8 @@ This page reports the main releases only and the main changes therein.
 ## [v1.2.0] - 2025-08-31
 **Parallel processing and more improvements**
 
+### Changes
+
 * Implemented parallel processing for pyramid stacking algorithm
 * 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.2.1
+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.1 → 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.1 → 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.1 → 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.1 → shinestacker-1.3.0}/docs/job.md

@@ -44,3 +44,5 @@ Arguments for the constructor of ```CombinedActions``` are for the :
 * ```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.1 → 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.1 → shinestacker-1.3.0}/pyproject.toml

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

{shinestacker-1.2.1 → 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.1 → shinestacker-1.3.0}/src/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-1.3.0/src/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()