def render_figure(fig):
w, h = fig.get_size_inches()
dpi_res = fig.get_dpi()
w, h = int(np.ceil(w * dpi_res)), int(np.ceil(h * dpi_res))
canvas = FigureCanvasAgg(fig)
buffer = BytesIO()
canvas.print_raw(buffer, dpi=dpi_res)
return pyglet.image.ImageData(w, h, 'RGBA', buffer.getvalue(), -4 * w)
def render_figure(fig):
w, h = fig.get_size_inches()
dpi_res = fig.get_dpi()
w, h = int(math.ceil(w * dpi_res)), int(math.ceil(h * dpi_res))
canvas = FigureCanvasAgg(fig)
pic_data = StringIO.StringIO()
canvas.print_raw(pic_data, dpi=dpi_res)
return pyglet.image.ImageData(w, h, 'RGBA', pic_data.getvalue(), -4 * w)
def render_figure(fig): w, h = fig.get_size_inches() dpi_res = fig.get_dpi() w, h = int(math.ceil(w * dpi_res)), int(math.ceil(h * dpi_res)) canvas = FigureCanvasAgg(fig) pic_data = StringIO.StringIO() canvas.print_raw(pic_data, dpi = dpi_res) return pyglet.image.ImageData(w, h, 'RGBA', pic_data.getvalue(), -4 * w)
def _update_image(self):
plot_structure(self.adjacency_matrix, self.fig)
# self.image = self._render_figure(fig)
w, h = self.fig.get_size_inches()
dpi_res = self.fig.get_dpi()
w, h = int(np.ceil(w * dpi_res)), int(np.ceil(h * dpi_res))
canvas = FigureCanvasAgg(self.fig)
buffer = BytesIO()
canvas.print_raw(buffer, dpi=dpi_res)
self.image = pyglet.image.ImageData(w, h, 'RGBA', buffer.getvalue(),
-4 * w)
def figure_to_image(mlp_fig, rel_anchor_x=0.5, rel_anchor_y=0.5):
from matplotlib.backends.backend_agg import FigureCanvasAgg
canvas = FigureCanvasAgg(mlp_fig)
pic_data = io.BytesIO()
canvas.print_raw(pic_data, dpi=mlp_fig.dpi)
width, height = mlp_fig.get_size_inches() * mlp_fig.dpi
width = int(width)
height = int(height)
image = pyglet.image.ImageData(width, height, 'RGBA', pic_data.getvalue(),
-4 * width)
image.anchor_x = int(image.width * rel_anchor_x)
image.anchor_y = int(image.height * rel_anchor_y)
return image
class MplVisual(Visual):
def __init__(self, sim: Simulator, **kwargs):
super(MplVisual, self).__init__(sim,
width=kwargs.get('width', 500),
height=kwargs.get('height', 500))
self.dpi = 80
self.figure = plt.figure(figsize=(self.width / self.dpi,
self.height / self.dpi),
dpi=self.dpi)
self._create_canvas()
def _create_canvas(self):
self.canvas = FigureCanvas(self.figure)
data = StringIO()
self.canvas.print_raw(data, dpi=self.dpi)
self.image = pyglet.image.ImageData(self.width, self.height, 'RGBA',
data.getvalue(), -4 * self.width)
def update_image(self):
data = StringIO()
self.canvas.print_raw(data, dpi=self.dpi)
self.image.set_data('RGBA', -4 * self.width, data.getvalue())
def on_draw(self):
self.clear()
glClearColor(1., 1., 1., 1.)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
self.switch_to()
self.dispatch_events()
if DISPLAY_FPS:
self.fps_display.draw()
if DISPLAY_HUMAN_RENDERED:
self.human_title.draw()
base_dimensions = (210, 160)
scale = 2
display_nparray(cv2.resize(
self.game_image,
dsize=(int(base_dimensions[1]*scale), int(base_dimensions[0]*scale)),
interpolation=cv2.INTER_CUBIC))\
.blit(50, self.height-base_dimensions[0]*scale-50)
if DISPLAY_MACHINE_RENDERED:
self.agent_title.draw()
base_dimensions = (84, 84)
scale = 2.5
state_images = [
np.repeat(self.state_image[:, :, i, np.newaxis], 3, axis=2)
for i in range(self.state_image.shape[-1])
]
for i, state_image in enumerate(state_images):
display_nparray(cv2.resize(state_image,
dsize=(int(base_dimensions[1]*scale), int(base_dimensions[0]*scale)),
interpolation=cv2.INTER_CUBIC))\
.blit(10+i*(84*scale+5), 10)
if DISPLAY_VAL_CHART:
dpi_res = min(self.width, self.height) / 10
fig = Figure((500 / dpi_res, 230 / dpi_res), dpi=dpi_res)
ax = fig.add_subplot(111)
# Set up plot
ax.set_title('Estimated Value over Time', fontsize=20)
ax.set_xticklabels([])
ax.set_ylabel('V(s)')
ax.plot(self.values[max(len(self.values) -
200, 0):]) # plot values
w, h = fig.get_size_inches()
dpi_res = fig.get_dpi()
w, h = int(np.ceil(w * dpi_res)), int(np.ceil(h * dpi_res))
canvas = FigureCanvasAgg(fig)
pic_data = io.BytesIO()
canvas.print_raw(pic_data, dpi=dpi_res)
img = pyglet.image.ImageData(w, h, 'RGBA', pic_data.getvalue(),
-4 * w)
img.blit(375, 265)
if DISPLAY_HEATMAP and self.evaluate_frame_number > 1:
self.heatmap_title.draw()
base_dimensions = (84, 84)
INTENSITY = 0.1
scale = 10
processed_frame = np.repeat(self.state_image[:, :, 3, np.newaxis],
3,
axis=2)
heatmap = generate_heatmap(game_wrapper.state, agent.DQN)
img = (heatmap * 255 * INTENSITY + processed_frame * 0.8).astype(
np.uint8)
display_nparray(
cv2.resize(img + (heatmap * 255 * INTENSITY).astype(np.uint8),
dsize=(int(base_dimensions[1] * scale),
int(base_dimensions[0] * scale)),
interpolation=cv2.INTER_CUBIC)).blit(880, 60)
self.flip()
def on_draw(self):
self.clear()
glClearColor(1., 1., 1., 1.)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
self.switch_to()
self.dispatch_events()
# Draw FPS counter
if DISPLAY_FPS:
self.fps_display.draw()
# Display RGB "human" version of the game state
if DISPLAY_HUMAN_RENDERED:
self.human_title.draw()
base_dimensions = (210, 160)
scale = 2
display_nparray(cv2.resize(
self.game_image,
dsize=(int(base_dimensions[1]*scale), int(base_dimensions[0]*scale)),
interpolation=cv2.INTER_CUBIC))\
.blit(50, self.height-base_dimensions[0]*scale-50)
# Display grayscale "machine" version of the game state (this is what the agent really sees)
if DISPLAY_MACHINE_RENDERED:
self.agent_title.draw()
base_dimensions = (84, 84)
scale = 2.5
# For some strange reason, we must render this in RGB mode (not 'L' mode as implied in the pyglet docs)
# Because of this, we must repeat each frame 3 times to simulate RGB, despite being grayscale
state_images = [
np.repeat(self.state_image[:, :, i, np.newaxis], 3, axis=2)
for i in range(self.state_image.shape[-1])
]
for i, state_image in enumerate(state_images):
display_nparray(cv2.resize(state_image,
dsize=(int(base_dimensions[1]*scale), int(base_dimensions[0]*scale)),
interpolation=cv2.INTER_CUBIC))\
.blit(10+i*(84*scale+5), 10)
# Display q-values
if DISPLAY_Q_VALUES:
self.q_val_title.draw()
LENGTH = 80
STARTING_X = 400
for i, (q_val, label) in enumerate(
zip(self.q_vals[::-1], self.action_titles[::-1])):
if q_val > self.max_q_val:
self.max_q_val = q_val
elif q_val < self.min_q_val:
self.min_q_val = q_val
# Draw square represention q-val
x_value = STARTING_X + i * (LENGTH + 10
) # x-coordinate to draw square
color = (150**(q_val *
2)) / (sum([150**(q * 2)
for q in self.q_vals]) + 0.0001)
pyglet.graphics.draw(
4, GL_QUADS,
('v2f', (x_value, self.height - 50, x_value + LENGTH,
self.height - 50, x_value + LENGTH, self.height -
LENGTH - 50, x_value, self.height - LENGTH - 50)),
('c3f', (color, color, color, color, color, color, color,
color, color, color, color, color)))
# Draw action label
glTranslatef(x_value + LENGTH / 2, self.height - 100 - LENGTH,
0.0)
glRotatef(-90.0, 0.0, 0.0, 1.0)
label.draw()
glRotatef(90.0, 0.0, 0.0, 1.0)
glTranslatef(-(x_value + LENGTH / 2),
-(self.height - 100 - LENGTH), 0.0)
# Display value history (adapted from https://learning.oreilly.com/library/view/matplotlib-plotting-cookbook/9781849513265/ch08s06.html)
if DISPLAY_VAL_CHART:
dpi_res = min(self.width, self.height) / 10
fig = Figure((500 / dpi_res, 230 / dpi_res), dpi=dpi_res)
ax = fig.add_subplot(111)
# Set up plot
ax.set_title('Estimated Value over Time', fontsize=20)
ax.set_xticklabels([])
ax.set_ylabel('V(s)')
ax.plot(self.values[max(len(self.values) -
200, 0):]) # plot values
w, h = fig.get_size_inches()
dpi_res = fig.get_dpi()
w, h = int(np.ceil(w * dpi_res)), int(np.ceil(h * dpi_res))
canvas = FigureCanvasAgg(fig)
pic_data = io.BytesIO()
canvas.print_raw(pic_data, dpi=dpi_res)
img = pyglet.image.ImageData(w, h, 'RGBA', pic_data.getvalue(),
-4 * w)
img.blit(375, 265)
# Display heatmap
if DISPLAY_HEATMAP and self.evaluate_frame_number > 1:
self.heatmap_title.draw()
base_dimensions = (84, 84)
INTENSITY = 0.1
scale = 10
processed_frame = np.repeat(self.state_image[:, :, 3, np.newaxis],
3,
axis=2)
heatmap = generate_heatmap(game_wrapper.state, agent.DQN)
img = (heatmap * 255 * INTENSITY + processed_frame * 0.8).astype(
np.uint8)
display_nparray(
cv2.resize(img + (heatmap * 255 * INTENSITY).astype(np.uint8),
dsize=(int(base_dimensions[1] * scale),
int(base_dimensions[0] * scale)),
interpolation=cv2.INTER_CUBIC)).blit(880, 60)
self.flip()
