Sync DemoService 42773efa3fee367a7ac26de8f7f0006519a6e1e8

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

@@ -437,8 +437,8 @@ def _run_fast_road_pipeline(
         rank_projections = getattr(module, "rank_road_template_projections", None)
         for search_distance_km in (6.0, 11.0, 18.0):
             template_kwargs = {}
-            if selected_label == "symbol_star" and callable(rank_projections):
-                # Screen every supplied star outline against this road graph;
+            if selected_label in {"symbol_star", "dog"} and callable(rank_projections):
+                # Screen every supplied animal/shape outline against this road graph;
                 # only the best fits enter the expensive shortest-path stage.
                 template_kwargs["template_examples"] = rank_projections(
                     graph, examples, search_distance_km * 1000.0,

api/ai-service/tests/test_gpx_shape_templates.py

@@ -11,6 +11,7 @@ APPROVED_TEMPLATES = ROOT / "router" / "ai" / "data" / "approved_road_shape_temp
 TSHIRT_TEMPLATES = ROOT / "router" / "ai" / "data" / "tshirt_shape_templates.json"
 STAR_TEMPLATES = ROOT / "router" / "ai" / "data" / "star_shape_templates.json"
 ALL_STAR_TEMPLATES = ROOT / "router" / "ai" / "data" / "star_shape_templates_all.json"
+ALL_DOG_TEMPLATES = ROOT / "router" / "ai" / "data" / "dog_shape_templates_all.json"
 
 
 def test_dog_and_star_gpx_examples_are_normalized_and_closed():
@@ -69,6 +70,20 @@ def test_new_star_gpx_examples_are_available_for_road_generation():
     assert all([tuple(point) for point in outline] in loaded["symbol_star"] for outline in all_outlines)
 
 
+def test_new_dog_gpx_examples_are_available_for_road_generation():
+    outlines = json.loads(ALL_DOG_TEMPLATES.read_text(encoding="utf-8"))["dog"]
+    assert len(outlines) == 998
+    assert len({tuple(map(tuple, outline)) for outline in outlines}) == 998
+    assert all(outline[0] == outline[-1] for outline in outlines)
+    script = ROOT / "router" / "ai" / "scripts" / "clip_osm_region_test.py"
+    tree = ast.parse(script.read_text(encoding="utf-8-sig"))
+    loader = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "_load_gpx_shape_templates")
+    scope = {"__file__": str(script), "Path": Path, "json": json}
+    exec(compile(ast.Module(body=[loader], type_ignores=[]), str(script), "exec"), scope)
+    loaded = scope["_load_gpx_shape_templates"]()
+    assert all([tuple(point) for point in outline] in loaded["dog"] for outline in outlines)
+
+
 def test_every_star_outline_is_screened_before_road_pathfinding():
     import math
     import networkx as nx

api/ai-service/tests/test_route_generation_recovery.py

@@ -157,7 +157,8 @@ def test_shape_priority_searches_multiple_lengths_and_ranks_by_shape(monkeypatch
     assert result["target_distance_km"] == 0
 
 
-def test_star_search_screens_all_outlines_before_road_routing(monkeypatch):
+@pytest.mark.parametrize("label", ["symbol_star", "dog"])
+def test_gpx_search_screens_all_outlines_before_road_routing(monkeypatch, label):
     examples = [[(index, 0), (index, 1), (index + 1, 1), (index, 0)] for index in range(1000)]
     screened = []
     routed = []
@@ -172,7 +173,7 @@ def test_star_search_screens_all_outlines_before_road_routing(monkeypatch):
                  "shape_quality": 0.6, "is_loop": True}]
 
     module = SimpleNamespace(
-        GPX_SHAPE_TEMPLATES={"symbol_star": examples},
+        GPX_SHAPE_TEMPLATES={label: examples},
         _build_or_get_walk_graph=lambda *_: (object(), "test"),
         rank_road_template_projections=screen,
         generate_candidate_routes=candidates,
@@ -181,7 +182,7 @@ def test_star_search_screens_all_outlines_before_road_routing(monkeypatch):
     monkeypatch.setattr(routes, "_route_nodes_to_coords", lambda _graph, nodes: [[nodes[0], 0], [nodes[1], 1]])
     monkeypatch.setattr(routes, "best_gpx_shape_match", lambda _coords, templates: (0.9, len(templates) - 1))
     routes._run_fast_road_pipeline(module, place=None, center_lat=37, center_lon=127,
-        radius_km=5, route_count=2, target_distance_km=6, selected_label="symbol_star", shape_priority=True)
+        radius_km=5, route_count=2, target_distance_km=6, selected_label=label, shape_priority=True)
     assert screened == [(1000, 6000), (1000, 11000), (1000, 18000)]
     assert len(routed) == 3
     assert all(len(templates) == 36 and templates[-1] == examples[-1] for templates in routed)

router/ai/scripts/build_dog_shape_templates.py

@@ -0,0 +1,43 @@
+"""Package location-free dog outlines from a multi-track GPX file.
+
+Usage: python build_dog_shape_templates.py DOG_ALL.gpx OUTPUT_JSON
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from build_gpx_shape_templates import normalized_outline_from_track
+
+
+def build(source: Path) -> dict[str, list[list[list[float]]]]:
+    outlines = []
+    seen = set()
+    root = ET.parse(source).getroot()
+    for index, track in enumerate(node for node in root if node.tag.rsplit("}", 1)[-1] == "trk"):
+        points = [
+            (float(node.attrib["lat"]), float(node.attrib["lon"]))
+            for node in track.iter()
+            if node.tag.rsplit("}", 1)[-1] == "trkpt"
+        ]
+        outline = normalized_outline_from_track(points, f"{source.name}:{index}")
+        signature = tuple(map(tuple, outline))
+        if signature not in seen:
+            seen.add(signature)
+            outlines.append(outline)
+    if not outlines:
+        raise ValueError("No dog outlines found")
+    return {"dog": outlines}
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        raise SystemExit("Usage: build_dog_shape_templates.py DOG_ALL.gpx OUTPUT_JSON")
+    output = Path(sys.argv[2])
+    templates = build(Path(sys.argv[1]))
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(templates, separators=(",", ":")) + "\n", encoding="utf-8")
+    print({label: len(items) for label, items in templates.items()})

router/ai/scripts/clip_osm_region_test.py

@@ -147,7 +147,7 @@ def _load_gpx_shape_templates() -> dict[str, list[list[tuple[float, float]]]]:
     data_dir = Path(__file__).resolve().parents[1] / "data"
     templates: dict[str, list[list[tuple[float, float]]]] = {"dog": [], "symbol_star": [], "t_shirt": []}
     seen: dict[str, set[tuple[tuple[float, float], ...]]] = {label: set() for label in templates}
-    for filename in ("gpx_shape_templates.json", "approved_road_shape_templates.json", "tshirt_shape_templates.json", "star_shape_templates.json", "star_shape_templates_all.json"):
+    for filename in ("gpx_shape_templates.json", "approved_road_shape_templates.json", "tshirt_shape_templates.json", "star_shape_templates.json", "star_shape_templates_all.json", "dog_shape_templates_all.json"):
         try:
             payload = json.loads((data_dir / filename).read_text(encoding="utf-8"))
         except (OSError, ValueError, TypeError):