Generic wpm model#

Warning

This feature is experimental and under active development. This version is intended for early adopters only and may be unstable.

The Generic wpm model simulates wave paths between transmitters, scene geometry and receivers. Configure transmitter positions, receiver positions, emitted rays and their connections independently. Choose it when you need raw path data for your own sensor processing. WPM stands for wave propagation model.

A three-row, five-column angular range sample of a wall. The center sample is 11 meters away and oblique samples have longer radial ranges.

The depth-sampling example derives radial ranges from valid direct returns to an enclosure wall. Uniform angular samples are not pinhole-camera pixels.#

Simulation#

Independent geometry. Free, Grid and Gaussian patterns describe the transmitters, receivers and rays. Transmitter and receiver patterns use Free or Grid geometry; ray patterns also support Gaussian sampling. A selected transmitter pattern assigns one ray bundle and one receiver-connection rule to all its transmitters. Refer to USD Attributes.

Reusable sampling. A ray bundle describes where rays start and which directions they sample relative to a transmitter. The same bundle is emitted at each transmitter pose. This separates the placement of emitting elements from the sampling around each element. Choose explicit rays for an irregular set of directions, a grid for regular sampling, or a Gaussian bundle for an angular spread. See Sample a Finite-Width Beam.

Scalar propagation. Electromagnetic or mechanical paths yield contributions from scene interactions toward receivers. Firing offsets place emissions within a complete capture. Refer to USD Attributes for propagation and timing controls.

Outputs#

The Contributions output contains per-path geometry, distance, velocity, timing, scalar power and validity. Optional channels describe the hit triangle. Every capture has a dense layout across tiles, transmitters, rays, bounces and receiver slots; read it using the output’s parameters and validity. Refer to Outputs for the contract and Sensor Outputs for shared mapping and ownership.

Features at a glance#

Applications#

Use this model for depth sampling, lidar-style angular scans, finite-width beams, bistatic or multistatic layouts, and acoustic layouts when your application supplies the measurement processing. It delivers raw path contributions rather than finished detector measurements. Your application interprets those paths according to the measurement it needs: for example, deriving a direct-return distance or processing paths between separated transmitters and receivers. Refer to model scope for the processing boundary.

Choose the Lidar generic wpm model for lidar detector returns, the Radar generic wpmDmat model for radar detections, or the Acoustic generic wpm model for echo envelopes. Independent configurations use separate RenderProducts; runtime selection changes the active pattern without replacing stored alternatives.

Sensor definition#

Apply OmniSensorGenericWpmAPI to an OmniGeneralSensor prim and author its omni:sensor:GenericWpm: attributes. The schema supplies the transmitter, receiver, ray and mapping APIs, but no complete default pattern. Start with Set Up a Sensor, then add a complete pattern.

This minimal prim emits one ray from one transmitter and evaluates return paths to one co-located receiver. The USD Python tab assumes an existing USD stage.

#usda 1.0
def OmniGeneralSensor "Sensor" (
    prepend apiSchemas = ["OmniSensorGenericWpmAPI"]
)
{
    token[] omni:sensor:GenericWpm:tx:patternTypes = ["free"]
    uint[] omni:sensor:GenericWpm:freePatterns:tx:numElementsPerPattern = [1]
    float3[] omni:sensor:GenericWpm:freePatterns:tx:positions = [(0, 0, 0)]
    float4[] omni:sensor:GenericWpm:freePatterns:tx:orientations = [(0, 0, 0, 1)]
    token[] omni:sensor:GenericWpm:rx:patternTypes = ["free"]
    uint[] omni:sensor:GenericWpm:freePatterns:rx:numElementsPerPattern = [1]
    float3[] omni:sensor:GenericWpm:freePatterns:rx:positions = [(0, 0, 0)]
    float4[] omni:sensor:GenericWpm:freePatterns:rx:orientations = [(0, 0, 0, 1)]
    token[] omni:sensor:GenericWpm:ray:patternTypes = ["free"]
    uint[] omni:sensor:GenericWpm:freePatterns:ray:numElementsPerPattern = [1]
    float3[] omni:sensor:GenericWpm:freePatterns:ray:positions = [(0, 0, 0)]
    float4[] omni:sensor:GenericWpm:freePatterns:ray:orientations = [(0, 0, 0, 1)]
    uint[] omni:sensor:GenericWpm:tx:rayPatternIndices = [0]
    token[] omni:sensor:GenericWpm:tx:mappingModes = ["1to1"]
}

from pxr import Sdf, UsdGeom, UsdRender

sensor = stage.DefinePrim("/Sensor", "OmniGeneralSensor")
sensor.AddAppliedSchema("OmniSensorGenericWpmAPI")
ns = "omni:sensor:GenericWpm:"
for role in ("tx", "rx", "ray"):
    sensor.CreateAttribute(ns + role + ":patternTypes", Sdf.ValueTypeNames.TokenArray, custom=False).Set(["free"])
    free = ns + "freePatterns:" + role + ":"
    sensor.CreateAttribute(free + "numElementsPerPattern", Sdf.ValueTypeNames.UIntArray, custom=False).Set([1])
    sensor.CreateAttribute(free + "positions", Sdf.ValueTypeNames.Float3Array, custom=False).Set([(0, 0, 0)])
    sensor.CreateAttribute(free + "orientations", Sdf.ValueTypeNames.Float4Array, custom=False).Set([(0, 0, 0, 1)])
sensor.CreateAttribute(ns + "tx:rayPatternIndices", Sdf.ValueTypeNames.UIntArray, custom=False).Set([0])
sensor.CreateAttribute(ns + "tx:mappingModes", Sdf.ValueTypeNames.TokenArray, custom=False).Set(["1to1"])

The Python example saves named channels and parameters and can display hit samples. The C example saves valid records with their logical slots. Both run the same recipe layers. Shared prim and output setup is described by Sensor Configuration and Output Configuration.

Configuration and outputs#