added A*, the SHAP and AADT features

Siriapps · Siriapps · commit c31370dc878b · 2026-03-29T14:38:09.000-05:00
diff --git a/backend/astar_route.py b/backend/astar_route.py
@@ -0,0 +1,76 @@
+"""
+SafeWay A* safer route computation.
+Separated from main.py so the logic is self-contained and testable.
+"""
+from __future__ import annotations
+import sys
+from pathlib import Path
+
+# Ensure the backend directory is on sys.path for sibling imports
+_backend_dir = str(Path(__file__).resolve().parent)
+if _backend_dir not in sys.path:
+    sys.path.insert(0, _backend_dir)
+
+
+def compute_astar_route(
+    origin_lat: float,
+    origin_lng: float,
+    dest_lat: float,
+    dest_lng: float,
+    departure_hour: int | None = None,
+) -> dict | None:
+    """
+    Compute a safety-optimized A* route between two lat/lng points.
+
+    Returns a route dict with the same shape as Google route entries, or None
+    if the route cannot be computed (e.g. graph not loaded, same origin/dest).
+    """
+    try:
+        import osmnx as ox
+        from risk_cache import get_prepared_graph, score_coordinates
+        from model.route_scoring import (
+            find_safer_route,
+            path_to_coordinates,
+            encode_polyline,
+            estimate_route_aadt,
+        )
+
+        G = get_prepared_graph()
+        orig_node = ox.distance.nearest_nodes(G, X=origin_lng, Y=origin_lat)
+        dest_node = ox.distance.nearest_nodes(G, X=dest_lng, Y=dest_lat)
+        if orig_node == dest_node:
+            return None
+
+        astar = find_safer_route(G, orig_node, dest_node, beta=0.5)
+        safe_coords = path_to_coordinates(G, astar["safe_path"])
+        if len(safe_coords) < 2:
+            return None
+
+        safe_polyline = encode_polyline(safe_coords)
+        safety = score_coordinates(safe_coords, sample_every=3, departure_hour=departure_hour)
+        aadt = estimate_route_aadt(G, astar["safe_path"])
+
+        return {
+            "distance_meters": astar["safe_distance_m"],
+            "duration": f"{astar['safe_time_secs']}s",
+            "polyline": safe_polyline,
+            "coordinates": safe_coords,
+            "safety_score": safety.get("score"),
+            "safety_label": safety.get("label", "unknown"),
+            "route_source": "safeway",
+            "risk_per_km": safety.get("risk_per_km"),
+            "total_exposure": safety.get("total_exposure"),
+            "route_km": safety.get("route_km"),
+            "n_high_risk": safety.get("n_high_risk", 0),
+            "top_risk_factors": safety.get("top_risk_factors", []),
+            "time_band": safety.get("time_band"),
+            "segment_risks": safety.get("segment_risks", []),
+            "high_risk_coords": safety.get("high_risk_coords", []),
+            "aadt_avg": aadt.get("aadt_avg"),
+            "aadt_max": aadt.get("aadt_max"),
+            "time_penalty_pct": astar["time_penalty_pct"],
+            "risk_reduction_pct": astar["risk_reduction_pct"],
+        }
+    except Exception as e:
+        print(f"[astar] route computation failed: {e}", flush=True)
+        return None
diff --git a/backend/main.py b/backend/main.py
@@ -442,6 +442,9 @@ def compute_route(payload: RouteRequest):
                     "top_risk_factors": safety.get("top_risk_factors", []),
                     "time_band": safety.get("time_band"),
                     "segment_risks": safety.get("segment_risks", []),
+                    "high_risk_coords": safety.get("high_risk_coords", []),
+                    "aadt_avg": safety.get("aadt_avg"),
+                    "aadt_max": safety.get("aadt_max"),
                 }
             except Exception as score_err:
                 print(f"[route] score_coordinates failed for route: {score_err}", flush=True)
@@ -470,9 +473,15 @@ def compute_route(payload: RouteRequest):
                 "route_source": "google",
             })
 
-    # ── SafeWay A* safer route — temporarily disabled ──────────────────
-    # TODO: re-enable once Google routes + scoring are confirmed working
-    pass
+    # ── SafeWay A* safer route ──────────────────────────────────────────
+    from astar_route import compute_astar_route
+    astar_result = compute_astar_route(
+        payload.origin.lat, payload.origin.lng,
+        payload.destination.lat, payload.destination.lng,
+        departure_hour=payload.departure_hour,
+    )
+    if astar_result:
+        result_routes.append(astar_result)
 
     # Sort: SafeWay route first, then by safety score ascending (safest first)
     result_routes.sort(key=lambda r: (
diff --git a/backend/risk_cache.py b/backend/risk_cache.py
@@ -394,6 +394,38 @@ def score_coordinates(
             "risk": round(seg_risk, 1),
         })
 
+    # Coordinates of high-risk nodes for ⚠️ map markers
+    high_risk_coords = []
+    for nid, r in zip(nearest, risks):
+        if r > 66:
+            try:
+                high_risk_coords.append({
+                    "latitude": G.nodes[nid]["y"],
+                    "longitude": G.nodes[nid]["x"],
+                })
+            except Exception:
+                pass
+
+    # AADT estimate from edge highway types at sampled nodes
+    _ROAD_CLASS = {
+        "residential": 1, "living_street": 1, "unclassified": 1,
+        "tertiary": 2, "tertiary_link": 2,
+        "secondary": 3, "secondary_link": 3,
+        "primary": 4, "primary_link": 4,
+        "trunk": 5, "trunk_link": 5,
+        "motorway": 6, "motorway_link": 6,
+    }
+    _AADT_PROXY = {1: 1_000, 2: 5_000, 3: 15_000, 4: 25_000, 5: 40_000, 6: 60_000}
+    aadt_values = []
+    for nid in nearest:
+        for _, _, ed in list(G.edges(nid, data=True))[:2]:
+            hw = ed.get("highway", "residential")
+            if isinstance(hw, list):
+                hw = hw[0] if hw else "residential"
+            aadt_values.append(_AADT_PROXY.get(_ROAD_CLASS.get(hw, 1), 1_000))
+    aadt_avg = round(sum(aadt_values) / len(aadt_values)) if aadt_values else None
+    aadt_max = max(aadt_values) if aadt_values else None
+
     return {
         "score": score,
         "label": label,
@@ -406,4 +438,7 @@ def score_coordinates(
         "top_risk_factors": top_risk_factors,
         "time_band": time_band,
         "segment_risks": segment_risks,
+        "high_risk_coords": high_risk_coords,
+        "aadt_avg": aadt_avg,
+        "aadt_max": aadt_max,
     }
diff --git a/frontend/app/directions.tsx b/frontend/app/directions.tsx
@@ -78,6 +78,7 @@ interface ModeRouteData {
   topRiskFactors?: { factor: string; weight: number }[] | { label: string; count: number; pct: number }[];
   timeBand?: string;
   segmentRisks?: number[];
+  highRiskCoords?: Array<{ latitude: number; longitude: number }>;
   aadtAvg?: number;
   aadtMax?: number;
   timePenaltyPct?: number;
@@ -95,6 +96,7 @@ interface ModeRoutes {
     topRiskFactors?: any[];
     timeBand?: string;
     segmentRisks?: number[];
+    highRiskCoords?: Array<{ latitude: number; longitude: number }>;
     aadtAvg?: number;
     aadtMax?: number;
     timePenaltyPct?: number;
@@ -186,6 +188,7 @@ function mapSafetyRoutesToAlternatives(safetyRoutes: SafetyRoute[]): RouteAltRow
       topRiskFactors: r.top_risk_factors,
       timeBand: r.time_band,
       segmentRisks: r.segment_risks,
+      highRiskCoords: r.high_risk_coords ?? [],
       aadtAvg: r.aadt_avg,
       aadtMax: r.aadt_max,
       timePenaltyPct: r.time_penalty_pct,
@@ -211,6 +214,7 @@ function primaryToAlternativeRow(primary: ModeRouteData, index = 0): RouteAltRow
     topRiskFactors: primary.topRiskFactors,
     timeBand: primary.timeBand,
     segmentRisks: primary.segmentRisks,
+    highRiskCoords: primary.highRiskCoords,
     aadtAvg: primary.aadtAvg,
     aadtMax: primary.aadtMax,
     timePenaltyPct: primary.timePenaltyPct,
@@ -429,8 +433,22 @@ function RouteDetailsModal({
                     )}
                     <Marker coordinate={{ latitude: destLat, longitude: destLng }} pinColor="#FF4444" />
                     {activeData?.coords?.length ? (
-                      <Polyline coordinates={activeData.coords} strokeColor={activeData.routeSource === 'safeway' ? '#1ABC93' : '#4A90E2'} strokeWidth={4} />
+                      (activeData.segmentRisks as any[])?.length
+                        ? (activeData.segmentRisks as any[]).map((seg: any, si: number) => (
+                            <Polyline
+                              key={`modal-seg-${si}`}
+                              coordinates={[seg.start, seg.end]}
+                              strokeColor={seg.risk > 66 ? '#FF4444' : seg.risk > 33 ? '#FFA500' : '#1ABC93'}
+                              strokeWidth={4}
+                            />
+                          ))
+                        : <Polyline coordinates={activeData.coords} strokeColor={activeData.routeSource === 'safeway' ? '#1ABC93' : '#4A90E2'} strokeWidth={4} />
                     ) : null}
+                    {(activeData?.highRiskCoords as any[] ?? []).map((coord: any, i: number) => (
+                      <Marker key={`modal-hs-${i}`} coordinate={coord} anchor={{ x: 0.5, y: 1.0 }} tracksViewChanges={false}>
+                        <Text style={{ fontSize: 14 }}>⚠️</Text>
+                      </Marker>
+                    ))}
                   </MapView>
                   {activeData && (
                     <View style={dm.routeTimeBubble}>
@@ -782,7 +800,7 @@ export default function DirectionsScreen() {
             safetyScore: primary.safetyScore, safetyLabel: primary.safetyLabel, routeSource: primary.routeSource,
             riskPerKm: primary.riskPerKm, nHighRisk: primary.nHighRisk, routeKm: primary.routeKm,
             topRiskFactors: primary.topRiskFactors, timeBand: primary.timeBand,
-            segmentRisks: primary.segmentRisks, aadtAvg: primary.aadtAvg, aadtMax: primary.aadtMax,
+            segmentRisks: primary.segmentRisks, highRiskCoords: primary.highRiskCoords, aadtAvg: primary.aadtAvg, aadtMax: primary.aadtMax,
             timePenaltyPct: primary.timePenaltyPct, riskReductionPct: primary.riskReductionPct,
           },
           alternatives: alts,
@@ -819,7 +837,7 @@ export default function DirectionsScreen() {
             safetyScore: primary.safetyScore, safetyLabel: primary.safetyLabel, routeSource: primary.routeSource,
             riskPerKm: primary.riskPerKm, nHighRisk: primary.nHighRisk, routeKm: primary.routeKm,
             topRiskFactors: primary.topRiskFactors, timeBand: primary.timeBand,
-            segmentRisks: primary.segmentRisks, aadtAvg: primary.aadtAvg, aadtMax: primary.aadtMax,
+            segmentRisks: primary.segmentRisks, highRiskCoords: primary.highRiskCoords, aadtAvg: primary.aadtAvg, aadtMax: primary.aadtMax,
             timePenaltyPct: primary.timePenaltyPct, riskReductionPct: primary.riskReductionPct,
           },
           alternatives: alts,
@@ -842,7 +860,7 @@ export default function DirectionsScreen() {
             safetyScore: primary.safetyScore, safetyLabel: primary.safetyLabel, routeSource: primary.routeSource,
             riskPerKm: primary.riskPerKm, nHighRisk: primary.nHighRisk, routeKm: primary.routeKm,
             topRiskFactors: primary.topRiskFactors, timeBand: primary.timeBand,
-            segmentRisks: primary.segmentRisks, aadtAvg: primary.aadtAvg, aadtMax: primary.aadtMax,
+            segmentRisks: primary.segmentRisks, highRiskCoords: primary.highRiskCoords, aadtAvg: primary.aadtAvg, aadtMax: primary.aadtMax,
             timePenaltyPct: primary.timePenaltyPct, riskReductionPct: primary.riskReductionPct,
           },
           alternatives: alts,
@@ -981,7 +999,8 @@ export default function DirectionsScreen() {
         safetyScore: selectedAlt.safetyScore, safetyLabel: selectedAlt.safetyLabel, routeSource: selectedAlt.routeSource,
         riskPerKm: selectedAlt.riskPerKm, nHighRisk: selectedAlt.nHighRisk, routeKm: selectedAlt.routeKm,
         topRiskFactors: selectedAlt.topRiskFactors, timeBand: selectedAlt.timeBand,
-        segmentRisks: selectedAlt.segmentRisks, aadtAvg: selectedAlt.aadtAvg, aadtMax: selectedAlt.aadtMax,
+        segmentRisks: selectedAlt.segmentRisks, highRiskCoords: selectedAlt.highRiskCoords,
+        aadtAvg: selectedAlt.aadtAvg, aadtMax: selectedAlt.aadtMax,
         timePenaltyPct: selectedAlt.timePenaltyPct, riskReductionPct: selectedAlt.riskReductionPct,
       }
     : modeData?.primary ?? null;
@@ -1020,6 +1039,19 @@ export default function DirectionsScreen() {
         {alternatives.map((alt, i) => {
           if (!alt.coords?.length) return null;
           const isSelected = i === selectedRouteIndex;
+          const segs = alt.segmentRisks as any[] | undefined;
+          if (isSelected && segs?.length) {
+            return segs.map((seg: any, si: number) => (
+              <Polyline
+                key={`${travelMode}-alt-${i}-seg-${si}`}
+                coordinates={[seg.start, seg.end]}
+                strokeColor={seg.risk > 66 ? '#FF4444' : seg.risk > 33 ? '#FFA500' : '#1ABC93'}
+                strokeWidth={5}
+                tappable
+                onPress={() => setSelectedRouteIndex(i)}
+              />
+            ));
+          }
           return (
             <Polyline
               key={`${travelMode}-alt-${i}`}
@@ -1034,6 +1066,11 @@ export default function DirectionsScreen() {
         {alternatives.length === 0 && activeData?.coords?.length ? (
           <Polyline key={travelMode} coordinates={activeData.coords} strokeColor="#4A90E2" strokeWidth={5} />
         ) : null}
+        {(alternatives[selectedRouteIndex]?.highRiskCoords as any[] ?? []).map((coord: any, i: number) => (
+          <Marker key={`hs-${i}`} coordinate={coord} anchor={{ x: 0.5, y: 1.0 }} tracksViewChanges={false}>
+            <Text style={{ fontSize: 16 }}>⚠️</Text>
+          </Marker>
+        ))}
         {heatmapFilter !== 'off' && crashPoints.length > 0 && (
           <Heatmap points={crashPoints} opacity={0.72} radius={20}
             gradient={{ colors: ['#00E5FF', '#FFD600', '#FF1744'], startPoints: [0.1, 0.5, 1.0], colorMapSize: 256 }}
diff --git a/frontend/lib/api.ts b/frontend/lib/api.ts
@@ -225,7 +225,8 @@ export type SafetyRoute = {
   n_high_risk?: number;
   top_risk_factors?: { factor: string; weight: number }[];
   time_band?: string;
-  segment_risks?: number[];
+  segment_risks?: any[];
+  high_risk_coords?: Array<{ latitude: number; longitude: number }>;
   time_penalty_pct?: number;
   risk_reduction_pct?: number;
   aadt_avg?: number;
