drizzle 2.0.1__tar.gz → 2.1.1__tar.gz

{drizzle-2.0.1 → drizzle-2.1.1}/.github/workflows/build.yml

@@ -8,7 +8,7 @@ on:
 
 jobs:
   build:
-    uses: OpenAstronomy/github-actions-workflows/.github/workflows/publish.yml@v1
+    uses: OpenAstronomy/github-actions-workflows/.github/workflows/publish.yml@v2
     with:
       upload_to_pypi: ${{ (github.event_name == 'release') && (github.event.action == 'released') }}
       targets: |

{drizzle-2.0.1 → drizzle-2.1.1}/.github/workflows/ci.yml

@@ -17,18 +17,23 @@ concurrency:
 
 jobs:
   test:
-    uses: OpenAstronomy/github-actions-workflows/.github/workflows/tox.yml@v1
+    uses: OpenAstronomy/github-actions-workflows/.github/workflows/tox.yml@v2
     with:
       envs: |
         - linux: check-style
         - linux: check-security
         - linux: py310-xdist
         - linux: py311-xdist
-        - linux: py313-xdist
-        - macos: py312-xdist
-        - windows: py312-xdist
-        - linux: py312-xdist-cov
+        - 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
-        - linux: py312-xdist-devdeps
+        - 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.1 → drizzle-2.1.1}/CHANGES.rst

@@ -4,6 +4,43 @@
 Release Notes
 =============
 
+
+2.1.1 (2025-08-14)
+==================
+
+- Fix a bug in the Cython code for ``tdriz()`` due to which the code would
+  raise an error for sub-second exposure times. [#192]
+
+- Fixed a numerical instability in the new and old "boxer" algorithm in #175
+  (withdrawn release 2.1.0). [#191]
+
+
+2.1.0 (2025-02-20; withdrawn)
+=============================
+
+- Restored faster "boxer" overlap for square kernel, improving resample speed;
+  optimized and simplified related code. [#175]
+
+
+2.1.1 (unreleased)
+==================
+
+- Fixed a bug in polygon intersection algorithm that could result in
+  incorrect output when the input polygons have nearly collinear edges. [#194]
+
+
+2.0.2 (unreleased)
+==================
+
+- Fixed 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)
 ==================
 
@@ -23,7 +60,7 @@ Release Notes
 - 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.1/drizzle.egg-info → drizzle-2.1.1}/PKG-INFO

@@ -1,40 +1,8 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: drizzle
-Version: 2.0.1
+Version: 2.1.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
-        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/
@@ -56,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
 =====================
@@ -108,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
@@ -200,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.1 → drizzle-2.1.1}/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.1 → drizzle-2.1.1}/drizzle/resample.py

@@ -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.0.1 → drizzle-2.1.1}/drizzle/tests/helpers.py

@@ -56,40 +56,71 @@ def wcs_from_file(filename, ext=None, return_data=False, crpix_shift=None,
     """
     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):
+
+    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 = 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
+        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
 

{drizzle-2.0.1 → drizzle-2.1.1}/drizzle/tests/test_overlap_calc.py

@@ -260,3 +260,27 @@ def test_intersection_case01():
     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)