Upload 9 files

README.txt

@@ -0,0 +1,126 @@
+HEG BRep Component Identification — Distribution Bundle
+=========================================================
+
+This folder is a self-contained Windows distribution. It runs without any
+pre-installed Python or conda. Drop the whole folder next to your viewer's
+installer; the viewer launches `heg_brep_service.bat` as a child process and
+talks to it over localhost HTTP.
+
+
+Contents
+--------
+heg_brep_service.bat   Launches the classification service. Prints
+                         `READY port=<N>` to stdout once models are loaded.
+                         Use `--device cpu` (default) or `--device cuda`.
+heg_brep_batch.bat     Optional batch CLI: STEP folder -> Excel report.
+                         Useful for offline regression testing.
+python\                 Conda-packed Python 3.10 environment (~2 GB).
+                         Includes pythonocc-core, occwl, torch (CPU),
+                         torch_geometric, fastapi, uvicorn, numpy, MKL.
+heg_brep\               The classification package (model, inference,
+                         extraction, server, batch CLI).
+BRepExtractor\          STEP -> NPZ feature extraction pipeline.
+models\                 Three checkpoints used by the two-pass classifier:
+                         pass1.pt (parent), elbow.pt, tee.pt.
+csharp_sample\          Reference C# integration: HegBrepClient.cs is a
+                         drop-in async client; Program.cs is a smoke test
+                         (build with `dotnet build`).
+
+
+Quick smoke test
+----------------
+From this folder, in a regular cmd.exe:
+
+  heg_brep_batch.bat C:\path\to\step_folder C:\path\to\out.xlsx
+
+Or run the service standalone and poke it with curl:
+
+  heg_brep_service.bat
+    (waits ~10-15s; prints `READY port=51571`)
+  curl http://127.0.0.1:51571/health
+  curl -X POST http://127.0.0.1:51571/classify ^
+       -H "Content-Type: application/json" ^
+       -d "{\"step_path\":\"C:\\path\\to\\part.step\"}"
+
+
+Service HTTP API
+----------------
+GET  /health
+       -> {"status":"ok","models_loaded":true,"device":"cpu","uptime_sec":...}
+
+POST /classify           Single STEP file -> classification result.
+       Body:  {"step_path": "C:\\full\\path\\to\\part.step",
+               "npz_keep_dir": "optional\\persist\\dir"}
+       Resp:  {"status":"ok",
+               "final_label": "4_tee_wf",
+               "final_conf": 0.9997,
+               "route": "tee",
+               "pass1_argmax": "tee", "pass1_conf": 1.0,
+               "pass2_argmax": "4_tee_wf", "pass2_predicted": "4_tee_wf",
+               "pass2_conf": 0.9997,
+               "npz_path": "...", "step_path": "..."}
+
+POST /classify_batch     Multiple STEPs in one call. Same JSON schema,
+                         but body is `{"step_paths": ["...", "..."]}`.
+
+POST /shutdown           Graceful exit. The host (your viewer) should call
+                         this on exit so the python.exe child doesn't linger.
+
+
+Performance budget (RTX 3050 laptop, --device cpu)
+--------------------------------------------------
+Service startup:       ~10-15s   (OCC + torch + 3 models cold-load)
+First /classify call:  ~1.0s     (single STEP extract + inference)
+Warm /classify calls:  ~0.8s     (warm OCC stack, varies with STEP size)
+
+Switch to `--device cuda` for ~5-10x faster inference if the target machine
+has CUDA 12.x drivers + a supported GPU. With CPU torch (default), no NVIDIA
+runtime is required.
+
+
+Output label space
+------------------
+Pass-1 (parent classifier): elbow | tee | pipe | miscellaneous
+Pass-2 elbow specialist:    1_elbow_wf | 2_elbow_pef | 3_elbow_sf | 8_elbow_misc
+Pass-2 tee specialist:      4_tee_wf | 5_tee_pef | 6_tee_sf | 9_tee_misc
+
+For pipe / miscellaneous routes the response has `final_label="random"` with
+the pass-1 confidence (no specialist exists for those families).
+
+
+C# integration
+--------------
+See csharp_sample/HegBrepClient.cs for a drop-in async client. Typical usage:
+
+    var client = new HegBrepClient();
+    await client.StartAsync(@"C:\Program Files\YourViewer\heg_brep\heg_brep_service.bat");
+    // Later, when user clicks "Identify":
+    var r = await client.ClassifyAsync(@"C:\tmp\selection.step");
+    label.Text = $"{r.FinalLabel} ({r.FinalConf:P1})";
+    // On viewer exit:
+    await client.StopAsync();
+
+The client spawns the .bat as a child process, reads the `READY port=<N>`
+line from its stdout, then POSTs to http://127.0.0.1:<N>/classify. Stderr is
+forwarded to Debug.WriteLine for your logger to capture.
+
+
+Troubleshooting
+---------------
+* "DLL load failed" on first run.
+    The bat sets PATH to include python\Library\bin where MKL / OCC DLLs
+    live. If you launch python.exe directly without the bat, you'll hit this.
+
+* Cold service start takes 30+ seconds.
+    The first run after extracting the zip is slow because Windows loads each
+    DLL from disk for the first time. Subsequent starts are ~5-10s once the
+    OS file cache is warm.
+
+* "Bodies which are not closed are not supported".
+    Upstream extractor limitation. Some STEP files (typically Inventor
+    exports without explicit BREP closure) cannot be processed. The HTTP
+    response is {"status": "extraction_failed", "error": "..."}.
+
+* `KMP_DUPLICATE_LIB_OK=TRUE` warning.
+    Set automatically. Coexists fine with both OpenMP runtimes; the warning
+    is overly conservative for inference.

__init__.py

@@ -0,0 +1,18 @@
+"""HEG BRep two-pass component-identification pipeline (unified, in-process)."""
+import os
+# Two OpenMP runtimes (MKL's libiomp5md + torch's libomp) get loaded into the
+# same process because conda's numpy and pip-installed torch don't share an OMP
+# build. The duplicate-load check is overly conservative for inference workloads;
+# allow it.
+os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
+
+from pathlib import Path
+
+PACKAGE_ROOT = Path(__file__).resolve().parent
+REPO_ROOT = PACKAGE_ROOT.parent
+
+DEFAULT_PASS1_MODEL = REPO_ROOT / "brep_two_pass" / "artifacts" / "pass1_parent_brep_v1" / "best_model_halfedge.pt"
+DEFAULT_ELBOW_MODEL = REPO_ROOT / "artifacts_he_elbow_only_v4" / "best_model_halfedge.pt"
+DEFAULT_TEE_MODEL   = REPO_ROOT / "artifacts_he_tee_only_v1" / "best_model_halfedge.pt"
+DEFAULT_FEATURE_LIST = REPO_ROOT / "BRepExtractor" / "feature_lists" / "all.json"
+DEFAULT_BREPEXTRACTOR_DIR = REPO_ROOT / "BRepExtractor"

batch.py

@@ -0,0 +1,132 @@
+"""Batch CLI: STEP folder -> Excel. Single process, models loaded once."""
+from __future__ import annotations
+import argparse
+import sys
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List
+
+from openpyxl import Workbook
+
+from heg_brep import (
+    DEFAULT_PASS1_MODEL, DEFAULT_ELBOW_MODEL, DEFAULT_TEE_MODEL, REPO_ROOT,
+)
+from heg_brep.inference import LoadedModel, TwoPassClassifier
+from heg_brep.extraction import extract_folder_to_npz
+
+
+COLUMNS = [
+    "file_name", "file_path", "stem", "status",
+    "pass1_argmax", "pass1_conf", "route",
+    "pass2_argmax", "pass2_predicted", "pass2_conf",
+    "final_label", "final_conf", "npz_path", "note",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("step_folder")
+    ap.add_argument("output_excel", nargs="?", default=None,
+                    help="Defaults to ./brep_two_pass_<timestamp>.xlsx")
+    ap.add_argument("--pass1_model", default=str(DEFAULT_PASS1_MODEL))
+    ap.add_argument("--elbow_model", default=str(DEFAULT_ELBOW_MODEL))
+    ap.add_argument("--tee_model",   default=str(DEFAULT_TEE_MODEL))
+    ap.add_argument("--device", default="cpu", choices=["cpu", "cuda"])
+    ap.add_argument("--pass2_min_conf", type=float, default=0.85)
+    ap.add_argument("--pass2_tau", type=float, default=0.0)
+    ap.add_argument("--num_workers", type=int, default=1)
+    ap.add_argument("--max_file_mb", type=float, default=None)
+    ap.add_argument("--npz_dir", default=None, help="Persist NPZs here (default: temp).")
+    return ap.parse_args()
+
+
+def write_excel(rows: List[Dict[str, object]], output_excel: Path) -> None:
+    wb = Workbook()
+    ws = wb.active
+    ws.title = "brep_two_pass"
+    ws.append(COLUMNS)
+    for r in rows:
+        ws.append([r.get(c, "") for c in COLUMNS])
+    for col in ws.columns:
+        letter = col[0].column_letter
+        max_len = max((len(str(c.value)) if c.value is not None else 0 for c in col), default=0)
+        ws.column_dimensions[letter].width = min(max(12, max_len + 2), 70)
+    output_excel.parent.mkdir(parents=True, exist_ok=True)
+    wb.save(output_excel)
+
+
+def main() -> int:
+    args = parse_args()
+    step_folder = Path(args.step_folder).expanduser().resolve()
+    if not step_folder.is_dir():
+        raise FileNotFoundError(f"step_folder not found: {step_folder}")
+
+    output_excel = (Path(args.output_excel).expanduser().resolve()
+                    if args.output_excel
+                    else REPO_ROOT / f"brep_two_pass_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx")
+    npz_dir = (Path(args.npz_dir).expanduser().resolve() if args.npz_dir
+               else Path(tempfile.mkdtemp(prefix="heg_brep_npz_")))
+
+    print(f"Extracting STEP files in {step_folder} -> {npz_dir}")
+    t0 = datetime.now()
+    summary = extract_folder_to_npz(
+        step_folder, output_dir=npz_dir,
+        num_workers=args.num_workers, max_file_mb=args.max_file_mb,
+    )
+    print(f"  extraction took {(datetime.now() - t0).total_seconds():.1f}s "
+          f"({len(summary['ok_stems'])} OK, {len(summary['skipped'])} skipped)")
+
+    print(f"Loading models on {args.device}...")
+    t0 = datetime.now()
+    pass1 = LoadedModel(Path(args.pass1_model), device=args.device)
+    elbow = LoadedModel(Path(args.elbow_model), device=args.device) if Path(args.elbow_model).exists() else None
+    tee   = LoadedModel(Path(args.tee_model),   device=args.device) if Path(args.tee_model).exists()   else None
+    clf = TwoPassClassifier(pass1=pass1, elbow=elbow, tee=tee,
+                            pass2_min_conf=args.pass2_min_conf, pass2_tau=args.pass2_tau)
+    print(f"  models loaded in {(datetime.now() - t0).total_seconds():.1f}s")
+
+    print(f"Classifying {len(summary['step_paths'])} files...")
+    t0 = datetime.now()
+    rows: List[Dict[str, object]] = []
+    ok = pass1_failed = pass2_failed = extraction_failed = 0
+    for sp in summary["step_paths"]:
+        stem = sp.stem
+        base = {c: "" for c in COLUMNS}
+        base.update({"file_name": sp.name, "file_path": str(sp), "stem": stem})
+        npz = npz_dir / f"{stem}.npz"
+        if not npz.exists():
+            base["status"] = "EXTRACTION_FAILED"
+            base["note"] = summary["skipped"].get(stem, "NPZ missing after extraction")
+            extraction_failed += 1
+            rows.append(base); continue
+        base["npz_path"] = str(npz)
+        try:
+            result = clf.classify_npz(npz)
+        except Exception as exc:
+            base["status"] = "INFERENCE_FAILED"
+            base["note"] = str(exc)[:500]
+            pass1_failed += 1
+            rows.append(base); continue
+        base.update({k: result.get(k, "") for k in result})
+        # Round confidences for the spreadsheet
+        for k in ("pass1_conf", "pass2_conf", "final_conf"):
+            v = base.get(k)
+            base[k] = round(float(v), 6) if isinstance(v, (int, float)) else v
+        base["status"] = "OK"
+        ok += 1
+        rows.append(base)
+
+    elapsed = (datetime.now() - t0).total_seconds()
+    print(f"  inference took {elapsed:.1f}s ({elapsed / max(1, len(rows)):.2f}s/file)")
+
+    write_excel(rows, output_excel)
+    print(f"Saved Excel: {output_excel}")
+    print(f"Summary -> total: {len(rows)} | OK: {ok} | "
+          f"extraction_failed: {extraction_failed} | inference_failed: {pass1_failed}")
+    print(f"NPZ dir: {npz_dir}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

explanation.txt

@@ -0,0 +1,119 @@
+HEG BRep Component Identifier — integration brief
+What it is
+A self-contained Windows folder (~2.1 GB unpacked) that runs an ML classifier for STEP-format CAD parts. Given a STEP file path, it returns a component label (elbow, tee, pipe, miscellaneous, plus a subtype for elbows/tees).
+
+It is not a DLL. It's a local HTTP service that runs as a child process of our viewer. The classifier is a PyTorch model behind a FastAPI server. The whole Python stack — interpreter, OCC kernel, torch, model weights — is bundled inside the folder. No Python install required on the user's machine.
+
+Architecture
+
+┌──────────────────────────┐                          ┌──────────────────────────────┐
+│  Our C# 3D Viewer        │   spawn child + stdout   │  heg_brep_service.bat        │
+│  (parent process)        │ ───────────────────────► │  (our launcher)              │
+│                          │                          │     └─► python.exe           │
+│  On viewer startup:      │   read line:             │         └─► FastAPI server   │
+│   - Process.Start(bat)   │ ◄───────────────────────│              on 127.0.0.1    │
+│   - read "READY port=N"  │   "READY port=51571"     │              :random_port    │
+│                          │                          │                              │
+│  On user click:          │   POST /classify         │  Loads models once at        │
+│   - HttpClient.PostAsync │ ───────────────────────► │  startup. Per-request:       │
+│   - JSON body            │ ◄─────────────────────── │  STEP → OCC features →       │
+│     {step_path: "..."}   │   JSON response          │  GNN classifier → JSON       │
+│                          │                          │                              │
+│  On viewer exit:         │   POST /shutdown         │                              │
+│   - StopAsync()          │ ───────────────────────► │  Graceful exit               │
+└──────────────────────────┘                          └──────────────────────────────┘
+Two key properties:
+
+One process per viewer instance. Service lifetime == viewer lifetime.
+Loopback only. Binds to 127.0.0.1, never exposed to the network. No firewall prompts.
+The API contract
+Endpoint	Method	Body	Returns
+/health	GET	—	{"status":"ok","models_loaded":true,"device":"cpu","uptime_sec":...}
+/classify	POST	{"step_path":"C:\\full\\path.step"}	classification JSON (below)
+/classify_batch	POST	{"step_paths":["...","..."]}	{"results":[...]}
+/shutdown	POST	—	{"status":"shutting_down"} (service exits ~200ms later)
+Successful /classify response:
+
+
+{
+  "status": "ok",
+  "final_label": "4_tee_wf",
+  "final_conf": 0.9997,
+  "route": "tee",
+  "pass1_argmax": "tee",       "pass1_conf": 1.0,
+  "pass2_argmax": "4_tee_wf",  "pass2_predicted": "4_tee_wf",  "pass2_conf": 0.9997,
+  "step_path": "C:\\...\\part.step",
+  "npz_path": "C:\\Users\\...\\AppData\\Local\\Temp\\heg_brep_npz_xxx\\part.npz"
+}
+Error responses (HTTP 200 with an error status field, not HTTP 4xx — so the C# code branches on status):
+
+
+{"step_path": "...", "status": "extraction_failed", "error": "Bodies which are not closed are not supported"}
+{"step_path": "...", "status": "inference_failed",  "error": "..."}
+{"step_path": "...", "status": "error",             "error": "step_path not found"}
+Label space
+Pass-1 (parent classifier): elbow / tee / pipe / miscellaneous
+Pass-2 elbow subtypes: 1_elbow_wf / 2_elbow_pef / 3_elbow_sf / 8_elbow_misc
+Pass-2 tee subtypes: 4_tee_wf / 5_tee_pef / 6_tee_sf / 9_tee_misc
+Pipe / miscellaneous: final_label is random (no specialist for these families). Use pass1_argmax if you need the parent label.
+*_wf = welded fitting, *_pef / *_sf = other manufacturing subtypes, *_misc = within-family unclassified.
+
+What you need to implement in C#
+There's a working reference client in dist/heg_brep_dist/csharp_sample/ (~150 lines). It targets .NET 6 but works on .NET Framework 4.7.2+ with no changes. Usage:
+
+
+var client = new HegBrepClient();
+
+// At viewer startup (or lazily on first identify request — your call):
+await client.StartAsync(@"C:\Program Files\OurViewer\heg_brep\heg_brep_service.bat");
+
+// When the user clicks "Identify component":
+var stepPath = await ExportCurrentSelectionToTempStep();   // your existing OCC export
+var result = await client.ClassifyAsync(stepPath);
+labelControl.Text = $"{result.FinalLabel} ({result.FinalConf:P1})";
+
+// On viewer shutdown:
+await client.StopAsync();
+The client class handles: spawning the bat, reading the READY port=N line from stdout, posting JSON, parsing responses, graceful shutdown with a Kill fallback.
+
+Performance budget
+Measured on a developer laptop (RTX 3050, but service runs on CPU):
+
+Event	Cost
+Service startup	10–15 s (paid once per viewer launch)
+First /classify after startup	~1.0 s
+Subsequent /classify calls	~0.8 s (dominated by OCC feature extraction; inference itself is ~50 ms)
+For UX, recommend you start the service eagerly at viewer launch (hide behind splash) or lazily on first Identify click (show a "warming up..." spinner for ~10 s).
+
+Failure modes you must handle
+Service won't start (heg_brep_service.bat exits before READY line) → log stderr (the client forwards it to Debug.WriteLine), surface error to user, do not retry in a tight loop.
+STEP fails extraction ("Bodies which are not closed are not supported" is the most common one — Inventor exports sometimes hit this). Branch on status != "ok".
+Service hangs / takes too long — HegBrepClient has a 60-second timeout. If ClassifyAsync throws TaskCanceledException, the service is wedged. Call StopAsync() and restart.
+Service crashes mid-session — process exits, next ClassifyAsync will throw a connection error. Recovery: catch, call StartAsync() again, retry once.
+A small supervisor that restarts the service on crash (max 3 retries per session) is a reasonable addition.
+
+What's in the bundle
+
+heg_brep_dist/
+├── heg_brep_service.bat    ← what you Process.Start
+├── heg_brep_batch.bat      ← offline regression-test tool, irrelevant for the viewer
+├── README.txt              ← detailed docs
+├── python/                 ← bundled Python 3.10 env (do not modify)
+├── heg_brep/               ← our Python code
+├── BRepExtractor/          ← STEP→features pipeline
+├── models/                 ← 3 model files (~94 MB total)
+└── csharp_sample/          ← HegBrepClient.cs + Program.cs (copy into your project)
+Installer should drop this whole folder somewhere under the viewer's install dir (e.g. Program Files\OurViewer\heg_brep\) and never modify it. Updates ship as a new folder replacement; viewer code doesn't change.
+
+Constraints / non-goals
+Windows x64 only. Linux / macOS / 32-bit not supported.
+CPU inference by default. A CUDA variant exists (separate ~2 GB bundle) if customers have NVIDIA GPUs — currently not packaged.
+STEP input only. Other CAD formats (IGES, JT, native Inventor/SolidWorks) would need a converter layer first.
+Single-threaded service. Don't fire concurrent /classify calls from multiple viewer threads — they'll serialize anyway. If you need parallelism, queue requests in C#.
+Questions to send back
+If anything in the contract is unclear, the things most worth raising before coding starts:
+
+Where in the installer layout should heg_brep_dist/ live? That determines the path you pass to StartAsync.
+Eager vs. lazy service startup — affects splash-screen design.
+How does the viewer currently export a selected solid to a STEP file? (We need a file path, not in-memory geometry, in v1.)
+Logging — should service stderr go to the viewer's existing log file, or to its own file alongside the bundle?

extraction.py

@@ -0,0 +1,118 @@
+"""In-process STEP -> NPZ extraction (no subprocess)."""
+from __future__ import annotations
+import json
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from heg_brep import DEFAULT_BREPEXTRACTOR_DIR, DEFAULT_FEATURE_LIST
+
+# Make the BRepExtractor package importable (it is laid out as `pipeline.*`)
+if str(DEFAULT_BREPEXTRACTOR_DIR) not in sys.path:
+    sys.path.insert(0, str(DEFAULT_BREPEXTRACTOR_DIR))
+
+
+def _load_feature_schema(feature_list: Path) -> dict:
+    with open(feature_list, "r") as fp:
+        return json.load(fp)
+
+
+def extract_step_to_npz(step_file: Path,
+                        output_dir: Optional[Path] = None,
+                        feature_list: Path = DEFAULT_FEATURE_LIST) -> Path:
+    """Extract a single STEP to an NPZ. Returns the produced NPZ path.
+
+    Raises RuntimeError if extraction fails or the file is skipped.
+    """
+    from pipeline.extract_brep_extractor_data_from_step import extract_brep_extractor_features
+
+    step_file = Path(step_file).expanduser().resolve()
+    if not step_file.exists():
+        raise FileNotFoundError(step_file)
+    if output_dir is None:
+        output_dir = Path(tempfile.mkdtemp(prefix="heg_brep_npz_"))
+    output_dir = Path(output_dir).expanduser().resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    schema = _load_feature_schema(feature_list)
+    ok = extract_brep_extractor_features(step_file, output_dir, schema, mesh_dir=None, seg_dir=None)
+    npz = output_dir / f"{step_file.stem}.npz"
+    if not ok or not npz.exists():
+        reason = _last_skip_reason_for(step_file, output_dir) or "unknown extraction failure"
+        raise RuntimeError(f"Extraction failed for {step_file.name}: {reason}")
+    return npz
+
+
+def extract_folder_to_npz(step_folder: Path,
+                          output_dir: Optional[Path] = None,
+                          feature_list: Path = DEFAULT_FEATURE_LIST,
+                          num_workers: int = 1,
+                          max_file_mb: Optional[float] = None) -> Dict[str, object]:
+    """Extract every STEP under `step_folder` to NPZ. Returns a summary dict
+    with: npz_dir, ok_stems, skipped (dict of stem -> reason), step_paths."""
+    from pipeline.extract_brep_extractor_data_from_step import extract_brep_extractor_data_from_step
+
+    step_folder = Path(step_folder).expanduser().resolve()
+    if not step_folder.is_dir():
+        raise FileNotFoundError(step_folder)
+    if output_dir is None:
+        output_dir = Path(tempfile.mkdtemp(prefix="heg_brep_npz_"))
+    output_dir = Path(output_dir).expanduser().resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    step_paths = _list_step_files(step_folder)
+    extract_brep_extractor_data_from_step(
+        step_path=step_folder,
+        output_path=output_dir,
+        mesh_dir=None,
+        seg_dir=None,
+        feature_list_path=feature_list,
+        force_regeneration=False,
+        max_file_mb=max_file_mb,
+        num_workers=max(1, int(num_workers)),
+    )
+
+    skipped = _all_skip_reasons(output_dir)
+    ok_stems = []
+    for sp in step_paths:
+        if (output_dir / f"{sp.stem}.npz").exists():
+            ok_stems.append(sp.stem)
+    return {
+        "npz_dir": output_dir,
+        "step_paths": step_paths,
+        "ok_stems": ok_stems,
+        "skipped": skipped,
+    }
+
+
+def _list_step_files(folder: Path) -> List[Path]:
+    out = set()
+    for pattern in ("*.stp", "*.step", "*.STP", "*.STEP"):
+        for p in folder.glob(pattern): out.add(p.resolve())
+        for p in folder.glob(f"**/{pattern}"): out.add(p.resolve())
+    return sorted(out)
+
+
+def _all_skip_reasons(npz_dir: Path) -> Dict[str, str]:
+    log = npz_dir / "skipped.jsonl"
+    out: Dict[str, str] = {}
+    if not log.exists():
+        return out
+    with log.open("r") as fp:
+        for line in fp:
+            line = line.strip()
+            if not line: continue
+            try:
+                rec = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            f = rec.get("file", "")
+            if f:
+                out[Path(f).stem] = str(rec.get("reason", "skipped"))
+    return out
+
+
+def _last_skip_reason_for(step_file: Path, npz_dir: Path) -> Optional[str]:
+    reasons = _all_skip_reasons(npz_dir)
+    return reasons.get(step_file.stem)

graph_data.py

@@ -0,0 +1,502 @@
+"""
+Utility helpers for loading BRep extractor-processed STEP data as PyG graphs.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+import re
+from typing import Dict, Iterable, List, Tuple
+
+import numpy as np
+import torch
+from torch_geometric.data import HeteroData
+
+# Backward-compatible default label mapping used by earlier checkpoints.
+DEFAULT_LABELS: Dict[str, int] = {"pipe": 0, "elbow": 1, "tjoint": 2, "random": 3}
+LABELS: Dict[str, int] = DEFAULT_LABELS.copy()
+STEP_EXTS = ("*.step", "*.stp", "*.STEP", "*.STP")
+
+
+def _class_sort_key(class_name: str) -> Tuple[int, int, str]:
+    """
+    Sort class names numerically when they have prefixes like `0_random`,
+    then lexicographically for the remaining part.
+    """
+    match = re.match(r"^\s*(\d+)(?:[_\-\s]+(.*))?$", class_name)
+    if match:
+        suffix = (match.group(2) or "").strip().lower()
+        return (0, int(match.group(1)), suffix)
+    return (1, 10**9, class_name.lower())
+
+
+def _iter_step_files(step_root: Path) -> List[Path]:
+    files_set = set()
+    for pattern in STEP_EXTS:
+        for step_file in step_root.glob(pattern):
+            files_set.add(step_file.resolve())
+        for step_file in step_root.glob(f"**/{pattern}"):
+            files_set.add(step_file.resolve())
+    return sorted(files_set)
+
+
+def discover_step_classes(step_root: Path) -> List[str]:
+    """
+    Discover class names from top-level folders under `step_root` that contain
+    STEP files.
+    """
+    step_root = Path(step_root)
+    if not step_root.exists():
+        raise FileNotFoundError(f"STEP root does not exist: {step_root}")
+
+    class_names = set()
+    for step_file in _iter_step_files(step_root):
+        rel = step_file.relative_to(step_root)
+        if len(rel.parts) < 2:
+            # Ignore STEP files placed directly under step_root.
+            continue
+        class_names.add(rel.parts[0])
+
+    if not class_names:
+        raise RuntimeError(f"No STEP class folders found under {step_root}")
+    return sorted(class_names, key=_class_sort_key)
+
+
+def build_class_labels(step_root: Path) -> Dict[str, int]:
+    """
+    Build a deterministic {class_name -> class_id} mapping from step_root.
+    """
+    classes = discover_step_classes(step_root)
+    return {name: idx for idx, name in enumerate(classes)}
+
+
+def build_label_metadata(
+    step_root: Path,
+    labels: Dict[str, int] | None = None,
+) -> Tuple[Dict[str, int], Dict[str, int], Dict[str, Tuple[str, ...]]]:
+    """
+    Build label metadata from STEP folder structure.
+
+    Returns:
+      - labels: {class_name: class_id}
+      - stem_to_label: {npz_stem: class_id}
+      - collisions: {stem: (class_name_a, class_name_b, ...)} for stems that
+        appear in more than one class folder. The chosen label follows the same
+        overwrite behavior as extractor output naming (`<stem>.npz`).
+    """
+    step_root = Path(step_root)
+    if labels is None:
+        labels = build_class_labels(step_root)
+    if not labels:
+        raise RuntimeError("No labels were provided/discovered for STEP classes.")
+
+    stem_to_label: Dict[str, int] = {}
+    stem_to_class: Dict[str, str] = {}
+    collisions = defaultdict(set)
+
+    for step_file in _iter_step_files(step_root):
+        rel = step_file.relative_to(step_root)
+        if len(rel.parts) < 2:
+            continue
+        class_name = rel.parts[0]
+        if class_name not in labels:
+            continue
+
+        stem = step_file.stem
+        prev_class = stem_to_class.get(stem)
+        if prev_class is not None and prev_class != class_name:
+            collisions[stem].update((prev_class, class_name))
+
+        stem_to_class[stem] = class_name
+        stem_to_label[stem] = int(labels[class_name])
+
+    if not stem_to_label:
+        raise RuntimeError(
+            f"No STEP files found under {step_root} for classes: {tuple(labels)}"
+        )
+
+    collision_out = {
+        stem: tuple(sorted(classes, key=_class_sort_key))
+        for stem, classes in collisions.items()
+    }
+    return labels, stem_to_label, collision_out
+
+
+def build_label_map(step_root: Path, labels: Dict[str, int] | None = None) -> Dict[str, int]:
+    """
+    Build a mapping from STEP file stem to integer label.
+    """
+    _, stem_to_label, _ = build_label_metadata(step_root, labels)
+    return stem_to_label
+
+
+def _flatten(arr: np.ndarray) -> np.ndarray:
+    return np.asarray(arr, dtype=np.float32).reshape(arr.shape[0], -1)
+
+
+def _coedge_grid_stats(coedge_grids: np.ndarray) -> np.ndarray:
+    """
+    Summarize coedge point grids into compact, less position-sensitive stats.
+    Input shape is expected as [N, C, U] (typically C=12).
+
+    Returns [N, 28]:
+      - channel mean (C=12)
+      - channel std  (C=12)
+      - xyz path length, xyz chord length, tortuosity, xyz bbox diag (4)
+    """
+    grids = np.asarray(coedge_grids, dtype=np.float32)
+    if grids.ndim != 3:
+        raise RuntimeError(f"Expected coedge grids with ndim=3, got shape {grids.shape}")
+    n, c, u = grids.shape
+
+    mean_c = grids.mean(axis=2)
+    std_c = grids.std(axis=2)
+
+    if c >= 3 and u >= 2:
+        xyz = grids[:, 0:3, :].transpose(0, 2, 1)  # [N, U, 3]
+        dif = xyz[:, 1:, :] - xyz[:, :-1, :]
+        seg_len = np.linalg.norm(dif, axis=2)
+        path_len = seg_len.sum(axis=1)
+        chord = np.linalg.norm(xyz[:, -1, :] - xyz[:, 0, :], axis=1)
+        bbox_diag = np.linalg.norm(xyz.max(axis=1) - xyz.min(axis=1), axis=1)
+        tort = path_len / (chord + 1e-6)
+    else:
+        path_len = np.zeros(n, dtype=np.float32)
+        chord = np.zeros(n, dtype=np.float32)
+        tort = np.ones(n, dtype=np.float32)
+        bbox_diag = np.zeros(n, dtype=np.float32)
+
+    shape_stats = np.stack([path_len, chord, tort, bbox_diag], axis=1).astype(np.float32)
+    return np.concatenate([mean_c, std_c, shape_stats], axis=1).astype(np.float32)
+
+
+def _face_grid_stats(face_grids: np.ndarray) -> np.ndarray:
+    """
+    Summarize face point grids into compact stats per face.
+    Returns [F, 10]: xyz_mean (3), xyz_std (3), nrm_mean (3), mask_frac (1).
+    """
+    face_grids = np.asarray(face_grids, dtype=np.float32)
+    f = face_grids.shape[0]
+    xyz = face_grids[:, 0:3, :, :].reshape(f, 3, -1)
+    nrm = face_grids[:, 3:6, :, :].reshape(f, 3, -1)
+    msk = face_grids[:, 6, :, :].reshape(f, -1)
+
+    mask = (msk > 0.5).astype(np.float32)
+    mask_frac = mask.mean(axis=1, keepdims=True)
+    w = mask / (mask.sum(axis=1, keepdims=True) + 1e-6)
+
+    xyz_mean = (xyz * w[:, None, :]).sum(axis=2)
+    xyz_var = (w[:, None, :] * (xyz - xyz_mean[:, :, None]) ** 2).sum(axis=2)
+    xyz_std = np.sqrt(np.maximum(xyz_var, 1e-12))
+    nrm_mean = (nrm * w[:, None, :]).sum(axis=2)
+    return np.concatenate([xyz_mean, xyz_std, nrm_mean, mask_frac], axis=1)
+
+
+def _build_face_neighbors(
+    coedge_face: np.ndarray,
+    coedge_edge: np.ndarray,
+    num_faces: int,
+) -> List[set[int]]:
+    """
+    Build face-face adjacency from shared model edges.
+    """
+    neighbors: List[set[int]] = [set() for _ in range(max(0, int(num_faces)))]
+    if num_faces <= 0 or coedge_face.size == 0 or coedge_edge.size == 0:
+        return neighbors
+
+    edge_to_faces: Dict[int, set[int]] = defaultdict(set)
+    for face_id, edge_id in zip(coedge_face.tolist(), coedge_edge.tolist()):
+        if face_id < 0 or face_id >= num_faces or edge_id < 0:
+            continue
+        edge_to_faces[int(edge_id)].add(int(face_id))
+
+    for attached_faces in edge_to_faces.values():
+        if len(attached_faces) < 2:
+            continue
+        face_list = list(attached_faces)
+        for src in face_list:
+            for dst in face_list:
+                if src != dst:
+                    neighbors[src].add(dst)
+    return neighbors
+
+
+def _derive_torus_like_features(
+    face_feats: np.ndarray,
+    coedge_face: np.ndarray,
+    coedge_edge: np.ndarray,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Derive robust torus-like signals from primitive flags + face adjacency.
+
+    Returns:
+      - face_ctx [F, 3]: bspline_core_flag, torus_like_flag, cyl_neighbor_count_norm
+      - global_ctx [3]: torus_like_face_fraction, torus_like_area_fraction, bspline_core_fraction
+    """
+    num_faces = int(face_feats.shape[0])
+    if num_faces == 0:
+        return np.zeros((0, 3), dtype=np.float32), np.zeros(3, dtype=np.float32)
+
+    feat_dim = int(face_feats.shape[1]) if face_feats.ndim == 2 else 0
+    if feat_dim > 5:
+        area = np.clip(np.asarray(face_feats[:, 5], dtype=np.float32), 0.0, None)
+    else:
+        area = np.ones((num_faces,), dtype=np.float32)
+    area_sum = float(area.sum())
+    if area_sum <= 1e-8:
+        area_frac = np.full((num_faces,), 1.0 / max(1, num_faces), dtype=np.float32)
+    else:
+        area_frac = area / (area_sum + 1e-8)
+
+    cylinder_mask = face_feats[:, 1] > 0.5 if feat_dim > 1 else np.zeros((num_faces,), dtype=bool)
+    torus_mask = face_feats[:, 4] > 0.5 if feat_dim > 4 else np.zeros((num_faces,), dtype=bool)
+    nurbs_mask = face_feats[:, 6] > 0.5 if feat_dim > 6 else np.zeros((num_faces,), dtype=bool)
+
+    neighbors = _build_face_neighbors(coedge_face, coedge_edge, num_faces)
+    cyl_neighbor_count = np.zeros((num_faces,), dtype=np.float32)
+    for i, nbrs in enumerate(neighbors):
+        if nbrs:
+            cyl_neighbor_count[i] = float(sum(1 for n in nbrs if cylinder_mask[n]))
+
+    cyl_neighbor_den = max(1.0, float(cyl_neighbor_count.max()))
+    cyl_neighbor_count_norm = (cyl_neighbor_count / cyl_neighbor_den).astype(np.float32)
+
+    # Treat large BSpline faces near cylinders as torus-like elbow core candidates.
+    bspline_core_mask = nurbs_mask & (area_frac >= 0.03) & (cyl_neighbor_count >= 1.0)
+    torus_like_mask = torus_mask | bspline_core_mask
+
+    face_ctx = np.stack(
+        [
+            bspline_core_mask.astype(np.float32),
+            torus_like_mask.astype(np.float32),
+            cyl_neighbor_count_norm,
+        ],
+        axis=1,
+    ).astype(np.float32)
+    global_ctx = np.array(
+        [
+            float(np.mean(torus_like_mask)),
+            float(np.sum(area_frac[torus_like_mask])),
+            float(np.mean(bspline_core_mask)),
+        ],
+        dtype=np.float32,
+    )
+    return face_ctx, global_ctx
+
+
+def compute_global_geom_features(data) -> np.ndarray:
+    """
+    Compute compact global geometry descriptors from face/coedge point samples.
+    Returns [5] float32: pca_ev_ratio_1/2/3, line_fit_rmse, plane_fit_rmse.
+    """
+    points = []
+    face_grids = np.asarray(data["face_point_grids"], dtype=np.float32)
+    if face_grids.size:
+        xyz = face_grids[:, 0:3, :, :].transpose(0, 2, 3, 1).reshape(-1, 3)
+        mask = face_grids[:, 6, :, :].reshape(-1) > 0.5
+        if mask.any():
+            points.append(xyz[mask])
+
+    coedge_grids = np.asarray(data["coedge_point_grids"], dtype=np.float32)
+    if coedge_grids.size:
+        co_xyz = coedge_grids[:, 0:3, :].transpose(0, 2, 1).reshape(-1, 3)
+        points.append(co_xyz)
+
+    if not points:
+        return np.zeros(5, dtype=np.float32)
+
+    pts = np.concatenate(points, axis=0)
+    if pts.shape[0] < 3:
+        return np.zeros(5, dtype=np.float32)
+    pts = pts[np.isfinite(pts).all(axis=1)]
+    if pts.shape[0] < 3:
+        return np.zeros(5, dtype=np.float32)
+
+    mean = pts.mean(axis=0, keepdims=True)
+    centered = pts - mean
+    scale = np.sqrt(np.mean(np.sum(centered ** 2, axis=1)))
+    centered = centered / (scale + 1e-6)
+    cov = (centered.T @ centered) / max(1, centered.shape[0])
+    if not np.isfinite(cov).all():
+        return np.zeros(5, dtype=np.float32)
+
+    ev = np.linalg.eigvalsh(cov)
+    ev = np.sort(ev)[::-1]
+    ev = np.maximum(ev, 0.0)
+    total = ev.sum()
+    if not np.isfinite(total) or total <= 0.0:
+        return np.zeros(5, dtype=np.float32)
+
+    ratios = ev / total
+    line_rmse = np.sqrt(max(ev[1] + ev[2], 0.0))
+    plane_rmse = np.sqrt(max(ev[2], 0.0))
+    feats = np.array(
+        [ratios[0], ratios[1], ratios[2], line_rmse, plane_rmse],
+        dtype=np.float32,
+    )
+    if not np.isfinite(feats).all():
+        return np.zeros(5, dtype=np.float32)
+    return feats
+
+def load_coedge_arrays(npz_path: Path) -> Dict[str, np.ndarray]:
+    """
+    Load node features and adjacency indices from a BRep extractor npz.
+    Returns a dict with coedge/face/edge/global features and topology arrays.
+    """
+    with np.load(npz_path) as data:
+        coedge_feats = _flatten(data["coedge_features"])
+        scale = np.asarray(data["coedge_scale_factors"], dtype=np.float32)[:, None]
+        reverse = np.asarray(data["coedge_reverse_flags"], dtype=np.float32)[:, None]
+        point_grids = _coedge_grid_stats(data["coedge_point_grids"])  # [N, compact_stats]
+        lcs = _flatten(data["coedge_lcs"])                  # [N, 16]
+
+        face_idx = np.asarray(data["face"], dtype=np.int64)
+        edge_idx = np.asarray(data["edge"], dtype=np.int64)
+        face_feats = np.asarray(data["face_features"], dtype=np.float32)  # [F, 7]
+        edge_feats = np.asarray(data["edge_features"], dtype=np.float32)  # [E, 10]
+
+        face_grids = np.asarray(data["face_point_grids"], dtype=np.float32)
+        face_grid_stats = _face_grid_stats(face_grids)
+        face_ctx, global_ctx = _derive_torus_like_features(face_feats, face_idx, edge_idx)
+
+        coedge_x = np.concatenate(
+            [coedge_feats, scale, reverse, point_grids, lcs], axis=1
+        )
+        face_x = np.concatenate([face_feats, face_ctx, face_grid_stats], axis=1)
+        edge_x = edge_feats
+        next_index = np.asarray(data["next"], dtype=np.int64)
+        mate_index = np.asarray(data["mate"], dtype=np.int64)
+        global_legacy = compute_global_geom_features(data)
+        # Keep legacy 5 features as prefix; append torus-like robustness stats.
+        global_features = np.concatenate([global_legacy, global_ctx], axis=0).astype(np.float32)
+
+    return {
+        "coedge_x": coedge_x,
+        "face_x": face_x,
+        "edge_x": edge_x,
+        "next": next_index,
+        "mate": mate_index,
+        "coedge_face": face_idx,
+        "coedge_edge": edge_idx,
+        "global_x": global_features,
+    }
+
+
+def make_edge_index(source: np.ndarray, target: np.ndarray) -> torch.Tensor:
+    """
+    Build a 2 x E tensor of edge indices (with both directions, deduplicated).
+    """
+    pairs = np.stack([source, target], axis=1)
+    flipped = pairs[:, ::-1]
+    all_pairs = np.concatenate([pairs, flipped], axis=0)
+    all_pairs = np.unique(all_pairs, axis=0)
+    return torch.tensor(all_pairs.T, dtype=torch.long)
+
+def make_directed_edge_index(source: np.ndarray, target: np.ndarray) -> torch.Tensor:
+    """
+    Build a 2 x E tensor of directed edge indices (no deduplication).
+    """
+    return torch.tensor(np.stack([source, target], axis=0), dtype=torch.long)
+
+def make_bipartite_edge_index(source: np.ndarray, target: np.ndarray) -> torch.Tensor:
+    """
+    Build a 2 x E tensor of directed bipartite edge indices (deduplicated).
+    """
+    pairs = np.stack([source, target], axis=1)
+    pairs = np.unique(pairs, axis=0)
+    return torch.tensor(pairs.T, dtype=torch.long)
+
+def make_heterodata(
+    coedge_x: np.ndarray,
+    face_x: np.ndarray,
+    edge_x: np.ndarray,
+    next_index: np.ndarray,
+    mate_index: np.ndarray,
+    coedge_face: np.ndarray,
+    coedge_edge: np.ndarray,
+    global_features: np.ndarray,
+    label: int | None,
+    norm_stats: Dict[str, Dict[str, np.ndarray | torch.Tensor]] | None = None,
+) -> HeteroData:
+    """
+    Create a PyG HeteroData graph for the coedge features/relations.
+    When mean/std are provided the features are normalised element-wise.
+    """
+    def _normalize(x_arr: np.ndarray, stats: Dict[str, np.ndarray | torch.Tensor] | None) -> torch.Tensor:
+        x_t = torch.tensor(x_arr, dtype=torch.float32)
+        if stats is None:
+            return x_t
+        mean = stats.get("mean")
+        std = stats.get("std")
+        if mean is None or std is None:
+            return x_t
+        mean_t = torch.as_tensor(mean, dtype=torch.float32)
+        std_t = torch.as_tensor(std, dtype=torch.float32)
+        return (x_t - mean_t) / std_t
+
+    coedge_stats = norm_stats.get("coedge") if norm_stats else None
+    face_stats = norm_stats.get("face") if norm_stats else None
+    edge_stats = norm_stats.get("edge") if norm_stats else None
+
+    x_coedge = _normalize(coedge_x, coedge_stats)
+    x_face = _normalize(face_x, face_stats)
+    x_edge = _normalize(edge_x, edge_stats)
+
+    idx = np.arange(coedge_x.shape[0], dtype=np.int64)
+    edge_next = make_directed_edge_index(idx, next_index)
+    edge_prev = make_directed_edge_index(next_index, idx)
+    edge_mate = make_edge_index(idx, mate_index)
+    edge_coedge_face = make_directed_edge_index(idx, coedge_face)
+    edge_face_coedge = make_directed_edge_index(coedge_face, idx)
+    edge_coedge_edge = make_directed_edge_index(idx, coedge_edge)
+    edge_edge_coedge = make_directed_edge_index(coedge_edge, idx)
+    edge_face_edge = make_bipartite_edge_index(coedge_face, coedge_edge)
+    edge_edge_face = make_bipartite_edge_index(coedge_edge, coedge_face)
+
+    data = HeteroData()
+    data["coedge"].x = x_coedge
+    data["face"].x = x_face
+    data["edge"].x = x_edge
+    data["global"].x = torch.tensor(global_features, dtype=torch.float32).view(1, -1)
+    data["coedge", "next", "coedge"].edge_index = edge_next
+    data["coedge", "prev", "coedge"].edge_index = edge_prev
+    data["coedge", "mate", "coedge"].edge_index = edge_mate
+    data["coedge", "to_face", "face"].edge_index = edge_coedge_face
+    data["face", "to_coedge", "coedge"].edge_index = edge_face_coedge
+    data["coedge", "to_edge", "edge"].edge_index = edge_coedge_edge
+    data["edge", "to_coedge", "coedge"].edge_index = edge_edge_coedge
+    data["face", "to_edge", "edge"].edge_index = edge_face_edge
+    data["edge", "to_face", "face"].edge_index = edge_edge_face
+    if label is not None:
+        data.y = torch.tensor([int(label)], dtype=torch.long)
+    return data
+
+
+def compute_feature_stats(npz_paths: Iterable[Path]) -> Dict[str, np.ndarray]:
+    """
+    Compute mean and std (per feature dimension) across all node features in the dataset.
+    """
+    totals = {"coedge": 0, "face": 0, "edge": 0}
+    sum_vec: Dict[str, np.ndarray | None] = {"coedge": None, "face": None, "edge": None}
+    sum_sq: Dict[str, np.ndarray | None] = {"coedge": None, "face": None, "edge": None}
+
+    for path in npz_paths:
+        graph = load_coedge_arrays(path)
+        for key, x in (("coedge", graph["coedge_x"]), ("face", graph["face_x"]), ("edge", graph["edge_x"])):
+            if sum_vec[key] is None:
+                sum_vec[key] = np.zeros(x.shape[1], dtype=np.float64)
+                sum_sq[key] = np.zeros(x.shape[1], dtype=np.float64)
+            sum_vec[key] += x.sum(axis=0)
+            sum_sq[key] += (x * x).sum(axis=0)
+            totals[key] += x.shape[0]
+
+    out = {}
+    for key in ("coedge", "face", "edge"):
+        if sum_vec[key] is None or totals[key] == 0:
+            raise RuntimeError(f"Cannot compute feature stats: no {key} features observed.")
+        mean = sum_vec[key] / totals[key]
+        var = sum_sq[key] / totals[key] - mean * mean
+        var = np.maximum(var, 1e-12)
+        std = np.sqrt(var)
+        out[key] = {"mean": mean.astype(np.float32), "std": std.astype(np.float32)}
+    return out

inference.py

@@ -0,0 +1,151 @@
+"""Loaded-model wrapper + classify helpers. All in-process; no subprocess."""
+from __future__ import annotations
+from pathlib import Path
+from typing import Dict
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from heg_brep.model import HalfEdgeGNN, resolve_reject_label
+from heg_brep.graph_data import load_coedge_arrays, make_heterodata
+
+
+def _align_2d(x: np.ndarray, target_dim: int) -> np.ndarray:
+    cur = int(x.shape[1])
+    if cur == target_dim:
+        return x
+    if cur > target_dim:
+        return x[:, :target_dim]
+    pad = np.zeros((x.shape[0], target_dim - cur), dtype=x.dtype)
+    return np.concatenate([x, pad], axis=1)
+
+
+def _align_1d(x: np.ndarray, target_dim: int) -> np.ndarray:
+    cur = int(x.shape[0])
+    if cur == target_dim:
+        return x
+    if cur > target_dim:
+        return x[:target_dim]
+    pad = np.zeros((target_dim - cur,), dtype=x.dtype)
+    return np.concatenate([x, pad], axis=0)
+
+
+class LoadedModel:
+    """A pass1 / elbow / tee checkpoint loaded into memory once."""
+
+    def __init__(self, ckpt_path: Path, device: str = "cpu"):
+        try:
+            ckpt = torch.load(str(ckpt_path), map_location="cpu", weights_only=False)
+        except TypeError:
+            ckpt = torch.load(str(ckpt_path), map_location="cpu")
+        if "global_in" not in ckpt or "gating_dim" not in ckpt:
+            raise RuntimeError(f"Checkpoint {ckpt_path} missing gating metadata.")
+        stats = ckpt["stats"]
+        if not all(k in stats for k in ("coedge", "face", "edge")):
+            raise RuntimeError(f"Checkpoint {ckpt_path} missing heterograph stats.")
+        coedge_in = ckpt.get("coedge_in", ckpt.get("node_in"))
+        face_in = ckpt.get("face_in")
+        edge_in = ckpt.get("edge_in")
+        if coedge_in is None or face_in is None or edge_in is None:
+            raise RuntimeError(f"Checkpoint {ckpt_path} missing input dims.")
+        labels = ckpt["labels"]
+        model = HalfEdgeGNN(
+            coedge_in=coedge_in, face_in=face_in, edge_in=edge_in,
+            global_in=ckpt["global_in"], hidden=ckpt["hp"]["hidden"],
+            layers=ckpt["hp"]["layers"], dropout=ckpt["hp"]["dropout"],
+            num_classes=len(labels), gating_dim=ckpt["gating_dim"],
+        ).to(device)
+        model.load_state_dict(ckpt["state_dict"])
+        model.eval()
+        self.model = model
+        self.device = device
+        self.coedge_in = int(coedge_in)
+        self.face_in = int(face_in)
+        self.edge_in = int(edge_in)
+        self.global_in = int(ckpt["global_in"])
+        self.stats = stats
+        self.labels = labels
+        self.inv_labels = {v: k for k, v in labels.items()}
+        self.reject_label = resolve_reject_label(labels, None)
+
+    @torch.no_grad()
+    def predict(self, npz_path: Path, min_conf: float = 0.0, tau: float = 0.0) -> Dict[str, object]:
+        g = load_coedge_arrays(npz_path)
+        g["coedge_x"] = _align_2d(g["coedge_x"], self.coedge_in)
+        g["face_x"]   = _align_2d(g["face_x"],   self.face_in)
+        g["edge_x"]   = _align_2d(g["edge_x"],   self.edge_in)
+        g["global_x"] = _align_1d(g["global_x"], self.global_in)
+        data = make_heterodata(
+            g["coedge_x"], g["face_x"], g["edge_x"],
+            g["next"], g["mate"], g["coedge_face"], g["coedge_edge"],
+            g["global_x"], label=None, norm_stats=self.stats,
+        )
+        data["coedge"].batch = torch.zeros(data["coedge"].x.size(0), dtype=torch.long)
+        data["global"].batch = torch.zeros(1, dtype=torch.long)
+        data["face"].batch   = torch.zeros(data["face"].x.size(0), dtype=torch.long)
+        data["edge"].batch   = torch.zeros(data["edge"].x.size(0), dtype=torch.long)
+        logits = self.model(data.to(self.device))
+        probs = F.softmax(logits, dim=-1).cpu().numpy()[0]
+        pred = int(probs.argmax())
+        conf = float(probs[pred])
+        argmax_label = self.inv_labels[pred]
+        effective_tau = max(tau, min_conf)
+        if conf < effective_tau and self.reject_label is not None:
+            predicted_label = self.reject_label
+        else:
+            predicted_label = argmax_label
+        return {
+            "argmax_label": argmax_label,
+            "argmax_conf": conf,
+            "predicted_label": predicted_label,
+        }
+
+
+ELBOW_ROUTES = {"elbow"}
+TEE_ROUTES = {"tee"}
+
+
+class TwoPassClassifier:
+    """Convenience wrapper that owns all three models and routes pass1 → pass2."""
+
+    def __init__(self, pass1: LoadedModel,
+                 elbow: "LoadedModel | None",
+                 tee:   "LoadedModel | None",
+                 pass2_min_conf: float = 0.85,
+                 pass2_tau: float = 0.0):
+        self.pass1 = pass1
+        self.elbow = elbow
+        self.tee = tee
+        self.pass2_min_conf = pass2_min_conf
+        self.pass2_tau = pass2_tau
+
+    def classify_npz(self, npz_path: Path) -> Dict[str, object]:
+        p1 = self.pass1.predict(npz_path, min_conf=0.0, tau=0.0)
+        route = str(p1["argmax_label"]).strip().lower()
+        out = {
+            "pass1_argmax": p1["argmax_label"],
+            "pass1_conf": float(p1["argmax_conf"]),
+            "route": route,
+            "pass2_argmax": "",
+            "pass2_predicted": "",
+            "pass2_conf": None,
+            "final_label": "",
+            "final_conf": None,
+        }
+        if route in ELBOW_ROUTES and self.elbow is not None:
+            specialist = self.elbow
+        elif route in TEE_ROUTES and self.tee is not None:
+            specialist = self.tee
+        else:
+            # pipe / miscellaneous: no specialist, passthrough as random
+            out["final_label"] = "random"
+            out["final_conf"] = out["pass1_conf"]
+            return out
+        p2 = specialist.predict(npz_path, min_conf=self.pass2_min_conf, tau=self.pass2_tau)
+        out["pass2_argmax"] = p2["argmax_label"]
+        out["pass2_predicted"] = p2["predicted_label"]
+        out["pass2_conf"] = float(p2["argmax_conf"])
+        out["final_label"] = p2["predicted_label"]
+        out["final_conf"] = out["pass2_conf"]
+        return out

model.py

@@ -0,0 +1,106 @@
+"""HalfEdge GNN model definition (moved from brep_two_pass/scripts/03_infer_halfedge.py)."""
+from __future__ import annotations
+from typing import Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_geometric.nn import (
+    HeteroConv, SAGEConv, JumpingKnowledge, BatchNorm,
+    global_mean_pool, global_max_pool,
+)
+from torch_geometric.data import HeteroData
+
+
+def resolve_reject_label(labels, requested: Optional[str]) -> Optional[str]:
+    if requested:
+        return requested
+    lower_to_name = {name.lower(): name for name in labels}
+    for candidate in ("random", "unknown", "other", "misc"):
+        if candidate in lower_to_name:
+            return lower_to_name[candidate]
+    for name in labels:
+        lower = name.lower()
+        if "random" in lower or "unknown" in lower:
+            return name
+    return None
+
+
+class HalfEdgeGNN(nn.Module):
+    def __init__(
+        self,
+        coedge_in: int, face_in: int, edge_in: int, global_in: int,
+        hidden=256, layers=6, dropout=0.2, num_classes=3,
+        jk_mode="cat", gating_dim=None,
+    ):
+        super().__init__()
+        self.convs = nn.ModuleList(); self.bns = nn.ModuleList()
+        self.encoders = nn.ModuleDict({
+            "coedge": nn.Sequential(nn.Linear(coedge_in, hidden), nn.ReLU(), nn.Dropout(dropout)),
+            "face":   nn.Sequential(nn.Linear(face_in,   hidden), nn.ReLU(), nn.Dropout(dropout)),
+            "edge":   nn.Sequential(nn.Linear(edge_in,   hidden), nn.ReLU(), nn.Dropout(dropout)),
+        })
+        for _ in range(layers):
+            conv = HeteroConv({
+                ('coedge','next','coedge'):     SAGEConv((hidden, hidden), hidden),
+                ('coedge','prev','coedge'):     SAGEConv((hidden, hidden), hidden),
+                ('coedge','mate','coedge'):     SAGEConv((hidden, hidden), hidden),
+                ('coedge','to_face','face'):    SAGEConv((hidden, hidden), hidden),
+                ('face','to_coedge','coedge'):  SAGEConv((hidden, hidden), hidden),
+                ('coedge','to_edge','edge'):    SAGEConv((hidden, hidden), hidden),
+                ('edge','to_coedge','coedge'):  SAGEConv((hidden, hidden), hidden),
+                ('face','to_edge','edge'):      SAGEConv((hidden, hidden), hidden),
+                ('edge','to_face','face'):      SAGEConv((hidden, hidden), hidden),
+            }, aggr='sum')
+            self.convs.append(conv)
+            self.bns.append(nn.ModuleDict({
+                "coedge": BatchNorm(hidden),
+                "face":   BatchNorm(hidden),
+                "edge":   BatchNorm(hidden),
+            }))
+        self.jk = JumpingKnowledge(mode=jk_mode)
+        self.jk_out = hidden * layers if jk_mode == "cat" else hidden
+        if gating_dim is None:
+            gating_dim = hidden
+        self.gating_dim = gating_dim
+        self.pool_in = self.jk_out * 2
+        self.proj = nn.Identity() if self.pool_in == gating_dim else nn.Linear(self.pool_in, gating_dim)
+
+        self.global_mlp = nn.Sequential(
+            nn.Linear(global_in, gating_dim),
+            nn.ReLU(), nn.Dropout(0.3),
+            nn.Linear(gating_dim, 2 * gating_dim),
+        )
+        self.head = nn.Sequential(
+            nn.Linear(gating_dim, hidden),
+            nn.ReLU(), nn.Dropout(dropout),
+            nn.Linear(hidden, num_classes),
+        )
+
+    def forward(self, data: HeteroData):
+        x = {
+            "coedge": self.encoders["coedge"](data["coedge"].x),
+            "face":   self.encoders["face"](data["face"].x),
+            "edge":   self.encoders["edge"](data["edge"].x),
+        }
+        outs = []
+        for conv, bn in zip(self.convs, self.bns):
+            x_new = conv(x, data.edge_index_dict)
+            x = {k: F.relu(bn[k](x_new[k]) + x[k]) for k in x}
+            outs.append(x["coedge"])
+        xj = self.jk(outs)
+        batch = data['coedge'].batch
+        g_mean = global_mean_pool(xj, batch)
+        g_max  = global_max_pool(xj, batch)
+        g = torch.cat([g_mean, g_max], dim=-1)
+        g0 = self.proj(g)
+        global_x = data["global"].x
+        if global_x.dim() == 1:
+            global_x = global_x.view(1, -1)
+        if global_x.size(0) != g0.size(0):
+            raise RuntimeError(f"Global feature batch mismatch: {global_x.size(0)} vs {g0.size(0)}")
+        gb = self.global_mlp(global_x)
+        gamma, beta = gb.chunk(2, dim=-1)
+        gamma = torch.sigmoid(gamma)
+        g_mod = g0 * gamma + beta
+        return self.head(g_mod)

server.py

@@ -0,0 +1,172 @@
+"""Local FastAPI service: STEP-file-in, classification-out. One process, models loaded once.
+
+Designed to be launched by a C# host app as a child process. The service binds to
+127.0.0.1 only; never exposes a network-facing port.
+
+Startup protocol:
+  - Bind a free port (default: OS-assigned via --port 0).
+  - Once models are loaded and the server is accepting requests, write
+    `READY port=<PORT>` to stdout (single line). The host reads that line to learn
+    where to connect.
+  - On `POST /shutdown` (or SIGTERM), drain in-flight requests and exit.
+
+Endpoints:
+  GET  /health                 -> service / model state
+  POST /classify {step_path}   -> single STEP classification
+  POST /classify_batch {paths} -> multiple in one call (sequential, single-process)
+  POST /shutdown               -> graceful exit
+"""
+from __future__ import annotations
+import argparse
+import os
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+from typing import List, Optional
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+
+from heg_brep import (
+    DEFAULT_PASS1_MODEL, DEFAULT_ELBOW_MODEL, DEFAULT_TEE_MODEL,
+)
+from heg_brep.inference import LoadedModel, TwoPassClassifier
+from heg_brep.extraction import extract_step_to_npz
+
+# Eagerly import the BRepExtractor pipeline at startup. Without this, the first
+# /classify call pays ~20-30s of OCC + occwl + igl cold-import cost — terrible
+# UX for an interactive viewer.
+import pipeline.extract_brep_extractor_data_from_step  # noqa: F401
+
+
+class State:
+    classifier: Optional[TwoPassClassifier] = None
+    started_at: float = 0.0
+    device: str = "cpu"
+    pass2_min_conf: float = 0.85
+    pass2_tau: float = 0.0
+
+
+app = FastAPI(title="HEG BRep component identification")
+
+
+class ClassifyRequest(BaseModel):
+    step_path: str
+    # Optional override: persist the NPZ to disk for inspection.
+    npz_keep_dir: Optional[str] = None
+
+
+class ClassifyBatchRequest(BaseModel):
+    step_paths: List[str]
+    npz_keep_dir: Optional[str] = None
+
+
+@app.get("/health")
+def health():
+    return {
+        "status": "ok",
+        "models_loaded": State.classifier is not None,
+        "device": State.device,
+        "uptime_sec": round(time.time() - State.started_at, 2),
+    }
+
+
+def _classify_one(step_path: str, npz_keep_dir: Optional[str]) -> dict:
+    if State.classifier is None:
+        raise HTTPException(status_code=503, detail="models not loaded yet")
+    sp = Path(step_path).expanduser()
+    if not sp.exists():
+        return {"step_path": str(sp), "status": "error", "error": "step_path not found"}
+    out_dir = Path(npz_keep_dir).expanduser().resolve() if npz_keep_dir \
+              else Path(tempfile.mkdtemp(prefix="heg_brep_npz_"))
+    try:
+        npz = extract_step_to_npz(sp, out_dir)
+    except Exception as exc:
+        return {"step_path": str(sp), "status": "extraction_failed", "error": str(exc)[:500]}
+    try:
+        result = State.classifier.classify_npz(npz)
+    except Exception as exc:
+        return {"step_path": str(sp), "status": "inference_failed", "error": str(exc)[:500],
+                "npz_path": str(npz)}
+    result.update({"step_path": str(sp), "status": "ok", "npz_path": str(npz)})
+    return result
+
+
+@app.post("/classify")
+def classify(req: ClassifyRequest):
+    return _classify_one(req.step_path, req.npz_keep_dir)
+
+
+@app.post("/classify_batch")
+def classify_batch(req: ClassifyBatchRequest):
+    return {"results": [_classify_one(p, req.npz_keep_dir) for p in req.step_paths]}
+
+
+@app.post("/shutdown")
+def shutdown():
+    threading.Thread(target=lambda: (time.sleep(0.2), os._exit(0)), daemon=True).start()
+    return {"status": "shutting_down"}
+
+
+def _load_models(args) -> None:
+    pass1 = LoadedModel(Path(args.pass1_model), device=args.device)
+    elbow = LoadedModel(Path(args.elbow_model), device=args.device) if Path(args.elbow_model).exists() else None
+    tee   = LoadedModel(Path(args.tee_model),   device=args.device) if Path(args.tee_model).exists()   else None
+    State.classifier = TwoPassClassifier(
+        pass1=pass1, elbow=elbow, tee=tee,
+        pass2_min_conf=args.pass2_min_conf, pass2_tau=args.pass2_tau,
+    )
+    State.device = args.device
+    State.pass2_min_conf = args.pass2_min_conf
+    State.pass2_tau = args.pass2_tau
+
+
+def parse_args() -> argparse.Namespace:
+    ap = argparse.ArgumentParser(description="HEG BRep classification service")
+    ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--port", type=int, default=0,
+                    help="Port to bind. 0 = let the OS pick. The chosen port is "
+                         "printed to stdout as a single line `READY port=<N>`.")
+    ap.add_argument("--pass1_model", default=str(DEFAULT_PASS1_MODEL))
+    ap.add_argument("--elbow_model", default=str(DEFAULT_ELBOW_MODEL))
+    ap.add_argument("--tee_model",   default=str(DEFAULT_TEE_MODEL))
+    ap.add_argument("--device", default="cpu", choices=["cpu", "cuda"])
+    ap.add_argument("--pass2_min_conf", type=float, default=0.85)
+    ap.add_argument("--pass2_tau", type=float, default=0.0)
+    return ap.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    State.started_at = time.time()
+    print(f"[heg_brep] loading models from:", file=sys.stderr)
+    print(f"  pass1: {args.pass1_model}", file=sys.stderr)
+    print(f"  elbow: {args.elbow_model}", file=sys.stderr)
+    print(f"  tee  : {args.tee_model}",   file=sys.stderr)
+    print(f"  device: {args.device}",     file=sys.stderr)
+    t0 = time.time()
+    _load_models(args)
+    print(f"[heg_brep] models loaded in {time.time() - t0:.1f}s", file=sys.stderr)
+
+    # Bind socket up front so we can tell the parent which port we got.
+    import socket
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.bind((args.host, int(args.port)))
+    bound_port = sock.getsockname()[1]
+    print(f"READY port={bound_port}", flush=True)
+
+    config = uvicorn.Config(app=app, host=args.host, port=bound_port, log_level="warning")
+    server = uvicorn.Server(config)
+    # uvicorn doesn't accept an already-bound socket in the simple Config API; close
+    # ours and let uvicorn rebind. Race window is fine because we're loopback only.
+    sock.close()
+    server.run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())