def render(self, mode='human'):
# DO NOT TRANSLATE TO OTHER LANGUAGES UNLESS YOU ARE BRAVE
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:
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'):
import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(400, 800)
#self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
#point1 = rendering.Point
#self.point1.add_attr(self.circletrans)
#rod = rendering.make_capsule(1, .2)
#point1.set_color(.8, .3, .3)
#self.pole_transform = rendering.Transform()
#rod.add_attr(self.pole_transform)
#axle = rendering.make_circle(.05)
#axle.set_color(0, 0, 0)
#self.viewer.add_geom(axle)
self.line1 = rendering.Line((-1, 0), (3, 0))
self.line2 = rendering.Line((0, -4), (0, 4))
self.viewer.add_geom(self.line1)
self.viewer.add_geom(self.line2)
x = self.state
costs = 0.99 * x**5 - 5 * x**4 + 4.98 * x**3 + 5 * x**2 - 6 * x - 1
self.point1 = rendering.make_circle(100)
self.point1.set_color(0, 1, 1)
self.circletrans = rendering.Transform(translation=(x, costs))
self.point1.add_attr(self.circletrans)
self.viewer.add_geom(self.point1)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
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)
theta = np.arctan2(self.x[0], self.x[1])
self.pole_transform.set_rotation(theta + np.pi / 2)
if self.u[0]:
self.imgtrans.scale = (-self.u[0] / 2, np.abs(self.u[0]) / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def __init__(self, pos, cd, _id):
self.cd = cd
self.pos = pos
self._id = _id
x, y = pos
x, y = x * SCALE, y * SCALE
self.shape = rendering.make_circle(x + OFFX, y + OFFY)
self.set_color()
viewer.add_geom(self.shape)
def render(self, mode='human'):
if self.viewer is None:
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)
self.pole_transform.set_rotation(self.state[0])
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
screen_width = 600
screen_height = 400
world_width = self.x_threshold * 2
scale = screen_width / world_width
carty = 100 # TOP OF CART
polewidth = 10.0
polelen = scale * 1.0
cartwidth = 50.0
cartheight = 30.0
if self.viewer is None:
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 __init__(self, pos, tlx, _id, nears):
self.tlx = tlx # Target lx of the desk
self.pos = pos
self._id = _id
self.nears = nears
self.err = 0
x, y = pos
x, y = x * SCALE, y * SCALE
lx, rx = x - Desk.Ws / 2 + OFFX, x + Desk.Ws / 2 + OFFX
by, ty = y - Desk.Hs / 2 + OFFY, y + Desk.Hs / 2 + OFFY
self.shape = rendering.FilledPolygon([(lx, by), (lx, ty), (rx, ty),
(rx, by)])
self.center = rendering.make_circle(x + OFFX,
y + OFFY,
radius=Desk.Hs / 4)
self.set_shape_color()
self.set_center_color(self.tlx)
viewer.add_geom(self.shape)
viewer.add_geom(self.center)
viewer.draw_polyline([(lx, by), (lx, ty), (rx, ty), (rx, by)])
def render(self, mode="human"):
if self.viewer is None:
import rendering
self.viewer = rendering.Viewer(700, 700)
# create rendering geometry
if self.render_geoms is None or self.rebuild_geoms:
import rendering
self.viewer.clear_geoms()
# import rendering only if we need it (and don't import for headless machines)
# from gym.envs.classic_control import rendering
self.render_geoms = []
self.render_geoms_xform = []
for entity in self.get_entities():
geom = rendering.make_circle(entity.get_size())
xform = rendering.Transform()
geom.set_color(*entity.get_color(), alpha=0.5)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
# add geoms to viewer
for geom in self.render_geoms:
self.viewer.add_geom(geom)
results = []
# update bounds to center around agent
cam_range = 1
pos = np.zeros(2)
self.viewer.set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range)
# update geometry positions
for a, entity in enumerate(self.get_entities()):
self.render_geoms_xform[a].set_translation(*entity.get_pos())
# render to display or array
results.append(self.viewer.render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self, mode='human'):
l = self.l
if self.viewer is None:
self.viewer = rendering.Viewer(720,720)
a = 1.8
self.viewer.set_bounds(-(l*a),l*a,-(l*a),l*a)
rod = rendering.make_capsule(l, l/15.2)
rod.set_color(.04, .39, .12)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.02)
axle.set_color(0,0,0)
self.viewer.add_geom(axle)
flywheel_diameter = self.flywheel_diameter
flywheel_rim = rendering.make_circle(flywheel_diameter/2,filled=False)
flywheel_rim.set_linewidth(7)
flywheel_rim.set_color(0.5,0.5,0.5)
self.flywheel_rim_transform = rendering.Transform()
flywheel_rim.add_attr(self.flywheel_rim_transform)
self.viewer.add_geom(flywheel_rim)
flywheel_cross = rendering.make_cross(flywheel_diameter,l/20)
flywheel_cross.set_color(0.5,0.5,0.5)
self.flywheel_cross_transform = rendering.Transform()
flywheel_cross.add_attr(self.flywheel_cross_transform)
self.viewer.add_geom(flywheel_cross)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, .3, .3)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
fname = path.join(path.dirname(__file__), "assets/gears.png")
self.sprocket = rendering.Image(fname, 1, 1)
self.sprocket_trans = rendering.Transform()
self.sprocket.add_attr(self.sprocket_trans)
self.viewer.add_geom(self.sprocket)
self.sprocket_trans.scale = (self.flywheel_diameter/1.6,self.flywheel_diameter/1.8)
# uncomment if you want to have an axle at the opposite end of the rod
# need to comment out equal lines above
#flywheel = rendering.make_circle(0.85,filled=False)
#flywheel.set_linewidth(5)
#flywheel.set_color(0.5,0.5,0.5)
#self.flywheel_transform = rendering.Transform()
#flywheel.add_attr(self.flywheel_transform)
#self.viewer.add_geom(flywheel)
self.viewer.add_onetime(self.img)
theta = self.state[0] + np.pi/2
self.pole_transform.set_rotation(theta)
sprocket_theta_offset = np.pi / 180
sprocket_length_offset = 0.05
self.sprocket_trans.set_translation((l+sprocket_length_offset) * np.cos(theta - sprocket_theta_offset+0.012),
(l+sprocket_length_offset) * np.sin(theta - sprocket_theta_offset))
self.sprocket_trans.set_rotation(theta + np.pi * (2.795))
flywheel_offset = 0
self.flywheel_rim_transform.set_translation(l * np.cos(theta - flywheel_offset), l * np.sin(theta - flywheel_offset))
self.flywheel_rim_transform.set_rotation(theta + np.pi/4)
self.flywheel_cross_transform.set_translation(l * np.cos(theta - flywheel_offset), l * np.sin(theta - flywheel_offset))
self.flywheel_cross_transform.set_rotation(theta + self.rotation_add)
img_offset = np.pi / 180
img_length_offset = 0.15
self.imgtrans.translation = ((l+img_length_offset) * np.cos(theta - img_offset+0.02), (l+img_length_offset) * np.sin(theta - img_offset))
if self.last_u:
self.imgtrans.scale = (-self.last_u/(self.max_torque/2), np.abs(self.last_u)/(self.max_torque/2))
return self.viewer.render(return_rgb_array = mode=='rgb_array')
def render(self, mode='human', close=False):
scale = 6
screen_width = scale * self.width
screen_height = scale * self.height
if self.viewer is None:
#TODO: remove when it works
import importlib
import rendering
importlib.reload(rendering)
self.viewer = rendering.Viewer(screen_width, screen_height)
self.cases = []
for i in range(self.height):
self.cases.append([])
for j in range(self.width):
x0 = i * scale
y0 = j * scale
x1 = (i + 1) * scale
y1 = (j + 1) * scale
case = rendering.FilledPolygon([(y0, x0), (y0, x1),
(y1, x1), (y1, x0)])
self.cases[i].append(case)
self.viewer.add_geom(case)
circle = rendering.make_circle(radius=self.roomba.radius * scale)
circle.set_color(1, 0, 0)
self.circle = circle
direction_circle = rendering.make_circle(
radius=self.roomba.radius * scale / 2) #color?
direction_circle.add_attr(
rendering.Transform(translation=(self.roomba.radius * scale /
2, 0)))
tracker = rendering.Compound([circle, direction_circle])
self.tracker_trans = rendering.Transform()
tracker.add_attr(self.tracker_trans)
self.viewer.add_geom(tracker)
for i in range(self.height):
for j in range(self.width):
if self.room[i, j] == 0:
self.cases[i][j].set_color(1, 1, 1)
elif self.room[i, j] == 1:
self.cases[i][j].set_color(
1 - 0.5 * min(1, self.dirty[i, j]),
1 - 0.5 * min(1, self.dirty[i, j]),
1 - 0.5 * min(1, self.dirty[i, j]))
elif self.room[i, j] == 2:
self.cases[i][j].set_color(0, 0, 0)
elif self.room[i, j] == 3:
self.cases[i][j].set_color(0.5, 0.5, 0)
self.tracker_trans.set_translation(self.roomba.pos[1] * scale,
self.roomba.pos[0] * scale)
self.tracker_trans.set_rotation(self.roomba.direction)
self.circle.set_color(self.roomba.get_life(), 0, 0)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
import rendering
roomw, roomh = 600, 400
scale = roomw / 5400
offx, offy = 100, 50
viewer = rendering.Viewer(roomw + 2 * offx, roomh + 2 * offy)
def int_scale(x):
return int(x * scale)
for x in range(0, roomw + 1, int_scale(1800)):
for y in range(0, roomh + 1, int_scale(1800)):
light = rendering.make_circle(x + offx, y + offy)
light.set_color(1,.8,0)
viewer.add_geom(light)
for _ in range(1000):
viewer.render()
def __init__(self, cx, cy, col=(0, 1, 0), rad=10):
self.start = (cx, cy)
self.end = (cx + rad, cy)
self.rad = rad
self.shape = rendering.make_circle(cx, cy, radius=rad)
self.shape.set_color(*col)
