| |
| """Render sampled ReInterHand shared-v1.1 views to self-contained HTML review pages. |
| |
| CONTRACT 6.5 keeps "the repackaging preserved the bytes" apart from "a human looked at |
| it". H2O, dex-ycb, ARCTIC and RHD all ship sampled per-view pages for the second half; |
| this gives ReInterHand the same artifact, written against the v1.1 layout rather than |
| ported from any of them: |
| |
| * every value is read through the released reader -- ``Registry``/``BundleReader`` plus |
| ``reinterhand_common.check_view``, the calls ``validate.py`` and ``read_sequence.py`` |
| already make -- so a page shows what the release declares rather than a re-derived copy |
| of it. ``data_key`` in a component marks a bundled numeric field; media, the standalone |
| ``*_valid.pt`` files beside it and the JSONL are read as the preserved files they are. |
| * the panels are the vocabulary of ReInterHand's **own** published v1.0 renderer |
| (``shared-v1.0/script/render_reinterhand_full_random.py`` and its pages under |
| ``doc/validation/full_random/``): native RGB, the MANO mesh in cyan for the left hand and |
| orange for the right, and the free-standing non-binary foreground mask as grayscale |
| intensity. That vocabulary is used unchanged so a reviewer can read a v1.1 page against |
| a v1.0 one -- including the one thing it is easy to get backwards, which is that this |
| release's MANO colours are **not** RHD's red/blue. |
| * the v1.0 renderer required a MANO runtime (``smplx`` plus the ``MANO_*.pkl`` weights) and |
| drew the geometry from it. Those weights are not part of the shared release (CONTRACT |
| 5.2: 模型权重不作为共享数据附带上传), so the runtime is an **optional input** here: with |
| ``--mano-runtime`` the MANO panel is drawn, without it the page names the missing runtime |
| and draws the rest. Either way the parameters are checked, because they are release |
| content. |
| * what the v1.0 pages could not do is measure the **join between the bundled parameters and |
| the preserved mask**, since there the two were separate files. v1.1 is where they live |
| one ``.pt`` apart, so this page projects the MANO geometry of *every* frame of the view |
| -- not only the sampled ones -- and reports how much of it lands on the mask's foreground. |
| The number is recorded, never asserted and never used to "fix" anything: a systematic |
| offset would be a finding about the release, not a reason to change a page. |
| |
| Per-frame validity is not uniform, and the pages have to survive that: over the two sample |
| sequences the exo views are valid on every frame while one sequence's ego view has only 5 of |
| 181 frames valid per hand. Sampling therefore always includes the first valid and the first |
| invalid frame of each series, and a hand whose slot is invalid is left undrawn with the |
| reason on the panel rather than drawn from parameters the release marks invalid. |
| |
| Every page is one self-contained file (previews as base64 JPEG data URIs -- a lossy |
| *preview* of a lossless frame, which CONTRACT 6 does not forbid because the release's own |
| bytes are untouched; PNG was used for RHD's 320x320 frames, and at 667x1024 portrait it |
| would make the page set an order of magnitude larger). Only the sampled RGB frames are |
| decoded; the mask is streamed once, end to end, for the whole-view scan. |
| |
| Run -- the ordering matters, see the 收尾验收顺序 in script/reinterhand_v1_1/README.md: |
| |
| python shared-v1.1/script/reinterhand_v1_1/render.py \ |
| --mano-runtime ../../tmp/runtime-v1.0 |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import base64 |
| import collections |
| import html |
| import io |
| import json |
| import multiprocessing |
| import os |
| import random |
| import subprocess |
| import sys |
| import time |
| from concurrent.futures import ProcessPoolExecutor |
| from pathlib import Path |
|
|
| |
| |
| |
| |
| |
| sys.dont_write_bytecode = True |
|
|
| import numpy as np |
| import torch |
| from PIL import Image, ImageDraw |
|
|
| from reinterhand_common import ( |
| DATASET_ROOT, |
| DEFAULT_MEDIA_DECLARATION, |
| FRAMES_REF, |
| RENDER_CELLS, |
| MediaDeclaration, |
| check_view, |
| load, |
| save, |
| ) |
| from warehouse import BundleReader, Registry |
|
|
| import mano_review |
|
|
| DECODE_SCOPE = ("ffmpeg demux over the preserved MKV; the sampled RGB frames are decoded " |
| "with select=, and the mask is streamed once from end to end for the " |
| "whole-view scan. Every frame's byte count is checked") |
| REPORT_SCOPE = ("v1.1 registry, keys, shapes, validity and timeline, plus the projection " |
| "of the bundled MANO parameters onto the preserved mask; not a media pixel " |
| "comparison of the released values themselves") |
| PROJECTION_SCOPE = ("bundled MANO parameters expanded to a camera-frame mesh and projected " |
| "through the view's own declared camera model (pinhole for exo, " |
| "opencv_fisheye4 for ego, both asserted by check_view before this runs), " |
| "then compared with the preserved mask's foreground. The mask has no " |
| "per-hand identity, so this measures coverage of both hands together, " |
| "not a per-hand match") |
|
|
| |
| |
| |
| |
| REVIEW_DIR = Path(__file__).resolve().parents[2] / "doc" / "validation" |
|
|
| |
| |
| |
| |
| HAND_COLORS = {"left": (0, 255, 255), "right": (255, 140, 0)} |
| |
| |
| MASK_TINT = (255, 0, 200) |
| MASK_TINT_ALPHA = 0.72 |
| MASK_TINT_CAP = 190 |
| |
| |
| PREVIEW_BOX = (460, 700) |
| PREVIEW_QUALITY = 88 |
| |
| |
| |
| FRAMES_CAP = 6 |
| |
| |
| DISPLAY_FRAME_FIELDS = ("frame_index", "sample_id", "source_frame_id", "sync_id", |
| "timestamp_ns", "clock_domain") |
|
|
|
|
| |
|
|
|
|
| def _ffmpeg_threads() -> str: |
| return os.environ.get("HAND_WAREHOUSE_FFMPEG_THREADS", "1") |
|
|
|
|
| def decode(path: Path, indices, pix_fmt: str, dtype, width: int, height: int, |
| channels: int): |
| """Decode exactly the requested frames of a preserved video, keyed by frame index. |
| |
| Same recipe as the published renderers (``HAND_WAREHOUSE_FFMPEG_THREADS``, one decoder |
| thread by default), with ``select=`` so a 200-frame stream is not read end to end for a |
| handful of stills. The byte count is checked rather than trusted: a short read would |
| silently misalign every frame after it, and ``-vsync 0`` plus an explicit ``-frames:v`` |
| is what makes ``select=`` yield exactly ``len(indices)`` frames. |
| """ |
| order = sorted(indices) |
| select = "+".join(f"eq(n\\,{index})" for index in order) |
| threads = _ffmpeg_threads() |
| argv = ["ffmpeg", "-v", "error", "-nostdin", "-filter_threads", threads, |
| "-threads", threads, "-noautorotate", "-i", str(path), "-map", "0:v:0", |
| "-vf", f"select={select}", "-vsync", "0", "-frames:v", str(len(order)), |
| "-threads", threads, "-f", "rawvideo", "-pix_fmt", pix_fmt, "-"] |
| raw = subprocess.run(argv, capture_output=True, check=True).stdout |
| |
| |
| |
| expected = len(order) * height * width * channels * np.dtype(dtype).itemsize |
| if len(raw) != expected: |
| raise ValueError(f"{path}: decoded {len(raw)} bytes, expected {expected}") |
| frames = np.frombuffer(raw, dtype=dtype).reshape(len(order), height, width, channels) |
| return {index: frames[position].copy() for position, index in enumerate(order)} |
|
|
|
|
| def stream(path: Path, pix_fmt: str, dtype, width: int, height: int, channels: int): |
| """Yield every frame of a preserved video in order, one at a time. |
| |
| The whole-view scan needs each mask frame once and nothing twice, so the decoder is read |
| as a pipe rather than collected into one array: a 667x1024 gray16le frame is 1.4 MB, and |
| all of a view's frames at once would be the largest thing this tool holds. |
| """ |
| threads = _ffmpeg_threads() |
| argv = ["ffmpeg", "-v", "error", "-nostdin", "-threads", threads, "-noautorotate", |
| "-i", str(path), "-map", "0:v:0", "-vsync", "0", "-threads", threads, |
| "-f", "rawvideo", "-pix_fmt", pix_fmt, "-"] |
| frame_bytes = width * height * channels * np.dtype(dtype).itemsize |
| process = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE) |
| try: |
| while True: |
| block = process.stdout.read(frame_bytes) |
| if not block: |
| break |
| if len(block) != frame_bytes: |
| raise ValueError(f"{path}: short frame, {len(block)} of {frame_bytes} bytes") |
| yield np.frombuffer(block, dtype=dtype).reshape(height, width, channels) |
| finally: |
| process.stdout.close() |
| error = process.stderr.read().decode("utf-8", "replace").strip() |
| process.stderr.close() |
| if process.wait() != 0: |
| raise ValueError(f"{path}: ffmpeg failed: {error}") |
|
|
|
|
| def probe(path: Path): |
| """Demux-only facts about a media file: packet count, shape, codec.""" |
| out = subprocess.run( |
| ["ffprobe", "-v", "error", "-select_streams", "v:0", "-count_packets", |
| "-show_entries", "stream=width,height,codec_name,pix_fmt,nb_read_packets", |
| "-of", "json", str(path)], |
| capture_output=True, text=True, check=True).stdout |
| facts = (json.loads(out).get("streams") or [{}])[0] |
| return {"frames": int(facts["nb_read_packets"]), "width": facts.get("width"), |
| "height": facts.get("height"), "codec": facts.get("codec_name"), |
| "pix_fmt": facts.get("pix_fmt")} |
|
|
|
|
| |
|
|
|
|
| def picture(image: Image.Image) -> str: |
| """A preview as a JPEG data URI. The released tensors and videos are never resized. |
| |
| The preview *is* lossy, and every page says so: a 667x1024 PNG of a real photograph is |
| around 600 KB and a page carries four panels per sampled frame, so the page set would be |
| an order of magnitude larger than the evidence it carries. The decoded frame is full |
| size until this last step, and every measurement on the page is taken before it. |
| """ |
| preview = image.copy() |
| preview.thumbnail(PREVIEW_BOX) |
| output = io.BytesIO() |
| preview.save(output, format="JPEG", quality=PREVIEW_QUALITY) |
| return ('<img loading="lazy" src="data:image/jpeg;base64,' |
| + base64.b64encode(output.getvalue()).decode() + '">') |
|
|
|
|
| def label_panel(image: Image.Image, text: str) -> Image.Image: |
| """The v1.0 renderer's in-frame panel label, so the two page sets look alike.""" |
| result = image.copy() |
| painter = ImageDraw.Draw(result) |
| painter.rectangle((0, 0, min(result.width, 460), 26), fill=(0, 0, 0)) |
| painter.text((8, 6), text, fill=(255, 255, 255)) |
| return result |
|
|
|
|
| def mask_intensity_panel(mask: np.ndarray, shift: int) -> Image.Image: |
| """The preserved mask's own values, shown as intensity rather than hidden in RGB. |
| |
| ``segment/foreground_intensity/v1`` is a *non-binary* foreground intensity in 0..255 |
| with no per-hand identity, so it is drawn as grayscale with a scale bar and its frame |
| minimum and maximum. The container is ``gray16le``: decoding it as 8-bit ``gray`` would |
| make ffmpeg rescale 0..65535 down to 0..255 and collapse the native range to almost |
| black, so the stored words are read verbatim. ``shift`` is 0 for the declared range; a |
| frame holding a value above 255 -- possible, since the container is wider than the |
| declaration -- is drawn shifted down by 8 bits and the caption says so, never clamped |
| silently, which would draw a wrong picture. |
| """ |
| image = Image.fromarray((mask >> shift).astype(np.uint8), "L").convert("RGB") |
| painter = ImageDraw.Draw(image) |
| width, height = image.size |
| bar_width = min(280, max(120, width // 2)) |
| x0, y0 = 12, max(40, height - 40) |
| ramp = np.tile(np.arange(256, dtype=np.uint8), (14, 1)) |
| image.paste(Image.fromarray(ramp, "L").convert("RGB"), (x0, y0)) |
| painter.rectangle((x0 - 1, y0 - 1, x0 + bar_width, y0 + 14), outline=(255, 70, 70), |
| width=2) |
| painter.text((x0, max(2, y0 - 16)), "intensity 0 -> 255" + (" (>>8)" if shift else ""), |
| fill=(255, 70, 70)) |
| painter.text((x0, min(height - 10, y0 + 17)), |
| f"stored min={int(mask.min())} max={int(mask.max())}", fill=(255, 70, 70)) |
| return image |
|
|
|
|
| def mask_overlay(image: np.ndarray, mask: np.ndarray, shift: int) -> Image.Image: |
| """The v1.0 renderer's magenta foreground tint, so alignment can be judged by eye.""" |
| tint = Image.new("RGBA", (mask.shape[1], mask.shape[0]), (*MASK_TINT, 0)) |
| tint.putalpha(Image.fromarray((mask >> shift).astype(np.uint8), "L").point( |
| lambda value: min(MASK_TINT_CAP, int(value * MASK_TINT_ALPHA)))) |
| return Image.alpha_composite(Image.fromarray(image).convert("RGBA"), tint).convert("RGB") |
|
|
|
|
| def mano_overlay(image: np.ndarray, pixels_by_side: dict, faces, width: int, |
| height: int) -> tuple: |
| """The MANO mesh drawn the way the v1.0 pages drew it: translucent fill, solid edge. |
| |
| Returns the image and how many triangles each hand contributed, so a caption can say |
| whether a hand was drawn at all rather than leaving an empty panel unexplained. A side |
| whose slot is invalid arrives as ``None`` and contributes nothing. |
| """ |
| base = Image.fromarray(image).convert("RGBA") |
| overlay = Image.new("RGBA", base.size, (0, 0, 0, 0)) |
| painter = ImageDraw.Draw(overlay, "RGBA") |
| counts = {} |
| for side in ("left", "right"): |
| pixels = pixels_by_side.get(side) |
| polygons = (list(mano_review.drawable_faces(faces, pixels, width, height, np)) |
| if pixels is not None else []) |
| counts[side] = None if pixels is None else len(polygons) |
| colour = HAND_COLORS[side] |
| for polygon in polygons: |
| painter.polygon(polygon, fill=(*colour, 28)) |
| painter.line(polygon + [polygon[0]], fill=(*colour, 220), width=2) |
| return Image.alpha_composite(base, overlay).convert("RGB"), counts |
|
|
|
|
| |
|
|
|
|
| def numeric_records(meta: dict, reader, view: Path) -> dict: |
| """One JSON-safe record per series the view carries, read through the released reader. |
| |
| Two shapes of series live here and the report has to keep them apart: |
| |
| * a **bundled** field (``data_key`` present) lives in a bundle file beside its ``valid`` |
| and is read with ``reader.field`` -- intrinsic, extrinsic, distortion, mano. The |
| migration owns these. |
| * a **preserved** media component (``rgb``, ``segment``) keeps v1.0's layout: the payload |
| is the MKV and the validity is a standalone ``*_valid.pt`` sibling, read with the same |
| ``torch.load(..., weights_only=True)`` ``check_view`` uses. The migration leaves both |
| alone. |
| |
| ``check_view`` has already asserted every one of these; the records restate them for the |
| report so the page and the checker cannot disagree. The arrays themselves are not kept |
| here -- they would make the record un-serialisable -- and ``validity_arrays`` reads the |
| same series again for the per-frame panels. |
| """ |
| records = {} |
| for name, component in meta["components"].items(): |
| if not component.get("available", True): |
| continue |
| if "data_key" in component: |
| data, valid = reader.field(view, component) |
| records[name] = { |
| "kind": "bundled", "file": component["data_ref"], |
| "data_key": component["data_key"], "valid_key": component["valid_key"], |
| "shape": list(data.shape), "dtype": str(data.dtype), |
| "valid_true": int(valid.sum()), "valid_total": int(valid.numel()), |
| "nan_count": (int(torch.isnan(data).sum()) |
| if data.is_floating_point() else None), |
| } |
| elif component["data_ref"].endswith(".mkv"): |
| valid = standalone_validity(view, component) |
| records[name] = { |
| "kind": "preserved_media", "file": component["data_ref"], |
| "valid_file": component["valid_ref"], |
| "shape": None, "dtype": None, "valid_shape": list(valid.shape), |
| "valid_dtype": str(valid.dtype), "valid_true": int(valid.sum()), |
| "valid_total": int(valid.numel()), "nan_count": None, |
| } |
| else: |
| continue |
| counts = valid_counts(valid if "data_key" not in component |
| else reader.field(view, component)[1]) |
| records[name]["valid_true_per_series"] = counts |
| return records |
|
|
|
|
| def standalone_validity(view: Path, component: dict): |
| """A preserved media component's standalone ``*_valid.pt``, exactly as check_view reads it.""" |
| return torch.load(view / component["valid_ref"], map_location="cpu", weights_only=True) |
|
|
|
|
| def valid_counts(valid) -> list: |
| """``valid`` true-counts split along its last axis when that axis is a small series axis. |
| |
| ReInterHand's ``mano`` validity is ``[T, 2]`` -- one flag per hand -- and the pages report |
| the two hands separately, which is why the split is worth carrying. ``[T]`` series get a |
| single count. The threshold mirrors the release's own two ``hand_slots``. |
| """ |
| if valid.dim() > 1 and valid.shape[-1] <= 4: |
| return [int(valid[..., slot].sum()) for slot in range(valid.shape[-1])] |
| return [int(valid.sum())] |
|
|
|
|
| def select_frames(n: int, valids, extra=(), cap: int = FRAMES_CAP) -> list: |
| """Sampling driven by the release's own validity, so a page shows its boundary cases. |
| |
| Both ends, the first frame each series is valid and the first it is not (an invalid row |
| is exactly what a reviewer wants to see once, and on these sample sequences it is the |
| majority of one ego view's frames), and whatever the caller has already decided is worth |
| seeing -- this renderer passes the frame whose MANO geometry the mask covers least, found |
| by the whole-view scan. Quarter points fill the rest, so a temporal view shows its span. |
| |
| Priority is strict, and the cap is therefore exact rather than a target: the ends and the |
| boundary cases are claims about the release and are never dropped, ``extra`` is the |
| caller's explicit choice, and only the quarter points are expendable. A view whose |
| validity is busy can legitimately fill the whole budget with boundary cases, in which |
| case the page shows no quarter point at all -- which is the right trade, because the |
| quarter point is the one pick that carries no information the caption does not. |
| """ |
| keep = {0, n - 1} | {int(index) for index in extra} |
| optional = {n // 4, n // 2, 3 * n // 4} - keep |
| for valid in valids: |
| if valid is None: |
| continue |
| flags = np.asarray(valid, dtype=bool).reshape(n, -1).any(axis=1) |
| for present in (np.flatnonzero(flags), np.flatnonzero(~flags)): |
| if len(present): |
| keep.add(int(present[0])) |
| room = max(0, cap - len(keep)) |
| return sorted(keep | set(sorted(optional)[:room])) |
|
|
|
|
| def declared_cell(meta: dict) -> dict: |
| """Which of the release's four render cells this view is in, and what follows from it. |
| |
| Taken from :data:`RENDER_CELLS` rather than re-derived, so the caption and the checkers |
| cannot disagree about, say, whether the stored frames are a temporal sequence. A view |
| outside the four measured cells is reported as such rather than guessed about. |
| """ |
| policy = meta["source_rendering"].get("background_policy") |
| cell = RENDER_CELLS.get((meta["view_type"], policy)) |
| if cell is None: |
| return {"view_type": meta["view_type"], "background_policy": policy, "known": False} |
| return {"view_type": meta["view_type"], "background_policy": policy, "known": True, |
| "temporal_relationship": cell["temporal_relationship"], |
| "sample_type": cell["sample_type"], "sampling": cell["sampling"], |
| "covers_span": cell["covers_span"], |
| "modal_source_steps": list(cell["modal_steps"]), |
| "source_fps": cell["source_fps"], |
| "sequence_id_role": cell["sequence_id_role"]} |
|
|
|
|
| def frame_rows_of(view: Path) -> dict: |
| """``camera/frames.jsonl`` as ``frame_index -> row``, the join the captions display.""" |
| rows = [json.loads(line) for line in |
| (view / FRAMES_REF).read_text(encoding="utf-8").splitlines() if line.strip()] |
| return {int(row["frame_index"]): {key: row.get(key) for key in DISPLAY_FRAME_FIELDS} |
| for row in rows} |
|
|
|
|
| def project(index: int, geometry, intrinsic, distortion, width: int, height: int, |
| cv2) -> dict: |
| """One series' geometry at one frame, projected and classified against the picture. |
| |
| The single projection implementation, shared by the whole-view scan and the per-frame |
| panels, so the number the header quotes and the polygon the panel draws cannot come from |
| two different formulas. Returns every point's pixel (NaN where the point is not in front |
| of the camera), the in-front mask, which points are inside the picture, and those points |
| as integer rows/columns for indexing the mask. |
| |
| ``distortion`` is the view's whole ``[T, 4]`` stack (or ``None`` for a pinhole view); this |
| is where the frame's own row is selected, so no caller can pass the stack by mistake -- |
| OpenCV asserts on exactly four coefficients and would otherwise fail deep inside the |
| fisheye call with an argument-shape message that says nothing about the frame index. |
| """ |
| frame_distortion = None if distortion is None else distortion[index] |
| pixels, front = mano_review.project_vertices(geometry[index], intrinsic[index], |
| frame_distortion, np, cv2) |
| finite = front & np.isfinite(pixels).all(axis=-1) |
| inside = (finite & (pixels[:, 0] >= 0) & (pixels[:, 0] < width) |
| & (pixels[:, 1] >= 0) & (pixels[:, 1] < height)) |
| return {"pixels": pixels, "front": front, "inside": inside, |
| "points": np.clip(pixels[inside], 0, None).astype(np.int64)} |
|
|
|
|
| def mano_mask_scan(meta: dict, mask_path: Path, mask_valid, mano_valid, geometry, |
| intrinsic, distortion, cv2) -> dict: |
| """Project the MANO mesh of *every* frame and count how much lands on the foreground. |
| |
| This is the measurement the v1.0 pages could not make: there the parameters and the mask |
| were separate files and nothing tied them together. It is deliberately a *coverage* count |
| and not an assertion -- the mask carries no per-hand identity, so it cannot say which hand |
| a pixel belongs to, and a systematic offset would be a finding about the source rather than |
| a reason to change the page. Frames the release marks invalid for either series, and |
| frames whose mask is entirely zero (a ratio with a zero denominator is not a number), are |
| excluded from the ratios and counted separately. |
| """ |
| n = meta["num_frames"] |
| width, height = meta["camera"]["image_size"] |
| per_side = {side: {"frames_used": 0, "joints_projected": 0, "joints_in_frame": 0, |
| "joints_on_foreground": 0, "vertices_in_frame": 0, |
| "vertices_on_foreground": 0, "frames_with_joints_in_frame": 0} |
| for side in ("left", "right")} |
| observed_min, observed_max = None, None |
| frames_scanned = frames_mask_empty = valid_frames_skipped_empty = 0 |
| coverage, worst = [], None |
| for index, frame in enumerate(stream(mask_path, "gray16le", np.uint16, width, height, 1)): |
| if index >= n: |
| break |
| frames_scanned += 1 |
| mask = frame[..., 0] |
| low, high = int(mask.min()), int(mask.max()) |
| observed_min = low if observed_min is None else min(observed_min, low) |
| observed_max = high if observed_max is None else max(observed_max, high) |
| if high == 0: |
| frames_mask_empty += 1 |
| if bool(mask_valid[index]): |
| valid_frames_skipped_empty += 1 |
| continue |
| foreground = mask > 0 |
| total_in_frame = total_on = 0 |
| for slot, side in enumerate(("left", "right")): |
| if not bool(mano_valid[index, slot]): |
| continue |
| data = per_side[side] |
| data["frames_used"] += 1 |
| vertices = project(index, geometry[side][0], intrinsic, distortion, width, |
| height, cv2) |
| rows = vertices["points"] |
| on = int(foreground[rows[:, 1], rows[:, 0]].sum()) if len(rows) else 0 |
| data["vertices_in_frame"] += int(vertices["inside"].sum()) |
| data["vertices_on_foreground"] += on |
| total_in_frame += int(vertices["inside"].sum()) |
| total_on += on |
| joints = project(index, geometry[side][1], intrinsic, distortion, width, |
| height, cv2) |
| data["joints_projected"] += int(joints["front"].sum()) |
| data["joints_in_frame"] += int(joints["inside"].sum()) |
| if joints["inside"].any(): |
| data["frames_with_joints_in_frame"] += 1 |
| joint_rows = joints["points"] |
| data["joints_on_foreground"] += (int(foreground[joint_rows[:, 1], |
| joint_rows[:, 0]].sum()) |
| if len(joint_rows) else 0) |
| |
| |
| if bool(mask_valid[index]) and total_in_frame: |
| share = total_on / total_in_frame |
| coverage.append(share) |
| if worst is None or share < worst[1]: |
| worst = (index, share) |
| return { |
| "frames_scanned": frames_scanned, |
| "frames_the_mask_is_empty_on": frames_mask_empty, |
| "valid_frames_excluded_because_the_mask_is_empty": valid_frames_skipped_empty, |
| "observed_value_range": {"min": observed_min, "max": observed_max}, |
| "frames_used_for_coverage": len(coverage), |
| "in_frame_vertices_median_on_foreground": ( |
| round(float(np.median(coverage)), 6) if coverage else None), |
| "in_frame_vertices_min_on_foreground": (round(worst[1], 6) if worst else None), |
| "least_covered_frame": (worst[0] if worst else None), |
| "per_hand": per_side, |
| "note": "the mask is a left+right union with no per-hand identity, so the per-hand " |
| "counts describe the geometry each hand contributes, not a per-hand " |
| "agreement; frames the release marks invalid, and frames whose mask is " |
| "entirely zero, are excluded from the ratios and counted separately", |
| } |
|
|
|
|
| _CV2 = None |
| _RUNTIME: dict = {} |
|
|
|
|
| def _cv2(): |
| """``cv2`` imported on demand: only the fisheye projection needs it.""" |
| global _CV2 |
| if _CV2 is None: |
| import cv2 |
| _CV2 = cv2 |
| return _CV2 |
|
|
|
|
| def mano_runtime(path): |
| """One loaded MANO pair per process, however many views that process renders.""" |
| if "mano" not in _RUNTIME: |
| _RUNTIME["mano"] = mano_review.ManoRuntime(Path(path), np, torch) |
| return _RUNTIME["mano"] |
|
|
|
|
| |
|
|
|
|
| def view_report(view: Path, meta: dict, records: dict, consumed: set, selected: list, |
| media: list, scan, gaps) -> dict: |
| """The published report shape, composed from the released checker's evidence.""" |
| bundles = sorted({component["data_ref"] for component in meta["components"].values() |
| if "data_key" in component}) |
| return { |
| "view": f"{view.parent.name}/{view.name}", |
| "sequence_id": meta["sequence_id"], |
| "camera_id": meta["camera_id"], |
| "view_type": meta["view_type"], |
| |
| |
| |
| "camera_family": meta["source_rendering"].get("camera_family"), |
| "split": meta["split"], |
| "num_frames": meta["num_frames"], |
| "camera": {"model": meta["camera"]["model"], |
| "schema_id": meta["camera"]["schema_id"], |
| "image_size": meta["camera"]["image_size"]}, |
| "render_cell": declared_cell(meta), |
| "series": records, |
| "bundle_files": bundles, |
| "media": media, |
| "mano_on_mask": scan, |
| "consumed_files": sorted(consumed), |
| "declared_media_schema_gaps_counted_here": dict(gaps), |
| "selected_frames": selected, |
| "decode_scope": DECODE_SCOPE, |
| "projection": {"model": meta["camera"]["model"], "scope": PROJECTION_SCOPE}, |
| "scope": REPORT_SCOPE, |
| } |
|
|
|
|
| def colour_legend() -> str: |
| """The colour vocabulary and what is deliberately not drawn, in one place.""" |
| def swatch(colour, label: str) -> str: |
| css = "rgb(" + ",".join(str(int(component)) for component in colour) + ")" |
| return ('<span class="swatch" style="background:' + css |
| + '"> </span> ' + html.escape(label)) |
|
|
| return ('<p class="legend">配色沿用 ReInterHand v1.0 复核页自己的约定（' |
| "<code>draw_mano_meshes</code>：青左手、橙右手；前景用洋红叠加），便于与 " |
| "<code>shared-v1.0/doc/validation/full_random/</code> 的页面并排读。" |
| "<b>注意这不是 RHD 的红/蓝</b>——照抄 RHD 会让复核者把左右手读反：" |
| + " · ".join([swatch(HAND_COLORS["left"], "左手（MANO 网格）"), |
| swatch(HAND_COLORS["right"], "右手（MANO 网格）"), |
| swatch(MASK_TINT, "前景强度叠加（洋红，α=0.72×强度）")]) |
| + "<br>mask 是 <code>segment/foreground_intensity/v1</code>：<b>非二值</b>前景" |
| "强度 0–255、<b>左右手并集、无左右手身份</b>，所以它按灰度强度显示并带刻度" |
| "条，而不是当成二值或按手着色。页面不画物体、不画接触、不画深度：这个 " |
| "release 没有这三类内容。</p>") |
|
|
|
|
| def scan_note(scan, mano_record) -> str: |
| """The header's account of the MANO-on-mask scan, with its own measured numbers.""" |
| median = scan["in_frame_vertices_median_on_foreground"] |
| sides = scan["per_hand"] |
| return ('<p class="note"><b>全视图扫描</b>（不止抽样帧：本视图 ' |
| + str(scan["frames_scanned"]) + " 帧全部参与，mask 从头到尾流式解一遍）：把每个" |
| "有效帧的 MANO 网格按其自身参数展开、经该视图声明的相机模型投到像素上，再看它" |
| "落在 mask 前景里的比例。取左右手都在画内的顶点合计，中位覆盖 " |
| + (f"{median:g}" if median is not None else "—（无可用帧）") |
| + ("（覆盖最低的一帧是 " + str(scan["least_covered_frame"]) + "，" |
| + f"{scan['in_frame_vertices_min_on_foreground']:g})" |
| if scan["least_covered_frame"] is not None else "") |
| + "；进入比值的帧 " + str(scan["frames_used_for_coverage"]) + "。逐手：" |
| + "｜".join(f"{side} 有效 {sides[side]['frames_used']} 帧、画内顶点 " |
| f"{sides[side]['vertices_in_frame']}、落在前景 " |
| f"{sides[side]['vertices_on_foreground']}、关节画内 " |
| f"{sides[side]['joints_in_frame']}" |
| for side in ("left", "right")) |
| + "。mask 全零的帧 " + str(scan["frames_the_mask_is_empty_on"]) + " 个" |
| + ("（其中 " + str(scan["valid_frames_excluded_because_the_mask_is_empty"]) |
| + " 个本身是有效帧，因分母为零而不进比值）" |
| if scan["valid_frames_excluded_because_the_mask_is_empty"] else "") |
| + "。实测值域 " + str(scan["observed_value_range"]["min"]) + "–" |
| + str(scan["observed_value_range"]["max"]) + "（声明 " |
| + str(scan.get("declared_value_range")) + "）。MANO 模型来自树外 runtime " |
| + html.escape(str(mano_record["runtime"])) + "（smplx " |
| + html.escape(str(mano_record.get("smplx"))) + "）。<b>这个数只被记录，不被断言、" |
| "也不用来「修正」任何发布值</b>：mask 没有左右手身份，所以它衡量的是「参数展开" |
| "出的几何是否落在前景上」这一件事，系统性偏移会是关于源的发现，而不是页面的" |
| "缺陷。</p>") |
|
|
|
|
| def render_one(view: Path, destination: Path, root: Path, declaration_path, |
| runtime_path) -> dict: |
| registry = Registry.load(root / "doc/schema.json") |
| meta = load(view / "metainfo.json") |
| n = meta["num_frames"] |
| width, height = meta["camera"]["image_size"] |
| components = meta["components"] |
| declaration = MediaDeclaration.load(declaration_path) |
| identity = {"view": f"{view.parent.name}/{view.name}", |
| "sequence_id": meta["sequence_id"], "camera_id": meta["camera_id"], |
| "view_type": meta["view_type"], "split": meta["split"], "num_frames": n} |
|
|
| |
| |
| |
| media_names = [name for name, component in components.items() |
| if str(component.get("data_ref", "")).endswith(".mkv")] |
| states = {name: declaration.state(view, meta["sequence_id"], |
| components[name]["data_ref"]) |
| for name in media_names} |
| blocked = {name: state for name, state in states.items() if state != "present"} |
| if blocked: |
| return dict(identity, rendered=False, media_states=states, |
| reason="this copy of the tree does not ship the media for this sequence " |
| "(" + ", ".join(sorted(set(blocked.values()))) |
| + "), so no frame can be decoded", |
| scope=REPORT_SCOPE) |
|
|
| reader = BundleReader() |
| gaps = collections.Counter() |
| consumed = check_view(view, meta, registry, reader, media=declaration, gaps=gaps) |
| records = numeric_records(meta, reader, view) |
|
|
| bundled = {name: reader.field(view, component) |
| for name, component in components.items() |
| if component.get("available", True) and "data_key" in component} |
| validity = {name: values[1].numpy() for name, values in bundled.items()} |
| intrinsic = bundled["intrinsic"][0].numpy().astype(np.float64) |
| motion = bundled["mano"][0].numpy().astype(np.float64) |
| mano_valid = bundled["mano"][1].numpy().astype(bool) |
| distortion = (bundled["distortion"][0].numpy().astype(np.float64) |
| if "distortion" in bundled else None) |
| |
| |
| assert (distortion is None) == (meta["camera"]["model"] == "pinhole"), ( |
| meta["camera"]["model"], distortion is not None) |
| rgb_valid = standalone_validity(view, components["rgb"]).numpy().astype(bool) |
| mask_valid = standalone_validity(view, components["segment"]).numpy().astype(bool) |
| validity["rgb"], validity["segment"] = rgb_valid, mask_valid |
|
|
| media = [] |
| for name in media_names: |
| reference = view / components[name]["data_ref"] |
| entry = {"component": name, "ref": components[name]["data_ref"], "state": "present", |
| "bytes": reference.stat().st_size, |
| "valid_ref": components[name].get("valid_ref")} |
| entry.update(probe(reference)) |
| media.append(entry) |
| for entry in media: |
| assert entry["frames"] == n, (entry, n) |
| |
| assert [entry["width"], entry["height"]] == [width, height], (entry, [width, height]) |
|
|
| mano = mano_runtime(runtime_path) if runtime_path is not None else None |
| geometry, scan = None, None |
| if mano is not None: |
| geometry = {side: mano.geometry(side, motion) for side in ("left", "right")} |
| scan = mano_mask_scan(meta, view / components["segment"]["data_ref"], mask_valid, |
| mano_valid, geometry, intrinsic, distortion, _cv2()) |
| segment = components["segment"] |
| scan["declared_value_range"] = segment.get("value_range") |
| scan["declared_normalization_scale"] = segment.get("normalization_scale") |
| scan["foreground_category"] = segment.get("foreground_category") |
| scan["identity_semantics"] = segment.get("identity_semantics") |
|
|
| rows = frame_rows_of(view) |
| selected = select_frames( |
| n, [mano_valid, rgb_valid, mask_valid], |
| extra=([scan["least_covered_frame"]] |
| if scan and scan["least_covered_frame"] is not None else [])) |
| rgb = decode(view / components["rgb"]["data_ref"], selected, "rgb24", np.uint8, |
| width, height, 3) |
| |
| masks = {index: frame[..., 0] for index, frame in |
| decode(view / components["segment"]["data_ref"], selected, "gray16le", |
| np.uint16, width, height, 1).items()} |
|
|
| panels_by_frame, details_by_frame = {}, {} |
| hands_not_drawn, hands_off_frame, mask_above_range = [], {}, [] |
| for index in selected: |
| panels = [] |
| image = rgb[index] |
| panels.append((f"原生 RGB（MKV 解出的第 {index} 帧，未重编码；预览为 JPEG 有损缩放）", |
| picture(label_panel( |
| Image.fromarray(image), |
| f"RGB | frame {index} | source " |
| f"{rows.get(index, {}).get('source_frame_id')}")))) |
|
|
| |
| |
| |
| |
| pixels_by_side, joints_by_side, drawn = {}, {}, {} |
| for slot, side in enumerate(("left", "right")): |
| if mano is None or not bool(mano_valid[index, slot]): |
| pixels_by_side[side] = None |
| joints_by_side[side] = None |
| hands_not_drawn.append({ |
| "frame_index": index, "side": side, |
| "why": "no MANO runtime" if mano is None |
| else "valid=false in the release"}) |
| continue |
| vertices = project(index, geometry[side][0], intrinsic, distortion, width, |
| height, _cv2()) |
| pixels_by_side[side] = vertices["pixels"] |
| joints = project(index, geometry[side][1], intrinsic, distortion, width, |
| height, _cv2()) |
| joints_by_side[side] = joints |
| if not joints["inside"].any(): |
| hands_off_frame[side] = hands_off_frame.get(side, 0) + 1 |
|
|
| if mano is None: |
| panels.append(("MANO 面板未绘制：未提供 <code>--mano-runtime</code>；MANO 权重按 " |
| "CONTRACT 5.2 不属于共享发布，参数仍记录在报告中", None)) |
| else: |
| overlay, drawn = mano_overlay(image, pixels_by_side, mano.faces, width, height) |
| caption = ("共享 MANO 网格（由 <code>mano/axis_angle61/v1</code> 参数展开的相机系" |
| "顶点，经本视图自己的 " + html.escape(meta["camera"]["model"]) |
| + " 投到像素；青＝左手、橙＝右手；可绘三角形数 左 " |
| + str(drawn["left"]) + " / 右 " + str(drawn["right"]) + "）") |
| for side in ("left", "right"): |
| if pixels_by_side[side] is None: |
| caption += (f"；{side} 本帧 valid=false，未绘制（参数存在但发布标记为无效，" |
| "不拿它当结果画）") |
| caption += "。网格按 v1.0 口径渲染：平移已在相机系，未再乘外参" |
| panels.append((caption, picture(overlay))) |
|
|
| mask = masks[index] |
| shift = 8 if int(mask.max()) > 255 else 0 |
| if shift: |
| mask_above_range.append({"frame_index": index, "max": int(mask.max())}) |
| panels.append((f"原生非二值 mask 强度（gray16le 原值，未二值化；本帧存储值 " |
| f"min={int(mask.min())} max={int(mask.max())}" |
| + ("，超出声明值域，面板按 >>8 缩放显示）" if shift else "）"), |
| picture(mask_intensity_panel(mask, shift)))) |
| panels.append(("mask 叠加在 RGB 上（洋红＝前景强度 ×0.72，上限 190，便于目视对齐；" |
| "这不是分类结果）", picture(mask_overlay(image, mask, shift)))) |
|
|
| details = { |
| "frame_index": index, |
| "source": rows.get(index), |
| "validity_at_this_frame": { |
| |
| |
| name: ({"valid": bool(values[index].any()), |
| "per_series": [bool(flag) for flag in values[index]]} |
| if values.ndim > 1 and values.shape[-1] <= 4 |
| else {"valid": bool(values[index])}) |
| for name, values in validity.items()}, |
| "mano": {side: { |
| "valid": bool(mano_valid[index, slot]), |
| "triangles_drawn": drawn.get(side), |
| "joints_in_frame": (int(joints_by_side[side]["inside"].sum()) |
| if joints_by_side.get(side) else None), |
| "joints_on_foreground": ( |
| int((mask > 0)[joints_by_side[side]["points"][:, 1], |
| joints_by_side[side]["points"][:, 0]].sum()) |
| if joints_by_side.get(side) and len(joints_by_side[side]["points"]) |
| else None)} |
| for slot, side in enumerate(("left", "right"))}, |
| "mask": {"stored_min": int(mask.min()), "stored_max": int(mask.max()), |
| "panel_shift": shift, "nonzero_pixels": int((mask > 0).sum()), |
| "valid": bool(mask_valid[index])}, |
| } |
| panels_by_frame[index] = panels |
| details_by_frame[index] = details |
|
|
| report = view_report(view, meta, records, consumed, selected, media, scan, gaps) |
| report.update(identity) |
| report["rendered"] = True |
| report["mano_runtime"] = mano.record if mano is not None else None |
| report["hands_not_drawn"] = hands_not_drawn |
| report["hands_geometry_entirely_off_frame"] = hands_off_frame |
| report["frames_with_a_mask_value_above_the_declared_range"] = mask_above_range |
|
|
| title = f"{view.parent.name}_{view.name}" |
| sections = [] |
| for index in selected: |
| figures = [] |
| for caption, source in panels_by_frame.get(index) or []: |
| figures.append("<figure>" + (source or "") + "<figcaption>" + caption |
| + "</figcaption></figure>") |
| sections.append( |
| f"<section><h2>帧 {index} / {n}</h2>" |
| + '<div class="panels">' + "".join(figures) + "</div>" |
| + "<details><summary>帧号、来源与各序列在本帧的有效性</summary><pre>" |
| + html.escape(json.dumps(details_by_frame[index], ensure_ascii=False, indent=2)) |
| + "</pre></details></section>") |
|
|
| cell = declared_cell(meta) |
| temporal = ("真实时序视频序列：每帧之间的时间关系本身是发布内容（可作跟踪/时序监督）" |
| if cell.get("temporal_relationship") else |
| "独立图片集合：MKV 只是无损批容器，<b>播放顺序不是时间</b>，不得当作运动、" |
| "跟踪、速度或时序监督使用") |
| css = ("body{font:16px sans-serif;max-width:1500px;margin:auto;padding:1rem;" |
| "background:#f5f7fa;color:#18232f;line-height:1.5}" |
| "section,details{background:#fff;padding:1rem;margin:1rem 0;border-radius:8px}" |
| "figure{margin:.5rem}figcaption{font-size:.85rem;max-width:460px}" |
| ".panels{display:flex;flex-wrap:wrap}img{max-width:100%;border:1px solid #ddd}" |
| "pre{white-space:pre-wrap;overflow:auto;font-size:12px}" |
| ".note{background:#fff7e6;border-left:3px solid #e0a800;padding:.6rem;" |
| "font-size:.9rem;max-width:1000px}" |
| ".legend{background:#eef3fa;border-left:3px solid #4a76a8;padding:.6rem;" |
| "font-size:.9rem;max-width:1000px}.swatch{border:1px solid #b9c3d0}") |
| header = ("<h1>" + html.escape(title) + "</h1>" |
| "<p>直接读取 v1.1 bundle（<code>" + html.escape(meta["sequence_id"]) |
| + "</code> 的 <code>" + html.escape(meta["camera_id"]) + "</code> 视图，" |
| + html.escape(meta["view_type"]) + " / " |
| + html.escape(str(cell.get("background_policy"))) + "，split=" |
| + html.escape(meta["split"]) + "，共 " + str(n) + " 帧）。" + temporal |
| + "。预览仅供人工复核，不是训练输入（CONTRACT §6.5）；本次只解码抽样的 " |
| + str(len(selected)) + " 帧 RGB，mask 则整段解过一遍。</p>") |
| header += colour_legend() |
| header += (scan_note(scan, mano.record) if scan is not None else |
| '<p class="note">本次未提供 <code>--mano-runtime</code>，所以没有做 ' |
| 'MANO→mask 的投影扫描，MANO 面板也未绘制。这不是数据缺失：MANO 权重按 ' |
| 'CONTRACT 5.2 不属于共享发布，参数本身仍逐帧记录在上面的报告里。</p>') |
| header += ('<p class="legend">MANO 参数 schema <code>' |
| + html.escape(str(components["mano"].get("schema_id"))) |
| + "</code>：48 维 16 关节轴角 + 10 维 shape + 3 维全局平移（共 61），姿态" |
| "弧度、平移米、<b>已在当前相机系</b>（CONTRACT 5.2），所以本页不对平移再乘" |
| "外参。平移是「模型输出顶点所加的全局平移」，<b>不是某个腕关节坐标</b>，" |
| "所以页面画的是展开后的网格而不是一个点。左右手各占 <code>hand</code> 轴" |
| "一个槽位，valid 逐帧逐手，本视图的有效帧数见上。</p>") |
| if hands_off_frame: |
| header += ('<p class="note">抽样帧里有 ' + html.escape(str(hands_off_frame)) |
| + " 次出现整只手都投到画外。ReInterHand 的 per_frame 单元每帧独立换背景、" |
| "相机也逐图随机，这属正常形态；此处只记录，不改判据。</p>") |
| if scan and scan["frames_the_mask_is_empty_on"]: |
| header += ('<p class="note">本视图有 ' + str(scan["frames_the_mask_is_empty_on"]) |
| + " 帧 mask 前景全为 0。这些帧不进覆盖比值（分母为零的比例没有意义），" |
| "但若被抽样仍会显示，以便复核者自己看一眼。</p>") |
| if mask_above_range: |
| header += ('<p class="note">抽样帧中有 ' + str(len(mask_above_range)) |
| + " 帧的 mask 存储值超过声明值域 [0,255]（最高 " |
| + str(max(item["max"] for item in mask_above_range)) |
| + "）。容器是 gray16le，所以这可以表示；面板按 >>8 缩放显示并在图注" |
| "标明，未做静默截断。全视图实测值域见上。</p>") |
| page = ('<!doctype html><html lang="zh"><meta charset="utf-8"><title>' |
| + html.escape(title) + "</title><style>" + css + "</style>" + header |
| + "".join(sections) |
| + "<details><summary>全部组件元信息及原始来源</summary><pre>" |
| + html.escape(json.dumps(meta, ensure_ascii=False, indent=2)) + "</pre></details>" |
| + "<details><summary>持久化复核结果（同 .report.json）</summary><pre>" |
| + html.escape(json.dumps( |
| {key: value for key, value in report.items() if not key.startswith("_")}, |
| ensure_ascii=False, indent=2)) |
| + "</pre></details></html>") |
|
|
| destination.mkdir(parents=True, exist_ok=True) |
| (destination / (title + ".html")).write_text(page, encoding="utf-8") |
| save(destination / (title + ".report.json"), |
| {key: value for key, value in report.items() if not key.startswith("_")}) |
| report["_page"] = title + ".html" |
| return report |
|
|
|
|
| def render_task(task): |
| for variable in ("OMP_NUM_THREADS", "MKL_NUM_THREADS", "OPENBLAS_NUM_THREADS", |
| "NUMEXPR_NUM_THREADS", "HAND_WAREHOUSE_FFMPEG_THREADS"): |
| os.environ[variable] = "1" |
| torch.set_num_threads(1) |
| view, destination, root, declaration, runtime = task |
| return render_one(Path(view), Path(destination), Path(root), |
| None if declaration is None else Path(declaration), |
| None if runtime is None else Path(runtime)) |
|
|
|
|
| |
|
|
|
|
| def shard_facts(root: Path, sequence: str) -> dict: |
| """Split, frame count, view count and render policy of one sequence.""" |
| metas = [load(path) for path in |
| sorted((root / "data" / sequence).glob("*/metainfo.json"))] |
| if not metas: |
| raise SystemExit(f"{sequence}: no views found") |
| policies = {meta["source_rendering"].get("background_policy") for meta in metas} |
| types = {meta["view_type"] for meta in metas} |
| |
| |
| |
| if len(policies) != 1 or types != {"exo", "ego"}: |
| raise SystemExit(f"{sequence}: {sorted(types)} / {sorted(policies)} is not a complete " |
| f"sequence") |
| return {"sequence": sequence, "split": metas[0]["split"], "views": len(metas), |
| "num_frames": max(meta["num_frames"] for meta in metas), |
| "view_types": sorted(types), |
| "camera_ids": sorted(meta["camera_id"] for meta in metas), |
| "policy": sorted(policies)[0]} |
|
|
|
|
| def shippable(root: Path, declaration: MediaDeclaration) -> dict: |
| """Facts for the sequences whose declared media this copy of the tree actually ships.""" |
| facts = {} |
| for path in sorted((root / "data").iterdir()): |
| if path.is_dir() and declaration.ships(path.name): |
| facts[path.name] = shard_facts(root, path.name) |
| return facts |
|
|
|
|
| def plan_views(facts: dict, seed: int, per_policy: int) -> list: |
| """Stratified sample over the sequences that ship media, one stratum per render policy. |
| |
| ``background_policy`` is the only sequence-wide render value -- the camera family and |
| frame rate differ *between* a sequence's exo and ego views by design -- so a sequence, |
| not a view, is the sampling unit, and the strata are the policies rather than the four |
| (view type, policy) cells. Inside a stratum the sequences are drawn uniformly with the |
| seed, and every view of a drawn sequence is rendered, which is what the v1.0 pages did |
| ("展示抽中序列的全部相机和全部帧"). With the media declaration this working copy |
| carries, the pool is the two sample sequences, so the draw is the whole media read-through; |
| on a published tree, where every sequence ships its media, the same rule spreads the sample |
| over both policies. A draw with no candidate at all is refused rather than silently |
| returning nothing. |
| """ |
| rng = random.Random(seed) |
| strata = collections.defaultdict(list) |
| for sequence, fact in facts.items(): |
| strata[fact["policy"]].append(sequence) |
| drawn = [] |
| for policy in sorted(strata): |
| pool = sorted(strata[policy]) |
| drawn.extend(pool if len(pool) <= per_policy |
| else sorted(rng.sample(pool, per_policy))) |
| if not drawn: |
| raise SystemExit("no sequence ships its media, so nothing can be rendered") |
| return sorted(drawn) |
|
|
|
|
| def main(argv=None): |
| parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) |
| parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[2], |
| help="the shared-v1.1 release root (default: this script's own)") |
| parser.add_argument("--out", type=Path, |
| help="where the pages go (default <root>/doc/validation)") |
| parser.add_argument("--seed", type=int, default=20261015) |
| parser.add_argument("--per-policy", type=int, default=1, |
| help="sequences drawn per render policy; all their views are rendered") |
| parser.add_argument("--workers", type=int, default=4, |
| help="at most 8, one decoder thread each") |
| parser.add_argument("--views", nargs="+", |
| help="render these views (<sequence>/<camera>) instead of sampling") |
| parser.add_argument("--media-declaration", type=Path, default=DEFAULT_MEDIA_DECLARATION, |
| help="which sequences' media this copy ships (default: the " |
| "tree-external declaration)") |
| parser.add_argument("--mano-runtime", type=Path, default=None, |
| help="directory with models/MANO_{LEFT,RIGHT}.pkl and a site/ holding " |
| "smplx; without it the MANO panel is not drawn (default: " |
| "<dataset>/tmp/runtime-v1.0 when it exists)") |
| parser.add_argument("--report", type=Path, help="write the whole-run report here too") |
| args = parser.parse_args(argv) |
| if not 1 <= args.workers <= 8: |
| parser.error("at most 8 workers and one decoder thread each") |
|
|
| root = args.root.resolve() |
| destination = (args.out or root / "doc/validation").resolve() |
| |
| |
| |
| |
| |
| |
| assert not args.views or destination != REVIEW_DIR.resolve(), ( |
| f"--views renders a selection, but {destination} holds the release's own review: " |
| "the pages, V1_1_VALIDATION.json and index.html that describe the sampled review " |
| "of the whole release; drop --views to render that sampling, or point --out " |
| "outside the release to look at one view") |
| declaration = MediaDeclaration.load(args.media_declaration) |
| runtime = args.mano_runtime |
| if runtime is None: |
| candidate = DATASET_ROOT / "tmp" / "runtime-v1.0" |
| runtime = candidate if (candidate / "models").is_dir() else None |
| if runtime is not None and not (Path(runtime) / "models").is_dir(): |
| parser.error(f"--mano-runtime {runtime} has no models/ directory") |
|
|
| release_sequences = sorted(path.name for path in (root / "data").iterdir() |
| if path.is_dir()) |
| if args.views: |
| views = [] |
| for token in args.views: |
| sequence, _, camera = token.partition("/") |
| view = root / "data" / sequence / camera |
| if not (view / "metainfo.json").is_file(): |
| parser.error(f"no such view: {token}") |
| views.append(view) |
| selected_sequences = sorted({view.parent.name for view in views}) |
| sampling = {"kind": "explicit", "views": args.views, |
| "rule": "explicit view list; no sampling applied"} |
| else: |
| facts = shippable(root, declaration) |
| selected_sequences = plan_views(facts, args.seed, args.per_policy) |
| views = [] |
| for sequence in selected_sequences: |
| views.extend(sorted(path.parent for path in |
| (root / "data" / sequence).glob("*/metainfo.json"))) |
| sampling = { |
| "seed": args.seed, |
| "rule": "sequences drawn uniformly inside each render policy, with the seed, from " |
| "the ones whose media this copy ships; every view of a drawn sequence is " |
| "rendered", |
| "per_policy": args.per_policy, |
| "sequences_in_release": len(release_sequences), |
| "sequences_shipping_media": len(facts), |
| "selections": [{"sequence": sequence, **facts[sequence]} |
| for sequence in selected_sequences], |
| } |
|
|
| start = time.monotonic() |
| |
| |
| |
| os.environ["PYTHONDONTWRITEBYTECODE"] = "1" |
| with ProcessPoolExecutor(max_workers=args.workers, |
| mp_context=multiprocessing.get_context("spawn")) as pool: |
| results = list(pool.map(render_task, |
| [(str(view), str(destination), str(root), |
| str(args.media_declaration), |
| None if runtime is None else str(runtime)) |
| for view in views])) |
|
|
| rendered = [entry for entry in results if entry.get("rendered")] |
| skipped = [entry for entry in results if not entry.get("rendered")] |
| scanned = [entry["mano_on_mask"] for entry in rendered if entry["mano_on_mask"]] |
| medians = [scan["in_frame_vertices_median_on_foreground"] for scan in scanned |
| if scan["in_frame_vertices_median_on_foreground"] is not None] |
| report = { |
| "review_kind": "全量后抽样", |
| "dataset_id": "ReInterHand", |
| "release_id": "shared-v1.1", |
| "views_requested": len(views), |
| "views_rendered": len(rendered), |
| "views_not_renderable": len(skipped), |
| "sequences": len(selected_sequences), |
| "sampling": sampling, |
| "media_declaration": { |
| "path": str(args.media_declaration), "origin": declaration.origin, |
| "materialised": (sorted(declaration.materialised) |
| if isinstance(declaration.materialised, set) |
| else declaration.materialised)}, |
| "mano_runtime": (str(runtime) if runtime is not None else None), |
| "wall_seconds": round(time.monotonic() - start, 3), |
| "decode_scope": DECODE_SCOPE, |
| "mano_on_mask": { |
| "views_scanned": len(scanned), |
| "frames_scanned": sum(scan["frames_scanned"] for scan in scanned), |
| "frames_the_mask_is_empty_on": sum(scan["frames_the_mask_is_empty_on"] |
| for scan in scanned), |
| "frames_used_for_coverage": sum(scan["frames_used_for_coverage"] |
| for scan in scanned), |
| "observed_value_range": { |
| "min": min((scan["observed_value_range"]["min"] for scan in scanned), |
| default=None), |
| "max": max((scan["observed_value_range"]["max"] for scan in scanned), |
| default=None)}, |
| "declared_value_ranges": sorted({tuple(scan["declared_value_range"]) |
| for scan in scanned |
| if scan.get("declared_value_range") |
| is not None}), |
| "in_frame_vertices_on_foreground": { |
| "views": len(medians), |
| "median_of_view_medians": (round(float(np.median(medians)), 6) |
| if medians else None), |
| "worst_view_median": min(medians) if medians else None, |
| "best_view_median": max(medians) if medians else None}, |
| "per_hand": {side: {key: sum(scan["per_hand"][side][key] for scan in scanned) |
| for key in ("frames_used", "joints_projected", |
| "joints_in_frame", "joints_on_foreground", |
| "vertices_in_frame", "vertices_on_foreground", |
| "frames_with_joints_in_frame")} |
| for side in ("left", "right")}, |
| "scope": PROJECTION_SCOPE}, |
| "reports": [{key: value for key, value in entry.items() if not key.startswith("_")} |
| for entry in results], |
| "scope": "post-full sampled views, read directly from v1.1 bundles and decoded from " |
| "the preserved media; evidence for human acceptance, not training input; " |
| "manual review pending", |
| } |
| if args.report: |
| save(args.report, report) |
| save(destination / "V1_1_VALIDATION.json", report) |
|
|
| index_css = ("body{font:16px sans-serif;max-width:1300px;margin:auto;padding:1rem;" |
| "background:#f5f7fa;color:#18232f;line-height:1.5}" |
| ".legend{background:#eef3fa;border-left:3px solid #4a76a8;padding:.6rem;" |
| "font-size:.9rem;max-width:1000px}.swatch{border:1px solid #b9c3d0}" |
| "table{border-collapse:collapse;width:100%}td,th{border:1px solid #ccd3de;" |
| "padding:4px 8px;text-align:left;font-size:.85rem}" |
| ".note{background:#fff7e6;border-left:3px solid #e0a800;padding:.6rem;" |
| "font-size:.9rem;max-width:1000px}") |
| rows = [] |
| for entry in sorted(rendered, key=lambda item: (item["sequence_id"], item["camera_id"])): |
| scan = entry["mano_on_mask"] |
| median = scan["in_frame_vertices_median_on_foreground"] if scan else None |
| hands = (entry["series"].get("mano") or {}).get("valid_true_per_series") |
| value_range = (f"{scan['observed_value_range']['min']}–" |
| f"{scan['observed_value_range']['max']}" if scan else "—") |
| rows.append("<tr><td><a href=\"" + html.escape(entry["_page"], quote=True) + "\">" |
| + html.escape(entry["view"]) + "</a></td><td>" |
| + html.escape(entry["split"]) + "</td><td>" |
| + html.escape(str(entry["render_cell"].get("background_policy"))) |
| + "</td><td>" + html.escape(entry["view_type"]) + "</td><td>" |
| + str(entry["num_frames"]) + "</td><td>" |
| + str(len(entry["selected_frames"])) + "</td><td>" |
| + ("/".join(str(count) for count in hands) + f" / {entry['num_frames']}" |
| if hands else "—") |
| + "</td><td>" |
| + " / ".join(str(item["bytes"] // 1024) + " KiB" |
| for item in entry["media"]) |
| + "</td><td>" + (f"{median:g}" if median is not None else "—") |
| + "</td><td>" + value_range + "</td></tr>") |
| skipped_rows = "".join( |
| "<li>" + html.escape(entry["view"]) + " — " + html.escape(entry["reason"]) + "</li>" |
| for entry in skipped) |
| index = ('<!doctype html><html lang="zh"><meta charset="utf-8">' |
| "<title>ReInterHand shared-v1.1 review</title><style>" + index_css + "</style>" |
| "<h1>ReInterHand shared-v1.1 全量后抽样人工复查</h1>" |
| "<p>数值按字节一致（CONTRACT §6）；媒体不重新编码。抽样规则与种子见 " |
| "V1_1_VALIDATION.json，本页所列视图即全部入选视图：" + str(len(rendered)) |
| + " 个视图 / " + str(len(selected_sequences)) + " 段序列。逐字段字节验收见 " |
| "<code>verify.py</code>，全树结构校验见 <code>validate.py</code>，含媒体的完整" |
| "读取见 <code>read_sequence.py</code>，证据留档在发布树外的 " |
| "<code>tmp/reinterhand-tools/</code>。</p>" + colour_legend() |
| + "<p>每页只解码该视图抽样的帧 RGB；<b>但 MANO↔mask 覆盖扫描跑的是每个入选" |
| "视图的全部帧</b>（mask 整段流式解一遍），全量结果见 V1_1_VALIDATION.json 的 " |
| "<code>mano_on_mask</code>。表里的覆盖中位是「左右手合计的画内顶点落在 mask " |
| "前景里的比例」的中位；mask 无左右手身份，故不分手断言。「MANO 有效帧」列是" |
| "左右手各自 valid=true 的帧数（分母为总帧数）——本发布里逐帧有效并非普遍成立，" |
| "ego 视图尤其稀疏。</p>" |
| + "<table><tr><th>视图</th><th>split</th><th>背景策略</th><th>类型</th>" |
| "<th>帧数</th><th>本页抽样帧</th><th>MANO 有效帧 左/右</th>" |
| "<th>媒体（rgb / mask）</th><th>前景覆盖中位</th><th>mask 实测值域</th></tr>" |
| + "".join(rows) + "</table>" |
| + ('<h2>未渲染的视图</h2><p>这些视图的媒体在本工作副本里按声明缺失，' |
| "因此无法解码；这是预期，不是失败。</p><ul>" + skipped_rows + "</ul>" |
| if skipped else "") |
| + '<ul><li><a href="../CONTRACT.md">CONTRACT.md</a></li>' |
| '<li><a href="../RAW_MAPPING.md">RAW_MAPPING.md</a></li>' |
| '<li><a href="../FULL_MIGRATION_SUMMARY.json">FULL_MIGRATION_SUMMARY.json</a>' |
| '</li><li><a href="V1_1_VALIDATION.json">V1_1_VALIDATION.json</a></li></ul>' |
| '<ul>' + "".join( |
| '<li><a href="' + html.escape(name, quote=True) + '">' |
| + html.escape(name) + "</a></li>" |
| for name in sorted(path.name for path in destination.glob("*.html") |
| if path.name != "index.html")) |
| + "</ul></html>") |
| destination.mkdir(parents=True, exist_ok=True) |
| (destination / "index.html").write_text(index, encoding="utf-8") |
| print("RENDER_DONE", len(rendered), "rendered,", len(skipped), "not renderable,", |
| round(report["wall_seconds"], 2), "seconds ->", destination / "index.html", |
| flush=True) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
