def _build_display(self, gold_cell, trap_cells):
screen_width = (self.num_cols + 2) * CELL_SIZE
screen_height = (self.num_rows + 2) * CELL_SIZE
self.viewer = rendering.Viewer(screen_width, screen_height)
all_objects = []
# List of border points' coordinates
bp_list = [(CELL_SIZE - MARGIN, CELL_SIZE - MARGIN),
(screen_width - CELL_SIZE + MARGIN, CELL_SIZE - MARGIN),
(screen_width - CELL_SIZE + MARGIN,
screen_height - CELL_SIZE + MARGIN),
(CELL_SIZE - MARGIN, screen_height - CELL_SIZE + MARGIN)]
border = rendering.PolyLine(bp_list, True)
border.set_linewidth(5)
all_objects.append(border)
# Vertical lines
for col in range(self.num_cols + 1):
x1, y1 = (col + 1) * CELL_SIZE, CELL_SIZE
x2, y2 = (col + 1) * CELL_SIZE, \
(self.num_rows + 1) * CELL_SIZE
line = rendering.PolyLine([(x1, y1), (x2, y2)], False)
all_objects.append(line)
# Horizontal lines
for row in range(self.num_rows + 1):
x1, y1 = CELL_SIZE, (row + 1) * CELL_SIZE
x2, y2 = (self.num_cols + 1) * CELL_SIZE, \
(row + 1) * CELL_SIZE
line = rendering.PolyLine([(x1, y1), (x2, y2)], False)
all_objects.append(line)
# Traps: --> circles
for cell in trap_cells:
trap_coords = get_coords(*cell, loc='center')
all_objects.append(draw_object([trap_coords]))
# Gold: --> triangle
gold_coords = get_coords(*gold_cell, loc='interior_triangle')
all_objects.append(draw_object(gold_coords))
# Agent --> square or robot
if (os.path.exists('robot-coordinates.pkl') and CELL_SIZE == 100):
agent_coords = pickle.load(open('robot-coordinates.pkl', 'rb'))
starting_coords = get_coords(0, 0, loc='center')
agent_coords += np.array(starting_coords)
else:
agent_coords = get_coords(0, 0, loc='interior_corners')
agent = draw_object(agent_coords)
self.agent_trans = rendering.Transform()
agent.add_attr(self.agent_trans)
all_objects.append(agent)
for obj in all_objects:
self.viewer.add_geom(obj)
def _render_mvas(self):
"""
Renders the outlines of the minimum vectoring altitudes onto the screen.
:return: None
"""
def transform_world_to_screen(coords):
return [
((coord[0] - self._world_x_min) * self._scale + self._padding,
(coord[1] - self._world_y_min) * self._scale + self._padding)
for coord in coords
]
for mva in self._mvas:
coordinates = transform_world_to_screen(mva.area.exterior.coords)
fill = rendering.FilledPolygon(coordinates)
fill.set_color(*ColorScheme.background_active)
self.viewer.add_geom(fill)
for mva in self._mvas:
coordinates = transform_world_to_screen(mva.area.exterior.coords)
outline = rendering.PolyLine(coordinates, True)
outline.set_linewidth(1)
outline.set_color(*ColorScheme.mva)
self.viewer.add_geom(outline)
def init_rendering(self, viewer):
self.steering_wheel = SteeringWheel()
self.add_part(self.steering_wheel, 0.065, 0.0, 0.0)
self.breadcrumb = rendering.PolyLine([], close=False)
self.breadcrumb._color.vec4 = Color.set_alpha(self.color, 0.5)
viewer.add_geom(self.breadcrumb)
def _render_faf(self):
"""
Renders the final approach fix symbol onto the screen
Currently only supports a single runway and a single approach corridor
:return: None
"""
faf_screen_render_size = 6
faf_x = self._runway.corridor.faf[0][0]
faf_y = self._runway.corridor.faf[1][0]
faf_vector = self._screen_vector(faf_x, faf_y)
corner_vector = np.array([[0], [faf_screen_render_size]])
corner_top = faf_vector + corner_vector
corner_right = np.dot(model.rot_matrix(121),
corner_vector) + faf_vector
corner_left = np.dot(model.rot_matrix(242), corner_vector) + faf_vector
poly_line = rendering.PolyLine([corner_top, corner_right, corner_left],
True)
poly_line.set_color(*ColorScheme.lines_info)
poly_line.set_linewidth(2)
self.viewer.add_geom(poly_line)
def _render(self, mode='human', close=False):
screen_width = 1200
screen_height = 400
# Shift the coordinates so that we can see above the top lane, below the bottom lane,
# left of the start position of the cars.
shift_y = 0.005
shift_x = 0.02
# The scaling is defined in terms of the height, apply the same scaling so that the
# rendering doesn't look weird.
# TODO: make sure we can see all obstacles (and maybe all cars).
scale_y = float(screen_height) / float(self._top_lane -
self._bottom_lane + 2 * shift_y)
scale_x = scale_y
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
# Draw the obstacles:
for obs in self._obstacles:
circle = geometry_utils.make_circle(obs.pos_x, obs.pos_y,
obs.radius)
circle = geometry_utils.shift_then_scale_points(
circle, shift_x, shift_y, scale_x, scale_y)
self.viewer.add_onetime(rendering.FilledPolygon(circle))
# Draw the car
for c in self._cars:
circle = geometry_utils.make_circle(c.pos_x, c.pos_y,
self._car_radius)
circle = geometry_utils.shift_then_scale_points(
circle, shift_x, shift_y, scale_x, scale_y)
self.viewer.add_onetime(rendering.PolyLine(circle, True))
# Draw the lanes
bottom_lane = [(-shift_x, self._bottom_lane),
(self._road_length + shift_x, self._bottom_lane)]
bottom_lane = geometry_utils.shift_then_scale_points(
bottom_lane, shift_x, shift_y, scale_x, scale_y)
self.viewer.add_onetime(rendering.PolyLine(bottom_lane, True))
top_lane = [(-shift_x, self._top_lane),
(self._road_length + shift_x, self._top_lane)]
top_lane = geometry_utils.shift_then_scale_points(
top_lane, shift_x, shift_y, scale_x, scale_y)
self.viewer.add_onetime(rendering.PolyLine(top_lane, True))
return self.viewer.render(return_rgb_array=(mode == "rgb_array"))
def make_ellipse(major=10, minor=5, res=30, filled=True):
points = []
for i in range(res):
ang = 2*np.pi*i / res
points.append((np.cos(ang)*major, np.sin(ang)*minor))
if filled:
return rendering.FilledPolygon(points)
else:
return rendering.PolyLine(points, True)
def make_disk_at(x, y, radius, res=30, filled=True):
points = []
for i in range(res):
ang = 2 * np.pi * i / res
points.append((np.cos(ang) * radius + x, np.sin(ang) * radius + y))
if filled:
return rendering.FilledPolygon(points)
else:
return rendering.PolyLine(points, True)
def make_circleCv4(radius=10, angle=2*np.pi, res=30, filled=True):
points = [(0, 0)]
for i in range(res + 1):
ang = (np.pi - (angle) / 2) + (angle * (i / res))
points.append((np.cos(ang) * radius, np.sin(ang) * radius))
if filled:
return FilledPolygonCv4(points)
else:
return rendering.PolyLine(points,True)
def make_oval(width=10, height=10, res=30, filled=True):
points = []
for i in range(res):
ang = 2 * math.pi * i / res
points.append((math.cos(ang) * width / 2, math.sin(ang) * height / 2))
if filled:
return rendering.FilledPolygon(points)
else:
return rendering.PolyLine(points, True)
def make_half_circle(radius=10, res=20, filled=True):
""" helper function for pyglet renderer"""
points = []
for i in range(res+1):
ang = math.pi-math.pi*i / res
points.append((math.cos(ang)*radius, math.sin(ang)*radius))
if filled:
return rendering.FilledPolygon(points)
else:
return rendering.PolyLine(points, True)
def create_rectangle(x, y, width, height, color, hollow=False):
ps = [(x, y), ((x + width), y), ((x + width), (y + height)),
(x, (y + height))]
if hollow:
rect = rendering.PolyLine(ps, True)
else:
rect = rendering.FilledPolygon(ps)
rect.set_color(color[0], color[1], color[2])
rect.add_attr(rendering.Transform())
return rect
def _render_runway(self):
runway_length = 1.7 * self._scale
runway_to_threshold_vector = \
np.dot(model.rot_matrix(self._runway.phi_from_runway), np.array([[0], [runway_length / 2]]))
runway_vector = self._screen_vector(self._runway.x, self._runway.y)
runway_line = rendering.PolyLine([
runway_vector - runway_to_threshold_vector,
runway_vector + runway_to_threshold_vector
], False)
runway_line.set_linewidth(5)
runway_line.set_color(*ColorScheme.runway)
self.viewer.add_geom(runway_line)
def render(self, mode='human'):
screen_width = 600
screen_height = 400
world_height = self.slider_range
scale_y = screen_height / world_height
scale_x = 1.0 * (screen_width / 2)
egg_x = screen_width / 2
egg_width = 20.0
egg_height = 30.0
reference_width = 2.0
reference_x_resolution = int(20 * self.episode_length_s)
reference_points = np.zeros((reference_x_resolution, 2))
reference_scale = np.linspace(0, self.episode_length_s,
reference_x_resolution)
reference_points[:,
0] = (scale_x * reference_scale) + (screen_width / 2)
reference_points[:, 1] = scale_y * self.reference_trajectory_fn(
reference_scale)
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
l, r, t, b = -egg_width / 2, egg_width / 2, egg_height / 2, -egg_height / 2
egg = rendering.FilledPolygon([(l, 0), (0, t), (r, 0), (0, b)])
self.egg_transform = rendering.Transform()
egg.add_attr(self.egg_transform)
self.viewer.add_geom(egg)
reference = rendering.PolyLine(reference_points, False)
self.reference_transform = rendering.Transform()
reference.add_attr(self.reference_transform)
self.viewer.add_geom(reference)
if self.state is None: return None
x, x_dot, r, r_dot, \
force_net, force_net_dot, \
force_interaction, force_interaction_dot = self.state
egg_y = (x * scale_y) + (screen_height / 2)
self.egg_transform.set_translation(egg_x, egg_y)
self.reference_transform.set_translation(-self.t * scale_x,
screen_height / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def _render_approach(self):
iaf_x = self._runway.corridor.iaf[0][0]
iaf_y = self._runway.corridor.iaf[1][0]
dashes = 48
runway_vector = self._screen_vector(self._runway.x, self._runway.y)
runway_iaf = self._screen_vector(iaf_x - self._runway.x,
iaf_y - self._runway.y)
for i in range(int(dashes / 2 + 1)):
start = runway_vector + runway_iaf / dashes * 2 * i
end = runway_vector + runway_iaf / dashes * (2 * i + 1)
dash = rendering.PolyLine([start, end], False)
dash.set_color(*ColorScheme.lines_info)
self.viewer.add_geom(dash)
def render(self, mode='human'):
screen_width = 350
screen_height = 400
scale = screen_width / 7
class Tank():
def __init__(self, x, y, dx, dy, viewer):
x, y, dx, dy = [z * scale for z in (x, y, dx, dy)]
self.x, self.y = x, y
tank = rendering.PolyLine([(x, y),
(x + dx, y), (x + dx, y + dy),
(x, y + dy)], True)
viewer.add_geom(tank)
level = rendering.FilledPolygon([(0, 0), (dx, 0), (dx, dy),
(0, dy)])
self.trans = rendering.Transform()
level.add_attr(self.trans)
level.set_color(.5, .5, 1.)
viewer.add_geom(level)
def setLevel(self, perc):
self.trans.set_scale(1, perc)
self.trans.set_translation(self.x, 1 + self.y)
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
self.tanks = [
Tank(*dim, self.viewer)
for dim in ((1, 2, 2, 2), (1, 5, 2, 2), (4, 2, 2, 2),
(4, 5, 2, 2), (0, 0.5, 7, 1.0))
]
for poly in (((.5, 1.5), (.5, 7.33), (5, 7.33),
(5, 7)), ((6.5, 1.5), (6.5, 7.66), (2, 7.66),
(2, 7)), ((.5, 4.5), (1.5, 4.5), (1.5, 4)),
((6.5, 4.5), (5.5, 4.5),
(5.5, 4)), ((2, 2), (2, 1.5)), ((2, 5), (2, 4.5)),
((5, 2), (5, 1.5)), ((5, 5), (5, 4.5))):
poly = [[x * scale for x in point] for point in poly]
self.viewer.add_geom(rendering.PolyLine(poly, False))
if self.state is None: return None
for tank, h in zip(self.tanks, self.state):
tank.setLevel(h / self.h_max)
self.tanks[4].setLevel(1 - sum(self.state) / (4 * self.h_max))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def get_geometry(self):
d = 0.0075
sensor = rendering.FilledPolygon([(-d, -d), (-d, +d), (+d, +d),
(+d, -d)])
sensor.set_color(1, 0, 0)
range_max, range_min, arc, precision = self.specs
ry = range_max * sin(arc)
rx = range_max * cos(arc)
cone = rendering.PolyLine([(rx, ry), (0., 0.), (rx, -ry)], close=False)
cone.set_linewidth(1)
cone._color.vec4 = (1, 0, 0, 0.3)
return [sensor, cone]
def _render_airplane(self, airplane: model.Airplane):
"""
Renders the airplane symbol and adjacent information onto the screen
Already supports multiple airplanes in the environment.
:param airplane: Airplane to render
:return: None
"""
render_size = 4
vector = self._screen_vector(airplane.x, airplane.y)
corner_vector = np.array([[0], [render_size]])
corner_top_right = np.dot(model.rot_matrix(45), corner_vector) + vector
corner_bottom_right = np.dot(model.rot_matrix(135),
corner_vector) + vector
corner_bottom_left = np.dot(model.rot_matrix(225),
corner_vector) + vector
corner_top_left = np.dot(model.rot_matrix(315), corner_vector) + vector
symbol = rendering.PolyLine([
corner_top_right, corner_bottom_right, corner_bottom_left,
corner_top_left
], True)
symbol.set_color(*ColorScheme.airplane)
symbol.set_linewidth(2)
self.viewer.add_onetime(symbol)
label_pos = np.dot(model.rot_matrix(135), 2 * corner_vector) + vector
render_altitude = round(airplane.h / 100)
render_speed = round(airplane.v / 10)
render_text = "%d %d" % (render_altitude, render_speed)
label_name = Label(airplane.name, x=label_pos[0][0], y=label_pos[1][0])
label_details = Label(render_text,
x=label_pos[0][0],
y=label_pos[1][0] - 15)
self.viewer.add_onetime(label_name)
self.viewer.add_onetime(label_details)
n = len(airplane.position_history)
for i in range(n - 5, max(0, n - 25), -1):
if i % 5 == 0:
circle = rendering.make_circle(radius=2, res=12)
screen_vector = self._screen_vector(
airplane.position_history[i][0],
airplane.position_history[i][1])
transform = rendering.Transform(
translation=(screen_vector[0][0], screen_vector[1][0]))
circle.add_attr(transform)
circle.set_color(*ColorScheme.airplane)
self.viewer.add_onetime(circle)
def __init__(self, x, y, dx, dy, viewer):
x, y, dx, dy = [z * scale for z in (x, y, dx, dy)]
self.x, self.y = x, y
tank = rendering.PolyLine([(x, y),
(x + dx, y), (x + dx, y + dy),
(x, y + dy)], True)
viewer.add_geom(tank)
level = rendering.FilledPolygon([(0, 0), (dx, 0), (dx, dy),
(0, dy)])
self.trans = rendering.Transform()
level.add_attr(self.trans)
level.set_color(.5, .5, 1.)
viewer.add_geom(level)
def get_geometry(self):
l = -self.length / 2.0
r = self.length / 2.0
t = self.width / 2.0
b = -self.width / 2.0
body = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
body.set_color(1, 1, 1)
bumpers = rendering.PolyLine([(l, b), (l, t), (r, t), (r, b)],
close=True)
bumpers.set_linewidth(3)
bumpers._color.vec4 = self.color
return [body, bumpers]
def _render_mvas(self):
def transform_world_to_screen(coords):
return [((coord[0] + self._world_x0) * self._scale + self._padding,
(coord[1] + self._world_y0) * self._scale + self._padding)
for coord in coords]
for mva in self._mvas:
coordinates = transform_world_to_screen(mva.area.exterior.coords)
fill = rendering.FilledPolygon(coordinates)
fill.set_color(*ColorScheme.background_active)
self.viewer.add_geom(fill)
outline = rendering.PolyLine(coordinates, True)
outline.set_linewidth(1)
outline.set_color(*ColorScheme.mva)
self.viewer.add_geom(outline)
def _render_faf(self):
faf_screen_render_size = 6
faf_x = self._runway.corridor.faf[0][0]
faf_y = self._runway.corridor.faf[1][0]
faf_vector = self._screen_vector(faf_x, faf_y)
corner_vector = np.array([[0], [faf_screen_render_size]])
corner_top = faf_vector + corner_vector
corner_right = np.dot(model.rot_matrix(121),
corner_vector) + faf_vector
corner_left = np.dot(model.rot_matrix(242), corner_vector) + faf_vector
poly_line = rendering.PolyLine([corner_top, corner_right, corner_left],
True)
poly_line.set_color(*ColorScheme.lines_info)
poly_line.set_linewidth(2)
self.viewer.add_geom(poly_line)
def _render_runway(self):
"""
Renders the runway symbol onto the screen
Currently only supports a single runway and a single approach corridor
:return: None
"""
runway_length = 1.7 * self._scale
runway_to_threshold_vector = \
np.dot(model.rot_matrix(self._runway.phi_from_runway), np.array([[0], [runway_length / 2]]))
runway_vector = self._screen_vector(self._runway.x, self._runway.y)
runway_line = rendering.PolyLine([
runway_vector - runway_to_threshold_vector,
runway_vector + runway_to_threshold_vector
], False)
runway_line.set_linewidth(5)
runway_line.set_color(*ColorScheme.runway)
self.viewer.add_geom(runway_line)
def render(self, mode='human'): screen_width = 800 screen_height = 600 cell_width = 50 cell_height = 50 if self.viewer is None: from gym.envs.classic_control import rendering self.viewer = rendering.Viewer(screen_width, screen_height) leftmargin = (screen_width-(cell_width*self.columns))/2 topmargin = screen_height - (screen_height-(cell_height*self.rows))/2 l, r, t, b = leftmargin, leftmargin+cell_width, topmargin, topmargin-cell_height for row in range(self.rows): for col in range(self.columns): self.cells[(row, col)] = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) red, green, blue = self.getcolors(0) self.cells[(row, col)].set_color(red, green, blue) self.viewer.add_geom(self.cells[(row, col)]) border = rendering.PolyLine([(l, b), (l, t), (r, t), (r, b), (l, b)], True) self.viewer.add_geom(border) l, r = l + cell_width, r + cell_width t, b = t - cell_height, b - cell_height l, r = leftmargin, leftmargin+cell_width if self.prevpos is not None: red, green, blue = self.getcolors(1) self.cells[tuple(self.prevpos)].set_color(red, green, blue) for i in self.possiblemoves: red, green, blue = self.getcolors(0) self.cells[tuple(i)].set_color(red, green, blue) red, green, blue = self.getcolors(2) self.cells[tuple(self.pos)].set_color(red, green, blue) red, green, blue = self.getcolors(3) self.possiblemoves = self.getmoves()[self.getmask()] for move in self.possiblemoves: self.cells[(move[0], move[1])].set_color(red, green, blue) return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def _render_approach(self):
"""
Render the approach path on the screen
Currently only supports a single runway and a single approach corridor
:return: None
"""
iaf_x = self._runway.corridor.iaf[0][0]
iaf_y = self._runway.corridor.iaf[1][0]
dashes = 48
runway_vector = self._screen_vector(self._runway.x, self._runway.y)
runway_iaf = np.array([[iaf_x - self._runway.x],
[iaf_y - self._runway.y]]) * self._scale
for i in range(int(dashes / 2 + 1)):
start = runway_vector + runway_iaf / dashes * 2 * i
end = runway_vector + runway_iaf / dashes * (2 * i + 1)
dash = rendering.PolyLine([start, end], False)
dash.set_color(*ColorScheme.lines_info)
self.viewer.add_geom(dash)
def draw_tasks(self, type_='box', fname=None):
drawn_tasks, shift = [], 0
for task in self.components['tasks']:
#if not task.completed:
drawn_tasks.append(rendering.Transform())
if type_ == 'box':
shift = 0.1
box = rendering.PolyLine(
[(0.1 * self.draw_scale, 0.4 * self.draw_scale),
(0.5 * self.draw_scale, 0.4 * self.draw_scale),
(0.5 * self.draw_scale, 0.1 * self.draw_scale),
(0.1 * self.draw_scale, 0.1 * self.draw_scale),
(0.1 * self.draw_scale, 0.4 * self.draw_scale),
(0.35 * self.draw_scale, 0.65 * self.draw_scale),
(0.75 * self.draw_scale, 0.65 * self.draw_scale),
(0.75 * self.draw_scale, 0.35 * self.draw_scale),
(0.5 * self.draw_scale, 0.1 * self.draw_scale),
(0.5 * self.draw_scale, 0.4 * self.draw_scale),
(0.75 * self.draw_scale, 0.65 * self.draw_scale)],
close=False)
box.set_linewidth(2)
box.add_attr(drawn_tasks[-1])
self.viewer.add_geom(box)
elif type_ == 'figure':
shift = 0.5
try:
with open(fname):
figure = rendering.Image(fname, \
width=0.9 * self.draw_scale, height=0.9 * self.draw_scale)
figure.add_attr(drawn_tasks[-1])
self.viewer.add_geom(figure)
except FileNotFoundError as e:
raise e
else:
raise NotImplementedError
#else:
# drawn_tasks.append(None)
return drawn_tasks, shift
def render(self, mode='human'):
screen_width = 600
screen_height = 400
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
self.track = rendering.Line((0, screen_height / 2),
(screen_width, screen_height / 2))
self.track.set_color(0, 0, 1)
self.viewer.add_geom(self.track)
self.traj = rendering.PolyLine([], False)
self.traj.set_color(1, 0, 0)
self.traj.set_linewidth(3)
self.viewer.add_geom(self.traj)
if len(self.traj.v) != len(self._path):
self.traj.v = []
for p in self._path:
self.traj.v.append(
(p[0] * 100, screen_height / 2 + p[1] * 100))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def make_ant(length=1):
l = length/4
leg1 = rendering.PolyLine([(l/2,0),(l/2,l),(-l*.5,3*l),(l/2,l)],True)
leg2 = rendering.PolyLine([(l/2,0),(l/2,-l),(-l*1.5,-3*l),(l/2,-l)],True)
leg3 = rendering.PolyLine([(l*1.5,0),(l*1.5,l/2),(l,2.5*l),(l*1.5,l/2)],True)
leg4 = rendering.PolyLine([(l*1.5,0),(l*1.5,-l/2),(l*2,-2.5*l),(l*1.5,-l/2)],True)
leg5 = rendering.PolyLine([(l*2.5,0),(l*2.5,l/2),(l*2.5,2*l),(l*2.5,l/2)],True)
leg6 = rendering.PolyLine([(l*2.5,0),(l*2.5,-l/2),(l*3.5,-2*l),(l*2.5,-l/2)],True)
circ0 = make_ellipse(2*l, l/1.5)
circ1 = make_ellipse(l, l/2)
circ1.add_attr(rendering.Transform(translation=(l+l/2, 0)))
circ2 = make_ellipse(l, l)
circ2.add_attr(rendering.Transform(translation=(2*l+l/2, 0)))
geom = rendering.Compound([leg1, leg2, leg3, leg4, leg5, leg6, circ0, circ1, circ2])
geom.add_attr(rendering.Transform(translation=(-3*l, 0)))
geom.add_attr(Flip(flipx=True))
return geom
def render(self, state, mode):
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(self.screen_width,
self.screen_height)
#wall
l, r, t, b = self.get_lrtb(0, state.dimentions[0], 0,
state.dimentions[1])
wall = rendering.PolyLine([(l, b), (l, t), (r, t), (r, b)], True)
wall.set_color(0., 0., 0.)
self.viewer.add_geom(wall)
#robot
robot = rendering.make_circle(self.robot["radius"] * self.scale)
self.robot_trans = rendering.Transform()
robot.add_attr(self.robot_trans)
robot.set_color(0.0, 0.0, 1.0)
self.viewer.add_geom(robot)
robot_orientation = rendering.make_capsule(
self.robot["radius"] * self.scale, 1.0)
self.orientation_trans = rendering.Transform()
robot_orientation.set_color(0.0, 1.0, 0.0)
robot_orientation.add_attr(self.orientation_trans)
self.viewer.add_geom(robot_orientation)
#target
target = rendering.make_circle(self.robot["radius"] * 0.3 *
self.scale)
self.target_trans = rendering.Transform()
target.add_attr(self.target_trans)
target.set_color(1.0, 0.0, 0.0)
self.viewer.add_geom(target)
#obstract
for obj in state.layout["static_objects"]:
l, r, t, b = self.get_lrtb(obj["l"], obj["r"], obj["t"],
obj["b"])
ob = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
ob.set_color(0, 0, 0)
self.viewer.add_geom(ob)
robot_x = (self.margin + state.pose[0]) * self.scale
robot_y = (self.margin + state.pose[1]) * self.scale
robot_orientation = state.pose[2]
self.robot_trans.set_translation(robot_x, robot_y)
self.orientation_trans.set_translation(robot_x, robot_y)
self.orientation_trans.set_rotation(robot_orientation)
self.target_trans.set_translation(
(state.target[0] + self.margin) * self.scale,
(state.target[1] + self.margin) * self.scale)
if state.obs is not None:
for i in range(int(len(state.obs))):
if i % self.SKIP_RENDER == 0:
lidar = rendering.make_capsule(self.scale * state.obs[i],
1.0)
lidar_trans = rendering.Transform()
lidar_trans.set_translation(robot_x, robot_y)
lidar_trans.set_rotation(
state.pose[2] +
i * self.robot["lidar"]["angle_increment"] -
self.robot["lidar"]["max_angle"])
lidar.set_color(1.0, 0.0, 0.0)
lidar.add_attr(lidar_trans)
self.viewer.add_onetime(lidar)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
CELL_SIZE = 30
PAD = 2
screen_width = CELL_SIZE * SnakeEnv.W + 2
screen_height = CELL_SIZE * SnakeEnv.H + 2
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
# lines
self.viewer.geoms = []
snake = np.append([self.head_new], self.body_new, 0)
body_unravel = np.unravel_index(snake, (SnakeEnv.H, SnakeEnv.W))
body_unravel = np.transpose(body_unravel)
body_unravel = np.multiply(body_unravel,
screen_height / SnakeEnv.H + 0)
body_unravel = np.add(body_unravel, CELL_SIZE / 2)
body_unravel[:, 0] = screen_height - body_unravel[:, 0]
body_unravel = np.flip(body_unravel, 1)
body_unravel[:, 0] = body_unravel[:, 0]
line = rendering.PolyLine(body_unravel, False)
self.viewer.add_geom(line)
food_idx = np.unravel_index(self.food_new, (SnakeEnv.H, SnakeEnv.W))
l, r, t, b = food_idx[1] * CELL_SIZE, (food_idx[1] + 1) * CELL_SIZE, (
SnakeEnv.H - food_idx[0]) * CELL_SIZE, (SnakeEnv.H - food_idx[0] -
1) * CELL_SIZE
l, r, t, b = l + PAD, r - PAD, t - PAD, b + PAD
food = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
food.set_color(0, 1, 0)
self.viewer.add_geom(food)
# field = self.state2field(self.head_new, self.body_new, self.food_new)
# # food_idx = np.unravel_index(self.food_new, (SnakeEnv.H, SnakeEnv.W))
# # l, r, t, b = food_idx[1] * CELL_SIZE, (food_idx[1] + 1) * CELL_SIZE, (SnakeEnv.H - food_idx[0]) * CELL_SIZE, (SnakeEnv.H - food_idx[0] - 1) * CELL_SIZE
# # l, r, t, b = l + PAD, r - PAD, t - PAD, b + PAD
# # food = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)])
# # food.set_color(0, 1, 0)
# # self.viewer.add_geom(food)
# snake_idxs = np.argwhere(field>0)
# snake_lifes = [field[tuple(idx)] for idx in snake_idxs]
# snake_idxs = [(idx, field[tuple(idx)]) for idx in snake_idxs]
# snake_idxs.sort(key=lambda x: x[1])
# idx0 = snake_idxs[0][0]
# l0, r0, t0, b0 = idx0[1] * CELL_SIZE, (idx0[1] + 1) * CELL_SIZE, (SnakeEnv.H - idx0[0]) * CELL_SIZE, (SnakeEnv.H - idx0[0] - 1) * CELL_SIZE
# l0, r0, t0, b0 = l0 + PAD, r0 - PAD, t0 - PAD, b0 + PAD
# for idx in snake_idxs[1:]:
# idx = idx[0]
# l, r, t, b = idx[1] * CELL_SIZE, (idx[1] + 1) * CELL_SIZE, (SnakeEnv.H - idx[0]) * CELL_SIZE, (SnakeEnv.H - idx[0] - 1) * CELL_SIZE
# l, r, t, b = l + PAD, r - PAD, t - PAD, b + PAD
# c = [idx[1] * CELL_SIZE + CELL_SIZE / 2, (SnakeEnv.H - idx[0]) * CELL_SIZE + CELL_SIZE / 2]
# step = idx-idx0
# if np.array_equal(step, [1,0]):
# cell = rendering.FilledPolygon([(l0,t0), (r0,t0), (r0,b), (l,b)])
# elif np.array_equal(step, [0,-1]):
# cell = rendering.FilledPolygon([(l,t0), (r0,t0), (r0,b0), (l,b0)])
# elif np.array_equal(step, [-1,0]):
# cell = rendering.FilledPolygon([(l,t), (r,t), (r,b0), (l,b0)])
# elif np.array_equal(step, [0,1]):
# cell = rendering.FilledPolygon([(l0,t0), (r,t), (r,b), (l0,b0)])
# else:
# print('oops')
# cell.set_color(0.5, 0.5, 0.5)
# self.viewer.add_geom(cell)
# idx0 = idx
# l0, r0, t0, b0 = l, r, t, b
# # for i in range(11):
# # print(self.field[i,:])
return self.viewer.render()
def render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
screen_width = 640
screen_height = 480
scale = np.max(self.h_added) / 440
bdata = [
] # (screen_width - 20, 20)] # first point in lower right corner
y = list(reversed(self.h_base))
for j, i in enumerate(y):
bdata.append((screen_width - 20 - j, 20 + int(i / scale)))
# bdata.append((screen_width - 20 - len(y), 20))
adata = [] # (screen_width - 20, 20)]
y = list(reversed(self.h_added))
for j, i in enumerate(y):
adata.append((screen_width - 20 - j, 20 + int(i / scale)))
# adata.append((screen_width - 20 - len(y), 20))
adata = adata[:self.tstep]
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
# l, r, t, b = -cartwidth / 2, cartwidth / 2, cartheight / 2, -cartheight / 2
# axleoffset = cartheight / 4.0
# cart = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
# self.carttrans = rendering.Transform()
# cart.add_attr(self.carttrans)
# self.viewer.add_geom(cart)
# self.poletrans = rendering.Transform(translation=(0, axleoffset))
# pole.add_attr(self.poletrans)
# pole.add_attr(self.carttrans)
# self.axle = rendering.make_circle(polewidth / 2)
# self.axle.add_attr(self.poletrans)
# self.axle.add_attr(self.carttrans)
self.xaxis = rendering.Line((20, 20), (screen_width - 20, 20))
self.xaxis.set_color(0, 0, 0)
self.yaxis = rendering.Line((20, 20), (20, screen_height - 20))
self.yaxis.set_color(0, 0, 0)
self.viewer.add_geom(self.xaxis)
self.viewer.add_geom(self.yaxis)
adde = rendering.PolyLine(adata, False)
adde.set_color(.1, .6, .8)
self.viewer.add_onetime(adde)
base = rendering.PolyLine(bdata, False)
base.set_color(.8, .6, .4)
self.viewer.add_onetime(base)
max_line = self.max_link_rate / scale
ml = rendering.Line((20, max_line + 20),
(screen_width - 20, max_line + 20))
ml.set_color(0.1, 0.9, .1)
self.viewer.add_onetime(ml)
# if self.state is None:
# return None
# x = self.state
# cartx = x[0] * scale + screen_width / 2.0 # MIDDLE OF CART
# self.carttrans.set_translation(cartx, carty)
# self.poletrans.set_rotation(-x[2])
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
