Initial commit: PID2Graph × Claude VLM evaluation + Gradio demo

Zero-shot P&ID graph extraction pipeline (semantic equipment + pipe
connectivity) built on Claude Opus 4.6 vision, benchmarked against the
PID2Graph OPEN100 subset, and wrapped in a Gradio demo with three
preset samples.

- pid2graph_eval/: Pydantic schema, graphml loader + semantic collapse,
structured-outputs VLM extractor (temperature=0), bbox-distance tiled
merge with seam-artifact filter, node/edge P/R/F1 metrics, CLI.
- app.py: Gradio Blocks demo — preset picker, tile toggle, NetworkX
bbox-based visualization of pred vs GT, per-run metrics table. Ships
with a workaround for the gradio_client 1.3.0 bool-schema bug.
- samples/: 3 OPEN100 diagrams (small/medium/large) with ground truth.

.gitattributes

@@ -0,0 +1 @@
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,35 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.ipynb_checkpoints/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Secrets
+.env
+.env.*
+!.env.example
+
+# PID2Graph dataset (9.3 GB — pulled from Zenodo, not committed)
+PID2Graph.zip
+PID2Graph.zip*.tmp
+PID2Graph/
+md5sums.txt
+urls.txt
+nohup.out
+
+# Evaluation artifacts (reproducible; keep locally, don't commit)
+results.json
+results_*.json
+
+# OS / editor
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+*.swp

README.md

@@ -0,0 +1,264 @@
+# PID2Graph × VLM Eval
+
+P&ID（配管計装図）画像から VLM（Claude Opus 4.6）でグラフ構造（シンボル＋接続関係）を抽出し、[PID2Graph](https://zenodo.org/records/14803338) データセットの正解と定量比較する実験。
+
+製造業の技術図面に対する VLM のゼロショット構造抽出性能を評価し、CV との**ハイブリッド戦略**の必要性を実データで検証した。
+
+## 背景と目的
+
+P&ID のデジタル化（画像 → 構造化データ）は、設備管理 DB への自動登録やシミュレーションモデルの自動生成に不可欠な技術である。従来は CNN ベースのシンボル検出＋線検出＋ルールベース接続推定というモジュラーパイプラインが主流だったが、顧客ごとに異なる図面規格への対応コストが課題だった。
+
+本実験では、VLM のゼロショット能力を活用して **訓練データなし** でどこまで構造抽出が可能かを定量的に検証する。
+
+## データセット
+
+[PID2Graph](https://zenodo.org/records/14803338)（Stürmer et al., 2025）の **OPEN100** サブセットを使用。
+
+- 12 枚の実 P&ID 画像（原子力プロジェクト OPEN100）
+- 正解は `.graphml` 形式（ノード: シンボル種別 + bounding box、エッジ: 接続種別）
+- 画像サイズ: 約 600×500 〜 2604×1744 ピクセル
+
+## 手法
+
+### Semantic Equipment フィルタリング
+
+正解データには connector（配管接続点）225 個、crossing（交差）71 個など、線レベルのプリミティブが大量に含まれる。VLM のゼロショットでこれらを網羅的に検出するのは非現実的なため、**意味のある機器シンボルのみ** を抽出・評価対象とした。
+
+| 対象（semantic） | 除外（primitive） |
+|---|---|
+| valve, instrumentation, tank, pump, inlet/outlet | connector, crossing, arrow, background, general |
+
+GT 側も同じフィルタを適用し、primitive を経由するエッジは直接エッジに縮約（collapse）してフェアな比較を行った。
+
+### 構造化出力
+
+Claude API の `messages.parse()` に Pydantic スキーマ（`GraphOut`）を渡し、JSON スキーマ違反を SDK 側で検出。`temperature=0` で決定論的サンプリングを強制。
+
+```json
+{
+  "nodes": [
+    {"id": "n1", "type": "valve", "label": "TCV 1401", "bbox": [578, 930, 586, 944]}
+  ],
+  "edges": [
+    {"source": "n1", "target": "n2", "label": "solid"}
+  ]
+}
+```
+
+### タイル分割（2×2）
+
+大きな図面を 4 タイルに分割（10-20% オーバーラップ）し、各タイルごとに VLM で抽出した後、bbox 距離ベースで重複排除＋マージ。
+
+**Seam Filter:** タイル境界付近で配管の切れ端を inlet/outlet と誤検出する問題に対し、タイル内側境界 ±50px 以内かつ図面外縁でない inlet/outlet を FP として除去する後処理を追加。
+
+## 実験結果
+
+### 12 枚全件ベースライン
+
+| 指標 | Precision | Recall | F1 | TP | FP | FN |
+|------|-----------|--------|----|----|----|-----|
+| **Nodes（single-shot）** | 0.941 | 0.699 | 0.802 | 527 | 33 | 227 |
+| **Nodes（tiled + seam filter）** | 0.828 | 0.948 | 0.884 | 715 | 149 | 39 |
+| Edges（single-shot） | 0.086 | 0.018 | 0.030 | 38 | 402 | 2033 |
+
+### Single-shot vs Tiled（サイズ別比較）
+
+| 図面 | GT nodes | Single F1 | Tiled F1 | ΔF1 | Tiled Precision | Tiled Recall |
+|------|----------|-----------|----------|------|-----------------|--------------|
+| **Small (#1, GT=27)** | 27 | 0.739 | 0.783 | +0.044 | 0.643 | 1.000 |
+| **Medium (#3, GT=53)** | 53 | 0.796 | 0.955 | +0.159 | 0.914 | 1.000 |
+| **Large (#0, GT=82)** | 82 | 0.706 | **0.964** | **+0.258** | 0.952 | 0.976 |
+
+### カテゴリ別 Recall（12 枚集計、single-shot）
+
+| type | GT | pred | Recall |
+|---|---|---|---|
+| instrumentation | 350 | 267 | 0.76 |
+| valve | 257 | 128 | **0.50** ← 最大の失点 |
+| inlet/outlet | 96 | 100 | 1.04 |
+| tank | 35 | 43 | 1.23 |
+| pump | 16 | 22 | 1.38 |
+
+## 考察
+
+### 1. VLM は「意味理解に強く、空間的な網羅性に弱い」
+
+- **Precision 0.94:** VLM が検出したシンボルの種別判定はほぼ正確。「見えているものを正しく分類する」能力は非常に高い
+- **Recall 0.70（single-shot）:** 正解の 30% を見落とす。特に valve（Recall 0.50）は小さなシンボルが画像リサイズで潰れるため
+
+これは理解力の問題ではなく **解像度の限界** である。
+
+### 2. タイル分割で解像度問題を解決
+
+図面が大きいほどタイル分割の効果が顕著：
+
+- Small（GT=27）: ΔF1 = +0.044（効果薄、FP 増加コスト）
+- Medium（GT=53）: ΔF1 = +0.159（Precision 維持しつつ Recall 1.000）
+- **Large（GT=82）: ΔF1 = +0.258**（Precision も 0.889→0.952 に向上）
+
+Large では 1-shot 時に曖昧な小要素を「とりあえず出す」��検出が、タイル分割で高解像度になることで消える。**実用的には図面サイズに応じた適応的モード切替が最適。**
+
+### 3. エッジ抽出は VLM 単体では実用にならない
+
+Edge F1 ≈ 0.03 は全条件で共通。VLM は配管の線形状を追跡しておらず、テキストタグの類似性から接続を推測している。これは **CV 的な線追跡ロジックとの組み合わせ** でしか解決できない。
+
+### 4. BPMN 構造抽出論文（Deka & Devereux, 2026）との比較
+
+同種のタスク（図面画像→構造化 JSON）で VLM を評価した SAC 2026 採択論文との対比：
+
+| 観点 | BPMN 論文 | 本実験（P&ID） |
+|---|---|---|
+| ノード数/図面 | 数十個 | 数百個（1 桁多い） |
+| Relation 抽出 | GPT-4.1 で F1 0.475 | Edge F1 ≈ 0.03 |
+| OCR 補完効果 | 中位モデルで有効、上位モデルには逆効果 | 未検証（今後の課題） |
+| 最有効プロンプト | DFS+BFS Hybrid | 今後検証予定 |
+
+P&ID は BPMN より要素数が 1 桁多く、シンボル種類も工業規格（ISO 10628）に依存するため、難度が大幅に高い。
+
+## 今後の課題：エッジ（接続関係）抽出の改善
+
+今回の実験ではノード検出で F1 0.964 を達成したが、エッジ抽出は F1 ≈ 0.03 で実用にならなかった。接続関係の抽出は P&ID デジタル化の核心であり、最優先の研究課題である。
+
+### アプローチ 1: モジュラーパイプライン（CV 主導）
+
+従来の P&ID デジタル化で主流のアプローチ。
+
+- **線検出:** 画像の二値化 → スケルトン化 → Hough 変換で配管ラインを検出（Moon et al., 2021）
+- **接続推定:** 検出済みシンボルの bbox と線分端点の近接性からグラフ探索で接続を復元
+- **課題:** モジュール間のエラー伝播。線の交差・分岐での追跡失敗が接続推定精度を大きく下げる
+
+参考実装: [Azure P&ID Digitization](https://github.com/Azure-Samples/digitization-of-piping-and-instrument-diagrams)（Microsoft ISE, 2024）
+
+### アプローチ 2: End-to-End Transformer（Relationformer）
+
+PID2Graph 論文（Stürmer et al., 2025）が提案。シンボルと接続関係を同時に抽出する。
+
+- Node AP 83.63%, Edge mAP 75.46%（モジュラー方式に対してエッジ検出で 25%以上の改善）
+- 接続関係を直接推論するため、線検出のエラー伝播がない
+- **課題:** 専用モデルの訓練が必要。新しい図面規格への汎化にはドメイン特化のファインチューニングが不可欠
+
+### アプローチ 3: ハイブリッド（CV + VLM）← 提案する方向性
+
+今回の実験結果と先行研究を踏まえた、最も有望なアプローチ。
+
+```
+[P&ID 画像]
+    │
+    ├─ Stage 1: ノード検出（CV or VLM タイル分割）
+    │   → 今回の手法で Precision 0.95, Recall 0.95 を達成済み
+    │
+    ├─ Stage 2: 線検出・追跡（CV）
+    │   → スケルトン化 + Hough 変換で配管ラインを抽出
+    │   → 検出済みノードの bbox を除去した画像に対して実行
+    │
+    ├─ Stage 3: 接続関係の推論（VLM）
+    │   → 確定済みノード一覧 + 線検出結果 + 元画像を VLM に渡す
+    │   → "これらのノード間の接続関係を列挙せよ" と推論
+    │   → VLM を「審判（Judge）」として活用（Ghosh et al., 2025）
+    │
+    └─ Stage 4: 後処理・検証
+        → グラフ整合性チェック（孤立ノード除去、双方向性確認）
+        → ドメイン知識による制約（バルブは必ず 2 本の配管に接続、等）
+```
+
+**根拠となる先行研究:**
+
+- **VLM as a Judge**（Ghosh et al., 2025）: VLM を直接検出に使わず、CV の結果を VLM が評価・補完するフレームワーク。Gemini 2.5 で F1 0.876
+- **Arrow-Guided VLM**（Spies et al., 2025）: CV 検出器で矢印方向を特定してから VLM に座標付きプロンプトで渡す。QA 精度 +9pp
+- **TextFlow**（Shukla et al., 2024）: VLM の出力を構造化テキスト（Graphviz/Mermaid）に変換し、LLM で推論する 2 段階分離
+- **Florence-2 ファインチューニング**（Khan et al., 2024）: 0.23B パラメータの軽量 VLM で、GPT-4o の zero-shot 比 F1 +52.4%。ドメイン特化ファインチューニングの有効性を実証
+
+### その他の改善課題
+
+| 課題 | 期待効果 | 優先度 |
+|------|---------|--------|
+| IoU ベース dedup（タイルマージ時） | tank/pump の過検出を解消、Precision 向上 | 高 |
+| 適応的タイル切替（GT サイズ推定→閾値判定） | 小図面での FP 削減 | 中 |
+| DFS+BFS Hybrid プロンプト | BPMN 論文で最有効。P&ID での検証が必要 | 中 |
+| Sonnet 4.6 との比較 | コスト 1/3 で精度差を測定 | 低 |
+
+## デモ
+
+Gradio ベースのインタ��クティブデモ。P&ID 画像をアップロード → VLM でグラフ構造を抽出 → 正解 graphml と比較 → スコア表示 + NetworkX でグラフ可視化。
+
+### 起動方法
+
+```bash
+git clone https://github.com/deepkick/pid2graph-vlm-eval.git
+cd pid2graph-vlm-eval
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+
+# .env に API キーを設定
+echo "ANTHROPIC_API_KEY=sk-ant-..." > .env
+
+# Gradio デモ起動
+python app.py
+# → http://127.0.0.1:7860
+```
+
+### CLI での評価実行
+
+```bash
+# 12 枚全件（single-shot）
+python -m pid2graph_eval.cli \
+    --image-dir "PID2Graph/Complete/PID2Graph OPEN100" \
+    --gt-dir "PID2Graph/Complete/PID2Graph OPEN100" \
+    --semantic-only --output results.json
+
+# タイル分割モード
+python -m pid2graph_eval.cli \
+    --image-dir "PID2Graph/Complete/PID2Graph OPEN100" \
+    --gt-dir "PID2Graph/Complete/PID2Graph OPEN100" \
+    --semantic-only --tiled --output results_tiled.json
+```
+
+## プロジェクト構成
+
+```
+pid2graph-vlm-eval/
+├── app.py                      # Gradio デモ UI
+├── requirements.txt
+├── .env                        # API キー（.gitignore 対象）
+├── pid2graph_eval/
+│   ├── schema.py               # Pydantic モデル（GraphOut）
+│   ├── gt_loader.py            # graphml → 正規化ノード/エッジ
+│   ├── extractor.py            # Claude API 呼び出し（single / tiled）
+│   ├── metrics.py              # P/R/F1 算出（ノード / エッジ）
+│   ├── tile.py                 # タイル分割・マージ・seam filter
+│   └── cli.py                  # CLI エントリポイント
+├── samples/                    # OPEN100 から 3 枚（small/medium/large）
+│   ├── open100_01_small.png
+│   ├── open100_01_small.graphml
+│   ├── open100_03_medium.png
+│   ├── open100_03_medium.graphml
+│   ├── open100_00_large.png
+│   └── open100_00_large.graphml
+└── results/                    # 評価結果 JSON
+```
+
+## 使用技術
+
+- **VLM:** Claude Opus 4.6（Anthropic API、構造化出力）
+- **評価データ:** PID2Graph OPEN100（CC BY-SA 4.0）
+- **ライブラリ:** NetworkX, Pydantic, Pillow, tqdm, Gradio, matplotlib
+- **開発環境:** Claude Code + VS Code（Dev Container）
+
+## 参考文献
+
+| 論文 | 手法 | URL |
+|------|------|-----|
+| Stürmer et al., 2025 — PID2Graph | Relationformer（End-to-End） | [arXiv:2411.13929](https://arxiv.org/abs/2411.13929) |
+| Ghosh et al., 2025 — VLM as a Judge | CV 検出 + VLM 品質評価 | [arXiv:2510.03376](https://arxiv.org/abs/2510.03376) |
+| Shteriyanov et al., 2025 | OCR + VLM + マルチモーダルプロンプト | [Wiley](https://onlinelibrary.wiley.com/doi/abs/10.1002/smr.70072) |
+| Deka & Devereux, 2026 — BPMN-VLM | VLM + OCR 補完 | [arXiv:2511.22448](https://arxiv.org/abs/2511.22448) |
+| Spies et al., 2025 — Arrow-Guided VLM | 物体検出 + VLM 推論 | [arXiv:2505.07864](https://arxiv.org/abs/2505.07864) |
+| Khan et al., 2024 | Florence-2 ファインチューニング | [arXiv:2411.03707](https://arxiv.org/abs/2411.03707) |
+| Shukla et al., 2024 — TextFlow | VLM → 構造化テキスト → LLM 推論 | [arXiv:2412.16420](https://arxiv.org/abs/2412.16420) |
+| Moon et al., 2021 | スケルトン化 + Hough 変換 | [MDPI](https://www.mdpi.com/2076-3417/11/21/10054) |
+| Goldstein et al., 2025 | P&ID → Neo4j 知識グラフ → RAG | [arXiv:2502.18928](https://arxiv.org/abs/2502.18928) |
+
+## License
+
+MIT

app.py

@@ -0,0 +1,449 @@
+"""Gradio demo: P&ID graph extraction with Claude VLM + evaluation.
+
+Usage (local):
+    ANTHROPIC_API_KEY=sk-ant-... python app.py
+
+Or put the key in a `.env` next to this file. The app:
+    1. Takes a P&ID image (preset or upload)
+    2. Runs extraction (optionally tiled 2x2) via Claude Opus 4.6
+    3. If a ground-truth graphml is provided, collapses it to semantic-only
+       form and computes node/edge P/R/F1 via `pid2graph_eval.metrics`
+    4. Draws both the prediction and the ground truth as NetworkX graphs
+       using bbox-based layouts so the topology matches the source image
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Optional
+
+# Matplotlib backend must be set before pyplot import for headless use;
+# the `matplotlib.use()` call below taints every subsequent import with
+# E402 ("module level import not at top of file"), which is expected here.
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.patches as mpatches  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+import networkx as nx  # noqa: E402
+
+import anthropic  # noqa: E402
+
+# ---------------------------------------------------------------------------
+# Gradio 4.44 / gradio_client 1.3.0 bug workaround
+# ---------------------------------------------------------------------------
+# At `/info` boot, Gradio walks every component's JSON schema via
+# `gradio_client.utils._json_schema_to_python_type`. That function does not
+# handle bool schemas (`additionalProperties: false` or `true`, both of which
+# are valid JSON Schema) — it recurses with the bool and then `if "const" in
+# schema:` on line 863 raises `TypeError: argument of type 'bool' is not
+# iterable`. Patch the function here before importing gradio so the crash is
+# avoided regardless of which component triggers it. (Fixed upstream in later
+# gradio_client releases; we stay on 4.44 because Python 3.9 can't run
+# gradio 5.) Harmless on versions where the bug is already fixed.
+import gradio_client.utils as _gc_utils  # noqa: E402
+
+_orig_json_schema_to_python_type = _gc_utils._json_schema_to_python_type
+
+
+def _patched_json_schema_to_python_type(schema, defs=None):  # type: ignore[override]
+    if isinstance(schema, bool):
+        # `True` means "any value is allowed"; `False` means "no value".
+        return "Any" if schema else "None"
+    return _orig_json_schema_to_python_type(schema, defs)
+
+
+_gc_utils._json_schema_to_python_type = _patched_json_schema_to_python_type
+
+import gradio as gr  # noqa: E402  (must come after the monkey-patch)
+from dotenv import load_dotenv  # noqa: E402
+
+from pid2graph_eval.extractor import (  # noqa: E402
+    DEFAULT_MODEL,
+    extract_graph,
+    extract_graph_tiled,
+)
+from pid2graph_eval.gt_loader import (  # noqa: E402
+    SEMANTIC_EQUIPMENT_TYPES,
+    collapse_through_primitives,
+    filter_by_types,
+    load_graphml,
+)
+from pid2graph_eval.metrics import evaluate  # noqa: E402
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+APP_ROOT = Path(__file__).parent
+SAMPLES_DIR = APP_ROOT / "samples"
+
+load_dotenv(APP_ROOT / ".env")
+
+# Presets: (display name) -> (image path, graphml path)
+PRESETS: dict[str, tuple[Path, Path]] = {
+    "OPEN100 #1 — small (27 semantic nodes)": (
+        SAMPLES_DIR / "open100_01_small.png",
+        SAMPLES_DIR / "open100_01_small.graphml",
+    ),
+    "OPEN100 #3 — medium (53 semantic nodes)": (
+        SAMPLES_DIR / "open100_03_medium.png",
+        SAMPLES_DIR / "open100_03_medium.graphml",
+    ),
+    "OPEN100 #0 — large (82 semantic nodes)": (
+        SAMPLES_DIR / "open100_00_large.png",
+        SAMPLES_DIR / "open100_00_large.graphml",
+    ),
+}
+
+NONE_LABEL = "(none — upload your own)"
+
+# Fixed palette so pred/GT visualizations use matching colors.
+TYPE_COLORS: dict[str, str] = {
+    "valve": "#ff6b6b",
+    "pump": "#4ecdc4",
+    "tank": "#ffd93d",
+    "instrumentation": "#6bcfff",
+    "inlet/outlet": "#c47bff",
+}
+
+LEGEND_HANDLES = [
+    mpatches.Patch(color=c, label=t) for t, c in TYPE_COLORS.items()
+]
+
+
+# ---------------------------------------------------------------------------
+# Visualization
+# ---------------------------------------------------------------------------
+
+def _bbox_to_xyxy(bbox) -> Optional[tuple[float, float, float, float]]:
+    """Normalize a bbox to `(xmin, ymin, xmax, ymax)` floats.
+
+    Accepts both shapes that flow through the pipeline:
+
+    * **list / tuple** `[x1, y1, x2, y2]` — produced by `gt_loader._bbox`
+      and by `tile.merge_tile_graphs` for the tiled pred path.
+    * **dict** `{"xmin": ..., "ymin": ..., "xmax": ..., "ymax": ...}` —
+      produced by `GraphOut.to_dict()` in single-shot mode, because the
+      Pydantic `BBox` model round-trips through `model_dump()`.
+
+    Returns `None` if the bbox is missing or malformed.
+    """
+    if bbox is None:
+        return None
+    if isinstance(bbox, dict):
+        try:
+            return (
+                float(bbox["xmin"]),
+                float(bbox["ymin"]),
+                float(bbox["xmax"]),
+                float(bbox["ymax"]),
+            )
+        except (KeyError, TypeError, ValueError):
+            return None
+    if isinstance(bbox, (list, tuple)) and len(bbox) == 4:
+        try:
+            return (
+                float(bbox[0]),
+                float(bbox[1]),
+                float(bbox[2]),
+                float(bbox[3]),
+            )
+        except (TypeError, ValueError):
+            return None
+    return None
+
+
+def draw_graph(graph_dict: dict, title: str, figsize=(8, 6)) -> plt.Figure:
+    """Render a graph as a matplotlib figure.
+
+    Node positions come from bbox centers when available (so the drawing
+    preserves the spatial layout of the original P&ID); nodes without a
+    bbox fall back to networkx spring layout.
+    """
+    fig, ax = plt.subplots(figsize=figsize, dpi=110)
+
+    G = nx.Graph()
+    pos: dict[str, tuple[float, float]] = {}
+    colors: list[str] = []
+    node_list: list[str] = []
+
+    for n in graph_dict.get("nodes", []):
+        nid = n["id"]
+        G.add_node(nid)
+        node_list.append(nid)
+        colors.append(TYPE_COLORS.get(n.get("type", ""), "#cccccc"))
+
+        coords = _bbox_to_xyxy(n.get("bbox"))
+        if coords is not None:
+            x1, y1, x2, y2 = coords
+            cx = (x1 + x2) / 2.0
+            cy = (y1 + y2) / 2.0
+            pos[nid] = (cx, -cy)  # flip y so the image is right-side up
+
+    for e in graph_dict.get("edges", []):
+        s, t = e.get("source"), e.get("target")
+        if s in G.nodes and t in G.nodes:
+            G.add_edge(s, t)
+
+    # Fall back to spring layout for any nodes that lack a bbox.
+    missing = [nid for nid in G.nodes if nid not in pos]
+    if missing:
+        if not pos:
+            pos = nx.spring_layout(G, seed=42)
+        else:
+            # Place missing nodes near the existing bbox cloud center.
+            xs = [p[0] for p in pos.values()]
+            ys = [p[1] for p in pos.values()]
+            cx0 = sum(xs) / len(xs)
+            cy0 = sum(ys) / len(ys)
+            for nid in missing:
+                pos[nid] = (cx0, cy0)
+
+    nx.draw_networkx_edges(G, pos, alpha=0.35, width=0.6, ax=ax)
+    nx.draw_networkx_nodes(
+        G, pos,
+        nodelist=node_list,
+        node_color=colors,
+        node_size=55,
+        linewidths=0.5,
+        edgecolors="#222",
+        ax=ax,
+    )
+
+    ax.set_title(title, fontsize=11)
+    ax.set_aspect("equal")
+    ax.axis("off")
+    ax.legend(handles=LEGEND_HANDLES, loc="lower right", fontsize=7, framealpha=0.9)
+    fig.tight_layout()
+    return fig
+
+
+# ---------------------------------------------------------------------------
+# Pipeline
+# ---------------------------------------------------------------------------
+
+def _preset_paths(preset_name: str) -> tuple[Optional[str], Optional[str]]:
+    """Resolve a preset dropdown selection to (image_path, graphml_path)."""
+    if preset_name == NONE_LABEL or preset_name not in PRESETS:
+        return None, None
+    img, gt = PRESETS[preset_name]
+    return (str(img) if img.exists() else None,
+            str(gt) if gt.exists() else None)
+
+
+def _format_metrics(metrics: dict, latency_s: float, mode: str) -> str:
+    nm = metrics["nodes"]
+    em = metrics["edges"]
+    return f"""
+### Metrics
+
+| | Precision | Recall | F1 | TP | FP | FN |
+|---|---:|---:|---:|---:|---:|---:|
+| **Nodes** | {nm['precision']:.3f} | {nm['recall']:.3f} | **{nm['f1']:.3f}** | {nm['tp']} | {nm['fp']} | {nm['fn']} |
+| **Edges** | {em['precision']:.3f} | {em['recall']:.3f} | **{em['f1']:.3f}** | {em['tp']} | {em['fp']} | {em['fn']} |
+
+- Pred: **{metrics['n_pred_nodes']}** ノード / **{metrics['n_pred_edges']}** エッジ
+- GT (semantic-collapsed): **{metrics['n_gt_nodes']}** ノード / **{metrics['n_gt_edges']}** エッジ
+- Mode: `{mode}` · Latency: **{latency_s:.1f}s**
+"""
+
+
+def _format_pred_only(pred_dict: dict, latency_s: float, mode: str) -> str:
+    return f"""
+### Prediction
+
+- **{len(pred_dict['nodes'])}** ノード / **{len(pred_dict['edges'])}** エッジ
+- Mode: `{mode}` · Latency: **{latency_s:.1f}s**
+- (正解 graphml 未指定のため評価スキップ)
+"""
+
+
+def run_extraction(
+    preset_name: str,
+    image_path: Optional[str],
+    gt_path: Optional[str],
+    use_tiling: bool,
+    progress: gr.Progress = gr.Progress(),
+) -> tuple[str, Optional[plt.Figure], Optional[plt.Figure], str]:
+    """Entry point wired to the Run button."""
+    # Preset overrides manual upload so the demo is reproducible.
+    preset_img, preset_gt = _preset_paths(preset_name)
+    if preset_img:
+        image_path = preset_img
+    if preset_gt:
+        gt_path = preset_gt
+
+    if not image_path:
+        return (
+            "⚠️ 画像をアップロードするか、プリセットを選択してください。",
+            None, None, "",
+        )
+
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        return (
+            "⚠️ `ANTHROPIC_API_KEY` が設定されていません。`.env` に追記して再起動してください。",
+            None, None, "",
+        )
+
+    client = anthropic.Anthropic()
+    mode = "tiled 2x2 + seam filter" if use_tiling else "single-shot"
+
+    try:
+        progress(0.05, desc=f"VLM 抽出開始 ({mode})…")
+        t0 = time.time()
+        if use_tiling:
+            pred_dict = extract_graph_tiled(
+                Path(image_path),
+                client=client,
+                rows=2,
+                cols=2,
+                overlap=0.1,
+                dedup_px=40.0,
+            )
+        else:
+            pred = extract_graph(Path(image_path), client=client)
+            pred_dict = pred.to_dict()
+        latency = time.time() - t0
+        progress(0.55, desc="予測を semantic types に絞り込み…")
+
+        # Defensive: drop anything non-semantic the VLM may have emitted.
+        pred_dict = filter_by_types(pred_dict, SEMANTIC_EQUIPMENT_TYPES)
+
+    except Exception as e:
+        return (f"❌ VLM 抽出中にエラー: `{e}`", None, None, "")
+
+    progress(0.65, desc="予測グラフを描画…")
+    pred_fig = draw_graph(
+        pred_dict,
+        title=f"Prediction — {len(pred_dict['nodes'])} nodes, {len(pred_dict['edges'])} edges",
+    )
+
+    gt_fig = None
+    metrics_md = _format_pred_only(pred_dict, latency, mode)
+
+    if gt_path and Path(gt_path).exists():
+        try:
+            progress(0.75, desc="GT graphml をロード & 縮約…")
+            gt_raw = load_graphml(Path(gt_path))
+            gt_dict = collapse_through_primitives(gt_raw, SEMANTIC_EQUIPMENT_TYPES)
+
+            progress(0.85, desc="P/R/F1 を評価…")
+            metrics = evaluate(
+                pred_dict,
+                gt_dict,
+                directed=False,
+                match_threshold=0.5,
+            )
+            metrics_md = _format_metrics(metrics, latency, mode)
+
+            progress(0.95, desc="GT グラフを描画…")
+            gt_fig = draw_graph(
+                gt_dict,
+                title=f"Ground Truth — {len(gt_dict['nodes'])} nodes, {len(gt_dict['edges'])} edges",
+            )
+        except Exception as e:
+            metrics_md += f"\n\n⚠️ GT 処理でエラー: `{e}`"
+
+    # Strip heavy-ish keys before JSON display.
+    display_dict = {
+        "nodes": pred_dict["nodes"],
+        "edges": pred_dict["edges"],
+    }
+    pred_json = json.dumps(display_dict, indent=2, ensure_ascii=False)
+
+    progress(1.0, desc="完了")
+    return metrics_md, pred_fig, gt_fig, pred_json
+
+
+def on_preset_change(preset_name: str):
+    """When a preset is picked, auto-fill the image and graphml fields."""
+    img, gt = _preset_paths(preset_name)
+    return img, gt
+
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+
+DESCRIPTION = """
+# PID2Graph × Claude VLM Demo
+
+P&ID (配管計装図) を Claude Opus 4.6 のビジョンで読み取り、シンボル（valve / pump /
+tank / instrumentation / inlet・outlet）とその接続関係を JSON グラフに変換します。
+正解 graphml を指定すると、ノード/エッジ単位の Precision / Recall / F1 を算出します。
+
+- **タイル分割 (2x2)**: 大きな図面では 1 枚を 4 タイルに分割してから抽出し、マージ時に
+  bbox 距離で重複排除 + タイル境界の inlet/outlet FP を後処理で除去します。
+- **評価ルール**: GT 側は semantic equipment のみを残し、配管プリミティブ (connector /
+  crossing / arrow / background) を経由する接続を 1 エッジに縮約します。
+- **VLM 設定**: `temperature=0` で決定論的サンプリング、構造化出力で JSON スキーマを強制。
+"""
+
+
+def build_ui() -> gr.Blocks:
+    with gr.Blocks(title="PID2Graph × Claude VLM Demo") as demo:
+        gr.Markdown(DESCRIPTION)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                preset = gr.Dropdown(
+                    choices=[NONE_LABEL] + list(PRESETS.keys()),
+                    value=NONE_LABEL,
+                    label="プリセット (OPEN100 より)",
+                )
+                image_in = gr.Image(
+                    type="filepath",
+                    label="P&ID 画像",
+                    height=260,
+                )
+                gt_in = gr.File(
+                    label="正解 graphml (任意)",
+                    file_types=[".graphml", ".xml"],
+                    type="filepath",
+                )
+                tiling = gr.Checkbox(
+                    value=True,
+                    label="タイル分割 (2x2) で抽出  — 高精度だがコスト・時間 4 倍",
+                )
+                run_btn = gr.Button("抽出実行", variant="primary")
+                gr.Markdown(
+                    "モデル: `" + DEFAULT_MODEL + "` · 所要時間目安: single ~20s / tiled ~60-80s"
+                )
+
+            with gr.Column(scale=2):
+                metrics_md = gr.Markdown()
+                with gr.Row():
+                    pred_plot = gr.Plot(label="Prediction")
+                    gt_plot = gr.Plot(label="Ground Truth")
+                with gr.Accordion("予測 JSON (nodes / edges)", open=False):
+                    # NOTE: using Textbox rather than `gr.Code(language="json")`
+                    # because the latter's schema has tripped the gradio_client
+                    # `additionalProperties: false` bug on 4.44.1 in the past.
+                    # Textbox is a plain string component — zero schema surface.
+                    pred_json = gr.Textbox(
+                        label="",
+                        lines=20,
+                        max_lines=30,
+                        show_copy_button=True,
+                        interactive=False,
+                    )
+
+        preset.change(on_preset_change, inputs=[preset], outputs=[image_in, gt_in])
+        run_btn.click(
+            run_extraction,
+            inputs=[preset, image_in, gt_in, tiling],
+            outputs=[metrics_md, pred_plot, gt_plot, pred_json],
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    # `show_api=False` hides the docs panel in the UI; the monkey-patch
+    # at the top of this file is what actually prevents the 4.44 crash,
+    # but disabling the docs is cheap defense-in-depth.
+    build_ui().launch(show_api=False)

pid2graph_eval/__init__.py

@@ -0,0 +1 @@
+"""PID2Graph evaluation toolkit: VLM extraction + graph metrics."""

pid2graph_eval/cli.py

@@ -0,0 +1,299 @@
+"""CLI entrypoint for the PID2Graph evaluation skeleton.
+
+Usage:
+    python -m pid2graph_eval.cli \
+        --image-dir path/to/images \
+        --gt-dir path/to/graphml \
+        --output results.json \
+        --limit 10
+
+The loader pairs each image with the graphml of the same stem
+(`A-001.png` ↔ `A-001.graphml`). Adjust `pair_samples` once you know the
+actual PID2Graph on-disk layout.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import anthropic
+from tqdm import tqdm
+
+from .extractor import (
+    DEFAULT_MAX_TOKENS,
+    DEFAULT_MODEL,
+    extract_graph,
+    extract_graph_tiled,
+)
+from .gt_loader import (
+    SEMANTIC_EQUIPMENT_TYPES,
+    collapse_through_primitives,
+    filter_by_types,
+    load_graphml,
+    summarize,
+)
+from .metrics import aggregate, evaluate
+
+IMAGE_EXTS = (".png", ".jpg", ".jpeg", ".webp")
+GT_EXTS = (".graphml", ".xml")
+
+
+def pair_samples(image_dir: Path, gt_dir: Path) -> list[tuple[Path, Path]]:
+    """Match each image to a graphml file by filename stem."""
+    gt_by_stem: dict[str, Path] = {}
+    for ext in GT_EXTS:
+        for p in gt_dir.rglob(f"*{ext}"):
+            gt_by_stem[p.stem] = p
+
+    pairs: list[tuple[Path, Path]] = []
+    for ext in IMAGE_EXTS:
+        for img in sorted(image_dir.rglob(f"*{ext}")):
+            gt = gt_by_stem.get(img.stem)
+            if gt is not None:
+                pairs.append((img, gt))
+    return pairs
+
+
+def run(args: argparse.Namespace) -> int:
+    image_dir = Path(args.image_dir)
+    gt_dir = Path(args.gt_dir)
+    output = Path(args.output)
+
+    if not image_dir.exists():
+        print(f"error: --image-dir does not exist: {image_dir}", file=sys.stderr)
+        return 2
+    if not gt_dir.exists():
+        print(f"error: --gt-dir does not exist: {gt_dir}", file=sys.stderr)
+        return 2
+
+    pairs = pair_samples(image_dir, gt_dir)
+    if args.limit:
+        pairs = pairs[: args.limit]
+    if not pairs:
+        print("error: no (image, graphml) pairs found — check stems match", file=sys.stderr)
+        return 1
+    print(f"found {len(pairs)} sample pair(s)")
+
+    client = anthropic.Anthropic()
+    per_sample: list[dict] = []
+    errors: list[dict] = []
+
+    for image_path, gt_path in tqdm(pairs, desc="eval"):
+        try:
+            gt_graph = load_graphml(gt_path)
+        except Exception as e:  # parsing a single bad file shouldn't kill the run
+            errors.append({"sample": image_path.stem, "stage": "gt_load", "error": str(e)})
+            continue
+
+        # Semantic-only mode: drop line-primitive nodes from the GT and
+        # re-wire the remaining semantic nodes via the original pipe
+        # connectivity (BFS through primitives). This matches the format
+        # the VLM is instructed to emit — one direct edge per physical
+        # pipeline, regardless of how many junctions it passes through.
+        if args.semantic_only:
+            gt_graph = collapse_through_primitives(gt_graph, SEMANTIC_EQUIPMENT_TYPES)
+
+        if args.dry_run:
+            per_sample.append(
+                {
+                    "sample": image_path.stem,
+                    "gt_summary": summarize(gt_graph),
+                }
+            )
+            continue
+
+        try:
+            if args.tile_rows > 1 or args.tile_cols > 1:
+                pred_dict = extract_graph_tiled(
+                    image_path,
+                    client=client,
+                    model=args.model,
+                    max_tokens=args.max_tokens,
+                    rows=args.tile_rows,
+                    cols=args.tile_cols,
+                    overlap=args.tile_overlap,
+                    dedup_px=args.dedup_px,
+                    seam_filter=not args.no_seam_filter,
+                    seam_threshold=args.seam_threshold_px,
+                    edge_threshold=args.edge_threshold_px,
+                )
+            else:
+                pred = extract_graph(
+                    image_path,
+                    client=client,
+                    model=args.model,
+                    max_tokens=args.max_tokens,
+                )
+                pred_dict = pred.to_dict()
+        except Exception as e:
+            errors.append({"sample": image_path.stem, "stage": "vlm", "error": str(e)})
+            continue
+
+        if args.semantic_only:
+            pred_dict = filter_by_types(
+                {**pred_dict, "directed": gt_graph.get("directed", False)},
+                SEMANTIC_EQUIPMENT_TYPES,
+            )
+
+        # Default to whatever the GT file says; allow CLI override.
+        if args.force_undirected:
+            directed = False
+        elif args.force_directed:
+            directed = True
+        else:
+            directed = gt_graph.get("directed", True)
+
+        metrics = evaluate(
+            pred_dict,
+            gt_graph,
+            directed=directed,
+            match_threshold=args.match_threshold,
+        )
+        per_sample.append(
+            {
+                "sample": image_path.stem,
+                "metrics": metrics,
+                "pred": pred_dict,
+                "gt_summary": summarize(gt_graph),
+            }
+        )
+
+    result: dict = {
+        "config": {
+            "model": args.model,
+            "max_tokens": args.max_tokens,
+            "directed": (
+                False if args.force_undirected
+                else True if args.force_directed
+                else "auto"
+            ),
+            "semantic_only": args.semantic_only,
+            "match_threshold": args.match_threshold,
+            "tile_rows": args.tile_rows,
+            "tile_cols": args.tile_cols,
+            "tile_overlap": args.tile_overlap,
+            "dedup_px": args.dedup_px,
+            "seam_filter": not args.no_seam_filter,
+            "seam_threshold_px": args.seam_threshold_px,
+            "edge_threshold_px": args.edge_threshold_px,
+            "limit": args.limit,
+            "dry_run": args.dry_run,
+        },
+        "per_sample": per_sample,
+        "errors": errors,
+    }
+    if not args.dry_run and per_sample:
+        result["aggregate"] = aggregate([s["metrics"] for s in per_sample if "metrics" in s])
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(result, indent=2, ensure_ascii=False))
+    print(f"wrote {output}")
+    if "aggregate" in result:
+        agg = result["aggregate"]
+        print(
+            f"  nodes  F1={agg['nodes_micro']['f1']:.3f}  "
+            f"P={agg['nodes_micro']['precision']:.3f}  "
+            f"R={agg['nodes_micro']['recall']:.3f}"
+        )
+        print(
+            f"  edges  F1={agg['edges_micro']['f1']:.3f}  "
+            f"P={agg['edges_micro']['precision']:.3f}  "
+            f"R={agg['edges_micro']['recall']:.3f}"
+        )
+    if errors:
+        print(f"  {len(errors)} error(s) — see `errors` in output JSON")
+    return 0
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="PID2Graph VLM evaluation skeleton")
+    p.add_argument("--image-dir", required=True, help="Directory containing P&ID images")
+    p.add_argument("--gt-dir", required=True, help="Directory containing graphml ground truth")
+    p.add_argument("--output", default="results.json", help="Where to write the JSON report")
+    p.add_argument("--model", default=DEFAULT_MODEL, help=f"Claude model id (default: {DEFAULT_MODEL})")
+    p.add_argument(
+        "--max-tokens",
+        type=int,
+        default=DEFAULT_MAX_TOKENS,
+        help=f"VLM max output tokens (default: {DEFAULT_MAX_TOKENS}, streamed)",
+    )
+    p.add_argument("--limit", type=int, default=0, help="Only process the first N samples (0 = all)")
+    p.add_argument("--match-threshold", type=float, default=0.5, help="Node similarity threshold")
+    p.add_argument(
+        "--semantic-only",
+        action="store_true",
+        help=(
+            "Restrict both prediction and GT to semantic equipment "
+            "(valve, pump, tank, instrumentation, inlet/outlet); "
+            "drops pipe-primitive nodes like connector/crossing/arrow."
+        ),
+    )
+    p.add_argument(
+        "--tile-rows",
+        type=int,
+        default=1,
+        help="Tile the image into this many rows before VLM extraction (default 1 = off)",
+    )
+    p.add_argument(
+        "--tile-cols",
+        type=int,
+        default=1,
+        help="Tile the image into this many columns before VLM extraction (default 1 = off)",
+    )
+    p.add_argument(
+        "--tile-overlap",
+        type=float,
+        default=0.1,
+        help="Fractional overlap between adjacent tiles (default 0.1 = 10%%)",
+    )
+    p.add_argument(
+        "--dedup-px",
+        type=float,
+        default=40.0,
+        help="Bbox-center distance (pixels) under which two same-type nodes are merged",
+    )
+    p.add_argument(
+        "--no-seam-filter",
+        action="store_true",
+        help=(
+            "Disable the inlet/outlet tile-seam FP filter. By default, "
+            "tiled extraction drops inlet/outlet nodes whose bbox center "
+            "sits within 50px of an inner tile seam and is not within "
+            "30px of the outer image border."
+        ),
+    )
+    p.add_argument(
+        "--seam-threshold-px",
+        type=float,
+        default=50.0,
+        help="Distance (px) from an inner tile seam that triggers FP filtering",
+    )
+    p.add_argument(
+        "--edge-threshold-px",
+        type=float,
+        default=30.0,
+        help="Distance (px) from the outer image edge that exempts a node from filtering",
+    )
+    p.add_argument(
+        "--force-undirected",
+        action="store_true",
+        help="Force undirected edge matching (default: use whatever the GT file says)",
+    )
+    p.add_argument(
+        "--force-directed",
+        action="store_true",
+        help="Force directed edge matching (default: use whatever the GT file says)",
+    )
+    p.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Skip VLM calls; just load GT and print summaries (for loader debugging)",
+    )
+    return run(p.parse_args())
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pid2graph_eval/extractor.py

@@ -0,0 +1,299 @@
+"""Claude VLM-based P&ID graph extraction.
+
+Uses the Anthropic SDK with:
+- Vision input (base64-encoded P&ID image)
+- Streaming (required for high `max_tokens` to avoid HTTP timeouts)
+- Structured outputs via `output_config.format={"type": "json_schema", ...}`
+  so the model is forced to return our Pydantic schema
+- Prompt caching on the (stable) system prompt so repeated evaluation runs
+  only pay full price once per 5-minute window
+
+Public API:
+    extract_graph(image_path, client=None, model="claude-opus-4-6") -> GraphOut
+    extract_graph_tiled(image_path, ..., rows=2, cols=2) -> dict
+
+The tiled variant splits the image into overlapping tiles, runs the VLM
+on each, and merges the results using bbox-distance deduplication. Used
+to break the ~50-symbol recall ceiling on large diagrams.
+
+Note on scope (semantic-only mode):
+    This prompt intentionally excludes PID2Graph's line-level primitives
+    (connector, crossing, arrow, background, general). It targets only
+    the five semantic equipment categories the VLM can recognize. The
+    matching CLI flag `--semantic-only` filters the ground truth to the
+    same five categories so P/R/F1 are comparable.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+from pathlib import Path
+from typing import Optional
+
+import anthropic
+
+from .schema import GraphOut
+from .tile import (
+    Tile,
+    filter_seam_artifacts,
+    merge_tile_graphs,
+    split_image,
+    tile_to_base64_png,
+)
+
+DEFAULT_MODEL = "claude-opus-4-6"
+DEFAULT_MAX_TOKENS = 64000  # streaming is required at this size
+DEFAULT_TEMPERATURE = 0.0  # deterministic sampling — kills run-to-run variance
+
+SYSTEM_PROMPT = """\
+You are an expert annotator for the PID2Graph benchmark, which turns
+Piping and Instrumentation Diagrams (P&IDs) into node/edge graphs.
+
+Your task: given a P&ID image (which may be a full diagram or a cropped
+region of one), emit every SEMANTIC EQUIPMENT symbol visible as a node,
+and every pipeline connection between two such symbols as an edge.
+Line-level primitives (pipe junctions, crossings, arrowheads, background
+regions) must NOT be emitted.
+
+NODE CATEGORIES — use EXACTLY one of these 5 lowercase labels for `type`:
+
+  - valve             all valve bodies: gate, ball, check, control, globe,
+                      butterfly, needle, etc. Each valve body is one node.
+  - pump              pumps and compressors (rotating equipment)
+  - tank              storage tanks, drums, vessels, columns, reactors,
+                      heat exchangers, any large process equipment
+  - instrumentation   circle/balloon instrument bubbles (PI, TI, FIC, TC,
+                      LT, PDT, ...). Each bubble is one node.
+  - inlet/outlet      diagram boundary terminals where a pipe enters or
+                      leaves the drawing. Use the literal string with a
+                      slash: "inlet/outlet".
+
+Do not invent other type names. Do not use synonyms. Do not use title case.
+Do not emit connector, crossing, arrow, background, or general — those
+are excluded from this task. If a drawn glyph does not clearly fit one of
+the five categories above, skip it.
+
+PER-NODE FIELDS:
+  id     unique id within THIS response, e.g. "n1", "n2", "n3", ...
+  type   one of the 5 labels above
+  label  leave null — PID2Graph ground truth does not store printed tags
+  bbox   REQUIRED. An object {xmin, ymin, xmax, ymax} with each coordinate
+         normalized to [0.0, 1.0] relative to the image you are shown.
+         (0, 0) is the top-left corner, (1, 1) is the bottom-right. Give
+         your best estimate of the symbol's tight bounding box. If you
+         cannot estimate it, still emit a best-effort box — never omit
+         the field and never return null.
+
+EDGES — edges in PID2Graph are UNDIRECTED. Emit an edge whenever two of
+the semantic nodes above are joined by a continuous pipeline, even if
+that pipeline passes through several pipe junctions, crossings, or
+arrowheads on its way. Those intermediate points must not appear as
+nodes; collapse the whole physical pipeline into a single direct edge
+between its two semantic endpoints.
+
+PER-EDGE FIELDS:
+  source / target  node ids from the `nodes` list
+  type             use "solid"
+  label            null
+
+Guidelines:
+  * Be exhaustive within the semantic scope.
+  * Ignore the title block, legend, border, and revision history.
+  * If the image is a cropped region (e.g. one tile of a larger diagram),
+    only emit symbols and edges visible within this crop. Do not infer
+    connections that continue off-crop — another tile will cover them.
+  * Return ONLY the JSON object matching the schema — no prose, no markdown.
+"""
+
+USER_INSTRUCTION = (
+    "Extract the semantic-equipment graph from this P&ID image as JSON. "
+    "Only the 5 categories listed in the instructions — no pipe primitives. "
+    "Include a bbox (normalized [0, 1]) for every node."
+)
+
+
+def _guess_media_type(path: Path) -> str:
+    ext = path.suffix.lower()
+    return {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".webp": "image/webp",
+    }.get(ext, "image/png")
+
+
+def _load_image_b64(path: Path) -> tuple[str, str]:
+    data = base64.standard_b64encode(path.read_bytes()).decode("utf-8")
+    return data, _guess_media_type(path)
+
+
+def _graphout_schema() -> dict:
+    """JSON schema for GraphOut, ready for `output_config.format`."""
+    return GraphOut.model_json_schema()
+
+
+def _call_vlm(
+    image_data: str,
+    media_type: str,
+    client: anthropic.Anthropic,
+    model: str,
+    max_tokens: int,
+    tag: str,
+    temperature: float = DEFAULT_TEMPERATURE,
+) -> GraphOut:
+    """Shared VLM request path used by both whole-image and tile extraction.
+
+    `tag` is a short human-readable identifier (filename, tile name) used
+    only to make error messages point at the right sample.
+
+    `temperature=0.0` by default for reproducible evaluation runs.
+    """
+    schema = _graphout_schema()
+
+    with client.messages.stream(
+        model=model,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        system=[
+            {
+                "type": "text",
+                "text": SYSTEM_PROMPT,
+                "cache_control": {"type": "ephemeral"},
+            }
+        ],
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": media_type,
+                            "data": image_data,
+                        },
+                    },
+                    {"type": "text", "text": USER_INSTRUCTION},
+                ],
+            }
+        ],
+        output_config={
+            "format": {
+                "type": "json_schema",
+                "schema": schema,
+            }
+        },
+    ) as stream:
+        final = stream.get_final_message()
+
+    if final.stop_reason == "refusal":
+        raise RuntimeError(f"VLM refused to answer for {tag} (stop_reason=refusal)")
+    if final.stop_reason == "max_tokens":
+        raise RuntimeError(
+            f"VLM hit max_tokens={max_tokens} for {tag} — "
+            f"output truncated; raise max_tokens or simplify the prompt"
+        )
+
+    text_block = next((b for b in final.content if b.type == "text"), None)
+    if text_block is None:
+        raise RuntimeError(
+            f"VLM emitted no text block for {tag} (stop_reason={final.stop_reason})"
+        )
+
+    try:
+        data = json.loads(text_block.text)
+    except json.JSONDecodeError as e:
+        raise RuntimeError(
+            f"VLM output is not valid JSON for {tag}: {e}\n"
+            f"first 500 chars: {text_block.text[:500]}"
+        )
+
+    return GraphOut.model_validate(data)
+
+
+def extract_graph(
+    image_path: Path,
+    client: Optional[anthropic.Anthropic] = None,
+    model: str = DEFAULT_MODEL,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+) -> GraphOut:
+    """Run the VLM on the whole image and return the parsed graph."""
+    client = client or anthropic.Anthropic()
+    image_path = Path(image_path)
+    image_data, media_type = _load_image_b64(image_path)
+    return _call_vlm(
+        image_data, media_type, client, model, max_tokens,
+        image_path.name, temperature=temperature,
+    )
+
+
+def extract_graph_tiled(
+    image_path: Path,
+    client: Optional[anthropic.Anthropic] = None,
+    model: str = DEFAULT_MODEL,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+    rows: int = 2,
+    cols: int = 2,
+    overlap: float = 0.1,
+    dedup_px: float = 40.0,
+    seam_filter: bool = True,
+    seam_filter_types: tuple[str, ...] = ("inlet/outlet",),
+    seam_threshold: float = 50.0,
+    edge_threshold: float = 30.0,
+) -> dict:
+    """Tile the image, extract each tile, merge via bbox-distance dedup.
+
+    Returns a plain dict (not a GraphOut) because merged nodes carry
+    extra `bbox` (in global pixel coordinates) and `source_tiles` fields
+    that don't fit the response schema. The dict shape is still
+    compatible with `metrics.evaluate()`.
+
+    Deduplication rules:
+      * Two nodes from different tiles are merged iff they share the
+        same `type` AND their bbox centers are within `dedup_px` pixels
+        in the un-tiled global image.
+      * Nodes with a null bbox are dropped (they can't be deduped).
+      * Edges are remapped through the merge map; undirected duplicates
+        are collapsed; self-loops (both endpoints merged to the same
+        global node) are dropped.
+    """
+    client = client or anthropic.Anthropic()
+    image_path = Path(image_path)
+    tiles: list[Tile] = split_image(image_path, rows=rows, cols=cols, overlap=overlap)
+
+    per_tile: list[tuple[GraphOut, Tile]] = []
+    for tile in tiles:
+        image_data, media_type = tile_to_base64_png(tile)
+        tag = f"{image_path.name}:{tile.name}"
+        graph = _call_vlm(
+            image_data, media_type, client, model, max_tokens,
+            tag, temperature=temperature,
+        )
+        per_tile.append((graph, tile))
+
+    merged = merge_tile_graphs(per_tile, dedup_px=dedup_px)
+
+    if seam_filter:
+        merged = filter_seam_artifacts(
+            merged,
+            tiles,
+            types=seam_filter_types,
+            seam_threshold=seam_threshold,
+            edge_threshold=edge_threshold,
+        )
+
+    # Attach provenance for downstream debugging / aggregation.
+    merged["tile_stats"] = [
+        {
+            "tile": tile.name,
+            "n_nodes": len(graph.nodes),
+            "n_edges": len(graph.edges),
+            "nodes_with_bbox": sum(1 for n in graph.nodes if n.bbox is not None),
+        }
+        for graph, tile in per_tile
+    ]
+    return merged

pid2graph_eval/gt_loader.py

@@ -0,0 +1,237 @@
+"""Load PID2Graph ground-truth graphml files and normalize to the common schema.
+
+PID2Graph OPEN100 schema (observed):
+    node attrs: label (category), xmin, xmax, ymin, ymax (bounding box)
+    edge attrs: edge_label (only 'solid' observed)
+    graph:      undirected
+
+Ten node categories are used across the dataset:
+    connector, crossing, arrow, instrumentation, valve, general,
+    inlet/outlet, background, tank, pump
+
+There are no printed tags (like "P-101") in the graphml — PID2Graph is a
+pure symbol + connectivity benchmark, not an OCR benchmark. The `label`
+field in our normalized dict is therefore always None for this dataset
+and metrics fall back to type-only matching.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable, Optional
+
+import networkx as nx
+
+# The PID2Graph graphml files store the category under `label`. Kept as a
+# tuple so other graphml-based datasets with different conventions can be
+# supported by extending the candidate list.
+NODE_TYPE_KEYS: tuple[str, ...] = ("label", "type", "category", "class")
+EDGE_TYPE_KEYS: tuple[str, ...] = ("edge_label", "type", "category")
+
+# The official PID2Graph OPEN100 categories. Exposed so extractor.py can
+# put them straight into the VLM prompt.
+PID2GRAPH_NODE_TYPES: tuple[str, ...] = (
+    "connector",
+    "crossing",
+    "arrow",
+    "instrumentation",
+    "valve",
+    "general",
+    "inlet/outlet",
+    "background",
+    "tank",
+    "pump",
+)
+
+# The subset used by the "semantic-only" evaluation mode: real equipment
+# and instrument symbols, excluding line-level primitives (connector /
+# crossing / arrow / background) AND the `general` catch-all, whose
+# shape definition is too vague for zero-shot VLM detection to handle.
+SEMANTIC_EQUIPMENT_TYPES: frozenset[str] = frozenset(
+    {
+        "valve",
+        "pump",
+        "tank",
+        "instrumentation",
+        "inlet/outlet",
+    }
+)
+
+
+def _norm_type(t: Optional[str]) -> str:
+    return (t or "").strip().lower()
+
+
+def filter_by_types(graph: dict, allowed: frozenset[str]) -> dict:
+    """Return a copy of `graph` keeping only nodes whose type is in `allowed`.
+
+    Edges are kept only when BOTH endpoints survive the filter. All
+    non-{nodes, edges} keys (e.g. `directed`, `tile_stats`,
+    `seam_filtered`) are passed through unchanged so downstream code
+    can still inspect provenance.
+    """
+    keep_ids: set[str] = set()
+    new_nodes: list[dict] = []
+    for n in graph["nodes"]:
+        if _norm_type(n.get("type")) in allowed:
+            keep_ids.add(n["id"])
+            new_nodes.append(n)
+
+    new_edges = [
+        e
+        for e in graph["edges"]
+        if e["source"] in keep_ids and e["target"] in keep_ids
+    ]
+
+    out = dict(graph)
+    out["nodes"] = new_nodes
+    out["edges"] = new_edges
+    return out
+
+
+def collapse_through_primitives(graph: dict, semantic_types: frozenset[str]) -> dict:
+    """Keep only semantic nodes; re-wire edges by walking through primitives.
+
+    Two semantic nodes are connected in the result iff there is a path
+    between them in the original graph consisting of zero or more
+    NON-semantic nodes (e.g. `connector`, `crossing`, `arrow`). This
+    matches what the VLM is asked to produce: one direct semantic-to-
+    semantic edge per physical pipeline, regardless of how many pipe
+    junctions it passes through.
+
+    The resulting graph is always treated as undirected — PID2Graph's
+    underlying graphml is undirected and path-based equivalence has no
+    natural orientation.
+    """
+    sem_ids: set[str] = {
+        n["id"] for n in graph["nodes"] if _norm_type(n.get("type")) in semantic_types
+    }
+
+    # Undirected adjacency for the full graph
+    adj: dict[str, list[str]] = {n["id"]: [] for n in graph["nodes"]}
+    for e in graph["edges"]:
+        s, t = e["source"], e["target"]
+        if s in adj and t in adj:
+            adj[s].append(t)
+            adj[t].append(s)
+
+    new_edges: set[tuple[str, str]] = set()
+
+    # BFS from each semantic node through primitive nodes; whenever we
+    # land on another semantic node, record the edge and stop expanding
+    # past it. Visiting primitives multiple times from different
+    # starting points is fine; the edge-set deduplicates results.
+    for start in sem_ids:
+        visited = {start}
+        stack: list[str] = [start]
+        while stack:
+            cur = stack.pop()
+            for nb in adj.get(cur, ()):
+                if nb in visited:
+                    continue
+                visited.add(nb)
+                if nb in sem_ids:
+                    a, b = sorted((start, nb))
+                    new_edges.add((a, b))
+                    # Don't recurse past a semantic boundary.
+                else:
+                    stack.append(nb)
+
+    new_nodes = [n for n in graph["nodes"] if n["id"] in sem_ids]
+    new_edges_list = [
+        {
+            "source": a,
+            "target": b,
+            "type": "solid",
+            "label": None,
+            "raw_attrs": {},
+        }
+        for a, b in sorted(new_edges)
+    ]
+
+    return {
+        "nodes": new_nodes,
+        "edges": new_edges_list,
+        "directed": False,
+    }
+
+
+def _first_attr(attrs: dict, keys: Iterable[str]) -> Optional[str]:
+    for k in keys:
+        v = attrs.get(k)
+        if v is None:
+            continue
+        s = str(v).strip()
+        if s:
+            return s
+    return None
+
+
+def _bbox(attrs: dict) -> Optional[list[float]]:
+    try:
+        return [
+            float(attrs["xmin"]),
+            float(attrs["ymin"]),
+            float(attrs["xmax"]),
+            float(attrs["ymax"]),
+        ]
+    except (KeyError, TypeError, ValueError):
+        return None
+
+
+def load_graphml(path: Path) -> dict:
+    """Parse a graphml file into `{nodes, edges, directed}`.
+
+    Each node/edge keeps its original attributes under `raw_attrs` so
+    experiments can try alternative fields without re-reading the file.
+    """
+    G = nx.read_graphml(path)
+
+    nodes: list[dict] = []
+    for node_id, attrs in G.nodes(data=True):
+        nodes.append(
+            {
+                "id": str(node_id),
+                "type": _first_attr(attrs, NODE_TYPE_KEYS) or "",
+                "label": None,  # PID2Graph has no printed tag in GT
+                "bbox": _bbox(attrs),
+                "raw_attrs": dict(attrs),
+            }
+        )
+
+    edges: list[dict] = []
+    for u, v, attrs in G.edges(data=True):
+        edges.append(
+            {
+                "source": str(u),
+                "target": str(v),
+                "type": _first_attr(attrs, EDGE_TYPE_KEYS),
+                "label": None,
+                "raw_attrs": dict(attrs),
+            }
+        )
+
+    return {
+        "nodes": nodes,
+        "edges": edges,
+        "directed": G.is_directed(),
+    }
+
+
+def summarize(graph: dict) -> dict:
+    """Quick stats for sanity-checking the loader on a new dataset."""
+    type_counts: dict[str, int] = {}
+    for n in graph["nodes"]:
+        t = n["type"] or "<empty>"
+        type_counts[t] = type_counts.get(t, 0) + 1
+    edge_type_counts: dict[str, int] = {}
+    for e in graph["edges"]:
+        t = e["type"] or "<empty>"
+        edge_type_counts[t] = edge_type_counts.get(t, 0) + 1
+    return {
+        "n_nodes": len(graph["nodes"]),
+        "n_edges": len(graph["edges"]),
+        "directed": graph.get("directed", False),
+        "node_types": type_counts,
+        "edge_types": edge_type_counts,
+    }

pid2graph_eval/metrics.py

@@ -0,0 +1,145 @@
+"""Graph-level evaluation: node matching, then edge matching, then P/R/F1.
+
+Matching strategy (skeleton — greedy by descending similarity):
+  1. Score every (predicted_node, gt_node) pair with `node_similarity`.
+  2. Greedily pick the highest-scoring pair until no pair clears the
+     threshold or all nodes on one side are consumed.
+  3. Map predicted edges through the resulting id alignment and intersect
+     with GT edges. Undirected matching is optional.
+
+TODO: swap greedy for Hungarian (scipy.optimize.linear_sum_assignment)
+      once we have a feel for the data. Greedy is good enough for a first
+      pass and keeps dependencies small.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+def _norm(s: Optional[str]) -> str:
+    return (s or "").strip().lower().replace("-", "_").replace(" ", "_")
+
+
+def node_similarity(pred: dict, gt: dict) -> float:
+    """Score a predicted node against a GT node in [0, 1].
+
+    Both `type` match and `label` match contribute. If either side has no
+    label, we fall back to type-only matching.
+    """
+    tp, tg = _norm(pred.get("type")), _norm(gt.get("type"))
+    lp, lg = _norm(pred.get("label")), _norm(gt.get("label"))
+
+    type_match = 1.0 if tp and tp == tg else 0.0
+
+    if lp and lg:
+        label_match = 1.0 if lp == lg else 0.0
+        return 0.5 * type_match + 0.5 * label_match
+
+    # Only one side (or neither) has a label — rely on type alone.
+    return type_match
+
+
+def match_nodes(
+    pred_nodes: list[dict],
+    gt_nodes: list[dict],
+    threshold: float = 0.5,
+) -> dict[str, str]:
+    """Greedy 1:1 matching. Returns `{pred_id: gt_id}` for matched pairs."""
+    scored: list[tuple[float, str, str]] = []
+    for p in pred_nodes:
+        for g in gt_nodes:
+            s = node_similarity(p, g)
+            if s >= threshold:
+                scored.append((s, p["id"], g["id"]))
+    scored.sort(reverse=True)
+
+    matches: dict[str, str] = {}
+    used_gt: set[str] = set()
+    for _score, pid, gid in scored:
+        if pid in matches or gid in used_gt:
+            continue
+        matches[pid] = gid
+        used_gt.add(gid)
+    return matches
+
+
+def _prf(tp: int, fp: int, fn: int) -> dict:
+    precision = tp / (tp + fp) if (tp + fp) else 0.0
+    recall = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) else 0.0
+    return {
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+        "tp": tp,
+        "fp": fp,
+        "fn": fn,
+    }
+
+
+def evaluate(pred: dict, gt: dict, directed: bool = True, match_threshold: float = 0.5) -> dict:
+    """Compare a single predicted graph against a single GT graph.
+
+    Args:
+        pred: `{nodes, edges}` as emitted by `GraphOut.to_dict()`.
+        gt:   `{nodes, edges}` as emitted by `gt_loader.load_graphml()`.
+        directed: if False, (u, v) and (v, u) are treated as the same edge.
+        match_threshold: minimum similarity to accept a node pairing.
+
+    Returns:
+        Dict with `nodes`, `edges`, and `n_matched_nodes` keys.
+    """
+    # --- nodes ------------------------------------------------------------
+    node_map = match_nodes(pred["nodes"], gt["nodes"], threshold=match_threshold)
+    tp_n = len(node_map)
+    fp_n = len(pred["nodes"]) - tp_n
+    fn_n = len(gt["nodes"]) - tp_n
+    node_metrics = _prf(tp_n, fp_n, fn_n)
+
+    # --- edges ------------------------------------------------------------
+    # Translate predicted edges through the node alignment. Unmatched
+    # endpoints make the edge uncountable (it becomes a guaranteed FP).
+    def canon(u: str, v: str) -> tuple[str, str]:
+        return (u, v) if directed else tuple(sorted((u, v)))  # type: ignore[return-value]
+
+    pred_edges_canon: set[tuple[str, str]] = set()
+    unmappable_pred_edges = 0
+    for e in pred["edges"]:
+        if e["source"] in node_map and e["target"] in node_map:
+            pred_edges_canon.add(canon(node_map[e["source"]], node_map[e["target"]]))
+        else:
+            unmappable_pred_edges += 1
+
+    gt_edges_canon: set[tuple[str, str]] = set(
+        canon(e["source"], e["target"]) for e in gt["edges"]
+    )
+
+    tp_e = len(pred_edges_canon & gt_edges_canon)
+    fp_e = (len(pred_edges_canon) - tp_e) + unmappable_pred_edges
+    fn_e = len(gt_edges_canon) - tp_e
+    edge_metrics = _prf(tp_e, fp_e, fn_e)
+
+    return {
+        "nodes": node_metrics,
+        "edges": edge_metrics,
+        "n_pred_nodes": len(pred["nodes"]),
+        "n_gt_nodes": len(gt["nodes"]),
+        "n_pred_edges": len(pred["edges"]),
+        "n_gt_edges": len(gt["edges"]),
+    }
+
+
+def aggregate(per_sample: list[dict]) -> dict:
+    """Micro-average across samples by summing TP/FP/FN."""
+    def sum_keys(metric: str) -> dict:
+        tp = sum(s[metric]["tp"] for s in per_sample)
+        fp = sum(s[metric]["fp"] for s in per_sample)
+        fn = sum(s[metric]["fn"] for s in per_sample)
+        return _prf(tp, fp, fn)
+
+    return {
+        "n_samples": len(per_sample),
+        "nodes_micro": sum_keys("nodes"),
+        "edges_micro": sum_keys("edges"),
+    }

pid2graph_eval/schema.py

@@ -0,0 +1,89 @@
+"""Common graph schema shared by predictions and normalized ground truth.
+
+The VLM is asked to emit a `GraphOut` instance (enforced via structured outputs).
+Ground truth graphml is normalized into the same dict shape by `gt_loader.py`,
+so both sides can be fed directly into `metrics.evaluate()`.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BBox(BaseModel):
+    """Axis-aligned bounding box in normalized image coordinates.
+
+    Each coordinate is in [0.0, 1.0] relative to the image the VLM was
+    shown. When extraction runs on a cropped tile, these are tile-local
+    coordinates; the tiled merger converts them back to global image
+    pixel coordinates before deduplication.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    xmin: float = Field(description="Left edge, normalized [0, 1] within the visible image.")
+    ymin: float = Field(description="Top edge, normalized [0, 1].")
+    xmax: float = Field(description="Right edge, normalized [0, 1].")
+    ymax: float = Field(description="Bottom edge, normalized [0, 1].")
+
+
+class NodeOut(BaseModel):
+    """A single symbol in the P&ID (pump, valve, tank, sensor, ...)."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    id: str = Field(description="Unique node id within this diagram (e.g. 'n1').")
+    type: str = Field(
+        description=(
+            "Category of the symbol, lowercase, singular. "
+            "Examples: 'pump', 'valve', 'tank', 'heat_exchanger', 'sensor', "
+            "'controller', 'compressor', 'column'."
+        )
+    )
+    label: Optional[str] = Field(
+        default=None,
+        description="Tag/identifier printed next to the symbol if visible (e.g. 'P-101').",
+    )
+    bbox: Optional[BBox] = Field(
+        default=None,
+        description=(
+            "Tight bounding box of the symbol, with each coordinate "
+            "normalized to [0, 1] relative to the image the VLM sees. "
+            "Required by the tiled extraction pipeline for deduplication."
+        ),
+    )
+
+
+class EdgeOut(BaseModel):
+    """A pipeline or signal connection between two symbols."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    source: str = Field(description="Source node id.")
+    target: str = Field(description="Target node id.")
+    type: Optional[str] = Field(
+        default=None,
+        description="Connection type: 'pipe', 'signal', 'electrical', ...",
+    )
+    label: Optional[str] = Field(
+        default=None,
+        description="Line tag if visible (e.g. '2\"-PW-101').",
+    )
+
+
+class GraphOut(BaseModel):
+    """Top-level graph extracted from a P&ID image."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    nodes: List[NodeOut]
+    edges: List[EdgeOut]
+
+    def to_dict(self) -> dict:
+        """Shape that `metrics.evaluate()` consumes."""
+        return {
+            "nodes": [n.model_dump() for n in self.nodes],
+            "edges": [e.model_dump() for e in self.edges],
+        }

pid2graph_eval/tile.py

@@ -0,0 +1,341 @@
+"""Image tiling and multi-tile result merging.
+
+Rationale:
+    Whole-page P&ID extraction hits a node-recall ceiling around 50-60%
+    on large diagrams because the VLM can only resolve ~50 symbols at
+    ~1.15MP vision downsampling. Splitting the image into overlapping
+    tiles, extracting each, then merging via bbox-distance deduplication
+    lets the model zoom in on smaller regions at full pixel budget.
+
+Coordinate conventions:
+    - The VLM sees an individual tile and reports bbox in *normalized*
+      [0, 1] coordinates relative to that tile (see `schema.BBox`).
+    - `merge_tile_graphs` converts each tile-local normalized bbox into
+      global image pixel coordinates and deduplicates across tiles using
+      the Euclidean distance between bbox centers.
+
+Overlap:
+    Tiles are grown outward by `overlap` fraction of the un-overlapped
+    tile size on each internal seam so a symbol that happens to straddle
+    a split line appears fully in at least one tile. The dedup step then
+    collapses the two detections into one node.
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+
+from PIL import Image
+
+from .schema import BBox, GraphOut
+
+
+@dataclass
+class Tile:
+    """One cropped region of the source image, ready to send to the VLM."""
+
+    image: Image.Image
+    x0: int  # top-left x in global (full-image) pixel coordinates
+    y0: int  # top-left y in global pixel coordinates
+    w: int   # tile width in global pixels
+    h: int   # tile height in global pixels
+    parent_w: int
+    parent_h: int
+    name: str  # short label, e.g. "r0c0"
+
+
+def split_image(
+    image_path: Path | str,
+    rows: int = 2,
+    cols: int = 2,
+    overlap: float = 0.1,
+) -> list[Tile]:
+    """Split `image_path` into `rows * cols` overlapping tiles.
+
+    `overlap` is the fractional grow-outward applied to each seam. With
+    `overlap=0.1` and 2x2 tiling each tile is 60% wide and 60% tall
+    (50% + 10% overlap on the internal edge). Boundary tiles are clipped
+    to the image extent so they never exceed the parent dimensions.
+    """
+    img = Image.open(Path(image_path)).convert("RGB")
+    W, H = img.size
+
+    base_tw = W / cols
+    base_th = H / rows
+    ow = int(round(base_tw * overlap))
+    oh = int(round(base_th * overlap))
+
+    tiles: list[Tile] = []
+    for r in range(rows):
+        for c in range(cols):
+            x0 = max(0, int(round(c * base_tw)) - ow)
+            y0 = max(0, int(round(r * base_th)) - oh)
+            x1 = min(W, int(round((c + 1) * base_tw)) + ow)
+            y1 = min(H, int(round((r + 1) * base_th)) + oh)
+            tile_img = img.crop((x0, y0, x1, y1))
+            tiles.append(
+                Tile(
+                    image=tile_img,
+                    x0=x0,
+                    y0=y0,
+                    w=x1 - x0,
+                    h=y1 - y0,
+                    parent_w=W,
+                    parent_h=H,
+                    name=f"r{r}c{c}",
+                )
+            )
+    return tiles
+
+
+def tile_to_base64_png(tile: Tile) -> tuple[str, str]:
+    """Encode a tile as base64 PNG for the Messages API `source.data` field."""
+    buf = io.BytesIO()
+    tile.image.save(buf, format="PNG")
+    return base64.standard_b64encode(buf.getvalue()).decode("utf-8"), "image/png"
+
+
+def _tile_bbox_to_global_px(bbox: BBox, tile: Tile) -> tuple[float, float, float, float]:
+    """Convert a tile-local normalized bbox to global pixel coordinates."""
+    return (
+        tile.x0 + bbox.xmin * tile.w,
+        tile.y0 + bbox.ymin * tile.h,
+        tile.x0 + bbox.xmax * tile.w,
+        tile.y0 + bbox.ymax * tile.h,
+    )
+
+
+def _center(bbox_px: tuple[float, float, float, float]) -> tuple[float, float]:
+    xmin, ymin, xmax, ymax = bbox_px
+    return (xmin + xmax) / 2.0, (ymin + ymax) / 2.0
+
+
+@dataclass
+class _MergedNode:
+    id: str
+    type: str
+    label: str | None
+    bbox_px: tuple[float, float, float, float]
+    center: tuple[float, float]
+    source_tiles: list[str] = field(default_factory=list)
+
+
+def merge_tile_graphs(
+    tile_results: Iterable[tuple[GraphOut, Tile]],
+    dedup_px: float = 40.0,
+) -> dict:
+    """Merge per-tile predictions into one global graph.
+
+    Two nodes are considered the same symbol iff they share the same
+    `type` AND their bbox centers are within `dedup_px` pixels in the
+    global (un-tiled) image coordinate space. The first occurrence
+    wins; later duplicates are absorbed and their tile name is recorded
+    on `source_tiles` for debugging.
+
+    Edges are re-wired through the tile-local → global id map. An edge
+    whose endpoints map to the same global node is dropped, and
+    undirected duplicates across tiles are collapsed.
+
+    Returns a plain dict matching the shape `metrics.evaluate()` expects,
+    plus a `directed: False` flag. Extra `bbox` and `source_tiles` fields
+    on each node are ignored by the evaluator but useful for visualizing
+    predictions later.
+    """
+    global_nodes: list[_MergedNode] = []
+    id_map: dict[tuple[str, str], str] = {}  # (tile.name, tile_local_id) -> global id
+    next_id = 1
+
+    tile_results = list(tile_results)
+
+    # --- nodes: dedup by (type, bbox center distance) -------------------
+    for graph, tile in tile_results:
+        for node in graph.nodes:
+            if node.bbox is None:
+                # No bbox → can't dedupe across tiles safely. Skip.
+                continue
+            bbox_px = _tile_bbox_to_global_px(node.bbox, tile)
+            cx, cy = _center(bbox_px)
+
+            matched_gid: str | None = None
+            for gn in global_nodes:
+                if gn.type != node.type:
+                    continue
+                dx = gn.center[0] - cx
+                dy = gn.center[1] - cy
+                if (dx * dx + dy * dy) ** 0.5 <= dedup_px:
+                    matched_gid = gn.id
+                    break
+
+            if matched_gid is None:
+                gid = f"n{next_id}"
+                next_id += 1
+                global_nodes.append(
+                    _MergedNode(
+                        id=gid,
+                        type=node.type,
+                        label=node.label,
+                        bbox_px=bbox_px,
+                        center=(cx, cy),
+                        source_tiles=[tile.name],
+                    )
+                )
+                id_map[(tile.name, node.id)] = gid
+            else:
+                id_map[(tile.name, node.id)] = matched_gid
+                for gn in global_nodes:
+                    if gn.id == matched_gid:
+                        if tile.name not in gn.source_tiles:
+                            gn.source_tiles.append(tile.name)
+                        break
+
+    # --- edges: remap ids, drop self-loops and duplicates ---------------
+    edge_set: set[tuple[str, str]] = set()
+    final_edges: list[dict] = []
+    for graph, tile in tile_results:
+        for edge in graph.edges:
+            src = id_map.get((tile.name, edge.source))
+            tgt = id_map.get((tile.name, edge.target))
+            if src is None or tgt is None:
+                continue
+            if src == tgt:
+                continue
+            a, b = sorted((src, tgt))  # undirected canonicalization
+            key = (a, b)
+            if key in edge_set:
+                continue
+            edge_set.add(key)
+            final_edges.append(
+                {
+                    "source": a,
+                    "target": b,
+                    "type": edge.type or "solid",
+                    "label": edge.label,
+                }
+            )
+
+    out_nodes = [
+        {
+            "id": gn.id,
+            "type": gn.type,
+            "label": gn.label,
+            "bbox": list(gn.bbox_px),
+            "source_tiles": gn.source_tiles,
+        }
+        for gn in global_nodes
+    ]
+
+    return {
+        "nodes": out_nodes,
+        "edges": final_edges,
+        "directed": False,
+    }
+
+
+def _inner_seam_lines(tiles: list[Tile]) -> tuple[list[float], list[float]]:
+    """Return (vertical_seam_xs, horizontal_seam_ys) for inner tile borders.
+
+    For 2x2 tiling with overlap, each internal seam corresponds to TWO
+    pixel x-coordinates: where one tile ends and where the adjacent tile
+    begins. Both are returned so the FP filter can match either edge of
+    the overlap band.
+    """
+    if not tiles:
+        return [], []
+    parent_w = tiles[0].parent_w
+    parent_h = tiles[0].parent_h
+    vx: set[float] = set()
+    hy: set[float] = set()
+    for t in tiles:
+        if t.x0 > 0:
+            vx.add(float(t.x0))
+        if t.x0 + t.w < parent_w:
+            vx.add(float(t.x0 + t.w))
+        if t.y0 > 0:
+            hy.add(float(t.y0))
+        if t.y0 + t.h < parent_h:
+            hy.add(float(t.y0 + t.h))
+    return sorted(vx), sorted(hy)
+
+
+def filter_seam_artifacts(
+    merged: dict,
+    tiles: list[Tile],
+    types: tuple[str, ...] = ("inlet/outlet",),
+    seam_threshold: float = 50.0,
+    edge_threshold: float = 30.0,
+) -> dict:
+    """Drop nodes that look like tile-boundary false positives.
+
+    A node is filtered iff ALL of the following hold:
+      * its `type` is in `types` (default: inlet/outlet only),
+      * its bbox center lies within `seam_threshold` pixels of any inner
+        tile seam (vertical OR horizontal), AND
+      * its bbox center is NOT within `edge_threshold` pixels of the
+        outer image border (real boundary inlet/outlets stay).
+
+    Edges referencing dropped nodes are also removed. The dropped nodes
+    are recorded under `seam_filtered` so the report can show what was
+    pruned.
+
+    Nodes whose `type` is not in `types`, or that have no `bbox`, are
+    passed through untouched.
+    """
+    if not tiles:
+        return merged
+
+    parent_w = tiles[0].parent_w
+    parent_h = tiles[0].parent_h
+    vx, hy = _inner_seam_lines(tiles)
+    types_set = set(types)
+
+    keep_ids: set[str] = set()
+    new_nodes: list[dict] = []
+    dropped: list[dict] = []
+
+    for n in merged["nodes"]:
+        if n.get("type") not in types_set:
+            keep_ids.add(n["id"])
+            new_nodes.append(n)
+            continue
+
+        bbox = n.get("bbox")
+        if not bbox or len(bbox) != 4:
+            keep_ids.add(n["id"])
+            new_nodes.append(n)
+            continue
+
+        cx = (bbox[0] + bbox[2]) / 2.0
+        cy = (bbox[1] + bbox[3]) / 2.0
+
+        near_outer = (
+            cx < edge_threshold
+            or cx > parent_w - edge_threshold
+            or cy < edge_threshold
+            or cy > parent_h - edge_threshold
+        )
+        near_seam_x = any(abs(cx - x) <= seam_threshold for x in vx)
+        near_seam_y = any(abs(cy - y) <= seam_threshold for y in hy)
+        near_seam = near_seam_x or near_seam_y
+
+        if near_seam and not near_outer:
+            dropped.append({"id": n["id"], "type": n["type"], "bbox": bbox})
+            continue
+
+        keep_ids.add(n["id"])
+        new_nodes.append(n)
+
+    new_edges = [
+        e
+        for e in merged["edges"]
+        if e["source"] in keep_ids and e["target"] in keep_ids
+    ]
+
+    out = dict(merged)
+    out["nodes"] = new_nodes
+    out["edges"] = new_edges
+    out["seam_filtered"] = dropped
+    return out

requirements.txt

@@ -0,0 +1,11 @@
+anthropic>=0.40.0
+pydantic>=2.0
+networkx>=3.0
+Pillow>=10.0
+tqdm>=4.65
+# gradio 5 requires Python 3.10+; stay on 4.x for Python 3.9 compat
+gradio>=4.44,<5.0
+# gradio 4.x imports HfFolder which was removed in huggingface_hub 1.0
+huggingface_hub>=0.26,<1.0
+matplotlib>=3.7
+python-dotenv>=1.0

samples/open100_03_medium.graphml

@@ -0,0 +1,2812 @@
+<?xml version='1.0' encoding='utf-8'?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+  <key id="d9" for="edge" attr.name="edge_label" attr.type="string" />
+  <key id="d8" for="node" attr.name="ymax" attr.type="long" />
+  <key id="d7" for="node" attr.name="xmax" attr.type="long" />
+  <key id="d6" for="node" attr.name="ymin" attr.type="long" />
+  <key id="d5" for="node" attr.name="xmin" attr.type="long" />
+  <key id="d4" for="node" attr.name="ymax" attr.type="double" />
+  <key id="d3" for="node" attr.name="ymin" attr.type="double" />
+  <key id="d2" for="node" attr.name="xmax" attr.type="double" />
+  <key id="d1" for="node" attr.name="xmin" attr.type="double" />
+  <key id="d0" for="node" attr.name="label" attr.type="string" />
+  <graph edgedefault="undirected">
+    <node id="arrow1">
+      <data key="d0">arrow</data>
+      <data key="d1">435.2</data>
+      <data key="d2">443.81</data>
+      <data key="d3">1133.9</data>
+      <data key="d4">1145.2</data>
+    </node>
+    <node id="arrow2">
+      <data key="d0">arrow</data>
+      <data key="d1">938.16</data>
+      <data key="d2">950.2</data>
+      <data key="d3">1141.49</data>
+      <data key="d4">1151.6</data>
+    </node>
+    <node id="instrumentation3">
+      <data key="d0">instrumentation</data>
+      <data key="d1">548.81</data>
+      <data key="d2">585.88</data>
+      <data key="d3">752.27</data>
+      <data key="d4">787.96</data>
+    </node>
+    <node id="arrow4">
+      <data key="d0">arrow</data>
+      <data key="d1">947.02</data>
+      <data key="d2">956.5</data>
+      <data key="d3">974.77</data>
+      <data key="d4">987.7</data>
+    </node>
+    <node id="arrow5">
+      <data key="d0">arrow</data>
+      <data key="d1">1050.04</data>
+      <data key="d2">1060.16</data>
+      <data key="d3">326.4</data>
+      <data key="d4">338.08</data>
+    </node>
+    <node id="background6">
+      <data key="d0">background</data>
+      <data key="d1">0.0</data>
+      <data key="d2">2290.0</data>
+      <data key="d3">0.0</data>
+      <data key="d4">42.19</data>
+    </node>
+    <node id="arrow7">
+      <data key="d0">arrow</data>
+      <data key="d1">1132.0</data>
+      <data key="d2">1140.19</data>
+      <data key="d3">807.19</data>
+      <data key="d4">819.4</data>
+    </node>
+    <node id="valve8">
+      <data key="d0">valve</data>
+      <data key="d1">686.6</data>
+      <data key="d2">705.0</data>
+      <data key="d3">412.24</data>
+      <data key="d4">423.8</data>
+    </node>
+    <node id="general9">
+      <data key="d0">general</data>
+      <data key="d1">326.69</data>
+      <data key="d2">333.49</data>
+      <data key="d3">524.17</data>
+      <data key="d4">535.47</data>
+    </node>
+    <node id="valve10">
+      <data key="d0">valve</data>
+      <data key="d1">1389.74</data>
+      <data key="d2">1408.61</data>
+      <data key="d3">588.82</data>
+      <data key="d4">620.35</data>
+    </node>
+    <node id="instrumentation11">
+      <data key="d0">instrumentation</data>
+      <data key="d1">895.0</data>
+      <data key="d2">931.05</data>
+      <data key="d3">328.63</data>
+      <data key="d4">364.32</data>
+    </node>
+    <node id="valve12">
+      <data key="d0">valve</data>
+      <data key="d1">1263.56</data>
+      <data key="d2">1282.56</data>
+      <data key="d3">959.3</data>
+      <data key="d4">973.12</data>
+    </node>
+    <node id="general13">
+      <data key="d0">general</data>
+      <data key="d1">326.69</data>
+      <data key="d2">333.49</data>
+      <data key="d3">620.8</data>
+      <data key="d4">632.1</data>
+    </node>
+    <node id="tank14">
+      <data key="d0">tank</data>
+      <data key="d1">385.98</data>
+      <data key="d2">668.68</data>
+      <data key="d3">352.8</data>
+      <data key="d4">435.92</data>
+    </node>
+    <node id="general15">
+      <data key="d0">general</data>
+      <data key="d1">416.18</data>
+      <data key="d2">430.91</data>
+      <data key="d3">335.68</data>
+      <data key="d4">344.36</data>
+    </node>
+    <node id="inlet/outlet16">
+      <data key="d0">inlet/outlet</data>
+      <data key="d1">1749.4</data>
+      <data key="d2">1912.0</data>
+      <data key="d3">595.9</data>
+      <data key="d4">632.0</data>
+    </node>
+    <node id="valve17">
+      <data key="d0">valve</data>
+      <data key="d1">749.65</data>
+      <data key="d2">768.85</data>
+      <data key="d3">620.17</data>
+      <data key="d4">632.57</data>
+    </node>
+    <node id="tank18">
+      <data key="d0">tank</data>
+      <data key="d1">334.14</data>
+      <data key="d2">736.83</data>
+      <data key="d3">496.71</data>
+      <data key="d4">660.73</data>
+    </node>
+    <node id="valve19">
+      <data key="d0">valve</data>
+      <data key="d1">485.86</data>
+      <data key="d2">504.05</data>
+      <data key="d3">1115.7</data>
+      <data key="d4">1153.58</data>
+    </node>
+    <node id="instrumentation20">
+      <data key="d0">instrumentation</data>
+      <data key="d1">661.06</data>
+      <data key="d2">698.13</data>
+      <data key="d3">448.36</data>
+      <data key="d4">484.05</data>
+    </node>
+    <node id="pump21">
+      <data key="d0">pump</data>
+      <data key="d1">596.74</data>
+      <data key="d2">722.31</data>
+      <data key="d3">1199.17</data>
+      <data key="d4">1250.5</data>
+    </node>
+    <node id="valve22">
+      <data key="d0">valve</data>
+      <data key="d1">781.09</data>
+      <data key="d2">800.43</data>
+      <data key="d3">789.01</data>
+      <data key="d4">824.64</data>
+    </node>
+    <node id="valve23">
+      <data key="d0">valve</data>
+      <data key="d1">874.46</data>
+      <data key="d2">894.18</data>
+      <data key="d3">357.62</data>
+      <data key="d4">389.8</data>
+    </node>
+    <node id="valve24">
+      <data key="d0">valve</data>
+      <data key="d1">989.34</data>
+      <data key="d2">1009.12</data>
+      <data key="d3">941.32</data>
+      <data key="d4">973.28</data>
+    </node>
+    <node id="general25">
+      <data key="d0">general</data>
+      <data key="d1">520.6</data>
+      <data key="d2">535.32</data>
+      <data key="d3">335.8</data>
+      <data key="d4">344.48</data>
+    </node>
+    <node id="valve26">
+      <data key="d0">valve</data>
+      <data key="d1">1049.6</data>
+      <data key="d2">1061.17</data>
+      <data key="d3">917.12</data>
+      <data key="d4">936.15</data>
+    </node>
+    <node id="valve27">
+      <data key="d0">valve</data>
+      <data key="d1">1081.87</data>
+      <data key="d2">1093.44</data>
+      <data key="d3">917.2</data>
+      <data key="d4">936.22</data>
+    </node>
+    <node id="instrumentation28">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1312.48</data>
+      <data key="d2">1349.55</data>
+      <data key="d3">661.02</data>
+      <data key="d4">696.71</data>
+    </node>
+    <node id="valve29">
+      <data key="d0">valve</data>
+      <data key="d1">1106.2</data>
+      <data key="d2">1142.39</data>
+      <data key="d3">876.76</data>
+      <data key="d4">895.78</data>
+    </node>
+    <node id="instrumentation30">
+      <data key="d0">instrumentation</data>
+      <data key="d1">676.84</data>
+      <data key="d2">713.91</data>
+      <data key="d3">751.63</data>
+      <data key="d4">787.32</data>
+    </node>
+    <node id="general31">
+      <data key="d0">general</data>
+      <data key="d1">585.29</data>
+      <data key="d2">600.02</data>
+      <data key="d3">335.8</data>
+      <data key="d4">344.48</data>
+    </node>
+    <node id="instrumentation32">
+      <data key="d0">instrumentation</data>
+      <data key="d1">863.03</data>
+      <data key="d2">900.1</data>
+      <data key="d3">465.28</data>
+      <data key="d4">500.97</data>
+    </node>
+    <node id="general33">
+      <data key="d0">general</data>
+      <data key="d1">519.81</data>
+      <data key="d2">534.53</data>
+      <data key="d3">444.15</data>
+      <data key="d4">452.83</data>
+    </node>
+    <node id="instrumentation34">
+      <data key="d0">instrumentation</data>
+      <data key="d1">822.41</data>
+      <data key="d2">859.48</data>
+      <data key="d3">576.3</data>
+      <data key="d4">611.99</data>
+    </node>
+    <node id="instrumentation35">
+      <data key="d0">instrumentation</data>
+      <data key="d1">862.82</data>
+      <data key="d2">899.89</data>
+      <data key="d3">576.93</data>
+      <data key="d4">612.63</data>
+    </node>
+    <node id="arrow36">
+      <data key="d0">arrow</data>
+      <data key="d1">937.79</data>
+      <data key="d2">949.8</data>
+      <data key="d3">814.05</data>
+      <data key="d4">822.4</data>
+    </node>
+    <node id="general37">
+      <data key="d0">general</data>
+      <data key="d1">1480.56</data>
+      <data key="d2">1493.46</data>
+      <data key="d3">907.16</data>
+      <data key="d4">914.66</data>
+    </node>
+    <node id="instrumentation38">
+      <data key="d0">instrumentation</data>
+      <data key="d1">749.0</data>
+      <data key="d2">783.67</data>
+      <data key="d3">774.18</data>
+      <data key="d4">809.0</data>
+    </node>
+    <node id="general39">
+      <data key="d0">general</data>
+      <data key="d1">1360.8</data>
+      <data key="d2">1372.7</data>
+      <data key="d3">906.9</data>
+      <data key="d4">913.8</data>
+    </node>
+    <node id="general40">
+      <data key="d0">general</data>
+      <data key="d1">1506.12</data>
+      <data key="d2">1517.72</data>
+      <data key="d3">986.19</data>
+      <data key="d4">993.69</data>
+    </node>
+    <node id="instrumentation41">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1269.09</data>
+      <data key="d2">1306.16</data>
+      <data key="d3">660.81</data>
+      <data key="d4">696.5</data>
+    </node>
+    <node id="general42">
+      <data key="d0">general</data>
+      <data key="d1">520.86</data>
+      <data key="d2">535.58</data>
+      <data key="d3">479.13</data>
+      <data key="d4">487.8</data>
+    </node>
+    <node id="general43">
+      <data key="d0">general</data>
+      <data key="d1">1300.56</data>
+      <data key="d2">1308.92</data>
+      <data key="d3">959.44</data>
+      <data key="d4">972.26</data>
+    </node>
+    <node id="general44">
+      <data key="d0">general</data>
+      <data key="d1">1301.57</data>
+      <data key="d2">1308.92</data>
+      <data key="d3">927.62</data>
+      <data key="d4">941.3</data>
+    </node>
+    <node id="pump45">
+      <data key="d0">pump</data>
+      <data key="d1">597.23</data>
+      <data key="d2">721.6</data>
+      <data key="d3">865.6</data>
+      <data key="d4">913.39</data>
+    </node>
+    <node id="general46">
+      <data key="d0">general</data>
+      <data key="d1">1263.7</data>
+      <data key="d2">1282.85</data>
+      <data key="d3">928.63</data>
+      <data key="d4">940.9</data>
+    </node>
+    <node id="arrow47">
+      <data key="d0">arrow</data>
+      <data key="d1">1157.81</data>
+      <data key="d2">1170.8</data>
+      <data key="d3">961.31</data>
+      <data key="d4">971.42</data>
+    </node>
+    <node id="general48">
+      <data key="d0">general</data>
+      <data key="d1">673.52</data>
+      <data key="d2">680.92</data>
+      <data key="d3">412.05</data>
+      <data key="d4">423.85</data>
+    </node>
+    <node id="general49">
+      <data key="d0">general</data>
+      <data key="d1">676.62</data>
+      <data key="d2">684.82</data>
+      <data key="d3">377.15</data>
+      <data key="d4">390.05</data>
+    </node>
+    <node id="general50">
+      <data key="d0">general</data>
+      <data key="d1">737.8</data>
+      <data key="d2">744.6</data>
+      <data key="d3">620.6</data>
+      <data key="d4">631.9</data>
+    </node>
+    <node id="instrumentation51">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1004.17</data>
+      <data key="d2">1039.2</data>
+      <data key="d3">913.3</data>
+      <data key="d4">947.57</data>
+    </node>
+    <node id="general52">
+      <data key="d0">general</data>
+      <data key="d1">726.63</data>
+      <data key="d2">768.7</data>
+      <data key="d3">915.62</data>
+      <data key="d4">955.0</data>
+    </node>
+    <node id="instrumentation53">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1097.43</data>
+      <data key="d2">1132.0</data>
+      <data key="d3">898.94</data>
+      <data key="d4">934.0</data>
+    </node>
+    <node id="general54">
+      <data key="d0">general</data>
+      <data key="d1">432.43</data>
+      <data key="d2">447.16</data>
+      <data key="d3">667.14</data>
+      <data key="d4">675.82</data>
+    </node>
+    <node id="general55">
+      <data key="d0">general</data>
+      <data key="d1">1316.55</data>
+      <data key="d2">1563.88</data>
+      <data key="d3">916.39</data>
+      <data key="d4">983.79</data>
+    </node>
+    <node id="arrow56">
+      <data key="d0">arrow</data>
+      <data key="d1">1225.8</data>
+      <data key="d2">1237.9</data>
+      <data key="d3">800.83</data>
+      <data key="d4">810.93</data>
+    </node>
+    <node id="instrumentation57">
+      <data key="d0">instrumentation</data>
+      <data key="d1">452.9</data>
+      <data key="d2">486.42</data>
+      <data key="d3">1102.1</data>
+      <data key="d4">1136.95</data>
+    </node>
+    <node id="arrow58">
+      <data key="d0">arrow</data>
+      <data key="d1">644.8</data>
+      <data key="d2">652.31</data>
+      <data key="d3">1148.25</data>
+      <data key="d4">1159.3</data>
+    </node>
+    <node id="instrumentation59">
+      <data key="d0">instrumentation</data>
+      <data key="d1">678.44</data>
+      <data key="d2">713.1</data>
+      <data key="d3">1081.1</data>
+      <data key="d4">1115.15</data>
+    </node>
+    <node id="valve60">
+      <data key="d0">valve</data>
+      <data key="d1">766.7</data>
+      <data key="d2">784.6</data>
+      <data key="d3">1116.45</data>
+      <data key="d4">1151.9</data>
+    </node>
+    <node id="instrumentation61">
+      <data key="d0">instrumentation</data>
+      <data key="d1">461.3</data>
+      <data key="d2">494.7</data>
+      <data key="d3">774.7</data>
+      <data key="d4">808.04</data>
+    </node>
+    <node id="instrumentation62">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1149.56</data>
+      <data key="d2">1185.4</data>
+      <data key="d3">745.03</data>
+      <data key="d4">778.9</data>
+    </node>
+    <node id="arrow63">
+      <data key="d0">arrow</data>
+      <data key="d1">643.04</data>
+      <data key="d2">653.16</data>
+      <data key="d3">820.4</data>
+      <data key="d4">831.4</data>
+    </node>
+    <node id="background64">
+      <data key="d0">background</data>
+      <data key="d1">1945.53</data>
+      <data key="d2">2290.0</data>
+      <data key="d3">0.0</data>
+      <data key="d4">1536.0</data>
+    </node>
+    <node id="arrow65">
+      <data key="d0">arrow</data>
+      <data key="d1">997.79</data>
+      <data key="d2">1007.92</data>
+      <data key="d3">494.86</data>
+      <data key="d4">510.68</data>
+    </node>
+    <node id="instrumentation66">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1406.6</data>
+      <data key="d2">1441.43</data>
+      <data key="d3">560.3</data>
+      <data key="d4">594.62</data>
+    </node>
+    <node id="valve67">
+      <data key="d0">valve</data>
+      <data key="d1">494.01</data>
+      <data key="d2">513.32</data>
+      <data key="d3">788.4</data>
+      <data key="d4">823.99</data>
+    </node>
+    <node id="instrumentation68">
+      <data key="d0">instrumentation</data>
+      <data key="d1">976.16</data>
+      <data key="d2">1013.23</data>
+      <data key="d3">1052.18</data>
+      <data key="d4">1087.88</data>
+    </node>
+    <node id="instrumentation69">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1188.44</data>
+      <data key="d2">1225.51</data>
+      <data key="d3">916.47</data>
+      <data key="d4">952.16</data>
+    </node>
+    <node id="arrow70">
+      <data key="d0">arrow</data>
+      <data key="d1">1081.97</data>
+      <data key="d2">1092.1</data>
+      <data key="d3">509.91</data>
+      <data key="d4">525.72</data>
+    </node>
+    <node id="instrumentation71">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1020.83</data>
+      <data key="d2">1057.9</data>
+      <data key="d3">1052.61</data>
+      <data key="d4">1088.3</data>
+    </node>
+    <node id="arrow72">
+      <data key="d0">arrow</data>
+      <data key="d1">1240.9</data>
+      <data key="d2">1253.98</data>
+      <data key="d3">929.46</data>
+      <data key="d4">939.57</data>
+    </node>
+    <node id="instrumentation73">
+      <data key="d0">instrumentation</data>
+      <data key="d1">549.39</data>
+      <data key="d2">586.47</data>
+      <data key="d3">1080.33</data>
+      <data key="d4">1116.02</data>
+    </node>
+    <node id="instrumentation74">
+      <data key="d0">instrumentation</data>
+      <data key="d1">715.51</data>
+      <data key="d2">752.58</data>
+      <data key="d3">343.29</data>
+      <data key="d4">378.98</data>
+    </node>
+    <node id="general75">
+      <data key="d0">general</data>
+      <data key="d1">724.4</data>
+      <data key="d2">768.0</data>
+      <data key="d3">1250.74</data>
+      <data key="d4">1290.8</data>
+    </node>
+    <node id="instrumentation76">
+      <data key="d0">instrumentation</data>
+      <data key="d1">731.62</data>
+      <data key="d2">768.69</data>
+      <data key="d3">1101.51</data>
+      <data key="d4">1137.2</data>
+    </node>
+    <node id="valve77">
+      <data key="d0">valve</data>
+      <data key="d1">813.5</data>
+      <data key="d2">832.94</data>
+      <data key="d3">1137.38</data>
+      <data key="d4">1152.83</data>
+    </node>
+    <node id="instrumentation78">
+      <data key="d0">instrumentation</data>
+      <data key="d1">820.28</data>
+      <data key="d2">857.35</data>
+      <data key="d3">465.06</data>
+      <data key="d4">500.76</data>
+    </node>
+    <node id="instrumentation79">
+      <data key="d0">instrumentation</data>
+      <data key="d1">1460.82</data>
+      <data key="d2">1497.89</data>
+      <data key="d3">552.04</data>
+      <data key="d4">587.73</data>
+    </node>
+    <node id="background80">
+      <data key="d0">background</data>
+      <data key="d1">0.0</data>
+      <data key="d2">2285.51</data>
+      <data key="d3">1494.1</data>
+      <data key="d4">1536.0</data>
+    </node>
+    <node id="background81">
+      <data key="d0">background</data>
+      <data key="d1">0.0</data>
+      <data key="d2">33.65</data>
+      <data key="d3">0.0</data>
+      <data key="d4">1536.0</data>
+    </node>
+    <node id="inlet/outlet82">
+      <data key="d0">inlet/outlet</data>
+      <data key="d1">1749.6</data>
+      <data key="d2">1914.81</data>
+      <data key="d3">306.0</data>
+      <data key="d4">341.1</data>
+    </node>
+    <node id="instrumentation83">
+      <data key="d0">instrumentation</data>
+      <data key="d1">470.33</data>
+      <data key="d2">507.4</data>
+      <data key="d3">688.47</data>
+      <data key="d4">724.16</data>
+    </node>
+    <node id="arrow84">
+      <data key="d0">arrow</data>
+      <data key="d1">602.1</data>
+      <data key="d2">613.79</data>
+      <data key="d3">1142.3</data>
+      <data key="d4">1151.2</data>
+    </node>
+    <node id="instrumentation85">
+      <data key="d0">instrumentation</data>
+      <data key="d1">514.56</data>
+      <data key="d2">551.64</data>
+      <data key="d3">688.47</data>
+      <data key="d4">724.16</data>
+    </node>
+    <node id="valve86">
+      <data key="d0">valve</data>
+      <data key="d1">837.79</data>
+      <data key="d2">858.84</data>
+      <data key="d3">809.46</data>
+      <data key="d4">824.31</data>
+    </node>
+    <node id="instrumentation87">
+      <data key="d0">instrumentation</data>
+      <data key="d1">674.88</data>
+      <data key="d2">710.7</data>
+      <data key="d3">344.1</data>
+      <data key="d4">376.64</data>
+    </node>
+    <node id="instrumentation88">
+      <data key="d0">instrumentation</data>
+      <data key="d1">616.18</data>
+      <data key="d2">653.26</data>
+      <data key="d3">262.26</data>
+      <data key="d4">297.95</data>
+    </node>
+    <node id="inlet/outlet89">
+      <data key="d0">inlet/outlet</data>
+      <data key="d1">1749.2</data>
+      <data key="d2">1913.19</data>
+      <data key="d3">451.62</data>
+      <data key="d4">488.6</data>
+    </node>
+    <node id="instrumentation90">
+      <data key="d0">instrumentation</data>
+      <data key="d1">617.25</data>
+      <data key="d2">654.32</data>
+      <data key="d3">294.38</data>
+      <data key="d4">330.07</data>
+    </node>
+    <node id="instrumentation91">
+      <data key="d0">instrumentation</data>
+      <data key="d1">547.27</data>
+      <data key="d2">584.35</data>
+      <data key="d3">292.89</data>
+      <data key="d4">328.58</data>
+    </node>
+    <node id="arrow92">
+      <data key="d0">arrow</data>
+      <data key="d1">601.32</data>
+      <data key="d2">613.4</data>
+      <data key="d3">813.07</data>
+      <data key="d4">823.18</data>
+    </node>
+    <node id="connector93">
+      <data key="d0">connector</data>
+      <data key="d5">1001</data>
+      <data key="d6">507</data>
+      <data key="d7">1009</data>
+      <data key="d8">515</data>
+    </node>
+    <node id="crossing94">
+      <data key="d0">crossing</data>
+      <data key="d5">947</data>
+      <data key="d6">871</data>
+      <data key="d7">955</data>
+      <data key="d8">879</data>
+    </node>
+    <node id="crossing95">
+      <data key="d0">crossing</data>
+      <data key="d5">1001</data>
+      <data key="d6">871</data>
+      <data key="d7">1009</data>
+      <data key="d8">879</data>
+    </node>
+    <node id="connector96">
+      <data key="d0">connector</data>
+      <data key="d5">1084</data>
+      <data key="d6">913</data>
+      <data key="d7">1092</data>
+      <data key="d8">921</data>
+    </node>
+    <node id="connector97">
+      <data key="d0">connector</data>
+      <data key="d5">1084</data>
+      <data key="d6">522</data>
+      <data key="d7">1092</data>
+      <data key="d8">530</data>
+    </node>
+    <node id="connector98">
+      <data key="d0">connector</data>
+      <data key="d5">665</data>
+      <data key="d6">357</data>
+      <data key="d7">673</data>
+      <data key="d8">365</data>
+    </node>
+    <node id="connector99">
+      <data key="d0">connector</data>
+      <data key="d5">671</data>
+      <data key="d6">357</data>
+      <data key="d7">679</data>
+      <data key="d8">365</data>
+    </node>
+    <node id="connector100">
+      <data key="d0">connector</data>
+      <data key="d5">563</data>
+      <data key="d6">784</data>
+      <data key="d7">571</data>
+      <data key="d8">792</data>
+    </node>
+    <node id="crossing101">
+      <data key="d0">crossing</data>
+      <data key="d5">564</data>
+      <data key="d6">815</data>
+      <data key="d7">572</data>
+      <data key="d8">823</data>
+    </node>
+    <node id="connector102">
+      <data key="d0">connector</data>
+      <data key="d5">675</data>
+      <data key="d6">493</data>
+      <data key="d7">683</data>
+      <data key="d8">501</data>
+    </node>
+    <node id="connector103">
+      <data key="d0">connector</data>
+      <data key="d5">676</data>
+      <data key="d6">480</data>
+      <data key="d7">684</data>
+      <data key="d8">488</data>
+    </node>
+    <node id="connector104">
+      <data key="d0">connector</data>
+      <data key="d5">500</data>
+      <data key="d6">1143</data>
+      <data key="d7">508</data>
+      <data key="d8">1151</data>
+    </node>
+    <node id="crossing105">
+      <data key="d0">crossing</data>
+      <data key="d5">564</data>
+      <data key="d6">1142</data>
+      <data key="d7">572</data>
+      <data key="d8">1150</data>
+    </node>
+    <node id="connector106">
+      <data key="d0">connector</data>
+      <data key="d5">523</data>
+      <data key="d6">349</data>
+      <data key="d7">531</data>
+      <data key="d8">357</data>
+    </node>
+    <node id="connector107">
+      <data key="d0">connector</data>
+      <data key="d5">524</data>
+      <data key="d6">340</data>
+      <data key="d7">532</data>
+      <data key="d8">348</data>
+    </node>
+    <node id="connector108">
+      <data key="d0">connector</data>
+      <data key="d5">1260</data>
+      <data key="d6">963</data>
+      <data key="d7">1268</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="crossing109">
+      <data key="d0">crossing</data>
+      <data key="d5">1202</data>
+      <data key="d6">962</data>
+      <data key="d7">1210</data>
+      <data key="d8">970</data>
+    </node>
+    <node id="connector110">
+      <data key="d0">connector</data>
+      <data key="d5">796</data>
+      <data key="d6">814</data>
+      <data key="d7">804</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="connector111">
+      <data key="d0">connector</data>
+      <data key="d5">834</data>
+      <data key="d6">813</data>
+      <data key="d7">842</data>
+      <data key="d8">821</data>
+    </node>
+    <node id="connector112">
+      <data key="d0">connector</data>
+      <data key="d5">597</data>
+      <data key="d6">814</data>
+      <data key="d7">605</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="connector113">
+      <data key="d0">connector</data>
+      <data key="d5">611</data>
+      <data key="d6">493</data>
+      <data key="d7">619</data>
+      <data key="d8">501</data>
+    </node>
+    <node id="connector114">
+      <data key="d0">connector</data>
+      <data key="d5">612</data>
+      <data key="d6">432</data>
+      <data key="d7">620</data>
+      <data key="d8">440</data>
+    </node>
+    <node id="connector115">
+      <data key="d0">connector</data>
+      <data key="d5">1133</data>
+      <data key="d6">803</data>
+      <data key="d7">1141</data>
+      <data key="d8">811</data>
+    </node>
+    <node id="crossing116">
+      <data key="d0">crossing</data>
+      <data key="d5">1164</data>
+      <data key="d6">802</data>
+      <data key="d7">1172</data>
+      <data key="d8">810</data>
+    </node>
+    <node id="crossing117">
+      <data key="d0">crossing</data>
+      <data key="d5">1133</data>
+      <data key="d6">802</data>
+      <data key="d7">1141</data>
+      <data key="d8">810</data>
+    </node>
+    <node id="connector118">
+      <data key="d0">connector</data>
+      <data key="d5">644</data>
+      <data key="d6">1144</data>
+      <data key="d7">652</data>
+      <data key="d8">1152</data>
+    </node>
+    <node id="crossing119">
+      <data key="d0">crossing</data>
+      <data key="d5">692</data>
+      <data key="d6">1143</data>
+      <data key="d7">700</data>
+      <data key="d8">1151</data>
+    </node>
+    <node id="crossing120">
+      <data key="d0">crossing</data>
+      <data key="d5">645</data>
+      <data key="d6">1143</data>
+      <data key="d7">653</data>
+      <data key="d8">1151</data>
+    </node>
+    <node id="crossing121">
+      <data key="d0">crossing</data>
+      <data key="d5">1083</data>
+      <data key="d6">963</data>
+      <data key="d7">1091</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="crossing122">
+      <data key="d0">crossing</data>
+      <data key="d5">1133</data>
+      <data key="d6">963</data>
+      <data key="d7">1141</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="connector123">
+      <data key="d0">connector</data>
+      <data key="d5">1051</data>
+      <data key="d6">322</data>
+      <data key="d7">1059</data>
+      <data key="d8">330</data>
+    </node>
+    <node id="connector124">
+      <data key="d0">connector</data>
+      <data key="d5">1746</data>
+      <data key="d6">319</data>
+      <data key="d7">1754</data>
+      <data key="d8">327</data>
+    </node>
+    <node id="crossing125">
+      <data key="d0">crossing</data>
+      <data key="d5">1051</data>
+      <data key="d6">319</data>
+      <data key="d7">1059</data>
+      <data key="d8">327</data>
+    </node>
+    <node id="connector126">
+      <data key="d0">connector</data>
+      <data key="d5">816</data>
+      <data key="d6">479</data>
+      <data key="d7">824</data>
+      <data key="d8">487</data>
+    </node>
+    <node id="crossing127">
+      <data key="d0">crossing</data>
+      <data key="d5">788</data>
+      <data key="d6">479</data>
+      <data key="d7">796</data>
+      <data key="d8">487</data>
+    </node>
+    <node id="connector128">
+      <data key="d0">connector</data>
+      <data key="d5">1052</data>
+      <data key="d6">334</data>
+      <data key="d7">1060</data>
+      <data key="d8">342</data>
+    </node>
+    <node id="connector129">
+      <data key="d0">connector</data>
+      <data key="d5">1051</data>
+      <data key="d6">913</data>
+      <data key="d7">1059</data>
+      <data key="d8">921</data>
+    </node>
+    <node id="connector130">
+      <data key="d0">connector</data>
+      <data key="d5">1164</data>
+      <data key="d6">775</data>
+      <data key="d7">1172</data>
+      <data key="d8">783</data>
+    </node>
+    <node id="connector131">
+      <data key="d0">connector</data>
+      <data key="d5">746</data>
+      <data key="d6">623</data>
+      <data key="d7">754</data>
+      <data key="d8">631</data>
+    </node>
+    <node id="crossing132">
+      <data key="d0">crossing</data>
+      <data key="d5">741</data>
+      <data key="d6">622</data>
+      <data key="d7">749</data>
+      <data key="d8">630</data>
+    </node>
+    <node id="connector133">
+      <data key="d0">connector</data>
+      <data key="d5">1297</data>
+      <data key="d6">962</data>
+      <data key="d7">1305</data>
+      <data key="d8">970</data>
+    </node>
+    <node id="connector134">
+      <data key="d0">connector</data>
+      <data key="d5">1279</data>
+      <data key="d6">962</data>
+      <data key="d7">1287</data>
+      <data key="d8">970</data>
+    </node>
+    <node id="connector135">
+      <data key="d0">connector</data>
+      <data key="d5">524</data>
+      <data key="d6">440</data>
+      <data key="d7">532</data>
+      <data key="d8">448</data>
+    </node>
+    <node id="connector136">
+      <data key="d0">connector</data>
+      <data key="d5">523</data>
+      <data key="d6">432</data>
+      <data key="d7">531</data>
+      <data key="d8">440</data>
+    </node>
+    <node id="connector137">
+      <data key="d0">connector</data>
+      <data key="d5">1508</data>
+      <data key="d6">980</data>
+      <data key="d7">1516</data>
+      <data key="d8">988</data>
+    </node>
+    <node id="connector138">
+      <data key="d0">connector</data>
+      <data key="d5">1509</data>
+      <data key="d6">982</data>
+      <data key="d7">1517</data>
+      <data key="d8">990</data>
+    </node>
+    <node id="connector139">
+      <data key="d0">connector</data>
+      <data key="d5">1123</data>
+      <data key="d6">895</data>
+      <data key="d7">1131</data>
+      <data key="d8">903</data>
+    </node>
+    <node id="connector140">
+      <data key="d0">connector</data>
+      <data key="d5">1126</data>
+      <data key="d6">892</data>
+      <data key="d7">1134</data>
+      <data key="d8">900</data>
+    </node>
+    <node id="connector141">
+      <data key="d0">connector</data>
+      <data key="d5">1204</data>
+      <data key="d6">948</data>
+      <data key="d7">1212</data>
+      <data key="d8">956</data>
+    </node>
+    <node id="connector142">
+      <data key="d0">connector</data>
+      <data key="d5">734</data>
+      <data key="d6">622</data>
+      <data key="d7">742</data>
+      <data key="d8">630</data>
+    </node>
+    <node id="connector143">
+      <data key="d0">connector</data>
+      <data key="d5">733</data>
+      <data key="d6">622</data>
+      <data key="d7">741</data>
+      <data key="d8">630</data>
+    </node>
+    <node id="connector144">
+      <data key="d0">connector</data>
+      <data key="d5">1250</data>
+      <data key="d6">931</data>
+      <data key="d7">1258</data>
+      <data key="d8">939</data>
+    </node>
+    <node id="connector145">
+      <data key="d0">connector</data>
+      <data key="d5">1260</data>
+      <data key="d6">931</data>
+      <data key="d7">1268</data>
+      <data key="d8">939</data>
+    </node>
+    <node id="connector146">
+      <data key="d0">connector</data>
+      <data key="d5">946</data>
+      <data key="d6">814</data>
+      <data key="d7">954</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="crossing147">
+      <data key="d0">crossing</data>
+      <data key="d5">948</data>
+      <data key="d6">814</data>
+      <data key="d7">956</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="connector148">
+      <data key="d0">connector</data>
+      <data key="d5">1222</data>
+      <data key="d6">802</data>
+      <data key="d7">1230</data>
+      <data key="d8">810</data>
+    </node>
+    <node id="connector149">
+      <data key="d0">connector</data>
+      <data key="d5">855</data>
+      <data key="d6">815</data>
+      <data key="d7">863</data>
+      <data key="d8">823</data>
+    </node>
+    <node id="connector150">
+      <data key="d0">connector</data>
+      <data key="d5">934</data>
+      <data key="d6">814</data>
+      <data key="d7">942</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="connector151">
+      <data key="d0">connector</data>
+      <data key="d5">829</data>
+      <data key="d6">1142</data>
+      <data key="d7">837</data>
+      <data key="d8">1150</data>
+    </node>
+    <node id="connector152">
+      <data key="d0">connector</data>
+      <data key="d5">934</data>
+      <data key="d6">1143</data>
+      <data key="d7">942</data>
+      <data key="d8">1151</data>
+    </node>
+    <node id="connector153">
+      <data key="d0">connector</data>
+      <data key="d5">1363</data>
+      <data key="d6">910</data>
+      <data key="d7">1371</data>
+      <data key="d8">918</data>
+    </node>
+    <node id="connector154">
+      <data key="d0">connector</data>
+      <data key="d5">1363</data>
+      <data key="d6">912</data>
+      <data key="d7">1371</data>
+      <data key="d8">920</data>
+    </node>
+    <node id="connector155">
+      <data key="d0">connector</data>
+      <data key="d5">645</data>
+      <data key="d6">862</data>
+      <data key="d7">653</data>
+      <data key="d8">870</data>
+    </node>
+    <node id="connector156">
+      <data key="d0">connector</data>
+      <data key="d5">644</data>
+      <data key="d6">827</data>
+      <data key="d7">652</data>
+      <data key="d8">835</data>
+    </node>
+    <node id="connector157">
+      <data key="d0">connector</data>
+      <data key="d5">436</data>
+      <data key="d6">1130</data>
+      <data key="d7">444</data>
+      <data key="d8">1138</data>
+    </node>
+    <node id="crossing158">
+      <data key="d0">crossing</data>
+      <data key="d5">436</data>
+      <data key="d6">815</data>
+      <data key="d7">444</data>
+      <data key="d8">823</data>
+    </node>
+    <node id="connector159">
+      <data key="d0">connector</data>
+      <data key="d5">524</data>
+      <data key="d6">493</data>
+      <data key="d7">532</data>
+      <data key="d8">501</data>
+    </node>
+    <node id="connector160">
+      <data key="d0">connector</data>
+      <data key="d5">524</data>
+      <data key="d6">484</data>
+      <data key="d7">532</data>
+      <data key="d8">492</data>
+    </node>
+    <node id="connector161">
+      <data key="d0">connector</data>
+      <data key="d5">1082</data>
+      <data key="d6">506</data>
+      <data key="d7">1090</data>
+      <data key="d8">514</data>
+    </node>
+    <node id="connector162">
+      <data key="d0">connector</data>
+      <data key="d5">1745</data>
+      <data key="d6">465</data>
+      <data key="d7">1753</data>
+      <data key="d8">473</data>
+    </node>
+    <node id="crossing163">
+      <data key="d0">crossing</data>
+      <data key="d5">1083</data>
+      <data key="d6">467</data>
+      <data key="d7">1091</data>
+      <data key="d8">475</data>
+    </node>
+    <node id="connector164">
+      <data key="d0">connector</data>
+      <data key="d5">1405</data>
+      <data key="d6">610</data>
+      <data key="d7">1413</data>
+      <data key="d8">618</data>
+    </node>
+    <node id="crossing165">
+      <data key="d0">crossing</data>
+      <data key="d5">1475</data>
+      <data key="d6">611</data>
+      <data key="d7">1483</data>
+      <data key="d8">619</data>
+    </node>
+    <node id="connector166">
+      <data key="d0">connector</data>
+      <data key="d5">435</data>
+      <data key="d6">672</data>
+      <data key="d7">443</data>
+      <data key="d8">680</data>
+    </node>
+    <node id="crossing167">
+      <data key="d0">crossing</data>
+      <data key="d5">436</data>
+      <data key="d6">702</data>
+      <data key="d7">444</data>
+      <data key="d8">710</data>
+    </node>
+    <node id="connector168">
+      <data key="d0">connector</data>
+      <data key="d5">1132</data>
+      <data key="d6">815</data>
+      <data key="d7">1140</data>
+      <data key="d8">823</data>
+    </node>
+    <node id="connector169">
+      <data key="d0">connector</data>
+      <data key="d5">1133</data>
+      <data key="d6">873</data>
+      <data key="d7">1141</data>
+      <data key="d8">881</data>
+    </node>
+    <node id="crossing170">
+      <data key="d0">crossing</data>
+      <data key="d5">1052</data>
+      <data key="d6">963</data>
+      <data key="d7">1060</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="connector171">
+      <data key="d0">connector</data>
+      <data key="d5">1745</data>
+      <data key="d6">610</data>
+      <data key="d7">1753</data>
+      <data key="d8">618</data>
+    </node>
+    <node id="connector172">
+      <data key="d0">connector</data>
+      <data key="d5">1475</data>
+      <data key="d6">584</data>
+      <data key="d7">1483</data>
+      <data key="d8">592</data>
+    </node>
+    <node id="connector173">
+      <data key="d0">connector</data>
+      <data key="d5">329</data>
+      <data key="d6">526</data>
+      <data key="d7">337</data>
+      <data key="d8">534</data>
+    </node>
+    <node id="connector174">
+      <data key="d0">connector</data>
+      <data key="d5">330</data>
+      <data key="d6">526</data>
+      <data key="d7">338</data>
+      <data key="d8">534</data>
+    </node>
+    <node id="connector175">
+      <data key="d0">connector</data>
+      <data key="d5">644</data>
+      <data key="d6">816</data>
+      <data key="d7">652</data>
+      <data key="d8">824</data>
+    </node>
+    <node id="crossing176">
+      <data key="d0">crossing</data>
+      <data key="d5">691</data>
+      <data key="d6">814</data>
+      <data key="d7">699</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="crossing177">
+      <data key="d0">crossing</data>
+      <data key="d5">643</data>
+      <data key="d6">814</data>
+      <data key="d7">651</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="connector178">
+      <data key="d0">connector</data>
+      <data key="d5">809</data>
+      <data key="d6">1143</data>
+      <data key="d7">817</data>
+      <data key="d8">1151</data>
+    </node>
+    <node id="connector179">
+      <data key="d0">connector</data>
+      <data key="d5">781</data>
+      <data key="d6">1142</data>
+      <data key="d7">789</data>
+      <data key="d8">1150</data>
+    </node>
+    <node id="connector180">
+      <data key="d0">connector</data>
+      <data key="d5">999</data>
+      <data key="d6">491</data>
+      <data key="d7">1007</data>
+      <data key="d8">499</data>
+    </node>
+    <node id="connector181">
+      <data key="d0">connector</data>
+      <data key="d5">890</data>
+      <data key="d6">379</data>
+      <data key="d7">898</data>
+      <data key="d8">387</data>
+    </node>
+    <node id="crossing182">
+      <data key="d0">crossing</data>
+      <data key="d5">999</data>
+      <data key="d6">380</data>
+      <data key="d7">1007</data>
+      <data key="d8">388</data>
+    </node>
+    <node id="connector183">
+      <data key="d0">connector</data>
+      <data key="d5">1083</data>
+      <data key="d6">932</data>
+      <data key="d7">1091</data>
+      <data key="d8">940</data>
+    </node>
+    <node id="connector184">
+      <data key="d0">connector</data>
+      <data key="d5">1154</data>
+      <data key="d6">963</data>
+      <data key="d7">1162</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="connector185">
+      <data key="d0">connector</data>
+      <data key="d5">562</data>
+      <data key="d6">325</data>
+      <data key="d7">570</data>
+      <data key="d8">333</data>
+    </node>
+    <node id="connector186">
+      <data key="d0">connector</data>
+      <data key="d5">562</data>
+      <data key="d6">349</data>
+      <data key="d7">570</data>
+      <data key="d8">357</data>
+    </node>
+    <node id="crossing187">
+      <data key="d0">crossing</data>
+      <data key="d5">1235</data>
+      <data key="d6">673</data>
+      <data key="d7">1243</data>
+      <data key="d8">681</data>
+    </node>
+    <node id="crossing188">
+      <data key="d0">crossing</data>
+      <data key="d5">1236</data>
+      <data key="d6">802</data>
+      <data key="d7">1244</data>
+      <data key="d8">810</data>
+    </node>
+    <node id="connector189">
+      <data key="d0">connector</data>
+      <data key="d5">818</data>
+      <data key="d6">591</data>
+      <data key="d7">826</data>
+      <data key="d8">599</data>
+    </node>
+    <node id="crossing190">
+      <data key="d0">crossing</data>
+      <data key="d5">788</data>
+      <data key="d6">591</data>
+      <data key="d7">796</data>
+      <data key="d8">599</data>
+    </node>
+    <node id="connector191">
+      <data key="d0">connector</data>
+      <data key="d5">691</data>
+      <data key="d6">783</data>
+      <data key="d7">699</data>
+      <data key="d8">791</data>
+    </node>
+    <node id="connector192">
+      <data key="d0">connector</data>
+      <data key="d5">509</data>
+      <data key="d6">814</data>
+      <data key="d7">517</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="connector193">
+      <data key="d0">connector</data>
+      <data key="d5">691</data>
+      <data key="d6">1111</data>
+      <data key="d7">699</data>
+      <data key="d8">1119</data>
+    </node>
+    <node id="connector194">
+      <data key="d0">connector</data>
+      <data key="d5">564</data>
+      <data key="d6">1112</data>
+      <data key="d7">572</data>
+      <data key="d8">1120</data>
+    </node>
+    <node id="connector195">
+      <data key="d0">connector</data>
+      <data key="d5">1305</data>
+      <data key="d6">930</data>
+      <data key="d7">1313</data>
+      <data key="d8">938</data>
+    </node>
+    <node id="connector196">
+      <data key="d0">connector</data>
+      <data key="d5">1313</data>
+      <data key="d6">931</data>
+      <data key="d7">1321</data>
+      <data key="d8">939</data>
+    </node>
+    <node id="connector197">
+      <data key="d0">connector</data>
+      <data key="d5">890</data>
+      <data key="d6">366</data>
+      <data key="d7">898</data>
+      <data key="d8">374</data>
+    </node>
+    <node id="connector198">
+      <data key="d0">connector</data>
+      <data key="d5">894</data>
+      <data key="d6">360</data>
+      <data key="d7">902</data>
+      <data key="d8">368</data>
+    </node>
+    <node id="connector199">
+      <data key="d0">connector</data>
+      <data key="d5">1279</data>
+      <data key="d6">930</data>
+      <data key="d7">1287</data>
+      <data key="d8">938</data>
+    </node>
+    <node id="connector200">
+      <data key="d0">connector</data>
+      <data key="d5">1298</data>
+      <data key="d6">931</data>
+      <data key="d7">1306</data>
+      <data key="d8">939</data>
+    </node>
+    <node id="connector201">
+      <data key="d0">connector</data>
+      <data key="d5">436</data>
+      <data key="d6">663</data>
+      <data key="d7">444</data>
+      <data key="d8">671</data>
+    </node>
+    <node id="connector202">
+      <data key="d0">connector</data>
+      <data key="d5">435</data>
+      <data key="d6">657</data>
+      <data key="d7">443</data>
+      <data key="d8">665</data>
+    </node>
+    <node id="connector203">
+      <data key="d0">connector</data>
+      <data key="d5">490</data>
+      <data key="d6">815</data>
+      <data key="d7">498</data>
+      <data key="d8">823</data>
+    </node>
+    <node id="connector204">
+      <data key="d0">connector</data>
+      <data key="d5">329</data>
+      <data key="d6">623</data>
+      <data key="d7">337</data>
+      <data key="d8">631</data>
+    </node>
+    <node id="connector205">
+      <data key="d0">connector</data>
+      <data key="d5">330</data>
+      <data key="d6">622</data>
+      <data key="d7">338</data>
+      <data key="d8">630</data>
+    </node>
+    <node id="connector206">
+      <data key="d0">connector</data>
+      <data key="d5">609</data>
+      <data key="d6">814</data>
+      <data key="d7">617</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="connector207">
+      <data key="d0">connector</data>
+      <data key="d5">612</data>
+      <data key="d6">862</data>
+      <data key="d7">620</data>
+      <data key="d8">870</data>
+    </node>
+    <node id="crossing208">
+      <data key="d0">crossing</data>
+      <data key="d5">612</data>
+      <data key="d6">814</data>
+      <data key="d7">620</data>
+      <data key="d8">822</data>
+    </node>
+    <node id="connector209">
+      <data key="d0">connector</data>
+      <data key="d5">1167</data>
+      <data key="d6">962</data>
+      <data key="d7">1175</data>
+      <data key="d8">970</data>
+    </node>
+    <node id="connector210">
+      <data key="d0">connector</data>
+      <data key="d5">1050</data>
+      <data key="d6">932</data>
+      <data key="d7">1058</data>
+      <data key="d8">940</data>
+    </node>
+    <node id="connector211">
+      <data key="d0">connector</data>
+      <data key="d5">452</data>
+      <data key="d6">432</data>
+      <data key="d7">460</data>
+      <data key="d8">440</data>
+    </node>
+    <node id="connector212">
+      <data key="d0">connector</data>
+      <data key="d5">451</data>
+      <data key="d6">493</data>
+      <data key="d7">459</data>
+      <data key="d8">501</data>
+    </node>
+    <node id="connector213">
+      <data key="d0">connector</data>
+      <data key="d5">1234</data>
+      <data key="d6">802</data>
+      <data key="d7">1242</data>
+      <data key="d8">810</data>
+    </node>
+    <node id="connector214">
+      <data key="d0">connector</data>
+      <data key="d5">523</data>
+      <data key="d6">475</data>
+      <data key="d7">531</data>
+      <data key="d8">483</data>
+    </node>
+    <node id="connector215">
+      <data key="d0">connector</data>
+      <data key="d5">524</data>
+      <data key="d6">449</data>
+      <data key="d7">532</data>
+      <data key="d8">457</data>
+    </node>
+    <node id="connector216">
+      <data key="d0">connector</data>
+      <data key="d5">777</data>
+      <data key="d6">816</data>
+      <data key="d7">785</data>
+      <data key="d8">824</data>
+    </node>
+    <node id="connector217">
+      <data key="d0">connector</data>
+      <data key="d5">765</data>
+      <data key="d6">622</data>
+      <data key="d7">773</data>
+      <data key="d8">630</data>
+    </node>
+    <node id="crossing218">
+      <data key="d0">crossing</data>
+      <data key="d5">787</data>
+      <data key="d6">622</data>
+      <data key="d7">795</data>
+      <data key="d8">630</data>
+    </node>
+    <node id="connector219">
+      <data key="d0">connector</data>
+      <data key="d5">490</data>
+      <data key="d6">804</data>
+      <data key="d7">498</data>
+      <data key="d8">812</data>
+    </node>
+    <node id="connector220">
+      <data key="d0">connector</data>
+      <data key="d5">490</data>
+      <data key="d6">804</data>
+      <data key="d7">498</data>
+      <data key="d8">812</data>
+    </node>
+    <node id="connector221">
+      <data key="d0">connector</data>
+      <data key="d5">598</data>
+      <data key="d6">1143</data>
+      <data key="d7">606</data>
+      <data key="d8">1151</data>
+    </node>
+    <node id="connector222">
+      <data key="d0">connector</data>
+      <data key="d5">665</data>
+      <data key="d6">414</data>
+      <data key="d7">673</data>
+      <data key="d8">422</data>
+    </node>
+    <node id="connector223">
+      <data key="d0">connector</data>
+      <data key="d5">670</data>
+      <data key="d6">414</data>
+      <data key="d7">678</data>
+      <data key="d8">422</data>
+    </node>
+    <node id="connector224">
+      <data key="d0">connector</data>
+      <data key="d5">985</data>
+      <data key="d6">963</data>
+      <data key="d7">993</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="crossing225">
+      <data key="d0">crossing</data>
+      <data key="d5">948</data>
+      <data key="d6">963</data>
+      <data key="d7">956</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="connector226">
+      <data key="d0">connector</data>
+      <data key="d5">1132</data>
+      <data key="d6">892</data>
+      <data key="d7">1140</data>
+      <data key="d8">900</data>
+    </node>
+    <node id="connector227">
+      <data key="d0">connector</data>
+      <data key="d5">701</data>
+      <data key="d6">414</data>
+      <data key="d7">709</data>
+      <data key="d8">422</data>
+    </node>
+    <node id="crossing228">
+      <data key="d0">crossing</data>
+      <data key="d5">788</data>
+      <data key="d6">414</data>
+      <data key="d7">796</data>
+      <data key="d8">422</data>
+    </node>
+    <node id="connector229">
+      <data key="d0">connector</data>
+      <data key="d5">763</data>
+      <data key="d6">1143</data>
+      <data key="d7">771</data>
+      <data key="d8">1151</data>
+    </node>
+    <node id="connector230">
+      <data key="d0">connector</data>
+      <data key="d5">1405</data>
+      <data key="d6">597</data>
+      <data key="d7">1413</data>
+      <data key="d8">605</data>
+    </node>
+    <node id="connector231">
+      <data key="d0">connector</data>
+      <data key="d5">1408</data>
+      <data key="d6">591</data>
+      <data key="d7">1416</data>
+      <data key="d8">599</data>
+    </node>
+    <node id="connector232">
+      <data key="d0">connector</data>
+      <data key="d5">972</data>
+      <data key="d6">1067</data>
+      <data key="d7">980</data>
+      <data key="d8">1075</data>
+    </node>
+    <node id="crossing233">
+      <data key="d0">crossing</data>
+      <data key="d5">948</data>
+      <data key="d6">1066</data>
+      <data key="d7">956</data>
+      <data key="d8">1074</data>
+    </node>
+    <node id="connector234">
+      <data key="d0">connector</data>
+      <data key="d5">631</data>
+      <data key="d6">349</data>
+      <data key="d7">639</data>
+      <data key="d8">357</data>
+    </node>
+    <node id="connector235">
+      <data key="d0">connector</data>
+      <data key="d5">631</data>
+      <data key="d6">326</data>
+      <data key="d7">639</data>
+      <data key="d8">334</data>
+    </node>
+    <node id="connector236">
+      <data key="d0">connector</data>
+      <data key="d5">435</data>
+      <data key="d6">493</data>
+      <data key="d7">443</data>
+      <data key="d8">501</data>
+    </node>
+    <node id="connector237">
+      <data key="d0">connector</data>
+      <data key="d5">435</data>
+      <data key="d6">432</data>
+      <data key="d7">443</data>
+      <data key="d8">440</data>
+    </node>
+    <node id="connector238">
+      <data key="d0">connector</data>
+      <data key="d5">948</data>
+      <data key="d6">984</data>
+      <data key="d7">956</data>
+      <data key="d8">992</data>
+    </node>
+    <node id="connector239">
+      <data key="d0">connector</data>
+      <data key="d5">482</data>
+      <data key="d6">1133</data>
+      <data key="d7">490</data>
+      <data key="d8">1141</data>
+    </node>
+    <node id="connector240">
+      <data key="d0">connector</data>
+      <data key="d5">482</data>
+      <data key="d6">1133</data>
+      <data key="d7">490</data>
+      <data key="d8">1141</data>
+    </node>
+    <node id="connector241">
+      <data key="d0">connector</data>
+      <data key="d5">419</data>
+      <data key="d6">349</data>
+      <data key="d7">427</data>
+      <data key="d8">357</data>
+    </node>
+    <node id="connector242">
+      <data key="d0">connector</data>
+      <data key="d5">420</data>
+      <data key="d6">340</data>
+      <data key="d7">428</data>
+      <data key="d8">348</data>
+    </node>
+    <node id="connector243">
+      <data key="d0">connector</data>
+      <data key="d5">777</data>
+      <data key="d6">803</data>
+      <data key="d7">785</data>
+      <data key="d8">811</data>
+    </node>
+    <node id="connector244">
+      <data key="d0">connector</data>
+      <data key="d5">779</data>
+      <data key="d6">805</data>
+      <data key="d7">787</data>
+      <data key="d8">813</data>
+    </node>
+    <node id="connector245">
+      <data key="d0">connector</data>
+      <data key="d5">763</data>
+      <data key="d6">1133</data>
+      <data key="d7">771</data>
+      <data key="d8">1141</data>
+    </node>
+    <node id="connector246">
+      <data key="d0">connector</data>
+      <data key="d5">763</data>
+      <data key="d6">1133</data>
+      <data key="d7">771</data>
+      <data key="d8">1141</data>
+    </node>
+    <node id="connector247">
+      <data key="d0">connector</data>
+      <data key="d5">1005</data>
+      <data key="d6">946</data>
+      <data key="d7">1013</data>
+      <data key="d8">954</data>
+    </node>
+    <node id="connector248">
+      <data key="d0">connector</data>
+      <data key="d5">1007</data>
+      <data key="d6">944</data>
+      <data key="d7">1015</data>
+      <data key="d8">952</data>
+    </node>
+    <node id="connector249">
+      <data key="d0">connector</data>
+      <data key="d5">677</data>
+      <data key="d6">414</data>
+      <data key="d7">685</data>
+      <data key="d8">422</data>
+    </node>
+    <node id="connector250">
+      <data key="d0">connector</data>
+      <data key="d5">683</data>
+      <data key="d6">414</data>
+      <data key="d7">691</data>
+      <data key="d8">422</data>
+    </node>
+    <node id="connector251">
+      <data key="d0">connector</data>
+      <data key="d5">946</data>
+      <data key="d6">1142</data>
+      <data key="d7">954</data>
+      <data key="d8">1150</data>
+    </node>
+    <node id="crossing252">
+      <data key="d0">crossing</data>
+      <data key="d5">948</data>
+      <data key="d6">1142</data>
+      <data key="d7">956</data>
+      <data key="d8">1150</data>
+    </node>
+    <node id="connector253">
+      <data key="d0">connector</data>
+      <data key="d5">436</data>
+      <data key="d6">1141</data>
+      <data key="d7">444</data>
+      <data key="d8">1149</data>
+    </node>
+    <node id="connector254">
+      <data key="d0">connector</data>
+      <data key="d5">482</data>
+      <data key="d6">1143</data>
+      <data key="d7">490</data>
+      <data key="d8">1151</data>
+    </node>
+    <node id="crossing255">
+      <data key="d0">crossing</data>
+      <data key="d5">436</data>
+      <data key="d6">1142</data>
+      <data key="d7">444</data>
+      <data key="d8">1150</data>
+    </node>
+    <node id="connector256">
+      <data key="d0">connector</data>
+      <data key="d5">587</data>
+      <data key="d6">349</data>
+      <data key="d7">595</data>
+      <data key="d8">357</data>
+    </node>
+    <node id="connector257">
+      <data key="d0">connector</data>
+      <data key="d5">588</data>
+      <data key="d6">340</data>
+      <data key="d7">596</data>
+      <data key="d8">348</data>
+    </node>
+    <node id="connector258">
+      <data key="d0">connector</data>
+      <data key="d5">1386</data>
+      <data key="d6">609</data>
+      <data key="d7">1394</data>
+      <data key="d8">617</data>
+    </node>
+    <node id="crossing259">
+      <data key="d0">crossing</data>
+      <data key="d5">1236</data>
+      <data key="d6">609</data>
+      <data key="d7">1244</data>
+      <data key="d8">617</data>
+    </node>
+    <node id="connector260">
+      <data key="d0">connector</data>
+      <data key="d5">1265</data>
+      <data key="d6">675</data>
+      <data key="d7">1273</data>
+      <data key="d8">683</data>
+    </node>
+    <node id="connector261">
+      <data key="d0">connector</data>
+      <data key="d5">595</data>
+      <data key="d6">432</data>
+      <data key="d7">603</data>
+      <data key="d8">440</data>
+    </node>
+    <node id="connector262">
+      <data key="d0">connector</data>
+      <data key="d5">595</data>
+      <data key="d6">493</data>
+      <data key="d7">603</data>
+      <data key="d8">501</data>
+    </node>
+    <node id="connector263">
+      <data key="d0">connector</data>
+      <data key="d5">1005</data>
+      <data key="d6">963</data>
+      <data key="d7">1013</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="connector264">
+      <data key="d0">connector</data>
+      <data key="d5">466</data>
+      <data key="d6">702</data>
+      <data key="d7">474</data>
+      <data key="d8">710</data>
+    </node>
+    <node id="connector265">
+      <data key="d0">connector</data>
+      <data key="d5">1237</data>
+      <data key="d6">930</data>
+      <data key="d7">1245</data>
+      <data key="d8">938</data>
+    </node>
+    <node id="crossing266">
+      <data key="d0">crossing</data>
+      <data key="d5">1236</data>
+      <data key="d6">931</data>
+      <data key="d7">1244</data>
+      <data key="d8">939</data>
+    </node>
+    <node id="connector267">
+      <data key="d0">connector</data>
+      <data key="d5">948</data>
+      <data key="d6">971</data>
+      <data key="d7">956</data>
+      <data key="d8">979</data>
+    </node>
+    <node id="connector268">
+      <data key="d0">connector</data>
+      <data key="d5">1305</data>
+      <data key="d6">963</data>
+      <data key="d7">1313</data>
+      <data key="d8">971</data>
+    </node>
+    <node id="connector269">
+      <data key="d0">connector</data>
+      <data key="d5">1313</data>
+      <data key="d6">962</data>
+      <data key="d7">1321</data>
+      <data key="d8">970</data>
+    </node>
+    <node id="connector270">
+      <data key="d0">connector</data>
+      <data key="d5">644</data>
+      <data key="d6">1155</data>
+      <data key="d7">652</data>
+      <data key="d8">1163</data>
+    </node>
+    <node id="connector271">
+      <data key="d0">connector</data>
+      <data key="d5">645</data>
+      <data key="d6">1195</data>
+      <data key="d7">653</data>
+      <data key="d8">1203</data>
+    </node>
+    <node id="connector272">
+      <data key="d0">connector</data>
+      <data key="d5">870</data>
+      <data key="d6">379</data>
+      <data key="d7">878</data>
+      <data key="d8">387</data>
+    </node>
+    <node id="connector273">
+      <data key="d0">connector</data>
+      <data key="d5">681</data>
+      <data key="d6">380</data>
+      <data key="d7">689</data>
+      <data key="d8">388</data>
+    </node>
+    <node id="connector274">
+      <data key="d0">connector</data>
+      <data key="d5">612</data>
+      <data key="d6">1195</data>
+      <data key="d7">620</data>
+      <data key="d8">1203</data>
+    </node>
+    <node id="connector275">
+      <data key="d0">connector</data>
+      <data key="d5">610</data>
+      <data key="d6">1142</data>
+      <data key="d7">618</data>
+      <data key="d8">1150</data>
+    </node>
+    <node id="crossing276">
+      <data key="d0">crossing</data>
+      <data key="d5">611</data>
+      <data key="d6">1142</data>
+      <data key="d7">619</data>
+      <data key="d8">1150</data>
+    </node>
+    <node id="connector277">
+      <data key="d0">connector</data>
+      <data key="d5">1483</data>
+      <data key="d6">911</data>
+      <data key="d7">1491</data>
+      <data key="d8">919</data>
+    </node>
+    <node id="connector278">
+      <data key="d0">connector</data>
+      <data key="d5">1483</data>
+      <data key="d6">912</data>
+      <data key="d7">1491</data>
+      <data key="d8">920</data>
+    </node>
+    <node id="connector279">
+      <data key="d0">connector</data>
+      <data key="d5">673</data>
+      <data key="d6">379</data>
+      <data key="d7">681</data>
+      <data key="d8">387</data>
+    </node>
+    <node id="connector280">
+      <data key="d0">connector</data>
+      <data key="d5">665</data>
+      <data key="d6">380</data>
+      <data key="d7">673</data>
+      <data key="d8">388</data>
+    </node>
+    <edge source="arrow1" target="connector157">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow1" target="connector253">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow2" target="connector152">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow2" target="connector251">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation3" target="connector100">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow4" target="connector238">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow4" target="connector267">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow5" target="connector123">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow5" target="connector128">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow7" target="connector115">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow7" target="connector168">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve8" target="connector227">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve8" target="connector250">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general9" target="connector173">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve10" target="instrumentation66">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve10" target="connector164">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve10" target="connector230">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve10" target="connector258">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation11" target="connector198">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve12" target="connector108">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve12" target="connector134">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general13" target="connector204">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector98">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector106">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector114">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector136">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector186">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector211">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector222">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector234">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector237">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector241">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector256">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector261">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank14" target="connector280">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general15" target="connector242">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="inlet/outlet16" target="connector171">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve17" target="connector131">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve17" target="connector217">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector102">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector113">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector143">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector159">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector174">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector202">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector205">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector212">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector236">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="tank18" target="connector262">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve19" target="instrumentation57">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve19" target="connector104">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve19" target="connector240">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve19" target="connector254">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation20" target="connector103">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="pump21" target="connector271">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="pump21" target="connector274">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve22" target="instrumentation38">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve22" target="connector110">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve22" target="connector216">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve22" target="connector243">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve23" target="connector181">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve23" target="connector197">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve23" target="connector272">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve24" target="instrumentation51">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve24" target="connector224">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve24" target="connector247">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve24" target="connector263">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general25" target="connector107">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve26" target="connector129">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve26" target="connector210">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve27" target="connector96">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve27" target="connector183">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve29" target="connector140">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve29" target="connector169">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve29" target="connector226">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation30" target="connector191">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general31" target="connector257">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general33" target="connector135">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general33" target="connector215">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation34" target="connector189">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow36" target="connector146">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow36" target="connector150">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general37" target="connector277">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation38" target="connector244">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general39" target="connector153">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general40" target="connector138">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation41" target="connector260">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general42" target="connector160">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general42" target="connector214">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general43" target="connector133">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general43" target="connector268">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general44" target="connector195">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general44" target="connector200">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="pump45" target="connector155">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="pump45" target="connector207">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general46" target="connector145">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general46" target="connector199">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow47" target="connector184">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow47" target="connector209">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general48" target="connector223">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general48" target="connector249">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general49" target="connector273">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general49" target="connector279">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general50" target="connector142">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation51" target="connector248">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation53" target="connector139">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general54" target="connector166">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general54" target="connector201">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general55" target="connector137">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general55" target="connector154">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general55" target="connector196">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general55" target="connector269">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="general55" target="connector278">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow56" target="connector148">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow56" target="connector213">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation57" target="connector239">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow58" target="connector118">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow58" target="connector270">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation59" target="connector193">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve60" target="instrumentation76">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve60" target="connector179">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve60" target="connector229">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve60" target="connector245">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation61" target="valve67">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation61" target="connector219">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation62" target="connector130">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow63" target="connector156">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow63" target="connector175">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow65" target="connector93">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow65" target="connector180">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation66" target="connector231">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve67" target="connector192">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve67" target="connector203">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve67" target="connector220">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation68" target="connector232">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation69" target="connector141">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow70" target="connector97">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow70" target="connector161">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow72" target="connector144">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow72" target="connector265">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation73" target="connector194">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation76" target="connector246">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve77" target="connector151">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve77" target="connector178">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation78" target="connector126">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation79" target="connector172">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="inlet/outlet82" target="connector124">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation83" target="connector264">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow84" target="connector221">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow84" target="connector275">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve86" target="connector111">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="valve86" target="connector149">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation87" target="connector99">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation88" target="instrumentation90">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="inlet/outlet89" target="connector162">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation90" target="connector235">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="instrumentation91" target="connector185">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow92" target="connector112">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="arrow92" target="connector206">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector93" target="crossing95">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing94" target="crossing95">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing94" target="crossing147">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing94" target="crossing225">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector96" target="connector97">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector98" target="connector99">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector100" target="crossing101">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing101" target="connector112">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing101" target="connector192">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector102" target="connector103">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector104" target="crossing105">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing105" target="connector194">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing105" target="connector221">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector106" target="connector107">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector108" target="crossing109">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing109" target="connector141">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing109" target="connector209">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector110" target="connector111">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector113" target="connector114">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector115" target="crossing117">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing116" target="crossing117">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing116" target="connector130">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing116" target="connector148">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector118" target="crossing120">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing119" target="crossing120">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing119" target="connector193">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing119" target="connector229">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing121" target="crossing122">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing121" target="crossing170">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing121" target="connector183">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing122" target="connector184">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing122" target="connector226">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector123" target="crossing125">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector124" target="crossing125">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector126" target="crossing127">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing127" target="crossing218">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing127" target="crossing228">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector128" target="connector129">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector131" target="crossing132">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector133" target="connector134">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector135" target="connector136">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector137" target="connector138">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector139" target="connector140">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector142" target="connector143">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector144" target="connector145">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector146" target="crossing147">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector149" target="connector150">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector151" target="connector152">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector153" target="connector154">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector155" target="connector156">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector157" target="crossing158">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing158" target="connector203">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing158" target="crossing167">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector159" target="connector160">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector161" target="crossing163">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector162" target="crossing163">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector164" target="crossing165">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing165" target="connector171">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing165" target="connector172">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector166" target="crossing167">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing167" target="connector264">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector168" target="connector169">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing170" target="connector210">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing170" target="connector263">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector173" target="connector174">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector175" target="crossing177">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing176" target="crossing177">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing176" target="connector191">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing176" target="connector216">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector178" target="connector179">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector180" target="crossing182">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector181" target="crossing182">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector185" target="connector186">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing187" target="crossing188">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing187" target="crossing259">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing187" target="connector260">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing188" target="connector213">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing188" target="crossing266">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector189" target="crossing190">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector195" target="connector196">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector197" target="connector198">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector199" target="connector200">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector201" target="connector202">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector204" target="connector205">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector206" target="crossing208">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector207" target="crossing208">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector211" target="connector212">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector214" target="connector215">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector217" target="crossing218">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector219" target="connector220">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector222" target="connector223">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector224" target="crossing225">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing225" target="connector267">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector227" target="crossing228">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector230" target="connector231">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector232" target="crossing233">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing233" target="connector238">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="crossing233" target="crossing252">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector234" target="connector235">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector236" target="connector237">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector239" target="connector240">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector241" target="connector242">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector243" target="connector244">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector245" target="connector246">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector247" target="connector248">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector249" target="connector250">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector251" target="crossing252">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector253" target="crossing255">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector254" target="crossing255">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector256" target="connector257">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector258" target="crossing259">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector261" target="connector262">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector265" target="crossing266">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector268" target="connector269">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector270" target="connector271">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector272" target="connector273">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector274" target="crossing276">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector275" target="crossing276">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector277" target="connector278">
+      <data key="d9">solid</data>
+    </edge>
+    <edge source="connector279" target="connector280">
+      <data key="d9">solid</data>
+    </edge>
+  </graph>
+</graphml>