def add_country(country, color):
if country == "Seychelles" or country == "Mauritius":
return
seg = map.Africa[country_codes.index(country_code_dict[country])]
poly = Polygon(seg, facecolor=color, edgecolor=color)
poly.set_alpha(0.4)
ax.add_patch(poly)
def parallelogram_gen(origin, side1, side2, size, opacity = 1):
# We rescale the points for the [1,1]^2 domain
first_point = origin/size
side1_scaled = side1/size
side2_scaled = side2/size
# Getting the points
second_point= (first_point + side1_scaled)
fourth_point= (first_point + side2_scaled)
third_point = side1_scaled+side2_scaled+first_point
x = [first_point[0],second_point[0],third_point[0],fourth_point[0]]
y = [first_point[1],second_point[1],third_point[1],fourth_point[1]];
fig = plt.figure(0,frameon=False,figsize=(1,1), dpi=size)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
# Paralllogelogram
p = Polygon(xy=list(zip(x,y)))
ax.add_patch(p)
p.set_alpha(None)
p.set_facecolor(np.zeros(3))
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
fig.add_axes(ax)
plt.axis('off')
# Convert figure to data
data = fig2data(fig)
plt.close(fig)
# Take just the first color entry
data = data[:,:,1]
# Normalize the data
data = data/data.max()
data = np.flip(data,0)
return ((data-1)*opacity)+1
def plotReachSet_norm1(self, NUM, figname):
fig = p.figure()
for j in range(n):
ax = fig.add_subplot(2,2,j+1 , aspect='equal')
ax.set_xlim(0, 4)
ax.set_ylim(0, 1)
ax.set_xlabel('$x_'+str(j+1)+'$')
ax.set_ylabel('$y_'+str(j+1)+'$')
for trace in self:
for i in [int(floor(k*len(trace.T)/NUM)) for k in range(NUM)]:
verts = [(trace.x[i][j] + 1/trace.d_norm1[i][2*j], trace.y[i][j] ),
(trace.x[i][j] , trace.y[i][j] - 1/trace.d_norm1[i][2*j+1]),
(trace.x[i][j] - 1/trace.d_norm1[i][2*j], trace.y[i][j] ),
(trace.x[i][j] , trace.y[i][j] + 1/trace.d_norm1[i][2*j+1])]
# poly = Ellipse((trace.x[i][j],trace.y[i][j]), width=trace.d1[i], height=trace.d2[i], angle=trace.theta[i])
poly = Polygon(verts, facecolor='0.8', edgecolor='k')
ax.add_artist(poly)
poly.set_clip_box(ax.bbox)
poly.set_alpha(1)
if i==0:
poly.set_facecolor('r')
else:
poly.set_facecolor(p.rand(3))
#for trace in self:
#e = Ellipse((trace.x[0][j],trace.y[0][j]), width=trace.d1[0], height=trace.d2[0], angle=trace.theta[0])
#ax.add_artist(e)
#e.set_clip_box(ax.bbox)
#e.set_alpha(1)
#e.set_facecolor('r')
#e.set_edgecolor('r')
p.savefig(figname)
def fillPolygon(self,xy,color = None, fill_color = None, ax=None,zorder=None,alpha=None):
if self.resolution is None:
raise AttributeError('there are no boundary datasets associated with this Basemap instance')
# get current axes instance (if none specified).
ax = ax or self._check_ax()
# get axis background color.
axisbgc = ax.get_axis_bgcolor()
npoly = 0
polys = []
# xa, ya = list(zip(*map.county_region[0]))
# check to see if all four corners of domain in polygon (if so,
# don't draw since it will just fill in the whole map).
# ** turn this off for now since it prevents continents that
# fill the whole map from being filled **
# xy = list(zip(xa.tolist(),ya.tolist()))
if self.coastpolygontypes[npoly] not in [2,4]:
poly = Polygon(xy,facecolor=color,edgecolor=color,linewidth=0)
else: # lakes filled with background color by default
if fill_color is None:
poly = Polygon(xy,facecolor=axisbgc,edgecolor=axisbgc,linewidth=0)
else:
poly = Polygon(xy,facecolor=fill_color,edgecolor=fill_color,linewidth=0)
if zorder is not None:
poly.set_zorder(zorder)
if alpha is not None:
poly.set_alpha(alpha)
ax.add_patch(poly)
polys.append(poly)
npoly = npoly + 1
# set axes limits to fit map region.
self.set_axes_limits(ax=ax)
# clip continent polygons to map limbs
polys,c = self._cliplimb(ax,polys)
return polys
def __add_xy_values_as_polygon__(self, xy: list, color: str, closed=False, fill=False, alpha=0.2, line_width=2):
xy = PlotterInterface.get_xy_from_timestamp_to_date_number(xy)
polygon = Polygon(np.array(xy), closed=closed, fill=fill)
polygon.set_visible(True)
polygon.set_color(color)
polygon.set_alpha(alpha)
polygon.set_linewidth(line_width)
self.axes_for_candlesticks.add_patch(polygon)
def draw_enter_exit(self):
"""plot enter and exit cells on the graph"""
start_polygon = Polygon(self.get_polygon_points(self.maze.start), True)
exit_polygon = Polygon(self.get_polygon_points(self.maze.exit), True)
start_polygon.set_facecolor(self.start_color)
exit_polygon.set_facecolor(self.exit_color)
exit_polygon.set_alpha(0.4)
self.ax.add_patch(start_polygon)
self.ax.add_patch(exit_polygon)
return
def animate_polygons(self, frame):
point = self.path[frame]
polygon = Polygon(self.get_polygon_points(point), True)
if point not in [self.maze.start, self.maze.exit]:
if point in self.path[:frame]:
#backtracking
polygon.set_facecolor(self.polygon_backtracking_color)
polygon.set_edgecolor(self.polygon_backtracking_edge_color)
self.ax.add_patch(polygon)
else:
polygon.set_facecolor(self.polygon_face_color)
polygon.set_edgecolor(self.polygon_edge_color)
self.ax.add_patch(polygon)
if point == self.maze.exit:
polygon.set_facecolor(self.exit_color)
polygon.set_alpha(1)
self.ax.add_patch(polygon)
return []
def fill_between(x, y1, y2, ax=P.gca(), alpha=0.5, **kwargs):
"""Plot distribution to a head surface, derived from some sensor locations.
The sensor locations are first projected onto the best fitting sphere and
finally projected onto a circle (by simply ignoring the z-axis).
:Parameters:
x:
,y1,y2
ax: mpl axes
axes to plot to. Standard is pylab.
view: one of 'top' and 'rear'
Defines from where the head is viewed.
**kwargs:
All additional arguments will be passed to `pylab.imshow()`.
:Returns:
(map, head, sensors)
The corresponding matplotlib objects are returned if plotted, ie.
if plothead is set to `False`, `head` will be `None`.
map
The colormap that makes the actual plot, a
matplotlib.image.AxesImage instance.
head
What is returned by `plot_head_outline()`.
sensors
The dots marking the electrodes, a matplotlib.lines.Line2d
instance.
"""
# add x,y2 in reverse order for proper polygon filling
verts = zip(x,y1) + [(x[i], y2[i]) for i in range(len(x)-1,-1,-1)]
poly = Polygon(verts, **kwargs)
poly.set_alpha(alpha)
ax.add_patch(poly)
ax.autoscale_view()
return poly
class PolygonInteractor(QtCore.QObject):
"""
Polygon Interactor
Parameters
----------
axtmp : matplotlib axis
matplotlib axis
pntxy :
"""
showverts = True
epsilon = 5 # max pixel distance to count as a vertex hit
polyi_changed = QtCore.pyqtSignal(list)
def __init__(self, axtmp, pntxy):
QtCore.QObject.__init__(self)
self.ax = axtmp
self.poly = Polygon([(1, 1)], animated=True)
self.ax.add_patch(self.poly)
self.canvas = self.poly.figure.canvas
self.poly.set_alpha(0.5)
self.pntxy = pntxy
self.ishist = True
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
xtmp, ytmp = list(zip(*self.poly.xy))
self.line = Line2D(xtmp, ytmp, marker='o', markerfacecolor='r',
color='y', animated=True)
self.ax.add_line(self.line)
self.poly.add_callback(self.poly_changed)
self._ind = None # the active vert
self.canvas.mpl_connect('button_press_event',
self.button_press_callback)
self.canvas.mpl_connect('button_release_event',
self.button_release_callback)
self.canvas.mpl_connect('motion_notify_event',
self.motion_notify_callback)
def draw_callback(self):
""" Draw callback """
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
QtWidgets.QApplication.processEvents()
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.poly)
self.ax.draw_artist(self.line)
self.canvas.update()
def new_poly(self, npoly):
""" New Polygon """
self.poly.set_xy(npoly)
self.line.set_data(list(zip(*self.poly.xy)))
self.canvas.draw()
self.update_plots()
def poly_changed(self, poly):
""" Changed Polygon """
# this method is called whenever the polygon object is called
# only copy the artist props to the line (except visibility)
vis = self.line.get_visible()
Artist.update_from(self.line, poly)
self.line.set_visible(vis) # don't use the poly visibility state
def get_ind_under_point(self, event):
"""get the index of vertex under point if within epsilon tolerance"""
# display coords
xytmp = np.asarray(self.poly.xy)
xyt = self.poly.get_transform().transform(xytmp)
xtt, ytt = xyt[:, 0], xyt[:, 1]
dtt = np.sqrt((xtt - event.x) ** 2 + (ytt - event.y) ** 2)
indseq = np.nonzero(np.equal(dtt, np.amin(dtt)))[0]
ind = indseq[0]
if dtt[ind] >= self.epsilon:
ind = None
return ind
def button_press_callback(self, event):
"""whenever a mouse button is pressed"""
if event.inaxes is None:
return
if event.button != 1:
return
self._ind = self.get_ind_under_point(event)
if self._ind is None:
xys = self.poly.get_transform().transform(self.poly.xy)
ptmp = self.poly.get_transform().transform([event.xdata, event.ydata])
# ptmp = event.x, event.y # display coords
if len(xys) == 1:
self.poly.xy = np.array(
[(event.xdata, event.ydata)] +
[(event.xdata, event.ydata)])
self.line.set_data(list(zip(*self.poly.xy)))
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.poly)
self.ax.draw_artist(self.line)
self.canvas.update()
return
dmin = -1
imin = -1
for i in range(len(xys) - 1):
s0tmp = xys[i]
s1tmp = xys[i + 1]
dtmp = dist_point_to_segment(ptmp, s0tmp, s1tmp)
if dmin == -1:
dmin = dtmp
imin = i
elif dtmp < dmin:
dmin = dtmp
imin = i
i = imin
# breakpoint()
self.poly.xy = np.array(list(self.poly.xy[:i + 1]) +
[(event.xdata, event.ydata)] +
list(self.poly.xy[i + 1:]))
self.line.set_data(list(zip(*self.poly.xy)))
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.poly)
self.ax.draw_artist(self.line)
self.canvas.update()
def button_release_callback(self, event):
"""Whenever a mouse button is released"""
if event.button != 1:
return
self._ind = None
self.update_plots()
def update_plots(self):
""" Update Plots """
polymask = Path(self.poly.xy).contains_points(self.pntxy)
self.polyi_changed.emit(polymask.tolist())
def motion_notify_callback(self, event):
"""on mouse movement"""
if self._ind is None:
return
if event.inaxes is None:
return
if event.button != 1:
return
xtmp, ytmp = event.xdata, event.ydata
self.poly.xy[self._ind] = xtmp, ytmp
if self._ind == 0:
self.poly.xy[-1] = xtmp, ytmp
self.line.set_data(list(zip(*self.poly.xy)))
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.poly)
self.ax.draw_artist(self.line)
self.canvas.update()
class Domain:
def __init__(self, vertices, subdomains=[]):
'''
This class describes a 2D polygonal domain
defined by n vertices following a closed
path:
vertices = np.array([[x0,y0],
[x1,y1],
[x2,y2],
...
[xn,yn]])
'''
self.vertices = vertices
self.polygon = Polygon(vertices)
self.path = self.polygon.get_path()
self.subdomains = subdomains
def __add__(self, other):
if isinstance(other, Domain):
return Domain(self.vertices, self.subdomains.append(other))
else:
return NotImplemented
def __sub__(self, other):
return None
def __len__(self):
return len(self.subdomains) + 1
@property
def area(self):
'''
Implementation of Shoelace formula using Numpy
https://en.wikipedia.org/wiki/Shoelace_formula
'''
x = self.vertices[:, 0]
y = self.vertices[:, 1]
return 0.5 * np.abs(
np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
def contains(self, points):
"""
Return True for points inside Domain
"""
return np.array(self.path.contains_points(points))
def contains_all(self, points):
"""
Return True if all points are inside Domain
"""
return self.contains(points).all()
def bounds(self):
'''
Returns a (minx, miny, maxx, maxy) tuple (float values) that bounds the object.
'''
return np.array(
[np.min(self.vertices, axis=0),
np.max(self.vertices, axis=0)])
def addMaterial(self, Subdomain, Value):
if self.contains_all(Subdomain.vertices):
Subdomain.Value = Value
self.subdomains.append(Subdomain)
else:
raise TypeError
def plot(self, show=True):
from matplotlib import pylab
from matplotlib.lines import Line2D
color = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w']
fig, ax = pylab.subplots()
self.polygon.set_alpha(0.3)
x, y = zip(*self.polygon.xy)
line = Line2D(x, y, linestyle='-', marker='o', markerfacecolor='k')
ax.add_line(line)
ax.set_title('Computational Domain')
ax.set_xlim((min(x) - 0.1 * max(x), 1.1 * max(x)))
ax.set_ylim((min(y) - 0.1 * max(y), 1.1 * max(y)))
line.set_color('k')
ax.add_patch(self.polygon)
for i, sub in enumerate(self.subdomains):
x, y = zip(*sub.polygon.xy)
line = Line2D(x, y, linestyle='--', color='k')
ax.add_line(line)
sub.polygon.set_color(color[1])
sub.polygon.set_alpha(0.3)
ax.add_patch(sub.polygon)
if show:
pylab.show()
class PolygonInteractor(QtCore.QObject):
"""
Polygon Interactor
Parameters
----------
axtmp : matplotlib axis
matplotlib axis
pntxy :
"""
showverts = True
epsilon = 5 # max pixel distance to count as a vertex hit
polyi_changed = QtCore.pyqtSignal(list)
def __init__(self, axtmp, pntxy):
QtCore.QObject.__init__(self)
self.ax = axtmp
self.poly = Polygon([(1, 1)], animated=True)
self.ax.add_patch(self.poly)
self.canvas = self.poly.figure.canvas
self.poly.set_alpha(0.5)
self.pntxy = pntxy
self.ishist = True
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
xtmp, ytmp = list(zip(*self.poly.xy))
self.line = Line2D(xtmp, ytmp, marker='o', markerfacecolor='r',
color='y', animated=True)
self.ax.add_line(self.line)
self.poly.add_callback(self.poly_changed)
self._ind = None # the active vert
self.canvas.mpl_connect('button_press_event',
self.button_press_callback)
self.canvas.mpl_connect('button_release_event',
self.button_release_callback)
self.canvas.mpl_connect('motion_notify_event',
self.motion_notify_callback)
def draw_callback(self):
""" Draw callback """
self.background = self.canvas.copy_from_bbox(self.ax.bbox)
QtWidgets.QApplication.processEvents()
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.poly)
self.ax.draw_artist(self.line)
self.canvas.update()
def new_poly(self, npoly):
""" New Polygon """
self.poly.set_xy(npoly)
self.line.set_data(list(zip(*self.poly.xy)))
self.canvas.draw()
self.update_plots()
def poly_changed(self, poly):
""" Changed Polygon """
# this method is called whenever the polygon object is called
# only copy the artist props to the line (except visibility)
vis = self.line.get_visible()
Artist.update_from(self.line, poly)
self.line.set_visible(vis) # don't use the poly visibility state
def get_ind_under_point(self, event):
"""get the index of vertex under point if within epsilon tolerance"""
# display coords
xytmp = np.asarray(self.poly.xy)
xyt = self.poly.get_transform().transform(xytmp)
xtt, ytt = xyt[:, 0], xyt[:, 1]
dtt = np.sqrt((xtt - event.x) ** 2 + (ytt - event.y) ** 2)
indseq = np.nonzero(np.equal(dtt, np.amin(dtt)))[0]
ind = indseq[0]
if dtt[ind] >= self.epsilon:
ind = None
return ind
def button_press_callback(self, event):
"""whenever a mouse button is pressed"""
if event.inaxes is None:
return
if event.button != 1:
return
self._ind = self.get_ind_under_point(event)
if self._ind is None:
xys = self.poly.get_transform().transform(self.poly.xy)
ptmp = event.x, event.y # display coords
if len(xys) == 1:
self.poly.xy = np.array(
[(event.xdata, event.ydata)] +
[(event.xdata, event.ydata)])
self.line.set_data(list(zip(*self.poly.xy)))
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.poly)
self.ax.draw_artist(self.line)
self.canvas.update()
return
dmin = -1
imin = -1
for i in range(len(xys) - 1):
s0tmp = xys[i]
s1tmp = xys[i + 1]
dtmp = dist_point_to_segment(ptmp, s0tmp, s1tmp)
if dmin == -1:
dmin = dtmp
imin = i
elif dtmp < dmin:
dmin = dtmp
imin = i
i = imin
self.poly.xy = np.array(list(self.poly.xy[:i + 1]) +
[(event.xdata, event.ydata)] +
list(self.poly.xy[i + 1:]))
self.line.set_data(list(zip(*self.poly.xy)))
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.poly)
self.ax.draw_artist(self.line)
self.canvas.update()
def button_release_callback(self, event):
"""Whenever a mouse button is released"""
if event.button != 1:
return
self._ind = None
self.update_plots()
def update_plots(self):
""" Update Plots """
polymask = Path(self.poly.xy).contains_points(self.pntxy)
self.polyi_changed.emit(polymask.tolist())
def motion_notify_callback(self, event):
"""on mouse movement"""
if self._ind is None:
return
if event.inaxes is None:
return
if event.button != 1:
return
xtmp, ytmp = event.xdata, event.ydata
self.poly.xy[self._ind] = xtmp, ytmp
if self._ind == 0:
self.poly.xy[-1] = xtmp, ytmp
self.line.set_data(list(zip(*self.poly.xy)))
self.canvas.restore_region(self.background)
self.ax.draw_artist(self.poly)
self.ax.draw_artist(self.line)
self.canvas.update()
m.drawparallels(np.arange(20,80,5),labels=[1,0,0,0],fmt=lat2str(), dashes=[2,0], linewidth=0.5)
m.drawmeridians(np.arange(-20,60,5),labels=[0,0,0,1],fmt=lon2str(), dashes=[2,0], linewidth=0.5)
shp_info = m.readshapefile('cities','cities')
x, y = zip(*m.cities)
m.scatter(x,y,15,marker='o',edgecolors='k',color='none',zorder=10)
print m.proj4string
shp_info = m.readshapefile('polygon','sectors',drawbounds=True, color='r')
ax = plt.gca() # get current axes instance
for nshape,seg in enumerate(m.sectors):
color = "#F9966B"
poly = Polygon(seg,facecolor=color,edgecolor=color)
poly.set_alpha(0.75)
ax.add_patch(poly)
# m.drawlsmask(ocean_color='0.3', lakes=True)
m.fillcontinents(color='0.9', zorder=0)
plt.savefig('008_map_laea.png', dpi=72)
plt.savefig('008_map_laea_big.png', dpi=108)
# create new figure
fig=plt.figure(figsize=(8,5))
# setup oblique mercator basemap.
m = Basemap(projection='cyl',llcrnrlat=35,urcrnrlat=65,\
llcrnrlon=-10,urcrnrlon=45,resolution='l')
