fix: detect signals against route edge segments, not just nodes

backend/signal/signal_model.py

@@ -71,7 +71,6 @@ EXPECTED IMPROVEMENT
 import json
 import os
 import math
-import pickle
 import logging
 import osmnx as ox
 
@@ -97,7 +96,7 @@ class SignalModel:
         graph,
         registry_file="data/signals_registry.json",
         cluster_radius=90,
-        detection_radius=80,
+        detection_radius=150,
         avg_wait_per_signal=75,
         stop_probability=0.85,
     ):
@@ -109,10 +108,6 @@ class SignalModel:
         self.stop_prob        = stop_probability
         self.junctions        = []
 
-        # Cache file lives next to the registry JSON
-        base = os.path.splitext(registry_file)[0]
-        self._cache_file = base + "_clustered.pkl"
-
         self._load_and_cluster_signals()
 
     # ── Load + Snap + Cluster ─────────────────────────────────────────────────
@@ -173,6 +168,26 @@ class SignalModel:
 
     # ── Route Analysis ────────────────────────────────────────────────────────
 
+    @staticmethod
+    def _point_to_segment_dist(plat, plng, alat, alng, blat, blng):
+        """Perpendicular distance from point P to segment A→B in metres."""
+        ax = (alng - plng) * _LAT_TO_M * math.cos(plat * math.pi / 180)
+        ay = (alat - plat) * _LAT_TO_M
+        bx = (blng - plng) * _LAT_TO_M * math.cos(plat * math.pi / 180)
+        by = (blat - plat) * _LAT_TO_M
+
+        ab_sq = ax*ax + ay*ay + bx*bx + by*by  # rough check
+        dx, dy = bx - ax, by - ay
+        seg_len_sq = dx*dx + dy*dy
+
+        if seg_len_sq == 0:
+            return math.sqrt(ax*ax + ay*ay)
+
+        t = max(0.0, min(1.0, ((-ax)*dx + (-ay)*dy) / seg_len_sq))
+        cx = ax + t*dx
+        cy = ay + t*dy
+        return math.sqrt(cx*cx + cy*cy)
+
     def analyze_route(self, route):
         signal_count = 0
 
@@ -185,15 +200,24 @@ class SignalModel:
         for junction in self.junctions:
             j_lat = junction["lat"]
             j_lng = junction["lng"]
+            detected = False
+
+            # Check each edge segment of the route, not just nodes
+            # Fixes sparse-node highways where no single node is within radius
+            for i in range(len(route_coords) - 1):
+                alat, alng = route_coords[i]
+                blat, blng = route_coords[i + 1]
 
-            for (node_lat, node_lng) in route_coords:
-                # Early exit on latitude diff before computing full distance
-                if abs(node_lat - j_lat) * _LAT_TO_M > self.detection_radius:
+                # Quick bbox reject
+                if (min(alat, blat) - j_lat) * _LAT_TO_M > self.detection_radius:
+                    continue
+                if (j_lat - max(alat, blat)) * _LAT_TO_M > self.detection_radius:
                     continue
 
-                dist = _fast_dist_m(node_lat, node_lng, j_lat, j_lng)
+                dist = self._point_to_segment_dist(j_lat, j_lng, alat, alng, blat, blng)
                 if dist <= self.detection_radius:
                     signal_count += 1
+                    detected = True
                     break
 
         expected_stops = signal_count * self.stop_prob
@@ -208,11 +232,27 @@ class SignalModel:
     # ── Attach Signal Weights to Graph ────────────────────────────────────────
 
     def attach_signal_weights(self):
-        # Snap each junction centroid to the nearest graph node
+        # Mark ALL nodes within detection_radius of each junction centroid.
+        # A single dot in the registry may represent a 4-way junction —
+        # all roads passing through that junction must carry the signal weight,
+        # not just the one road the dot happens to snap to.
         node_to_junction = {}
+        all_node_coords = [
+            (n, self.G.nodes[n]["y"], self.G.nodes[n]["x"])
+            for n in self.G.nodes
+        ]
+
         for jid, junction in enumerate(self.junctions):
-            node = ox.distance.nearest_nodes(self.G, junction["lng"], junction["lat"])
-            node_to_junction[node] = jid
+            jlat, jlng = junction["lat"], junction["lng"]
+            for node, nlat, nlng in all_node_coords:
+                if abs(nlat - jlat) * _LAT_TO_M > self.detection_radius:
+                    continue
+                if _fast_dist_m(jlat, jlng, nlat, nlng) <= self.detection_radius:
+                    # If node already tagged by a closer junction, keep that one
+                    if node not in node_to_junction:
+                        node_to_junction[node] = jid
+
+        logger.info(f"[SignalModel] Nodes tagged with signal: {len(node_to_junction)}")
 
         expected_delay_min = self.stop_prob * (self.avg_wait / 60.0)