FPP-ML-Bench: Fringe Projection Profilometry Benchmarking Dataset

The first open-source, photorealistic synthetic dataset for single-shot fringe projection profilometry (FPP), generated using VIRTUS-FPP in NVIDIA Isaac Sim. This dataset enables standardized benchmarking and systematic comparison of deep learning approaches for single-shot 3D depth reconstruction from fringe patterns.

Dataset Summary

Property	Value
Total fringe images	15,600 (52 per viewpoint × 6 viewpoints × 50 objects)
Depth reconstructions	300 (6 viewpoints × 50 objects)
Objects	50
Viewpoints per object	6 (0°, 60°, 120°, 180°, 240°, 300°)
Resolution	960 × 960 pixels
Measurement range	1.5–2.1 m
Ground truth method	18-step phase shifting + Gray-code unwrapping
Train / Val / Test split	240 / 30 / 30 (object-level, 40/5/5 objects)

Repository Layout

The dataset is organized into two top-level directories serving different purposes:

fpp-ml-bench/
├── training_datasets/          # Pre-split, ready-to-train data (plug and play)
└── fpp_synthetic_dataset/      # Full raw dataset per object (complete scans + all metadata)

training_datasets/ is what you need if you want to train models directly. fpp_synthetic_dataset/ is the complete raw dataset with all phase, mesh, and reconstruction data per object.

---

training_datasets/

Pre-split into train/val/test at the object level. Contains six dataset variants covering all combinations of normalization strategy and background handling, plus the normalization parameter files needed for individual normalization.

training_datasets/
├── training_data_depth_raw/
│   ├── train/
│   │   ├── fringe/             # 240 fringe images (full background)
│   │   └── depth/              # 240 raw depth .mat files
│   ├── val/
│   │   ├── fringe/             # 30 fringe images
│   │   └── depth/              # 30 raw depth .mat files
│   └── test/
│       ├── fringe/             # 30 fringe images
│       └── depth/              # 30 raw depth .mat files
├── training_data_depth_global_normalized/      # same structure, global normalized depth
├── training_data_depth_individual_normalized/  # same structure, [0,1] normalized depth
├── training_data_bgremoved_depth_raw/          # background pixels zeroed in fringe input
├── training_data_bgremoved_depth_global_normalized/
├── training_data_bgremoved_depth_individual_normalized/
└── info_depth_params/          # per-sample min/max for individual normalization
    ├── train/depth/
    ├── val/depth/
    └── test/depth/

Loading training data

import scipy.io as sio
from PIL import Image
import numpy as np

# --- Pick a dataset variant ---
# Full background (recommended):
#   training_data_depth_raw
#   training_data_depth_global_normalized
#   training_data_depth_individual_normalized        <-- recommended
# Background removed (for ablation study):
#   training_data_bgremoved_depth_raw
#   training_data_bgremoved_depth_global_normalized
#   training_data_bgremoved_depth_individual_normalized

dataset_dir = "training_datasets/training_data_depth_individual_normalized"

# Load a fringe image
fringe = np.array(
    Image.open(f"{dataset_dir}/train/fringe/banana-a0.png").convert("L"),
    dtype=np.float32
) / 255.0  # normalize to [0, 1]

# Load the corresponding depth map
depth = sio.loadmat(f"{dataset_dir}/train/depth/banana-a0.mat")["depthMap"]

Denormalizing individual normalized depth

When using training_data_depth_individual_normalized, load the stored min/max to recover metric depth from model predictions:

# Load normalization parameters (mirror the split and filename)
params = sio.loadmat(
    "training_datasets/info_depth_params/train/depth/banana-a0.mat"
)
depth_min = float(params["depth_min"])
depth_max = float(params["depth_max"])

# Recover depth in mm from a [0, 1] prediction
depth_mm = prediction * (depth_max - depth_min) + depth_min

Dataset variants

The six training_data_* folders cover the full experimental matrix from the paper:

Folder	Fringe input	Depth target	Object MAE (mm)
training_data_depth_raw	Full	Raw (mm)	148.07
training_data_depth_global_normalized	Full	Meters	82.49
training_data_depth_individual_normalized	Full	[0, 1]	16.20
training_data_bgremoved_depth_raw	BG zeroed	Raw (mm)	437.40
training_data_bgremoved_depth_global_normalized	BG zeroed	Meters	598.40
training_data_bgremoved_depth_individual_normalized	BG zeroed	[0, 1]	45.01

Background removal degrades performance across all normalizations. See the paper for full analysis.

---

fpp_synthetic_dataset/

The complete raw dataset. Each of the 50 objects has its full 6-viewpoint scan with all intermediate and final outputs from VIRTUS-FPP. All depth representations live in a single flat depth_information/ folder.

fpp_synthetic_dataset/
├── depth_information/                              # All depth data, flat (2100 files)
│   ├── banana-a0_raw_depth.mat
│   ├── banana-a0_raw_depth.png
│   ├── banana-a0_global_normalized_depth.mat
│   ├── banana-a0_global_normalized_depth.png
│   ├── banana-a0_individual_normalized_depth.mat
│   ├── banana-a0_individual_normalized_depth.png
│   ├── banana-a0_individual_normalized_depth_params.mat
│   ├── banana-a60_raw_depth.mat                    # ... next viewpoint
│   └── ...                                         # 7 files × 300 samples
│
├── banana/                                         # object folder (50 total)
│   ├── A0/                                         # viewpoint (6 per object)
│   │   ├── A_0.png                                 # fringe images (52 per viewpoint)
│   │   ├── A_1.png
│   │   ├── ...
│   │   ├── A_51.png
│   │   ├── banana-a0.ply                           # ground truth mesh
│   │   ├── wrapped_phase.mat                       # wrapped phase map
│   │   ├── unwrapped_phase.mat                     # unwrapped phase map
│   │   ├── reconstruction.fig                      # MATLAB figure
│   │   ├── reconstruction.png                      # rendered reconstruction
│   │   ├── mask.csv                                # object mask
│   │   ├── x.csv                                   # point cloud X coordinates
│   │   ├── y.csv                                   # point cloud Y coordinates
│   │   └── z.csv                                   # point cloud Z coordinates
│   ├── A60/                                        # next viewpoint, same structure
│   ├── A120/
│   ├── A180/
│   ├── A240/
│   └── A300/
├── battery/                                        # next object, same structure
└── ...                                             # 50 objects total

Files per object-viewpoint

File	Format	Description
A_0.png – A_51.png	PNG (960×960, grayscale)	52-frame fringe pattern sequence. A_0.png is used as model input in the benchmarking study.
<object>-<angle>.ply	PLY	Ground truth 3D mesh
wrapped_phase.mat	MAT	Wrapped phase map from phase-shifting algorithm
unwrapped_phase.mat	MAT	Temporally unwrapped phase (Gray-code)
mask.csv	CSV	Binary object mask
x.csv, y.csv, z.csv	CSV	Point cloud coordinates (mm)
reconstruction.png	PNG	Rendered depth reconstruction
reconstruction.fig	FIG	MATLAB figure of reconstruction

Files in depth_information/

Seven files per object-viewpoint, named <object>-<angle>_<type>:

Suffix	Format	Description
_raw_depth.mat	MAT	Depth in millimeters
_raw_depth.png	PNG	Visualization of raw depth
_global_normalized_depth.mat	MAT	Depth in meters (raw / 1000)
_global_normalized_depth.png	PNG	Visualization of global normalized depth
_individual_normalized_depth.mat	MAT	Depth normalized to [0, 1] per sample
_individual_normalized_depth.png	PNG	Visualization of individual normalized depth
_individual_normalized_depth_params.mat	MAT	depth_min and depth_max for denormalization

Loading from fpp_synthetic_dataset

import scipy.io as sio
from PIL import Image
import numpy as np

object_name = "banana"
viewpoint   = "A0"
angle_tag   = "a0"  # lowercase, used in depth_information filenames

base = "fpp_synthetic_dataset"

# --- Full fringe sequence ---
fringes = [
    np.array(Image.open(f"{base}/{object_name}/{viewpoint}/A_{i}.png").convert("L"))
    for i in range(52)
]

# --- Ground truth mesh ---
# banana-a0.ply  (use open3d or trimesh)
import trimesh
mesh = trimesh.load(f"{base}/{object_name}/{viewpoint}/{object_name}-{angle_tag}.ply")

# --- Phase maps ---
wrapped   = sio.loadmat(f"{base}/{object_name}/{viewpoint}/wrapped_phase.mat")
unwrapped = sio.loadmat(f"{base}/{object_name}/{viewpoint}/unwrapped_phase.mat")

# --- Point cloud ---
import pandas as pd
x = pd.read_csv(f"{base}/{object_name}/{viewpoint}/x.csv").values
y = pd.read_csv(f"{base}/{object_name}/{viewpoint}/y.csv").values
z = pd.read_csv(f"{base}/{object_name}/{viewpoint}/z.csv").values

# --- Depth maps (from depth_information) ---
raw_depth = sio.loadmat(
    f"{base}/depth_information/{object_name}-{angle_tag}_raw_depth.mat"
)["depthMap"]

ind_depth = sio.loadmat(
    f"{base}/depth_information/{object_name}-{angle_tag}_individual_normalized_depth.mat"
)["depthMap"]

params = sio.loadmat(
    f"{base}/depth_information/{object_name}-{angle_tag}_individual_normalized_depth_params.mat"
)
depth_min, depth_max = float(params["depth_min"]), float(params["depth_max"])

---

Data Acquisition

Virtual FPP System

All data were generated using VIRTUS-FPP, a physics-based virtual FPP system in NVIDIA Isaac Sim. The pipeline integrates OptiX ray tracing for photorealistic rendering, PhysX for physics, and USD for 3D scene composition. The projector is modeled via the inverse camera model, enabling accurate fringe projection at arbitrary distances without hardware constraints.

Parameter	Value
Camera focal length	50 cm
Camera resolution	960 × 960 pixels
Projector intensity	40 nits
Projector offset	0.1 m below, 0.125 m left of camera
Stereo reprojection error	0.056 pixels
Projector reprojection error	0.049 pixels

Objects

50 objects sourced from the YCB Object Dataset and NVIDIA Physical AI Warehouse. The collection spans cylindrical containers, rectangular boxes, complex shapes (power drills, sprayguns), and industrial components. All objects use consistent matte material properties: roughness = 0.95, specular = 0.15, AO-to-diffuse = 0.95.

Multi-View Acquisition

Each object was rotated about the vertical axis in 60° increments, yielding 6 viewpoints (A0, A60, A120, A180, A240, A300) with approximately 50% overlap between adjacent views.

Ground Truth Generation

Ground truth depth maps were generated using an 18-step phase-shifting sequence combined with Gray-code temporal unwrapping and triangulation. This provides perfect ground truth geometry free from the measurement errors inherent to physical systems.

Train/Val/Test Split

The split is performed at the object level—no object appears in more than one split. This forces models to generalize to entirely unseen geometries rather than memorizing shapes seen during training.

Split	Objects	Samples (objects × 6 viewpoints)
Train	40	240
Val	5	30
Test	5	30

Intended Uses

• Benchmarking deep learning architectures for single-shot FPP depth estimation
• Evaluating data representation and loss function strategies for fringe-to-depth learning
• Research into phase unwrapping, depth refinement, and multi-view fusion
• Studying fundamental limitations of single-shot depth recovery from structured light

Limitations

• Synthetic only: All data is rendered in simulation. Domain gap to real-world FPP systems has not been characterized. See the paper for discussion on sim-to-real transfer.
• Material properties: All objects use identical matte materials. Specular, translucent, or highly reflective surfaces are not represented.
• Single-shot input: Only A_0.png (first fringe image) is used as model input in the benchmarking study. The remaining 51 patterns are available for alternative formulations (e.g., multi-frame input).
• Fixed measurement range: All objects are scanned at 1.5–2.1 m. Performance at other distances is unknown.

Citation

If you use this dataset, please cite:

@article{lakshman2026comprehensive,
  title={Comprehensive Machine Learning Benchmarking for Fringe Projection Profilometry with Photorealistic Synthetic Data},
  author={Lakshman S, Anush and Haroon, Adam and Li, Beiwen},
  journal={arXiv preprint arXiv:2601.08900},
  year={2026}
}

@article{haroon2025virtus,
  title={VIRTUS-FPP: virtual sensor modeling for fringe projection profilometry in NVIDIA Isaac Sim},
  author={Haroon, Adam and Lakshman, Anush and Balasubramaniam, Badrinath and Li, Beiwen},
  journal={arXiv preprint arXiv:2509.22685},
  year={2025}
}

Contact

Questions or issues: open an issue on GitHub or contact anushlak@iastate.edu or aharoon@iastate.edu.