def _vis_o_prev_v(self):
if True: # self.vis_init:
prev_v_color = (0., 1., 0.)
self.vis_prev_v = [rendering.Line() for _ in range(self.hp_uav_n)]
for i in range(self.hp_uav_n):
self.vis_prev_v[i].set_color(*prev_v_color)
self.vis_prev_v[i].linewidth.stroke = 2
# self.vis_viewer.add_geom(self.vis_prev_v[i])
self.vis_viewer.add_onetime(self.vis_prev_v[i])
for i in range(self.hp_uav_n):
self.vis_prev_v[i].start = self.s_uav_pos_prev[i]
local_uav_v_prev_prev = self.o_prev_prev[i]
s_goal = self.s_goal
s_uav_pos_prev = self.s_uav_pos_prev[i]
rela_goal_pos = s_goal - s_uav_pos_prev
rot_inv_mat = self.local_to_global(rela_goal_pos)
global_uav_v_prev_prev = np.dot(rot_inv_mat, local_uav_v_prev_prev)
if self.hp_coord_mode == 'local':
self.vis_prev_v[i].end = self.s_uav_pos_prev[i] + global_uav_v_prev_prev
else:
self.vis_prev_v[i].end = self.s_uav_pos_prev[i] + local_uav_v_prev_prev
def make_visualizer(self, width=640, height=480):
from gym.envs.classic_control import rendering
self.visualizer_width = width
self.visualizer_height = height
self.visualizer_cart_width = 40
self.visualizer_cart_height = 40
self.visualizer_pole_width = 10
self.visualizer_pole_height = 100
self.visualizer_border = 50
self.viewer = rendering.Viewer(self.visualizer_width,
self.visualizer_height)
self.track = rendering.Line(
(self.visualizer_border, self.visualizer_height / 2),
(self.visualizer_width - self.visualizer_border,
self.visualizer_height / 2))
self.track.set_color(1, 0, 0)
self.viewer.add_geom(self.track)
l, r, t, b = -self.visualizer_cart_width / 2, self.visualizer_cart_width / 2, self.visualizer_cart_height / 2, -self.visualizer_cart_height / 2
cart = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
self.cart_trans = rendering.Transform()
cart.add_attr(self.cart_trans)
cart.set_color(0, 0, 0)
self.viewer.add_geom(cart)
l, r, t, b = -self.visualizer_pole_width / 2, self.visualizer_pole_width / 2, self.visualizer_pole_height - self.visualizer_pole_width / 2, -self.visualizer_pole_width / 2
pole = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole.set_color(0.5, 0.5, 0.5)
self.pole_trans = rendering.Transform(translation=(0, 0))
pole.add_attr(self.pole_trans)
pole.add_attr(self.cart_trans)
self.viewer.add_geom(pole)
def render(self, mode='human'):
screen_width = 600
screen_height = 400
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
self.track = rendering.Line((0, screen_height / 2),
(screen_width, screen_height / 2))
self.track.set_color(0, 0, 1)
self.viewer.add_geom(self.track)
self.traj = rendering.PolyLine([], False)
self.traj.set_color(1, 0, 0)
self.traj.set_linewidth(3)
self.viewer.add_geom(self.traj)
if len(self.traj.v) != len(self._path):
self.traj.v = []
for p in self._path:
self.traj.v.append(
(p[0] * 100, screen_height / 2 + p[1] * 100))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 500
screen_height = 500
playersize = 50
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
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 = -polewidth / 2, polewidth / 2, polelen - polewidth / 2, -polewidth / 2
pole = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole.set_color(.8, .6, .4)
self.poletrans = rendering.Transform(translation=(0, axleoffset))
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(.5, .5, .8)
self.viewer.add_geom(self.axle)
self.track = rendering.Line((0, carty), (screen_width, carty))
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])
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()
return
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(750, 500)
self.viewer.set_bounds(-2, 12, 0, 5)
evader = rendering.make_circle(1, 30, True)
evader.set_color(0, 1, 0)
self.evader_transform = rendering.Transform()
evader.add_attr(self.evader_transform)
self.viewer.add_geom(evader)
pursuer = rendering.make_circle(1, 30, True)
pursuer.set_color(1, 0, 0)
self.pursuer_transform = rendering.Transform()
pursuer.add_attr(self.pursuer_transform)
self.viewer.add_geom(pursuer)
fence = rendering.Line((0, 2.5), (10, 2.5))
self.viewer.add_geom(fence)
# draw
self.viewer.render()
self.evader_transform.set_translation(self.state[0], 3.75)
self.pursuer_transform.set_translation(self.state[1], 1.25)
if mode == 'rgb_array':
return self.viewer.get_array()
elif mode == 'human':
pass
else:
return super(FenceEscape, self).render(mode=mode)
def make_wall(wall: Wall) -> rendering.Geom: # pylint: disable=unused-argument
geom_background = rendering.make_polygon(
[(-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0)],
filled=True,
)
geom_background.set_color(*RED)
geom_tile_lines = [
# horizontal
rendering.Line((-1.0, -0.33), (1.0, -0.33)),
rendering.Line((-1.0, 0.33), (1.0, 0.33)),
# vertical
rendering.Line((-0.5, -1.0), (-0.5, -0.33)),
rendering.Line((0.5, -1.0), (0.5, -0.33)),
# vertical
rendering.Line((0.0, -0.33), (0.0, 0.33)),
# vertical
rendering.Line((-0.5, 1.0), (-0.5, 0.33)),
rendering.Line((0.5, 1.0), (0.5, 0.33)),
]
return Group([geom_background, *geom_tile_lines])
def render(self, mode='human'):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.screen_width, \
self.screen_height)
left, right, top, bottom = -self.boatwidth/2, \
self.boatwidth/2, \
self.boatheight/2, \
-self.boatheight/2
boat = rendering.FilledPolygon([(left, bottom), \
(left, top), (right, top), \
(right, bottom)])
self.boattrans = rendering.Transform()
boat.add_attr(self.boattrans)
self.viewer.add_geom(boat)
left, right, top, bottom = -self.dockwidth/2, self.dockwidth/2,\
self.dockheight/2, -self.dockheight/2
dock = rendering.FilledPolygon([(left, bottom), (left, top),\
(right, top), (right, bottom)])
dock.set_color(.8, .6, .4)
self.docktrans = rendering.Transform()
dock.add_attr(self.docktrans)
self.viewer.add_geom(dock)
self.track = rendering.Line((0, self.screen_height/2), \
(self. screen_width,self.screen_height/2))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
position = self.state[0]
boatx = position[0] + self.screen_width / 2
self.boattrans.set_translation(boatx, 50)
self.docktrans.set_translation(self.screen_width / 2,
self.dockheight / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human', close=False):
# If close is True, close the created viewer
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
screen_width, screen_height = (600, 400)
self.viewer = rendering.Viewer(screen_width, screen_height)
# Create grid world
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))
# Create the first skeleton
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)
# Create the second skeleton
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)
# Create the bullion
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)
# Create the robot
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, values=None, mode='human'):
screen_width = 600
screen_height = 600
square_size_height = screen_height / self.n_squares_height
square_size_width = screen_width / self.n_squares_width
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
#add invisible squares for visualising state values
l, r, t, b = -square_size_width / 2, square_size_width / 2, square_size_height / 2, -square_size_height / 2
self.squares = [[
rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
for j in range(0, self.n_squares_width)
] for i in range(0, self.n_squares_height)]
sq_transforms = [[
rendering.Transform() for j in range(0, self.n_squares_width)
] for i in range(0, self.n_squares_height)]
for i in range(0, self.n_squares_height):
for j in range(0, self.n_squares_width):
self.squares[i][j].add_attr(sq_transforms[i][j])
self.viewer.add_geom(self.squares[i][j])
sq_x, sq_y = self.convert_pos_to_xy(
(i, j), (square_size_width, square_size_height))
sq_transforms[i][j].set_translation(sq_x, sq_y)
self.squares[i][j].set_color(1, 1, 1)
#horizontal grid lines
for i in range(1, self.n_squares_height):
track = rendering.Line((0, i * square_size_height),
(screen_width, i * square_size_height))
track.set_color(0, 0, 0)
self.viewer.add_geom(track)
#vertical grid lines
for i in range(1, self.n_squares_width):
track = rendering.Line((i * square_size_width, 0),
(i * square_size_width, screen_height))
track.set_color(0, 0, 0)
self.viewer.add_geom(track)
#the agent
#self.agent = rendering.Image('robo.jpg', width=square_size_width/2, height=square_size_height/2)
l, r, t, b = -square_size_width / 4, square_size_width / 4, square_size_height / 4, -square_size_height / 4
self.agent = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
#self.agent = make_oval(width=square_size_width/2, height=square_size_height/2)
self.agenttrans = rendering.Transform()
self.agent.add_attr(self.agenttrans)
self.viewer.add_geom(self.agent)
#the goal
self.goal = make_oval(width=square_size_width / 4,
height=square_size_height / 4)
self.goal.set_color(1, 0, 1)
self.goaltrans = rendering.Transform()
self.goal.add_attr(self.goaltrans)
self.viewer.add_geom(self.goal)
if self.state is None: return
goal_pos = list(zip(*np.where(self.state[0] == 1)))[0]
agent_pos = list(zip(*np.where(self.state[2] == 1)))[0]
agent_x, agent_y = self.convert_pos_to_xy(
agent_pos, (square_size_width, square_size_height))
self.agenttrans.set_translation(agent_x, agent_y)
goal_x, goal_y = self.convert_pos_to_xy(
goal_pos, (square_size_width, square_size_height))
self.goaltrans.set_translation(goal_x, goal_y)
if values is not None:
maxval, minval = values.max(), values.min()
rng = maxval - minval
for i, row in enumerate(values):
for j, val in enumerate(row):
if rng == 0: col = 1
else: col = (maxval - val) / rng
self.squares[i][j].set_color(col, 1, col)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode="human"):
screen_width = 600
screen_height = 400
world_width = self.x_threshold * 2
scale = screen_width / world_width
carty = 100 # TOP OF CART
polewidth = 10.0
polelen = scale * (2 * self.length)
cartwidth = 50.0
cartheight = 30.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
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 = (
-polewidth / 2,
polewidth / 2,
polelen - polewidth / 2,
-polewidth / 2,
)
pole = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole.set_color(0.8, 0.6, 0.4)
self.poletrans = rendering.Transform(translation=(0, axleoffset))
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.5, 0.5, 0.8)
self.viewer.add_geom(self.axle)
self.track = rendering.Line((0, carty), (screen_width, carty))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
self._pole_geom = pole
if self.state is None:
return None
# Edit the pole polygon vertex
pole = self._pole_geom
l, r, t, b = (
-polewidth / 2,
polewidth / 2,
polelen - polewidth / 2,
-polewidth / 2,
)
pole.v = [(l, b), (l, t), (r, t), (r, b)]
x = self.state
cartx = x[0] * scale + screen_width / 2.0 # MIDDLE OF CART
self.carttrans.set_translation(cartx, carty)
self.poletrans.set_rotation(-x[2])
return self.viewer.render(return_rgb_array=mode == "rgb_array")
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
screen_width = 700
screen_height = 600
world_width = self.x_threshold * 2
scale = screen_width / world_width
carty = 100 # TOP OF CART
polewidth = 10.0
polelen = scale * 1.0
cartwidth = 20.0
cartheight = 20.0
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width,
screen_height,
display=self.display)
#affichage robot
l, rt, rb, t, b = -cartwidth / 2, 15, 15, cartheight / 2, -cartheight / 2
axleoffset = cartheight / 4.0
self.chose = []
cart = rendering.FilledPolygon([(l, b), (l, t), (rt, t), (rb, b),
(rt, rb)])
self.chose.append(cart)
self.carttrans = rendering.Transform()
cart.add_attr(self.carttrans)
self.viewer.add_geom(self.chose[0])
#affichage ligne de separation
self.ligne = rendering.Line((600, 0), (600, 600))
self.ligne.set_color(0, 0, 0)
self.viewer.add_geom(self.ligne)
#affichage arbres
self.truc = []
cpt = 0
for i in range(len(self.treeslocations) / 2):
tree_x = self.treeslocations[i]
tree_y = self.treeslocations[i + len(self.treeslocations) / 2]
self.truc.append(
rendering.FilledPolygon([
(tree_x * screen_width / 10 - 10,
tree_y * screen_height / 10 - 10),
(tree_x * screen_width / 10 + 10,
tree_y * screen_height / 10 - 10),
(tree_x * screen_width / 10 + 10,
tree_y * screen_height / 10 + 10),
(tree_x * screen_width / 10 - 10,
tree_y * screen_height / 10 + 10)
]))
self.truc[cpt].set_color(0, 1, 0)
self.viewer.add_geom(self.truc[cpt])
cpt += 1
#affichage fuites
self.fuites_render = []
cpt = 0
for i in range(len(self.fuites)):
fuite_x = self.fuites_view[i]
fuite_y = self.fuites_view[i + len(self.fuites_view) / 2]
self.fuites_render.append(
rendering.FilledPolygon([(fuite_x - 25, fuite_y - 25),
(fuite_x - 25, fuite_y + 25),
(fuite_x + 25, fuite_y - 25),
(fuite_x + 25, fuite_y + 25)]))
self.fuites_render[cpt].set_color(0, 0, 0)
self.viewer.add_geom(self.fuites_render[cpt])
cpt += 1
#affichage zone batterie
l, r, t, b = -cartwidth, cartwidth, cartheight, -cartheight
zone_b = rendering.FilledPolygon([
(self.battery_zone[0] * screen_width / 10 + l,
self.battery_zone[1] * screen_height / 10 + b),
(self.battery_zone[0] * screen_width / 10 + l,
self.battery_zone[1] * screen_height / 10 + t),
(self.battery_zone[0] * screen_width / 10 + r,
self.battery_zone[1] * screen_height / 10 + t),
(self.battery_zone[0] * screen_width / 10 + r,
self.battery_zone[1] * screen_height / 10 + b)
])
zone_b.set_color(1, 1, 0)
self.viewer.add_geom(zone_b)
#affichage zone eau
self.zone_w = rendering.FilledPolygon([
(self.water_zone[0] * screen_width / 10 + l,
self.water_zone[1] * screen_height / 10 + b),
(self.water_zone[0] * screen_width / 10 + l,
self.water_zone[1] * screen_height / 10 + t),
(self.water_zone[0] * screen_width / 10 + r,
self.water_zone[1] * screen_height / 10 + t),
(self.water_zone[0] * screen_width / 10 + r,
self.water_zone[1] * screen_height / 10 + b)
])
self.zone_w.set_color(0, 0, 1)
self.viewer.add_geom(self.zone_w)
#affichage etat reservoir robot
l, r, t, b = -10, 10, 10, -10
self.reservoir_render = rendering.FilledPolygon([
(650 + l, 325 + b), (650 + l, 325 + t), (650 + r, 325 + t),
(650 + r, 325 + b)
])
self.reservoir_render.set_color(0, 0, 1)
self.viewer.add_geom(self.reservoir_render)
x = self.state
cartx = x[0] * scale + screen_width / 2.0 # MIDDLE OF CART
carty = x[1] * scale + screen_height / 2
self.carttrans.set_rotation(x[2])
self.carttrans.set_translation(cartx, carty)
#changement couleur arbre
for i in range(len(self.treeslocations) / 2):
if (x[i + 4] == 1):
self.truc[i].set_color(1, 0, 0)
else:
self.truc[i].set_color(0, 1, 0)
#changement couleur fuite
for i in range(len(self.fuites)):
if (self.fuites[i] == 1):
self.fuites_render[i].set_color(0, 0, 1)
else:
self.fuites_render[i].set_color(0, 0, 0)
#le probleme est juste ici.
reservoir_color = (self.reservoir_lim -
self.reservoir) / self.reservoir_lim
#print(self.reservoir_lim)
#print(self.reservoir)
#print(self.reservoir/self.reservoir_lim)
#print(reservoir_color)
self.reservoir_render.set_color(reservoir_color, reservoir_color, 1)
#changement couleur cart selon la temperature
red_color = self.temperature / self.tempLim
self.chose[0].set_color(red_color, 0, 0)
#changement couleur zone eau
blue_color = 1 - (self.water_reserve / self.water_reserve_lim)
#print(blue_color)
self.zone_w.set_color(blue_color, blue_color, 1)
#print("hello world")
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', close=False):
factor = self.scaling_factor # scaling factor; should be a multiple of 10
window_width = self.l * factor
window_height = self.l * factor
if self.viewer is None:
self.viewer = rendering.Viewer(window_width, window_height)
l, r, t, b = 0, window_width, window_height / 2, -window_height / 2
outline = rendering.make_polygon([(l, b), (l, t), (r, t), (r, b)],
filled=False)
for i in np.arange(start=1 * factor,
stop=(self.l - 1) * factor + 1,
step=factor):
line_h = rendering.Line((0, i), (window_width, i))
line_w = rendering.Line((i, 0), (i, window_height))
self.viewer.add_geom(line_w)
self.viewer.add_geom(line_h)
for i in self.b_states_1:
partition1 = rendering.make_polygon(self.c(i))
partition1.set_color(0.1, 0.1, 0.1)
self.viewer.add_geom(partition1)
for i in self.b_states_2:
partition2 = rendering.make_polygon(self.c(i))
partition2.set_color(0.1, 0.1, 0.1)
self.viewer.add_geom(partition2)
for i in self.b_states_3:
partition3 = rendering.make_polygon(self.c(i))
partition3.set_color(0.1, 0.1, 0.1)
self.viewer.add_geom(partition3)
agent_pos = self.state
agent_x = agent_pos % self.l
agent_y = math.floor(agent_pos / self.l)
agent_coords = [
(agent_x * factor + 10, agent_y * factor + 10),
((agent_x + 1) * factor - 10, agent_y * factor + 10),
((agent_x + 1) * factor - 10, (agent_y + 1) * factor - 10),
(agent_x * factor + 10, (agent_y + 1) * factor - 10)
]
agent_point = rendering.make_polygon(agent_coords)
agent_point.set_color(0.5, 0, 0.5)
self.viewer.add_onetime(agent_point)
goal = self.c(self.finish[0])
goal_point = rendering.make_polygon(goal)
goal_point.set_color(0, 0, 1)
self.viewer.add_geom(goal_point)
for i in self.starting_states:
start = self.c(i)
start_point = rendering.make_polygon(start)
start_point.set_color(0, 0.5, 0)
self.viewer.add_geom(start_point)
agent_pos = self.state
agent_x = agent_pos % self.l
agent_y = math.floor(agent_pos / self.l)
agent_coords = [(agent_x * factor + 10, agent_y * factor + 10),
((agent_x + 1) * factor - 10, agent_y * factor + 10),
((agent_x + 1) * factor - 10,
(agent_y + 1) * factor - 10),
(agent_x * factor + 10, (agent_y + 1) * factor - 10)]
agent_point = rendering.make_polygon(agent_coords)
agent_point.set_color(0.5, 0, 0.5)
self.viewer.add_onetime(agent_point)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
""" visualise the system"""
# set window sizes
w_window = 600
h_window = 500
# 'real' width and height of the robot
robo_w = L1
robo_h = 0.5*robo_w
# set scaling factor
w_world = 2 * x_limit
scale = w_window/w_world
# width of arm in the window
w_arm = scale*L1/10
# length of lower arm in the window
s_L1 = scale*L1
# length of upper arm in the window
s_L2 = scale*L2
# width of robot in the window
w_robo = scale*robo_w
# height of robot in the window
h_robo = scale*robo_h
# diameter of wheels in the window
d_wheel = w_robo/4.
# robo vertical location
robo_y = d_wheel/2 + h_robo/2 + h_window/10
# track vertical location
track_y = robo_y - d_wheel/2 - h_robo/2
# Initialise a Viewer object if not exist
if self.viewer is None:
# create viewer with pre-defined window sizes
self.viewer = rendering.Viewer(w_window, h_window)
# create robot object and ghost robots for periodic display
self.robot = Robot(w_robo, h_robo, d_wheel, w_arm, s_L1, s_L2)
self.robot.add_to(self)
# plot ghost robots only if x_limit is ignored
if ignore_x_limit:
self.robot_ghost_l = Robot(w_robo, h_robo, d_wheel, w_arm, s_L1, s_L2)
self.robot_ghost_l.add_to(self)
self.robot_ghost_r = Robot(w_robo, h_robo, d_wheel, w_arm, s_L1, s_L2)
self.robot_ghost_r.add_to(self)
# create the track
self.track = rendering.Line((0, track_y), (w_window, track_y))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
if self.state is None:
return None
x, x_dot, alpha, alpha_dot, beta, beta_dot = self.state
if ignore_x_limit:
x = np.mod((x + x_limit), 2 * x_limit) - x_limit
robo_x = x*scale + w_window / 2.0
self.robot.cart_trans.set_translation(robo_x, robo_y)
self.robot.arm_l_trans.set_rotation(alpha)
self.robot.arm_u_trans.set_rotation((beta-alpha))
# plot ghost robots only if x_limit is ignored
if ignore_x_limit:
self.robot_ghost_l.cart_trans.set_translation(robo_x-w_window, robo_y)
self.robot_ghost_l.arm_l_trans.set_rotation(alpha)
self.robot_ghost_l.arm_u_trans.set_rotation((beta-alpha))
self.robot_ghost_r.cart_trans.set_translation(robo_x+w_window, robo_y)
self.robot_ghost_r.arm_l_trans.set_rotation(alpha)
self.robot_ghost_r.arm_u_trans.set_rotation((beta-alpha))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def draw_lasting_line(Viewer, start, end, **attrs):
geom = rendering.Line(start, end)
rendering._add_attrs(geom, attrs)
Viewer.add_geom(geom)
return geom
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])
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
screen_width = 600
screen_height = 600
# establish the scale relations with real world, using physical units.
world_width = self.height_threshold * 2
scale = screen_width / world_width
# rec1 represent the body, and rec2 represent the head.
rec1width = 80.0
rec1height = 30.0
rec2width = 50.0
rec2height = 30.0
# to display the variation of displacement of rec1 and rec2, make them stay at the center of screen.
rec1_bottom = 250
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height, display=self.display)
l, r, t, b = -rec1width / 2, rec1width / 2, -rec1height / 2, rec1height / 2
rec1 = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
rec1.set_color(0, 0, 0)
self.rec1trans = rendering.Transform()
rec1.add_attr(self.rec1trans)
self.viewer.add_geom(rec1)
l, r, t, b = -rec2width / 2, rec2width / 2, -rec2height / 2, rec2height / 2
rec2 = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
rec2.set_color(.8, .6, .4)
self.rec2trans = rendering.Transform()
rec2.add_attr(self.rec2trans)
self.viewer.add_geom(rec2)
# how to make line appear exactly once in one episode.
line1 = rendering.Line((0, 0), (screen_width, 0))
line1.set_color(0, 0, 0)
self.line1trans = rendering.Transform()
line1.add_attr(self.line1trans)
self.viewer.add_geom(line1)
line2 = rendering.Line((0, 0), (screen_width, 0))
line2.set_color(.8, .6, .4)
self.line2trans = rendering.Transform()
line2.add_attr(self.line2trans)
self.viewer.add_geom(line2)
x = self.state
rec1x = screen_width / 2.0
rec1y = x[2] * scale + rec1_bottom
rec2x = screen_width / 2.0
rec2y = x[0] * scale + rec1_bottom
# absolute transformations, reference the position of origin.
self.rec1trans.set_translation(rec1x, rec1y)
self.rec2trans.set_translation(rec2x, rec2y)
self.line1trans.set_translation(0, self.balance_body * scale + rec1_bottom)
self.line2trans.set_translation(0, self.balance_head * scale + rec1_bottom)
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
rwidth = 80
l, r, t, b = 100, 100 + rwidth, 100 + rwidth, 100
if self.viewer is None:
#from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
#create grid world
for index in range(0, 6):
line1 = rendering.Line(
(l, b + index * rwidth),
(l + self.sizex * rwidth, b + index * rwidth))
line1.set_color(0.5, 0, 0)
self.viewer.add_geom(line1)
line2 = rendering.Line(
(l + index * rwidth, b),
(l + index * rwidth, b + self.sizey * rwidth))
line2.set_color(0.5, 0, 0)
self.viewer.add_geom(line2)
#create obstacles
for index in range(0, len(self.obstacles)):
pole1 = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
pole1.set_color(0, 0, 0)
tx, ty = self.obstacles[index] % self.sizex, self.obstacles[
index] // self.sizex
self.poletrans1 = rendering.Transform(translation=(rwidth * tx,
rwidth *
ty))
pole1.add_attr(self.poletrans1)
self.viewer.add_geom(pole1)
#create terminal
pole2 = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole2.set_color(0.2, 0.8, 0.4)
tx, ty = self.terminate % self.sizex, self.terminate // self.sizex
self.poletrans2 = rendering.Transform(translation=(rwidth * tx,
rwidth * ty))
pole2.add_attr(self.poletrans2)
self.viewer.add_geom(pole2)
#create robot
tx, ty = self.statex + 0.5, self.statey + 0.5
self.robot = rendering.make_circle(30)
self.robotrans = rendering.Transform(translation=(l + rwidth * tx,
b + rwidth * ty))
self.robot.add_attr(self.robotrans)
self.robot.set_color(0.8, 0.2, 0.2)
self.viewer.add_geom(self.robot)
if self.state is None: return None
tx, ty = self.statex + 0.5, self.statey + 0.5
self.robotrans.set_translation(l + rwidth * tx,
b + rwidth * ty) #translate robot
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 800
screen_height = 600
x, y, theta, x_dot, y_dot, theta_dot = self.state
# theta = (((theta+np.pi) % (2*np.pi))) - np.pi
costheta = np.cos(theta)
sintheta = np.sin(theta)
theta = np.arctan2(sintheta, costheta)
world_width = self.x_threshold * 2
scale = screen_width / world_width
carty = y * scale + screen_height / 2.0
cartx = x * scale + screen_width / 2.0
polewidth = 10.0
polelen = scale * (2 * self.l)
fan_width = 10.0
fan_height = 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 = -polelen / 2, polelen / 2, polewidth / 2, -polewidth / 2
pole = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole.set_color(.8, .6, .4)
self.pole_trans = rendering.Transform()
pole.add_attr(self.pole_trans)
self.viewer.add_geom(pole)
l, r, t, b = -fan_width / 2, fan_width / 2, fan_height - fan_width / 2, -fan_width / 2
axle1 = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
axle1.set_color(.5, .5, .8)
self.axle1_trans = rendering.Transform()
axle1.add_attr(self.axle1_trans)
self.viewer.add_geom(axle1)
axle2 = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
axle2.set_color(.5, .5, .8)
self.axle2_trans = rendering.Transform()
axle2.add_attr(self.axle2_trans)
self.viewer.add_geom(axle2)
trackx = rendering.Line((0, -polelen / 4), (0, polelen / 4))
trackx.set_color(255, 0, 0)
self.trackx_trans = rendering.Transform()
trackx.add_attr(self.trackx_trans)
self.viewer.add_geom(trackx)
tracky = rendering.Line((-polelen / 4, 0), (polelen / 4, 0))
tracky.set_color(255, 0, 0)
self.tracky_trans = rendering.Transform()
tracky.add_attr(self.tracky_trans)
self.viewer.add_geom(tracky)
goal = rendering.Line(
(-polelen / 4 + screen_width / 2, screen_height / 2),
(polelen / 4 + screen_width / 2, screen_height / 2))
goal.set_color(0, 255, 0)
self.viewer.add_geom(goal)
goal = rendering.Line(
(screen_width / 2, screen_height / 2 - polelen / 4),
(screen_width / 2, screen_height / 2 + polelen / 4))
goal.set_color(0, 255, 0)
self.viewer.add_geom(goal)
self._pole_geom = pole
if self.state is None:
return None
self.pole_trans.set_translation(cartx, carty)
self.pole_trans.set_rotation(theta)
self.trackx_trans.set_translation(cartx, carty)
self.tracky_trans.set_translation(cartx, carty)
self.axle1_trans.set_translation(cartx + (polelen / 2 * np.cos(theta)),
carty + (polelen / 2 * np.sin(theta)))
self.axle1_trans.set_rotation(theta)
self.axle2_trans.set_translation(cartx - (polelen / 2 * np.cos(theta)),
carty - (polelen / 2 * np.sin(theta)))
self.axle2_trans.set_rotation(theta)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
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'):
from gym.envs.classic_control import rendering
screen_width = 600
screen_height = 600
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
#创建网格世界
self.line1 = rendering.Line((100, 100), (500, 100))
self.line2 = rendering.Line((100, 200), (500, 200))
self.line3 = rendering.Line((100, 300), (500, 300))
self.line4 = rendering.Line((100, 400), (500, 400))
self.line5 = rendering.Line((100, 500), (500, 500))
self.line6 = rendering.Line((100, 100), (100, 500))
self.line7 = rendering.Line((200, 100), (200, 500))
self.line8 = rendering.Line((300, 100), (300, 500))
self.line9 = rendering.Line((400, 100), (400, 500))
self.line10 = rendering.Line((500, 100), (500, 500))
#创建石柱
self.shizhu = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(250, 350))
self.shizhu.add_attr(self.circletrans)
self.shizhu.set_color(0.8, 0.6, 0.4)
#创建第一个火坑
self.fire1 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(450, 250))
self.fire1.add_attr(self.circletrans)
self.fire1.set_color(1, 0, 0)
#创建第二个火坑
self.fire2 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(150, 150))
self.fire2.add_attr(self.circletrans)
self.fire2.set_color(1, 0, 0)
#创建宝石
self.diamond = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(450, 150))
self.diamond.add_attr(self.circletrans)
self.diamond.set_color(0, 0, 1)
#创建机器人
self.robot = rendering.make_circle(30)
self.robotrans = rendering.Transform()
self.robot.add_attr(self.robotrans)
self.robot.set_color(0, 1, 0)
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.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.shizhu)
self.viewer.add_geom(self.fire1)
self.viewer.add_geom(self.fire2)
self.viewer.add_geom(self.diamond)
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', screen_width=1000):
# whether draw pulse and echo source
draw_pulse_direction = True
draw_echo_source = False
# settings screen
aspect_ratio = self.world_height / self.world_width
screen_height = int(aspect_ratio * screen_width)
scale = screen_width / self.world_width
# initilize screen
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
r = (self.bat.size * scale) / 2
wing = 4 * math.pi / 5 # angle [rad]
nose_x, nose_y = r, 0
r_x, r_y = r * math.cos(-wing), r * math.sin(-wing)
l_x, l_y = r * math.cos(+wing), r * math.sin(+wing)
bat_geom = rendering.FilledPolygon([
(nose_x, nose_y),
(r_x, r_y),
(l_x, l_y)])
bat_geom.set_color(0, 0, 0)
self.battrans = rendering.Transform()
bat_geom.add_attr(self.battrans)
self.viewer.add_geom(bat_geom)
self._bat_geom = bat_geom
for w in self.walls:
x0, y0, x1, y1 = w.unpack() * scale
line = rendering.Line((x0, y0), (x1, y1))
line.linewidth = rendering.LineWidth(10)
line.set_color(0.5, 0.5, 0.5)
self.viewer.add_geom(line)
bat_geom = self._bat_geom
self.battrans.set_translation(*self.bat.bat_vec * scale)
self.battrans.set_rotation(self.bat.angle)
if self.bat.emit == True:
if draw_pulse_direction == True:
pulse_length = 0.5
pulse_vec = pulse_length * cos_sin(self.last_pulse_angle)
pulse_vec = rotate_vector(
pulse_vec, self.bat.angle) + self.bat.bat_vec
x0, y0 = self.bat.bat_vec * scale
x1, y1 = pulse_vec * scale
line = self.viewer.draw_line([x0, y0], [x1, y1])
self.viewer.add_geom(line)
if draw_echo_source == True:
radius = 4 # pixel
echo_source_vec = self.bat.state[0] * self.bat.lidar_length
echo_source_vec = rotate_vector(
echo_source_vec, self.bat.angle) + self.bat.bat_vec
x, y = echo_source_vec * scale
echo_source = rendering.make_circle(radius)
echo_source.set_color(0.9, 0.65, 0.4)
echotrans = rendering.Transform()
echo_source.add_attr(echotrans)
echotrans.set_translation(x, y)
self.viewer.add_geom(echo_source)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 600
screen_height = 400
world_width = self.x_threshold * 2
scale = screen_width / world_width
carty = 100 # TOP OF CART
polewidth = 10.0
polelen = scale * 1.0
cartwidth = 50.0
cartheight = 30.0
x = self.state
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
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 = -polewidth / 2, polewidth / 2, polelen - polewidth / 2, -polewidth / 2
pole = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole.set_color(.8, .6, .4)
self.poletrans = rendering.Transform(translation=(0, axleoffset))
pole.add_attr(self.poletrans)
pole.add_attr(self.carttrans)
self.viewer.add_geom(pole)
pole_2 = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
pole_2.set_color(.8, .6, .4)
self.poletrans_2 = rendering.Transform(translation=(0, axleoffset))
pole_2.add_attr(self.poletrans_2)
self.viewer.add_geom(pole_2)
self.axle = rendering.make_circle(polewidth / 2)
self.axle.add_attr(self.poletrans)
self.axle.add_attr(self.carttrans)
self.axle.set_color(.5, .5, .8)
self.viewer.add_geom(self.axle)
self.axle_2 = rendering.make_circle(polewidth / 2)
self.axle_2.add_attr(self.poletrans_2)
#self.axle.add_attr(self.carttrans)
self.axle_2.set_color(.5, .5, .8)
self.viewer.add_geom(self.axle_2)
self.track = rendering.Line((0, carty), (screen_width, carty))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
if self.state is None: return None
cartx = x[0] * scale + screen_width / 2.0 # MIDDLE OF CART
self.carttrans.set_translation(cartx, carty)
self.poletrans.set_rotation(-x[2])
self.poletrans_2.set_translation(cartx + np.sin(x[2]) * polelen,
carty + np.cos(x[2]) * polelen)
self.poletrans_2.set_rotation(-x[4])
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
floory = 50 # floor
screen_width = 600
screen_height = int(self.y_threshold) + 2 * floory
polewidth = 10.0
state = self.state
x1, x2, x3, x4, x5, y1, y2, y3, y4, y5, z1, z2, z3, z4, z5, YCM, yd, _, _, _, _, _, rotAngleX, rotAngleY, rotAngleZ = state
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
self.poletrans = rendering.Transform(translation=(screen_width / 2,
floory))
self.poletranszy = rendering.Transform(
translation=(screen_width / 2 + 200, floory))
self.headtrans = rendering.Transform(translation=(screen_width / 2,
floory))
self.headtranszy = rendering.Transform(
translation=(screen_width / 2 + 200, floory))
# back leg
deltax = polewidth / 2 * (y2 - y1) / self.lengths[0]
deltay = -polewidth / 2 * (x2 - x1) / self.lengths[0]
#deltaz = -polewidth/2*(z2-z1)/self.lengths[0]
leg1 = rendering.FilledPolygon([(x1 - deltax / 2, y1 - deltay / 2),
(x2 - deltax, y2 - deltay),
(x2 + deltax, y2 + deltay),
(x1 + deltax / 2, y1 + deltay / 2)
])
leg1zy = rendering.FilledPolygon([
(z1 - deltax / 2, y1 - deltay / 2), (z2 - deltax, y2 - deltay),
(z2 + deltax, y2 + deltay), (z1 + deltax / 2, y1 + deltay / 2)
])
# back of the body
deltax = polewidth / 2 * (y3 - y2) / self.lengths[1]
deltay = -polewidth / 2 * (x3 - x2) / self.lengths[1]
backBody = rendering.FilledPolygon([(x2 - deltax, y2 - deltay),
(x3 - deltax, y3 - deltay),
(x3 + deltax, y3 + deltay),
(x2 + deltax, y2 + deltay)])
backBodyzy = rendering.FilledPolygon([(z2 - deltax, y2 - deltay),
(z3 - deltax, y3 - deltay),
(z3 + deltax, y3 + deltay),
(z2 + deltax, y2 + deltay)])
# front of the body
deltax = polewidth / 2 * (y4 - y3) / self.lengths[2]
deltay = -polewidth / 2 * (x4 - x3) / self.lengths[2]
frontBody = rendering.FilledPolygon([(x3 - deltax, y3 - deltay),
(x4 - deltax, y4 - deltay),
(x4 + deltax, y4 + deltay),
(x3 + deltax, y3 + deltay)])
frontBodyzy = rendering.FilledPolygon([(z3 - deltax, y3 - deltay),
(z4 - deltax, y4 - deltay),
(z4 + deltax, y4 + deltay),
(z3 + deltax, y3 + deltay)])
# leg 2
deltax = polewidth / 2 * (y5 - y4) / self.lengths[3]
deltay = -polewidth / 2 * (x5 - x4) / self.lengths[3]
leg2 = rendering.FilledPolygon([(x4 - deltax, y4 - deltay),
(x5 - deltax / 2, y5 - deltay / 2),
(x5 + deltax / 2, y5 + deltay / 2),
(x4 + deltax, y4 + deltay)])
leg2zy = rendering.FilledPolygon([
(z4 - deltax, y4 - deltay), (z5 - deltax / 2, y5 - deltay / 2),
(z5 + deltax / 2, y5 + deltay / 2), (z4 + deltax, y4 + deltay)
])
leg1.set_color(.8, .6, .4)
leg1.add_attr(self.poletrans)
self.viewer.add_geom(leg1)
leg1zy.set_color(.8, .6, .4)
leg1zy.add_attr(self.poletranszy)
self.viewer.add_geom(leg1zy)
backBody.set_color(.8, .6, .4)
backBody.add_attr(self.poletrans)
self.viewer.add_geom(backBody)
backBodyzy.set_color(.8, .6, .4)
backBodyzy.add_attr(self.poletranszy)
self.viewer.add_geom(backBodyzy)
frontBody.set_color(.8, .6, .4)
frontBody.add_attr(self.poletrans)
self.viewer.add_geom(frontBody)
frontBodyzy.set_color(.8, .6, .4)
frontBodyzy.add_attr(self.poletranszy)
self.viewer.add_geom(frontBodyzy)
leg2.set_color(.8, .6, .4)
leg2.add_attr(self.poletrans)
self.viewer.add_geom(leg2)
leg2zy.set_color(.8, .6, .4)
leg2zy.add_attr(self.poletranszy)
self.viewer.add_geom(leg2zy)
#cat head
head = rendering.make_circle(polewidth)
head.add_attr(self.poletrans)
head.add_attr(self.headtrans)
head.set_color(.8, .6, .4)
self.viewer.add_geom(head)
headzy = rendering.make_circle(polewidth)
headzy.add_attr(self.headtranszy)
headzy.set_color(.8, .6, .4)
self.viewer.add_geom(headzy)
#add horizon line corresponding to the floor
self.track = rendering.Line((0, floory), (screen_width, floory))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
self._cat3D_geom1 = leg1
self._cat3D_geom1zy = leg1zy
self._cat3D_geom2 = backBody
self._cat3D_geom2zy = backBodyzy
self._cat3D_geom3 = frontBody
self._cat3D_geom3zy = frontBodyzy
self._cat3D_geom4 = leg2
self._cat3D_geom4zy = leg2zy
self._cat3D_geom5 = head
self._cat3D_geom6 = headzy
if self.state is None: return None
# leg 1
leg1 = self._cat3D_geom1
delta_vector = self.unit_vector(np.array([(y2 - y1), -(x2 - x1)]))
deltax = polewidth / 2 * delta_vector[0]
deltay = polewidth / 2 * delta_vector[1]
leg1.v = [(x1 - deltax / 2, y1 - deltay / 2),
(x2 - deltax, y2 - deltay), (x2 + deltax, y2 + deltay),
(x1 + deltax / 2, y1 + deltay / 2)]
leg1zy = self._cat3D_geom1zy
delta_vector = self.unit_vector(np.array([(y2 - y1), -(z2 - z1)]))
deltax = polewidth / 2 * delta_vector[0]
deltay = polewidth / 2 * delta_vector[1]
leg1zy.v = [(z1 - deltax / 2, y1 - deltay / 2),
(z2 - deltax, y2 - deltay), (z2 + deltax, y2 + deltay),
(z1 + deltax / 2, y1 + deltay / 2)]
# back of the body
backBody = self._cat3D_geom2
delta_vector = self.unit_vector(np.array([(y3 - y2), -(x3 - x2)]))
deltax = polewidth / 2 * delta_vector[0]
deltay = polewidth / 2 * delta_vector[1]
backBody.v = [(x2 - deltax, y2 - deltay), (x3 - deltax, y3 - deltay),
(x3 + deltax, y3 + deltay), (x2 + deltax, y2 + deltay)]
backBodyzy = self._cat3D_geom2zy
delta_vector = self.unit_vector(np.array([(y3 - y2), -(z3 - z2)]))
deltax = polewidth / 2 * delta_vector[0]
deltay = polewidth / 2 * delta_vector[1]
backBodyzy.v = [(z2 - deltax, y2 - deltay), (z3 - deltax, y3 - deltay),
(z3 + deltax, y3 + deltay), (z2 + deltax, y2 + deltay)]
# front of the body
frontBody = self._cat3D_geom3
delta_vector = self.unit_vector(np.array([(y4 - y3), -(x4 - x3)]))
deltax = polewidth / 2 * delta_vector[0]
deltay = polewidth / 2 * delta_vector[1]
frontBody.v = [(x3 - deltax, y3 - deltay), (x4 - deltax, y4 - deltay),
(x4 + deltax, y4 + deltay), (x3 + deltax, y3 + deltay)]
frontBodyzy = self._cat3D_geom3zy
delta_vector = self.unit_vector(np.array([(y4 - y3), -(z4 - z3)]))
deltax = polewidth / 2 * delta_vector[0]
deltay = polewidth / 2 * delta_vector[1]
frontBodyzy.v = [
(z3 - deltax, y3 - deltay), (z4 - deltax, y4 - deltay),
(z4 + deltax, y4 + deltay), (z3 + deltax, y3 + deltay)
]
# leg 2
leg2 = self._cat3D_geom4
delta_vector = self.unit_vector(np.array([(y5 - y4), -(x5 - x4)]))
deltax = polewidth / 2 * delta_vector[0]
deltay = polewidth / 2 * delta_vector[1]
leg2.v = [(x4 - deltax, y4 - deltay),
(x5 - deltax / 2, y5 - deltay / 2),
(x5 + deltax / 2, y5 + deltay / 2),
(x4 + deltax, y4 + deltay)]
leg2zy = self._cat3D_geom4zy
delta_vector = self.unit_vector(np.array([(y5 - y4), -(z5 - z4)]))
deltax = polewidth / 2 * delta_vector[0]
deltay = polewidth / 2 * delta_vector[1]
leg2zy.v = [(z4 - deltax, y4 - deltay),
(z5 - deltax / 2, y5 - deltay / 2),
(z5 + deltax / 2, y5 + deltay / 2),
(z4 + deltax, y4 + deltay)]
#head
head = self._cat3D_geom5
self.headtrans.set_translation(x4, y4)
headzy = self._cat3D_geom6
self.headtranszy.set_translation(screen_width / 2 + 200 + z4,
floory + y4)
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 = 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.cos(3 * pos))
return self.viewer.render(return_rgb_array=(mode == 'rgb_array'))
def render(self, mode='human'): # , close=False):
''' Gives out relevent information '''
screen_width = 600
screen_height = 400
world_width = self.len_threshold * 2.0
scale = screen_width / world_width
springwidth = 4.0 # 10.0
masswidth = 60.0 # 50.0
massheight = 35.0 # 30.0
mass_y = 100.0
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
# Make mass
l, r, t, b = -masswidth / 2., masswidth / 2., massheight / 2., -massheight / 2.
mass = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
self.masstrans = rendering.Transform(
) # does this allow it to move?
mass.add_attr(self.masstrans)
self.viewer.add_geom(mass)
# Make spring
l, r, t, b = self.minSpring_location, self.defaultPosition, springwidth / 2., -springwidth / 2.
spring = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
spring.set_color(0.8, 0.6, 0.4) # TODO eventually...
self.springtrans = rendering.Transform()
spring.add_attr(self.springtrans)
spring.add_attr(self.masstrans)
self.viewer.add_geom(spring)
# Make Track
self.track = rendering.Line(
(0.0, mass_y - massheight / 2.),
(screen_width, mass_y - massheight / 2.))
self.track.set_color(0.0, 0.0, 1.0) #
self.viewer.add_geom(self.track)
l, r, t, b = (screen_width / 2.0 + self.refInput -
30), (screen_width / 2.0 + self.refInput +
30.), (mass_y - massheight / 2.0 -
2.0), (mass_y - massheight / 2.0 + 2.0)
self.command = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
self.command.set_color(1.0, 0.0, 0.0)
self.viewer.add_geom(self.command)
self._spring_geom = spring # TODO Necessary?
self._command_geom = self.command
if self.state is None: return None
# Update
# Mass
x = self.state[0] # new position
mass_x = x * scale + screen_width / 2.0 # middle of mass
self.masstrans.set_translation(mass_x, mass_y)
l, r, t, b = (screen_width / 2.0 + self.refInput -
30), (screen_width / 2.0 + self.refInput +
30.), (mass_y - massheight / 2.0 -
2.0), (mass_y - massheight / 2.0 + 2.0)
self._command_geom.v = [(l, b), (l, t), (r, t), (r, b)]
# Spring
l, r, t, b = -x, 0.0, springwidth / 2., -springwidth / 2.
self._spring_geom.v = [(l, b), (l, t), (r, t), (r, b)]
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, values=None, mode='human'):
screen_width = 600
screen_height = 600
square_size_height = screen_height / self.n_squares_height
square_size_width = screen_width / self.n_squares_width
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
#add invisible squares for visualising state values
l, r, t, b = -square_size_width / 2, square_size_width / 2, square_size_height / 2, -square_size_height / 2
self.squares = [[
rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
for j in range(0, self.n_squares_width)
] for i in range(0, self.n_squares_height)]
sq_transforms = [[
rendering.Transform() for j in range(0, self.n_squares_width)
] for i in range(0, self.n_squares_height)]
for i in range(0, self.n_squares_height):
for j in range(0, self.n_squares_width):
self.squares[i][j].add_attr(sq_transforms[i][j])
self.viewer.add_geom(self.squares[i][j])
sq_x, sq_y = self.convert_pos_to_xy(
(i, j), (square_size_width, square_size_height))
sq_transforms[i][j].set_translation(sq_x, sq_y)
self.squares[i][j].set_color(1, 1, 1)
#horizontal grid lines
for i in range(1, self.n_squares_height):
track = rendering.Line((0, i * square_size_height),
(screen_width, i * square_size_height))
track.set_color(0, 0, 0)
self.viewer.add_geom(track)
#vertical grid lines
for i in range(1, self.n_squares_width):
track = rendering.Line((i * square_size_width, 0),
(i * square_size_width, screen_height))
track.set_color(0, 0, 0)
self.viewer.add_geom(track)
#the voids
l, r, t, b = -square_size_width / 2, square_size_width / 2, square_size_height / 2, -square_size_height / 2
self.voids = [ rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)]) for i in \
range(np.sum(self.state[self.OBJECT_TO_IDX['void']])) ]
self.voidtrans = [
rendering.Transform() for i in range(len(self.voids))
]
for i in range(len(self.voids)):
self.voids[i].set_color(0, 0, 1)
self.voids[i].add_attr(self.voidtrans[i])
self.viewer.add_geom(self.voids[i])
#the agent
#self.agent = rendering.Image('robo.jpg', width=square_size_width/2, height=square_size_height/2)
l, r, t, b = -square_size_width / 4, square_size_width / 4, square_size_height / 4, -square_size_height / 4
self.agent = rendering.FilledPolygon([(l, b), (l, t), (r, t),
(r, b)])
#self.agent = make_oval(width=square_size_width/2, height=square_size_height/2)
self.agenttrans = rendering.Transform()
self.agent.add_attr(self.agenttrans)
self.viewer.add_geom(self.agent)
#the goal
self.goal = make_oval(width=square_size_width / 4,
height=square_size_height / 4)
self.goal.set_color(1, 0, 1)
self.goaltrans = rendering.Transform()
self.goal.add_attr(self.goaltrans)
self.viewer.add_geom(self.goal)
#the coins
self.coins = [ make_oval(width=square_size_width/4, height=square_size_height/4) for i in \
range(np.sum(self.state[self.OBJECT_TO_IDX['coin']])) ]
self.cointrans = [
rendering.Transform() for i in range(len(self.coins))
]
for i in range(len(self.coins)):
self.coins[i].set_color(1, 1, 0)
self.coins[i].add_attr(self.cointrans[i])
self.viewer.add_geom(self.coins[i])
#the thorns
l, r, t, b = -square_size_width / 4, square_size_width / 4, square_size_height / 3, -square_size_height / 3
self.thorns = [ rendering.FilledPolygon([(l,b), (0,t), (r,b)]) for i in \
range(np.sum(self.state[self.OBJECT_TO_IDX['thorns']])) ]
self.thornstrans = [
rendering.Transform() for i in range(len(self.thorns))
]
for i in range(len(self.thorns)):
self.thorns[i].set_color(1, 0, 0)
self.thorns[i].add_attr(self.thornstrans[i])
self.viewer.add_geom(self.thorns[i])
#the leftarrows
x1, x2, x3 = -0.35 * square_size_width, -0.1 * square_size_width, 0.3 * square_size_width
y1, y2, y3, y4, y5 = -0.14*square_size_height, -0.03*square_size_height, 0,\
0.03*square_size_height, 0.14*square_size_height
self.leftarrows = [rendering.FilledPolygon([(x1,y3),(x2,y5),(x2,y4),(x3,y4),(x3,y2),(x2,y2),(x2,y1)]) for i in \
range(np.sum(self.state[self.OBJECT_TO_IDX['arrow']]==1))]
self.leftarrowtrans = [
rendering.Transform() for i in range(len(self.leftarrows))
]
for i in range(len(self.leftarrows)):
self.leftarrows[i].set_color(0, 0, 0)
self.leftarrows[i].add_attr(self.leftarrowtrans[i])
self.viewer.add_geom(self.leftarrows[i])
#the rightarrows
x1, x2, x3 = -0.3 * square_size_width, 0.1 * square_size_width, 0.35 * square_size_width
y1, y2, y3, y4, y5 = -0.14*square_size_height, -0.03*square_size_height, 0,\
0.03*square_size_height, 0.14*square_size_height
self.rightarrows = [rendering.FilledPolygon([(x2,y2),(x1,y2),(x1,y4),(x2,y4),(x2,y5),(x3,y3),(x2,y1)]) for i in \
range(np.sum(self.state[self.OBJECT_TO_IDX['arrow']]==2))]
self.rightarrowtrans = [
rendering.Transform() for i in range(len(self.rightarrows))
]
for i in range(len(self.rightarrows)):
self.rightarrows[i].set_color(0, 0, 0)
self.rightarrows[i].add_attr(self.rightarrowtrans[i])
self.viewer.add_geom(self.rightarrows[i])
#the uparrows
x1, x2, x3, x4, x5 = -0.14*square_size_height, -0.03*square_size_height, 0,\
0.03*square_size_height, 0.14*square_size_height
y1, y2, y3 = -0.3 * square_size_width, 0.1 * square_size_width, 0.35 * square_size_width
self.uparrows = [rendering.FilledPolygon([(x2,y2),(x1,y2),(x3,y3),(x5,y2),(x4,y2),(x4,y1),(x2,y1)]) for i in \
range(np.sum(self.state[self.OBJECT_TO_IDX['arrow']]==3))]
self.uparrowtrans = [
rendering.Transform() for i in range(len(self.uparrows))
]
for i in range(len(self.uparrows)):
self.uparrows[i].set_color(0, 0, 0)
self.uparrows[i].add_attr(self.uparrowtrans[i])
self.viewer.add_geom(self.uparrows[i])
#the downarrows
x1, x2, x3, x4, x5 = -0.14*square_size_height, -0.03*square_size_height, 0,\
0.03*square_size_height, 0.14*square_size_height
y1, y2, y3 = -0.35 * square_size_width, -0.1 * square_size_width, 0.3 * square_size_width
self.downarrows = [rendering.FilledPolygon([(x3,y1),(x1,y2),(x2,y2),(x2,y3),(x4,y3),(x4,y2),(x5,y2)]) for i in \
range(np.sum(self.state[self.OBJECT_TO_IDX['arrow']]==4))]
self.downarrowtrans = [
rendering.Transform() for i in range(len(self.downarrows))
]
for i in range(len(self.downarrows)):
self.downarrows[i].set_color(0, 0, 0)
self.downarrows[i].add_attr(self.downarrowtrans[i])
self.viewer.add_geom(self.downarrows[i])
if self.state is None: return
goal_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['goal']] == 1)))[0]
void_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['void']] == 1)))
agent_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['agent']] == 1)))[0]
coin_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['coin']] != 0)))
thorns_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['thorns']] == 1)))
leftarrow_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['arrow']] == 1)))
rightarrow_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['arrow']] == 2)))
uparrow_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['arrow']] == 3)))
downarrow_pos = list(
zip(*np.where(self.state[self.OBJECT_TO_IDX['arrow']] == 4)))
goal_x, goal_y = self.convert_pos_to_xy(
goal_pos, (square_size_width, square_size_height))
self.goaltrans.set_translation(goal_x, goal_y)
for i in range(len(self.voids)):
void_x, void_y = self.convert_pos_to_xy(
void_pos[i], (square_size_width, square_size_height))
self.voidtrans[i].set_translation(void_x, void_y)
agent_x, agent_y = self.convert_pos_to_xy(
agent_pos, (square_size_width, square_size_height))
self.agenttrans.set_translation(agent_x, agent_y)
for i in range(len(self.coins)):
if coin_pos[
i] == agent_pos: #making sure there are no white disks on top of the agent
self.coins[i].set_color(0, 0, 0)
elif self.state[self.OBJECT_TO_IDX['coin']][coin_pos[i]] == -1:
self.coins[i].set_color(1, 1, 1)
else:
self.coins[i].set_color(1, 1, 0)
coin_x, coin_y = self.convert_pos_to_xy(
coin_pos[i], (square_size_width, square_size_height))
self.cointrans[i].set_translation(coin_x, coin_y)
for i in range(len(self.thorns)):
thorns_x, thorns_y = self.convert_pos_to_xy(
thorns_pos[i], (square_size_width, square_size_height))
self.thornstrans[i].set_translation(thorns_x, thorns_y)
for i in range(len(self.leftarrows)):
leftarrow_x, leftarrow_y = self.convert_pos_to_xy(
leftarrow_pos[i], (square_size_width, square_size_height))
self.leftarrowtrans[i].set_translation(leftarrow_x, leftarrow_y)
for i in range(len(self.rightarrows)):
rightarrow_x, rightarrow_y = self.convert_pos_to_xy(
rightarrow_pos[i], (square_size_width, square_size_height))
self.rightarrowtrans[i].set_translation(rightarrow_x, rightarrow_y)
for i in range(len(self.uparrows)):
uparrow_x, uparrow_y = self.convert_pos_to_xy(
uparrow_pos[i], (square_size_width, square_size_height))
self.uparrowtrans[i].set_translation(uparrow_x, uparrow_y)
for i in range(len(self.downarrows)):
downarrow_x, downarrow_y = self.convert_pos_to_xy(
downarrow_pos[i], (square_size_width, square_size_height))
self.downarrowtrans[i].set_translation(downarrow_x, downarrow_y)
if values is not None:
maxval, minval = values.max(), values.min()
rng = maxval - minval
for i, row in enumerate(values):
for j, val in enumerate(row):
if rng == 0: col = 1
else: col = (maxval - val) / rng
self.squares[i][j].set_color(col, 1, col)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human', **kwargs):
screen_width = 600
screen_height = 600
world_width = 2 * X
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(-X, X, 100) - X
ys = np.linspace(-Y, Y, 100) - Y - 5
x_scaled = X * scale
y_scaled = Y * scale
ones_x = np.ones_like(xs)
ones_y = np.ones_like(ys)
lines = [
list(zip((xs) * scale, 2 * Y * scale * ones_x)),
list(zip((xs) * scale, 0 * ones_x)),
list(zip(2 * X * scale * ones_y, (ys) * scale)),
list(zip(0 * ones_y, (ys) * scale))
]
for line in lines:
xys = line
track = rendering.make_polyline(xys)
track.set_linewidth(4)
track.set_color(0, .5, 0)
self.viewer.add_geom(track)
# clearance = 10
agent_size = 5
agent = rendering.make_circle(agent_size, filled=True)
self.agenttrans = rendering.Transform(
translation=(0, 0)) # translation = (dx,dy)ずらす
agent.add_attr(self.agenttrans)
agent.set_color(.9, .5, .5)
self.viewer.add_geom(agent)
horizontal_line = rendering.Line((0, y_scaled),
(2 * x_scaled, y_scaled))
self.viewer.add_geom(horizontal_line)
for i in range(20):
pos_x = i * scale
line_length = 3 if i % 2 == 0 else 1
flagpole = rendering.Line((pos_x, y_scaled - line_length),
(pos_x, y_scaled + line_length))
self.viewer.add_geom(flagpole)
"""
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)
"""
flag_size = 7
flag = rendering.make_circle(flag_size, filled=True)
self.flagtrans = rendering.Transform(
translation=(0, 0)) # translation = (dx,dy)ずらす
flag.add_attr(self.flagtrans)
flag.set_color(.5, .9, .9)
self.viewer.add_geom(flag)
"""
self.flagtrans = rendering.Transform(
)
flagx = (self.GOAL[0]+X)*scale
print(self.GOAL)
flagy1 = (self.GOAL[1] + Y) * scale
flagy2 = flagy1 + 20
flagpole = rendering.Line((flagx, flagy1), (flagx, flagy2))
flagpole.add_attr(rendering.Transform(translation=(0, 0.1)))
flagpole.add_attr(self.flagtrans)
self.viewer.add_geom(flagpole)
flag = rendering.FilledPolygon(
[(flagx, flagy2), (flagx, flagy2-8), (flagx+20, flagy2-4)])
flag.set_color(.8, .8, 0)
flag.add_attr(self.flagtrans)
self.viewer.add_geom(flag)
"""
pos = self.state
self.flagtrans.set_translation((self.GOAL[0] + X) * scale,
(self.GOAL[1] + Y) * scale)
self.agenttrans.set_translation((pos[0] + X) * scale,
(pos[1] + Y) * scale)
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.x_threshold*2
scale = screen_width/world_width
carty = 100 # TOP OF CART
polewidth = 10.0
polelen = scale * 1.0
cartwidth = 50.0
cartheight = 30.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
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 = -polewidth/2,polewidth/2,polelen-polewidth/2,-polewidth/2
pole = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)])
pole.set_color(.8,.6,.4)
self.poletrans = rendering.Transform(translation=(0, axleoffset))
pole.add_attr(self.poletrans)
pole.add_attr(self.carttrans)
self.viewer.add_geom(pole)
l,r,t,b = -1,1,50,-50
vect = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)])
vect.set_color(1,0,0)
self.vecttrans = rendering.Transform(translation=(0.2*screen_width, 0.8*screen_height))
vect.add_attr(self.vecttrans)
self.viewer.add_geom(vect)
self.axle = rendering.make_circle(polewidth/2)
self.axle.add_attr(self.poletrans)
self.axle.add_attr(self.carttrans)
self.axle.set_color(.5,.5,.8)
self.viewer.add_geom(self.axle)
self.track = rendering.Line((0,carty), (screen_width,carty))
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.vecttrans.set_rotation(self.alpha)
return self.viewer.render(return_rgb_array = mode=='rgb_array')
def render(self, state_action_list, mode='human'):
action_dict = {0: "nothing", 1: "left", 2: "right"}
screen_width = 600
screen_height = 600
carty = screen_height / 2
cartwidth = screen_width/8#50.0
cartheight = 0.6 * cartwidth#30.0
polewidth = cartwidth/5
polelen = (3.2)*cartheight
wallwidth = polewidth
wallheight = screen_height
viewer = rendering.Viewer(screen_width, screen_height)
scale = (screen_width/2 - 2*cartwidth/2 - wallwidth)/self.x_threshold
l,r,t,b = -wallwidth/2, wallwidth/2, wallheight/2, -wallheight/2
wall = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)])
gray = 100/255
wall.set_color(gray, gray, gray)
walltrans = rendering.Transform()
walltrans.set_translation(self.x_threshold*scale +wallwidth/2 + cartwidth/2 + screen_width/2.0, carty)
wall.add_attr(walltrans)
viewer.add_geom(wall)
owall = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)])
owall.set_color(gray, gray, gray)
owalltrans = rendering.Transform()
owalltrans.set_translation(-self.x_threshold*scale -wallwidth/2 - cartwidth/2 + screen_width/2.0, carty)
owall.add_attr(owalltrans)
viewer.add_geom(owall)
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)])
carttrans = rendering.Transform()
cart.add_attr(carttrans)
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(.8,.6,.4)
poletrans = rendering.Transform(translation=(0, axleoffset))
pole.add_attr(poletrans)
pole.add_attr(carttrans)
viewer.add_geom(pole)
axle = rendering.make_circle(polewidth/2)
axle.add_attr(poletrans)
axle.add_attr(carttrans)
axle.set_color(.5,.5,.8)
viewer.add_geom(axle)
right_arrow_points = [(0, 0), (-2, 1), (-2, 0.5), (-6, 0.5),
(-6, -0.5), (-2, -0.5), (-2, -1), (0, 0)]
right_arrow_points = [(screen_width / 2 - cartwidth / 2 + cartwidth/8 * x,
carty + cartheight / 2 + cartwidth/8 * y)
for (x, y) in right_arrow_points]
right_arrow = rendering.FilledPolygon(right_arrow_points)
right_arrow.set_color(0, 0, 0)
right_arrow_trans = rendering.Transform()
right_arrow.add_attr(right_arrow_trans)
left_arrow_points = [(0, 0), (2, 1), (2, 0.5), (6, 0.5),
(6, -0.5), (2, -0.5), (2, -1), (0, 0)]
left_arrow_points = [(screen_width / 2 + cartwidth / 2 + cartwidth/8 * x,
carty + cartheight / 2 + cartwidth/8 * y)
for (x, y) in left_arrow_points]
left_arrow = rendering.FilledPolygon(left_arrow_points)
left_arrow.set_color(0, 0, 0)
left_arrow_trans = rendering.Transform()
left_arrow.add_attr(left_arrow_trans)
track = rendering.Line((-self.x_threshold*scale - cartwidth/2 + screen_width/2.0,carty),
(self.x_threshold*scale + cartwidth/2 + screen_width/2.0,carty))
track.set_color(0,0,0)
viewer.add_geom(track)
frames = []
for state, action in state_action_list:
x, x_dot, theta, theta_dot = state
print(x)
cartx = x*scale + screen_width/2.0 # MIDDLE OF CART
carttrans.set_translation(cartx, carty)
poletrans.set_rotation(-theta)
if action_dict[action] == "right":
right_arrow_trans.set_translation(x*scale, 0)
viewer.add_onetime(right_arrow)
if action_dict[action] == "left":
left_arrow_trans.set_translation(x*scale, 0)
viewer.add_onetime(left_arrow)
frames.append(viewer.render(return_rgb_array = mode=='rgb_array'))
viewer.close()
return np.array(frames).astype(np.uint8)
