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
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
agent = rendering.make_circle(
min(screen_height, screen_width) * 0.03)
origin = rendering.make_circle(
min(screen_height, screen_width) * 0.03)
trans = rendering.Transform(translation=(0, 0))
agent.add_attr(trans)
self.trans = trans
agent.set_color(1, 0, 0)
origin.set_color(0, 0, 0)
origin.add_attr(rendering.Transform(
translation=(screen_width // 2, screen_height // 2)))
self.viewer.add_geom(agent)
self.viewer.add_geom(origin)
# self.trans.set_translation(0, 0)
self.trans.set_translation(
(self.state[0] + 1) / 2 * screen_width,
(self.state[1] + 1) / 2 * 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
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):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(self.XMIN, self.XMAX, self.YMIN, self.YMAX)
self.goal.shape = rendering.make_circle(self.goal.r)
self.goal.shape.set_color(0.5, 1, 0.5)
self.goal.transform = rendering.Transform()
self.goal.shape.add_attr(self.goal.transform)
self.viewer.add_geom(self.goal.shape)
for obstacle in self.obstacles:
obstacle.shape = rendering.make_circle(obstacle.r)
obstacle.shape.set_color(0, 0, 0)
obstacle.transform = rendering.Transform()
obstacle.shape.add_attr(obstacle.transform)
self.viewer.add_geom(obstacle.shape)
self.quad.shape = rendering.make_circle(self.quad.r)
self.quad.shape.set_color(0, 0, 1)
self.quad.transform = rendering.Transform()
self.quad.shape.add_attr(self.quad.transform)
self.viewer.add_geom(self.quad.shape)
self.accel_shape = rendering.make_capsule(1.0, 0.3)
self.accel_shape.set_color(1, 0, 0)
self.accel_shape_transform = rendering.Transform()
self.accel_shape.add_attr(self.accel_shape_transform)
self.viewer.add_geom(self.accel_shape)
self.quad.transform.set_translation(self.quad.x, self.quad.y)
self.goal.transform.set_translation(self.goal.x, self.goal.y)
for obstacle in self.obstacles:
obstacle.transform.set_translation(*obstacle.state())
if self.last_u is not None:
ux, uy = self.last_u
u_mag = np.sqrt(ux**2 + uy**2)
self.accel_shape_transform.set_translation(self.quad.x, self.quad.y)
self.accel_shape_transform.set_scale(u_mag, 1.0)
self.accel_shape_transform.set_rotation(math.atan2(uy, ux))
self.viewer.render()
if mode == 'rgb_array':
return self.viewer.get_array()
elif mode == 'human':
pass
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
return
screen_width = 400
screen_height = 400
world_width = self.max_position - self.min_position
scale = screen_width/world_width
carwidth=20
carheight=20
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
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)
pos_x = self.state[0]
pos_y = 0
self.cartrans.set_translation((pos_x-self.min_position)*scale, (pos_y-self.min_position)*scale)
self.viewer.render()
if mode == 'rgb_array':
return self.viewer.get_array()
elif mode is 'human':
pass
else:
return super(PointEnv, self).render(mode=mode)
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500,500)
self.viewer.set_bounds(-2.2,2.2,-2.2,2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0,0,0)
self.viewer.add_geom(axle)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0] + np.pi/2)
if self.last_u:
self.imgtrans.scale = (-self.last_u/2, np.abs(self.last_u)/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 = 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)
#创建摆杆和台车之间的连接
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):
obs = self._gen_observation()
for i in range(obs.shape[0]):
s = ''
for j in range(obs.shape[1]):
z = int(obs[i, j, 0] + 2 * obs[i, j, 1] + 4 * obs[i, j, 2])
s += str(z)
print(s)
print('========')
# print(self.state, (self.x, self.y))
return 'CONCON'
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)
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)
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 = 600
screen_height = 400
world_width = 2e+08
scale = screen_width / world_width
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height, display=self.display)
earth = rendering.make_circle(radius=scale * 6.357e+06, filled=True)
earth_trans = rendering.Transform(translation=(screen_width / 2, screen_height / 2))
earth.set_color(.1,.1,.8)
earth.add_attr(earth_trans)
satellite = rendering.make_circle(radius=scale * 6.357e+05, filled=True)
satellite.set_color(.8,.6,.4)
self.satellite_trans = rendering.Transform()
satellite.add_attr(self.satellite_trans)
orbit = rendering.make_circle(radius=scale * self.vm_output[0x4], filled=False)
orbit_trans = rendering.Transform(translation=(screen_width / 2, screen_height / 2))
orbit.add_attr(orbit_trans)
self.viewer.add_geom(orbit)
self.viewer.add_geom(earth)
self.viewer.add_geom(satellite)
x, y = self.vm_output[0x2], self.vm_output[0x3]
satx = x * scale + screen_width / 2.0
saty = y * scale + screen_height / 2.0
self.satellite_trans.set_translation(satx, saty)
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 = 2 * self.l_max_threshold# * np.sin(self.theta_threshold)
scale = screen_width/world_width
cable_pin = screen_height - 10
payload_size = 10.0
cable_width = 2.0
theta, theta_dot, l, l_dot = self.state
if self.viewer is None:
self.l_init = l # save the initial length for scaling cable
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
# 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, -l*scale-cable_width/2
self.cable = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)])
self.cabletrans = rendering.Transform(translation=(screen_width/2, cable_pin))
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, cable_pin-l*scale))
self.payload.add_attr(self.payloadtrans)
self.payload.set_color(0.5,0.5,0.5) # mid gray
self.viewer.add_geom(self.payload)
if self.state is None:
return None
# calculate the payload position in the window, then move it there
payload_screen_x = screen_width/2 + l*np.sin(theta)*scale
payload_screen_y = cable_pin - l*np.cos(theta)*scale
self.payloadtrans.set_translation(payload_screen_x, payload_screen_y)
# rotate the cable
self.cabletrans.set_rotation(theta)
# change its length by scaling its length relative to its initial length
self.cabletrans.set_scale(1, l/self.l_init)
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
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)
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)
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.viewer.render()
if mode == 'rgb_array':
return self.viewer.get_array()
elif mode is 'human':
pass
else:
return super(CartPoleEnv, self).render(mode=mode)
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(.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)
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()
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 _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.window_size,self.window_size)
#self.viewer.set_bounds(0,self.field_length,0,self.field_length)
self.ball_transform = rendering.Transform()
self.target_transform = rendering.Transform()
target = rendering.make_circle(self.scale)
target.set_color(0,1,0)
target.add_attr(self.target_transform)
ball = rendering.make_circle(self.scale)
ball.set_color(1,0,0)
ball.add_attr(self.ball_transform)
self.viewer.add_geom(ball)
self.viewer.add_geom(target)
#fname = path.join(path.dirname(__file__), "assets/clockwise.png")
#self.img = rendering.Image(fname, 1., 1.)
#self.imgtrans = rendering.Transform()
#self.img.add_attr(self.imgtrans)
#self.viewer.add_onetime(self.img)
self.target_transform.set_translation(
int(self.scale*self.state[2]),
int(self.scale*self.state[3]))
self.ball_transform.set_translation(
int(self.scale*self.state[0]),
int(self.scale*self.state[1]))
#if self.last_u:
# self.imgtrans.scale = (-self.last_u/2, np.abs(self.last_u)/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 = 600
screen_height = 400
world_width = (self.max_pos * 2) * 2
scale = screen_width / world_width
bally = 100
ballradius = 3
if self.viewer is None:
clearance = 0 # y-offset
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
mass = rendering.make_circle(ballradius * 2)
mass.set_color(.8, .3, .3)
mass.add_attr(rendering.Transform(translation=(0, clearance)))
self.masstrans = rendering.Transform()
mass.add_attr(self.masstrans)
self.viewer.add_geom(mass)
self.track = rendering.Line((0, bally), (screen_width, bally))
self.track.set_color(0.5, 0.5, 0.5)
self.viewer.add_geom(self.track)
zero_line = rendering.Line((screen_width / 2, 0),
(screen_width / 2, screen_height))
zero_line.set_color(0.5, 0.5, 0.5)
self.viewer.add_geom(zero_line)
x = self.state[0]
ballx = x * scale + screen_width / 2.0
self.masstrans.set_translation(ballx, bally)
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: from gym.envs.classic_control import rendering self.viewer = rendering.Viewer(700,700) self.viewer.set_bounds(-80, 80, -80, 80) # left wall left_wall = rendering.make_capsule(self.max_x*2,1) left_wall.set_color(0.5,0.3,0.3) left_wall_transform = rendering.Transform() left_wall.add_attr(left_wall_transform) self.viewer.add_geom(left_wall) left_wall_transform.set_rotation(np.pi/2) left_wall_transform.set_translation(-self.max_y,-self.max_x) # right wall right_wall = rendering.make_capsule(self.max_x*2,1) right_wall.set_color(0.5,0.3,0.3) right_wall_transform = rendering.Transform() right_wall.add_attr(right_wall_transform) self.viewer.add_geom(right_wall) right_wall_transform.set_rotation(np.pi/2) right_wall_transform.set_translation(self.max_y,-self.max_x) # upper wall (puck's side) upper_wall = rendering.make_capsule(self.max_y*2,1) upper_wall.set_color(0.5,0.3,0.3) upper_wall_transform = rendering.Transform() upper_wall.add_attr(upper_wall_transform) self.viewer.add_geom(upper_wall) upper_wall_transform.set_translation(-self.max_y,-self.max_x) # upper goal upper_goal = rendering.make_capsule(self.goal_len,1) upper_goal.set_color(1.,1.,1.) upper_goal_transform = rendering.Transform() upper_goal.add_attr(upper_goal_transform) self.viewer.add_geom(upper_goal) upper_goal_transform.set_translation(-self.goal_len/2., -self.max_x) # lower wall (agent's side) lower_wall = rendering.make_capsule(self.max_y*2,1) lower_wall.set_color(0.5,0.3,0.3) lower_wall_transform = rendering.Transform() lower_wall.add_attr(lower_wall_transform) self.viewer.add_geom(lower_wall) lower_wall_transform.set_translation(-self.max_y,self.max_x) # lower goal lower_goal = rendering.make_capsule(self.goal_len,1) lower_goal.set_color(1.,1.,1.) lower_goal_transform = rendering.Transform() lower_goal.add_attr(lower_goal_transform) self.viewer.add_geom(lower_goal) lower_goal_transform.set_translation(-self.goal_len/2., self.max_x) # middle line middle_line = rendering.make_capsule(self.max_y*2,1) middle_line.set_color(0.1,0.3,0.3) middle_line_transform = rendering.Transform() middle_line.add_attr(middle_line_transform) self.viewer.add_geom(middle_line) middle_line_transform.set_translation(-self.max_y,0.) middle_circle_big = rendering.make_circle(self.puckR+0.2) middle_circle_big.set_color(0.1,0.3,0.3) middle_circle_big_transform = rendering.Transform() middle_circle_big.add_attr(middle_circle_big_transform) self.viewer.add_geom(middle_circle_big) middle_circle_big_transform.set_translation(0.,0.) middle_circle_small = rendering.make_circle(self.puckR-0.5) middle_circle_small.set_color(1.,1.,1.) middle_circle_small_transform = rendering.Transform() middle_circle_small.add_attr(middle_circle_small_transform) self.viewer.add_geom(middle_circle_small) middle_circle_small_transform.set_translation(0.,0.) # objects puck = rendering.make_circle(self.puckR) puck.set_color=(.8,.3,.3) self.puck_transform = rendering.Transform() puck.add_attr(self.puck_transform) self.viewer.add_geom(puck) agent = rendering.make_circle(self.agentR) agent.set_color(.6,.3,.3) self.agent_transform = rendering.Transform() agent.add_attr(self.agent_transform) self.viewer.add_geom(agent) self.puck_transform.set_translation(self.state[5],self.state[4]) self.agent_transform.set_translation(self.state[1],self.state[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 = 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 __init__(self, sheepObject):
self.object = sheepObject
self.body = Part(rendering.make_circle(self.object.radius, res=50))
self.body.set_color(181 / 255, 185 / 255, 215 / 255)
def render(self, mode='human'):
"""
Obsolete rendering platform, for debugging purposes.
To render simulation, start bluesky --client and connect to running server.
"""
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
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', 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
# 如果还没有设定屏幕对象，则初始化整个屏幕具备的元素。
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, 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, 0.15 * rad),
(rad, 0),
(0.7 * rad, -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)
a = self.action
if a in [0, 1, 2, 3]:
# 根据action绘制箭头
degree = 0
if a == 0:
degree = 180
elif a == 1:
degree = 0
elif a == 2:
degree = 90
else:
degree = 270
self.line_trans.set_translation(ppx * scale, ppy * scale)
self.line_trans.set_rotation(degree / RAD2DEG)
# self.line.set_color(0,0,0)
self.arrow.set_color(0, 0, 0)
else:
# self.line.set_color(r,g,b)
self.arrow.set_color(r, g, b)
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[1]*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[1]*scale)
#self.objtrans.set_translation(100, 200)
return self.viewer.render(return_rgb_array = mode=='rgb_array')
def render(self, mode='human'):
_, h, m = self._observation()
if self.viewer is None:
from gym.envs.classic_control import rendering
y = self._r.H_MAX_RENDER
y0 = self._r.H0
GY = (y - y0) / 20
Y = y - y0 + GY
H = Y / 10
W = H / 10
self.flame_offset = W / 2
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(left=-Y / 2,
right=Y / 2,
bottom=y - Y,
top=y)
ground = rendering.make_polygon([(-Y / 2, y0 - GY), (-Y / 2, y0),
(Y / 2, y0), (Y / 2, y0 - GY)])
ground.set_color(.3, .6, .3)
pad = rendering.make_polygon([(-3 * W, y0 - GY / 3), (-3 * W, y0),
(3 * W, y0), (3 * W, y0 - GY / 3)])
pad.set_color(.6, .6, .6)
rocket = rendering.make_polygon([(-W / 2, 0), (-W / 2, H),
(W / 2, H), (W / 2, 0)],
filled=True)
rocket.set_color(0, 0, 0)
self.r_trans = rendering.Transform()
rocket.add_attr(self.r_trans)
self.make_fuel_poly = lambda mass: [(-W / 2, 0),
(-W / 2, H *
((mass - self._r.M1) /
(self._r.M0 - self._r.M1))),
(W / 2, H *
((mass - self._r.M1) /
(self._r.M0 - self._r.M1))),
(W / 2, 0)]
self.fuel = rendering.make_polygon(self.make_fuel_poly(m),
filled=True)
self.fuel.set_color(.8, .1, .14)
self.fuel.add_attr(self.r_trans)
flame = rendering.make_circle(radius=W, res=30)
flame.set_color(.96, 0.85, 0.35)
self.f_trans = rendering.Transform()
flame.add_attr(self.f_trans)
flame_outer = rendering.make_circle(radius=2 * W, res=30)
flame_outer.set_color(.95, 0.5, 0.2)
self.fo_trans = rendering.Transform()
flame_outer.add_attr(self.fo_trans)
for g in [ground, pad, rocket, self.fuel, flame_outer, flame]:
self.viewer.add_geom(g)
self.r_trans.set_translation(newx=0, newy=h)
self.f_trans.set_translation(newx=0, newy=h)
self.fo_trans.set_translation(newx=0, newy=h - self.flame_offset)
self.fuel.v = self.make_fuel_poly(m)
s = 0 if self._thrust_last is None else self._thrust_last / self._r.THRUST_MAX
self.f_trans.set_scale(newx=s, newy=s)
self.fo_trans.set_scale(newx=s, newy=s)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
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)
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)
driver = rendering.make_circle(carheight / 2.5)
driver.set_color(.8, .8, 0)
driver.add_attr(
rendering.Transform(translation=(-carwidth / 4,
clearance + 10)))
driver.add_attr(self.cartrans)
self.viewer.add_geom(driver)
z, x, c, v = l / 3, r / 3, t / 3, b / 3
topfront_wheel = rendering.FilledPolygon([(z, v), (z, c), (x, c),
(x, v)])
topfront_wheel.set_color(.5, .5, .5)
topfront_wheel.add_attr(
rendering.Transform(translation=(carwidth / 4,
clearance + carwidth / 2)))
topfront_wheel.add_attr(self.cartrans)
self.viewer.add_geom(topfront_wheel)
toprear_wheel = rendering.FilledPolygon([(z, v), (z, c), (x, c),
(x, v)])
toprear_wheel.set_color(.5, .5, .5)
toprear_wheel.add_attr(
rendering.Transform(translation=(-carwidth / 4 - 3,
clearance + carwidth / 2)))
toprear_wheel.add_attr(self.cartrans)
self.viewer.add_geom(toprear_wheel)
bottomrear_wheel = rendering.FilledPolygon([(z, v), (z, c), (x, c),
(x, v)])
bottomrear_wheel.add_attr(
rendering.Transform(translation=(-carwidth / 4 - 3,
clearance - 6)))
bottomrear_wheel.add_attr(self.cartrans)
bottomrear_wheel.set_color(.5, .5, .5)
self.viewer.add_geom(bottomrear_wheel)
bottomfront_wheel = rendering.FilledPolygon([(z, v), (z, c),
(x, c), (x, v)])
bottomfront_wheel.add_attr(
rendering.Transform(translation=(carwidth / 4, clearance - 6)))
bottomfront_wheel.add_attr(self.cartrans)
bottomfront_wheel.set_color(.5, .5, .5)
self.viewer.add_geom(bottomfront_wheel)
flagx = (self.goal_position - self.min_position) * scale
flagy1 = self._height(self.goal_position) * scale
flagy2 = flagy1 + 50
flagpole = rendering.Line((flagx, flagy1 + 15), (flagx, flagy2))
self.viewer.add_geom(flagpole)
flag = rendering.FilledPolygon([(flagx, flagy2),
(flagx, flagy2 - 10),
(flagx + 25, flagy2 - 5)])
flag.set_color(.8, .3, 0)
self.viewer.add_geom(flag)
road_top = rendering.Line(
(self.min_position * scale, self.max_position_y * scale),
(self.max_position * scale * 3, self.max_position_y * scale))
self.viewer.add_geom(road_top)
road_bot = rendering.Line(
(self.min_position * scale, self.min_position_y * scale),
(self.max_position * scale * 3, self.min_position_y * scale))
self.viewer.add_geom(road_bot)
pos_x = self.state[0]
pos_y = self.state[1]
vel = self.state[2]
theta = self.state[3]
self.cartrans.set_translation((pos_x - self.min_position) * scale,
pos_y * scale)
self.cartrans.set_rotation(theta)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 500
screen_height = 300
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)])
if self.get_reward() == 0:
cart.set_color(0., 0., 0.)
else:
cart.set_color(0., .0, 1.)
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'):
from gym.envs.classic_control import rendering
# screen_width = 1000
# screen_height = 1000
# # 如果没有viewer，创建viewer和uav、landmarks
# if self.viewer is None:
# self.viewer = rendering.Viewer(screen_height, screen_width)
# # 保存service关联直线
# self.services_count = 0
# self.render_landmarks = []
# self.render_landmarks_tranform = []
# for landmark in self.world.landmarks.values():
# geom = rendering.make_circle(landmark.size)
# geom_transform = rendering.Transform(translation=(landmark.state.pos[0], landmark.state.pos[1]))
# geom.set_color(0, 1, 0)
# geom.add_attr(geom_transform)
# self.render_landmarks.append(geom)
# self.render_landmarks_tranform.append(geom_transform)
# self.viewer.add_geom(geom)
# self.render_geom = []
# self.render_tranform = []
# for uav in self.world.UAVs:
# geom = rendering.make_circle(uav.size)
# form = rendering.Transform()
# geom.set_color(1, 0, 0)
# geom.add_attr(form)
# self.render_geom.append(geom)
# self.render_tranform.append(form)
# self.viewer.add_geom(geom)
# self.viewer.set_bounds(0, 1000, 0, 1000)
# # 刷新landmark位置
# for i, landmark in enumerate(self.world.landmarks.values()):
# self.render_landmarks_tranform[i].set_translation(*landmark.state.pos)
# # 刷新uav位置
# for i, uav in enumerate(self.world.UAVs):
# self.render_tranform[i].set_translation(*uav.state.pos)
# # 消除上个时间片的用户服务关联
# for i in range(self.services_count):
# self.viewer.geoms.pop(-1-i)
# self.services_count = 0
# # 刷新uav和landmark之间的关联
# for uav in self.world.UAVs:
# print(uav.associator)
# for i in uav.associator:
# line = rendering.Line(uav.state.pos, self.world.landmarks[str(i)].state.pos)
# self.viewer.add_geom(line)
# self.services_count += 1
# 新代码 不适用tranform，直接刷新全局组件
screen_width = Range
screen_height = Range
# 如果没有viewer，创建viewer和uav、landmarks
if self.viewer is None:
self.viewer = rendering.Viewer(screen_height, screen_width)
self.viewer.set_bounds(0, Range, 0, Range)
self.viewer.geoms.clear()
for uav in self.world.UAVs:
geom = rendering.make_circle(uav.size)
geom.set_color(1, 0, 0)
geom_form = rendering.Transform(translation=(uav.state.pos[0],
uav.state.pos[1]))
geom.add_attr(geom_form)
self.viewer.add_geom(geom)
for landmark in self.world.landmarks.values():
geom = rendering.make_circle(landmark.size)
geom.set_color(0, 1, 0)
geom_transform = rendering.Transform(
translation=(landmark.state.pos[0], landmark.state.pos[1]))
geom.add_attr(geom_transform)
self.viewer.add_geom(geom)
for uav in self.world.UAVs:
for i in uav.associator:
line = rendering.Line(uav.state.pos,
self.world.landmarks[str(i)].state.pos)
self.viewer.add_geom(line)
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', close=False):
from gym.envs.classic_control import rendering
screen_width = 110
screen_height = 110
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
self.line1 = rendering.Line((5, 5), (5, 105))
self.line2 = rendering.Line((5, 5), (105, 5))
self.line3 = rendering.Line((105, 5), (105, 105))
self.line4 = rendering.Line((105, 105), (5, 105))
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.obstacle1 = rendering.make_circle(15, 120)
self.obs1trans = rendering.Transform(translation=(85, 25))
self.obstacle1.add_attr(self.obs1trans)
self.viewer.add_geom(self.obstacle1)
self.obstacle2 = rendering.make_circle(20, 160)
self.obs2trans = rendering.Transform(translation=(30, 30))
self.obstacle2.add_attr(self.obs2trans)
self.viewer.add_geom(self.obstacle2)
self.pursuer1 = rendering.make_circle(1)
self.p1trans = rendering.Transform()
self.pursuer1.add_attr(self.p1trans)
self.pursuer1.set_color(0, 1, 0)
self.pursuer1_capture = rendering.make_circle(2, 30, filled=False)
self.p1ctrans = rendering.Transform()
self.pursuer1_capture.add_attr(self.p1ctrans)
self.pursuer1_capture.set_color(0, 1, 0)
self.pursuer2 = rendering.make_circle(1)
self.p2trans = rendering.Transform()
self.pursuer2.add_attr(self.p2trans)
self.pursuer2.set_color(0, 1, 0)
self.pursuer2_capture = rendering.make_circle(2, 30, filled=False)
self.p2ctrans = rendering.Transform()
self.pursuer2_capture.add_attr(self.p2ctrans)
self.pursuer2_capture.set_color(0, 1, 0)
self.evader = rendering.make_circle(1)
self.etrans = rendering.Transform()
self.evader.add_attr(self.etrans)
self.evader.set_color(0, 0, 1)
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.pursuer1)
self.viewer.add_geom(self.pursuer1_capture)
self.viewer.add_geom(self.pursuer2)
self.viewer.add_geom(self.pursuer2_capture)
self.viewer.add_geom(self.evader)
if self.state is None:
return None
self.p1trans.set_translation(self.state[1][0] + 5, self.state[1][1] + 5)
self.p1ctrans.set_translation(self.state[1][0] + 5, self.state[1][1] + 5)
self.p2trans.set_translation(self.state[2][0] + 5, self.state[2][1] + 5)
self.p2ctrans.set_translation(self.state[2][0] + 5, self.state[2][1] + 5)
self.etrans.set_translation(self.state[0][4] + 5, self.state[0][5] + 5)
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 = 550
screen_height = 550
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
self.line1 = rendering.Line((25, 25), (525, 25))
self.line2 = rendering.Line((25, 125), (525, 125))
self.line3 = rendering.Line((25, 225), (525, 225))
self.line4 = rendering.Line((25, 325), (525, 325))
self.line5 = rendering.Line((25, 425), (525, 425))
self.line12 = rendering.Line((25, 525), (525, 525))
self.line6 = rendering.Line((25, 25), (25, 525))
self.line7 = rendering.Line((125, 25), (125, 525))
self.line8 = rendering.Line((225, 25), (225, 525))
self.line9 = rendering.Line((325, 25), (325, 525))
self.line10 = rendering.Line((425, 25), (425, 525))
self.line11 = rendering.Line((525, 25), (525, 525))
# 创建墙
self.kulo1 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(175, 75))
self.kulo1.add_attr(self.circletrans)
self.kulo1.set_color(0, 0, 0)
self.kulo2 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(175, 175))
self.kulo2.add_attr(self.circletrans)
self.kulo2.set_color(0, 0, 0)
self.kulo3 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(175, 275))
self.kulo3.add_attr(self.circletrans)
self.kulo3.set_color(0, 0, 0)
self.kulo4 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(175, 375))
self.kulo4.add_attr(self.circletrans)
self.kulo4.set_color(0, 0, 0)
self.kulo11 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(375, 175))
self.kulo11.add_attr(self.circletrans)
self.kulo11.set_color(0, 0, 0)
self.kulo22 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(375, 275))
self.kulo22.add_attr(self.circletrans)
self.kulo22.set_color(0, 0, 0)
self.kulo33 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(375, 375))
self.kulo33.add_attr(self.circletrans)
self.kulo33.set_color(0, 0, 0)
self.kulo44 = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(375, 475))
self.kulo44.add_attr(self.circletrans)
self.kulo44.set_color(0, 0, 0)
# 终点
self.gold = rendering.make_circle(40)
self.circletrans = rendering.Transform(translation=(475, 475))
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.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.line12)
self.viewer.add_geom(self.kulo1)
self.viewer.add_geom(self.kulo2)
self.viewer.add_geom(self.kulo3)
self.viewer.add_geom(self.kulo4)
self.viewer.add_geom(self.kulo11)
self.viewer.add_geom(self.kulo22)
self.viewer.add_geom(self.kulo33)
self.viewer.add_geom(self.kulo44)
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 % 5 - 1], self.y[int((self.state - 1) / 5)])
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode):
from gym.envs.classic_control import rendering
screen_width = 1200
screen_height = 1000
node_radius = 5 # must be int
node_filled = False # boolean
# used for reference to scale longitude/latitude to x,y grid
min_x_coord = 100.0
min_y_coord = 100.0
max_x_coord = 0.0
max_y_coord = 0.0
for node in self.G._nodes:
if float(node.coordinates[0]) < min_x_coord:
min_x_coord = float(node.coordinates[0])
if float(node.coordinates[1]) < min_y_coord:
min_y_coord = float(node.coordinates[1])
if float(node.coordinates[0]) > max_x_coord:
max_x_coord = float(node.coordinates[0])
if float(node.coordinates[1]) > max_y_coord:
max_y_coord = float(node.coordinates[1])
x_coord_scale = screen_width / (max_x_coord - min_x_coord)
y_coord_scale = screen_height / (max_y_coord - min_y_coord)
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
# self.viewer.set_bounds(min_x_coord,max_x_coord,min_y_coord,max_y_coord)
for edge in self.G._edges:
start_coord = edge._source.coordinates # tuple
end_coord = edge._destination.coordinates # tuple
x_s = float(start_coord[0]) - min_x_coord
y_s = float(start_coord[1]) - min_y_coord
x_e = float(end_coord[0]) - min_x_coord
y_e = float(end_coord[1]) - min_y_coord
self.viewer.draw_line(
start=(x_s * x_coord_scale, y_s * y_coord_scale),
end=(x_e * x_coord_scale, y_e * y_coord_scale),
)
for node in self.G._nodes:
node_color = (0.1, 0.1, 0.1)
node_x = float(node.coordinates[0]) - min_x_coord
node_y = float(node.coordinates[1]) - min_y_coord
node_index = node.index
node_circle = rendering.make_circle(radius=node_radius,
filled=node_filled)
node_circle.add_attr(
rendering.Transform(
translation=(node_x * x_coord_scale,
node_y * y_coord_scale),
scale=(1, 1),
))
if node.visited == True:
node_filled = True
if node.source_node == True:
node_color = (1.0, 0, 0)
elif node.dest_node == True:
node_color = (0, 1.0, 0)
node_circle.set_color(node_color[0], node_color[1], node_color[2])
self.viewer.add_onetime(node_circle)
return self.viewer.render(return_rgb_array=mode == "rgb_array")
def render1(self, mode='human'):
stepsize = self.screen_width // 10
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.screen_width,
self.screen_height)
# ------------------------
# WorkSpace
l, r, t, b = -self.workSpaceWidth, self.workSpaceWidth, \
self.workSpaceHeight, - self.workSpaceHeight
workspace = rendering.make_polygon([(l, b), (l, t), (r, t),
(r, b)], False)
workspace.set_color(.0, .0, .0)
self.workspacetrans = rendering.Transform(
translation=(self.screen_width / 2.0,
self.screen_height / 3.0 - 20),
rotation=0.00)
workspace.add_attr(self.workspacetrans)
self.viewer.add_geom(workspace)
# ------------------------
# Desired Zone
# l, r, t, b = -self.workSpaceWidth//2, self.workSpaceWidth//2, \
# self.workSpaceHeight//2, - self.workSpaceHeight//2
# axleoffset = self.objheight/4.0
# zone = rendering.make_polygon(
# [(l, b), (l, t), (r, t), (r, b)], False)
# zone.set_color(.0, 255, 0)
# self.zonetrans = rendering.Transform(translation=(
# self.screen_width/2.0, self.workSpaceHeight + 12), rotation=0.00)
# zone.add_attr(self.zonetrans)
# self.viewer.add_geom(zone)
# ------------------------
# Desired Zone
radious = 10
zone = rendering.make_circle(radious, 30, False)
zone.set_color(0, 165, 255)
self.zonetrans = rendering.Transform(
translation=(self.Desired_pos_x, self.Desired_pos_y),
rotation=-0.00)
zone.add_attr(self.zonetrans)
self.viewer.add_geom(zone)
# ------------------------
# left Arm
larm = rendering.Image('larm.jpg', self.armwidth, self.armheight)
larm.set_color(255, 255, 255)
self.larmtrans = rendering.Transform(rotation=-0.1)
larm.add_attr(self.larmtrans)
self.viewer.add_geom(larm)
# ------------------------
# right Arm
rarm = rendering.Image('rarm.jpg', self.armwidth, self.armheight)
rarm.set_color(255, 255, 255)
self.rarmtrans = rendering.Transform(rotation=0.1)
rarm.add_attr(self.rarmtrans)
self.viewer.add_geom(rarm)
# ------------------------
# Keyboard
obj1 = rendering.Image('Object_Keyboard.jpg', self.objwidth,
self.objheight)
obj1.set_color(255, 255, 255)
self.objtrans = rendering.Transform(rotation=-0.00)
obj1.add_attr(self.objtrans)
self.viewer.add_geom(obj1)
# ------------------------
if self.state_obj is None:
return None
x = self.state_obj
orientation_state = x[0]
objx = x[1] * stepsize + self.screen_width // 2.0 # MIDDLE OF CART
objy = x[2] * stepsize + self.screen_height // 4.0 # MIDDLE OF CART
pos = self.movementPath[self.step_count]
self.objtrans.set_translation(pos[0], pos[1])
disR = math.tanh(np.radians(
(orientation_state / 100))) * (self.objwidth / 2)
self.larmtrans.set_translation(pos[0] - self.objwidth // 2 - 20,
pos[1] - self.objheight - 20 - disR)
self.rarmtrans.set_translation(pos[0] + self.objwidth // 2 + 20,
pos[1] - self.objheight - 20 + disR)
self.pos_x_object = pos[0]
self.pos_y_object = pos[1]
self.movement_distance = \
math.sqrt(math.pow(self.pos_x_object - self.movementPath[self.step_count - 1][0], 2)
+ math.pow(self.pos_y_object - self.movementPath[self.step_count - 1][1], 2))
# print(self.movement_distance)
self.objtrans.set_rotation(
np.radians(orientation_state * self.rotation_step))
# self.larmtrans.set_rotation(np.radians(
# orientation_state * self.rotation_step))
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, state_action_list, mode='human'):
action_dict = {0: "left", 1: "nothing", 2: "right"}
screen_width = 600
screen_height = 400
world_width = 5
scale = screen_width / world_width
carty = 150
polewidth = 10.0
polelen = scale * 1.0
cartwidth = 50.0
cartheight = 30.0
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)])
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 + 7.5 * x,
carty + cartheight / 2 + 7.5 * 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 + 7.5 * x,
carty + cartheight / 2 + 7.5 * 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 + screen_width / 2.0, carty),
(self.x_threshold * scale + screen_width / 2.0, carty))
track.set_color(0, 0, 0)
viewer.add_geom(track)
for state, action in state_action_list:
x, x_dot, theta, theta_dot = state
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)
viewer.render(return_rgb_array=mode == 'rgb_array')
time.sleep(0.1)
viewer.close()
def _render(self, mode='human', close=False): if close: if self.viewer is not None: self.viewer.close() self.viewer = None return x1,y1,z1 = self.body1.getPosition() x2,y2,z2 = self.body2.getPosition() x3,y3,z3 = self.body3.getPosition() x4,y4,z4 = self.body4.getPosition() state = self._get_obs() if self.viewer is None: from gym.envs.classic_control import rendering self.viewer = rendering.Viewer(self.viewerSize, self.viewerSize) self.viewer.set_bounds(-self.spaceSize/2.0,self.spaceSize/2.0,-self.spaceSize/2.0,self.spaceSize/2.0) cw, ch = self.size_box l, r, t, b = -cw/2, cw/2, ch/2, -ch/2 cart = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)]) self.cart_trans = rendering.Transform() cart.add_attr(self.cart_trans) self.viewer.add_geom(cart) pole = rendering.make_capsule(self.size_pole[0], self.size_pole[1]) pole.set_color(.8, .6, .4) self.pole_trans = rendering.Transform() pole.add_attr(self.pole_trans) pole.add_attr(self.cart_trans) self.viewer.add_geom(pole) pole2 = rendering.make_capsule(self.size_pole[0], self.size_pole[1]) pole2.set_color(.8, .6, .4) self.pole_trans2 = rendering.Transform() self.axle_trans21 = rendering.Transform() pole2.add_attr(self.pole_trans2) pole2.add_attr(self.axle_trans21) pole2.add_attr(self.pole_trans) pole2.add_attr(self.cart_trans) self.viewer.add_geom(pole2) pole3 = rendering.make_capsule(self.size_pole[0], self.size_pole[1]) pole3.set_color(.8, .6, .4) self.pole_trans3 = rendering.Transform() self.axle_trans32 = rendering.Transform() pole3.add_attr(self.pole_trans3) pole3.add_attr(self.axle_trans32) pole3.add_attr(self.pole_trans2) pole3.add_attr(self.axle_trans21) pole3.add_attr(self.pole_trans) pole3.add_attr(self.cart_trans) self.viewer.add_geom(pole3) axle = rendering.make_circle(self.size_pole[1]/2.) axle.set_color(.5,.5,.8) axle.add_attr(self.cart_trans) self.viewer.add_geom(axle) axle2 = rendering.make_circle(self.size_pole[1]/2.) axle2.set_color(.5,.5,.8) axle2.add_attr(self.axle_trans21) axle2.add_attr(self.pole_trans) axle2.add_attr(self.cart_trans) self.viewer.add_geom(axle2) axle3 = rendering.make_circle(self.size_pole[1]/2.) axle3.set_color(.5,.5,.8) axle3.add_attr(self.axle_trans32) axle3.add_attr(self.pole_trans2) axle3.add_attr(self.axle_trans21) axle3.add_attr(self.pole_trans) axle3.add_attr(self.cart_trans) self.viewer.add_geom(axle3) self.track = rendering.Line((-self.spaceSize/2.0, 0), (self.spaceSize/2.0, 0)) self.track.set_color(0,0,0) self.viewer.add_geom(self.track) self.cart_trans.set_translation(x1,y1) self.pole_trans.set_rotation(state[2] + math.pi/2) self.axle_trans21.set_translation(self.size_pole[0], 0) self.pole_trans2.set_rotation(state[4]) self.axle_trans32.set_translation(self.size_pole[0], 0) self.pole_trans3.set_rotation(state[6]) 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])
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 # 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", N=1):
N = max(1, N)
screen_width = 600
screen_height = 600
world_width = 2.5
scale = screen_width / world_width
carty = 100 # TOP OF CART
polewidth = 10.0 * (self.model.mp / 0.5)**0.5
polelen = scale * self.model.lp
cartwidth = 50.0 * (self.model.mc / 0.5)**0.25
cartheight = 30.0 * (self.model.mc / 0.5)**0.25
if self.state is None:
return None
x, _, theta, _ = 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)
self.carttrans = [0] * N
self.poletrans = [0] * N
self.axles = [0] * N
for i in range(N - 1, -1, -1):
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)])
cart.attrs[0].vec4 = (0.0, 0.0, 0.0, 1.0 / (N - i))
self.carttrans[i] = rendering.Transform()
cart.add_attr(self.carttrans[i])
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)
pole.attrs[0].vec4 = (0.8, 0.6, 0.4, 1.0 / (N - i))
self.poletrans[i] = rendering.Transform(
translation=(0, axleoffset))
pole.add_attr(self.poletrans[i])
pole.add_attr(self.carttrans[i])
self.viewer.add_geom(pole)
self.axles[i] = rendering.make_circle(polewidth / 2)
self.axles[i].add_attr(self.poletrans[i])
self.axles[i].add_attr(self.carttrans[i])
self.axles[i].set_color(0.5, 0.5, 0.8)
self.axles[i].attrs[0].vec4 = (0.5, 0.5, 0.8, 1.0 / (N - i))
self.viewer.add_geom(self.axles[i])
self.carttrans[i].set_translation(cartx, carty)
self.poletrans[i].set_rotation(-theta - np.pi)
self.track = rendering.Line((0, carty), (screen_width, carty))
self.track.set_color(0, 0, 0)
self.viewer.add_geom(self.track)
for i in range(N - 1):
self.carttrans[i].set_translation(*self.carttrans[i +
1].translation)
self.poletrans[i].set_rotation(self.poletrans[i + 1].rotation)
self.carttrans[-1].set_translation(cartx, carty)
self.poletrans[-1].set_rotation(theta + np.pi)
return self.viewer.render(return_rgb_array=mode == "rgb_array")
def render_orthographic(self,
mode='human',
close=False,
action_idx=None,
action_vec=None):
if close:
if self.viewer_x is not None:
self.viewer_x.close()
self.viewer_x = None
if self.viewer_y is not None:
self.viewer_y.close()
self.viewer_y = None
if self.viewer_orthographic is not None:
self.viewer_orthographic.close()
self.viewer_orthographic = None
return
screen_width = 600
screen_height = 600
world_height = self.max_position_y - self.min_position_y # same for y
scale = (screen_height - 120) / world_height
carwidth = 20
carheight = 10
if self.viewer_orthographic is None:
self.viewer_orthographic = rendering.Viewer(
screen_width, screen_height)
# ys = np.linspace(self.min_position_y, self.max_position_y, 100)
# zs = self._height(ys)
# xyzs = list(zip((ys-self.min_position_y)*scale, zs*scale))
# self.track = rendering.make_polyline(xyzs)
# self.track.set_linewidth(4)
# self.viewer_orthographic.add_geom(self.track)
min_x = -math.pi / 6
min_y = -math.pi / 6
origin_res = 50
origin_radius = 2
origin_circle = rendering.make_circle(radius=origin_radius,
res=origin_res,
filled=True)
origin_circle.set_color(0, 0, 0)
origin_circle.add_attr(
rendering.Transform(
translation=((min_x - self.min_position_x) * scale,
(min_y - self.min_position_y) * scale)))
self.viewer_orthographic.add_geom(origin_circle)
radius_unscaled = math.sqrt((self.goal_position - min_x)**2 +
(self.goal_position - min_y)**2)
equilline_radius = radius_unscaled * scale
#
# points_x = []
# points_y = []
# offset_x, offset_y = (min_x - self.min_position_x) * scale, (min_y - self.min_position_y)*scale
# for i in range(res):
# ang = 2 * math.pi * i / res
# points_x.append(offset_x + math.cos(ang) * radius)
# points_y.append(offset_y + math.sin(ang) * radius)
#
# equiline = list(zip(points_x, points_y))
# self.track = rendering.make_polyline(equiline)
# self.track.set_linewidth(4)
equiline = rendering.make_circle(radius=equilline_radius,
res=200,
filled=False)
equiline.set_color(0, 0, 0)
equiline.add_attr(
rendering.Transform(
translation=((min_x - self.min_position_x) * scale,
(min_y - self.min_position_y) * scale)))
equiline.add_attr(
rendering.LineWidth(10)) # not sure why doesn't work
self.viewer_orthographic.add_geom(equiline)
clearance = 5
clearance_wheels = 0
l, r, t, b = -carwidth / 2, carwidth / 2, carheight / 2, -carheight / 2
car = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
car.add_attr(rendering.Transform(translation=(0, clearance)))
self.cartrans_orth = rendering.Transform()
car.add_attr(self.cartrans_orth)
self.viewer_orthographic.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_wheels)))
frontwheel.add_attr(self.cartrans_orth)
self.viewer_orthographic.add_geom(frontwheel)
backwheel = rendering.make_circle(carheight / 2.5)
backwheel.add_attr(
rendering.Transform(translation=(-carwidth / 4,
clearance_wheels)))
backwheel.add_attr(self.cartrans_orth)
backwheel.set_color(.5, .5, .5)
self.viewer_orthographic.add_geom(backwheel)
flagx = (self.goal_position - self.min_position_x) * scale
flagy1 = (self.goal_position - self.min_position_y) * scale
flagy2 = flagy1 + 50
flagpole = rendering.Line((flagx, flagy1), (flagx, flagy2))
self.viewer_orthographic.add_geom(flagpole)
flag = rendering.FilledPolygon([(flagx, flagy2),
(flagx, flagy2 - 10),
(flagx + 25, flagy2 - 5)])
flag.set_color(1, 0, 0)
self.viewer_orthographic.add_geom(flag)
# set trails
if self.trailer:
self.trail_trans = []
trail_color_increment = 1.0 / self.trail_num
for i in range(self.trail_num):
trail = rendering.make_circle(radius=5)
trail.set_color(1 - trail_color_increment * i, 0, 0)
trans = rendering.Transform()
trail.add_attr(trans)
self.viewer_orthographic.add_geom(trail)
self.trail_trans.append(trans)
if action_idx is not None or action_vec is not None:
actions = np.array([[0, 0], [-1, 0], [1, 0], [0, -1], [0, 1]])
if action_idx is not None:
action_vertex = tuple(actions[action_idx] * scale * 0.1)
elif action_vec is not None:
action_vertex = tuple(
np.sum(action_vec.reshape(-1, 1) * actions, axis=0) *
scale * 0.1)
action_direction = rendering.make_polyline([(0, 0), action_vertex])
action_direction.add_attr(self.cartrans_orth)
action_direction.set_linewidth(2)
action_direction.set_color(0, 1, 0)
self.viewer_orthographic.add_onetime(action_direction)
if self.show_velo == True:
velocity_vertex = tuple(np.array(self.state[2:4]) * scale * 10)
velocity = rendering.make_polyline([(0, 0), velocity_vertex])
velocity.add_attr(self.cartrans_orth)
velocity.set_linewidth(2)
velocity.set_color(0, 0, 1)
self.viewer_orthographic.add_onetime(velocity)
if self.trailer:
for i in range(len(self.last_few_positions)):
self.trail_trans[i].set_translation(
(self.last_few_positions[i][0] - self.min_position_x) *
scale,
(self.last_few_positions[i][1] - self.min_position_y) *
scale)
pos_x = self.state[0]
pos_y = self.state[1]
self.cartrans_orth.set_translation(
(pos_x - self.min_position_x) * scale,
(pos_y - self.min_position_y) * scale)
return self.viewer_orthographic.render(
return_rgb_array=mode == 'rgb_array')
def render(self, goal_pos, x, P, sx, WORLD_SIZE, GOAL_RADIUS):
'''
goal is green, with radius a green ring
belief x location organge, with a angle head
real location sx location golden start
'''
goal_pos = goal_pos.detach().numpy() # get value of tensor
x = x.detach().numpy()
P = P.detach().numpy()
sx = sx.detach().numpy()
screen_width, screen_height = 500, 500
xyBox = WORLD_SIZE
world_width = 2 * xyBox
scale = screen_width/world_width
center = translate(torch.zeros(2), -xyBox, scale)
goal_pos = translate(goal_pos, -xyBox, scale)
agent_size = AGENT_SIZE
goal_size = GOAL_SIZE
if self.viewer is None:
self.viewer = rendering.Viewer(screen_width, screen_height)
goal = rendering.make_circle(goal_size, res=30)
goal_ring = rendering.make_circle(GOAL_RADIUS * scale, res=30, filled=False)
goal.set_color(*GREEN) #green
goal_ring.set_color(*GREEN) #green
self.goal_motion = rendering.Transform(translation=center)
goal.add_attr(self.goal_motion)
goal_ring.add_attr(self.goal_motion)
agent = rendering.make_circle(agent_size, res=30)
head = rendering.make_polygon([(0,5),(0,-5),(5,0)])
star = rendering.make_polygon([(0, -10), (6, 8), (-10, -3.0), (10, -3.0), (-6, 8)])
agent.set_color(*ORANGE) #orange,
head.set_color(*GREY)
head.add_attr(rendering.Transform(translation=(10,0))) #offset
star.set_color(*GOLD)
self.agent_motion = rendering.Transform(translation=(0,0))
self.head_motion = rendering.Transform() # for rotation (turning)
self.star_motion = rendering.Transform(translation=(0,0))
agent.add_attr(self.agent_motion)
head.add_attr(self.head_motion)
head.add_attr(self.agent_motion)
star.add_attr(self.star_motion)
self.viewer.add_geom(goal)
self.viewer.add_geom(goal_ring)
self.viewer.add_geom(star)
self.viewer.add_geom(agent)
self.viewer.add_geom(head)
self.viewer.add_geom(agent) # dummy addition to replace with cov
self.goal_motion.set_translation(goal_pos[0], goal_pos[1])
# belief
#r, ang = x[0][2], x[0][3]
#px = r * np.cos(ang)
#py = r * np.sin(ang)
#position = np.array([px, py])
position, ang = x[0][:2], x[0][2]
move = translate(position, -xyBox, scale)
self.agent_motion.set_translation(move[0], move[1])
self.head_motion.set_rotation(ang)
#star
#sr, sang = sx[0][2], sx[0][3]
#spx = sr * np.cos(sang)
#spy = sr * np.sin(sang)
#sposition = np.array([spx, spy])
sposition, sang = sx[0][:2], sx[0][2]
smove = translate(sposition, -xyBox, scale)
self.star_motion.set_translation(smove[0], smove[1])
#pts = np.vstack(ellipse(np.zeros(2), P[-2:,-2:], conf_int=5.991*scale**2)).T #100 added
pts = np.vstack(ellipse(np.zeros(2), P[:2, :2], conf_int=5.991 * scale ** 2)).T # 100 added
pts = [tuple(v) for v in pts]
cov = rendering.make_polygon(pts, False)
cov.set_color(*ORANGE)
cov.add_attr(rendering.Transform(translation=(move[0], move[1])))
self.viewer.geoms[-1] = cov
return self.viewer.render(return_rgb_array=False)
def _plot_state(self, viewer, state):
polygon = rendering.make_circle(radius=5, res=30, filled=True)
state_tr = rendering.Transform(translation=(state[0], state[1]))
polygon.add_attr(state_tr)
viewer.add_onetime(polygon)
def render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
zero = (0, 0)
u_size = self.u_size
m = 2 # 格子之间的间隙尺寸
# 如果还没有设定屏幕对象，则初始化整个屏幕具备的元素。
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.width, self.height)
# 在Viewer里绘制一个几何图像的步骤如下：
# 1. 建立该对象需要的数据本身
# 2. 使用rendering提供的方法返回一个geom对象
# 3. 对geom对象进行一些对象颜色、线宽、线型、变换属性的设置（有些对象提供一些个
# 性化的方法来设置属性，具体请参考继承自这些Geom的对象），这其中有一个重要的
# 属性就是变换属性，
# 该属性负责对对象在屏幕中的位置、渲染、缩放进行渲染。如果某对象
# 在呈现时可能发生上述变化，则应建立关于该对象的变换属性。该属性是一个
# Transform对象，而一个Transform对象，包括translate、rotate和scale
# 三个属性，每个属性都由以np.array对象描述的矩阵决定。
# 4. 将新建立的geom对象添加至viewer的绘制对象列表里，如果在屏幕上只出现一次，
# 将其加入到add_onegeom(）列表中，如果需要多次渲染，则将其加入add_geom()
# 5. 在渲染整个viewer之前，对有需要的geom的参数进行修改，修改主要基于该对象
# 的Transform对象
# 6. 调用Viewer的render()方法进行绘制
''' 绘制水平竖直格子线，由于设置了格子之间的间隙，可不用此段代码
for i in range(self.n_width+1):
line = rendering.Line(start = (i*u_size, 0),
end =(i*u_size, u_size*self.n_height))
line.set_color(0.5,0,0)
self.viewer.add_geom(line)
for i in range(self.n_height):
line = rendering.Line(start = (0, i*u_size),
end = (u_size*self.n_width, i*u_size))
line.set_color(0,0,1)
self.viewer.add_geom(line)
'''
# 绘制格子
for x in range(self.n_width):
for y in range(self.n_height):
v = [(x * u_size + m, y * u_size + m),
((x + 1) * u_size - m, y * u_size + m),
((x + 1) * u_size - m, (y + 1) * u_size - m),
(x * u_size + m, (y + 1) * u_size - m)]
rect = rendering.FilledPolygon(v)
r = self.grids.get_reward(x, y) / 10
if r < 0:
rect.set_color(0.9 - r, 0.9 + r, 0.9 + r)
elif r > 0:
rect.set_color(0.3, 0.5 + r, 0.3)
else:
rect.set_color(0.9, 0.9, 0.9)
self.viewer.add_geom(rect)
# 绘制边框
v_outline = [(x * u_size + m, y * u_size + m),
((x + 1) * u_size - m, y * u_size + m),
((x + 1) * u_size - m, (y + 1) * u_size - m),
(x * u_size + m, (y + 1) * u_size - m)]
outline = rendering.make_polygon(v_outline, False)
outline.set_linewidth(3)
if self._is_end_state(x, y):
# 给终点方格添加金黄色边框
outline.set_color(0.9, 0.9, 0)
self.viewer.add_geom(outline)
if self.start[0] == x and self.start[1] == y:
outline.set_color(0.5, 0.5, 0.8)
self.viewer.add_geom(outline)
if self.grids.get_type(x, y) == 1: # 障碍格子用深灰色表示
rect.set_color(0.3, 0.3, 0.3)
else:
pass
# 绘制个体
self.agent = rendering.make_circle(u_size / 4, 30, True)
self.agent.set_color(1.0, 1.0, 0.0)
self.viewer.add_geom(self.agent)
self.agent_trans = rendering.Transform()
self.agent.add_attr(self.agent_trans)
# 更新个体位置
x, y = self._state_to_xy(self.state)
self.agent_trans.set_translation((x + 0.5) * u_size, (y + 0.5) * u_size)
return self.viewer.render(return_rgb_array= mode == 'rgb_array')
def _render(self, mode='human', close=False):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
x1, y1, z1 = self.body1.getPosition()
x2, y2, z2 = self.body2.getPosition()
x3, y3, z3 = self.body3.getPosition()
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.viewerSize, self.viewerSize)
self.viewer.set_bounds(-self.spaceSize / 2.0, self.spaceSize / 2.0,
-self.spaceSize / 2.0, self.spaceSize / 2.0)
rod1 = rendering.make_capsule(1, .3)
rod1.set_color(0.4, 0.4, 0.4)
self.pole_transform1 = rendering.Transform()
self.pole_transform11 = rendering.Transform()
rod1.add_attr(self.pole_transform1)
rod1.add_attr(self.pole_transform11)
self.viewer.add_geom(rod1)
rod2 = rendering.make_capsule(1, .2)
rod2.set_color(0.2, 0.2, 0.2)
self.pole_transform2 = rendering.Transform()
self.pole_transform21 = rendering.Transform()
rod2.add_attr(self.pole_transform2)
rod2.add_attr(self.pole_transform21)
self.viewer.add_geom(rod2)
rod3 = rendering.make_capsule(1, .1)
rod3.set_color(0, 0, 0)
self.pole_transform3 = rendering.Transform()
self.pole_transform31 = rendering.Transform()
rod3.add_attr(self.pole_transform3)
rod3.add_attr(self.pole_transform31)
self.viewer.add_geom(rod3)
axle1 = rendering.make_circle(.2)
axle1.set_color(1, 0, 0)
self.axle_transform1 = rendering.Transform()
axle1.add_attr(self.axle_transform1)
self.viewer.add_geom(axle1)
self.axle_transform12 = rendering.Transform()
axle1.add_attr(self.axle_transform12)
axle2 = rendering.make_circle(.15)
axle2.set_color(0, 1, 0)
self.axle_transform2 = rendering.Transform()
axle2.add_attr(self.axle_transform2)
self.axle_transform22 = rendering.Transform()
axle2.add_attr(self.axle_transform22)
self.viewer.add_geom(axle2)
axle3 = rendering.make_circle(.1)
axle3.set_color(0, 0, 1)
self.axle_transform3 = rendering.Transform()
axle3.add_attr(self.axle_transform3)
self.axle_transform32 = rendering.Transform()
axle3.add_attr(self.axle_transform32)
self.viewer.add_geom(axle3)
target = rendering.make_circle(.05)
target.set_color(0.7, 0.7, 0.7)
self.viewer.add_geom(target)
self.targetTrans = rendering.Transform()
target.add_attr(self.targetTrans)
#fname = path.join(path.dirname(__file__), "assets/clockwise.png")
#self.img = rendering.Image(fname, 1., 1.)
#self.imgtrans = rendering.Transform()
#self.img.add_attr(self.imgtrans)
self.transform_link(self.body1, self.pole_transform11,
self.pole_transform1, self.axle_transform12,
self.axle_transform1)
self.transform_link(self.body2, self.pole_transform21,
self.pole_transform2, self.axle_transform22,
self.axle_transform2)
self.transform_link(self.body3, self.pole_transform31,
self.pole_transform3, self.axle_transform32,
self.axle_transform3)
self.targetTrans.set_translation(self.targetPos[0], self.targetPos[1])
return self.viewer.render(True)
def render(self, mode='human', close=False):
# 可视化地图
lines = []
line1 = rendering.Line((0, 0), (0, 200))
lines.append(line1)
line2 = rendering.Line((120, 0), (120, 200))
lines.append(line2)
line3 = rendering.Line((0, 200), (600, 200))
lines.append(line3)
line4 = rendering.Line((0, 100), (600, 100))
lines.append(line4)
line5 = rendering.Line((240, 0), (240, 200))
lines.append(line5)
line6 = rendering.Line((360, 0), (360, 200))
lines.append(line6)
line7 = rendering.Line((480, 0), (480, 200))
lines.append(line7)
line8 = rendering.Line((600, 0), (600, 200))
lines.append(line8)
line9 = rendering.Line((0, 0), (120, 0))
lines.append(line9)
line10 = rendering.Line((240, 0), (360, 0))
lines.append(line10)
line11 = rendering.Line((480, 0), (600, 0))
lines.append(line11)
# 创建terminal
terminals = []
termin = rendering.make_circle(40)
circletrans = rendering.Transform(translation=(300, 50))
terminals.add_attr(circletrans)
terminals.set_color(1, 0.9, 0)
terminals.append(termin)
# 创建building
buildings = []
building1 = rendering.make_circle(40)
building1_transiform = rendering.Transform(translation=(60, 50))
building1.add_attr(building1_transiform)
building1.set_color(0, 0, 0)
buildings.append(building1)
building2 = rendering.make_circle(40)
building2_transiform = rendering.Transform(translation=(540, 50))
building2.add_attr(building2_transiform)
building2.set_color(0, 0, 0)
buildings.append(building2)
#创建
transiform = rendering.Transform(translation=(50, 50))
for line_ in lines:
line_.set_color(0, 0, 0)
line_.add_attr(transiform)
self.viewer.add_geom(line_)
for building_ in buildings:
building_.add_attr(transiform)
self.viewer.add_geom(building_)
for terminal_ in terminals:
terminal_.add_attr(transiform)
self.viewer.add_geom(terminal_)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
self.screen_width = 1200
self.screen_height = 950
self.y_left = -450
self.y_right = 700
self.z_bottom = -110
world_width = self.y_right - self.y_left
scale = self.screen_width / world_width
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.screen_width,
self.screen_height)
# black background
self.background = rendering.make_polygon(
[(0, 0), (0, self.screen_height),
(self.screen_width, self.screen_height),
(self.screen_width, 0)],
filled=True)
self.background.set_color(0.05, 0.05, 0.05)
# create Ken
self.ken = rendering.make_capsule(self.kenlength * scale,
self.damaradius * 0.25 * scale)
self.kentrans = rendering.Transform()
self.ken.add_attr(self.kentrans)
self.ken.set_color(0, 1, 0) # red greed blue (0-black, 1-white)
# use a polygon as the handle
cx, cy = self.kencorner
cx *= scale
cy *= scale
vec = [(0.0, 8.0 * scale), (cx, cy), (cx, -cy),
(5.0 * scale, -7.5 * scale), (7.0 * scale, -37.5 * scale),
(9.0 * scale, -47.5 * scale), (13.0 * scale, -56 * scale),
(14.0 * scale, -66 * scale), (-14.0 * scale, -66 * scale),
(-13.0 * scale, -56 * scale), (-9.0 * scale, -47.5 * scale),
(-7.0 * scale, -37.5 * scale), (-5.0 * scale, -7.5 * scale),
(-cx, -cy), (-cx, cy)]
self.handle = rendering.make_polygon(vec, filled=True)
self.handletrans = rendering.Transform()
self.handle.add_attr(self.handletrans)
self.handle.set_color(0.1, 0.9, 0.1)
# create Dama
self.dama = rendering.make_circle(self.damaradius * scale)
self.damatrans = rendering.Transform()
self.dama.add_attr(self.damatrans)
self.dama.set_color(1, 0, 0)
# make a hole on Dama
self.hole = rendering.make_capsule(self.damaradius * 5 / 6 * scale,
self.damaradius * 0.4 * scale)
self.holetrans = rendering.Transform()
self.hole.add_attr(self.holetrans)
self.hole.set_color(0.2, 0.2, 0.9)
# add a string connecting Ken and Dama
self.string = rendering.Line((0.0, 0.0),
(0.0, -self.length * scale))
self.stringtrans = rendering.Transform()
self.string.add_attr(self.stringtrans)
self.string.set_color(1, 1, 1)
# add geom in displaying order
self.viewer.add_geom(self.background)
self.viewer.add_geom(self.dama)
self.viewer.add_geom(self.hole)
self.viewer.add_geom(self.ken)
self.viewer.add_geom(self.handle)
self.viewer.add_geom(self.string)
# load the change from self.observation
ken_y = self.observation[0]
ken_z = self.observation[1]
dama_y = self.observation[6]
dama_z = self.observation[7]
theta = self.observation[10]
self.kentrans.set_translation((ken_y - self.y_left) * scale,
(ken_z - self.z_bottom) * scale)
self.handletrans.set_translation((ken_y - self.y_left) * scale,
(ken_z - self.z_bottom) * scale)
self.damatrans.set_translation((dama_y - self.y_left) * scale,
(dama_z - self.z_bottom) * scale)
self.damatrans.set_rotation(theta)
self.holetrans.set_translation((dama_y - self.y_left) * scale,
(dama_z - self.z_bottom) * scale)
self.holetrans.set_rotation(theta + np.pi / 2)
if self.tighten:
self.stringtrans.set_translation((ken_y - self.y_left) * scale,
(ken_z - self.z_bottom) * scale)
self.stringtrans.set_rotation(theta)
else:
self.stringtrans.set_translation(-self.length * scale,
-self.length * scale)
self.kentrans.set_rotation(self.beta - np.pi + np.pi / 2)
self.handletrans.set_rotation(self.beta - np.pi)
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)#, display=self.display) '''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)''' for i in xrange(self.SystemLength): self.offsettrans = rendering.Transform() self.error_offsettrans = rendering.Transform() self.translist.append(self.offsettrans) self.error_translist.append(self.error_offsettrans) axle = rendering.make_circle(polewidth/2) error = rendering.make_circle(polewidth/4) axle.add_attr(self.offsettrans) error.add_attr(self.error_offsettrans) axle.set_color(.8,.6,.4) error.set_color(.1,.1,.1) self.viewer.add_geom(axle) self.viewer.add_geom(error) #print "Putting on the screen!" #self.track = rendering.Line((0,carty), (screen_width,carty)) #self.track.set_color(0,0,0) #self.viewer.add_geom(self.track) for i,t in enumerate(self.translist): #print "something happening?" if self.state[i]!=0: #print "Moving to be visible!" t.set_translation(i*(400./self.SystemLength)+100., 200) else: t.set_translation(-10,-10) for i,t in enumerate(self.error_translist): if self.error_state[i]!=0: t.set_translation(i*(400./self.SystemLength)+100. + (400./self.SystemLength)/2., 200) else: t.set_translation(-10,-10) #print "This is being run, though!" #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'):
s, s_dot, theta, theta_dot = self.state
x, x_dot = self.x(s), self.x_dot(s)
if self.viewer is None:
self.viewer = rendering.Viewer(self.screen_width_pixels,
self.screen_height_pixels)
# track / ground
ss = np.linspace(self.x_min, self.x_max, 2000)
xs = np.array(self.x(ss))
ys = np.array(self.y(ss))
xys = list(zip((xs - self.x_min) * self.scale, ys * self.scale))
self.track = rendering.make_polyline(xys)
self.track.set_color(44 / 255, 160 / 255, 44 / 255)
self.track.set_linewidth(5)
self.viewer.add_geom(self.track)
# start flag
flag_x = (self.x(self.starting_position) - self.x_min) * self.scale
flag_bottom_y = self.y(self.starting_position) * self.scale
flag_top_y = flag_bottom_y + 100.0
flagpole = rendering.Line((flag_x, flag_bottom_y),
(flag_x, flag_top_y))
self.viewer.add_geom(flagpole)
flag = rendering.FilledPolygon([(flag_x, flag_top_y),
(flag_x, flag_top_y - 25),
(flag_x + 50, flag_top_y - 15)])
flag.set_color(105 / 255, 183 / 255, 100 / 255)
self.viewer.add_geom(flag)
# goal margin
stone_width, stone_height = 16, 16
left_stone_x = (self.x(self.min_goal) - self.x_min) * self.scale
left_stone_bottom_y = self.y(self.min_goal) * self.scale
right_stone_x = (self.x(self.max_goal) - self.x_min) * self.scale
right_stone_bottom_y = self.y(self.max_goal) * self.scale
left_stone = rendering.FilledPolygon([
(left_stone_x, left_stone_bottom_y),
(left_stone_x + stone_width, left_stone_bottom_y),
(left_stone_x + stone_width / 2,
left_stone_bottom_y + stone_height)
])
right_stone = rendering.FilledPolygon([
(right_stone_x - stone_width, right_stone_bottom_y),
(right_stone_x, right_stone_bottom_y),
(right_stone_x - stone_width / 2,
right_stone_bottom_y + stone_height)
])
left_stone.set_color(237 / 255, 102 / 255, 93 / 255)
right_stone.set_color(237 / 255, 102 / 255, 93 / 255)
self.viewer.add_geom(left_stone)
self.viewer.add_geom(right_stone)
for ii in range(0, 8 + 1):
marker = rendering.FilledPolygon([
(ii * pi / 2 * self.scale - stone_width / 4, 0),
(ii * pi / 2 * self.scale - stone_width / 4,
stone_height / 2),
(ii * pi / 2 * self.scale + stone_width / 4,
stone_height / 2),
(ii * pi / 2 * self.scale + stone_width / 4, 0)
])
marker.set_color(242 / 255, 108 / 255, 100 / 255)
self.viewer.add_geom(marker)
marker = rendering.FilledPolygon([
((self.bottom - self.x_min) * self.scale - stone_width / 4, 0),
((self.bottom - self.x_min) * self.scale - stone_width / 4,
stone_height / 2),
((self.bottom - self.x_min) * self.scale + stone_width / 4,
stone_height / 2),
((self.bottom - self.x_min) * self.scale + stone_width / 4, 0)
])
marker.set_color(255 / 255, 193 / 255, 86 / 255)
self.viewer.add_geom(marker)
# cart
l, r, t, b = [
-self.cart_width_pixels / 2, self.cart_width_pixels / 2,
self.cart_height_pixels / 2, -self.cart_height_pixels / 2
]
cart = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
cart.set_color(96 / 255, 99 / 255, 106 / 255)
self.cart_trans = rendering.Transform()
cart.add_attr(
rendering.Transform(translation=(0, self.wheels_radius +
self.cart_height_pixels / 2)))
cart.add_attr(self.cart_trans)
self.viewer.add_geom(cart)
# wheels
front_wheel = rendering.make_circle(self.wheels_radius)
front_wheel.set_color(65 / 255, 68 / 255, 81 / 255)
front_wheel.add_attr(
rendering.Transform(translation=(self.cart_width_pixels / 4,
self.wheels_radius)))
front_wheel.add_attr(self.cart_trans)
self.viewer.add_geom(front_wheel)
back_wheel = rendering.make_circle(self.wheels_radius)
back_wheel.set_color(65 / 255, 68 / 255, 81 / 255)
back_wheel.add_attr(
rendering.Transform(translation=(-self.cart_width_pixels / 4,
self.wheels_radius)))
back_wheel.add_attr(self.cart_trans)
self.viewer.add_geom(back_wheel)
# pole
pole_line = LineString([(0, 0), (0, self.pole_length_pixels)
]).buffer(self.pole_width_pixels / 2)
pole = rendering.make_polygon(list(pole_line.exterior.coords))
pole.set_color(168 / 255, 120 / 255, 110 / 255)
self.pole_trans = rendering.Transform(
translation=(0, self.cart_height_pixels + self.wheels_radius))
pole.add_attr(self.pole_trans)
pole.add_attr(self.cart_trans)
self.viewer.add_geom(pole)
# axle
self.axle = rendering.make_circle(self.pole_width_pixels / 2)
self.axle.add_attr(self.pole_trans)
self.axle.add_attr(self.cart_trans)
self.axle.set_color(127 / 255, 127 / 255, 127 / 255)
self.viewer.add_geom(self.axle)
self.cart_trans.set_translation((x - self.x_min) * self.scale,
self.y(s) * self.scale)
k = np.arctan(-1 / self.y_dot(x)) if self.y_dot(x) != 0.0 else pi / 2
self.cart_trans.set_rotation(pi / 2 + k if k < 0 else k - pi / 2)
self.pole_trans.set_rotation(-(pi / 2 + k if k < 0 else k - pi / 2) -
theta)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
"""
Draws the current state of the game
"""
if self.viewer is None:
screen_width = 800
screen_height = 600
self.viewer = rendering.Viewer(screen_width, screen_height)
if self.state is None: return None
# rescale board
a = 60 # width
b = 60 # height
turns = np.where(
self.MovesPlayed[:, 4] >= 0)[0] # loop over valid moves
for i in turns:
if mode == 'human': # to draw turn-by-turn, skip to last counter
i = turns[-1]
p = self.MovesPlayed[i, 1] # player
x = self.MovesPlayed[i, 2] # x
y = self.MovesPlayed[i, 3] # y
s = self.MovesPlayed[i, 4] # score
# doing this every time (not calling same object each time) should add an additional counter
counter = rendering.make_circle(18)
if p == 1:
counter.set_color(.8, .1, .2)
elif p == 2:
counter.set_color(.1, .8, .2)
self.counter_trans = rendering.Transform()
counter.add_attr(self.counter_trans)
self.counter_trans.set_translation(a + b * x, a + b * y)
# updating the position of the same counter 'glow' object will only produce one on screen
if i == turns[-1]:
self.new_counter = rendering.make_circle(22) #self.MSize*1.2)
self.new_counter.set_color(1, 1, 0)
self.new_counter.add_attr(self.counter_trans)
self.viewer.add_geom(
self.new_counter) # this might produce many copies
# print('Added counter. Turn',i,'Player',p)
self.viewer.add_geom(counter)
if mode == 'human' and self.Scored > 0: # draw line if a point is scored
for i in range(self.Scored):
ys = self.StrikesPlayed[len(self.StrikesPlayed) - i, 2:6:2]
xs = self.StrikesPlayed[len(self.StrikesPlayed) - i, 3:6:2]
# draw strike as a polyline
self.strike = rendering.make_polyline(
list(zip(a + b * xs, a + b * ys)))
self.strike.set_linewidth(15.0)
if p == 1:
self.strike.set_color(.7, .1, .3)
elif p == 2:
self.strike.set_color(.1, .7, .3)
self.viewer.add_geom(self.strike)
else:
for i in range(len(self.StrikesPlayed)):
p = self.StrikesPlayed[i, 1] # player
ys = self.StrikesPlayed[i, 2:6:2]
xs = self.StrikesPlayed[i, 3:6:2]
# draw strike as a polyline
self.strike = rendering.make_polyline(
list(zip(a + b * xs, a + b * ys)))
self.strike.set_linewidth(15.0)
if p == 1:
self.strike.set_color(.7, .1, .3)
elif p == 2:
self.strike.set_color(.1, .7, .3)
self.viewer.add_geom(self.strike)
# txt = '- Player 1: {} -'.format(self.Points[0])
# self.txt1.set_text(txt)
# txt = '- Player 2: {} -'.format(self.Points[1])
# self.txt2.set_text(txt)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode="human"):
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(0.5, 0.5, 0.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(0.5, 0.5, 0.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(0.8, 0.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):
if close:
if self.viewer is not None:
self.viewer.close()
self.viewer = None
return
zero = (0, 0)
u_size = self.u_size
m = 2 # 格子之间的间隙尺寸
# 如果还没有设定屏幕对象，则初始化整个屏幕具备的元素。
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(self.width, self.height)
# 在Viewer里绘制一个几何图像的步骤如下：
# 1. 建立该对象需要的数据本身
# 2. 使用rendering提供的方法返回一个geom对象
# 3. 对geom对象进行一些对象颜色、线宽、线型、变换属性的设置（有些对象提供一些个
# 性化的方法来设置属性，具体请参考继承自这些Geom的对象），这其中有一个重要的
# 属性就是变换属性，
# 该属性负责对对象在屏幕中的位置、渲染、缩放进行渲染。如果某对象
# 在呈现时可能发生上述变化，则应建立关于该对象的变换属性。该属性是一个
# Transform对象，而一个Transform对象，包括translate、rotate和scale
# 三个属性，每个属性都由以np.array对象描述的矩阵决定。
# 4. 将新建立的geom对象添加至viewer的绘制对象列表里，如果在屏幕上只出现一次，
# 将其加入到add_onegeom(）列表中，如果需要多次渲染，则将其加入add_geom()
# 5. 在渲染整个viewer之前，对有需要的geom的参数进行修改，修改主要基于该对象
# 的Transform对象
# 6. 调用Viewer的render()方法进行绘制
''' 绘制水平竖直格子线，由于设置了格子之间的间隙，可不用此段代码
for i in range(self.n_width+1):
line = rendering.Line(start = (i*u_size, 0),
end =(i*u_size, u_size*self.n_height))
line.set_color(0.5,0,0)
self.viewer.add_geom(line)
for i in range(self.n_height):
line = rendering.Line(start = (0, i*u_size),
end = (u_size*self.n_width, i*u_size))
line.set_color(0,0,1)
self.viewer.add_geom(line)
'''
# 绘制格子
for x in range(self.n_width):
for y in range(self.n_height):
v = [(x * u_size + m, y * u_size + m),
((x + 1) * u_size - m, y * u_size + m),
((x + 1) * u_size - m, (y + 1) * u_size - m),
(x * u_size + m, (y + 1) * u_size - m)]
rect = rendering.FilledPolygon(v)
r = self.grids.get_reward(x, y) / 10
if r < 0:
rect.set_color(0.9 - r, 0.9 + r, 0.9 + r)
elif r > 0:
rect.set_color(0.3, 0.5 + r, 0.3)
else:
rect.set_color(0.9, 0.9, 0.9)
self.viewer.add_geom(rect)
# 绘制边框
v_outline = [(x * u_size + m, y * u_size + m),
((x + 1) * u_size - m, y * u_size + m),
((x + 1) * u_size - m, (y + 1) * u_size - m),
(x * u_size + m, (y + 1) * u_size - m)]
outline = rendering.make_polygon(v_outline, False)
outline.set_linewidth(3)
if self._is_end_state(x, y):
# 给终点方格添加金黄色边框
outline.set_color(0.9, 0.9, 0)
self.viewer.add_geom(outline)
if self.start[0] == x and self.start[1] == y:
outline.set_color(0.5, 0.5, 0.8)
self.viewer.add_geom(outline)
if self.grids.get_type(x, y) == 1: # 障碍格子用深灰色表示
rect.set_color(0.3, 0.3, 0.3)
else:
pass
# 绘制个体
self.agent = rendering.make_circle(u_size / 4, 30, True)
self.agent.set_color(1.0, 1.0, 0.0)
self.viewer.add_geom(self.agent)
self.agent_trans = rendering.Transform()
self.agent.add_attr(self.agent_trans)
# 更新个体位置
x, y = self._state_to_xy(self.state)
self.agent_trans.set_translation((x + 0.5) * u_size,
(y + 0.5) * u_size)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render_y(self, mode='human', close=False):
if close:
if self.viewer_x is not None:
self.viewer_x.close()
self.viewer_x = None
if self.viewer_y is not None:
self.viewer_y.close()
self.viewer_y = None
if self.viewer_orthographic is not None:
self.viewer_orthographic.close()
self.viewer_orthographic = None
return
screen_width = 600
screen_height = 400
world_width = self.max_position_y - self.min_position_y # same for y
scale = screen_width / world_width
carwidth = 40
carheight = 20
if self.viewer_y is None:
from gym.envs.classic_control import rendering
self.viewer_y = rendering.Viewer(screen_width, screen_height)
# xs = np.linspace(self.min_position_x, self.max_position_x, 100)
ys = np.linspace(self.min_position_y, self.max_position_y, 100)
# ys = np.zeros(100)
zs = self._height(ys)
xyzs = list(zip((ys - self.min_position_y) * scale, zs * scale))
self.track = rendering.make_polyline(xyzs)
self.track.set_linewidth(4)
self.viewer_y.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_y = rendering.Transform()
car.add_attr(self.cartrans_y)
self.viewer_y.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_y)
self.viewer_y.add_geom(frontwheel)
backwheel = rendering.make_circle(carheight / 2.5)
backwheel.add_attr(
rendering.Transform(translation=(-carwidth / 4, clearance)))
backwheel.add_attr(self.cartrans_y)
backwheel.set_color(.5, .5, .5)
self.viewer_y.add_geom(backwheel)
flagx = (self.goal_position - self.min_position_x) * scale
flagy1 = self._height(
self.goal_position) * scale #jm: need to change this
flagy2 = flagy1 + 50
flagpole = rendering.Line((flagx, flagy1), (flagx, flagy2))
self.viewer_y.add_geom(flagpole)
flag = rendering.FilledPolygon([(flagx, flagy2),
(flagx, flagy2 - 10),
(flagx + 25, flagy2 - 5)])
flag.set_color(0, .8, .8)
self.viewer_y.add_geom(flag)
pos = self.state[1]
self.cartrans_y.set_translation(
(pos - self.min_position_y) * scale,
self._height(pos) * scale) #jm: need to change this
self.cartrans_y.set_rotation(math.cos(3 * pos))
# pos_x = self.state[0]
# pos_y = self.state[1]
# self.cartrans_y.set_translation((pos_y-self.min_position_y)*scale, self._height_for_car(pos_x, pos_y)*scale)
# self.cartrans_y.set_rotation(math.cos(3 * pos_y))
return self.viewer_y.render(return_rgb_array=mode == 'rgb_array')
