| --- |
| pretty_name: DREAMS-AVATAR |
| license: cc-by-nc-4.0 |
| 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 |
|
|
| **The DREAMS-Avatar dataset from the [DEGAS](https://initialneil.github.io/DEGAS) paper |
| (3DV 2025), re-registered to pure SMPL-X.** |
|
|
| These are the same multiview captures introduced as the *DREAMS-Avatar dataset* in DEGAS |
| (Fig. 1b); what is new here is the registration. |
|
|
| 32 calibrated, matted camera views of a full-body performance, with one SMPL-X body fitted |
| to all views at once by our multiview tracker: 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`: |
|
|
|  |
|  |
|  |
|
|
| One instant of `P1C1` (frame 1399, an open-hand gesture) through three of the 32 cameras: |
| a front face closeup, a full-body wide view, and a back-oblique view. It is the **same |
| single SMPL-X body** in all three. The hands are read from RGB (WiLoR) rather than zeroed, |
| and the face is driven by dense MediaPipe landmarks, which is what makes the 100 expression |
| coefficients observable at all. |
|
|
| > The caption burned into P1C1's QC renders reads one higher than the true frame |
| > (`f1400` here, and likewise in the `previews/` contact sheets). Those images were |
| > rasterised before the frame renumbering described below and were renamed rather than |
| > re-rendered. **The filenames and every metadata column are correct**; only the pixels |
| > carry the stale number. Captures other than P1C1 are unaffected. |
|
|
| 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` | |
| | Face control | **both** paths shipped: the fitted SMPL-X expression + jaw, and per-frame 512-d DPE codes in `dpe/` ([details](#driving-the-face-smpl-x-expression-or-dpe-codes)) | |
| | 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 | |
|
|
| --- |
|
|
| ## 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 |
| dpe/dpe-multi-faces.zip per-frame DPE expression codes (optional face path) |
| dpe/dpe_meta.json which cameras, reference frame, crop, per-cam stats |
| 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 |
| dreams_to_actorshq.py convert a capture into an ActorsHQ-format tree |
| verify_alignment.py re-measure the video<->SMPL-X frame offset |
| prepare_training.py decode into an AvatarReX / DEGAS training layout |
| extract_dpe_codes.py regenerate the DPE codes yourself |
| upload_capture.sh packaging + upload pipeline (for maintainers) |
| ``` |
|
|
| ### The Data tab |
|
|
| `previews/metadata.jsonl` is loaded by the `imagefolder` builder, so the **Data** tab is a |
| browsable index of every fitted frame that has QC output: one row per |
| (capture x every 100th frame), with the 32-view contact sheet as the `image` column plus |
|
|
| `capture`, `subject`, `session`, `role`, `frame`, `video_frame`, `n_cams`, `n_frames`, |
| `n_views_fit` (views the fit actually used), `n_face_views` (views with an accepted face |
| crop), `stages` (`A+B+C+F` cold start / `W` warm), `joint_span_y_m` (vertical extent of the |
| SMPL-X joints, a cheap "did the fit explode" number rather than a body height), and the |
| repo-relative paths to the full-resolution `videos` / `smplx` / `cameras`. |
|
|
| Sort or filter on `n_face_views` or `joint_span_y_m` to find the frames worth inspecting. |
|
|
| ### `videos/camNN.mp4` carries two things |
|
|
| Each file is **4096 x 1500** and is published **uncropped on purpose**: |
|
|
| | half | pixels | what it is | |
| |---|---|---| |
| | **left** | `0..2047` | the matted RGB image (black background) | |
| | **right** | `2048..4095` | the **alpha matte**: a binary silhouette registered to the colour half within a few pixels, replicated over 3 channels | |
|
|
| The right half is the **foreground mask that avatar training needs**, not a rendering |
| artifact, so it is shipped as data. Do not crop the videos to the left half when |
| re-packaging. `scripts/load_capture.py` returns `(rgb, alpha)` from one decode, and |
| `scripts/prepare_training.py` splits them into `<frame>.jpg` and `mask/<frame>.png` |
| (masks are emitted **by default**). |
|
|
| The calibration `(fx, fy, cx, cy, w=2048, h=1500)` refers to the left half; both halves |
| share it, pixel for pixel. 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 | 0-based frame id. This is the index everything else is keyed by. | |
| | `video_frames` | `(T,)` int32 | equal to `frames` (d=0); shipped so no offset has to be remembered | |
| | `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: there is no offset (d = 0), uniformly, for every capture.** |
|
|
| ``` |
| smplx.npz["frames"][i] == 0-based frame index in videos/camNN.mp4 == GT frame index |
| ``` |
|
|
| One number indexes everything. `smplx.npz["video_frames"]` is shipped as an explicit |
| column and is equal to `frames`, so a reader never has to remember whether an offset |
| applies. |
|
|
| > **History, because it cost us a day.** P1C1 was first tracked assuming `GT = video + 1`. |
| > That offset had been measured on a near-static frame, where every candidate offset looks |
| > identical, and it was wrong. Re-measured on high-motion frames against the alpha matte, |
| > the true offset is 0, and P1C1's fits were renumbered from `1..1836` to `0..1835` |
| > accordingly. A one-frame error is nearly invisible in a still overlay and poisons every |
| > downstream avatar, so the offset is now **measured per capture, never assumed**: |
| > `scripts/verify_alignment.py` re-derives it from the shipped files alone and refuses to |
| > answer when the window it was given cannot resolve it. |
| > |
| > If you pulled P1C1 before this renumbering, re-download `data/P1C1/smplx.npz`. The |
| > videos and calibration never changed. |
| |
| **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 |
|
|
| # `frame` is the same number as the mp4 frame index: no offset, ever. |
| rgb, alpha = cap.read_frame("cam03", frame=1399) # (1500,2048,3), (1500,2048) |
| uv = cap.cameras["cam03"].project(cap.joints(frame=1399)) # (144,2) pixels |
| |
| params = cap.smplx_params(frame=1399) # 10 arrays, each (1, D) |
| print(cap.smplx_forward_kwargs) # feed straight into smplx.SMPLX(...) |
| ``` |
| |
| Re-derive the frame offset yourself, from the shipped files only: |
| |
| ```bash |
| python scripts/verify_alignment.py data/P1C1 --cams 6 12 --start 1300 --count 250 --expect 0 |
| ``` |
| |
| 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(1399).items()}) |
| verts = out.vertices[0].numpy() # (10475,3) in the same world as the cameras |
| ``` |
| |
| Sequential decode is far cheaper than seeking, and gives you the matte for free: |
| |
| ```python |
| for frame, rgb, alpha in cap.iter_frames("cam03", start=0, end=200): |
| ... # alpha is the mp4's right half |
| ``` |
| |
| ## 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 --workers 8 |
| ``` |
|
|
| ``` |
| /scratch/train/P1C1/ |
| calibration_full.json {"cam00": {K, R, T, RT, imgSize, ...}} world-to-camera, Y-up |
| cam_cam00/00000000.jpg RGB from the mp4's LEFT half, named by frame id |
| cam_cam00/mask/00000000.png alpha matte from the RIGHT half |
| smplx/00000000.npz per-frame params, (1,D) |
| smplx_params.npz the same params stacked |
| meta.json |
| ``` |
|
|
| Masks are written **by default** (the matte is a training input); pass `--no-masks` to skip |
| them. The world Y-flip is baked into `calibration_full.json`, so the trainer never sees the |
| DEGAS calibration quirk. |
|
|
| 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. |
|
|
| --- |
|
|
| ## Prepare for an ActorsHQ loader |
|
|
| Most full-body avatar codebases already read the **ActorsHQ** layout. `scripts/dreams_to_actorshq.py` |
| writes one, so an *unmodified* ActorsHQ reader can train on DREAMS-AVATAR without knowing |
| anything about mp4 halves or Y-down calibration. |
|
|
| ### 1. Download |
|
|
| ```bash |
| pip install "huggingface_hub[cli]" numpy opencv-python torch # torch only for the .pt |
| huggingface-cli download initialneil/DREAMS-AVATAR --repo-type dataset \ |
| --local-dir ./DREAMS-AVATAR |
| ``` |
|
|
| One capture is ~2 GiB, so pull only what you need: |
|
|
| ```bash |
| huggingface-cli download initialneil/DREAMS-AVATAR --repo-type dataset \ |
| --include "data/P1C1/*" "scripts/*" --local-dir ./DREAMS-AVATAR |
| ``` |
|
|
| Equivalent from Python: |
|
|
| ```python |
| from huggingface_hub import snapshot_download |
| snapshot_download("initialneil/DREAMS-AVATAR", repo_type="dataset", |
| allow_patterns=["data/P1C1/*", "scripts/*"], |
| local_dir="./DREAMS-AVATAR") |
| ``` |
|
|
| `load_dataset("initialneil/DREAMS-AVATAR")` gives you the **QC preview index only** (the |
| `imagefolder` build over `previews/`) — it is for browsing in the Data tab, not for |
| training. Training needs the files on disk, so use `huggingface-cli download` / |
| `snapshot_download`. |
|
|
| ### 2. Convert a capture |
|
|
| ```bash |
| cd DREAMS-AVATAR |
| python scripts/dreams_to_actorshq.py --capture-dir data/P1C1 --out actorshq/P1C1 |
| ``` |
|
|
| Needs `ffmpeg` on `PATH`. Full-resolution, all 32 cameras, all 1836 frames is ~59k images; |
| subset while you are still wiring things up: |
|
|
| ```bash |
| python scripts/dreams_to_actorshq.py --capture-dir data/P1C1 --out actorshq/P1C1 \ |
| --scale 2x --stride 4 --cams 0 2 4 6 8 10 12 14 --workers 8 \ |
| --smplx-model-dir /path/to/smplx --verify |
| ``` |
|
|
| | flag | effect | |
| |---|---| |
| | `--scale 1x\|2x\|4x` | image size: `2048x1500` / `1024x750` / `512x375`. `calibration.csv` stores focal and principal point **normalised**, so the same rows are valid at every scale; only `w,h` change. Default `2x`. | |
| | `--stride`, `--frames A B` | frame subset (frame ids, not row numbers) | |
| | `--cams` | which cameras to **decode**. `calibration.csv` always holds all 32 (see the warning below). | |
| | `--smplx-model-dir` | dir with `SMPLX_NEUTRAL.npz`; lets the compat `.npz` fold in `hands_mean` | |
| | `--verify` | re-projects the SMPL-X joints through `cameras.json` and through the emitted csv and fails if they disagree by more than 1e-3 px | |
| | `--no-masks`, `--no-images` | skip the alpha mattes / skip decoding entirely | |
|
|
| Output: |
|
|
| ``` |
| actorshq/P1C1/ |
| 2x/ |
| calibration.csv ActorsHQ convention, all 32 cameras |
| rgbs/Cam001/Cam001_rgb000000.jpg ... the mp4's LEFT half |
| masks/Cam001/Cam001_mask000000.png ... the mp4's RIGHT half (alpha matte) |
| smplx_dreams.pt SMPL-X, lossless, with model metadata |
| smpl_params.npz SMPL-X, float arrays only (compat) |
| dreams_meta.json what was emitted, and under which conventions |
| ``` |
|
|
| ### 3. Point the loader at it |
|
|
| `calibration.csv` is exactly Synthesia's: |
|
|
| ``` |
| name,w,h,rx,ry,rz,tx,ty,tz,fx,fy,px,py |
| ``` |
|
|
| `(rx,ry,rz)` is the axis-angle of the **camera-to-world** rotation, `(tx,ty,tz)` is the |
| **camera centre in world space**, and `fx,fy,px,py` are **normalised** by `w,h` |
| (`fx_pixels = fx * w`). That is what `actorshq.dataset.camera_data.read_calibration_csv` |
| expects, and what DEGAS's own `read_ActorsHQ_cameras` reconstructs as |
| `R = Rodrigues(rvec).T`, `c = (tx,ty,tz)`. |
|
|
| > **Camera numbering.** ActorsHQ readers derive the image folder from the calibration |
| > **row index** (`Cam%03d % (i+1)`), not from the `name` column. So the csv is always |
| > written **dense**: row `i` is DREAMS `cam{i:02d}` is `Cam{i+1:03d}`, whether or not that |
| > camera was decoded. A 1-based `cam_select` in your config therefore means what it looks |
| > like it means. Do not filter rows out of the csv. |
| |
| SMPL-X is not part of the ActorsHQ spec (ActorsHQ ships none), so two files are written: |
| |
| * **`smplx_dreams.pt`** — `torch.load` → dict. Lossless: keeps `flat_hand_mean=False`, |
| `num_betas=300`, `num_expression_coeffs=100`, plus `gender`/`model_type`/`use_pca`. |
| **Prefer this one.** In DEGAS: `smplx_type: smplx_dreams.pt`. |
| * **`smpl_params.npz`** — float arrays only, the AnimatableGaussians-style file some |
| readers insist on. An `.npz` cannot carry the model metadata (a loader that turns every |
| array into a tensor chokes on strings and 0-d scalars), which costs two things: |
| `flat_hand_mean` is assumed `True`, so `hands_mean` is **folded into the hand poses** |
| (needs `--smplx-model-dir`); and `num_expression_coeffs` cannot be expressed, so |
| `expression` is **omitted** by default (`--npz-expression-coeffs 10` writes the leading |
| 10 instead). Geometry is otherwise identical; only the face is dropped. |
|
|
| Both are indexed so that **row index == frame id**, matching the `%06d` in the image |
| filenames, because ActorsHQ-style loaders index the SMPL-X arrays with the raw frame |
| number. |
|
|
| ### Things worth knowing before you start |
|
|
| * **`videos/camNN.mp4` is 4096x1500 and holds two images**: LEFT 2048 = matted RGB, |
| RIGHT 2048 = the alpha matte. The converter splits them into `rgbs/` and `masks/`. |
| * **There is no frame offset (d = 0)**: `smplx.npz["frames"][i]` is the mp4 frame index is |
| the number in the emitted filenames. Re-derive it yourself with |
| `scripts/verify_alignment.py`. |
| * **`C1` is the train capture and `C2` the test capture** of the same subject. Convert both |
| and hold `C2` out; `P5`/`P6` ship `C2` only, as cross-reenactment driving sequences. |
| * The world is **Y-up** everywhere in the emitted tree — the `cameras.json` Y-down flip is |
| baked into the calibration, so cameras and SMPL-X share one frame. |
|
|
| ### Not using ActorsHQ? DEGAS reads this dataset natively |
|
|
| If you are training [DEGAS](https://initialneil.github.io/DEGAS) itself, there is no need |
| to convert or to duplicate ~40 GB of jpgs. DEGAS has a `frameset_type: dreams` reader that |
| consumes `cameras.json` + `smplx.npz` + the mp4s directly and decodes only the |
| (camera, frame) pairs a split asks for into a local cache: |
|
|
| ```yaml |
| dataset: |
| dat_dir: /path/to/DREAMS-AVATAR/data/P1C1 |
| frameset_type: dreams |
| scale: 2x |
| resolution: 1 |
| train: {frm_list: np.arange(0, 1836, 4).tolist(), cam_select: [0, 2, 4, 6], mini_batch: 1} |
| ``` |
|
|
| `cam_select` is **0-based** there (`cam00`..`cam31`, matching the mp4 names), unlike the |
| 1-based ActorsHQ path. The two paths are checked against each other: identical cameras, |
| byte-identical decoded RGB and masks, identical SMPL-X tensors. |
|
|
| --- |
|
|
| ## Driving the face: SMPL-X expression, or DPE codes |
|
|
| This dataset ships what you need for **both** ways of animating the face, and they are |
| mutually exclusive: pick one per training run. |
|
|
| ### Path 1: the fitted SMPL-X expression (in `smplx.npz`) |
|
|
| `smplx.npz` carries a real 100-dim `expression` and a `jaw_pose` per frame, fitted from |
| dense MediaPipe face landmarks across every view that saw the face. Let them drive the |
| mesh and the posed geometry moves its own face; an appearance network conditioned on that |
| geometry sees the expression for free, with no extra input and no architecture change. |
|
|
| Nothing extra to download. In DEGAS this is `smplx_nofacial: ''`. |
|
|
| ### Path 2: per-frame DPE expression codes (in `dpe/`) |
|
|
| This is the formulation in the DEGAS paper: **neutralize the mesh's face** and drive it |
| from a separate code instead. Two steps, and both are required: |
|
|
| 1. Zero the mesh's facial parameters (`smplx_nofacial: exp+jaw`, plus |
| `optim_skip: [expression, jaw_pose]` so they stay zero). The mesh then carries pose and |
| identity but no facial motion at all. |
| 2. Feed the decoder's 512-d face branch a per-frame code from `dpe/dpe-multi-faces.zip`. |
|
|
| ``` |
| dpe/dpe-multi-faces.zip members dpe-{frame:06d}-cam{cc:02d}.pt |
| each a dict {'exp': FloatTensor(1, 512)} |
| dpe/dpe_meta.json cams, ref_frame, pad, dim, and per-camera statistics |
| ``` |
|
|
| The members are keyed by **frame id**, not by position in a split, so a code can never be |
| silently mis-paired with a frame when you change `frm_list`. Two cameras are stored per |
| frame; a loader is expected to concatenate them to `(N_faces, 512)` and sample a random |
| convex combination as augmentation. |
|
|
| | capture | codes | cameras | reference frame | expression range (per-dim std, cam07 / cam30) | |
| |---|---|---|---|---| |
| | P1C1 | 3672 | cam07, cam30 | 918 | 0.323 / 0.332 | |
| | P1C2 | 586 | cam07, cam30 | 146 | 0.171 / 0.229 | |
| | P2C1 | 3736 | cam07, cam30 | 934 | 0.248 / 0.247 | |
| | P2C2 | 800 | cam07, cam30 | 200 | **0.090 / 0.095** | |
| | P3C1 | 3664 | cam07, cam30 | 916 | 0.267 / 0.302 | |
| | P3C2 | 814 | cam07, cam30 | 203 | 0.243 / 0.366 | |
| | P4C1 | 3098 | cam07, cam30 | 774 | 0.291 / 0.347 | |
| | P4C2 | 526 | cam07, cam30 | 131 | 0.238 / 0.260 | |
| | P5C2 | 622 | cam07, cam30 | 155 | 0.149 / 0.180 | |
| | P6C2 | 350 | cam07, cam30 | 87 | **0.325 / 0.376** | |
|
|
| **All 10 captures are covered**, including `P5C2` and `P6C2`, the cross-reenactment driving |
| sequences, so an avatar can be driven by another subject's session on the DPE path as well |
| as on the SMPL-X one. |
|
|
| Counts are codes, not frames: each frame contributes one code per camera, so a capture of |
| *N* frames shot with two cameras yields 2*N*. |
|
|
| **Pick your driving sequence by that last column.** It is how much the expression code |
| actually moves over the capture, so it is a direct measure of how much facial motion there |
| is to transfer. Every `C2` is flatter than its own `C1` (they are short takes), but the |
| spread among them matters: **`P6C2` is the liveliest of all ten** and is the one to reach |
| for in a cross-reenactment demo, while **`P2C2` is by far the flattest** and will make any |
| expression-transfer method look like it is doing nothing. That is a property of the take, |
| not of the method. |
|
|
| **There is no `P5` or `P6` avatar, and there will not be one.** `P5C1` does not exist in |
| the source dataset and `P6C1` was excluded, so there is nothing to train those two subjects |
| on. Their `C2` captures exist precisely so they can *drive somebody else's* avatar. |
|
|
| **How they were made.** The code is `mlp_exp(dir(mlp(enc(face_crop))))` from |
| [OpenTalker/DPE](https://github.com/OpenTalker/DPE)'s `Generator(size=256, style_dim=512, |
| motion_dim=20)`. That is exactly the tensor DPE's own `dec_exp` consumes, so it carries |
| expression and nothing else, and 512 is exactly DEGAS's `n_face_embs`: nothing is reshaped, |
| padded or projected. `enc.net_app` takes a single image, so the code is an absolute |
| per-frame function with no reference frame to choose and no convention to get wrong. The |
| face box comes from S3FD on one reference frame, expanded by 50 px, then held fixed for the |
| sequence, matching DPE's own `crop_video.py`. |
|
|
| **The crop is a FIXED box, not per-frame tracking.** S3FD detects once on a reference |
| frame, the box is padded by 50 px per side, and that box is reused unchanged for the rest |
| of the sequence, which is what DPE's own `crop_video.py` does. A subject who moves |
| substantially out of that box degrades, and nothing re-detects to recover. The reference |
| frame is mid-sequence by default (`frames[len // 2]`), never hand-picked, and both the |
| frame and the resulting box are recorded per capture in `dpe_meta.json` (`ref_frame` and |
| `stats.<cam>.box`), so every published code set is reproducible from its own metadata. |
|
|
| **The per-camera mix is stochastic, and it runs at evaluation time too.** A loader is |
| expected to draw `w ~ U(0,1)^N`, normalise it, and return `einsum('i,ij->j', w, codes)`, |
| redrawn on every sample. In DEGAS that is exactly what `__getitem__` does, during training |
| *and* during evaluation, so DPE-driven evaluation is not deterministic across cameras. If |
| you need reproducible numbers, restrict the evaluation to a single camera per frame. |
|
|
| **Cameras 07 and 30 are frontal tele views, and both are inside the training split.** The |
| held-out evaluation camera (cam03, the frontal face closeup) is deliberately excluded, so |
| no evaluation pixels leak into the face conditioning. Keep that property if you regenerate: |
|
|
| ```bash |
| python scripts/extract_dpe_codes.py --capture data/P1C1 --cams 7 30 --out data/P1C1/dpe |
| ``` |
|
|
| **Driving one session with another session's codes is a bug, not a feature.** When you |
| evaluate a P1C1-trained avatar on P1C2, point the loader at `data/P1C2/dpe/`, or you will |
| render P1C2's poses with P1C1's expressions. |
|
|
| In DEGAS, `with_face_dpe` resolves relative to `dat_dir` and accepts a directory, so |
| `with_face_dpe: dpe` is the whole configuration. |
|
|
| --- |
|
|
| ## How the registration was produced |
|
|
| Our multiview SMPL-X registration (release pending). The fitted |
| result is what this dataset ships, so you do not need the tracker itself to use the data. |
| 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, 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). |
|
|
| 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): Detailed Expressions on Full-Body Gaussian Avatars (3DV 2025), which introduced these captures as the DREAMS-Avatar dataset |
| - [DEGAS code](https://github.com/initialneil/DEGAS): training and evaluation, reads this dataset natively via `frameset_type: dreams` |
| - [DEGAS pretrained avatars](https://huggingface.co/initialneil/DEGAS): avatars trained on these captures, for both face paths |
|
|
| ## Licence |
|
|
| **[CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)** (Creative Commons |
| Attribution-NonCommercial 4.0 International). Free to use, share, and adapt for |
| non-commercial research with attribution; commercial use is prohibited. Full text in |
| [`LICENSE`](LICENSE). |
|
|
| Attribution: cite the DEGAS paper (see the citation below). |
|
|
| The SMPL-X body model is **not** included in this repository. It must be obtained from |
| [smpl-x.is.tue.mpg.de](https://smpl-x.is.tue.mpg.de) and stays under its own licence from |
| the Max Planck Institute; nothing here grants any right to it. |
|
|
| ## Citation |
|
|
| Please cite the DEGAS paper. |
|
|
| ```bibtex |
| @inproceedings{shao2025degas, |
| title = {{DEGAS: Detailed Expressions on Full-Body Gaussian Avatars}}, |
| author = {Zhijing Shao and Duotun Wang and Qing-Yao Tian and Yao-Dong Yang and Hengyu Meng and Zeyu Cai and Bo Dong and Yu Zhang and Kang Zhang and Zeyu Wang}, |
| booktitle = {Proceedings of the International Conference on 3D Vision (3DV)}, |
| year = {2025} |
| } |
| ``` |
|
|
