dkist-processing-math 2.2.2__py3-none-any.whl → 3.0.0__py3-none-any.whl

dkist_processing_math/arithmetic.py

@@ -1,5 +1,6 @@
 """Arithmetic."""
 
+from datetime import datetime
 from typing import Generator
 from typing import Iterable
 from typing import Union
@@ -124,3 +125,21 @@ def divide_fits_access_by_array(
     for obj in access_objs:
         obj.data = next(divide_arrays_by_array(obj.data, array_to_divide_by))
         yield obj
+
+
+def closest_datetime(
+    target_datetime: str | datetime, datetimes: list[str | datetime] | str | datetime
+) -> str | datetime:
+    """Find the closest datetime to a target datetime. Return type is of the same type as the datetimes list."""
+    if isinstance(target_datetime, str):
+        target_datetime = datetime.fromisoformat(target_datetime)
+    if isinstance(datetimes, str) or isinstance(datetimes, datetime):
+        datetimes = [datetimes]
+    converted_datetimes = [
+        datetime.fromisoformat(d) if isinstance(d, str) else d for d in datetimes
+    ]
+    closest_index, _ = min(
+        enumerate(converted_datetimes),
+        key=lambda dt: abs(dt[1] - target_datetime),
+    )
+    return datetimes[closest_index]

dkist_processing_math/tests/test_arithmetic.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Generator
 
 import numpy as np
@@ -5,6 +6,7 @@ import pytest
 from astropy.io import fits
 from dkist_processing_common.models.fits_access import FitsAccessBase
 
+from dkist_processing_math.arithmetic import closest_datetime
 from dkist_processing_math.arithmetic import divide_arrays_by_array
 from dkist_processing_math.arithmetic import divide_fits_access_by_array
 from dkist_processing_math.arithmetic import subtract_array_from_arrays
@@ -18,7 +20,7 @@ def multiple_test_fits_access(request, numpy_arrays):
     for i, array in enumerate(numpy_arrays):
         hdu = fits.PrimaryHDU(data=array)
         hdu.header["TEST"] = i
-        access_list.append(FitsAccessBase(hdu=hdu))
+        access_list.append(FitsAccessBase(header=hdu.header, data=array))
     if request.param == "multiple":
         return access_list
     return access_list[0]
@@ -126,3 +128,54 @@ def test_divide_arrays_by_array_wrong_shape(numpy_arrays_wrong_shape, numpy_arra
     """
     with pytest.raises(ValueError):
         list(divide_arrays_by_array(numpy_arrays_wrong_shape, numpy_array))
+
+
+@pytest.mark.parametrize(
+    "datetimes, expected_result",
+    [
+        pytest.param(
+            ["2025-12-31T00:00:00", "2026-01-07T00:00:00"],
+            "2025-12-31T00:00:00",
+            id="multiple solar gain ops",
+        ),
+        pytest.param("2025-12-31T00:00:00", "2025-12-31T00:00:00", id="single solar gain op"),
+    ],
+)
+def test_closest_datetime_with_strings(datetimes, expected_result):
+    """
+    Given: a target datetime and a list of string datetimes
+    When: running the closest_datetime method
+    Then: the closest datetime from the list of datetimes is returned
+    """
+    result = closest_datetime(
+        target_datetime="2026-01-01T00:00:00",
+        datetimes=datetimes,
+    )
+    assert result == expected_result
+
+
+@pytest.mark.parametrize(
+    "datetimes, expected_result",
+    [
+        pytest.param(
+            [
+                datetime(2025, 12, 31),
+                datetime(2026, 1, 7),
+            ],
+            datetime(2025, 12, 31),
+            id="multiple solar gain ops",
+        ),
+        pytest.param(datetime(2025, 12, 31), datetime(2025, 12, 31), id="single solar gain op"),
+    ],
+)
+def test_closest_datetime_with_datetimes(datetimes, expected_result):
+    """
+    Given: a target datetime and a list of datetimes
+    When: running the closest_datetime method
+    Then: the closest datetime from the list of datetimes is returned
+    """
+    result = closest_datetime(
+        target_datetime=datetime(2026, 1, 1),
+        datetimes=datetimes,
+    )
+    assert result == expected_result

dkist_processing_math/tests/test_transform.py

@@ -1,18 +1,12 @@
 import numpy as np
 import pytest
-from scipy import ndimage as spnd
 from skimage import transform as transform
 
-from dkist_processing_math.transform import affine_transform_arrays
+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 import rotate_arrays_about_point
-from dkist_processing_math.transform import rotation_matrix
-from dkist_processing_math.transform import scale_matrix
-from dkist_processing_math.transform import shear_matrix
-from dkist_processing_math.transform import translate_arrays
-from dkist_processing_math.transform import translation_matrix
 from dkist_processing_math.transform.binning import resize_arrays
 from dkist_processing_math.transform.binning import resize_arrays_local_mean
 
@@ -149,328 +143,238 @@ def test_resize_arrays_local_mean_single_array(numpy_array, resized_array):
     np.testing.assert_allclose(result, resized_array)
 
 
-def test_affine_transform_specify_matrix(numpy_array):
-    """
-    Given: a numpy_array
-    When: applying the affine transform and specifying the full transformation matrix
-    Then: an Iterator containing the transformed array is returned
-    """
-    angle = np.radians(90)
-    # Create the Affine transform for the rotation
-    rotation = transform.AffineTransform(rotation=angle)
-    # Offset to the center of the array for the rotation
-    p = np.array([4.5, 4.5])
-    # Create the Affine transform for the translation
-    trans = transform.AffineTransform(translation=p)
-    # Create the composite transform matrix for the rotation about the center
-    tform = trans.params @ rotation.params @ np.linalg.inv(trans.params)
-    # Perform the transformation
-    result = affine_transform_arrays(numpy_array, matrix=tform)
-    # Compare against the same rotation computed with a different method.
-    np.testing.assert_allclose(next(result), transform.rotate(numpy_array, -90, center=(4.5, 4.5)))
-
-
-def test_affine_transform_specify_rotate(numpy_array):
-    """
-    Given: a numpy_array
-    When: applying the affine transform and specifying a rotation angle and rotation point
-    Then: an Iterator containing the rotated array is returned
-    """
-    angle = np.radians(90)
-    rotation = transform.AffineTransform(rotation=angle)
-    # Offset to the center of the array for the rotation
-    p = np.array([4.5, 4.5, 0])
-    # Transform the offset to rotated space
-    o = p - np.dot(rotation.params, p)
-    result = affine_transform_arrays(numpy_array, rotation=np.radians(90), translation=o[0:2][::-1])
-    np.testing.assert_allclose(next(result), spnd.rotate(numpy_array, -90))
-
-
-def test_affine_transform_specify_scale_x(numpy_array):
-    """
-    Given: a numpy_array
-    When: applying the affine transform and specifying a scale factor for the X axis only
-    Then: an Iterator containing the array scaled along the X axis is returned
-    """
-
-    num_rows = numpy_array.shape[0]
-    num_cols = numpy_array.shape[1]
-    desired_output = np.zeros_like(numpy_array)
-    desired_output[0:num_rows, 0 : num_cols // 2] = numpy_array[0:num_rows, 0:num_cols:2]
-    result = affine_transform_arrays(numpy_array, scale=(0.5, 1.0))
-    np.testing.assert_allclose(next(result), desired_output)
-
-
-def test_affine_transform_specify_scale_y(numpy_array):
-    """
-    Given: a numpy_array
-    When: applying the affine transform and specifying a scale factor for the Y axis only
-    Then: an Iterator containing the array scaled along the Y axis is returned
-    """
-    num_rows = numpy_array.shape[0]
-    num_cols = numpy_array.shape[1]
-    desired_output = np.zeros_like(numpy_array)
-    desired_output[0 : num_rows // 2, 0:num_cols] = numpy_array[0:num_rows:2, 0:num_cols]
-    result = affine_transform_arrays(numpy_array, scale=(1.0, 0.5))
-    np.testing.assert_allclose(next(result), desired_output)
-
-
-def test_affine_transform_specify_scale_both(numpy_array):
-    """
-    Given: a numpy_array
-    When: applying the affine transform and specifying a scale factor for each axis
-    Then: an Iterator containing the array scaled separately along each axis is returned
-    """
-    tform = transform.SimilarityTransform(scale=0.5)
-    desired_output = transform.warp(numpy_array, tform.inverse)
-    result = affine_transform_arrays(numpy_array, scale=(0.5, 0.5))
-    np.testing.assert_allclose(next(result), desired_output)
-
-
-def test_affine_transform_specify_scale_scalar(numpy_array):
-    """
-    Given: a numpy_array
-    When: applying the affine transform and specifying a scalar scale factor to be applied to both axes
-    Then: an Iterator containing the array scaled identically on each axis is returned
-    """
-    tform = transform.SimilarityTransform(scale=0.5)
-    desired_output = transform.warp(numpy_array, tform.inverse)
-    result = affine_transform_arrays(numpy_array, scale=0.5)
-    np.testing.assert_allclose(next(result), desired_output)
+@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_affine_transform_specify_shear(numpy_array):
+def test_apply_affine_transform_single_array_wrapped():
     """
-    Given: a numpy_array
-    When: applying the affine transform and specifying a shear angle
-    Then: an Iterator containing the sheared array is returned
+    Given: a single ndarray (not wrapped in a list)
+    When: applying the correction
+    Then: it is accepted and the generator yields exactly one result
     """
-    shear_mat = np.array([[1, 0.1, 0], [0.2, 1, 0], [0, 0, 1]])
-    shear_mat_inv = np.linalg.inv(shear_mat)
-    desired_output = transform.warp(numpy_array, shear_mat_inv)
-    result = affine_transform_arrays(numpy_array, shear=(0.1, 0.2))
-    np.testing.assert_allclose(next(result), desired_output)
+    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_affine_transform_specify_translate(numpy_array):
+def test_apply_affine_transform_nonfinite_values_replaced():
     """
-    Given: a numpy_array
-    When: applying the affine transform and specifying a translation vector
-    Then: an Iterator containing the translated array is returned
+    Given: an input array containing NaN and ±inf
+    When: applying the correction
+    Then: the output is fully finite (NaN/inf do not survive interpolation)
     """
-    result = affine_transform_arrays(numpy_array, translation=(2, 5))
-    desired_output = spnd.shift(numpy_array, (2, 5))
-    np.testing.assert_allclose(next(result), desired_output)
+    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_affine_transform_all_params_none(numpy_array):
-    """
-    Given: a numpy_array
-    When: applying the affine transform and specifying no parameters
-    Then: an error is raised
+def test_apply_affine_transform_hand_derived_shift():
     """
-    with pytest.raises(ValueError):
-        affine_transform_arrays(numpy_array)
-
+    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
 
-def test_affine_transform_matrix_and_one_param(numpy_array):
+    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.
     """
-    Given: a numpy_array
-    When: applying the affine transform and specifying both a full matrix and one or more transform parameters
-    Then: an error is raised
-    """
-    with pytest.raises(ValueError):
-        affine_transform_arrays(numpy_array, matrix=np.ones((2, 2)), shear=0.1)
+    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"))
 
-def test_affine_transform_matrix_wrong_shape(numpy_array):
-    """
-    Given: a numpy_array
-    When: applying the affine transform and specifying both a full matrix and one or more transform parameters
-    Then: an error is raised
-    """
-    with pytest.raises(ValueError):
-        affine_transform_arrays(numpy_array, matrix=np.ones((2, 2)))
+    assert result[3, 4] == pytest.approx(1.0)
 
 
-def test_affine_transform_arrays(numpy_arrays):
+def test_apply_affine_transform_yields_one_per_input():
     """
-    Given: an iterable of numpy_arrays
-    When: applying the affine transform
-    Then: a Iterator containing the transformed arrays is returned
+    Given: a list of N arrays
+    When: applying the correction
+    Then: the generator yields exactly N arrays, each with the correct shape
     """
-    results = affine_transform_arrays(numpy_arrays, translation=(7, 3))
-    desired_outputs = [spnd.shift(array, (7, 3)) for array in numpy_arrays]
-    for result, desired_output in zip(results, desired_outputs):
-        np.testing.assert_allclose(result, desired_output)
-
-
-def test_affine_transform_arrays_single_array(numpy_array):
-    """
-    Given: a single numpy array
-    When: applying the affine transform to an iterable of arrays
-    Then: an Iterator containing the transformed array is returned
-    """
-    results = affine_transform_arrays(numpy_array, translation=(2, 3))
-    result = next(results)
-    desired_output = spnd.shift(numpy_array, (2, 3))
-    np.testing.assert_allclose(result, desired_output)
+    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_rotate_arrays_about_point(numpy_arrays):
+def test_apply_affine_transform_hand_derived_rotation():
     """
-    Given: an iterable of numpy arrays
-    When: rotating an iterable of arrays about a point
-    Then: an Iterator containing the rotated arrays is returned
-    """
-    angle = -45
-    p = np.array([5, 2])
-    results = rotate_arrays_about_point(numpy_arrays, angle=np.radians(angle), point=p)
-    desired_outputs = [transform.rotate(array, angle, center=p) for array in numpy_arrays]
-    for result, desired_output in zip(results, desired_outputs):
-        np.testing.assert_allclose(result, desired_output)
-
+    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
 
-def test_rotate_arrays_about_point_single_array(numpy_array):
+    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].
     """
-    Given: a single numpy array
-    When: rotating an iterable of arrays about a point
-    Then: an Iterator containing the rotated array is returned
-    """
-    angle = -45
-    p = np.array([5, 2])
-    results = rotate_arrays_about_point(numpy_array, angle=np.radians(angle), point=p)
-    result = next(results)
-    desired_output = transform.rotate(numpy_array, angle, center=p)
-    np.testing.assert_allclose(result, desired_output)
-
+    array = np.zeros((10, 10))
+    array[1, 7] = 1.0
 
-def test_translate_arrays(numpy_arrays):
-    """
-    Given: an iterable of numpy arrays
-    When: translating an iterable of arrays by a vector
-    Then: an Iterator containing the translated arrays is returned
-    """
-    results = translate_arrays(numpy_arrays, translation=(5, 2))
-    desired_outputs = [spnd.shift(array, (5, 2)) for array in numpy_arrays]
-    for result, desired_output in zip(results, desired_outputs):
-        np.testing.assert_allclose(result, desired_output)
+    result = next(
+        apply_affine_transform(array, np.array([0.0, 0.0]), np.pi / 2, order="shift_then_rotate")
+    )
 
-
-def test_translate_arrays_single_array(numpy_array):
-    """
-    Given: a single numpy array
-    When: translating an iterable of arrays by a vector
-    Then: an Iterator containing the translated array is returned
-    """
-    results = translate_arrays(numpy_array, translation=(5, 2))
-    result = next(results)
-    desired_output = spnd.shift(numpy_array, (5, 2))
-    np.testing.assert_allclose(result, desired_output)
+    assert result[2, 1] == pytest.approx(1.0)
 
 
-def test_scale_matrix(numpy_array):
-    """
-    Given: a single numpy array
-    When: creating a scale matrix operator
-    Then: a correct scale matrix is produced
+def test_apply_affine_transform_hand_derived_shift_and_rotate():
     """
-    scale_mat = scale_matrix((0.2, 0.4))
-    desired_output = affine_transform_arrays(numpy_array, scale=(0.2, 0.4))
-    result = affine_transform_arrays(numpy_array, matrix=scale_mat)
-    np.testing.assert_allclose(next(result), next(desired_output))
+    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
 
-
-def test_rotation_matrix(numpy_array):
-    """
-    Given: a single numpy array
-    When: creating a rotation matrix operator
-    Then: a correct rotation matrix is produced
+    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).
     """
-    angle = np.radians(30)
-    rotation_mat = rotation_matrix(angle)
-    desired_output = affine_transform_arrays(numpy_array, rotation=angle)
-    result = affine_transform_arrays(numpy_array, matrix=rotation_mat)
-    np.testing.assert_allclose(next(result), next(desired_output))
+    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")
+    )
 
-def test_shear_matrix(numpy_array):
-    """
-    Given: a single numpy array
-    When: creating a shear matrix operator
-    Then: a correct shear matrix is produced
-    """
-    shear = (0.1, 0.2)
-    shear_mat = shear_matrix(shear)
-    desired_shear_mat = np.array([[1, 0.1, 0], [0.2, 1, 0], [0, 0, 1]])
-    np.testing.assert_allclose(shear_mat, desired_shear_mat)
-    desired_output = affine_transform_arrays(numpy_array, shear=shear)
-    result = affine_transform_arrays(numpy_array, matrix=shear_mat)
-    np.testing.assert_allclose(next(result), next(desired_output))
+    assert result[2, 2] == pytest.approx(1.0)
 
 
-def test_shear_matrix_scalar(numpy_array):
+def test_affine_inverse_transform_matrix_matches_numpy_inverse():
     """
-    Given: a single numpy array
-    When: creating a shear matrix operator
-    Then: a correct shear matrix is produced
-    """
-    shear = 0.1
-    shear_mat = shear_matrix(shear)
-    desired_shear_mat = np.array([[1, 0.1, 0], [0.1, 1, 0], [0, 0, 1]])
-    np.testing.assert_allclose(shear_mat, desired_shear_mat)
-    desired_output = affine_transform_arrays(numpy_array, shear=shear)
-    result = affine_transform_arrays(numpy_array, matrix=shear_mat)
-    np.testing.assert_allclose(next(result), next(desired_output))
-
+    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
 
-def test_translation_matrix(numpy_array):
+    This verifies the matrix algebra is correct end-to-end, independently of any
+    hand-derived expected values.
     """
-    Given: a single numpy array
-    When: creating a translation matrix operator
-    Then: a correct translation matrix is produced
-    """
-    trans = (2.3, 5.7)
-    trans_mat = translation_matrix(trans)
-    desired_output = affine_transform_arrays(numpy_array, translation=trans)
-    result = affine_transform_arrays(numpy_array, matrix=trans_mat)
-    np.testing.assert_allclose(next(result), next(desired_output))
+    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)
 
-def test_translation_matrix_scalar(numpy_array):
-    """
-    Given: a single numpy array
-    When: creating a translation matrix operator
-    Then: a correct translation matrix is produced
-    """
-    trans = 4.2
-    trans_mat = translation_matrix(trans)
-    desired_output = affine_transform_arrays(numpy_array, translation=trans)
-    result = affine_transform_arrays(numpy_array, matrix=trans_mat)
-    np.testing.assert_allclose(next(result), next(desired_output))
+    # 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
 
-
-def test_matrix_compositions(numpy_array):
-    """
-    Given: a single numpy array
-    When: creating a composition of transform matrices
-    Then: a correct transform results from the composition
-    """
-    trans = (2.3, 5.7)
-    trans_mat = translation_matrix(trans)
-    shear = (0.1, 0.2)
-    shear_mat = shear_matrix(shear)
-    angle = np.radians(30)
-    rotation_mat = rotation_matrix(angle)
-    scale = (0.2, 0.4)
-    scale_mat = scale_matrix(scale)
-    # The order in which the transforms are applied reads right to left:
-    composition = trans_mat @ rotation_mat @ scale_mat @ shear_mat
-    result = affine_transform_arrays(numpy_array, matrix=composition)
-    desired_output = affine_transform_arrays(
-        numpy_array, scale=scale, shear=shear, rotation=angle, translation=trans
-    )
-    np.testing.assert_allclose(next(result), next(desired_output))
+    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():

dkist_processing_math/transform/__init__.py

@@ -1,24 +1,14 @@
 """init."""
 
-from .affine import affine_transform_arrays
-from .affine import rotate_arrays_about_point
-from .affine import rotation_matrix
-from .affine import scale_matrix
-from .affine import shear_matrix
-from .affine import translate_arrays
-from .affine import translation_matrix
+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_transform_arrays",
-    "translate_arrays",
-    "rotate_arrays_about_point",
-    "rotation_matrix",
-    "translation_matrix",
-    "scale_matrix",
-    "shear_matrix",
+    "affine_inverse_transform_matrix",
+    "apply_affine_transform",
     "make_binary",
     "bin_arrays",
     "do_hough",

dkist_processing_math/transform/affine.py

@@ -1,261 +1,186 @@
 """Affine transforms."""
 
-from functools import partial
-from typing import Iterable
-from typing import Iterator
-from typing import Tuple
-from typing import Union
+from collections.abc import Generator
+from collections.abc import Iterable
+from typing import Literal
 
 import numpy as np
-from skimage import transform as skit
-
-
-def affine_transform_arrays(
-    arrays: Union[Iterable[np.ndarray], np.ndarray],
-    matrix: np.ndarray = None,
-    scale: Union[Tuple[float, float], np.ndarray, float] = None,
-    translation: Union[Tuple[float, float], np.ndarray, float] = None,
-    rotation: float = None,
-    shear: Union[Tuple[float, float], np.ndarray, float] = None,
-    **kwargs,
-) -> Iterator[np.ndarray]:
-    """
-    Transform an iterable of input arrays using a generalized affine transform operator.
-
-    A transform matrix may be specified or separate parameters for scale, translation,
-    rotation and shear may be specified instead. This method abstracts the use of the
-    scikit-image affine transform, which may easily be replaced with one from scipy or
-    another origin. If transform parameters are specified, they are applied in this order:
-    shear, scale, rotation, translation
+import scipy.ndimage as spnd
 
-    Parameters
-    ----------
-    arrays
-        The array(s) to be transformed
-    matrix
-        The transformation matrix to be used for the transform. If specified, none of
-        [translation, rotation, or shear] may be used. Optional. If matrix is not specified,
-        at least one of the following must be used: scale, translation, rotation, shear
-    scale
-        The scale factor to be applied in the transform: (Sx, Sy). If a scalar is used, the same
-        value is applied to each axis.
-    translation
-        The translation to be applied in the transform: (Tx, Ty) in pixel units.
-    rotation
-        The rotation angle, in radians, to be applied to the transformation.
-        A positive angle is counter-clockwise in a right handed coordinate system
-    shear
-        The shear factor to be applied in the transform: (Shx, Shy). If a scalar is used, the same
-        value is applied to each axis.
-    **kwargs
-        Optional arguments to be passed on to skimage.transform.warp() if desired. See
-        https://scikit-image.org/docs/stable/api/skimage.transform.html#skimage.transform.warp
-        for more details.
-
-    Returns
-    -------
-    The transformed array(s)
 
+def affine_inverse_transform_matrix(
+    array_shape: tuple[int, ...],
+    shift: np.ndarray,
+    angle: float,
+    order: Literal["rotate_then_shift", "shift_then_rotate"],
+) -> np.ndarray:
     """
-    tform = None
-    any_param_set = any(param is not None for param in [scale, translation, rotation, shear])
-
-    # We do our own pre-checks here so that we're not totally tied to use scikit-image in the future
-    #
-    if not any_param_set and matrix is None:
-        raise ValueError(
-            "You must specify matrix or at least one of scale, rotate, shear, or shift."
-        )
+    Build the homogeneous-coordinates inverse transform matrix for a center-preserving rotation and shift.
 
-    elif any_param_set and matrix is not None:
-        raise ValueError(
-            "You cannot specify both matrix and any of scale, rotate, shear, or shift."
-        )
-
-    elif matrix is not None:
-        if matrix.shape != (3, 3):
-            raise ValueError(f"Invalid shape of transformation matrix: {matrix.shape}")
-        tform = skit.AffineTransform(matrix=matrix)
-
-    elif any_param_set:
-        # Construct the matrix from parameters
-        if scale is None:
-            scale = (1.0, 1.0)
-        elif np.isscalar(scale):
-            scale = (scale, scale)
-
-        if translation is None:
-            translation = (0.0, 0.0)
-        elif np.isscalar(translation):
-            translation = (translation, translation)
-
-        if rotation is None:
-            rotation = 0.0
-
-        if shear is None:
-            shear = (0.0, 0.0)
-
-        translation = translation[::-1]  # Because skimage and numpy have different axes ordering
-        shear_mat = shear_matrix(shear)
-        temp_tform = skit.AffineTransform(scale=scale, translation=translation, rotation=rotation)
-        tform_mat = temp_tform.params @ shear_mat
-        tform = skit.AffineTransform(matrix=tform_mat)
-
-    arrays = [arrays] if isinstance(arrays, np.ndarray) else arrays
-    partial_warp = partial(skit.warp, inverse_map=tform.inverse, **kwargs)
-    return map(partial_warp, arrays)
-
-
-def rotate_arrays_about_point(
-    arrays: Union[Iterable[np.ndarray], np.ndarray],
-    angle: float = 0.0,
-    point: Union[Tuple[float, float], np.ndarray] = None,
-    **kwargs,
-) -> Iterator[np.ndarray]:
-    """
-    Rotate an iterable of arrays about a specified point.
+    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
     ----------
-    arrays
-        The array(s) to be rotated
+    array_shape
+        The shape of the 2D array the transform will be applied to.
 
-    angle
-        The angle, in radians, for the rotation to be applied, optional. Default is zero
-        A positive angle is counter-clockwise in a right handed coordinate system and
-        clockwise in a left-handed coordinate system
+    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).
 
-    point
-        The point, in pixel coordinates (x, y) about which to rotate. Optional. Default is None,
-        meaning the center of the array will be used. Note that the origin pixel is centered at
-        (0, 0) and has extent: [-0.5: 0.5, -0.5: 0.5]
+    angle
+        The rotation angle, in radians.
 
-    kwargs
-        Any arguments to be passed to skimage.transform.rotate. See
-        https://scikit-image.org/docs/stable/api/skimage.transform.html#skimage.transform.rotate
-        for more details.
+    order
+        Whether the modeled forward operation shifts first and then rotates
+        (``"shift_then_rotate"``) or rotates first and then shifts (``"rotate_then_shift"``).
 
     Returns
     -------
-    An Iterator yielding the rotated arrays.
+    A ``(3, 3)`` homogeneous transform matrix encoding the rotation and shift together.
 
     """
-    arrays = [arrays] if isinstance(arrays, np.ndarray) else arrays
-    partial_rotate = partial(skit.rotate, angle=np.degrees(angle), center=point, **kwargs)
-    return map(partial_rotate, arrays)
-
-
-def translate_arrays(
-    arrays: Union[Iterable[np.ndarray], np.ndarray],
-    translation: Union[Tuple[float, float], np.ndarray] = (0.0, 0.0),
-    **kwargs,
-) -> Iterator[np.ndarray]:
-    """
-    Translate an iterable of arrays by a specified vector.
-
-    Parameters
-    ----------
-    arrays
-        The array(s) to be translated
-
-    translation
-        The translation to be applied in the transform: (Tx, Ty) in pixel units. Optional.
-
-    **kwargs
-        Optional arguments to be passed on to skimage.transform.warp() if desired. See
-        https://scikit-image.org/docs/stable/api/skimage.transform.html#skimage.transform.warp
-        for more details.
-
-    Returns
-    -------
-    np.ndarray
-        The translated array
-
+    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]:
     """
-    arrays = [arrays] if isinstance(arrays, np.ndarray) else arrays
-    return affine_transform_arrays(arrays, translation=translation, **kwargs)
+    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.
 
-def scale_matrix(scale_factors: Union[Tuple[float, float], float] = (1.0, 1.0)) -> np.ndarray:
-    """
-    Create an Affine Transform matrix for a scale operation.
+    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
     ----------
-    scale_factors
-        The scale factors to use in scaling the array. If a scalar is passed, it
-        is applied to both axes.
-
-    Returns
-    -------
-    A 3x3 homogeneous transform matrix implementing the scaling
-
-    """
-    return skit.AffineTransform(scale=scale_factors).params
-
-
-def rotation_matrix(angle: float = 0.0) -> np.ndarray:
-    """
-    Create an Affine Transform matrix for a rotation operation.
+    arrays
+        One or more arrays to correct. A single `np.ndarray` is wrapped automatically.
 
-    This assumes the rotation is about (0, 0) and it is up to the user
-    to calculate the appropriate translation offset to be applied in the
-    skimage.warp() method to achieve rotation about an arbitrary point
+    shift
+        The shift to apply, in pixels. See `affine_inverse_transform_matrix` for convention.
 
-    Parameters
-    ----------
     angle
-        The angle of rotation in radians. This represents counter-clockwise rotation
-        in a right-handed coordinate system and clockwise rotation in a left-handed
-        system
+        The rotation angle, in radians. See `affine_inverse_transform_matrix` for details.
 
-    Returns
-    -------
-    A 3x3 homogeneous transform matrix implementing the rotation
+    order
+        Whether the modeled forward operation shifts first then rotates (``"shift_then_rotate"``)
+        or rotates first then shifts (``"rotate_then_shift"``).
 
-    """
-    return skit.AffineTransform(rotation=angle).params
+    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"``.
 
-def shear_matrix(shear_factors: Union[Tuple[float, float], float] = (1.0, 1.0)) -> np.ndarray:
-    """
-    Create an Affine Transform matrix for a shear operation.
+    cval
+        Fill value used when ``mode="constant"``. Default `np.nan`.
 
-    Parameters
-    ----------
-    shear_factors
-        The shear scaling factors.
-
-    Returns
-    -------
-    A 3x3 homogeneous transform matrix implementing the shear
+    Yields
+    ------
+    np.ndarray
+        Corrected arrays, one per input, each with the same shape as its input.
 
     """
-    if isinstance(shear_factors, float):
-        shear_factors = shear_factors, shear_factors
-    shear_mat = np.eye(3, 3)
-    shear_mat[0, 1] = shear_factors[0]
-    shear_mat[1, 0] = shear_factors[1]
-    return shear_mat
+    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 translation_matrix(offsets: Union[Tuple[float, float], float] = (1.0, 1.0)) -> np.ndarray:
-    """
-    Create an Affine Transform matrix for a translation operation.
 
-    Parameters
-    ----------
-    offsets
-        The translation ofsets.
+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,
+    )
 
-    Returns
-    -------
-    A 3x3 homogeneous transform matrix implementing the translation
 
-    """
-    if isinstance(offsets, float):
-        offsets = offsets, offsets
-    trans_mat = np.eye(3, 3)
-    trans_mat[0, 2] = offsets[1]
-    trans_mat[1, 2] = offsets[0]
-    return trans_mat
+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.2.dist-info → dkist_processing_math-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-math
-Version: 2.2.2
+Version: 3.0.0
 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.2.dist-info → dkist_processing_math-3.0.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 changelog/.gitempty,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dkist_processing_math/__init__.py,sha256=z2HXBhrQyX-yBiLTWnPUgVevMA7QI_3ZdJKn3ev1F8I,252
-dkist_processing_math/arithmetic.py,sha256=WgO3lQI4GIVVOiXb_F7tQCZ5XQKzm_kF_zcy_3IL964,3695
+dkist_processing_math/arithmetic.py,sha256=-kLO64IT2RxyykH1jlthvC0pegkhyJpIj9oa_9rdAdY,4457
 dkist_processing_math/feature.py,sha256=xdhPkkoOX9aO50BeMjU_2vKwAOG1AUBA3TvfHzZuP6A,2004
 dkist_processing_math/linear_algebra.py,sha256=yCA6ZuNORFnAyXywj73QMmGCpv9ZC2FSoMEPc8wToQY,4180
 dkist_processing_math/statistics.py,sha256=KkZTy8wdslPSQ5qP4z_We60Vizaxqna7rmMwxkoj36U,3178
 dkist_processing_math/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dkist_processing_math/tests/conftest.py,sha256=TV0o-R2lU1MvZleme0w-akcgO5wOTlFNKhjSlmDwkqg,1593
-dkist_processing_math/tests/test_arithmetic.py,sha256=18YI4Fr_m0KU0dYR8_ef7CMmnOlb-Zc4I8ERgoYdxdA,5658
+dkist_processing_math/tests/test_arithmetic.py,sha256=IzNm6u1ER5w_zlasOgTXlXSZjmpXnXpUmRb20XPx4DM,7320
 dkist_processing_math/tests/test_feature.py,sha256=ZB8r_IUrAyTAlKbxEXwr8Q2zS7KPmlJhaU1l0guK0Xc,2311
 dkist_processing_math/tests/test_linear_algebra.py,sha256=k-XqIIBPsenNMKqo2nQnDkkN-6T1nvVT8BrJnupAIFU,6495
 dkist_processing_math/tests/test_statistics.py,sha256=N0S8C9Bwhd1VgCAkm6RqIZF_Ulwrcet9wqfbndw8KZs,2998
-dkist_processing_math/tests/test_transform.py,sha256=M761Yceh3FKV00udvb6_AeKuyBpQrUAG-mLfO-PbHmc,20253
-dkist_processing_math/transform/__init__.py,sha256=dFAi8bpLDa1Gp-kNrAsjcLnkRqyFNYbfzafC6gUUXHs,618
-dkist_processing_math/transform/affine.py,sha256=2U_qG700otfz5ePjbaa_m47ttRYRaNAj71W9NtcZ4xU,8596
+dkist_processing_math/tests/test_transform.py,sha256=-y-ZZK8GXxWbnBNdA5GDD83IWnoBWFF5YQAZPfxDp8k,15862
+dkist_processing_math/transform/__init__.py,sha256=D7g9xVIvSHF92QKgsNCsYA3hrCys01uN3gkKcOdnyTo,337
+dkist_processing_math/transform/affine.py,sha256=e6VX_34ns3E5UZql1o8KnaiJHO-Lhn5R6xEBooP38Zg,7129
 dkist_processing_math/transform/binary.py,sha256=a_wYYORIvfD8AmQor3t5fMO8LwoFondyX-5awGQeUZk,1207
 dkist_processing_math/transform/binning.py,sha256=--CUP0nYxrWXbou48UJg8liSQJkwxBlDsKRXZTvhRCU,5173
 dkist_processing_math/transform/hough.py,sha256=CUGkoFNLSTeCOF_0L-hT7BtPomB-oAdc0VVb_UfKGiY,1371
@@ -24,7 +24,7 @@ docs/landing_page.rst,sha256=JCyR9SRhYS6zeEUlonIzko1kQ0tAFDIfi7pCoQanZeA,251
 docs/make.bat,sha256=mBAhtURwhQ7yc95pqwJzlhqBSvRknr1aqZ5s8NKvdKs,4513
 docs/requirements.txt,sha256=Kbl_X4c7RQZw035YTeNB63We6I7pvXFU4T0Uflp2yDY,29
 licenses/LICENSE.rst,sha256=piZaQplkzOMmH1NXg6QIdo9wwo9pPCoHkvm2-DmH76E,1462
-dkist_processing_math-2.2.2.dist-info/METADATA,sha256=lHuOull8f05fjgkr_N7NwKMLiojK04JPN0WX3u4f0dw,4467
-dkist_processing_math-2.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-dkist_processing_math-2.2.2.dist-info/top_level.txt,sha256=7NeFrOlR4xhZ3LMT4jN99LQugukjr6l9u3w_s6b-uO4,46
-dkist_processing_math-2.2.2.dist-info/RECORD,,
+dkist_processing_math-3.0.0.dist-info/METADATA,sha256=UT0lWh4pkz94qHbdpGz9tdHT6mUGYsReTO5p1SGj-pg,4467
+dkist_processing_math-3.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+dkist_processing_math-3.0.0.dist-info/top_level.txt,sha256=7NeFrOlR4xhZ3LMT4jN99LQugukjr6l9u3w_s6b-uO4,46
+dkist_processing_math-3.0.0.dist-info/RECORD,,

{dkist_processing_math-2.2.2.dist-info → dkist_processing_math-3.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any