rio-tiler 7.8.0__tar.gz → 7.9.0__tar.gz

{rio_tiler-7.8.0 → rio_tiler-7.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rio-tiler
-Version: 7.8.0
+Version: 7.9.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/

{rio_tiler-7.8.0 → rio_tiler-7.9.0}/pyproject.toml

@@ -161,7 +161,7 @@ exclude = [
 max-complexity = 14
 
 [tool.bumpversion]
-current_version = "7.8.0"
+current_version = "7.9.0"
 parse = """(?x)
     (?P<major>\\d+)\\.
     (?P<minor>\\d+)\\.

{rio_tiler-7.8.0 → rio_tiler-7.9.0}/rio_tiler/__init__.py

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

{rio_tiler-7.8.0 → rio_tiler-7.9.0}/rio_tiler/io/xarray.py

@@ -2,12 +2,14 @@
 
 from __future__ import annotations
 
+import math
 import warnings
 from typing import Any, Dict, List, Optional, Tuple
 
 import attr
 import numpy
 from morecantile import Tile, TileMatrixSet
+from rasterio import windows
 from rasterio.crs import CRS
 from rasterio.enums import Resampling
 from rasterio.errors import NotGeoreferencedWarning
@@ -16,9 +18,9 @@ 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 rasterio.warp import transform_bounds, transform_geom
 
-from rio_tiler.constants import WEB_MERCATOR_TMS, WGS84_CRS
+from rio_tiler.constants import WEB_MERCATOR_CRS, WEB_MERCATOR_TMS, WGS84_CRS
 from rio_tiler.errors import (
     InvalidGeographicBounds,
     MissingCRS,
@@ -27,10 +29,11 @@ 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, Indexes, NoData, RIOResampling, WarpResampling
 from rio_tiler.utils import (
     CRS_to_uri,
+    _get_width_height,
+    _missing_size,
     _validate_shape_input,
     cast_to_sequence,
     get_array_statistics,
@@ -268,53 +271,24 @@ class XarrayReader(BaseReader):
                 f"Tile(x={tile_x}, y={tile_y}, z={tile_z}) is outside bounds"
             )
 
-        da, band_names = self._sel_indexes(indexes)
-
-        if nodata is not None:
-            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.
-        da = da.rio.clip_box(
-            *tile_bounds,
-            crs=dst_crs,
+        return self.part(
+            tile_bounds,
+            dst_crs=dst_crs,
+            bounds_crs=dst_crs,
+            reproject_method=reproject_method,
             auto_expand=auto_expand,
-        )
-        da = da.rio.reproject(
-            dst_crs,
-            shape=(tilesize, tilesize),
-            transform=from_bounds(*tile_bounds, height=tilesize, width=tilesize),
-            resampling=Resampling[reproject_method],
             nodata=nodata,
+            indexes=indexes,
+            height=tilesize,
+            width=tilesize,
+            out_dtype=out_dtype,
+            **kwargs,
         )
 
-        # Forward valid_min/valid_max to the ImageData object
-        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),) * da.rio.count
-
-        arr = da.to_masked_array()
-        if out_dtype:
-            arr = arr.astype(out_dtype)
-        arr.mask |= arr.data == da.rio.nodata
-
-        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)
-
-        return ImageData(
-            arr,
-            bounds=tile_bounds,
-            crs=dst_crs,
-            dataset_statistics=stats,
-            band_names=band_names,
-        )
-
-    def part(
+    def part(  # noqa: C901
         self,
         bbox: BBox,
         dst_crs: Optional[CRS] = None,
@@ -348,11 +322,12 @@ class XarrayReader(BaseReader):
             rio_tiler.models.ImageData: ImageData instance with data, mask and input spatial info.
 
         """
-        if max_size and width and height:
+        if max_size and (width or height):
             warnings.warn(
-                "'max_size' will be ignored with with 'height' and 'width' set.",
+                "'max_size' will be ignored with with 'height' or 'width' set.",
                 UserWarning,
             )
+            max_size = None
 
         dst_crs = dst_crs or bounds_crs
 
@@ -361,33 +336,99 @@ class XarrayReader(BaseReader):
         if nodata is not None:
             da = da.rio.write_nodata(nodata)
 
+        # Forward valid_min/valid_max to the ImageData object
+        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),) * da.rio.count
+
         da = da.rio.clip_box(
             *bbox,
             crs=bounds_crs,
             auto_expand=auto_expand,
         )
 
-        if dst_crs != self.crs:
-            dst_transform, w, h = calculate_default_transform(
-                self.crs,
-                dst_crs,
-                da.rio.width,
-                da.rio.height,
-                *da.rio.bounds(),
+        src_width = da.rio.width
+        src_height = da.rio.height
+        src_bounds = list(da.rio.bounds())
+        src_transform = da.rio.transform()
+
+        # Fix for https://github.com/cogeotiff/rio-tiler/issues/654
+        #
+        # When using `calculate_default_transform` with dataset
+        # which span at high/low latitude outside the area_of_use
+        # of the WebMercator projection, we `crop` the dataset
+        # to get the transform (resolution).
+        #
+        # Note: Should be handled in gdal 3.8 directly
+        # https://github.com/OSGeo/gdal/pull/8775
+        if (
+            self.crs == WGS84_CRS
+            and dst_crs == WEB_MERCATOR_CRS
+            and (src_bounds[1] < -85.06 or src_bounds[3] > 85.06)
+        ):
+            warnings.warn(
+                "Adjusting dataset latitudes to avoid re-projection overflow",
+                UserWarning,
             )
-            da = da.rio.reproject(
-                dst_crs,
-                shape=(h, w),
-                transform=dst_transform,
-                resampling=Resampling[reproject_method],
-                nodata=nodata,
+            src_bounds[1] = max(src_bounds[1], -85.06)
+            src_bounds[3] = min(src_bounds[3], 85.06)
+            w = windows.from_bounds(*src_bounds, transform=src_transform)
+            src_height = round(w.height)
+            src_width = round(w.width)
+
+        # Specific FIX when bounds and transform are inverted
+        # See: https://github.com/US-GHG-Center/veda-config-ghg/pull/333
+        elif (
+            self.crs == WGS84_CRS
+            and dst_crs == WEB_MERCATOR_CRS
+            and (src_bounds[1] > 85.06 or src_bounds[3] < -85.06)
+        ):
+            warnings.warn(
+                "Adjusting dataset latitudes to avoid re-projection overflow",
+                UserWarning,
             )
+            src_bounds[1] = min(src_bounds[1], 85.06)
+            src_bounds[3] = max(src_bounds[3], -85.06)
+            w = windows.from_bounds(*src_bounds, transform=src_transform)
+            src_height = round(w.height)
+            src_width = round(w.width)
 
-        # Forward valid_min/valid_max to the ImageData object
-        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),) * da.rio.count
+        if dst_crs != self.crs:
+            # transform of the reprojected dataset
+            dst_transform, _, _ = calculate_default_transform(
+                self.crs, dst_crs, src_width, src_height, *src_bounds
+            )
+        else:
+            dst_transform = from_bounds(*src_bounds, src_width, src_height)
+
+        if bounds_crs and bounds_crs != dst_crs:
+            bbox = transform_bounds(bounds_crs, dst_crs, *bbox, densify_pts=21)
+
+        w, s, e, n = bbox
+        # max size of the output dataset for the bbox
+        dst_width = max(1, round((e - w) / dst_transform.a))
+        dst_height = max(1, round((s - n) / dst_transform.e))
+
+        if max_size:
+            height, width = _get_width_height(max_size, dst_height, dst_width)
+
+        elif _missing_size(height, width):
+            ratio = dst_height / dst_width
+            if width:
+                height = math.ceil(width * ratio)
+            else:
+                width = math.ceil(height / ratio)
+
+        height = height or dst_height
+        width = width or dst_width
+        da = da.rio.reproject(
+            dst_crs,
+            shape=(height, width),
+            transform=from_bounds(w, s, e, n, width, height),
+            resampling=Resampling[reproject_method],
+            nodata=nodata,
+        )
 
         arr = da.to_masked_array()
         if out_dtype:
@@ -401,7 +442,7 @@ class XarrayReader(BaseReader):
 
         img = ImageData(
             arr,
-            bounds=da.rio.bounds(),
+            bounds=bbox,
             crs=da.rio.crs,
             dataset_statistics=stats,
             band_names=band_names,
@@ -449,11 +490,12 @@ class XarrayReader(BaseReader):
             rio_tiler.models.ImageData: ImageData instance with data, mask and input spatial info.
 
         """
-        if max_size and width and height:
+        if max_size and (width or height):
             warnings.warn(
-                "'max_size' will be ignored with with 'height' and 'width' set.",
+                "'max_size' will be ignored with with 'height' or 'width' set.",
                 UserWarning,
             )
+            max_size = None
 
         da, band_names = self._sel_indexes(indexes)
 
@@ -500,17 +542,18 @@ class XarrayReader(BaseReader):
             band_names=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 max_size:
+            height, 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
-            )
+        elif _missing_size(height, width):
+            ratio = img.height / img.width
+            if width:
+                height = math.ceil(width * ratio)
+            else:
+                width = math.ceil(height / ratio)
+
+        if (height and width) and (height != da.rio.height or width != da.rio.width):
+            img = img.resize(height, width, resampling_method=resampling_method)
 
         return img
 
@@ -622,6 +665,8 @@ class XarrayReader(BaseReader):
             reproject_method=reproject_method,
             resampling_method=resampling_method,
             out_dtype=out_dtype,
+            auto_expand=auto_expand,
+            **kwargs,
         )
 
         if dst_crs != shape_crs:

{rio_tiler-7.8.0 → rio_tiler-7.9.0}/rio_tiler/reader.py

@@ -20,6 +20,7 @@ from rio_tiler.constants import WGS84_CRS
 from rio_tiler.errors import InvalidBufferSize, PointOutsideBounds, TileOutsideBounds
 from rio_tiler.models import ImageData, PointData
 from rio_tiler.types import BBox, Indexes, NoData, RIOResampling, WarpResampling
+from rio_tiler.utils import _get_width_height, _missing_size
 from rio_tiler.utils import _requested_tile_aligned_with_internal_tile as is_aligned
 from rio_tiler.utils import (
     _round_window,
@@ -42,28 +43,6 @@ class Options(TypedDict, total=False):
     post_process: Optional[Callable[[numpy.ma.MaskedArray], numpy.ma.MaskedArray]]
 
 
-def _get_width_height(max_size, dataset_height, dataset_width) -> Tuple[int, int]:
-    """Get Output Width/Height based on a max_size and dataset shape."""
-    if max(dataset_height, dataset_width) < max_size:
-        return dataset_height, dataset_width
-
-    ratio = dataset_height / dataset_width
-    if ratio > 1:
-        height = max_size
-        width = math.ceil(height / ratio)
-    else:
-        width = max_size
-        height = math.ceil(width * ratio)
-
-    return height, width
-
-
-def _missing_size(w: Optional[int] = None, h: Optional[int] = None):
-    """Check if one and only one size (width, height) is valid."""
-    iterator = iter([w, h])
-    return any(iterator) and not any(iterator)
-
-
 def _apply_buffer(
     buffer: float,
     bounds: BBox,
@@ -297,6 +276,19 @@ def read(
             numpy.multiply(data, scales, out=data, casting="unsafe")
             numpy.add(data, offsets, out=data, casting="unsafe")
 
+            # apply scale/offsets to stats
+            if dataset_statistics:
+                scales = numpy.array(dataset.scales)[numpy.array(indexes) - 1].reshape(
+                    (-1, 1)
+                )
+                offsets = numpy.array(dataset.offsets)[numpy.array(indexes) - 1].reshape(
+                    (-1, 1)
+                )
+                stats_array = numpy.array(dataset_statistics)
+                numpy.multiply(stats_array, scales, out=stats_array, casting="unsafe")
+                numpy.add(stats_array, offsets, out=stats_array, casting="unsafe")
+                dataset_statistics = [tuple(s) for s in stats_array.tolist()]
+
         if post_process:
             data = post_process(data)
 

{rio_tiler-7.8.0 → rio_tiler-7.9.0}/rio_tiler/utils.py

@@ -43,6 +43,28 @@ def _chunks(my_list: Sequence, chuck_size: int) -> Generator[Sequence, None, Non
         yield my_list[i : i + chuck_size]
 
 
+def _get_width_height(max_size, dataset_height, dataset_width) -> Tuple[int, int]:
+    """Get Output Width/Height based on a max_size and dataset shape."""
+    if max(dataset_height, dataset_width) < max_size:
+        return dataset_height, dataset_width
+
+    ratio = dataset_height / dataset_width
+    if ratio > 1:
+        height = max_size
+        width = math.ceil(height / ratio)
+    else:
+        width = max_size
+        height = math.ceil(width * ratio)
+
+    return height, width
+
+
+def _missing_size(w: Optional[int] = None, h: Optional[int] = None):
+    """Check if one and only one size (width, height) is valid."""
+    iterator = iter([w, h])
+    return any(iterator) and not any(iterator)
+
+
 # Ref: https://stackoverflow.com/posts/73905572
 def _weighted_quantiles(
     values: NDArray[numpy.floating],