def plot_probe(data,
ax=None,
show_cbar=True,
make_pretty=True,
fig_kwargs=dict(),
line_kwargs=dict()):
"""
Function to create matplotlib plot from ProbePlot object
:param data: ProbePlot object, either class or dict
:param ax: matplotlib axis to plot on, if None, will create figure
:param show_cbar: whether or not to display colour bar
:param make_pretty: get rid of spines on axis
:param fig_kwargs: dict of matplotlib keywords associcated with plt.subplots e.g can be
fig size, tight layout etc.
:param line_kwargs: dict of matplotlib keywords associated with ax.hlines/ax.vlines
:return: matplotlib axis and figure handles
"""
if not isinstance(data, dict):
data = data.convert2dict()
if not ax:
fig, ax = plt.subplots(figsize=(2, 8), **fig_kwargs)
else:
fig = plt.gcf()
for (x, y, dat) in zip(data['data']['x'], data['data']['y'],
data['data']['c']):
im = NonUniformImage(ax, interpolation='nearest', cmap=data['cmap'])
im.set_clim(data['clim'][0], data['clim'][1])
im.set_data(x, y, dat.T)
ax.images.append(im)
ax.set_xlim(data['xlim'][0], data['xlim'][1])
ax.set_ylim(data['ylim'][0], data['ylim'][1])
ax.set_xlabel(data['labels']['xlabel'])
ax.set_ylabel(data['labels']['ylabel'])
ax.set_title(data['labels']['title'])
if make_pretty:
ax.get_xaxis().set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
if show_cbar:
cbar = fig.colorbar(im, orientation="horizontal", pad=0.02, ax=ax)
cbar.set_label(data['labels']['clabel'])
ax = add_lines(ax, data, **line_kwargs)
plt.show()
return ax, fig
def execute(self):
pylab.ioff()
self.figure = pylab.figure()
self.figure.canvas.mpl_connect('motion_notify_event', self.dataPrinter)
x = self.fieldContainer.dimensions[-1].data
y = self.fieldContainer.dimensions[-2].data
xmin=scipy.amin(x)
xmax=scipy.amax(x)
ymin=scipy.amin(y)
ymax=scipy.amax(y)
#Support for images with non uniform axes adapted
#from python-matplotlib-doc/examples/pcolor_nonuniform.py
ax = self.figure.add_subplot(111)
vmin = self.fieldContainer.attributes.get('vmin', None)
vmax = self.fieldContainer.attributes.get('vmax', None)
if vmin is not None:
vmin /= self.fieldContainer.unit
if vmax is not None:
vmax /= self.fieldContainer.unit
if MPL_LT_0_98_1 or self.fieldContainer.isLinearlyDiscretised():
pylab.imshow(self.fieldContainer.maskedData,
aspect='auto',
interpolation='nearest',
vmin=vmin,
vmax=vmax,
origin='lower',
extent=(xmin, xmax, ymin, ymax))
pylab.colorbar(format=F(self.fieldContainer), ax=ax)
else:
im = NonUniformImage(ax, extent=(xmin,xmax,ymin,ymax))
if vmin is not None or vmax is not None:
im.set_clim(vmin, vmax)
im.set_data(x, y, self.fieldContainer.maskedData)
else:
im.set_data(x, y, self.fieldContainer.maskedData)
im.autoscale_None()
ax.images.append(im)
ax.set_xlim(xmin,xmax)
ax.set_ylim(ymin,ymax)
pylab.colorbar(im,format=F(self.fieldContainer), ax=ax)
pylab.xlabel(self.fieldContainer.dimensions[-1].shortlabel)
pylab.ylabel(self.fieldContainer.dimensions[-2].shortlabel)
pylab.title(self.fieldContainer.label)
#ax=pylab.gca()
if self.show:
pylab.ion()
pylab.show()
def plot_time_frequency(spectrum, interpolation='bilinear',
background_color=None, clim=None, dbscale=True, **kwargs):
"""
Time-frequency plot. Modeled after image_nonuniform.py example
spectrum is a dataframe with frequencies in columns and time in rows
"""
if spectrum is None:
return None
times = spectrum.index
freqs = spectrum.columns
if dbscale:
z = 10 * np.log10(spectrum.T)
else:
z = spectrum.T
ax = plt.figure().add_subplot(111)
extent = (times[0], times[-1], freqs[0], freqs[-1])
im = NonUniformImage(ax, interpolation=interpolation, extent=extent)
if background_color:
im.get_cmap().set_bad(kwargs['background_color'])
else:
z[np.isnan(z)] = 0.0 # replace missing values with 0 color
if clim:
im.set_clim(clim)
if 'cmap' in kwargs:
im.set_cmap(kwargs['cmap'])
im.set_data(times, freqs, z)
ax.set_xlim(extent[0], extent[1])
ax.set_ylim(extent[2], extent[3])
ax.images.append(im)
if 'colorbar_label' in kwargs:
plt.colorbar(im, label=kwargs['colorbar_label'])
else:
plt.colorbar(im, label='Power (dB/Hz)')
plt.xlabel('Time (s)')
plt.ylabel('Frequency (Hz)')
return plt.gcf()
scatf5 = 5.0*scatf1
# print max scatter values and their times
print 'max scatter f1 = ' + str(max(scatf1)) + ' Hz'
tofmax = times[argmax(scatf2)]
tofmaxgps = tofmax + start_time
print 'time of max f2 = ' + str(tofmax) + ' s, GPS=' + str(tofmaxgps)
fig = plt.figure(figsize=(12,12))
ax1 = fig.add_subplot(211)
# Plot Spectrogram
if plotspec==1:
im1 = NonUniformImage(ax1, interpolation='bilinear',extent=(min(t),max(t),10,55),cmap='jet')
im1.set_data(t,freq,20.0*log10(Pxx))
if witness_base=="GDS-CALIB_STRAIN":
print "setting color limits for STRAIN"
im1.set_clim(-1000,-800)
elif witness_base=="ASC-AS_B_RF45_Q_YAW_OUT_DQ" or witness_base=="ASC-AS_B_RF36_Q_PIT_OUT_DQ" or witness_base=="ASC-AS_A_RF45_Q_PIT_OUT_DQ" or witness_base=="LSC-MICH_IN1_DQ":
im1.set_clim(-200,20)
elif witness_base == "OMC-LSC_SERVO_OUT_DQ":
im1.set_clim(-240,-85)
ax1.images.append(im1)
#cbar1 = fig.colorbar(im1)
#cbar1.set_clim(-120,-40)
# plot fringe prediction timeseries
#ax1.plot(times,scatf5, c='blue', linewidth='0.2', label='f5')
ax1.plot(times,scatf4, c='purple', linewidth='0.4', label='f4')
ax1.plot(times,scatf3, c='green', linewidth='0.4', label='f3')
ax1.plot(times,scatf2, c='blue', linewidth='0.4', label='f2')
ax1.plot(times,scatf1, c='black', linewidth='0.4', label='f1')
#if plotspec < 1 and dur <= 3600:
#pl.legend(bbox_to_anchor=(0., -0.3, 0.75, .102), loc=2, ncol=2, mode="expand", borderaxespad=0.,fontsize=10)
if DISPLAY_2D==1:
dar=(alfa2[-1]-alfa2[0])/(Dd2[-1]-Dd2[0]) *1 #7E-4
ax = plt.subplot(223)
#fig1.subplots_adjust(bottom=0.07, hspace=0.3)
pl.title('Trigger rate - Conservative case')
pl.ylabel('Distance [km]')
pl.xlabel('Slope [deg]')
im = NonUniformImage(ax,interpolation='nearest', extent=(Dd2[0],Dd2[-1],alfa2[0],alfa2[-1]),cmap='jet')
im.set_data(alfa,Dd,Nconfig_ew_cons)
ax.images.append(im)
ax.set_ylim(Dd2[0],Dd2[-1])
ax.set_xlim(alfa2[0],alfa2[-1])
im.set_clim(0,np.max(Nconfig_ew_aggr))
pl.colorbar(im)
#pl.colorbar(im,orientation="horizontal")
#pl.gca().set_aspect(dar,adjustable='box')
ax = plt.subplot(224)
#fig1.subplots_adjust(bottom=0.07, hspace=0.3)
pl.title('Trigger rate - Aggressive case')
pl.ylabel('Distance [km]')
pl.xlabel('Slope [deg]')
im = NonUniformImage(ax,interpolation='nearest', extent=(Dd2[0],Dd2[-1],alfa2[0],alfa2[-1]),cmap='jet')
im.set_data(alfa,Dd,Nconfig_ew_aggr)
ax.images.append(im)
ax.set_ylim(Dd2[0],Dd2[-1])
ax.set_xlim(alfa2[0],alfa2[-1])
if output_var == "beta":
mag_press = (bx * bx + by * by) / (8.0 * np.pi)
for i in range(len(var)):
var[i] = var[i] / (mag_press**2)
var[i] = mag_press * var[i]
fig, ax = plt.subplots()
frame = 0
x = X[:, 0]
y = Y[0, :]
if output_var == "rad" or output_var == "beta":
im = NonUniformImage(ax, animated=True, origin='lower', extent=(x_min,x_max,y_min,y_max),\
interpolation='nearest', norm=matplotlib.colors.SymLogNorm(linthresh=1e-5, base=10))
im.set_data(x, y, np.transpose(var[frame]))
im.set_clim(vmin=1e-4)
ax.add_image(im)
ax.set(xlim=(x_min, x_max),
ylim=(y_min, y_max),
xlabel="x (cm)",
ylabel="y (cm)",
title=output_var + ", t=" + str(t[frame]))
var_colorbar = fig.colorbar(im)
var_colorbar.set_label(fullnames[output_var] + " (" +
fullunits[output_var] + ")")
elif output_var == "dt" or output_var == "dt_thermal" or output_var == "dt_rad":
im = NonUniformImage(ax, animated=True, origin='lower', extent=(x_min,x_max,y_min,y_max),\
interpolation='nearest', norm=matplotlib.colors.SymLogNorm(linthresh=1e-10, base=10))
im.set_data(x, y, np.transpose(var[frame]))
if (np.isnan(np.nanmax(var))): im.set_clim(vmin=1e-4, vmax=1.0)
else: im.set_clim(vmin=1e-4, vmax=np.nanmax(var))
def plot_3D(
Xdata,
Ydata,
Zdata,
colormap="RdBu_r",
color_list=None,
x_min=None,
x_max=None,
y_min=None,
y_max=None,
z_min=None,
z_max=None,
title="",
xlabel="",
ylabel="",
zlabel="",
xticks=None,
yticks=None,
fig=None,
ax=None,
is_logscale_x=False,
is_logscale_y=False,
is_logscale_z=False,
is_disp_title=True,
type_plot="stem",
is_contour=False,
save_path=None,
is_show_fig=None,
is_switch_axes=False,
win_title=None,
font_name="arial",
font_size_title=12,
font_size_label=10,
font_size_legend=8,
):
"""Plots a 3D graph ("stem", "surf" or "pcolor")
Parameters
----------
Xdata : ndarray
array of x-axis values
Ydata : ndarray
array of y-axis values
Zdata : ndarray
array of z-axis values
colormap : colormap object
colormap prescribed by user
x_min : float
minimum value for the x-axis (no automated scaling in 3D)
x_max : float
maximum value for the x-axis (no automated scaling in 3D)
y_min : float
minimum value for the y-axis (no automated scaling in 3D)
y_max : float
maximum value for the y-axis (no automated scaling in 3D)
z_min : float
minimum value for the z-axis (no automated scaling in 3D)
z_max : float
maximum value for the z-axis (no automated scaling in 3D)
title : str
title of the graph
xlabel : str
label for the x-axis
ylabel : str
label for the y-axis
zlabel : str
label for the z-axis
xticks : list
list of ticks to use for the x-axis
fig : Matplotlib.figure.Figure
existing figure to use if None create a new one
ax : Matplotlib.axes.Axes object
ax on which to plot the data
is_logscale_x : bool
boolean indicating if the x-axis must be set in logarithmic scale
is_logscale_y : bool
boolean indicating if the y-axis must be set in logarithmic scale
is_logscale_z : bool
boolean indicating if the z-axis must be set in logarithmic scale
is_disp_title : bool
boolean indicating if the title must be displayed
type_plot : str
type of 3D graph : "stem", "surf", "pcolor" or "scatter"
is_contour : bool
True to show contour line if type_plot = "pcolor"
save_path : str
full path including folder, name and extension of the file to save if save_path is not None
is_show_fig : bool
True to show figure after plot
is_switch_axes : bool
to switch x and y axes
"""
# Set if figure must be shown if is_show_fig is None
if is_show_fig is None:
is_show_fig = True if fig is None else False
# Set if figure is 3D
if type_plot not in ["pcolor", "pcolormesh", "scatter"]:
is_3d = True
else:
is_3d = False
# Set figure if needed
if fig is None and ax is None:
(fig, ax, _, _) = init_fig(fig=None, shape="rectangle", is_3d=is_3d)
if color_list is None:
color_list = COLORS
# Calculate z limits
if z_min is None:
z_min = np_min(Zdata)
if z_max is None:
z_max = np_max(Zdata)
# Check logscale on z axis
if is_logscale_z:
Zdata = 10 * log10(np_abs(Zdata))
clb_format = "%0.0f"
else:
clb_format = "%.4g"
# Switch axes
if is_switch_axes:
Xdata, Ydata = Ydata, Xdata
if len(Xdata.shape) > 1:
Xdata = Xdata.T
if len(Ydata.shape) > 1:
Ydata = Ydata.T
if len(Zdata.shape) > 1:
Zdata = Zdata.T
x_min, y_min = y_min, x_min
x_max, y_max = y_max, x_max
xlabel, ylabel = ylabel, xlabel
xticks, yticks = yticks, xticks
is_logscale_x, is_logscale_y = is_logscale_y, is_logscale_x
# Plot
if type_plot == "stem":
cmap = matplotlib.cm.get_cmap(colormap)
for xi, yi, zi in zip(Xdata, Ydata, Zdata):
line = art3d.Line3D(*zip((xi, yi, 0), (xi, yi, zi)),
linewidth=2.0,
marker="o",
markersize=3.0,
markevery=(1, 1),
color=cmap(0))
ax.add_line(line)
ax.set_xlim3d(x_max, x_min)
ax.set_ylim3d(y_min, y_max)
ax.set_zlim3d(z_min, z_max)
# set correct angle
ax.view_init(elev=20.0, azim=45)
ax.zaxis.set_rotate_label(False)
ax.set_zlabel(zlabel, rotation=0)
ax.xaxis.labelpad = 5
ax.yaxis.labelpad = 5
ax.zaxis.labelpad = 5
if xticks is not None:
ax.xaxis.set_ticks(xticks)
if yticks is not None:
ax.yaxis.set_ticks(yticks)
# white background
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor("w")
ax.yaxis.pane.set_edgecolor("w")
ax.zaxis.pane.set_edgecolor("w")
if is_logscale_z:
ax.zscale("log")
elif type_plot == "surf":
ax.plot_surface(Xdata, Ydata, Zdata, cmap=colormap)
ax.set_xlim3d(x_max, x_min)
ax.set_ylim3d(y_min, y_max)
ax.set_zlim3d(z_min, z_max)
ax.zaxis.set_rotate_label(False)
ax.set_zlabel(zlabel, rotation=0)
ax.xaxis.labelpad = 5
ax.yaxis.labelpad = 5
ax.zaxis.labelpad = 5
if xticks is not None:
ax.xaxis.set_ticks(xticks)
if yticks is not None:
ax.yaxis.set_ticks(yticks)
# white background
ax.xaxis.pane.fill = False
ax.yaxis.pane.fill = False
ax.zaxis.pane.fill = False
ax.xaxis.pane.set_edgecolor("w")
ax.yaxis.pane.set_edgecolor("w")
ax.zaxis.pane.set_edgecolor("w")
if is_logscale_z:
ax.zscale("log")
elif type_plot == "pcolor":
Zdata[Zdata < z_min] = z_min
Zdata[Zdata > z_max] = z_max
# Handle descending order axes (e.g. spectrogram of run-down in freq/rpm map)
if Ydata[-1] < Ydata[0]:
Ydata = Ydata[::-1]
Zdata = Zdata[:, ::-1]
if Xdata[-1] < Xdata[0]:
Xdata = Xdata[::-1]
Zdata = Zdata[::-1, :]
im = NonUniformImage(
ax,
interpolation="bilinear",
extent=(x_min, x_max, y_max, y_min),
cmap=colormap,
picker=10,
)
im.set_data(Xdata, Ydata, Zdata.T)
im.set_clim(z_min, z_max)
ax.images.append(im)
if is_contour:
ax.contour(Xdata, Ydata, Zdata.T, colors="black", linewidths=0.8)
clb = fig.colorbar(im, ax=ax, format=clb_format)
clb.ax.set_title(zlabel, fontsize=font_size_legend, fontname=font_name)
clb.ax.tick_params(labelsize=font_size_legend)
for l in clb.ax.yaxis.get_ticklabels():
l.set_family(font_name)
if xticks is not None:
ax.xaxis.set_ticks(xticks)
if yticks is not None:
ax.yaxis.set_ticks(yticks)
ax.set_xlim([x_min, x_max])
ax.set_ylim([y_min, y_max])
elif type_plot == "pcolormesh":
c = ax.pcolormesh(Xdata,
Ydata,
Zdata,
cmap=colormap,
shading="gouraud",
antialiased=True)
clb = fig.colorbar(c, ax=ax)
clb.ax.set_title(zlabel, fontsize=font_size_legend, fontname=font_name)
clb.ax.tick_params(labelsize=font_size_legend)
for l in clb.ax.yaxis.get_ticklabels():
l.set_family(font_name)
if xticks is not None:
ax.xaxis.set_ticks(xticks)
if yticks is not None:
ax.yaxis.set_ticks(yticks)
ax.set_xlim([x_min, x_max])
ax.set_ylim([y_min, y_max])
elif type_plot == "scatter":
c = ax.scatter(
Xdata,
Ydata,
# s=10,
c=Zdata,
marker=".",
cmap=colormap,
vmin=z_min,
vmax=z_max,
picker=True,
pickradius=5,
)
clb = fig.colorbar(c, ax=ax)
clb.ax.set_title(zlabel, fontsize=font_size_legend, fontname=font_name)
clb.ax.tick_params(labelsize=font_size_legend)
for l in clb.ax.yaxis.get_ticklabels():
l.set_family(font_name)
if xticks is not None:
ax.xaxis.set_ticks(xticks)
if yticks is not None:
ax.yaxis.set_ticks(yticks)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
if is_logscale_x:
ax.xscale("log")
if is_logscale_y:
ax.yscale("log")
if is_disp_title:
ax.set_title(title)
if is_3d:
for item in ([ax.xaxis.label, ax.yaxis.label, ax.zaxis.label] +
ax.get_xticklabels() + ax.get_yticklabels() +
ax.get_zticklabels()):
item.set_fontsize(font_size_label)
else:
for item in ([ax.xaxis.label, ax.yaxis.label] + ax.get_xticklabels() +
ax.get_yticklabels()):
item.set_fontsize(font_size_label)
item.set_fontname(font_name)
ax.title.set_fontsize(font_size_title)
ax.title.set_fontname(font_name)
if save_path is not None:
save_path = save_path.replace("\\", "/")
fig.savefig(save_path)
plt.close()
if is_show_fig:
fig.show()
if win_title:
manager = plt.get_current_fig_manager()
if manager is not None:
manager.set_window_title(win_title)
def __Plot2D(self, xa, ya, param, con, params, label, kind, fnc_x, fnc_y,
fnc_z, axis_label, fnc_filt, appto, axs, **kwargs):
import pylab
from matplotlib.image import NonUniformImage
from numpy import linspace
from scipy.interpolate import splrep, splev
from mpl_toolkits.mplot3d import Axes3D
if len(params) > 0:
cons = self.lookup.getConditions(con, _asarray(params), fnc_filt,
**kwargs)
else:
cons = _asarray(con)
for i, con in enumerate(cons):
vals = self.lookup.getWhere(con)
if vals <> []:
if self.objects[vals[0]].data.has_key(xa) and \
self.objects[vals[0]].data.has_key(ya):
if not appto:
f = pylab.figure()
if kind in ['imshow', 'contour', 'contourf']:
axs.append(f.add_subplot(111))
else:
axs.append(f.gca(projection='3d'))
else:
if type(appto) in [list, tuple]:
axs = appto
else:
axs.append(appto)
ax_num = i % len(axs)
if self.objects[vals[0]].data.has_key(param):
ma = fnc_z(self.objects[vals[0]].getData(param))
x_axis = fnc_x(self.objects[vals[0]].getData(xa))
y_axis = fnc_y(self.objects[vals[0]].getData(ya))
else:
def generateMatrix(dO, xa, ya, param, kind, ma, xs,
ys):
# generates a matrix for the Image or contoure plot
if dO.data.has_key(xa) and dO.data.has_key(ya) and \
self.header.has_key(param):
ma.append(fnc_z(dO.getData(ya)))
xs.append(fnc_x(dO.getData(xa)))
ys.append(fnc_y(dO.getHeader(param)))
ma = []
xs = []
ys = []
self.map(generateMatrix,
con,
xa=xa,
ya=ya,
param=param,
kind=kind,
ma=ma,
xs=xs,
ys=ys)
x_min, x_max = max(LP_func.transpose(xs)[0]), min(
LP_func.transpose(xs)[-1])
x_axis = linspace(x_min, x_max, 400)
for i in xrange(len(xs)):
ma[i] = splev(x_axis, splrep(xs[i], ma[i], k=3))
xs[i] = x_axis
y_axis = ys
if kind == 'imshow':
im = NonUniformImage(axs[ax_num],
interpolation='bilinear')
im.set_cmap(kwargs.get('cmap', None))
im.set_data(x_axis, y_axis, ma)
if kwargs.has_key('vmin'):
im.set_clim(vmin=kwargs['vmin'])
if kwargs.has_key('vmax'):
im.set_clim(vmax=kwargs['vmax'])
axs[ax_num].images.append(im)
#~ xlabel( r'Wavelength [nm]' )
#~ ylabel( r'Delay [ps]' )
pylab.show()
if kwargs.has_key('bar'):
bar = kwargs['bar']
kwargs.pop('bar')
else:
bar = True
if bar:
axs[ax_num].get_figure().colorbar(im)
axs[ax_num].set_xlim(x_axis[0], x_axis[-1])
axs[ax_num].set_ylim(y_axis[0], y_axis[-1])
pylab.draw()
elif kind == 'contour':
N = kwargs.get('N', 8)
X, Y = pylab.meshgrid(x_axis, y_axis)
CS = axs[ax_num].contour(X, Y, ma, N, **kwargs)
if kwargs.has_key('labels'):
labels = kwargs['labels']
kwargs.pop('labels')
fmt = {}
for l, s in zip(CS.levels, labels):
fmt[l] = s
elif kwargs.has_key('fmt'):
fmt = kwargs('fmt')
else:
fmt = '%1.2f'
if kwargs.has_key('fontsize'):
fontsize = kwargs['fontsize']
else:
fontsize = 12
axs[ax_num].clabel(CS,
CS.levels,
inline=1,
fmt=fmt,
fontsize=fontsize)
pylab.show()
axs[ax_num].set_xlim(x_axis[0], x_axis[-1])
axs[ax_num].set_ylim(y_axis[0], y_axis[-1])
pylab.draw()
elif kind == 'contourf':
N = kwargs.get('N', 8)
X, Y = pylab.meshgrid(x_axis, y_axis)
CS = axs[ax_num].contourf(X, Y, ma, N, **kwargs)
axs[ax_num].get_figure().colorbar(CS)
pylab.show()
axs[ax_num].set_xlim(x_axis[0], x_axis[-1])
axs[ax_num].set_ylim(y_axis[0], y_axis[-1])
pylab.draw()
elif kind == 'surf':
X, Y = pylab.meshgrid(x_axis, y_axis)
CS = axs[ax_num].plot_surface(X, Y, pylab.array(ma),
**kwargs)
#axs[ax_num].get_figure().colorbar(CS, shrink=0.5, aspect=5)
pylab.show()
#axs[ax_num].set_xlim(x_axis[0],x_axis[-1])
#axs[ax_num].set_ylim(y_axis[0],y_axis[-1])
pylab.draw()
elif kind == 'contour3d':
N = kwargs.get('N', 8)
X, Y = pylab.meshgrid(x_axis, y_axis)
CS = axs[ax_num].contourf(X, Y, ma, N, **kwargs)
if kwargs.has_key('labels'):
labels = kwargs['labels']
kwargs.pop('labels')
fmt = {}
for l, s in zip(CS.levels, labels):
fmt[l] = s
elif kwargs.has_key('fmt'):
fmt = kwargs('fmt')
else:
fmt = '%1.2f'
if kwargs.has_key('fontsize'):
fontsize = kwargs['fontsize']
else:
fontsize = 12
axs[ax_num].clabel(CS,
CS.levels,
inline=1,
fmt=fmt,
fontsize=fontsize)
pylab.show()
axs[ax_num].set_xlim(x_axis[0], x_axis[-1])
axs[ax_num].set_ylim(y_axis[0], y_axis[-1])
pylab.draw()
lab = self.lookup.keys_to_string(con)
axs[ax_num].set_title(lab)
pylab.show()
pylab.draw()
def analyzeArea(rasterTransfo, resAnalysis, pLim, newRasters, cfgPath,
cfgFlags):
"""
Compare results to reference.
Compute True positive, False negative... areas.
"""
fname = cfgPath['pressurefileList']
dataPressure = newRasters['newRasterPressure']
scoord = rasterTransfo['s']
lcoord = rasterTransfo['l']
cellarea = rasterTransfo['rasterArea']
indRunoutPoint = rasterTransfo['indRunoutPoint']
# initialize Arrays
nTopo = len(fname)
TP = np.empty((nTopo))
FN = np.empty((nTopo))
FP = np.empty((nTopo))
TN = np.empty((nTopo))
# take first simulation as reference
newMask = copy.deepcopy(dataPressure[0])
# prepare mask for area resAnalysis
newMask[0:indRunoutPoint] = 0
newMask[np.where(np.nan_to_num(newMask) < pLim)] = 0
newMask[np.where(np.nan_to_num(newMask) >= pLim)] = 1
# comparison rasterdata with mask
log.info('{: <15} {: <15} {: <15} {: <15} {: <15}'.format(
'Sim number ', 'TP ', 'FN ', 'FP ', 'TN'))
# rasterinfo
nStart, m_start = np.nonzero(np.nan_to_num(newMask))
nStart = min(nStart)
nTot = len(scoord)
for i in range(nTopo):
rasterdata = dataPressure[i]
"""
area
# true positive: reality(mask)=1, model(rasterdata)=1
# false negative: reality(mask)=1, model(rasterdata)=0
# false positive: reality(mask)=0, model(rasterdata)=1
# true negative: reality(mask)=0, model(rasterdata)=0
"""
# for each pressure-file pLim is introduced (1/3/.. kPa), where the avalanche has stopped
newRasterData = copy.deepcopy(rasterdata)
newRasterData[0:indRunoutPoint] = 0
newRasterData[np.where(np.nan_to_num(newRasterData) < pLim)] = 0
newRasterData[np.where(np.nan_to_num(newRasterData) >= pLim)] = 1
if cfgFlags.getboolean('savePlot') and i > 0:
# read paths
pathResult = cfgPath['pathResult']
projectName = cfgPath['dirName']
outname = ''.join([
pathResult, os.path.sep, 'pics', os.path.sep, projectName, '_',
str(i), '_compToRef', '.pdf'
])
if not os.path.exists(os.path.dirname(outname)):
os.makedirs(os.path.dirname(outname))
fig = plt.figure(figsize=(figW * 2, figH), dpi=figReso)
y_lim = scoord[indRunoutPoint + 20] + resAnalysis['runout'][0, 0]
# for figure: referenz-simulation bei pLim=1
ax1 = plt.subplot(121)
ax1.title.set_text('Reference Peak Presseure in the RunOut area')
cmap = cmapPres
cmap.set_under(color='w')
im = NonUniformImage(ax1,
extent=[
lcoord.min(),
lcoord.max(),
scoord.min(),
scoord.max()
],
cmap=cmap)
im.set_clim(vmin=pLim,
vmax=np.max((dataPressure[0])[nStart:nTot + 1]))
im.set_data(lcoord, scoord, dataPressure[0])
ref0 = ax1.images.append(im)
cbar = ax1.figure.colorbar(im,
extend='both',
ax=ax1,
use_gridspec=True)
cbar.ax.set_ylabel('peak pressure [kPa]')
ax1.set_xlim([lcoord.min(), lcoord.max()])
ax1.set_ylim([scoord[indRunoutPoint - 20], y_lim])
ax1.set_xlabel(r'$l\;[m]$')
ax1.set_ylabel(r'$s\;[m]$')
ax2 = plt.subplot(122)
ax2.title.set_text(
'Difference between current and reference in the RunOut area\n Blue = FN, Red = FP'
)
colorsList = [[0, 0, 1], [1, 1, 1], [1, 0, 0]]
cmap = matplotlib.colors.ListedColormap(colorsList)
cmap.set_under(color='b')
cmap.set_over(color='r')
cmap.set_bad(color='k')
im = NonUniformImage(ax2,
extent=[
lcoord.min(),
lcoord.max(),
scoord.min(),
scoord.max()
],
cmap=cmap)
im.set_clim(vmin=-0.000000001, vmax=0.000000001)
im.set_data(lcoord, scoord, newRasterData - newMask)
ref0 = ax2.images.append(im)
# cbar = ax2.figure.colorbar(im, ax=ax2, extend='both', use_gridspec=True)
# cbar.ax.set_ylabel('peak pressure [kPa]')
ax2.set_xlim([lcoord.min(), lcoord.max()])
ax2.set_ylim([scoord[indRunoutPoint - 20], y_lim])
ax2.set_xlabel(r'$l\;[m]$')
ax2.set_ylabel(r'$s\;[m]$')
plt.subplots_adjust(wspace=0.3)
# fig.tight_layout()
# plt.show()
fig.savefig(outname, transparent=True)
plt.close(fig)
tpInd = np.where((newMask[nStart:nTot + 1] == True)
& (newRasterData[nStart:nTot + 1] == True))
fpInd = np.where((newMask[nStart:nTot + 1] == False)
& (newRasterData[nStart:nTot + 1] == True))
fnInd = np.where((newMask[nStart:nTot + 1] == True)
& (newRasterData[nStart:nTot + 1] == False))
tnInd = np.where((newMask[nStart:nTot + 1] == False)
& (newRasterData[nStart:nTot + 1] == False))
# Teilrasterpunkte
tpCount = len(tpInd[0])
fpCount = len(fpInd[0])
fnCount = len(fnInd[0])
tnCount = len(tnInd[0])
# subareas
tp = sum(cellarea[tpInd[0] + nStart, tpInd[1]])
fp = sum(cellarea[fpInd[0] + nStart, fpInd[1]])
fn = sum(cellarea[fnInd[0] + nStart, fnInd[1]])
tn = sum(cellarea[tnInd[0] + nStart, tnInd[1]])
# take reference (first simulation) as normalizing area
areaSum = tp + fn
TP[i] = tp
FN[i] = fn
FP[i] = fp
TN[i] = tn
log.info('{: <15} {:<15.4f} {:<15.4f} {:<15.4f} {:<15.4f}'.format(
*[i + 1, tp / areaSum, fn / areaSum, fp / areaSum, tn / areaSum]))
resAnalysis['TP'] = TP
resAnalysis['FN'] = FN
resAnalysis['FP'] = FP
resAnalysis['TN'] = TN
return resAnalysis
def plot2D(ma, xs, ys, kind='imshow', fnc_x=lambda x:x, fnc_y=lambda y:y, fnc_z=lambda z:z , axis_label = None, appto = None, **kwargs):
import pylab
from matplotlib.image import NonUniformImage
from numpy import linspace
from scipy.interpolate import splrep, splev
from mpl_toolkits.mplot3d import Axes3D
if appto is None or kind not in ['imshow', 'contour', 'contourf']:
f=pylab.figure()
if kind in ['imshow', 'contour', 'contourf']:
ax=f.add_subplot(111)
else:
ax = f.gca(projection='3d')
else:
ax = appto
CS=None
try:
pylab.array(xs)
x_min = max(transpose(xs)[0]); x_max = min(transpose(xs)[-1])
x_axis = linspace(x_min, x_max,400)
for i in xrange(len(xs)):
ma[i] = splev(x_axis, splrep(xs[i], ma[i], k=3))
xs[i] = x_axis
except:
x_axis = fnc_x(xs)
y_axis = fnc_y(ys)
if kind == 'imshow':
im = NonUniformImage(ax, interpolation='bilinear' )
im.set_cmap(kwargs.get('cmap',None))
im.set_data( x_axis, y_axis, fnc_z(ma) )
if kwargs.has_key('vmin'):
im.set_clim(vmin=kwargs['vmin'])
if kwargs.has_key('vmax'):
im.set_clim(vmax=kwargs['vmax'])
ax.images.append( im )
#~ xlabel( r'Wavelength [nm]' )
#~ ylabel( r'Delay [ps]' )
pylab.show()
if kwargs.has_key('bar'):
bar = kwargs['bar']
kwargs.pop('bar')
else:
bar = True
if bar:
ax.get_figure().colorbar(im)
ax.set_xlim(x_axis[0],x_axis[-1])
ax.set_ylim(y_axis[0],y_axis[-1])
pylab.draw()
elif kind == 'contour':
N=kwargs.get('N', 8)
X, Y = pylab.meshgrid(x_axis, y_axis)
CS=ax.contour(X, Y, fnc_z(ma), N, **kwargs)
if kwargs.has_key('labels'):
labels = kwargs['labels']
kwargs.pop('labels')
fmt = {}
for l, s in zip( CS.levels, labels ):
fmt[l] = s
elif kwargs.has_key('fmt'):
fmt = kwargs('fmt')
else:
fmt = '%1.2f'
if kwargs.has_key('fontsize'):
fontsize = kwargs['fontsize']
else:
fontsize = 12
ax.clabel(CS, CS.levels, inline=1, fmt = fmt, fontsize = fontsize)
pylab.show()
ax.set_xlim(x_axis[0],x_axis[-1])
ax.set_ylim(y_axis[0],y_axis[-1])
pylab.draw()
elif kind == 'contourf':
N=kwargs.get('N', 8)
X, Y = pylab.meshgrid(x_axis, y_axis)
CS=ax.contourf(X, Y, fnc_z(ma), N, **kwargs)
ax.get_figure().colorbar(CS)
pylab.show()
ax.set_xlim(x_axis[0],x_axis[-1])
ax.set_ylim(y_axis[0],y_axis[-1])
pylab.draw()
elif kind == 'surf':
X, Y = pylab.meshgrid(x_axis, y_axis)
CS=ax.plot_surface(X, Y, fnc_z(pylab.array(ma)), **kwargs)
#ax.get_figure().colorbar(CS, shrink=0.5, aspect=5)
pylab.show()
ax.set_xlim(x_axis[0],x_axis[-1])
ax.set_ylim(y_axis[0],y_axis[-1])
pylab.draw()
elif kind == 'contour3d':
N=kwargs.get('N', 8)
X, Y = pylab.meshgrid(x_axis, y_axis)
CS=ax.contourf(X, Y, fnc_z(ma), N, **kwargs)
if kwargs.has_key('labels'):
labels = kwargs['labels']
kwargs.pop('labels')
fmt = {}
for l, s in zip( CS.levels, labels ):
fmt[l] = s
elif kwargs.has_key('fmt'):
fmt = kwargs('fmt')
else:
fmt = '%1.2f'
if kwargs.has_key('fontsize'):
fontsize = kwargs['fontsize']
else:
fontsize = 12
ax.clabel(CS, CS.levels, inline=1, fmt = fmt, fontsize = fontsize)
pylab.show()
ax.set_xlim(x_axis[0],x_axis[-1])
ax.set_ylim(y_axis[0],y_axis[-1])
pylab.draw()
if axis_label is not None:
ax.set_xlabel(axis_label[0])
ax.set_ylabel(axis_labe[1])
pylab.show()
return ax, CS
def single_plot(data, x, y, axes=None, beta=None, cbar_label='',
cmap=plt.get_cmap('RdBu'), vmin=None, vmax=None,
phase_speeds=True, manual_locations=False, **kwargs):
"""
Plot a single frame Time-Distance Diagram on physical axes.
This function uses mpl NonUniformImage to plot a image using x and y arrays,
it will also optionally over plot in contours beta lines.
Parameters
----------
data: np.ndarray
The 2D image to plot
x: np.ndarray
The x coordinates
y: np.ndarray
The y coordinates
axes: matplotlib axes instance [*optional*]
The axes to plot the data on, if None, use plt.gca().
beta: np.ndarray [*optional*]
The array to contour over the top, default to none.
cbar_label: string [*optional*]
The title label for the colour bar, default to none.
cmap: A matplotlib colour map instance [*optional*]
The colourmap to use, default to 'RdBu'
vmin: float [*optional*]
The min scaling for the image, default to the image limits.
vmax: float [*optional*]
The max scaling for the image, default to the image limits.
phase_speeds : bool
Add phase speed lines to the plot
manual_locations : bool
Array for clabel locations.
Returns
-------
None
"""
if axes is None:
axes = plt.gca()
x = x[:xxlim]
data = data[:,:xxlim]
im = NonUniformImage(axes,interpolation='nearest',
extent=[x.min(),x.max(),y.min(),y.max()],rasterized=False)
im.set_cmap(cmap)
if vmin is None and vmax is None:
lim = np.max([np.nanmax(data),
np.abs(np.nanmin(data))])
im.set_clim(vmax=lim,vmin=-lim)
else:
im.set_clim(vmax=vmax,vmin=vmin)
im.set_data(x,y,data)
im.set_interpolation('nearest')
axes.images.append(im)
axes.set_xlim(x.min(),x.max())
axes.set_ylim(y.min(),y.max())
cax0 = make_axes_locatable(axes).append_axes("right", size="5%", pad=0.05)
cbar0 = plt.colorbar(im, cax=cax0, ticks=mpl.ticker.MaxNLocator(7))
cbar0.set_label(cbar_label)
cbar0.solids.set_edgecolor("face")
kwergs = {'levels': [1., 1/3., 1/5., 1/10., 1/20.]}
kwergs.update(kwargs)
if beta is not None:
ct = axes.contour(x,y,beta[:,:xxlim],colors=['k'], **kwergs)
plt.clabel(ct,fontsize=14,inline_spacing=3, manual=manual_locations,
fmt=mpl.ticker.FuncFormatter(betaswap))
axes.set_xlabel("Time [s]")
axes.set_ylabel("Height [Mm]")
ax1 = fig.add_subplot(121)
Pxx, freq, t, im = specgram(senial_indep_2500_muestras,
NFFT=NFFT,
Fs=500,
noverlap=noverlap,
scale_by_freq='magnitude',
detrend=mlab.detrend_linear,
window=mlab.window_hanning)
# Plot Spectrogram
im1 = NonUniformImage(ax1,
interpolation='bilinear',
extent=(min(t), max(t), 10, 55),
cmap='jet')
im1.set_data(t, freq, Pxx)
im1.set_clim()
ax1.images.append(im1)
cbar1 = fig.colorbar(im1)
plt.yscale('linear')
plt.ylabel('Frequency [Hz]', fontsize=18)
#xlab = 'Time [seconds] from ' + str(startutc) + ' UTC'
plt.xlabel('Time', fontsize=18)
plt.title('Espectrograma sujeto control', fontsize=18)
plt.xlim(0, max(t))
plt.ylim(0, 36)
# Sujeto dislexia
ax1 = fig.add_subplot(122)
Pxx_d, freq_d, t_d, im_d = specgram(senial_indep_2500_muestras_dislexia,
NFFT=NFFT,
def plot_wcohere(WCT,
t,
freq,
coi=None,
sig=None,
plot_period=False,
ax=None,
title="Wavelet Coherence",
block=None,
mask=None,
cax=None):
"""
Plot wavelet coherence using results from calc_wave_coherence.
Parameters
----------
*First 5 parameters can be obtained from from calc_wave_coherence
WCT: 2D numpy array with coherence values
t : 2D numpy array with sample_times
freq : 1D numpy array with the frequencies wavelets were calculated at
sig : 2D numpy array, default None
Optional. Plots significance of waveform coherence contours.
coi : 2D numpy array, default None
Optional. Pass coi to plot cone of influence
plot_period : bool
Should the y-axis be in period or in frequency (Hz)
ax : plt.axe, default None
Optional ax object to plot into.
title : str, default "Wavelet Coherence"
Optional title for the graph
block : [int, int]
Plots only points between ints.
Returns
-------
tuple : (fig, wcohere_pvals)
Where fig is a matplotlib Figure
and result is a tuple consisting of [WCT, t, y_vals]
"""
dt = np.mean(np.diff(t))
if plot_period:
y_vals = np.log2(1 / freq)
if not plot_period:
y_vals = np.log2(freq)
if ax is None:
fig, ax = plt.subplots()
else:
fig = None
if mask is not None:
WCT = np.ma.array(WCT, mask=mask)
# Set the x and y axes of the plot
extent_corr = [t.min(), t.max(), 0, max(y_vals)]
# Fill the plot with the magnitude squared coherence values
im = NonUniformImage(ax, interpolation='bilinear', extent=extent_corr)
if plot_period:
im.set_data(t, y_vals, WCT)
else:
im.set_data(t, y_vals[::-1], WCT[::-1, :])
im.set_clim(0, 1)
ax.images.append(im)
# Plot the cone of influence - Periods greater thanthose are subject to edge effects.
if coi is not None:
# Performed by plotting a polygon
x_positions = np.zeros(shape=(len(t), ))
x_positions = t
y_positions = np.zeros(shape=(len(t), ))
if plot_period:
y_positions = np.log2(coi)
else:
y_positions = np.log2(1 / coi)
ax.plot(x_positions, y_positions, 'w--', linewidth=2, c="w")
# Plot the significance level contour plot
if sig is not None:
ax.contour(t,
y_vals,
sig, [-99, 1],
colors='k',
linewidths=2,
extent=extent_corr)
# Add limits, titles, etc.
ax.set_ylim(min(y_vals), max(y_vals))
if block:
ax.set_xlim(t[block[0]], t[int(block[1] * 1 / dt)])
else:
ax.set_xlim(t.min(), t.max())
if plot_period:
y_ticks = np.linspace(min(y_vals), max(y_vals), 8)
# TODO improve ticks
y_ticks = [
np.log2(x)
for x in [0.004, 0.008, 0.016, 0.032, 0.064, 0.125, 0.25, 0.5, 1]
]
y_labels = [str(x) for x in (np.round(np.exp2(y_ticks), 3))]
ax.set_ylabel("Period")
else:
y_ticks = np.linspace(min(y_vals), max(y_vals), 8)
# TODO improve ticks
# y_ticks = [np.log2(x) for x in [256, 128, 64, 32, 16, 8, 4, 2, 1]]
y_ticks = [np.log2(x) for x in [64, 32, 16, 8, 4, 2, 1]]
y_labels = [str(x) for x in (np.round(np.exp2(y_ticks), 3))]
ax.set_ylabel("Frequency (Hz)")
ax.set_yticks(y_ticks)
ax.set_yticklabels(y_labels)
ax.set_title(title)
ax.set_xlabel("Time (s)")
if cax is not None:
plt.colorbar(im, cax=cax, use_gridspec=False)
else:
if fig is not None:
fig.colorbar(im)
else:
plt.colorbar(im, ax=ax, use_gridspec=True)
return fig, [WCT, t, y_vals]
def visuTransfo(rasterTransfo, inputData, cfgPath, cfgFlags):
"""
Plot and save the domain transformation figure
"""
# read paths
pathResult = cfgPath['pathResult']
projectName = cfgPath['dirName']
# read rasterdata
sourceData = inputData['sourceData']
header = sourceData['header']
xllc = rasterTransfo['xllc']
yllc = rasterTransfo['yllc']
cellsize = rasterTransfo['cellsize']
rasterdata = sourceData['rasterData']
# read avaPath with scale
Avapath = inputData['Avapath']
xPath = Avapath['x']
yPath = Avapath['y']
# read domain boundarries with scale
DBXl = rasterTransfo['DBXl']*cellsize+xllc
DBXr = rasterTransfo['DBXr']*cellsize+xllc
DBYl = rasterTransfo['DBYl']*cellsize+yllc
DBYr = rasterTransfo['DBYr']*cellsize+yllc
fig = plt.figure(figsize=(figW*2, figH), dpi=figReso)
# for figure: referenz-simulation bei pLim=1
ax1 = plt.subplot(121)
indRunoutPoint = rasterTransfo['indRunoutPoint']
xx = rasterTransfo['x'][indRunoutPoint]
yy = rasterTransfo['y'][indRunoutPoint]
newRasterdata = rasterdata
maskedArray = newRasterdata # np.ma.masked_where(np.isnan(newRasterdata), newRasterdata)
cmap = cmapPres
cmap.set_under(color='w')
n, m = np.shape(newRasterdata)
x = np.arange(m)*cellsize+xllc
y = np.arange(n)*cellsize+yllc
im0 = NonUniformImage(ax1, extent=[x.min(), x.max(), y.min(), y.max()], cmap=cmap)
# im.set_interpolation('bilinear')
im0.set_clim(vmin=0.000000001)
im0.set_data(x, y, maskedArray)
ref1 = ax1.images.append(im0)
# cbar = ax1.figure.colorbar(im0, ax=ax1, use_gridspec=True)
plt.autoscale(False)
ref0 = plt.plot(xx, yy, 'ro', markersize=ms, label='Beta point')
ref2 = plt.plot(xPath, yPath,
'b-', linewidth=lw, label='flow path')
ref3 = plt.plot(DBXl, DBYl,
'g-', linewidth=lw, label='domain')
ref3 = plt.plot(DBXr, DBYr,
'g-', linewidth=lw, label='domain')
ref3 = plt.plot([DBXl, DBXr], [DBYl, DBYr],
'g-', linewidth=lw, label='domain')
refs = [ref0[0], ref2[0], ref3[0]]
labels = ['Beta point', 'flow path', 'domain']
ax1.title.set_text('XY Domain')
ax1.legend(refs, labels, loc=0)
ax1.set_xlim([x.min(), x.max()])
ax1.set_ylim([y.min(), y.max()])
ax1.set_xlabel(r'$x\;[m]$')
ax1.set_ylabel(r'$y\;[m]$')
ax2 = plt.subplot(122)
ax2.title.set_text('sl Domain \n Black = out of raster')
isosurf = copy.deepcopy(inputData['avalData'])
lcoord = rasterTransfo['l']
scoord = rasterTransfo['s']
ref1 = ax2.axhline(y=scoord[indRunoutPoint], color='r', linewidth=lw,
linestyle='-', label='Beta point')
maskedArray = isosurf # np.ma.array(isosurf,mask=np.isnan(isosurf))
im = NonUniformImage(ax2, extent=[lcoord.min(), lcoord.max(),
scoord.min(), scoord.max()], cmap=cmap)
# im.set_interpolation('bilinear')
im.set_clim(vmin=0.000000001)
im.set_data(lcoord, scoord, maskedArray)
ref0 = ax2.images.append(im)
cbar = ax2.figure.colorbar(im, ax=ax2, use_gridspec=True)
cbar.ax.set_ylabel('peak pressure [kPa]')
ax2.set_xlim([lcoord.min(), lcoord.max()])
ax2.set_ylim([scoord.min(), scoord.max()])
ax2.set_xlabel(r'$l\;[m]$')
ax2.set_ylabel(r'$s\;[m]$')
ax2.legend()
fig.tight_layout()
if cfgFlags.getboolean('plotFigure'):
plt.show()
else:
plt.ioff()
if cfgFlags.getboolean('savePlot'):
outname = ''.join([pathResult, os.path.sep, 'pics', os.path.sep,
projectName, '_domTransfo', '.pdf'])
if not os.path.exists(os.path.dirname(outname)):
os.makedirs(os.path.dirname(outname))
fig.savefig(outname, transparent=True)
plt.close(fig)
