rastr 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

rastr/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
+
+__commit_id__ = commit_id = None

rastr/arr/fill.py

@@ -1,6 +1,11 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import numpy as np
-from numpy.typing import NDArray
-from scipy.interpolate import NearestNDInterpolator
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
 
 
 def fillna_nearest_neighbours(arr: NDArray[np.float64]) -> NDArray[np.float64]:
@@ -11,6 +16,8 @@ def fillna_nearest_neighbours(arr: NDArray[np.float64]) -> NDArray[np.float64]:
     In the case of tiebreaks, the value from the neighbour with the lowest index is
     imputed.
     """
+    from scipy.interpolate import NearestNDInterpolator
+
     nonnan_mask = np.nonzero(~np.isnan(arr))
     nonnan_idxs = np.array(nonnan_mask).transpose()
 

rastr/create.py

@@ -1,18 +1,32 @@
-from collections.abc import Iterable
-from functools import partial
+from __future__ import annotations
+
+import importlib.util
+import warnings
+from typing import TYPE_CHECKING, TypeVar
 
-import geopandas as gpd
 import numpy as np
-import pandas as pd
 import rasterio.features
+import rasterio.transform
 from affine import Affine
-from shapely.geometry import Point, Polygon
-from tqdm.notebook import tqdm
+from pyproj import CRS
+from shapely.geometry import Point
 
 from rastr.gis.fishnet import create_point_grid, get_point_grid_shape
 from rastr.meta import RasterMeta
 from rastr.raster import RasterModel
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    import geopandas as gpd
+    from numpy.typing import ArrayLike
+    from shapely.geometry import Polygon
+
+
+TQDM_INSTALLED = importlib.util.find_spec("tqdm") is not None
+
+_T = TypeVar("_T")
+
 
 class MissingColumnsError(ValueError):
     """Raised when target columns are missing from the GeoDataFrame."""
@@ -61,17 +75,10 @@ def raster_distance_from_polygon(
     Raises:
         ValueError: If the provided CRS is geographic (lat/lon).
     """
-    if extent_polygon is None and snap_raster is None:
-        err_msg = "Either 'extent_polygon' or 'snap_raster' must be provided. "
-        raise ValueError(err_msg)
-    elif extent_polygon is not None and snap_raster is not None:
-        err_msg = "Only one of 'extent_polygon' or 'snap_raster' can be provided. "
-        raise ValueError(err_msg)
-
-    if not show_pbar:
-
-        def _pbar(x: Iterable) -> None:
-            return x  # No-op if no progress bar is needed
+    if show_pbar and not TQDM_INSTALLED:
+        msg = "The 'tqdm' package is not installed. Progress bars will not be shown."
+        warnings.warn(msg, UserWarning, stacklevel=2)
+        show_pbar = False
 
     # Check if the provided CRS is projected (cartesian)
     if raster_meta.crs.is_geographic:
@@ -80,36 +87,44 @@ def raster_distance_from_polygon(
         )
         raise ValueError(err_msg)
 
-    # Calculate the coordinates
-    if snap_raster is not None:
+    if extent_polygon is None and snap_raster is None:
+        err_msg = "Either 'extent_polygon' or 'snap_raster' must be provided. "
+        raise ValueError(err_msg)
+    elif extent_polygon is not None and snap_raster is not None:
+        err_msg = "Only one of 'extent_polygon' or 'snap_raster' can be provided. "
+        raise ValueError(err_msg)
+    elif extent_polygon is None and snap_raster is not None:
+        # Calculate the coordinates
         x, y = snap_raster.get_xy()
-    else:
+
+        # Create a mask to identify points for which distance should be calculated
+        distance_extent = snap_raster.bbox.difference(polygon)
+    elif extent_polygon is not None and snap_raster is None:
         x, y = create_point_grid(
             bounds=extent_polygon.bounds, cell_size=raster_meta.cell_size
         )
-
-    points = [Point(x, y) for x, y in zip(x.flatten(), y.flatten(), strict=True)]
-
-    # Create a mask to identify points for which distance should be calculated
-    if extent_polygon is not None:
         distance_extent = extent_polygon.difference(polygon)
     else:
-        distance_extent = snap_raster.bbox.difference(polygon)
+        raise AssertionError
 
-    if show_pbar:
-        _pbar = partial(tqdm, desc="Finding points within extent")
-    mask = [distance_extent.intersects(point) for point in _pbar(points)]
+    pts = [Point(x, y) for x, y in zip(x.flatten(), y.flatten(), strict=True)]
 
-    if show_pbar:
-        _pbar = partial(tqdm, desc="Calculating distances")
-    distances = np.where(
-        mask, np.array([polygon.distance(point) for point in _pbar(points)]), np.nan
-    )
+    _pts = _pbar(pts, desc="Finding points within extent") if show_pbar else pts
+    mask = [distance_extent.intersects(pt) for pt in _pts]
+
+    _pts = _pbar(pts, desc="Calculating distances") if show_pbar else pts
+    distances = np.where(mask, np.array([polygon.distance(pt) for pt in _pts]), np.nan)
     distance_raster = distances.reshape(x.shape)
 
     return RasterModel(arr=distance_raster, raster_meta=raster_meta)
 
 
+def _pbar(iterable: Iterable[_T], *, desc: str | None = None) -> Iterable[_T]:
+    from tqdm import tqdm
+
+    return tqdm(iterable, desc=desc)
+
+
 def full_raster(
     raster_meta: RasterMeta,
     *,
@@ -185,7 +200,8 @@ def rasterize_gdf(
             shapes,
             out_shape=shape,
             transform=transform,
-            fill=np.nan,  # Fill gaps with NaN
+            # Fill gaps with NaN
+            fill=np.nan,  # type: ignore[reportArgumentType] docstring contradicts inferred annotation
             dtype=np.float32,
         )
 
@@ -222,6 +238,8 @@ def _validate_columns_numeric(gdf: gpd.GeoDataFrame, target_cols: list[str]) ->
     Raises:
         NonNumericColumnsError: If any columns contain non-numeric data.
     """
+    import pandas as pd
+
     non_numeric_cols = []
     for col in target_cols:
         if not pd.api.types.is_numeric_dtype(gdf[col]):
@@ -259,3 +277,105 @@ def _validate_no_overlapping_geometries(gdf: gpd.GeoDataFrame) -> None:
                     "Overlapping geometries can lead to data loss during rasterization."
                 )
                 raise OverlappingGeometriesError(msg)
+
+
+def raster_from_point_cloud(
+    x: ArrayLike,
+    y: ArrayLike,
+    z: ArrayLike,
+    *,
+    crs: CRS | str,
+    cell_size: float | None = None,
+) -> RasterModel:
+    """Create a raster from a point cloud via interpolation.
+
+    Interpolation is only possible within the convex hull of the points. Outside of
+    this, cells will be NaN-valued.
+
+    All (x,y) points must be unique.
+
+    Args:
+        x: X coordinates of points.
+        y: Y coordinates of points.
+        z: Values at each (x, y) point to assign the raster.
+        crs: Coordinate reference system for the (x, y) coordinates.
+        cell_size: Desired cell size for the raster. If None, a heuristic is used based
+                   on the spacing between (x, y) points.
+
+    Returns:
+        Raster containing the interpolated values.
+
+    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)
+
+    # Validate input arrays
+    if len(x) != len(y) or len(x) != len(z):
+        msg = "Length of x, y, and z must be equal."
+        raise ValueError(msg)
+    if len(x) < 3:
+        msg = "At least three (x, y, z) points are required to triangulate a surface."
+        raise ValueError(msg)
+    # Check for duplicate (x, y) points
+    xy_points = np.column_stack((x, y))
+    if len(xy_points) != len(np.unique(xy_points, axis=0)):
+        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(np.column_stack((x, y)))
+        distances, _ = tree.query(np.column_stack((x, y)), 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)
+
+    # 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
+    rows, cols = np.indices(shape)
+    xs, ys = rasterio.transform.xy(
+        transform=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 RasterModel(arr=arr, raster_meta=raster_meta)

rastr/gis/fishnet.py

@@ -1,12 +1,18 @@
-import geopandas as gpd
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import numpy as np
-from geopandas.array import GeometryArray
 from shapely import BufferCapStyle, BufferJoinStyle
 
+if TYPE_CHECKING:
+    from geopandas.array import GeometryArray
+    from numpy.typing import NDArray
+
 
 def create_point_grid(
     *, bounds: tuple[float, float, float, float], cell_size: float
-) -> tuple[np.ndarray, np.ndarray]:
+) -> tuple[NDArray, NDArray]:
     """Create a regular grid of point coordinates for raster centers.
 
     This function replicates the original grid generation logic that uses
@@ -25,7 +31,8 @@ def create_point_grid(
     x_coords = np.arange(xmin + cell_size / 2, xmax + cell_size / 2, cell_size)
     y_coords = np.arange(ymax - cell_size / 2, ymin - cell_size / 2, -cell_size)
 
-    return np.meshgrid(x_coords, y_coords)
+    x_points, y_points = np.meshgrid(x_coords, y_coords)  # type: ignore[reportAssignmentType]
+    return x_points, y_points
 
 
 def get_point_grid_shape(
@@ -58,6 +65,8 @@ def create_fishnet(
     Returns:
         Shapely Polygons.
     """
+    import geopandas as gpd
+
     # Use the shared helper function to create the point grid
     xx, yy = create_point_grid(bounds=bounds, cell_size=res)
 

rastr/gis/smooth.py

@@ -5,12 +5,15 @@ Fork + Port of <https://github.com/philipschall/shapelysmooth> (Public domain)
 
 from __future__ import annotations
 
-from typing import TypeAlias
+from typing import TYPE_CHECKING, TypeAlias
 
 import numpy as np
 from shapely.geometry import LineString, Polygon
 from typing_extensions import assert_never
 
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
 T: TypeAlias = LineString | Polygon
 
 
@@ -46,7 +49,7 @@ def catmull_rom_smooth(geometry: T, alpha: float = 0.5, subdivs: int = 10) -> T:
 
 
 def _catmull_rom(
-    coords: np.ndarray,
+    coords: NDArray,
     *,
     alpha: float = 0.5,
     subdivs: int = 8,
@@ -89,7 +92,7 @@ def _catmull_rom(
 
 
 def _recursive_eval(
-    slice4: np.ndarray, tangents: list[float], ts: np.ndarray
+    slice4: NDArray, tangents: list[float], ts: NDArray
 ) -> list[tuple[float, float]]:
     """De Boor/De Casteljau-style recursive linear interpolation over 4 control points.
 
@@ -128,7 +131,7 @@ def _recursive_eval(
 
 def _get_coords(
     geometry: LineString | Polygon,
-) -> tuple[np.ndarray, list[np.ndarray]]:
+) -> tuple[NDArray, list[NDArray]]:
     if isinstance(geometry, LineString):
         return np.array(geometry.coords), []
     elif isinstance(geometry, Polygon):

rastr/io.py

@@ -1,16 +1,26 @@
+from __future__ import annotations
+
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import numpy as np
 import rasterio
-from numpy.typing import NDArray
-from pyproj.crs import CRS
+import rasterio.merge
+from pyproj.crs.crs import CRS
 
 from rastr.meta import RasterMeta
 from rastr.raster import RasterModel
 
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
 
-def read_raster_inmem(raster_path: Path, crs: CRS | None = None) -> RasterModel:
+def read_raster_inmem(
+    raster_path: Path | str, *, crs: CRS | str | None = None
+) -> RasterModel:
     """Read raster data from a file and return an in-memory Raster object."""
+    crs = CRS.from_user_input(crs) if crs is not None else None
+
     with rasterio.open(raster_path, mode="r") as dst:
         # Read the entire array
         arr: NDArray[np.float64] = dst.read()
@@ -27,3 +37,58 @@ def read_raster_inmem(raster_path: Path, crs: CRS | None = None) -> RasterModel:
     raster_meta = RasterMeta(cell_size=cell_size, crs=crs, transform=transform)
     raster_obj = RasterModel(arr=arr, raster_meta=raster_meta)
     return raster_obj
+
+
+def read_raster_mosaic_inmem(
+    mosaic_dir: Path | str, *, glob: str = "*.tif", crs: CRS | None = None
+) -> RasterModel:
+    """Read a raster mosaic from a directory and return an in-memory Raster object.
+
+    This assumes that all rasters have the same metadata, e.g. coordinate system,
+    cell size, etc.
+    """
+    mosaic_dir = Path(mosaic_dir)
+    raster_paths = list(mosaic_dir.glob(glob))
+    if not raster_paths:
+        msg = f"No raster files found in {mosaic_dir} matching {glob}"
+        raise FileNotFoundError(msg)
+
+    # Sort raster_paths in alphabetical order by stem
+    raster_paths.sort(key=lambda p: p.stem)
+
+    # Open all TIFF datasets using context managers to ensure proper closure
+    sources = []
+    try:
+        for raster_path in raster_paths:
+            src = rasterio.open(raster_path)
+            sources.append(src)
+
+        # Merge into a single mosaic array & transform
+        arr, transform = rasterio.merge.merge(sources)
+
+        # Copy metadata from the first dataset
+        out_meta = sources[0].meta.copy()
+        out_meta.update(
+            {
+                "driver": "GTiff",
+                "height": arr.shape[1],
+                "width": arr.shape[2],
+                "transform": transform,
+            }
+        )
+        cell_size = sources[0].res[0]
+        if crs is None:
+            crs = CRS.from_user_input(sources[0].crs)
+
+        nodata = sources[0].nodata
+        if nodata is not None:
+            arr[arr == nodata] = np.nan
+
+        arr = arr.squeeze().astype(np.float64)
+
+        raster_meta = RasterMeta(cell_size=cell_size, crs=crs, transform=transform)
+        raster_obj = RasterModel(arr=arr, raster_meta=raster_meta)
+        return raster_obj
+    finally:
+        for src in sources:
+            src.close()

rastr/meta.py

@@ -1,8 +1,15 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 import numpy as np
 from affine import Affine
 from pydantic import BaseModel, InstanceOf
 from pyproj import CRS
-from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+    from typing_extensions import Self
 
 
 class RasterMeta(BaseModel, extra="forbid"):
@@ -11,6 +18,8 @@ class RasterMeta(BaseModel, extra="forbid"):
     Attributes:
         cell_size: Cell size in meters.
         crs: Coordinate reference system.
+        transform: The affine transformation associated with the raster. This is based
+                   on the CRS, the cell size, as well as the offset/origin.
     """
 
     cell_size: float
@@ -26,7 +35,7 @@ class RasterMeta(BaseModel, extra="forbid"):
             transform=Affine.scale(2.0, 2.0),
         )
 
-    def get_cell_centre_coords(self, shape: tuple[int, int]) -> np.ndarray:
+    def get_cell_centre_coords(self, shape: tuple[int, int]) -> NDArray:
         """Return an array of (x, y) coordinates for the center of each cell.
 
         The coordinates will be in the coordinate system defined by the
@@ -36,13 +45,43 @@ class RasterMeta(BaseModel, extra="forbid"):
             shape: (rows, cols) of the raster array.
 
         Returns:
-            np.ndarray of shape (rows, cols, 2) with (x, y) coordinates for each
-            cell center.
+            (x, y) coordinates for each cell center, with shape (rows, cols, 2)
         """
-        rows, cols = shape
-        x_idx = np.arange(cols)
-        y_idx = np.arange(rows)
-        xv, yv = np.meshgrid(x_idx, y_idx)
-        x_coords, y_coords = self.transform * (xv + 0.5, yv + 0.5)
-        coords = np.stack([x_coords, y_coords], axis=-1)
+        x_coords = self.get_cell_x_coords(shape[1])  # cols for x-coordinates
+        y_coords = self.get_cell_y_coords(shape[0])  # rows for y-coordinates
+        coords = np.stack(np.meshgrid(x_coords, y_coords), axis=-1)
         return coords
+
+    def get_cell_x_coords(self, n_columns: int) -> NDArray:
+        """Return an array of x coordinates for the center of each cell.
+
+        The coordinates will be in the coordinate system defined by the
+        raster's transform.
+
+        Args:
+            n_columns: Number of columns in the raster array.
+
+        Returns:
+            x_coordinates at cell centers, with shape (n_columns,)
+        """
+        x_idx = np.arange(n_columns) + 0.5
+        y_idx = np.zeros_like(x_idx)  # Use y=0 for a single row
+        x_coords, _ = self.transform * (x_idx, y_idx)  # type: ignore[reportAssignmentType] overloaded tuple size in affine
+        return x_coords
+
+    def get_cell_y_coords(self, n_rows: int) -> NDArray:
+        """Return an array of y coordinates for the center of each cell.
+
+        The coordinates will be in the coordinate system defined by the
+        raster's transform.
+
+        Args:
+            n_rows: Number of rows in the raster array.
+
+        Returns:
+            y_coordinates at cell centers, with shape (n_rows,)
+        """
+        x_idx = np.zeros(n_rows)  # Use x=0 for a single column
+        y_idx = np.arange(n_rows) + 0.5
+        _, y_coords = self.transform * (x_idx, y_idx)  # type: ignore[reportAssignmentType] overloaded tuple size in affine
+        return y_coords