Download python/examples/body_physics_props.py from e-zorzi/data_for_skillblender: direct link, hf CLI and curl.
- Browser
- Download file 8.96 kB
-
https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/body_physics_props.py
- Command line
-
hf download hf://datasets/e-zorzi/data_for_skillblender/python/examples/body_physics_props.py
-
curl -L -o body_physics_props.py https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/body_physics_props.py
8.96 kB
| """ | |
| Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. | |
| NVIDIA CORPORATION and its licensors retain all intellectual property | |
| and proprietary rights in and to this software, related documentation | |
| and any modifications thereto. Any use, reproduction, disclosure or | |
| distribution of this software and related documentation without an express | |
| license agreement from NVIDIA CORPORATION is strictly prohibited. | |
| Body physics properties example | |
| ------------------------------- | |
| An example that demonstrates how to load rigid body, update its properties | |
| and apply various actions. Specifically, there are three scenarios that | |
| presents the following: | |
| - Load rigid body asset with varying properties | |
| - Modify body shape properties | |
| - Modify body visual properties | |
| - Apply body force | |
| - Apply body linear velocity | |
| """ | |
| from isaacgym import gymutil | |
| from isaacgym import gymapi | |
| # initialize gym | |
| gym = gymapi.acquire_gym() | |
| # parse arguments | |
| args = gymutil.parse_arguments(description="Body Physics Properties Example") | |
| # configure sim | |
| sim_params = gymapi.SimParams() | |
| if args.physics_engine == gymapi.SIM_FLEX: | |
| sim_params.flex.relaxation = 0.9 | |
| sim_params.flex.dynamic_friction = 0.0 | |
| sim_params.flex.static_friction = 0.0 | |
| elif args.physics_engine == gymapi.SIM_PHYSX: | |
| sim_params.physx.solver_type = 1 | |
| sim_params.physx.num_position_iterations = 4 | |
| sim_params.physx.num_velocity_iterations = 1 | |
| sim_params.physx.num_threads = args.num_threads | |
| sim_params.physx.use_gpu = args.use_gpu | |
| sim_params.use_gpu_pipeline = False | |
| if args.use_gpu_pipeline: | |
| print("WARNING: Forcing CPU pipeline.") | |
| sim = gym.create_sim(args.compute_device_id, args.graphics_device_id, args.physics_engine, sim_params) | |
| if sim is None: | |
| print("*** Failed to create sim") | |
| quit() | |
| # create viewer using the default camera properties | |
| viewer = gym.create_viewer(sim, gymapi.CameraProperties()) | |
| if viewer is None: | |
| raise ValueError('*** Failed to create viewer') | |
| # add ground plane | |
| plane_params = gymapi.PlaneParams() | |
| plane_params.static_friction = 0.0 | |
| plane_params.dynamic_friction = 0.0 | |
| gym.add_ground(sim, plane_params) | |
| # set up the env grid | |
| num_envs = 3 | |
| spacing = 1.8 | |
| env_lower = gymapi.Vec3(-spacing, 0.0, -spacing) | |
| env_upper = gymapi.Vec3(spacing, spacing, spacing) | |
| # create list to mantain environment and asset handles | |
| envs = [] | |
| box_handles = [] | |
| actor_handles = [] | |
| # create box assets w/ varying densities (measured in kg/m^3) | |
| box_size = 0.2 | |
| box_densities = [8., 32., 1024.] | |
| for dx in range(3): | |
| # AssetOptions enables loading assets with different properties | |
| # Properties include density, angularDamping, maxAngularVelocity, linearDamping, maxLinearVelocity etc. | |
| asset_options = gymapi.AssetOptions() | |
| asset_options.density = box_densities[dx] | |
| asset_box = gym.create_box(sim, box_size, box_size, box_size, asset_options) | |
| box_handles.append(asset_box) | |
| # create capsule asset | |
| asset_options = gymapi.AssetOptions() | |
| asset_options.density = 100. | |
| asset_capsule = gym.create_capsule(sim, 0.2, 0.2, asset_options) | |
| # create ball asset with gravity disabled | |
| asset_root = "../../assets" | |
| asset_file = "urdf/ball.urdf" | |
| asset_options = gymapi.AssetOptions() | |
| asset_options.disable_gravity = True | |
| print("Loading asset '%s' from '%s'" % (asset_file, asset_root)) | |
| asset_ball = gym.load_asset(sim, asset_root, asset_file, asset_options) | |
| # create static box asset | |
| asset_options.fix_base_link = True | |
| asset_box = gym.create_box(sim, 0.5, 0.1, 0.5, asset_options) | |
| print('Creating %d environments' % num_envs) | |
| for i in range(num_envs): | |
| # create env | |
| env = gym.create_env(sim, env_lower, env_upper, 1) | |
| envs.append(env) | |
| # Scenario 1: Source boxes collide with target boxes with varying densities | |
| if i == 0: | |
| # add moving boxes to env | |
| for dx in range(3): | |
| name = 'moving_box_{}'.format(dx) | |
| actor_handles.append(gym.create_actor(env, box_handles[0], gymapi.Transform(p=gymapi.Vec3(dx, 0.1, 0.)), name, i, 0)) | |
| # set shape physics properties for moving boxes | |
| shape_props = gym.get_actor_rigid_shape_properties(env, actor_handles[-1]) | |
| # set_actor_rigid_shape_properties enables setting shape properties for rigid body | |
| # Properties include friction, rolling_friction, torsion_friction, restitution etc. | |
| shape_props[0].friction = 0. | |
| shape_props[0].rolling_friction = 0. | |
| shape_props[0].torsion_friction = 0. | |
| gym.set_actor_rigid_shape_properties(env, actor_handles[-1], shape_props) | |
| # set visual property like color to moving boxes | |
| gym.set_rigid_body_color(env, actor_handles[-1], 0, gymapi.MESH_VISUAL, gymapi.Vec3(0., 1., 0.)) | |
| # apply linear velocity | |
| gym.set_rigid_linear_velocity(env, | |
| gym.get_rigid_handle(env, name, gym.get_actor_rigid_body_names(env, actor_handles[0])[0]), | |
| gymapi.Vec3(0., 0., 2.)) | |
| # add target boxes to env | |
| target_box_names = ['target_box_low', 'target_box_med', 'target_box_high'] | |
| target_box_positions = [gymapi.Vec3(0., 0.1, 2.), gymapi.Vec3(1, 0.1, 2.), gymapi.Vec3(2, 0.1, 2.)] | |
| target_box_color = [gymapi.Vec3(0., 1., 0.), gymapi.Vec3(2, 0.1, 2.), gymapi.Vec3(1., 0., 0.)] | |
| for dx in range(3): | |
| actor_handles.append(gym.create_actor(env, box_handles[dx], gymapi.Transform(p=target_box_positions[dx]), target_box_names[dx], i, 0)) | |
| # set shape physics properties for target boxes | |
| shape_props = gym.get_actor_rigid_shape_properties(env, actor_handles[-1]) | |
| # set coeffecient of friction | |
| shape_props[0].friction = 0. | |
| shape_props[0].rolling_friction = 0. | |
| shape_props[0].torsion_friction = 0. | |
| gym.set_actor_rigid_shape_properties(env, actor_handles[-1], shape_props) | |
| # set visual property like color to target boxes | |
| gym.set_rigid_body_color(env, actor_handles[-1], 0, gymapi.MESH_VISUAL, target_box_color[dx]) | |
| # Scenario 2: Capsule with varying restitution and complince dropped on a hanging box | |
| if i == 1: | |
| # add box actor | |
| pose = gymapi.Transform() | |
| pose.p = gymapi.Vec3(0.0, 0.5, 0.0) | |
| pose.r = gymapi.Quat(0, 0, 0, 1) | |
| box_handle = gym.create_actor(env, asset_box, pose, "actor1", i, 0) | |
| actor_handles.append(box_handle) | |
| # set restitution for box actor | |
| shape_props = gym.get_actor_rigid_shape_properties(env, box_handle) | |
| shape_props[0].restitution = 1 | |
| shape_props[0].compliance = 0.5 | |
| gym.set_actor_rigid_shape_properties(env, box_handle, shape_props) | |
| # add capsule actor | |
| pose.p = gymapi.Vec3(0.0, 2.0, 0.0) | |
| capsule_handle = gym.create_actor(env, asset_capsule, pose, "actor2", i, 0) | |
| # set restitution for capsule actor | |
| shape_props = gym.get_actor_rigid_shape_properties(env, capsule_handle) | |
| shape_props[0].restitution = 1 | |
| shape_props[0].compliance = 0.5 | |
| gym.set_actor_rigid_shape_properties(env, capsule_handle, shape_props) | |
| # Scenario 3: Balls with gravity enabled and disabled | |
| if i == 2: | |
| # create ball pyramid | |
| pose = gymapi.Transform() | |
| pose.r = gymapi.Quat(0, 0, 0, 1) | |
| num_balls = 3 | |
| ball_radius = .2 | |
| ball_spacing = 2.5 * ball_radius | |
| y = 1 * (num_balls - 1) * ball_spacing | |
| while num_balls > 0: | |
| pose.p = gymapi.Vec3(num_balls * 0.001, 1. + y, 0) | |
| # create ball actor | |
| ball_handle = gym.create_actor(env, asset_ball, pose, None) | |
| color_vec = [1, .2, .2] | |
| if num_balls != 2: | |
| color_vec = [.3, .8, .3] | |
| # Enable gravity back on the middle ball | |
| body_props = gym.get_actor_rigid_body_properties(env, ball_handle) | |
| for b in range(len(body_props)): | |
| body_props[b].flags = gymapi.RIGID_BODY_NONE | |
| gym.set_actor_rigid_body_properties(env, ball_handle, body_props) | |
| # set ball color | |
| color = gymapi.Vec3(color_vec[0], color_vec[1], color_vec[2]) | |
| gym.set_rigid_body_color(env, ball_handle, 0, gymapi.MESH_VISUAL_AND_COLLISION, color) | |
| y += ball_spacing | |
| num_balls -= 1 | |
| # look at the first env | |
| cam_pos = gymapi.Vec3(6, 4.5, 3) | |
| cam_target = gymapi.Vec3(-0.8, 0.5, 0) | |
| gym.viewer_camera_look_at(viewer, None, cam_pos, cam_target) | |
| while not gym.query_viewer_has_closed(viewer): | |
| # step the physics | |
| gym.simulate(sim) | |
| gym.fetch_results(sim, True) | |
| # update the viewer | |
| gym.step_graphics(sim) | |
| gym.draw_viewer(viewer, sim, True) | |
| # Wait for dt to elapse in real time. | |
| # This synchronizes the physics simulation with the rendering rate. | |
| gym.sync_frame_time(sim) | |
| print('Done') | |
| gym.destroy_viewer(viewer) | |
| gym.destroy_sim(sim) | |