dkist-processing-math 2.2.3__tar.gz → 3.0.0rc1__tar.gz

{dkist_processing_math-2.2.3 → dkist_processing_math-3.0.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-math
-Version: 2.2.3
+Version: 3.0.0rc1
 Summary: Common math functionality used in the DKIST calibrations suite
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause

dkist_processing_math-3.0.0rc1/changelog/27.feature.rst

@@ -0,0 +1 @@
+Add ``apply_affine_transform`` which applies a combined center-preserving rotation and shift to an iterable of 2D arrays in a single interpolation pass. The rotation is specified as a scalar ``angle`` in radians. Also add ``affine_inverse_transform_matrix`` for callers that need the underlying homogeneous-coordinates matrix directly.

dkist_processing_math-3.0.0rc1/changelog/27.removal.rst

@@ -0,0 +1 @@
+Remove ``affine_transform_arrays``, ``translate_arrays``, ``rotate_arrays_about_point``, ``scale_matrix``, ``rotation_matrix``, ``shear_matrix``, and ``translation_matrix`` from ``dkist_processing_math.transform``. These were superseded by ``apply_affine_transform`` (and, for callers that need the raw matrix, ``affine_inverse_transform_matrix``).

dkist_processing_math-3.0.0rc1/dkist_processing_math/tests/test_transform.py

@@ -0,0 +1,452 @@
+import numpy as np
+import pytest
+from skimage import transform as transform
+
+from dkist_processing_math.transform import affine_inverse_transform_matrix
+from dkist_processing_math.transform import apply_affine_transform
+from dkist_processing_math.transform import bin_arrays
+from dkist_processing_math.transform import do_hough
+from dkist_processing_math.transform import make_binary
+from dkist_processing_math.transform.binning import resize_arrays
+from dkist_processing_math.transform.binning import resize_arrays_local_mean
+
+
+@pytest.fixture()
+def binned_arrays(numpy_arrays):
+    """
+    Create a list of binned arrays from numpy_arrays
+
+    Parameters
+    ----------
+    numpy_arrays: List[np.ndarray]
+        A list of arrays to be binned
+
+    Returns
+    -------
+    List[np.ndarray]
+        A list of 2x2 binned versions of the input arrays
+
+    """
+
+    temp_arrays = np.zeros((2, 2, 2), dtype=numpy_arrays[0].dtype)
+    for array, temp_array in zip(numpy_arrays, temp_arrays):
+        for row in range(temp_array.shape[1]):
+            for column in range(temp_array.shape[0]):
+                temp_array[column, row] = array[
+                    column * 5 : (column + 1) * 5, row * 5 : (row + 1) * 5
+                ].mean()
+    return temp_arrays
+
+
+@pytest.fixture()
+def binned_array(numpy_array, binned_arrays):
+    """
+    Create a binned array from numpy_array
+
+    Parameters
+    ----------
+    numpy_array: np.ndarray
+        The array to be binned
+
+    Returns
+    -------
+    np.ndarray
+        A 2x2 binned version of the input array
+
+    """
+    return binned_arrays[0]
+
+
+@pytest.fixture()
+def resized_arrays(numpy_arrays):
+    temp_arrays = np.zeros((2, 20, 100), dtype=numpy_arrays[0].dtype)
+    for array, temp_array in zip(numpy_arrays, temp_arrays):
+        temp_array[:, :] = transform.resize_local_mean(array, (20, 100), preserve_range=True)
+    return temp_arrays
+
+
+@pytest.fixture()
+def resized_array(resized_arrays):
+    return resized_arrays[0]
+
+
+def test_bin_arrays(numpy_arrays, binned_arrays):
+    """
+    Given: an iterable of numpy_arrays
+    When: binning an iterable of numpy_arrays
+    Then: an Iterator of binned versions of the input arrays is returned
+    """
+    results = bin_arrays(numpy_arrays, (5, 5))
+    for result, binned_array in zip(results, binned_arrays):
+        np.testing.assert_allclose(result, binned_array)
+
+
+def test_bin_arrays_single_array(numpy_array, binned_array):
+    """
+    Given: an single numpy_array
+    When: binning an iterable of numpy_arrays
+    Then: an Iterator containing the binned version of the input arrays is returned
+    """
+    result = next(bin_arrays(numpy_array, (5, 5)))
+    np.testing.assert_allclose(result, binned_array)
+
+
+def test_bin_arrays_bad_bin_factor(numpy_array):
+    """
+    Given: a single numpy array
+    When: binning an array using a bad binning factor
+    Then: an error is raised
+    """
+    with pytest.raises(ValueError):
+        next(bin_arrays(numpy_array, (3, 3)))
+
+
+def test_resize_arrays(numpy_arrays, resized_arrays):
+    """
+    Given: an iterable of numpy_arrays
+    When: resizing an iterable of numpy_arrays
+    Then: an Iterator of resized versions of the input arrays is returned
+    """
+    results = resize_arrays(numpy_arrays, (20, 100))
+    for result, resized_array in zip(results, resized_arrays):
+        np.testing.assert_allclose(result, resized_array)
+
+
+def test_resize_arrays_single_array(numpy_array, resized_array):
+    """
+    Given: a single numpy array
+    When: resizing that array
+    Then: an Iterator of resized versions of the input arrays is returned
+    """
+    result = next(resize_arrays(numpy_array, (20, 100)))
+    np.testing.assert_allclose(result, resized_array)
+
+
+def test_resize_arrays_local_mean(numpy_arrays, resized_arrays):
+    """
+    Given: an iterable of numpy_arrays
+    When: resizing an iterable of numpy_arrays
+    Then: an Iterator of resized versions of the input arrays is returned
+    """
+    results = resize_arrays_local_mean(numpy_arrays, (20, 100))
+    for result, resized_array in zip(results, resized_arrays):
+        np.testing.assert_allclose(result, resized_array)
+
+
+def test_resize_arrays_local_mean_single_array(numpy_array, resized_array):
+    """
+    Given: a single numpy array
+    When: resizing that array
+    Then: an Iterator of resized versions of the input arrays is returned
+    """
+    result = next(resize_arrays_local_mean(numpy_array, (20, 100)))
+    np.testing.assert_allclose(result, resized_array)
+
+
+@pytest.mark.parametrize(
+    "array_shape, shift, angle, order, expected_matrix",
+    [
+        pytest.param(
+            (100, 100),
+            np.array([0.0, 0.0]),
+            0.0,
+            "shift_then_rotate",
+            np.eye(3),
+            id="identity",
+        ),
+        pytest.param(
+            (100, 200),
+            np.array([0.0, 0.0]),
+            np.pi,
+            "shift_then_rotate",
+            np.array([[-1.0, 0.0, 99.0], [0.0, -1.0, 199.0], [0.0, 0.0, 1.0]]),
+            id="180_rotation_about_center",
+        ),
+        pytest.param(
+            (100, 100),
+            np.array([5.0, -3.0]),
+            0.0,
+            "shift_then_rotate",
+            np.array([[1.0, 0.0, -5.0], [0.0, 1.0, 3.0], [0.0, 0.0, 1.0]]),
+            id="pure_translation",
+        ),
+        pytest.param(
+            (100, 100),
+            np.array([0.0, 0.0]),
+            np.pi / 2,
+            "shift_then_rotate",
+            np.array([[0.0, 1.0, 0.0], [-1.0, 0.0, 99.0], [0.0, 0.0, 1.0]]),
+            id="90_deg_rotation",
+        ),
+    ],
+)
+def test_affine_inverse_transform_matrix_hand_derived(
+    array_shape, shift, angle, order, expected_matrix
+):
+    """
+    Given: 2D array shape / shift / angle / order combinations with easy-to-derive-by-hand expected matrices
+    When: building the homogeneous inverse transform matrix
+    Then: the result matches the hand-derived expectation
+    """
+    result = affine_inverse_transform_matrix(array_shape, shift, angle, order=order)
+    np.testing.assert_allclose(result, expected_matrix, atol=1e-10)
+
+
+def test_affine_inverse_transform_matrix_rejects_invalid_order():
+    """
+    Given: an `order` value that isn't one of the two recognized options
+    When: building the homogeneous inverse transform matrix
+    Then: a ValueError is raised, rather than silently falling back to some default behavior
+    """
+    with pytest.raises(ValueError, match="order must be"):
+        affine_inverse_transform_matrix(
+            (10, 10), np.array([0.0, 0.0]), 0.0, order="not_a_real_order"
+        )
+
+
+def test_affine_inverse_transform_matrix_requires_2d():
+    """
+    Given: an array_shape with more than 2 dimensions
+    When: building the homogeneous inverse transform matrix
+    Then: a ValueError is raised
+    """
+    with pytest.raises(ValueError, match="array_shape must be 2D"):
+        affine_inverse_transform_matrix((10, 10, 10), np.zeros(3), 0.3, order="shift_then_rotate")
+
+
+@pytest.mark.parametrize(
+    "shift",
+    [
+        pytest.param(5.0, id="scalar_shift"),
+        pytest.param(np.array([5.0]), id="length_one_shift"),
+        pytest.param(np.array([1.0, 2.0, 3.0]), id="wrong_length_shift"),
+    ],
+)
+def test_affine_inverse_transform_matrix_rejects_mismatched_shift(shift):
+    """
+    Given: a `shift` whose shape doesn't match `array_shape`'s dimensionality -- including scalar
+        and length-1 shifts, which would otherwise silently broadcast rather than raising
+    When: building the homogeneous inverse transform matrix for a 2D array_shape
+    Then: a ValueError is raised
+    """
+    with pytest.raises(ValueError, match="shift must have shape"):
+        affine_inverse_transform_matrix((10, 10), shift, 0.0, order="shift_then_rotate")
+
+
+def test_apply_affine_transform_identity():
+    """
+    Given: a zero shift and zero rotation
+    When: applying the correction
+    Then: the output array is numerically identical to the input
+    """
+    array = np.arange(100.0).reshape(10, 10)
+    result = next(
+        apply_affine_transform(array, np.array([0.0, 0.0]), 0.0, order="shift_then_rotate")
+    )
+    np.testing.assert_allclose(result, array, atol=1e-10)
+
+
+def test_apply_affine_transform_single_array_wrapped():
+    """
+    Given: a single ndarray (not wrapped in a list)
+    When: applying the correction
+    Then: it is accepted and the generator yields exactly one result
+    """
+    array = np.zeros((5, 5))
+    results = list(
+        apply_affine_transform(array, np.array([0.0, 0.0]), 0.0, order="shift_then_rotate")
+    )
+    assert len(results) == 1
+    assert results[0].shape == (5, 5)
+
+
+def test_apply_affine_transform_nonfinite_values_replaced():
+    """
+    Given: an input array containing NaN and ±inf
+    When: applying the correction
+    Then: the output is fully finite (NaN/inf do not survive interpolation)
+    """
+    array = np.ones((10, 10))
+    array[0, 0] = np.nan
+    array[0, 1] = np.inf
+    array[0, 2] = -np.inf
+    result = next(
+        apply_affine_transform(array, np.array([0.0, 0.0]), 0.0, order="shift_then_rotate")
+    )
+    assert np.isfinite(result).all()
+
+
+def test_apply_affine_transform_hand_derived_shift():
+    """
+    Given: a distinctive single-pixel array and a pure integer shift (no rotation)
+    When: applying the correction with shift_then_rotate
+    Then: the bright pixel lands exactly where hand-derived arithmetic says it should
+
+    With shift=[2, 3] and no rotation, a pixel at (row=1, col=1) moves to (row=3, col=4).
+    This directly tests that the sign convention is correct end-to-end -- that a positive
+    shift moves content in the positive direction -- with no ambiguity from interpolation.
+    """
+    array = np.zeros((10, 10))
+    array[1, 1] = 1.0
+    shift = np.array([2.0, 3.0])
+
+    result = next(apply_affine_transform(array, shift, 0.0, order="shift_then_rotate"))
+
+    assert result[3, 4] == pytest.approx(1.0)
+
+
+def test_apply_affine_transform_yields_one_per_input():
+    """
+    Given: a list of N arrays
+    When: applying the correction
+    Then: the generator yields exactly N arrays, each with the correct shape
+    """
+    arrays = [np.ones((8, 8)) * i for i in range(3)]
+    results = list(
+        apply_affine_transform(arrays, np.array([0.0, 0.0]), 0.0, order="shift_then_rotate")
+    )
+    assert len(results) == 3
+    assert all(r.shape == (8, 8) for r in results)
+
+
+def test_apply_affine_transform_hand_derived_rotation():
+    """
+    Given: a distinctive single-pixel array and a 90° CCW rotation (no shift)
+    When: applying the transform with shift_then_rotate
+    Then: the bright pixel lands exactly where hand-derived arithmetic says it should
+
+    With angle=π/2 and no shift, a pixel at (row=1, col=7) in a 10×10 array (center=(4.5, 4.5))
+    rotates CCW to (row=2, col=1). Derivation: the pull-back maps output (r', c') to input
+    (c', 9−r'), so output[2, 1] samples input[1, 7].
+    """
+    array = np.zeros((10, 10))
+    array[1, 7] = 1.0
+
+    result = next(
+        apply_affine_transform(array, np.array([0.0, 0.0]), np.pi / 2, order="shift_then_rotate")
+    )
+
+    assert result[2, 1] == pytest.approx(1.0)
+
+
+def test_apply_affine_transform_hand_derived_shift_and_rotate():
+    """
+    Given: a distinctive single-pixel array, a shift of [1, 0], and a 90° CCW rotation
+    When: applying shift_then_rotate
+    Then: the bright pixel lands exactly where hand-derived arithmetic says it should
+
+    Shift [1, 0] moves (1, 7) → (2, 7); 90° CCW about center (4.5, 4.5) then moves
+    (2, 7) → (2, 2). The pull-back for output (2, 2): after un-centering, applying CW
+    rotation, re-centering, and un-shifting gives input (1, 7).
+    """
+    array = np.zeros((10, 10))
+    array[1, 7] = 1.0
+
+    result = next(
+        apply_affine_transform(array, np.array([1.0, 0.0]), np.pi / 2, order="shift_then_rotate")
+    )
+
+    assert result[2, 2] == pytest.approx(1.0)
+
+
+def test_affine_inverse_transform_matrix_matches_numpy_inverse():
+    """
+    Given: a known shift and rotation angle
+    When: computing the inverse transform matrix
+    Then: the result matches np.linalg.inv of the hand-composed forward matrix
+
+    This verifies the matrix algebra is correct end-to-end, independently of any
+    hand-derived expected values.
+    """
+    shape = (11, 21)
+    shift = np.array([3.0, -5.0])
+    angle = np.pi / 4
+
+    cx, cy = (shape[0] - 1) / 2.0, (shape[1] - 1) / 2.0  # 5.0, 10.0
+    cos_a, sin_a = np.cos(angle), np.sin(angle)
+
+    # Hand-composed forward matrix for shift_then_rotate:
+    # T(center) @ R_fwd @ T(-center) @ T(shift)
+    R_fwd = np.array([[cos_a, -sin_a, 0.0], [sin_a, cos_a, 0.0], [0.0, 0.0, 1.0]])
+    T_cen = np.array([[1.0, 0.0, cx], [0.0, 1.0, cy], [0.0, 0.0, 1.0]])
+    T_neg_cen = np.array([[1.0, 0.0, -cx], [0.0, 1.0, -cy], [0.0, 0.0, 1.0]])
+    T_s = np.array([[1.0, 0.0, shift[0]], [0.0, 1.0, shift[1]], [0.0, 0.0, 1.0]])
+    forward = T_cen @ R_fwd @ T_neg_cen @ T_s
+
+    result = affine_inverse_transform_matrix(shape, shift, angle, order="shift_then_rotate")
+    np.testing.assert_allclose(result, np.linalg.inv(forward), atol=1e-10)
+
+
+def test_make_binary_image():
+    """
+    Given: a single numpy array
+    When: generating a binary image for values in the array below a threshold
+    Then: a correct binary array results from the generation
+    """
+    input_array = np.ones((10, 10), dtype=float)
+    input_array[:5, :] += 1.0
+    result = make_binary(input_array)  # Something ridiculous
+    assert isinstance(result, np.ndarray)
+
+    expected = np.ones((10, 10), dtype=int)
+    expected[:5, :] = 0
+    np.testing.assert_equal(result, expected)
+
+
+def test_make_binary_trigger_cutoff():
+    """
+    Given: a single numpy array
+    When: calling make_binary in such a way that the result will converge to all 0s or all 1s
+    Then: make_binary returns before a single value array is created
+    """
+    rng = np.random.default_rng()
+    input_array = rng.standard_normal((100, 100))
+    result = make_binary(input_array, numotsu=100)
+    frac = np.sum(result) / result.size
+    assert frac >= 1e-3
+
+
+def test_do_hough(numpy_array):
+    """
+    Given: a single numpy array
+    When: performing a hough line transformation
+    Then: return the correct hough space, array of angle values, and array of distance values
+    """
+    binary = make_binary(numpy_array)
+
+    # Rho and Theta ranges
+    thetas = np.linspace(-np.pi / 4, np.pi / 4, 1500)
+    width, height = binary.shape
+    diag_len = np.ceil(np.sqrt(width * width + height * height))  # max_dist
+    diag_len = int(diag_len)
+    num_rhos = 2 * diag_len + 1
+    rhos = np.linspace(-diag_len, diag_len, num_rhos)
+    # Cache some reusable values
+    cos_t = np.cos(thetas)
+    sin_t = np.sin(thetas)
+    num_thetas = len(thetas)
+    # Hough accumulator array of theta vs rho
+    accumulator = np.zeros((num_rhos, num_thetas), dtype=np.uint64)
+    y_idxs, x_idxs = np.nonzero(binary)  # (row, col) indexes to edges
+    for i in range(len(x_idxs)):
+        x = x_idxs[i]
+        y = y_idxs[i]
+        for t_idx in range(num_thetas):
+            # Calculate rho. diag_len is added for a positive index
+            rho = round(x * cos_t[t_idx] + y * sin_t[t_idx]) + diag_len
+            accumulator[rho, t_idx] += 1
+    desired_H = accumulator
+    desired_thetas = thetas
+    desired_rhos = rhos
+    assert isinstance(desired_H, np.ndarray)
+    assert isinstance(desired_thetas, np.ndarray)
+    assert isinstance(desired_rhos, np.ndarray)
+
+    result_H, result_theta, result_rho = do_hough(binary, theta_min=-np.pi / 4, theta_max=np.pi / 4)
+    assert isinstance(result_H, np.ndarray)
+    assert isinstance(result_theta, np.ndarray)
+    assert isinstance(result_rho, np.ndarray)
+
+    np.testing.assert_allclose(result_H, desired_H)
+    np.testing.assert_allclose(result_theta, desired_thetas)
+    np.testing.assert_allclose(result_rho, desired_rhos)

dkist_processing_math-3.0.0rc1/dkist_processing_math/transform/__init__.py

@@ -0,0 +1,15 @@
+"""init."""
+
+from .affine import affine_inverse_transform_matrix
+from .affine import apply_affine_transform
+from .binary import make_binary
+from .binning import bin_arrays
+from .hough import do_hough
+
+__all__ = [
+    "affine_inverse_transform_matrix",
+    "apply_affine_transform",
+    "make_binary",
+    "bin_arrays",
+    "do_hough",
+]

dkist_processing_math-3.0.0rc1/dkist_processing_math/transform/affine.py

@@ -0,0 +1,186 @@
+"""Affine transforms."""
+
+from collections.abc import Generator
+from collections.abc import Iterable
+from typing import Literal
+
+import numpy as np
+import scipy.ndimage as spnd
+
+
+def affine_inverse_transform_matrix(
+    array_shape: tuple[int, ...],
+    shift: np.ndarray,
+    angle: float,
+    order: Literal["rotate_then_shift", "shift_then_rotate"],
+) -> np.ndarray:
+    """
+    Build the homogeneous-coordinates inverse transform matrix for a center-preserving rotation and shift.
+
+    This is the matrix form needed by `scipy.ndimage.affine_transform`'s `matrix` kwarg
+    to apply a rotation about the array's center and a shift in a single pass. A positive
+    angle rotates content counter-clockwise (the conventional mathematical direction).
+    The `order` argument controls which forward operation is being modeled (see below).
+
+    Parameters
+    ----------
+    array_shape
+        The shape of the 2D array the transform will be applied to.
+
+    shift
+        The shift to apply, in pixels, with length `ndim` (matching `array_shape`). A positive
+        `shift` moves the array's content in the positive direction along each axis (e.g.
+        ``shift=[0, 1]`` moves content one pixel toward higher column indices).
+
+    angle
+        The rotation angle, in radians.
+
+    order
+        Whether the modeled forward operation shifts first and then rotates
+        (``"shift_then_rotate"``) or rotates first and then shifts (``"rotate_then_shift"``).
+
+    Returns
+    -------
+    A ``(3, 3)`` homogeneous transform matrix encoding the rotation and shift together.
+
+    """
+    ndim = len(array_shape)
+
+    shift = np.asarray(shift, dtype=np.float64)
+    if shift.shape != (ndim,):
+        raise ValueError(f"shift must have shape ({ndim},) to match array_shape, got {shift.shape}")
+
+    if order not in ("rotate_then_shift", "shift_then_rotate"):
+        raise ValueError(f"order must be 'rotate_then_shift' or 'shift_then_rotate', got {order!r}")
+
+    if ndim != 2:
+        raise ValueError(f"array_shape must be 2D; got {ndim = }.")
+
+    center = 0.5 * (np.asarray(array_shape, dtype=np.float64) - 1.0)
+
+    # This function returns the pull-back (inverse) of the requested forward transform, because
+    # `scipy.ndimage.affine_transform` maps each *output* pixel coordinate back to the *input*
+    # coordinate to sample. The inverse of T(v) is T(-v); the inverse of rotation R is R(-angle).
+    # Each matrix below uses its inverse form directly, so the negations are visible at the
+    # construction site rather than applied to the variables earlier in the function.
+    R = _rotation_matrix(-angle)  # R_fwd^-1
+    T_uncenter = _translation_matrix(center)  # T_fwd(-center)^-1 = T(+center)
+    T_center = _translation_matrix(-center)  # T_fwd(+center)^-1 = T(-center)
+    T_shift = _translation_matrix(-shift)  # T_fwd(+shift)^-1  = T(-shift)
+
+    if order == "shift_then_rotate":
+        # Inverse of: T(+center) @ R_fwd @ T(-center) @ T(+shift)
+        return T_shift @ T_uncenter @ R @ T_center
+    else:  # order == "rotate_then_shift"
+        # Inverse of: T(+shift) @ T(+center) @ R_fwd @ T(-center)
+        return T_uncenter @ R @ T_center @ T_shift
+
+
+def apply_affine_transform(
+    arrays: Iterable[np.ndarray] | np.ndarray,
+    shift: np.ndarray,
+    angle: float,
+    order: Literal["rotate_then_shift", "shift_then_rotate"],
+    interp_order: int = 1,
+    mode: str = "nearest",
+    cval: float = np.nan,
+) -> Generator[np.ndarray, None, None]:
+    """
+    Apply a center-preserving rotation and shift to each input array.
+
+    Builds a single homogeneous-coordinates inverse transform matrix (via
+    `affine_inverse_transform_matrix`) and applies it with one
+    `scipy.ndimage.affine_transform` call per array, resolving both the rotation and shift in a
+    single interpolation pass. Non-finite values (NaN, ±inf) are replaced before interpolation so
+    that they don't spread during resampling.
+
+    The transform matrix is recomputed only when the array shape changes, so passing a sequence of
+    same-shaped arrays (the typical case) incurs only one matrix build.
+
+    Parameters
+    ----------
+    arrays
+        One or more arrays to correct. A single `np.ndarray` is wrapped automatically.
+
+    shift
+        The shift to apply, in pixels. See `affine_inverse_transform_matrix` for convention.
+
+    angle
+        The rotation angle, in radians. See `affine_inverse_transform_matrix` for details.
+
+    order
+        Whether the modeled forward operation shifts first then rotates (``"shift_then_rotate"``)
+        or rotates first then shifts (``"rotate_then_shift"``).
+
+    interp_order
+        Spline interpolation order for `scipy.ndimage.affine_transform`. Must be 0–5.
+        0 = nearest-neighbor, 1 = bilinear (default), …, 5 = quintic.
+
+    mode
+        How points outside the array boundary are handled. Passed directly to
+        `scipy.ndimage.affine_transform`. Default ``"nearest"``.
+
+    cval
+        Fill value used when ``mode="constant"``. Default `np.nan`.
+
+    Yields
+    ------
+    np.ndarray
+        Corrected arrays, one per input, each with the same shape as its input.
+
+    """
+    arrays = [arrays] if isinstance(arrays, np.ndarray) else arrays
+
+    previous_shape = None
+    matrix = None
+
+    for array in arrays:
+        array = np.asarray(array, dtype=np.float64)
+
+        # Replace non-finite values before interpolation; affine_transform spreads NaN/inf.
+        finite_mask = np.isfinite(array)
+        if not finite_mask.all():
+            finite_values = array[finite_mask]
+            if finite_values.size == 0:
+                # Entire array is non-finite -- fill with a safe scalar.
+                array.fill(cval if np.isfinite(cval) else 0.0)
+            else:
+                pos_inf = np.isposinf(array)
+                if pos_inf.any():
+                    array[pos_inf] = finite_values.max()
+                neg_inf = np.isneginf(array)
+                if neg_inf.any():
+                    array[neg_inf] = finite_values.min()
+                nan_mask = np.isnan(array)
+                if nan_mask.any():
+                    array[nan_mask] = np.nanmedian(array)
+
+        if array.shape != previous_shape:
+            matrix = affine_inverse_transform_matrix(array.shape, shift, angle, order=order)
+            previous_shape = array.shape
+
+        yield spnd.affine_transform(
+            array,
+            matrix=matrix,
+            order=interp_order,
+            mode=mode,
+            cval=cval,
+            prefilter=(interp_order > 1),
+        )
+
+
+def _rotation_matrix(angle: float) -> np.ndarray:
+    """Build a (3, 3) homogeneous rotation matrix for the given angle in radians."""
+    cosine_angle, sine_angle = np.cos(angle), np.sin(angle)
+    return np.array(
+        [[cosine_angle, -sine_angle, 0.0], [sine_angle, cosine_angle, 0.0], [0.0, 0.0, 1.0]],
+        dtype=np.float64,
+    )
+
+
+def _translation_matrix(shift: np.ndarray) -> np.ndarray:
+    """Build an (ndim+1, ndim+1) homogeneous pure-translation matrix."""
+    ndim = len(shift)
+    m = np.eye(ndim + 1, dtype=np.float64)
+    m[:ndim, ndim] = shift
+    return m

{dkist_processing_math-2.2.3 → dkist_processing_math-3.0.0rc1}/dkist_processing_math.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-math
-Version: 2.2.3
+Version: 3.0.0rc1
 Summary: Common math functionality used in the DKIST calibrations suite
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause

{dkist_processing_math-2.2.3 → dkist_processing_math-3.0.0rc1}/dkist_processing_math.egg-info/SOURCES.txt

@@ -7,6 +7,8 @@ README.rst
 bitbucket-pipelines.yml
 pyproject.toml
 changelog/.gitempty
+changelog/27.feature.rst
+changelog/27.removal.rst
 dkist_processing_math/__init__.py
 dkist_processing_math/arithmetic.py
 dkist_processing_math/feature.py
@@ -16,6 +18,8 @@ dkist_processing_math.egg-info/PKG-INFO
 dkist_processing_math.egg-info/SOURCES.txt
 dkist_processing_math.egg-info/dependency_links.txt
 dkist_processing_math.egg-info/requires.txt
+dkist_processing_math.egg-info/scm_file_list.json
+dkist_processing_math.egg-info/scm_version.json
 dkist_processing_math.egg-info/top_level.txt
 dkist_processing_math/tests/__init__.py
 dkist_processing_math/tests/conftest.py