Download python/examples/soft_body.py from e-zorzi/data_for_skillblender: direct link, hf CLI and curl.
- Browser
- Download file 6.54 kB
-
https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/soft_body.py
- Command line
-
hf download hf://datasets/e-zorzi/data_for_skillblender/python/examples/soft_body.py
-
curl -L -o soft_body.py https://huggingface.co/datasets/e-zorzi/data_for_skillblender/resolve/main/python/examples/soft_body.py
6.54 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. | |
| Soft Body | |
| --------- | |
| Simple import of a URDF with a soft body link and rigid body press mechanism | |
| """ | |
| import math | |
| import random | |
| from isaacgym import gymapi | |
| from isaacgym import gymutil | |
| import numpy as np | |
| # initialize gym | |
| gym = gymapi.acquire_gym() | |
| # parse arguments | |
| args = gymutil.parse_arguments(description="FEM Soft Body Example") | |
| if args.physics_engine != gymapi.SIM_FLEX: | |
| print("*** Soft body example only supports FleX") | |
| print("*** Run example with --flex flag") | |
| quit() | |
| random.seed(7) | |
| # simulation parameters | |
| sim_params = gymapi.SimParams() | |
| sim_params.dt = 1.0 / 60.0 | |
| sim_params.substeps = 3 | |
| sim_params.flex.solver_type = 5 | |
| sim_params.flex.num_outer_iterations = 4 | |
| sim_params.flex.num_inner_iterations = 20 | |
| sim_params.flex.relaxation = 0.8 | |
| sim_params.flex.warm_start = 0.75 | |
| sim_params.flex.shape_collision_margin = 0.1 | |
| # enable Von-Mises stress visualization | |
| sim_params.stress_visualization = True | |
| sim_params.stress_visualization_min = 0.0 | |
| sim_params.stress_visualization_max = 1.e+5 | |
| 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.compute_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, plane_params) | |
| # create viewer | |
| viewer = gym.create_viewer(sim, gymapi.CameraProperties()) | |
| if viewer is None: | |
| print("*** Failed to create viewer") | |
| quit() | |
| # load urdf for sphere asset used to create softbody | |
| asset_root = "../../assets" | |
| soft_asset_file = "urdf/icosphere.urdf" | |
| soft_thickness = 0.1 # important to add some thickness to the soft body to avoid interpenetrations | |
| asset_options = gymapi.AssetOptions() | |
| asset_options.fix_base_link = True | |
| asset_options.thickness = soft_thickness | |
| asset_options.default_dof_drive_mode = gymapi.DOF_MODE_POS | |
| print("Loading asset '%s' from '%s'" % (soft_asset_file, asset_root)) | |
| soft_asset = gym.load_asset(sim, asset_root, soft_asset_file, asset_options) | |
| asset_soft_body_count = gym.get_asset_soft_body_count(soft_asset) | |
| asset_soft_materials = gym.get_asset_soft_materials(soft_asset) | |
| # Print asset soft material properties | |
| print('Soft Material Properties:') | |
| for i in range(asset_soft_body_count): | |
| mat = asset_soft_materials[i] | |
| print(f'(Body {i}) youngs: {mat.youngs} poissons: {mat.poissons} damping: {mat.damping}') | |
| # set up the env grid | |
| num_envs = 4 | |
| spacing = 3.0 | |
| env_lower = gymapi.Vec3(-spacing, 0.0, -spacing) | |
| env_upper = gymapi.Vec3(spacing, spacing, spacing) | |
| # cache some common handles for later use | |
| envs = [] | |
| soft_actors = [] | |
| print("Creating %d environments" % num_envs) | |
| num_per_row = int(math.sqrt(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) | |
| pose = gymapi.Transform() | |
| pose.p = gymapi.Vec3(0.0, 2.0, 0.0) | |
| # add soft body + rail actor | |
| soft_actor = gym.create_actor(env, soft_asset, pose, "soft", i, 1) | |
| soft_actors.append(soft_actor) | |
| # set soft material within a range of default | |
| actor_default_soft_materials = gym.get_actor_soft_materials(env, soft_actor) | |
| actor_soft_materials = gym.get_actor_soft_materials(env, soft_actor) | |
| for j in range(asset_soft_body_count): | |
| youngs = actor_soft_materials[j].youngs | |
| actor_soft_materials[j].youngs = random.uniform(youngs * 0.2, youngs * 2.4) | |
| poissons = actor_soft_materials[j].poissons | |
| actor_soft_materials[j].poissons = random.uniform(poissons * 0.8, poissons * 1.2) | |
| damping = actor_soft_materials[j].damping | |
| # damping is 0, instead we just randomize from scratch | |
| actor_soft_materials[j].damping = random.uniform(0.0, 0.08)**2 | |
| gym.set_actor_soft_materials(env, soft_actor, actor_soft_materials) | |
| # enable pd-control on rail joint to allow | |
| # control of the press using the GUI | |
| gym.set_joint_target_position(env, gym.get_joint_handle(env, "soft", "rail"), 0.0) | |
| # Point camera at environments | |
| cam_pos = gymapi.Vec3(-4.0, 2.8, -1.2) | |
| cam_target = gymapi.Vec3(0.0, 1.4, 1.0) | |
| gym.viewer_camera_look_at(viewer, None, cam_pos, cam_target) | |
| # options | |
| flag_draw_contacts = False | |
| flag_compute_pressure = False | |
| while not gym.query_viewer_has_closed(viewer): | |
| # step the physics | |
| gym.simulate(sim) | |
| gym.fetch_results(sim, True) | |
| if (flag_draw_contacts): | |
| gym.clear_lines(viewer) | |
| for env in envs: | |
| gym.draw_env_soft_contacts(viewer, env, gymapi.Vec3(0.7, 0.2, 0.15), 0.0005, True, True) | |
| if (flag_compute_pressure): | |
| # read tetrahedral and triangle data from simulation | |
| (tet_indices, tet_stress) = gym.get_sim_tetrahedra(sim) | |
| (tri_indices, tri_parents, tri_normals) = gym.get_sim_triangles(sim) | |
| for env in envs: | |
| # get range (start, count) for each soft actor (assumes one soft body) | |
| tet_range = gym.get_actor_tetrahedra_range(env, 0, 0) | |
| tri_range = gym.get_actor_triangle_range(env, 0, 0) | |
| for i in range(tri_range.start, tri_range.start + tri_range.count): | |
| # 'parent' tetrahedron of this triangle | |
| parent = tri_parents[i] | |
| parent_stress = tet_stress[parent] | |
| # convert to numpy | |
| stress = np.matrix([(parent_stress.x.x, parent_stress.y.x, parent_stress.z.x), | |
| (parent_stress.x.y, parent_stress.y.y, parent_stress.z.y), | |
| (parent_stress.x.z, parent_stress.y.z, parent_stress.z.z)]) | |
| normal = np.array((tri_normals[i].x, tri_normals[i].y, tri_normals[i].z)) | |
| # compute force density (since normal is normalized) | |
| force = np.dot(stress, normal) | |
| # update the viewer | |
| gym.step_graphics(sim) | |
| gym.draw_viewer(viewer, sim, False) | |
| # Wait for dt to elapse in real time. | |
| # This synchronizes the physics simulation with the rendering rate. | |
| gym.sync_frame_time(sim) | |
| gym.destroy_viewer(viewer) | |
| gym.destroy_sim(sim) | |