rastr 0.5.0__tar.gz → 0.7.0__tar.gz

{rastr-0.5.0 → rastr-0.7.0}/.github/copilot-instructions.md

@@ -69,7 +69,9 @@
 
 - Use `uv run pytest` for testing, and ensure all tests are passing before committing changes.
 - Do not perform equality checks with floating point values; instead, use `pytest.approx`.
-- Use only one assert statement per test function to ensure clarity and simplicity.
+- Follow an arrange-act-assert structure in test functions with explicit comments separating each section where possible (context managers can force the assert and act sections to be unified).
+- In the assert block of each test, use only one contiguous block of assert statements to ensure clarity and simplicity.
+
 
 ## Documentation & Workflow Management
 

{rastr-0.5.0 → rastr-0.7.0}/.github/workflows/ci.yml

@@ -1,7 +1,6 @@
 name: CI
 permissions:
   contents: read
-  pull-requests: write
 on:
   workflow_dispatch:
   push:
@@ -21,12 +20,15 @@ concurrency:
   cancel-in-progress: true
 jobs:
   tests:
+    name: Run Tests and Checks
     runs-on: ${{ matrix.os }}
     env:
       PYTHONIOENCODING: utf-8
     steps:
       - name: Checkout code
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
 
       - name: Setup git user config
         run: |
@@ -41,8 +43,10 @@ jobs:
 
       - name: Setup Python
         run: |
-          uv python pin ${{ matrix.python-version }}
+          uv python pin ${PYTHON_VERSION}
           uv python install
+        env:
+          PYTHON_VERSION: ${{ matrix.python-version }}
 
       - name: Run pre-commit
         if: matrix.checks
@@ -54,6 +58,13 @@ jobs:
         run: |
           uv run pyright
 
+      - name: Run zizmor
+        if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
+        run: |
+          uv run zizmor --no-progress --pedantic .github/
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Run pytest
         uses: pavelzw/pytest-action@510c5e90c360a185039bea56ce8b3e7e51a16507 # v2.2.0
         if: matrix.pytest
@@ -92,6 +103,8 @@ jobs:
     name: Analyse Code Quality
     runs-on: ubuntu-latest
     needs: tests
+    permissions:
+      pull-requests: write # SonarQube needs to post comments on PRs
     if: always() && needs.tests.result == 'success'
 
     steps:
@@ -99,6 +112,7 @@ jobs:
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:
           fetch-depth: 0 # Shallow clones should be disabled for better relevancy of analysis
+          persist-credentials: false
 
       - name: Download coverage reports
         uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
@@ -110,7 +124,7 @@ jobs:
       - name: Create SonarQube properties
         run: |
           cat > sonar-project.properties << EOF
-          sonar.projectKey=${{ vars.SONAR_PROJECT_KEY }}
+          sonar.projectKey=${SONAR_PROJECT_KEY}
           sonar.language=py
           sonar.python.version=3.13
           sonar.sources=./src
@@ -119,9 +133,11 @@ jobs:
           sonar.exclusions=**/Dockerfile,**/notebooks/**,**/scripts/**
           sonar.verbose=false
           EOF
+        env:
+          SONAR_PROJECT_KEY: ${{ vars.SONAR_PROJECT_KEY }}
 
       - name: Run SonarQube analysis
-        uses: SonarSource/sonarqube-scan-action@884b79409bbd464b2a59edc326a4b77dc56b2195 # v3.1.0
+        uses: SonarSource/sonarqube-scan-action@fd88b7d7ccbaefd23d8f36f73b59db7a3d246602 # v6.0.0
         env:
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
           SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL }}

rastr-0.7.0/.github/workflows/release.yml

@@ -0,0 +1,35 @@
+name: Release to PyPI
+permissions:
+  contents: read
+on:
+  push:
+    tags:
+      - "v*"
+jobs:
+  deploy:
+    name: Release on PyPI
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      id-token: write # This is necessary to use trusted publishing with uv
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@3b9817b1bf26186f03ab8277bab9b827ea5cc254 # v3.2.0
+        with:
+          version: "0.7.13" # Sync with pyproject.toml
+          enable-cache: false
+
+      - name: "Set up Python"
+        uses: actions/setup-python@0b93645e9fea7318ecaed2b359559ac225c90a2b # v5.3.0
+        with:
+          python-version: 3.13
+
+      - name: Release
+        run: |
+          uv build
+          uv publish --trusted-publishing always

{rastr-0.5.0 → rastr-0.7.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: rastr
-Version: 0.5.0
+Version: 0.7.0
 Summary: Geospatial Raster datatype library for Python.
 Project-URL: Source Code, https://github.com/tonkintaylor/rastr
 Project-URL: Bug Tracker, https://github.com/tonkintaylor/rastr/issues
 Project-URL: Releases, https://github.com/tonkintaylor/rastr/releases
-Project-URL: Source Archive, https://github.com/tonkintaylor/rastr/archive/fde05e3c098da7ff9e77a37332d55fb7dbacd873.zip
+Project-URL: Source Archive, https://github.com/tonkintaylor/rastr/archive/2b485cc676121c82f468dca7733e444c3033abbe.zip
 Author-email: Tonkin & Taylor Limited <Sub-DisciplineData+AnalyticsStaff@tonkintaylor.co.nz>, Nathan McDougall <nmcdougall@tonkintaylor.co.nz>, Ben Karl <bkarl@tonkintaylor.co.nz>
 License-Expression: MIT
 License-File: LICENSE
@@ -77,8 +77,8 @@ from rastr.create import full_raster
 from rastr.meta import RasterMeta
 from rastr.raster import Raster
 
-# Create an example raster
-raster = Raster.example()
+# Read a raster from a file
+raster = Raster.read_file("path/to/raster.tif")
 
 # Basic arithmetic operations
 doubled = raster * 2

{rastr-0.5.0 → rastr-0.7.0}/README.md

@@ -43,8 +43,8 @@ from rastr.create import full_raster
 from rastr.meta import RasterMeta
 from rastr.raster import Raster
 
-# Create an example raster
-raster = Raster.example()
+# Read a raster from a file
+raster = Raster.read_file("path/to/raster.tif")
 
 # Basic arithmetic operations
 doubled = raster * 2

{rastr-0.5.0 → rastr-0.7.0}/pyproject.toml

@@ -66,6 +66,7 @@ dev = [
   "ruff>=0.13.2",
   "tqdm>=4.67.1",
   "usethis>=0.15.2",
+  "zizmor>=1.14.2",
 ]
 test = [
   "coverage[toml]>=7.10.1",
@@ -263,6 +264,6 @@ root_packages = [ "rastr" ]
 [[tool.importlinter.contracts]]
 name = "rastr"
 type = "layers"
-layers = [ "create | io", "raster", "meta", "arr | gis", "_version" ]
+layers = [ "create : io : raster", "meta", "arr | gis", "_version" ]
 containers = [ "rastr" ]
 exhaustive = true

rastr-0.7.0/src/rastr/__init__.py

@@ -0,0 +1,7 @@
+from rastr.meta import RasterMeta
+from rastr.raster import Raster
+
+__all__ = [
+    "Raster",
+    "RasterMeta",
+]

{rastr-0.5.0 → rastr-0.7.0}/src/rastr/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.7.0'
+__version_tuple__ = version_tuple = (0, 7, 0)
 
 __commit_id__ = commit_id = None

{rastr-0.5.0 → rastr-0.7.0}/src/rastr/arr/fill.py

@@ -8,7 +8,7 @@ if TYPE_CHECKING:
     from numpy.typing import NDArray
 
 
-def fillna_nearest_neighbours(arr: NDArray[np.float64]) -> NDArray[np.float64]:
+def fillna_nearest_neighbours(arr: NDArray) -> NDArray:
     """Fill NaN values in an N-dimensional array with their nearest neighbours' values.
 
     The nearest neighbour is determined using the Euclidean distance between array
@@ -28,4 +28,5 @@ def fillna_nearest_neighbours(arr: NDArray[np.float64]) -> NDArray[np.float64]:
     # Interpolate at the array indices
     interp = NearestNDInterpolator(nonnan_idxs, arr[nonnan_mask])
     filled_arr = interp(*np.indices(arr.shape))
-    return filled_arr
+    # Preserve the original dtype
+    return filled_arr.astype(arr.dtype)

{rastr-0.5.0 → rastr-0.7.0}/src/rastr/create.py

@@ -11,12 +11,14 @@ from affine import Affine
 from pyproj import CRS
 from shapely.geometry import Point
 
+from rastr.gis.crs import get_affine_sign
 from rastr.gis.fishnet import create_point_grid, get_point_grid_shape
+from rastr.gis.interpolate import interpn_kernel
 from rastr.meta import RasterMeta
 from rastr.raster import Raster
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
+    from collections.abc import Collection, Iterable
 
     import geopandas as gpd
     from numpy.typing import ArrayLike
@@ -141,7 +143,7 @@ def rasterize_gdf(
     gdf: gpd.GeoDataFrame,
     *,
     raster_meta: RasterMeta,
-    target_cols: list[str],
+    target_cols: Collection[str],
 ) -> list[Raster]:
     """Rasterize geometries from a GeoDataFrame.
 
@@ -183,9 +185,10 @@ def rasterize_gdf(
     shape = get_point_grid_shape(bounds=expanded_bounds, cell_size=cell_size)
 
     # Create the affine transform for rasterization
+    xs, ys = get_affine_sign(raster_meta.crs)
     transform = Affine.translation(
         expanded_bounds[0], expanded_bounds[3]
-    ) * Affine.scale(cell_size, -cell_size)
+    ) * Affine.scale(xs * cell_size, ys * cell_size)
 
     # Create rasters for each target column using rasterio.features.rasterize
     rasters = []
@@ -212,7 +215,9 @@ def rasterize_gdf(
     return rasters
 
 
-def _validate_columns_exist(gdf: gpd.GeoDataFrame, target_cols: list[str]) -> None:
+def _validate_columns_exist(
+    gdf: gpd.GeoDataFrame, target_cols: Collection[str]
+) -> None:
     """Validate that all target columns exist in the GeoDataFrame.
 
     Args:
@@ -228,7 +233,9 @@ def _validate_columns_exist(gdf: gpd.GeoDataFrame, target_cols: list[str]) -> No
         raise MissingColumnsError(msg)
 
 
-def _validate_columns_numeric(gdf: gpd.GeoDataFrame, target_cols: list[str]) -> None:
+def _validate_columns_numeric(
+    gdf: gpd.GeoDataFrame, target_cols: Collection[str]
+) -> None:
     """Validate that all target columns contain numeric data.
 
     Args:
@@ -308,14 +315,31 @@ def raster_from_point_cloud(
     Raises:
         ValueError: If any (x, y) points are duplicated, or if they are all collinear.
     """
-    from scipy.interpolate import LinearNDInterpolator
-    from scipy.spatial import KDTree, QhullError
-
-    x = np.asarray(x).ravel()
-    y = np.asarray(y).ravel()
-    z = np.asarray(z).ravel()
     crs = CRS.from_user_input(crs)
+    x, y, z = _validate_xyz(
+        np.asarray(x).ravel(), np.asarray(y).ravel(), np.asarray(z).ravel()
+    )
 
+    raster_meta, shape = RasterMeta.infer(x, y, cell_size=cell_size, crs=crs)
+    arr = interpn_kernel(
+        points=np.column_stack((x, y)),
+        values=z,
+        xi=np.column_stack(_get_grid(raster_meta, shape=shape)),
+    ).reshape(shape)
+
+    # We only support float rasters for now; we should preserve the input dtype if
+    # possible
+    if z.dtype in (np.float16, np.float32, np.float64):
+        arr = arr.astype(z.dtype)
+    else:
+        arr = arr.astype(np.float64)
+
+    return Raster(arr=arr, raster_meta=raster_meta)
+
+
+def _validate_xyz(
+    x: np.ndarray, y: np.ndarray, z: np.ndarray
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     # Validate input arrays
     if len(x) != len(y) or len(x) != len(z):
         msg = "Length of x, y, and z must be equal."
@@ -339,53 +363,18 @@ def raster_from_point_cloud(
         msg = "Duplicate (x, y) points found. Each (x, y) point must be unique."
         raise ValueError(msg)
 
-    # Heuristic for cell size if not provided
-    if cell_size is None:
-        # Half the 5th percentile of nearest neighbor distances between the (x,y) points
-        tree = KDTree(xy_points)
-        distances, _ = tree.query(xy_points, k=2)
-        distances: np.ndarray
-        cell_size = float(np.percentile(distances[distances > 0], 5)) / 2
-
-    # Compute bounds from data
-    minx, miny, maxx, maxy = np.min(x), np.min(y), np.max(x), np.max(y)
-
-    # Compute grid shape
-    width = int(np.ceil((maxx - minx) / cell_size))
-    height = int(np.ceil((maxy - miny) / cell_size))
-    shape = (height, width)
+    return x, y, z
 
-    # Compute transform: upper left corner is (minx, maxy)
-    transform = Affine.translation(minx, maxy) * Affine.scale(cell_size, -cell_size)
 
-    # Create grid coordinates for raster cells
+def _get_grid(
+    raster_meta: RasterMeta, *, shape: tuple[int, int]
+) -> tuple[np.ndarray, np.ndarray]:
+    """Get coordinates for raster cell centres based on raster metadata and shape."""
     rows, cols = np.indices(shape)
     xs, ys = rasterio.transform.xy(
-        transform=transform, rows=rows, cols=cols, offset="center"
+        transform=raster_meta.transform, rows=rows, cols=cols, offset="center"
     )
     grid_x = np.array(xs).ravel()
     grid_y = np.array(ys).ravel()
 
-    # Perform interpolation
-    try:
-        interpolator = LinearNDInterpolator(
-            points=xy_points, values=z, fill_value=np.nan
-        )
-    except QhullError as err:
-        msg = (
-            "Failed to interpolate. This may be due to insufficient or "
-            "degenerate input points. Ensure that the (x, y) points are not all "
-            "collinear (i.e. that the convex hull is non-degenerate)."
-        )
-        raise ValueError(msg) from err
-
-    grid_values = np.array(interpolator(np.column_stack((grid_x, grid_y))))
-
-    arr = grid_values.reshape(shape).astype(np.float32)
-
-    raster_meta = RasterMeta(
-        cell_size=cell_size,
-        crs=crs,
-        transform=transform,
-    )
-    return Raster(arr=arr, raster_meta=raster_meta)
+    return grid_x, grid_y

rastr-0.7.0/src/rastr/gis/crs.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import warnings
+from typing import Literal
+
+from pyproj import CRS
+
+
+def get_affine_sign(crs: CRS | str) -> tuple[Literal[+1, -1], Literal[+1, -1]]:
+    """Return (x_sign, y_sign) for an Affine scale, given a CRS.
+
+    Some coordinate systems may use unconventional axis directions, in which case
+    the correct direction may not be possible to infer correctly. In these cases,
+    the assumption is that x increases to the right, and y increases upwards.
+    """
+    crs = CRS.from_user_input(crs)
+
+    # Try to detect horizontal axis directions from CRS metadata
+    dir_x, dir_y, *_ = [(a.direction or "").lower() for a in crs.axis_info]
+
+    try:
+        if _is_conventional_direction(dir_x):
+            x_sign = +1
+        else:
+            x_sign = -1
+    except NotImplementedError:
+        msg = (
+            f"Could not determine x-axis direction from CRS axis info '{dir_x}'. "
+            "Falling back to +1 (increasing to the right)."
+        )
+        warnings.warn(msg, stacklevel=2)
+        x_sign = +1
+
+    try:
+        if _is_conventional_direction(dir_y):
+            y_sign = -1
+        else:
+            y_sign = +1
+    except NotImplementedError:
+        msg = (
+            f"Could not determine y-axis direction from CRS axis info '{dir_y}'. "
+            "Falling back to -1 (increasing upwards)."
+        )
+        warnings.warn(msg, stacklevel=2)
+        y_sign = -1
+
+    return x_sign, y_sign
+
+
+def _is_conventional_direction(direction: str) -> bool:
+    """Return True if the axis direction indicates positive increase."""
+    if (
+        "north" in direction
+        or "up" in direction
+        or "east" in direction
+        or "right" in direction
+    ):
+        return True
+    elif (
+        "south" in direction
+        or "down" in direction
+        or "west" in direction
+        or "left" in direction
+    ):
+        return False
+    else:
+        raise NotImplementedError

{rastr-0.5.0 → rastr-0.7.0}/src/rastr/gis/fishnet.py

@@ -41,8 +41,20 @@ def get_point_grid_shape(
     """Calculate the shape of the point grid based on bounds and cell size."""
 
     xmin, ymin, xmax, ymax = bounds
-    ncols = int(np.ceil((xmax - xmin) / cell_size))
-    nrows = int(np.ceil((ymax - ymin) / cell_size))
+    ncols_exact = (xmax - xmin) / cell_size
+    nrows_exact = (ymax - ymin) / cell_size
+
+    # Use round for values very close to integers to avoid floating-point
+    # sensitivity while maintaining ceil behavior for truly fractional values
+    if np.isclose(ncols_exact, np.round(ncols_exact)):
+        ncols = int(np.round(ncols_exact))
+    else:
+        ncols = int(np.ceil(ncols_exact))
+
+    if np.isclose(nrows_exact, np.round(nrows_exact)):
+        nrows = int(np.round(nrows_exact))
+    else:
+        nrows = int(np.ceil(nrows_exact))
 
     return nrows, ncols
 

rastr-0.7.0/src/rastr/gis/interpolate.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def interpn_kernel(
+    points: np.ndarray,
+    values: np.ndarray,
+    *,
+    xi: np.ndarray,
+    kernel: Callable[[np.ndarray], np.ndarray] | None = None,
+) -> np.ndarray:
+    """Interpolate scattered data to new points, with optional kernel transformation.
+
+    For example, you could provide a kernel to transform cartesian coordinate points
+    to polar coordinates before interpolation, giving interpolation which follows the
+    circular pattern of the data.
+
+    Args:
+        points: Array of shape (n_points, n_dimensions) representing the input points.
+        values: Array of shape (n_points,) representing the values at each input point.
+        xi: Array of shape (m_points, n_dimensions) representing the points to
+            interpolate to.
+        kernel: Optional function to transform points (and xi) before interpolation.
+    """
+    from scipy.interpolate import LinearNDInterpolator
+    from scipy.spatial import QhullError
+
+    if kernel is not None:
+        xi = kernel(xi)
+        points = kernel(points)
+    try:
+        interpolator = LinearNDInterpolator(
+            points=points, values=values, fill_value=np.nan
+        )
+    except QhullError as err:
+        msg = (
+            "Failed to interpolate. This may be due to insufficient or "
+            "degenerate input points. Ensure that the (x, y) points are not all "
+            "collinear (i.e. that the convex hull is non-degenerate)."
+        )
+        raise ValueError(msg) from err
+
+    grid_values = np.array(interpolator(xi))
+    return grid_values

rastr-0.7.0/src/rastr/gis/smooth.py

@@ -0,0 +1,161 @@
+"""Utilities for smoothing geometries.
+
+Fork + Port of <https://github.com/philipschall/shapelysmooth> (Public domain)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeVar
+
+import numpy as np
+from numpy.lib.stride_tricks import sliding_window_view
+from shapely.geometry import LineString, Polygon
+from typing_extensions import assert_never
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+T = TypeVar("T", bound=LineString | Polygon)
+
+
+class InputeTypeError(TypeError):
+    """Raised when the input geometry is of the incorrect type."""
+
+
+def catmull_rom_smooth(geometry: T, alpha: float = 0.5, subdivs: int = 10) -> T:
+    """Polyline smoothing using Catmull-Rom splines.
+
+    Args:
+        geometry: The geometry to smooth
+        alpha: The tension parameter, between 0 and 1 inclusive. Defaults to 0.5.
+               - For uniform Catmull-Rom splines, alpha = 0.
+               - For centripetal Catmull-Rom splines, alpha = 0.5.
+               - For chordal Catmull-Rom splines, alpha = 1.0.
+        subdivs:
+            Number of subdivisions of each polyline segment. Default value: 10.
+
+    Returns: The smoothed geometry.
+    """
+    coords, interior_coords = _get_coords(geometry)
+    coords_smoothed = _catmull_rom(coords, alpha=alpha, subdivs=subdivs)
+    if isinstance(geometry, LineString):
+        return geometry.__class__(coords_smoothed)
+    elif isinstance(geometry, Polygon):
+        interior_coords_smoothed = [
+            _catmull_rom(c, alpha=alpha, subdivs=subdivs) for c in interior_coords
+        ]
+        return geometry.__class__(coords_smoothed, holes=interior_coords_smoothed)
+    else:
+        assert_never(geometry)
+
+
+def _catmull_rom(
+    coords: NDArray,
+    *,
+    alpha: float = 0.5,
+    subdivs: int = 8,
+) -> list[tuple[float, float]]:
+    arr = np.asarray(coords, dtype=float)
+    n = arr.shape[0]
+    if n < 2:
+        return arr.tolist()
+
+    is_closed = np.allclose(arr[0], arr[-1])
+    if is_closed:
+        arr = np.vstack([arr[-2], arr, arr[2]])
+    else:
+        arr = np.vstack(
+            [
+                2.0 * arr[0] + 1.0 * arr[1],
+                arr,
+                2.0 * arr[-1] + 0.0 * arr[-2],
+            ]
+        )
+
+    # Shape of (segments, 4, D)
+    segments = sliding_window_view(arr, (4, arr.shape[1]))[:, 0, :]
+
+    # Distances and tangent values
+    diffs = np.diff(segments, axis=1)
+    dists = np.linalg.norm(diffs, axis=2)
+    tangents = np.concatenate(
+        [np.zeros((len(dists), 1)), np.cumsum(dists**alpha, axis=1)], axis=1
+    )
+
+    # Build ts per segment
+    if subdivs > 1:
+        seg_lens = (tangents[:, 2] - tangents[:, 1]) / subdivs
+        u = np.linspace(1, subdivs - 1, subdivs - 1)
+        ts = tangents[:, [1]] + seg_lens[:, None] * u  # (N-3, subdivs-1)
+    else:
+        ts = np.empty((len(segments), 0))
+
+    # Vectorize over segments
+    out_segments = []
+    for seg, tang, tvals in zip(segments, tangents, ts, strict=True):
+        if tvals.size:
+            out_segments.append(
+                _recursive_eval(seg, np.asarray(tang), np.asarray(tvals))
+            )
+    if out_segments:
+        all_midpoints = np.vstack(out_segments)
+    else:
+        all_midpoints = np.empty((0, arr.shape[1]))
+
+    # Gather final output in order
+    result = [tuple(arr[1])]
+    idx = 0
+    for k in range(len(segments)):
+        block = all_midpoints[idx : idx + max(subdivs - 1, 0)]
+        result.extend(map(tuple, block))
+        result.append(tuple(segments[k, 2]))
+        idx += max(subdivs - 1, 0)
+
+    return result
+
+
+def _recursive_eval(slice4: NDArray, tangents: NDArray, ts: NDArray) -> NDArray:
+    """De Boor/De Casteljau-style recursive linear interpolation over 4 control points.
+
+    Parameterized by the non-uniform 'tangents' values.
+    """
+    slice4 = np.asarray(slice4, dtype=float)
+    tangents = np.asarray(tangents, dtype=float)
+    ts = np.asarray(ts, dtype=float)
+    bigm = ts.shape[0]
+    bigd = slice4.shape[1]
+
+    # Initialize points for all ts, shape (M, 4, D)
+    points = np.broadcast_to(slice4, (bigm, 4, bigd)).copy()
+
+    # Recursive interpolation, but vectorized across all ts
+    for r in range(1, 4):
+        idx = max(r - 2, 0)
+        denom = tangents[r - idx : 4 - idx] - tangents[idx : 4 - r + idx]
+        denom = np.where(denom == 0, np.finfo(float).eps, denom)  # avoid div 0
+
+        # Compute weights for all parameter values at once
+        left_w = (tangents[r - idx : 4 - idx][None, :] - ts[:, None]) / denom
+        right_w = 1 - left_w
+
+        # Weighted sums between consecutive points
+        points = (
+            left_w[..., None] * points[:, 0 : 4 - r, :]
+            + right_w[..., None] * points[:, 1 : 5 - r, :]
+        )
+
+    # Result is first (and only) point at this level
+    return points[:, 0, :]
+
+
+def _get_coords(
+    geometry: LineString | Polygon,
+) -> tuple[NDArray, list[NDArray]]:
+    if isinstance(geometry, LineString):
+        return np.array(geometry.coords), []
+    elif isinstance(geometry, Polygon):
+        return np.array(geometry.exterior.coords), [
+            np.array(hole.coords) for hole in geometry.interiors
+        ]
+    else:
+        assert_never(geometry)