drizzle 2.0.0__tar.gz → 2.1.0__tar.gz

drizzle-2.1.0/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - '*.x'
+    tags:
+      - "*"
+  pull_request:
+  schedule:
+    - cron: '0 6 * * 1'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    uses: OpenAstronomy/github-actions-workflows/.github/workflows/tox.yml@v1
+    with:
+      envs: |
+        - linux: check-style
+        - linux: check-security
+        - linux: py310-xdist
+        - linux: py311-xdist
+        - linux: py312-xdist
+        # `tox` does not currently respect `requires-python` versions when creating testing environments;
+        # if this breaks, add an upper pin to `requires-python` and revert this py3 to the latest working version
+        - linux: py3-cov-xdist
+          coverage: codecov
+        - macos: py3-xdist
+        - windows: py3-xdist
+          # exclude Python 1.13.4, see https://github.com/python/cpython/issues/135151
+          python-version: '>=3.13.5 <3.14'
+        - linux: py3-devdeps-xdist
+      toxdeps: tox-uv
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

{drizzle-2.0.0 → drizzle-2.1.0}/CHANGES.rst

@@ -4,16 +4,39 @@
 Release Notes
 =============
 
+
+2.0.2 (unreleased)
+==================
+
+- Fix a bug in ``resample.Drizzle`` due to which initially, before adding
+  the first image, ``Drizzle.output_img`` is not filled with ``NaN`` when
+  ``fillval`` is either ``INDEF``, ``NAN``, ``None`` *and* the ``Drizzle``
+  object was initialized with ``out_img=None``. [#170]
+
+- Fixes a crash when ``Drizzle`` is initialized with ``disable_ctx``
+  set to ``True``. [#180]
+
+
+2.0.1 (2025-01-28)
+==================
+
+- Update ``utils.calc_pixmap`` code to be ready for upcoming changes in GWCS
+  due to which inverse WCS transformations will respect bounding box by
+  allowing the caller of ``utils.calc_pixmap`` to disable the bounding box(es)
+  on both or one of the input WCS when computing the pixel map. [#164]
+
+
 2.0.0 (2024-10-23)
 ==================
 
-- Backward incompatible major re-design of API. Backward compatibility was
+- Backward incompatible major re-design of API to make the code I/O agnostic.
+  Removed FITS-specific code. Backward compatibility was
   maintained with JWST and Roman pipelines only. [#134]
 
 - Deprecated module ``util``. New software should not import from this
   module as it will be removed in a future release. [#134]
 
-- Bug fix: exposure time was undefined when in_units were not cps. [#134]
+- Bug fix: exposure time was undefined when ``in_units`` were not "cps". [#134]
 
 - BUG FIX: ``cdrizzle.tdriz`` signature was out of date. [#134]
 

{drizzle-2.0.0/drizzle.egg-info → drizzle-2.1.0}/PKG-INFO

@@ -1,40 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: drizzle
-Version: 2.0.0
+Version: 2.1.0
 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
-        Astronomy (AURA)
-        
-        Redistribution and use in source and binary forms, with or without
-        modification, are permitted provided that the following conditions
-        are met:
-        
-            1. Redistributions of source code must retain the above
-              copyright notice, this list of conditions and the following
-              disclaimer.
-        
-            2. Redistributions in binary form must reproduce the above
-              copyright notice, this list of conditions and the following
-              disclaimer in the documentation and/or other materials
-              provided with the distribution.
-        
-            3. The name of AURA and its representatives may not be used to
-              endorse or promote products derived from this software without
-              specific prior written permission.
-        
-        THIS SOFTWARE IS PROVIDED BY AURA ``AS IS'' AND ANY EXPRESS OR
-        IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-        WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-        ARE DISCLAIMED. IN NO EVENT SHALL AURA BE LIABLE FOR ANY DIRECT,
-        INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-        (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-        HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-        STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-        ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-        OF THE POSSIBILITY OF SUCH DAMAGE.
-        
 Project-URL: Homepage, https://github.com/spacetelescope/drizzle
 Project-URL: Bug Tracker, https://github.com/spacetelescope/drizzle/issues
 Project-URL: Documentation, http://spacetelescope.github.io/drizzle/
@@ -43,8 +11,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.rst
 Requires-Dist: numpy
-Requires-Dist: astropy
 Provides-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"
@@ -55,6 +24,7 @@ Requires-Dist: sphinx-automodapi; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Requires-Dist: matplotlib; extra == "docs"
 Requires-Dist: pytest-doctestplus; extra == "docs"
+Dynamic: license-file
 
 drizzle Documentation
 =====================
@@ -107,8 +77,8 @@ Requirements
 The Drizzle Algorithm
 ---------------------
 
-This section has been extracted from Chapter 2 of
-`The DrizzlePac Handbook <http://www.stsci.edu/hst/HST_overview/drizzlepac/documents/handbooks/drizzlepac.pdf>`_ [Driz2012]_
+This section has been extracted from Chapter 3 of
+`The DrizzlePac Handbook <https://hst-docs.stsci.edu/drizzpac>`_ [Driz2025]_
 
 There are a family of linear reconstruction techniques that, at two opposite
 extremes, are represented by the interlacing and shift-and-add techniques, with
@@ -199,4 +169,4 @@ for identifying cosmic rays in the original image. Blot requires the user
 to provide the world coordinate system (WCS)-based transformations in the
 form of a pixel map array as input.
 
-.. [Driz2012] Gonzaga, S., Hack, W., Fruchter, A., Mack, J., eds. 2012, The DrizzlePac Handbook. (Baltimore, STScI)
+.. [Driz2025] Anand, G. S., Mack, J., et al., 2025, “The DrizzlePac Handbook”, Version 3.0, (Baltimore: STScI)

{drizzle-2.0.0 → drizzle-2.1.0}/README.rst

@@ -49,8 +49,8 @@ Requirements
 The Drizzle Algorithm
 ---------------------
 
-This section has been extracted from Chapter 2 of
-`The DrizzlePac Handbook <http://www.stsci.edu/hst/HST_overview/drizzlepac/documents/handbooks/drizzlepac.pdf>`_ [Driz2012]_
+This section has been extracted from Chapter 3 of
+`The DrizzlePac Handbook <https://hst-docs.stsci.edu/drizzpac>`_ [Driz2025]_
 
 There are a family of linear reconstruction techniques that, at two opposite
 extremes, are represented by the interlacing and shift-and-add techniques, with
@@ -141,4 +141,4 @@ for identifying cosmic rays in the original image. Blot requires the user
 to provide the world coordinate system (WCS)-based transformations in the
 form of a pixel map array as input.
 
-.. [Driz2012] Gonzaga, S., Hack, W., Fruchter, A., Mack, J., eds. 2012, The DrizzlePac Handbook. (Baltimore, STScI)
+.. [Driz2025] Anand, G. S., Mack, J., et al., 2025, “The DrizzlePac Handbook”, Version 3.0, (Baltimore: STScI)

{drizzle-2.0.0 → drizzle-2.1.0}/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",
@@ -76,23 +76,24 @@ class Drizzle:
     information about which input image has contributed to the corresponding
     pixel in the resampled data array. Context image uses 32 bit integers to
     encode this information and hence it can keep track of only 32 input images.
-    First bit corresponds to the first input image, second bit corrsponds to the
-    second input image, and so on. We call this (0-indexed) order "context ID"
-    which is represented by the ``ctx_id`` parameter/property. If the number of
+    The first bit corresponds to the first input image, the second bit
+    corresponds to the second input image, and so on.
+    We call this (0-indexed) order "context ID" which is represented by
+    the ``ctx_id`` parameter/property. If the number of
     input images exceeds 32, then it is necessary to have multiple context
-    images ("planes") to hold information about all input images with the first
+    images ("planes") to hold information about all input images, with the first
     plane encoding which of the first 32 images contributed to the output data
-    pixel, second plane representing next 32 input images (number 33-64), etc.
-    For this reason, context array is either a 2D array (if the total number
-    of resampled images is less than 33) of the type `numpy.int32` and shape
-    ``(ny, nx)`` or a a 3D array of shape ``(np, ny, nx)`` where ``nx`` and
-    ``ny`` are dimensions of image's data. ``np`` is the number of "planes"
-    equal to ``(number of input images - 1) // 32 + 1``. If a bit at position
-    ``k`` in a pixel with coordinates ``(p, y, x)`` is 0 then input image number
-    ``32 * p + k`` (0-indexed) did not contribute to the output data pixel
-    with array coordinates ``(y, x)`` and if that bit is 1 then input image
-    number ``32 * p + k`` did contribute to the pixel ``(y, x)`` in the
-    resampled image.
+    pixel, the second plane representing next 32 input images (number 33-64),
+    etc. For this reason, context array is either a 2D array (if the total
+    number of resampled images is less than 33) of the type `numpy.int32` and
+    shape ``(ny, nx)`` or a a 3D array of shape ``(np, ny, nx)`` where ``nx``
+    and ``ny`` are dimensions of the image data. ``np`` is the number of
+    "planes" computed as ``(number of input images - 1) // 32 + 1``. If a bit at
+    position ``k`` in a pixel with coordinates ``(p, y, x)`` is 0, then input
+    image number ``32 * p + k`` (0-indexed) did not contribute to the output
+    data pixel with array coordinates ``(y, x)`` and if that bit is 1, then
+    input image number ``32 * p + k`` did contribute to the pixel ``(y, x)``
+    in the resampled image.
 
     As an example, let's assume we have 8 input images. Then, when ``out_ctx``
     pixel values are displayed using binary representation (and decimal in
@@ -413,7 +414,11 @@ class Drizzle:
                     )
 
         if out_img is None:
-            self._out_img = np.zeros(out_shape, dtype=np.float32)
+            if self._fillval.upper() in ["INDEF", "NAN"]:
+                fillval = np.nan
+            else:
+                fillval = float(self._fillval)
+            self._out_img = np.full(out_shape, fillval, dtype=np.float32)
         else:
             self._out_img = out_img
 
@@ -548,7 +553,7 @@ class Drizzle:
 
             self._alloc_output_arrays(
                 out_shape=self._out_shape,
-                max_ctx_id=max(self._max_ctx_id, self._ctx_id),
+                max_ctx_id=self._max_ctx_id,
                 out_img=None,
                 out_wht=None,
                 out_ctx=None,

drizzle-2.1.0/drizzle/tests/helpers.py

@@ -0,0 +1,221 @@
+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]
+
+    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