fastpgv 0.1.0__tar.gz

fastpgv-0.1.0/.github/workflows/testpypi.yml

@@ -0,0 +1,48 @@
+name: TestPyPI
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    uses: ./.github/workflows/wheels.yml
+  publish:
+    needs: build
+    runs-on: ubuntu-22.04
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/fastpgv
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: python -m pip install twine
+      - run: python -m twine check dist/*
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+  verify:
+    needs: publish
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: python -m pip install numpy
+      - name: Install published package (allow index propagation)
+        run: |
+          for attempt in 1 2 3 4 5; do
+            python -m pip install --index-url https://test.pypi.org/simple/ --only-binary=:all: --no-deps fastpgv==0.1.0 && break
+            sleep 20
+          done
+          python -c 'import fastpgv; assert fastpgv.__version__ == "0.1.0"'
+      - run: python examples/two_polygons.py

fastpgv-0.1.0/.github/workflows/wheels.yml

@@ -0,0 +1,57 @@
+name: Build and Test
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  wheels:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            arch: x86_64
+          - os: macos-14
+            arch: arm64
+          - os: macos-15-intel
+            arch: x86_64
+          - os: windows-2022
+            arch: AMD64
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pypa/cibuildwheel@v3.1
+        env:
+          CIBW_ARCHS: ${{ matrix.arch }}
+          CIBW_ENVIRONMENT_MACOS: MACOSX_DEPLOYMENT_TARGET=11.0
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+  source:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: python -m pip install build twine
+      - run: python -m build --sdist
+      - run: python -m twine check dist/*
+      - name: Build and test outside the repository
+        run: |
+          mkdir /tmp/fastpgv-source
+          tar -xf dist/*.tar.gz -C /tmp/fastpgv-source
+          cd /tmp/fastpgv-source/fastpgv-0.1.0
+          python -m pip install '.[test]'
+          python -m pytest
+          python examples/two_polygons.py
+      - uses: actions/upload-artifact@v4
+        with:
+          name: source
+          path: dist/*.tar.gz

fastpgv-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+build/
+dist/
+wheelhouse/
+__pycache__/
+.pytest_cache/
+*.egg-info/

fastpgv-0.1.0/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.18)
+project(fastpgv LANGUAGES CXX)
+set(PYBIND11_FINDPYTHON ON)
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+find_package(pybind11 CONFIG REQUIRED)
+find_package(Threads REQUIRED)
+pybind11_add_module(_native cpp/bindings.cpp cpp/sled.cpp)
+target_link_libraries(_native PRIVATE Threads::Threads)
+target_compile_features(_native PRIVATE cxx_std_17)
+if(MSVC)
+  target_compile_options(_native PRIVATE /W4 /fp:precise)
+else()
+  target_compile_options(_native PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+install(TARGETS _native LIBRARY DESTINATION fastpgv RUNTIME DESTINATION fastpgv)

fastpgv-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SLED contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastpgv-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: fastpgv
+Version: 0.1.0
+Summary: Weighted polygon-to-grid aggregation with the native SLED algorithm
+Keywords: polygon,raster,geospatial,SLED,aggregation
+Author: SLED contributors
+License-Expression: MIT
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
+License-File: licenses/pybind11-LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.23
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: shapely>=2; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: shapely>=2; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=6; extra == "dev"
+Description-Content-Type: text/markdown
+
+# fastpgv
+
+**fastpgv** is a lightweight Python wrapper for fast density computation for Polygon-to-Grid Visualization (PGV).
+
+This package provides an efficient way to compute density results through a simple Python interface.
+Compute a density value for every pixel from weighted polygons using the C++17 SLED (Sweep-Line Edge-Difference Aggregation) algorithm.
+
+## Features
+
+- One Python interface: `fastpgv.run(weighted_polygons, resolution)`.
+- Weighted polygons with explicit vertex coordinates.
+- The polygons should be non-overlapping.
+- C++ computation backend with the Python interface.
+
+## Installation
+
+From the `fastpgv/` source directory:
+
+```bash
+python -m pip install .
+```
+
+After version 0.1.0 is successfully published to production PyPI:
+
+```bash
+python -m pip install fastpgv==0.1.0
+```
+
+Publication is pending. The prepared wheel is for CPython 3.12 on macOS 11+
+Apple Silicon (arm64). Other environments need to build the source distribution
+with a C++17 compiler. Cross-platform wheels are not included in this release.
+
+## Requirements
+
+- Python 3.10 or newer.
+- NumPy, installed automatically by pip.
+- A C++17 compiler for source builds. pip installs the Python build dependencies.
+
+Java, DuckDB, APRIL, Boost, and the original benchmark repository are not required.
+
+## Quick Example
+
+```python
+import fastpgv
+
+# Polygons contain ordered vertex coordinates, not just identifiers.
+polygon_a = {
+    "type": "Polygon",
+    "coordinates": [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+}
+polygon_b = {
+    "type": "Polygon",
+    "coordinates": [[[1, 0], [2, 0], [2, 1], [1, 1], [1, 0]]],
+}
+
+density = fastpgv.run(
+    [(polygon_a, 2.0), (polygon_b, 3.0)],
+    resolution=(2, 1),
+)
+print(density)
+# [[2. 3.]]
+```
+
+## Inputs and Output
+
+Both arguments are required:
+
+| Argument | Meaning |
+|---|---|
+| `weighted_polygons` | Nonempty iterable of `(geometry, weight)` pairs |
+| `resolution` | Positive integer `(X, Y)`: columns and rows |
+
+Geometry must contain ordered vertices as a GeoJSON `Polygon` or `MultiPolygon`
+dictionary, or expose `__geo_interface__` (for example, a Shapely polygon).
+Consecutive vertices define edges automatically; open rings are closed internally.
+No separate edge input is required or accepted. The first ring is the exterior;
+additional rings are holes. MultiPolygon components share one weight.
+
+Weights must be explicit finite numbers. Negative and zero weights are supported.
+The supported use case is non-overlapping polygonal inputs: interiors must not
+overlap, but shared edges and vertices are allowed. Overlaps are not automatically
+checked; validate this requirement before calling `run`.
+The grid covers the combined minimum
+bounding rectangle of **all** supplied geometries, including zero-weight ones.
+
+`run` returns a `numpy.ndarray` directly, with dtype `float64` and shape `(Y, X)`.
+`density[v, u]` is the value of the pixel in row `v` and column `u`. Row zero is
+the top row at `y_max`; columns run from `x_min` to `x_max`.
+
+The function returns data directly; it does not write files or render a visualization.
+
+## Notes
+
+- Each pixel value is the sum of `weight * polygon_pixel_intersection_area`:
+  **weighted area, not area-normalized density**.
+- Coordinates are planar, with no CRS transformation or geodesic calculation.
+  Project geographic coordinates first when metric areas are required.
+- Supply valid polygon topology. Ring orientation is corrected, but invalid
+  holes and self-intersections are not repaired. Empty input is rejected.
+- Numerical tests use absolute tolerance `1e-9` or relative tolerance `1e-12`.
+  Floating-point results can differ across platforms; extreme coordinates or
+  weights may require rescaling and application-specific error analysis.
+- The complete output array requires `8 * X * Y` bytes, plus polygon-edge and
+  working storage. Choose a resolution that fits available memory.
+
+## License and Further Information
+
+MIT licensed, by **SLED contributors**.
+
+The source archive includes `PUBLISHING.md` (build and upload instructions),
+`PORTING.md` (implementation provenance), and `THIRD_PARTY_NOTICES.md`
+(dependency notices).

fastpgv-0.1.0/PORTING.md

@@ -0,0 +1,26 @@
+# Native engine provenance
+
+Version 0.1.0 is a standalone adaptation of the SLED implementation in
+`pgv-c-code/baseline/sled.cpp`, reviewed on 2026-09-07. The source workspace
+had no committed revision to identify. No sibling files are needed to build.
+The reference file's SHA-256 was
+`0bf6fc00ae4a03633bf97e0b85939c1f766de206544b53477d8d0d93b25a4e4d`.
+
+Retained algorithm: corrected outer/hole orientation, downward signed edges,
+exact coordinate-pair cancellation, row scheduling, vertical-grid fragment
+splitting, trapezoidal boundary integration, and row difference prefix sums.
+The density-only revision removes candidate-count buffers and instrumentation.
+
+Adaptation changes: Python validates weighted geometry pairs with vertices;
+C++ takes coordinate arrays instead of JSON strings. A Builder and one-row
+Sweep replace benchmark context/output dependencies. Translated shoelace
+coordinates reduce orientation cancellation; grid-index conversion clamps
+before integer conversion. Native buffers use long double as in SLED; output
+is float64. Interactive updates, benchmark timers, DuckDB, Boost, and APRIL
+are excluded. The public function is `run(weighted_polygons, resolution)`;
+bounds are inferred from input geometries. File readers and public row streaming
+are excluded. This snapshot is maintained independently, not auto-synchronized.
+
+Tests use analytical fixtures and Shapely intersection areas. Repository-local
+validation also compares densities against the original SLED and scan methods;
+their executable is not a package or test dependency.

fastpgv-0.1.0/PUBLISHING.md

@@ -0,0 +1,117 @@
+# Build and Publish
+
+## Release Status
+
+Package version: 0.1.0. TestPyPI and production PyPI publication have not yet
+occurred. A successful name lookup does not reserve a project name. Do not
+advertise `pip install fastpgv` from production PyPI until that release exists.
+
+## Manual Production Upload
+
+No GitHub repository is required. Upload only the freshly validated release
+files, not the older files in `dist/`. From the release directory containing
+the wheel, source archive, and `SHA256SUMS`:
+
+```bash
+python -m pip install --upgrade twine
+shasum -a 256 -c SHA256SUMS
+python -m twine check --strict fastpgv-0.1.0-cp312-cp312-macosx_11_0_arm64.whl fastpgv-0.1.0.tar.gz
+python -m twine upload --repository pypi fastpgv-0.1.0-cp312-cp312-macosx_11_0_arm64.whl fastpgv-0.1.0.tar.gz
+```
+
+Use a production account at pypi.org with a verified email and two-factor
+authentication configured. Create a production PyPI API token locally. For a
+first project upload, an account-scoped token may be needed; after creating the
+project, replace it with a project-scoped token. At Twine's prompts, enter
+`__token__` as the username and paste the token at the hidden password prompt.
+Never include the token in command arguments, files, or chat. TestPyPI accounts
+and tokens are separate and cannot authenticate to production PyPI.
+
+Before uploading, check https://pypi.org/project/fastpgv/ again. A missing project
+does not reserve the name or guarantee permission. If the name/version is no
+longer available, stop and resolve it instead of renaming artifacts manually.
+Uploaded filenames cannot be overwritten. Do not upload validation reports or
+checksum files: the command above names only the two distribution files.
+
+This release includes only a CPython 3.12 macOS 11+ arm64 wheel and a source
+archive. Other Python/platform combinations require a C++17 source build and
+are not confirmed by the local macOS validation. No cross-platform CI results
+are claimed.
+
+After uploading, verify in a new CPython 3.12 environment on macOS Apple Silicon:
+
+```bash
+python3.12 -m venv /tmp/fastpgv-pypi-check
+/tmp/fastpgv-pypi-check/bin/python -m pip install --index-url https://pypi.org/simple/ --only-binary=:all: fastpgv==0.1.0
+/tmp/fastpgv-pypi-check/bin/python -c 'import fastpgv; p={"type":"Polygon","coordinates":[[[0,0],[1,0],[1,1],[0,1],[0,0]]]}; assert fastpgv.run([(p,2)],(1,1)).tolist()==[[2.0]]; print("PyPI installation verified")'
+```
+
+Also run `examples/two_polygons.py` from the extracted source archive using that
+environment. Expected output is `[[2. 3.]]`. Publication and this post-upload
+check remain manual steps until the upload succeeds.
+
+## Optional GitHub Builds
+
+The workflows in this folder assume **fastpgv is the repository root**. Place
+this standalone folder in its own GitHub repository to activate them; workflows
+nested inside a parent repository are not automatically executed by GitHub.
+
+## Local Validation
+
+Use Python 3.10 or newer and a C++17 compiler:
+
+```bash
+python -m pip install build twine
+python -m build
+python -m twine check dist/*
+python -m venv /tmp/fastpgv-wheel-test
+/tmp/fastpgv-wheel-test/bin/python -m pip install dist/*.whl pytest shapely
+/tmp/fastpgv-wheel-test/bin/python -m pytest tests
+/tmp/fastpgv-wheel-test/bin/python examples/two_polygons.py
+```
+
+On Windows use the environment's `Scripts/python.exe` instead of `bin/python`.
+Also extract the source archive to a directory outside the original repository
+and run `python -m build --wheel` there. Check that no sibling source folders
+or installed benchmark binary are needed. Build outputs and validation results
+are local only; cross-platform support is confirmed by CI, not inferred from
+one macOS build.
+
+The wheel workflow targets standard CPython 3.10–3.14 on Linux x86_64,
+macOS arm64/x86_64, and Windows x86_64. It runs tests against installed wheels,
+including translated-coordinate and geometry-oracle tests on Windows, where
+`long double` has different precision. Free-threaded CPython and musl Linux
+are not targeted in this release.
+
+## Trusted Publishing to TestPyPI
+
+1. Create a TestPyPI account and enable its required account security settings.
+2. Create/configure the standalone GitHub repository. No repository URL or
+   publisher identity is embedded in this source snapshot.
+3. On TestPyPI, register a pending Trusted Publisher for `fastpgv`, using your
+   GitHub owner/repository, workflow `testpypi.yml`, and environment `testpypi`.
+   If the name is unavailable, resolve the name before publishing.
+4. Create the matching GitHub environment and require approval for publication.
+5. Run the **TestPyPI** workflow manually. It first builds and tests all wheels
+   plus the source archive, checks metadata, then uploads through OIDC.
+6. Review the post-upload installation check and TestPyPI project page.
+
+Never put API tokens in source files, workflow YAML, or chat. The workflow uses
+short-lived Trusted Publishing credentials. An upload is public and versioned;
+an existing filename cannot be overwritten. Fixes require a new version.
+
+Manual post-upload verification in a new environment:
+
+```bash
+python -m pip install numpy
+python -m pip install --index-url https://test.pypi.org/simple/ \
+  --only-binary=:all: --no-deps fastpgv==0.1.0
+python examples/two_polygons.py
+```
+
+The workflow above targets TestPyPI only. For the manual production release,
+use the explicit production upload command earlier in this guide.
+
+Official references: [Trusted Publishing](https://docs.pypi.org/trusted-publishers/),
+[packaging binary extensions](https://packaging.python.org/en/latest/guides/packaging-binary-extensions/),
+[cibuildwheel](https://cibuildwheel.pypa.io/).

fastpgv-0.1.0/README.md

@@ -0,0 +1,112 @@
+# fastpgv
+
+**fastpgv** is a lightweight Python wrapper for fast density computation for Polygon-to-Grid Visualization (PGV).
+
+This package provides an efficient way to compute density results through a simple Python interface.
+Compute a density value for every pixel from weighted polygons using the C++17 SLED (Sweep-Line Edge-Difference Aggregation) algorithm.
+
+## Features
+
+- One Python interface: `fastpgv.run(weighted_polygons, resolution)`.
+- Weighted polygons with explicit vertex coordinates.
+- The polygons should be non-overlapping.
+- C++ computation backend with the Python interface.
+
+## Installation
+
+From the `fastpgv/` source directory:
+
+```bash
+python -m pip install .
+```
+
+After version 0.1.0 is successfully published to production PyPI:
+
+```bash
+python -m pip install fastpgv==0.1.0
+```
+
+Publication is pending. The prepared wheel is for CPython 3.12 on macOS 11+
+Apple Silicon (arm64). Other environments need to build the source distribution
+with a C++17 compiler. Cross-platform wheels are not included in this release.
+
+## Requirements
+
+- Python 3.10 or newer.
+- NumPy, installed automatically by pip.
+- A C++17 compiler for source builds. pip installs the Python build dependencies.
+
+Java, DuckDB, APRIL, Boost, and the original benchmark repository are not required.
+
+## Quick Example
+
+```python
+import fastpgv
+
+# Polygons contain ordered vertex coordinates, not just identifiers.
+polygon_a = {
+    "type": "Polygon",
+    "coordinates": [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]],
+}
+polygon_b = {
+    "type": "Polygon",
+    "coordinates": [[[1, 0], [2, 0], [2, 1], [1, 1], [1, 0]]],
+}
+
+density = fastpgv.run(
+    [(polygon_a, 2.0), (polygon_b, 3.0)],
+    resolution=(2, 1),
+)
+print(density)
+# [[2. 3.]]
+```
+
+## Inputs and Output
+
+Both arguments are required:
+
+| Argument | Meaning |
+|---|---|
+| `weighted_polygons` | Nonempty iterable of `(geometry, weight)` pairs |
+| `resolution` | Positive integer `(X, Y)`: columns and rows |
+
+Geometry must contain ordered vertices as a GeoJSON `Polygon` or `MultiPolygon`
+dictionary, or expose `__geo_interface__` (for example, a Shapely polygon).
+Consecutive vertices define edges automatically; open rings are closed internally.
+No separate edge input is required or accepted. The first ring is the exterior;
+additional rings are holes. MultiPolygon components share one weight.
+
+Weights must be explicit finite numbers. Negative and zero weights are supported.
+The supported use case is non-overlapping polygonal inputs: interiors must not
+overlap, but shared edges and vertices are allowed. Overlaps are not automatically
+checked; validate this requirement before calling `run`.
+The grid covers the combined minimum
+bounding rectangle of **all** supplied geometries, including zero-weight ones.
+
+`run` returns a `numpy.ndarray` directly, with dtype `float64` and shape `(Y, X)`.
+`density[v, u]` is the value of the pixel in row `v` and column `u`. Row zero is
+the top row at `y_max`; columns run from `x_min` to `x_max`.
+
+The function returns data directly; it does not write files or render a visualization.
+
+## Notes
+
+- Each pixel value is the sum of `weight * polygon_pixel_intersection_area`:
+  **weighted area, not area-normalized density**.
+- Coordinates are planar, with no CRS transformation or geodesic calculation.
+  Project geographic coordinates first when metric areas are required.
+- Supply valid polygon topology. Ring orientation is corrected, but invalid
+  holes and self-intersections are not repaired. Empty input is rejected.
+- Numerical tests use absolute tolerance `1e-9` or relative tolerance `1e-12`.
+  Floating-point results can differ across platforms; extreme coordinates or
+  weights may require rescaling and application-specific error analysis.
+- The complete output array requires `8 * X * Y` bytes, plus polygon-edge and
+  working storage. Choose a resolution that fits available memory.
+
+## License and Further Information
+
+MIT licensed, by **SLED contributors**.
+
+The source archive includes `PUBLISHING.md` (build and upload instructions),
+`PORTING.md` (implementation provenance), and `THIRD_PARTY_NOTICES.md`
+(dependency notices).

fastpgv-0.1.0/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,12 @@
+# Dependencies and notices
+
+The SLED implementation is distributed under the MIT license in LICENSE.
+Native bindings use pybind11 (BSD-3-Clause); its notice is reproduced in
+`licenses/pybind11-LICENSE`. NumPy is a separately installed runtime dependency
+under its own BSD license; it is not bundled here. Build tools scikit-build-core,
+CMake, and a C++17 compiler are installed separately. Test tools pytest and
+Shapely are optional and are not runtime dependencies.
+
+No DuckDB, APRIL, Boost, private datasets, or benchmark outputs are included.
+CMake does not fetch source files from the network. A source build still needs
+the declared Python build dependencies, normally provisioned by pip.

fastpgv-0.1.0/cpp/bindings.cpp

@@ -0,0 +1,24 @@
+#include "sled.h"
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <algorithm>
+#include <limits>
+
+namespace py = pybind11;
+PYBIND11_MODULE(_native, module) {
+  module.attr("long_double_bits") = std::numeric_limits<long double>::digits;
+  py::class_<fastpgv::Sweep>(module, "Sweep")
+      .def("next_row", [](fastpgv::Sweep& sweep) {
+        fastpgv::Row row;
+        { py::gil_scoped_release release; row = sweep.next(); }
+        if (row.v < 0) throw py::stop_iteration();
+        py::array_t<double> density(row.density.size());
+        std::copy(row.density.begin(), row.density.end(), density.mutable_data());
+        return density;
+      });
+  py::class_<fastpgv::Builder>(module, "Builder")
+      .def(py::init<>())
+      .def("add", &fastpgv::Builder::add, py::call_guard<py::gil_scoped_release>())
+      .def("finish", &fastpgv::Builder::finish, py::call_guard<py::gil_scoped_release>());
+}

fastpgv-0.1.0/cpp/sled.cpp

@@ -0,0 +1,195 @@
+// Adapted from pgv-c-code/baseline/sled.cpp; see PORTING.md.
+#include "sled.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <stdexcept>
+#include <tuple>
+
+namespace fastpgv {
+namespace {
+auto key(const Edge& e) { return std::tie(e.xu, e.yu, e.xl, e.yl); }
+
+long double snap(long double value) {
+  const auto nearest = std::round(value);
+  const auto tolerance = 64.0L * std::numeric_limits<long double>::epsilon() *
+                         std::max(1.0L, std::abs(value));
+  return std::abs(value - nearest) <= tolerance ? nearest : value;
+}
+
+long double interpolate(const Edge& e, long double y) {
+  const auto t = (static_cast<long double>(e.yu) - y) /
+                 (static_cast<long double>(e.yu) - e.yl);
+  return e.xu + (static_cast<long double>(e.xl) - e.xu) * t;
+}
+
+// Clamp before integer conversion, including edges far outside a custom bbox.
+int bounded_index(long double position, int maximum) {
+  return static_cast<int>(std::clamp(position, 0.0L,
+                                   static_cast<long double>(maximum)));
+}
+}  // namespace
+
+void Builder::add(const Geometry& geometry, double weight) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (finished_) throw std::logic_error("builder has already been consumed");
+  if (!std::isfinite(weight)) throw std::invalid_argument("weight must be finite");
+  if (geometry.empty()) throw std::invalid_argument("geometry must not be empty");
+  std::vector<Edge> additions;
+  Bounds local{};
+  bool first = true;
+  for (const auto& polygon : geometry) {
+    if (polygon.empty()) throw std::invalid_argument("polygon requires an outer ring");
+    for (std::size_t r = 0; r < polygon.size(); ++r) {
+      std::vector<Point> ring;
+      for (const auto& point : polygon[r]) {
+        if (!std::isfinite(point[0]) || !std::isfinite(point[1]))
+          throw std::invalid_argument("coordinates must be finite");
+        if (first) { local = {point[0], point[1], point[0], point[1]}; first = false; }
+        local[0] = std::min(local[0], point[0]);
+        local[1] = std::min(local[1], point[1]);
+        local[2] = std::max(local[2], point[0]);
+        local[3] = std::max(local[3], point[1]);
+        if (ring.empty() || ring.back() != point) ring.push_back(point);
+      }
+      if (ring.size() < 3) throw std::invalid_argument("ring requires three distinct vertices");
+      if (ring.front() != ring.back()) ring.push_back(ring.front());
+      if (ring.size() < 4) throw std::invalid_argument("degenerate ring");
+      // Translation reduces cancellation on platforms where long double is double.
+      long double area = 0;
+      for (std::size_t i = 0; i + 1 < ring.size(); ++i) {
+        const long double ax = static_cast<long double>(ring[i][0]) - ring[0][0];
+        const long double ay = static_cast<long double>(ring[i][1]) - ring[0][1];
+        const long double bx = static_cast<long double>(ring[i+1][0]) - ring[0][0];
+        const long double by = static_cast<long double>(ring[i+1][1]) - ring[0][1];
+        area += ax * by - bx * ay;
+      }
+      if (!std::isfinite(area) || area == 0)
+        throw std::invalid_argument("ring has zero or non-finite signed area");
+      if ((area > 0) != (r == 0)) std::reverse(ring.begin(), ring.end());
+      for (std::size_t i = 0; i + 1 < ring.size(); ++i) {
+        const auto& a = ring[i]; const auto& b = ring[i+1];
+        if (a[1] == b[1]) continue;
+        if (a[1] > b[1]) additions.push_back({a[0], a[1], b[0], b[1], weight});
+        else additions.push_back({b[0], b[1], a[0], a[1], -static_cast<long double>(weight)});
+      }
+    }
+  }
+  edges_.insert(edges_.end(), additions.begin(), additions.end());
+  if (!have_bounds_) { bounds_ = local; have_bounds_ = true; }
+  else {
+    bounds_[0] = std::min(bounds_[0], local[0]); bounds_[1] = std::min(bounds_[1], local[1]);
+    bounds_[2] = std::max(bounds_[2], local[2]); bounds_[3] = std::max(bounds_[3], local[3]);
+  }
+}
+
+std::unique_ptr<Sweep> Builder::finish(int width, int height) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (finished_) throw std::logic_error("builder has already been consumed");
+  if (!have_bounds_) throw std::invalid_argument("weighted_polygons must not be empty");
+  const Bounds bounds = bounds_;
+  for (double value : bounds)
+    if (!std::isfinite(value)) throw std::invalid_argument("bounds must be finite");
+  if (width <= 0 || height <= 0 || bounds[2] <= bounds[0] || bounds[3] <= bounds[1])
+    throw std::invalid_argument("resolution and bounds must have positive extent");
+  if (width == std::numeric_limits<int>::max() || height == std::numeric_limits<int>::max())
+    throw std::invalid_argument("resolution exceeds native index capacity");
+  for (int axis = 0; axis < 2; ++axis) {
+    double span = bounds[axis+2] - bounds[axis];
+    double step = span / (axis == 0 ? width : height);
+    if (!std::isfinite(span) || !(step > 0) ||
+        bounds[axis] + step == bounds[axis] || bounds[axis+2] - step == bounds[axis+2])
+      throw std::invalid_argument("grid spacing is not representable at these coordinates");
+  }
+  std::stable_sort(edges_.begin(), edges_.end(), [](const Edge& a, const Edge& b) { return key(a) < key(b); });
+  std::size_t write = 0;
+  for (std::size_t i = 0; i < edges_.size();) {
+    auto edge = edges_[i++];
+    while (i < edges_.size() && key(edge) == key(edges_[i])) edge.weight += edges_[i++].weight;
+    if (!std::isfinite(edge.weight)) throw std::overflow_error("edge coefficient overflow");
+    if (edge.weight != 0) edges_[write++] = edge;
+  }
+  edges_.resize(write);
+  edges_.shrink_to_fit();
+  finished_ = true;
+  return std::make_unique<Sweep>(std::move(edges_), bounds, width, height);
+}
+
+Sweep::Sweep(std::vector<Edge> edges, Bounds bounds, int width, int height)
+    : edges_(std::move(edges)), bounds_(bounds), width_(width), height_(height),
+      dx_((bounds[2]-bounds[0])/width), dy_((bounds[3]-bounds[1])/height),
+      last_rows_(edges_.size(), -1), offsets_(static_cast<std::size_t>(height)+1, 0),
+      boundary_(width), difference_(static_cast<std::size_t>(width)+1) {
+  std::vector<int> first_rows(edges_.size(), -1);
+  for (std::size_t i = 0; i < edges_.size(); ++i) {
+    auto top = std::min(static_cast<long double>(edges_[i].yu), static_cast<long double>(bounds[3]));
+    auto bottom = std::max(static_cast<long double>(edges_[i].yl), static_cast<long double>(bounds[1]));
+    if (!(bottom < top)) continue;
+    int first = bounded_index(std::floor(snap((bounds[3]-top)/dy_)), height-1);
+    int last = bounded_index(std::ceil(snap((bounds[3]-bottom)/dy_))-1, height-1);
+    first_rows[i] = first; last_rows_[i] = last; ++offsets_[first+1];
+  }
+  for (int row = 1; row <= height; ++row) offsets_[row] += offsets_[row-1];
+  entries_.resize(offsets_.back());
+  auto cursors = offsets_;
+  for (std::size_t i = 0; i < edges_.size(); ++i)
+    if (first_rows[i] >= 0) entries_[cursors[first_rows[i]]++] = i;
+}
+
+void Sweep::accumulate(const Edge& edge, int row) {
+  long double top = std::min(static_cast<long double>(edge.yu),
+                            static_cast<long double>(bounds_[3] - row * dy_));
+  long double bottom = std::max(static_cast<long double>(edge.yl),
+                               static_cast<long double>(bounds_[3] - (row+1) * dy_));
+  if (!(bottom < top)) return;
+  auto xt = interpolate(edge, top), xb = interpolate(edge, bottom);
+  std::vector<long double> parameters{0, 1};
+  if (xt != xb) {
+    int first = bounded_index(std::floor(snap((std::min(xt,xb)-bounds_[0])/dx_))+1, width_);
+    int last = bounded_index(std::ceil(snap((std::max(xt,xb)-bounds_[0])/dx_))-1, width_);
+    for (int line = first; line <= last; ++line) {
+      auto t = (static_cast<long double>(bounds_[0]+line*dx_) - xt)/(xb-xt);
+      if (t > 0 && t < 1) parameters.push_back(t);
+    }
+  }
+  std::sort(parameters.begin(), parameters.end());
+  parameters.erase(std::unique(parameters.begin(), parameters.end()), parameters.end());
+  for (std::size_t i = 0; i+1 < parameters.size(); ++i) {
+    auto a = xt + (xb-xt)*parameters[i], b = xt + (xb-xt)*parameters[i+1];
+    auto h = (top-bottom)*(parameters[i+1]-parameters[i]);
+    auto midpoint = (a+b)*0.5L, suffix = edge.weight*h*dx_;
+    if (midpoint < bounds_[0]) { difference_[0] += suffix; difference_[width_] -= suffix; continue; }
+    if (midpoint >= bounds_[2]) continue;
+    int column = bounded_index(std::floor(snap((midpoint-bounds_[0])/dx_)), width_);
+    if (column >= width_) continue;
+    const long double right = bounds_[0]+(column+1)*dx_;
+    boundary_[column] += edge.weight*((right-a)+(right-b))*0.5L*h;
+    difference_[column+1] += suffix; difference_[width_] -= suffix;
+  }
+}
+
+Row Sweep::next() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (next_row_ == height_) return {-1, {}};
+  const int row = next_row_;
+  std::fill(boundary_.begin(), boundary_.end(), 0);
+  std::fill(difference_.begin(), difference_.end(), 0);
+  active_.insert(active_.end(), entries_.begin()+offsets_[row], entries_.begin()+offsets_[row+1]);
+  std::size_t retained = 0;
+  for (auto i : active_) {
+    accumulate(edges_[i], row);
+    if (last_rows_[i] > row) active_[retained++] = i;
+  }
+  active_.resize(retained);
+  Row result{row, std::vector<double>(width_)};
+  long double suffix = 0;
+  for (int column = 0; column < width_; ++column) {
+    suffix += difference_[column];
+    result.density[column] = static_cast<double>(boundary_[column]+suffix);
+    if (!std::isfinite(result.density[column])) throw std::overflow_error("density overflow");
+  }
+  ++next_row_;
+  return result;
+}
+}  // namespace fastpgv

fastpgv-0.1.0/cpp/sled.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <array>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace fastpgv {
+using Point = std::array<double, 2>;
+using Polygon = std::vector<std::vector<Point>>;
+using Geometry = std::vector<Polygon>;
+using Bounds = std::array<double, 4>;
+
+struct Edge {
+  double xu, yu, xl, yl;
+  long double weight;
+};
+
+struct Row {
+  int v;
+  std::vector<double> density;
+};
+
+class Sweep {
+ public:
+  Sweep(std::vector<Edge> edges, Bounds bounds, int width, int height);
+  Row next();
+
+ private:
+  void accumulate(const Edge& edge, int row);
+  std::vector<Edge> edges_;
+  Bounds bounds_;
+  int width_, height_, next_row_ = 0;
+  double dx_, dy_;
+  std::vector<int> last_rows_;
+  std::vector<std::size_t> offsets_, entries_, active_;
+  std::vector<long double> boundary_, difference_;
+  std::mutex mutex_;
+};
+
+class Builder {
+ public:
+  void add(const Geometry& geometry, double weight);
+  std::unique_ptr<Sweep> finish(int width, int height);
+ private:
+  std::vector<Edge> edges_;
+  Bounds bounds_{};
+  bool have_bounds_ = false, finished_ = false;
+  std::mutex mutex_;
+};
+}  // namespace fastpgv

fastpgv-0.1.0/examples/two_polygons.py

@@ -0,0 +1,8 @@
+import fastpgv
+
+polygons = [
+    {"type": "Polygon", "coordinates": [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]]},
+    {"type": "Polygon", "coordinates": [[[1, 0], [2, 0], [2, 1], [1, 1], [1, 0]]]},
+]
+density = fastpgv.run([(polygons[0], 2), (polygons[1], 3)], resolution=(2, 1))
+print(density)  # [[2., 3.]]

fastpgv-0.1.0/licenses/pybind11-LICENSE

@@ -0,0 +1,29 @@
+Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
+
+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. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT HOLDER OR CONTRIBUTORS 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.
+
+Please also refer to the file .github/CONTRIBUTING.md, which clarifies licensing of
+external contributions to this project including patches, pull requests, etc.

fastpgv-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["scikit-build-core>=0.11,<2", "pybind11>=3.0,<4"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "fastpgv"
+version = "0.1.0"
+description = "Weighted polygon-to-grid aggregation with the native SLED algorithm"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE", "THIRD_PARTY_NOTICES.md", "licenses/*"]
+authors = [{name = "SLED contributors"}]
+dependencies = ["numpy>=1.23"]
+keywords = ["polygon", "raster", "geospatial", "SLED", "aggregation"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: C++",
+  "Topic :: Scientific/Engineering :: GIS",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "shapely>=2"]
+dev = ["pytest>=8", "shapely>=2", "build>=1.2", "twine>=6"]
+
+[tool.scikit-build]
+cmake.version = ">=3.18"
+wheel.packages = ["src/fastpgv"]
+sdist.include = ["cpp/*.cpp", "cpp/*.h", "src/fastpgv/*.py", "tests/*.py", "examples/*.py", "licenses/*", "/README.md", "/PORTING.md", "/PUBLISHING.md", "/THIRD_PARTY_NOTICES.md", "/LICENSE", "/CMakeLists.txt", "/pyproject.toml", ".github/workflows/*.yml"]
+sdist.exclude = ["dist/**", "build/**", ".venv/**", "**/__pycache__/**", "**/*.pyc", ".pytest_cache/**"]
+
+[tool.cibuildwheel]
+build = "cp310-* cp311-* cp312-* cp313-* cp314-*"
+skip = "*-musllinux_* *-win32 *-manylinux_i686"
+test-requires = ["pytest>=8", "shapely>=2"]
+test-command = "python -m pytest {project}/tests"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

fastpgv-0.1.0/src/fastpgv/__init__.py

@@ -0,0 +1,75 @@
+"""SLED weighted polygon-to-grid aggregation."""
+import math as _math
+from numbers import Integral as _Integral, Real as _Real
+
+import numpy as _np
+from . import _native
+
+__version__ = "0.1.0"
+__all__ = ["run"]
+
+
+def _number(value, label):
+    if isinstance(value, bool) or not isinstance(value, _Real):
+        raise ValueError(f"{label} must be a finite number")
+    try:
+        result = float(value)
+    except (OverflowError, ValueError) as exc:
+        raise ValueError(f"{label} must be a finite number") from exc
+    if not _math.isfinite(result):
+        raise ValueError(f"{label} must be a finite number")
+    return result
+
+
+def _geometry(value):
+    value = getattr(value, "__geo_interface__", value)
+    if not isinstance(value, dict) or value.get("type") not in ("Polygon", "MultiPolygon"):
+        raise ValueError("geometry must be a GeoJSON Polygon or MultiPolygon with vertex coordinates")
+    try:
+        polygons = [value["coordinates"]] if value["type"] == "Polygon" else value["coordinates"]
+        return [
+            [[[_number(p[0], "coordinate"), _number(p[1], "coordinate")]
+              for p in ring] for ring in polygon] for polygon in polygons]
+    except (KeyError, IndexError, TypeError) as exc:
+        raise ValueError("invalid polygon vertex coordinates") from exc
+
+
+def run(weighted_polygons, resolution):
+    """Return weighted intersection areas as a float64 array shaped (Y, X).
+
+    weighted_polygons is an iterable of (geometry, weight) pairs. Geometry
+    contains ordered vertices as a GeoJSON Polygon/MultiPolygon dictionary
+    or an object exposing __geo_interface__. Weights must be finite.
+    resolution is (X, Y); both dimensions are required positive integers.
+    Bounds are inferred from all polygons. Row zero is the top/northern row.
+    Valid polygon topology is required; coordinates are treated as planar.
+    """
+    try:
+        dimensions = tuple(resolution)
+    except TypeError as exc:
+        raise ValueError("resolution must be two positive integers (X, Y)") from exc
+    if len(dimensions) != 2 or any(isinstance(v, bool) or not isinstance(v, _Integral)
+                                 or not 0 < v < 2147483647 for v in dimensions):
+        raise ValueError("resolution must be two positive integers (X, Y)")
+    x, y = map(int, dimensions)
+    builder = _native.Builder()
+    try:
+        records = iter(weighted_polygons)
+    except TypeError as exc:
+        raise ValueError("weighted_polygons must be an iterable of (geometry, weight) pairs") from exc
+    for index, record in enumerate(records):
+        if isinstance(record, (str, bytes, dict)):
+            raise ValueError(f"weighted polygon {index} must be a (geometry, weight) pair")
+        try:
+            geometry, weight = record
+        except (TypeError, ValueError) as exc:
+            raise ValueError(f"weighted polygon {index} must be a (geometry, weight) pair") from exc
+        try:
+            builder.add(_geometry(geometry), _number(weight, "weight"))
+        except ValueError as exc:
+            raise ValueError(f"weighted polygon {index}: {exc}") from exc
+    sweep = builder.finish(x, y)
+    density = _np.empty((y, x), dtype=_np.float64)
+    for v in range(y):
+        density[v] = sweep.next_row()
+    return density

fastpgv-0.1.0/tests/test_benchmark_reference.py

@@ -0,0 +1,37 @@
+"""Optional snapshot parity check; not required for standalone wheel tests.
+
+Set FASTPGV_BASELINE to the absolute pgv_baselines executable path.
+"""
+import csv
+import os
+import subprocess
+
+import numpy as np
+import pytest
+from shapely.geometry import box
+
+import fastpgv
+from test_fastpgv import fixture, write_records
+
+
+@pytest.mark.skipif(not os.environ.get("FASTPGV_BASELINE"), reason="optional benchmark executable")
+@pytest.mark.parametrize("resolution", [(4, 4), (17, 13)])
+@pytest.mark.parametrize("shared", [False, True])
+def test_benchmark_reference(tmp_path, resolution, shared):
+    source = tmp_path / "records.jsonl"
+    geometries, weights = ([box(0, 0, 2, 4), box(2, 0, 4, 4)], [2, 2]) if shared else fixture()
+    write_records(source, geometries, weights)
+    process = subprocess.run([
+        os.environ["FASTPGV_BASELINE"], "--records", str(source), "--resolution", f"{resolution[0]}x{resolution[1]}",
+        "--method", "scan,SLED", "--threads", "1",
+        "--out-dir", str(tmp_path / "reference"), "--run-name", "package_validation",
+        "--compare", "--no-progress"], capture_output=True, text=True)
+    assert process.returncode == 0, process.stderr + process.stdout
+    result = fastpgv.run(zip(geometries, weights), resolution)
+    paths = list((tmp_path / "reference").rglob("pixels.csv"))
+    assert len(paths) == 2
+    for path in paths:
+        with path.open() as f:
+            rows = list(csv.DictReader(f))
+        np.testing.assert_allclose(result.ravel(), [float(r["density"]) for r in rows],
+                                   atol=1e-9, rtol=1e-12)

fastpgv-0.1.0/tests/test_fastpgv.py

@@ -0,0 +1,115 @@
+import json
+import inspect
+
+import numpy as np
+import pytest
+from shapely.geometry import Polygon, MultiPolygon, box, mapping
+
+import fastpgv
+
+
+def fixture():
+    return [box(0, 0, 2, 2), Polygon([(0.25, 0.25), (3.75, 0.75), (2.25, 3.75)]),
+            Polygon([(0, 0), (4, 0), (4, 4), (0, 4)],
+                    [[(1, 1), (3, 1), (3, 3), (1, 3)]]),
+            MultiPolygon([box(0, 3, 1, 4), box(3, 0, 4, 1)]), box(1.25, 1.25, 2.75, 2.75)], \
+           [1, 2, 0.5, -0.75, 0]
+
+
+def write_records(path, geometries, weights):
+    with path.open("w") as f:
+        for geometry, weight in zip(geometries, weights):
+            f.write(json.dumps({"cell_id": "duplicate", "geometry": mapping(geometry),
+                                "weight": {"value": weight}}) + "\n")
+
+
+@pytest.mark.parametrize("resolution", [(4, 4), (17, 13), (1, 1)])
+def test_geometry_oracle(resolution):
+    geometries, weights = fixture()
+    result = fastpgv.run(zip(geometries, weights), resolution)
+    x, y = resolution
+    expected = np.zeros((y, x))
+    dx, dy = 4/x, 4/y
+    for v in range(y):
+        for u in range(x):
+            pixel = box(u*dx, 4-(v+1)*dy, (u+1)*dx, 4-v*dy)
+            expected[v, u] = sum(w*g.intersection(pixel).area for g, w in zip(geometries, weights))
+    difference = np.abs(result - expected)
+    assert np.all((difference <= 1e-9) | (difference <= 1e-12*np.abs(expected)))
+    assert result.dtype == np.float64 and result.shape == (y, x)
+
+
+def test_example_and_vertices():
+    # Overlaps remain an internal algorithm regression, not a public guarantee.
+    a = {"type": "Polygon", "coordinates": [[[0, 0], [2, 0], [2, 2], [0, 2], [0, 0]]]}
+    b = {"type": "Polygon", "coordinates": [[[1, 1], [2, 1], [2, 2], [1, 2]]]}
+    np.testing.assert_array_equal(fastpgv.run([(a, 2), (b, 3)], (2, 2)), [[2, 5], [2, 2]])
+
+
+def test_release_example():
+    a, b = box(0, 0, 1, 1), box(1, 0, 2, 1)
+    assert a.intersection(b).area == 0
+    np.testing.assert_array_equal(fastpgv.run([(mapping(a), 2), (mapping(b), 3)], (2, 1)), [[2, 3]])
+
+
+def test_shared_boundaries_and_zero_weights():
+    left, right = box(0, 0, 1, 2), box(1, 0, 2, 2)
+    np.testing.assert_array_equal(fastpgv.run([(left, 1), (right, 2)], (2, 2)), [[1, 2], [1, 2]])
+    assert not fastpgv.run([(left, 1), (left, -1)], (2, 2)).any()
+    # Zero-weight geometry still defines the domain.
+    np.testing.assert_array_equal(fastpgv.run([(box(0, 0, 1, 1), 1), (box(0, 0, 2, 2), 0)], (2, 2)),
+                                  [[0, 0], [1, 0]])
+    assert not fastpgv.run([(left, 0)], (2, 2)).any()
+
+
+def test_orientation_and_unsegmented_edges():
+    left = Polygon([(0, 0), (0, 2), (1, 2), (1, 1), (1, 0)])
+    right = box(1, 0, 2, 2)
+    np.testing.assert_array_equal(fastpgv.run([(left, 1), (right, 1)], (2, 2)), np.ones((2, 2)))
+
+
+def test_translated_coordinates():
+    # Also runs on Windows, where long double has 53 significand bits.
+    origin = 1e8
+    polygon = Polygon([(origin, origin), (origin+2, origin), (origin, origin+2)])
+    np.testing.assert_allclose(fastpgv.run([(polygon, 1)], (2, 2)), [[0.5, 0], [1, 0.5]], atol=1e-9)
+
+
+@pytest.mark.parametrize("resolution", [(0, 2), (2.5, 2), (True, 2), (2,), (2147483647, 2), None])
+def test_invalid_resolution(resolution):
+    with pytest.raises(ValueError, match="resolution"):
+        fastpgv.run([(box(0, 0, 1, 1), 1)], resolution)
+
+
+@pytest.mark.parametrize("geometry", [{"type": "Point", "coordinates": [0, 0]},
+    {"type": "Polygon", "coordinates": []},
+    {"type": "Polygon", "coordinates": [[[0, 0], [1, 1], [2, 2]]]},
+    {"type": "Polygon", "coordinates": [[[0, 0], [1, float("nan")], [2, 0]]]},
+    {"type": "Polygon", "coordinates": None}, "polygon_id"])
+def test_invalid_geometry(geometry):
+    with pytest.raises(ValueError):
+        fastpgv.run([(geometry, 1)], (2, 2))
+
+
+@pytest.mark.parametrize("weight", [float("nan"), float("inf"), "1", True, 10**400])
+def test_invalid_weight(weight):
+    with pytest.raises(ValueError, match="weight"):
+        fastpgv.run([(box(0, 0, 1, 1), weight)], (2, 2))
+
+
+@pytest.mark.parametrize("records", [[], None, [()], [(1, 2, 3)], ["ab"], [{"geometry": {}, "weight": 1}]])
+def test_invalid_pairs(records):
+    with pytest.raises(ValueError):
+        fastpgv.run(records, (2, 2))
+
+
+def test_public_api():
+    assert fastpgv.__all__ == ["run"]
+    assert list(inspect.signature(fastpgv.run).parameters) == ["weighted_polygons", "resolution"]
+    for name in ("rasterize", "rasterize_jsonl", "iter_rows_jsonl", "GridResult", "GridRow"):
+        assert not hasattr(fastpgv, name)
+    for keyword in ("bounds", "weights", "streaming"):
+        with pytest.raises(TypeError):
+            fastpgv.run([(box(0, 0, 1, 1), 1)], (2, 2), **{keyword: None})
+    with pytest.raises(TypeError):
+        fastpgv.run([(box(0, 0, 1, 1), 1)])