def plotsidebyside(array1, array2, title1='', title2='', maintitle=''):
fig = plt.figure(figsize=(14, 5))
fig.suptitle(maintitle, fontsize=14)
vmax = np.max([array1, array2])
vmin = np.min([array1, array2])
ax1 = plt.subplot(121)
ax2 = plt.subplot(122, sharex=ax1, sharey=ax1)
im1 = ax1.imshow(array1,
cmap='RdGy',
interpolation='none',
vmin=vmin,
vmax=vmax)
ax1.set_title(title1, fontsize=22)
ax1.set_adjustable('box')
fig.colorbar(im1, ax=ax1, shrink=.8, aspect=20)
im2 = ax2.imshow(array2,
cmap='RdGy',
interpolation='none',
vmin=vmin,
vmax=vmax)
ax2.set_title(title2, fontsize=22)
ax2.set_adjustable('box')
fig.colorbar(im2, ax=ax2, shrink=.8, aspect=20)
if saveFigFlag: wpu.save_figs_with_idx(foutname)
def mySimplePlot(array, title=''):
plt.figure()
plt.imshow(array, cmap='Spectral', interpolation='none')
plt.title(title)
plt.colorbar()
if saveFigFlag: wpu.save_figs_with_idx(foutname)
def plotsidebyside(array1, array2, title1='', title2='', maintitle=''):
fig = plt.figure(figsize=(14, 5))
fig.suptitle(maintitle, fontsize=14)
vmax = np.max([array1, array2])
vmin = np.min([array1, array2])
ax1 = plt.subplot(121)
ax2 = plt.subplot(122, sharex=ax1, sharey=ax1)
im1 = ax1.imshow(array1, cmap='RdGy',
interpolation='none',
vmin=vmin, vmax=vmax)
ax1.set_title(title1, fontsize=22)
ax1.set_adjustable('box-forced')
fig.colorbar(im1, ax=ax1, shrink=.8, aspect=20)
im2 = ax2.imshow(array2, cmap='RdGy',
interpolation='none',
vmin=vmin, vmax=vmax)
ax2.set_title(title2, fontsize=22)
ax2.set_adjustable('box-forced')
fig.colorbar(im2, ax=ax2, shrink=.8, aspect=20)
if saveFigFlag: wpu.save_figs_with_idx(foutname)
plt.show(block=True)
def mySimplePlot(array, title=''):
plt.figure()
plt.imshow(array, cmap='spectral', interpolation='none')
plt.title(title)
plt.colorbar()
if saveFigFlag: wpu.save_figs_with_idx(foutname)
plt.show(block=True)
def fit_peaks_talbot2gauss(zvec, contrast, wavelength,
patternPeriod, sourceDist,
cohLength,
fname4graphs, title4graph='Title'):
def _func_4_fit(z, Amp, Amp2, sigma1, sigma2):
return Amp*np.exp(-z**2/2/sigma1**2) + Amp2*np.exp(-z**2/2/sigma2**2)
cohL_o = cohLength/wavelength*patternPeriod
p0 = [1.0, .5, cohL_o, cohL_o*.15]
bounds = ([.01, .01, cohL_o*0.5, cohL_o*0.01],
[2.0, 2.0, cohL_o*1.5, cohL_o*1.0])
popt, pcov = curve_fit(_func_4_fit, zvec, contrast, p0=p0,
bounds=bounds)
print("Fit 1D")
print("Amp, z_period, sigma, phase")
print(popt)
cohLength1 = np.abs(popt[2])*wavelength/patternPeriod
cohLength2 = np.abs(popt[3])*wavelength/patternPeriod
print('Coherent length: {:.4g} um'.format(cohLength1*1e6))
print('Coherent length: {:.4g} um'.format(cohLength2*1e6))
plt.figure(figsize=(12, 9))
plt.plot(zvec*1e3, 100*contrast, 'ok', ms=7, label='data')
fitted_values = _func_4_fit(zvec, popt[0], popt[1],
popt[2], popt[3])
chi2 = _chi2(contrast, fitted_values)
wpu.print_blue('chi2 Fit = {:.3f}'.format(chi2))
zvec_4_fit = np.linspace(zvec[0], zvec[-1], zvec.size*5)
plt.plot(zvec_4_fit*1e3,
100*_func_4_fit(zvec_4_fit, popt[0], popt[1], popt[2], popt[3]),
'-r', lw=3, label='Fit')
max_cont, min_cont, mean_cont = max_min_mean_4plot(zvec, contrast)
plt.plot(np.unique(zvec)*1e3, 100*max_cont, '--c', lw=2, label='Max')
plt.plot(np.unique(zvec)*1e3, 100*min_cont, '--c', lw=2, label='Min')
plt.plot(np.unique(zvec)*1e3, 100*mean_cont, '--m', lw=2, label='Mean')
title4graph += r', $l_{coh}$ =' + ' {:.3f} um'.format(cohLength1*1e6)
title4graph += r', $l_{coh}$ =' + ' {:.3f} um'.format(cohLength2*1e6)
title4graph += r', $\chi^2$ = {:.3f}'.format(chi2)
plt.xlabel('Distance [mm]', fontsize=27)
plt.ylabel(r'Visibility $\times$ 100 [%]', fontsize=27)
plt.title(title4graph, fontsize=27, weight='bold')
plt.legend(fontsize=22)
plt.grid()
wpu.save_figs_with_idx(fname4graphs)
plt.show(block=True)
return cohLength1, cohLength2, popt # zperiod
def slope_error_hist(thickness_cropped,
fitted,
pixelSize,
delta=1,
sourcedistance=1.0,
saveFigFlag=True,
str4title=''):
errorThickness = thickness_cropped - fitted
plt.figure(figsize=(15, 8))
plt.subplot(121)
slope_error_h = np.diff(errorThickness, axis=0) / pixelSize[0] * delta
argNotNAN = np.isfinite(slope_error_h)
factor_seh, unit_seh = wpu.choose_unit(slope_error_h[argNotNAN])
sigma_seh = np.std(slope_error_h[argNotNAN].flatten())
plt.hist(slope_error_h[argNotNAN].flatten() * factor_seh,
100,
histtype='stepfilled')
plt.xlabel(r'Slope Error [$ ' + unit_seh + ' rad$ ]')
plt.title('Horizontal, SDV = ' + '{:.2f}'.format(sigma_seh * factor_seh) +
' $' + unit_seh + ' rad$')
plt.subplot(122)
slope_error_v = np.diff(errorThickness, axis=1) / pixelSize[1] * delta
argNotNAN = np.isfinite(slope_error_v)
factor_sev, unit_sev = wpu.choose_unit(slope_error_v[argNotNAN])
sigma_sev = np.std(slope_error_v[argNotNAN].flatten())
plt.hist(slope_error_v[argNotNAN].flatten() * factor_sev,
100,
histtype='stepfilled')
plt.xlabel(r'Slope Error [$ ' + unit_sev + ' rad$ ]')
plt.title('Vertical, SDV = ' + '{:.2f}'.format(sigma_sev * factor_sev) +
' $' + unit_sev + ' rad$')
if delta != 1:
str4title += ' WF slope error'
else:
str4title += ' Thickness slope error'
plt.suptitle(str4title, fontsize=18, weight='bold')
if saveFigFlag:
wpu.save_figs_with_idx(fname2save, extension='png')
wpu.log_this('Slope Error Hor SDV = ' +
'{:.3f}'.format(sigma_seh * factor_seh) + unit_seh + ' rad')
wpu.log_this('Slope Error Ver SDV = ' +
'{:.3f}'.format(sigma_sev * factor_sev) + unit_sev + ' rad')
plt.show(block=True)
return sigma_seh, sigma_sev
def plot_DPC(dpc01,
dpc10,
pixelsize,
titleStr='',
saveFigFlag=False,
saveFileSuf='graph'):
'''
TODO: Write Docstring
Plot differencial phase signal
'''
if titleStr is not '':
titleStr = ', ' + titleStr
factor, unit_xy = wpu.choose_unit(np.sqrt(dpc01.size) * pixelsize[0])
dpc01_plot = dpc01 * pixelsize[1] / np.pi
dpc10_plot = dpc10 * pixelsize[0] / np.pi
vlim01 = np.max((np.abs(wpu.mean_plus_n_sigma(dpc01_plot, -5)),
np.abs(wpu.mean_plus_n_sigma(dpc01_plot, 5))))
vlim10 = np.max((np.abs(wpu.mean_plus_n_sigma(dpc10_plot, -5)),
np.abs(wpu.mean_plus_n_sigma(dpc10_plot, 5))))
plt.figure(figsize=(12, 6))
plt.subplot(121)
plt.imshow(dpc01_plot,
cmap='RdGy_r',
vmin=-vlim01,
vmax=vlim01,
extent=wpu.extent_func(dpc01_plot, pixelsize) * factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('DPC - Horizontal', fontsize=18, weight='bold') # 01
plt.subplot(122)
plt.imshow(dpc10_plot,
cmap='RdGy_r',
vmin=-vlim10,
vmax=vlim10,
extent=wpu.extent_func(dpc10_plot, pixelsize) * factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('DPC - Vertical', fontsize=18, weight='bold')
plt.suptitle('Differential Phase ' + r'[$\pi$ rad]' + titleStr,
fontsize=18,
weight='bold')
plt.tight_layout(rect=[0, 0, 1, 1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf)
plt.show(block=False)
def dpc_integration(dpc01,
dpc10,
pixelsize,
idx4crop=[0, -1, 0, -1],
plotErrorIntegration=False,
saveFileSuf=None,
shifthalfpixel=False,
method='FC'):
'''
TODO: Write Docstring
Integration of DPC to obtain phase. Currently only supports
Frankot Chellappa
'''
if idx4crop == '':
vmin = wpu.mean_plus_n_sigma(dpc01**2 + dpc10**2, -3)
vmax = wpu.mean_plus_n_sigma(dpc01**2 + dpc10**2, 3)
_, idx = wpu.crop_graphic_image(dpc01**2 + dpc10**2,
kargs4graph={
'cmap': 'viridis',
'vmin': vmin,
'vmax': vmax
})
else:
idx = idx4crop
dpc01 = wpu.crop_matrix_at_indexes(dpc01, idx)
dpc10 = wpu.crop_matrix_at_indexes(dpc10, idx)
if method == 'FC':
phase = wps.frankotchellappa(dpc01 * pixelsize[1],
dpc10 * pixelsize[0],
reflec_pad=True)
phase = np.real(phase)
else:
wpu.print_red('ERROR: Unknown integration method: ' + method)
if plotErrorIntegration:
wps.error_integration(dpc01 * pixelsize[1],
dpc10 * pixelsize[0],
phase,
pixelsize,
errors=False,
shifthalfpixel=shifthalfpixel,
plot_flag=True)
if saveFileSuf is not None:
wpu.save_figs_with_idx(saveFileSuf)
return phase
def plot_intensities_harms(int00,
int01,
int10,
pixelsize,
titleStr,
saveFigFlag=False,
saveFileSuf='graph'):
# Plot Real image (intensity)
if titleStr is not '':
titleStr = ', ' + titleStr
factor, unit_xy = wpu.choose_unit(np.sqrt(int00.size) * pixelsize[0])
plt.figure(figsize=(14, 6))
plt.subplot(131)
plt.imshow(int00,
cmap='viridis',
vmax=wpu.mean_plus_n_sigma(int00, 4),
extent=wpu.extent_func(int00, pixelsize) * factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('00', fontsize=18, weight='bold')
plt.subplot(132)
plt.imshow(int01,
cmap='viridis',
vmax=wpu.mean_plus_n_sigma(int01, 4),
extent=wpu.extent_func(int01, pixelsize) * factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('01', fontsize=18, weight='bold')
plt.subplot(133)
plt.imshow(int10,
cmap='viridis',
vmax=wpu.mean_plus_n_sigma(int10, 4),
extent=wpu.extent_func(int10, pixelsize) * factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('10', fontsize=18, weight='bold')
plt.suptitle('Absorption obtained from the Harmonics' + titleStr,
fontsize=18,
weight='bold')
plt.tight_layout(rect=[0, 0, 1, 1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf)
plt.show(block=False)
def fit_peaks_talbot(zvec, contrast, wavelength,
patternPeriod, sourceDist,
fname4graphs, title4graph='Title'):
def _func_4_fit(z, Amp, sigma):
return (Amp*np.exp(-z**2/2/sigma**2))
p0 = [1.0, np.sqrt(np.sum(contrast*zvec**2)/np.sum(contrastV))]
# bounds = ([1e-3, 0.1, .01, -1., .001],
# [2.0, 1.0, 100 , 1., .1])
popt, pcov = curve_fit(_func_4_fit, zvec, contrast, p0=p0)
print("Fit 1D")
print("Amp, sigma")
print(popt)
cohLength = np.abs(popt[1])*wavelength/patternPeriod
print('Coherent length: {:.4g} um'.format(cohLength*1e6))
plt.figure(figsize=(12, 9))
plt.plot(zvec*1e3, 100*contrast, 'ok', ms=7, label='data')
fitted_values = _func_4_fit(zvec, popt[0], popt[1])
chi2 = _chi2(contrast, fitted_values)
wpu.print_blue('chi2 Fit = {:.3f}'.format(chi2))
zvec_4_fit = np.linspace(zvec[0], zvec[-1], zvec.size*5)
plt.plot(zvec_4_fit*1e3,
100*_func_4_fit(zvec_4_fit, popt[0], popt[1]),
'-r', lw=3, label='Fit')
max_cont, min_cont, mean_cont = max_min_mean_4plot(zvec, contrast)
plt.plot(np.unique(zvec)*1e3, 100*max_cont, '--c', lw=2, label='Max')
plt.plot(np.unique(zvec)*1e3, 100*min_cont, '--c', lw=2, label='Min')
plt.plot(np.unique(zvec)*1e3, 100*mean_cont, '--m', lw=2, label='Mean')
title4graph += r', $l_{coh}$ =' + ' {:.3f} um'.format(cohLength*1e6)
title4graph += r', $\chi^2$ = {:.3f}'.format(chi2)
plt.xlabel('Distance [mm]', fontsize=27)
plt.ylabel(r'Visibility $\times$ 100 [%]', fontsize=27)
plt.title(title4graph, fontsize=27, weight='bold')
plt.legend(fontsize=22)
plt.grid()
wpu.save_figs_with_idx(fname4graphs)
plt.show(block=True)
return cohLength, popt # zperiod
def _load_data_from_pickle(fname):
fig = pickle.load(open(fname, 'rb'))
fig.set_size_inches((12, 9), forward=True)
wpu.save_figs_with_idx(fname4graphs)
plt.show(block=True) # this lines keep the script alive to see the plot
curves = []
for i in range(len(fig.axes[0].lines)):
curves.append(np.asarray(fig.axes[0].lines[i].get_data()))
return curves
def plot_DPC(dpc01, dpc10,
pixelsize, titleStr='',
saveFigFlag=False, saveFileSuf='graph'):
'''
TODO: Write Docstring
Plot differencial phase signal
'''
if titleStr is not '':
titleStr = ', ' + titleStr
factor, unit_xy = wpu.choose_unit(np.sqrt(dpc01.size)*pixelsize[0])
dpc01_plot = dpc01*pixelsize[1]/np.pi
dpc10_plot = dpc10*pixelsize[0]/np.pi
vlim01 = np.max((np.abs(wpu.mean_plus_n_sigma(dpc01_plot, -5)),
np.abs(wpu.mean_plus_n_sigma(dpc01_plot, 5))))
vlim10 = np.max((np.abs(wpu.mean_plus_n_sigma(dpc10_plot, -5)),
np.abs(wpu.mean_plus_n_sigma(dpc10_plot, 5))))
plt.figure(figsize=(12, 6))
plt.subplot(121)
plt.imshow(dpc01_plot, cmap='RdGy_r',
vmin=-vlim01, vmax=vlim01,
extent=wpu.extent_func(dpc01_plot, pixelsize)*factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('DPC - Horizontal', fontsize=18, weight='bold') # 01
plt.subplot(122)
plt.imshow(dpc10_plot, cmap='RdGy_r',
vmin=-vlim10, vmax=vlim10,
extent=wpu.extent_func(dpc10_plot, pixelsize)*factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('DPC - Vertical', fontsize=18,
weight='bold')
plt.suptitle('Differential Phase ' + r'[$\pi$ rad]' + titleStr,
fontsize=18, weight='bold')
plt.tight_layout(rect=[0, 0, 1, 1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf)
plt.show(block=False)
def plot_max_min_mean(zvec, contrast, fname4graphs, title4graph='Title'):
plt.figure(figsize=(12, 9))
plt.plot(zvec*1e3, 100*contrast, 'ok', ms=7, label='data')
max_cont, min_cont, mean_cont = max_min_mean_4plot(zvec, contrast)
plt.plot(np.unique(zvec)*1e3, 100*max_cont, '--c', lw=2, label='Max')
plt.plot(np.unique(zvec)*1e3, 100*min_cont, '--c', lw=2, label='Min')
plt.plot(np.unique(zvec)*1e3, 100*mean_cont, '--m', lw=2, label='Mean')
plt.xlabel('Distance [mm]', fontsize=27)
plt.ylabel(r'Visibility $\times$ 100 [%]', fontsize=27)
plt.title(title4graph, fontsize=27, weight='bold')
plt.legend(fontsize=22)
plt.grid()
wpu.save_figs_with_idx(fname4graphs)
plt.show(block=True)
def plot_dark_field(darkField01,
darkField10,
pixelsize,
titleStr='',
saveFigFlag=False,
saveFileSuf='graph'):
'''
TODO: Write Docstring
Plot Dark field
'''
if titleStr is not '':
titleStr = ', ' + titleStr
factor, unit_xy = wpu.choose_unit(np.sqrt(darkField01.size) * pixelsize[0])
plt.figure(figsize=(14, 6))
plt.subplot(121)
plt.imshow(darkField01,
cmap='viridis',
vmax=wpu.mean_plus_n_sigma(darkField01, 4),
extent=wpu.extent_func(darkField01, pixelsize) * factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('Horizontal', fontsize=18, weight='bold') # 01
plt.subplot(122)
plt.imshow(darkField10,
cmap='viridis',
vmax=wpu.mean_plus_n_sigma(darkField01, 4),
extent=wpu.extent_func(darkField10, pixelsize) * factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('Vertical', fontsize=18, weight='bold') # 10
plt.suptitle('Dark Field', fontsize=18, weight='bold')
plt.tight_layout(rect=[0, 0, 1, 1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf)
plt.show(block=False)
def plot_intensities_harms(int00, int01, int10,
pixelsize, titleStr,
saveFigFlag=False, saveFileSuf='graph'):
# Plot Real image (intensity)
if titleStr is not '':
titleStr = ', ' + titleStr
factor, unit_xy = wpu.choose_unit(np.sqrt(int00.size)*pixelsize[0])
plt.figure(figsize=(14, 6))
plt.subplot(131)
plt.imshow(int00, cmap='viridis',
vmax=wpu.mean_plus_n_sigma(int00, 4),
extent=wpu.extent_func(int00, pixelsize)*factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('00', fontsize=18, weight='bold')
plt.subplot(132)
plt.imshow(int01, cmap='viridis',
vmax=wpu.mean_plus_n_sigma(int01, 4),
extent=wpu.extent_func(int01, pixelsize)*factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('01', fontsize=18, weight='bold')
plt.subplot(133)
plt.imshow(int10, cmap='viridis',
vmax=wpu.mean_plus_n_sigma(int10, 4),
extent=wpu.extent_func(int10, pixelsize)*factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('10', fontsize=18, weight='bold')
plt.suptitle('Absorption obtained from the Harmonics' + titleStr,
fontsize=18, weight='bold')
plt.tight_layout(rect=[0, 0, 1, 1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf)
plt.show(block=False)
def dpc_integration(dpc01, dpc10, pixelsize, idx4crop=[0, -1, 0, -1],
plotErrorIntegration=False,
saveFileSuf=None,
shifthalfpixel=False, method='FC'):
'''
TODO: Write Docstring
Integration of DPC to obtain phase. Currently only supports
Frankot Chellappa
'''
if idx4crop == '':
vmin = wpu.mean_plus_n_sigma(dpc01**2+dpc10**2, -3)
vmax = wpu.mean_plus_n_sigma(dpc01**2+dpc10**2, 3)
_, idx = wpu.crop_graphic_image(dpc01**2+dpc10**2,
kargs4graph={'cmap': 'viridis',
'vmin': vmin,
'vmax': vmax})
else:
idx = idx4crop
dpc01 = wpu.crop_matrix_at_indexes(dpc01, idx)
dpc10 = wpu.crop_matrix_at_indexes(dpc10, idx)
if method == 'FC':
phase = wps.frankotchellappa(dpc01*pixelsize[1],
dpc10*pixelsize[0],
reflec_pad=True)
phase = np.real(phase)
else:
wpu.print_red('ERROR: Unknown integration method: ' + method)
if plotErrorIntegration:
wps.error_integration(dpc01*pixelsize[1],
dpc10*pixelsize[0],
phase, pixelsize, errors=False,
shifthalfpixel=shifthalfpixel, plot_flag=True)
if saveFileSuf is not None:
wpu.save_figs_with_idx(saveFileSuf)
return phase
def plot_dark_field(darkField01, darkField10,
pixelsize, titleStr='',
saveFigFlag=False, saveFileSuf='graph'):
'''
TODO: Write Docstring
Plot Dark field
'''
if titleStr is not '':
titleStr = ', ' + titleStr
factor, unit_xy = wpu.choose_unit(np.sqrt(darkField01.size)*pixelsize[0])
plt.figure(figsize=(14, 6))
plt.subplot(121)
plt.imshow(darkField01, cmap='viridis',
vmax=wpu.mean_plus_n_sigma(darkField01, 4),
extent=wpu.extent_func(darkField01, pixelsize)*factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('Horizontal', fontsize=18, weight='bold') # 01
plt.subplot(122)
plt.imshow(darkField10, cmap='viridis',
vmax=wpu.mean_plus_n_sigma(darkField01, 4),
extent=wpu.extent_func(darkField10, pixelsize)*factor)
plt.xlabel(r'$[{0} m]$'.format(unit_xy))
plt.ylabel(r'$[{0} m]$'.format(unit_xy))
plt.colorbar(shrink=0.5)
plt.title('Vertical', fontsize=18, weight='bold') # 10
plt.suptitle('Dark Field', fontsize=18, weight='bold')
plt.tight_layout(rect=[0, 0, 1, 1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf)
plt.show(block=False)
def fit_radius_dpc(dpx,
dpy,
pixelsize,
radius4fit,
kwave,
saveFigFlag=False,
str4title=''):
xVec = wpu.realcoordvec(dpx.shape[1], pixelsize[1])
yVec = wpu.realcoordvec(dpx.shape[0], pixelsize[0])
lim_x = np.argwhere(xVec >= -radius4fit * 1.01)[0, 0]
lim_y = np.argwhere(yVec >= -radius4fit * 1.01)[0, 0]
xmatrix, ymatrix = np.meshgrid(xVec[lim_x:-lim_x + 1],
yVec[lim_y:-lim_y + 1])
fig = plt.figure(figsize=(14, 5))
fig.suptitle(str4title + 'Phase [rad]', fontsize=14)
ax1 = plt.subplot(121)
ax2 = plt.subplot(122, sharex=ax1, sharey=ax1)
ax1.plot(xVec[lim_x:-lim_x + 1] * 1e6,
dpx[dpx.shape[1] // 4, lim_x:-lim_x + 1],
'-ob',
label='1/4')
ax1.plot(xVec[lim_x:-lim_x + 1] * 1e6,
dpx[dpx.shape[1] // 2, lim_x:-lim_x + 1],
'-or',
label='1/2')
ax1.plot(xVec[lim_x:-lim_x + 1] * 1e6,
dpx[dpx.shape[1] // 4 * 3, lim_x:-lim_x + 1],
'-og',
label='3/4')
lin_fitx = np.polyfit(xVec[lim_x:-lim_x + 1], dpx[dpx.shape[1] // 2,
lim_x:-lim_x + 1], 1)
lin_funcx = np.poly1d(lin_fitx)
ax1.plot(xVec[lim_x:-lim_x + 1] * 1e6,
lin_funcx(xVec[lim_x:-lim_x + 1]),
'--c',
lw=2,
label='Fit 1/2')
curvrad_x = kwave / (lin_fitx[0])
wpu.print_blue('lin_fitx[0] x: {:.3g} m'.format(lin_fitx[0]))
wpu.print_blue('lin_fitx[1] x: {:.3g} m'.format(lin_fitx[1]))
wpu.print_blue('Curvature Radius of WF x: {:.3g} m'.format(curvrad_x))
ax1.ticklabel_format(style='sci', axis='y', scilimits=(0, 1))
ax1.set_xlabel(r'[$\mu m$]')
ax1.set_ylabel('dpx [radians]')
ax1.legend(loc=0, fontsize='small')
ax1.set_title('Curvature Radius of WF {:.3g} m'.format(curvrad_x),
fontsize=16)
ax1.set_adjustable('box-forced')
ax2.plot(yVec[lim_y:-lim_y + 1] * 1e6,
dpy[lim_y:-lim_y + 1, dpy.shape[0] // 4],
'-ob',
label='1/4')
ax2.plot(yVec[lim_y:-lim_y + 1] * 1e6,
dpy[lim_y:-lim_y + 1, dpy.shape[0] // 2],
'-or',
label='1/2')
ax2.plot(yVec[lim_y:-lim_y + 1] * 1e6,
dpy[lim_y:-lim_y + 1, dpy.shape[0] // 4 * 3],
'-og',
label='3/4')
lin_fity = np.polyfit(yVec[lim_y:-lim_y + 1], dpy[lim_y:-lim_y + 1,
dpy.shape[0] // 2], 1)
lin_funcy = np.poly1d(lin_fity)
ax2.plot(yVec[lim_y:-lim_y + 1] * 1e6,
lin_funcy(yVec[lim_y:-lim_y + 1]),
'--c',
lw=2,
label='Fit 1/2')
curvrad_y = kwave / (lin_fity[0])
wpu.print_blue('Curvature Radius of WF y: {:.3g} m'.format(curvrad_y))
ax2.ticklabel_format(style='sci', axis='y', scilimits=(0, 1))
ax2.set_xlabel(r'[$\mu m$]')
ax2.set_ylabel('dpy [radians]')
ax2.legend(loc=0, fontsize='small')
ax2.set_title('Curvature Radius of WF {:.3g} m'.format(curvrad_y),
fontsize=16)
ax2.set_adjustable('box-forced')
if saveFigFlag:
wpu.save_figs_with_idx(fname2save, extension='png')
plt.show(block=False)
def plot_residual_1d(xvec,
data,
fitted,
str4title='',
saveFigFlag=False,
saveAsciiFlag=False):
# Plot Horizontal profile
errorThickness = -data + fitted
argNotNAN = np.isfinite(errorThickness)
factorx, unitx = wpu.choose_unit(xvec)
factory1, unity1 = wpu.choose_unit(data)
factory2, unity2 = wpu.choose_unit(errorThickness)
ptp = np.ptp(errorThickness[argNotNAN].flatten() * factory2)
wpu.print_red('PV: {0:4.3g} '.format(ptp) + unity2[-1] + 'm')
sigmaError = np.std(errorThickness[argNotNAN].flatten() * factory2)
wpu.print_red('SDV: {0:4.3g} '.format(sigmaError) + unity2[-1] + 'm')
str4title += '\n' + \
r'PV $= {0:.2f}$ '.format(ptp) + '$' + unity2 + ' m$, '\
'SDV $= {0:.2f}$ '.format(sigmaError) + '$' + unity2 + ' m$'
plt.figure(figsize=(10, 7))
ax1 = plt.gca()
ax1.plot(xvec[argNotNAN] * factorx,
data[argNotNAN] * factory1,
'-ko',
markersize=5,
label='1D data')
ax1.plot(xvec[argNotNAN] * factorx,
fitted[argNotNAN] * factory1,
'-+r',
label='Fit parabolic')
ax2 = ax1.twinx()
# trick to add both axes to legend
ax2.plot(np.nan, '-ko', label='1D data')
ax2.plot(np.nan, '-+r', label='Fit parabolic')
ax2.plot(xvec[argNotNAN] * factorx,
errorThickness[argNotNAN] * factory2,
'-+',
markersize=5,
label='fit residual')
plt.title(str4title)
for tl in ax2.get_yticklabels():
tl.set_color('b')
ax2.legend(loc=1, fontsize='small')
# trick to add both axes to legend
ax1.grid(color='gray')
ax1.set_xlabel(r'[$' + unitx + ' m$]')
ax1.set_ylabel(r'Thickness ' + r'[$' + unity1 + ' m$]')
# ax2.set_ylim([-20, 20])
ax2.set_ylim(-1.1 * np.max(np.abs(errorThickness[argNotNAN]) * factory2),
1.1 * np.max(np.abs(errorThickness[argNotNAN]) * factory2))
ax2.set_ylabel(r'Residual' + r'[$' + unity2 + ' m$]')
ax2.grid(b='off')
plt.xlim(-1.1 * np.max(xvec * factorx), 1.1 * np.max(xvec * factorx))
plt.tight_layout(rect=(0, 0, 1, .98))
if saveFigFlag:
wpu.save_figs_with_idx(fname2save, extension='png')
if saveAsciiFlag:
csv_fname = wpu.get_unique_filename(fname2save, 'csv')
np.savetxt(csv_fname,
np.transpose([xvec, data, fitted, fitted - data]),
delimiter=',\t',
header="xvec, data, fitted, residual, " + str4title,
fmt='%.6g')
plt.show(block=False)
def _n_profiles_H_V(arrayH,
arrayV,
virtual_pixelsize,
zlabel=r'z',
titleH='Horiz',
titleV='Vert',
nprofiles=5,
filter_width=0,
remove2ndOrder=False,
saveFileSuf='',
saveFigFlag=True):
xxGrid, yyGrid = wpu.grid_coord(arrayH, virtual_pixelsize)
fit_coefs = [[], []]
data2saveH = None
data2saveV = None
labels_H = None
labels_V = None
plt.rcParams['lines.markersize'] = 4
plt.rcParams['lines.linewidth'] = 2
# Horizontal
if np.all(np.isfinite(arrayH)):
plt.figure(figsize=(12, 12 * 9 / 16))
xvec = xxGrid[0, :]
data2saveH = np.c_[xvec]
header = ['x [m]']
ls_cycle, lc_jet = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=nprofiles,
cmap_str='gist_rainbow_r')
lc = []
labels_H = []
for i, row in enumerate(
np.linspace(filter_width // 2,
np.shape(arrayV)[0] - filter_width // 2 - 1,
nprofiles + 2,
dtype=int)):
if i == 0 or i == nprofiles + 1:
continue
if filter_width != 0:
yvec = arrayH[row - filter_width:row + filter_width, :]
yvec = np.sum(yvec, 0) / filter_width / 2
else:
yvec = arrayH[row, :]
lc.append(next(lc_jet))
p01 = np.polyfit(xvec, yvec, 1)
fit_coefs[0].append(p01)
if remove2ndOrder:
yvec -= p01[0] * xvec + p01[1]
plt.plot(xvec * 1e6,
yvec,
next(ls_cycle),
color=lc[i - 1],
label=str(row))
if not remove2ndOrder:
plt.plot(xvec * 1e6,
p01[0] * xvec + p01[1],
'--',
color=lc[i - 1],
lw=3)
data2saveH = np.c_[data2saveH, yvec]
header.append(str(row))
labels_H.append(str(row))
if remove2ndOrder:
titleH = titleH + ', 2nd order removed'
plt.legend(title='Pixel Y', loc=0, fontsize=12)
plt.xlabel(r'x [$\mu m$]', fontsize=18)
plt.ylabel(zlabel, fontsize=18)
plt.title(titleH + ', Filter Width = {:d} pixels'.format(filter_width),
fontsize=20)
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_H')
plt.show(block=False)
header.append(zlabel +
', Filter Width = {:d} pixels'.format(filter_width))
wpu.save_csv_file(data2saveH,
wpu.get_unique_filename(
saveFileSuf + '_WF_profiles_H', 'csv'),
headerList=header)
plt.figure(figsize=(12, 12 * 9 / 16))
plt.imshow(arrayH,
cmap='RdGy',
vmin=wpu.mean_plus_n_sigma(arrayH, -3),
vmax=wpu.mean_plus_n_sigma(arrayH, 3))
plt.xlabel('Pixel')
plt.ylabel('Pixel')
plt.title(titleH + ', Profiles Position')
currentAxis = plt.gca()
_, lc_jet = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=nprofiles,
cmap_str='gist_rainbow_r')
for i, row in enumerate(
np.linspace(filter_width // 2,
np.shape(arrayV)[0] - filter_width // 2 - 1,
nprofiles + 2,
dtype=int)):
if i == 0 or i == nprofiles + 1:
continue
currentAxis.add_patch(
Rectangle((-.5, row - filter_width // 2 - .5),
np.shape(arrayH)[1],
filter_width,
facecolor=lc[i - 1],
alpha=.5))
plt.axhline(row, color=lc[i - 1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_H')
plt.show(block=True)
# Vertical
if np.all(np.isfinite(arrayV)):
plt.figure(figsize=(12, 12 * 9 / 16))
xvec = yyGrid[:, 0]
data2saveV = np.c_[xvec]
header = ['y [m]']
ls_cycle, lc_jet = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=nprofiles,
cmap_str='gist_rainbow_r')
lc = []
labels_V = []
for i, col in enumerate(
np.linspace(filter_width // 2,
np.shape(arrayH)[1] - filter_width // 2 - 1,
nprofiles + 2,
dtype=int)):
if i == 0 or i == nprofiles + 1:
continue
if filter_width != 0:
yvec = arrayV[:, col - filter_width:col + filter_width]
yvec = np.sum(yvec, 1) / filter_width / 2
else:
yvec = arrayV[:, col]
lc.append(next(lc_jet))
p10 = np.polyfit(xvec, yvec, 1)
fit_coefs[1].append(p10)
if remove2ndOrder:
yvec -= p10[0] * xvec + p10[1]
plt.plot(xvec * 1e6,
yvec,
next(ls_cycle),
color=lc[i - 1],
label=str(col))
if not remove2ndOrder:
plt.plot(xvec * 1e6,
p10[0] * xvec + p10[1],
'--',
color=lc[i - 1],
lw=3)
data2saveV = np.c_[data2saveV, yvec]
header.append(str(col))
labels_V.append(str(col))
if remove2ndOrder:
titleV = titleV + ', 2nd order removed'
plt.legend(title='Pixel X', loc=0, fontsize=12)
plt.xlabel(r'y [$\mu m$]', fontsize=18)
plt.ylabel(zlabel, fontsize=18)
plt.title(titleV + ', Filter Width = {:d} pixels'.format(filter_width),
fontsize=20)
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_Y')
plt.show(block=False)
header.append(zlabel +
', Filter Width = {:d} pixels'.format(filter_width))
wpu.save_csv_file(data2saveV,
wpu.get_unique_filename(
saveFileSuf + '_WF_profiles_V', 'csv'),
headerList=header)
plt.figure(figsize=(12, 12 * 9 / 16))
plt.imshow(arrayV,
cmap='RdGy',
vmin=wpu.mean_plus_n_sigma(arrayV, -3),
vmax=wpu.mean_plus_n_sigma(arrayV, 3))
plt.xlabel('Pixel')
plt.ylabel('Pixel')
plt.title(titleV + ', Profiles Position')
currentAxis = plt.gca()
for i, col in enumerate(
np.linspace(filter_width // 2,
np.shape(arrayH)[1] - filter_width // 2 - 1,
nprofiles + 2,
dtype=int)):
if i == 0 or i == nprofiles + 1:
continue
currentAxis.add_patch(
Rectangle((col - filter_width // 2 - .5, -.5),
filter_width,
np.shape(arrayV)[0],
facecolor=lc[i - 1],
alpha=.5))
plt.axvline(col, color=lc[i - 1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_Y')
plt.show(block=True)
return data2saveH, data2saveV, labels_H, labels_V, fit_coefs
def curv_from_height(height,
virtual_pixelsize,
grazing_angle=0.0,
projectionFromDiv=1.0,
labels=[],
xlabel='x',
ylabel='Curvature',
titleStr='',
saveFileSuf=''):
ls_cycle, lc_cycle = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=height.shape[1] - 1,
cmap_str='gist_rainbow_r')
if grazing_angle // .00001 > 0:
projection = 1 / np.sin(grazing_angle) * projectionFromDiv
else:
projection = projectionFromDiv
projected_pixel = virtual_pixelsize * projection
xvec = wpu.realcoordvec(height.shape[0] - 2, projected_pixel)
print('projected_pixel')
print(projected_pixel)
plt.figure(figsize=(12, 12 * 9 / 16))
list_curv = [xvec]
header = [xlabel + ' [m]']
for j_line in range(1, height.shape[1]):
curv = np.diff(np.diff(height[:, j_line])) / projected_pixel**2
if j_line == 1:
factor_x, unit_x = wpu.choose_unit(xvec)
#factor_y, unit_y = wpu.choose_unit(curv)
list_curv.append(curv)
header.append(labels[j_line - 1])
plt.plot(xvec * factor_x,
curv,
next(ls_cycle),
c=next(lc_cycle),
label=labels[j_line - 1])
marginx = 0.1 * np.ptp(xvec * factor_x)
plt.xlim(
[np.min(xvec * factor_x) - marginx,
np.max(xvec * factor_x) + marginx])
plt.xlabel(xlabel + r' [$' + unit_x + ' m$]')
plt.ylabel(ylabel + r'[$m^{-1}$]')
plt.legend(loc=0, fontsize=12)
if grazing_angle // .00001 > 0:
plt.title(titleStr + 'Mirror Curvature,\n' +
'grazing angle {:.2f} mrad,\n'.format(grazing_angle * 1e3) +
'projection due divergence = ' +
r'$ \times $ {:.2f}'.format(projectionFromDiv))
else:
plt.title(titleStr + 'Curvature')
plt.tight_layout()
wpu.save_figs_with_idx(saveFileSuf)
plt.show()
data2saveV = np.asarray(list_curv).T
header.append(ylabel + ' [1/m]')
if grazing_angle // .00001 > 0:
header.append(', grazing_angle = {:.4g}'.format(grazing_angle))
if projectionFromDiv // 1 != 1:
header.append('projection due divergence = ' +
'{:.2f}x'.format(projectionFromDiv))
wpu.save_csv_file(data2saveV,
wpu.get_unique_filename(saveFileSuf + '_curv_' + xlabel,
'csv'),
headerList=header)
return np.asarray(list_curv).T
def main_single_gr_Talbot(img, imgRef,
phenergy, pixelsize, distDet2sample,
period_harm, saveFileSuf,
unwrapFlag=True,
plotFlag=True,
saveFigFlag=False):
global inifname # name of .ini file
[period_harm_Vert, period_harm_Hor] = period_harm
# img, imgRef = wpu.align_two_images(img, imgRef)
# Crop
img_size_o = np.shape(img)
# take index from ini file
idx4crop = list(map(int, (wpu.get_from_ini_file(inifname, 'Parameters',
'Crop').split(','))))
# Plot Real Image wiht default crop
tmpImage = wpu.crop_matrix_at_indexes(img, idx4crop)
plt.figure()
plt.imshow(tmpImage,
cmap='viridis',
extent=wpu.extent_func(tmpImage, pixelsize)*1e6)
plt.xlabel(r'$[\mu m]$')
plt.ylabel(r'$[\mu m]$')
plt.colorbar()
plt.title('Raw Image with initial Crop', fontsize=18, weight='bold')
plt.pause(.1)
# ask if the crop need to be changed
newCrop = easyqt.get_yes_or_no('New Crop?')
if saveFigFlag and not newCrop:
wpu.save_figs_with_idx(saveFileSuf + '_Talbot_image')
plt.close(plt.gcf())
if newCrop:
[colorlimit,
cmap] = wpu.plot_slide_colorbar(img,
title='SELECT COLOR SCALE,\n' +
'Raw Image, No Crop',
xlabel=r'x [$\mu m$ ]',
ylabel=r'y [$\mu m$ ]',
extent=wpu.extent_func(img,
pixelsize)*1e6)
idx4crop = wpu.graphical_roi_idx(img, verbose=True,
kargs4graph={'cmap': cmap,
'vmin': colorlimit[0],
'vmax': colorlimit[1]})
wpu.set_at_ini_file(inifname, 'Parameters', 'Crop',
'{}, {}, {}, {}'.format(idx4crop[0], idx4crop[1],
idx4crop[2], idx4crop[3]))
img = wpu.crop_matrix_at_indexes(img, idx4crop)
# Plot Real Image AFTER crop
plt.imshow(img, cmap='viridis',
extent=wpu.extent_func(img, pixelsize)*1e6)
plt.xlabel(r'$[\mu m]$')
plt.ylabel(r'$[\mu m]$')
plt.colorbar()
plt.title('Raw Image with New Crop', fontsize=18, weight='bold')
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_Talbot_image')
plt.show(block=True)
else:
img = tmpImage
imgRef = wpu.crop_matrix_at_indexes(imgRef, idx4crop)
# calculate harmonic position after crop
period_harm_Vert = int(period_harm_Vert*(idx4crop[1] - idx4crop[0]) /
img_size_o[0])
period_harm_Hor = int(period_harm_Hor*(idx4crop[3] - idx4crop[2]) /
img_size_o[1])
# Obtain harmonic periods from images
(period_harm_Vert,
_) = wgi.exp_harm_period(img, [period_harm_Vert,
period_harm_Hor],
harmonic_ij=['1', '0'],
searchRegion=20,
isFFT=False, verbose=True)
(_,
period_harm_Horz) = wgi.exp_harm_period(img, [period_harm_Vert,
period_harm_Hor],
harmonic_ij=['0', '1'],
searchRegion=20,
isFFT=False, verbose=True)
# Calculate everything
harmPeriod = [period_harm_Vert, period_harm_Hor]
[int00, int01, int10,
darkField01, darkField10,
phaseFFT_01,
phaseFFT_10] = wgi.single_2Dgrating_analyses(img, imgRef,
harmonicPeriod=harmPeriod,
plotFlag=plotFlag,
unwrapFlag=unwrapFlag,
verbose=True)
virtual_pixelsize = [0, 0]
virtual_pixelsize[0] = pixelsize[0]*img.shape[0]/int00.shape[0]
virtual_pixelsize[1] = pixelsize[1]*img.shape[1]/int00.shape[1]
diffPhase01 = phaseFFT_01*virtual_pixelsize[1]/distDet2sample/hc*phenergy
diffPhase10 = phaseFFT_10*virtual_pixelsize[0]/distDet2sample/hc*phenergy
return [int00, int01, int10,
darkField01, darkField10,
diffPhase01, diffPhase10,
virtual_pixelsize]
def _coh_func_fit_bessel(coh_function, coh_func_coord,
wavelength, sourceDistance,
title4graph='Title', saveGraphs=False):
'''
TO BE FINISHED!!!!
'''
coh_function *= 1/np.max(coh_function)
plt.figure(figsize=(12, 9))
plt.plot(coh_func_coord*1e6, coh_function, '-og', lw=3,
label='DOC function - experimental envelop')
plt.xlabel(title4graph + r' Position [$\mu m$]', fontsize=27)
plt.ylabel('Coh Function', fontsize=27)
plt.title(title4graph + ' Coh Function', fontsize=27, weight='bold')
from scipy.ndimage.filters import gaussian_filter
zeros_arg = argrelmin(gaussian_filter(coh_function, 5), order=10)
print('zeros')
print(coh_func_coord[zeros_arg]*1e6)
zero1 = np.min(np.abs(coh_func_coord[zeros_arg]))
plt.plot(coh_func_coord[zeros_arg]*1e6,
coh_function[zeros_arg], 'sr',
label='Minima')
from scipy.special import j0
def _func4fitCoh(x, p0, p1, p2):
sigma = p2/2.35
return p0 * np.abs(j0(x * p1)) * np.exp(-x**2/2/sigma**2)
p0 = [10.000, 2.40482556/zero1, 50e-6]
arg4fit = np.where(np.abs(coh_func_coord) > 1e-6)
popt, pcov = curve_fit(_func4fitCoh,
coh_func_coord[arg4fit],
coh_function[arg4fit], p0=p0)
yamp = wavelength*sourceDistance*popt[1]/2/np.pi
beam_size = wavelength*sourceDistance/popt[2]
print("Fit bessel")
print("Amp, y_o, FWHM beam")
print('{:.3f} {:.3f}um {:.3f}um'.format(popt[0], yamp*1e6, beam_size*1e6))
fitted_func = _func4fitCoh(coh_func_coord, popt[0], popt[1], popt[2])
gauss_envelope = _func4fitCoh(coh_func_coord, popt[0], 0, popt[2])
plt.plot(coh_func_coord*1e6, fitted_func, '--m',
lw=3, label='Fitted Function')
plt.plot(coh_func_coord*1e6, gauss_envelope, '--c',
lw=3, label='Gaussian Envelop')
plt.title(title4graph +
r' Fit, $y_o$:{:.1f}um,'.format(yamp*1e6) +
r' $\Delta_{source}$' + ':{:.1f}um'.format(popt[2]*1e6),
fontsize=27, weight='bold')
plt.legend(loc=1, fontsize=14)
plt.grid()
if saveGraphs:
wpu.save_figs_with_idx(fname4graphs)
plt.show(block=True)
return coh_func_coord, fitted_func
min_cV[n] = np.min(contrastV[n * nimages:(n + 1) * nimages])
min_cH[n] = np.min(contrastH[n * nimages:(n + 1) * nimages])
# %%
mean_cV /= np.max(mean_cV)
mean_cH /= np.max(mean_cH)
# %%
plt.figure(figsize=(12, 9))
plt.plot(new_zvec, mean_cV, '-ko', lw=2)
plt.plot(new_zvec, mean_cH, '-rs', lw=2)
plt.plot(new_zvec, max_cV, '--k', lw=2)
plt.plot(new_zvec, max_cH, '--r', lw=2)
plt.plot(new_zvec, min_cV, '--k', lw=2)
plt.plot(new_zvec, min_cH, '--r', lw=2)
plt.plot(zvec, contrastV, 'ok')
plt.plot(zvec, contrastH, 'sr')
plt.xlabel(r'z distance [mm]')
plt.title(fname.rsplit('.')[0].rsplit('/')[-1])
wpu.save_figs_with_idx(fname.rsplit('.')[0].rsplit('/')[-1])
plt.show()
def _n_profiles_H_V(arrayH, arrayV, virtual_pixelsize,
zlabel=r'z',
titleH='Horiz', titleV='Vert',
nprofiles=5, filter_width=0,
remove1stOrderDPC=False,
saveFileSuf='',
saveFigFlag=True):
xxGrid, yyGrid = wpu.grid_coord(arrayH, virtual_pixelsize)
fit_coefs = [[], []]
data2saveH = None
data2saveV = None
labels_H = None
labels_V = None
plt.rcParams['lines.markersize'] = 4
plt.rcParams['lines.linewidth'] = 2
# Horizontal
if np.all(np.isfinite(arrayH)):
plt.figure(figsize=(12, 12*9/16))
xvec = xxGrid[0, :]
data2saveH = np.c_[xvec]
header = ['x [m]']
if filter_width != 0:
arrayH_filtered = uniform_filter1d(arrayH, filter_width, 0)
else:
arrayH_filtered = arrayH
ls_cycle, lc_jet = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=nprofiles,
cmap_str='gist_rainbow_r')
lc = []
labels_H = []
for i, row in enumerate(np.linspace(filter_width//2,
np.shape(arrayV)[0]-filter_width//2-1,
nprofiles + 2, dtype=int)):
if i == 0 or i == nprofiles + 1:
continue
yvec = arrayH_filtered[row, :]
lc.append(next(lc_jet))
p01 = np.polyfit(xvec, yvec, 1)
fit_coefs[0].append(p01)
if remove1stOrderDPC:
yvec -= p01[0]*xvec + p01[1]
plt.plot(xvec*1e6, yvec, next(ls_cycle), color=lc[i-1],
label=str(row))
if not remove1stOrderDPC:
plt.plot(xvec*1e6, p01[0]*xvec + p01[1], '--',
color=lc[i-1], lw=3)
data2saveH = np.c_[data2saveH, yvec]
header.append(str(row))
labels_H.append(str(row))
if remove1stOrderDPC:
titleH = titleH + ', 2nd order removed'
plt.legend(title='Pixel Y', loc=0, fontsize=12)
plt.xlabel(r'x [$\mu m$]', fontsize=18)
plt.ylabel(zlabel, fontsize=18)
plt.title(titleH + ', Filter Width = {:d} pixels'.format(filter_width),
fontsize=20)
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_H')
plt.show(block=False)
header.append(zlabel + ', Filter Width = {:d} pixels'.format(filter_width))
wpu.save_csv_file(data2saveH,
wpu.get_unique_filename(saveFileSuf +
'_WF_profiles_H', 'csv'),
headerList=header)
plt.figure(figsize=(12, 12*9/16))
plt.imshow(arrayH, cmap='RdGy',
vmin=wpu.mean_plus_n_sigma(arrayH, -3),
vmax=wpu.mean_plus_n_sigma(arrayH, 3))
plt.xlabel('Pixel')
plt.ylabel('Pixel')
plt.title(titleH + ', Profiles Position')
currentAxis = plt.gca()
_, lc_jet = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=nprofiles,
cmap_str='gist_rainbow_r')
for i, row in enumerate(np.linspace(filter_width//2,
np.shape(arrayV)[0]-filter_width//2-1,
nprofiles + 2, dtype=int)):
if i == 0 or i == nprofiles + 1:
continue
currentAxis.add_patch(Rectangle((-.5, row - filter_width//2 - .5),
np.shape(arrayH)[1], filter_width,
facecolor=lc[i-1], alpha=.5))
plt.axhline(row, color=lc[i-1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_H')
plt.show(block=True)
# Vertical
if np.all(np.isfinite(arrayV)):
plt.figure(figsize=(12, 12*9/16))
xvec = yyGrid[:, 0]
data2saveV = np.c_[xvec]
header = ['y [m]']
if filter_width != 0:
arrayV_filtered = uniform_filter1d(arrayV, filter_width, 1)
else:
arrayV_filtered = arrayV
ls_cycle, lc_jet = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=nprofiles,
cmap_str='gist_rainbow_r')
lc = []
labels_V = []
for i, col in enumerate(np.linspace(filter_width//2,
np.shape(arrayH)[1]-filter_width//2-1,
nprofiles + 2, dtype=int)):
if i == 0 or i == nprofiles + 1:
continue
yvec = arrayV_filtered[:, col]
lc.append(next(lc_jet))
p10 = np.polyfit(xvec, yvec, 1)
fit_coefs[1].append(p10)
if remove1stOrderDPC:
yvec -= p10[0]*xvec + p10[1]
plt.plot(xvec*1e6, yvec, next(ls_cycle), color=lc[i-1],
label=str(col))
if not remove1stOrderDPC:
plt.plot(xvec*1e6, p10[0]*xvec + p10[1], '--',
color=lc[i-1], lw=3)
data2saveV = np.c_[data2saveV, yvec]
header.append(str(col))
labels_V.append(str(col))
if remove1stOrderDPC:
titleV = titleV + ', 2nd order removed'
plt.legend(title='Pixel X', loc=0, fontsize=12)
plt.xlabel(r'y [$\mu m$]', fontsize=18)
plt.ylabel(zlabel, fontsize=18)
plt.title(titleV + ', Filter Width = {:d} pixels'.format(filter_width),
fontsize=20)
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_Y')
plt.show(block=False)
header.append(zlabel + ', Filter Width = {:d} pixels'.format(filter_width))
wpu.save_csv_file(data2saveV,
wpu.get_unique_filename(saveFileSuf +
'_WF_profiles_V', 'csv'),
headerList=header)
plt.figure(figsize=(12, 12*9/16))
plt.imshow(arrayV, cmap='RdGy',
vmin=wpu.mean_plus_n_sigma(arrayV, -3),
vmax=wpu.mean_plus_n_sigma(arrayV, 3))
plt.xlabel('Pixel')
plt.ylabel('Pixel')
plt.title(titleV + ', Profiles Position')
currentAxis = plt.gca()
for i, col in enumerate(np.linspace(filter_width//2,
np.shape(arrayH)[1]-filter_width//2-1,
nprofiles + 2, dtype=int)):
if i == 0 or i == nprofiles + 1:
continue
currentAxis.add_patch(Rectangle((col - filter_width//2 - .5, -.5),
filter_width, np.shape(arrayV)[0],
facecolor=lc[i-1], alpha=.5))
plt.axvline(col, color=lc[i-1])
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf + '_Y')
plt.show(block=True)
return data2saveH, data2saveV, labels_H, labels_V, fit_coefs
def curv_from_height(height, virtual_pixelsize,
grazing_angle=0.0, projectionFromDiv=1.0,
labels=[],
xlabel='x', ylabel='Curvature',
titleStr='', saveFileSuf=''):
ls_cycle, lc_cycle = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=height.shape[1] - 1,
cmap_str='gist_rainbow_r')
if grazing_angle//.00001 > 0:
projection = 1/np.sin(grazing_angle)*projectionFromDiv
else:
projection = projectionFromDiv
projected_pixel = virtual_pixelsize*projection
xvec = wpu.realcoordvec(height.shape[0]-2, projected_pixel)
print('projected_pixel')
print(projected_pixel)
plt.figure(figsize=(12, 12*9/16))
list_curv = [xvec]
header = [xlabel + ' [m]']
for j_line in range(1, height.shape[1]):
curv = np.diff(np.diff(height[:, j_line]))/projected_pixel**2
if j_line == 1:
factor_x, unit_x = wpu.choose_unit(xvec)
#factor_y, unit_y = wpu.choose_unit(curv)
list_curv.append(curv)
header.append(labels[j_line - 1])
plt.plot(xvec*factor_x, curv,
next(ls_cycle), c=next(lc_cycle),
label=labels[j_line - 1])
marginx = 0.1*np.ptp(xvec*factor_x)
plt.xlim([np.min(xvec*factor_x)-marginx,
np.max(xvec*factor_x)+marginx])
plt.xlabel(xlabel + r' [$' + unit_x + ' m$]')
plt.ylabel(ylabel + r'[$m^{-1}$]')
plt.legend(loc=0, fontsize=12)
if grazing_angle//.00001 > 0:
plt.title(titleStr + 'Mirror Curvature,\n' +
'grazing angle {:.2f} mrad,\n'.format(grazing_angle*1e3) +
'projection due divergence = ' +
r'$ \times $ {:.2f}'.format(projectionFromDiv))
else:
plt.title(titleStr + 'Curvature')
plt.tight_layout()
wpu.save_figs_with_idx(saveFileSuf)
plt.show()
data2saveV = np.asarray(list_curv).T
header.append(ylabel + ' [1/m]')
if grazing_angle//.00001 > 0:
header.append(', grazing_angle = {:.4g}'.format(grazing_angle))
if projectionFromDiv//1 != 1:
header.append('projection due divergence = ' +
'{:.2f}x'.format(projectionFromDiv))
wpu.save_csv_file(data2saveV,
wpu.get_unique_filename(saveFileSuf +
'_curv_' + xlabel, 'csv'),
headerList=header)
return np.asarray(list_curv).T
def plot_integration(integrated, pixelsize,
titleStr='Title', ctitle=' ',
max3d_grid_points=101,
plotProfile=True,
plot3dFlag=True,
saveFigFlag=False,
saveFileSuf='graph',
**kwarg4surf):
'''
TODO: Write Docstring
'''
xxGrid, yyGrid = wpu.grid_coord(integrated, pixelsize)
factor_x, unit_x = wpu.choose_unit(xxGrid)
factor_y, unit_y = wpu.choose_unit(yyGrid)
# Plot Integration 2
if plot3dFlag:
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
rstride = integrated.shape[0] // max3d_grid_points + 1
cstride = integrated.shape[1] // max3d_grid_points + 1
surf = ax.plot_surface(xxGrid*factor_x, yyGrid*factor_y,
integrated[::-1, :],
rstride=rstride,
cstride=cstride,
cmap='viridis', linewidth=0.1, **kwarg4surf)
ax_lim = np.max([np.abs(xxGrid*factor_x), np.abs(yyGrid*factor_y)])
ax.set_xlim3d(-ax_lim, ax_lim)
ax.set_ylim3d(-ax_lim, ax_lim)
if 'vmin' in kwarg4surf:
ax.set_zlim3d(bottom=kwarg4surf['vmin'])
if 'vmax' in kwarg4surf:
ax.set_zlim3d(top=kwarg4surf['vmax'])
plt.xlabel(r'$x [' + unit_x + ' m]$', fontsize=24)
plt.ylabel(r'$y [' + unit_y + ' m]$', fontsize=24)
plt.title(titleStr, fontsize=24, weight='bold')
cbar = plt.colorbar(surf, shrink=.8, aspect=20)
cbar.ax.set_title(ctitle, y=1.01)
plt.tight_layout(rect=[0, 0, 1, 1])
ax.text2D(0.05, 0.9, 'strides = {}, {}'.format(rstride, cstride),
transform=ax.transAxes)
if saveFigFlag:
ax.view_init(elev=30, azim=60)
wpu.save_figs_with_idx(saveFileSuf)
ax.view_init(elev=30, azim=-120)
wpu.save_figs_with_idx(saveFileSuf)
plt.pause(.5)
plt.show(block=False)
if plotProfile:
wpu.plot_profile(xxGrid*factor_x, yyGrid*factor_y,
integrated[::-1, :],
xlabel=r'$x [' + unit_x + ' m]$',
ylabel=r'$y [' + unit_y + ' m]$',
title=titleStr,
xunit='\mu m', yunit='\mu m',
arg4main={'cmap': 'viridis', 'lw': 3})
if saveFigFlag:
plt.ioff()
plt.figure(figsize=(10, 8))
plt.imshow(integrated[::-1, :], cmap='viridis',
extent=wpu.extent_func(integrated, pixelsize)*factor_x,
**kwarg4surf)
plt.xlabel(r'$x [' + unit_x + ' m]$', fontsize=24)
plt.ylabel(r'$y [' + unit_x + ' m]$', fontsize=24)
plt.title(titleStr, fontsize=18, weight='bold')
cbar = plt.colorbar()
cbar.ax.set_title(ctitle, y=1.01)
wpu.save_figs_with_idx(saveFileSuf)
plt.close()
plt.ion()
ax2.plot(yVec*1e6, dpy[:,dpy.shape[0]//4*3],'-og')
ax2.ticklabel_format(style='sci', axis='y', scilimits=(0, 1))
ax2.set_xlabel('[um]')
ax2.set_ylabel('dpy [radians]')
lin_fity = np.polyfit(yVec, dpy[:,dpy.shape[0]//2], 1)
lin_funcy = np.poly1d(lin_fity)
ax2.plot(yVec*1e6, lin_funcy(yVec),'--c',lw=2)
curvrad_y = kwave/(lin_fity[0])
ax2.set_title('Curvature Radius of WF {:.3g} m'.format(curvrad_y), fontsize=18)
ax2.set_adjustable('box-forced')
if saveFigFlag: wpu.save_figs_with_idx(foutname)
plt.show(block=True)
# %%
plotsidebyside(sx, sy, r'Displacement $S_x$ [pixels]',
r'Displacement $S_y$ [pixels]')
# %%
mySimplePlot(totalS, title=r'Displacement Module $|\vec{S}|$ [pixels]')
# %%
ax2.plot(yVec * 1e6, dpy[:, dpy.shape[0] // 4], '-ob')
ax2.plot(yVec * 1e6, dpy[:, dpy.shape[0] // 2], '-or')
ax2.plot(yVec * 1e6, dpy[:, dpy.shape[0] // 4 * 3], '-og')
ax2.ticklabel_format(style='sci', axis='y', scilimits=(0, 1))
ax2.set_xlabel('[um]')
ax2.set_ylabel('dpy [radians]')
lin_fity = np.polyfit(yVec, dpy[:, dpy.shape[0] // 2], 1)
lin_funcy = np.poly1d(lin_fity)
ax2.plot(yVec * 1e6, lin_funcy(yVec), '--c', lw=2)
curvrad_y = kwave / (lin_fity[0])
ax2.set_title('Curvature Radius of WF {:.3g} m'.format(curvrad_y), fontsize=18)
ax2.set_adjustable('box')
if saveFigFlag: wpu.save_figs_with_idx(foutname)
# plt.show()
print('flag6')
# %%
plotsidebyside(sx, sy, 'Displacement $S_x$ [pixels]',
'Displacement $S_y$ [pixels]')
# %%
mySimplePlot(totalS, title='Displacement Module $|\vec{S}|$ [pixels]')
# %%
fig = plt.figure(figsize=(14, 5))
def plot_residual_parabolic_lens_2d(thickness,
pixelsize,
fitted,
fitParameters,
saveFigFlag=False,
savePickle=False,
str4title='',
saveSdfData=False,
vlimErrSigma=1,
plotProfileFlag=True,
plot3dFlag=True,
makeAnimation=False):
xmatrix, ymatrix = wpu.grid_coord(thickness, pixelsize)
errorThickness = thickness - fitted
argNotNAN = np.isfinite(errorThickness)
factorx, unitx = wpu.choose_unit(xmatrix)
factory, unity = wpu.choose_unit(ymatrix)
factorz, unitz = wpu.choose_unit(errorThickness[argNotNAN])
ptp = np.ptp(errorThickness[argNotNAN].flatten() * factorz)
wpu.print_red('PV: {0:4.3g} '.format(ptp) + unitz[-1] + 'm')
sigmaError = np.std(errorThickness[argNotNAN].flatten() * factorz)
wpu.print_red('SDV: {0:4.3g} '.format(sigmaError) + unitz[-1] + 'm')
str4title += r'Residual, ' + \
r'R $= {:.4g} \mu m$,'.format(fitParameters[0]*1e6) + '\n' + \
r'PV $= {0:.2f}$ '.format(ptp) + '$' + unitz + ' m$, '\
'SDV $= {0:.2f}$ '.format(sigmaError) + '$' + unitz + ' m$'
# Plot Histogram
plt.figure(figsize=(7, 8))
plt.hist(errorThickness[argNotNAN] * factorz,
100,
color='r',
histtype='step')
plt.xlabel(r'Residual [$' + unitz + ' m$ ]')
plt.title(str4title)
if saveFigFlag:
wpu.save_figs_with_idx(fname2save, extension='png')
plt.show(block=False)
# Plot Profiles
vlimErr = wpu.mean_plus_n_sigma(errorThickness[argNotNAN] * factorz,
vlimErrSigma / 2)
cmap4graph = plt.cm.Spectral_r
cmap4graph.set_over('m')
cmap4graph.set_under('c')
if plotProfileFlag:
wpu.plot_profile(xmatrix * factorx,
ymatrix * factory,
errorThickness * factorz,
title=str4title,
xlabel=r'[$' + unitx + ' m$ ]',
ylabel=r'[$' + unity + ' m$ ]',
zlabel=r'[$' + unitz + ' m$ ]',
arg4main={
'cmap': 'Spectral_r',
'vmin': -vlimErr,
'vmax': vlimErr,
'extend': 'both'
})
if savePickle or saveFigFlag:
fig = plt.figure(figsize=(10, 7))
cf = plt.contourf(xmatrix * factorx,
ymatrix * factory,
errorThickness * factorz,
256,
cmap=cmap4graph,
extend='both')
plt.clim(-vlimErr, vlimErr)
plt.contour(cf, levels=cf.levels[::32], colors='gray')
plt.xlabel(r'[$' + unitx + ' m$ ]', fontsize=22)
plt.ylabel(r'[$' + unity + ' m$ ]', fontsize=22)
plt.title(str4title, fontsize=22)
cbar = plt.colorbar(cf, shrink=.8, aspect=20)
# cbar.set_clim(-vlimErr, vlimErr)
cbar.ax.set_title(r'[$' + unitz + ' m$ ]', y=1.01)
plt.gca().set_aspect('equal', adjustable='box')
plt.grid(color='grey')
if saveFigFlag:
wpu.save_figs_with_idx(fname2save, extension='png')
if savePickle:
wpu.save_figs_with_idx_pickle(fig, fname2save)
plt.show(block=True)
# Plot 3D
if plot3dFlag:
wpu.print_red('MESSAGE: Ploting 3d in the background')
fig = plt.figure(figsize=(10, 7), facecolor="white")
ax = fig.gca(projection='3d')
plt.tight_layout(pad=2.5)
surf = ax.plot_trisurf(xmatrix[argNotNAN].flatten() * factorx,
ymatrix[argNotNAN].flatten() * factory,
errorThickness[argNotNAN].flatten() * factorz,
vmin=-vlimErr,
vmax=vlimErr,
cmap=cmap4graph,
linewidth=0.1,
shade=False)
ax.view_init(azim=-120, elev=40)
plt.xlabel(r'$x$ [$' + unitx + ' m$ ]')
plt.ylabel(r'$y$ [$' + unity + ' m$ ]')
plt.title(str4title)
cbar = plt.colorbar(surf, shrink=.8, aspect=20, extend='both')
cbar.ax.set_title(r'[$' + unitz + ' m$ ]', y=1.01)
plt.tight_layout()
if saveFigFlag:
wpu.save_figs_with_idx(fname2save, extension='png')
ax.view_init(azim=690, elev=40)
wpu.save_figs_with_idx(fname2save, extension='png')
if makeAnimation:
# plt.show(block=False)
plt.pause(1.0)
wpu.rocking_3d_figure(ax,
wpu.get_unique_filename(fname2save, 'gif'),
elevOffset=45,
azimOffset=60,
elevAmp=0,
azimAmpl=-1,
dpi=80,
npoints=5)
plt.pause(1.0)
plt.close('all')
# plt.show(block=True)
if saveSdfData:
mask_for_sdf = errorThickness * 0.0
mask_for_sdf[~argNotNAN] = 1.0
errorThickness[~argNotNAN] = 00000000
wpu.save_sdf_file(
errorThickness, pixelsize,
wpu.get_unique_filename(fname2save + '_residual', 'sdf'))
wpu.save_sdf_file(
mask_for_sdf, pixelsize,
wpu.get_unique_filename(fname2save + '_residual_mask', 'sdf'))
return sigmaError / factorz, ptp / factorz
for i in range(0, nfiles, step_files):
data = list_all_data[i]
plt.plot(data[:, 0] * 1e3,
data[:, curve_index] * 1e9,
next(lstyle_cycle),
color=next(lc_cycle),
label=label_list[i])
plt.xlabel('y [$mm$]')
plt.ylabel('Height [$nm$]')
plt.title(addThisToTitle)
plt.legend(loc=0, fontsize=10)
if saveFlag:
wpu.save_figs_with_idx()
plt.show()
# %% splines
from scipy.interpolate import interp1d
fspline = []
for _ in list_of_files:
fspline.append([])
for k in range(nfiles):
data = list_all_data[k]
def main_terminal(data_dir,
zvec_from,
startDist,
step_z_scan,
image_per_point,
strideFile,
pixelSize=0.65e-6,
gratingPeriod=4.8e-6,
pattern='Diagonal',
sourceDistanceV=-1,
sourceDistanceH=32,
unFilterSize=1,
searchRegion=20,
idx4crop=[0, -1, 0, -1],
darkRegionSelctionFlag=True):
'''
*** all unit in [m]
data_dir: data folder path
zvec_from: distance type:
'Calculated'
'Tabled'
startDist: started distance postion
step_z_scan: step size
image_per_point: images number for every distance
strideFile: Stride (Use only every XX files)
pixelSize: Pixel Size
gratingPeriod: CB Grating Period
pattern: grating pattern
'Diagonal' or 'Edge']
sourceDistanceV: Distance to Source
in the VERTICAL [m]
sourceDistanceH: Distance to Source
in the Horizontal [m]
unFilterSize: Size for Uniform Filter [Pixels]
default_value 1
searchRegion: Size of Region for Searching
the Peak [in Pixels]
default_value=20
idx4crop: crop area
[low_y, high_y, low_x, high_x ]
darkRegionSelctionFlag: use dark region [0, 20, 0, 20]?
'''
wpu._mpl_settings_4_nice_graphs()
# =============================================================================
# %% Load Image
# =============================================================================
originalDir = os.getcwd()
# samplefileName = easyqt.get_file_names("Choose one of the scan files")[0]
# data_dir = samplefileName.rsplit('/', 1)[0]
os.chdir(data_dir)
try:
os.mkdir(data_dir + '/output/')
except:
pass
fname2save = data_dir + '/output/' + 'zscan'
# wpu.print_blue('MESSAGE: Loading files ' +
# samplefileName.rsplit('_', 1)[0] + '*.tif')
wpu.print_blue('MESSAGE: Loading files ' + data_dir + '/*.tif')
# listOfDataFiles = glob.glob(samplefileName.rsplit('_', 2)[0] + '*.tif')
listOfDataFiles = glob.glob(os.path.join(data_dir, '*.tif'))
listOfDataFiles.sort()
nfiles = len(listOfDataFiles)
# zvec_from = easyqt.get_choice(message='z distances is calculated or from table?',
# title='Title',
# choices=['Calculated', 'Tabled'])
# %%
if zvec_from == 'Calculated':
# startDist = easyqt.get_float('Starting distance scan [mm]',
# title='Title',
# default_value=20)*1e-3
# step_z_scan = easyqt.get_float('Step size scan [mm]',
# title='Title',
# default_value=5)*1e-3
# image_per_point = easyqt.get_int('Number of images by step',
# title='Title',
# default_value=1)
zvec = np.linspace(
startDist,
startDist + step_z_scan * (nfiles / image_per_point - 1),
int(nfiles / image_per_point))
zvec = zvec.repeat(image_per_point)
# strideFile = easyqt.get_int('Stride (Use only every XX files)',
# title='Title',
# default_value=1)
listOfDataFiles = listOfDataFiles[0::strideFile]
zvec = zvec[0::strideFile]
print(zvec)
elif zvec_from == 'Tabled':
zvec = np.loadtxt(
easyqt.get_file_names("Table with the z distance values in mm")
[0]) * 1e-3
step_z_scan = np.mean(np.diff(zvec))
if step_z_scan > 0:
pass
else:
listOfDataFiles = listOfDataFiles[::-1]
zvec = zvec[::-1]
img = dxchange.read_tiff(listOfDataFiles[0])
# =============================================================================
# %% Experimental parameters
# =============================================================================
# pixelSize = easyqt.get_float("Enter Pixel Size [um]",
# title='Experimental Values',
# default_value=.6500, decimals=5)*1e-6
# gratingPeriod = easyqt.get_float("Enter CB Grating Period [um]",
# title='Experimental Values',
# default_value=4.8)*1e-6
# pattern = easyqt.get_choice(message='Select CB Grating Pattern',
# title='Title',
# choices=['Diagonal', 'Edge'])
# # choices=['Edge', 'Diagonal'])
# sourceDistanceV = easyqt.get_float("Enter Distance to Source\n in the VERTICAL [m]",
# title='Experimental Values',
# default_value=-0.73)
# sourceDistanceH = easyqt.get_float("Enter Distance to Source\n in the Horizontal [m]",
# title='Experimental Values',
# default_value=34.0)
# unFilterSize = easyqt.get_int("Enter Size for Uniform Filter [Pixels]\n" +
# " (Enter 1 to NOT use the filter)",
# title='Experimental Values',
# default_value=1)
# searchRegion = easyqt.get_int("Enter Size of Region for Searching\n the Peak [in Pixels]",
# title='Experimental Values',
# default_value=20)
os.chdir(originalDir)
# =============================================================================
# %% Crop
# =============================================================================
idx4crop = [0, -1, 0, -1]
# [colorlimit,
# cmap] = wpu.plot_slide_colorbar(img,
# title='SELECT COLOR SCALE,\n' +
# 'Raw Image, No Crop',
# xlabel=r'x [$\mu m$ ]',
# ylabel=r'y [$\mu m$ ]',
# extent=wpu.extent_func(img,
# pixelSize)*1e6)
# idx4crop = wpu.graphical_roi_idx(img, verbose=True,
# kargs4graph={'cmap': cmap,
# 'vmin': colorlimit[0],
# 'vmax': colorlimit[1]})
wpu.print_blue("MESSAGE: idx for cropping")
wpu.print_blue(idx4crop)
# =============================================================================
# %% Dark indexes
# =============================================================================
# darkRegionSelctionFlag = easyqt.get_yes_or_no('Do you want to select ' +
# 'region for dark calculation?\n' +
# 'Press ESC to use [0, 20, 0, 20]')
print(darkRegionSelctionFlag)
if darkRegionSelctionFlag:
idx4cropDark = wpu.graphical_roi_idx(img,
verbose=True,
kargs4graph={
'cmap': cmap,
'vmin': colorlimit[0],
'vmax': colorlimit[1]
})
else:
idx4cropDark = [0, 20, 0, 20]
# dark_im = dxchange.read_tiff(listOfDataFiles[0])*0.0 + avgDark
img = wpu.crop_matrix_at_indexes(img, idx4crop)
# ==============================================================================
# %% Harmonic Periods
# ==============================================================================
if pattern == 'Diagonal':
period_harm_Vert = np.int(
np.sqrt(2) * pixelSize / gratingPeriod * img.shape[0])
period_harm_Horz = np.int(
np.sqrt(2) * pixelSize / gratingPeriod * img.shape[1])
elif pattern == 'Edge':
period_harm_Vert = np.int(2 * pixelSize / gratingPeriod * img.shape[0])
period_harm_Horz = np.int(2 * pixelSize / gratingPeriod * img.shape[1])
# Obtain harmonic periods from images
(period_harm_Vert,
_) = wgi.exp_harm_period(img, [period_harm_Vert, period_harm_Horz],
harmonic_ij=['1', '0'],
searchRegion=40,
isFFT=False,
verbose=True)
(_, period_harm_Horz) = wgi.exp_harm_period(
img, [period_harm_Vert, period_harm_Horz],
harmonic_ij=['0', '1'],
searchRegion=40,
isFFT=False,
verbose=True)
wpu.log_this('Input folder: ' + data_dir, preffname=fname2save)
wpu.log_this('\nNumber of files : ' + str(nfiles))
wpu.log_this('Stride : ' + str(strideFile))
print(zvec_from)
wpu.log_this('Z distances is ' + zvec_from)
if zvec_from == 'Calculated':
wpu.log_this('Step zscan [mm] : {:.4g}'.format(step_z_scan * 1e3))
wpu.log_this('Start point zscan [mm] : {:.4g}'.format(startDist * 1e3))
wpu.log_this('Pixel Size [um] : {:.4g}'.format(pixelSize * 1e6))
wpu.log_this('Grating Period [um] : {:.4g}'.format(gratingPeriod * 1e6))
wpu.log_this('Grating Pattern : ' + pattern)
wpu.log_this('Crop idxs : ' + str(idx4crop))
wpu.log_this('Dark idxs : ' + str(idx4cropDark))
wpu.log_this('Vertical Source Distance: ' + str(sourceDistanceV))
wpu.log_this('Horizontal Source Distance: ' + str(sourceDistanceH))
wpu.log_this('Uniform Filter Size : {:d}'.format(unFilterSize))
wpu.log_this('Search Region : {:d}'.format(searchRegion))
# =============================================================================
# %% Calculate everything
# =============================================================================
# =============================================================================
# %% multiprocessing
# =============================================================================
ncpus = cpu_count()
wpu.print_blue("MESSAGE: %d cpu's available" % ncpus)
tzero = time.time()
p = Pool(ncpus - 2)
indexes = range(len(listOfDataFiles))
parameters = []
for i in indexes:
parameters.append([
i, listOfDataFiles, zvec, idx4cropDark, idx4crop, period_harm_Vert,
sourceDistanceV, period_harm_Horz, sourceDistanceH, searchRegion,
unFilterSize
])
res = p.map(_func, parameters)
p.close()
wpu.print_blue('MESSAGE: Time spent: {0:.3f} s'.format(time.time() -
tzero))
'''
res = []
for i in range(len(listOfDataFiles)):
res.append(_func(i))
print(res)
'''
# =============================================================================
# %% Sorting the data
# =============================================================================
contrastV = np.asarray([x[0] for x in res])
contrastH = np.asarray([x[1] for x in res])
p0 = np.asarray([x[2] for x in res])
pv = np.asarray([x[3] for x in res])
ph = np.asarray([x[4] for x in res])
pattern_period_Vert_z = pixelSize / (pv[:, 0] - p0[:, 0]) * img.shape[0]
pattern_period_Horz_z = pixelSize / (ph[:, 1] - p0[:, 1]) * img.shape[1]
# =============================================================================
# %% Save csv file
# =============================================================================
outputfname = wpu.get_unique_filename(fname2save, 'csv')
wpu.save_csv_file(np.c_[zvec.T, contrastV.T, contrastH.T,
pattern_period_Vert_z.T, pattern_period_Horz_z.T],
outputfname,
headerList=[
'z [m]', 'Vert Contrast', 'Horz Contrast',
'Vert Period [m]', 'Horz Period [m]'
])
wpu.log_this('\nOutput file: ' + outputfname)
# =============================================================================
# %% Plot
# =============================================================================
# contrast vs z
fig = plt.figure(figsize=(10, 7))
plt.plot(zvec * 1e3, contrastV * 100, '-ko', label='Vert')
plt.plot(zvec * 1e3, contrastH * 100, '-ro', label='Hor')
plt.xlabel(r'Distance $z$ [mm]', fontsize=14)
plt.ylabel(r'Visibility $\times$ 100 [%]', fontsize=14)
plt.title('Visibility vs detector distance', fontsize=14, weight='bold')
plt.legend(fontsize=14, loc=0)
wpu.save_figs_with_idx(fname2save)
plt.show(block=False)
# =============================================================================
# %% Plot Harmonic position and calculate source distance
# =============================================================================
from wavepytools.diag.coherence.fit_singleGratingCoherence_z_scan import fit_period_vs_z
#xshi 20190719
#from fit_singleGratingCoherence_z_scan import fit_period_vs_z
(sourceDistance_from_fit_V,
patternPeriodFromData_V) = fit_period_vs_z(zvec,
pattern_period_Vert_z,
contrastV,
direction='Vertical',
threshold=.002,
fname4graphs=fname2save)
(sourceDistance_from_fit_H,
patternPeriodFromData_H) = fit_period_vs_z(zvec,
pattern_period_Horz_z,
contrastH,
direction='Horizontal',
threshold=0.0005,
fname4graphs=fname2save)
wgi.plot_integration(-(phase - np.min(phase)) / kwave / delta * 1e6,
virtual_pixelsize,
titleStr=r'Thickness Beryllium $[\mu m]$,' +
'\n Frankot Chellappa integration',
plot3dFlag=True,
saveFigFlag=True,
saveFileSuf=saveFileSuf)
wps.error_integration(diffPhase01 * virtual_pixelsize[1],
diffPhase10 * virtual_pixelsize[0],
phase,
virtual_pixelsize,
errors=False,
plot_flag=True)
wpu.save_figs_with_idx(saveFileSuf)
# %%
def _pad_2_make_square(array, mode='edge'):
diff_shape = array.shape[0] - array.shape[1]
if diff_shape > 1:
return np.pad(array, ((0, 0), (0, diff_shape)), mode=mode)
elif diff_shape < 1:
return np.pad(array, ((0, -diff_shape), (0, 0)), mode=mode)
def plot_integration(integrated,
pixelsize,
titleStr='Title',
ctitle=' ',
max3d_grid_points=101,
plotProfile=True,
plot3dFlag=True,
saveFigFlag=False,
saveFileSuf='graph',
**kwarg4surf):
'''
TODO: Write Docstring
'''
xxGrid, yyGrid = wpu.grid_coord(integrated, pixelsize)
factor_x, unit_x = wpu.choose_unit(xxGrid)
factor_y, unit_y = wpu.choose_unit(yyGrid)
# Plot Integration 2
if plot3dFlag:
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
rstride = integrated.shape[0] // max3d_grid_points + 1
cstride = integrated.shape[1] // max3d_grid_points + 1
surf = ax.plot_surface(xxGrid * factor_x,
yyGrid * factor_y,
integrated[::-1, :],
rstride=rstride,
cstride=cstride,
cmap='viridis',
linewidth=0.1,
**kwarg4surf)
ax_lim = np.max([np.abs(xxGrid * factor_x), np.abs(yyGrid * factor_y)])
ax.set_xlim3d(-ax_lim, ax_lim)
ax.set_ylim3d(-ax_lim, ax_lim)
if 'vmin' in kwarg4surf:
ax.set_zlim3d(bottom=kwarg4surf['vmin'])
if 'vmax' in kwarg4surf:
ax.set_zlim3d(top=kwarg4surf['vmax'])
plt.xlabel(r'$x [' + unit_x + ' m]$', fontsize=24)
plt.ylabel(r'$y [' + unit_y + ' m]$', fontsize=24)
plt.title(titleStr, fontsize=24, weight='bold')
cbar = plt.colorbar(surf, shrink=.8, aspect=20)
cbar.ax.set_title(ctitle, y=1.01)
plt.tight_layout(rect=[0, 0, 1, 1])
ax.text2D(0.05,
0.9,
'strides = {}, {}'.format(rstride, cstride),
transform=ax.transAxes)
if saveFigFlag:
ax.view_init(elev=30, azim=60)
wpu.save_figs_with_idx(saveFileSuf)
ax.view_init(elev=30, azim=-120)
wpu.save_figs_with_idx(saveFileSuf)
plt.pause(.5)
plt.show(block=False)
if plotProfile:
wpu.plot_profile(xxGrid * factor_x,
yyGrid * factor_y,
integrated[::-1, :],
xlabel=r'$x [' + unit_x + ' m]$',
ylabel=r'$y [' + unit_y + ' m]$',
title=titleStr,
xunit='\mu m',
yunit='\mu m',
arg4main={
'cmap': 'viridis',
'lw': 3
})
if saveFigFlag:
plt.ioff()
plt.figure(figsize=(10, 8))
plt.imshow(integrated[::-1, :],
cmap='viridis',
extent=wpu.extent_func(integrated, pixelsize) * factor_x,
**kwarg4surf)
plt.xlabel(r'$x [' + unit_x + ' m]$', fontsize=24)
plt.ylabel(r'$y [' + unit_x + ' m]$', fontsize=24)
plt.title(titleStr, fontsize=18, weight='bold')
cbar = plt.colorbar()
cbar.ax.set_title(ctitle, y=1.01)
wpu.save_figs_with_idx(saveFileSuf)
plt.close()
plt.ion()
def integrate_DPC_cumsum(data_DPC,
wavelength,
grazing_angle=0.0,
projectionFromDiv=1.0,
labels=[],
xlabel='x',
ylabel='Height',
titleStr='',
saveFileSuf=''):
ls_cycle, lc_cycle = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=data_DPC.shape[1] - 1,
cmap_str='gist_rainbow_r')
if grazing_angle // .00001 > 0:
projection = 1 / np.sin(grazing_angle) * projectionFromDiv
else:
projection = projectionFromDiv
xvec = data_DPC[:, 0] * projection
plt.figure(figsize=(12, 12 * 9 / 16))
list_integrated = [xvec]
header = [xlabel + ' [m]']
for j_line in range(1, data_DPC.shape[1]):
integrated = (
np.cumsum(data_DPC[:, j_line] - np.mean(data_DPC[:, j_line])) *
(xvec[1] - xvec[0]))
integrated *= -1 / 2 / np.pi * wavelength * np.abs(projection)
# TODO: check here!!
if j_line == 1:
factor_x, unit_x = wpu.choose_unit(xvec)
factor_y, unit_y = wpu.choose_unit(integrated)
list_integrated.append(integrated)
header.append(labels[j_line - 1])
plt.plot(xvec * factor_x,
integrated * factor_y,
next(ls_cycle),
c=next(lc_cycle),
label=labels[j_line - 1])
marginx = 0.1 * np.ptp(xvec * factor_x)
plt.xlim(
[np.min(xvec * factor_x) - marginx,
np.max(xvec * factor_x) + marginx])
plt.xlabel(xlabel + r' [$' + unit_x + ' m$]')
plt.ylabel(ylabel + r' [$' + unit_y + ' m$]')
plt.legend(loc=0, fontsize=12)
if grazing_angle // .00001 > 0:
plt.title(titleStr + 'Mirror Height,\n' +
'grazing angle {:.2f} mrad,\n'.format(grazing_angle * 1e3) +
'projection due divergence = ' +
r'$ \times $ {:.2f}'.format(projectionFromDiv))
else:
plt.title(titleStr + 'Integration Cumulative Sum')
plt.tight_layout()
wpu.save_figs_with_idx(saveFileSuf)
plt.show()
data2saveV = np.asarray(list_integrated).T
header.append(ylabel + ' [m]')
if grazing_angle // .00001 > 0:
header.append('grazing_angle = {:.4g}'.format(grazing_angle))
if projectionFromDiv // 1 != 1:
header.append('projection due divergence = ' +
'{:.2f}x'.format(projectionFromDiv))
wpu.save_csv_file(data2saveV,
wpu.get_unique_filename(
saveFileSuf + '_integrated_' + xlabel, 'csv'),
headerList=header)
return np.asarray(list_integrated).T
delta = 5.3276849026895334e-06
wgi.plot_integration(-(phase - np.min(phase))/kwave/delta*1e6,
virtual_pixelsize,
titleStr=r'Thickness Beryllium $[\mu m]$,' +'\n Frankot Chellappa integration',
plot3dFlag=True,
saveFigFlag=True,
saveFileSuf=saveFileSuf)
wps.error_integration(diffPhase01*virtual_pixelsize[1],
diffPhase10*virtual_pixelsize[0],
phase, virtual_pixelsize, errors=False,
plot_flag=True)
wpu.save_figs_with_idx(saveFileSuf)
# %%
def _pad_2_make_square(array, mode='edge'):
diff_shape = array.shape[0] - array.shape[1]
if diff_shape > 1:
return np.pad(array, ((0, 0), (0, diff_shape)), mode=mode)
elif diff_shape < 1:
return np.pad(array, ((0, -diff_shape), (0, 0)), mode=mode)
# %%
thickness = (phase - np.min(phase))/kwave/delta
ax = wgi.plot_integration(thickness*1e6,
virtual_pixelsize,
titleStr=r'Material: ' + material +
', Thickness $[\mu m]$',
ctitle=r'$[\mu m]$',
saveFigFlag=True, saveFileSuf=saveFileSuf)
ax.view_init(elev=30, azim=60)
plt.show(block=False)
wpu.save_figs_with_idx(saveFileSuf + '_Talbot_image')
plt.show(block=False)
# %% save thicknes txt
saveFileSuf += '_thickness_' + material
np.savetxt(saveFileSuf + '.dat', thickness,
header='values in meter, pixel size i,j = ' +
'{:.6g} meters, '.format(virtual_pixelsize[0]) +
'{:.6g} meters'.format(virtual_pixelsize[1]))
# %% Plot thickness and save as pickle
titleStr = r'Material: ' + material + ', Thickness $[\mu m]$'
_default_plot_for_pickle(thickness*1e6, pixelsize,
# =============================================================================
# %% Plot
# =============================================================================
# contrast vs z
fig = plt.figure(figsize=(10, 7))
plt.plot(zvec * 1e3, contrastV * 100, '-ko', label='Vert')
plt.plot(zvec * 1e3, contrastH * 100, '-ro', label='Hor')
plt.xlabel(r'Distance $z$ [mm]', fontsize=14)
plt.ylabel(r'Visibility $\times$ 100 [%]', fontsize=14)
plt.title('Visibility vs detector distance', fontsize=14, weight='bold')
plt.legend(fontsize=14, loc=0)
wpu.save_figs_with_idx(fname2save)
plt.show(block=False)
# =============================================================================
# %% Plot Harmonic position and calculate source distance
# =============================================================================
from fit_singleGratingCoherence_z_scan import fit_period_vs_z
(sourceDistance_from_fit_V,
patternPeriodFromData_V) = fit_period_vs_z(zvec,
pattern_period_Vert_z,
contrastV,
direction='Vertical',
threshold=.005,
fname4graphs=fname2save)
def integrate_DPC_cumsum(data_DPC, wavelength,
grazing_angle=0.0, projectionFromDiv=1.0,
remove2ndOrder=False,
labels=[],
xlabel='x', ylabel='Height',
titleStr='', saveFileSuf=''):
ls_cycle, lc_cycle = wpu.line_style_cycle(['-'], ['o', 's', 'd', '^'],
ncurves=data_DPC.shape[1] - 1,
cmap_str='gist_rainbow_r')
if grazing_angle//.00001 > 0:
projection = 1/np.sin(grazing_angle)*projectionFromDiv
else:
projection = projectionFromDiv
xvec = data_DPC[:, 0]*projection
plt.figure(figsize=(12, 12*9/16))
list_integrated = [xvec]
header = [xlabel + ' [m]']
for j_line in range(1, data_DPC.shape[1]):
integrated = (np.cumsum(data_DPC[:, j_line] - np.mean(data_DPC[:, j_line]))
* (xvec[1]-xvec[0])) # TODO: removed mean 20181020
# integrated = (np.cumsum(data_DPC[:, j_line])) * (xvec[1]-xvec[0])
integrated *= -1/2/np.pi*wavelength*np.abs(projection)
p02 = np.polyfit(xvec, integrated, 2)
fitted_pol2 = p02[0]*xvec**2 + p02[1]*xvec + p02[2]
if remove2ndOrder:
integrated -= fitted_pol2
titleStr += 'Removed 2nd order, '
# TODO: check here!!
if j_line == 1:
factor_x, unit_x = wpu.choose_unit(xvec)
factor_y, unit_y = wpu.choose_unit(integrated)
list_integrated.append(integrated)
header.append(labels[j_line - 1])
lc = next(lc_cycle)
plt.plot(xvec*factor_x,
integrated*factor_y,
next(ls_cycle), c=lc,
label=labels[j_line - 1])
if not remove2ndOrder:
plt.plot(xvec*1e6, (fitted_pol2)*factor_y,
'--', color=lc, lw=3)
marginx = 0.1*np.ptp(xvec*factor_x)
plt.xlim([np.min(xvec*factor_x)-marginx,
np.max(xvec*factor_x)+marginx])
plt.xlabel(xlabel + r' [$' + unit_x + ' m$]')
plt.ylabel(ylabel + r' [$' + unit_y + ' m$]')
plt.legend(loc=0, fontsize=12)
if grazing_angle//.00001 > 0:
plt.title(titleStr + 'Mirror Height,\n' +
'grazing angle {:.2f} mrad,\n'.format(grazing_angle*1e3) +
'projection due divergence = ' +
r'$ \times $ {:.2f}'.format(projectionFromDiv))
else:
plt.title(titleStr + 'Integration Cumulative Sum')
plt.tight_layout()
wpu.save_figs_with_idx(saveFileSuf)
plt.show()
data2saveV = np.asarray(list_integrated).T
header.append(ylabel + ' [m]')
if grazing_angle//.00001 > 0:
header.append('grazing_angle = {:.4g}'.format(grazing_angle))
if projectionFromDiv//1 != 1:
header.append('projection due divergence = ' +
'{:.2f}x'.format(projectionFromDiv))
wpu.save_csv_file(data2saveV,
wpu.get_unique_filename(saveFileSuf +
'_integrated_' + xlabel, 'csv'),
headerList=header)
return np.asarray(list_integrated).T
# %% alignment 1
img1_aligned, img2_aligned, pixel_shift = wpu.gui_align_two_images(img1, img2, option='pad')
# save files
outfname = wpu.get_unique_filename(img1fname.split('.')[0] + '_aligned',
'tiff')
dxchange.write_tiff(img1_aligned, outfname)
wpu.print_blue('MESSAGE: file ' + outfname + ' saved.')
outfname = wpu.get_unique_filename(img2fname.split('.')[0] + '_aligned',
'tiff')
dxchange.write_tiff(img2_aligned, outfname)
wpu.print_blue('MESSAGE: file ' + outfname + ' saved.')
# %%
plt.figure(figsize=(12, 12))
plt.imshow(img1_aligned[::5, ::5], cmap='viridis')
plt.title('img1')
wpu.save_figs_with_idx('aligned')
plt.show(block=False)
plt.figure(figsize=(12, 12))
plt.imshow(img2_aligned[::5, ::5], cmap='viridis')
plt.title('img2')
wpu.save_figs_with_idx('aligned')
plt.show(block=True)
print('Bye')
def plot_integration(integrated, pixelsize,
titleStr='Title', ctitle=' ', saveFigFlag=False,
saveFileSuf='graph'):
'''
TODO: Write Docstring
'''
xxGrid, yyGrid = wpu.grid_coord(integrated, pixelsize)
factor_x, unit_x = wpu.choose_unit(xxGrid)
factor_y, unit_y = wpu.choose_unit(yyGrid)
wpu.plot_profile(xxGrid*factor_x, yyGrid*factor_y, integrated[::-1, :],
xlabel=r'$x [' + unit_x + ' m]$',
ylabel=r'$y [' + unit_y + ' m]$',
title=titleStr,
xunit='\mu m', yunit='\mu m',
arg4main={'cmap': 'viridis', 'lw': 3})
if saveFigFlag:
plt.ioff()
plt.figure(figsize=(10, 8))
plt.imshow(integrated[::-1, :], cmap='viridis',
extent=wpu.extent_func(integrated, pixelsize)*factor_x)
plt.xlabel(r'$x [' + unit_x + ' m]$', fontsize=24)
plt.ylabel(r'$y [' + unit_x + ' m]$', fontsize=24)
plt.title(titleStr, fontsize=18, weight='bold')
cbar = plt.colorbar()
cbar.ax.set_title(ctitle, y=1.01)
wpu.save_figs_with_idx(saveFileSuf)
# plt.show(block=False)
plt.close(plt.gcf())
plt.ion()
# Plot Integration 2
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
rstride = integrated.shape[0] // 101 + 1
cstride = integrated.shape[1] // 101 + 1
surf = ax.plot_surface(xxGrid*factor_x, yyGrid*factor_y,
integrated[::-1, :],
rstride=rstride,
cstride=cstride,
cmap='viridis', linewidth=0.1)
ax_lim = np.max([np.abs(xxGrid*factor_x), np.abs(yyGrid*factor_y)])
ax.set_xlim3d(-ax_lim, ax_lim)
ax.set_ylim3d(-ax_lim, ax_lim)
plt.xlabel(r'$x [' + unit_x + ' m]$', fontsize=24)
plt.ylabel(r'$y [' + unit_y + ' m]$', fontsize=24)
plt.title(titleStr, fontsize=24, weight='bold')
cbar = plt.colorbar(surf, shrink=.8, aspect=20)
cbar.ax.set_title(ctitle, y=1.01)
fig.tight_layout()
plt.tight_layout()
if saveFigFlag:
wpu.save_figs_with_idx(saveFileSuf)
ax.text2D(0.05, 0.9, 'strides = {}, {}'.format(rstride, cstride),
transform=ax.transAxes)
plt.show(block=False)
return ax
