| |
| """Derive FreiHAND training labels: exactly 255 -> 255; every other value -> 0. |
| |
| Writes a new candidate tree, never the input. In the unchanged warehouse schema, |
| 0 means unassigned (not a newly asserted background category). Evaluation and all |
| non-segment annotations remain byte-identical. No downloads, raw, models or GPU. |
| """ |
| import argparse |
| from contextlib import closing |
| import copy |
| from datetime import datetime, timezone |
| import hashlib |
| import json |
| from pathlib import Path |
| import shutil |
| import subprocess |
| import tempfile |
| import time |
|
|
| import numpy as np |
| import torch |
|
|
| try: |
| from render_full_random_review import decode_frames, probe_video |
| except ModuleNotFoundError as exc: |
| if exc.name != "render_full_random_review": |
| raise |
| from updated.render_full_random_review import decode_frames, probe_video |
|
|
| REPORT = "doc/validation/segment-eq255-20261014.json" |
| RULE = "output = 255 if decoded source intensity == 255 else 0; 0 = unassigned" |
| METHOD = "User-approved 2026-10-14 FreiHAND training-only exact-255 selection; " + RULE |
| LABEL = {"mask_value": 255, "category_id": "hand", "entity_id": "hand_right", |
| "part_id": None, "source_instance_id": None, |
| "source_attributes": {"selected_source_intensity": 255}} |
| REMOVED_KEYS = ("value_range", "normalization_scale", "foreground_category", "entity_id") |
| TRAIN_COUNTS = {f"training_{start:08d}": min(4096, 130240 - start) for start in range(0, 130240, 4096)} |
| FRAME_COUNTS = {**TRAIN_COUNTS, "evaluation_00000000": 3960} |
|
|
|
|
| def scope_sequences(scope): |
| training = sorted(TRAIN_COUNTS) |
| if scope == "pilot": |
| return sorted([training[0], training[-1], "evaluation_00000000"]) |
| if scope == "all_33_shards": |
| return sorted(FRAME_COUNTS) |
| raise ValueError("Unknown scope") |
|
|
|
|
| def check_scope(source, report): |
| expected = scope_sequences(report["scope"]) |
| if report["sequences"] != expected: |
| raise ValueError("Missing, duplicated or unexpected shards for declared scope") |
| if sorted(p.name for p in (source / "data").iterdir() if p.is_dir()) != sorted(FRAME_COUNTS): |
| raise ValueError("Source is not the full original 33-shard release") |
| for seq in expected: |
| meta = read_json(source / "data" / seq / "camera/metainfo.json") |
| if meta["num_frames"] != FRAME_COUNTS[seq] or meta["camera"]["image_size"] != [224, 224]: |
| raise ValueError(f"Wrong fixed-source frame count or dimensions: {seq}") |
|
|
|
|
| def check_totals(report, views): |
| expected = {"training_frames": sum(v["frames"] for v in views), |
| "pixels_checked": sum(v["pixels_checked"] for v in views), |
| "empty_frames": sum(len(v["empty_after_selection_frames"]) for v in views)} |
| if any(report.get(k) != value for k, value in expected.items()): |
| raise ValueError("Report totals disagree with complete decoded views") |
|
|
|
|
| def sha(path): |
| with Path(path).open("rb") as f: |
| return hashlib.file_digest(f, "sha256").hexdigest() |
|
|
|
|
| def read_json(path): |
| return json.loads(Path(path).read_text(encoding="utf-8")) |
|
|
|
|
| def write_json(path, value): |
| Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n", encoding="utf-8") |
|
|
|
|
| def inventory(root): |
| return {p.relative_to(root).as_posix(): sha(p) for p in sorted(root.rglob("*")) if p.is_file()} |
|
|
|
|
| def verify_sums(root): |
| rows = {} |
| for line in (root / "doc/FILE_SHA256SUMS").read_text().splitlines(): |
| digest, name = line.split(" ", 1) |
| p = root / name |
| if name in rows or not p.resolve().is_relative_to(root.resolve()) or sha(p) != digest: |
| raise ValueError(f"Invalid or changed checksum entry: {name}") |
| rows[name] = digest |
| actual = {p.relative_to(root).as_posix() for p in root.rglob("*") if p.is_file()} |
| if actual != set(rows) | {"doc/FILE_SHA256SUMS"}: |
| raise ValueError("File set differs from FILE_SHA256SUMS") |
| rows["doc/FILE_SHA256SUMS"] = sha(root / "doc/FILE_SHA256SUMS") |
| return rows |
|
|
|
|
| def selected(mask): |
| if mask.dtype not in (np.uint8, np.uint16) or mask.ndim != 2 or np.any(mask > 255): |
| raise ValueError("Expected a decoded uint8-range, single-channel training mask") |
| return np.where(mask == 255, 255, 0).astype(np.uint8) |
|
|
|
|
| def label_row(index, has_hand): |
| return {"frame_index": index, "labels": [copy.deepcopy(LABEL)] if has_hand else []} |
|
|
|
|
| def new_metadata(meta): |
| meta = copy.deepcopy(meta) |
| seg = meta["components"]["segment"] |
| if (meta["dataset_id"] != "FreiHAND" or meta["split"] != "train" or |
| seg["schema_id"] != "segment/foreground_intensity/v1" or |
| seg.get("entity_id") != "hand_right" or seg["storage"]["pixel_format"] != "gray"): |
| raise ValueError("Only original FreiHAND training foreground-intensity masks may be converted") |
| seg["schema_id"] = "segment/uint16_labels/v1" |
| seg["mapping_ref"] = "annotation/segment/instances.jsonl" |
| for key in REMOVED_KEYS: |
| del seg[key] |
| seg["provenance"] = {"kind": "derived", "method": METHOD} |
| |
| |
| seg["storage"]["encoder_parameters"] = {"level": 3, "threads": 1, "input_pixel_format": "gray"} |
| seg["storage"]["decoder"] = "FFmpeg native gray; uint8 to uint16 widening, no value scaling" |
| return meta |
|
|
|
|
| def check_metadata(old, new): |
| old_other, new_other = copy.deepcopy(old), copy.deepcopy(new) |
| a = old_other["components"].pop("segment") |
| b = new_other["components"].pop("segment") |
| if old_other != new_other: |
| raise ValueError("Metadata outside components.segment changed") |
| allowed = set(REMOVED_KEYS) | {"schema_id", "mapping_ref", "provenance", "storage"} |
| if {k: v for k, v in a.items() if k not in allowed} != {k: v for k, v in b.items() if k not in allowed}: |
| raise ValueError("Unapproved segment metadata change") |
| if (any(k in b for k in REMOVED_KEYS) or b["schema_id"] != "segment/uint16_labels/v1" or |
| b["mapping_ref"] != "annotation/segment/instances.jsonl" or |
| b["provenance"] != {"kind": "derived", "method": METHOD}): |
| raise ValueError("Wrong derived label declaration") |
| for key in set(a["storage"]) | set(b["storage"]): |
| if key not in {"encoder_parameters", "decoder"} and a["storage"].get(key) != b["storage"].get(key): |
| raise ValueError(f"Unapproved storage change: {key}") |
| expected_storage = new_metadata(old)["components"]["segment"]["storage"] |
| for key in ("decoder", "encoder_parameters"): |
| if b["storage"].get(key) != expected_storage[key]: |
| raise ValueError(f"Wrong derived gray8 storage declaration: {key}") |
|
|
|
|
| def encode_frames(path, frames, width, height): |
| command = ["ffmpeg", "-nostdin", "-v", "error", "-n", "-f", "rawvideo", "-pixel_format", "gray", |
| "-video_size", f"{width}x{height}", "-framerate", "1", "-i", "pipe:0", "-an", |
| "-c:v", "ffv1", "-level", "3", "-threads", "1", "-pix_fmt", "gray", str(path)] |
| with tempfile.TemporaryFile() as errors: |
| p = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=errors) |
| try: |
| for frame in frames: |
| if frame.dtype != np.uint8 or frame.shape != (height, width): |
| raise ValueError("Unexpected encoder input shape or dtype") |
| p.stdin.write(frame.tobytes()) |
| p.stdin.close() |
| if p.wait() != 0: |
| errors.seek(0) |
| raise RuntimeError(errors.read().decode(errors="replace")) |
| finally: |
| if not p.stdin.closed: |
| p.stdin.close() |
| if p.poll() is None: |
| p.terminate() |
| p.wait(timeout=10) |
|
|
|
|
| def convert_view(source, target): |
| meta = read_json(source / "metainfo.json") |
| updated = new_metadata(meta) |
| count = meta["num_frames"] |
| width, height = meta["camera"]["image_size"] |
| seg = meta["components"]["segment"] |
| probe_video(source / seg["data_ref"], seg["storage"], [width, height]) |
| output = target / seg["data_ref"] |
| partial = output.with_name("mask.eq255-partial.mkv") |
| mapping = target / updated["components"]["segment"]["mapping_ref"] |
| with mapping.open("x", encoding="utf-8") as rows, closing( |
| decode_frames(source / seg["data_ref"], "gray", width, height, count)) as stream: |
| def frames(): |
| for index, old in enumerate(stream): |
| out = selected(old) |
| rows.write(json.dumps(label_row(index, bool(np.any(out))), separators=(",", ":")) + "\n") |
| yield out |
| encode_frames(partial, frames(), width, height) |
| partial.replace(output) |
| write_json(target / "metainfo.json", updated) |
|
|
|
|
| def verify_view(source, target): |
| oldmeta, newmeta = read_json(source / "metainfo.json"), read_json(target / "metainfo.json") |
| check_metadata(oldmeta, newmeta) |
| count = oldmeta["num_frames"] |
| width, height = oldmeta["camera"]["image_size"] |
| oldseg, newseg = oldmeta["components"]["segment"], newmeta["components"]["segment"] |
| for base, comp in ((source, oldseg), (target, newseg)): |
| probe_video(base / comp["data_ref"], comp["storage"], [width, height]) |
| valid = torch.load(target / newseg["valid_ref"], map_location="cpu", weights_only=True) |
| if valid.dtype != torch.bool or tuple(valid.shape) != (count,): |
| raise ValueError("Wrong standalone mask validity") |
| if sha(source / oldseg["valid_ref"]) != sha(target / newseg["valid_ref"]): |
| raise ValueError("Mask validity changed") |
| histogram = np.zeros(256, dtype=np.int64) |
| empty = [] |
| with (target / newseg["mapping_ref"]).open() as mappings, closing( |
| decode_frames(source / oldseg["data_ref"], "gray", width, height, count)) as oldframes, closing( |
| decode_frames(target / newseg["data_ref"], "gray", width, height, count)) as newframes: |
| for i, (old, new) in enumerate(zip(oldframes, newframes, strict=True)): |
| |
| if np.any((new != 0) & (new != 255)) or not np.array_equal(new == 255, old == 255): |
| raise ValueError(f"Selection/roundtrip mismatch: {target}, frame {i}") |
| has_hand = bool(np.any(new == 255)) |
| row = json.loads(mappings.readline()) |
| if row != label_row(i, has_hand): |
| raise ValueError(f"Wrong mapping or frame order: {target}, frame {i}") |
| histogram += np.bincount(old.ravel(), minlength=256) |
| if not has_hand: |
| empty.append(i) |
| if mappings.read().strip(): |
| raise ValueError("Extra mapping rows") |
| return {"sequence": source.parent.name, "frames": count, |
| "pixels_checked": count * width * height, "source_histogram": histogram.tolist(), |
| "retained_255_pixels": int(histogram[255]), "discarded_1_254_pixels": int(histogram[1:255].sum()), |
| "empty_after_selection_frames": empty, "valid_frames": int(valid.sum()), |
| "all_pixels_match_exact_255_rule": True} |
|
|
|
|
| def check_frozen(source, target, sequences, source_hashes): |
| expected_data = {n for n in source_hashes if n.startswith("data/") and n.split("/")[1] in sequences} |
| changes = {f"data/{seq}/camera/{rel}" for seq in sequences if seq.startswith("training_") |
| for rel in ("metainfo.json", "annotation/segment/mask.mkv")} |
| added = {f"data/{seq}/camera/annotation/segment/instances.jsonl" for seq in sequences if seq.startswith("training_")} |
| actual = {p.relative_to(target).as_posix() for p in (target / "data").rglob("*") if p.is_file()} |
| if actual != expected_data | added or added & expected_data: |
| raise ValueError("Candidate data paths changed outside approved additions") |
| for name in sorted(expected_data - changes): |
| if sha(target / name) != source_hashes[name]: |
| raise ValueError(f"Frozen data changed: {name}") |
| if inventory(source) != source_hashes: |
| raise ValueError("Original input tree changed") |
| return {"frozen_data_files_verified": len(expected_data - changes), |
| "changed_data_files": sorted(changes), "added_data_files": sorted(added), |
| "original_source_unchanged": True, "evaluation_unchanged": "evaluation_00000000" in sequences} |
|
|
|
|
| def prepend(path, text): |
| path.write_text(text + path.read_text(encoding="utf-8"), encoding="utf-8") |
|
|
|
|
| def write_docs(target, report): |
| summary = ("# 2026-10-14 训练 segment 精确255派生候选\n\n" |
| "本候选不是单纯的 v1.0→v1.1 无损重打包。用户新增确认：训练原mask值255保留为255，0–254设为0；" |
| "统一标签规范中0仍为unassigned，不能将其声明为已确认背景，也不新增0的JSON映射。" |
| "255通过每帧instances.jsonl映射到hand/hand_right；不推测手指部位。" |
| "评估集原区域码与映射全部保留；其他annotation、RGB、帧表、split和mask_valid原字节不变。\n\n" |
| "这是一次会丢失中间强度的、按用户规则生成的标签派生。只保证保留集合恰为原值255，" |
| "不宣称边界更准确或原手前景面积不变。过滤后全0的样本单列在机器报告中，不删图、不改valid；" |
| "全0表示没有已分配手区域，不证明原图没有手。无SAM3、raw、新下载或上传。\n\n" |
| f"本次范围：{report['scope']}，训练{report['training_frames']}张，" |
| f"逐像素对照{report['pixels_checked']}个像素，过滤后空mask {report['empty_frames']}张。" |
| "完整机械校验与逐分片统计见[本次报告](validation/segment-eq255-20261014.json)。\n\n" |
| "当前检查入口是 `script/segment_eq255.py verify --source /path/to/original/shared-v1.1 --release .`。" |
| "旧validate_freihand.py和旧媒体校验是灰度原版的专用工具，不用于本派生候选；保留以追溯原迁移。" |
| "下方旧报告、doc/validation旧图和旧验收仅为原灰度版本的历史证据，不代表本次派生结果。\n\n" |
| "## 以下为此前无损存储迁移记录\n\n") |
| prepend(target / "doc/MIGRATION_REPORT.md", summary) |
| prepend(target / "doc/CONTRACT.md", "# 本候选的训练segment特定补充（2026-10-14）\n\n" |
| "用户新增确认以精确255选择替代FreiHAND训练强度存储：255→255，0–254→0。" |
| "采用已有segment/uint16_labels/v1及每帧instances.jsonl；0=unassigned，255=hand/hand_right。" |
| "FFV1 gray8存储0/255，读取精确拓宽至uint16，不缩放。此补充仅替代历史合同中本训练集保留中间灰度的约定，" |
| "不改变通用保留码、schema.json、评估集或其他标注。归档规范原件未改。" |
| "派生有损信息与验收范围见[MIGRATION_REPORT.md](MIGRATION_REPORT.md)。\n\n") |
| prepend(target / "doc/RAW_MAPPING.md", "# 当前训练mask派生映射（2026-10-14）\n\n" |
| "实际输入为已验收shared-v1.1的训练FFV1灰度，不读取raw。解码值255→标签255；0–254→标签0（unassigned）。" |
| "255映射category_id=hand、entity_id=hand_right、part_id=null、source_instance_id=null；" |
| "source_attributes.selected_source_intensity=255是原强度，不能当作源实例ID。" |
| "每帧有255时写此标签，无255时labels=[]。评估集的20/30等是区域码，绝不套用训练强度规则。" |
| "下面原始raw→shared映射是历史上游说明，原件不改；当前派生规则优先适用于训练segment。\n\n") |
| prepend(target / "script/README.md", "# 当前精确255候选的使用入口\n\n" |
| "`segment_eq255.py`只处理已有FreiHAND训练强度，不读取raw、不下载、不运行模型。" |
| "依赖Python、NumPy、PyTorch、FFmpeg及同目录原媒体解码工具。\n\n" |
| "```bash\npython -B script/segment_eq255.py verify --source /path/to/original/shared-v1.1 --release .\n" |
| "sha256sum -c doc/FILE_SHA256SUMS\n" |
| "python -B script/segment_eq255.py convert --source /path/to/original/shared-v1.1 --output /new/path/shared-v1.1 --pilot\n" |
| "# 去掉--pilot才覆盖全部33分片；输出必须是新目录。\n```\n\n" |
| "读取mask时gray8只拓宽uint16，不归一化为旧强度；0未分配、255右手。" |
| "未来训练把0当负样本还是不监督需要在任务读取器明确规定，不由这次存储编码暗中决定。" |
| "只使用本入口验证派生候选；下面的旧专用验证和预览命令仍要求原灰度训练mask，不适用于当前候选。\n\n" |
| "## 原无损迁移工具的历史说明\n\n") |
|
|
|
|
| def convert(source, target, pilot=False): |
| torch.set_num_threads(1) |
| source, target = source.resolve(), target.resolve() |
| if target.exists() or target.is_relative_to(source) or source.is_relative_to(target): |
| raise ValueError("Output must be a new tree outside the original input") |
| started = time.monotonic() |
| source_hashes = verify_sums(source) |
| scope = "pilot" if pilot else "all_33_shards" |
| sequences = scope_sequences(scope) |
| check_scope(source, {"scope": scope, "sequences": sequences}) |
| target.mkdir(parents=True) |
| for part in ("doc", "script"): |
| shutil.copytree(source / part, target / part) |
| for seq in sequences: |
| shutil.copytree(source / "data" / seq, target / "data" / seq) |
| results = [] |
| for seq in sequences: |
| if not seq.startswith("training_"): |
| continue |
| a, b = source / "data" / seq / "camera", target / "data" / seq / "camera" |
| convert_view(a, b) |
| results.append(verify_view(a, b)) |
| print(f"verified {seq}: {results[-1]['frames']} frames; empty={len(results[-1]['empty_after_selection_frames'])}", flush=True) |
| frozen = check_frozen(source, target, sequences, source_hashes) |
| report = {"status": "candidate_machine_verified", "scope": scope, |
| "created_utc": datetime.now(timezone.utc).isoformat(), "rule": RULE, |
| "zero_semantics": "unassigned", "hand_label": LABEL, "source_files_sha256": source_hashes, |
| "sequences": sequences, "views": results, **frozen, |
| "training_frames": sum(r["frames"] for r in results), |
| "pixels_checked": sum(r["pixels_checked"] for r in results), |
| "empty_frames": sum(len(r["empty_after_selection_frames"]) for r in results), |
| "elapsed_seconds": round(time.monotonic() - started, 2), |
| "quality_claim": "Exact chosen rule, not independently verified hand boundaries", |
| "human_review": "not_claimed", "independent_agent_review": "not_claimed"} |
| write_docs(target, report) |
| shutil.copy2(Path(__file__), target / "script/segment_eq255.py") |
| test = Path(__file__).with_name("test_segment_eq255.py") |
| if test.exists(): |
| shutil.copy2(test, target / "script/test_segment_eq255.py") |
| write_json(target / REPORT, report) |
| files = inventory(target) |
| (target / "doc/FILE_SHA256SUMS").write_text("".join(f"{digest} {name}\n" for name, digest in sorted(files.items()) |
| if name != "doc/FILE_SHA256SUMS"), encoding="utf-8") |
| verify_sums(target) |
| print(json.dumps({k: report[k] for k in ("status", "scope", "training_frames", "pixels_checked", "empty_frames", "elapsed_seconds")}), flush=True) |
|
|
|
|
| def verify(source, release): |
| torch.set_num_threads(1) |
| report = read_json(release / REPORT) |
| if report["rule"] != RULE or report["zero_semantics"] != "unassigned": |
| raise ValueError("Wrong derivation policy") |
| check_scope(source, report) |
| verify_sums(release) |
| frozen = check_frozen(source, release, report["sequences"], report["source_files_sha256"]) |
| if any(report[k] != v for k, v in frozen.items()): |
| raise ValueError("Frozen-file receipt differs from recomputed result") |
| recomputed = [] |
| for seq in report["sequences"]: |
| if seq.startswith("training_"): |
| recomputed.append(verify_view(source / "data" / seq / "camera", release / "data" / seq / "camera")) |
| print(f"reverified {seq}", flush=True) |
| if recomputed != report["views"]: |
| raise ValueError("Recomputed per-frame results differ") |
| check_totals(report, recomputed) |
| print(json.dumps({"status": "source_candidate_readback_passed", "training_frames": sum(v['frames'] for v in recomputed), |
| "original_source_unchanged": True, "other_annotations_unchanged": True}), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser(description=__doc__) |
| sub = parser.add_subparsers(dest="command", required=True) |
| p = sub.add_parser("convert") |
| p.add_argument("--source", type=Path, required=True) |
| p.add_argument("--output", type=Path, required=True) |
| p.add_argument("--pilot", action="store_true") |
| p = sub.add_parser("verify") |
| p.add_argument("--source", type=Path, required=True) |
| p.add_argument("--release", type=Path, required=True) |
| args = parser.parse_args() |
| if args.command == "convert": |
| convert(args.source, args.output, args.pilot) |
| else: |
| verify(args.source, args.release) |
|
|
