def taylor(scores):
fig = plt.figure(1)
tr = PolarAxes.PolarTransform()
CCgrid= np.concatenate((np.arange(0,10,2)/10.,[0.9,0.95,0.99]))
CCpolar=np.arccos(CCgrid)
gf=FixedLocator(CCpolar)
tf=DictFormatter(dict(zip(CCpolar, map(str,CCgrid))))
STDgrid=np.arange(0,2.0,.5)
gfs=FixedLocator(STDgrid)
tfs=DictFormatter(dict(zip(STDgrid, map(str,STDgrid))))
ra0, ra1 =0, np.pi/2
cz0, cz1 = 0, 2
grid_helper = floating_axes.GridHelperCurveLinear(
tr, extremes=(ra0, ra1, cz0, cz1),
grid_locator1=gf,
tick_formatter1=tf,
grid_locator2=gfs,
tick_formatter2=tfs)
ax1 = floating_axes.FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_subplot(ax1)
ax1.axis["top"].set_axis_direction("bottom")
ax1.axis["top"].toggle(ticklabels=True, label=True)
ax1.axis["top"].major_ticklabels.set_axis_direction("top")
ax1.axis["top"].label.set_axis_direction("top")
ax1.axis["top"].label.set_text("Correlation")
ax1.axis["left"].set_axis_direction("bottom")
ax1.axis["left"].label.set_text("Normalized Standard deviation")
ax1.axis["right"].set_axis_direction("top")
ax1.axis["right"].toggle(ticklabels=True)
ax1.axis["right"].major_ticklabels.set_axis_direction("left")
ax1.axis["bottom"].set_visible(False)
ax1 = ax1.get_aux_axes(tr)
rs,ts = np.meshgrid(np.linspace(0,2),np.linspace(0,np.pi/2))
rms = np.sqrt(1 + rs**2 - 2*rs*np.cos(ts))
contours = ax1.contour(ts, rs, rms, 3,colors='0.5')
plt.clabel(contours, inline=1, fontsize=10)
plt.grid(linestyle=':',alpha=0.5)
for r in scores.iterrows():
th=np.arccos(r[1].CORRELATION)
rr=r[1].MSTD/r[1].OSTD
ax1.plot(th,rr,'o',label=r[0])
plt.legend(loc='upper right',bbox_to_anchor=[1.2,1.15])
plt.show()
def taylor_template(angle_lim, std_lim, rect, xaxislab, fig=None):
# written by Maria Aristizabal: https://github.com/MariaAristizabal/Evaluation_surf_metrics_Dorian_figures
import mpl_toolkits.axisartist.floating_axes as floating_axes
from matplotlib.projections import PolarAxes
from mpl_toolkits.axisartist.grid_finder import (FixedLocator,
DictFormatter)
if fig is None:
fig = plt.figure()
tr = PolarAxes.PolarTransform()
min_corr = np.round(np.cos(angle_lim), 1)
CCgrid = np.concatenate(
(np.arange(min_corr * 10, 10, 2.0) / 10., [0.9, 0.95, 0.99]))
CCpolar = np.arccos(CCgrid)
gf = FixedLocator(CCpolar)
tf = DictFormatter(dict(zip(CCpolar, map(str, CCgrid))))
STDgrid = np.arange(0, std_lim, .5)
gfs = FixedLocator(STDgrid)
tfs = DictFormatter(dict(zip(STDgrid, map(str, STDgrid))))
ra0, ra1 = 0, angle_lim
cz0, cz1 = 0, std_lim
grid_helper = floating_axes.GridHelperCurveLinear(tr,
extremes=(ra0, ra1, cz0,
cz1),
grid_locator1=gf,
tick_formatter1=tf,
grid_locator2=gfs,
tick_formatter2=tfs)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
ax1.axis["top"].set_axis_direction("bottom")
ax1.axis["top"].toggle(ticklabels=True, label=True)
ax1.axis["top"].major_ticklabels.set_axis_direction("top")
ax1.axis["top"].label.set_axis_direction("top")
ax1.axis["top"].label.set_text("Correlation")
ax1.axis['top'].label.set_size(14)
ax1.axis["left"].set_axis_direction("bottom")
if xaxislab == 'yes':
ax1.axis["left"].label.set_text("Normalized Standard Deviation")
ax1.axis['left'].label.set_size(14)
ax1.axis["right"].set_axis_direction("top")
ax1.axis["right"].toggle(ticklabels=True)
ax1.axis["right"].major_ticklabels.set_axis_direction("left")
ax1.axis["bottom"].set_visible(False)
ax1 = ax1.get_aux_axes(tr)
plt.grid(linestyle=':', alpha=0.5)
return fig, ax1
def test_curvelinear3():
fig = plt.figure(figsize=(5, 5))
tr = (mtransforms.Affine2D().scale(np.pi / 180, 1) +
mprojections.PolarAxes.PolarTransform())
grid_locator1 = angle_helper.LocatorDMS(15)
tick_formatter1 = angle_helper.FormatterDMS()
grid_locator2 = FixedLocator([2, 4, 6, 8, 10])
grid_helper = GridHelperCurveLinear(
tr,
extremes=(0, 360, 10, 3),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None,
)
ax1 = FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_subplot(ax1)
r_scale = 10
tr2 = mtransforms.Affine2D().scale(1, 1 / r_scale) + tr
grid_locator2 = FixedLocator([30, 60, 90])
grid_helper2 = GridHelperCurveLinear(tr2,
extremes=(0, 360, 10 * r_scale,
3 * r_scale),
grid_locator2=grid_locator2)
ax1.axis["right"] = axis = grid_helper2.new_fixed_axis("right", axes=ax1)
ax1.axis["left"].label.set_text("Test 1")
ax1.axis["right"].label.set_text("Test 2")
for an in ["left", "right"]:
ax1.axis[an].set_visible(False)
axis = grid_helper.new_floating_axis(1,
7,
axes=ax1,
axis_direction="bottom")
ax1.axis["z"] = axis
axis.toggle(all=True, label=True)
axis.label.set_text("z = ?")
axis.label.set_visible(True)
axis.line.set_color("0.5")
ax2 = ax1.get_aux_axes(tr)
xx, yy = [67, 90, 75, 30], [2, 5, 8, 4]
ax2.scatter(xx, yy)
(l, ) = ax2.plot(xx, yy, "k-")
l.set_clip_path(ax1.patch)
def taylor_template(angle_lim, std_lim):
fig = plt.figure()
tr = PolarAxes.PolarTransform()
min_corr = np.round(np.cos(angle_lim), 1)
CCgrid = np.concatenate(
(np.arange(min_corr * 10, 10, 2.0) / 10., [0.9, 0.95, 0.99]))
CCpolar = np.arccos(CCgrid)
gf = FixedLocator(CCpolar)
tf = DictFormatter(dict(zip(CCpolar, map(str, CCgrid))))
STDgrid = np.arange(0, std_lim, .5)
gfs = FixedLocator(STDgrid)
tfs = DictFormatter(dict(zip(STDgrid, map(str, STDgrid))))
ra0, ra1 = 0, angle_lim
cz0, cz1 = 0, std_lim
grid_helper = floating_axes.GridHelperCurveLinear(tr,
extremes=(ra0, ra1, cz0,
cz1),
grid_locator1=gf,
tick_formatter1=tf,
grid_locator2=gfs,
tick_formatter2=tfs)
ax1 = floating_axes.FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_subplot(ax1)
ax1.axis["top"].set_axis_direction("bottom")
ax1.axis["top"].toggle(ticklabels=True, label=True)
ax1.axis["top"].major_ticklabels.set_axis_direction("top")
ax1.axis["top"].label.set_axis_direction("top")
ax1.axis["top"].label.set_text("Correlation")
ax1.axis['top'].label.set_size(14)
ax1.axis["left"].set_axis_direction("bottom")
ax1.axis["left"].label.set_text("Normalized Standard Deviation")
ax1.axis['left'].label.set_size(14)
ax1.axis["right"].set_axis_direction("top")
ax1.axis["right"].toggle(ticklabels=True)
ax1.axis["right"].major_ticklabels.set_axis_direction("left")
ax1.axis["bottom"].set_visible(False)
ax1 = ax1.get_aux_axes(tr)
plt.grid(linestyle=':', alpha=0.5)
return fig, ax1
def setup_axes2(fig, rect):
#mengatur locator dan formatter
tr = PolarAxes.PolarTransform()
pi = np.pi
angle_ticks = [(0, r"$0$"), (.25 * pi, r"$\frac{1}{4}\pi$"),
(.5 * pi, r"$\frac{1}{2}\pi$")]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
grid_locator2 = MaxNLocator(2)
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(.5 * pi, 0, 2, 1),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None,
)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch
ax1.patch.zorder = 0.9
return ax1, aux_ax
def setup_axes2(fig, rect):
tr = PolarAxes.PolarTransform()
pi = np.pi
angle_ticks = [(0, r"$0$"), (.25 * pi, r"$\frac{1}{4}\pi$"),
(.5 * pi, r"$\frac{1}{2}\pi$")]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
grid_locator2 = MaxNLocator(2)
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(.5 * pi, 0, 2, 1),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
# 创建一个ParasiteAxes
aux_ax = ax1.get_aux_axes(tr)
# 让aux_ax具有一个ax中的剪切路径
aux_ax.patch = ax1.patch
# 但这样做会有一个副作用，这个patch会被绘制两次，并且可能会被绘制于其它
# Artist的上面，因此用降低其zorder值的方法来阻止该情况
ax1.patch.zorder = 0.9
return ax1, aux_ax
def setup_axes2(self, fig, rect, n_markers, lat_min, lat_max, angle_ticks):
"""
for thin shells, lat subset
"""
tr = PolarAxes.PolarTransform()
rs = np.linspace(self.r_inner, self.r_outer, n_markers)
if not angle_ticks:
angle_ticks = []
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
# set the number of r points you want on plot
grid_locator2 = FixedLocator(rs)
tick_formatter2 = None
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(lat_max / 180 * np.pi, lat_min / 180 * np.pi,
self.r_outer, self.r_inner), # 70/180
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=tick_formatter2)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
# format tick labels (see: https://matplotlib.org/mpl_toolkits/axes_grid/users/axisartist.html)
ax1.axis["bottom"].major_ticklabels.set_rotation(-90)
ax1.axis["bottom"].major_ticklabels.set_va("center")
ax1.axis["bottom"].major_ticklabels.set_pad(12)
# create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
return ax1, aux_ax
def setup_axes1(self, fig, T_ticks, subplotshape=None):
"""
A simple one.
"""
deg = -45.
self.tr = Affine2D().rotate_deg(deg)
theta_ticks = [] #np.arange(theta_min, theta_max, d_T)
grid_helper = GridHelperCurveLinear(
self.tr,
grid_locator1=FixedLocator(T_ticks),
grid_locator2=FixedLocator(theta_ticks))
if subplotshape is None:
subplotshape = (1, 1, 1)
ax1 = Subplot(fig, *subplotshape, grid_helper=grid_helper)
# ax1 will have a ticks and gridlines defined by the given
# transform (+ transData of the Axes). Note that the transform of
# the Axes itself (i.e., transData) is not affected by the given
# transform.
fig.add_subplot(ax1)
# SW, SE, NE, NW
corners = np.array([[-25., -20.], [30., 40.], [-40., 120.],
[-105., 60.]])
corners_t = self._tf(corners[:, 0], corners[:, 1])
# ax1.set_aspect(1.)
x_min, x_max = self.x_range
ax1.set_xlim(x_min, x_max)
ax1.set_ylim(*self.y_range)
ax1.set_xlabel('Temperature [C]')
ax1.set_aspect(1)
#ax1.axis["t"]=ax1.new_floating_axis(0, 0.)
#T_axis = ax1.axis['t']
#theta_axis = ax1.axis["t2"]=ax1.new_floating_axis(1, 0.)
# plot.draw()
# plot.show()
self.ax1 = ax1
def setup_axes(self, fig, rect, n_markers):
"""
With custom locator and formatter.
Note that the extreme values are swapped.
"""
tr = PolarAxes.PolarTransform()
rs = np.linspace(self.r_inner, self.r_outer, n_markers)
angle_ticks = []
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
# set the number of r points you want on plot
grid_locator2 = FixedLocator(rs)
tick_formatter2 = None
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(0.5 * np.pi, -0.5 * np.pi, self.r_outer, self.r_inner),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=tick_formatter2)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
# create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
return ax1, aux_ax
def polarplot(self):
tr = PolarAxes.PolarTransform()
grid_locator1 = FixedLocator([v for v, s in self.angle_ticks])
tick_formatter1 = DictFormatter(dict(self.angle_ticks))
grid_locator2 = FixedLocator([a for a, b in self.radius_ticks])
tick_formatter2 = DictFormatter(dict(self.radius_ticks))
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(self.max_angle, self.min_angle, self.max_rad,
self.min_rad),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=tick_formatter2)
ax = floating_axes.FloatingSubplot(self.fig,
self.rect,
grid_helper=grid_helper)
self.fig.add_subplot(ax)
ax.grid(True, color='b', linewidth=0.2, linestyle='-')
aux_ax = ax.get_aux_axes(tr)
aux_ax.patch = ax.patch
ax.patch.zorder = 0.9
ax.axis['bottom'].set_label(r'Angle ($^{\circ}$)')
ax.axis['bottom'].major_ticklabels.set_rotation(180)
ax.axis['bottom'].label.set_rotation(180)
ax.axis['bottom'].LABELPAD += 30
ax.axis['left'].set_label('Range (m)')
ax.axis['left'].label.set_rotation(0)
ax.axis['left'].LABELPAD += 15
ax.axis['left'].set_visible(True)
return ax, aux_ax
def test_curvelinear4():
# Remove this line when this test image is regenerated.
plt.rcParams['text.kerning_factor'] = 6
fig = plt.figure(figsize=(5, 5))
tr = (mtransforms.Affine2D().scale(np.pi / 180, 1) +
mprojections.PolarAxes.PolarTransform())
grid_locator1 = angle_helper.LocatorDMS(5)
tick_formatter1 = angle_helper.FormatterDMS()
grid_locator2 = FixedLocator([2, 4, 6, 8, 10])
grid_helper = GridHelperCurveLinear(tr,
extremes=(120, 30, 10, 0),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None)
ax1 = FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_subplot(ax1)
ax1.axis["left"].label.set_text("Test 1")
ax1.axis["right"].label.set_text("Test 2")
for an in ["top"]:
ax1.axis[an].set_visible(False)
axis = grid_helper.new_floating_axis(1,
70,
axes=ax1,
axis_direction="bottom")
ax1.axis["z"] = axis
axis.toggle(all=True, label=True)
axis.label.set_axis_direction("top")
axis.label.set_text("z = ?")
axis.label.set_visible(True)
axis.line.set_color("0.5")
ax2 = ax1.get_aux_axes(tr)
xx, yy = [67, 90, 75, 30], [2, 5, 8, 4]
ax2.scatter(xx, yy)
l, = ax2.plot(xx, yy, "k-")
l.set_clip_path(ax1.patch)
def setup_axes(fig, rect, theta, radius):
""" Sets up the axes in such a way we can plot the polarplot. """
tr = PolarAxes.PolarTransform()
pi = np.pi
angle_ticks = [(-4. / 8. * pi, r"$-\frac{1}{2}\pi$"), (-3. / 8. * pi, r""),
(-2. / 8. * pi, r"$-\frac{1}{4}\pi$"), (-1. / 8. * pi, r""),
(0. / 8. * pi, r"$0$"), (1. / 8. * pi, r""),
(2. / 8. * pi, r"$\frac{1}{4}\pi$"), (3. / 8. * pi, r""),
(4. / 8. * pi, r"$\frac{1}{2}\pi$"),
(6. / 8. * pi, r"$\frac{3}{4}\pi$"),
(8. / 8. * pi, r"$\pi$")]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
grid_locator2 = MaxNLocator(3)
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(theta[0], theta[1], radius[0], radius[1]),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
# adjust axis
# "bottom", "top", "left", "right"
ax1.axis["left"].set_axis_direction("bottom")
ax1.axis["right"].set_axis_direction("top")
ax1.axis["bottom"].set_visible(False)
ax1.axis["top"].set_axis_direction("bottom")
ax1.axis["top"].toggle(ticklabels=True, label=True)
ax1.axis["top"].major_ticklabels.set_axis_direction("top")
ax1.axis["top"].label.set_axis_direction("top")
# create a parasite axes
aux_ax = ax1.get_aux_axes(tr)
return ax1, aux_ax
def setup_axes2(fig, rect):
"""
With custom locator and formatter.
Note that the extreme values are swapped.
"""
tr = PolarAxes.PolarTransform()
pi = np.pi
angle_ticks = [(.5 * pi, r"90$\degree$"), (.625 * pi, r"112.5$\degree$"),
(.75 * pi, r"135$\degree$"),
(.81111111 * pi, r"146$\degree$"),
(.84444444 * pi, r"152$\degree$"), (pi, r"180$\degree$")]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
grid_locator2 = MaxNLocator(2)
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(pi, 0.5 * pi, 6371, 0),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
ax1.axis["bottom"].major_ticklabels.set_axis_direction("top")
ax1.axis["left"].toggle(ticklabels=False)
ax1.axis["left"].toggle(ticks=False)
ax1.axis["top"].toggle(ticks=False)
fig.add_subplot(ax1)
# create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
return ax1, aux_ax
def setup_axes2(fig, rect):
"""
With custom locator and formatter.
Note that the extreme values are swapped.
"""
#tr_scale = Affine2D().scale(np.pi/180., 1.)
tr = PolarAxes.PolarTransform()
pi = np.pi
angle_ticks = [(0, r"$0$"), (.25 * pi, r"$\frac{1}{4}\pi$"),
(.5 * pi, r"$\frac{1}{2}\pi$")]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
grid_locator2 = MaxNLocator(2)
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(.5 * pi, 0, 2, 1),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None,
)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
# create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
return ax1, aux_ax
def setup_axes2(fig, rect):
"""
With custom locator and formatter.
Note that the extreme values are swapped.
"""
tr = PolarAxes.PolarTransform()
pi = np.pi
angle_ticks = [(0,'180' ),
(.25*pi,'135' ),
(.5*pi, '90'),
(.75*pi,'45' ),
(pi,'0')]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
grid_locator2 = MaxNLocator(nbins=6)
grid_helper = floating_axes.GridHelperCurveLinear(
tr, extremes=(pi,0, 6371,3481),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None)
ax1 = floating_axes.FloatingSubplot(fig, rect,
grid_helper=grid_helper)
fig.add_subplot(ax1)
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
return ax1, aux_ax
def setup_axes2(fig, rect, tmin, tmax, zmin, zmax):
"""
With custom locator and formatter.
Note that the extreme values are swapped.
"""
tr = PolarAxes.PolarTransform()
pi = np.pi
angle_ticks = [(tmin, '%.2f' % tmin), (0, r'$0$'), (tmax, '%.2f' % tmax)]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
grid_locator2 = MaxNLocator(4)
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(tmax, tmin, zmax, zmin),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
# create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.95 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
return ax1, aux_ax
def plot_polar_heatmap(data,
name,
interp_factor=5.,
color_limits=False,
hide_colorbar=False,
vmin=None,
vmax=None,
log_scale=True,
dpi=200,
output_dir=None):
"""Plots the polar heatmap describing azimuth and latitude / elevation components.
Plots the polar heatmap where each cell of the heatmap corresponds to
the specific element of the array provided by `gather_polar_errors`
function.
Parameters
----------
data : 2D array
Indicates the array containing the sum of angular errors within the
specified angular ranges. It is usually provided by `gather_polar_errors`
function.
name : str
Indicates the name of the output png file.
interp_factor : float
Indicates the interpolation factor of the heatmap.
color_limits : boolean
Specifies if the determined intensity limits should be returned.
hide_colorbar : boolean
Specifies if the colorbar should be hidden.
vmin : float
Indicates the minimum value of the colorbar.
vmax : float
Indicates the maximum value of the colorbar.
log_scale : float
Specifies if the heatmap sould be in the logarithmic scale.
dpi : integer
Indicates the DPI of the output image.
output_dir : str
Indicates the path to the output folder where the image will be stored.
"""
th0, th1 = 0., 180.
r0, r1 = 0, 90
thlabel, rlabel = 'Azimuth', 'Elevation'
tr_scale = Affine2D().scale(np.pi / 180., 1.)
tr = tr_scale + PolarAxes.PolarTransform()
lat_ticks = [(.0 * 90., '0$^{\circ}$'), (.33 * 90., '30$^{\circ}$'),
(.66 * 90., '60$^{\circ}$'), (1. * 90., '90$^{\circ}$')]
r_grid_locator = FixedLocator([v for v, s in lat_ticks])
r_grid_formatter = DictFormatter(dict(lat_ticks))
angle_ticks = [(0 * 180., '90$^{\circ}$'), (.25 * 180., '45$^{\circ}$'),
(.5 * 180., '0$^{\circ}$'), (.75 * 180., '-45$^{\circ}$'),
(1. * 180., '-90$^{\circ}$')]
theta_grid_locator = FixedLocator([v for v, s in angle_ticks])
theta_tick_formatter = DictFormatter(dict(angle_ticks))
grid_helper = GridHelperCurveLinear(tr,
extremes=(th0, th1, r0, r1),
grid_locator1=theta_grid_locator,
grid_locator2=r_grid_locator,
tick_formatter1=theta_tick_formatter,
tick_formatter2=r_grid_formatter)
fig = plt.figure()
ax = floating_axes.FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_subplot(ax)
ax.set_facecolor('white')
ax.axis["bottom"].set_visible(False)
ax.axis["top"].toggle(ticklabels=True, label=True)
ax.axis["top"].set_axis_direction("bottom")
ax.axis["top"].major_ticklabels.set_axis_direction("top")
ax.axis["top"].label.set_axis_direction("top")
ax.axis["left"].set_axis_direction("bottom")
ax.axis["right"].set_axis_direction("top")
ax.axis["top"].label.set_text(thlabel)
ax.axis["left"].label.set_text(rlabel)
aux_ax = ax.get_aux_axes(tr)
aux_ax.patch = ax.patch
ax.patch.zorder = 0.9
rad = np.linspace(0, 90, data.shape[1])
azm = np.linspace(0, 180, data.shape[0])
f = interpolate.interp2d(rad,
azm,
data,
kind='linear',
bounds_error=True,
fill_value=0)
new_rad = np.linspace(0, 90, 180 * interp_factor)
new_azm = np.linspace(0, 180, 360 * interp_factor)
new_data_angle_dist = f(new_rad, new_azm)
new_r, new_th = np.meshgrid(new_rad, new_azm)
new_data_angle_dist += 1.
if log_scale:
data_mesh = aux_ax.pcolormesh(
new_th,
new_r,
new_data_angle_dist,
cmap='jet',
norm=colors.LogNorm(
vmin=1. if vmin is None else vmin,
vmax=new_data_angle_dist.max() if vmax is None else vmax))
else:
data_mesh = aux_ax.pcolormesh(new_th,
new_r,
new_data_angle_dist,
cmap='jet',
vmin=vmin,
vmax=vmax)
cbar = plt.colorbar(data_mesh,
orientation='vertical',
shrink=.88,
pad=.1,
aspect=15)
cbar.ax.set_ylabel('Absolute error, [deg.]')
if hide_colorbar:
cbar.remove()
ax.grid(False)
plt.show()
if output_dir is not None:
if not os.path.exists(output_dir):
os.makedirs(output_dir)
fig.savefig(os.path.join(output_dir, f'{name}_chart.png'),
transparent=False,
bbox_inches='tight',
pad_inches=0.1,
dpi=dpi)
if color_limits:
return 1., new_data_angle_dist.max()
def taylor(scores, colors, units, angle_lim):
fig = plt.figure()
tr = PolarAxes.PolarTransform()
CCgrid = np.concatenate((np.arange(0, 10, 2) / 10., [0.9, 0.95, 0.99]))
CCpolar = np.arccos(CCgrid)
gf = FixedLocator(CCpolar)
tf = DictFormatter(dict(zip(CCpolar, map(str, CCgrid))))
max_std = np.nanmax([scores.OSTD, scores.MSTD])
if np.round(scores.OSTD[0], 2) <= 0.2:
#STDgrid=np.linspace(0,np.round(scores.OSTD[0]+0.01,2),3)
STDgrid = np.linspace(0, np.round(scores.OSTD[0] + max_std + 0.02, 2),
3)
if np.logical_and(
np.round(scores.OSTD[0], 2) > 0.2,
np.round(scores.OSTD[0], 2) <= 1):
STDgrid = np.linspace(0, np.round(scores.OSTD[0] + 0.1, 2), 3)
if np.logical_and(
np.round(scores.OSTD[0], 2) > 1,
np.round(scores.OSTD[0], 2) <= 5):
STDgrid = np.arange(0, np.round(scores.OSTD[0] + 2, 2), 1)
if np.round(scores.OSTD[0], 2) > 5:
STDgrid = np.arange(0, np.round(scores.OSTD[0] + 5, 1), 2)
gfs = FixedLocator(STDgrid)
tfs = DictFormatter(dict(zip(STDgrid, map(str, STDgrid))))
ra0, ra1 = 0, angle_lim
if np.round(scores.OSTD[0], 2) <= 0.2:
cz0, cz1 = 0, np.round(max_std + 0.1, 2)
else:
#cz0, cz1 = 0, np.round(scores.OSTD[0]+0.1,2)
cz0, cz1 = 0, np.round(max_std + 0.1, 2)
grid_helper = floating_axes.GridHelperCurveLinear(tr,
extremes=(ra0, ra1, cz0,
cz1),
grid_locator1=gf,
tick_formatter1=tf,
grid_locator2=gfs,
tick_formatter2=tfs)
ax1 = floating_axes.FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_subplot(ax1)
ax1.axis["top"].set_axis_direction("bottom")
ax1.axis["top"].toggle(ticklabels=True, label=True)
ax1.axis["top"].major_ticklabels.set_axis_direction("top")
ax1.axis["top"].label.set_axis_direction("top")
ax1.axis["top"].label.set_text("Correlation")
ax1.axis['top'].label.set_size(14)
ax1.axis["left"].set_axis_direction("bottom")
ax1.axis["left"].label.set_text("Standard Deviation " + '(' + units + ')')
ax1.axis['left'].label.set_size(14)
ax1.axis["right"].set_axis_direction("top")
ax1.axis["right"].toggle(ticklabels=True)
ax1.axis["right"].major_ticklabels.set_axis_direction("left")
ax1.axis["bottom"].set_visible(False)
ax1 = ax1.get_aux_axes(tr)
plt.grid(linestyle=':', alpha=0.5)
for i, r in enumerate(scores.iterrows()):
theta = np.arccos(r[1].CORRELATION)
rr = r[1].MSTD
ax1.plot(theta, rr, 'o', label=r[0], color=colors[i])
ax1.plot(0, scores.OSTD[0], 'o', label='Obs')
plt.legend(loc='upper right', bbox_to_anchor=[1.3, 1.15])
plt.show()
rs, ts = np.meshgrid(np.linspace(0, np.round(max_std + 0.1, 2)),
np.linspace(0, angle_lim))
rms = np.sqrt(scores.OSTD[0]**2 + rs**2 -
2 * rs * scores.OSTD[0] * np.cos(ts))
ax1.contour(ts, rs, rms, 5, colors='0.5')
#contours = ax1.contour(ts, rs, rms,5,colors='0.5')
#plt.clabel(contours, inline=1, fontsize=10)
plt.grid(linestyle=':', alpha=0.5)
for i, r in enumerate(scores.iterrows()):
#crmse = np.sqrt(r[1].OSTD**2 + r[1].MSTD**2 \
# - 2*r[1].OSTD*r[1].MSTD*r[1].CORRELATION)
crmse = np.sqrt(scores.OSTD[0]**2 + r[1].MSTD**2 \
- 2*scores.OSTD[0]*r[1].MSTD*r[1].CORRELATION)
print(crmse)
c1 = ax1.contour(ts, rs, rms, [crmse], colors=colors[i])
plt.clabel(c1, inline=1, fontsize=10, fmt='%1.2f')
return fig, ax1
cgax.axis["bottom"].get_helper().nth_coord_ticks = 0
# and also set tickmarklength to zero for better presentation
cgax.axis["right"].major_ticks.set_ticksize(0)
cgax.axis["top"].major_ticks.set_ticksize(0)
# make ticklabels of left and bottom axis unvisible,
# because we are drawing them
cgax.axis["right"].major_ticklabels.set_visible(False)
cgax.axis["top"].major_ticklabels.set_visible(False)
# and also set tickmarklength to zero for better presentation
cgax.axis["right"].major_ticks.set_ticksize(0)
cgax.axis["top"].major_ticks.set_ticksize(0)
plt.text(0.025,
-0.065,
'azimuth',
transform=caax.transAxes,
va='bottom',
ha='left')
cbar.set_label('reflectivity [dBZ]')
gh = cgax.get_grid_helper()
# set azimuth resolution to 15deg
gh.grid_finder.grid_locator1 = FixedLocator([i for i in np.arange(0, 359, 5)])
gh.grid_finder.grid_locator2._nbins = 30
gh.grid_finder.grid_locator2._steps = [1, 1.5, 2, 2.5, 5, 10]
cgax.axis["lat"] = cgax.new_floating_axis(0, 240)
cgax.axis["lat"].set_ticklabel_direction('-')
cgax.axis["lat"].label.set_text("range [km]")
cgax.axis["lat"].label.set_rotation(180)
cgax.axis["lat"].label.set_pad(10)
plt.tight_layout()
plt.draw()
plt.show()
def plot_shape(topological, max_level=10):
'''
Shows the average tree shape as a bullseye plot.
Parameters
----------
topological : TopologicalAnalysisResult
Topological stats of the model to be visualized.
max_level : int
Maximul tree-depth of the visualization. Maximum allowed value is 16.
Returns
-------
: matplotlib.figure.Figure
The matpotlib Figure
'''
ts = topological.avg_tree_shape()
max_levels, _ = ts.shape
max_levels = min(max_levels, max_level + 1)
# precision of the plot (should be at least 2**max_levels)
max_nodes = max(128, 2**max_levels)
# custom color map
cm = LinearSegmentedColormap.from_list(
'w2r', [(1, 1, 1), (23. / 255., 118. / 255., 182. / 255.)], N=256)
# figure
fig = plt.figure(1, figsize=(12, 6))
tr = Affine2D().translate(np.pi, 0) + PolarAxes.PolarTransform()
x_ticks = [x + 2. for x in range(max_levels - 1)]
grid_locator2 = FixedLocator(x_ticks)
tick_formatter2 = DictFormatter(
{k: " " + str(int(k) - 1)
for k in x_ticks})
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(0, np.pi, 0, max_levels),
grid_locator2=grid_locator2,
tick_formatter2=tick_formatter2)
ax3 = floating_axes.FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_axes(ax3)
# fix axes
ax3.axis["bottom"].set_visible(False)
ax3.axis["top"].set_visible(False)
ax3.axis["right"].set_axis_direction("top")
ax3.axis["left"].set_axis_direction("bottom")
ax3.axis["left"].major_ticklabels.set_pad(-5)
ax3.axis["left"].major_ticklabels.set_rotation(180)
# ax3.axis["left"].label.set_text("tree level")
# ax3.axis["left"].label.set_ha("right")
ax3.axis["left"].label.set_rotation(180)
ax3.axis["left"].label.set_pad(20)
ax3.axis["left"].major_ticklabels.set_ha("left")
ax = ax3.get_aux_axes(tr)
ax.patch = ax3.patch # for aux_ax to have a clip path as in ax
ax3.patch.zorder = .9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
# data to be plotted
theta, r = np.mgrid[0:np.pi:(max_nodes + 1) * 1j, 0:max_levels + 1]
z = np.zeros(theta.size).reshape(theta.shape)
for level in xrange(max_levels):
num_nodes = 2**level
num_same_color = max_nodes / num_nodes
for node in xrange(num_nodes):
if node < ts.shape[1]:
z[num_same_color * node:num_same_color * (node + 1),
level] = ts[level, node]
# draw the tree nodes frequencies
h = ax.pcolormesh(theta, r, z, cmap=cm, vmin=0., vmax=1.)
# color bar
cax = fig.add_axes([.95, 0.15, 0.025, 0.8]) # axes for the colot bar
cbar = fig.colorbar(h, cax=cax, ticks=np.linspace(0, 1, 11))
cbar.ax.tick_params(labelsize=8)
cax.set_title('Frequency', verticalalignment="bottom", fontsize=10)
# separate depths
for level in xrange(1, max_levels + 1):
ax.plot(np.linspace(0, np.pi, num=128), [1 * level] * 128,
'k:',
lw=0.3)
# separate left sub-tree from right sub-tree
ax.plot([np.pi, np.pi], [0, 1], 'k-')
ax.plot([0, 0], [0, 1], 'k-')
# label tree depths
ax.text(np.pi / 2 * 3,
.2,
"ROOT",
horizontalalignment='center',
verticalalignment='center')
ax.text(-.08,
max_levels,
"Tree level",
verticalalignment='bottom',
fontsize=14)
# left/right subtree
# ax.text(np.pi/4.,max_levels*1.15, "Left subtree", fontsize=12,
# horizontalalignment="center", verticalalignment="center")
# ax.text(np.pi/4.*3,max_levels*1.15, "Right subtree", fontsize=12,
# horizontalalignment="center", verticalalignment="center")
ax3.set_title("Average Tree Shape: " + str(topological.model),
fontsize=16,
y=1.2)
return fig
def erpa_axes(fig, rect, PA_bin_edges, epq_edges, log_epq_offset):
import mpl_toolkits.axisartist.floating_axes as floating_axes
from matplotlib.projections import PolarAxes
from mpl_toolkits.axisartist.grid_finder import (FixedLocator,
DictFormatter)
'''
Function that creates the axes for the energy resolved pitch angle plots.
Arguments:
fig: the figure the axes will be plotted on
rect: the subplot of the figure the axis belongs on
Note that the extreme/boundary values are swapped.
If this function is used within the function erpa_plotter, the arguments are defined within erpa_plotter
'''
tr = PolarAxes.PolarTransform()
#pi = np.pi
#setting tick marks and tick labels for the pitch angle/circumference axis
angle_ticks = [(x * np.pi / 180.0, str(x) + '$^\circ$')
for x in PA_bin_edges]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
#Make our log scale r axis start closer to r=0
#setting tick marks and tick labels of the energy per charge/radial axis
radius_ticks = [
(np.log10(x) - log_epq_offset, "{:.1f}".format(x)) for x in epq_edges
] #may cause issue if log(epq) < 0 (negative radius on polar plot...)
grid_locator2 = FixedLocator([v for v, s in radius_ticks])
tick_formatter2 = DictFormatter(dict(radius_ticks))
#Arika's version with the extremes flipped
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(np.max(PA_bin_edges) * np.pi / 180.0, np.min(PA_bin_edges),
np.max(np.log10(epq_edges)) - log_epq_offset,
np.min(np.log10(epq_edges)) - log_epq_offset),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=tick_formatter2)
#version w/o extremes flipped -> doesn't appear to work!
#grid_helper = floating_axes.GridHelperCurveLinear(
# tr, extremes=(np.min(PA_bin_edges),np.max(PA_bin_edges)*np.pi/180.0, np.min(np.log10(epq_edges),np.max(np.log10(epq_edges)))),
# grid_locator1=grid_locator1,
# grid_locator2=grid_locator2,
# tick_formatter1=tick_formatter1,
# tick_formatter2=tick_formatter2)
#grid_helper = floating_axes.GridHelperCurveLinear(
# tr, extremes=(np.pi,0,1,0.5),
# grid_locator1=grid_locator1,
# grid_locator2=grid_locator2,
# tick_formatter1=tick_formatter1,
# tick_formatter2=tick_formatter2)
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
fig.add_subplot(ax1)
#Old way of doing plotting label and ticks
ax1.axis["bottom"].major_ticklabels.set_rotation(180)
ax1.axis["top"].major_ticklabels.set_axis_direction("top")
ax1.axis["top"].label.set_axis_direction("top")
ax1.axis['bottom'].major_ticklabels.set_fontsize(
15) #pitch angle tick label
#after some experimenting, this works!
#bad documentation for this
#new experiemnt with radial text on right hand side
ax1.axis['left'].toggle(
ticklabels=False) #turn off left side radial labels
ax1.axis['right'].label.set_text('E/q (keV/e)')
ax1.axis['right'].label.set_fontsize(15)
ax1.axis['right'].label.set_visible(
True) #turn on right side radial labels
ax1.axis['right'].toggle(ticklabels=True, label='E/q (keV/e)')
ax1.axis['right'].major_ticklabels.set_fontsize(
15) #E/q tick label size, after some guesswork, this works!
#Alternate plotting label and ticks section --> doesn't appear to work!
#adjust x axis (theta):
# ticklabels=True
# thlabel='Pitch Angle'
# rlabel='E/q (keV/e)'
# ax1.axis["bottom"].set_visible(False)
# ax1.axis["top"].set_axis_direction("bottom") # tick direction
# ax1.axis["top"].toggle(ticklabels=ticklabels, label=bool(thlabel))
# ax1.axis["top"].major_ticklabels.set_axis_direction("top")
# ax1.axis["top"].label.set_axis_direction("top")
#
# # adjust y axis (r):
# ax1.axis["left"].set_axis_direction("bottom") # tick direction
# ax1.axis["right"].set_axis_direction("top") # tick direction
# ax1.axis["left"].toggle(ticklabels=ticklabels, label=bool(rlabel))
#
# # add labels:
# ax1.axis["top"].label.set_text(thlabel)
# ax1.axis["left"].label.set_text(rlabel)
#create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
aux_ax.set_axis_bgcolor('k')
###Note from Arika Egan: Not sure why this part is necessary, but it accompanied the example this function was created from, and it doesn't do any harm.
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to prevent this.
return ax1, aux_ax
def create_cg(st, fig=None, subplot=111):
""" Helper function to create curvelinear grid
The function makes use of the Matplotlib AXISARTIST namespace
`mpl_toolkits.axisartist \
<https://matplotlib.org/mpl_toolkits/axes_grid/users/axisartist.html>`_.
Here are some limitations to normal Matplotlib Axes. While using the
Matplotlib `AxesGrid Toolkit \
<https://matplotlib.org/mpl_toolkits/axes_grid/index.html>`_
most of the limitations can be overcome.
See `Matplotlib AxesGrid Toolkit User’s Guide \
<https://matplotlib.org/mpl_toolkits/axes_grid/users/index.html>`_.
Parameters
----------
st : string
scan type, 'PPI' or 'RHI'
fig : matplotlib Figure object
If given, the PPI will be plotted into this figure object. Axes are
created as needed. If None a new figure object will be created or
current figure will be used, depending on "subplot".
subplot : :class:`matplotlib:matplotlib.gridspec.GridSpec`, \
matplotlib grid definition
nrows/ncols/plotnumber, see examples section
defaults to '111', only one subplot
Returns
-------
cgax : matplotlib toolkit axisartist Axes object
curvelinear Axes (r-theta-grid)
caax : matplotlib Axes object (twin to cgax)
Cartesian Axes (x-y-grid) for plotting cartesian data
paax : matplotlib Axes object (parasite to cgax)
The parasite axes object for plotting polar data
"""
if st == 'RHI':
# create transformation
tr = Affine2D().scale(np.pi / 180, 1) + PolarAxes.PolarTransform()
# build up curvelinear grid
extreme_finder = ah.ExtremeFinderCycle(20, 20,
lon_cycle=100,
lat_cycle=None,
lon_minmax=(0, np.inf),
lat_minmax=(0, np.inf),
)
# locator and formatter for angular annotation
grid_locator1 = ah.LocatorDMS(10.)
tick_formatter1 = ah.FormatterDMS()
# grid_helper for curvelinear grid
grid_helper = GridHelperCurveLinear(tr,
extreme_finder=extreme_finder,
grid_locator1=grid_locator1,
grid_locator2=None,
tick_formatter1=tick_formatter1,
tick_formatter2=None,
)
# try to set nice locations for range gridlines
grid_helper.grid_finder.grid_locator2._nbins = 30.0
grid_helper.grid_finder.grid_locator2._steps = [0, 1, 1.5,
2, 2.5, 5, 10]
if st == 'PPI':
# Set theta start to north
tr_rotate = Affine2D().translate(-90, 0)
# set theta running clockwise
tr_scale = Affine2D().scale(-np.pi / 180, 1)
# create transformation
tr = tr_rotate + tr_scale + PolarAxes.PolarTransform()
# build up curvelinear grid
extreme_finder = ah.ExtremeFinderCycle(20, 20,
lon_cycle=360,
lat_cycle=None,
lon_minmax=(360, 0),
lat_minmax=(0, np.inf),
)
# locator and formatter for angle annotation
locs = [i for i in np.arange(0., 359., 10.)]
grid_locator1 = FixedLocator(locs)
tick_formatter1 = DictFormatter(dict([(i, r"${0:.0f}^\circ$".format(i))
for i in locs]))
# grid_helper for curvelinear grid
grid_helper = GridHelperCurveLinear(tr,
extreme_finder=extreme_finder,
grid_locator1=grid_locator1,
grid_locator2=None,
tick_formatter1=tick_formatter1,
tick_formatter2=None,
)
# try to set nice locations for range gridlines
grid_helper.grid_finder.grid_locator2._nbins = 15.0
grid_helper.grid_finder.grid_locator2._steps = [0, 1, 1.5, 2,
2.5,
5,
10]
# if there is no figure object given
if fig is None:
# create new figure if there is only one subplot
if subplot is 111:
fig = pl.figure()
# otherwise get current figure or create new figure
else:
fig = pl.gcf()
# generate Axis
cgax = SubplotHost(fig, subplot, grid_helper=grid_helper)
fig.add_axes(cgax)
# PPIs always plottetd with equal aspect
if st == 'PPI':
cgax.set_aspect('equal', adjustable='box')
# get twin axis for cartesian grid
caax = cgax.twin()
# move axis annotation from right to left and top to bottom for
# cartesian axis
caax.toggle_axisline()
# make right and top axis visible and show ticklabels (curvelinear axis)
cgax.axis["top", "right"].set_visible(True)
cgax.axis["top", "right"].major_ticklabels.set_visible(True)
# make ticklabels of left and bottom axis invisible (curvelinear axis)
cgax.axis["left", "bottom"].major_ticklabels.set_visible(False)
# and also set tickmarklength to zero for better presentation
# (curvelinear axis)
cgax.axis["top", "right", "left", "bottom"].major_ticks.set_ticksize(0)
# show theta (angles) on top and right axis
cgax.axis["top"].get_helper().nth_coord_ticks = 0
cgax.axis["right"].get_helper().nth_coord_ticks = 0
# generate and add parasite axes with given transform
paax = ParasiteAxesAuxTrans(cgax, tr, "equal")
# note that paax.transData == tr + cgax.transData
# Anything you draw in paax will match the ticks and grids of cgax.
cgax.parasites.append(paax)
return cgax, caax, paax
def curved_earth_axes(rect=111,
fig=None,
minground=0.,
maxground=2000,
minalt=0,
maxalt=500,
Re=6371.,
nyticks=5,
nxticks=4):
"""
Create curved axes in ground-range and altitude
Copied from DaViTPy: https://github.com/vtsuperdarn/davitpy/blob/1b578ea2491888e3d97d6e0a8bc6d8cc7c9211fb/davitpy/utils/plotUtils.py#L559
"""
from matplotlib.transforms import Affine2D, Transform
import mpl_toolkits.axisartist.floating_axes as floating_axes
from matplotlib.projections import polar
from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
import numpy as np
from pylab import gcf
ang = maxground / Re
minang = minground / Re
angran = ang - minang
angle_ticks = [(0, "{:.0f}".format(minground))]
while angle_ticks[-1][0] < angran:
tang = angle_ticks[-1][0] + 1. / nxticks * angran
angle_ticks.append((tang, "{:.0f}".format((tang - minang) * Re)))
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
altran = float(maxalt - minalt)
alt_ticks = [(minalt + Re, "{:.0f}".format(minalt))]
while alt_ticks[-1][0] < Re + maxalt:
alt_ticks.append(
(altran / float(nyticks) + alt_ticks[-1][0],
"{:.0f}".format(altran / float(nyticks) + alt_ticks[-1][0] - Re)))
_ = alt_ticks.pop()
grid_locator2 = FixedLocator([v for v, s in alt_ticks])
tick_formatter2 = DictFormatter(dict(alt_ticks))
tr_rotate = Affine2D().rotate(np.pi / 2 - ang / 2)
tr_shift = Affine2D().translate(0, Re)
tr = polar.PolarTransform() + tr_rotate
grid_helper = \
floating_axes.GridHelperCurveLinear(tr, extremes=(0, angran, Re+minalt,
Re+maxalt),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=tick_formatter2,)
if not fig:
fig = gcf()
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
# adjust axis
# ax1.axis["left"].label.set_text(r"Alt. [km]")
# ax1.axis["bottom"].label.set_text(r"Ground range [km]")
ax1.invert_xaxis()
ax1.minground = minground
ax1.maxground = maxground
ax1.minalt = minalt
ax1.maxalt = maxalt
ax1.Re = Re
fig.add_subplot(ax1, transform=tr)
# create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
# for aux_ax to have a clip path as in ax
aux_ax.patch = ax1.patch
# but this has a side effect that the patch is drawn twice, and possibly
# over some other artists. So, we decrease the zorder a bit to prevent this.
ax1.patch.zorder = 0.9
return ax1, aux_ax
gh.grid_finder.grid_locator1 = FixedLocator([
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
20,
22,
25,
30,
35,
40,
50,
60,
70,
80,
90,
])
def get_slice_axes(fig, num, lat1=-90., lat2=90., shrink=1.0):
tr_rotate = Affine2D().translate(0, 90)
# set up polar axis
tr = PolarAxes.PolarTransform() + tr_rotate
angle_ticks = [(np.radians(i), str(i)) for i in np.arange(80, -81, -10)]
# angle_ticks = [(np.radians(80), r"$80$"),
# (np.radians(40), r"$\frac{3}{4}\pi$"),
# (1.*np.pi, r"$\pi$"),
# (1.25*np.pi, r"$\frac{5}{4}\pi$"),
# (1.5*np.pi, r"$\frac{3}{2}\pi$"),
# (1.75*np.pi, r"$\frac{7}{4}\pi$")]
# set up ticks and spacing around the circle
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
# set up grid spacing along the 'radius'
radius_ticks = [
(1., ''),
# (1.5, '%i' % (MAX_R/2.)),
(R / Rb, '')
]
grid_locator2 = FixedLocator([v for v, s in radius_ticks])
tick_formatter2 = DictFormatter(dict(radius_ticks))
# define angle ticks around the circumference:
# set up axis:
# tr: the polar axis setup
# extremes: theta max, theta min, r max, r min
# the grid for the theta axis
# the grid for the r axis
# the tick formatting for the theta axis
# the tick formatting for the r axis
lat1 = np.radians(lat1)
lat2 = np.radians(lat2)
grid_helper = floating_axes.GridHelperCurveLinear(
tr,
extremes=(-lat1, lat2, R / Rb * shrink, 1 * shrink),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=tick_formatter2)
ax1 = floating_axes.FloatingSubplot(fig, num, grid_helper=grid_helper)
fig.add_subplot(ax1)
ax1.axis["left"].set_axis_direction("bottom")
ax1.axis["right"].set_axis_direction("bottom")
ax1.axis["left"].major_ticklabels.set_rotation(90)
#ax1.axis["right"].set_tick_direction('out')
#ax1.axis
# ax1.axis["left"].major_ticks.set_tick_out(True)
# # ax1.axis["bottom"].set_visible(False)
ax1.axis["bottom"].set_axis_direction("right")
ax1.axis["bottom"].major_ticks.set_tick_out(True)
# ax1.axis["bottom"].major_ticklabels.locs_angles_labels = [0, 0, 0, 0,0,0,0]
# print(ax1.axis["bottom"].major_ticklabels._locs_angles_labels)
#ax1.axis["bottom"].major_ticklabels.set_ha('right')
majortick_iter, minortick_iter = ax1.axis[
'bottom']._axis_artist_helper.get_tick_iterators(ax1)
tick_loc_angle, ticklabel_loc_angle_label = ax1.axis[
'bottom']._get_tick_info(majortick_iter)
#ax1.axis["bottom"].major_ticklabels.set_pad(1.0)
aux_ax = ax1.get_aux_axes(tr)
aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax
ax1.patch.zorder = 0.9 # but this has a side effect that the patch is
# drawn twice, and possibly over some other
# artists. So, we decrease the zorder a bit to
# prevent this.
return ax1, aux_ax
cgax.set_ylim(0, 7)
cbar = plt.gcf().colorbar(pm, shrink=0.8, extend='both') #, pad=0.05)
plt.gca().invert_xaxis()
cbar.set_label('Z (dBZ)', fontsize=fft)
caax.set_xlabel('x (km)', fontsize=fft)
caax.set_ylabel('z (km)', fontsize=fft)
cbar.ax.tick_params(labelsize=fft)
caax.tick_params(labelsize=fft)
plt.figtext(xl, yu, 'c) BoXPol RHI \n 2014-10-07, 02:37 UTC', fontsize=fft)
gh = cgax.get_grid_helper()
locs = [0.]
gh.grid_finder.grid_locator1 = FixedLocator(locs)
gh.grid_finder.tick_formatter1 = DictFormatter(
dict([(i, r"${0:.0f}^\circ$".format(i)) for i in locs]))
plt.yticks(fontsize=fft)
plt.xticks(fontsize=fft)
plt.tight_layout()
plt.show()
'''
grid_gpm_xy2 = np.vstack((gpm_x[:,cut].ravel(), gpm_y.ravel())).transpose() # GPM Grid erschaffen
xxxyyy = np.vstack((xxx[0:-1,0:-1].ravel(), yyy[0:-1,0:-1].ravel())).transpose()
mask1 = ~np.isnan(ma)
result2 = wrl.ipol.interpolate(xxxyyy, grid_gpm_xy2, ma[mask1].reshape(ma.shape[0]*ma.shape[1],1), wrl.ipol.Idw, nnearest=4) #Idw
def taylor_normalized(scores, colors, angle_lim):
import mpl_toolkits.axisartist.floating_axes as floating_axes
from matplotlib.projections import PolarAxes
from mpl_toolkits.axisartist.grid_finder import (FixedLocator,
DictFormatter)
fig = plt.figure()
tr = PolarAxes.PolarTransform()
min_corr = np.round(np.cos(angle_lim), 1)
CCgrid = np.concatenate(
(np.arange(min_corr * 10, 10, 2.0) / 10., [0.9, 0.95, 0.99]))
CCpolar = np.arccos(CCgrid)
gf = FixedLocator(CCpolar)
tf = DictFormatter(dict(zip(CCpolar, map(str, CCgrid))))
STDgrid = np.arange(0, 2.0, .5)
gfs = FixedLocator(STDgrid)
tfs = DictFormatter(dict(zip(STDgrid, map(str, STDgrid))))
ra0, ra1 = 0, angle_lim
cz0, cz1 = 0, 2
grid_helper = floating_axes.GridHelperCurveLinear(tr,
extremes=(ra0, ra1, cz0,
cz1),
grid_locator1=gf,
tick_formatter1=tf,
grid_locator2=gfs,
tick_formatter2=tfs)
ax1 = floating_axes.FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_subplot(ax1)
ax1.axis["top"].set_axis_direction("bottom")
ax1.axis["top"].toggle(ticklabels=True, label=True)
ax1.axis["top"].major_ticklabels.set_axis_direction("top")
ax1.axis["top"].label.set_axis_direction("top")
ax1.axis["top"].label.set_text("Correlation")
ax1.axis['top'].label.set_size(14)
ax1.axis["left"].set_axis_direction("bottom")
ax1.axis["left"].label.set_text("Normalized Standard Deviation")
ax1.axis['left'].label.set_size(14)
ax1.axis["right"].set_axis_direction("top")
ax1.axis["right"].toggle(ticklabels=True)
ax1.axis["right"].major_ticklabels.set_axis_direction("left")
ax1.axis["bottom"].set_visible(False)
ax1 = ax1.get_aux_axes(tr)
plt.grid(linestyle=':', alpha=0.5)
for i, r in enumerate(scores.iterrows()):
theta = np.arccos(r[1].CORRELATION)
rr = r[1].MSTD / r[1].OSTD
print(rr)
print(theta)
ax1.plot(theta, rr, 'o', label=r[0], color=colors[i])
ax1.plot(0, 1, 'o', label='Obs')
plt.legend(loc='upper right', bbox_to_anchor=[1.3, 1.15])
plt.show()
rs, ts = np.meshgrid(np.linspace(0, 2), np.linspace(0, angle_lim))
rms = np.sqrt(1 + rs**2 - 2 * rs * np.cos(ts))
ax1.contour(ts, rs, rms, 3, colors='0.5')
#contours = ax1.contour(ts, rs, rms,3,colors='0.5')
#plt.clabel(contours, inline=1, fontsize=10)
plt.grid(linestyle=':', alpha=0.5)
for i, r in enumerate(scores.iterrows()):
crmse = np.sqrt(1 + (r[1].MSTD/scores.OSTD[i])**2 \
- 2*(r[1].MSTD/scores.OSTD[i])*r[1].CORRELATION)
print(crmse)
c1 = ax1.contour(ts, rs, rms, [crmse], colors=colors[i])
plt.clabel(c1, inline=1, fontsize=10, fmt='%1.2f')
def curvedEarthAxes(rect=111,
fig=None,
minground=0.,
maxground=2000,
minalt=0,
maxalt=500,
Re=6371.,
nyticks=5,
nxticks=4):
"""Create curved axes in ground-range and altitude
Parameters
----------
rect : Optional[int]
subplot spcification
fig : Optional[pylab.figure object]
(default to gcf)
minground : Optional[float]
maxground : Optional[int]
maximum ground range [km]
minalt : Optional[int]
lowest altitude limit [km]
maxalt : Optional[int]
highest altitude limit [km]
Re : Optional[float]
Earth radius in kilometers
nyticks : Optional[int]
Number of y axis tick marks; default is 5
nxticks : Optional[int]
Number of x axis tick marks; deafult is 4
Returns
-------
ax : matplotlib.axes object
containing formatting
aax : matplotlib.axes object
containing data
Example
-------
import numpy as np
from utils import plotUtils
ax, aax = plotUtils.curvedEarthAxes()
th = np.linspace(0, ax.maxground/ax.Re, 50)
r = np.linspace(ax.Re+ax.minalt, ax.Re+ax.maxalt, 20)
Z = exp( -(r - 300 - ax.Re)**2 / 100**2 ) * np.cos(th[:, np.newaxis]/th.max()*4*np.pi)
x, y = np.meshgrid(th, r)
im = aax.pcolormesh(x, y, Z.T)
ax.grid()
written by Sebastien, 2013-04
"""
from matplotlib.transforms import Affine2D, Transform
import mpl_toolkits.axisartist.floating_axes as floating_axes
from matplotlib.projections import polar
from mpl_toolkits.axisartist.grid_finder import FixedLocator, DictFormatter
import numpy as np
from pylab import gcf
ang = maxground / Re
minang = minground / Re
angran = ang - minang
angle_ticks = [(0, "{:.0f}".format(minground))]
while angle_ticks[-1][0] < angran:
tang = angle_ticks[-1][0] + 1. / nxticks * angran
angle_ticks.append((tang, "{:.0f}".format((tang - minang) * Re)))
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
altran = float(maxalt - minalt)
alt_ticks = [(minalt + Re, "{:.0f}".format(minalt))]
while alt_ticks[-1][0] < Re + maxalt:
alt_ticks.append(
(altran / float(nyticks) + alt_ticks[-1][0],
"{:.0f}".format(altran / float(nyticks) + alt_ticks[-1][0] - Re)))
_ = alt_ticks.pop()
grid_locator2 = FixedLocator([v for v, s in alt_ticks])
tick_formatter2 = DictFormatter(dict(alt_ticks))
tr_rotate = Affine2D().rotate(np.pi / 2 - ang / 2)
tr_shift = Affine2D().translate(0, Re)
tr = polar.PolarTransform() + tr_rotate
grid_helper = \
floating_axes.GridHelperCurveLinear(tr, extremes=(0, angran, Re+minalt,
Re+maxalt),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=tick_formatter2,)
if not fig: fig = gcf()
ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper)
# adjust axis
ax1.axis["left"].label.set_text(r"Alt. [km]")
ax1.axis["bottom"].label.set_text(r"Ground range [km]")
ax1.invert_xaxis()
ax1.minground = minground
ax1.maxground = maxground
ax1.minalt = minalt
ax1.maxalt = maxalt
ax1.Re = Re
fig.add_subplot(ax1, transform=tr)
# create a parasite axes whose transData in RA, cz
aux_ax = ax1.get_aux_axes(tr)
# for aux_ax to have a clip path as in ax
aux_ax.patch = ax1.patch
# but this has a side effect that the patch is drawn twice, and possibly
# over some other artists. So, we decrease the zorder a bit to prevent this.
ax1.patch.zorder = 0.9
return ax1, aux_ax
import numpy as np
# well, it's a wradlib example
import wradlib
from mpl_toolkits.axisartist.grid_finder import FixedLocator
# reading in data, range and theta arrays from special rhi hdf5 file
file = '../../examples/data/polar_rhi_dBZ_bonn.h5'
data, meta = wradlib.io.from_hdf5(file, dataset='data')
r, meta = wradlib.io.from_hdf5(file, dataset='range')
th, meta = wradlib.io.from_hdf5(file, dataset='theta')
# mask data array for better presentation
mask_ind = np.where(data <= np.nanmin(data))
data[mask_ind] = np.nan
ma = np.ma.array(data, mask=np.isnan(data))
subplots = [221, 222, 223, 224]
for sp in subplots:
cgax, caax, paax, pm = wradlib.vis.plot_cg_rhi(ma,
r, th, rf=1e3, autoext=True,
refrac=False, subplot=sp)
t = plt.title('CG RHI #%(sp)d' %locals())
t.set_y(1.1)
cgax.set_ylim(0, 15)
cbar = plt.gcf().colorbar(pm, pad=0.125)
caax.set_xlabel('range [km]')
caax.set_ylabel('height [km]')
gh = cgax.get_grid_helper()
# set theta to some nice values
gh.grid_finder.grid_locator1 = FixedLocator([0, 5, 10, 15, 20, 30, 40, 60, 90,])
cbar.set_label('reflectivity [dBZ]')
plt.tight_layout()
plt.draw()
plt.show()
rmesh = np.loadtxt(response.readlines())[::4]
response.close()
np.save('data/hmi_rmesh.npy', rmesh)
# rot2d has 49 columns, latitudes are 90-i*15/8; i starts at 0
lat = np.array([15./8.*i for i in np.arange(49)])/180.*np.pi
r, th = np.meshgrid(rmesh, lat)
# adapted from
# http://matplotlib.org/examples/axes_grid/demo_floating_axes.html
fig = pl.gcf()
tr = PolarAxes.PolarTransform()
angle_ticks = [(0.0, r"$0^\circ$"),
(0.25*np.pi, r"$45^\circ$"),
(0.5*np.pi, r"$90^\circ$")]
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
grid_locator2 = MaxNLocator(2)
grid_helper = floating_axes.GridHelperCurveLinear(
tr, extremes=(0, 0.5*np.pi, 0, 1),
grid_locator1=grid_locator1,
grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1,
tick_formatter2=None)
ax1 = floating_axes.FloatingSubplot(fig, 111, grid_helper=grid_helper)
fig.add_subplot(ax1)
ax1.axis["left"].set_axis_direction("bottom")
