rio-tiler 7.0.1__tar.gz → 7.2.0__tar.gz

{rio_tiler-7.0.1 → rio_tiler-7.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rio-tiler
-Version: 7.0.1
+Version: 7.2.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/
@@ -79,6 +79,7 @@ Provides-Extra: s3
 Requires-Dist: boto3; extra == 's3'
 Provides-Extra: test
 Requires-Dist: boto3; extra == 'test'
+Requires-Dist: h5netcdf; extra == 'test'
 Requires-Dist: morecantile<7.0,>=6.0; extra == 'test'
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'

{rio_tiler-7.0.1 → rio_tiler-7.2.0}/pyproject.toml

@@ -43,6 +43,7 @@ test = [
     # XarrayReader
     "xarray",
     "rioxarray",
+    "h5netcdf",
     # S3
     "boto3",
     # Some tests will fail with 5.0
@@ -157,7 +158,7 @@ ignore = [
 max-complexity = 14
 
 [tool.bumpversion]
-current_version = "7.0.1"
+current_version = "7.2.0"
 search = "{current_version}"
 replace = "{new_version}"
 regex = false

{rio_tiler-7.0.1 → rio_tiler-7.2.0}/rio_tiler/__init__.py

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

{rio_tiler-7.0.1 → rio_tiler-7.2.0}/rio_tiler/io/stac.py

@@ -3,7 +3,18 @@
 import json
 import os
 import warnings
-from typing import Any, Dict, Iterator, Optional, Sequence, Set, Tuple, Type, Union
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
 from urllib.parse import urlparse
 
 import attr
@@ -273,7 +284,13 @@ class STACReader(MultiBaseReader):
         self.minzoom = self.minzoom if self.minzoom is not None else self._minzoom
         self.maxzoom = self.maxzoom if self.maxzoom is not None else self._maxzoom
 
-        self.assets = list(
+        self.assets = self.get_asset_list()
+        if not self.assets:
+            raise MissingAssets("No valid asset found. Asset's media types not supported")
+
+    def get_asset_list(self) -> List[str]:
+        """Get valid asset list"""
+        return list(
             _get_assets(
                 self.item,
                 include=self.include_assets,
@@ -282,8 +299,6 @@ class STACReader(MultiBaseReader):
                 exclude_asset_types=self.exclude_asset_types,
             )
         )
-        if not self.assets:
-            raise MissingAssets("No valid asset found. Asset's media types not supported")
 
     def _get_reader(self, asset_info: AssetInfo) -> Tuple[Type[BaseReader], Dict]:
         """Get Asset Reader."""

{rio_tiler-7.0.1 → rio_tiler-7.2.0}/rio_tiler/io/xarray.py

@@ -2,15 +2,21 @@
 
 from __future__ import annotations
 
+import warnings
 from typing import Any, Dict, List, Optional
 
 import attr
+import numpy
 from morecantile import Tile, TileMatrixSet
 from rasterio.crs import CRS
 from rasterio.enums import Resampling
+from rasterio.errors import NotGeoreferencedWarning
+from rasterio.features import bounds as featureBounds
+from rasterio.features import rasterize
 from rasterio.transform import from_bounds, rowcol
 from rasterio.warp import calculate_default_transform
 from rasterio.warp import transform as transform_coords
+from rasterio.warp import transform_geom
 
 from rio_tiler.constants import WEB_MERCATOR_TMS, WGS84_CRS
 from rio_tiler.errors import (
@@ -21,8 +27,9 @@ from rio_tiler.errors import (
 )
 from rio_tiler.io.base import BaseReader
 from rio_tiler.models import BandStatistics, ImageData, Info, PointData
-from rio_tiler.types import BBox, NoData, WarpResampling
-from rio_tiler.utils import CRS_to_uri, _validate_shape_input
+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
 
 try:
     import xarray
@@ -76,11 +83,14 @@ class XarrayReader(BaseReader):
                 "Dataset doesn't have CRS information, please add it before using rio-tiler (e.g. `ds.rio.write_crs('epsg:4326', inplace=True)`)"
             )
 
+        # adds half x/y resolution on each values
+        # https://github.com/corteva/rioxarray/issues/645#issuecomment-1461070634
+        xres, yres = map(abs, self.input.rio.resolution())
         if self.crs == WGS84_CRS and (
-            round(self.bounds[0]) < -180
-            or round(self.bounds[1]) < -90
-            or round(self.bounds[2]) > 180
-            or round(self.bounds[3]) > 90
+            self.bounds[0] + xres / 2 < -180
+            or self.bounds[1] + yres / 2 < -90
+            or self.bounds[2] - xres / 2 > 180
+            or self.bounds[3] - yres / 2 > 90
         ):
             raise InvalidGeographicBounds(
                 f"Invalid geographic bounds: {self.bounds}. Must be within (-180, -90, 180, 90)."
@@ -109,16 +119,20 @@ 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]
+        return [str(band) for d in self._dims for band in self.input[d].values] or [
+            "value"
+        ]
 
     def info(self) -> Info:
         """Return xarray.DataArray info."""
-        bands = [str(band) for d in self._dims for band in self.input[d].values]
-        metadata = [band.attrs for d in self._dims for band in self.input[d]]
+        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),
+            "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)],
             "dtype": str(self.input.dtype),
@@ -127,8 +141,12 @@ class XarrayReader(BaseReader):
             "count": self.input.rio.count,
             "width": self.input.rio.width,
             "height": self.input.rio.height,
-            "attrs": self.input.attrs,
+            "attrs": {
+                k: (v.tolist() if isinstance(v, (numpy.ndarray, numpy.generic)) else v)
+                for k, v in self.input.attrs.items()
+            },
         }
+
         return Info(**meta)
 
     def statistics(
@@ -137,11 +155,30 @@ class XarrayReader(BaseReader):
         categories: Optional[List[float]] = None,
         percentiles: Optional[List[int]] = None,
         hist_options: Optional[Dict] = None,
-        max_size: int = 1024,
+        nodata: Optional[NoData] = None,
         **kwargs: Any,
     ) -> Dict[str, BandStatistics]:
-        """Return bands statistics from a dataset."""
-        raise NotImplementedError
+        """Return statistics from a dataset."""
+        hist_options = hist_options or {}
+
+        ds = self.input
+        if nodata is not None:
+            ds = ds.rio.write_nodata(nodata)
+
+        data = ds.to_masked_array()
+        data.mask |= data.data == ds.rio.nodata
+
+        stats = get_array_statistics(
+            data,
+            categorical=categorical,
+            categories=categories,
+            percentiles=percentiles,
+            **hist_options,
+        )
+
+        return {
+            self.band_names[ix]: BandStatistics(**val) for ix, val in enumerate(stats)
+        }
 
     def tile(
         self,
@@ -152,6 +189,7 @@ class XarrayReader(BaseReader):
         reproject_method: WarpResampling = "nearest",
         auto_expand: bool = True,
         nodata: Optional[NoData] = None,
+        **kwargs: Any,
     ) -> ImageData:
         """Read a Web Map tile from a dataset.
 
@@ -203,6 +241,11 @@ class XarrayReader(BaseReader):
         arr = ds.to_masked_array()
         arr.mask |= arr.data == ds.rio.nodata
 
+        output_bounds = ds.rio._unordered_bounds()
+        if output_bounds[1] > output_bounds[3] and ds.rio.transform().e > 0:
+            yaxis = self.input.dims.index(self.input.rio.y_dim)
+            arr = numpy.flip(arr, axis=yaxis)
+
         return ImageData(
             arr,
             bounds=tile_bounds,
@@ -219,6 +262,11 @@ class XarrayReader(BaseReader):
         reproject_method: WarpResampling = "nearest",
         auto_expand: bool = True,
         nodata: Optional[NoData] = None,
+        max_size: Optional[int] = None,
+        height: Optional[int] = None,
+        width: Optional[int] = None,
+        resampling_method: RIOResampling = "nearest",
+        **kwargs: Any,
     ) -> ImageData:
         """Read part of a dataset.
 
@@ -229,11 +277,21 @@ class XarrayReader(BaseReader):
             reproject_method (WarpResampling, optional): WarpKernel resampling algorithm. Defaults to `nearest`.
             auto_expand (boolean, optional): When True, rioxarray's clip_box will expand clip search if only 1D raster found with clip. When False, will throw `OneDimensionalRaster` error if only 1 x or y data point is found. Defaults to True.
             nodata (int or float, optional): Overwrite dataset internal nodata value.
+            max_size (int, optional): Limit the size of the longest dimension of the dataset read, respecting bounds X/Y aspect ratio.
+            height (int, optional): Output height of the array.
+            width (int, optional): Output width of the array.
+            resampling_method (RIOResampling, optional): RasterIO resampling algorithm. Defaults to `nearest`.
 
         Returns:
             rio_tiler.models.ImageData: ImageData instance with data, mask and input spatial info.
 
         """
+        if max_size and width and height:
+            warnings.warn(
+                "'max_size' will be ignored with with 'height' and 'width' set.",
+                UserWarning,
+            )
+
         dst_crs = dst_crs or bounds_crs
 
         ds = self.input
@@ -271,7 +329,12 @@ class XarrayReader(BaseReader):
         arr = ds.to_masked_array()
         arr.mask |= arr.data == ds.rio.nodata
 
-        return ImageData(
+        output_bounds = ds.rio._unordered_bounds()
+        if output_bounds[1] > output_bounds[3] and ds.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,
@@ -279,11 +342,30 @@ class XarrayReader(BaseReader):
             band_names=self.band_names,
         )
 
+        output_height = height or img.height
+        output_width = width or img.width
+        if max_size and not (width and height):
+            output_height, output_width = _get_width_height(
+                max_size, img.height, img.width
+            )
+
+        if output_height != img.height or output_width != img.width:
+            img = img.resize(
+                output_height, output_width, resampling_method=resampling_method
+            )
+
+        return img
+
     def preview(
         self,
         max_size: int = 1024,
         height: Optional[int] = None,
         width: Optional[int] = None,
+        nodata: Optional[NoData] = None,
+        dst_crs: Optional[CRS] = None,
+        reproject_method: WarpResampling = "nearest",
+        resampling_method: RIOResampling = "nearest",
+        **kwargs: Any,
     ) -> ImageData:
         """Return a preview of a dataset.
 
@@ -291,12 +373,76 @@ class XarrayReader(BaseReader):
             max_size (int, optional): Limit the size of the longest dimension of the dataset read, respecting bounds X/Y aspect ratio. Defaults to 1024.
             height (int, optional): Output height of the array.
             width (int, optional): Output width of the array.
+            nodata (int or float, optional): Overwrite dataset internal nodata value.
+            dst_crs (rasterio.crs.CRS, optional): target coordinate reference system.
+            reproject_method (WarpResampling, optional): WarpKernel resampling algorithm. Defaults to `nearest`.
+            resampling_method (RIOResampling, optional): RasterIO resampling algorithm. Defaults to `nearest`.
 
         Returns:
             rio_tiler.models.ImageData: ImageData instance with data, mask and input spatial info.
 
         """
-        raise NotImplementedError
+        if max_size and width and height:
+            warnings.warn(
+                "'max_size' will be ignored with with 'height' and 'width' set.",
+                UserWarning,
+            )
+
+        ds = self.input
+        if nodata is not None:
+            ds = ds.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(),
+            )
+            ds = ds.rio.reproject(
+                dst_crs,
+                shape=(h, w),
+                transform=dst_transform,
+                resampling=Resampling[reproject_method],
+                nodata=nodata,
+            )
+
+        # Forward valid_min/valid_max to the ImageData object
+        minv, maxv = ds.attrs.get("valid_min"), ds.attrs.get("valid_max")
+        stats = None
+        if minv is not None and maxv is not None:
+            stats = ((minv, maxv),) * ds.rio.count
+
+        arr = ds.to_masked_array()
+        arr.mask |= arr.data == ds.rio.nodata
+
+        output_bounds = ds.rio._unordered_bounds()
+        if output_bounds[1] > output_bounds[3] and ds.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,
+            dataset_statistics=stats,
+            band_names=self.band_names,
+        )
+
+        output_height = height or img.height
+        output_width = width or img.width
+        if max_size and not (width and height):
+            output_height, output_width = _get_width_height(
+                max_size, img.height, img.width
+            )
+
+        if output_height != img.height or output_width != img.width:
+            img = img.resize(
+                output_height, output_width, resampling_method=resampling_method
+            )
+
+        return img
 
     def point(
         self,
@@ -304,6 +450,7 @@ class XarrayReader(BaseReader):
         lat: float,
         coord_crs: CRS = WGS84_CRS,
         nodata: Optional[NoData] = None,
+        **kwargs: Any,
     ) -> PointData:
         """Read a pixel value from a dataset.
 
@@ -331,7 +478,11 @@ class XarrayReader(BaseReader):
 
         y, x = rowcol(ds.rio.transform(), ds_lon, ds_lat)
 
-        arr = ds[:, int(y[0]), int(x[0])].to_masked_array()
+        if ds.ndim == 2:
+            arr = numpy.expand_dims(ds[int(y[0]), int(x[0])].to_masked_array(), axis=0)
+        else:
+            arr = ds[:, int(y[0]), int(x[0])].to_masked_array()
+
         arr.mask |= arr.data == ds.rio.nodata
 
         return PointData(
@@ -347,7 +498,13 @@ class XarrayReader(BaseReader):
         dst_crs: Optional[CRS] = None,
         shape_crs: CRS = WGS84_CRS,
         reproject_method: WarpResampling = "nearest",
+        auto_expand: bool = True,
         nodata: Optional[NoData] = None,
+        max_size: Optional[int] = None,
+        height: Optional[int] = None,
+        width: Optional[int] = None,
+        resampling_method: RIOResampling = "nearest",
+        **kwargs: Any,
     ) -> ImageData:
         """Read part of a dataset defined by a geojson feature.
 
@@ -356,52 +513,57 @@ class XarrayReader(BaseReader):
             dst_crs (rasterio.crs.CRS, optional): Overwrite target coordinate reference system.
             shape_crs (rasterio.crs.CRS, optional): Input geojson coordinate reference system. Defaults to `epsg:4326`.
             reproject_method (WarpResampling, optional): WarpKernel resampling algorithm. Defaults to `nearest`.
+            auto_expand (boolean, optional): When True, rioxarray's clip_box will expand clip search if only 1D raster found with clip. When False, will throw `OneDimensionalRaster` error if only 1 x or y data point is found. Defaults to True.
             nodata (int or float, optional): Overwrite dataset internal nodata value.
+            max_size (int, optional): Limit the size of the longest dimension of the dataset read, respecting bounds X/Y aspect ratio.
+            height (int, optional): Output height of the array.
+            width (int, optional): Output width of the array.
+            resampling_method (RIOResampling, optional): RasterIO resampling algorithm. Defaults to `nearest`.
 
         Returns:
             rio_tiler.models.ImageData: ImageData instance with data, mask and input spatial info.
 
         """
+        shape = _validate_shape_input(shape)
+
         if not dst_crs:
             dst_crs = shape_crs
 
-        shape = _validate_shape_input(shape)
+        # Get BBOX of the polygon
+        bbox = featureBounds(shape)
 
-        ds = self.input
-        if nodata is not None:
-            ds = ds.rio.write_nodata(nodata)
+        img = self.part(
+            bbox,
+            dst_crs=dst_crs,
+            bounds_crs=shape_crs,
+            nodata=nodata,
+            max_size=max_size,
+            width=width,
+            height=height,
+            reproject_method=reproject_method,
+            resampling_method=resampling_method,
+        )
 
-        ds = ds.rio.clip([shape], crs=shape_crs)
+        if dst_crs != shape_crs:
+            shape = transform_geom(shape_crs, dst_crs, shape)
 
-        if dst_crs != self.crs:
-            dst_transform, w, h = calculate_default_transform(
-                self.crs,
-                dst_crs,
-                ds.rio.width,
-                ds.rio.height,
-                *ds.rio.bounds(),
-            )
-            ds = ds.rio.reproject(
-                dst_crs,
-                shape=(h, w),
-                transform=dst_transform,
-                resampling=Resampling[reproject_method],
-                nodata=nodata,
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                category=NotGeoreferencedWarning,
+                module="rasterio",
             )
-
-        # Forward valid_min/valid_max to the ImageData object
-        minv, maxv = ds.attrs.get("valid_min"), ds.attrs.get("valid_max")
-        stats = None
-        if minv is not None and maxv is not None:
-            stats = ((minv, maxv),) * ds.rio.count
-
-        arr = ds.to_masked_array()
-        arr.mask |= arr.data == ds.rio.nodata
-
-        return ImageData(
-            arr,
-            bounds=ds.rio.bounds(),
-            crs=ds.rio.crs,
-            dataset_statistics=stats,
-            band_names=self.band_names,
-        )
+            cutline_mask = rasterize(
+                [shape],
+                out_shape=(img.height, img.width),
+                transform=img.transform,
+                all_touched=True,  # Mandatory for matching masks at different resolutions
+                default_value=0,
+                fill=1,
+                dtype="uint8",
+            ).astype("bool")
+
+        img.cutline_mask = cutline_mask
+        img.array.mask = numpy.where(~cutline_mask, img.array.mask, True)
+
+        return img

{rio_tiler-7.0.1 → rio_tiler-7.2.0}/rio_tiler/utils.py

@@ -3,7 +3,17 @@
 import math
 import warnings
 from io import BytesIO
-from typing import Any, Dict, Generator, List, Optional, Sequence, Tuple, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
 
 import numpy
 import rasterio
@@ -642,12 +652,15 @@ def pansharpening_brovey(
 def _convert_to_raster_space(
     src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
     poly_coordinates: List,
+    op: Optional[Callable[[float], Any]] = None,
 ) -> List[str]:
+    # NOTE: we could remove this once we have rasterio >= 1.4.2
+    op = op or numpy.floor
     polygons = []
     for point in poly_coordinates:
         xs, ys = zip(*coords(point))
-        src_y, src_x = rowcol(src_dst.transform, xs, ys)
-        polygon = ", ".join([f"{x} {y}" for x, y in list(zip(src_x, src_y))])
+        src_y, src_x = rowcol(src_dst.transform, xs, ys, op=op)
+        polygon = ", ".join([f"{int(x)} {int(y)}" for x, y in list(zip(src_x, src_y))])
         polygons.append(f"({polygon})")
 
     return polygons
@@ -657,6 +670,7 @@ def create_cutline(
     src_dst: Union[DatasetReader, DatasetWriter, WarpedVRT],
     geometry: Dict,
     geometry_crs: CRS = None,
+    op: Optional[Callable[[float], Any]] = None,
 ) -> str:
     """
     Create WKT Polygon Cutline for GDALWarpOptions.
@@ -678,13 +692,13 @@ def create_cutline(
         geometry = transform_geom(geometry_crs, src_dst.crs, geometry)
 
     if geom_type == "Polygon":
-        polys = ",".join(_convert_to_raster_space(src_dst, geometry["coordinates"]))
+        polys = ",".join(_convert_to_raster_space(src_dst, geometry["coordinates"], op))
         wkt = f"POLYGON ({polys})"
 
     elif geom_type == "MultiPolygon":
         multi_polys = []
         for poly in geometry["coordinates"]:
-            polys = ",".join(_convert_to_raster_space(src_dst, poly))
+            polys = ",".join(_convert_to_raster_space(src_dst, poly, op))
             multi_polys.append(f"({polys})")
         str_multipoly = ",".join(multi_polys)
         wkt = f"MULTIPOLYGON ({str_multipoly})"