xxxspatialencoderastra/raw_data_astra_augmentation

Astra augmentation — RGB-D/GT and editable Blender scenes

Read the repaired training data as WebDataset

training_data/ contains 132,617 RGB-D frames in 68,037 layouts, organized into 800 source-scene directories and 803 WDS TARs. Annotation release: v0.3.4_physical_objects_20261031.

• training_data/astra_part1/: 197 original Part1 source scenes.
• training_data/astra_part2/: 593 original Part2 source scenes.
• training_data/reconstruction/: 10 additional reconstructed source scenes.

Each part-000.tar, part-001.tar, etc. contains only its own source scene. One WDS sample is one layout with all its views together. Its key matches the corresponding Blender WDS layout key. RGB, uint16 depth, all instance visibility layers, camera parameters, 2D/3D annotations, multi-view scene metadata and provenance are preserved byte-for-byte from the repaired snapshot.

Download the TARs listed in training_data/source_scenes.jsonl. shard in training_data/layouts.jsonl and training_data/samples.jsonl is relative to training_data/. The categories and their existing IDs are in training_data/categories.json. No train/validation/test split is assigned.

The *_path fields retain the original native-directory paths. For archived frames, use the index's __key__, shard and *_component fields. source_scene retains the annotation source ID; blender_source_scene in the source catalog identifies the corresponding Blender source.

Example (after downloading one source-scene TAR):

import io, json
import numpy as np
from PIL import Image
import webdataset as wds

sample = next(iter(wds.WebDataset("part-000.tar", shardshuffle=False)))
layout = json.loads(sample["json"])
view = layout["frames"][0]
fields = view["components"]
annotation = json.loads(sample[fields["annotation.json"]])
rgb = Image.open(io.BytesIO(sample[fields["rgb.png"]])).convert("RGB")
depth_m = np.asarray(Image.open(io.BytesIO(sample[fields["depth.png"]])), dtype=np.float32) / 1000.0
boxes_3d = [obj["camera_box_3d"] for obj in annotation["objects"]]

Restore the original directory format when needed

training_data/native_metadata.tar.gz contains the original global indices, dataset manifest, category table, native ownership lineage and validation summaries. Extract it into astra_augment/. Then iterate the selected training TARs and write each component to the path in json.original_files:

from pathlib import Path
root = Path("astra_augment")
for sample in wds.WebDataset(downloaded_training_tar_paths, shardshuffle=False):
    layout = json.loads(sample["json"])
    for component, original_path in layout["original_files"].items():
        destination = root / original_path
        destination.parent.mkdir(parents=True, exist_ok=True)
        destination.write_bytes(sample[component])

downloaded_training_tar_paths contains only source-scene part-*.tar files. Restoring all source TARs plus the native metadata preserves the existing obb_training_v3 directory-reader entry point. The following path-based examples apply to that restored directory.

Locate frames and annotations

• samples.jsonl: one record per RGB-D frame; use annotation_path to open its annotations.
• layouts.jsonl: multi-view groups and their scene_metadata_path.
• categories.json: category names, category_id and zero-based class_index.
• scenes/.../frames/<frame_id>/: RGB, depth.png, instance masks and annotation.json.

All paths in these files are relative to astra_augment/.

Per-object 2D and 3D fields

Each entry in annotation.json["objects"] contains:

Field	Meaning
category_name, category_id, class_index	Object category and its catalog IDs.
object_id	Object identity within the layout, shared across its views.
instance_id	Object label value in this frame's instance masks.
camera_box_2d_rend	Tight visible 2D box [xmin, ymin, xmax, ymax] in pixels; maximum coordinates are exclusive.
camera_box_2d_proj	2D extent of the projected full 3D box; it can extend outside the image.
camera_box_3d	Eight 3D corner points, shape (8, 3), in camera coordinates, in metres. Use these directly to read or project the 3D box.
camera_center	3D box centre [x, y, z] in camera coordinates, in metres.
camera_scale	Three full box side lengths along OBB-local X/Y/Z axes, in metres. These are not half-extents.
camera_yaw_pitch_roll	Orientation [yaw, pitch, roll], in radians, intrinsic ZYX: Rz(yaw) @ Ry(pitch) @ Rx(roll).
visible_pixels	Number of visible supporting pixels across instance layers, counting each pixel once.

Camera axes are +X right, +Y down, +Z forward. camera_scale describes the OBB-local axes, not the fixed camera axes. With R = Rz(yaw) @ Ry(pitch) @ Rx(roll), corners can be reconstructed as (signs * camera_scale / 2) @ R.T + camera_center, where signs enumerates the eight combinations of ±1. Corner ordering may differ from the stored array; the 3D point set is equivalent. Reading the supplied camera_box_3d needs no reconstruction.

Per-frame depth and camera fields

Field	Meaning
rgb_path, depth_path	Paths to the RGB image and depth map.
depth_units	millimeters: unsigned 16-bit Z-depth, with 0 indicating invalid depth. Divide by 1,000 for metres.
rgb_intrinsic	Camera intrinsic matrix K, shape (3, 3), in pixels.
camera_pose	Camera-to-world transform, shape (4, 4). For column vectors, p_world = camera_pose @ [x_cam, y_cam, z_cam, 1].
instance_path, instance_layers	Composed frontmost instance mask and native visibility layers. Their label values match object instance_id values.

Example: read both 2D and 3D annotations

This example reads an actual frame via the sample index; it uses only Python's standard library.

import json
from pathlib import Path

root = Path("astra_augment")
with (root / "samples.jsonl").open() as f:
    sample = json.loads(next(f))
ann = json.loads((root / sample["annotation_path"]).read_text())
obj = ann["objects"][0]

print("Category:", obj["category_name"])
print("2D box [pixels]:", obj["camera_box_2d_rend"])
print("3D centre [m]:", obj["camera_center"])
print("3D side lengths [m, stored order]:", obj["camera_scale"])
print("Yaw/pitch/roll [rad]:", obj["camera_yaw_pitch_roll"])
print("3D box: 8 camera-space corners [m]:", obj["camera_box_3d"])

K = ann["rgb_intrinsic"]
camera_to_world = ann["camera_pose"]
print("RGB:", root / ann["rgb_path"])
print("Depth:", root / ann["depth_path"])

For the first indexed frame, the first object's category is booth_bench, its 2D box is [147, 229, 517, 446], and its 3D centre is approximately [-0.2494, 0.2284, 3.1568] metres. The same object record contains all eight 3D corners.

To load its depth map, install Pillow and NumPy, then use:

import numpy as np
from PIL import Image

depth_m = np.asarray(Image.open(root / ann["depth_path"]), dtype=np.float32) / 1000.0
valid_depth = depth_m > 0

Annotation scope

800 layouts (1,580 frames) with confirmed quality problems are excluded as whole multi-view groups. Original files are preserved separately.

Annotation release: v0.3.4_physical_objects_20261031 — 132,617 frames, 68,037 layouts, 2,493,627 per-frame object annotations.

Instances represent physical objects and functional fixtures. Dependent mesh parts belong to their physical owner. Walls, floors, ceilings, architectural glazing, continuous terrain, finishes and non-object appearance details are excluded. Door/window frames and functional fixtures remain; visible independent small objects are retained, including one-pixel instances. The 2D boxes describe visible support; 3D boxes describe full object geometry.

Canonical source outdoor/environment background exclusions are applied before native object completion. Indoor views do not annotate the excluded exterior scenery through their windows. RGB, depth and camera parameters are preserved. Instance layers retain visibility support for objects within the target region, including objects behind interior glass. Augmentation remains stopped.

Editable Blender scenes

Status: complete. 68,037 layouts in 800 source-scene directories and 1127 TAR shards; matching 132,617 RGB-D frames.

• blender_files/astra_part1/: 197 original Part1 source scenes.
• blender_files/astra_part2/: 593 original Part2 source scenes.
• blender_files/reconstruction/: 10 additional reconstructed source scenes, including living room, bedroom, showers, bathroom, mechanical room, colonnade, road junctions and railway platform.

Each source-scene directory uses its original source name and contains only that source's augmented layouts, stored in part-000.tar, part-001.tar, etc. One layout and all five components stay together in one TAR. Existing single-source TAR payloads are reused unchanged; mixed-source TARs are regrouped with an approximately 4 GiB target, keeping oversized individual layouts whole.

Read blender_files/source_scenes.jsonl for the 800 source scenes and their TAR lists. In blender_files/layout_index.jsonl, shard is a path relative to blender_files/; for example astra_part1/airplane_22/part-000.tar. source_scene preserves the full original source identity. original_directory is historical lineage, not a current download path.

One WDS sample is one augmented Blender layout. Its key is the unchanged layout ID. Components are scene.blend, cameras.json, object_bindings.json, native_name_map.json, and json (layout/source/view linkage). External media are embedded in the Blender file. No train/validation split is assigned.

The Blender and repaired training-data WDS TARs contain the same retained layout IDs. Excluded samples remain excluded. These Blender assets retain their v0.3.3 binding snapshot; use the training_data/ WDS release v0.3.4_physical_objects_20261031 for current 2D/3D annotations. This reorganization preserves all five component payloads without re-exporting or rendering scenes.

Example (after downloading a source-scene TAR):

import webdataset as wds
from pathlib import Path
sample = next(iter(wds.WebDataset("part-000.tar").decode()))
Path("scene.blend").write_bytes(sample["scene.blend"])
cameras = sample["cameras.json"]
layout = sample["json"]