rastr 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

rastr/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)
 
 __commit_id__ = commit_id = None

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/create.py

@@ -13,10 +13,10 @@ 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
+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
@@ -49,9 +49,9 @@ def raster_distance_from_polygon(
     *,
     raster_meta: RasterMeta,
     extent_polygon: Polygon | None = None,
-    snap_raster: RasterModel | None = None,
+    snap_raster: Raster | None = None,
     show_pbar: bool = False,
-) -> RasterModel:
+) -> Raster:
     """Make a raster where each cell's value is its centre's distance to a polygon.
 
     The raster should use a projected coordinate system.
@@ -116,7 +116,7 @@ def raster_distance_from_polygon(
     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)
+    return Raster(arr=distance_raster, raster_meta=raster_meta)
 
 
 def _pbar(iterable: Iterable[_T], *, desc: str | None = None) -> Iterable[_T]:
@@ -130,19 +130,19 @@ def full_raster(
     *,
     bounds: tuple[float, float, float, float],
     fill_value: float = np.nan,
-) -> RasterModel:
+) -> Raster:
     """Create a raster with a specified fill value for all cells."""
     shape = get_point_grid_shape(bounds=bounds, cell_size=raster_meta.cell_size)
     arr = np.full(shape, fill_value, dtype=np.float32)
-    return RasterModel(arr=arr, raster_meta=raster_meta)
+    return Raster(arr=arr, raster_meta=raster_meta)
 
 
 def rasterize_gdf(
     gdf: gpd.GeoDataFrame,
     *,
     raster_meta: RasterMeta,
-    target_cols: list[str],
-) -> list[RasterModel]:
+    target_cols: Collection[str],
+) -> list[Raster]:
     """Rasterize geometries from a GeoDataFrame.
 
     Supports polygons, points, linestrings, and other geometry types.
@@ -205,14 +205,16 @@ def rasterize_gdf(
             dtype=np.float32,
         )
 
-        # Create RasterModel
-        raster = RasterModel(arr=raster_array, raster_meta=raster_meta)
+        # Create Raster
+        raster = Raster(arr=raster_array, raster_meta=raster_meta)
         rasters.append(raster)
 
     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 +230,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:
@@ -286,7 +290,7 @@ def raster_from_point_cloud(
     *,
     crs: CRS | str,
     cell_size: float | None = None,
-) -> RasterModel:
+) -> Raster:
     """Create a raster from a point cloud via interpolation.
 
     Interpolation is only possible within the convex hull of the points. Outside of
@@ -320,8 +324,18 @@ def raster_from_point_cloud(
     if len(x) != len(y) or len(x) != len(z):
         msg = "Length of x, y, and z must be equal."
         raise ValueError(msg)
+    xy_finite_mask = np.isfinite(x) & np.isfinite(y)
+    if np.any(~xy_finite_mask):
+        msg = "Some (x,y) points are NaN-valued or non-finite. These will be ignored."
+        warnings.warn(msg, stacklevel=2)
+        x = x[xy_finite_mask]
+        y = y[xy_finite_mask]
+        z = z[xy_finite_mask]
     if len(x) < 3:
-        msg = "At least three (x, y, z) points are required to triangulate a surface."
+        msg = (
+            "At least three valid (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))
@@ -332,8 +346,8 @@ def raster_from_point_cloud(
     # 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)
+        tree = KDTree(xy_points)
+        distances, _ = tree.query(xy_points, k=2)
         distances: np.ndarray
         cell_size = float(np.percentile(distances[distances > 0], 5)) / 2
 
@@ -378,4 +392,4 @@ def raster_from_point_cloud(
         crs=crs,
         transform=transform,
     )
-    return RasterModel(arr=arr, raster_meta=raster_meta)
+    return Raster(arr=arr, raster_meta=raster_meta)

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/gis/smooth.py

@@ -5,7 +5,7 @@ Fork + Port of <https://github.com/philipschall/shapelysmooth> (Public domain)
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, TypeAlias
+from typing import TYPE_CHECKING, TypeVar
 
 import numpy as np
 from shapely.geometry import LineString, Polygon
@@ -14,7 +14,7 @@ from typing_extensions import assert_never
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
-T: TypeAlias = LineString | Polygon
+T = TypeVar("T", bound=LineString | Polygon)
 
 
 class InputeTypeError(TypeError):
@@ -38,12 +38,12 @@ def catmull_rom_smooth(geometry: T, alpha: float = 0.5, subdivs: int = 10) -> T:
     coords, interior_coords = _get_coords(geometry)
     coords_smoothed = _catmull_rom(coords, alpha=alpha, subdivs=subdivs)
     if isinstance(geometry, LineString):
-        return type(geometry)(coords_smoothed)
+        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 type(geometry)(coords_smoothed, holes=interior_coords_smoothed)
+        return geometry.__class__(coords_smoothed, holes=interior_coords_smoothed)
     else:
         assert_never(geometry)
 

rastr/io.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeVar
 
 import numpy as np
 import rasterio
@@ -9,39 +9,59 @@ import rasterio.merge
 from pyproj.crs.crs import CRS
 
 from rastr.meta import RasterMeta
-from rastr.raster import RasterModel
+from rastr.raster import Raster
 
 if TYPE_CHECKING:
     from numpy.typing import NDArray
 
+R = TypeVar("R", bound=Raster)
+
 
 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."""
+    raster_path: Path | str,
+    *,
+    crs: CRS | str | None = None,
+    cls: type[R] = Raster,
+) -> R:
+    """Read raster data from a file and return an in-memory Raster object.
+
+    Args:
+        raster_path: Path to the raster file.
+        crs: Optional CRS to override the raster's native CRS.
+        cls: The Raster subclass to instantiate. This is mostly for internal use,
+             but can be useful if you have a custom `Raster` subclass.
+    """
     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()
-        arr = arr.squeeze().astype(np.float64)
+        raw_arr: NDArray = dst.read()
+        raw_arr = raw_arr.squeeze()
+
         # Extract metadata
         cell_size = dst.res[0]
         if crs is None:
             crs = CRS.from_user_input(dst.crs)
         transform = dst.transform
         nodata = dst.nodata
+
+        # Cast integers to float16 to handle NaN values
+        if np.issubdtype(raw_arr.dtype, np.integer):
+            arr = raw_arr.astype(np.float16)
+        else:
+            arr = raw_arr
+
         if nodata is not None:
-            arr[arr == nodata] = np.nan
+            arr[raw_arr == nodata] = np.nan
 
     raster_meta = RasterMeta(cell_size=cell_size, crs=crs, transform=transform)
-    raster_obj = RasterModel(arr=arr, raster_meta=raster_meta)
+    raster_obj = cls(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:
+) -> Raster:
     """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,
@@ -81,13 +101,19 @@ def read_raster_mosaic_inmem(
             crs = CRS.from_user_input(sources[0].crs)
 
         nodata = sources[0].nodata
-        if nodata is not None:
-            arr[arr == nodata] = np.nan
+        raw_arr = arr.squeeze()
 
-        arr = arr.squeeze().astype(np.float64)
+        # Cast integers to float16 to handle NaN values
+        if np.issubdtype(raw_arr.dtype, np.integer):
+            arr = raw_arr.astype(np.float16)
+        else:
+            arr = raw_arr
+
+        if nodata is not None:
+            arr[raw_arr == nodata] = np.nan
 
         raster_meta = RasterMeta(cell_size=cell_size, crs=crs, transform=transform)
-        raster_obj = RasterModel(arr=arr, raster_meta=raster_meta)
+        raster_obj = Raster(arr=arr, raster_meta=raster_meta)
         return raster_obj
     finally:
         for src in sources: