Uniform label schema (missing fields as null) so the viewer infers one structure; pack.py normalizes

README.md

@@ -66,7 +66,7 @@ tools/export.py                                    导出为训练格式
 }
 ```
 
-`corners` 和 `bbox` 至少有一个，其余字段有就填，没有就省略。缺失的字段在训练时只是该项不计损失，不影响其他字段。
+`corners` 和 `bbox` 至少有一个，其余字段有就填，没有就省略或写 `null`。缺失的字段在训练时只是该项不计损失，不影响其他字段。`tools/pack.py` 打包时会把每个对象补全为同一组字段，缺失的写成 `null`。
 
 | 字段 | 取值 |
 |---|---|

data/qdu_damo/train/qdu_damo-train-00000.tar

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e70083ac857c77dcc41b417836acdc34d8c45e417d8f580000fbb150891ee7bb
-size 215244800
+oid sha256:52c94bec06c3eee80897bae5477f102317fe8655c569bc3296f8dc7864ab951d
+size 215388160

data/qdu_gimbal_0507/train/qdu_gimbal_0507-train-00000.tar

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:adeab0cf28812efd59ae9273a87570ee5651f4d48367e18b3b35cabfbdff40ba
-size 144240640
+oid sha256:5c699734af383a63bde07549aecf3b1f01ee83f7bd977b767756757d1f7414ce
+size 144414720

data/qdu_gimbal_0509/train/qdu_gimbal_0509-train-00000.tar

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:369a20dac37bc3fcce0514a332bf77b43c5816b0daf67e46e6fc4edfc699e1cc
-size 260864000
+oid sha256:3949562cea031db5d5da955a6c97fb8e890867976180d881ebb73d48c10d74f4
+size 261437440

tools/export.py

@@ -1,257 +1,259 @@
-"""Export rmcv/armor shards to YOLO pose, COCO keypoints or SJTU LabelRoboMaster txt.
-
-Usage:
-    python export.py <input> <output> [--format yolo-pose|coco|sjtu]
-                     [--classes sjtu|color|plate] [--order sjtu|tongji]
-                     [--split train,test] [--source a,b]
-
-<input> is a directory holding WebDataset .tar shards (searched recursively,
-split taken from the parent folder name) or loose <key>.jpg + <key>.json pairs.
-
-Class tables:
-    sjtu   36 classes, colour * 9 + tag (blue, red, gray, purple x
-           sentry, 1-5, outpost, base small, base large), as in LabelRoboMaster
-    color  0 blue, 1 red
-    plate  one class
-
-Regions that must not be trained as background (role "ignore", plates whose
-class cannot be decided under the chosen table, or corners not in LT, LB, RB, RT
-counter-clockwise order) are painted grey (114) for yolo-pose / sjtu and written
-as iscrowd=1 boxes for coco. Confirmed negatives are left as background.
-
-Requires numpy and Pillow.
-"""
-
-import argparse
-import io
-import json
-import tarfile
-from pathlib import Path
-
-import numpy as np
-from PIL import Image, ImageDraw
-
-COLORS = ["blue", "red", "gray", "purple"]
-SJTU_TAGS = ["sentry", "1", "2", "3", "4", "5", "outpost", "base_small", "base_large"]
-ORDERS = {
-    "sjtu": [0, 1, 2, 3],    # LT, LB, RB, RT
-    "tongji": [0, 3, 2, 1],  # TL, TR, BR, BL
-}
-MIRROR = [3, 2, 1, 0]  # horizontal flip: LT<->RT, LB<->RB
-GREY = (114, 114, 114)
-MASK_PAD = 0.15
-STICKERS = Path(__file__).resolve().parent.parent / "stickers.json"
-ATTR_KEYS = ["color", "size", "sticker", "flags", "corner_def", "label_type"]
-
-
-def order_ok(obj):
-    """LT, LB, RB, RT must run counter-clockwise in y-down image coords (negative signed area)."""
-    if "corners" not in obj:
-        return True
-    x, y = np.asarray(obj["corners"], float).T
-    return float(np.dot(x, np.roll(y, -1)) - np.dot(y, np.roll(x, -1))) < 0
-
-
-def class_id(obj, table):
-    if not order_ok(obj):
-        return None
-    if table == "plate":
-        return 0
-    color = obj.get("color")
-    if table == "color":
-        return {"blue": 0, "red": 1}.get(color)
-    tag = obj.get("sticker")
-    if tag == "base":
-        tag = {"small": "base_small", "large": "base_large"}.get(obj.get("size"))
-    if color not in COLORS or tag not in SJTU_TAGS:
-        return None
-    return COLORS.index(color) * 9 + SJTU_TAGS.index(tag)
-
-
-def class_names(table):
-    return {"plate": ["armor"], "color": ["blue", "red"]}.get(
-        table, [f"{c}_{t}" for c in COLORS for t in SJTU_TAGS])
-
-
-def iter_samples(root):
-    """Yield (split, key, jpg_bytes, label_dict)."""
-    root = Path(root)
-    for tar_path in sorted(root.rglob("*.tar")):
-        pending = {}
-        with tarfile.open(tar_path) as tar:
-            for member in tar:
-                if not member.isfile():
-                    continue
-                key, _, ext = member.name.rpartition(".")
-                parts = pending.setdefault(key, {})
-                parts[ext] = tar.extractfile(member).read()
-                if "jpg" in parts and "json" in parts:
-                    del pending[key]
-                    yield tar_path.parent.name, key, parts["jpg"], json.loads(parts["json"])
-    for json_path in sorted(root.rglob("*.json")):
-        jpg_path = json_path.with_suffix(".jpg")
-        if jpg_path.exists():
-            yield (json_path.parent.name, json_path.stem,
-                   jpg_path.read_bytes(), json.loads(json_path.read_text("utf-8")))
-
-
-def obj_box(obj):
-    if "bbox" in obj:
-        x, y, bw, bh = obj["bbox"]
-        return x, y, x + bw, y + bh
-    q = np.asarray(obj["corners"], float)
-    return (*q.min(0), *q.max(0))
-
-
-def clip_box(box, w, h):
-    x0, y0, x1, y1 = box
-    return (min(max(x0, 0), w - 1), min(max(y0, 0), h - 1),
-            min(max(x1, 0), w - 1), min(max(y1, 0), h - 1))
-
-
-def mask_box(obj, w, h):
-    x0, y0, x1, y1 = obj_box(obj)
-    px, py = (x1 - x0) * MASK_PAD, (y1 - y0) * MASK_PAD
-    return clip_box((x0 - px, y0 - py, x1 + px, y1 + py), w, h)
-
-
-def keypoints(obj, order, w, h):
-    """Clipped corners (4x2), visibility (4,) and clipped box. Box-only labels get invisible points."""
-    box = clip_box(obj_box(obj), w, h)
-    if "corners" not in obj:
-        return np.zeros((4, 2)), np.zeros(4, int), box
-    q = np.asarray(obj["corners"], float)[order]
-    inside = (q[:, 0] >= 0) & (q[:, 0] < w) & (q[:, 1] >= 0) & (q[:, 1] < h)
-    vis = np.where(inside, np.asarray(obj.get("visibility", [2, 2, 2, 2]), int)[order], 0)
-    return np.clip(q, 0, [w - 1, h - 1]), vis, box
-
-
-def yolo_pose_line(cls, obj, order, w, h):
-    pts, vis, (x0, y0, x1, y1) = keypoints(obj, order, w, h)
-    vals = [(x0 + x1) / 2 / w, (y0 + y1) / 2 / h, (x1 - x0) / w, (y1 - y0) / h]
-    for (x, y), v in zip(pts, vis):
-        vals += [x / w, y / h, int(v)]
-    return f"{cls} " + " ".join(f"{v:.6g}" for v in vals)
-
-
-def sjtu_line(cls, obj, w, h):
-    q = np.asarray(obj["corners"], float) / [w, h]
-    return f"{cls} " + " ".join(f"{v:.6g}" for v in q.ravel())
-
-
-def coco_ann(ann_id, img_id, cls, obj, order, w, h, ref_ids):
-    if cls is None:
-        x0, y0, x1, y1 = mask_box(obj, w, h)
-        kps, nk = [0] * 12, 0
-    else:
-        pts, vis, (x0, y0, x1, y1) = keypoints(obj, order, w, h)
-        kps = [v for (x, y), s in zip(pts, vis) for v in (round(float(x), 2), round(float(y), 2), int(s))]
-        nk = int((vis > 0).sum())
-    fields = {k: obj[k] for k in ATTR_KEYS if k in obj}
-    side = {"red": 0, "blue": 100}.get(obj.get("color"))
-    if side is not None and obj.get("sticker") in ref_ids:
-        fields["ref_id"] = ref_ids[obj["sticker"]] + side
-    bw, bh = float(x1 - x0), float(y1 - y0)
-    return {
-        "id": ann_id, "image_id": img_id, "category_id": 1 if cls is None else cls + 1,
-        "iscrowd": int(cls is None), "num_keypoints": nk, "keypoints": kps,
-        "bbox": [round(float(x0), 2), round(float(y0), 2), round(bw, 2), round(bh, 2)],
-        "area": round(bw * bh, 2), "attributes": fields,
-    }
-
-
-def main():
-    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    ap.add_argument("input")
-    ap.add_argument("output")
-    ap.add_argument("--format", choices=["yolo-pose", "coco", "sjtu"], default="yolo-pose")
-    ap.add_argument("--classes", choices=["sjtu", "color", "plate"], default="sjtu")
-    ap.add_argument("--order", choices=list(ORDERS), default="sjtu",
-                    help="keypoint order for yolo-pose / coco (sjtu txt is always LT,LB,RB,RT)")
-    ap.add_argument("--split", default="", help="comma list, e.g. train,test (default all)")
-    ap.add_argument("--source", default="", help="comma list of sources (default all)")
-    ap.add_argument("--quality", type=int, default=95, help="JPEG quality for masked images")
-    args = ap.parse_args()
-
-    splits = set(filter(None, args.split.split(",")))
-    sources = set(filter(None, args.source.split(",")))
-    order = ORDERS[args.order]
-    ref_ids = {s["id"]: s["ref_id"] for s in json.loads(STICKERS.read_text("utf-8"))["stickers"]}
-    out = Path(args.output)
-    stats = {"images": 0, "labels": 0, "masked": 0}
-    seen_splits = set()
-    coco = {}
-    ann_id = 0
-
-    for split, key, jpg, label in iter_samples(args.input):
-        source = label["image"].get("source", "nosource")
-        if (splits and split not in splits) or (sources and source not in sources):
-            continue
-        w, h = label["image"]["width"], label["image"]["height"]
-        name = f"{source}__{key.replace('/', '__')}"
-        img_dir = out / "images" / split
-        img_dir.mkdir(parents=True, exist_ok=True)
-        seen_splits.add(split)
-        stats["images"] += 1
-
-        objs = [o for o in label.get("objects", []) if o.get("role", "positive") != "negative"]
-        classes = [class_id(o, args.classes) if o.get("role", "positive") == "positive" else None
-                   for o in objs]
-
-        if args.format == "coco":
-            ds = coco.setdefault(split, {"images": [], "annotations": []})
-            img_id = len(ds["images"]) + 1
-            ds["images"].append({**label["image"], "id": img_id, "file_name": f"{split}/{name}.jpg"})
-            for obj, cls in zip(objs, classes):
-                ann_id += 1
-                ds["annotations"].append(coco_ann(ann_id, img_id, cls, obj, order, w, h, ref_ids))
-                stats["labels" if cls is not None else "masked"] += 1
-            (img_dir / f"{name}.jpg").write_bytes(jpg)
-            continue
-
-        lines, masks = [], []
-        for obj, cls in zip(objs, classes):
-            if cls is None or (args.format == "sjtu" and "corners" not in obj):
-                masks.append(mask_box(obj, w, h))
-            elif args.format == "yolo-pose":
-                lines.append(yolo_pose_line(cls, obj, order, w, h))
-            else:
-                lines.append(sjtu_line(cls, obj, w, h))
-        if masks:
-            im = Image.open(io.BytesIO(jpg)).convert("RGB")
-            draw = ImageDraw.Draw(im)
-            for box in masks:
-                draw.rectangle(box, fill=GREY)
-            im.save(img_dir / f"{name}.jpg", quality=args.quality)
-        else:
-            (img_dir / f"{name}.jpg").write_bytes(jpg)
-        lbl_dir = out / "labels" / split
-        lbl_dir.mkdir(parents=True, exist_ok=True)
-        (lbl_dir / f"{name}.txt").write_text("".join(l + "\n" for l in lines))
-        stats["labels"] += len(lines)
-        stats["masked"] += len(masks)
-
-    names = class_names(args.classes)
-    flip = [order.index(MIRROR[order[j]]) for j in range(4)]
-    if args.format == "coco":
-        kp_names = [["LT", "LB", "RB", "RT"][i] for i in order]
-        categories = [{"id": i + 1, "name": n, "keypoints": kp_names,
-                       "skeleton": [[1, 2], [2, 3], [3, 4], [4, 1]]} for i, n in enumerate(names)]
-        (out / "annotations").mkdir(parents=True, exist_ok=True)
-        for split, ds in coco.items():
-            ds["categories"] = categories
-            ds["info"] = {"description": "rmcv/armor", "flip_idx": flip}
-            (out / "annotations" / f"{split}.json").write_text(json.dumps(ds, ensure_ascii=False), "utf-8")
-    elif args.format == "yolo-pose":
-        yaml = [f"path: {out.resolve().as_posix()}"]
-        yaml += [f"{'val' if s == 'test' else s}: images/{s}" for s in sorted(seen_splits)]
-        yaml += ["kpt_shape: [4, 3]", f"flip_idx: {flip}",
-                 "# Horizontal flips mirror the digit; train with fliplr: 0.", "names:"]
-        yaml += [f"  {i}: {n}" for i, n in enumerate(names)]
-        (out / "data.yaml").write_text("\n".join(yaml) + "\n")
-
-    print(json.dumps(stats))
-
-
-if __name__ == "__main__":
-    main()
+"""Export rmcv/armor shards to YOLO pose, COCO keypoints or SJTU LabelRoboMaster txt.
+
+Usage:
+    python export.py <input> <output> [--format yolo-pose|coco|sjtu]
+                     [--classes sjtu|color|plate] [--order sjtu|tongji]
+                     [--split train,test] [--source a,b]
+
+<input> is a directory holding WebDataset .tar shards (searched recursively,
+split taken from the parent folder name) or loose <key>.jpg + <key>.json pairs.
+
+Class tables:
+    sjtu   36 classes, colour * 9 + tag (blue, red, gray, purple x
+           sentry, 1-5, outpost, base small, base large), as in LabelRoboMaster
+    color  0 blue, 1 red
+    plate  one class
+
+Regions that must not be trained as background (role "ignore", plates whose
+class cannot be decided under the chosen table, or corners not in LT, LB, RB, RT
+counter-clockwise order) are painted grey (114) for yolo-pose / sjtu and written
+as iscrowd=1 boxes for coco. Confirmed negatives are left as background.
+
+Requires numpy and Pillow.
+"""
+
+import argparse
+import io
+import json
+import tarfile
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+COLORS = ["blue", "red", "gray", "purple"]
+SJTU_TAGS = ["sentry", "1", "2", "3", "4", "5", "outpost", "base_small", "base_large"]
+ORDERS = {
+    "sjtu": [0, 1, 2, 3],    # LT, LB, RB, RT
+    "tongji": [0, 3, 2, 1],  # TL, TR, BR, BL
+}
+MIRROR = [3, 2, 1, 0]  # horizontal flip: LT<->RT, LB<->RB
+GREY = (114, 114, 114)
+MASK_PAD = 0.15
+STICKERS = Path(__file__).resolve().parent.parent / "stickers.json"
+ATTR_KEYS = ["color", "size", "sticker", "flags", "corner_def", "label_type"]
+
+
+def order_ok(obj):
+    """LT, LB, RB, RT must run counter-clockwise in y-down image coords (negative signed area)."""
+    if "corners" not in obj:
+        return True
+    x, y = np.asarray(obj["corners"], float).T
+    return float(np.dot(x, np.roll(y, -1)) - np.dot(y, np.roll(x, -1))) < 0
+
+
+def class_id(obj, table):
+    if not order_ok(obj):
+        return None
+    if table == "plate":
+        return 0
+    color = obj.get("color")
+    if table == "color":
+        return {"blue": 0, "red": 1}.get(color)
+    tag = obj.get("sticker")
+    if tag == "base":
+        tag = {"small": "base_small", "large": "base_large"}.get(obj.get("size"))
+    if color not in COLORS or tag not in SJTU_TAGS:
+        return None
+    return COLORS.index(color) * 9 + SJTU_TAGS.index(tag)
+
+
+def class_names(table):
+    return {"plate": ["armor"], "color": ["blue", "red"]}.get(
+        table, [f"{c}_{t}" for c in COLORS for t in SJTU_TAGS])
+
+
+def iter_samples(root):
+    """Yield (split, key, jpg_bytes, label_dict)."""
+    root = Path(root)
+    for tar_path in sorted(root.rglob("*.tar")):
+        pending = {}
+        with tarfile.open(tar_path) as tar:
+            for member in tar:
+                if not member.isfile():
+                    continue
+                key, _, ext = member.name.rpartition(".")
+                parts = pending.setdefault(key, {})
+                parts[ext] = tar.extractfile(member).read()
+                if "jpg" in parts and "json" in parts:
+                    del pending[key]
+                    yield tar_path.parent.name, key, parts["jpg"], json.loads(parts["json"])
+    for json_path in sorted(root.rglob("*.json")):
+        jpg_path = json_path.with_suffix(".jpg")
+        if jpg_path.exists():
+            yield (json_path.parent.name, json_path.stem,
+                   jpg_path.read_bytes(), json.loads(json_path.read_text("utf-8")))
+
+
+def obj_box(obj):
+    if "bbox" in obj:
+        x, y, bw, bh = obj["bbox"]
+        return x, y, x + bw, y + bh
+    q = np.asarray(obj["corners"], float)
+    return (*q.min(0), *q.max(0))
+
+
+def clip_box(box, w, h):
+    x0, y0, x1, y1 = box
+    return (min(max(x0, 0), w - 1), min(max(y0, 0), h - 1),
+            min(max(x1, 0), w - 1), min(max(y1, 0), h - 1))
+
+
+def mask_box(obj, w, h):
+    x0, y0, x1, y1 = obj_box(obj)
+    px, py = (x1 - x0) * MASK_PAD, (y1 - y0) * MASK_PAD
+    return clip_box((x0 - px, y0 - py, x1 + px, y1 + py), w, h)
+
+
+def keypoints(obj, order, w, h):
+    """Clipped corners (4x2), visibility (4,) and clipped box. Box-only labels get invisible points."""
+    box = clip_box(obj_box(obj), w, h)
+    if "corners" not in obj:
+        return np.zeros((4, 2)), np.zeros(4, int), box
+    q = np.asarray(obj["corners"], float)[order]
+    inside = (q[:, 0] >= 0) & (q[:, 0] < w) & (q[:, 1] >= 0) & (q[:, 1] < h)
+    vis = np.where(inside, np.asarray(obj.get("visibility", [2, 2, 2, 2]), int)[order], 0)
+    return np.clip(q, 0, [w - 1, h - 1]), vis, box
+
+
+def yolo_pose_line(cls, obj, order, w, h):
+    pts, vis, (x0, y0, x1, y1) = keypoints(obj, order, w, h)
+    vals = [(x0 + x1) / 2 / w, (y0 + y1) / 2 / h, (x1 - x0) / w, (y1 - y0) / h]
+    for (x, y), v in zip(pts, vis):
+        vals += [x / w, y / h, int(v)]
+    return f"{cls} " + " ".join(f"{v:.6g}" for v in vals)
+
+
+def sjtu_line(cls, obj, w, h):
+    q = np.asarray(obj["corners"], float) / [w, h]
+    return f"{cls} " + " ".join(f"{v:.6g}" for v in q.ravel())
+
+
+def coco_ann(ann_id, img_id, cls, obj, order, w, h, ref_ids):
+    if cls is None:
+        x0, y0, x1, y1 = mask_box(obj, w, h)
+        kps, nk = [0] * 12, 0
+    else:
+        pts, vis, (x0, y0, x1, y1) = keypoints(obj, order, w, h)
+        kps = [v for (x, y), s in zip(pts, vis) for v in (round(float(x), 2), round(float(y), 2), int(s))]
+        nk = int((vis > 0).sum())
+    fields = {k: obj[k] for k in ATTR_KEYS if k in obj}
+    side = {"red": 0, "blue": 100}.get(obj.get("color"))
+    if side is not None and obj.get("sticker") in ref_ids:
+        fields["ref_id"] = ref_ids[obj["sticker"]] + side
+    bw, bh = float(x1 - x0), float(y1 - y0)
+    return {
+        "id": ann_id, "image_id": img_id, "category_id": 1 if cls is None else cls + 1,
+        "iscrowd": int(cls is None), "num_keypoints": nk, "keypoints": kps,
+        "bbox": [round(float(x0), 2), round(float(y0), 2), round(bw, 2), round(bh, 2)],
+        "area": round(bw * bh, 2), "attributes": fields,
+    }
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("input")
+    ap.add_argument("output")
+    ap.add_argument("--format", choices=["yolo-pose", "coco", "sjtu"], default="yolo-pose")
+    ap.add_argument("--classes", choices=["sjtu", "color", "plate"], default="sjtu")
+    ap.add_argument("--order", choices=list(ORDERS), default="sjtu",
+                    help="keypoint order for yolo-pose / coco (sjtu txt is always LT,LB,RB,RT)")
+    ap.add_argument("--split", default="", help="comma list, e.g. train,test (default all)")
+    ap.add_argument("--source", default="", help="comma list of sources (default all)")
+    ap.add_argument("--quality", type=int, default=95, help="JPEG quality for masked images")
+    args = ap.parse_args()
+
+    splits = set(filter(None, args.split.split(",")))
+    sources = set(filter(None, args.source.split(",")))
+    order = ORDERS[args.order]
+    ref_ids = {s["id"]: s["ref_id"] for s in json.loads(STICKERS.read_text("utf-8"))["stickers"]}
+    out = Path(args.output)
+    stats = {"images": 0, "labels": 0, "masked": 0}
+    seen_splits = set()
+    coco = {}
+    ann_id = 0
+
+    for split, key, jpg, label in iter_samples(args.input):
+        source = label["image"].get("source") or "nosource"
+        if (splits and split not in splits) or (sources and source not in sources):
+            continue
+        w, h = label["image"]["width"], label["image"]["height"]
+        name = f"{source}__{key.replace('/', '__')}"
+        img_dir = out / "images" / split
+        img_dir.mkdir(parents=True, exist_ok=True)
+        seen_splits.add(split)
+        stats["images"] += 1
+
+        # null means "not labelled": drop those keys so presence checks below stay simple
+        objs = [{k: v for k, v in o.items() if v is not None} for o in label.get("objects", [])]
+        objs = [o for o in objs if o.get("role", "positive") != "negative"]
+        classes = [class_id(o, args.classes) if o.get("role", "positive") == "positive" else None
+                   for o in objs]
+
+        if args.format == "coco":
+            ds = coco.setdefault(split, {"images": [], "annotations": []})
+            img_id = len(ds["images"]) + 1
+            ds["images"].append({**label["image"], "id": img_id, "file_name": f"{split}/{name}.jpg"})
+            for obj, cls in zip(objs, classes):
+                ann_id += 1
+                ds["annotations"].append(coco_ann(ann_id, img_id, cls, obj, order, w, h, ref_ids))
+                stats["labels" if cls is not None else "masked"] += 1
+            (img_dir / f"{name}.jpg").write_bytes(jpg)
+            continue
+
+        lines, masks = [], []
+        for obj, cls in zip(objs, classes):
+            if cls is None or (args.format == "sjtu" and "corners" not in obj):
+                masks.append(mask_box(obj, w, h))
+            elif args.format == "yolo-pose":
+                lines.append(yolo_pose_line(cls, obj, order, w, h))
+            else:
+                lines.append(sjtu_line(cls, obj, w, h))
+        if masks:
+            im = Image.open(io.BytesIO(jpg)).convert("RGB")
+            draw = ImageDraw.Draw(im)
+            for box in masks:
+                draw.rectangle(box, fill=GREY)
+            im.save(img_dir / f"{name}.jpg", quality=args.quality)
+        else:
+            (img_dir / f"{name}.jpg").write_bytes(jpg)
+        lbl_dir = out / "labels" / split
+        lbl_dir.mkdir(parents=True, exist_ok=True)
+        (lbl_dir / f"{name}.txt").write_text("".join(l + "\n" for l in lines))
+        stats["labels"] += len(lines)
+        stats["masked"] += len(masks)
+
+    names = class_names(args.classes)
+    flip = [order.index(MIRROR[order[j]]) for j in range(4)]
+    if args.format == "coco":
+        kp_names = [["LT", "LB", "RB", "RT"][i] for i in order]
+        categories = [{"id": i + 1, "name": n, "keypoints": kp_names,
+                       "skeleton": [[1, 2], [2, 3], [3, 4], [4, 1]]} for i, n in enumerate(names)]
+        (out / "annotations").mkdir(parents=True, exist_ok=True)
+        for split, ds in coco.items():
+            ds["categories"] = categories
+            ds["info"] = {"description": "rmcv/armor", "flip_idx": flip}
+            (out / "annotations" / f"{split}.json").write_text(json.dumps(ds, ensure_ascii=False), "utf-8")
+    elif args.format == "yolo-pose":
+        yaml = [f"path: {out.resolve().as_posix()}"]
+        yaml += [f"{'val' if s == 'test' else s}: images/{s}" for s in sorted(seen_splits)]
+        yaml += ["kpt_shape: [4, 3]", f"flip_idx: {flip}",
+                 "# Horizontal flips mirror the digit; train with fliplr: 0.", "names:"]
+        yaml += [f"  {i}: {n}" for i, n in enumerate(names)]
+        (out / "data.yaml").write_text("\n".join(yaml) + "\n")
+
+    print(json.dumps(stats))
+
+
+if __name__ == "__main__":
+    main()

tools/pack.py

@@ -1,122 +1,136 @@
-"""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
-
-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", {})
-    try:
-        w, h = Image.open(io.BytesIO(jpg)).size
-    except Exception as e:  # unreadable image
-        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 "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 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(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()
+"""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:  # unreadable image
+        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()