Python matplotlib.colors 模块，Lognorm() 实例源码
我们从Python开源项目中，提取了以下34个代码示例，用于说明如何使用matplotlib.colors.Lognorm()。
def show_C12(C12, qz_ind=0, qr_ind=0, N1=None,N2=None, vmin=None, vmax=None, title=False):
g12_num = qz_ind * num_qr + qr_ind
if N1 is None:
N1=0
if N2 is None:
N2=Nming
if vmin is None:
vmin = 1
if vmax is None:
vmax = 1.02
data = g12b[N1:N2,N1:N2,g12_num]
fig, ax = plt.subplots()
im=ax.imshow( data, origin='lower' , cmap='viridis',
norm= Lognorm( vmin, vmax ),
extent=[0, data.shape[0]*timeperframe, 0, data.shape[0]*timeperframe ] )
#ax.set_title('%s-%s frames--Qth= %s'%(N1,N2,g12_num))
if title:
ax.set_title('%s-%s frames--Qz= %s--Qr= %s'%(N1,N2, qz_center[qz_ind], qr_center[qr_ind] ))
ax.set_xlabel( r'$t_1$ $(s)$', fontsize = 18)
ax.set_ylabel( r'$t_2$ $(s)$', fontsize = 18)
fig.colorbar(im)
#plt.show()
def prettyPlot(samps, dat, hid):
fig, ax = plt.subplots()
sz = 18
plt.rc('xtick', labelsize=sz)
plt.rc('ytick', labelsize=sz)
ax.set_xticklabels([1]+samps, fontsize=sz)
ax.set_yticklabels([1]+samps[::-1], fontsize=sz)
ax.xaxis.set_major_locator(ticker.MultipleLocator(1))
ax.yaxis.set_major_locator(ticker.MultipleLocator(1))
ax.set_xlabel('Number of Experts', fontsize=sz+2)
ax.set_ylabel('Minibatch Size', fontsize=sz+2)
ax.set_title('MOE Cell Speedup Factor', fontsize=sz+4)
#Show cell values
for i in range(len(samps)):
for j in range(len(samps)):
ax.text(i, j, str(dat[i,j])[:4], ha='center', va='center', fontsize=sz, color='white')
plt.imshow(cellTimes, norm=colors.Lognorm(vmin=cellTimes.min(), vmax=cellTimes.max()))
plt.show()
def mplot_function(f, vmin, vmax, logscale):
mesh = f.function_space().mesh()
if (mesh.geometry().dim() != 2):
raise AttributeError('Mesh must be 2D')
# DG0 cellwise function
if f.vector().size() == mesh.num_cells():
C = f.vector().get_local()
if logscale:
return plt.tripcolor(mesh2triang(mesh), C, vmin=vmin, vmax=vmax, norm=cls.Lognorm() )
else:
return plt.tripcolor(mesh2triang(mesh), vmax=vmax)
# Scalar function,interpolated to vertices
elif f.value_rank() == 0:
C = f.compute_vertex_values(mesh)
if logscale:
return plt.tripcolor(mesh2triang(mesh), shading='gouraud', vmax=vmax)
# Vector function,interpolated to vertices
elif f.value_rank() == 1:
w0 = f.compute_vertex_values(mesh)
if (len(w0) != 2*mesh.num_vertices()):
raise AttributeError('Vector field must be 2D')
X = mesh.coordinates()[:, 0]
Y = mesh.coordinates()[:, 1]
U = w0[:mesh.num_vertices()]
V = w0[mesh.num_vertices():]
C = np.sqrt(U*U+V*V)
return plt.quiver(X,Y,U,V, units='x', headaxislength=7, headwidth=7, headlength=7, scale=4, pivot='middle')
# Plot a generic dolfin object (if supported)
def _get_cmap_data(data, kwargs):
"""Get normalized values to be used with a colormap.
Parameters
----------
data : array_like
cmap_min : Optional[float] or "min"
By default 0. If "min",minimum value of the data.
cmap_max : Optional[float]
By default,maximum value of the data
cmap_normalize : str or colors.normalize
Returns
-------
normalizer : colors.normalize
normalized_data : array_like
"""
norm = kwargs.pop("cmap_normalize", None)
if norm == "log":
cmap_max = kwargs.pop("cmap_max", data.max())
cmap_min = kwargs.pop("cmap_min", data[data > 0].min())
norm = colors.Lognorm(cmap_min, cmap_max)
elif not norm:
cmap_max = kwargs.pop("cmap_max", 0)
if cmap_min == "min":
cmap_min = data.min()
norm = colors.normalize(cmap_min, cmap_max, clip=True)
return norm, norm(data)
def plot(self):
# Prepare the data
x = self.locs[self.field_x]
y = self.locs[self.field_y]
valid = (np.isfinite(x) & np.isfinite(y))
x = x[valid]
y = y[valid]
# Prepare the figure
self.figure.clear()
# self.canvas.figure = self.figure
axes = self.figure.add_subplot(111)
# Start hist2 version
bins_x = lib.calculate_optimal_bins(x, 1000)
bins_y = lib.calculate_optimal_bins(y, 1000)
counts, x_edges, y_edges, image = axes.hist2d(x, y, bins=[bins_x, bins_y], norm=Lognorm())
x_range = x.ptp()
axes.set_xlim([bins_x[0] - 0.05*x_range, x.max() + 0.05*x_range])
y_range = y.ptp()
axes.set_ylim([bins_y[0] - 0.05*y_range, y.max() + 0.05*y_range])
self.figure.colorbar(image, ax=axes)
axes.grid(False)
axes.get_xaxis().set_label_text(self.field_x)
axes.get_yaxis().set_label_text(self.field_y)
self.selector = RectangleSelector(axes, self.on_rect_select, useblit=False,
rectprops=dict(facecolor='green', alpha=0.2, fill=True))
self.canvas.draw()
def daplot(quantity, qmin, qmax):
ax.set_xlim(0, size)
ax.set_ylim(0, size)
ax.set_xticklabels(())
ax.set_yticklabels(())
plt.imshow(quantity, origin='lower', interpolation='nearest',
norm=colors.Lognorm(vmin=qmin, vmax=qmax), cmap=cm.coolwarm)
cbar = plt.colorbar()
cbar.ax.tick_params(labelsize=14)
# minimum and maximum emission-line fluxes for plot ranges
def daplot(quantity, cmap=cm.coolwarm)
plt.colorbar()
# minimum and maximum emission-line fluxes for plot ranges
def daplot(quantity, cmap=cm.coolwarm)
plt.colorbar()
# minimum and maximum emission-line fluxes for plot ranges
def plot_price(smoothed_prices):
plot_over_map(10**(smoothed_prices - 3), norm=Lognorm(1.5e2, 1e3))
cb = plt.colorbar(fraction=0.03, ticks=sp.linspace(2e2, 1e3, 9), format=FormatStrFormatter(u'£%dk'))
cb.set_label(u'price paid (£1000s)')
plt.title('2015 Average Price Paid')
plt.gcf().set_size_inches(36, 36)
plt.gcf().savefig(os.path.join(OUTPUT_PATH, 'price_paid.png'), bBox_inches='tight')
def plot_relative_price(relative_prices):
plot_over_map(10**relative_prices, norm=Lognorm(0.5, 2))
cb = plt.colorbar(fraction=0.03, ticks=sp.linspace(0.5, 2, 4), format=FormatStrFormatter('x%.2f'))
cb.set_label('fraction of average price paid for commute time')
plt.title('Price relative to commute')
plt.gcf().set_size_inches(36, 'relative_price.png'), bBox_inches='tight')
def plot(outfn, a, genomeSize, base2chr, _windowSize, dpi=300, ext="svg"):
"""Save contact plot"""
def format_fn(tick_val, tick_pos):
"""Mark axis ticks with chromosome names"""
if int(tick_val) in base2chr:
return base2chr[int(tick_val)]
else:
sys.stderr.write("[WARNING] %s not in ticks!\n"%tick_val)
return ''
# invert base2chr
base2chr = {genomeSize-b: c for b, c in base2chr.iteritems()}
# start figure
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_title("Contact intensity plot [%sk]"%(_windowSize/1000,))
# label Y axis with chromosome names
if len(base2chr)<50:
ax.yaxis.set_major_formatter(FuncFormatter(format_fn))
ax.yaxis.set_major_locator(MaxNLocator(integer=True))
plt.yticks(base2chr.keys())
ax.set_ylabel("Chromosomes")
else:
ax.set_ylabel("Genome position")
# label axes
ax.set_xlabel("Genome position")
plt.imshow(a+1, cmap=cm.hot, norm=Lognorm(), extent=(0, genomeSize))#
plt.colorbar()
# save
fig.savefig("%s.%s"%(outfn,ext), dpi=dpi, papertype="a4")
def plot_confusion_matrix(labels, confusion_matrix, directory, name, extension):
"""
Plots the normalized confusion matrix with the target names as axis ticks.
"""
IoUs = calculate_IoU(confusion_matrix)
size = len(labels)/5+2
fig, ax = plt.subplots(figsize=(size+2, size))
plot = ax.imshow(confusion_matrix, cmap=plt.cm.Blues, norm=Lognorm())
# plot.set_clim(vmin=0,vmax=100)
ticks_with_IoU = []
ticks_without_IoU = []
tick_marks = np.arange(len(IoUs))
IoUs_for_average = []
for label, IoU in zip(labels, IoUs):
if math.isnan(IoU):
IoU = 0
else:
IoUs_for_average.append(IoU)
ticks_with_IoU.append("{}: {:.2%}".format(label['name'], IoU))
ticks_without_IoU.append("{}".format(label['name']))
avg_IoU = np.average(IoUs_for_average)
fig.colorbar(plot)
ax.set_xticks(tick_marks)
ax.set_xticklabels(ticks_without_IoU, rotation=90)
ax.set_yticks(tick_marks)
ax.set_yticklabels(ticks_with_IoU)
ax.set_title("Average IoU: {:.2%}".format(avg_IoU))
ax.set_xlabel('Predicted label')
ax.set_ylabel('True label')
fig.tight_layout()
fig.savefig(os.path.join(directory, '{}.{}'.format(name, extension)))
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=None,
zmin=1):
"""Print and plot the confusion matrix for the intent classification.
normalization can be applied by setting `normalize=True`."""
import numpy as np
zmax = cm.max()
plt.clf()
plt.imshow(cm, cmap=cmap if cmap else plt.cm.Blues,
aspect='auto', norm=Lognorm(vmin=zmin, vmax=zmax))
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, rotation=90)
plt.yticks(tick_marks, classes)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
logger.info("normalized confusion matrix: \n{}".format(cm))
else:
logger.info("Confusion matrix,without normalization: \n{}".format(cm))
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.ylabel('True label')
plt.xlabel('Predicted label')
def create_plot_correlation(params,plabs,col='red',mark='.',num=[]):
if ( len(num) < 1 ):
n = range(0,len(params))
else:
n = num
plt.figure(1,figsize=(4*len(n),4*len(n)))
gs = gridspec.GridSpec(nrows=len(n),ncols=len(n))
o = 0
for i in n:
p = 0
for j in n:
if ( j < i ):
plt.subplot(gs[o*len(n)+p])
plt.tick_params( axis='y',which='both',direction='in',labelleft='off')
plt.tick_params( axis='x',labelbottom='off')
plt.ticklabel_format(uSEOffset=False, axis='both')
if ( j == n[0] ):
plt.ylabel(plabs[i],fontsize=25)
elif ( j == i - 1 ):
plt.tick_params( axis='y',labelleft='off')
plt.tick_params( axis='x',labelbottom='off')
else:
plt.tick_params( axis='y',labelbottom='off')
if ( i == n[len(n)-1]):
plt.xlabel(plabs[j],fontsize=25)
else:
plt.tick_params( axis='y',labelbottom='off')
plt.hist2d(params[j],params[i],bins=100,norm=Lognorm())
p = p + 1
o = o + 1
fname = outdir+'/'+star+'_correlations.pdf'
print 'Creating ', fname
plt.savefig(fname,format='pdf',bBox_inches='tight')
plt.close()
def _save_2d_error_plot(self, detector, xlist, ylist, elist, x_axis_label, y_axis_label, z_axis_label):
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from matplotlib import colors
# configure logscale on X and Y axis (both for positive and negative numbers)
fig, ax = plt.subplots(1, 1)
if PlotAxis.x in self.axis_with_logscale:
plt.xscale('symlog')
if PlotAxis.y in self.axis_with_logscale:
plt.yscale('symlog')
if PlotAxis.z in self.axis_with_logscale:
norm = colors.Lognorm(vmin=elist[elist > 0].min(), vmax=elist.max())
else:
norm = colors.normalize(vmin=elist.min(), vmax=elist.max())
plt.xlabel(x_axis_label)
plt.ylabel(y_axis_label)
mesh = plt.pcolormesh(xlist, elist.clip(0.0), cmap=self.colormap, norm=norm)
cbar = fig.colorbar(mesh)
cbar.set_label(label=z_axis_label, rotation=270, verticalalignment='bottom')
base_name, _ = os.path.splitext(self.plot_filename)
plt.savefig(base_name + "_error.png")
plt.close()
def clicks_heatmap_first_occ():
print 'loading'
db = MysqLDatabase(DATABASE_HOST, DATABASE_USER, DATABASE_PASSWORD, DATABASE_NAME)
db_worker_view = db.get_work_view()
coords = db_worker_view.retrieve_all_links_coords_clicks_first_occ()
print 'coord loaded'
links = {}
x = []
y = []
values = []
for link in coords.values():
x_normed = float(link['x'])/float(1920)
y_normed = float(link['y'])/float(link['page_length'])
if x_normed <=1.0 and y_normed <=1.0:
x.append(x_normed)
y.append(y_normed)
values.append(float(link['counts']))
heatmap, xedges, yedges = np.histogram2d(x, bins=100, weights=values)
extent = [xedges[0], xedges[-1], yedges[-1], yedges[0] ]
fig_size = (2.4, 2)
plt.clf()
plt.figure(figsize=fig_size)
plt.grid(True)
plt.imshow(heatmap , extent=extent, origin='upper', cmap=plt.get_cmap('jet'))
plt.colorbar()
#plt.title("Clicks Heatmap Log normalized")
plt.show()
plt.savefig('output/clicks_heatmap_lognormed_self_loop_first_occ.pdf')
plt.clf()
plt.figure(figsize=fig_size)
plt.grid(True)
plt.imshow(heatmap , norm=normalize(), cmap=plt.get_cmap('jet'))
plt.colorbar()
#plt.title("Clicks Heatmap normalized")
plt.show()
plt.savefig('output/clicks_heatmap_normed_self_loop_first_occ.pdf')
print "done"
def clicks_heatmap_total():
print 'loading'
db = MysqLDatabase(DATABASE_HOST, DATABASE_NAME)
db_worker_view = db.get_work_view()
coords = db_worker_view.retrieve_all_links_coords_clicks()
print 'coord loaded'
links = {}
x = []
y = []
values = []
for coord in coords:
x_normed = float(coord['x'])/float(1920)
y_normed = float(coord['y'])/float(coord['page_length'])
if x_normed <=1.0 and y_normed <=1.0:
x.append(x_normed)
y.append(y_normed)
values.append(float(coord['counts']))
heatmap, yedges[0] ]
fig_size = (2.4, cmap=plt.get_cmap('jet'))
plt.colorbar()
#plt.title("Clicks Heatmap Log normalized")
plt.show()
plt.savefig('output/clicks_heatmap_lognormed_self_loop_total.pdf')
plt.clf()
plt.figure(figsize=fig_size)
plt.grid(True)
plt.imshow(heatmap , cmap=plt.get_cmap('jet'))
plt.colorbar()
#plt.title("Clicks Heatmap normalized")
plt.show()
plt.savefig('output/clicks_heatmap_normed_self_loop_total.pdf')
print "done"
def links_heatmap():
#http://stackoverflow.com/questions/2369492/generate-a-heatmap-in-matplotlib-using-a-scatter-data-set
# Get URLs from a text file,remove white space.
print 'loading'
db = MysqLDatabase(DATABASE_HOST, DATABASE_NAME)
db_worker_view = db.get_work_view()
coords = db_worker_view.retrieve_all_links_coords()
print 'coord loaded'
x=[]
y=[]
page_lenghts = db_worker_view.retrieve_all_page_lengths()
print 'lenghts loaded'
for coord in coords:
x_normed = float(coord['x'])/float(1920)
y_normed = float(coord['y'])/float(page_lenghts[coord['source_article_id']])
if x_normed <=1.0 and y_normed <=1.0:
x.append(x_normed)
y.append(y_normed)
heatmap, bins=100)
extent = [xedges[0], yedges[0]]
fig_size = (2.4, 2)
#fig_size = (3.5,3)
plt.clf()
plt.figure(figsize=fig_size)
plt.grid(True)
plt.imshow(heatmap, cmap=plt.get_cmap('jet'))
plt.colorbar()
#plt.title("Links Heatmap Log normalized")
plt.show()
plt.savefig('output/links_heatmap_lognormed_self_loop.pdf')
plt.clf()
plt.figure(figsize=fig_size)
plt.grid(True)
plt.imshow(heatmap ,cmap=plt.get_cmap('jet'))
plt.colorbar()
#plt.title("Links Heatmap normalized")
plt.show()
plt.savefig('output/links_heatmap_normed_self_loop.pdf')
print "done"
def plot(self,keys=None,burn=1000):
if keys is None:
keys=self.names0
k=0
#plm=putil.Plm1(rows=2,cols=2,xmulti=True,ymulti=True,slabel=False)
for i in range(len(keys)):
for j in range(len(keys)):
k=k+1
if i==j:
x=self.chain[keys[i]][burn:]
plt.subplot(len(keys),len(keys),k)
#sig=np.std(self.chain[keys[i]][burn:])
xmean=np.mean(x)
nbins=np.max([20,x.size/1000])
plt.hist(x,bins=nbins,normed=True,histtype='step')
plt.axvline(np.mean(self.chain[keys[i]][burn:]),lw=2.0,color='g')
if i == (len(keys)-1):
plt.xlabel(self.descr[keys[i]][3])
plt.text(0.05,0.7,stat_text(self.chain[keys[i]][burn:]),transform=plt.gca().transAxes)
plt.gca().xaxis.set_major_locator(MaxNLocator(3, prune="both"))
plt.gca().yaxis.set_major_locator(MaxNLocator(3, prune="both"))
plt.gca().set_yticklabels([])
else:
if i > j:
plt.subplot(len(keys),k)
x=self.chain[keys[j]][burn:]
y=self.chain[keys[i]][burn:]
nbins=np.max([32,x.size/1000])
plt.hist2d(x,y,bins=[nbins,nbins],norm=Lognorm())
plt.axvline(np.mean(self.chain[keys[j]][burn:]),lw=2.0)
plt.axhline(np.mean(self.chain[keys[i]][burn:]),lw=2.0)
if j == 0:
plt.ylabel(self.descr[keys[i]][3])
else:
plt.gca().set_yticklabels([])
if i == (len(keys)-1):
plt.xlabel(self.descr[keys[j]][3])
else:
plt.gca().set_xticklabels([])
plt.gca().xaxis.set_major_locator(MaxNLocator(3, prune="both"))
plt.gca().yaxis.set_major_locator(MaxNLocator(3, prune="both"))
#plt.colorbar(pad=0.0,fraction=0.1)
plt.subplots_adjust(hspace=0.15,wspace=0.1)
def plotFace2D(
mesh2D,
j, real_or_imag='real', ax=None, range_x=None,
range_y=None, sample_grid=None,
logScale=True, clim=None, mirror=False, pcolorOpts=None,
cbar=True
):
"""
Create a streamplot (a slice in the theta direction) of a face vector
:param discretize.CylMesh mesh2D: cylindrically symmetric mesh
:param np.ndarray j: face vector (x,z components)
:param str real_or_imag: real or imaginary component
:param matplotlib.axes ax: axes
:param numpy.ndarray range_x: x-extent over which we want to plot
:param numpy.ndarray range_y: y-extent over which we want to plot
:param numpy.ndarray sample_grid: x,y spacings at which to re-sample the plotting grid
:param bool logScale: use a log scale for the colorbar?
"""
if ax is None:
fig, 1, figsize=(6, 4))
if len(j) == mesh2D.nF:
vType = 'F'
elif len(j) == mesh2D.nC*2:
vType = 'CCv'
if pcolorOpts is None:
pcolorOpts = {}
if logScale is True:
pcolorOpts['norm'] = Lognorm()
else:
pcolorOpts = {}
f = mesh2D.plotimage(
getattr(j, real_or_imag),
view='vec', vType=vType, ax=ax,
range_x=range_x, range_y=range_y, sample_grid=sample_grid,
mirror=mirror,
pcolorOpts=pcolorOpts,
)
out = (ax,)
if cbar is True:
cb = plt.colorbar(f[0], ax=ax)
out += (cbar,)
if clim is not None:
cb.set_clim(clim)
cb.update_ticks()
return out
def plotEdge2D(
mesh2D,
h, pcolorOpts=None
):
"""
Create a pcolor plot (a slice in the theta direction) of an edge vector
:param discretize.CylMesh mesh2D: cylindrically symmetric mesh
:param np.ndarray h: edge vector (y components)
:param str real_or_imag: real or imaginary component
:param matplotlib.axes ax: axes
:param numpy.ndarray range_x: x-extent over which we want to plot
:param numpy.ndarray range_y: y-extent over which we want to plot
:param numpy.ndarray sample_grid: x,y spacings at which to re-sample the plotting grid
:param bool logScale: use a log scale for the colorbar?
"""
if ax is None:
fig, 4))
if len(h) == mesh2D.nE:
vType = 'E'
elif len(h) == mesh2D.nC:
vType = 'CC'
elif len(h) == 2*mesh2D.nC:
vType = 'CCv'
if logScale is True:
pcolorOpts['norm'] = Lognorm()
else:
pcolorOpts = {}
cb = plt.colorbar(
mesh2D.plotimage(
getattr(h,
view='real',
range_x=range_x,
mirror=mirror,
pcolorOpts=pcolorOpts,
)[0], ax=ax
)
if clim is not None:
cb.set_clim(clim)
return ax, cb
def save_png_series( imgs, ROI=None, logs=True, outDir=None, uid=None,vmin=None,cmap='viridis',dpi=100):
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import Lognorm
"""
save a series of images in a format of png
Parameters
----------
imgs : array
image data array for the movie
dimensions are: [num_img][num_rows][num_cols]
ROI: e.g. xs,xe,ys,ye = vert #x_start,x_end,y_start,y_end
outDir: the output path
vmin/vmax: for image contrast
cmap: the color for plot
dpi: resolution
Returns
-------
save png files
"""
if uid==None:
uid='uid'
num_frame=0
for img in imgs:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
if ROI is None:
i0=img
asp =1.0
else:
i0=select_regoin(img, ROI, keep_shape=False,)
xs,xe,ys,ye = ROI
asp = (ye-ys)/float( xe - xs )
ax.set_aspect('equal')
if not logs:
im=ax.imshow(i0,cmap=cmap,interpolation="nearest",vmax=vmax) #vmin=0,vmax=1,
else:
im=ax.imshow(i0,
interpolation="nearest" , norm=Lognorm(vmin, vmax))
#ttl = ax.text(.75,.2,'',transform = ax.transAxes,va='center',color='white',fontsize=18)
#fig.set_size_inches( [5.,5 * asp] )
#plt.tight_layout()
fname = outDir + 'uid_%s-frame-%s.png'%(uid,num_frame )
num_frame +=1
plt.savefig( fname, dpi=None )
def spectrogram(self,
ax=None,
freq_range=None,
dB_thresh=35,
derivative=True,
colormap='gray',
compensated=True):
"""Plots a spectrogram,requires matplotlib
ax - axis on which to plot
freq_range - a tuple of frequencies,eg (300,8000)
dB_thresh - noise floor threshold value,increase to suppress noise,
decrease to improve detail
derivative - if True,plots the spectral derivative,SAP style
colormap - colormap to use,good values: 'inferno','gray'
compensated - if True,centers the displayed window around the center
of the short FFT. If False,the window always starts
at the begining of data window. Both methods are equivalent
when n_overlap = 0 and the data window length is the full nfft.
Returns an axis object
"""
if compensated:
data_overlap = self._noverlap + self._data_in_window - self._nfft
if data_overlap < 0:
print('warning: spectrogram does not fully cover the data')
data_overlap = 0
comp = (data_overlap / 2) / self._rate
else:
comp = 0
from matplotlib import colors
if ax is None:
import matplotlib.pyplot as plt
ax = plt.gca()
if derivative:
pxx, f, t = self.max_spec_derivative(freq_range=freq_range)
thresh = value_from_dB(dB_thresh, np.max(pxx))
ax.pcolorfast(t + comp,
f,
pxx,
cmap=colormap,
norm=colors.SymLognorm(linthresh=thresh))
else:
pxx, t = self.power(freq_range)
thresh = value_from_dB(dB_thresh,
norm=colors.Lognorm(vmin=thresh))
return ax
def plot_img(ax, data, **kwargs):
"""plot an image using imshow,pcolor,pcolormesh
"""
assert ax is not None, "missing axis argument 'ax'"
vmin = kwargs['vmin']
vmax = kwargs['vmax']
cmap = kwargs['cmap']
title = kwargs['title']
# FIXME: convert plottype into func: imshow,pcolormesh,pcolorfast
mpl = ax.pcolorfast(data, vmin = vmin, vmax = vmax, cmap = cmap)
# normalize to [0,1]
# mpl = ax.imshow(inv,interpolation = "none")
# mpl = ax.pcolorfast(data,vmin = vmin,vmax = vmax,cmap = cmap)
# mpl = ax.pcolorfast(data,vmin = vmins[j],vmax = vmaxs[j],vmin = -2,vmax = 2,cmap = cmap)
# mpl = ax.pcolormesh(data,cmap = cmap)
# mpl = ax.pcolor(data)
# mpl = ax.pcolorfast(data)
# mpl = ax.imshow(data,interpolation = "none")
# mpl = ax.pcolormesh(
# data,
# norm = mplcolors.Lognorm(vmin=data.min(),vmax=data.max())
ax.grid(0)
if kwargs.has_key('aspect'):
ax.set_aspect(kwargs['aspect'])
if kwargs.has_key('colorbar'):
if kwargs['colorbar']:
plt.colorbar(mappable = mpl, ax = ax, orientation = "horizontal")
if kwargs.has_key('title'):
ax.set_title(title) #,fontsize=8)
else:
ax.set_title("%s" % ('matrix')) #,fontsize=8)
# if kwargs.has_key('xlabel'):
ax.set_xlabel("")
# if kwargs.has_key('ylabel'):
ax.set_ylabel("")
# if kwargs.has_key('xticks'):
ax.set_xticks([])
# if kwargs.has_key('yticks'):
ax.set_yticks([])
def plot_all_chan_spectrum(spectrum, bins, *, **kwargs):
def integrate_to_angles(spectrum, lo, hi):
lo_ind, hi_ind = bins.searchsorted([lo, hi])
return spectrum[lo_ind:hi_ind].sum(axis=0)
if ax is None:
fig, ax = plt.subplots(figsize=(13.5, 9.5))
else:
fig = ax.figure
div = make_axes_locatable(ax)
ax_r = div.append_axes('right', pad=0.1, sharey=ax)
ax_t = div.append_axes('top', sharex=ax)
ax_r.yaxis.tick_right()
ax_r.yaxis.set_label_position("right")
ax_t.xaxis.tick_top()
ax_t.xaxis.set_label_position("top")
im = ax.imshow(spectrum, aspect='auto',
extent=(-.5, 383.5,
bins[0], bins[-1]),
norm=Lognorm())
e_line, = ax_r.plot(spectrum.sum(axis=1), bins[:-1] + np.diff(bins))
p_line, = ax_t.plot(spectrum.sum(axis=0))
label = ax_t.annotate('[0,70] kEv', (0, 1), (10, -10),
xycoords='axes fraction',
textcoords='offset pixels',
va='top', ha='left')
def update(lo, hi):
p_data = integrate_to_angles(spectrum, hi)
p_line.set_ydata(p_data)
ax_t.relim()
ax_t.autoscale(axis='y')
label.set_text(f'[{lo:.1f},{hi:.1f}] keV')
fig.canvas.draw_idle()
span = SpanSelector(ax_r, update, 'vertical', useblit=True,
rectprops={'alpha': .5, 'facecolor': 'red'},
span_stays=True)
ax.set_xlabel('channel [#]')
ax.set_ylabel('E [keV]')
ax_t.set_xlabel('channel [#]')
ax_t.set_ylabel('total counts')
ax_r.set_ylabel('E [keV]')
ax_r.set_xlabel('total counts')
ax.set_xlim(-.5, 383.5)
ax.set_ylim(bins[0], bins[-1])
ax_r.set_xlim(xmin=0)
return spectrum, {'center': {'ax': ax, 'im': im},
'top': {'ax': ax_t, 'p_line': p_line},
'right': {'ax': ax_r, 'e_line': e_line,
'span': span}}
def _ticker(self):
'''
Return two sequences: ticks (colorbar data locations)
and ticklabels (strings).
'''
locator = self.locator
formatter = self.formatter
if locator is None:
if self.boundaries is None:
if isinstance(self.norm, colors.Nonorm):
nv = len(self._values)
base = 1 + int(nv / 10)
locator = ticker.IndexLocator(base=base, offset=0)
elif isinstance(self.norm, colors.Boundarynorm):
b = self.norm.boundaries
locator = ticker.FixedLocator(b, nbins=10)
elif isinstance(self.norm, colors.Lognorm):
locator = ticker.LogLocator()
else:
locator = ticker.MaxNLocator()
else:
b = self._boundaries[self._inside]
locator = ticker.FixedLocator(b, nbins=10)
if isinstance(self.norm, colors.Nonorm):
intv = self._values[0], self._values[-1]
else:
intv = self.vmin, self.vmax
locator.create_dummy_axis(minpos=intv[0])
formatter.create_dummy_axis(minpos=intv[0])
locator.set_view_interval(*intv)
locator.set_data_interval(*intv)
formatter.set_view_interval(*intv)
formatter.set_data_interval(*intv)
b = np.array(locator())
ticks = self._locate(b)
inrange = (ticks > -0.001) & (ticks < 1.001)
ticks = ticks[inrange]
b = b[inrange]
formatter.set_locs(b)
ticklabels = [formatter(t, i) for i, t in enumerate(b)]
offset_string = formatter.get_offset()
return ticks, ticklabels, offset_string
def _ticker(self):
'''
Return the sequence of ticks (colorbar data locations),
ticklabels (strings),and the corresponding offset string.
'''
locator = self.locator
formatter = self.formatter
if locator is None:
if self.boundaries is None:
if isinstance(self.norm, offset_string
def heatmap(X, Y, Z, logy=True, cbar=True, hide_low=True,
cmap=default_cmap, fig_kws={}, cbar_kws={}, plot_kws={}, **kwargs):
"""Plot the heatmap of the particle size distribution.
"""
# Set the colorbar min and max based on the min and max of the values
cbar_min = kwargs.pop('cbar_min', Z.min() if Z.min() > 0.0 else 1.)
cbar_max = kwargs.pop('cbar_max', Z.max())
# copy to avoid modifying original data
Z_plot = Z.copy()
if hide_low:
# Hide NaN values
Z_plot = nan_to_num(Z_plot)
# Increase values below cbar_min to cbar_min
below_min = Z_plot < cbar_min
Z_plot[below_min] = cbar_min
# Set the plot_kws
plot_kws = dict(dict(norm=Lognorm(vmin=cbar_min, vmax=cbar_max), cmap=cmap),
**plot_kws)
# Set the figure keywords
fig_kws = dict(dict(figsize=(16,8)), **fig_kws)
if ax is None:
plt.figure(**fig_kws)
ax = plt.gca()
# Plot the data as a pcolormesh
im = ax.pcolormesh(X, Z_plot, **plot_kws)
# Set the ylim to match the data
ax.set_ylim([Y.min(), Y.max()])
# Set the axis to be log in the y-axis
if logy:
ax.semilogy()
ax.yaxis.set_major_formatter(ScalarFormatter())
ax.set_ylabel("$D_p \; [nm]$")
if cbar:
# Set the figure keywords
cbar_kws = dict(dict(label='$dN/dlogD_p \; [cm^{-3}]$'), **cbar_kws)
clb = plt.colorbar(im, **cbar_kws)
return ax
def plot_jet_image(
ax, image, vmin=1e-9, vmax=1e-2, cmap="jet", title="Intensity",
label_axes=True, visible_axes=False, show_colorbar=True, colorbar_inside=False):
"""display jet image.
Args:
ax: matplotlib axes to plot on.
image: array representing image to plot.
vmin,vmax: min,max intensity values to plot.
"""
width, height = image.T.shape
dw, dh = 1./width, 1./height
if not (vmin is None) and not (vmax is None):
if vmin < 0:
norm = MidPointnorm(vmin=vmin, vmax=vmax)
ticks = None
else:
norm = Lognorm(vmin=vmin, vmax=vmax)
ticks = np.logspace(
np.log10(vmin), np.log10(vmax),
1 + np.log10(vmax) - np.log10(vmin))
else:
norm = None
ticks = None
p = ax.imshow(
image.T, extent=(-(1+dw), 1+dw, -(1+dh), 1+dh), origin='low',
interpolation='nearest', norm=norm, cmap=cmap)
if show_colorbar:
if colorbar_inside:
cax = ax.figure.add_axes([0.85, 0.08, 0.03, 0.82])
else:
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
cbar = plt.colorbar(p, cax=cax, ticks=ticks)
cbar.set_label(title, rotation=90, fontsize=18)
cbar.ax.tick_params(labelsize=12)
if colorbar_inside:
cbar.ax.yaxis.set_ticks_position('left')
if label_axes:
ax.set_xlabel(r'$x_1$', fontsize=18)
ax.set_ylabel(r'$x_2$', fontsize=18)
ax.tick_params(axis='both', which='major', labelsize=12)
else:
ax.axes.get_xaxis().set_ticks([])
ax.axes.get_yaxis().set_ticks([])
ax.axes.get_xaxis().set_visible(visible_axes)
ax.axes.get_yaxis().set_visible(visible_axes)
if visible_axes:
for spine in ['top', 'bottom', 'left', 'right']:
ax.spines[spine].set_linewidth(1)
ax.spines[spine].set_color('k')
else:
for spine in ['top', 'right']:
ax.spines[spine].set_visible(False)
ax.axes.grid(False)