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 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 s = self.state if self.viewer is None: self.viewer = rendering.Viewer(500, 500) bound = self.LINK_LENGTH_1 + self.LINK_LENGTH_2 + 0.2 # 2.2 for default self.viewer.set_bounds(-bound, bound, -bound, bound) if s is None: return None p1 = [-self.LINK_LENGTH_1 * cos(s[0]), self.LINK_LENGTH_1 * sin(s[0])] p2 = [ p1[0] - self.LINK_LENGTH_2 * cos(s[0] + s[1]), p1[1] + self.LINK_LENGTH_2 * sin(s[0] + s[1]) ] xys = np.array([[0, 0], p1, p2])[:, ::-1] thetas = [s[0] - pi / 2, s[0] + s[1] - pi / 2] link_lengths = [self.LINK_LENGTH_1, self.LINK_LENGTH_2] self.viewer.draw_line((-2.2, 1), (2.2, 1)) for ((x, y), th, llen) in zip(xys, thetas, link_lengths): l, r, t, b = 0, llen, .1, -.1 jtransform = rendering.Transform(rotation=th, translation=(x, y)) link = self.viewer.draw_polygon([(l, b), (l, t), (r, t), (r, b)]) link.add_attr(jtransform) link.set_color(0, .8, .8) circ = self.viewer.draw_circle(.1) circ.set_color(.8, .8, 0) circ.add_attr(jtransform) 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'): 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 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'): if self.viewer is None: import rendering block_size = self.window // (self.dim + 1) border_size = (self.window - self.dim * block_size) // 2 self.viewer = rendering.Viewer(self.window, self.window) border = rendering.Border(self.window, self.window, border_size, BORDER_COLOR) self.plotter = rendering.Plotter(self.window, self.window, border_size, self.dim, self.dim) self.viewer.add_geom(border) self.viewer.add_geom(self.plotter) self.transform = rendering.Transform() return_rgb_array = (mode == 'rgb_array') self.plotter.update_points(self.plot_sparse) return self.viewer.render(return_rgb_array)
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'): # global viewer q_1, q_2, dq_1, dq_2 = self.state if self.viewer is None: self.viewer = rendering.Viewer(500, 500) bound = self.l_1 + self.l_2 + 0.2 self.viewer.set_bounds(-bound, bound, -bound, bound) # p1 = [-l_1[None] * np.cos(q_1[t]), l_1[None] * np.sin(q_1[t])] p1 = [self.l_1 * np.cos(q_1), self.l_1 * np.sin(q_1)] p2 = [ p1[0] - self.l_2 * np.cos(q_1 + q_2), p1[1] + self.l_2 * np.sin(q_1 + q_2) ] xys = np.array([[0, 0], p1, p2]) # [:,::-1] thetas = [q_1, q_1 + q_2] # thetas = [q_1[t] - np.pi/2, q_1[t] + q_2[t] - np.pi/2] link_lengths = [self.l_1, self.l_2] self.viewer.draw_line((-2.2, 1), (2.2, 1)) for ((x, y), th, llen) in zip(xys, thetas, link_lengths): l, r, t, b = 0, llen, .1, -.1 jtransform = rendering.Transform(rotation=th, translation=(x, y)) link = self.viewer.draw_polygon([(l, b), (l, t), (r, t), (r, b)]) link.add_attr(jtransform) link.set_color(0, .8, .8) circ = self.viewer.draw_circle(.1) circ.set_color(.8, .8, 0) circ.add_attr(jtransform) return self.viewer.render(return_rgb_array=mode == 'rgb_array')
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')
def render(self, mode='human'): screen_width = 800 screen_height = 500 world_width = self.width scale = screen_width / world_width # Function to make box obstacles def make_obstacle(obstacle): l, r, t, b = obstacle.l, obstacle.r, obstacle.t, obstacle.b obstacle = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) return obstacle def make_zone(zone, color): l, r, t, b = zone zone = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) zone.set_color(color[0], color[1], color[2]) return zone # Creates viewer object, robots, and obstacles if self.viewer is None: self.viewer = rendering.Viewer(screen_width, screen_height) # Add starting zones self.viewer.add_geom(make_zone(self.team1_start, [0, 0, 0.5])) self.viewer.add_geom(make_zone(self.team2_start, [0.5, 0, 0])) # Add bonus zone self.viewer.add_geom(make_zone(self.bonus_bounds, [0.8, 0.8, 0])) # Add robot geometry l, r, t, b = -self.robot.width / 2, self.robot.width / 2, -self.robot.length / 2, self.robot.length / 2 robot = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) robot.set_color(0, 0, 1) self.robot_trans = rendering.Transform() robot.add_attr(self.robot_trans) l, r, t, b = -self.robot.gun_width / 2, self.robot.gun_width / 2, -self.robot.gun_width / 2, self.robot.gun_length - self.robot.gun_width / 2 robot_gun = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) self.robot_guntrans = rendering.Transform() robot_gun.add_attr(self.robot_guntrans) self.viewer.add_geom(robot) self.viewer.add_geom(robot_gun) # Add enemy geometry l, r, t, b = -self.enemy.width / 2, self.enemy.width / 2, -self.enemy.length / 2, self.enemy.length / 2 enemy = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) enemy.set_color(1, 0, 0) self.enemy_trans = rendering.Transform() enemy.add_attr(self.enemy_trans) l, r, t, b = -self.enemy.gun_width / 2, self.enemy.gun_width / 2, -self.enemy.gun_width / 2, self.enemy.gun_length - self.enemy.gun_width / 2 enemy_gun = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) self.enemy_guntrans = rendering.Transform() enemy_gun.add_attr(self.enemy_guntrans) self.viewer.add_geom(enemy) self.viewer.add_geom(enemy_gun) # Add obstacles for obstacle in self.obstacles: self.viewer.add_geom(make_obstacle(obstacle)) if self.state is None: return None x = self.state # Render location for robot robotx, roboty = x[0] * scale, x[1] * scale gun_angle = x[2] * np.pi / 180 self.robot_trans.set_translation(robotx, roboty) self.robot_trans.set_rotation((self.robot.angle - 90) * np.pi / 180) self.robot_guntrans.set_translation(robotx, roboty) self.robot_guntrans.set_rotation(gun_angle) # Render location for enemy enemyx, enemyy = x[3] * scale, x[4] * scale enemy_gun_angle = x[5] * np.pi / 180 self.enemy_trans.set_translation(enemyx, enemyy) self.enemy_guntrans.set_translation(enemyx, enemyy) self.enemy_guntrans.set_rotation(enemy_gun_angle) return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self): screen_width = MAZE_W * UNIT screen_height = MAZE_H * UNIT offset = np.array([UNIT / 2, UNIT / 2]) if self.viewer is None: import rendering self.viewer = rendering.Viewer(screen_width, screen_height) for c in range(0, MAZE_W * UNIT, UNIT): x0, y0, x1, y1 = c, 0, c, MAZE_H * UNIT self.viewer.add_geom(rendering.Line((x0, y0), (x1, y1))) for r in range(0, MAZE_H * UNIT, UNIT): x0, y0, x1, y1, = 0, r, MAZE_W * UNIT, r self.viewer.add_geom(rendering.Line((x0, y0), (x1, y1))) hell1_center = offset + self.hell1_coord * UNIT hell1 = rendering.FilledPolygon([ (-BLOCK_SIZE / 2, -BLOCK_SIZE / 2), (-BLOCK_SIZE / 2, BLOCK_SIZE / 2), (BLOCK_SIZE / 2, BLOCK_SIZE / 2), (BLOCK_SIZE / 2, -BLOCK_SIZE / 2) ]) hell1trans = rendering.Transform() hell1.add_attr(hell1trans) hell1trans.set_translation(hell1_center[0], MAZE_H * UNIT - hell1_center[1]) self.viewer.add_geom(hell1) # hell2_center = offset + self.hell2_coord * UNIT # hell2 = rendering.FilledPolygon([(-BLOCK_SIZE/2, -BLOCK_SIZE/2), (-BLOCK_SIZE/2, BLOCK_SIZE/2), (BLOCK_SIZE/2, BLOCK_SIZE/2), (BLOCK_SIZE/2, -BLOCK_SIZE/2)]) # hell2trans = rendering.Transform() # hell2.add_attr( hell2trans ) # hell2trans.set_translation( hell2_center[0], MAZE_H * UNIT - hell2_center[1] ) # self.viewer.add_geom( hell2 ) goal_center = offset + self.goal_coord * UNIT goal = rendering.FilledPolygon([(-BLOCK_SIZE / 2, -BLOCK_SIZE / 2), (-BLOCK_SIZE / 2, BLOCK_SIZE / 2), (BLOCK_SIZE / 2, BLOCK_SIZE / 2), (BLOCK_SIZE / 2, -BLOCK_SIZE / 2)]) goal.set_color(1., 1., 0.) goaltrans = rendering.Transform() goal.add_attr(goaltrans) goaltrans.set_translation(goal_center[0], MAZE_H * UNIT - goal_center[1]) self.viewer.add_geom(goal) agent = rendering.FilledPolygon([ (-BLOCK_SIZE / 2, -BLOCK_SIZE / 2), (-BLOCK_SIZE / 2, BLOCK_SIZE / 2), (BLOCK_SIZE / 2, BLOCK_SIZE / 2), (BLOCK_SIZE / 2, -BLOCK_SIZE / 2) ]) agent.set_color(1., 0., 0.) self.agenttrans = rendering.Transform() agent.add_attr(self.agenttrans) self.viewer.add_geom(agent) agent_center = offset + self.agent_coord * UNIT self.agenttrans.set_translation(agent_center[0], MAZE_H * UNIT - agent_center[1]) return self.viewer.render(return_rgb_array=False)