shinestacker 1.3.1__tar.gz → 1.5.0__tar.gz

{shinestacker-1.3.1 → shinestacker-1.5.0}/CHANGELOG.md

@@ -2,11 +2,48 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v1.5.0] - 2025-09-16
+**GUI updates and fixes**
+
+### Added
+- implemented image rotation
+- dotted cursor in secondary two-image view
+
+### Fixed
+- fixed zoom in wheel events for side-by-side view
+- restored standard cursor in empty retouch views
+- lower/upper case GUI labels
+
+### Changed
+- code refactoring and cleanup
+
+---
+
+## [v1.4.0] - 2025-09-14
+**GUI improvements**
+
+### Added
+- added retouch view mode with master and frame side by side and top-bottom
+- implemented "Open Recent" menu entry for both projects and retouch images
+- expert options can be shown with a checkbox in each dialog
+- optional summary plots for alignment transformation parameters
+
+### Fixed
+- fixed bug in plot generation
+- fixes warning due to missing glyph in PDF generation on macOS
+- safer parallel plot generation using a thread locks
+
+### Changed
+- code refactoring in various areas
+
+
 ## [v1.3.1] - 2025-09-08
+**Fixes and optimizations**
 
-## Fixed
+### Fixed
 - fixed input folder widget in job configuration
 - better management of patological alignments
+- restored alignment match plots
 
 ### Changed
 - improved automatic parameters for parallel alignment

{shinestacker-1.3.1/src/shinestacker.egg-info → shinestacker-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.3.1
+Version: 1.5.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0
@@ -70,11 +70,11 @@ 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
+## 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
+## 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).**
 
@@ -93,17 +93,17 @@ 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.
 
-# Credits
+## 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.
 
-# Resources
+## Resources
 
 * [Pyramid Methods in Image Processing](https://www.researchgate.net/publication/246727904_Pyramid_Methods_in_Image_Processing), E. H. Adelson, C. H. Anderson,  J. R. Bergen, P. J. Burt, J. M. Ogden, RCA Engineer, 29-6, Nov/Dec 1984
 Pyramid methods in image processing
 * [A Multi-focus Image Fusion Method Based on Laplacian Pyramid](http://www.jcomputers.us/vol6/jcp0612-07.pdf), Wencheng Wang, Faliang Chang, Journal of Computers 6 (12), 2559, December 2011
 
-# License
+## License
 
 <img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
 
@@ -112,7 +112,7 @@ Pyramid methods in image processing
 
 - **Logo**: The Shine Stacker logo was designed by [Alessandro Lista](https://linktr.ee/alelista). Copyright © Alessandro Lista. All rights reserved. The logo is not covered by the LGPL-3.0 license of this project.
 
-# Attribution request
+## Attribution request
 📸 If you publish images created with Shine Stacker, please consider adding a note such as:
 
 *Created with Shine Stacker – https://github.com/lucalista/shinestacker*

{shinestacker-1.3.1 → shinestacker-1.5.0}/README.md

@@ -38,11 +38,11 @@ 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
+## 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
+## 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).**
 
@@ -61,17 +61,17 @@ 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.
 
-# Credits
+## 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.
 
-# Resources
+## Resources
 
 * [Pyramid Methods in Image Processing](https://www.researchgate.net/publication/246727904_Pyramid_Methods_in_Image_Processing), E. H. Adelson, C. H. Anderson,  J. R. Bergen, P. J. Burt, J. M. Ogden, RCA Engineer, 29-6, Nov/Dec 1984
 Pyramid methods in image processing
 * [A Multi-focus Image Fusion Method Based on Laplacian Pyramid](http://www.jcomputers.us/vol6/jcp0612-07.pdf), Wencheng Wang, Faliang Chang, Journal of Computers 6 (12), 2559, December 2011
 
-# License
+## License
 
 <img src="https://www.gnu.org/graphics/lgplv3-147x51.png" alt="LGPL 3 logo">
 
@@ -80,7 +80,7 @@ Pyramid methods in image processing
 
 - **Logo**: The Shine Stacker logo was designed by [Alessandro Lista](https://linktr.ee/alelista). Copyright © Alessandro Lista. All rights reserved. The logo is not covered by the LGPL-3.0 license of this project.
 
-# Attribution request
+## Attribution request
 📸 If you publish images created with Shine Stacker, please consider adding a note such as:
 
 *Created with Shine Stacker – https://github.com/lucalista/shinestacker*

{shinestacker-1.3.1 → shinestacker-1.5.0}/docs/alignment.md

@@ -100,12 +100,21 @@ 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. 
+* ```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.
+
+## Automatic selection of processing strategy
+
+A class ```AlignFramesAuto``` implements alignment with either sequential or parallel processing, and automatically tunes parallel processing parameters.
+This class has extra parameters, in addition to the above ones:
+
+* ```mode``` (optional, default: ```auto```): can be ```auto```, ```sequential``` or ```parallel```.
+* ```memory_limit``` (optional, default: 8×1024<sup>3</sup>sup>): memory limit to determine optimal running parameters
+
 
 ## Allowed configurations
 
 ⚠️ Not all combinations of detector, descriptor and match methods are allowed. Combinations that are not allowed
-give raise to an exception.
+give raise to an exception. This is automatically prevented if one works with the GUI, but may occur when using python scripting. Below the table of the allowed combination with a comparison of CPU performances.
 
 ## CPU performances
 

shinestacker-1.5.0/src/shinestacker/_version.py

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

{shinestacker-1.3.1 → shinestacker-1.5.0}/src/shinestacker/algorithms/align.py

@@ -5,13 +5,13 @@ import logging
 import numpy as np
 import cv2
 import matplotlib.pyplot as plt
-import matplotlib
 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
-matplotlib.use('Agg')
+setup_matplotlib_mode()
 
 _DEFAULT_FEATURE_CONFIG = {
     'detector': constants.DEFAULT_DETECTOR,
@@ -135,14 +135,14 @@ def check_homography_distortion(m, img_shape, homography_thresholds=_HOMOGRAPHY_
         (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)
+            m, img_shape, homography_thresholds)
     return False, f'invalid transfrom option {transform_type}', None
 
 
@@ -251,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
 
 
@@ -349,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, _result = 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}")
@@ -407,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
@@ -417,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:
@@ -432,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 = np.array(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()
@@ -458,15 +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 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}'),
@@ -476,7 +652,8 @@ 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 = os.path.join(
@@ -504,5 +681,8 @@ class AlignFrames(AlignFramesBase):
             return None
         return img
 
+    def relative_transformation(self):
+        return False
+
     def sequential_processing(self):
         return True

{shinestacker-1.3.1 → shinestacker-1.5.0}/src/shinestacker/algorithms/align_parallel.py

@@ -39,6 +39,7 @@ class AlignFramesParallel(AlignFramesBase):
         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
@@ -48,6 +49,9 @@ class AlignFramesParallel(AlignFramesBase):
         self._kp = None
         self._des = None
 
+    def relative_transformation(self):
+        return True
+
     def cache_img(self, idx):
         with self._cache_locks[idx]:
             self._img_locks[idx] += 1
@@ -56,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):
@@ -112,6 +118,7 @@ class AlignFramesParallel(AlignFramesBase):
                               self.process.id, self.process.name, 2 * n_frames)
         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
@@ -168,9 +175,17 @@ class AlignFramesParallel(AlignFramesBase):
             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"
@@ -277,7 +292,8 @@ class AlignFramesParallel(AlignFramesBase):
                 return self.extract_features(idx, delta + 1)
         transform_type = self.alignment_config['transform']
         thresholds = self.get_transform_thresholds()
-        is_valid, _reason, _result = 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']