shinestacker 1.0.4.post2__py3-none-any.whl → 1.2.0__py3-none-any.whl

shinestacker/_version.py

@@ -1 +1 @@
-__version__ = '1.0.4.post2'
+__version__ = '1.2.0'

shinestacker/algorithms/__init__.py

@@ -8,6 +8,8 @@ from .balance import BalanceFrames
 from .stack import FocusStackBunch, FocusStack
 from .depth_map import DepthMapStack
 from .pyramid import PyramidStack
+from .pyramid_tiles import PyramidTilesStack
+from .pyramid_auto import PyramidAutoStack
 from .multilayer import MultiLayer
 from .noise_detection import NoiseDetection, MaskNoise
 from .vignetting import Vignetting
@@ -16,5 +18,6 @@ logger.addHandler(logging.NullHandler())
 
 __all__ = [
 	'StackJob', 'CombinedActions', 'AlignFrames', 'BalanceFrames', 'FocusStackBunch', 'FocusStack',
-	'DepthMapStack', 'PyramidStack', 'MultiLayer', 'NoiseDetection', 'MaskNoise', 'Vignetting'
+	'DepthMapStack', 'PyramidStack', 'PyramidTilesStack', 'PyramidAutoStack', 'MultiLayer',
+	'NoiseDetection', 'MaskNoise', 'Vignetting'
 ]

shinestacker/algorithms/align.py

@@ -1,12 +1,13 @@
-# pylint: disable=C0114, C0115, C0116, E1101, R0914, R0913, R0917, R0912, R0915, R0902
+# pylint: disable=C0114, C0115, C0116, E1101, R0914, R0913, R0917, R0912, R0915, R0902, E1121, W0102
 import logging
+import math
 import numpy as np
 import matplotlib.pyplot as plt
 import cv2
 from .. config.constants import constants
 from .. core.exceptions import AlignmentError, InvalidOptionError
 from .. core.colors import color_str
-from .utils import img_8bit, img_bw_8bit, save_plot, get_img_metadata, validate_image, img_subsample
+from .utils import img_8bit, img_bw_8bit, save_plot, img_subsample
 from .stack_framework import SubAction
 
 _DEFAULT_FEATURE_CONFIG = {
@@ -29,6 +30,7 @@ _DEFAULT_ALIGNMENT_CONFIG = {
     'refine_iters': constants.DEFAULT_REFINE_ITERS,
     'align_confidence': constants.DEFAULT_ALIGN_CONFIDENCE,
     'max_iters': constants.DEFAULT_ALIGN_MAX_ITERS,
+    'abort_abnormal': constants.DEFAULT_ALIGN_ABORT_ABNORMAL,
     'border_mode': constants.DEFAULT_BORDER_MODE,
     'border_value': constants.DEFAULT_BORDER_VALUE,
     'border_blur': constants.DEFAULT_BORDER_BLUR,
@@ -44,6 +46,89 @@ _cv2_border_mode_map = {
     constants.BORDER_REPLICATE_BLUR: cv2.BORDER_REPLICATE
 }
 
+_AFFINE_THRESHOLDS = {
+    'max_rotation': 10.0,  # degrees
+    'min_scale': 0.9,
+    'max_scale': 1.1,
+    'max_shear': 5.0,  # degrees
+    'max_translation_ratio': 0.1,  # 10% of image dimension
+}
+
+_HOMOGRAPHY_THRESHOLDS = {
+    'max_skew': 10.0,  # degrees
+    'max_scale_change': 1.5,  # max area change ratio
+    'max_aspect_ratio': 2.0,  # max aspect ratio change
+}
+
+
+def decompose_affine_matrix(m):
+    a, b, tx = m[0, 0], m[0, 1], m[0, 2]
+    c, d, ty = m[1, 0], m[1, 1], m[1, 2]
+    scale_x = math.sqrt(a**2 + b**2)
+    scale_y = math.sqrt(c**2 + d**2)
+    rotation = math.degrees(math.atan2(b, a))
+    shear = math.degrees(math.atan2(-c, d)) - rotation
+    shear = (shear + 180) % 360 - 180
+    return (scale_x, scale_y), rotation, shear, (tx, ty)
+
+
+def check_affine_matrix(m, img_shape, affine_thresholds=_AFFINE_THRESHOLDS):
+    if affine_thresholds is None:
+        return True, "No thresholds provided"
+    (scale_x, scale_y), rotation, shear, (tx, ty) = decompose_affine_matrix(m)
+    h, w = img_shape[:2]
+    reasons = []
+    if abs(rotation) > affine_thresholds['max_rotation']:
+        reasons.append(f"rotation too large ({rotation:.1f}°)")
+    if scale_x < affine_thresholds['min_scale'] or scale_x > affine_thresholds['max_scale']:
+        reasons.append(f"x-scale out of range ({scale_x:.2f})")
+    if scale_y < affine_thresholds['min_scale'] or scale_y > affine_thresholds['max_scale']:
+        reasons.append(f"y-scale out of range ({scale_y:.2f})")
+    if abs(shear) > affine_thresholds['max_shear']:
+        reasons.append(f"shear too large ({shear:.1f}°)")
+    max_tx = w * affine_thresholds['max_translation_ratio']
+    max_ty = h * affine_thresholds['max_translation_ratio']
+    if abs(tx) > max_tx:
+        reasons.append(f"x-translation too large (|{tx:.1f}| > {max_tx:.1f})")
+    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"
+
+
+def check_homography_distortion(m, img_shape, homography_thresholds=_HOMOGRAPHY_THRESHOLDS):
+    if homography_thresholds is None:
+        return True, "No thresholds provided"
+    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)
+    reasons = []
+    area_orig = w * h
+    area_new = cv2.contourArea(transformed)
+    area_ratio = area_new / area_orig
+    if area_ratio > homography_thresholds['max_scale_change'] or \
+       area_ratio < 1.0 / homography_thresholds['max_scale_change']:
+        reasons.append(f"area change too large ({area_ratio:.2f})")
+    rect = cv2.minAreaRect(transformed.astype(np.float32))
+    (w_rect, h_rect) = rect[1]
+    aspect_ratio = max(w_rect, h_rect) / min(w_rect, h_rect)
+    if aspect_ratio > homography_thresholds['max_aspect_ratio']:
+        reasons.append(f"aspect ratio change too large ({aspect_ratio:.2f})")
+    angles = []
+    for i in range(4):
+        vec1 = transformed[(i + 1) % 4] - transformed[i]
+        vec2 = transformed[(i - 1) % 4] - transformed[i]
+        angle = np.degrees(np.arccos(np.dot(vec1, vec2) /
+                           (np.linalg.norm(vec1) * np.linalg.norm(vec2))))
+        angles.append(angle)
+    max_angle_dev = max(abs(angle - 90) for angle in angles)
+    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"
+
 
 def get_good_matches(des_0, des_1, matching_config=None):
     matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
@@ -152,7 +237,9 @@ def find_transform(src_pts, dst_pts, transform=constants.DEFAULT_TRANSFORM,
 
 
 def align_images(img_1, img_0, feature_config=None, matching_config=None, alignment_config=None,
-                 plot_path=None, callbacks=None):
+                 plot_path=None, callbacks=None,
+                 affine_thresholds=_AFFINE_THRESHOLDS,
+                 homography_thresholds=_HOMOGRAPHY_THRESHOLDS):
     feature_config = {**_DEFAULT_FEATURE_CONFIG, **(feature_config or {})}
     matching_config = {**_DEFAULT_MATCHING_CONFIG, **(matching_config or {})}
     alignment_config = {**_DEFAULT_ALIGNMENT_CONFIG, **(alignment_config or {})}
@@ -161,10 +248,15 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
     except KeyError as e:
         raise InvalidOptionError("border_mode", alignment_config['border_mode']) from e
     min_matches = 4 if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY else 3
-    validate_image(img_0, *get_img_metadata(img_1))
     if callbacks and 'message' in callbacks:
         callbacks['message']()
+    h_ref, w_ref = img_1.shape[:2]
+    h0, w0 = img_0.shape[:2]
     subsample = alignment_config['subsample']
+    if subsample == 0:
+        img_res = (float(h0) / 1000) * (float(w0) / 1000)
+        target_res = constants.DEFAULT_ALIGN_RES_TARGET_MPX
+        subsample = int(1 + math.floor(img_res / target_res))
     fast_subsampling = alignment_config['fast_subsampling']
     min_good_matches = alignment_config['min_good_matches']
     while True:
@@ -204,15 +296,14 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
                 flags=2), cv2.COLOR_BGR2RGB)
             plt.figure(figsize=(10, 5))
             plt.imshow(img_match, 'gray')
-            plt.savefig(plot_path)
+            save_plot(plot_path)
             if callbacks and 'save_plot' in callbacks:
                 callbacks['save_plot'](plot_path)
-        h, w = img_0.shape[:2]
         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, h], [w, h], [w, 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
@@ -225,22 +316,37 @@ def align_images(img_1, img_0, feature_config=None, matching_config=None, alignm
                 m[:, 2] = translation_fullres
             else:
                 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)
+        if not is_valid:
+            if callbacks and 'warning' in callbacks:
+                callbacks['warning'](f"invalid transformation: {reason}")
+            return n_good_matches, None, None
+
         if callbacks and 'align_message' in callbacks:
             callbacks['align_message']()
         img_mask = np.ones_like(img_0, dtype=np.uint8)
         if alignment_config['transform'] == constants.ALIGN_HOMOGRAPHY:
             img_warp = cv2.warpPerspective(
-                img_0, m, (w, h),
+                img_0, m, (w_ref, h_ref),
                 borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
             if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-                mask = cv2.warpPerspective(img_mask, m, (w, h),
+                mask = cv2.warpPerspective(img_mask, m, (w_ref, h_ref),
                                            borderMode=cv2.BORDER_CONSTANT, borderValue=0)
         elif alignment_config['transform'] == constants.ALIGN_RIGID:
             img_warp = cv2.warpAffine(
-                img_0, m, (w, h),
+                img_0, m, (w_ref, h_ref),
                 borderMode=cv2_border_mode, borderValue=alignment_config['border_value'])
             if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
-                mask = cv2.warpAffine(img_mask, m, (w, h),
+                mask = cv2.warpAffine(img_mask, m, (w_ref, h_ref),
                                       borderMode=cv2.BORDER_CONSTANT, borderValue=0)
         if alignment_config['border_mode'] == constants.BORDER_REPLICATE_BLUR:
             if callbacks and 'blur_message' in callbacks:
@@ -293,7 +399,7 @@ class AlignFrames(SubAction):
             '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_ALERT),
+                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)
@@ -303,19 +409,27 @@ class AlignFrames(SubAction):
                 f"{self.process.name}-matches-{idx_str}.pdf"
         else:
             plot_path = None
+        if self.alignment_config['abort_abnormal']:
+            affine_thresholds = _AFFINE_THRESHOLDS
+            homography_thresholds = _HOMOGRAPHY_THRESHOLDS
+        else:
+            affine_thresholds = None
+            homography_thresholds = None
         n_good_matches, _m, img = align_images(
             img_1, img_0,
             feature_config=self.feature_config,
             matching_config=self.matching_config,
             alignment_config=self.alignment_config,
             plot_path=plot_path,
-            callbacks=callbacks
+            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(f": image not aligned, too few matches found: "
                                      f"{n_good_matches}", level=logging.CRITICAL)
-            raise AlignmentError(idx, f"too few matches found: "
+            raise AlignmentError(idx, f"Image not aligned, too few matches found: "
                                  f"{n_good_matches} < {self.min_matches}")
         return img