def render(self, mode='human'):
screen_width = 600
screen_height = 600
world_width = 10.0
world_height = 10.0
xscale = screen_width / world_width
yscale = screen_height / world_height
robotwidth = 0.25
robotheight = 0.25
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
xy = [(0.0, 0.0), (0.0, 10.0), (10.0, 10.0), (10.0, 0.0)]
xys = [(x * xscale, y * yscale) for x, y in xy]
self.surface = rendering.make_polyline(xys)
self.surface.set_linewidth(4)
self.viewer.add_geom(self.surface)
l, r, t, b = -robotwidth / 2, robotwidth / 2, robotheight / 2, -robotheight / 2
self.robot = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.robot.set_color(0.0, 0.0, 0.8)
self.robot.add_attr(rendering.Transform(translation=(0, 0)))
self.robot_trans = rendering.Transform()
self.robot.add_attr(self.robot_trans)
self.viewer.add_geom(self.robot)
l = self.G[0][0, 0] * xscale
b = self.G[0][1, 0] * yscale
r = self.G[1][0, 0] * xscale
t = self.G[1][1, 0] * yscale
self.goal_area = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.goal_area.set_color(0.8, 0.0, 0.0)
self.viewer.add_geom(self.goal_area)
self._trajectory.append(
(self.state[0] * xscale, self.state[1] * yscale))
if len(self._trajectory) >= 2:
move = rendering.Line(start=self._trajectory[-2],
end=self._trajectory[-1])
# orange: rgb(244, 215, 66)
move.set_color(244.0 / 255.0, 215.0 / 255.0, 66.0 / 255.0)
move.add_attr(rendering.LineStyle(0xAAAA))
move.add_attr(rendering.LineWidth(4))
self.viewer.add_geom(move)
self.robot_trans.set_translation(self.state[0] * xscale,
self.state[1] * yscale)
self.robot_trans.set_rotation(np.arctan2(self.state[3], self.state[2]))
self.robot_trans.set_scale(xscale, yscale)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def _render_agent_vision(self):
'''rendering style to display what the agent 'sees' displaying only vertices and vectors'''
from gym.envs.classic_control import rendering
a_cp_dim = 0.03
v_dim = 0.015
bx, by = 0, 0
thin_line = 2 * 2
thick_line = 5 * 2
white = (1., 1., 1.)
dark_grey = (0.2, 0.2, 0.2)
dash = rendering.LineStyle(style=True)
# DRAW FINAL POINTS
for f_loc in self.block_final_pos.values():
fx, fy = self.scale_units(f_loc)
t = rendering.Transform(translation=(fx, fy))
self.viewer.draw_circle(v_dim, 100, color=white).add_attr(t)
self.viewer.draw_circle(self.scaled_epsilon / RATIO,
30,
color=dark_grey,
linewidth=thick_line,
filled=False).add_attr(t)
# DRAW OBJECTS
for obj in self.drawlist:
# DRAW agent cp, pointer, distance btwn agent and block
if 'agent' in obj.userData:
x, y = obj.position
t = rendering.Transform(translation=(x, y))
self.viewer.draw_circle(a_cp_dim, 30, color=white).add_attr(t)
vx, vy = obj.GetWorldVector(localVector=(0, 0.1))
self.viewer.draw_polyline([(x, y), (x + vx, y + vy)],
color=white,
linewidth=thin_line)
if by != 0 and bx != 0:
self.viewer.draw_polyline(
[(x, y), (bx, by)], color=white,
linewidth=thin_line).add_attr(dash)
# DRAW block cp, distance btwn block and goal, vertices
if 'block' in obj.userData:
bx, by = obj.worldCenter
t = rendering.Transform(translation=(bx, by))
self.viewer.draw_circle(v_dim, 30, color=cp_color).add_attr(t)
self.viewer.draw_polyline([(bx, by), (fx, fy)],
color=white,
linewidth=thin_line).add_attr(dash)
for v in self.blks_vertices[obj.userData]:
x, y = obj.GetWorldPoint(v)
t = rendering.Transform(translation=(x, y))
self.viewer.draw_circle(v_dim, 30,
color=cp_color).add_attr(t)
def render(self, mode='human'):
screen_width = 600
screen_height = 600
world_width = self.observation_space.high[0] + 2
world_height = self.observation_space.high[0] + 2
xscale = screen_width / world_width
yscale = screen_height / world_height
robotwidth = 0.5
robotheight = 0.5
goalwidth = 0.5
goalheight = 0.5
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
#Grid
for heightX in range(int(self.observation_space.high[0] + 1)):
heightX = float(heightX)
for widthX in range(int(self.observation_space.high[0] + 1)):
widthX = float(widthX)
xy = [(0.5 + widthX, 0.5 + heightX),
(0.5 + widthX,
self.observation_space.high[0] + 1.5 - heightX),
(self.observation_space.high[0] + 1.5 - widthX,
self.observation_space.high[0] + 1.5 - heightX),
(self.observation_space.high[0] - widthX + 1.5,
0.5 + heightX)]
xys = [(x * xscale, y * yscale) for x, y in xy]
self.surface = rendering.make_polyline(xys)
self.surface.set_linewidth(1)
self.viewer.add_geom(self.surface)
xy = [(0.5, 0.5), (0.5, self.observation_space.high[0] + 1.5),
(self.observation_space.high[0] + 1.5,
self.observation_space.high[0] + 1.5),
(self.observation_space.high[0] + 1.5, 0.5)]
xys = [(x * xscale, y * yscale) for x, y in xy]
self.surface = rendering.make_polyline(xys)
self.surface.set_linewidth(4)
self.viewer.add_geom(self.surface)
xy = [(0.5, 0.5), (self.observation_space.high[0] + 1.5, 0.5)]
xys = [(x * xscale, y * yscale) for x, y in xy]
self.surface = rendering.make_polyline(xys)
self.surface.set_linewidth(4)
self.viewer.add_geom(self.surface)
self.obstacle_area = []
self.obstacle_trans = []
for k in range(len(self.obstacles)):
l, r, t, b = -goalwidth, goalwidth, goalheight, -goalheight
self.obstacle_area.append(
rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]))
self.obstacle_area[k].set_color(0.0, 0.8, 0.0)
self.obstacle_area[k].add_attr(
rendering.Transform(translation=(0, 0)))
self.obstacle_trans.append(rendering.Transform())
self.obstacle_area[k].add_attr(self.obstacle_trans[k])
self.viewer.add_geom(self.obstacle_area[k])
self.goal_area = []
self.goal_trans = []
for k in range(len(self.terminals)):
l, r, t, b = -goalwidth, goalwidth, goalheight, -goalheight
self.goal_area.append(
rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]))
self.goal_area[k].set_color(0.8, 0.0, 0.0)
self.goal_area[k].add_attr(
rendering.Transform(translation=(0, 0)))
self.goal_trans.append(rendering.Transform())
self.goal_area[k].add_attr(self.goal_trans[k])
self.viewer.add_geom(self.goal_area[k])
l, r, t, b = -robotwidth, robotwidth, robotheight, -robotheight
self.robot = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.robot.set_color(0.0, 0.0, 0.8)
self.robot.add_attr(rendering.Transform(translation=(0, 0)))
self.robot_trans = rendering.Transform()
self.robot.add_attr(self.robot_trans)
self.viewer.add_geom(self.robot)
self._trajectory.append(
((self.state[0] + 1) * xscale, (self.state[1] + 1) * yscale))
for k in range(len(self.obstacles)):
self.obstacle_trans[k].set_translation(
(self.obstacles[k][0] + 1) * xscale,
(self.obstacles[k][1] + 1) * yscale)
self.obstacle_trans[k].set_scale(xscale, yscale)
for k in range(len(self.terminals)):
self.goal_trans[k].set_translation(
(self.terminals[k][0] + 1) * xscale,
(self.terminals[k][1] + 1) * yscale)
self.goal_trans[k].set_scale(xscale, yscale)
if len(self._trajectory) >= 2:
move = rendering.Line(start=self._trajectory[-2],
end=self._trajectory[-1])
# orange: rgb(244, 215, 66)
move.set_color(244.0 / 255.0, 215.0 / 255.0, 66.0 / 255.0)
move.add_attr(rendering.LineStyle(0xAAAA))
move.add_attr(rendering.LineWidth(4))
self.viewer.add_geom(move)
self.robot_trans.set_translation((self.state[0] + 1) * xscale,
(self.state[1] + 1) * yscale)
self.robot_trans.set_scale(xscale, yscale)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')