Fixing random turns

backend/api/routes.py

@@ -11,14 +11,40 @@ DISTANCE_BUDGET_FACTOR_POLLUTION  = 1.8
 DISTANCE_BUDGET_FACTOR_OVERALL    = 1.5
 
 
-def route_to_geojson(G, route):
+def _edge_geometry_coords(edge, u_node, v_node, G):
+    """
+    Return (lon, lat) coordinate list for an edge, using intermediate
+    geometry points where available.
+
+    osmnx stores geometry as either:
+      - A Shapely LineString (when built/pickled from fresh download)
+      - A WKT string like "LINESTRING(...)" (when loaded from graphml)
+    Both are handled here. Falls back to straight node→node if missing.
     """
-    Build GeoJSON coordinates from the route node list.
+    geom = edge.get("geometry")
+    if geom is None:
+        return [
+            [G.nodes[u_node]["x"], G.nodes[u_node]["y"]],
+            [G.nodes[v_node]["x"], G.nodes[v_node]["y"]],
+        ]
+    try:
+        # Shapely LineString
+        if hasattr(geom, "coords"):
+            return [[lon, lat] for lon, lat in geom.coords]
+        # WKT string — parse it
+        from shapely.wkt import loads as wkt_loads
+        return [[lon, lat] for lon, lat in wkt_loads(str(geom)).coords]
+    except Exception:
+        return [
+            [G.nodes[u_node]["x"], G.nodes[u_node]["y"]],
+            [G.nodes[v_node]["x"], G.nodes[v_node]["y"]],
+        ]
+
 
-    For each edge, use the OSM edge geometry (intermediate curve points)
-    if available — otherwise fall back to straight start→end node coords.
-    This prevents phantom turns caused by straight-line interpolation
-    between widely-spaced nodes on curved roads.
+def route_to_geojson(G, route):
+    """
+    Build GeoJSON coordinates from the route node list using full edge
+    geometry (intermediate curve points), preventing phantom turns.
     """
     if len(route) == 0:
         coordinates = []
@@ -26,20 +52,16 @@ def route_to_geojson(G, route):
         n = route[0]
         coordinates = [[G.nodes[n]["x"], G.nodes[n]["y"]]]
     else:
-        coordinates = [[G.nodes[route[0]]["x"], G.nodes[route[0]]["y"]]]
+        coordinates = []
         for i in range(len(route) - 1):
             u, v = route[i], route[i + 1]
             edge = list(G[u][v].values())[0]
-            geom = edge.get("geometry")
-            if geom is not None:
-                # geom is a Shapely LineString — coords are (lon, lat)
-                # Skip the first point (already added as previous node)
-                pts = list(geom.coords)
-                for lon, lat in pts[1:]:
-                    coordinates.append([lon, lat])
+            pts = _edge_geometry_coords(edge, u, v, G)
+            if i == 0:
+                coordinates.extend(pts)
             else:
-                # No intermediate geometry — just add the end node
-                coordinates.append([G.nodes[v]["x"], G.nodes[v]["y"]])
+                # Skip first point — already added as last point of prev edge
+                coordinates.extend(pts[1:])
 
     return {
         "type": "Feature",

backend/routing/routing_engine.py

@@ -231,6 +231,12 @@ def weighted_directional_route(
 
     pq = []
 
+    # ── Node-level guard: once a node is settled as 'current', never
+    #    expand it again. This prevents the route from looping back
+    #    through the same intersection via a different predecessor,
+    #    which causes T-detours and U-shaped routes. ──────────────────────────
+    settled_nodes = set()
+
     def edge_cost(edge, prev_node=None, curr_node=None, next_node=None):
         # If this edge leads into a signalled junction but the maneuver
         # is a free left turn, don't apply the signal delay cost
@@ -266,10 +272,15 @@ def weighted_directional_route(
 
         state = (prev, current)
 
+        # Skip if this node has already been settled (prevents backtracking)
+        if current in settled_nodes:
+            continue
+
         # Skip if we already found a cheaper way to this (prev, curr)
         if state in visited and visited[state] <= cost:
             continue
         visited[state] = cost
+        settled_nodes.add(current)
 
         # ── Reached destination — reconstruct path ────────────────────────
         if current == dest: