Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+graph.sqlite filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,23 @@
 ---
-title: Setvl Node Graph Viewer
-emoji: 🏢
+title: SetVL Node Graph Viewer
+emoji: 🛣️
 colorFrom: gray
-colorTo: pink
+colorTo: yellow
 sdk: gradio
 sdk_version: 6.27.0
-python_version: '3.13'
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SetVL Node Graph Viewer
+
+只读浏览 SetVL-480K 全库的 node graph：12,250 个场景、119,996 个节点、108,374 条边。
+
+节点按所属道路走廊着色，红圈为孤儿节点；边按来源着色——青=同路相连、
+橙=路口相连、紫=最小补全的桥接边，白色加粗=高花费边（路网上绕路过远或不可达，
+按直线连接）。
+
+图片存放在配套的 Dataset repo，由 CDN 按需分发。
+
+建图规则见仓库里的 `GRAPH_RULES.md`。

app.py

@@ -0,0 +1,403 @@
+#!/usr/bin/env python3
+"""SetVL Node Graph 只读浏览器（Gradio）。
+
+给别人看结果用的：能翻场景、看图、看每条边每个节点的属性，但**改不了任何东西**。
+没有写入接口——不是靠界面藏起来，是压根没实现。
+
+数据来自 `prepare.py` 打出来的包（graph.sqlite + satellite/ + ground/ 全是包内相对路径），
+所以整个目录拷到哪都能跑，不依赖原始的 52 GB 数据集。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import sqlite3
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import gradio as gr
+from PIL import Image, ImageDraw
+
+HERE = Path(__file__).resolve().parent
+
+# 图片从哪来，两种模式：
+#   本地包  —— SETVL_PACKAGE 指向 prepare.py 产出的目录，直接读文件
+#   HF 数据集 —— SETVL_DATASET 指向 "user/repo"，按需从 CDN 取，本地只留缓存
+# 27 GB 图片放 Dataset repo、Space 里只放 93 MB 的数据库，Space 构建才快。
+PACKAGE = Path(os.environ.get("SETVL_PACKAGE", HERE / "package"))
+DATASET = os.environ.get("SETVL_DATASET", "").strip()
+DB = Path(os.environ.get("SETVL_DB", "")) if os.environ.get("SETVL_DB") else None
+if DB is None:
+    DB = (HERE / "graph.sqlite") if (HERE / "graph.sqlite").exists() else PACKAGE / "graph.sqlite"
+
+ZOOM, RASTER = 17, 400
+CITIES: List[str] = []
+
+# 与复核台一致的配色，换个地方看图不会认错
+COL = {
+    "corridor_chain": (104, 200, 192),
+    "intersection": (241, 164, 60),
+    "bridge": (184, 162, 224),
+    "manual": (104, 200, 192),
+}
+COL_ORPHAN = (239, 91, 77)
+COL_HIGHCOST = (232, 229, 218)
+
+
+def asset(rel: str) -> Optional[Path]:
+    """把包内相对路径解析成本地可读文件。
+
+    数据集模式下按需从 HF CDN 拉取并缓存——27 GB 不必也不该整个下到 Space 里。
+    取不到就返回 None，让调用方降级（画空白底图、跳过该张街景），不要抛异常
+    把整个页面打挂。
+    """
+    local = PACKAGE / rel
+    if local.is_file():
+        return local
+    if not DATASET:
+        return None
+    try:
+        from huggingface_hub import hf_hub_download
+        return Path(hf_hub_download(DATASET, rel, repo_type="dataset"))
+    except Exception:
+        return None
+
+
+def connect() -> sqlite3.Connection:
+    if not DB.exists():
+        raise FileNotFoundError(
+            f"找不到 {DB}。先跑 prepare.py 打包，或设 SETVL_DB 指向 graph.sqlite。")
+    con = sqlite3.connect(f"file:{DB}?mode=ro", uri=True, check_same_thread=False)
+    con.row_factory = sqlite3.Row
+    return con
+
+
+CON = None
+
+
+def con() -> sqlite3.Connection:
+    global CON
+    if CON is None:
+        CON = connect()
+    return CON
+
+
+# --------------------------------------------------------------- 投影
+
+def mercator(lat: float, lon: float) -> Tuple[float, float]:
+    s = 256 * (2 ** ZOOM)
+    x = (lon + 180.0) / 360.0 * s
+    sy = math.sin(math.radians(lat))
+    y = (0.5 - math.log((1 + sy) / (1 - sy)) / (4 * math.pi)) * s
+    return x, y
+
+
+def tile_center(sat_rel: str) -> Optional[Tuple[float, float]]:
+    parts = Path(sat_rel).stem.split("_")
+    try:
+        return float(parts[-1]), float(parts[-2])
+    except (ValueError, IndexError):
+        return None
+
+
+def projector(sat_rel: str):
+    c = tile_center(sat_rel)
+    if c is None:
+        return None
+    cx, cy = mercator(*c)
+
+    def to_px(lat: float, lon: float) -> Tuple[float, float]:
+        x, y = mercator(lat, lon)
+        return x - cx + RASTER / 2, y - cy + RASTER / 2
+    return to_px
+
+
+def corridor_color(cid: Optional[str]) -> Tuple[int, int, int]:
+    if not cid:
+        return (120, 130, 125)
+    h = 0
+    for ch in cid:
+        h = (h * 31 + ord(ch)) & 0xFFFFFFFF
+    import colorsys
+    r, g, b = colorsys.hls_to_rgb((h % 360) / 360.0, 0.58, 0.55)
+    return int(r * 255), int(g * 255), int(b * 255)
+
+
+# --------------------------------------------------------------- 查询
+
+def list_scenes(city: str, min_nodes: int, only_high_cost: bool,
+                only_orphan: bool, query: str, page: int,
+                per_page: int = 60) -> Tuple[List[str], int]:
+    where, args = [], []
+    if city and city != "全部":
+        where.append("s.city = ?")
+        args.append(city)
+    if min_nodes:
+        where.append("s.node_count >= ?")
+        args.append(int(min_nodes))
+    if query.strip():
+        where.append("s.scene_id LIKE ?")
+        args.append(f"%{query.strip()}%")
+    if only_high_cost:
+        where.append("EXISTS (SELECT 1 FROM edge e WHERE e.scene_id = s.scene_id "
+                     "AND e.high_cost_auto = 1)")
+    if only_orphan:
+        where.append("EXISTS (SELECT 1 FROM node n WHERE n.scene_id = s.scene_id "
+                     "AND n.is_orphan_auto = 1)")
+    clause = (" WHERE " + " AND ".join(where)) if where else ""
+    total = con().execute(f"SELECT COUNT(*) FROM scene s{clause}", args).fetchone()[0]
+    page = max(0, page)
+    rows = con().execute(
+        f"SELECT s.scene_id, s.city, s.node_count FROM scene s{clause} "
+        "ORDER BY s.scene_id LIMIT ? OFFSET ?", args + [per_page, page * per_page])
+    labels = [f"{r['scene_id']}  ·  {r['node_count']}n  ·  {r['city']}" for r in rows]
+    return labels, total
+
+
+def scene_of(label: str) -> Optional[str]:
+    return label.split("  ·  ")[0] if label else None
+
+
+def load_scene(scene_id: str) -> Optional[Dict[str, Any]]:
+    s = con().execute("SELECT * FROM scene WHERE scene_id = ?", (scene_id,)).fetchone()
+    if s is None:
+        return None
+    nodes = [dict(r) for r in con().execute(
+        "SELECT * FROM node WHERE scene_id = ? ORDER BY label", (scene_id,))]
+    edges = [dict(r) for r in con().execute(
+        "SELECT * FROM edge WHERE scene_id = ? ORDER BY source_label, target_label",
+        (scene_id,))]
+    for n in nodes:
+        n["corridor_id"] = n["corridor_id_human"] or n["corridor_id_auto"]
+        n["corridor_name"] = (n["corridor_name_human"] or n["corridor_name_auto"]
+                              or n["corridor_id"])
+        o = n["is_orphan_human"]
+        n["is_orphan"] = int(o) if o is not None else (n["is_orphan_auto"] or 0)
+    for e in edges:
+        e["origin"] = e["origin_human"] or e["origin_auto"] or "bridge"
+        hc = e["high_cost_human"]
+        e["high_cost"] = int(hc) if hc is not None else (e["high_cost_auto"] or 0)
+        e["in_graph"] = e["edge_verdict_human"] != "reject"
+    return {"scene": dict(s), "nodes": nodes, "edges": edges}
+
+
+# --------------------------------------------------------------- 绘图
+
+def render(scene_id: str, show_road_path: bool) -> Tuple[Optional[Image.Image], str, str]:
+    det = load_scene(scene_id)
+    if det is None:
+        return None, "未找到该场景", ""
+    sat = asset(det["scene"]["satellite_path"])
+    base = (Image.open(sat).convert("RGB") if sat
+            else Image.new("RGB", (RASTER, RASTER), (18, 22, 20)))
+    base = base.resize((RASTER * 2, RASTER * 2), Image.LANCZOS)
+    d = ImageDraw.Draw(base, "RGBA")
+    proj = projector(det["scene"]["satellite_path"])
+    if proj is None:
+        return base, "无法从瓦片名解析中心坐标", ""
+    P = {n["label"]: tuple(v * 2 for v in proj(n["lat"], n["lon"])) for n in det["nodes"]}
+
+    for e in det["edges"]:
+        a, b = P.get(e["source_label"]), P.get(e["target_label"])
+        if not a or not b:
+            continue
+        col = COL.get(e["origin"], COL["bridge"])
+        alpha = 60 if not e["in_graph"] else 255
+        if e["high_cost"]:
+            col = COL_HIGHCOST
+        path = None
+        if show_road_path and not e["high_cost"] and e["road_path_auto"]:
+            try:
+                pts = json.loads(e["road_path_auto"])
+                path = [tuple(v * 2 for v in proj(p[0], p[1])) for p in pts]
+            except (ValueError, TypeError):
+                path = None
+        if path and len(path) > 1:
+            d.line([a] + path + [b], fill=col + (alpha,), width=3, joint="curve")
+        else:
+            d.line([a, b], fill=col + (alpha,), width=3)
+
+    for n in det["nodes"]:
+        p = P[n["label"]]
+        fill = corridor_color(n["corridor_id"])
+        r = 9
+        d.ellipse([p[0] - r, p[1] - r, p[0] + r, p[1] + r], fill=fill + (255,),
+                  outline=(COL_ORPHAN if n["is_orphan"] else (12, 16, 14)) + (255,),
+                  width=3 if n["is_orphan"] else 2)
+        d.text((p[0] - 4, p[1] - 6), n["label"], fill=(12, 16, 14))
+
+    sc = det["scene"]
+    from collections import Counter
+    oc = Counter(e["origin"] for e in det["edges"])
+    corridors = sorted({n["corridor_name"] for n in det["nodes"] if n["corridor_name"]})
+    summary = "\n".join([
+        f"**{sc['scene_id']}**",
+        "",
+        f"- 城市：{sc['city']}　节点 {len(det['nodes'])}　边 {len(det['edges'])}",
+        f"- 边构成：走廊链 {oc.get('corridor_chain',0)}　路口 {oc.get('intersection',0)}　"
+        f"桥接 {oc.get('bridge',0)}　人工 {oc.get('manual',0)}",
+        f"- 孤儿节点 {sum(n['is_orphan'] for n in det['nodes'])}　"
+        f"高花费边 {sum(e['high_cost'] for e in det['edges'])}　"
+        f"被拒边 {sum(0 if e['in_graph'] else 1 for e in det['edges'])}",
+        f"- 路网碎片化：{'是' if sc['net_fragmented_auto'] else '否'}",
+        "",
+        f"**走廊（{len(corridors)}）**：" + ("、".join(corridors[:8]) or "—")
+        + ("…" if len(corridors) > 8 else ""),
+    ])
+
+    lines = ["| 边 | 来源 | 欧氏 m | 路网 m | 绕路 | 高花费 | 状态 |",
+             "|---|---|---|---|---|---|---|"]
+    for e in det["edges"]:
+        lines.append(
+            f"| {e['source_label']}–{e['target_label']} | {e['origin']} | "
+            f"{(e['euclid_distance_m_auto'] or 0):.1f} | "
+            f"{('%.1f' % e['road_distance_m_auto']) if e['road_distance_m_auto'] else '—'} | "
+            f"{('%.2fx' % e['detour_ratio_auto']) if e['detour_ratio_auto'] else '—'} | "
+            f"{'是' if e['high_cost'] else ''} | "
+            f"{'已拒' if not e['in_graph'] else ''} |")
+    return base, summary, "\n".join(lines)
+
+
+def node_gallery(scene_id: str) -> List[Tuple[str, str]]:
+    det = load_scene(scene_id)
+    if det is None:
+        return []
+    out = []
+    city = det["scene"]["city"]
+    folder = PACKAGE / "ground" / city
+    for n in det["nodes"]:
+        cap = (f"{n['label']} · {n['corridor_name'] or '无走廊'}"
+               + (" · 孤儿" if n["is_orphan"] else ""))
+        # 街景文件名带朝向，本地包直接 glob；数据集模式下朝向未知，
+        # 逐个试常见朝向取第一张命中的
+        if folder.is_dir():
+            hits = sorted(folder.glob(f"{city},{n['panoid']},*.webp"))
+            if hits:
+                out.append((str(hits[0]), cap))
+                continue
+        rel = ground_rel(n)
+        if rel:
+            p = asset(rel)
+            if p:
+                out.append((str(p), cap))
+    return out
+
+
+def ground_rel(node: Dict[str, Any]) -> Optional[str]:
+    """从索引表查这个 pano 的街景文件名。
+
+    打包时写了一张 pano -> 文件名 的索引，因为文件名里有 alt/year/heading
+    三个字段是数据库里没有的，猜不出来。
+    """
+    row = con().execute(
+        "SELECT rel FROM ground_index WHERE panoid = ? LIMIT 1",
+        (node["panoid"],)).fetchone()
+    return row[0] if row else None
+
+
+def node_table(scene_id: str) -> str:
+    det = load_scene(scene_id)
+    if det is None:
+        return ""
+    lines = ["| 节点 | 走廊 | 来源 | 吸附 m | 孤儿 | 人工覆盖 |", "|---|---|---|---|---|---|"]
+    for n in det["nodes"]:
+        ov = []
+        if n["corridor_id_human"] is not None:
+            ov.append("走廊")
+        if n["is_orphan_human"] is not None:
+            ov.append("孤儿")
+        lines.append(
+            f"| {n['label']} | {n['corridor_name'] or '—'} | "
+            f"{n['corridor_source_auto'] or '—'} | "
+            f"{(n['snap_distance_m_auto'] or 0):.1f} | {'是' if n['is_orphan'] else ''} | "
+            f"{'、'.join(ov)} |")
+    return "\n".join(lines)
+
+
+# --------------------------------------------------------------- 界面
+
+def build() -> gr.Blocks:
+    global CITIES
+    CITIES = ["全部"] + [r[0] for r in
+                        con().execute("SELECT DISTINCT city FROM scene ORDER BY city")]
+    n_scene = con().execute("SELECT COUNT(*) FROM scene").fetchone()[0]
+    n_node = con().execute("SELECT COUNT(*) FROM node").fetchone()[0]
+    n_edge = con().execute("SELECT COUNT(*) FROM edge").fetchone()[0]
+
+    with gr.Blocks(title="SetVL Node Graph Viewer", theme=gr.themes.Base()) as demo:
+        gr.Markdown(
+            f"# SetVL Node Graph Viewer\n"
+            f"{n_scene:,} 个场景 · {n_node:,} 个节点 · {n_edge:,} 条边 · **只读浏览**\n\n"
+            f"节点按所属走廊着色，红圈是孤儿；边按来源着色："
+            f"<span style='color:#68c8c0'>青=走廊链</span>、"
+            f"<span style='color:#f1a43c'>橙=路口边</span>、"
+            f"<span style='color:#b8a2e0'>紫=桥接边</span>，"
+            f"白色加粗=高花费边（直线连接）。")
+        with gr.Row():
+            with gr.Column(scale=1):
+                city = gr.Dropdown(CITIES, value="全部", label="城市")
+                query = gr.Textbox(label="scene_id 搜索", placeholder="片段即可")
+                min_nodes = gr.Slider(1, 38, value=1, step=1, label="最少节点数")
+                with gr.Row():
+                    f_cost = gr.Checkbox(label="含高花费边")
+                    f_orph = gr.Checkbox(label="含孤儿")
+                page = gr.Number(value=0, precision=0, label="页码（每页 60）")
+                info = gr.Markdown()
+                picker = gr.Radio(choices=[], label="场景", interactive=True)
+            with gr.Column(scale=2):
+                show_path = gr.Checkbox(value=True, label="按道路走线绘制边")
+                canvas = gr.Image(label="场景图", type="pil", height=560)
+                summary = gr.Markdown()
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 节点")
+                ntab = gr.Markdown()
+            with gr.Column():
+                gr.Markdown("### 边")
+                etab = gr.Markdown()
+        gallery = gr.Gallery(label="街景", columns=6, height=260)
+
+        def refresh(c, mn, hc, orp, q, pg):
+            labels, total = list_scenes(c, mn, hc, orp, q, int(pg or 0))
+            pages = max(1, -(-total // 60))
+            msg = f"命中 **{total:,}** 个场景　第 {int(pg or 0)+1} / {pages} 页"
+            return gr.update(choices=labels, value=labels[0] if labels else None), msg
+
+        def show(label, sp):
+            sid = scene_of(label)
+            if not sid:
+                return None, "", "", "", []
+            img, summ, et = render(sid, sp)
+            return img, summ, node_table(sid), et, node_gallery(sid)
+
+        for ctl in (city, min_nodes, f_cost, f_orph, query, page):
+            ctl.change(refresh, [city, min_nodes, f_cost, f_orph, query, page],
+                       [picker, info])
+        picker.change(show, [picker, show_path], [canvas, summary, ntab, etab, gallery])
+        show_path.change(show, [picker, show_path], [canvas, summary, ntab, etab, gallery])
+        demo.load(refresh, [city, min_nodes, f_cost, f_orph, query, page], [picker, info])
+    return demo
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--package", type=Path)
+    ap.add_argument("--share", action="store_true", help="开公网临时链接（72 小时）")
+    ap.add_argument("--port", type=int, default=7860)
+    args = ap.parse_args()
+    if args.package:
+        global PACKAGE, DB
+        PACKAGE = args.package
+        DB = PACKAGE / "graph.sqlite"
+    import tempfile
+    build().launch(share=args.share, server_port=args.port,
+                   allowed_paths=[str(PACKAGE), tempfile.gettempdir(),
+                                  os.path.expanduser("~/.cache/huggingface")])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.0
+pillow>=10.0
+huggingface_hub>=0.25