def set_mappable(self, mappable):
"""
When a new plot is created this method should be called with the new mappable
"""
# sanity check the mappable
mappable = self._validate_mappable(mappable)
self.ax.clear()
try: # Use current cmap
cmap = get_current_cmap(self.colorbar)
except AttributeError:
# else use default
cmap = ConfigService.getString("plots.images.Colormap")
self.colorbar = Colorbar(ax=self.ax, mappable=mappable)
self.cmin_value, self.cmax_value = mappable.get_clim()
self.update_clim_text()
self.cmap_changed(cmap, False)
mappable_cmap = get_current_cmap(mappable)
if mappable_cmap.name.endswith('_r'):
self.crev.setChecked(True)
else:
self.crev.setChecked(False)
self.cmap.setCurrentIndex(
self.cmap_list.index(mappable_cmap.name.replace('_r', '')))
self.redraw()
def plot_scatter_profilesSet(df,
profileSet=[],
var='CTEMP',
wd=7.48,
ht=5,
varmin=-2,
varmax=5,
levs=[],
show=True,
colorunit='$\\theta^{\circ}$C ',
save=False,
savename="Untitled.png",
fontsize=8,
zmin=0.0,
ticks=[],
cline=[],
legend_show=True):
matplotlib.rcParams.update({'font.size': fontsize})
plt.close(1)
fig = plt.figure(1, figsize=(wd, ht))
gs = gridspec.GridSpec(2, 1, height_ratios=[1, 0.05])
ax = plt.subplot(gs[0, 0])
if not profileSet:
raise ValueError('profileSet cannot be null!')
selectProfiles = df.PROFILE_NUMBER.isin(profileSet)
cs = ax.scatter(df.loc[selectProfiles, 'DIST_GLINE'],
df.loc[selectProfiles, 'DEPTH'],
c=df.loc[selectProfiles, 'CTEMP'])
cs_gamman = ax.tricontour(df.loc[selectProfiles, 'DIST_GLINE'],
df.loc[selectProfiles, 'DEPTH'],
df.loc[selectProfiles, 'gamman'],
colors='0.5')
distSortedIndices = np.argsort(df.loc[selectProfiles, 'DIST_GLINE'])
ax.plot(df.loc[selectProfiles, 'DIST_GLINE'].values[distSortedIndices],
df.loc[selectProfiles, 'ECHODEPTH'].values[distSortedIndices],
linewidth=4,
color='k')
if not cline:
cline = np.arange(27.8, 28.5, 0.1)
ax.clabel(cs_gamman, colors='k', fontsize=14, fmt='%3.2f')
colorax = plt.subplot(gs[1, 0])
cbar1 = Colorbar(ax=colorax, mappable=cs, orientation='horizontal')
cbar1.ax.get_children()[0].set_linewidths(5)
cbar1.set_label(colorunit)
if save:
plt.savefig(savename, dpi=300)
if show:
plt.show()
def pmft_plot(pmft, ax=None):
"""Helper function to draw 2D PMFT diagram.
.. moduleauthor:: Jin Soo Ihm <*****@*****.**>
Args:
pmft (:class:`freud.pmft.PMFTXY2D`):
PMFTXY2D instance.
ax (:class:`matplotlib.axes.Axes`): axes object to plot.
If :code:`None`, make a new axes and figure object.
(Default value = :code:`None`).
Returns:
:class:`matplotlib.axes.Axes`: axes object with the diagram.
"""
if not MATPLOTLIB:
return None
try:
from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable
from matplotlib.colorbar import Colorbar
except ImportError:
return None
else:
# Plot figures
if ax is None:
fig = Figure()
ax = fig.subplots()
pmft_arr = np.copy(pmft.PMFT)
pmft_arr[np.isinf(pmft_arr)] = np.nan
xlims = (pmft.X[0], pmft.X[-1])
ylims = (pmft.Y[0], pmft.Y[-1])
ax.set_xlim(xlims)
ax.set_ylim(ylims)
ax.xaxis.set_ticks([i for i in range(int(xlims[0]), int(xlims[1]+1))])
ax.yaxis.set_ticks([i for i in range(int(ylims[0]), int(ylims[1]+1))])
ax.set_xlabel(r'$x$')
ax.set_ylabel(r'$y$')
ax.set_title('PMFT')
ax_divider = make_axes_locatable(ax)
cax = ax_divider.append_axes("right", size="7%", pad="10%")
im = ax.imshow(np.flipud(pmft_arr),
extent=[xlims[0], xlims[1], ylims[0], ylims[1]],
interpolation='nearest', cmap='viridis',
vmin=-2.5, vmax=3.0)
cb = Colorbar(cax, im)
cb.set_label(r"$k_B T$")
return ax
def pmft_plot(pmft, ax=None):
"""Helper function to draw 2D PMFT diagram.
Args:
pmft (:class:`freud.pmft.PMFTXY2D`):
PMFTXY2D instance.
ax (:class:`matplotlib.axes.Axes`): Axes object to plot.
If :code:`None`, make a new axes and figure object.
(Default value = :code:`None`).
Returns:
:class:`matplotlib.axes.Axes`: Axes object with the diagram.
"""
from matplotlib.colorbar import Colorbar
from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable
# Plot figures
if ax is None:
fig = plt.figure()
ax = fig.subplots()
pmft_arr = np.copy(pmft.PMFT)
pmft_arr[np.isinf(pmft_arr)] = np.nan
xlims = (pmft.X[0], pmft.X[-1])
ylims = (pmft.Y[0], pmft.Y[-1])
ax.set_xlim(xlims)
ax.set_ylim(ylims)
ax.xaxis.set_ticks([i for i in range(int(xlims[0]), int(xlims[1] + 1))])
ax.yaxis.set_ticks([i for i in range(int(ylims[0]), int(ylims[1] + 1))])
ax.set_xlabel(r"$x$")
ax.set_ylabel(r"$y$")
ax.set_title("PMFT")
ax_divider = make_axes_locatable(ax)
cax = ax_divider.append_axes("right", size="7%", pad="10%")
im = ax.imshow(
np.flipud(pmft_arr),
extent=[xlims[0], xlims[1], ylims[0], ylims[1]],
interpolation="nearest",
cmap="viridis",
vmin=-2.5,
vmax=3.0,
)
cb = Colorbar(cax, im)
cb.set_label(r"$k_B T$")
return ax
def map_skyobjs(x,
y,
n,
mu,
label=None,
n_min=10,
vmin=None,
vmax=None,
y_size=4,
margin=0.2,
fontsize=30,
cbar_label=False):
"""Map the RA, Dec distributions of sky objects."""
# Only keey the bins with enough sky objects in them
mu[n <= n_min] = np.nan
xy_ratio = (x.max() - x.min()) / (y.max() - y.min())
fig = plt.figure(figsize=(xy_ratio * y_size, y_size))
ax1 = fig.add_subplot(111)
ax1.grid(linestyle='--', alpha=0.6)
im = ax1.imshow(mu.T,
origin='lower',
extent=[x[0], x[-1], y[0], y[-1]],
aspect='equal',
interpolation='nearest',
cmap=plt.get_cmap('coolwarm'),
vmin=vmin,
vmax=vmax)
ax1.set_xlim(x.min() - margin, x.max() + margin)
ax1.set_ylim(y.min() - margin, y.max() + margin)
if label is not None:
plt.text(0.03, 1.05, label, transform=ax1.transAxes, fontsize=38)
# Color bar
cb_axes = fig.add_axes([0.48, 0.90, 0.37, 0.06])
cb = Colorbar(ax=cb_axes,
mappable=im,
orientation='horizontal',
ticklocation='top')
if cbar_label:
cb.set_label(r'$\mu{\rm Jy}/\mathrm{arcsec}^2$', fontsize=25)
_ = ax1.set_xlabel(r'$\mathrm{R.A.\ [deg]}$', fontsize=fontsize)
_ = ax1.set_ylabel(r'$\mathrm{Dec\ [deg]}$', fontsize=fontsize)
return fig
def draw_ctag_ratio(in_file, out_dir, ext='.pdf', **opts):
"""
Heat map showing efficiency ratio gaia and some other tagger.
Makes iso-efficiency contours for gaia.
misc options:
tagger
tagger_disp (for display)
vmax
"""
options = {'tagger':'jfc', 'tagger_disp':'JetFitterCharm', 'vmax':1.2,
'num_tagger':'gaia', 'num_tagger_disp':None,
'textsize':_text_size}
for key, val in opts.items():
if not key in options:
raise TypeError("{} not a valid arg".format(key))
options[key] = val
fig = Figure(figsize=_fig_size)
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1,1,1)
ds = in_file['{}/all'.format(options['num_tagger'])]
ds_denom = in_file['{}/all'.format(options['tagger'])]
eff_array, extent = _get_arr_extent(ds)
denom_array, denom_extent = _get_arr_extent(ds_denom)
ratio_array = eff_array / denom_array
im = ax.imshow(ratio_array.T, extent=extent,
origin='lower', aspect='auto',
vmin=1.0, vmax=options['vmax'])
textsize = options['textsize']
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
cb = Colorbar(ax=cax, mappable=im)
cb.set_label('$\epsilon_{{c}}$ ratio ({} / {})'.format(
options['num_tagger_disp'] or options['num_tagger'].upper(),
options['tagger_disp']), size=textsize)
cb.ax.tick_params(labelsize=textsize, which='both')
label_rejrej_axes(ax, ds, textsize=textsize)
_add_eq_contour(ax, ds, ds_denom, colorbar=cb)
add_contour(ax,ds, opts=dict(textsize=textsize))
out_name = '{}/ctag-2d-{}-vs-{}{}'.format(
out_dir, options['num_tagger'], options['tagger'], ext)
# ignore complaints about not being able to log scale images
with warnings.catch_warnings():
warnings.simplefilter("ignore")
canvas.print_figure(out_name, bbox_inches='tight')
def _colorbar_extension_length(spacing):
"""
Produce 12 colorbars with variable length extensions for either
uniform or proportional spacing.
Helper function for test_colorbar_extension_length.
"""
# Get a colormap and appropriate norms for each extension type.
cmap, norms = _get_cmap_norms()
# Create a figure and adjust whitespace for subplots.
fig = plt.figure()
fig.subplots_adjust(hspace=.6)
for i, extension_type in enumerate(('neither', 'min', 'max', 'both')):
# Get the appropriate norm and use it to get colorbar boundaries.
norm = norms[extension_type]
boundaries = values = norm.boundaries
values = values[:-1]
for j, extendfrac in enumerate((None, 'auto', 0.1)):
# Create a subplot.
cax = fig.add_subplot(12, 1, i*3 + j + 1)
# Generate the colorbar.
Colorbar(cax, cmap=cmap, norm=norm,
boundaries=boundaries, values=values,
extend=extension_type, extendfrac=extendfrac,
orientation='horizontal', spacing=spacing)
# Turn off text and ticks.
cax.tick_params(left=False, labelleft=False,
bottom=False, labelbottom=False)
# Return the figure to the caller.
return fig
def _colorbar_extension_shape(spacing):
"""
Produce 4 colorbars with rectangular extensions for either uniform
or proportional spacing.
Helper function for test_colorbar_extension_shape.
"""
# Get a colormap and appropriate norms for each extension type.
cmap, norms = _get_cmap_norms()
# Create a figure and adjust whitespace for subplots.
fig = plt.figure()
fig.subplots_adjust(hspace=4)
for i, extension_type in enumerate(('neither', 'min', 'max', 'both')):
# Get the appropriate norm and use it to get colorbar boundaries.
norm = norms[extension_type]
boundaries = values = norm.boundaries
# note that the last value was silently dropped pre 3.3:
values = values[:-1]
# Create a subplot.
cax = fig.add_subplot(4, 1, i + 1)
# Generate the colorbar.
Colorbar(cax, cmap=cmap, norm=norm,
boundaries=boundaries, values=values,
extend=extension_type, extendrect=True,
orientation='horizontal', spacing=spacing)
# Turn off text and ticks.
cax.tick_params(left=False, labelleft=False,
bottom=False, labelbottom=False)
# Return the figure to the caller.
return fig
def colorbar(self, mappable, *, ticks=None, **kwargs):
if self.orientation in ["top", "bottom"]:
orientation = "horizontal"
else:
orientation = "vertical"
if mpl.rcParams["mpl_toolkits.legacy_colorbar"]:
cbook.warn_deprecated(
"3.2", message="Since %(since)s, mpl_toolkits's own colorbar "
"implementation is deprecated; it will be removed "
"%(removal)s. Set the 'mpl_toolkits.legacy_colorbar' rcParam "
"to False to use Matplotlib's default colorbar implementation "
"and suppress this deprecation warning.")
if ticks is None:
ticks = ticker.MaxNLocator(5) # For backcompat.
from .colorbar import Colorbar
else:
from matplotlib.colorbar import Colorbar
cb = Colorbar(
self, mappable, orientation=orientation, ticks=ticks, **kwargs)
self._config_axes()
self.cbid = mappable.callbacksSM.connect('changed', cb.update_normal)
mappable.colorbar = cb
if mpl.rcParams["mpl_toolkits.legacy_colorbar"]:
self.locator = cb.cbar_axis.get_major_locator()
else:
self.locator = cb.locator
return cb
def test_colorbar_powernorm_extension():
# Test that colorbar with powernorm is extended correctly
f, ax = plt.subplots()
cb = Colorbar(ax,
norm=PowerNorm(gamma=0.5, vmin=0.0, vmax=1.0),
orientation='vertical',
extend='both')
assert cb._values[0] >= 0.0
def test_colorbar_lognorm_extension(extend):
# Test that colorbar with lognorm is extended correctly
f, ax = plt.subplots()
cb = Colorbar(ax,
norm=LogNorm(vmin=0.1, vmax=1000.0),
orientation='vertical',
extend=extend)
assert cb._values[0] >= 0.0
def draw_ctag_ratio(in_file, out_dir, ext='.pdf', **opts):
"""
misc options:
tagger
tagger_disp (for display)
vmax
"""
options = {'tagger':'jfc', 'tagger_disp':'JetFitterCharm', 'vmax':1.2}
for key, val in opts.items():
if not key in options:
raise TypeError("{} not a valid arg".format(key))
options[key] = val
fig = Figure(figsize=(8,6))
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1,1,1)
ds = in_file['gaia/all']
ds_denom = in_file['{}/all'.format(options['tagger'])]
eff_array, extent = _get_arr_extent(ds)
denom_array, denom_extent = _get_arr_extent(ds_denom)
ratio_array = eff_array / denom_array
im = ax.imshow(ratio_array.T, extent=extent,
origin='lower', aspect='auto',
vmin=1.0, vmax=options['vmax'])
ax.set_xscale('log')
ax.set_yscale('log')
ax.grid(which='both')
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
cb = Colorbar(ax=cax, mappable=im)
cb.set_label('$\epsilon_{{c}}$ ratio (GAIA / {})'.format(
options['tagger_disp']))
_label_axes(ax, ds)
_add_eq_contour(ax, ds, ds_denom, colorbar=cb)
_add_contour(ax,ds)
out_name = '{}/rejrej-ratio-{}{}'.format(
out_dir, options['tagger'], ext)
# ignore complaints about not being able to log scale images
with warnings.catch_warnings():
warnings.simplefilter("ignore")
canvas.print_figure(out_name, bbox_inches='tight')
def set_mappable(self, mappable):
"""
When a new plot is created this method should be called with the new mappable
"""
self.ax.clear()
self.colorbar = Colorbar(ax=self.ax, mappable=mappable)
self.cmin_value, self.cmax_value = self.colorbar.get_clim()
self.update_clim_text()
self.redraw()
def set_mappable(self, mappable):
"""
When a new plot is created this method should be called with the new mappable
"""
self.ax.clear()
try: # Use current cmap
cmap = self.colorbar.get_cmap()
except AttributeError:
try: # else use viridis
cmap = cm.viridis
except AttributeError: # else default
cmap = None
self.colorbar = Colorbar(ax=self.ax, mappable=mappable)
self.cmin_value, self.cmax_value = self.colorbar.get_clim()
self.update_clim_text()
self.cmap_changed(cmap)
self.cmap.setCurrentIndex(sorted(cm.cmap_d.keys()).index(self.colorbar.get_cmap().name))
self.redraw()
def UpdateColorbarPP(stuff):
v_min = np.int(textbox_pp_min.text)
v_max = np.int(textbox_pp_max.text)
my_gamma = np.double(textbox_pp_g.text)
print("\n v_min = ", v_min)
print("v_max = ", v_max)
print("gamma = ", my_gamma)
pp_image.set_norm(colors.PowerNorm(gamma=my_gamma))
pp_image.set_clim([v_min, v_max])
cb_pp = Colorbar(ax=c_ax_pp,
mappable=pp_image,
orientation='horizontal',
ticklocation='top')
cb_pp.locator = ticker.MaxNLocator(nbins=3)
cb_pp.update_ticks()
def plot_density(density, box, ax=None):
R"""Helper function to plot density diagram.
Args:
density (:math:`\left(N_x, N_y\right)` :class:`numpy.ndarray`):
Array containing density.
box (:class:`freud.box.Box`):
Simulation box.
ax (:class:`matplotlib.axes.Axes`): axes object to plot.
If :code:`None`, make a new axes and figure object.
(Default value = :code:`None`).
Returns:
:class:`matplotlib.axes.Axes`: axes object with the diagram.
"""
if not MATPLOTLIB:
return None
try:
from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable
from matplotlib.colorbar import Colorbar
except ImportError:
return None
if ax is None:
fig = Figure()
ax = fig.subplots()
xlims = (-box.Lx/2, box.Lx/2)
ylims = (-box.Ly/2, box.Ly/2)
ax.set_title('Gaussian Density')
ax.set_xlabel(r'$x$')
ax.set_ylabel(r'$y$')
ax_divider = make_axes_locatable(ax)
cax = ax_divider.append_axes("right", size="7%", pad="10%")
im = ax.imshow(density, extent=[xlims[0], xlims[1], ylims[0], ylims[1]])
cb = Colorbar(cax, im)
cb.set_label("Density")
return ax
def set_mappable(self, mappable):
"""
When a new plot is created this method should be called with the new mappable
"""
self.ax.clear()
try: # Use current cmap
cmap = get_current_cmap(self.colorbar)
except AttributeError:
# else use default
cmap = ConfigService.getString("plots.images.Colormap")
self.colorbar = Colorbar(ax=self.ax, mappable=mappable)
self.cmin_value, self.cmax_value = mappable.get_clim()
self.update_clim_text()
self.cmap_changed(cmap)
mappable_cmap = get_current_cmap(mappable)
self.cmap.setCurrentIndex(
sorted(cm.cmap_d.keys()).index(mappable_cmap.name))
self.redraw()
def make_colorbar(cax, im, dim):
"""
Function to plot colorbar.
Args:
cax (Axes): Axes of colorbar of heatmap, mainly defines the location of the colorbar.
im (Image): The mapping relationship between data and color.
dim (str): Unit.
Returns:
Axes: Return the axes object of colorbar of heatmap.
"""
cax.axis('on')
if dim == 'OnOff' or dim == 'Onoff':
Colorbar(cax, im, ticks=[0, 1])
elif '%' in dim or dim == 'percent' or dim == 'percentage':
Colorbar(cax, im, format='%.0f %%')
else:
Colorbar(cax, im, format='%.3g', label='in ' + dim)
return cax
def compare(nx, nz):
ld = nx / 2
# load files
upvert_plot_nl = np.load('upvert_plot_nl.npy')
upvert_plot_gql3 = np.load('upvert_plot_gql3.npy')
upvert_plot_ql = np.load('upvert_plot_ql.npy')
vp_ql = np.load('vp_ql.npy')
wp_ql = np.load('wp_ql.npy')
vp_gql3 = np.load('vp_gql3.npy')
wp_gql3 = np.load('wp_gql3.npy')
vp_nl = np.load('vp_nl.npy')
wp_nl = np.load('wp_nl.npy')
# define max/min for colorbar
combined = np.array([upvert_plot_ql, upvert_plot_gql3, upvert_plot_nl])
cbarmin, cbarmax = np.amin(combined), np.amax(combined)
fig = plt.figure(7, figsize=(15,8))
gs = gridspec.GridSpec(1, 4, width_ratios=[1, 1, 1, 0.05])
gs.update(left=0.05, right=0.95, bottom=0.2, top=0.6, wspace=0.2, hspace=0.2)
# set axes (2 rows, 5 columns per row... [ql, colorbar, extra row for spacing, gql, dns, sharedcolorbar]
ax00 = fig.add_subplot(gs[0, 0])
ax01 = fig.add_subplot(gs[0, 1], sharey=ax00)
ax02 = fig.add_subplot(gs[0, 2], sharey=ax00)
# Define plots
plt00 = ax00.pcolormesh(Yv[:, 0:nz/2], Z[:, 0:nz/2], upvert_plot_ql, vmax=cbarmax, vmin=cbarmin, cmap=cmap)
ax00.quiver(Yhalf[::3, ::3], Zhalf[::3, ::3], vp_ql[::3, ::3], wp_ql[::3, ::3])
plt01 = ax01.pcolormesh(Yv[:, 0:nz/2], Z[:, 0:nz/2], upvert_plot_gql3, vmax=cbarmax, vmin=cbarmin, cmap=cmap)
ax01.quiver(Yhalf[::3, ::3], Zhalf[::3, ::3], vp_gql3[::3, ::3], wp_gql3[::3, ::3])
plt02 = ax02.pcolormesh(Yv[:, 0:nz/2], Z[:, 0:nz/2], upvert_plot_nl, vmax=cbarmax, vmin=cbarmin, cmap=cmap)
ax02.quiver(Yhalf[::3, ::3], Zhalf[::3, ::3], vp_nl[::3, ::3], wp_nl[::3, ::3])
# Labels
# fig.suptitle('Streamwise Fluctuations of Time-Averaged Velocity, Near Wall', size=18)
ax00.set_title('$\Lambda_x$ = 0 (QL)', size=14)
ax00.set_ylabel('z', size=fsize, rotation=0)
ax00.tick_params(axis='both', which='major', labelsize=ticksize)
ax00.set_xlabel('y', size=fsize)
ax00.yaxis.set_major_locator(plt.MaxNLocator(5))
ax01.set_title('$\Lambda_x$ = 3 (GQL)', size=fsize)
ax01.set_xlabel('y', size=fsize)
ax01.tick_params(axis='both', which='major', labelsize=ticksize)
ax02.set_title('$\Lambda_x$ = %i (NL)' %ld, size=fsize)
ax02.set_xlabel('y', size=fsize)
ax02.tick_params(axis='both', which='major', labelsize=ticksize)
# Set colorbars
cbax03 = plt.subplot(gs[0, 3])
cb03 = Colorbar(ax=cbax03, mappable=plt01, orientation='vertical', ticklocation='right')
cb03.ax.set_yticklabels(cb03.ax.get_yticklabels(), fontsize=ticksize)
cb03.ax.yaxis.set_major_locator(plt.MaxNLocator(5))
# Housekeeping
plt.setp(ax01.get_yticklabels(), visible=False) # Turn off ticks for y axes
plt.setp(ax02.get_yticklabels(), visible=False)
# plt.setp(ax75.get_yticklabels(), visible=False)
# plt.setp(ax76.get_yticklabels(), visible=False)
fig.savefig('vert_structure_compare.png')
return fig.show()
def colorbar(self, mappable, *, locator=None, **kwargs):
if locator is None:
if "ticks" not in kwargs:
kwargs["ticks"] = ticker.MaxNLocator(5)
if locator is not None:
if "ticks" in kwargs:
raise ValueError("Either *locator* or *ticks* need" +
" to be given, not both")
else:
kwargs["ticks"] = locator
if self.orientation in ["top", "bottom"]:
orientation = "horizontal"
else:
orientation = "vertical"
if mpl.rcParams["mpl_toolkits.legacy_colorbar"]:
cbook.warn_deprecated(
"3.2",
message="Since %(since)s, mpl_toolkits's own colorbar "
"implementation is deprecated; it will be removed "
"%(removal)s. Set the 'mpl_toolkits.legacy_colorbar' rcParam "
"to False to use Matplotlib's default colorbar implementation "
"and suppress this deprecation warning.")
from .colorbar import Colorbar
else:
from matplotlib.colorbar import Colorbar
cb = Colorbar(self, mappable, orientation=orientation, **kwargs)
self._config_axes()
def on_changed(m):
cb.set_cmap(m.get_cmap())
cb.set_clim(m.get_clim())
cb.update_bruteforce(m)
self.cbid = mappable.callbacksSM.connect('changed', on_changed)
mappable.colorbar = cb
if mpl.rcParams["mpl_toolkits.legacy_colorbar"]:
self.locator = cb.cbar_axis.get_major_locator()
else:
self.locator = cb.locator
return cb
def create_vertical_colorbars(images,
labels,
subplot_spec,
fig=None,
n_ticks=3,
**kwargs):
if not isinstance(images, list):
images = [images]
if not isinstance(labels, list):
labels = [labels]
n_cbars = len(images)
cbar_gs = gs.GridSpecFromSubplotSpec(n_cbars,
1,
subplot_spec=subplot_spec,
**kwargs)
if fig is None:
fig = plt.gcf()
for image, label, cbar_ss in zip(images, labels, cbar_gs):
ax = fig.add_subplot(cbar_ss)
tick_locator = ticker.MaxNLocator(nbins=n_ticks)
Colorbar(ax, image, ticks=tick_locator, label=label)
def rate_plot(ax, rate_estimates, rate_windows, N, step=7000, label=''):
window_x = (rate_windows.start + rate_windows.end) / 2
rates = [float(rate) for rate in rate_estimates.columns[5:]]
#log_rates = np.log10(rates)
#top = log_rates[-1]
#log_delta = log_rates[2] - log_rates[1]
#bottom = log_rates[1] - log_delta
# enable drawing of estimates that overlap 0 (log10(0) = -inf)
#rates[0] = bottom
#log_expectation = np.log10(rate_windows.loc[:, 'E'])
#log_expectation[log_expectation < bottom] = bottom
expectation = rate_windows.loc[:, 'E']
# Plot likelihood of rates as heat map
likelihoods = rate_estimates.loc[:, rate_estimates.
columns[5]:].T #.loc[::-1, :]
hm_x = rate_estimates['start'].tolist() + [rate_estimates['end'].max()]
heatmap = ax.pcolor(hm_x,
rates,
likelihoods,
cmap='viridis',
norm=colors.LogNorm(vmin=1e-10, vmax=1))
legend = label.replace('\n', '') + '_legend'
legendfig = plt.figure(figsize=(.5, 6))
legend_ax = legendfig.add_subplot(111)
cbar = Colorbar(legend_ax, heatmap)
legendfig.savefig(legend)
plt.close(legendfig)
# Plot expectation as solid line
ax.plot(window_x, expectation, 'k-', linewidth=2, label='Expected Rate')
# legend = ax.legend(loc='upper left')
ax.set_ylabel(label)
ax.set_ylim(0, 0.003) #ax.set_ylim(bottom, top)
ax.yaxis.grid(which="major", color='k', linestyle='--', linewidth=1)
def plot_station_locations(positions,
title=' ',
save=False,
savename="untitled.png",
wd=12,
ht=12,
region='Whole',
plotBathy=True):
x = positions[:, 1]
y = positions[:, 0]
lat0 = -90
lon0 = 0
plt.figure(1, figsize=(wd, ht))
gs = gridspec.GridSpec(2, 1, height_ratios=[1, 0.05])
mapax = plt.subplot(gs[0, 0])
m = createMapProjections(lat0, lon0, region=region)
m.drawmapboundary()
m.drawcoastlines()
#m.fillcontinents(color='#cc9966');
m.readshapefile(
"/media/data/Datasets/Shapefiles/AntarcticGroundingLine/GSHHS_f_L6",
"GSHHS_f_L6",
color='m')
## if(markers != None):
## for i in range(len(markers)):
## plt.text(xgrid[i],ygrid[i], str(markers[i]), color='b');
parallels = np.arange(-80, -30 + 1, 5.)
labels = [1, 1, 1, 0]
m.drawparallels(parallels, labels=labels)
meridians = np.arange(-180, 180, 20.)
labels = [1, 1, 0, 1]
m.drawmeridians(meridians, labels=labels)
m.scatter(x, y, latlon=True, color='r', s=0.25, marker='.')
if (plotBathy == True):
bathy = xr.open_dataset(
'/media/data/Datasets/Bathymetry/GEBCO_2014_2D.nc')
lonlen = len(bathy.lon)
lonindices = np.arange(0, lonlen + 1, 30)
lonindices[-1] = lonindices[-1] - 1
bathyS = bathy.isel(lon=lonindices, lat=np.arange(0, 3600, 5))
clevs = np.array([-100, -500, -1000, -1500, -2000, -3000, -6000])[::-1]
longrid, latgrid = np.meshgrid(bathyS.lon.values, bathyS.lat.values)
cs = m.contour(longrid,
latgrid,
bathyS.elevation.where(bathyS.elevation <= 0).values,
latlon=True,
levels=clevs,
linewidths=0.2,
extend='min',
ax=mapax) #, , cmap='rainbow' , levels=clevs,
## plt.figure(2)
## cf = plt.contourf(longrid, latgrid,bathyS.elevation.where(bathyS.elevation <= 0).values, levels=clevs, extend='min') #, , cmap='rainbow' , levels=clevs,
## plt.figure(1)
bathycolorbar = plt.subplot(gs[1, 0])
cbar1 = Colorbar(ax=bathycolorbar,
mappable=cs,
orientation='horizontal')
cbar1.ax.get_children()[0].set_linewidths(5)
cbar1.set_label('Depth (m)')
if (save == True):
plt.savefig(savename, dpi=900)
plt.show()
X = X /1e+3
Y = Y / 1e+3
cordx = cordx /1e+3
cordy = cordy /1e+3
filename_counter = 0
for i in np.arange(len(magnitude1)):
fig = plt.figure(figsize =(4.1,4.1))
gs = fig.add_gridspec(28,28)
ax_cb = plt.subplot(gs[0:12,13])
ax_map = plt.subplot(gs[0:12,1:13])
ax_UWD = plt.subplot(gs[17:22,1:-1])
ax_SDH = plt.subplot(gs[23:,1:-1])
cf = ax_map.contourf(X,Y,uztot[i,:,:],levels = np.linspace(np.min(uztot),0,30))
cb = Colorbar(ax = ax_cb, mappable = cf,ticks = np.linspace(np.min(uztot),0,5))
cbar_label = np.round(np.linspace(np.min(uztot),0,5)*10)/10
cb.ax.set_yticklabels(cbar_label,fontsize = 6 )
cb.set_label('Vert. Displacement [m]',fontsize = 8 )
ax_map.set_xticks([np.min(X),0,np.max(X)])
ax_map.set_yticks([np.min(Y),0,np.max(Y)])
ax_map.set_xlabel('x [km]',fontsize = 8 )
ax_map.set_ylabel('y [km]', fontsize = 8)
ax_map.set_xticklabels(labels = [int(np.min(X)),int(0),int(np.max(X))], fontsize = 6)
ax_map.set_yticklabels(labels = [int(np.min(Y)),0,int(np.max(Y))], fontsize = 6)
h1 = []
h2 = []
names_st = ['ST1','ST2']
def plot_grid(ratios, coeffs = [[1,0],[0,1]],
Pk = 5.0, kappa=np.inf, struct = 'pp', sampling = 1,
color_mode = 'Tot[O]+12', figname = None, show_plot = True,
data = None, interp_data = None):
'''
Creates the diagram of a given line ratio grid for rapid inspection, including wraps
(fold-over regions), and of certain line ratios, if "data" is specified.
:Args:
ratios: string
The line ratios defining the grid, e.g. '[NII]/[SII]+;[OIII]/Hb'
coeffs: list of list [default: [[1,0],[0,1]] ]
The different coefficients with which to mix the line ratios.
The size of each sub-list must be equal to the number of line ratios
involved. Used for projected 3D diagnostic grids.
Pk: float [default: 5.0]
MAPPINGS model pressure. This value must match an existing grid file.
kappa: float [default: np.inf
The kappa value. This value must match an existing grid file.
struct: string [default: 'pp']
spherical ('sph') or plane-parallel ('pp') HII regions. This value
must match an existing reference grid file.
sampling: int [default: 1]
Use a resampled grid ?
color_mode: string [default: 'Tot[O]+12']
Color the grid according to 'Tot[O]+12', 'gas[O]+12' or 'LogQ'.
figname: string [default: None]
'path+name+format' to save the Figure to.
show_plot: bool [default: True]
Do you want to display the Figure ?
data: list of numpy array [default: None]
List of Arrays of the line ratio values. One array per line ratio.
interp_data: numpy array [default: 'linear']
interpolated line ratios (via pyqz.interp_qz)
'''
# 0) Let's get the data in question
[grid, grid_cols, metadata] = pyqz.get_grid(ratios, coeffs=coeffs, Pk=Pk, kappa=kappa,
struct=struct, sampling = sampling)
# 1) What are the bad segments in this grid ?
bad_segs = pyqz.check_grid(ratios, coeffs=coeffs, Pk = Pk, kappa=kappa, struct=struct,
sampling = sampling)
# 2) Start the plotting
fig = plt.figure(figsize=(10,8))
gs = gridspec.GridSpec(1,2, height_ratios=[1], width_ratios=[1,0.05])
gs.update(left=0.14,right=0.88,bottom=0.14,top=0.92,
wspace=0.1,hspace=0.1)
ax1 = fig.add_subplot(gs[0,0])
if not(color_mode in grid_cols):
sys.exit('color_mode unknown: %s' % color_mode)
# 2) Plot the grid points
# Let's make the distinction between the 'TRUE' MAPPINGS point,
# and those that were interpolated in a finer grid using Akima splines
pts = ax1.scatter(grid[:,grid_cols.index('Mix_x')],
grid[:,grid_cols.index('Mix_y')],
marker='o',
c=grid[:,grid_cols.index(color_mode)],
s=30, cmap=pyqz_cmap_0, edgecolor='none',
vmin=np.min(grid[:,grid_cols.index(color_mode)]),
vmax=np.max(grid[:,grid_cols.index(color_mode)]),
zorder=3)
# Now mark the "original" points with a black outline. First, which are they ?
if sampling > 1:
origin_cond = [n for n in range(len(grid)) if
(grid[n,metadata['columns'].index('LogQ')] in
metadata['resampled']['LogQ']) and
(grid[n,metadata['columns'].index('Tot[O]+12')] in
metadata['resampled']['Tot[O]+12'])]
else:
origin_cond = [n for n in range(len(grid))]
# Now plot the black outlines.
original_pts = ax1.scatter(grid[origin_cond, grid_cols.index('Mix_x')],
grid[origin_cond, grid_cols.index('Mix_y')],
marker='o',
c=grid[origin_cond, grid_cols.index(color_mode)],
s=60, cmap=pyqz_cmap_0, edgecolor='k', facecolor='white',
vmin=np.min(grid[:,grid_cols.index(color_mode)]),
vmax=np.max(grid[:,grid_cols.index(color_mode)]),
zorder=5)
# 2-1) Draw the grid lines
# Check as a function of LogQ and Tot[O]+12. Where are these ?
u = grid_cols.index('LogQ')
v = grid_cols.index('Tot[O]+12')
for i in [u,v]:
# Here, 'var' plays the role of 'q' or 'z' depending on 'i'.
for var in np.unique(grid[:,i]):
# Plot the grid line
ax1.plot(grid[grid[:,i]==var][:,grid_cols.index('Mix_x')],
grid[grid[:,i]==var][:,grid_cols.index('Mix_y')],
'k-', lw = 1, zorder=1)
# Plot the bad segments
for bad_seg in bad_segs:
ax1.plot([bad_seg[0][0],bad_seg[1][0]],[bad_seg[0][1],bad_seg[1][1]], 'r-',
linewidth=4, zorder=0)
# Now, also plot the data, if anything was provided !
if not(interp_data is None):
# Compute the combined "observed" ratios
data_comb = [np.zeros_like(data[0]),np.zeros_like(data[1])]
for k in range(len(ratios.split(';'))):
data_comb[0] += coeffs[0][k]*data[k]
data_comb[1] += coeffs[1][k]*data[k]
ax1.scatter(data_comb[0][interp_data == interp_data],
data_comb[1][interp_data == interp_data],
marker='s', c=interp_data[interp_data == interp_data],
s=15, cmap = pyqz_cmap_0, edgecolor='k',
vmin = np.min(grid[:,grid_cols.index(color_mode)]),
vmax = np.max(grid[:,grid_cols.index(color_mode)]),
zorder=2, alpha=0.35)
# Plot also the points outside the grid ?
# Which are they ? Need to check if they have a valid input first !
# mind the "~" to invert the bools ! isn't this cool ?
my_out_pts = ~np.isnan(data_comb[0]) * ~np.isnan(data_comb[1]) * \
np.isnan(interp_data)
# Don't do this if this is a test with fullgrid_x ...
ax1.scatter(data_comb[0][my_out_pts], data_comb[1][my_out_pts],
marker = '^', facecolor = 'none', edgecolor = 'k', s=60)
# 3) Plot the colorbar
cb_ax = plt.subplot(gs[0,1])
cb = Colorbar(ax = cb_ax, mappable = pts, orientation='vertical')
# Colorbar legend
cb.set_label(color_mode, labelpad = 10)
# 4) Axis names, kappa value, etc ...
rats = ratios.split(';')
# Make sure the labels look pretty in ALL cases ...
labelx,labely = get_plot_labels(rats,coeffs)
ax1.set_xlabel(labelx,labelpad = 10)
ax1.set_ylabel(labely,labelpad = 10)
if not(kappa in [np.inf, 'inf']) :
kappa_str = r'$\kappa$ = '+str(kappa)
else :
kappa_str = r'$\kappa$ = $\infty$'
ax1.text(0.85,0.9,kappa_str, horizontalalignment='left',verticalalignment='bottom',
transform=ax1.transAxes)
ax1.grid(True)
if figname :
fig.savefig(figname, bbox_inches='tight')
if show_plot:
plt.show()
else:
plt.close()
cmap=copy(plt.cm.plasma)
cmap.set_bad('white', 1.)
cmap.set_over('yellow', 1.)
offset=.125
image1 = m1.pcolormesh(x-offset,y+offset,np.ma.masked_invalid(plotter1),shading='flat', cmap=cmap,vmin=0, vmax=1)
image2 = m2.pcolormesh(x-offset,y+offset,np.ma.masked_invalid(plotter2),shading='flat', cmap=cmap,vmin=0, vmax=1)
# DRAW COASTLINES AND MAP BOUNDARY
m1.drawcoastlines()
m1.drawmapboundary()
m2.drawcoastlines()
m2.drawmapboundary()
#COLORBAR
from matplotlib.colorbar import Colorbar
cb=Colorbar(ax=ax3, mappable = image1, orientation="vertical", ticks=[0,.25,.5,.75,1])
cb.ax.tick_params(labelsize=ftsz-2)
cb.ax.set_ylabel('R$^2$ (BA$_{actual}$, BA$_{predicted}$)',fontsize=ftsz, labelpad=12)
#TEXT LABELS
ax1.text(.38,1.02,'Soil Moisture', fontsize=ftsz-2,transform=ax1.transAxes)
ax2.text(.38,1.02,'Precipitation', fontsize=ftsz-2, transform=ax2.transAxes)
#A and B label
ax1.text(-.05,.96,'a', weight='bold', fontsize=ftsz,transform=ax1.transAxes)
ax2.text(-.05,.96,'b', weight='bold',fontsize=ftsz, transform=ax2.transAxes)
plt.show()
def _overlay_rejrej(array_one, array_two,
out_name = 'rejrej.pdf',
do_rel = False,
do_contour = False,
do_abs_contour = False,
do_equal_contour = False,
z_range = None,
extra_cuts=[]):
if do_contour and do_abs_contour:
warnings.warn("can't do both abs_contour and contour, "
"won't use abs_contour")
do_abs_contour = False
array_one['eff'] = _maximize_efficiency(array_one['eff'])
array_two['eff'] = _maximize_efficiency(array_two['eff'])
arrays = array_one, array_two
# pretty sure the 'nonzero' calls here aren't needed (bool array returned
# by the inequality should work)
array_one['eff'][np.nonzero(array_one['eff'] <= 0.0)] = np.NaN
array_two['eff'][np.nonzero(array_two['eff'] <= 0.0)] = np.NaN
if do_rel:
old_warn_set = np.seterr(divide = 'ignore')
eff_array = array_one['eff'] / array_two['eff']
np.seterr(**old_warn_set)
else:
eff_array = array_one['eff'] - array_two['eff']
for a in arrays:
if not 'tagger' in a:
warnings.warn('no tagger name given',stacklevel = 2)
a['tagger'] = 'unknown'
if _get_rel_plot_alignment(array_one, array_two) > 1e-6:
ranges = [(p['x_range'], p['y_range']) for p in arrays]
raise ValueError("ranges {} don't match {}".format(*ranges))
if not _check_sig_bg_match(*arrays):
err = 'array mismatch ---'
for a in arrays:
err += 'sig: {signal}, bgx: {x_bg}, bgy: {y_bg} '.format(**a)
raise ValueError(err)
x_min, x_max = array_one['x_range']
y_min, y_max = array_one['y_range']
fig = plt.figure()
gs = GridSpec(20,21)
ax = plt.subplot(gs[:,0:-1])
aspect = float(x_max - x_min) / (y_max - y_min)
# cmap = mp.colors.Colormap('rainbow')
rel_min = np.min(eff_array[np.isfinite(eff_array)])
rel_max = np.max(eff_array[np.isfinite(eff_array)])
if z_range:
rel_min, rel_max = z_range
if do_abs_contour:
contour_array = array_one['eff']
signal = array_one['signal']
contour_range = (0,0.5) if signal == 'charm' else (0.5,1)
else:
contour_array = eff_array
contour_range = (rel_min, rel_max)
contour_order, c_lines = _get_contour_order_and_lines(contour_range)
print 'plot range: {: .2f}--{:.2f}'.format(
rel_min, rel_max)
im = ax.imshow(
eff_array,
origin = 'upper',
extent = (x_min,x_max, y_min, y_max),
aspect = aspect,
interpolation = 'nearest',
vmin = rel_min,
vmax = rel_max,
)
if len(c_lines) == 0:
do_contour = False
if do_contour or do_abs_contour:
ct = ax.contour(
contour_array,
origin = 'upper',
extent = (x_min,x_max, y_min, y_max),
aspect = aspect,
linewidths = 2,
levels = c_lines,
colors = 'k',
)
plt.clabel(ct, fontsize=12, inline=1,
fmt = '%.{}f'.format(-contour_order + 1 ))
equal_contour_level = 1.0 if do_rel else 0.0
if do_equal_contour:
equal_ct = ax.contour(
eff_array,
origin = 'upper',
extent = (x_min,x_max, y_min, y_max),
aspect = aspect,
linewidths = 2,
levels = [equal_contour_level],
colors = 'r',
)
plt.clabel(equal_ct, fontsize=9, inline=True,
fmt={equal_contour_level:'equal'})
im.get_cmap().set_bad(alpha=0)
ax.set_xticks([])
ax.set_yticks([])
ax.invert_yaxis()
cb_ax = plt.subplot(gs[:,-1])
plt.subplots_adjust(left = 0.25) # FIXME: use OO call here
# cb = plt.colorbar()
cb = Colorbar(ax = cb_ax, mappable = im)
taggers = [_simplify_tagger_name(x) for x in arrays]
flav_char = _flav_to_char[array_one['signal']]
sig_label = '$\epsilon_\mathrm{{ {} }}$'.format(flav_char)
cb_lab_string = '{} $/$ {} {s}' if do_rel else '{} $-$ {} {s}'
cb.set_label(cb_lab_string.format(*taggers, s = sig_label ))
if do_contour:
cb.add_lines(ct)
if do_equal_contour:
if rel_min < equal_contour_level < rel_max:
cb.add_lines(equal_ct)
position = ax.get_position()
new_aspect = ax.get_aspect()
# ax.set_position(position)
ax_log = fig.add_subplot(111, frameon = False)
ax_log.set_xscale('log')
ax_log.set_yscale('log')
ax_log.axis((10**x_min, 10**x_max, 10**y_min, 10**y_max))
ax_log.set_aspect(aspect)
ax_log.set_xlabel('{} rejection'.format(array_one['x_bg']))
ax_log.set_ylabel('{} rejection'.format(array_one['y_bg']))
ax_log.grid(True)
cuts_to_display = array_one['cuts_to_display']
for cut in extra_cuts:
cut.point_type = 'wo'
cuts_to_display.append(cut)
for cut in cuts_to_display:
x, y, z = cut.xyz
# print cut.xyz
ax_log.plot([x],[y],cut.point_type)
fmt_dict = dict(cut1=cut.cut1, cut2=cut.cut2, eff=z)
ax_log.annotate(cut.plot_string.format(**fmt_dict), (x,y),
**cut.ann_opts)
ax_log.set_aspect(new_aspect)
ax_log.set_position(position)
plt.savefig(out_name, bbox_inches = 'tight')
plt.close()
ax0 = pp.subplot(gs[0, 0:10])
ax1 = pp.subplot(gs[0, 12:22])
cb_ax = pp.subplot(gs[0,-1])
ax0.set_title('Base System Transition Matrix')
im = ax0.imshow(base_transition_matrix, interpolation='nearest', origin='lower',
vmin=0, vmax=1, cmap='gist_earth')
ax0.set_xlabel('State [index]')
ax0.set_ylabel('State [index]')
ax1.set_title('Mutant Transition Matrix')
im = ax1.imshow(sampling['transition_matrix'], interpolation='nearest',
origin='lower', vmin=0, vmax=1, cmap='gist_earth')
ax1.set_xlabel('State [index]')
ax1.set_ylabel('State [index]')
cb = Colorbar(ax = cb_ax, mappable = im) # use the raw colorbar constructor
cb.set_label('Transition Probability')
cb.set_ticks([0, 0.25, 0.5, 0.75, 1.0])
#cb = Colorbar(ax=pp.subplot(gs[1, -1]), mappable=lower)
#cb.set_ticks(np.asarray(np.unique(trajectory), dtype=int))
#cb.set_label('state')
sampling.close()
print 'saving figure as %s' % plot_fn
pp.savefig(plot_fn)
if sys.platform == 'darwin':
os.system('open %s' % plot_fn)
def plot_basemap(
lons,
lats,
size,
color,
labels=None,
projection="cyl",
resolution="l",
continent_fill_color="0.8",
water_fill_color="1.0",
colormap=None,
marker="o",
title=None,
colorbar_ticklabel_format=None,
show=True,
**kwargs
): # @UnusedVariable
"""
Creates a basemap plot with a data point scatter plot.
:type lons: list/tuple of floats
:param lons: Longitudes of the data points.
:type lats: list/tuple of floats
:param lats: Latitudes of the data points.
:type size: list/tuple of floats (or a single float)
:param size: Size of the individual points in the scatter plot.
:type color: list/tuple of
floats/:class:`~obspy.core.utcdatetime.UTCDateTime` (or a single float)
:param color: Color information of the individual data points. Can be
:type labels: list/tuple of str
:param labels: Annotations for the individual data points.
:type projection: str, optional
:param projection: The map projection. Currently supported are
* ``"cyl"`` (Will plot the whole world.)
* ``"ortho"`` (Will center around the mean lat/long.)
* ``"local"`` (Will plot around local events)
Defaults to "cyl"
:type resolution: str, optional
:param resolution: Resolution of the boundary database to use. Will be
based directly to the basemap module. Possible values are
* ``"c"`` (crude)
* ``"l"`` (low)
* ``"i"`` (intermediate)
* ``"h"`` (high)
* ``"f"`` (full)
Defaults to ``"l"``
:type continent_fill_color: Valid matplotlib color, optional
:param continent_fill_color: Color of the continents. Defaults to
``"0.9"`` which is a light gray.
:type water_fill_color: Valid matplotlib color, optional
:param water_fill_color: Color of all water bodies.
Defaults to ``"white"``.
:type colormap: str, optional, any matplotlib colormap
:param colormap: The colormap for color-coding the events.
The event with the smallest property will have the
color of one end of the colormap and the event with the biggest
property the color of the other end with all other events in
between.
Defaults to None which will use the default colormap for the date
encoding and a colormap going from green over yellow to red for the
depth encoding.
:type title: str
:param title: Title above plot.
:type colorbar_ticklabel_format: str or func or
subclass of :matplotlib:`matplotlib.ticker.Formatter`
:param colorbar_ticklabel_format: Format string or Formatter used to format
colorbar tick labels.
:type show: bool
:param show: Whether to show the figure after plotting or not. Can be used
to do further customization of the plot before showing it.
"""
min_color = min(color)
max_color = max(color)
if isinstance(color[0], (datetime.datetime, UTCDateTime)):
datetimeplot = True
color = [date2num(t) for t in color]
else:
datetimeplot = False
scal_map = ScalarMappable(norm=Normalize(min_color, max_color), cmap=colormap)
scal_map.set_array(np.linspace(0, 1, 1))
fig = plt.figure()
# The colorbar should only be plotted if more then one event is
# present.
if len(lons) > 1 and hasattr(color, "__len__") and not isinstance(color, (str, native_str)):
show_colorbar = True
else:
show_colorbar = False
if projection == "local":
ax_x0, ax_width = 0.10, 0.80
else:
ax_x0, ax_width = 0.05, 0.90
if show_colorbar:
map_ax = fig.add_axes([ax_x0, 0.13, ax_width, 0.77])
cm_ax = fig.add_axes([ax_x0, 0.05, ax_width, 0.05])
plt.sca(map_ax)
else:
map_ax = fig.add_axes([ax_x0, 0.05, ax_width, 0.85])
if projection == "cyl":
bmap = Basemap(resolution=resolution)
elif projection == "ortho":
bmap = Basemap(
projection="ortho", resolution=resolution, area_thresh=1000.0, lat_0=np.mean(lats), lon_0=np.mean(lons)
)
elif projection == "local":
if min(lons) < -150 and max(lons) > 150:
max_lons = max(np.array(lons) % 360)
min_lons = min(np.array(lons) % 360)
else:
max_lons = max(lons)
min_lons = min(lons)
lat_0 = (max(lats) + min(lats)) / 2.0
lon_0 = (max_lons + min_lons) / 2.0
if lon_0 > 180:
lon_0 -= 360
deg2m_lat = 2 * np.pi * 6371 * 1000 / 360
deg2m_lon = deg2m_lat * np.cos(lat_0 / 180 * np.pi)
if len(lats) > 1:
height = (max(lats) - min(lats)) * deg2m_lat
width = (max_lons - min_lons) * deg2m_lon
margin = 0.2 * (width + height)
height += margin
width += margin
else:
height = 2.0 * deg2m_lat
width = 5.0 * deg2m_lon
bmap = Basemap(
projection="aeqd",
resolution=resolution,
area_thresh=1000.0,
lat_0=lat_0,
lon_0=lon_0,
width=width,
height=height,
)
# not most elegant way to calculate some round lats/lons
def linspace2(val1, val2, N):
"""
returns around N 'nice' values between val1 and val2
"""
dval = val2 - val1
round_pos = int(round(-np.log10(1.0 * dval / N)))
delta = round(2.0 * dval / N, round_pos) / 2
new_val1 = np.ceil(val1 / delta) * delta
new_val2 = np.floor(val2 / delta) * delta
N = (new_val2 - new_val1) / delta + 1
return np.linspace(new_val1, new_val2, N)
N1 = int(np.ceil(height / max(width, height) * 8))
N2 = int(np.ceil(width / max(width, height) * 8))
bmap.drawparallels(
linspace2(lat_0 - height / 2 / deg2m_lat, lat_0 + height / 2 / deg2m_lat, N1), labels=[0, 1, 1, 0]
)
if min(lons) < -150 and max(lons) > 150:
lon_0 %= 360
meridians = linspace2(lon_0 - width / 2 / deg2m_lon, lon_0 + width / 2 / deg2m_lon, N2)
meridians[meridians > 180] -= 360
bmap.drawmeridians(meridians, labels=[1, 0, 0, 1])
else:
msg = "Projection '%s' not supported." % projection
raise ValueError(msg)
# draw coast lines, country boundaries, fill continents.
plt.gca().set_axis_bgcolor(water_fill_color)
bmap.drawcoastlines(color="0.4")
bmap.drawcountries(color="0.75")
bmap.fillcontinents(color=continent_fill_color, lake_color=water_fill_color)
# draw the edge of the bmap projection region (the projection limb)
bmap.drawmapboundary(fill_color=water_fill_color)
# draw lat/lon grid lines every 30 degrees.
bmap.drawmeridians(np.arange(-180, 180, 30))
bmap.drawparallels(np.arange(-90, 90, 30))
# compute the native bmap projection coordinates for events.
x, y = bmap(lons, lats)
# plot labels
if labels:
if 100 > len(lons) > 1:
for name, xpt, ypt, colorpt in zip(labels, x, y, color):
# Check if the point can actually be seen with the current bmap
# projection. The bmap object will set the coordinates to very
# large values if it cannot project a point.
if xpt > 1e25:
continue
plt.text(
xpt,
ypt,
name,
weight="heavy",
color="k",
zorder=100,
path_effects=[PathEffects.withStroke(linewidth=3, foreground="white")],
)
elif len(lons) == 1:
plt.text(
x[0],
y[0],
labels[0],
weight="heavy",
color="k",
path_effects=[PathEffects.withStroke(linewidth=3, foreground="white")],
)
scatter = bmap.scatter(x, y, marker=marker, s=size, c=color, zorder=10, cmap=colormap)
if title:
plt.suptitle(title)
# Only show the colorbar for more than one event.
if show_colorbar:
if colorbar_ticklabel_format is not None:
if isinstance(colorbar_ticklabel_format, (str, native_str)):
formatter = FormatStrFormatter(colorbar_ticklabel_format)
elif hasattr(colorbar_ticklabel_format, "__call__"):
formatter = FuncFormatter(colorbar_ticklabel_format)
elif isinstance(colorbar_ticklabel_format, Formatter):
formatter = colorbar_ticklabel_format
locator = MaxNLocator(5)
else:
if datetimeplot:
locator = AutoDateLocator()
formatter = AutoDateFormatter(locator)
formatter.scaled[1 / (24.0 * 60.0)] = "%H:%M:%S"
else:
locator = None
formatter = None
cb = Colorbar(cm_ax, scatter, cmap=colormap, orientation="horizontal", ticks=locator, format=formatter)
# format=formatter)
# ticks=mpl.ticker.MaxNLocator(4))
cb.update_ticks()
if show:
plt.show()
return fig
def test_colorbarbase():
# smoke test from #3805
ax = plt.gca()
Colorbar(ax, cmap=plt.cm.bone)
def plotProfDist_in_BoundingBox(df,
boundingBox=[],
var='CTEMP',
wd=7.48,
ht=5,
varmin=-2,
varmax=5,
levs=[],
show=True,
plotEcho=False,
xlat=False,
colorunit='$\\theta^{\circ}$C ',
save=False,
savename="Untitled.png",
fontsize=8,
levels=[],
zmin=0.0,
ticks=[],
cline=[],
legend_show=True,
plotTimeHist=False):
matplotlib.rcParams.update({'font.size': fontsize})
plt.close(1)
fig = plt.figure(1, figsize=(wd, ht))
gs = gridspec.GridSpec(2, 1, height_ratios=[1, 0.05])
ax = plt.subplot(gs[0, 0])
if not boundingBox:
raise ValueError(
'provide arg boundingBox in fmt [[llcornerx, llcornery], [urcrnrx, urcrnry]] \n With x1,y1 being lower left corner of bounding box, and going counter-clockwise from that point.'
)
try:
leftlonlim = boundingBox[0][0]
rightlonlim = boundingBox[1][0]
lowerlatlim = boundingBox[0][1]
upperlatlim = boundingBox[1][1]
except:
raise ValueError(
'provide arg boundingBox in fmt [[x1,y1], [x2, y2], [x3, y3], [x4, y4]] \n With x1,y1 being lower left corner of bounding box, and going counter-clockwise from that point.'
)
selectProfiles = (df.LATITUDE >= lowerlatlim) & (
df.LATITUDE <= upperlatlim) & (df.LONGITUDE >= leftlonlim) & (
df.LONGITUDE <= rightlonlim) & (~df.CTEMP.isnull())
if xlat:
dist = df.loc[selectProfiles, 'LATITUDE']
else:
dist = df.loc[selectProfiles, 'DIST_GLINE']
depth = df.loc[selectProfiles, 'DEPTH']
gamman = df.loc[selectProfiles, 'gamman']
if xlat:
ndist = int((np.max(dist) - np.min(dist)) / 0.01)
else:
ndist = int(df.loc[selectProfiles, 'DIST_GLINE'].max() / 10.)
dist_grid = np.linspace(np.min(dist), np.max(dist), ndist)
ndepth = int(np.abs(df.loc[selectProfiles, 'DEPTH'].min()) / 10.)
depth_grid = np.linspace(df.loc[selectProfiles, 'DEPTH'].min(), 0, ndepth)
gamman_interpolated = mlab.griddata(dist,
depth,
gamman,
dist_grid,
depth_grid,
interp='linear')
cs = ax.scatter(dist,
df.loc[selectProfiles, 'DEPTH'],
c=df.loc[selectProfiles, 'CTEMP'])
if levels:
cs_gamman = ax.contour(dist_grid,
depth_grid,
gamman_interpolated,
levels,
colors='0.5')
else:
cs_gamman = ax.contour(dist_grid,
depth_grid,
gamman_interpolated,
colors='0.5')
distSortedIndices = np.argsort(df.loc[selectProfiles, 'DIST_GLINE'])
if plotEcho:
depthMin = df.loc[selectProfiles].groupby(
pd.cut(df.loc[selectProfiles].DIST_GLINE,
dist_grid))[["DEPTH"]].min(axis=1).values
echodepthMin = df.loc[selectProfiles].groupby(
pd.cut(df.loc[selectProfiles].DIST_GLINE,
dist_grid))[["ECHODEPTH"]].min(axis=1).values
min_of_depth_echodepth = np.array(list(zip(depthMin,
echodepthMin))).min(axis=1)
ax.plot(dist_grid[:-1], min_of_depth_echodepth, linewidth=4, color='k')
#ax.set_xlim(df.loc[selectProfiles, 'DIST_GLINE'].min()-1, df.loc[selectProfiles, 'DIST_GLINE'].max()+1)
if not cline:
cline = np.arange(27.8, 28.5, 0.1)
ax.clabel(cs_gamman, colors='k', fontsize=14, fmt='%3.2f')
colorax = plt.subplot(gs[1, 0])
cbar1 = Colorbar(ax=colorax, mappable=cs, orientation='horizontal')
cbar1.ax.get_children()[0].set_linewidths(5)
cbar1.set_label(colorunit)
if plotTimeHist:
plt.close(2)
fig = plt.figure(2, figsize=(wd, ht))
uniqueProfs = df.loc[selectProfiles].groupby("PROFILE_NUMBER").head(
1).index
df.loc[uniqueProfs, "JULD"].hist()
plt.show()
if save:
plt.savefig(savename, dpi=300)
if show:
plt.show()
def plot_cartopy(lons, lats, size, color, labels=None, projection='global',
resolution='110m', continent_fill_color='0.8',
water_fill_color='1.0', colormap=None, colorbar=None,
marker="o", title=None, colorbar_ticklabel_format=None,
show=True, proj_kwargs=None, **kwargs): # @UnusedVariable
"""
Creates a Cartopy plot with a data point scatter plot.
:type lons: list/tuple of floats
:param lons: Longitudes of the data points.
:type lats: list/tuple of floats
:param lats: Latitudes of the data points.
:type size: float or list/tuple of floats
:param size: Size of the individual points in the scatter plot.
:type color: list/tuple of floats (or objects that can be
converted to floats, like e.g.
:class:`~obspy.core.utcdatetime.UTCDateTime`)
:param color: Color information of the individual data points to be
used in the specified color map (e.g. origin depths,
origin times).
:type labels: list/tuple of str
:param labels: Annotations for the individual data points.
:type projection: str, optional
:param projection: The map projection.
Currently supported are:
* ``"global"`` (Will plot the whole world using
:class:`~cartopy.crs.Mollweide`.)
* ``"ortho"`` (Will center around the mean lat/long using
:class:`~cartopy.crs.Orthographic`.)
* ``"local"`` (Will plot around local events using
:class:`~cartopy.crs.AlbersEqualArea`.)
* Any other Cartopy :class:`~cartopy.crs.Projection`. An instance
of this class will be created using the supplied ``proj_kwargs``.
Defaults to "global"
:type resolution: str, optional
:param resolution: Resolution of the boundary database to use. Will be
passed directly to the Cartopy module. Possible values are:
* ``"110m"``
* ``"50m"``
* ``"10m"``
Defaults to ``"110m"``. For compatibility, you may also specify any of
the Basemap resolutions defined in :func:`plot_basemap`.
:type continent_fill_color: Valid matplotlib color, optional
:param continent_fill_color: Color of the continents. Defaults to
``"0.9"`` which is a light gray.
:type water_fill_color: Valid matplotlib color, optional
:param water_fill_color: Color of all water bodies.
Defaults to ``"white"``.
:type colormap: str, any matplotlib colormap, optional
:param colormap: The colormap for color-coding the events as provided
in `color` kwarg.
The event with the smallest `color` property will have the
color of one end of the colormap and the event with the highest
`color` property the color of the other end with all other events
in between.
Defaults to None which will use the default matplotlib colormap.
:type colorbar: bool, optional
:param colorbar: When left `None`, a colorbar is plotted if more than one
object is plotted. Using `True`/`False` the colorbar can be forced
on/off.
:type title: str
:param title: Title above plot.
:type colorbar_ticklabel_format: str or function or
subclass of :class:`matplotlib.ticker.Formatter`
:param colorbar_ticklabel_format: Format string or Formatter used to format
colorbar tick labels.
:type show: bool
:param show: Whether to show the figure after plotting or not. Can be used
to do further customization of the plot before showing it.
:type proj_kwargs: dict
:param proj_kwargs: Keyword arguments to pass to the Cartopy
:class:`~cartopy.ccrs.Projection`. In this dictionary, you may specify
``central_longitude='auto'`` or ``central_latitude='auto'`` to have
this function calculate the latitude or longitude as it would for other
projections. Some arguments may be ignored if you choose one of the
built-in ``projection`` choices.
"""
import matplotlib.pyplot as plt
if isinstance(color[0], (datetime.datetime, UTCDateTime)):
datetimeplot = True
color = [date2num(getattr(t, 'datetime', t)) for t in color]
else:
datetimeplot = False
fig = plt.figure()
# The colorbar should only be plotted if more then one event is
# present.
if colorbar is not None:
show_colorbar = colorbar
else:
if len(lons) > 1 and hasattr(color, "__len__") and \
not isinstance(color, (str, native_str)):
show_colorbar = True
else:
show_colorbar = False
if projection == "local":
ax_x0, ax_width = 0.10, 0.80
elif projection == "global":
ax_x0, ax_width = 0.01, 0.98
else:
ax_x0, ax_width = 0.05, 0.90
proj_kwargs = proj_kwargs or {}
if projection == 'global':
proj_kwargs['central_longitude'] = np.mean(lons)
proj = ccrs.Mollweide(**proj_kwargs)
elif projection == 'ortho':
proj_kwargs['central_latitude'] = np.mean(lats)
proj_kwargs['central_longitude'] = mean_longitude(lons)
proj = ccrs.Orthographic(**proj_kwargs)
elif projection == 'local':
if min(lons) < -150 and max(lons) > 150:
max_lons = max(np.array(lons) % 360)
min_lons = min(np.array(lons) % 360)
else:
max_lons = max(lons)
min_lons = min(lons)
lat_0 = max(lats) / 2. + min(lats) / 2.
lon_0 = max_lons / 2. + min_lons / 2.
if lon_0 > 180:
lon_0 -= 360
deg2m_lat = 2 * np.pi * 6371 * 1000 / 360
deg2m_lon = deg2m_lat * np.cos(lat_0 / 180 * np.pi)
if len(lats) > 1:
height = (max(lats) - min(lats)) * deg2m_lat
width = (max_lons - min_lons) * deg2m_lon
margin = 0.2 * (width + height)
height += margin
width += margin
else:
height = 2.0 * deg2m_lat
width = 5.0 * deg2m_lon
# Do intelligent aspect calculation for local projection
# adjust to figure dimensions
w, h = fig.get_size_inches()
aspect = w / h
if show_colorbar:
aspect *= 1.2
if width / height < aspect:
width = height * aspect
else:
height = width / aspect
proj_kwargs['central_latitude'] = lat_0
proj_kwargs['central_longitude'] = lon_0
proj_kwargs['standard_parallels'] = [lat_0, lat_0]
proj = ccrs.AlbersEqualArea(**proj_kwargs)
# User-supplied projection.
elif isinstance(projection, type):
if 'central_longitude' in proj_kwargs:
if proj_kwargs['central_longitude'] == 'auto':
proj_kwargs['central_longitude'] = mean_longitude(lons)
if 'central_latitude' in proj_kwargs:
if proj_kwargs['central_latitude'] == 'auto':
proj_kwargs['central_latitude'] = np.mean(lats)
if 'pole_longitude' in proj_kwargs:
if proj_kwargs['pole_longitude'] == 'auto':
proj_kwargs['pole_longitude'] = np.mean(lons)
if 'pole_latitude' in proj_kwargs:
if proj_kwargs['pole_latitude'] == 'auto':
proj_kwargs['pole_latitude'] = np.mean(lats)
proj = projection(**proj_kwargs)
else:
msg = "Projection '%s' not supported." % projection
raise ValueError(msg)
if show_colorbar:
map_ax = fig.add_axes([ax_x0, 0.13, ax_width, 0.77], projection=proj)
cm_ax = fig.add_axes([ax_x0, 0.05, ax_width, 0.05])
plt.sca(map_ax)
else:
ax_y0, ax_height = 0.05, 0.85
if projection == "local":
ax_y0 += 0.05
ax_height -= 0.05
map_ax = fig.add_axes([ax_x0, ax_y0, ax_width, ax_height],
projection=proj)
if projection == 'local':
x0, y0 = proj.transform_point(lon_0, lat_0, proj.as_geodetic())
map_ax.set_xlim(x0 - width / 2, x0 + width / 2)
map_ax.set_ylim(y0 - height / 2, y0 + height / 2)
else:
map_ax.set_global()
# Pick features at specified resolution.
resolution = _CARTOPY_RESOLUTIONS[resolution]
try:
borders, land, ocean = _CARTOPY_FEATURES[resolution]
except KeyError:
borders = cfeature.NaturalEarthFeature(cfeature.BORDERS.category,
cfeature.BORDERS.name,
resolution,
edgecolor='none',
facecolor='none')
land = cfeature.NaturalEarthFeature(cfeature.LAND.category,
cfeature.LAND.name, resolution,
edgecolor='face', facecolor='none')
ocean = cfeature.NaturalEarthFeature(cfeature.OCEAN.category,
cfeature.OCEAN.name, resolution,
edgecolor='face',
facecolor='none')
_CARTOPY_FEATURES[resolution] = (borders, land, ocean)
# Draw coast lines, country boundaries, fill continents.
if MATPLOTLIB_VERSION >= [2, 0, 0]:
map_ax.set_facecolor(water_fill_color)
else:
map_ax.set_axis_bgcolor(water_fill_color)
map_ax.add_feature(ocean, facecolor=water_fill_color)
map_ax.add_feature(land, facecolor=continent_fill_color)
map_ax.add_feature(borders, edgecolor='0.75')
map_ax.coastlines(resolution=resolution, color='0.4')
# Draw grid lines - TODO: draw_labels=True doesn't work yet.
if projection == 'local':
map_ax.gridlines()
else:
# Draw lat/lon grid lines every 30 degrees.
map_ax.gridlines(xlocs=range(-180, 181, 30), ylocs=range(-90, 91, 30))
# Plot labels
if labels and len(lons) > 0:
with map_ax.hold_limits():
for name, xpt, ypt, _colorpt in zip(labels, lons, lats, color):
map_ax.text(xpt, ypt, name, weight="heavy", color="k",
zorder=100, transform=ccrs.Geodetic(),
path_effects=[
PathEffects.withStroke(linewidth=3,
foreground="white")])
scatter = map_ax.scatter(lons, lats, marker=marker, s=size, c=color,
zorder=10, cmap=colormap,
transform=ccrs.Geodetic())
if title:
plt.suptitle(title)
# Only show the colorbar for more than one event.
if show_colorbar:
if colorbar_ticklabel_format is not None:
if isinstance(colorbar_ticklabel_format, (str, native_str)):
formatter = FormatStrFormatter(colorbar_ticklabel_format)
elif hasattr(colorbar_ticklabel_format, '__call__'):
formatter = FuncFormatter(colorbar_ticklabel_format)
elif isinstance(colorbar_ticklabel_format, Formatter):
formatter = colorbar_ticklabel_format
locator = MaxNLocator(5)
else:
if datetimeplot:
locator = AutoDateLocator()
formatter = AutoDateFormatter(locator)
# Compat with old matplotlib versions.
if hasattr(formatter, "scaled"):
formatter.scaled[1 / (24. * 60.)] = '%H:%M:%S'
else:
locator = None
formatter = None
cb = Colorbar(cm_ax, scatter, cmap=colormap,
orientation='horizontal',
ticks=locator,
format=formatter)
# Compat with old matplotlib versions.
if hasattr(cb, "update_ticks"):
cb.update_ticks()
if show:
plt.show()
return fig
def plot_basemap(lons, lats, size, color, labels=None, projection='global',
resolution='l', continent_fill_color='0.8',
water_fill_color='1.0', colormap=None, colorbar=None,
marker="o", title=None, colorbar_ticklabel_format=None,
show=True, **kwargs): # @UnusedVariable
"""
Creates a basemap plot with a data point scatter plot.
:type lons: list/tuple of floats
:param lons: Longitudes of the data points.
:type lats: list/tuple of floats
:param lats: Latitudes of the data points.
:type size: float or list/tuple of floats
:param size: Size of the individual points in the scatter plot.
:type color: list/tuple of floats (or objects that can be
converted to floats, like e.g.
:class:`~obspy.core.utcdatetime.UTCDateTime`)
:param color: Color information of the individual data points to be
used in the specified color map (e.g. origin depths,
origin times).
:type labels: list/tuple of str
:param labels: Annotations for the individual data points.
:type projection: str, optional
:param projection: The map projection. Currently supported are
* ``"global"`` (Will plot the whole world.)
* ``"ortho"`` (Will center around the mean lat/long.)
* ``"local"`` (Will plot around local events)
Defaults to "global"
:type resolution: str, optional
:param resolution: Resolution of the boundary database to use. Will be
based directly to the basemap module. Possible values are
* ``"c"`` (crude)
* ``"l"`` (low)
* ``"i"`` (intermediate)
* ``"h"`` (high)
* ``"f"`` (full)
Defaults to ``"l"``. For compatibility, you may also specify any of the
Cartopy resolutions defined in :func:`plot_cartopy`.
:type continent_fill_color: Valid matplotlib color, optional
:param continent_fill_color: Color of the continents. Defaults to
``"0.9"`` which is a light gray.
:type water_fill_color: Valid matplotlib color, optional
:param water_fill_color: Color of all water bodies.
Defaults to ``"white"``.
:type colormap: str, any matplotlib colormap, optional
:param colormap: The colormap for color-coding the events as provided
in `color` kwarg.
The event with the smallest `color` property will have the
color of one end of the colormap and the event with the highest
`color` property the color of the other end with all other events
in between.
Defaults to None which will use the default matplotlib colormap.
:type colorbar: bool, optional
:param colorbar: When left `None`, a colorbar is plotted if more than one
object is plotted. Using `True`/`False` the colorbar can be forced
on/off.
:type title: str
:param title: Title above plot.
:type colorbar_ticklabel_format: str or function or
subclass of :class:`matplotlib.ticker.Formatter`
:param colorbar_ticklabel_format: Format string or Formatter used to format
colorbar tick labels.
:type show: bool
:param show: Whether to show the figure after plotting or not. Can be used
to do further customization of the plot before showing it.
"""
min_color = min(color)
max_color = max(color)
if any([isinstance(c, (datetime.datetime, UTCDateTime)) for c in color]):
datetimeplot = True
color = [np.isfinite(float(t)) and date2num(t) or np.nan
for t in color]
else:
datetimeplot = False
scal_map = ScalarMappable(norm=Normalize(min_color, max_color),
cmap=colormap)
scal_map.set_array(np.linspace(0, 1, 1))
fig = plt.figure()
# The colorbar should only be plotted if more then one event is
# present.
if colorbar is not None:
show_colorbar = colorbar
else:
if len(lons) > 1 and hasattr(color, "__len__") and \
not isinstance(color, (str, native_str)):
show_colorbar = True
else:
show_colorbar = False
if projection == "local":
ax_x0, ax_width = 0.10, 0.80
elif projection == "global":
ax_x0, ax_width = 0.01, 0.98
else:
ax_x0, ax_width = 0.05, 0.90
if show_colorbar:
map_ax = fig.add_axes([ax_x0, 0.13, ax_width, 0.77])
cm_ax = fig.add_axes([ax_x0, 0.05, ax_width, 0.05])
else:
ax_y0, ax_height = 0.05, 0.85
if projection == "local":
ax_y0 += 0.05
ax_height -= 0.05
map_ax = fig.add_axes([ax_x0, ax_y0, ax_width, ax_height])
if projection == 'global':
bmap = Basemap(projection='moll', lon_0=round(np.mean(lons), 4),
resolution=_BASEMAP_RESOLUTIONS[resolution], ax=map_ax)
elif projection == 'ortho':
bmap = Basemap(projection='ortho',
resolution=_BASEMAP_RESOLUTIONS[resolution],
area_thresh=1000.0, lat_0=round(np.mean(lats), 4),
lon_0=round(np.mean(lons), 4), ax=map_ax)
elif projection == 'local':
if min(lons) < -150 and max(lons) > 150:
max_lons = max(np.array(lons) % 360)
min_lons = min(np.array(lons) % 360)
else:
max_lons = max(lons)
min_lons = min(lons)
lat_0 = max(lats) / 2. + min(lats) / 2.
lon_0 = max_lons / 2. + min_lons / 2.
if lon_0 > 180:
lon_0 -= 360
deg2m_lat = 2 * np.pi * 6371 * 1000 / 360
deg2m_lon = deg2m_lat * np.cos(lat_0 / 180 * np.pi)
if len(lats) > 1:
height = (max(lats) - min(lats)) * deg2m_lat
width = (max_lons - min_lons) * deg2m_lon
margin = 0.2 * (width + height)
height += margin
width += margin
else:
height = 2.0 * deg2m_lat
width = 5.0 * deg2m_lon
# do intelligent aspect calculation for local projection
# adjust to figure dimensions
w, h = fig.get_size_inches()
aspect = w / h
if show_colorbar:
aspect *= 1.2
if width / height < aspect:
width = height * aspect
else:
height = width / aspect
bmap = Basemap(projection='aea',
resolution=_BASEMAP_RESOLUTIONS[resolution],
area_thresh=1000.0, lat_0=round(lat_0, 4),
lon_0=round(lon_0, 4),
width=width, height=height, ax=map_ax)
# not most elegant way to calculate some round lats/lons
def linspace2(val1, val2, N):
"""
returns around N 'nice' values between val1 and val2
"""
dval = val2 - val1
round_pos = int(round(-np.log10(1. * dval / N)))
# Fake negative rounding as not supported by future as of now.
if round_pos < 0:
factor = 10 ** (abs(round_pos))
delta = round(2. * dval / N / factor) * factor / 2
else:
delta = round(2. * dval / N, round_pos) / 2
new_val1 = np.ceil(val1 / delta) * delta
new_val2 = np.floor(val2 / delta) * delta
N = (new_val2 - new_val1) / delta + 1
return np.linspace(new_val1, new_val2, N)
N1 = int(np.ceil(height / max(width, height) * 8))
N2 = int(np.ceil(width / max(width, height) * 8))
parallels = linspace2(lat_0 - height / 2 / deg2m_lat,
lat_0 + height / 2 / deg2m_lat, N1)
# Old basemap versions have problems with non-integer parallels.
try:
bmap.drawparallels(parallels, labels=[0, 1, 1, 0])
except KeyError:
parallels = sorted(list(set(map(int, parallels))))
bmap.drawparallels(parallels, labels=[0, 1, 1, 0])
if min(lons) < -150 and max(lons) > 150:
lon_0 %= 360
meridians = linspace2(lon_0 - width / 2 / deg2m_lon,
lon_0 + width / 2 / deg2m_lon, N2)
meridians[meridians > 180] -= 360
bmap.drawmeridians(meridians, labels=[1, 0, 0, 1])
else:
msg = "Projection '%s' not supported." % projection
raise ValueError(msg)
# draw coast lines, country boundaries, fill continents.
map_ax.set_axis_bgcolor(water_fill_color)
bmap.drawcoastlines(color="0.4")
bmap.drawcountries(color="0.75")
bmap.fillcontinents(color=continent_fill_color,
lake_color=water_fill_color)
# draw the edge of the bmap projection region (the projection limb)
bmap.drawmapboundary(fill_color=water_fill_color)
# draw lat/lon grid lines every 30 degrees.
bmap.drawmeridians(np.arange(-180, 180, 30))
bmap.drawparallels(np.arange(-90, 90, 30))
# compute the native bmap projection coordinates for events.
x, y = bmap(lons, lats)
# plot labels
if labels:
if 100 > len(lons) > 1:
for name, xpt, ypt, _colorpt in zip(labels, x, y, color):
# Check if the point can actually be seen with the current bmap
# projection. The bmap object will set the coordinates to very
# large values if it cannot project a point.
if xpt > 1e25:
continue
map_ax.text(xpt, ypt, name, weight="heavy",
color="k", zorder=100,
path_effects=[
PathEffects.withStroke(linewidth=3,
foreground="white")])
elif len(lons) == 1:
map_ax.text(x[0], y[0], labels[0], weight="heavy", color="k",
path_effects=[
PathEffects.withStroke(linewidth=3,
foreground="white")])
# scatter plot is removing valid x/y points with invalid color value,
# so we plot those points separately.
try:
nan_points = np.isnan(np.array(color, dtype=np.float))
except ValueError:
# `color' was not a list of values, but a list of colors.
pass
else:
if nan_points.any():
x_ = np.array(x)[nan_points]
y_ = np.array(y)[nan_points]
size_ = np.array(size)[nan_points]
scatter = bmap.scatter(x_, y_, marker=marker, s=size_, c="0.3",
zorder=10, cmap=None)
scatter = bmap.scatter(x, y, marker=marker, s=size, c=color,
zorder=10, cmap=colormap)
if title:
plt.suptitle(title)
# Only show the colorbar for more than one event.
if show_colorbar:
if colorbar_ticklabel_format is not None:
if isinstance(colorbar_ticklabel_format, (str, native_str)):
formatter = FormatStrFormatter(colorbar_ticklabel_format)
elif hasattr(colorbar_ticklabel_format, '__call__'):
formatter = FuncFormatter(colorbar_ticklabel_format)
elif isinstance(colorbar_ticklabel_format, Formatter):
formatter = colorbar_ticklabel_format
locator = MaxNLocator(5)
else:
if datetimeplot:
locator = AutoDateLocator()
formatter = AutoDateFormatter(locator)
# Compat with old matplotlib versions.
if hasattr(formatter, "scaled"):
formatter.scaled[1 / (24. * 60.)] = '%H:%M:%S'
else:
locator = None
formatter = None
cb = Colorbar(cm_ax, scatter, cmap=colormap,
orientation='horizontal',
ticks=locator,
format=formatter)
# Compat with old matplotlib versions.
if hasattr(cb, "update_ticks"):
cb.update_ticks()
if show:
plt.show()
return fig
def diffraction_plot(diffraction,
k_values,
ax=None,
cmap="afmhot",
vmin=4e-6,
vmax=0.7):
"""Helper function to plot diffraction pattern.
Args:
diffraction (:class:`numpy.ndarray`):
Diffraction image data.
k_values (:class:`numpy.ndarray`):
:math:`k` value magnitudes for each bin of the diffraction image.
ax (:class:`matplotlib.axes.Axes`):
Axes object to plot. If :code:`None`, make a new axes and figure
object (Default value = :code:`None`).
cmap (str):
Colormap name to use (Default value = :code:`'afmhot'`).
vmin (float):
Minimum of the color scale (Default value = 4e-6).
vmax (float):
Maximum of the color scale (Default value = 0.7).
Returns:
:class:`matplotlib.axes.Axes`: Axes object with the diagram.
"""
import matplotlib.colors
from matplotlib.colorbar import Colorbar
from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable
if ax is None:
fig = plt.figure()
ax = fig.subplots()
# Plot the diffraction image and color bar
norm = matplotlib.colors.LogNorm(vmin=vmin, vmax=vmax)
im = ax.imshow(np.clip(diffraction, vmin, vmax),
interpolation="nearest",
cmap=cmap,
norm=norm)
ax_divider = make_axes_locatable(ax)
cax = ax_divider.append_axes("right", size="7%", pad="10%")
cb = Colorbar(cax, im)
cb.set_label(r"$S(\vec{k})$")
# Determine the number of ticks on the axis
grid_size = diffraction.shape[0]
num_ticks = len(
[i for i in ax.xaxis.get_ticklocs() if 0 <= i <= grid_size])
# Ensure there are an odd number of ticks, so that there is a tick at zero
num_ticks += 1 - num_ticks % 2
ticks = np.linspace(0, grid_size, num_ticks)
# Set tick locations and labels
tick_labels = np.interp(ticks, range(grid_size), k_values)
tick_labels = [f"{x:.3g}" for x in tick_labels]
ax.xaxis.set_ticks(ticks)
ax.xaxis.set_ticklabels(tick_labels)
ax.yaxis.set_ticks(ticks)
ax.yaxis.set_ticklabels(tick_labels)
# Set title, limits, aspect
ax.set_title("Diffraction Pattern")
ax.set_aspect("equal", "datalim")
ax.set_xlabel("$k_x$")
ax.set_ylabel("$k_y$")
return ax
def add_ortho(lats, lons, colors, CClim,
central_longitude, central_latitude,
text=None, size=50, marker=['o', 'd'],
colormap='viridis', fig=None,
rect=[0.0, 0.0, 1.0, 1.0]):
if not fig:
fig = plt.figure()
proj = ccrs.Orthographic(central_longitude=central_longitude,
central_latitude=central_latitude)
# left, bottom, width, height
ax = fig.add_axes([rect[0],
rect[1] + rect[3] * 0.12,
rect[2],
rect[3] * 0.85],
projection=proj)
cm_ax = fig.add_axes([rect[0],
rect[1],
rect[2],
rect[3] * 0.08])
plt.sca(ax)
# make the map global rather than have it zoom in to
# the extents of any plotted data
ax.set_global()
ax.stock_img()
ax.coastlines()
ax.gridlines()
lats_mark1 = []
lons_mark1 = []
colors_mark1 = []
lats_mark2 = []
lons_mark2 = []
colors_mark2 = []
cmap = get_cmap(colormap)
cmap.set_under('grey')
for lon, lat, color in zip(lons, lats, colors):
if color > CClim:
lats_mark1.append(lat)
lons_mark1.append(lon)
colors_mark1.append(color)
else:
lats_mark2.append(lat)
lons_mark2.append(lon)
colors_mark2.append(color)
if len(lons_mark1) > 0:
scatter = ax.scatter(lons_mark1, lats_mark1, s=size, c=colors_mark1,
marker=marker[0],
cmap=cmap, vmin=CClim, vmax=1, zorder=10,
transform=ccrs.Geodetic())
if len(lons_mark2) > 0:
scatter = ax.scatter(lons_mark2, lats_mark2, s=size, c=colors_mark2,
marker=marker[1],
cmap=cmap, vmin=CClim, vmax=1, zorder=10,
transform=ccrs.Geodetic())
locator = MaxNLocator(5)
cb = Colorbar(cm_ax, scatter, cmap=cmap,
orientation='horizontal',
ticks=locator,
extend='min')
cb.set_label('CC')
# Compat with old matplotlib versions.
if hasattr(cb, "update_ticks"):
cb.update_ticks()
ax.plot(central_longitude, central_latitude, color='red', marker='*',
markersize=np.sqrt(size))
if (text):
for lat, lon, text in zip(lats, lons, text):
# Avoid plotting invisible texts. They clutter at the origin
# otherwise
dist = locations2degrees(lat, lon,
central_latitude, central_longitude)
if (dist < 90):
plt.text(lon, lat, text, weight="heavy",
transform=ccrs.Geodetic(),
color="k", zorder=100,
path_effects=[
PathEffects.withStroke(linewidth=3,
foreground="white")])
return ax
class ColorbarWidget(QWidget):
colorbarChanged = Signal() # The parent should simply redraw their canvas
def __init__(self, parent=None):
super(ColorbarWidget, self).__init__(parent)
self.setWindowTitle("Colorbar")
self.setMaximumWidth(200)
self.cmap = QComboBox()
self.cmap.addItems(sorted(cm.cmap_d.keys()))
self.cmap.currentIndexChanged.connect(self.cmap_index_changed)
self.cmin = QLineEdit()
self.cmin_value = 0
self.cmin.setMaximumWidth(100)
self.cmin.editingFinished.connect(self.clim_changed)
self.cmin_layout = QHBoxLayout()
self.cmin_layout.addStretch()
self.cmin_layout.addWidget(self.cmin)
self.cmin_layout.addStretch()
self.cmax = QLineEdit()
self.cmax_value = 1
self.cmax.setMaximumWidth(100)
self.cmax.editingFinished.connect(self.clim_changed)
self.cmin.setValidator(QDoubleValidator())
self.cmax.setValidator(QDoubleValidator())
self.cmax_layout = QHBoxLayout()
self.cmax_layout.addStretch()
self.cmax_layout.addWidget(self.cmax)
self.cmax_layout.addStretch()
self.norm_layout = QHBoxLayout()
self.norm = QComboBox()
self.norm.addItems(NORM_OPTS)
self.norm.currentIndexChanged.connect(self.norm_changed)
self.powerscale = QLineEdit()
self.powerscale_value = 2
self.powerscale.setText("2")
self.powerscale.setValidator(QDoubleValidator(0.001,100,3))
self.powerscale.setMaximumWidth(50)
self.powerscale.editingFinished.connect(self.norm_changed)
self.powerscale.hide()
self.powerscale_label = QLabel("n=")
self.powerscale_label.hide()
self.norm_layout.addStretch()
self.norm_layout.addWidget(self.norm)
self.norm_layout.addStretch()
self.norm_layout.addWidget(self.powerscale_label)
self.norm_layout.addWidget(self.powerscale)
self.autoscale = QCheckBox("Autoscaling")
self.autoscale.setChecked(True)
self.autoscale.stateChanged.connect(self.update_clim)
self.canvas = FigureCanvas(Figure())
if parent:
# Set facecolor to match parent
self.canvas.figure.set_facecolor(parent.palette().window().color().getRgbF())
self.ax = self.canvas.figure.add_axes([0.4,0.05,0.2,0.9])
# layout
self.layout = QVBoxLayout(self)
self.layout.addWidget(self.cmap)
self.layout.addLayout(self.cmax_layout)
self.layout.addWidget(self.canvas, stretch=1)
self.layout.addLayout(self.cmin_layout)
self.layout.addLayout(self.norm_layout)
self.layout.addWidget(self.autoscale)
def set_mappable(self, mappable):
"""
When a new plot is created this method should be called with the new mappable
"""
self.ax.clear()
try: # Use current cmap
cmap = self.colorbar.get_cmap()
except AttributeError:
try: # else use viridis
cmap = cm.viridis
except AttributeError: # else default
cmap = None
self.colorbar = Colorbar(ax=self.ax, mappable=mappable)
self.cmin_value, self.cmax_value = self.colorbar.get_clim()
self.update_clim_text()
self.cmap_changed(cmap)
self.cmap.setCurrentIndex(sorted(cm.cmap_d.keys()).index(self.colorbar.get_cmap().name))
self.redraw()
def cmap_index_changed(self):
self.cmap_changed(self.cmap.currentText())
def cmap_changed(self, name):
self.colorbar.set_cmap(name)
self.colorbar.mappable.set_cmap(name)
self.redraw()
def norm_changed(self):
"""
Called when a different normalization is selected
"""
idx = self.norm.currentIndex()
if NORM_OPTS[idx] == 'Power':
self.powerscale.show()
self.powerscale_label.show()
else:
self.powerscale.hide()
self.powerscale_label.hide()
self.colorbar.mappable.set_norm(self.get_norm())
self.set_mappable(self.colorbar.mappable)
def get_norm(self):
"""
This will create a matplotlib.colors.Normalize from selected idx, limits and powerscale
"""
idx = self.norm.currentIndex()
if self.autoscale.isChecked():
cmin = cmax = None
else:
cmin = self.cmin_value
cmax = self.cmax_value
if NORM_OPTS[idx] == 'Power':
if self.powerscale.hasAcceptableInput():
self.powerscale_value = float(self.powerscale.text())
return PowerNorm(gamma=self.powerscale_value, vmin=cmin, vmax=cmax)
elif NORM_OPTS[idx] == "SymmetricLog10":
return SymLogNorm(1e-8 if cmin is None else max(1e-8, abs(cmin)*1e-3),
vmin=cmin, vmax=cmax)
else:
return Normalize(vmin=cmin, vmax=cmax)
def clim_changed(self):
"""
Called when either the min or max is changed. Will unset the autoscale.
"""
self.autoscale.blockSignals(True)
self.autoscale.setChecked(False)
self.autoscale.blockSignals(False)
self.update_clim()
def update_clim(self):
"""
This will update the clim of the plot based on min, max, and autoscale
"""
if self.autoscale.isChecked():
data = self.colorbar.mappable.get_array()
try:
try:
self.cmin_value = data[~data.mask].min()
self.cmax_value = data[~data.mask].max()
except AttributeError:
self.cmin_value = np.nanmin(data)
self.cmax_value = np.nanmax(data)
except (ValueError, RuntimeWarning):
# all values mask
pass
self.update_clim_text()
else:
if self.cmin.hasAcceptableInput():
cmin = float(self.cmin.text())
if cmin < self.cmax_value:
self.cmin_value = cmin
else: # reset values back
self.update_clim_text()
if self.cmax.hasAcceptableInput():
cmax = float(self.cmax.text())
if cmax > self.cmin_value:
self.cmax_value = cmax
else: #reset values back
self.update_clim_text()
self.colorbar.set_clim(self.cmin_value, self.cmax_value)
self.redraw()
def update_clim_text(self):
"""
Update displayed limit values based on stored ones
"""
self.cmin.setText("{:.4}".format(self.cmin_value))
self.cmax.setText("{:.4}".format(self.cmax_value))
def redraw(self):
"""
Redraws the colobar and emits signal to cause the parent to redraw
"""
self.colorbar.update_ticks()
self.colorbar.draw_all()
self.canvas.draw_idle()
self.colorbarChanged.emit()
def plot(self, figure=None, overlays=[], colorbar=True, vmin=None,
vmax=None, linear=True, showz=True, yres=DEFAULT_YRES,
max_dist=None, **matplotlib_args):
"""
Plot spectrogram onto figure.
Parameters
----------
figure : `~matplotlib.Figure`
Figure to plot the spectrogram on. If None, new Figure is created.
overlays : list
List of overlays (functions that receive figure and axes and return
new ones) to be applied after drawing.
colorbar : bool
Flag that determines whether or not to draw a colorbar. If existing
figure is passed, it is attempted to overdraw old colorbar.
vmin : float
Clip intensities lower than vmin before drawing.
vmax : float
Clip intensities higher than vmax before drawing.
linear : bool
If set to True, "stretch" image to make frequency axis linear.
showz : bool
If set to True, the value of the pixel that is hovered with the
mouse is shown in the bottom right corner.
yres : int or None
To be used in combination with linear=True. If None, sample the
image with half the minimum frequency delta. Else, sample the
image to be at most yres pixels in vertical dimension. Defaults
to 1080 because that's a common screen size.
max_dist : float or None
If not None, mask elements that are further than max_dist away
from actual data points (ie, frequencies that actually have data
from the receiver and are not just nearest-neighbour interpolated).
"""
# [] as default argument is okay here because it is only read.
# pylint: disable=W0102,R0914
if linear:
delt = yres
if delt is not None:
delt = max(
(self.freq_axis[0] - self.freq_axis[-1]) / (yres - 1),
_min_delt(self.freq_axis) / 2.
)
delt = float(delt)
data = _LinearView(self.clip_values(vmin, vmax), delt)
freqs = np.arange(
self.freq_axis[0], self.freq_axis[-1], -data.delt
)
else:
data = np.array(self.clip_values(vmin, vmax))
freqs = self.freq_axis
figure = plt.gcf()
if figure.axes:
axes = figure.axes[0]
else:
axes = figure.add_subplot(111)
params = {
'origin': 'lower',
'aspect': 'auto',
}
params.update(matplotlib_args)
if linear and max_dist is not None:
toplot = ma.masked_array(data, mask=data.make_mask(max_dist))
else:
toplot = data
im = axes.imshow(toplot, **params)
xa = axes.get_xaxis()
ya = axes.get_yaxis()
xa.set_major_formatter(
FuncFormatter(self.time_formatter)
)
if linear:
# Start with a number that is divisible by 5.
init = (self.freq_axis[0] % 5) / data.delt
nticks = 15.
# Calculate MHz difference between major ticks.
dist = (self.freq_axis[0] - self.freq_axis[-1]) / nticks
# Round to next multiple of 10, at least ten.
dist = max(round(dist, -1), 10)
# One pixel in image space is data.delt MHz, thus we can convert
# our distance between the major ticks into image space by dividing
# it by data.delt.
ya.set_major_locator(
IndexLocator(
dist / data.delt, init
)
)
ya.set_minor_locator(
IndexLocator(
dist / data.delt / 10, init
)
)
def freq_fmt(x, pos):
# This is necessary because matplotlib somehow tries to get
# the mid-point of the row, which we do not need here.
x = x + 0.5
return self.format_freq(self.freq_axis[0] - x * data.delt)
else:
freq_fmt = _list_formatter(freqs, self.format_freq)
ya.set_major_locator(MaxNLocator(integer=True, steps=[1, 5, 10]))
ya.set_major_formatter(
FuncFormatter(freq_fmt)
)
axes.set_xlabel(self.t_label)
axes.set_ylabel(self.f_label)
# figure.suptitle(self.content)
figure.suptitle(
' '.join([
get_day(self.start).strftime("%d %b %Y"),
'Radio flux density',
'(' + ', '.join(self.instruments) + ')',
])
)
for tl in xa.get_ticklabels():
tl.set_fontsize(10)
tl.set_rotation(30)
figure.add_axes(axes)
figure.subplots_adjust(bottom=0.2)
figure.subplots_adjust(left=0.2)
if showz:
axes.format_coord = self._mk_format_coord(
data, figure.gca().format_coord)
if colorbar:
if len(figure.axes) > 1:
Colorbar(figure.axes[1], im).set_label("Intensity")
else:
figure.colorbar(im).set_label("Intensity")
for overlay in overlays:
figure, axes = overlay(figure, axes)
for ax in figure.axes:
ax.autoscale()
if isinstance(figure, SpectroFigure):
figure._init(self, freqs)
return axes
def plot_global_qz(pickle_fn, do_all_diags = True, show_plots = True, save_loc = None):
''' A plotting function designed to plot the pickle output from pyqz.get_global_qz().
:Args:
pickel_fn: string
the path+filename of the pickle filed to process.
do_all_diags: bool [default: True]
Whether to construct the diagnostic grid plots for all individual
diagnostics or not.
show_plots: bool [default: True]
Whether to display the plots or not.
save_loc: string [default: None][
If set, the location where the plots will be saved. If not set, no plots
will be saved.
:Notes:
You must set KDE_pickle_loc to the location of your choice when running
pyqz.get_global_qz() and pyqz.get_global_qz_ff(), if you want the associated
pickle file to be generated.
'''
# 0) Open the pickle file, and check what we are dealing with ...
ftmp = open(pickle_fn,'r')
KDE_frompickle = pickle.load(ftmp)
ftmp.close()
# What will I call my plots ?
ids = KDE_frompickle['ids']
Pk = KDE_frompickle['Pk']
kappa = KDE_frompickle['kappa']
struct = KDE_frompickle['struct']
sampling = KDE_frompickle['sampling']
KDE_method = KDE_frompickle['KDE_method']
fn_in = pyqz_tools.get_KDE_picklefn(ids, Pk, kappa, struct, sampling, KDE_method)
# First things first. Generate the grid plots for all the diagnostics. ---------------
discrete_pdf = KDE_frompickle['discrete_pdf']
rsf = KDE_frompickle['rsf']
rsf_keys = KDE_frompickle['rsf_keys']
if do_all_diags:
for key in discrete_pdf.keys():
# Reconstruct the line flux mix from the raw rsf data
Rval = []
for (r,ratio) in enumerate(key.split('|')[0].split(';')):
l1 = ratio.split('/')[0]
l2 = ratio.split('/')[1]
Rval.append(np.log10(rsf[:,rsf_keys.index(l1)]/
rsf[:,rsf_keys.index(l2)]))
if save_loc:
plot_name = os.path.join(save_loc, fn_in[:-4] + '_' +
key.replace('/','-').replace(';','_vs_').replace('|','_')
+ '.pdf')
else:
plot_name = None
plot_grid(key.split('|')[0],
coeffs = diagnostics[key.split('|')[0]]['coeffs'],
Pk = Pk, kappa=kappa, struct = struct, sampling = sampling,
color_mode = key.split('|')[1],
figname = plot_name, show_plot = show_plots,
data = Rval, interp_data = discrete_pdf[key])
# Let's get started with the KDE plot ------------------------------------------------
plt.figure(figsize=(13,8))
gs = gridspec.GridSpec(2,2, height_ratios=[0.05,1.], width_ratios=[1.,1.])
gs.update(left=0.1, right=0.95, bottom=0.1,top=0.9, wspace=0.15, hspace=0.07 )
ax1 = plt.subplot(gs[1,0])
ax2 = plt.subplot(gs[1,1])
# First, the direct estimates --------------------------------------------------------
qzs = KDE_frompickle['qzs']
which_grids = KDE_frompickle['which_grids']
# Create an array to keep track of how big my zoom window will be for ax2
ax2_lims = [np.nan, np.nan, np.nan, np.nan]
for (k,key) in enumerate(discrete_pdf.keys()):
# Make sure we show each point only once
if not(qzs[0] in key):
continue
# Don't do anything if the point lands outside the plot.
if np.isnan(discrete_pdf[key][0]):
continue
this_diag = key.split('|')[0]
for ax in [ax1,ax2]:
# The individual realizations
ax.scatter(discrete_pdf[this_diag+'|'+qzs[0]][1:],
discrete_pdf[this_diag+'|'+qzs[1]][1:],
c='k', marker = 'o', s = 1, zorder = 2)
# Update the zoom-window limits if required
ax2_lims = [np.nanmin(( ax2_lims[0],
np.nanmin(discrete_pdf[this_diag+'|'+qzs[0]][1:])
)),
np.nanmax(( ax2_lims[1],
np.nanmax(discrete_pdf[this_diag+'|'+qzs[0]][1:])
)),
np.nanmin(( ax2_lims[2],
np.nanmin(discrete_pdf[this_diag+'|'+qzs[1]][1:])
)),
np.nanmax(( ax2_lims[3],
np.nanmax(discrete_pdf[this_diag+'|'+qzs[1]][1:])
)),
]
# The direct estimate
ax.plot(discrete_pdf[this_diag+'|'+qzs[0]][0],
discrete_pdf[this_diag+'|'+qzs[1]][0],
c='w', marker = 's',markeredgewidth=1.5,
markerfacecolor='w',
markeredgecolor='k', markersize=11, zorder=10)
grid_number = which_grids.index(this_diag)+1
ax.text(discrete_pdf[this_diag+'|'+qzs[0]][0],
discrete_pdf[this_diag+'|'+qzs[1]][0],
grid_number,
size=12, ha='center',va='center', zorder=11, color='k')
if ax == ax1:
# And also add the name of the diagnostic
ax.text(QZs_lim[qzs[0]][0] +0.05, QZs_lim[qzs[1]][1] - 0.05*grid_number,
'%i: %s' % (grid_number,this_diag),
horizontalalignment = 'left', verticalalignment = 'center')
# Now, plot the global KDE and the associated contours -------------------------------
all_gridZ = KDE_frompickle['all_gridZ']
gridX = KDE_frompickle['gridX']
gridY = KDE_frompickle['gridY']
final_data = KDE_frompickle['final_data']
final_cols = KDE_frompickle['final_cols']
# Loop through all reconstructed KDEs. Plot all the contours, but only the full KDE.
kde = False
for gridZ_key in all_gridZ.keys():
# If it is just some nans, go no further
if np.all(np.isnan(all_gridZ[gridZ_key])):
continue
# Careful here: gridZ has a weird arrangement ...
gridZ = np.rot90(all_gridZ[gridZ_key])[::-1,:]
for ax in [ax1,ax2]:
if gridZ_key == 'all':
my_c = 'darkorange'
my_c2 = 'none'
my_lw = 2.5
my_zo = 7
# Plot the KDE
kde = ax.imshow(gridZ,
extent=[QZs_lim[qzs[0]][0],
QZs_lim[qzs[0]][1],
QZs_lim[qzs[1]][0],
QZs_lim[qzs[1]][1],
],
cmap=pyqz_cmap_1,
origin='lower',
zorder=0, interpolation='nearest')
else:
my_c = 'royalblue'
my_c2 = 'none'
my_lw = 1.5
my_zo = 3
# Plot the contour (two times for the look)
# Mind the fact that gridX and gridY refer to the "un-derotated" gridZ !
kde_cont = ax.contour(gridX, gridY, all_gridZ[gridZ_key], [PDF_cont_level],
colors = my_c, linestyles = '-', linewidths = my_lw,
zorder = my_zo)
# Plot the individual and global KDE estimates -------------------------------
if gridZ_key == 'all':
final_keys = ['<'+qzs[0]+'{KDE}>','err('+qzs[0]+'{KDE})',
'<'+qzs[1]+'{KDE}>','err('+qzs[1]+'{KDE})']
else:
final_keys = [gridZ_key+'|'+qzs[0]+'{KDE}',
'err('+gridZ_key+'|'+qzs[0]+'{KDE})',
gridZ_key+'|'+qzs[1]+'{KDE}',
'err('+gridZ_key+'|'+qzs[1]+'{KDE})']
mean_est = [final_data[final_cols.index(final_keys[0])],
final_data[final_cols.index(final_keys[2])]]
err_est = [final_data[final_cols.index(final_keys[1])],
final_data[final_cols.index(final_keys[3])]]
ax.errorbar(mean_est[0], mean_est[1],
xerr = err_est[0],yerr = err_est[1],
elinewidth = 2., ecolor = my_c, capthick = 0,
zorder = my_zo)
ax.plot(mean_est[0], mean_est[1],
c = my_c, marker = 'o', markersize = 10, markeredgecolor = my_c,
markerfacecolor = my_c2, markeredgewidth = 2, zorder = my_zo)
# Plot the combined direct estimates -------------------------------------------------
final_keys = ['<'+qzs[0]+'>','std('+qzs[0]+')', '<'+qzs[1]+'>','std('+qzs[1]+')']
mean_est = [final_data[final_cols.index(final_keys[0])],
final_data[final_cols.index(final_keys[2])]]
err_est = [final_data[final_cols.index(final_keys[1])],
final_data[final_cols.index(final_keys[3])]]
# Only if that value actually exists !
if not(np.any(np.isnan(mean_est))):
for ax in [ax1,ax2]:
ax.errorbar(mean_est[0], mean_est[1],
xerr = err_est[0], yerr = err_est[1],
elinewidth = 2,
ecolor = 'k', capthick = 0, zorder = 8)
ax.plot(mean_est[0],mean_est[1],
'*', c = 'w', markeredgecolor = 'k',
markeredgewidth = 2, markerfacecolor = 'w',
markersize = 20, zorder = 9)
# Very well, finalize the plot now.
for ax in [ax1, ax2]:
ax.set_xlabel(qzs[0])
ax.grid(True)
# Set the left plot to cover the full extent of the qz plane
ax1.set_xlim(QZs_lim[qzs[0]])
ax1.set_ylim(QZs_lim[qzs[1]])
ax1.set_ylabel(qzs[1])
# Define the limits for the right plot - a zoomed-in version
if np.any(np.isnan(ax2_lims)):
ax2.set_xlim(QZs_lim[qzs[0]])
ax2.set_ylim(QZs_lim[qzs[1]])
else:
ax2.set_xlim(ax2_lims[:2])
ax2.set_ylim(ax2_lims[2:])
# Plot the window of the right plot in the left one
rectx = [ax2_lims[0], ax2_lims[1], ax2_lims[1], ax2_lims[0], ax2_lims[0]]
recty = [ax2_lims[2], ax2_lims[2], ax2_lims[3], ax2_lims[3], ax2_lims[2]]
ax1.plot(rectx,recty, 'k--', lw = 1.5, markersize=5,zorder=1)
ax2.set_aspect('auto')
ax1.set_aspect('auto')
ax1.locator_params(axis='x',nbins=5)
ax2.locator_params(axis='x',nbins=5)
# Plot the colorbar if required
if kde:
cb_ax = plt.subplot(gs[0,:])
cb = Colorbar(ax = cb_ax, mappable = kde, orientation='horizontal')
# Colorbar legend
cb.set_label(r'Joint Probability Density (normalized to peak)', labelpad = -60)
cb.ax.xaxis.set_ticks_position('top')
cb.solids.set_edgecolor('face')
# Draw the 1-sigma level (assuming gaussian = 61% of the peak)
cb.ax.axvline(x = PDF_cont_level, color = 'darkorange', linewidth = 3,
linestyle = '-')
# Get ready to save this:
if save_loc:
plot_name = os.path.join(save_loc, fn_in[:-3]+'pdf')
plt.savefig(plot_name, bbox_inches='tight')
if show_plots:
plt.show()
else:
plt.close()
# ----------------------------------------------------------------------------------------
def voronoi_plot(box, polytopes, ax=None, color_by_sides=True, cmap=None):
"""Helper function to draw 2D Voronoi diagram.
Args:
box (:class:`freud.box.Box`):
Simulation box.
polytopes (:class:`numpy.ndarray`):
Array containing Voronoi polytope vertices.
ax (:class:`matplotlib.axes.Axes`): Axes object to plot.
If :code:`None`, make a new axes and figure object.
(Default value = :code:`None`).
color_by_sides (bool):
If :code:`True`, color cells by the number of sides.
If :code:`False`, random colors are used for each cell.
(Default value = :code:`True`).
cmap (str):
Colormap name to use (Default value = :code:`None`).
Returns:
:class:`matplotlib.axes.Axes`: Axes object with the diagram.
"""
from matplotlib import cm
from matplotlib.collections import PatchCollection
from matplotlib.patches import Polygon
from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable
from matplotlib.colorbar import Colorbar
if ax is None:
fig = Figure()
ax = fig.subplots()
# Draw Voronoi polytopes
patches = [Polygon(poly[:, :2]) for poly in polytopes]
patch_collection = PatchCollection(patches, edgecolors='black', alpha=0.4)
if color_by_sides:
colors = np.array([len(poly) for poly in polytopes])
num_colors = np.ptp(colors) + 1
else:
colors = np.random.RandomState().permutation(np.arange(len(patches)))
num_colors = np.unique(colors).size
# Ensure we have enough colors to uniquely identify the cells
if cmap is None:
if color_by_sides and num_colors <= 10:
cmap = 'tab10'
else:
if num_colors > 20:
warnings.warn('More than 20 unique colors were requested. '
'Consider providing a colormap to the cmap '
'argument.', UserWarning)
cmap = 'tab20'
cmap = cm.get_cmap(cmap, num_colors)
bounds = np.arange(np.min(colors), np.max(colors)+1)
patch_collection.set_array(np.array(colors)-0.5)
patch_collection.set_cmap(cmap)
patch_collection.set_clim(bounds[0]-0.5, bounds[-1]+0.5)
ax.add_collection(patch_collection)
# Draw box
corners = [[0, 0, 0], [0, 1, 0], [1, 1, 0], [1, 0, 0]]
# Need to copy the last point so that the box is closed.
corners.append(corners[0])
corners = box.make_absolute(corners)[:, :2]
ax.plot(corners[:, 0], corners[:, 1], color='k')
# Set title, limits, aspect
ax.set_title('Voronoi Diagram')
ax.set_xlim((np.min(corners[:, 0]), np.max(corners[:, 0])))
ax.set_ylim((np.min(corners[:, 1]), np.max(corners[:, 1])))
ax.set_aspect('equal', 'datalim')
# Add colorbar for number of sides
if color_by_sides:
ax_divider = make_axes_locatable(ax)
cax = ax_divider.append_axes("right", size="7%", pad="10%")
cb = Colorbar(cax, patch_collection)
cb.set_label("Number of sides")
cb.set_ticks(bounds)
return ax
def _plot_eff_array(array_dict, use_contour = True,
out_name = 'rejrej.pdf'):
eff_array = array_dict['eff']
eff_array = _maximize_efficiency(eff_array)
x_min, x_max = array_dict['x_range']
y_min, y_max = array_dict['y_range']
eff_array[np.nonzero(eff_array < 0.0)] = np.nan
fig = plt.figure()
gs = GridSpec(20,21)
ax = plt.subplot(gs[:,0:-1])
aspect = float(x_max - x_min) / (y_max - y_min)
im = ax.imshow(
eff_array,
origin = 'upper',
extent = (x_min,x_max, y_min, y_max),
aspect = aspect,
interpolation = 'nearest',
vmin = 0,
vmax = 1,
)
if use_contour:
im.set_cmap('Greys')
ct = ax.contour(
eff_array,
origin = 'upper',
extent = (x_min,x_max, y_min, y_max),
aspect = aspect,
linewidths = 2,
levels = np.arange(0.1,1.0,0.1),
)
im.get_cmap().set_bad(alpha=0)
ax.set_xticks([])
ax.set_yticks([])
ax.invert_yaxis()
cb_ax = plt.subplot(gs[:,-1])
plt.subplots_adjust(left = 0.25) # FIXME: use OO call here
# cb = plt.colorbar()
cb = Colorbar(ax = cb_ax, mappable = im)
cb.set_label('{} efficiency'.format(array_dict['signal']))
if use_contour: cb.add_lines(ct)
position = ax.get_position()
new_aspect = ax.get_aspect()
# ax.set_position(position)
ax_log = fig.add_subplot(111, frameon = False)
ax_log.set_xscale('log')
ax_log.set_yscale('log')
ax_log.axis((10**x_min, 10**x_max, 10**y_min, 10**y_max))
ax_log.set_aspect(aspect)
ax_log.set_xlabel('{} rejection'.format(array_dict['x_bg']))
ax_log.set_ylabel('{} rejection'.format(array_dict['y_bg']))
ax_log.grid(True)
ax_log.set_aspect(new_aspect)
ax_log.set_position(position)
plt.savefig(out_name, bbox_inches = 'tight')
plt.close()
class ColorbarWidget(QWidget):
colorbarChanged = Signal() # The parent should simply redraw their canvas
def __init__(self, parent=None):
super(ColorbarWidget, self).__init__(parent)
self.setWindowTitle("Colorbar")
self.setMaximumWidth(200)
self.dval = QDoubleValidator()
self.cmin = QLineEdit()
self.cmin_value = 0
self.cmin.setMaximumWidth(100)
self.cmin.editingFinished.connect(self.clim_changed)
self.cmin_layout = QHBoxLayout()
self.cmin_layout.addStretch()
self.cmin_layout.addWidget(self.cmin)
self.cmin_layout.addStretch()
self.cmax = QLineEdit()
self.cmax_value = 1
self.cmax.setMaximumWidth(100)
self.cmax.editingFinished.connect(self.clim_changed)
self.cmin.setValidator(self.dval)
self.cmax.setValidator(self.dval)
self.cmax_layout = QHBoxLayout()
self.cmax_layout.addStretch()
self.cmax_layout.addWidget(self.cmax)
self.cmax_layout.addStretch()
self.norm_layout = QHBoxLayout()
self.norm = QComboBox()
self.norm.addItems(NORM_OPTS)
self.norm.currentIndexChanged.connect(self.norm_changed)
self.powerscale = QLineEdit()
self.powerscale_value = 2
self.powerscale.setText("2")
self.powerscale.setValidator(QDoubleValidator(0.001,100,3))
self.powerscale.setMaximumWidth(50)
self.powerscale.editingFinished.connect(self.norm_changed)
self.powerscale.hide()
self.powerscale_label = QLabel("n=")
self.powerscale_label.hide()
self.norm_layout.addStretch()
self.norm_layout.addWidget(self.norm)
self.norm_layout.addStretch()
self.norm_layout.addWidget(self.powerscale_label)
self.norm_layout.addWidget(self.powerscale)
self.autoscale = QCheckBox("Autoscaling")
self.autoscale.setChecked(True)
self.autoscale.stateChanged.connect(self.update_clim)
self.canvas = FigureCanvas(Figure())
if parent:
# Set facecolor to match parent
self.canvas.figure.set_facecolor(parent.palette().window().color().getRgbF())
self.ax = self.canvas.figure.add_axes([0.4,0.05,0.2,0.9])
# layout
self.layout = QVBoxLayout(self)
self.layout.addLayout(self.cmax_layout)
self.layout.addWidget(self.canvas, stretch=1)
self.layout.addLayout(self.cmin_layout)
self.layout.addLayout(self.norm_layout)
self.layout.addWidget(self.autoscale)
def set_mappable(self, mappable):
"""
When a new plot is created this method should be called with the new mappable
"""
self.ax.clear()
self.colorbar = Colorbar(ax=self.ax, mappable=mappable)
self.cmin_value, self.cmax_value = self.colorbar.get_clim()
self.update_clim_text()
self.redraw()
def norm_changed(self):
"""
Called when a different normalization is selected
"""
idx = self.norm.currentIndex()
if NORM_OPTS[idx] == 'Power':
self.powerscale.show()
self.powerscale_label.show()
else:
self.powerscale.hide()
self.powerscale_label.hide()
self.colorbar.mappable.set_norm(self.get_norm())
self.colorbarChanged.emit()
def get_norm(self):
"""
This will create a matplotlib.colors.Normalize from selected idx, limits and powerscale
"""
idx = self.norm.currentIndex()
if self.autoscale.isChecked():
cmin = cmax = None
else:
cmin = self.cmin_value
cmax = self.cmax_value
if NORM_OPTS[idx] == 'Power':
if self.powerscale.hasAcceptableInput():
self.powerscale_value = float(self.powerscale.text())
return PowerNorm(gamma=self.powerscale_value, vmin=cmin, vmax=cmax)
elif NORM_OPTS[idx] == "SymmetricLog10":
return SymLogNorm(1e-8 if cmin is None else max(1e-8, abs(cmin)*1e-3),
vmin=cmin, vmax=cmax)
else:
return Normalize(vmin=cmin, vmax=cmax)
def clim_changed(self):
"""
Called when either the min or max is changed. Will unset the autoscale.
"""
self.autoscale.blockSignals(True)
self.autoscale.setChecked(False)
self.autoscale.blockSignals(False)
self.update_clim()
def update_clim(self):
"""
This will update the clim of the plot based on min, max, and autoscale
"""
if self.autoscale.isChecked():
data = self.colorbar.mappable.get_array()
try:
try:
self.cmin_value = data[~data.mask].min()
self.cmax_value = data[~data.mask].max()
except AttributeError:
self.cmin_value = np.nanmin(data)
self.cmax_value = np.nanmax(data)
except (ValueError, RuntimeWarning):
# all values mask
pass
self.update_clim_text()
else:
if self.cmin.hasAcceptableInput():
self.cmin_value = float(self.cmin.text())
if self.cmax.hasAcceptableInput():
self.cmax_value = float(self.cmax.text())
self.colorbar.set_clim(self.cmin_value, self.cmax_value)
self.redraw()
def update_clim_text(self):
"""
Update displayed limit values based on stored ones
"""
self.cmin.setText("{:.4}".format(self.cmin_value))
self.cmax.setText("{:.4}".format(self.cmax_value))
def redraw(self):
"""
Redraws the colobar and emits signal to cause the parent to redraw
"""
self.colorbar.update_ticks()
self.colorbar.draw_all()
self.canvas.draw_idle()
self.colorbarChanged.emit()
def plot_cartopy(lons,
lats,
size,
color,
labels=None,
projection='global',
resolution='110m',
continent_fill_color='0.8',
water_fill_color='1.0',
colormap=None,
colorbar=None,
marker="o",
title=None,
colorbar_ticklabel_format=None,
show=True,
proj_kwargs=None,
**kwargs): # @UnusedVariable
"""
Creates a Cartopy plot with a data point scatter plot.
:type lons: list/tuple of floats
:param lons: Longitudes of the data points.
:type lats: list/tuple of floats
:param lats: Latitudes of the data points.
:type size: float or list/tuple of floats
:param size: Size of the individual points in the scatter plot.
:type color: list/tuple of floats (or objects that can be
converted to floats, like e.g.
:class:`~obspy.core.utcdatetime.UTCDateTime`)
:param color: Color information of the individual data points to be
used in the specified color map (e.g. origin depths,
origin times).
:type labels: list/tuple of str
:param labels: Annotations for the individual data points.
:type projection: str, optional
:param projection: The map projection.
Currently supported are:
* ``"global"`` (Will plot the whole world using
:class:`~cartopy.crs.Mollweide`.)
* ``"ortho"`` (Will center around the mean lat/long using
:class:`~cartopy.crs.Orthographic`.)
* ``"local"`` (Will plot around local events using
:class:`~cartopy.crs.AlbersEqualArea`.)
* Any other Cartopy :class:`~cartopy.crs.Projection`. An instance
of this class will be created using the supplied ``proj_kwargs``.
Defaults to "global"
:type resolution: str, optional
:param resolution: Resolution of the boundary database to use. Will be
passed directly to the Cartopy module. Possible values are:
* ``"110m"``
* ``"50m"``
* ``"10m"``
Defaults to ``"110m"``. For compatibility, you may also specify any of
the Basemap resolutions defined in :func:`plot_basemap`.
:type continent_fill_color: Valid matplotlib color, optional
:param continent_fill_color: Color of the continents. Defaults to
``"0.9"`` which is a light gray.
:type water_fill_color: Valid matplotlib color, optional
:param water_fill_color: Color of all water bodies.
Defaults to ``"white"``.
:type colormap: str, any matplotlib colormap, optional
:param colormap: The colormap for color-coding the events as provided
in `color` kwarg.
The event with the smallest `color` property will have the
color of one end of the colormap and the event with the highest
`color` property the color of the other end with all other events
in between.
Defaults to None which will use the default matplotlib colormap.
:type colorbar: bool, optional
:param colorbar: When left `None`, a colorbar is plotted if more than one
object is plotted. Using `True`/`False` the colorbar can be forced
on/off.
:type title: str
:param title: Title above plot.
:type colorbar_ticklabel_format: str or function or
subclass of :class:`matplotlib.ticker.Formatter`
:param colorbar_ticklabel_format: Format string or Formatter used to format
colorbar tick labels.
:type show: bool
:param show: Whether to show the figure after plotting or not. Can be used
to do further customization of the plot before showing it.
:type proj_kwargs: dict
:param proj_kwargs: Keyword arguments to pass to the Cartopy
:class:`~cartopy.ccrs.Projection`. In this dictionary, you may specify
``central_longitude='auto'`` or ``central_latitude='auto'`` to have
this function calculate the latitude or longitude as it would for other
projections. Some arguments may be ignored if you choose one of the
built-in ``projection`` choices.
"""
import matplotlib.pyplot as plt
min_color = min(color)
max_color = max(color)
if isinstance(color[0], (datetime.datetime, UTCDateTime)):
datetimeplot = True
color = [date2num(getattr(t, 'datetime', t)) for t in color]
else:
datetimeplot = False
scal_map = ScalarMappable(norm=Normalize(min_color, max_color),
cmap=colormap)
scal_map.set_array(np.linspace(0, 1, 1))
fig = plt.figure()
# The colorbar should only be plotted if more then one event is
# present.
if colorbar is not None:
show_colorbar = colorbar
else:
if len(lons) > 1 and hasattr(color, "__len__") and \
not isinstance(color, (str, native_str)):
show_colorbar = True
else:
show_colorbar = False
if projection == "local":
ax_x0, ax_width = 0.10, 0.80
elif projection == "global":
ax_x0, ax_width = 0.01, 0.98
else:
ax_x0, ax_width = 0.05, 0.90
proj_kwargs = proj_kwargs or {}
if projection == 'global':
proj_kwargs['central_longitude'] = np.mean(lons)
proj = ccrs.Mollweide(**proj_kwargs)
elif projection == 'ortho':
proj_kwargs['central_latitude'] = np.mean(lats)
proj_kwargs['central_longitude'] = np.mean(lons)
proj = ccrs.Orthographic(**proj_kwargs)
elif projection == 'local':
if min(lons) < -150 and max(lons) > 150:
max_lons = max(np.array(lons) % 360)
min_lons = min(np.array(lons) % 360)
else:
max_lons = max(lons)
min_lons = min(lons)
lat_0 = max(lats) / 2. + min(lats) / 2.
lon_0 = max_lons / 2. + min_lons / 2.
if lon_0 > 180:
lon_0 -= 360
deg2m_lat = 2 * np.pi * 6371 * 1000 / 360
deg2m_lon = deg2m_lat * np.cos(lat_0 / 180 * np.pi)
if len(lats) > 1:
height = (max(lats) - min(lats)) * deg2m_lat
width = (max_lons - min_lons) * deg2m_lon
margin = 0.2 * (width + height)
height += margin
width += margin
else:
height = 2.0 * deg2m_lat
width = 5.0 * deg2m_lon
# Do intelligent aspect calculation for local projection
# adjust to figure dimensions
w, h = fig.get_size_inches()
aspect = w / h
if show_colorbar:
aspect *= 1.2
if width / height < aspect:
width = height * aspect
else:
height = width / aspect
proj_kwargs['central_latitude'] = lat_0
proj_kwargs['central_longitude'] = lon_0
proj = ccrs.AlbersEqualArea(**proj_kwargs)
# User-supplied projection.
elif isinstance(projection, type):
if 'central_longitude' in proj_kwargs:
if proj_kwargs['central_longitude'] == 'auto':
proj_kwargs['central_longitude'] = np.mean(lons)
if 'central_latitude' in proj_kwargs:
if proj_kwargs['central_latitude'] == 'auto':
proj_kwargs['central_latitude'] = np.mean(lats)
if 'pole_longitude' in proj_kwargs:
if proj_kwargs['pole_longitude'] == 'auto':
proj_kwargs['pole_longitude'] = np.mean(lons)
if 'pole_latitude' in proj_kwargs:
if proj_kwargs['pole_latitude'] == 'auto':
proj_kwargs['pole_latitude'] = np.mean(lats)
proj = projection(**proj_kwargs)
else:
msg = "Projection '%s' not supported." % projection
raise ValueError(msg)
if show_colorbar:
map_ax = fig.add_axes([ax_x0, 0.13, ax_width, 0.77], projection=proj)
cm_ax = fig.add_axes([ax_x0, 0.05, ax_width, 0.05])
plt.sca(map_ax)
else:
ax_y0, ax_height = 0.05, 0.85
if projection == "local":
ax_y0 += 0.05
ax_height -= 0.05
map_ax = fig.add_axes([ax_x0, ax_y0, ax_width, ax_height],
projection=proj)
if projection == 'local':
x0, y0 = proj.transform_point(lon_0, lat_0, proj.as_geodetic())
map_ax.set_xlim(x0 - width / 2, x0 + width / 2)
map_ax.set_ylim(y0 - height / 2, y0 + height / 2)
else:
map_ax.set_global()
# Pick features at specified resolution.
resolution = _CARTOPY_RESOLUTIONS[resolution]
try:
borders, land, ocean = _CARTOPY_FEATURES[resolution]
except KeyError:
borders = cfeature.NaturalEarthFeature(cfeature.BORDERS.category,
cfeature.BORDERS.name,
resolution,
edgecolor='none',
facecolor='none')
land = cfeature.NaturalEarthFeature(cfeature.LAND.category,
cfeature.LAND.name,
resolution,
edgecolor='face',
facecolor='none')
ocean = cfeature.NaturalEarthFeature(cfeature.OCEAN.category,
cfeature.OCEAN.name,
resolution,
edgecolor='face',
facecolor='none')
_CARTOPY_FEATURES[resolution] = (borders, land, ocean)
# Draw coast lines, country boundaries, fill continents.
map_ax.set_axis_bgcolor(water_fill_color)
map_ax.add_feature(ocean, facecolor=water_fill_color)
map_ax.add_feature(land, facecolor=continent_fill_color)
map_ax.add_feature(borders, edgecolor='0.75')
map_ax.coastlines(resolution=resolution, color='0.4')
# Draw grid lines - TODO: draw_labels=True doesn't work yet.
if projection == 'local':
map_ax.gridlines()
else:
# Draw lat/lon grid lines every 30 degrees.
map_ax.gridlines(xlocs=range(-180, 181, 30), ylocs=range(-90, 91, 30))
# Plot labels
if labels and len(lons) > 0:
with map_ax.hold_limits():
for name, xpt, ypt, _colorpt in zip(labels, lons, lats, color):
map_ax.text(xpt,
ypt,
name,
weight="heavy",
color="k",
zorder=100,
transform=ccrs.Geodetic(),
path_effects=[
PathEffects.withStroke(linewidth=3,
foreground="white")
])
scatter = map_ax.scatter(lons,
lats,
marker=marker,
s=size,
c=color,
zorder=10,
cmap=colormap,
transform=ccrs.Geodetic())
if title:
plt.suptitle(title)
# Only show the colorbar for more than one event.
if show_colorbar:
if colorbar_ticklabel_format is not None:
if isinstance(colorbar_ticklabel_format, (str, native_str)):
formatter = FormatStrFormatter(colorbar_ticklabel_format)
elif hasattr(colorbar_ticklabel_format, '__call__'):
formatter = FuncFormatter(colorbar_ticklabel_format)
elif isinstance(colorbar_ticklabel_format, Formatter):
formatter = colorbar_ticklabel_format
locator = MaxNLocator(5)
else:
if datetimeplot:
locator = AutoDateLocator()
formatter = AutoDateFormatter(locator)
# Compat with old matplotlib versions.
if hasattr(formatter, "scaled"):
formatter.scaled[1 / (24. * 60.)] = '%H:%M:%S'
else:
locator = None
formatter = None
cb = Colorbar(cm_ax,
scatter,
cmap=colormap,
orientation='horizontal',
ticks=locator,
format=formatter)
# Compat with old matplotlib versions.
if hasattr(cb, "update_ticks"):
cb.update_ticks()
if show:
plt.show()
return fig
plt.plot([startx, startx + 35000], [starty, starty],
'k',
linewidth=3)
plt.text(startx + 17500,
starty - 12000,
'35 km',
fontsize=fontsize,
ha='center',
va='center')
#deal with colorbars
if ((filenum == 1) & (i == 0)): # plot first color bar in row 1
colorax = plt.subplot(gs[1, rowscale])
colorbar1 = Colorbar(ax=colorax,
mappable=cs,
orientation='horizontal',
ticklocation='bottom',
ticks=[0.2, 0.5, 0.8])
colorbar1.ax.tick_params(labelsize=fontsize)
clabel = '$\mathrm{sig}(\mathrm{a}\Delta \mathrm{CFS}-\mathrm{b})$'
colorbar1.set_label(clabel, size=fontsize)
pos = colorax.get_position() # get the original position
colorax.set_position(
[pos.x0, pos.y0 + 0.017, pos.width, pos.height])
if ((filenum == 1) & (i == 1)): # plot first color bar in row 3
colorax = plt.subplot(gs[i * 2 + 1, filenum * rowscale])
colorbar2 = Colorbar(ax=colorax,
mappable=cs,
orientation='horizontal',
ticklocation='bottom',
ticks=[0.2, 0.5, 0.8])
