Guidance on accessing RTX LiDAR reflectance data after enabling reflectance flags

[pabguzman]

Hi NVIDIA Support Team and Community,

I’m working on an Isaac Sim 5.1 project where I need to inspect the reflectance produced by the RTX LiDAR pipeline. Following the public documentation for omni.sensors.nv.materials, I enable both recommended settings before instantiating the sensor:

--/app/sensors/nv/lidar/enableRtxReflectanceInformation=true
--/app/sensors/nv/lidar/enableAdditionalRtxReturnInformation=true

The LiDAR is configured with auxOutputType="EXTRA", and I capture the output via GenericModelOutput (or alternatively through IsaacCreateRTXLidarScanBuffer). I can see auxType reporting EXTRA, but neither the GMO Python bindings nor the scan-buffer annotator expose a reflectivity array or any additional fields populated by these flags. All I receive are the usual fields (positions, intensity, materialId, etc.).

To help reproduce the issue, I’m preparing a minimal standalone script that isolates the functionality I’m using and shows the current output. I’ll happily attach it to the ticket.

The next steps for retrieving the reflectance data are not clear to me, and I have some questions about this process. For example:

• Is there an extra setting or API needed to materialise reflectance values once those flags are enabled?
• Should reflectivity appear in an existing annotator payload (e.g., IsaacCreateRTXLidarScanBuffer) or via a different data structure?
• If the information remains in the auxiliary buffer, what is the supported way to decode it from Python?

Any guidance or sample code would be greatly appreciated. I’d like to confirm whether reflectance can be accessed at runtime in Isaac Sim 5.1 once the two flags above are enabled.

Thanks in advance for your help!

Best regards,
Pablo Guzmán

The citted code:

#!/usr/bin/env python3

import sys
import time
from pathlib import Path

import numpy as np

try:
    from plyfile import PlyData, PlyElement
except ModuleNotFoundError as exc:
    print("Install plyfile before running this script: pip install plyfile")
    raise SystemExit(1) from exc

PROJECT_ROOT = Path(__file__).resolve().parent.parent
if str(PROJECT_ROOT) not in sys.path:
    sys.path.append(str(PROJECT_ROOT))

from isaacsim import SimulationApp

simulation_app = SimulationApp(
    {
        "headless": False,
        "extra_args": [
            "--/rtx-transient/stableIds/enabled=true",
            "--/app/sensors/nv/lidar/outputBufferOnGPU=true",
            "--/app/sensors/nv/lidar/enableRtxReflectanceInformation=true",
            "--/app/sensors/nv/lidar/enableAdditionalRtxReturnInformation=true",
        ],
    }
)

import omni
import omni.physx
import omni.replicator.core as rep
import omni.usd
from isaacsim.core.api.materials import OmniPBR
from isaacsim.core.api.objects import VisualCuboid
from isaacsim.sensors.rtx import LidarRtx, apply_nonvisual_material, get_gmo_data
from pxr import Sdf, UsdGeom

NV_MATERIALS = [
    ("asphalt", "none", "emissive"),
    ("bark", "none", "emissive"),
    ("steel", "none", "emissive"),
]


def _create_scene() -> None:
    stage = omni.usd.get_context().get_stage()
    UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)

    stage.DefinePrim("/World", "Xform")
    stage.DefinePrim("/World/Geometry", "Xform")
    stage.DefinePrim("/World/Sensors", "Xform")

    rep.create.light(rotation=(315, 0, 0), intensity=3000, light_type="distant")
    omni.physx.utils.addPhysicsScene(stage=stage, path="/World/PhysicsScene")

    colors = [np.array([255, 0, 0]), np.array([0, 255, 0]), np.array([0, 0, 255])]
    offsets = [-2.5, 0.0, 2.5]
    for idx, offset in enumerate(offsets):
        cube = VisualCuboid(
            prim_path=f"/World/Geometry/Cube_{idx}",
            name=f"cube_{idx}",
            position=np.array([-2.5, offset, 0.0]),
            color=colors[idx],
            scale=np.array([1, 1, 1]),
        )
        cube.prim.CreateAttribute("semantics:class", Sdf.ValueTypeNames.Token).Set(
            "Cube"
        )

        cube_material = OmniPBR(
            prim_path=f"/Looks/cube_{idx}/material",
            name=f"cube_{idx}_material",
            color=colors[idx],
        )
        nv = NV_MATERIALS[idx]
        apply_nonvisual_material(cube_material.prim, nv[0], nv[1], nv[2])
        cube.apply_visual_material(cube_material)


def _ensure_output_dir() -> Path:
    out_dir = Path(__file__).resolve().parent / "ply_intensity_exports_nonzero"
    out_dir.mkdir(parents=True, exist_ok=True)
    return out_dir


def _save_frame_as_ply(frame_idx: int, gmo, output_dir: Path) -> None:
    num_points = int(getattr(gmo, "numElements", 0))
    if num_points <= 0:
        print(f"[PLY Export] Frame {frame_idx}: empty scan, skipping export")
        return

    points = np.stack(
        [
            np.asarray(gmo.x, dtype=np.float32),
            np.asarray(gmo.y, dtype=np.float32),
            np.asarray(gmo.z, dtype=np.float32),
        ],
        axis=1,
    )[:num_points]
    intensities = np.asarray(gmo.scalar, dtype=np.float32)[:num_points]
    material_ids = np.asarray(gmo.matId, dtype=np.int32)[:num_points]

    nonzero_mask = intensities > 0.000
    nonzero_count = int(np.count_nonzero(nonzero_mask))
    if nonzero_count == 0:
        print(
            f"[PLY Export] Frame {frame_idx}: no non-zero intensities, skipping export"
        )
        return

    filtered_points = points[nonzero_mask]
    filtered_intensities = intensities[nonzero_mask]
    filtered_materials = material_ids[nonzero_mask]

    vertices = np.empty(
        nonzero_count,
        dtype=[
            ("x", "f4"),
            ("y", "f4"),
            ("z", "f4"),
            ("intensity", "f4"),
            ("material_id", "i4"),
        ],
    )
    vertices["x"] = filtered_points[:, 0]
    vertices["y"] = filtered_points[:, 1]
    vertices["z"] = filtered_points[:, 2]
    vertices["intensity"] = filtered_intensities
    vertices["material_id"] = filtered_materials

    ply_path = output_dir / f"frame_{frame_idx:03d}.ply"
    ply = PlyData([PlyElement.describe(vertices, "vertex")], text=False)
    ply.comments.append("Only points with intensity > 0 were exported.")
    ply.write(str(ply_path))
    print(f"[PLY Export] Frame {frame_idx}: saved {nonzero_count} points -> {ply_path}")

    stats = {
        "min": float(filtered_intensities.min()),
        "max": float(filtered_intensities.max()),
        "mean": float(filtered_intensities.mean()),
        "std": float(filtered_intensities.std()),
        "q25": float(np.percentile(filtered_intensities, 25)),
        "median": float(np.median(filtered_intensities)),
        "q75": float(np.percentile(filtered_intensities, 75)),
    }
    print(
        "  scalar stats: "
        f"min={stats['min']:.4f} max={stats['max']:.4f} "
        f"mean={stats['mean']:.4f} std={stats['std']:.4f} "
        f"q25={stats['q25']:.4f} median={stats['median']:.4f} q75={stats['q75']:.4f}"
    )


def main():
    stage = omni.usd.get_context().get_stage()
    if stage is None:
        print("No hay stage activo")
        simulation_app.close()
        sys.exit(1)

    _create_scene()

    additional_lidar_attributes = {
        "omni:sensor:Core:auxOutputType": "EXTRA",
        "omni:sensor:Core:elementsCoordsType": "CARTESIAN",
        "omni:sensor:Core:outputFrameOfReference": "WORLD",
        "omni:sensor:Core:intensityProcessing": "NORMALIZATION",
        "omni:sensor:Core:intensityScalePercent": 1.0,
        "omni:sensor:Core:scanRateBaseHz": 100,
    }

    sensor = LidarRtx(
        prim_path="/World/lidar",
        name="lidar",
        position=(0.0, -3.0, 0.0),
        **additional_lidar_attributes,
    )
    sensor.initialize()
    sensor.attach_annotator("GenericModelOutput")

    timeline = omni.timeline.get_timeline_interface()
    timeline.play()

    output_dir = _ensure_output_dir()
    print(f"[RTX Repro] Exporting PLY files to: {output_dir}")

    pos, orient = sensor.get_world_pose()

    for frame_idx in range(55):
        # Move lidar before capturing next frame.
        new_pos = (pos[0], pos[1] + 0.1 * frame_idx, pos[2])
        sensor.set_world_pose(position=new_pos, orientation=orient)

        simulation_app.update()

        frame_data = sensor.get_current_frame()
        gmo_buffer = frame_data.get("GenericModelOutput")
        if gmo_buffer is None:
            print(f"[RTX Repro] Frame {frame_idx}: missing annotator data")
            continue

        gmo_data = get_gmo_data(gmo_buffer)

        print(f"[RTX Repro] Frame {frame_idx}: numElements={gmo_data.numElements}")
        _save_frame_as_ply(frame_idx, gmo_data, output_dir)

        time.sleep(0.5)

    timeline.stop()
    simulation_app.close()
    print("[RTX Repro] Finished exporting moving point clouds.")


if __name__ == "__main__":
    main()

[pabguzman]

#309