Python Gym API

class isaacgym.gymapi.Gym

acquire_actor_root_state_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves buffer for Actor root states. The buffer has shape (num_actors, 13). State for each actor root contains position([0:3]), rotation([3:7]), linear velocity([7:10]), and angular velocity([10:13]).

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for actor root states
Return type:: isaacgym.gymapi.Tensor

acquire_dof_force_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves buffer for DOF forces. One force value per each DOF in simulation.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for DOF forces
Return type:: isaacgym.gymapi.Tensor

acquire_dof_state_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves Degree-of-Freedom state buffer. Buffer has shape (num_dofs, 2). Each DOF state contains position and velocity.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for DOF states
Return type:: isaacgym.gymapi.Tensor

acquire_force_sensor_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves buffer for force sensors. The buffer has shape (num_force_sensors, 6). Each force sensor state has forces (3) and torques (3) data.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for force sensors
Return type:: isaacgym.gymapi.Tensor

acquire_jacobian_tensor(self: Gym, arg0: Sim, arg1: str) → Tensor

Retrieves buffer information for Jacobian

Parameters:

param1 (Sim) – Simulation Handle
param2 (str) – Name of Actor

Returns:

GymTensor object containing buffer for Jacobian

Return type:

isaacgym.gymapi.Tensor

acquire_mass_matrix_tensor(self: Gym, arg0: Sim, arg1: str) → Tensor

Retrieves buffer for Mass matrix

Parameters:

param1 (Sim) – Simulation Handle
param2 (str) – Name of Actor

Returns:

GymTensor object containing buffer for Mass Matrix

Return type:

isaacgym.gymapi.Tensor

acquire_net_contact_force_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves buffer for net contract forces. The buffer has shape (num_rigid_bodies, 3). Each contact force state contains one value for each X, Y, Z axis.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for net contact forces
Return type:: isaacgym.gymapi.Tensor

acquire_particle_state_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves buffer for particle states. Flex backend only.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for particle states
Return type:: isaacgym.gymapi.Tensor

acquire_pneumatic_pressure_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves buffer for penumatic pressure states. Flex backend only.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for pneumatic pressure
Return type:: isaacgym.gymapi.Tensor

acquire_pneumatic_target_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves buffer for pneumatic targets. Flex backend only.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for pneumatic targets
Return type:: isaacgym.gymapi.Tensor

acquire_rigid_body_state_tensor(self: Gym, arg0: Sim) → Tensor

Retrieves buffer for Rigid body states. The buffer has shape (num_rigid_bodies, 13). State for each rigid body contains position([0:3]), rotation([3:7]), linear velocity([7:10]), and angular velocity([10:13]).

Parameters:: param1 (Sim) – Simulation Handle
Returns:: GymTensor object containing buffer for rigid body states
Return type:: isaacgym.gymapi.Tensor

add_ground(self: Gym, sim: Sim, params: PlaneParams) → None

Adds ground plane to simulation.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (isaacgym.gymapi.PlaneParams) – Structure of parameters for ground plane

add_heightfield(self: Gym, arg0: Sim, arg1: numpy.ndarray[int16], arg2: HeightFieldParams) → None

Adds ground heightfield to simulation.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (heightSamples) – Height samples as Int16 array. Column-major order.
param3 (carbongym.gymapi.GymHeightFieldParams) – Structure of parameters for heightfield

add_lines(*args, **kwargs)

Overloaded function.

add_lines(self: Gym, arg0: Viewer, arg1: Env, arg2: int, arg3: numpy.ndarray[float32], arg4: numpy.ndarray[float32]) -> None
Adds lines to the viewer. Adds lines that start and end on the specified vertices, with the colors defined.
Each line is defined by a tuple of 6 floats in the vertices array, organized as {p1.x, p1.y, p1.z, p2.x, p2.y, p2.z}, defined in the environment frame.

Each color is a tuple of 3 floats ranging from [0,1] representing the {r, g, b} spectrum.
Args:
param1 (Viewer): Viewer Handle. param2 (Env): Environment Handle. param3 (int): number of lines to draw param4 (array of float): vertices of the lines. Must be of size at least 6*numLines param5 (array of float): colors to be applied to the lines. Must be of size at least 3*numLines
add_lines(self: Gym, arg0: Viewer, arg1: Env, arg2: int, arg3: numpy.ndarray[Vec3], arg4: numpy.ndarray[Vec3]) -> None
Adds lines to the viewer. Adds lines that start and end on the specified vertices, with the colors defined.
Each line is defined by a tuple of 6 floats in the vertices array, organized as {p1.x, p1.y, p1.z, p2.x, p2.y, p2.z}, defined in the environment frame.

Each color is a tuple of 3 floats ranging from [0,1] representing the {r, g, b} spectrum.
Args:
param1 (Viewer): Viewer Handle. param2 (Env): Environment Handle. param3 (int): number of lines to draw param4 (array of isaacgym.gymapi.Vec3): vertices of the lines. Must be of size at least 2*numLines param5 (array of isaacgym.gymapi.Vec3): colors to be applied to the lines. Must be of size at least numLines

add_triangle_mesh(self: Gym, arg0: Sim, arg1: numpy.ndarray[float32], arg2: numpy.ndarray[uint32], arg3: TriangleMeshParams) → None

Adds ground heightfield to simulation.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (heightSamples) – Height samples as Int16 array. Column-major order.
param3 (carbongym.gymapi.GymHeightFieldParams) – Structure of parameters for heightfield

apply_actor_dof_efforts(self: Gym, arg0: Env, arg1: int, arg2: numpy.ndarray[float32]) → bool

Applies efforts passed as an ordered array to the Degrees of Freedom of an actor.

If the Degree of Freedom is linear, the effort is a force in Newton.
If the Degree of Freedom is revolute, the effort is a torque in Nm.

See isaacgym.gymapi.Gym.set_dof_actuation_force_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of float) : array containing the efforts for all degrees of freedom of the actor.

Returns:

true if viewer has closed, false otherwise

Return type:

bool

apply_body_force_at_pos(self: Gym, env: Env, rigidHandle: int, force: Vec3, pos: Vec3 = None, space: CoordinateSpace = CoordinateSpace.ENV_SPACE) → None

Applies a force at the given position of the selected body for the immediate timestep, in Newtons. If the force is not at the center-of-mass of the body, a torque will be applied in Nm.

Parameters:

env (Env) – Environment
rigidHandle (Body) – Rigid body handle
force (isaacgym.gymapi.Vec3) – force
pos (isaacgym.gymapi.Vec3) – pos, can be None
space (isaacgym.gymapi.CoordinateSpace) – coordinate space of force and position vectors

apply_body_forces(self: Gym, env: Env, rigidHandle: int, force: Vec3 = None, torque: Vec3 = None, space: CoordinateSpace = CoordinateSpace.ENV_SPACE) → None

Applies a force and/or torque to the selected body for the immediate timestep, in Newtons and Nm respectively. The force is applied at the center of mass of the body.

Parameters:

env (Env) – Environment
rigidHandle (Body) – Rigid body handle
force (isaacgym.gymapi.Vec3) – force, can be None
torque (isaacgym.gymapi.Vec3) – torque, can be None
space (isaacgym.gymapi.CoordinateSpace) – coordinate space of the force and torque vectors

apply_dof_effort(self: Gym, arg0: Env, arg1: int, arg2: float) → None

Applies effort on a DOF. If the DOF is prismatic, the effort will be a force in Newtons. If the DOF is revolute, the effort will be a Torque, in Nm.

See isaacgym.gymapi.Gym.set_dof_actuation_force_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (DOF) – DOF Handle
param3 (float) – effort

apply_rigid_body_force_at_pos_tensors(self: Gym, sim: Sim, forceTensor: Tensor, posTensor: Tensor = None, space: CoordinateSpace = CoordinateSpace.ENV_SPACE) → bool

Applies rigid body forces at given positions for the immediate timestep, in Newtons.

Parameters:

sim (Sim) – Simulation Handle
forceTensor (isaacgym.gymapi.Tensor) – Buffer containing forces
posTensor (isaacgym.gymapi.Tensor) – Buffer containing positions, can be None (if None, forces will be applied at CoM)
space (isaacgym.gymapi.CoordinateSpace) – Coordinate space of force and torque vectors

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

apply_rigid_body_force_tensors(self: Gym, sim: Sim, forceTensor: Tensor = None, torqueTensor: Tensor = None, space: CoordinateSpace = CoordinateSpace.ENV_SPACE) → bool

Applies forces and/or torques to rigid bodies for the immediate timestep, in Newtons.

Parameters:

sim (Sim) – Simulation Handle
forceTensor (isaacgym.gymapi.Tensor) – Buffer containing forces, can be None
torqueTensor (isaacgym.gymapi.Tensor) – Buffer containing torques, can be None
space (isaacgym.gymapi.CoordinateSpace) – Coordinate space of force and torque vectors

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

attach_camera_to_body(self: Gym, arg0: int, arg1: Env, arg2: int, arg3: Transform, arg4: CameraFollowMode) → None

Attaches Camera to a rigid body

Parameters:

param1 (Camera) – Camera Handle.
param2 (Env) – Environment Handle.
param3 (Body) – handle to the rigid body
param4 (isaacgym.gymapi.Transform) – transform from rigid body to camera position
param5 (isaacgym.gymapi.CameraFollowMode) – Follow mode. see isaacgym.gymapi.CameraFollowMode

attach_sim(self: Gym, arg0: int, arg1: int, arg2: SimType, arg3: str, arg4: str) → Sim

Attach simulation to USD scene, updates will be saved to USD stage.

Parameters:

param1 (int) – index of CUDA-enabled GPU to be used for simulation.
param2 (int) – index of GPU to be used for rendering.
param3 (isaacgym.gymapi.SimType) – Type of simulation to be used.
param4 (string) – Path to root directory of USD scene
param5 (string) – Filename of USD scene

Returns:

Simulation Handle

Return type:

Sim

begin_aggregate(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: bool) → bool

Creates new aggregate group

Parameters:

param1 (Env) – Environment Handle
param2 (int) – Maximum number of bodies
param3 (int) – Maximum number of shapes
param4 (bool) – Flag to enable or disable self collision

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

clear_lines(self: Gym, arg0: Viewer) → None

Clears all lines from the viewer

Parameters:: param1 (Viewer) – Viewer Handle.

create_actor(self: Gym, env: Env, asset: Asset, pose: Transform, name: str = None, group: int = - 1, filter: int = - 1, segmentationId: int = 0) → int

Creates an Actor from an Asset

Parameters:

param1 (Env) – Environment Handle.
param2 (Asset) – Asset Handle
param3 (isaacgym.gymapi.Transform) – transform transform of where the actor will be initially placed
param4 (str) – name of the actor
param5 (int) – collision group that actor will be part of. The actor will not collide with anything outside of the same collisionGroup
param6 (int) – bitwise filter for elements in the same collisionGroup to mask off collision
param7 (int) – segmentation ID used in segmentation camera sensors

Returns:

Handle to actor

Return type:

Handle

create_aggregate(self: Gym, arg0: Env, arg1: List[int]) → bool

Creates aggregate group for actors with CPU pipeline

Parameters:

param1 (Env) – Environment Handle
param2 (list of Actor) – Actor Handles

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

create_asset_force_sensor(self: Gym, asset: Asset, body_idx: int, local_pose: Transform, props: ForceSensorProperties = None) → int

Creates a force sensor on a body at the provided position

Args:
asset (Asset): Asset body_idx (int): Rigid body index local_pose (isaacgym.gymapi.Transform): Local pose of the sensor relative to the body props (isaacgym.gymapi.ForceSensorProperties): Force sensor properties (optional)

Returns:: Force sensor index or -1 on failure.

create_box(self: Gym, sim: Sim, width: float, height: float, depth: float, options: AssetOptions = None) → Asset

Creates a box Asset

Parameters:

param1 (Sim) – Simulation Handle.
param2 (float) – width of the box (x-axis)
param3 (float) – height of the box (y-axis)
param4 (float) – depth of the box (z-axis)
param5 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

create_camera_sensor(self: Gym, arg0: Env, arg1: CameraProperties) → int

Creates Camera Sensor on given environment. The properties of the camera sensor are given by camProps. See isaacgym.gymapi.CameraProperties.

Parameters:

param1 (Env) – Environment Handle.
param2 (isaacgym.gymapi.CameraProperties) – properties of the camera sensor

Returns:

Camera Handle

Return type:

Handle

create_capsule(self: Gym, sim: Sim, radius: float, width: float, options: AssetOptions = None) → Asset

Creates a Capsule mesh that extends along the x-axis with its local origin at the center of the capsule

Parameters:

param1 (Sim) – Simulation Handle.
param2 (float) – capsule radius
param3 (float) – width of the capsule (x-axis)
param4 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

create_cloth_grid(self: Gym, arg0: Sim, arg1: int, arg2: int, arg3: float, arg4: float) → Asset

Creates a cloth grid made of particles connected with constraints.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (int) – width of the cloth (x-axis)
param3 (int) – length of the cloth (y-axis)
param4 (float) – distance between particles width-wise (x-axis)
param5 (float) – distance between particles length-wise (y-axis)
param6 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

create_env(self: Gym, arg0: Sim, arg1: Vec3, arg2: Vec3, arg3: int) → Env

Creates one simulation Environment

Parameters:

param1 (Sim) – Simulation Handle.
param2 (isaacgym.gymapi.Vec3) – lower bounds of environment space
param3 (isaacgym.gymapi.Vec3) – upper bounds of environment space
param4 (int) – Number of environments to tile in a row

create_performance_timers(self: Gym, arg0: Sim) → int

Creates a set of performance timers that can be queried by the user

Parameters:: param1 (Sim) – Simulation Handle
Returns:: Simulation Timers Handle
Return type:: Handle

create_rigid_body_attractor(self: Gym, arg0: Env, arg1: AttractorProperties) → int

Creates an attractor for the selected environment using the properties defined.

Parameters:

param1 (Env) – Environment Handle
param2 (isaacgym.gymapi.AttractorProperties) – the new properties for the attractor.

Returns:

Attractor Handle

Return type:

Handle

create_sim(self: Gym, compute_device: int = 0, graphics_device: int = 0, type: SimType = SimType.SIM_FLEX, params: SimParams = <SimParams object at 0x7fb9865855e0>) → Sim

Allocates which device will simulate and which device will render the scene. Defines the simulation type to be used.

Parameters:

param1 (int) – index of CUDA-enabled GPU to be used for simulation.
param2 (int) – index of GPU to be used for rendering.
param3 (isaacgym.gymapi.SimType) – Type of simulation to be used.
param4 (isaacgym.gymapi.SimParams) – Simulation parameters.

Returns:

Simulation Handle

Return type:

Sim

create_sphere(self: Gym, sim: Sim, radius: float, options: AssetOptions = None) → Asset

Creates a sphere Asset

Parameters:

param1 (Sim) – Simulation Handle.
param2 (float) – sphere radius
param3 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

create_tet_grid(*args, **kwargs)

Overloaded function.

create_tet_grid(self: Gym, arg0: Sim, arg1: SoftMaterial, arg2: int, arg3: int, arg4: int, arg5: float, arg6: float, arg7: float, arg8: float, arg9: bool, arg10: bool, arg11: bool, arg12: bool) -> Asset

Creates a tetrahedral Grid

Args:
param1 (Sim): Simulation Handle. param2 (isaacgym.gymapi.SoftMaterial): soft material definitions param3 (int): dimx number of tetrahedrons on x-axis param4 (int): dimy number of tetrahedrons on y-axis param5 (int): dimz number of tetrahedrons on z-axis param6 (float): spacingx length of tetrahedrons on x-axis param7 (float): spacingy length of tetrahedrons on y-axis param8 (float): spacingz length of tetrahedrons on z-axis param9 (float): density of tetrahedrons param10 (bool): when true, fixes the base of the box where it is placed. param11 (bool): when true, fixes the top of the box where it is placed. param12 (bool): when true, fixes the left side of the box where it is placed. param13 (bool): when true, fixes the right side of the box where it is placed. param14 (isaacgym.gymapi.AssetOptions): asset Options.

Returns:
Handle: Handle to asset
create_tet_grid(self: Gym, arg0: Sim, arg1: SoftMaterial, arg2: int, arg3: int, arg4: int, arg5: float, arg6: float, arg7: float, arg8: float, arg9: bool, arg10: bool, arg11: bool, arg12: bool) -> Asset

Creates a tetrahedral Grid

Args:
param1 (Sim): Simulation Handle. param2 (isaacgym.gymapi.SoftMaterial): soft material definitions param3 (int): dimx number of tetrahedrons on x-axis param4 (int): dimy number of tetrahedrons on y-axis param5 (int): dimz number of tetrahedrons on z-axis param6 (float): spacingx length of tetrahedrons on x-axis param7 (float): spacingy length of tetrahedrons on y-axis param8 (float): spacingz length of tetrahedrons on z-axis param9 (float): density of tetrahedrons param10 (bool): when true, fixes the base of the box where it is placed. param11 (bool): when true, fixes the top of the box where it is placed. param12 (bool): when true, fixes the left side of the box where it is placed. param13 (bool): when true, fixes the right side of the box where it is placed. param14 (isaacgym.gymapi.AssetOptions): asset Options.

Returns:
Handle: Handle to asset

create_texture_from_buffer(self: Gym, arg0: Sim, arg1: int, arg2: int, arg3: numpy.ndarray[uint8]) → int

Loads a texture from an image buffer.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (int) – Width of the texture
param3 (int) – Height of the texture
param4 (py::array_t) – Texture Buffer

Returns:

Handle to the texture or -1 if failure

Return type:

int

create_texture_from_file(self: Gym, arg0: Sim, arg1: str) → int

Loads a texture from a file.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (str) – filename of the image file containing texture

Returns:

Handle to the texture

Return type:

Handle

create_usd_exporter(self: Gym, options: UsdExportOptions = None) → UsdExporter

Destroy USD exporter

Parameters:: param1 (isaacgym.gymapi.UsdExportOptions) – USD Exporter Options
Returns:: Handle to Exporter
Return type:: Handle

create_viewer(self: Gym, arg0: Sim, arg1: CameraProperties) → Viewer

Creates a viewer for the simulation.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (isaacgym.gymapi.CameraProperties) – Camera properties for default camera in viewer

debug_print_asset(self: Gym, asset: Asset, outpath: str = None) → None

Outputs assets properties of asset to std out or to file.

Parameters:

param1 (isaacgym.gymapi.Asset) – Asset
param2 (string) – Output file path

destroy_camera_sensor(self: Gym, arg0: Sim, arg1: Env, arg2: int) → None

Destroys all data referring to given camera sensor

Parameters:

param1 (Sim) – Simulation Handle.
param2 (Camera) – Handle to the camera

destroy_env(self: Gym, arg0: Env) → None

Deletes an environment and releases memory used from it

Parameters:: param1 (Env) – Environment Handle.

destroy_performance_timers(self: Gym, arg0: Sim, arg1: int) → None

Destroys internal timers

Parameters:

param1 (Sim) – Simulation Handle
param2 (Timers) – Simulation Timers Handle

destroy_sim(self: Gym, arg0: Sim) → None

Cleans up all remaining handles to the simulation

Parameters:: param1 (Sim) – Simulation Handle

destroy_usd_exporter(self: Gym, arg0: UsdExporter) → None

Destroy USD exporter

Parameters:: param1 (Exporter) – USD Exporter Handle

destroy_viewer(self: Gym, arg0: Viewer) → None

Closes viewer and destroys its handle

Parameters:: param1 (Viewer) – Viewer Handle.

draw_env_rigid_contacts(self: Gym, arg0: Viewer, arg1: Env, arg2: Vec3, arg3: float, arg4: bool) → None

Draw Contact Forces for all Rigid Bodies in an Env.

Parameters:

param1 (Env) – Environment Handle
param2 (isaacgym.gymapi.Vec3) – contact’s color.
param3 (float) – scale to draw contact force vectors.
param4 (float) – apply square root scale when drawing contact force vectors

draw_env_soft_contacts(self: Gym, arg0: Viewer, arg1: Env, arg2: Vec3, arg3: float, arg4: bool, arg5: bool) → None

Draw Contact Forces for all soft Bodies in an Env.

Parameters:

param1 (Env) – Environment Handle
param2 (isaacgym.gymapi.Vec3) – contact’s color.
param3 (float) – scale to draw contact force vectors.
param4 (bool) – apply square root scale when drawing contact force vectors
param5 (bool) – force visualization

draw_viewer(self: Gym, viewer: Viewer, sim: Sim, render_collision: bool = True) → None

Renders the viewer

Parameters:

param1 (Viewer) – Viewer Handle.
param2 (Sim) – Simulation Handle.
param3 (bool) – renterCollisionMeshes flag to determine if should render the collision meshes instead of display meshes

enable_actor_dof_force_sensors(self: Gym, arg0: Env, arg1: int) → bool

Enables DOF force collection for the actor’s degrees of freedom.

Parameters:

( (param1) – obj: list of Env): Environment Handles
param2 (Actor) – Actor Handle

Returns:

True if DOF force collection is supported for this actor, False otherwise.

end_access_image_tensors(self: Gym, arg0: Sim) → None

Terminates access to image tensors. Releases data from all image tensors to the GPU

Parameters:: param1 (Sim) – Simulation Handle.

end_aggregate(self: Gym, arg0: Env) → bool

Ends current aggregate group

Parameters:: param1 (Env) – Environment Handle
Returns:: true if operation was succesful, false otherwise.
Return type:: bool

export_usd_asset(self: Gym, arg0: UsdExporter, arg1: Asset, arg2: str) → bool

Exports asset in USD Format

Parameters:

param1 (Exporter) – USD Exporter Handle
param2 (Asset) – Asset Handle
param3 (str) – path and file name to save the asset.

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

export_usd_sim(self: Gym, exporter: UsdExporter, sim: Sim, name: str, dirName: str = None) → object

Exports simulation in USD Format

Parameters:

param1 (isaacgym.gymapi.UsdExporter) – USD Exporter Handle
param2 (Sim) – Simulation Handle
param3 (str) – path and file name to save the asset.

Returns:

obj: map to transforms : returns none if failed

fetch_results(self: Gym, arg0: Sim, arg1: bool) → None

Populates Host buffers for the simulation from Device values

Parameters:

param1 (Sim) – Simulation Handle
param2 (bool) – flags if should wait for latest simulation step to complete.

find_actor_actuator_index(self: Gym, arg0: Env, arg1: int, arg2: str) → int

Gets the index of a named actuator of the actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (str) – Name of the actuator

Returns:

index of the actuator

Return type:

int

find_actor_dof_handle(self: Gym, arg0: Env, arg1: int, arg2: str) → int

Finds actor Degree of Freedom handle given its name

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.
param3 (str) – name of DOF

Returns:

DOF Handle

Return type:

Handle

find_actor_dof_index(self: Gym, arg0: Env, arg1: int, arg2: str, arg3: IndexDomain) → int

Find the array index of a named degree-of-freedom. Use domain eActorDomain to get an index into arrays returned by functions like isaacgym.gymapi.Gym.get_actor_dof_states or isaacgym.gymapi.Gym.get_actor_dof_properties. Currently, the other domains are not useful, because there is no API for dealing with DOFs at the env or sim level. This may change in the future.

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.
param3 (str) – Name of the DOF
param4 (isaacgym.gymapi.IndexDomain) – determines which state buffer to get the index for (env or sim).

Returns:

index of the DOF in the specified domain

Return type:

int

find_actor_fixed_tendon_joint_index(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: str) → int

Gets the name of a joint in a fixed tendon of an actor at the indexes provided

Note

The order of joints in an actor tendon may differ from the order in the asset.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of the tendon
param4 (str) – Name of the joint

Returns:

index of the joint, or -1 if not found

Return type:

int

find_actor_handle(self: Gym, arg0: Env, arg1: str) → int

Gets handle for an actor, given its name

Parameters:

param1 (Env) – Environment Handle.
param2 (str) – name of actor

Returns:

Handle to actor

Return type:

Handle

find_actor_index(self: Gym, arg0: Env, arg1: str, arg2: IndexDomain) → int

Gets index of actor in domain from actor name

Parameters:

param1 (Env) – Environment Handle
param2 (str) – Actor Name
param3 (isaacgym.gymapi.IndexDomain) – Simulation, Environment, or Actor domain

Returns:

Actor Index

Return type:

int

find_actor_joint_handle(self: Gym, arg0: Env, arg1: int, arg2: str) → int

Finds actor Joint handle given its name

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.
param3 (str) – joint name

Returns:

Joint Handle

Return type:

Handle

find_actor_joint_index(self: Gym, arg0: Env, arg1: int, arg2: str, arg3: IndexDomain) → int

Use this function to find the array index of a named joint. Currently, this function is not useful, because there is no API for dealing with joint arrays. This may change in the future.

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.
param3 (str) – name of the joint.
param4 (isaacgym.gymapi.IndexDomain) – determines which state buffer to get the index for (env or sim).

Returns:

index of the joint in the specified domain

Return type:

Handle

find_actor_rigid_body_handle(self: Gym, arg0: Env, arg1: int, arg2: str) → int

Finds actor rigid body handle given its name

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (str) – name of the rigid body.

Returns:

Rigid Body Handle

Return type:

Handle

find_actor_rigid_body_index(self: Gym, arg0: Env, arg1: int, arg2: str, arg3: IndexDomain) → int

Use this function to find the index of a rigid body in a state buffer.

Use domain DOMAIN_ENV to get an index into the state buffer returned by isaacgym.gymapi.Gym.get_env_rigid_body_states.
Use domain DOMAIN_SIM to get an index into the state buffer returned by isaacgym.gymapi.Gym.get_sim_rigid_body_states.
Use domain DOMAIN_ACTOR to get an index into the state buffer returned by isaacgym.gymapi.Gym.get_actor_rigid_body_states
Use domain DOMAIN_ACTOR to get an index into the property buffer returned by isaacgym.gymapi.Gym.get_actor_rigid_body_properties.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (str) – name of the rigid body.
param4 (isaacgym.gymapi.IndexDomain) – determines which state buffer to get the index for (env or sim).

Returns:

index of the rigid body in the specified domain

Return type:

int

find_actor_tendon_index(self: Gym, arg0: Env, arg1: int, arg2: str) → int

Gets the index of a named tendon of the actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (str) – Name of the tendon

Returns:

index of the tendon

Return type:

int

find_asset_actuator_index(self: Gym, arg0: Asset, arg1: str) → int

Gets the index of a named actuator in the asset’s actuator array

Parameters:

param1 (Asset) – Asset Handle
param2 (str) – name of the actuator

Returns:

index of the actuator

Return type:

int

find_asset_dof_index(self: Gym, arg0: Asset, arg1: str) → int

Gets the index of a named degree-of-freedom in the asset’s DOF array

Parameters:

param1 (Asset) – Asset Handle
param2 (str) – name of the DOF

Returns:

index of the DOF

Return type:

int

find_asset_joint_index(self: Gym, arg0: Asset, arg1: str) → int

Gets the index of a named joint in the asset’s joint array

Parameters:

param1 (Asset) – Asset Handle
param2 (str) – name of the joint

Returns:

index of the joint

Return type:

int

find_asset_rigid_body_index(self: Gym, arg0: Asset, arg1: str) → int

Gets the index of a named rigid body in the asset’s body array

Parameters:

param1 (Asset) – Asset Handle
param2 (str) – name of the rigid body

Returns:

index of the rigid body

Return type:

int

find_asset_tendon_index(self: Gym, arg0: Asset, arg1: str) → int

Gets the index of a named tendon in the asset’s tendon array

Parameters:

param1 (Asset) – Asset Handle
param2 (str) – name of the tendon

Returns:

index of the tendon

Return type:

int

free_texture(self: Gym, arg0: Sim, arg1: int) → None

releases texture data from memory

Parameters:

param1 (Sim) – Simulation Handle.
param2 (Texture) – Texture handle to free.

get_actor_actuator_count(self: Gym, arg0: Env, arg1: int) → int

Gets number of actuators for an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

number of actuators in actor

Return type:

int

get_actor_actuator_joint_name(self: Gym, arg0: Env, arg1: int, arg2: int) → str

Gets the name of an actuator for an actor at the index provided

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of the actuator

Returns:

name of actuator in asset

Return type:

str

get_actor_actuator_name(self: Gym, arg0: Env, arg1: int, arg2: int) → str

Gets the name of an actuator for an actor at the index provided

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of the actuator

Returns:

name of actuator in asset

Return type:

str

get_actor_actuator_properties(self: Gym, arg0: Env, arg1: int) → List[ActuatorProperties]

Gets an array of actuator properties for an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

array containing isaacgym.gymapi.ActuatorProperties structure

Return type:

array of isaacgym.gymapi.ActuatorProperties

get_actor_asset(self: Gym, arg0: Env, arg1: int) → Asset

Gets Asset for an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

Asset Handle

Return type:

Handle

get_actor_count(self: Gym, arg0: Env) → int

Gets number of actors in an environment

Parameters:: param1 (Env) – Environment Handle.
Returns:: name of actors in environment
Return type:: int

get_actor_dof_count(self: Gym, arg0: Env, arg1: int) → int

Gets number of Degree of Freedom for an actor

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.

Returns:

number of DOFs in actor

Return type:

int

get_actor_dof_dict(self: Gym, arg0: Env, arg1: int) → Dict[str, int]

maps degree of freedom names to actor-relative indices

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: dict of str : dictionary of actor degree of freedom names

get_actor_dof_forces(self: Gym, arg0: Env, arg1: int) → numpy.ndarray[float32]

Gets forces for the actor’s degrees of freedom.

If the Degree of Freedom is linear, the force is a force in Newtons.
If the Degree of Freedom is revolute, the force is a torque in Nm.

The returned values depend on the dof_force_sensor_mode specified in AssetOptions.

See isaacgym.gymapi.Gym.acquire_dof_force_tensor for new tensor version of this API.

Parameters:

( (param1) – obj: list of Env): Environment Handles
param2 (Actor) – Actor Handle

Returns:

obj: list of float : array of DOF forces

get_actor_dof_frames(self: Gym, arg0: Env, arg1: int) → numpy.ndarray[DofFrame]

Gets Frames for Degrees of Freedom of actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of isaacgym.gymapi.DofFrame : List of actor dof frames

get_actor_dof_handle(self: Gym, arg0: Env, arg1: int, arg2: int) → int

Gets number of Degree of Freedom for an actor

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.
param3 (int) – index of DOF

Returns:

DOF Handle

Return type:

Handle

get_actor_dof_index(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: IndexDomain) → int

Currently, this function is not useful, because there is no API for dealing with DOF arrays at the env or sim level. This may change in the future.

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.
param3 (int) – Index of the DOF
param4 (isaacgym.gymapi.IndexDomain) – determines which state buffer to get the index for (env or sim).

Returns:

Handle of the DOF in the specified domain

Return type:

Handle

get_actor_dof_names(self: Gym, arg0: Env, arg1: int) → List[str]

Gets names of all degrees of freedom on actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of str : list of actor degree of freedon names

get_actor_dof_position_targets(self: Gym, arg0: Env, arg1: int) → numpy.ndarray[float32]

Gets target position for the actor’s degrees of freedom. if the joint is prismatic, the target is in meters. if the joint is revolute, the target is in radians.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of float : array of position targets

get_actor_dof_properties(self: Gym, arg0: Env, arg1: int) → numpy.ndarray[carb::gym::GymDofProperties]

Gets properties for all Dofs on an actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

A structured Numpy array of DOF properties.

get_actor_dof_states(self: Gym, arg0: Env, arg1: int, arg2: int) → numpy.ndarray[DofState]

Gets state for the actor’s degrees of freedom. see isaacgym.gymapi.DofState

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – flags for the state to update, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

obj: list of isaacgym.gymapi.DofState : array of states

get_actor_dof_velocity_targets(self: Gym, arg0: Env, arg1: int) → numpy.ndarray[float32]

Gets target velocities for the actor’s degrees of freedom. if the joint is prismatic, the target is in m/s. if the joint is revolute, the target is in rad/s.

Parameters:

( (param1) – obj: list of Env): Environment Handles
param2 (Actor) – Actor Handle

Returns:

obj: list of float : array of velocity targets

get_actor_fixed_tendon_joint_coefficients(self: Gym, arg0: Env, arg1: int, arg2: int) → List[float]

Gets an array of tendon joint coefficients for the given actor and tendon index

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – index of tendon to get joint coefficients of

Returns:

array containing float coefficients

Return type:

array of float

get_actor_fixed_tendon_joint_name(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: int) → str

Gets the name of a joint in a fixed tendon of an actor at the indexes provided.

Note

The order of joints in an actor tendon may differ from the order in the asset.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of the tendon
param4 (int) – Index of the joint

Returns:

name of joint in fixed tendon of actor

Return type:

str

get_actor_force_sensor(self: Gym, arg0: Env, arg1: int, arg2: int) → ForceSensor

Gets a force sensor instance for the given actor

Parameters:

param1 (Env) – Environment
param2 (Handle) – Actor handle
param3 (int) – Force sensor index

Returns:

the force sensor instance or None on failure.

Return type:

isaacgym.gymapi.ForceSensor

get_actor_force_sensor_count(self: Gym, arg0: Env, arg1: int) → int

Gets number of force sensors in the specified actor

Parameters:

param1 (Env) – Environment
param2 (Handle) – Actor handle

Returns:

Number of sensors

Return type:

int

get_actor_handle(self: Gym, arg0: Env, arg1: int) → int

Gets handle for an actor, given its index

Parameters:

param1 (Env) – Environment Handle.
param2 (int) – actor index

Returns:

Handle to actor

Return type:

Handle

get_actor_index(self: Gym, arg0: Env, arg1: int, arg2: IndexDomain) → int

Gets index of actor in domain from actor handle

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (isaacgym.gymapi.IndexDomain) – Simulation, Environment, or Actor domain

Returns:

Actor Index

Return type:

int

get_actor_joint_count(self: Gym, arg0: Env, arg1: int) → int

Gets number of joints for an actor

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.

Returns:

number of joints in actor

Return type:

int

get_actor_joint_dict(self: Gym, arg0: Env, arg1: int) → Dict[str, int]

maps joint names to actor-relative indices

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: dict of str : dictionary of actor joint names

get_actor_joint_handle(self: Gym, arg0: Env, arg1: int, arg2: int) → int

Gets actor joint handle given its index

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.
param3 (int) – index of joint

Returns:

Joint Handle

Return type:

Handle

get_actor_joint_index(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: IndexDomain) → int

Get the array index of a named joint Currently, this function is not useful, because there is no API for dealing with joint arrays. This may change in the future.

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle.
param3 (int) – index of joint
param4 (isaacgym.gymapi.IndexDomain) – determines which state buffer to get the index for (env or sim).

Returns:

index of the joint in the specified domain

Return type:

Handle

get_actor_joint_names(self: Gym, arg0: Env, arg1: int) → List[str]

Gets names of all joints on actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of str : list of actor joint names

get_actor_joint_transforms(self: Gym, arg0: Env, arg1: int) → numpy.ndarray[Transform]

Gets Transforms for Joints on actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of isaacgym.gymapi.Transform : List of actor joint transforms

get_actor_name(self: Gym, arg0: Env, arg1: int) → str

Gets name of actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

Actor Name

Return type:

str

get_actor_rigid_body_count(self: Gym, arg0: Env, arg1: int) → int

Gets number of rigid bodies for an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

number of rigid bodies in actor

Return type:

int

get_actor_rigid_body_dict(self: Gym, arg0: Env, arg1: int) → Dict[str, int]

maps rigid body names to actor-relative indices

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: dict of str : dictionary of actor rigid body names

get_actor_rigid_body_handle(self: Gym, arg0: Env, arg1: int, arg2: int) → int

Gets actor rigid body handle given its index

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Rigid Body Index

Returns:

Rigid Body Handle

Return type:

Handle

get_actor_rigid_body_index(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: IndexDomain) → int

Use this function to get the index of a rigid body in a state buffer.

Use domain DOMAIN_ENV to get an index into the state buffer returned by isaacgym.gymapi.Gym.get_env_rigid_body_states.
Use domain DOMAIN_SIM to get an index into the state buffer returned by isaacgym.gymapi.Gym.get_sim_rigid_body_states.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – index of the rigid body in the actor rigid body array.
param4 (isaacgym.gymapi.IndexDomain) – determines which state buffer to get the index for (env or sim).

Returns:

index of the rigid body in the specified domain

Return type:

int

get_actor_rigid_body_names(self: Gym, arg0: Env, arg1: int) → List[str]

Gets names of all rigid bodies on actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of str : list of actor rigid body names

get_actor_rigid_body_properties(self: Gym, arg0: Env, arg1: int) → List[RigidBodyProperties]

Gets properties for rigid bodies in an actor on selected environment.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of isaacgym.gymapi.RigidBodyProperties : list of rigid body properties

get_actor_rigid_body_shape_indices(self: Gym, arg0: Env, arg1: int) → List[IndexRange]

Maps actor body shapes to index ranges in shape array

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of isaacgym.gymapi.IndexRange : indices

get_actor_rigid_body_states(self: Gym, arg0: Env, arg1: int, arg2: int) → numpy.ndarray[RigidBodyState]

Gets state for the actors’s Rigid Bodies. see isaacgym.gymapi.RigidBodyState.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Actor) – Actor Handle
param2 (int) – flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

obj: list of isaacgym.gymapi.RigidBodyState : List of rigid body states

get_actor_rigid_shape_count(self: Gym, arg0: Env, arg1: int) → int

Gets count of actor shapes

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

number of shapes in actor

Return type:

int

get_actor_rigid_shape_properties(self: Gym, arg0: Env, arg1: int) → List[RigidShapeProperties]

Gets properties for rigid shapes in an actor on selected environment.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of isaacgym.gymapi.RigidShapeProperties : list of rigid shape properties

get_actor_root_rigid_body_handle(self: Gym, arg0: Env, arg1: int) → int

Get the handle of the root rigid body of an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

Root Rigid Body Handle

Return type:

Handle

get_actor_scale(self: Gym, arg0: Env, arg1: int) → float

Gets the scale of the actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

The current scale factor of the actor.

get_actor_soft_body_count(self: Gym, arg0: Env, arg1: int) → int

Gets number of soft bodies for an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

number of soft bodies in actor

Return type:

int

get_actor_soft_materials(self: Gym, arg0: Env, arg1: int) → List[SoftMaterial]

Gets properties for all soft materials on an actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

obj: list of isaacgym.gymapi.SoftMaterials: Array of soft materials

get_actor_tendon_count(self: Gym, arg0: Env, arg1: int) → int

Gets number of tendons for an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

number of tendons in actor

Return type:

int

get_actor_tendon_name(self: Gym, arg0: Env, arg1: int, arg2: int) → str

Gets the name of a tendon for an actor at the index provided

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of the tendon

Returns:

name of tendon in asset

Return type:

str

get_actor_tendon_offset(self: Gym, arg0: Env, arg1: int, arg2: int) → float

Gets the length offset of a tendon of an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of the tendon

Returns:

Tendon offset or FLOAT_MAX if invalid handles/indices provided

Return type:

float

get_actor_tendon_properties(self: Gym, arg0: Env, arg1: int) → List[TendonProperties]

Gets an array of tendon properties for an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

array containing isaacgym.gymapi.TendonProperties structure

Return type:

array of isaacgym.gymapi.TendonProperties

get_actor_tetrahedra_range(self: Gym, arg0: Env, arg1: int, arg2: int) → IndexRange

Gets the tetrahedra range for a given actor and soft body link

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of soft body in this actor

Returns:

Range (start, count)

get_actor_triangle_range(self: Gym, arg0: Env, arg1: int, arg2: int) → IndexRange

Gets the triangle range for a given actor and soft body link

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of soft body in this actor

Returns:

Range (start, count)

get_asset_actuator_count(self: Gym, arg0: Asset) → int

Gets the count of actuators on a given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: number of actuators in asset
Return type:: int

get_asset_actuator_joint_name(self: Gym, arg0: Asset, arg1: int) → str

Gets the name of an actuator of the given asset at the index provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – Index of the actuator

Returns:

name of actuator in asset

Return type:

str

get_asset_actuator_name(self: Gym, arg0: Asset, arg1: int) → str

Gets the name of an actuator of the given asset at the index provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – Index of the actuator

Returns:

name of actuator in asset

Return type:

str

get_asset_actuator_properties(self: Gym, arg0: Asset) → List[ActuatorProperties]

Gets an array of actuator properties for the given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: array containing isaacgym.gymapi.ActuatorProperties structure
Return type:: array of isaacgym.gymapi.ActuatorProperties

get_asset_dof_count(self: Gym, arg0: Asset) → int

Gets the count of Degrees of Freedom on a given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: number of degrees of freedom in asset
Return type:: int

get_asset_dof_dict(self: Gym, arg0: Asset) → Dict[str, int]

Maps dof names to asset-relative indices

Parameters:: param1 (Asset) – Asset Handle
Returns:: dictionary containing mapping between dof names and asset relative indices
Return type:: dict of str

get_asset_dof_name(self: Gym, arg0: Asset, arg1: int) → str

Gets the name of the degree of freedom on the given asset at the index provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – index of the DOF

Returns:

name of DOF in asset

Return type:

str

get_asset_dof_names(self: Gym, arg0: Asset) → List[str]

Get list of asset DOF names

Parameters:: param1 (Asset) – Asset Handle
Returns:: list of degree of freedom names in asset
Return type:: list of str

get_asset_dof_properties(self: Gym, arg0: Asset) → numpy.ndarray[carb::gym::GymDofProperties]

Gets an array of DOF properties for the given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: A structured Numpy array of DOF properties.

get_asset_dof_type(self: Gym, arg0: Asset, arg1: int) → DofType

Gets the Degree of Freedom type on the given asset at the index provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – index of the joint

Returns:

type of degree of freedom

Return type:

isaacgym.gymapi.DofType

get_asset_fixed_tendon_joint_coefficients(self: Gym, arg0: Asset, arg1: int) → List[float]

Gets an array of tendon joint coefficients for the given asset and tendon index

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – index of tendon to get joint coefficients of

Returns:

array containing float coefficients

Return type:

array of float

get_asset_fixed_tendon_joint_name(self: Gym, arg0: Asset, arg1: int, arg2: int) → str

Gets the name of a joint in a fixed tendon of the given asset at the indexes provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – Index of the tendon
param3 (int) – Index of the joint

Returns:

name of joint in fixed tendon in asset

Return type:

str

get_asset_joint_count(self: Gym, arg0: Asset) → int

Gets the count of joints on the given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: number of joints in asset
Return type:: int

get_asset_joint_dict(self: Gym, arg0: Asset) → Dict[str, int]

Maps joint names to asset-relative indices

Parameters:: param1 (Asset) – Asset Handle
Returns:: dictionary containing mapping between joint names and asset relative indices
Return type:: dict of str

get_asset_joint_name(self: Gym, arg0: Asset, arg1: int) → str

Gets the name of the joint on the given asset at the index provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – index of the joint

Returns:

name of joint in asset

Return type:

str

get_asset_joint_names(self: Gym, arg0: Asset) → List[str]

Get list of asset joint names

Parameters:: param1 (Asset) – Asset Handle
Returns:: list of joint names in asset
Return type:: list of str

get_asset_joint_type(self: Gym, arg0: Asset, arg1: int) → JointType

Gets the joint type on the given asset at the index provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – index of the joint

Returns:

type of joint

Return type:

isaacgym.gymapi.JointType

get_asset_rigid_body_count(self: Gym, arg0: Asset) → int

Gets the count of rigid bodies on the given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: number of rigid bodies in asset
Return type:: int

get_asset_rigid_body_dict(self: Gym, arg0: Asset) → Dict[str, int]

Maps rigid body names to asset-relative indices

Parameters:: param1 (Asset) – Asset Handle
Returns:: dictionary containing mapping between body names and asset relative indices
Return type:: dict of str

get_asset_rigid_body_name(self: Gym, arg0: Asset, arg1: int) → str

Gets the name of the rigid body on the given asset at the index provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – index of the rigid body

Returns:

name of rigid body

Return type:

str

get_asset_rigid_body_names(self: Gym, arg0: Asset) → List[str]

Gets names of rigid bodies in asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: list rigid body names.

get_asset_rigid_body_shape_indices(self: Gym, arg0: Asset) → List[IndexRange]

Maps asset body index to index ranges in shape array, i.e. the range at index i will map to the indices of all of body i’s shapes

Parameters:: param1 (Asset) – Asset Handle
Returns:: obj: list of isaacgym.gymapi.IndexRange : indices

get_asset_rigid_shape_count(self: Gym, arg0: Asset) → int

Gets number of rigid shapes in asset

Parameters:: param1 (Asset) – Asset
Returns:: number of rigid shapes
Return type:: int

get_asset_rigid_shape_properties(self: Gym, arg0: Asset) → List[RigidShapeProperties]

Gets properties for rigid shapes in an asset.

Parameters:: param1 (Asset) – Asset Handle
Returns:: obj: list of isaacgym.gymapi.RigidShapeProperties : list of rigid shape properties

get_asset_soft_body_count(self: Gym, arg0: Asset) → int

Gets the count of soft bodies on the given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: number of soft bodies in asset
Return type:: int

get_asset_soft_materials(self: Gym, arg0: Asset) → List[SoftMaterial]

Gets an array of soft materials for the given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: list of isaacgym.gymapi.SoftMaterial objects.

get_asset_tendon_count(self: Gym, arg0: Asset) → int

Gets the count of tendons on a given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: number of tendons in asset
Return type:: int

get_asset_tendon_name(self: Gym, arg0: Asset, arg1: int) → str

Gets the name of a tendon of the given asset at the index provided

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – Index of the tendon

Returns:

name of tendon in asset

Return type:

str

get_asset_tendon_properties(self: Gym, arg0: Asset) → List[TendonProperties]

Gets an array of tendon properties for the given asset

Parameters:: param1 (Asset) – Asset Handle
Returns:: array containing isaacgym.gymapi.TendonProperties structure
Return type:: array of isaacgym.gymapi.TendonProperties

get_attractor_properties(self: Gym, arg0: Env, arg1: int) → AttractorProperties

Get properties of the selected attractor.

Parameters:

param1 (Env) – Environment Handle
param2 (Attractor) – Attractor Handle

Returns:

properties of selected attractor.

Return type:

isaacgym.gymapi.AttractorProperties

get_camera_image(self: Gym, arg0: Sim, arg1: Env, arg2: int, arg3: ImageType) → object

Gets image from selected camera

Parameters:

param1 (Sim) – Simulation Handle.
param2 (Camera) – Camera handle.
param3 (isaacgym.gymapi.ImageType) – type of image to obtain from camera. see isaacgym.gymapi.ImageType

Returns:

Array containing image data from selected camera

Return type:

image

get_camera_image_gpu_tensor(self: Gym, arg0: Sim, arg1: Env, arg2: int, arg3: ImageType) → object

Retrieves camera image buffer on GPU

Parameters:

param1 (Sim) – Simulation Handle.
param2 (Env) – Environment Handle.
param3 (Camera) – Camera handle.
param4 (isaacgym.gymapi.ImageType) – type of image to obtain from camera. see isaacgym.gymapi.ImageType

Returns:

GymTensor object containing image buffer

Return type:

isaacgym.gymapi.Tensor

get_camera_proj_matrix(self: Gym, arg0: Sim, arg1: Env, arg2: int) → numpy.ndarray[float32]

Gets Camera Projection Matrix

Parameters:

param1 (Sim) – Simulation Handle.
param2 (Camera) – Camera Handle.

Returns:

Camera projection matrix

Return type:

isaacgym.gymapi.Mat44

get_camera_transform(self: Gym, arg0: Sim, arg1: Env, arg2: int) → Transform

Gets Camera Transform

Parameters:

param1 (Sim) – Simulation Handle.
param2 (Env) – refEnv environment of reference to determine the origin
param3 (Camera) – Camera Handle.

Returns:

Camera Transform

Return type:

isaacgym.gymapi.Transform

get_camera_view_matrix(self: Gym, arg0: Sim, arg1: Env, arg2: int) → numpy.ndarray[float32]

Gets Camera View Matrix

Parameters:

param1 (Sim) – Simulation Handle.
param2 (Camera) – Camera Handle.

Returns:

Camera view matrix

Return type:

isaacgym.gymapi.Mat44

get_dof_frame(self: Gym, arg0: Env, arg1: int) → DofFrame

Gets Degree of Freedom Frame

Parameters:

param1 (Env) – Environment Handle
param2 (DOF) – Handle to degree of freedom.

Returns:

Frame for DOF

Return type:

isaacgym.gymapi.DofFrame

get_dof_position(self: Gym, arg0: Env, arg1: int) → float

Gets position for a degree of freedom.

See isaacgym.gymapi.Gym.acquire_dof_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (DOF) – Handle to degree of freedom.

Returns:

position for DOF

Return type:

float

get_dof_target_position(self: Gym, arg0: Env, arg1: int) → float

Gets target position for the DOF. if the DOF is prismatic, the target is in meters. if the DOF is revolute, the target is in radians.

See isaacgym.gymapi.Gym.set_dof_position_target_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (DOF) – DOF Handle

Returns:

target position

Return type:

float

get_dof_target_velocity(self: Gym, arg0: Env, arg1: int) → float

Gets target velocity for the DOF. if the DOF is prismatic, the target is in m/s. if the DOF is revolute, the target is in rad/s.

Parameters:

param1 (Env) – Environment Handle
param2 (DOF) – DOF Handle

Returns:

target velocity

Return type:

float

get_dof_type_string(self: Gym, arg0: DofType) → str

Converts the degree of freedom type from GymDofType to string

Parameters:: param1 (isaacgym.gymapi.DofType) – Degree of freedom type
Returns:: name of type as string
Return type:: str

get_dof_velocity(self: Gym, arg0: Env, arg1: int) → float

Gets velocity for a degree of freedom.

See isaacgym.gymapi.Gym.acquire_dof_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (DOF) – Handle to degree of freedom.

Returns:

Velocity for DOF

Return type:

float

get_elapsed_time(self: Gym, arg0: Sim) → float

Gets Elapsed wall clock time since the simulation started.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: elapsed wall clock time, in seconds.
Return type:: double

get_env(self: Gym, arg0: Sim, arg1: int) → Env

Gets Environment Handle

Parameters:

param1 (Sim) – Simulation Handle.
param2 (int) – index of environment.

Returns:

Environment Handle, if index is valid, nullptr otherwise

Return type:

Env

get_env_count(self: Gym, arg0: Sim) → int

Gets count of environments on simulation

Parameters:: param1 (Sim) – Simulation Handle.
Returns:: number of environments
Return type:: int

get_env_dof_count(self: Gym, arg0: Env) → int

Gets count of degrees of freedom for environment

Parameters:: param1 (Env) – Environment Handle
Returns:: count of Degrees of Freedom
Return type:: int

get_env_joint_count(self: Gym, arg0: Env) → int

Gets count of joints for environment

Parameters:: param1 (Env) – Environment Handle
Returns:: Number of joints in environment
Return type:: int

get_env_origin(self: Gym, arg0: Env) → Vec3

Gets position of environment origin, in simulation global coordinates

Parameters:: param1 (Env) – Environment Handle.
Returns:: environment origin
Return type:: isaacgym.gymapi.Vec3

get_env_rigid_body_count(self: Gym, arg0: Env) → int

Gets count of rigid bodies for environment

Parameters:: param1 (Env) – Environment Handle
Returns:: Number of rigid bodies in environment
Return type:: int

get_env_rigid_body_states(self: Gym, arg0: Env, arg1: int) → numpy.ndarray[RigidBodyState]

Gets state for the environments’s Rigid Bodies. see isaacgym.gymapi.RigidBodyState.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (int) – flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

List of rigid body states

Return type:

list of isaacgym.gymapi.RigidBodyState

get_env_rigid_contact_forces(self: Gym, arg0: Env) → numpy.ndarray[Vec3]

Gets contact forces for a single environment.

See isaacgym.gymapi.Gym.acquire_net_contact_force_tensor for new tensor version of this API.

Parameters:: param1 (Env) – environment handle
Returns:: obj: list of isaacgym.gymapi.Vec3: Contact forces for the environment

get_env_rigid_contacts(self: Gym, arg0: Env) → numpy.ndarray[RigidContact]

Gets contact information for environment

Parameters:: param1 (Env) – environment handle
Returns:: obj: list of isaacgym.gymapi.RigidContact: Contact information for the environment

get_frame_count(self: Gym, arg0: Sim) → int

Gets Current frame count in the simulation.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: current frame count in the simulation
Return type:: int64_t

get_joint_handle(self: Gym, arg0: Env, arg1: str, arg2: str) → int

Searches for the joint handle in an actor, given their names

Parameters:

param1 (Env) – Environment Handle
param2 (str) – Actor Name
param3 (str) – Joint Name

Returns:

Joint handle

Return type:

Handle

get_joint_name(self: Gym, arg0: Env, arg1: int) → str

Gets the joint name.

Parameters:

param1 (Joint) – Environment handle
param1 – Joint handle

Returns:

Joint Name

Return type:

str

get_joint_position(self: Gym, arg0: Env, arg1: int) → float

Gets position for the joint.

Parameters:

param1 (Env) – Environment Handle
param2 (Joint) – Handle to joint of interest.

Returns:

The joint position value.

Return type:

float

get_joint_target_position(self: Gym, arg0: Env, arg1: int) → float

Gets target position for the joint. if the joint is prismatic, the target is in meters. if the joint is revolute, the target is in radians.

Parameters:

param1 (Env) – Environment Handle
param2 (Joint) – Joint Handle

Returns:

target position

Return type:

float

get_joint_target_velocity(self: Gym, arg0: Env, arg1: int) → float

Gets target velocity for the joint. if the joint is prismatic, the target is in m/s. if the joint is revolute, the target is in rad/s.

Parameters:

param1 (Env) – Environment Handle
param2 (Joint) – Joint Handle

Returns:

target velocity

Return type:

float

get_joint_transform(self: Gym, arg0: Env, arg1: int) → Transform

Gets Transform for the joint.

Parameters:

param1 (Env) – Environment Handle
param2 (Joint) – Handle to joint of interest.

Returns:

The joint transform value.

Return type:

isaacgym.gymapi.Transform

get_joint_type_string(self: Gym, arg0: JointType) → str

Converts the joint type from JointType to string

Parameters:: param1 (JointType) – Type of Joint.
Returns:: String containing joint type.
Return type:: string

get_joint_velocity(self: Gym, arg0: Env, arg1: int) → float

Gets velocity for the joint.

Parameters:

param1 (Env) – Environment Handle
param2 (Joint) – Handle to joint of interest.

Returns:

The joint velocity value.

Return type:

float

get_performance_timers(self: Gym, arg0: Sim, arg1: int) → PerformanceTimers

Returns a struct of performance timers which reflect the times of the most recent operations for a set of timers

Parameters:

param1 (Sim) – Simulation Handle
param2 (Timers) – Simulation Timers Handle returned by isaacgym.gymapi.Gym.create_performance_timers

Returns:

Performance timers data structure

Return type:

isaacgym.gymapi.PerformanceTimers

get_pneumatic_pressure(self: Gym, arg0: Env, arg1: int, arg2: int) → float

Gets pressure for selected actuator.

See isaacgym.gymapi.Gym.acquire_pneumatic_pressure_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (SoftActuator) – Soft Actuator Handle

Returns:

pressure, in Pa.

Return type:

float

get_pneumatic_target(self: Gym, arg0: Env, arg1: int, arg2: int) → float

Gets pressure target for selected actuator.

See isaacgym.gymapi.Gym.acquire_pneumatic_target_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (SoftActuator) – Soft Actuator Handle

Returns:

pressure target, in Pa.

Return type:

float

get_rigid_angular_velocity(self: Gym, arg0: Env, arg1: int) → Vec3

Gets Angular Velocity for Rigid Body.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Body) – Rigid Body handle

Returns:

angular velocity

Return type:

isaacgym.gymapi.Vec3

get_rigid_body_color(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: MeshType) → Vec3

Gets color of rigid body

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle
param3 (int) – index of rigid body to be set
param4 (isaacgym.gymapi.MeshType) – selection of what mesh is to be set

Returns:

Vector containing RGB values in range [0,1]

Return type:

isaacgym.gymapi.Vec3

get_rigid_body_segmentation_id(self: Gym, arg0: Env, arg1: int, arg2: int) → int

Gets segmentation ID for rigid body

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle
param3 (int) – index of rigid body to be set

Returns:

segmentation ID for selected body

Return type:

uint32_t

get_rigid_body_texture(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: MeshType) → int

Gets Handle for rigid body texture

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle
param3 (int) – index of rigid body to be set
param4 (isaacgym.gymapi.MeshType) – selection of what mesh is to be set

Returns:

handle for applied texture, INVALID_HANDLE if none is applied.

Return type:

Handle`

get_rigid_contact_forces(self: Gym, arg0: Sim) → numpy.ndarray[Vec3]

Gets contact forces in simulation.

See isaacgym.gymapi.Gym.acquire_net_contact_force_tensor for new tensor version of this API.

Parameters:: param1 (Sim) – Simulation handle
Returns:: obj: list of isaacgym.gymapi.Vec3: Contact forces for the simulator

get_rigid_contacts(self: Gym, arg0: Sim) → numpy.ndarray[RigidContact]

Gets contact information for simulation.

Parameters:: param1 (Sim) – Simulation handle
Returns:: obj: list of isaacgym.gymapi.RigidContact: Contact information for the simulation

get_rigid_handle(self: Gym, arg0: Env, arg1: str, arg2: str) → int

Searches for the rigid body in an actor, given their names

Parameters:

param1 (Env) – Environment Handle
param2 (str) – Actor Name
param3 (str) – Rigid Body Name

Returns:

Rigid Body handle

Return type:

Handle

get_rigid_linear_velocity(self: Gym, arg0: Env, arg1: int) → Vec3

Gets Linear Velocity for Rigid Body.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Body) – Rigid Body handle

Returns:

linear velocity

Return type:

isaacgym.gymapi.Vec3

get_rigid_name(self: Gym, arg0: Env, arg1: int) → str

Gets the rigid body name.

Parameters:

param1 (Body) – Environment handle
param1 – Rigid Body handle

Returns:

Rigid Body Name

Return type:

str

get_rigid_transform(self: Gym, arg0: Env, arg1: int) → Transform

Vectorized bindings to get rigid body transforms in the env frame.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Body) – Environment handle
param1 – Rigid Body handle

Returns:

Transform

Return type:

isaacgym.gymapi.Transform

get_sensor(self: Gym, arg0: Env, arg1: int) → int: N/A

get_sim_actor_count(self: Gym, arg0: Sim) → int

Gets total number of actors in simulation

Parameters:: param1 (Sim) – Simulation Handle.
Returns:: Number of actors
Return type:: int

get_sim_dof_count(self: Gym, arg0: Sim) → int

Gets count of degrees of freedom for simulation

Parameters:: param1 (Sim) – Simulation Handle
Returns:: count of Degrees of Freedom
Return type:: int

get_sim_force_sensor_count(self: Gym, arg0: Sim) → int

Gets number of force sensors in simulation

Parameters:: param1 (Sim) – Simulation Handle
Returns:: Number of sensors
Return type:: int

get_sim_joint_count(self: Gym, arg0: Sim) → int

Gets count of joints for simulation

Parameters:: param1 (Sim) – Simulation Handle
Returns:: Joint count for simulation
Return type:: int

get_sim_params(self: Gym, arg0: Sim) → object

Gets simulation Parameters. See isaacgym.gymapi.SimParams

Parameters:: param1 (Sim) – Simulation Handle.
Returns:: current simulation parameters
Return type:: isaacgym.gymapi.SimParams

get_sim_rigid_body_count(self: Gym, arg0: Sim) → int

Gets count of Rigid Bodies for simulation

Parameters:: param1 (Sim) – Simulation Handle
Returns:: Count of rigid bodies
Return type:: int

get_sim_rigid_body_states(self: Gym, arg0: Sim, arg1: int) → numpy.ndarray[RigidBodyState]

Gets state for the simulation’s Rigid Bodies. see isaacgym.gymapi.RigidBodyState.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (int) – flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

List of rigid body states

Return type:

list of isaacgym.gymapi.RigidBodyState

get_sim_tetrahedra(self: Gym, arg0: Sim) → Tuple[List[int], List[Mat33]]

Gets the tetrahedra indices and Cauchy stress tensors

Parameters:: param1 (Sim) – Simulation Handle
Returns:: tuple(indices[] (int), stress[] (Matrix33))

get_sim_tetrahedra_count(self: Gym, arg0: Sim) → int

Gets the total number of tetrahedra in the simulation

Parameters:: param1 (Sim) – Simulation Handle
Returns:: tetrahedra count
Return type:: int

get_sim_time(self: Gym, arg0: Sim) → float

Gets Elapsed Simulation Time.

Parameters:: param1 (Sim) – Simulation Handle
Returns:: elapsed simulation time, in seconds
Return type:: double

get_sim_triangle_count(self: Gym, arg0: Sim) → int

Gets the total number of deformable triangles in the simulation

Parameters:: param1 (Sim) – Simulation Handle
Returns:: triangle count
Return type:: int

get_sim_triangles(self: Gym, arg0: Sim) → Tuple[List[int], List[int], List[Vec3]]

Gets the triangle indices, parent tetrahedron indices, and face normals

Parameters:: param1 (Sim) – Simulation Handle
Returns:: tuple(indices (int[]), parents (int[]), normals (Float3[]))

get_soft_contacts(self: Gym, arg0: Sim) → numpy.ndarray[SoftContact]

Gets soft contact information for simulation

Args: param1 (Sim): Simulation handle

Returns: :obj: list of isaacgym.gymapi.SoftContact: Contact information for the simulation

get_usd_export_root(self: Gym, arg0: UsdExporter) → str

Get USD export directory of a USD exporter

Parameters:: param1 (Exporter) – USD Exporter Handle
Returns:: path the root directory path
Return type:: str

get_vec_actor_dof_states(*args, **kwargs)

Overloaded function.

get_vec_actor_dof_states(self: Gym, arg0: List[Env], arg1: int, arg2: int) -> numpy.ndarray[DofState]

Gets state for the actor’s degrees of freedom from multiple environments. see isaacgym.gymapi.DofState.

See isaacgym.gymapi.Gym.acquire_dof_state_tensor for new tensor version of this API.

Args:
param1 (:obj: list of Env): Environment Handles param2 (Actor): Actor Handle param3 (int): flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

obj:

list of isaacgym.gymapi.DofState : array of states
get_vec_actor_dof_states(self: Gym, arg0: List[Env], arg1: List[int], arg2: int) -> numpy.ndarray[DofState]

Gets state for the actors degrees of freedom from multiple environments. see isaacgym.gymapi.DofState.

See isaacgym.gymapi.Gym.acquire_dof_state_tensor for new tensor version of this API.

Args:
param1 (:obj: list of Env): Environment Handles param2 (:obj: list of Actor): Actor Handles param3 (int): flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

obj:

list of isaacgym.gymapi.DofState : array of states

get_vec_env_rigid_contact_forces(self: Gym, arg0: List[Env]) → numpy.ndarray[Vec3]

Gets contact forces for a list of environments.

See isaacgym.gymapi.Gym.acquire_net_contact_force_tensor for new tensor version of this API.

Parameters:: ( (param1) – obj: list of Env): list of environment handles
Returns:: obj: list of isaacgym.gymapi.Vec3: Contact forces, size of list is numEnvs * numBodies

get_vec_rigid_angular_velocity(*args, **kwargs)

Overloaded function.

get_vec_rigid_angular_velocity(self: Gym, arg0: List[Env], arg1: int) -> numpy.ndarray[Vec3]

vectorized bindings to get rigid body angular velocities in the env frame.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Args:
param1 (:obj: list of Env): list of environment handles param2 (Body): Rigid Body handle

Returns:

obj:

list of isaacgym.gymapi.Vec3: Angular velocities
get_vec_rigid_angular_velocity(self: Gym, arg0: List[Env], arg1: List[int]) -> numpy.ndarray[Vec3]

vectorized bindings to get rigid body angular velocities in the env frame.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Args:
param1 (:obj: list of Env): list of environment handles param2 (:obj: list of Body): list of Rigid Body handles

Returns:

obj:

list of isaacgym.gymapi.Vec3: Angular velocities

get_vec_rigid_linear_velocity(*args, **kwargs)

Overloaded function.

get_vec_rigid_linear_velocity(self: Gym, arg0: List[Env], arg1: int) -> numpy.ndarray[Vec3]

Vectorized bindings to get rigid body linear velocities in the env frame.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Args:
param1 (:obj: list of Env): list of environment handles param1 (Body): Rigid Body handle

Returns:

obj:

list of isaacgym.gymapi.Vec3: Linear velocities
get_vec_rigid_linear_velocity(self: Gym, arg0: List[Env], arg1: List[int]) -> numpy.ndarray[Vec3]

Vectorized bindings to get rigid body linear velocities in the env frame.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Args:
param1 (:obj: list of Env): list of environment handles param1 (:obj: list of Body): list of Rigid Body handles

Returns:

obj:

list of isaacgym.gymapi.Vec3: Linear velocities

get_vec_rigid_transform(*args, **kwargs)

Overloaded function.

get_vec_rigid_transform(self: Gym, arg0: List[Env], arg1: int) -> numpy.ndarray[Transform]

Vectorized bindings to get rigid body transforms in the env frame.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Args:
param1 (:obj: list of Env): list of environment handles param1 (Body): Rigid Body handle

Returns:

obj:

list of isaacgym.gymapi.Transform: Transforms
get_vec_rigid_transform(self: Gym, arg0: List[Env], arg1: List[int]) -> numpy.ndarray[Transform]

Vectorized bindings to get rigid body transforms in the env frame.

See isaacgym.gymapi.Gym.acquire_rigid_body_state_tensor for new tensor version of this API.

Args:
param1 (:obj: list of Env): list of environment handles param1 (:obj: list of Body): list of Rigid Body handles

Returns:

obj:

list of isaacgym.gymapi.Transform: Transforms

get_version(self: Gym) → Version

Get Gym version.

Returns:: isaacgym.gymapi.Version

get_viewer_camera_handle(self: Gym, arg0: Viewer) → int

Gets handle for the viewer camera

Parameters:: param1 (Viewer) – Viewer Handle.
Returns:: Camera Handle
Return type:: Handle

get_viewer_camera_transform(self: Gym, arg0: Viewer, arg1: Env) → Transform

Gets camera transform, with respect to the selected environment

Parameters:

param1 (Viewer) – Viewer Handle.
param2 (Env) – revEnv environment of reference

Returns:

Camera Transform

Return type:

isaacgym.gymapi.Transform

get_viewer_mouse_position(self: Gym, arg0: Viewer) → Vec2

Returns the latest mouse position from the viewer

Parameters:: param1 (Viewer) – Viewer Handle.
Returns:: Vector containing the normalized mouse coordinates
Return type:: isaacgym.gymapi.Vec2

get_viewer_size(self: Gym, arg0: Viewer) → Int2

Returns the size of the window from the viewer

Parameters:: param1 (Viewer) – Viewer Handle.
Returns:: Vector containing the window size
Return type:: isaacgym.gymapi.Int2

load_asset(self: Gym, sim: Sim, rootpath: str, filename: str, options: AssetOptions = None) → Asset

Loads an asset from a file. The file type will be determined by its extension.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (str) – path to asset root folder
param3 (str) – asset file name
param4 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

load_mjcf(self: Gym, sim: Sim, rootpath: str, filename: str, options: AssetOptions = None) → Asset

Loads an Asset from a MJCF file.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (str) – path to asset root folder
param3 (str) – asset file name
param4 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

load_opensim(self: Gym, sim: Sim, rootpath: str, filename: str, options: AssetOptions = None) → Asset

Loads an Asset from a OpenSim file.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (str) – path to asset root folder
param3 (str) – asset file name
param4 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

load_sim(self: Gym, arg0: int, arg1: int, arg2: SimType, arg3: str, arg4: str) → Sim

Load simulation from USD scene, updates will not be saved to USD stage.

Parameters:

param1 (int) – index of CUDA-enabled GPU to be used for simulation.
param2 (int) – index of GPU to be used for rendering.
param3 (isaacgym.gymapi.SimType) – Type of simulation to be used.
param4 (string) – Path to root directory of USD scene
param5 (string) – Filename of USD scene

Returns:

Simulation Handle

Return type:

Sim

load_urdf(self: Gym, sim: Sim, rootpath: str, filename: str, options: AssetOptions = None) → Asset

Loads an Asset from a URDF file.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (str) – path to asset root folder
param3 (str) – asset file name
param4 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

load_usd(self: Gym, sim: Sim, rootpath: str, filename: str, options: AssetOptions = None) → Asset

Loads an Asset from a USD file.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (str) – path to asset root folder
param3 (str) – asset file name
param4 (isaacgym.gymapi.AssetOptions) – asset Options.

Returns:

Handle to asset

Return type:

Handle

omni_connect(self: Gym, arg0: OmniConnectionParams) → bool: Connect to Omniverse Kit

omni_disconnect(self: Gym) → None: Disconnect from Omniverse Kit

poll_viewer_events(self: Gym, arg0: Viewer) → None

Poll viewer without rendering updates

Parameters:: param1 (Viewer) – Viewer Handle.

prepare_sim(self: Gym, arg0: Sim) → bool

Prepares simulation with buffer allocations

Parameters:: param1 (Sim) – Simulation Handle
Returns:: true if operation was succesful, false otherwise.
Return type:: bool

query_viewer_action_events(self: Gym, arg0: Viewer) → List[ActionEvent]

Checks if a given event has occurred.

Parameters:: param1 (Viewer) – Viewer Handle.
Returns:: obj: list of isaacgym.gymapi.ActionEvent: List of events and values

query_viewer_has_closed(self: Gym, arg0: Viewer) → bool

Checks whether the viewer has closed

Parameters:: param1 (Viewer) – Viewer Handle.
Returns:: true if viewer has closed, false otherwise
Return type:: bool

refresh_actor_root_state_tensor(self: Gym, arg0: Sim) → bool

Updates actor root state buffer

Parameters:: param1 (Sim) – Simulation Handle

refresh_dof_force_tensor(self: Gym, arg0: Sim) → bool

Updates buffer state for DOF forces

Parameters:: param1 (Sim) – Simulation Handle

refresh_dof_state_tensor(self: Gym, arg0: Sim) → bool

Updates DOF state buffer

Parameters:: param1 (Sim) – Simulation Handle

refresh_force_sensor_tensor(self: Gym, arg0: Sim) → bool

Updates buffer state for force sensors tensor

Parameters:: param1 (Sim) – Simulation Handle

refresh_jacobian_tensors(self: Gym, arg0: Sim) → bool

Updates buffer state for Jacobian tensor

Parameters:: param1 (Sim) – Simulation Handle

refresh_mass_matrix_tensors(self: Gym, arg0: Sim) → bool

Updates buffer state for Mass Matrix tensor

Parameters:: param1 (Sim) – Simulation Handle

refresh_net_contact_force_tensor(self: Gym, arg0: Sim) → bool

Updates buffer state for net contact force tensor

Parameters:: param1 (Sim) – Simulation Handle

refresh_particle_state_tensor(self: Gym, arg0: Sim) → bool

Updates buffer for particle states tensor. Flex backend only.

Parameters:: param1 (Sim) – Simulation Handle

refresh_pneumatic_pressure_tensor(self: Gym, arg0: Sim) → bool

Updates buffer state for pneumatic pressure tensor. Flex backend only.

Parameters:: param1 (Sim) – Simulation Handle

refresh_pneumatic_target_tensor(self: Gym, arg0: Sim) → bool

Updates buffer state for pneumatic target tensor. Flex backend only.

Parameters:: param1 (Sim) – Simulation Handle

refresh_rigid_body_state_tensor(self: Gym, arg0: Sim) → bool

Updates rigid body states buffer

Parameters:: param1 (Sim) – Simulation Handle

render_all_camera_sensors(self: Gym, arg0: Sim) → None

Renders all images obtained from camera sensors

Parameters:: param1 (Sim) – Simulation Handle.

reset_actor_materials(self: Gym, arg0: Env, arg1: int, arg2: MeshType) → None

Resets all materials on an actor to what was loaded with the asset file.

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle
param3 (isaacgym.gymapi.MeshType) – selection of what mesh is to be set

reset_actor_particles_to_rest(self: Gym, arg0: Env, arg1: int) → bool

Resets particles in actor to their rest position

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_dof_position_targets(self: Gym, arg0: Env, arg1: int, arg2: numpy.ndarray[float32]) → bool

Sets target position for the actor’s degrees of freedom. if the joint is prismatic, the target is in meters. if the joint is revolute, the target is in radians.

See isaacgym.gymapi.Gym.set_dof_position_target_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of float) : array of position targets

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_dof_properties(self: Gym, arg0: Env, arg1: int, arg2: numpy.ndarray[carb::gym::GymDofProperties]) → bool

Sets Degrees of Freedom Properties for Actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
properties. (param3 A structured Numpy array of DOF) –

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_dof_states(self: Gym, arg0: Env, arg1: int, arg2: numpy.ndarray[DofState], arg3: int) → bool

Sets states for the actor’s Rigid Bodies. see isaacgym.gymapi.RigidBodyState.

See isaacgym.gymapi.Gym.set_dof_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of isaacgym.gymapi.DofState): array of states to set.
param4 (int) – flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_dof_velocity_targets(self: Gym, arg0: Env, arg1: int, arg2: numpy.ndarray[float32]) → bool

Sets target velocities for the actor’s degrees of fredom. if the joint is prismatic, the target is in m/s. if the joint is revolute, the target is in rad/s.

See isaacgym.gymapi.Gym.set_dof_velocity_target_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of float) : array of velocity targets

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_fixed_tendon_joint_coefficients(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: List[float]) → bool

Sets coefficients of joints in fixed tendon of an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of fixed tendon
( (param4) – obj: list of float): list of coefficients to set

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_rigid_body_properties(self: Gym, env: Env, actorHandle: int, props: List[RigidBodyProperties], recomputeInertia: bool = False) → bool

Sets properties for rigid bodies in an actor on selected environment.

Note: Changing the center-of-mass when using the GPU pipeline is currently not supported (but mass and inertia can be changed).

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of isaacgym.gymapi.RigidBodyProperties): list of properties to set
param4 (bool) – flag for recomputing inertia tensor on a mass change

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_rigid_body_states(self: Gym, arg0: Env, arg1: int, arg2: numpy.ndarray[RigidBodyState], arg3: int) → bool

Sets states for the actor’s Rigid Bodies. see isaacgym.gymapi.RigidBodyState.

See isaacgym.gymapi.Gym.set_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of isaacgym.gymapi.RigidBodyState): array of states to set.
param4 (int) – flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_rigid_shape_properties(self: Gym, arg0: Env, arg1: int, arg2: List[RigidShapeProperties]) → bool

Sets properties for rigid shapes in an ector on selected environment.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of isaacgym.gymapi.RigidShapeProperties): list of properties to set

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_root_state_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets actor root state buffer to values provided for all actors in simulation.

See isaacgym.gymapi.Gym.set_actor_root_state_tensor_indexed for indexed version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing actor root states

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_actor_root_state_tensor_indexed(self: Gym, arg0: Sim, arg1: Tensor, arg2: Tensor, arg3: int) → bool

Sets actor root state buffer to values provided for given actor indices. Full actor root states buffer should be provided for all actors.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing actor root states
param3 (isaacgym.gymapi.Tensor) – Buffer containing actor indices
param4 (int) – Size of actor indices buffer

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_actor_scale(self: Gym, arg0: Env, arg1: int, arg2: float) → bool

Sets the scale of the actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (float) –

Returns:

True if scale was set successfully, false otherwise.

set_actor_soft_materials(self: Gym, arg0: Env, arg1: int, arg2: List[SoftMaterial]) → bool

Sets soft material properties for Actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of isaacgym.gymapi.SoftMaterials): properties for soft materials, see isaacgym.gymapi.SoftMaterials.

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_actor_tendon_offset(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: float) → bool

Sets the length offset of a tendon of an actor

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (int) – Index of the tendon
param4 (float) – The offset to set

Returns:

indicator whether operation was successful

Return type:

bool

set_actor_tendon_properties(self: Gym, arg0: Env, arg1: int, arg2: List[TendonProperties]) → bool

Sets properties for tendons in an actor.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
( (param3) – obj: list of isaacgym.gymapi.TendonProperties): list of properties to set

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_asset_fixed_tendon_joint_coefficients(self: Gym, arg0: Asset, arg1: int, arg2: List[float]) → bool

Sets coefficients of joints in fixed tendon in an asset.

Parameters:

param1 (Asset) – Asset Handle
param2 (int) – Index of fixed tendon
( (param3) – obj: list of float): list of coefficients to set

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_asset_rigid_shape_properties(self: Gym, arg0: Asset, arg1: List[RigidShapeProperties]) → bool

Sets properties for rigid shapes in an asset.

Parameters:

param1 (Asset) – Asset Handle
( (param2) – obj: list of isaacgym.gymapi.RigidShapeProperties): list of properties to set

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_asset_tendon_properties(self: Gym, arg0: Asset, arg1: List[TendonProperties]) → bool

Sets properties for tendons in an asset.

Parameters:

param1 (Asset) – Asset Handle
( (param2) – obj: list of isaacgym.gymapi.TendonProperties): list of properties to set

Returns:

return true if operation was succesful, false otherwise.

Return type:

bool

set_attractor_properties(self: Gym, arg0: Env, arg1: int, arg2: AttractorProperties) → None

Modifies the properties of an attractor given by its handle and the environment selected. for modifying only the attractor target, see setAttractorTarget.

Parameters:

param1 (Env) – Environment Handle
param2 (Attractor) – Attractor Handle
param3 (isaacgym.gymapi.AttractorProperties) – the new properties for the attractor.

set_attractor_target(self: Gym, arg0: Env, arg1: int, arg2: Transform) → None

Modifies target of the selected attractor.

Parameters:

param1 (Env) – Environment Handle
param2 (Attractor) – Attractor Handle
param3 (isaacgym.gymapi.Transform) – attractor target pose, in global coordinate.

Returns:

properties of selected attractor.

Return type:

isaacgym.gymapi.AttractorProperties

set_camera_location(self: Gym, arg0: int, arg1: Env, arg2: Vec3, arg3: Vec3) → None

Positions the viewer camera to look at a specified target location. Setting Camera location manually will detach the camera if it is attached to a body

Parameters:

param1 (Camera) – Viewer Handle.
param2 (Env) – refEnv environment of reference to determine the origin
param3 (isaacgym.gymapi.Vec3) – position where the camera will be placed, with respect to the selected environment origin
param4 (isaacgym.gymapi.Vec3) – target location that will be at the center of the camera, with respect to the selected environment

Returns:

true if viewer has closed, false otherwise

Return type:

bool

set_camera_transform(self: Gym, arg0: int, arg1: Env, arg2: Transform) → None

Sets camera transform with respect to the attached rigid body.

Parameters:

param1 (Camera) – Viewer Handle.
param2 (Env) – refEnv environment of reference to determine the origin
param3 (isaacgym.gymapi.Transform) – transform from rigid body to camera position

Returns:

true if viewer has closed, false otherwise

Return type:

bool

set_dof_actuation_force_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets DOF actuation forces to values provided for all DOFs in simulation. Force is in Newton for linear DOF. For revolute DOF, force is torque in Nm.

See isaacgym.gymapi.Gym.set_dof_actuation_force_tensor_indexed for indexed version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing forces

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_dof_actuation_force_tensor_indexed(self: Gym, arg0: Sim, arg1: Tensor, arg2: Tensor, arg3: int) → bool

Sets DOF actuation forces to values provided for given actor indices. Full DOF actuation force buffer should be provided for all actors. Force is in Newton for linear DOF. For revolute DOF, force is torque in Nm.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing DOF actuations states
param3 (isaacgym.gymapi.Tensor) – Buffer containing actor indices
param4 (int) – Size of actor indices buffer

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_dof_position_target_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets DOF position targets to values provided for all DOFs in simulation. For presimatic DOF, target is in meters. For revolute DOF, target is in radians.

See isaacgym.gymapi.Gym.set_dof_position_target_tensor_indexed for indexed version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing DOF position targets

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_dof_position_target_tensor_indexed(self: Gym, arg0: Sim, arg1: Tensor, arg2: Tensor, arg3: int) → bool

Sets DOF position targets to values provided for given actor indices. Full DOF position targets buffer should be provided for all actors. For presimatic DOF, target is in meters. For revolute DOF, target is in radians.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing DOF position targets
param3 (isaacgym.gymapi.Tensor) – Buffer containing actor indices
param4 (int) – Size of actor indices buffer

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_dof_state_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets DOF state buffer to values provided for all DOFs in simulation. DOF state includes position in meters for prismatic DOF, or radians for revolute DOF, and velocity in m/s for prismatic DOF and rad/s for revolute DOF.

See isaacgym.gymapi.Gym.set_dof_state_tensor_indexed for indexed version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing DOF states

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_dof_state_tensor_indexed(self: Gym, arg0: Sim, arg1: Tensor, arg2: Tensor, arg3: int) → bool

Sets DOF state buffer to values provided for given actor indices. Full DOF state buffer should be provided for all actors. DOF state includes position in meters for prismatic DOF, or radians for revolute DOF, and velocity in m/s for prismatic DOF and rad/s for revolute DOF.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing DOF states
param3 (isaacgym.gymapi.Tensor) – Buffer containing actor indices
param4 (int) – Size of actor indices buffer

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_dof_target_position(self: Gym, arg0: Env, arg1: int, arg2: float) → None

Sets a target position for the DOF. if the DOF is prismatic, the target is in meters. if the DOF is revolute, the target is in radians.

Parameters:

param1 (Env) – Environment Handle
param2 (DOF) – DOF Handle
param3 (float) – position

set_dof_target_velocity(self: Gym, arg0: Env, arg1: int, arg2: float) → None

Sets a target velocity for the DOF. if the DOF is prismatic, the target is in m/s. if the DOF is revolute, the target is in rad/s.

See isaacgym.gymapi.Gym.set_dof_velocity_target_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (DOF) – DOF Handle
param3 (float) – velocity

set_dof_velocity_target_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets DOF velocity targets to values provided for all DOFs in simulation For prismatic DOF, target is in m/s. For revolute DOF, target is in rad/s.

See isaacgym.gymapi.Gym.set_dof_velocity_target_tensor_indexed for indexed version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing DOF velocity targets

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_dof_velocity_target_tensor_indexed(self: Gym, arg0: Sim, arg1: Tensor, arg2: Tensor, arg3: int) → bool

Sets DOF velocity targets to values provided for given actor indices. Full DOF velocity target buffer should be provided for all actors. For prismatic DOF, target is in m/s. For revolute DOF, target is in rad/s.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing DOF velocity targets
param3 (isaacgym.gymapi.Tensor) – Buffer containing actor indices
param4 (int) – Size of actor indices buffer

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_env_rigid_body_states(self: Gym, arg0: Env, arg1: numpy.ndarray[RigidBodyState], arg2: int) → bool

Sets states for simulation’s Rigid Bodies. see isaacgym.gymapi.RigidBodyState

Parameters:

param1 (Env) – Environment Handle
param2 (int) – List of rigid body states
param2 – flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_joint_target_position(self: Gym, arg0: Env, arg1: int, arg2: float) → None

Sets a target position for the joint. if the joint is prismatic, the target is in meters. if the joint is revolute, the target is in radians.

Parameters:

param1 (Env) – Environment Handle
param2 (Joint) – Joint Handle
param3 (float) – position

set_joint_target_velocity(self: Gym, arg0: Env, arg1: int, arg2: float) → None

Sets a target velocity for the joint. if the joint is prismatic, the target is in m/s. if the joint is revolute, the target is in rad/s.

Parameters:

param1 (Env) – Environment Handle
param2 (Joint) – Joint Handle
param3 (float) – velocity

set_light_parameters(self: Gym, arg0: Sim, arg1: int, arg2: Vec3, arg3: Vec3, arg4: Vec3) → None

Sets light parameters

Parameters:

param1 (Sim) – Simulation Handle.
param2 (int) – index to the light to be changed.
param3 (isaacgym.gymapi.Vec3) – intensity intensity of the light focus in the range [0,1] per channel, in RGB.
param4 (isaacgym.gymapi.Vec3) – ambient intensity of the ambient light in the range [0,1] per channel, in RGB.
param5 (isaacgym.gymapi.Vec3) – direction direction of the light focus

set_particle_state_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets particle states buffer to values provided. Flex backend only.

See isaacgym.gymapi.Gym.set_particle_state_tensor_indexed for indexed version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing particle states

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_particle_state_tensor_indexed(self: Gym, arg0: Sim, arg1: Tensor, arg2: Tensor, arg3: int) → bool

Sets particle state buffer to values provided for given actor indices. Flex backend only.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing particle states
param3 (isaacgym.gymapi.Tensor) – Buffer containing actor indices
param4 (int) – Size of actor indices buffer

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_pneumatic_pressure(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: float) → None

Sets pressure for selected actuator. the pressure value is clamped between 0 and actuator max pressure.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (SoftActuator) – Soft Actuator Handle
param4 (float) – pressure, in Pa.

set_pneumatic_pressure_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets pneumatic pressure buffer to values provided. Flex backend only.

See isaacgym.gymapi.Gym.set_pneumatic_pressure_tensor_indexed for indexed version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing pneumatic pressures

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_pneumatic_pressure_tensor_indexed(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets pneumatic pressure buffer to values provided for given actor indices. Flex backend only.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing pneumatic pressure
param3 (isaacgym.gymapi.Tensor) – Buffer containing actor indices
param4 (int) – Size of actor indices buffer

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_pneumatic_target(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: float) → None

Sets target pressure for selected actuator. the target value is clamped between 0 and actuator max pressure.

Parameters:

param1 (Env) – Environment Handle
param2 (Actor) – Actor Handle
param3 (SoftActuator) – Soft Actuator Handle
param4 (float) – pressure target, in Pa.

set_pneumatic_target_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets pneumatic target buffer to values provided. Flex backend only.

See isaacgym.gymapi.Gym.set_pneumatic_target_tensor_indexed for indexed version of this API.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing pneumatic targets

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_pneumatic_target_tensor_indexed(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets pneumatic target buffer to values provided for given actor indices. Flex backend only.

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing pneumatic targets
param3 (isaacgym.gymapi.Tensor) – Buffer containing actor indices
param4 (int) – Size of actor indices buffer

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_rigid_angular_velocity(self: Gym, arg0: Env, arg1: int, arg2: Vec3) → None

Sets Angular Velocity for Rigid Body.

See isaacgym.gymapi.Gym.set_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Body) – Rigid Body Handle
param3 (isaacgym.gymapi.Vec3) – angular velocity.

set_rigid_body_color(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: MeshType, arg4: Vec3) → None

Sets color of rigid body

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle
param3 (int) – index of rigid body to be set
param4 (isaacgym.gymapi.MeshType) – selection of what mesh is to be set
param5 (isaacgym.gymapi.Vec3) – Vector containing RGB values in range [0,1]

set_rigid_body_segmentation_id(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: int) → None

Sets segmentation ID for rigid body

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle
param3 (int) – index of rigid body to be set
param4 (uint32_t) – segmentation ID for selected body

set_rigid_body_state_tensor(self: Gym, arg0: Sim, arg1: Tensor) → bool

Sets rigid body state buffer to values provided for all rigid bodies in simulation. Flex backend only. State for each rigid body should contain position([0:3]), rotation([3:7]), linear velocity([7:10]), and angular velocity([10:13]).

Parameters:

param1 (Sim) – Simulation Handle
param2 (isaacgym.gymapi.Tensor) – Buffer containing rigid body states

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_rigid_body_texture(self: Gym, arg0: Env, arg1: int, arg2: int, arg3: MeshType, arg4: int) → None

Sets texture on Rigid Body

Parameters:

param1 (Env) – Environment Handle.
param2 (Actor) – Actor Handle
param3 (int) – index of rigid body to be set
param4 (isaacgym.gymapi.MeshType) – selection of what mesh is to be set
param5 (Texture) – texture handle for the selected texture

set_rigid_linear_velocity(self: Gym, arg0: Env, arg1: int, arg2: Vec3) → None

Sets Linear Velocity for Rigid Body.

See isaacgym.gymapi.Gym.set_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Body) – Rigid Body handle
param3 (isaacgym.gymapi.Vec3) – linear velocity

set_rigid_transform(self: Gym, arg0: Env, arg1: int, arg2: Transform) → None

Sets Transform for Rigid Body.

See isaacgym.gymapi.Gym.set_rigid_body_state_tensor for new tensor version of this API.

Parameters:

param1 (Env) – Environment Handle
param2 (Body) – Rigid Body handle
param3 (isaacgym.gymapi.Transform) – Transform

set_sim_device(self: Gym, arg0: Sim) → None

Sets sim compute device to be the current CUDA device.

Parameters:: param1 (Sim) – Simulation Handle

set_sim_params(self: Gym, arg0: Sim, arg1: SimParams) → None

Sets simulation Parameters. See isaacgym.gymapi.SimParams

Parameters:

param1 (Sim) – Simulation Handle.
param2 (isaacgym.gymapi.SimParams) – simulation parameters

set_sim_rigid_body_states(self: Gym, arg0: Sim, arg1: numpy.ndarray[RigidBodyState], arg2: int) → bool

Sets states for simulation’s Rigid Bodies. see isaacgym.gymapi.RigidBodyState

Parameters:

param1 (Sim) – Simulation Handle
param2 (int) – List of rigid body states
param2 – flags for the state to obtain, can be velocities (isaacgym.gymapi.STATE_VEL), positions(isaacgym.gymapi.STATE_POS) or both (isaacgym.gymapi.STATE_ALL)

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

set_usd_export_root(self: Gym, arg0: UsdExporter, arg1: str) → bool

Set USD export directory of a USD exporter

Parameters:

param1 (Exporter) – USD Exporter Handle
param3 (str) – path the root directory path (pass “.” for current working directory)

Returns:

true if operation was succesful, false otherwise.

Return type:

bool

simulate(self: Gym, arg0: Sim) → None

Steps the simulation by one time-step of dt, in seconds, divided in n substeps

Parameters:: param1 (Sim) – Simulation Handle

start_access_image_tensors(self: Gym, arg0: Sim) → None

Allows access to image tensors. Transfers data from all image tensors from the GPU to memory

Parameters:: param1 (Sim) – Simulation Handle.

step_graphics(self: Gym, arg0: Sim) → None

Update graphics of the simulator

Updates the simulation’s graphics. If one is displaying the simulation through a viewer, this method should be called in advance to obtain the latest graphics state.

Parameters:: param1 (Sim) – Simulation Handle.

subscribe_viewer_keyboard_event(self: Gym, arg0: Viewer, arg1: KeyboardInput, arg2: str) → None

Subscribes an action to a keyboard event. Each action keeps a list of mappings. This function push the mapping to the end of the list.

Parameters:

param1 (Viewer) – Viewer Handle.
param2 (isaacgym.gymapi.KeyboardInput) – keyboard input to subscribe to
param3 (str) – name of the action to be mapped

subscribe_viewer_mouse_event(self: Gym, arg0: Viewer, arg1: MouseInput, arg2: str) → None

Subscribes an action to a mouse event. Each action keeps a list of mappings. This function push the mapping to the end of the list.

Parameters:

param1 (Viewer) – Viewer Handle.
param2 (isaacgym.gymapi.MouseInput) – mouse input to subscribe to
param3 (str) – name of the action to be mapped

sync_frame_time(self: Gym, arg0: Sim) → None

Throttles simulation speed to real time.

Parameters:: param1 (Sim) – Simulation Handle

viewer_camera_look_at(self: Gym, arg0: Viewer, arg1: Env, arg2: Vec3, arg3: Vec3) → None

Positions the viewer camera to look at a specified target location

Parameters:

param1 (Viewer) – Viewer Handle.
param2 (Env) – refEnv environment of reference to determine the origin
param3 (isaacgym.gymapi.Vec3) – position where the camera will be placed, with respect to the selected environment origin
param4 (isaacgym.gymapi.Vec3) – target location that will be at the center of the camera, with respect to the selected environment

write_camera_image_to_file(self: Gym, arg0: Sim, arg1: Env, arg2: int, arg3: ImageType, arg4: str) → None

Writes image from camera directly to a PNG file.

Parameters:

param1 (Sim) – Simulation Handle.
param2 (Camera) – Camera Handle
param3 (isaacgym.gymapi.ImageType) – type of image to obtain from camera. see isaacgym.gymapi.ImageType
param4 (str) – filename string with the name of the file to be saved

write_viewer_image_to_file(self: Gym, arg0: Viewer, arg1: str) → None

Outputs image obtained from a viewer directly to a PNG file.

Parameters:

param1 (Viewer) – Viewer Handle.
param2 (str) – filename string with the name of the file to be saved