219 lines
8.2 KiB
Python
219 lines
8.2 KiB
Python
#!/usr/bin/env python3
|
|
"""Register a building model's footprint onto its site-plan outline / corner
|
|
callouts by point-to-edge ICP, and emit a site_manifest-ready placement.
|
|
|
|
Proven on 27号地块: site outlines can hide on odd layers (EVTR), a building
|
|
may have NO drawn outline at all (1#A — only DIM_COOR corner callouts), and
|
|
per-building rotations differ. This tool answers: given the model footprint
|
|
polygon(s) and a set of site points (outline vertices or corner callouts, in
|
|
site-plan meters), what rotation + anchor places the model on the site?
|
|
|
|
Method: brute-force angle sweep (score = trimmed mean distance from each site
|
|
point to the nearest transformed footprint edge) + ICP translation refinement.
|
|
Constrain --angle-window when the outline is visibly axis-aligned: balcony
|
|
teeth love a tilted false minimum (27号 2# found a 10.75° pit before the
|
|
window was clamped). Registering the UNION of several floors' footprints
|
|
(--floors F1 F2 F4) beats one floor when upper wings overhang.
|
|
|
|
Usage:
|
|
python3 register_site_outlines.py --spec outputs/x/spec_b1.json \
|
|
--floors F4 --site-points outline.json [--angle-window -6 6] \
|
|
--out registration.json [--prefix 1B]
|
|
|
|
site-points JSON: [[x, y], ...] (site-plan meters; surveying convention on
|
|
both 13号/27号: drawing x = 测绘Y east, drawing y = 测绘X north), or
|
|
{"points": [[x, y], ...]}.
|
|
|
|
Output JSON includes rotation_deg / model_anchor_m (footprint centroid) /
|
|
survey_anchor_m / residual_m plus a ready-to-paste manifest_entry. Judge the
|
|
residual: 配电房 hit 0.06 m (outline == model), 0.5-1 m is normal with
|
|
balconies, several meters means wrong outline or wrong floors — check the
|
|
overlay plot before trusting it.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import math
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import showcase_schema
|
|
|
|
|
|
def dist_pt_seg(p, a, b) -> float:
|
|
ax, ay = a
|
|
bx, by = b
|
|
px, py = p
|
|
dx, dy = bx - ax, by - ay
|
|
l2 = dx * dx + dy * dy
|
|
if l2 == 0:
|
|
return math.hypot(px - ax, py - ay)
|
|
t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / l2))
|
|
return math.hypot(px - (ax + t * dx), py - (ay + t * dy))
|
|
|
|
|
|
def poly_edges(poly):
|
|
return list(zip(poly, poly[1:] + poly[:1]))
|
|
|
|
|
|
def centroid(pts):
|
|
return (sum(p[0] for p in pts) / len(pts), sum(p[1] for p in pts) / len(pts))
|
|
|
|
|
|
def rot(p, th, c):
|
|
x, y = p[0] - c[0], p[1] - c[1]
|
|
ct, st = math.cos(th), math.sin(th)
|
|
return (x * ct - y * st, x * st + y * ct)
|
|
|
|
|
|
def register(model_polys, site_pts, angle_window=None, coarse=1.0, refine=0.05, trim=0.9):
|
|
"""Best (theta_deg, translation, score) overlaying model polygons on points.
|
|
|
|
score = trimmed mean distance from each site point to the nearest
|
|
transformed model edge (worst 10% dropped: corner callouts include strays).
|
|
"""
|
|
all_pts = [p for poly in model_polys for p in poly]
|
|
mc = centroid(all_pts)
|
|
sc = centroid(site_pts)
|
|
edges_m = [e for poly in model_polys for e in poly_edges(poly)]
|
|
|
|
def score_at(th_deg, t):
|
|
th = math.radians(th_deg)
|
|
edges = [
|
|
((rot(a, th, mc)[0] + t[0], rot(a, th, mc)[1] + t[1]), (rot(b, th, mc)[0] + t[0], rot(b, th, mc)[1] + t[1]))
|
|
for a, b in edges_m
|
|
]
|
|
ds = sorted(min(dist_pt_seg(p, a, b) for a, b in edges) for p in site_pts)
|
|
k = max(1, int(len(ds) * trim))
|
|
return sum(ds[:k]) / k
|
|
|
|
lo, hi = angle_window if angle_window else (-180.0, 180.0)
|
|
best = (lo, sc, 1e9)
|
|
th = lo
|
|
while th < hi + 1e-9:
|
|
s = score_at(th, sc)
|
|
if s < best[2]:
|
|
best = (th, sc, s)
|
|
th += coarse
|
|
th0 = best[0]
|
|
t = list(best[1])
|
|
for _ in range(4):
|
|
thr = math.radians(th0)
|
|
edges = [
|
|
(
|
|
(rot(a, thr, mc)[0] + t[0], rot(a, thr, mc)[1] + t[1]),
|
|
(rot(b, thr, mc)[0] + t[0], rot(b, thr, mc)[1] + t[1]),
|
|
)
|
|
for a, b in edges_m
|
|
]
|
|
vecs = []
|
|
for p in site_pts:
|
|
dmin, q = 1e9, None
|
|
for a, b in edges:
|
|
ax, ay = a
|
|
bx, by = b
|
|
dx, dy = bx - ax, by - ay
|
|
l2 = dx * dx + dy * dy or 1e-9
|
|
tt = max(0.0, min(1.0, ((p[0] - ax) * dx + (p[1] - ay) * dy) / l2))
|
|
qq = (ax + tt * dx, ay + tt * dy)
|
|
d = math.hypot(p[0] - qq[0], p[1] - qq[1])
|
|
if d < dmin:
|
|
dmin, q = d, qq
|
|
vecs.append((p[0] - q[0], p[1] - q[1], dmin))
|
|
vecs.sort(key=lambda v: v[2])
|
|
k = max(1, int(len(vecs) * trim))
|
|
t[0] += sum(v[0] for v in vecs[:k]) / k
|
|
t[1] += sum(v[1] for v in vecs[:k]) / k
|
|
best_f = (th0, score_at(th0, t))
|
|
dth = -1.5
|
|
while dth <= 1.5 + 1e-9:
|
|
cand = th0 + dth
|
|
if lo - 1e-9 <= cand <= hi + 1e-9:
|
|
s = score_at(cand, t)
|
|
if s < best_f[1]:
|
|
best_f = (cand, s)
|
|
dth += refine
|
|
th0 = best_f[0]
|
|
return th0, tuple(t), score_at(th0, t), mc
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
parser.add_argument("--spec", required=True, help="building_spec.json")
|
|
parser.add_argument(
|
|
"--floors", nargs="+", required=True, help="floor keys whose footprints form the registration target"
|
|
)
|
|
parser.add_argument(
|
|
"--site-points", required=True, help="JSON: [[x,y],...] site outline vertices / corner callouts (m)"
|
|
)
|
|
parser.add_argument(
|
|
"--angle-window", nargs=2, type=float, default=None, metavar=("LO", "HI"), help="restrict rotation search (deg)"
|
|
)
|
|
parser.add_argument("--out", required=True)
|
|
parser.add_argument("--prefix", default="", help="building prefix for the manifest entry")
|
|
args = parser.parse_args()
|
|
|
|
spec = showcase_schema.normalize_spec(json.loads(Path(args.spec).read_text(encoding="utf-8")))
|
|
try:
|
|
showcase_schema.validate_spec(spec)
|
|
except showcase_schema.ValidationFailure as exc:
|
|
raise SystemExit(str(exc)) from exc
|
|
polys = []
|
|
for fk in args.floors:
|
|
floor = spec.get("floors", {}).get(fk)
|
|
if floor is None:
|
|
raise SystemExit(f"floor {fk!r} not in spec")
|
|
polys.extend((floor.get("footprint") or {}).get("polygons") or [])
|
|
if not polys:
|
|
raise SystemExit(
|
|
"no footprint polygons on the requested floors — enable generate_footprints or pick other floors"
|
|
)
|
|
raw = json.loads(Path(args.site_points).read_text(encoding="utf-8"))
|
|
site_pts = raw.get("points") if isinstance(raw, dict) else raw
|
|
site_pts = [(float(p[0]), float(p[1])) for p in site_pts]
|
|
if len(site_pts) < 4:
|
|
raise SystemExit("need at least 4 site points")
|
|
|
|
window = tuple(args.angle_window) if args.angle_window else None
|
|
th, t, score, mc = register(polys, site_pts, angle_window=window)
|
|
result = {
|
|
"spec": args.spec,
|
|
"floors": args.floors,
|
|
"rotation_deg": round(th, 3),
|
|
"model_anchor_m": [round(mc[0], 3), round(mc[1], 3)],
|
|
"survey_anchor_m": [round(t[0], 3), round(t[1], 3)],
|
|
"residual_m": round(score, 3),
|
|
"site_points": len(site_pts),
|
|
"manifest_entry": {
|
|
"spec": args.spec,
|
|
"prefix": args.prefix,
|
|
"model_anchor_m": [round(mc[0], 3), round(mc[1], 3)],
|
|
"survey_anchor_m": [round(t[0], 3), round(t[1], 3)],
|
|
"rotation_deg": round(th, 3),
|
|
"registration_residual_m": round(score, 3),
|
|
},
|
|
}
|
|
out = Path(args.out)
|
|
out.parent.mkdir(parents=True, exist_ok=True)
|
|
out.write_text(json.dumps(result, ensure_ascii=False, indent=1), encoding="utf-8")
|
|
print(
|
|
json.dumps(
|
|
{"out": str(out), "rotation_deg": result["rotation_deg"], "residual_m": result["residual_m"]},
|
|
ensure_ascii=False,
|
|
)
|
|
)
|
|
if score > 2.0:
|
|
print(
|
|
f"WARNING residual {score:.2f} m is high — wrong outline, wrong floors, "
|
|
"or the site points include strays (garage outline / fire pads); "
|
|
"plot the overlay before trusting this placement.",
|
|
file=sys.stderr,
|
|
)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|