Merge branch 'main' into band-interleaved

Author: kylebarron

README.md

@@ -28,7 +28,7 @@ Fast, async GeoTIFF and [Cloud-Optimized GeoTIFF][cogeo] (COG) reader for Python
 - Lightweight with **no GDAL dependency**.
 - Access data from AWS S3, Google Cloud Storage, and Azure Storage via **integration with [obstore]**.
 - **Full type hinting** for all operations.
-- **Broad decompression support**: Deflate, LZMA, LZW, JPEG, JPEG2000, WebP, ZSTD.
+- **Broad decompression support**: Deflate, JPEG, JPEG2000, LERC, LERC_DEFLATE, LERC_ZSTD, LZMA, LZW, WebP, ZSTD.
 - Support for **any arbitrary backend** via [obspec] protocols.
 
 [Affine]: https://affine.readthedocs.io/en/latest/

pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
 keywords = ["geotiff", "tiff", "async", "cog", "raster", "gis"]
 dependencies = [
     "affine>=2.4.0",
-    "async-tiff>=0.5.0",
+    "async-tiff>=0.6.0-beta.1",
     "numpy>=2.0",
     "pyproj>=3.3.0",
 ]

src/async_geotiff/_geotiff.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+import math
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import TYPE_CHECKING, Self, cast
+from typing import TYPE_CHECKING, Self
 
 import numpy as np
 from affine import Affine
@@ -161,17 +162,25 @@ def bounds(self) -> tuple[float, float, float, float]:
             lower left x, lower left y, upper right x, upper right y
 
         """
-        transform = self.transform
-
-        # TODO: Remove type casts once affine supports typing overloads for matmul
-        # https://github.com/rasterio/affine/pull/137
-        (left, top) = cast("tuple[float, float]", transform * (0, 0))
-        (right, bottom) = cast(
-            "tuple[float, float]",
-            transform * (self.width, self.height),
+        # Transform all four corners to handle rotated images correctly
+        # Pixel coordinates of corners: (x, y, 1) for affine transform
+        corners_pixel = np.array(
+            [
+                [0, 0, 1],
+                [self.width, 0, 1],
+                [0, self.height, 1],
+                [self.width, self.height, 1],
+            ],
         )
 
-        return (left, bottom, right, top)
+        # Apply affine transform: transform @ corners_pixel.T
+        transform_matrix = np.array(self.transform).reshape(3, 3)
+        corners_geo = (transform_matrix @ corners_pixel.T)[:2].T
+
+        min_x, min_y = corners_geo.min(axis=0)
+        max_x, max_y = corners_geo.max(axis=0)
+
+        return (float(min_x), float(min_y), float(max_x), float(max_y))
 
     # @property
     # def colorinterp(self) -> list[str]:
@@ -346,7 +355,11 @@ def photometric(self) -> PhotometricInterpretation | None:  # noqa: PLR0911
     def res(self) -> tuple[float, float]:
         """Return the (width, height) of pixels in the units of its CRS."""
         transform = self.transform
-        return (transform.a, -transform.e)
+        # For rotated images, resolution is the magnitude of the pixel size
+        # calculated from the transform matrix components
+        res_x = math.sqrt(transform.a**2 + transform.d**2)
+        res_y = math.sqrt(transform.b**2 + transform.e**2)
+        return (res_x, res_y)
 
     @property
     def shape(self) -> tuple[int, int]:

tests/image_list.py

@@ -1,28 +1,30 @@
 from __future__ import annotations
 
 ALL_DATA_IMAGES: list[tuple[str, str]] = [
-    ("eox_cloudless", "eox"),
-    ("nlcd_landcover", "nlcd"),
-    ("uint16_1band_lzw_block128_predictor2", "rasterio"),
-    ("uint8_1band_deflate_block128_unaligned", "rasterio"),
-    ("uint8_1band_lzma_block64", "rasterio"),
-    ("uint8_rgb_deflate_block64_cog", "rasterio"),
-    ("uint8_rgb_webp_block64_cog", "rasterio"),
-    ("uint8_rgba_webp_block64_cog", "rasterio"),
+    ("eox", "eox_cloudless"),
+    ("nlcd", "nlcd_landcover"),
+    ("rasterio", "float32_1band_lerc_block32"),
+    ("rasterio", "float32_1band_lerc_deflate_block32"),
+    ("rasterio", "float32_1band_lerc_zstd_block32"),
+    ("rasterio", "uint16_1band_lzw_block128_predictor2"),
+    ("rasterio", "uint8_1band_deflate_block128_unaligned"),
+    ("rasterio", "uint8_1band_lzma_block64"),
+    ("rasterio", "uint8_rgb_deflate_block64_cog"),
+    ("rasterio", "uint8_rgb_webp_block64_cog"),
+    ("rasterio", "uint8_rgba_webp_block64_cog"),
+    ("umbra", "sydney_airport_GEC"),
 ]
 """All fixtures where the data can be compared with rasterio."""
 
 
 ALL_TEST_IMAGES: list[tuple[str, str]] = [
     *ALL_DATA_IMAGES,
     # YCbCr is auto-decompressed by rasterio
-    ("maxar_opendata_yellowstone_visual", "vantor"),
-    # we don't support LERC yet
-    ("float32_1band_lerc_block32", "rasterio"),
+    ("vantor", "maxar_opendata_yellowstone_visual"),
 ]
 """All fixtures where we test metadata parsing."""
 
 ALL_MASKED_IMAGES: list[tuple[str, str]] = [
-    ("maxar_opendata_yellowstone_visual", "vantor"),
+    ("vantor", "maxar_opendata_yellowstone_visual"),
 ]
 """All fixtures that have a nodata mask."""

tests/test_colormap.py

@@ -13,16 +13,16 @@
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     [
-        ("nlcd_landcover", "nlcd"),
+        ("nlcd", "nlcd_landcover"),
     ],
 )
 async def test_colormap(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
     colormap = geotiff.colormap

tests/test_crs.py

@@ -26,14 +26,14 @@ def projjson_schema() -> dict:
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_TEST_IMAGES,
 )
 async def test_crs(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
     with load_rasterio(file_name, variant=variant) as rasterio_ds:
@@ -42,14 +42,14 @@ async def test_crs(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
-    [("nlcd_landcover", "nlcd")],
+    ("variant", "file_name"),
+    [("nlcd", "nlcd_landcover")],
 )
 async def test_crs_custom_projjson_schema(
     load_geotiff: LoadGeoTIFF,
     projjson_schema: dict,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     """Validate that a user-defined CRS produces valid PROJJSON."""
     geotiff = await load_geotiff(file_name, variant=variant)

tests/test_fetch.py

@@ -16,14 +16,14 @@
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_DATA_IMAGES,
 )
 async def test_fetch(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
 
@@ -39,14 +39,14 @@ async def test_fetch(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_DATA_IMAGES,
 )
 async def test_fetch_overview(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
     overview = geotiff.overviews[0]
@@ -55,22 +55,22 @@ async def test_fetch_overview(
 
     window = Window(0, 0, overview.tile_width, overview.tile_height)
     with load_rasterio(file_name, variant=variant, OVERVIEW_LEVEL=0) as rasterio_ds:
-        rasterio_data = rasterio_ds.read(window=window)
+        rasterio_data = rasterio_ds.read(window=window, boundless=True)
 
     np.testing.assert_array_equal(tile.array.data, rasterio_data)
     assert tile.array.crs == geotiff.crs
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_MASKED_IMAGES,
 )
 async def test_mask(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
 
@@ -90,14 +90,14 @@ async def test_mask(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_MASKED_IMAGES,
 )
 async def test_mask_overview(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
     overview = geotiff.overviews[0]
@@ -118,14 +118,14 @@ async def test_mask_overview(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_DATA_IMAGES,
 )
 async def test_fetch_as_masked(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
 

tests/test_geotiff.py

@@ -12,14 +12,14 @@
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_TEST_IMAGES,
 )
 async def test_ifd_info(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
 

tests/test_read.py

@@ -19,14 +19,14 @@
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_DATA_IMAGES,
 )
 async def test_read_single_tile(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     """Test reading a window that fits within a single tile."""
     geotiff = await load_geotiff(file_name, variant=variant)
@@ -47,14 +47,14 @@ async def test_read_single_tile(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_DATA_IMAGES,
 )
 async def test_read_spanning_tiles(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     """Test reading a window that spans multiple tiles."""
     geotiff = await load_geotiff(file_name, variant=variant)
@@ -93,14 +93,14 @@ async def test_read_spanning_tiles(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_DATA_IMAGES,
 )
 async def test_read_overview(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     """Test reading from an overview level."""
     geotiff = await load_geotiff(file_name, variant=variant)
@@ -151,14 +151,14 @@ async def test_read_bounds_validation(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("file_name", "variant"),
+    ("variant", "file_name"),
     ALL_DATA_IMAGES,
 )
 async def test_read_full(
     load_geotiff: LoadGeoTIFF,
     load_rasterio: LoadRasterio,
-    file_name: str,
     variant: str,
+    file_name: str,
 ) -> None:
     geotiff = await load_geotiff(file_name, variant=variant)
     array = await geotiff.read()