Hugging Face's logo

Datasets:
Lorenzo000
/
office_synthetic

Tags:
robotics
computer-vision
synthetic-data
indoor
office
rgb-d
Dataset card Files
xet
 Community

The dataset is currently empty. Upload or create new data files. Then, you will be able to explore them in the Dataset Viewer.

Office Synthetic Dataset

Overview

office_syntetic is a synthetic RGB-D robotics dataset designed for research on long-term perception in changing indoor environments.

The dataset represents an office environment observed at multiple temporal states. Between temporal configurations, objects may remain unchanged, move to different locations, disappear, or appear.

The main research objectives are:

  • object re-identification across temporal changes;
  • dynamic semantic mapping;
  • temporal object association;
  • change detection;
  • RGB-D perception;
  • object detection;
  • instance segmentation;
  • evaluation of robotic perception systems in dynamic indoor environments.

The dataset was generated in Blender and provides synchronized:

  • RGB images;
  • depth maps;
  • camera poses;
  • object-detection annotations;
  • instance-ID segmentation maps;
  • per-frame visibility information;
  • scene-level object metadata.

The original Blender scenes and the scripts used for dataset generation are also provided to support reproducibility and further extensions.

Dataset at a Glance

Property Value
Environment type Synthetic indoor office
Temporal configurations 10
Temporal states t_0 – t_9
Camera heights 3
Heights 0.5 m, 1.0 m, 1.5 m
Frames per acquisition 100
Acquisitions 30
Total synchronized frame sets 3,000
RGB resolution 1920 × 1080
Semantic classes 17
Rendering engine Blender Cycles
Blender version 5.0.1
RGB format PNG
Depth format OpenEXR
Segmentation format OpenEXR
Pose format NumPy .npy
Detection format YOLO
Scene units meters

An acquisition is defined as one temporal environment configuration observed from one camera height.

Therefore:

10 temporal configurations
× 3 camera heights
× 100 frames
= 30 acquisitions
= 3,000 synchronized observations

Each synchronized observation contains the modalities associated with the same camera frame.

Dataset Design

Temporal Environment Configurations

The office environment is represented by ten temporal configurations:

t_0
t_1
t_2
...
t_9

t_0 represents the initial configuration of the office.

Later configurations represent modified states of the same environment.

Possible temporal changes include:

  • an object remaining unchanged;
  • an object being moved to another position;
  • an object disappearing from the environment;
  • a new object appearing in the environment.

The repository contains the corresponding Blender scene files:

0.blend
1.blend
2.blend
...
9.blend

The temporal structure makes it possible to evaluate perception algorithms not only across different viewpoints, but also across modifications of the environment itself.

Camera Heights

Each temporal configuration is observed from three different camera heights:

Acquisition Camera height
height500 0.5 m
height1000 1.0 m
height1500 1.5 m

The initial horizontal camera position is:

x = 2.5 m
y = 2.5 m

while the vertical coordinate depends on the acquisition:

z ∈ {0.5, 1.0, 1.5} m

This provides observations of the same environment from different vertical viewpoints.

Camera and Rendering Configuration

The synthetic camera uses the following configuration:

Parameter Value
Camera model Perspective
Resolution 1920 × 1080
Focal length 22 mm
Sensor width 18 mm
Sensor height 24 mm
Sensor fit Horizontal
Near clipping plane 0.1 m
Far clipping plane 1000 m
Rendering engine Blender Cycles
Blender version 5.0.1

The Blender scene uses metric units with:

unit_scale = 1.0

World-space geometry and depth measurements are therefore represented using metric scene units.

RGB rendering uses:

Cycles samples = 32
Denoising = enabled

Robot / Camera Trajectory

Camera motion is generated using a constrained pseudo-random walk.

The trajectory-generation parameters are:

Parameter Value
Frames 100
Starting frame 1
Initial XY position (2.5 m, 2.5 m)
Forward step 0.50 m
Rotation interval every 5 frames
Random yaw variation [-35°, +35°]
Initial yaw 90°
Fixed X rotation 90°
Fixed Y rotation 0°
Allowed X interval [-3.5 m, +3.5 m]
Allowed Y interval [-3.5 m, +3.5 m]
Collision radius 0.10 m
Random seed 1234
Maximum attempts per frame 100

The camera moves forward by a fixed step while its yaw is periodically perturbed.

Candidate positions are checked against the spatial bounds and scene collision geometry before being accepted.

If a proposed movement is invalid, alternative orientations are sampled until a valid configuration is found or the maximum number of attempts is reached.

A fixed pseudo-random seed is used, making trajectory generation deterministic for a fixed scene geometry and configuration.

Dataset Organization

A typical temporal configuration is organized as:

0/
├── height500/
│   ├── rgb/
│   ├── depth_exr/
│   ├── pose/
│   ├── labels/
│   ├── masks/
│   └── metadata/
│
├── height1000/
│   ├── rgb/
│   ├── depth_exr/
│   ├── pose/
│   ├── labels/
│   ├── masks/
│   └── metadata/
│
└── height1500/
    ├── rgb/
    ├── depth_exr/
    ├── pose/
    ├── labels/
    ├── masks/
    └── metadata/

The same structure is repeated for all temporal configurations.

Each acquisition contains 100 synchronized frames.

Data Modalities

RGB Images

RGB observations are stored as PNG files:

rgb/
├── rgb_000001.png
├── rgb_000002.png
├── ...
└── rgb_000100.png

Properties:

  • resolution: 1920 × 1080;
  • color mode: RGB;
  • bit depth: 8 bit;
  • rendering engine: Blender Cycles;
  • Cycles samples: 32;
  • denoising enabled.

Depth Maps

Depth maps are stored in OpenEXR format:

depth_exr/
├── depth_000001.exr
├── depth_000002.exr
├── ...
└── depth_000100.exr

Depth information originates from Blender's Z/Depth render pass.

Depth values are stored as floating-point values without normalization.

Since the Blender scene uses metric units, depth information can be interpreted in metric scene units.

Camera Poses

Camera poses are stored as:

pose/
├── T_wc_000001.npy
├── T_wc_000002.npy
├── ...
└── T_wc_000100.npy

Each file contains a 4 × 4 homogeneous transformation matrix:

T_wc

obtained directly from Blender's camera matrix_world.

Therefore, T_wc represents the transformation from the local Blender camera coordinate frame to the Blender world coordinate frame.

Matrices are stored using NumPy with float64 precision.

Conceptually:

p_world = T_wc · p_camera

when homogeneous coordinates are used according to Blender's camera-local coordinate convention.

Instance Segmentation

Instance segmentation maps are stored as:

masks/
├── seg_000001.exr
├── seg_000002.exr
├── ...
└── seg_000100.exr

Each annotated object target receives a scene-local numerical identifier.

The segmentation identifier is defined as:

segmentation_id = target_index + 1

while:

0 = background

Instance identifiers are encoded using a 24-bit RGB representation and stored in floating-point OpenEXR images.

The segmentation maps therefore represent individual object instances rather than only semantic classes.

Scope of Instance IDs

target_index and segmentation_id are local identifiers associated with the target enumeration of a particular scene/acquisition.

They must not automatically be interpreted as persistent identities across different temporal configurations.

In particular:

segmentation_id != persistent cross-temporal object identity

unless a persistent correspondence between objects has been established separately.

Object Detection Annotations

Object detection annotations are stored in YOLO format:

labels/
├── rgb_000001.txt
├── rgb_000002.txt
├── ...
└── rgb_000100.txt

Each line follows the standard representation:

<class_id> <x_center> <y_center> <width> <height>

Bounding-box coordinates are normalized with respect to the image dimensions.

A relevant property of the annotation pipeline is that bounding boxes are derived directly from the rendered instance segmentation.

They are therefore not obtained simply by projecting a full 3D object bounding box into the image.

Instead, the pipeline identifies the pixels associated with an instance and computes the corresponding image-space bounding rectangle.

This makes the generated annotations dependent on the visible portion of the object and naturally accounts for occlusion.

An object is included in the annotations only when at least:

20 visible pixels

belong to its instance segmentation.

Semantic Classes

The dataset defines 17 semantic object classes:

ID Class
0 desk
1 chair
2 trash_can
3 plant
4 fan
5 monitor
6 extinguisher
7 bookshelf
8 cabinet
9 bottle
10 book
11 coffee_machine
12 cup
13 print
14 keyboard
15 mouse
16 backpack

The same semantic class_id convention is used by the generated detection annotations and object metadata.

Object Representation

Complex Blender assets may consist of several meshes and hierarchical components.

The annotation pipeline does not necessarily treat every mesh as an independent semantic instance.

Instead, annotated objects are defined using top-level semantic targets.

For example, an asset represented by:

Top-level object
├── mesh component 1
├── mesh component 2
├── mesh component 3
└── ...

can be represented as a single annotated object instance.

This avoids producing multiple unrelated annotations for the internal mesh components of the same logical object.

Scene-Level Object Metadata

Each acquisition contains:

metadata/objects_world_metadata.json

This file describes the annotated objects present in the corresponding scene.

For each target, information includes:

target_index
name
kind
class_id
mesh_count
instance_parent
origin_world_m
bbox_center_world_m
bbox_min_world_m
bbox_max_world_m

The metadata file also specifies that coordinates are expressed using Blender world coordinates in meters.

target_index

target_index identifies an annotated target inside the scene.

It is used internally by the segmentation pipeline and is related to the segmentation identifier through:

segmentation_id = target_index + 1

It should not be assumed to be a persistent identifier across temporal configurations.

World-space geometry

For each target, the metadata provides:

origin_world_m
bbox_center_world_m
bbox_min_world_m
bbox_max_world_m

These values make it possible to compare rendered observations with object geometry in the global environment reference frame.

Per-Frame Visibility Metadata

Per-frame visibility information is stored in:

metadata/visible_objects_by_frame.jsonl

Each line corresponds to one frame.

A record contains information such as:

frame
visible_count
visible_targets

Each visible target includes information such as:

target_index
name
class_id
segmentation_id
yolo_bbox
origin_world_m
bbox_center_world_m
bbox_min_world_m
bbox_max_world_m

Visibility is determined directly from the rendered instance-ID segmentation.

An object must contain at least:

20 visible pixels

to be considered visible by the annotation pipeline.

The visibility definition therefore accounts naturally for:

  • camera viewpoint;
  • field of view;
  • object occlusion;
  • partial visibility;
  • object position.

Visibility Reports

The repository includes utilities for computing object visibility statistics:

visibility_report.py
run_report.sh

The reports are generated using:

objects_world_metadata.json
visible_objects_by_frame.jsonl

and can provide information such as:

  • number of objects present in the scene;
  • number of objects observed by the camera;
  • objects never observed;
  • number of visible frames for each object;
  • percentage of visible frames;
  • first visible frame;
  • last visible frame;
  • per-class visibility statistics.

Visibility reports should be interpreted independently for each temporal configuration and camera height.

Frame Synchronization

All modalities use the same six-digit frame identifier.

For example:

rgb/rgb_000042.png
depth_exr/depth_000042.exr
pose/T_wc_000042.npy
labels/rgb_000042.txt
masks/seg_000042.exr

refer to the same camera observation.

This provides direct synchronization between:

RGB
depth
pose
detection
segmentation
visibility metadata

Object Re-identification

Object re-identification across temporal scene changes is one of the principal intended uses of the dataset.

A typical problem consists of determining whether two observations acquired at different temporal states correspond to the same physical or logical object despite changes in:

  • viewpoint;
  • camera height;
  • partial occlusion;
  • object location;
  • surrounding objects;
  • scene appearance;
  • environmental configuration.

For example, an object visible in t_0 may be moved before being observed again in a later temporal state.

A re-identification system may therefore need to distinguish between:

same object, different position

and:

different object, same semantic class

Semantic Class vs Instance Identity

Semantic identity and instance identity are separate concepts.

For example, two objects may both have:

class_id = 1

and therefore both represent chairs, while still being two distinct physical object instances.

Similarly, an individual object may preserve its physical identity even after its position changes.

Cross-temporal Identity

The instance segmentation identifiers are not designed to act as persistent cross-temporal object IDs.

target_index is assigned according to the target enumeration within a scene and:

segmentation_id = target_index + 1

Therefore, equality of target_index or segmentation_id between two different temporal configurations must not by itself be interpreted as proof that they represent the same physical object.

Experiments requiring explicit ground-truth object correspondences across temporal states should use a separately validated persistent correspondence between object instances.

This distinction is especially important when the dataset is used as an object re-identification benchmark.

Dynamic Semantic Mapping

The dataset is also designed for research on dynamic semantic mapping.

Each observation combines:

  • RGB appearance;
  • metric depth;
  • camera pose;
  • semantic class information;
  • object-instance segmentation;
  • object visibility;
  • world-space object metadata.

Across temporal states, objects may:

remain
move
appear
disappear

A semantic mapping algorithm can therefore be evaluated not only on its ability to represent an environment, but also on its ability to update that representation as the environment changes.

Potential research questions include:

  • detecting that a previously mapped object has moved;
  • determining whether an observation corresponds to an already mapped object;
  • detecting objects that have disappeared;
  • adding newly appearing objects;
  • updating object positions;
  • maintaining semantic information over time;
  • maintaining object identity across long-term observations.

Suggested Research Tasks

The dataset can support experiments on:

  • object re-identification;
  • temporal object association;
  • dynamic semantic mapping;
  • long-term robotic perception;
  • semantic SLAM;
  • object detection;
  • instance segmentation;
  • RGB-D perception;
  • change detection;
  • semantic map maintenance;
  • visibility-aware perception;
  • viewpoint robustness;
  • temporal scene understanding;
  • synthetic-to-real transfer.

Reproducibility

The repository includes the Blender source scenes and the scripts used to generate the dataset.

The generation pipeline can be summarized as:

Blender temporal scene
        │
        ├── constrained camera trajectory
        │
        ├── RGB rendering
        │
        ├── depth rendering
        │
        ├── camera pose ground truth
        │
        ├── instance-ID rendering
        │
        ├── YOLO bounding boxes
        │
        ├── per-frame visibility metadata
        │
        └── scene-level object metadata

Trajectory generation uses a fixed pseudo-random seed.

For a fixed:

  • Blender scene;
  • camera-height configuration;
  • trajectory configuration;
  • collision geometry;
  • random seed;

the trajectory-generation procedure is deterministic.

The source .blend files make it possible to regenerate observations, modify the environment, introduce additional temporal configurations, or change the sensing pipeline.

Experimental Protocols

No official training, validation, or test split is imposed by the dataset.

Researchers may define splits according to the target task.

Temporal Evaluation

One possible temporal protocol is:

earlier temporal states
        │
        ▼
initialization / training
        │
        ▼
later temporal states
        │
        ▼
evaluation

For example, a semantic representation may be initialized using t_0 and then evaluated on later temporal configurations.

This protocol can be used to study:

  • object re-identification;
  • map updating;
  • object movement;
  • appearance/disappearance detection;
  • long-term semantic consistency.

Viewpoint Evaluation

The three camera heights can also be treated as different observation domains:

height500
height1000
height1500

This makes it possible to evaluate robustness to significant changes in viewpoint.

Dataset Statistics

The dataset generation design results in:

Statistic Value
Temporal configurations 10
Heights per configuration 3
Frames per height 100
Acquisitions 30
Total frame sets 3,000
Semantic classes 17

Therefore:

10 × 3 × 100 = 3,000

synchronized observation sets are produced when all temporal configurations and acquisition heights are included.

Object-level statistics such as:

  • total number of instances;
  • number of instances per semantic class;
  • average visible instances per frame;
  • visibility percentages;
  • number of never-observed objects;

can be derived from the metadata and visibility-report files.

Because scene contents change across temporal configurations, these statistics should be computed from the released dataset rather than inferred only from the initial scene.

Limitations

The dataset is entirely synthetic and therefore does not reproduce every characteristic of real robotic sensing.

Relevant limitations include:

  • synthetic RGB appearance;
  • absence of real camera noise;
  • absence of real depth-sensor noise and artifacts;
  • limited environment diversity;
  • a single office environment;
  • a fixed semantic-class vocabulary;
  • a finite set of temporal changes;
  • procedurally generated camera trajectories;
  • synthetic lighting and materials;
  • segmentation IDs are scene-local rather than persistent cross-temporal identities.

Results obtained exclusively on this dataset should therefore not automatically be interpreted as representative of performance in real-world environments.

However, the controlled synthetic setting provides exact geometric and semantic ground truth and makes it possible to evaluate specific aspects of long-term perception under repeatable conditions.

The availability of the source Blender scenes also enables extensions such as:

  • additional temporal configurations;
  • different object arrangements;
  • new camera trajectories;
  • alternative camera heights;
  • additional sensor models;
  • controlled appearance variations.

Repository Contents

The repository contains the original Blender scenes:

0.blend
1.blend
2.blend
...
9.blend

and dataset-generation utilities including:

sample_with_gt.py
visibility_report.py
run_report.sh

Additional assets required by the scenes may also be included in:

assets/

The generated observations are organized according to temporal configuration and camera height.

Ground Truth Summary

The dataset provides several complementary levels of ground truth.

Ground Truth Representation
Camera appearance RGB PNG
Scene depth OpenEXR depth map
Camera pose 4×4 T_wc NumPy matrix
Object semantic class class_id
Object detection YOLO bounding box
Object instance segmentation RGB24 instance ID
Object visibility Per-frame JSONL
Object world position World-space metadata
Object world bounding box World-space metadata

This combination supports experiments that require both image-space and world-space information.

Repository

Hugging Face dataset repository:

Lorenzo000/office_syntetic
Downloads last month
23
Total file size:
24.5 kB