def set_subplot_map(self, highlights, cgeorange):
###SUBPLOT: SET MAP
self.oldax = self.p.ax
self.p.ax = self.p.fig.add_axes([0.02, -0.39, 1.04, 0.44])
self.p.setmap(projection='cyl', georange=cgeorange, resolution='i')
self.p.draw('country coastline province city')
###SUBPLOT: HIGHLIGHT COASTLINES & PLOT LEGEND
colors = ['#AAFFAA', '#FFFF44', '#FF3333', '#BB0044']
descr = ['10~25%', '25~50%', '50~75%', '>75%']
handles = []
for i, clr in enumerate(colors, 0):
patch = PathCollection(geos_to_path(
MultiLineString(highlights[i]).buffer(self.buffersize)),
facecolor=clr)
self.p.ax.add_collection(patch)
handles.append(Patch(color=clr, label=descr[i]))
self.p.ax.text(0.98,
0.27,
'中心经过1经纬度\n范围内的几率',
transform=self.p.ax.transAxes,
va='bottom',
ha='right',
fontsize=6,
family='Source Han Sans CN')
self.p.legend(handles=handles, loc='lower right', framealpha=0.8)
def PolygonPath(shape):
"""Constructs a compound matplotlib path from a Shapely or GeoJSON-like
geometric object"""
if isinstance(shape, (sgeom.LineString, sgeom.Point)):
return Path(np.vstack(shape.xy).T)
elif isinstance(shape, sgeom.Polygon):
codes, vertices = PolygonCodes(shape)
return Path(vertices, codes)
elif isinstance(
shape,
(sgeom.MultiPolygon, sgeom.MultiLineString, sgeom.MultiPoint)):
codes, vertices = [], []
for poly in shape:
sub_codes, sub_vertices = PolygonCodes(poly)
codes.append(sub_codes)
vertices.append(sub_vertices)
codes = np.concatenate(codes)
vertices = np.concatenate(vertices)
return Path(vertices, codes)
elif isinstance(shape, sgeom.GeometryCollection):
return PathCollection([PolygonPath(geom) for geom in shape.geoms])
else:
raise ValueError('Unsupported shape type {}.'.format(type(shape)))
def as_patch(self, **kwds):
""" matplotlib pathpatch for hlines and vlines
**pathkwds : any valid PathCollection keyword (linestyle, edgecolor)
Notes
-----
First, finds coordinates of hlines, vlines. Then, it it finds
the x, y coords of each line; it extracts the points corresponding to
each isoline, and makes a path for each of these."""
hlines = zip(*np.where(self.hlines))
vlines = zip(*np.where(self.vlines))
xunique = set([x for x, y in hlines])
yunique = set([y for x, y in vlines])
hpaths = []
vpaths = []
# REVERSE PATHS FOR SAKE OF PLOT (y,x) !!
for xun in xunique:
hpaths.append(Path([(y, x) for x, y in hlines if x == xun]))
for yun in yunique:
vpaths.append(Path([(y, x) for x, y in vlines if y == yun]))
return PathCollection(hpaths + vpaths, **kwds)
def _make_barb(self, temperature, theta, speed, angle):
"""Add the barb to the plot at the specified location."""
u, v = self._uv(speed, angle)
if 0 < speed < _BARB_BINS[0]:
# Plot the missing barbless 1-2 knots line.
length = self._kwargs['length']
pivot_points = dict(tip=0.0, middle=-length / 2.)
pivot = self._kwargs.get('pivot', 'tip')
offset = pivot_points[pivot]
verts = [(0.0, offset), (0.0, length + offset)]
rangle = math.radians(-angle)
verts = mtransforms.Affine2D().rotate(rangle).transform(verts)
codes = [Path.MOVETO, Path.LINETO]
path = Path(verts, codes)
size = length**2 / 4
xy = np.array([[temperature, theta]])
barb = PathCollection([path], (size, ),
offsets=xy,
transOffset=self._transform,
**self._custom_kwargs)
barb.set_transform(mtransforms.IdentityTransform())
self.axes.add_collection(barb)
else:
barb = plt.barbs(temperature,
theta,
u,
v,
transform=self._transform,
**self._kwargs)
return barb
def makeplot(field2plot, lon_ts, lat_ts, vmin, vmax, m, findex, shp_info):
norm = colors.Normalize(vmin=vmin, vmax=vmax)
bounds = np.arange(vmin, vmax + .0001, dvar)
ax = plt.gca()
ax.cla()
paths = []
for line in shp_info[4]._paths:
paths.append(Path(line.vertices, codes=line.codes))
coll = PathCollection(paths, linewidths=0, facecolors='black', zorder=2)
ax.add_collection(coll)
m.drawcoastlines(ax=ax, linewidth=0.05)
m.drawcountries(ax=ax, linewidth=0.05)
pcm = plt.pcolormesh(lon_ts, lat_ts, field2plot, norm=norm, cmap=cmap)
# cbar = plt.colorbar(pcm, norm=norm, cmap=cmap, orientation='vertical', pad=0.05, aspect=15,
# shrink=0.7, extend='both')
# cbar.set_ticks(bounds)
figname = str(findex).zfill(5)
plt.savefig(figdir + figname, facecolor="black", dpi=150)
plt.close()
print findex
return findex
def _add_bondlength_change_collection(self,
index,
threshold=0,
zorder=20,
**kwargs):
"""Comute and draw bondlength changes on the axes."""
codes = [Path.MOVETO, Path.LINETO]
col = []
amp = []
colors = []
for obbond in ob.OBMolBondIter(self.molecule):
atom1, atom2 = (self.molecule.GetAtom(obbond.GetBeginAtomIdx()),
self.molecule.GetAtom(obbond.GetEndAtomIdx()))
atom1nc, atom2nc = [
self._to_normal_coordinates(atom, index)
for atom in (atom1, atom2)
]
if obbond.GetLength() == 0.0:
logger.error(
"Bond between %i and %i with length %.1f ignored." %
(atom1.GetIdx(), atom2.GetIdx(), obbond.GetLength()))
continue
amplitude = atom1.GetDistance(atom2) - atom1nc.GetDistance(atom2nc)
if abs(amplitude * 100) <= threshold: continue
amp.append(abs(amplitude * 50))
colors.append(self.bond_colors[0 if amplitude < 0.0 else 1])
verts = (self._2Dcoords(atom1), self._2Dcoords(atom2))
segment = Path(verts, codes)
col.append(segment)
lw = 0.0 if not col else np.array(amp) * kwargs.pop("lw", 1.0)
kw = {'edgecolors': colors, 'linewidths': lw}
kwargs.update(kw)
self._vib_bonds = PathCollection(col, zorder=zorder, **kwargs)
self.axes.add_collection(self._vib_bonds)
def plot_map_native(lon_corners, lat_corners, data, **kwargs):
from matplotlib import pyplot, patches, path
import numpy
# Fix longitude coordinates; we need longitudes to run from
# -180 to 180, not from 0 to 360
lon_corners.values = numpy.where(lon_corners > 180, lon_corners - 360,
lon_corners)
# Loop over GLL nodes and create paths that describe the boundaries
# of each node; collect these into a list to plot all at once
path_list = []
for icol in range(lon_corners.shape[0]):
# Get corners for this node
x_corners = lon_corners[icol, :].values
y_corners = lat_corners[icol, :].values
# Repeat first vertex at end of array to close the path
x_corners = numpy.append(x_corners, x_corners[0])
y_corners = numpy.append(y_corners, y_corners[0])
# Create paths connecting the corners and append to list
vertices = numpy.column_stack([x_corners, y_corners])
path_list.append(path.Path(vertices, closed=True))
# Plot collection of patches
from matplotlib.collections import PathCollection
collection = PathCollection(path_list, transform=crs.Geodetic(), **kwargs)
collection.set_array(data)
ax = pyplot.gca()
pl = ax.add_collection(collection)
return pl
def _get_patch_collections(self, axes):
for key, collection in self._collection_map.items():
marker = self._markers[key]
coll = PathCollection([marker.get_path()],
offsets=collection,
transOffset=axes.transAxes,
facecolors=[self._colors[key]])
yield coll
def on_ax(self, ax, pos, orientation):
trans = np.reshape(orientation, (2, 2)).T
for offset, normal, text, size, halign, valign, color in self.texts:
normal = np.matmul(normal, trans)
angle = math.atan2(-normal[1], normal[0]) * 180 / math.pi
x, y = (pos + np.matmul(offset, trans)) * Y_TRANS
if angle >= 180 or angle < 0:
if halign == 'right':
halign = 'left'
elif halign == 'left':
halign = 'right'
if valign == 'top':
valign = 'bottom'
elif valign == 'bottom':
valign = 'top'
angle -= 180
kw = {
'x': x,
'y': y,
'color': color,
# 'font': 'sans-serif',
'fontsize': size,
's': text,
'rotation': angle,
'rotation_mode': 'anchor',
'horizontalalignment': halign,
'verticalalignment': valign,
'clip_on': True,
}
ax.text(**kw)
if self.paths:
d = {}
d['paths'] = []
d['linewidths'] = []
d['edgecolors'] = []
d['facecolors'] = []
for path, linewidth, edgecolor, facecolor in self.paths:
verts = path.vertices
verts = np.matmul(verts, trans)
verts = (pos + verts) * Y_TRANS
path.vertices = verts
d['paths'].append(path)
d['linewidths'].append(linewidth)
d['edgecolors'].append(edgecolor)
d['facecolors'].append(facecolor)
pc = PathCollection(offset_position='data', **d)
ax.add_collection(pc)
def plot(self,
*,
ax,
color,
lw=2,
n=30000,
fuzz=3,
rot=None,
rot_point=None,
**kwargs):
"""Add this plot to the axis.
Parameters
----------
ax: Axes
Matplotlib axis to add the art to
color: str
Color to use. Must be readable by `matplotlib.colors.to_rgba`. Can be
something like "black", "k", or "#ffffff".
lw: float > 0
Linewidth to use for chords
n: int > 0
Number of chords to use
fuzz: float > 0
How ragged edges should be
rot: float
How much to rotate the shape, in radians
rot_point: ndarray (optional)
What point to rotate the shape around (default is the center)
kwargs:
Passed to `PathCollection`
Returns
-------
None
"""
color = np.array(to_rgba(color)) * 255
colors = np.tile(color.reshape(-1, 1), n).T
colors[:, :3] += np.random.randint(-50, 50, (n, 3))
colors = np.minimum(255, np.maximum(0, colors)) / 255
alpha = kwargs.pop("alpha", 0.05)
colors[:, -1] = alpha
ax.add_collection(
PathCollection(
[
Path(p) for p in self.gen_points(
n=n, fuzz=fuzz, rot=rot, rot_point=rot_point)
],
linewidths=lw,
edgecolors=colors,
facecolors="none",
**kwargs,
))
def _add_oop_angle_change_collection(self,
index,
threshold=0,
CURVE_TYPE=4,
zorder=50,
**kwargs):
"""Compute and draw torsion changes on the axes."""
CURVE_TYPE_3, CURVE_TYPE_4 = 3, 4
col = []
edgecolors = []
if CURVE_TYPE is CURVE_TYPE_3:
codes = [
Path.MOVETO,
Path.CURVE3,
Path.CURVE3,
]
elif CURVE_TYPE is CURVE_TYPE_4:
codes = [
Path.MOVETO,
Path.CURVE4,
Path.CURVE4,
Path.CURVE4,
]
for torsion in ob.OBMolTorsionIter(self.molecule):
atoms = [self.molecule.GetAtom(idx + 1) for idx in torsion]
atomsnc = [
self._to_normal_coordinates(atom, index) for atom in atoms
]
teq = self.molecule.GetTorsion(*atoms)
tnc = self.molecule.GetTorsion(*atomsnc)
amplitude = (tnc - teq + 360.0) % 360.0
if amplitude > 180.0:
amplitude -= 360.0
if abs(amplitude) <= threshold: continue
intensity = abs(amplitude / 40)
a, b, c, d = [self._2Dcoords(atom) for atom in atoms]
p2 = 0.5 * (b + c) # middle
p1 = intensity * (a - p2) + p2
p3 = intensity * (d - p2) + p2
color = self.oop_colors[0 if amplitude < 0.0 else 1]
if CURVE_TYPE is CURVE_TYPE_3:
verts = [p1, p2, p3]
elif CURVE_TYPE is CURVE_TYPE_4:
verts = [p1, b, c, p3]
curve = Path(verts, codes)
col.append(curve)
edgecolors.append(color)
kw = {'edgecolors': edgecolors, 'facecolors': 'none'}
kwargs.update(kw)
self._vib_oop = PathCollection(col, zorder=zorder, **kwargs)
self.axes.add_collection(self._vib_oop)
def __init__(self, n=100, marker=triangle):
v, c = marker
v, c = np.array(v), np.array(c)
self._marker = marker
self._base_vertices = np.tile(v.reshape(-1), n).reshape(n, len(v), 2)
self._vertices = np.tile(v.reshape(-1), n).reshape(n, len(v), 2)
self._codes = np.tile(c.reshape(-1), n)
self._scale = np.ones(n)
self._translate = np.zeros((n, 2))
self._rotate = np.zeros(n)
self._path = Path(vertices=self._vertices.reshape(n*len(v), 2),
codes=self._codes)
self._collection = PathCollection(
[self._path], facecolor="white", edgecolor="black")
def plot(self,
ax=None,
unfilled=(4, 5),
edgecolors='k',
facecolors=(0.75, 0.75, 0.75)):
from matplotlib.path import Path
from matplotlib.collections import PathCollection
ax = get_axes(ax, xlab="R (m)", ylab="z (m)")
ax.set_aspect('equal')
ax.set_xlim((0.5, 2.5))
ax.set_ylim((-1.5, 1.5))
paths = [Path(xy) for i, xy in enumerate(self.xy) if i not in unfilled]
pc = PathCollection(paths,
facecolors=facecolors,
edgecolors=edgecolors)
ax.add_collection(pc)
paths = [Path(self.xy[i]) for i in unfilled]
pc = PathCollection(paths, facecolors='none', edgecolors=edgecolors)
ax.add_collection(pc)
return ax
def _add_spectrum_collection(self, **kwargs):
"""Draw spectrum on the axes."""
codes = [
Path.MOVETO,
Path.LINETO,
]
col = []
for frequency, intensity in zip(self.frequencies, self.intensities):
verts = [(frequency, 0.0), (frequency, intensity)]
col.append(Path(verts, codes))
kw = {}
kwargs.update(kw)
self._spectrum = PathCollection(col, **kwargs)
self.axes.add_collection(self._spectrum)
def __init__(self, n=100):
v = np.array([(-0.25, -0.25), (+0.0, +0.5), (+0.25, -0.25), (0, 0)])
c = np.array([Path.MOVETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY])
self._base_vertices = np.tile(v.reshape(-1), n).reshape(n, len(v), 2)
self._vertices = np.tile(v.reshape(-1), n).reshape(n, len(v), 2)
self._codes = np.tile(c.reshape(-1), n)
self._scale = np.ones(n)
self._translate = np.zeros((n, 2))
self._rotate = np.zeros(n)
self._path = Path(vertices=self._vertices.reshape(n*len(v), 2),
codes=self._codes)
self._collection = PathCollection([self._path], linewidth=0.5,
facecolor="k", edgecolor="w")
def _add_bond_collection(self, zorder=10, **kwargs):
"""Draw molecule skeleton on the axes."""
col = []
codes = [
Path.MOVETO,
Path.LINETO,
] # segment
for obbond in ob.OBMolBondIter(self.molecule):
atom1, atom2 = (self.molecule.GetAtom(obbond.GetBeginAtomIdx()),
self.molecule.GetAtom(obbond.GetEndAtomIdx()))
verts = self._2Dcoords(atom1), self._2Dcoords(atom2)
segment = Path(verts, codes)
col.append(segment)
kw = {'edgecolors': 'k'}
kwargs.update(kw)
self._mol_bonds = PathCollection(col, zorder=zorder, **kwargs)
self.axes.add_collection(self._mol_bonds)
def makeplot(field2plot, lon_ts, lat_ts, vmin, vmax, m, findex, shp_info):
norm = colors.Normalize(vmin=vmin, vmax=vmax)
bounds = np.arange(vmin, vmax + .0001, dvar)
#fig = plt.figure()
#ax = fig.add_subplot(111)
ax = plt.gca()
ax.cla()
paths = []
for line in shp_info[4]._paths:
paths.append(Path(line.vertices, codes=line.codes))
coll = PathCollection(paths, linewidths=0, facecolors='grey', zorder=2)
ax.add_collection(coll)
m.drawcoastlines(ax=ax, linewidth=0.05)
m.drawcountries(ax=ax, linewidth=0.05)
# m.fillcontinents(color = 'gray')
# m.drawmapboundary()
# m.drawparallels(np.arange(round(coordinates[2]), coordinates[3], dlat), linewidth=0.,
# labels=[1, 0, 0, 0], fontname='Times New Roman', fontsize=16, zorder=1)
# m.drawmeridians(np.arange(round(coordinates[0]), coordinates[1], dlon), linewidth=0.,
# labels=[0, 0, 0, 1], fontname='Times New Roman', fontsize=16, zorder=1)
# u2plot = u[tt, ::NN, ::NN].squeeze()
# v2plot = v[tt, ::NN, ::NN].squeeze()
# speed = np.sqrt(u2plot*u2plot + v2plot*v2plot)
# speed = np.ma.masked_greater(speed, 1.5)
pcm = plt.pcolormesh(lon_ts, lat_ts, field2plot, norm=norm, cmap=cmap)
# cbar = plt.colorbar(pcm, norm=norm, cmap=cmap, orientation='vertical', pad=0.05, aspect=15,
# shrink=0.7, extend='both')
# cbar.set_ticks(bounds)
figname = str(findex).zfill(5)
plt.savefig(figdir + figname, dpi=200)
plt.close()
print findex
return findex
def get_patches(self, ax):
ranges = LineCollection(self._cap_ranges, linestyle="solid")
links = LineCollection(self._oob_links,
linestyle="dotted",
colors=colorConverter.to_rgba_array("#808080"))
color = colorConverter.to_rgba_array("#DC143C")
scales = np.array((20, ))
marker_obj = MarkerStyle("o")
path = marker_obj.get_path().transformed(marker_obj.get_transform())
offsets = PathCollection((path, ),
scales,
facecolors=color,
offsets=self._oob_offsets,
transOffset=ax.transData)
offsets.set_transform(IdentityTransform())
return [ranges, links, offsets]
def _generate_node_artist(pos, styles, *, ax):
N = len(pos)
proto_node = next(iter(pos))
x = np.zeros(N) * np.nan
y = np.zeros(N) * np.nan
properties = {
k: [None] * N
for k in styles[proto_node] if k in _VALID_NODE_STYLE
}
for j, node in enumerate(pos):
x[j], y[j] = pos[node]
for key, values in properties.items():
values[j] = styles[node][key]
key_map = {
'size': 'sizes',
'color': 'facecolors',
'shape': 'marker',
'width': 'linewidths',
'edgecolor': 'edgecolors'
}
renamed_properties = {key_map[k]: v for k, v in properties.items()}
markers = renamed_properties.pop('marker', None)
if markers is None:
paths = (MarkerStyle('o'), )
else:
paths = [MarkerStyle(m) for m in markers]
paths = [p.get_path().transformed(p.get_transform()) for p in paths]
offsets = np.column_stack([x, y])
node_art = PathCollection(paths,
offsets=offsets,
transOffset=ax.transData,
**renamed_properties)
node_art.set_transform(mtransforms.IdentityTransform())
ax.add_collection(node_art)
ax.autoscale_view()
return node_art
def my_scatter(self, ax, x, y):
from matplotlib.collections import PathCollection
from matplotlib.path import Path
import matplotlib.transforms as mtransforms
phi = np.linspace(0, 2 * np.pi, 100)
# Scale, in pixel coordinates
rad = 2
x_circle = np.cos(phi) * rad
y_circle = np.sin(phi) * rad
verts = np.vstack([x_circle, y_circle]).T
path = Path(verts, closed=False)
collection = PathCollection(
[path],
facecolor='blue',
edgecolor='black',
transOffset=ax.transData,
)
collection.set_transform(mtransforms.IdentityTransform())
ax.add_collection(collection, autolim=True)
ax.autoscale()
px = np.random.rand(10)
py = np.random.rand(10)
offsets = np.ma.column_stack([px, py])
#%% 1
fig, ax = plt.subplots()
reduction = 50
c = Path.unit_circle()
c = c.transformed(Affine2D().scale(0.5 * reduction))
collection = PathCollection(
(c,), offsets=offsets,
transOffset = ax.transData,
edgecolor='black',
facecolor=(0, 0, 0, .0125),
linewidth=1
)
collection.set_transform(IdentityTransform())
ax.add_collection( collection )
#%% 2
collection.set_path_effects([withStroke(linewidth=5, foreground='r')])
collection.set_path_effects([])
collection.get_path_effects()
'flag', 'prism', 'ocean', 'gist_earth', 'terrain', 'gist_stern',
'gnuplot', 'gnuplot2', 'CMRmap', 'cubehelix', 'brg',
'gist_rainbow', 'rainbow', 'jet', 'nipy_spectral', 'gist_ncar'])]
colormaplist = sum([x[1] for x in colormap_from_reference],[])
#
# Artist may not reture the same value as given by setter...
# Also, matplotlib has a routine to get a list of valid property values.
# With get_valid_values, it may be possible to implement more automatic
# property list generation.
#
# The following is an initial attempt. Needs to check more how well
# matplotlib is organized in this aspect.
obj = PathCollection(Path.unit_rectangle())
#plinestylelist, plinestyle_rlist = artist_property_checker(obj, 'linestyle')
pedgecolorlist, pedgecolor_rlist = artist_property_checker(
obj, 'edgecolor', values="'"+"','".join(collist)+"'")
plinestylelist = ['solid', 'dotted', 'dashed', 'dashdot']
plinestyle_rlist = ['solid', 'dotted', 'dashed', 'dashdot']
if isMPL2:
plinestylelist = plinestylelist[:4]
plinestyle_rlist = plinestyle_rlist[:4]
def colormap_list():
return colormaplist
def scratch_file():
which = values > 1.
for shp_link in [shp_link]:
fig = plt.figure()
patchco = map_poly_shp(shp_link)
patchcoB = map_poly_shp(shp_link, which=which)
patchco.set_facecolor('none')
ax = setup_ax([patchco, patchcoB])
fig.add_axes(ax)
plt.show()
break
'''
xy = (((0, 0), (0, 0)), ((2, 1), (2, 1)), ((3, 1), (3, 1)), ((2, 5), (2,
5)))
xy = np.array([[10, 30], [20, 20]])
markerobj = mpl.markers.MarkerStyle('o')
path = markerobj.get_path().transformed(markerobj.get_transform())
scales = np.array([2, 2])
fig = plt.figure()
ax = fig.add_subplot(111)
pc = PathCollection((path,), scales, offsets=xy, \
facecolors='r', transOffset=mpl.transforms.IdentityTransform())
#pc.set_transform(mpl.transforms.IdentityTransform())
#_ = _add_axes2col(pc, [0, 0, 5, 5])
ax.add_collection(pc)
fig.add_axes(ax)
#ax = setup_ax([pc], ax)
plt.show()
def __init__(self, n=100, angle=0, radius=0):
v = np.array([(-0.25, -0.25), (+0.0, +0.5), (+0.25, -0.25), (0, 0)])
c = np.array([Path.MOVETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY])
self._base_vertices = np.tile(v.reshape(-1), n).reshape(n, len(v), 2)
self._vertices = np.tile(v.reshape(-1), n).reshape(n, len(v), 2)
self._codes = np.tile(c.reshape(-1), n)
self._scale = np.ones(n)
self._translate = np.zeros((n, 2))
self._rotate = np.zeros((n, 2))
self._path = Path(vertices=self._vertices.reshape(n * len(v), 2),
codes=self._codes)
self.cone = True if angle else False
if self.cone:
# viewing cone
angles = [-angle / 2, -angle / 4, 0, angle / 4, angle / 2]
#cos_ang = np.cos(angle/2)
#sin_ang = np.sin(angle/2)
#cos_ang2 = np.cos(angle/4)
#sin_ang2 = np.sin(angle/4)
bl = np.tan(angle / np.pi) * 4 / 3 * np.sqrt(radius) / np.pi
v_cone = []
for a in angles:
cos_ang = np.cos(a)
sin_ang = np.sin(a)
v_cone.append((sin_ang * radius - cos_ang * bl,
cos_ang * radius + sin_ang * bl))
v_cone.append((sin_ang * radius, cos_ang * radius))
v_cone.append((sin_ang * radius + cos_ang * bl,
cos_ang * radius - sin_ang * bl))
v_cone = np.array([(0, 0)] + v_cone[1:-1] + [(0, 0)])
#v_cone = np.array([(+0.0, +0.0),
# (-sin_ang*radius, cos_ang*radius),
# (-sin_ang*radius + cos_ang*bl, cos_ang*radius + sin_ang*bl),
# (-sin_ang2*radius -cos_ang2*bl, cos_ang2*radius -sin_ang2*bl),
# (-sin_ang2*radius, cos_ang2*radius),
# (0,0),
# (-sin_ang2*radius, cos_ang2*radius),
# (-sin_ang2*radius + cos_ang2*bl, cos_ang2*radius + sin_ang2*bl),
# (-bl, radius),
# (0.,radius),
# (bl, radius),
# (sin_ang2*radius - cos_ang2*bl, cos_ang2*radius + sin_ang2*bl),
# (sin_ang2*radius, cos_ang2*radius),
# (sin_ang2*radius + cos_ang2*bl, cos_ang2*radius - sin_ang2*bl),
# (sin_ang*radius - cos_ang*bl, cos_ang*radius + sin_ang*bl),
# (sin_ang*radius, cos_ang*radius),
# (0,0)])
c_cone = np.array([
Path.MOVETO, Path.LINETO, Path.CURVE4, Path.CURVE4,
Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4,
Path.CURVE4, Path.CURVE4, Path.CURVE4, Path.CURVE4,
Path.CURVE4, Path.CURVE4, Path.CLOSEPOLY
])
#c_cone = np.array([Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY])
self._base_vertices_cone = np.tile(v_cone.reshape(-1),
n).reshape(n, len(v_cone), 2)
self._vertices_cone = np.tile(v_cone.reshape(-1),
n).reshape(n, len(v_cone), 2)
self._codes_cone = np.tile(c_cone.reshape(-1), n)
self._path_cone = Path(vertices=self._vertices_cone.reshape(
n * len(v_cone), 2),
codes=self._codes_cone)
self._collection = PathCollection([self._path, self._path_cone],
linewidths=[0.5, 0.1],
facecolors=["k", (0, 0, 0, 0)],
edgecolors=["w", "b"])
else:
self._collection = PathCollection([self._path],
linewidth=0.5,
facecolor="k",
edgecolor="w")
angle2 = angle1 + np.random.randint(180, 270)
path = mpath.Path.wedge(angle1, angle2)
verts, codes = path.vertices * .25, path.codes
path = mpath.Path(verts, codes)
paths.append(path)
offsets = np.ones((n, 2))
offsets[:, 0], offsets[:, 1] = np.linspace(1, 10, n) + .2, y
X, Y = offsets[:, 0], offsets[:, 1]
sizes = np.ones(n) / 100
offsets[:, 1] -= sizes / 2 - .125
facecolors = ['%.1f' % c for c in np.linspace(0.25, 0.75, n)]
collection = PathCollection(paths,
sizes=None,
linewidths=1.0,
facecolors=facecolors,
edgecolor="black",
offsets=offsets - (0.2, -0.25),
transOffset=ax.transData)
ax.add_collection(collection)
ax.text(1 - 0.25,
y + 0.35,
"Path collection",
size="small",
ha="left",
va="baseline")
ax.text(10 + 0.25,
y + 0.35,
"PathCollection",
color="blue",
size="small",
def plot_beachball_mpl(
mt, axes,
beachball_type='deviatoric',
position=(0., 0.),
size=None,
zorder=0,
color_t='red',
color_p='white',
edgecolor='black',
linewidth=2,
alpha=1.0,
projection='lambert',
size_units='points'):
'''
Plot beachball diagram to a Matplotlib plot
:param mt: :py:class:`pyrocko.moment_tensor.MomentTensor` object or an
array or sequence which can be converted into an MT object
:param beachball_type: ``'deviatoric'`` (default), ``'full'``, or ``'dc'``
:param position: position of the beachball in data coordinates
:param size: diameter of the beachball either in points or in data
coordinates, depending on the ``size_units`` setting
:param zorder: (passed through to matplotlib drawing functions)
:param color_t: color for compressional quadrants (default: ``'red'``)
:param color_p: color for extensive quadrants (default: ``'white'``)
:param edgecolor: color for lines (default: ``'black'``)
:param linewidth: linewidth in points (default: ``2``)
:param alpha: (passed through to matplotlib drawing functions)
:param projection: ``'lambert'`` (default), ``'stereographic'``, or
``'orthographic'``
:param size_units: ``'points'`` (default) or ``'data'``, where the
latter causes the beachball to be projected in the plots data
coordinates (axes must have an aspect ratio of 1.0 or the
beachball will be shown distorted when using this).
'''
transform, position, size = choose_transform(
axes, size_units, position, size)
mt = deco_part(mt, beachball_type)
eig = mt.eigensystem()
if eig[0] == 0. and eig[1] == 0. and eig[2] == 0:
raise BeachballError('eigenvalues are zero')
data = []
for (group, patches, patches_lower, patches_upper,
lines, lines_lower, lines_upper) in eig2gx(eig):
if group == 'P':
color = color_p
else:
color = color_t
# plot "upper" features for lower hemisphere, because coordinate system
# is NED
for poly in patches_upper:
verts = project(poly, projection)[:, ::-1] * size + position[NA, :]
if alpha == 1.0:
data.append((Path(verts), color, color, linewidth))
else:
data.append((Path(verts), color, 'none', 0.0))
for poly in lines_upper:
verts = project(poly, projection)[:, ::-1] * size + position[NA, :]
data.append((Path(verts), 'none', edgecolor, linewidth))
paths, facecolors, edgecolors, linewidths = zip(*data)
path_collection = PathCollection(
paths,
facecolors=facecolors,
edgecolors=edgecolors,
linewidths=linewidths,
alpha=alpha,
zorder=zorder,
transform=transform)
axes.add_artist(path_collection)
def as_path_collection(self, **kw):
kw.setdefault('facecolors', 'none')
kw.setdefault('edgecolors', 'b')
kw.setdefault('linewidth', 2)
paths = [Path(self.y[:, :2])]
return PathCollection(paths, **kw)
cols = []
#서울 구별 인구수 반영 그림 그리기
fig = plt.figure()
ax = plt.gca()
for x in range(len(seoul)):
coord = seoul[x]['geometry']
verts = coord['coordinates'][0]
patch = Polygon.Polygon(
verts,
facecolor=seoulcolor[seoul[x]['properties']['SIG_KOR_NM']],
ec='k')
cols.append(patch)
ax.add_patch(patch)
plt.autoscale()
plt.axis('off')
p = PathCollection(cols, cmap=cm.Blues)
p.set_array(np.array(colors))
ax.add_collection(p)
ax.autoscale_view()
plt.colorbar(p)
plt.show()
#Draw Heat Map
dx, dy = 0.15, 0.05
y, x = np.mgrid[slice(-3, 3 + dy, dy), slice(-3, 3 + dx, dx)]
z = (1 - x / 2. + x**5 + y**3) * np.exp(-x**2 - y**2)
z = z[:-1, :-1]
z_min, z_max = -np.abs(z).max(), np.abs(z).max()
def draw_networkx_nodes(
G,
pos,
nodelist=None,
node_size=300,
node_color="#1f78b4",
node_shape="o",
alpha=None,
cmap=None,
vmin=None,
vmax=None,
ax=None,
linewidths=None,
edgecolors=None,
label=None,
):
"""Draw the nodes of the graph G.
This draws only the nodes of the graph G.
Parameters
----------
G : graph
A networkx graph
pos : dictionary
A dictionary with nodes as keys and positions as values.
Positions should be sequences of length 2.
ax : Matplotlib Axes object, optional
Draw the graph in the specified Matplotlib axes.
nodelist : list, optional
Draw only specified nodes (default G.nodes())
node_size : scalar or array
Size of nodes (default=300). If an array is specified it must be the
same length as nodelist.
node_color : color or array of colors (default='#1f78b4')
Node color. Can be a single color or a sequence of colors with the same
length as nodelist. Color can be string, or rgb (or rgba) tuple of
floats from 0-1. If numeric values are specified they will be
mapped to colors using the cmap and vmin,vmax parameters. See
matplotlib.scatter for more details.
node_shape : string
The shape of the node. Specification is as matplotlib.scatter
marker, one of 'so^>v<dph8' (default='o').
alpha : float or array of floats
The node transparency. This can be a single alpha value (default=None),
in which case it will be applied to all the nodes of color. Otherwise,
if it is an array, the elements of alpha will be applied to the colors
in order (cycling through alpha multiple times if necessary).
cmap : Matplotlib colormap
Colormap for mapping intensities of nodes (default=None)
vmin,vmax : floats
Minimum and maximum for node colormap scaling (default=None)
linewidths : [None | scalar | sequence]
Line width of symbol border (default =1.0)
edgecolors : [None | scalar | sequence]
Colors of node borders (default = node_color)
label : [None| string]
Label for legend
Returns
-------
matplotlib.collections.PathCollection
`PathCollection` of the nodes.
Examples
--------
>>> G = nx.dodecahedral_graph()
>>> nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G))
Also see the NetworkX drawing examples at
https://networkx.github.io/documentation/latest/auto_examples/index.html
See Also
--------
draw()
draw_networkx()
draw_networkx_edges()
draw_networkx_labels()
draw_networkx_edge_labels()
"""
from collections.abc import Iterable
try:
import matplotlib.pyplot as plt
from matplotlib.collections import PathCollection
import numpy as np
except ImportError as e:
raise ImportError("Matplotlib required for draw()") from e
except RuntimeError:
print("Matplotlib unable to open display")
raise
if ax is None:
ax = plt.gca()
if nodelist is None:
nodelist = list(G)
if len(nodelist) == 0: # empty nodelist, no drawing
return PathCollection(None)
try:
xy = np.asarray([pos[v] for v in nodelist])
except KeyError as e:
raise nx.NetworkXError(f"Node {e} has no position.") from e
except ValueError as e:
raise nx.NetworkXError("Bad value in node positions.") from e
if isinstance(alpha, Iterable):
node_color = apply_alpha(node_color, alpha, nodelist, cmap, vmin, vmax)
alpha = None
node_collection = ax.scatter(
xy[:, 0],
xy[:, 1],
s=node_size,
c=node_color,
marker=node_shape,
cmap=cmap,
vmin=vmin,
vmax=vmax,
alpha=alpha,
linewidths=linewidths,
edgecolors=edgecolors,
label=label,
)
ax.tick_params(
axis="both",
which="both",
bottom=False,
left=False,
labelbottom=False,
labelleft=False,
)
node_collection.set_zorder(2)
return node_collection
m = Basemap(projection='cyl',llcrnrlat=-10,urcrnrlat=70,\
llcrnrlon=-140,urcrnrlon=-40,resolution='c')
shp_info = m.readshapefile(
'/home/s1251441/Python/landfile/land/ne_10m_land_scale_rank',
'scalerank',
drawbounds=True)
ax = plt.gca()
ax.cla()
paths = []
for line in shp_info[4]._paths:
paths.append(Path(line.vertices, codes=line.codes))
coll = PathCollection(paths,
linewidths=0.5,
zorder=0,
facecolors='black',
color='grey')
## m = Basemap(projection='robin',lon_0=0,resolution='c')
## m = Basemap(projection='ortho',lon_0=-90,lat_0=90,resolution='c')
m = Basemap(projection='cyl',llcrnrlat=20,urcrnrlat=80,\
llcrnrlon=-160,urcrnrlon=-40,resolution='c')
# drawing something seems necessary to 'initiate' the map properly
m.drawcoastlines(color='black', zorder=0, linewidth=0)
m.drawcountries(color='black', zorder=0, linewidth=0)
m.drawparallels(np.arange(-90., 90., 10.), linewidth=0.5, labels=[1, 1, 0, 0])
m.drawmeridians(np.arange(0., 360., 20.), linewidth=0.5, labels=[0, 0, 1, 1])
##
##m.bluemarble()
ax = plt.gca()
