IsaacLab最新2025教程(4)-导入刚体和柔性物体并配置物理参数

前言

机器人和物体的交互数据在强化学习中很重要，而且和domain randomization有很强的联系，依然还是根据官网教程介绍一下流程，但是isaaclab教程没有导入自定义物体的教程，后续有时间会出一个加载自定义object的帖子，比如urdf，stl，step等格式的教程，不过这个主要是isaacsim的内容了。

下面的代码综合了两个教程的内容，教程链接：

Interacting with a rigid object — Isaac Lab Documentation

Interacting with a deformable object — Isaac Lab Documentation

代码注释

接下来，我们设计一个包含可变形物体和刚性物体的仿真场景。场景中包括地面、灯光、可变形立方体和刚性圆锥体。

import torch
import isaacsim.core.utils.prims as prim_utils
import isaaclab.sim as sim_utils
import isaaclab.utils.math as math_utils
from isaaclab.assets import DeformableObject, DeformableObjectCfg, RigidObject, RigidObjectCfg
from isaaclab.sim import SimulationContext

def design_scene():

    ## 设置地板，灯光什么。
    cfg = sim_utils.GroundPlaneCfg()
    cfg.func("/World/defaultGroundPlane", cfg)

    cfg = sim_utils.DomeLightCfg(intensity=2000.0, color=(0.8, 0.8, 0.8))
    cfg.func("/World/Light", cfg)

    # 创建并行环境
    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):
        prim_utils.create_prim(f"/World/Origin{i}", "Xform", translation=origin)

    # 可变形物体
    cfg = DeformableObjectCfg(
        prim_path="/World/Origin.*/Cube_deformable",
        spawn=sim_utils.MeshCuboidCfg(
            size=(0.2, 0.2, 0.2),
            deformable_props=sim_utils.DeformableBodyPropertiesCfg(rest_offset=0.0, contact_offset=0.001),
            visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.5, 0.1, 0.0)),
            physics_material=sim_utils.DeformableBodyMaterialCfg(poissons_ratio=0.4, youngs_modulus=1e5),
        ),
        init_state=DeformableObjectCfg.InitialStateCfg(pos=(0.0, 0.0, 1.0)),
        debug_vis=True,
    )
    deformcube_object = DeformableObject(cfg=cfg)

    # 刚性物体
    cfg = RigidObjectCfg(
        prim_path="/World/Origin.*/Cube_rigid",
        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.5, 0.1, 0.0)),
        ),
        init_state=RigidObjectCfg.InitialStateCfg(pos=(1.0, 1.0, 0.0)),
        debug_vis=True,
    )
    rigidcube_object = RigidObject(cfg=cfg)

    # 返回场景中的实体和原点信息
    scene_entities = {"deformcube_object": deformcube_object, "rigidcube_object": rigidcube_object}
    return scene_entities, origins

 在场景设计完成后，我们可以设计可以观察到可变形物体和刚性物体的行为的仿真运行过程。

def run_simulator(sim: sim_utils.SimulationContext, entities: dict[str, DeformableObject], origins: torch.Tensor):
    cube_object = entities["deformcube_object"]
    rigid_cube_object = entities["rigidcube_object"]

    # 定义仿真步长
    sim_dt = sim.get_physics_dt()
    sim_time = 0.0
    count = 0

    # 可变形物体的节点运动学目标
    # 这个nodal其实就类似与拎东西的那个受力点，相当于施加了一个外力揪着可形变物体四处移动
    nodal_kinematic_target = cube_object.data.nodal_kinematic_target.clone()

    # 仿真循环
    while simulation_app.is_running():
        # 每 250 步重置一次
        if count % 250 == 0:
            sim_time = 0.0
            count = 0
            root_state = rigid_cube_object.data.default_root_state.clone()
            root_state[:, :3] += origins
            root_state[:, :3] += math_utils.sample_cylinder(
                radius=0.1, h_range=(0.25, 0.5), size=rigid_cube_object.num_instances, device=rigid_cube_object.device
            )
            rigid_cube_object.write_root_pose_to_sim(root_state[:, :7])
            rigid_cube_object.write_root_velocity_to_sim(root_state[:, 7:])

            # 重置可变形物体的节点状态
            nodal_state = cube_object.data.default_nodal_state_w.clone()

            # 对物体施加随机姿态
            pos_w = torch.rand(cube_object.num_instances, 3, device=sim.device) * 0.1 + origins
            quat_w = math_utils.random_orientation(cube_object.num_instances, device=sim.device)
            nodal_state[..., :3] = cube_object.transform_nodal_pos(nodal_state[..., :3], pos_w, quat_w)

            # 将节点状态写入仿真
            cube_object.write_nodal_state_to_sim(nodal_state)

            # 将节点状态写入运动学目标并释放所有顶点
            nodal_kinematic_target[..., :3] = nodal_state[..., :3]
            nodal_kinematic_target[..., 3] = 1.0
            cube_object.write_nodal_kinematic_target_to_sim(nodal_kinematic_target)

            # 重置缓冲区
            cube_object.reset()

            print("----------------------------------------")
            print("[INFO]: Resetting object state...")

        # 更新索引为 0 和 3 的立方体的运动学目标
        nodal_kinematic_target[[0, 3], 0, 2] += 0.001
        nodal_kinematic_target[[0, 3], 0, 3] = 0.0  # 0: 约束, 1: 自由
        cube_object.write_nodal_kinematic_target_to_sim(nodal_kinematic_target)

        # 将内部数据写入仿真
        cube_object.write_data_to_sim()

        # 执行仿真步
        sim.step()

        # 更新仿真时间
        sim_time += sim_dt
        count += 1

        # 更新缓冲区
        cube_object.update(sim_dt)

        # 每 50 步打印一次根位置
        if count % 50 == 0:
            print(f"Root position (in world): {cube_object.data.root_pos_w[:, :3]}")

def main():
    """Main function."""
    # Load kit helper
    sim_cfg = sim_utils.SimulationCfg(device=args_cli.device)
    sim = SimulationContext(sim_cfg)

    # Set main camera
    sim.set_camera_view(eye=[3.0, 0.0, 1.0], target=[0.0, 0.0, 0.5])

    # Design scene
    scene_entities, scene_origins = design_scene()
    scene_origins = torch.tensor(scene_origins, device=sim.device)

    # Play the simulator
    sim.reset()

    print("[INFO]: Setup complete...")

    # Run the simulator
    run_simulator(sim, scene_entities, scene_origins)

if __name__ == "__main__":
    # Run the main function
    main()

    # Close sim app
    simulation_app.close()

让我们看一下效果图：