drizzle 2.0.0__cp312-cp312-macosx_11_0_arm64.whl → 2.0.1__cp312-cp312-macosx_11_0_arm64.whl

drizzle/resample.py

@@ -6,7 +6,7 @@ import numpy as np
 
 from drizzle import cdrizzle
 
-__all__ = ["blot_image", "Drizzle"]
+__all__ = ["Drizzle", "blot_image"]
 
 SUPPORTED_DRIZZLE_KERNELS = [
     "square",

drizzle/tests/helpers.py

@@ -0,0 +1,190 @@
+import os
+
+import gwcs
+import numpy as np
+from gwcs.coordinate_frames import CelestialFrame, Frame2D
+
+from astropy import coordinates as coord
+from astropy import units
+from astropy import wcs as fits_wcs
+from astropy.io import fits
+from astropy.modeling.models import (
+    Mapping,
+    Pix2Sky_TAN,
+    Polynomial2D,
+    RotateNative2Celestial,
+    Shift,
+)
+from astropy.modeling.projections import AffineTransformation2D
+
+__all__ = ["wcs_from_file"]
+
+TEST_DIR = os.path.abspath(os.path.dirname(__file__))
+DATA_DIR = os.path.join(TEST_DIR, 'data')
+
+
+def wcs_from_file(filename, ext=None, return_data=False, crpix_shift=None,
+                  wcs_type="fits"):
+    """
+    Read the WCS from a ".fits" file.
+
+    Parameters
+    ----------
+    filename : str
+        Name of the file to load WCS from.
+
+    ext : int, None, optional
+        Extension number to load the WCS from. When `None`, the WCS will be
+        loaded from the first extension containing a WCS.
+
+    return_data : bool, optional
+        When `True`, this function will return a tuple with first item
+        being the WCS and the second item being the image data array.
+
+    crpix_shift : tuple, None, optional
+        A tuple of two values to be added to header CRPIX values before
+        creating the WCS. This effectively introduces a constant shift
+        in the image coordinate system.
+
+    wcs_type : {"fits", "gwcs"}, optional
+        Return either a FITS WCS or a gwcs.
+
+    Returns
+    -------
+    WCS or tuple of WCS and image data
+
+    """
+    full_file_name = os.path.join(DATA_DIR, filename)
+    path = os.path.join(DATA_DIR, full_file_name)
+    with fits.open(path) as hdu:
+        if ext is None:
+            for k, u in enumerate(hdu):
+                if "CTYPE1" in u.header:
+                    ext = k
+                    break
+
+        hdr = hdu[ext].header
+        naxis1 = hdr.get("WCSNAX1", hdr.get("NAXIS1"))
+        naxis2 = hdr.get("WCSNAX2", hdr.get("NAXIS2"))
+        if naxis1 is not None and naxis2 is not None:
+            shape = (naxis2, naxis1)
+            if hdu[ext].data is None:
+                hdu[ext].data = np.zeros(shape, dtype=np.float32)
+        else:
+            shape = None
+
+        if crpix_shift is not None and "CRPIX1" in hdr:
+            hdr["CRPIX1"] += crpix_shift[0]
+            hdr["CRPIX2"] += crpix_shift[1]
+
+        result = fits_wcs.WCS(hdr, hdu)
+        result.array_shape = shape
+
+        if wcs_type == "gwcs":
+            result = _gwcs_from_hst_fits_wcs(result)
+
+        if return_data:
+            result = (result, )
+            if not isinstance(return_data, (list, tuple)):
+                return_data = [ext]
+            for ext in return_data:
+                data = (hdu[ext].data, )
+                result = result + data
+
+    return result
+
+
+def _gwcs_from_hst_fits_wcs(w):
+    # NOTE: this function ignores table distortions
+    def coeffs_to_poly(mat, degree):
+        pol = Polynomial2D(degree=degree)
+        for i in range(mat.shape[0]):
+            for j in range(mat.shape[1]):
+                if 0 < i + j <= degree:
+                    setattr(pol, f'c{i}_{j}', mat[i, j])
+        return pol
+
+    nx, ny = w.pixel_shape
+    x0, y0 = w.wcs.crpix - 1
+
+    cd = w.wcs.piximg_matrix
+
+    if w.sip is None:
+        # construct GWCS:
+        det2sky = (
+            (Shift(-x0) & Shift(-y0)) |
+            Pix2Sky_TAN() | RotateNative2Celestial(*w.wcs.crval, 180)
+        )
+    else:
+        cfx, cfy = np.dot(cd, [w.sip.a.ravel(), w.sip.b.ravel()])
+        a = np.reshape(cfx, w.sip.a.shape)
+        b = np.reshape(cfy, w.sip.b.shape)
+        a[1, 0] = cd[0, 0]
+        a[0, 1] = cd[0, 1]
+        b[1, 0] = cd[1, 0]
+        b[0, 1] = cd[1, 1]
+
+        polx = coeffs_to_poly(a, w.sip.a_order)
+        poly = coeffs_to_poly(b, w.sip.b_order)
+
+        sip = Mapping((0, 1, 0, 1)) | (polx & poly)
+
+        # construct GWCS:
+        det2sky = (
+            (Shift(-x0) & Shift(-y0)) | sip |
+            Pix2Sky_TAN() | RotateNative2Celestial(*w.wcs.crval, 180)
+        )
+
+    detector_frame = Frame2D(
+        name="detector",
+        axes_names=("x", "y"),
+        unit=(units.pix, units.pix)
+    )
+    sky_frame = CelestialFrame(
+        reference_frame=getattr(coord, w.wcs.radesys).__call__(),
+        name=w.wcs.radesys,
+        unit=(units.deg, units.deg)
+    )
+    pipeline = [(detector_frame, det2sky), (sky_frame, None)]
+    gw = gwcs.wcs.WCS(pipeline)
+    gw.array_shape = w.array_shape
+    gw.bounding_box = ((-0.5, nx - 0.5), (-0.5, ny - 0.5))
+
+    if w.sip is not None:
+        # compute inverse SIP and re-create output GWCS
+
+        # compute inverse SIP:
+        hdr = gw.to_fits_sip(
+            max_inv_pix_error=1e-5,
+            inv_degree=None,
+            npoints=64,
+            crpix=w.wcs.crpix,
+            projection='TAN',
+            verbose=False
+        )
+        winv = fits_wcs.WCS(hdr)
+        ap = winv.sip.ap.copy()
+        bp = winv.sip.bp.copy()
+        ap[1, 0] += 1
+        bp[0, 1] += 1
+        polx_inv = coeffs_to_poly(ap, winv.sip.ap_order)
+        poly_inv = coeffs_to_poly(bp, winv.sip.bp_order)
+        af = AffineTransformation2D(
+            matrix=np.linalg.inv(winv.wcs.piximg_matrix)
+        )
+
+        # set analytical inverses:
+        sip.inverse = af | Mapping((0, 1, 0, 1)) | (polx_inv & poly_inv)
+
+        # construct GWCS:
+        det2sky = (
+            (Shift(-x0) & Shift(-y0)) | sip |
+            Pix2Sky_TAN() | RotateNative2Celestial(*w.wcs.crval, 180)
+        )
+
+        pipeline = [(detector_frame, det2sky), (sky_frame, None)]
+        gw = gwcs.wcs.WCS(pipeline)
+        gw.array_shape = w.array_shape
+        gw.bounding_box = ((-0.5, nx - 0.5), (-0.5, ny - 0.5))
+
+    return gw

drizzle/tests/test_resample.py

@@ -5,9 +5,10 @@ import numpy as np
 import pytest
 
 from astropy import wcs
-from astropy.io import fits
 from drizzle import cdrizzle, resample, utils
 
+from .helpers import wcs_from_file
+
 TEST_DIR = os.path.abspath(os.path.dirname(__file__))
 DATA_DIR = os.path.join(TEST_DIR, 'data')
 
@@ -166,20 +167,20 @@ def centroid_statistics(title, fname, image1, image2, amp, size):
     return tuple(diff)
 
 
-def make_point_image(input_image, point, value):
+def make_point_image(shape, point, value):
     """
     Create an image with a single point set
     """
-    output_image = np.zeros(input_image.shape, dtype=input_image.dtype)
+    output_image = np.zeros(shape, dtype=np.float32)
     output_image[point] = value
     return output_image
 
 
-def make_grid_image(input_image, spacing, value):
+def make_grid_image(shape, spacing, value):
     """
     Create an image with points on a grid set
     """
-    output_image = np.zeros(input_image.shape, dtype=input_image.dtype)
+    output_image = np.zeros(shape, dtype=np.float32)
 
     shape = output_image.shape
     half_space = int(spacing / 2)
@@ -190,29 +191,6 @@ def make_grid_image(input_image, spacing, value):
     return output_image
 
 
-def read_image(filename):
-    """
-    Read the image from a fits file
-    """
-    path = os.path.join(DATA_DIR, filename)
-    hdu = fits.open(path)
-
-    image = hdu[1].data
-    hdu.close()
-    return image
-
-
-def read_wcs(filename):
-    """
-    Read the wcs of a fits file
-    """
-    path = os.path.join(DATA_DIR, filename)
-    hdu = fits.open(path)
-    the_wcs = wcs.WCS(hdu[1].header)
-    hdu.close()
-    return the_wcs
-
-
 def test_drizzle_defaults():
     n = 200
     in_shape = (n, n)
@@ -256,52 +234,86 @@ def test_drizzle_defaults():
     assert driz.out_img[1, 2] == 1
     assert (driz.out_img[2, 1] - 2.0) < 1.0e-14
 
-
-def test_square_with_point(tmpdir):
+@pytest.mark.parametrize(
+    'kernel,test_image_type,max_diff_atol',
+    [
+        ("square", "point", 1.0e-5),
+        ("square", "grid", 1.0e-5),
+        ('point', "grid", 1.0e-5),
+        ("turbo", "grid", 1.0e-5),
+        ('lanczos3', "grid", 1.0e-5),
+        ("gaussian", "grid", 2.0e-5),
+    ],
+)
+def test_resample_kernel(tmpdir, kernel, test_image_type, max_diff_atol):
     """
     Test do_driz square kernel with point
     """
-    output_difference = str(tmpdir.join('difference_square_point.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_square_point.fits')
+    output_difference = str(
+        tmpdir.join(f"difference_{kernel}_{test_image_type}.txt")
+    )
 
-    insci = read_image(input_file)
-    inwcs = read_wcs(input_file)
-    insci = make_point_image(insci, (500, 200), 100.0)
-    inwht = np.ones(insci.shape, dtype=insci.dtype)
-    output_wcs = read_wcs(output_template)
+    inwcs = wcs_from_file("j8bt06nyq_flt.fits", ext=1)
+    if test_image_type == "point":
+        insci = make_point_image(inwcs.array_shape, (500, 200), 100.0)
+    else:
+        insci = make_grid_image(inwcs.array_shape, 64, 100.0)
+    inwht = np.ones_like(insci)
+    output_wcs, template_data = wcs_from_file(
+        f"reference_{kernel}_{test_image_type}.fits",
+        ext=1,
+        return_data=True
+    )
 
     pixmap = utils.calc_pixmap(
         inwcs,
         output_wcs,
     )
 
-    # ignore previous pscale and compute it the old way (only to make
-    # tests work with old truth files and thus to show that new API gives
-    # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
-        np.sum(output_wcs.wcs.pc**2, axis=0)[0] /
-        np.sum(inwcs.wcs.cd**2, axis=0)[0]
-    )
+    if kernel == "point":
+        pscale_ratio = 1.0
+    else:
+        pscale_ratio = utils.estimate_pixel_scale_ratio(
+            inwcs,
+            output_wcs,
+            refpix_from=inwcs.wcs.crpix,
+            refpix_to=output_wcs.wcs.crpix,
+        )
+
+        # ignore previous pscale and compute it the old way (only to make
+        # tests work with old truth files and thus to show that new API gives
+        # same results when equal definitions of the pixel scale is used):
+        pscale_ratio = np.sqrt(
+            np.sum(output_wcs.wcs.pc**2, axis=0)[0] /
+            np.sum(inwcs.wcs.cd**2, axis=0)[0]
+        )
 
     driz = resample.Drizzle(
-        kernel='square',
+        kernel=kernel,
         out_shape=output_wcs.array_shape,
         fillval=0.0,
     )
-    driz.add_image(
-        insci,
-        exptime=1.0,
-        pixmap=pixmap,
-        weight_map=inwht,
-        scale=pscale,
-    )
 
-    template_data = read_image(output_template)
+    if kernel in ["square", "turbo", "point"]:
+        driz.add_image(
+            insci,
+            exptime=1.0,
+            pixmap=pixmap,
+            weight_map=inwht,
+            scale=pscale_ratio,
+        )
+    else:
+        with pytest.warns(Warning):
+            driz.add_image(
+                insci,
+                exptime=1.0,
+                pixmap=pixmap,
+                weight_map=inwht,
+                scale=pscale_ratio,
+            )
 
     _, med_diff, max_diff = centroid_statistics(
-        "square with point",
+        f"{kernel} with {test_image_type}",
         output_difference,
         driz.out_img,
         template_data,
@@ -310,7 +322,66 @@ def test_square_with_point(tmpdir):
     )
 
     assert med_diff < 1.0e-6
-    assert max_diff < 1.0e-5
+    assert max_diff < max_diff_atol
+
+
+@pytest.mark.parametrize(
+    'kernel,max_diff_atol',
+    [
+        ("square", 1.0e-5),
+        ("turbo", 1.0e-5),
+    ],
+)
+def test_resample_kernel_image(tmpdir, kernel, max_diff_atol):
+    """
+    Test do_driz square kernel with point
+    """
+    inwcs, insci = wcs_from_file(
+        "j8bt06nyq_flt.fits",
+        ext=1,
+        return_data=True
+    )
+    inwht = np.ones_like(insci)
+
+    outwcs, ref_sci, ref_ctx, ref_wht = wcs_from_file(
+        f"reference_{kernel}_image.fits",
+        ext=1,
+        return_data=["SCI", "CTX", "WHT"]
+    )
+    ref_ctx = np.array(ref_ctx, dtype=np.int32)
+
+    pixmap = utils.calc_pixmap(
+        inwcs,
+        outwcs,
+    )
+
+    pscale_ratio = np.sqrt(
+        np.sum(outwcs.wcs.cd**2, axis=0)[0] /
+        np.sum(inwcs.wcs.cd**2, axis=0)[0]
+    )
+
+    driz = resample.Drizzle(
+        kernel=kernel,
+        out_shape=ref_sci.shape,
+        fillval=0.0,
+    )
+
+    driz.add_image(
+        insci,
+        exptime=1.0,
+        pixmap=pixmap,
+        weight_map=inwht,
+        scale=pscale_ratio,
+    )
+    outctx = driz.out_ctx[0]
+
+    # in order to avoid small differences in the staircase in the outline
+    # of the input image in the output grid, select a subset:
+    sl = np.s_[125: -125, 5: -5]
+
+    assert np.allclose(driz.out_img[sl], ref_sci[sl], atol=0, rtol=1.0e-6)
+    assert np.allclose(driz.out_wht[sl], ref_wht[sl], atol=0, rtol=1.0e-6)
+    assert np.all(outctx[sl] == ref_ctx[sl])
 
 
 @pytest.mark.parametrize(
@@ -389,472 +460,64 @@ def test_zero_input_weight(kernel, fc):
     assert np.sum(np.abs(outsci[(outwht == 0)])) == 0.0
 
 
-def test_square_with_grid(tmpdir):
-    """
-    Test do_driz square kernel with grid
-    """
-    output_difference = str(tmpdir.join('difference_square_grid.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_square_grid.fits')
-
-    insci = read_image(input_file)
-    inwcs = read_wcs(input_file)
-    insci = make_grid_image(insci, 64, 100.0)
-
-    inwht = np.ones(insci.shape, dtype=insci.dtype)
-    output_wcs = read_wcs(output_template)
-
-    pixmap = utils.calc_pixmap(
-        inwcs,
-        output_wcs,
-    )
-    pscale = utils.estimate_pixel_scale_ratio(
-        inwcs,
-        output_wcs,
-        refpix_from=inwcs.wcs.crpix,
-        refpix_to=output_wcs.wcs.crpix,
-    )
-    # ignore previous pscale and compute it the old way (only to make
-    # tests work with old truth files and thus to show that new API gives
-    # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
-        np.sum(output_wcs.wcs.pc**2, axis=0)[0] /
-        np.sum(inwcs.wcs.cd**2, axis=0)[0]
-    )
-
-    driz = resample.Drizzle(
-        kernel='square',
-        out_shape=output_wcs.array_shape,
-        fillval=0.0,
-    )
-    driz.add_image(
-        insci,
-        exptime=1.0,
-        pixmap=pixmap,
-        weight_map=inwht,
-        scale=pscale,
-    )
-    template_data = read_image(output_template)
-
-    _, med_diff, max_diff = centroid_statistics(
-        "square with grid",
-        output_difference,
-        driz.out_img,
-        template_data,
-        20.0,
-        8,
-    )
-    assert med_diff < 1.0e-6
-    assert max_diff < 1.0e-5
-
-
-def test_turbo_with_grid(tmpdir):
-    """
-    Test do_driz turbo kernel with grid
-    """
-    output_difference = str(tmpdir.join('difference_turbo_grid.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_turbo_grid.fits')
-
-    insci = read_image(input_file)
-    inwcs = read_wcs(input_file)
-    insci = make_grid_image(insci, 64, 100.0)
-    inwht = np.ones(insci.shape, dtype=insci.dtype)
-    output_wcs = read_wcs(output_template)
-
-    pixmap = utils.calc_pixmap(
-        inwcs,
-        output_wcs,
-    )
-    pscale = utils.estimate_pixel_scale_ratio(
-        inwcs,
-        output_wcs,
-        refpix_from=inwcs.wcs.crpix,
-        refpix_to=output_wcs.wcs.crpix,
-    )
-
-    # ignore previous pscale and compute it the old way (only to make
-    # tests work with old truth files and thus to show that new API gives
-    # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
-        np.sum(output_wcs.wcs.pc**2, axis=0)[0] /
-        np.sum(inwcs.wcs.cd**2, axis=0)[0]
-    )
-
-    driz = resample.Drizzle(
-        kernel='turbo',
-        out_shape=output_wcs.array_shape,
-        fillval=0.0,
-    )
-    driz.add_image(
-        insci,
-        exptime=1.0,
-        pixmap=pixmap,
-        weight_map=inwht,
-        scale=pscale,
-    )
-
-    template_data = read_image(output_template)
-
-    _, med_diff, max_diff = centroid_statistics(
-        "turbo with grid",
-        output_difference,
-        driz.out_img,
-        template_data,
-        20.0,
-        8,
-    )
-
-    assert med_diff < 1.0e-6
-    assert max_diff < 1.0e-5
-
-
-def test_gaussian_with_grid(tmpdir):
-    """
-    Test do_driz gaussian kernel with grid
-    """
-    output_difference = str(tmpdir.join('difference_gaussian_grid.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_gaussian_grid.fits')
-
-    insci = read_image(input_file)
-    inwcs = read_wcs(input_file)
-    insci = make_grid_image(insci, 64, 100.0)
-    inwht = np.ones(insci.shape, dtype=insci.dtype)
-    output_wcs = read_wcs(output_template)
-
-    pixmap = utils.calc_pixmap(
-        inwcs,
-        output_wcs,
-    )
-    pscale = utils.estimate_pixel_scale_ratio(
-        inwcs,
-        output_wcs,
-        refpix_from=inwcs.wcs.crpix,
-        refpix_to=output_wcs.wcs.crpix,
-    )
-
-    # ignore previous pscale and compute it the old way (only to make
-    # tests work with old truth files and thus to show that new API gives
-    # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
-        np.sum(output_wcs.wcs.pc**2, axis=0)[0] /
-        np.sum(inwcs.wcs.cd**2, axis=0)[0]
-    )
-
-    driz = resample.Drizzle(
-        kernel='gaussian',
-        out_shape=output_wcs.array_shape,
-        fillval=0.0,
-    )
-    with pytest.warns(Warning):
-        driz.add_image(
-            insci,
-            exptime=1.0,
-            pixmap=pixmap,
-            weight_map=inwht,
-            scale=pscale,
-        )
-
-    template_data = read_image(output_template)
-
-    _, med_diff, max_diff = centroid_statistics(
-        "gaussian with grid",
-        output_difference,
-        driz.out_img,
-        template_data,
-        20.0,
-        8,
-    )
-
-    assert med_diff < 1.0e-6
-    assert max_diff < 2.0e-5
-
-
-def test_lanczos_with_grid(tmpdir):
-    """
-    Test do_driz lanczos kernel with grid
-    """
-    output_difference = str(tmpdir.join('difference_lanczos_grid.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_lanczos_grid.fits')
-
-    insci = read_image(input_file)
-    inwcs = read_wcs(input_file)
-    insci = make_grid_image(insci, 64, 100.0)
-    inwht = np.ones(insci.shape, dtype=insci.dtype)
-    output_wcs = read_wcs(output_template)
-
-    pixmap = utils.calc_pixmap(
-        inwcs,
-        output_wcs,
-    )
-    pscale = utils.estimate_pixel_scale_ratio(
-        inwcs,
-        output_wcs,
-        refpix_from=inwcs.wcs.crpix,
-        refpix_to=output_wcs.wcs.crpix,
-    )
-
-    # ignore previous pscale and compute it the old way (only to make
-    # tests work with old truth files and thus to show that new API gives
-    # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
-        np.sum(output_wcs.wcs.pc**2, axis=0)[0] /
-        np.sum(inwcs.wcs.cd**2, axis=0)[0]
-    )
-
-    driz = resample.Drizzle(
-        kernel='lanczos3',
-        out_shape=output_wcs.array_shape,
-        fillval=0.0,
-    )
-    with pytest.warns(Warning):
-        driz.add_image(
-            insci,
-            exptime=1.0,
-            pixmap=pixmap,
-            weight_map=inwht,
-            scale=pscale,
-        )
-
-    template_data = read_image(output_template)
-
-    _, med_diff, max_diff = centroid_statistics(
-        "lanczos with grid",
-        output_difference,
-        driz.out_img,
-        template_data,
-        20.0,
-        8,
-    )
-    assert med_diff < 1.0e-6
-    assert max_diff < 1.0e-5
-
-
-def test_point_with_grid(tmpdir):
-    """
-    Test do_driz point kernel with grid
-    """
-    output_difference = str(tmpdir.join('difference_point_grid.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_point_grid.fits')
-
-    insci = read_image(input_file)
-    inwcs = read_wcs(input_file)
-    insci = make_grid_image(insci, 64, 100.0)
-    inwht = np.ones(insci.shape, dtype=insci.dtype)
-    output_wcs = read_wcs(output_template)
-
-    pixmap = utils.calc_pixmap(inwcs, output_wcs)
-
-    driz = resample.Drizzle(kernel='point', out_shape=output_wcs.array_shape, fillval=0.0)
-    driz.add_image(insci, exptime=1.0, pixmap=pixmap, weight_map=inwht)
-
-    template_data = read_image(output_template)
-
-    _, med_diff, max_diff = centroid_statistics(
-        "point with grid",
-        output_difference,
-        driz.out_img,
-        template_data,
-        20.0,
-        8,
-    )
-    assert med_diff < 1.0e-6
-    assert max_diff < 1.0e-5
-
-
-def test_blot_with_point(tmpdir):
-    """
-    Test do_blot with point image
-    """
-    output_difference = str(tmpdir.join('difference_blot_point.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_blot_point.fits')
-
-    outsci = read_image(input_file)
-    outwcs = read_wcs(input_file)
-    outsci = make_point_image(outsci, (500, 200), 40.0)
-    inwcs = read_wcs(output_template)
-
-    pixmap = utils.calc_pixmap(inwcs, outwcs)
-
-    # compute pscale the old way (only to make
-    # tests work with old truth files and thus to show that new API gives
-    # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
-        np.sum(inwcs.wcs.pc**2, axis=0)[0] /
-        np.sum(outwcs.wcs.cd**2, axis=0)[0]
-    )
-
-    blotted_image = resample.blot_image(
-        outsci,
-        pixmap=pixmap,
-        pix_ratio=pscale,
-        exptime=1.0,
-        output_pixel_shape=inwcs.pixel_shape,
-    )
-
-    template_data = read_image(output_template)
-
-    _, med_diff, max_diff = centroid_statistics(
-        "blot with point",
-        output_difference,
-        blotted_image,
-        template_data,
-        20.0,
-        16,
-    )
-    assert med_diff < 1.0e-6
-    assert max_diff < 1.0e-5
-
-
-def test_blot_with_default(tmpdir):
+@pytest.mark.parametrize(
+    'interpolator,test_image_type',
+    [
+        ("poly5", "point"),
+        ("default", "grid"),
+        ('lan3', "grid"),
+        ("lan5", "grid"),
+    ],
+)
+def test_blot_interpolation(tmpdir, interpolator, test_image_type):
     """
-    Test do_blot with default grid image
+    Test do_driz square kernel with point
     """
-    output_difference = str(tmpdir.join('difference_blot_default.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_blot_default.fits')
-
-    outsci = read_image(input_file)
-    outsci = make_grid_image(outsci, 64, 100.0)
-    outwcs = read_wcs(input_file)
-    inwcs = read_wcs(output_template)
-
-    pixmap = utils.calc_pixmap(inwcs, outwcs)
-
-    # compute pscale the old way (only to make
-    # tests work with old truth files and thus to show that new API gives
-    # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
-        np.sum(inwcs.wcs.pc**2, axis=0)[0] /
-        np.sum(outwcs.wcs.cd**2, axis=0)[0]
+    output_difference = str(
+        tmpdir.join(f"difference_blot_{interpolator}_{test_image_type}.txt")
     )
 
-    blotted_image = resample.blot_image(
-        outsci,
-        pixmap=pixmap,
-        pix_ratio=pscale,
-        exptime=1.0,
-        output_pixel_shape=inwcs.pixel_shape,
-    )
-
-    template_data = read_image(output_template)
-
-    _, med_diff, max_diff = centroid_statistics(
-        "blot with defaults",
-        output_difference,
-        blotted_image,
-        template_data,
-        20.0,
-        16,
-    )
-
-    assert med_diff < 1.0e-6
-    assert max_diff < 1.0e-5
-
-
-def test_blot_with_lan3(tmpdir):
-    """
-    Test do_blot with lan3 grid image
-    """
-    output_difference = str(tmpdir.join('difference_blot_lan3.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_blot_lan3.fits')
-
-    outsci = read_image(input_file)
-    outsci = make_grid_image(outsci, 64, 100.0)
-    outwcs = read_wcs(input_file)
-    inwcs = read_wcs(output_template)
+    outwcs = wcs_from_file("j8bt06nyq_flt.fits", ext=1)
+    if test_image_type == "point":
+        outsci = make_point_image(outwcs.array_shape, (500, 200), 40.0)
+        ref_fname = "reference_blot_point.fits"
+    else:
+        outsci = make_grid_image(outwcs.array_shape, 64, 100.0)
+        ref_fname = f"reference_blot_{interpolator}.fits"
+    inwcs, template_data = wcs_from_file(ref_fname, ext=1, return_data=True)
 
     pixmap = utils.calc_pixmap(inwcs, outwcs)
 
     # compute pscale the old way (only to make
     # tests work with old truth files and thus to show that new API gives
     # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
+    pscale_ratio = np.sqrt(
         np.sum(inwcs.wcs.pc**2, axis=0)[0] /
         np.sum(outwcs.wcs.cd**2, axis=0)[0]
     )
 
-    blotted_image = resample.blot_image(
-        outsci,
-        pixmap=pixmap,
-        pix_ratio=pscale,
-        exptime=1.0,
-        output_pixel_shape=inwcs.pixel_shape,
-        interp="lan3",
-    )
-
-    template_data = read_image(output_template)
-
-    _, med_diff, max_diff = centroid_statistics(
-        "blot with lan3",
-        output_difference,
-        blotted_image,
-        template_data,
-        20.0,
-        16,
-    )
-
-    assert med_diff < 1.0e-6
-    assert max_diff < 1.0e-5
-
-
-def test_blot_with_lan5(tmpdir):
-    """
-    Test do_blot with lan5 grid image
-    """
-    output_difference = str(tmpdir.join('difference_blot_lan5.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_blot_lan5.fits')
-
-    outsci = read_image(input_file)
-    outsci = make_grid_image(outsci, 64, 100.0)
-    outwcs = read_wcs(input_file)
-    inwcs = read_wcs(output_template)
-
-    pixmap = utils.calc_pixmap(inwcs, outwcs)
-
-    # compute pscale the old way (only to make
-    # tests work with old truth files and thus to show that new API gives
-    # same results when equal definitions of the pixel scale is used):
-    pscale = np.sqrt(
-        np.sum(inwcs.wcs.pc**2, axis=0)[0] /
-        np.sum(outwcs.wcs.cd**2, axis=0)[0]
-    )
+    if interpolator == "default":
+        kwargs = {}
+    else:
+        kwargs = {"interp": interpolator}
 
     blotted_image = resample.blot_image(
         outsci,
         pixmap=pixmap,
-        pix_ratio=pscale,
+        pix_ratio=pscale_ratio,
         exptime=1.0,
         output_pixel_shape=inwcs.pixel_shape,
-        interp="lan5",
+        **kwargs
     )
 
-    template_data = read_image(output_template)
-
     _, med_diff, max_diff = centroid_statistics(
-        "blot with lan5",
+        "blot with '{interpolator}' and '{test_image_type}'",
         output_difference,
         blotted_image,
         template_data,
         20.0,
         16,
     )
-
     assert med_diff < 1.0e-6
     assert max_diff < 1.0e-5
 

drizzle/tests/test_utils.py

@@ -1,11 +1,7 @@
-import os
-
 import numpy as np
 import pytest
 from numpy.testing import assert_almost_equal, assert_equal
 
-from astropy import wcs
-from astropy.io import fits
 from drizzle.utils import (
     _estimate_pixel_scale,
     calc_pixmap,
@@ -13,8 +9,7 @@ from drizzle.utils import (
     estimate_pixel_scale_ratio,
 )
 
-TEST_DIR = os.path.abspath(os.path.dirname(__file__))
-DATA_DIR = os.path.join(TEST_DIR, 'data')
+from .helpers import wcs_from_file
 
 
 def test_map_rectangular():
@@ -30,18 +25,17 @@ def test_map_rectangular():
     assert_equal(pixmap[5, 500], (500, 5))
 
 
-def test_map_to_self():
+@pytest.mark.parametrize(
+    "wcs_type", ["fits", "gwcs"]
+)
+def test_map_to_self(wcs_type):
     """
     Map a pixel array to itself. Should return the same array.
     """
-    input_file = os.path.join(DATA_DIR, 'input1.fits')
-    input_hdu = fits.open(input_file)
-
-    input_wcs = wcs.WCS(input_hdu[1].header)
-    naxis1, naxis2 = input_wcs.pixel_shape
-    input_hdu.close()
+    input_wcs = wcs_from_file("j8bt06nyq_sip_flt.fits", ext=1, wcs_type=wcs_type)
+    shape = input_wcs.array_shape
 
-    ok_pixmap = np.indices((naxis1, naxis2), dtype='float32')
+    ok_pixmap = np.indices(shape, dtype='float64')
     ok_pixmap = ok_pixmap.transpose()
 
     pixmap = calc_pixmap(input_wcs, input_wcs)
@@ -56,9 +50,10 @@ def test_map_to_self():
     pixmap = calc_pixmap(input_wcs, input_wcs, (12, 34))
     assert_equal(pixmap.shape, (12, 34, 2))
 
-    # Check that an exception is raised for WCS without pixel_shape or
+    # Check that an exception is raised for WCS without pixel_shape and
     # bounding_box:
     input_wcs.pixel_shape = None
+    input_wcs.bounding_box = None
     with pytest.raises(ValueError):
         calc_pixmap(input_wcs, input_wcs)
 
@@ -72,31 +67,31 @@ def test_map_to_self():
     assert_equal(pixmap.shape, (12, 34, 2))
 
     # from bounding box and pixel_shape (the later takes precedence):
-    input_wcs.pixel_shape = (naxis1, naxis2)
+    input_wcs.array_shape = shape
     pixmap = calc_pixmap(input_wcs, input_wcs)
     assert_equal(pixmap.shape, ok_pixmap.shape)
 
 
-def test_translated_map():
+@pytest.mark.parametrize(
+    "wcs_type", ["fits", "gwcs"]
+)
+def test_translated_map(wcs_type):
     """
     Map a pixel array to  at translated array.
     """
-    first_file = os.path.join(DATA_DIR, 'input1.fits')
-    first_hdu = fits.open(first_file)
-    first_header = first_hdu[1].header
-
-    first_wcs = wcs.WCS(first_header)
-    naxis1, naxis2 = first_wcs.pixel_shape
-    first_hdu.close()
-
-    second_file = os.path.join(DATA_DIR, 'input3.fits')
-    second_hdu = fits.open(second_file)
-    second_header = second_hdu[1].header
-
-    second_wcs = wcs.WCS(second_header)
-    second_hdu.close()
+    first_wcs = wcs_from_file(
+        "j8bt06nyq_sip_flt.fits",
+        ext=1,
+        wcs_type=wcs_type
+    )
+    second_wcs = wcs_from_file(
+        "j8bt06nyq_sip_flt.fits",
+        ext=1,
+        crpix_shift=(-2, -2),  # shift loaded WCS by adding this to CRPIX
+        wcs_type=wcs_type
+    )
 
-    ok_pixmap = np.indices((naxis1, naxis2), dtype='float32') - 2.0
+    ok_pixmap = np.indices(first_wcs.array_shape, dtype='float32') - 2.0
     ok_pixmap = ok_pixmap.transpose()
 
     pixmap = calc_pixmap(first_wcs, second_wcs)
@@ -104,31 +99,81 @@ def test_translated_map():
     # Got x-y transpose right
     assert_equal(pixmap.shape, ok_pixmap.shape)
     # Mapping an array to a translated array
-    assert_almost_equal(pixmap, ok_pixmap, decimal=5)
+    assert_almost_equal(pixmap[2:, 2:], ok_pixmap[2:, 2:], decimal=5)
 
 
-def test_estimate_pixel_scale_ratio():
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
+def test_disable_gwcs_bbox():
+    """
+    Map a pixel array to a translated version ofitself.
+    """
+    first_wcs = wcs_from_file(
+        "j8bt06nyq_sip_flt.fits",
+        ext=1,
+        wcs_type="gwcs"
+    )
+    second_wcs = wcs_from_file(
+        "j8bt06nyq_sip_flt.fits",
+        ext=1,
+        crpix_shift=(-2, -2),  # shift loaded WCS by adding this to CRPIX
+        wcs_type="gwcs"
+    )
 
-    with fits.open(input_file) as h:
-        w = wcs.WCS(h[1].header)
+    ok_pixmap = np.indices(first_wcs.array_shape, dtype='float64') - 2.0
+    ok_pixmap = ok_pixmap.transpose()
+
+    # Mapping an array to a translated array
+
+    # disable both bounding boxes:
+    pixmap = calc_pixmap(first_wcs, second_wcs, disable_bbox="both")
+    assert_almost_equal(pixmap[2:, 2:], ok_pixmap[2:, 2:], decimal=5)
+    assert np.all(np.isfinite(pixmap[:2, :2]))
+    assert np.all(np.isfinite(pixmap[-2:, -2:]))
+    # check bbox was restored
+    assert first_wcs.bounding_box is not None
+    assert second_wcs.bounding_box is not None
+
+    # disable "from" bounding box:
+    pixmap = calc_pixmap(second_wcs, first_wcs, disable_bbox="from")
+    assert_almost_equal(pixmap[:-2, :-2], ok_pixmap[:-2, :-2] + 4.0, decimal=5)
+    assert np.all(np.logical_not(np.isfinite(pixmap[-2:, -2:])))
+    # check bbox was restored
+    assert first_wcs.bounding_box is not None
+    assert second_wcs.bounding_box is not None
+
+    # disable "to" bounding boxes:
+    pixmap = calc_pixmap(first_wcs, second_wcs, disable_bbox="to")
+    assert_almost_equal(pixmap[2:, 2:], ok_pixmap[2:, 2:], decimal=5)
+    assert np.all(np.isfinite(pixmap[:2, :2]))
+    assert np.all(pixmap[:2, :2] < 0.0)
+    assert np.all(np.isfinite(pixmap[-2:, -2:]))
+    # check bbox was restored
+    assert first_wcs.bounding_box is not None
+    assert second_wcs.bounding_box is not None
+
+    # enable all bounding boxes:
+    pixmap = calc_pixmap(first_wcs, second_wcs, disable_bbox="none")
+    assert_almost_equal(pixmap[2:, 2:], ok_pixmap[2:, 2:], decimal=5)
+    assert np.all(np.logical_not(np.isfinite(pixmap[:2, :2])))
+    # check bbox was restored
+    assert first_wcs.bounding_box is not None
+    assert second_wcs.bounding_box is not None
 
-    pscale = estimate_pixel_scale_ratio(w, w, w.wcs.crpix, (0, 0))
 
+def test_estimate_pixel_scale_ratio():
+    w = wcs_from_file("j8bt06nyq_flt.fits", ext=1)
+    pscale = estimate_pixel_scale_ratio(w, w, w.wcs.crpix, (0, 0))
     assert abs(pscale - 0.9999999916964737) < 1.0e-9
 
 
 def test_estimate_pixel_scale_no_refpix():
     # create a WCS without higher order (polynomial) distortions:
-    fits_file = os.path.join(DATA_DIR, 'input1.fits')
-    with fits.open(fits_file) as h:
-        w = wcs.WCS(h[1].header, h)
-        w.sip = None
-        w.det2im1 = None
-        w.det2im2 = None
-        w.cpdis1 = None
-        w.cpdis2 = None
-        pixel_shape = w.pixel_shape[:]
+    w = wcs_from_file("j8bt06nyq_sip_flt.fits", ext=1)
+    w.sip = None
+    w.det2im1 = None
+    w.det2im2 = None
+    w.cpdis1 = None
+    w.cpdis2 = None
+    pixel_shape = w.pixel_shape[:]
 
     ref_pscale = _estimate_pixel_scale(w, w.wcs.crpix)
 

drizzle/utils.py

@@ -7,7 +7,7 @@ __all__ = ["calc_pixmap", "decode_context", "estimate_pixel_scale_ratio"]
 _DEG2RAD = math.pi / 180.0
 
 
-def calc_pixmap(wcs_from, wcs_to, shape=None):
+def calc_pixmap(wcs_from, wcs_to, shape=None, disable_bbox="to"):
     """
     Calculate a discretized on a grid mapping between the pixels of two images
     using provided WCS of the original ("from") image and the destination ("to")
@@ -35,6 +35,14 @@ def calc_pixmap(wcs_from, wcs_to, shape=None):
         ``numpy.ndarray`` order. When provided, it takes precedence over the
         ``wcs_from.array_shape`` property.
 
+    disable_bbox : {"to", "from", "both", "none"}, optional
+        Indicates whether to use or not to use the bounding box of either
+        (both) ``wcs_from`` or (and) ``wcs_to`` when computing pixel map. When
+        ``disable_bbox`` is "none", pixel coordinates outside of the bounding
+        box are set to `NaN` only if ``wcs_from`` or (and) ``wcs_to`` sets
+        world coordinates to NaN when input pixel coordinates are outside of
+        the bounding box.
+
     Returns
     -------
     pixmap : numpy.ndarray
@@ -57,16 +65,39 @@ def calc_pixmap(wcs_from, wcs_to, shape=None):
     If ``bounding_box`` is not available, a `ValueError` will be raised.
 
     """
+    if (bbox_from := getattr(wcs_from, "bounding_box", None)) is not None:
+        try:
+            # to avoid dependency on astropy just to check whether
+            # the bounding box is an instance of
+            # modeling.bounding_box.ModelBoundingBox, we try to
+            # directly use and bounding_box(order='F') and if it fails,
+            # fall back to converting the bounding box to a tuple
+            # (of intervals):
+            bbox_from = bbox_from.bounding_box(order='F')
+        except AttributeError:
+            bbox_from = tuple(bbox_from)
+
+    if (bbox_to := getattr(wcs_to, "bounding_box", None)) is not None:
+        try:
+            # to avoid dependency on astropy just to check whether
+            # the bounding box is an instance of
+            # modeling.bounding_box.ModelBoundingBox, we try to
+            # directly use and bounding_box(order='F') and if it fails,
+            # fall back to converting the bounding box to a tuple
+            # (of intervals):
+            bbox_to = bbox_to.bounding_box(order='F')
+        except AttributeError:
+            bbox_to = tuple(bbox_to)
+
     if shape is None:
         shape = wcs_from.array_shape
-        if shape is None:
-            if (bbox := getattr(wcs_from, "bounding_box", None)) is not None:
-                if (nd := np.ndim(bbox)) == 1:
-                    bbox = (bbox, )
-                if nd > 1:
-                    shape = tuple(
-                        int(math.ceil(lim[1] + 0.5)) for lim in bbox[::-1]
-                    )
+        if shape is None and bbox_from is not None:
+            if (nd := np.ndim(bbox_from)) == 1:
+                bbox_from = (bbox_from, )
+            if nd > 1:
+                shape = tuple(
+                    int(math.ceil(lim[1] + 0.5)) for lim in bbox_from[::-1]
+                )
 
     if shape is None:
         raise ValueError(
@@ -74,7 +105,22 @@ def calc_pixmap(wcs_from, wcs_to, shape=None):
         )
 
     y, x = np.indices(shape, dtype=np.float64)
-    x, y = wcs_to.world_to_pixel_values(*wcs_from.pixel_to_world_values(x, y))
+
+    # temporarily disable the bounding box for the "from" WCS:
+    if disable_bbox in ["from", "both"] and bbox_from is not None:
+        wcs_from.bounding_box = None
+    if disable_bbox in ["to", "both"] and bbox_to is not None:
+        wcs_to.bounding_box = None
+    try:
+        x, y = wcs_to.world_to_pixel_values(
+            *wcs_from.pixel_to_world_values(x, y)
+        )
+    finally:
+        if bbox_from is not None:
+            wcs_from.bounding_box = bbox_from
+        if bbox_to is not None:
+            wcs_to.bounding_box = bbox_to
+
     pixmap = np.dstack([x, y])
     return pixmap
 

{drizzle-2.0.0.dist-info → drizzle-2.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: drizzle
-Version: 2.0.0
+Version: 2.0.1
 Summary: A package for combining dithered images into a single image
 Author-email: STScI <help@stsci.edu>
 License: Copyright (C) 2011,2014 Association of Universities for Research in
@@ -43,18 +43,19 @@ Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.rst
 Requires-Dist: numpy
-Requires-Dist: astropy
-Provides-Extra: docs
-Requires-Dist: sphinx ; extra == 'docs'
-Requires-Dist: sphinx-automodapi ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
-Requires-Dist: matplotlib ; extra == 'docs'
-Requires-Dist: pytest-doctestplus ; extra == 'docs'
-Requires-Dist: tomli ; (python_version < "3.11") and extra == 'docs'
 Provides-Extra: test
-Requires-Dist: pytest ; extra == 'test'
-Requires-Dist: pytest-cov ; extra == 'test'
-Requires-Dist: pytest-doctestplus ; extra == 'test'
+Requires-Dist: astropy; extra == "test"
+Requires-Dist: gwcs; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-doctestplus; extra == "test"
+Provides-Extra: docs
+Requires-Dist: tomli; python_version < "3.11" and extra == "docs"
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-automodapi; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: matplotlib; extra == "docs"
+Requires-Dist: pytest-doctestplus; extra == "docs"
 
 drizzle Documentation
 =====================

drizzle-2.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+drizzle-2.0.1.dist-info/RECORD,,
+drizzle-2.0.1.dist-info/WHEEL,sha256=VujM3ypTCyUW6hcTDdK2ej0ARVMxlU1Djlh_zWnDgqk,109
+drizzle-2.0.1.dist-info/LICENSE.rst,sha256=zbEvAxiq9xY9gvf78KeZaARrnOsTcqC9FeOC6tg8VbA,1474
+drizzle-2.0.1.dist-info/top_level.txt,sha256=MA5uqwTj1sJBi-hCeQj9v3-sZ9nVUTe6bd_zGWTKy5A,8
+drizzle-2.0.1.dist-info/METADATA,sha256=Gdz6feRphBOFDmd0DPNR6Kw5E17xJFxXOyzhp5X_ZDo,10691
+drizzle/resample.py,sha256=mm1g_AiLhIS4Rz3ksqSyRr9g7V-Rjv8CribzMSs6sM0,28280
+drizzle/util.py,sha256=dmaA4MtbUKZa-KTLosDsYG3nuVWCWkqRMCL8zqRf8II,811
+drizzle/__init__.py,sha256=oKjebdSpXrrHeytrwme-CcDlxqSXpED5P8GxUkYLmV0,313
+drizzle/cdrizzle.cpython-312-darwin.so,sha256=0tpzpf-ylYdddq1RPUpXbcKbphknJlqd5ZwEgmfh-Y4,151200
+drizzle/utils.py,sha256=RTDJgedsN2vS1ngdf0r3dmq-xyQi1h-fq6DbKnqNSc8,10561
+drizzle/tests/test_utils.py,sha256=G6TzJSILzZCqgpkQwvSzyO5SLfEjR8aQbLiUE2TlTd4,7453
+drizzle/tests/test_overlap_calc.py,sha256=HJPdD5waKM7j4iz8qT38mJyCQDVtb8CzGfgRUpjFQIk,6800
+drizzle/tests/test_cdrizzle.py,sha256=KnK6l8CZ7HxGx2OlziYtAsOMka3PebP-sLJuOIOMTAw,697
+drizzle/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drizzle/tests/test_resample.py,sha256=lP4xia9O9EoPoZhFIopcr82WKMEuhftPg6ipRFDY5Zg,30500
+drizzle/tests/helpers.py,sha256=EpErKWlt7agxPODzGHZgmr08A1Ou1LTsHXTMtmzpwqM,5697

{drizzle-2.0.0.dist-info → drizzle-2.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-macosx_11_0_arm64
 

drizzle-2.0.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-drizzle-2.0.0.dist-info/RECORD,,
-drizzle-2.0.0.dist-info/WHEEL,sha256=T94HOVPNbYE6jyG6QmiIglWJ01nwJvHIWFgubY8hhjc,109
-drizzle-2.0.0.dist-info/LICENSE.rst,sha256=zbEvAxiq9xY9gvf78KeZaARrnOsTcqC9FeOC6tg8VbA,1474
-drizzle-2.0.0.dist-info/top_level.txt,sha256=MA5uqwTj1sJBi-hCeQj9v3-sZ9nVUTe6bd_zGWTKy5A,8
-drizzle-2.0.0.dist-info/METADATA,sha256=qcK15S6z6SyVHihtf5rksL29AhbesMaq32utR6dRfh4,10648
-drizzle/resample.py,sha256=HJD6l2xo9_VoYbWCAEbez5qKBYrGxoTPMuOGWwVnBmw,28280
-drizzle/util.py,sha256=dmaA4MtbUKZa-KTLosDsYG3nuVWCWkqRMCL8zqRf8II,811
-drizzle/__init__.py,sha256=oKjebdSpXrrHeytrwme-CcDlxqSXpED5P8GxUkYLmV0,313
-drizzle/cdrizzle.cpython-312-darwin.so,sha256=ATKETt5Cuo__LdMJF23bN3Jepw-doNh7YImcwNpA654,151200
-drizzle/utils.py,sha256=uyAPOQ7LbwT9IJ4O4NYj8luoDpsVS2iOOMBcj74dPvc,8537
-drizzle/tests/test_utils.py,sha256=0QdI24l6z2H1UdPabmNe3BwgTSA8b1_xHzRFhgEkV_c,5696
-drizzle/tests/test_overlap_calc.py,sha256=HJPdD5waKM7j4iz8qT38mJyCQDVtb8CzGfgRUpjFQIk,6800
-drizzle/tests/test_cdrizzle.py,sha256=KnK6l8CZ7HxGx2OlziYtAsOMka3PebP-sLJuOIOMTAw,697
-drizzle/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-drizzle/tests/test_resample.py,sha256=ke_A5htg9ez77ehsKjKn5hSjwDbat4_Vz0GI6IqPB7w,39577