feat: added example implementation for tiles

Author: JanssenBrm

app/main.py

@@ -3,7 +3,7 @@
 from app.platforms.dispatcher import load_processing_platforms
 from .config.logger import setup_logging
 from .config.settings import settings
-from .routers import jobs_status, unit_jobs, health
+from .routers import jobs_status, unit_jobs, health, tiles
 
 setup_logging()
 
@@ -19,6 +19,7 @@
 # keycloak.register(app, prefix="/auth")  # mounts OIDC endpoints for login if needed
 
 # include routers
+app.include_router(tiles.router)
 app.include_router(jobs_status.router)
 app.include_router(unit_jobs.router)
 app.include_router(health.router)

app/routers/tiles.py

@@ -0,0 +1,33 @@
+import logging
+from fastapi import APIRouter, HTTPException, status
+from geojson_pydantic import GeometryCollection
+
+from app.schemas.tiles import TileRequest
+from app.services.tiles import split_polygon_by_grid
+
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+@router.post(
+    "/tiles",
+    status_code=status.HTTP_201_CREATED,
+    tags=["Upscale Tasks"],
+    summary="Split an area of interest in a list of tiles.",
+    description="Given a certain area of interest and a tiling grid definition (from the"
+    "service’s Max AOI capacity), calculate the number of tiles to be"
+    "processed by the upscaling service.",
+)
+def split_in_tiles(payload: TileRequest) -> GeometryCollection:
+    try:
+        logger.debug(f"Splitting tiles in a {payload.grid} formation")
+        return split_polygon_by_grid(payload.aoi, payload.grid)
+    except Exception as e:
+        logger.exception(
+            f"An error occurred while calculating tiles for {payload.grid}"
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred while calculating tiles for {payload.grid}: {e}",
+        )

app/schemas/tiles.py

@@ -1,6 +1,15 @@
-# class TileRequest(BaseModel):
-#     aoi: dict
-#     grid: str
+from enum import Enum
+from pydantic import BaseModel
+from geojson_pydantic import Polygon
+
+
+class GridTypeEnum(str, Enum):
+    KM_20 = "20x20km"
+
+
+class TileRequest(BaseModel):
+    aoi: Polygon
+    grid: GridTypeEnum
 
 
 # class TileResponse(BaseModel):

app/services/tiles.py

@@ -0,0 +1,93 @@
+import logging
+from typing import Callable, Dict, List
+
+import pyproj
+from geojson_pydantic import GeometryCollection, Polygon
+from geojson_pydantic.geometries import Geometry, parse_geometry_obj
+from shapely import box
+from shapely.geometry import shape
+from shapely.ops import transform
+
+from app.schemas.tiles import GridTypeEnum
+
+logger = logging.getLogger(__name__)
+
+GRID_REGISTRY: Dict[GridTypeEnum, Callable[[Polygon], GeometryCollection]] = {}
+
+
+def split_polygon_by_grid(polygon: Polygon, grid: GridTypeEnum) -> GeometryCollection:
+    """
+    Split a GeoJSON Polygon into smaller polygons according to the specified grid type.
+
+    :param polygon: The GeoJSON Polygon to split.
+    :param grid: The grid type to use for splitting.
+    :return: A list of GeoJSON Polygons.
+    :raises ValueError: If the grid type is unknown.
+    """
+    if grid.lower() not in GRID_REGISTRY:
+        logger.error(f"An unknown grid was requested: {grid}")
+        raise ValueError(f"Unknown grid: {grid}")
+
+    split_func = GRID_REGISTRY[grid]
+    return split_func(polygon)
+
+
+def split_by_20x20_km_grid(polygon: Polygon) -> GeometryCollection:
+    """
+    Split polygon into 20x20 km tiles.
+
+    :param polygon: The GeoJSON Polygon to split.
+    :return: A list of GeoJSON Polygons.
+    """
+    logger.debug("Splitting polygon in a 20x20km grid")
+
+    return GeometryCollection(
+        type="GeometryCollection", geometries=_split_by_km_grid(polygon, 20.0)
+    )
+
+
+def _split_by_km_grid(aoi: Polygon, cell_size_km: float) -> List[Geometry]:
+    """
+    Splits a polygon into a list of smaller polygons based on a square grid of given size in km.
+
+    :param aoi: Polygon in GeoJSON format.
+    :param cell_size_km: Size of the grid cell in kilometers (default 20km).
+    :return: List of polygons as GeoJSON dicts.
+    """
+    # Load the polygon
+    polygon = shape(aoi)
+
+    # Project to a local projection (meters) for accurate distance calculations
+    proj_wgs84 = pyproj.CRS("EPSG:4326")
+    proj_meters = pyproj.CRS("EPSG:3857")
+    project_to_meters = pyproj.Transformer.from_crs(
+        proj_wgs84, proj_meters, always_xy=True
+    ).transform
+    project_to_wgs84 = pyproj.Transformer.from_crs(
+        proj_meters, proj_wgs84, always_xy=True
+    ).transform
+
+    polygon_m = transform(project_to_meters, polygon)
+    min_x, min_y, max_x, max_y = polygon_m.bounds
+    cell_size_m = cell_size_km * 1000  # convert km to meters
+
+    result_polygons: List[Geometry] = []
+
+    x = min_x
+    while x < max_x:
+        y = min_y
+        while y < max_y:
+            cell = box(x, y, x + cell_size_m, y + cell_size_m)
+            intersection = polygon_m.intersection(cell)
+            if not intersection.is_empty:
+                # Transform back to WGS84
+                intersection_wgs84 = transform(project_to_wgs84, intersection)
+                result_polygons.append(
+                    parse_geometry_obj(intersection_wgs84.__geo_interface__)
+                )
+            y += cell_size_m
+        x += cell_size_m
+    return result_polygons
+
+
+GRID_REGISTRY[GridTypeEnum.KM_20] = split_by_20x20_km_grid

mypy.ini

@@ -1,8 +0,0 @@
-[mypy-openeo]
-ignore_missing_imports = True
-
-[mypy-fastapi_keycloak]
-ignore_missing_imports = True
-
-[mypy-requests]
-ignore_missing_imports = True

requirements.txt

@@ -1,6 +1,7 @@
 fastapi
 fastapi_keycloak
 flake8
+geojson_pydantic
 httpx
 mypy
 mypy_extensions
@@ -9,9 +10,11 @@ psycopg2-binary
 pydantic
 pydantic-settings
 pydantic_core
+pyproj
 pytest
 pytest-asyncio
 pytest-cov
 python-dotenv
 requests
-SQLAlchemy
+SQLAlchemy
+types-shapely   

tests/routers/test_tiles.py

@@ -0,0 +1,32 @@
+from unittest.mock import patch
+import pytest
+from app.schemas.tiles import GridTypeEnum
+
+
+@pytest.fixture
+def dummy_payload():
+    coords = [[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]]
+    return {
+        "aoi": {
+            "type": "Polygon",
+            "coordinates": coords,
+        },
+        "grid": GridTypeEnum.KM_20,
+    }
+
+
+def test_split_in_tiles_success(client, dummy_payload):
+    response = client.post("/tiles", json=dummy_payload)
+    assert response.status_code == 201
+    data = response.json()
+    assert "geometries" in data
+    assert len(data["geometries"]) == 36
+    assert data["type"] == "GeometryCollection"
+
+
+@patch("app.routers.tiles.split_polygon_by_grid")
+def test_split_in_tiles_unknown_grid(mock_split, client, dummy_payload):
+    mock_split.side_effect = ValueError("Unknown grid: INVALID_GRID")
+    response = client.post("/tiles", json=dummy_payload)
+    assert response.status_code == 500
+    assert "Unknown grid" in response.json()["detail"]

tests/services/test_tiles_splits.py

@@ -0,0 +1,50 @@
+from geojson_pydantic import GeometryCollection, Polygon
+import pytest
+
+from app.schemas.tiles import GridTypeEnum
+from app.services.tiles import (
+    _split_by_km_grid,
+    split_by_20x20_km_grid,
+    split_polygon_by_grid,
+)
+
+
+def test_split_polygon_by_grid_known_grid():
+    coords = [[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]]
+    polygon = Polygon(type="Polygon", coordinates=coords)
+
+    # Should work with known grid
+    result = split_polygon_by_grid(polygon, GridTypeEnum.KM_20)
+    assert isinstance(result, GeometryCollection)
+    assert len(result.geometries) >= 36
+
+
+def test_split_polygon_by_grid_unknown_grid_raises():
+    coords = [[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]]
+    polygon = Polygon(type="Polygon", coordinates=coords)
+
+    with pytest.raises(ValueError):
+        split_polygon_by_grid(polygon, "UNKNOWN_GRID")
+
+
+def test__split_by_km_grid_creates_multiple_cells():
+    coords = [[(0, 0), (0.36, 0), (0.36, 0.36), (0, 0.36), (0, 0)]]
+    polygon = Polygon(type="Polygon", coordinates=coords)
+
+    result = _split_by_km_grid(polygon, 10.0)
+
+    assert len(result) == 25
+    for geom in result:
+        assert geom.type == "Polygon"
+
+
+def test_split_by_20x20_km_grid_returns_geometry_collection():
+    coords = [[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]]
+    polygon = Polygon(type="Polygon", coordinates=coords)
+
+    result = split_by_20x20_km_grid(polygon)
+
+    assert isinstance(result, GeometryCollection)
+    assert len(result.geometries) == 36
+    for geom in result.geometries:
+        assert geom.type == "Polygon"