DREAMS-AVATAR

The DREAMS-Avatar dataset from the 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 the 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:

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
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
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
  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 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:

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

pip install huggingface_hub numpy opencv-python
huggingface-cli download initialneil/DREAMS-AVATAR --repo-type dataset \
    --include "data/P1C1/*" "scripts/*" --local-dir ./DREAMS-AVATAR

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:

python scripts/verify_alignment.py data/P1C1 --cams 6 12 --start 1300 --count 250 --expect 0

Rebuilding the mesh:

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:

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:

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

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:

huggingface-cli download initialneil/DREAMS-AVATAR --repo-type dataset \
    --include "data/P1C1/*" "scripts/*" --local-dir ./DREAMS-AVATAR

Equivalent from 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

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:

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 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:

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.

---

How the registration was produced

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, 600 dense 2D surface landmarks
hands	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.

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: Detailed Expressions on Full-Body Gaussian Avatars (3DV 2025), which introduced these captures as the DREAMS-Avatar dataset
• Holistic-Tracker: the monocular counterpart

Licence

CC 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.

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 and stays under its own licence from the Max Planck Institute; nothing here grants any right to it.

Citation

Please cite the DEGAS paper.

@inproceedings{shao2025degas,
  title     = {DEGAS: Detailed Expressions on Full-Body Gaussian Avatars},
  author    = {Shao, Zhijing and Wang, Duotun and Tian, Qing-Yao and Yang, Yao-Dong and Meng, Hengyu and Cai, Zeyu and Dong, Bo and Zhang, Yu and Zhang, Kang and Wang, Zeyu},
  booktitle = {International Conference on 3D Vision (3DV)},
  year      = {2025}
}