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