| """Small v1.1 reader; no model, GPU, raw data, or media decoding required.""" |
| import json |
| from pathlib import Path, PurePosixPath |
|
|
| import torch |
|
|
| PROFILE = "pt/tensor_bundle/v1" |
| LAYOUT = { |
| "intrinsic": ("camera/camera.pt", "intrinsic"), |
| "keypoints_xyz": ("annotation/keypoints/keypoints.pt", "xyz"), |
| "mano": ("annotation/mano/mano.pt", "motion"), |
| } |
|
|
|
|
| def safe_path(root, reference): |
| """Resolve a canonical, view-relative POSIX reference without traversal.""" |
| if not isinstance(reference, str) or not reference or any(x in reference for x in ("\\", ":", "<", ">")): |
| raise ValueError(f"Invalid relative reference: {reference!r}") |
| path = PurePosixPath(reference) |
| if path.is_absolute() or ".." in path.parts or path.as_posix() != reference or reference == ".": |
| raise ValueError(f"Reference must stay inside view: {reference}") |
| result = Path(root).joinpath(*path.parts) |
| if not result.resolve().is_relative_to(Path(root).resolve()): |
| raise ValueError(f"Reference escapes its input tree: {reference}") |
| return result |
|
|
|
|
| def exact_tensor(a, b): |
| """Compare dtype, shape and contiguous bytes, including NaN payload bits.""" |
| return (a.dtype == b.dtype and a.shape == b.shape and |
| torch.equal(a.contiguous().view(torch.uint8), b.contiguous().view(torch.uint8))) |
|
|
|
|
| class ViewReader: |
| def __init__(self, view): |
| self.view = Path(view) |
| self.meta = json.loads((self.view / "metainfo.json").read_text()) |
| if self.meta["schema_version"] != "hand-warehouse/1.1": |
| raise ValueError("ViewReader expects a v1.1 view") |
| self.cache = {} |
|
|
| def tensor(self, reference, keys=None): |
| path = safe_path(self.view, reference) |
| if keys is not None and (not isinstance(keys, list) or not keys or |
| any(not isinstance(k, str) or not k for k in keys)): |
| raise ValueError("Dictionary keys must be a nonempty list of nonempty strings") |
| if reference not in self.cache: |
| self.cache[reference] = torch.load(path, map_location="cpu", weights_only=True) |
| value = self.cache[reference] |
| for key in keys or []: |
| value = value[key] |
| if not isinstance(value, torch.Tensor) or value.device.type != "cpu": |
| raise TypeError(f"Reference is not a CPU tensor: {reference} {keys}") |
| return value |
|
|
| def numeric(self, name): |
| if name not in LAYOUT: |
| raise ValueError(f"Unsupported FreiHAND numerical component: {name}") |
| component = self.meta["components"][name] |
| reference, entry = LAYOUT[name] |
| if component["data_ref"] != reference or component["valid_ref"] != reference: |
| raise ValueError("Numerical data and valid must use the registered bundle path") |
| if component["data_key"] != [entry, "data"] or component["valid_key"] != [entry, "valid"]: |
| raise ValueError("Numerical data and valid must use the registered same-entry keys") |
| for key in ("storage", "valid_storage"): |
| if component[key]["profile"] != PROFILE: |
| raise ValueError("Numerical fields must declare the bundle profile") |
| data = self.tensor(component["data_ref"], component["data_key"]) |
| valid = self.tensor(component["valid_ref"], component["valid_key"]) |
| bundle = self.cache[reference] |
| if type(bundle) is not dict or set(bundle) != {entry} or type(bundle[entry]) is not dict or set(bundle[entry]) != {"data", "valid"}: |
| raise ValueError("Unexpected bundle fields") |
| if valid.dtype != torch.bool: |
| raise TypeError("valid must be bool") |
| return data, valid |
|
|
| def validity(self, name): |
| component = self.meta["components"][name] |
| return self.tensor(component["valid_ref"], component.get("valid_key")) |
|
|
