Add P1C1 metadata + SMPL-X + previews

LICENSE

@@ -0,0 +1,39 @@
+DREAMS-AVATAR dataset licence (research only)
+=============================================
+
+PROVISIONAL. This text states the intent under which the data is published; the
+maintainer may replace it with a formal licence.
+
+1. Permitted use
+   The videos, calibration, SMPL-X registrations and preview images in this
+   repository are made available for NON-COMMERCIAL ACADEMIC RESEARCH ONLY.
+
+2. Not permitted
+   a. Commercial use of any kind.
+   b. Redistribution of the imagery (videos, frames, preview sheets), in whole or
+      in part, outside this repository.
+   c. Any use intended to identify, re-identify, impersonate, or generate
+      likenesses of the captured subjects outside a research context.
+   d. Training or evaluating biometric identification or surveillance systems.
+
+3. Derived data
+   SMPL-X parameters, meshes and renderings derived from this data inherit these
+   terms.
+
+4. SMPL-X body model
+   The SMPL-X model is NOT included in this repository. It must be obtained from
+   https://smpl-x.is.tue.mpg.de and remains subject to the Max Planck Institute
+   licence. Nothing here grants any right to that model.
+
+5. Source captures
+   The raw multiview captures originate from the DEGAS project. Their original
+   capture terms continue to apply and take precedence over this file where they
+   are stricter.
+
+6. Subject removal
+   A captured subject may request removal of their capture by opening a
+   discussion on this repository; the maintainer will remove it.
+
+7. No warranty
+   Provided "as is", without warranty of any kind. The registrations are the
+   output of an automatic tracker and contain errors.

README.md

@@ -0,0 +1,284 @@
+---
+pretty_name: DREAMS-AVATAR
+license: other
+license_name: dreams-avatar-research-only
+license_link: LICENSE
+language:
+- en
+task_categories:
+- image-to-3d
+- keypoint-detection
+tags:
+- 3d
+- avatar
+- smplx
+- multiview
+- human-pose-estimation
+- motion-capture
+- degas
+size_categories:
+- n<1K
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: previews/**
+---
+
+# DREAMS-AVATAR
+
+**DEGAS multiview captures, re-registered to pure SMPL-X.**
+
+32 calibrated, matted camera views of a full-body performance, with one SMPL-X body fitted
+to all views at once by the
+[Holistic-Multiview-Tracker](https://github.com/initialneil/Holistic-Multiview-Tracker)
+(branch `reusable-v0.2.0`): 300 shape coefficients, 100 expression coefficients, jaw and
+both eyes, hands as free 45-dim axis-angle (`use_pca=False`).
+
+3-panel QC on three held-out views of the same instant, `raw | omni-600 landmarks | SMPL-X overlay`:
+
+![P1C1 f1400 cam03](https://huggingface.co/datasets/initialneil/DREAMS-AVATAR/resolve/main/assets/showcase/P1C1_f00001400_cam03.jpg)
+![P1C1 f1400 cam06](https://huggingface.co/datasets/initialneil/DREAMS-AVATAR/resolve/main/assets/showcase/P1C1_f00001400_cam06.jpg)
+![P1C1 f1400 cam12](https://huggingface.co/datasets/initialneil/DREAMS-AVATAR/resolve/main/assets/showcase/P1C1_f00001400_cam12.jpg)
+
+Open hand, splayed fingers, front torso: the hands are read from RGB (WiLoR) rather than
+zeroed, the face is driven by dense MediaPipe landmarks so the 100 expression coefficients
+are actually observable, and the overlay is the *same* body seen from every camera.
+
+Browse the fitted result frame by frame in the **Data** tab above: one row per
+(capture x every 100th frame), each carrying the 32-view QC contact sheet.
+
+---
+
+## What is in here
+
+| | |
+|---|---|
+| Captures | 10 (`P1C1`, `P1C2`, `P2C1`, `P2C2`, `P3C1`, `P3C2`, `P4C1`, `P4C2`, `P5C2`, `P6C2`) |
+| Subjects | 6 (`P1`..`P6`) |
+| Cameras per capture | 32, hardware-synchronised, calibrated, static |
+| Image size | 2048 x 1500 RGB, matted (black background) plus a per-pixel alpha matte |
+| Frame rate | 22 fps |
+| Registration | pure SMPL-X, neutral, `num_betas=300`, `num_expression_coeffs=100`, `use_pca=False`, `flat_hand_mean=False`, `use_face_contour=True` |
+| Per capture | ~2 GiB of video + one consolidated `smplx.npz` + calibration + QC preview |
+
+### How the captures are meant to be used
+
+`Cy` is the session: **`C1` is the training capture, `C2` is the test capture** of the same
+subject.
+
+* **`P1`..`P4`** ship **both** sessions, so each of those subjects has a train capture and a
+  held-out test capture.
+* **`P5` and `P6`** are for **cross-reenactment only**: only their **`C2`** captures are
+  included, as driving sequences to animate an avatar trained on somebody else. There are
+  no `P5C1` / `P6C1` here (`P5C1` does not exist at all; `P6C1` is deliberately excluded).
+
+| subject | C1 (train) | C2 (test / driving) | role |
+|---|---|---|---|
+| P1 | yes | yes | train + test |
+| P2 | yes | yes | train + test |
+| P3 | yes | yes | train + test |
+| P4 | yes | yes | train + test |
+| P5 | not included | yes | cross-reenact driving only |
+| P6 | not included | yes | cross-reenact driving only |
+
+### Upload status
+
+| Capture | videos | SMPL-X | frames |
+|---|---|---|---|
+| P1C1 | yes | yes | 1836 |
+| the other 9 | pending | pending | |
+
+Captures are tracked and uploaded one at a time; this table is updated as each lands.
+
+---
+
+## Layout
+
+```
+data/<PxCy>/
+  videos/cam00.mp4 ... cam31.mp4   32 matted H.264 videos, 4096x1500 side-by-side
+  smplx.npz                        our SMPL-X registration, all frames stacked
+  cameras.json                     the capture calibration (32 rigs x 1 camera)
+  capture.json                     machine-readable capture card (sizes, conventions)
+  preview.jpg                      one 32-view QC contact sheet
+previews/
+  <PxCy>_f<frame:08d>.jpg          QC contact sheets, one per sampled frame
+  metadata.jsonl                   the table rendered in the Data tab
+assets/showcase/                   the 3-panel images used above
+scripts/
+  load_capture.py                  minimal reader: videos + smplx + cameras
+  prepare_training.py              decode into an AvatarReX / DEGAS training layout
+  upload_capture.sh                packaging + upload pipeline (for maintainers)
+```
+
+### `videos/camNN.mp4`
+
+Each file is **4096 x 1500**: the **left half is the matted RGB image**, the **right half
+is the alpha matte** (replicated over 3 channels). The calibration `(fx, fy, cx, cy, w=2048,
+h=1500)` refers to the left half.
+
+Camera index `NN` corresponds to `cameras.json -> rigs[NN].cameras[0]`.
+
+### `smplx.npz`
+
+Every per-frame fit stacked over time, bit-identical to what the tracker wrote (no
+downcasting, no re-quantisation):
+
+| key | shape | notes |
+|---|---|---|
+| `frames` | `(T,)` int32 | GT frame id, 1-based. This is the index everything else is keyed by. |
+| `video_frames` | `(T,)` int32 | `frames - 1`, the 0-based frame index inside `camNN.mp4` |
+| `global_orient` | `(T,3)` float32 | axis-angle, world frame |
+| `body_pose` | `(T,63)` float32 | 21 joints, axis-angle |
+| `jaw_pose` | `(T,3)` float32 | |
+| `leye_pose`, `reye_pose` | `(T,3)` float32 | driven by the MediaPipe iris landmarks |
+| `left_hand_pose`, `right_hand_pose` | `(T,45)` float32 | full axis-angle, **not** PCA |
+| `betas` | `(T,300)` float32 | shape (constant over a capture) |
+| `expression` | `(T,100)` float32 | |
+| `transl` | `(T,3)` float32 | |
+| `joints` | `(T,144,3)` float32 | SMPL-X joints in world coordinates, shipped for convenience |
+| `view_ids` | `(T,Vmax)` int16 | which cameras the fit actually used at that frame, `-1` padded |
+| `n_views`, `n_face_views` | `(T,)` int16 | views used / views with an accepted face crop |
+| `stages` | `(T,)` str | fit schedule at that frame (`A+B+C+F` cold start, `W` warm) |
+| `smplx_kwargs` | scalar str | JSON, the exact `smplx.SMPLX(...)` constructor arguments |
+| `meta` | scalar str | JSON, capture-level provenance |
+
+Vertices are **not** shipped (they are a deterministic function of the parameters, and
+would add ~200 MB per capture). Rebuild them with the `smplx_kwargs` above; the SMPL-X body
+model itself must be obtained from [smpl-x.is.tue.mpg.de](https://smpl-x.is.tue.mpg.de)
+under its own licence.
+
+### Conventions you need to get right
+
+**Frames.** `frame` always means the GT frame id in `smplx.npz["frames"]` (1-based). The
+matching video frame index is `frame - 1`: the mp4s hold `N-1` frames against the capture's
+`N` GT frames, so GT frame 0 has no image. Getting this wrong fits every frame against its
+neighbour and is nearly invisible in a static pose.
+
+**Cameras.** `cameras.json` is nested (`rigs[i].cameras[0]`) and its world is **Y-down**,
+while SMPL-X is Y-up. The registration lives in the flipped, Y-up world, so:
+
+```python
+A     = np.diag([1.0, -1.0, -1.0])          # world_flip
+K     = [[fx, 0, cx], [0, fy, cy], [0, 0, 1]]
+R_w2c = R @ A
+t_w2c = -R @ c                              # c = camera centre as stored in cameras.json
+x_cam = R_w2c @ x_world + t_w2c
+uv    = (K @ x_cam)[:2] / x_cam[2]
+```
+
+`scripts/load_capture.py` does exactly this; `scripts/prepare_training.py` bakes the flip
+into the emitted `calibration_full.json` so downstream training code never sees it.
+
+Distortion `D` is all-zero for these captures (the images ship undistorted).
+
+---
+
+## Quickstart
+
+```bash
+pip install huggingface_hub numpy opencv-python
+huggingface-cli download initialneil/DREAMS-AVATAR --repo-type dataset \
+    --include "data/P1C1/*" "scripts/*" --local-dir ./DREAMS-AVATAR
+```
+
+```python
+import sys; sys.path.append("DREAMS-AVATAR/scripts")
+from load_capture import Capture
+
+cap = Capture("DREAMS-AVATAR/data/P1C1")
+print(cap)                                    # 32 cams, 1836 frames, 2048x1500
+
+rgb, alpha = cap.read_frame("cam03", frame=1400)   # (1500,2048,3), (1500,2048)
+uv = cap.cameras["cam03"].project(cap.joints(frame=1400))   # (144,2) pixels
+
+params = cap.smplx_params(frame=1400)         # 10 arrays, each (1, D)
+print(cap.smplx_forward_kwargs)               # feed straight into smplx.SMPLX(...)
+```
+
+Rebuilding the mesh:
+
+```python
+import smplx, torch
+m = smplx.SMPLX(model_path="<your SMPLX dir>", batch_size=1, **cap.smplx_forward_kwargs)
+out = m(**{k: torch.from_numpy(v) for k, v in cap.smplx_params(1400).items()})
+verts = out.vertices[0].numpy()               # (10475,3) in the same world as the cameras
+```
+
+Sequential decode is far cheaper than seeking:
+
+```python
+for frame, rgb, alpha in cap.iter_frames("cam03", start=1, end=200):
+    ...
+```
+
+## Preparing avatar-training input
+
+`scripts/prepare_training.py` turns a capture into the flat, per-camera-folder layout that
+the DEGAS / AvatarReX style trainers expect:
+
+```bash
+python scripts/prepare_training.py data/P1C1 --out /scratch/train/P1C1 \
+       --stride 4 --cams 0 3 6 9 12 15 18 21 --masks --workers 8
+```
+
+```
+/scratch/train/P1C1/
+  calibration_full.json      {"cam00": {K, R, T, RT, imgSize, ...}}   world-to-camera, Y-up
+  cam_cam00/00000001.jpg     RGB, named by GT frame id
+  cam_cam00/mask/00000001.png
+  smplx/00000001.npz         per-frame params, (1,D)
+  smplx_params.npz           the same params stacked
+  meta.json
+```
+
+This is the **proposed** training contract. Key names and the image/mask split will be
+reconciled against the training code in the retrain phase; re-emitting after a format
+change costs one ffmpeg pass per camera.
+
+---
+
+## How the registration was produced
+
+[Holistic-Multiview-Tracker](https://github.com/initialneil/Holistic-Multiview-Tracker),
+branch `reusable-v0.2.0`. One SMPL-X body, N calibrated views, minimising the summed 2D
+reprojection error rather than fitting a visual hull:
+
+| part | predictor |
+|---|---|
+| body | [sapiens-omni-600](https://github.com/initialneil/sapiens-omni-600), 600 dense 2D surface landmarks |
+| hands | [WiLoR](https://github.com/rolpotamias/WiLoR), reprojected as a vertex-to-vertex term (MANO is the SMPL-X hand submesh) |
+| face | MediaPipe FaceLandmarker, 105 embedded points plus 10 iris points |
+
+Sequence mode warm-starts frame `N` from frame `N-1` and only cold-starts the first frame of
+a shard, so a ~1800 frame capture is practical. FLAME and joint offsets are off: this is
+native SMPL-X, matching [DEGAS](https://initialneil.github.io/DEGAS.html).
+
+The `previews/` contact sheets and the 3-panel images above are the tracker's own QC output,
+rendered on every 100th frame with the mesh rasterised through the true calibrated camera.
+
+## Related
+
+- [DEGAS](https://initialneil.github.io/DEGAS.html): Detailed Expressions on Full-Body Gaussian Avatars
+- [Holistic-Tracker](https://github.com/initialneil/Holistic-Tracker): the monocular counterpart
+
+## Licence and consent
+
+Research use only, non-commercial. The captures show identifiable people; do not
+redistribute the imagery, and do not use it to build systems that identify or impersonate
+the subjects. The SMPL-X body model is **not** included here and remains subject to its own
+licence from the Max Planck Institute.
+
+If you are a subject in this data and want it removed, open a discussion on this repo.
+
+## Citation
+
+```bibtex
+@misc{dreams-avatar-2026,
+  title  = {DREAMS-AVATAR: DEGAS multiview captures re-registered to pure SMPL-X},
+  author = {Shao, Zhijing},
+  year   = {2026},
+  url    = {https://huggingface.co/datasets/initialneil/DREAMS-AVATAR}
+}
+```

data/P1C1/cameras.json

@@ -0,0 +1,2893 @@
+{
+	"ground_plane" : 
+	[
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	],
+	"radius" : 1.0,
+	"rigs" : 
+	[
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.99977880716323853,
+							0.0063244248740375042,
+							0.020059023052453995
+						],
+						[
+							-0.0054655848070979118,
+							0.99907785654067993,
+							-0.042585421353578568
+						],
+						[
+							-0.020309854298830032,
+							0.042466368526220322,
+							0.99889141321182251
+						]
+					],
+					"c" : 
+					[
+						-7.1153044700622559e-07,
+						-1.4826395511627197,
+						-2.6142139434814453
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 2378.634765625,
+					"fy" : 2378.634765625,
+					"h" : 1500,
+					"info" : "042032820187-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820187",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.99974364042282104,
+							-0.018158476799726486,
+							-0.013526227325201035
+						],
+						[
+							0.020207745954394341,
+							0.98502480983734131,
+							0.17122434079647064
+						],
+						[
+							0.01021450012922287,
+							-0.1714538037776947,
+							0.98513919115066528
+						]
+					],
+					"c" : 
+					[
+						-0.00013948231935501099,
+						-0.3537394106388092,
+						-2.6267125606536865
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1789.2591552734375,
+					"fy" : 1789.2591552734375,
+					"h" : 1500,
+					"info" : "042032820172-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820172",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.99985349178314209,
+							-0.01560401264578104,
+							0.0070295259356498718
+						],
+						[
+							0.016968213021755219,
+							0.85028314590454102,
+							-0.52605199813842773
+						],
+						[
+							0.0022314377129077911,
+							0.52609431743621826,
+							0.85042327642440796
+						]
+					],
+					"c" : 
+					[
+						-0.0073757311329245567,
+						-2.3462204933166504,
+						-2.621171236038208
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1785.7711181640625,
+					"fy" : 1785.7711181640625,
+					"h" : 1500,
+					"info" : "041131220272-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "041131220272",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.99755185842514038,
+							0.0083239311352372169,
+							-0.069433599710464478
+						],
+						[
+							-0.010169358924031258,
+							0.999603271484375,
+							-0.026267355307936668
+						],
+						[
+							0.06918739527463913,
+							0.026909150183200836,
+							0.99724066257476807
+						]
+					],
+					"c" : 
+					[
+						-0.21882268786430359,
+						-1.4867063760757446,
+						-2.644909143447876
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 5182.36376953125,
+					"fy" : 5182.36376953125,
+					"h" : 1500,
+					"info" : "042131020001-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042131020001",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.685649573802948,
+							0.0071092415601015091,
+							-0.727897047996521
+						],
+						[
+							-0.38862979412078857,
+							0.84909361600875854,
+							-0.35778054594993591
+						],
+						[
+							0.61550921201705933,
+							0.5281946063041687,
+							0.58494347333908081
+						]
+					],
+					"c" : 
+					[
+						-1.8865025043487549,
+						-2.3287115097045898,
+						-1.8302794694900513
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1781.2928466796875,
+					"fy" : 1781.2928466796875,
+					"h" : 1500,
+					"info" : "042032820159-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820159",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.71022188663482666,
+							0.012667356058955193,
+							-0.70386385917663574
+						],
+						[
+							-0.038413528352975845,
+							0.99904584884643555,
+							-0.020780798047780991
+						],
+						[
+							0.70292907953262329,
+							0.041796877980232239,
+							0.71003079414367676
+						]
+					],
+					"c" : 
+					[
+						-1.8813941478729248,
+						-1.471271276473999,
+						-1.8304221630096436
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 2371.3564453125,
+					"fy" : 2371.3564453125,
+					"h" : 1500,
+					"info" : "042032820156-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820156",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.68823426961898804,
+							-0.0013963263481855392,
+							-0.72548723220825195
+						],
+						[
+							0.1251538097858429,
+							0.98523449897766113,
+							0.11683104932308197
+						],
+						[
+							0.71461188793182373,
+							-0.17120462656021118,
+							0.67824685573577881
+						]
+					],
+					"c" : 
+					[
+						-1.8826209306716919,
+						-0.3555065393447876,
+						-1.8431063890457153
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1771.633056640625,
+					"fy" : 1771.633056640625,
+					"h" : 1500,
+					"info" : "041131220255-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "041131220255",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.63659375905990601,
+							0.0070461789146065712,
+							-0.77116703987121582
+						],
+						[
+							-0.022916210815310478,
+							0.99968951940536499,
+							-0.0097830016165971756
+						],
+						[
+							0.77085864543914795,
+							0.02390003390610218,
+							0.63655763864517212
+						]
+					],
+					"c" : 
+					[
+						-2.0620980262756348,
+						-1.4757134914398193,
+						-1.6690757274627686
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 5077.1103515625,
+					"fy" : 5077.1103515625,
+					"h" : 1500,
+					"info" : "042131020034-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042131020034",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.022983022034168243,
+							0.0098905907943844795,
+							-0.9996868371963501
+						],
+						[
+							-0.04140155017375946,
+							0.99910265207290649,
+							0.0089329807087779045
+						],
+						[
+							0.99887824058532715,
+							0.041183274239301682,
+							0.023371884599328041
+						]
+					],
+					"c" : 
+					[
+						-2.6552853584289551,
+						-1.4731272459030151,
+						-0.016699902713298798
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 2351.86328125,
+					"fy" : 2351.86328125,
+					"h" : 1500,
+					"info" : "042032820189-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820189",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.020695451647043228,
+							-0.0095787998288869858,
+							-0.99973994493484497
+						],
+						[
+							-0.51971369981765747,
+							0.85433661937713623,
+							0.0025728605687618256
+						],
+						[
+							0.85408979654312134,
+							0.51963174343109131,
+							-0.022659115493297577
+						]
+					],
+					"c" : 
+					[
+						-2.6613638401031494,
+						-2.3336374759674072,
+						-0.019422814249992371
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1787.1995849609375,
+					"fy" : 1787.1995849609375,
+					"h" : 1500,
+					"info" : "042032820178-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820178",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.0017560217529535294,
+							-0.0098642986267805099,
+							-0.99994975328445435
+						],
+						[
+							0.1782233864068985,
+							0.98393911123275757,
+							-0.010019334033131599
+						],
+						[
+							0.98398852348327637,
+							-0.17823202908039093,
+							3.0228868126869202e-05
+						]
+					],
+					"c" : 
+					[
+						-2.6583425998687744,
+						-0.3582407534122467,
+						-0.020087916404008865
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1776.6854248046875,
+					"fy" : 1776.6854248046875,
+					"h" : 1500,
+					"info" : "041131220260-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "041131220260",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.072798892855644226,
+							-0.0074999937787652016,
+							-0.99731838703155518
+						],
+						[
+							-0.013888604007661343,
+							0.99988240003585815,
+							-0.0065054791048169136
+						],
+						[
+							0.99724996089935303,
+							0.013377770781517029,
+							-0.072894491255283356
+						]
+					],
+					"c" : 
+					[
+						-2.6990907192230225,
+						-1.480023980140686,
+						0.22978486120700836
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 5138.12109375,
+					"fy" : 5138.12109375,
+					"h" : 1500,
+					"info" : "042131020029-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042131020029",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.76026898622512817,
+							-0.0055369534529745579,
+							-0.64958482980728149
+						],
+						[
+							-0.021611243486404419,
+							0.99962574243545532,
+							0.016772985458374023
+						],
+						[
+							0.64924883842468262,
+							0.0267903171479702,
+							-0.76010406017303467
+						]
+					],
+					"c" : 
+					[
+						-1.7545278072357178,
+						-1.4870845079421997,
+						2.0024347305297852
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 5218.81787109375,
+					"fy" : 5218.81787109375,
+					"h" : 1500,
+					"info" : "042131020019-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042131020019",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.69281274080276489,
+							0.0010390696115791798,
+							-0.72111678123474121
+						],
+						[
+							-0.36976057291030884,
+							0.85801893472671509,
+							0.35648369789123535
+						],
+						[
+							0.61910223960876465,
+							0.51361703872680664,
+							-0.5940622091293335
+						]
+					],
+					"c" : 
+					[
+						-1.8988977670669556,
+						-2.3343207836151123,
+						1.7938884496688843
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1791.7742919921875,
+					"fy" : 1791.7742919921875,
+					"h" : 1500,
+					"info" : "041131220235-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "041131220235",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.68310022354125977,
+							0.0047086798585951328,
+							-0.73030942678451538
+						],
+						[
+							0.1166602298617363,
+							0.98784250020980835,
+							-0.10274986922740936
+						],
+						[
+							0.72094690799713135,
+							-0.1553865373134613,
+							-0.67534476518630981
+						]
+					],
+					"c" : 
+					[
+						-1.9096056222915649,
+						-0.35902422666549683,
+						1.8335007429122925
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1797.0045166015625,
+					"fy" : 1797.0045166015625,
+					"h" : 1500,
+					"info" : "042032820188-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820188",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.7058335542678833,
+							0.0033496017567813396,
+							-0.70836979150772095
+						],
+						[
+							-0.024536110460758209,
+							0.99927318096160889,
+							0.029173431918025017
+						],
+						[
+							0.70795261859893799,
+							0.037972215563058853,
+							-0.70523834228515625
+						]
+					],
+					"c" : 
+					[
+						-1.9000109434127808,
+						-1.4761124849319458,
+						1.8084433078765869
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 2391.1611328125,
+					"fy" : 2391.1611328125,
+					"h" : 1500,
+					"info" : "042032820166-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820166",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.99995827674865723,
+							-0.0089588714763522148,
+							0.0017825812101364136
+						],
+						[
+							-0.008868013508617878,
+							0.99891477823257446,
+							0.045722953975200653
+						],
+						[
+							-0.002190273255109787,
+							0.045705240219831467,
+							-0.99895250797271729
+						]
+					],
+					"c" : 
+					[
+						-0.050685644149780273,
+						-1.4931169748306274,
+						2.6202154159545898
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 2418.541748046875,
+					"fy" : 2418.541748046875,
+					"h" : 1500,
+					"info" : "042032820158-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820158",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.99610930681228638,
+							-0.0075509278103709221,
+							0.087802208960056305
+						],
+						[
+							-0.0055164704099297523,
+							0.99971121549606323,
+							0.023390570655465126
+						],
+						[
+							-0.087953470647335052,
+							0.02281520701944828,
+							-0.99586319923400879
+						]
+					],
+					"c" : 
+					[
+						0.1831657886505127,
+						-1.4902843236923218,
+						2.636763334274292
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 4996.25732421875,
+					"fy" : 4996.25732421875,
+					"h" : 1500,
+					"info" : "042131020041-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042131020041",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.9997449517250061,
+							-0.01295993197709322,
+							-0.018494654446840286
+						],
+						[
+							-0.020760234445333481,
+							0.84976887702941895,
+							0.52674645185470581
+						],
+						[
+							0.0088895875960588455,
+							0.52699613571166992,
+							-0.84982115030288696
+						]
+					],
+					"c" : 
+					[
+						-0.054456010460853577,
+						-2.352524995803833,
+						2.6293706893920898
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1790.0133056640625,
+					"fy" : 1790.0133056640625,
+					"h" : 1500,
+					"info" : "041131220261-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "041131220261",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.99963837862014771,
+							0.026743648573756218,
+							-0.00283021479845047
+						],
+						[
+							0.026818025857210159,
+							0.98346394300460815,
+							-0.17910754680633545
+						],
+						[
+							-0.0020065736025571823,
+							-0.17911867797374725,
+							-0.98382538557052612
+						]
+					],
+					"c" : 
+					[
+						-0.048479326069355011,
+						-0.36015069484710693,
+						2.6487228870391846
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1779.42236328125,
+					"fy" : 1779.42236328125,
+					"h" : 1500,
+					"info" : "041131220253-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "041131220253",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.64273864030838013,
+							0.0031604096293449402,
+							0.76607900857925415
+						],
+						[
+							0.024652188643813133,
+							0.99955892562866211,
+							0.01655951701104641
+						],
+						[
+							-0.76568889617919922,
+							0.029528968036174774,
+							-0.64253294467926025
+						]
+					],
+					"c" : 
+					[
+						2.0458173751831055,
+						-1.4919195175170898,
+						1.7196044921875
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 5231.091796875,
+					"fy" : 5231.091796875,
+					"h" : 1500,
+					"info" : "042131020028-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042131020028",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.70267671346664429,
+							-0.0042091058567166328,
+							0.71149677038192749
+						],
+						[
+							0.027837298810482025,
+							0.9990541934967041,
+							0.0334024578332901
+						],
+						[
+							-0.71096444129943848,
+							0.043277278542518616,
+							-0.70189493894577026
+						]
+					],
+					"c" : 
+					[
+						1.8445219993591309,
+						-1.4873323440551758,
+						1.8655474185943604
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 2359.339111328125,
+					"fy" : 2359.339111328125,
+					"h" : 1500,
+					"info" : "042032820179-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820179",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.70941370725631714,
+							-0.0058966665528714657,
+							0.70476764440536499
+						],
+						[
+							-0.12919087707996368,
+							0.98410987854003906,
+							-0.12180867046117783
+						],
+						[
+							-0.69285053014755249,
+							-0.17746229469776154,
+							-0.69890284538269043
+						]
+					],
+					"c" : 
+					[
+						1.8645299673080444,
+						-0.36033046245574951,
+						1.8825584650039673
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1791.569580078125,
+					"fy" : 1791.569580078125,
+					"h" : 1500,
+					"info" : "041131220273-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "041131220273",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.71407037973403931,
+							-0.018623331561684608,
+							0.69982612133026123
+						],
+						[
+							0.34658393263816833,
+							0.85914283990859985,
+							0.37650126218795776
+						],
+						[
+							-0.60826230049133301,
+							0.51139688491821289,
+							-0.60703384876251221
+						]
+					],
+					"c" : 
+					[
+						1.837710976600647,
+						-2.3479263782501221,
+						1.8526068925857544
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1808.480712890625,
+					"fy" : 1808.480712890625,
+					"h" : 1500,
+					"info" : "041131220236-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "041131220236",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.076994970440864563,
+							0.00070070661604404449,
+							0.99703121185302734
+						],
+						[
+							-0.17270408570766449,
+							0.98487383127212524,
+							-0.01402910053730011
+						],
+						[
+							-0.98195981979370117,
+							-0.1732715368270874,
+							-0.075709313154220581
+						]
+					],
+					"c" : 
+					[
+						2.6400704383850098,
+						-0.35975420475006104,
+						0.086691178381443024
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1789.728271484375,
+					"fy" : 1789.728271484375,
+					"h" : 1500,
+					"info" : "042032820182-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820182",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.039545632898807526,
+							0.010706024244427681,
+							0.99916034936904907
+						],
+						[
+							0.51809543371200562,
+							0.8552476167678833,
+							0.011341636069118977
+						],
+						[
+							-0.8544081449508667,
+							0.51810890436172485,
+							-0.039368048310279846
+						]
+					],
+					"c" : 
+					[
+						2.6209020614624023,
+						-2.3470981121063232,
+						0.082048363983631134
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1789.5955810546875,
+					"fy" : 1789.5955810546875,
+					"h" : 1500,
+					"info" : "042032820186-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820186",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.055626779794692993,
+							-0.0024624969810247421,
+							0.99844855070114136
+						],
+						[
+							0.022725043818354607,
+							0.99974101781845093,
+							0.0011996012181043625
+						],
+						[
+							-0.99819302558898926,
+							0.022623056545853615,
+							0.055668327957391739
+						]
+					],
+					"c" : 
+					[
+						2.7049500942230225,
+						-1.4966907501220703,
+						-0.15607133507728577
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 5311.93896484375,
+					"fy" : 5311.93896484375,
+					"h" : 1500,
+					"info" : "042131020016-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042131020016",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							-0.029232239350676537,
+							-0.01076057180762291,
+							0.99951469898223877
+						],
+						[
+							0.053320862352848053,
+							0.99850159883499146,
+							0.012309110723435879
+						],
+						[
+							-0.99814945459365845,
+							0.053654808551073074,
+							-0.028614671900868416
+						]
+					],
+					"c" : 
+					[
+						2.6447646617889404,
+						-1.495847225189209,
+						0.081528395414352417
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 2408.6162109375,
+					"fy" : 2408.6162109375,
+					"h" : 1500,
+					"info" : "042032820167-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820167",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.71080350875854492,
+							0.005710309837013483,
+							0.70336753129959106
+						],
+						[
+							0.36521205306053162,
+							0.85161840915679932,
+							-0.37598693370819092
+						],
+						[
+							-0.60114771127700806,
+							0.52413111925125122,
+							0.60324788093566895
+						]
+					],
+					"c" : 
+					[
+						1.8218140602111816,
+						-2.340024471282959,
+						-1.8943350315093994
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1803.7322998046875,
+					"fy" : 1803.7322998046875,
+					"h" : 1500,
+					"info" : "042071120027-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042071120027",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.69692009687423706,
+							-0.0033488078042864799,
+							0.71714097261428833
+						],
+						[
+							-0.12217219918966293,
+							0.9848170280456543,
+							0.12332612276077271
+						],
+						[
+							-0.70666563510894775,
+							-0.17356313765048981,
+							0.68592965602874756
+						]
+					],
+					"c" : 
+					[
+						1.8281830549240112,
+						-0.35650897026062012,
+						-1.908189058303833
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 1812.3741455078125,
+					"fy" : 1812.3741455078125,
+					"h" : 1500,
+					"info" : "042032820173-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820173",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.77913391590118408,
+							-0.015277845785021782,
+							0.62667125463485718
+						],
+						[
+							0.017884960398077965,
+							0.99983775615692139,
+							0.0021392218768596649
+						],
+						[
+							-0.62660235166549683,
+							0.0095412544906139374,
+							0.77928072214126587
+						]
+					],
+					"c" : 
+					[
+						1.6819428205490112,
+						-1.4865034818649292,
+						-2.1011180877685547
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 5215.01416015625,
+					"fy" : 5215.01416015625,
+					"h" : 1500,
+					"info" : "042052820027-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042052820027",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		},
+		{
+			"camera_model" : "MindVision",
+			"cameras" : 
+			[
+				{
+					"D" : 
+					[
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0,
+						0.0
+					],
+					"R" : 
+					[
+						[
+							0.72792786359786987,
+							-0.0098063843324780464,
+							0.68558359146118164
+						],
+						[
+							0.032681748270988464,
+							0.99925744533538818,
+							-0.020407211035490036
+						],
+						[
+							-0.68487441539764404,
+							0.037261050194501877,
+							0.72770780324935913
+						]
+					],
+					"c" : 
+					[
+						1.8307652473449707,
+						-1.4816135168075562,
+						-1.9038161039352417
+					],
+					"cx" : 1024.0,
+					"cy" : 750.0,
+					"depth_scale" : 1.0,
+					"fov" : 0.0,
+					"fx" : 2419.163818359375,
+					"fy" : 2419.163818359375,
+					"h" : 1500,
+					"info" : "042032820175-color",
+					"lens_flip" : "no",
+					"lens_type" : "RECTILINEAR",
+					"w" : 2048
+				}
+			],
+			"ground_plane" : 
+			[
+				0.0,
+				0.0,
+				0.0,
+				0.0
+			],
+			"image_format" : "RGB",
+			"info" : "042032820175",
+			"rig_position" : 
+			[
+				0.0,
+				0.0,
+				0.0
+			],
+			"rig_rotation" : 
+			[
+				[
+					1.0,
+					0.0,
+					0.0
+				],
+				[
+					0.0,
+					1.0,
+					0.0
+				],
+				[
+					0.0,
+					0.0,
+					1.0
+				]
+			]
+		}
+	]
+}

data/P1C1/capture.json

@@ -0,0 +1,53 @@
+{
+  "capture": "P1C1",
+  "subject": "P1",
+  "session": "C1",
+  "role": "train",
+  "n_cams": 32,
+  "n_rigs_in_calibration": 32,
+  "video": {
+    "width": 4096,
+    "height": 1500,
+    "n_frames": 1836,
+    "fps": 22.0,
+    "codec": "h264",
+    "pix_fmt": "yuv444p",
+    "layout": "side-by-side: LEFT half = RGB, RIGHT half = alpha matte",
+    "rgb_width": 2048
+  },
+  "video_bytes": 2101806372,
+  "frame_convention": {
+    "smplx_frame": "GT frame id, 1-based; stored in smplx.npz['frames']",
+    "video_frame": "smplx_frame - 1, 0-based index into camNN.mp4"
+  },
+  "camera_convention": {
+    "K": "[[fx,0,cx],[0,fy,cy],[0,0,1]] from rigs[i].cameras[0]",
+    "R_w2c": "R @ diag(1,-1,-1)",
+    "t_w2c": "-R @ c",
+    "note": "cameras.json world is Y-down; the world_flip puts the fit in the same Y-up world as the DEGAS GT"
+  },
+  "n_frames": 1836,
+  "gt_frame_range": [
+    1,
+    1836
+  ],
+  "smplx_kwargs": {
+    "model_type": "smplx",
+    "gender": "neutral",
+    "use_pca": false,
+    "num_betas": 300,
+    "num_expression_coeffs": 100,
+    "use_face_contour": true,
+    "flat_hand_mean": false,
+    "create_global_orient": false,
+    "create_body_pose": false,
+    "create_betas": false,
+    "create_left_hand_pose": false,
+    "create_right_hand_pose": false,
+    "create_jaw_pose": false,
+    "create_leye_pose": false,
+    "create_reye_pose": false,
+    "create_expression": false,
+    "create_transl": false
+  }
+}

data/P1C1/smplx.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5974c67525495bdbdab0519cd38f22edc570f16c411f2c182c43ad2e3e01bfa
+size 6829764

previews/metadata.jsonl

@@ -0,0 +1,18 @@
+{"file_name": "P1C1_f00000100.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 100, "video_frame": 99, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 12, "stages": "W", "body_height_m": 1.6515, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00000200.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 200, "video_frame": 199, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 11, "stages": "W", "body_height_m": 1.7022, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00000300.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 300, "video_frame": 299, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 10, "stages": "W", "body_height_m": 1.9227, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00000400.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 400, "video_frame": 399, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 11, "stages": "W", "body_height_m": 1.6455, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00000500.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 500, "video_frame": 499, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 11, "stages": "W", "body_height_m": 1.6573, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00000600.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 600, "video_frame": 599, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 10, "stages": "W", "body_height_m": 1.6455, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00000700.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 700, "video_frame": 699, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 10, "stages": "W", "body_height_m": 1.6465, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00000800.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 800, "video_frame": 799, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 10, "stages": "W", "body_height_m": 1.643, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00000900.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 900, "video_frame": 899, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 11, "stages": "W", "body_height_m": 1.6407, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001000.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1000, "video_frame": 999, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 9, "stages": "W", "body_height_m": 1.6732, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001100.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1100, "video_frame": 1099, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 10, "stages": "W", "body_height_m": 1.6627, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001200.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1200, "video_frame": 1199, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 11, "stages": "W", "body_height_m": 1.6596, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001300.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1300, "video_frame": 1299, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 9, "stages": "W", "body_height_m": 1.4965, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001400.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1400, "video_frame": 1399, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 11, "stages": "W", "body_height_m": 1.6594, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001500.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1500, "video_frame": 1499, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 9, "stages": "W", "body_height_m": 1.6556, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001600.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1600, "video_frame": 1599, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 9, "stages": "W", "body_height_m": 1.6423, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001700.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1700, "video_frame": 1699, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 10, "stages": "W", "body_height_m": 1.6608, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}
+{"file_name": "P1C1_f00001800.jpg", "capture": "P1C1", "subject": "P1", "session": "C1", "role": "train", "frame": 1800, "video_frame": 1799, "n_cams": 32, "n_frames": 1836, "n_views_fit": 32, "n_face_views": 9, "stages": "W", "body_height_m": 1.6651, "videos": "data/P1C1/videos", "smplx": "data/P1C1/smplx.npz", "cameras": "data/P1C1/cameras.json"}

scripts/build_metadata.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+"""Rebuild `previews/metadata.jsonl` -- the table the HF dataset viewer renders.
+
+One row per (capture x sampled frame). The `file_name` column is resolved by the
+`imagefolder` builder into an `image` feature, so Data Studio shows a browsable
+thumbnail of every QC contact sheet next to its metadata.
+
+Columns
+    file_name      -> image     32-view QC contact sheet [raw | omni-600 | SMPL-X]
+    capture                     PxCy
+    subject / session           Px / Cy
+    role                        train (C1) / test (C2) / cross_reenact_driving (P5,P6 C2)
+    frame                       GT frame id (1-based)
+    video_frame                 frame - 1, 0-based index into videos/camNN.mp4
+    n_cams                      cameras in the capture
+    n_frames                    fitted frames in the capture
+    n_views_fit                 views actually used by the fit at this frame
+    n_face_views                views with an accepted MediaPipe face at this frame
+    stages                      fit schedule at this frame (A+B+C+F cold / W warm)
+    body_height_m               SMPL-X joint-span height, a cheap sanity number
+    videos / smplx / cameras    repo-relative paths to the full-res assets
+
+Run after every capture is staged; it rescans the whole staging tree.
+
+Usage:
+    python build_metadata.py --staging /mnt/sdb/degas_project/DREAMS-AVATAR-hf/staging
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+
+def build(staging: Path) -> dict:
+    prev_dir = staging / "previews"
+    data_dir = staging / "data"
+    captures = sorted(p.name for p in data_dir.iterdir() if p.is_dir()) if data_dir.is_dir() else []
+    if not captures:
+        raise SystemExit(f"no captures under {data_dir}")
+
+    rows = []
+    for cap in captures:
+        d = data_dir / cap
+        card = json.loads((d / "capture.json").read_text())
+        z = np.load(d / "smplx.npz", allow_pickle=False)
+        frames = z["frames"].astype(int)
+        idx_of = {int(f): i for i, f in enumerate(frames)}
+        joints = z["joints"]
+        n_views = z["n_views"]
+        n_face = z["n_face_views"]
+        stages = z["stages"]
+
+        imgs = sorted(prev_dir.glob(f"{cap}_f*.jpg"))
+        for img in imgs:
+            fr = int(img.stem.split("_f")[1])
+            i = idx_of.get(fr)
+            if i is None:
+                print(f"[metadata] WARN {img.name}: frame {fr} not in smplx.npz", file=sys.stderr)
+                continue
+            j = joints[i]
+            rows.append({
+                "file_name": img.name,
+                "capture": cap,
+                "subject": card["subject"],
+                "session": card["session"],
+                "role": card.get("role", ""),
+                "frame": fr,
+                "video_frame": fr - 1,
+                "n_cams": int(card["n_cams"]),
+                "n_frames": int(card.get("n_frames", len(frames))),
+                "n_views_fit": int(n_views[i]),
+                "n_face_views": int(n_face[i]),
+                "stages": str(stages[i]),
+                "body_height_m": round(float(j[:, 1].max() - j[:, 1].min()), 4),
+                "videos": f"data/{cap}/videos",
+                "smplx": f"data/{cap}/smplx.npz",
+                "cameras": f"data/{cap}/cameras.json",
+            })
+
+    rows.sort(key=lambda r: (r["capture"], r["frame"]))
+    prev_dir.mkdir(parents=True, exist_ok=True)
+    out = prev_dir / "metadata.jsonl"
+    with out.open("w") as fh:
+        for r in rows:
+            fh.write(json.dumps(r) + "\n")
+    print(f"[metadata] {out}: {len(rows)} rows over {len(captures)} captures "
+          f"({', '.join(captures)})", flush=True)
+    return {"rows": len(rows), "captures": captures, "path": str(out)}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--staging", type=Path, required=True)
+    a = ap.parse_args()
+    print(json.dumps(build(a.staging)))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/consolidate_smplx.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+"""Consolidate per-frame Holistic-Multiview-Tracker SMPL-X npz -> ONE per-capture smplx.npz.
+
+Source (READ ONLY, produced by the tracker):
+    <DEGAS_DATASET>/<PxCy>/hmt_seq_out/smplx/smplx_<gt_frame:08d>.npz
+
+Each per-frame file holds unbatched arrays:
+    global_orient(3) body_pose(63) jaw_pose(3) leye_pose(3) reye_pose(3)
+    left_hand_pose(45) right_hand_pose(45) betas(300) expression(100) transl(3)
+    vertices(10475,3) joints(144,3)
+    view_ids(V,) gt_frame() n_face_views() stages()
+
+Output `smplx.npz` stacks every parameter over time, LOSSLESSLY (identical dtypes,
+no downcast, no re-quantisation) and adds an explicit frame index:
+
+    frames        int32 (T,)      GT frame id, == the number in the source filename
+    video_frames  int32 (T,)      frames - 1  == 0-based frame index inside videos/camNN.mp4
+    global_orient float32 (T,3)
+    body_pose     float32 (T,63)
+    jaw_pose      float32 (T,3)
+    leye_pose     float32 (T,3)
+    reye_pose     float32 (T,3)
+    left_hand_pose  float32 (T,45)   axis-angle, use_pca=False
+    right_hand_pose float32 (T,45)   axis-angle, use_pca=False
+    betas         float32 (T,300)
+    expression    float32 (T,100)
+    transl        float32 (T,3)
+    joints        float32 (T,144,3)  SMPL-X joints in world frame (derived, shipped for convenience)
+    view_ids      int16   (T,Vmax)   camera indices actually used at that frame, -1 padded
+    n_views       int16   (T,)
+    n_face_views  int16   (T,)
+    stages        <U..    (T,)       fit schedule for that frame ("A+B+C+F" cold / "W" warm)
+    smplx_kwargs  <U..    ()         JSON: exact smplx.SMPLX(...) kwargs to rebuild the model
+    meta          <U..    ()         JSON: capture, n_frames, source, tracker commit, ...
+
+`vertices` (10475,3 per frame, ~230 MB per capture) is DERIVED and omitted by default;
+pass --with-vertices to also emit <out_dir>/smplx_vertices.npz.
+
+Usage:
+    python consolidate_smplx.py P1C1 --out /path/to/staging/data/P1C1/smplx.npz
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+DATASET_ROOT = Path("/mnt/sdb/degas_project/DEGAS_DATASET")
+
+# Params that are stacked over time. Order is the SMPL-X forward() kwarg order.
+PARAM_KEYS = [
+    "global_orient", "body_pose", "jaw_pose", "leye_pose", "reye_pose",
+    "left_hand_pose", "right_hand_pose", "betas", "expression", "transl",
+]
+EXTRA_KEYS = ["joints"]
+
+# Locked by the tracker (configs/degas.yaml + hmt/smplx_builder.py LOCKED_KWARGS).
+SMPLX_KWARGS = dict(
+    model_type="smplx",
+    gender="neutral",
+    use_pca=False,
+    num_betas=300,
+    num_expression_coeffs=100,
+    use_face_contour=True,
+    flat_hand_mean=False,
+    create_global_orient=False,
+    create_body_pose=False,
+    create_betas=False,
+    create_left_hand_pose=False,
+    create_right_hand_pose=False,
+    create_jaw_pose=False,
+    create_leye_pose=False,
+    create_reye_pose=False,
+    create_expression=False,
+    create_transl=False,
+)
+
+
+def consolidate(capture: str, dataset_root: Path, out_path: Path,
+                with_vertices: bool = False, verify: bool = True) -> dict:
+    seq = dataset_root / capture / "hmt_seq_out" / "smplx"
+    files = sorted(seq.glob("smplx_*.npz"))
+    if not files:
+        raise SystemExit(f"no per-frame npz under {seq}")
+
+    frames = np.array([int(f.stem.split("_")[1]) for f in files], np.int32)
+    T = len(files)
+    print(f"[consolidate] {capture}: {T} frames, GT {frames[0]}..{frames[-1]}", flush=True)
+
+    acc: dict[str, list] = {k: [] for k in PARAM_KEYS + EXTRA_KEYS}
+    view_ids, n_face, stages, verts = [], [], [], []
+
+    for i, f in enumerate(files):
+        z = np.load(f, allow_pickle=False)
+        for k in PARAM_KEYS + EXTRA_KEYS:
+            acc[k].append(z[k])
+        view_ids.append(np.asarray(z["view_ids"], np.int16))
+        n_face.append(int(z["n_face_views"]))
+        stages.append(str(z["stages"]))
+        if with_vertices:
+            verts.append(z["vertices"])
+        assert int(z["gt_frame"]) == int(frames[i]), f"{f}: gt_frame != filename"
+        if (i + 1) % 500 == 0:
+            print(f"  .. {i + 1}/{T}", flush=True)
+
+    vmax = max(len(v) for v in view_ids)
+    vids = np.full((T, vmax), -1, np.int16)
+    for i, v in enumerate(view_ids):
+        vids[i, :len(v)] = v
+
+    out = {k: np.stack(acc[k]) for k in PARAM_KEYS + EXTRA_KEYS}
+    out["frames"] = frames
+    out["video_frames"] = (frames - 1).astype(np.int32)
+    out["view_ids"] = vids
+    out["n_views"] = np.array([len(v) for v in view_ids], np.int16)
+    out["n_face_views"] = np.asarray(n_face, np.int16)
+    out["stages"] = np.asarray(stages)
+    out["smplx_kwargs"] = np.asarray(json.dumps(SMPLX_KWARGS))
+    out["meta"] = np.asarray(json.dumps({
+        "capture": capture,
+        "n_frames": T,
+        "gt_frame_first": int(frames[0]),
+        "gt_frame_last": int(frames[-1]),
+        "video_frame_offset": -1,
+        "note": "video frame index = GT frame - 1 (GT frame 0 has no video frame)",
+        "source": "Holistic-Multiview-Tracker run_degas_sequence.py (branch reusable-v0.2.0)",
+        "world_frame": "Y-up; cameras.json world is Y-down -> world_flip=diag(1,-1,-1)",
+    }))
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(out_path, **out)
+    mb = out_path.stat().st_size / 2**20
+    print(f"[consolidate] wrote {out_path}  ({mb:.1f} MB)", flush=True)
+
+    if with_vertices:
+        vp = out_path.with_name("smplx_vertices.npz")
+        np.savez_compressed(vp, frames=frames, vertices=np.stack(verts))
+        print(f"[consolidate] wrote {vp}  ({vp.stat().st_size / 2**20:.1f} MB)", flush=True)
+
+    if verify:
+        _verify(out_path, files, frames)
+
+    return {"capture": capture, "n_frames": T, "bytes": out_path.stat().st_size,
+            "gt_first": int(frames[0]), "gt_last": int(frames[-1]),
+            "n_views_max": int(vmax)}
+
+
+def _verify(out_path: Path, files: list[Path], frames: np.ndarray) -> None:
+    """Bit-exact round-trip check on a random sample of frames."""
+    z = np.load(out_path, allow_pickle=False)
+    rng = np.random.default_rng(0)
+    idx = rng.choice(len(files), size=min(25, len(files)), replace=False)
+    for i in idx:
+        src = np.load(files[int(i)], allow_pickle=False)
+        for k in PARAM_KEYS + EXTRA_KEYS:
+            a, b = src[k], z[k][int(i)]
+            if a.dtype != b.dtype or not np.array_equal(a, b):
+                raise SystemExit(f"LOSSY: frame {frames[i]} key {k} mismatch")
+    print(f"[consolidate] verify OK: {len(idx)} random frames bit-identical to source", flush=True)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("capture", help="e.g. P1C1")
+    ap.add_argument("--dataset-root", type=Path, default=DATASET_ROOT)
+    ap.add_argument("--out", type=Path, required=True, help="output smplx.npz path")
+    ap.add_argument("--with-vertices", action="store_true",
+                    help="also write smplx_vertices.npz (~200 MB/capture)")
+    ap.add_argument("--no-verify", action="store_true")
+    a = ap.parse_args()
+    info = consolidate(a.capture, a.dataset_root, a.out, a.with_vertices, not a.no_verify)
+    print(json.dumps(info))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/hf_upload.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+"""Push the staging tree to the HuggingFace dataset repo.
+
+Two upload paths:
+  * SMALL files (README, previews/, assets/, scripts/, cameras.json, smplx.npz,
+    capture.json, preview.jpg) -> `upload_folder`, one atomic commit.
+  * BIG files (data/<PxCy>/videos/*.mp4, ~2 GiB per capture) -> `upload_large_folder`,
+    which is chunked, multi-worker and RESUMABLE: it keeps per-file state under
+    <staging>/.cache/huggingface, so re-running after a network drop skips what is done.
+
+Usage:
+    python hf_upload.py --staging .../staging --capture P1C1          # meta + that capture
+    python hf_upload.py --staging .../staging --meta-only             # README/previews/scripts
+    python hf_upload.py --staging .../staging --capture P1C1 --videos-only
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+REPO_ID = "initialneil/DREAMS-AVATAR"
+
+META_PATTERNS = [
+    "README.md", "LICENSE",
+    "previews/*.jsonl", "previews/*.jpg", "assets/**/*.jpg",
+    "scripts/*.py", "scripts/*.sh",
+]
+CAPTURE_SMALL = ["data/{cap}/cameras.json", "data/{cap}/smplx.npz",
+                 "data/{cap}/capture.json", "data/{cap}/preview.jpg"]
+CAPTURE_BIG = ["data/{cap}/videos/*.mp4"]
+
+
+def ensure_repo(api: HfApi, repo_id: str, private: bool) -> str:
+    url = api.create_repo(repo_id=repo_id, repo_type="dataset", private=private,
+                          exist_ok=True)
+    info = api.repo_info(repo_id=repo_id, repo_type="dataset")
+    print(f"[repo] {url}  private={info.private}", flush=True)
+    return str(url)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--staging", type=Path, required=True)
+    ap.add_argument("--repo-id", default=REPO_ID)
+    ap.add_argument("--capture", default=None)
+    ap.add_argument("--meta-only", action="store_true")
+    ap.add_argument("--videos-only", action="store_true")
+    ap.add_argument("--private", action="store_true", help="create as private (default PUBLIC)")
+    ap.add_argument("--workers", type=int, default=4)
+    a = ap.parse_args()
+
+    api = HfApi()
+    who = api.whoami()["name"]
+    print(f"[hf] logged in as {who}", flush=True)
+    ensure_repo(api, a.repo_id, a.private)
+
+    if not a.videos_only:
+        pats = list(META_PATTERNS)
+        if a.capture:
+            pats += [p.format(cap=a.capture) for p in CAPTURE_SMALL]
+        msg = (f"Add {a.capture} metadata + SMPL-X + previews" if a.capture
+               else "Update dataset card / previews / scripts")
+        print(f"[upload] small files: {pats}", flush=True)
+        ci = api.upload_folder(repo_id=a.repo_id, repo_type="dataset",
+                               folder_path=str(a.staging), allow_patterns=pats,
+                               commit_message=msg)
+        print(f"[upload] commit {getattr(ci, 'oid', ci)}", flush=True)
+
+    if a.capture and not a.meta_only:
+        pats = [p.format(cap=a.capture) for p in CAPTURE_BIG]
+        print(f"[upload] LARGE (resumable): {pats}", flush=True)
+        api.upload_large_folder(repo_id=a.repo_id, repo_type="dataset",
+                                folder_path=str(a.staging), allow_patterns=pats,
+                                num_workers=a.workers, print_report=True,
+                                print_report_every=30)
+        print("[upload] large folder done", flush=True)
+
+    files = api.list_repo_files(repo_id=a.repo_id, repo_type="dataset")
+    print(json.dumps({"repo": f"https://huggingface.co/datasets/{a.repo_id}",
+                      "n_files": len(files)}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/load_capture.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python
+"""Minimal reader for one DREAMS-AVATAR capture: videos + SMPL-X + cameras.
+
+Zero dependencies beyond numpy + opencv-python. Nothing here needs the SMPL-X model
+file -- that is only required if you want vertices (see `smplx_forward_kwargs`).
+
+    from load_capture import Capture
+
+    cap = Capture("data/P1C1")
+    print(cap)                                  # P1C1: 32 cams, 1836 frames, 2048x1500
+
+    # --- cameras -------------------------------------------------------------
+    cam = cap.cameras["cam03"]
+    uv  = cam.project(cap.joints(frame=1400))   # (144,2) pixel coords in the RGB half
+
+    # --- images --------------------------------------------------------------
+    rgb, alpha = cap.read_frame("cam03", frame=1400)   # (1500,2048,3) uint8, (1500,2048) uint8
+    for frame, rgb, alpha in cap.iter_frames("cam03", start=1400, end=1410):
+        ...
+
+    # --- SMPL-X --------------------------------------------------------------
+    p = cap.smplx_params(frame=1400)            # dict of (1,D) float32 torch-ready arrays
+    kw = cap.smplx_forward_kwargs               # exact smplx.SMPLX(**kw) constructor args
+
+Frame convention
+    `frame` is ALWAYS the GT frame id stored in smplx.npz["frames"] (1-based).
+    The matching video frame index is `frame - 1` (GT frame 0 has no video frame).
+    This module does the -1 for you; never pass a raw video index.
+
+Video layout
+    Each camNN.mp4 is 4096x1500: LEFT half = matted RGB, RIGHT half = the alpha matte
+    replicated over 3 channels. The calibration (fx, fy, cx, cy, w=2048, h=1500) refers
+    to the LEFT half.
+
+Camera convention
+    K     = [[fx, 0, cx], [0, fy, cy], [0, 0, 1]]     from cameras.json rigs[i].cameras[0]
+    R_w2c = R @ diag(1, -1, -1)                       (world_flip: cameras.json is Y-down)
+    t_w2c = -R @ c                                    (c = camera centre, unflipped world)
+    x_cam = R_w2c @ x_world + t_w2c ;  uv = (K @ x_cam)[:2] / x_cam[2]
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator
+
+import numpy as np
+
+WORLD_FLIP = np.diag([1.0, -1.0, -1.0])   # cameras.json world (Y-down) -> SMPL-X world (Y-up)
+
+PARAM_KEYS = ("global_orient", "body_pose", "jaw_pose", "leye_pose", "reye_pose",
+              "left_hand_pose", "right_hand_pose", "betas", "expression", "transl")
+
+
+@dataclass(frozen=True)
+class PinholeCamera:
+    name: str
+    K: np.ndarray        # (3,3)
+    R_w2c: np.ndarray    # (3,3)
+    t_w2c: np.ndarray    # (3,)
+    width: int
+    height: int
+
+    def project(self, xyz_world: np.ndarray) -> np.ndarray:
+        """(N,3) world points -> (N,2) pixels in the RGB half."""
+        x = np.asarray(xyz_world, np.float64).reshape(-1, 3) @ self.R_w2c.T + self.t_w2c
+        uvw = x @ self.K.T
+        return uvw[:, :2] / uvw[:, 2:3]
+
+    @property
+    def center(self) -> np.ndarray:
+        """Camera centre in the SMPL-X (Y-up) world."""
+        return -self.R_w2c.T @ self.t_w2c
+
+    @property
+    def extrinsic(self) -> np.ndarray:
+        """(3,4) world-to-camera [R|t]."""
+        return np.concatenate([self.R_w2c, self.t_w2c[:, None]], 1)
+
+
+def load_cameras(path: str | Path, world_flip: bool = True) -> dict[str, PinholeCamera]:
+    """cameras.json -> {"cam00": PinholeCamera, ...}; index i == videos/cam{i:02d}.mp4."""
+    d = json.loads(Path(path).read_text())
+    A = WORLD_FLIP if world_flip else np.eye(3)
+    cams: dict[str, PinholeCamera] = {}
+    for i, rig in enumerate(d["rigs"]):
+        c = rig["cameras"][0]
+        K = np.array([[c["fx"], 0.0, c["cx"]], [0.0, c["fy"], c["cy"]], [0.0, 0.0, 1.0]], np.float64)
+        R = np.asarray(c["R"], np.float64).reshape(3, 3)
+        C = np.asarray(c["c"], np.float64).reshape(3)
+        cams[f"cam{i:02d}"] = PinholeCamera(f"cam{i:02d}", K, R @ A, -R @ C,
+                                            int(c["w"]), int(c["h"]))
+    return cams
+
+
+class Capture:
+    """One `data/<PxCy>/` directory."""
+
+    def __init__(self, root: str | Path):
+        self.root = Path(root)
+        self.name = self.root.name
+        self.cameras = load_cameras(self.root / "cameras.json")
+        self.video_dir = self.root / "videos"
+        z = np.load(self.root / "smplx.npz", allow_pickle=False)
+        self.smplx = {k: z[k] for k in z.files}
+        self.frames: np.ndarray = self.smplx["frames"].astype(int)
+        self._idx = {int(f): i for i, f in enumerate(self.frames)}
+        self.smplx_forward_kwargs: dict = json.loads(str(self.smplx["smplx_kwargs"]))
+        self.meta: dict = json.loads(str(self.smplx["meta"]))
+        self.card: dict = json.loads((self.root / "capture.json").read_text()) \
+            if (self.root / "capture.json").exists() else {}
+
+    # ---------------------------------------------------------------- indexing
+    def index(self, frame: int) -> int:
+        if frame not in self._idx:
+            raise KeyError(f"{self.name}: no SMPL-X fit for GT frame {frame} "
+                           f"(have {self.frames[0]}..{self.frames[-1]})")
+        return self._idx[frame]
+
+    def video_frame(self, frame: int) -> int:
+        return frame - 1
+
+    # ---------------------------------------------------------------- SMPL-X
+    def smplx_params(self, frame: int, batched: bool = True) -> dict[str, np.ndarray]:
+        """The 10 SMPL-X forward() tensors at `frame`, shaped (1,D) if batched."""
+        i = self.index(frame)
+        out = {k: self.smplx[k][i] for k in PARAM_KEYS}
+        return {k: v[None] for k, v in out.items()} if batched else out
+
+    def joints(self, frame: int) -> np.ndarray:
+        return self.smplx["joints"][self.index(frame)]
+
+    # ---------------------------------------------------------------- video
+    def read_frame(self, cam: str, frame: int) -> tuple[np.ndarray, np.ndarray]:
+        """(rgb HxWx3 uint8, alpha HxW uint8) for one camera at one GT frame."""
+        import cv2
+        vf = self.video_frame(frame)
+        cap = cv2.VideoCapture(str(self.video_dir / f"{cam}.mp4"))
+        try:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, vf)
+            ok, bgr = cap.read()
+            if not ok:
+                raise RuntimeError(f"{cam}: cannot read video frame {vf}")
+        finally:
+            cap.release()
+        return _split(bgr)
+
+    def iter_frames(self, cam: str, start: int | None = None, end: int | None = None
+                    ) -> Iterator[tuple[int, np.ndarray, np.ndarray]]:
+        """Sequential decode (much faster than repeated seeks). Yields (frame, rgb, alpha)."""
+        import cv2
+        start = int(self.frames[0]) if start is None else start
+        end = int(self.frames[-1]) if end is None else end
+        cap = cv2.VideoCapture(str(self.video_dir / f"{cam}.mp4"))
+        try:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, self.video_frame(start))
+            for frame in range(start, end + 1):
+                ok, bgr = cap.read()
+                if not ok:
+                    break
+                rgb, alpha = _split(bgr)
+                yield frame, rgb, alpha
+        finally:
+            cap.release()
+
+    def __repr__(self) -> str:
+        c = next(iter(self.cameras.values()))
+        return (f"<Capture {self.name}: {len(self.cameras)} cams, {len(self.frames)} frames "
+                f"(GT {self.frames[0]}..{self.frames[-1]}), {c.width}x{c.height}>")
+
+
+def _split(bgr: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    w = bgr.shape[1] // 2
+    return bgr[:, :w, ::-1].copy(), bgr[:, w:, 0].copy()
+
+
+if __name__ == "__main__":
+    import argparse
+
+    ap = argparse.ArgumentParser(description="Smoke-test a capture directory.")
+    ap.add_argument("capture_dir", help="e.g. data/P1C1")
+    ap.add_argument("--frame", type=int, default=None)
+    ap.add_argument("--cam", default="cam03")
+    a = ap.parse_args()
+
+    cap = Capture(a.capture_dir)
+    print(cap)
+    print("smplx kwargs:", cap.smplx_forward_kwargs)
+    f = a.frame if a.frame is not None else int(cap.frames[len(cap.frames) // 2])
+    p = cap.smplx_params(f)
+    print(f"frame {f}: " + ", ".join(f"{k}{tuple(v.shape)}" for k, v in p.items()))
+
+    rgb, alpha = cap.read_frame(a.cam, f)
+    print(f"{a.cam} rgb{rgb.shape} alpha{alpha.shape} fg={float((alpha > 12).mean()):.3f}")
+
+    uv = cap.cameras[a.cam].project(cap.joints(f))
+    inside = ((uv[:, 0] >= 0) & (uv[:, 0] < rgb.shape[1]) &
+              (uv[:, 1] >= 0) & (uv[:, 1] < rgb.shape[0])).mean()
+    print(f"reprojected joints inside image: {inside:.1%}")

scripts/make_previews.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+"""Build the browsable QC previews for one capture.
+
+Reads (READ ONLY) the tracker's QC output:
+    <DEGAS_DATASET>/<PxCy>/hmt_seq_out/grid_f<frame:08d>.jpg     32-view contact sheet
+    <DEGAS_DATASET>/<PxCy>/hmt_seq_out/panels/f<frame>_cam<NN>.jpg  3-panel per view
+
+Writes into the HF staging tree:
+    previews/<PxCy>_f<frame:08d>.jpg     downscaled contact sheet, one per sampled frame
+                                          (this is the `image` column of the data viewer)
+    data/<PxCy>/preview.jpg               one representative contact sheet for the capture
+
+Usage:
+    python make_previews.py P1C1 --staging /mnt/sdb/degas_project/DREAMS-AVATAR-hf/staging
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from PIL import Image
+
+DATASET_ROOT = Path("/mnt/sdb/degas_project/DEGAS_DATASET")
+Image.MAX_IMAGE_PIXELS = None
+
+
+def _save_resized(src: Path, dst: Path, width: int, quality: int = 88) -> int:
+    im = Image.open(src).convert("RGB")
+    if im.width > width:
+        h = max(1, round(im.height * width / im.width))
+        im = im.resize((width, h), Image.LANCZOS)
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    im.save(dst, "JPEG", quality=quality, optimize=True, progressive=True)
+    return dst.stat().st_size
+
+
+def make_previews(capture: str, dataset_root: Path, staging: Path,
+                  grid_width: int = 1920, hero_width: int = 2560) -> dict:
+    out_dir = dataset_root / capture / "hmt_seq_out"
+    grids = sorted(out_dir.glob("grid_f*.jpg"))
+    if not grids:
+        raise SystemExit(f"no grid_f*.jpg under {out_dir} -- has the tracker finished {capture}?")
+
+    prev_dir = staging / "previews"
+    rows = []
+    total = 0
+    for g in grids:
+        frame = int(g.stem.split("_f")[1])
+        dst = prev_dir / f"{capture}_f{frame:08d}.jpg"
+        total += _save_resized(g, dst, grid_width)
+        rows.append({"file_name": dst.name, "frame": frame})
+
+    # capture-level preview.jpg: the middle sampled frame
+    mid = grids[len(grids) // 2]
+    cap_prev = staging / "data" / capture / "preview.jpg"
+    _save_resized(mid, cap_prev, hero_width)
+
+    print(f"[previews] {capture}: {len(rows)} grids -> {prev_dir} "
+          f"({total / 2**20:.1f} MB), preview.jpg from {mid.name}", flush=True)
+    return {"capture": capture, "n_previews": len(rows), "rows": rows,
+            "preview_source": mid.name, "bytes": total}
+
+
+def copy_showcase(capture: str, dataset_root: Path, staging: Path,
+                  frame: int, cams: list[int], width: int = 2560) -> list[str]:
+    """Copy the hand-picked 3-panel views used as the README hero images."""
+    panels = dataset_root / capture / "hmt_seq_out" / "panels"
+    out = []
+    for c in cams:
+        src = panels / f"f{frame:08d}_cam{c:02d}.jpg"
+        if not src.exists():
+            print(f"[showcase] MISSING {src}", file=sys.stderr)
+            continue
+        dst = staging / "assets" / "showcase" / f"{capture}_f{frame:08d}_cam{c:02d}.jpg"
+        _save_resized(src, dst, width, quality=92)
+        out.append(str(dst.relative_to(staging)))
+        print(f"[showcase] {src.name} -> {dst.relative_to(staging)}", flush=True)
+    return out
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("capture")
+    ap.add_argument("--dataset-root", type=Path, default=DATASET_ROOT)
+    ap.add_argument("--staging", type=Path, required=True)
+    ap.add_argument("--grid-width", type=int, default=1920)
+    ap.add_argument("--showcase-frame", type=int, default=None,
+                    help="also copy panels/f<frame>_cam<NN>.jpg into assets/showcase/")
+    ap.add_argument("--showcase-cams", type=int, nargs="*", default=[3, 6, 12])
+    a = ap.parse_args()
+
+    info = make_previews(a.capture, a.dataset_root, a.staging, a.grid_width)
+    if a.showcase_frame is not None:
+        info["showcase"] = copy_showcase(a.capture, a.dataset_root, a.staging,
+                                         a.showcase_frame, a.showcase_cams)
+    print(json.dumps({k: v for k, v in info.items() if k != "rows"}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/prepare_training.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python
+"""Decode one DREAMS-AVATAR capture into an AvatarReX / DEGAS-style training layout.
+
+NOTE ON SCOPE
+    This targets the DEGAS / DREAMS avatar *training input* format (flat
+    `calibration_full.json` + per-camera image folders + per-frame SMPL-X). The exact
+    key names and the image/mask split will be RECONCILED WITH THE TRAINING CODE in the
+    retrain phase -- treat the emitted tree as the proposed contract, not as frozen.
+    Everything here is derived from `data/<PxCy>/` alone, so re-emitting after a format
+    change is cheap (one ffmpeg pass per camera).
+
+INPUT   data/<PxCy>/{videos/cam*.mp4, smplx.npz, cameras.json}
+OUTPUT  <out>/
+          calibration_full.json          {"cam00": {K, R, T, RT, imgSize, ...}, ...}
+                                          R,T are WORLD-TO-CAMERA in the SMPL-X Y-up world
+          cam_00/00000001.jpg  ...        RGB, <frame:08d>.jpg, frame == GT frame id
+          cam_00/mask/00000001.png ...    alpha matte (only with --masks)
+          smplx/00000001.npz              per-frame SMPL-X params, (1,D) batched
+          smplx_params.npz                the same params stacked over the emitted range
+          meta.json                       what was emitted and with which conventions
+
+WHY THIS SHAPE
+  * `calibration_full.json` is flat (`{cam_name: entry}`) which is what AvatarReX and
+    the DEGAS trainer both consume -- unlike the capture's nested `rigs[i].cameras[0]`.
+  * The world Y-flip is BAKED IN here (R = R_json @ diag(1,-1,-1)), so the trainer needs
+    no knowledge of the DEGAS calibration quirk: cameras and SMPL-X are in one frame.
+  * Images are written as <GT frame id>, the same number that indexes `smplx.npz`, so a
+    dataloader can pair them by filename with no offset table.
+
+Examples
+    # every 4th frame, 8 front cameras, with masks
+    python prepare_training.py data/P1C1 --out /scratch/train/P1C1 \
+        --stride 4 --cams 0 3 6 9 12 15 18 21 --masks
+
+    # everything (32 cams x 1836 frames ~= 59k jpgs, ~40 GB) -- use --workers
+    python prepare_training.py data/P1C1 --out /scratch/train/P1C1 --workers 8
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+import sys
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from load_capture import PARAM_KEYS, Capture, load_cameras  # noqa: E402
+
+
+# --------------------------------------------------------------------- calibration
+def write_calibration(cap: Capture, out: Path) -> dict:
+    """Flat AvatarReX-style calibration_full.json (world-to-camera, Y-up world)."""
+    entries = {}
+    for name, c in cap.cameras.items():
+        entries[name] = {
+            "K": c.K.tolist(),
+            "R": c.R_w2c.tolist(),
+            "T": c.t_w2c.tolist(),
+            "RT": c.extrinsic.tolist(),
+            "imgSize": [c.width, c.height],
+            "width": c.width,
+            "height": c.height,
+            "D": [0.0] * 5,          # DEGAS captures ship all-zero distortion
+            "center": c.center.tolist(),
+        }
+    p = out / "calibration_full.json"
+    p.write_text(json.dumps(entries, indent=1) + "\n")
+    print(f"[calib] {p} ({len(entries)} cameras, world-to-camera, Y-up world)", flush=True)
+    return entries
+
+
+# --------------------------------------------------------------------- images
+def _decode_cam(video: Path, out_dir: Path, frames: list[int], rgb_w: int,
+                quality: int, masks: bool, jpg_dir_fmt: str) -> tuple[str, int]:
+    """One ffmpeg pass per camera; select only the wanted video frames."""
+    cam = video.stem
+    img_dir = out_dir / jpg_dir_fmt.format(cam=cam)
+    img_dir.mkdir(parents=True, exist_ok=True)
+    vidx = [f - 1 for f in frames]                       # GT frame -> video frame
+    sel = "+".join(f"eq(n\\,{v})" for v in vidx)
+
+    # RGB = left half
+    tmp = img_dir / "_tmp"
+    tmp.mkdir(exist_ok=True)
+    subprocess.run(
+        ["ffmpeg", "-y", "-v", "error", "-threads", "1", "-i", str(video),
+         "-vf", f"select='{sel}',crop={rgb_w}:in_h:0:0", "-vsync", "0",
+         "-q:v", str(quality), str(tmp / "%08d.jpg")],
+        check=True)
+    got = sorted(tmp.glob("*.jpg"))
+    if len(got) != len(frames):
+        raise RuntimeError(f"{cam}: ffmpeg returned {len(got)} frames, wanted {len(frames)}")
+    for src, f in zip(got, frames):
+        src.rename(img_dir / f"{f:08d}.jpg")
+    shutil.rmtree(tmp)
+
+    if masks:
+        mdir = img_dir / "mask"
+        mdir.mkdir(exist_ok=True)
+        tmp.mkdir(exist_ok=True)
+        subprocess.run(
+            ["ffmpeg", "-y", "-v", "error", "-threads", "1", "-i", str(video),
+             "-vf", f"select='{sel}',crop={rgb_w}:in_h:{rgb_w}:0,format=gray", "-vsync", "0",
+             str(tmp / "%08d.png")],
+            check=True)
+        for src, f in zip(sorted(tmp.glob("*.png")), frames):
+            src.rename(mdir / f"{f:08d}.png")
+        shutil.rmtree(tmp)
+    return cam, len(frames)
+
+
+# --------------------------------------------------------------------- smplx
+def write_smplx(cap: Capture, out: Path, frames: list[int]) -> None:
+    sdir = out / "smplx"
+    sdir.mkdir(parents=True, exist_ok=True)
+    stack = {k: [] for k in PARAM_KEYS}
+    for f in frames:
+        p = cap.smplx_params(f, batched=True)
+        np.savez(sdir / f"{f:08d}.npz", **p)
+        for k in PARAM_KEYS:
+            stack[k].append(p[k][0])
+    np.savez_compressed(out / "smplx_params.npz",
+                        frames=np.asarray(frames, np.int32),
+                        **{k: np.stack(v) for k, v in stack.items()},
+                        smplx_kwargs=np.asarray(json.dumps(cap.smplx_forward_kwargs)))
+    print(f"[smplx] {len(frames)} per-frame npz in {sdir} + smplx_params.npz", flush=True)
+
+
+# --------------------------------------------------------------------- driver
+def prepare(capture_dir: Path, out: Path, stride: int, start: int | None, end: int | None,
+            cams: list[int] | None, masks: bool, quality: int, workers: int,
+            jpg_dir_fmt: str, dry_run: bool) -> dict:
+    cap = Capture(capture_dir)
+    print(cap, flush=True)
+    out.mkdir(parents=True, exist_ok=True)
+
+    frames = [int(f) for f in cap.frames]
+    if start is not None:
+        frames = [f for f in frames if f >= start]
+    if end is not None:
+        frames = [f for f in frames if f <= end]
+    frames = frames[::stride]
+    names = ([f"cam{c:02d}" for c in cams] if cams else sorted(cap.cameras))
+    missing = [n for n in names if not (cap.video_dir / f"{n}.mp4").exists()]
+    if missing:
+        raise SystemExit(f"missing videos: {missing}")
+
+    rgb_w = next(iter(cap.cameras.values())).width
+    print(f"[plan] {len(names)} cams x {len(frames)} frames = {len(names) * len(frames)} images "
+          f"({rgb_w}x{next(iter(cap.cameras.values())).height}), masks={masks}", flush=True)
+    if dry_run:
+        return {"dry_run": True, "cams": names, "n_frames": len(frames)}
+
+    write_calibration(cap, out)
+    write_smplx(cap, out, frames)
+
+    jobs = [(cap.video_dir / f"{n}.mp4", out, frames, rgb_w, quality, masks, jpg_dir_fmt)
+            for n in names]
+    done = 0
+    if workers > 1:
+        with ProcessPoolExecutor(max_workers=workers) as ex:
+            futs = {ex.submit(_decode_cam, *j): j[0].stem for j in jobs}
+            for fu in as_completed(futs):
+                cam, n = fu.result()
+                done += n
+                print(f"[img] {cam}: {n} frames  ({done}/{len(jobs) * len(frames)})", flush=True)
+    else:
+        for j in jobs:
+            cam, n = _decode_cam(*j)
+            done += n
+            print(f"[img] {cam}: {n} frames  ({done}/{len(jobs) * len(frames)})", flush=True)
+
+    meta = {
+        "capture": cap.name,
+        "source": str(capture_dir),
+        "cams": names,
+        "frames": {"first": frames[0], "last": frames[-1], "stride": stride, "count": len(frames)},
+        "image_dir_format": jpg_dir_fmt,
+        "image_name_format": "{frame:08d}.jpg  (frame == GT frame id == smplx.npz['frames'])",
+        "masks": masks,
+        "image_size": [rgb_w, next(iter(cap.cameras.values())).height],
+        "calibration": "calibration_full.json, flat {cam: {K,R,T,RT,imgSize}}, "
+                       "world-to-camera, SMPL-X Y-up world (world_flip already applied)",
+        "smplx_kwargs": cap.smplx_forward_kwargs,
+        "video_frame_of": "GT frame - 1",
+        "status": "PROPOSED training contract -- reconcile with the trainer in the retrain phase",
+    }
+    (out / "meta.json").write_text(json.dumps(meta, indent=2) + "\n")
+    print(f"[done] {out}", flush=True)
+    return meta
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("capture_dir", type=Path, help="data/<PxCy>")
+    ap.add_argument("--out", type=Path, required=True)
+    ap.add_argument("--stride", type=int, default=1)
+    ap.add_argument("--start", type=int, default=None, help="first GT frame")
+    ap.add_argument("--end", type=int, default=None, help="last GT frame")
+    ap.add_argument("--cams", type=int, nargs="*", default=None, help="camera indices, default all")
+    ap.add_argument("--masks", action="store_true", help="also write the alpha matte as PNG")
+    ap.add_argument("--quality", type=int, default=2, help="ffmpeg -q:v (2 = near-lossless jpg)")
+    ap.add_argument("--workers", type=int, default=4)
+    ap.add_argument("--dir-format", default="cam_{cam}",
+                    help="per-camera image dir, e.g. 'cam_{cam}' -> cam_cam00/")
+    ap.add_argument("--dry-run", action="store_true")
+    a = ap.parse_args()
+    prepare(a.capture_dir, a.out, a.stride, a.start, a.end, a.cams, a.masks,
+            a.quality, a.workers, a.dir_format, a.dry_run)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/stage_capture.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+"""Assemble one capture into the HuggingFace staging tree.
+
+    staging/data/<PxCy>/videos/cam00.mp4 .. cam31.mp4   hardlink to frameset-videos/NN.mp4
+    staging/data/<PxCy>/cameras.json                    copy of the capture calibration
+    staging/data/<PxCy>/smplx.npz                       written by consolidate_smplx.py
+    staging/data/<PxCy>/preview.jpg                     written by make_previews.py
+    staging/data/<PxCy>/capture.json                    machine-readable capture card
+
+Videos are HARDLINKED (same filesystem, /mnt/sdb) so staging costs ~0 bytes and the
+source capture dir is never modified. Falls back to symlink, then copy.
+
+The source `frameset-videos/` must already be extracted (`7z x frameset-videos.7z`);
+--extract will do it if the directory is missing.
+
+Usage:
+    python stage_capture.py P1C1 --staging /mnt/sdb/degas_project/DREAMS-AVATAR-hf/staging
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+DATASET_ROOT = Path("/mnt/sdb/degas_project/DEGAS_DATASET")
+
+# The published set is 10 captures. C1 = train, C2 = test.
+# P1..P4 ship both sessions; P5/P6 are CROSS-REENACT DRIVING ONLY, so only their C2 is
+# published. P5C1 does not exist on disk at all; P6C1 exists but is deliberately excluded.
+INCLUDED = ["P1C1", "P1C2", "P2C1", "P2C2", "P3C1", "P3C2",
+            "P4C1", "P4C2", "P5C2", "P6C2"]
+EXCLUDED = {
+    "P5C1": "does not exist",
+    "P6C1": "excluded on purpose: P5/P6 contribute cross-reenact driving (C2) only",
+}
+
+
+def link_or_copy(src: Path, dst: Path) -> str:
+    if dst.exists() or dst.is_symlink():
+        dst.unlink()
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        os.link(src, dst)
+        return "hardlink"
+    except OSError:
+        try:
+            dst.symlink_to(src)
+            return "symlink"
+        except OSError:
+            shutil.copy2(src, dst)
+            return "copy"
+
+
+def probe_video(path: Path) -> dict:
+    out = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
+         "stream=width,height,nb_frames,r_frame_rate,codec_name,pix_fmt",
+         "-of", "json", str(path)],
+        capture_output=True, text=True, check=True).stdout
+    s = json.loads(out)["streams"][0]
+    num, den = s["r_frame_rate"].split("/")
+    return {"width": int(s["width"]), "height": int(s["height"]),
+            "n_frames": int(s["nb_frames"]), "fps": round(int(num) / int(den), 4),
+            "codec": s["codec_name"], "pix_fmt": s["pix_fmt"]}
+
+
+def stage(capture: str, dataset_root: Path, staging: Path, extract: bool = False,
+          force: bool = False) -> dict:
+    if capture in EXCLUDED and not force:
+        raise SystemExit(
+            f"{capture} is NOT part of DREAMS-AVATAR: {EXCLUDED[capture]}.\n"
+            f"published captures: {', '.join(INCLUDED)}   (--force to override)")
+    if capture not in INCLUDED and not force:
+        raise SystemExit(f"{capture} is not in the published set "
+                         f"({', '.join(INCLUDED)}); use --force to add it anyway")
+    src = dataset_root / capture
+    if not src.is_dir():
+        raise SystemExit(f"no such capture: {src}")
+
+    vdir = src / "frameset-videos"
+    if not vdir.is_dir() or not list(vdir.glob("*.mp4")):
+        if not extract:
+            raise SystemExit(f"{vdir} empty; re-run with --extract (runs 7z x)")
+        arc = src / "frameset-videos.7z"
+        print(f"[stage] extracting {arc} ...", flush=True)
+        subprocess.run(["7z", "x", "-y", f"-o{src}", str(arc)], check=True,
+                       stdout=subprocess.DEVNULL)
+
+    mp4s = sorted(vdir.glob("*.mp4"))
+    dst = staging / "data" / capture
+    mode = None
+    total = 0
+    for m in mp4s:
+        cam = int(m.stem)
+        mode = link_or_copy(m, dst / "videos" / f"cam{cam:02d}.mp4")
+        total += m.stat().st_size
+    print(f"[stage] {capture}: {len(mp4s)} videos via {mode} "
+          f"({total / 2**30:.2f} GiB)", flush=True)
+
+    cams_src = src / "cameras.json"
+    shutil.copy2(cams_src, dst / "cameras.json")
+    cams = json.loads(cams_src.read_text())
+    n_rigs = len(cams["rigs"])
+
+    v0 = probe_video(mp4s[0])
+    assert v0["width"] % 2 == 0
+    card = {
+        "capture": capture,
+        "subject": capture[:2],
+        "session": capture[2:],
+        "role": ("train" if capture.endswith("C1") else
+                 ("cross_reenact_driving" if capture[:2] in ("P5", "P6") else "test")),
+        "n_cams": len(mp4s),
+        "n_rigs_in_calibration": n_rigs,
+        "video": {**v0,
+                  "layout": "side-by-side: LEFT half = RGB, RIGHT half = alpha matte",
+                  "rgb_width": v0["width"] // 2},
+        "video_bytes": total,
+        "frame_convention": {
+            "smplx_frame": "GT frame id, 1-based; stored in smplx.npz['frames']",
+            "video_frame": "smplx_frame - 1, 0-based index into camNN.mp4",
+        },
+        "camera_convention": {
+            "K": "[[fx,0,cx],[0,fy,cy],[0,0,1]] from rigs[i].cameras[0]",
+            "R_w2c": "R @ diag(1,-1,-1)",
+            "t_w2c": "-R @ c",
+            "note": "cameras.json world is Y-down; the world_flip puts the fit in the "
+                    "same Y-up world as the DEGAS GT",
+        },
+    }
+    smplx_npz = dst / "smplx.npz"
+    if smplx_npz.exists():
+        import numpy as np
+        z = np.load(smplx_npz, allow_pickle=False)
+        card["n_frames"] = int(len(z["frames"]))
+        card["gt_frame_range"] = [int(z["frames"][0]), int(z["frames"][-1])]
+        card["smplx_kwargs"] = json.loads(str(z["smplx_kwargs"]))
+    (dst / "capture.json").write_text(json.dumps(card, indent=2) + "\n")
+    print(f"[stage] wrote {dst / 'capture.json'}", flush=True)
+    return card
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("capture")
+    ap.add_argument("--dataset-root", type=Path, default=DATASET_ROOT)
+    ap.add_argument("--staging", type=Path, required=True)
+    ap.add_argument("--extract", action="store_true", help="7z x frameset-videos.7z if missing")
+    ap.add_argument("--force", action="store_true",
+                    help="stage a capture outside the published 10 (P5C1/P6C1 are excluded)")
+    a = ap.parse_args()
+    print(json.dumps(stage(a.capture, a.dataset_root, a.staging, a.extract, a.force)))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/upload_capture.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# upload_capture.sh <PxCy> [--extract] [--meta-only] [--no-upload]
+#
+# One finished capture -> the public HF dataset `initialneil/DREAMS-AVATAR`.
+#
+# Published set (10): P1C1 P1C2 P2C1 P2C2 P3C1 P3C2 P4C1 P4C2 P5C2 P6C2
+#   C1 = train, C2 = test. P5/P6 are cross-reenact DRIVING only, so only their C2 ships.
+#   P5C1 does not exist; P6C1 is excluded on purpose (stage_capture.py refuses both).
+#
+#   1. stage      hardlink frameset-videos/NN.mp4 -> staging/data/<PxCy>/videos/camNN.mp4,
+#                 copy cameras.json, write capture.json
+#   2. smplx      hmt_seq_out/smplx/*.npz -> staging/data/<PxCy>/smplx.npz (verified lossless)
+#   3. previews   hmt_seq_out/grid_f*.jpg -> staging/previews/<PxCy>_f*.jpg + preview.jpg
+#   4. metadata   rebuild staging/previews/metadata.jsonl over ALL staged captures
+#   5. upload     small files in one commit, then the mp4s via resumable upload_large_folder
+#
+# The tracker's output dir is only ever READ.
+# Re-runnable: safe to re-run after a network drop, the large upload resumes.
+#
+#   ./upload_capture.sh P1C1
+#   ./upload_capture.sh P2C1 --extract        # if frameset-videos/ not unpacked yet
+#   ./upload_capture.sh P1C1 --meta-only      # refresh card/smplx/previews, skip the 2 GiB
+set -euo pipefail
+
+CAPTURE="${1:?usage: upload_capture.sh <PxCy> [--extract] [--meta-only] [--no-upload]}"
+shift || true
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BASE="$(dirname "$HERE")"
+STAGING="${STAGING:-$BASE/staging}"
+DATASET_ROOT="${DATASET_ROOT:-/mnt/sdb/degas_project/DEGAS_DATASET}"
+PY="${PY:-/home/szj/miniconda3/envs/omni_pose/bin/python}"
+LOGDIR="$BASE/logs"; mkdir -p "$LOGDIR"
+
+EXTRACT=""; META_ONLY=""; NO_UPLOAD=""
+for arg in "$@"; do
+  case "$arg" in
+    --extract)   EXTRACT="--extract" ;;
+    --meta-only) META_ONLY="--meta-only" ;;
+    --no-upload) NO_UPLOAD=1 ;;
+    *) echo "unknown flag: $arg" >&2; exit 2 ;;
+  esac
+done
+
+echo "=== [1/5] stage $CAPTURE ==============================================="
+"$PY" "$HERE/stage_capture.py" "$CAPTURE" --dataset-root "$DATASET_ROOT" \
+      --staging "$STAGING" $EXTRACT
+
+echo "=== [2/5] consolidate SMPL-X ==========================================="
+"$PY" "$HERE/consolidate_smplx.py" "$CAPTURE" --dataset-root "$DATASET_ROOT" \
+      --out "$STAGING/data/$CAPTURE/smplx.npz"
+
+# capture.json is written before smplx.npz exists on a first run -> refresh it
+"$PY" "$HERE/stage_capture.py" "$CAPTURE" --dataset-root "$DATASET_ROOT" \
+      --staging "$STAGING" >/dev/null
+
+echo "=== [3/5] previews ====================================================="
+"$PY" "$HERE/make_previews.py" "$CAPTURE" --dataset-root "$DATASET_ROOT" \
+      --staging "$STAGING"
+
+echo "=== [4/5] metadata.jsonl + scripts ====================================="
+"$PY" "$HERE/build_metadata.py" --staging "$STAGING"
+mkdir -p "$STAGING/scripts"
+cp -f "$HERE"/*.py "$HERE"/*.sh "$STAGING/scripts/"    # ship the pipeline with the data
+
+if [[ -n "$NO_UPLOAD" ]]; then
+  echo "=== [5/5] upload SKIPPED (--no-upload) ==="
+  exit 0
+fi
+
+echo "=== [5/5] upload to HuggingFace ========================================"
+LOG="$LOGDIR/upload_${CAPTURE}_$(date +%Y%m%d_%H%M%S).log"
+echo "log: $LOG"
+"$PY" "$HERE/hf_upload.py" --staging "$STAGING" --capture "$CAPTURE" $META_ONLY 2>&1 | tee "$LOG"
+echo "=== done: https://huggingface.co/datasets/initialneil/DREAMS-AVATAR ==="