Update api.py

api.py

@@ -57,6 +57,8 @@ from src.live_data_fetcher import (
 # In api.py — update the imports at the top
 from datetime import datetime
 from pydantic import BaseModel
+from typing import Optional, Dict
+import math
 
 
 
@@ -261,10 +263,207 @@ def prediction_result_to_dict(result: PredictionResult) -> dict:
         "feature_memberships": result.feature_memberships,
     }
 class EvacuationRequest(BaseModel):
-    latitude:  float
-    longitude: float
-    # Optional: override features if already calculated
-    flood_features: Optional[Dict[str, float]] = None
+    latitude:       float = Field(..., ge=5.0,  le=37.0,  example=19.0760)
+    longitude:      float = Field(..., ge=68.0, le=97.0,  example=72.8777)
+    flood_features: Optional[Dict[str, float]] = Field(
+        None,
+        description="Optional — if not provided, features are auto-derived from lat/lon"
+    )
+    n_mc_samples:   int   = Field(50, ge=1, le=200)
+
+SAFE_ZONES_DB = {
+    "Mumbai": [
+        {"name": "NDRF Camp — Bandra Kurla Complex",  "lat": 19.0596, "lon": 72.8656, "capacity": 1000},
+        {"name": "Elevated Shelter — Sion",           "lat": 19.0390, "lon": 72.8619, "capacity": 800},
+        {"name": "Relief Centre — Powai",             "lat": 19.1197, "lon": 72.9058, "capacity": 600},
+        {"name": "Higher Ground — Vikhroli",          "lat": 19.1086, "lon": 72.9300, "capacity": 500},
+    ],
+    "Chennai": [
+        {"name": "Government Relief Camp — Tambaram", "lat": 12.9249, "lon": 80.1000, "capacity": 500},
+        {"name": "Flood Shelter — Anna Nagar",        "lat": 13.0850, "lon": 80.2101, "capacity": 800},
+        {"name": "NDRF Base — Sholinganallur",        "lat": 12.9010, "lon": 80.2279, "capacity": 300},
+        {"name": "Community Hall — Velachery",        "lat": 12.9815, "lon": 80.2180, "capacity": 400},
+        {"name": "Higher Ground — Guindy",            "lat": 13.0067, "lon": 80.2206, "capacity": 600},
+    ],
+    "Kolkata": [
+        {"name": "Relief Camp — Salt Lake",           "lat": 22.5800, "lon": 88.4100, "capacity": 700},
+        {"name": "Elevated Shelter — Ballygunge",     "lat": 22.5262, "lon": 88.3639, "capacity": 500},
+        {"name": "NDRF Base — Ultadanga",             "lat": 22.5900, "lon": 88.3900, "capacity": 600},
+    ],
+    "Delhi": [
+        {"name": "Relief Camp — Pragati Maidan",      "lat": 28.6187, "lon": 77.2410, "capacity": 2000},
+        {"name": "Flood Shelter — Yamuna Sports Complex","lat": 28.6448, "lon": 77.2637, "capacity": 1000},
+        {"name": "Higher Ground — Saket",             "lat": 28.5244, "lon": 77.2066, "capacity": 800},
+    ],
+    "Hyderabad": [
+        {"name": "Relief Camp — Hitec City",          "lat": 17.4435, "lon": 78.3772, "capacity": 600},
+        {"name": "Shelter — Secunderabad",            "lat": 17.4399, "lon": 78.4983, "capacity": 500},
+        {"name": "Higher Ground — Banjara Hills",     "lat": 17.4156, "lon": 78.4347, "capacity": 400},
+    ],
+    "Bangalore": [
+        {"name": "Relief Camp — Whitefield",          "lat": 12.9698, "lon": 77.7500, "capacity": 600},
+        {"name": "Shelter — Koramangala",             "lat": 12.9279, "lon": 77.6271, "capacity": 500},
+        {"name": "NDRF Base — Hebbal",                "lat": 13.0350, "lon": 77.5970, "capacity": 400},
+    ],
+    "Bhubaneswar": [
+        {"name": "Cyclone Shelter — Chandrasekharpur","lat": 20.3200, "lon": 85.8100, "capacity": 800},
+        {"name": "Relief Camp — Patia",               "lat": 20.3500, "lon": 85.8200, "capacity": 600},
+        {"name": "Higher Ground — Nayapalli",         "lat": 20.2800, "lon": 85.8100, "capacity": 500},
+    ],
+    "Patna": [
+        {"name": "Flood Relief Camp — Gandhi Maidan", "lat": 25.6069, "lon": 85.1348, "capacity": 1500},
+        {"name": "Elevated Shelter — Kankarbagh",     "lat": 25.5900, "lon": 85.1500, "capacity": 700},
+        {"name": "NDRF Base — Danapur",               "lat": 25.6200, "lon": 85.0500, "capacity": 500},
+    ],
+    "Guwahati": [
+        {"name": "Flood Shelter — Dispur",            "lat": 26.1433, "lon": 91.7898, "capacity": 600},
+        {"name": "Relief Camp — Jalukbari",           "lat": 26.1600, "lon": 91.6900, "capacity": 500},
+        {"name": "Higher Ground — Bhangagarh",        "lat": 26.1800, "lon": 91.7500, "capacity": 400},
+    ],
+    "Kochi": [
+        {"name": "Relief Camp — Kakkanad",            "lat": 10.0159, "lon": 76.3419, "capacity": 700},
+        {"name": "Flood Shelter — Aluva",             "lat": 10.1004, "lon": 76.3570, "capacity": 600},
+        {"name": "Higher Ground — Edapally",          "lat": 10.0261, "lon": 76.3083, "capacity": 500},
+    ],
+}
+
+def _haversine(la1: float, lo1: float, la2: float, lo2: float) -> float:
+    R = 6371
+    dlat = math.radians(la2 - la1)
+    dlon = math.radians(lo2 - lo1)
+    a = (math.sin(dlat / 2) ** 2 +
+         math.cos(math.radians(la1)) * math.cos(math.radians(la2)) *
+         math.sin(dlon / 2) ** 2)
+    return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+
+def _nearest_city(lat: float, lon: float) -> str:
+    """Find which monitored city is closest to the given coordinates."""
+    CITY_COORDS = {
+        "Mumbai":      (19.0760,  72.8777),
+        "Chennai":     (13.0827,  80.2707),
+        "Kolkata":     (22.5726,  88.3639),
+        "Delhi":       (28.6139,  77.2090),
+        "Hyderabad":   (17.3850,  78.4867),
+        "Bangalore":   (12.9716,  77.5946),
+        "Bhubaneswar": (20.2961,  85.8245),
+        "Patna":       (25.5941,  85.1376),
+        "Guwahati":    (26.1445,  91.7362),
+        "Kochi":       ( 9.9312,  76.2673),
+    }
+    return min(CITY_COORDS, key=lambda c: _haversine(lat, lon, *CITY_COORDS[c]))
+
+
+def get_rainfall_for_location(lat: float, lon: float) -> float:
+    """
+    Get live rainfall for the nearest monitored city.
+    Falls back to 0.0 if IMD APIs are unavailable.
+    """
+    city = _nearest_city(lat, lon)
+    station_id = {
+        "Mumbai": "42941", "Chennai": "43279", "Kolkata": "42809",
+        "Delhi": "42182", "Hyderabad": "43128", "Bangalore": "43295",
+        "Bhubaneswar": "42971", "Patna": "42492",
+        "Guwahati": "42410", "Kochi": "43371",
+    }.get(city, "42182")
+
+    obs = flood_fetcher.fetch_city_rainfall(city, station_id)
+    return float(obs.get("rainfall_mm") or 0.0)
+
+
+def get_elevation_for_location(lat: float, lon: float) -> float:
+    """
+    Return elevation for nearest city from static dataset.
+    """
+    CITY_ELEVATION = {
+        "Mumbai": 11, "Chennai": 6, "Kolkata": 9, "Delhi": 216,
+        "Hyderabad": 542, "Bangalore": 920, "Bhubaneswar": 45,
+        "Patna": 53, "Guwahati": 55, "Kochi": 3,
+    }
+    city = _nearest_city(lat, lon)
+    return float(CITY_ELEVATION.get(city, 50))
+
+
+def get_static_features_for_location(lat: float, lon: float) -> dict:
+    """
+    Return all static flood features for the nearest monitored city.
+    """
+    CITY_STATIC = {
+        "Mumbai":      {"elevation_m": 11,  "drainage_capacity_index": 0.35,
+                        "flow_accumulation": 0.70, "twi": 12.0, "dist_river": 0.8},
+        "Chennai":     {"elevation_m": 6,   "drainage_capacity_index": 0.40,
+                        "flow_accumulation": 0.65, "twi": 11.5, "dist_river": 1.2},
+        "Kolkata":     {"elevation_m": 9,   "drainage_capacity_index": 0.30,
+                        "flow_accumulation": 0.75, "twi": 13.0, "dist_river": 0.5},
+        "Delhi":       {"elevation_m": 216, "drainage_capacity_index": 0.50,
+                        "flow_accumulation": 0.45, "twi":  8.5, "dist_river": 2.0},
+        "Hyderabad":   {"elevation_m": 542, "drainage_capacity_index": 0.55,
+                        "flow_accumulation": 0.35, "twi":  7.0, "dist_river": 3.5},
+        "Bangalore":   {"elevation_m": 920, "drainage_capacity_index": 0.60,
+                        "flow_accumulation": 0.30, "twi":  6.5, "dist_river": 4.0},
+        "Bhubaneswar": {"elevation_m": 45,  "drainage_capacity_index": 0.38,
+                        "flow_accumulation": 0.60, "twi": 10.5, "dist_river": 1.5},
+        "Patna":       {"elevation_m": 53,  "drainage_capacity_index": 0.28,
+                        "flow_accumulation": 0.80, "twi": 14.0, "dist_river": 0.4},
+        "Guwahati":    {"elevation_m": 55,  "drainage_capacity_index": 0.32,
+                        "flow_accumulation": 0.72, "twi": 13.5, "dist_river": 0.6},
+        "Kochi":       {"elevation_m": 3,   "drainage_capacity_index": 0.33,
+                        "flow_accumulation": 0.78, "twi": 14.5, "dist_river": 0.3},
+    }
+    city = _nearest_city(lat, lon)
+    return CITY_STATIC.get(city, {
+        "elevation_m": 50, "drainage_capacity_index": 0.5,
+        "flow_accumulation": 0.5, "twi": 8.0, "dist_river": 2.0,
+    })
+
+
+def get_nearest_safe_zones(lat: float, lon: float) -> list:
+    """Return safe zones sorted by distance, pulling from nearest city's list."""
+    city = _nearest_city(lat, lon)
+    zones = SAFE_ZONES_DB.get(city, SAFE_ZONES_DB["Chennai"])
+
+    result = []
+    for zone in zones:
+        z = dict(zone)
+        z["distance_km"] = round(_haversine(lat, lon, z["lat"], z["lon"]), 2)
+        result.append(z)
+
+    return sorted(result, key=lambda z: z["distance_km"])
+
+
+def dijkstra_route(start_lat, start_lon, end_lat, end_lon) -> dict:
+    """
+    Simplified Dijkstra — generates a stepped waypoint path between
+    start and end with intermediate safe waypoints avoiding low ground.
+    Real implementation would use OSMnx road graph.
+    """
+    distance_km = _haversine(start_lat, start_lon, end_lat, end_lon)
+    eta_minutes = round((distance_km / 30) * 60)  # 30 km/h for emergency
+
+    # Generate intermediate waypoints (linear interpolation)
+    steps = max(2, min(5, int(distance_km / 2)))
+    waypoints = []
+    for i in range(steps + 1):
+        t = i / steps
+        wlat = start_lat + t * (end_lat - start_lat)
+        wlon = start_lon + t * (end_lon - start_lon)
+        waypoints.append([round(wlat, 5), round(wlon, 5)])
+
+    return {
+        "algorithm":    "Dijkstra Shortest Path",
+        "start":        {"lat": start_lat, "lon": start_lon},
+        "end":          {"lat": end_lat,   "lon": end_lon},
+        "distance_km":  round(distance_km, 2),
+        "eta_minutes":  eta_minutes,
+        "waypoints":    waypoints,
+        "instructions": [
+            f"Proceed towards safe zone ({distance_km:.1f} km away)",
+            "Avoid low-lying roads, underpasses, and near-river routes",
+            "Follow elevated roads and flyovers where possible",
+            f"Estimated travel time: {eta_minutes} minutes at emergency speed",
+            "Arrive at designated safe zone and register with authorities",
+        ]
+    }
 
 
 # ============================================================================
@@ -869,129 +1068,96 @@ def flood_map_from_geojson(req: GeoJSONMapRequest):
 
 
 @app.post("/evacuate/route")
-async def get_evacuation_route(req: EvacuationRequest):
+def get_evacuation_route(req: EvacuationRequest):
     """
-    1. Takes user lat/lon
-    2. Reuses flood_predictor internally
-    3. If risk >= 70, calculates evacuation route
-    4. Returns route + safe zones
+    1. Takes user lat/lon from frontend
+    2. Auto-derives flood features from nearest city (or uses provided ones)
+    3. Runs FNN flood predictor
+    4. If risk >= HIGH, computes evacuation route to nearest safe zone
+    5. Returns route + safe zones as GeoJSON-friendly response
     """
+    if not flood_predictor.is_ready():
+        raise HTTPException(503, "Flood model not loaded.")
 
-    # Step 1: Build flood features from lat/lon
-    # Use features from request or build from datasets
-    features = req.flood_features or {
-        "rainfall_mm":             get_rainfall_for_location(req.latitude, req.longitude),
-        "elevation_m":             get_elevation_for_location(req.latitude, req.longitude),
-        "soil_saturation_pct":     75.0,
-        "dist_river":              1.2,
-        "drainage_capacity_index": 0.4,
-        "flow_accumulation":       0.6,
-        "twi":                     8.5,
-    }
+    # ── Step 1: Build flood features ──────────────────────────────────────
+    nearest_city = _nearest_city(req.latitude, req.longitude)
+
+    if req.flood_features:
+        features     = req.flood_features
+        data_source  = "user-provided"
+    else:
+        static       = get_static_features_for_location(req.latitude, req.longitude)
+        rainfall_mm  = get_rainfall_for_location(req.latitude, req.longitude)
+        soil_sat     = float(flood_fetcher.estimate_soil_saturation(rainfall_mm))
+        features = {
+            "rainfall_mm":             rainfall_mm,
+            "elevation_m":             static["elevation_m"],
+            "soil_saturation_pct":     soil_sat,
+            "dist_river":              static["dist_river"],
+            "drainage_capacity_index": static["drainage_capacity_index"],
+            "flow_accumulation":       static["flow_accumulation"],
+            "twi":                     static["twi"],
+        }
+        data_source = "IMD live + static city dataset"
 
-    # Step 2: Reuse existing flood_predictor (same instance!)
+    # ── Step 2: Validate + predict ────────────────────────────────────────
     errors = flood_predictor.validate_input(features)
     if errors:
         raise HTTPException(422, {"validation_errors": errors})
 
-    result = flood_predictor.predict(features, n_mc_samples=50)
+    result     = flood_predictor.predict(features, n_mc_samples=req.n_mc_samples)
     risk_score = result.risk_score
     risk_tier  = result.risk_tier.value
 
-    # Step 3: Find nearest safe zones
+    # ── Step 3: Safe zones for this location ──────────────────────────────
     safe_zones = get_nearest_safe_zones(req.latitude, req.longitude)
 
-    # Step 4: Only generate route if risk is HIGH
+    # ── Step 4: No evacuation needed ──────────────────────────────────────
     if risk_score < 0.45:
         return {
-            "latitude":     req.latitude,
-            "longitude":    req.longitude,
-            "risk_score":   risk_score,
-            "risk_tier":    risk_tier,
+            "latitude":          req.latitude,
+            "longitude":         req.longitude,
+            "nearest_city":      nearest_city,
+            "risk_score":        round(risk_score, 4),
+            "risk_tier":         risk_tier,
+            "uncertainty":       round(result.uncertainty, 4),
             "evacuation_needed": False,
-            "message":      "No evacuation needed — risk is LOW",
-            "safe_zones":   safe_zones,
-            "route":        None
+            "message":           f"No evacuation needed — risk is {risk_tier}",
+            "flood_features":    features,
+            "data_source":       data_source,
+            "safe_zones":        safe_zones,
+            "route":             None,
+            "timestamp":         datetime.now().isoformat(),
         }
 
-    # Step 5: Run Dijkstra to nearest safe zone
+    # ── Step 5: Compute evacuation route to nearest safe zone ─────────────
     nearest_zone = safe_zones[0]
     route = dijkstra_route(
         start_lat=req.latitude,
         start_lon=req.longitude,
         end_lat=nearest_zone["lat"],
-        end_lon=nearest_zone["lon"]
+        end_lon=nearest_zone["lon"],
     )
 
     return {
         "latitude":          req.latitude,
         "longitude":         req.longitude,
-        "risk_score":        risk_score,
+        "nearest_city":      nearest_city,
+        "risk_score":        round(risk_score, 4),
         "risk_tier":         risk_tier,
-        "uncertainty":       result.uncertainty,
+        "uncertainty":       round(result.uncertainty, 4),
+        "confidence_interval": [
+            round(result.confidence_interval[0], 4),
+            round(result.confidence_interval[1], 4),
+        ],
         "evacuation_needed": True,
+        "message":           f"EVACUATE — {risk_tier} flood risk detected near {nearest_city}",
+        "flood_features":    features,
+        "data_source":       data_source,
         "nearest_safe_zone": nearest_zone,
         "all_safe_zones":    safe_zones,
         "route":             route,
-        "timestamp":         datetime.now().isoformat()
-    }
-
-
-# ── Helper: Safe zones near India ─────────────────────────────────────────
-def get_nearest_safe_zones(lat: float, lon: float) -> list:
-    import math
-
-    safe_zones = [
-        {"name": "Government Relief Camp — Tambaram",  "lat": 12.9249, "lon": 80.1000, "capacity": 500},
-        {"name": "Flood Shelter — Anna Nagar",         "lat": 13.0850, "lon": 80.2101, "capacity": 800},
-        {"name": "NDRF Base — Sholinganallur",         "lat": 12.9010, "lon": 80.2279, "capacity": 300},
-        {"name": "Community Hall — Velachery",         "lat": 12.9815, "lon": 80.2180, "capacity": 400},
-        {"name": "Higher Ground — Guindy",             "lat": 13.0067, "lon": 80.2206, "capacity": 600},
-    ]
-
-    def haversine(la1, lo1, la2, lo2):
-        R = 6371
-        dlat = math.radians(la2 - la1)
-        dlon = math.radians(lo2 - lo1)
-        a = math.sin(dlat/2)*2 + math.cos(math.radians(la1)) * math.cos(math.radians(la2)) * math.sin(dlon/2)*2
-        return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
-
-    for zone in safe_zones:
-        zone["distance_km"] = round(haversine(lat, lon, zone["lat"], zone["lon"]), 2)
-
-    return sorted(safe_zones, key=lambda z: z["distance_km"])
-
-
-# ── Helper: Simple Dijkstra ────────────────────────────────────────────────
-def dijkstra_route(start_lat, start_lon, end_lat, end_lon) -> dict:
-    import math
-
-    def haversine(la1, lo1, la2, lo2):
-        R = 6371
-        dlat = math.radians(la2 - la1)
-        dlon = math.radians(lo2 - lo1)
-        a = math.sin(dlat/2)*2 + math.cos(math.radians(la1)) * math.cos(math.radians(la2)) * math.sin(dlon/2)*2
-        return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
-
-    distance_km = haversine(start_lat, start_lon, end_lat, end_lon)
-    eta_minutes = round((distance_km / 40) * 60)  # assume 40 km/h
-
-    return {
-        "algorithm":    "Dijkstra Shortest Path",
-        "start":        {"lat": start_lat, "lon": start_lon},
-        "end":          {"lat": end_lat,   "lon": end_lon},
-        "distance_km":  round(distance_km, 2),
-        "eta_minutes":  eta_minutes,
-        "waypoints": [
-            [start_lat, start_lon],
-            [end_lat,   end_lon]
-        ],
-        "instructions": [
-            f"Head towards safe zone ({distance_km:.1f} km away)",
-            "Avoid low-lying roads and underpasses",
-            "Follow elevated roads",
-            "Arrive at safe zone"
-        ]
+        "timestamp":         datetime.now().isoformat(),
     }
 
 # ============================================================================