rio-tiler 7.3.0__tar.gz → 7.4.0__tar.gz

{rio_tiler-7.3.0 → rio_tiler-7.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rio-tiler
-Version: 7.3.0
+Version: 7.4.0
 Summary: User friendly Rasterio plugin to read raster datasets.
 Project-URL: Homepage, https://cogeotiff.github.io/rio-tiler/
 Project-URL: Documentation, https://cogeotiff.github.io/rio-tiler/
@@ -54,13 +54,12 @@ Requires-Dist: attrs
 Requires-Dist: cachetools
 Requires-Dist: color-operations
 Requires-Dist: httpx
-Requires-Dist: importlib-resources>=1.1.0; python_version < '3.9'
 Requires-Dist: morecantile<7.0,>=5.0
 Requires-Dist: numexpr
 Requires-Dist: numpy
 Requires-Dist: pydantic~=2.0
 Requires-Dist: pystac>=0.5.4
-Requires-Dist: rasterio>=1.3.0
+Requires-Dist: rasterio>=1.4.0
 Requires-Dist: typing-extensions
 Provides-Extra: benchmark
 Requires-Dist: pytest; extra == 'benchmark'

{rio_tiler-7.3.0 → rio_tiler-7.4.0}/pyproject.toml

@@ -29,10 +29,9 @@ dependencies = [
     "morecantile>=5.0,<7.0",
     "pydantic~=2.0",
     "pystac>=0.5.4",
-    "rasterio>=1.3.0",
+    "rasterio>=1.4.0",
     "color-operations",
     "typing-extensions",
-    "importlib_resources>=1.1.0; python_version < '3.9'",
 ]
 
 [project.optional-dependencies]
@@ -161,7 +160,7 @@ exclude = [
 max-complexity = 14
 
 [tool.bumpversion]
-current_version = "7.3.0"
+current_version = "7.4.0"
 search = "{current_version}"
 replace = "{new_version}"
 regex = false

{rio_tiler-7.3.0 → rio_tiler-7.4.0}/rio_tiler/__init__.py

@@ -1,6 +1,6 @@
 """rio-tiler."""
 
-__version__ = "7.3.0"
+__version__ = "7.4.0"
 
 from . import (  # noqa
     colormap,

{rio_tiler-7.3.0 → rio_tiler-7.4.0}/rio_tiler/colormap.py

@@ -5,6 +5,8 @@ import os
 import pathlib
 import re
 import warnings
+from importlib.resources import as_file
+from importlib.resources import files as resources_files
 from typing import Dict, List, Sequence, Tuple, Union
 
 import attr
@@ -24,15 +26,6 @@ from rio_tiler.types import (
     IntervalColorMapType,
 )
 
-try:
-    from importlib.resources import as_file
-    from importlib.resources import files as resources_files
-except ImportError:
-    # Try backported to PY<39 `importlib_resources`.
-    from importlib_resources import as_file  # type: ignore
-    from importlib_resources import files as resources_files  # type: ignore
-
-
 EMPTY_COLORMAP: GDALColorMapType = {i: (0, 0, 0, 0) for i in range(256)}
 
 _RIO_CMAP_DIR = resources_files(__package__) / "cmap_data"

{rio_tiler-7.3.0 → rio_tiler-7.4.0}/rio_tiler/io/stac.py

@@ -21,6 +21,7 @@ import attr
 import httpx
 import pystac
 import rasterio
+from affine import Affine
 from cachetools import LRUCache, cached
 from cachetools.keys import hashkey
 from morecantile import TileMatrixSet
@@ -277,7 +278,7 @@ class STACReader(MultiBaseReader):
                 ]
             ):
                 self.height, self.width = self.item.ext.proj.shape
-                self.transform = self.item.ext.proj.transform
+                self.transform = Affine(*self.item.ext.proj.transform)
                 self.bounds = array_bounds(self.height, self.width, self.transform)
                 self.crs = rasterio.crs.CRS.from_string(self.item.ext.proj.crs_string)
 

{rio_tiler-7.3.0 → rio_tiler-7.4.0}/rio_tiler/io/xarray.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import warnings
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import attr
 import numpy
@@ -28,8 +28,13 @@ from rio_tiler.errors import (
 from rio_tiler.io.base import BaseReader
 from rio_tiler.models import BandStatistics, ImageData, Info, PointData
 from rio_tiler.reader import _get_width_height
-from rio_tiler.types import BBox, NoData, RIOResampling, WarpResampling
-from rio_tiler.utils import CRS_to_uri, _validate_shape_input, get_array_statistics
+from rio_tiler.types import BBox, Indexes, NoData, RIOResampling, WarpResampling
+from rio_tiler.utils import (
+    CRS_to_uri,
+    _validate_shape_input,
+    cast_to_sequence,
+    get_array_statistics,
+)
 
 try:
     import xarray
@@ -105,6 +110,7 @@ class XarrayReader(BaseReader):
             for d in self.input.dims
             if d not in [self.input.rio.x_dim, self.input.rio.y_dim]
         ]
+        assert len(self._dims) in [0, 1], "Can't handle >=4D DataArray"
 
     @property
     def minzoom(self):
@@ -118,29 +124,38 @@ class XarrayReader(BaseReader):
 
     @property
     def band_names(self) -> List[str]:
-        """Return list of `band names` in DataArray."""
-        return [str(band) for d in self._dims for band in self.input[d].values] or [
-            "value"
-        ]
+        """
+        Return list of `band descriptions` in DataArray.
+
+        `Bands` are all dimensions not defined as spatial dims by rioxarray.
+        """
+        if not self._dims:
+            coords_name = list(self.input.coords)
+            if len(coords_name) > 3 and (coord := coords_name[2]):
+                return [str(self.input.coords[coord].data)]
+
+            return [self.input.name or "array"]
+
+        return [str(band) for d in self._dims for band in self.input[d].values]
 
     def info(self) -> Info:
         """Return xarray.DataArray info."""
-        bands = [str(band) for d in self._dims for band in self.input[d].values] or [
-            "value"
-        ]
         metadata = [band.attrs for d in self._dims for band in self.input[d]] or [{}]
 
         meta = {
             "bounds": self.bounds,
             "crs": CRS_to_uri(self.crs) or self.crs.to_wkt(),
             "band_metadata": [(f"b{ix}", v) for ix, v in enumerate(metadata, 1)],
-            "band_descriptions": [(f"b{ix}", v) for ix, v in enumerate(bands, 1)],
+            "band_descriptions": [
+                (f"b{ix}", v) for ix, v in enumerate(self.band_names, 1)
+            ],
             "dtype": str(self.input.dtype),
             "nodata_type": "Nodata" if self.input.rio.nodata is not None else "None",
             "name": self.input.name,
             "count": self.input.rio.count,
             "width": self.input.rio.width,
             "height": self.input.rio.height,
+            "dimensions": self.input.dims,
             "attrs": {
                 k: (v.tolist() if isinstance(v, (numpy.ndarray, numpy.generic)) else v)
                 for k, v in self.input.attrs.items()
@@ -149,6 +164,28 @@ class XarrayReader(BaseReader):
 
         return Info(**meta)
 
+    def _sel_indexes(
+        self, indexes: Optional[Indexes] = None
+    ) -> Tuple[xarray.DataArray, List[str]]:
+        """Select `band` indexes in DataArray."""
+        da = self.input
+        band_names = self.band_names
+        if indexes := cast_to_sequence(indexes):
+            assert all(v > 0 for v in indexes), "Indexes value must be >= 1"
+            if da.ndim == 2:
+                if indexes != (1,):
+                    raise ValueError(
+                        f"Invalid indexes {indexes} for array of shape {da.shape}"
+                    )
+
+                return da, band_names
+
+            indexes = [idx - 1 for idx in indexes]
+            da = da[indexes]
+            band_names = [self.band_names[idx] for idx in indexes]
+
+        return da, band_names
+
     def statistics(
         self,
         categorical: bool = False,
@@ -156,17 +193,19 @@ class XarrayReader(BaseReader):
         percentiles: Optional[List[int]] = None,
         hist_options: Optional[Dict] = None,
         nodata: Optional[NoData] = None,
+        indexes: Optional[Indexes] = None,
         **kwargs: Any,
     ) -> Dict[str, BandStatistics]:
         """Return statistics from a dataset."""
         hist_options = hist_options or {}
 
-        ds = self.input
+        da, band_names = self._sel_indexes(indexes)
+
         if nodata is not None:
-            ds = ds.rio.write_nodata(nodata)
+            da = da.rio.write_nodata(nodata)
 
-        data = ds.to_masked_array()
-        data.mask |= data.data == ds.rio.nodata
+        data = da.to_masked_array()
+        data.mask |= data.data == da.rio.nodata
 
         stats = get_array_statistics(
             data,
@@ -176,9 +215,7 @@ class XarrayReader(BaseReader):
             **hist_options,
         )
 
-        return {
-            self.band_names[ix]: BandStatistics(**val) for ix, val in enumerate(stats)
-        }
+        return {band_names[ix]: BandStatistics(**val) for ix, val in enumerate(stats)}
 
     def tile(
         self,
@@ -189,6 +226,7 @@ class XarrayReader(BaseReader):
         reproject_method: WarpResampling = "nearest",
         auto_expand: bool = True,
         nodata: Optional[NoData] = None,
+        indexes: Optional[Indexes] = None,
         **kwargs: Any,
     ) -> ImageData:
         """Read a Web Map tile from a dataset.
@@ -211,20 +249,21 @@ class XarrayReader(BaseReader):
                 f"Tile(x={tile_x}, y={tile_y}, z={tile_z}) is outside bounds"
             )
 
-        ds = self.input
+        da, band_names = self._sel_indexes(indexes)
+
         if nodata is not None:
-            ds = ds.rio.write_nodata(nodata)
+            da = da.rio.write_nodata(nodata)
 
         tile_bounds = tuple(self.tms.xy_bounds(Tile(x=tile_x, y=tile_y, z=tile_z)))
         dst_crs = self.tms.rasterio_crs
 
         # Create source array by clipping the xarray dataset to extent of the tile.
-        ds = ds.rio.clip_box(
+        da = da.rio.clip_box(
             *tile_bounds,
             crs=dst_crs,
             auto_expand=auto_expand,
         )
-        ds = ds.rio.reproject(
+        da = da.rio.reproject(
             dst_crs,
             shape=(tilesize, tilesize),
             transform=from_bounds(*tile_bounds, height=tilesize, width=tilesize),
@@ -233,16 +272,16 @@ class XarrayReader(BaseReader):
         )
 
         # Forward valid_min/valid_max to the ImageData object
-        minv, maxv = ds.attrs.get("valid_min"), ds.attrs.get("valid_max")
+        minv, maxv = da.attrs.get("valid_min"), da.attrs.get("valid_max")
         stats = None
         if minv is not None and maxv is not None and nodata not in [minv, maxv]:
-            stats = ((minv, maxv),) * ds.rio.count
+            stats = ((minv, maxv),) * da.rio.count
 
-        arr = ds.to_masked_array()
-        arr.mask |= arr.data == ds.rio.nodata
+        arr = da.to_masked_array()
+        arr.mask |= arr.data == da.rio.nodata
 
-        output_bounds = ds.rio._unordered_bounds()
-        if output_bounds[1] > output_bounds[3] and ds.rio.transform().e > 0:
+        output_bounds = da.rio._unordered_bounds()
+        if output_bounds[1] > output_bounds[3] and da.rio.transform().e > 0:
             yaxis = self.input.dims.index(self.input.rio.y_dim)
             arr = numpy.flip(arr, axis=yaxis)
 
@@ -251,7 +290,7 @@ class XarrayReader(BaseReader):
             bounds=tile_bounds,
             crs=dst_crs,
             dataset_statistics=stats,
-            band_names=self.band_names,
+            band_names=band_names,
         )
 
     def part(
@@ -262,6 +301,7 @@ class XarrayReader(BaseReader):
         reproject_method: WarpResampling = "nearest",
         auto_expand: bool = True,
         nodata: Optional[NoData] = None,
+        indexes: Optional[Indexes] = None,
         max_size: Optional[int] = None,
         height: Optional[int] = None,
         width: Optional[int] = None,
@@ -294,11 +334,12 @@ class XarrayReader(BaseReader):
 
         dst_crs = dst_crs or bounds_crs
 
-        ds = self.input
+        da, band_names = self._sel_indexes(indexes)
+
         if nodata is not None:
-            ds = ds.rio.write_nodata(nodata)
+            da = da.rio.write_nodata(nodata)
 
-        ds = ds.rio.clip_box(
+        da = da.rio.clip_box(
             *bbox,
             crs=bounds_crs,
             auto_expand=auto_expand,
@@ -308,11 +349,11 @@ class XarrayReader(BaseReader):
             dst_transform, w, h = calculate_default_transform(
                 self.crs,
                 dst_crs,
-                ds.rio.width,
-                ds.rio.height,
-                *ds.rio.bounds(),
+                da.rio.width,
+                da.rio.height,
+                *da.rio.bounds(),
             )
-            ds = ds.rio.reproject(
+            da = da.rio.reproject(
                 dst_crs,
                 shape=(h, w),
                 transform=dst_transform,
@@ -321,25 +362,25 @@ class XarrayReader(BaseReader):
             )
 
         # Forward valid_min/valid_max to the ImageData object
-        minv, maxv = ds.attrs.get("valid_min"), ds.attrs.get("valid_max")
+        minv, maxv = da.attrs.get("valid_min"), da.attrs.get("valid_max")
         stats = None
         if minv is not None and maxv is not None:
-            stats = ((minv, maxv),) * ds.rio.count
+            stats = ((minv, maxv),) * da.rio.count
 
-        arr = ds.to_masked_array()
-        arr.mask |= arr.data == ds.rio.nodata
+        arr = da.to_masked_array()
+        arr.mask |= arr.data == da.rio.nodata
 
-        output_bounds = ds.rio._unordered_bounds()
-        if output_bounds[1] > output_bounds[3] and ds.rio.transform().e > 0:
+        output_bounds = da.rio._unordered_bounds()
+        if output_bounds[1] > output_bounds[3] and da.rio.transform().e > 0:
             yaxis = self.input.dims.index(self.input.rio.y_dim)
             arr = numpy.flip(arr, axis=yaxis)
 
         img = ImageData(
             arr,
-            bounds=ds.rio.bounds(),
-            crs=ds.rio.crs,
+            bounds=da.rio.bounds(),
+            crs=da.rio.crs,
             dataset_statistics=stats,
-            band_names=self.band_names,
+            band_names=band_names,
         )
 
         output_height = height or img.height
@@ -362,6 +403,7 @@ class XarrayReader(BaseReader):
         height: Optional[int] = None,
         width: Optional[int] = None,
         nodata: Optional[NoData] = None,
+        indexes: Optional[Indexes] = None,
         dst_crs: Optional[CRS] = None,
         reproject_method: WarpResampling = "nearest",
         resampling_method: RIOResampling = "nearest",
@@ -388,19 +430,20 @@ class XarrayReader(BaseReader):
                 UserWarning,
             )
 
-        ds = self.input
+        da, band_names = self._sel_indexes(indexes)
+
         if nodata is not None:
-            ds = ds.rio.write_nodata(nodata)
+            da = da.rio.write_nodata(nodata)
 
         if dst_crs and dst_crs != self.crs:
             dst_transform, w, h = calculate_default_transform(
                 self.crs,
                 dst_crs,
-                ds.rio.width,
-                ds.rio.height,
-                *ds.rio.bounds(),
+                da.rio.width,
+                da.rio.height,
+                *da.rio.bounds(),
             )
-            ds = ds.rio.reproject(
+            da = da.rio.reproject(
                 dst_crs,
                 shape=(h, w),
                 transform=dst_transform,
@@ -409,25 +452,25 @@ class XarrayReader(BaseReader):
             )
 
         # Forward valid_min/valid_max to the ImageData object
-        minv, maxv = ds.attrs.get("valid_min"), ds.attrs.get("valid_max")
+        minv, maxv = da.attrs.get("valid_min"), da.attrs.get("valid_max")
         stats = None
         if minv is not None and maxv is not None:
-            stats = ((minv, maxv),) * ds.rio.count
+            stats = ((minv, maxv),) * da.rio.count
 
-        arr = ds.to_masked_array()
-        arr.mask |= arr.data == ds.rio.nodata
+        arr = da.to_masked_array()
+        arr.mask |= arr.data == da.rio.nodata
 
-        output_bounds = ds.rio._unordered_bounds()
-        if output_bounds[1] > output_bounds[3] and ds.rio.transform().e > 0:
+        output_bounds = da.rio._unordered_bounds()
+        if output_bounds[1] > output_bounds[3] and da.rio.transform().e > 0:
             yaxis = self.input.dims.index(self.input.rio.y_dim)
             arr = numpy.flip(arr, axis=yaxis)
 
         img = ImageData(
             arr,
-            bounds=ds.rio.bounds(),
-            crs=ds.rio.crs,
+            bounds=da.rio.bounds(),
+            crs=da.rio.crs,
             dataset_statistics=stats,
-            band_names=self.band_names,
+            band_names=band_names,
         )
 
         output_height = height or img.height
@@ -450,6 +493,7 @@ class XarrayReader(BaseReader):
         lat: float,
         coord_crs: CRS = WGS84_CRS,
         nodata: Optional[NoData] = None,
+        indexes: Optional[Indexes] = None,
         **kwargs: Any,
     ) -> PointData:
         """Read a pixel value from a dataset.
@@ -464,32 +508,33 @@ class XarrayReader(BaseReader):
             PointData
 
         """
-        ds_lon, ds_lat = transform_coords(coord_crs, self.crs, [lon], [lat])
+        da_lon, da_lat = transform_coords(coord_crs, self.crs, [lon], [lat])
 
         if not (
-            (self.bounds[0] < ds_lon[0] < self.bounds[2])
-            and (self.bounds[1] < ds_lat[0] < self.bounds[3])
+            (self.bounds[0] < da_lon[0] < self.bounds[2])
+            and (self.bounds[1] < da_lat[0] < self.bounds[3])
         ):
             raise PointOutsideBounds("Point is outside dataset bounds")
 
-        ds = self.input
+        da, band_names = self._sel_indexes(indexes)
+
         if nodata is not None:
-            ds = ds.rio.write_nodata(nodata)
+            da = da.rio.write_nodata(nodata)
 
-        y, x = rowcol(ds.rio.transform(), ds_lon, ds_lat)
+        y, x = rowcol(da.rio.transform(), da_lon, da_lat)
 
-        if ds.ndim == 2:
-            arr = numpy.expand_dims(ds[int(y[0]), int(x[0])].to_masked_array(), axis=0)
+        if da.ndim == 2:
+            arr = numpy.expand_dims(da[int(y[0]), int(x[0])].to_masked_array(), axis=0)
         else:
-            arr = ds[:, int(y[0]), int(x[0])].to_masked_array()
+            arr = da[:, int(y[0]), int(x[0])].to_masked_array()
 
-        arr.mask |= arr.data == ds.rio.nodata
+        arr.mask |= arr.data == da.rio.nodata
 
         return PointData(
             arr,
             coordinates=(lon, lat),
             crs=coord_crs,
-            band_names=self.band_names,
+            band_names=band_names,
         )
 
     def feature(
@@ -500,6 +545,7 @@ class XarrayReader(BaseReader):
         reproject_method: WarpResampling = "nearest",
         auto_expand: bool = True,
         nodata: Optional[NoData] = None,
+        indexes: Optional[Indexes] = None,
         max_size: Optional[int] = None,
         height: Optional[int] = None,
         width: Optional[int] = None,
@@ -537,6 +583,7 @@ class XarrayReader(BaseReader):
             dst_crs=dst_crs,
             bounds_crs=shape_crs,
             nodata=nodata,
+            indexes=indexes,
             max_size=max_size,
             width=width,
             height=height,

{rio_tiler-7.3.0 → rio_tiler-7.4.0}/rio_tiler/models.py

@@ -14,13 +14,13 @@ from rasterio import windows
 from rasterio.coords import BoundingBox
 from rasterio.crs import CRS
 from rasterio.dtypes import dtype_ranges
-from rasterio.enums import ColorInterp
+from rasterio.enums import ColorInterp, Resampling
 from rasterio.errors import NotGeoreferencedWarning
 from rasterio.features import rasterize
 from rasterio.io import MemoryFile
 from rasterio.plot import reshape_as_image
-from rasterio.transform import from_bounds
-from rasterio.warp import transform_geom
+from rasterio.transform import array_bounds, from_bounds
+from rasterio.warp import calculate_default_transform, reproject, transform_geom
 from typing_extensions import Self
 
 from rio_tiler.colormap import apply_cmap
@@ -34,6 +34,7 @@ from rio_tiler.types import (
     IntervalTuple,
     NumType,
     RIOResampling,
+    WarpResampling,
 )
 from rio_tiler.utils import (
     _validate_shape_input,
@@ -786,3 +787,44 @@ class ImageData:
         ).astype("float32")
 
         return cover_array.sum(-1).sum(1) / (cover_scale**2)
+
+    def reproject(
+        self,
+        dst_crs: CRS,
+        resolution: Optional[Tuple[float, float]] = None,
+        reproject_method: WarpResampling = "nearest",
+    ) -> "ImageData":
+        """Reproject data and mask."""
+        dst_transform, w, h = calculate_default_transform(
+            self.crs,
+            dst_crs,
+            self.width,
+            self.height,
+            *self.bounds,
+            resolution=resolution,
+        )
+
+        destination = numpy.ma.masked_array(
+            numpy.zeros((self.count, h, w), dtype=self.array.dtype),
+        )
+        destination, _ = reproject(
+            self.array,
+            destination,
+            src_transform=self.transform,
+            src_crs=self.crs,
+            dst_transform=dst_transform,
+            dst_crs=dst_crs,
+            resampling=Resampling[reproject_method],
+        )
+
+        bounds = array_bounds(h, w, dst_transform)
+
+        return ImageData(
+            destination,
+            assets=self.assets,
+            crs=dst_crs,
+            bounds=bounds,
+            band_names=self.band_names,
+            metadata=self.metadata,
+            dataset_statistics=self.dataset_statistics,
+        )