Download python/examples/large_mass_ratio.py from e-zorzi/data_for_skillblender: direct link, hf CLI and curl.
- Browser
- Download file 6.42 kB
-
https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/large_mass_ratio.py
- Command line
-
hf download hf://datasets/e-zorzi/data_for_skillblender/python/examples/large_mass_ratio.py
-
curl -L -o large_mass_ratio.py https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/large_mass_ratio.py
6.42 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. | |
| Large mass-ratio test | |
| ------------------------------- | |
| A test of the simulation stability stacks of boxes with large mass ratio. There are two scenarios available: | |
| - Same size boxes, the next level boxes are 10 times heavier compared to the box it is standing on | |
| - Inverted pyramid of boxes, they have the same density but the next level boxes are 4 times larger and 4*4*4 = 64 heavier than previous level one | |
| """ | |
| from isaacgym import gymutil | |
| from isaacgym import gymapi | |
| from math import sqrt | |
| # initialize gym | |
| gym = gymapi.acquire_gym() | |
| # parse arguments | |
| args = gymutil.parse_arguments( | |
| description="Large Mass Ratio Test", | |
| custom_parameters=[ | |
| {"name": "--num_envs", "type": int, "default": 100, "help": "Number of environments to create"}, | |
| {"name": "--inverted_pyramid_test", "action": "store_true", "help": "Run test with stack of boxes of increasing sizes but the same density"}]) | |
| inverted_pyramid_test = args.inverted_pyramid_test | |
| # configure sim | |
| sim_params = gymapi.SimParams() | |
| if args.physics_engine == gymapi.SIM_FLEX: | |
| sim_params.substeps = 6 | |
| sim_params.flex.num_inner_iterations = 5 | |
| sim_params.flex.num_inner_iterations = 24 | |
| sim_params.flex.relaxation = 0.7 | |
| sim_params.flex.warm_start = 0.25 | |
| displacement = 0.02 | |
| elif args.physics_engine is gymapi.SIM_PHYSX: | |
| sim_params.substeps = 6 | |
| sim_params.physx.solver_type = 1 | |
| sim_params.physx.num_position_iterations = 100 | |
| sim_params.physx.num_velocity_iterations = 0 | |
| sim_params.physx.num_threads = args.num_threads | |
| sim_params.physx.use_gpu = args.use_gpu | |
| sim_params.physx.rest_offset = 0.001 | |
| displacement = 0.002 | |
| 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() | |
| gym.add_ground(sim, gymapi.PlaneParams()) | |
| # set up the env grid | |
| num_envs = args.num_envs | |
| num_per_row = int(sqrt(num_envs)) | |
| spacing = 4.5 | |
| if inverted_pyramid_test: | |
| spacing = 12.0 | |
| # look at the first env | |
| cam_pos = gymapi.Vec3(8.0, 6.5, 3.0) | |
| cam_target = gymapi.Vec3(10.0, 6.0, 10.0) | |
| if not inverted_pyramid_test: | |
| cam_pos.y = 3.0 | |
| cam_target.y = 1.9 | |
| gym.viewer_camera_look_at(viewer, None, cam_pos, cam_target) | |
| box_color = gymapi.Vec3(0.1, 0.9, 0.05) | |
| 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 = [] | |
| box_sizes = [] | |
| actor_handles = [] | |
| # create box assets w/ varying densities (measured in kg/m^3) | |
| box_size = 0.5 | |
| box_density = 1 | |
| # AssetOptions enables loading assets with different properties | |
| # Properties include density, angularDamping, maxAngularVelocity, linearDamping, maxLinearVelocity etc. | |
| asset_options = gymapi.AssetOptions() | |
| asset_options.thickness = 0.005 | |
| if not inverted_pyramid_test: | |
| stack_height = 5 | |
| for dx in range(stack_height): | |
| asset_options.density = box_density | |
| asset_box = gym.create_box(sim, box_size, box_size, box_size, asset_options) | |
| box_handles.append(asset_box) | |
| box_density *= 10 | |
| for i in range(num_envs): | |
| # create env | |
| env = gym.create_env(sim, env_lower, env_upper, num_per_row) | |
| envs.append(env) | |
| box_color = gymapi.Vec3(0.2, 0.75, 0.18) | |
| color_step = box_color.y / (stack_height - 1) | |
| # add moving boxes to env | |
| for b in range(stack_height): | |
| name = 'box_{}'.format(b) | |
| actor_handles.append(gym.create_actor(env, box_handles[b], gymapi.Transform( | |
| p=gymapi.Vec3(0., 0.5 * box_size + (box_size + displacement) * b + 0.001, 0.)), name, i, 0)) | |
| gym.set_rigid_body_color(env, actor_handles[-1], 0, gymapi.MESH_VISUAL, box_color) | |
| box_color.x += 0.85 * color_step * b | |
| box_color.y -= color_step * b | |
| box_color.z -= 0.04 * b | |
| else: | |
| stack_height = 5 | |
| scale_factor = 2 | |
| color_step = box_color.x / (stack_height - 1) | |
| new_box_size = box_size | |
| for dx in range(stack_height): | |
| asset_options.density = 100 | |
| asset_box = gym.create_box(sim, new_box_size, new_box_size, new_box_size, asset_options) | |
| box_handles.append(asset_box) | |
| box_sizes.append(new_box_size) | |
| new_box_size *= scale_factor | |
| print('Creating %d environments' % num_envs) | |
| for i in range(num_envs): | |
| # create env | |
| env = gym.create_env(sim, env_lower, env_upper, num_per_row) | |
| envs.append(env) | |
| start_height = 0.001 | |
| box_color = gymapi.Vec3(0.9, 0.25, 0.15) | |
| color_step = box_color.x / (stack_height - 1) | |
| # add moving boxes to env | |
| for b in range(stack_height): | |
| name = 'box_{}'.format(b) | |
| start_height += (0.5 * box_sizes[b] + displacement) | |
| actor_handles.append(gym.create_actor(env, box_handles[b], gymapi.Transform(p=gymapi.Vec3(0., start_height, 0.)), name, i, 0)) | |
| box_color.x -= 0.9 * color_step * b | |
| box_color.y -= 0.02 * color_step * b | |
| box_color.z += 0.8 * color_step * b | |
| gym.set_rigid_body_color(env, actor_handles[-1], 0, gymapi.MESH_VISUAL, box_color) | |
| start_height += 0.5 * box_sizes[b] | |
| 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) | |