| """Check rmcv/armor labels and pack <key>.jpg + <key>.json pairs into WebDataset tar shards.
|
|
|
| Usage:
|
| python pack.py <input_dir> <dataset_root> --source <source> --split train|test [--shard-mb 1024]
|
|
|
| Writes <dataset_root>/data/<source>/<split>/<source>-<split>-00000.tar ... and prints a
|
| summary. Every label is checked first; nothing is written if any label fails.
|
|
|
| Requires Pillow.
|
| """
|
|
|
| import argparse
|
| import io
|
| import json
|
| import re
|
| import sys
|
| import tarfile
|
| from pathlib import Path
|
|
|
| from PIL import Image
|
|
|
| IMAGE_KEYS = ["width", "height", "source", "sequence", "frame", "camera"]
|
| OBJECT_KEYS = ["corners", "bbox", "color", "size", "sticker", "visibility", "flags",
|
| "corner_def", "label_type", "role"]
|
| ENUMS = {
|
| "color": {"blue", "red", "gray", "purple"},
|
| "size": {"small", "large"},
|
| "corner_def": {"sjtu4", "unspecified"},
|
| "label_type": {"human", "human_checked", "model"},
|
| "role": {"positive", "ignore", "negative"},
|
| }
|
| FLAGS = {"truncated", "occluded", "motion_blur", "overexposed", "unlit"}
|
| STICKERS = Path(__file__).resolve().parent.parent / "stickers.json"
|
|
|
|
|
| def check(label, jpg, stickers):
|
| """Return a list of problems for one image."""
|
| errors = []
|
| image = label.get("image", {})
|
| if set(image) - set(IMAGE_KEYS):
|
| errors.append(f"image: unknown keys {sorted(set(image) - set(IMAGE_KEYS))}")
|
| try:
|
| w, h = Image.open(io.BytesIO(jpg)).size
|
| except Exception as e:
|
| return [f"image: {e}"]
|
| if (image.get("width"), image.get("height")) != (w, h):
|
| errors.append(f"image size {image.get('width')}x{image.get('height')} != jpg {w}x{h}")
|
| for i, obj in enumerate(label.get("objects", [])):
|
| where = f"objects[{i}]"
|
| if set(obj) - set(OBJECT_KEYS):
|
| errors.append(f"{where}: unknown keys {sorted(set(obj) - set(OBJECT_KEYS))}")
|
| obj = {k: v for k, v in obj.items() if v is not None}
|
| if "corners" not in obj and "bbox" not in obj:
|
| errors.append(f"{where}: needs corners or bbox")
|
| if "corners" in obj:
|
| q = obj["corners"]
|
| if len(q) != 4 or any(len(p) != 2 for p in q):
|
| errors.append(f"{where}: corners must be 4 [x, y] points")
|
| else:
|
| area = sum(q[k][0] * q[(k + 1) % 4][1] - q[k][1] * q[(k + 1) % 4][0] for k in range(4))
|
| if area >= 0:
|
| errors.append(f"{where}: corners not LT, LB, RB, RT counter-clockwise")
|
| if "bbox" in obj and (len(obj["bbox"]) != 4 or obj["bbox"][2] <= 0 or obj["bbox"][3] <= 0):
|
| errors.append(f"{where}: bbox must be [x, y, w, h] with w, h > 0")
|
| for key, allowed in ENUMS.items():
|
| if key in obj and obj[key] not in allowed:
|
| errors.append(f"{where}: {key}={obj[key]!r}")
|
| if "sticker" in obj and obj["sticker"] not in stickers:
|
| errors.append(f"{where}: sticker={obj['sticker']!r} not in stickers.json")
|
| if "visibility" in obj and (len(obj["visibility"]) != 4 or set(obj["visibility"]) - {0, 1, 2}):
|
| errors.append(f"{where}: visibility must be 4 values of 0/1/2")
|
| if set(obj.get("flags", [])) - FLAGS:
|
| errors.append(f"{where}: unknown flags {sorted(set(obj['flags']) - FLAGS)}")
|
| return errors
|
|
|
|
|
| def normalize(label):
|
| """Write every image / object with the same keys (missing -> null) so readers see one schema."""
|
| return {"image": {k: label["image"].get(k) for k in IMAGE_KEYS},
|
| "objects": [{k: o.get(k) for k in OBJECT_KEYS} for o in label.get("objects", [])]}
|
|
|
|
|
| def main():
|
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
| ap.add_argument("input_dir")
|
| ap.add_argument("dataset_root")
|
| ap.add_argument("--source", required=True)
|
| ap.add_argument("--split", required=True, choices=["train", "test"])
|
| ap.add_argument("--shard-mb", type=int, default=1024)
|
| args = ap.parse_args()
|
|
|
| if not re.fullmatch(r"[a-z0-9_]+", args.source):
|
| sys.exit("source must use lowercase letters, digits and underscores")
|
| stickers = {s["id"] for s in json.loads(STICKERS.read_text("utf-8"))["stickers"]}
|
|
|
| pairs, problems = [], []
|
| for json_path in sorted(Path(args.input_dir).rglob("*.json")):
|
| jpg_path = json_path.with_suffix(".jpg")
|
| if not jpg_path.exists():
|
| continue
|
| label = json.loads(json_path.read_text("utf-8"))
|
| label.setdefault("image", {})["source"] = args.source
|
| jpg = jpg_path.read_bytes()
|
| problems += [f"{json_path.name}: {e}" for e in check(label, jpg, stickers)]
|
| pairs.append((json_path.stem, jpg, label))
|
| if problems:
|
| print("\n".join(problems[:50]))
|
| sys.exit(f"{len(problems)} problems, nothing written")
|
| if not pairs:
|
| sys.exit("no <key>.jpg + <key>.json pairs found")
|
|
|
| out_dir = Path(args.dataset_root) / "data" / args.source / args.split
|
| out_dir.mkdir(parents=True, exist_ok=True)
|
| limit = args.shard_mb * 1024 * 1024
|
| shard, size, tar, counts = 0, 0, None, {"images": 0, "objects": 0, "shards": 0}
|
| for key, jpg, label in pairs:
|
| data = json.dumps(normalize(label), ensure_ascii=False).encode("utf-8")
|
| if tar is None or size + len(jpg) + len(data) > limit:
|
| if tar:
|
| tar.close()
|
| tar = tarfile.open(out_dir / f"{args.source}-{args.split}-{shard:05d}.tar", "w")
|
| shard, size = shard + 1, 0
|
| counts["shards"] += 1
|
| for ext, payload in (("jpg", jpg), ("json", data)):
|
| info = tarfile.TarInfo(f"{key}.{ext}")
|
| info.size = len(payload)
|
| tar.addfile(info, io.BytesIO(payload))
|
| size += len(jpg) + len(data) + 2048
|
| counts["images"] += 1
|
| counts["objects"] += len(label.get("objects", []))
|
| tar.close()
|
| print(json.dumps({"out": str(out_dir), **counts}))
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
