Sync DemoService 778e066c9915dd0ec1a6d9a620a99adbf50c2f31

api/ai-service/app/api/v1/endpoints/route_generation.py

@@ -11,7 +11,7 @@ from fastapi import APIRouter, HTTPException, status
 from pydantic import BaseModel, Field, field_validator
 
 from app.core.config import settings
-from app.services.gpx_shape_similarity import best_gpx_shape_match
+from app.services.gpx_shape_similarity import best_gpx_shape_match, gpx_route_rank_score, route_footprint_km
 from app.services.walking_route_fallback import generate_walking_fallback
 
 router = APIRouter(prefix="/ai", tags=["ai"])
@@ -473,6 +473,7 @@ def _run_fast_road_pipeline(
             continue
         shape_quality = float(route.get("shape_quality", 0.0))
         similarity, example_index = best_gpx_shape_match(coords, examples) if examples else (0.0, None)
+        footprint_km = route_footprint_km(coords) if examples else 0.0
         route_label = selected_label or "nearby_route"
         maneuvers = maneuvers_for_route(graph, route["nodes"]) if callable(maneuvers_for_route) else []
         routes.append(
@@ -488,7 +489,9 @@ def _run_fast_road_pipeline(
                 "is_loop": bool(route.get("is_loop")),
                 "route_quality": {
                     "art_ready": generation_mode == "fast_walk_roads" and bool(selected_label),
-                    **({"gpx_similarity": similarity, "gpx_example_index": example_index} if examples else {}),
+                    **({"gpx_similarity": similarity, "gpx_example_index": example_index,
+                        "gpx_footprint_km": footprint_km,
+                        "gpx_rank_score": gpx_route_rank_score(similarity, footprint_km)} if examples else {}),
                     "target_shape": {
                         "score": shape_quality,
                         "route_coverage": shape_quality,
@@ -505,8 +508,9 @@ def _run_fast_road_pipeline(
 
     if examples:
         routes.sort(key=lambda route: (
+            -route["route_quality"]["gpx_rank_score"],
             -route["route_quality"]["gpx_similarity"],
-            abs(route["length_km"] - target_distance_km),
+            0 if auto_distance else abs(route["length_km"] - target_distance_km),
         ))
         routes = routes[:route_count]
     elif auto_distance:

api/ai-service/app/services/gpx_shape_similarity.py

@@ -5,6 +5,23 @@ from __future__ import annotations
 import math
 
 
+def route_footprint_km(coords: list[tuple[float, float]] | list[list[float]]) -> float:
+    """Balanced geographic span; a long narrow detour should not look wide."""
+    if len(coords) < 2:
+        return 0.0
+    latitudes = [point[0] for point in coords]
+    longitudes = [point[1] for point in coords]
+    center_lat = (min(latitudes) + max(latitudes)) / 2
+    width_km = (max(longitudes) - min(longitudes)) * 111.32 * math.cos(math.radians(center_lat))
+    height_km = (max(latitudes) - min(latitudes)) * 111.32
+    return math.sqrt(max(0.0, width_km * height_km))
+
+
+def gpx_route_rank_score(similarity: float, footprint_km: float) -> float:
+    """Prefer a broad drawing when GPX fit is close, without rewarding distance alone."""
+    return similarity + 0.04 * min(max(footprint_km, 0.0) / 7.0, 1.0)
+
+
 def _sample_outline(points: list[tuple[float, float]], count: int = 24) -> list[complex]:
     if len(points) < 3:
         return []

api/ai-service/app/services/walking_route_fallback.py

@@ -11,7 +11,7 @@ from typing import Any
 
 import requests
 
-from app.services.gpx_shape_similarity import best_gpx_shape_match
+from app.services.gpx_shape_similarity import best_gpx_shape_match, gpx_route_rank_score, route_footprint_km
 
 PROVIDER_URL = os.getenv("WALK_ROUTE_PROVIDER_URL", "https://valhalla1.openstreetmap.de/route")
 HEADERS = {"User-Agent": "RunTheShape/1.0 (+https://github.com/hwangtutu/Tranimal_Run)"}
@@ -116,7 +116,7 @@ def generate_walking_fallback(
             continue
         # Auto mode searches several sizes of the same GPX drawing. The
         # result's measured length, rather than a hidden default, is shown.
-        requested_size_km = (3, 5, 8, 12, 16, 20, 6, 10)[attempt] if auto_distance else target_distance_km
+        requested_size_km = (6, 10, 14, 18, 24, 30, 36, 42)[attempt] if auto_distance else target_distance_km
         scale = requested_size_km * 1000 / perimeter / 1.2
         angle = generation_angle(generation_id) + attempt * math.pi * (3 - math.sqrt(5))
         # Shorter retries also work near a coast or on a small island.
@@ -140,7 +140,7 @@ def generate_walking_fallback(
             trip = response.json().get("trip", {})
             summary = trip.get("summary", {})
             length = float(summary.get("length", 0))
-            if summary.get("has_ferry") or not math.isfinite(length) or length <= 0 or (auto_distance and not 1.5 <= length <= 20):
+            if summary.get("has_ferry") or not math.isfinite(length) or length <= 0 or (auto_distance and not 1.5 <= length <= 45):
                 continue
             coords = []
             leg_shapes = []
@@ -167,6 +167,7 @@ def generate_walking_fallback(
             # Matching any unrelated dog example could give a misleadingly
             # high score even when the placed contour was badly distorted.
             similarity, _ = best_gpx_shape_match(coords, [source_example]) if templates else (0.0, None)
+            footprint_km = route_footprint_km(coords) if templates else 0.0
             waypoint_error_m = None
             if templates and len(leg_shapes) == len(locations) - 1:
                 snapped = [leg_shapes[0][0]] + [leg[-1] for leg in leg_shapes]
@@ -181,7 +182,9 @@ def generate_walking_fallback(
                 "estimated_route":False,"results":[{"label":label,"score":0.0,"shape":0.0}],
                 "route_quality":{"art_ready":False,
                     **({"gpx_similarity":similarity,"gpx_example_index":source_example_index,
-                        "road_waypoint_error_m":waypoint_error_m} if templates else {})}})
+                        "road_waypoint_error_m":waypoint_error_m,
+                        "gpx_footprint_km":footprint_km,
+                        "gpx_rank_score":gpx_route_rank_score(similarity, footprint_km)} if templates else {})}})
         except requests.RequestException as exc:
             if not isinstance(exc, requests.HTTPError) or (exc.response is not None and exc.response.status_code in {429,502,503,504}):
                 break
@@ -189,7 +192,8 @@ def generate_walking_fallback(
             continue
     if not routes:
         return None
-    routes.sort(key=lambda route: (-route["route_quality"].get("gpx_similarity", 0.0),
+    routes.sort(key=lambda route: (-route["route_quality"].get("gpx_rank_score", 0.0),
+                                   -route["route_quality"].get("gpx_similarity", 0.0),
                                    route["route_quality"].get("road_waypoint_error_m") or 0.0,
                                    0 if auto_distance else abs(route["length_km"]-target_distance_km)))
     routes = routes[:route_count]

api/ai-service/tests/test_gpx_shape_similarity.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
-from app.services.gpx_shape_similarity import best_gpx_shape_match
+from app.services.gpx_shape_similarity import best_gpx_shape_match, gpx_route_rank_score, route_footprint_km
 
 
 def test_finds_closest_gpx_outline_independent_of_rotation_and_location():
@@ -24,3 +24,13 @@ def test_finds_closest_gpx_outline_independent_of_rotation_and_location():
 
 def test_empty_or_short_route_has_no_match():
     assert best_gpx_shape_match([[37.5, 127.0]], [[(0, 0), (1, 0), (0, 1)]]) == (0.0, None)
+
+
+def test_wide_gpx_contour_wins_close_fit_but_not_poor_fit():
+    narrow = [[37.5, 127.0], [37.55, 127.001], [37.5, 127.0]]
+    wide = [[37.5, 127.0], [37.55, 127.06], [37.5, 127.0]]
+    narrow_span = route_footprint_km(narrow)
+    wide_span = route_footprint_km(wide)
+    assert wide_span > narrow_span
+    assert gpx_route_rank_score(0.96, wide_span) > gpx_route_rank_score(0.97, narrow_span)
+    assert gpx_route_rank_score(0.96, wide_span) < gpx_route_rank_score(0.99, narrow_span)

api/ai-service/tests/test_walking_route_fallback.py

@@ -185,3 +185,20 @@ def test_auto_distance_tries_multiple_sizes_and_reports_measured_length(monkeypa
     first = json.loads(get.call_args_list[0].kwargs['params']['json'])['locations']
     second = json.loads(get.call_args_list[1].kwargs['params']['json'])['locations']
     assert first[1] != second[1]
+
+
+def test_auto_distance_keeps_wide_measured_road_route(monkeypatch):
+    import json
+    def following_provider(_url, *, params, **_kwargs):
+        locations = json.loads(params['json'])['locations']
+        legs = [{'shape': encode([[a['lat'], a['lon']], [b['lat'], b['lon']]])}
+                for a, b in zip(locations, locations[1:])]
+        return SimpleNamespace(raise_for_status=lambda: None,
+            json=lambda: {'trip': {'summary': {'length': 30.0, 'has_ferry': False}, 'legs': legs}})
+    monkeypatch.setattr(requests, 'get', following_provider)
+    example = [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]
+    result = walking.generate_walking_fallback(**options(), templates=[example],
+        generation_id='wide-gpx', auto_distance=True)
+    assert result['best_route']['length_km'] == 30.0
+    assert result['best_route']['route_quality']['gpx_footprint_km'] > 0
+    assert result['target_distance_km'] == 30.0

router/ai/scripts/clip_osm_region_test.py

@@ -2416,7 +2416,7 @@ def generate_candidate_routes(
         shuffled_examples = random.sample(examples, len(examples)) if examples else []
         for attempt in range(guided_attempts):
             try:
-                guided_target_m = (3000.0, 5000.0, 8000.0, 12000.0, 16000.0)[attempt % 5] if auto_distance else target_distance_m
+                guided_target_m = (6000.0, 10000.0, 14000.0, 18000.0, 24000.0, 30000.0, 36000.0)[attempt % 7] if auto_distance else target_distance_m
                 geo_points = guided_geo_waypoints(
                     graph=graph,
                     label=str(selected_label),
@@ -2431,7 +2431,7 @@ def generate_candidate_routes(
             if len(route_nodes) < 18:
                 continue
             length_m = route_length_m(graph, route_nodes)
-            if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 20000.0):
+            if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 45000.0):
                 continue
             unique_ratio = len(set(route_nodes)) / len(route_nodes)
             if unique_ratio < 0.50:
@@ -2524,7 +2524,7 @@ def generate_candidate_routes(
             continue
 
         length_m = route_length_m(graph, route_nodes)
-        if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 20000.0):
+        if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 45000.0):
             continue
         unique_ratio = len(set(route_nodes)) / len(route_nodes)
         if unique_ratio < 0.55:
@@ -2603,7 +2603,7 @@ def generate_candidate_routes(
             if len(route_nodes) < 10:
                 continue
             length_m = route_length_m(graph, route_nodes)
-            if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 20000.0):
+            if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 45000.0):
                 continue
             pts = route_points(graph, route_nodes)
             shape_quality, shape_metrics = route_shape_quality_with_metrics(pts, close_loop=False)