def __init__(self, a, outputDir, nagents, color='#FF004D'): # very red purple
self.a = a
self.n = a.order() # number of nodes
self.m = a.size() # number of links
self.latmax = max([self.a.node[i]['geo'][0] for i in self.a.node.keys()]) * 180. / np.pi
self.latmin = min([self.a.node[i]['geo'][0] for i in self.a.node.keys()]) * 180. / np.pi
self.lonmax = max([self.a.node[i]['geo'][1] for i in self.a.node.keys()]) * 180. / np.pi
self.lonmin = min([self.a.node[i]['geo'][1] for i in self.a.node.keys()]) * 180. / np.pi
self.loncenter = (self.lonmax - self.lonmin) / 2. + self.lonmin
self.latcenter = (self.latmax - self.latmin) / 2. + self.latmin
#print "Center", self.latcenter, self.loncenter
self.nagents = nagents
self.outputDir = outputDir
self.color = color
self.colorLetter = 'b'
if color == GREEN:
self.colorLetter = 'g'
# if the ith link to be made is (p,q) then orderedEdges[i] = (p,q)
self.orderedEdges = [None] * self.m
for e in a.edges_iter():
self.orderedEdges[a.edge[e[0]][e[1]]['order']] = e
# movements[i][j] is the index (in orderedEdges) of agent i's jth link
self.movements = agentOrder.getAgentOrder(a, nagents, self.orderedEdges)
# link2agent[i] is the agent that will make the ith link
self.link2agent = [-1] * self.m
for i in range(nagents):
for e in self.movements[i]:
self.link2agent[e] = i
# keyneeds[i,j] = number of keys agent i needs for portal j
self.agentkeyneeds = np.zeros([self.nagents,self.n],dtype=int)
for i in xrange(self.nagents):
for e in self.movements[i]:
p, q = self.orderedEdges[e]
self.agentkeyneeds[i][q] += 1
self.names = np.array([a.node[i]['name'] for i in xrange(self.n)])
# The alphabetical order
self.nameOrder = np.argsort(self.names)
self.xy = np.array([self.a.node[i]['xy'] for i in xrange(self.n)])
# The order from north to south (for easy-to-find labels)
self.posOrder = np.argsort(self.xy,axis=0)[::-1,1]
# The inverse permutation of posOrder
self.nslabel = [-1]*self.n
for i in xrange(self.n):
self.nslabel[self.posOrder[i]] = i
self.maxNameLen = max([len(a.node[i]['name']) for i in xrange(self.n)])
self.num_portals = self.n
self.num_links = self.m
self.num_fields = -1
def compute_time_attributes(a, nagents):
# By agentOrder.getAgentOrder function ...
m = a.size() # number of links
# if the ith link to be made is (p,q) then orderedEdges[i] = (p,q)
orderedEdges = [None] * m
for e in a.edges():
orderedEdges[a.edges[e[0], e[1]]['order']] = e
# movements[i][j] is the index (in orderedEdges) of agent i's jth link
movements = agentOrder.getAgentOrder(a, nagents, orderedEdges)
def __init__(self, a, outputDir, nagents, color='#FF004D'):
self.a = a
self.n = a.order() # number of nodes
self.m = a.size() # number of links
self.nagents = nagents
self.outputDir = outputDir
self.color = color
# if the ith link to be made is (p,q) then orderedEdges[i] = (p,q)
self.orderedEdges = [None] * self.m
for e in a.edges():
self.orderedEdges[a.edges[e[0], e[1]]['order']] = e
# movements[i][j] is the index (in orderedEdges) of agent i's jth link
self.movements = agentOrder.getAgentOrder(a, nagents,
self.orderedEdges)
# link2agent[i] is the agent that will make the ith link
self.link2agent = [-1] * self.m
for i in range(nagents):
for e in self.movements[i]:
self.link2agent[e] = i
# keyneeds[i,j] = number of keys agent i needs for portal j
self.agentkeyneeds = np.zeros([self.nagents, self.n], dtype=int)
for i in xrange(self.nagents):
for e in self.movements[i]:
p, q = self.orderedEdges[e]
self.agentkeyneeds[i][q] += 1
self.names = np.array([a.node[i]['name'] for i in xrange(self.n)])
# The alphabetical order
makeLowerCase = np.vectorize(lambda s: s.lower())
self.nameOrder = np.argsort(makeLowerCase(self.names))
self.xy = np.array([self.a.node[i]['xy'] for i in xrange(self.n)])
# print self.xy
# The order from north to south (for easy-to-find labels)
self.posOrder = np.argsort(self.xy, axis=0)[::-1, 1]
# The inverse permutation of posOrder
self.nslabel = [-1] * self.n
for i in xrange(self.n):
self.nslabel[self.posOrder[i]] = i
self.maxNameLen = max([len(a.node[i]['name']) for i in xrange(self.n)])
# total stats for this plan
self.num_portals = self.n
self.num_links = self.m
self.num_fields = 0
def __init__(self,a,outputDir,nagents,color='#FF004D'):
self.a = a
self.n = a.order() # number of nodes
self.m = a.size() # number of links
self.nagents = nagents
self.outputDir = outputDir
self.color = color
# if the ith link to be made is (p,q) then orderedEdges[i] = (p,q)
self.orderedEdges = [None]*self.m
for e in a.edges_iter():
self.orderedEdges[a.edge[e[0]][e[1]]['order']] = e
# movements[i][j] is the index (in orderedEdges) of agent i's jth link
self.movements = agentOrder.getAgentOrder(a,nagents,self.orderedEdges)
# link2agent[i] is the agent that will make the ith link
self.link2agent = [-1]*self.m
for i in range(nagents):
for e in self.movements[i]:
self.link2agent[e] = i
# keyneeds[i,j] = number of keys agent i needs for portal j
self.agentkeyneeds = np.zeros([self.nagents,self.n],dtype=int)
for i in xrange(self.nagents):
for e in self.movements[i]:
p,q = self.orderedEdges[e]
self.agentkeyneeds[i][q] += 1
self.names = np.array([a.node[i]['name'] for i in xrange(self.n)])
# The alphabetical order
makeLowerCase = np.vectorize(lambda s: s.lower())
self.nameOrder = np.argsort(makeLowerCase(self.names))
self.xy = np.array([self.a.node[i]['xy'] for i in xrange(self.n)])
# The order from north to south (for easy-to-find labels)
self.posOrder = np.argsort(self.xy,axis=0)[::-1,1]
# The inverse permutation of posOrder
self.nslabel = [-1]*self.n
for i in xrange(self.n):
self.nslabel[self.posOrder[i]] = i
self.maxNameLen = max([len(a.node[i]['name']) for i in xrange(self.n)])
def __init__(self,a,outputDir,nagents,color='#FF004D',useGoogle=False,api_key=None):
self.a = a
self.n = a.order() # number of nodes
self.m = a.size() # number of links
self.nagents = nagents
self.outputDir = outputDir
self.color = color
# if the ith link to be made is (p,q) then orderedEdges[i] = (p,q)
self.orderedEdges = [None]*self.m
for e in a.edges_iter():
self.orderedEdges[a.edge[e[0]][e[1]]['order']] = e
# movements[i][j] is the index (in orderedEdges) of agent i's jth link
self.movements = agentOrder.getAgentOrder(a,nagents,self.orderedEdges)
# link2agent[i] is the agent that will make the ith link
self.link2agent = [-1]*self.m
for i in range(nagents):
for e in self.movements[i]:
self.link2agent[e] = i
# keyneeds[i,j] = number of keys agent i needs for portal j
self.agentkeyneeds = np.zeros([self.nagents,self.n],dtype=int)
for i in xrange(self.nagents):
for e in self.movements[i]:
p,q = self.orderedEdges[e]
self.agentkeyneeds[i][q] += 1
self.names = np.array([a.node[i]['name'] for i in xrange(self.n)])
# The alphabetical order
self.nameOrder = np.argsort(self.names)
self.xy = np.array([self.a.node[i]['xy'] for i in xrange(self.n)])
# The order from north to south (for easy-to-find labels)
self.posOrder = np.argsort(self.xy,axis=0)[::-1,1]
# The inverse permutation of posOrder
self.nslabel = [-1]*self.n
for i in xrange(self.n):
self.nslabel[self.posOrder[i]] = i
self.maxNameLen = max([len(a.node[i]['name']) for i in xrange(self.n)])
# total stats for this plan
self.num_portals = self.n
self.num_links = self.m
self.num_fields = -1
if useGoogle:
# coordinates needed for google maps
latmax = np.rad2deg(max([self.a.node[i]['geo'][0] for i in self.a.node.keys()]))
latmin = np.rad2deg(min([self.a.node[i]['geo'][0] for i in self.a.node.keys()]))
lonmax = np.rad2deg(max([self.a.node[i]['geo'][1] for i in self.a.node.keys()]))
lonmin = np.rad2deg(min([self.a.node[i]['geo'][1] for i in self.a.node.keys()]))
loncenter = (lonmax-lonmin)/2. + lonmin
latcenter = (latmax-latmin)/2. + latmin
print "Center Coordinates (lat,lon): ",latcenter,loncenter
xmin = self.xy[:,0].min()*1.1
xmax = self.xy[:,0].max()*1.1
ymin = self.xy[:,1].min()*1.1
ymax = self.xy[:,1].max()*1.1
# determine zoom for google maps
self.xylims = np.array([xmin,xmax,ymin,ymax])
map_ywidth = 640.
platescale = (ymax-ymin)/map_ywidth
map_xwidth = (xmax-xmin) / platescale
zoom = math.log(map_ywidth/(latmax-latmin),2)
# update so zoom is an integer
zoom = round(zoom)
map_ywidth = (latmax-latmin) * 2.**zoom
platescale = (ymax-ymin)/map_ywidth
map_xwidth = (xmax-xmin)/platescale
# now we need xwidth,ywidth < 640.
while map_xwidth > 640. or map_ywidth > 640.:
zoom = zoom - 1
map_ywidth = (latmax-latmin) * 2.**zoom
platescale = (ymax-ymin)/map_ywidth
map_xwidth = (xmax-xmin)/platescale
# turn things in to integers for maps API
map_xwidth = int(map_xwidth)
map_ywidth = int(map_ywidth)
zoom = int(zoom)
# google maps API
# get API key
if api_key is not None:
url = "http://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size={2}x{3}&zoom={4}&sensor=false&key={5}".format(latcenter,loncenter,map_xwidth,map_ywidth,zoom,api_key)
else:
url = "http://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size={2}x{3}&zoom={4}&sensor=false".format(latcenter,loncenter,map_xwidth,map_ywidth,zoom)
# determine if we can use google maps
self.google_image = None
try:
buffer = StringIO(urllib2.urlopen(url).read())
self.google_image = Image.open(buffer)
plt.clf()
except urllib2.URLError as err:
print("Could not connect to google maps server!")
def __init__(self,
a,
outputDir,
nagents,
color='#FF004D',
useGoogle=False,
api_key=None):
self.a = a
self.n = a.order() # number of nodes
self.m = a.size() # number of links
self.nagents = nagents
self.outputDir = outputDir
self.color = color
# if the ith link to be made is (p,q) then orderedEdges[i] = (p,q)
self.orderedEdges = [None] * self.m
for e in a.edges_iter():
self.orderedEdges[a.edge[e[0]][e[1]]['order']] = e
# movements[i][j] is the index (in orderedEdges) of agent i's jth link
self.movements = agentOrder.getAgentOrder(a, nagents,
self.orderedEdges)
# link2agent[i] is the agent that will make the ith link
self.link2agent = [-1] * self.m
for i in range(nagents):
for e in self.movements[i]:
self.link2agent[e] = i
# keyneeds[i,j] = number of keys agent i needs for portal j
self.agentkeyneeds = np.zeros([self.nagents, self.n], dtype=int)
for i in xrange(self.nagents):
for e in self.movements[i]:
p, q = self.orderedEdges[e]
self.agentkeyneeds[i][q] += 1
self.names = np.array([a.node[i]['name'] for i in xrange(self.n)])
# The alphabetical order
makeLowerCase = np.vectorize(lambda s: s.lower())
self.nameOrder = np.argsort(makeLowerCase(self.names))
self.xy = np.array([self.a.node[i]['xy'] for i in xrange(self.n)])
# print self.xy
# The order from north to south (for easy-to-find labels)
self.posOrder = np.argsort(self.xy, axis=0)[::-1, 1]
# The inverse permutation of posOrder
self.nslabel = [-1] * self.n
for i in xrange(self.n):
self.nslabel[self.posOrder[i]] = i
self.maxNameLen = max([len(a.node[i]['name']) for i in xrange(self.n)])
# total stats for this plan
self.num_portals = self.n
self.num_links = self.m
self.num_fields = 0
if useGoogle:
# convert xy coordinates to web mercator
x_merc = np.array([
128. / np.pi * (self.a.node[i]['geo'][1] + np.pi)
for i in self.a.node.keys()
])
min_x_merc = np.min(x_merc)
#print "min_x_merc",min_x_merc
x_merc = x_merc - min_x_merc
#print "Xmin, Xmax",np.min(x_merc),np.max(x_merc)
y_merc = np.array([
128. / np.pi *
(np.pi -
np.log(np.tan(np.pi / 4. + self.a.node[i]['geo'][0] / 2.)))
for i in self.a.node.keys()
])
min_y_merc = np.min(y_merc)
#print "min_y_merc",min_y_merc
y_merc = y_merc - min_y_merc
#print "Ymin, Ymax",np.min(y_merc),np.max(y_merc)
# determine proper zoom such that the map is smaller than 640 on both sides
zooms = np.arange(0, 20, 1)
largest_x_zoom = 0
largest_y_zoom = 0
for zm in zooms:
#print "X max",np.max(x_merc * 2.**zm + 20.)
#print "Y max",np.max(y_merc * 2.**zm + 20.)
if np.max(x_merc * 2.**zm) < 256.:
largest_x_zoom = zm
#print "X",largest_x_zoom
if np.max(y_merc * 2.**zm) < 256.:
largest_y_zoom = zm
#print "Y",largest_y_zoom
zoom = np.min([largest_x_zoom, largest_y_zoom])
min_x_merc = min_x_merc * 2.**(1 + zoom)
min_y_merc = min_y_merc * 2.**(1 + zoom)
self.xy[:, 0] = x_merc * 2.**(1 + zoom)
self.xy[:, 1] = y_merc * 2.**(1 + zoom)
for i in xrange(self.n):
self.a.node[i]['xy'] = self.xy[i]
xsize = np.max(self.xy[:, 0]) + 20
ysize = np.max(self.xy[:, 1]) + 20
self.xylims = [-10, xsize - 10, ysize - 10, -10]
# coordinates needed for google maps
loncenter = np.rad2deg((min_x_merc + xsize / 2. - 10.) * np.pi /
(128. * 2.**(zoom + 1)) - np.pi)
latcenter = np.rad2deg(2. * np.arctan(
np.exp(-1. * ((min_y_merc + ysize / 2. - 10.) * np.pi /
(128. * 2.**(zoom + 1)) - np.pi))) - np.pi / 2.)
#latmax = np.rad2deg(max([self.a.node[i]['geo'][0] for i in self.a.node.keys()]))
#latmin = np.rad2deg(min([self.a.node[i]['geo'][0] for i in self.a.node.keys()]))
#lonmax = np.rad2deg(max([self.a.node[i]['geo'][1] for i in self.a.node.keys()]))
#lonmin = np.rad2deg(min([self.a.node[i]['geo'][1] for i in self.a.node.keys()]))
#loncenter = (lonmax-lonmin)/2. + lonmin
#latcenter = (latmax-latmin)/2. + latmin
#print "Center Coordinates (lat,lon): ",latcenter,loncenter
# turn things in to integers for maps API
map_xwidth = int(xsize)
map_ywidth = int(ysize)
zoom = int(zoom) + 1
# google maps API
# get API key
if api_key is not None:
url = "http://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size={2}x{3}&zoom={4}&sensor=false&key={5}".format(
latcenter, loncenter, map_xwidth, map_ywidth, zoom,
api_key)
else:
url = "http://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size={2}x{3}&zoom={4}&sensor=false".format(
latcenter, loncenter, map_xwidth, map_ywidth, zoom)
#print url
# determine if we can use google maps
self.google_image = None
try:
buffer = StringIO(urllib2.urlopen(url).read())
self.google_image = Image.imread(buffer)
plt.clf()
except urllib2.URLError as err:
print("Could not connect to google maps server!")
def __init__(self,
a,
outputDir,
nagents,
color='#FF004D',
useGoogle=False,
api_key=None):
self.a = a
self.n = a.order() # number of nodes
self.m = a.size() # number of links
self.nagents = nagents
self.outputDir = outputDir
self.color = color
# if the ith link to be made is (p,q) then orderedEdges[i] = (p,q)
self.orderedEdges = [None] * self.m
for e in a.edges_iter():
self.orderedEdges[a.edge[e[0]][e[1]]['order']] = e
# movements[i][j] is the index (in orderedEdges) of agent i's jth link
self.movements = agentOrder.getAgentOrder(a, nagents,
self.orderedEdges)
# link2agent[i] is the agent that will make the ith link
self.link2agent = [-1] * self.m
for i in range(nagents):
for e in self.movements[i]:
self.link2agent[e] = i
# keyneeds[i,j] = number of keys agent i needs for portal j
self.agentkeyneeds = np.zeros([self.nagents, self.n], dtype=int)
for i in xrange(self.nagents):
for e in self.movements[i]:
p, q = self.orderedEdges[e]
self.agentkeyneeds[i][q] += 1
self.names = np.array([a.node[i]['name'] for i in xrange(self.n)])
# The alphabetical order
self.nameOrder = np.argsort(self.names)
self.xy = np.array([self.a.node[i]['xy'] for i in xrange(self.n)])
# The order from north to south (for easy-to-find labels)
self.posOrder = np.argsort(self.xy, axis=0)[::-1, 1]
# The inverse permutation of posOrder
self.nslabel = [-1] * self.n
for i in xrange(self.n):
self.nslabel[self.posOrder[i]] = i
self.maxNameLen = max([len(a.node[i]['name']) for i in xrange(self.n)])
# total stats for this plan
self.num_portals = self.n
self.num_links = self.m
self.num_fields = -1
if useGoogle:
# coordinates needed for google maps
latmax = np.rad2deg(
max([self.a.node[i]['geo'][0] for i in self.a.node.keys()]))
latmin = np.rad2deg(
min([self.a.node[i]['geo'][0] for i in self.a.node.keys()]))
lonmax = np.rad2deg(
max([self.a.node[i]['geo'][1] for i in self.a.node.keys()]))
lonmin = np.rad2deg(
min([self.a.node[i]['geo'][1] for i in self.a.node.keys()]))
loncenter = (lonmax - lonmin) / 2. + lonmin
latcenter = (latmax - latmin) / 2. + latmin
print "Center Coordinates (lat,lon): ", latcenter, loncenter
xmin = self.xy[:, 0].min() * 1.1
xmax = self.xy[:, 0].max() * 1.1
ymin = self.xy[:, 1].min() * 1.1
ymax = self.xy[:, 1].max() * 1.1
# determine zoom for google maps
self.xylims = np.array([xmin, xmax, ymin, ymax])
map_ywidth = 640.
platescale = (ymax - ymin) / map_ywidth
map_xwidth = (xmax - xmin) / platescale
zoom = math.log(map_ywidth / (latmax - latmin), 2)
# update so zoom is an integer
zoom = round(zoom)
map_ywidth = (latmax - latmin) * 2.**zoom
platescale = (ymax - ymin) / map_ywidth
map_xwidth = (xmax - xmin) / platescale
# now we need xwidth,ywidth < 640.
while map_xwidth > 640. or map_ywidth > 640.:
zoom = zoom - 1
map_ywidth = (latmax - latmin) * 2.**zoom
platescale = (ymax - ymin) / map_ywidth
map_xwidth = (xmax - xmin) / platescale
# turn things in to integers for maps API
map_xwidth = int(map_xwidth)
map_ywidth = int(map_ywidth)
zoom = int(zoom)
# google maps API
# get API key
if api_key is not None:
url = "http://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size={2}x{3}&zoom={4}&sensor=false&key={5}".format(
latcenter, loncenter, map_xwidth, map_ywidth, zoom,
api_key)
else:
url = "http://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size={2}x{3}&zoom={4}&sensor=false".format(
latcenter, loncenter, map_xwidth, map_ywidth, zoom)
# determine if we can use google maps
self.google_image = None
try:
buffer = StringIO(urllib2.urlopen(url).read())
self.google_image = Image.open(buffer)
plt.clf()
except urllib2.URLError as err:
print("Could not connect to google maps server!")
def __init__(self,a,outputDir,nagents,color='#FF004D',useGoogle=False,api_key=None):
self.a = a
self.n = a.order() # number of nodes
self.m = a.size() # number of links
self.nagents = nagents
self.outputDir = outputDir
self.color = color
# if the ith link to be made is (p,q) then orderedEdges[i] = (p,q)
self.orderedEdges = [None]*self.m
for e in a.edges_iter():
self.orderedEdges[a.edge[e[0]][e[1]]['order']] = e
# movements[i][j] is the index (in orderedEdges) of agent i's jth link
self.movements = agentOrder.getAgentOrder(a,nagents,self.orderedEdges)
# link2agent[i] is the agent that will make the ith link
self.link2agent = [-1]*self.m
for i in range(nagents):
for e in self.movements[i]:
self.link2agent[e] = i
# keyneeds[i,j] = number of keys agent i needs for portal j
self.agentkeyneeds = np.zeros([self.nagents,self.n],dtype=int)
for i in xrange(self.nagents):
for e in self.movements[i]:
p,q = self.orderedEdges[e]
self.agentkeyneeds[i][q] += 1
self.names = np.array([a.node[i]['name'] for i in xrange(self.n)])
# The alphabetical order
makeLowerCase = np.vectorize(lambda s: s.lower())
self.nameOrder = np.argsort(makeLowerCase(self.names))
self.xy = np.array([self.a.node[i]['xy'] for i in xrange(self.n)])
# print self.xy
# The order from north to south (for easy-to-find labels)
self.posOrder = np.argsort(self.xy,axis=0)[::-1,1]
# The inverse permutation of posOrder
self.nslabel = [-1]*self.n
for i in xrange(self.n):
self.nslabel[self.posOrder[i]] = i
self.maxNameLen = max([len(a.node[i]['name']) for i in xrange(self.n)])
# total stats for this plan
self.num_portals = self.n
self.num_links = self.m
self.num_fields = 0
if useGoogle:
# convert xy coordinates to web mercator
x_merc = np.array([128./np.pi * (self.a.node[i]['geo'][1] + np.pi) for i in self.a.node.keys()])
min_x_merc = np.min(x_merc)
#print "min_x_merc",min_x_merc
x_merc = x_merc - min_x_merc
#print "Xmin, Xmax",np.min(x_merc),np.max(x_merc)
y_merc = np.array([128./np.pi * (np.pi - np.log(np.tan(np.pi/4. + self.a.node[i]['geo'][0]/2.))) for i in self.a.node.keys()])
min_y_merc = np.min(y_merc)
#print "min_y_merc",min_y_merc
y_merc = y_merc - min_y_merc
#print "Ymin, Ymax",np.min(y_merc),np.max(y_merc)
# determine proper zoom such that the map is smaller than 640 on both sides
zooms = np.arange(0,20,1)
largest_x_zoom = 0
largest_y_zoom = 0
for zm in zooms:
#print "X max",np.max(x_merc * 2.**zm + 20.)
#print "Y max",np.max(y_merc * 2.**zm + 20.)
if np.max(x_merc * 2.**zm) < 256.:
largest_x_zoom = zm
#print "X",largest_x_zoom
if np.max(y_merc * 2.**zm) < 256.:
largest_y_zoom = zm
#print "Y",largest_y_zoom
zoom = np.min([largest_x_zoom,largest_y_zoom])
min_x_merc = min_x_merc*2.**(1+zoom)
min_y_merc = min_y_merc*2.**(1+zoom)
self.xy[:,0] = x_merc*2.**(1+zoom)
self.xy[:,1] = y_merc*2.**(1+zoom)
for i in xrange(self.n):
self.a.node[i]['xy'] = self.xy[i]
xsize = np.max(self.xy[:,0])+20
ysize = np.max(self.xy[:,1])+20
self.xylims = [-10,xsize-10,ysize-10,-10]
# coordinates needed for google maps
loncenter = np.rad2deg((min_x_merc+xsize/2.-10.)*np.pi/(128.*2.**(zoom+1)) - np.pi)
latcenter = np.rad2deg(2.*np.arctan(np.exp(-1.*((min_y_merc+ysize/2.-10.)*np.pi/(128.*2.**(zoom+1)) - np.pi))) - np.pi/2.)
#latmax = np.rad2deg(max([self.a.node[i]['geo'][0] for i in self.a.node.keys()]))
#latmin = np.rad2deg(min([self.a.node[i]['geo'][0] for i in self.a.node.keys()]))
#lonmax = np.rad2deg(max([self.a.node[i]['geo'][1] for i in self.a.node.keys()]))
#lonmin = np.rad2deg(min([self.a.node[i]['geo'][1] for i in self.a.node.keys()]))
#loncenter = (lonmax-lonmin)/2. + lonmin
#latcenter = (latmax-latmin)/2. + latmin
#print "Center Coordinates (lat,lon): ",latcenter,loncenter
# turn things in to integers for maps API
map_xwidth = int(xsize)
map_ywidth = int(ysize)
zoom = int(zoom)+1
# google maps API
# get API key
if api_key is not None:
url = "http://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size={2}x{3}&zoom={4}&sensor=false&key={5}".format(latcenter,loncenter,map_xwidth,map_ywidth,zoom,api_key)
else:
url = "http://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size={2}x{3}&zoom={4}&sensor=false".format(latcenter,loncenter,map_xwidth,map_ywidth,zoom)
#print url
# determine if we can use google maps
self.google_image = None
try:
buffer = StringIO(urllib2.urlopen(url).read())
self.google_image = Image.imread(buffer)
plt.clf()
except urllib2.URLError as err:
print("Could not connect to google maps server!")
