Spaces:
Paused
Paused
| """ | |
| Area estimation for a previously-grounded region — Phase 16, follow-up | |
| chain hop 2 ("How much area?" after "Where exactly?"). | |
| Closes part of the gap flagged in PHASE15.md §2 ("What this does NOT | |
| do... it does not chain area calculation... automatically") and | |
| LEFT.md §3 ("Multi-step follow-up conversations... the rest of the | |
| chain (area size, then radar cross-check) is not built yet"). | |
| HONESTY CONTRACT: | |
| This is a geometric calculation over the PREVIOUS turn's bounding box — | |
| not a new model call, not a segmentation of the actual object, and not a | |
| guaranteed-accurate measurement. It only produces a real area figure | |
| when the source image carries usable georeferencing (a CRS + bounds from | |
| GeoTIFF metadata, in projected/metric units): | |
| - PNG/JPEG benchmark images have no CRS at all -> area is reported as | |
| unavailable, never guessed. | |
| - GeoTIFFs in a geographic (degree-based) CRS, e.g. plain WGS84 | |
| (EPSG:4326) without a projection, would need proper reprojection to | |
| convert degrees to metres — this module deliberately does NOT do that | |
| (no pyproj dependency added for a hackathon follow-up feature) and | |
| instead reports area as unavailable rather than silently treating | |
| degrees as if they were metres, which would be badly wrong at most | |
| latitudes. | |
| - Only GeoTIFFs in a recognisably projected/metric CRS (UTM zones, Web | |
| Mercator, a handful of common projected EPSG codes) get a real number, | |
| computed as: pixel-box footprint -> ground distance (using this | |
| image's own bounds/width/height as its ground-sample distance) -> | |
| rectangular area in km². This is the box's rectangular footprint, not | |
| a precise outline of the detected object. | |
| """ | |
| from __future__ import annotations | |
| from dataclasses import dataclass | |
| from typing import Optional | |
| class AreaResult: | |
| area_km2: Optional[float] | |
| area_note: str | |
| method: str | |
| # Pragmatic prototype check on the CRS string only — not a full units | |
| # lookup via a projections database. Good enough to catch the common | |
| # "GeoTIFF in a UTM/Mercator-family projected CRS" case that matters for | |
| # a hackathon demo; anything else is honestly reported as unavailable | |
| # rather than guessed. State this limitation wherever this is surfaced. | |
| _PROJECTED_CRS_HINTS = ("UTM", "3857", "MERCATOR", ":326", ":327", ":3035", ":5070", ":2163") | |
| _GEOGRAPHIC_CRS_HINTS = ("4326", "WGS 84", "WGS84", "LONGLAT", "LONG/LAT", "GEOGCS") | |
| def _looks_projected(crs: Optional[str]) -> Optional[bool]: | |
| """Returns True (projected/metric), False (geographic/degrees), or | |
| None (couldn't tell from the string — treated as unsupported).""" | |
| if not crs: | |
| return None | |
| c = crs.upper() | |
| if any(h in c for h in _GEOGRAPHIC_CRS_HINTS): | |
| return False | |
| if any(h in c for h in _PROJECTED_CRS_HINTS): | |
| return True | |
| return None | |
| def estimate_box_area_km2( | |
| box: tuple[float, float, float, float], | |
| image_width: int, | |
| image_height: int, | |
| crs: Optional[str], | |
| bounds: Optional[tuple], | |
| ) -> AreaResult: | |
| """box is (x_min, y_min, x_max, y_max) in PIXEL coordinates on the | |
| same image the box was originally computed from — image_width/ | |
| image_height/crs/bounds must all come from that same image's own | |
| upload metadata (api/upload.py's UploadResponse), never a different | |
| image, or the ground-sample distance will be silently wrong.""" | |
| x_min, y_min, x_max, y_max = box | |
| if not crs or not bounds or image_width <= 0 or image_height <= 0: | |
| return AreaResult( | |
| area_km2=None, | |
| area_note=( | |
| "Area unavailable — the source image has no georeferencing metadata " | |
| "(no CRS/bounds), so pixel dimensions cannot be converted to a ground " | |
| "distance. This is expected for PNG/JPEG benchmark images." | |
| ), | |
| method="unavailable_no_georeferencing", | |
| ) | |
| projected = _looks_projected(crs) | |
| if projected is not True: | |
| reason = ( | |
| f"source CRS ({crs}) appears to be a geographic (degree-based) coordinate " | |
| "system, not a projected metric one" | |
| if projected is False | |
| else f"source CRS ({crs}) could not be confidently identified as projected/metric" | |
| ) | |
| return AreaResult( | |
| area_km2=None, | |
| area_note=( | |
| f"Area unavailable — {reason}. Converting degrees to km\u00b2 without proper " | |
| "reprojection would silently misestimate area (the error varies with " | |
| "latitude), so this is intentionally left unreported rather than guessed. " | |
| "Reproject the source GeoTIFF to a projected CRS (e.g. the appropriate UTM " | |
| "zone) to get a real area figure here." | |
| ), | |
| method="unavailable_geographic_crs", | |
| ) | |
| minx, miny, maxx, maxy = bounds | |
| px_width_m = abs(maxx - minx) / image_width | |
| px_height_m = abs(maxy - miny) / image_height | |
| box_width_px = abs(x_max - x_min) | |
| box_height_px = abs(y_max - y_min) | |
| box_width_m = box_width_px * px_width_m | |
| box_height_m = box_height_px * px_height_m | |
| area_km2 = (box_width_m * box_height_m) / 1_000_000.0 | |
| return AreaResult( | |
| area_km2=round(area_km2, 4), | |
| area_note=( | |
| f"Approximate area from the previously grounded bounding box: " | |
| f"{box_width_m:.0f} m \u00d7 {box_height_m:.0f} m, using this image's own GeoTIFF " | |
| f"ground-sample distance ({px_width_m:.2f} m/px \u00d7 {px_height_m:.2f} m/px, derived " | |
| "from its bounds/width/height — not a hardcoded sensor resolution). This is the " | |
| "box's rectangular footprint, not a precise segmentation of the actual " | |
| "object/region — treat it as a rough order-of-magnitude estimate, not a " | |
| "validated measurement." | |
| ), | |
| method="bbox_pixel_to_ground_geotiff_gsd", | |
| ) | |