shinestacker 1.3.0__tar.gz → 1.4.0__tar.gz

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

@@ -2,8 +2,46 @@
 
 This page reports the main releases only and the main changes therein.
 
+## [v1.4.0] - 2025-09-14
+**GUI improvements**
 
-## [v1.3.0] - 2025-09-05
+### 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
+
+---
+
+### Changed
+- code cleanup
+
+## [v1.3.1] - 2025-09-08
+**Fixes and optimizations**
+
+## Fixed
+- fixed input folder widget in job configuration
+- better management of patological alignments
+- restored alignment match plots
+
+### Changed
+- improved automatic parameters for parallel alignment
+- improved pyramid performances by combining two input steps
+- improved performances of ORB and SURF feature extraction with key points caching
+- improved configuration GUI using tabs and other minor GUI improvements
+- code clean up and some fixes
+
+---
+
+## [v1.3.0] - 2025-09-06
 **Parallel processing and input flexibility**
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shinestacker
-Version: 1.3.0
+Version: 1.4.0
 Summary: ShineStacker
 Author-email: Luca Lista <luka.lista@gmail.com>
 License-Expression: LGPL-3.0

{shinestacker-1.3.0 → shinestacker-1.4.0}/THIRD_PARTY_LICENSES.txt

@@ -40,18 +40,17 @@ psdtags
 License: MIT
 https://pypi.org/project/psdtags/
 
+-------------------------------------------------------------------------------
+psutil
+License: BSD-3-Clause
+https://pypi.org/project/psutil/
+
 -------------------------------------------------------------------------------
 PySide6
 License: GNU Lesser General Public License v3.0 (LGPL-3.0)  
 or commercial license from The Qt Company
 https://doc.qt.io/qtforpython/
 
-Full license text follows:
-
---- BEGIN LGPL-3.0 LICENSE ---
-<qui incolla il testo completo della LGPL-3.0>
---- END LGPL-3.0 LICENSE ---
-
 -------------------------------------------------------------------------------
 scipy
 License: BSD-3-Clause
@@ -67,14 +66,8 @@ tqdm
 License: Mozilla Public License 2.0 (MPL-2.0)
 https://github.com/tqdm/tqdm
 
-Full license text follows:
-
---- BEGIN MPL-2.0 LICENSE ---
-<qui incolla il testo completo della MPL-2.0>
---- END MPL-2.0 LICENSE ---
-
 -------------------------------------------------------------------------------
 
 NOTE:
 This file is provided for license compliance and attribution purposes.  
-Your application code is licensed separately under the GNU Lesser General Public License v3.0.
+Shine Stacker code is licensed separately under the GNU Lesser General Public License v3.0.

{shinestacker-1.3.0 → shinestacker-1.4.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
 
@@ -127,3 +136,10 @@ give raise to an exception.
 | 0.2887   |  AKAZE   | BRISK      | NORM_HAMMING |
 | 0.4075   |  AKAZE   | SIFT       | KNN          |
 | 0.4397   |  SIFT    | SIFT       | KNN          |
+
+## References
+
+For a detailed review of the various image registration methods, see the publication below:
+*  [A Review of Keypoints’ Detection and Feature Description in Image Registration](https://onlinelibrary.wiley.com/doi/10.1155/2021/8509164), Scientific Programming 2021, 8509164, doi:10.1155/2021/8509164
+
+

shinestacker-1.4.0/index.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Shine Stacker</title>
+  <meta name="description" content="Shine Stacker – Open source focus stacking framework with GUI for macro and micro photography.">
+    
+    <!-- Open Graph / Facebook -->
+    <meta property="og:type" content="website">
+    <meta property="og:title" content="Shine Stacker">
+    <meta property="og:description" content="Open source focus stacking framework with GUI for macro and micro photography.">
+    <meta property="og:image" content="https://raw.githubusercontent.com/lucalista/shinestacker/main/src/shinestacker/gui/ico/shinestacker.png">
+    <meta property="og:url" content="https://lucalista.github.io/shinestacker/">
+    
+    <!-- Twitter Card -->
+    <meta name="twitter:card" content="summary_large_image">
+    <meta name="twitter:title" content="Shine Stacker">
+    <meta name="twitter:description" content="Open source focus stacking framework with GUI for macro and micro photography.">
+    <meta name="twitter:image" content="https://raw.githubusercontent.com/lucalista/shinestacker/main/src/shinestacker/gui/ico/shinestacker.png">
+  <style>
+    body { font-family: sans-serif; margin: 40px; line-height: 1.6; background: #f7f7f7; color: #333; }
+    h1 { color: #2c3e50; font-size: 48px}
+    a { color: #2980b9; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    .container { max-width: 800px; margin: auto; background: #fff; padding: 30px; border-radius: 10px; box-shadow: 0 4px 10px rgba(0,0,0,0.1);}
+    .logo { width: 150px; }
+    ul { text-align: left; }
+    .footer { color: #A0A0A0; }
+  </style>
+</head>
+<body>
+  <div class="container" style="text-align:center;">
+  <h1>Shine Stacker</h1>
+    <img src="https://raw.githubusercontent.com/lucalista/shinestacker/main/src/shinestacker/gui/ico/shinestacker.png" alt="Shine Stacker Logo" class="logo">  <p>Open source framework and GUI for focus stacking macro and micro photography.</p>
+  <h2><a href="https://lucalista.github.io/shinestacker/docs/main.html">Go to GitHub website</h2>
+  <ul>
+  <li><a href="https://shinestacker.wordpress.com/">Shine Stacker on Wordpress</a></li>
+  <li><a href="https://shinestacker.readthedocs.io/">Complete documentation</a></li>
+  <li><a href="https://github.com/lucalista/shinestacker">Source code and releases on GitHub</a></li>
+</ul>
+<hr style="color: #f0f0ff;">
+<p class="footer">Shine Stacker, &copy; 2025, <a href="https://github.com/lucalista" alt="Luca Lista">Luca Lista</a> (LGPL-3.0).<br>
+Logo © <a href="https://linktr.ee/alelista" alt="Alessandro Lista">Alessandro Lista</a> — All rights reserved.
+</div>
+</body>
+</html>

shinestacker-1.4.0/src/shinestacker/_version.py

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

{shinestacker-1.3.0 → shinestacker-1.4.0}/src/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-1.3.0 → shinestacker-1.4.0}/src/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