File size: 6,574 Bytes
a3ae635 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | """Shared helpers for the published RHD shared-v1.0 tools."""
from pathlib import Path
import codecs, collections, hashlib, io, json, pickle, subprocess
import imageio_ffmpeg
import numpy as np
import torch
SCRIPT_DIR = Path(__file__).resolve().parent
RELEASE_ROOT = SCRIPT_DIR.parent
DATASET_ROOT = RELEASE_ROOT.parent
RAW_ROOT = DATASET_ROOT / "raw" / "data"
TMP_ROOT = DATASET_ROOT / "tmp" / "rhd-tools"
FFMPEG = imageio_ffmpeg.get_ffmpeg_exe()
FF = FFMPEG
def load(path):
return json.loads(Path(path).read_text(encoding="utf-8"))
def save(path, value):
path = Path(path); path.parent.mkdir(parents=True, exist_ok=True)
tmp = path.with_suffix(path.suffix + ".tmp")
tmp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False), encoding="utf-8")
tmp.replace(path)
def write_jsonl(path, rows):
path = Path(path); path.parent.mkdir(parents=True, exist_ok=True)
path.write_text("".join(json.dumps(x, ensure_ascii=False, allow_nan=False) + "\n" for x in rows), encoding="utf-8")
def save_tensor(path, value):
path = Path(path); path.parent.mkdir(parents=True, exist_ok=True)
torch.save(torch.as_tensor(np.asarray(value).copy()), path)
lines = write_jsonl
tensor = save_tensor
def ffmpeg(args, data=None):
result = subprocess.run([FFMPEG, "-v", "error", "-y", *map(str, args)], input=data, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if result.returncode:
raise RuntimeError(result.stderr.decode(errors="replace"))
return result.stdout
def storage(profile, codec, pixel_format, size, source_lossy, parameters):
version = ffmpeg(["-version"]).decode().splitlines()[0]
return {"profile": profile, "codec": codec, "pixel_format": pixel_format,
"encoded_size": size, "source_lossy": source_lossy,
"decoder": version, "encoder_parameters": parameters}
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
allowed = {
("numpy.core.multiarray", "_reconstruct"): np.core.multiarray._reconstruct,
("numpy._core.multiarray", "_reconstruct"): np.core.multiarray._reconstruct,
("numpy", "ndarray"): np.ndarray, ("numpy", "dtype"): np.dtype,
("numpy.core.numeric", "_frombuffer"): np.core.numeric._frombuffer,
("numpy._core.numeric", "_frombuffer"): np.core.numeric._frombuffer,
("_codecs", "encode"): codecs.encode,
("collections", "OrderedDict"): collections.OrderedDict,
}
if (module, name) not in allowed:
raise pickle.UnpicklingError(f"Unsupported class: {module}.{name}")
return allowed[(module, name)]
Restricted = RestrictedUnpickler
class View:
def __init__(self, dataset, sequence, camera, frame_ids, size, source, kind="image", split="unknown"):
assert dataset == "RHD" and camera == "camera" and kind == "image"
self.root = RELEASE_ROOT
self.path = RELEASE_ROOT / "data" / sequence / camera
self.path.mkdir(parents=True, exist_ok=True)
self.count = len(frame_ids)
archive = Path(source["archive"]).name
self.source = dict(source)
self.checks = []
self.meta = {
"schema_version": "hand-warehouse/1.0", "dataset_id": "RHD",
"release_id": "shared-v1.0", "sequence_id": sequence, "camera_id": "camera",
"sample_type": "image", "num_frames": self.count,
"hand_slots": ["left", "right"], "split": split,
"split_scheme": "RHD_official_training_evaluation",
"split_source_locator": {"archive": "raw/data/" + archive, "member_prefix": split + "/"},
"sampling": {"type": "independent", "source_fps": None, "frames_ref": "camera/frames.jsonl",
"shard_max_images": 512,
"selection": "all source independent images sorted by source ID"},
"camera": {"model": "unknown", "schema_id": None, "image_size": size},
"components": {}, "storage_revision": "lossless-video-2026-09-18"}
self.frames = [{"frame_index": i, "source_frame_id": str(fid), "timestamp_ns": None,
"clock_domain": None, "source_locator": {**self.source, "source_frame_id": str(fid)}}
for i, fid in enumerate(frame_ids)]
@property
def p(self): return self.path
@property
def T(self): return self.count
@property
def m(self): return self.meta
def add(self, name, ref, schema, axes, valid, method="source values retained", **metadata):
valid_ref = Path(ref).with_name(Path(ref).stem + "_valid.pt").as_posix()
save_tensor(self.path / valid_ref, valid)
self.meta["components"][name] = {
"available": True, "schema_id": schema, "data_ref": ref, "axes": axes,
"valid_ref": valid_ref, "valid_axes": axes[:np.asarray(valid).ndim],
"provenance": {"kind": "format_conversion", "method": method},
"source_locator": dict(self.source), **metadata}
def array(self, name, ref, schema, value, valid, axes, **metadata):
value = np.asarray(value, np.float32).copy(); valid = np.asarray(valid, bool)
assert value.shape[:valid.ndim] == valid.shape and value.shape[0] == self.count
assert np.isfinite(value[valid]).all()
value[~valid] = np.nan; save_tensor(self.path / ref, value)
self.add(name, ref, schema, axes, valid, **metadata)
restored = torch.load(self.path / ref, map_location="cpu", weights_only=True).numpy()
assert np.array_equal(restored, value, equal_nan=True)
self.checks.append({"test": "tensor_serialization_exact", "file": ref,
"shape": list(value.shape), "valid_count": int(valid.sum())})
def intrinsic(self, value):
self.meta["camera"].update(model="pinhole", schema_id="camera/pinhole/v1")
self.array("intrinsic", "camera/intrinsic.pt", "camera/pinhole/v1", value,
np.ones(self.count, bool), ["T", "row", "column"])
def finish(self):
write_jsonl(self.path / "camera/frames.jsonl", self.frames)
save(self.path / "metainfo.json", self.meta)
save(TMP_ROOT / "checks" / f'{self.meta["sequence_id"]}__camera.checks.json',
{"checks": self.checks, "frames": self.count, "input": self.source})
def sha256(path):
h = hashlib.sha256()
with Path(path).open("rb") as stream:
for block in iter(lambda: stream.read(8 << 20), b""): h.update(block)
return h.hexdigest()
|