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

drizzle/tests/test_utils.py

@@ -0,0 +1,238 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_almost_equal, assert_equal
+
+from drizzle.utils import (
+    _estimate_pixel_scale,
+    calc_pixmap,
+    decode_context,
+    estimate_pixel_scale_ratio,
+)
+
+from .helpers import wcs_from_file
+
+
+def test_map_rectangular():
+    """
+    Make sure the initial index array has correct values
+    """
+    naxis1 = 1000
+    naxis2 = 10
+
+    pixmap = np.indices((naxis1, naxis2), dtype='float32')
+    pixmap = pixmap.transpose()
+
+    assert_equal(pixmap[5, 500], (500, 5))
+
+
+@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_wcs = wcs_from_file("j8bt06nyq_sip_flt.fits", ext=1, wcs_type=wcs_type)
+    shape = input_wcs.array_shape
+
+    ok_pixmap = np.indices(shape, dtype='float64')
+    ok_pixmap = ok_pixmap.transpose()
+
+    pixmap = calc_pixmap(input_wcs, input_wcs)
+
+    # Got x-y transpose right
+    assert_equal(pixmap.shape, ok_pixmap.shape)
+
+    # Mapping an array to itself
+    assert_almost_equal(pixmap, ok_pixmap, decimal=5)
+
+    # user-provided shape
+    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 and
+    # bounding_box:
+    input_wcs.pixel_shape = None
+    input_wcs.bounding_box = None
+    with pytest.raises(ValueError):
+        calc_pixmap(input_wcs, input_wcs)
+
+    # user-provided shape when array_shape is not set:
+    pixmap = calc_pixmap(input_wcs, input_wcs, (12, 34))
+    assert_equal(pixmap.shape, (12, 34, 2))
+
+    # from bounding box:
+    input_wcs.bounding_box = ((5.3, 33.5), (2.8, 11.5))
+    pixmap = calc_pixmap(input_wcs, input_wcs)
+    assert_equal(pixmap.shape, (12, 34, 2))
+
+    # from bounding box and pixel_shape (the later takes precedence):
+    input_wcs.array_shape = shape
+    pixmap = calc_pixmap(input_wcs, input_wcs)
+    assert_equal(pixmap.shape, ok_pixmap.shape)
+
+
+@pytest.mark.parametrize(
+    "wcs_type", ["fits", "gwcs"]
+)
+def test_translated_map(wcs_type):
+    """
+    Map a pixel array to  at translated array.
+    """
+    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(first_wcs.array_shape, dtype='float32') - 2.0
+    ok_pixmap = ok_pixmap.transpose()
+
+    pixmap = calc_pixmap(first_wcs, second_wcs)
+
+    # Got x-y transpose right
+    assert_equal(pixmap.shape, ok_pixmap.shape)
+    # Mapping an array to a translated array
+    assert_almost_equal(pixmap[2:, 2:], ok_pixmap[2:, 2:], decimal=5)
+
+
+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"
+    )
+
+    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
+
+
+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:
+    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)
+
+    if hasattr(w, 'bounding_box'):
+        del w.bounding_box
+    pscale1 = _estimate_pixel_scale(w, None)
+    assert np.allclose(ref_pscale, pscale1, atol=0.0, rtol=1.0e-8)
+
+    w.bounding_box = None
+    w.pixel_shape = None
+    pscale2 = _estimate_pixel_scale(w, None)
+    assert np.allclose(pscale1, pscale2, atol=0.0, rtol=1.0e-8)
+
+    w.pixel_shape = pixel_shape
+    pscale3 = _estimate_pixel_scale(w, None)
+    assert np.allclose(pscale1, pscale3, atol=0.0, rtol=1.0e-14)
+
+    w.bounding_box = ((-0.5, pixel_shape[0] - 0.5), (-0.5, pixel_shape[1] - 0.5))
+    pscale4 = _estimate_pixel_scale(w, None)
+    assert np.allclose(pscale3, pscale4, atol=0.0, rtol=1.0e-8)
+
+
+def test_decode_context():
+    ctx = np.array(
+        [[[0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 36196864, 0, 0],
+          [0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 0, 0, 0],
+          [0, 0, 537920000, 0, 0, 0]],
+         [[0, 0, 0, 0, 0, 0,],
+          [0, 0, 0, 67125536, 0, 0],
+          [0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 0, 0, 0],
+          [0, 0, 163856, 0, 0, 0]],
+         [[0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 8203, 0, 0],
+          [0, 0, 0, 0, 0, 0],
+          [0, 0, 0, 0, 0, 0],
+          [0, 0, 32865, 0, 0, 0]]],
+        dtype=np.int32
+    )
+
+    idx1, idx2 = decode_context(ctx, [3, 2], [1, 4])
+
+    assert sorted(idx1) == [9, 12, 14, 19, 21, 25, 37, 40, 46, 58, 64, 65, 67, 77]
+    assert sorted(idx2) == [9, 20, 29, 36, 47, 49, 64, 69, 70, 79]
+
+    # context array must be 3D:
+    with pytest.raises(ValueError):
+        decode_context(ctx[0], [3, 2], [1, 4])
+
+    # pixel coordinates must be integer:
+    with pytest.raises(ValueError):
+        decode_context(ctx, [3.0, 2], [1, 4])
+
+    # coordinate lists must be equal in length:
+    with pytest.raises(ValueError):
+        decode_context(ctx, [3, 2], [1, 4, 5])
+
+    # coordinate lists must be 1D:
+    with pytest.raises(ValueError):
+        decode_context(ctx, [[3, 2]], [[1, 4]])

drizzle/util.py

@@ -1,138 +1,15 @@
-import numpy as np
+"""
+Module ``util`` has been deprecated.
+"""
+import warnings
 
-
-def find_keyword_extn(fimg, keyword, value=None):
-    """
-    This function will return the index of the extension in a multi-extension
-    FITS file which contains the desired keyword with the given value.
-
-    Parameters
-    ----------
-
-    fimg : hdulist
-        A list of header data units
-
-    keyword : str
-        The keyword to search for
-
-    value : str or number, optional
-        If set, the value the keyword must have to match
-
-    Returns
-    -------
-
-    The index of the extension
-    """
-
-    i = 0
-    extnum = -1
-    # Search through all the extensions in the FITS object
-    for chip in fimg:
-        hdr = chip.header
-        # Check to make sure the extension has the given keyword
-        if keyword in hdr:
-            if value is not None:
-                # If it does, then does the value match the desired value
-                # MUST use 'str.strip' to match against any input string!
-                if hdr[keyword].strip() == value:
-                    extnum = i
-                    break
-            else:
-                extnum = i
-                break
-        i += 1
-    # Return the index of the extension which contained the
-    # desired EXTNAME value.
-    return extnum
-
-
-def get_extn(fimg, extn=''):
-    """
-    Returns the FITS extension corresponding to extension specified in
-    filename. Defaults to returning the first extension with data or the
-    primary extension, if none have data.
-
-    Parameters
-    ----------
-
-    fimg : hdulist
-        A list of header data units
-
-    extn : str
-        The extension name and version to match
-
-    Returns
-    -------
-
-    The matching header data unit
-    """
-
-    if extn:
-        try:
-            _extn = parse_extn(extn)
-            if _extn[0]:
-                _e = fimg.index_of(_extn)
-            else:
-                _e = _extn[1]
-
-        except KeyError:
-            _e = None
-
-        if _e is None:
-            _extn = None
-        else:
-            _extn = fimg[_e]
-
-    else:
-        # If no extension is provided, search for first extension
-        # in FITS file with data associated with it.
-
-        # Set up default to point to PRIMARY extension.
-        _extn = fimg[0]
-        # then look for first extension with data.
-        for _e in fimg:
-            if _e.data is not None:
-                _extn = _e
-                break
-
-    return _extn
-
-
-def get_keyword(fimg, keyword, default=None):
-    """
-    Return a keyword value from the header of an image,
-    or the default if the keyword is not found.
-
-    Parameters
-    ----------
-
-    fimg : hdulist
-        A list of header data units
-
-    keyword : hdulist
-        The keyword value to search for
-
-    default : str or number, optional
-        The default value if not found
-
-    Returns
-    -------
-
-    The value if found or default if not
-    """
-
-    value = None
-    if keyword:
-        _nextn = find_keyword_extn(fimg, keyword)
-        try:
-            value = fimg[_nextn].header[keyword]
-        except KeyError:
-            value = None
-
-    if value is None and default is not None:
-        value = default
-
-    return value
+warnings.warn(
+    "Module 'drizzle.util' has been deprecated since version 2.0.0 "
+    "and it will be removed in a future release. "
+    "Please replace calls to 'util.is_blank()' with alternative "
+    "implementation.",
+    DeprecationWarning
+)
 
 
 def is_blank(value):
@@ -141,116 +18,17 @@ def is_blank(value):
 
     Parameters
     ----------
-
     value : str
         The value to check
 
     Returns
     -------
-
     True or False
     """
+    warnings.warn(
+        "'is_blank()' has been deprecated since version 2.0.0 "
+        "and it will be removed in a future release. "
+        "Please replace calls to 'is_blank()' with alternative implementation.",
+        DeprecationWarning
+    )
     return value.strip() == ""
-
-
-def parse_extn(extn=''):
-    """
-    Parse a string representing a qualified fits extension name as in the
-    output of parse_filename and return a tuple (str(extname), int(extver)),
-    which can be passed to pyfits functions using the 'ext' kw.
-    Default return is the first extension in a fits file.
-
-    Examples
-    --------
-        >>> parse_extn('sci,2')
-        ('sci', 2)
-        >>> parse_extn('2')
-        ('', 2)
-        >>> parse_extn('sci')
-        ('sci', 1)
-
-    Parameters
-    ----------
-    extn : str
-        The extension name
-
-    Returns
-    -------
-    A tuple of the extension name and value
-    """
-    if not extn:
-        return ('', 0)
-
-    try:
-        lext = extn.split(',')
-    except Exception:
-        return ('', 1)
-
-    if len(lext) == 1 and lext[0].isdigit():
-        return ("", int(lext[0]))
-    elif len(lext) == 2:
-        return (lext[0], int(lext[1]))
-    else:
-        return (lext[0], 1)
-
-
-def parse_filename(filename):
-    """
-    Parse out filename from any specified extensions.
-    Returns rootname and string version of extension name.
-
-    Parameters
-    ----------
-
-    filename : str
-        The filename to be parsed
-
-    Returns
-    -------
-
-    A tuple with the filename root and extension
-    """
-    # Parse out any extension specified in filename
-    _indx = filename.find('[')
-    if _indx > 0:
-        # Read extension name provided
-        _fname = filename[:_indx]
-        _extn = filename[_indx + 1:-1]
-    else:
-        _fname = filename
-        _extn = ''
-
-    return _fname, _extn
-
-
-def set_pscale(the_wcs):
-    """
-    Calculates the plate scale from cdelt and the pc  matrix and adds
-    it to the WCS. Plate scale is not part of the WCS standard, but is
-    required by the drizzle code
-
-    Parameters
-    ----------
-
-    the_wcs : wcs
-        A WCS object
-    """
-    try:
-        cdelt = the_wcs.wcs.get_cdelt()
-        pc = the_wcs.wcs.get_pc()
-
-    except Exception:
-        try:
-            # for non-celestial axes, get_cdelt doesnt work
-            cdelt = the_wcs.wcs.cd * the_wcs.wcs.cdelt
-        except AttributeError:
-            cdelt = the_wcs.wcs.cdelt
-
-        try:
-            pc = the_wcs.wcs.pc
-        except AttributeError:
-            pc = 1
-
-    pccd = np.array(cdelt * pc)
-    scales = np.sqrt((pccd ** 2).sum(axis=0, dtype=float))
-    the_wcs.pscale = scales[0]