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