Download python/examples/interop_torch.py from e-zorzi/data_for_skillblender: direct link, hf CLI and curl.
- Browser
- Download file 6.7 kB
-
https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/interop_torch.py
- Command line
-
hf download hf://datasets/e-zorzi/data_for_skillblender/python/examples/interop_torch.py
-
curl -L -o interop_torch.py https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/interop_torch.py
6.7 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. | |
| """ | |
| import numpy as np | |
| import imageio | |
| import math | |
| import os | |
| from isaacgym import gymapi | |
| from isaacgym import gymutil | |
| from isaacgym import gymtorch | |
| import torch | |
| gym = gymapi.acquire_gym() | |
| # Parse arguments | |
| args = gymutil.parse_arguments(description="PyTorch tensor interop example", | |
| custom_parameters=[ | |
| {"name": "--headless", "action": "store_true", "help": ""}]) | |
| # configure sim | |
| sim_params = gymapi.SimParams() | |
| sim_params.gravity = gymapi.Vec3(0.0, -9.8, 0.0) | |
| if args.physics_engine == gymapi.SIM_FLEX: | |
| sim_params.flex.solver_type = 5 | |
| sim_params.flex.num_outer_iterations = 4 | |
| sim_params.flex.num_inner_iterations = 8 | |
| sim_params.flex.relaxation = 0.75 | |
| sim_params.flex.warm_start = 0.4 | |
| 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 | |
| # This determines whether physics tensors are on CPU or GPU | |
| sim_params.use_gpu_pipeline = True | |
| if not args.use_gpu_pipeline: | |
| print("Warning: Forcing GPU 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() | |
| ball_asset = gym.create_sphere(sim, 0.5, None) | |
| use_viewer = not args.headless | |
| # create viewer | |
| if use_viewer: | |
| viewer = gym.create_viewer(sim, gymapi.CameraProperties()) | |
| if viewer is None: | |
| print("*** Failed to create viewer") | |
| quit() | |
| else: | |
| viewer = None | |
| # Add ground plane | |
| plane_params = gymapi.PlaneParams() | |
| gym.add_ground(sim, plane_params) | |
| # set up env grid | |
| num_envs = 16 | |
| envs_per_row = int(math.sqrt(num_envs)) | |
| spacing = 2.0 | |
| env_lower = gymapi.Vec3(-spacing, 0.0, -spacing) | |
| env_upper = gymapi.Vec3(spacing, spacing, spacing) | |
| envs = [] | |
| cams = [] | |
| cam_tensors = [] | |
| # create envs | |
| for i in range(num_envs): | |
| # create env | |
| env = gym.create_env(sim, env_lower, env_upper, envs_per_row) | |
| envs.append(env) | |
| # add actor | |
| pose = gymapi.Transform() | |
| pose.p = gymapi.Vec3(0.0, 5.0, 0.0) | |
| pose.r = gymapi.Quat(0.0, 0.0, 0.0, 1.0) | |
| actor_handle = gym.create_actor(env, ball_asset, pose, "ball", i, 0) | |
| # set ball restitution | |
| props = gym.get_actor_rigid_shape_properties(env, actor_handle) | |
| props[0].restitution = 0.9 | |
| gym.set_actor_rigid_shape_properties(env, actor_handle, props) | |
| # set ball color | |
| c = 0.5 + 0.5 * np.random.random(3) | |
| gym.set_rigid_body_color(env, actor_handle, 0, gymapi.MESH_VISUAL_AND_COLLISION, gymapi.Vec3(c[0], c[1], c[2])) | |
| # add camera | |
| cam_props = gymapi.CameraProperties() | |
| cam_props.width = 128 | |
| cam_props.height = 128 | |
| cam_props.enable_tensors = True | |
| cam_handle = gym.create_camera_sensor(env, cam_props) | |
| gym.set_camera_location(cam_handle, env, gymapi.Vec3(5, 1, 0), gymapi.Vec3(0, 1, 0)) | |
| cams.append(cam_handle) | |
| # obtain camera tensor | |
| cam_tensor = gym.get_camera_image_gpu_tensor(sim, env, cam_handle, gymapi.IMAGE_COLOR) | |
| print("Got camera tensor with shape", cam_tensor.shape) | |
| # wrap camera tensor in a pytorch tensor | |
| torch_cam_tensor = gymtorch.wrap_tensor(cam_tensor) | |
| cam_tensors.append(torch_cam_tensor) | |
| print(" Torch camera tensor device:", torch_cam_tensor.device) | |
| print(" Torch camera tensor shape:", torch_cam_tensor.shape) | |
| # point camera at middle env | |
| cam_pos = gymapi.Vec3(8, 2, 6) | |
| cam_target = gymapi.Vec3(-8, 0, -6) | |
| middle_env = envs[num_envs // 2 + envs_per_row // 2] | |
| gym.viewer_camera_look_at(viewer, middle_env, cam_pos, cam_target) | |
| # prepare tensor access | |
| gym.prepare_sim(sim) | |
| # get GPU physics state tensor | |
| state_tensor = gym.acquire_rigid_body_state_tensor(sim) | |
| print("Gym state tensor shape:", state_tensor.shape) | |
| print("Gym state tensor data @ 0x%x" % state_tensor.data_address) | |
| # wrap physics state tensor in a pytorch tensor | |
| rb_states = gymtorch.wrap_tensor(state_tensor) | |
| print("Torch state tensor device:", rb_states.device) | |
| print("Torch state tensor shape:", rb_states.shape) | |
| print("Torch state tensor data @ 0x%x" % rb_states.data_ptr()) | |
| # create some wrapper tensors for different slices | |
| num_bodies = rb_states.shape[0] | |
| rb_positions = rb_states[:, 0:3] | |
| rb_orientations = rb_states[:, 3:7] | |
| rb_linvels = rb_states[:, 7:10] | |
| rb_angvels = rb_states[:, 10:13] | |
| # create directory for saved images | |
| img_dir = "interop_images" | |
| if not os.path.exists(img_dir): | |
| os.mkdir(img_dir) | |
| frame_count = 0 | |
| next_fps_report = 2.0 | |
| t1 = 0 | |
| while viewer is None or not gym.query_viewer_has_closed(viewer): | |
| frame_no = gym.get_frame_count(sim) | |
| gym.simulate(sim) | |
| gym.fetch_results(sim, True) | |
| # refresh state data in the tensor | |
| gym.refresh_rigid_body_state_tensor(sim) | |
| gym.step_graphics(sim) | |
| # render sensors and refresh camera tensors | |
| gym.render_all_camera_sensors(sim) | |
| gym.start_access_image_tensors(sim) | |
| # write out state and sensors periodically during the first little while | |
| if frame_no < 60 and frame_no % 10 == 0: | |
| print("========= Frame %d ==========" % frame_no) | |
| # print the state tensors | |
| # print("RB states:") | |
| # print(rb_states.cpu().detach().numpy()) | |
| print("RB positions:") | |
| print(rb_positions) | |
| # print("RB orientations:") | |
| # print(rb_orientations) | |
| # print("RB linear velocities:") | |
| # print(rb_linvels) | |
| # print("RB angular velocities:") | |
| # print(rb_angvels) | |
| for i in range(num_envs): | |
| # write tensor to image | |
| fname = os.path.join(img_dir, "cam-%04d-%04d.png" % (frame_no, i)) | |
| cam_img = cam_tensors[i].cpu().numpy() | |
| imageio.imwrite(fname, cam_img) | |
| t = gym.get_elapsed_time(sim) | |
| if t >= next_fps_report: | |
| t2 = gym.get_elapsed_time(sim) | |
| fps = frame_count / (t2 - t1) | |
| print("FPS %.1f (%.1f)" % (fps, fps * num_envs)) | |
| frame_count = 0 | |
| t1 = gym.get_elapsed_time(sim) | |
| next_fps_report = t1 + 2.0 | |
| gym.end_access_image_tensors(sim) | |
| if viewer is not None: | |
| gym.draw_viewer(viewer, sim, True) | |
| gym.sync_frame_time(sim) | |
| frame_count += 1 | |