drizzle 2.2.0__cp313-cp313-win_amd64.whl

drizzle/tests/helpers.py

@@ -0,0 +1,215 @@
+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)
+
+    def get_shape(hdr):
+        naxis1 = hdr.get("WCSNAX1", hdr.get("NAXIS1"))
+        naxis2 = hdr.get("WCSNAX2", hdr.get("NAXIS2"))
+        if naxis1 is None or naxis2 is None:
+            return None
+        return (naxis2, naxis1)
+
+    def data_from_hdr(hdr, data=None, shape=None):
+        if data is not None:
+            return data
+        bitpix = hdr.get("BITPIX", -32)
+        dtype = fits.hdu.BITPIX2DTYPE[bitpix]
+        shape = get_shape(hdr) or shape
+        if shape is None:
+            return None
+        return np.zeros(shape, dtype=dtype)
+
+    if os.path.splitext(filename)[1] in [".hdr", ".txt"]:
+        hdul = None
+        hdr = fits.Header.fromfile(path, sep="\n", endcard=False, padding=False)
+
+    else:
+        with fits.open(path) as fits_hdul:
+            hdul = fits.HDUList([hdu.copy() for hdu in fits_hdul])
+
+        if ext is None and hdul is not None:
+            for k, u in enumerate(hdul):
+                if "CTYPE1" in u.header:
+                    ext = k
+                    break
+
+        hdr = hdul[ext].header
+
+    if crpix_shift is not None and "CRPIX1" in hdr:
+        hdr["CRPIX1"] += crpix_shift[0]
+        hdr["CRPIX2"] += crpix_shift[1]
+
+    # this is to avoid warnings about naxis mismatch
+    # "FITSFixedWarning: The WCS transformation has more axes (2) than the
+    # image it is associated with (0)" which, unfortunately, we cannot turn off.
+    if hdul and hdul[ext].data is None:
+        hdul[ext].data = np.empty(get_shape(hdr)[::-1], dtype=np.float32)
+
+    result = fits_wcs.WCS(hdr, hdul)
+
+    shape = get_shape(hdr)
+    result.array_shape = shape
+
+    if wcs_type == "gwcs":
+        result = _gwcs_from_hst_fits_wcs(result)
+
+    if return_data:
+        if hdul is None:
+            data = data_from_hdr(hdr, data=None, shape=shape)
+            return (result, data)
+
+        result = (result,)
+        if not isinstance(return_data, (list, tuple)):
+            return_data = [ext]
+        for ext in return_data:
+            data = data_from_hdr(hdul[ext].header, data=hdul[ext].data, shape=shape)
+            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_cdrizzle.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+from drizzle import cdrizzle
+
+
+def test_cdrizzle():
+    """
+    Call C unit tests for cdrizzle, which are in the src/tests directory
+    """
+
+    size = 100
+    data = np.zeros((size, size), dtype="float32")
+    weights = np.ones((size, size), dtype="float32")
+
+    pixmap = np.indices((size, size), dtype="float64")
+    pixmap = pixmap.transpose()
+
+    output_data = np.zeros((size, size), dtype="float32")
+    output_counts = np.zeros((size, size), dtype="float32")
+    output_context = np.zeros((size, size), dtype="int32")
+
+    cdrizzle.test_cdrizzle(
+        data,
+        weights,
+        pixmap,
+        output_data,
+        output_counts,
+        output_context,
+    )

drizzle/tests/test_overlap_calc.py

@@ -0,0 +1,287 @@
+from itertools import product
+from math import sqrt
+
+import numpy as np
+import pytest
+
+from drizzle.cdrizzle import clip_polygon, invert_pixmap
+
+SQ2 = 1.0 / sqrt(2.0)
+
+
+def _is_poly_eq(p1, p2, rtol=0, atol=4e-12):
+    if len(p1) != len(p2):
+        return False
+
+    p1 = p1[:]
+    for _ in p1:
+        p1.append(p1.pop(0))
+        if np.allclose(p1, p2, rtol=rtol, atol=atol):
+            return True
+    return False
+
+
+def _coord_mapping(xin, yin):
+    crpix = (289, 348)  # center of distortions
+    shift = (1000, 1000)
+    rmat = 2.0 * np.array([[0.78103169, 0.66712321], [-0.63246699, 0.74091539]])
+    x = xin - crpix[0]
+    y = yin - crpix[1]
+
+    # add non-linear distortions
+    x += 2.4e-6 * x**2 - 1.0e-7 * x * y + 3.1e-6 * y**2
+    y += 1.2e-6 * x**2 - 2.0e-7 * x * y + 1.1e-6 * y**2
+
+    x, y = np.dot(rmat, [x, y])
+    x += shift[0]
+    y += shift[1]
+
+    return x, y
+
+
+def _roll_vertices(polygon, n=1):
+    n = n % len(polygon)
+    return polygon[n:] + polygon[:n]
+
+
+def test_invert_pixmap():
+    yin, xin = np.indices((1000, 1200), dtype=float)
+    xin = xin.flatten()
+    yin = yin.flatten()
+
+    xout, yout = _coord_mapping(xin, yin)
+    xout = xout.reshape((1000, 1200))
+    yout = yout.reshape((1000, 1200))
+    pixmap = np.dstack([xout, yout])
+
+    test_coords = [
+        (300, 600),
+        (0, 0),
+        (1199, 999),
+        (0, 999),
+        (1199, 0),
+        (200, 0),
+        (0, 438),
+        (1199, 432),
+    ]
+
+    for xr, yr in test_coords:
+        xout_t, yout_t = _coord_mapping(xr, yr)
+        xyin = invert_pixmap(pixmap, [xout_t, yout_t], [[-0.5, 1199.5], [-0.5, 999.5]])
+        assert np.allclose(xyin, [xr, yr], atol=0.05)
+
+
+def test_invert_small_pixmap():
+    yin, xin = np.indices((2, 2), dtype=float)
+    pixmap = np.dstack([xin, yin])
+
+    test_coords = list(product(*(2 * [[-0.5, 1.5]])))
+
+    for xr, yr in test_coords:
+        xyin = invert_pixmap(pixmap, [xr, yr], [[-0.5, 1.5], [-0.5, 1.5]])
+        assert np.allclose(xyin, [xr, yr], atol=0.05)
+
+
+def test_poly_intersection_with_self():
+    p = [(0, 0), (1, 0), (1, 1), (0, 1)]
+
+    for k in range(4):
+        q = _roll_vertices(p, k)
+
+        pq = clip_polygon(q, p)
+        assert _is_poly_eq(pq, q)
+
+
+@pytest.mark.parametrize(
+    "shift",
+    [(0.25, 0.1), (-0.25, -0.1), (-0.25, 0.1), (0.25, -0.1)],
+)
+def test_poly_intersection_shifted(shift):
+    p = [(0, 0), (1, 0), (1, 1), (0, 1)]
+    sx, sy = shift
+    pq_ref = sorted(
+        [
+            (max(0, sx), max(0, sy)),
+            (min(1, sx + 1), max(0, sy)),
+            (min(1, sx + 1), min(1, sy + 1)),
+            (max(0, sx), min(1, sy + 1)),
+        ],
+    )
+
+    for k in range(4):
+        q = [(x + sx, y + sy) for x, y in p]
+        q = _roll_vertices(q, k)
+        pq = clip_polygon(q, p)
+        assert np.allclose(sorted(pq), pq_ref)
+
+
+@pytest.mark.parametrize(
+    "shift",
+    [(0, 70), (70, 0), (0, -70), (-70, 0)],
+)
+def test_poly_intersection_shifted_large(shift):
+    p = [(-0.5, -0.5), (99.5, -0.5), (99.5, 99.5), (-0.5, 99.5)]
+    sx, sy = shift
+    pq_ref = sorted(
+        [
+            (max(-0.5, -0.5 + sx), max(-0.5, -0.5 + sy)),
+            (min(99.5, 99.5 + sx), max(-0.5, -0.5 + sy)),
+            (min(99.5, 99.5 + sx), min(99.5, 99.5 + sy)),
+            (max(-0.5, -0.5 + sx), min(99.5, 99.5 + sy)),
+        ],
+    )
+
+    for k in range(4):
+        q = [(x + sx, y + sy) for x, y in p]
+        q = _roll_vertices(q, k)
+        pq = clip_polygon(p, q)
+        assert len(pq) == 4
+        assert np.allclose(sorted(pq), pq_ref)
+
+
+def test_poly_intersection_rotated45():
+    p = [(0, 0), (1, 0), (1, 1), (0, 1)]
+    q = [(0, 0), (SQ2, -SQ2), (2.0 * SQ2, 0), (SQ2, SQ2)]
+    pq_ref = [(0, 0), (SQ2, SQ2), (1, 0), (1, SQ2 / (1.0 + SQ2))]
+
+    for k in range(4):
+        q = _roll_vertices(q, k)
+        pq = clip_polygon(p, q)
+        assert np.allclose(sorted(pq), pq_ref)
+
+
+@pytest.mark.parametrize(
+    "axis",
+    [0, 1],
+)
+def test_poly_intersection_flipped_axis(axis):
+    p = [(0, 0), (1, 0), (1, 1), (0, 1)]
+    # (flipped wrt X-axis or Y-axis). Also change direction:
+    if axis == 0:
+        q = [(i, -j) for i, j in p][::-1]
+    else:
+        q = [(-i, j) for i, j in p][::-1]
+
+    for k in range(4):
+        q = _roll_vertices(q, k)
+        pq = clip_polygon(p, q)
+        assert len(pq) == 0
+
+
+def test_poly_intersection_reflect_origin():
+    p = [(0, 0), (1, 0), (1, 1), (0, 1)]
+    # reflect wrt origin:
+    q = [(-i, -j) for i, j in p]
+
+    for k in range(4):
+        q = _roll_vertices(q, k)
+        pq = clip_polygon(p, q)
+        assert not pq
+
+
+@pytest.mark.parametrize(
+    "q,small",
+    [
+        ([(0.1, 0.1), (0.9, 0.1), (0.9, 0.9), (0.1, 0.9)], True),
+        ([(0.0, 0.0), (1.0, 0.0), (1.0, 0.4), (0.0, 0.4)], True),
+        ([(-0.1, -0.1), (1.1, -0.1), (1.1, 1.1), (-0.1, 1.1)], False),
+    ],
+)
+def test_poly_includes_the_other(q, small):
+    wnd = [(0, 0), (1, 0), (1, 1), (0, 1)]
+
+    for k in range(4):
+        q = _roll_vertices(q, k)
+        qp = clip_polygon(q, wnd)
+
+        assert _is_poly_eq(qp, q if small else wnd)
+
+
+@pytest.mark.parametrize(
+    "q",
+    [
+        [(0, 0), (1, 0), (0.5, 0.6)],
+        [(0.1, 0), (0.9, 0), (0.5, 0.6)],
+    ],
+)
+def test_poly_triangle_common_side(q):
+    p = [(0, 0), (1, 0), (1, 1), (0, 1)]
+    sq = sorted(q)
+
+    for k in range(3):
+        q = _roll_vertices(q, k)
+        pq = clip_polygon(p, q)
+        assert np.allclose(sq, sorted(pq))
+
+
+def test_poly_triangle_common_side_lg():
+    p = [(0, 0), (1, 0), (1, 1), (0, 1)]
+    q = [(-0.1, 0), (1.1, 0), (0.5, 0.6)]
+    ref_pq = [(0, 0), (0, 0.1), (0.5, 0.6), (1, 0), (1, 0.1)]
+
+    for k in range(3):
+        q = _roll_vertices(q, k)
+        pq = clip_polygon(p, q)
+        assert np.allclose(ref_pq, sorted(pq))
+
+
+def test_poly_intersection_with_self_extra_vertices():
+    p = [(0, 0), (1, 0), (1, 1), (0, 1)]
+    p_ref = [(0, 0), (0, 1), (1, 0), (1, 1)]
+    # Q is same as P with extra vertices places along P's edges
+    q = [(0, 0), (0.5, 0), (1, 0), (1, 0.4), (1, 1), (0.7, 1), (0, 1), (0, 0.2)]
+
+    for k in range(4):
+        q = _roll_vertices(q, k)
+
+        pq = clip_polygon(p, q)
+        assert sorted(pq) == p_ref
+
+        pq = clip_polygon(q, p)
+        assert sorted(pq) == p_ref
+
+
+def test_intersection_case01():
+    # a real case of failure of the code from PR #104
+    p = [
+        (4517.377385, 8863.424319),
+        (5986.279535, 12966.888023),
+        (1917.908619, 14391.538506),
+        (453.893145, 10397.019260),
+    ]
+
+    wnd = [(-0.5, -0.5), (5224.5, -0.5), (5224.5, 15999.5), (-0.5, 15999.5)]
+
+    cp_ref = [
+        (4517.377385, 8863.424319),
+        (5224.5, 10838.812526396974),
+        (5224.5, 13233.64580022457),
+        (1917.908619, 14391.538506),
+        (453.893145, 10397.01926),
+    ]
+
+    cp = clip_polygon(p, wnd)
+
+    assert _is_poly_eq(cp, cp_ref)
+
+
+def test_intersection_case02():
+    # a real case of failure reported in #189
+    p = [
+        (-0.04000000000000009104, 1.5),
+        (2.73499999999999943157, 1.5),
+        (1.83500000000000018652, -0.5),
+        (-0.03999999999999998002, -0.5),
+    ]
+    wnd = [(-0.5, -0.5), (3.5, -0.5), (3.5, 3.5), (-0.5, 3.5)]
+
+    cp_ref = [
+        (-0.04, 1.5),
+        (-0.04, -0.5),
+        (1.835, -0.5),
+        (2.735, 1.5),
+    ]
+
+    cp = clip_polygon(p, wnd)
+
+    assert _is_poly_eq(cp, cp_ref)