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)
# ipdb.set_trace()
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(400, 400)
# create rendering geometry
# NOTE: this is true only for the first time render function is called
# to modify rendering (removing obstacles or robots), you need to remove
# geom from self.render_geoms
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:
# ugly hack to determine obstacles
# NOTE: this if statement is never called as of now
if hasattr(entity, "vertices"):
geom = rendering.make_polygon(entity.vertices)
else:
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
if 'agent' in entity.name:
geom.set_color(*entity.color, alpha=1.0)
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', 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)):
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 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)
# 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)
# delete lines in last render
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()
self.count_line_landmark = 0
# build new lines for render
for a, agent in enumerate(
self.world.agents): # between agents and landmarks
for l, landmark in enumerate(self.world.landmarks):
dis = np.sqrt(
np.sum(
np.square(
[agent.state.p_pos - landmark.state.p_pos])))
if dis <= self.world.observing_range:
self.count_line_landmark += 1
temp = rendering.make_line(agent.state.p_pos,
landmark.state.p_pos)
temp.set_color(0, 245, 255)
self.viewers[i].geoms.append(temp)
self.count_line_other = 0
for a, agent in enumerate(
self.world.agents): # between agents and agents
for o, other in enumerate(self.world.agents):
if other is agent:
continue
dis = np.sqrt(
np.sum(
np.square([agent.state.p_pos - other.state.p_pos
])))
if dis <= self.world.observing_range:
self.count_line_other += 1
temp = rendering.make_line(agent.state.p_pos,
other.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=True):
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:
geom = rendering.make_circle(entity.size)
xform = rendering.Transform()
entity_comm_geoms = []
if 'agent' in entity.name:
geom.set_color(*entity.color, 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)
geom.add_attr(xform)
self.render_geoms.append(geom)
self.render_geoms_xform.append(xform)
self.comm_geoms.append(entity_comm_geoms)
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):
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=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)
# render to display or array
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
def render(self,
mode='human',
window_size=None,
dynamic_render=False,
grid_mode=False):
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
if window_size is not None:
self.viewers[i] = rendering.Viewer(*window_size)
else:
if grid_mode:
self.viewers[i] = rendering.Viewer(
self.world.width * self.world.unit[0],
self.world.height * self.world.unit[1])
else:
self.viewers[i] = rendering.Viewer(
self.world.width, self.world.height)
# create rendering geometry
# if self.render_geoms is None:
# ========== draw horizon lines
# from multiagent import renderin
if self.render_geoms is None or dynamic_render:
# 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 = []
VIEW_BOUNDER = 2
if grid_mode:
grid_size = self.world.unit[0]
for i in range(0, self.world.height):
start = (-1.,
i * self.world.unit[1] * self.world.ratio[1] - 1.)
end = (1., start[1])
# geom = self.viewer.draw_line(start, end)
geom = rendering.Line(start, end)
# self.viewers[0].add_geom(geom)
self.render_geoms.append(geom)
# draw vertical lines
for i in range(0, self.world.width):
start = (i * self.world.unit[0] * self.world.ratio[0] - 1.,
1.)
end = (start[0], -1)
# geom = self.viewer.draw_line(start, end)
geom = rendering.Line(start, end)
# self.viewers[0].add_geom(geom)
self.render_geoms.append(geom)
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)
# viewer.add_onetime(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):
# print("len of geoms", len(self.render_geoms_xform), len(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
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:
# for i, t in enumerate(agent.trajectory):
# if i % 2: continue
# geom = rendering.make_circle(0.02, filled=True)
# xform = rendering.Transform()
# geom.set_color(*agent.color, alpha=0.1)
# geom.add_attr(xform)
# self.render_geoms.append(geom)
# xform.set_translation(*t)
# self.render_geoms_xform.append(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.6)
else:
geom.set_color(*entity.color, alpha=0.4)
geom.add_attr(xform)
self.render_geoms.append(geom)
xform.set_translation(*entity.state.p_pos)
self.render_geoms_xform.append(xform)
# orientation
if 'agent' in entity.name:
xform_rot = rendering.Transform()
geom_range = rendering.make_circle(0.02, filled=True)
geom_range.set_color(0, 0, 0, alpha=0.8)
geom_range.add_attr(xform_rot)
xform_rot.set_translation(*(entity.state.p_pos +
entity.size * entity.state.p_rot))
self.render_geoms.append(geom_range)
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 = 10
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'):
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
from multirobot 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)
results = []
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
results.append(
self.viewers[i].render(return_rgb_array=mode == 'rgb_array'))
return results
