def mark_pixel(pixels, color='g', ax=None, linewidth=None):
''' surrounds pixels given by pixels with a border '''
pixel_x, pixel_y = get_pixel_coords()
if ax is None:
ax = plt.gca()
patches = []
for xy in zip(pixel_x[pixels], pixel_y[pixels]):
patches.append(
RegularPolygon(
xy=xy,
numVertices=6,
radius=9.5 / np.sqrt(3),
orientation=0., # in radians
fill=False,
))
if linewidth is None:
linewidth = calc_linewidth(ax=ax)
collection = PatchCollection(patches, picker=0)
collection.set_linewidth(linewidth)
collection.set_edgecolors(color)
collection.set_facecolor('none')
ax.add_collection(collection)
plt.draw_if_interactive()
return collection
def add_blobs(rows, columns, sizes, color=None, ax=None):
"""The function draws circles around given pixel coordinates
Parameters
-----------
rows: array
pixel positions, y axis
columns: array
pixel positions, x axis
sizes:array
Returns
-------
star_circles:
"""
ax = ax or plt.gca()
star_circles = PatchCollection([
Circle((col, row), radius=3 * sigma)
for row, col, sigma in zip(rows, columns, sizes)
])
star_circles.set_facecolor('none')
color = color or next(ax._get_lines.prop_cycler).get('color')
star_circles.set_edgecolor(color)
ax.add_collection(star_circles)
return star_circles
def _create_patch(self):
"""Creates a matplotlib polygon patch from the Shape points.
This is used when making 2d images of the Shape object.
:raises ValueError: No points defined for the Shape
:return: a plotable polygon shape
:rtype: Matplotlib object patch
"""
if self.points is None:
ValueError("No points defined for", self)
patches = []
xylist = []
for x1, z1 in zip([row[0] for row in self.points],
[row[1] for row in self.points]):
xylist.append([x1, z1])
polygon = Polygon(xylist, closed=True)
patches.append(polygon)
p = PatchCollection(patches)
if self.color is not None:
p.set_facecolor(self.color)
p.set_color(self.color)
p.color = self.color
p.edgecolor = self.color
# checks to see if an alpha value is provided in the color
if len(self.color) == 4:
p.set_alpha = self.color[-1]
self.patch = p
return p
def make_plot_delta(date, start_date, end_date, dframe, save=False):
fig, ax = plt.subplots(figsize=(15, 10))
m = Basemap(llcrnrlon=-105.0,
llcrnrlat=45.4,
urcrnrlon=-95.7,
urcrnrlat=49.5,
projection='merc',
resolution='h')
cmap = plt.get_cmap('seismic')
pc = PatchCollection(dframe.shapes, zorder=2)
norm = Normalize(vmin=-500, vmax=500)
pc.set_facecolor(cmap(norm(dframe['Delta GDD (5yr)'].fillna(0).values)))
ax.add_collection(pc)
m.drawcoastlines()
m.drawcountries()
m.drawstates()
m.readshapefile('./cb_2017_us_county_500k/cb_2017_us_county_500k',
'counties')
mapper = matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap)
mapper.set_array(dframe['Delta GDD (5yr)'])
cbar = m.colorbar(mapper,
location='bottom',
ticks=[-500, -250, -100, 0, 100, 250, 500])
cbar.set_label('Delta GDDs: Corn ' + str(date.strftime('%Y-%b-%d')))
plt.title('Difference from 5yr Average: Corn GDDs for period ' +
str(start_date) + ' to ' + str(end_date),
fontsize=18)
if save:
fig.savefig('./maps/Delta/delta5yr-' + str(date.strftime('%Y-%m-%d')) +
'.png',
format='png')
return m
def draw_map(df, measure, Colors, Title):
plt.clf()
fig = plt.figure()
ax = fig.add_subplot(111, axisbg='None')
ax.set_xlim(minx - 0.2 * w, maxx + 0.2 * w)
ax.set_ylim(miny - 0.2 * h, maxy + 0.2 * h)
ax.set_aspect(1)
cmap = plt.get_cmap(Colors)
df['patches'] = df['Poly'].map(
lambda x: PolygonPatch(x, ec='#555555', lw=0.2, alpha=0.5, zorder=4))
pc = PatchCollection(df['patches'].values, match_original=True)
norm = mpl.colors.Normalize()
pc.set_facecolor(cmap(norm(df[measure].values)))
ax.add_collection(pc)
plt.title(Title)
#Add a colorbar for the PolyCollection
#Classified the prices into 7 classes using natural break
breaks = nb(df[df[measure].notnull()][measure].values, initial=500, k=7)
jb = pd.DataFrame({'jenks_bins': breaks.yb},
index=df[df[measure].notnull()].index)
df = df.join(jb)
df.jenks_bins.fillna(-1, inplace=True)
jenks_labels = ["<= Above %0.1f" % b for b in breaks.bins]
cb = colorbar_index(ncolors=len(jenks_labels),
cmap=cmap,
shrink=0.5,
labels=jenks_labels)
cb.ax.tick_params(labelsize=8)
fig.set_size_inches(10, 10)
plt.savefig(Title, ext='png', close=True, dpi=400, bbox_inches='tight')
def draw_map(ratings_data, title, save_name):
fig = plt.figure(figsize=(16,9))
fig.suptitle(title, fontsize=20, y=.90)
ax = fig.add_subplot(111, facecolor='w', frame_on=False)
m = Basemap(lon_0=0, projection='robin')
m.drawmapboundary(color='w')
m.readshapefile(shapefile, 'units', color='#888888', linewidth=.2)
for info, shape in zip(m.units_info, m.units):
country = info["NAME"]
if country not in ratings_data:
color = inactive_color
else:
color = active_color
try:
non_visited_country.remove(country)
except:
pass
pc = PatchCollection([Polygon(np.array(shape), True)])
pc.set_facecolor(color)
if country in ratings_data:
pc.set_alpha((ratings_data[country]+rating_shift) / (max_rating+rating_shift))
ax.add_collection(pc)
ax.axhspan(0, 1000 * 1800, facecolor='w', edgecolor='w', zorder=2)
ax_legend = fig.add_axes([0.35, 0.14, 0.3, 0.03], zorder=3)
index = [0.0, 1.0]
cm = LinearSegmentedColormap.from_list('ramen_colormap', zip(index, colors))
cb = mpl.colorbar.ColorbarBase(ax_legend, cmap=cm, ticks=[0, 1], orientation='horizontal')
cb.ax.set_xticklabels(["3/5 Stars", "5/5 Stars"])
plt.savefig("output/%s.png" % save_name, bbox_inches='tight', pad_inches=.2)
def make_plot(self,
val,
cct,
clm,
cmap='jet',
cmap_norm=None,
cmap_vmin=None,
cmap_vmax=None):
# make color mapping
smap = ScalarMappable(cmap_norm, cmap)
smap.set_clim(cmap_vmin, cmap_vmax)
smap.set_array(val)
bin_colors = smap.to_rgba(val)
# make patches
patches = []
for i_c, i_clm in enumerate(clm):
patches.append(
Rectangle((i_clm[0], i_clm[2]), i_clm[1] - i_clm[0],
i_clm[3] - i_clm[2]))
patches_colle = PatchCollection(patches)
patches_colle.set_edgecolor('face')
patches_colle.set_facecolor(bin_colors)
return patches_colle, smap
def make_plot_gdd(date, start_date, end_date, dframe, save=False):
fig, ax = plt.subplots(figsize=(15, 10))
m = Basemap(llcrnrlon=-105.0,
llcrnrlat=45.4,
urcrnrlon=-95.7,
urcrnrlat=49.5,
projection='merc',
resolution='h')
cmap = plt.get_cmap('nipy_spectral')
pc = PatchCollection(dframe.shapes, zorder=2)
norm = Normalize(vmin=100, vmax=2800)
pc.set_facecolor(cmap(norm(dframe['Corn AGDD (F)'].fillna(0).values)))
ax.add_collection(pc)
m.drawcoastlines()
m.drawcountries()
m.drawstates()
m.readshapefile('./cb_2017_us_county_500k/cb_2017_us_county_500k',
'counties')
mapper = matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap)
mapper.set_array(dframe['Corn AGDD (F)'])
cbar = m.colorbar(mapper, location='bottom')
cbar.set_label('Accumulated GDDs: Corn ' + str(date.strftime('%Y-%b-%d')))
plt.title('Corn Growing Season GDDs for period ' + str(start_date) +
' to ' + str(end_date),
fontsize=18)
if save:
fig.savefig('./maps/AGDD/gdds-' + str(date.strftime('%Y-%m-%d')) +
'.png',
format='png')
return m
def plot_ax2_rejected(ax2):
ax2.set_title('Points per\nrejected-cloud', pad=5, fontsize=SMALL_SIZE + 1)
ax2.set_xlim(-0.1, 2.1)
ax2.set_ylim(-0.1, 1.1)
x_coord = np.linspace(0.0, 2.0, num=nrejected + 1)
widths = x_coord[1:] - x_coord[:-1]
patches = []
for i in range(nrejected):
x_patch = x_coord[i]
patches.append(
mpatches.FancyBboxPatch(
(x_patch, 0.0),
widths[i],
1.0,
boxstyle=mpatches.BoxStyle("Round", pad=0.0,
rounding_size=0.2)))
add_label(ax2, (x_patch + 0.5 * widths[i], 0.5),
data_size[~ids_bool][i],
color='white')
if nrejected == 0:
patches.append(
mpatches.FancyBboxPatch(
(0.0, 0.0),
2.0,
1.0,
boxstyle=mpatches.BoxStyle("Round", pad=0.0,
rounding_size=0.2)))
add_label(ax2, (1.0, 0.5), 'None', color='black')
collection = PatchCollection(patches, alpha=1.0)
collection.set_edgecolor('k')
collection.set_facecolor(colors_all[~ids_bool])
ax2.add_collection(collection)
ax2.axis('off')
def create_pixels(lons,lats,widths,heights,alphas,color,label): """ Plot of pixels using centers (lons,lats), with sizes (widhts,heights), angle alphas, and color color. :param lons: array of longitude coordinates at the center of the pixels :param lats: array of latitude coordinates at the center of the pixels :param widths: array of widhts of the pixels :param heights: array of heights of the pixels :param alphas: array of angles of the pixels :param color: tuple with RGB color values :return col: collection of rectangles with the pixels Developed in Python 2.7.15 :: Anaconda 4.5.10, on MACINTOSH. Angel Farguell ([email protected]) 2018-12-28 """ # Create pixels pixels=[] for x, y, h, w, a in zip(lons, lats, heights, widths, alphas): xpos = x - w/2 # The x position will be half the width from the center ypos = y - h/2 # same for the y position, but with height rect = Rectangle( (xpos, ypos), w, h, a) # Create a rectangle pixels.append(rect) # Add the rectangle patch to our list # Create a collection from the rectangles col = PatchCollection(pixels) # set the alpha for all rectangles col.set_alpha(0.5) # Set the colors using the colormap col.set_facecolor( [color]*len(lons) ) # No lines col.set_linewidth( 0 ) return col
def _create_patch(self):
"""Creates a matplotlib polygon patch from the Shape points. This is
used when making 2d images of the Shape object.
Raises:
ValueError: No points defined for the Shape
Returns:
Matplotlib object patch: a plotable polygon shape
"""
if self.points is None:
raise ValueError("No points defined for", self)
patches = []
xylist = []
for point in self.points:
xylist.append([point[0], point[1]])
polygon = Polygon(xylist, closed=True)
patches.append(polygon)
patch = PatchCollection(patches)
if self.color is not None:
patch.set_facecolor(self.color)
patch.set_color(self.color)
patch.color = self.color
patch.edgecolor = self.color
# checks to see if an alpha value is provided in the color
if len(self.color) == 4:
patch.set_alpha = self.color[-1]
self.patch = patch
return patch
def print_map(m, shapefile, colored_map_dict, ax, dict_key='NAME'):
""" plots using pyplot a basemap object
m -- the base map object
shapefile -- a file with the coordinates of the countries
colored_map_dict -- a dictionary that points from a legal name of a country
in shapefile to a python color: {'Argentina':'r'}
ax -- axis object
"""
m.readshapefile(shapefile, 'units', drawbounds=True, linewidth=.2)
for info, shape in zip(m.units_info, m.units):
unitname = info['NAME']
try:
color = colored_map_dict[info[dict_key]]
except: # no color for this country
continue
patches = [Polygon(np.array(shape), True)]
pc = PatchCollection(patches)
pc.set_facecolor(color)
ax.add_collection(pc)
plt.show()
def show_uboxes(uboxes,S=None,col='b',ecol='k', fig=None):
if uboxes.dim != 2:
raise Exception("show_uboxes: dimension must be 2")
if S is None:
S = range(uboxes.size)
patches = []
for i in S:
art = mpatches.Rectangle(uboxes.corners[i],uboxes.width[0],uboxes.width[1])
patches.append(art)
if not fig:
fig = plt.figure()
ax = fig.gca()
ax.hold(True)
collection = PatchCollection(patches)
collection.set_facecolor(col)
collection.set_edgecolor(ecol)
ax.add_collection(collection,autolim=True)
ax.autoscale_view()
plt.draw()
plt.show()
return fig
def draw_zips_3(zctashapes, dfl, colorcol='', gamma=1.0):
if len(colorcol)>0:
c = dfl[colorcol].copy()#**gamma
shapes = zctashapes
Nshp = len(shapes)
cm = plt.get_cmap('Dark2')
cccol = cm(1.*c/max(c))
# -- plot --
fig = plt.figure()
ax = fig.add_subplot(111)
for nshp in xrange(Nshp):
ptchs = []
pts = np.array(shapes[nshp].points)
prt = shapes[nshp].parts
par = list(prt) + [pts.shape[0]]
for pij in xrange(len(prt)):
ptchs.append(Polygon(pts[par[pij]:par[pij+1]]))
# ax.add_collection(PatchCollection(ptchs,facecolor=cccol[nshp,:],edgecolor='k', linewidths=.1))
pc = PatchCollection(ptchs,facecolor=cccol[nshp],norm=colors.PowerNorm(gamma=gamma),edgecolor='k', linewidths=.1)
# for collection in pc:?
pc.set_facecolor(cccol[nshp])
ax.add_collection(pc)
ax.set_xlim(-91,-82)
ax.set_ylim(41,48)
return ax
def show_uboxes_corners( corners, width, S=None, col='b', ecol='k' ):
"""
This version takes the corners and width arrays as arguments
instead.
"""
if corners.ndim != 2:
raise Exception("show_uboxes_corners: dimension must be 2")
if S is None:
S = range( len(corners) )
patches = []
for i in S:
art = mpatches.Rectangle( corners[i], width[0], width[1] )
patches.append(art)
fig = plt.figure()
ax = fig.gca()
ax.hold(True)
collection = PatchCollection(patches)
collection.set_facecolor(col)
collection.set_edgecolor(ecol)
ax.add_collection(collection,autolim=True)
ax.autoscale_view()
plt.show()
return fig
def c(p):
# where p is list of primitives
# outputs a collecction of primitives. essentially takes union. can treat this as a new primitive
coll = PatchCollection(p)
coll.set_edgecolor('k')
coll.set_facecolor([0, 0, 0, 0])
# coll.set_alpha(0.5)
return coll
def plot_world_chloropleth(datafile,
dest,
colorscale,
bins,
nodatacolor='#dddddd',
scale=1,
projection='robin',
resolution='l',
usecol='Magnitude',
inputkwargs={}):
"""Format: CSV with 'Country Name', 'Country Code', and 'Magnitude' columns."""
# See http://ramiro.org/notebook/basemap-choropleth/
shapefile = 'ne_10m_admin_0_countries_lakes/ne_10m_admin_0_countries_lakes'
num_colors = len(bins) - 1
gc = GeonamesCache()
iso3_codes = list(gc.get_dataset_by_key(gc.get_countries(), 'iso3').keys())
df = pd.read_csv(datafile, **inputkwargs)
df.set_index('Country Code', inplace=True)
df = df.reindex(
iso3_codes) #.dropna() # Filter out non-countries and missing values.
values = df[usecol]
# https://matplotlib.org/api/pyplot_summary.html#matplotlib.pyplot.colormaps
cm = plt.get_cmap(colorscale)
scheme = [cm(i / num_colors) for i in range(num_colors)]
scheme.append(nodatacolor)
df['bin'] = np.digitize(values, bins) - 1
df.sort_values('bin', ascending=False).head(10)
# This doesn't work, is it important?
# mpl.style.use('map')
fig = plt.figure(figsize=(default_size * scale, default_size * scale))
ax = fig.add_subplot(111, facecolor='w', frame_on=False)
m = Basemap(lon_0=0, projection=projection, resolution=resolution)
m.drawmapboundary(linewidth=default_map_linewidth * scale, color='w')
m.readshapefile(shapefile,
'units',
color='#444444',
linewidth=default_border_linewidth * scale)
for info, shape in zip(m.units_info, m.units):
iso3 = info['ADM0_A3']
if iso3 not in df.index:
color = nodatacolor
else:
color = scheme[df.loc[iso3]['bin']]
patches = [Polygon(np.array(shape), True)]
pc = PatchCollection(patches)
pc.set_facecolor(color)
ax.add_collection(pc)
plt.savefig(dest, bbox_inches='tight')
class BostonDensity(BostonScatter):
def __init__(self, dataPoints):
super(BostonDensity, self).__init__(dataPoints)
return
def dataDF(self):
super(BostonDensity, self).dataDF()
self.df_map['count'] = self.df_map['poly'].map(lambda x: int(len(filter(prep(x).contains, self.dataPoints))))
self.df_map['POP100'] = self.df_map['POP100'].apply(float)
self.df_map['density'] = (self.df_map['count'] * 1000) / self.df_map['POP100']
# it's easier to work with NaN values when classifying
self.df_map.replace(to_replace={'density': {0: np.nan}}, inplace=True)
self.breaks = nb(
self.df_map[self.df_map['density'].notnull()].density.values,
initial=300,
k=5)
# the notnull method lets us match indices when joining
jb = pd.DataFrame({'jenks_bins': self.breaks.yb}, index=self.df_map[self.df_map['density'].notnull()].index)
self.df_map = self.df_map.join(jb)
self.df_map.jenks_bins.fillna(-1, inplace=True)
return
def tracts(self):
self.pc = PatchCollection(self.df_map['patches'], match_original=True)
# impose our colour map onto the patch collection
norm = mplc.Normalize()
self.pc.set_facecolor(self.cmap(norm(self.df_map['jenks_bins'].values)))
self.ax.add_collection(self.pc)
return
def colorScale(self):
# Add a colour bar
cb = colorbar_index(ncolors=len(self.jenks_labels), cmap=self.cmap, shrink=0.5, labels=self.jenks_labels)
cb.ax.tick_params(labelsize=6)
return
def patchesDF(self):
# use a blue colour ramp - we'll be converting it to a map using cmap()
self.cmap = plt.get_cmap('Blues')
# draw tracts with black outline. make suffolk (boston) thicker
super(BostonDensity, self).patchesDF()
self.jenks_labels = ["<= %0.1f per 1000 people (%s tracts)" % (b, c) for b, c in zip(
self.breaks.bins, self.breaks.counts)]
self.jenks_labels.insert(0, '<= 0.0 per 1000 people (%s tracts)' % len(self.df_map[self.df_map['density'].isnull()]))
return
def data(self):
highest = '\n'.join([row['CT_ID_10'] + "," +
str(row['density']) for i, row in self.df_map[
(self.df_map['jenks_bins'] == 4)][:30].sort(columns='density',
ascending=False).iterrows()])
self.highest = 'TRACT_ID,DENSITY\n' + highest
return
def circles(x, y, s, marker=None, c='b', vmin=None, vmax=None, **kwargs):
"""
Taken from here: https://gist.github.com/syrte/592a062c562cd2a98a83
Make a scatter plot of circles.
Similar to pl.scatter, but the size of circles are in data scale.
Parameters
----------
x, y : scalar or array_like, shape (n, )
Input data
s : scalar or array_like, shape (n, )
Radius of circles.
c : color or sequence of color, optional, default : 'b'
`c` can be a single color format string, or a sequence of color
specifications of length `N`, or a sequence of `N` numbers to be
mapped to colors using the `cmap` and `norm` specified via kwargs.
Note that `c` should not be a single numeric RGB or RGBA sequence
because that is indistinguishable from an array of values
to be colormapped. (If you insist, use `color` instead.)
`c` can be a 2-D array in which the rows are RGB or RGBA, however.
vmin, vmax : scalar, optional, default: None
`vmin` and `vmax` are used in conjunction with `norm` to normalize
luminance data. If either are `None`, the min and max of the
color array is used.
kwargs : `~matplotlib.collections.Collection` properties
Eg. alpha, edgecolor(ec), facecolor(fc), linewidth(lw), linestyle(ls),
norm, cmap, transform, etc.
Returns
-------
paths : `~matplotlib.collections.PathCollection`
Examples
--------
a = np.arange(11)
circles(a, a, s=a*0.2, c=a, alpha=0.5, ec='none')
pl.colorbar()
License
--------
This code is under [The BSD 3-Clause License]
(http://opensource.org/licenses/BSD-3-Clause)
"""
# You can set `facecolor` with an array for each patch,
# while you can only set `facecolors` with a value for all.
zipped = np.broadcast(x, y, s)
patches = [Circle((x_, y_), s_) for x_, y_, s_ in zipped]
collection = PatchCollection(patches, **kwargs)
if c is not None and np.issubdtype(c.dtype, np.number):
collection.set_array(c)
collection.set_clim(vmin, vmax)
else:
collection.set_facecolor(c)
ax = pl.gca()
ax.add_collection(collection)
ax.autoscale_view()
return collection
def plot_map(self,
title_name,
cmap=None,
figwidth=14,
bins=[0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.],
bin_labels=None,
save_path=None):
if cmap is None:
cmap = self._set_colormap()
self.df_map['bins'] = self.df_map[self.values_col].apply(
self._get_bins, args=(bins, ))
if bin_labels is None:
bin_labels = ["{0}%".format(100 * x) for x in bins]
fig = plt.figure(figsize=(figwidth, figwidth * self.h / self.w))
ax = fig.add_subplot(111, axisbg='w', frame_on=False)
func = lambda x: PolygonPatch(
x, ec='#111111', lw=.8, alpha=1., zorder=4)
self.df_map['patches'] = self.df_map['poly'].map(func)
pc = PatchCollection(self.df_map['patches'], match_original=True)
#cmap_rng = (self.df_map['bins'].values - min(bins)) / float(max(bins))
#cmap_rng = (self.df_map['bins'].values - self.df_map['bins'].values.min())/ \
# (self.df_map['bins'].values.max() - float(self.df_map['bins'].values.min()))
#cmap_list = [cmap(val) for val in cmap_rng]
cmap_list = [cmap(val) for val in self.df_map[self.values_col].values]
pc.set_facecolor(cmap_list)
ax.add_collection(pc)
self.map.drawmapscale(self.coords[0] + 0.08,
self.coords[1] + -0.01,
self.coords[0],
self.coords[1],
10.,
fontsize=16,
barstyle='fancy',
labelstyle='simple',
fillcolor1='w',
fillcolor2='#555555',
fontcolor='#555555',
zorder=5,
ax=ax)
cbar = self._create_colorbar(cmap,
ncolors=len(bin_labels) + 1,
labels=bin_labels,
shrink=0.5)
cbar.ax.tick_params(labelsize=16)
if title_name is not None:
fig.suptitle(title_name,
fontdict={
'size': 24,
'fontweight': 'bold'
},
y=0.92)
if save_path is not None:
plt.savefig(save_path,
dpi=100,
frameon=False,
bbox_inches='tight',
pad_inches=0.5)
def plot_shapefile_polys(shapefile, ax, m, cmap):
"""
Plot polygons from the given shapefile on a basemap.
Parameters
----------
shapefile : shapefile object
Shapefile opened with fiona (``fiona.open(path_to_shapefile)``)
ax : matplotlib ax object
Axes to plot on
m : basemap object
cmap : matplotlib colormap
Colormap to use to color the individual polygons in the shapefile
"""
from descartes import PolygonPatch
from matplotlib.collections import PatchCollection
import shapely
import shapely.ops
# Break up MultiPolygons into Polygons, keeping track of
# which shape they belong to
polygons = []
names = []
for i in shapefile:
# name = i['properties'][name_property]
name = i['id']
geom = shapely.geometry.shape(i['geometry'])
if geom.geom_type == 'MultiPolygon':
for poly in geom:
polygons.append(poly)
names.append(name)
else:
polygons.append(geom)
names.append(name)
# Create patches with basemap-transformed coordinates
def TransformedPolygonPatch(poly):
return PolygonPatch(shapely.ops.transform(m, poly),
ec='#555555',
lw=.2,
alpha=1.,
zorder=4)
polygon_patches = [TransformedPolygonPatch(p) for p in polygons]
# Create name->color_id mapping dict
colors = {name: idx for idx, name in enumerate(list(set(names)))}
n = plt.Normalize(0, len(colors))
pc = PatchCollection(polygon_patches, match_original=True)
# Now go through all names and set the color appropriately
pc.set_facecolor(cmap(n([colors[i] for i in names])))
pc.set_alpha(0.2)
ax.add_collection(pc)
return ax
def update(self, element: Element, time: Timestamp, µcluster: MicroCluster,
clusters: Optional[list[Cluster]],
unclustered: Optional[Set[MicroCluster]],
eliminated: Optional[Set[MicroCluster]]):
max_density = max(
[µcluster.density(time) for µcluster in self.dyclee.all_µclusters])
if µcluster in self.patch_map:
self.patch_map[µcluster].remove()
patch_collection = PatchCollection([
Rectangle(
µcluster.centroid - µcluster.context.hyperbox_lengths / 2,
*µcluster.context.hyperbox_lengths)
])
patch_collection.set_edgecolor('w')
patch_collection.set_facecolor(
(0, 0, 0, 0.5 * µcluster.density(time) / max_density))
self.patch_map[µcluster] = patch_collection
self.ax.add_collection(patch_collection)
if clusters is not None:
for cluster in clusters:
for µcluster in cluster.µclusters:
self.patch_map[µcluster].set_edgecolor(
self.colour_manager.get_colour(cluster.label))
self.patch_map[µcluster].set_facecolor(
(0, 0, 0, 0.5 * µcluster.density(time) / max_density))
order = sorted(range(len(clusters)),
key=lambda i: clusters[i].label)
self.ax.legend([
Rectangle((0, 0),
1,
1,
facecolor='none',
edgecolor=self.colour_manager.get_colour(
clusters[i].label)) for i in order
], [clusters[i].label for i in order],
loc=self.legend_loc)
if unclustered is not None:
for µcluster in unclustered:
self.patch_map[µcluster].set_edgecolor(
self.colour_manager.get_colour(µcluster.label,
self.unclustered_opacity))
self.patch_map[µcluster].set_facecolor(
(0, 0, 0, 0.5 * µcluster.density(time) / max_density))
if eliminated is not None:
for µcluster in eliminated:
self.patch_map[µcluster].remove()
del self.patch_map[µcluster]
class GreaterBostonDensity(GreaterBostonScatter):
def __init__(self, dataPoints):
super(GreaterBostonDensity, self).__init__(dataPoints)
self.routeColor = 'r'
return
def dataDF(self):
super(GreaterBostonDensity, self).dataDF()
self.df_map['count'] = self.df_map['poly'].map(lambda x: int(len(filter(prep(x).contains, self.dataPoints))))
self.df_map['density_m'] = self.df_map['count'] / self.df_map['area_m']
self.df_map['density_km'] = self.df_map['count'] / self.df_map['area_km']
# it's easier to work with NaN values when classifying
self.df_map.replace(to_replace={'density_m': {0: np.nan}, 'density_km': {0: np.nan}}, inplace=True)
self.breaks = nb(
self.df_map[self.df_map['density_km'].notnull()].density_km.values,
initial=300,
k=5)
# the notnull method lets us match indices when joining
jb = pd.DataFrame({'jenks_bins': self.breaks.yb}, index=self.df_map[self.df_map['density_km'].notnull()].index)
self.df_map = self.df_map.join(jb)
self.df_map.jenks_bins.fillna(-1, inplace=True)
return
def patchesDF(self):
# use a blue colour ramp - we'll be converting it to a map using cmap()
self.cmap = plt.get_cmap('Blues')
# draw tracts with black outline. make suffolk (boston) thicker
self.df_map['patches'] = [PolygonPatch(row['poly'], ec='k',
lw=0.25 if (row['COUNTY'] != suffolkID) else 0.8,
alpha=.9, zorder=4) for i,row in self.df_map.iterrows()]
self.jenks_labels = ["<=$%0.1f/km$^2$ (%s tracts)" % (b, c) for b, c in zip(
self.breaks.bins, self.breaks.counts)]
self.jenks_labels.insert(0, '<=$0.0/km$^2$ (%s tracts)' % len(self.df_map[self.df_map['density_km'].isnull()]))
return
def data(self):
highest = '\n'.join([row['TRACT'] + "," +
str(row['density_km']) for i, row in self.df_map[
(self.df_map['jenks_bins'] == 4)][:30].sort(columns='density_km',
ascending=False).iterrows()])
self.highest = 'TRACT_ID,DENSITY\n' + highest
return # function returns nothing
def tracts(self):
self.pc = PatchCollection(self.df_map['patches'], match_original=True)
# impose our colour map onto the patch collection
norm = mplc.Normalize()
self.pc.set_facecolor(self.cmap(norm(self.df_map['jenks_bins'].values)))
self.ax.add_collection(self.pc)
return
def plot_rectangles(fld, xp, yp, title = None, cntr_lat=None, cntr_lon=None,
c_width=2500., ctables=None, norm=None, ax=None, fig=None):
if ctables == None:
ctables = P.cm.viridis
if title == None:
title = "No Title"
if norm == None:
norm = [fld.min(), fld.max()]
Fnorm = mpl.colors.Normalize(vmin=norm[0], vmax=norm[1], clip=True)
# Here's where you have to make a ScalarMappable with the colormap
mappable = P.cm.ScalarMappable(norm=Fnorm, cmap=ctables)
# normalize the data for the colormapping
colors_norm = fld/(norm[1]-norm[0])
# Give it your non-normalized color data
mappable.set_array(fld)
rects = []
for p in zip(xp, yp):
xpos = p[0] - c_width/2 # The x position will be half the width from the center
ypos = p[1] - c_width/2 # same for the y position, but with height
rect = Rectangle( (xpos, ypos), c_width, c_width ) # Create a rectangle
rects.append(rect) # Add the rectangle patch to our list
# Create a collection from the rectangles
col = PatchCollection(rects)
# set the alpha for all rectangles
col.set_alpha(0.8)
# Set the colors using the colormap
col.set_facecolor( ctables(colors_norm) )
# create figure if fig == None
if fig == None:
fig = plt.figure()
if ax == None:
ax = fig.add_subplot(111)
# plot collection of rectangles
ax.add_collection(col)
# add a colorbar
P.colorbar(mappable)
P.title(title, fontsize=10)
return
def plot_polygons(self):
p = PatchCollection(self.__array_polygons, alpha=.5)
p.set_facecolor([0, 0, 0])
p.set_edgecolor([0, 0, 0])
self.__ax.set_xlim((0, self.__x_lim))
self.__ax.set_ylim((0, self.__y_lim))
self.__ax.set_title(self.__title)
self.__ax.add_collection(p)
plt.axis('off')
plt.title('')
plt.plot()
plt.savefig('Results/' + self.__title, bbox_inches='tight', pad_inches=0)
def add_circles(self, ax, centers, radis):
circles = []
for c, r in zip(centers, radis):
circles.append(patches.Circle(tuple(c), r))
patch_collection = PatchCollection(circles)
patch_collection.set_facecolor("none")
patch_collection.set_edgecolor("blue")
patch_collection.set_linewidth(1.5)
patch_collection.set_linestyle("dashed")
ax.add_collection(patch_collection)
print "added %d circles" % len(circles)
def gen_heat_map(m, pickups):
df_map = pd.DataFrame({
'poly': [Polygon(xy) for xy in m.nyc],
'zone_id': [zone['LocationID'] for zone in m.nyc_info]})
df_map['area_km'] = df_map['poly'].map(lambda x: x.area) / 1000000
area_map = df_map.groupby(['zone_id'])['area_km'].sum()
count = 0
fig = plt.figure()
cmap = plt.get_cmap('Greys_r')
color_map = np.zeros(len(df_map['poly']))
pickup_map = {}
plt.clf()
norm = Normalize()
# dateIndex, go over all the predicted lines
for dateIndex in xrange(len(pickups)):
pickups_count = pickups[dateIndex][2:]
for i in xrange(len(pickups_count) - 2):
index = i + 1
if index in LOCATIONID_MAP.keys():
pickup_map[LOCATIONID_MAP[index]] += pickups_count[i]
else:
pickup_map[index] = pickups_count[i]
for i in xrange(len(m.nyc_info)):
index = m.nyc_info[i]['LocationID']
if index in LOCATIONID_MAP.keys():
color_map[i] = pickup_map[LOCATIONID_MAP[index]]
else:
color_map[i] = pickup_map[index]
ax = fig.add_subplot(111, frame_on=False, xticks=[], yticks=[])
ax.set_title("Prediction")
df_map['patches'] = [PolygonPatch(x, fc='white', ec='grey', lw=.25, alpha=1.0,
zorder=4) for x in df_map['poly']]
pc = PatchCollection(df_map['patches'].values, match_original=True)
pc.set_facecolor(cmap(norm(color_map)))
ax.add_collection(pc)
min_x, min_y = m(lower_left[0], lower_left[1])
max_x, max_y = m(upper_right[0], upper_right[1])
ax.set_xlim(min_x, max_x)
ax.set_ylim(min_y, max_y)
ax.set_aspect(1)
plt.tight_layout()
fig.set_size_inches(16.76, 16.88)
plt.show()
#plt.savefig('data2/heat_map/nyc-' + str(date) + '-' + str(time) + '.png', dpi=100, alpha=True)
count += 1
if count % 100 == 0:
print count
def plotpatchcollection(self, mypatches, mycolors=[], mylw=[]):
self.canvas.figure.clf()
ax = self.canvas.figure.subplots()
p = PatchCollection(mypatches) # , alpha=0.4)
p.set_facecolor(tuple(mycolors))
p.set_linewidth(mylw)
ax.add_collection(p)
ax.autoscale(enable=True, axis="both", tight=None)
self.canvas.draw()
def ZoomPerspectiveEtopo():
fig, ax = plt.subplots(figsize=(3, 2.5))
# setup Lambert Conformal basemap.
print("I am trying to get rid of these bloody lakes")
m = Basemap(width=1800000,
height=1500000,
projection='lcc',
area_thresh=10000000.,
resolution='h',
lat_1=45.,
lat_2=55,
lat_0=25.7,
lon_0=91.5)
# draw coastlines.
#m.drawrivers()
m.drawcoastlines()
# draw a boundary around the map, fill the background.
# this background will end up being the ocean color, since
# the continents will be drawn on top.
m.drawmapboundary(fill_color='aqua')
# fill continents, set lake color same as ocean color.
m.fillcontinents(color='peru', lake_color='white')
# draw parallels and meridians.
# label parallels on right and top
# meridians on bottom and left
parallels = np.arange(0., 81, 5.)
# labels = [left,right,top,bottom]
m.drawparallels(parallels, labels=[False, True, True, False])
meridians = np.arange(10., 351., 5.)
m.drawmeridians(meridians, labels=[True, False, False, True])
m.drawcountries()
m.readshapefile('Mega_divide_footprint', 'MDF')
# All this stuff from:
# http://www.datadependence.com/2016/06/creating-map-visualisations-in-python/
df_poly = pd.DataFrame(
{'shapes': [Polygon(np.array(shape), True) for shape in m.MDF]})
print(df_poly)
#df_poly = df_poly.merge(new_areas, on='area', how='left')
cmap = plt.get_cmap('Oranges')
pc = PatchCollection(df_poly.shapes, zorder=2, alpha=0.5)
pc.set_facecolor("gray")
ax.add_collection(pc)
FigFileName = "Test.svg"
FigFormat = "svg"
plt.savefig(FigFileName, format=FigFormat, dpi=200)
def paw_plot(sdata=None, sdata_bg=None, cdata=None, cmap=None, clim=None, edgecolor='#555555', bgcolor='#cccccc', legend=True, ax=None):
ax = ax if ax else plt.gca()
r = np.array([ 0, 1, 1, 1, 1, 1 ])
theta = np.array([ 0, 30, 75, 120, 165, 210 ]) * np.pi / 180.0
theta = np.array([ -5, 25, 70, 115, 160, 205 ]) * np.pi / 180.0
# theta = np.array([ 0, 30, 72, 114, 156, 198 ]) * np.pi / 180.0
if sdata is None:
sdata = np.array([4,1,1,1,1,1])*.08
if cdata is None:
cdata = np.ones(len(r))
if cmap is None:
cmap = 'magma'
if clim is None:
clim = [0,1]
xx = r * np.cos(theta)
yy = r * np.sin(theta)
patches = [ mpatch.Circle((x,y),rad) for (x,y,rad) in zip(xx,yy,np.sqrt(sdata)) ]
col = PatchCollection(patches, zorder=2)
col.set_array(cdata)
col.set_cmap(cmap)
col.set_edgecolor(edgecolor)
col.set_clim(vmin=clim[0], vmax=clim[1])
ax.add_patch(mpatch.Arc((0.0, 0.0), 2.0, 2.0, angle=0.0,
theta1=theta[1]*180.0/np.pi, theta2=theta[-1]*180.0/np.pi,
edgecolor=edgecolor,facecolor='none', zorder=0, linestyle='--'))
ax.add_collection(col)
if legend:
plt.colorbar(col)
if sdata_bg is not None:
patches = [ mpatch.Circle((x,y),rad) for (x,y,rad) in zip(xx,yy,np.sqrt(sdata_bg)) ]
col = PatchCollection(patches, zorder=1)
col.set_edgecolor(edgecolor)
col.set_facecolor(bgcolor)
ax.add_collection(col)
ax.axis('equal')
ax.axis('off')
ax.set_xlim([-1.2,1.2])
ax.set_ylim([-.8,1.35])
def _detailed_map_setup(self):
"""
Loads the shapefile from the files, stores country information and
geometery for determing which country a tweet falls in and coloring
that country according to the analyzed sentiment.
Also ticks the progress bar as the countries are loaded.
"""
# Get the shapefile path name
dir_filepath = path.dirname(path.abspath(__file__))
shapefile = path.join(dir_filepath, 'data', 'ne_10m_admin_0_countries')
# Draw the outer map
self.map_.drawmapboundary(color='#d3d3d3')
# read in the shapefile
self.map_.readshapefile(shapefile,
'countries',
color='black',
linewidth=.2)
# iterate over the country info and shape info. Use `index` to record
# loading progress
for index, (info, shape) in enumerate(
zip(self.map_.countries_info, self.map_.countries)):
# `iso3` is a 3 letter country code
iso3 = info['ADM0_A3']
# don't map the antartic
if iso3 == 'ATA':
continue
# convert shape to numpy array for use with basemap
shape = np.array(shape)
# basemap/matplotlib specific data wrangling
polygon = Polygon(shape, True)
patches = [polygon]
# store the (iso_name, path) in cache. Will use `contains_points`
# method to later determine in which country tweets fall
self._cache_path.append((iso3, matplotlib.path.Path(shape)))
# basemap/matplotlib specific data wrangling
patch_collection = PatchCollection(patches)
# store the (iso_name, patch_collection) to change the country
# color
self._cache_patches.append((iso3, patch_collection))
# Set default country facecolor to be gray.
patch_collection.set_facecolor('#d3d3d3')
# basemap/matplotlib specific data wrangling
self.axis.add_collection(patch_collection)
# There's ~4268 items. 1/100 or one tick mark is every 42 paces
if index % 42 == 0:
self.country_progress.emit(index)
def _plot_ward_budget_with_color(self, to_map, axes):
"""Plot the budget per city ward, coloring each polygon according to
"the ward's budget.
to_map: the Basemap with the map of Toronto
axes: the axes
"""
# Plot the City Wards in Toronto. The borders of these polygons are
# plot as they are in the Shapefile
dummy = to_map.readshapefile(shapefile='./shp_dir/icitw_wgs84',
name='city_wards',
drawbounds=False, color='green')
# The set of polygons (city-wards in Toronto) to add (to plot)
patches = []
# The ten-years budget per city-ward (in same order as its
# geographical polygon
ten_yrs_bdg = []
for shape, shp_info in zip(to_map.city_wards, to_map.city_wards_info):
# print shp_info
# The GIS shapefile 'city_wards' ('icitw_wgs84') has the ward
# number as the field with key 'SCODE_NAME' in that shapefile
# (you need to .lstrip('0') from it, because, e.g., wards whose
# number has a single digit are padded with left '0's in the
# shapefile, but are nevertheless in the decimal system -just
# padded with '0's, that's it- but Python will understand it
# as in octal, not decimal syste.)
shape_ward_number = int(shp_info['SCODE_NAME'].lstrip('0'))
# the shapefile doesn't have the budget for this ward-number,
# but the Excel spreadsheet we had done the ETL on it did
ward_budget = self._total_budget_per_ward[shape_ward_number]
# print "Ward: %02d, 10-years budget: %f, Ward-name: %s" % \
# (shape_ward_number, ward_budget, shp_info['NAME'])
# append this budget and its associated geographical polygon
ten_yrs_bdg.append(ward_budget)
patches.append(Polygon(np.array(shape), True))
cmap = plt.get_cmap('Greens')
patch_collection = PatchCollection(patches, match_original=True)
norm = Normalize(vmin=min(ten_yrs_bdg),
vmax=max(ten_yrs_bdg))
patch_collection.set_facecolor(cmap(norm(ten_yrs_bdg)))
axes.add_collection(patch_collection)
def get_shape_collections(data: Dict):
shapes = []
for points in data.values():
shapes.append(
Polygon(np.array([points['lons'], points['lats']]).T, closed=True))
collection = PatchCollection(shapes)
collection.set_facecolor('#eeeeee')
collection.set_edgecolor('black')
collection.set_linewidth(0.2)
return collection
def draw_bboxes(bboxes, ax=None, color='red', linewidth=1, **kw):
if ax is None:
ax = plt.gca()
patches = [
mpatches.Rectangle((i[1], i[0]), i[3] - i[1], i[2] - i[0])
for i in bboxes
]
boxcoll = PatchCollection(patches, **kw)
boxcoll.set_facecolor('none')
boxcoll.set_edgecolor(color)
boxcoll.set_linewidth(linewidth)
ax.collections = []
ax.add_collection(boxcoll)
def Createheatmap(m, breaks, MapData, jenksLabels, Coordinates, ComplaintChoice, FirstDate, LastDate):
""" Create the heatmap charts. This module saves the chart as a png file. """
CHFig = plt.figure()
# use a blue color ramp - we'll be converting it to a map using cmap()
cmap = plt.get_cmap('Blues')
# draw NYC neighborhoods with grey (given by the hex number #555555) outlines.
MapData['patches'] = MapData['poly'].map(lambda polys: PolygonPatch(polys, ec='#555555', lw=.2, alpha=1., zorder=4))
PC = PatchCollection(MapData['patches'], match_original=True)
# impose our color map onto the patch collection.
norm = Normalize()
PC.set_facecolor(cmap(norm(MapData['jenks_bins'].values)))
Axis = CHFig.add_subplot(111, axisbg='w', frame_on=False)
Axis.add_collection(PC)
# Provide some facts about classification method and where the data came from.
Axis.text(
1.03, 0,
'Classification method: natural breaks\n Contains 311 Complaint data. $\copyright$ 311 data from: https://nycopendata.socrata.com/',
ha='right', va='bottom',
size=5,
color='#555555',
transform=Axis.transAxes)
# Add a color bar
ColorBar = ColorBarIndex(ncolors=len(jenksLabels), cmap=cmap, shrink=0.5, labels=jenksLabels)
ColorBar.ax.tick_params(labelsize=6)
# Add a title
plt.title("Densities of Complaint type: {0} \n Date Range: {1} to {2}".format(ComplaintChoice, FirstDate, LastDate))
# Draw a map scale.
m.drawmapscale(
Coordinates[0] + 0.08, Coordinates[1] + 0.015,
Coordinates[0], Coordinates[1],
10.,
barstyle='fancy', labelstyle='simple',
fillcolor1='w', fillcolor2='#555555',
# #555555 refers to the gray color.
fontcolor='#555555',
zorder=5)
CHFig.set_size_inches(7.22, 5.25)
title = 'Output/Heatmap_' + str(ComplaintChoice)+ "_" + str(pd.to_datetime(FirstDate).date()) + "_" + str(pd.to_datetime(LastDate).date()) + '.png'
plt.savefig(title, dpi=100, alpha=True)
plt.close()
def plot_population_map(df, region_path, figsize=(10, 20)):
"""Plot a map of population, broken down by region."""
# Create axes and figure, with the map centred on England.
fig, axes = plt.subplots(figsize=size)
data_map = Basemap(
resolution='i', # c, l, i, h, f or None.
projection='merc',
lat_0=54.5,
lon_0=-4.36,
llcrnrlon=-6.0,
llcrnrlat=49.5,
urcrnrlon=2.0,
urcrnrlat=55.2)
# Draw general geography.
data_map.drawmapboundary(fill_color='#46bcec')
data_map.fillcontinents(color='#f2f2f2', lake_color='#46bcec')
data_map.drawcoastlines()
# Read in the shape file and record it in a more useful format.
data_map.readshapefile(region_path, 'regions', color='none')
regions = dict([
(info['NAME'], shape)
for info, shape in zip(data_map.regions_info, data_map.regions)
])
# Get populations in each region.
region_counts = df.groupby('Region').size()
# Create Polygon objects from shape file.
shapes = [
Polygon(np.array(regions[index]), True)
for index in region_counts.index
]
# Define colour map and attach data to each region the appropriate colour.
cmap = plt.get_cmap('Oranges')
pc = PatchCollection(shapes, zorder=2)
norm = Normalize()
pc.set_facecolor(cmap(norm(region_counts)))
axes.add_collection(pc)
# Create mapper object to apply colour to shapes.
mapper = matplotlib.cm.ScalarMappable(cmap=cmap)
mapper.set_array(region_counts)
plt.colorbar(mapper, shrink=0.4)
# Set title and show.
plt.title('Population by Region')
plt.show()
def IndicatorHeatMap(YEAR, LOCATION="Maryland", INDICATOR="None"):
# Using a CSV of economic indicators, create a heatmap that
# shows the data. This will be used under scatter and hexbin maps
# if an indicator is selected.
# This can probably be turned into an if/elif/else statement that
# sets a common variable to a string based on the indicator chosen
# and passes that variable through the breaks and jenks process.
df_map = pd.merge(df_map, indicator_list, on="county_name", how="left")
if INDICATOR == "None":
pass
elif INDICATOR == "Median Household Income":
# Select county or neighborhood MHHI data from the passed year
breaks = nb(
df_map[df_map["mhhi"].notnull()].mhhi.values,
initial=300,
k=5)
jb = pd.DataFrame({"jenks_bins":breaks.yb}, index=df_map[df_map["mhhi"].notnull()].index)
df_map = df_map.join(jb)
df_map.jenks_bins.fillna(-1, inplace=True)
jenks_labels = ["Median Household Income:\n<= %f" % b for b in breaks.bins]
elif INDICATOR == "Millennial Population Growth":
# Select county or neighborhood Millennial population data from the passed year
pass
else:
print "The %s indicator is not yet available in this program." % INDICATOR
ax = fig.add_subplot(111, axisbg = "w", frame_on = False)
# Change get_cmap color based on INDICATOR
cmap = plt.get_cmap("Blues")
df_map["patches"] = df_map["poly"].map(lambda x: PolygonPatch(x, ec="#555555", lw=.2, alpha=1, zorder=4))
pc = PatchCollection(df_map["patches"], match_original=True)
norm = Normalize()
pc.set_facecolor(cmap(norm(df_map["jenks_bins"].values)))
ax.add_collection(pc)
cb = colorbar_index(ncolors=len(jenks_labels), cmap=cmap, shrink=0.5, labels=jenks_labels)
cb.ax.tick_params(labelsize=8)
m.drawmapscale(
-125, 20,
-125, 20,
10.,
barstyle = "fancy", labelstyle = "simple",
fillcolor1 = "w", fillcolor2 = "w",
fontcolor = "w",
zorder=9,
units = "m",
fontsize =7)
def plot_map(m, coords, df_map, info, savefig=False):
plt.clf()
fig = plt.figure()
ax = fig.add_subplot(111, axisbg='w', frame_on=True)
# draw wards with grey outlines
norm = Normalize()
for i in xrange(5):
color = colormaps[i]
cmap = plt.get_cmap(color)
cond = (df_map['class'] == (i+1))
inx = df_map[cond].index
if cond.sum() > 0:
pc = PatchCollection(df_map[cond]['patches'],
match_original=True, alpha=0.75)
pc.set_facecolor(cmap(norm(df_map.loc[inx, 'cls_%d'%(i+1)].values)))
ax.add_collection(pc)
if (df_map['class'] == 0).sum() > 0:
pc = PatchCollection(df_map[df_map['class'] == 0]['patches'],
match_original=True, alpha=0.1
)
pc.set_facecolor('grey')
ax.add_collection(pc)
x, y = m(coords[0], coords[3]+0.006)
details = ax.annotate(info, xy=(x, y), size=20, color='k')
# Draw a map scale
m.drawmapscale(
coords[0]+0.02, coords[1]-0.004,
coords[0], coords[1],
2,
barstyle='fancy', labelstyle='simple',
fillcolor1='w', fillcolor2='#555555',
fontcolor='#555555', units='mi',
zorder=5)
legend_patches = []
for i in range(5):
legend_patches.append(mpatches.Patch(color='C%d' % i,
label=classes[i]))
ax.legend(handles=legend_patches, loc='upper right')
fig.set_size_inches(12, 12)
plt.tight_layout()
if savefig:
plt.savefig(savefig, dpi=200, alpha=True)
def plot_trajectory_ellipse(frame, varx="attr_VARX", vary="attr_VARY", covxy="attr_COVXY", opacity_factor=1):
"""
Draw the trajectory and uncertainty ellipses around teach point.
1) Scatter of points
2) Trajectory lines
3) Ellipses
:param frame: Trajectory
:param opacity_factor: all opacity values are multiplied by this. Useful when used to plot multiple Trajectories in
an overlay plot.
:return: axis
"""
ellipses = []
segments = []
start_point = None
for i, pnt in frame.iterrows():
# The ellipse
U, s, V = np.linalg.svd(np.array([[pnt[varx], pnt[covxy]],
[pnt[covxy], pnt[vary]]]), full_matrices=True)
w, h = s**.5
theta = np.arctan(V[1][0]/V[0][0]) # == np.arccos(-V[0][0])
ellipse = {"xy":pnt[list(frame.geo_cols)].values, "width":w, "height":h, "angle":theta}
ellipses.append(Ellipse(**ellipse))
# The line segment
x, y = pnt[list(frame.geo_cols)][:2]
if start_point:
segments.append([start_point, (x, y)])
start_point = (x, y)
ax = plt.gca()
ellipses = PatchCollection(ellipses)
ellipses.set_facecolor('none')
ellipses.set_color("green")
ellipses.set_linewidth(2)
ellipses.set_alpha(.4*opacity_factor)
ax.add_collection(ellipses)
frame.plot(kind="scatter", x=frame.geo_cols[0], y=frame.geo_cols[1], marker=".", ax=plt.gca(), alpha=opacity_factor)
lines = LineCollection(segments)
lines.set_color("gray")
lines.set_linewidth(1)
lines.set_alpha(.2*opacity_factor)
ax.add_collection(lines)
return ax
def _get_fpt_ell_collection(dm, fpts, T_data, alpha, edgecolor):
ell_patches = []
for (x, y, a, c, d) in fpts: # Manually Calculated sqrtm(inv(A))
with catch_warnings():
simplefilter("ignore")
aIS = 1 / sqrt(a)
cIS = (c / sqrt(a) - c / sqrt(d)) / (a - d + eps(1))
dIS = 1 / sqrt(d)
transEll = Affine2D([(aIS, 0, x), (cIS, dIS, y), (0, 0, 1)])
unitCirc1 = Circle((0, 0), 1, transform=transEll)
ell_patches = [unitCirc1] + ell_patches
ellipse_collection = PatchCollection(ell_patches)
ellipse_collection.set_facecolor("none")
ellipse_collection.set_transform(T_data)
ellipse_collection.set_alpha(alpha)
ellipse_collection.set_edgecolor(edgecolor)
return ellipse_collection
def ZoomPerspectiveEtopo():
fig, ax = plt.subplots(figsize=(3, 2.5))
# setup Lambert Conformal basemap.
print("I am trying to get rid of these bloody lakes")
m = Basemap(width=1800000,height=1500000,projection='lcc',area_thresh=10000000.,
resolution='h',lat_1=45.,lat_2=55,lat_0=25.7,lon_0=91.5)
# draw coastlines.
#m.drawrivers()
m.drawcoastlines()
# draw a boundary around the map, fill the background.
# this background will end up being the ocean color, since
# the continents will be drawn on top.
m.drawmapboundary(fill_color='aqua')
# fill continents, set lake color same as ocean color.
m.fillcontinents(color='peru',lake_color='white')
# draw parallels and meridians.
# label parallels on right and top
# meridians on bottom and left
parallels = np.arange(0.,81,5.)
# labels = [left,right,top,bottom]
m.drawparallels(parallels,labels=[False,True,True,False])
meridians = np.arange(10.,351.,5.)
m.drawmeridians(meridians,labels=[True,False,False,True])
m.drawcountries()
m.readshapefile('Mega_divide_footprint', 'MDF')
# All this stuff from:
# http://www.datadependence.com/2016/06/creating-map-visualisations-in-python/
df_poly = pd.DataFrame({
'shapes': [Polygon(np.array(shape), True) for shape in m.MDF]})
print(df_poly)
#df_poly = df_poly.merge(new_areas, on='area', how='left')
cmap = plt.get_cmap('Oranges')
pc = PatchCollection(df_poly.shapes, zorder=2, alpha = 0.5)
pc.set_facecolor("gray")
ax.add_collection(pc)
FigFileName = "Test.svg"
FigFormat = "svg"
plt.savefig(FigFileName,format=FigFormat,dpi=200)
def plot_map(self, title_name, cmap=None, figwidth=14,
bins=[0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.],
bin_labels=None, save_path=None):
if cmap is None:
cmap = self._set_colormap()
self.df_map['bins'] = self.df_map[self.values_col].apply(self._get_bins, args=(bins,))
if bin_labels is None:
bin_labels = ["{0}%".format(100 * x) for x in bins]
fig = plt.figure(figsize=(figwidth, figwidth * self.h / self.w))
ax = fig.add_subplot(111, axisbg = 'w', frame_on = False)
func = lambda x: PolygonPatch(x, ec='#111111', lw=.8, alpha=1.,
zorder=4)
self.df_map['patches'] = self.df_map['poly'].map(func)
pc = PatchCollection(self.df_map['patches'], match_original=True)
#cmap_rng = (self.df_map['bins'].values - min(bins)) / float(max(bins))
#cmap_rng = (self.df_map['bins'].values - self.df_map['bins'].values.min())/ \
# (self.df_map['bins'].values.max() - float(self.df_map['bins'].values.min()))
#cmap_list = [cmap(val) for val in cmap_rng]
cmap_list = [cmap(val) for val in self.df_map[self.values_col].values]
pc.set_facecolor(cmap_list)
ax.add_collection(pc)
self.map.drawmapscale(self.coords[0] + 0.08,
self.coords[1] + -0.01,
self.coords[0],
self.coords[1],
10.,
fontsize=16,
barstyle='fancy',
labelstyle='simple',
fillcolor1='w',
fillcolor2='#555555',
fontcolor='#555555',
zorder=5,
ax=ax)
cbar = self._create_colorbar(cmap, ncolors=len(bin_labels) + 1,
labels=bin_labels, shrink=0.5)
cbar.ax.tick_params(labelsize=16)
if title_name is not None:
fig.suptitle(title_name, fontdict={'size':24, 'fontweight':'bold'},
y=0.92)
if save_path is not None:
plt.savefig(save_path, dpi=100, frameon=False, bbox_inches='tight', pad_inches=0.5)
def plotGeometry(self, ax = None):
if (ax is None):
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_aspect(1)
self.blockPatch.set_facecolor('#F0F0F0')
self.blockPatch.set_edgecolor('k')
ax.add_patch(self.blockPatch)
pc = PatchCollection(self.channelPatches, match_original = True)
pc.set_facecolor('w')
pc.set_edgecolor('k')
pc.set_zorder(2)
ax.add_collection(pc)
self.plotDimensions(ax)
ax.set_xlim(self.xMin, self.xMax)
ax.set_ylim(self.yMin, self.yMax)
plt.show()
def show_box(b, col="b", ecol="k", alpha=1):
patches = []
# lower left corner at b[0], followed by width and height
xy = b[0]
width = np.absolute(b[0, 1] - b[0, 0])
height = np.absolute(b[1, 1] - b[1, 0])
art = mpatches.Rectangle(xy, width, height)
# art = mpatches.Rectangle(b[0],b[1,0],b[1,1])
patches.append(art)
ax = plt.gca()
ax.hold(True)
collection = PatchCollection(patches)
collection.set_facecolor(col)
collection.set_edgecolor(ecol)
collection.set_alpha(alpha)
ax.add_collection(collection, autolim=True)
ax.autoscale_view()
plt.show()
def show_boxes(boxes, S=None, col="b", ecol="k", alpha=1):
if boxes.dim != 2:
raise Exception("show_boxes: dimension must be 2")
if S is None:
S = range(boxes.size)
patches = []
for i in S:
art = mpatches.Rectangle(boxes.corners[i], boxes.widths[i][0], boxes.widths[i][1])
patches.append(art)
ax = plt.gca()
ax.hold(True)
collection = PatchCollection(patches)
collection.set_facecolor(col)
collection.set_edgecolor(ecol)
collection.set_alpha(alpha)
ax.add_collection(collection, autolim=True)
ax.autoscale_view()
plt.show()
def plot_sparse_trajectory(trajectory, r=50, opacity_factor=1, plot_text=True,
num_col="segment_sparcify_n", min_static=100):
"""
Plots a sparsified trajectory as circles with the number of points they represent as a number inside.
:param trajectory: Trajectory object
:param r: the radius of circles
:param num_col: where to find the number to put in the circles
:param min_static: minimum count to change color of circle
:param plot_text: put the text with num of points in the circle?
:return: ax
"""
ax = plt.gca()
trajectory.plot(kind="scatter", x=trajectory.geo_cols[0], y=trajectory.geo_cols[1], marker=".",
ax=plt.gca(), alpha=0.0*opacity_factor)
circles = []
segments = []
start_point = None
for i, pnt in trajectory.iterrows():
circles.append(Circle(pnt[list(trajectory.geo_cols)].values, radius=r))
if plot_text:
plt.text(*pnt[list(trajectory.geo_cols)], s=str(int(pnt[num_col])), fontsize=12)
x, y = pnt[list(trajectory.geo_cols)][:2]
if start_point:
segments.append([start_point, (x, y)])
start_point = (x, y)
circles = PatchCollection(circles)
circles.set_facecolor(['none' if cnt < min_static else 'red' for cnt in trajectory[num_col].values])
circles.set_alpha(.5*opacity_factor)
ax.add_collection(circles)
lines = LineCollection(segments)
lines.set_color("gray")
lines.set_alpha(.2*opacity_factor)
ax.add_collection(lines)
return ax
def make_plot(self, val, cct, clm,
cmap = 'jet', cmap_norm = None,
cmap_vmin = None, cmap_vmax = None):
# make color mapping
smap = ScalarMappable(cmap_norm, cmap)
smap.set_clim(cmap_vmin, cmap_vmax)
smap.set_array(val)
bin_colors = smap.to_rgba(val)
# make patches
patches = []
for i_c, i_clm in enumerate(clm):
patches.append(Rectangle((i_clm[0], i_clm[2]),
i_clm[1] - i_clm[0],
i_clm[3] - i_clm[2]))
patches_colle = PatchCollection(patches)
patches_colle.set_edgecolor('face')
patches_colle.set_facecolor(bin_colors)
return patches_colle, smap
def show_box(b,col='b',ecol='k',alpha=1, fig=None):
patches = []
# lower left corner at b[0], followed by width and height
art = mpatches.Rectangle(b[0],b[1,0],b[1,1])
patches.append(art)
if fig:
ax = fig.gca()
else:
fig = plt.figure()
ax = fig.gca()
ax.hold(True)
collection = PatchCollection(patches)
collection.set_facecolor(col)
collection.set_edgecolor(ecol)
collection.set_alpha(alpha)
ax.add_collection(collection,autolim=True)
ax.autoscale_view()
plt.show()
return fig
def build_map_nmf(df_map, m, coords, info, title, CrimePatterns):
# plt.clf()
fig = plt.figure()
ax = fig.add_subplot(111, axisbg='w', frame_on=True)
# draw wards with grey outlines
norm = Normalize()
for i in xrange(5):
color = colormaps[i]
cmap = plt.get_cmap(color)
pc = PatchCollection(df_map[df_map['class'] == i+1]['patches'], match_original=True, alpha=0.8)
pc.set_facecolor(cmap(norm(df_map.loc[(df_map['class'] == i+1), i].values)))
ax.add_collection(pc)
pc = PatchCollection(df_map[df_map['class'] == 0]['patches'], match_original=True, alpha=0.2)
pc.set_facecolor('grey')
ax.add_collection(pc)
x, y = m(coords[0] + 0.02, coords[1] + 1.0)
details = plt.annotate(info, xy=(x, y), size=24, color='#555555')
# Draw a map scale
m.drawmapscale(
coords[0] + 0.2, coords[1] + 0.95,
coords[0], coords[1],
20., fontsize=8,
barstyle='fancy', labelstyle='simple',
fillcolor1='w', fillcolor2='#555555',
fontcolor='#555555', units='mi',
zorder=5)
legend_patches = []
for i in range(6):
legend_patches.append(mpatches.Patch(color=colors[i],
label=CrimePatterns[i]))
plt.legend(handles=legend_patches, loc='lower right')
x1, y1 = m(coords[0] + 0.05, 33.62)
colorinfo = 'Color represent each cluster of community;\nBrightness represent the severities of crime in each community'
plt.annotate(colorinfo, xy=(x1, y1), size=16, color='#555555')
plt.tight_layout()
fig.set_size_inches(12, 13)
plt.savefig(title, dpi=300, alpha=True)
def chloropleth(self, query, color = "Blues"):
"""shows a chloropleth map of crimes
Args:
query: name of sql
"""
self.load()
data = pd.read_sql_query(con=self.con, sql=query)
points = self.gen_points(data, self.data_map)
self.data_map['count'] = self.data_map['poly'].map(lambda x: len(list(filter(prep(x).contains, points))))
self.data_map['density_m'] = self.data_map['count'] / self.data_map['area_m']
self.data_map['density_km'] = self.data_map['count'] / self.data_map['area_km']
self.data_map.replace(to_replace={'density_m': {0: np.nan}, 'density_km': {0: np.nan}}, inplace=True)
breaks = nb(
self.data_map[self.data_map['density_km'].notnull()].density_km.values,
initial=300,
k=5)
jb = pd.DataFrame({'jenks_bins': breaks.yb}, index=self.data_map[self.data_map['density_km'].notnull()].index)
self.data_map = self.data_map.join(jb)
self.data_map.jenks_bins.fillna(-1, inplace=True)
jenks_labels = ["<= %0.1f/km$^2$(%s communities)" % (b, c) for b, c in zip(
breaks.bins, breaks.counts)]
jenks_labels.insert(0, 'None (%s communities)' % len(self.data_map[self.data_map['density_km'].isnull()]))
cmap = plt.get_cmap(color)
self.data_map['patches'] = self.data_map['poly'].map(lambda x: PolygonPatch(x, ec='#555555', lw=.2, alpha=1., zorder=4))
pc = PatchCollection(self.data_map['patches'], match_original=True)
norm = Normalize()
pc.set_facecolor(cmap(norm(self.data_map['jenks_bins'].values)))
self.ax.add_collection(pc)
cb = self.gen_colorbar(colors=len(jenks_labels), color_map=cmap, shrink=0.5, labels=jenks_labels)
cb.ax.tick_params(labelsize=6)
plt.tight_layout()
plt.show()
def basemap(data='deg_OsakaBayMap_okada.bln'):
"""
Title: Function of plotting map in Osaka Bay
Created on 2014/07/17
Referrence: http://matplotlib.org/examples/api/patch_collection.html
"""
# Get land data
patches = _read_lands(data)
# Plot patches
p = PatchCollection(patches, lw=0.5)
p.set_facecolor('#eeeeee') #'w') #, alpha=0.5
ax = plt.gca()
ax.add_collection(p)
# Set figure options
ax.set_xlabel(u'Longitude [\N{DEGREE SIGN}E]')
ax.set_ylabel(u'Latitude [\N{DEGREE SIGN}N]')
ax.xaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax.yaxis.set_major_formatter(FormatStrFormatter('%.1f'))
ax.set_xlim([134.82, 135.48])
ax.set_ylim([34.20, 34.76])
def visualize_investment_in_toronto():
"""Function to visualize the investment in the neighborhoods of
Toronto.
This function is too big, it will be splitted in several parts according
to the visualization they do.
It plots these ESRI Shapefiles from Toronto using matplotlib/basemap/etc.
(These shapefiles are available as Open Data from the City of Toronto):
. The City Wards in Toronto;
. The Neighborhoods defined as Priority Investment by the City of Toronto
. The Business Improvement Areas defined by the City of Toronto
. The Current Value Assessment on Tax Impact for Residential Neighborhoods
in the City of Toronto (last year available, 2011)
"""
fig = plt.figure()
axes = [None, None, None]
# grid of 2x2 rows and colums for the subplots with differ. visualizations
axes[0] = plt.subplot2grid((2, 2), (0, 0))
axes[1] = plt.subplot2grid((2, 2), (0, 1))
axes[2] = plt.subplot2grid((2, 2), (1, 0), colspan=2)
# axes = fig.add_subplot(111)
# First map is the Priority investment by the City of Toronto
axes[0].set_title("Priority investment by the City of Toronto")
to_map = draw_toronto_and_city_wards(axis=axes[0])
# Read the Shapefile of the Priority Investment Neighborhoods in Toronto.
# The Shapefile is read first and its polygons are filled with the color
# 'facecolor' in a for-loop below
dummy = to_map.readshapefile(shapefile="./shp_dir/TO_priority_inv_neighb", name="prio_investm", drawbounds=False)
patches = []
for info, shape in zip(to_map.prio_investm_info, to_map.prio_investm):
# print info
patches.append(Polygon(np.array(shape), True))
axes[0].add_collection(PatchCollection(patches, facecolor="m", edgecolor="k", linewidths=1.0, zorder=3))
# Read the Shapefile of the Business Improvement Areas in Toronto.
# The Shapefile is read first and its polygons are filled with the color
# 'facecolor' in a for-loop below
axes[1].set_title("Business Improvement Areas of Toronto")
to_map = draw_toronto_and_city_wards(axis=axes[1])
dummy = to_map.readshapefile(shapefile="./shp_dir/TO_busin_improv_area", name="busin_improv", drawbounds=False)
patches = []
for info, shape in zip(to_map.busin_improv_info, to_map.busin_improv):
# print info
patches.append(Polygon(np.array(shape), True))
axes[1].add_collection(PatchCollection(patches, facecolor="g", edgecolor="k", linewidths=1.0, zorder=2))
# Read the Shapefile of the Estimated Tax Impact in Toronto.
# The way to plot this Shapefile is different than the previous one, since
# this shapefile has an Avg Tax Impact value [field 'avgtaximpa']
# associated to each of its polygons, so the different tonalities of
# 'facecolor' in its polygons represent the Avg Tax Impact value in each
# polygon
axes[2].set_title("Current Value and Assessed Tax Impact per Sub-Ward")
to_map = draw_basic_map_of_toronto(axis=axes[2])
dummy = to_map.readshapefile(
shapefile="shp_dir/CVA_2011_Tax_Impact_WGS84", name="tax_assesm_impact", drawbounds=False
)
patches = []
taxes = []
# Note that the taxes impact (in taxes[]) is different inside a same ward
# in the city of Toronto. I.e., a same ward can have different subpolygons
# with different tax-impact. Example, for 'ward' = 2:
# {'subdiv': '19041', 'ward': 2.0, 'avgtaximpa': -56.0554, ...}
# {'subdiv': '19042', 'ward': 2.0, 'avgtaximpa': -58.6994, ...}
for info, shape in zip(to_map.tax_assesm_impact_info, to_map.tax_assesm_impact):
# print info
# The estimated taxes in the polygon is the gradient which gives the
# tonality of red to the polygon
taxes.append(float(info["avgtaximpa"]))
patches.append(Polygon(np.array(shape), True))
cmap = plt.get_cmap("Reds")
patch_collection = PatchCollection(patches, match_original=True)
min_taxes = min(taxes)
max_taxes = max(taxes)
norm = Normalize(min_taxes, max_taxes)
patch_collection.set_facecolor(cmap(norm(taxes)))
axes[2].add_collection(patch_collection)
# Add a colour bar
delta_gradient_taxes = max_taxes - min_taxes
color_bar_taxes = [min_taxes]
for i in range(1, 6):
color_bar_taxes.append(min_taxes + (i / 6.0) * delta_gradient_taxes)
color_bar_taxes.append(max_taxes)
clor_bar = colorbar_index(
ncolors=len(color_bar_taxes), cmap=cmap, shrink=0.7, labels=color_bar_taxes, format="%.2f", ax=axes[2]
)
# Set the font-size of the tick labels in the color bar
clor_bar.ax.tick_params(labelsize=7)
clor_bar.set_label(label="Tax Impact")
# Show highest densities, in descending order
# highest = '\n'.join(
# value[1] for _, value in df_map[(df_map['jenks_bins'] == 4)][:10].sort().iterrows())
# highest = 'Most Dense Wards:\n\n' + highest
# Subtraction is necessary for precise y coordinate alignment
# details = clor_bar.ax.text(
# -1., 0 - 0.007,
# highest,
# ha='right', va='bottom',
# size=5,
# color='#555555')
# Add a small legend
# ( http://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes.text )
# dummy = axes[2].text(
# 0.98, 0.05,
# 'This is a map of taxes and investment per subwards in Toronto\n' +
# 'Obtained from Open Data of the City of Toronto\n' +
# 'See README of this project for URLs\n',
# horizontalalignment='right', verticalalignment='bottom',
# size=6,
# color='#555555',
# bbox=dict(facecolor='red', alpha=0.2),
# transform=axes[2].transAxes)
# Draw a map scale
# to_map.drawmapscale(
# coords[0] + 0.08, coords[1] + 0.015,
# coords[0], coords[1],
# 10.,
# barstyle='fancy', labelstyle='simple',
# fillcolor1='w', fillcolor2='#555555',
# fontcolor='#555555',
# zorder=5)
fig.set_tight_layout(True)
fig.set_size_inches(9, 7)
# plt.title('Toronto Neighborhoods: Priority Investment, Business ' +
# 'Improvement Areas,\nand Current Value Assessment of Tax ' +
# 'Impact on Residential Properties')
# plt.legend()
fig.savefig("TO_developm_neighborhoods.png", dpi=600)
plt.show()
def GenerateMap(self, inputFile):
start = time.time()
#Create file which hold statistics for each inputFile (containing mean/median travel times, std, min, max etc.)
self.statistics = self.createStatistics()
self.basename = os.path.basename(inputFile)[:-4]
AttributeParameter = self.A
coords = self.coords
#Format figure
plt.clf()
fig = plt.figure()
#Picture frame for Map
gs = gridspec.GridSpec(12, 12)
ax = plt.subplot(gs[:,:],axisbg='w', frame_on=False)
try:
#Read MetropAccess-matka-aikamatriisi data in
MatrixData = pd.read_csv(inputFile, sep=';')
#Join data to shapefile (pandas 'merge' function)
df_map = pd.merge(left=self.Y, right=MatrixData, how='outer', left_on='YKR_ID', right_on='from_id')
#CLASSIFY MATRIX DATA
#Replace -1 values
df_map.replace(to_replace={AttributeParameter: {-1: np.nan}}, inplace=True)
#Data for histogram
histData = pd.DataFrame(df_map[df_map[AttributeParameter].notnull()][AttributeParameter].values)
maxBin = max(df_map[df_map[AttributeParameter].notnull()][AttributeParameter].values) #.AttributeParameter.values)
NoData = int(maxBin+1)
NullCount = len(df_map[df_map[AttributeParameter].isnull()])
NullP = (NullCount/13230.0)*100
#Fill NoData values with maxBin+1 value
df_map[AttributeParameter].fillna(NoData, inplace=True)
#Manual classification
if not self.Cl in ['Natural Breaks', 'Quantiles', "Fisher's Jenks"]:
#Create bins for classification based on chosen classification method
Manual = True
if "time" in AttributeParameter:
measure = "min"
measure2 = "minutes" #Another string-form for summary
titleMeas = "time"
if self.Cl == "10 Minute Equal Intervals":
#Calculate the highest class (10 minutes * Number of classes)
maxClass = 10*self.Nclasses
#Create 'higher than' info for the colorbar
maxClassInfo = str(maxClass-10)
#Create array of bins from 0 to highest class with increments of 10
bins = np.arange(10, maxClass, 10)
#Add extra classes for No Data and higher than maxClass values
if maxBin < maxClass:
bins = list(np.append(bins, [maxClass+1, maxClass+2]))
else:
bins = list(np.append(bins, [maxBin, maxBin+1]))
elif self.Cl == "5 Minute Equal Intervals":
#Calculate the highest class (10 minutes * Number of classes)
maxClass = 5*self.Nclasses
#Create 'higher than' info for the colorbar
maxClassInfo = str(maxClass-5)
#Create array of bins from 0 to highest class with increments of 5
bins = np.arange(5, maxClass, 5)
#Add extra classes for No Data and higher than maxClass values
if maxBin < maxClass:
bins = list(np.append(bins, [maxClass+1, maxClass+2]))
else:
bins = list(np.append(bins, [maxBin, maxBin+1]))
elif "dist" in AttributeParameter:
measure = "km"
measure2 = "kilometers"
titleMeas = "distance"
if self.Cl == "5 Km Equal Intervals":
#Calculate the highest class (5000 meters * Number of classes)
maxClass = 5000*self.Nclasses
#Create 'higher than' info for the colorbar
maxClassInfo = str((maxClass-5000)/1000)
#Create array of bins from 0 to highest class with increments of 5000 (meters)
bins = np.arange(5000, maxClass, 5000)
#Add extra classes for No Data and higher than maxClass values
if maxBin < maxClass:
bins = list(np.append(bins, [maxClass+1, maxClass+2]))
else:
bins = list(np.append(bins, [maxBin, maxBin+1]))
elif self.Cl == "10 Km Equal Intervals":
#Calculate the highest class (5000 meters * Number of classes)
maxClass = 10000*self.Nclasses
#Create 'higher than' info for the colorbar
maxClassInfo = str((maxClass-10000)/1000)
#Create array of bins from 0 to highest class with increments of 5000 (meters)
bins = np.arange(0, maxClass, 10000)
#Add extra classes for No Data and higher than maxClass values
if maxBin < maxClass:
bins = list(np.append(bins, [maxClass+1, maxClass+2]))
else:
bins = list(np.append(bins, [maxBin, maxBin+1]))
#Classify data based on bins
breaks = mc.User_Defined(df_map[df_map[AttributeParameter].notnull()][AttributeParameter], bins)
else:
Manual = False
if self.Cl == 'Natural Breaks':
breaks = nb(df_map[df_map[AttributeParameter].notnull()][AttributeParameter],initial=100, k=self.Nclasses)
elif self.Cl == 'Quantiles':
breaks = Quantiles(df_map[df_map[AttributeParameter].notnull()][AttributeParameter], k=self.Nclasses)
elif self.Cl == "Fisher's Jenks":
breaks = fj(df_map[df_map[AttributeParameter].notnull()][AttributeParameter], k=self.Nclasses)
bins = list(breaks.bins)
if "time" in AttributeParameter:
measure = "min"
measure2 = "minutes" #Another string-form for summary
titleMeas = "time"
maxClassInfo = str(bins[-2])
else:
measure = "km"
measure2 = "kilometers"
titleMeas = "distance"
maxClassInfo = str(bins[-2]/1000)
bins.append(maxBin)
bins.append(maxBin)
#the notnull method lets us match indices when joining
jb = pd.DataFrame({'jenks_bins': breaks.yb}, index=df_map[df_map[AttributeParameter].notnull()].index)
df_map = df_map.join(jb)
brksBins = bins[:-1]#breaks.bins[:-1] #Do not take into account NoData values
if measure2 == "kilometers": #Convert meters (in data) to kilometers for legend
b = [round((x/1000),0) for x in brksBins]
brksBins = b
del b
brksCounts = breaks.counts[:-1] #Do not take into account NoData values
#Check if brksCounts and brksBins dismatches --> insert 0 values if necessary (to match the counts)
if len(brksBins) != len(brksCounts):
dif = len(brksBins)-len(brksCounts)
brksCounts = np.append(brksCounts,[0 for x in xrange(dif)])
else:
dif=0
#List for measures which will be inserted to class labels
measureList = [measure for x in xrange(len(brksBins))]
#Class labels
jenks_labels = ["%0.0f %s (%0.1f %%)" % (b, msr, (c/13230.0)*100) for b, msr, c in zip(brksBins[:-1],measureList[:-1],brksCounts[:-1])]
if Manual == True:
if "dist" in AttributeParameter:
jenks_labels.insert(int(maxBin), '>' + maxClassInfo +' km (%0.1f %%)' % ((brksCounts[-1]/13230.0)*100))
else:
jenks_labels.insert(int(maxBin), '>'+ maxClassInfo +' min (%0.1f %%)' % ((brksCounts[-1]/13230.0)*100))
jenks_labels.insert(NoData, 'NoData (%0.1f %%)' % (NullP))
#Use modified colormap ('my_colormap') - Choose here the default colormap which is used as a startpoint --> cm.YourColor'sName (eg. cm.Blues) - See available Colormaps: http://matplotlib.org/examples/color/colormaps_reference.html
cmap = self.my_colormap(cm.RdYlBu, len(bins))
#Draw grid with grey outlines
df_map['Grid'] = df_map['poly'].map(lambda x: PolygonPatch(x, ec='#555555', lw=.2, alpha=1., zorder=4)) #RGB color-codes can be found at http://www.rapidtables.com/web/color/RGB_Color.htm
pc = PatchCollection(df_map['Grid'], match_original=True)
#-----------------------------
#Reclassify data to value range 0.0-1.0 (--> colorRange is 0.0-1.0)
if Manual == True:
colbins = np.linspace(0.0,1.0, len(bins))
colbins = colbins-0.001
colbins[0], colbins[-1] = 0.0001, 1.0
reclassification = {}
for index in range(len(bins)):
reclassification[index] = colbins[index]
reclassification['_reclassify'] = self.reclassify
reclass = []
dataList = list(df_map['jenks_bins'])
for value in dataList:
reclass.append(self.reclassify(reclassification, value))
df_map['jenks_binsR'] = reclass
else:
norm = Normalize()
df_map['jenks_binsR'] = norm(df_map['jenks_bins'].values)
#-----------------------------
#Impose colour map onto the patch collection
pc.set_facecolor(cmap(df_map['jenks_binsR'].values))
#Add colored Grid to map
ax.add_collection(pc)
#Add coastline to the map
self.C['Polys'] = self.C['poly'].map(lambda x: PolygonPatch(x, fc='#606060', ec='#555555', lw=.25, alpha=.88, zorder=4)) #Alpha adjusts transparency, fc='facecolor', ec='edgecolor'
cpc = PatchCollection(self.C['Polys'], match_original=True)
ax.add_collection(cpc)
#Add roads to the map
for feature in self.R:
xx,yy=feature.xy
self.B.plot(xx,yy, linestyle='solid', color='#606060', linewidth=0.7, alpha=.6)
#Add metro to the map
for line in self.M: #metroLines is a shapely MultiLineString object consisting of multiple lines (is iterable)
x,y=line.xy
self.B.plot(x,y, color='#FF2F2F', linewidth=0.65, alpha=.4)
#----------------------
#GENERATE TARGET POINT
#----------------------
#Generate YKR_ID from csv name
ykrID = int(self.basename.split('_')[2])
#Find index of target YKR_ID
tIndex = df_map.YKR_ID[df_map.YKR_ID == ykrID].index.tolist()
trow = df_map[tIndex[0]:tIndex[0]+1]
targetPolygon = trow.poly
centroid = targetPolygon.values[0].centroid #Get centroid of the polygon --> Returns shapely polygon point-type object
self.B.plot(
centroid.x,centroid.y,
'go', markersize=3, label="= Destination")
#-----------------------------
#LEGEND
#-----------------------------
#Draw a map scale
self.B.drawmapscale(
coords[0] + 0.47, coords[1] + 0.013, #Etäisyys vasemmalta, etäisyys alhaalta: plussataan koordinaatteihin asteissa
coords[0], coords[1],
#10.,
10.,
barstyle='fancy', labelstyle='simple',yoffset=200, #yoffset determines the height of the mapscale
fillcolor1='w', fillcolor2='#909090', fontsize=6, # black= #000000
fontcolor='#202020',
zorder=5)
#Set up title
if "PT" in AttributeParameter:
tMode = "public transportation"
elif "Car" in AttributeParameter:
tMode = "car"
elif "Walk" in AttributeParameter:
tMode = "walking"
titleText = "Travel %s to %s (YKR-ID) \n by %s" % (titleMeas,str(ykrID),tMode)
plt.figtext(.852,.735,
titleText, size=9.5)
#Plot copyright texts
copyr = "%s MetropAccess project, University of Helsinki, 2014\nLicensed under a Creative Commons Attribution 4.0 International License" % (unichr(0xa9))
plt.figtext(.24,.078,copyr,fontsize=4.5)
#----------------
#Add a colour bar
#----------------
#Set arbitary location (and size) for the colorbar
axColor = plt.axes([.86, .15, .016,.52]) #([DistFromLeft, DistFromBottom, Width, Height])
cb = self.colorbar_index(ncolors=len(jenks_labels), cmap=cmap, labels=jenks_labels, cax=axColor)#, shrink=0.5)#, orientation="vertical", pad=0.05,aspect=20)#,cax=cbaxes) #This is a function --> see at the beginning of the code. #, cax=cbaxes shrink=0.5,
cb.ax.tick_params(labelsize=5.5)
#Inform travel sum of the whole grid (i.e. centrality of the location)
#Travel time
if measure2 == "minutes":
tMean = histData.mean().values[0]
tMedian=histData.median().values[0]
tMax = histData.max().values[0]
tMin = histData.min().values[0]
tStd=histData.std().values[0]
travelSummary = "Summary:"
travelMean = "Mean: %0.0f %s" % (tMean, measure2)
travelMedian = "Median: %0.0f %s" % (tMedian, measure2)
travelStd = "Std: %0.0f %s" % (tStd,measure2)
travelRange = "Range: %0.0f-%0.0f %s" % (tMin,tMax,measure2)
#Travel distance
else:
h = histData.values/1000
histData = pd.DataFrame(h)
del h
tMean = histData.mean().values[0]
tMedian=histData.median().values[0]
tMax = histData.max().values[0]
tMin = histData.min().values[0]
tStd=histData.std().values[0]
travelSummary = "Summary:"
travelMean = "Mean: %0.1f %s" % (tMean, measure2)
travelMedian = "Median: %0.1f %s" % (tMedian, measure2)
travelStd = "Std: %0.1f %s" % (tStd,measure2)
travelRange = "Range: %0.1f-%0.1f %s" % (tMin,tMax,measure2)
#Write information to a statistics file
mInfo = "%s;%0.0f;%0.0f;%0.0f;%0.0f;%0.0f\n" % ( str(ykrID), tMean, tMedian, tStd, tMin, tMax)
self.writeStatistics(mInfo)
#Helper variables for moving Summary statistic texts
initialPos = .58 #.15 #.44
initialXPos = .975 #.20 #.97
textSize = 5.25
split = 0.018
#Plot Travel Summary title
plt.figtext(initialXPos, initialPos+split*4,
travelSummary, ha='left', va='bottom', color='#404040', size=textSize, style='normal',fontweight='bold')
#Plot Travel Summary mean
plt.figtext(initialXPos, initialPos+split*3,
travelMean,ha='left', va='bottom', size=textSize, color='b')
#Plot Travel Summary median
plt.figtext(initialXPos, initialPos+split*2,
travelMedian,ha='left', va='bottom', size=textSize, color='r')
#Plot Travel Summary Standard deviation
plt.figtext(initialXPos, initialPos+split,
travelStd,ha='left', va='bottom', size=textSize)
#Plot Travel Summary Range
plt.figtext(initialXPos, initialPos,
travelRange,ha='left', va='bottom', size=textSize)
#Plot Legend symbol
ax.legend(bbox_to_anchor=(.97, 0.07), fontsize=5.5, frameon=False, numpoints=1) #1.265 bbox_to_anchor=(x,y) --> arbitary location for legend, more info: http://matplotlib.org/api/legend_api.html
#--------------------------------------------------------
#Travel time and population (catchment areas) histograms
#--------------------------------------------------------
#New axes for travel time/distance histogram
ax = plt.axes([.98, .39, .16, .14], axisbg='w') #([DistFromLeft, DistFromBottom, Width, Height])
#Add histogram
n, bins, patches = ax.hist(histData.values, 100, normed=False, facecolor='green', alpha=0.75, rwidth=0.5, orientation="vertical")
ax.axvline(histData.median(), color='r', linestyle='solid', linewidth=1.8)
ax.axvline(histData.mean(), color='b', linestyle='solid', linewidth=1.0)
if measure2 == "minutes":
ax.set_xlabel("t(min)", fontsize=5,labelpad=1.5)
xupLim = 250 #upper limit for x-axis
else:
ax.set_xlabel("km", fontsize=5,labelpad=1.5)
xupLim = 100 #upper limit for x-axis
#Set valuelimits for axes
ax.set_xlim(0,xupLim-30)
if max(n) < 1000: #ymax will be set to 1000 if count of individual bin is under 1000, else 1500
yMax = 1000
else:
yMax = 1600
ax.set_ylim(0,yMax)
#Set histogram title
plt.figtext(.975, .535,
"Travel %s histogram" % titleMeas,ha='left', va='bottom', size=5.7, style='italic')
#Adjust tick font sizes and set yaxis to right
ax.tick_params(axis='both', direction="out",labelsize=4.5, pad=1,
labelright=True,labelleft=False, top=False, left=False,
color='k', length=3, width=.9)
ax.xaxis.set_ticks(np.arange(0,xupLim-30,30))
gridlines = ax.get_xgridlines()
gridlines.extend( ax.get_ygridlines() )
for line in gridlines:
line.set_linewidth(.28)
line.set_linestyle('dotted')
ax.grid(True)
#----------------------------------------------------
#New axes for population diagram
ax = plt.axes([.98, .17, .16, .14], axisbg='w') #([DistFromLeft, DistFromBottom, Width, Height])
#Make dataframe from Ykr-population
pop = pd.read_csv(self.Ypop, sep=';')
#Use original Matrix without NoData values
MatrixData.replace(to_replace={AttributeParameter: {-1: np.nan}}, inplace=True)
#Join population information and time matrix
join = pd.merge(left=MatrixData, right=pop, how='outer', left_on='from_id', right_on='YKR_ID')
#Sort data by attribute parameter
sorted = join.sort(columns=[AttributeParameter])
#Aggregate data by AttributeParameter
aggre = pd.DataFrame(sorted.groupby(AttributeParameter).sum().Population)
#Create attribute from index
aggre[AttributeParameter] = aggre.index
#Create cumulative population attribute
aggre['cumPop'] = aggre['Population'].cumsum()
#Reset index and determine AttributeParameter as float (matplotlib requires for it to work)
aggre.reset_index(inplace=True, drop=True)
aggre[AttributeParameter].astype(float)
#print aggre[0:10]
#Create filled curve plot from the cumulative population
ax.fill_between(aggre.index,aggre['cumPop']/1000,0, interpolate=True, lw=1, facecolor='green', alpha=0.6)
#Set valuelimits for axes
ax.set_xlim(0,xupLim-50)
ax.set_ylim(-10,aggre['cumPop'].max()/1000+50)
gridlines = ax.get_xgridlines()
gridlines.extend( ax.get_ygridlines() )
for line in gridlines:
line.set_linewidth(.28)
line.set_linestyle('dotted')
ax.grid(True)
ax.tick_params(axis='both', direction="out",labelsize=4.5, pad=1,
labelright=True,labelleft=False, top=False, left=False,
color='k', length=3, width=.9)
ax.xaxis.set_ticks(np.arange(0,xupLim-30,30))
if measure2 == "minutes":
ax.set_xlabel("t(min)", fontsize=5,labelpad=1.5)
measure3 = 'minutes'
else:
measure3 = 'km'
ax.set_xlabel("km", fontsize=5,labelpad=1.5)
#Set histogram title
plt.figtext(.975, .315,
"Population (per 1000) reached within (x) %s" % measure3,ha='left', va='bottom', size=5.7, style='italic')
#-----------------------
#Save map to disk
#-----------------------
fig.set_size_inches(9.22, 6.35) #(Width, Height)
outputPath = os.path.join(self.outputFolder, self.basename) + AttributeParameter + ".png"
plt.savefig(outputPath, dpi=300, alpha=True, bbox_inches='tight')
plt.close() #or plt.close('all') --> closes all figure windows
end = time.time()
lasted = int(end-start)
return lasted
except Exception as e:
return e
def plotChoropleth(filename,imgfile,figNum):
shapefile = 'data/ne/ne_10m_admin_0_countries'
cols = ['CC', 'DISCON']
num_colors = 20
gc = GeonamesCache()
iso_codes = list(gc.get_dataset_by_key(gc.get_countries(), 'iso').keys())
df = pd.read_csv(filename, skiprows=0, usecols=cols)
df.set_index('CC', inplace=True)
df = df.ix[iso_codes].dropna() # Filter out non-countries and missing values.
values = df['DISCON']
cm = plt.get_cmap('Reds')
scheme = [cm(float(i) / num_colors) for i in range(num_colors)]
#bins = np.linspace(values.min(), values.max(), num_colors)
bins = np.linspace(0, 1, num_colors)
df['bin'] = np.digitize(values, bins) - 1
df.sort_values('bin', ascending=False)#.head(10)
#print(df)
mpl.style.use('seaborn-pastel')
print('Plotting Figure {0}: {1}'.format(figNum,imgfile))
fig = plt.figure(figNum,figsize=(22, 12))
ax = fig.add_subplot(111, axisbg='w', frame_on=False)
#plt.title('Disco Choropleth', fontsize=20)#, y=.95)
m = Basemap(lon_0=0, projection='robin')
m.drawmapboundary(color='w')
m.readshapefile(shapefile, 'units', color='#444444', linewidth=.2)
for info, shape in zip(m.units_info, m.units):
#iso = info['ADM0_A3']
iso = info['ISO_A2']
#print(iso)
try:
if iso not in df.index:
color = '#dddddd'
else:
color = scheme[int(df.ix[iso]['bin'])]
except TypeError:
print(iso)
traceback.print_exc()
patches = [Polygon(np.array(shape), True)]
pc = PatchCollection(patches)
pc.set_facecolor(color)
ax.add_collection(pc)
# Cover up Antarctica so legend can be placed over it.
ax.axhspan(0, 1000 * 1800, facecolor='w', edgecolor='w', zorder=2)
# Draw color legend.
ax_legend = fig.add_axes([0.35, 0.14, 0.3, 0.03], zorder=3)
cmap = mpl.colors.ListedColormap(scheme)
cb = mpl.colorbar.ColorbarBase(ax_legend, cmap=cmap, ticks=bins, boundaries=bins, orientation='horizontal')
cb.ax.set_xticklabels([str(round(i, 2)) for i in bins],rotation='80')
# Set the map footer.
#plt.annotate(descripton, xy=(-.8, -3.2), size=14, xycoords='axes fraction')
plt.savefig(imgfile, bbox_inches='tight', pad_inches=.2)
cmap.set_under(color=cmap(0)) # if yearBuilt less than min(range)
cmap.set_over(color='white') # if yearBuilt is more than max(range)
norm = matplotlib.colors.BoundaryNorm(yearBuilt_bins, ncolors)
df_map['color'] = norm(df_map.yearBuilt)
# normalization changes nans to -1, same as underflow
df_map['color'][df_map.yearBuilt<1700] = -2
#df_map
plt.clf()
fig = plt.figure()
ax = fig.add_subplot(111, axisbg='w', frame_on=False)
# plot parcels by adding the PatchCollection to the axes instance
pc = PatchCollection(df_map['patches'].values, match_original=True)
#pc.set_facecolor(cmap(norm(df_map.yearBuilt)/(ncolors-1)))
pc.set_facecolor(cmap(np.ma.masked_less_equal(list(df_map.color), -2)/(ncolors-1)))
ax.add_collection(pc)
yearBuilt_labels = ['%.0f-%.0f' % (np.ceil(yearBuilt_bins[i]), np.floor(yearBuilt_bins[i+1]))
for i in range(ncolors)]
#yearBuilt_labels.append('>%.0f' % yearBuilt_bins[-1])
yearBuilt_labels[0] = '<%.0f' % yearBuilt_bins[1]
#yearBuilt_bins = np.insert(yearBuilt_bins, 0, 1700)
#yearBuilt_bins = np.append(yearBuilt_bins, 2016)
cb = colorbar_index(ncolors=ncolors, cmap=cmap, shrink=0.5,
labels=yearBuilt_labels)
# boundaries = [i for i in range(ncolors+1)])
# , extend='both')
# boundaries = [1700] + list(yearBuilt_bins) + [2016])
cb.ax.tick_params(labelsize=6)
# you could also use 'Oranges' or 'Greens'
cmap = plt.get_cmap('Blues')
# draw boundaries with grey outlines
df_map['patches'] = df_map['poly'].map(lambda x: PolygonPatch(x, ec='#555555', lw=.2, alpha=1., zorder=4))
# set the PatchCollection with our defined 'patches'
pc = PatchCollection(df_map['patches'], match_original=True)
# normalize our bins between the min and max values within the bins
norm = Normalize(vmin=df_map['bins'].min(), vmax=df_map['bins'].max())
# impose our color map onto the patch collection
pc.set_facecolor(cmap(norm(df_map['bins'].values)))
ax.add_collection(pc)
# Add a color bar which has our bin_labels applied
cb = colorbar_index(ncolors=len(bin_labels), cmap=cmap, shrink=0.5, labels=bin_labels)
# set the font size of the labels (set to size 10 here)
cb.ax.tick_params(labelsize=10)
# Create a bit of small print
smallprint = ax.text(
# set the x,y location of the smallprint
1, 1,
# add whatever text you would like to appear
'This is a U.S. map showing ' + var_2_analyze + ' per state.',
# set the horizontal/vertical alignment
ha='right', va='bottom',
# <codecell>
figwidth = 14
fig = plt.figure(figsize=(figwidth, figwidth*h/w))
ax = fig.add_subplot(111, axisbg='w', frame_on=False)
cmap = plt.get_cmap('Blues')
# draw neighborhoods with grey outlines
df_map['patches'] = df_map['poly'].map(lambda x: PolygonPatch(x, ec='#111111', lw=.8, alpha=1., zorder=4))
pc = PatchCollection(df_map['patches'], match_original=True)
# apply our custom color values onto the patch collection
cmap_list = [cmap(val) for val in (df_map.jenks_bins.values - df_map.jenks_bins.values.min())/(
df_map.jenks_bins.values.max()-float(df_map.jenks_bins.values.min()))]
pc.set_facecolor(cmap_list)
ax.add_collection(pc)
#Draw a map scale
m.drawmapscale(coords[0] + 0.08, coords[1] + -0.01,
coords[0], coords[1], 10.,
fontsize=16, barstyle='fancy', labelstyle='simple',
fillcolor1='w', fillcolor2='#555555', fontcolor='#555555',
zorder=5, ax=ax,)
# ncolors+1 because we're using a "zero-th" color
cbar = custom_colorbar(cmap, ncolors=len(jenks_labels)+1, labels=jenks_labels, shrink=0.5)
cbar.ax.tick_params(labelsize=16)
fig.suptitle(" Time Spent in Seattle Neighborhoods", fontdict={'size':24, 'fontweight':'bold'}, y=0.92)
ax.set_title(" Using location data collected from my Android phone via Google Takeout", fontsize=14, y=0.98)
def GenerateBasemapImage(DataDirectory, RasterFile, FigWidthInches = 4, FigHeightInches = 3, bm_width = 2000000, bm_height = 2000000, projection = 'lcc',resolution = 'l', lat_0 = 0, lon_0 = 0, lat_1 = 45,lat_2 = 55, satellite_height = 10000000, FigFormat = "png", fig_dpi = 500, out_fname_prefix = ""):
"""
This makes the basemap image.
Args:
DataDirectory (str): The directory of the raster file
RasterFile (str): the name of the raster file (include extension)
FigWidthInches (float): How wide you want the basemap
FigHeightInches (float): How high you want your basemap
bm_width (float): The width in metres of your basemap
bm_height (float): The height in metres covered by your basemap
projection (str): The projection of your basemap. See basemap docs for details
resolution (str): Resolution. See basmap documentation. Default is "l" (for low) since higher resolution ("high" or "full") must be installed separately with basemap (and is very large)
lat_0 (flt): Latitude of centre of your map
lon_0 (flt): Longitude of centre of your map
lat_1 (flt): See basemap documentation
lon_1 (flt): See basemap documentation
satellite_height (flt): The satellite height in metres for geostationary projections
FigFormat (str): Figure format, can be `png`, `svg`, `pdf`, etc.
fig_dpi (int): Dots per inch of your figure
out_fname_prefix (str): The prefix of the image file. If blank uses the fname_prefix
Author: SMM
Date: 24/01/2018
"""
# Make sure data directory is in correct format
if not DataDirectory.endswith(os.sep):
print("You forgot the separator at the end of the directory, appending...")
DataDirectory = DataDirectory+os.sep
# Set up the figure. This is needed to both size the figure and get the axis handle for plotting polygons
fig, ax = plt.subplots(figsize=(FigWidthInches, FigHeightInches))
# get some filenames
RasterSplit = RasterFile.split(".")
Raster_prefix = RasterSplit[0]
Shape_name = DataDirectory+Raster_prefix+"_footprint"
SName = "Shape"
Full_Shape_name = Shape_name+".shp"
# Get the name of the image
if len(out_fname_prefix) == 0:
FigFileName = DataDirectory+Base_file+"_basemap."+fig_format
else:
FigFileName = DataDirectory+out_fname_prefix+"_basemap."+fig_format
# Now for the basemap
# setup Lambert Conformal basemap.
#m = Basemap(width=bm_width,height=bm_width,projection=projection,
# resolution=resolution,lat_1=lat_1 ,lat_2=lat_2,lat_0=lat_0,lon_0=lon_0, satellite_height = satellite_height, area_thresh = 100000)
# create the shapefile
LSDMGDAL.CreateShapefileOfRasterFootprint(DataDirectory, RasterFile)
#shape_feature = ShapelyFeature(Reader(fname).geometries(),ccrs.PlateCarree(), facecolor='none')
#ax.add_feature(shape_feature)
# draw coastlines.
#m.drawcoastlines(linewidth = 0.5)
# draw a boundary around the map, fill the background.
# this background will end up being the ocean color, since
# the continents will be drawn on top.
#m.drawmapboundary(fill_color='snow')
# fill continents, set lake color same as ocean color.
#m.fillcontinents(color='lightgray',lake_color='snow')
# draw parallels and meridians.
# label parallels on right and top
# meridians on bottom and left
parallels = np.arange(0.,90,5.)
# labels = [left,right,top,bottom]
#m.drawparallels(parallels,labels=[False,True,True,False])
meridians = np.arange(10.,351.,5.)
#m.drawmeridians(meridians,labels=[True,False,False,True])
#m.drawcountries()
# Make a patch from the shapefile
# All this stuff from:
# http://www.datadependence.com/2016/06/creating-map-visualisations-in-python/
df_poly = pd.DataFrame({
'shapes': [Polygon(np.array(shape), True) for shape in m.footprint]})
#df_poly = df_poly.merge(new_areas, on='area', how='left')
#cmap = plt.get_cmap('Oranges')
pc = PatchCollection(df_poly.shapes, zorder=2, alpha = 0.5)
pc.set_facecolor("crimson")
ax.add_collection(pc)
plt.savefig(FigFileName,format=FigFormat,dpi=fig_dpi)
