Datasets:

GDAOSU
/

Olbedo

license: cc-by-4.0
dataset_info:
  - config_name: default
    features:
      - name: frame_id
        dtype: int32
      - name: orig_frame
        dtype: string
      - name: image
        dtype: image
      - name: image_raw
        dtype: binary
      - name: albedo
        dtype: image
      - name: albedo_raw
        dtype: binary
      - name: depth
        dtype: image
      - name: depth_raw
        dtype: binary
      - name: normal
        dtype: image
      - name: normal_raw
        dtype: binary
      - name: mask
        dtype: image
      - name: camera
        dtype: string
      - name: sky_raw
        dtype: binary
      - name: model
        dtype: string
      - name: scene
        dtype: string
      - name: date
        dtype: string
      - name: lighting
        dtype: string
    splits:
      - name: train
        num_bytes: 48468861351
        num_examples: 5664
      - name: test
        num_bytes: 9440057784
        num_examples: 520
      - name: train_selected
        num_bytes: 21972048865
        num_examples: 2487
    download_size: 79310118605
    dataset_size: 79880968000
  - config_name: models
    features:
      - name: model_name
        dtype: string
      - name: scene
        dtype: string
      - name: date
        dtype: string
      - name: lighting
        dtype: string
      - name: model_raw
        dtype: binary
    splits:
      - name: train
        num_bytes: 7294616740
        num_examples: 27
    download_size: 3751431547
    dataset_size: 7294616740
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train-*
      - split: test
        path: data/test-*
      - split: train_selected
        path: data/train_selected-*
  - config_name: models
    data_files:
      - split: train
        path: models/train-*

Olbedo: An Albedo and Shading Aerial Dataset for Large-Scale Outdoor Environments

Shuang Song¹‡, Debao Huang¹‡, Deyan Deng¹, Haolin Xiong², Yang Tang¹, Yajie Zhao², Rongjun Qin¹*

¹ The Ohio State University · ² University of Southern California
‡ Equal contribution · * Corresponding author

This repository contains the Olbedo dataset, containing RGB images, albedo, depth, surface normals, camera parameters, sky HDR maps, and 3D scene models.

HuggingFace: GDAOSU/Olbedo

Dataset Structure

Main config (default)

Three splits: train (5,664 samples), train_selected (2,487 samples), test (520 samples).

Column	Type	Description
`frame_id`	int	Unique frame identifier
`orig_frame`	string	Original frame number
`image`	Image	sRGB preview (PNG, for visualization)
`image_raw`	binary	Original EXR file (Linear RGB, for training)
`albedo`	Image	sRGB preview (PNG, for visualization)
`albedo_raw`	binary	Original EXR file (Linear RGB, for training)
`depth`	Image	Colormap preview (PNG, INFERNO colormap)
`depth_raw`	binary	Original EXR file (float, for training)
`normal`	Image	RGB preview (PNG, remapped from [-1,1] to [0,1])
`normal_raw`	binary	Original EXR file (float RGB, for training)
`mask`	Image	Segmentation mask (PNG)
`camera`	string	Camera parameters (JSON string)
`sky_raw`	binary	Sky HDR map (.hdr), `None` if not available
`model`	string	GLB model filename (e.g. `scene_date_lighting.glb`)
`scene`	string	Scene name
`date`	string	Capture date (YYYYMMDD)
`lighting`	string	Lighting condition (sunrise/sunset/overcast)

The test split has None for depth, normal, camera, sky, and model columns.

Models config

A separate config containing 27 3D scene models in GLB format.

Column	Type	Description
`model_name`	string	Model identifier (e.g. `osu_coe_corridors_20220720_sunrise`)
`scene`	string	Scene name
`date`	string	Capture date
`lighting`	string	Lighting condition
`model_raw`	binary	GLB file (binary)

Usage

Load the dataset

from datasets import load_dataset

# Load a split (downloads data)
ds = load_dataset("GDAOSU/Olbedo", split="train")

# Or use streaming to avoid downloading everything
ds = load_dataset("GDAOSU/Olbedo", split="train", streaming=True)
row = next(iter(ds))

Recover raw EXR files (image, albedo, depth, normal)

ds = load_dataset("GDAOSU/Olbedo", split="train", streaming=True)

for row in ds:
    fid = row['frame_id']

    # Save image EXR
    with open(f"{fid:04d}_im.exr", "wb") as f:
        f.write(row['image_raw'])

    # Save albedo EXR
    with open(f"{fid:04d}_albedo.exr", "wb") as f:
        f.write(row['albedo_raw'])

    # Save depth EXR
    if row['depth_raw'] is not None:
        with open(f"{fid:04d}_depth.exr", "wb") as f:
            f.write(row['depth_raw'])

    # Save normal EXR
    if row['normal_raw'] is not None:
        with open(f"{fid:04d}_normal.exr", "wb") as f:
            f.write(row['normal_raw'])

Recover camera JSON

import json

row = next(iter(ds))
if row['camera'] is not None:
    camera = json.loads(row['camera'])
    print(camera['focal'], camera['cx'], camera['cy'])  # intrinsics
    print(camera['X'], camera['Y'], camera['Z'])        # translation

    # Save to file
    fid = row['frame_id']
    with open(f"{fid:04d}_camera.json", "w") as f:
        f.write(row['camera'])

Recover sky HDR maps

Only some frames have sky HDR maps (frames 3801+).

for row in ds:
    if row['sky_raw'] is not None:
        fid = row['frame_id']
        with open(f"{fid:04d}_sky.hdr", "wb") as f:
            f.write(row['sky_raw'])

Recover 3D models (GLB)

Models are stored in a separate config. Each model corresponds to a unique scene/date/lighting combination.

models = load_dataset("GDAOSU/Olbedo", "models", split="train", streaming=True)

for row in models:
    name = row['model_name']
    with open(f"{name}.glb", "wb") as f:
        f.write(row['model_raw'])
    print(f"Saved {name}.glb ({len(row['model_raw']) / 1e6:.0f} MB)")

Link frames to their 3D model

Each frame's model field contains the GLB filename. To find which model a frame belongs to:

row = next(iter(ds))
print(row['model'])  # e.g. "osu_coe_corridors_20220720_sunrise.glb"

Recover all data for a single frame

import json

ds = load_dataset("GDAOSU/Olbedo", split="train", streaming=True)
row = next(iter(ds))
fid = row['frame_id']
prefix = f"{fid:04d}"

# Save all files
with open(f"{prefix}_im.exr", "wb") as f:
    f.write(row['image_raw'])
with open(f"{prefix}_albedo.exr", "wb") as f:
    f.write(row['albedo_raw'])
if row['depth_raw']:
    with open(f"{prefix}_depth.exr", "wb") as f:
        f.write(row['depth_raw'])
if row['normal_raw']:
    with open(f"{prefix}_normal.exr", "wb") as f:
        f.write(row['normal_raw'])
if row['camera']:
    with open(f"{prefix}_camera.json", "w") as f:
        f.write(row['camera'])
if row['sky_raw']:
    with open(f"{prefix}_sky.hdr", "wb") as f:
        f.write(row['sky_raw'])

# Save mask from preview Image
if row['mask'] is not None:
    row['mask'].save(f"{prefix}_mask.png")

print(f"Frame {fid}: scene={row['scene']}, date={row['date']}, lighting={row['lighting']}, model={row['model']}")

Scenes

The dataset covers 4 locations with multiple captures under different dates and lighting conditions:

goodale_park
osu_coe_corridors
osu_residential_area
schottenstein_center

File Formats

Image/Albedo EXR: Linear RGB, float16/float32. Apply sRGB transfer function for display.
Depth EXR: Single-channel float (channel name I). Use OpenEXR library to read.
Normal EXR: RGB float in [-1, 1] range. Remap to [0, 1] for visualization.
Sky HDR: Radiance HDR format (.hdr).
3D Models: glTF Binary (.glb).
Camera JSON: Contains intrinsics (focal, cx, cy, distortion), extrinsics (rotation matrix, translation), and metadata (GPS, sun position).