PyPI - shinestacker - Versions diffs - 1.3.0__tar.gz → 1.3.1__tar.gz - Mend

shinestacker 1.3.0tar.gz → 1.3.1tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of shinestacker might be problematic. Click here for more details.

Files changed (144) hide show

{shinestacker-1.3.0 → shinestacker-1.3.1}/CHANGELOG.md RENAMED Viewed

@@ -2,8 +2,22 @@
 This page reports the main releases only and the main changes therein.
+## [v1.3.1] - 2025-09-08
-## [v1.3.0] - 2025-09-05
+## Fixed
+- fixed input folder widget in job configuration
+- better management of patological alignments
+### 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.3.1}/PKG-INFO RENAMED Viewed

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

{shinestacker-1.3.0 → shinestacker-1.3.1}/THIRD_PARTY_LICENSES.txt RENAMED Viewed

@@ -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.3.1}/docs/alignment.md RENAMED Viewed

@@ -127,3 +127,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.3.1/index.html ADDED Viewed

@@ -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.3.1/src/shinestacker/_version.py ADDED Viewed

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

{shinestacker-1.3.0 → shinestacker-1.3.1}/src/shinestacker/algorithms/align.py RENAMED Viewed

@@ -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
+import matplotlib
 from .. config.constants import constants
 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
+matplotlib.use('Agg')
 _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,8 +130,9 @@ 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,
@@ -139,7 +143,7 @@ def check_transform(m, img_0, transform_type,
     if transform_type == constants.ALIGN_HOMOGRAPHY:
         return check_homography_distortion(
             m, img_0.shape, homography_thresholds)
-    return False, f'invalid transfrom option {transform_type}'
+    return False, f'invalid transfrom option {transform_type}', None
 def get_good_matches(des_0, des_ref, matching_config=None):
@@ -270,6 +274,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 +331,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,7 +349,7 @@ 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(
+        is_valid, reason, _result = check_transform(
             m, img_0, transform_type,
             affine_thresholds, homography_thresholds)
         if not is_valid:
@@ -427,7 +437,7 @@ class AlignFramesBase(SubAction):
             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]
+            y = np.array(self._n_good_matches)[no_ref]
             if self.process.ref_idx == 0:
                 y_max = y[1]
             elif self.process.ref_idx >= len(y):
@@ -454,10 +464,6 @@ class AlignFramesBase(SubAction):
 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)
@@ -473,8 +479,10 @@ class AlignFrames(AlignFramesBase):
                 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"
+            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()

{shinestacker-1.3.0 → shinestacker-1.3.1}/src/shinestacker/algorithms/align_auto.py RENAMED Viewed

@@ -1,23 +1,27 @@
 # pylint: disable=C0114, C0115, C0116, W0718, R0912, R0915, E1101, R0914, R0911, E0606, R0801, R0902
 import os
+import numpy as np
 from ..config.constants import constants
 from .align import AlignFramesBase, AlignFrames
 from .align_parallel import AlignFramesParallel
+from .utils import get_first_image_file, get_img_metadata, read_img
 class AlignFramesAuto(AlignFramesBase):
     def __init__(self, enabled=True, feature_config=None, matching_config=None,
                  alignment_config=None, **kwargs):
-        super().__init__(enabled=True, feature_config=None, matching_config=None,
-                         alignment_config=None, **kwargs)
         self.mode = kwargs.pop('mode', constants.DEFAULT_ALIGN_MODE)
+        self.memory_limit = kwargs.pop('memory_limit', constants.DEFAULT_ALIGN_MEMORY_LIMIT_GB)
         self.max_threads = kwargs.pop('max_threads', constants.DEFAULT_ALIGN_MAX_THREADS)
         self.chunk_submit = kwargs.pop('chunk_submit', constants.DEFAULT_ALIGN_CHUNK_SUBMIT)
         self.bw_matching = kwargs.pop('bw_matching', constants.DEFAULT_ALIGN_BW_MATCHING)
         self.kwargs = kwargs
+        super().__init__(enabled=True, feature_config=None, matching_config=None,
+                         alignment_config=None, **kwargs)
         available_cores = os.cpu_count() or 1
         self.num_threads = min(self.max_threads, available_cores)
         self._implementation = None
+        self.overhead = 30.0
     def begin(self, process):
         if self.mode == 'sequential' or self.num_threads == 1:
@@ -39,7 +43,15 @@ class AlignFramesAuto(AlignFramesBase):
                     descriptor = constants.DEFAULT_DESCRIPTOR
                 if detector in (constants.DETECTOR_SIFT, constants.DETECTOR_AKAZE) or \
                         descriptor in (constants.DESCRIPTOR_SIFT, constants.DESCRIPTOR_AKAZE):
-                    num_threads = min(3, self.num_threads)
+                    shape, dtype = get_img_metadata(
+                        read_img(get_first_image_file(process.input_filepaths())))
+                    bytes_per_pixel = 3 * np.dtype(dtype).itemsize
+                    img_memory = bytes_per_pixel * float(shape[0]) * float(shape[1]) * \
+                        self.overhead / constants.ONE_GIGA
+                    num_threads = max(
+                        1,
+                        int(round(self.memory_limit) / img_memory))
+                    num_threads = min(num_threads, self.num_threads)
                     chunk_submit = True
                 else:
                     num_threads = self.num_threads

{shinestacker-1.3.0 → shinestacker-1.3.1}/src/shinestacker/algorithms/align_parallel.py RENAMED Viewed

@@ -12,9 +12,11 @@ from ..config.constants import constants
 from .. core.exceptions import InvalidOptionError, RunStopException
 from .. core.colors import color_str
 from .. core.core_utils import make_chunks
-from .utils import read_img, img_subsample, img_bw
-from .align import (AlignFramesBase, detect_and_compute_matches, find_transform,
-                    check_transform, _cv2_border_mode_map, rescale_trasnsform)
+from .utils import read_img, img_subsample, img_bw, img_bw_8bit
+from .align import (AlignFramesBase, find_transform,
+                    check_transform, _cv2_border_mode_map, rescale_trasnsform,
+                    validate_align_config, detector_map, descriptor_map,
+                    get_good_matches)
 def compose_transforms(t1, t2, transform_type):
@@ -31,8 +33,8 @@ def compose_transforms(t1, t2, transform_type):
 class AlignFramesParallel(AlignFramesBase):
     def __init__(self, enabled=True, feature_config=None, matching_config=None,
                  alignment_config=None, **kwargs):
-        super().__init__(enabled=True, feature_config=None, matching_config=None,
-                         alignment_config=None, **kwargs)
+        super().__init__(enabled, feature_config, matching_config,
+                         alignment_config, **kwargs)
         self.max_threads = kwargs.get('max_threads', constants.DEFAULT_ALIGN_MAX_THREADS)
         self.chunk_submit = kwargs.get('chunk_submit', constants.DEFAULT_ALIGN_CHUNK_SUBMIT)
         self.bw_matching = kwargs.get('bw_matching', constants.DEFAULT_ALIGN_BW_MATCHING)
@@ -43,6 +45,8 @@ class AlignFramesParallel(AlignFramesBase):
         self._transforms = None
         self._cumulative_transforms = None
         self.step_counter = 0
+        self._kp = None
+        self._des = None
     def cache_img(self, idx):
         with self._cache_locks[idx]:
@@ -98,10 +102,14 @@ class AlignFramesParallel(AlignFramesBase):
     def begin(self, process):
         super().begin(process)
+        if self.plot_matches:
+            self.print_message(
+                "requested plot matches is not supported with parallel processing",
+                color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
         n_frames = self.process.num_input_filepaths()
+        self.print_message(f"preprocess {n_frames} images in parallel, cores: {self.max_threads}")
         self.process.callback(constants.CALLBACK_STEP_COUNTS,
                               self.process.id, self.process.name, 2 * n_frames)
-        self.print_message(f"preprocess {n_frames} images in parallel, cores: {self.max_threads}")
         input_filepaths = self.process.input_filepaths()
         self._img_cache = [None] * n_frames
         self._img_locks = [0] * n_frames
@@ -110,6 +118,8 @@ class AlignFramesParallel(AlignFramesBase):
         self._n_good_matches = [0] * n_frames
         self._transforms = [None] * n_frames
         self._cumulative_transforms = [None] * n_frames
+        self._kp = [None] * n_frames
+        self._des = [None] * n_frames
         max_chunck_size = self.max_threads
         ref_idx = self.process.ref_idx
         self.print_message(f"reference: {self.image_str(ref_idx)}")
@@ -125,9 +135,11 @@ class AlignFramesParallel(AlignFramesBase):
                 self.submit_threads(idxs, imgs)
         else:
             self.submit_threads(sub_indices, sub_img_filepaths)
-        for i in range(n_frames):
-            if self._img_cache[i] is not None:
-                self._img_cache[i] = None
+        for idx in range(n_frames):
+            if self._img_cache[idx] is not None:
+                self._img_cache[idx] = None
+                self._kp[idx] = None
+                self._des[idx] = None
         gc.collect()
         self.print_message("combining transformations")
         transform_type = self.alignment_config['transform']
@@ -152,6 +164,9 @@ class AlignFramesParallel(AlignFramesBase):
                 self.print_message(
                     f"warning: no cumulative transform for {self.image_str(i)}",
                     color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+        for idx in range(n_frames):
+            self._transforms[idx] = None
+        gc.collect()
         missing_transforms = 0
         for i in range(n_frames):
             if self._cumulative_transforms[i] is not None:
@@ -165,6 +180,32 @@ class AlignFramesParallel(AlignFramesBase):
         self.print_message(msg)
         self.process.add_begin_steps(n_frames)
+    def detect_and_compute_matches(self, img_ref, ref_idx, img_0, idx):
+        feature_config, matching_config = self.feature_config, self.matching_config
+        feature_config_detector = feature_config['detector']
+        feature_config_descriptor = feature_config['descriptor']
+        match_method = matching_config['match_method']
+        validate_align_config(feature_config_detector, feature_config_descriptor, match_method)
+        img_bw_0, img_bw_ref = img_bw_8bit(img_0), img_bw_8bit(img_ref)
+        detector = detector_map[feature_config_detector]()
+        if feature_config_detector == feature_config_descriptor and \
+           feature_config_detector in (constants.DETECTOR_SIFT,
+                                       constants.DETECTOR_AKAZE,
+                                       constants.DETECTOR_BRISK):
+            if self._kp[idx] is None or self._des[idx] is None:
+                kp_0, des_0 = detector.detectAndCompute(img_bw_0, None)
+            else:
+                kp_0, des_0 = self._kp[idx], self._des[idx]
+            if self._kp[ref_idx] is None or self._des[ref_idx] is None:
+                kp_ref, des_ref = detector.detectAndCompute(img_bw_ref, None)
+            else:
+                kp_ref, des_ref = self._kp[ref_idx], self._des[ref_idx]
+        else:
+            descriptor = descriptor_map[feature_config_descriptor]()
+            kp_0, des_0 = descriptor.compute(img_bw_0, detector.detect(img_bw_0, None))
+            kp_ref, des_ref = descriptor.compute(img_bw_ref, detector.detect(img_bw_ref, None))
+        return kp_0, kp_ref, get_good_matches(des_0, des_ref, matching_config)
     def extract_features(self, idx, delta=1):
         ref_idx = self.process.ref_idx
         pass_ref_err_msg = "cannot find path to reference frame"
@@ -202,8 +243,8 @@ class AlignFramesParallel(AlignFramesBase):
                 img_ref_sub = img_subsample(img_ref, subsample, fast_subsampling)
             else:
                 img_0_sub, img_ref_sub = img_0, img_ref
-            kp_0, kp_ref, good_matches = detect_and_compute_matches(
-                img_ref_sub, img_0_sub, self.feature_config, self.matching_config)
+            kp_0, kp_ref, good_matches = self.detect_and_compute_matches(
+                img_ref_sub, ref_idx, img_0_sub, idx)
             n_good_matches = len(good_matches)
             if n_good_matches > min_good_matches or subsample == 1:
                 break
@@ -217,8 +258,6 @@ class AlignFramesParallel(AlignFramesBase):
                 f"warning: only {n_good_matches} found for "
                 f"{self.image_str(idx)}, trying next frame",
                 color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
-            self._target_indices[idx] = None
-            self._transforms[idx] = None
             return self.extract_features(idx, delta + 1)
         transform = self.alignment_config['transform']
         src_pts = np.float32([kp_0[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
@@ -231,23 +270,24 @@ class AlignFramesParallel(AlignFramesBase):
         if subsample > 1:
             m = rescale_trasnsform(m, w0, h0, w_sub, h_sub, subsample, transform)
             if m is None:
-                warning_messages.append(f"invalid option {transform}")
-                self._target_indices[idx] = None
-                self._transforms[idx] = None
-                return info_messages, warning_messages
+                self.print_message(
+                    f"invalid option {transform} "
+                    f"for {self.image_str(idx)}, trying next frame",
+                    color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+                return self.extract_features(idx, delta + 1)
         transform_type = self.alignment_config['transform']
         thresholds = self.get_transform_thresholds()
-        is_valid, reason = check_transform(m, img_0, transform_type, *thresholds)
+        is_valid, _reason, _result = check_transform(m, img_0, transform_type, *thresholds)
         if not is_valid:
+            msg = f"invalid transformation for {self.image_str(idx)}"
+            do_abort = self.alignment_config['abort_abnormal']
+            if not do_abort:
+                msg += ", trying next frame"
             self.print_message(
-                f"warning: invalid transformation for {self.image_str(idx)}: {reason}",
-                level=logging.WARNING)
-            if self.alignment_config['abort_abnormal']:
+                msg, color=constants.LOG_COLOR_WARNING, level=logging.WARNING)
+            if do_abort:
                 raise RuntimeError("invalid transformation: {reason}")
-            warning_messages.append(f"invalid transformation found: {reason}")
-            self._target_indices[idx] = None
-            self._transforms[idx] = None
-            return info_messages, warning_messages
+            return self.extract_features(idx, delta + 1)
         self._transforms[idx] = m
         self._target_indices[idx] = target_idx
         return info_messages, warning_messages

{shinestacker-1.3.0 → shinestacker-1.3.1}/src/shinestacker/algorithms/base_stack_algo.py RENAMED Viewed

@@ -1,10 +1,10 @@
-# pylint: disable=C0114, C0115, C0116, E0602, R0903
+# pylint: disable=C0114, C0115, C0116, E0602, R0903, R0902
 import os
 import numpy as np
-from .. core.exceptions import InvalidOptionError, ImageLoadError, RunStopException
+from .. core.exceptions import InvalidOptionError, RunStopException
 from .. config.constants import constants
 from .. core.colors import color_str
-from .utils import read_img, get_img_metadata, validate_image, get_img_file_shape, extension_tif_jpg
+from .utils import read_img, get_img_metadata, get_first_image_file
 class BaseStackAlgo:
@@ -14,6 +14,9 @@ class BaseStackAlgo:
         self.process = None
         self.filenames = None
         self.shape = None
+        self.dtype = None
+        self.num_pixel_values = None
+        self.max_pixel_value = None
         self.do_step_callback = False
         if float_type == constants.FLOAT_32:
             self.float_type = np.float32
@@ -41,14 +44,16 @@ class BaseStackAlgo:
         return f"image: {self.idx_tot_str(idx)}, " \
                f"{os.path.basename(self.filenames[idx])}"
+    def num_images(self):
+        return len(self.filenames)
     def init(self, filenames):
         self.filenames = filenames
-        first_img_file = ''
-        for filename in filenames:
-            if os.path.isfile(filename) and extension_tif_jpg(filename):
-                first_img_file = filename
-                break
-        self.shape = get_img_file_shape(first_img_file)
+        self.shape, self.dtype = get_img_metadata(read_img(get_first_image_file(filenames)))
+        self.num_pixel_values = constants.NUM_UINT8 \
+            if self.dtype == np.uint8 else constants.NUM_UINT16
+        self.max_pixel_value = constants.MAX_UINT8 \
+            if self.dtype == np.uint8 else constants.MAX_UINT16
     def total_steps(self, n_frames):
         return self._steps_per_frame * n_frames
@@ -56,17 +61,6 @@ class BaseStackAlgo:
     def print_message(self, msg):
         self.process.sub_message_r(color_str(msg, constants.LOG_COLOR_LEVEL_3))
-    def read_image_and_update_metadata(self, img_path, metadata):
-        img = read_img(img_path)
-        if img is None:
-            raise ImageLoadError(img_path)
-        updated = metadata is None
-        if updated:
-            metadata = get_img_metadata(img)
-        else:
-            validate_image(img, *metadata)
-        return img, metadata, updated
     def check_running(self, cleanup_callback=None):
         if self.process.callback(constants.CALLBACK_CHECK_RUNNING,
                                  self.process.id, self.process.name) is False:

{shinestacker-1.3.0 → shinestacker-1.3.1}/src/shinestacker/algorithms/depth_map.py RENAMED Viewed

@@ -3,7 +3,7 @@ import numpy as np
 import cv2
 from .. config.constants import constants
 from .. core.exceptions import InvalidOptionError
-from .utils import read_img, img_bw
+from .utils import read_img, read_and_validate_img, img_bw
 from .base_stack_algo import BaseStackAlgo
@@ -62,19 +62,15 @@ class DepthMapStack(BaseStackAlgo):
                                  f"{constants.DM_MAP_AVERAGE} and {constants.DM_MAP_MAX}.")
     def focus_stack(self):
-        gray_images = []
-        metadata = None
+        n_images = len(self.filenames)
+        gray_images = np.empty((n_images, *self.shape), dtype=self.float_type)
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": reading file (1/2) {img_path.split('/')[-1]}")
-            img, metadata, _updated = self.read_image_and_update_metadata(img_path, metadata)
+            self.print_message(f": reading and validating {self.image_str(i)}")
+            img = read_and_validate_img(img_path, self.shape, self.dtype)
             gray = img_bw(img)
-            gray_images.append(gray)
+            gray_images[i] = gray.astype(self.float_type)
             self.after_step(i)
             self.check_running()
-        dtype = metadata[1]
-        gray_images = np.array(gray_images, dtype=self.float_type)
         if self.energy == constants.DM_ENERGY_SOBEL:
             energies = self.get_sobel_map(gray_images)
         elif self.energy == constants.DM_ENERGY_LAPLACIAN:
@@ -92,7 +88,7 @@ class DepthMapStack(BaseStackAlgo):
         weights = self.get_focus_map(energies)
         blended_pyramid = None
         for i, img_path in enumerate(self.filenames):
-            self.print_message(f": reading file (2/2) {img_path.split('/')[-1]}")
+            self.print_message(f": reading {self.image_str(i)}")
             img = read_img(img_path).astype(self.float_type)
             weight = weights[i]
             gp_img = [img]
@@ -109,12 +105,11 @@ class DepthMapStack(BaseStackAlgo):
                              for j in range(self.levels)]
             blended_pyramid = current_blend if blended_pyramid is None \
                 else [np.add(bp, cb) for bp, cb in zip(blended_pyramid, current_blend)]
-            self.after_step(i + len(self.filenames))
+            self.after_step(i + n_images)
             self.check_running()
         result = blended_pyramid[0]
         self.print_message(': blend levels')
         for j in range(1, self.levels):
             size = (blended_pyramid[j].shape[1], blended_pyramid[j].shape[0])
             result = cv2.pyrUp(result, dstsize=size) + blended_pyramid[j]
-        n_values = constants.MAX_UINT8 if dtype == np.uint8 else constants.MAX_UINT16
-        return np.clip(np.absolute(result), 0, n_values).astype(dtype)
+        return np.clip(np.absolute(result), 0, self.num_pixel_values).astype(self.dtype)

shinestacker 1.3.0__tar.gz → 1.3.1__tar.gz

Potentially problematic release.

shinestacker 1.3.0tar.gz → 1.3.1tar.gz