@mytec: 1.2iter ready for test

backend/app/services/terrain_service.py

@@ -0,0 +1,191 @@
+import struct
+import asyncio
+import aiofiles
+import httpx
+from pathlib import Path
+from typing import List, Optional, Tuple
+import numpy as np
+
+
+class TerrainService:
+    """
+    SRTM elevation data service
+    - Downloads and caches .hgt tiles
+    - Provides elevation lookups
+    - Generates elevation profiles
+    """
+
+    # SRTM tile dimensions (1 arc-second = 3601x3601, 3 arc-second = 1201x1201)
+    TILE_SIZE = 3601  # 1 arc-second (30m resolution)
+
+    # Mirror URLs for SRTM data (USGS requires login, use mirrors)
+    SRTM_MIRRORS = [
+        "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{lat_dir}/{tile_name}.hgt.gz",
+        "https://s3.amazonaws.com/elevation-tiles-prod/skadi/{lat_dir}/{tile_name}.hgt.gz",
+    ]
+
+    def __init__(self, cache_dir: str = "/opt/rfcp/backend/data/srtm"):
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(exist_ok=True, parents=True)
+        self._tile_cache: dict[str, np.ndarray] = {}  # In-memory cache
+        self._max_cached_tiles = 10  # Limit memory usage
+
+    def get_tile_name(self, lat: float, lon: float) -> str:
+        """Convert lat/lon to SRTM tile name (e.g., N48E035)"""
+        lat_int = int(lat) if lat >= 0 else int(lat) - 1
+        lon_int = int(lon) if lon >= 0 else int(lon) - 1
+
+        lat_letter = 'N' if lat_int >= 0 else 'S'
+        lon_letter = 'E' if lon_int >= 0 else 'W'
+
+        return f"{lat_letter}{abs(lat_int):02d}{lon_letter}{abs(lon_int):03d}"
+
+    def get_tile_path(self, tile_name: str) -> Path:
+        """Get local path for tile"""
+        return self.cache_dir / f"{tile_name}.hgt"
+
+    async def download_tile(self, tile_name: str) -> bool:
+        """Download SRTM tile from mirror"""
+        import gzip
+
+        tile_path = self.get_tile_path(tile_name)
+        if tile_path.exists():
+            return True
+
+        lat_dir = tile_name[:3]  # e.g., "N48"
+
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            for mirror in self.SRTM_MIRRORS:
+                url = mirror.format(lat_dir=lat_dir, tile_name=tile_name)
+                try:
+                    response = await client.get(url)
+                    if response.status_code == 200:
+                        # Decompress gzip
+                        decompressed = gzip.decompress(response.content)
+
+                        async with aiofiles.open(tile_path, 'wb') as f:
+                            await f.write(decompressed)
+
+                        print(f"Downloaded {tile_name} from {mirror}")
+                        return True
+                except Exception as e:
+                    print(f"Failed to download from {mirror}: {e}")
+                    continue
+
+        print(f"Failed to download tile {tile_name}")
+        return False
+
+    async def load_tile(self, tile_name: str) -> Optional[np.ndarray]:
+        """Load tile into memory (with caching)"""
+        # Check memory cache
+        if tile_name in self._tile_cache:
+            return self._tile_cache[tile_name]
+
+        tile_path = self.get_tile_path(tile_name)
+
+        # Download if missing
+        if not tile_path.exists():
+            success = await self.download_tile(tile_name)
+            if not success:
+                return None
+
+        # Read HGT file (big-endian signed 16-bit integers)
+        try:
+            async with aiofiles.open(tile_path, 'rb') as f:
+                data = await f.read()
+
+            # Parse as numpy array
+            arr = np.frombuffer(data, dtype='>i2').reshape(self.TILE_SIZE, self.TILE_SIZE)
+
+            # Manage cache size
+            if len(self._tile_cache) >= self._max_cached_tiles:
+                # Remove oldest entry
+                oldest = next(iter(self._tile_cache))
+                del self._tile_cache[oldest]
+
+            self._tile_cache[tile_name] = arr
+            return arr
+
+        except Exception as e:
+            print(f"Error loading tile {tile_name}: {e}")
+            return None
+
+    async def get_elevation(self, lat: float, lon: float) -> float:
+        """Get elevation at specific coordinate (meters above sea level)"""
+        tile_name = self.get_tile_name(lat, lon)
+        tile = await self.load_tile(tile_name)
+
+        if tile is None:
+            return 0.0  # No data, assume sea level
+
+        # Calculate position within tile
+        lat_int = int(lat) if lat >= 0 else int(lat) - 1
+        lon_int = int(lon) if lon >= 0 else int(lon) - 1
+
+        lat_frac = lat - lat_int
+        lon_frac = lon - lon_int
+
+        # Row 0 = north edge, row 3600 = south edge
+        row = int((1 - lat_frac) * (self.TILE_SIZE - 1))
+        col = int(lon_frac * (self.TILE_SIZE - 1))
+
+        # Clamp to valid range
+        row = max(0, min(row, self.TILE_SIZE - 1))
+        col = max(0, min(col, self.TILE_SIZE - 1))
+
+        elevation = tile[row, col]
+
+        # -32768 = void/no data
+        if elevation == -32768:
+            return 0.0
+
+        return float(elevation)
+
+    async def get_elevation_profile(
+        self,
+        lat1: float, lon1: float,
+        lat2: float, lon2: float,
+        num_points: int = 100
+    ) -> List[dict]:
+        """
+        Get elevation profile between two points
+
+        Returns list of {lat, lon, elevation, distance} dicts
+        """
+        lats = np.linspace(lat1, lat2, num_points)
+        lons = np.linspace(lon1, lon2, num_points)
+
+        # Calculate cumulative distances
+        total_distance = self.haversine_distance(lat1, lon1, lat2, lon2)
+        distances = np.linspace(0, total_distance, num_points)
+
+        profile = []
+        for i, (lat, lon, dist) in enumerate(zip(lats, lons, distances)):
+            elev = await self.get_elevation(lat, lon)
+            profile.append({
+                "lat": float(lat),
+                "lon": float(lon),
+                "elevation": elev,
+                "distance": float(dist)
+            })
+
+        return profile
+
+    @staticmethod
+    def haversine_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+        """Calculate distance between two points in meters"""
+        EARTH_RADIUS = 6371000  # meters
+
+        lat1, lon1, lat2, lon2 = map(np.radians, [lat1, lon1, lat2, lon2])
+
+        dlat = lat2 - lat1
+        dlon = lon2 - lon1
+
+        a = np.sin(dlat/2)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon/2)**2
+        c = 2 * np.arcsin(np.sqrt(a))
+
+        return EARTH_RADIUS * c
+
+
+# Singleton instance
+terrain_service = TerrainService()