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