[isaacsim.sensors.physics] Isaac Sim Physics Sensor Simulation#

Warning

Deprecation: Extension deprecated since Isaac Sim 6.0.0 in favor of the Experimental extension: isaacsim.sensors.experimental.physics

Version: 1.1.7

Overview#

Deprecated since version 6.0.0: This extension is deprecated in favor of isaacsim.sensors.experimental.physics.

The isaacsim.sensors.physics extension provides physics-based sensor simulation capabilities for Isaac Sim. This extension offers contact sensors for detecting physical interactions, IMU sensors for measuring inertial data, and effort sensors for monitoring joint forces and torques in robotic simulations. The sensors integrate with the physics simulation to provide real-time measurements with configurable sampling rates, filtering, and interpolation capabilities.

Key Components#

`ContactSensor`#

ContactSensor detects physical contact and measures contact forces in real-time. The sensor creates a collision detection area that monitors when objects come into contact and reports the magnitude of contact forces. It requires the parent prim to have UsdPhysics.CollisionAPI enabled and supports configurable force thresholds to filter contacts based on minimum and maximum force values.

The sensor provides both basic contact information (boolean contact state and force magnitude) and detailed contact data including contact positions, normals, and impulses. Detection radius can be configured to limit the sensing area, and the sensor operates at specified frequencies or time steps.

import isaacsim.sensors.physics as sensors_physics

# Create a contact sensor with force thresholds
contact_sensor = sensors_physics.ContactSensor(
    prim_path="/World/ContactSensor",
    min_threshold=1.0,
    max_threshold=1000.0,
    radius=0.5,
    frequency=60
)

# Get current contact data
frame_data = contact_sensor.get_current_frame()

`IMUSensor`#

IMUSensor measures linear acceleration, angular velocity, and orientation through simulated inertial measurement. The sensor provides three-axis linear acceleration, three-axis angular velocity, and quaternion orientation data from physics simulation. It supports configurable filtering for each measurement type using moving average filters to smooth sensor readings.

The sensor can be positioned and oriented relative to its parent body through local translation and rotation offsets. It operates at configurable sampling frequencies and can include or exclude gravity from acceleration measurements.

# Create an IMU sensor with filtering
imu_sensor = sensors_physics.IMUSensor(
    prim_path="/World/Robot/IMU",
    frequency=100,
    linear_acceleration_filter_size=5,
    angular_velocity_filter_size=3,
    orientation_filter_size=2
)

# Get current inertial measurements
imu_data = imu_sensor.get_current_frame(read_gravity=False)

`EffortSensor`#

EffortSensor monitors joint effort (force/torque) in articulated bodies during physics simulation. The sensor measures the effort applied to specific joints in robotic systems and provides configurable sampling rates with data interpolation capabilities. It maintains internal buffers for temporal data processing and automatically manages data acquisition through physics simulation callbacks.

The sensor can operate at different frequencies than the physics step rate and provides interpolation between samples when needed. It supports both latest data retrieval and time-based interpolated values.

# Create an effort sensor for a robot joint
effort_sensor = sensors_physics.EffortSensor(
    prim_path="/World/Robot/joint_1",
    sensor_period=0.01,  # 100 Hz sampling
    use_latest_data=False
)

# Get interpolated effort reading
reading = effort_sensor.get_sensor_reading()
print(f"Joint effort: {reading.value} at time {reading.time}")

Functionality#

Sensor Creation Commands#

The extension provides USD commands for programmatically creating sensor prims in the stage. IsaacSensorCreateContactSensor creates contact sensors with collision detection capabilities, while IsaacSensorCreateImuSensor creates IMU sensors with inertial measurement functionality. These commands handle prim creation, schema application, and initial configuration.

Data Structures#

EsSensorReading encapsulates effort sensor measurement data including the measured value, timestamp, and validity status. The sensor classes use these data containers to manage buffered sensor readings and provide consistent interfaces for accessing measurement data across different sensor types.

Integration#

The extension integrates with omni.physics for physics simulation callbacks and omni.timeline for simulation timing control. It uses isaacsim.core.api for base sensor functionality and connects with the broader Isaac Sim ecosystem for robotic simulation workflows. The sensors automatically register with physics simulation events to collect data during simulation steps.

Enable Extension#

The extension can be enabled (if not already) in one of the following ways:

Command-line interface

Define the next entry as an application argument from a terminal.

APP_SCRIPT.(sh|bat) --enable isaacsim.sensors.physics

Experience/extension configuration

Define the next entry under [dependencies] in an experience (.kit) file or an extension configuration (extension.toml) file.

[dependencies]
"isaacsim.sensors.physics" = {}

Extension Manager UI

Open the Window > Extensions menu in a running application instance and search for isaacsim.sensors.physics. Then, toggle the enable control button if it is not already active.

Python API#

Commands

`IsaacSensorCreatePrim`	Command for creating Isaac sensor prims in the USD stage.
`IsaacSensorCreateContactSensor`	Create an Isaac Contact Sensor prim in the USD stage.
`IsaacSensorCreateImuSensor`	Command for creating an IMU (Inertial Measurement Unit) sensor prim in the stage.

Sensors

`ContactSensor`	A sensor that detects physical contact and measures contact forces.
`EsSensorReading`	A container for effort sensor measurement data.
`EffortSensor`	A sensor for measuring joint effort (force/torque) in articulated bodies.
`IMUSensor`	A physics-based IMU (Inertial Measurement Unit) sensor that measures linear acceleration, angular velocity, and orientation.

Commands#

class IsaacSensorCreatePrim(*args: Any, **kwargs: Any)#

Bases: Command

Command for creating Isaac sensor prims in the USD stage.

This command creates a new sensor prim using the specified Isaac sensor schema type and applies the provided transformation properties. The sensor is created at the specified path with the given translation and orientation. It serves as a base command for creating various types of Isaac sensors.

Parameters:

path – USD path where the sensor prim will be created.
parent – Parent prim path under which the sensor will be created.
translation – Translation vector for positioning the sensor in 3D space.
orientation – Quaternion rotation for orienting the sensor.
schema_type – Isaac sensor schema type to apply to the created prim.

class IsaacSensorCreateContactSensor(*args: Any, **kwargs: Any)#

Bases: Command

Create an Isaac Contact Sensor prim in the USD stage.

This command creates a contact sensor that detects physical contact between objects in a simulation. The sensor monitors contact forces and reports when they fall within specified threshold ranges. It automatically applies the PhysX Contact Report API to the parent prim to enable contact detection.

Parameters:

path – USD path where the contact sensor prim will be created.
parent – USD path of the parent prim. Must be specified for successful sensor creation.
min_threshold – Minimum contact force threshold for detection.
max_threshold – Maximum contact force threshold for detection.
color – RGBA color values for sensor visualization.
radius – Detection radius for the contact sensor. Negative values use default behavior.
sensor_period – Data collection frequency in seconds. Negative values use default behavior.
translation – 3D translation offset from the parent prim’s origin.

class IsaacSensorCreateImuSensor(*args: Any, **kwargs: Any)#

Bases: Command

Command for creating an IMU (Inertial Measurement Unit) sensor prim in the stage.

This command creates an Isaac IMU sensor that can measure linear acceleration, angular velocity, and orientation. The sensor supports configurable filter sizes for smoothing the measured values and can be positioned and oriented relative to its parent prim.

Parameters:

path – USD path where the IMU sensor prim will be created.
parent – USD path of the parent prim to attach the sensor to.
sensor_period – Sensor update period in simulation time. Negative values use the default period.
translation – Local translation offset from the parent prim.
orientation – Local rotation offset from the parent prim as a quaternion (w, x, y, z).
linear_acceleration_filter_size – Number of samples to use for linear acceleration filtering.
angular_velocity_filter_size – Number of samples to use for angular velocity filtering.
orientation_filter_size – Number of samples to use for orientation filtering.

Sensors#

Bases: BaseSensor

A sensor that detects physical contact and measures contact forces.

ContactSensor creates and manages a contact sensor that can detect when objects come into contact with it and measure the magnitude of contact forces. The sensor must be attached to a prim that has the UsdPhysics.CollisionAPI enabled. It provides real-time contact detection with configurable thresholds and can report detailed contact information including positions, normals, and impulses.

The sensor can operate at a specified frequency or time step and includes filtering capabilities through min/max thresholds to ignore contacts below or above certain force values. It supports both basic contact detection (boolean in-contact state and force magnitude) and detailed contact data (individual contact points with full physics information).

Parameters:

prim_path – USD path where the contact sensor will be created.
name – Name identifier for the sensor.
frequency – Sensor update frequency in Hz. Cannot be used with dt.
dt – Sensor update time step in seconds. Cannot be used with frequency.
translation – Local translation offset of the sensor relative to its parent prim.
position – World position where the sensor should be placed.
min_threshold – Minimum force threshold below which contacts are ignored.
max_threshold – Maximum force threshold above which contacts are clamped.
radius – Detection radius of the contact sensor. Negative values indicate unlimited radius.

Raises:

Exception – If both frequency and dt are specified simultaneously.
Exception – If the parent prim does not have UsdPhysics.CollisionAPI enabled.
Exception – If sensor creation fails.

add_raw_contact_data_to_frame() → None#: Add raw contact data to the current frame for detailed contact information.

apply_visual_material( visual_material: VisualMaterial, weaker_than_descendants: bool = False, ) → None#

Apply visual material to the held prim and optionally its descendants.

Parameters:

visual_material – Visual material to be applied to the held prim. Currently supports PreviewSurface, OmniPBR and OmniGlass.
weaker_than_descendants – True if the material shouldn’t override the descendants materials, otherwise False.

Example:

>>> from isaacsim.core.api.materials import OmniGlass
>>>
>>> # create a dark-red glass visual material
>>> material = OmniGlass(
...     prim_path="/World/material/glass",  # path to the material prim to create
...     ior=1.25,
...     depth=0.001,
...     thin_walled=False,
...     color=np.array([0.5, 0.0, 0.0])
... )
>>> prim.apply_visual_material(material)

get_applied_visual_material() → VisualMaterial#

Return the current applied visual material in case it was applied using apply_visual_material.

or it’s one of the following materials that was already applied before: PreviewSurface, OmniPBR and OmniGlass.

Returns:: The current applied visual material if its type is currently supported.

Example:

>>> # given a visual material applied
>>> prim.get_applied_visual_material()
<isaacsim.core.api.materials.omni_glass.OmniGlass object at 0x7f36263106a0>

get_current_frame() → dict#

Get the current sensor frame data including contact information.

Returns:: Dictionary containing contact data with keys for time, physics step, contact status, force, and number of contacts.

get_default_state() → XFormPrimState#

Get the default prim states (spatial position and orientation).

Returns:: An object that contains the default state of the prim (position and orientation)

Example:

>>> state = prim.get_default_state()
>>> state
<isaacsim.core.utils.types.XFormPrimState object at 0x7f33addda650>
>>>
>>> state.position
[-4.5299529e-08 -1.8347054e-09 -2.8610229e-08]
>>> state.orientation
[1. 0. 0. 0.]

get_dt() → float#

Get the sensor sampling time interval.

Returns:: The time interval between sensor readings in seconds.

get_frequency() → int#

Get the current sensor sampling frequency.

Returns:: The sensor frequency in Hz.

get_local_pose() → tuple[ndarray, ndarray]#

Get prim’s pose with respect to the local frame (the prim’s parent frame).

Returns:: First index is the position in the local frame (with shape (3, )). Second index is quaternion orientation (with shape (4, )) in the local frame

Example:

>>> # if the prim is in position (1.0, 0.5, 0.0) with respect to the world frame
>>> position, orientation = prim.get_local_pose()
>>> position
[0. 0. 0.]
>>> orientation
[0. 0. 0.]

get_local_scale() → ndarray#

Get prim’s scale with respect to the local frame (the parent’s frame).

Returns:: Scale applied to the prim’s dimensions in the local frame. shape is (3, ).

Example:

>>> prim.get_local_scale()
[1. 1. 1.]

get_max_threshold() → float#

Maximum force threshold for contact detection.

Returns:: The maximum force threshold value.

get_min_threshold() → float#

Minimum force threshold for contact detection.

Returns:: The minimum force threshold value.

get_radius() → float#

Radius of the contact sensor detection area.

Returns:: The radius value of the sensor detection area.

get_visibility() → bool#

Get the visibility of the prim in stage.

Returns:: True if the prim is visible in stage. False otherwise.

Example:

>>> # get the visible state of an visible prim on the stage
>>> prim.get_visibility()
True

get_world_pose() → tuple[ndarray, ndarray]#

Get prim’s pose with respect to the world’s frame.

Returns:: First index is the position in the world frame (with shape (3, )). Second index is quaternion orientation (with shape (4, )) in the world frame

Example:

>>> # if the prim is in position (1.0, 0.5, 0.0) with respect to the world frame
>>> position, orientation = prim.get_world_pose()
>>> position
[1.  0.5 0. ]
>>> orientation
[1. 0. 0. 0.]

get_world_scale() → ndarray#

Get prim’s scale with respect to the world’s frame.

Returns:: Scale applied to the prim’s dimensions in the world frame. shape is (3, ).

Example:

>>> prim.get_world_scale()
[1. 1. 1.]

initialize(physics_sim_view: object = None) → None#

Initialize the contact sensor.

Parameters:: physics_sim_view – Physics simulation view to initialize with.

is_paused() → bool#

Check if the contact sensor is currently paused.

Returns:: True if the sensor is paused, False otherwise.

is_valid() → bool#

Check if the prim path has a valid USD Prim at it.

Returns:: True is the current prim path corresponds to a valid prim in stage. False otherwise.

Example:

>>> # given an existing and valid prim
>>> prims.is_valid()
True

is_visual_material_applied() → bool#

Check if there is a visual material applied.

Returns:: True if there is a visual material applied. False otherwise.

Example:

>>> # given a visual material applied
>>> prim.is_visual_material_applied()
True

pause() → None#: Pause sensor data collection by disabling the contact sensor.

post_reset() → None#: Resets the sensor to its initial state after a simulation reset.

remove_raw_contact_data_from_frame() → None#: Remove raw contact data from the current frame.

resume() → None#: Resume sensor data collection by enabling the contact sensor.

set_default_state( position: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set the default state of the prim (position and orientation), that will be used after each reset.

Parameters:

position – Position in the world frame of the prim. shape is (3, ). Which means left unchanged.
orientation – Quaternion orientation in the world frame of the prim. Quaternion is scalar-first (w, x, y, z). shape is (4, ). Which means left unchanged.

Example:

>>> # configure default state
>>> prim.set_default_state(position=np.array([1.0, 0.5, 0.0]), orientation=np.array([1, 0, 0, 0]))
>>>
>>> # set default states during post-reset
>>> prim.post_reset()

set_dt(value: float) → None#

Set the sensor period (time step) for the contact sensor.

Parameters:: value – The sensor period in seconds.

set_frequency(value: float) → None#

Set the sensor sampling frequency.

Parameters:: value – The frequency in Hz to set for the sensor.

set_local_pose( translation: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set prim’s pose with respect to the local frame (the prim’s parent frame).

Warning

This method will change (teleport) the prim pose immediately to the indicated value

Parameters:

translation – Translation in the local frame of the prim (with respect to its parent prim). shape is (3, ).
orientation – Quaternion orientation in the local frame of the prim. quaternion is scalar-first (w, x, y, z). shape is (4, ).

Hint

This method belongs to the methods used to set the prim state

Example:

>>> prim.set_local_pose(translation=np.array([1.0, 0.5, 0.0]), orientation=np.array([1., 0., 0., 0.]))

set_local_scale( scale: Sequence[float] | None, ) → None#

Set prim’s scale with respect to the local frame (the prim’s parent frame).

Parameters:: scale – Scale to be applied to the prim’s dimensions. shape is (3, ).

Example:

>>> # scale prim 10 times smaller
>>> prim.set_local_scale(np.array([0.1, 0.1, 0.1]))

set_max_threshold(value: float) → None#

Set the maximum force threshold for contact detection.

Parameters:: value – The maximum threshold value.

set_min_threshold(value: float) → None#

Set the minimum force threshold for contact detection.

Parameters:: value – The minimum threshold value.

set_radius(value: float) → None#

Set the radius of the contact sensor detection area.

Parameters:: value – The radius value to set.

set_visibility(visible: bool) → None#

Set the visibility of the prim in stage.

Parameters:: visible – Flag to set the visibility of the usd prim in stage.

Example:

>>> # make prim not visible in the stage
>>> prim.set_visibility(visible=False)

set_world_pose( position: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set prim’s pose with respect to the world’s frame.

Warning

This method will change (teleport) the prim pose immediately to the indicated value

Parameters:

position – Position in the world frame of the prim. shape is (3, ).
orientation – Quaternion orientation in the world frame of the prim. quaternion is scalar-first (w, x, y, z). shape is (4, ).

Hint

This method belongs to the methods used to set the prim state

Example:

>>> prim.set_world_pose(position=np.array([1.0, 0.5, 0.0]), orientation=np.array([1., 0., 0., 0.]))

property name: str | None#

Name given to the prim when instantiating it.

Returns:: Name given to the prim when instantiating it. Otherwise None.

property non_root_articulation_link: bool#

Used to query if the prim is a non root articulation link.

Returns:: True if the prim itself is a non root link

Example:

>>> # for a wrapped articulation (where the root prim has the Physics Articulation Root property applied)
>>> prim.non_root_articulation_link
False

property prim: pxr.Usd.Prim#

USD Prim object that this object holds.

Returns:: USD Prim object that this object holds.

property prim_path: str#

Prim path in the stage.

Returns:: Prim path in the stage.

class EsSensorReading( is_valid: bool = False, time: float = 0, value: float = 0, )#

Bases: object

A container for effort sensor measurement data.

This class encapsulates a single reading from an effort sensor, containing the measured value, timestamp, and validity status. It is used by EffortSensor to store and manage sensor data in buffers for interpolation and retrieval.

Parameters:

is_valid – Whether the sensor reading contains valid data.
time – Simulation time when the measurement was taken.
value – The measured effort value from the sensor.

class EffortSensor( prim_path: str, sensor_period: float = -1, use_latest_data: bool = False, enabled: bool = True, )#

Bases: SingleArticulation

A sensor for measuring joint effort (force/torque) in articulated bodies.

This sensor monitors the effort applied to a specific joint in an articulated body during physics simulation. It provides configurable sampling rates and data interpolation capabilities for accurate measurements. The sensor automatically manages data acquisition through physics simulation callbacks and maintains internal buffers for temporal data processing.

Parameters:

prim_path – Full USD path to the joint, including the articulated body path and joint name (e.g., “/World/Robot/joint_name”).
sensor_period – Time interval between sensor readings in seconds. If negative or less than the physics step size, readings are taken at every physics step.
use_latest_data – Whether to always return the most recent measurement instead of interpolated values.
enabled – Whether the sensor is actively collecting data.

apply_action( control_actions: ArticulationAction, ) → None#

Apply joint positions, velocities and/or efforts to control an articulation.

Parameters:: control_actions – Actions to be applied for next physics step.

Hint

High stiffness makes the joints snap faster and harder to the desired target, and higher damping smoothes but also slows down the joint’s movement to target

For position control, set relatively high stiffness and low damping (to reduce vibrations)
For velocity control, stiffness must be set to zero with a non-zero damping
For effort control, stiffness and damping must be set to zero

Example:

>>> from isaacsim.core.utils.types import ArticulationAction
>>>
>>> # move all the robot joints to the indicated position
>>> action = ArticulationAction(joint_positions=np.array([0.0, -1.0, 0.0, -2.2, 0.0, 2.4, 0.8, 0.04, 0.04]))
>>> prim.apply_action(action)
>>>
>>> # close the robot fingers: panda_finger_joint1 (7) and panda_finger_joint2 (8) to 0.0
>>> action = ArticulationAction(joint_positions=np.array([0.0, 0.0]), joint_indices=np.array([7, 8]))
>>> prim.apply_action(action)

apply_visual_material( visual_material: VisualMaterial, weaker_than_descendants: bool = False, ) → None#

Apply visual material to the held prim and optionally its descendants.

Parameters:

visual_material – Visual material to be applied to the held prim. Currently supports PreviewSurface, OmniPBR and OmniGlass.
weaker_than_descendants – True if the material shouldn’t override the descendants materials, otherwise False.

Example:

>>> from isaacsim.core.api.materials import OmniGlass
>>>
>>> # create a dark-red glass visual material
>>> material = OmniGlass(
...     prim_path="/World/material/glass",  # path to the material prim to create
...     ior=1.25,
...     depth=0.001,
...     thin_walled=False,
...     color=np.array([0.5, 0.0, 0.0])
... )
>>> prim.apply_visual_material(material)

change_buffer_size(new_buffer_size: int) → None#

Resize the sensor data buffers to a new size.

Adjusts both the main sensor reading buffer and interpolation buffer to the specified size.

Parameters:: new_buffer_size – New size for the sensor data buffers.

disable_gravity() → None#

Keep gravity from affecting the robot.

Example:

>>> prim.disable_gravity()

enable_gravity() → None#

Allow gravity to affect the robot.

Example:

>>> prim.enable_gravity()

get_angular_velocity() → ndarray#

Angular velocity of the root articulation prim.

Returns:: 3D angular velocity vector. Shape (3,).

Example:

>>> prim.get_angular_velocity()
[0. 0. 0.]

get_applied_action() → ArticulationAction#

Last applied action.

Returns:: Last applied action. Note that a dictionary is used as the object’s string representation.

Example:

>>> # last applied action: joint_positions -> [0.0, -1.0, 0.0, -2.2, 0.0, 2.4, 0.8, 0.04, 0.04]
>>> prim.get_applied_action()
{'joint_positions': [0.0, -1.0, 0.0, -2.200000047683716, 0.0, 2.4000000953674316,
                     0.800000011920929, 0.03999999910593033, 0.03999999910593033],
 'joint_velocities': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
 'joint_efforts': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]}

get_applied_joint_efforts( joint_indices: list | ndarray | None = None, ) → ndarray#

Get the efforts applied to the joints set by the set_joint_efforts method.

Parameters:: joint_indices – indices to specify which joints to read. Defaults to None (all joints)
Raises:: Exception – If the handlers are not initialized
Returns:: all or selected articulation joint applied efforts

Example:

>>> # get all applied joint efforts
>>> prim.get_applied_joint_efforts()
[ 0.  0.  0.  0.  0.  0.  0.  0.  0.]
>>>
>>> # get finger applied efforts: panda_finger_joint1 (7) and panda_finger_joint2 (8)
>>> prim.get_applied_joint_efforts(joint_indices=np.array([7, 8]))
[0.  0.]

get_applied_visual_material() → VisualMaterial#

Return the current applied visual material in case it was applied using apply_visual_material.

or it’s one of the following materials that was already applied before: PreviewSurface, OmniPBR and OmniGlass.

Returns:: The current applied visual material if its type is currently supported.

Example:

>>> # given a visual material applied
>>> prim.get_applied_visual_material()
<isaacsim.core.api.materials.omni_glass.OmniGlass object at 0x7f36263106a0>

get_articulation_body_count() → int#

Get the number of bodies (links) that make up the articulation.

Returns:: Amount of bodies.

Example:

>>> prim.get_articulation_body_count()
12

get_articulation_controller() → ArticulationController#

Get the articulation controller.

Note

If no articulation_controller was passed during class instantiation, a default controller of type ArticulationController (a Proportional-Derivative controller that can apply position targets, velocity targets and efforts) will be used

Returns:: Articulation controller.

Example:

>>> prim.get_articulation_controller()
<isaacsim.core.api.controllers.articulation_controller.ArticulationController object at 0x7f04a0060190>

get_default_state() → XFormPrimState#

Get the default prim states (spatial position and orientation).

Returns:: An object that contains the default state of the prim (position and orientation)

Example:

>>> state = prim.get_default_state()
>>> state
<isaacsim.core.utils.types.XFormPrimState object at 0x7f33addda650>
>>>
>>> state.position
[-4.5299529e-08 -1.8347054e-09 -2.8610229e-08]
>>> state.orientation
[1. 0. 0. 0.]

get_dof_index(dof_name: str) → int#

Get a DOF index given its name.

Parameters:: dof_name – Name of the DOF.
Returns:: DOF index.

Example:

>>> prim.get_dof_index("panda_finger_joint2")
8

get_enabled_self_collisions() → uint8#

Get the enable self collisions flag (physxArticulation:enabledSelfCollisions).

Returns:: self collisions flag (boolean interpreted as int)

Example:

>>> prim.get_enabled_self_collisions()
0

get_joint_positions( joint_indices: list | ndarray | None = None, ) → ndarray#

Get the articulation joint positions.

Parameters:: joint_indices – indices to specify which joints to read. Defaults to None (all joints)
Returns:: all or selected articulation joint positions

Example:

>>> # get all joint positions
>>> prim.get_joint_positions()
[ 1.1999920e-02 -5.6962633e-01  1.3480479e-08 -2.8105433e+00  6.8284894e-06
  3.0301569e+00  7.3234749e-01  3.9912373e-02  3.9999999e-02]
>>>
>>> # get finger positions: panda_finger_joint1 (7) and panda_finger_joint2 (8)
>>> prim.get_joint_positions(joint_indices=np.array([7, 8]))
[0.03991237  3.9999999e-02]

get_joint_velocities( joint_indices: list | ndarray | None = None, ) → ndarray#

Get the articulation joint velocities.

Parameters:: joint_indices – indices to specify which joints to read. Defaults to None (all joints)
Returns:: all or selected articulation joint velocities

Example:

>>> # get all joint velocities
>>> prim.get_joint_velocities()
[ 1.91603772e-06 -7.67638255e-03 -2.19138826e-07  1.10636465e-02 -4.63412944e-05
  3.48245539e-02  8.84692147e-02  5.40335372e-04 1.02849208e-05]
>>>
>>> # get finger velocities: panda_finger_joint1 (7) and panda_finger_joint2 (8)
>>> prim.get_joint_velocities(joint_indices=np.array([7, 8]))
[5.4033537e-04 1.0284921e-05]

get_joints_default_state() → JointsState#

Default joint states (positions and velocities).

Returns:: An object that contains the default joint positions and velocities.

Example:

>>> state = prim.get_joints_default_state()
>>> state
<isaacsim.core.utils.types.JointsState object at 0x7f04a0061240>
>>>
>>> state.positions
[ 0.012  -0.57000005  0.  -2.81  0.  3.037  0.785398  0.04  0.04 ]
>>> state.velocities
[0. 0. 0. 0. 0. 0. 0. 0. 0.]

get_joints_state() → JointsState#

Current joint states (positions and velocities).

Returns:: An object that contains the current joint positions and velocities.

Example:

>>> state = prim.get_joints_state()
>>> state
<isaacsim.core.utils.types.JointsState object at 0x7f02f6df57b0>
>>>
>>> state.positions
[ 1.1999920e-02 -5.6962633e-01  1.3480479e-08 -2.8105433e+00 6.8284894e-06
  3.0301569e+00  7.3234749e-01  3.9912373e-02  3.9999999e-02]
>>> state.velocities
[ 1.91603772e-06 -7.67638255e-03 -2.19138826e-07  1.10636465e-02 -4.63412944e-05
  245539e-02  8.84692147e-02  5.40335372e-04  1.02849208e-05]

get_linear_velocity() → ndarray#

Linear velocity of the root articulation prim.

Returns:: 3D linear velocity vector. Shape (3,).

Example:

>>> prim.get_linear_velocity()
[0. 0. 0.]

get_local_pose() → tuple[ndarray, ndarray]#

Get prim’s pose with respect to the local frame (the prim’s parent frame).

Returns:: First index is the position in the local frame (with shape (3, )). Second index is quaternion orientation (with shape (4, )) in the local frame

Example:

>>> # if the prim is in position (1.0, 0.5, 0.0) with respect to the world frame
>>> position, orientation = prim.get_local_pose()
>>> position
[0. 0. 0.]
>>> orientation
[0. 0. 0.]

get_local_scale() → ndarray#

Get prim’s scale with respect to the local frame (the parent’s frame).

Returns:: Scale applied to the prim’s dimensions in the local frame. shape is (3, ).

Example:

>>> prim.get_local_scale()
[1. 1. 1.]

get_measured_joint_efforts( joint_indices: list | ndarray | None = None, ) → ndarray#

Returns the efforts computed/measured by the physics solver of the joint forces in the DOF motion direction.

Parameters:: joint_indices – indices to specify which joints to read. Defaults to None (all joints)
Raises:: Exception – If the handlers are not initialized
Returns:: all or selected articulation joint measured efforts

Example:

>>> # get all joint efforts
>>> prim.get_measured_joint_efforts()
[ 2.7897308e-06 -6.9083519e+00 -3.6398471e-06  1.9158335e+01 -4.3552645e-06
  1.1866090e+00 -4.7079347e-06  3.2339853e-04 -3.2044132e-04]
>>>
>>> # get finger efforts: panda_finger_joint1 (7) and panda_finger_joint2 (8)
>>> prim.get_measured_joint_efforts(joint_indices=np.array([7, 8]))
[ 0.0003234  -0.00032044]

get_measured_joint_forces( joint_indices: list | ndarray | None = None, ) → ndarray#

Get the measured joint reaction forces and torques (link incoming joint forces and torques) to external loads.

Forces and torques are reported in the local body reference frame (child joint frame of the link’s incoming joint).

Note

Since the name->index map for joints has not been exposed yet, it is possible to access the joint names and their indices through the articulation metadata.

prim._articulation_view._metadata.joint_names  # list of names
prim._articulation_view._metadata.joint_indices  # dict of name: index

To retrieve a specific row for the link incoming joint force/torque use joint_index + 1

Parameters:: joint_indices – indices to specify which joints to read. Defaults to None (all joints)
Raises:: Exception – If the handlers are not initialized
Returns:: measured joint forces and torques. Shape is (num_joint + 1, 6). Row index 0 is the incoming joint of the base link. For the last dimension the first 3 values are for forces and the last 3 for torques

Example:

>>> # get all measured joint forces and torques
>>> prim.get_measured_joint_forces()
[[ 0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00  0.0000000e+00]
 [ 1.4995076e+02  4.2574748e-06  5.6364370e-04  4.8701895e-05 -6.9072924e+00  3.1881387e-05]
 [-2.8971717e-05 -1.0677823e+02 -6.8384506e+01 -6.9072924e+00 -5.4927128e-05  6.1222494e-07]
 [ 8.7120995e+01 -4.3871860e-05 -5.5795174e+01  5.3687054e-05 -2.4538563e+01  1.3333466e-05]
 [ 5.3519474e-05 -4.8109909e+01  6.0709282e+01  1.9157074e+01 -5.9258469e-05  8.2744418e-07]
 [-3.1691040e+01  2.3313689e-04  3.9990173e+01 -5.8968733e-05 -1.1863431e+00  2.2335558e-05]
 [-1.0809851e-04  1.5340537e+01 -1.5458489e+01  1.1863426e+00  6.1094368e-05 -1.5940281e-05]
 [-7.5418940e+00 -5.0814648e+00 -5.6512990e+00 -5.6385466e-05  3.8859999e-01 -3.4943256e-01]
 [ 4.7421460e+00 -3.1945827e+00  3.5528181e+00  5.5852943e-05  8.4794536e-03  7.6405057e-03]
 [ 4.0760727e+00  2.1640673e-01 -4.0513167e+00 -5.9565349e-04  1.1407082e-02  2.1432268e-06]
 [ 5.1680198e-03 -9.7754575e-02 -9.7093947e-02 -8.4155556e-12 -1.2910691e-12 -1.9347857e-11]
 [-5.1910793e-03  9.7588278e-02 -9.7106412e-02  8.4155573e-12  1.2910637e-12 -1.9347855e-11]]
>>>
>>> # get measured joint force and torque for the fingers
>>> metadata = prim._articulation_view._metadata
>>> joint_indices = 1 + np.array([
...     metadata.joint_indices["panda_finger_joint1"],
...     metadata.joint_indices["panda_finger_joint2"],
... ])
>>> joint_indices
[10 11]
>>> prim.get_measured_joint_forces(joint_indices)
[[ 5.1680198e-03 -9.7754575e-02 -9.7093947e-02 -8.4155556e-12 -1.2910691e-12 -1.9347857e-11]
 [-5.1910793e-03  9.7588278e-02 -9.7106412e-02  8.4155573e-12  1.2910637e-12 -1.9347855e-11]]

get_sensor_reading( interpolation_function: object = None, use_latest_data: bool = False, ) → EsSensorReading#

Get the current sensor reading with optional interpolation.

Returns either the latest reading or an interpolated value based on sensor period and timing. Handles cases where sensor frequency differs from physics step frequency.

Parameters:

interpolation_function – Custom interpolation function to use instead of linear interpolation.
use_latest_data – Whether to force using the most recent data regardless of sensor period.

Returns:

Sensor reading containing timestamp, effort value, and validity status.

get_sleep_threshold() → float#

Get the threshold for articulations to enter a sleep state.

Search for Articulations and Sleeping in PhysX docs for more details

Returns:: sleep threshold

Example:

>>> prim.get_sleep_threshold()
0.005

get_solver_position_iteration_count() → int#

Get the solver (position) iteration count for the articulation.

The solver iteration count determines how accurately contacts, drives, and limits are resolved. Search for Solver Iteration Count in PhysX docs for more details.

Returns:: position iteration count

Example:

>>> prim.get_solver_position_iteration_count()
32

get_solver_velocity_iteration_count() → int#

Get the solver (velocity) iteration count for the articulation.

The solver iteration count determines how accurately contacts, drives, and limits are resolved. Search for Solver Iteration Count in PhysX docs for more details.

Returns:: velocity iteration count

Example:

>>> prim.get_solver_velocity_iteration_count()
32

get_stabilization_threshold() → float#

Get the mass-normalized kinetic energy below which the articulation may participate in stabilization.

Search for Stabilization Threshold in PhysX docs for more details

Returns:: stabilization threshold

Example:

>>> prim.get_stabilization_threshold()
0.0009999999

get_visibility() → bool#

Get the visibility of the prim in stage.

Returns:: True if the prim is visible in stage. False otherwise.

Example:

>>> # get the visible state of an visible prim on the stage
>>> prim.get_visibility()
True

get_world_pose() → tuple[ndarray, ndarray]#

Get prim’s pose with respect to the world’s frame.

Returns:: First index is the position in the world frame (with shape (3, )). Second index is quaternion orientation (with shape (4, )) in the world frame

Example:

>>> # if the prim is in position (1.0, 0.5, 0.0) with respect to the world frame
>>> position, orientation = prim.get_world_pose()
>>> position
[1.  0.5 0. ]
>>> orientation
[1. 0. 0. 0.]

get_world_scale() → ndarray#

Get prim’s scale with respect to the world’s frame.

Returns:: Scale applied to the prim’s dimensions in the world frame. shape is (3, ).

Example:

>>> prim.get_world_scale()
[1. 1. 1.]

get_world_velocity() → ndarray#

Get the articulation root velocity.

Returns:: current velocity of the root prim. Shape (6,).

initialize( physics_sim_view: omni.physics.tensors.SimulationView = None, ) → None#

Create a physics simulation view if not passed and an articulation view using PhysX tensor API.

Note

If the articulation has been added to the world scene (e.g., world.scene.add(prim)), it will be automatically initialized when the world is reset (e.g., world.reset()).

Warning

This method needs to be called after each hard reset (e.g., Stop + Play on the timeline) before interacting with any other class method.

Parameters:: physics_sim_view – Current physics simulation view.

Example:

>>> prim.initialize()

initialize_callbacks() → None#

Initialize physics and timeline event callbacks for the effort sensor.

Sets up callbacks for physics step events, stage opening events, and timeline play/stop events to manage sensor data acquisition and state reset.

is_valid() → bool#

Check if the prim path has a valid USD Prim at it.

Returns:: True is the current prim path corresponds to a valid prim in stage. False otherwise.

Example:

>>> # given an existing and valid prim
>>> prims.is_valid()
True

is_visual_material_applied() → bool#

Check if there is a visual material applied.

Returns:: True if there is a visual material applied. False otherwise.

Example:

>>> # given a visual material applied
>>> prim.is_visual_material_applied()
True

lerp(start: float, end: float, time: float) → float#

Perform linear interpolation between two values.

Parameters:

start – Starting value.
end – Ending value.
time – Interpolation factor between 0 and 1.

Returns:

Interpolated value between start and end.

post_reset() → None#

Reset the prim to its default state (position and orientation).

Note

For an articulation, in addition to configuring the root prim’s default position and spatial orientation (defined via the set_default_state method), the joint’s positions, velocities, and efforts (defined via the set_joints_default_state method) are imposed

Example:

>>> prim.post_reset()

set_angular_velocity(velocity: ndarray) → None#

Set the angular velocity of the root articulation prim.

Warning

This method will immediately set the articulation state

Parameters:: velocity – 3D angular velocity vector. Shape (3,).

Hint

This method belongs to the methods used to set the articulation kinematic state:

set_linear_velocity, set_angular_velocity, set_joint_positions, set_joint_velocities, set_joint_efforts

Example:

>>> prim.set_angular_velocity(np.array([0.1, 0.0, 0.0]))

set_default_state( position: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set the default state of the prim (position and orientation), that will be used after each reset.

Parameters:

position – Position in the world frame of the prim. shape is (3, ). Which means left unchanged.
orientation – Quaternion orientation in the world frame of the prim. Quaternion is scalar-first (w, x, y, z). shape is (4, ). Which means left unchanged.

Example:

>>> # configure default state
>>> prim.set_default_state(position=np.array([1.0, 0.5, 0.0]), orientation=np.array([1, 0, 0, 0]))
>>>
>>> # set default states during post-reset
>>> prim.post_reset()

set_enabled_self_collisions(flag: bool) → None#

Set the enable self collisions flag (physxArticulation:enabledSelfCollisions).

Parameters:: flag – whether to enable self collisions

Example:

>>> prim.set_enabled_self_collisions(True)

set_joint_efforts( efforts: ndarray, joint_indices: list | ndarray | None = None, ) → None#

Set the articulation joint efforts.

Note

This method can be used for effort control. For this purpose, there must be no joint drive or the stiffness and damping must be set to zero.

Parameters:

efforts – articulation joint efforts
joint_indices – indices to specify which joints to manipulate. Defaults to None (all joints)

Hint

This method belongs to the methods used to set the articulation kinematic state:

set_linear_velocity, set_angular_velocity, set_joint_positions, set_joint_velocities, set_joint_efforts

Example:

>>> # set all the robot joint efforts to 0.0
>>> prim.set_joint_efforts(np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]))
>>>
>>> # set only the fingers efforts: panda_finger_joint1 (7) and panda_finger_joint2 (8) to 10
>>> prim.set_joint_efforts(np.array([10, 10]), joint_indices=np.array([7, 8]))

set_joint_positions( positions: ndarray, joint_indices: list | ndarray | None = None, ) → None#

Set the articulation joint positions.

Warning

This method will immediately set (teleport) the affected joints to the indicated value. Use the apply_action method to control robot joints.

Parameters:

positions – articulation joint positions
joint_indices – indices to specify which joints to manipulate. Defaults to None (all joints)

Hint

This method belongs to the methods used to set the articulation kinematic state:

set_linear_velocity, set_angular_velocity, set_joint_positions, set_joint_velocities, set_joint_efforts

Example:

>>> # set all the robot joints
>>> prim.set_joint_positions(np.array([0.0, -1.0, 0.0, -2.2, 0.0, 2.4, 0.8, 0.04, 0.04]))
>>>
>>> # set only the fingers in closed position: panda_finger_joint1 (7) and panda_finger_joint2 (8) to 0.0
>>> prim.set_joint_positions(np.array([0.04, 0.04]), joint_indices=np.array([7, 8]))

set_joint_velocities( velocities: ndarray, joint_indices: list | ndarray | None = None, ) → None#

Set the articulation joint velocities.

Warning

This method will immediately set the affected joints to the indicated value. Use the apply_action method to control robot joints.

Parameters:

velocities – articulation joint velocities
joint_indices – indices to specify which joints to manipulate. Defaults to None (all joints)

Hint

This method belongs to the methods used to set the articulation kinematic state:

set_linear_velocity, set_angular_velocity, set_joint_positions, set_joint_velocities, set_joint_efforts

Example:

>>> # set all the robot joint velocities to 0.0
>>> prim.set_joint_velocities(np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]))
>>>
>>> # set only the fingers velocities: panda_finger_joint1 (7) and panda_finger_joint2 (8) to -0.01
>>> prim.set_joint_velocities(np.array([-0.01, -0.01]), joint_indices=np.array([7, 8]))

set_joints_default_state( positions: ndarray | None = None, velocities: ndarray | None = None, efforts: ndarray | None = None, ) → None#

Set the joint default states (positions, velocities and/or efforts) to be applied after each reset.

Note

The default states will be set during post-reset (e.g., calling .post_reset() or world.reset() methods)

Parameters:

positions – Joint positions.
velocities – Joint velocities.
efforts – Joint efforts.

Example:

>>> # configure default joint states
>>> prim.set_joints_default_state(
...     positions=np.array([0.0, -1.0, 0.0, -2.2, 0.0, 2.4, 0.8, 0.04, 0.04]),
...     velocities=np.zeros(shape=(prim.num_dof,)),
...     efforts=np.zeros(shape=(prim.num_dof,))
... )
>>>
>>> # set default states during post-reset
>>> prim.post_reset()

set_linear_velocity(velocity: ndarray) → None#

Set the linear velocity of the root articulation prim.

Warning

This method will immediately set the articulation state

Parameters:: velocity – 3D linear velocity vector. Shape (3,).

Hint

This method belongs to the methods used to set the articulation kinematic state:

set_linear_velocity, set_angular_velocity, set_joint_positions, set_joint_velocities, set_joint_efforts

Example:

>>> prim.set_linear_velocity(np.array([0.1, 0.0, 0.0]))

set_local_pose( translation: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set prim’s pose with respect to the local frame (the prim’s parent frame).

Warning

This method will change (teleport) the prim pose immediately to the indicated value

Parameters:

translation – Translation in the local frame of the prim (with respect to its parent prim). shape is (3, ).
orientation – Quaternion orientation in the local frame of the prim. quaternion is scalar-first (w, x, y, z). shape is (4, ).

Hint

This method belongs to the methods used to set the prim state

Example:

>>> prim.set_local_pose(translation=np.array([1.0, 0.5, 0.0]), orientation=np.array([1., 0., 0., 0.]))

set_local_scale( scale: Sequence[float] | None, ) → None#

Set prim’s scale with respect to the local frame (the prim’s parent frame).

Parameters:: scale – Scale to be applied to the prim’s dimensions. shape is (3, ).

Example:

>>> # scale prim 10 times smaller
>>> prim.set_local_scale(np.array([0.1, 0.1, 0.1]))

set_sleep_threshold(threshold: float) → None#

Set the threshold for articulations to enter a sleep state.

Search for Articulations and Sleeping in PhysX docs for more details

Parameters:: threshold – sleep threshold

Example:

>>> prim.set_sleep_threshold(0.01)

set_solver_position_iteration_count(count: int) → None#

Set the solver (position) iteration count for the articulation.

The solver iteration count determines how accurately contacts, drives, and limits are resolved. Search for Solver Iteration Count in PhysX docs for more details.

Warning

Setting a higher number of iterations may improve the fidelity of the simulation, although it may affect its performance.

Parameters:: count – position iteration count

Example:

>>> prim.set_solver_position_iteration_count(64)

set_solver_velocity_iteration_count(count: int) → None#

Set the solver (velocity) iteration count for the articulation.

The solver iteration count determines how accurately contacts, drives, and limits are resolved. Search for Solver Iteration Count in PhysX docs for more details.

Warning

Setting a higher number of iterations may improve the fidelity of the simulation, although it may affect its performance.

Parameters:: count – velocity iteration count

Example:

>>> prim.set_solver_velocity_iteration_count(64)

set_stabilization_threshold(threshold: float) → None#

Set the mass-normalized kinetic energy below which the articulation may participate in stabilization.

Search for Stabilization Threshold in PhysX docs for more details

Parameters:: threshold – stabilization threshold

Example:

>>> prim.set_stabilization_threshold(0.005)

set_visibility(visible: bool) → None#

Set the visibility of the prim in stage.

Parameters:: visible – Flag to set the visibility of the usd prim in stage.

Example:

>>> # make prim not visible in the stage
>>> prim.set_visibility(visible=False)

set_world_pose( position: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set prim’s pose with respect to the world’s frame.

Warning

This method will change (teleport) the prim pose immediately to the indicated value

Parameters:

position – Position in the world frame of the prim. shape is (3, ).
orientation – Quaternion orientation in the world frame of the prim. quaternion is scalar-first (w, x, y, z). shape is (4, ).

Hint

This method belongs to the methods used to set the prim state

Example:

>>> prim.set_world_pose(position=np.array([1.0, 0.5, 0.0]), orientation=np.array([1., 0., 0., 0.]))

set_world_velocity(velocity: ndarray) → None#

Set the articulation root velocity.

Parameters:: velocity – linear and angular velocity to set the root prim to. Shape (6,).

update_dof_name(dof_name: str) → None#

Update the degree of freedom name for effort measurement.

Changes which joint the sensor monitors for effort data. Requires at least 3 physics steps to have passed for proper initialization.

Parameters:: dof_name – Name of the joint degree of freedom to monitor.

property dof_names: list[str]#

Prim names for each DOF.

Returns:: Prim names.

Example:

>>> prim.dof_names
['panda_joint1', 'panda_joint2', 'panda_joint3', 'panda_joint4', 'panda_joint5',
 'panda_joint6', 'panda_joint7', 'panda_finger_joint1', 'panda_finger_joint2']

property dof_properties: ndarray#

Articulation DOF properties.

DOF properties#
Index	Property name	Description
0	`type`	DOF type: invalid/unknown/uninitialized (0), rotation (1), translation (2)
1	`hasLimits`	Whether the DOF has limits
2	`lower`	Lower DOF limit (in radians or meters)
3	`upper`	Upper DOF limit (in radians or meters)
4	`driveMode`	Drive mode for the DOF: force (1), acceleration (2)
5	`maxVelocity`	Maximum DOF velocity. In radians/s, or stage_units/s
6	`maxEffort`	Maximum DOF effort. In N or N*stage_units
7	`stiffness`	DOF stiffness
8	`damping`	DOF damping

Returns:: Named NumPy array of shape (num_dof, 9).

Example:

>>> # get properties for all DOFs
>>> prim.dof_properties
[(1,  True, -2.8973,  2.8973, 1, 1.0000000e+01, 5220., 60000., 3000.)
 (1,  True, -1.7628,  1.7628, 1, 1.0000000e+01, 5220., 60000., 3000.)
 (1,  True, -2.8973,  2.8973, 1, 5.9390470e+36, 5220., 60000., 3000.)
 (1,  True, -3.0718, -0.0698, 1, 5.9390470e+36, 5220., 60000., 3000.)
 (1,  True, -2.8973,  2.8973, 1, 5.9390470e+36,  720., 25000., 3000.)
 (1,  True, -0.0175,  3.7525, 1, 5.9390470e+36,  720., 15000., 3000.)
 (1,  True, -2.8973,  2.8973, 1, 1.0000000e+01,  720.,  5000., 3000.)
 (2,  True,  0.    ,  0.04  , 1, 3.4028235e+38,  720.,  6000., 1000.)
 (2,  True,  0.    ,  0.04  , 1, 3.4028235e+38,  720.,  6000., 1000.)]
>>>
>>> # property names
>>> prim.dof_properties.dtype.names
('type', 'hasLimits', 'lower', 'upper', 'driveMode', 'maxVelocity', 'maxEffort', 'stiffness', 'damping')
>>>
>>> # get DOF upper limits
>>> prim.dof_properties["upper"]
[ 2.8973  1.7628  2.8973 -0.0698  2.8973  3.7525  2.8973  0.04    0.04  ]
>>>
>>> # get the last DOF (panda_finger_joint2) upper limit
>>> prim.dof_properties["upper"][8]  # or prim.dof_properties[8][3]
0.04

property handles_initialized: bool#

Whether the articulation handler is initialized.

Returns:: Whether the handler was initialized.

Example:

>>> prim.handles_initialized
True

property name: str | None#

Name given to the prim when instantiating it.

Returns:: Name given to the prim when instantiating it. Otherwise None.

property non_root_articulation_link: bool#

Used to query if the prim is a non root articulation link.

Returns:: True if the prim itself is a non root link

Example:

>>> # for a wrapped articulation (where the root prim has the Physics Articulation Root property applied)
>>> prim.non_root_articulation_link
False

property num_bodies: int#

Number of articulation links.

Returns:: Number of links.

Example:

>>> prim.num_bodies
9

property num_dof: int#

Number of degrees of freedom of the articulation.

Returns:: Amount of DOFs.

Example:

>>> prim.num_dof
9

property prim: pxr.Usd.Prim#

USD Prim object that this object holds.

Returns:: USD Prim object that this object holds.

property prim_path: str#

Prim path in the stage.

Returns:: Prim path in the stage.

Bases: BaseSensor

A physics-based IMU (Inertial Measurement Unit) sensor that measures linear acceleration, angular velocity, and orientation.

This sensor provides inertial measurements from a simulated IMU attached to a physics body. It measures three-axis linear acceleration, three-axis angular velocity, and orientation as a quaternion. The sensor supports configurable sampling rates and filtering for each measurement type.

The sensor can be created at an existing prim path or will automatically create a new IMU prim if the path doesn’t exist. When creating a new prim, it uses physics simulation settings to determine default timing parameters.

Parameters:

prim_path – USD path where the IMU sensor prim is located or will be created.
name – Identifier name for the sensor instance.
frequency – Sampling frequency in Hz for sensor readings. Cannot be specified together with dt.
dt – Time interval in seconds between sensor readings. Cannot be specified together with frequency.
translation – Local translation offset of the sensor relative to its parent body.
position – Local position offset of the sensor relative to its parent body.
orientation – Local orientation offset of the sensor as a quaternion relative to its parent body.
linear_acceleration_filter_size – Number of samples for moving average filter applied to linear acceleration measurements.
angular_velocity_filter_size – Number of samples for moving average filter applied to angular velocity measurements.
orientation_filter_size – Number of samples for moving average filter applied to orientation measurements.

Raises:

Exception – If both frequency and dt are specified simultaneously.
Exception – If IMU sensor prim creation fails at the specified path.

apply_visual_material( visual_material: VisualMaterial, weaker_than_descendants: bool = False, ) → None#

Apply visual material to the held prim and optionally its descendants.

Parameters:

visual_material – Visual material to be applied to the held prim. Currently supports PreviewSurface, OmniPBR and OmniGlass.
weaker_than_descendants – True if the material shouldn’t override the descendants materials, otherwise False.

Example:

>>> from isaacsim.core.api.materials import OmniGlass
>>>
>>> # create a dark-red glass visual material
>>> material = OmniGlass(
...     prim_path="/World/material/glass",  # path to the material prim to create
...     ior=1.25,
...     depth=0.001,
...     thin_walled=False,
...     color=np.array([0.5, 0.0, 0.0])
... )
>>> prim.apply_visual_material(material)

get_applied_visual_material() → VisualMaterial#

Return the current applied visual material in case it was applied using apply_visual_material.

or it’s one of the following materials that was already applied before: PreviewSurface, OmniPBR and OmniGlass.

Returns:: The current applied visual material if its type is currently supported.

Example:

>>> # given a visual material applied
>>> prim.get_applied_visual_material()
<isaacsim.core.api.materials.omni_glass.OmniGlass object at 0x7f36263106a0>

get_current_frame(read_gravity: bool = True) → dict#

Get the current sensor reading frame containing IMU data.

Parameters:

read_gravity – Whether to include gravity in the linear acceleration reading.

Returns:

‘lin_acc’: Linear acceleration as a 3D tensor
’ang_vel’: Angular velocity as a 3D tensor
’orientation’: Orientation quaternion in scalar-first (w, x, y, z) order as a 4D tensor
’time’: Sensor reading timestamp
’physics_step’: Current physics simulation step
’is_valid’: Whether the current sensor reading is valid

Return type:

Dictionary containing sensor data with keys

get_default_state() → XFormPrimState#

Get the default prim states (spatial position and orientation).

Returns:: An object that contains the default state of the prim (position and orientation)

Example:

>>> state = prim.get_default_state()
>>> state
<isaacsim.core.utils.types.XFormPrimState object at 0x7f33addda650>
>>>
>>> state.position
[-4.5299529e-08 -1.8347054e-09 -2.8610229e-08]
>>> state.orientation
[1. 0. 0. 0.]

get_dt() → float#

Get the current IMU sensor sampling period.

Returns:: The sampling period in seconds.

get_frequency() → int#

Get the current IMU sensor sampling frequency.

Returns:: The sampling frequency in Hz.

get_local_pose() → tuple[ndarray, ndarray]#

Get prim’s pose with respect to the local frame (the prim’s parent frame).

Returns:: First index is the position in the local frame (with shape (3, )). Second index is quaternion orientation (with shape (4, )) in the local frame

Example:

>>> # if the prim is in position (1.0, 0.5, 0.0) with respect to the world frame
>>> position, orientation = prim.get_local_pose()
>>> position
[0. 0. 0.]
>>> orientation
[0. 0. 0.]

get_local_scale() → ndarray#

Get prim’s scale with respect to the local frame (the parent’s frame).

Returns:: Scale applied to the prim’s dimensions in the local frame. shape is (3, ).

Example:

>>> prim.get_local_scale()
[1. 1. 1.]

get_visibility() → bool#

Get the visibility of the prim in stage.

Returns:: True if the prim is visible in stage. False otherwise.

Example:

>>> # get the visible state of an visible prim on the stage
>>> prim.get_visibility()
True

get_world_pose() → tuple[ndarray, ndarray]#

Get prim’s pose with respect to the world’s frame.

Returns:: First index is the position in the world frame (with shape (3, )). Second index is quaternion orientation (with shape (4, )) in the world frame

Example:

>>> # if the prim is in position (1.0, 0.5, 0.0) with respect to the world frame
>>> position, orientation = prim.get_world_pose()
>>> position
[1.  0.5 0. ]
>>> orientation
[1. 0. 0. 0.]

get_world_scale() → ndarray#

Get prim’s scale with respect to the world’s frame.

Returns:: Scale applied to the prim’s dimensions in the world frame. shape is (3, ).

Example:

>>> prim.get_world_scale()
[1. 1. 1.]

initialize(physics_sim_view: object = None) → None#

Initialize the IMU sensor.

Parameters:: physics_sim_view – The physics simulation view to use for initialization.

is_paused() → bool#

Check if the IMU sensor is currently paused.

Returns:: True if the sensor is paused, False if enabled.

is_valid() → bool#

Check if the prim path has a valid USD Prim at it.

Returns:: True is the current prim path corresponds to a valid prim in stage. False otherwise.

Example:

>>> # given an existing and valid prim
>>> prims.is_valid()
True

is_visual_material_applied() → bool#

Check if there is a visual material applied.

Returns:: True if there is a visual material applied. False otherwise.

Example:

>>> # given a visual material applied
>>> prim.is_visual_material_applied()
True

pause() → None#: Pause the IMU sensor by disabling it.

post_reset() → None#: Resets the sensor to its initial state after a simulation reset.

resume() → None#: Resume the IMU sensor by enabling it.

set_default_state( position: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set the default state of the prim (position and orientation), that will be used after each reset.

Parameters:

position – Position in the world frame of the prim. shape is (3, ). Which means left unchanged.
orientation – Quaternion orientation in the world frame of the prim. Quaternion is scalar-first (w, x, y, z). shape is (4, ). Which means left unchanged.

Example:

>>> # configure default state
>>> prim.set_default_state(position=np.array([1.0, 0.5, 0.0]), orientation=np.array([1, 0, 0, 0]))
>>>
>>> # set default states during post-reset
>>> prim.post_reset()

set_dt(value: float) → None#

Set the IMU sensor sampling period.

Parameters:: value – The sampling period in seconds.

set_frequency(value: int) → None#

Set the IMU sensor sampling frequency.

Parameters:: value – The sampling frequency in Hz.

set_local_pose( translation: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set prim’s pose with respect to the local frame (the prim’s parent frame).

Warning

This method will change (teleport) the prim pose immediately to the indicated value

Parameters:

translation – Translation in the local frame of the prim (with respect to its parent prim). shape is (3, ).
orientation – Quaternion orientation in the local frame of the prim. quaternion is scalar-first (w, x, y, z). shape is (4, ).

Hint

This method belongs to the methods used to set the prim state

Example:

>>> prim.set_local_pose(translation=np.array([1.0, 0.5, 0.0]), orientation=np.array([1., 0., 0., 0.]))

set_local_scale( scale: Sequence[float] | None, ) → None#

Set prim’s scale with respect to the local frame (the prim’s parent frame).

Parameters:: scale – Scale to be applied to the prim’s dimensions. shape is (3, ).

Example:

>>> # scale prim 10 times smaller
>>> prim.set_local_scale(np.array([0.1, 0.1, 0.1]))

set_visibility(visible: bool) → None#

Set the visibility of the prim in stage.

Parameters:: visible – Flag to set the visibility of the usd prim in stage.

Example:

>>> # make prim not visible in the stage
>>> prim.set_visibility(visible=False)

set_world_pose( position: Sequence[float] | None = None, orientation: Sequence[float] | None = None, ) → None#

Set prim’s pose with respect to the world’s frame.

Warning

This method will change (teleport) the prim pose immediately to the indicated value

Parameters:

position – Position in the world frame of the prim. shape is (3, ).
orientation – Quaternion orientation in the world frame of the prim. quaternion is scalar-first (w, x, y, z). shape is (4, ).

Hint

This method belongs to the methods used to set the prim state

Example:

>>> prim.set_world_pose(position=np.array([1.0, 0.5, 0.0]), orientation=np.array([1., 0., 0., 0.]))

property name: str | None#

Name given to the prim when instantiating it.

Returns:: Name given to the prim when instantiating it. Otherwise None.

property non_root_articulation_link: bool#

Used to query if the prim is a non root articulation link.

Returns:: True if the prim itself is a non root link

Example:

>>> # for a wrapped articulation (where the root prim has the Physics Articulation Root property applied)
>>> prim.non_root_articulation_link
False

property prim: pxr.Usd.Prim#

USD Prim object that this object holds.

Returns:: USD Prim object that this object holds.

property prim_path: str#

Prim path in the stage.

Returns:: Prim path in the stage.

Python API

[isaacsim.sensors.physics] Isaac Sim Physics Sensor Simulation#

Overview#

Key Components#

ContactSensor#

IMUSensor#

EffortSensor#

Functionality#

Sensor Creation Commands#

Data Structures#

Integration#

Enable Extension#

Python API#

Commands#

Sensors#

`ContactSensor`#

`IMUSensor`#

`EffortSensor`#