def make_moving_obstacle( # pylint: disable=unused-argument
obstacle: MovingObstacle, ) -> rendering.Geom:
pad = 0.8
geom = rendering.make_polygon(
[
(-pad, 0.0),
(0.0, pad),
(pad, 0.0),
(0.0, -pad),
],
filled=True,
)
geom.set_color(*RED)
geom_outline = rendering.make_polygon(
[
(-pad, 0.0),
(0.0, pad),
(pad, 0.0),
(0.0, -pad),
],
filled=False,
)
geom_outline.set_linewidth(3)
return Group([geom, geom_outline])
def _make_door_open( # pylint: disable=unused-argument
door: Door, ) -> rendering.Geom:
pad = 0.8
geoms_frame_background = [
rendering.make_polygon(
[(-1.0, -1.0), (-1.0, 1.0), (-pad, 1.0), (-pad, -1.0)],
filled=True,
),
rendering.make_polygon(
[(pad, -1.0), (pad, 1.0), (1.0, 1.0), (1.0, -1.0)],
filled=True,
),
rendering.make_polygon(
[(-1.0, -1.0), (-1.0, -pad), (1.0, -pad), (1.0, -1.0)],
filled=True,
),
rendering.make_polygon(
[(-1.0, pad), (-1.0, 1.0), (1.0, 1.0), (1.0, pad)],
filled=True,
),
]
geom_frame_background = rendering.Compound(geoms_frame_background)
geom_frame_background.set_color(*colormap[door.color])
geom_frame = rendering.make_polygon(
[(-pad, -pad), (-pad, pad), (pad, pad), (pad, -pad)],
filled=False,
)
return Group([geom_frame_background, geom_frame])
def render(self, mode='human'):
# TBD
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(1250, 600)
self.viewer.set_bounds(-50., 200., -10., 110.)
glider_shape = [(-10, -1), (4, -1), (5, -0.5), (5, 0), (1, 1),
(-2, 1), (-3, 0.5), (-4, -0.5), (-8.5, -0.5),
(-10, 1), (-10.5, 1)]
self.glider = rendering.make_polygon(glider_shape, filled=True)
self.glider.set_color(0, 0, 0)
self.glidertrans = rendering.Transform()
self.glider.add_attr(self.glidertrans)
wing_shape = [(-3, -0.25), (0, -0.5), (1, -0.4), (2, -0.25),
(1, -0.1), (0, 0)]
self.wing = rendering.make_polygon(wing_shape, filled=True)
self.wing.set_color(255, 0, 0)
self.wingtrans = rendering.Transform()
self.wing.add_attr(self.wingtrans)
elev_shape = [(-1.5, -0.25), (0, -0.5), (0.5, -0.4), (1, -0.25),
(0.5, -0.1), (0, 0)]
self.elev = rendering.make_polygon(elev_shape, filled=True)
self.elev.set_color(255, 0, 255)
self.elevtrans = rendering.Transform()
self.elev.add_attr(self.elevtrans)
# Draw the sea
self.viewer.draw_polygon([(-50, -50), (200, -50), (200, 0), (-50, 0)],
color=(0, 0, 255))
self.viewer.add_onetime(self.glider)
self.glidertrans.translation = (self.state[0], self.state[1])
self.glidertrans.rotation = (self.state[2])
self.viewer.add_onetime(self.wing)
self.wingtrans.translation = (self.state[0], self.state[1])
self.wingtrans.rotation = (self.state[2])
if self.last_eps is not None:
x0, y0, th = self.state[0], self.state[1], self.state[2]
Lt = 9.6
x = x0 - Lt * np.cos(th)
y = y0 - Lt * np.sin(th)
self.viewer.add_onetime(self.elev)
self.elevtrans.translation = (x, y)
self.elevtrans.rotation = (th + self.last_eps)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
# render image
scale = self.screen_width / self.world_width
origin = [self.screen_width / 10, self.screen_height / 10]
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.screen_width,
self.screen_height)
# plot robot with orientation
pursuit_radius = int(self.robot_radius * scale)
pursuit = rendering.make_polygon(
[(-pursuit_radius, pursuit_radius), (0, pursuit_radius),
(pursuit_radius, 0), (0, -pursuit_radius),
(-pursuit_radius, -pursuit_radius)],
filled=True)
pursuit.set_color(.8, .6, .4)
self.pursuit_trans = rendering.Transform()
pursuit.add_attr(self.pursuit_trans)
self.viewer.add_geom(pursuit)
# plot target with orientation
evader_radius = int(self.robot_radius * scale)
evader = rendering.make_polygon([(-evader_radius, evader_radius),
(0, evader_radius),
(evader_radius, 0),
(0, -evader_radius),
(-evader_radius, -evader_radius)])
evader.set_color(.5, .5, .8)
self.evader_trans = rendering.Transform()
evader.add_attr(self.evader_trans)
self.viewer.add_geom(evader)
# plot obstacles
for ob in self.ob_list:
ob_radius = self.ob_radius * scale
obstacle = rendering.make_circle(ob_radius)
obstacle.set_color(0, 0, 0)
obstacle.add_attr(
rendering.Transform(translation=(ob[0] * scale + origin[0],
ob[1] * scale +
origin[1])))
self.viewer.add_geom(obstacle)
self.pursuit_trans.set_translation(
self.get_state()[0] * scale + origin[0],
self.get_state()[1] * scale + origin[1])
self.pursuit_trans.set_rotation(self.get_state()[2])
self.evader_trans.set_translation(
self.get_goal()[0] * scale + origin[0],
self.get_goal()[1] * scale + origin[1])
self.evader_trans.set_rotation(self.get_goal()[2])
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def draw_startingEndPoint(self, rendering, cell_width, cell_height): start_pivot = ((self.start_pos[0]+0.5) * cell_width, ((self.map_height-self.start_pos[1])-0.5) * cell_height) start_points = self.get_vertex(start_pivot, cell_width, cell_height) start_polygon = rendering.make_polygon(start_points) start_polygon.set_color(0.8, 0.8, 1) self.viewer.add_geom(start_polygon) end_pivot = ((self.end_pos[0]+0.5) * cell_width, ((self.map_height-self.end_pos[1])-0.5) * cell_height) end_points = self.get_vertex(end_pivot, cell_width, cell_height) end_polygon = rendering.make_polygon(end_points) end_polygon.set_color(0.8, 0.6, 1) self.viewer.add_geom(end_polygon)
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.Viewer(self.width, self.height)
sz = self
oversize = 1.1
self.viewer.set_bounds(oversize * self.minx, oversize * self.maxx,
oversize * self.minx, oversize * self.maxx)
if self.ndim < 3:
self.goal = rendering.make_circle(.1)
else:
self.goal = rendering.make_polygon([(.1, 0), (-.1, .05),
(-.1, -.05), (.1, 0)])
self.goal.set_color(1, 0, 0)
self.goal_transform = rendering.Transform()
self.goal.add_attr(self.goal_transform)
self.viewer.add_geom(self.goal)
if self.ndim < 3:
puck = rendering.make_circle(.05)
else:
puck = rendering.make_polygon([(.1, 0), (-.1, .05),
(-.1, -.05), (.1, 0)])
puck.set_color(0, 0, 0)
self.puck_transform = rendering.Transform()
puck.add_attr(self.puck_transform)
self.viewer.add_geom(puck)
if self.ndim == 1:
self.goal_transform.set_translation(self.goalx[0], 0)
self.puck_transform.set_translation(self.x[0], 0)
elif self.ndim > 1:
self.goal_transform.set_translation(self.goalx[0], self.goalx[1])
self.puck_transform.set_translation(self.x[0], self.x[1])
if self.ndim == 3:
self.goal_transform.set_rotation(self.goalx[2] * np.pi)
self.puck_transform.set_rotation(self.x[2] * np.pi)
if np.all(abs(self.x - self.goalx) < self.deadband):
self.goal.set_color(0, 1, 0)
else:
self.goal.set_color(1, 0, 0)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def __init__(self):
radius = 50.0
res = 5 # 3-sided
points = [(np.cos(2 * np.pi * i / res) * radius,
np.sin(2 * np.pi * i / res) * radius) for i in range(res)]
points = [points[0], points[2], points[4], points[1], points[3]]
self.goal = rendering.make_polygon(points, False)
def render(self, mode='human'):
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(250, 100)
self.viewer.set_bounds(-5.0, 5.0, -2.0, 2.0)
w = 0.6; h = 0.4
l, r, t, b = -w/2, w/2, h/2, -h/2
box = rendering.make_polygon([(l,b), (l,t), (r,t), (r,b)])
box.set_color(.8, .3, .3)
self.box_transform = rendering.Transform()
box.add_attr(self.box_transform)
self.viewer.add_geom(box)
line = rendering.make_polyline([(-5,-h/2), (5,-h/2)])
line.set_color(0, 0, 0)
self.viewer.add_geom(line)
self.box_transform.set_translation(self.state[0], 0)
if self.last_u is not None:
arrow = rendering.make_polyline([(self.state[0], 0),
(self.state[0]+self.last_u, 0)])
arrow.set_linewidth(2)
self.viewer.add_onetime(arrow)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def create_viewer(self):
viewer = rendering.Viewer(self.screen_width, self.screen_height)
for light in self.maze.light_polygons:
light.transform(self.screen_width, self.screen_height)
polygon = rendering.make_polygon(light.polygon, filled=True)
polygon.set_color(light.color[0], light.color[1], light.color[2])
viewer.add_geom(polygon)
for wall in self.maze.walls:
wall.transform(self.screen_width, self.screen_height)
line = viewer.draw_line(wall.p1, wall.p2)
viewer.add_geom(line)
for border in self.maze.borders:
border.transform(self.screen_width, self.screen_height)
line = viewer.draw_line(border.p1, border.p2)
viewer.add_geom(line)
circle = rendering.make_circle(self.robot.radius)
self.robot_trans = rendering.Transform(translation=(self.screen_width / 2 + self.robot.x * self.scale, self.screen_height / 2 + self.robot.y * self.scale), rotation=0.0, scale=(self.scale, self.scale))
circle.add_attr(self.robot_trans)
viewer.add_geom(circle)
return viewer
def __init__(self, dynamic_body, ego, road):
super().__init__(occlusion=dynamic_body, ego=ego)
self.body = rendering.make_polygon(list(dynamic_body.bounding_box()))
if dynamic_body is ego:
self.body.set_color(*RGB.RED.value)
self.focal_road = road
if dynamic_body.bounding_box().intersects(
self.focal_road.bounding_box()):
self.road_angle = rendering.make_polyline(list())
else:
self.road_angle = rendering.make_polyline(
list(dynamic_body.line_anchor(self.focal_road)))
self.road_angle.set_color(*RGB.MAGENTA.value)
if dynamic_body.target_spline:
self.target_spline = rendering.make_polyline(
[tuple(point) for point in dynamic_body.target_spline])
self.target_spline.set_color(*RGB.GREEN.value)
else:
self.target_spline = None
if dynamic_body.planner_spline:
self.planner_spline = rendering.make_polyline(
[tuple(point) for point in dynamic_body.planner_spline])
self.planner_spline_markers = make_markers(
dynamic_body.planner_spline)
else:
self.planner_spline = rendering.make_polyline(list())
self.planner_spline_markers = make_markers(list())
self.planner_spline.set_color(*RGB.BLUE.value)
self.planner_spline_markers.set_color(*RGB.BLUE.value)
def __init__(self):
self.screen_width = 600
self.screen_height = 400
self.state = np.zeros(_NUM_DISTANCE_SENSOR, dtype=np.float32)
self.viewer = None
self.robot = Robot()
self.obstacles = []
for i in range(3):
obs = GeomContainer(
rendering.make_polygon(UNIT_SQUARE * 50),
lambda pos, angle: polyline_to_segmentlist(
rotate(UNIT_SQUARE, angle) * 50 + pos))
obs.set_color(0, 1, 0)
self.obstacles.append(obs)
self.obstacles.append(Wall([0, 0], [self.screen_width, 0], (0, 1, 0)))
self.obstacles.append(
Wall([self.screen_width, 0],
[self.screen_width, self.screen_height], (0, 1, 0)))
self.obstacles.append(
Wall([self.screen_width, self.screen_height],
[0, self.screen_height], (0, 1, 0)))
self.obstacles.append(Wall([0, self.screen_height], [0, 0], (0, 1, 0)))
#
self.visible_object = []
self.register_visible_object(self.robot)
for obs in self.obstacles:
self.register_visible_object(obs)
def __init__(self):
self.screen_width = 600
self.screen_height = 400
self.state = np.zeros(8, dtype=np.float32)
self.viewer = None
self.robot = Robot()
self.obstacles = []
self.edges = []
## add static obstacles
for i in range(15):
obs = GeomContainer(rendering.make_polygon(UNIT_SQUARE * 50),
lambda pos, angle: polyline_to_segmentlist(rotate(UNIT_SQUARE, angle) * 50 + pos))
obs.set_color(0, 1, 0)
self.obstacles.append(obs)
## add walls to surround the environment
self.edges.append(Wall([0, 0], [self.screen_width, 0], (0, 1, 0)))
self.edges.append(Wall([self.screen_width, 0], [self.screen_width, self.screen_height],
(0, 1, 0)))
self.edges.append(Wall([self.screen_width, self.screen_height], [0, self.screen_height],
(0, 1, 0)))
self.edges.append(Wall([0, self.screen_height], [0, 0], (0, 1, 0)))
self.visible_object = []
self.register_visible_object(self.robot)
for obs in self.obstacles:
self.register_visible_object(obs)
def __init__(self, **kwargs):
self.length = 20
self.width = 30
geom = rendering.make_polygon([(-self.width / 2, self.length / 2),
(self.width / 2, self.length / 2),
(self.width / 2, -self.length / 2),
(-self.width / 2, -self.length / 2)])
collider_func = None
GeomContainer.__init__(self, geom, collider_func=collider_func)
self.set_color(0, 0, 1)
self.sensors = []
for i in range(_NUM_DISTANCE_SENSOR):
dist_sensor = DistanceSensor(rendering.make_circle(5))
dist_sensor.set_color(1, 0, 0)
if i % 2 == 0:
dist_sensor.set_pos(
*(rotate([15, 0], 360 / _NUM_DISTANCE_SENSOR *
i, deg=True)))
else:
dist_sensor.set_pos(
*(rotate([10, 0], 360 / _NUM_DISTANCE_SENSOR *
i, deg=True)))
dist_sensor.set_angle(360 / _NUM_DISTANCE_SENSOR * i, True)
dist_sensor.add_attr(self.trans)
self.sensors.append(dist_sensor)
def __init__(self, pelican_crossing, ego, **kwargs):
super().__init__(**kwargs)
coordinates = pelican_crossing.bounding_box()
self.area = rendering.make_polygon(list(coordinates))
self.area.set_color(*RGB.WHITE.value)
self.markings = rendering.Compound([
rendering.make_polyline([
tuple(pelican_crossing.outbound_intersection_bounding_box.
rear_left),
tuple(pelican_crossing.outbound_intersection_bounding_box.
rear_right)
]),
rendering.make_polyline([
tuple(pelican_crossing.inbound_intersection_bounding_box.
front_left),
tuple(pelican_crossing.inbound_intersection_bounding_box.
front_right)
]),
rendering.make_polyline([
tuple(pelican_crossing.static_bounding_box.rear_left),
tuple(pelican_crossing.static_bounding_box.front_left)
]),
rendering.make_polyline([
tuple(pelican_crossing.static_bounding_box.rear_right),
tuple(pelican_crossing.static_bounding_box.front_right)
])
])
offset_rear_right = Point(
coordinates.rear_right.x +
(pelican_crossing.constants.width * 0.15),
coordinates.rear_right.y)
offset_rear_left = Point(
coordinates.rear_left.x +
(pelican_crossing.constants.width * 0.15), coordinates.rear_left.y)
offset_front_right = Point(
coordinates.front_right.x -
(pelican_crossing.constants.width * 0.15),
coordinates.front_right.y)
offset_front_left = Point(
coordinates.front_left.x -
(pelican_crossing.constants.width * 0.15),
coordinates.front_left.y)
self.inner = rendering.Compound([
rendering.make_polyline(
[tuple(offset_rear_right),
tuple(offset_rear_left)]),
rendering.make_polyline(
[tuple(offset_front_right),
tuple(offset_front_left)])
])
self.inner.add_attr(mods.FactoredLineStyle(0x0F0F, 1))
self.outbound_traffic_light_view = TrafficLightView(
pelican_crossing.outbound_traffic_light, ego)
self.inbound_traffic_light_view = TrafficLightView(
pelican_crossing.inbound_traffic_light, ego)
def setup_render(self, viewer):
from gym.envs.classic_control import rendering
road_poly = self.vertices
self.geom = rendering.make_polygon(road_poly)
self.xform = rendering.Transform()
self.geom.add_attr(self.xform)
self.geom.set_color(*ROAD_COLOR)
viewer.add_geom(self.geom)
def make_hidden( # pylint: disable=unused-argument
hidden: Hidden, ) -> rendering.Geom:
geom = rendering.make_polygon(
[(-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0)],
filled=True,
)
return geom
def __init__(self, car, ego, road):
super().__init__(car, ego, road)
self.roof = rendering.make_polygon(list(car.roof()))
if car is ego:
self.roof.set_color(0.5, 0, 0)
else:
self.roof.set_color(0.5, 0.5, 0.5)
def make_rect(row, col, cr, cg, cb):
l, r, t, b = 0, 1, 0, -1
wall = rendering.make_polygon([(l, b), (l, t), (r, t), (r, b)])
wall.set_color(cr, cg, cb)
wall_transform = rendering.Transform()
wall_transform.set_translation(col, MAX_BOARD_SIZE[0] - row)
wall.add_attr(wall_transform)
return wall
def make_agent() -> rendering.Geom:
pad = 0.7
geom_agent = rendering.make_polygon([(-pad, -pad), (0.0, pad),
(pad, -pad)],
filled=False)
geom_agent.set_linewidth(3)
geom_agent.set_color(*BLUE)
return geom_agent
def render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(self.size_c * UNIT,
self.size_r * UNIT)
# render playground
m = np.copy(self.grids)
g = 0 # the gap between grids
for x in (range(self.size_c)):
for y in (range(self.size_r)):
# the coordinates of 4 angle of the grid
v = [(x * UNIT + g, y * UNIT + g),
((x + 1) * UNIT - g, y * UNIT + g),
((x + 1) * UNIT - g, (y + 1) * UNIT - g),
(x * UNIT + g, (y + 1) * UNIT - g)]
grid = rendering.FilledPolygon(v)
if m[(self.size_r - 1) - y,
x] == 1: # the block, notice the correspondence between numpy and pyglet
grid.set_color(0, 0, 0) # black
else:
grid.set_color(0, 0.5, 0) # green
if m[(self.size_r - 1) - y, x] == 3: # goal
grid.set_color(135 / 255, 206 / 255, 235 / 255) # sky blue
self.viewer.add_geom(grid)
# draw outline
v_outline = v
outline = rendering.make_polygon(v_outline, False)
outline.set_linewidth(1)
outline.set_color(0, 0, 0)
self.viewer.add_geom(outline)
# render agent
self.agent_render = rendering.make_circle(UNIT / 2, 30, True)
self.agent_render.set_color(1.0, 1.0, 1.0) # white
self.viewer.add_geom(self.agent_render)
self.agent_trans = rendering.Transform()
self.agent_render.add_attr(
self.agent_trans) # agent position change update
agent_r, agent_c = self.agent[0], self.agent[
1] # the row and column of agent
agent_x, agent_y = agent_c, (
self.size_r -
1) - agent_r # the relationship between array and coordinates
self.agent_trans.set_translation((agent_x + 0.5) * UNIT,
(agent_y + 0.5) * UNIT)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def make_capsule(length, width, *, filled=True):
l, r, t, b = 0, length, width / 2, -width / 2
box = rendering.make_polygon([(l, b), (l, t), (r, t), (r, b)],
filled=filled)
circ0 = rendering.make_circle(width / 2, filled=filled)
circ1 = rendering.make_circle(width / 2, filled=filled)
circ1.add_attr(rendering.Transform(translation=(length, 0)))
geom = Group([box, circ0, circ1])
return geom
def render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
unit = 50
screen_width = 5 * unit
screen_height = 5 * unit
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
#创建网格
for c in range(5):
line = rendering.Line((0, c * unit), (screen_width, c * unit))
line.set_color(0, 0, 0)
self.viewer.add_geom(line)
for r in range(5):
line = rendering.Line((r * unit, 0), (r * unit, screen_height))
line.set_color(0, 0, 0)
self.viewer.add_geom(line)
# 创建墙壁
for x, y in self.walls:
r = rendering.make_polygon(
v=[[x * unit, y *
unit], [(x + 1) * unit, y *
unit], [(x + 1) * unit, (y + 1) *
unit], [x * unit, (y + 1) *
unit], [x * unit, y * unit]])
r.set_color(0, 0, 0)
self.viewer.add_geom(r)
# 创建机器人
self.robot = rendering.make_circle(20)
self.robotrans = rendering.Transform()
self.robot.add_attr(self.robotrans)
self.robot.set_color(0.8, 0.6, 0.4)
self.viewer.add_geom(self.robot)
# 创建出口
self.exit = rendering.make_circle(20)
self.exitrans = rendering.Transform(
translation=(4 * unit + unit / 2, 2 * unit + unit / 2))
self.exit.add_attr(self.exitrans)
self.exit.set_color(0, 1, 0)
self.viewer.add_geom(self.exit)
if self.__state is None:
return None
self.robotrans.set_translation(self.__state[0] * unit + unit / 2,
self.__state[1] * unit + unit / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def make_box(x, y, w, h, color=None):
from gym.envs.classic_control import rendering
poly = rendering.make_polygon([(x, y), (x, y + h), (x + w, y + h),
(x + w, y)],
filled=True)
if color is not None:
poly.set_color(*color)
return poly
def render(self, mode='human'):
screen_width = 600
screen_height = 600
world_width = self.max_x - self.min_y
scale = screen_width / world_width
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
xs = [0, 2, 3, 2, 0]
ys = [1, 1, 0, -1, -1]
for i in range(5):
xs[i] *= 10
ys[i] *= 10
print(xs)
xys = list(zip(xs, ys))
vessel_circle = rendering.make_polygon(xys)
# vessel.add_attr(rendering.Transform(translation=(0, 0)))
vessel_circle.set_color(.0, .0, 1)
self.cartrans = rendering.Transform()
vessel_circle.add_attr(self.cartrans)
self.viewer.add_geom(vessel_circle)
obstacles = [
rendering.make_circle(self.obstacles_radius * scale)
for _ in range(self.obstacles_number)
]
self.obstacles_cp = []
for o, pos in zip(obstacles, self.obstacles_position):
o.set_color(1, 0, 0)
x = (pos[0] - self.min_x) * scale
y = (pos[1] - self.min_y) * scale
# o.add_attr(rendering.Transform(translation=(x, y)))
self.obstacles_cp.append([rendering.Transform(), [x, y]])
o.add_attr(self.obstacles_cp[-1][0])
self.viewer.add_geom(o)
target = rendering.make_circle(self.goal_radius * scale)
target.set_color(.0, 1, 0)
self.target_c = rendering.Transform()
target.add_attr(rendering.Transform(translation=(0, 0)))
target.add_attr(self.target_c)
self.viewer.add_geom(target)
pos = [self.vessel_position_x, self.vessel_position_y]
self.cartrans.set_translation((pos[0] - self.min_x) * scale,
(pos[1] - self.min_y) * scale)
self.cartrans.set_rotation(self.vessel_head_angle)
self.target_c.set_translation((2.5 - self.min_x) * scale,
(2.5 - self.min_y) * scale)
for c, p in self.obstacles_cp:
c.set_translation(p[0], p[1])
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
u_size = self.u_size
m = 2 # gap between grids
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.width, self.height)
for i in range(self.n_width + 1):
line = rendering.Line(start=(i * u_size, 0),
end=(i * u_size, u_size * self.n_height))
self.viewer.add_geom(line)
for i in range(self.n_height):
line = rendering.Line(start=(0, i * u_size),
end=(u_size * self.n_width, i * u_size))
self.viewer.add_geom(line)
# draw grids
for x in range(self.n_width):
for y in range(self.n_height):
v = [(x * u_size + m, y * u_size + m),
((x + 1) * u_size - m, y * u_size + m),
((x + 1) * u_size - m, (y + 1) * u_size - m),
(x * u_size + m, (y + 1) * u_size - m)]
rect = rendering.FilledPolygon(v)
rect.set_color(1.0, 1.0, 1.0)
self.viewer.add_geom(rect)
# frame
v_outline = [(x * u_size + m, y * u_size + m),
((x + 1) * u_size - m, y * u_size + m),
((x + 1) * u_size - m, (y + 1) * u_size - m),
(x * u_size + m, (y + 1) * u_size - m)]
outline = rendering.make_polygon(v_outline, False)
outline.set_linewidth(10)
if self._is_end_state(x, y):
self.viewer.add_geom(outline)
if self.start[0] == x and self.start[1] == y:
self.viewer.add_geom(outline)
# agent
self.agent = rendering.make_circle(u_size / 4, 30, True)
self.viewer.add_geom(self.agent)
self.agent_trans = rendering.Transform()
self.agent.add_attr(self.agent_trans)
x, y = self._state_to_xy(self.state)
self.agent_trans.set_translation((x + 0.5) * u_size,
(y + 0.5) * u_size)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 500
screen_height = 500
world_width = 15
scale = screen_width / world_width
target_radius = 0.3
car_radius = 0.1
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
self.viewer.set_bounds(0, 15, 0, 15)
self.red = rendering.make_circle(target_radius)
self.green = rendering.make_circle(target_radius)
self.blue = rendering.make_circle(target_radius)
self.red.set_color(1., 0., 0.)
self.green.set_color(0., 1., 0.)
self.blue.set_color(0., 0., 1.)
self.red_trans = rendering.Transform()
self.green_trans = rendering.Transform()
self.blue_trans = rendering.Transform()
self.red.add_attr(self.red_trans)
self.green.add_attr(self.green_trans)
self.blue.add_attr(self.blue_trans)
self.viewer.add_geom(self.red)
self.viewer.add_geom(self.green)
self.viewer.add_geom(self.blue)
self.car = rendering.make_circle(car_radius)
self.car.set_color(0., 0., 0.)
self.car_trans = rendering.Transform()
self.car.add_attr(self.car_trans)
self.viewer.add_geom(self.car)
self.car_orientation = rendering.make_polygon([(0, 0.2), (0, -0.2),
(0.4, 0)])
self.car_orientation.set_color(1., 0., 1.)
self.rotation = rendering.Transform()
self.car_orientation.add_attr(self.rotation)
self.viewer.add_geom(self.car_orientation)
self.red_trans.set_translation(self.red_position[0],
self.red_position[1])
self.green_trans.set_translation(self.green_position[0],
self.green_position[1])
self.blue_trans.set_translation(self.blue_position[0],
self.blue_position[1])
self.car_trans.set_translation(self.new_position[0],
self.new_position[1])
self.rotation.set_translation(self.new_position[0],
self.new_position[1])
self.rotation.set_rotation(self.orientation)
return self.viewer.render(return_rgb_array=(mode == 'rgb_array'))
def __init__(self, road):
self.area = rendering.make_polygon(list(road.static_bounding_box))
self.area.set_color(*RGB.WHITE.value)
coordinates = road.bounding_box()
self.edge_markings = rendering.Compound([
rendering.make_polyline(
[tuple(coordinates.rear_left),
tuple(coordinates.front_left)]),
rendering.make_polyline([
tuple(coordinates.rear_right),
tuple(coordinates.front_right)
])
])
outbound_coordinates = road.outbound.bounding_box()
self.centre_markings = rendering.make_polyline([
tuple(outbound_coordinates.rear_right),
tuple(outbound_coordinates.front_right)
])
self.centre_markings.add_attr(mods.FactoredLineStyle(0x00FF, 2))
lane_lines = list()
for lane in road.outbound.lanes[:-1] + road.inbound.lanes[:-1]:
lane_coordinates = lane.bounding_box()
lane_line = rendering.make_polyline([
tuple(lane_coordinates.rear_right),
tuple(lane_coordinates.front_right)
])
lane_lines.append(lane_line)
self.lane_markings = rendering.Compound(lane_lines)
self.lane_markings.add_attr(mods.FactoredLineStyle(0x00FF, 2))
self.pelican_crossing_view = None
self.bus_stop_views = list()
for direction in [road.outbound, road.inbound]:
if direction.bus_stop is not None:
markings = rendering.make_polygon(list(
direction.bus_stop.static_bounding_box),
filled=False)
self.bus_stop_views.append(markings)
def _get_geoms(self):
from gym.envs.classic_control import rendering
ice_shape = [
[-self.max_position, -self.max_position / 2],
[-self.max_position, self.max_position / 2],
[self.max_position, self.max_position / 2],
[self.max_position, -self.max_position / 2],
]
ice = rendering.make_polygon(v=ice_shape, filled=True)
ice.set_color(0.65, 0.95, 0.96)
return [ice] + super()._get_geoms()
def _make_door_closed_unlocked( # pylint: disable=unused-argument
door: Door, ) -> rendering.Geom:
geom_door = rendering.make_polygon(
# [(-0.8, -0.8), (-0.8, 0.8), (0.8, 0.8), (0.8, -0.8)], filled=True,
[(-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0)],
filled=True,
)
geom_door.set_color(*colormap[door.color])
pad = 0.8
geom_frame = rendering.make_polygon(
[(-pad, -pad), (-pad, pad), (pad, pad), (pad, -pad)],
filled=False,
)
geom_handle = rendering.make_circle(radius=0.2, res=10, filled=False)
geom_handle.add_attr(rendering.Transform(translation=(0.4, 0.0)))
return Group([geom_door, geom_frame, geom_handle])
def render(self, mode='human', close=False):
if close:
if self.viewer:
self.viewer.close()
self.viewer = None
return
screen_width = 600
screen_height = 600
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
# 创建网格界面
for i in range(100, 501, 80):
line = rendering.Line((100, i), (500, i))
line.set_color(0, 0, 0)
self.viewer.add_geom(line)
line = rendering.Line((i, 100), (i, 500))
line.set_color(0, 0, 0)
self.viewer.add_geom(line)
for i in [4, 9, 11, 12, 23, 24, 25]:
cp = [self.x[i - 1], self.y[i - 1]]
wall = rendering.make_polygon([(cp[0] - 40, cp[1] - 40),
(cp[0] - 40, cp[1] + 40),
(cp[0] + 40, cp[1] + 40),
(cp[0] + 40, cp[1] - 40)],
filled=True)
wall.set_color(0, 0, 0)
self.viewer.add_geom(wall)
exit = rendering.make_circle(40)
exit_id = 15
exit.add_attr(
rendering.Transform(
translation=([self.x[exit_id - 1], self.y[exit_id - 1]])))
exit.set_color(1, 0.9, 0)
self.viewer.add_geom(exit)
robot = rendering.make_circle(30)
self.robotrans = rendering.Transform()
robot.add_attr(self.robotrans)
robot.set_color(0.8, 0.6, 0.4)
self.viewer.add_geom(robot)
if self.state is None:
return None
self.robotrans.set_translation(self.x[self.state - 1],
self.y[self.state - 1])
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='h'):
from gym.envs.classic_control import rendering
screen_width = 600
screen_height = 600
self.viewer = rendering.Viewer(screen_width, screen_height)
#################################
## create grid world
lines = []
### horizontals
for y in range(100, 580, 80):
x1, x2 = 100, 500
li = rendering.Line((x1, y), (x2, y))
lines.append(li)
### verticals
for x in range(100, 580, 80):
y1, y2 = 100, 500
li = rendering.Line((x, y1), (x, y2))
lines.append(li)
### create black squares
vertices1 = [(100, 260), (100, 340), (180, 340), (180, 260)]
vertices2 = [(260, 260), (260, 340), (180, 340), (180, 260)]
vertices3 = [(260, 180), (260, 100), (340, 100), (340, 180)]
vertices4 = [(420, 180), (420, 100), (340, 100), (340, 180)]
vertices5 = [(420, 180), (420, 100), (500, 100), (500, 180)]
vertices6 = [(340, 420), (420, 420), (420, 340), (340, 340)]
vertices7 = [(340, 420), (420, 420), (420, 500), (340, 500)]
vertices = [
vertices1, vertices2, vertices3, vertices4, vertices5, vertices6,
vertices7
]
filledSquares = []
for v in vertices:
square = rendering.make_polygon(v, filled=True)
square.set_color(0, 0, 0)
filledSquares.append(square)
## create exit
exit = rendering.make_circle(40)
trans = rendering.Transform(translation=(460, 300))
exit.add_attr(trans)
exit.set_color(255, 0, 0)
## add objects
for line in lines:
self.viewer.add_geom(line)
for square in filledSquares:
self.viewer.add_geom(square)
self.viewer.add_geom(exit)
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
zero = (0, 0)
u_size = self.u_size
m = 2 # 格子之间的间隙尺寸
# 如果还没有设定屏幕对象，则初始化整个屏幕具备的元素。
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.width, self.height)
# 在Viewer里绘制一个几何图像的步骤如下：
# 1. 建立该对象需要的数据本身
# 2. 使用rendering提供的方法返回一个geom对象
# 3. 对geom对象进行一些对象颜色、线宽、线型、变换属性的设置（有些对象提供一些个
# 性化的方法来设置属性，具体请参考继承自这些Geom的对象），这其中有一个重要的
# 属性就是变换属性，
# 该属性负责对对象在屏幕中的位置、渲染、缩放进行渲染。如果某对象
# 在呈现时可能发生上述变化，则应建立关于该对象的变换属性。该属性是一个
# Transform对象，而一个Transform对象，包括translate、rotate和scale
# 三个属性，每个属性都由以np.array对象描述的矩阵决定。
# 4. 将新建立的geom对象添加至viewer的绘制对象列表里，如果在屏幕上只出现一次，
# 将其加入到add_onegeom(）列表中，如果需要多次渲染，则将其加入add_geom()
# 5. 在渲染整个viewer之前，对有需要的geom的参数进行修改，修改主要基于该对象
# 的Transform对象
# 6. 调用Viewer的render()方法进行绘制
''' 绘制水平竖直格子线，由于设置了格子之间的间隙，可不用此段代码
for i in range(self.n_width+1):
line = rendering.Line(start = (i*u_size, 0),
end =(i*u_size, u_size*self.n_height))
line.set_color(0.5,0,0)
self.viewer.add_geom(line)
for i in range(self.n_height):
line = rendering.Line(start = (0, i*u_size),
end = (u_size*self.n_width, i*u_size))
line.set_color(0,0,1)
self.viewer.add_geom(line)
'''
# 绘制格子
for x in range(self.n_width):
for y in range(self.n_height):
v = [(x * u_size + m, y * u_size + m),
((x + 1) * u_size - m, y * u_size + m),
((x + 1) * u_size - m, (y + 1) * u_size - m),
(x * u_size + m, (y + 1) * u_size - m)]
rect = rendering.FilledPolygon(v)
r = self.grids.get_reward(x, y) / 10
if r < 0:
rect.set_color(0.9 - r, 0.9 + r, 0.9 + r)
elif r > 0:
rect.set_color(0.3, 0.5 + r, 0.3)
else:
rect.set_color(0.9, 0.9, 0.9)
self.viewer.add_geom(rect)
# 绘制边框
v_outline = [(x * u_size + m, y * u_size + m),
((x + 1) * u_size - m, y * u_size + m),
((x + 1) * u_size - m, (y + 1) * u_size - m),
(x * u_size + m, (y + 1) * u_size - m)]
outline = rendering.make_polygon(v_outline, False)
outline.set_linewidth(3)
if self._is_end_state(x, y):
# 给终点方格添加金黄色边框
outline.set_color(0.9, 0.9, 0)
self.viewer.add_geom(outline)
if self.start[0] == x and self.start[1] == y:
outline.set_color(0.5, 0.5, 0.8)
self.viewer.add_geom(outline)
if self.grids.get_type(x, y) == 1: # 障碍格子用深灰色表示
rect.set_color(0.3, 0.3, 0.3)
else:
pass
# 绘制个体
self.agent = rendering.make_circle(u_size / 4, 30, True)
self.agent.set_color(1.0, 1.0, 0.0)
self.viewer.add_geom(self.agent)
self.agent_trans = rendering.Transform()
self.agent.add_attr(self.agent_trans)
# 更新个体位置
x, y = self._state_to_xy(self.state)
self.agent_trans.set_translation((x + 0.5) * u_size, (y + 0.5) * u_size)
return self.viewer.render(return_rgb_array= mode == 'rgb_array')
def make_player():
l, c, r, t, m, b = 0, 0.5, 1, 0, -0.5, -1
player = rendering.make_polygon([(l, m), (c, t), (r, m), (c, b)])
player.set_color(0.0, 0.0, 1.0)
return player
