NVIDIA Isaac Sim

https://docs.isaacsim.omniverse.nvidia.com/latest/
Admin
NVIDIA Isaac Sim is a reference application built on NVIDIA Omniverse that enables developers to...
Tokens:4,391,021
Snippets:30,323
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Run SDG Getting Started Example (Command Line)

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/replicator_tutorials/tutorial_replicator_getting_started.html

Command to run the standalone example script. On Windows, use python.bat instead of python.sh.

```bash
./python.sh standalone_examples/api/isaacsim.replicator.examples/sdg_getting_started_01.py

```

--------------------------------

### Standalone SimReady Assets SDG example setup

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/replicator_tutorials/tutorial_replicator_isaac_randomizers.html

Standalone application setup for the SimReady Assets SDG example. Imports required modules, parses the --num-scenarios argument, enables the omni.simready.explorer extension, and defines helper functions for enabling the explorer, setting prim variants, and searching for SimReady assets asynchronously.

```python
"""Demonstrate synthetic data generation using SimReady assets with randomized scenes."""

from isaacsim import SimulationApp

simulation_app = SimulationApp(launch_config={"headless": False})

import argparse
import asyncio
import os
import sys
import time
from typing import Any

import carb.settings
import isaacsim.core.experimental.utils.app as app_utils
import isaacsim.core.experimental.utils.bounds as bounds_utils
import isaacsim.core.experimental.utils.stage as stage_utils
import numpy as np
import omni.replicator.core as rep
from isaacsim.core.experimental.utils.semantics import upgrade_prim_semantics_to_labels
from isaacsim.core.simulation_manager import SimulationManager
from pxr import Sdf, Usd, UsdPhysics

NUM_SCENARIOS = 5
SEED = 34

parser = argparse.ArgumentParser()
parser.add_argument(
    "--num-scenarios", type=int, default=NUM_SCENARIOS, help="Number of randomization scenarios to create"
)
args, _ = parser.parse_known_args()
num_scenarios = args.num_scenarios

if not app_utils.is_extension_enabled("omni.simready.explorer"):
    app_utils.enable_extension("omni.simready.explorer")
import omni.simready.explorer as sre


def enable_simready_explorer() -> None:
    """Enable the SimReady Explorer window if not already open."""
    if sre.get_instance().browser_model is None:
        import omni.kit.actions.core as actions

        actions.execute_action("omni.simready.explorer", "toggle_window")


def set_prim_variants(prim: Usd.Prim, variants: dict[str, str]) -> None:
    """Set variant selections on a prim from a dictionary of variant set names to values.

    Args:
        prim: USD prim containing the variant sets to update.
        variants: Desired selection keyed by variant-set name.
    """
    vsets = prim.GetVariantSets()
    for name, value in variants.items():
        vset = vsets.GetVariantSet(name)
        if vset:
            vset.SetVariantSelection(value)


async def search_assets_async() -> tuple[list, list, list]:
    """Search for SimReady assets (tables, dishes, items) asynchronously.

    Returns:
        Separate table, dish, and food-item search result lists.
    """
    print(f"[SDG] Searching for SimReady assets...")
    start_time = time.time()
    tables = await sre.find_assets(["table", "furniture"])
    print(f"[SDG]   - Found {len(tables)} tables ({time.time() - start_time:.2f}s)")
    start_time = time.time()
    plates = await sre.find_assets(["plate"])
    print(f"[SDG]   - Found {len(plates)} plates ({time.time() - start_time:.2f}s)")
    start_time = time.time()
    bowls = await sre.find_assets(["bowl"])
    print(f"[SDG]   - Found {len(bowls)} bowls ({time.time() - start_time:.2f}s)")
    dishes = plates + bowls
    start_time = time.time()
    fruits = await sre.find_assets(["fruit"])
    print(f"[SDG]   - Found {len(fruits)} fruits ({time.time() - start_time:.2f}s)")
    start_time = time.time()
    vegetables = await sre.find_assets(["vegetable"])
    print(f"[SDG]   - Found {len(vegetables)} vegetables ({time.time() - start_time:.2f}s)")
    items = fruits + vegetables
    return tables, dishes, items


def search_assets() -> tuple[list, list, list]:
    """Run SimReady asset search while pumping the app (required in standalone SimulationApp).

    Returns:
        Separate table, dish, and food-item search result lists.
    """
    search_task = asyncio.ensure_future(search_assets_async())
    while not search_task.done():
        app_utils.update_app()
    return search_task.result()
```

--------------------------------

### setup_workspace example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/action_and_event_data_generation/ext_behavior_tree_gen/three_api_functions.html

Creates a PlannerSession and loads input data. All arguments are optional, but typical runs provide cache_dir, output_dir, context_data_paths, and node_catalog_paths. Returns a PlannerSession with fields like workspace_ready, actors_loaded, objects_loaded, and nodes_loaded.

```python
session = core_api.setup_workspace(
    cache_dir=str(OUTPUT_DIR / "planner_cache"),
    output_dir=str(OUTPUT_DIR),
    context_data_paths=context_files["actors"] + context_files["objects"],
    node_catalog_paths=node_catalog_paths,
    actor_schema_path=actor_schema_path,
    object_schema_path=object_schema_path,
)

print(session.workspace_ready)
print(session.actors_loaded, session.objects_loaded, session.nodes_loaded)
```

--------------------------------

### Install and run Zenoh RMW router

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/installation/install_ros.html?setup.install_method=Pixi&setup.platform=Windows&setup.ros_distro=Jazzy

Install the Zenoh RMW implementation for ROS 2 Jazzy, source the ROS setup, set the RMW implementation, and start the Zenoh router. Without the router, nodes cannot discover each other because multicast discovery is disabled by default.

```bash
apt-get update && apt-get install -y ros-jazzy-rmw-zenoh-cpp
source /opt/ros/jazzy/setup.bash
export RMW_IMPLEMENTATION=rmw_zenoh_cpp
ros2 run rmw_zenoh_cpp rmw_zenohd
```

--------------------------------

### Run standalone example sdg_getting_started_03.py

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/replicator_tutorials/tutorial_replicator_getting_started.html

Run the standalone example on Linux/macOS. On Windows, use python.bat instead of python.sh.

```bash
./python.sh standalone_examples/api/isaacsim.replicator.examples/sdg_getting_started_03.py
```

--------------------------------

### Renamed extensions examples: ROS2 setting and LidarRtx imports

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/migration_guides/isaac_sim_4_5/extensions_renaming.html

Examples from the Isaac Sim 4.5 extension renaming guide. The shell command starts Kit with a deprecated ROS2 setting; the deprecation manager copies its value to the new setting name. The two Python snippets show the old and new import paths for the LidarRtx API.

```bash
./isaac-sim.sh --/exts/omni.isaac.ros2_bridge/ros_distro=humble

```

```python
from omni.isaac.sensor import LidarRtx

```

```python
from isaacsim.sensors.experimental.rtx import Lidar

```

--------------------------------

### Run standalone example sdg_getting_started_02.py

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/replicator_tutorials/tutorial_replicator_getting_started.html

Runs the standalone example for custom writer and annotators with multiple cameras. On Windows, use python.bat instead of python.sh.

```bash
./python.sh standalone_examples/api/isaacsim.replicator.examples/sdg_getting_started_02.py

```

--------------------------------

### Shared example setup for Behavior Tree Gen API

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/action_and_event_data_generation/ext_behavior_tree_gen/three_api_functions.html

Shared setup for the three-step API examples. Resolves bundled 'simple' example file paths and validates the API key. Replace helper calls with your own paths for custom planner data.

```python
import os
from pathlib import Path

from omni.ai.behavior_tree_gen.core import api as core_api
from omni.ai.behavior_tree_gen.bridge.utils import (
    get_example_scene_context_files,
    get_extension_path,
    load_example_scene_config,
    resolve_example_scene_file_path,
)

# Change these inputs to match your environment.
ROOT_DIR = Path("Your/Output/Folder/Path") / "behavior_tree_gen_output"
OUTPUT_DIR = ROOT_DIR / "output"
API_KEY = "Your_NVIDIA_API_key"
SCENARIO = "Anna picks up the CardBox_A and places it on the Table."

ext_path = get_extension_path()
scene_config = load_example_scene_config("simple")
context_files = get_example_scene_context_files("simple")

if ext_path is None or scene_config is None:
    raise RuntimeError("Could not load the bundled example scene configuration.")
if not API_KEY:
    raise RuntimeError("Set NVIDIA_API_KEY before running this example.")

node_catalog_paths = []
for path in (scene_config.get("node_catalogs") or {}).values():
    resolved_path = resolve_example_scene_file_path(path, ext_path=ext_path)
    if resolved_path:
        node_catalog_paths.append(resolved_path)

metadata_schemas = scene_config.get("metadata_schemas", {})
actor_schema_path = resolve_example_scene_file_path(
    metadata_schemas.get("actor"),
    ext_path=ext_path,
)
object_schema_path = resolve_example_scene_file_path(
    metadata_schemas.get("object"),
    ext_path=ext_path,
)

model_info = scene_config.get("model_info", {})
model_selection_config_path = resolve_example_scene_file_path(
    model_info.get("model_selection_config"),
    ext_path=ext_path,
)
embedding_model_configs_path = resolve_example_scene_file_path(
    model_info.get("embedding_model_configs"),
    ext_path=ext_path,
)
named_model_configs_path = resolve_example_scene_file_path(
    model_info.get("model_configs"),
    ext_path=ext_path,
)
node_to_model_map_path = resolve_example_scene_file_path(
    model_info.get("node_to_model_map"),
    ext_path=ext_path,
)

```

--------------------------------

### setup_writer(_writer_config: dict) -> Any

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/isaacsim.replicator.writers/docs/index.html

Initializes the writer and attaches the render product.

```APIDOC
## setup_writer(_writer_config: dict) -> Any

### Description
Initializes the writer and attaches the render product.

### Method
setup_writer

### Parameters
- **config_data** (dict) - Required - A dictionary containing the general configurations for the script.
- **writer_config** (dict) - Required - A dictionary containing writer-specific configurations.

### Returns
Initialized DOPE writer instance.
```

--------------------------------

### Get entities with GetEntities service and regex filters

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/ros2_tutorials/bridge_configuration/tutorial_ros2_simulation_control.html

Retrieves a list of all entities present in the simulation with optional filtering using POSIX Extended regular expressions. The filter parameter matches entity names (full USD prim paths). Examples include getting all entities, filtering for prims containing 'camera', paths starting with '/World', and paths ending with 'mesh'.

```bash
ros2 service call /get_entities simulation_interfaces/srv/GetEntities "{filters: {filter: ''}}"
```

```bash
ros2 service call /get_entities simulation_interfaces/srv/GetEntities "{filters: {filter: 'camera'}}"
```

```bash
ros2 service call /get_entities simulation_interfaces/srv/GetEntities "{filters: {filter: '^/World'}}"
```

```bash
ros2 service call /get_entities simulation_interfaces/srv/GetEntities "{filters: {filter: 'mesh$'}}"
```

--------------------------------

### Get stage time code with get_stage_time_code

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/isaacsim.asset.importer.utils/docs/index.html

Demonstrates querying a stage's time-code range and rate using get_stage_time_code. The example creates an in-memory stage and prints the returned tuple of start time code, end time code, and time codes per second.

```python
>>> from isaacsim.asset.importer.utils import stage_utils
>>> from pxr import Usd
>>>
>>> stage = Usd.Stage.CreateInMemory()
>>> stage_utils.get_stage_time_code(stage)
(0.0, 0.0, 24.0)

```

--------------------------------

### Run standalone example sdg_getting_started_05.py

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/replicator_tutorials/tutorial_replicator_getting_started.html

Run the standalone example directly. On Windows, use python.bat instead of python.sh.

```bash
./python.sh standalone_examples/api/isaacsim.replicator.examples/sdg_getting_started_05.py
```

--------------------------------

### Full async planner example with setup_workspace, prepare_runtime, and generate_behavior_tree

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/action_and_event_data_generation/ext_behavior_tree_gen/three_api_functions.html

Complete async example for Script Editor that sets up the workspace, prepares the runtime, and generates a behavior tree. Requires an NVIDIA API key and a valid output folder; raises RuntimeError if the scene config or API key is missing.

```python
import asyncio
import os
from pathlib import Path

from omni.ai.behavior_tree_gen.core import api as core_api
from omni.ai.behavior_tree_gen.bridge.utils import (
    get_example_scene_context_files,
    get_extension_path,
    load_example_scene_config,
    resolve_example_scene_file_path,
)

# Change these inputs to match your environment.
ROOT_DIR = Path("Your/Output/Folder/Path") / "behavior_tree_gen_output"
OUTPUT_DIR = ROOT_DIR / "output"
API_KEY = "Your_NVIDIA_API_key"
SCENARIO = "Anna picks up the CardBox_A and places it on the Table."


async def run_planner_example():
    ext_path = get_extension_path()
    scene_config = load_example_scene_config("basic")
    context_files = get_example_scene_context_files("basic")

    if ext_path is None or scene_config is None:
        raise RuntimeError("Could not load the bundled example scene configuration.")
    if not API_KEY:
        raise RuntimeError("Set NVIDIA_API_KEY before running this example.")

    node_catalog_paths = []
    for path in (scene_config.get("node_catalogs") or {}).values():
        resolved_path = resolve_example_scene_file_path(path, ext_path=ext_path)
        if resolved_path:
            node_catalog_paths.append(resolved_path)

    metadata_schemas = scene_config.get("metadata_schemas", {})
    actor_schema_path = resolve_example_scene_file_path(
        metadata_schemas.get("actor"),
        ext_path=ext_path,
    )
    object_schema_path = resolve_example_scene_file_path(
        metadata_schemas.get("object"),
        ext_path=ext_path,
    )

    model_info = scene_config.get("model_info", {})
    model_selection_config_path = resolve_example_scene_file_path(
        model_info.get("model_selection_config"),
        ext_path=ext_path,
    )
    embedding_model_configs_path = resolve_example_scene_file_path(
        model_info.get("embedding_model_configs"),
        ext_path=ext_path,
    )
    named_model_configs_path = resolve_example_scene_file_path(
        model_info.get("model_configs"),
        ext_path=ext_path,
    )
    node_to_model_map_path = resolve_example_scene_file_path(
        model_info.get("node_to_model_map"),
        ext_path=ext_path,
    )

    session = core_api.setup_workspace(
        cache_dir=str(OUTPUT_DIR / "planner_cache"),
        output_dir=str(OUTPUT_DIR),
        context_data_paths=context_files["actors"] + context_files["objects"],
        node_catalog_paths=node_catalog_paths,
        actor_schema_path=actor_schema_path,
        object_schema_path=object_schema_path,
    )

    print(session.workspace_ready)
    print(session.actors_loaded, session.objects_loaded, session.nodes_loaded)

    runtime_result = await core_api.prepare_runtime(
        session,
        api_key=API_KEY,
        model_selection_config_path=model_selection_config_path,
        embedding_model_configs_path=embedding_model_configs_path,
        named_model_configs_path=named_model_configs_path,
        node_to_model_map_path=node_to_model_map_path,
    )

    if not runtime_result.success:
        raise RuntimeError(runtime_result.message)

    print(runtime_result.chat_model_name)
    print(runtime_result.retriever_ready, runtime_result.action_ir_ready)

    result = await core_api.generate_behavior_tree(
        session,
        SCENARIO,
    )

    if not result.success:
        raise RuntimeError(result.error_message)

    print(result.success)
    print(result.behavior_tree_folder_path)


asyncio.ensure_future(run_planner_example())

```

--------------------------------

### Get stage up axis

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/deprecated/isaacsim.core.utils/docs/index.html

Gets the current up-axis of the USD stage. The example shows 'Z' as the up-axis.

```python
>>> import isaacsim.core.utils.stage as stage_utils
>>>
>>> stage_utils.get_stage_up_axis()
Z

```

--------------------------------

### Get max solver iterations example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/isaacsim.core.simulation_manager/docs/index.html

Shows how to get the maximum number of solver iterations using get_max_solver_iterations().

```python
>>> physics_scene.get_max_solver_iterations()
-1
```

--------------------------------

### run_example_async: Setup stage, Carter Nova, and camera

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/replicator_tutorials/tutorial_replicator_cosmos.html

Sets up the Replicator example by opening a stage, enabling script nodes, disabling capture on play, and setting DLSS to Quality mode (2). It loads the Carter Nova asset with its navigation graph, positions the navigation target, and configures the front hawk camera with tickRate=0 for autotrigger. Optionally advances the timeline by start_delay before returning.

```python
async def run_example_async(
    num_clips,
    num_frames_per_clip,
    capture_interval,
    start_delay=0.0,
    use_instance_id=True,
    segmentation_mapping=None,
):
    assets_root_path = await get_assets_root_path_async()
    if assets_root_path is None:
        print("Assets root path not found, exiting")
        return

    stage_path = assets_root_path + STAGE_URL
    print(f"Opening stage: '{stage_path}'")
    opened, stage = await open_stage_async(stage_path)
    if not opened or stage is None:
        print(f"Could not open stage: '{stage_path}', exiting")
        return

    # Enable script nodes
    carb.settings.get_settings().set_bool("/app/omni.graph.scriptnode/opt_in", True)

    # Disable capture on play on the new stage, data is captured manually using the step function
    rep.orchestrator.set_capture_on_play(False)

    # Set DLSS to Quality mode (2) for best SDG results (Options: 0 (Performance), 1 (Balanced), 2 (Quality), 3 (Auto)
    carb.settings.get_settings().set("rtx/post/dlss/execMode", 2)

    # Load carter nova asset with its navigation graph
    carter_url_path = assets_root_path + CARTER_NAV_ASSET_URL
    print(f"Loading carter nova asset: '{carter_url_path}' at prim path: '{CARTER_NAV_PATH}'")
    add_reference_to_stage(usd_path=carter_url_path, path=CARTER_NAV_PATH)
    XformPrim(CARTER_NAV_PATH, reset_xform_op_properties=True).set_local_poses(
        translations=[CARTER_NAV_POSITION], orientations=[(1.0, 0.0, 0.0, 0.0)]
    )

    # Set the navigation target position
    if not get_prim_at_path(CARTER_NAV_TARGET_PATH).IsValid():
        print(f"Carter navigation target prim not found at path: {CARTER_NAV_TARGET_PATH}, exiting")
        return
    XformPrim(CARTER_NAV_TARGET_PATH, reset_xform_op_properties=True).set_local_poses(
        translations=[CARTER_NAV_TARGET_POSITION], orientations=[(1.0, 0.0, 0.0, 0.0)]
    )

    # Use the carter nova front hawk camera for capturing data
    camera_prim = stage_utils.get_current_stage(backend="usd").GetPrimAtPath(CARTER_CAMERA_PATH)
    if not camera_prim.IsValid():
        print(f"Camera prim not found at path: {CARTER_CAMERA_PATH}, exiting")
        return
    # tickRate=0 forces autotrigger so the sensor cameras stay in sync with rep.orchestrator.step_async
    # under multi-tick rendering.
    if camera_prim.HasAttribute("omni:sensor:tickRate"):
        camera_prim.GetAttribute("omni:sensor:tickRate").Set(0.0)

    # Advance the timeline with the start delay if provided
    if start_delay is not None and start_delay > 0:
        await advance_timeline_by_duration_async(start_delay)
```

--------------------------------

### get_extension_id example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/deprecated/isaacsim.core.utils/docs/index.html

Gets the full extension id for a loaded extension. The example shows the output for "omni.kit.window.stage".

```python
>>> import isaacsim.core.utils.extensions as extensions_utils
>>>
>>> extensions_utils.get_extension_id("omni.kit.window.stage")
omni.kit.window.stage-2.4.3
```

--------------------------------

### Get cube size with get_size()

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/deprecated/isaacsim.core.api/docs/index.html

Shows how to get the edge length of a cube prim. The example returns 1.0 for a unit cube.

```python
>>> prim.get_size()
1.0
```

--------------------------------

### setup_simulation

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/action_and_event_data_generation/tutorial_omni_metropolis_pipeline.html

Runs each registered extension's setup function with its parsed configuration.

```APIDOC
## setup_simulation

### Description
Async function that runs each registered extension's setup function with its parsed configuration. Returns True if all succeeded. Use get_setup_error_message() on failure.

### Returns
- **bool** - True if all setup functions succeeded, False otherwise.
```

--------------------------------

### Run basic camera creation example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/sensors/isaacsim_sensors_camera.html

Runs the basic camera creation example, which creates a camera with rgb and distance_to_image_plane annotators in a warehouse scene.

```bash
./python.sh standalone_examples/api/isaacsim.sensors.experimental.rtx/create_camera_basic.py
```

--------------------------------

### get_dof_index() example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/deprecated/isaacsim.robot.wheeled_robots/docs/index.html

Returns the DOF index for a given DOF name. The example shows getting the index for "panda_finger_joint2".

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

```

--------------------------------

### Code structure for interactive and standalone pick-and-place examples

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/examples/manipulation_franka_pick_place.html

Shows the file dependencies for the interactive and standalone examples. The interactive example starts with pick_place_example.py, which calls pick_place_task.py, which uses the shared controller pick_place.py. The standalone example directly uses the same controller.

```text
# Interactive Example
isaacsim.robot_motion.examples/manipulation/interactive/pick_place/pick_place_example.py
↓
isaacsim.robot_motion.examples/manipulation/pick_place_task.py
↓
isaacsim.robot_motion.examples/manipulation/controllers/pick_place.py

# Standalone Example
standalone_examples/api/isaacsim.robot_motion.examples/manipulation/pick_place.py
↓
isaacsim.robot_motion.examples/manipulation/controllers/pick_place.py
```

--------------------------------

### Run camera annotator devices example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/sensors/isaacsim_sensors_camera.html

Run the example to select between CPU- and CUDA-resident annotator buffers.

```bash
./python.sh standalone_examples/api/isaacsim.sensors.experimental.rtx/camera_annotator_devices.py

```

--------------------------------

### Complete HelloWorld sample with cube creation and property query

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/core_api_tutorials/tutorial_core_hello_world.html

Complete HelloWorld sample that creates a ground plane, a blue cube with collision and rigid body, and queries its pose and velocity in setup_post_load. The setup_post_load method runs after the load button is pressed and after one physics time step to propagate physics handles.

```python
 1import isaacsim.core.experimental.utils.stage as stage_utils
 2import numpy as np
 3from isaacsim.core.experimental.materials import PreviewSurfaceMaterial
 4from isaacsim.core.experimental.objects import Cube
 5from isaacsim.core.experimental.prims import GeomPrim, RigidPrim
 6from isaacsim.examples.base.base_sample_experimental import BaseSample
 7from isaacsim.storage.native import get_assets_root_path
 8
 9
10class HelloWorld(BaseSample):
11    def __init__(self) -> None:
12        super().__init__()
13
14    def setup_scene(self):
15        # Add ground plane
16        ground_plane = stage_utils.add_reference_to_stage(
17            usd_path=get_assets_root_path() + "/Isaac/Environments/Grid/default_environment.usd",
18            path="/World/ground",
19        )
20
21        # Create a blue visual material for the cube
22        visual_material = PreviewSurfaceMaterial("/World/Materials/blue")
23        visual_material.set_input_values("diffuseColor", [0.0, 0.0, 1.0])
24
25        # Create the cube geometry
26        self._cube_shape = Cube(
27            paths="/World/fancy_cube",
28            positions=np.array([[0.0, 0.0, 1.0]]),
29            sizes=[1.0],
30            scales=np.array([[0.5015, 0.5015, 0.5015]]),
31            reset_xform_op_properties=True,
32        )
33
34        # Apply collision and rigid body
35        GeomPrim(paths=self._cube_shape.paths, apply_collision_apis=True)
36        self._cube = RigidPrim(paths=self._cube_shape.paths)
37        self._cube_shape.apply_visual_materials(visual_material)
38
39    # This function is called after load button is pressed
40    # It's called once, after both setup_scene and one physics time step has finished
41    # to propagate physics handles needed to retrieve physical properties
42    async def setup_post_load(self):
43        # -- Begin query properties -- #
44        # Query cube properties using RigidPrim methods
45        positions, orientations = self._cube.get_world_poses()
46        # get_velocities() returns a tuple: (linear_velocities, angular_velocities)
47        linear_velocities, angular_velocities = self._cube.get_velocities()
48
49        # Convert from warp arrays to numpy for printing
50        # Note: experimental APIs return batched results (even for single objects)
51        print("Cube position is : " + str(positions.numpy()[0]))
52        print("Cube's orientation is : " + str(orientations.numpy()[0]))
53        print("Cube's linear velocity is : " + str(linear_velocities.numpy()[0]))
54        # -- End of query properties -- #

```

--------------------------------

### Get physics scene paths example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/isaacsim.core.simulation_manager/docs/index.html

Shows how to get all USD Physics Scene prim paths using the static method get_physics_scene_paths().

```python
>>> from isaacsim.core.simulation_manager import PhysicsScene
>>>
>>> PhysicsScene.get_physics_scene_paths()
['/World/physicsScene']
```

--------------------------------

### get_extension_path example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/deprecated/isaacsim.core.utils/docs/index.html

Gets the path to the loaded extension root directory by its full id. The example first obtains the id and then passes it to get_extension_path.

```python
>>> import isaacsim.core.utils.extensions as extensions_utils
>>>
>>> ext_id = extensions_utils.get_extension_id("omni.kit.window.stage")
>>> extensions_utils.get_extension_path(ext_id)
/home/user/.local/share/ov/pkg/isaac_sim-<version>/kit/exts/omni.kit.window.stage
```

--------------------------------

### NavSDGDemo start method

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/replicator_tutorials/tutorial_replicator_amr_navigation.html

Configures and starts the SDG demo. Sets up environment cycling, randomizes poses and lighting, subscribes to timeline and stage events, and plays the simulation.

```python
def start(
        self,
        num_frames: int = 4,
        out_dir: str | None = None,
        env_urls: list[str | None] | None = None,
        env_interval: int = 1,
        seed: int | None = None,
    ) -> None:
        """Start the SDG demo with the given configuration."""
        print(f"[SDG] Starting")
        if seed is not None:
            rep.set_global_seed(seed)
            random.seed(seed)
        selected_env_urls = env_urls if env_urls is not None else DEFAULT_ENV_URLS
        self._num_frames = num_frames
        self._out_dir = out_dir if out_dir is not None else os.path.join(os.getcwd(), "_out_nav_sdg_demo")
        self._cycled_env_urls = cycle(selected_env_urls)
        self._env_interval = env_interval
        self._frame_counter = 0
        self._trigger_distance = 2.0
        self._load_env()
        self._randomize_dolly_pose()
        self._randomize_dolly_light()
        self._randomize_prop_poses()
        self._setup_sdg()
        app_utils.play()
        self._timeline_sub = carb.eventdispatcher.get_eventdispatcher().observe_event(
            event_name=omni.timeline.GLOBAL_EVENT_CURRENT_TIME_TICKED,
            on_event=self._on_timeline_event,
            observer_name="amr_navigation.NavSDGDemo._on_timeline_event",
        )
        self._stage_event_sub = carb.eventdispatcher.get_eventdispatcher().observe_event(
            event_name=omni.usd.get_context().stage_event_name(omni.usd.StageEventType.CLOSING),
            on_event=self._on_stage_closing_event,
            observer_name="amr_navigation.NavSDGDemo._on_stage_closing_event",
        )
        self._in_running_state = True
```

--------------------------------

### Install and start Isaac Teleop CloudXR runtime

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/isaacsim.replicator.teleop/docs/index.html

Install the Isaac Teleop runtime with CloudXR and retargeters, start the CloudXR runtime in a separate terminal, and optionally source the environment file before launching Isaac Sim. Required for live teleop with input_mode="live".

```bash
python -m pip install "isaacteleop[cloudxr,retargeters]~=1.3.131"

```

```bash
python -m isaacteleop.cloudxr --accept-eula

```

```bash
source ~/.cloudxr/run/cloudxr.env

```

--------------------------------

### Run the Franka pick-and-place FSM example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/state_machine_tutorials/tutorial_state_machines.html

Command to run the library-free FSM demo. Press Play in the viewport and drag a cube while the robot is mid-stack to see the stack recovery path return the held cube before re-stacking.

```bash
./python.sh standalone_examples/tutorials/state_machine/franka_pick_place_fsm.py

```

--------------------------------

### Get coatings of non-visual materials

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/isaacsim.core.experimental.materials/docs/index.html

Returns a list of coatings for each prim. The example shows getting coatings for all prims, resulting in ['none', 'none', 'none'].

```python
>>> # get the coatings of all prims
>>> prims.get_coatings()
['none', 'none', 'none']
```

--------------------------------

### Run ROS 2 Camera manual example on Linux

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/ros2_tutorials/bridge_configuration/tutorial_ros2_python.html

Executes the camera_manual.py standalone example on Linux.

```bash
./python.sh standalone_examples/api/isaacsim.ros2.bridge/camera_manual.py
```

--------------------------------

### Get prim path with get_prim_path

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/py/source/extensions/isaacsim.core.experimental.utils/docs/index.html

Shows how to get the path of a prim instance using get_prim_path. The example defines a Cube prim and retrieves its path.

```python
>>> import isaacsim.core.experimental.utils.prim as prim_utils
>>> import isaacsim.core.experimental.utils.stage as stage_utils
>>>
>>> prim = stage_utils.define_prim(f"/World/Cube", "Cube")
>>> prim_utils.get_prim_path(prim)
'/World/Cube'

```

--------------------------------

### Run annotator device selection example

Source: https://docs.isaacsim.omniverse.nvidia.com/latest/sensors/isaacsim_sensors_camera.html

Runs the example demonstrating CPU vs CUDA-resident annotator buffers.

```bash
./python.sh standalone_examples/api/isaacsim.sensors.experimental.rtx/camera_annotator_devices.py
```
Tokens:
Raw