Download python/examples/domain_randomization.py from e-zorzi/data_for_skillblender: direct link, hf CLI and curl.
- Browser
- Download file 6.85 kB
-
https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/domain_randomization.py
- Command line
-
hf download hf://datasets/e-zorzi/data_for_skillblender/python/examples/domain_randomization.py
-
curl -L -o domain_randomization.py https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/domain_randomization.py
6.85 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. | |
| Domain Randomization Example | |
| ---------------------------- | |
| An example that demonstrates domain randomization. | |
| - Randomize color | |
| - Randomize texture | |
| - Randomize light parameters | |
| - Randomize camera position | |
| """ | |
| import os | |
| import random | |
| from isaacgym import gymapi | |
| from isaacgym import gymutil | |
| # initialize gym | |
| gym = gymapi.acquire_gym() | |
| # parse arguments | |
| args = gymutil.parse_arguments( | |
| description="Domain Randomization Example", | |
| headless=True, | |
| custom_parameters=[ | |
| {"name": "--save_images", "action": "store_true", "help": "Store Images To Disk"}]) | |
| # configure sim | |
| sim_params = gymapi.SimParams() | |
| sim_params.substeps = 2 | |
| sim_params.dt = 1.0 / 60.0 | |
| if args.physics_engine == gymapi.SIM_FLEX: | |
| pass | |
| else: | |
| 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() | |
| # add ground plane | |
| plane_params = gymapi.PlaneParams() | |
| gym.add_ground(sim, gymapi.PlaneParams()) | |
| # create viewer | |
| if not args.headless: | |
| viewer = gym.create_viewer(sim, gymapi.CameraProperties()) | |
| if viewer is None: | |
| raise ValueError('*** Failed to create viewer') | |
| # set up the env grid | |
| num_envs = 1 | |
| spacing = 0.75 | |
| env_lower = gymapi.Vec3(-spacing, 0.0, -spacing) | |
| env_upper = gymapi.Vec3(spacing, spacing, spacing) | |
| # create ant asset | |
| asset_root = "../../assets" | |
| asset_file = "mjcf/nv_ant.xml" | |
| print("Loading asset '%s' from '%s'" % (asset_file, asset_root)) | |
| ant_asset = gym.load_asset(sim, asset_root, asset_file) | |
| if ant_asset is None: | |
| raise IOError("Failed to load asset") | |
| envs = [] | |
| actor_handles = [] | |
| camera_handles = [] | |
| # Load textures from file | |
| texture_files = os.listdir("../../assets/textures/") | |
| loaded_texture_handle_list = [] | |
| for file in texture_files: | |
| if file.endswith(".jpg"): | |
| loaded_texture_handle_list.append(gym.create_texture_from_file(sim, os.path.join("../../assets/textures/", file))) | |
| # Sensor camera properties | |
| cam_pos = gymapi.Vec3(0.0, 3.0, 3.0) | |
| cam_target = gymapi.Vec3(0.0, 0.0, -1.0) | |
| cam_props = gymapi.CameraProperties() | |
| cam_props.width = 360 | |
| cam_props.height = 360 | |
| # Create environments | |
| print('Creating %d environments' % num_envs) | |
| for i in range(num_envs): | |
| # create env | |
| env = gym.create_env(sim, env_lower, env_upper, 2) | |
| envs.append(env) | |
| # create ant actor | |
| pose = gymapi.Transform() | |
| pose.p = gymapi.Vec3(0, 0.5, 0) | |
| pose.r = gymapi.Quat(-0.707107, 0.0, 0.0, 0.707107) | |
| ahandle = gym.create_actor(env, ant_asset, pose, 'ant', i, 1) | |
| actor_handles.append(ahandle) | |
| # configure DOF properties to move freely | |
| props = gym.get_actor_dof_properties(env, ahandle) | |
| props["driveMode"].fill(gymapi.DOF_MODE_NONE) | |
| props["stiffness"].fill(0.0) | |
| props["damping"].fill(0.0) | |
| gym.set_actor_dof_properties(env, ahandle, props) | |
| # create camera actor | |
| camera_handle = gym.create_camera_sensor(env, cam_props) | |
| camera_handles.append(camera_handle) | |
| body = gym.get_actor_rigid_body_handle(env, ahandle, 0) | |
| gym.attach_camera_to_body(camera_handle, env, body, gymapi.Transform(p=cam_pos), gymapi.FOLLOW_TRANSFORM) | |
| gym.set_camera_location(camera_handle, env, cam_pos, cam_target) | |
| # position viewer camera | |
| if not args.headless: | |
| gym.viewer_camera_look_at(viewer, None, cam_pos, cam_target) | |
| sequence_number = 0 | |
| # Only create the folder if it doesn't exist | |
| if not os.path.exists('dr_output_images'): | |
| os.mkdir("dr_output_images") | |
| while True: | |
| # step the physics | |
| gym.simulate(sim) | |
| gym.fetch_results(sim, True) | |
| # render camera sensor | |
| gym.render_all_camera_sensors(sim) | |
| # update graphics transforms | |
| gym.step_graphics(sim) | |
| if not args.headless: | |
| # render the viewer | |
| gym.draw_viewer(viewer, sim, True) | |
| # Wait for dt to elapse in real time to sync viewer with | |
| # simulation rate. Not necessary in headless. | |
| gym.sync_frame_time(sim) | |
| # Check for exit condition - user closed the viewer window | |
| if gym.query_viewer_has_closed(viewer): | |
| break | |
| # randomize body color/texture to box actors and env lights every 100 frames | |
| if gym.get_frame_count(sim) % 100 == 0: | |
| for i in range(num_envs): | |
| env = envs[i] | |
| # randomize sensor camera position | |
| y_offset = random.uniform(-1.0, 1.0) | |
| z_offset = random.uniform(-1.0, 1.0) | |
| cam_pos_new = cam_pos + gymapi.Vec3(0., y_offset, z_offset) | |
| gym.set_camera_location(camera_handles[i], env, cam_pos_new, cam_target) | |
| # randomize colors and textures for rigid body | |
| num_bodies = gym.get_actor_rigid_body_count(env, actor_handles[-1]) | |
| for n in range(num_bodies): | |
| gym.set_rigid_body_color(env, actor_handles[-1], n, gymapi.MESH_VISUAL, | |
| gymapi.Vec3(random.uniform(0, 1), random.uniform(0, 1), random.uniform(0, 1))) | |
| gym.set_rigid_body_texture(env, actor_handles[-1], n, gymapi.MESH_VISUAL, | |
| loaded_texture_handle_list[random.randint(0, len(loaded_texture_handle_list)-1)]) | |
| # randomize light parameters | |
| l_color = gymapi.Vec3(random.uniform(1, 1), random.uniform(1, 1), random.uniform(1, 1)) | |
| l_ambient = gymapi.Vec3(random.uniform(0, 1), random.uniform(0, 1), random.uniform(0, 1)) | |
| l_direction = gymapi.Vec3(random.uniform(0, 1), random.uniform(0, 1), random.uniform(0, 1)) | |
| gym.set_light_parameters(sim, 0, l_color, l_ambient, l_direction) | |
| # save rgb image to disk | |
| if args.save_images: | |
| print("writing dr_output_images/rgb_image_%03d_%03d.png" % (sequence_number, i)) | |
| rgb_image_filename = "dr_output_images/rgb_image_%03d_%03d.png" % (sequence_number, i) | |
| gym.write_camera_image_to_file(sim, env, camera_handle, gymapi.IMAGE_COLOR, rgb_image_filename) | |
| sequence_number = sequence_number + 1 | |
| print('Done') | |
| if not args.headless: | |
| gym.destroy_viewer(viewer) | |
| gym.destroy_sim(sim) | |