feat: Implement transform, height, width (#8)

* Initial pytest setup

* feat: Implement `transform`, `height`, `width`

* add python test ci

* don't apply ruff on fixtures

Author: kylebarron

.github/workflows/test.yml

@@ -0,0 +1,48 @@
+name: Test Python
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  lint-python:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+
+      - name: Install a specific version of uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          version: "latest"
+
+      # # Ensure docs build without warnings
+      # - name: Check docs
+      #   if: "${{ matrix.python-version == 3.11 }}"
+      #   run: uv run --group docs mkdocs build --strict
+
+      # Use ruff-action so we get annotations in the Github UI
+      - uses: astral-sh/ruff-action@v3
+
+  pytest:
+    name: Pytest
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+
+      - name: Install a specific version of uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          version: "latest"
+
+      - name: Run pytest
+        run: uv run pytest

pyproject.toml

@@ -16,11 +16,20 @@ dependencies = [
 morecantile = ["morecantile>=7.0,<8.0"]
 
 [dependency-groups]
-dev = ["ipykernel>=7.1.0", "rasterio>=1.4.4"]
+dev = [
+    "ipykernel>=7.1.0",
+    "obstore>=0.8.2",
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+    "rasterio>=1.4.4",
+]
 
 [build-system]
 requires = ["uv_build>=0.8.8,<0.9.0"]
 build-backend = "uv_build"
 
+[tool.ruff]
+extend-exclude = ["fixtures"]
+
 [tool.ruff.lint]
 select = ["I"]

src/async_geotiff/__init__.py

@@ -1,4 +1,4 @@
-from ._version import __version__
 from ._geotiff import GeoTIFF
+from ._version import __version__
 
 __all__ = ["GeoTIFF", "__version__"]

src/async_geotiff/_geotiff.py

@@ -2,14 +2,15 @@
 
 from typing import TYPE_CHECKING, Literal, Self
 
-from async_tiff import TIFF, ImageFileDirectory, ObspecInput
-from async_tiff.store import ObjectStore
+from affine import Affine
+from async_tiff import TIFF
 
 from async_geotiff.enums import Compression, Interleaving, PhotometricInterp
 
 if TYPE_CHECKING:
     import pyproj
-    from affine import Affine
+    from async_tiff import GeoKeyDirectory, ImageFileDirectory, ObspecInput
+    from async_tiff.store import ObjectStore
 
 
 class GeoTIFF:
@@ -19,13 +20,32 @@ class GeoTIFF:
     """The underlying async-tiff TIFF instance that we wrap.
     """
 
+    _primary_ifd: ImageFileDirectory
+    """The primary (first) IFD of the GeoTIFF.
+
+    Some tags, like most geo tags, only exist on the primary IFD.
+    """
+
+    _gkd: GeoKeyDirectory
+    """The GeoKeyDirectory of the primary IFD.
+    """
+
     def __init__(self, tiff: TIFF) -> None:
         """Create a GeoTIFF from an existing TIFF instance."""
+
+        first_ifd = tiff.ifds[0]
+        gkd = first_ifd.geo_key_directory
+
         # Validate that this is indeed a GeoTIFF
-        if not has_geokeys(tiff.ifds[0]):
+        if gkd is None:
             raise ValueError("TIFF does not contain GeoTIFF keys")
 
+        if len(tiff.ifds) == 0:
+            raise ValueError("TIFF does not contain any IFDs")
+
         self._tiff = tiff
+        self._primary_ifd = first_ifd
+        self._gkd = gkd
 
     @classmethod
     async def open(
@@ -36,7 +56,7 @@ async def open(
         prefetch: int = 32768,
         multiplier: int | float = 2.0,
     ) -> Self:
-        """Open a new TIFF.
+        """Open a new GeoTIFF.
 
         Args:
             path: The path within the store to read from.
@@ -121,12 +141,12 @@ def compression(self) -> Compression:
 
     @property
     def count(self) -> int:
-        """The number of raster bands in the dataset."""
+        """The number of raster bands in the full image."""
         raise NotImplementedError()
 
     @property
     def crs(self) -> pyproj.CRS:
-        """The dataset’s coordinate reference system."""
+        """The dataset's coordinate reference system."""
         raise NotImplementedError()
 
     @property
@@ -138,8 +158,8 @@ def dtypes(self) -> list[str]:
 
     @property
     def height(self) -> int:
-        """The height (number of rows) of the dataset."""
-        raise NotImplementedError()
+        """The height (number of rows) of the full image."""
+        return self._primary_ifd.image_height
 
     def index(
         self,
@@ -208,12 +228,48 @@ def transform(self) -> Affine:
 
         This transform maps pixel row/column coordinates to coordinates in the dataset's coordinate reference system.
         """
-        raise NotImplementedError()
+        if (tie_points := self._primary_ifd.model_tiepoint) and (
+            model_scale := self._primary_ifd.model_pixel_scale
+        ):
+            x_origin = tie_points[3]
+            y_origin = tie_points[4]
+            x_resolution = model_scale[0]
+            y_resolution = -model_scale[1]
+
+            return Affine(x_resolution, 0, x_origin, 0, y_resolution, y_origin)
+
+        if model_transformation := self._primary_ifd.model_transformation:
+            # ModelTransformation is a 4x4 matrix in row-major order
+            # [0  1  2  3 ]   [a  b  0  c]
+            # [4  5  6  7 ] = [d  e  0  f]
+            # [8  9  10 11]   [0  0  1  0]
+            # [12 13 14 15]   [0  0  0  1]
+            x_origin = model_transformation[3]
+            y_origin = model_transformation[7]
+            row_rotation = model_transformation[1]
+            col_rotation = model_transformation[4]
+
+            # TODO: confirm these are correct
+            # Why does geotiff.js square and then square-root them?
+            # https://github.com/developmentseed/async-geotiff/issues/7
+            x_resolution = model_transformation[0]
+            y_resolution = -model_transformation[5]
+
+            return Affine(
+                model_transformation[0],
+                row_rotation,
+                x_origin,
+                col_rotation,
+                model_transformation[5],
+                y_origin,
+            )
+
+        raise ValueError("The image does not have an affine transformation.")
 
     @property
     def width(self) -> int:
-        """The width (number of columns) of the dataset."""
-        raise NotImplementedError()
+        """The width (number of columns) of the full image."""
+        return self._primary_ifd.image_width
 
     def xy(
         self,

tests/conftest.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, Generator
+
+import pytest
+import rasterio
+from async_tiff.store import LocalStore
+
+from async_geotiff import GeoTIFF
+
+if TYPE_CHECKING:
+    from rasterio.io import DatasetReader
+
+
+@pytest.fixture(scope="session")
+def root_dir() -> Path:
+    root_dir = Path(__file__).parent.resolve()
+
+    if root_dir.name != "async-geotiff":
+        root_dir = root_dir.parent
+
+    return root_dir
+
+
+@pytest.fixture(scope="session")
+def fixture_store(root_dir) -> LocalStore:
+    return LocalStore(root_dir / "fixtures")
+
+
+@pytest.fixture
+def load_geotiff(fixture_store):
+    async def _load(name: str) -> GeoTIFF:
+        path = f"geotiff-test-data/rasterio_generated/fixtures/{name}.tif"
+        return await GeoTIFF.open(path=path, store=fixture_store)
+
+    return _load
+
+
+@pytest.fixture
+def load_rasterio(root_dir):
+    @contextmanager
+    def _load(name: str) -> Generator[DatasetReader, None, None]:
+        path = f"{root_dir}/fixtures/geotiff-test-data/rasterio_generated/fixtures/{name}.tif"
+        with rasterio.open(path) as ds:
+            yield ds
+
+    return _load

tests/test_geotiff.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Awaitable, Callable
+
+import pytest
+
+from async_geotiff import GeoTIFF
+
+if TYPE_CHECKING:
+    from rasterio.io import DatasetReader
+
+
+@pytest.mark.asyncio
+async def test_height_width(
+    load_geotiff: Callable[[str], Awaitable[GeoTIFF]],
+    load_rasterio: Callable[[str], DatasetReader],
+) -> None:
+    name = "uint8_rgb_deflate_block64_cog"
+
+    geotiff = await load_geotiff(name)
+    with load_rasterio(name) as rasterio_ds:
+        assert rasterio_ds.height == geotiff.height
+        assert rasterio_ds.width == geotiff.width
+
+
+@pytest.mark.asyncio
+async def test_transform(
+    load_geotiff: Callable[[str], Awaitable[GeoTIFF]],
+    load_rasterio: Callable[[str], DatasetReader],
+) -> None:
+    name = "uint8_rgb_deflate_block64_cog"
+
+    geotiff = await load_geotiff(name)
+    with load_rasterio(name) as rasterio_ds:
+        assert rasterio_ds.transform == geotiff.transform