| """ |
| I-BADAS Dataset Statistics and Visualization Script |
| ==================================================== |
| Generates a comprehensive suite of academic-quality figures describing the |
| I-BADAS (Intralogistics Bin Anomaly Detection And Segmentation) dataset. |
| |
| All category names are discovered dynamically from every annotations.coco.json |
| found under the dataset root; the sample file is NOT treated as definitive. |
| |
| Usage: |
| python ibadas_stats.py --root /path/to/test --out figures/ |
| python ibadas_stats.py --root /path/to/test --train_root /path/to/train --out figures/ |
| |
| Dependencies: |
| pip install numpy matplotlib scipy pycocotools tqdm Pillow |
| """ |
|
|
| import argparse |
| import json |
| import os |
| import sys |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| |
| import matplotlib.pyplot as plt |
| import numpy as np |
|
|
| from matplotlib.offsetbox import OffsetImage, AnnotationBbox |
|
|
| from mpl_toolkits.mplot3d import proj3d |
| from scipy.spatial import ConvexHull, QhullError |
|
|
| from matplotlib.patches import Patch |
| from scipy.spatial import ConvexHull |
| from mpl_toolkits.mplot3d.art3d import Poly3DCollection |
| from matplotlib.lines import Line2D |
| from scipy.spatial.transform import Rotation |
| try: |
| from PIL import Image as PILImage |
| except ImportError: |
| PILImage = None |
|
|
| try: |
| from pycocotools import mask as coco_mask_utils |
| HAS_PYCOCOTOOLS = True |
| except ImportError: |
| HAS_PYCOCOTOOLS = False |
|
|
| |
| |
| |
| VIRIDIS = plt.cm.viridis |
| VIRIDIS_R = plt.cm.viridis_r |
| CLASS_ORDER = ["empty_clean", "empty_dirty", "non_empty"] |
| FONT_TITLE = {"fontsize": 13, "fontweight": "bold", "color": "#1a1a2e"} |
| FONT_LABEL = {"fontsize": 11, "color": "#1a1a2e"} |
| FONT_TICK = {"fontsize": 9} |
| SPINE_COLOR = "#cccccc" |
| BG_AXES = "#f9f9f9" |
|
|
| def style_ax(ax, title="", xlabel="", ylabel=""): |
| ax.set_facecolor(BG_AXES) |
| for spine in ax.spines.values(): |
| spine.set_edgecolor(SPINE_COLOR) |
| ax.tick_params(colors="#444444", labelsize=9) |
| ax.set_title(title, **FONT_TITLE, pad=10) |
| if xlabel: |
| ax.set_xlabel(xlabel, **FONT_LABEL) |
| if ylabel: |
| ax.set_ylabel(ylabel, **FONT_LABEL) |
| ax.grid(True, linestyle="--", linewidth=0.5, alpha=0.6, color="#cccccc") |
| ax.set_axisbelow(True) |
|
|
| def viridis_palette(n): |
| return [VIRIDIS(i / max(n - 1, 1)) for i in range(n)] |
|
|
| def save(fig, path, dpi=180): |
| fig.savefig(path, dpi=dpi, bbox_inches="tight", |
| facecolor=fig.get_facecolor()) |
| plt.close(fig) |
| print(f" Saved: {path}") |
|
|
| |
| |
| |
|
|
| def load_all_scenes(root: Path): |
| """ |
| Walk the dataset root and load every annotations.coco.json. |
| Returns a list of scene dicts: |
| { |
| 'scene_id': str, |
| 'coco': dict, # raw COCO JSON |
| 'cat_map': {id: name}, |
| 'supercategory_map': {id: supercategory}, |
| } |
| Also builds a global category registry across all files. |
| """ |
| scene_dirs = sorted(root.iterdir()) if root.is_dir() else [] |
| scenes = [] |
| global_cats = {} |
|
|
| for sd in scene_dirs: |
| ann_file = sd / "annotations.coco.json" |
| if not ann_file.exists(): |
| continue |
| with open(ann_file) as f: |
| coco = json.load(f) |
|
|
| cat_map = {} |
| supercat_map = {} |
| for c in coco.get("categories", []): |
| cat_map[c["id"]] = c["name"] |
| supercat_map[c["id"]] = c.get("supercategory", "unknown") |
| global_cats[c["name"]] = c.get("supercategory", "unknown") |
|
|
| scenes.append({ |
| "scene_id": sd.name, |
| "coco": coco, |
| "cat_map": cat_map, |
| "supercat_map": supercat_map, |
| "root": sd, |
| }) |
|
|
| if not scenes: |
| sys.exit(f"[ERROR] No annotations.coco.json files found under {root}") |
|
|
| print(f"Loaded {len(scenes)} scenes.") |
| print(f"Global categories discovered: {sorted(global_cats.keys())}") |
| return scenes, global_cats |
|
|
| def aggregate(scenes): |
| """ |
| Build flat lists and dicts for all aggregated statistics. |
| """ |
| records = [] |
| ann_records = [] |
|
|
| for s in scenes: |
| coco = s["coco"] |
| cat_map = s["cat_map"] |
| supercat_map = s["supercat_map"] |
| img_map = {img["id"]: img for img in coco.get("images", [])} |
|
|
| ann_by_img = defaultdict(list) |
| for ann in coco.get("annotations", []): |
| ann_by_img[ann["image_id"]].append(ann) |
|
|
| for img in coco.get("images", []): |
| rec = { |
| "scene_id": s["scene_id"], |
| "image_id": img["id"], |
| "file_name": img["file_name"], |
| "classification": img.get("classification", "unknown"), |
| "box_type": img.get("box_type", "unknown"), |
| "camera": img.get("camera", "unknown"), |
| "robot": img.get("robot", False), |
| "split": "good" if img["file_name"].startswith("good/") else "anomaly", |
| "annotations": ann_by_img[img["id"]], |
| "n_annotations": len(ann_by_img[img["id"]]), |
| } |
| records.append(rec) |
| for ann in ann_by_img[img["id"]]: |
| cat_name = cat_map.get(ann["category_id"], "unknown") |
| ann_records.append({ |
| "scene_id": s["scene_id"], |
| "image_id": img["id"], |
| "classification": rec["classification"], |
| "cat_name": cat_name, |
| "supercat": supercat_map.get(ann["category_id"], "unknown"), |
| "area": ann.get("area", 0), |
| "bbox": ann.get("bbox", [0, 0, 0, 0]), |
| }) |
|
|
| return records, ann_records |
|
|
|
|
| def load_poses(scenes): |
| """ |
| Load poses.json from each scene where available. |
| Supports: |
| |
| 1. [{"R": ..., "t": ...}, ...] |
| 2. {"id": {"R": ..., "t": ...}, ...} |
| 3. {"image.npy": [{"R": ..., "t": ...}], ...} |
| """ |
|
|
| pose_records = [] |
|
|
| for s in scenes: |
| poses_file = s["root"] / "poses.json" |
|
|
| if not poses_file.exists(): |
| continue |
|
|
| with open(poses_file) as f: |
| poses = json.load(f) |
|
|
| if isinstance(poses, list): |
| iterable = [] |
| for idx, p in enumerate(poses): |
| iterable.append((idx, p)) |
|
|
| elif isinstance(poses, dict): |
| iterable = [] |
| for key, value in poses.items(): |
| if isinstance(value, list): |
| for p in value: |
| iterable.append((key, p)) |
| elif isinstance(value, dict): |
| iterable.append((key, value)) |
| else: |
| continue |
|
|
| for image_key, p in iterable: |
| if not isinstance(p, dict): |
| continue |
|
|
| t = p.get("cam_t_m2c") or p.get("t") or p.get("translation") or [0, 0, 0] |
| |
| |
| R = p.get("cam_R_m2c") or p.get("R") or p.get("rotation") |
|
|
| record = { |
| "scene_id": s["scene_id"], |
| "tx": t[0], |
| "ty": t[1], |
| "tz": t[2], |
| "image_id": image_key, |
| } |
| |
| |
| if R is not None: |
| record["R"] = R |
| |
| pose_records.append(record) |
|
|
| return pose_records |
|
|
| |
| |
| |
|
|
| def _resolve_train_image_path(task_dir, file_name): |
| """ |
| Resolve the absolute image path of a train image. Tries, in order: |
| <task_dir>/<file_name>, <task_dir>/rgb/<file_name>, <task_dir>/rgb/<basename>. |
| Falls back to the first candidate if none exists. |
| """ |
| candidates = [ |
| task_dir / file_name, |
| task_dir / "rgb" / file_name, |
| task_dir / "rgb" / Path(file_name).name, |
| ] |
| for c in candidates: |
| if c.is_file(): |
| return str(c) |
| return str(candidates[0]) |
|
|
|
|
| def load_train_data(train_root): |
| """ |
| Load the train split. Expected layout: |
| |
| <train_root>/[real/]<scene>/<task>/{annotations.coco.json, poses.json, rgb/, ...} |
| |
| Tasks of the same scene are pooled, so the train scene_id is the scene folder |
| name (e.g. "000001") and matches the test scene_id. |
| |
| Returns (train_records, train_pose_records). Records carry '_abs_path'. |
| Returns ([], []) if train_root is None or nothing is found. |
| """ |
| if train_root is None: |
| return [], [] |
|
|
| train_root = Path(train_root) |
| if not train_root.is_dir(): |
| print(f" [WARN] Train root not found: {train_root}") |
| return [], [] |
|
|
| if (train_root / "real").is_dir(): |
| train_root = train_root / "real" |
|
|
| train_records = [] |
| train_pose_records = [] |
| n_task_dirs = 0 |
|
|
| for scene_dir in sorted(p for p in train_root.iterdir() if p.is_dir()): |
| |
| |
| task_dirs = sorted( |
| p for p in scene_dir.iterdir() |
| if p.is_dir() and (p / "annotations.coco.json").exists() |
| ) |
| if not task_dirs and (scene_dir / "annotations.coco.json").exists(): |
| task_dirs = [scene_dir] |
|
|
| for task_dir in task_dirs: |
| with open(task_dir / "annotations.coco.json") as f: |
| coco = json.load(f) |
|
|
| cat_map = {} |
| supercat_map = {} |
| for c in coco.get("categories", []): |
| cat_map[c["id"]] = c["name"] |
| supercat_map[c["id"]] = c.get("supercategory", "unknown") |
|
|
| s = { |
| "scene_id": scene_dir.name, |
| "coco": coco, |
| "cat_map": cat_map, |
| "supercat_map": supercat_map, |
| "root": task_dir, |
| } |
|
|
| recs, _ = aggregate([s]) |
| for r in recs: |
| r["_abs_path"] = _resolve_train_image_path(task_dir, r["file_name"]) |
| r["_root"] = str(task_dir) |
| r["task"] = task_dir.name |
| train_records.extend(recs) |
| train_pose_records.extend(load_poses([s])) |
| n_task_dirs += 1 |
|
|
| print(f" Train: {len(train_records)} images, {len(train_pose_records)} poses " |
| f"from {n_task_dirs} task folders under {train_root}") |
| return train_records, train_pose_records |
|
|
|
|
| def _train_reference_stats(train_records, train_pose_records): |
| """ |
| Compute the train reference values used for the train-referenced deltas: |
| mean intensity, translation centroid and mean rotation, per scene and global. |
| """ |
| refs = { |
| "scene_intensity_mean": {}, |
| "global_intensity_mean": None, |
| "scene_translation_centroid": {}, |
| "global_translation_centroid": None, |
| "scene_rotation_mean": {}, |
| "global_rotation_mean": None, |
| } |
|
|
| |
| scene_intensities = defaultdict(list) |
| all_intensities = [] |
| if PILImage is not None: |
| for r in train_records: |
| p = Path(r.get("_abs_path", "")) |
| if not p.is_file(): |
| continue |
| try: |
| img = np.asarray(PILImage.open(p).convert("L")) |
| m = float(np.mean(img)) |
| except Exception: |
| continue |
| scene_intensities[r["scene_id"]].append(m) |
| all_intensities.append(m) |
|
|
| refs["scene_intensity_mean"] = { |
| sc: float(np.mean(v)) for sc, v in scene_intensities.items() if v |
| } |
| if all_intensities: |
| refs["global_intensity_mean"] = float(np.mean(all_intensities)) |
|
|
| |
| scene_t = defaultdict(list) |
| scene_r = defaultdict(list) |
| all_t = [] |
| all_r = [] |
| for pose in train_pose_records: |
| sc = pose["scene_id"] |
| t = _pose_translation(pose) |
| rot = _pose_rotation(pose) |
| if t is not None: |
| scene_t[sc].append(t) |
| all_t.append(t) |
| if rot is not None: |
| scene_r[sc].append(rot) |
| all_r.append(rot) |
|
|
| refs["scene_translation_centroid"] = { |
| sc: np.mean(v, axis=0) for sc, v in scene_t.items() if v |
| } |
| if all_t: |
| refs["global_translation_centroid"] = np.mean(all_t, axis=0) |
|
|
| refs["scene_rotation_mean"] = { |
| sc: Rotation.concatenate(v).mean() for sc, v in scene_r.items() if v |
| } |
| if all_r: |
| refs["global_rotation_mean"] = Rotation.concatenate(all_r).mean() |
|
|
| return refs |
|
|
| |
| |
| |
| SCENE_CAMERA = {1: "RealSense", 2: "Zivid", 3: "RealSense", |
| 4: "Zivid", 5: "RealSense", 6: "Zivid"} |
|
|
| LOAD_CARRIER_GROUPS = [ |
| ("KLT4314", [1, 2]), |
| ("KLT4315", [3, 4]), |
| ("SetBox", [5, 6]), |
| ] |
|
|
| SCENE_LOAD_CARRIER = { |
| 1: "KLT4314", 2: "KLT4314", |
| 3: "KLT4315", 4: "KLT4315", |
| 5: "SetBox", 6: "SetBox", |
| } |
|
|
| CAMERA_COLORS = { |
| "RealSense": "#7EB8D4", |
| "Zivid": "#D4A87E", |
| } |
|
|
| BINARY_MAP = { |
| "empty_clean": "Anomaly-Free", |
| "empty_dirty": "Anomalous", |
| "non_empty": "Anomalous", |
| } |
|
|
| BINARY_CLASSES = ["Anomaly-Free", "Anomalous"] |
|
|
| TRINARY_CLASSES = CLASS_ORDER |
|
|
| PASTEL_GREEN = "#48c16e80" |
| PASTEL_PURPLE = "#48237480" |
| PASTEL_TEAL = "#1e9c8980" |
| PASTEL_YELLOW = "#eae51a80" |
|
|
| BIN_COLORS = {"Anomaly-Free": PASTEL_GREEN, "Anomalous": PASTEL_PURPLE} |
| TRI_COLORS = { |
| "empty_clean": PASTEL_GREEN, |
| "empty_dirty": PASTEL_TEAL, |
| "non_empty": PASTEL_YELLOW, |
| } |
|
|
| |
| |
| |
|
|
| def fig_class_per_scene(records, out_dir): |
| scenes_ids = sorted(set(r["scene_id"] for r in records)) |
| scenes_ids_int = sorted(set(int(r["scene_id"]) for r in records)) |
| n_scenes = len(scenes_ids) |
|
|
| binary_counts = defaultdict(lambda: defaultdict(int)) |
| trinary_counts = defaultdict(lambda: defaultdict(int)) |
|
|
| for r in records: |
| cls = r["classification"] |
| sid = r["scene_id"] |
| binary_counts[sid][BINARY_MAP[cls]] += 1 |
| trinary_counts[sid][cls] += 1 |
|
|
| bar_w = 0.30 |
| task_gap = 0.06 |
| scene_gap = 0.85 |
|
|
| task1_offsets = np.array([i * scene_gap - (bar_w / 2 + task_gap / 2) |
| for i in range(n_scenes)]) |
| task2_offsets = task1_offsets + bar_w + task_gap |
| scene_centres = (task1_offsets + task2_offsets) / 2 |
|
|
| fig = plt.figure(figsize=(6.5, 6.0)) |
| fig.patch.set_facecolor("white") |
| gs = fig.add_gridspec(2, 1, height_ratios=[4, 1.5], hspace=-0.02) |
| ax = fig.add_subplot(gs[0]) |
| ax_table = fig.add_subplot(gs[1]) |
| ax_table.axis("off") |
|
|
| fig.subplots_adjust(top=0.92, bottom=0.05) |
|
|
| def draw_stacked(ax, x_positions, class_order, color_map, count_dict, scenes): |
| bottoms = np.zeros(len(scenes)) |
| for cls in class_order: |
| vals = np.array([count_dict[sc].get(cls, 0) for sc in scenes], |
| dtype=float) |
| ax.bar(x_positions, vals, width=bar_w, bottom=bottoms, |
| color=color_map[cls], label=cls, |
| edgecolor="white", linewidth=0.5) |
| for xp, v, bot in zip(x_positions, vals, bottoms): |
| if v >= 1: |
| ax.text(xp, bot + v / 2, str(int(v)), |
| ha="center", va="center", |
| fontsize=8, color="#444444", fontweight="bold") |
| bottoms += vals |
| for xp, tot in zip(x_positions, bottoms): |
| if tot > 0: |
| ax.text(xp, tot + 0.8, str(int(tot)), |
| ha="center", va="bottom", |
| fontsize=8, color="#333333", fontweight="bold") |
|
|
| draw_stacked(ax, task1_offsets, BINARY_CLASSES, BIN_COLORS, |
| binary_counts, scenes_ids) |
| draw_stacked(ax, task2_offsets, TRINARY_CLASSES, TRI_COLORS, |
| trinary_counts, scenes_ids) |
|
|
| margin = 0.25 |
| x_left = task1_offsets[0] - margin |
| x_right = task2_offsets[-1] + margin |
| ax.set_xlim(x_left, x_right) |
|
|
| ax.set_xticks(scene_centres) |
| ax.set_xticklabels([]) |
| ax.tick_params(axis="x", length=0) |
|
|
| for i in range(1, n_scenes): |
| sep_x = (task2_offsets[i - 1] + task1_offsets[i]) / 2 |
| ax.axvline(sep_x, color=SPINE_COLOR, linewidth=0.7, |
| linestyle="dotted", alpha=0.5) |
|
|
| ax.grid(False) |
|
|
| blank = Patch(facecolor="none", edgecolor="none", label="") |
| legend_elements = ( |
| [Patch(facecolor="none", edgecolor="none", label="Task 1:")] + |
| [Patch(facecolor=BIN_COLORS[c], edgecolor="#aaaaaa", |
| linewidth=0.5, label=c) for c in BINARY_CLASSES] + |
| [blank] + |
| [Patch(facecolor="none", edgecolor="none", label="Task 2:")] + |
| [Patch(facecolor=TRI_COLORS[c], edgecolor="#aaaaaa", |
| linewidth=0.5, label=c) for c in TRINARY_CLASSES] |
| ) |
| ax.legend(handles=legend_elements, |
| title="Anomaly Detection Task", |
| fontsize=8, title_fontsize=10, |
| framealpha=0.9, edgecolor=SPINE_COLOR, |
| bbox_to_anchor=(1.0, 1.0), |
| loc="upper right", |
| ncol=2, |
| borderpad=0.6, labelspacing=0.3) |
|
|
| style_ax(ax, xlabel="", ylabel="Number of Images") |
|
|
| row_labels = ["Task", "Camera", "Load Carrier", "Scene"] |
|
|
| task_row = [] |
| cam_row = [] |
| lc_row = [] |
| scene_row = [] |
| row_labels = ["Task", "Camera", "Load Carrier", "Scene"] |
|
|
| |
| cam_values = [] |
| lc_values = [] |
| scene_values = [] |
|
|
| for sid in scenes_ids_int: |
| task_row += ["Task 1", "Task 2"] |
|
|
| cam = SCENE_CAMERA.get(sid, "Unknown") |
| lc = SCENE_LOAD_CARRIER.get(sid, "") |
|
|
| cam_values.append(cam) |
| lc_values.append(lc) |
| scene_values.append(f"Scene {sid}") |
|
|
| |
| cam_row += ["", ""] |
| lc_row += ["", ""] |
| scene_row += ["", ""] |
|
|
| cell_text = [task_row, cam_row, lc_row, scene_row] |
|
|
| boundaries = [x_left] |
| for i in range(n_scenes): |
| boundaries.append((task1_offsets[i] + task2_offsets[i]) / 2) |
| if i < n_scenes - 1: |
| boundaries.append((task2_offsets[i] + task1_offsets[i+1]) / 2) |
| else: |
| boundaries.append(x_right) |
|
|
| col_widths_data = [ |
| boundaries[k+1] - boundaries[k] |
| for k in range(len(boundaries)-1) |
| ] |
| total_w = sum(col_widths_data) |
| col_widths = [w / total_w for w in col_widths_data] |
|
|
| |
| |
| |
| |
| |
|
|
| tbl = ax_table.table( |
| cellText = cell_text, |
| rowLabels = row_labels, |
| colLabels = None, |
| cellLoc = "center", |
| loc = "center", |
| colWidths = col_widths, |
| ) |
|
|
| tbl.auto_set_font_size(False) |
| tbl.set_fontsize(8) |
| tbl.scale(1, 1.6) |
|
|
| for (row, col), cell in tbl.get_celld().items(): |
| cell.set_edgecolor("#9C9C9C") |
| cell.set_linewidth(0.5) |
| cell.set_facecolor("#FFFFFF") |
|
|
| if col == -1: |
| cell.set_text_props( |
| |
| |
| |
| fontweight="bold", |
| fontsize=8 |
| ) |
| cell.visible_edges = "closed" |
| elif row == 0: |
| cell.visible_edges = "closed" |
|
|
| |
| for row in [1, 2, 3]: |
| for i in range(n_scenes): |
| col_t1 = i * 2 |
| col_t2 = i * 2 + 1 |
|
|
| cell_t1 = tbl[row, col_t1] |
| cell_t2 = tbl[row, col_t2] |
|
|
| cell_t1.visible_edges = "LBT" |
| cell_t2.visible_edges = "RBT" |
|
|
| |
| fig.canvas.draw() |
|
|
| |
| for row, values in zip( |
| [1, 2, 3], |
| [cam_values, lc_values, scene_values] |
| ): |
| for i, text in enumerate(values): |
|
|
| c1 = tbl[row, i * 2] |
| c2 = tbl[row, i * 2 + 1] |
|
|
| x = c1.get_x() |
| y = c1.get_y() |
|
|
| w = c1.get_width() + c2.get_width() |
| h = c1.get_height() |
|
|
| ax_table.text( |
| x + w / 2, |
| y + h / 2, |
| text, |
| ha="center", |
| va="center", |
| fontsize=8, |
| transform=ax_table.transAxes, |
| ) |
|
|
| save(fig, out_dir / "image_dist_per_classification_and_scene.pdf") |
|
|
| |
| |
| |
|
|
| def fig_mask_area_violin(ann_records, out_dir, tick_fs=10, label_fs=12): |
|
|
| cats = sorted(set(r["cat_name"] for r in ann_records)) |
|
|
| data = { |
| c: np.log1p([r["area"] for r in ann_records |
| if r["cat_name"] == c and r["area"] > 0]) |
| for c in cats |
| } |
|
|
| cats = [c for c in cats if len(data[c]) > 1] |
| colors = viridis_palette(len(cats)) |
|
|
| x = np.arange(len(cats)) |
|
|
| fig, ax = plt.subplots(figsize=(max(4, len(cats) * 0.5 + 1), 5)) |
| fig.patch.set_facecolor("white") |
|
|
| parts = ax.violinplot( |
| [data[c] for c in cats], |
| positions=x, |
| showmedians=True, |
| showextrema=True, |
| widths=0.8 |
| ) |
|
|
| for pc, col in zip(parts["bodies"], colors): |
| pc.set_facecolor(col) |
| pc.set_alpha(0.8) |
|
|
| parts["cmedians"].set_color("white") |
| parts["cmins"].set_color("#555") |
| parts["cmaxes"].set_color("#555") |
| parts["cbars"].set_color("#555") |
|
|
| ax.set_xticks(x) |
| ax.set_xticklabels(cats, rotation=30, ha="right", fontsize=label_fs) |
|
|
| style_ax(ax, xlabel="Segmentation Mask", ylabel="log(1 + Mask Area in pixels²)") |
|
|
| ax.xaxis.label.set_fontweight("bold") |
| ax.yaxis.label.set_fontweight("bold") |
| ax.yaxis.label.set_fontsize(label_fs) |
| ax.xaxis.label.set_fontsize(label_fs) |
| ax.tick_params(axis="both", labelsize=label_fs) |
|
|
| ax.set_xlim(-0.5, len(cats) - 0.5) |
|
|
| fig.tight_layout() |
| save(fig, out_dir / "segmentation_mask_area_violin.pdf") |
|
|
|
|
| |
| |
| |
|
|
| def _accumulate_gray_histogram(records): |
| """ |
| Accumulate the 256-bin grayscale histogram over all readable images of the |
| given records. Returns (histogram, number_of_loaded_images). |
| """ |
| hist_acc = np.zeros(256) |
| n_loaded = 0 |
|
|
| for r in records: |
| img_path = Path(r.get("_abs_path", "")) |
| if not img_path.exists(): |
| continue |
|
|
| try: |
| img_pil = PILImage.open(img_path).convert("L") |
| img = np.array(img_pil) |
| h, _ = np.histogram(img, bins=256, range=(0, 256)) |
| hist_acc += h |
| n_loaded += 1 |
| except Exception: |
| continue |
|
|
| return hist_acc, n_loaded |
|
|
|
|
| def fig_intensity_histogram_global( |
| records, out_dir, image_meta=None, y_max=0.017, train_records=None |
| ): |
| if PILImage is None: |
| print(" [SKIP] Pillow not available for intensity histograms.") |
| return |
|
|
| if image_meta is None: |
| image_meta = { |
| "Dark": ("./test/000006/anomaly/rgb/00027.png", "Scene 6\nImg Num: 27"), |
| "Midtone": ( |
| "./test/000004/anomaly/rgb/00116.png", |
| "Scene 4\nImg Num: 116", |
| ), |
| "Bright": ( |
| "./test/000001/anomaly/rgb/00235.png", |
| "Scene 1\nImg Num: 235", |
| ), |
| } |
|
|
| fig, ax = plt.subplots(1, 1, figsize=(6, 4.3)) |
| fig.patch.set_facecolor("white") |
|
|
| global_hist_acc = np.zeros(256) |
| global_n_loaded = 0 |
|
|
| for r in records: |
| img_path = Path(r.get("_abs_path", "")) |
| if not img_path.exists(): |
| continue |
|
|
| try: |
| img_pil = PILImage.open(img_path).convert("L") |
| img = np.array(img_pil) |
| h, _ = np.histogram(img, bins=256, range=(0, 256)) |
| global_hist_acc += h |
| global_n_loaded += 1 |
| except Exception: |
| continue |
|
|
| if global_n_loaded > 0: |
| from scipy.ndimage import gaussian_filter1d |
|
|
| global_hist_acc = gaussian_filter1d(global_hist_acc, sigma=2) |
|
|
| global_norm = global_hist_acc / global_hist_acc.sum() |
| ax.plot( |
| range(256), |
| global_norm, |
| color=plt.cm.viridis(0.2), |
| alpha=1.0, |
| linewidth=1.5, |
| label="Test", |
| ) |
|
|
| if train_records: |
| train_hist, train_n_loaded = _accumulate_gray_histogram(train_records) |
| if train_n_loaded > 0: |
| train_hist = gaussian_filter1d(train_hist, sigma=2) |
| train_norm = train_hist / train_hist.sum() |
| ax.plot( |
| range(256), |
| train_norm, |
| color=plt.cm.viridis(0.88), |
| alpha=1.0, |
| linewidth=1.5, |
| linestyle="--", |
| label="Train", |
| ) |
|
|
| |
| ax.legend( |
| loc="lower center", |
| bbox_to_anchor=(0.42, 0.02), |
| ncol=2, |
| frameon=True, |
| framealpha=0.5, |
| fontsize=10, |
| borderpad=0.4, |
| facecolor="white", |
| edgecolor="gray", |
| ) |
|
|
| if y_max is not None: |
| ax.set_ylim(0, y_max) |
|
|
| def add_sample_image( |
| img_path, label_info, xybox, title, highlight_color, is_right |
| ): |
| if not img_path or not Path(img_path).exists(): |
| return |
| try: |
| img_obj = PILImage.open(img_path) |
| orig_w, orig_h = img_obj.size |
| zoom_factor = 100.0 / max(orig_w, orig_h) |
| imagebox = OffsetImage(np.array(img_obj), zoom=zoom_factor) |
| img_gray = np.array(img_obj.convert("L")) |
| mean_val = np.mean(img_gray) |
| x_idx = min(255, max(0, int(mean_val))) |
| y_val = global_norm[x_idx] |
|
|
| ab = AnnotationBbox( |
| imagebox, |
| (mean_val, y_val), |
| xybox=xybox, |
| xycoords="data", |
| boxcoords="axes fraction", |
| arrowprops=dict(arrowstyle="->", color=highlight_color, lw=1), |
| bboxprops=dict(edgecolor=highlight_color), |
| ) |
| ax.add_artist(ab) |
|
|
| ax.text( |
| xybox[0], |
| xybox[1] + 0.21, |
| title, |
| transform=ax.transAxes, |
| ha="center", |
| fontsize=8, |
| color=highlight_color, |
| weight="bold", |
| ) |
|
|
| text_x_offset = -0.065 if is_right else 0.035 |
| ax.text( |
| xybox[0] + text_x_offset, |
| xybox[1] - 0.23, |
| label_info, |
| transform=ax.transAxes, |
| ha="center", |
| va="center", |
| fontsize=8, |
| color="black", |
| ) |
| except Exception: |
| pass |
|
|
| colors = [plt.cm.viridis(0.2), plt.cm.viridis(0.5), plt.cm.viridis(0.8)] |
| |
| positions = [(0.19, 0.80), (0.5, 0.80), (0.81, 0.80)] |
| titles = ["Dark", "Midtone", "Bright"] |
|
|
| for i, key in enumerate(titles): |
| if key in image_meta: |
| path, label = image_meta[key] |
| is_right = i == 2 |
| add_sample_image(path, label, positions[i], key, colors[i], is_right) |
|
|
| style_ax( |
| ax, title="", xlabel="Pixel Intensity", ylabel="Normalized Pixel Frequency" |
| ) |
| ax.set_facecolor("white") |
|
|
| fig.tight_layout() |
| save(fig, out_dir / "intensity_histogram_global.pdf") |
|
|
| |
| |
| |
|
|
| def calc_intensity_statistics_global(records, label="Dataset"): |
| if PILImage is None: |
| print(" [SKIP] Pillow not available for intensity calculations.") |
| return |
|
|
| |
| global_hist_acc = np.zeros(256, dtype=np.int64) |
| global_n_loaded = 0 |
|
|
| for r in records: |
| img_path = Path(r.get("_abs_path", "")) |
| if not img_path.exists(): |
| continue |
| |
| try: |
| img_pil = PILImage.open(img_path).convert("L") |
| img = np.array(img_pil) |
| h, _ = np.histogram(img, bins=256, range=(0, 256)) |
| global_hist_acc += h |
| global_n_loaded += 1 |
| except Exception: |
| continue |
|
|
| if global_n_loaded == 0: |
| print("No images were loaded successfully.") |
| return |
|
|
| total_pixels = global_hist_acc.sum() |
| if total_pixels == 0: |
| print("Total pixels is 0. Cannot compute statistics.") |
| return |
|
|
| intensities = np.arange(256) |
| |
| |
| mean_intensity = np.sum(intensities * global_hist_acc) / total_pixels |
| |
| |
| mean_sq_intensity = np.sum((intensities ** 2) * global_hist_acc) / total_pixels |
| variance = mean_sq_intensity - (mean_intensity ** 2) |
| std_intensity = np.sqrt(variance) |
| |
| |
| non_zero_bins = np.where(global_hist_acc > 0)[0] |
| min_val = non_zero_bins[0] if len(non_zero_bins) > 0 else 0 |
| max_val = non_zero_bins[-1] if len(non_zero_bins) > 0 else 0 |
| |
| |
| cum_hist = np.cumsum(global_hist_acc) |
| cum_hist_norm = cum_hist / total_pixels |
| |
| p25 = np.searchsorted(cum_hist_norm, 0.25) |
| median = np.searchsorted(cum_hist_norm, 0.50) |
| p75 = np.searchsorted(cum_hist_norm, 0.75) |
|
|
| print(f"{label} Intensity Statistics (Over {global_n_loaded} images):") |
| print(f" Total Pixels: {total_pixels:,}") |
| print(f" Mean: {mean_intensity:.2f}") |
| print(f" Std Dev: {std_intensity:.2f}") |
| print(f" Min: {min_val}") |
| print(f" Max: {max_val}") |
| print(f" 25th Pct: {p25}") |
| print(f" Median: {median}") |
| print(f" 75th Pct: {p75}") |
|
|
| return { |
| "n_images": global_n_loaded, |
| "total_pixels": total_pixels, |
| "mean": mean_intensity, |
| "std": std_intensity, |
| "min": min_val, |
| "max": max_val, |
| "p25": p25, |
| "median": median, |
| "p75": p75 |
| } |
|
|
| |
| |
| |
|
|
| def draw_working_frustum(ax, K, R, t, min_depth, actual_max_depth, draw_max_depth=None, color='magenta', label='Camera'): |
| if draw_max_depth is None or draw_max_depth > actual_max_depth: |
| draw_max_depth = actual_max_depth |
| |
| fx, fy = K[0, 0], K[1, 1] |
| cx, cy = K[0, 2], K[1, 2] |
| |
| w = cx * 2 |
| h = cy * 2 |
| corners = np.array([[0,0], [w,0], [w,h], [0,h]]) |
| |
| def get_pts_at_depth(depth): |
| pts = np.zeros((4, 3)) |
| pts[:, 0] = (corners[:, 0] - cx) * depth / fx |
| pts[:, 1] = (corners[:, 1] - cy) * depth / fy |
| pts[:, 2] = depth |
| return pts |
| |
| near_pts = get_pts_at_depth(min_depth) |
| far_pts = get_pts_at_depth(draw_max_depth) |
| |
| origin = np.array([[0, 0, 0]]) |
| all_pts = np.vstack((origin, near_pts, far_pts)) |
| |
| has_extension = actual_max_depth > draw_max_depth |
| if has_extension: |
| ext_pts = get_pts_at_depth(draw_max_depth + 150.0) |
| all_pts = np.vstack((all_pts, ext_pts)) |
| |
| all_pts = (R.T @ (all_pts.T - t.reshape(3, 1))).T |
| |
| orig = all_pts[0] |
| n = all_pts[1:5] |
| f = all_pts[5:9] |
| |
| for i in range(4): |
| ax.plot([orig[0], f[i,0]], [orig[1], f[i,1]], [orig[2], f[i,2]], color=color, alpha=0.3, linestyle=':') |
| |
| for i in range(4): |
| next_i = (i + 1) % 4 |
| ax.plot([n[i,0], n[next_i,0]], [n[i,1], n[next_i,1]], [n[i,2], n[next_i,2]], color=color, linewidth=1.5) |
| |
| far_ls = ':' if has_extension else '-' |
| ax.plot([f[i,0], f[next_i,0]], [f[i,1], f[next_i,1]], [f[i,2], f[next_i,2]], color=color, linewidth=1.5, linestyle=far_ls) |
| ax.plot([n[i,0], f[i,0]], [n[i,1], f[i,1]], [n[i,2], f[i,2]], color=color, linewidth=1.5) |
| |
| if has_extension: |
| ext = all_pts[9:13] |
| ax.plot([f[i,0], ext[i,0]], [f[i,1], ext[i,1]], [f[i,2], ext[i,2]], color=color, linewidth=1.5, linestyle=':') |
| |
| if i == 0: |
| ax.text(ext[i,0], ext[i,1], ext[i,2] - 40, f"Max depth range at {actual_max_depth}mm", |
| color=color, fontsize=11, style='italic', |
| bbox=dict(facecolor='white', alpha=0.8, edgecolor='none', pad=2)) |
|
|
| |
| lw, lh, l_depth = 10.0, 10.0, -12.0 |
| bw, bh, b_front, b_back = 20.0, 15.0, -12.0, -35.0 |
| |
| cam_body_pts = np.array([ |
| [0, 0, 0], |
| [-lw, -lh, l_depth], [lw, -lh, l_depth], [lw, lh, l_depth], [-lw, lh, l_depth], |
| [-bw, -bh, b_front], [bw, -bh, b_front], [bw, bh, b_front], [-bw, bh, b_front], |
| [-bw, -bh, b_back], [bw, -bh, b_back], [bw, bh, b_back], [-bw, bh, b_back], |
| ]) |
| |
| cam_body_world = (R.T @ (cam_body_pts.T - t.reshape(3, 1))).T |
| |
| box_edges = [ |
| (0,1), (0,2), (0,3), (0,4), |
| (1,2), (2,3), (3,4), (4,1), |
| (5,6), (6,7), (7,8), (8,5), |
| (9,10), (10,11), (11,12), (12,9), |
| (5,9), (6,10), (7,11), (8,12) |
| ] |
| |
| for e1, e2 in box_edges: |
| ax.plot([cam_body_world[e1,0], cam_body_world[e2,0]], |
| [cam_body_world[e1,1], cam_body_world[e2,1]], |
| [cam_body_world[e1,2], cam_body_world[e2,2]], |
| color=color, linewidth=0.8) |
|
|
| ax.plot([], [], [], color=color, linewidth=1.5, label=label) |
| |
| return all_pts |
|
|
| def fig_pose_3d_with_frames(pose_records, out_dir, cam_properties=None, voxel_size=100): |
| if not pose_records and not cam_properties: |
| print(" [SKIP] No pose data found.") |
| return |
|
|
| plt.rcParams.update({ |
| 'font.size': 14, |
| 'axes.titlesize': 16, |
| 'axes.labelsize': 14, |
| 'legend.fontsize': 12 |
| }) |
|
|
| fig = plt.figure(figsize=(12, 9)) |
| ax = fig.add_subplot(111, projection="3d") |
|
|
| ax.set_facecolor('white') |
| |
| ax.xaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
| ax.yaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
| ax.zaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
| |
| tx_list, ty_list, tz_list = [], [], [] |
| length = 100.0 |
| alpha_val = 0.4 |
| occupied_voxels = set() |
|
|
| if pose_records: |
| for p in pose_records: |
| if "tx" in p: |
| t = np.array([p["tx"], p["ty"], p["tz"]]) |
| elif "t" in p: |
| t = np.array(p["t"]) |
| else: |
| continue |
| |
| if voxel_size is not None and voxel_size > 0: |
| voxel_idx = ( |
| int(np.floor(t[0] / voxel_size)), |
| int(np.floor(t[1] / voxel_size)), |
| int(np.floor(t[2] / voxel_size)) |
| ) |
| if voxel_idx in occupied_voxels: |
| continue |
| occupied_voxels.add(voxel_idx) |
| |
| tx_list.append(t[0]) |
| ty_list.append(t[1]) |
| tz_list.append(t[2]) |
|
|
| R = np.array(p["R"]).reshape(3, 3) |
| for i, color in enumerate(['r', 'g', 'b']): |
| ax.quiver(t[0], t[1], t[2], R[0, i] * length, R[1, i] * length, R[2, i] * length, |
| color=color, alpha=alpha_val) |
|
|
| ax.plot([], [], [], color='r', label='X Axis Rotation') |
| ax.plot([], [], [], color='g', label='Y Axis Rotation') |
| ax.plot([], [], [], color='b', label='Z Axis Rotation') |
|
|
| all_x, all_y, all_z = list(tx_list), list(ty_list), list(tz_list) |
| all_x.append(0.0) |
| all_y.append(0.0) |
| all_z.append(0.0) |
|
|
| if cam_properties: |
| cmap = plt.get_cmap('viridis') |
| |
| safe_viridis_values = [0.1, 0.88] |
| |
| for idx, (cam_id, props) in enumerate(cam_properties.items()): |
| K = np.array(props["cam_K"]).reshape(3, 3) |
| R = np.array(props.get("R", np.eye(3))).reshape(3, 3) |
| t = np.array(props.get("t", np.zeros(3))) |
| |
| min_depth = props.get("min_depth", 300.0) |
| max_depth = props.get("max_depth", 1000.0) |
| draw_max_depth = props.get("draw_max_depth", max_depth) |
| |
| color_val = safe_viridis_values[idx % len(safe_viridis_values)] |
| cam_color = cmap(color_val) |
| |
| legend_label = f"{cam_id} Frustum" |
| |
| pts = draw_working_frustum(ax, K, R, t, min_depth, max_depth, draw_max_depth=draw_max_depth, color=cam_color, label=legend_label) |
| |
| all_x.extend(pts[:, 0]) |
| all_y.extend(pts[:, 1]) |
| all_z.extend(pts[:, 2]) |
|
|
| if all_x: |
| ax.set_xlim(min(all_x), max(all_x)) |
| ax.set_ylim(min(all_y), max(all_y)) |
| ax.set_zlim(min(all_z), max(all_z)) |
| |
| ax.set_xlabel("X Translation [mm]", labelpad=20) |
| ax.set_ylabel("Y Translation [mm]", labelpad=20) |
| ax.set_zlabel("Z Translation [mm]", labelpad=20) |
|
|
| ax.tick_params(axis='z', pad=10) |
| |
| if cam_properties or pose_records: |
| ax.legend(loc='upper right', bbox_to_anchor=(0.4, 0.78), ncol = 1) |
|
|
| ax.view_init(elev=8, azim=-79) |
| ax.invert_zaxis() |
| |
| plt.tight_layout() |
| plt.savefig(out_dir / "translation_rotation_3d.pdf", bbox_inches='tight') |
| plt.rcParams.update(plt.rcParamsDefault) |
|
|
|
|
| def _pose_translation(p): |
| if "tx" in p: |
| return np.array([p["tx"], p["ty"], p["tz"]], dtype=float) |
| if "t" in p: |
| return np.array(p["t"], dtype=float) |
| return None |
|
|
|
|
| def fig_pose_3d_train_vs_test(pose_records, train_pose_records, out_dir=None, |
| cam_properties=None, voxel_size=135, |
| sphere_coverage=100.0, show_points=False, |
| show_vectors=True, show_ellipsoids=True, |
| task2_parity="odd"): |
| import re |
|
|
| if not pose_records and not train_pose_records: |
| print(" [SKIP] No pose data found for train/test comparison.") |
| return |
|
|
| task2_parity = str(task2_parity).lower() |
| if task2_parity not in {"odd", "even", "both"}: |
| raise ValueError("task2_parity must be 'odd', 'even', or 'both'") |
|
|
| def is_task2_pose(p): |
| task = str(p.get("task", "")).lower().replace(" ", "") |
| if task in {"2", "task2", "task_2"}: |
| return True |
|
|
| for key in ("image_path", "_abs_path", "file_path", "path", |
| "image_name", "file_name"): |
| value = str(p.get(key, "")).replace("\\", "/").lower() |
| if re.search(r"(?:^|/)task[_]?2(?:/|$)", value): |
| return True |
| return False |
|
|
| def get_image_number(p): |
| for key in ("image_id", "image_name", "file_name", |
| "image_path", "_abs_path", "file_path", "path"): |
| value = str(p.get(key, "")) |
| if not value or value.lower() == "none": |
| continue |
| match = re.search(r"(\d+)(?=\.[^.]+$|$)", value) |
| if match: |
| return int(match.group(1)) |
| return None |
|
|
| sets = [ |
| ("Test", pose_records, "#fde725"), |
| ("Train", train_pose_records, "#20a486"), |
| ] |
|
|
| rc = { |
| 'font.size': 14, |
| 'axes.titlesize': 16, |
| 'axes.labelsize': 14, |
| 'legend.fontsize': 12, |
| } |
|
|
| task2_seen = 0 |
| task2_kept = 0 |
|
|
| with plt.rc_context(rc): |
| fig = plt.figure(figsize=(12, 9)) |
| ax = fig.add_subplot(111, projection="3d") |
| ax.set_facecolor('white') |
|
|
| ax.xaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
| ax.yaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
| ax.zaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
|
|
| length = 100.0 |
| alpha_val = 0.4 |
| all_x, all_y, all_z = [0.0], [0.0], [0.0] |
| sphere_proxies = [] |
| point_proxies = [] |
|
|
| scatter_x, scatter_y, scatter_z, scatter_c = [], [], [], [] |
|
|
| for name, poses, color in sets: |
| if not poses: |
| continue |
|
|
| all_translations = [] |
| filtered_translations = [] |
| occupied_voxels = set() |
|
|
| for p in poses: |
| |
| if name == "Train" and is_task2_pose(p): |
| task2_seen += 1 |
| if task2_parity != "both": |
| image_number = get_image_number(p) |
| if image_number is None: |
| print( |
| " [WARNING] Could not determine image number " |
| "for a Task 2 training pose; skipping it for " |
| f"task2_parity='{task2_parity}'." |
| ) |
| continue |
| if task2_parity == "odd" and image_number % 2 == 0: |
| continue |
| if task2_parity == "even" and image_number % 2 != 0: |
| continue |
| task2_kept += 1 |
|
|
| t = _pose_translation(p) |
| if t is None: |
| continue |
|
|
| all_translations.append(t) |
|
|
| if voxel_size is not None and voxel_size > 0: |
| voxel_idx = ( |
| int(np.floor(t[0] / voxel_size)), |
| int(np.floor(t[1] / voxel_size)), |
| int(np.floor(t[2] / voxel_size)), |
| ) |
| if voxel_idx in occupied_voxels: |
| continue |
| occupied_voxels.add(voxel_idx) |
|
|
| filtered_translations.append(t) |
|
|
| if show_vectors and p.get("R") is not None: |
| R = np.asarray(p["R"], dtype=float).reshape(3, 3) |
| for i, axis_color in enumerate(['r', 'g', 'b']): |
| ax.quiver(t[0], t[1], t[2], |
| R[0, i] * length, R[1, i] * length, R[2, i] * length, |
| color=axis_color, alpha=alpha_val) |
|
|
| if not all_translations: |
| continue |
|
|
| t_arr_all = np.array(all_translations) |
| t_arr_filtered = np.array(filtered_translations) |
|
|
| if show_points and len(t_arr_filtered) > 0: |
| scatter_x.extend(t_arr_filtered[:, 0]) |
| scatter_y.extend(t_arr_filtered[:, 1]) |
| scatter_z.extend(t_arr_filtered[:, 2]) |
| scatter_c.extend([color] * len(t_arr_filtered)) |
|
|
| point_proxies.append( |
| Line2D([0], [0], marker='o', color='w', markerfacecolor=color, |
| markersize=6, label=f"{name} translations") |
| ) |
|
|
| center = t_arr_all.mean(axis=0) |
|
|
| if show_ellipsoids: |
| dists = np.linalg.norm(t_arr_all - center, axis=1) |
| threshold = np.percentile(dists, sphere_coverage) |
| core_points = t_arr_all[dists <= threshold] |
|
|
| if len(core_points) >= 4: |
| hull = ConvexHull(core_points) |
| faces = [core_points[simplex] for simplex in hull.simplices] |
| poly = Poly3DCollection(faces, alpha=0.2, facecolors=color, linewidths=0) |
| ax.add_collection3d(poly) |
|
|
| sphere_proxies.append( |
| Patch(facecolor=color, edgecolor=color, alpha=0.3, |
| label=f"{name} convex hull") |
| ) |
|
|
| all_x.extend([core_points[:, 0].min(), core_points[:, 0].max()]) |
| all_y.extend([core_points[:, 1].min(), core_points[:, 1].max()]) |
| all_z.extend([core_points[:, 2].min(), core_points[:, 2].max()]) |
| else: |
| all_x.extend(t_arr_filtered[:, 0]) |
| all_y.extend(t_arr_filtered[:, 1]) |
| all_z.extend(t_arr_filtered[:, 2]) |
|
|
| if task2_parity != "both": |
| print( |
| f" Train Task 2 parity filter ('{task2_parity}'): " |
| f"kept {task2_kept}/{task2_seen} Task 2 poses." |
| ) |
|
|
| if show_points and scatter_x: |
| ax.scatter(scatter_x, scatter_y, scatter_z, |
| s=0.2, c=scatter_c, alpha=1, depthshade=False) |
|
|
| if show_vectors: |
| ax.plot([], [], [], color='r', label='X Axis Rotation') |
| ax.plot([], [], [], color='g', label='Y Axis Rotation') |
| ax.plot([], [], [], color='b', label='Z Axis Rotation') |
|
|
| if cam_properties: |
| cmap = plt.get_cmap('viridis') |
| safe_viridis_values = [0.1, 0.88] |
|
|
| for idx, (cam_id, props) in enumerate(cam_properties.items()): |
| K = np.array(props["cam_K"]).reshape(3, 3) |
| R = np.array(props.get("R", np.eye(3))).reshape(3, 3) |
| t = np.array(props.get("t", np.zeros(3))) |
|
|
| min_depth = props.get("min_depth", 300.0) |
| max_depth = props.get("max_depth", 1000.0) |
| draw_max_depth = props.get("draw_max_depth", max_depth) |
|
|
| color_val = safe_viridis_values[idx % len(safe_viridis_values)] |
| cam_color = cmap(color_val) |
|
|
| pts = draw_working_frustum( |
| ax, K, R, t, min_depth, max_depth, |
| draw_max_depth=draw_max_depth, |
| color=cam_color, |
| label=f"{cam_id} Frustum", |
| ) |
|
|
| all_x.extend(pts[:, 0]) |
| all_y.extend(pts[:, 1]) |
| all_z.extend(pts[:, 2]) |
|
|
| if all_x: |
| ax.set_xlim(min(all_x), max(all_x)) |
| ax.set_ylim(min(all_y), max(all_y)) |
| ax.set_zlim(min(all_z), max(all_z)) |
|
|
| ax.set_xlabel("X Translation [mm]", labelpad=20) |
| ax.set_ylabel("Y Translation [mm]", labelpad=20) |
| ax.set_zlabel("Z Translation [mm]", labelpad=20) |
|
|
| ax.tick_params(axis='z', pad=10) |
|
|
| handles, labels = ax.get_legend_handles_labels() |
| handles = point_proxies + handles + sphere_proxies |
| ax.legend(handles=handles, loc='upper left', bbox_to_anchor=(0.13, 0.78), ncol=1) |
|
|
| ax.view_init(elev=8, azim=-79) |
| ax.invert_zaxis() |
|
|
| plt.tight_layout() |
| if out_dir: |
| out_path = out_dir / "translation_rotation_3d_train_vs_test_vectors.pdf" |
| plt.savefig(out_path, bbox_inches='tight') |
| plt.show() |
| plt.close(fig) |
|
|
| |
| |
| |
|
|
| def print_6dof_stats(pose_records, label=None): |
| if label: |
| print(f"\n[{label}]") |
|
|
| if not pose_records: |
| print(" [SKIP] No pose data found.") |
| return |
|
|
| translations = [] |
| rotations_euler = [] |
|
|
| for p in pose_records: |
| if "tx" in p: |
| t = [p["tx"], p["ty"], p["tz"]] |
| elif "t" in p: |
| t = p["t"] |
| else: |
| continue |
| translations.append(t) |
|
|
| if "R" in p: |
| rmat = np.array(p["R"]).reshape(3, 3) |
| euler = Rotation.from_matrix(rmat).as_euler('xyz', degrees=True) |
| rotations_euler.append(euler) |
| elif "rx" in p: |
| rvec = [p["rx"], p["ry"], p["rz"]] |
| euler = Rotation.from_rotvec(rvec).as_euler('xyz', degrees=True) |
| rotations_euler.append(euler) |
| else: |
| rotations_euler.append([0.0, 0.0, 0.0]) |
|
|
| t_arr = np.array(translations) |
| r_arr = np.array(rotations_euler) |
|
|
| t_mean = np.mean(t_arr, axis=0) |
| t_std = np.std(t_arr, axis=0) |
| r_mean = np.mean(r_arr, axis=0) |
| r_std = np.std(r_arr, axis=0) |
|
|
| print("Translation Statistics [mm]:") |
| print(f" X: Mean {t_mean[0]:.3f}, Std {t_std[0]:.3f}") |
| print(f" Y: Mean {t_mean[1]:.3f}, Std {t_std[1]:.3f}") |
| print(f" Z: Mean {t_mean[2]:.3f}, Std {t_std[2]:.3f}") |
| print("Rotation Statistics (Euler XYZ) [degrees]:") |
| print(f" RX: Mean {r_mean[0]:.3f}, Std {r_std[0]:.3f}") |
| print(f" RY: Mean {r_mean[1]:.3f}, Std {r_std[1]:.3f}") |
| print(f" RZ: Mean {r_mean[2]:.3f}, Std {r_std[2]:.3f}") |
|
|
| return t_mean, t_std, r_mean, r_std |
|
|
|
|
| |
| |
| |
|
|
| def fig_spatial_heatmap_ungrouped(ann_records, out_dir): |
| H, W = 480, 640 |
| if not HAS_PYCOCOTOOLS: |
| return |
| |
| FS = 19 |
|
|
| |
| MERGED = { |
| "nuisance_dent+plastic": ["nuisance_dent", "nuisance_plastic"], |
| } |
| MERGED_LOOKUP = {} |
| for merged_name, members in MERGED.items(): |
| for m in members: |
| MERGED_LOOKUP[m] = merged_name |
|
|
| |
| all_cats_raw = sorted({r["cat_name"] for r in ann_records if "cat_name" in r}) |
| seen = set() |
| all_cats = [] |
| for cat in all_cats_raw: |
| display = MERGED_LOOKUP.get(cat, cat) |
| if display not in seen: |
| all_cats.append(display) |
| seen.add(display) |
|
|
| |
| heatmaps = {cat: np.zeros((H, W), dtype=float) for cat in all_cats} |
|
|
| for r in ann_records: |
| seg = r.get("_segmentation") |
| if seg is None: |
| continue |
| cat = r.get("cat_name") |
| if cat is None: |
| continue |
| display = MERGED_LOOKUP.get(cat, cat) |
| if display not in heatmaps: |
| continue |
| try: |
| if isinstance(seg, dict) and not isinstance(seg.get("counts"), list): |
| rle = seg |
| else: |
| rle = coco_mask_utils.frPyObjects(seg, H, W) |
| m = coco_mask_utils.decode(rle) |
| if m.ndim == 3: |
| m = m.sum(axis=2) |
| heatmaps[display] += m.astype(float) |
| except Exception: |
| continue |
|
|
| n_cats = len(all_cats) |
| n_rows, n_cols = 2, 6 |
|
|
| fig, axes = plt.subplots(n_rows, n_cols, figsize=(n_cols * 4, n_rows * 3.5)) |
| fig.patch.set_facecolor("white") |
| axes = axes.flatten() |
|
|
| for ax, cat in zip(axes, all_cats): |
| im = ax.imshow(heatmaps[cat], cmap="viridis", interpolation="bilinear") |
| ax.set_title(cat, fontsize=FS) |
| ax.axis("off") |
| cbar = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04) |
| cbar.ax.tick_params(labelsize=FS - 2) |
|
|
| for ax in axes[n_cats:]: |
| ax.set_visible(False) |
|
|
| fig.tight_layout() |
| save(fig, out_dir / "spatial_heatmap_ungrouped.pdf") |
|
|
|
|
| def fig_spatial_heatmap_ungrouped_common_legend(ann_records, out_dir): |
| H, W = 480, 640 |
| if not HAS_PYCOCOTOOLS: |
| return |
| |
| FS = 14 |
|
|
| |
| MERGED = { |
| "nuisance_dent+plastic": ["nuisance_dent", "nuisance_plastic"], |
| } |
| MERGED_LOOKUP = {} |
| for merged_name, members in MERGED.items(): |
| for m in members: |
| MERGED_LOOKUP[m] = merged_name |
|
|
| |
| all_cats_raw = sorted({r["cat_name"] for r in ann_records if "cat_name" in r}) |
| seen = set() |
| all_cats = [] |
| for cat in all_cats_raw: |
| display = MERGED_LOOKUP.get(cat, cat) |
| if display not in seen: |
| all_cats.append(display) |
| seen.add(display) |
|
|
| |
| heatmaps = {cat: np.zeros((H, W), dtype=float) for cat in all_cats} |
|
|
| for r in ann_records: |
| seg = r.get("_segmentation") |
| if seg is None: |
| continue |
| cat = r.get("cat_name") |
| if cat is None: |
| continue |
| display = MERGED_LOOKUP.get(cat, cat) |
| if display not in heatmaps: |
| continue |
| try: |
| if isinstance(seg, dict) and not isinstance(seg.get("counts"), list): |
| rle = seg |
| else: |
| rle = coco_mask_utils.frPyObjects(seg, H, W) |
| m = coco_mask_utils.decode(rle) |
| if m.ndim == 3: |
| m = m.sum(axis=2) |
| heatmaps[display] += m.astype(float) |
| except Exception: |
| continue |
|
|
| n_cats = len(all_cats) |
| n_rows, n_cols = 4, 3 |
|
|
| fig, axes = plt.subplots(n_rows, n_cols, figsize=(n_cols * 4, n_rows * 2.9)) |
| fig.patch.set_facecolor("white") |
| axes = axes.flatten() |
|
|
| |
| x_ticks = [0, W // 2, W - 1] |
| y_ticks = [0, H // 2, H - 1] |
|
|
| for ax, cat in zip(axes, all_cats): |
| im = ax.imshow( |
| heatmaps[cat], |
| cmap="viridis", |
| interpolation="bilinear" |
| ) |
|
|
| ax.set_title(cat, fontsize=FS) |
|
|
| |
| ax.set_xlabel("x (pixels)", fontsize=FS - 1) |
| ax.set_ylabel("y (pixels)", fontsize=FS - 1) |
|
|
| |
| ax.set_xticks(x_ticks) |
| ax.set_yticks(y_ticks) |
|
|
| ax.tick_params( |
| axis="both", |
| which="major", |
| labelsize=FS - 3 |
| ) |
|
|
| ax.tick_params( |
| axis="y", |
| labelrotation=70 |
| ) |
|
|
| cbar = fig.colorbar( |
| im, |
| ax=ax, |
| fraction=0.046, |
| pad=0.07 |
| ) |
| cbar.set_label( |
| "Annotation count", |
| fontsize=FS - 2 |
| ) |
| cbar.ax.tick_params(labelsize=FS - 2) |
|
|
| for ax in axes[n_cats:]: |
| ax.set_visible(False) |
|
|
| fig.subplots_adjust( |
| left=0.08, |
| right=0.95, |
| top=0.97, |
| bottom=0.05, |
| hspace=0.5, |
| wspace=0.30 |
| ) |
|
|
| fig.tight_layout() |
| save(fig, out_dir / "spatial_heatmap_ungrouped.pdf") |
|
|
|
|
| |
| |
| |
|
|
| def inject_abs_paths(records, scenes): |
| """Attach absolute image paths to each record for pixel-level figures.""" |
| scene_root_map = {s["scene_id"]: s["root"] for s in scenes} |
| for r in records: |
| root = scene_root_map.get(r["scene_id"]) |
| if root: |
| r["_abs_path"] = str(root / r["file_name"]) |
| r["_root"] = str(root) |
|
|
| def inject_segmentation(ann_records, scenes): |
| """Attach segmentation data to ann_records for spatial heatmap figure.""" |
| |
| for s in scenes: |
| scene_id = s["scene_id"] |
| cat_map = s["cat_map"] |
| for ann in s["coco"].get("annotations", []): |
| cat_name = cat_map.get(ann["category_id"], "unknown") |
| seg = ann.get("segmentation") |
| if seg: |
| |
| for ar in ann_records: |
| if (ar["scene_id"] == scene_id and |
| ar["image_id"] == ann["image_id"] and |
| ar["cat_name"] == cat_name and |
| "_segmentation" not in ar): |
| ar["_segmentation"] = seg |
| break |
|
|
| my_cameras = { |
| "RealSense": { |
| "cam_K": [608.43, 0.0, 311.2, 0.0, 608.4, 239.6, 0.0, 0.0, 1.0], |
| "min_depth": 300.0, |
| "max_depth": 3000.0, |
| "draw_max_depth": 1200.0 |
| }, |
| "Zivid": { |
| "cam_K": [1242.25, 0.0, 620.7, 0.0, 1241.8, 503.7, 0.0, 0.0, 1.0], |
| "min_depth": 350.0, |
| "max_depth": 1100.0, |
| "draw_max_depth": 1100.0 |
| } |
| } |
|
|
| def calc_variability_metrics(records, pose_records, label="", ignore_sym=False, sym_axis='z'): |
| print("Variability Metrics Report" + label) |
|
|
| |
| |
| |
| scene_intensity = defaultdict(list) |
| all_intensity = [] |
| if PILImage is not None: |
| for r in records: |
| img_path_str = r.get("_abs_path", "") |
| if not img_path_str: |
| continue |
| img_path = Path(img_path_str) |
| if img_path.is_file(): |
| try: |
| img = np.array(PILImage.open(img_path).convert("L")) |
| mean_val = np.mean(img) |
| scene_intensity[r["scene_id"]].append(mean_val) |
| all_intensity.append(mean_val) |
| except Exception: |
| pass |
|
|
| print("\nIllumination Spread per Scene (Mean Pixel Intensity):") |
| for sc in sorted(scene_intensity.keys()): |
| means = scene_intensity[sc] |
| if means: |
| print(f" Scene {sc}: Mean {np.mean(means):.2f}, StdDev {np.std(means):.2f}, " |
| f"Min {np.min(means):.2f}, Max {np.max(means):.2f}") |
|
|
| if all_intensity: |
| print(f"\nIllumination Spread (All Scenes Pooled): " |
| f"Mean {np.mean(all_intensity):.2f}, StdDev {np.std(all_intensity):.2f}, " |
| f"Min {np.min(all_intensity):.2f}, Max {np.max(all_intensity):.2f}") |
|
|
| if not pose_records: |
| return |
|
|
| |
| |
| |
| scene_poses = defaultdict(lambda: {"t": [], "rot": []}) |
| t_all = [] |
| rot_all = [] |
| scene_ids_all = [] |
|
|
| for p in pose_records: |
| sc = p["scene_id"] |
|
|
| if "tx" in p: |
| t = [p["tx"], p["ty"], p["tz"]] |
| elif "t" in p: |
| t = p["t"] |
| else: |
| t = None |
|
|
| rot = None |
| if "R" in p: |
| rmat = np.array(p["R"]).reshape(3, 3) |
| rot = Rotation.from_matrix(rmat) |
| elif "rx" in p: |
| rvec = [p["rx"], p["ry"], p["rz"]] |
| rot = Rotation.from_rotvec(rvec) |
|
|
| if t is not None: |
| t_all.append(t) |
| scene_poses[sc]["t"].append(t) |
| if rot is not None: |
| rot_all.append(rot) |
| scene_poses[sc]["rot"].append(rot) |
| scene_ids_all.append(sc) |
|
|
| def _translation_spread_mm(t_list): |
| """Per-pose Euclidean distance from the centroid, merging X/Y/Z |
| into a single scalar. Returns (mean, std, min, max).""" |
| if len(t_list) < 2: |
| return None |
| t_arr = np.array(t_list) |
| centroid = np.mean(t_arr, axis=0) |
| dist = np.linalg.norm(t_arr - centroid, axis=1) |
| return float(np.mean(dist)), float(np.std(dist)), float(np.min(dist)), float(np.max(dist)) |
|
|
| def _quat_spread_deg(rot_list, scene_ids=None): |
| if len(rot_list) < 2: |
| return None |
| rots = Rotation.concatenate(rot_list) |
| mean_rot = rots.mean() |
| rel = mean_rot.inv() * rots |
| dev_deg = rel.magnitude() * 180.0 / np.pi |
| |
| if ignore_sym and scene_ids is not None: |
| vec = [0.0, 0.0, 0.0] |
| vec[{'x': 0, 'y': 1, 'z': 2}[sym_axis.lower()]] = np.pi |
| sym_rot = Rotation.from_rotvec(vec) |
| |
| rel_sym = mean_rot.inv() * (rots * sym_rot) |
| dev_deg_sym = rel_sym.magnitude() * 180.0 / np.pi |
| |
| |
| mask = np.array([int(sid) <= 4 for sid in scene_ids]) |
| dev_deg[mask] = np.minimum(dev_deg[mask], dev_deg_sym[mask]) |
| |
| return float(np.mean(dev_deg)), float(np.std(dev_deg)), float(np.min(dev_deg)), float(np.max(dev_deg)) |
|
|
| |
| |
| |
| print("\nGlobal Pose Diversity:") |
| t_global = _translation_spread_mm(t_all) |
| if t_global is not None: |
| mean_t, std_t, min_t, max_t = t_global |
| print(f" Translation Spread [mm]: Mean {mean_t:.1f}, StdDev {std_t:.1f}, " |
| f"Min {min_t:.1f}, Max {max_t:.1f}") |
|
|
| r_global = _quat_spread_deg(rot_all, scene_ids=scene_ids_all) |
| if r_global is not None: |
| mean_r, std_r, min_r, max_r = r_global |
| print(f" Rotation Spread [deg]: Mean {mean_r:.1f}, StdDev {std_r:.1f}, " |
| f"Min {min_r:.1f}, Max {max_r:.1f}") |
|
|
| |
| |
| |
| print("\nPer-Scene Pose Spread:") |
| for sc in sorted(scene_poses.keys()): |
| ts = scene_poses[sc]["t"] |
| rots_sc = scene_poses[sc]["rot"] |
| line_parts = [f" Scene {sc}:"] |
|
|
| t_summary = _translation_spread_mm(ts) |
| if t_summary is not None: |
| mean_t, std_t, min_t, max_t = t_summary |
| line_parts.append( |
| f"Translation [mm] Mean {mean_t:.1f} StdDev {std_t:.1f} Min {min_t:.1f} Max {max_t:.1f}" |
| ) |
|
|
| r_summary = _quat_spread_deg(rots_sc, scene_ids=[sc] * len(rots_sc)) |
| if r_summary is not None: |
| mean_r, std_r, min_r, max_r = r_summary |
| line_parts.append( |
| f"Rotation [deg] Mean {mean_r:.1f} StdDev {std_r:.1f} Min {min_r:.1f} Max {max_r:.1f}" |
| ) |
|
|
| print(" | ".join(line_parts)) |
|
|
| def _pose_rotation(pose): |
| """Convert a pose record to a scipy Rotation object.""" |
| if "R" in pose: |
| rmat = np.asarray(pose["R"], dtype=float).reshape(3, 3) |
| return Rotation.from_matrix(rmat) |
|
|
| if "rx" in pose: |
| rvec = np.array( |
| [pose["rx"], pose["ry"], pose["rz"]], |
| dtype=float, |
| ) |
| return Rotation.from_rotvec(rvec) |
|
|
| return None |
|
|
|
|
| def _pose_translation(pose): |
| """Extract the translation vector from a pose record.""" |
| if "tx" in pose: |
| return np.array( |
| [pose["tx"], pose["ty"], pose["tz"]], |
| dtype=float, |
| ) |
|
|
| if "t" in pose: |
| return np.asarray(pose["t"], dtype=float) |
|
|
| return None |
|
|
|
|
| def _pose_key_variants(value): |
| """ |
| Generate possible identifiers for matching a pose record to an image. |
| |
| Pose files in I-BADAS may use integer indices, image filenames, |
| or filename stems as keys. |
| """ |
| variants = set() |
|
|
| if value is None: |
| return variants |
|
|
| text = str(value) |
| variants.add(text) |
|
|
| path = Path(text) |
| variants.add(path.name) |
| variants.add(path.stem) |
|
|
| try: |
| number = int(text) |
| variants.add(str(number)) |
| variants.add(f"{number:05d}") |
| variants.add(f"{number:06d}") |
| variants.add(f"{number:08d}") |
| except (TypeError, ValueError): |
| pass |
|
|
| return variants |
|
|
|
|
| def _build_pose_lookup(pose_records): |
| """ |
| Build a lookup table from scene/image identifiers to pose records. |
| """ |
| lookup = {} |
|
|
| for pose in pose_records: |
| scene_id = pose["scene_id"] |
|
|
| for key in _pose_key_variants(pose.get("image_id")): |
| lookup[(scene_id, key)] = pose |
|
|
| return lookup |
|
|
|
|
| def _find_pose_for_record(record, pose_lookup): |
| """Find the pose corresponding to an image record.""" |
| scene_id = record["scene_id"] |
|
|
| candidates = set() |
|
|
| candidates.update(_pose_key_variants(record.get("image_id"))) |
| candidates.update(_pose_key_variants(record.get("file_name"))) |
|
|
| for key in candidates: |
| pose = pose_lookup.get((scene_id, key)) |
| if pose is not None: |
| return pose |
|
|
| return None |
|
|
|
|
| def _rotation_distance_deg(reference_rotation, rotation, scene_id=None, ignore_sym=False, sym_axis='z'): |
| relative = reference_rotation.inv() * rotation |
| dist = float(relative.magnitude() * 180.0 / np.pi) |
| |
| if ignore_sym and scene_id is not None and int(scene_id) <= 4: |
| vec = [0.0, 0.0, 0.0] |
| vec[{'x': 0, 'y': 1, 'z': 2}[sym_axis.lower()]] = np.pi |
| sym_rot = Rotation.from_rotvec(vec) |
| relative_sym = reference_rotation.inv() * (rotation * sym_rot) |
| dist_sym = float(relative_sym.magnitude() * 180.0 / np.pi) |
| dist = min(dist, dist_sym) |
| |
| return dist |
|
|
|
|
| def _percentile_rank(values): |
| """ |
| Convert values to percentile ranks in [0, 1]. |
| |
| Lower values correspond to lower variation. |
| """ |
| values = np.asarray(values, dtype=float) |
|
|
| if len(values) == 0: |
| return np.array([]) |
|
|
| order = np.argsort(values, kind="stable") |
| ranks = np.empty(len(values), dtype=float) |
|
|
| if len(values) == 1: |
| ranks[order] = 0.0 |
| return ranks |
|
|
| ranks[order] = np.arange(len(values)) / (len(values) - 1) |
|
|
| return ranks |
|
|
|
|
| def export_variation_csv(records, pose_records, out_dir, |
| train_records=None, train_pose_records=None, |
| ignore_sym=False, sym_axis='y'): |
| """ |
| Compute per-image illumination and pose variation scores and export them |
| to a CSV file. |
| |
| The CSV contains raw measurements, per-scene variation scores, |
| global variation scores, and percentile ranks. |
| |
| If train_records / train_pose_records are given, the CSV additionally |
| contains the same deltas measured against the TRAIN data references |
| (per train scene and over the whole train set), plus percentile ranks. |
| """ |
| if PILImage is None: |
| print(" [SKIP] Pillow not available for illumination analysis.") |
| return |
|
|
| out_dir = Path(out_dir) |
| out_dir.mkdir(parents=True, exist_ok=True) |
|
|
| pose_lookup = _build_pose_lookup(pose_records) |
|
|
| rows = [] |
|
|
| |
| |
| |
|
|
| use_train = bool(train_records) or bool(train_pose_records) |
| if use_train: |
| train_refs = _train_reference_stats( |
| train_records or [], train_pose_records or [] |
| ) |
| else: |
| train_refs = None |
|
|
| |
| |
| |
|
|
| scene_intensities = defaultdict(list) |
| all_intensities = [] |
|
|
| for record in records: |
| image_path = Path(record.get("_abs_path", "")) |
|
|
| if not image_path.is_file(): |
| continue |
|
|
| try: |
| image = np.asarray(PILImage.open(image_path).convert("L")) |
| mean_intensity = float(np.mean(image)) |
| except Exception: |
| continue |
|
|
| scene_intensities[record["scene_id"]].append(mean_intensity) |
| all_intensities.append(mean_intensity) |
|
|
| scene_intensity_mean = { |
| scene_id: float(np.mean(values)) |
| for scene_id, values in scene_intensities.items() |
| if values |
| } |
|
|
| global_intensity_mean = ( |
| float(np.mean(all_intensities)) |
| if all_intensities |
| else np.nan |
| ) |
|
|
| |
| |
| |
|
|
| scene_translations = defaultdict(list) |
| scene_rotations = defaultdict(list) |
|
|
| all_translations = [] |
| all_rotations = [] |
|
|
| matched_pose_count = 0 |
|
|
| for record in records: |
| pose = _find_pose_for_record(record, pose_lookup) |
|
|
| if pose is None: |
| continue |
|
|
| translation = _pose_translation(pose) |
| rotation = _pose_rotation(pose) |
|
|
| if translation is not None: |
| scene_translations[record["scene_id"]].append(translation) |
| all_translations.append(translation) |
|
|
| if rotation is not None: |
| scene_rotations[record["scene_id"]].append(rotation) |
| all_rotations.append(rotation) |
|
|
| if translation is not None or rotation is not None: |
| matched_pose_count += 1 |
|
|
| |
| scene_translation_centroids = { |
| scene_id: np.mean(values, axis=0) |
| for scene_id, values in scene_translations.items() |
| if values |
| } |
|
|
| |
| global_translation_centroid = ( |
| np.mean(all_translations, axis=0) |
| if all_translations |
| else None |
| ) |
|
|
| |
| scene_rotation_means = {} |
|
|
| for scene_id, rotations in scene_rotations.items(): |
| if rotations: |
| scene_rotation_means[scene_id] = ( |
| Rotation.concatenate(rotations).mean() |
| ) |
|
|
| |
| global_rotation_mean = None |
|
|
| if all_rotations: |
| global_rotation_mean = ( |
| Rotation.concatenate(all_rotations).mean() |
| ) |
|
|
| |
| |
| |
|
|
| for record in records: |
| scene_id = record["scene_id"] |
|
|
| row = { |
| "scene_id": scene_id, |
| "image_id": record["image_id"], |
| "file_name": record["file_name"], |
| "classification": record.get("classification", ""), |
| "camera": record.get("camera", ""), |
| "box_type": record.get("box_type", ""), |
| } |
|
|
| |
| |
| |
|
|
| image_path = Path(record.get("_abs_path", "")) |
|
|
| mean_intensity = np.nan |
|
|
| if image_path.is_file(): |
| try: |
| image = np.asarray( |
| PILImage.open(image_path).convert("L") |
| ) |
| mean_intensity = float(np.mean(image)) |
| except Exception: |
| pass |
|
|
| row["mean_intensity"] = mean_intensity |
|
|
| if ( |
| np.isfinite(mean_intensity) |
| and scene_id in scene_intensity_mean |
| ): |
| row["illumination_variation_scene"] = abs( |
| mean_intensity - scene_intensity_mean[scene_id] |
| ) |
| else: |
| row["illumination_variation_scene"] = np.nan |
|
|
| if np.isfinite(mean_intensity): |
| row["illumination_variation_global"] = abs( |
| mean_intensity - global_intensity_mean |
| ) |
| else: |
| row["illumination_variation_global"] = np.nan |
|
|
| |
| |
| |
|
|
| pose = _find_pose_for_record(record, pose_lookup) |
|
|
| translation = None |
| rotation = None |
|
|
| if pose is not None: |
| translation = _pose_translation(pose) |
| rotation = _pose_rotation(pose) |
|
|
| if translation is not None: |
| row["tx"] = float(translation[0]) |
| row["ty"] = float(translation[1]) |
| row["tz"] = float(translation[2]) |
|
|
| scene_centroid = scene_translation_centroids.get(scene_id) |
|
|
| if scene_centroid is not None: |
| row["translation_variation_scene_mm"] = float( |
| np.linalg.norm(translation - scene_centroid) |
| ) |
|
|
| if global_translation_centroid is not None: |
| row["translation_variation_global_mm"] = float( |
| np.linalg.norm( |
| translation - global_translation_centroid |
| ) |
| ) |
| else: |
| row["tx"] = np.nan |
| row["ty"] = np.nan |
| row["tz"] = np.nan |
| row["translation_variation_scene_mm"] = np.nan |
| row["translation_variation_global_mm"] = np.nan |
|
|
| if rotation is not None: |
| scene_rotation = scene_rotation_means.get(scene_id) |
|
|
| if scene_rotation is not None: |
| row["rotation_variation_scene_deg"] = ( |
| _rotation_distance_deg( |
| scene_rotation, |
| rotation, |
| scene_id=scene_id, |
| ignore_sym=ignore_sym, |
| sym_axis=sym_axis |
| ) |
| ) |
|
|
| if global_rotation_mean is not None: |
| row["rotation_variation_global_deg"] = ( |
| _rotation_distance_deg( |
| global_rotation_mean, |
| rotation, |
| scene_id=scene_id, |
| ignore_sym=ignore_sym, |
| sym_axis=sym_axis |
| ) |
| ) |
| else: |
| row["rotation_variation_scene_deg"] = np.nan |
| row["rotation_variation_global_deg"] = np.nan |
|
|
| |
| |
| |
|
|
| if use_train: |
| |
| ill_train_scene = np.nan |
| ill_train_global = np.nan |
|
|
| if np.isfinite(mean_intensity): |
| ref_scene_int = train_refs["scene_intensity_mean"].get(scene_id) |
| if ref_scene_int is not None: |
| ill_train_scene = abs(mean_intensity - ref_scene_int) |
|
|
| if train_refs["global_intensity_mean"] is not None: |
| ill_train_global = abs( |
| mean_intensity - train_refs["global_intensity_mean"] |
| ) |
|
|
| |
| trans_train_scene = np.nan |
| trans_train_global = np.nan |
|
|
| if translation is not None: |
| ref_scene_t = train_refs["scene_translation_centroid"].get(scene_id) |
| if ref_scene_t is not None: |
| trans_train_scene = float( |
| np.linalg.norm(translation - ref_scene_t) |
| ) |
|
|
| if train_refs["global_translation_centroid"] is not None: |
| trans_train_global = float( |
| np.linalg.norm( |
| translation - train_refs["global_translation_centroid"] |
| ) |
| ) |
|
|
| |
| rot_train_scene = np.nan |
| rot_train_global = np.nan |
|
|
| if rotation is not None: |
| ref_scene_r = train_refs["scene_rotation_mean"].get(scene_id) |
| if ref_scene_r is not None: |
| rot_train_scene = _rotation_distance_deg( |
| ref_scene_r, rotation, |
| scene_id=scene_id, |
| ignore_sym=ignore_sym, |
| sym_axis=sym_axis |
| ) |
|
|
| if train_refs["global_rotation_mean"] is not None: |
| rot_train_global = _rotation_distance_deg( |
| train_refs["global_rotation_mean"], rotation, |
| scene_id=scene_id, |
| ignore_sym=ignore_sym, |
| sym_axis=sym_axis |
| ) |
|
|
| row["illumination_variation_train_scene"] = ill_train_scene |
| row["illumination_variation_train_global"] = ill_train_global |
| row["translation_variation_train_scene_mm"] = trans_train_scene |
| row["translation_variation_train_global_mm"] = trans_train_global |
| row["rotation_variation_train_scene_deg"] = rot_train_scene |
| row["rotation_variation_train_global_deg"] = rot_train_global |
|
|
| rows.append(row) |
|
|
| |
| |
| |
|
|
| score_columns = [ |
| "illumination_variation_scene", |
| "illumination_variation_global", |
| "translation_variation_scene_mm", |
| "translation_variation_global_mm", |
| "rotation_variation_scene_deg", |
| "rotation_variation_global_deg", |
| ] |
|
|
| if use_train: |
| score_columns += [ |
| "illumination_variation_train_scene", |
| "illumination_variation_train_global", |
| "translation_variation_train_scene_mm", |
| "translation_variation_train_global_mm", |
| "rotation_variation_train_scene_deg", |
| "rotation_variation_train_global_deg", |
| ] |
|
|
| for column in score_columns: |
| valid = np.isfinite( |
| np.asarray([row[column] for row in rows], dtype=float) |
| ) |
|
|
| values = np.asarray( |
| [row[column] for row in rows], |
| dtype=float, |
| ) |
|
|
| ranks = np.full(len(rows), np.nan) |
|
|
| if np.any(valid): |
| ranks[valid] = _percentile_rank(values[valid]) |
|
|
| rank_column = f"{column}_percentile" |
|
|
| for row, rank in zip(rows, ranks): |
| row[rank_column] = rank |
|
|
| |
| |
| |
|
|
| scene_score_columns = [ |
| "illumination_variation_scene", |
| "translation_variation_scene_mm", |
| "rotation_variation_scene_deg", |
| ] |
|
|
| if use_train: |
| scene_score_columns += [ |
| "illumination_variation_train_scene", |
| "translation_variation_train_scene_mm", |
| "rotation_variation_train_scene_deg", |
| ] |
|
|
| for score_column in scene_score_columns: |
| for scene_id in sorted( |
| set(row["scene_id"] for row in rows) |
| ): |
| indices = [ |
| i |
| for i, row in enumerate(rows) |
| if row["scene_id"] == scene_id |
| and np.isfinite(row[score_column]) |
| ] |
|
|
| if not indices: |
| continue |
|
|
| values = np.asarray( |
| [rows[i][score_column] for i in indices], |
| dtype=float, |
| ) |
|
|
| ranks = _percentile_rank(values) |
|
|
| for i, rank in zip(indices, ranks): |
| rows[i][f"{score_column}_percentile"] = rank |
|
|
| |
| |
| |
| |
| |
|
|
| rows.sort( |
| key=lambda row: ( |
| str(row["scene_id"]), |
| np.inf |
| if not np.isfinite(row["illumination_variation_scene"]) |
| else row["illumination_variation_scene"], |
| ) |
| ) |
|
|
| if not rows: |
| print(" [SKIP] No image measurements could be generated.") |
| return |
|
|
| import csv |
|
|
| csv_path = out_dir / "image_variation_scores.csv" |
|
|
| fieldnames = list(rows[0].keys()) |
|
|
| with open(csv_path, "w", newline="") as f: |
| writer = csv.DictWriter(f, fieldnames=fieldnames) |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
| print(f" Saved: {csv_path}") |
| print(f" Images in CSV: {len(rows)}") |
| print(f" Images with matched poses: {matched_pose_count}") |
|
|
|
|
| |
| |
| |
|
|
| def print_intensity_stat_deltas(test_stats, train_stats): |
| """Delta of the global pixel-mean intensity (Test minus Train).""" |
| if not test_stats or not train_stats: |
| print(" [SKIP] Missing intensity statistics for train/test delta.") |
| return |
|
|
| print("\nIntensity Mean Delta (Test minus Train):") |
| print(f" Train mean: {train_stats['mean']:.2f}, " |
| f"Test mean: {test_stats['mean']:.2f}, " |
| f"Delta: {test_stats['mean'] - train_stats['mean']:+.2f}") |
|
|
|
|
| def print_6dof_stat_deltas(test_result, train_result): |
| """ |
| Delta of the translation means and of the Euler XYZ rotation means |
| (Test minus Train). Inputs are the tuples returned by print_6dof_stats. |
| """ |
| if test_result is None or train_result is None: |
| print(" [SKIP] Missing 6DOF statistics for train/test delta.") |
| return |
|
|
| t_mean_test, _, r_mean_test, _ = test_result |
| t_mean_train, _, r_mean_train, _ = train_result |
|
|
| dt = t_mean_test - t_mean_train |
| dr = r_mean_test - r_mean_train |
|
|
| print("\n6DOF Mean Delta (Test minus Train):") |
| print("Translation [mm]:") |
| print(f" X: {dt[0]:+.3f}") |
| print(f" Y: {dt[1]:+.3f}") |
| print(f" Z: {dt[2]:+.3f}") |
| print(f" Euclidean norm: {np.linalg.norm(dt):.3f}") |
| print("Rotation (Euler XYZ) [degrees]:") |
| print(f" RX: {dr[0]:+.3f}") |
| print(f" RY: {dr[1]:+.3f}") |
| print(f" RZ: {dr[2]:+.3f}") |
|
|
|
|
|
|
| def print_train_test_mean_deltas(records, pose_records, train_records, train_pose_records, ignore_sym=False, sym_axis='z'): |
| """ |
| Global and per-scene deltas between the test and train mean values |
| (Test minus Train): mean image intensity, translation centroid, and the |
| geodesic angle between the mean rotations. |
| """ |
| if not train_records and not train_pose_records: |
| print(" [SKIP] No train data available for train/test deltas.") |
| return |
|
|
| test_refs = _train_reference_stats(records, pose_records) |
| train_refs = _train_reference_stats(train_records, train_pose_records) |
|
|
| print("\nTrain vs. Test Mean Deltas (Test minus Train):") |
|
|
| |
| |
| |
| print("\n Illumination (mean image intensity):") |
| test_g = test_refs["global_intensity_mean"] |
| train_g = train_refs["global_intensity_mean"] |
| if test_g is not None and train_g is not None: |
| print(f" Global: Train {train_g:.2f}, Test {test_g:.2f}, " |
| f"Delta {test_g - train_g:+.2f}") |
|
|
| common = sorted(set(test_refs["scene_intensity_mean"]) |
| & set(train_refs["scene_intensity_mean"])) |
| for sc in common: |
| tr = train_refs["scene_intensity_mean"][sc] |
| te = test_refs["scene_intensity_mean"][sc] |
| print(f" Scene {sc}: Train {tr:.2f}, Test {te:.2f}, Delta {te - tr:+.2f}") |
|
|
| |
| |
| |
| print("\n Translation centroid [mm]:") |
| test_c = test_refs["global_translation_centroid"] |
| train_c = train_refs["global_translation_centroid"] |
| if test_c is not None and train_c is not None: |
| d = test_c - train_c |
| print(f" Global: Delta X {d[0]:+.1f}, Y {d[1]:+.1f}, Z {d[2]:+.1f}, " |
| f"|Delta| {np.linalg.norm(d):.1f}") |
|
|
| common = sorted(set(test_refs["scene_translation_centroid"]) |
| & set(train_refs["scene_translation_centroid"])) |
| for sc in common: |
| d = (test_refs["scene_translation_centroid"][sc] |
| - train_refs["scene_translation_centroid"][sc]) |
| print(f" Scene {sc}: Delta X {d[0]:+.1f}, Y {d[1]:+.1f}, Z {d[2]:+.1f}, " |
| f"|Delta| {np.linalg.norm(d):.1f}") |
|
|
| |
| |
| |
| print("\n Rotation (geodesic angle between mean rotations) [deg]:") |
| test_r = test_refs["global_rotation_mean"] |
| train_r = train_refs["global_rotation_mean"] |
| if test_r is not None and train_r is not None: |
| print(f" Global: {_rotation_distance_deg(train_r, test_r, scene_id=sc, ignore_sym=ignore_sym, sym_axis=sym_axis):.2f}") |
|
|
| common = sorted(set(test_refs["scene_rotation_mean"]) & set(train_refs["scene_rotation_mean"])) |
| for sc in common: |
| ang = _rotation_distance_deg(train_refs["scene_rotation_mean"][sc], |
| test_refs["scene_rotation_mean"][sc], |
| scene_id=sc, ignore_sym=ignore_sym, sym_axis=sym_axis) |
| print(f" Scene {sc}: {ang:.2f}") |
|
|
|
|
| def fig_pose_3d_train_vs_test_hover( |
| pose_records, |
| train_pose_records, |
| out_dir=None, |
| cam_properties=None, |
| voxel_size=135, |
| sphere_coverage=100.0, |
| show_points=False, |
| show_vectors=True, |
| show_ellipsoids=True, |
| ): |
|
|
| if not pose_records and not train_pose_records: |
| print(" [SKIP] No pose data found for train/test comparison.") |
| return |
|
|
| sets = [ |
| ("Test", pose_records, "#fde725"), |
| ("Train", train_pose_records, "#20a486"), |
| ] |
|
|
| rc = { |
| "font.size": 14, |
| "axes.titlesize": 16, |
| "axes.labelsize": 14, |
| "legend.fontsize": 12, |
| } |
|
|
| def get_image_metadata(p): |
| """ |
| Extract the image name and path from a pose record. |
| |
| Add keys here if your dataset uses different field names. |
| """ |
|
|
| |
| path_keys = ( |
| "image_path", |
| "abs_path", |
| "absolute_path", |
| "file_path", |
| "filepath", |
| "path", |
| "image", |
| ) |
|
|
| |
| name_keys = ( |
| "image_name", |
| "filename", |
| "file_name", |
| "name", |
| ) |
|
|
| image_path = None |
| image_name = None |
|
|
| for key in path_keys: |
| value = p.get(key) |
|
|
| if isinstance(value, (str, os.PathLike)): |
| image_path = os.fspath(value) |
| break |
|
|
| for key in name_keys: |
| value = p.get(key) |
|
|
| if isinstance(value, (str, os.PathLike)): |
| image_name = os.fspath(value) |
| break |
|
|
| |
| if image_name is None and image_path is not None: |
| image_name = os.path.basename(image_path) |
|
|
| if image_name is None: |
| image_name = "Unknown" |
|
|
| if image_path is None: |
| image_path = "Unknown" |
|
|
| return image_name, image_path |
|
|
| with plt.rc_context(rc): |
|
|
| fig = plt.figure(figsize=(12, 9)) |
| ax = fig.add_subplot(111, projection="3d") |
|
|
| ax.set_facecolor("white") |
|
|
| ax.xaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
| ax.yaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
| ax.zaxis.set_pane_color((1.0, 1.0, 1.0, 1.0)) |
|
|
| length = 100.0 |
| alpha_val = 0.4 |
|
|
| all_x = [0.0] |
| all_y = [0.0] |
| all_z = [0.0] |
|
|
| sphere_proxies = [] |
| point_proxies = [] |
|
|
| |
| scatter_x = [] |
| scatter_y = [] |
| scatter_z = [] |
| scatter_c = [] |
| scatter_metadata = [] |
|
|
| for split_name, poses, color in sets: |
|
|
| if not poses: |
| continue |
|
|
| all_translations = [] |
| filtered_translations = [] |
|
|
| |
| |
| occupied_voxels = set() |
|
|
| for p in poses: |
|
|
| t = _pose_translation(p) |
|
|
| if t is None: |
| continue |
|
|
| t = np.asarray(t, dtype=float).reshape(-1) |
|
|
| if t.size != 3 or not np.all(np.isfinite(t)): |
| continue |
|
|
| all_translations.append(t) |
|
|
| |
| if voxel_size is not None and voxel_size > 0: |
|
|
| voxel_idx = ( |
| int(np.floor(t[0] / voxel_size)), |
| int(np.floor(t[1] / voxel_size)), |
| int(np.floor(t[2] / voxel_size)), |
| ) |
|
|
| if voxel_idx in occupied_voxels: |
| continue |
|
|
| occupied_voxels.add(voxel_idx) |
|
|
| filtered_translations.append(t) |
|
|
| |
| |
| |
| if show_points: |
|
|
| image_name, image_path = get_image_metadata(p) |
|
|
| scatter_x.append(float(t[0])) |
| scatter_y.append(float(t[1])) |
| scatter_z.append(float(t[2])) |
| scatter_c.append(color) |
|
|
| scatter_metadata.append({ |
| "name": image_name, |
| "path": image_path, |
| "set": split_name, |
| "translation": t.copy(), |
| }) |
|
|
| |
| if show_vectors and p.get("R") is not None: |
|
|
| R = np.asarray( |
| p["R"], dtype=float |
| ).reshape(3, 3) |
|
|
| for i, axis_color in enumerate(["r", "g", "b"]): |
|
|
| ax.quiver( |
| t[0], |
| t[1], |
| t[2], |
| R[0, i] * length, |
| R[1, i] * length, |
| R[2, i] * length, |
| color=axis_color, |
| alpha=alpha_val, |
| ) |
|
|
| if not all_translations: |
| continue |
|
|
| t_arr_all = np.asarray(all_translations) |
| t_arr_filtered = np.asarray(filtered_translations) |
|
|
| |
| if show_points and len(t_arr_filtered) > 0: |
|
|
| point_proxies.append( |
| Line2D( |
| [0], |
| [0], |
| marker="o", |
| color="w", |
| markerfacecolor=color, |
| markersize=6, |
| label=f"{split_name} translations", |
| ) |
| ) |
|
|
| center = t_arr_all.mean(axis=0) |
|
|
| if show_ellipsoids: |
|
|
| dists = np.linalg.norm( |
| t_arr_all - center, |
| axis=1, |
| ) |
|
|
| threshold = np.percentile( |
| dists, |
| sphere_coverage, |
| ) |
|
|
| core_points = t_arr_all[dists <= threshold] |
|
|
| |
| if len(core_points) >= 4: |
|
|
| try: |
| hull = ConvexHull(core_points) |
|
|
| faces = [ |
| core_points[simplex] |
| for simplex in hull.simplices |
| ] |
|
|
| poly = Poly3DCollection( |
| faces, |
| alpha=0.2, |
| facecolors=color, |
| linewidths=0, |
| shade=True, |
| ) |
|
|
| ax.add_collection3d(poly) |
|
|
| except QhullError: |
| |
| |
| pass |
|
|
| sphere_proxies.append( |
| Patch( |
| facecolor=color, |
| edgecolor=color, |
| alpha=0.3, |
| label=f"{split_name} convex hull", |
| ) |
| ) |
|
|
| if len(core_points) > 0: |
|
|
| all_x.extend([ |
| core_points[:, 0].min(), |
| core_points[:, 0].max(), |
| ]) |
|
|
| all_y.extend([ |
| core_points[:, 1].min(), |
| core_points[:, 1].max(), |
| ]) |
|
|
| all_z.extend([ |
| core_points[:, 2].min(), |
| core_points[:, 2].max(), |
| ]) |
|
|
| else: |
|
|
| all_x.extend(t_arr_filtered[:, 0]) |
| all_y.extend(t_arr_filtered[:, 1]) |
| all_z.extend(t_arr_filtered[:, 2]) |
|
|
| |
| |
| |
|
|
| if show_points and scatter_x: |
|
|
| scatter = ax.scatter( |
| scatter_x, |
| scatter_y, |
| scatter_z, |
| s=12, |
| c=scatter_c, |
| alpha=1.0, |
| depthshade=False, |
| picker=True, |
| ) |
|
|
| |
| annot = ax.annotate( |
| "", |
| xy=(0, 0), |
| xytext=(15, 15), |
| textcoords="offset points", |
| bbox={ |
| "boxstyle": "round,pad=0.5", |
| "fc": "white", |
| "ec": "gray", |
| "alpha": 0.95, |
| }, |
| arrowprops={ |
| "arrowstyle": "->", |
| "color": "gray", |
| }, |
| zorder=100, |
| ) |
|
|
| annot.set_visible(False) |
|
|
| |
| hover_state = {"index": None} |
|
|
| def on_move(event): |
|
|
| if event.inaxes != ax or event.x is None or event.y is None: |
|
|
| if annot.get_visible(): |
| annot.set_visible(False) |
| hover_state["index"] = None |
| fig.canvas.draw_idle() |
|
|
| return |
|
|
| |
| xyz = np.column_stack(( |
| scatter_x, |
| scatter_y, |
| scatter_z, |
| )) |
|
|
| projected_x, projected_y, projected_z = ( |
| proj3d.proj_transform( |
| xyz[:, 0], |
| xyz[:, 1], |
| xyz[:, 2], |
| ax.get_proj(), |
| ) |
| ) |
|
|
| |
| display_points = ax.transData.transform( |
| np.column_stack(( |
| projected_x, |
| projected_y, |
| )) |
| ) |
|
|
| mouse_position = np.array([ |
| event.x, |
| event.y, |
| ]) |
|
|
| distances = np.linalg.norm( |
| display_points - mouse_position, |
| axis=1, |
| ) |
|
|
| |
| idx = int(np.argmin(distances)) |
|
|
| |
| hover_radius = 12 |
|
|
| if distances[idx] > hover_radius: |
|
|
| if annot.get_visible(): |
| annot.set_visible(False) |
| hover_state["index"] = None |
| fig.canvas.draw_idle() |
|
|
| return |
|
|
| |
| if ( |
| hover_state["index"] == idx |
| and annot.get_visible() |
| ): |
| return |
|
|
| metadata = scatter_metadata[idx] |
|
|
| image_name = metadata["name"] |
| image_path = metadata["path"] |
| split_name = metadata["set"] |
| translation = metadata["translation"] |
|
|
| |
| annot.xy = ( |
| projected_x[idx], |
| projected_y[idx], |
| ) |
|
|
| annot.set_text( |
| f"Image: {image_name}\n" |
| f"Path: {image_path}\n" |
| f"Split: {split_name}\n" |
| f"X: {translation[0]:.2f} mm\n" |
| f"Y: {translation[1]:.2f} mm\n" |
| f"Z: {translation[2]:.2f} mm" |
| ) |
|
|
| annot.set_visible(True) |
| hover_state["index"] = idx |
|
|
| fig.canvas.draw_idle() |
|
|
| |
| fig.canvas.mpl_connect( |
| "motion_notify_event", |
| on_move, |
| ) |
|
|
| |
| |
| |
|
|
| if show_vectors: |
|
|
| ax.plot( |
| [], [], [], |
| color="r", |
| label="X Axis Rotation", |
| ) |
|
|
| ax.plot( |
| [], [], [], |
| color="g", |
| label="Y Axis Rotation", |
| ) |
|
|
| ax.plot( |
| [], [], [], |
| color="b", |
| label="Z Axis Rotation", |
| ) |
|
|
| |
| |
| |
|
|
| if cam_properties: |
|
|
| cmap = plt.get_cmap("viridis") |
| safe_viridis_values = [0.1, 0.88] |
|
|
| for idx, (cam_id, props) in enumerate( |
| cam_properties.items() |
| ): |
|
|
| K = np.asarray( |
| props["cam_K"] |
| ).reshape(3, 3) |
|
|
| R = np.asarray( |
| props.get("R", np.eye(3)) |
| ).reshape(3, 3) |
|
|
| t = np.asarray( |
| props.get("t", np.zeros(3)) |
| ) |
|
|
| min_depth = props.get("min_depth", 300.0) |
| max_depth = props.get("max_depth", 1000.0) |
|
|
| draw_max_depth = props.get( |
| "draw_max_depth", |
| max_depth, |
| ) |
|
|
| color_val = safe_viridis_values[ |
| idx % len(safe_viridis_values) |
| ] |
|
|
| cam_color = cmap(color_val) |
|
|
| pts = draw_working_frustum( |
| ax, |
| K, |
| R, |
| t, |
| min_depth, |
| max_depth, |
| draw_max_depth=draw_max_depth, |
| color=cam_color, |
| label=f"{cam_id} Frustum", |
| ) |
|
|
| all_x.extend(pts[:, 0]) |
| all_y.extend(pts[:, 1]) |
| all_z.extend(pts[:, 2]) |
|
|
| |
| |
| |
|
|
| if all_x: |
|
|
| ax.set_xlim(min(all_x), max(all_x)) |
| ax.set_ylim(min(all_y), max(all_y)) |
| ax.set_zlim(min(all_z), max(all_z)) |
|
|
| ax.set_xlabel("X Translation [mm]", labelpad=20) |
| ax.set_ylabel("Y Translation [mm]", labelpad=20) |
| ax.set_zlabel("Z Translation [mm]", labelpad=20) |
|
|
| ax.tick_params(axis="z", pad=10) |
|
|
| handles, labels = ax.get_legend_handles_labels() |
|
|
| handles = point_proxies + handles + sphere_proxies |
|
|
| ax.legend( |
| handles=handles, |
| loc="upper left", |
| bbox_to_anchor=(0.13, 0.78), |
| ncol=1, |
| ) |
|
|
| ax.view_init(elev=8, azim=-79) |
| ax.invert_zaxis() |
|
|
| plt.tight_layout() |
|
|
| |
| if out_dir: |
|
|
| out_path = ( |
| out_dir |
| / "translation_rotation_3d_train_vs_test_vectors.pdf" |
| ) |
|
|
| plt.savefig( |
| out_path, |
| bbox_inches="tight", |
| ) |
|
|
| print(f" Saved figure: {out_path}") |
|
|
| |
| plt.show(block=True) |
|
|
|
|
| def attach_image_metadata(pose_records, image_records, label=""): |
| """Attach image names and paths to pose records.""" |
|
|
| def normalize_stem(value): |
| stem = Path(str(value)).stem |
|
|
| |
| if stem.startswith("rgb_"): |
| stem = stem[4:] |
|
|
| |
| if stem.isdigit(): |
| stem = str(int(stem)) |
|
|
| return stem |
|
|
| image_lookup = {} |
|
|
| for record in image_records: |
| scene_id = str(record.get("scene_id", "")).strip() |
| filename = record.get("file_name", "") |
|
|
| |
| image_stem = normalize_stem( |
| filename if filename else record.get("image_id", "") |
| ) |
|
|
| key = (scene_id, image_stem) |
|
|
| |
| image_lookup.setdefault(key, []).append(record) |
|
|
| matched = 0 |
| unmatched = [] |
|
|
| for pose in pose_records: |
| scene_id = str(pose.get("scene_id", "")).strip() |
| pose_image_id = str(pose.get("image_id", "")) |
|
|
| image_stem = normalize_stem(pose_image_id) |
| key = (scene_id, image_stem) |
|
|
| candidates = image_lookup.get(key, []) |
|
|
| if len(candidates) == 1: |
| image_record = candidates[0] |
|
|
| pose["image_name"] = image_record.get( |
| "file_name", |
| pose_image_id, |
| ) |
| pose["image_path"] = image_record.get( |
| "_abs_path", |
| image_record.get("file_name", "Unknown"), |
| ) |
|
|
| matched += 1 |
|
|
| else: |
| pose["image_name"] = pose_image_id |
| pose["image_path"] = ( |
| "Not found" if not candidates else "Ambiguous match" |
| ) |
|
|
| if len(unmatched) < 10: |
| unmatched.append({ |
| "scene_id": scene_id, |
| "pose_image_id": pose_image_id, |
| "candidate_count": len(candidates), |
| }) |
|
|
| print( |
| f" Matched {label}pose records to images: " |
| f"{matched}/{len(pose_records)}" |
| ) |
|
|
| if unmatched: |
| print(f" Unmatched {label}pose examples:") |
| for item in unmatched: |
| print(f" {item}") |
|
|
| return pose_records |
|
|
| def main(): |
| import matplotlib.ticker |
|
|
| parser = argparse.ArgumentParser( |
| description="Generate I-BADAS dataset statistics figures.") |
| parser.add_argument("--root", type=str, default="/media/rtx5090/i-badas/test", |
| help="Path to the dataset root (containing scene folders)") |
| parser.add_argument("--train_root", type=str, default="/media/rtx5090/i-badas/train", |
| help="Optional path to the train split (train/ or train/real/). " |
| "If given, train-referenced deltas are added to the " |
| "variation CSV.") |
| parser.add_argument("--out", type=str, default="/media/rtx5090/i-badas/scripts/figures", |
| help="Output directory for figures") |
| args = parser.parse_args() |
|
|
| root = Path(args.root) |
| out_dir = Path(args.out) |
| out_dir.mkdir(parents=True, exist_ok=True) |
|
|
| print("=" * 60) |
| print("I-BADAS Dataset Statistics Generator") |
| print("=" * 60) |
|
|
| plt.rcParams.update({ |
| "font.family": "DejaVu Sans", |
| "axes.titlepad": 10, |
| "figure.dpi": 100, |
| "savefig.facecolor": "white", |
| }) |
|
|
| |
| print("\n[1/4] Loading annotations...") |
| scenes, global_cats = load_all_scenes(root) |
| records, ann_records = aggregate(scenes) |
| inject_abs_paths(records, scenes) |
| inject_segmentation(ann_records, scenes) |
| pose_records = load_poses(scenes) |
|
|
| print(f" Total images : {len(records)}") |
| print(f" Total annots : {len(ann_records)}") |
| print(f" Total poses : {len(pose_records)}") |
| print(f" Categories : {sorted(global_cats.keys())}") |
|
|
| print("\n[1/4] Loading train data (reference for train-referenced deltas)...") |
| train_records, train_pose_records = load_train_data(args.train_root) |
| have_train = bool(train_records) or bool(train_pose_records) |
|
|
| print("\n[1/4] Exporting Variation Metrics") |
| export_variation_csv(records, pose_records, out_dir, |
| train_records=train_records, |
| train_pose_records=train_pose_records, |
| ignore_sym=True, sym_axis='y') |
|
|
| print("\n[3/4] Generating figures...") |
| |
| fig_class_per_scene(records, out_dir) |
| fig_mask_area_violin(ann_records, out_dir) |
| fig_intensity_histogram_global(records, out_dir, |
| train_records=train_records if train_records else None) |
|
|
| test_int_stats = calc_intensity_statistics_global( |
| records, label="Test" if have_train else "Dataset") |
| if have_train and train_records: |
| print() |
| train_int_stats = calc_intensity_statistics_global(train_records, label="Train") |
| print_intensity_stat_deltas(test_int_stats, train_int_stats) |
|
|
| fig_pose_3d_with_frames(pose_records, out_dir, my_cameras) |
| |
|
|
| attach_image_metadata( |
| pose_records=pose_records, |
| image_records=records, |
| label="test ", |
| ) |
|
|
| attach_image_metadata( |
| pose_records=train_pose_records, |
| image_records=train_records, |
| label="train ", |
| ) |
|
|
| if have_train: |
| fig_pose_3d_train_vs_test(pose_records=pose_records, train_pose_records=train_pose_records, |
| task2_parity="both", out_dir=out_dir, cam_properties=my_cameras, |
| show_points=False, |
| show_vectors=True, |
| show_ellipsoids=True, |
| voxel_size=135) |
| |
| print("\n[Interactive] Generating 3D train/test pose visualization...") |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| test_6dof = print_6dof_stats(pose_records, label="Test" if have_train else None) |
| if have_train and train_pose_records: |
| train_6dof = print_6dof_stats(train_pose_records, label="Train") |
| print_6dof_stat_deltas(test_6dof, train_6dof) |
|
|
| fig_spatial_heatmap_ungrouped_common_legend(ann_records, out_dir) |
|
|
| calc_variability_metrics(records, pose_records, |
| label=" (Test)" if have_train else "", ignore_sym=True, sym_axis="y") |
| if have_train: |
| print() |
| calc_variability_metrics(train_records, train_pose_records, label=" (Train)", ignore_sym=True, sym_axis="y") |
| print_train_test_mean_deltas(records, pose_records, |
| train_records, train_pose_records, ignore_sym=True, sym_axis="y") |
|
|
| print("\n[4/4] Done.") |
| print(f" All figures written to: {out_dir.resolve()}") |
| print("=" * 60) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
