drizzle 1.15.3__cp312-cp312-win32.whl → 2.0.0__cp312-cp312-win32.whl

drizzle/tests/test_drizzle.py

@@ -1,834 +0,0 @@
-import math
-import os
-import pytest
-
-import numpy as np
-from astropy import wcs
-from astropy.io import fits
-
-from drizzle import drizzle, cdrizzle
-
-TEST_DIR = os.path.abspath(os.path.dirname(__file__))
-DATA_DIR = os.path.join(TEST_DIR, 'data')
-ok = False
-
-
-def bound_image(image):
-    """
-    Compute region where image is non-zero
-    """
-    coords = np.nonzero(image)
-    ymin = coords[0].min()
-    ymax = coords[0].max()
-    xmin = coords[1].min()
-    xmax = coords[1].max()
-    return (ymin, ymax, xmin, xmax)
-
-
-def centroid(image, size, center):
-    """
-    Compute the centroid of a rectangular area
-    """
-    ylo = int(center[0] - size / 2)
-    yhi = min(ylo + size, image.shape[0])
-    xlo = int(center[1] - size / 2)
-    xhi = min(xlo + size, image.shape[1])
-
-    yx1 = np.mgrid[ylo:yhi, xlo:xhi, 1:2]
-    center = (yx1[..., 0] * image[ylo:yhi, xlo:xhi]).sum(
-        axis=(1, 2),
-        dtype=np.float64,
-    )
-
-    if center[2] == 0.0:
-        return None
-
-    center[0] /= center[2]
-    center[1] /= center[2]
-    return center
-
-
-def centroid_close(list_of_centroids, size, point):
-    """
-    Find if any centroid is close to a point
-    """
-    for i in range(len(list_of_centroids) - 1, -1, -1):
-        if (abs(list_of_centroids[i][0] - point[0]) < int(size / 2) and
-                abs(list_of_centroids[i][1] - point[1]) < int(size / 2)):
-            return 1
-
-    return 0
-
-
-def centroid_compare(centroid):
-    return centroid[1]
-
-
-def centroid_distances(image1, image2, amp, size):
-    """
-    Compute a list of centroids and the distances between them in two images
-    """
-    distances = []
-    list_of_centroids = centroid_list(image2, amp, size)
-    for center2 in list_of_centroids:
-        center1 = centroid(image1, size, center2)
-        if center1 is None:
-            continue
-
-        disty = center2[0] - center1[0]
-        distx = center2[1] - center1[1]
-        dist = math.sqrt(disty * disty + distx * distx)
-        dflux = abs(center2[2] - center1[2])
-        distances.append([dist, dflux, center1, center2])
-
-    distances.sort(key=centroid_compare)
-    return distances
-
-
-def centroid_list(image, amp, size):
-    """
-    Find the next centroid
-    """
-    list_of_centroids = []
-    points = np.transpose(np.nonzero(image > amp))
-    for point in points:
-        if not centroid_close(list_of_centroids, size, point):
-            center = centroid(image, size, point)
-            list_of_centroids.append(center)
-
-    return list_of_centroids
-
-
-def centroid_statistics(title, fname, image1, image2, amp, size):
-    """
-    write centroid statistics to compare differences btw two images
-    """
-    stats = ("minimum", "median", "maximum")
-    images = (None, None, image1, image2)
-    im_type = ("", "", "test", "reference")
-
-    diff = []
-    distances = centroid_distances(image1, image2, amp, size)
-    indexes = (0, int(len(distances) / 2), len(distances) - 1)
-    fd = open(fname, 'w')
-    fd.write("*** %s ***\n" % title)
-
-    if len(distances) == 0:
-        diff = [0.0, 0.0, 0.0]
-        fd.write("No matches!!\n")
-
-    elif len(distances) == 1:
-        diff = [distances[0][0], distances[0][0], distances[0][0]]
-
-        fd.write("1 match\n")
-        fd.write("distance = %f flux difference = %f\n" %
-                 (distances[0][0], distances[0][1]))
-
-        for j in range(2, 4):
-            ylo = int(distances[0][j][0]) - 1
-            yhi = int(distances[0][j][0]) + 2
-            xlo = int(distances[0][j][1]) - 1
-            xhi = int(distances[0][j][1]) + 2
-            subimage = images[j][ylo:yhi,xlo:xhi]
-            fd.write("\n%s image centroid = (%f,%f) image flux = %f\n" %
-                     (im_type[j], distances[0][j][0], distances[0][j][1],
-                      distances[0][j][2]))
-            fd.write(str(subimage) + "\n")
-
-    else:
-        fd.write("%d matches\n" % len(distances))
-
-        for k in range(0,3):
-            i = indexes[k]
-            diff.append(distances[i][0])
-            fd.write("\n%s distance = %f flux difference = %f\n" %
-                     (stats[k],distances[i][0], distances[i][1]))
-
-            for j in range(2, 4):
-                ylo = int(distances[i][j][0]) - 1
-                yhi = int(distances[i][j][0]) + 2
-                xlo = int(distances[i][j][1]) - 1
-                xhi = int(distances[i][j][1]) + 2
-                subimage = images[j][ylo:yhi,xlo:xhi]
-                fd.write("\n%s %s image centroid = (%f,%f) image flux = %f\n" %
-                         (stats[k], im_type[j], distances[i][j][0],
-                          distances[i][j][1], distances[i][j][2]))
-                fd.write(str(subimage) + "\n")
-
-    fd.close()
-    return tuple(diff)
-
-
-def make_point_image(input_image, point, value):
-    """
-    Create an image with a single point set
-    """
-    output_image = np.zeros(input_image.shape, dtype=input_image.dtype)
-    output_image[point] = value
-    return output_image
-
-
-def make_grid_image(input_image, spacing, value):
-    """
-    Create an image with points on a grid set
-    """
-    output_image = np.zeros(input_image.shape, dtype=input_image.dtype)
-
-    shape = output_image.shape
-    half_space = int(spacing / 2)
-    for y in range(half_space, shape[0], spacing):
-        for x in range(half_space, shape[1], spacing):
-            output_image[y,x] = value
-
-    return output_image
-
-
-def print_wcs(title, wcs):
-    """
-    Print the wcs header cards
-    """
-    print("=== %s ===" % title)
-    print(wcs.to_header_string())
-
-
-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_square_with_point(tmpdir):
-    """
-    Test do_driz square kernel with point
-    """
-    output = str(tmpdir.join('output_square_point.fits'))
-    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')
-
-    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)
-
-    driz = drizzle.Drizzle(outwcs=output_wcs, wt_scl="")
-    driz.add_image(insci, inwcs, inwht=inwht)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("square with point",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           template_data, 20.0, 8)
-
-        assert med_diff < 1.0e-6
-        assert max_diff < 1.0e-5
-
-
-@pytest.mark.parametrize(
-    'kernel', ['square', 'point', 'turbo', 'gaussian', 'lanczos3'],
-)
-def test_zero_input_weight(kernel):
-    """
-    Test do_driz square kernel with grid
-    """
-    # initialize input:
-    insci = np.ones((200, 400), dtype=np.float32)
-    inwht = np.ones((200, 400), dtype=np.float32)
-    inwht[:, 150:155] = 0
-
-    # initialize output:
-    outsci = np.zeros((210, 410), dtype=np.float32)
-    outwht = np.zeros((210, 410), dtype=np.float32)
-    outctx = np.zeros((210, 410), dtype=np.int32)
-
-    # define coordinate mapping:
-    pixmap = np.moveaxis(np.mgrid[1:201, 1:401][::-1], 0, -1)
-
-    # resample:
-    cdrizzle.tdriz(
-        insci, inwht, pixmap,
-        outsci, outwht, outctx,
-        uniqid=1,
-        xmin=0, xmax=400,
-        ymin=0, ymax=200,
-        pixfrac=1,
-        kernel=kernel,
-        in_units='cps',
-        expscale=1,
-        wtscale=1,
-        fillstr='INDEF',
-    )
-
-    # check that no pixel with 0 weight has any counts:
-    assert np.sum(np.abs(outsci[(outwht == 0)])) == 0.0
-
-
-def test_square_with_grid(tmpdir):
-    """
-    Test do_driz square kernel with grid
-    """
-    output = str(tmpdir.join('output_square_grid.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=output_wcs, wt_scl="")
-    driz.add_image(insci, inwcs, inwht=inwht)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("square with grid",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           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 = str(tmpdir.join('output_turbo_grid.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=output_wcs, wt_scl="", kernel='turbo')
-    driz.add_image(insci, inwcs, inwht=inwht)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("turbo with grid",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           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 = str(tmpdir.join('output_gaussian_grid.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=output_wcs, wt_scl="", kernel='gaussian')
-    driz.add_image(insci, inwcs, inwht=inwht)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("gaussian with grid",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           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 = str(tmpdir.join('output_lanczos_grid.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=output_wcs, wt_scl="", kernel='lanczos3')
-    driz.add_image(insci, inwcs, inwht=inwht)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("lanczos with grid",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           template_data, 20.0, 8)
-        assert med_diff < 1.0e-6
-        assert max_diff < 1.0e-5
-
-
-def test_tophat_with_grid(tmpdir):
-    """
-    Test do_driz tophat kernel with grid
-    """
-    output = str(tmpdir.join('output_tophat_grid.fits'))
-    output_difference = str(tmpdir.join('difference_tophat_grid.txt'))
-
-    input_file = os.path.join(DATA_DIR, 'j8bt06nyq_flt.fits')
-    output_template = os.path.join(DATA_DIR, 'reference_tophat_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)
-
-    driz = drizzle.Drizzle(outwcs=output_wcs, wt_scl="", kernel='tophat')
-    driz.add_image(insci, inwcs, inwht=inwht)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("tophat with grid",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           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 = str(tmpdir.join('output_point_grid.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=output_wcs, wt_scl="", kernel='point')
-    driz.add_image(insci, inwcs, inwht=inwht)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("point with grid",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           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 = str(tmpdir.join('output_blot_point.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=outwcs)
-    driz.outsci = outsci
-
-    driz.blot_image(inwcs)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("blot with point",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           template_data, 20.0, 16)
-        assert med_diff < 1.0e-6
-        assert max_diff < 1.0e-5
-
-
-def test_blot_with_default(tmpdir):
-    """
-    Test do_blot with default grid image
-    """
-    output = str(tmpdir.join('output_blot_default.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=outwcs)
-    driz.outsci = outsci
-
-    driz.blot_image(inwcs)
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("blot with defaults",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           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 = str(tmpdir.join('output_blot_lan3.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=outwcs)
-    driz.outsci = outsci
-
-    driz.blot_image(inwcs, interp="lan3")
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("blot with lan3",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           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 = str(tmpdir.join('output_blot_lan5.fits'))
-    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)
-
-    driz = drizzle.Drizzle(outwcs=outwcs)
-    driz.outsci = outsci
-
-    driz.blot_image(inwcs, interp="lan5")
-
-    if ok:
-        driz.write(output_template)
-    else:
-        driz.write(output)
-        template_data = read_image(output_template)
-
-        min_diff, med_diff, max_diff = centroid_statistics("blot with lan5",
-                                                           output_difference,
-                                                           driz.outsci,
-                                                           template_data, 20.0, 16)
-        assert med_diff < 1.0e-6
-        assert max_diff < 1.0e-5
-
-
-def test_context_planes():
-    """Reproduce error seen in issue #50"""
-    shape = [10, 10]
-    outwcs = wcs.WCS()
-    outwcs.pixel_shape = shape
-    driz = drizzle.Drizzle(outwcs=outwcs)
-
-    image = np.ones(shape)
-    inwcs = wcs.WCS()
-    inwcs.pixel_shape = shape
-
-    for i in range(32):
-        driz.add_image(image, inwcs)
-    assert driz.outcon.shape == (1, 10, 10)
-
-    driz.add_image(image, inwcs)
-    assert driz.outcon.shape == (2, 10, 10)
-
-
-@pytest.mark.parametrize(
-    'kernel',
-    [
-        'square',
-        'point',
-        'turbo',
-        pytest.param(
-            'lanczos2',
-            marks=pytest.mark.xfail(reason='Not a flux-conserving kernel'),
-        ),
-        pytest.param(
-            'lanczos3',
-            marks=pytest.mark.xfail(reason='Not a flux-conserving kernel'),
-        ),
-        pytest.param(
-            'gaussian',
-            marks=pytest.mark.xfail(reason='Not a flux-conserving kernel'),
-        ),
-    ],
-)
-def test_flux_conservation_nondistorted(kernel):
-    n = 200
-    in_shape = (n, n)
-
-    # input coordinate grid:
-    y, x = np.indices(in_shape, dtype=np.float64)
-
-    # simulate a gaussian "star":
-    fwhm = 2.9
-    x0 = 50.0
-    y0 = 68.0
-    sig = fwhm / (2.0 * np.sqrt(2.0 * np.log(2.0 * fwhm)))
-    sig2 = sig * sig
-    star = np.exp(-0.5 / sig2 * ((x.astype(np.float32) - x0)**2 + (y.astype(np.float32) - y0)**2))
-    in_sci = (star / np.sum(star)).astype(np.float32)  # normalize to 1
-    in_wht = np.ones(in_shape, dtype=np.float32)
-
-    # linear shift:
-    xp = x + 0.5
-    yp = y + 0.2
-
-    pixmap = np.dstack([xp, yp])
-
-    out_shape = (int(yp.max()) + 1, int(xp.max()) + 1)
-    # make sure distorion is not moving flux out of the image towards negative
-    # coordinates (just because of the simple way of how we account for output
-    # image size)
-    assert np.min(xp) > -0.5 and np.min(yp) > -0.5
-
-    out_sci = np.zeros(out_shape, dtype=np.float32)
-    out_ctx = np.zeros(out_shape, dtype=np.int32)
-    out_wht = np.zeros(out_shape, dtype=np.float32)
-
-    cdrizzle.tdriz(
-        in_sci,
-        in_wht,
-        pixmap,
-        out_sci,
-        out_wht,
-        out_ctx,
-        pixfrac=1.0,
-        scale=1.0,
-        kernel=kernel,
-        in_units="cps",
-        expscale=1.0,
-        wtscale=1.0,
-    )
-
-    assert np.allclose(
-        np.sum(out_sci * out_wht),
-        np.sum(in_sci),
-        atol=0.0,
-        rtol=0.0001,
-    )
-
-@pytest.mark.parametrize(
-    'kernel',
-    [
-        'square',
-        'point',
-        'turbo',
-        pytest.param(
-            'lanczos2',
-            marks=pytest.mark.xfail(reason='Not a flux-conserving kernel'),
-        ),
-        pytest.param(
-            'lanczos3',
-            marks=pytest.mark.xfail(reason='Not a flux-conserving kernel'),
-        ),
-        pytest.param(
-            'gaussian',
-            marks=pytest.mark.xfail(reason='Not a flux-conserving kernel'),
-        ),
-    ],
-)
-def test_flux_conservation_distorted(kernel):
-    n = 200
-    in_shape = (n, n)
-
-    # input coordinate grid:
-    y, x = np.indices(in_shape, dtype=np.float64)
-
-    # simulate a gaussian "star":
-    fwhm = 2.9
-    x0 = 50.0
-    y0 = 68.0
-    sig = fwhm / (2.0 * np.sqrt(2.0 * np.log(2.0 * fwhm)))
-    sig2 = sig * sig
-    star = np.exp(-0.5 / sig2 * ((x.astype(np.float32) - x0)**2 + (y.astype(np.float32) - y0)**2))
-    in_sci = (star / np.sum(star)).astype(np.float32)  # normalize to 1
-    in_wht = np.ones(in_shape, dtype=np.float32)
-
-    # linear shift:
-    xp = x + 0.5
-    yp = y + 0.2
-    # add distortion:
-    xp += 1e-4 * x**2 + 1e-5 * x * y
-    yp += 1e-3 * y**2 - 2e-5 * x * y
-
-    pixmap = np.dstack([xp, yp])
-
-    out_shape = (int(yp.max()) + 1, int(xp.max()) + 1)
-    # make sure distorion is not moving (pixels with) flux out of the image
-    # towards negative coordinates (just because of the simple way of how we
-    # account for output image size):
-    assert np.min(xp) > -0.5 and np.min(yp) > -0.5
-
-    out_sci = np.zeros(out_shape, dtype=np.float32)
-    out_ctx = np.zeros(out_shape, dtype=np.int32)
-    out_wht = np.zeros(out_shape, dtype=np.float32)
-
-    cdrizzle.tdriz(
-        in_sci,
-        in_wht,
-        pixmap,
-        out_sci,
-        out_wht,
-        out_ctx,
-        pixfrac=1.0,
-        scale=1.0,
-        kernel=kernel,
-        in_units="cps",
-        expscale=1.0,
-        wtscale=1.0,
-    )
-
-    assert np.allclose(
-        np.sum(out_sci * out_wht),
-        np.sum(in_sci),
-        atol=0.0,
-        rtol=0.0001,
-    )
-
-
-def test_no_context_array():
-    """
-    Test that providing None for "outctx" is supported.
-    """
-    # initialize input:
-    insci = np.ones((200, 400), dtype=np.float32)
-    inwht = np.ones((200, 400), dtype=np.float32)
-    inwht[:, 150:155] = 0
-
-    # initialize output:
-    outsci = np.zeros((210, 410), dtype=np.float32)
-    outwht = np.zeros((210, 410), dtype=np.float32)
-    outctx = None
-
-    # define coordinate mapping:
-    pixmap = np.moveaxis(np.mgrid[1:201, 1:401][::-1], 0, -1)
-
-    # resample:
-    cdrizzle.tdriz(
-        insci, inwht, pixmap,
-        outsci, outwht, outctx,
-        uniqid=1,
-        xmin=0, xmax=400,
-        ymin=0, ymax=200,
-        pixfrac=1,
-        kernel='square',
-        in_units='cps',
-        expscale=1,
-        wtscale=1,
-        fillstr='INDEF',
-    )
-
-    # check that no pixel with 0 weight has any counts:
-    assert np.sum(np.abs(outsci[(outwht == 0)])) == 0.0