| """Diagnostics for IR files: counts, GT geometry checks, and the front-direction test. |
| |
| python -m fastfill.inspect_ir /Volumes/harddisk/fastfill_ir/IL3D.jsonl [--limit 5000] |
| |
| Front test: for wall-hugging categories (bed, sofa, wardrobe, toilet, ...) the side of the footprint that |
| touches the boundary should be the back, i.e. local -X under the IR convention (front = local +X). |
| A different dominant side means the adapter's front_offset_deg is wrong. |
| """ |
| import argparse |
| import collections |
| import json |
| import math |
| import re |
|
|
| from shapely.geometry import Point, Polygon |
|
|
| from fastfill.validate import check |
|
|
| WALL_HUGGERS = re.compile(r"\b(bed|sofa|couch|wardrobe|closet|toilet|dresser|bookcase|bookshelf|tv[ _]?stand|" |
| r"refrigerator|fridge|sideboard|nightstand|armoire)\b", re.I) |
|
|
|
|
| def wall_side(o, ring, tol=0.15): |
| """Which local axis side (+X, -X, +Y, -Y) of the footprint lies on the boundary, or None.""" |
| c, s = math.cos(o["yaw"]), math.sin(o["yaw"]) |
| hx, hy = o["size"][0] / 2, o["size"][1] / 2 |
| x, y = o["pos"][0], o["pos"][1] |
| best, name = tol, None |
| for lab, (dx, dy) in {"+X": (hx, 0), "-X": (-hx, 0), "+Y": (0, hy), "-Y": (0, -hy)}.items(): |
| d = ring.distance(Point(x + c * dx - s * dy, y + s * dx + c * dy)) |
| if d < best: |
| best, name = d, lab |
| return name |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("files", nargs="+") |
| ap.add_argument("--limit", type=int, default=None) |
| a = ap.parse_args() |
| for path in a.files: |
| n, nobj, btypes, rtypes, cats = 0, [], collections.Counter(), collections.Counter(), collections.Counter() |
| meta = collections.Counter() |
| geo = collections.Counter() |
| sides = collections.defaultdict(collections.Counter) |
| for line in open(path): |
| r = json.loads(line) |
| n += 1 |
| nobj.append(len(r["objects"])) |
| btypes[r.get("boundary_type")] += 1 |
| rtypes[r.get("room_type")] += 1 |
| meta["rooms_with_tilted"] += bool(r["meta"].get("n_tilted")) |
| meta["rooms_with_incomplete"] += bool(r["meta"].get("n_incomplete")) |
| for o in r["objects"]: |
| cats[o["category"]] += 1 |
| if r.get("boundary") and r["objects"] and (a.limit is None or geo["rooms"] < a.limit): |
| c = check(r) |
| geo["rooms"] += 1 |
| geo["objects"] += c["n"] |
| geo["valid"] += c["valid"] |
| geo["oob_objects"] += len(c["oob"]) |
| geo["rooms_with_collision"] += bool(c["collisions"]["main"]) |
| geo["oor_sum"] += c["oor"] |
| ring = Polygon(r["boundary"]).exterior |
| for o in r["objects"]: |
| m = WALL_HUGGERS.search(o["category"] or "") |
| if m: |
| sides[m.group(1).lower()][wall_side(o, ring)] += 1 |
| nobj.sort() |
| q = lambda f: nobj[min(int(f * len(nobj)), len(nobj) - 1)] if nobj else None |
| print(f"== {path}\nrooms {n} objects/room p10 {q(.1)} p50 {q(.5)} p90 {q(.9)} max {q(1)}") |
| print("boundary_type", dict(btypes), "\nmeta", dict(meta)) |
| print("room_type top", rtypes.most_common(12)) |
| print("category top", cats.most_common(25), f"({len(cats)} distinct)") |
| if geo["rooms"]: |
| g = geo |
| print(f"GT geometry on {g['rooms']} rooms: valid {g['valid'] / g['rooms']:.3f} " |
| f"oob_object_rate {g['oob_objects'] / max(g['objects'], 1):.3f} " |
| f"rooms_with_main_collision {g['rooms_with_collision'] / g['rooms']:.3f} mean_oor {g['oor_sum'] / g['rooms']:.3f}") |
| print("front test (side touching the wall; expect -X):") |
| for k, v in sorted(sides.items(), key=lambda kv: -sum(kv[1].values()))[:10]: |
| tot = sum(v.values()) |
| print(f" {k:12s} n={tot:6d} " + " ".join(f"{s}:{v[s] / tot:.2f}" for s in ("-X", "+X", "-Y", "+Y", None))) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
