def test_non_tuple_rgbaface():
# This passes rgbaFace as a ndarray to draw_path.
fig = plt.figure()
fig.add_subplot(projection="3d").scatter(
[0, 1, 2], [0, 1, 2], path_effects=[patheffects.Stroke(linewidth=4)])
fig.canvas.draw()
np.arange(1, 52, 1),
tf_pcacf[:, 1:].T,
vmin=0,
vmax=0.04,
cmap=cmap,
rasterized=True)
if np.any(tf_pcacf_p < 0.05):
co = pc_cacf_ax.contour(trial_t,
np.arange(1, 51, 1),
tf_pcacf_p[:, 1:].T,
levels=[0.05],
colors='w',
linewidths=0.75)
plt.setp(co.collections,
path_effects=([
path_effects.Stroke(linewidth=2., foreground='black'),
path_effects.Normal()
]))
pc_cacf_ax.axvline(0, ls='-', c='k', lw=0.5)
pc_cacf_ax.set_xlabel('time relative to stimulus (ms)')
pc_cacf_ax.set_ylabel('lag (trials)')
pc_cacf_ax.set_title(r'smoothed partial acf of phases')
cb_ax = fig.add_subplot(gs2[1, 0])
plt.colorbar(pc,
cax=cb_ax,
label='partial circular correlation coefficient',
orientation='horizontal',
ticks=[0, 0.01, 0.02, 0.03, 0.04])
patch = pl.fill(radec[:, 0],
radec[:, 1],
lw=0,
facecolor="#27ae60",
zorder=100)
superstamp_patches.append(patch)
text = pl.text(268.6,
-27.6,
'Microlensing\nsuperstamp',
color='#27ae60',
zorder=999,
fontsize=22,
va='center',
ha='left')
text.set_path_effects([
path_effects.Stroke(linewidth=4, foreground='white'),
path_effects.Normal()
])
"""
annotate_target(187.27789633, 2.05240632, "3C 273")
annotate_target(180.44154, -3.76128, "GW Vir", ha='right')
"""
# Mars was in the field when C9 started on April 21st
ra = [
264.32006, 266.32142, 268.32035, 270.31586, 272.30694, 274.29257,
276.27171, 278.24329, 280.20625, 282.15951
]
dec = [
-23.25199, -23.38232, -23.48986, -23.57480, -23.63741, -23.67799,
-23.69692, -23.69462, -23.67157, -23.62832
def plot_fixed_points(adata,
vecfld,
basis='X_umap',
marker="o",
markersize=200,
c='w',
cmap=None,
filltype=["full", "top", "none"],
background=None,
save_show_or_return="return",
save_kwargs={},
ax=None,
**kwargs):
"""Plot fixed points stored in the VectorField2D class.
Arguments
---------
vecfld: :class:`~vector_field`
An instance of the vector_field class.
basis: `str` (default: 'umap')
The basis on which the fixed points are ploted.
marker: `str` (default: `o`)
The marker type. Any string supported by matplotlib.markers.
markersize: `float` (default: 200)
The size of the marker.
cmap: string (optional, default 'Blues')
The name of a matplotlib colormap to use for coloring or shading the confidence of fixed points. If None, the
default color map will set to be viridis (inferno) when the background is white (black).
filltype: list
The fill type used for stable, saddle, and unstable fixed points. Default is 'full', 'top' and 'none',
respectively.
background: `str` or None (default: None)
The background color of the plot.
save_show_or_return: {'show', 'save', 'return'} (default: `return`)
Whether to save, show or return the figure.
save_kwargs: `dict` (default: `{}`)
A dictionary that will passed to the save_fig function. By default it is an empty dictionary and the save_fig function
will use the {"path": None, "prefix": 'plot_fixed_points', "dpi": None, "ext": 'pdf', "transparent": True, "close":
True, "verbose": True} as its parameters. Otherwise you can provide a dictionary that properly modify those keys
according to your needs.
ax: :class:`~matplotlib.axes.Axes`
The matplotlib axes used for plotting. Default is to use the current axis.
kwargs:
Key word arguments passed to the find_fixed_point function of the vector field class for high dimension fixed
point identification.
"""
import matplotlib
from matplotlib import rcParams, markers
import matplotlib.patheffects as PathEffects
from matplotlib.colors import to_hex
if background is None:
_background = rcParams.get("figure.facecolor")
_background = to_hex(
_background) if type(_background) is tuple else _background
else:
_background = background
if _background in ["#ffffff", "black"]:
_theme_ = "inferno"
else:
_theme_ = "viridis"
_cmap = _themes[_theme_]["cmap"] if cmap is None else cmap
Xss, ftype = vecfld.get_fixed_points(**kwargs)
if Xss.shape[1] > 2:
fp_ind = nearest_neighbors(Xss, vecfld.data['X'], 1).flatten()
# fix the bug when certain cells are filtered during the vector field learning
Xss = adata.obsm[basis][fp_ind]
if ax is None:
ax = plt.gca()
for i in range(len(Xss)):
cur_ftype = ftype[i]
marker_ = markers.MarkerStyle(marker=marker,
fillstyle=filltype[int(cur_ftype + 1)])
ax.scatter(
*Xss[i],
marker=marker_,
s=markersize,
c=c,
edgecolor=_select_font_color(_background),
linewidths=1,
cmap=_cmap,
vmin=0,
zorder=5,
)
txt = ax.text(
*Xss[i],
repr(i),
c=("black"
if cur_ftype == -1 else "blue" if cur_ftype == 0 else "red"),
horizontalalignment="center",
verticalalignment="center",
zorder=6,
weight="bold",
)
txt.set_path_effects([
PathEffects.Stroke(linewidth=1.5,
foreground=_background,
alpha=0.8),
PathEffects.Normal(),
])
if save_show_or_return == "save":
s_kwargs = {
"path": None,
"prefix": "plot_fixed_points",
"dpi": None,
"ext": "pdf",
"transparent": True,
"close": True,
"verbose": True,
}
s_kwargs = update_dict(s_kwargs, save_kwargs)
save_fig(**s_kwargs)
elif save_show_or_return == "show":
plt.tight_layout()
plt.show()
elif save_show_or_return == "return":
return ax
def _draw_outline(o, lw: int):
"Outline bounding box onto image `Patch`."
o.set_path_effects([
patheffects.Stroke(linewidth=lw, foreground='black'),
patheffects.Normal()
])
def draw_T_2m(T_2m=None,
map_extent=(50, 150, 0, 65),
regrid_shape=20,
add_china=True,
city=True,
south_China_sea=True,
output_dir=None,
Global=False):
# set font
plt.rcParams['font.sans-serif'] = ['SimHei'] # 步骤一（替换sans-serif字体）
plt.rcParams['axes.unicode_minus'] = False # 步骤二（解决坐标轴负数的负号显示问题）
# set figure
plt.figure(figsize=(16, 9))
if (Global == True):
plotcrs = ccrs.Robinson(central_longitude=115.)
else:
plotcrs = ccrs.AlbersEqualArea(
central_latitude=(map_extent[2] + map_extent[3]) / 2.,
central_longitude=(map_extent[0] + map_extent[1]) / 2.,
standard_parallels=[30., 60.])
ax = plt.axes([0.01, 0.1, .98, .84], projection=plotcrs)
datacrs = ccrs.PlateCarree()
map_extent2 = utl.adjust_map_ratio(ax,
map_extent=map_extent,
datacrs=datacrs)
# define return plots
plots = {}
if T_2m is not None:
x, y = np.meshgrid(T_2m['lon'], T_2m['lat'])
z = np.squeeze(T_2m['data'])
cmap = dk_ctables.cm_temp()
cmap.set_under(color=[0, 0, 0, 0], alpha=0.0)
plots['T_2m'] = ax.pcolormesh(x,
y,
z,
cmap=cmap,
zorder=1,
transform=datacrs,
alpha=0.5,
vmin=-45,
vmax=45)
z = gaussian_filter(z, 5)
plots['T_2m_zero'] = ax.contour(x,
y,
z,
levels=[0],
colors='#232B99',
linewidths=2,
transform=datacrs,
zorder=2)
cl_zero = plt.clabel(plots['T_2m_zero'],
inline=1,
fontsize=15,
fmt='%i',
colors='#232B99')
for t in cl_zero:
t.set_path_effects([
mpatheffects.Stroke(linewidth=3, foreground='white'),
mpatheffects.Normal()
])
plots['T_2m_35'] = ax.contour(x,
y,
z,
levels=[35, 37, 40],
colors=['#FF8F00', '#FF6200', '#FF0000'],
linewidths=2,
transform=datacrs,
zorder=2)
cl_35 = plt.clabel(plots['T_2m_35'],
inline=1,
fontsize=15,
fmt='%i',
colors='#FF0000')
for t in cl_35:
t.set_path_effects([
mpatheffects.Stroke(linewidth=3, foreground='white'),
mpatheffects.Normal()
])
plt.title('[' + T_2m.attrs['model'] + ']' + ' ' + T_2m.attrs['title'],
loc='left',
fontsize=30)
ax.add_feature(cfeature.OCEAN)
utl.add_china_map_2cartopy_public(ax,
name='coastline',
edgecolor='gray',
lw=0.8,
zorder=4,
alpha=0.5)
if add_china:
utl.add_china_map_2cartopy_public(ax,
name='province',
edgecolor='gray',
lw=0.5,
zorder=4)
utl.add_china_map_2cartopy_public(ax,
name='nation',
edgecolor='black',
lw=0.8,
zorder=4)
utl.add_china_map_2cartopy_public(ax,
name='river',
edgecolor='#74b9ff',
lw=0.8,
zorder=4,
alpha=0.5)
# grid lines
gl = ax.gridlines(crs=datacrs,
linewidth=2,
color='gray',
alpha=0.5,
linestyle='--',
zorder=5)
gl.xlocator = mpl.ticker.FixedLocator(np.arange(0, 360, 15))
gl.ylocator = mpl.ticker.FixedLocator(np.arange(-90, 90, 15))
utl.add_cartopy_background(ax, name='RD')
l, b, w, h = ax.get_position().bounds
#forecast information
bax = plt.axes([l, b + h - 0.1, .25, .1], facecolor='#FFFFFFCC')
bax.set_yticks([])
bax.set_xticks([])
bax.axis([0, 10, 0, 10])
initTime = pd.to_datetime(
str(T_2m.coords['forecast_reference_time'].values)).replace(
tzinfo=None).to_pydatetime()
fcst_time = initTime + timedelta(
hours=T_2m.coords['forecast_period'].values[0])
#发布时间
if (sys.platform[0:3] == 'lin'):
locale.setlocale(locale.LC_CTYPE, 'zh_CN.utf8')
if (sys.platform[0:3] == 'win'):
locale.setlocale(locale.LC_CTYPE, 'chinese')
plt.text(2.5, 7.5, '起报时间: ' + initTime.strftime("%Y年%m月%d日%H时"), size=15)
plt.text(2.5, 5, '预报时间: ' + fcst_time.strftime("%Y年%m月%d日%H时"), size=15)
plt.text(2.5,
2.5,
'预报时效: ' + str(int(T_2m.coords['forecast_period'].values[0])) +
'小时',
size=15)
plt.text(2.5, 0.5, 'www.nmc.cn', size=15)
# add color bar
if (T_2m != None):
cax = plt.axes([l, b - 0.04, w, .02])
cb = plt.colorbar(plots['T_2m'], cax=cax, orientation='horizontal')
cb.ax.tick_params(labelsize='x-large')
cb.set_label(u'°C', size=20)
# add south China sea
if south_China_sea:
utl.add_south_China_sea(pos=[l + w - 0.091, b, .1, .2])
small_city = False
#if(map_extent2[1]-map_extent2[0] < 25):
# small_city=True
#if city:
utl.add_city_and_number_on_map(ax,
data=T_2m,
map_extent=map_extent2,
transform=datacrs,
zorder=6,
size=13,
small_city=small_city)
utl.add_logo_extra_in_axes(pos=[l - 0.02, b + h - 0.1, .1, .1],
which='nmc',
size='Xlarge')
# show figure
if (output_dir != None):
plt.savefig(output_dir + '最低温度_预报_' + '起报时间_' +
initTime.strftime("%Y年%m月%d日%H时") + '预报时效_' +
str(T_2m.coords['forecast_period'].values[0]) + '小时' +
'.png',
dpi=200)
if (output_dir == None):
plt.show()
def my_own_quiver_function(axis,
X_pos,
Y_pos,
X_val,
Y_val,
plot_velocity_legend='False',
standard_vel=5,
limits=None,
Z_val=None):
global fontsize_global
if plot_velocity_legend == 'False' or plot_velocity_legend == False:
plot_velocity_legend = False
legend_text = ''
elif plot_velocity_legend == 'True' or plot_velocity_legend == True:
plot_velocity_legend = True
if standard_vel > 1.0:
legend_text = str(int(standard_vel)) + "kms$^{-1}$"
else:
legend_text = str(int(standard_vel * 10.) / 10.) + "kms$^{-1}$"
standard_vel = yt.units.km.in_units('cm').value * standard_vel
if limits is None:
xmin = np.min(X_pos)
xmax = np.max(X_pos)
ymin = np.min(Y_pos)
ymax = np.max(Y_pos)
else:
xmin = limits[0][0]
xmax = limits[0][1]
ymin = limits[1][0]
ymax = limits[1][1]
rv_colors = np.linspace(-1, 1, 256)
rv_cmap = plt.cm.get_cmap('bwr')
len_scale = standard_vel / (0.07 * (xmax - xmin))
vels = np.hypot(X_val, Y_val)
for xp in range(len(X_pos[0])):
for yp in range(len(Y_pos[0])):
xvel = X_val[xp][yp] / len_scale
yvel = Y_val[xp][yp] / len_scale
width_val = np.sqrt(X_val[xp][yp]**2. +
Y_val[xp][yp]**2.) / standard_vel
if width_val > 0.8:
width_val = 0.8
try:
if Z_val == None:
color = 'w'
except:
#cmap = 'idl06_r'
zvel = Z_val[xp][yp] / len_scale
cit = np.argmin(abs(rv_colors - zvel))
color = rv_cmap(cit)
axis.add_patch(
mpatches.FancyArrowPatch(
(X_pos[xp][yp], Y_pos[xp][yp]),
(X_pos[xp][yp] + xvel, Y_pos[xp][yp] + yvel),
color=color,
linewidth=1. * width_val,
arrowstyle='->',
mutation_scale=15. * width_val,
shrinkA=0.0,
shrinkB=0.0))
if plot_velocity_legend:
#print("plotting quiver legend")
pos_start = [xmax - 0.15 * (xmax - xmin), ymin + 0.07 * (ymax - ymin)]
xvel = standard_vel / len_scale
yvel = 0.0
width_val = 1.0
axis.add_patch(
mpatches.FancyArrowPatch(
(pos_start[0], pos_start[1]),
(pos_start[0] + xvel, pos_start[1] + yvel),
arrowstyle='->',
color='w',
linewidth=1. * width_val,
mutation_scale=15. * width_val))
annotate_text = axis.text((xmax - 0.01 * (xmax - xmin)),
(ymin + 0.03 * (ymax - ymin)),
legend_text,
va="center",
ha="right",
color='w',
fontsize=fontsize_global)
annotate_text.set_path_effects([
path_effects.Stroke(linewidth=3, foreground='black'),
path_effects.Normal()
])
return axis
def model_electrophysiological_fit(layer_fit, ax):
################# AESTHETICS
v4_color = 'black'
it_color = 'black'
n_layers = len(layer_fit['layers'])
v4 = layer_fit['v4']
it = layer_fit['it']
delta = layer_fit['delta']
alpha = .1
################## V4
plt.plot(v4['mu'],
color=v4_color,
linestyle='--',
linewidth=1,
alpha=1,
label='V4')
v4_min = v4['mu'] - (v4['std'] / np.sqrt(n_layers))
v4_max = v4['mu'] + (v4['std'] / np.sqrt(n_layers))
plt.fill_between(x=range(n_layers),
y1=v4_min,
y2=v4_max,
color=v4_color,
alpha=alpha,
edgecolor='')
annotate_fit_to_layer('v4', layer_fit)
################## IT
plt.plot(it['mu'],
color=it_color,
linestyle='-',
linewidth=1,
alpha=1,
label='IT')
it_min = it['mu'] - (it['std'] / np.sqrt(n_layers))
it_max = it['mu'] + (it['std'] / np.sqrt(n_layers))
plt.fill_between(x=range(n_layers),
y1=it_min,
y2=it_max,
color=it_color,
alpha=alpha,
edgecolor='')
annotate_fit_to_layer('it', layer_fit)
################ DELTA
import matplotlib.patheffects as pe
params = {
'solid_capstyle': 'round',
'linewidth': 5,
'zorder': 1,
}
plt.plot(
range(n_layers),
delta,
color='white',
label='$\Delta_{IT - V4}$',
path_effects=[pe.Stroke(linewidth=3, foreground='black'),
pe.Normal()],
)
plt.ylim(min(delta) - .1, max(v4['mu']) + .15)
################ LABELS
plt.yticks(size=6)
plt.ylabel('Cross-validated fit to Neural Data', labelpad=0, fontsize=11)
plt.xlabel("Model Layer", labelpad=5, fontsize=10)
plt.xticks(range(n_layers), layer_fit['layers'], rotation=90, fontsize=7)
plt.legend(framealpha=0, fontsize=9, title_fontsize=9, loc=4)
arrowprops=dict(arrowstyle="simple",
fc="#aaaaaa", ec="none",
connectionstyle="arc3,rad=0.0"),
)
annotate_target(127.578771, +22.235908, "K2-34")
annotate_target(126.61603759, +10.08037466, "HIP 41378")
# Plot the Beehive cluster
import pandas as pd
df = pd.read_csv('catalogs/beehive.csv')
for member in df.iterrows():
annotate_target(member[1].RA_d, member[1].DEC_d, "", size=10, color='#c0392b')
text = pl.text(130., 20.5, 'M44 (Beehive)', style='italic', color='black',
zorder=999, fontsize=30, va='center', ha='center')
text.set_path_effects([path_effects.Stroke(linewidth=4, foreground='white'),
path_effects.Normal()])
# Plot the M67 cluster
df = pd.read_csv('catalogs/m67.csv')
for member in df.iterrows():
annotate_target(member[1].RA_d, member[1].DEC_d, "", size=10, color='#c0392b')
text = pl.text(132.8250 - 0.6, +11.8000, 'M67', style='italic', color='black',
zorder=999, fontsize=30, va='center')
text.set_path_effects([path_effects.Stroke(linewidth=4, foreground='white'),
path_effects.Normal()])
# Plot the M67 cluster
#df = pd.read_csv('catalogs/stello-m67-paper.txt')
#for member in df.iterrows():
def plot_map_standard(proj,
point_locs,
df_t,
area='EU',
west=-9.5,
east=28,
south=35,
north=62,
fonts=14,
path=None,
SLP=False,
gust=False):
if path == None:
# set up the paths and test for existence
path = expanduser('~') + '/Documents/Metar_plots'
try:
os.listdir(path)
except FileNotFoundError:
os.mkdir(path)
else:
path = path
df = df_t.loc[(df_t['longitude'] >= west - 4)
& (df_t['longitude'] <= east + 4)
& (df_t['latitude'] <= north + 4) &
(df_t['latitude'] >= south - 4)]
plt.rcParams['savefig.dpi'] = 300
# =========================================================================
# Create the figure and an axes set to the projection.
fig = plt.figure(figsize=(20, 16))
ax = fig.add_subplot(1, 1, 1, projection=proj)
if area == 'Antarctica':
df = df.loc[df['latitude'] < north]
ax.set_extent([-180, 180, -90, -60], ccrs.PlateCarree())
theta = np.linspace(0, 2 * np.pi, 100)
center, radius = [0.5, 0.5], 0.5
verts = np.vstack([np.sin(theta), np.cos(theta)]).T
circle = mpath.Path(verts * radius + center)
ax.set_boundary(circle, transform=ax.transAxes)
elif area == 'Arctic':
df = df.loc[df['latitude'] > south]
ax.set_extent([-180, 180, 60, 90], ccrs.PlateCarree())
theta = np.linspace(0, 2 * np.pi, 100)
center, radius = [0.5, 0.5], 0.5
verts = np.vstack([np.sin(theta), np.cos(theta)]).T
circle = mpath.Path(verts * radius + center)
ax.set_boundary(circle, transform=ax.transAxes)
else:
ax.set_extent((west, east, south, north))
# Get the wind components, converting from m/s to knots as will
# be appropriate for the station plot.
df['dd'][df['dd'] > 360] = np.nan
u, v = wind_components(df['ff'].values * units('knots'),
df['dd'].values * units('deg'))
cloud_frac = df['cloud_cover']
# Change the DPI of the resulting figure. Higher DPI drastically improves
# look of the text rendering.
# Set up a cartopy feature for state borders.
# state_boundaries = feat.NaturalEarthFeature(category='cultural',
# name='admin_0_countries',
# scale='10m',
# facecolor='#d8dcd6',
# alpha=0.5)
# ax.coastlines(resolution='10m', zorder=0, color='black')
# ax.add_feature(feat.LAND)
ax.add_feature(feat.COASTLINE.with_scale('10m'),
zorder=2,
edgecolor='black')
ax.add_feature(feat.OCEAN.with_scale('50m'), zorder=0)
ax.add_feature(feat.STATES.with_scale('10m'),
zorder=1,
facecolor='white',
edgecolor='#5e819d')
# ax.add_feature(cartopy.feature.OCEAN, zorder=0)
# Set plot bounds
# Start the station plot by specifying the axes to draw on, as well as the
# lon/lat of the stations (with transform). We also the fontsize to 12 pt.
stationplot = StationPlot(ax,
df['longitude'].values,
df['latitude'].values,
clip_on=True,
transform=ccrs.PlateCarree(),
fontsize=fonts)
# Plot the temperature and dew point to the upper and lower left,
# respectively, of the center point. Each one uses a different color.
Temp = stationplot.plot_parameter('NW',
df['TT'],
color='#fd3c06',
fontweight='bold',
zorder=3)
Td = stationplot.plot_parameter('SW', df['TD'], color='#01ff07')
if gust == True:
maxff = stationplot.plot_parameter('SE',
df['max_gust'],
color='#cb416b',
fontweight='bold',
zorder=3)
maxff.set_path_effects([
path_effects.Stroke(linewidth=1.5, foreground='black'),
path_effects.Normal()
])
# fontweight = 'bold'
# More complex ex. uses custom formatter to control how sea-level pressure
# values are plotted. This uses the standard trailing 3-digits of
# the pressure value in tenths of millibars.
if (area != 'Antarctica' and area != 'Arctic'):
p = stationplot.plot_parameter(
'NE',
df['SLP'],
formatter=lambda v: format(10 * v, '.0f')[-3:],
color="#a2cffe")
for x in [Temp, Td, p]:
x.set_path_effects([
path_effects.Stroke(linewidth=1.5, foreground='black'),
path_effects.Normal()
])
else:
for x in [Temp, Td]:
x.set_path_effects([
path_effects.Stroke(linewidth=1.5, foreground='black'),
path_effects.Normal()
])
# Add wind barbs
stationplot.plot_barb(u, v, zorder=3, linewidth=2)
# Plot the cloud cover symbols in the center location. This uses the codes
# made above and uses the `sky_cover` mapper to convert these values to
# font codes for the weather symbol font.
stationplot.plot_symbol('C', cloud_frac, sky_cover)
# Same this time, but plot current weather to the left of center, using the
# `current_weather` mapper to convert symbols to the right glyphs.
for val in range(0, 2):
wx = df[['ww', 'StationType']]
if val == 0:
# mask all the unmanned stations
wx['ww'].loc[wx['StationType'] > 3] = np.nan
wx2 = wx['ww'].fillna(00).astype(int).values.tolist()
stationplot.plot_symbol('W', wx2, current_weather, zorder=4)
else:
# mask all the manned stations
wx['ww'].loc[(wx['StationType'] <= 3)] = np.nan
# mask all reports smaller than 9
# =7 is an empty symbol!
wx['ww'].loc[wx['ww'] <= 9] = 7
wx2 = wx['ww'].fillna(7).astype(int).values.tolist()
stationplot.plot_symbol('W', wx2, current_weather_auto, zorder=4)
if SLP == True:
lon = df['longitude'].loc[(df.PressureDefId == 'mean sea level')
& (df.Hp <= 750)].values
lat = df['latitude'].loc[(df.PressureDefId == 'mean sea level')
& (df.Hp <= 750)].values
xp, yp, _ = proj.transform_points(ccrs.PlateCarree(), lon, lat).T
sea_levelp = df['SLP'].loc[(df.PressureDefId == 'mean sea level')
& (df.Hp <= 750)]
x_masked, y_masked, pres = remove_nan_observations(
xp, yp, sea_levelp.values)
slpgridx, slpgridy, slp = interpolate_to_grid(x_masked,
y_masked,
pres,
interp_type='cressman',
search_radius=400000,
rbf_func='quintic',
minimum_neighbors=1,
hres=100000,
rbf_smooth=100000)
Splot_main = ax.contour(slpgridx,
slpgridy,
slp,
colors='k',
linewidths=2,
extent=(west, east, south, north),
levels=list(range(950, 1050, 10)))
plt.clabel(Splot_main, inline=1, fontsize=12, fmt='%i')
Splot = ax.contour(slpgridx,
slpgridy,
slp,
colors='k',
linewidths=1,
linestyles='--',
extent=(west, east, south, north),
levels=[
x for x in range(950, 1050, 1)
if x not in list(range(950, 1050, 10))
])
plt.clabel(Splot, inline=1, fontsize=10, fmt='%i')
# stationplot.plot_text((2, 0), df['Station'])
# Also plot the actual text of the station id. Instead of cardinal
# directions, plot further out by specifying a location of 2 increments
# in x and 0 in y.stationplot.plot_text((2, 0), df['station'])
if (area == 'Antarctica' or area == 'Arctic'):
plt.savefig(path + '/CURR_SYNOP_' + area + '.png',
bbox_inches='tight',
pad_inches=0)
else:
plt.savefig(path + '/CURR_SYNOP_' + area + '.png',
bbox_inches='tight',
transparent="True",
pad_inches=0)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import matplotlib
matplotlib.rcParams['toolbar'] = 'None'
import matplotlib.pyplot as plt
from matplotlib.path import Path
import matplotlib.patches as patches
import matplotlib.patheffects as PathEffects
verts = [(45, 96), (262, 130), (268, 66), (33, 191)]
codes = [Path.MOVETO, Path.CURVE4, Path.CURVE4, Path.CURVE4]
size = 256, 256
dpi = 72.0
figsize = size[0] / float(dpi), size[1] / float(dpi)
fig = plt.figure(figsize=figsize, dpi=dpi, facecolor="white")
axes = fig.add_axes([0.0, 0.0, 1.0, 1.0], frameon=False)
axes.set_xlim(0, size[0])
axes.set_ylim(0, size[1])
path = Path(verts, codes)
patch = patches.PathPatch(path, facecolor='none', lw=50, alpha=0.5)
patch.set_path_effects([PathEffects.Stroke(capstyle='round')])
axes.add_patch(patch)
plt.xticks([]), plt.yticks([])
fig.savefig('agg-bezier-2.png', dpi=dpi)
plt.show()
x_contour[0],
y_contour[0],
label=promoter,
linewidth=1.0,
c=cmap(
col_norm(df_energies[df_energies.Name == promoter]
["Energy (kT)"].values[0])),
)
text = ax_c.annotate(f"{i + 1}", (
np.mean(x_contour[0]),
np.mean(y_contour),
),
fontsize=7,
color="white")
text.set_path_effects([
path_effects.Stroke(linewidth=1.5, foreground="black"),
path_effects.Normal()
])
ax_c.set_xlim(right=1.2e1)
ax_c.set_ylim(top=1e1)
ax_c.set_ylabel(r'$k_i$ (bursts per mRNA lifetime)')
ax_c.set_xlabel(r'$b$ (transcripts per burst)')
# (D)
# Add gridlines
[ax_d.axhline(x, color="white", linewidth=0.5) for x in [0.1, 1]]
# initialize lsit to save y position
y_pos = list()
for i, promoter in enumerate(df_energies.Name):
if len(fixation_intervals) > 0:
avg_times.append(tmid)
avg_dts.append(numpy.median(fixation_intervals))
upper_dts.append(
numpy.percentile(fixation_intervals, 75, interpolation='nearest'))
lower_dts.append(
numpy.percentile(fixation_intervals, 25, interpolation='nearest'))
fixation_time_axis.plot(
avg_times,
avg_dts,
'w-',
linewidth=1,
path_effects=[pe.Stroke(linewidth=2.5, foreground='k'),
pe.Normal()])
fixation_time_axis.fill_between(avg_times, lower_dts, upper_dts, color='0.8')
fixation_time_axis.plot(avg_times, lower_dts, 'k-', linewidth=0.25)
fixation_time_axis.plot(avg_times, upper_dts, 'k-', linewidth=0.25)
######
#
# Now do fixation trajectories
#
########
theory_times = numpy.arange(0, 121) * 500
total_Mfixeds = numpy.zeros_like(theory_times) * 1.0
def movie(self, scale='linear', text=False, **kwargs):
'''Create a movie of a populated array'''
log.debug('Creating movie')
start = time.time()
# If there's not a lot of movement the movie should be fixed
fig = plt.figure(figsize=(4, 4))
ax = fig.add_subplot(111)
plt.subplots_adjust(hspace=0, wspace=0)
ax.set_facecolor('red')
dat = (self.ar)
if scale == 'log':
dat = np.log10(self.ar)
if 'vmin' not in kwargs:
# Calculate color stretch...
y = dat.ravel()
y = y[np.isfinite(y)]
y = y[y != 0]
kwargs['vmin'] = np.percentile(y, 10)
kwargs['vmax'] = np.percentile(y, 90)
im = ax.imshow(dat[:, :, 0].T, **kwargs)
ax.axis('off')
if text:
if self.name is not None:
text1 = ax.text(0.1,
0.9,
self.name,
fontsize=10,
color='white',
transform=ax.transAxes)
text1.set_path_effects([
path_effects.Stroke(linewidth=2, foreground='black'),
path_effects.Normal()
])
text2 = ax.text(0.1,
0.83,
'Campaign {}'.format(self.campaign),
fontsize=8,
color='white',
transform=ax.transAxes)
text2.set_path_effects([
path_effects.Stroke(linewidth=2, foreground='black'),
path_effects.Normal()
])
text3 = ax.text(0.1,
0.78,
'Cadence: {}'.format(int(self.cadence_names[0])),
fontsize=8,
color='white',
transform=ax.transAxes)
text3.set_path_effects([
path_effects.Stroke(linewidth=2, foreground='black'),
path_effects.Normal()
])
def animate(i):
im.set_array(dat[:, :, i].T)
if text:
text3.set_text('Cadence: {}'.format(int(
self.cadence_names[i])))
return im, text3,
return im,
anim = animation.FuncAnimation(fig,
animate,
frames=len(self.cadence_names),
interval=30,
blit=True)
anim.save(self.output, dpi=150)
log.debug('Saved. ({0:0.2g}s)'.format(time.time() - start))
plt.close()
cf = iplt.pcolormesh(scs, axes=axgr[0], cmap=gustcmap, norm=norm)
iplt.pcolormesh(vscs, axes=axgr[1], cmap=gustcmap, norm=norm)
iplt.pcolormesh(sscs, axes=axgr[2], cmap=gustcmap, norm=norm)
# Plot place labels
for ax in axgr:
ax.plot(pop['LONGITUDE'].values,
pop['LATITUDE'].values,
marker='o',
fillstyle='none',
markersize=5,
linestyle='none',
color='black',
path_effects=[
path_effects.Stroke(linewidth=2, foreground='white'),
path_effects.Normal()
])
geodetic_transform = ccrs.PlateCarree()._as_mpl_transform(ax)
for i, row, in pop.iterrows():
if row['NAMEASCII'] in ['Dhaka', 'Saidpur', 'Jamalpur']:
text = ax.text(row['LONGITUDE'],
row['LATITUDE'],
row['NAMEASCII'],
ha='right',
fontsize=8,
transform=offset_copy(geodetic_transform,
units='dots',
x=-4,
y=4))
text.set_path_effects([
def __init__(
self,
line: Line2D,
x: Position,
label: str | None = None,
align: bool = True,
yoffset: float = 0,
yoffset_logspace: bool = False,
outline_color: AutoLiteral | ColorLike | None = "auto",
outline_width: float = 8,
**kwargs,
) -> None:
"""
Parameters
----------
line : Line2D
Line to be decorated.
x : Position
Horizontal target position for the label (in data units).
label : str, optional
Override for line label, by default None.
align : bool, optional
If true, the label is parallel to the line, otherwise horizontal,
by default True.
yoffset : float, optional
An additional y offset for the line label, by default 0.
yoffset_logspace : bool, optional
If true yoffset is applied exponentially to appear linear on a log-axis,
by default False.
outline_color : None | "auto" | Colorlike
Colour of the outline. If set to "auto", use the background color.
If set to None, do not draw an outline, by default "auto".
outline_width : float
Width of the outline, by default 8.
"""
self._line = line
self._target_x = x
self._ax = line.axes
self._auto_align = align
self._yoffset = yoffset
self._yoffset_logspace = yoffset_logspace
label = label or line.get_label()
# Populate self._pos, self._anchor_a, self._anchor_b
self._update_anchors()
# Set a bunch of default arguments
kwargs.setdefault("color", self._line.get_color())
kwargs.setdefault("clip_on", True)
kwargs.setdefault("zorder", 2.5)
if "ha" not in kwargs:
kwargs.setdefault("horizontalalignment", "center")
if "va" not in kwargs:
kwargs.setdefault("verticalalignment", "center")
# Initialize Text Artist
super().__init__(
*self._label_pos,
label,
rotation=self._rotation,
rotation_mode="anchor",
**kwargs,
)
# Apply outline effect
if outline_color is not None:
if outline_color == "auto":
outline_color = line.axes.get_facecolor()
self.set_path_effects([
patheffects.Stroke(linewidth=outline_width,
foreground=outline_color),
patheffects.Normal(),
])
# activate clipping if needed and place on axes
if kwargs["clip_on"]:
self.set_clip_path(self._ax.patch)
self._ax._add_text(self)
#-*- coding: utf-8 -*
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patheffects as path_effects
import seaborn as sns
x = [3.5, 9.2, 11.7, 24.1, 49.1]
y = [
u"Nuestra\nImplementación", u"HomographyNet\n(Regresión)",
u"ORB\n+\nRANSAC", u"HomographyNet\n(Clasificación)",
u"Homografía\nIdentidad"
]
ax = sns.barplot(y, x, palette="Blues")
ax.set(ylabel="Mean Average Corner Error\n(pixels)")
for i, rect in enumerate(ax.patches):
txt = ax.text(rect.get_x() + rect.get_width() / 2.0 -
len(str(x[i])) * 0.05,
rect.get_height() - 2.75 - rect.get_height() * 0.05,
x[i],
fontsize=20,
color='white')
txt.set_path_effects([
path_effects.Stroke(linewidth=2, foreground="gray"),
path_effects.Normal()
])
plt.xticks(rotation=30)
plt.tight_layout()
plt.show()
def _render_on_subplot(self, subplot):
r"""
Render this arrow in a subplot. This is the key function that
defines how this arrow graphics primitive is rendered in
matplotlib's library.
EXAMPLES:
This function implicitly ends up rendering this arrow on
a matplotlib subplot::
sage: arrow((0,1), (2,-1))
Graphics object consisting of 1 graphics primitive
TESTS:
The length of the ends (shrinkA and shrinkB) should not depend
on the width of the arrow, because Matplotlib already takes
this into account. See :trac:`12836`::
sage: fig = Graphics().matplotlib()
sage: sp = fig.add_subplot(1,1,1)
sage: a = arrow((0,0), (1,1))
sage: b = arrow((0,0), (1,1), width=20)
sage: p1 = a[0]._render_on_subplot(sp)
sage: p2 = b[0]._render_on_subplot(sp)
sage: p1.shrinkA == p2.shrinkA
True
sage: p1.shrinkB == p2.shrinkB
True
Dashed arrows should have solid arrowheads,
:trac:`12852`. This test saves the plot of a dashed arrow to
an EPS file. Within the EPS file, ``stroke`` will be called
twice: once to draw the line, and again to draw the
arrowhead. We check that both calls do not occur while the
dashed line style is enabled::
sage: a = arrow((0,0), (1,1), linestyle='dashed')
sage: filename = tmp_filename(ext='.eps')
sage: a.save(filename=filename)
sage: with open(filename, 'r') as f:
....: contents = f.read().replace('\n', ' ')
sage: two_stroke_pattern = r'setdash.*stroke.*stroke.*setdash'
sage: import re
sage: two_stroke_re = re.compile(two_stroke_pattern)
sage: two_stroke_re.search(contents) is None
True
"""
from sage.plot.misc import get_matplotlib_linestyle
options = self.options()
head = options.pop('head')
if head == 0: style = '<|-'
elif head == 1: style = '-|>'
elif head == 2: style = '<|-|>'
else:
raise KeyError(
'head parameter must be one of 0 (start), 1 (end) or 2 (both).'
)
width = float(options['width'])
arrowshorten_end = float(options.get('arrowshorten', 0)) / 2.0
arrowsize = float(options.get('arrowsize', 5))
head_width = arrowsize
head_length = arrowsize * 2.0
color = to_mpl_color(options['rgbcolor'])
from matplotlib.patches import FancyArrowPatch
p = FancyArrowPatch((self.xtail, self.ytail), (self.xhead, self.yhead),
lw=width,
arrowstyle='%s,head_width=%s,head_length=%s' %
(style, head_width, head_length),
shrinkA=arrowshorten_end,
shrinkB=arrowshorten_end,
fc=color,
ec=color)
p.set_linestyle(
get_matplotlib_linestyle(options['linestyle'], return_type='long'))
p.set_zorder(options['zorder'])
p.set_label(options['legend_label'])
if options['linestyle'] != 'solid':
# The next few lines work around a design issue in matplotlib. Currently, the specified
# linestyle is used to draw both the path and the arrowhead. If linestyle is 'dashed', this
# looks really odd. This code is from Jae-Joon Lee in response to a post to the matplotlib mailing
# list. See http://sourceforge.net/mailarchive/forum.php?thread_name=CAG%3DuJ%2Bnw2dE05P9TOXTz_zp-mGP3cY801vMH7yt6vgP9_WzU8w%40mail.gmail.com&forum_name=matplotlib-users
import matplotlib.patheffects as pe
class CheckNthSubPath(object):
def __init__(self, patch, n):
"""
creates an callable object that returns True if the provided
path is the n-th path from the patch.
"""
self._patch = patch
self._n = n
def get_paths(self, renderer):
self._patch.set_dpi_cor(renderer.points_to_pixels(1.))
paths, fillables = self._patch.get_path_in_displaycoord()
return paths
def __call__(self, renderer, gc, tpath, affine, rgbFace):
path = self.get_paths(renderer)[self._n]
vert1, code1 = path.vertices, path.codes
import numpy as np
if np.all(vert1 == tpath.vertices) and np.all(
code1 == tpath.codes):
return True
else:
return False
class ConditionalStroke(pe.RendererBase):
def __init__(self, condition_func, pe_list):
"""
path effect that is only applied when the condition_func
returns True.
"""
super(ConditionalStroke, self).__init__()
self._pe_list = pe_list
self._condition_func = condition_func
def draw_path(self, renderer, gc, tpath, affine, rgbFace):
if self._condition_func(renderer, gc, tpath, affine,
rgbFace):
for pe1 in self._pe_list:
pe1.draw_path(renderer, gc, tpath, affine, rgbFace)
pe1 = ConditionalStroke(CheckNthSubPath(p, 0), [pe.Stroke()])
pe2 = ConditionalStroke(CheckNthSubPath(p, 1),
[pe.Stroke(linestyle="solid")])
p.set_path_effects([pe1, pe2])
subplot.add_patch(p)
return p
def draw_mslp_gust10m_uv10m(gust=None,
mslp=None,
uv10m=None,
map_extent=(50, 150, 0, 65),
regrid_shape=20,
add_china=True,
city=True,
south_China_sea=True,
output_dir=None,
Global=False):
# set font
plt.rcParams['font.sans-serif'] = ['SimHei'] # 步骤一（替换sans-serif字体）
plt.rcParams['axes.unicode_minus'] = False # 步骤二（解决坐标轴负数的负号显示问题）
# set figure
plt.figure(figsize=(16, 9))
if (Global == True):
plotcrs = ccrs.Robinson(central_longitude=115.)
else:
plotcrs = ccrs.AlbersEqualArea(
central_latitude=(map_extent[2] + map_extent[3]) / 2.,
central_longitude=(map_extent[0] + map_extent[1]) / 2.,
standard_parallels=[30., 60.])
datacrs = ccrs.PlateCarree()
ax = plt.axes([0.01, 0.1, .98, .84], projection=plotcrs)
map_extent2 = utl.adjust_map_ratio(ax,
map_extent=map_extent,
datacrs=datacrs)
#draw data
plots = {}
if gust is not None:
x, y = np.meshgrid(gust['lon'], gust['lat'])
z = np.squeeze(gust['data'].values)
cmap = dk_ctables.cm_wind_speed_nws()
cmap.set_under(color=[0, 0, 0, 0], alpha=0.0)
z[z < 7.9] = np.nan
plots['gust'] = ax.pcolormesh(x,
y,
z,
cmap=cmap,
vmin=7.9,
vmax=65,
zorder=1,
transform=datacrs,
alpha=0.5)
ax.quiver(x,
y,
np.squeeze(uv10m['u10m'].values),
np.squeeze(uv10m['v10m'].values),
transform=datacrs,
regrid_shape=40,
width=0.001)
if mslp is not None:
x, y = np.meshgrid(mslp['lon'], mslp['lat'])
clevs_mslp = np.arange(900, 1100, 2.5)
z = gaussian_filter(np.squeeze(mslp['data']), 5)
plots['mslp'] = ax.contour(x,
y,
z,
clevs_mslp,
colors='black',
linewidths=1,
transform=datacrs,
zorder=2,
alpha=0.5)
cl = plt.clabel(plots['mslp'],
inline=1,
fontsize=15,
fmt='%.1f',
colors='black')
for t in cl:
t.set_path_effects([
mpatheffects.Stroke(linewidth=3, foreground='white'),
mpatheffects.Normal()
])
#additional information
plt.title('[' + mslp.attrs['model'] + '] ' + '海平面气压, ' + '逐' +
'%i' % gust.attrs['t_gap'] + '小时10米最大阵风和10米平均风',
loc='left',
fontsize=30)
utl.add_china_map_2cartopy_public(ax,
name='coastline',
edgecolor='gray',
lw=0.8,
zorder=3,
alpha=0.5)
if add_china:
utl.add_china_map_2cartopy_public(ax,
name='province',
edgecolor='gray',
lw=0.5,
zorder=3)
utl.add_china_map_2cartopy_public(ax,
name='nation',
edgecolor='black',
lw=0.8,
zorder=3)
utl.add_china_map_2cartopy_public(ax,
name='river',
edgecolor='#74b9ff',
lw=0.8,
zorder=3,
alpha=0.5)
# grid lines
gl = ax.gridlines(crs=datacrs,
linewidth=2,
color='gray',
alpha=0.5,
linestyle='--',
zorder=4)
gl.xlocator = mpl.ticker.FixedLocator(np.arange(0, 360, 15))
gl.ylocator = mpl.ticker.FixedLocator(np.arange(-90, 90, 15))
#utl.add_cartopy_background(ax,name='RD')
ax.add_feature(cfeature.LAND, color='#F5E19F')
ax.add_feature(cfeature.OCEAN)
l, b, w, h = ax.get_position().bounds
#forecast information
bax = plt.axes([l, b + h - 0.1, .25, .1], facecolor='#FFFFFFCC')
bax.set_yticks([])
bax.set_xticks([])
bax.axis([0, 10, 0, 10])
initTime = pd.to_datetime(
str(mslp.coords['forecast_reference_time'].values)).replace(
tzinfo=None).to_pydatetime()
fcst_time = initTime + timedelta(
hours=mslp.coords['forecast_period'].values[0])
#发布时间
if (sys.platform[0:3] == 'lin'):
locale.setlocale(locale.LC_CTYPE, 'zh_CN.utf8')
if (sys.platform[0:3] == 'win'):
locale.setlocale(locale.LC_CTYPE, 'chinese')
plt.text(2.5, 7.5, '起报时间: ' + initTime.strftime("%Y年%m月%d日%H时"), size=15)
plt.text(2.5, 5, '预报时间: ' + fcst_time.strftime("%Y年%m月%d日%H时"), size=15)
plt.text(2.5,
2.5,
'预报时效: ' + str(int(mslp.coords['forecast_period'].values[0])) +
'小时',
size=15)
plt.text(2.5, 0.5, 'www.nmc.cn', size=15)
# add color bar
if (gust != None):
cax = plt.axes([l, b - 0.04, w, .02])
cb = plt.colorbar(plots['gust'],
cax=cax,
orientation='horizontal',
extend='max',
ticks=[
8.0, 10.8, 13.9, 17.2, 20.8, 24.5, 28.5, 32.7,
37, 41.5, 46.2, 51.0, 56.1, 61.3
])
cb.ax.tick_params(labelsize='x-large')
cb.set_label('风速 (m/s)', size=20)
# add south China sea
if south_China_sea:
utl.add_south_China_sea(pos=[l + w - 0.091, b, .1, .2])
small_city = False
if (map_extent2[1] - map_extent2[0] < 25):
small_city = True
if city:
utl.add_city_on_map(ax,
map_extent=map_extent2,
transform=datacrs,
zorder=5,
size=13,
small_city=small_city)
utl.add_logo_extra_in_axes(pos=[l - 0.02, b + h - 0.1, .1, .1],
which='nmc',
size='Xlarge')
# show figure
if (output_dir != None):
plt.savefig(output_dir + '海平面气压_逐6小时最大风速_预报_' + '起报时间_' +
initTime.strftime("%Y年%m月%d日%H时") + '预报时效_' +
str(mslp.coords['forecast_period'].values[0]) + '小时' +
'.png',
dpi=200)
if (output_dir == None):
plt.show()
def plot_animation(clip,
parents,
filename=None,
fps=30,
axis_scale=50,
elev=45,
azim=45):
rot = R.from_quat([0, 0, 0, 1])
translation = np.array([[0, 0, 0]])
translations = np.zeros((clip.shape[0], 3))
joints, root_dx, root_dz, root_dr = clip[:, :
-3], clip[:,
-3], clip[:,
-2], clip[:,
-1]
joints = joints.reshape((len(joints), -1, 3))
for i in range(len(joints)):
joints[i, :, :] = rot.apply(joints[i])
joints[i, :, 0] = joints[i, :, 0] + translation[0, 0]
joints[i, :, 2] = joints[i, :, 2] + translation[0, 2]
rot = R.from_rotvec(np.array([0, -root_dr[i], 0])) * rot
translation = translation + rot.apply(
np.array([root_dx[i], 0, root_dz[i]]))
translations[i, :] = translation
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim3d(-axis_scale, axis_scale)
ax.set_zlim3d(0, axis_scale)
ax.set_ylim3d(-axis_scale, axis_scale)
ax.grid(True)
ax.set_axis_off()
ax.view_init(elev=elev, azim=azim)
xs = np.linspace(-200, 200, 50)
ys = np.linspace(-200, 200, 50)
X, Y = np.meshgrid(xs, ys)
Z = np.zeros(X.shape)
wframe = ax.plot_wireframe(X,
Y,
Z,
rstride=2,
cstride=2,
color='grey',
lw=0.2)
points = []
lines = []
acolors = list(sorted(colors.cnames.keys()))[::-1]
tmp = np.zeros(translations.shape)
lines.append(
plt.plot(translations[:, 0],
-translations[:, 2],
lw=2,
path_effects=[
pe.Stroke(linewidth=1, foreground='black'),
pe.Normal()
])[0])
lines.append([
plt.plot([0, 0], [0, 0], [0, 0],
color='red',
lw=2,
path_effects=[
pe.Stroke(linewidth=3, foreground='black'),
pe.Normal()
])[0] for _ in range(joints.shape[1])
])
def animate(i):
changed = []
for j in range(len(parents)):
if parents[j] != -1:
lines[1][j].set_data(
np.array([[joints[i, j, 0], joints[i, parents[j], 0]],
[-joints[i, j, 2], -joints[i, parents[j], 2]]]))
lines[1][j].set_3d_properties(
np.array([joints[i, j, 1], joints[i, parents[j], 1]]))
changed += lines
return changed
plt.tight_layout()
ani = animation.FuncAnimation(fig,
animate,
np.arange(joints.shape[0]),
interval=1000 / fps)
if filename != None:
ani.save(filename, fps=fps, bitrate=13934)
ani.event_source.stop()
del ani
plt.close()
try:
plt.show()
plt.save()
except AttributeError as e:
pass
def draw(self):
# In order to speed up the plotting, we only recalculate everything
# if necessary.
self.IntRegionLines = []
# Figure out the color and ylabel
# Choose the particle type and px, py, or pz
self.UpdateLabelsandColors()
self.xmin = self.hist2d[2][0]
self.xmax = self.hist2d[2][-1]
self.ymin = self.hist2d[1][0]
self.ymax = self.hist2d[1][-1]
if self.GetPlotParam('masked'):
self.tick_color = 'k'
else:
self.tick_color = 'white'
self.clim = list(self.hist2d[3])
if self.GetPlotParam('set_v_min'):
self.clim[0] = 10**self.GetPlotParam('v_min')
if self.GetPlotParam('set_v_max'):
self.clim[1] = 10**self.GetPlotParam('v_max')
self.gs = gridspec.GridSpecFromSubplotSpec(
100, 100, subplot_spec=self.parent.gs0[
self.pos]) #, bottom=0.2,left=0.1,right=0.95, top = 0.95)
self.axes = self.figure.add_subplot(
self.gs[self.parent.axes_extent[0]:self.parent.axes_extent[1],
self.parent.axes_extent[2]:self.parent.axes_extent[3]])
self.cax = self.axes.imshow(
self.hist2d[0],
cmap=new_cmaps.cmaps[self.parent.MainParamDict['ColorMap']],
norm=self.norm(),
origin='lower',
aspect='auto',
interpolation=self.GetPlotParam('interpolation'))
self.cax.set_extent([self.xmin, self.xmax, self.ymin, self.ymax])
self.cax.set_clim(self.clim)
self.shock_line = self.axes.axvline(self.parent.shock_loc,
linewidth=1.5,
linestyle='--',
color=self.parent.shock_color,
path_effects=[
PathEffects.Stroke(
linewidth=2,
foreground='k'),
PathEffects.Normal()
])
if not self.GetPlotParam('show_shock'):
self.shock_line.set_visible(False)
self.axC = self.figure.add_subplot(
self.gs[self.parent.cbar_extent[0]:self.parent.cbar_extent[1],
self.parent.cbar_extent[2]:self.parent.cbar_extent[3]])
# Technically I should use the colorbar class here,
# but I found it annoying in some of it's limitations.
if self.parent.MainParamDict['HorizontalCbars']:
self.cbar = self.axC.imshow(
self.gradient,
aspect='auto',
cmap=new_cmaps.cmaps[self.parent.MainParamDict['ColorMap']])
# Make the colobar axis more like the real colorbar
self.axC.tick_params(
axis='x',
which='both', # bothe major and minor ticks
top=False, # turn off top ticks
labelsize=self.parent.MainParamDict['NumFontSize'])
self.axC.tick_params(
axis='y', # changes apply to the y-axis
which='both', # both major and minor ticks are affected
left=False, # ticks along the bottom edge are off
right=False, # ticks along the top edge are off
labelleft=False)
else:
self.cbar = self.axC.imshow(
np.transpose(self.gradient)[::-1],
aspect='auto',
origin='upper',
cmap=new_cmaps.cmaps[self.parent.MainParamDict['ColorMap']])
# Make the colobar axis more like the real colorbar
self.axC.tick_params(
axis='x',
which='both', # bothe major and minor ticks
top=False, # turn off top ticks
bottom=False,
labelbottom=False,
labelsize=self.parent.MainParamDict['NumFontSize'])
self.axC.tick_params(
axis='y', # changes apply to the y-axis
which='both', # both major and minor ticks are affected
left=False, # ticks along the bottom edge are off
right=True, # ticks along the top edge are off
labelleft=False,
labelright=True,
labelsize=self.parent.MainParamDict['NumFontSize'])
self.cbar.set_extent([0, 1.0, 0, 1.0])
if not self.GetPlotParam('show_cbar'):
self.axC.set_visible(False)
if int(matplotlib.__version__[0]) < 2:
self.axes.set_axis_bgcolor(self.GetPlotParam('face_color'))
else:
self.axes.set_facecolor(self.GetPlotParam('face_color'))
self.axes.tick_params(
labelsize=self.parent.MainParamDict['NumFontSize'],
color=self.tick_color)
self.axes.set_xlabel(self.x_label,
labelpad=self.parent.MainParamDict['xLabelPad'],
color='black',
size=self.parent.MainParamDict['AxLabelSize'])
self.axes.set_ylabel(self.y_label,
labelpad=self.parent.MainParamDict['yLabelPad'],
color='black',
size=self.parent.MainParamDict['AxLabelSize'])
self.refresh()
##############################################################################
## affichage de la localisation des déviation en fonction des composants
std = np.sqrt(pca.explained_variance_)
##############################################################################
# plot the mean and the different axes of the PCA
ax1.plot(
fCDF,
pca.mean_,
c='C0',
label='Mean',
linewidth=2,
zorder=10,
path_effects=[pe.Stroke(linewidth=4, foreground='w'),
pe.Normal()])
# Transform the axes points into curves
y = pca.inverse_transform([std[0], 0])
ax1.plot(
fCDF,
y,
'g',
label='1st component [+std]',
linewidth=2,
zorder=10,
path_effects=[pe.Stroke(linewidth=4, foreground='w'),
pe.Normal()])
y = pca.inverse_transform([-std[0], 0])
ax1.plot(
fCDF,
num = len(labels)
names = dict()
for i in range(10):
names[i] = str(i)
palette = np.array(sns.color_palette("hls", 10))
f = plt.figure(figsize=(8, 8))
ax = plt.subplot(aspect='equal')
sc = ax.scatter(embeds[:, 0],
embeds[:, 1],
lw=0,
s=40,
c=palette[labels.astype(np.int)])
ax.axis('off')
ax.axis('tight')
# We add the labels for each digit.
txts = []
for i in range(10):
# Position of each label.
xtext, ytext = np.median(embeds[labels == i, :], axis=0)
txt = ax.text(xtext, ytext, names[i])
txt.set_path_effects([
PathEffects.Stroke(linewidth=5, foreground="w"),
PathEffects.Normal()
])
txts.append(txt)
fname = 'mnist-sphereface-%d-epoch.png' % (epoch)
plt.savefig(fname)
ax2.xaxis.set_major_formatter(date_format_bf)
# plt.axhline(y=freq[stria_floc], color='r')
# plt.axvline(x=bf_dt_arr[stria_tloc], color='r')
ax2.set_xlabel("Time (UTC)", fontsize=14)
ax2.set_ylabel("Frequency (MHz)", fontsize=14)
ax2.set_yticklabels([*ax2.get_yticks()], fontsize=14)
text2 = ax2.text(0.05,
0.9,
'b) LOFAR Dynamic Spectrum',
fontdict={
'size': 14,
'color': 'w'
},
transform=ax2.transAxes)
text2.set_path_effects(
[path_effects.Stroke(linewidth=1, foreground='k'),
path_effects.Normal()])
#plt.tight_layout()
# fig.autofmt_xdate()
xy0 = v0.get_data()
xy0 = (xy0[0][0], xy0[1][0])
coords0 = gax.get_xaxis_transform()
con_axes0 = ConnectionPatch(xyA=xy0,
xyB=(0, 1),
coordsA=coords0,
coordsB="axes fraction",
axesA=gax,
axesB=ax2,
arrowstyle="-",
color="r")
def draw_contour(shakegrid, popgrid, oceanfile, oceangridfile, cityfile, basename, borderfile=None, is_scenario=False):
"""Create a contour map showing population (greyscale) underneath contoured MMI.
:param shakegrid:
ShakeGrid object.
:param popgrid:
Grid2D object containing population data.
:param oceanfile:
String path to file containing ocean vector data in a format compatible with fiona.
:param oceangridfile:
String path to file containing ocean grid data .
:param cityfile:
String path to file containing GeoNames cities data.
:param basename:
String path containing desired output PDF base name, i.e., /home/pager/exposure. ".pdf" and ".png" files will
be made.
:param make_png:
Boolean indicating whether a PNG version of the file should also be created in the
same output folder as the PDF.
:returns:
Tuple containing:
- Name of PNG file created, or None if PNG output not specified.
- Cities object containing the cities that were rendered on the contour map.
"""
gd = shakegrid.getGeoDict()
# Retrieve the epicenter - this will get used on the map
center_lat = shakegrid.getEventDict()['lat']
center_lon = shakegrid.getEventDict()['lon']
# load the ocean grid file (has 1s in ocean, 0s over land)
# having this file saves us almost 30 seconds!
oceangrid = GDALGrid.load(oceangridfile, samplegeodict=gd, resample=True)
# load the cities data, limit to cities within shakemap bounds
allcities = Cities.fromDefault()
cities = allcities.limitByBounds((gd.xmin, gd.xmax, gd.ymin, gd.ymax))
# define the map
# first cope with stupid 180 meridian
height = (gd.ymax-gd.ymin)*111.191
if gd.xmin < gd.xmax:
width = (gd.xmax-gd.xmin)*np.cos(np.radians(center_lat))*111.191
xmin, xmax, ymin, ymax = (gd.xmin, gd.xmax, gd.ymin, gd.ymax)
else:
xmin, xmax, ymin, ymax = (gd.xmin, gd.xmax, gd.ymin, gd.ymax)
xmax += 360
width = ((gd.xmax+360) - gd.xmin)*np.cos(np.radians(center_lat))*111.191
aspect = width/height
# if the aspect is not 1, then trim bounds in x or y direction as appropriate
if width > height:
dw = (width - height)/2.0 # this is width in km
xmin = xmin + dw/(np.cos(np.radians(center_lat))*111.191)
xmax = xmax - dw/(np.cos(np.radians(center_lat))*111.191)
width = (xmax-xmin)*np.cos(np.radians(center_lat))*111.191
if height > width:
dh = (height - width)/2.0 # this is width in km
ymin = ymin + dh/111.191
ymax = ymax - dh/111.191
height = (ymax-ymin)*111.191
aspect = width/height
figheight = FIGWIDTH/aspect
bbox = (xmin, ymin, xmax, ymax)
bounds = (xmin, xmax, ymin, ymax)
figsize = (FIGWIDTH, figheight)
# Create the MercatorMap object, which holds a separate but identical
# axes object used to determine collisions between city labels.
mmap = MercatorMap(bounds, figsize, cities, padding=0.5)
fig = mmap.figure
ax = mmap.axes
# this needs to be done here so that city label collision detection will work
fig.canvas.draw()
clon = xmin + (xmax-xmin)/2
clat = ymin + (ymax-ymin)/2
geoproj = mmap.geoproj
proj = mmap.proj
# project our population grid to the map projection
projstr = proj.proj4_init
popgrid_proj = popgrid.project(projstr)
popdata = popgrid_proj.getData()
newgd = popgrid_proj.getGeoDict()
# Use our GMT-inspired palette class to create population and MMI colormaps
popmap = ColorPalette.fromPreset('pop')
mmimap = ColorPalette.fromPreset('mmi')
# set the image extent to that of the data
img_extent = (newgd.xmin, newgd.xmax, newgd.ymin, newgd.ymax)
plt.imshow(popdata, origin='upper', extent=img_extent, cmap=popmap.cmap,
vmin=popmap.vmin, vmax=popmap.vmax, zorder=POP_ZORDER, interpolation='nearest')
# draw 10m res coastlines
ax.coastlines(resolution="10m", zorder=COAST_ZORDER);
states_provinces = cfeature.NaturalEarthFeature(
category='cultural',
name='admin_1_states_provinces_lines',
scale='50m',
facecolor='none')
ax.add_feature(states_provinces, edgecolor='black',zorder=COAST_ZORDER)
# draw country borders using natural earth data set
if borderfile is not None:
borders = ShapelyFeature(Reader(borderfile).geometries(),
ccrs.PlateCarree())
ax.add_feature(borders, zorder=COAST_ZORDER, edgecolor='black', linewidth=2, facecolor='none')
# clip the ocean data to the shakemap
bbox = (gd.xmin, gd.ymin, gd.xmax, gd.ymax)
oceanshapes = _clip_bounds(bbox, oceanfile)
ax.add_feature(ShapelyFeature(oceanshapes, crs=geoproj), facecolor=WATERCOLOR, zorder=OCEAN_ZORDER)
# It turns out that when presented with a map that crosses the 180 meridian,
# the matplotlib/cartopy contouring routine thinks that the 180 meridian is a map boundary
# and only plots one side of the contour. Contouring the geographic MMI data and then
# projecting the resulting contour vectors does the trick. Sigh.
# define contour grid spacing
contoury = np.linspace(ymin, ymax, gd.ny)
contourx = np.linspace(xmin, xmax, gd.nx)
# smooth the MMI data for contouring
mmi = shakegrid.getLayer('mmi').getData()
smoothed_mmi = gaussian_filter(mmi, FILTER_SMOOTH)
# create masked arrays of the ocean grid
landmask = np.ma.masked_where(oceangrid._data == 0.0, smoothed_mmi)
oceanmask = np.ma.masked_where(oceangrid._data == 1.0, smoothed_mmi)
# contour the data
land_contour = plt.contour(contourx, contoury, np.flipud(oceanmask), linewidths=3.0, linestyles='solid',
zorder=LANDC_ZORDER, cmap=mmimap.cmap,
vmin=mmimap.vmin, vmax=mmimap.vmax,
levels=np.arange(0.5, 10.5, 1.0),
transform=geoproj)
ocean_contour = plt.contour(contourx, contoury, np.flipud(landmask), linewidths=2.0, linestyles='dashed',
zorder=OCEANC_ZORDER, cmap=mmimap.cmap,
vmin=mmimap.vmin, vmax=mmimap.vmax,
levels=np.arange(0.5, 10.5, 1.0), transform=geoproj)
# the idea here is to plot invisible MMI contours at integer levels and then label them.
# clabel method won't allow text to appear, which is this case is kind of ok, because
# it allows us an easy way to draw MMI labels as roman numerals.
cs_land = plt.contour(contourx, contoury, np.flipud(oceanmask),
linewidths=0.0, levels=np.arange(0, 11),alpha=0.0,
zorder=CLABEL_ZORDER, transform=geoproj)
clabel_text = ax.clabel(cs_land, np.arange(0, 11), colors='k', zorder=CLABEL_ZORDER, fmt='%.0f', fontsize=40)
for clabel in clabel_text:
x, y = clabel.get_position()
label_str = clabel.get_text()
roman_label = MMI_LABELS[label_str]
th=plt.text(x, y, roman_label, zorder=CLABEL_ZORDER, ha='center',
va='center', color='black', weight='normal',
size=16)
th.set_path_effects([path_effects.Stroke(linewidth=2.0, foreground='white'),
path_effects.Normal()])
cs_ocean = plt.contour(contourx, contoury, np.flipud(landmask),
linewidths=0.0, levels=np.arange(0, 11),
zorder=CLABEL_ZORDER, transform=geoproj)
clabel_text = ax.clabel(cs_ocean, np.arange(0, 11), colors='k', zorder=CLABEL_ZORDER, fmt='%.0f', fontsize=40)
for clabel in clabel_text:
x, y = clabel.get_position()
label_str = clabel.get_text()
roman_label = MMI_LABELS[label_str]
th=plt.text(x, y, roman_label, zorder=CLABEL_ZORDER, ha='center',
va='center', color='black', weight='normal',
size=16)
th.set_path_effects([path_effects.Stroke(linewidth=2.0, foreground='white'),
path_effects.Normal()])
# draw meridians and parallels using Cartopy's functions for that
gl = ax.gridlines(draw_labels=True,
linewidth=2, color=(0.9, 0.9, 0.9), alpha=0.5, linestyle='-',
zorder=GRID_ZORDER)
gl.xlabels_top = False
gl.xlabels_bottom = False
gl.ylabels_left = False
gl.ylabels_right = False
gl.xlines = True
step = 1
# let's floor/ceil the edges to nearest half a degree
gxmin = np.floor(xmin * 2) / 2
gxmax = np.ceil(xmax * 2) / 2
gymin = np.floor(ymin * 2) / 2
gymax = np.ceil(ymax * 2) / 2
xlocs = np.linspace(gxmin, gxmax+0.5, num=5)
ylocs = np.linspace(gymin, gymax+0.5, num=5)
gl.xlocator = mticker.FixedLocator(xlocs)
gl.ylocator = mticker.FixedLocator(ylocs)
gl.xformatter = LONGITUDE_FORMATTER
gl.yformatter = LATITUDE_FORMATTER
gl.xlabel_style = {'size': 15, 'color': 'black'}
gl.ylabel_style = {'size': 15, 'color': 'black'}
# TODO - figure out x/y axes data coordinates corresponding to 10% from left
# and 10% from top
# use geoproj and proj
dleft = 0.01
dtop = 0.97
proj_str = proj.proj4_init
merc_to_dd = pyproj.Proj(proj_str)
# use built-in transforms to get from axes units to data units
display_to_data = ax.transData.inverted()
axes_to_display = ax.transAxes
# these are x,y coordinates in projected space
yleft, t1 = display_to_data.transform(axes_to_display.transform((dleft, 0.5)))
t2, xtop = display_to_data.transform(axes_to_display.transform((0.5, dtop)))
# these are coordinates in lon,lat space
yleft_dd, t1_dd = merc_to_dd(yleft, t1, inverse=True)
t2_dd, xtop_dd = merc_to_dd(t2, xtop, inverse=True)
# drawing our own tick labels INSIDE the plot, as Cartopy doesn't seem to support this.
yrange = ymax - ymin
xrange = xmax - xmin
ddlabelsize = 12
for xloc in gl.xlocator.locs:
outside = xloc < xmin or xloc > xmax
# don't draw labels when we're too close to either edge
near_edge = (xloc-xmin) < (xrange*0.1) or (xmax-xloc) < (xrange*0.1)
if outside or near_edge:
continue
xtext = r'$%.1f^\circ$W' % (abs(xloc))
ax.text(xloc, xtop_dd, xtext,
fontsize=ddlabelsize, zorder=GRID_ZORDER, ha='center',
fontname=DEFAULT_FONT,
transform=ccrs.Geodetic())
for yloc in gl.ylocator.locs:
outside = yloc < gd.ymin or yloc > gd.ymax
# don't draw labels when we're too close to either edge
near_edge = (yloc-gd.ymin) < (yrange*0.1) or (gd.ymax-yloc) < (yrange*0.1)
if outside or near_edge:
continue
if yloc < 0:
ytext = r'$%.1f^\circ$S' % (abs(yloc))
else:
ytext = r'$%.1f^\circ$N' % (abs(yloc))
thing = ax.text(yleft_dd, yloc, ytext,
fontsize=ddlabelsize, zorder=GRID_ZORDER, va='center',
fontname=DEFAULT_FONT,
transform=ccrs.Geodetic())
# draw cities
mapcities = mmap.drawCities(shadow=True, zorder=CITIES_ZORDER)
# draw the figure border thickly
# TODO - figure out how to draw map border
# bwidth = 3
# ax.spines['top'].set_visible(True)
# ax.spines['left'].set_visible(True)
# ax.spines['bottom'].set_visible(True)
# ax.spines['right'].set_visible(True)
# ax.spines['top'].set_linewidth(bwidth)
# ax.spines['right'].set_linewidth(bwidth)
# ax.spines['bottom'].set_linewidth(bwidth)
# ax.spines['left'].set_linewidth(bwidth)
# Get the corner of the map with the lowest population
corner_rect, filled_corner = _get_open_corner(popgrid, ax)
clat2 = round_to_nearest(center_lat, 1.0)
clon2 = round_to_nearest(center_lon, 1.0)
# draw a little globe in the corner showing in small-scale where the earthquake is located.
# proj = ccrs.Orthographic(central_latitude=clat2,
# central_longitude=clon2)
# ax2 = fig.add_axes(corner_rect,projection=proj)
# ax2.add_feature(cartopy.feature.OCEAN, zorder=0,facecolor=WATERCOLOR,edgecolor=WATERCOLOR)
# ax2.add_feature(cartopy.feature.LAND, zorder=0, edgecolor='black')
# ax2.plot([clon2],[clat2],'w*',linewidth=1,markersize=16,markeredgecolor='k',markerfacecolor='r')
# gh=ax2.gridlines();
# ax2.set_global();
# ax2.outline_patch.set_edgecolor('black')
# ax2.outline_patch.set_linewidth(2);
# Draw the map scale in the unoccupied lower corner.
corner = 'lr'
if filled_corner == 'lr':
corner = 'll'
draw_scale(ax, corner, pady=0.05, padx=0.05)
# Draw the epicenter as a black star
plt.sca(ax)
plt.plot(center_lon, center_lat, 'k*', markersize=16, zorder=EPICENTER_ZORDER, transform=geoproj)
if is_scenario:
plt.text(center_lon, center_lat, 'SCENARIO', fontsize=64,
zorder=WATERMARK_ZORDER, transform=geoproj,
alpha=0.2, color='red', horizontalalignment='center')
# create pdf and png output file names
pdf_file = basename+'.pdf'
png_file = basename+'.png'
# save to pdf
plt.savefig(pdf_file)
plt.savefig(png_file)
return (pdf_file, png_file, mapcities)
family="Lint McCree Intl BB",
)
# Title
# -----------------------------------------------------------------------------
textpath = TextPath((8, 80),
"MATPLOTLIB",
size=8,
prop=FontProperties(family="GlassJaw BB"))
patch = mpatches.PathPatch(textpath,
facecolor="none",
edgecolor="none",
zorder=5,
joinstyle="round")
patch.set_path_effects([
path_effects.Stroke(linewidth=8, foreground="black"),
path_effects.Stroke(linewidth=6, foreground="yellow"),
path_effects.Stroke(linewidth=3, foreground="black"),
])
transform = ax.transData + mpl.transforms.Affine2D().rotate_deg(2.5)
patch.set_transform(transform)
ax.add_artist(patch)
Z = np.linspace(1, 0, 100).reshape(100, 1)
im = ax.imshow(Z, cmap="autumn", extent=[1, 100, 79, 87], zorder=15)
im.set_transform(transform)
im.set_clip_path(patch._path, patch.get_transform())
ax.text(
47,
def _draw_outline(o, lw):
o.set_path_effects([
patheffects.Stroke(linewidth=lw, foreground='black'),
patheffects.Normal()
])
def mslp_label(mslp, lat, lon):
#Determine an appropriate window given the lat/lon grid resolution
mslp = np.ma.masked_invalid(mslp)
local_min, local_max = extrema(mslp, mode='wrap', window=50)
#Determine axis boundaries
xmin, xmax, ymin, ymax = ax.get_extent()
lons2d, lats2d = np.meshgrid(lon, lat)
transformed = proj.transform_points(ccrs.PlateCarree(), lons2d, lats2d)
x = transformed[..., 0]
y = transformed[..., 1]
#Get location of extrema on grid
xlows = x[local_min]
xhighs = x[local_max]
ylows = y[local_min]
yhighs = y[local_max]
lowvals = mslp[local_min]
highvals = mslp[local_max]
yoffset = 0.022 * (ymax - ymin)
dmin = yoffset
#Plot low pressures
xyplotted = []
for x, y, p in zip(xlows, ylows, lowvals):
if x < xmax - yoffset and x > xmin + yoffset and y < ymax - yoffset and y > ymin + yoffset:
dist = [np.sqrt((x - x0)**2 + (y - y0)**2) for x0, y0 in xyplotted]
if not dist or min(dist) > dmin: #,fontweight='bold'
a = ax.text(x,
y,
'L',
fontsize=20,
ha='center',
va='center',
color='r',
fontweight='normal')
b = ax.text(x,
y - yoffset,
repr(int(p)),
fontsize=12,
ha='center',
va='top',
color='r',
fontweight='normal')
a.set_path_effects([
path_effects.Stroke(linewidth=1.5, foreground='black'),
path_effects.SimpleLineShadow(),
path_effects.Normal()
])
b.set_path_effects([
path_effects.Stroke(linewidth=1.5, foreground='black'),
path_effects.SimpleLineShadow(),
path_effects.Normal()
])
xyplotted.append((x, y))
#Plot high pressures
xyplotted = []
for x, y, p in zip(xhighs, yhighs, highvals):
if x < xmax - yoffset and x > xmin + yoffset and y < ymax - yoffset and y > ymin + yoffset:
dist = [np.sqrt((x - x0)**2 + (y - y0)**2) for x0, y0 in xyplotted]
if not dist or min(dist) > dmin:
a = ax.text(x,
y,
'H',
fontsize=20,
ha='center',
va='center',
color='b',
fontweight='normal')
b = ax.text(x,
y - yoffset,
repr(int(p)),
fontsize=12,
ha='center',
va='top',
color='b',
fontweight='normal')
a.set_path_effects([
path_effects.Stroke(linewidth=1.5, foreground='black'),
path_effects.SimpleLineShadow(),
path_effects.Normal()
])
b.set_path_effects([
path_effects.Stroke(linewidth=1.5, foreground='black'),
path_effects.SimpleLineShadow(),
path_effects.Normal()
])
xyplotted.append((x, y))
def animation_plot(animations, savepath, parents, interval=33.33):
for ai in range(len(animations)):
anim = animations[ai][0].copy()
joints = anim[:, :-4].copy()
root_x = anim[:, -4].copy()
root_y = anim[:, -3].copy()
root_z = anim[:, -2].copy()
root_r = anim[:, -1].copy()
joints = joints.reshape((len(joints), -1, 3))
joints[:, :, 0] = joints[:, :, 0] - joints[0:1, 0:1, 0]
joints[:, :, 2] = joints[:, :, 2] - joints[0:1, 0:1, 2]
# fid_l, fid_r = np.array([4,5]), np.array([9,10])
# foot_heights = np.minimum(joints[:,fid_l,1], joints[:,fid_r,1]).min(axis=1)
# floor_height = softmin(foot_heights, softness=0.5, axis=0)
# joints[:,:,1] -= floor_height
rotation = Quaternions.id(1)
offsets = []
translation = np.array([[0, 0, 0]])
for i in range(len(joints)):
joints[i, :, :] = rotation * joints[i]
joints[i, :, 0] = joints[i, :, 0] + translation[0, 0]
joints[i, :, 1] = joints[i, :, 1] + translation[0, 1]
joints[i, :, 2] = joints[i, :, 2] + translation[0, 2]
rotation = Quaternions.from_angle_axis(
-root_r[i], np.array([0, 1, 0])) * rotation
offsets.append(rotation * np.array([0, 0, 1]))
translation = translation + rotation * np.array(
[root_x[i], root_y[i], root_z[i]])
animations[ai] = joints
scale = 8.25 * ((len(animations)) / 2.)
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(111, projection="3d")
ax.set_xlim3d(-scale * 30, scale * 30)
ax.set_zlim3d(0, scale * 60)
ax.set_ylim3d(-scale * 30, scale * 30)
ax.set_xticks([], [])
ax.set_yticks([], [])
ax.set_zticks([], [])
ax.view_init(0, 90)
ax.set_aspect("equal")
plt.tight_layout()
acolors = ["green", "red"] #list(sorted(colors.cnames.keys()))[::-1]
lines = []
for ai, anim in enumerate(animations):
lines.append([
plt.plot([0, 0], [0, 0], [0, 0],
color=acolors[ai],
lw=2,
path_effects=[
pe.Stroke(linewidth=3, foreground="black"),
pe.Normal()
])[0] for _ in range(anim.shape[1])
])
def animate(i):
changed = []
for ai in range(len(animations)):
offset = 200 * (ai - ((len(animations)) / 2))
for j in range(len(parents)):
if parents[j] != -1:
lines[ai][j].set_data([
animations[ai][i, j, 0] + offset,
animations[ai][i, parents[j], 0] + offset
], [
-animations[ai][i, j, 2],
-animations[ai][i, parents[j], 2]
])
lines[ai][j].set_3d_properties([
animations[ai][i, j, 1], animations[ai][i, parents[j],
1]
])
changed += lines
return changed
ani = animation.FuncAnimation(fig,
animate,
np.arange(len(animations[0])),
interval=interval)
ani.save(savepath, writer="ffmpeg", fps=30)
plt.close()
ax.scatter(Px, Py, edgecolor="black", facecolor="white", zorder=20)
ax.scatter(Px, Py, edgecolor="None", facecolor="C1", alpha=0.5, zorder=30)
y, dy = 1.0, 0.125
style = "arc,angleA=-0,angleB=0,armA=-100,armB=0,rad=0"
for i in range(len(I)):
text = ax.annotate(
"Point " + chr(ord("A") + i),
xy=(Px[i], Py[i]),
xycoords="data",
xytext=(0, 18),
textcoords="offset points",
ha="center",
size="small",
arrowprops=dict(
arrowstyle="->", shrinkA=0, shrinkB=5, color="black", linewidth=0.75
),
)
text.set_path_effects(
[path_effects.Stroke(linewidth=2, foreground="white"), path_effects.Normal()]
)
text.arrow_patch.set_path_effects(
[path_effects.Stroke(linewidth=2, foreground="white"), path_effects.Normal()]
)
plt.tight_layout()
plt.savefig("../../figures/ornaments/annotation-direct.pdf")
plt.show()
