RTX Lidar Synthetic Data#

There are several Annotators to use for Synthetic data collection from the RTX Lidar. The annotator name, the node it creates, and the annotator outputs are all described below. To control the node, you can set the parameters on it using the annotator’s initialize function.

For example, if you had the render product path for a RTX Lidar, then you could create a 360 degree scan buffer of that Lidar, and make sure it outputs the timestamp for each Lidar return in the buffer with the following code.

# Create the annotator.
annotator = rep.AnnotatorRegistry.get_annotator("RtxSensorCpuIsaacCreateRTXLidarScanBuffer")

# Initialize the annotator so it will also output the time stamps.
annotator.initialize(outputTimestamp=True)

# Attach the render product after the annotator is initialized.
annotator.attach([render_product_path])

To read about the nodes the annotators create and the inputs that control the RTX Lidar Nodes, click on the node link at the top of each table.

Annotators#

The following annotators create an RTX Lidar Omnigraph Node, and pull data from it for your use. Several annotators reference Lidar Profile Parameters, and/or Emitter State Parameters.

RtxSensorCpuIsaacComputeRTXLidarFlatScan		Compute RTX Lidar Flat Scan Node
		Output:
	azimuthRange: The min/max horizontal angle of the output in degrees. depthRange: The min/max range of the sensor as defined by the RTX Lidar Config Parameters `near/farRangeM`. horizontalFov: The field of view of the sensor in degrees. horizontalResolution: The amount rotated between each tick in degrees. numCols: The number of ticks in a rotation. numRows: 1. Used to help build the ROS laserscan message. rotationRate: The Hz of the rotary Lidar. timesStamp: Timestamp of first beam in the scan
		Output for each tick/return:
	intensitiesData: Intensity value in the range [0 .. 255]. linearDepthData: The distance of the return hit from the sensor origin in meters and projected onto the plane.

RtxSensorCpuIsaacComputeRTXLidarPointCloud		Compute RTX Lidar Point Cloud Node
		Output:
	info[“transform”]: Transform to apply to the position data if you want it in world space.
		Output for each return:
	data: The \((x, y, z)\) position data of the return in the Lidar’s coordinate system. info[“azimuth/elevation”]: Horizontal/Vertical polar angle of the return in degrees. info[“range”]: The distance of the return hit from the sensor origin in meters. info[“intensity”]: Intensity value in the range [0.0 .. 1.0], then scaled by \(\frac{intensityScalePercent}{100}\) in the RTX Lidar Config Parameters.

RtxSensorCpuIsaacReadRTXLidarData		Read RTX Lidar Point Data Node
		Output:
	numTicks/numChannels/numEchos: The maximum number of ticks, channels, and echos for the returns. The product of these will be the same as the number of returns if you initialize the annotator with `annotator.initialize(keepOnlyPositiveDistance=False)` before attaching the render product. depthRange: The min/max range of the sensor as defined by the RTX Lidar Config Parameter `near/farRangeM`.
		Output for each tick:
	tickAzimuths: Horizontal polar angle of the return tick. tickStates: The emitter state used for the tick, which is an index into the `emitterStates` array as defined by the Emitter State Parameters. tickTimestamps: The timestamp of the tick in nanoseconds. Can be added to the `deltaTimes` of the return to get the return’s timestamp.
		Output for each return:
	azimuths/elevations: Horizontal/Vertical polar angle of the return in degrees. distances: The distance of the return hit from the sensor origin in meters. intensities: Intensity value in the range [0.0 .. 1.0]. deltaTimes: Time as measured from the start of the tick in nanoseconds. hitPointNormals/velocities: The normal at the hit location, in world coordinates. However, if `app.sensors.nv.lidar.enableVelocity=true` then these outputs are the normalized velocity at the hit point. ticks/channels/echos: The tick/channel/echo index of the return. beamIds: The beam Id if `beam` is set in Emitter State Parameters. emitterIds: Same as the channel unless the RTX Lidar Config Parameters is set up so emitters fire through different channels. materialIds: The sensor material Id at the hit location. Same as index from `rtSensorNameToIdMap` setting in the RTX Sensor Visual Materials. objectIds: The object Id at the hit location. The objectId can be used to get the prim path of the object with the following code: from omni.syntheticdata._syntheticdata import acquire_syntheticdata_interface primpath = acquire_syntheticdata_interface().get_uri_from_instance_segmentation_id(object_id)

RtxSensorCpuIsaacCreateRTXLidarScanBuffer		Create RTX Lidar Scan Buffer
		Output in info dictionary:
	numReturnsPerScan: The maximum number of returns possible in the output. ticksPerScan/numChannels/numEchos: The maximum number of ticks, channels, and echos for output. The product of these will be the same as the number of returns if you initialize the annotator with `annotator.initialize(keepOnlyPositiveDistance=False)` before attaching the render product. renderProductPath: The render product from the sensor camera. transform: Transform of the latest data added to the scan buffer for transforming the data to world space. If you output your data in sensor coordinates using `annotator.initialize(transformPoints=False)` then be aware that only the transform is current with only most recently added data.
		Output for each return: [*]
	data: The \((x, y, z)\) position data of the return in world coordinate system. You can output data in the sensor coordinate system with `annotator.initialize(transformPoints=False)`. distance: The distance of the return hit from the sensor origin in meters. intensity: Intensity value in the range [0.0 .. 1.0]. azimuth/elevation: Horizontal/Vertical polar angle of the return in radians. normal/velocity: The normal at the hit location, in world coordinates. However, if `app.sensors.nv.lidar.enableVelocity=true` then these outputs are the normalized velocity at the hit point. timestamp: Time since sensor creation time in nanoseconds for each return. beamId: The beam Id if `beam` is set in Emitter State Parameters. emitterId: Same as the channel unless the RTX Lidar Config Parameters is set up so emitters fire through different channels. materialId: The sensor material Id at the hit location. Same as index from `rtSensorNameToIdMap` setting in the RTX Sensor Visual Materials. objectId: The object Id at the hit location. The objectId can be used to get the prim path of the object with the following code: from omni.syntheticdata._syntheticdata import acquire_syntheticdata_interface primpath = acquire_syntheticdata_interface().get_uri_from_instance_segmentation_id(object_id) index: This will hold the indices into the full size scan buffer of the return, unless you set `annotator.initialize(keepOnlyPositiveDistance=False)` for the annotator. From this index, you can get the tick, the emitter, and the echo for each return. [†]

[*]
data is always returned, but the rest of the per return data is controlled with the outputFoo input parameters. The intensity and distance are output by default, but you could suppress them or turn on, for example, elevation with annotator.initialize(outputElevation=True).

[†]
See this note.