tools/export.py

"""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()