chien90190/worldhmr-fastcam

K-pop Dance Clips

Paper | Project page | Code

Short clips of K-pop dance videos from YouTube, with a 3D estimate of every dancer and of the camera.

file	what it is
main.csv	616 clips from 306 videos (59.2k frames, 41 min)
pair.csv	11 pairs: the same moment filmed by a fancam and by the broadcast (22 clips)
fetch.py	downloads the videos and cuts out the clips
annotations/	3D dancers and camera, one file per clip
yolo11n_pose/	2D detections, one file per clip

• The videos are not included. fetch.py gets them from YouTube.
• The annotations are our estimates, not ground truth. Some clips have visible errors, such as jitter.
• The clips are for evaluation. There is no train / test split.

Get the clips

You need Python 3.9+, ffmpeg, and the newest yt-dlp.

pip install -U "yt-dlp[default,deno]"

python fetch.py main.csv --out_dir clips                         # all clips
python fetch.py main.csv --out_dir clips --clips 003_01 003_02   # some clips
python fetch.py pair.csv --out_dir pairs                         # the pairs

Each clip is saved as <clip_name>.mp4. Videos that are no longer on YouTube are listed at the end.

Update yt-dlp before every run. An old version often fails with HTTP Error 403: Forbidden. Last tested with yt-dlp 2026.08.19.

Clip lists

main.csv and pair.csv have the same columns, one row per clip. source_ means the YouTube video, clip_ means the clip you get.

column	meaning
clip_name	<video>_<clip>: 003_02 is the 2nd clip of video 003
youtube_url	the YouTube video
source_frame_rate	frame rate of the YouTube video (30 or 60 fps)
source_duration_seconds	length of the YouTube video
clip_frame_rate	frame rate of the clip: 24 fps
clip_width, clip_height	size of the clip in pixels; all 2D annotations use it
start_frame_24fps	first frame of the clip, after converting the whole video to 24 fps
end_frame_24fps	the frame after the last one (not included)
start_seconds, end_seconds	the same span in seconds, to find it in the YouTube player

Clips with the same video number come from the same video.

YouTube sometimes replaces a video with a new encode. fetch.py warns when the download does not match source_frame_rate or source_duration_seconds; the frames of that video may then be off.

In pair.csv, NN_reference is the fancam (fixed camera) and NN_target is the broadcast. Both clips have the same number of frames, and frame i of one shows the same moment as frame i of the other (within half a frame).

Annotations

annotations/main/<clip_name>.npz and annotations/pair/<clip_name>.npz. Each file has P people and T frames. Frame i is frame i of the clip.

key	shape	meaning
body_model	()	"smplx": the body is stored under the smplx/ keys
camera/intrinsics	(3,3)	camera matrix K, in pixels
camera/extrinsics	(T,4,4)	world to camera: x_cam = E @ x_world
track_id	(P,)	person id
detected	(P,T)	True if the person was detected on that frame; False if the pose is filled in
bbox_xyxy	(P,T,4)	detection box in pixels; NaN if none
keypoints_2d	(P,T,25,3)	ViTPose 2D keypoints (OpenPose BODY_25 order): x, y, confidence; NaN if none
contact	(P,T,6)	True if the joint is planted (not moving)
contact_joints	(6,)	names of those 6 joints
smplx/betas	(P,10)	SMPL-X body shape
smplx/global_orient	(P,T,3)	body rotation, world, axis-angle
smplx/body_pose	(P,T,63)	joint rotations, axis-angle
smplx/transl	(P,T,3)	position, world, meters
smplx_incam/global_orient, smplx_incam/body_pose, smplx_incam/transl	(P,T,..)	the same, in camera coordinates, before the world-space step; NaN where not detected

• World: +y is up, units are meters. Each clip has its own world.
• Camera: OpenCV style (x right, y down, z forward).
• Hands and face are not estimated.

Make the 3D meshes. Register (free) at https://smpl-x.is.tue.mpg.de and download SMPL-X v1.1; SMPLX_NEUTRAL.npz is inside. Then pip install smplx torch. The files have no hand or face parameters, so the code below sets them to zero:

import numpy as np, torch
from smplx import SMPLX

d = np.load("annotations/main/003_02.npz")
model = SMPLX("SMPLX_NEUTRAL.npz", use_pca=False, flat_hand_mean=True, num_betas=10)

p = 0                                         # first person
T = d["detected"].shape[1]
f = lambda x: torch.as_tensor(x, dtype=torch.float32)
zeros = lambda n: torch.zeros(T, n)
out = model(betas=f(d["smplx/betas"][p])[None].expand(T, -1),
            global_orient=f(d["smplx/global_orient"][p]),
            body_pose=f(d["smplx/body_pose"][p]),
            transl=f(d["smplx/transl"][p]),
            jaw_pose=zeros(3), leye_pose=zeros(3), reye_pose=zeros(3),
            left_hand_pose=zeros(45), right_hand_pose=zeros(45), expression=zeros(10))
verts = out.vertices.numpy()                  # (T, 10475, 3), world

E = d["camera/extrinsics"]
verts_cam = np.einsum("tij,tvj->tvi", E[:, :3, :3], verts) + E[:, None, :3, 3]
uv = np.einsum("ij,tvj->tvi", d["camera/intrinsics"], verts_cam)
uv = uv[..., :2] / uv[..., 2:]                # (T, 10475, 2), pixels

Keep only detected frames. Every person has a pose on every frame. Where the person was not detected, the pose is filled in. To skip those frames:

p, t = np.nonzero(d["detected"])
transl = d["smplx/transl"][p, t]              # (N, 3)
E_t    = d["camera/extrinsics"][t]            # (N, 4, 4), same rows

Pairs

• NN_target: our estimate on the broadcast clip.
• NN_reference: our estimate on the fancam clip. Use it as the ground truth for NN_target.
• The same track_id in both files is the same person.
• A track_id that is only in NN_reference is a person NN_target missed.
• The two files have different world coordinates. target_to_reference converts NN_target coordinates to NN_reference coordinates.

NN_reference has no smplx_incam/ keys and has two more:

key	shape	meaning
smpl_joints_world	(P,T,24,3)	SMPL joints, world
target_to_reference	(4,4)	x_ref = S @ x_target: scale, rotation around +y, and shift

r = np.load("annotations/pair/01_reference.npz")
t = np.load("annotations/pair/01_target.npz")
S = r["target_to_reference"]
for tid in set(r["track_id"]) & set(t["track_id"]):
    i = list(r["track_id"]).index(tid)        # the same person in both files
    j = list(t["track_id"]).index(tid)
    # build person j's joints or vertices from t as above, then
    # x_ref = x_target @ S[:3, :3].T + S[:3, 3]

Evaluating your own method. The shared track_ids and target_to_reference are computed for our NN_target only. To evaluate your own estimate on a broadcast clip, match its people to those in NN_reference and fit your own alignment.

2D detections

yolo11n_pose/main/<clip_name>.npz and yolo11n_pose/pair/NN_target.npz. Every person YOLO11n-pose (ultralytics 8.4.14) finds on every frame. We use them to measure how well the 3D estimate lines up with the video. D is the largest number of detections on one frame.

key	shape	meaning
bbox_xyxy	(T,D,4)	box in pixels; NaN if the frame has fewer detections
score	(T,D)	detection confidence; NaN if none
keypoints_2d	(T,D,17,3)	COCO 17 keypoints: x, y, confidence; NaN if none
joint_names	(17,)	keypoint names

The detections are not linked across frames or to track_id.

Terms

• License. The annotations, the 2D detections and the two CSV files are under CC BY-NC 4.0 (https://creativecommons.org/licenses/by-nc/4.0/): free for non-commercial use, with credit. fetch.py is under the MIT License. See LICENSE.
• Videos. The videos belong to their owners. We do not host or share them; the CSV files only point to public YouTube videos. Whether you may download them depends on YouTube's terms and the owners' rights.
• SMPL-X. The SMPL-X model is not included. Download it from https://smpl-x.is.tue.mpg.de and follow its license.
• Removal. If you own a video here, or appear in one, and want it removed, contact authors with the clip_name or YouTube URL. It will be removed in the next version.