rastr 0.2.0__py3-none-any.whl → 0.4.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.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 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 | str, 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 | str, crs: CRS | None = None) -> Raster
     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"):
@@ -28,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
@@ -38,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

rastr/raster.py

@@ -1,30 +1,24 @@
 """Raster data structure."""
 
-from collections.abc import Callable, Generator
+from __future__ import annotations
+
+import importlib.util
+import warnings
 from contextlib import contextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Any, Literal, overload
 
-import geopandas as gpd
-import matplotlib as mpl
 import numpy as np
-import pandas as pd
+import numpy.ma
 import rasterio.plot
 import rasterio.sample
 import rasterio.transform
 import skimage.measure
-import xyzservices.providers as xyz
-from matplotlib import pyplot as plt
-from matplotlib.axes import Axes
-from mpl_toolkits.axes_grid1 import make_axes_locatable
-from numpy.typing import NDArray
 from pydantic import BaseModel, InstanceOf, field_validator
 from pyproj.crs.crs import CRS
 from rasterio.enums import Resampling
-from rasterio.io import BufferedDatasetWriter, DatasetReader, DatasetWriter, MemoryFile
-from scipy.ndimage import gaussian_filter
-from shapely.geometry import LineString, Polygon
-from typing_extensions import Self
+from rasterio.io import MemoryFile
+from shapely.geometry import LineString, Point, Polygon
 
 from rastr.arr.fill import fillna_nearest_neighbours
 from rastr.gis.fishnet import create_fishnet
@@ -32,16 +26,14 @@ from rastr.gis.smooth import catmull_rom_smooth
 from rastr.meta import RasterMeta
 
 if TYPE_CHECKING:
-    from folium import Map
+    from collections.abc import Callable, Generator
 
-try:
-    import folium
-    import folium.raster_layers
+    import geopandas as gpd
     from folium import Map
-except ImportError:
-    FOLIUM_INSTALLED = False
-else:
-    FOLIUM_INSTALLED = True
+    from matplotlib.axes import Axes
+    from numpy.typing import ArrayLike, NDArray
+    from rasterio.io import BufferedDatasetWriter, DatasetReader, DatasetWriter
+    from typing_extensions import Self
 
 try:
     from rasterio._err import CPLE_BaseError
@@ -49,7 +41,9 @@ except ImportError:
     CPLE_BaseError = Exception  # Fallback if private module import fails
 
 
-CTX_BASEMAP_SOURCE = xyz.Esri.WorldImagery  # pyright: ignore[reportAttributeAccessIssue]
+FOLIUM_INSTALLED = importlib.util.find_spec("folium") is not None
+BRANCA_INSTALLED = importlib.util.find_spec("branca") is not None
+MATPLOTLIB_INSTALLED = importlib.util.find_spec("matplotlib") is not None
 
 
 class RasterCellArrayShapeError(ValueError):
@@ -62,6 +56,57 @@ class RasterModel(BaseModel):
     arr: InstanceOf[np.ndarray]
     raster_meta: RasterMeta
 
+    @property
+    def meta(self) -> RasterMeta:
+        """Alias for raster_meta."""
+        return self.raster_meta
+
+    @meta.setter
+    def meta(self, value: RasterMeta) -> None:
+        self.raster_meta = value
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        """Shape of the raster array."""
+        return self.arr.shape
+
+    @property
+    def crs(self) -> CRS:
+        """Convenience property to access the CRS via meta."""
+        return self.meta.crs
+
+    @crs.setter
+    def crs(self, value: CRS) -> None:
+        """Set the CRS via meta."""
+        self.meta.crs = value
+
+    def __init__(
+        self,
+        *,
+        arr: ArrayLike,
+        meta: RasterMeta | None = None,
+        raster_meta: RasterMeta | None = None,
+    ) -> None:
+        arr = np.asarray(arr)
+
+        # Set the meta
+        if meta is not None and raster_meta is not None:
+            msg = (
+                "Only one of 'meta' or 'raster_meta' should be provided, they are "
+                "aliases."
+            )
+            raise ValueError(msg)
+        elif meta is not None and raster_meta is None:
+            raster_meta = meta
+        elif meta is None and raster_meta is not None:
+            pass
+        else:
+            # Don't need to mention `'meta'` to simplify the messaging.
+            msg = "The attribute 'raster_meta' is required."
+            raise ValueError(msg)
+
+        super().__init__(arr=arr, raster_meta=raster_meta)
+
     def __eq__(self, other: object) -> bool:
         """Check equality of two RasterModel objects."""
         if not isinstance(other, RasterModel):
@@ -160,6 +205,16 @@ class RasterModel(BaseModel):
         """Get the coordinates of the cell centres in the raster."""
         return self.raster_meta.get_cell_centre_coords(self.arr.shape)
 
+    @property
+    def cell_x_coords(self) -> NDArray[np.float64]:
+        """Get the x coordinates of the cell centres in the raster."""
+        return self.raster_meta.get_cell_x_coords(self.arr.shape[1])
+
+    @property
+    def cell_y_coords(self) -> NDArray[np.float64]:
+        """Get the y coordinates of the cell centres in the raster."""
+        return self.raster_meta.get_cell_y_coords(self.arr.shape[0])
+
     @contextmanager
     def to_rasterio_dataset(
         self,
@@ -195,14 +250,15 @@ class RasterModel(BaseModel):
 
     def sample(
         self,
-        xy: list[tuple[float, float]],
+        xy: list[tuple[float, float]] | list[Point] | ArrayLike,
         *,
         na_action: Literal["raise", "ignore"] = "raise",
     ) -> NDArray[np.float64]:
         """Sample raster values at GeoSeries locations and return sampled values.
 
         Args:
-            xy: A list of (x, y) coordinates to sample the raster at.
+            xy: A list of (x, y) coordinates or shapely Point objects to sample the
+                raster at.
             na_action: Action to take when a NaN value is encountered in the input xy.
                        Options are "raise" (raise an error) or "ignore" (replace with
                        NaN).
@@ -213,6 +269,12 @@ class RasterModel(BaseModel):
         # If this function is too slow, consider the optimizations detailed here:
         # https://rdrn.me/optimising-sampling/
 
+        # Convert shapely Points to coordinate tuples if needed
+        if isinstance(xy, (list, tuple)):
+            xy = [_get_xy_tuple(point) for point in xy]
+
+        xy = np.asarray(xy, dtype=float)
+
         # Short-circuit
         if len(xy) == 0:
             return np.array([], dtype=float)
@@ -249,7 +311,7 @@ class RasterModel(BaseModel):
 
             # Convert the sampled values to a NumPy array and set masked values to NaN
             raster_values = np.array(
-                [s.data[0] if not s.mask else np.nan for s in samples]
+                [s.data[0] if not numpy.ma.getmask(s) else np.nan for s in samples]
             ).astype(float)
 
             if len(xy_nan_idxs) > 0:
@@ -298,19 +360,25 @@ class RasterModel(BaseModel):
         m: Map | None = None,
         opacity: float = 1.0,
         colormap: str = "viridis",
+        cbar_label: str | None = None,
     ) -> Map:
         """Display the raster on a folium map."""
-        if not FOLIUM_INSTALLED:
-            msg = "The 'folium' package is required for 'explore()'."
+        if not FOLIUM_INSTALLED or not MATPLOTLIB_INSTALLED:
+            msg = "The 'folium' and 'matplotlib' packages are required for 'explore()'."
             raise ImportError(msg)
 
+        import folium.raster_layers
+        import geopandas as gpd
+        import matplotlib as mpl
+
         if m is None:
             m = folium.Map()
 
-        rbga_map: Callable[[float], tuple[float, float, float, float]] = mpl.colormaps[
+        rgba_map: Callable[[float], tuple[float, float, float, float]] = mpl.colormaps[
             colormap
         ]
 
+        # Cast to GDF to facilitate converting bounds to WGS84
         wgs84_crs = CRS.from_epsg(4326)
         gdf = gpd.GeoDataFrame(geometry=[self.bbox], crs=self.raster_meta.crs).to_crs(
             wgs84_crs
@@ -320,8 +388,15 @@ class RasterModel(BaseModel):
         arr = np.array(self.arr)
 
         # Normalize the data to the range [0, 1] as this is the cmap range
-        min_val = np.nanmin(arr)
-        max_val = np.nanmax(arr)
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message="All-NaN slice encountered",
+                category=RuntimeWarning,
+            )
+            min_val = np.nanmin(arr)
+            max_val = np.nanmax(arr)
+
         if max_val > min_val:  # Prevent division by zero
             arr = (arr - min_val) / (max_val - min_val)
         else:
@@ -332,26 +407,46 @@ class RasterModel(BaseModel):
         flip_x = self.raster_meta.transform.a < 0
         flip_y = self.raster_meta.transform.e > 0
         if flip_x:
-            arr = np.flip(self.arr, axis=1)
+            arr = np.flip(arr, axis=1)
         if flip_y:
-            arr = np.flip(self.arr, axis=0)
+            arr = np.flip(arr, axis=0)
 
         img = folium.raster_layers.ImageOverlay(
             image=arr,
             bounds=[[ymin, xmin], [ymax, xmax]],
             opacity=opacity,
-            colormap=rbga_map,
+            colormap=rgba_map,
             mercator_project=True,
         )
 
         img.add_to(m)
 
+        # Add a colorbar legend
+        if BRANCA_INSTALLED:
+            from branca.colormap import LinearColormap as BrancaLinearColormap
+            from matplotlib.colors import to_hex
+
+            # Determine legend data range in original units
+            vmin = float(min_val) if np.isfinite(min_val) else 0.0
+            vmax = float(max_val) if np.isfinite(max_val) else 1.0
+            if vmax <= vmin:
+                vmax = vmin + 1.0
+
+            sample_points = np.linspace(0, 1, rgba_map.N)
+            colors = [to_hex(rgba_map(x)) for x in sample_points]
+            legend = BrancaLinearColormap(colors=colors, vmin=vmin, vmax=vmax)
+            if cbar_label:
+                legend.caption = cbar_label
+            legend.add_to(m)
+
         m.fit_bounds([[ymin, xmin], [ymax, xmax]])
 
         return m
 
     def to_clipboard(self) -> None:
         """Copy the raster cell array to the clipboard."""
+        import pandas as pd
+
         pd.DataFrame(self.arr).to_clipboard(index=False, header=False)
 
     def plot(
@@ -363,9 +458,17 @@ class RasterModel(BaseModel):
         cmap: str = "viridis",
     ) -> Axes:
         """Plot the raster on a matplotlib axis."""
+        if not MATPLOTLIB_INSTALLED:
+            msg = "The 'matplotlib' package is required for 'plot()'."
+            raise ImportError(msg)
+
+        from matplotlib import pyplot as plt
+        from mpl_toolkits.axes_grid1 import make_axes_locatable
+
         if ax is None:
-            _, ax = plt.subplots()
-        ax: Axes
+            _, _ax = plt.subplots()
+            _ax: Axes
+            ax = _ax
 
         if basemap:
             msg = "Basemap plotting is not yet implemented."
@@ -387,8 +490,8 @@ class RasterModel(BaseModel):
         max_y_nonzero = np.max(y_nonzero)
 
         # Transform to raster CRS
-        x1, y1 = self.raster_meta.transform * (min_x_nonzero, min_y_nonzero)
-        x2, y2 = self.raster_meta.transform * (max_x_nonzero, max_y_nonzero)
+        x1, y1 = self.raster_meta.transform * (min_x_nonzero, min_y_nonzero)  # type: ignore[reportAssignmentType] overloaded tuple size in affine
+        x2, y2 = self.raster_meta.transform * (max_x_nonzero, max_y_nonzero)  # type: ignore[reportAssignmentType]
         xmin, xmax = sorted([x1, x2])
         ymin, ymax = sorted([y1, y2])
 
@@ -409,11 +512,14 @@ class RasterModel(BaseModel):
         divider = make_axes_locatable(ax)
         cax = divider.append_axes("right", size="5%", pad=0.05)
         fig = ax.get_figure()
-        fig.colorbar(img, label=cbar_label, cax=cax)
+        if fig is not None:
+            fig.colorbar(img, label=cbar_label, cax=cax)
         return ax
 
     def as_geodataframe(self, name: str = "value") -> gpd.GeoDataFrame:
         """Create a GeoDataFrame representation of the raster."""
+        import geopandas as gpd
+
         polygons = create_fishnet(bounds=self.bounds, res=self.raster_meta.cell_size)
         point_tuples = [polygon.centroid.coords[0] for polygon in polygons]
         raster_gdf = gpd.GeoDataFrame(
@@ -482,6 +588,43 @@ class RasterModel(BaseModel):
         raster_meta = RasterMeta.example()
         return cls(arr=arr, raster_meta=raster_meta)
 
+    @overload
+    def apply(
+        self,
+        func: Callable[[np.ndarray], np.ndarray],
+        *,
+        raw: Literal[True],
+    ) -> Self: ...
+    @overload
+    def apply(
+        self,
+        func: Callable[[float], float] | Callable[[np.ndarray], np.ndarray],
+        *,
+        raw: Literal[False] = False,
+    ) -> Self: ...
+    def apply(self, func, *, raw=False) -> Self:
+        """Apply a function element-wise to the raster array.
+
+        Creates a new raster instance with the same metadata (CRS, transform, etc.)
+        but with the data array transformed by the provided function. The original
+        raster is not modified.
+
+        Args:
+            func: The function to apply to the raster array. If `raw` is True, this
+                  function should accept and return a NumPy array. If `raw` is False,
+                  this function should accept and return a single float value.
+            raw: If True, the function is applied directly to the entire array at
+                 once. If False, the function is applied element-wise to each cell
+                 in the array using `np.vectorize()`. Default is False.
+        """
+        new_raster = self.model_copy()
+        if raw:
+            new_arr = func(self.arr)
+        else:
+            new_arr = np.vectorize(func)(self.arr)
+        new_raster.arr = np.asarray(new_arr)
+        return new_raster
+
     def fillna(self, value: float) -> Self:
         """Fill NaN values in the raster with a specified value.
 
@@ -493,41 +636,42 @@ class RasterModel(BaseModel):
         return new_raster
 
     def get_xy(self) -> tuple[NDArray[np.float64], NDArray[np.float64]]:
-        """Get the x and y coordinates of the raster in meshgrid format."""
-        col_idx, row_idx = np.meshgrid(
-            np.arange(self.arr.shape[1]),
-            np.arange(self.arr.shape[0]),
-        )
+        """Get the x and y coordinates of the raster cell centres in meshgrid format.
 
-        col_idx = col_idx.flatten()
-        row_idx = row_idx.flatten()
+        Returns the coordinates of the cell centres as two separate 2D arrays in
+        meshgrid format, where each array has the same shape as the raster data array.
 
-        coords = np.vstack((row_idx, col_idx)).T
-
-        x, y = rasterio.transform.xy(self.raster_meta.transform, *coords.T)
-        x = np.array(x).reshape(self.arr.shape)
-        y = np.array(y).reshape(self.arr.shape)
-        return x, y
+        Returns:
+            A tuple of (x, y) coordinate arrays where:
+            - x: 2D array of x-coordinates of cell centres
+            - y: 2D array of y-coordinates of cell centres
+            Both arrays have the same shape as the raster data array.
+        """
+        coords = self.raster_meta.get_cell_centre_coords(self.arr.shape)
+        return coords[:, :, 0], coords[:, :, 1]
 
     def contour(
-        self, *, levels: list[float], smoothing: bool = True
+        self, levels: list[float] | NDArray, *, smoothing: bool = True
     ) -> gpd.GeoDataFrame:
         """Create contour lines from the raster data, optionally with smoothing.
 
-        The contour lines are returned as a GeoDataFrame with the contours as linestring
-        geometries and the contour levels as attributes in a column named 'level'.
+        The contour lines are returned as a GeoDataFrame with the contours dissolved
+        by level, resulting in one row per contour level. Each row contains a
+        (Multi)LineString geometry representing all contour lines for that level,
+        and the contour level value in a column named 'level'.
 
         Consider calling `blur()` before this method to smooth the raster data before
         contouring, to denoise the contours.
 
         Args:
-            levels: A list of contour levels to generate. The contour lines will be
-                    generated for each level in this list.
+            levels: A list or array of contour levels to generate. The contour lines
+                    will be generated for each level in this sequence.
             smoothing: Defaults to true, which corresponds to applying a smoothing
                        algorithm to the contour lines. At the moment, this is the
                        Catmull-Rom spline algorithm. If set to False, the raw
                        contours will be returned without any smoothing.
         """
+        import geopandas as gpd
 
         all_levels = []
         all_geoms = []
@@ -537,7 +681,7 @@ class RasterModel(BaseModel):
                 level=level,
             )
 
-            # Constructg shapely LineString objects
+            # Construct shapely LineString objects
             # Convert to CRS from array index coordinates to raster CRS
             geoms = [
                 LineString(
@@ -566,7 +710,8 @@ class RasterModel(BaseModel):
             crs=self.raster_meta.crs,
         )
 
-        return contour_gdf
+        # Dissolve contours by level to merge all contour lines of the same level
+        return contour_gdf.dissolve(by="level", as_index=False)
 
     def blur(self, sigma: float) -> Self:
         """Apply a Gaussian blur to the raster data.
@@ -576,6 +721,7 @@ class RasterModel(BaseModel):
                    coordinate distance (e.g. meters). A larger sigma results in a more
                    blurred image.
         """
+        from scipy.ndimage import gaussian_filter
 
         cell_sigma = sigma / self.raster_meta.cell_size
 
@@ -605,6 +751,82 @@ class RasterModel(BaseModel):
 
         return raster
 
+    def crop(
+        self,
+        bounds: tuple[float, float, float, float],
+        strategy: Literal["underflow", "overflow"] = "underflow",
+    ) -> Self:
+        """Crop the raster to the specified bounds as (minx, miny, maxx, maxy).
+
+        Args:
+            bounds: A tuple of (minx, miny, maxx, maxy) defining the bounds to crop to.
+            strategy:   The cropping strategy to use. 'underflow' will crop the raster
+                        to be fully within the bounds, ignoring any cells that are
+                        partially outside the bounds. 'overflow' will instead include
+                        cells that intersect the bounds, ensuring the bounds area
+                        remains covered with cells.
+
+        Returns:
+            A new RasterModel instance cropped to the specified bounds.
+        """
+
+        minx, miny, maxx, maxy = bounds
+        arr = self.arr
+
+        # Get the half cell size for cropping
+        cell_size = self.raster_meta.cell_size
+        half_cell_size = cell_size / 2
+
+        # Get the cell centre coordinates as 1D arrays
+        x_coords = self.cell_x_coords
+        y_coords = self.cell_y_coords
+
+        # Get the indices to crop the array
+        if strategy == "underflow":
+            x_idx = (x_coords >= minx + half_cell_size) & (
+                x_coords <= maxx - half_cell_size
+            )
+            y_idx = (y_coords >= miny + half_cell_size) & (
+                y_coords <= maxy - half_cell_size
+            )
+        elif strategy == "overflow":
+            x_idx = (x_coords > minx - half_cell_size) & (
+                x_coords < maxx + half_cell_size
+            )
+            y_idx = (y_coords > miny - half_cell_size) & (
+                y_coords < maxy + half_cell_size
+            )
+        else:
+            msg = f"Unsupported cropping strategy: {strategy}"
+            raise NotImplementedError(msg)
+
+        # Crop the array
+        cropped_arr = arr[np.ix_(y_idx, x_idx)]
+
+        # Check the shape of the cropped array
+        if cropped_arr.size == 0:
+            msg = "Cropped array is empty; no cells within the specified bounds."
+            raise ValueError(msg)
+
+        # Recalculate the transform for the cropped raster
+        x_coords = x_coords[x_idx]
+        y_coords = y_coords[y_idx]
+        transform = rasterio.transform.from_bounds(
+            west=x_coords.min() - half_cell_size,
+            south=y_coords.min() - half_cell_size,
+            east=x_coords.max() + half_cell_size,
+            north=y_coords.max() + half_cell_size,
+            width=cropped_arr.shape[1],
+            height=cropped_arr.shape[0],
+        )
+
+        # Update the raster
+        cls = self.__class__
+        new_meta = RasterMeta(
+            cell_size=cell_size, crs=self.raster_meta.crs, transform=transform
+        )
+        return cls(arr=cropped_arr, raster_meta=new_meta)
+
     def resample(
         self, new_cell_size: float, *, method: Literal["bilinear"] = "bilinear"
     ) -> Self:
@@ -654,9 +876,24 @@ class RasterModel(BaseModel):
 
     @field_validator("arr")
     @classmethod
-    def check_2d_array(cls, v: np.ndarray) -> np.ndarray:
+    def check_2d_array(cls, v: NDArray) -> NDArray:
         """Validator to ensure the cell array is 2D."""
         if v.ndim != 2:
             msg = "Cell array must be 2D"
             raise RasterCellArrayShapeError(msg)
         return v
+
+
+def _get_xy_tuple(xy: Any) -> tuple[float, float]:
+    """Convert Point or coordinate tuple to coordinate tuple.
+
+    Args:
+        xy: Either a coordinate tuple or a shapely Point object.
+
+    Returns:
+        A coordinate tuple (x, y).
+    """
+    if isinstance(xy, Point):
+        return (xy.x, xy.y)
+    x, y = xy
+    return (float(x), float(y))

rastr-0.4.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: rastr
+Version: 0.4.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/336916af169603534dd0728c10401667f263d98a.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
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: affine>=2.4.0
+Requires-Dist: branca>=0.8.1
+Requires-Dist: folium>=0.20.0
+Requires-Dist: geopandas>=1.1.1
+Requires-Dist: matplotlib>=3.10.5
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: pandas>=2.3.1
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pyproj>=3.7.1
+Requires-Dist: rasterio>=1.4.3
+Requires-Dist: scikit-image>=0.25.2
+Requires-Dist: scipy>=1.15.3
+Requires-Dist: shapely>=2.1.1
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: typing-extensions>=4.14.1
+Description-Content-Type: text/markdown
+
+<h1 align="center">
+  <img src="https://raw.githubusercontent.com/tonkintaylor/rastr/refs/heads/develop/docs/logo.svg"><br>
+</h1>
+
+# rastr
+
+[![PyPI Version](https://img.shields.io/pypi/v/rastr.svg)](<https://pypi.python.org/pypi/rastr>)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![usethis](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/usethis-python/usethis-python/main/assets/badge/v1.json)](https://github.com/usethis-python/usethis-python)
+
+A lightweight geospatial raster datatype library for Python focused on simplicity.
+
+## Overview
+
+`rastr` provides an intuitive interface for creating, reading, manipulating, and exporting geospatial raster data in Python.
+
+### Features
+
+- 🧮 **Complete raster arithmetic**: Full support for mathematical operations (`+`, `-`, `*`, `/`) between rasters and scalars.
+- 📊 **Flexible visualization**: Built-in plotting with matplotlib and interactive mapping with folium.
+- 🗺️ **Geospatial analysis tools**: Contour generation, Gaussian blurring, and spatial sampling.
+- 🛠️ **Data manipulation**: Fill NaN values, extrapolate missing data, and resample to different resolutions.
+- 🔗 **Seamless integration**: Works with GeoPandas, rasterio, and the broader Python geospatial ecosystem.
+- ↔️ **Vector-to-raster workflows**: Convert GeoDataFrame polygons, points, and lines to raster format.
+
+## Installation
+
+```bash
+# With uv
+uv add rastr
+
+# With pip
+pip install rastr
+```
+
+## Quick Start
+
+```python
+from pyproj.crs.crs import CRS
+from rasterio.transform import from_origin
+from rastr.create import full_raster
+from rastr.meta import RasterMeta
+from rastr.raster import RasterModel
+
+# Create an example raster
+raster = RasterModel.example()
+
+# Basic arithmetic operations
+doubled = raster * 2
+summed = raster + 10
+combined = raster + doubled
+
+# Create full rasters with specified values
+cell_size = 1.0
+empty_raster = full_raster(
+    RasterMeta(
+        cell_size=cell_size,
+        crs=CRS.from_epsg(2193),
+        transform=from_origin(0, 100, cell_size, cell_size),
+    ),
+    bounds=(0, 0, 100, 100),
+    fill_value=0.0,
+)
+
+# Visualize the data
+ax = raster.plot(cbar_label="Values")
+
+# Interactive web mapping (requires folium)
+m = raster.explore(opacity=0.8, colormap="plasma")
+
+# Sample values at specific coordinates
+xy_points = [(100.0, 200.0), (150.0, 250.0)]
+values = raster.sample(xy_points)
+
+# Generate contour lines
+contours = raster.contour(levels=[0.1, 0.5, 0.9], smoothing=True)
+
+# Apply spatial operations
+blurred = raster.blur(sigma=2.0)  # Gaussian blur
+filled = raster.extrapolate(method="nearest")  # Fill NaN values via nearest-neighbours
+resampled = raster.resample(new_cell_size=0.5)  # Change resolution
+
+# Export to file
+raster.to_file("output.tif")
+
+# Convert to GeoDataFrame for vector analysis
+gdf = raster.as_geodataframe(name="elevation")
+```
+
+## Limitations
+
+Current version limitations:
+
+- Only Single-band rasters are supported.
+- In-memory processing only (streaming support planned).
+- Square cells only (rectangular cell support planned).
+- Only float dtypes (integer support planned).
+
+### Contributing
+
+See the
+[CONTRIBUTING.md](https://github.com/usethis-python/usethis-python/blob/main/CONTRIBUTING.md)
+file.

rastr-0.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+rastr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rastr/_version.py,sha256=2_0GUP7yBCXRus-qiJKxQD62z172WSs1sQ6DVpPsbmM,704
+rastr/create.py,sha256=6aHpRFRXmpXzuzTt-SxY_BfVc7dXKCBLCArb7DjUrsM,13494
+rastr/io.py,sha256=RgkiV_emOPjTFeI2a1aCBtfWwrSLH0XmP8rx9tu6PAI,2952
+rastr/meta.py,sha256=5iDvGkYe8iMMkPV6gSL04jNcLRhuRNFqe9AppUpp55E,2928
+rastr/raster.py,sha256=I9CQB2NYUOFvvpdzNsQcDBdgLXDCjB7ONFxDAq_6_SU,31995
+rastr/arr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rastr/arr/fill.py,sha256=80ucb36el9s042fDSwK1SZJhp_GNJNMM0fpQTWmJvgE,1001
+rastr/gis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rastr/gis/fishnet.py,sha256=Ic-0HV61ST8OxwhyoMyV_ybihs2xuhgAY-3n4CknAt8,2670
+rastr/gis/smooth.py,sha256=3HQDQHQM5_LeNk21R8Eb8VpF727JcXq21HO9JMvcpW4,4810
+rastr-0.4.0.dist-info/METADATA,sha256=GjZF16Tmxjz3WUbEFhAB1jW19AecpNkJpk__YNSamQQ,4953
+rastr-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rastr-0.4.0.dist-info/licenses/LICENSE,sha256=7qUsx93G2ATTRLZiSYuQofwAX_uWvrqnAiMK8PzxvNc,1080
+rastr-0.4.0.dist-info/RECORD,,

rastr-0.2.0.dist-info/METADATA

@@ -1,44 +0,0 @@
-Metadata-Version: 2.4
-Name: rastr
-Version: 0.2.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/551d36604b84f947fffbe328e9e877732c9e35fb.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
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.10
-Requires-Dist: affine>=2.4.0
-Requires-Dist: folium>=0.20.0
-Requires-Dist: geopandas>=1.1.1
-Requires-Dist: matplotlib>=3.10.5
-Requires-Dist: numpy>=2.2.6
-Requires-Dist: pandas>=2.3.1
-Requires-Dist: pydantic>=2.11.7
-Requires-Dist: pyproj>=3.7.1
-Requires-Dist: rasterio>=1.4.3
-Requires-Dist: scikit-image>=0.25.2
-Requires-Dist: scipy>=1.15.3
-Requires-Dist: shapely>=2.1.1
-Requires-Dist: tqdm>=4.67.1
-Requires-Dist: typing-extensions>=4.14.1
-Requires-Dist: xyzservices>=2025.4.0
-Description-Content-Type: text/markdown
-
-# Rastr
-
-[![PyPI Version](https://img.shields.io/pypi/v/rastr.svg)](<https://pypi.python.org/pypi/rastr>)
-[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![usethis](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/usethis-python/usethis-python/main/assets/badge/v1.json)](https://github.com/usethis-python/usethis-python)
-
-Geospatial Raster datatype library for Python.
-
-Currently, only single-banded, in-memory rasters with square cells are supported.

rastr-0.2.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-rastr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rastr/_version.py,sha256=iB5DfB5V6YB5Wo4JmvS-txT42QtmGaWcWp3udRT7zCI,511
-rastr/create.py,sha256=tHLVnGarMt04p1z8CVknMWMjQLKrb0WrcP_Wgdw8xr4,9346
-rastr/io.py,sha256=dKOY5JYQDULg3Si24cysVTZuWoPjftAE8pbxgSoN1tw,967
-rastr/meta.py,sha256=jmDDx3w61ZZ3dQSrMFgaBx0LJxYp42xTm_7uS_s96lg,1547
-rastr/raster.py,sha256=jGk9buG1uKQ3tb3ciI4yhw9JFu7oyXWXMnUBnPjOD54,23142
-rastr/arr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rastr/arr/fill.py,sha256=7N3ECMli7ssNJJk5qgDoj_3xExgu03nohGPgUKWxcCk,903
-rastr/gis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rastr/gis/fishnet.py,sha256=LZqtI9cgYPacuWNfIfdbTkRMRSnJCQdYlaT2eVPmorM,2459
-rastr/gis/smooth.py,sha256=LbWvAG1O-O5H6P5LrbwD03mbnXVYjkH1re-_iZ4arIU,4754
-rastr-0.2.0.dist-info/METADATA,sha256=7uUi8aLMaEbxoPfk6go_szv3H_TnDGYGE4RSC_sbUqo,2191
-rastr-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rastr-0.2.0.dist-info/licenses/LICENSE,sha256=7qUsx93G2ATTRLZiSYuQofwAX_uWvrqnAiMK8PzxvNc,1080
-rastr-0.2.0.dist-info/RECORD,,