def _get_viewer(self):
if self.viewer is None:
#import pdb; pdb.set_trace()
#self.viewer = mujoco_py.MjViewer(self.sim)
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim)
self._viewer_setup()
return self.viewer
def _get_viewer(self, camera_id):
if self.viewer is None:
from mujoco_py import GlfwContext
GlfwContext(offscreen=True)
self.viewer = mujoco_py.MjRenderContextOffscreen(self._env.sim, -1)
self.viewer_setup(camera_id)
return self.viewer
def initialize_camera(self, init_fctn):
sim = self.sim
viewer = mujoco_py.MjRenderContextOffscreen(sim,
device_id=self.device_id)
# viewer = mujoco_py.MjViewer(sim)
init_fctn(viewer.cam)
sim.add_render_context(viewer)
def __init__(self, sim, env_name, width=400, height=400, mp4size=(4, 4)):
self.sim = sim
self.context = mujoco_py.MjRenderContextOffscreen(sim, -1)
self.width = width
self.height = height
self.record = []
self.mp4size = mp4size
self.env_name = env_name
def _setup_render_rgb(sim: mujoco_py.MjSim) -> mujoco_py.MjSim: # create copy of simulation to customize rendering context # flags defined in mjvisualize.h render_sim = mujoco_py.MjSim(sim.model) render_sim.set_state(sim.get_state()) render_ctx = mujoco_py.MjRenderContextOffscreen(render_sim) render_ctx.scn.stereo = 2 # side-by-side rendering return render_sim
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if 'rgb_array' in mode:
self.viewer = mujoco_py.MjRenderContextOffscreen(
self.sim, device_id=self.device_id)
self.viewer_setup()
self._viewers[mode] = self.viewer
return super()._get_viewer(mode)
def initialize_camera(self):
# set camera parameters for viewing
sim = self.sim
viewer = mujoco_py.MjRenderContextOffscreen(sim)
camera = viewer.cam
camera.type = 1
camera.trackbodyid = 0
camera.elevation = -20
sim.add_render_context(viewer)
def _get_viewer(self):
if self.viewer is None:
# offscreen render
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, 0)
# self.viewer = mujoco_py.MjViewer(self.sim)
self.viewer_setup()
return self.viewer
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
elif mode == 'rgb_array':
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, 0)
self.viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == "human":
self.viewer = mujoco_py.MjViewer(self.sim)
elif mode == "rgb_array":
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, device_id=-1)
self._viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def __init__(self, animate=False, sim=None, camera=False, heightfield=True):
if camera:
import cv2
self.prev_img = np.zeros((24,24))
if sim is not None:
self.sim = sim
self.model = self.sim.model
else:
self.modelpath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets/ant_terrain_mjc.xml")
self.model = mujoco_py.load_model_from_path(self.modelpath)
self.sim = mujoco_py.MjSim(self.model)
self.camera = camera
self.animate = animate
self.HF = heightfield
self.HF_div = 5
if self.HF:
self.hf_data = self.model.hfield_data
self.hf_ncol = self.model.hfield_ncol[0]
self.hf_nrow = self.model.hfield_nrow[0]
self.hf_size = self.model.hfield_size[0]
self.hf_grid = self.hf_data.reshape((self.hf_nrow, self.hf_ncol))
self.hf_grid_aug = np.zeros((self.hf_nrow * 2, self.hf_ncol * 2))
self.hf_grid_aug[:self.hf_nrow, :self.hf_ncol] = self.hf_grid
self.hf_m_per_cell = float(self.hf_size[1]) / self.hf_nrow
self.rob_dim = 0.5
self.hf_res = int(self.rob_dim / self.hf_m_per_cell)
self.hf_offset_x = 4
self.hf_offset_y = 3
self.model.opt.timestep = 0.02
# Environment dimensions
self.q_dim = self.sim.get_state().qpos.shape[0]
self.qvel_dim = self.sim.get_state().qvel.shape[0]
self.obs_dim = self.q_dim + self.qvel_dim - 2 + 4 + (24**2) * 2 # x,y not present, + 4contacts
self.act_dim = self.sim.data.actuator_length.shape[0]
# Environent inner parameters
self.viewer = None
self.step_ctr = 0
if camera:
self.cam_viewer = mujoco_py.MjRenderContextOffscreen(self.sim, 0)
self.frame_list = []
# Initial methods
if animate:
self.setupcam()
self.reset()
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
elif mode == 'rgb_array':
device_id = self.sim.model.camera_name2id('camera1')
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, device_id=device_id)
self._viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
elif mode == 'rgb_array' or mode == 'depth_array': # add depth mode, similar with mujoco_env
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim,
device_id=-1)
self._viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def initialize(self, use_cur_pos):
tmp = MODEL_XML_BASE.format(self.get_asset_mesh_str(),
self.get_asset_material_str(),
self.get_body_str())
model = load_model_from_xml(tmp)
self.sim = MjSim(model)
if self.view:
self.viewer = MjViewer(self.sim)
else:
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, -1)
self._get_starting_step(use_cur_pos)
def _connect(self, joint_names, camera_id=-1):
"""Connect to the interface.
Parameters
----------
joint_names : list
The set of joints to gather feedback from.
camera_id : int, optional (Default: -1)
The ID of the camera to use when visualizing the environment.
Can also be changed in-simulation with the Tab key.
"""
self.sim = mjp.MjSim(self.model)
self.sim.forward() # run forward to fill in sim.data
model = self.sim.model
self.model = model
joint_ids = [model.joint_name2id(name) for name in joint_names]
self.joint_pos_addrs = [model.get_joint_qpos_addr(name) for name in joint_names]
self.joint_vel_addrs = [model.get_joint_qvel_addr(name) for name in joint_names]
# Need to also get the joint rows of the Jacobian, inertia matrix, and
# gravity vector. This is trickier because if there's a quaternion in
# the joint (e.g. a free joint or a ball joint) then the joint position
# address will be different than the joint Jacobian row. This is because
# the quaternion joint will have a 4D position and a 3D derivative. So
# we go through all the joints, and find out what type they are, then
# calculate the Jacobian position based on their order and type.
index = 0
self.joint_dyn_addrs = []
for ii, joint_type in enumerate(model.jnt_type):
if ii in joint_ids:
self.joint_dyn_addrs.append(index)
if joint_type == 0: # free joint
index += 6 # derivative has 6 dimensions
elif joint_type == 1: # ball joint
index += 3 # derivative has 3 dimensions
else: # slide or hinge joint
index += 1 # derivative has 1 dimensions
# if we want to use the offscreen render context create it before the
# viewer so the corresponding window is behind the viewer
if self.create_offscreen_rendercontext:
self.offscreen = mjp.MjRenderContextOffscreen(self.sim, 0)
# create the visualizer
if self.visualize:
self.viewer = mjp.MjViewer(self.sim)
# if specified, set the camera
if camera_id > -1:
self.viewer.cam.type = const.CAMERA_FIXED
self.viewer.cam.fixedcamid = camera_id
print("MuJoCo session created")
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == 'human':
self.viewer = mujoco_py.MjViewer(
self.sim, self.key_callback_function)
elif mode == 'rgb_array':
self.viewer = mujoco_py.MjRenderContextOffscreen(
self.sim, device_id=-1)
self._viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def _setup_render_depth(sim: mujoco_py.MjSim) -> mujoco_py.MjSim: # create copy of simulation to customize rendering context # flags defined in mjvisualize.h render_sim = mujoco_py.MjSim(sim.model) render_sim.set_state(sim.get_state()) render_ctx = mujoco_py.MjRenderContextOffscreen(render_sim) render_ctx.vopt.flags[1] = 0 # textures off render_ctx.scn.flags[0] = 0 # shadow off render_ctx.scn.flags[2] = 0 # reflection off render_ctx.scn.flags[4] = 0 # skybox off render_ctx.scn.stereo = 2 # side-by-side rendering return render_sim
def render(self, mode='new', width=752, height=912, distance=3, azimuth=170, elevation=-30, cache_key='current'):
key = (distance, azimuth, elevation)
target = 'latch1'
if key not in self.render_cache[cache_key]:
# The mujoco renderer is stupid and changes the inner state in minor
# ways, which can ruin some long trajectories. Because of this, we
# save the inner state before rendering and restore it afterwards.
inner_state = copy.deepcopy(self.get_inner_state())
if self.viewer is None:
if 'CUSTOM_DOCKER_IMAGE' not in os.environ:
# We detected that we are running on desktop, in which case we should
# use glfw as the mode.
mode = 'glfw'
if not self.__class__.MJ_INIT and mode == 'glfw':
print("WTF")
try:
mujoco_py.MjViewer(self.sim)
print("WOW")
except Exception:
print('Failed to initialize GLFW, rendering may or may not work.')
self.__class__.MJ_INIT = True
# Note: opus machines typically have 4 GPUs, but the docker is given access to just 1. The problem
# is that OpenGL "sees" all 4 GPUs, but errors out if it tries to use one that it doesn't have
# access to, so we simply try all 4 GPUs in turn until it works. We start at -1 (autodetect GPU)
# for cases where we are running this outside of opus, in which case the default most likely works.
for device in range(-1, 4):
try:
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, device_id=device)
break
except RuntimeError:
print('Device', device, 'didn\'t work.')
self.viewer.scn.flags[2] = 0 # Disable reflections (~25% speedup)
body_id = self.sim.model.body_name2id(target)
lookat = self.sim.data.body_xpos[body_id]
for idx, value in enumerate(lookat):
self.viewer.cam.lookat[idx] = value
self.viewer.cam.distance = distance
self.viewer.cam.azimuth = azimuth
self.viewer.cam.elevation = elevation
self.viewer.render(width, height)
img = self.viewer.read_pixels(width, height, depth=False)
img = img[::-1, :, :]
self.set_inner_state(inner_state)
self.render_cache[cache_key][key] = img
return self.render_cache[cache_key][key]
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
elif mode == 'rgb_array':
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, device_id=-1)
self._viewer_setup()
self._viewers[mode] = self.viewer
if self.camera_pos != self.last_camera_pos:
self.last_camera_pos = self.camera_pos
self._viewer_setup()
return self.viewer
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
#self.viewer._paused = True
self.viewer._hide_overlay = True
elif mode == 'rgb_array':
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim,
device_id=-1)
self._viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def _get_viewer(self): # , mode): # , camera_name=None):
mode = "human"
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == 'human':
self.viewer = mujoco_py.MjViewer(
self.sim) #, camera_name=camera_name)
elif mode == 'rgb_array' or mode == 'depth_array':
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, -1)
self.viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def get_viewer(self, mode):
self.viewer = self.viewers.get(mode)
if self.viewer is None:
self.viewer = mujoco_py.MjViewer(self.sim) if mode in [
"human"
] else mujoco_py.MjRenderContextOffscreen(
self.sim, -1) if mode in ["rgb_array", "depth_array"] else None
self.viewer._hide_overlay = True
self.viewer._render_every_frame = True
self.viewer.cam.trackbodyid = 0
# self.viewer.cam.azimuth = 180
# self.viewer.cam.elevation = -15
self.viewers[mode] = self.viewer
return self.viewer
def _get_viewer(self, mode): self.viewer = self._viewers.get(mode) if self.viewer is None: if mode == 'human': self.viewer = mujoco_py.MjViewer(self.sim) elif 'rgb_array' in mode: self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, 0) self.viewer_setup() self._viewers[mode] = self.viewer # if mode == 'rgb_array_y': # self.viewer_setup(view_angle='y') # else: # self.viewer_setup(view_angle='x') self.viewer_setup() return self.viewer
def __init__(self, config, size=(128, 128)):
self._env = metaworld.envs.mujoco.sawyer_xyz.v2.sawyer_hammer_v2.SawyerHammerEnvV2(
)
self._env._last_rand_vec = np.array([-0.06, 0.4, 0.02])
self._env._set_task_called = True
self.size = size
#Setup camera in environment
self.viewer = mujoco_py.MjRenderContextOffscreen(self._env.sim, -1)
self.viewer.cam.elevation = -15
self.viewer.cam.azimuth = 137.5
self.viewer.cam.distance = 0.9
self.viewer.cam.lookat[0] = -0.
self.viewer.cam.lookat[1] = 0.6
self.viewer.cam.lookat[2] = 0.175
def __init__(self, config, size=(128, 128)):
self._env = metaworld.envs.mujoco.sawyer_xyz.v2.sawyer_drawer_open_v2.SawyerDrawerOpenEnvV2(
)
self._env._last_rand_vec = np.array([-0.1, 0.9, 0.0])
self._env._set_task_called = True
self.size = size
#Setup camera in environment
self.viewer = mujoco_py.MjRenderContextOffscreen(self._env.sim, -1)
self.viewer.cam.elevation = -22.5
self.viewer.cam.azimuth = 15
self.viewer.cam.distance = 0.75
self.viewer.cam.lookat[0] = -0.15
self.viewer.cam.lookat[1] = 0.7
self.viewer.cam.lookat[2] = 0.10
def _get_viewer(self, mode):
self.viewer = self._viewers.get(mode)
if self.viewer is None:
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
elif mode == 'keyboard':
self.viewer = mujoco_py.MjViewerKeyboard(self.sim)
elif mode == 'controller':
self.viewer = mujoco_py.MjViewerController(self.sim)
elif mode == 'rgb_array':
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim,
device_id=-1)
self._viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def __init__(self,
model_path,
dataset_name,
use_procedural=False,
cam_pos_file=None,
cam_norm_pos_file=None):
super().__init__(dataset_name,
cam_pos_file=cam_pos_file,
cam_norm_pos_file=cam_norm_pos_file)
self.model = mujoco_py.load_model_from_path(model_path)
self.sim = mujoco_py.MjSim(self.model)
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, None)
self.cam_modder = CameraModder(self.sim)
self.tex_modder = TextureModder(self.sim)
self.use_procedural = use_procedural
def _get_viewer(self, mode) -> mujoco_py.MjViewer:
self.viewer = self._viewers.get(mode)
if self.viewer is not None:
return self.viewer
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
# we turn off the overlay and make the window smaller.
self.viewer._hide_overlay = True
import glfw
glfw.set_window_size(self.viewer.window, self.default_window_width, self.default_window_height)
else:
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, -1)
self.viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def __init__(self, hm_fun_list, *hm_args):
self.hm_fun_list = hm_fun_list
self.hm_args = hm_args
# External parameters
self.joints_rads_low = np.array([-0.2, -0.6, -0.6] * 4)
self.joints_rads_high = np.array([0.6, 0.6, 0.6] * 4)
self.joints_rads_diff = self.joints_rads_high - self.joints_rads_low
self.target_vel = 0.4 # Target velocity with which we want agent to move
self.max_steps = 300
self.camera = False
self.reset()
self.camera = False
if self.camera:
self.cam_viewer = mujoco_py.MjRenderContextOffscreen(self.sim, 0)
def get_viewer(self, mode):
self.viewer = self.viewers.get(mode)
if self.viewer is None:
self.viewer = mujoco_py.MjViewer(self.sim) if mode in [
"human"
] else mujoco_py.MjRenderContextOffscreen(
self.sim, -1) if mode in ["rgb_array", "depth_array"] else None
self.viewer.vopt.geomgroup[0] = (1 if self.render_collision_mesh
else 0)
self.viewer.vopt.geomgroup[1] = (1
if self.render_visual_mesh else 0)
self.viewer._hide_overlay = True
self.viewer._render_every_frame = True
self.viewer.cam.trackbodyid = 0
self.viewer.cam.azimuth = 180
self.viewer.cam.elevation = -15
self.viewers[mode] = self.viewer
return self.viewer
