与刚性物体交互

与刚性物体交互#

在以前的教程中，我们学习了独立脚本的基本工作原理以及如何将不同的对象（或 对象 ）生成到仿真中。本教程展示了如何创建和与刚性物体交互。为此，我们将使用 Isaac Lab 中提供的 assets.RigidObject 类。

代码#

该教程对应于 scripts/tutorials/01_assets 目录中的 run_rigid_object.py 脚本。

run_rigid_object.py 的代码
  1# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
  2# All rights reserved.
  3#
  4# SPDX-License-Identifier: BSD-3-Clause
  5
  6"""
  7This script demonstrates how to create a rigid object and interact with it.
  8
  9.. code-block:: bash
 10
 11    # Usage
 12    ./isaaclab.sh -p scripts/tutorials/01_assets/run_rigid_object.py
 13
 14"""
 15
 16"""Launch Isaac Sim Simulator first."""
 17
 18
 19import argparse
 20
 21from isaaclab.app import AppLauncher
 22
 23# add argparse arguments
 24parser = argparse.ArgumentParser(description="Tutorial on spawning and interacting with a rigid object.")
 25# append AppLauncher cli args
 26AppLauncher.add_app_launcher_args(parser)
 27# parse the arguments
 28args_cli = parser.parse_args()
 29
 30# launch omniverse app
 31app_launcher = AppLauncher(args_cli)
 32simulation_app = app_launcher.app
 33
 34"""Rest everything follows."""
 35
 36import torch
 37
 38import isaaclab.sim as sim_utils
 39import isaaclab.utils.math as math_utils
 40from isaaclab.assets import RigidObject, RigidObjectCfg
 41from isaaclab.sim import SimulationContext
 42
 43
 44def design_scene():
 45    """Designs the scene."""
 46    # Ground-plane
 47    cfg = sim_utils.GroundPlaneCfg()
 48    cfg.func("/World/defaultGroundPlane", cfg)
 49    # Lights
 50    cfg = sim_utils.DomeLightCfg(intensity=2000.0, color=(0.8, 0.8, 0.8))
 51    cfg.func("/World/Light", cfg)
 52
 53    # Create separate groups called "Origin1", "Origin2", "Origin3"
 54    # Each group will have a robot in it
 55    origins = [[0.25, 0.25, 0.0], [-0.25, 0.25, 0.0], [0.25, -0.25, 0.0], [-0.25, -0.25, 0.0]]
 56    for i, origin in enumerate(origins):
 57        sim_utils.create_prim(f"/World/Origin{i}", "Xform", translation=origin)
 58
 59    # Rigid Object
 60    cone_cfg = RigidObjectCfg(
 61        prim_path="/World/Origin.*/Cone",
 62        spawn=sim_utils.ConeCfg(
 63            radius=0.1,
 64            height=0.2,
 65            rigid_props=sim_utils.RigidBodyPropertiesCfg(),
 66            mass_props=sim_utils.MassPropertiesCfg(mass=1.0),
 67            collision_props=sim_utils.CollisionPropertiesCfg(),
 68            visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 1.0, 0.0), metallic=0.2),
 69        ),
 70        init_state=RigidObjectCfg.InitialStateCfg(),
 71    )
 72    cone_object = RigidObject(cfg=cone_cfg)
 73
 74    # return the scene information
 75    scene_entities = {"cone": cone_object}
 76    return scene_entities, origins
 77
 78
 79def run_simulator(sim: sim_utils.SimulationContext, entities: dict[str, RigidObject], origins: torch.Tensor):
 80    """Runs the simulation loop."""
 81    # Extract scene entities
 82    # note: we only do this here for readability. In general, it is better to access the entities directly from
 83    #   the dictionary. This dictionary is replaced by the InteractiveScene class in the next tutorial.
 84    cone_object = entities["cone"]
 85    # Define simulation stepping
 86    sim_dt = sim.get_physics_dt()
 87    sim_time = 0.0
 88    count = 0
 89    # Simulate physics
 90    while simulation_app.is_running():
 91        # reset
 92        if count % 250 == 0:
 93            # reset counters
 94            sim_time = 0.0
 95            count = 0
 96            # reset root state
 97            root_state = cone_object.data.default_root_state.clone()
 98            # sample a random position on a cylinder around the origins
 99            root_state[:, :3] += origins
100            root_state[:, :3] += math_utils.sample_cylinder(
101                radius=0.1, h_range=(0.25, 0.5), size=cone_object.num_instances, device=cone_object.device
102            )
103            # write root state to simulation
104            cone_object.write_root_pose_to_sim(root_state[:, :7])
105            cone_object.write_root_velocity_to_sim(root_state[:, 7:])
106            # reset buffers
107            cone_object.reset()
108            print("----------------------------------------")
109            print("[INFO]: Resetting object state...")
110        # apply sim data
111        cone_object.write_data_to_sim()
112        # perform step
113        sim.step()
114        # update sim-time
115        sim_time += sim_dt
116        count += 1
117        # update buffers
118        cone_object.update(sim_dt)
119        # print the root position
120        if count % 50 == 0:
121            print(f"Root position (in world): {cone_object.data.root_pos_w}")
122
123
124def main():
125    """Main function."""
126    # Load kit helper
127    sim_cfg = sim_utils.SimulationCfg(device=args_cli.device)
128    sim = SimulationContext(sim_cfg)
129    # Set main camera
130    sim.set_camera_view(eye=[1.5, 0.0, 1.0], target=[0.0, 0.0, 0.0])
131    # Design scene
132    scene_entities, scene_origins = design_scene()
133    scene_origins = torch.tensor(scene_origins, device=sim.device)
134    # Play the simulator
135    sim.reset()
136    # Now we are ready!
137    print("[INFO]: Setup complete...")
138    # Run the simulator
139    run_simulator(sim, scene_entities, scene_origins)
140
141
142if __name__ == "__main__":
143    # run the main function
144    main()
145    # close sim app
146    simulation_app.close()

代码解释#

在此脚本中，我们将 main 函数拆分为两个单独的函数，这两个函数强调了在仿真器中设置任何仿真的两个主要步骤:

  1. 设计场景: 顾名思义，这一部分负责将所有对象添加到场景中。

  2. 运行仿真: 这部分负责推进仿真器，与场景中的对象交互，例如改变它们的姿势，并对其施加任何命令。

这两个步骤之间的区别是必需的，因为只有在第一步完成并且仿真器被重置后，第二步才会发生。一旦仿真器被重置（自动播放仿真），就不应该再向场景中添加新的（带有物理效果）对象，因为这可能会导致意外行为。但是，可以通过它们各自的句柄与对象进行交互。

设计场景#

与之前的教程类似，我们使用一个地面平面和一个光源填充场景。此外，我们使用 assets.RigidObject 类将一个刚性物体添加到场景中。该类负责在输入路径处生成对象，同时初始化其对应的刚性物理句柄。

在本教程中，我们使用与 Spawn Objects 教程中刚性锥体类似的生成配置创建一个圆锥形刚性物体。唯一的区别是现在我们将生成配置封装到 assets.RigidObjectCfg 类中。该类包含有关资产生成策略、默认初始状态和其他元信息的信息。当将此类传递给 assets.RigidObject 类时，当播放仿真时，它会生成对象并初始化相应的物理句柄。

作为多次生成刚性物体原语的示例，我们创建其父级 Xform 原语 /World/Origin{i} ，它们对应不同的生成位置。当将正则表达式 /World/Origin.*/Cone 传递给 assets.RigidObject 类时，它会在每个 /World/Origin{i} 位置生成刚性物体原语。例如，如果场景中存在 /World/Origin1 和 /World/Origin2 ，则刚性物体原语会分别生成在 /World/Origin1/Cone 和 /World/Origin2/Cone 位置。

    # Create separate groups called "Origin1", "Origin2", "Origin3"
    # Each group will have a robot in it
    origins = [[0.25, 0.25, 0.0], [-0.25, 0.25, 0.0], [0.25, -0.25, 0.0], [-0.25, -0.25, 0.0]]
    for i, origin in enumerate(origins):
        sim_utils.create_prim(f"/World/Origin{i}", "Xform", translation=origin)

    # Rigid Object
    cone_cfg = RigidObjectCfg(
        prim_path="/World/Origin.*/Cone",
        spawn=sim_utils.ConeCfg(
            radius=0.1,
            height=0.2,
            rigid_props=sim_utils.RigidBodyPropertiesCfg(),
            mass_props=sim_utils.MassPropertiesCfg(mass=1.0),
            collision_props=sim_utils.CollisionPropertiesCfg(),
            visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 1.0, 0.0), metallic=0.2),
        ),
        init_state=RigidObjectCfg.InitialStateCfg(),
    )
    cone_object = RigidObject(cfg=cone_cfg)

因为我们想要与刚性物体交互，我们将此实体传递回主函数。然后，该实体用于在仿真循环中与刚性物体交互。在后续教程中，我们将看到如何使用 scene.InteractiveScene 类更方便地处理多个场景实体。

    # return the scene information
    scene_entities = {"cone": cone_object}
    return scene_entities, origins

运行仿真循环#

我们修改了仿真循环以与刚性物体交互，包括三个步骤——在固定间隔重置仿真状态，推进仿真，以及更新刚性物体的内部缓冲区。为了方便本教程，我们从场景字典中提取刚性物体的实体并将其存储在一个变量中。

重置仿真状态#

为了重置生成的刚性物体对象的仿真状态，我们需要设置其姿势和速度。它们共同定义了生成的刚性物体对象的根状态。重要的是要注意，此状态定义在 仿真世界坐标系 中，而不是它们父级 Xform 对象的坐标系。这是因为物理引擎只能理解世界坐标系，而不能理解父级 Xform 对象的坐标系。因此，在设置之前，我们需要将刚性物体对象的期望状态转换为世界坐标系。

我们使用 assets.RigidObject.data.default_root_state 属性获取生成的刚性物体对象的默认根状态。该默认状态可以从 assets.RigidObjectCfg.init_state 属性中配置，我们在本教程中将其保留为单位状态。然后，我们随机化根状态的平移，并使用 assets.RigidObject.write_root_pose_to_sim() 和 assets.RigidObject.write_root_velocity_to_sim() 方法设置刚性物体对象的期望状态。顾名思义，此方法将刚性物体对象的根状态写入仿真缓冲区。

            # reset root state
            root_state = cone_object.data.default_root_state.clone()
            # sample a random position on a cylinder around the origins
            root_state[:, :3] += origins
            root_state[:, :3] += math_utils.sample_cylinder(
                radius=0.1, h_range=(0.25, 0.5), size=cone_object.num_instances, device=cone_object.device
            )
            # write root state to simulation
            cone_object.write_root_pose_to_sim(root_state[:, :7])
            cone_object.write_root_velocity_to_sim(root_state[:, 7:])
            # reset buffers
            cone_object.reset()

推进仿真#

在推进仿真之前，我们执行 assets.RigidObject.write_data_to_sim() 方法。此方法将其他数据，例如外部力，写入仿真缓冲区。在本教程中，我们没有对刚性物体施加任何外部力，因此此方法不是必需的。但是，为了完整性，我们还是加入了它。

        # apply sim data
        cone_object.write_data_to_sim()

更新状态#

在推进仿真后，我们使用 assets.RigidObject.update() 方法更新刚性物体对象的内部缓冲区，以反映其在 assets.RigidObject.data 属性中的新状态。

        # update buffers
        cone_object.update(sim_dt)

代码执行#

现在我们已经浏览了代码，让我们运行脚本并查看结果:

./isaaclab.sh -p scripts/tutorials/01_assets/run_rigid_object.py

这应该打开一个场景，上面有一个地面平面、灯光和几个绿色圆锥体。圆锥体应该从一个随机高度掉落并落到地面上。要停止仿真，你可以关闭窗口，或者在 UI 中按下 STOP 按钮，或者在终端中按下 Ctrl+C

run_rigid_object.py 的结果

本教程展示了如何生成刚性物体并将它们封装在一个 RigidObject 类中以初始化它们的物理句柄，从而允许设置和获取它们的状态。在下一个教程中，我们将看到如何与由关节连接的一系列刚性物体组成的关节物体进行交互。

目录