File size: 7,810 Bytes
c227dfe
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
#!/usr/bin/env python3
"""BlueprintParse-R50 — detect five sanitary fixture classes in Korean architectural floor-plan images (ONNX, CPU/GPU).

Classes (model label ids 1..5): gas_range, toilet, washbasin, kitchen_sink, bathtub. Nothing else is detected or claimed.
Per-drawing counts are a DRAFT for human review: automatic quantity takeoff did not pass our gate (COUNT_NO_GO).

Pre-processing = training: grayscale, shrink so the long side <= max_side (2048, read from model metadata),
scale to 0..1, replicate to 3 channels. Boxes are mapped back to original pixel coordinates.

Usage:
    python blueprintparse.py plan.png                    # JSON to stdout
    python blueprintparse.py plan.png --providers CUDAExecutionProvider,CPUExecutionProvider
    python blueprintparse.py --selftest                  # synthetic drawing, no data needed
"""
from __future__ import annotations

import argparse
import hashlib
import io
import json
import sys
from pathlib import Path

HERE = Path(__file__).resolve().parent
MODEL = HERE / "bp_fp32.onnx"
MODEL_SHA256 = "5ed19b8bccc6d5abfdeb5dd26f153c28379115b100a9a4ce479479e10bffb773"
INPUT_NAME, OUTPUT_NAMES = "image", ("boxes", "labels", "scores")
CLASS_EN = {"객체_가스레인지": "gas_range", "객체_변기": "toilet", "객체_세면대": "washbasin",
            "객체_싱크대": "kitchen_sink", "객체_욕조": "bathtub"}
SCORE_THRESHOLD, CANDIDATE_FLOOR, REVIEW_THRESHOLD = 0.5, 0.3, 0.8


def sha256_file(p) -> str:
    h = hashlib.sha256()
    with open(p, "rb") as f:
        for b in iter(lambda: f.read(1 << 22), b""):
            h.update(b)
    return h.hexdigest()


def preprocess(data: bytes, max_side: int):
    """-> (x [3,h,w] float32, scale, (W, H))."""
    import numpy as np
    from PIL import Image
    with Image.open(io.BytesIO(data)) as im:
        im = im.convert("L"); W, H = im.size; s = min(1.0, max_side / max(W, H))
        small = im.resize((max(1, round(W * s)), max(1, round(H * s))), Image.BILINEAR) if s < 1.0 else im.copy()
    a = np.asarray(small, dtype=np.uint8).astype(np.float32) / 255.0
    return np.repeat(a[None], 3, axis=0), s, (W, H)


def to_original(box, scale: float, size) -> list:
    W, H = size
    x0, y0, x1, y1 = (float(v) / scale for v in box)
    return [round(max(0., min(W, x0)), 2), round(max(0., min(H, y0)), 2),
            round(max(0., min(W, x1)), 2), round(max(0., min(H, y1)), 2)]


class BlueprintParse:
    def __init__(self, model_path=MODEL, providers=None, threads: int | None = None, verify_sha: bool = True):
        import onnxruntime as ort
        self.path = Path(model_path)
        if verify_sha and self.path.resolve() == MODEL.resolve() and sha256_file(self.path) != MODEL_SHA256:
            raise ValueError("bp_fp32.onnx sha256 mismatch")
        so = ort.SessionOptions()
        if threads:
            so.intra_op_num_threads = int(threads)
        self.sess = ort.InferenceSession(str(self.path), so, providers=providers or ["CPUExecutionProvider"])
        meta = {}
        for k, v in self.sess.get_modelmeta().custom_metadata_map.items():
            try:
                meta[k] = json.loads(v)
            except (ValueError, TypeError):
                meta[k] = v
        self.meta = meta
        cid = meta.get("class_ids") or {c: i + 1 for i, c in enumerate(CLASS_EN)}
        self.names = {int(v): k for k, v in cid.items()}
        self.max_side = int(meta.get("max_side", 2048))

    def raw(self, x):
        import numpy as np
        b, l, s = self.sess.run(list(OUTPUT_NAMES), {INPUT_NAME: np.ascontiguousarray(x, dtype=np.float32)})
        return np.asarray(b), np.asarray(l), np.asarray(s)

    def __call__(self, data: bytes, score_threshold: float = SCORE_THRESHOLD, candidate_floor: float = CANDIDATE_FLOOR) -> dict:
        x, scale, size = preprocess(data, self.max_side)
        dets, cands = [], []
        for b, l, s in zip(*self.raw(x)):
            s = float(s)
            if s < candidate_floor:
                continue
            name = self.names.get(int(l), f"unknown:{int(l)}")
            d = {"class": CLASS_EN.get(name, "out_of_scope"), "score": round(s, 4), "box_xyxy": to_original(b, scale, size)}
            (dets if s >= score_threshold else cands).append(d)
        dets.sort(key=lambda d: -d["score"]); cands.sort(key=lambda d: -d["score"])
        counts = {c: 0 for c in CLASS_EN.values()}
        for d in dets:
            if d["class"] in counts:
                counts[d["class"]] += 1
        review = bool(cands) or any(d["score"] < REVIEW_THRESHOLD for d in dets) or not dets
        return {"input": {"sha256": hashlib.sha256(data).hexdigest(), "width": size[0], "height": size[1],
                          "resize_scale": round(scale, 6)},
                "counts_draft": counts, "detections": dets, "uncertain_candidates": cands,
                "thresholds": {"score": score_threshold, "candidate_floor": candidate_floor},
                "review_required": True, "low_confidence_present": review,
                "note": "Counts are a draft for human review (automatic takeoff COUNT_NO_GO). Zero detections is not proof of absence."}


def synthetic_drawing(h: int = 1448, w: int = 2048, seed: int = 0) -> bytes:
    """Deterministic synthetic line drawing (white background, black walls / boxes / rings). Not dataset data."""
    import numpy as np
    from PIL import Image
    rng = np.random.default_rng(seed)
    a = np.ones((h, w), dtype=np.float32)
    for _ in range(60):
        if rng.random() < .5:
            y = int(rng.integers(0, h)); x0, x1 = sorted(rng.integers(0, w, 2)); a[max(0, y - 2):y + 2, x0:x1] = 0
        else:
            x = int(rng.integers(0, w)); y0, y1 = sorted(rng.integers(0, h, 2)); a[y0:y1, max(0, x - 2):x + 2] = 0
    for _ in range(25):
        cx, cy = int(rng.integers(40, w - 40)), int(rng.integers(40, h - 40)); r = int(rng.integers(10, 35))
        a[cy - r:cy + r, cx - r] = a[cy - r:cy + r, cx + r - 1] = 0
        a[cy - r, cx - r:cx + r] = a[cy + r - 1, cx - r:cx + r] = 0
        yy, xx = np.ogrid[-r:r, -r:r]; ring = np.abs(np.sqrt(yy ** 2 + xx ** 2) - r * .6) < 1.2
        a[cy - r:cy + r, cx - r:cx + r][ring] = 0
    buf = io.BytesIO(); Image.fromarray((a * 255).astype("uint8")).save(buf, format="PNG")
    return buf.getvalue()


def selftest(threads=None) -> dict:
    import onnxruntime as ort
    m = BlueprintParse(threads=threads)
    out = m(synthetic_drawing())
    assert out["review_required"] is True and set(out["counts_draft"]) == set(CLASS_EN.values())
    return {"ok": True, "onnxruntime": ort.__version__, "inputs": [i.name for i in m.sess.get_inputs()],
            "outputs": [o.name for o in m.sess.get_outputs()], "max_side": m.max_side,
            "class_names_en": [CLASS_EN.get(m.names[k], "?") for k in sorted(m.names)],
            "metadata_precision": m.meta.get("precision"), "n_detections": len(out["detections"]),
            "n_candidates": len(out["uncertain_candidates"])}


def main(argv=None) -> int:
    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    ap.add_argument("image", nargs="?")
    ap.add_argument("--model", default=str(MODEL))
    ap.add_argument("--providers", default="CPUExecutionProvider")
    ap.add_argument("--threads", type=int, default=None)
    ap.add_argument("--selftest", action="store_true")
    a = ap.parse_args(argv)
    if a.selftest:
        print(json.dumps(selftest(a.threads), ensure_ascii=False, indent=1)); return 0
    if not a.image:
        ap.error("image path required (or --selftest)")
    m = BlueprintParse(a.model, providers=[p for p in a.providers.split(",") if p], threads=a.threads)
    print(json.dumps(m(Path(a.image).read_bytes()), ensure_ascii=False, indent=1))
    return 0


if __name__ == "__main__":
    sys.exit(main())