height correction, new defalt

flight_map/terrain.py

@@ -1,3 +1,4 @@
+import logging
 import math
 from contextlib import ExitStack
 from pathlib import Path
@@ -5,39 +6,40 @@ from typing import Any
 
 import rasterio
 from pyproj import Transformer
+from shapely.geometry import Point
+from shapely.geometry.base import BaseGeometry
 
 from flight_map.geo import Bounds
-from flight_map.storage import Observation
+
+LOGGER = logging.getLogger(__name__)
 
 
 class Elevation:
-    """Metre-valued terrain and optional h-H geoid separation rasters."""
+    """Metre-valued terrain for the separate map land-elevation summary."""
 
     def __init__(
         self,
         terrain: Path | None,
         reference: str = "unknown",
-        geoid: Path | None = None,
-        confirm_geometric_ellipsoid: bool = False,
     ) -> None:
         self.terrain_path = terrain
         self.reference = reference
-        self.geoid_path = geoid
-        self.confirm_geometric_ellipsoid = confirm_geometric_ellipsoid
         self.stack = ExitStack()
         self.ground: Any = None
-        self.geoid: Any = None
         self.ground_transform: Transformer | None = None
-        self.geoid_transform: Transformer | None = None
+        self.land_samples = 0
+        self.valid_land_samples = 0
+        self.water_samples = 0
+
+    @property
+    def land_coverage(self) -> float:
+        return self.valid_land_samples / self.land_samples if self.land_samples else 0.0
 
     def __enter__(self) -> "Elevation":
         with ExitStack() as stack:
             if self.terrain_path:
                 self.ground = stack.enter_context(rasterio.open(self.terrain_path))
                 self.ground_transform = self._transform(self.ground)
-            if self.geoid_path:
-                self.geoid = stack.enter_context(rasterio.open(self.geoid_path))
-                self.geoid_transform = self._transform(self.geoid)
             self.stack = stack.pop_all()
         return self
 
@@ -64,7 +66,10 @@ class Elevation:
         result = float(value) * dataset.scales[0] + dataset.offsets[0]
         return result if math.isfinite(result) else None
 
-    def mean_ground(self, bounds: Bounds, samples: int = 64) -> float | None:
+    def mean_ground(
+        self, bounds: Bounds, samples: int = 64, *, water: BaseGeometry | None = None
+    ) -> float | None:
+        self.land_samples = self.valid_land_samples = self.water_samples = 0
         if not self.ground or self.ground_transform is None or self.reference == "unknown":
             return None
         if samples < 2:
@@ -81,22 +86,35 @@ class Elevation:
             )
             for col in range(samples):
                 lon = bounds.west + (bounds.east - bounds.west) * (col + 0.5) / samples
+                if water is not None and water.covers(Point(lon, lat)):
+                    self.water_samples += 1
+                    continue
+                self.land_samples += 1
                 value = self.sample(self.ground, self.ground_transform, lon, lat)
                 if value is None:
-                    return None
+                    continue
+                self.valid_land_samples += 1
                 values.append(value)
-        return sum(values) / len(values)
-
-    def aircraft_altitude(self, observation: Observation) -> float | None:
-        if not self.confirm_geometric_ellipsoid or observation.geo_altitude is None:
+        if not values:
+            LOGGER.warning(
+                "Average land elevation unavailable: no valid land samples "
+                "(%d mapped water samples excluded).",
+                self.water_samples,
+            )
             return None
-        if self.reference == "wgs84-ellipsoid":
-            return observation.geo_altitude
-        if self.reference != "orthometric" or not self.geoid or self.geoid_transform is None:
-            return None
-        separation = self.sample(
-            self.geoid, self.geoid_transform, observation.longitude, observation.latitude
+        if self.valid_land_samples < self.land_samples:
+            LOGGER.warning(
+                "Incomplete height map: %.1f%% of sampled land has elevation data "
+                "(%d/%d); averaging valid land only. Missing land is not treated as water.",
+                100 * self.land_coverage,
+                self.valid_land_samples,
+                self.land_samples,
+            )
+        LOGGER.info(
+            "Land elevation coverage: %.1f%% (%d/%d); %d water samples excluded.",
+            100 * self.land_coverage,
+            self.valid_land_samples,
+            self.land_samples,
+            self.water_samples,
         )
-        if separation is None:
-            return None
-        return observation.geo_altitude - separation
+        return sum(values) / len(values)