def render(self, mode="human"):
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
if mode == "human":
self.viewer.imshow(self.observation)
elif mode == "rgb_array":
render_frame = np.copy(self.worldL)
render_frame[5:self.window_shape[1]+5, 5:self.window_shape[0]+5] = self.observation
cv2.rectangle(render_frame, (0,0), (self.window_shape[1]+10, self.window_shape[0]+10),
(0,0,0), 5)
return render_frame
def render(self, mode='human', width=240, height=240):
img = np.array(DrawObservation((self.lastFieldObs, self.lastBotObs), width, height))
img = np.expand_dims(img, axis=-1)
img = np.repeat(img, 3, axis=-1)
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
return self.viewer.isopen
def render(self, mode='human'):
""" render the current drawn picture image for human """
if mode == 'human':
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(self._get_rgb_array())
elif mode == 'rgb_array':
return self._get_rgb_array()
else:
raise NotImplementedError
def render(self, mode='human', inspect=False, img=None):
if not inspect:
return self.env.render(mode)
else:
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.env.env.viewer is None:
self.env.env.viewer = rendering.SimpleImageViewer()
self.env.env.viewer.imshow(img)
return self.env.env.viewer.isopen
def render(self, size=None):
import cv2
img = self._obs[-1] if type(self._obs) is list else self._obs
if size: img = cv2.resize(img, size, interpolation=cv2.INTER_NEAREST)
if len(img.shape) == 2: img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) #img = np.expand_dims(img, -1)
try:
self.viewer.imshow(img)
except AttributeError:
from gym.envs.classic_control import rendering
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
return self.viewer.isopen
def render(self, mode='human'):
img = copy.copy(self._base_img)
img = np.asarray(img)
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
return self.viewer.isopen
def render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow((self.state.repeat(RENDER_UPSCALE, axis=0).repeat(RENDER_UPSCALE, axis=1)*255).astype(np.uint8))
def render(self, mode="human"):
if turn_off_rendering:
return
try:
img = self.game.get_state().screen_buffer
img = np.transpose(img, [1, 2, 0])
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
except AttributeError:
pass
def render(self, mode='human'):
enabled = True
if enabled and mode == 'human':
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
player_index_to_view = 0
state = self.game_state.get_board(player_index_to_view)
state[state > 1] = self.SNAKE_BODY
obs = SnakesBackendSync.convert_observation_to_img(state)
self.viewer.imshow(obs)
def _render(self, mode='human', close=False):
if close:
return
if mode == 'human' and self.show_warped:
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
img = self._observation(self.env._render('rgb_array', close)) * np.ones([1, 1, 3], dtype=np.uint8)
self.viewer.imshow(img)
return img
else:
return self.env._render(mode, close)
def init_gym_env(self):
"""Initialize the environment instance that the current class is wrapping."""
from dm_control import suite
env = suite.load(
domain_name=self.domain_name,
task_name=self.task_name,
visualize_reward=self._visualize_reward,
)
self.viewer = []
self._viewer = None if novideo_mode else rendering.SimpleImageViewer()
return env
def main(game_name, model_name):
parser = argparse.ArgumentParser(description="Auto Trainer")
parser.add_argument('--gpu', '-g', type=int, default=-1)
args = parser.parse_args()
print('Using gpu: {}'.format(args.gpu))
env = gym.make(game_name)
agent = PredictorAgent(SAVE_DIR, env, name=model_name, gpu=args.gpu)
prediction_view = rendering.SimpleImageViewer()
error_view = rendering.SimpleImageViewer()
last_save_time = agent.save()
reset = True
for i in range(ROUNDS):
if reset:
reset_obs = cupy.array(process_image(env.reset()).data,
dtype="float32")
agent.initialize_state(reset_obs)
action = agent(reset_obs, reward=0)
if action >= env.action_space.n:
action = 0 # no-op
env.render()
raw_obs, reward, reset, _data = env.step(action)
if reward:
print('Non-zero reward:', reward)
obs = cupy.array(process_image(raw_obs).data, dtype="float32")
action = agent(obs, reward)
if action >= env.action_space.n:
action = 0 # no-op
# Render things prediction
env.render()
prediction_view.imshow(to_image_format(agent.predicted_image.data))
error_view.imshow(to_err_mask_image(agent.error_mask.data))
if time.time() - last_save_time > SAVE_INTERVAL_SECONDS:
last_save_time = agent.save()
print('Saved the', agent.name, 'agent')
def render(self, mode='human'):
try:
img = self.game.get_state().screen_buffer
img = np.transpose(img, [1, 2, 0])
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
except AttributeError:
pass
def render(self, mode: Text = 'rgb_array') -> Union[np.ndarray, bool]:
if self._last_observation is None:
raise ValueError('Environment not ready to render. Call reset() first.')
if mode == 'rgb_array':
return self._last_observation
if mode == 'human':
if self.viewer is None:
from gym.envs.classic_control import rendering # pylint: disable=g-import-not-at-top
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(self._last_observation)
return self.viewer.isopen
def render(self, state, close):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
img = self.rgb.get_image(state)
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
return self.viewer.isopen
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
if mode == 'rgb_array':
return self.screen
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(self.screen)
def render(self, mode="human"):
canvas = self._get_canvas()
if mode == "rgb_array":
return canvas
elif mode == "human":
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(canvas)
return self.viewer.isopen
else:
super(FluidPaint, self).render(mode=mode) # just raise an exception
def __init__(self):
self.env = gym.make(env_name)
self.viewer = rendering.SimpleImageViewer()
self.render = render
self.episode = 1
self.total_reward = 0
self.clear()
self.EPS = eps_start
if create_video:
self.env = wrappers.Monitor(self.env, dir_, force=True)
print('observations shape:', observation_shape)
#print('action details', action_details)
print('no of actions:', no_of_actions)
def random_agent(num_envs=1, max_steps=100000):
setup_utils.setup_and_load(use_cmd_line_args=True)
print(Config.IS_HIGH_RES)
env = make('standard', num_envs=num_envs)
env.render()
viewer = rendering.SimpleImageViewer()
for step in range(max_steps):
acts = np.array(
[env.action_space.sample() for _ in range(env.num_envs)])
_obs, rews, _dones, _infos = env.step(acts)
print("step", step, "rews", rews)
env.render()
env.close()
def render(self, mode='human', close=None):
img = room_to_rgb(self.room_state, self.room_fixed)
if mode == 'rgb_array':
return img
elif mode is 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
return self.viewer.isopen
else:
super(SokobanEnv, self).render(mode=mode) # just raise an exception
def render(self, mode='human'):
if mode == 'rgb_array':
return self.last_obs
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(self.last_obs)
return self.viewer.isopen
else:
assert 0, "Render mode '%s' is not supported" % mode
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
return
img = self._get_image()
if mode == 'rgb_array':
return img
elif mode is 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
def render(self, mode='human', close=False):
img = self._obs
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
img = self._repeat_upsample(img, 64, 64)
self.viewer.imshow(img)
if close:
self.viewer.close()
return self.viewer.isopen
def _render(self, mode='gui', close=False):
if self.mode == "gui":
img = imread(os.path.join(os.path.dirname(os.path.realpath(__file__)),'sumo.png'), 1)
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
else:
raise NotImplementedError("Only rendering in GUI mode is supported")
def render(self,
mode='human',
close=False,
record_pngs_dir=None,
record_json_dir=None):
from PIL import Image
if close:
self.close()
return
human_factor = utility.HUMAN_FACTOR
frames = self._render_frames()
if mode == 'rgb_array':
return frames[0]
all_img = resize(
frames[0],
(self._board_size * human_factor, self._board_size * human_factor),
interp='nearest')
other_imgs = [
resize(frame, (int(self._board_size * human_factor / 4),
int(self._board_size * human_factor / 4)),
interp='nearest') for frame in frames[1:]
]
other_imgs = np.concatenate(other_imgs, 0)
img = np.concatenate([all_img, other_imgs], 1)
if self._viewer is None:
from gym.envs.classic_control import rendering
self._viewer = rendering.SimpleImageViewer()
self._viewer.imshow(img)
if record_pngs_dir:
Image.fromarray(img).save(
os.path.join(record_pngs_dir, '%d.png' % self._step_count))
if record_json_dir:
info = self.get_json_info()
with open(
os.path.join(record_json_dir,
'%d.json' % self._step_count), 'w') as f:
f.write(json.dumps(info, sort_keys=True, indent=4))
for agent in self._agents:
if agent.has_key_input():
self._viewer.window.on_key_press = agent.on_key_press
self._viewer.window.on_key_release = agent.on_key_release
break
time.sleep(1.0 / self._render_fps)
def render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
# We only import this here in case we're running on a headless server
from gym.envs.classic_control import rendering
assert mode == 'human', "Button only supports human render mode"
img = self._get_ob()
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
def render(self, mode='human'):
tile_size=16
img = self._prob.render(get_string_map(self._rep._map, self._prob.get_tile_types()))
img = self._rep.render(img, self._prob._tile_size, self._prob._border_size).convert("RGB")
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
if not hasattr(img, 'shape'):
img = np.array(img)
self.viewer.imshow(img)
return self.viewer.isopen
def render(self, mode='human'):
img = copy.copy(self._base_img)
for agent_i in range(self.n_agents):
for neighbour in self.__get_neighbour_coordinates(
self.agent_pos[agent_i]):
fill_cell(img,
neighbour,
cell_size=CELL_SIZE,
fill=AGENT_NEIGHBORHOOD_COLOR,
margin=0.1)
fill_cell(img,
self.agent_pos[agent_i],
cell_size=CELL_SIZE,
fill=AGENT_NEIGHBORHOOD_COLOR,
margin=0.1)
for agent_i in range(self.n_agents):
draw_circle(img,
self.agent_pos[agent_i],
cell_size=CELL_SIZE,
fill=AGENT_COLOR)
write_cell_text(img,
text=str(agent_i + 1),
pos=self.agent_pos[agent_i],
cell_size=CELL_SIZE,
fill='white',
margin=0.4)
for prey_i in range(self.n_preys):
if self._prey_alive[prey_i]:
draw_circle(img,
self.prey_pos[prey_i],
cell_size=CELL_SIZE,
fill=PREY_COLOR)
write_cell_text(img,
text=str(prey_i + 1),
pos=self.prey_pos[prey_i],
cell_size=CELL_SIZE,
fill='white',
margin=0.4)
img = np.asarray(img)
if mode == 'rgb_array':
return img
elif mode == 'human':
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
return self.viewer.isopen
def __init__(self):
from gym.envs.classic_control import rendering
self.viewer = rendering.SimpleImageViewer()
self._action_set = {0, 1} # go up, go down
self.action_space = spaces.Discrete(len(self._action_set))
# init obstacle
self.obstacle = Obstacle()
# init robot
self.robby = Robot()
def _render(self, mode='human', close=False):
if close:
if hasattr(self, 'viewer') and self.viewer is not None:
self.viewer.close()
self.viewer = None
return
img = self.pixel_array
if mode == 'rgb_array':
return img
elif mode == 'human':
if not hasattr(self, 'viewer') or self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.SimpleImageViewer()
self.viewer.imshow(img)
