--- 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`: ![P1C1 f1399 cam03](https://huggingface.co/datasets/initialneil/DREAMS-AVATAR/resolve/main/assets/showcase/P1C1_f00001399_cam03.jpg) ![P1C1 f1399 cam06](https://huggingface.co/datasets/initialneil/DREAMS-AVATAR/resolve/main/assets/showcase/P1C1_f00001399_cam06.jpg) ![P1C1 f1399 cam12](https://huggingface.co/datasets/initialneil/DREAMS-AVATAR/resolve/main/assets/showcase/P1C1_f00001399_cam12.jpg) 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// 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/ _f.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 `.jpg` and `mask/.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="", 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..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} } ```