def setup_geometry(self, env): """ create geoms and transforms for basic agents and landmarks """ # lazy import from multiagent import rendering if getattr(env, "render_dict", None) is not None: return env.render_dict = {} # make geometries and transforms for entity in env.world.entities: name = entity.name geom = rendering.make_circle(entity.size) xform = rendering.Transform() # agent on top, other entity to background alpha = 0.6 if "agent" in name else 0.5 geom.set_color(*entity.color, alpha=alpha) geom.add_attr(xform) env.render_dict[name] = { "geom": geom, "xform": xform, "attach_ent": entity } # VIS: show visual range/receptor field if 'agent' in entity.name and env.show_visual_range: vis_geom = rendering.make_circle(entity.vision_range) vis_geom.set_color(*entity.color, alpha=0.2) vis_xform = rendering.Transform() vis_geom.add_attr(vis_xform) env.render_dict[name+"_vis"] = { "geom": vis_geom, "xform": vis_xform, "attach_ent": entity } # LABEL: display type & numbering prefix = "A" if "agent" in entity.name else "L" idx = int(name.split(" ")[-1]) x = entity.state.p_pos[0] y = entity.state.p_pos[1] label_geom = rendering.Text("{}{}".format(prefix,idx), position=(x,y), font_size=30) label_xform = rendering.Transform() label_geom.add_attr(label_xform) env.render_dict[name+"_label"] = { "geom": label_geom, "xform": label_xform, "attach_ent": entity } # add geoms to viewer for viewer in env.viewers: viewer.geoms = [] for k, d in env.render_dict.items(): viewer.add_geom(d["geom"])
def getNewLine(self, x1, y1, x2, y2): from multiagent import rendering x11 = 100 * x1 y11 = 100 * y1 x22 = 100 * x2 y22 = 100 * y2 m = 20 # 表示每边截掉的长度 if x11 == x22: if y11 > y22: long_line = rendering.Line( (x11 - 5, y11 - m), (x22 - 5, y22 + m)) # move left, r=6 circle = rendering.make_circle(radius=5, res=30) circle_transform = rendering.Transform( translation=(x11 - 5 + 50, y11 - m + 50)) #circle_transform = rendering.Transform(translation=(x11-5,y11-m) elif y11 < y22: long_line = rendering.Line((x11 + 5, y11 + m), (x22 + 5, y22 - m)) # move right circle = rendering.make_circle(radius=5, res=30) circle_transform = rendering.Transform( translation=(x11 + 5 + 50, y11 + m + 50)) #short_line = rendering.Line((x11 + 5 - n_vih1, y11 + m), (x11 + 5 + n_vih1, y11 + m)) else: print('1,It is a point rather than a line') elif y11 == y22: if x11 > x22: long_line = rendering.Line((x11 - m, y11 + 5), (x22 + m, y22 + 5)) # move up circle = rendering.make_circle(radius=5, res=30) circle_transform = rendering.Transform( translation=(x11 - m + 50, y11 + 5 + 50)) #short_line = rendering.Line((x11 - m, y11 + 5 - n_vih1), (x11 - m, y11 + 5 + n_vih1)) elif x11 < x22: long_line = rendering.Line((x11 + m, y11 - 5), (x22 - m, y22 - 5)) # move down circle = rendering.make_circle(radius=5, res=30) circle_transform = rendering.Transform( translation=(x11 + m + 50, y11 - 5 + 50)) #short_line = rendering.Line((x11 + m, y11 - 5 - n_vih1), (x11 + m, y11 - 5 + n_vih1)) else: print('2,It is a point rather than a line') else: print('3,It is not a line') self._transform = rendering.Transform(translation=(50, 50)) long_line.add_attr(self._transform) long_line.set_linewidth(4) self.viewer.add_geom(long_line) # short_line.set_color(0, 0, 0) circle.add_attr(circle_transform) self.viewer.add_geom(circle) newline = [] newline.append(circle) newline.append(long_line) return newline
def _add_geoms_to_viewer(self): black_list = [] # not render agent in its own viewer # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.entities: geom = rendering.make_circle( entity.size ) if 'surface' not in entity.name else rendering.make_polygon_with_hole( entity.poly) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) black_list.append(geom) elif 'surface' in entity.name: geom.set_color(entity.color) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for i, viewer in enumerate(self.viewers): viewer.geoms = [] for geom in self.render_geoms: if geom == black_list[i]: continue viewer.add_geom(geom)
def setup_geometry(self): # lazy import from multiagent import rendering if self.render_dict is not None: return self.render_dict = {} # make geometries and transforms for entity in self.world.entities: name = entity.name geom = rendering.make_circle(entity.size) xform = rendering.Transform() # agent on top, other entity to background alpha = 1.0 if "agent" in name else 0.5 geom.set_color(*entity.color, alpha=alpha) geom.add_attr(xform) self.render_dict[name] = { "geom": geom, "xform": xform, "attach_ent": entity } # LABEL: display type & numbering prefix = "A" if "agent" in entity.name else "L" idx = int(name.split(" ")[-1]) x = entity.state.p_pos[0] y = entity.state.p_pos[1] label_geom = rendering.Text("{}{}".format(prefix, idx), position=(x, y), font_size=30) label_xform = rendering.Transform() label_geom.add_attr(label_xform) self.render_dict[name + "_label"] = { "geom": label_geom, "xform": label_xform, "attach_ent": entity } # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for k, d in self.render_dict.items(): viewer.add_geom(d["geom"])
def _reset_viewers(self): for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = RoadViewer(STATE_W, STATE_H) self.transforms[i] = rendering.Transform()
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: for other in self.world.agents: if other is agent: continue word = '_' message += (other.name + ' to ' + agent.name + ': ' + word + ' ') # print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(800, 800) # 修改显示框大小 # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # 设置显示框 self.viewers[i].set_bounds(-30, +30, -30, +30) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append(self.viewers[i].render(return_rgb_array = mode=='rgb_array')) return results
def render(self): # oberservation radius geom = rendering.make_circle(self.observation_radius) geom.set_color(*self.color, alpha=0.05) xform = rendering.Transform() xform.set_translation(*self.state.p_pos) geom.add_attr(xform) return [geom]
def render(self, mode='human'): from multiagent import rendering if self.viewer is None: self.viewer = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer self.viewer.geoms = [] for geom in self.render_geoms: self.viewer.add_geom(geom) results = [] # update bounds to center around agent cam_range = 1 pos = np.zeros(self.world.dim_p) self.viewer.set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions currentState = [] for e, entity in enumerate(self.world.entities): # 4 self.render_geoms_xform[e].set_translation(*entity.state.p_pos) currentState.append( list(entity.state.p_pos) + list(entity.state.p_vel)) # print(currentState) # render to display or array results.append( self.viewer.render(return_rgb_array=mode == 'rgb_array')) return currentState # trajectory[0] = [allAgentsStates, allAgentsActions, allAgentsRewards, allAgentsNextState], # agentState = [agentPos1, agentPos2, agentVel1
def observation(self, agent, world): # get positions of all entities in this agent's reference frame for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(200, 200) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in world.agents + world.landmarks: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 pos = np.zeros(world.dim_p) self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions for e, entity in enumerate(world.agents + world.landmarks): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append(self.viewers[i].render(return_rgb_array=True)) return np.concatenate(results)
def render(self, mode='human'): for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700,700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0]-cam_range,pos[0]+cam_range,pos[1]-cam_range,pos[1]+cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append(self.viewers[i].render(return_rgb_array = mode=='rgb_array')) return results
def render(self, mode='human'): if self.viewer is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewer = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer self.viewer.geoms = [] for geom in self.render_geoms: self.viewer.add_geom(geom) from multiagent import rendering # update bounds to center around agent if self.world.boundary: self.viewer.set_bounds(self.world.boundary[0][0], self.world.boundary[1][0], self.world.boundary[0][1], self.world.boundary[1][1]) else: cam_range = 1.5 #1 self.viewer.set_bounds(-cam_range, cam_range, -cam_range, cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self): # debug geom = rendering.make_circle(self.size * 2.0) geom.set_color(*self.color, alpha=0.2) xform = rendering.Transform() xform.set_translation(*self.state.p_pos) geom.add_attr(xform) # visual quadrants axis_length = 2 x_axis = rendering.Line(start=(self.state.p_pos[0] - axis_length, self.state.p_pos[1]), end=(self.state.p_pos[0] + axis_length, self.state.p_pos[1])) x_axis.set_color(*self.color, alpha=0.3) y_axis = rendering.Line(start=(self.state.p_pos[0], self.state.p_pos[1] - axis_length), end=(self.state.p_pos[0], self.state.p_pos[1] + axis_length)) y_axis.set_color(*self.color, alpha=0.3) return [geom, x_axis, y_axis]
def render(self, mode='human'): for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for agent in self.world.agents: geom = rendering.make_circle(agent.size) if agent.armed: # render arms radius0 = agent.size * 1.3 radius1 = agent.size * 1.5 aim = rendering.make_polygon([ (np.cos(-.1) * radius1, np.sin(-.1) * radius0), (radius0, 0), (np.cos(.1) * radius1, np.sin(.1) * radius0) ]) geom = rendering.Compound([geom, aim]) xform = rendering.Transform() geom.set_color(*agent.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 pos = np.zeros(self.world.dim_p) self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions for a, agent in enumerate(self.world.agents): xform = self.render_geoms_xform[a] xform.set_translation(*agent.state.p_pos) if agent.state.aim_heading is not None: xform.set_rotation(agent.state.aim_heading) for projectile in self.world.projectiles: geom = rendering.Line(start=tuple(projectile[:2]), end=tuple(projectile[2:])) for viewer in self.viewers: viewer.add_onetime(geom) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(900, 900) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: if 'landmark' in entity.name: geom = rendering.make_circle(entity.size) # xform = rendering.Transform() #eom4 = rendering.make_cone(0.1 + entity.size, [entity.state.p_pos], [entity.state.p_vel]) xform4 = rendering.Transform() # if 'agent' in entity.name: # geom.set_color(*entity.color, alpha=0.5) # # geom4.set_color(*entity.color, alpha=0.5) # geom.set_color(*entity.color) geom.add_attr(xform4) # geom4.add_attr(xform4) self.render_geoms.append(geom) # self.render_geoms_xform.append(xform) # self.render_geoms.append(geom4) self.render_geoms_xform.append(xform4) else: #print(entity.render_vel) geom = rendering.make_circle(entity.size) # xform = rendering.Transform() print(entity.render_vel) #geom4 = rendering.make_cone(0.1 + entity.size, entity.state.p_pos[0],entity.state.p_pos[1], entity.render_vel[0],entity.render_vel[1]) geom4 = rendering.make_circle(0.2 + entity.size, filled=False) xform4 = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) geom4.set_color(*entity.color, alpha=0.5) # geom.set_color(*entity.color) geom.add_attr(xform4) geom4.add_attr(xform4) self.render_geoms.append(geom) # self.render_geoms_xform.append(xform) self.render_geoms.append(geom4) self.render_geoms_xform.append(xform4) # for entity in self.world.entities: # # geom4 = rendering.make_cone(0.1 + entity.size, entity.state.p_pos, # [entity.state.p_vel[0], entity.state.p_vel[1]]) # # # # if 'agent' in entity.name: # geom4.set_color(*entity.color) # # # geom.add_attr(xform) # xform4 = rendering.Transform() # #geom4.add_attr(xform4) # # self.render_geoms.append(geom4) # # self.render_geoms_xform.append(xform) # # self.render_geoms_xform.append(xform4) geom1 = rendering.make_wall(0.5) self.render_geoms.append(geom1) xform1 = rendering.Transform() self.render_geoms_xform.append(xform1) ############################# Environment 1 ############################################################ # geom2 = rendering.make_obstacles(0.1) # self.render_geoms.append(geom2) # xform2 = rendering.Transform() # self.render_geoms_xform.append(xform2) ############################ Environment 2 ############################################################ # geom2, geom3 = rendering.make_obstacles1(0.1) # self.render_geoms.append(geom2) # xform2 = rendering.Transform() # self.render_geoms_xform.append(xform2) # self.render_geoms.append(geom3) # xform3 = rendering.Transform() # self.render_geoms_xform.append(xform3) # geom4 = rendering.make_cone(0.1 + entity.size, entity.state.p_pos[0], entity.state.p_pos[1], # entity.render_vel[0], entity.render_vel[1]) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos vel = self.agents[i].state.p_vel self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions from multiagent import rendering for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) #self.render_geoms[e].add_attr(self.render_geoms_xform[e]) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human', attn=None): # attn: matrix of size (num_agents, num_agents) # if mode == 'human': # alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' # message = '' # for agent in self.world.agents: # for other in self.world.agents: # if other is agent: # continue # if np.all(other.state.c == 0): # word = '_' # else: # word = alphabet[np.argmax(other.state.c)] # message += (other.name + ' to ' + agent.name + ': ' + word + ' ') # print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) self.render_count = len(self.render_geoms) # render attn graph if attn is not None: # initialize render geoms for line for i in range(self.n): for j in range(i + 1, self.n): geom = rendering.Line( start=self.world.agents[i].state.p_pos, end=self.world.agents[j].state.p_pos, linewidth=2) color = (1.0, 0.0, 0.0) alpha = 0 geom.set_color(*color, alpha) xform = rendering.Transform() self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) if attn is not None: self._add_lines(attn) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = self.cam_range if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] self.render_range_geoms = [] self.render_range_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.3) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) #if 'agent' in entity.name and entity.alive: if 'agent' in entity.name: range_geom = rendering.make_circle( self.world.observable_range) range_xform = rendering.Transform() if entity.alive: range_geom.set_color(1, 1, 1, alpha=0.6) else: range_geom.set_color(0.1, 0.1, 0.1, alpha=0) range_geom.add_attr(range_xform) self.render_range_geoms.append(range_geom) self.render_range_geoms_xform.append(range_xform) for wall in self.world.walls: corners = ((wall.axis_pos - 0.5 * wall.width, wall.endpoints[0]), (wall.axis_pos - 0.5 * wall.width, wall.endpoints[1]), (wall.axis_pos + 0.5 * wall.width, wall.endpoints[1]), (wall.axis_pos + 0.5 * wall.width, wall.endpoints[0])) if wall.orient == 'H': corners = tuple(c[::-1] for c in corners) geom = rendering.make_polygon(corners) if wall.hard: geom.set_color(*wall.color) else: geom.set_color(*wall.color, alpha=0.5) self.render_geoms.append(geom) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_range_geoms: viewer.add_geom(geom) for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry color from multiagent import rendering for entity, g in zip(self.world.entities, self.render_geoms): if 'agent' in entity.name: if entity.hold > 0: g.set_color(*entity.color, alpha=0.7) else: g.set_color(*entity.color, alpha=0.3) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) for a, agent in enumerate(self.world.agents): if agent.alive: self.render_range_geoms_xform[a].set_translation( *agent.state.p_pos) self.render_range_geoms[a].set_color(1, 1, 1, alpha=0.6) else: self.render_range_geoms[a].set_color(0.1, 0.1, 0.1, alpha=0) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human', VP_W=700, VP_H=700, print_text=False): if print_text and mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' message_constructed = False for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') message_constructed = True if message_constructed: print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(VP_W, VP_H) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] self.sensor_render_geoms = [] self.sensor_render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) if entity.sensor is not None: v = self._make_receptor_locations( entity, self.world.position_scale) sensor_geom = rendering.make_polygon(v=v, filled=True) sensor_geom.set_color(*entity.color, alpha=0.2) sensor_xform = rendering.Transform() sensor_geom.add_attr(sensor_xform) self.sensor_render_geoms.append(sensor_geom) self.sensor_render_geoms_xform.append(sensor_xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] viewer.sensor_geoms = [] for sensor_geom in self.sensor_render_geoms: viewer.add_geom(sensor_geom) for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos / self.world.position_scale self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation( *(entity.state.p_pos / self.world.position_scale)) if (entity.rwr is not None) and (len(entity.rwr.observers) > 0): one_time_geom = self.viewers[i].draw_circle( radius=entity.size * 1.5, res=30, filled=False) xform = rendering.Transform() xform.set_translation(*(entity.state.p_pos / self.world.position_scale)) one_time_geom.add_attr(xform) one_time_geom.set_color(0.75, 0.25, 0.25) one_time_geom.set_linewidth(5.0) if entity.sensor is not None: self.sensor_render_geoms_xform[e].set_translation( *(entity.state.p_pos / self.world.position_scale)) rotation = np.sign(entity.state.p_vel[1]) * np.arccos( entity.state.p_vel[0] / np.linalg.norm(entity.state.p_vel)) self.sensor_render_geoms_xform[e].set_rotation(rotation) if len(entity.sensor.detections) > 0: self.sensor_render_geoms[e].set_color(0.75, 0.25, 0.25, alpha=0.2) else: self.sensor_render_geoms[e].set_color(*entity.color, alpha=0.2) if print_text: print("Detecions for entity: ", entity.name, entity.sensor.detections) # render expendables for missile in entity.state.missiles_in_flight: one_time_geom = self.viewers[i].draw_circle( radius=missile.size, res=30, filled=False) xform = rendering.Transform() xform.set_translation(*(missile.state.p_pos / self.world.position_scale)) one_time_geom.add_attr(xform) one_time_geom.set_color(*missile.color) one_time_geom.set_linewidth(5.0) # render to display or array results.append(self.viewers[i].render( return_rgb_array=mode == 'rgb_array', VP_W=VP_W, VP_H=VP_H)) return results
def __init__(self, world, env_spec, reset_callback=None, reward_callback=None, observation_callback=None, info_callback=None, done_callback=None, shared_viewer=True): self.world = world self.env_spec = env_spec self.agents = self.world.policy_agents # set required vectorized gym env property self.n = len(world.policy_agents) # scenario callbacks self.reset_callback = reset_callback self.reward_callback = reward_callback self.observation_callback = observation_callback self.info_callback = info_callback self.done_callback = done_callback # environment parameters self.discrete_action_space = True # if true, action is a number 0...N, otherwise action is a one-hot N-dimensional vector self.discrete_action_input = False # if true, even the action is continuous, action will be performed discretely self.force_discrete_action = world.discrete_action if hasattr( world, 'discrete_action') else False # if true, every agent has the same reward self.shared_reward = world.collaborative if hasattr( world, 'collaborative') else False self.time = 0 # configure spaces self.action_space = [] self.observation_space = [] for agent in self.agents: total_action_space = [] # physical action space if self.discrete_action_space: u_action_space = spaces.Discrete(world.dim_p * 2 + 1) else: u_action_space = spaces.Box(low=-agent.u_range, high=+agent.u_range, shape=(world.dim_p, ), dtype=np.float32) if agent.movable: total_action_space.append(u_action_space) # communication action space if self.discrete_action_space: c_action_space = spaces.Discrete(world.dim_c) else: c_action_space = spaces.Box(low=0.0, high=1.0, shape=(world.dim_c, ), dtype=np.float32) if not agent.silent: total_action_space.append(c_action_space) # total action space if len(total_action_space) > 1: # all action spaces are discrete, so simplify to MultiDiscrete action space if all([ isinstance(act_space, spaces.Discrete) for act_space in total_action_space ]): act_space = MultiDiscrete( [[0, act_space.n - 1] for act_space in total_action_space]) else: act_space = spaces.Tuple(total_action_space) self.action_space.append(act_space) else: self.action_space.append(total_action_space[0]) # observation space obs_dim = len(observation_callback(agent, self.world)) self.observation_space.append( spaces.Box(low=-np.inf, high=+np.inf, shape=(obs_dim, ), dtype=np.float32)) agent.action.c = np.zeros(self.world.dim_c) # rendering self.shared_viewer = shared_viewer # import rendering only if needed. TODO Add a global rendering flag from multiagent import rendering # TODO Create a debug flag for this w = self.env_spec.width * 2 + 0.2 h = self.env_spec.height * 2 + 0.2 self.world_bound_geom = rendering.make_polygon([(0, 0), (w, 0), (w, h), (0, h)], False) self.world_bound_geom.set_color(0., 0., 0., alpha=0.3) xform = rendering.Transform() xform.set_translation(-w / 2, -h / 2) self.world_bound_geom.add_attr(xform) if self.shared_viewer: self.viewers = [rendering.Viewer(700, 700)] else: self.viewers = [rendering.Viewer(700, 700) for i in self.n] for i, viewer in enumerate(self.viewers): viewer.cam_range = self.env_spec.zoom self._reset_render()
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] # message += (other.name + ' to ' + agent.name + ': ' + word + ' ') print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] # VIS: show visual range/receptor field self.vis_render_geoms = [] self.vis_render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: # geom.set_color(*entity.color, alpha=0.5) geom.set_color(*entity.color) # agent on top else: # geom.set_color(*entity.color) geom.set_color(*entity.color, alpha=0.5) # entity to background geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # VIS: show visual range/receptor field if 'agent' in entity.name and self.show_visual_range: vis_range = entity.vision_range vis_geom = rendering.make_circle(vis_range) vis_xform = rendering.Transform() vis_geom.set_color(*entity.color, alpha=0.2) vis_geom.add_attr(vis_xform) self.vis_render_geoms.append(vis_geom) self.vis_render_geoms_xform.append(vis_xform) else: self.vis_render_geoms.append(None) self.vis_render_geoms_xform.append(None) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) # VIS: show visual range/receptor field for vis_geom in self.vis_render_geoms: if vis_geom is not None: viewer.add_geom(vis_geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent # cam_range = 1 cam_range = self.cam_range if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos # self.viewers[i].set_bounds(pos[0]-cam_range,pos[0]+cam_range,pos[1]-cam_range,pos[1]+cam_range) self.viewers[i].set_bounds(-cam_range, cam_range, -cam_range, cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # VIS: show visual range/receptor field if self.vis_render_geoms_xform[e] is not None: self.vis_render_geoms_xform[e].set_translation( *entity.state.p_pos) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for i, agent in enumerate(self.world.agents): comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') #print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] #zgy self.render_lines = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) geom_line = rendering.make_line((0, 0), (fire_range, 0)) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) geom_line.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom_line.set_color(*entity.color) geom.add_attr(xform) geom_line.add_attr(xform) self.render_geoms.append(geom) self.render_geoms.append(geom_line) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) for geom_line in self.render_geoms: viewer.add_geom(geom_line) results = [] # zgy agents = self.world.agents for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): my_chi = np.zeros(1) if abs(agents[e].state.p_vel[0]) < 1e-5 and abs( agents[e].state.p_vel[1]) < 1e-5: my_chi[0] = 0 else: my_chi[0] = math.atan2(agents[e].state.p_vel[1], agents[e].state.p_vel[0]) self.render_geoms_xform[e].set_translation(*entity.state.p_pos) self.render_geoms_xform[e].set_rotation(my_chi[0]) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') # if(message is not ''): # print(message) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) # Add debug geoms # TODO This needs to change to the parent -> child render() tree debug_geoms = [] for e, entity in enumerate(self.world.entities): debug_geoms.extend(entity.render()) for i, geom in enumerate(debug_geoms): self.viewers[0].add_onetime(geom) # TODO Add a debug flag self.viewers[0].add_onetime(self.world_bound_geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0], pos[0], pos[1], pos[1]) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human'): for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering from multirobot.environment import rendering as mrrendering self.viewers[i] = mrrendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) # from gym.envs.classic_control import rendering from multiagent import rendering from multirobot.environment import rendering as mrrendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # render fov of vehicles for vehicle in self.world.vehicles: geom = mrrendering.make_fov(vehicle.fov, 30) xform = rendering.Transform() geom.set_color(*vehicle.color, alpha=0.5) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) for i in range(len(self.viewers)): # update bounds to center around agent if self.shared_viewer: self.viewers[i].set_bounds(-self.world.size_x - 1, self.world.size_x + 1, -self.world.size_y - 1, self.world.size_y + 1) else: cam_range = 1 pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # update fov sectors e = len(self.world.entities) for v, vehicle in enumerate(self.world.vehicles): self.render_geoms_xform[e + v].set_translation( *vehicle.state.p_pos) self.render_geoms_xform[e + v].set_rotation( vehicle.state.p_ang) # render to display or array # return image of viewer[0], as [0] consider as global viewer result = self.viewers[0].render(return_rgb_array=(mode == 'rgb_array')) return result
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering print("initialize viewer") self.viewers[i] = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None or self.render_geoms is not None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_attack = [] self.render_geoms_line = [] self.render_geoms_range = [] self.render_geoms_xform = [] self.render_geoms_attack_xform = [] self.render_geoms_line_xform = [] self.render_geoms_range_xform = [] for entity in self.world.entities: if "agent" in entity.name: geom = rendering.make_circle(entity.size) else: geom = rendering.make_polygon([[0.1, -0.1], [0.1, 0.1], [-0.1, 0.1], [-0.1, -0.1]]) xform = rendering.Transform() xform_atk = rendering.Transform() x_form_line = rendering.Transform() # xform_range = rendering.Transform() geom_attack, geom_line, geom_range = None, None, None if 'agent' in entity.name: if entity.num_balloons != 0: geom.set_color(*entity.color, alpha=0.0 + 0.2 * entity.num_balloons) if entity.action.a[0] and entity.action.a[1]: geom_attack = rendering.make_circle(entity.size / 4) geom_attack.add_attr(xform_atk) geom_line = rendering.make_line( (0, 0), (entity.action.a[0] - entity.state.p_pos[0], entity.action.a[1] - entity.state.p_pos[1])) geom_line.add_attr(x_form_line) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms_line.append(geom_line) self.render_geoms_line_xform.append(x_form_line) self.render_geoms_attack.append(geom_attack) self.render_geoms_attack_xform.append(xform_atk) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) for atk_geom in self.render_geoms_attack: if atk_geom: viewer.add_geom(atk_geom) for line_geom in self.render_geoms_line: if line_geom: viewer.add_geom(line_geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) for a, agent in enumerate(self.world.agents): self.render_geoms_attack_xform[a].set_translation( *agent.action.a) for a, agent in enumerate(self.world.agents): self.render_geoms_line_xform[a].set_translation( *agent.state.p_pos) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') #print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700,700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] i = 0 for goal in self.world.goals: geom = rendering.make_circle_with_arrow(goal.size, goal.state.p_pos, goal.state.p_ang, filled=True) geom.set_color(*goal.color, alpha=0.5) xform_goal = rendering.Transform() geom.add_attr(xform_goal) self.render_geoms.append(geom) self.render_geoms_xform.append(xform_goal) for agent in self.world.agents: geom = rendering.make_circle_with_arrow(agent.size, agent.state.p_pos, agent.state.p_ang, filled=True) geom.set_color(*agent.color, alpha=0.5) xform_agent = rendering.Transform() geom.add_attr(xform_agent) self.render_geoms.append(geom) self.render_geoms_xform.append(xform_agent) for human in self.world.humans: geom = rendering.make_circle_with_arrow(human.size, human.pos, human.p_ang, filled=True) geom.set_color(*human.color, alpha=0.5) xform_human = rendering.Transform() geom.add_attr(xform_human) self.render_geoms.append(geom) self.render_geoms_xform.append(xform_human) # for entity in self.world.entities: # #print('position:',entity.state.p_pos) # #print('velocity:',entity.state.p_vel) # #if i < 1: # if i < self.world.num_goals+self.world.num_agents: # # render goal and agent # # print("success") # geom = rendering.make_circle_with_arrow(entity.size, entity.state.p_pos, entity.state.p_ang, filled=True) # #geom = rendering.plot_car(entity.state.p_pos, entity.state.p_ang) # else: # # render obstacle # geom = rendering.make_circle(entity.size) # xform = rendering.Transform() # # if 'agent' in entity.name: # if 'human' in entity.name: # geom.set_color(*entity.color, alpha=0.5) # else: # geom.set_color(*entity.color) # geom.add_attr(xform) # self.render_geoms.append(geom) # self.render_geoms_xform.append(xform) # i = i + 1 # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] # print(len(self.viewers)) for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0]-cam_range,pos[0]+cam_range,pos[1]-cam_range,pos[1]+cam_range) # update geometry positions for g, goal in enumerate(self.world.goals): self.render_geoms_xform[g].set_rotation(goal.state.p_ang) self.render_geoms_xform[g].set_translation(*goal.state.p_pos) for a, agent in enumerate(self.world.agents): L = len(self.world.goals) self.render_geoms_xform[a+L].set_rotation(agent.state.p_ang) self.render_geoms_xform[a+L].set_translation(*agent.state.p_pos) for h, human in enumerate(self.world.humans): l1 = len(self.world.goals) l2 = len(self.world.agents) self.render_geoms_xform[h+l1+l2].set_rotation(human.p_ang) self.render_geoms_xform[h+l1+l2].set_translation(*human.pos) # for e, entity in enumerate(self.world.entities): # if (e < self.world.num_goals+self.world.num_agents): # #print("angle:", entity.state.p_ang) # self.render_geoms_xform[e].set_rotation(entity.state.p_ang) # #print("abc") # self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append(self.viewers[i].render(return_rgb_array = mode=='rgb_array')) return results
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] i = 0 for entity in self.world.entities: if i < 8: #geom = rendering.make_circle_with_arrow(radius= entity.size,p_pos=entity.state.p_pos,filled=False) geom = rendering.make_circle_with_arrow(entity.size, entity.state.p_pos, filled=True) else: geom = rendering.make_circle(entity.size) xform = rendering.Transform() # 6 entities if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) i = i + 1 # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds( pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range, ) # update geometry positions for e, entity in enumerate(self.world.entities): # u if (e < 4): v_angle = np.arctan2(entity.state.p_vel[1], entity.state.p_vel[0]) self.render_geoms_xform[e].set_rotation(v_angle + 1 / 2 * math.pi) if (e >= 4 and e < 8): v_angle = np.arctan2(entity.state.p_vel[1], entity.state.p_vel[0]) self.render_geoms_xform[e].set_rotation(1 / 2 * math.pi + v_angle) self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700,700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) '''UAV = self.world.entities[0] for entity in self.world.entities: # world.entities: if entity.name == 'agent 0': continue else: geom = rendering.make_line(UAV.state.p_pos, entity.state.p_pos) geom.set_color(*entity.color) self.render_geoms.append(geom)''' # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0]-cam_range,pos[0]+cam_range,pos[1]-cam_range,pos[1]+cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) if self.viewers[i].geoms is not None: for line in range(len(self.world.entities), len(self.viewers[i].geoms)): self.viewers[i].geoms.pop() uav_position = self.world.entities[0].state.p_pos '''for l, landmark in enumerate(self.world.landmarks): dis = np.sqrt(np.sum(np.square([uav_position - landmark.state.p_pos]))) if dis <= 0.7: temp = rendering.make_line(uav_position, landmark.state.p_pos) temp.set_color(0, 245, 255) self.viewers[i].geoms.append(temp)''' # render to display or array results.append(self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self, mode='human', close=False): if close: # close any existic renderers for i, viewer in enumerate(self.viewers): if viewer is not None: viewer.close() self.viewers[i] = None return [] if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') # print(message) for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700, 700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] self.comm_geoms = [] for entity in self.world.entities: alpha = 0 if not entity.visible else 1 geom = rendering.make_circle(entity.size) xform = rendering.Transform() entity_comm_geoms = [] if 'agent' in entity.name: geom.set_color(*entity.color, alpha=alpha * 0.5) if not entity.silent: dim_c = self.world.dim_c # make circles to represent communication for ci in range(dim_c): comm = rendering.make_circle(entity.size / dim_c) comm.set_color(1, 1, 1) comm.add_attr(xform) offset = rendering.Transform() comm_size = (entity.size / dim_c) offset.set_translation( ci * comm_size * 2 - entity.size + comm_size, 0) comm.add_attr(offset) entity_comm_geoms.append(comm) else: geom.set_color(*entity.color, alpha=alpha) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) self.comm_geoms.append(entity_comm_geoms) if hasattr(self.world, 'walls'): for wall in self.world.walls: corners = ((wall.axis_pos - 0.5 * wall.width, wall.endpoints[0]), (wall.axis_pos - 0.5 * wall.width, wall.endpoints[1]), (wall.axis_pos + 0.5 * wall.width, wall.endpoints[1]), (wall.axis_pos + 0.5 * wall.width, wall.endpoints[0])) if wall.orient == 'H': corners = tuple(c[::-1] for c in corners) geom = rendering.make_polygon(corners) if wall.hard: geom.set_color(*wall.color) else: geom.set_color(*wall.color, alpha=0.5) self.render_geoms.append(geom) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) for entity_comm_geoms in self.comm_geoms: for geom in entity_comm_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0] - cam_range, pos[0] + cam_range, pos[1] - cam_range, pos[1] + cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): alpha = 0 if not entity.visible else 1 self.render_geoms_xform[e].set_translation(*entity.state.p_pos) if 'agent' in entity.name: self.render_geoms[e].set_color(*entity.color, alpha=alpha * 0.5) if not entity.silent: for ci in range(self.world.dim_c): color = 1 - entity.state.c[ci] self.comm_geoms[e][ci].set_color( color, color, color) else: self.render_geoms[e].set_color(*entity.color, alpha=alpha) # render to display or array results.append( self.viewers[i].render(return_rgb_array=mode == 'rgb_array')) return results
def render(self): # 每条路长road_length=80,同条路上的两车道相距bi_dis=5,两条路之间相距distance=100 from multiagent import rendering if self.viewer is None: self.viewer = rendering.Viewer(600, 600) # 600x600 是画板的长和框 for i in range(4): for j in range(4): rectangle = rendering.make_polyline([(-15, 15), (15, 15), (15, -15), (-15, -15), (-15, 15)]) rect_transform = rendering.Transform( translation=(100 * i + 50, 100 * j + 50)) rectangle.add_attr(rect_transform) self.viewer.add_geom(rectangle) score_label = pyglet.text.Label('0', font_size=8, x=100 * i + 38, y=100 * j + 50, anchor_x='left', anchor_y='center', color=(25, 25, 25, 255)) self.label[i][j] = score_label self.step_count_label = pyglet.text.Label( 'step_count:000', font_name='Times New Roman', font_size=12, x=39, y=100 * 5 - 20, anchor_x='left', anchor_y='center', color=(25, 25, 25, 255)) self.step_total_re_label = pyglet.text.Label( 'step_total_reward:000', font_name='Times New Roman', font_size=12, x=39, y=100 * 5 + 5, anchor_x='left', anchor_y='center', color=(25, 25, 25, 255)) self.total_re_label = pyglet.text.Label( 'total_reward:000', font_name='Times New Roman', font_size=12, x=39, y=100 * 5 + 30, anchor_x='left', anchor_y='center', color=(25, 25, 25, 255)) for x1 in range(4): for y1 in range(3): x2 = x1 y2 = y1 + 1 self.lines[x1][y1][x2][y2] = self.getNewLine( x1, y1, x2, y2) self.lines[x2][y2][x1][y1] = self.getNewLine( x2, y2, x1, y1) for x1 in range(3): for y1 in range(4): x2 = x1 + 1 y2 = y1 self.lines[x1][y1][x2][y2] = self.getNewLine( x1, y1, x2, y2) self.lines[x2][y2][x1][y1] = self.getNewLine( x2, y2, x1, y1) for x1 in range(4): for y1 in range(3): x2 = x1 y2 = y1 + 1 self.updateLine(x1, y1, x2, y2) self.updateLine(x2, y2, x1, y1) for x1 in range(3): for y1 in range(4): x2 = x1 + 1 y2 = y1 self.updateLine(x1, y1, x2, y2) self.updateLine(x2, y2, x1, y1) arr = None win = self.viewer.window win.switch_to() win.dispatch_events() win.clear() for geom in self.viewer.geoms: geom.render() for i in range(4): for j in range(4): self.label[i][j].text = "{}".format(self.nod_rewards[i][j]) self.label[i][j].draw() self.step_count_label.text = "step_count:{}".format(self.count) self.step_count_label.draw() self.step_total_re_label.text = "step_total_reward:{}".format( self.step_total_re) self.step_total_re_label.draw() self.total_re_label.text = "total_reward:{}".format(self.total_re) self.total_re_label.draw() win.flip() return arr
def _render(self, mode='human', close=True): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') # print(message) if close: # close any existic renderers for i,viewer in enumerate(self.viewers): if viewer is not None: viewer.close() self.viewers[i] = None return [] for i in range(len(self.viewers)): # create viewers (if necessary) if self.viewers[i] is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.viewers[i] = rendering.Viewer(700,700) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: geom = rendering.make_circle(entity.size) xform = rendering.Transform() if 'agent' in entity.name: geom.set_color(*entity.color, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) # add geoms to viewer for viewer in self.viewers: viewer.geoms = [] for geom in self.render_geoms: viewer.add_geom(geom) results = [] for i in range(len(self.viewers)): # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewers[i].set_bounds(pos[0]-cam_range, pos[0]+cam_range, pos[1]-cam_range, pos[1]+cam_range) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append(self.viewers[i].render(return_rgb_array = mode=='rgb_array')) return results
def render_whole_field(self, mode='human'): if mode == 'human': alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' message = '' for agent in self.world.agents: comm = [] for other in self.world.agents: if other is agent: continue if np.all(other.state.c == 0): word = '_' else: word = alphabet[np.argmax(other.state.c)] message += (other.name + ' to ' + agent.name + ': ' + word + ' ') # for i in range(len(self.viewers)): # # create viewers (if necessary) # if self.viewers[i] is None: # # import rendering only if we need it (and don't import for headless machines) # #from gym.envs.classic_control import rendering # from multiagent import rendering # self.viewers[i] = rendering.Viewer(700,700) if self.viewer is None: from multiagent import rendering self.viewer = rendering.Viewer(53 * 7, 120 * 7) # create rendering geometry if self.render_geoms is None: # import rendering only if we need it (and don't import for headless machines) #from gym.envs.classic_control import rendering from multiagent import rendering self.render_geoms = [] self.render_geoms_xform = [] for entity in self.world.entities: size = 2 * entity.size # if entity.position == 'q_back': # size = 2*size geom = rendering.make_circle(size) xform = rendering.Transform() if 'q_back' == entity.position: geom.set_color(0, 1, 0, alpha=0.5) else: geom.set_color(*entity.color) geom.add_attr(xform) self.render_geoms.append(geom) self.render_geoms_xform.append(xform) self.viewer.geoms = [] for geom in self.render_geoms: self.viewer.add_geom(geom) line_of_scrimmage = self.world.line_of_scrimmage first_down_line = line_of_scrimmage + self.world.first_down_line self.viewer.draw_line((0, line_of_scrimmage), (53, line_of_scrimmage)) self.viewer.draw_line((0, first_down_line), (53, first_down_line)) results = [] from multiagent import rendering # update bounds to center around agent cam_range = 1 if self.shared_viewer: pos = np.zeros(self.world.dim_p) else: pos = self.agents[i].state.p_pos self.viewer.set_bounds(0, 53, 0, 120) # update geometry positions for e, entity in enumerate(self.world.entities): self.render_geoms_xform[e].set_translation(*entity.state.p_pos) # render to display or array results.append( self.viewer.render(return_rgb_array=mode == 'rgb_array')) return results