drizzle 2.1.0__tar.gz → 2.1.1__tar.gz

{drizzle-2.1.0 → 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.1.0 → drizzle-2.1.1}/.github/workflows/ci.yml

@@ -17,7 +17,7 @@ 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

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

@@ -5,10 +5,34 @@ 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)
 ==================
 
-- Fix a bug in ``resample.Drizzle`` due to which initially, before adding
+- 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]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drizzle
-Version: 2.1.0
+Version: 2.1.1
 Summary: A package for combining dithered images into a single image
 Author-email: STScI <help@stsci.edu>
 Project-URL: Homepage, https://github.com/spacetelescope/drizzle

{drizzle-2.1.0 → 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)

{drizzle-2.1.0 → drizzle-2.1.1}/drizzle/tests/test_resample.py

@@ -286,6 +286,7 @@ def test_drizzle_defaults():
     assert driz.out_img[1, 2] == 1
     assert (driz.out_img[2, 1] - 2.0) < 1.0e-14
 
+
 @pytest.mark.parametrize(
     'kernel,test_image_type,max_diff_atol',
     [
@@ -355,7 +356,10 @@ def test_resample_kernel(tmpdir, kernel, test_image_type, max_diff_atol):
             scale=pscale_ratio,
         )
     else:
-        with pytest.warns(Warning):
+        with pytest.warns(
+            Warning,
+            match=f"Kernel '{kernel}' is not a flux-conserving kernel"
+        ):
             driz.add_image(
                 insci,
                 exptime=1.0,
@@ -486,7 +490,10 @@ def test_zero_input_weight(kernel, fc):
             fillstr='INDEF',
         )
     else:
-        with pytest.warns(Warning):
+        with pytest.warns(
+            Warning,
+            match=f"Kernel '{kernel}' is not a flux-conserving kernel"
+        ):
             cdrizzle.tdriz(
                 insci,
                 inwht,
@@ -760,7 +767,10 @@ def test_flux_conservation_nondistorted(kernel, fc):
             wtscale=1.0,
         )
     else:
-        with pytest.warns(Warning):
+        with pytest.warns(
+            Warning,
+            match=f"Kernel '{kernel}' is not a flux-conserving kernel"
+        ):
             cdrizzle.tdriz(
                 in_sci,
                 in_wht,
@@ -848,7 +858,10 @@ def test_flux_conservation_distorted(kernel, fc):
             wtscale=1.0,
         )
     else:
-        with pytest.warns(Warning):
+        with pytest.warns(
+            Warning,
+            match=f"Kernel '{kernel}' is not a flux-conserving kernel"
+        ):
             cdrizzle.tdriz(
                 in_sci,
                 in_wht,
@@ -1138,7 +1151,7 @@ def test_resample_get_shape_from_pixmap():
         exptime=0.0,
     )
 
-    driz.add_image(in_sci, weight_map=in_wht, exptime=1.0, pixmap=pixmap)
+    driz.add_image(in_sci, weight_map=in_wht, exptime=0.1, pixmap=pixmap)
     assert driz.out_img.shape == in_shape
 
 
@@ -1223,3 +1236,115 @@ def test_nan_fillval(fillval):
     )
 
     assert np.all(np.isnan(driz.out_img))
+
+
+def test_resample_edge_sgarea_bug():
+    """
+    Test from https://github.com/spacetelescope/drizzle/issues/187
+
+    """
+    pixmap = (np.array([
+        [
+            [0.31887051, 1.],
+            [1.01898591, 1.],
+            [1.71909665, 1.],
+        ],
+        [
+            [0.31591881, 0.],
+            [1.0160342312345672, 0.],
+            [1.716145, 0.],
+        ]
+    ], dtype="f8"))
+
+    in_shape = pixmap.shape[:2]
+    img = np.full(in_shape, 42, dtype=np.float32)
+    out_shape = (4, 4)
+
+    driz = resample.Drizzle(
+        kernel='square',
+        fillval='nan',
+        out_shape=out_shape,
+        disable_ctx=True,
+    )
+
+    driz.add_image(
+        img,
+        exptime=11.776,
+        in_units='cps',
+        pixfrac=1.0,
+        pixmap=pixmap,
+        scale=1.0,
+        wht_scale=1.0,
+    )
+    # expected pixels should be close to 42
+    np.testing.assert_allclose(driz.out_img[:2, :3], img[0, 0], rtol=1e-6)
+
+    # other values should be nan
+    np.testing.assert_equal(driz.out_img[:, 3:], np.nan)
+    np.testing.assert_equal(driz.out_img[2:], np.nan)
+
+
+def test_resample_edge_collinear():
+    """
+    Test that resample does not crash when the input image is smaller than the
+    output image, and the edges of the two images are nearly collinear.
+
+    Test based on the example from
+    https://github.com/spacetelescope/drizzle/issues/189#issue-3196294879
+
+    """
+    pixmap = (np.array([
+        [
+            [0.31, 1.0],
+            [1.01, 1.0],
+            [2.01, 1.0],
+        ],
+        [
+            [0.31, 0.],
+            [1.01, 0.],
+            [1.71, 0.],
+        ]
+    ], dtype="f8"))
+
+    in_shape = pixmap.shape[:2]
+    img = np.full(in_shape, np.pi, dtype=np.float32)
+    in_flux = np.sum(img)
+    out_shape = (4, 4)
+
+    driz = resample.Drizzle(
+        kernel='square',
+        fillval='nan',
+        out_shape=out_shape,
+        disable_ctx=True,
+    )
+
+    driz.add_image(
+        img,
+        exptime=11.776,
+        in_units='cps',
+        pixfrac=1.0,
+        pixmap=pixmap,
+        scale=1.0,
+        wht_scale=1.0,
+    )
+
+    out_flux = np.nansum(driz.out_img * driz.out_wht)
+
+    # Given this pixmap, the entire input image should fit within the output
+    # image. There should be at least 7 pixels with finite values in the output
+    # image. We can get more than 7 pixels with finite values due to rounding
+    # errors when computing polygon intersections (those "extra" pixels should)
+    # have very small weights.
+    assert np.sum(driz.out_wht > 1e-30) == 7
+    assert np.sum(np.isfinite(driz.out_img)) >= 7
+    # output image intensity must be equal to the input image intensity:
+    assert np.allclose(
+        driz.out_img[np.isfinite(driz.out_img)],
+        img[0, 0],
+        rtol=0,
+        atol=1e-6
+    )
+    # flux in the output image should be equal to the flux in the input image:
+    assert np.allclose(out_flux, in_flux, rtol=1e-6, atol=0.0)
+    # area of the signal in the input image:
+    assert np.allclose(np.sum(driz.out_wht), 6.0, rtol=0, atol=1.0e-6)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drizzle
-Version: 2.1.0
+Version: 2.1.1
 Summary: A package for combining dithered images into a single image
 Author-email: STScI <help@stsci.edu>
 Project-URL: Homepage, https://github.com/spacetelescope/drizzle

{drizzle-2.1.0 → drizzle-2.1.1}/src/cdrizzleapi.c

@@ -230,19 +230,29 @@ tdriz(PyObject *obj UNUSED_PARAM, PyObject *args, PyObject *keywords) {
     p.fill_value = fill_value;
     p.error = &error;
 
-    if (driz_error_check(&error, "xmin must be >= 0", p.xmin >= 0)) goto _exit;
-    if (driz_error_check(&error, "ymin must be >= 0", p.ymin >= 0)) goto _exit;
-    if (driz_error_check(&error, "xmax must be > xmin", p.xmax > p.xmin))
+    if (driz_error_check(&error, "xmin must be >= 0", p.xmin >= 0)) {
         goto _exit;
-    if (driz_error_check(&error, "ymax must be > ymin", p.ymax > p.ymin))
+    }
+    if (driz_error_check(&error, "ymin must be >= 0", p.ymin >= 0)) {
         goto _exit;
-    if (driz_error_check(&error, "scale must be > 0", p.scale > 0.0))
+    }
+    if (driz_error_check(&error, "xmax must be > xmin", p.xmax > p.xmin)) {
         goto _exit;
-    if (driz_error_check(&error, "exposure time must be > 0", p.exposure_time))
+    }
+    if (driz_error_check(&error, "ymax must be > ymin", p.ymax > p.ymin)) {
+        goto _exit;
+    }
+    if (driz_error_check(&error, "scale must be > 0", p.scale > 0.0f)) {
         goto _exit;
+    }
+    if (driz_error_check(&error, "exposure time must be > 0",
+                         p.exposure_time > 0.0f)) {
+        goto _exit;
+    }
     if (driz_error_check(&error, "weight scale must be > 0",
-                         p.weight_scale > 0.0))
+                         p.weight_scale > 0.0f)) {
         goto _exit;
+    }
 
     get_dimensions(p.pixmap, psize);
     if (psize[0] != isize[0] || psize[1] != isize[1]) {

{drizzle-2.1.0 → drizzle-2.1.1}/src/cdrizzlebox.c

@@ -88,75 +88,98 @@ This is used by BOXER.
 */
 
 static inline_macro double
-sgarea(const double x1, const double y1, const double x2, const double y2,
-	const int sgn_dx, const double slope, const double inv_slope) {
-  double c, xlo, xhi, ylo, yhi, xtop;
+sgarea(const double x1, const double y1, const double x2, const double y2) {
+    double xlo, xhi, ylo, yhi, xtop;
+    double dx, dy, det, sgn_dx;
 
-  /* Trap vertical line */
-  if (inv_slope == 0) {
-    return 0.0;
-  }
-
-  if (sgn_dx < 0) {
-    xlo = x2;
-    xhi = x1;
-  } else {
-    xlo = x1;
-    xhi = x2;
-  }
-
-  /* And determine the bounds ignoring y for now */
-  if (xlo >= 1.0 || xhi <= 0.0) {
-    return 0.0;
-  }
+    dx = x2 - x1;
+    dy = y2 - y1;
 
-  xlo = MAX(xlo, 0.0);
-  xhi = MIN(xhi, 1.0);
+    /* Trap vertical line */
+    if (dx == 0) {
+        return 0.0;
+    }
 
-  /* Now look at y */
-  c = y1 - slope * x1;
-  ylo = slope * xlo + c;
-  yhi = slope * xhi + c;
+    if (dx < 0) {
+        sgn_dx = -1.0;
+        xlo = x2;
+        xhi = x1;
+    } else {
+        sgn_dx = 1.0;
+        xlo = x1;
+        xhi = x2;
+    }
 
-  /* Trap segment entirely below axis */
-  if (ylo <= 0.0 && yhi <= 0.0) {
-    return 0.0;
-  }
-
-  /* There are four possibilities: both y below 1, both y above 1 and
-     one of each. */
-  if (ylo >= 1.0 && yhi >= 1.0) {
-    /* Line segment is entirely above square */
-    return sgn_dx * (xhi - xlo);
-  }
-
-  /* Adjust bounds if segment crosses axis (to exclude anything below
-     axis) */
-  if (ylo < 0.0) {
-    ylo = 0.0;
-    xlo = -c * inv_slope;
-  }
-
-  if (yhi < 0.0) {
-    yhi = 0.0;
-    xhi = -c * inv_slope;
-  }
-
-  if (ylo <= 1.0) {
-    if (yhi <= 1.0) {
-      /* Segment is entirely within the square.
-	 The case of zero slope will end up here without ever
-	 calling for inv_slope earlier. */
-      return sgn_dx * 0.5 * (xhi - xlo) * (yhi + ylo);
+    /* And determine the bounds ignoring y for now */
+    if (xlo >= 1.0 || xhi <= 0.0) {
+        return 0.0;
+    }
+
+    xlo = MAX(xlo, 0.0);
+    xhi = MIN(xhi, 1.0);
+
+    /* Now look at y */
+    double slope = dy / dx;
+    ylo = y1 + slope * (xlo - x1);
+    yhi = y1 + slope * (xhi - x1);
+
+    /* Alternative code that may be more stable under certain circumstances */
+    /*
+        if (xlo < 0.0) {
+            xlo = 0.0;
+            ylo = y1 + (dy / dx) * (xlo - x1);
+        } else {
+            ylo = (sgn_dx > 0.0) ? y1 : y2;
+        }
+
+        if (xhi > 1.0) {
+            xhi = 1.0;
+            yhi = y1 + (dy / dx) * (xhi - x1);
+        } else {
+            yhi = (sgn_dx > 0.0) ? y2 : y1;
+        }
+    */
+
+    /* Trap segment entirely below axis */
+    if (ylo <= 0.0 && yhi <= 0.0) {
+        return 0.0;
+    }
+
+    /* There are four possibilities: both y below 1, both y above 1 and
+       one of each. */
+    if (ylo >= 1.0 && yhi >= 1.0) {
+        /* Line segment is entirely above square */
+        return sgn_dx * (xhi - xlo);
     }
 
-    /* Otherwise, it must cross the top of the square */
-    xtop = (1.0 - c) * inv_slope;
-    return sgn_dx * (0.5 * (xtop - xlo) * (1.0 + ylo) + xhi - xtop);
-  }
+    det = x1 * y2 - y1 * x2;
 
-  xtop = (1.0 - c) * inv_slope;
-  return sgn_dx * (0.5 * (xhi - xtop) * (1.0 + yhi) + xtop - xlo);
+    /* Adjust bounds if segment crosses axis (to exclude anything below
+       axis) */
+    if (ylo < 0.0) {
+        ylo = 0.0;
+        xlo = det / dy;
+    }
+
+    if (yhi < 0.0) {
+        yhi = 0.0;
+        xhi = det / dy;
+    }
+
+    if (ylo <= 1.0) {
+        if (yhi <= 1.0) {
+            /* Segment is entirely within the square.
+               The case of zero slope will end up here. */
+            return sgn_dx * 0.5 * (xhi - xlo) * (yhi + ylo);
+        }
+
+        /* Otherwise, it must cross the top of the square */
+        xtop = (dx + det) / dy;
+        return sgn_dx * (0.5 * (xtop - xlo) * (1.0 + ylo) + xhi - xtop);
+    }
+
+    xtop = (dx + det) / dy;
+    return sgn_dx * (0.5 * (xhi - xtop) * (1.0 + yhi) + xtop - xlo);
 }
 
 /**
@@ -170,37 +193,34 @@ sgarea(const double x1, const double y1, const double x2, const double y2,
 */
 
 double
-boxer(double is, double js,
-      const double x[4], const double y[4],
-      const int sgn_dx[4], const double slope[4], const double inv_slope[4]) {
-  integer_t i;
-  double sum;
-  double px[4], py[4];
-
-  assert(x);
-  assert(y);
-
-  is -= 0.5;
-  js -= 0.5;
-  /* Set up coords relative to unit square at origin Note that the
-     +0.5s were added when this code was included in DRIZZLE */
-
-  for (i = 0; i < 4; ++i) {
-    px[i] = x[i] - is;
-    py[i] = y[i] - js;
-  }
-
-  /* For each line in the polygon (or at this stage, input
-     quadrilateral) calculate the area common to the unit square
-     (allow negative area for subsequent `vector' addition of
-     subareas). */
-  sum = 0.0;
-  for (i = 0; i < 4; ++i) {
-    sum += sgarea(px[i], py[i], px[(i+1) & 0x3], py[(i+1) & 0x3],
-		  sgn_dx[i], slope[i], inv_slope[i]);
-  }
-
-  return sum;
+boxer(double is, double js, const double x[4], const double y[4]) {
+    integer_t i;
+    double sum;
+    double px[4], py[4];
+
+    assert(x);
+    assert(y);
+
+    is -= 0.5;
+    js -= 0.5;
+    /* Set up coords relative to unit square at origin Note that the
+       +0.5s were added when this code was included in DRIZZLE */
+
+    for (i = 0; i < 4; ++i) {
+        px[i] = x[i] - is;
+        py[i] = y[i] - js;
+    }
+
+    /* For each line in the polygon (or at this stage, input
+       quadrilateral) calculate the area common to the unit square
+       (allow negative area for subsequent `vector' addition of
+       subareas). */
+    sum = 0.0;
+    for (i = 0; i < 4; ++i) {
+        sum += sgarea(px[i], py[i], px[(i + 1) & 0x3], py[(i + 1) & 0x3]);
+    }
+
+    return sum;
 }
 
 /** ---------------------------------------------------------------------------
@@ -284,8 +304,7 @@ compute_area(double is, double js, const double x[4], const double y[4]) {
                              * segment inside the square
                              */
                             width = segment[1][0] - segment[0][0];
-                            area += 0.5 * width *
-                                    ((1.0 + delta[0]) + (1.0 + delta[1]));
+                            area += 0.5 * width * (2.0 + delta[0] + delta[1]);
                         }
                     }
 
@@ -313,14 +332,14 @@ compute_area(double is, double js, const double x[4], const double y[4]) {
                             width = segment[1][0] - midpoint[0];
                             /* Delta[0] is at the crossing point and thus zero
                              */
-                            area += 0.5 * width * (1.0 + (1.0 + delta[1]));
+                            area += 0.5 * width * (2.0 + delta[1]);
                         } else {
                             width = segment[1][0] - midpoint[0];
                             area += width;
                             width = midpoint[0] - segment[0][0];
                             /* Delta[1] is at the crossing point and thus zero
                              */
-                            area += 0.5 * width * ((1.0 + delta[0]) + 1.0);
+                            area += 0.5 * width * (2.0 + delta[0]);
                         }
 
                     } else {
@@ -873,10 +892,8 @@ do_kernel_square(struct driz_param_t *p) {
     integer_t bv, i, j, ii, jj, min_ii, max_ii, min_jj, max_jj, nhit;
     integer_t osize[2], mapsize[2];
     float scale2, vc, d, dow;
-    double dh, jaco, dover, w, dx, dy;
+    double dh, jaco, dover, w;
     double xin[4], yin[4], xout[4], yout[4];
-    double slope[4], inv_slope[4];
-    int sgn_dx[4];
 
     struct scanner s;
     int xmin, xmax, ymin, ymax, n;
@@ -918,32 +935,40 @@ do_kernel_square(struct driz_param_t *p) {
         }
 
         /* Set the input corner positions */
-
         yin[1] = yin[0] = (double)j + dh;
         yin[3] = yin[2] = (double)j - dh;
 
         for (i = xmin; i <= xmax; ++i) {
             nhit = 0;
 
-            xin[3] = xin[0] = (double)i - dh;
-            xin[2] = xin[1] = (double)i + dh;
-
-	    /* Assuming we don't need to extrapolate, call a more
-	     * efficient interpolator that takes advantage of the fact
-	     * that pixfrac<1 and that we are using a square grid.
-	     */
-	    if (i > 0 && i < mapsize[0] - 2 && j > 0 && j < mapsize[1] - 2) {
-	        if (interpolate_four_points(p, i, j, dh,
-					    xout, xout + 1, xout + 2, xout + 3,
-					    yout, yout + 1, yout + 2, yout + 3))
-		    goto _miss;
-	    } else {
-	        for (ii = 0; ii < 4; ++ii) {
+            // xin[3] = xin[0] = (double)i - dh;
+            // xin[2] = xin[1] = (double)i + dh;
+
+            // for (ii = 0; ii < 4; ++ii) {
+            //     if (interpolate_point(p, xin[ii], yin[ii], xout + ii,
+            //                           yout + ii)) {
+            //         goto _miss;
+            //     }
+            // }
+
+            /* Assuming we don't need to extrapolate, call a more
+             * efficient interpolator that takes advantage of the fact
+             * that pixfrac<1 and that we are using a square grid.
+             */
+            if (i > 0 && i < mapsize[0] - 2 && j > 0 && j < mapsize[1] - 2) {
+                if (interpolate_four_points(p, i, j, dh, xout, xout + 1,
+                                            xout + 2, xout + 3, yout, yout + 1,
+                                            yout + 2, yout + 3))
+                    goto _miss;
+            } else {
+                xin[3] = xin[0] = (double)i - dh;
+                xin[2] = xin[1] = (double)i + dh;
+                for (ii = 0; ii < 4; ++ii) {
                     if (interpolate_point(p, xin[ii], yin[ii], xout + ii,
                                           yout + ii))
-		        goto _miss;
-	        }
-	    }
+                        goto _miss;
+                }
+            }
 
             /* Work out the area of the quadrilateral on the output
              * grid.  If the points are in clockwise order we get a
@@ -951,7 +976,7 @@ do_kernel_square(struct driz_param_t *p) {
              * will be negative, but so will the areas computed by
              * boxer, so it doesn't actually matter once we divide it
              * out.
-	     */
+             */
 
             jaco = 0.5f * ((xout[1] - xout[3]) * (yout[0] - yout[2]) -
                            (xout[0] - xout[2]) * (yout[1] - yout[3]));
@@ -967,38 +992,20 @@ do_kernel_square(struct driz_param_t *p) {
                 w = 1.0 / jaco;
             }
 
-	    /* Pre-compute slopes and sign of dx for each segment,
-	       since they will be used for all pixels in the loop.
-	       Also compute the inverse of the slope to avoid more
-	       division calls later.
-	     */
-
-	    for (ii = 0; ii < 4; ii++) {
-	        dx = xout[(ii+1) & 0x3] - xout[ii];
-	        dy = yout[(ii+1) & 0x3] - yout[ii];
-	        if (dx >= 0) {
-		  sgn_dx[ii] = 1;
-		} else {
-		  sgn_dx[ii] = -1;
-		}
-	        slope[ii] = dy / dx;
-	        inv_slope[ii] = dx / dy;
-	    }
-
             /* Loop over output pixels which could be affected */
             min_jj = MAX(fortran_round(min_doubles(yout, 4)), 0);
             max_jj = MIN(fortran_round(max_doubles(yout, 4)), osize[1] - 1);
             min_ii = MAX(fortran_round(min_doubles(xout, 4)), 0);
             max_ii = MIN(fortran_round(max_doubles(xout, 4)), osize[0] - 1);
 
-	    for (jj = min_jj; jj <= max_jj; ++jj) {
-	        for (ii = min_ii; ii <= max_ii; ++ii) {
+            for (jj = min_jj; jj <= max_jj; ++jj) {
+                for (ii = min_ii; ii <= max_ii; ++ii) {
                     /* Call boxer to calculate overlap */
-                    //dover = compute_area((double)ii, (double)jj, xout, yout);
-		    dover = boxer((double)ii, (double)jj, xout, yout,
-				  sgn_dx, slope, inv_slope);
+                    // dover = compute_area((double)ii, (double)jj, xout, yout);
+                    dover = boxer((double)ii, (double)jj, xout, yout);
 
-		    /* Could be positive or negative, depending on the sign of jaco */
+                    /* Could be positive or negative, depending on the sign of
+                     * jaco */
                     if (dover != 0.0) {
                         vc = get_pixel(p->output_counts, ii, jj);
 
@@ -1008,7 +1015,7 @@ do_kernel_square(struct driz_param_t *p) {
                         ++nhit;
 
                         /* If we are creating or modifying the context image we
-                           do so here */
+                            do so here */
                         if (p->output_context && dow > 0.0) {
                             set_bit(p->output_context, ii, jj, bv);
                         }

{drizzle-2.1.0 → drizzle-2.1.1}/src/cdrizzlebox.h

@@ -25,9 +25,7 @@ int dobox(struct driz_param_t *p);
 
 double compute_area(double is, double js, const double x[4], const double y[4]);
 
-double boxer(double is, double js, const double x[4], const double y[4],
-	     const int sgn_dx[4], const double slope[4],
-	     const double inv_slope[4]);
+double boxer(double is, double js, const double x[4], const double y[4]);
 
 typedef int (*kernel_handler_t)(struct driz_param_t *);
 

{drizzle-2.1.0 → drizzle-2.1.1}/src/cdrizzlemap.c

@@ -19,6 +19,22 @@ static const double VERTEX_ATOL = 1.0e-12;
 static const double APPROX_ZERO = 1.0e3 * DBL_MIN;
 static const double MAX_INV_ERR = 0.03;
 
+void
+debug_print_polygon(const struct polygon *p, char *msg) {
+    int i;
+    if (msg) {
+        printf("%s\n", msg);
+    }
+    printf("Polygon with %d vertices:\n", p->npv);
+    for (i = 0; i < p->npv; ++i) {
+        printf("  Vertex %d: (%.20f, %.20f)\n", i, p->v[i].x, p->v[i].y);
+    }
+    printf("\n");
+    fflush(stdout);
+}
+
+void rotate_polygon(struct polygon *p, int pos);
+
 /** ---------------------------------------------------------------------------
  * Find the tighest bounding box around valid (finite) pixmap values.
  *
@@ -178,10 +194,10 @@ interpolate_point(struct driz_param_t *par, double xin, double yin,
  *         four x points, then four y points.
  */
 int
-interpolate_four_points(struct driz_param_t *par,
-			int ixcen, int iycen, double h,
-			double *x1, double *x2, double *x3, double *x4,
-			double *y1, double *y2, double *y3, double *y4) {
+interpolate_four_points(struct driz_param_t *par, int ixcen, int iycen,
+                        double h, double *x1, double *x2, double *x3,
+                        double *x4, double *y1, double *y2, double *y3,
+                        double *y4) {
     int i, j, nx2, ny2;
     double fac;
     npy_intp *ndim;
@@ -205,30 +221,30 @@ interpolate_four_points(struct driz_param_t *par,
      * center point, given by i=j=1 below. Loop ordered for speed
      * based on numpy array order.
      */
+    ixcen -= 1;
+    iycen -= 1;
     assert(h <= 1);
-    assert(ixcen >= 1 && iycen >= 1 && ixcen <= nx2 && iycen <= ny2);
-
-    for (j = 0; j <= 2; j++) {
-      for (i = 0; i <= 2; i++) {
-	p = get_pixmap(pixmap, i + ixcen - 1, j + iycen - 1);
-	if (i == 1 && j == 1) {
-	  fac = (1 - h) * (1 - h);
-	} else {
-	  if (i == 1 || j == 1) {
-	    fac = (1 - h) * h;
-	  } else {
-	    fac = h * h;
-	  }
-	}
-	f[i][j] = p[0] * fac;
-	g[i][j] = p[1] * fac;
-      }
+    assert(ixcen >= 0 && iycen >= 0 && ixcen < nx2 && iycen < ny2);
+
+    for (j = 0; j <= 2; ++j) {
+        for (i = 0; i <= 2; ++i) {
+            p = get_pixmap(pixmap, i + ixcen, j + iycen);
+            if (i == 1 && j == 1) {
+                fac = (1 - h) * (1 - h);
+            } else if (i == 1 || j == 1) {
+                fac = (1 - h) * h;
+            } else {
+                fac = h * h;
+            }
+            f[i][j] = p[0] * fac;
+            g[i][j] = p[1] * fac;
+        }
     }
 
     /* We return the vertices of a square going clockwise in the
      * original pixel grid.
      * Order in y: +h, +h, -h, -h; order in x: -h, +h, +h, -h
-    */
+     */
 
     *x1 = f[0][1] + f[1][1] + f[0][2] + f[1][2];
     *y1 = g[0][1] + g[1][1] + g[0][2] + g[1][2];
@@ -242,17 +258,16 @@ interpolate_four_points(struct driz_param_t *par,
     *x4 = f[0][0] + f[1][0] + f[0][1] + f[1][1];
     *y4 = g[0][0] + g[1][0] + g[0][1] + g[1][1];
 
-    if (npy_isnan(*x1) || npy_isnan(*y1) ||
-	npy_isnan(*x2) || npy_isnan(*y2) ||
-	npy_isnan(*x3) || npy_isnan(*y3) ||
-	npy_isnan(*x4) || npy_isnan(*y4)) return 1;
+    if (npy_isnan(*x1) || npy_isnan(*y1) || npy_isnan(*x2) || npy_isnan(*y2) ||
+        npy_isnan(*x3) || npy_isnan(*y3) || npy_isnan(*x4) || npy_isnan(*y4)) {
+        return 1;
+    }
 
     return 0;
 }
 
 /** ---------------------------------------------------------------------------
  * Map an integer pixel position from the input to the output image.
- * Fall back on interpolation if the value at the point is undefined
  *
  * pixmap: The mapping of the pixel centers from input to output image
  * i - The index of the x coordinate
@@ -260,7 +275,6 @@ interpolate_four_points(struct driz_param_t *par,
  * x - X-coordinate of the point on the output image (output)
  * y - Y-coordinate of the point on the output image (output)
  */
-
 int
 map_pixel(PyArrayObject *pixmap, int i, int j, double *x, double *y) {
     double *pv = (double *)PyArray_GETPTR3(pixmap, j, i, 0);
@@ -442,6 +456,38 @@ is_point_strictly_in_hp(const struct vertex pt, const struct vertex v_,
     return ((area(v, pt) - area(v_, pt) - area(v, v_)) > 0.0);
 }
 
+/**
+ * Rotates the vertices of a polygon by a specified number of positions.
+ *
+ * This function shifts the vertices of the given polygon `p` by `pos`
+ * positions. For each rotation, the first vertex is moved to the end of the
+ * vertex array, effectively rotating the polygon's vertex order. The operation
+ * is performed in-place and repeated `pos` times.
+ *
+ * @param p   Pointer to the polygon structure to be rotated. The polygon is
+ *            expected to have an array of vertices `v` and a count `npv`.
+ * @param pos Number of positions to rotate the polygon's vertices.
+ */
+void
+rotate_polygon(struct polygon *p, int pos) {
+    int i, k, m;
+    double x, y;
+
+    for (i = 0; i < pos; ++i) {
+        // rotate polygon p by pos vertices
+        // (move first pos vertices to the end of the polygon)
+        x = p->v[0].x;
+        y = p->v[0].y;
+        for (k = 0; k < p->npv - 1; ++k) {
+            m = mod(k + 1, p->npv);
+            p->v[k].x = p->v[m].x;
+            p->v[k].y = p->v[m].y;
+        }
+        p->v[p->npv - 1].x = x;
+        p->v[p->npv - 1].y = y;
+    }
+}
+
 /**
  * Append a vertex to a polygon.
  *
@@ -619,12 +665,16 @@ clip_polygon_to_window(const struct polygon *p, const struct polygon *wnd,
                 // compute intersection point:
                 // https://en.wikipedia.org/wiki/Line–line_intersection
                 d = area(dp, dw);  // d != 0 because (v2_inside != v1_inside)
+
                 app_ = area(*pv, *pv_);
                 aww_ = area(*wv, *wv_);
+
                 vi.x = (app_ * dw.x - aww_ * dp.x) / d;
                 vi.y = (app_ * dw.y - aww_ * dp.y) / d;
 
-                append_vertex(ppout, vi);
+                if (isfinite(vi.x) && isfinite(vi.y)) {
+                    append_vertex(ppout, vi);
+                }
                 if (v2_inside) {
                     // outside to inside:
                     append_vertex(ppout, *pv);
@@ -633,6 +683,7 @@ clip_polygon_to_window(const struct polygon *p, const struct polygon *wnd,
                 // both edge vertices are inside
                 append_vertex(ppout, *pv);
             }
+
             // nothing to do when both edge vertices are outside
 
             // advance polygon edge: