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