Sync DemoService 71bd72e86a2e2123979cade60f569b398f021fbd

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

@@ -62,6 +62,11 @@ class RouteGenerateRequest(BaseModel):
     fallbackLongitude: float | None = Field(default=None, ge=-180, le=180)
 
 
+class ShapeDiscoveryRequest(BaseModel):
+    latitude: float = Field(..., ge=-90, le=90)
+    longitude: float = Field(..., ge=-180, le=180)
+
+
 class RouteSnapRequest(BaseModel):
     centerLat: float = Field(..., ge=-90, le=90)
     centerLng: float = Field(..., ge=-180, le=180)
@@ -618,6 +623,64 @@ def _run_experimental_next_edge(
     }
 
 
+@router.post("/routes/discover-shapes")
+def discover_shapes(payload: ShapeDiscoveryRequest) -> dict[str, Any]:
+    """Find runnable dog, star and T-shirt outlines near a picked map point."""
+    workspace_dir = Path(settings.ai_workspace_dir)
+    script_dir = workspace_dir / "scripts"
+    script_path = script_dir / "experimental_next_edge_service.py"
+    if str(script_dir) not in sys.path:
+        sys.path.insert(0, str(script_dir))
+    try:
+        module = _load_pipeline_module(script_dir / "clip_osm_region_test.py")
+        spec = importlib.util.spec_from_file_location("shape_discovery_runtime", script_path)
+        if spec is None or spec.loader is None:
+            raise RuntimeError("Shape discovery is unavailable")
+        experiment = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(experiment)
+        outlines = getattr(module, "GPX_SHAPE_TEMPLATES", {})
+        graph = experiment.fetch_small_walk_graph(payload.latitude, payload.longitude)
+        road, paths_by_label, snap_distance = experiment.discover_shape_paths(
+            graph, {label: outlines.get(label, []) for label in ("dog", "symbol_star", "t_shirt")},
+            payload.latitude, payload.longitude,
+        )
+        candidates = []
+        for label, paths in paths_by_label.items():
+            ranked = []
+            for path in paths:
+                coords = road.geo(path)
+                similarity, _ = best_gpx_shape_match(coords, outlines[label])
+                edges = list(zip(path[:-1], path[1:]))
+                retrace = 1 - len(set(edges)) / max(1, len(edges))
+                score = max(0., similarity - .2 * retrace)
+                ranked.append((score, similarity, retrace, path, coords))
+            if ranked:
+                score, similarity, retrace, path, coords = max(ranked, key=lambda row: row[0])
+                candidates.append({
+                    "label": label, "score": round(score, 4),
+                    "shape_similarity": round(similarity, 4),
+                    "retrace_ratio": round(retrace, 4),
+                    "available": score >= .7,
+                    "distance_km": round(sum(road.length[a, b] for a, b in edges) / 1000, 2)
+                    if (edges := list(zip(path[:-1], path[1:]))) else 0,
+                    "route_coords": coords,
+                })
+            else:
+                candidates.append({"label": label, "score": 0., "shape_similarity": 0.,
+                                   "retrace_ratio": 0., "available": False,
+                                   "distance_km": 0., "route_coords": []})
+        candidates.sort(key=lambda candidate: -candidate["score"])
+        return {"point": [payload.latitude, payload.longitude],
+                "road_start": road.geo([int(road.nearest(road.project([(payload.latitude, payload.longitude)]))[0][0])])[0],
+                "snap_distance_m": round(snap_distance, 1),
+                "search_radius_km": 0.8, "candidates": candidates}
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.exception("shape discovery failed")
+        raise HTTPException(status_code=503, detail="이 지점의 도로를 조회하지 못했습니다. 잠시 후 다시 시도해 주세요.") from exc
+
+
 def _nearby_road_return_routes(
     graph: Any,
     route_count: int,

main/app/_components/LeafletMap.tsx

@@ -26,6 +26,7 @@ export type LeafletMapProps = {
   markers?: MapMarker[];
   selectedMarkerId?: string | null;
   onMarkerClick?: (marker: MapMarker) => void;
+  onMapClick?: (point: [number, number]) => void;
   className?: string;
   zoom?: number;
   preserveViewport?: boolean;

main/app/_components/LeafletMapClient.tsx

@@ -10,6 +10,7 @@ import {
   TileLayer,
   ZoomControl,
   useMap,
+  useMapEvents,
 } from "react-leaflet";
 
 type RouteLayer = {
@@ -35,6 +36,11 @@ function isMapContainerReady(map: ReturnType<typeof useMap>): boolean {
   }
 }
 
+function MapClickHandler({ onMapClick }: { onMapClick?: (point: [number, number]) => void }) {
+  useMapEvents({ click: (event) => onMapClick?.([event.latlng.lat, event.latlng.lng]) });
+  return null;
+}
+
 function InitialRunView({ route, center, zoom }: {
   route: [number, number][];
   center: [number, number];
@@ -154,6 +160,7 @@ export default function LeafletMapClient({
   markers,
   selectedMarkerId,
   onMarkerClick,
+  onMapClick,
   markerEmoji = "🏃",
   className,
   zoom = 13,
@@ -173,6 +180,7 @@ export default function LeafletMapClient({
   markers?: MapMarker[];
   selectedMarkerId?: string | null;
   onMarkerClick?: (marker: MapMarker) => void;
+  onMapClick?: (point: [number, number]) => void;
   className?: string;
   zoom?: number;
   preserveViewport?: boolean;
@@ -263,6 +271,7 @@ export default function LeafletMapClient({
       fadeAnimation={false}
       markerZoomAnimation={false}
     >
+      {interactive && onMapClick && <MapClickHandler onMapClick={onMapClick} />}
       {interactive && <ZoomControl position="bottomleft" />}
       <TileLayer
         attribution='&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'

main/app/route-search/page.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { Suspense, useEffect, useMemo, useState } from "react";
+import { Suspense, useEffect, useMemo, useRef, useState } from "react";
 import { useRouter, useSearchParams } from "next/navigation";
 import LeafletMap, { type MapMarker, type MapRouteLayer } from "../_components/LeafletMap";
 import WebLocationPermission from "../_components/WebLocationPermission";
@@ -15,6 +15,15 @@ import { prepareCoursePreview } from "../_utils/coursePreview";
 
 type Point = [number, number];
 
+type ShapeDiscoveryCandidate = {
+  label: "dog" | "symbol_star" | "t_shirt";
+  score: number;
+  shape_similarity: number;
+  available: boolean;
+  distance_km: number;
+  route_coords: Point[];
+};
+
 type DemoSampleRun = {
   id: string;
   label: "dog" | "symbol_star" | "t_shirt";
@@ -440,6 +449,12 @@ function RouteSearchPageContent() {
   const [sampleGalleryLabel, setSampleGalleryLabel] = useState<DemoSampleRun["label"] | null>(null);
   const [isPostLoading, setIsPostLoading] = useState(true);
   const [selectedPlaceCenter, setSelectedPlaceCenter] = useState<Point | null>(null);
+  const [discoveryPoint, setDiscoveryPoint] = useState<Point | null>(null);
+  const [discoveryCandidates, setDiscoveryCandidates] = useState<ShapeDiscoveryCandidate[]>([]);
+  const [discoveryLoading, setDiscoveryLoading] = useState(false);
+  const [discoveryError, setDiscoveryError] = useState<string | null>(null);
+  const [previewDiscoveryLabel, setPreviewDiscoveryLabel] = useState<string | null>(null);
+  const discoveryRequest = useRef<AbortController | null>(null);
 
   const activeRegion = useMemo(
     () =>
@@ -537,8 +552,11 @@ function RouteSearchPageContent() {
     title: sample.title,
     kind: sample.label === "dog" ? "sampleDog" : sample.label === "t_shirt" ? "sampleTshirt" : "sampleStar",
   }));
+  const previewDiscovery = discoveryCandidates.find((candidate) => candidate.label === previewDiscoveryLabel);
   const selectedMapRoutes: MapRouteLayer[] =
-    selectedSample?.route && selectedSample.route.length > 1
+    previewDiscovery?.route_coords && previewDiscovery.route_coords.length > 1
+      ? [{ points: previewDiscovery.route_coords, color: "#1E40AF", weight: 5, opacity: 0.95 }]
+      : selectedSample?.route && selectedSample.route.length > 1
       ? [{ points: selectedSample.route, color: selectedSample.label === "dog" ? "#f97316" : selectedSample.label === "t_shirt" ? "#0d9488" : "#a855f7", weight: 5, opacity: 0.95 }]
       : sampleGalleryLabel
       ? galleryMapSamples.map((sample) => ({
@@ -785,6 +803,33 @@ function RouteSearchPageContent() {
     router.push(`/route-results?${params.toString()}`);
   };
 
+  const discoverAtPoint = async (point: Point) => {
+    discoveryRequest.current?.abort();
+    const controller = new AbortController();
+    discoveryRequest.current = controller;
+    setDiscoveryPoint(point);
+    setDiscoveryCandidates([]);
+    setPreviewDiscoveryLabel(null);
+    setDiscoveryError(null);
+    setDiscoveryLoading(true);
+    try {
+      const response = await fetch(`${process.env.NEXT_PUBLIC_API_BASE_URL ?? ""}/api/v1/ai/routes/discover-shapes`, {
+        method: "POST", headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ latitude: point[0], longitude: point[1] }),
+        signal: controller.signal, cache: "no-store",
+      });
+      const data = await response.json() as { candidates?: ShapeDiscoveryCandidate[]; detail?: string };
+      if (!response.ok || !Array.isArray(data.candidates)) {
+        throw new Error(data.detail || "이 지점의 도로를 조회하지 못했습니다.");
+      }
+      if (!controller.signal.aborted) setDiscoveryCandidates(data.candidates);
+    } catch (error) {
+      if (!controller.signal.aborted) setDiscoveryError(error instanceof Error ? error.message : "탐색에 실패했습니다.");
+    } finally {
+      if (!controller.signal.aborted) setDiscoveryLoading(false);
+    }
+  };
+
   const handleStartSelectedPostRoute = () => {
     if (
       typeof window === "undefined" ||
@@ -848,7 +893,8 @@ function RouteSearchPageContent() {
                 <LeafletMap
                   center={mapCenter}
                   routes={selectedMapRoutes}
-                  markers={[...sampleMarkers, ...postMarkers]}
+                  markers={[...sampleMarkers, ...postMarkers, ...(discoveryPoint ? [{ id: "discovery-point", position: discoveryPoint, title: "선택한 지점", kind: "location" as const }] : [])]}
+                  onMapClick={(point) => { void discoverAtPoint(point); }}
                   selectedMarkerId={selectedSampleId ?? (selectedPostId ? `post-${selectedPostId}` : null)}
                   onMarkerClick={(marker) => {
                     if (marker.kind === "sampleDog" || marker.kind === "sampleStar" || marker.kind === "sampleTshirt") {
@@ -869,6 +915,35 @@ function RouteSearchPageContent() {
                 경로 미리보기
               </div>
             </div>
+            <div className="border-t border-black/10 bg-[#f3f7ff] px-4 py-4">
+              <p className="text-sm font-bold text-[#111]">지도에서 한 점을 찍어 모양 찾기</p>
+              <p className="mt-1 text-xs text-[#516177]">선택한 점 근처 약 0.8km 도로에서 강아지·별·티셔츠 경로를 함께 찾습니다.</p>
+              {discoveryLoading && <p className="mt-3 text-sm text-[#1E40AF]">주변 도로와 모양을 확인하는 중...</p>}
+              {discoveryError && <p role="alert" className="mt-3 text-sm text-red-600">{discoveryError}</p>}
+              {discoveryCandidates.length > 0 && <div className="mt-3 grid grid-cols-3 gap-2">
+                {discoveryCandidates.map((candidate) => {
+                  const label = candidate.label === "dog" ? "강아지" : candidate.label === "symbol_star" ? "별" : "티셔츠";
+                  return <button key={candidate.label} type="button"
+                    disabled={!candidate.available}
+                    onClick={() => setPreviewDiscoveryLabel(candidate.label)}
+                    className={`rounded-xl border p-2 text-left text-xs ${candidate.available ? "border-[#1E40AF]/25 bg-white" : "border-black/10 bg-[#e8ebef] text-[#667085]"}`}>
+                    <span className="block font-bold">{label}</span>
+                    <span className="mt-1 block">{candidate.available ? `유사도 ${Math.round(candidate.shape_similarity * 100)}점` : "적합한 경로 없음"}</span>
+                  </button>;
+                })}
+              </div>}
+              {previewDiscovery?.available && discoveryPoint && <button type="button"
+                className="mt-3 w-full rounded-full bg-[#1E40AF] px-4 py-3 text-sm font-bold text-white"
+                onClick={() => router.push(prepareCoursePreview({
+                  id: `discovered-${previewDiscovery.label}-${Date.now()}`,
+                  title: `${previewDiscovery.label === "dog" ? "강아지" : previewDiscovery.label === "symbol_star" ? "별" : "티셔츠"} 모양 코스`,
+                  place, distanceKm: previewDiscovery.distance_km,
+                  center: discoveryPoint, route: previewDiscovery.route_coords,
+                  label: previewDiscovery.label, source: "지도 지점 모양 탐색",
+                }))}>
+                이 경로 살펴보기 · {previewDiscovery.distance_km.toFixed(2)}km
+              </button>}
+            </div>
             <div className="border-t border-black/10 bg-white px-4 py-4">
               <div className="flex items-start justify-between gap-3">
                 <div className="min-w-0">

router/ai/scripts/experimental_next_edge_service.py

@@ -11,6 +11,7 @@ import torch
 import networkx as nx
 import osmnx as ox
 import requests
+import numpy as np
 
 from train_gpx_next_edge import NextEdgeGATv2, RoadGraph, rollout
 
@@ -85,3 +86,46 @@ def generate_experimental_paths(graph, model, outlines, count, generation_id):
         if len(results) >= count:
             break
     return results
+
+
+def discover_shape_paths(graph, outlines_by_label, latitude, longitude):
+    """Try each shape around one picked point on the same walkable graph.
+
+    The point is snapped to a nearby road and kept as the start and end of
+    every candidate. Scores are calculated later from the completed routes.
+    """
+    road = RoadGraph(graph)
+    nearest, distance = road.nearest(road.project([(latitude, longitude)]))
+    start = int(nearest[0])
+    if float(distance[0]) > 180:
+        raise ValueError("선택한 점에서 180m 이내에 보행 가능한 도로가 없습니다.")
+    result = {}
+    for label, outlines in outlines_by_label.items():
+        candidates = []
+        # Spread the bounded search across the full GPX outline collection.
+        outline_indices = np.linspace(0, len(outlines) - 1, min(3, len(outlines))).astype(int) if outlines else []
+        for outline_index in outline_indices:
+            outline = outlines[int(outline_index)]
+            body = np.asarray(outline[:-1], dtype=np.float32)
+            body = body[np.linspace(0, len(body) - 1, min(12, len(body))).astype(int)]
+            body -= body[0].copy()
+            for scale in (300., 600.):
+                for quarter in range(4):
+                    angle = quarter * math.pi / 2
+                    rotation = np.array([[math.cos(angle), -math.sin(angle)],
+                                         [math.sin(angle), math.cos(angle)]], dtype=np.float32)
+                    nearest_nodes, snap_distance = road.nearest(body @ rotation.T * scale + road.xy[start])
+                    if float(np.quantile(snap_distance, .8)) > 120:
+                        continue
+                    anchors = [start] + [int(node) for node in nearest_nodes[1:]] + [start]
+                    path = [start]
+                    for a, b in zip(anchors[:-1], anchors[1:]):
+                        leg = road.route(a, b)
+                        if not leg:
+                            path = []
+                            break
+                        path.extend(leg[1:])
+                    if len(path) >= 8:
+                        candidates.append(path)
+        result[label] = candidates
+    return road, result, float(distance[0])

router/ai/tests/test_gpx_next_edge.py

@@ -46,3 +46,19 @@ def test_match_train_and_holdout_rollout():
     report = module.evaluate(test_road, [outline], model)
     assert report["shortest_path"]["road_valid"] == 1
     assert report["gatv2"]["road_valid"] == 1
+
+
+def test_point_discovery_keeps_start_and_end_on_picked_road():
+    from experimental_next_edge_service import discover_shape_paths
+
+    road = grid()
+    path = [7, 8, 9, 15, 21, 20, 19, 13, 7]
+    outline = module.normalized_outline_from_track([road.geo([node])[0] for node in path for _ in range(15)])
+    picked = road.geo([7])[0]
+    result_road, routes, snap_m = discover_shape_paths(
+        road.graph, {"dog": [outline]}, picked[0], picked[1]
+    )
+    assert snap_m < 1
+    assert routes["dog"]
+    assert all(route[0] == 7 and route[-1] == 7 for route in routes["dog"])
+    assert all((a, b) in result_road.length for route in routes["dog"] for a, b in zip(route[:-1], route[1:]))