| """ |
| shard_utils.py — pack rendered pose directories into plain (stored) tar shards. |
| |
| Each shard `shard_{group:05d}.tar` holds a contiguous block of pose ids; in-tar layout is |
| `pose_{id:06d}/{modality}/{file}`. Tars are STORED (no compression) since PNG/NPZ are already |
| compressed. Per-shard sha256 + a `shards_index.csv` are emitted. |
| |
| Used by render_smal_multiview.py (--shard) to pack rendered output into tar shards. |
| """ |
| import os |
| import csv |
| import tarfile |
| import hashlib |
| from collections import defaultdict |
|
|
|
|
| def sha256_file(path, buf=1 << 20): |
| h = hashlib.sha256() |
| with open(path, "rb") as f: |
| for chunk in iter(lambda: f.read(buf), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def pack_to_shards(items, shard_dir, shard_size, modalities=("rgb", "seg", "npz"), |
| index_csv=None, log=print): |
| """ |
| items : iterable of (pose_id:int, src_pose_dir:str). Need not be sorted. |
| shard_dir : output directory for shard_*.tar (+ index_csv if given). |
| shard_size : number of pose ids per shard group (group = pose_id // shard_size). |
| modalities : subdirectories under each pose dir to include (others, e.g. overlays, are skipped). |
| Returns the list of index rows (dicts). |
| """ |
| os.makedirs(shard_dir, exist_ok=True) |
| groups = defaultdict(list) |
| for pid, src in items: |
| groups[pid // shard_size].append((int(pid), src)) |
|
|
| rows = [] |
| for g in sorted(groups): |
| members = sorted(groups[g], key=lambda x: x[0]) |
| shard_path = os.path.join(shard_dir, f"shard_{g:05d}.tar") |
| n_files = 0 |
| with tarfile.open(shard_path, "w") as tar: |
| for pid, src in members: |
| arc_pose = f"pose_{pid:06d}" |
| for mod in modalities: |
| md = os.path.join(src, mod) |
| if not os.path.isdir(md): |
| continue |
| for fn in sorted(os.listdir(md)): |
| tar.add(os.path.join(md, fn), arcname=f"{arc_pose}/{mod}/{fn}") |
| n_files += 1 |
| sz = os.path.getsize(shard_path) |
| sha = sha256_file(shard_path) |
| rows.append({"shard": os.path.basename(shard_path), |
| "pose_start": members[0][0], "pose_end": members[-1][0], |
| "num_poses": len(members), "num_files": n_files, |
| "bytes": sz, "sha256": sha}) |
| log(f"[shard] {os.path.basename(shard_path)} poses {members[0][0]}-{members[-1][0]} " |
| f"({len(members)}) {sz/1e9:.2f} GB {n_files} files") |
|
|
| if index_csv: |
| fields = ["shard", "pose_start", "pose_end", "num_poses", "num_files", "bytes", "sha256"] |
| existing = [] |
| if os.path.exists(index_csv): |
| with open(index_csv, newline="") as f: |
| existing = [r for r in csv.DictReader(f)] |
| by_shard = {r["shard"]: r for r in existing} |
| for r in rows: |
| by_shard[r["shard"]] = {k: str(r[k]) for k in fields} |
| with open(index_csv, "w", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=fields) |
| w.writeheader() |
| for s in sorted(by_shard): |
| w.writerow(by_shard[s]) |
| log(f"[shard] wrote index {index_csv} ({len(by_shard)} shards)") |
| return rows |
|
|
|
|
| def modalities_from_flags(save_rgb=True, save_mask=True, save_npz=True, |
| save_keypoints=False, save_depth=False, save_canny=False): |
| mods = [] |
| if save_rgb: mods.append("rgb") |
| if save_mask: mods.append("seg") |
| if save_npz: mods.append("npz") |
| if save_keypoints: mods.append("rgb_with_keypoints2d") |
| if save_depth: mods.append("depth") |
| if save_canny: mods.append("canny") |
| return tuple(mods) |
|
|
