def plot_career(careerPath):
title = getTitle(careerPath)
plt.figure(figsize=(120,60))
m = Basemap(resolution='c', # c, l, i, h, f or None
projection='cyl',
fix_aspect=True)
plt.title(title, fontsize=120)
# m.drawmapboundary(fill_color='#46bcec')
m.drawcoastlines()#color='#f2f2f2',lake_color='#46bcec')
m.drawcountries(antialiased=False)
long = 0
lat = 51
output = io.StringIO()
for _, entry in careerPath.iterrows():
if np.isnan(entry.CapitalLongitude) or np.isnan(entry.CapitalLatitude):
continue
if np.isnan(entry.yearPostingStart):
print_statement = entry.country+"\n"
elif np.isnan(entry.yearPostingEnd):
print_statement = entry.country + "({}-)".format(int(entry.yearPostingStart))+"\n"
else:
print_statement = entry.country + "({}-{})".format(int(entry.yearPostingStart), int(entry.yearPostingEnd))+"\n"
# print(print_statement)
output.write(entry.job+"\n")
output.write(print_statement)
output.write("\n")
m.drawgreatcircle(long,lat, entry.CapitalLongitude,entry.CapitalLatitude, del_s =1, lw=20)
long, lat = entry.CapitalLongitude,entry.CapitalLatitude
plt.text(x=-170, y=-80, s= output.getvalue(), fontsize=120)
print(output.getvalue())
plt.savefig("paths/"+title+".pdf")
def generate_map(output, lats=[], lons=[], wesn=None):
"""
creates a traffic map for a specific experiment
:param output:
:param lats:
:param lons:
:param wesn:
:return:
"""
"see http://matplotlib.org/basemap/users/examples.html"
m = Basemap(llcrnrlon=-180., llcrnrlat=-60., urcrnrlon=190., urcrnrlat=80., \
rsphere=(6378137.00, 6356752.3142), \
resolution='l', projection='merc', \
lat_0=40., lon_0=-20., lat_ts=20.)
for i in range(0, len(lats), 1):
centerlat = 55.95
centerlon = -3.2
m.drawgreatcircle(lons[i],
lats[i],
centerlon,
centerlat,
linewidth=2,
color='b')
m.drawcoastlines()
m.fillcontinents()
m.drawparallels(np.arange(-60, 90, 20))
m.drawmeridians(np.arange(-200, 200, 30))
plt.savefig(output, dpi=300, bbox_inches='tight')
plt.close()
def plot_lat_long(coords):
starting_lat = coords[0][1].lat
starting_lon = coords[0][1].long
print "starting lat: %s\nstarting lon: %s\n" % (starting_lat, starting_lon)
for coord in coords[1:]:
lat = coord[1].lat
lon = coord[1].long
print "lat: %s\nlon: %s\n" % (lat, lon)
m = Basemap(projection='merc',llcrnrlat=-80,urcrnrlat=80,\
llcrnrlon=-180,urcrnrlon=180,lat_ts=20,resolution='c')
m.drawcoastlines()
m.fillcontinents(color='coral',lake_color='aqua')
# draw parallels and meridians.
m.drawparallels(np.arange(-90.,91.,30.))
m.drawmeridians(np.arange(-180.,181.,60.))
xpt, ypt = m(lon, lat)
m.plot(xpt, ypt, 'bo')
lonlat = 51.53; lonlon = 0.08
m.drawgreatcircle(starting_lon,starting_lat,lon,lat,linewidth=2,color='b')
m.drawmapboundary(fill_color='aqua')
plt.title("Blorp")
plt.show()
starting_lat = lat
starting_lon = lon
def plotOnMap(A,A1):
x = np.zeros(len(A))
y = np.zeros(len(A))
name = []
for i in range(0, len(A)):
x[i] = HelpMethod.radTodeg(A[i].lat)
y[i] = HelpMethod.radTodeg(A[i].lon)
name.append(A[i].status1)
fig = plt.figure()
llcrnrlat=y[0] - 10
llcrnrlon = x[0] - 10
urcrnrlat = y[len(x) - 1] + 20
urcrnrlon = x[len(y) - 1] + 20
m = Basemap(llcrnrlat=llcrnrlat, llcrnrlon=llcrnrlon, urcrnrlat=urcrnrlat,
urcrnrlon=urcrnrlon)
for i in range(1, len(x)):
m.drawgreatcircle(x[i - 1], y[i - 1], x[i], y[i], color="red")
i = +2
m.drawcoastlines()
m.fillcontinents()
m.drawparallels(np.arange(0, 90, 10), labels=[1, 1, 0, 1])
# draw meridians
m.drawmeridians(np.arange(-180, 180, 10), labels=[1, 1, 0, 1])
for i in range(0, len(x)):
plt.text(x[i], y[i], name[i])
plt.savefig(A1)
plt.close(fig)
def main():
connection = sl.connect(FLIGHTS_DB)
query = """
select cast(sa.longitude as float) as source_lon,
cast(sa.latitude as float) as source_lat,
cast(da.longitude as float) as dest_lon,
cast(da.latitude as float) as dest_lat
from routes
inner join airports sa on sa.id = routes.source_id
inner join airports da on da.id = routes.dest_id
"""
routes = pd.read_sql_query(query, connection)
connection.close()
myMap = Basemap(projection='merc',
llcrnrlat=-80,
urcrnrlat=80,
llcrnrlon=-180,
urcrnrlon=180,
lat_ts=20,
resolution='c')
myMap.drawcoastlines()
for name, row in routes[:3000].iterrows():
if abs(row["source_lon"] - row["dest_lon"]) < 90:
myMap.drawgreatcircle(row["source_lon"],
row["source_lat"],
row["dest_lon"],
row["dest_lat"],
linewidth=1,
color='b')
def draw():
xs = []
ys = []
m = Basemap(projection='mill',
llcrnrlat=25,
llcrnrlon=-130,
urcrnrlat=50,
urcrnrlon=-60,
resolution='1')
m.drawcoastlines()
m.drawcountries(linewidth=2)
m.drawstates(color='b')
NYClat, NYClon = 40.7127, -74.0059
xpt, ypt = m(NYClon, NYClat)
xs.append(xpt)
ys.append(ypt)
m.plot(xpt, ypt, 'c*', markersize=15)
LAlat, LAlon = 34.05, -118.25
xpt, ypt = m(LAlon, LAlat)
xs.append(xpt)
ys.append(ypt)
m.plot(xpt, ypt, 'g^', markersize=15)
m.plot(xs, ys, color='r', linewidth=3, label='flight')
m.drawgreatcircle(NYClon, NYClat, LAlon, LAlat, color='c', label='Arc')
plt.legend(loc=4)
plt.show()
def addMap(self):
plt.figure(num="QuarksrouteMap")
m = Basemap(llcrnrlon=self.corners[0][0],
llcrnrlat=self.corners[0][1],
urcrnrlon=self.corners[1][0],
urcrnrlat=self.corners[1][1])
m.drawmapboundary(fill_color='#A6CAE0', linewidth=0)
m.fillcontinents(color='grey', alpha=0.6, lake_color='blue')
m.drawcountries(color="white")
m.drawcoastlines(linewidth=0.1, color="white")
head = ()
index = 0
for hop in self.data["hops"]:
if hop["geo"]:
if head is not ():
m.drawgreatcircle(head[0],
head[1],
hop["geo"]["location"]["longitude"],
hop["geo"]["location"]["latitude"],
linewidth=2,
color='blue')
head = (hop["geo"]["location"]["longitude"],
hop["geo"]["location"]["latitude"])
m.plot(head[0],
head[1],
linestyle='none',
marker="o",
markersize=8,
alpha=0.6,
c="cyan",
markeredgecolor="black",
markeredgewidth=1)
plt.annotate(index, xy=(head[0], head[1] + 2))
index = index + 1
def drawUSMap(chromosome, states, fname=None):
"Draws a map of the United States of America. That is true."
m = Basemap(llcrnrlon=-126,
llcrnrlat=24,
urcrnrlon=-67,
urcrnrlat=50,
resolution='c',
projection='merc',
lon_0=-95,
lat_0=37)
caplon = [x[3] for x in states]
caplat = [x[2] for x in states]
labels = [unicode(x[1], 'utf-8') for x in states]
m.drawcoastlines()
m.drawstates()
m.drawcountries()
m.fillcontinents(color='coral', lake_color='aqua')
m.drawmapboundary(fill_color='aqua')
for i in range(len(caplon) - 1):
nylon, nylat, lonlon, lonlat = caplon[chromosome[i]], caplat[
chromosome[i]], caplon[chromosome[i + 1]], caplat[chromosome[i +
1]]
m.drawgreatcircle(nylon, nylat, lonlon, lonlat, linewidth=2, color='b')
# Draw points on cities
x, y = m(caplon, caplat)
m.plot(x, y, 'bo', markersize=4)
# Write city names
for label, xpt, ypt in zip(labels, x, y):
plt.text(xpt, ypt, label, fontsize=10)
if fname == None:
fname = 'US' + str(int(time.time()))
plt.savefig('images/' + fname + '.svg', bbox_inches='tight')
def draw(self, pop):
fig=plt.figure()
ax=fig.add_axes([0.1,0.1,0.8,0.8])
m = Basemap(llcrnrlon=-125.,llcrnrlat=25.,urcrnrlon=-65.,urcrnrlat=52.,
rsphere=(6378137.00,6356752.3142),
resolution='l',projection='merc',
lat_0=40.,lon_0=-20.,lat_ts=20.)
l = pop[0]
for i in range(len(l.sol)):
lat1 = l.sol[i].lat
lon1 = l.sol[i].lon
m.drawgreatcircle(lon1,lat1,lon1,lat1, linewidth=4, color = 'r')
if i == len(l.sol) - 1:
lat2 = l.sol[0].lat
lon2 = l.sol[0].lon
else:
lat2 = l.sol[i+1].lat
lon2 = l.sol[i+1].lon
m.drawgreatcircle(lon1,lat1,lon2,lat2, color = 'b')
m.drawcoastlines()
m.drawstates()
m.drawcountries()
m.fillcontinents()
ax.set_title('GREEDY')
plt.show()
def map_trace(tr,ax='None',showpath=True,showplot=True,Lat_0=0.0,Lon_0=60.0):
from mpl_toolkits.basemap import Basemap
if ax == 'None':
m = Basemap(projection='ortho',lat_0=Lat_0,lon_0=Lon_0,resolution='l')
m.drawmapboundary()
m.drawcoastlines()
m.fillcontinents(color='gray',lake_color='white')
else:
m = ax
x1,y1 = m(tr.stats.sac['evlo'],tr.stats.sac['evla'])
x2,y2 = m(tr.stats.sac['stlo'],tr.stats.sac['stla'])
m.scatter(x1,y1,s=200.0,marker='*',facecolors='y',edgecolors='k',zorder=99)
m.scatter(x2,y2,s=20.0,marker='^',color='b',zorder=99)
if showpath == True:
m.drawgreatcircle(tr.stats.sac['evlo'],tr.stats.sac['evla'],
tr.stats.sac['stlo'],tr.stats.sac['stla'],
linewidth=1,color='k',alpha=0.5)
if showplot == True:
plt.show()
else:
return m
def show_flight(flight_info):
m = Basemap(llcrnrlon=-180, llcrnrlat=-90, urcrnrlon=180, urcrnrlat=90, \
projection='mill', resolution='c')
m.shadedrelief()
plt.show()
m.drawcoastlines()
# m.drawcounties(linewidth=2)
m.drawstates(color='b')
xs = []
ys = []
# Plot arrival points
NYClat, NYClon = float(flight_info[1][0]), float(flight_info[1][1])
xpt, ypt = m(NYClon, NYClat)
xs.append(xpt)
ys.append(ypt)
m.plot(xpt, ypt, 'go', markersize=20)
# Plot departure points
LAlat, LAlon = float(flight_info[0][0]), float(flight_info[0][1])
xpt, ypt = m(LAlon, LAlat)
xs.append(xpt)
ys.append(ypt)
m.drawgreatcircle(NYClon, NYClat, LAlon, LAlat, linewidth=2, color='b')
m.drawcoastlines()
m.plot(xpt, ypt, 'r^', markersize=20)
m.plot(xs, ys, color='y', linewidth=3, label='Flight 112')
# Customization of plotted map and displaying it
plt.title('Flight Map')
def draw(self, pop):
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
m = Basemap(llcrnrlon=-125.,
llcrnrlat=25.,
urcrnrlon=-65.,
urcrnrlat=52.,
rsphere=(6378137.00, 6356752.3142),
resolution='l',
projection='merc',
lat_0=40.,
lon_0=-20.,
lat_ts=20.)
l = pop[0]
for i in range(len(l.sol)):
lat1 = l.sol[i].lat
lon1 = l.sol[i].lon
m.drawgreatcircle(lon1, lat1, lon1, lat1, linewidth=4, color='r')
if i == len(l.sol) - 1:
lat2 = l.sol[0].lat
lon2 = l.sol[0].lon
else:
lat2 = l.sol[i + 1].lat
lon2 = l.sol[i + 1].lon
m.drawgreatcircle(lon1, lat1, lon2, lat2, color='b')
m.drawcoastlines()
m.drawstates()
m.drawcountries()
m.fillcontinents()
ax.set_title('GREEDY')
plt.show()
def plot_eq(self,ax='None',showpath=True,showplot=True,lon_0=0.0,lat_0=0.0):
from mpl_toolkits.basemap import Basemap
if ax == 'None':
#m = Basemap(projection='hammer',lon_0=self.ry)
m = Basemap(projection='ortho',lat_0=lat_0,lon_0=lon_0,resolution='l')
m.drawmapboundary()
m.drawcoastlines()
m.fillcontinents(color='gray',lake_color='white')
else:
m = ax
x1,y1 = m(self.sy,90.0-self.sx)
x2,y2 = m(self.ry,90.0-self.rx)
m.scatter(x1,y1,s=200.0,marker='*',facecolors='y',edgecolors='k',zorder=99)
m.scatter(x2,y2,s=20.0,marker='^',color='b',zorder=99)
if showpath == True:
lon_s = self.sy
lat_s = 90.0-self.sx
lon_r = self.ry
lat_r = 90.0-self.rx
print "lon_s,lat_s,lon_r,lat_r", lon_s, lat_s, lon_r, lat_r
m.drawgreatcircle(lon_s,lat_s,lon_r,lat_r,linewidth=1,color='k',alpha=0.5)
if showplot == True:
plt.show()
else:
return m
def draw(x1, x2, x3, x4):
map = Basemap(projection='robin',
lat_0=0,
lon_0=0,
resolution='l',
area_thresh=1000.0)
map.drawcoastlines()
map.drawcountries()
map.fillcontinents(color='coral', lake_color='aqua')
map.drawmapboundary(fill_color='aqua')
map.drawmeridians(np.arange(0, 360, 30))
map.drawparallels(np.arange(-90, 90, 30))
#initiate ocean and icecap colours
#map.bluemarble()
#draw a blob on the map
x, y = map(x2, x1)
map.plot(x, y, 'bo', markersize=10)
x, y = map(x4, x3)
map.plot(x, y, 'bd', markersize=10)
map.drawgreatcircle(x2, x1, x4, x3, linewidth=2, color='b')
plt.show()
def map_trace(tr,ax='None',showpath=True,showplot=True,Lat_0=0.0,Lon_0=60.0):
from mpl_toolkits.basemap import Basemap
if ax == 'None':
m = Basemap(projection='ortho',lat_0=Lat_0,lon_0=Lon_0,resolution='l')
m.drawmapboundary()
m.drawcoastlines()
m.fillcontinents(color='gray',lake_color='white')
else:
m = ax
x1,y1 = m(tr.stats.sac['evlo'],tr.stats.sac['evla'])
x2,y2 = m(tr.stats.sac['stlo'],tr.stats.sac['stla'])
m.scatter(x1,y1,s=200.0,marker='*',facecolors='y',edgecolors='k',zorder=99)
m.scatter(x2,y2,s=20.0,marker='^',color='b',zorder=99)
if showpath == True:
m.drawgreatcircle(tr.stats.sac['evlo'],tr.stats.sac['evla'],
tr.stats.sac['stlo'],tr.stats.sac['stla'],
linewidth=1,color='k',alpha=0.5)
if showplot == True:
plt.show()
else:
return m
def image_result(flightnum):
#设置画布大小
plt.figure(figsize=(8, 8))
#画一幅中国地图
map1 = Basemap(llcrnrlon=77, llcrnrlat=14, urcrnrlon=140, urcrnrlat=51)
# map1 = Basemap(resolution = 'h' , llcrnrlon=73, llcrnrlat=18, urcrnrlon=135, urcrnrlat=53)
#画出国家边界
map1.drawcountries()
#画出海岸线
# map1.drawcoastlines()
#画一幅NASA的bluemarble地图
map1.bluemarble()
#获取航班信息
flight = flightaware(flightnum)
#获得航班总共的信息条数
z = len(flight)
#导入函数
# facheck= flightawareparser.fascrapper()
facheck = fascrapper()
#获得航班号对应的航班起始站点的信息
details = facheck.flightdata(flightnum)
#取整条航线上的四个点
x1, y1 = map1(flight[1][1], flight[1][2])
x2, y2 = map1(flight[int(z / 3)][1], flight[int(z / 3)][2])
x3, y3 = map1(flight[int(2 * z / 3)][1], flight[int(2 * z / 3)][2])
x4, y4 = map1(flight[z - 1][1], flight[z - 1][2])
x = [x1, x2, x3, x4]
y = [y1, y2, y3, y4]
#画点
map1.scatter(x, y, 270, marker='o', color='steelblue')
#画线
map1.drawgreatcircle(x1, y1, x2, y2, linewidth=2, color='lightblue')
map1.drawgreatcircle(x2, y2, x3, y3, linewidth=2, color='lightblue')
map1.drawgreatcircle(x3, y3, x4, y4, linewidth=2, color='lightblue')
#备注文字
plt.text(x1, y1, flight[1][0], rotation=0, fontsize=10, color='lawngreen')
plt.text(x1, y1, details[2], rotation=30, fontsize=12, color='snow')
plt.text(x2,
y2,
flight[int(z / 3)][0],
rotation=0,
fontsize=10,
color='lawngreen')
plt.text(x3,
y3,
flight[int(2 * z / 3)][0],
rotation=0,
fontsize=10,
color='lawngreen')
plt.text(x4,
y4,
flight[z - 1][0],
rotation=0,
fontsize=10,
color='lawngreen')
plt.text(x4, y4, details[3], rotation=30, fontsize=12, color='snow')
#plt.text(x2, y2, '北京', rotation=30, fontsize=15, color='coral')
plt.savefig('flight.png')
class GCMapper:
def __init__(self):
# create new figure, axes instances.
self.fig = plt.figure()
self.ax = self.fig.add_axes([0.1, 0.1, 0.8, 0.8], axisbg='#a5bfdd')
# setup mercator map projection.
self.map = Basemap(llcrnrlon=-130.,
llcrnrlat=1.,
urcrnrlon=40.,
urcrnrlat=70.,
rsphere=(6378137.00, 6356752.3142),
resolution='c',
projection='merc',
lat_0=40.,
lon_0=-20.,
lat_ts=20.)
def plot(self, element):
if isinstance(element, Segment):
self.plot_segment(element)
if isinstance(element, Route):
self.plot_route(element)
if isinstance(element, Point):
self.plot_point(element)
raise Exception('Incompatible type %s of element to plot' %
type(element))
def plot_route(self, route, color='b', linestyle='-'):
#just to be suer
route.init_segments()
for segment in route.segments:
self.plot_segment(segment, color=color, linestyle=linestyle)
def plot_point(self, point, formatting='go'):
x, y = self.map(point.lon, point.lat)
self.map.plot(x, y, formatting, ms=8)
def plot_segment(self, segment, color='b', linestyle='-'):
point1 = segment.start
point2 = segment.end
self.map.drawgreatcircle(point1.lon,
point1.lat,
point2.lon,
point2.lat,
linestyle=linestyle,
linewidth=1.5,
color=color)
def render(self):
self.map.drawcoastlines(color='#8f8457')
self.map.fillcontinents(color='#f5f0db')
self.map.drawcountries(color='#a9a06d')
self.map.drawparallels(np.arange(10, 90, 20), labels=[1, 1, 0, 1])
self.map.drawmeridians(np.arange(-180, 180, 30), labels=[1, 1, 0, 1])
self.ax.set_title('Flights')
plt.show()
def plot_test(self, resolution=5):
'''
Show a plot of the earth and polygon with points tested for beeing inside.
resolution : a positive number. The grid resolution in degrees for the test.
'''
import matplotlib.pyplot as plt
try:
from mpl_toolkits.basemap import Basemap
except Exception as e:
print(e)
raise ImportError(
"This function requiers Basemap, please install and try again")
lons, lats = np.meshgrid(np.arange(-180, 180.01, resolution),
np.arange(-90, 90.01, resolution))
points = np.asarray([lats.flatten(), lons.flatten()]).T
points_in = self.contains_points(points, radians=False)
fig, ax = plt.subplots(figsize=(10, 10))
m = Basemap()
plot_vertices = self.vertices_geo
if self.radians:
plot_vertices = np.rad2deg(self.vertices_geo)
for i in range(len(plot_vertices) - 1):
m.drawgreatcircle(plot_vertices[i][1],
plot_vertices[i][0],
plot_vertices[i + 1][1],
plot_vertices[i + 1][0],
c='b',
lw=3)
m.drawgreatcircle(plot_vertices[i + 1][1],
plot_vertices[i + 1][0],
plot_vertices[0][1],
plot_vertices[0][0],
c='b',
lw=3)
m.drawcoastlines()
m.drawmeridians(np.arange(-180, 180, 10))
m.drawparallels(np.arange(-90, 90, 10))
for i, point in enumerate(points):
if points_in[i]:
c = 'b'
else:
c = 'r'
m.scatter(point[1], point[0], latlon=True, s=20, c=c, lw=0)
plt.show()
def plot(st, **kwargs):
gc = kwargs.get('great_circle', False)
width = 28000000
latav = []
lonav = []
for tr in st:
latav.append(tr.stats.stla)
lonav.append(tr.stats.stlo)
latav = np.mean(latav)
lonav = np.mean(lonav)
fig1 = plt.figure(figsize=(10, 10))
lat_s = st[0].stats.evla
lon_s = st[0].stats.evlo
m = Basemap(projection='aeqd', lat_0=lat_s, lon_0=lon_s)
xpt, ypt = m(lon_s, lat_s)
m.scatter(xpt, ypt, s=99, c='red', marker='o', lw=1)
m.drawcoastlines(linewidth=0.5)
for tr in st:
lat_0 = tr.stats.stla
lon_0 = tr.stats.stlo
xpt, ypt = m(lon_0, lat_0)
if gc == True:
m.drawgreatcircle(lon_s,
lat_s,
lon_0,
lat_0,
color='k',
alpha=0.1,
lw=0.4)
m.scatter(xpt, ypt, s=5, c='green', marker='o', lw=0)
'''
fig2 = plt.figure(figsize=(10,10))
m = Basemap(projection='ortho',lat_0=latav,lon_0=lonav)
xpt, ypt = m(st[0].stats.sac['evlo'], st[0].stats.sac['evla'])
m.scatter(xpt,ypt,s=99,c='red',marker='o',lw=1)
# fill background.
#m.drawmapboundary(fill_color='aqua')
# draw coasts and fill continents.
m.drawcoastlines(linewidth=0.5)
#m.fillcontinents(color='coral',lake_color='aqua')
# 20 degree graticule.
m.drawparallels(np.arange(-80,81,20))
m.drawmeridians(np.arange(-180,180,20))
# draw a black dot at the center.
for tr in st:
lat_0 = tr.stats.sac['stla']
lon_0 = tr.stats.sac['stlo']
xpt, ypt = m(lon_0, lat_0)
m.scatter(xpt,ypt,s=5,c='green',marker='o',lw=0)
'''
plt.show()
def general(input_file="input.csv"):
# create arrays to hold
lats = []
longs = []
weights = []
names = []
with open(input_file) as input_csv:
csv_reader = csv.reader(input_csv)
#next(csv_reader, None)
for row in csv_reader:
#print (float(row[0]))
x, y, w, n = float(row[0]), float(row[1]), row[2], row[3]
lats.append(x)
longs.append(y)
weights.append(w)
names.append(n)
# create background map
minLat=min(lats)
maxLat=max(lats)
minLong = min(longs)
maxLong = max(longs)
if minLat -10 >-90:
minLat = minLat-10
if maxLat +10 <90:
maxLat = maxLat +10
if minLong -10 >-180:
minLong = minLong-10
if maxLong +10<180:
maxLong = maxLong+10
m= Basemap(llcrnrlon=minLong, llcrnrlat=minLat, urcrnrlon=maxLong,
urcrnrlat=maxLat, projection='merc', lat_1=33, lat_2=45,
lon_0=-95, resolution='c', area_thresh=10000)
m.drawcoastlines()
m.drawmapboundary(fill_color='aqua')
m.drawcountries()
m.fillcontinents(color='green', lake_color='aqua')
m.drawstates()
ypt, xpt = m(longs, lats)
m.plot(ypt, xpt, 'bo', markersize=10)
for y, x, name in zip(ypt,xpt,names):
plt.text(y-1000,x+1000,name)
for i in range(0,len(ypt)-1):
m.drawgreatcircle(longs[i], lats[i], longs[i+1], lats[i+1], linewidth=1, color='r')
for i in range(0,len(weights)-1):
plt.text(((ypt[i]+ypt[i+1])/2),((xpt[i]+xpt[i+1])/2),weights[i+1])
plt.show()
def plotSatelliteTrajectory(longitude,latitude,trajectoryname,fig_type='eps'):
# TODO: This plotting function needs to be looked over...
from mpl_toolkits.basemap import Basemap #@UnresolvedImport
import pylab
import numpy
m = Basemap(projection='cyl',llcrnrlat=-90,urcrnrlat=90,\
llcrnrlon=-180,urcrnrlon=180,resolution='c')
m.drawmapboundary()
m.drawcoastlines()
lon_nanix = numpy.where(~numpy.isnan(longitude))[0]
lon_ix_split = numpy.where(numpy.diff(lon_nanix) != 1)[0]
if lon_ix_split.shape[0]==0 and lon_nanix.shape[0]!=0:
lon = longitude[lon_nanix]
lat = latitude[lon_nanix]
m.drawgreatcircle(lon[0],lat[0],lon[1],lat[1],color='red')
m1 = m.drawgreatcircle(lon[0],lat[0],lon[1],lat[1],color='red')
m = makesTheActuallyTrajectoryPlot(m,lon,lat)
elif lon_ix_split.shape[0]==1:
lon = longitude[lon_nanix[0:lon_ix_split[0]+1]]
lat = latitude[lon_nanix[0:lon_ix_split[0]+1]]
m.drawgreatcircle(lon[0],lat[0],lon[1],lat[1],color='red')
m1 = m.drawgreatcircle(lon[0],lat[0],lon[1],lat[1],color='red')
m = makesTheActuallyTrajectoryPlot(m,lon,lat)
lon = longitude[lon_nanix[lon_ix_split[-1]+1:]]
lat = latitude[lon_nanix[lon_ix_split[-1]+1:]]
m = makesTheActuallyTrajectoryPlot(m,lon,lat)
elif lon_ix_split.shape[0]>1:
lon = longitude[lon_nanix[0:lon_ix_split[0]+1]]
lat = latitude[lon_nanix[0:lon_ix_split[0]+1]]
m.drawgreatcircle(lon[0],lat[0],lon[1],lat[1],color='red')
m1 = m.drawgreatcircle(lon[0],lat[0],lon[1],lat[1],color='red')
m = makesTheActuallyTrajectoryPlot(m,lon,lat)
for c in range(len(lon_ix_split)-1):
lon = longitude[lon_nanix[lon_ix_split[c]+1:lon_ix_split[c+1]+1]]
lat = latitude[lon_nanix[lon_ix_split[c]+1:lon_ix_split[c+1]+1]]
m = makesTheActuallyTrajectoryPlot(m,lon,lat)
lon = longitude[lon_nanix[lon_ix_split[-1]+1:]]
lat = latitude[lon_nanix[lon_ix_split[-1]+1:]]
m = makesTheActuallyTrajectoryPlot(m,lon,lat)
pylab.legend((m1),['CloudSat/Calipso'],loc=0)
if isinstance(fig_type, str) == True:
figname = '%s.%s' %(trajectoryname, fig_type)
pylab.savefig(figname)
else:
for figtype in fig_type:
figname = '%s.%s' %(trajectoryname, figtype)
pylab.savefig(figname)
class GCMapper:
def __init__(self):
# create new figure, axes instances.
self.fig = plt.figure()
self.ax = self.fig.add_axes([0.1,0.1,0.8,0.8], axisbg = '#a5bfdd')
# setup mercator map projection.
self.map = Basemap(llcrnrlon = -130., llcrnrlat = 1.,
urcrnrlon = 40., urcrnrlat = 70.,
rsphere = (6378137.00,6356752.3142),
resolution = 'c',
projection = 'merc',
lat_0 = 40.,lon_0 = -20.,lat_ts = 20.)
def plot(self, element):
if isinstance(element, Segment):
self.plot_segment(element)
if isinstance(element, Route):
self.plot_route(element)
if isinstance(element, Point):
self.plot_point(element)
raise Exception('Incompatible type %s of element to plot' % type(element))
def plot_route(self, route, color = 'b', linestyle = '-'):
#just to be suer
route.init_segments()
for segment in route.segments:
self.plot_segment(segment, color = color, linestyle = linestyle)
def plot_point(self, point, formatting = 'go'):
x, y = self.map(point.lon, point.lat)
self.map.plot(x, y, formatting, ms = 8)
def plot_segment(self, segment, color = 'b', linestyle = '-'):
point1 = segment.start
point2 = segment.end
self.map.drawgreatcircle(
point1.lon, point1.lat,
point2.lon, point2.lat,
linestyle = linestyle,
linewidth = 1.5,
color = color)
def render(self):
self.map.drawcoastlines(color='#8f8457')
self.map.fillcontinents(color='#f5f0db')
self.map.drawcountries(color='#a9a06d')
self.map.drawparallels(np.arange(10,90,20), labels = [1,1,0,1])
self.map.drawmeridians(np.arange(-180,180,30), labels = [1,1,0,1])
self.ax.set_title('Flights')
plt.show()
def drawMap(chromosome, continent, countries, fname=None):
"Draws a map of a given chromosome on a given continent."
continentBoundary = {
'AO': [121, -43.0, 230, 20, 130, -10],
'AS': [31, -13.0, 141, 53, 60, 20],
'AF': [-24, -35.0, 59, 38, 10, 0],
'EU': [-22, 33.0, 40, 65, 17, 52],
'SA': [-82, -52.0, -40, 15, -17, -62],
'NA': [-100, 4.0, -52, 50, -62, 20]
}
lllon, lllat, urlon, urlat, lon0, lat0 = continentBoundary[continent]
plt.clf()
map = Basemap(projection='merc',
lat_0=lat0,
lon_0=lon0,
resolution='c',
llcrnrlon=lllon,
llcrnrlat=lllat,
urcrnrlon=urlon,
urcrnrlat=urlat)
map.drawcountries()
caplon = [x[3] for x in countries]
caplat = [x[2] for x in countries]
caplonDX = [x[7] + x[3] for x in countries]
caplatDX = [x[6] + x[2] for x in countries]
labels = [unicode(x[1], 'utf-8') for x in countries]
# TODO make maps prettier: better colors etc.
map.fillcontinents(color='coral')
# Connect cities in a proper order
# TODO fix 180/-180 longitude problem
for i in range(len(caplon) - 1):
nylon, nylat, lonlon, lonlat = caplon[chromosome[i]], caplat[
chromosome[i]], caplon[chromosome[i + 1]], caplat[chromosome[i +
1]]
map.drawgreatcircle(nylon,
nylat,
lonlon,
lonlat,
linewidth=1,
color='b')
# Draw points on cities
x, y = map(caplon, caplat)
map.plot(x, y, 'bo', markersize=2)
# Write city names
x, y = map(caplonDX, caplatDX)
for label, xpt, ypt in zip(labels, x, y):
plt.text(xpt, ypt, label, fontsize=8)
if fname == None:
fname = str(int(time.time()))
plt.savefig('images/' + fname + '.svg', bbox_inches='tight')
def find_pierce_coor(self,plot='False'):
import geopy
from geopy.distance import VincentyDistance
'''
given an instance of the receiver function class this function
returns latitude and longitude of all receiver side pierce points
of Pds in a given depth range (the default range is 50 - 800 km)
NOTE:
be careful that ses3d typically uses colatitude, while
this function returns latitude '''
depth_range = np.arange(50,800,5) #set range of pierce points
#geodetic info
bearing = self.az
lon_s = self.ses3d_seismogram.sy
lat_s = 90.0-self.ses3d_seismogram.sx
lon_r = self.ses3d_seismogram.ry
lat_r = 90.0-self.ses3d_seismogram.rx
origin = geopy.Point(lat_s, lon_s)
#find how far away the pierce point is
model = TauPyModel(model='pyrolite_5km')
for i in range(0,len(depth_range)):
phase = 'P'+str(depth_range[i])+'s'
pierce = model.get_pierce_points(self.eq_depth,self.delta_deg,phase_list=[phase])
points = pierce[0].pierce
for j in range(0,len(points)):
if points[j]['depth'] == depth_range[i] and points[j]['dist']*(180.0/np.pi) > 25.0:
prc_dist = points[j]['dist']*(180.0/np.pi)
d_km = prc_dist * ((2*np.pi*6371.0/360.0))
destination = VincentyDistance(kilometers=d_km).destination(origin,bearing)
lat = destination[0]
lon = destination[1]
value = 0
row = {'depth':depth_range[i],'dist':prc_dist,'lat':lat,'lon':lon,'value':value}
self.pierce_dict.append(row)
if plot=='True':
m = Basemap(projection='hammer',lon_0=0)
m.drawmapboundary()
m.drawcoastlines()
m.drawgreatcircle(lon_s,lat_s,lon_r,lat_r,linewidth=1,color='b',alpha=0.5)
for i in range(len(self.pierce_dict)):
x,y = m(self.pierce_dict[i]['lon'],self.pierce_dict[i]['lat'])
m.scatter(x,y,5,marker='o',color='r')
plt.show()
def plot_interactions(locations: List[str],
latent_graph: ndarray,
map: Basemap,
ax: Axis,
skip_first: bool = False):
"""
Given station ids and latent graph plot edges in different colors
"""
# Transform lan/lot into region-specific values
pixel_coords = [map(*coords) for coords in locations]
# Draw contours and borders
map.shadedrelief()
map.drawcountries()
# m.bluemarble()
# m.etopo()
# Plot Locations of weather stations
for i, (x, y) in enumerate(pixel_coords):
ax.plot(x, y, 'ok', markersize=10, color='yellow')
ax.text(x + 10, y + 10, "Station " + str(i), fontsize=20, color='yellow');
# Infer number of edge types and atoms from latent graph
n_atoms = latent_graph.shape[-1]
n_edge_types = latent_graph.shape[0]
color_map = get_cmap('Set1')
for i in range(n_atoms):
for j in range(n_atoms):
for edge_type in range(n_edge_types):
if latent_graph[edge_type, i, j] > 0.5:
if skip_first and edge_type == 0:
continue
# Draw line between points
x = locations[i]
y = locations[j]
map.drawgreatcircle(x[0], x[1], y[0], y[1],
color=color_map(edge_type - 1),
label=str(edge_type))
handles, labels = ax.get_legend_handles_labels()
unique = [(h, l) for i, (h, l) in enumerate(zip(handles, labels)) if l not in labels[:i]]
ax.legend(*zip(*unique))
return ax
def plot_legs(df, dst_dir, title="?", boundary="all"):
'''
plot all legs in df on a map, df should have columns: 'latitude_x',
'longitude_x', 'latitude_y' and 'longitude_y'
'''
fig = plt.figure(1, figsize=(16, 12))
# setup mercator map projection.
if boundary == "domestic":
m = Basemap(llcrnrlon=-126,
llcrnrlat=23.5,
urcrnrlon=-65,
urcrnrlat=50,
projection='merc')
else:
m = Basemap(llcrnrlon=-150,
llcrnrlat=-35,
urcrnrlon=136,
urcrnrlat=62,
projection='merc')
m.drawmapboundary(fill_color='#EBF4FA')
m.drawcoastlines()
m.fillcontinents()
m.drawcountries()
# m.drawcounties(linewidth= 0.15, color= '#000066')
m.drawstates(linewidth=1.2, linestyle='solid', color='w')
m.drawparallels(np.arange(15, 60, 15), labels=[1, 1, 1, 1])
m.drawmeridians(np.arange(-120, -50, 40), labels=[1, 1, 1, 1])
plt.title(title, fontsize=20)
for index, row in df.iterrows():
Dep_lat = row['latitude_x']
Dep_lon = row['longitude_x']
Arr_lat = row['latitude_y']
Arr_lon = row['longitude_y']
# draw great circle route between NY and London
m.drawgreatcircle(Dep_lon,
Dep_lat,
Arr_lon,
Arr_lat,
del_s=10,
alpha=0.7,
linestyle='solid')
fig.savefig(dst_dir + "legs_" + "%s" % boundary + ".png", dpi=150)
fig.clear()
return
def contact_map(wspr_data):
"""Show all the contacts on a map"""
filename = os.path.join(Config.target, 'contactmap.png')
logging.info('Drawing connection map to %s', filename)
__calls = []
points = []
for data in wspr_data:
if data.rx_call in __calls:
continue
__calls.append(data.rx_call)
points.append((data.rx_lon, data.rx_lat))
points = np.array(points)
right, upl = points.max(axis=0) + [15., 10.]
left, downl = points.min(axis=0) + [-15., -10]
if right > 180 or left < -180:
right, left, upl, downl = (180., -180., 90., -90.)
fig = plt.figure(figsize=(12, 8))
fig.text(.01, .02, ('http://github/com/0x9900/wspr - Contacts map - '
'Time span: %sH - Band: %s') % (Config.timespan, Config.band))
fig.suptitle('[{}] WSPR Stats'.format(Config.callsign), fontsize=14, fontweight='bold')
logging.info("Origin lat: %f / lon: %f", wspr_data[0].tx_lat, wspr_data[0].tx_lon)
bmap = Basemap(projection='mill', lon_0=wspr_data[0].tx_lon, lat_0=wspr_data[0].tx_lat,
urcrnrlat=upl, urcrnrlon=right, llcrnrlat=downl, llcrnrlon=left,
resolution='c')
bmap.drawlsmask(land_color="#5c4033", ocean_color="#9999ff", resolution='l')
bmap.drawparallels(np.arange(-90., 90., 45.))
bmap.drawmeridians(np.arange(-180., 180., 45.))
bmap.drawcountries()
bmap.drawstates(linestyle='dashed', color='#777777')
#bmap.drawrivers(linestyle='dotted', color='#7777ff')
for lon, lat in points:
bmap.drawgreatcircle(wspr_data[0].tx_lon, wspr_data[0].tx_lat, lon, lat,
linewidth=.5, color='navy', del_s=1)
x, y = bmap(lon, lat)
bmap.plot(x, y, '*', markersize=4, alpha=.5, color='yellow')
plt.savefig(filename)
plt.close()
def trace_route(ip_address: str) -> None:
if platform.system() in ('Linux', 'Darwin'):
command = ['traceroute', '-m', '25', '-n', ip_address]
elif platform.system() == 'Windows':
tracert_path = Path('C:') / 'Windows' / 'System32' / 'TRACERT.exe'
# alt: tracert_path = Path(subprocess.run(['where.exe', 'tracert'], capture_output=True, encoding='utf-8').stdout.rstrip())
command = [str(tracert_path), '-h', '25', '-d', '-4', ip_address]
else:
print(
"Sorry, this Python program does not have support for your current operating system!"
)
sys.exit(-1)
# Start traceroute command
proc = subprocess.Popen(command,
stdout=subprocess.PIPE,
shell=True,
universal_newlines=True)
# Plot a pretty enough map
fig = plt.figure(figsize=(10, 6), edgecolor='w')
m = Basemap(projection='mill', lon_0=0, resolution='l')
m.shadedrelief(scale=0.05)
# Where we are coming from
last_lon = None
last_lat = None
# Parse individual traceroute command lines
for line in proc.stdout:
print(line, end='')
if platform.system() == 'Windows' and len(line.split()) != 8:
continue
hop_ip = line.split()[1 if platform.system() in ('Linux', 'Darwin')
else 7] # First step already handled other cases
if hop_ip in ('*', 'to'):
continue
(lat, lon) = get_location(hop_ip)
if (lat is None):
continue
if last_lat is not None and (last_lat - lat + last_lon - lon) != 0.0:
# print(lastLat, lastLon, lat, lon)
x, y = m(lon, lat)
m.scatter(x, y, 10, marker='o', color='r')
line, = m.drawgreatcircle(last_lon, last_lat, lon, lat, color='b')
last_lat = lat
last_lon = lon
plt.tight_layout()
plt.show()
def _dump_graph(self, title=None, lon_0=0, lat_0=90,
projection='vandg', func=lambda x: len(x._edges)):
from mpl_toolkits.basemap import Basemap
from matplotlib import pyplot as plt
fig = plt.figure()
m = Basemap()
counts = {}
for node in self._nodes:
count = func(node)
counts.setdefault(count, [])
counts[count].append(list(node._point))
minx = np.inf
miny = np.inf
maxx = -np.inf
maxy = -np.inf
for k, v in counts.items():
v = np.array(v)
ra, dec = vector.vector_to_radec(v[:, 0], v[:, 1], v[:, 2])
x, y = m(ra, dec)
m.plot(x, y, 'o', label=str(k))
for x0 in x:
minx = min(x0, minx)
maxx = max(x0, maxx)
for y0 in y:
miny = min(y0, miny)
maxy = max(y0, maxy)
for edge in list(self._edges):
A, B = [x._point for x in edge._nodes]
r0, d0 = vector.vector_to_radec(A[0], A[1], A[2])
r1, d1 = vector.vector_to_radec(B[0], B[1], B[2])
m.drawgreatcircle(r0, d0, r1, d1, color='blue')
plt.xlim(minx, maxx)
plt.ylim(miny, maxy)
if title:
plt.title("%s, %d v, %d e" % (
title, len(self._nodes), len(self._edges)))
plt.legend()
plt.show()
def plot_city_in_map(self,name, routes=None):
geolocator = Nominatim()
fig = plt.figure(num=None, figsize=(150, 150))
m = Basemap(projection='merc', llcrnrlat=-80, urcrnrlat=80, llcrnrlon=-180, urcrnrlon=180, resolution='c')
m.drawcoastlines()
m.fillcontinents(color='tan', lake_color='lightblue')
# draw parallels and meridians.
m.drawmapboundary(fill_color='lightblue')
m.drawcountries(color='black')
nylat = 40.78;
nylon = -73.98
# lonlat, lonlon are lat/lon of London.
lonlat = 51.53;
lonlon = 0.08
# draw great circle route between NY and London
# m.drawgreatcircle(nylon, nylat, lonlon, lonlat, linewidth=2, color='b')
last_long = 0
last_lat = 0
count = 0
color = None
for city in routes:
loc = geolocator.geocode(city)
# x, y = map(loc.longitude, loc.latitude)
if count !=0 :
print('lala: %s' % count)
print(loc)
if (count % 2) is 0:
color = 'b'
else:
color = 'g'
m.drawgreatcircle(last_long, last_lat, loc.longitude, loc.latitude, linewidth=2, color=color)
x, y = m(loc.longitude, loc.latitude)
m.plot(x, y, 'b', markersize=50)
plt.text(x, y, city, fontsize=8 , fontweight='bold', ha='left', va='top', color='k')
last_long = loc.longitude
last_lat = loc.latitude
count += 1
plt.title(name)
plt.show()
def display(lat1,lon1,lat2,lon2):
# create new figure, axes instances.
fig=plt.figure()
ax=fig.add_axes([0.1,0.1,0.8,0.8])
# setup mercator map projection.
m = Basemap(projection='mill',lon_0=0) # Whole map
#
#
# m = Basemap(llcrnrlon=-30.,llcrnrlat=20.,urcrnrlon=60.,urcrnrlat=80.,\
# rsphere=(6378137.00,6356752.3142),\
# resolution='l',projection='merc',\
# lat_0=40.,lon_0=-20.,lat_ts=20.) #just Europe
#
# nylat, nylon are lat/lon of New York
deblat = lat1; deblon = lon1
# lonlat, lonlon are lat/lon of London.
finlat = lat2; finlon = lon2
# draw great circle route between NY and London
m.drawgreatcircle(deblon,deblat,finlon,finlat,linewidth=2,color='r')
m.drawcoastlines()
m.fillcontinents()
# draw parallels
m.drawparallels(np.arange(10,90,20),labels=[1,1,0,1])
# draw meridians
m.drawmeridians(np.arange(-180,180,30),labels=[1,1,0,1])
xpt1,ypt1 = m(lon1,lat1)
xpt2,ypt2 = m(lon2,lat2)
lonpt1, latpt1 = m(xpt1,ypt1,inverse=True) # plot a blue dot there
lonpt2, latpt2 = m(xpt2,ypt2,inverse=True) # plot a blue dot there
m.plot(xpt1,ypt1,'bo') # plot a blue dot there
m.plot(xpt2,ypt2,'bo') # plot a blue dot there
# put some text next to the dot, offset a little bit
# (the offset is in map projection coordinates)
plt.text(xpt1+100000,ypt1+100000,'Universite' % (lonpt1,latpt1))
plt.text(xpt1+100000,ypt1+100000,'Universite' % (lonpt2,latpt2))
ax.set_title('Parcours du Chercheur')
plt.show()
def draw(version, cities_coor):
m = Basemap(llcrnrlon=-180.,
llcrnrlat=-80.,
urcrnrlon=180.,
urcrnrlat=80.,
rsphere=(6378137.00, 6356752.3142),
resolution='l',
projection='mill',
lat_0=0.,
lon_0=-0.,
lat_ts=30.)
m.drawcoastlines()
m.fillcontinents()
for x in range(len(version.genom) - 1):
m.drawgreatcircle(cities_coor[version.genom[x]][1],
cities_coor[version.genom[x]][0],
cities_coor[version.genom[x + 1]][1],
cities_coor[version.genom[x + 1]][0],
linewidth=2,
color="b")
return m
def GDELT_interactions_maplot(self,counts_int):
max_val = np.log10(counts_int.max())
def get_alpha(interaction_counts):
'''
Convert a count to an alpha val.
Log-scaled
'''
scale = np.log10(interaction_counts)
return (scale/max_val) * 0.25
# Draw the basemap like before
plt.figure(figsize=(12,12))
event_map = Basemap(projection='merc',
resolution='l', area_thresh=1000.0, # Low resolution
lat_0=15, lon_0=30, # Map center
llcrnrlon=10, llcrnrlat=1, # Lower left corner
urcrnrlon=50, urcrnrlat=30) # Upper right corner
# Draw important features
event_map.drawcoastlines()
event_map.drawcountries()
event_map.fillcontinents(color='0.8')
event_map.drawmapboundary()
# Draw the lines on the map:
for arc, count in interaction_counts.iteritems():
point1, point2 = arc
y1, x1 = point1
y2, x2 = point2
# Only plot lines where both points are on our map:
if ((x1 > 10 and x1 < 100 and y1 > 20 and y1 < 70) and
(x2 > 10 and x2 < 100 and y2 > 20 and y2 < 70)):
line_alpha = get_alpha(count)
# Draw the great circle line
event_map.drawgreatcircle(x1, y1, x2, y2, linewidth=2,color='r', alpha=line_alpha)
plt.show()
def translation_pathway(N, vt=2., Ric=1221):
fig, ax = plt.subplots(1)
fig2, ax2 = plt.subplots(1)
# use low resolution coastlines.
map = Basemap(projection='moll',lat_0=0,lon_0=0,resolution='l')
# draw coastlines, country boundaries, fill continents.
map.drawcoastlines(linewidth=0.25)
map.drawcountries(linewidth=0.25)
map.fillcontinents(color='coral',lake_color='aqua')
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary(fill_color='aqua')
# draw lat/lon grid lines every 30 degrees.
map.drawmeridians(np.arange(0,360,30))
map.drawparallels(np.arange(-90,90,30))
for i in range(N):
Point = seismo.random_points(seismo="surface")
pos_1, pos_2 = seismo.bottom_point_zeta(Point, Ric=1221)
x_, y_, z_ = seismo.from_seismo_to_cartesian(Ric-Point['depth'],
Point['longitude'], Point['latitude'])
Age = geodyn.translation(x_/Ric, y_/Ric, z_/Ric, vt, 1.)
age_x, age_y = map(Point['longitude'], Point['latitude'])
map.scatter(age_x, age_y, s=Age*100, zorder=10)
#print Age, Ric-Point['depth'], Point['longitude'], Point['longitude']
Nd = 20
x, y, z, d, dx = seismo.raypath_straight(pos_1, pos_2, Nd, coordinate_type="spherical")
r, theta, phi = seismo.from_cartesian_to_seismo(x, y, z)
A = geodyn.translation(x/Ric, y/Ric, z/Ric, vt, 1.)
Age_average = np.sum(A)/Nd
map.scatter(age_x, age_y, s=Age*100, zorder=20)
ax.scatter(Point['longitude'], Age_average)
map.drawgreatcircle(pos_1['longitude'], pos_1['latitude'], pos_2['longitude'], pos_2['latitude'])
for i, xtheta in enumerate(theta[0:-1]):
map.drawgreatcircle(phi[i], theta[i], phi[i+1], theta[i+1])
def example_2():
# retrieve data
dir = "/homespace/gaubert/viirs/real-data"
#geo_file = h5py.File("%s/%s" %(dir,"GMODO_npp_d20120224_t1821456_e1823098_b01694_c20120306214722023793_cspp_dev.h5"))
#geo_file = h5py.File("%s/%s" %(dir,"GMODO_npp_d20120224_t1823110_e1824352_b01694_c20120306215057805679_cspp_dev.h5"))
#geo_file = h5py.File("%s/%s" %(dir,"GMODO_npp_d20120224_t1826018_e1827260_b01694_c20120306215454419051_cspp_dev.h5"))
#geo_file = h5py.File("%s/%s" %(dir,"GMODO_npp_d20120224_t1827272_e1828514_b01694_c20120306215852012949_cspp_dev.h5"))
geo_file = h5py.File("/homespace/gaubert/GMTCO_npp_d20120224_t1100479_e1102121_b01689_c20120224172231282331_noaa_ops.h5")
#lats = geo_file['All_Data']['VIIRS-MOD-GEO_All']['Latitude'][:]
#lons = geo_file['All_Data']['VIIRS-MOD-GEO_All']['Longitude'][:]
lats = geo_file['All_Data']['VIIRS-MOD-GEO-TC_All']['Latitude'][:]
lons = geo_file['All_Data']['VIIRS-MOD-GEO-TC_All']['Longitude'][:]
line_len = len(lats[0])
col_len = len(lats)
print("line len %d, col len %d" % (line_len, col_len))
print("Upper left corner point: (%f,%f)\n" % (lats[0][0], lons[0][0] ))
print("Lower right corner point: (%f,%f)\n" % (lats[col_len-1][line_len-1], lons[col_len-1][line_len-1]))
# draw map with markers for float locations
#m = Basemap(projection='hammer',lon_0=180)
lon_ref = lons[(col_len-1)/2][(line_len-1)/2]
#lat_ref = 10
lat_ref = lats[(col_len-1)/2][(line_len-1)/2]
#m = Basemap(projection='ortho',lat_0=lat_ref,lon_0=lon_ref,resolution='l')
m = Basemap(projection='nsper',lat_0=lat_ref,lon_0=lon_ref,satellite_height=2000*1000,resolution='l')
#x, y = m(lons[0:10],lats[0:10])
x,y = m(lons,lats)
m.drawcoastlines()
m.drawmapboundary(fill_color='#99ffff')
#m.fillcontinents(color='#cc9966',lake_color='#99ffff')
#m.scatter(x,y,s = 1 ,color='k')
m.drawgreatcircle(lons[0][0],lats[0][0],lons[0][-1],lats[0][-1],linewidth=1,color='b')
m.drawgreatcircle(lons[0][0],lats[0][0],lons[col_len-1][0],lats[col_len-1][0],linewidth=1,color='b')
m.drawgreatcircle(lons[col_len-1][0],lats[col_len-1][0],lons[col_len-1][line_len-1],lats[col_len-1][line_len-1],linewidth=1,color='b')
m.drawgreatcircle(lons[0][line_len-1],lats[0][line_len-1],lons[col_len-1][line_len-1],lats[col_len-1][line_len-1],linewidth=1,color='b')
plt.title('Location of VIIRS granule ')
plt.savefig('/tmp/plot-gran3.png')
def calling():
m = Basemap(projection='mill',
llcrnrlat = 25,
llcrnrlon = -130,
urcrnrlat = 50,
urcrnrlon = -60,
resolution='l')
m.drawcoastlines()
m.drawcountries(linewidth=2)
m.drawstates(color='b')
#m.drawcounties(color='darkred')
#m.fillcontinents()
#m.etopo()
#m.bluemarble()
xs = []
ys = []
NYClat, NYClon = 40.7127, -74.0059
xpt, ypt = m(NYClon, NYClat)
xs.append(xpt)
ys.append(ypt)
m.plot(xpt, ypt, 'c*', markersize=15)
LAlat, LAlon = 34.05, -118.25
xpt, ypt = m(LAlon, LAlat)
xs.append(xpt)
ys.append(ypt)
m.plot(xpt, ypt, 'g^', markersize=15)
m.plot(xs, ys, color='r', linewidth=3, label='Flight 98')
m.drawgreatcircle(NYClon, NYClat, LAlon, LAlat, color='c', linewidth=3, label='Arc')
plt.legend(loc=4)
plt.title('Basemap Tutorial')
plt.show()
def drawWorldMap(chromosome, countries, fname=None):
"Draws a map of the whole world"
m = Basemap(projection='robin', lon_0=0, resolution='c')
m.drawcoastlines()
m.fillcontinents(color='coral', lake_color='aqua')
# draw parallels and meridians.
m.drawparallels(np.arange(-90., 140., 30.))
m.drawmeridians(np.arange(0., 360., 60.))
m.drawmapboundary(fill_color='aqua')
# Draw points on cities
caplon = [x[3] for x in countries]
caplat = [x[2] for x in countries]
labels = [unicode(x[1], 'utf-8') for x in countries]
x, y = m(caplon, caplat)
m.plot(x, y, 'bo', markersize=5)
for i in range(len(caplon) - 1):
nylon, nylat, lonlon, lonlat = caplon[chromosome[i]], caplat[
chromosome[i]], caplon[chromosome[i + 1]], caplat[chromosome[i +
1]]
m.drawgreatcircle(nylon, nylat, lonlon, lonlat, linewidth=1, color='b')
if fname == None:
fname = 'world' + str(int(time.time()))
plt.savefig('images/' + fname + '.png')
def make_map():
m = Basemap(projection='lcc',
resolution='l',
width=2500000,
height=3200000,
lon_0=-78.70,
lat_0=-11.,
urcrnrlat=2.)
m.shadedrelief()
m.drawcountries(linewidth=0.6,
linestyle='solid',
color='k',
antialiased=1,
ax=None,
zorder=None)
m.drawrivers(linewidth=0.1,
linestyle='solid',
color='b',
antialiased=1,
ax=None,
zorder=None)
m.drawgreatcircle(lon1=0,
lat1=0,
lon2=-100,
lat2=0,
del_s=100.0,
linewidth=1,
color='w')
m.drawparallels(np.arange(int(-50.), int(50.), 10),
labels=[1, 0, 0, 0],
linewidth=0.0,
size=8)
m.drawmeridians(np.arange(int(-100.), int(-50.), 10),
labels=[0, 0, 0, 1],
linewidth=0.0,
size=8)
return m
def draw_map(coordinates:list):
"""
This function draws a map for a list of
Coordinates that would be passed as a parameter
The function loops through the list of
coordinates and then plots the map for every departure airport from the
arrival airport.
:params List[Dict[str,str]]
"""
fig=plt.figure()
ax=fig.add_axes([0.1,0.1,0.8,0.8])
m = Basemap(\
rsphere=(6378137.00,6356752.3142),\
resolution='l',projection='cyl',\
)
arrlon = float(coordinates[0]['arrLon'])
arrlat = float(coordinates[0]['arrLat'])
for i in range(len(coordinates)):
deplon = float(coordinates[i]['depLon'])
deplat = float(coordinates[i]['depLat'])
# # draw great circle route between Arrival and Department Airport
m.drawgreatcircle(deplon,deplat,arrlon,arrlat,linewidth=1,color='r')
m.plot(deplon,deplat, marker='o',color='b')
m.drawcoastlines()
m.fillcontinents()
m.drawmapboundary(fill_color='aqua')
#draw parallels
m.drawparallels(np.arange(10,90,20),labels=[1,1,0,1])
#draw meridians
m.drawmeridians(np.arange(-180,180,30),labels=[1,1,0,1])
ax.set_title('Flight Movement Map From EDDF Airport By Chinedum Roland Eke')
plt.show()
def draw(x1,x2,x3,x4): map = Basemap(projection='robin', lat_0=0, lon_0=0, resolution='l', area_thresh=1000.0) map.drawcoastlines() map.drawcountries() map.fillcontinents(color='coral', lake_color='aqua') map.drawmapboundary(fill_color='aqua') map.drawmeridians(np.arange(0,360,30)) map.drawparallels(np.arange(-90,90,30)) #initiate ocean and icecap colours #map.bluemarble() #draw a blob on the map x,y = map(x2,x1) map.plot(x,y, 'bo', markersize=10) x,y = map(x4,x3) map.plot(x,y, 'bd', markersize=10) map.drawgreatcircle(x2,x1,x4,x3,linewidth=2,color='b') plt.show()
def save_map(routes, file_name):
"""
Render flight routes to an image file.
:param list routes: flight path lines
:param str file_name: image output file name
"""
fig = plt.figure(figsize=(7.195, 3.841), dpi=100)
m = Basemap(projection='cyl', lon_0=0, resolution='c')
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
for (colour, alpha, linewidth, lat1, long1, lat2, long2) in sorted(routes):
"""
Cannot handle situations in which the great circle intersects the
edge of the map projection domain, and then re-enters the domain.
Fix from: http://stackoverflow.com/questions/13888566/
"""
line, = m.drawgreatcircle(long1,
lat1,
long2,
lat2,
linewidth=linewidth,
color=colour,
alpha=alpha,
solid_capstyle='round')
p = line.get_path()
# Find the index which crosses the dateline (the delta is large)
cut_point = np.where(np.abs(np.diff(p.vertices[:, 0])) > 200)[0]
if cut_point:
cut_point = cut_point[0]
# Create new vertices with a nan in between and set
# those as the path's vertices
new_verts = np.concatenate([
p.vertices[:cut_point, :], [[np.nan, np.nan]],
p.vertices[cut_point + 1:, :]
])
p.codes = None
p.vertices = new_verts
m.warpimage(image="earth_lights_lrg.jpg")
plt.savefig(file_name, dpi=1000)
def draw_records(rdd, n: int, colors="bgrcmy", alpha=1, seed=0):
"""
n = -1 for all records
"""
m = Basemap(llcrnrlon=-30.,
llcrnrlat=30.,
urcrnrlon=40.,
urcrnrlat=75.,
rsphere=(6378137.00, 6356752.3142),
resolution='l',
projection='merc',
lat_ts=20.)
colors = itertools.cycle(colors)
if type(rdd) == RDD:
collection = rdd.takeSample(False, n,
seed) if n >= 0 else rdd.collect()
else:
collection = rdd[:n] if n >= 0 else rdd
for i, (c, record) in enumerate(zip(colors, collection)):
print("{} over {}".format(i, len(collection)))
lat, long, time, alt, speed = record.Lat, record.Long, record.Time, record.Alt, record.Speed
# print((record["From"]["Lat"], record["From"]["Long"], record["From"]["Alt"]))
m.drawgreatcircle(record["From"]["Long"],
record["From"]["Lat"],
long[0],
lat[0],
color="k",
alpha=alpha)
for x1, x2 in zip(
zip(lat[:-1], long[:-1], time[:-1], alt[:-1], speed[:-1]),
zip(lat[1:], long[1:], time[1:], alt[1:], speed[1:])):
lat1, long1, t1, alt1, s1 = x1
lat2, long2, t2, alt2, s2 = x2
# print((lat1, long1, alt1, s1), (lat2, long2, alt2, s2), (t2-t1)/1000)
m.drawgreatcircle(long1, lat1, long2, lat2, color=c, alpha=alpha)
# print((record["To"]["Lat"], record["To"]["Long"], record["To"]["Alt"]))
m.drawgreatcircle(long[-1],
lat[-1],
record["To"]["Long"],
record["To"]["Lat"],
color="k",
alpha=alpha)
m.drawcoastlines()
m.fillcontinents()
# draw parallels
m.drawparallels(np.arange(10, 90, 5), labels=[1, 1, 0, 1])
# draw meridians
m.drawmeridians(np.arange(-180, 180, 10), labels=[1, 1, 0, 1])
plt.show()
def map_stream(st,showpath=True,showplot=True,Lat_0=0.0,Lon_0=60.0):
from mpl_toolkits.basemap import Basemap
fig = plt.figure()
plt.ion()
m = Basemap(projection='ortho',lat_0=Lat_0,lon_0=Lon_0,resolution='l')
m.drawmapboundary()
m.drawcoastlines()
m.fillcontinents(color='gray',lake_color='white')
gc_lines = []
for tr in st:
x1,y1 = m(tr.stats.sac['evlo'],tr.stats.sac['evla'])
x2,y2 = m(tr.stats.sac['stlo'],tr.stats.sac['stla'])
m.scatter(x1,y1,s=200.0,marker='*',facecolors='y',edgecolors='k',zorder=99)
station_pt = m.scatter(x2,y2,s=20.0,marker='^',color='b',zorder=99,picker=1)
station_pt.set_label(tr.stats.station)
if showpath == True:
gc_line = m.drawgreatcircle(tr.stats.sac['evlo'],tr.stats.sac['evla'],
tr.stats.sac['stlo'],tr.stats.sac['stla'],
linewidth=1,color='k',alpha=0.5)
gc_line[0].set_label(tr.stats.station)
gc_lines.append(gc_line)
def onpick(event):
art = event.artist
picked = art.get_label()
print "removing station(s) ", picked
st_to_remove = st.select(station=picked)
for killed_tr in st_to_remove:
st.remove(killed_tr)
art.remove()
for gc in gc_lines:
gc_line_label = gc[0].get_label()
if gc_line_label == picked:
gc[0].remove()
fig.canvas.draw()
fig.canvas.mpl_connect('pick_event', onpick)
if showplot == True:
plt.show()
else:
return m
def save_map(routes, file_name):
"""
Render flight routes to an image file.
:param list routes: flight path lines
:param str file_name: image output file name
"""
fig = plt.figure(figsize=(7.195, 3.841), dpi=100)
m = Basemap(projection='cyl', lon_0=0, resolution='c')
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
for (colour, alpha, linewidth, lat1, long1, lat2, long2) in sorted(routes):
"""
Cannot handle situations in which the great circle intersects the
edge of the map projection domain, and then re-enters the domain.
Fix from: http://stackoverflow.com/questions/13888566/
"""
line, = m.drawgreatcircle(long1, lat1, long2, lat2,
linewidth=linewidth,
color=colour,
alpha=alpha,
solid_capstyle='round')
p = line.get_path()
# Find the index which crosses the dateline (the delta is large)
cut_point = np.where(np.abs(np.diff(p.vertices[:, 0])) > 200)[0]
if cut_point:
cut_point = cut_point[0]
# Create new vertices with a nan in between and set
# those as the path's vertices
new_verts = np.concatenate([p.vertices[:cut_point, :],
[[np.nan, np.nan]],
p.vertices[cut_point+1:, :]])
p.codes = None
p.vertices = new_verts
m.warpimage(image="earth_lights_lrg.jpg")
plt.savefig(file_name, dpi=1000)
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
# setup mercator map projection.
m = Basemap(
llcrnrlon=-100.0,
llcrnrlat=20.0,
urcrnrlon=20.0,
urcrnrlat=60.0,
rsphere=(6378137.00, 6356752.3142),
resolution="l",
projection="merc",
lat_0=40.0,
lon_0=-20.0,
lat_ts=20.0,
)
# nylat, nylon are lat/lon of New York
nylat = 40.78
nylon = -73.98
# lonlat, lonlon are lat/lon of London.
lonlat = 51.53
lonlon = 0.08
# draw great circle route between NY and London
m.drawgreatcircle(nylon, nylat, lonlon, lonlat, linewidth=2, color="b")
m.drawcoastlines()
m.fillcontinents()
# draw parallels
m.drawparallels(np.arange(10, 90, 20), labels=[1, 1, 0, 1])
# draw meridians
m.drawmeridians(np.arange(-180, 180, 30), labels=[1, 1, 0, 1])
ax.set_title("Great Circle from New York to London")
plt.savefig("plotgreatcircle.png")
plt.text(xpt,ypt,label)
"""
Next, let's display each edge in our array:
"""
twoFlights = flights.dot(flights)
threeFlights = flights.dot(flights).dot(flights)
print twoFlights
print
print threeFlights
for c1 in cityNum.keys():
for c2 in cityNum.keys():
#if c1 != c2 and flights[cityNum[c1],cityNum[c2]] > 0:
if c1 != c2 and twoFlights[cityNum[c1],cityNum[c2]] > 0:
#if c1 != c2 and threeFlights[cityNum[c1],cityNum[c2]] > 0:
#Get city coordinates:
c1lat,c1lon = cityCoords[c1]
c2lat,c2lon = cityCoords[c2]
print c1, c1lon, c1lat, c2, c2lat,c2lon
#Draw edge between them:
m.drawgreatcircle(c1lon,c1lat,c2lon,c2lat,linewidth=2,color='b')
"""
Display the final product:
"""
plt.show()
class WorldMap(object):
def __init__(self, world_size=30):
plt.clf()
self.world_size = world_size
self.world_map = Basemap(projection="vandg", lat_0=0, lon_0=0)
self.world_map.drawparallels(np.arange(-90.0, 91.0, 180.0 / (world_size - 1.0)), latmax=90)
self.world_map.drawmeridians(np.arange(0, 360, (360.0 / world_size)), latmax=90)
def tron_to_lonlat(self, tx, ty):
lat = 180.0 / (self.world_size - 1.0) * ty - 90.0
lon = (360.0 / self.world_size) * tx
return (lon, lat)
def tron_to_xy(self, tx, ty):
(lon, lat) = self.tron_to_lonlat(tx, ty)
return self.world_map(lon, lat)
def _plot_trace(self, trace, color):
if len(trace) > 0:
x, y = self.tron_to_xy(trace[0][0], trace[0][1])
self.world_map.plot(x, y, color + "o", markersize=8.0)
if len(trace) > 1:
lon0, lat0 = self.tron_to_lonlat(trace[0][0], trace[0][1])
for pos in trace[1:]:
lon, lat = self.tron_to_lonlat(pos[0], pos[1])
if (lon0 == 180.0) and (lon >= 180.0):
self.world_map.drawgreatcircle(lon0 + 0.001, lat0, lon + 0.001, lat, linewidth=5, color=color)
elif (lon0 >= 180.0) and (lon == 180.0):
self.world_map.drawgreatcircle(lon0 + 0.001, lat0, lon + 0.001, lat, linewidth=5, color=color)
else:
self.world_map.drawgreatcircle(lon0, lat0, lon, lat, linewidth=5, color=color)
lon0, lat0 = lon, lat
if trace[-1][0] >= 15:
x, y = self.tron_to_xy(trace[-1][0] + 0.001, trace[-1][1])
else:
x, y = self.tron_to_xy(trace[-1][0], trace[-1][1])
self.world_map.plot(x, y, color + "D", markersize=8.0)
def plot_trace(self, trace1=None, trace2=None, player1=BLUE, player2=RED):
if player1 == BLUE:
p1color = "b"
elif player1 == RED:
p1color = "r"
else:
p1color = "m"
if player2 == BLUE:
p2color = "b"
elif player2 == RED:
p2color = "r"
else:
p2color = "m"
self._plot_trace(trace1, p1color)
self._plot_trace(trace2, p2color)
def plot_points(self, points, color="k"):
for point in points:
x, y = self.tron_to_xy(point[0] + 0.001, point[1])
self.world_map.plot(x, y, color + "s", markersize=6.0)
def show(self, title=None):
if title:
plt.title(title)
plt.show()
def save(self, title=None, filename="world.png"):
if title:
plt.title(title)
fig = plt.gcf()
fig.set_size_inches(16, 12)
plt.savefig(filename, dpi=100)
def map_G(G):
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap
import matplotlib.cm as cmx
import matplotlib as mpl
mpl.rcParams['font.size'] = 10.
mpl.rcParams['axes.labelsize'] = 8.
mpl.rcParams['xtick.labelsize'] = 6.
mpl.rcParams['ytick.labelsize'] = 6.
from shapelib import ShapeFile
import dbflib
from matplotlib.collections import LineCollection
from matplotlib import cm
import matplotlib.colors as colors
###########################################################################################
fig = plt.figure(3)
#Custom adjust of the subplots
plt.subplots_adjust(left=0.05,right=0.95,top=0.90,bottom=0.05,wspace=0.15,hspace=0.05)
ax = plt.subplot(111)
m = Basemap(projection='cyl',\
llcrnrlon=-9, \
llcrnrlat=3.8, \
urcrnrlon=-1.5, \
urcrnrlat = 11, \
resolution = 'h', \
# projection = 'tmerc', \
lat_0 = 7.38, \
lon_0 = -5.30)
# read subpref coordinates
subpref_coord = read_in_subpref_lonlat()
shp = ShapeFile(r'/home/sscepano/DATA SET7S/D4D/SubPrefecture/GEOM_SOUS_PREFECTURE')
dbf = dbflib.open(r'/home/sscepano/DATA SET7S/D4D/SubPrefecture/GEOM_SOUS_PREFECTURE')
for npoly in range(shp.info()[0]):
shpsegs = []
shpinfo = []
shp_object = shp.read_object(npoly)
verts = shp_object.vertices()
rings = len(verts)
for ring in range(rings):
lons, lats = zip(*verts[ring])
# if max(lons) > 721. or min(lons) < -721. or max(lats) > 91. or min(lats) < -91:
# raise ValueError,msg
x, y = m(lons, lats)
shpsegs.append(zip(x,y))
if ring == 0:
shapedict = dbf.read_record(npoly)
#print shapedict
name = shapedict["ID_DEPART"]
subpref_id = shapedict["ID_SP"]
# add information about ring number to dictionary.
shapedict['RINGNUM'] = ring+1
shapedict['SHAPENUM'] = npoly+1
shpinfo.append(shapedict)
#print subpref_id
#print name
lines = LineCollection(shpsegs,antialiaseds=(1,))
# lines.set_facecolors(col[subpref_id])
lines.set_edgecolors('gray')
lines.set_linewidth(0.1)
ax.add_collection(lines)
if G.has_node(-1):
G.remove_node(-1)
if G.has_node(0):
G.remove_node(0)
###########################################################################################################
### this is the main part: scale weights of # commuters, use colormap by work location and then plot
### all or just the routes with more that 10 commutes
###########################################################################################################
# max7s = 0
# min7s = 10000000
# for u,v,d in G.edges(data=True):
# if d['weight'] > max7s:
# max7s = d['weight']
# if d['weight'] < min7s:
# min7s = d['weight']
#
# max7s = float(max7s)
# print "max", (max7s)
# print "min", (min7s)
#
# scaled_weight = defaultdict(int)
#
# for i in range(len(G.edges())):
# scaled_weight[i] = defaultdict(int)
# for u,v,d in G.edges(data=True):
# scaled_weight[u][v] = (d['weight'] - min7s) / (max7s - min7s)
values = range(256)
jet = cm = plt.get_cmap('jet')
cNorm = colors.Normalize(vmin=0, vmax=values[-1])
scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=jet)
for u, v, d in G.edges(data=True):
# lo = []
# la = []
# lo.append(subpref_coord[u][0])
# lo.append(subpref_coord[v][0])
# la.append(subpref_coord[u][1])
# la.append(subpref_coord[v][1])
# x, y = m(lo, la)
# linewidth7s = scaled_weight[u][v] * 2.5 + 0.25
# m.plot(x,y, linewidth= linewidth7s)
# if linewidth7s > 1:
# print (linewidth7s)
if d['weight'] >= 0:
colorVal = scalarMap.to_rgba(values[v])
# linewidth7s = scaled_weight[u][v] * 2.5 + 0.35
# print u, v, d['weight'], scaled_weight[u][v]
###########################################################################################################
### no scaling vs scaling the width of the line
###########################################################################################################
# linewidth7s = d['weight'] / 10
m.drawgreatcircle(subpref_coord[u][0], subpref_coord[u][1], \
subpref_coord[v][0], subpref_coord[v][1], linewidth= d['weight']*100, color=colorVal)
# m.drawcoastlines()
#m.fillcontinents()
plt.savefig('/home/sscepano/Project7s/D4D/CI/commuting_centers/Igor/high_betweenes_routes4.png',dpi=700)
#plt.show()
###################################################################################################3
return
d_long = end_long - start_long
a = math.sin(d_latt/2)**2 + math.cos(start_latt) * math.cos(end_latt) * math.sin(d_long/2)**2
c = 2 * math.asin(math.sqrt(a))
return 6371 * c *1000
longslist=[0,90,180]
latslist=[65,65,65]
dpslist=[5,10,5]
dmslist=[5,5,10]
print m(0,60)
print m(0,70)
print m(-5,65)
print m(5,65)
print m.gcpoints(0,60,0,70,10)
m.drawgreatcircle(0,60,0,70,100)
m.drawgreatcircle(-5,65,5,65,100)
m.drawgreatcircle(0,60,-5,65,100)
m.drawgreatcircle(0,60,5,65,100)
m.drawgreatcircle(-5,65,0,70,100)
m.drawgreatcircle(0,70,5,65,100)
'''
# draw ellipses
for n in range(0,len(longslist)):
xy= m(longslist[n],latslist[n])
w = haversine(longslist[n]-dmslist[n],latslist[n],longslist[n]+dmslist[n],latslist[n])
h = haversine(longslist[n],latslist[n]-dpslist[n],longslist[n],latslist[n]+dpslist[n])
e = Ellipse(xy, w,h,longslist[n])
print xy, w,h,e
top_right_lon = get_domain('full_utah')['top_right_lon']
top_right_lat = get_domain('full_utah')['top_right_lat']
m = Basemap(resolution='i',area_thresh=10.,projection='cyl',\
llcrnrlon=bot_left_lon,llcrnrlat=bot_left_lat,\
urcrnrlon=top_right_lon,urcrnrlat=top_right_lat,)
m.drawstates(color='k', linewidth=.8)
m.drawcoastlines()
m.drawcounties()
m.fillcontinents()
#Plot Subdomains (Salt Lake Valley, Utah Lake, etc...)
for area in ['salt_lake_valley','utah_valley','cache_valley','uintah_basin','bear_lake']:
domain = get_domain(area)
toprightlat = domain['top_right_lat']
topleftlat = domain['top_right_lat']
toprightlon = domain['top_right_lon']
topleftlon = domain['bot_left_lon']
botrightlat = domain['bot_left_lat']
botrightlon = domain['top_right_lon']
botleftlat = domain['bot_left_lat']
botleftlon = domain['bot_left_lon']
m.drawgreatcircle(toprightlon,toprightlat,topleftlon,topleftlat, color='#FFFF4C', linewidth='3')
m.drawgreatcircle(topleftlon,topleftlat,botleftlon,botleftlat, color='#FFFF4c', linewidth='3')
m.drawgreatcircle(botleftlon,botleftlat,botrightlon,botrightlat, color='#FFFF4c', linewidth='3')
m.drawgreatcircle(botrightlon,botrightlat,toprightlon,toprightlat, color='#FFFF4c', linewidth='3')
# <headingcell level=2>
# Grafisch
# <codecell>
fig = plt.figure(figsize=(9,9))
m = Basemap(projection='ortho',lon_0=lon0,lat_0=lat0,resolution='l')
m.shadedrelief()
# draw parallels and meridians.
m.drawparallels(np.arange(-90.,120.,30.))
m.drawmeridians(np.arange(0.,420.,10.))
# draw distance
m.drawgreatcircle(lon1,lat1,lon2,lat2,linewidth=2,color='b')
# draw km
x, y = m(lon0, lat0+0.5)
sx,sy= m(lon1, lat1)
ex,ey= m(lon2, lat2)
plt.text(x, y, '%dkm' % (dist2), color='k', ha='center', va='bottom',fontsize=14)
plt.text(sx,sy, sadr, color='k', ha='left',fontsize=9)
plt.text(ex,ey, eadr, color='k', ha='left',fontsize=9)
fig.savefig('Distance-Berlin-Lisbon.png',dpi=72,transparent=True,bbox_inches='tight')
# <codecell>
print('Done.')
# <codecell>
def johnsons(input_file="input.csv"):
lats = []
longs = []
weights = []
names = []
path = []
paths = []
minLat = 90;
minLong = 180;
maxLat = -90
maxLong =-180
with open(input_file) as input_csv:
csv_reader = csv.reader(input_csv)
for row in csv_reader:
if row[0] != "done":
x, y, w, n = float(row[0]), float(row[1]), row[2], row[3]
lats.append(x)
longs.append(y)
weights.append(w)
names.append(n)
if x<minLat:
minLat=x
if y<minLong:
minLong = y
if x>maxLat:
maxLat = x
if y>maxLong:
maxLong = y
else:
path.append(lats)
path.append(longs)
path.append(weights)
path.append(names)
paths.append(path)
lats = []
longs = []
weights = []
names = []
path = []
# create background map
if minLat -10 >-90:
minLat = minLat-10
if maxLat +10 <90:
maxLat = maxLat +10
if minLong -10 >-180:
minLong = minLong-10
if maxLong +10<180:
maxLong = maxLong+10
m= Basemap(llcrnrlon=minLong, llcrnrlat=minLat, urcrnrlon=maxLong,
urcrnrlat=maxLat, projection='merc', lat_1=33, lat_2=45,
lon_0=-95, resolution='c', area_thresh=10000)
m.drawcoastlines()
m.drawmapboundary(fill_color='aqua')
m.drawcountries()
m.fillcontinents(color='green', lake_color='aqua')
m.drawstates()
for p in paths:
in_lats= p[0];
in_longs =p[1];
in_names = p[3];
in_weight = p[2];
ypt, xpt = m(in_longs, in_lats)
m.plot(ypt, xpt, 'bo', markersize=10)
for y, x, name in zip(ypt,xpt,in_names):
plt.text(y-1000,x+1000,name)
for i in range(0,len(in_lats)-1):
m.drawgreatcircle(in_longs[i], in_lats[i], in_longs[i+1], in_lats[i+1], linewidth=1, color='r')
for i in range(0,len(in_weight)-1):
plt.text(((ypt[i]+ypt[i+1])/2),((xpt[i]+xpt[i+1])/2),in_weight[i+1])
plt.show()
rsphere=(6378137.00,6356752.3142),\
resolution='c',area_thresh=10000.,projection='merc',\
lat_0=40.,lon_0=-20.,lat_ts=20.)
# nylat, nylon are lat/lon of New York
nylat = 40.78
nylon = -73.98
# lonlat, lonlon are lat/lon of London.
lonlat = 51.53
lonlon = 0.08
# find 1000 points along the great circle.
#x,y = m.gcpoints(nylon,nylat,lonlon,lonlat,1000)
# draw the great circle.
#m.plot(x,y,linewidth=2)
# drawgreatcircle performs the previous 2 steps in one call.
m.drawgreatcircle(nylon,nylat,lonlon,lonlat,linewidth=2,color='b')
m.drawcoastlines()
m.fillcontinents()
# draw parallels
circles = np.arange(10,90,20)
m.drawparallels(circles,labels=[1,1,0,1])
# draw meridians
meridians = np.arange(-180,180,30)
m.drawmeridians(meridians,labels=[1,1,0,1])
plt.title('Great Circle from New York to London (Mercator)')
sys.stdout.write('plotting Great Circle from New York to London (Mercator)\n')
# create new figure
fig=plt.figure()
# setup a gnomonic projection.
def prims(input_file= "input.csv"):
lats = []
longs = []
weights = []
names = []
neighbors = []
with open(input_file) as input_csv:
csv_reader = csv.reader(input_csv)
for row in csv_reader:
x,y,w,n,ne = float(row[0]), float(row[1]), row[2], row[3], row[4]
lats.append(x)
longs.append(y)
weights.append(w)
names.append(n)
neighbors.append(ne)
# background map
minLat=min(lats)
maxLat=max(lats)
minLong = min(longs)
maxLong = max(longs)
if minLat -10 >-90:
minLat = minLat-10
if maxLat +10 <90:
maxLat = maxLat +10
if minLong -10 >-180:
minLong = minLong-10
if maxLong +10<180:
maxLong = maxLong+10
m= Basemap(llcrnrlon=minLong, llcrnrlat=minLat, urcrnrlon=maxLong,
urcrnrlat=maxLat, projection='merc', lat_1=33, lat_2=45,
lon_0=-95, resolution='c', area_thresh=10000)
m.drawcoastlines()
m.drawmapboundary(fill_color='aqua')
m.fillcontinents(color='green', lake_color='aqua')
m.drawstates()
m.drawcountries()
ypt, xpt = m(longs, lats)
m.plot(ypt, xpt, 'bo', markersize=10)
for y, x, name in zip(ypt,xpt,names):
plt.text(y+1000,x+1000,name)
for i in range(0,(len(longs))):
neighbors_list = neighbors[i].split("_");
inner_lats = []
inner_longs = []
inner_weight = []
for neighbor in neighbors_list:
if(neighbor==''):
continue
value_list = neighbor.split(";")
if(len(value_list)>=2):
if(value_list[0] != " " and value_list[1] != " "):
lat = float(value_list[0])
lng = float(value_list[1])
w = float(value_list[2])
inner_lats.append(lat)
inner_longs.append(lng)
inner_weight.append(w)
if(inner_longs!= []):
in_ypt, in_xpt = m(inner_longs, inner_lats)
m.plot(in_ypt, in_xpt, 'bo', markersize=10)
inner_y, inner_x = m(inner_longs,inner_lats)
for j in range(0,len(inner_longs)):
m.drawgreatcircle(longs[i],lats[i],inner_longs[j],inner_lats[j], linewidth=1,color="r")
plt.text((ypt[i]+inner_y[j])/2,(xpt[i]+inner_x[j])/2,inner_weight[j])
plt.show()
#lat_1=minlat, lat_2=maxlat,
lat_0=minlat + height/2,
lon_0=minlon + width/2,)
#lon_0=-180)
m.drawcoastlines()
m.drawstates()
m.drawcountries()
m.fillcontinents()
#m.drawparallels(np.arange(pts.latitude.min(),pts.latitude.max(),2.), labels=[1,1,1,1], fmt="%0.1f")
#m.drawmeridians(np.arange(pts.longitude.min(), pts.longitude.max(),5.), labels=[1,1,1,1], fmt="%0.1f")
for f in fly.iterrows():
f = f[1]
m.drawgreatcircle(f.startlon, f.startlat, f.endlon, f.endlat, linewidth=3, alpha=0.4, color='b' )
m.plot(*m(f.startlon, f.startlat), color='g', alpha=0.8, marker='o')
m.plot(*m(f.endlon, f.endlat), color='r', alpha=0.5, marker='o' )
#pa = Point(m(f.startlon, f.startlat))
#pb = Point(m(f.endlon, f.endlat))
#plt.plot([pa.x, pb.x], [pa.y, pb.y], linewidth=4)
plt.savefig('data/flightdata.png', dpi=300, frameon=False, transparent=True)
# <headingcell level=1>
# Scratch
# <codecell>
flights.distance.sum()
def map_commutes(G):
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap
import matplotlib as mpl
mpl.rcParams['font.size'] = 10.
mpl.rcParams['axes.labelsize'] = 8.
mpl.rcParams['xtick.labelsize'] = 6.
mpl.rcParams['ytick.labelsize'] = 6.
from shapelib import ShapeFile
import dbflib
from matplotlib.collections import LineCollection
from matplotlib import cm
###########################################################################################
fig = plt.figure(3)
#Custom adjust of the subplots
plt.subplots_adjust(left=0.05,right=0.95,top=0.90,bottom=0.05,wspace=0.15,hspace=0.05)
ax = plt.subplot(111)
m = Basemap(projection='cyl',\
llcrnrlon=-9, \
llcrnrlat=3.8, \
urcrnrlon=-1.5, \
urcrnrlat = 11, \
resolution = 'h', \
# projection = 'tmerc', \
lat_0 = 7.38, \
lon_0 = -5.30)
# read subpref coordinates
subpref_coord = read_subpref_lonlat()
shp = ShapeFile(r'/home/sscepano/DATA SET7S/D4D/SubPrefecture/GEOM_SOUS_PREFECTURE')
dbf = dbflib.open(r'/home/sscepano/DATA SET7S/D4D/SubPrefecture/GEOM_SOUS_PREFECTURE')
for npoly in range(shp.info()[0]):
shpsegs = []
shpinfo = []
shp_object = shp.read_object(npoly)
verts = shp_object.vertices()
rings = len(verts)
for ring in range(rings):
lons, lats = zip(*verts[ring])
# if max(lons) > 721. or min(lons) < -721. or max(lats) > 91. or min(lats) < -91:
# raise ValueError,msg
x, y = m(lons, lats)
shpsegs.append(zip(x,y))
if ring == 0:
shapedict = dbf.read_record(npoly)
#print shapedict
name = shapedict["ID_DEPART"]
subpref_id = shapedict["ID_SP"]
# add information about ring number to dictionary.
shapedict['RINGNUM'] = ring+1
shapedict['SHAPENUM'] = npoly+1
shpinfo.append(shapedict)
#print subpref_id
#print name
lines = LineCollection(shpsegs,antialiaseds=(1,))
# lines.set_facecolors(col[subpref_id])
lines.set_edgecolors('k')
lines.set_linewidth(0.2)
ax.add_collection(lines)
if G.has_node(-1):
G.remove_node(-1)
if G.has_node(0):
G.remove_node(0)
max7s = 1
min7s = 10000000
for u,v,d in G.edges(data=True):
if d['weight'] > max7s:
max7s = d['weight']
if d['weight'] < min7s:
min7s = d['weight']
max7s = float(max7s)
print "max", (max7s)
print "min", (min7s)
scaled_weight = defaultdict(int)
for i in range(256):
scaled_weight[i] = defaultdict(int)
for u,v,d in G.edges(data=True):
scaled_weight[u][v] = (d['weight'] - min7s) / (max7s - min7s)
for u, v, d in G.edges(data=True):
# lo = []
# la = []
# lo.append(subpref_coord[u][0])
# lo.append(subpref_coord[v][0])
# la.append(subpref_coord[u][1])
# la.append(subpref_coord[v][1])
# x, y = m(lo, la)
# linewidth7s = scaled_weight[u][v] * 2.5 + 0.25
# m.plot(x,y, linewidth= linewidth7s)
# if linewidth7s > 1:
# print (linewidth7s)
linewidth7s = scaled_weight[u][v] * 2.5 + 0.25
m.drawgreatcircle(subpref_coord[u][0], subpref_coord[u][1], \
subpref_coord[v][0], subpref_coord[v][1], linewidth= linewidth7s, color='r')
m.drawcoastlines()
m.fillcontinents()
plt.savefig('/home/sscepano/Project7s/D4D/CI/urban_rural/home_work/OUTPUT_files/maps/hw_commuting_cur.png',dpi=700)
#plt.show()
###################################################################################################3
return
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
map = Basemap(projection='merc',
lat_0=0, lon_0=0,
llcrnrlon=-20.,llcrnrlat=0.,urcrnrlon=180.,urcrnrlat=80.)
map.drawmapboundary(fill_color='aqua')
map.fillcontinents(color='coral',lake_color='aqua')
map.drawcoastlines()
map.drawparallels(range(0, 90, 20))
map.drawmeridians(range(0, 180, 20))
#Paris-Tokyo
map.drawgreatcircle(2.3, 48.9, 139.7, 35.6,linewidth=2,color='r')
#Tokyo-Dubai
map.drawgreatcircle(139.7, 35.6, 55.2, 25.,linewidth=2,color='r')
#Dubai-Paris
map.drawgreatcircle(55.2, 25., 2.3, 48.9,linewidth=2,color='r')
plt.show()
def render(segments):
# create new figure, axes instances.
fig = plt.figure()
ax = fig.add_axes([0.1,0.1,0.8,0.8], axisbg = '#a5bfdd')
llcrnrlon = config.map_dimensions['lon'][0]
urcrnrlon = config.map_dimensions['lon'][1]
llcrnrlat = config.map_dimensions['lat'][0]
urcrnrlat = config.map_dimensions['lat'][1]
# setup mercator map projection.
m = Basemap(
llcrnrlon = llcrnrlon, llcrnrlat = llcrnrlat,
urcrnrlon = urcrnrlon, urcrnrlat = urcrnrlat,
rsphere = (6378137.00,6356752.3142),
resolution = 'c', projection = 'merc',
#lat_0 = 40.,lon_0 = -20.,lat_ts = 20.
)
for segment in segments['benchmark']:
m.drawgreatcircle(segment.start.lon, segment.start.lat,
segment.end.lon, segment.end.lat,
linewidth = 1, color='#00458A')
x, y = m(segment.start.lon, segment.start.lat)
m.plot(x, y, 'bo', ms = 4)
x, y = m(segment.end.lon, segment.end.lat)
m.plot(x, y, 'bo', ms = 4)
for segment in segments['formation']:
p('geo-debug', 'Start to plot a formation trajectory')
p('geo-debug', 'Trajectory: (%s, %s) -> (%s, %s)' % (
segment.start.lon, segment.start.lat,
segment.end.lon, segment.end.lat
))
m.drawgreatcircle(segment.start.lon, segment.start.lat,
segment.end.lon, segment.end.lat,
linewidth = 1, color='g')
x, y = m(segment.start.lon, segment.start.lat)
m.plot(x, y, 'go', ms = 4)
x, y = m(segment.end.lon, segment.end.lat)
m.plot(x, y, 'go', ms = 4)
p('geo-debug', 'Done with plotting a formation trajectory')
for segment in segments['solo']:
m.drawgreatcircle(segment.start.lon, segment.start.lat,
segment.end.lon, segment.end.lat,
linewidth = 1, color='r')
x, y = m(segment.start.lon, segment.start.lat)
m.plot(x, y, 'ro', ms = 4)
x, y = m(segment.end.lon, segment.end.lat)
m.plot(x, y, 'ro', ms = 4)
m.drawcoastlines(color='#8f8457')
m.fillcontinents(color='#f5f0db')
m.drawcountries(color='#a9a06d')
m.drawparallels(config.map['parallels'], labels = [1,1,0,1])
m.drawmeridians(config.map['meridians'], labels = [1,1,0,1])
return plt, ax
#!/bin/env python
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
from mpl_toolkits.basemap import Basemap
import numpy as np
import matplotlib.pyplot as plt
from g import getCoordinates
# llcrnrlat,llcrnrlon,urcrnrlat,urcrnrlon
# are the lat/lon values of the lower left and upper right corners
# of the map.
# resolution = 'c' means use crude resolution coastlines.
fig = plt.figure(figsize=(20,18))
m = Basemap(projection='cyl',llcrnrlat=-90,urcrnrlat=90,\
llcrnrlon=-180,urcrnrlon=180,resolution='c')
m.drawcoastlines()
m.fillcontinents(color='grey',lake_color='black')
# lonlat, lonlon are lat/lon of London.
lonlat = 51.53; lonlon = 0.08
for c in getCoordinates():
if len(c['Longitude']) > 2:
lon = float(c['Longitude'])
lat = float(c['Latitude'])
m.drawgreatcircle(lon, lat,lonlon,lonlat,linewidth=2,color='b')
m.drawparallels(np.arange(-90.,91.,30.), color='red')
m.drawmeridians(np.arange(-180.,181.,60.), color='red')
m.drawmapboundary(fill_color='black')
plt.title("How about a nice game of chess?")
plt.show()
# Draw the points on the map:
for arc, count in interaction_counts.iteritems():
point1, point2 = arc
y1, x1 = point1
y2, x2 = point2
## if x1<-30:
## x1=x1+360
## if x2<-30:
## x2=x2+360
# Only plot lines where both points are on our map:
if ((y1 > -60 and y1 < 75) and (y2 > -60 and y2 < 75)):
line_alpha = get_alpha(count)
#line, =
event_map.drawgreatcircle(x1, y1, x2, y2, linewidth=3, color='r', alpha=line_alpha)
'''
p = line.get_path()
# find the index which crosses the dateline (the delta is large)
cut_point = np.where(np.abs(np.diff(p.vertices[:, 0])) > 200)[0]
if cut_point:
cut_point = cut_point[0]
# create new vertices with a nan inbetween and set those as the path's vertices
new_verts = np.concatenate(
[p.vertices[:cut_point, :],
[[np.nan, np.nan]],
p.vertices[cut_point+1:, :]]
)
p.codes = None
p.vertices = new_verts
'''
