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