Capture guide

Capture setups for 4DGS

4dgspl.at builds a 4D Gaussian Splatting scene from 4–8 (or more) videos that record the same moment from different angles. You can get those videos from real cameras, phones, virtual cameras in 3D software, or by having an AI coding agent produce them. Whichever you choose, the deliverable is the same: one video per camera and, ideally, the camera calibration.

AStudio rigPermanently installed, calibrated cameras and fixed lighting. BPhones or manual setup4–8 phones on tripods; take it on set. CVirtual rig4–8 virtual cameras in Blender, Unreal or Unity; exact calibration. DWith AI agentsClaude Code or Codex builds the scene, renders and writes COLMAP.

A · Studio rig

If you have a permanent multi-camera rig (volumetric stage, motion-capture room), your calibration is most likely ready. Upload one video per camera and the calibration in one of the supported formats. Hardware-triggered sync (genlock/timecode) gives the best results.

Common rules for every method

Ring, framing, height, names, sync: rules that apply to every method

Ring: cameras stand around the performer at equal angles (6 cameras: 60°, 8: 45°), all aimed at the centre. We recommend 8 cameras; with 4, views between the cameras show ghosting (tests).
Framing: the performer fills 70–85 % of the frame height. For a 35 mm lens and a 1.8 m performer the radius is ≈4 m; step back a little for wide moves.
Height: chest height (≈1.5 m) for 6 cameras. With 8 or more, two interleaved heights: even cameras ≈1.1 m, odd cameras ≈2.1 m looking down at the target; only then are the top of the head and under the arms visible.
Target and level: every camera aims at the performer's torso (≈1 m) and stays level (no roll). The engine derives the scene centre and the up direction from this.
Portrait framing: for a single standing performer, holding all cameras in portrait (9:16) gives the performer ≈1.8× more pixels; stay landscape for wide arm movements.
Action area: the performer stays within the ≈1 m wide centre; every camera sees the whole performer with margin at the edges.
Cameras never move: no panning, sliding or zooming during the take.

Topic	Rule	Why
Names	`cam00.mp4`, `cam01.mp4` … in the same order as around the ring	Videos are matched to calibrated cameras by name.
Sync	All videos start at the same moment with the same frame rate (25 or 30 fps)	The engine assumes every camera sees the same instant in each frame; today you align the videos yourself.
Resolution	Identical everywhere (1920×1080 recommended), landscape	The calibration needs the same aspect ratio.
Image	Fixed focus, exposure and white balance; stabilization, HDR, motion blur and depth of field off	A changing image shows the same point in a different colour or place.
Backdrop and light	Plain single-colour backdrop; black (velvet) if possible, pure black (RGB 0, 0, 0) in virtual scenes; soft, flicker-free light	The performer separates cleanly. The engine can fill a grey or coloured backdrop with Gaussians, burying the scene in fog from new angles (test).
Duration	4–10 second clips	During early access the first few seconds of each project are processed.

Method B

Capture procedure with phones or a manual setup

Step by step with 4–8 phones: settings, calibration moment, clap sync, alignment

Without a professional rig, you can do your first 4DGS shoot with 4–8 phones or cameras in an afternoon.

Prepare the kitIdeally 4–8 phones of the same model, a tripod and phone mount for each, power and at least 10 GB free space. A plain backdrop (curtain, wall), soft light, and textured objects for calibration (patterned rug, newspapers, books, patterned boxes).
Set up the ringTape the centre of the scene on the floor. Place the cameras at equal angles and the same height as in the common rules, all facing that mark. Label them cam00, cam01… in order; cam00 is the performer's front.
Lock the settingsOn every device:
- Same resolution and frame rate (1080p, 30 fps), landscape.
- Main camera (1×); automatic ultra-wide switching, zoom and portrait mode off.
- Focus and exposure lock (AE/AF lock), fixed white balance; HDR and stabilization off.
- Manual-control apps such as Blackmagic Camera (iOS) or Open Camera (Android) help.
Start recording and give a calibration momentStart recording on all cameras. For the first 3–4 seconds keep textured objects in the centre and on the floor, then remove them. COLMAP estimates the camera poses from these frames. Do not touch the cameras.
Give a sync cueClap sharply or fire a flash where every camera can see it. That moment is the zero point you align the videos to.
ShootThe performer does a 4–10 second action in the centre. Nobody crosses the ring; the cameras do not move.
Align and name the videosFind the clap time in each video (peak in the audio waveform or the flash frame) and start the video there:
```
# cam00: clap at 3.40 s; keep 8 seconds, drop audio
ffmpeg -ss 3.40 -i raw/cam00.mov -t 8 -c:v libx264 -crf 18 -pix_fmt yuv420p -an out/cam00.mp4
```
Repeat for each camera with its own clap time. Automatic time sync on the server is in development.
Create the calibrationUse the frames from the calibration moment to create calibration.zip with COLMAP.
UploadCreate a project on 4dgspl.at with the number of cameras, upload camNN.mp4 into their slots and calibration.zip as the calibration, then press "Send for processing".

Camera calibration

Creating COLMAP data from images

COLMAP commands, accepted formats, automatic calibration on the server

The engine has to know each camera's position, orientation and field of view in the scene. That is the calibration; the open-source COLMAP estimates it from images.

Route	When	Status
Virtual rig export	Blender, Unreal, Unity: the cameras are known, so the calibration is exact	Blender script (beta) available
Run COLMAP yourself	Phone and camera shoots; steps below	Available today
Automatic COLMAP on the server	If you upload no calibration, the server will estimate it from the images	In development

Accepted formats

COLMAP text: a .zip with cameras.txt and images.txt. Camera model PINHOLE or SIMPLE_PINHOLE (undistorted). Image names in images.txt must be cam00.jpg, cam01.jpg…; the name without extension is matched to the video's camera label.
4dgs-cameras JSON: OpenCV convention (x right, y down, z forward), world → camera R, t (metres) and fx, fy, cx, cy.

COLMAP step by step

Install COLMAP (macOS: brew install colmap, Ubuntu: sudo apt install colmap, Windows: GitHub releases). Then extract each camera's frame from the calibration moment (with the textured objects in the scene) and solve:

# 1) One frame per video from the calibration moment (here at 1.5 s)
mkdir -p calib/images
for v in raw/cam*.mov; do
  name=$(basename "$v" .mov)                   # cam00, cam01, …
  ffmpeg -ss 1.5 -i "$v" -frames:v 1 -q:v 2 "calib/images/$name.jpg"
done

# 2) Features: one camera per image, undistorted PINHOLE model
colmap feature_extractor --database_path calib/db.db --image_path calib/images \
  --ImageReader.camera_model PINHOLE --ImageReader.single_camera 0

# 3) Match all pairs, build the sparse model
colmap exhaustive_matcher --database_path calib/db.db
mkdir -p calib/sparse
colmap mapper --database_path calib/db.db --image_path calib/images --output_path calib/sparse

# 4) Convert to text and package
mkdir -p calib/txt
colmap model_converter --input_path calib/sparse/0 --output_path calib/txt --output_type TXT
(cd calib/txt && zip ../../out/calibration.zip cameras.txt images.txt)

Were all cameras registered? calib/txt/images.txt needs one line per camera. If some are missing, add more texture to the scene at the calibration moment or move neighbouring cameras closer; solving from a single frame with 4 cameras can be hard, 6–8 cameras are more reliable.

Scale and orientation do not matter; the engine centres the scene on the camera ring itself.

The PINHOLE model ignores the small lens distortion of phones; with the main (1×) camera this is usually good enough.

Method C

4–8 camera virtual rig for Blender, Unreal and Unity

Blender script, Unreal and Unity steps, the plugin in development

Building a scene in 3D software and rendering from virtual cameras is the cleanest way to test the system and to produce synthetic training data: the cameras are perfectly synchronized and the calibration is exported, not estimated. Step-by-step page: Blender render to 4D Gaussian Splatting.

Cameras	Spacing	Layout (radius 3.5 m, target 1 m)
4	90°	Front, right, back, left; all at 1.5 m (trial only; ghosting in between)
6	60°	Equal spacing; all at 1.5 m
8	45°	Even cameras at 1.1 m, odd at 2.1 m (upper ones look slightly down) — recommended
12–16	30°–22.5°	Two interleaved rings: half at 1.0 m, half at 2.2 m; pays off with the "High" and "Highest" processing quality, and best for automatic COLMAP (neighbour angle ≤30°)

In every tool: 35 mm lens (36 mm sensor), lens shift 0, motion blur, depth of field, vignette, film grain, auto exposure and bloom off; cameras not animated; a pure black world background (RGB 0, 0, 0, Strength 0) — Blender colour values are linear, even 0.05 shows as ≈25 % grey; matte materials (Roughness ≥ 0.6, low Specular, Metallic 0): the engine cannot store view-dependent highlights, they leave streaks between angles; soft light from all sides; the same frame range rendered from every camera.

Blender Script · beta

Download our Python script that builds the rig, renders an MP4 per camera and writes calibration.zip: 4dgspl_blender_rig.py (MIT licensed). The calibration maths is tested against our engine's reader. The script writes the archive as kalibrasyon.zip; upload it as is.

Prepare the sceneModel or character at the origin, feet on the floor, Z up, metres; animation on the timeline (e.g. frames 1–120 at 30 fps).
Build the rig and render
```
blender -b myscene.blend -P 4dgspl_blender_rig.py -- --kamera 6 --yaricap 3.5 --cikti //out --render
```
From the UI: Scripting → Open → the script → Run Script (settings are in the AYARLAR block at the top). Options are in Turkish: --kamera cameras, --yaricap radius, --yukseklik height, --cikti output folder.
Using your own camerasFor your cameras named cam00… only write the calibration: -- --mevcut --cikti //out.
UploadUpload the camNN.mp4 files and the calibration zip from the output folder to your project.

Unreal Engine Scripts · beta

RigPlace 4–8 CineCameraActors (table above), aim each at the performer's torso with Look at Tracking; same focal length and sensor on every camera.
RenderA separate Movie Render Queue job per camera; anti-aliasing on, Motion Blur, Depth of Field, Vignette and Auto Exposure off; render PNG sequences and convert with ffmpeg -framerate 30 -i cam00/%04d.png -c:v libx264 -crf 18 -pix_fmt yuv420p cam00.mp4.
CalibrationOur Unreal Python scripts (rig setup, camera export and COLMAP converter) are shared with early-access users via hello@4dgspl.at. If you don't want to wait, create the calibration with COLMAP from the renders; a textured floor in the scene makes solving easier.

Unity

Rig4–8 cameras, Physical Camera on, 35 mm focal length / 36 mm sensor, Gate Fit: Horizontal, lens shift 0. Add a LookAt (or Cinemachine) to the target and keep positions fixed.
RenderWith the Unity Recorder package, one Movie Recorder per camera (H.264 MP4, constant 30 fps, same frame range). In post-processing turn off Motion Blur, Depth of Field, Bloom, Auto Exposure and Film Grain.
CalibrationUntil our plugin ships, create it with COLMAP from the renders.

The 4dgspl.at Rig plugin is in development In development

We are working on a plugin for Blender, Unreal and Unity that builds a 4–8 camera rig in one click, locks the settings to 4dgspl.at's rules, renders every camera, exports the calibration and uploads the result straight to your project. Today's Blender script is its first step. To be notified: hello@4dgspl.at.

Method D

4–8 view video and COLMAP generation with AI agents

Adjustable prompt for Claude Code / Codex with a live camera layout preview

Coding agents such as Claude Code and Codex can run Blender headless: they build the model you describe or use yours, animate it, render from 4–8 cameras and write the COLMAP calibration 4dgspl.at reads. The window below generates a detailed prompt from your settings; edit it as you like and paste it into your agent.

Why not AI video generation models? Text-to-video models "invent" each angle separately; they cannot deliver geometrically consistent, synchronized 4–8 views of the same moment with known camera poses. The 3D scene + render route gives consistent views and exact calibration.

Agent Model Describe the model Motion

Cameras Duration (s)

Frame rate Resolution

Ring radius (m) Camera height (m)

Background Prompt language

The prompt is generated only in your browser; nothing is sent anywhere. If you edited the text by hand, setting changes won't overwrite it; press "Rebuild from settings" to apply them.

What our tests taught us

The same scene with 4, 8 and 16 cameras

The same scene with 4, 8 and 16 cameras: times, quality and lessons

Our team rendered the same animated human figure in Blender with 4, 8 and 16 camera rings and processed it with our engine (2026-10-27; 4 s, 60 frames, 960×540 processing resolution, RTX 5080).

Cameras	Engine time	GPU peak	Gaussians	View from 45° between cameras
4	2 min 16 s	0.7 GB	5,596	Ghosting: doubled arm, dark smears on the legs
8	5 min 10 s	1.4 GB	7,256	Clean
16	5 min 16 s	1.4 GB	10,185	Clean; no clear gain over 8 at this resolution

4 cameras work, but views between cameras show ghosting. 6 cameras is the minimum, 8 is our recommendation.
Training PSNR is misleading: the 4-camera test scored highest (49.9 dB) because few images are easy to memorize. Judge quality from angles between the cameras.
Let the subject fill the frame: in the tests the figure covered ≈60 % of the frame height; aim for 70–85 % (radius ≈4 m for a 35 mm lens and a 1.8 m figure).
One height is not enough: all cameras were at 1.5 m, so the top of the head and under the arms stay weak. With 8 or more cameras use two heights.
Calibration units: the focal length must be in pixels. A test with the focal length written in the wrong unit ended as a grey screen; the engine now rejects such files up front.
The background must be pure black: when we processed the same human scene with a dark grey background (0.05 in Blender, ≈25 % grey on screen), the engine filled the background with Gaussians; the training cameras looked perfect (46 dB) while from new angles the figure was buried in fog. Black-background tests did not show this.
Glossy plastic leaves streaks and the space above the subject can cloud up: the Microduck robot's glossy white plastic left line-shaped streaks between angles, and a semi-transparent "cloud" stayed above the head and below the feet where no camera could tell it apart from the background. The engine now drops Gaussians that fall on the background when exporting; make materials matte when rendering.
AI-built scenes work: the raccoon and tomato figures made with the prompt window's settings processed without issues.

Checklist before uploading

The last five checks before uploading

6–8 videos (8 recommended) named cam00.mp4 … in the same order as around the ring; the performer fills 70–85 % of the frame height.
All with the same resolution, frame rate and length; all starting at the same moment.
Fixed focus, exposure and white balance; the cameras did not move during the take.
The calibration zip contains cameras.txt (PINHOLE) and images.txt; one line per camera, names camNN.
The performer is fully visible in every camera; plain backdrop.

Create an account and upload See the examples