---
license: cc-by-4.0
language:
- en
size_categories:
- n>1T
---

# 3D Multi-view Rendering Dataset (Objaverse / GObjaverse)

<u>**[3/25/2026] Update: The data is temporarily incomplete and is actively being uploaded...**</u>

This repository hosts parquet-formatted multi-view rendering data for 3D assets.
It contains three uploaded folders:

- `gobjaverse_parquet/` (1.1T): original views from the GObjaverse dataset.
- `complete-objaverse-parquet/` (1.4T): custom "more complete view" renders.
- `complete-objaverse-top/` (852.7G): top-to-down views with azimuth sampling.

## Dataset splits

### 1) `gobjaverse_parquet`

- Source: original GObjaverse view set.
- Per object: one parquet file.
- Main usage: baseline view supervision from original camera settings.

### 2) `complete-objaverse-parquet`

- Source: custom rendering pipeline with denser/more complete coverage.
- Per object: one parquet file.
- Typical view count in generation scripts: 36 canonical views + optional top views merged during parquet building.

### 3) `complete-objaverse-top`

- Source: top-to-down render pass.
- Purpose: improve overhead viewpoint coverage that is usually underrepresented in horizon-only renderings.
- Used together with complete views during parquet construction.

## Rendering view config (from `objaverse-rendering`)

The rendering behavior is defined in `objaverse-rendering/scripts/blender_script.py`:

- Engine: `CYCLES` (used by distributed launcher).
- Resolution: `512 x 512`.
- Output image format: `PNG` with `RGBA`.
- Camera focal setup:
  - `lens = 35`
  - `sensor_width = 32`
  - camera distance derived from FoV:
    - `fov = 2 * atan(sensor_width / (2 * lens))`
    - `camera_dist = 0.5 / sin(fov / 2)`
- Camera orbit sampling:
  - Azimuth: uniform sweep over `[0, 2pi)` with `theta = i / N * 2pi`.
  - Elevation: fixed horizon angle (`phi = 90 deg` in spherical coordinates), i.e. near zero elevation around the object.
- In this repo's launcher (`objaverse-rendering/scripts/distributed_blender.py`), `--num_images 6` is used for that specific run config.

## Azimuth / Elevation by folder

Angles below are in degrees.

### `complete-objaverse-parquet`

This split is a merged parquet of:

1) base complete views (`view_id` 0-35), and  
2) top views (`view_id` 36-47) from `complete-objaverse-top`.

- Base complete views (`view_id` 0-35):
  - Elevation set: `{0, 30, 60}`.
  - For each elevation: azimuth is uniformly sampled over 12 views:
    - `azimuth = {0, 30, 60, ..., 330}`.
- Top merged views (`view_id` 36-47):
  - Elevation: `90` (implemented numerically as `90 - 1e-12` in render code to avoid singularity).
  - Azimuth: `0, 30, 60, ..., 330` (12 views).

### `complete-objaverse-top`

- Number of views per object: `12`.
- Elevation: top-down (`90`, numerically `90 - 1e-12` in code).
- Azimuth: uniform 12-step sweep:
  - `azimuth = {0, 30, 60, ..., 330}`.

### `gobjaverse_parquet`

- This split keeps the **original GObjaverse camera views**.
- Each object parquet stores 40 views (200 key-value rows = 40 views x 5 assets per view).
- Azimuth/elevation are read from per-view camera JSON entries (`00000.json` ... `00039.json`) inside parquet:
  - azimuth/elevation should be treated as metadata from JSON (recommended source of truth),
  - therefore elevation is not a single globally fixed value in this split.

## Example file tree (Hugging Face dataset layout)

```text
<dataset-root>/
├── README.md
├── gobjaverse_parquet/
│   ├── 0/
│   │   ├── 10228.parquet
│   │   └── ...
│   ├── 1/
│   └── ...
├── complete-objaverse-parquet/
│   ├── 0/
│   │   ├── 10228.parquet
│   │   └── ...
│   └── ...
└── complete-objaverse-top/
    ├── 0/
    │   ├── 10228/
    │   │   └── campos_512_v4/
    │   │       ├── 0000/
    │   │       │   ├── rgba_0000.png
    │   │       │   ├── nd_0000.png
    │   │       │   └── nd_0000.exr
    │   │       ├── ...
    │   │       └── 0011/
    │   │   └── ...
    │   └── ...
    └── ...
```

Notes:

- Parquet folders are object-centric (`<group_id>/<object_id>.parquet`).
- Top folder often stores per-view image files before/alongside parquet packaging.

## Parquet file format

There are **two parquet layouts** in this dataset:

### A) `complete-objaverse-parquet` format

- Schema:
  - `view_id` (`int64`)
  - `image_png` (`binary`)
  - `nd_png` (`binary`)
- Typical rows per object parquet: `48` (`view_id` from `0` to `47`).
- Interpretation: each row is one rendered view.

### B) `gobjaverse_parquet` format

- Schema:
  - `keys` (`string`)
  - `values` (`binary`)
- Typical rows per object parquet: `200`.
- Interpretation: each row is one keyed asset blob, e.g.:
  - `00000.png`
  - `00000_albedo.png`
  - `00000_mr.png`
  - `00000_nd.png`
  - `00000.json`
  - ... repeated across views.

### Practical interpretation

- One parquet file = one object.
- In `complete-objaverse-parquet`, rows are view records.
- In `gobjaverse_parquet`, rows are `(key, binary payload)` records.
- Binary payloads can be decoded as PNG bytes (or JSON bytes for `*.json` entries).

## Minimal loading example

```python
import io
import pyarrow.parquet as pq
from PIL import Image

# 1) complete-objaverse-parquet: row-per-view
t1 = pq.read_table("complete-objaverse-parquet/0/10010.parquet")
r1 = t1.to_pylist()[0]
img = Image.open(io.BytesIO(r1["image_png"]))
nd = Image.open(io.BytesIO(r1["nd_png"]))
print("complete view_id:", r1["view_id"], img.size, nd.size)

# 2) gobjaverse_parquet: key-value blobs
t2 = pq.read_table("gobjaverse_parquet/0/10010.parquet")
rows = t2.to_pylist()
blob_map = {x["keys"]: x["values"] for x in rows}
img0 = Image.open(io.BytesIO(blob_map["00000.png"]))
nd0 = Image.open(io.BytesIO(blob_map["00000_nd.png"]))
json0 = blob_map["00000.json"].decode("utf-8")
print("gobj keys:", len(blob_map), "img0:", img0.size, "nd0:", nd0.size)
print("json snippet:", json0[:80])
```


## Citation / usage note

If you use these data splits, please cite the following original sources:

- Objaverse: https://huggingface.co/datasets/allenai/objaverse
- GObjaverse: https://github.com/modelscope/richdreamer/tree/main/dataset/gobjaverse