dkist-processing-math 2.1.1__py3-none-any.whl

dkist_processing_math/transform/affine.py

@@ -0,0 +1,260 @@
+"""Affine transforms."""
+from functools import partial
+from typing import Iterable
+from typing import Iterator
+from typing import Tuple
+from typing import Union
+
+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
+
+    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)
+
+    """
+    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."
+        )
+
+    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.
+
+    Parameters
+    ----------
+    arrays
+        The array(s) to be rotated
+
+    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
+
+    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]
+
+    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.
+
+    Returns
+    -------
+    An Iterator yielding the rotated arrays.
+
+    """
+    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
+
+    """
+    arrays = [arrays] if isinstance(arrays, np.ndarray) else arrays
+    return affine_transform_arrays(arrays, translation=translation, **kwargs)
+
+
+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.
+
+    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.
+
+    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
+
+    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
+
+    Returns
+    -------
+    A 3x3 homogeneous transform matrix implementing the rotation
+
+    """
+    return skit.AffineTransform(rotation=angle).params
+
+
+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.
+
+    Parameters
+    ----------
+    shear_factors
+        The shear scaling factors.
+
+    Returns
+    -------
+    A 3x3 homogeneous transform matrix implementing the shear
+
+    """
+    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
+
+
+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.
+
+    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

dkist_processing_math/transform/binary.py

@@ -0,0 +1,37 @@
+"""Functionality for binary images."""
+import numpy
+import numpy as np
+from skimage import filters as skif
+
+
+def make_binary(data: numpy.ndarray, numotsu: int = 1) -> np.ndarray:
+    """Generate a binary image from an input float or int array.
+
+    A threshold value is chosen via Otsu's method and all values below the threshold are set to 1 while everything
+    else is set to 0. Thus the result is technically an _inverse_ binary image, which is useful for isolating the
+    target grid as a feature of interest.
+
+    Parameters
+    ----------
+    data
+        Data to convert to binary
+
+    numotsu
+        The number of times to perform thresholding using Otsu's method. Numbers larger than 1 are useful if the
+        pixel distribution of the data has > 2 modes.
+
+    Returns
+    -------
+    An array of 1's and 0's corresponding to the thresholded input data.
+
+    """
+    threshold = np.inf
+    for i in range(numotsu):
+        tmp = skif.threshold_otsu(data[data < threshold])
+        frac = np.sum(data < tmp) / data.size
+        # TODO: make this a parameter
+        if frac < 1e-3:
+            break
+        threshold = tmp
+    binary = np.array(data < threshold, dtype=int)
+    return binary

dkist_processing_math/transform/binning.py

@@ -0,0 +1,192 @@
+"""Binning transforms."""
+from functools import partial
+from typing import Iterable
+from typing import Iterator
+from typing import Literal
+from typing import Tuple
+from typing import Union
+
+import numpy as np
+from skimage import transform as skit
+
+
+def bin_arrays(
+    arrays: Union[Iterable[np.ndarray], np.ndarray], bin_factors: (int, int)
+) -> Iterator[np.ndarray]:
+    """
+    Bin an iterable of arrays by summation over an integral number of pixels in each dimension.
+
+    Parameters
+    ----------
+    arrays
+        The arrays to be binned
+
+    bin_factors
+        The bin factors for each axis, which must be integral divisors of each array dimension
+
+    Returns
+    -------
+    An Iterator yielding the binned arrays
+
+    """
+    arrays = [arrays] if isinstance(arrays, np.ndarray) else arrays
+    partial_bin = partial(_bin_array, bin_factors=bin_factors)
+    return map(partial_bin, arrays)
+
+
+def _bin_array(array: np.ndarray, bin_factors: (int, int)) -> np.ndarray:
+    """
+    Bin an array by summation over an integral number of pixels in each dimension.
+
+    Parameters
+    ----------
+    array
+        The array to be binned
+
+    bin_factors
+        The bin factors for each axis, which must be integral divisors of each array dimension
+
+    Returns
+    -------
+    The binned array
+
+    """
+    input_shape = array.shape
+    if input_shape[0] % bin_factors[0] or input_shape[1] % bin_factors[1]:
+        raise ValueError(
+            "Array dimensions must be an integral multiple of the binning factor\n"
+            f"Shape of array = {input_shape}, binning factors = {bin_factors}"
+        )
+    return skit.downscale_local_mean(array, bin_factors)
+
+
+def resize_arrays(
+    arrays: Union[Iterable[np.ndarray], np.ndarray],
+    output_shape: Tuple[int, ...],
+    order: Literal[0, 1, 2, 3, 4, 5] = 0,
+    mode: Literal["constant", "edge", "symmetric", "reflect", "wrap"] = "edge",
+) -> Iterator[np.ndarray]:
+    """
+    Resize an iterable of arrays using specified interpolation order.
+
+    This function is more geared towards up-sampling arrays smoothly. For more accurate downsampling see
+    `resize_arrays_local_mean`
+
+    Parameters
+    ----------
+    arrays
+        The arrays to be binned
+
+    output_shape
+        Shape to bin the input arrays to
+
+    order
+        The order of interpolation:
+
+            0: Nearest-neighbor
+            1: Bi-linear (default)
+            2: Bi-quadratic
+            3: Bi-cubic
+            4: Bi-quartic
+            5: Bi-quintic
+
+    mode
+        Points outside the boundaries of the input are filled according to the given mode. See `numpy.pad` for explanations.
+
+    Returns
+    -------
+    An Iterator yielding the binned arrays
+
+    """
+    arrays = [arrays] if isinstance(arrays, np.ndarray) else arrays
+    partial_bin = partial(_resize_array, output_shape=output_shape, order=order, mode=mode)
+    return map(partial_bin, arrays)
+
+
+def _resize_array(
+    array: np.ndarray,
+    output_shape: Tuple[int, ...],
+    order: Literal[0, 1, 2, 3, 4, 5] = 0,
+    mode: Literal["constant", "edge", "symmetric", "reflect", "wrap"] = "edge",
+) -> np.ndarray:
+    """
+    Resize an array using the given interpolation order.
+
+    Parameters
+    ----------
+    array
+        The array to be binned
+
+    output_shape
+        Shape to bin the input arrays to
+
+    order
+        The order of interpolation:
+
+            0: Nearest-neighbor
+            1: Bi-linear (default)
+            2: Bi-quadratic
+            3: Bi-cubic
+            4: Bi-quartic
+            5: Bi-quintic
+
+    mode
+        Points outside the boundaries of the input are filled according to the given mode. See `numpy.pad` for explanations.
+
+    Returns
+    -------
+    The binned array
+
+    """
+    return skit.resize(
+        array, output_shape, preserve_range=True, anti_aliasing=False, order=order, mode=mode
+    )
+
+
+def resize_arrays_local_mean(
+    arrays: Union[Iterable[np.ndarray], np.ndarray], output_shape: Tuple[int, ...]
+) -> Iterator[np.ndarray]:
+    """
+    Bin an iterable of arrays by summation over an integral number of pixels in each dimension.
+
+    This function is good for downsampling arrays, but acts like nearest-neighbor when upsampling.
+    See `resize` for more flexible upsampling options.
+
+    Note that when downsampling this method is sensitive to extreme outliers.
+
+    Parameters
+    ----------
+    arrays
+        The arrays to be binned
+
+    output_shape
+        Shape to bin the input arrays to
+
+    Returns
+    -------
+    An Iterator yielding the binned arrays
+
+    """
+    arrays = [arrays] if isinstance(arrays, np.ndarray) else arrays
+    partial_bin = partial(_resize_array_local_mean, output_shape=output_shape)
+    return map(partial_bin, arrays)
+
+
+def _resize_array_local_mean(array: np.ndarray, output_shape: Tuple[int, ...]) -> np.ndarray:
+    """
+    Bin an array by summation over an integral number of pixels in each dimension.
+
+    Parameters
+    ----------
+    array
+        The array to be binned
+
+    output_shape
+        Shape to bin the input arrays to
+
+    Returns
+    -------
+    The binned array
+
+    """
+    return skit.resize_local_mean(array, output_shape, preserve_range=True)

dkist_processing_math/transform/hough.py

@@ -0,0 +1,44 @@
+"""Hough transforms."""
+from typing import Tuple
+
+import numpy
+import numpy as np
+from skimage import transform as skit
+
+
+def do_hough(
+    binary: numpy.ndarray, theta_min: float, theta_max: float, numtheta: int = 1500
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Perform a Hough line transform on input data.
+
+    Resolution in the angle dimension can be increased via numtheta.
+
+    Parameters
+    ----------
+    binary
+        An integer array of 1's and 0's
+
+    theta_min
+        The minimum angle to use for the hough transform fitting
+
+    theta_max
+        The maximum angle to use for the hough transform fitting
+
+    numtheta
+        The number of samples in the theta dimension of the Hough transform.
+
+    Returns
+    -------
+    A tuple containing:
+        - The 2D Hough space (i.e., accumulator) of the input image.
+        - A 1D array of the angle values corresponding to the Hough accumulator. Angles will range from -pi/4 to 3/4 pi and the length will be equal to numtheta.
+        - A 1D array of the distance values corresponding to the Hough accumulator. This array is entirely determined by skimage.transform.hough_line
+
+    """
+    hough = skit.hough_line(binary, theta=np.linspace(theta_min, theta_max, numtheta))
+    hough_accumulator = hough[0]
+    theta = hough[1]
+    rho = hough[2]
+
+    return hough_accumulator, theta, rho

dkist_processing_math-2.1.1.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.1
+Name: dkist-processing-math
+Version: 2.1.1
+Summary: Common math functionality used in the DKIST calibrations suite
+Author-email: NSO / AURA <dkistdc@nso.edu>
+License: BSD-3-Clause
+Project-URL: Homepage, https://nso.edu/dkist/data-center/
+Project-URL: Repository, https://bitbucket.org/dkistdc/dkist-processing-math/
+Project-URL: Documentation, https://docs.dkist.nso.edu/projects/math
+Project-URL: Help, https://nso.atlassian.net/servicedesk/customer/portal/5
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/x-rst
+Requires-Dist: dkist-processing-common >=4.0.0
+Requires-Dist: numpy >=1.24.0
+Requires-Dist: scikit-image >=0.21.0
+Requires-Dist: scipy >=1.11.0
+Requires-Dist: peakutils >=1.3.3
+Provides-Extra: docs
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: sphinx-astropy ; extra == 'docs'
+Requires-Dist: sphinx-changelog ; extra == 'docs'
+Requires-Dist: sphinx-autoapi ; extra == 'docs'
+Requires-Dist: pytest ; extra == 'docs'
+Requires-Dist: towncrier ; extra == 'docs'
+Requires-Dist: dkist-sphinx-theme ; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+Requires-Dist: pytest-mock ; extra == 'test'
+Requires-Dist: hypothesis ; extra == 'test'
+Requires-Dist: towncrier ; extra == 'test'
+
+dkist-processing-math
+=====================
+
+dkist-processing-math contains the math functions used throughout the DKIST data processing software stack.
+
+
+Development
+-----------
+.. code-block:: bash
+
+    git clone git@bitbucket.org:dkistdc/dkist-processing-visp.git
+    cd dkist-processing-visp
+    pre-commit install
+    pip install -e .[test]
+    pytest -v --cov dkist_processing_visp
+
+Changelog
+#########
+
+When you make **any** change to this repository it **MUST** be accompanied by a changelog file.
+The changelog for this repository uses the `towncrier <https://github.com/twisted/towncrier>`__ package.
+Entries in the changelog for the next release are added as individual files (one per change) to the ``changelog/`` directory.
+
+Writing a Changelog Entry
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A changelog entry accompanying a change should be added to the ``changelog/`` directory.
+The name of a file in this directory follows a specific template::
+
+  <PULL REQUEST NUMBER>.<TYPE>[.<COUNTER>].rst
+
+The fields have the following meanings:
+
+* ``<PULL REQUEST NUMBER>``: This is the number of the pull request, so people can jump from the changelog entry to the diff on BitBucket.
+* ``<TYPE>``: This is the type of the change and must be one of the values described below.
+* ``<COUNTER>``: This is an optional field, if you make more than one change of the same type you can append a counter to the subsequent changes, i.e. ``100.bugfix.rst`` and ``100.bugfix.1.rst`` for two bugfix changes in the same PR.
+
+The list of possible types is defined the the towncrier section of ``pyproject.toml``, the types are:
+
+* ``feature``: This change is a new code feature.
+* ``bugfix``: This is a change which fixes a bug.
+* ``doc``: A documentation change.
+* ``removal``: A deprecation or removal of public API.
+* ``misc``: Any small change which doesn't fit anywhere else, such as a change to the package infrastructure.
+
+
+Rendering the Changelog at Release Time
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When you are about to tag a release first you must run ``towncrier`` to render the changelog.
+The steps for this are as follows:
+
+* Run `towncrier build --version vx.y.z` using the version number you want to tag.
+* Agree to have towncrier remove the fragments.
+* Add and commit your changes.
+* Tag the release.
+
+**NOTE:** If you forget to add a Changelog entry to a tagged release (either manually or automatically with ``towncrier``)
+then the Bitbucket pipeline will fail. To be able to use the same tag you must delete it locally and on the remote branch:
+
+.. code-block:: bash
+
+    # First, actually update the CHANGELOG and commit the update
+    git commit
+
+    # Delete tags
+    git tag -d vWHATEVER.THE.VERSION
+    git push --delete origin vWHATEVER.THE.VERSION
+
+    # Re-tag with the same version
+    git tag vWHATEVER.THE.VERSION
+    git push --tags origin main

dkist_processing_math-2.1.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+changelog/.gitempty,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dkist_processing_math/__init__.py,sha256=Mf7liCQC9M5YgFrz2NZ0dZ5smvcuw47ww6MC9mijAHw,249
+dkist_processing_math/arithmetic.py,sha256=h8E4DUBGQLDUiNWmZb2kZRrLMmjEpdl1S_mIi3ntZ6w,3694
+dkist_processing_math/feature.py,sha256=vwrkXBlK7wM6-KFaWxhBsMpHiHbpsWOiuGOhf3PRLSY,2003
+dkist_processing_math/linear_algebra.py,sha256=3ycmWklgLI89NjQgwgY81Zv1m_L4jJXHnt70TzQDVWQ,4179
+dkist_processing_math/statistics.py,sha256=Dgt1gSDQDN2XGV38xSQ3ZUmyIeGMZRoBl2vGHcADAYs,1233
+dkist_processing_math/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dkist_processing_math/tests/conftest.py,sha256=Pg7lDltF_N7SVIjAi0rRADXBftsSzw0o94-SfKW1Zko,1333
+dkist_processing_math/tests/test_arithmetic.py,sha256=18YI4Fr_m0KU0dYR8_ef7CMmnOlb-Zc4I8ERgoYdxdA,5658
+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=0_bFuKxcu6hfimScB5du38qzABq2syX7SQrA9ZjwbuA,2173
+dkist_processing_math/tests/test_transform.py,sha256=M761Yceh3FKV00udvb6_AeKuyBpQrUAG-mLfO-PbHmc,20253
+dkist_processing_math/transform/__init__.py,sha256=gZGyavJgtuquv8vc_VkXraJjz_8MkDTk9UwGQhthHwM,617
+dkist_processing_math/transform/affine.py,sha256=wJvL-R3DMpOmEnCKL8YI8eRUE7enH2Vg-mSLLpfCEoE,8595
+dkist_processing_math/transform/binary.py,sha256=64FhSBScuVCykHYA8Oh99wQodqVUiPdbtpFGIMl5BX8,1206
+dkist_processing_math/transform/binning.py,sha256=1zSX4SIJnc_LiQY-oOCeZhy-zGAp5ALJFXhJ7Pz6uDI,5172
+dkist_processing_math/transform/hough.py,sha256=o0l9YaYgMBqeKACHT8lZ4PbMZVJwjD-cE1kKrFg8mog,1370
+docs/Makefile,sha256=qnlVz6PuBqE39NfHWuUnHhNEA-EFgT2-WJNNNy9ttfk,4598
+docs/changelog.rst,sha256=S2jPASsWlQxSlAPqdvNrYvhk9k3FcFWNXFNDYXBSjl4,120
+docs/conf.py,sha256=wo1DmmqFac7fMpPLXZrY69vCXb3cji4Y7eYWOphUu_w,1835
+docs/index.rst,sha256=qNJUPrbv1dEdn_QLn5pZOhMTNikWVNAeSQnV76hFnis,103
+docs/make.bat,sha256=mBAhtURwhQ7yc95pqwJzlhqBSvRknr1aqZ5s8NKvdKs,4513
+docs/requirements.txt,sha256=Kbl_X4c7RQZw035YTeNB63We6I7pvXFU4T0Uflp2yDY,29
+licenses/LICENSE.rst,sha256=piZaQplkzOMmH1NXg6QIdo9wwo9pPCoHkvm2-DmH76E,1462
+dkist_processing_math-2.1.1.dist-info/METADATA,sha256=GPD3CVAME94Z-utZGhZTZm-jbGtE97P8RlqU5PwSk8Q,4301
+dkist_processing_math-2.1.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+dkist_processing_math-2.1.1.dist-info/top_level.txt,sha256=7NeFrOlR4xhZ3LMT4jN99LQugukjr6l9u3w_s6b-uO4,46
+dkist_processing_math-2.1.1.dist-info/RECORD,,

dkist_processing_math-2.1.1.dist-info/WHEEL

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

dkist_processing_math-2.1.1.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+changelog
+dkist_processing_math
+docs
+licenses