pycerr 2.2.0__tar.gz → 2.2.2__tar.gz

{pycerr-2.2.0 → pycerr-2.2.2}/CHANGELOG.md

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.2.2] - 2026-09-28
+
+### Fixed
+
+- **GLCM sum entropy dropped the p(x+y) = 2 term.** The emptiness check on the
+  indices of grey-level sum 2 used `np.any`, and the only cell with that sum
+  sits at index 0, so the term p(1,1)·log₂p(1,1) was left out whenever the
+  lowest grey level neighboured itself. Sum entropy was underestimated for
+  such structures. The same check in the difference-entropy loop is fixed too.
+- **NGTDM contrast skipped grey-level shifts.** The contrast double sum
+  skipped shift *k* whenever grey level *k* was empty, which dropped valid
+  pairs for any structure with empty grey levels (typically homogeneous
+  organs with fixed bin number).
+- **NGTDM level probabilities now follow IBSI.** `p` counted every voxel in
+  the structure but was normalised by the number of voxels with a valid
+  neighbourhood (N<sub>v,c</sub>), so it could sum to more than 1 in 2D/2.5D.
+  It now counts only voxels with at least one neighbour. All NGTDM features
+  can change slightly for 2D/2.5D calculations. With both NGTDM fixes, contrast
+  matches the IBSI 1 consensus values for configurations A, B and C.
+
+### Changed
+
+- **`polyFill` is vectorized**, 3-23x faster on typical contours, with
+  pixel-identical output (checked against the previous implementation in
+  `tests/test_poly_fill.py`). Contours extending past the image edge are now
+  clipped; previously they raised `IndexError` past the far edge and wrapped
+  around at negative indices.
+- **`importStructureMask` pads a uint8 mask** instead of an int64 copy,
+  cutting its memory use 8x. Output is unchanged.
+
+## [2.2.1] - 2026-09-26
+
+### Changed
+
+- **The Qt desktop viewer's dependencies are now an optional extra.** `PyQt5`,
+  `pyvista` and `pyvistaqt` moved out of the base install into
+  `pip install "pycerr[viewer]"`. PyQt5 publishes no aarch64 Linux wheel, so
+  `pip install pycerr` on arm64 Linux (Apple Silicon Docker images, ARM
+  servers) tried to build it from source and failed for want of `qmake`.
+  Everything that does not draw a Qt window is unaffected: the Python API,
+  batch/headless processing in containers, and the Jupyter viewer
+  (`cerr.viewer.pycerr_nbviewer`), which uses `ipywidgets` + matplotlib and
+  keeps `ipywidgets` as a base dependency. Launching the desktop viewer without
+  the extra now raises an ImportError naming the install command instead of
+  `No module named 'PySide2'`.
+
 ## [2.2.0] - 2026-09-17
 
 ### Added

{pycerr-2.2.0/pycerr.egg-info → pycerr-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycerr
-Version: 2.2.0
+Version: 2.2.2
 Summary: A Computational Environment for Radiological Research
 Author-email: "Aditya P. Apte" <aptea@mskcc.org>, Aditi Iyer <iyera@mskcc.org>, Eve LoCastro <locastre@mskcc.org>, "Joseph O. Deasy" <deasyj@mskcc.org>
 Project-URL: Homepage, https://github.com/cerr/pyCERR
@@ -30,9 +30,10 @@ Requires-Dist: ipywidgets
 Requires-Dist: surface-distance-based-measures
 Requires-Dist: itk-strain
 Requires-Dist: numba
-Requires-Dist: PyQt5
-Requires-Dist: pyvista
-Requires-Dist: pyvistaqt
+Provides-Extra: viewer
+Requires-Dist: PyQt5; extra == "viewer"
+Requires-Dist: pyvista; extra == "viewer"
+Requires-Dist: pyvistaqt; extra == "viewer"
 Provides-Extra: napari
 Requires-Dist: napari[all]; extra == "napari"
 Requires-Dist: napari-animation; extra == "napari"

{pycerr-2.2.0 → pycerr-2.2.2}/cerr/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.0'
-__version_tuple__ = version_tuple = (2, 2, 0)
+__version__ = version = '2.2.2'
+__version_tuple__ = version_tuple = (2, 2, 2)
 
-__commit_id__ = commit_id = 'g1496840a3'
+__commit_id__ = commit_id = 'gf85644a5a'

{pycerr-2.2.0 → pycerr-2.2.2}/cerr/contour/rasterseg.py

@@ -29,77 +29,81 @@ def polyFill(rowV, colV, xSize, ySize):
         np.ndarray: Boolean mask of shape ``(xSize, ySize)`` where filled
         pixels are 1 and background pixels are 0.
     """
-    # Initialize the result matrix with zeros
+    # Vectorized scanline fill: O(edge crossings) rather than a Python loop over
+    # scanlines x edges. Scanlines run along the column (y) axis. Semantics:
+    # an edge covers scanlines ceil(top)..bottom but toggles only where y != bottom;
+    # a flat edge on an integer scanline draws ceil(min row)..floor(max row); an
+    # integer bottom vertex draws its own pixel; toggles within 1e-6 of an integer
+    # snap to it; sorted toggles pair up as ceil(t0)..floor(t1). An odd crossing
+    # count on a scanline raises IndexError. Pixels outside the image are clipped.
     result = np.zeros((xSize, ySize))
-
-    # Some contours have more than one segment. Treat them as separate polygons on the same image.
-    # They shouldn't overlap, but if they do, the value of the resultant mask will be 1.0.
-    pointCount = len(rowV)
-    edgeList = np.zeros((pointCount, 4))
-
-    # Iterate over each point in the contour
-    for point in range(pointCount):
-        if point == pointCount - 1:
-            p1x, p1y = rowV[point], colV[point]
-            p2x, p2y = rowV[0], colV[0]
-        else:
-            p1x, p1y = rowV[point], colV[point]
-            p2x, p2y = rowV[point + 1], colV[point + 1]
-
-        # Ensure that the edge is ordered from top to bottom (y-wise)
-        if p1y <= p2y:
-            edgeList[point, :] = [p1x, p1y, p2x, p2y]
-        else:
-            edgeList[point, :] = [p2x, p2y, p1x, p1y]
-
-    # Get the relevant y-range to loop over
-    minY = int(np.ceil(np.min(edgeList[:, 1])))
-    maxY = int(np.floor(np.max(edgeList[:, 3])))
-
-    # Loop over the relevant lines in the image.
-    for y in range(minY, maxY + 1):
-        # Get the active edges that cover the current y value
-        indV = (edgeList[:, 1] <= y) & (edgeList[:, 3] >= y)
-        activeEdges = edgeList[indV, :]
-
-        # Create lists to store pixels to draw and intersections
-        drawlist = np.empty(0,dtype=int)
-        togglelist = np.empty(0,dtype=float)
-
-        # Iterate over the active edges
-        edgeCount = activeEdges.shape[0]
-        for edge in range(edgeCount):
-            p1x, p1y, p2x, p2y = activeEdges[edge, :]
-
-            # Check if it's a flat line
-            if p1y == p2y:
-                if p1x > p2x:
-                    drawlist = np.append(drawlist, np.arange(int(np.ceil(p2x)), int(np.floor(p1x)) + 1))
-                else:
-                    drawlist = np.append(drawlist, np.arange(int(np.ceil(p1x)), int(np.floor(p2x)) + 1))
-            elif p2y == y and p2x == round(p2x):
-                drawlist = np.append(drawlist,int(p2x))
-            elif p2y != y:
-                invslope = float(p2x - p1x) / float(p2y - p1y)
-                togglelist = np.append(togglelist, p1x + (invslope * (y - p1y)))
-
-        # Snap to center if less than tolerance
-        snap_tol = 1e-6
-        togglelistRound = np.round(togglelist)
-        ind_snap = np.abs(togglelistRound - togglelist) < snap_tol
-        togglelist[ind_snap] = togglelistRound[ind_snap]
-
-        # Sort the toggle points in order
-        togglelist.sort()
-
-        # Iterate over pairs in the toggle list and draw the pixels accordingly
-        for i in range(0, len(togglelist), 2):
-            x1, x2 = int(np.ceil(togglelist[i])), int(np.floor(togglelist[i + 1]))
-            result[x1:x2 + 1, y] = 1
-
-        # Turn on the pixels in the drawlist
-        result[drawlist, y] = 1
-
+    rowV = np.asarray(rowV, dtype=float)
+    colV = np.asarray(colV, dtype=float)
+    if len(rowV) == 0:
+        return result
+
+    # Edges ordered top to bottom (y-wise); the polygon is closed
+    nxt = np.roll(np.arange(len(rowV)), -1)
+    p1x, p1y, p2x, p2y = rowV, colV, rowV[nxt], colV[nxt]
+    swap = ~(p1y <= p2y)
+    ax = np.where(swap, p2x, p1x)
+    ay = np.where(swap, p2y, p1y)
+    bx = np.where(swap, p1x, p2x)
+    by = np.where(swap, p1y, p2y)
+    if int(np.floor(np.max(by))) < int(np.ceil(np.min(ay))):
+        return result
+
+    # Flat edges lying on an integer scanline
+    flat = ay == by
+    for e in np.nonzero(flat & (ay == np.round(ay)) & (ay >= 0) & (ay < ySize))[0]:
+        lo, hi = (bx[e], ax[e]) if ax[e] > bx[e] else (ax[e], bx[e])
+        result[max(int(np.ceil(lo)), 0):int(np.floor(hi)) + 1, int(ay[e])] = 1
+
+    # Bottom vertices on integer grid points
+    ax, ay, bx, by = ax[~flat], ay[~flat], bx[~flat], by[~flat]
+    vertex = (by == np.round(by)) & (bx == np.round(bx))         & (bx >= 0) & (bx < xSize) & (by >= 0) & (by < ySize)
+    result[bx[vertex].astype(int), by[vertex].astype(int)] = 1
+
+    # Toggle points of each edge on every scanline it crosses
+    y0 = np.ceil(ay).astype(np.int64)
+    y1 = np.floor(by).astype(np.int64)
+    y1 = np.where(by == np.round(by), y1 - 1, y1)  # no toggle on the bottom scanline
+    k = np.maximum(y1 - y0 + 1, 0)
+    total = int(k.sum())
+    if total == 0:
+        return result
+    e = np.repeat(np.arange(len(k)), k)
+    y = y0[e] + (np.arange(total) - np.repeat(np.cumsum(k) - k, k))
+    invslope = (bx[e] - ax[e]) / (by[e] - ay[e])
+    t = ax[e] + invslope * (y.astype(float) - ay[e])
+
+    # Snap to center if less than tolerance
+    t_round = np.round(t)
+    snap = np.abs(t_round - t) < 1e-6
+    t[snap] = t_round[snap]
+
+    # Sort toggles within each scanline and pair them up
+    order = np.lexsort((t, y))
+    t, y = t[order], y[order]
+    if np.any(np.unique(y, return_counts=True)[1] % 2):
+        raise IndexError("odd number of polygon crossings on a scanline")
+    x1 = np.ceil(t[0::2]).astype(np.int64)
+    x2 = np.floor(t[1::2]).astype(np.int64)
+    cols = y[0::2]
+    # Clip runs to the image
+    x1 = np.maximum(x1, 0)
+    x2 = np.minimum(x2, xSize - 1)
+    keep = (x1 <= x2) & (cols >= 0) & (cols < ySize)
+    x1, x2, cols = x1[keep], x2[keep], cols[keep]
+    if len(x1) == 0:
+        return result
+
+    # Draw all runs at once with a difference array along rows
+    r0, r1, c0, c1 = int(x1.min()), int(x2.max()), int(cols.min()), int(cols.max())
+    runs = np.zeros((r1 - r0 + 2, c1 - c0 + 1), dtype=np.int32)
+    np.add.at(runs, (x1 - r0, cols - c0), 1)
+    np.add.at(runs, (x2 + 1 - r0, cols - c0), -1)
+    result[r0:r1 + 1, c0:c1 + 1][np.cumsum(runs, axis=0)[:-1] > 0] = 1
     return result
 
 # Example usage:

{pycerr-2.2.0 → pycerr-2.2.2}/cerr/dataclasses/structure.py

@@ -956,8 +956,9 @@ def importStructureMask(mask3M, assocScanNum, structName, planC, structNum=None)
     """
 
     # Pad mask to account for boundary edges
-    paddedMask3M = mask3M.astype(int)
-    paddedMask3M = np.pad(paddedMask3M, ((1,1),(1,1),(0,0)), 'constant', constant_values = 0)
+    # uint8 rather than int64 keeps the copy small; only voxels == 1 are contoured below
+    paddedMask3M = np.pad(np.asarray(mask3M == 1, dtype=np.uint8), ((1, 1), (1, 1), (0, 0)),
+                          'constant', constant_values=0)
     dt = datetime.now()
     if isinstance(structNum,(int, float, np.integer, np.floating)):
         struct_meta = planC.structure[structNum]

{pycerr-2.2.0 → pycerr-2.2.2}/cerr/radiomics/gray_level_cooccurence.py

@@ -178,7 +178,7 @@ def cooccurToScalarFeatures(cooccurM):
             px[n, col] = np.sum(cooccurM[indPxC[n], col])
             pXminusY[n, col] = np.sum(cooccurM[indCtrstC[n], col])
 
-            if np.any(indCtrstC[n]):
+            if len(indCtrstC[n]) > 0:
                 pXminusYlogPXminusY[n, col] = pXminusY[n, col] * np.log2(pXminusY[n, col] + np.finfo(float).eps)
             else:
                 pXminusYlogPXminusY[n, col] = 0
@@ -273,7 +273,7 @@ def cooccurToScalarFeatures(cooccurM):
             pXplusY[n - 1, off] = np.sum(cooccurM[indPxPlusYc[n - 1], off], axis=0)
 
             # Calculate p(x+y) log2(p(x+y))
-            if np.any(indPxPlusYc[n - 1]):
+            if len(indPxPlusYc[n - 1]) > 0:
                 pXplusYlogPXplusY[n - 1, off] = pXplusY[n - 1, off] * np.log2(pXplusY[n - 1, off] + np.finfo(float).eps)
             else:
                 pXplusYlogPXplusY[n - 1, off] = 0 #np.zeros(numCooccurs)

{pycerr-2.2.0 → pycerr-2.2.2}/cerr/radiomics/neighbor_gray_tone.py

@@ -100,12 +100,10 @@ def calcNGTDM(scan_array, patch_size, numGrLevels):
             ind_lev_v = (vox_val_v == lev) & vox_mask_v.astype(bool)
             vals_v = q_m[ind_lev_v]
             s[lev - 1, :] += vals_v.sum().astype(s.dtype)
+            p[lev - 1] += ind_lev_v.sum()
 
-    # Calculate level probabilities (p)
-    numVoxels = np.sum(scan_array > 0)
-    for iLev in range(1, numGrLevels + 1):
-        scanLev3M = scan_array == iLev
-        p[iLev - 1] = np.sum(scanLev3M) / Nvc
+    # Level probabilities (p) over voxels with a valid neighbourhood (IBSI n_i / N_v,c)
+    p = p / Nvc
 
     return s, p, Nvc
 
@@ -127,8 +125,6 @@ def ngtdmToScalarFeatures(s, p, Nvc):
     term1 = 0
     term2 = 0
     for lev in range(1, numLevels + 1):
-        if p[lev-1] == 0:
-            continue
         term1 += np.sum(p * np.roll(p, lev) * (indV - np.roll(indV, lev))**2)
         term2 += s[lev - 1, 0]
     featuresS['contrast'] = 1 / (Ng * (Ng - 1)) * term1 * term2 / Nvc

{pycerr-2.2.0 → pycerr-2.2.2}/cerr/viewer/README_pycerr_gui.md

@@ -8,10 +8,13 @@ A CERR-style (MATLAB CERR) slice viewer built on **pyCERR**, in a single file: `
 ## Setup (Windows, your paths)
 
 ```bat
-pip install PyQt5 matplotlib scipy
-pip install pyvista pyvistaqt   :: optional, GPU-accelerated 3D view
+pip install "pycerr[viewer]"    :: Qt binding + pyvista/pyvistaqt 3D view
 ```
 
+The base `pip install pycerr` is deliberately Qt-free, so it installs on
+platforms without a PyQt5 wheel (arm64 Linux) and in headless containers; the
+`viewer` extra adds what this desktop GUI needs.
+
 pyCERR itself: either `pip install pyCERR`, **or** use your local checkout — the script
 already points at it via:
 

{pycerr-2.2.0 → pycerr-2.2.2}/cerr/viewer/pycerr_gui/__init__.py

@@ -57,7 +57,8 @@ Features (mirroring the classic CERR slice viewer):
     view (updates as you scroll) and the full field pyramid in the 3D view
 
 Requirements:
-  pip install pyCERR PyQt5 matplotlib scipy
+  pip install "pycerr[viewer]"   -- Qt binding + pyvista/pyvistaqt 3D view
+                                    (the base pycerr install is Qt-free)
   -- or add your local pyCERR checkout to sys.path (see PYCERR_PATH below).
 
 Run:

{pycerr-2.2.0 → pycerr-2.2.2}/cerr/viewer/pycerr_gui/common.py

@@ -18,8 +18,20 @@ try:
     from PyQt5 import QtCore, QtGui, QtWidgets
     from PyQt5.QtCore import Qt
 except ImportError:  # pragma: no cover - PySide fallback
-    from PySide2 import QtCore, QtGui, QtWidgets  # type: ignore
-    from PySide2.QtCore import Qt  # type: ignore
+    try:
+        from PySide2 import QtCore, QtGui, QtWidgets  # type: ignore
+        from PySide2.QtCore import Qt  # type: ignore
+    except ImportError as exc:  # no Qt binding at all
+        # The Qt binding is an optional dependency (see pyproject's `viewer`
+        # extra), so say how to get it rather than surfacing a bare
+        # "No module named 'PySide2'".
+        raise ImportError(
+            "The pyCERR desktop viewer needs a Qt binding, which is not part of "
+            "the base install. Install it with:\n"
+            '    pip install "pycerr[viewer]"\n'
+            "For notebooks use the Qt-free viewer instead: "
+            "from cerr.viewer.pycerr_nbviewer import showNB"
+        ) from exc
 
 import logging
 

{pycerr-2.2.0 → pycerr-2.2.2/pycerr.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycerr
-Version: 2.2.0
+Version: 2.2.2
 Summary: A Computational Environment for Radiological Research
 Author-email: "Aditya P. Apte" <aptea@mskcc.org>, Aditi Iyer <iyera@mskcc.org>, Eve LoCastro <locastre@mskcc.org>, "Joseph O. Deasy" <deasyj@mskcc.org>
 Project-URL: Homepage, https://github.com/cerr/pyCERR
@@ -30,9 +30,10 @@ Requires-Dist: ipywidgets
 Requires-Dist: surface-distance-based-measures
 Requires-Dist: itk-strain
 Requires-Dist: numba
-Requires-Dist: PyQt5
-Requires-Dist: pyvista
-Requires-Dist: pyvistaqt
+Provides-Extra: viewer
+Requires-Dist: PyQt5; extra == "viewer"
+Requires-Dist: pyvista; extra == "viewer"
+Requires-Dist: pyvistaqt; extra == "viewer"
 Provides-Extra: napari
 Requires-Dist: napari[all]; extra == "napari"
 Requires-Dist: napari-animation; extra == "napari"

{pycerr-2.2.0 → pycerr-2.2.2}/pycerr.egg-info/SOURCES.txt

@@ -470,6 +470,7 @@ tests/test_imrtp.py
 tests/test_lattice.py
 tests/test_module_imports.py
 tests/test_nii_export_import.py
+tests/test_poly_fill.py
 tests/test_portpy_bridge.py
 tests/test_portpy_bridge_phase2.py
 tests/test_portpy_bridge_phase3.py

{pycerr-2.2.0 → pycerr-2.2.2}/pycerr.egg-info/requires.txt

@@ -17,9 +17,6 @@ ipywidgets
 surface-distance-based-measures
 itk-strain
 numba
-PyQt5
-pyvista
-pyvistaqt
 
 [ants]
 antspyx
@@ -37,3 +34,8 @@ nvidia-curand
 [napari]
 napari[all]
 napari-animation
+
+[viewer]
+PyQt5
+pyvista
+pyvistaqt

{pycerr-2.2.0 → pycerr-2.2.2}/pycerr.egg-info/scm_file_list.json

@@ -1164,6 +1164,7 @@
     "tests/test_lattice.py",
     "tests/test_module_imports.py",
     "tests/test_nii_export_import.py",
+    "tests/test_poly_fill.py",
     "tests/test_portpy_bridge.py",
     "tests/test_portpy_bridge_phase2.py",
     "tests/test_portpy_bridge_phase3.py",

pycerr-2.2.2/pycerr.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.2.2",
+  "distance": 0,
+  "node": "gf85644a5ac131d6d64abcc0b4153e55632377685",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-28"
+}

{pycerr-2.2.0 → pycerr-2.2.2}/pyproject.toml

@@ -48,12 +48,6 @@ dependencies = [
     # that dominate its Gauss-Newton CG matvec. ~90x on the derivative operator
     # versus the vectorized numpy form.
     'numba',
-    # Desktop Qt viewer (cerr.viewer.pycerr_gui): PyQt5 is the Qt binding;
-    # pyvista/pyvistaqt drive the GPU-accelerated 3D view (vtk is pulled in
-    # transitively by pyvista).
-    'PyQt5',
-    'pyvista',
-    'pyvistaqt'
 ]
 
 [project.urls]
@@ -61,6 +55,22 @@ dependencies = [
 "Bug Tracker" = "https://github.com/cerr/pyCERR/issues"
 
 [project.optional-dependencies]
+# Desktop Qt viewer (cerr.viewer.pycerr_gui) plus the ROE and IMRTP GUIs: PyQt5
+# is the Qt binding; pyvista/pyvistaqt drive the GPU-accelerated 3D view (vtk
+# comes in transitively via pyvista).
+#
+# Kept out of the base install because PyQt5 publishes no aarch64 Linux wheel:
+# on arm64 Linux (Apple Silicon Docker, ARM servers) `pip install pycerr` tried
+# to build it from source and failed for want of qmake. Everything that does
+# not draw a Qt window -- headless servers and containers, batch processing,
+# and the Jupyter viewer (cerr.viewer.pycerr_nbviewer, which needs only
+# ipywidgets + matplotlib) -- works without it:
+#   pip install "pycerr[viewer]"
+viewer = [
+    "PyQt5",
+    "pyvista",
+    "pyvistaqt",
+]
 napari = [
     "napari[all]",
     "napari-animation"

pycerr-2.2.2/tests/test_poly_fill.py

@@ -0,0 +1,115 @@
+"""
+Checks that the vectorized rasterseg.polyFill reproduces the original
+scanline implementation pixel for pixel.
+"""
+
+import numpy as np
+import pytest
+from cerr.contour.rasterseg import polyFill
+
+
+def reference_poly_fill(rowV, colV, xSize, ySize):
+    """Original loop-based polyFill (pyCERR <= 2.2.1), kept as the reference."""
+    result = np.zeros((xSize, ySize))
+    pointCount = len(rowV)
+    edgeList = np.zeros((pointCount, 4))
+    for point in range(pointCount):
+        p1x, p1y = rowV[point], colV[point]
+        p2x, p2y = rowV[(point + 1) % pointCount], colV[(point + 1) % pointCount]
+        if p1y <= p2y:
+            edgeList[point, :] = [p1x, p1y, p2x, p2y]
+        else:
+            edgeList[point, :] = [p2x, p2y, p1x, p1y]
+    minY = int(np.ceil(np.min(edgeList[:, 1])))
+    maxY = int(np.floor(np.max(edgeList[:, 3])))
+    for y in range(minY, maxY + 1):
+        indV = (edgeList[:, 1] <= y) & (edgeList[:, 3] >= y)
+        activeEdges = edgeList[indV, :]
+        drawlist = np.empty(0, dtype=int)
+        togglelist = np.empty(0, dtype=float)
+        for edge in range(activeEdges.shape[0]):
+            p1x, p1y, p2x, p2y = activeEdges[edge, :]
+            if p1y == p2y:
+                if p1x > p2x:
+                    drawlist = np.append(drawlist, np.arange(int(np.ceil(p2x)), int(np.floor(p1x)) + 1))
+                else:
+                    drawlist = np.append(drawlist, np.arange(int(np.ceil(p1x)), int(np.floor(p2x)) + 1))
+            elif p2y == y and p2x == round(p2x):
+                drawlist = np.append(drawlist, int(p2x))
+            elif p2y != y:
+                invslope = float(p2x - p1x) / float(p2y - p1y)
+                togglelist = np.append(togglelist, p1x + (invslope * (y - p1y)))
+        togglelistRound = np.round(togglelist)
+        ind_snap = np.abs(togglelistRound - togglelist) < 1e-6
+        togglelist[ind_snap] = togglelistRound[ind_snap]
+        togglelist.sort()
+        for i in range(0, len(togglelist), 2):
+            x1, x2 = int(np.ceil(togglelist[i])), int(np.floor(togglelist[i + 1]))
+            result[x1:x2 + 1, y] = 1
+        result[drawlist, y] = 1
+    return result
+
+
+def star_polygon(rng, center, rMax, nPts, integer=False):
+    ang = np.sort(rng.uniform(0, 2 * np.pi, nPts))
+    rad = rng.uniform(0.3 * rMax, rMax, nPts)
+    rowV = center[0] + rad * np.cos(ang)
+    colV = center[1] + rad * np.sin(ang)
+    if integer:
+        rowV, colV = np.round(rowV), np.round(colV)
+    return rowV, colV
+
+
+def assert_same(rowV, colV, xSize, ySize):
+    rowV, colV = np.asarray(rowV, dtype=float), np.asarray(colV, dtype=float)
+    inside = rowV.min() >= 0 and colV.min() >= 0 and rowV.max() < xSize - 1 and colV.max() < ySize - 1
+    if inside:
+        expected = reference_poly_fill(rowV, colV, xSize, ySize)
+    else:
+        # The reference raises past the far edge and wraps negative indices;
+        # polyFill clips. Compare against the reference on a padded canvas.
+        pad = int(np.ceil(max(-rowV.min(), -colV.min(), rowV.max() - xSize,
+                              colV.max() - ySize, 0))) + 2
+        expected = reference_poly_fill(rowV + pad, colV + pad, xSize + 2 * pad,
+                                       ySize + 2 * pad)[pad:pad + xSize, pad:pad + ySize]
+    np.testing.assert_array_equal(polyFill(rowV, colV, xSize, ySize), expected)
+
+
+@pytest.mark.parametrize("integer", [False, True])
+def test_random_polygons(integer):
+    rng = np.random.default_rng(0 if integer else 1)
+    for _ in range(300):
+        nPts = int(rng.integers(3, 60))
+        rowV, colV = star_polygon(rng, (64, 64), rng.uniform(2, 60), nPts, integer)
+        assert_same(rowV, colV, 128, 128)
+
+
+def test_axis_aligned_and_degenerate():
+    # square with flat edges on integer scanlines
+    assert_same([10, 10, 20, 20], [10, 30, 30, 10], 64, 64)
+    # half-integer square
+    assert_same([10.5, 10.5, 20.5, 20.5], [10.5, 30.5, 30.5, 10.5], 64, 64)
+    # triangle with integer vertices
+    assert_same([10, 20, 30, 20], [5, 10, 5, 1], 50, 50)
+    # sub-pixel polygon
+    assert_same([5.2, 5.4, 5.3], [5.1, 5.2, 5.4], 16, 16)
+    # single point and a line
+    assert_same([5.0], [5.0], 16, 16)
+    assert_same([2.0, 12.0], [3.0, 3.0], 16, 16)
+
+
+def test_polygon_extending_past_image():
+    rng = np.random.default_rng(2)
+    for _ in range(100):
+        rowV, colV = star_polygon(rng, (rng.uniform(40, 60), rng.uniform(40, 60)), 30, 25)
+        assert_same(rowV, colV, 64, 64)
+        # crossing the top/left border (negative indices)
+        rowV, colV = star_polygon(rng, (rng.uniform(0, 10), rng.uniform(15, 50)), 12, 25)
+        assert_same(rowV, colV, 64, 64)
+
+
+def test_multi_segment_contour():
+    # two disjoint polygons concatenated into one vertex list
+    rowV = np.r_[10.3, 10.3, 20.7, 20.7, 30.2, 40.8, 35.5]
+    colV = np.r_[10.2, 20.6, 20.6, 10.2, 30.1, 30.9, 45.4]
+    assert_same(rowV, colV, 64, 64)

pycerr-2.2.0/pycerr.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "2.2.0",
-  "distance": 0,
-  "node": "g1496840a36511ad614704e99556a973f04f2d509",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-17"
-}