def render(self, mode='human'):
"""
Renders the environment.
The set of supported modes varies per environment. (And some
environments do not support rendering at all.) By convention,
if mode is:
- human: render to the current display or terminal and
return nothing. Usually for human consumption.
- rgb_array: Return an numpy.ndarray with shape (x, y, 3),
representing RGB values for an x-by-y pixel image, suitable
for turning into a video.
- ansi: Return a string (str) or StringIO.StringIO containing a
terminal-style text representation. The text can include newlines
and ANSI escape sequences (e.g. for colors).
:param mode: Render mode, one of [human|rgb_array], default human
:type mode: str, optional
:return: Rendered image.
"""
screen_width = 500
screen_height = 500
world_width = 4
scale = screen_width / world_width
pole_width = 10.0
pole_len = scale * (2 * self.pole_length)
cart_width = 50.0
cart_height = 30.0
cart_y = screen_height / 2
if self.viewer is None:
# noinspection PyBroadException
try:
from gym.envs.classic_control import rendering
except:
if not self._logged_headless_message:
print(
'Unable to connect to display. Running the Ivy environment in headless mode...'
)
self._logged_headless_message = True
return
self.viewer = rendering.Viewer(screen_width, screen_height)
# Track.
track = rendering.Line((0., cart_y), (screen_width, cart_y))
track.set_color(0., 0., 0.)
self.viewer.add_geom(track)
# Cart.
l = -cart_width / 2
r = cart_width / 2
t = cart_height / 2
b = -cart_height / 2
cart_geom = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.cart_tr = rendering.Transform()
cart_geom.add_attr(self.cart_tr)
cart_geom.set_color(0., 0., 0.)
self.viewer.add_geom(cart_geom)
# Pole.
l = -pole_width / 2
r = pole_width / 2
t = pole_len - pole_width / 2
b = -pole_width / 2
self.pole_geom = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.pole_tr = rendering.Transform(translation=(0, 0))
self.pole_geom.add_attr(self.pole_tr)
self.pole_geom.add_attr(self.cart_tr)
self.viewer.add_geom(self.pole_geom)
# Axle.
axle_geom = rendering.make_circle(pole_width / 2)
axle_geom.add_attr(self.pole_tr)
axle_geom.add_attr(self.cart_tr)
axle_geom.set_color(0.5, 0.5, 0.5)
self.viewer.add_geom(axle_geom)
cart_x = ivy.to_numpy(self.x * scale + screen_width / 2.0)[0]
self.cart_tr.set_translation(cart_x, cart_y)
self.pole_tr.set_rotation(-ivy.to_numpy(self.angle)[0])
rew = ivy.to_numpy(self.get_reward())[0]
self.pole_geom.set_color(1 - rew, rew, 0.)
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
screen_width = 600
screen_height = 600 # before was 400
world_width = 5 # max visible position of cart
scale = screen_width / world_width
carty = screen_height / 2 # TOP OF CART
polewidth = 6.0
polelen = scale * self.l # 0.6 or self.l
cartwidth = 40.0
cartheight = 20.0
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
l, r, t, b = -cartwidth / 2, cartwidth / 2, cartheight / 2, -cartheight / 2
cart = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
self.carttrans = rendering.Transform()
cart.add_attr(self.carttrans)
cart.set_color(1, 0, 0)
self.viewer.add_geom(cart)
l, r, t, b = -polewidth / 2, polewidth / 2, polelen - polewidth / 2, -polewidth / 2
pole = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole.set_color(0, 0, 1)
self.poletrans = rendering.Transform(translation=(0, 0))
pole.add_attr(self.poletrans)
pole.add_attr(self.carttrans)
self.viewer.add_geom(pole)
self.axle = rendering.make_circle(polewidth / 2)
self.axle.add_attr(self.poletrans)
self.axle.add_attr(self.carttrans)
self.axle.set_color(0.1, 1, 1)
self.viewer.add_geom(self.axle)
# Make another circle on the top of the pole
self.pole_bob = rendering.make_circle(polewidth / 2)
self.pole_bob_trans = rendering.Transform()
self.pole_bob.add_attr(self.pole_bob_trans)
self.pole_bob.add_attr(self.poletrans)
self.pole_bob.add_attr(self.carttrans)
self.pole_bob.set_color(0, 0, 0)
self.viewer.add_geom(self.pole_bob)
self.wheel_l = rendering.make_circle(cartheight / 4)
self.wheel_r = rendering.make_circle(cartheight / 4)
self.wheeltrans_l = rendering.Transform(
translation=(-cartwidth / 2, -cartheight / 2))
self.wheeltrans_r = rendering.Transform(translation=(cartwidth / 2,
-cartheight /
2))
self.wheel_l.add_attr(self.wheeltrans_l)
self.wheel_l.add_attr(self.carttrans)
self.wheel_r.add_attr(self.wheeltrans_r)
self.wheel_r.add_attr(self.carttrans)
self.wheel_l.set_color(0, 0, 0) # Black, (B, G, R)
self.wheel_r.set_color(0, 0, 0) # Black, (B, G, R)
self.viewer.add_geom(self.wheel_l)
self.viewer.add_geom(self.wheel_r)
self.track = rendering.Line(
(screen_width / 2 - self.x_threshold * scale,
carty - cartheight / 2 - cartheight / 4),
(screen_width / 2 + self.x_threshold * scale,
carty - cartheight / 2 - cartheight / 4))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
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])
self.pole_bob_trans.set_translation(-self.l * np.sin(x[2]),
self.l * np.cos(x[2]))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 600
screen_height = 600
scale = screen_width / 120
latplane = self.state[0]
lonplane = self.state[1]
latplane2 = self.state_object[0]
lonplane2 = self.state_object[1]
length_plane = 1 * scale
if self.viewer is None:
#set start position
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
plane = rendering.FilledPolygon([(-length_plane, -length_plane),
(0, length_plane),
(length_plane, -length_plane)
]) # NOSEUP
x_plane, y_plane = latlon_to_screen(-1, -1, latplane, lonplane,
scale)
plane.add_attr(rendering.Transform(translation=(x_plane, y_plane)))
self.planetrans = rendering.Transform()
plane.add_attr(self.planetrans)
plane.set_color(0, 1, 0)
self.viewer.add_geom(plane)
plane2 = rendering.FilledPolygon([(-length_plane, -length_plane),
(0, length_plane),
(length_plane, -length_plane)
]) # NOSEUP
x_plane2, y_plane2 = latlon_to_screen(-1, -1, latplane2, lonplane2,
scale)
plane2.add_attr(
rendering.Transform(translation=(x_plane2, y_plane2)))
self.planetrans2 = rendering.Transform()
plane2.add_attr(self.planetrans2)
plane.set_color(1, 0, 0)
self.viewer.add_geom(plane2)
waypoint = rendering.make_circle(3)
x_waypoint, y_waypoint = latlon_to_screen(-1, -1,
bs.traf.actwp.lat[0],
bs.traf.actwp.lon[0],
scale)
waypoint.add_attr(
rendering.Transform(translation=(x_waypoint, y_waypoint)))
self.viewer.add_geom(waypoint)
self.latplane_init = latplane
self.lonplane_init = lonplane
self.latplane2_init = latplane2
self.lonplane2_init = lonplane2
x_screen_dx, y_screen_dy = dlatlon_to_screen(self.latplane_init,
self.lonplane_init,
latplane, lonplane, scale)
self.planetrans.set_translation(x_screen_dx, y_screen_dy)
# self.planetrans.set_rotation(1)
x_screen_dx2, y_screen_dy2 = dlatlon_to_screen(self.latplane2_init,
self.lonplane2_init,
latplane2, lonplane2,
scale)
self.planetrans2.set_translation(x_screen_dx2, y_screen_dy2)
# self.planetrans2.set_rotation(self.state_object[2]*0.0174532925)
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
screen_width = 600
screen_height = 400
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
# 创建网格世界
self.line1 = rendering.Line((100, 300), (500, 300))
self.line2 = rendering.Line((100, 200), (500, 200))
self.line3 = rendering.Line((100, 300), (100, 100))
self.line4 = rendering.Line((180, 300), (180, 100))
self.line5 = rendering.Line((260, 300), (260, 100))
self.line6 = rendering.Line((340, 300), (340, 100))
self.line7 = rendering.Line((420, 300), (420, 100))
self.line8 = rendering.Line((500, 300), (500, 100))
self.line9 = rendering.Line((100, 100), (180, 100))
self.line10 = rendering.Line((260, 100), (340, 100))
self.line11 = rendering.Line((420, 100), (500, 100))
# 创建第一个骷髅
self.kulo1 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(140, 150))
self.kulo1.add_attr(self.circletrans)
self.kulo1.set_color(0, 0, 0)
# 创建第二个骷髅
self.kulo2 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(460, 150))
self.kulo2.add_attr(self.circletrans)
self.kulo2.set_color(0, 0, 0)
# 创建金条
self.gold = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(300, 150))
self.gold.add_attr(self.circletrans)
self.gold.set_color(1, 0.9, 0)
# 创建机器人
self.robot = rendering.make_circle(30)
self.robotrans = rendering.Transform()
self.robot.add_attr(self.robotrans)
self.robot.set_color(0.8, 0.6, 0.4)
self.line1.set_color(0, 0, 0)
self.line2.set_color(0, 0, 0)
self.line3.set_color(0, 0, 0)
self.line4.set_color(0, 0, 0)
self.line5.set_color(0, 0, 0)
self.line6.set_color(0, 0, 0)
self.line7.set_color(0, 0, 0)
self.line8.set_color(0, 0, 0)
self.line9.set_color(0, 0, 0)
self.line10.set_color(0, 0, 0)
self.line11.set_color(0, 0, 0)
self.viewer.add_geom(self.line1)
self.viewer.add_geom(self.line2)
self.viewer.add_geom(self.line3)
self.viewer.add_geom(self.line4)
self.viewer.add_geom(self.line5)
self.viewer.add_geom(self.line6)
self.viewer.add_geom(self.line7)
self.viewer.add_geom(self.line8)
self.viewer.add_geom(self.line9)
self.viewer.add_geom(self.line10)
self.viewer.add_geom(self.line11)
self.viewer.add_geom(self.kulo1)
self.viewer.add_geom(self.kulo2)
self.viewer.add_geom(self.gold)
self.viewer.add_geom(self.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='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
scale = self.width / self.l_unit # 计算两者映射关系
rad = self.rad * scale # 随后都是用世界尺寸来描述
t_rad = self.target_rad * scale # target radius
action = self.action
if action is None:
length = 0.00
else:
length = np.sqrt(np.sum(np.dot(action, action)))
#print(action, length)
# 如果还没有设定屏幕对象，则初始化整个屏幕具备的元素。
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()方法进行绘制
target = rendering.make_circle(t_rad, 30, True)
target.set_color(0.1, 0.9, 0.1)
self.viewer.add_geom(target)
target_circle = rendering.make_circle(t_rad, 30, False)
target_circle.set_color(0, 0, 0)
self.viewer.add_geom(target_circle)
self.target_trans = rendering.Transform()
target.add_attr(self.target_trans)
target_circle.add_attr(self.target_trans)
self.agent = rendering.make_circle(rad, 30, True)
self.agent.set_color(0, 1, 0)
self.viewer.add_geom(self.agent)
self.agent_trans = rendering.Transform()
self.agent.add_attr(self.agent_trans)
agent_circle = rendering.make_circle(rad, 30, False)
agent_circle.set_color(0, 0, 0)
agent_circle.add_attr(self.agent_trans)
self.viewer.add_geom(agent_circle)
start_p = (0, 0)
end_p = (0.7 * rad * length, 0)
self.line = rendering.Line(start_p, end_p)
self.line.linewidth = rad / 10
self.line_trans = rendering.Transform()
self.line.add_attr(self.line_trans)
self.viewer.add_geom(self.line)
self.arrow = rendering.FilledPolygon([
(0.7 * rad * length, 0.15 * rad), (rad * length, 0),
(0.7 * rad * length, -0.15 * rad)
])
self.arrow.set_color(0, 0, 0)
self.arrow.add_attr(self.line_trans)
self.viewer.add_geom(self.arrow)
# 如果已经为屏幕准备好了要绘制的对象
# 本例中唯一要做的就是改变小车的位置和旋转
ppx, ppy, _, _, tx, ty = self.state
self.target_trans.set_translation(tx * scale, ty * scale)
self.agent_trans.set_translation(ppx * scale, ppy * scale)
# 按距离给Agent着色
vv, ms = self.reward + 0.3, 1
r, g, b, = 0, 1, 0
if vv >= 0:
r, g, b = 1 - ms * vv, 1, 1 - ms * vv
else:
r, g, b = 1, 1 + ms * vv, 1 + ms * vv
self.agent.set_color(r, g, b)
if length == 0:
self.line.set_color(r, g, b)
self.arrow.set_color(r, g, b) # 背景色
else:
if action[1] >= 0:
rotate = math.acos(action[0] / length) # action[0]水平方向
else: # 垂直方向
rotate = 2 * math.pi - math.acos(action[0] / length)
self.line_trans.set_translation(ppx * scale, ppy * scale)
self.line_trans.set_rotation(rotate)
self.line.set_color(0, 0, 0)
self.arrow.set_color(0, 0, 0)
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
if self.viewer is None:
self.viewer = rendering.Viewer(SCREEN_WIDTH, SCREEN_HEIGHT)
self.viewer.set_bounds(0, SCREEN_WIDTH / SCALE, 0,
SCREEN_HEIGHT / SCALE) #
# Draw fire
for obj in self.fire:
obj.ttl -= 0.15
# Change fire particles color (RGB)
particle_color = (max(0.2, 0.2 + obj.ttl), max(0.2, 0.5 * obj.ttl),
max(0.2, 0.5 * obj.ttl))
obj.color1 = particle_color
obj.color2 = particle_color
self._clean_fire(False)
# Draw sky
self.viewer.draw_polygon([(0, 0), (0, SCREEN_HEIGHT),
(SCREEN_WIDTH, SCREEN_HEIGHT),
(SCREEN_WIDTH, 0)],
color=SKY_COLOR)
# Draw relief
for p in self.relief_coords:
self.viewer.draw_polygon(p, color=RELIEF_COLOR)
for obj in self.fire + self.drawlist:
for f in obj.fixtures:
trans = f.body.transform
if type(f.shape) is circleShape:
t = rendering.Transform(translation=trans * f.shape.pos)
self.viewer.draw_circle(f.shape.radius,
20,
color=obj.color1).add_attr(t)
self.viewer.draw_circle(f.shape.radius,
20,
color=obj.color2,
filled=False,
linewidth=2).add_attr(t)
else:
path = [trans * v for v in f.shape.vertices]
self.viewer.draw_polygon(path, color=obj.color1)
path.append(path[0])
self.viewer.draw_polyline(path,
color=obj.color2,
linewidth=2)
# Draw flags
flagy1 = self.plateau_y
flagy2 = flagy1 + 50 / SCALE
if self.terminated:
flag_color = (1.0, 0.0, 0.0)
else:
flag_color = (1.0, 1.0, 1.0)
for x in [self.plateau_x1, self.plateau_x2]:
# Pillars
self.viewer.draw_polyline([(x, flagy1), (x, flagy2)],
color=(0, 0, 0))
# Flags
self.viewer.draw_polygon(
[(x + self.wind_direction / SCALE, flagy2),
(x + self.wind_direction / SCALE, flagy2 - 10 / SCALE),
(x + self.wind_direction * 25 / SCALE, flagy2 - 5 / SCALE)],
color=flag_color)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
world_width = self.max_position - self.min_position
ratio = (2 * self.parameters['magnitude'] +
self.offset) / world_width * 2
screen_width = 600
screen_height = int(400 * ratio) + 50
scale = screen_width / world_width
carwidth = 40
carheight = 20
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
xs = np.linspace(self.min_position, self.max_position, 100)
ys = self._height(xs)
xys = list(zip((xs - self.min_position) * scale, ys * scale))
self.track = rendering.make_polyline(xys)
self.track.set_linewidth(4)
self.viewer.add_geom(self.track)
clearance = 10
l, r, t, b = -carwidth / 2, carwidth / 2, carheight, 0
car = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
car.add_attr(rendering.Transform(translation=(0, clearance)))
self.cartrans = rendering.Transform()
car.add_attr(self.cartrans)
self.viewer.add_geom(car)
frontwheel = rendering.make_circle(carheight / 2.5)
frontwheel.set_color(.5, .5, .5)
frontwheel.add_attr(
rendering.Transform(translation=(carwidth / 4, clearance)))
frontwheel.add_attr(self.cartrans)
self.viewer.add_geom(frontwheel)
backwheel = rendering.make_circle(carheight / 2.5)
backwheel.add_attr(
rendering.Transform(translation=(-carwidth / 4, clearance)))
backwheel.add_attr(self.cartrans)
backwheel.set_color(.5, .5, .5)
self.viewer.add_geom(backwheel)
flagx = (self.goal_position - self.min_position) * scale
flagy1 = self._height(self.goal_position) * scale
flagy2 = flagy1 + 50
flagpole = rendering.Line((flagx, flagy1), (flagx, flagy2))
self.viewer.add_geom(flagpole)
flag = rendering.FilledPolygon([(flagx, flagy2),
(flagx, flagy2 - 10),
(flagx + 25, flagy2 - 5)])
flag.set_color(.8, .8, 0)
self.viewer.add_geom(flag)
pos = self.state[0]
self.cartrans.set_translation((pos - self.min_position) * scale,
self._height(pos) * scale)
self.cartrans.set_rotation(
math.atan(
math.cos(self.parameters['frequency'] * pos) *
self.parameters['magnitude'] * self.parameters['frequency']))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode: str = 'human') -> Optional[np.ndarray]:
"""
Render a state of the environment.
Args:
mode: one of 'human' or 'rgb_array'. The first uses pyglet to create a
window in which to display the frames. The second returns the frame
as a (H x W x C) for usage with other visualization libraries.
Returns:
A numpy.ndarray or None.
"""
assert mode in ['human', 'rgb_array']
screen_size = 600
scale = screen_size / 5
if self.viewer is None:
from gym.envs.classic_control import rendering
# First time the environment is rendered.
self.viewer = rendering.Viewer(screen_size, screen_size)
# Add the background to the viewer.
left, right, top, bottom = 0, screen_size, screen_size, 0
background = rendering.make_polygon([(left, bottom), (left, top),
(right, top),
(right, bottom)],
filled=True)
background.set_color(.0862, .1411, .2784)
self.viewer.add_geom(background)
for row in range(5):
for col in range(5):
state = (row, col)
for next_state in [(row + 1, col), (row - 1, col),
(row, col + 1), (row, col - 1)]:
if next_state not in self.maze[state]:
# Add the geometry of the edges and walls (i.e. the boundaries between
# adjacent squares that are not connected).
row_diff, col_diff = np.subtract(next_state, state)
left = (col + (col_diff > 0)) * scale - 2 * (
col_diff != 0)
right = (
(col + 1) -
(col_diff < 0)) * scale + 2 * (col_diff != 0)
top = (5 - (row + (row_diff > 0))) * scale - 2 * (
row_diff != 0)
bottom = (5 - (
(row + 1) -
(row_diff < 0))) * scale + 2 * (row_diff != 0)
wall = rendering.make_polygon([(left, bottom),
(left, top),
(right, top),
(right, bottom)],
filled=True)
wall.set_color(1., 1., 1.)
self.viewer.add_geom(wall)
# Add the geometry of the goal square to the viewer.
left, right, top, bottom = scale * 4 + 10, scale * 5 - 10, scale - 10, 10
goal = rendering.make_polygon([(left, bottom), (left, top),
(right, top), (right, bottom)],
filled=True)
goal.set_color(.1607, .7803, .6745)
# Add the geometry of the agent to the viewer.
agent = rendering.make_circle(radius=scale * .6 / 2,
res=100,
filled=True)
self.agent_transform = rendering.Transform()
agent.add_attr(self.agent_transform)
agent.set_color(.894, .247, .3529)
self.viewer.add_geom(agent)
self.viewer.add_geom(goal)
# Update the agent's position in the maze.
agent_col = scale * (self.state[1] + .5)
agent_row = screen_size - scale * (self.state[0] + .5)
self.agent_transform.set_translation(agent_col, agent_row)
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
screen_width = 600
screen_height = 400
world_width = self.max_position - self.min_position
scale = screen_width / world_width
carwidth = 40
carheight = 20
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
xs = np.linspace(self.min_position, self.max_position, 100)
ys = self._height(xs)
xys = zip((xs - self.min_position) * scale, ys * scale)
self.track = rendering.make_polyline(xys)
self.track.set_linewidth(4)
self.viewer.add_geom(self.track)
clearance = 10
l, r, t, b = -carwidth / 2, carwidth / 2, carheight, 0
car = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
car.add_attr(rendering.Transform(translation=(0, clearance)))
self.cartrans = rendering.Transform()
car.add_attr(self.cartrans)
self.viewer.add_geom(car)
frontwheel = rendering.make_circle(carheight / 2.5)
frontwheel.set_color(.5, .5, .5)
frontwheel.add_attr(
rendering.Transform(translation=(carwidth / 4, clearance)))
frontwheel.add_attr(self.cartrans)
self.viewer.add_geom(frontwheel)
backwheel = rendering.make_circle(carheight / 2.5)
backwheel.add_attr(
rendering.Transform(translation=(-carwidth / 4, clearance)))
backwheel.add_attr(self.cartrans)
backwheel.set_color(.5, .5, .5)
self.viewer.add_geom(backwheel)
flagx = (self.goal_position - self.min_position) * scale
flagy1 = self._height(self.goal_position) * scale
flagy2 = flagy1 + 50
flagpole = rendering.Line((flagx, flagy1), (flagx, flagy2))
self.viewer.add_geom(flagpole)
flag = rendering.FilledPolygon([(flagx, flagy2),
(flagx, flagy2 - 10),
(flagx + 25, flagy2 - 5)])
flag.set_color(.8, .8, 0)
self.viewer.add_geom(flag)
pos = self.state[0]
self.cartrans.set_translation((pos - self.min_position) * scale,
self._height(pos) * scale)
self.cartrans.set_rotation(np.cos(3 * pos))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def make_key(key: Key) -> rendering.Geom: # pylint: disable=unused-argument
# OUTLINE
lw = 4
geom_bow_outline = rendering.make_circle(radius=0.4, res=6, filled=False)
geom_bow_outline.add_attr(rendering.Transform(translation=(-0.3, 0.0)))
geom_bow_outline.set_linewidth(lw)
geom_blade_outline = make_capsule(0.6, 0.2, filled=False)
for geom in geom_blade_outline.geoms:
geom.set_linewidth(lw)
geom_bit1_outline = make_capsule(0.3, 0.1, filled=False)
geom_bit1_outline.add_attr(
rendering.Transform(translation=(0.4, 0.0), rotation=math.pi / 2))
for geom in geom_bit1_outline.geoms:
geom.set_linewidth(lw)
geom_bit2_outline = make_capsule(0.3, 0.1, filled=False)
geom_bit2_outline.add_attr(
rendering.Transform(translation=(0.5, 0.0), rotation=math.pi / 2))
for geom in geom_bit2_outline.geoms:
geom.set_linewidth(lw)
geom_bit3_outline = make_capsule(0.3, 0.1, filled=False)
geom_bit3_outline.add_attr(
rendering.Transform(translation=(0.6, 0.0), rotation=math.pi / 2))
for geom in geom_bit3_outline.geoms:
geom.set_linewidth(lw)
geom_outline = Group([
geom_bow_outline,
geom_blade_outline,
geom_bit1_outline,
geom_bit2_outline,
geom_bit3_outline,
])
# BODY
geom_bow = rendering.make_circle(radius=0.4, res=6, filled=True)
geom_bow.add_attr(rendering.Transform(translation=(-0.3, 0.0)))
geom_blade = rendering.make_capsule(0.6, 0.2)
geom_bit1 = rendering.make_capsule(0.3, 0.1)
geom_bit1.add_attr(
rendering.Transform(translation=(0.4, 0.0), rotation=math.pi / 2))
geom_bit2 = rendering.make_capsule(0.3, 0.1)
geom_bit2.add_attr(
rendering.Transform(translation=(0.5, 0.0), rotation=math.pi / 2))
geom_bit3 = rendering.make_capsule(0.3, 0.1)
geom_bit3.add_attr(
rendering.Transform(translation=(0.6, 0.0), rotation=math.pi / 2))
geom = rendering.Compound(
[geom_bow, geom_blade, geom_bit1, geom_bit2, geom_bit3])
geom.set_color(*colormap[key.color])
return Group([geom_outline, geom])
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(VIEWPORT_W, VIEWPORT_H)
self.viewer.set_bounds(0, VIEWPORT_W / SCALE, 0,
VIEWPORT_H / SCALE)
for obj in self.particles:
obj.ttl -= 0.15
obj.color1 = (max(0.2, 0.2 + obj.ttl), max(0.2, 0.5 * obj.ttl),
max(0.2, 0.5 * obj.ttl))
obj.color2 = (max(0.2, 0.2 + obj.ttl), max(0.2, 0.5 * obj.ttl),
max(0.2, 0.5 * obj.ttl))
self._clean_particles(False)
for p in self.sky_polys:
self.viewer.draw_polygon(p, color=(0, 0, 0))
for obj in self.particles + self.drawlist:
for f in obj.fixtures:
trans = f.body.transform
if type(f.shape) is circleShape:
t = rendering.Transform(translation=trans * f.shape.pos)
self.viewer.draw_circle(f.shape.radius,
20,
color=obj.color1).add_attr(t)
self.viewer.draw_circle(f.shape.radius,
20,
color=obj.color2,
filled=False,
linewidth=2).add_attr(t)
else:
path = [trans * v for v in f.shape.vertices]
self.viewer.draw_polygon(path, color=obj.color1)
path.append(path[0])
self.viewer.draw_polyline(path,
color=obj.color2,
linewidth=2)
for x in [self.helipad_x1, self.helipad_x2]:
flagy1 = self.helipad_y
flagy2 = flagy1 + 50 / SCALE
self.viewer.draw_polyline([(x, flagy1), (x, flagy2)],
color=(1, 1, 1))
self.viewer.draw_polygon([(x, flagy2), (x, flagy2 - 10 / SCALE),
(x + 25 / SCALE, flagy2 - 5 / SCALE)],
color=(0.8, 0.8, 0))
clock_prog = self.curr_step / MAX_NUM_STEPS
self.viewer.draw_polyline(
[(0, 0.05 * VIEWPORT_H / SCALE),
(clock_prog * VIEWPORT_W / SCALE, 0.05 * VIEWPORT_H / SCALE)],
color=(255, 0, 0),
linewidth=5)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 500
screen_height = 500
world_width = 10
scale = screen_width / world_width
ball_radius = scale * 0.4
cx, cy = screen_width / 2.0, screen_height / 2.0
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
self.ball = rendering.make_circle(ball_radius)
self.balltrans = rendering.Transform()
self.ball.add_attr(self.balltrans)
self.ball.set_color(.5, .5, .8)
self.viewer.add_geom(self.ball)
self.fixed_ball1 = rendering.make_circle(ball_radius)
self.fixed_ball1trans = rendering.Transform(
translation=(self.x0[0] * scale + cx, self.y0[0] * scale + cy))
self.fixed_ball1.add_attr(self.fixed_ball1trans)
self.fixed_ball1.set_color(.5, .5, .8)
self.viewer.add_geom(self.fixed_ball1)
self.fixed_ball2 = rendering.make_circle(ball_radius)
self.fixed_ball2trans = rendering.Transform(
translation=(self.x0[1] * scale + cx, self.y0[1] * scale + cy))
self.fixed_ball2.add_attr(self.fixed_ball2trans)
self.fixed_ball2.set_color(.5, .5, .8)
self.viewer.add_geom(self.fixed_ball2)
self.fixed_ball3 = rendering.make_circle(ball_radius)
self.fixed_ball3trans = rendering.Transform(
translation=(self.x0[2] * scale + cx, self.y0[2] * scale + cy))
self.fixed_ball3.add_attr(self.fixed_ball3trans)
self.fixed_ball3.set_color(.5, .5, .8)
self.viewer.add_geom(self.fixed_ball3)
self.fixed_ball4 = rendering.make_circle(ball_radius)
self.fixed_ball4trans = rendering.Transform(
translation=(self.x0[3] * scale + cx, self.y0[3] * scale + cy))
self.fixed_ball4.add_attr(self.fixed_ball4trans)
self.fixed_ball4.set_color(.5, .5, .8)
self.viewer.add_geom(self.fixed_ball4)
self.target_circle = rendering.make_circle(ball_radius / 4)
self.target_circletrans = rendering.Transform(
translation=(self.state[4] * scale + cx,
self.state[5] * scale + cy))
self.target_circle.add_attr(self.target_circletrans)
self.target_circle.set_color(.5, .0, .0)
self.viewer.add_geom(self.target_circle)
if self.state is None: return None
#edit the ball
ball = self.ball
points_on_circle = []
for i in range(30):
ang = 2 * np.pi * i / 30
points_on_circle.append(
(np.cos(ang) * ball_radius, np.sin(ang) * ball_radius))
ball.v = points_on_circle
x = self.state
ballx = x[0] * scale + screen_width / 2.0
bally = x[1] * scale + screen_height / 2.0
self.balltrans.set_translation(ballx, bally)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human', close=False):
joint_1, joint_2, joint_3, robot_end = self.__compute_joint_positions()
# Then, compute the coordinates of the joints in screen space
joint_1_screen = [int((0.5 + joint_1[0]) * self.screen_size),
self.screen_size - int((0.5 - joint_1[1]) * self.screen_size)]
joint_2_screen = [int((0.5 + joint_2[0]) * self.screen_size),
self.screen_size - int((0.5 - joint_2[1]) * self.screen_size)]
joint_3_screen = [int((0.5 + joint_3[0]) * self.screen_size),
self.screen_size - int((0.5 - joint_3[1]) * self.screen_size)]
robot_end_screen = [int((0.5 + robot_end[0]) * self.screen_size),
self.screen_size - int((0.5 - robot_end[1]) * self.screen_size)]
target_screen = [int((0.5 + self.target_position[0]) * self.screen_size),
self.screen_size - int((0.5 - self.target_position[1]) * self.screen_size)]
if self.env_type == EnvType.MULTI_TARG_2_DOF:
target_2_screen = [int((0.5 + self.target_2_position[0]) * self.screen_size),
self.screen_size - int((0.5 - self.target_2_position[1]) * self.screen_size)]
from gym.envs.classic_control import rendering
link_lengths = [0, 0, 0] if self.link_lengths is None else self.link_lengths
if self.viewer is None:
self.viewer = rendering.Viewer(self.screen_size, self.screen_size)
self.j1_trans = rendering.Transform()
joint1 = rendering.make_circle(4)
joint1.add_attr(self.j1_trans)
self.j2_trans = rendering.Transform()
joint2 = rendering.make_circle(3)
if self.dof == 2:
joint2.set_color(1, 0, 0)
joint2.add_attr(self.j2_trans)
self.j3_trans = rendering.Transform()
if self.dof == 2:
joint3 = rendering.make_circle(3)
joint3.set_color(0, 0, 1)
else:
joint3 = rendering.make_circle(4)
joint3.add_attr(self.j3_trans)
self.end_trans = rendering.Transform()
end = rendering.make_circle(2)
end.set_color(0, 0, 1)
end.add_attr(self.end_trans)
self.target_trans = rendering.Transform()
target = rendering.make_circle(self.screen_size * self.target_distance)
target.set_color(1, 0, 0)
target.add_attr(self.target_trans)
if self.env_type == EnvType.MULTI_TARG_2_DOF:
self.target_2_trans = rendering.Transform()
target_2 = rendering.make_circle(self.screen_size * self.target_distance)
target_2.set_color(0, 0, 1)
target_2.add_attr(self.target_2_trans)
self.l1_trans = rendering.Transform()
self.link1 = rendering.Line([0, 0], [0, link_lengths[0] * self.screen_size])
self.link1.add_attr(self.l1_trans)
self.l2_trans = rendering.Transform()
self.link2 = rendering.Line([0, 0], [0, link_lengths[1] * self.screen_size])
self.link2.add_attr(self.l2_trans)
self.l3_trans = rendering.Transform()
self.link3 = rendering.Line([0, 0], [0, link_lengths[2] * self.screen_size])
self.link3.add_attr(self.l3_trans)
self.viewer.add_geom(self.link1)
self.viewer.add_geom(self.link2)
if self.dof > 2:
self.viewer.add_geom(self.link3)
self.viewer.add_geom(joint1)
self.viewer.add_geom(joint2)
self.viewer.add_geom(joint3)
if self.dof > 2:
self.viewer.add_geom(end)
self.viewer.add_geom(target)
if self.env_type == EnvType.MULTI_TARG_2_DOF:
self.viewer.add_geom(target_2)
if self.reset_viewer:
self.link1.start, self.link1.end = [0, 0], [0, link_lengths[0] * self.screen_size]
self.link2.start, self.link2.end = [0, 0], [0, link_lengths[1] * self.screen_size]
self.link3.start, self.link3.end = [0, 0], [0, link_lengths[2] * self.screen_size]
self.j1_trans.set_translation(joint_1_screen[0], joint_1_screen[1])
self.j2_trans.set_translation(joint_2_screen[0], joint_2_screen[1])
self.j3_trans.set_translation(joint_3_screen[0], joint_3_screen[1])
self.end_trans.set_translation(robot_end_screen[0], robot_end_screen[1])
self.target_trans.set_translation(target_screen[0], target_screen[1])
if self.env_type == EnvType.MULTI_TARG_2_DOF:
self.target_2_trans.set_translation(target_2_screen[0], target_2_screen[1])
self.l1_trans.set_translation(joint_1_screen[0], joint_1_screen[1])
self.l2_trans.set_translation(joint_2_screen[0], joint_2_screen[1])
self.l3_trans.set_translation(joint_3_screen[0], joint_3_screen[1])
self.l1_trans.set_rotation(self.current_joint_angles[0])
self.l2_trans.set_rotation(self.current_joint_angles[1] + self.current_joint_angles[0])
self.l3_trans.set_rotation(
self.current_joint_angles[2] + self.current_joint_angles[1] + self.current_joint_angles[0])
self.valid_space = rendering.make_circle(self.screen_size * sum(self.link_lengths), filled=False, res=50)
translation = rendering.Transform()
translation.set_translation(0.5 * self.screen_size, 0.5 * self.screen_size)
self.valid_space.add_attr(translation)
self.viewer.add_onetime(self.valid_space)
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
screen_width = 800
screen_height = 800
scale_width = screen_width / (self.bound_box[0, 1] -
self.bound_box[0, 0])
scale_height = screen_height / (self.bound_box[1, 1] -
self.bound_box[1, 0])
zero_width = scale_width * (-self.bound_box[0, 0])
zero_height = scale_height * (-self.bound_box[1, 0])
drone_width = 20
drone_height = 20
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
l, r, t, b = -drone_width / 2, drone_width / 2, drone_height / 2, -drone_height / 2
drone = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
self.drone_trans = rendering.Transform()
drone.add_attr(self.drone_trans)
self.viewer.add_geom(drone)
goal = rendering.make_circle(scale_height * 0.2)
goal.set_color(.0, 1.0, .0)
self.goal_trans = rendering.Transform()
goal.add_attr(self.goal_trans)
self.viewer.add_geom(goal)
obstacles = []
self.obstacle_trans = []
# add_geom
for it_obstacle in range(self.obstacle_num):
if self.obstacle_type[it_obstacle] == 'cylinder':
radius = scale_height * self.obstacle_dim[it_obstacle]
obstacles.append(rendering.make_circle(radius))
obstacles[it_obstacle].set_color(1.0, .0, .0)
self.obstacle_trans.append(rendering.Transform())
obstacles[it_obstacle].add_attr(
self.obstacle_trans[it_obstacle])
self.viewer.add_geom(obstacles[it_obstacle])
elif self.obstacle_type[it_obstacle] == 'rectangle':
obst_dim = self.obstacle_dim[it_obstacle]
rect_width = obst_dim[0] * scale_width
rect_height = obst_dim[1] * scale_height
l, r, t, b = -rect_width / 2, rect_width / 2, rect_height / 2, -rect_height / 2
obstacles.append(
rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)]))
obstacles[it_obstacle].set_color(1.0, .0, .0)
self.obstacle_trans.append(rendering.Transform())
obstacles[it_obstacle].add_attr(
self.obstacle_trans[it_obstacle])
self.viewer.add_geom(obstacles[it_obstacle])
elif self.obstacle_type[it_obstacle] == 'wall':
wall_vector = self.obstacle_dim[
it_obstacle] - self.obstacle_pos[it_obstacle, :2]
wall_width = np.linalg.norm(wall_vector) * scale_width
wall_height = 5
l, r, t, b = 0, wall_width, 0, wall_height
obstacles.append(
rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)]))
obstacles[it_obstacle].set_color(1.0, 0.0, 0.0)
self.obstacle_trans.append(rendering.Transform())
obstacles[it_obstacle].add_attr(
self.obstacle_trans[it_obstacle])
self.viewer.add_geom(obstacles[it_obstacle])
laser_readings = []
self.laser_readings_array = []
for it_laser in range(self.num_samples_laser):
laser_readings.append(rendering.make_circle(3))
laser_readings[it_laser].set_color(0.0, 0.0, 1.0)
self.laser_readings_array.append(rendering.Transform())
laser_readings[it_laser].add_attr(
self.laser_readings_array[it_laser])
self.viewer.add_geom(laser_readings[it_laser])
if self.state is None: return None
drone_x = self.state[0] * scale_width + zero_width
drone_y = self.state[1] * scale_height + zero_height
self.drone_trans.set_translation(drone_x, drone_y)
self.drone_trans.set_rotation(self.state[2])
goal_x = self.goal_pos[0] * scale_width + zero_width
goal_y = self.goal_pos[1] * scale_height + zero_height
self.goal_trans.set_translation(goal_x, goal_y)
# set_translation
for it_obstacles in range(self.obstacle_num):
if self.obstacle_type[it_obstacles] == 'cylinder':
object_it_pos = self.obstacle_pos[it_obstacles]
obstacle_x = object_it_pos[0] * scale_width + zero_width
obstacle_y = object_it_pos[1] * scale_height + zero_height
self.obstacle_trans[it_obstacles].set_translation(
obstacle_x, obstacle_y)
elif self.obstacle_type[it_obstacles] == 'rectangle':
object_it_pos = self.obstacle_pos[it_obstacles]
obstacle_x = object_it_pos[0] * scale_width + zero_width
obstacle_y = object_it_pos[1] * scale_height + zero_height
self.obstacle_trans[it_obstacles].set_translation(
obstacle_x, obstacle_y)
self.obstacle_trans[it_obstacles].set_rotation(
object_it_pos[2])
elif self.obstacle_type[it_obstacles] == 'wall':
wall_pose = self.obstacle_pos[it_obstacles]
wall_x = wall_pose[0] * scale_width + zero_width
wall_y = wall_pose[1] * scale_height + zero_height
self.obstacle_trans[it_obstacles].set_translation(
wall_x, wall_y)
wall_vector = self.obstacle_dim[it_obstacles] - wall_pose[:2]
rotation_angle = np.arctan2(wall_vector[1], wall_vector[0])
self.obstacle_trans[it_obstacles].set_rotation(rotation_angle)
if True:
rays = np.linspace(-np.pi, np.pi, self.num_samples_laser)
for it_laser in range(self.num_samples_laser):
laser_reading_it = self.laser_obs[it_laser]
if laser_reading_it > self.max_measurement_laser:
laser_reading_it = self.max_measurement_laser
laser_intersect = self.state[:2] + laser_reading_it *\
np.array([np.cos(self.state[2] + rays[it_laser]),
np.sin(self.state[2] + rays[it_laser])])
laser_x = laser_intersect[0] * scale_width + zero_width
laser_y = laser_intersect[1] * scale_height + zero_height
self.laser_readings_array[it_laser].set_translation(
laser_x, laser_y)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
assert mode in ['human', 'state_pixels', 'rgb_array']
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(WINDOW_W, WINDOW_H)
self.score_label = pyglet.text.Label('0000',
font_size=36,
x=20,
y=WINDOW_H * 2.5 / 40.00,
anchor_x='left',
anchor_y='center',
color=(255, 255, 255, 255))
self.transform = rendering.Transform()
if "t" not in self.__dict__: return # reset() not called yet
zoom = 0.1 * SCALE * max(1 - self.t, 0) + ZOOM * SCALE * min(
self.t, 1) # Animate zoom first second
zoom_state = ZOOM * SCALE * STATE_W / WINDOW_W
zoom_video = ZOOM * SCALE * VIDEO_W / WINDOW_W
scroll_x = self.car.hull.position[0]
scroll_y = self.car.hull.position[1]
angle = -self.car.hull.angle
vel = self.car.hull.linearVelocity
if np.linalg.norm(vel) > 0.5:
angle = math.atan2(vel[0], vel[1])
self.transform.set_scale(zoom, zoom)
self.transform.set_translation(
WINDOW_W / 2 - (scroll_x * zoom * math.cos(angle) -
scroll_y * zoom * math.sin(angle)),
WINDOW_H / 4 - (scroll_x * zoom * math.sin(angle) +
scroll_y * zoom * math.cos(angle)))
self.transform.set_rotation(angle)
self.car.draw(self.viewer, mode != "state_pixels")
arr = None
win = self.viewer.window
win.switch_to()
win.dispatch_events()
win.clear()
t = self.transform
if mode == 'rgb_array':
VP_W = VIDEO_W
VP_H = VIDEO_H
elif mode == 'state_pixels':
VP_W = STATE_W
VP_H = STATE_H
else:
pixel_scale = 1
if hasattr(win.context, '_nscontext'):
pixel_scale = win.context._nscontext.view().backingScaleFactor(
) # pylint: disable=protected-access
VP_W = int(pixel_scale * WINDOW_W)
VP_H = int(pixel_scale * WINDOW_H)
gl.glViewport(0, 0, VP_W, VP_H)
t.enable()
self.render_road()
for geom in self.viewer.onetime_geoms:
geom.render()
self.viewer.onetime_geoms = []
t.disable()
self.render_indicators(WINDOW_W, WINDOW_H)
if mode == 'human':
win.flip()
return self.viewer.isopen
image_data = pyglet.image.get_buffer_manager().get_color_buffer(
).get_image_data()
arr = np.fromstring(image_data.get_data(), dtype=np.uint8, sep='')
arr = arr.reshape(VP_H, VP_W, 4)
arr = arr[::-1, :, 0:3]
return arr
def render(self, mode="human"):
screen_width = 1000
screen_height = 600
world_width = 5.0
scale = screen_width / world_width
carty = 200 # TOP OF CART
polewidth1 = 10.0 * (self.model.mp1 / 0.5)
polewidth2 = 10.0 * (self.model.mp2 / 0.5)
polelen1 = scale * self.model.l1
polelen2 = scale * self.model.l2
cartwidth = 50.0 * torch.sqrt(self.model.mc / 0.5)
cartheight = 30.0 * torch.sqrt(self.model.mc / 0.5)
if self.state is None:
return None
x, _, theta1, _, theta2, _ = self.state
cartx = x * scale + screen_width / 2.0 # MIDDLE OF CART
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
self.viewer.window.set_vsync(False)
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)
l, r, t, b = (-polewidth1 / 2, polewidth1 / 2,
polelen1 - polewidth1 / 2, -polewidth1 / 2)
pole1 = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole1.set_color(0.8, 0.6, 0.4)
self.pole1trans = rendering.Transform(translation=(0, axleoffset))
pole1.add_attr(self.pole1trans)
pole1.add_attr(self.carttrans)
self.viewer.add_geom(pole1)
self.axle1 = rendering.make_circle(polewidth1 / 2)
self.axle1.add_attr(self.pole1trans)
self.axle1.add_attr(self.carttrans)
self.axle1.set_color(0.5, 0.5, 0.8)
self.viewer.add_geom(self.axle1)
l, r, t, b = (-polewidth2 / 2, polewidth2 / 2,
polelen2 - polewidth2 / 2, -polewidth2 / 2)
pole2 = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole2.set_color(0.8, 0.6, 0.4)
self.pole2trans = rendering.Transform(translation=(0, polelen1 -
axleoffset))
pole2.add_attr(self.pole2trans)
pole2.add_attr(self.pole1trans)
pole2.add_attr(self.carttrans)
self.viewer.add_geom(pole2)
self.axle2 = rendering.make_circle(polewidth2 / 2)
self.axle2.add_attr(self.pole2trans)
self.axle2.add_attr(self.pole1trans)
self.axle2.add_attr(self.carttrans)
self.axle2.set_color(0.5, 0.5, 0.8)
self.viewer.add_geom(self.axle2)
self.track = rendering.Line((0, carty), (screen_width, carty))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
self.carttrans.set_translation(cartx, carty)
self.pole1trans.set_rotation(theta1)
self.pole2trans.set_rotation(theta2 - theta1)
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
screen_width = 600
screen_height = 400
world_width = 1.5 * self.x_max_threshold
scale = screen_width / world_width
scale = screen_width / world_width # Scale according to width
# scale = screen_height/world_height # Scale according to height
# Define the payload diameter and cable width in pixels
payload_size = 10.0
cable_width = 2.0
# Define the trolley size and its offset from the bottom of the screen (pixels)
trolley_width = 50.0
trolley_height = 30.0
trolley_yOffset = screen_height - 25
theta, theta_dot, x, x_dot = self.state
if self.viewer is None: # Initial scene setup
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
# the target is a series of circles, a bullseye
self.target = rendering.make_circle(payload_size * 2)
self.targettrans = rendering.Transform(
translation=(screen_width / 2 + self.desired_trolley * scale,
trolley_yOffset - self.cable_length * scale))
self.target.add_attr(self.targettrans)
self.target.set_color(1, 0, 0) # red
self.viewer.add_geom(self.target)
self.target = rendering.make_circle(payload_size * 1.25)
self.targettrans = rendering.Transform(
translation=(screen_width / 2 + self.desired_trolley * scale,
trolley_yOffset - self.cable_length * scale))
self.target.add_attr(self.targettrans)
self.target.set_color(1, 1, 1) # white
self.viewer.add_geom(self.target)
self.target = rendering.make_circle(payload_size / 2)
self.targettrans = rendering.Transform(
translation=(screen_width / 2 + self.desired_trolley * scale,
trolley_yOffset - self.cable_length * scale))
self.target.add_attr(self.targettrans)
self.target.set_color(1, 0, 0) # red
self.viewer.add_geom(self.target)
# Define the trolley polygon
l, r, t, b = -trolley_width / 2, trolley_width / 2, trolley_height / 2, -trolley_height / 2
self.trolley = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.trolleytrans = rendering.Transform(
translation=(screen_width / 2 + x * scale, trolley_yOffset))
self.trolley.add_attr(self.trolleytrans)
self.trolley.set_color(0.85, 0.85, 0.85) # light gray
self.viewer.add_geom(self.trolley)
# define the cable as a polygon, so we can change its length later
l, r, t, b = -cable_width / 2, cable_width / 2, cable_width / 2, -self.cable_length * scale - cable_width / 2
self.cable = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.cabletrans = rendering.Transform(
translation=(screen_width / 2 + x * scale, trolley_yOffset))
self.cable.add_attr(self.cabletrans)
self.cable.set_color(0.25, 0.25, 0.25) # dark gray
self.viewer.add_geom(self.cable)
# the payload is a circle.
self.payload = rendering.make_circle(payload_size)
self.payloadtrans = rendering.Transform(
translation=(screen_width / 2 + x * scale,
trolley_yOffset - self.cable_length))
self.payload.add_attr(self.payloadtrans)
self.payload.set_color(0.5, 0.5, 0.5) # mid gray
self.viewer.add_geom(self.payload)
# This is a bar that shows the direction of the current accel. command
l, r, t, b = -10.0, 10.0, cable_width / 2, -cable_width / 2
self.accel = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.acceltrans = rendering.Transform(
translation=(screen_width / 2 + x * scale - trolley_width / 2,
trolley_yOffset))
self.accel.add_attr(self.acceltrans)
self.accel.set_color(0.1, 0.1, 0.5)
self.viewer.add_geom(self.accel)
# calculate the payload position in the window, then move it there
payload_screen_x = (x - self.cable_length * np.sin(theta)) * scale
payload_screen_y = trolley_yOffset - self.cable_length * np.cos(
theta) * scale
self.payloadtrans.set_translation(screen_width / 2 + payload_screen_x,
payload_screen_y)
# rotate the cable
self.cabletrans.set_translation(screen_width / 2 + x * scale,
trolley_yOffset)
self.cabletrans.set_rotation(-theta)
# move the trolley
self.trolleytrans.set_translation(screen_width / 2 + x * scale,
trolley_yOffset)
# show the accel direction
#self.acceltrans.set_translation(screen_width/2 + (x*scale + np.sign(self.x_accel)*(trolley_width/2+10)), trolley_yOffset)
# show the accel direction
accel_scaling = 0.025 * self.x_accel * scale
# self.acceltrans.set_translation(screen_width/2 + (x*scale + np.sign(self.x_accel)*(trolley_width/2+10)), trolley_yOffset)
self.acceltrans.set_translation(
screen_width / 2 + (x * scale + (20 * accel_scaling / 2)),
trolley_yOffset)
self.acceltrans.set_scale(accel_scaling, 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
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(VIEWPORT_W, VIEWPORT_H)
self.viewer.set_bounds(0, W, 0, H)
sky = rendering.FilledPolygon(((0, 0), (0, H), (W, H), (W, 0)))
self.sky_color = rgb(126, 150, 233)
sky.set_color(*self.sky_color)
self.sky_color_half_transparent = np.array(
(np.array(self.sky_color) + rgb(255, 255, 255))) / 2
self.viewer.add_geom(sky)
self.rockettrans = rendering.Transform()
engine = rendering.FilledPolygon(
((0, 0), (ENGINE_WIDTH / 2, -ENGINE_HEIGHT),
(-ENGINE_WIDTH / 2, -ENGINE_HEIGHT)))
self.enginetrans = rendering.Transform()
engine.add_attr(self.enginetrans)
engine.add_attr(self.rockettrans)
engine.set_color(.4, .4, .4)
self.viewer.add_geom(engine)
self.fire = rendering.FilledPolygon(
((ENGINE_WIDTH * 0.4, 0), (-ENGINE_WIDTH * 0.4, 0),
(-ENGINE_WIDTH * 1.2, -ENGINE_HEIGHT * 5),
(0, -ENGINE_HEIGHT * 8), (ENGINE_WIDTH * 1.2,
-ENGINE_HEIGHT * 5)))
self.fire.set_color(*rgb(255, 230, 107))
self.firescale = rendering.Transform(scale=(1, 1))
self.firetrans = rendering.Transform(translation=(0,
-ENGINE_HEIGHT))
self.fire.add_attr(self.firescale)
self.fire.add_attr(self.firetrans)
self.fire.add_attr(self.enginetrans)
self.fire.add_attr(self.rockettrans)
smoke = rendering.FilledPolygon(
((ROCKET_WIDTH / 2, THRUSTER_HEIGHT * 1),
(ROCKET_WIDTH * 3, THRUSTER_HEIGHT * 1.03),
(ROCKET_WIDTH * 4, THRUSTER_HEIGHT * 1),
(ROCKET_WIDTH * 3, THRUSTER_HEIGHT * 0.97)))
smoke.set_color(*self.sky_color_half_transparent)
self.smokescale = rendering.Transform(scale=(1, 1))
smoke.add_attr(self.smokescale)
smoke.add_attr(self.rockettrans)
self.viewer.add_geom(smoke)
self.gridfins = []
for i in (-1, 1):
finpoly = ((i * ROCKET_WIDTH * 1.1, THRUSTER_HEIGHT * 1.01),
(i * ROCKET_WIDTH * 0.4, THRUSTER_HEIGHT * 1.01),
(i * ROCKET_WIDTH * 0.4, THRUSTER_HEIGHT * 0.99),
(i * ROCKET_WIDTH * 1.1, THRUSTER_HEIGHT * 0.99))
gridfin = rendering.FilledPolygon(finpoly)
gridfin.add_attr(self.rockettrans)
gridfin.set_color(0.25, 0.25, 0.25)
self.gridfins.append(gridfin)
if self.stepnumber % round(FPS / 10) == 0 and self.power > 0:
s = [
MAX_SMOKE_LIFETIME * self.power, # total lifetime
0, # current lifetime
self.power * (1 + 0.2 * np.random.random()), # size
np.array(self.lander.position) +
self.power * ROCKET_WIDTH * 10 * np.array(
(np.sin(self.lander.angle + self.gimbal),
-np.cos(self.lander.angle + self.gimbal))) +
self.power * 5 * (np.random.random(2) - 0.5)
] # position
self.smoke.append(s)
for s in self.smoke:
s[1] += 1
if s[1] > s[0]:
self.smoke.remove(s)
continue
t = rendering.Transform(translation=(s[3][0],
s[3][1] + H * s[1] / 2000))
self.viewer.draw_circle(
radius=0.05 * s[1] + s[2],
color=self.sky_color + (1 - (2 * s[1] / s[0] - 1)**2) / 3 *
(self.sky_color_half_transparent - self.sky_color)).add_attr(t)
self.viewer.add_onetime(self.fire)
for g in self.gridfins:
self.viewer.add_onetime(g)
for obj in self.drawlist:
for f in obj.fixtures:
trans = f.body.transform
path = [trans * v for v in f.shape.vertices]
self.viewer.draw_polygon(path, color=obj.color1)
for l in zip(self.legs, [-1, 1]):
path = [
self.lander.fixtures[0].body.transform *
(l[1] * ROCKET_WIDTH / 2, ROCKET_HEIGHT / 8),
l[0].fixtures[0].body.transform * (l[1] * LEG_LENGTH * 0.8, 0)
]
self.viewer.draw_polyline(path,
color=self.ship.color1,
linewidth=1 if START_HEIGHT > 500 else 2)
self.viewer.draw_polyline(
((self.helipad_x2, self.terrainheigth + SHIP_HEIGHT),
(self.helipad_x1, self.terrainheigth + SHIP_HEIGHT)),
color=rgb(206, 206, 2),
linewidth=1)
self.rockettrans.set_translation(*self.lander.position)
self.rockettrans.set_rotation(self.lander.angle)
self.enginetrans.set_rotation(self.gimbal)
self.firescale.set_scale(newx=1,
newy=self.power * np.random.uniform(1, 1.3))
self.smokescale.set_scale(newx=self.force_dir, newy=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
scale = 10
screen_width = (self.region[1] - self.region[0]) * scale
screen_height = (self.region[3] - self.region[2]) * scale
world_width = self.region[1] - self.region[0]
scale = screen_width/world_width
objwidth=40
objheight=40
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
#render obstacles
self.render_obsts = []
self.obsts_trans_list = []
for obstacle in self.obstacles:
obst_trans = rendering.Transform()
obst = rendering.make_circle(obstacle[2]*scale)
obst.add_attr(obst_trans)
obst.set_color(0,0,0)
self.viewer.add_geom(obst)
self.obsts_trans_list.append(obst_trans)
self.render_obsts.append(obst)
#render goal
self.goal_trans = rendering.Transform()
self.goal_ren = rendering.make_circle(self.goal[2]*scale)
self.goal_ren.add_attr(self.goal_trans)
self.goal_ren.set_color(0,255,0)
self.viewer.add_geom(self.goal_ren)
#print("goal[0]={} goal[1]={}".format(self.goal[0],self.goal[1]))
#render arrows
fname = path.join(path.dirname(__file__), "assets/arrow.png")
self.img_list = []
self.imgtrans_list = []
for id in xrange(self.agent_num):
img = rendering.Image(fname, 20., 40.)
#print("img={}".format(img))
imgtrans = rendering.Transform()
img.add_attr(imgtrans)
self.img_list.append(img)
self.imgtrans_list.append(imgtrans)
#print("self.img_list={}, self.imgtrans_list={}".format(self.img_list,self.imgtrans_list))
self.objtrans = rendering.Transform()
l,r,t,b = -objwidth/2, objwidth/2, -objheight/2, objheight/2
self.obj = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)])
self.obj.add_attr(self.objtrans)
self.obj.set_color(255,0,0)
self.viewer.add_geom(self.obj)
self.scales = []
self.rotations = []
for id in xrange(self.agent_num):
self.scales.append(np.abs(self.action[id*2]))
self.rotations.append(self.action[id*2+1]-math.pi/2) #anti-clockwise
self.arrow_offsets = [[30,0],[0,-30],[-30,0],[0,30]] * scale
for id in xrange(self.agent_num):
self.viewer.add_onetime(self.img_list[id])
self.imgtrans_list[id].set_translation(self.state[0]*scale+self.arrow_offsets[id][0],\
self.state[2]*scale+self.arrow_offsets[id][1]) #follow object #arrow vis V1
#self.imgtrans_list[id].set_translation(self.state[0]*scale,self.state[2]*scale) #arrow vis V2, follow object
#self.imgtrans_list[id].set_translation(100+60*id, 200) #arrow vis V3, fixed position
self.imgtrans_list[id].set_rotation(self.rotations[id]) # rotation
self.imgtrans_list[id].scale = (self.scales[id],self.scales[id])
for i, obst_trans in enumerate(self.obsts_trans_list):
obst_trans.set_translation(self.obstacles[i][0]*scale,self.obstacles[i][1]*scale)
self.goal_trans.set_translation(self.goal[0]*scale,self.goal[1]*scale)
self.objtrans.set_translation(self.state[0]*scale, self.state[2]*scale)
#self.objtrans.set_translation(100, 200)
return self.viewer.render(return_rgb_array = mode=='rgb_array')
def render(self, mode='human'):
screen_width = self.screen_size
screen_height = self.screen_size
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
# Background
# background = rendering.FilledPolygon([(0, 0), (0, screen_height), (screen_width, screen_height), (screen_width, 0)])
# background.set_color(1, 1, 1)
# self.viewer.add_geom(background)
# Start of the light beam
start = rendering.FilledPolygon(
[(0 + screen_width / 30, screen_height / 2 + screen_height / 20),
(0, screen_height / 2 + screen_height / 20),
(0, screen_height / 2 - screen_height / 20),
(0 + screen_width / 30, screen_height / 2 - screen_height / 20)])
self.viewer.add_geom(start)
# First light beam
first_beam = rendering.Line((0 + screen_width / 30, screen_height / 2),
(screen_width / 2, screen_height / 2))
first_beam.set_color(1, 1, 0)
self.viewer.add_geom(first_beam)
# Second light beam
self.second_beam = rendering.Line((screen_width / 2, screen_height / 2),
(screen_width / 2, screen_height))
self.second_beam.set_color(1, 1, 0)
self.viewer.add_geom(self.second_beam)
# Goal
self.goal = rendering.make_circle(self.screen_size / 40)
self.goaltrans = rendering.Transform()
self.goal.add_attr(self.goaltrans)
self.goal.set_color(0, .5, 0)
self.goaltrans.set_translation(screen_width * (self.state[1] / 100), screen_height)
self.viewer.add_geom(self.goal)
# Mirror
mirror_w = screen_width / 30
mirror_h = screen_height / 500
mirror = rendering.FilledPolygon(
[(- mirror_w, - mirror_h), (- mirror_w, + mirror_h), (mirror_w, + mirror_h), (mirror_w, - mirror_h)])
mirror.set_color(.8, .6, .4)
self.mirrortrans = rendering.Transform()
self.mirrortrans.set_translation(screen_width / 2, screen_height / 2)
mirror.add_attr(self.mirrortrans)
self.viewer.add_geom(mirror)
if self.state is None:
return None
x = self.state
self.mirrortrans.set_rotation(x[0] / 57.29577951308232)
beam_pos = (self.highest_angle - x[0]) / (self.highest_angle - self.lowest_angle)
self.second_beam.__init__((screen_width / 2, screen_height / 2), (beam_pos * screen_width, screen_height))
self.second_beam.set_color(1, 1, 0)
self.goaltrans.set_translation(screen_width * (x[1] / 100), screen_height)
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)
'''
# 绘制格子
self.translations_dict = {}
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) / 100
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)
elif self.grids.get_type(x, y) == 2: # red
rect.set_color(1., 0., 0.)
else:
pass
agent_tmp = rendering.make_circle(u_size / 10, 30, True)
agent_tmp.set_color(0, 0.9, 0)
self.viewer.add_geom(agent_tmp)
trans_tmp = rendering.Transform()
agent_tmp.add_attr(trans_tmp)
self.translations_dict[(x, y)] = trans_tmp
# 绘制个体
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)
# self.translations_dict = {}
# color_dict = {3: (1.0, 1.0, 0.0), 4: (0, 0.4, 0)}
# for key, color_type in self.movable_types_dict.items():
# agent_tmp = rendering.make_circle(u_size / 5, 20, False)
# agent_tmp.set_color(*color_dict[color_type])
# self.viewer.add_geom(agent_tmp)
# trans_tmp = rendering.Transform()
# agent_tmp.add_attr(trans_tmp)
#
# self.translations_dict[key] = trans_tmp
# 更新个体位置
# x, y = self._state_to_xy(self.state)
# x = self.state[0]
# y = self.state[1]
x, y = self.current_x, self.current_y
self.agent_trans.set_translation((x + 0.5) * u_size,
(y + 0.5) * u_size)
for x in range(self.n_width):
for y in range(self.n_height):
key = (x, y)
if key in self.movable_types_dict:
self.translations_dict[key].set_translation(
(x + 0.5) * u_size, (y + 0.5) * u_size)
self.translations_dict[key].set_scale(1, 1)
else:
self.translations_dict[key].set_translation(
(x + 0.5) * u_size, (y + 0.5) * u_size)
self.translations_dict[key].set_scale(0, 0)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode="human"):
assert mode in ["human", "state_pixels", "rgb_array"]
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(WINDOW_W, WINDOW_H)
self.score_label = pyglet.text.Label(
"0000",
font_size=36,
x=20,
y=WINDOW_H * 2.5 / 40.00,
anchor_x="left",
anchor_y="center",
color=(255, 255, 255, 255),
)
self.transform = rendering.Transform()
if "t" not in self.__dict__:
return # reset() not called yet
# Animate zoom first second:
zoom = 0.1 * SCALE * max(1 - self.t, 0) + ZOOM * SCALE * min(self.t, 1)
scroll_x = self.car.hull.position[0]
scroll_y = self.car.hull.position[1]
angle = -self.car.hull.angle
vel = self.car.hull.linearVelocity
if np.linalg.norm(vel) > 0.5:
angle = math.atan2(vel[0], vel[1])
self.transform.set_scale(zoom, zoom)
self.transform.set_translation(
WINDOW_W / 2 - (scroll_x * zoom * math.cos(angle) -
scroll_y * zoom * math.sin(angle)),
WINDOW_H / 4 - (scroll_x * zoom * math.sin(angle) +
scroll_y * zoom * math.cos(angle)),
)
self.transform.set_rotation(angle)
self.car.draw(self.viewer, mode != "state_pixels")
#middle line
p2 = self.road[self.car.curren_tile].center_p
p1 = self.road[self.car.curren_tile - 2].center_p
self.debug_line(p1, p2)
#curve forecast
p3 = p2
if (self.car.curren_tile + FUTURE_SIGHT) < len(self.road):
p4 = self.road[self.car.curren_tile +
int(FUTURE_SIGHT / 2)].center_p
p5 = self.road[self.car.curren_tile +
int(FUTURE_SIGHT / 2)].center_p
p6 = self.road[self.car.curren_tile + FUTURE_SIGHT].center_p
else:
p4 = self.road[-1].center_p
p5 = p3
p6 = p4
self.debug_line(p3, p4, color=(50, 50, 0))
self.debug_line(p5, p6, color=(0, 100, 50))
arr = None
win = self.viewer.window
win.switch_to()
win.dispatch_events()
win.clear()
t = self.transform
if mode == "rgb_array":
VP_W = VIDEO_W
VP_H = VIDEO_H
elif mode == "state_pixels":
VP_W = STATE_W
VP_H = STATE_H
else:
pixel_scale = 1
if hasattr(win.context, "_nscontext"):
pixel_scale = (
win.context._nscontext.view().backingScaleFactor()) # pylint: disable=protected-access
VP_W = int(pixel_scale * WINDOW_W)
VP_H = int(pixel_scale * WINDOW_H)
gl.glViewport(0, 0, VP_W, VP_H)
t.enable()
self.render_road()
for geom in self.viewer.onetime_geoms:
geom.render()
self.viewer.onetime_geoms = []
t.disable()
self.render_indicators(WINDOW_W, WINDOW_H)
if mode == "human":
win.flip()
return self.viewer.isopen
image_data = (pyglet.image.get_buffer_manager().get_color_buffer().
get_image_data())
arr = np.fromstring(image_data.get_data(), dtype=np.uint8, sep="")
arr = arr.reshape(VP_H, VP_W, 4)
arr = arr[::-1, :, 0:3]
return arr
def render(self, mode='human'):
# Initiate the viewer
if self.viewer is None:
self.viewer = rendering.Viewer(self.screen_width, self.screen_height)
clearance = 10
for i in range(0, self.N):
for j in range(0, self.historySave):
# Define the shift in position to transform the coordinate of the current drawing.
display_pos_x = (self.screen_width / (self.N + 1)) * (i + 1)
display_pos_y = (self.screen_height / (self.historySave + 2)) * (self.historySave - j + 1)
circletrans = rendering.Transform()
circletrans.set_translation(display_pos_x, display_pos_y)
# Clear the drawing by adding a larger circle with background color.
clear_box = rendering.make_circle(self.digitRadius + j*7, 30, True)
clear_box.set_color(1, 1, 1)
clear_box.add_attr(circletrans)
self.viewer.add_geom(clear_box)
# Draw the circle ball for each bandit.
# Radius of the circle is changed to address the current/past reward illustration.
number_0 = rendering.make_circle(self.digitRadius + j*4, 30, False)
number_0.add_attr(rendering.Transform(translation=(0, clearance)))
number_0.set_color(0, 0, 1)
number_1 = rendering.make_circle(self.digitRadius + j*4, 30, True)
number_1.add_attr(rendering.Transform(translation=(0, clearance)))
number_1.set_color(0, 0.5, 1)
if self.historyReward[i][j] == 0:
number_0.add_attr(circletrans)
self.viewer.add_geom(number_0)
if j == (self.historySave -1):
number_0.set_color(1, 0, 0)
else:
number_1.add_attr(circletrans)
self.viewer.add_geom(number_1)
if j == (self.historySave -1):
number_1.set_color(0, 0, 1)
# Clear the cursor area for updating the current cursor's position.
display_pos_x = 0
display_pos_y = (self.screen_height / (self.historySave + 2)) - self.digitRadius*3
clear_box = rendering.make_polygon([(0, 0), (0, self.digitRadius * 5), (self.screen_width, self.digitRadius * 5),
(self.screen_width, 0)])
boxtrans = rendering.Transform()
boxtrans.set_translation(display_pos_x, display_pos_y)
clear_box.add_attr(boxtrans)
clear_box.set_color(1, 1, 1)
self.viewer.add_geom(clear_box)
# Drawing the cursor to show which action/bandit is currently selected.
display_pos_x = (self.screen_width / (self.N + 1)) * (self.action + 1) - self.digitRadius
display_pos_y = (self.screen_height / (self.historySave + 2)) - self.digitRadius
arrow = rendering.make_polygon([(0, 0), (0, self.digitRadius*2), (self.digitRadius*2, self.digitRadius*2), (self.digitRadius*2, 0)])
boxtrans = rendering.Transform()
boxtrans.set_translation(display_pos_x, display_pos_y)
arrow.add_attr(boxtrans)
arrow.set_color(1, 0, 0)
self.viewer.add_geom(arrow)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def _render_state(s, color=(1, 0, 0)):
attr = rendering.Transform(translation=tuple(s))
circ = rendering.make_circle(0.1)
circ.set_color(*color)
circ.add_attr(attr)
return circ
def render(self, mode='human'):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(WINDOW_W, WINDOW_H)
self.score_label = pyglet.text.Label('0000',
font_size=36,
x=20,
y=WINDOW_H * 2.5 / 40.00,
anchor_x='left',
anchor_y='center',
color=(255, 255, 255, 255))
self.transform = rendering.Transform()
if "t" not in self.__dict__: return # reset() not called yet
# zoom = 0.1*SCALE*max(1-self.t, 0) + ZOOM*SCALE*min(self.t, 1) # Animate zoom first second
zoom = ZOOM * SCALE
zoom_state = ZOOM * SCALE * STATE_W / WINDOW_W
zoom_video = ZOOM * SCALE * VIDEO_W / WINDOW_W
scroll_x = self.car.hull.position[0]
scroll_y = self.car.hull.position[1]
angle = -self.car.hull.angle
vel = self.car.hull.linearVelocity
if np.linalg.norm(vel) > 0.5:
angle = math.atan2(vel[0], vel[1])
self.transform.set_scale(zoom, zoom)
self.transform.set_translation(
WINDOW_W / 2 - (scroll_x * zoom * math.cos(angle) -
scroll_y * zoom * math.sin(angle)),
WINDOW_H / 4 - (scroll_x * zoom * math.sin(angle) +
scroll_y * zoom * math.cos(angle)))
self.transform.set_rotation(angle)
self.car.draw(self.viewer, mode != "state_pixels")
arr = None
win = self.viewer.window
if mode != 'state_pixels':
win.switch_to()
win.dispatch_events()
if mode == "rgb_array" or mode == "state_pixels":
win.clear()
t = self.transform
if mode == 'rgb_array':
VP_W = VIDEO_W
VP_H = VIDEO_H
else:
VP_W = STATE_W
VP_H = STATE_H
gl.glViewport(0, 0, VP_W, VP_H)
t.enable()
self.render_road()
for geom in self.viewer.onetime_geoms:
geom.render()
t.disable()
self.render_indicators(WINDOW_W,
WINDOW_H) # TODO: find why 2x needed, wtf
image_data = pyglet.image.get_buffer_manager().get_color_buffer(
).get_image_data()
arr = np.fromstring(image_data.data, dtype=np.uint8, sep='')
arr = arr.reshape(VP_H, VP_W, 4)
arr = arr[::-1, :, 0:3]
if mode == "rgb_array" and not self.human_render: # agent can call or not call env.render() itself when recording video.
win.flip()
if mode == 'human':
self.human_render = True
win.clear()
t = self.transform
gl.glViewport(0, 0, WINDOW_W, WINDOW_H)
t.enable()
self.render_road()
for geom in self.viewer.onetime_geoms:
geom.render()
t.disable()
self.render_indicators(WINDOW_W, WINDOW_H)
win.flip()
self.viewer.onetime_geoms = []
return arr
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
screen_width = 1300
screen_height = 800
scale_width = screen_width / (self.bound_box[0, 1] -
self.bound_box[0, 0])
scale_height = screen_height / (self.bound_box[1, 1] -
self.bound_box[1, 0])
zero_width = scale_width * (-self.bound_box[0, 0])
zero_height = scale_height * (-self.bound_box[1, 0])
drone_width = 20
drone_height = 20
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
l, r, t, b = -drone_width / 2, drone_width / 2, drone_height / 2, -drone_height / 2
drone = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
self.drone_trans = rendering.Transform()
drone.add_attr(self.drone_trans)
self.viewer.add_geom(drone)
goal = rendering.make_circle(screen_height / 6.0 * 0.5)
goal.set_color(.0, 1.0, .0)
self.goal_trans = rendering.Transform()
goal.add_attr(self.goal_trans)
self.viewer.add_geom(goal)
obstacles = []
self.obstacle_trans = []
for it_obstacles in range(self.obstacle_num):
radius = screen_height / 8.0 * self.obstacle_radius[
it_obstacles]
obstacles.append(rendering.make_circle(radius))
obstacles[it_obstacles].set_color(1.0, .0, .0)
self.obstacle_trans.append(rendering.Transform())
obstacles[it_obstacles].add_attr(
self.obstacle_trans[it_obstacles])
self.viewer.add_geom(obstacles[it_obstacles])
laser_readings = []
self.laser_readings_array = []
for it_laser in range(self.num_samples_laser):
laser_readings.append(rendering.make_circle(3))
laser_readings[it_laser].set_color(0.0, 0.0, 1.0)
self.laser_readings_array.append(rendering.Transform())
laser_readings[it_laser].add_attr(
self.laser_readings_array[it_laser])
self.viewer.add_geom(laser_readings[it_laser])
if self.state is None: return None
drone_x = self.state[0] * scale_width + zero_width
drone_y = self.state[1] * scale_height + zero_height
self.drone_trans.set_translation(drone_x, drone_y)
goal_x = self.goal_pos[0] * scale_width + zero_width
goal_y = self.goal_pos[1] * scale_height + zero_height
self.goal_trans.set_translation(goal_x, goal_y)
if self.obstacle_num == 1:
object_it_pos = self.objects_pos
obstacle_x = object_it_pos[0] * scale_width + zero_width
obstacle_y = object_it_pos[1] * scale_height + zero_height
self.obstacle_trans[0].set_translation(obstacle_x, obstacle_y)
else:
for it_obstacles in range(self.obstacle_num):
object_it_pos = self.objects_pos[it_obstacles, :]
obstacle_x = object_it_pos[0] * scale_width + zero_width
obstacle_y = object_it_pos[1] * scale_height + zero_height
self.obstacle_trans[it_obstacles].set_translation(
obstacle_x, obstacle_y)
if True:
rays = np.linspace(-np.pi / 2, np.pi / 2, self.num_samples_laser)
for it_laser in range(self.num_samples_laser):
laser_reading_it = self.laser_obs[it_laser]
# laser_reading_it = self.laser_readings()[it_laser]
if laser_reading_it > self.max_measurement_laser:
laser_reading_it = self.max_measurement_laser
laser_intersect = self.state[:2] + laser_reading_it * \
np.array([np.cos(rays[it_laser]),
np.sin(rays[it_laser])])
laser_x = laser_intersect[0] * scale_width + zero_width
laser_y = laser_intersect[1] * scale_height + zero_height
self.laser_readings_array[it_laser].set_translation(
laser_x, laser_y)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'): # graphic engine
from gym.envs.classic_control import rendering
if self.viewer is None: # create window viewer
self.viewer = rendering.Viewer(VIEWPORT_W, VIEWPORT_H)
self.viewer.set_bounds(0, VIEWPORT_W / SCALE, 0,
VIEWPORT_H / SCALE)
for obj in self.particles:
obj.ttl -= 0.15
obj.color1 = (max(0.2, 0.2 + obj.ttl), max(0.2, 0.5 * obj.ttl),
max(0.2, 0.5 * obj.ttl))
# obj.color1 = (max(0.1, 0.1 + obj.ttl), max(0.1, 0.1 * obj.ttl), max(0.1, 0.1 * obj.ttl))
obj.color2 = (max(0.2, 0.2 + obj.ttl), max(0.2, 0.5 * obj.ttl),
max(0.2, 0.5 * obj.ttl))
self._clean_particles(False)
for p in self.sky_polys:
self.viewer.draw_polygon(
p, color=(0.0, 0.0,
0.0)) # define the color of the background sky
""""################################## create stars ########################################"""
# draw large stars
for pos in self.stars_poly_large:
self.viewer.draw_polygon(v=((pos[0], pos[1]), (pos[0] + 0.05,
pos[1]),
(pos[0] + 0.05, pos[1] + 0.05),
(pos[0], pos[1] + 0.05)),
color=(1.0, 1.0, 1.0))
# draw small stars
for pos in self.stars_poly_small:
self.viewer.draw_polygon(v=((pos[0], pos[1]), (pos[0] + 0.02,
pos[1]),
(pos[0] + 0.02, pos[1] + 0.02),
(pos[0], pos[1] + 0.02)),
color=(1.0, 0.9, 0.9))
# draw "earth"
self.viewer.draw_circle_earth(radius=2.5,
res=100,
color=(0.0, 0.40, 0.80))
self.viewer.draw_polygon(v=((-0.02 + 10, 0 + 10.3), (-1.0 + 10,
1.4 + 10.3),
(1.1 + 10, 1.5 + 10.3), (0 + 10, 0 + 10.3),
(1.2 + 10, -0.5 + 10.3), (-0.3 + 10,
-2 + 10.3)),
color=(50 / 255, 200 / 255, 50 / 255))
""""################################## create stars ########################################"""
"""################################# Change the color of moon terrain ####################################"""
""" if do this, then moon terrain is not static body"""
for p in self.moon_polys:
self.viewer.draw_polygon(p,
color=(169 / 255, 169 / 255, 169 / 255))
"""################################# Change the color of moon terrain ####################################"""
for obj in self.particles + self.drawlist:
for f in obj.fixtures: # what does this for loop try to do ???
trans = f.body.transform
if type(f.shape) is circleShape:
t = rendering.Transform(translation=trans * f.shape.pos)
self.viewer.draw_circle(f.shape.radius,
20,
color=obj.color1).add_attr(t)
self.viewer.draw_circle(f.shape.radius,
20,
color=obj.color2,
filled=False,
linewidth=2).add_attr(t)
else:
path = [trans * v for v in f.shape.vertices]
self.viewer.draw_polygon(path, color=obj.color1)
path.append(path[0])
self.viewer.draw_polyline(path,
color=obj.color2,
linewidth=2)
flag_y1 = self.helipad_one_y
flag_y2 = self.helipad_one_y + 70 / SCALE
flag_x = self.helipad_one_x
self.viewer.draw_polyline(v=((flag_x, flag_y1), (flag_x, flag_y2)),
color=(1, 1, 1))
self.viewer.draw_polygon(v=((flag_x, flag_y2), (flag_x,
flag_y2 - 25 / SCALE),
(flag_x + 40 / SCALE,
flag_y2 - 25 / SCALE),
(flag_x + 40 / SCALE, flag_y2)),
color=(178 / 255, 34 / 255, 34 / 255))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 600
screen_height = 600
world_width = self.dimension - 1 + 2
world_height = self.dimension - 1 + 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.dimension - 1 + 1)):
heightX = float(heightX)
for widthX in range(int(self.dimension - 1 + 1)):
widthX = float(widthX)
xy = [(0.5 + widthX, 0.5 + heightX),
(0.5 + widthX, self.dimension - 1 + 1.5 - heightX),
(self.dimension - 1 + 1.5 - widthX,
self.dimension - 1 + 1.5 - heightX),
(self.dimension - 1 - 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.dimension - 1 + 1.5),
(self.dimension - 1 + 1.5, self.dimension - 1 + 1.5),
(self.dimension - 1 + 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.dimension - 1 + 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._position[0] + 1) * xscale,
(self._position[1] + 1) * yscale))
for k in range(len(self.obstacles)):
try:
self.obstacle_trans[k]
except:
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])
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._position[0] + 1) * xscale,
(self._position[1] + 1) * yscale)
self.robot_trans.set_scale(xscale, yscale)
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
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(VIEWPORT_W, VIEWPORT_H)
self.viewer.set_bounds(self.scroll, VIEWPORT_W / SCALE + self.scroll,
0, VIEWPORT_H / SCALE)
self.viewer.draw_polygon([
(self.scroll, 0),
(self.scroll + VIEWPORT_W / SCALE, 0),
(self.scroll + VIEWPORT_W / SCALE, VIEWPORT_H / SCALE),
(self.scroll, VIEWPORT_H / SCALE),
],
color=(0.9, 0.9, 1.0))
for poly, x1, x2 in self.cloud_poly:
if x2 < self.scroll / 2: continue
if x1 > self.scroll / 2 + VIEWPORT_W / SCALE: continue
self.viewer.draw_polygon([(p[0] + self.scroll / 2, p[1])
for p in poly],
color=(1, 1, 1))
for poly, color in self.terrain_poly:
if poly[1][0] < self.scroll: continue
if poly[0][0] > self.scroll + VIEWPORT_W / SCALE: continue
self.viewer.draw_polygon(poly, color=color)
self.lidar_render = (self.lidar_render + 1) % 100
i = self.lidar_render
if i < 2 * len(self.lidar):
l = self.lidar[i] if i < len(
self.lidar) else self.lidar[len(self.lidar) - i - 1]
self.viewer.draw_polyline([l.p1, l.p2],
color=(1, 0, 0),
linewidth=1)
for obj in self.drawlist:
for f in obj.fixtures:
trans = f.body.transform
if type(f.shape) is circleShape:
t = rendering.Transform(translation=trans * f.shape.pos)
self.viewer.draw_circle(f.shape.radius,
30,
color=obj.color1).add_attr(t)
self.viewer.draw_circle(f.shape.radius,
30,
color=obj.color2,
filled=False,
linewidth=2).add_attr(t)
else:
path = [trans * v for v in f.shape.vertices]
self.viewer.draw_polygon(path, color=obj.color1)
path.append(path[0])
self.viewer.draw_polyline(path,
color=obj.color2,
linewidth=2)
flagy1 = TERRAIN_HEIGHT
flagy2 = flagy1 + 50 / SCALE
x = TERRAIN_STEP * 3
self.viewer.draw_polyline([(x, flagy1), (x, flagy2)],
color=(0, 0, 0),
linewidth=2)
f = [(x, flagy2), (x, flagy2 - 10 / SCALE),
(x + 25 / SCALE, flagy2 - 5 / SCALE)]
self.viewer.draw_polygon(f, color=(0.9, 0.2, 0))
self.viewer.draw_polyline(f + [f[0]], color=(0, 0, 0), linewidth=2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
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[1] + 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)
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)
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.goal_area = None
self.goal_trans = None
l,r,t,b = -goalwidth, goalwidth, goalheight, -goalheight
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.goal_area.add_attr(rendering.Transform(translation=(0, 0)))
self.goal_trans = rendering.Transform()
self.goal_area.add_attr(self.goal_trans)
self.viewer.add_geom(self.goal_area)
self._trajectory.append( ( (self.state[0] + 1 ) * xscale, (self.state[1] + 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] + 1) * xscale, (self.state[1] + 1) * yscale)
self.robot_trans.set_scale(xscale,yscale)
self.goal_trans.set_translation((self.terminal[0] + 1) * xscale, (self.terminal[1] + 1) * yscale)
self.goal_trans.set_scale(xscale,yscale)
return self.viewer.render(return_rgb_array = mode=='rgb_array')
