def _set_lim_and_transforms(self):
"""
Overrides the method with the same name in the PolarAxes-class.
This method replaces the same method in the PolarAxes-class. It ensures
that the limits and label placement fit the north-polar projection.
"""
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.NorthPolarTransform()
# pylint: attribute-defined-outside-init,invalid-name
self.transData = (
self.transScale +
self.transProjection +
(self.transProjectionAffine + self.transAxes))
# pylint: attribute-defined-outside-init,invalid-name
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes) # pylint: attribute-defined-outside-init
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform) # pylint: attribute-defined-outside-init
self._yaxis_transform = (
Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData) # pylint: attribute-defined-outside-init
self._yaxis_text1_transform = (
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform) # pylint: attribute-defined-outside-init
def _set_lim_and_transforms(self):
PolarAxes._set_lim_and_transforms(self)
try:
theta_position = self._theta_label1_position
except AttributeError:
theta_position = self.get_theta_offset()
self.transProjection = self.GlobeCrossSectionTransform()
self.transData = (
self.transScale +
self.transProjection +
(self.transProjectionAffine + self.transAxes))
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes)
self._xaxis_text1_transform = (
theta_position +
self._xaxis_transform)
self._yaxis_transform = (
Affine2D().scale(num.pi * 2.0, 1.0) +
self.transData)
try:
rlp = getattr(self, '_r_label1_position')
except AttributeError:
rlp = getattr(self, '_r_label_position')
self._yaxis_text1_transform = (
rlp +
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform)
def _set_lim_and_transforms(self): PolarAxes._set_lim_and_transforms(self) self.transProjection = self.NorthPolarTransform() self.axisProjection = self.NorthPolarAxisTransform() self.transData = ( Affine2D().scale(numpy.pi/180.0, 1.0/90.0) + self.transScale + self.transProjection + (self.transProjectionAffine + self.transAxes)) self._xaxis_pretransform = ( Affine2D().scale(1.0, 1.0) ) self._xaxis_transform = ( self._xaxis_pretransform + self.axisProjection + self.PolarAffine(IdentityTransform(), Bbox.unit()) + self.transAxes) self._xaxis_text1_transform = ( self._theta_label1_position + self._xaxis_transform) self._yaxis_transform = ( Affine2D().scale(numpy.pi*2.0, 1.0) + self.transScale + self.axisProjection + (self.transProjectionAffine + self.transAxes)) self._yaxis_text1_transform = ( self._r_label1_position + Affine2D().translate(0.0, -0.051) + self._yaxis_transform)
def _set_lim_and_transforms(self):
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.GlobeCrossSectionTransform(GlobeCrossSectionAxes.RESOLUTION)
self.transData = self.transScale + self.transProjection + (self.transProjectionAffine + self.transAxes)
self._xaxis_transform = (
self.transProjection + self.PolarAffine(IdentityTransform(), Bbox.unit()) + self.transAxes
)
self._xaxis_text1_transform = self._theta_label1_position + self._xaxis_transform
self._yaxis_transform = Affine2D().scale(num.pi * 2.0, 1.0) + self.transData
self._yaxis_text1_transform = (
self._r_label1_position + Affine2D().scale(1.0 / 360.0, 1.0) + self._yaxis_transform
)
def _set_lim_and_transforms(self):
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.NorthPolarTransform()
self.transData = (
self.transScale +
self.transProjection +
(self.transProjectionAffine + self.transAxes))
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes)
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform)
self._yaxis_transform = (
Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData)
def _set_lim_and_transforms(self):
"""
"""
PolarAxes._set_lim_and_transforms(self)
self.transProjection = self.DipPolarTransform()
# pylint: attribute-defined-outside-init,invalid-name
self.transData = (
self.transScale +
self.transProjection +
(self.transProjectionAffine + self.transAxes))
# pylint: attribute-defined-outside-init,invalid-name
self._xaxis_transform = (
self.transProjection +
self.PolarAffine(IdentityTransform(), Bbox.unit()) +
self.transAxes) # pylint: attribute-defined-outside-init
self._xaxis_text1_transform = (
self._theta_label1_position +
self._xaxis_transform) # pylint: attribute-defined-outside-init
self._yaxis_transform = (
Affine2D().scale(np.pi * 2.0, 1.0) +
self.transData) # pylint: attribute-defined-outside-init
self._yaxis_text1_transform = (
Affine2D().scale(1.0 / 360.0, 1.0) +
self._yaxis_transform) # pylint: attribute-defined-outside-init
def curvelinear_test2(fig):
"""
Polar projection, but in a rectangular box.
"""
# PolarAxes.PolarTransform takes radian. However, we want our coordinate
# system in degree
tr = Affine2D().scale(np.pi / 180, 1) + PolarAxes.PolarTransform()
# Polar projection, which involves cycle, and also has limits in
# its coordinates, needs a special method to find the extremes
# (min, max of the coordinate within the view).
extreme_finder = angle_helper.ExtremeFinderCycle(
nx=20,
ny=20, # Number of sampling points in each direction.
lon_cycle=360,
lat_cycle=None,
lon_minmax=None,
lat_minmax=(0, np.inf),
)
# Find grid values appropriate for the coordinate (degree, minute, second).
grid_locator1 = angle_helper.LocatorDMS(12)
# Use an appropriate formatter. Note that the acceptable Locator and
# Formatter classes are a bit different than that of Matplotlib, which
# cannot directly be used here (this may be possible in the future).
tick_formatter1 = angle_helper.FormatterDMS()
grid_helper = GridHelperCurveLinear(tr,
extreme_finder=extreme_finder,
grid_locator1=grid_locator1,
tick_formatter1=tick_formatter1)
ax1 = SubplotHost(fig, 1, 2, 2, grid_helper=grid_helper)
# make ticklabels of right and top axis visible.
ax1.axis["right"].major_ticklabels.set_visible(True)
ax1.axis["top"].major_ticklabels.set_visible(True)
# let right axis shows ticklabels for 1st coordinate (angle)
ax1.axis["right"].get_helper().nth_coord_ticks = 0
# let bottom axis shows ticklabels for 2nd coordinate (radius)
ax1.axis["bottom"].get_helper().nth_coord_ticks = 1
fig.add_subplot(ax1)
ax1.set_aspect(1)
ax1.set_xlim(-5, 12)
ax1.set_ylim(-5, 10)
ax1.grid(True, zorder=0)
# A parasite axes with given transform
ax2 = ParasiteAxesAuxTrans(ax1, tr, "equal")
# note that ax2.transData == tr + ax1.transData
# Anything you draw in ax2 will match the ticks and grids of ax1.
ax1.parasites.append(ax2)
ax2.plot(np.linspace(0, 30, 51), np.linspace(10, 10, 51), linewidth=2)
ax2.pcolor(np.linspace(0, 90, 4), np.linspace(0, 10, 4),
np.arange(9).reshape((3, 3)))
ax2.contour(np.linspace(0, 90, 4),
np.linspace(0, 10, 4),
np.arange(16).reshape((4, 4)),
colors="k")
def create_cg(
fig=None,
subplot=111,
rot=-450,
scale=-1,
angular_spacing=10,
radial_spacing=10,
latmin=0,
lon_cycle=360,
):
""" 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
----------
fig : matplotlib Figure object
If given, the PPI/RHI 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
rot : float
Rotation of the source data in degrees, defaults to -450 for PPI,
use 0 for RHI
scale : float
Scale of source data, defaults to -1. for PPI, use 1 for RHI
angular_spacing : float
Spacing of the angular grid, defaults to 10.
radial_spacing : float
Spacing of the radial grid, defaults to 10.
latmin : float
Startvalue for radial grid, defaults to 0.
lon_cycle : float
Angular cycle, defaults to 360.
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
"""
# create transformation
# rotate
tr_rotate = Affine2D().translate(rot, 0)
# scale
tr_scale = Affine2D().scale(scale * np.pi / 180, 1)
# polar
tr_polar = PolarAxes.PolarTransform()
tr = tr_rotate + tr_scale + tr_polar
# build up curvelinear grid
extreme_finder = ah.ExtremeFinderCycle(
360,
360,
lon_cycle=lon_cycle,
lat_cycle=None,
lon_minmax=None,
lat_minmax=(latmin, np.inf),
)
# locator and formatter for angular annotation
grid_locator1 = ah.LocatorDMS(lon_cycle // angular_spacing)
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 radial gridlines
grid_locator2 = grid_helper.grid_finder.grid_locator2
grid_locator2._nbins = (radial_spacing * 2 + 1) // np.sqrt(2)
# if there is no figure object given
if fig is None:
# create new figure if there is only one subplot
if subplot == 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)
# 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 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, '{}_chart.png'.format(name)),
transparent=False,
bbox_inches='tight',
pad_inches=0.1,
dpi=dpi)
if color_limits:
return 1., new_data_angle_dist.max()
def get_smith(fig,
rect=111,
plot_impedance=True,
plot_ticks=False,
plot_admittance=False,
plot_labels=False):
'''Function which returns an axis with a blank smith chart, provide a figure and optional rect coords'''
#Example use:
# fig3 = plt.figure(3)
# ax31 = pySmith.get_smith(fig3, 221)
# ax31.plot(np.real(filtsmatrix[0,:,0,0]),np.imag(filtsmatrix[0,:,0,0]))
# ax32= pySmith.get_smith(fig3, 222)
# ax32.plot(np.real(filtsmatrix[0,:,0,1]),np.imag(filtsmatrix[0,:,0,1]))
# ax33 = pySmith.get_smith(fig3, 223)
# ax33.plot(np.real(filtsmatrix[0,:,1,0]),np.imag(filtsmatrix[0,:,1,0]))
# ax34 = pySmith.get_smith(fig3, 224)
# ax34.plot(np.real(filtsmatrix[0,:,1,1]),np.imag(filtsmatrix[0,:,1,1]))
try:
#font definition
font = {
'family': 'sans-serif',
'color': 'black',
'weight': 'normal',
'size': 16,
}
#plot radial tick marks
tr = PolarAxes.PolarTransform()
num_thetas = 8 #*3 #12 gives in 30 deg intervals, 8 in 45 deg, 24 in 15deg
thetas = np.linspace(0.0, math.pi * (1 - 2.0 / num_thetas),
num_thetas // 2)
angle_ticks = [] #(0, r"$0$"),
for theta in thetas:
angle_info = []
angle_info.append(theta)
deg = int(round(180.0 * theta / math.pi))
angle_info.append(r'%d$^{\circ}$' % deg)
angle_ticks.append(angle_info)
grid_locator1 = FixedLocator([v for v, s in angle_ticks])
tick_formatter1 = DictFormatter(dict(angle_ticks))
thetas2 = np.linspace(math.pi, 2 * math.pi * (1 - 1.0 / num_thetas),
num_thetas // 2)
angle_ticks2 = [] #(0, r"$0$"),
for theta in thetas2:
angle_info = []
angle_info.append(theta)
deg = int(round(180.0 * theta / math.pi))
angle_info.append(r'%d$^{\circ}$' % deg)
angle_ticks2.append(angle_info)
grid_locator2 = FixedLocator([v for v, s in angle_ticks2])
tick_formatter2 = DictFormatter(dict(angle_ticks2))
grid_helper1 = floating_axes.GridHelperCurveLinear(
tr,
extremes=(math.pi, 0, 1, 0),
grid_locator1=grid_locator1,
#grid_locator2=grid_locator2,
tick_formatter1=tick_formatter1 #,
#tick_formatter2=None,
)
grid_helper2 = floating_axes.GridHelperCurveLinear(
tr,
extremes=(2 * math.pi, math.pi, 1, 0),
grid_locator1=grid_locator2,
#grid_locator2=grid_locator2,
tick_formatter1=tick_formatter2 #,
#tick_formatter2=None,
)
r1 = int(math.floor(rect / 100))
r2 = int(math.floor((rect - 100 * r1) / 10))
r3 = int(math.floor((rect - 100 * r1 - 10 * r2)))
ax = SubplotHost(fig, r1, r2, r3, grid_helper=grid_helper1)
ax2 = SubplotHost(fig, r1, r2, r3, grid_helper=grid_helper2)
#ax.set_aspect(math.pi/180.0,'datalim')
fig.add_subplot(ax)
fig.add_subplot(ax2)
ax.axis["bottom"].major_ticklabels.set_axis_direction("top")
ax.axis["bottom"].major_ticklabels.set_fontsize(13)
ax.axis["left"].set_visible(False)
ax.axis["left"].toggle(all=False)
ax.axis["right"].set_visible(False)
ax.axis["right"].toggle(all=False)
ax.axis["top"].set_visible(False)
ax.axis["top"].toggle(all=False)
ax.patch.set_visible(False)
ax2.axis["bottom"].major_ticklabels.set_fontsize(13)
ax2.axis["left"].set_visible(False)
ax2.axis["left"].toggle(all=False)
ax2.axis["right"].set_visible(False)
ax2.axis["right"].toggle(all=False)
ax2.axis["top"].set_visible(False)
ax2.axis["top"].toggle(all=False)
#ax = fig.add_subplot(rect)
#remove axis labels
ax.axis('off')
#set aspect ratio to 1
ax.set_aspect(1) #, 'datalim')
#set limits
ax.set_xlim([-1.02, 1.02])
ax.set_ylim([-1.02, 1.02])
#remove axis labels
ax2.axis('off')
#set aspect ratio to 1
ax2.set_aspect(1) #,'datalim')
#set limits
ax2.set_xlim([-1.02, 1.02])
ax2.set_ylim([-1.02, 1.02])
ax2.patch.set_visible(False)
if plot_impedance:
#make lines of constant resistance
res_log = np.linspace(-4, 4, 9)
react_log = np.linspace(-5, 5, 2001)
res = 2**res_log
react = 10**react_log
react2 = np.append(-1.0 * react[::-1], np.array([0]))
react = np.append(react2, react)
for r in res:
z = 1j * react + r
gam = (z - 1) / (z + 1)
x = np.real(gam)
y = np.imag(gam)
if abs(r - 1) > 1e-6:
ax.plot(x, y, c='k', linewidth=0.75, alpha=0.25)
else:
ax.plot(x, y, c='k', linewidth=1.0, alpha=0.4)
#make lines of constant reactance
react_log = np.linspace(-3, 3, 7)
res_log = np.linspace(-5, 5, 2001)
res = 10**res_log
react = 2**react_log
react2 = np.append(-1.0 * react[::-1], np.array([0]))
react = np.append(react2, react)
for chi in react:
z = 1j * chi + res
gam = (z - 1) / (z + 1)
x = np.real(gam)
y = np.imag(gam)
if abs(chi - 1) > 1e-6 and abs(chi +
1) > 1e-6 and abs(chi) > 1e-6:
ax.plot(x, y, c='k', linewidth=0.75, alpha=0.25)
else:
ax.plot(x, y, c='k', linewidth=1.0, alpha=0.4)
if plot_admittance:
#make lines of constant conductance
res_log = np.linspace(-4, 4, 9)
react_log = np.linspace(-5, 5, 2001)
res = 2**res_log
react = 10**react_log
react = np.append(-1.0 * react[::-1], react)
for r in res:
y = 1.0 / r + 1.0 / (1j * react)
gam = (1.0 / y - 1) / (1.0 / y + 1)
x = np.real(gam)
y = np.imag(gam)
if abs(r - 1) > 1e-6:
ax.plot(x, y, c='k', linewidth=0.75, alpha=0.25)
else:
ax.plot(x, y, c='k', linewidth=1.0, alpha=0.4)
#make lines of constant susceptance
react_log = np.linspace(-3, 3, 7)
res_log = np.linspace(-5, 5, 2001)
res = 10**res_log
react = 2**react_log
react = np.append(-1.0 * react[::-1], react)
for chi in react:
y = 1.0 / (1j * chi) + 1.0 / res
gam = (1.0 / y - 1) / (1.0 / y + 1)
x = np.real(gam)
y = np.imag(gam)
if abs(chi - 1) > 1e-6 and abs(chi + 1) > 1e-6:
ax.plot(x, y, c='k', linewidth=0.75, alpha=0.25)
else:
ax.plot(x, y, c='k', linewidth=1.0, alpha=0.4)
y = 1.0 / res
gam = (1.0 / y - 1) / (1.0 / y + 1)
x = np.real(gam)
y = np.imag(gam)
ax.plot(x, y, c='k', linewidth=1.0, alpha=0.75)
if plot_labels:
#naive text placement only works for default python figure size with 1 subplot
ax.text(-0.15, 1.04, r'$\Gamma$ = 1j', fontdict=font)
ax.text(-1.4, -0.035, r'$\Gamma$ = -1', fontdict=font)
ax.text(-0.17, -1.11, r'$\Gamma$ = -1j', fontdict=font)
ax.text(1.04, -0.035, r'$\Gamma$ = 1', fontdict=font)
if plot_ticks:
num_minorticks = 3
num_thetas = num_thetas * (num_minorticks + 1)
thetas = np.linspace(0, 2.0 * math.pi * (1.0 - 1.0 / num_thetas),
num_thetas)
r_inner = 0.985
r_outer = 1.0
rads = np.linspace(r_inner, r_outer, 2)
ticknum = 0
for theta in thetas:
x = rads * np.cos(theta)
y = rads * np.sin(theta)
if ticknum % (num_minorticks + 1) != 0:
ax.plot(x, y, c='k', linewidth=1.0, alpha=1.0)
ticknum = ticknum + 1
return ax
except Exception as e:
print('\nError in %s' % inspect.stack()[0][3])
print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
def __init__(self, *args, **kwargs): self.lon_degs = 45 self.lat_degs = 15 PolarAxes.__init__(self, *args, **kwargs)
def __init__(self, refstd, fig=None, rect=111, label='_'):
"""
Set up Taylor diagram axes, i.e. single quadrant polar
plot, using mpl_toolkits.axisartist.floating_axes. refstd is
the reference standard deviation to be compared to.
"""
from matplotlib.projections import PolarAxes
from mpl_toolkits.axisartist import floating_axes
from mpl_toolkits.axisartist import grid_finder
self.refstd = refstd # Reference standard deviation.
tr = PolarAxes.PolarTransform()
# Correlation labels.
rlocs = np.concatenate((np.arange(10)/10., [0.95, 0.99]))
tlocs = np.arccos(rlocs) # Conversion to polar angles.
gl1 = grid_finder.FixedLocator(tlocs) # Positions.
dict_formatter = {
list(zip(tlocs, map(str, rlocs)))
}
tf1 = grid_finder.DictFormatter(dict_formatter)
# Standard deviation axis extent.
self.smin = 0
self.smax = 1.5*self.refstd
extremes = (0,
np.pi/2, # 1st quadrant.
self.smin,
self.smax)
ghelper = floating_axes.GridHelperCurveLinear(tr,
extremes=extremes,
grid_locator1=gl1,
tick_formatter1=tf1)
if fig is None:
fig = plt.figure()
ax = floating_axes.FloatingSubplot(fig, rect, grid_helper=ghelper)
fig.add_subplot(ax)
# Adjust axes.
ax.axis['top'].set_axis_direction('bottom') # Angle axis.
ax.axis['top'].toggle(ticklabels=True, label=True)
ax.axis['top'].major_ticklabels.set_axis_direction('top')
ax.axis['top'].label.set_axis_direction('top')
ax.axis['top'].label.set_text('Correlation')
ax.axis['left'].set_axis_direction('bottom') # X axis.
ax.axis['left'].label.set_text('Standard deviation')
ax.axis['right'].set_axis_direction('top') # Y axis.
ax.axis['right'].toggle(ticklabels=True)
ax.axis['right'].major_ticklabels.set_axis_direction('left')
ax.axis['bottom'].set_visible(False) # Useless.
# Contours along standard deviations.
ax.grid(False)
self._ax = ax # Graphical axes.
self.ax = ax.get_aux_axes(tr) # Polar coordinates.
# Add reference point and stddev contour.
l, = self.ax.plot([0], self.refstd, 'ko',
ls='', ms=10, label=label)
t = np.linspace(0, np.pi/2)
r = np.zeros_like(t) + self.refstd
self.ax.plot(t, r, 'k--', label='_')
# Collect sample points for latter use (e.g. legend).
self.samplePoints = [l]
def cla(self):
PolarAxes.cla(self)
self.set_thetagrids([0, 15, 30, 45, 60, 75, 90])
def TaylorDiagram(stddev,
corrcoef,
refstd,
fig,
colors,
normalize=True,
position=111):
"""Plot a Taylor diagram.
This is adapted from the code by Yannick Copin found here:
https://gist.github.com/ycopin/3342888
Parameters
----------
stddev : numpy.ndarray
an array of standard deviations
corrcoeff : numpy.ndarray
an array of correlation coefficients
refstd : float
the reference standard deviation
fig : matplotlib figure
the matplotlib figure
colors : array
an array of colors for each element of the input arrays
normalize : bool, optional
disable to skip normalization of the standard deviation
"""
from matplotlib.projections import PolarAxes
import mpl_toolkits.axisartist.floating_axes as FA
import mpl_toolkits.axisartist.grid_finder as GF
# define transform
tr = PolarAxes.PolarTransform()
# correlation labels
rlocs = np.concatenate((np.arange(10) / 10., [0.95, 0.99]))
tlocs = np.arccos(rlocs)
gl1 = GF.FixedLocator(tlocs)
tf1 = GF.DictFormatter(dict(zip(tlocs, map(str, rlocs))))
# standard deviation axis extent
if normalize:
stddev = stddev / refstd
refstd = 1.
smin = 0
smax = max(2.0, 1.1 * stddev.max())
# add the curvilinear grid
ghelper = FA.GridHelperCurveLinear(tr,
extremes=(0, np.pi / 2, smin, smax),
grid_locator1=gl1,
tick_formatter1=tf1)
ax = FA.FloatingSubplot(fig, position, grid_helper=ghelper)
fig.add_subplot(ax)
# adjust axes
ax.axis["top"].set_axis_direction("bottom")
ax.axis["top"].toggle(ticklabels=True, label=True)
ax.axis["top"].major_ticklabels.set_axis_direction("top")
ax.axis["top"].label.set_axis_direction("top")
ax.axis["top"].label.set_text("Correlation")
ax.axis["left"].set_axis_direction("bottom")
if normalize:
ax.axis["left"].label.set_text("Normalized standard deviation")
else:
ax.axis["left"].label.set_text("Standard deviation")
ax.axis["right"].set_axis_direction("top")
ax.axis["right"].toggle(ticklabels=True)
ax.axis["right"].major_ticklabels.set_axis_direction("left")
ax.axis["bottom"].set_visible(False)
ax.grid(True)
aux = ax.get_aux_axes(tr)
# Plot data
corrcoef = corrcoef.clip(-1, 1)
for i in range(len(corrcoef)):
aux.plot(np.arccos(corrcoef[i]),
stddev[i],
'o',
color=colors[i],
mew=0,
ms=8)
# Add reference point and stddev contour
l, = aux.plot([0], refstd, 'k*', ms=12, mew=0)
t = np.linspace(0, np.pi / 2)
r = np.zeros_like(t) + refstd
aux.plot(t, r, 'k--')
# centralized rms contours
rs, ts = np.meshgrid(np.linspace(smin, smax), np.linspace(0, np.pi / 2))
rms = np.sqrt(refstd**2 + rs**2 - 2 * refstd * rs * np.cos(ts))
contours = aux.contour(ts, rs, rms, 5, colors='k', alpha=0.4)
aux.clabel(contours, fmt='%1.1f')
return ax, aux
def fractional_polar_axes(f, thlim=(0, 180), rlim=(0, 1), step=(30, 0.2),
thlabel=None, rlabel=None, ticklabels=False):
"""Return polar axes that adhere to desired theta (in deg) and r limits. steps for theta
and r are really just hints for the locators."""
th0, th1 = thlim # deg
r0, r1 = rlim
thstep, rstep = step
# scale degrees to radians:
tr_scale = Affine2D().scale(np.pi/180., 1.)
tr = tr_scale + PolarAxes.PolarTransform()
theta_grid_locator = angle_helper.LocatorDMS((th1-th0)//thstep)
r_grid_locator = MaxNLocator((r1-r0)//rstep)
theta_tick_formatter = angle_helper.FormatterDMS()
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=None)
a = FloatingSubplot(f, 111, grid_helper=grid_helper)
f.add_subplot(a)
# adjust x axis (theta):
a.axis["bottom"].set_visible(False)
a.axis["top"].set_axis_direction("bottom") # tick direction
a.axis["top"].toggle(ticklabels=ticklabels, label=bool(thlabel))
a.axis["top"].major_ticklabels.set_axis_direction("top")
a.axis["top"].label.set_axis_direction("top")
# adjust y axis (r):
a.axis["left"].set_axis_direction("bottom") # tick direction
a.axis["right"].set_axis_direction("top") # tick direction
a.axis["left"].toggle(ticklabels=ticklabels, label=bool(rlabel))
# add labels:
a.axis["top"].label.set_text(thlabel)
a.axis["left"].label.set_text(rlabel)
# create a parasite axes whose transData is theta, r:
auxa = a.get_aux_axes(tr)
# make aux_ax to have a clip path as in a?:
auxa.patch = a.patch
# 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:
a.patch.zorder = -2
# add sector lines for both dimensions:
thticks = grid_helper.grid_info['lon_info'][0]
rticks = grid_helper.grid_info['lat_info'][0]
for th in thticks[1:-1]: # all but the first and last
auxa.plot([th, th], [r0, r1], '--', c='grey', zorder=-1)
for ri, r in enumerate(rticks):
# plot first r line as axes border in solid black only if it isn't at r=0
if ri == 0 and r != 0:
ls, lw, color = 'solid', 2, 'black'
else:
ls, lw, color = 'dashed', 1, 'grey'
# From http://stackoverflow.com/a/19828753/2020363
auxa.add_artist(plt.Circle([0, 0], radius=r, ls=ls, lw=lw, color=color, fill=False,
transform=auxa.transData._b, zorder=-1))
return auxa
def curvelinear_test2(fig):
"""
polar projection, but in a rectangular box.
"""
# PolarAxes.PolarTransform takes radian. However, we want our coordinate
# system in degree
tr = Affine2D().scale(np.pi / 180., 1.) + PolarAxes.PolarTransform()
# polar projection, which involves cycle, and also has limits in
# its coordinates, needs a special method to find the extremes
# (min, max of the coordinate within the view).
# 20, 20 : number of sampling points along x, y direction
extreme_finder = angle_helper.ExtremeFinderCycle(
20,
20,
lon_cycle=360,
lat_cycle=None,
lon_minmax=None,
lat_minmax=(0, np.inf),
)
grid_locator1 = angle_helper.LocatorDMS(12)
# Find a grid values appropriate for the coordinate (degree,
# minute, second).
tick_formatter1 = angle_helper.FormatterDMS()
# And also uses an appropriate formatter. Note that,the
# acceptable Locator and Formatter class is a bit different than
# that of mpl's, and you cannot directly use mpl's Locator and
# Formatter here (but may be possible in the future).
grid_helper = GridHelperCurveLinear(tr,
extreme_finder=extreme_finder,
grid_locator1=grid_locator1,
tick_formatter1=tick_formatter1)
ax1 = SubplotHost(fig, 1, 2, 2, grid_helper=grid_helper)
# make ticklabels of right and top axis visible.
ax1.axis["right"].major_ticklabels.set_visible(True)
ax1.axis["top"].major_ticklabels.set_visible(True)
# let right axis shows ticklabels for 1st coordinate (angle)
ax1.axis["right"].get_helper().nth_coord_ticks = 0
# let bottom axis shows ticklabels for 2nd coordinate (radius)
ax1.axis["bottom"].get_helper().nth_coord_ticks = 1
fig.add_subplot(ax1)
# A parasite axes with given transform
ax2 = ParasiteAxesAuxTrans(ax1, tr, "equal")
# note that ax2.transData == tr + ax1.transData
# Anthing you draw in ax2 will match the ticks and grids of ax1.
ax1.parasites.append(ax2)
intp = cbook.simple_linear_interpolation
ax2.plot(intp(np.array([0, 30]), 50), intp(np.array([10., 10.]), 50))
ax1.set_aspect(1.)
ax1.set_xlim(-5, 12)
ax1.set_ylim(-5, 10)
ax1.grid(True)
def Taylor_diag(series,names):
""" Taylor Diagram : obs is reference data sample
in a full diagram (0 --> npi)
--------------------------------------------------------------------------
Input: series - dict with all time series (lists) to analyze
series[0] - is the observation, the reference by default.
"""
from matplotlib.projections import PolarAxes
corr,std ={},{}
for i in series.keys():
corr[i] = ma.corrcoef(series[0],series[i])[1,0]
std[i] = ma.std(series[i])/ma.std(series[0])
ref = 1# ma.std(series[0])
#print corr
rlocs = np.concatenate((np.arange(0,-10,-0.25),[-0.95,-0.99],np.arange(0,10,0.25),[0.95,0.99]))
str_rlocs = np.concatenate((np.arange(0,10,0.25),[0.95,0.99],np.arange(0,10,0.25),[0.95,0.99]))
tlocs = np.arccos(rlocs) # Conversion to polar angles
gl1 = GF.FixedLocator(tlocs) # Positions
tf1 = GF.DictFormatter(dict(zip(tlocs, map(str,rlocs))))
str_locs2 = np.arange(-10,11,0.5)
tlocs2 = np.arange(-10,11,0.5) # Conversion to polar angles
g22 = GF.FixedLocator(tlocs2)
tf2 = GF.DictFormatter(dict(zip(tlocs2, map(str,str_locs2))))
tr = PolarAxes.PolarTransform()
smin = 0
smax = 2.5
ghelper = FA.GridHelperCurveLinear(tr,
extremes=(0,np.pi, # 1st quadrant
smin,smax),
grid_locator1=gl1,
#grid_locator2=g11,
tick_formatter1=tf1,
tick_formatter2=tf2,
)
fig = plt.figure(figsize=(10,5), dpi=100)
ax = FA.FloatingSubplot(fig, 111, grid_helper=ghelper)
fig.add_subplot(ax)
ax.axis["top"].set_axis_direction("bottom")
ax.axis["top"].toggle(ticklabels=True, label=True)
ax.axis["top"].major_ticklabels.set_axis_direction("top")
ax.axis["top"].label.set_axis_direction("top")
ax.axis["top"].label.set_text("Correlation Coefficient")
ax.axis["left"].set_axis_direction("bottom")
ax.axis["left"].label.set_text("Standard Deviation")
ax.axis["right"].set_axis_direction("top")
ax.axis["right"].toggle(ticklabels=True, label=True)
ax.axis["right"].set_visible(True)
ax.axis["right"].major_ticklabels.set_axis_direction("bottom")
#ax.axis["right"].label.set_text("Standard Deviation")
ax.axis["bottom"].set_visible(False)
ax.grid(True)
ax = ax.get_aux_axes(tr)
t = np.linspace(0, np.pi)
r = np.zeros_like(t) + ref
ax.plot(t,r, 'k--', label='_')
rs,ts = np.meshgrid(np.linspace(smin,smax),
np.linspace(0,np.pi))
rms = np.sqrt(ref**2 + rs**2 - 2*ref*rs*np.cos(ts))
CS =ax.contour(ts, rs,rms,cmap=cm.bone)
plt.clabel(CS, inline=1, fontsize=10)
ax.plot(np.arccos(0.9999),ref,'k',marker='*',ls='', ms=10)
aux = range(1,len(corr))
#del aux[ref]
colors = plt.matplotlib.cm.jet(np.linspace(0,1,len(corr)))
for i in aux:
ax.plot(np.arccos(corr[i]), std[i],c=colors[i],alpha=0.7,marker='o',label="%s" %names[i])
ax.text(np.arccos(corr[i]), std[i],"%s"%i)
legend(bbox_to_anchor=(1.5, 1),prop=dict(size='large'),loc='best')
plt.savefig('example.png', dpi=500)
return
def curvelinear_test3(fig):
"""
polar projection, but in a rectangular box.
"""
global ax1, axis
import numpy as np
import angle_helper
from matplotlib.projections import PolarAxes
from matplotlib.transforms import Affine2D
from mpl_toolkits.axes_grid.parasite_axes import SubplotHost
# PolarAxes.PolarTransform takes radian. However, we want our coordinate
# system in degree
tr = Affine2D().scale(np.pi/180., 1.) + PolarAxes.PolarTransform()
# polar projection, which involves cycle, and also has limits in
# its coordinates, needs a special method to find the extremes
# (min, max of the coordinate within the view).
# 20, 20 : number of sampling points along x, y direction
extreme_finder = angle_helper.ExtremeFinderCycle(20, 20,
lon_cycle = 360,
lat_cycle = None,
lon_minmax = None,
lat_minmax = (0, np.inf),
)
grid_locator1 = angle_helper.LocatorDMS(12)
# Find a grid values appropriate for the coordinate (degree,
# minute, second).
tick_formatter1 = angle_helper.FormatterDMS()
# And also uses an appropriate formatter. Note that,the
# acceptable Locator and Formatter class is a bit different than
# that of mpl's, and you cannot directly use mpl's Locator and
# Formatter here (but may be possible in the future).
grid_helper = GridHelperCurveLinear(tr,
extreme_finder=extreme_finder,
grid_locator1=grid_locator1,
tick_formatter1=tick_formatter1
)
ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
for axis in ax1.axis.itervalues():
axis.set_visible(False)
fig.add_subplot(ax1)
grid_helper = ax1.get_grid_helper()
ax1.axis["lat1"] = axis = grid_helper.new_floating_axis(0, 130,
axes=ax1,
axis_direction="left"
)
axis.label.set_text("Test")
axis.label.set_visible(True)
axis.get_helper()._extremes=0.001, 10
grid_helper = ax1.get_grid_helper()
ax1.axis["lat2"] = axis = grid_helper.new_floating_axis(0, 50, axes=ax1,
axis_direction="right")
axis.label.set_text("Test")
axis.label.set_visible(True)
axis.get_helper()._extremes=0.001, 10
ax1.axis["lon"] = axis = grid_helper.new_floating_axis(1, 10,
axes=ax1,
axis_direction="bottom")
axis.label.set_text("Test 2")
axis.get_helper()._extremes= 50, 130
axis.major_ticklabels.set_axis_direction("top")
axis.label.set_axis_direction("top")
grid_helper.grid_finder.grid_locator1.den = 5
grid_helper.grid_finder.grid_locator2._nbins = 5
# # A parasite axes with given transform
# ax2 = ParasiteAxesAuxTrans(ax1, tr, "equal")
# # note that ax2.transData == tr + ax1.transData
# # Anthing you draw in ax2 will match the ticks and grids of ax1.
# ax1.parasites.append(ax2)
# intp = cbook.simple_linear_interpolation
# ax2.plot(intp(np.array([0, 30]), 50),
# intp(np.array([10., 10.]), 50))
ax1.set_aspect(1.)
ax1.set_xlim(-5, 12)
ax1.set_ylim(-5, 10)
ax1.grid(True)
def __init__(self,
refstd,
fig=None,
rect=111,
label='_',
srange=(0, 1.5),
extend=False):
"""
Set up Taylor diagram axes, i.e. single quadrant polar
plot, using `mpl_toolkits.axisartist.floating_axes`.
Parameters:
* refstd: reference standard deviation to be compared to
* fig: input Figure or None
* rect: subplot definition
* label: reference label
* srange: stddev axis extension, in units of *refstd*
* extend: extend diagram to negative correlations
"""
from matplotlib.projections import PolarAxes
import mpl_toolkits.axisartist.floating_axes as FA
import mpl_toolkits.axisartist.grid_finder as GF
import matplotlib.pyplot as plt
self.refstd = refstd # Reference standard deviation
tr = PolarAxes.PolarTransform()
rlocs = np.array([0, 0.2, 0.5, 0.7, 0.8, 0.9, 0.95, 0.99, 1])
if extend: # Diagram extended to negative correlations
self.tmax = np.pi
rlocs = np.concatenate((-rlocs[:0:-1], rlocs))
else:
self.tmax = np.pi / 2
tlocs = np.arccos(rlocs) # Conversion to polar angles
gl1 = GF.FixedLocator(tlocs) # Positions
tf1 = GF.DictFormatter(dict(zip(tlocs, map(str, rlocs))))
# Standard deviation axis extent (in units of reference stddev)
self.smin = srange[0] * self.refstd
self.smax = srange[1] * self.refstd
ghelper = FA.GridHelperCurveLinear(tr,
extremes=(0, self.tmax, self.smin,
self.smax),
grid_locator1=gl1,
tick_formatter1=tf1)
if fig is None: fig = plt.figure()
ax = FA.FloatingSubplot(fig, rect, grid_helper=ghelper)
fig.add_subplot(ax)
ax.axis["top"].set_axis_direction("bottom") # "Angle axis"
ax.axis["top"].toggle(ticklabels=True, label=True)
ax.axis["top"].major_ticklabels.set_axis_direction("top")
ax.axis["top"].label.set_axis_direction("top")
ax.axis["top"].label.set_text("Correlation")
ax.axis["left"].set_axis_direction("bottom") # "X axis"
ax.axis["left"].label.set_text("Standard deviation")
ax.axis["left"].toggle(ticklabels=False)
ax.axis["right"].set_axis_direction("top") # "Y-axis"
ax.axis["right"].toggle(ticklabels=True)
ax.axis["right"].major_ticklabels.set_axis_direction(
"bottom" if extend else "left")
if self.smin:
ax.axis["bottom"].toggle(ticklabels=False, label=False)
else:
ax.axis["bottom"].set_visible(False) # Unused
self._ax = ax # Graphical axes
self.ax = ax.get_aux_axes(tr) # Polar coordinates
# Add reference point and stddev contour
l, = self.ax.plot([0],
self.refstd,
'k*',
ls='',
ms=10,
label=label,
clip_on=False)
t = np.linspace(0, self.tmax)
r = np.zeros_like(t) + self.refstd
self.ax.plot(t, r, 'k--', label='_')
# Collect sample points for latter use (e.g. legend)
self.samplePoints = [l]
def __init__(self, refstd, fig=None, rect=111, label='_', srange=(0, 1.5)):
"""
Set up Taylor diagram axes, i.e. single quadrant polar
plot, using `mpl_toolkits.axisartist.floating_axes`.
Parameters:
* refstd: reference standard deviation to be compared to
* fig: input Figure or None
* rect: subplot definition
* label: reference label
* srange: stddev axis extension, in units of *refstd*
"""
from matplotlib.projections import PolarAxes
import mpl_toolkits.axisartist.floating_axes as FA
import mpl_toolkits.axisartist.grid_finder as GF
self.refstd = refstd # Reference standard deviation
tr = PolarAxes.PolarTransform()
# Correlation labels
rlocs = NP.concatenate((NP.arange(10)/10., [0.95, 0.99]))
tlocs = NP.arccos(rlocs) # Conversion to polar angles
gl1 = GF.FixedLocator(tlocs) # Positions
tf1 = GF.DictFormatter(dict(zip(tlocs, map(str, rlocs))))
# Standard deviation axis extent (in units of reference stddev)
self.smin = srange[0]*self.refstd
#self.smax = srange[1]*self.refstd
self.smax = srange[1] * 1.1
ghelper = FA.GridHelperCurveLinear(tr,
extremes=(0, NP.pi/2, # 1st quadrant
self.smin, self.smax),
grid_locator1=gl1,
tick_formatter1=tf1)
if fig is None:
fig = PLT.figure()
ax = FA.FloatingSubplot(fig, rect, grid_helper=ghelper)
fig.add_subplot(ax)
# Adjust axes
ax.axis["top"].set_axis_direction("bottom") # "Angle axis"
ax.axis["top"].toggle(ticklabels=True, label=True)
ax.axis["top"].major_ticklabels.set_axis_direction("top")
ax.axis["top"].label.set_axis_direction("top")
ax.axis["top"].label.set_text("Correlación")
ax.axis["left"].set_axis_direction("bottom") # "X axis"
ax.axis["left"].label.set_text("Desviación estándar")
ax.axis["right"].set_axis_direction("top") # "Y axis"
ax.axis["right"].toggle(ticklabels=True)
ax.axis["right"].major_ticklabels.set_axis_direction("left")
ax.axis["bottom"].set_visible(False) # Useless
self._ax = ax # Graphical axes
self.ax = ax.get_aux_axes(tr) # Polar coordinates
# Add reference point and stddev contour
l, = self.ax.plot([0], self.refstd, 'k*',
ls='', ms=10, label=label)
t = NP.linspace(0, NP.pi/2)
r = NP.zeros_like(t) + self.refstd
self.ax.plot(t, r, 'k--', label='_')
# Collect sample points for latter use (e.g. legend)
self.samplePoints = [l]
def test_axis_direction():
# Remove this line when this test image is regenerated.
plt.rcParams['text.kerning_factor'] = 6
fig = plt.figure(figsize=(5, 5))
# PolarAxes.PolarTransform takes radian. However, we want our coordinate
# system in degree
tr = Affine2D().scale(np.pi / 180., 1.) + PolarAxes.PolarTransform()
# polar projection, which involves cycle, and also has limits in
# its coordinates, needs a special method to find the extremes
# (min, max of the coordinate within the view).
# 20, 20 : number of sampling points along x, y direction
extreme_finder = angle_helper.ExtremeFinderCycle(
20,
20,
lon_cycle=360,
lat_cycle=None,
lon_minmax=None,
lat_minmax=(0, np.inf),
)
grid_locator1 = angle_helper.LocatorDMS(12)
tick_formatter1 = angle_helper.FormatterDMS()
grid_helper = GridHelperCurveLinear(tr,
extreme_finder=extreme_finder,
grid_locator1=grid_locator1,
tick_formatter1=tick_formatter1)
ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
for axis in ax1.axis.values():
axis.set_visible(False)
fig.add_subplot(ax1)
ax1.axis["lat1"] = axis = grid_helper.new_floating_axis(
0, 130, axes=ax1, axis_direction="left")
axis.label.set_text("Test")
axis.label.set_visible(True)
axis.get_helper().set_extremes(0.001, 10)
ax1.axis["lat2"] = axis = grid_helper.new_floating_axis(
0, 50, axes=ax1, axis_direction="right")
axis.label.set_text("Test")
axis.label.set_visible(True)
axis.get_helper().set_extremes(0.001, 10)
ax1.axis["lon"] = axis = grid_helper.new_floating_axis(
1, 10, axes=ax1, axis_direction="bottom")
axis.label.set_text("Test 2")
axis.get_helper().set_extremes(50, 130)
axis.major_ticklabels.set_axis_direction("top")
axis.label.set_axis_direction("top")
grid_helper.grid_finder.grid_locator1.set_params(nbins=5)
grid_helper.grid_finder.grid_locator2.set_params(nbins=5)
ax1.set_aspect(1.)
ax1.set_xlim(-8, 8)
ax1.set_ylim(-4, 12)
ax1.grid(True)
def Taylor_diag(series, names, styles, colors):
""" Taylor Diagram : obs is reference data sample
in a full diagram (0 --> npi)
--------------------------------------------------------------------------
Input: series - dict with all time series (lists) to analyze
series[0] - is the observation, the reference by default.
"""
from matplotlib.projections import PolarAxes
taylor_stats = np.array([
AnDA_Taylor_stats(series[i], series[list(series.keys())[0]])
for i in series.keys()
])
crmsd, corr, std = taylor_stats.T
ref = std[0]
rlocs = np.concatenate((np.arange(0, 10, 0.25), [0.95, 0.99]))
str_rlocs = np.concatenate((np.arange(0, 10, 0.25), [0.95, 0.99]))
tlocs = np.arccos(rlocs) # Conversion to polar angles
gl1 = GF.FixedLocator(tlocs) # Positions
tf1 = GF.DictFormatter(dict(zip(tlocs, map(str, rlocs))))
str_locs2 = np.arange(0, 11, 0.5)
tlocs2 = np.arange(0, 11, 0.5) # Conversion to polar angles
g22 = GF.FixedLocator(tlocs2)
tf2 = GF.DictFormatter(dict(zip(tlocs2, map(str, str_locs2))))
tr = PolarAxes.PolarTransform()
smin = 0
smax = (120 / 100) * np.max(std)
ghelper = FA.GridHelperCurveLinear(
tr,
extremes=(
0,
np.pi / 2, # 1st quadrant
smin,
smax),
grid_locator1=gl1,
#grid_locator2=g11,
tick_formatter1=tf1,
tick_formatter2=tf2,
)
fig = plt.figure(figsize=(10, 5), dpi=100)
ax = FA.FloatingSubplot(fig, 111, grid_helper=ghelper)
fig.add_subplot(ax)
ax.axis["top"].set_axis_direction("bottom")
ax.axis["top"].toggle(ticklabels=True, label=True)
ax.axis["top"].major_ticklabels.set_axis_direction("top")
ax.axis["top"].label.set_axis_direction("top")
ax.axis["top"].label.set_text("Correlation Coefficient")
ax.axis["left"].set_axis_direction("bottom")
ax.axis["left"].label.set_text("Standard Deviation")
ax.axis["right"].set_axis_direction("top")
ax.axis["right"].toggle(ticklabels=True, label=True)
ax.axis["right"].set_visible(True)
ax.axis["right"].major_ticklabels.set_axis_direction("bottom")
ax.axis["right"].label.set_text("Standard Deviation")
ax.axis["bottom"].set_visible(False)
ax.grid(True)
ax = ax.get_aux_axes(tr)
t = np.linspace(0, np.pi / 2)
r = np.zeros_like(t) + ref
ax.plot(t, r, 'k--', label='_')
rs, ts = np.meshgrid(np.linspace(smin, smax), np.linspace(0, np.pi / 2))
rms = np.sqrt(ref**2 + rs**2 - 2 * ref * rs * np.cos(ts))
CS = ax.contour(ts, rs, rms, cmap=cm.bone)
plt.clabel(CS, inline=1, fontsize=10)
ax.plot(np.arccos(0.9999), ref, 'k', marker='*', ls='', ms=10)
aux = range(1, len(corr))
#colors = plt.matplotlib.cm.jet(np.linspace(0,1,len(corr)))
for i in reversed(aux):
ax.plot(np.arccos(corr[i]),
std[i],
c=colors[i],
alpha=0.7,
marker=styles[i],
label="%s" % names[i])
#ax.text(np.arccos(corr[i]), std[i],"%s"%i)
# inset axes....
'''axins = ax.inset_axes([1.1, 0, 0.3, 0.3])
def pol2cart(phi, rho):
x = rho * np.cos(phi)
y = rho * np.sin(phi)
return(x, y)
x = np.empty(len(aux))
y = np.empty(len(aux))
for i in reversed(aux):
x[i-1], y[i-1] = pol2cart(np.arccos(corr[i]), std[i])
axins.plot(x[i-1], y[i-1], c=colors[i],alpha=0.7,marker=styles[i],label="%s" %names[i])
#axins.text(x[i-1], y[i-1],"%s"%i)
# sub region of the original image
x1, x2, y1, y2 = np.min(x)-(1/50)*np.min(x), np.max(x)+(1/50)*np.max(x),\
np.min(y)-(1)*np.min(y), np.max(y)+(1)*np.max(y)
axins.set_xlim(x1,x2)
axins.set_ylim(y1,y2)
axins.set_xticks([])
axins.set_yticks([])
axins.set_xticklabels('')
axins.set_yticklabels('')'''
plt.legend(bbox_to_anchor=(1.5, 1), prop=dict(size='small'), loc='best')
def curvelinear_test4(fig):
"""
polar projection, but in a rectangular box.
"""
global ax1, axis
import numpy as np
import angle_helper
from matplotlib.projections import PolarAxes
tr = Affine2D().scale(np.pi/180., 1.) + PolarAxes.PolarTransform()
grid_locator1 = angle_helper.LocatorDMS(5)
tick_formatter1 = angle_helper.FormatterDMS()
from grid_finder import FixedLocator
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)
#ax1.axis["top"].set_visible(False)
#ax1.axis["bottom"].major_ticklabels.set_axis_direction("top")
fig.add_subplot(ax1)
#ax1.grid(True)
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)
#grid_helper2 = ax1.get_grid_helper()
ax1.axis["z"] = axis = grid_helper.new_floating_axis(1, 70,
axes=ax1,
axis_direction="bottom")
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")
#axis.label.set_visible(True)
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 set_xlim(self, *args, **kwargs): """ Override set_xlim and set_ylim to be between -pi, pi and 0, 1.0 """ PolarAxes.set_xlim(self, -2*numpy.pi, 2*numpy.pi) PolarAxes.set_ylim(self, 0, 1)
def curvelinear_test3(fig):
"""
polar projection, but in a rectangular box.
"""
global ax1, axis
import numpy as np
import angle_helper
from matplotlib.projections import PolarAxes
# PolarAxes.PolarTransform takes radian. However, we want our coordinate
# system in degree
tr = Affine2D().scale(np.pi/180., 1.) + PolarAxes.PolarTransform()
# polar projection, which involves cycle, and also has limits in
# its coordinates, needs a special method to find the extremes
# (min, max of the coordinate within the view).
grid_locator1 = angle_helper.LocatorDMS(15)
# Find a grid values appropriate for the coordinate (degree,
# minute, second).
tick_formatter1 = angle_helper.FormatterDMS()
# And also uses an appropriate formatter. Note that,the
# acceptable Locator and Formatter class is a bit different than
# that of mpl's, and you cannot directly use mpl's Locator and
# Formatter here (but may be possible in the future).
from grid_finder import FixedLocator
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)
#ax1.axis["top"].set_visible(False)
#ax1.axis["bottom"].major_ticklabels.set_axis_direction("top")
fig.add_subplot(ax1)
#ax1.grid(True)
r_scale = 10.
tr2 = 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)
#grid_helper2 = ax1.get_grid_helper()
ax1.axis["z"] = axis = grid_helper.new_floating_axis(1, 7,
axes=ax1,
axis_direction="bottom")
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")
#axis.label.set_visible(True)
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 test_polar_box():
# Remove this line when this test image is regenerated.
plt.rcParams['text.kerning_factor'] = 6
fig = plt.figure(figsize=(5, 5))
# PolarAxes.PolarTransform takes radian. However, we want our coordinate
# system in degree
tr = Affine2D().scale(np.pi / 180., 1.) + PolarAxes.PolarTransform()
# polar projection, which involves cycle, and also has limits in
# its coordinates, needs a special method to find the extremes
# (min, max of the coordinate within the view).
extreme_finder = angle_helper.ExtremeFinderCycle(20,
20,
lon_cycle=360,
lat_cycle=None,
lon_minmax=None,
lat_minmax=(0, np.inf))
grid_locator1 = angle_helper.LocatorDMS(12)
tick_formatter1 = angle_helper.FormatterDMS()
grid_helper = GridHelperCurveLinear(tr,
extreme_finder=extreme_finder,
grid_locator1=grid_locator1,
tick_formatter1=tick_formatter1)
ax1 = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper)
ax1.axis["right"].major_ticklabels.set_visible(True)
ax1.axis["top"].major_ticklabels.set_visible(True)
# let right axis shows ticklabels for 1st coordinate (angle)
ax1.axis["right"].get_helper().nth_coord_ticks = 0
# let bottom axis shows ticklabels for 2nd coordinate (radius)
ax1.axis["bottom"].get_helper().nth_coord_ticks = 1
fig.add_subplot(ax1)
ax1.axis["lat"] = axis = grid_helper.new_floating_axis(0, 45, axes=ax1)
axis.label.set_text("Test")
axis.label.set_visible(True)
axis.get_helper().set_extremes(2, 12)
ax1.axis["lon"] = axis = grid_helper.new_floating_axis(1, 6, axes=ax1)
axis.label.set_text("Test 2")
axis.get_helper().set_extremes(-180, 90)
# A parasite axes with given transform
ax2 = ParasiteAxes(ax1, tr, viewlim_mode="equal")
assert ax2.transData == tr + ax1.transData
# Anything you draw in ax2 will match the ticks and grids of ax1.
ax1.parasites.append(ax2)
ax2.plot(np.linspace(0, 30, 50), np.linspace(10, 10, 50))
ax1.set_aspect(1.)
ax1.set_xlim(-5, 12)
ax1.set_ylim(-5, 10)
ax1.grid(True)
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()
#%%
taylor(skillscores)
#%% Create a plotting function. In this case for Taylor diagrams.
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))))
STDgrid=np.arange(0,np.round(skillscores.OSTD[0]+1,1),.5)
gfs=FixedLocator(STDgrid)
tfs=DictFormatter(dict(zip(STDgrid, map(str,STDgrid))))
ra0, ra1 =0, np.pi/2
cz0, cz1 = 0, np.round(skillscores.OSTD[0]+1,1)
grid_helper = floating_axes.GridHelperCurveLinear(
tr, extremes=(ra0, ra1, cz0, cz1),
grid_locator1=gf,
