def step4(self): ''' Perform a 4th order timestep ''' def order2(c): Vc = np.exp( -1j * c * self.dt / 2. * ( self.V - self.gravity() + self.g * abs( self.psi ) ** 2 ) ) Tc = self.expksquare ** c return Vc, Tc p = 1/(4.-4.**(1/3.)) q = 1 - 4 * p Vp,Tp = order2( p ) Vq,Tq = order2( q ) return Vp * ff.fftshift( ff.ifft2( Tp * ff.fft2( ff.fftshift( Vp ** 2 * ff.fftshift( ff.ifft2( Tp * ff.fft2( ff.fftshift( Vp * Vq * ff.fftshift( ff.ifft2( Tq * ff.fft2( ff.fftshift( Vq * Vp * ff.fftshift( ff.ifft2( Tp * ff.fft2( ff.fftshift( Vp ** 2 * ff.fftshift( ff.ifft2( Tp * ff.fft2( ff.fftshift( Vp * self.psi ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )
def fftPropagate(field, grid, propDistance): '''Propagates a sampled 1D field along the optical axis. fftPropagate propagates a sampled 1D field a distance L by computing the field's angular spectrum, multiplying each spectral component by the propagation kernel exp(j * 2 * pi * fx * L / wavelength), and then recomibining the propagated spectral components. The angular spectrum is computed using a FFT. Parameters ---------- field : 1D array of complex The sampled field to propagate. grid : Grid The grid on which the sampled field lies. propDistance : float The distance to propagate the field in the same physical units as the grid. ''' scalingFactor = (grid.physicalSize / (grid.gridSize - 1)) F = scalingFactor * fftshift(fft(ifftshift(field))) # Compute the z-component of the wavevector # Adding 0j ensures that numpy.sqrt returns complex numbers kz = 2 * np.pi * np.sqrt(1 - (grid.pfX * grid.wavelength)**2 + 0j) / grid.wavelength # Propagate the field's spectral components Fprop = F * np.exp(1j * kz * propDistance) # Recombine the spectral components fieldProp = fftshift(ifft(ifftshift(Fprop))) / scalingFactor return fieldProp
def test_depth_kwarg(self): nz = 100 zN2 = 0.5*nz**-1 + np.arange(nz, dtype=np.float64)/nz zU = 0.5*nz**-1 + np.arange(nz+1, dtype=np.float64)/nz N2 = np.full(nz, 1.) f0 = 1. #beta = 1e-6 beta = 0. Nx = 1 Ny = 1 dx = .1 dy = .1 k = fft.fftshift( fft.fftfreq(Nx, dx) ) l = fft.fftshift( fft.fftfreq(Ny, dy) ) ubar = np.zeros(nz+1) vbar = np.zeros(nz+1) etax = np.zeros(2) etay = np.zeros(2) with self.assertRaises(ValueError): z, growth_rate, vertical_modes = modes.instability_analysis_from_N2_profile( zN2, N2, f0, beta, k, l, zU, ubar, vbar, etax, etay, depth=zN2[-5] ) # no error expected z, growth_rate, vertical_mode = modes.instability_analysis_from_N2_profile( zN2, N2, f0, beta, k, l, zU, ubar, vbar, etax, etay, depth=1.1 )
def compute_fft(x, n=None, axis=True, power=True, fftshift=True, fs=1.0): """ Compute and return the FFT of the input data :param x: :param n: :param power: :param fftshift: :return: """ x = x.strip('[]') x = [float(i) for i in x.split(',') if i is not ''] fft_out = fftpack.fft(x,n) if axis is True: axis_values = np.linspace(0, 2*fs, len(fft_out)) else: axis_values = [] if power is True: fft_out = np.abs(fft_out) if fftshift is True: fft_out = fftpack.fftshift(fft_out) axis_values = fftpack.fftshift(axis_values) outdict = {'data_in': x, 'data_out': fft_out, 'axis':axis_values, 'power':power, 'fft_shift':fft_shift}
def sim_pic(self,data,alpha): '''Do the forward transform to simulate a picture. Currently with 4Pi cruft.''' self.alpha = alpha self.e1 = fftshift(exp(1j*self.alpha)) self.e2 = fftshift(exp(2j*self.alpha)) return self.Afunc(data)
def test5(): global L0, N L = deepcopy(L0) rho = zeros(N, 'double') rho[0] = 1. rho[N/2] = 1. print rho print fft(rho) rho = fftshift(fft(rho)) print "fft(rho) =", rho L = fft(L).T L = fft(L).T L = fftshift(L) #print L x = linalg.solve(L, rho) print "x =", x #x[abs(x)<0.001] = 0 x = ifftshift(ifft(x)).real * N print "ifft(x) =", x F = [] for i in xrange(len(x)-1): F.append(x[i+1] - x[i]) print "F =", F print "--------------------------------"
def rescale_target_superpixel_resolution(E_target): '''Rescale the target field to the superpixel resolution (currently only 4x4 superpixels implemented)''' superpixelSize = 4 ny,nx = scipy.shape(E_target) maskCenterX = scipy.ceil((nx+1)/2) maskCenterY = scipy.ceil((ny+1)/2) nSuperpixelX = int(nx/superpixelSize) nSuperpixelY = int(ny/superpixelSize) FourierMaskSuperpixelResolution = fourier_mask(ny,nx,superpixelSize) E_target_ft = fft.fftshift(fft.fft2(fft.ifftshift(E_target))) #Apply mask E_target_ft = FourierMaskSuperpixelResolution*E_target_ft #Remove zeros outside of mask E_superpixelResolution_ft = E_target_ft[(maskCenterY - scipy.ceil((nSuperpixelY-1)/2)-1):(maskCenterY + scipy.floor((nSuperpixelY-1)/2)),(maskCenterX - scipy.ceil((nSuperpixelX-1)/2)-1):(maskCenterX + scipy.floor((nSuperpixelX-1)/2))] # Add phase gradient to compensate for anomalous 1.5 pixel shift in real # plane phaseFactor = [[(scipy.exp(2*1j*pi*((k+1)/nSuperpixelY+(j+1)/nSuperpixelX)*3/8)) for j in range(nSuperpixelX)] for k in range(nSuperpixelY)] # QUESTION E_superpixelResolution_ft = E_superpixelResolution_ft*phaseFactor # Fourier transform back to DMD plane E_superpixelResolution = fft.fftshift(fft.ifft2(fft.ifftshift(E_superpixelResolution_ft))) return E_superpixelResolution
def standard_dsi_algorithm(S,bvals,bvecs): #volume size sz=16 #shifting origin=8 #hanning width filter_width=32. #number of signal sampling points n=515 #odf radius #radius=np.arange(2.1,30,.1) radius=np.arange(2.1,6,.2) #radius=np.arange(.1,6,.1) bv=bvals bmin=np.sort(bv)[1] bv=np.sqrt(bv/bmin) qtable=np.vstack((bv,bv,bv)).T*bvecs qtable=np.floor(qtable+.5) #calculate radius for the hanning filter r = np.sqrt(qtable[:,0]**2+qtable[:,1]**2+qtable[:,2]**2) #setting hanning filter width and hanning hanning=.5*np.cos(2*np.pi*r/filter_width) #center and index in q space volume q=qtable+origin q=q.astype('i8') #apply the hanning filter values=S*hanning #create the signal volume Sq=np.zeros((sz,sz,sz)) for i in range(n): Sq[q[i][0],q[i][1],q[i][2]]+=values[i] #apply fourier transform Pr=fftshift(np.abs(np.real(fftn(fftshift(Sq),(sz,sz,sz))))) #vertices, edges, faces = create_unit_sphere(5) #vertices, faces = sphere_vf_from('symmetric362') vertices, faces = sphere_vf_from('symmetric724') odf = np.zeros(len(vertices)) for m in range(len(vertices)): xi=origin+radius*vertices[m,0] yi=origin+radius*vertices[m,1] zi=origin+radius*vertices[m,2] PrI=map_coordinates(Pr,np.vstack((xi,yi,zi)),order=1) for i in range(len(radius)): odf[m]=odf[m]+PrI[i]*radius[i]**2 peaks,inds=peak_finding(odf.astype('f8'),faces.astype('uint16')) return Pr,odf,peaks
def rolloff(grid_shape, nhood_shape=[6,6], ncrop=None, osfactor=2, threshold=0.01, axes=[-1, -2], combi=False, slice_prof_coef=1): if combi: nz = spatial_dims[-1] spatial_dims = grid_shape[:-1] ndims = len(spatial_dims) ro_data = ones(nz, dtype='complex64') ro_K = zeros((nz, ndims), dtype='float32') ro_K[:,2] = linspace(-nz/2, nz/2, nz, endpoint=False) else: spatial_dims = grid_shape ndims = len(spatial_dims) ro_data = array([1.0], dtype='complex64') ro_K = array([[0]*ndims], dtype='float32') G = sparse_matrix_operator(ro_K, grid_shape=spatial_dims, nhood_shape=nhood_shape, osfactor=osfactor, combi=combi, slice_prof_coef=slice_prof_coef) ro = G.T * ro_data n = sqrt(G.shape[1]) ro = reshape(ro, (n,n)) #if osfactor > 1 and ncrop == None: # ncrop = int((spatial_dims[0]/osfactor) * (osfactor - 1) / 2) ro = fftshift(abs(ifftn(fftshift(ro, axes=axes), axes=axes)), axes=axes) # transform to image if ncrop > 0: ro = ro[ncrop:-ncrop, ncrop:-ncrop] #print 'rolloff shape:', ro.shape ro = ro / ro.max() # normalize ro[ro < threshold] = 1.0 #ro_max = ro.max() #ro[ro < threshold*ro_max] = 1.0 ro = 1.0 / ro #ro = ro**2 #print 'TOOK OUT SQUARED RO' #ro = ro / ro.max() return ro
def plot_transfer_function(self, ds): ax1 = pl.subplot(211) ax2 = pl.subplot(212) Hw = self.transfer_function(ds.omega) ax1.plot(fftp.fftshift(ds.f), np.abs(fftp.fftshift(Hw)) ** 2, "k--") ax2.plot(fftp.fftshift(ds.f), np.angle(fftp.fftshift(Hw)), "k--")
def genwavenumber(nlon): if (nlon%2 == 0): wavenumber = fftpack.fftshift(fftpack.fftfreq(nlon)*nlon)[1:] else: wavenumber = fftpack.fftshift(fftpack.fftfreq(nlon)*nlon) return wavenumber
def pulseSpectrum(t, SVEAAmp, lambdaZero = 0.0, units = 'nm'): ''' Compute the spectrum of o SVEA pulse center at lambdaZero * t: time vector * SVEAAmp: SVEA enveloppe of the pulse * lambdaZero: center of the pulse [m] * units: Units of the output ['nm','um','m'] ''' C = 2.99792458e-4 nt = len(t) dt = t[1] - t[0] T = t.max()-t.min() w = wspace(T,nt) vs = fftpack.fftshift(w/(2*pi)) # Assign uniScale unitScale = { 'nm': lambda: 1.0e9, 'um': lambda: 1.0e6, 'm': lambda: 1.0 }[units]() if lambdaZero != 0.0: wavelength = ( 1.0/( (vs/C)+1.0/(lambdaZero) ) )*unitScale return [wavelength, fftpack.fftshift(pow(abs(dt*fftpack.fft(SVEAAmp)/sqrt(2.0*pi)),2))] else: return [vs, fftpack.fftshift(pow(abs(dt*fftpack.fft(SVEAAmp)/sqrt(2.0*pi)),2))]
def __init__(self, x, y, s, detrend=True, window=False, **kwargs): # r-space self.x = np.asanyarray(x) self.y = np.asanyarray(y) self.s = np.asanyarray(s) assert len(self.x.shape) == 2 assert self.x.shape == self.y.shape == self.s.shape assert self.x.size == self.y.size == self.s.size # r-space spacing self.dx = self._delta(self.x, np.index_exp[0,0], np.index_exp[1,0]) self.dy = self._delta(self.y, np.index_exp[0,0], np.index_exp[0,1]) # r-space samples self.n0 = self.x.shape[0] self.n1 = self.x.shape[1] # r-space lengths self.lx = self.n0 * self.dx self.ly = self.n1 * self.dy # k-space u = fftpack.fftshift(fftpack.fftfreq(self.n0)) v = fftpack.fftshift(fftpack.fftfreq(self.n1)) self.u, self.v = np.meshgrid(u, v, indexing='ij') # k-space spacing self.du = self._delta(self.u, np.index_exp[0,0], np.index_exp[1,0]) self.dv = self._delta(self.v, np.index_exp[0,0], np.index_exp[0,1]) # k-space lengths self.lu = self.n0 * self.du self.lv = self.n1 * self.dv # nyquist try: self.nyquist_u = 0.5/self.dx except ZeroDivisionError: self.nyquist_u = 0.0 try: self.nyquist_v = 0.5/self.dy except ZeroDivisionError: self.nyquist_v = 0.0 self.k = np.sqrt(self.u**2 + self.v**2) # detrend the signal if detrend: self.s = signal.detrend(self.s) # apply window to signal if window: self._window() self.s = self.s * self.window # compute the FFT self.fft = fftpack.fftshift(fftpack.fft2(self.s)) self.power = self.fft.real**2 + self.fft.imag**2
def sineSubtraction(x, N, H, sfreq, smag, sphase, fs): """ Subtract sinusoids from a sound x: input sound, N: fft-size, H: hop-size sfreq, smag, sphase: sinusoidal frequencies, magnitudes and phases returns xr: residual sound """ hN = N/2 # half of fft size x = np.append(np.zeros(hN),x) # add zeros at beginning to center first window at sample 0 x = np.append(x,np.zeros(hN)) # add zeros at the end to analyze last sample bh = blackmanharris(N) # blackman harris window w = bh/ sum(bh) # normalize window sw = np.zeros(N) # initialize synthesis window sw[hN-H:hN+H] = triang(2*H) / w[hN-H:hN+H] # synthesis window L = sfreq.shape[0] # number of frames, this works if no sines xr = np.zeros(x.size) # initialize output array pin = 0 for l in range(L): xw = x[pin:pin+N]*w # window the input sound X = fft(fftshift(xw)) # compute FFT Yh = UF_C.genSpecSines(N*sfreq[l,:]/fs, smag[l,:], sphase[l,:], N) # generate spec sines Xr = X-Yh # subtract sines from original spectrum xrw = np.real(fftshift(ifft(Xr))) # inverse FFT xr[pin:pin+N] += xrw*sw # overlap-add pin += H # advance sound pointer xr = np.delete(xr, range(hN)) # delete half of first window which was added in stftAnal xr = np.delete(xr, range(xr.size-hN, xr.size)) # delete half of last window which was added in stftAnal return xr
def fft(self, nfft=None, ssb=False): """ Computes the Fast Fourier transform of the signal using :func:`scipy.fftpack.fft` function. The Fourier transform of a time series function is defined as: .. math:: \mathcal{F}(y) ~=~ \int_{-\infty}^{\infty} y(t) e^{-2 \pi j f t}\,dt Parameters ---------- nfft : int, optional Specify the number of points for the FFT. The default is the length of the time series signal. ssb : boolean, optional If true, returns only the single side band (components corresponding to positive frequency). Returns ------- : Signal The FFT of the signal. """ if nfft is None: nfft = self.size uf = Signal(fftshift(fft(self.values, n=nfft)), index=fftshift(fftfreq(nfft, self.ts))) return uf[uf.index >= 0] if ssb else uf
def plot_q_qhat(q, t): # Plot Potential Vorticity plt.clf() plt.subplot(2,1,1) plt.pcolormesh(xx/1e3,yy/1e3,q) plt.colorbar() plt.axes([-Lx/2e3, Lx/2e3, -Ly/2e3, Ly/2e3]) name = "PV at t = %5.2f" % (t/(3600.0*24.0)) plt.title(name) # compute power spectrum and shift ffts qe = np.vstack((q0,-np.flipud(q))) qhat = np.absolute(fftn(qe)) kx = fftshift((parms.ikx/parms.ikx[0,1]).real) ky = fftshift((parms.iky/parms.iky[1,0]).real) qhat = fftshift(qhat) Sx, Sy = int(parms.Nx/2), parms.Ny Sk = 1.5 # Plot power spectrum plt.subplot(2,1,2) #plt.pcolor(kx[Sy:Sy+20,Sx:Sx+20],ky[Sy:Sy+20,Sx:Sx+20],qhat[Sy:Sy+20,Sx:Sx+20]) plt.pcolor(kx[Sy:int(Sk*Sy),Sx:int(Sk*Sx)],ky[Sy:int(Sk*Sy),Sx:int(Sk*Sx)], qhat[Sy:int(Sk*Sy),Sx:int(Sk*Sx)]) plt.axis([0, 10, 0, 10]) plt.colorbar() name = "PS at t = %5.2f" % (t/(3600.0*24.0)) plt.title(name) plt.draw()
def find_foci(evt, type,key,type2,key2,minPhase=-500000, maxPhase=500000, steps=101, field_of_view_rad=100, wavelength=1.053, CCD_S_DIST=0.375, PX_SIZE=75e-6): img = evt[type][key].data centroids = evt[type2][key2].data Nfoci = centroids.shape[0] Xrange, Yrange = img.shape Npixel = field_of_view_rad p = numpy.linspace(-Xrange/2, Xrange/2-1, Xrange) q = numpy.linspace(-Yrange/2, Yrange/2-1, Yrange) pp, qq = numpy.meshgrid(p, q) phase_matrix = (2*numpy.pi/wavelength)*numpy.sqrt(1-((PX_SIZE/CCD_S_DIST)**2)*(qq**2 + pp**2)) prop_length = numpy.linspace(minPhase, maxPhase, steps) variance = numpy.zeros([steps, Nfoci]) # shift stuff for performance reasons img_shifted = fftshift(img) phase_matrix_shifted = fftshift(phase_matrix) for idx, phase in enumerate(prop_length): img_propagated = img_shifted * numpy.exp(1.j*phase*phase_matrix_shifted) recon = fftshift(ifft2(img_propagated)) for CC in numpy.arange(Nfoci): centerx, centery = centroids[CC, :] ###print centerx, centery reconcut = numpy.abs(recon[numpy.max([0, centerx-Npixel-1]).astype(int): numpy.min([Xrange-1, centerx+Npixel]).astype(int), numpy.max([0, centery-Npixel-1]).astype(int): numpy.min([Yrange-1, centery+Npixel]).astype(int)]) variance[idx, CC] = reconcut.var() focus_distance = numpy.zeros(Nfoci) CC_size = numpy.zeros(Nfoci) focused_CC = numpy.zeros(4*Npixel**2 * Nfoci).reshape(Nfoci, 2*Npixel, 2*Npixel) for CC in numpy.arange(Nfoci): ind_max = numpy.argmax(variance[:, CC]) tmp = variance[:, CC] # get max which is not at border loc_max_bool = numpy.r_[True, tmp[1:] > tmp[:-1]] & numpy.r_[tmp[:-1] > tmp[1:], True] loc_max_bool[0] = False loc_max_bool[-1] = False ind_max = numpy.argmax(tmp*loc_max_bool) focus_distance[CC] = prop_length[ind_max] img_propagated = img_shifted * numpy.exp(1.j * focus_distance[CC] * phase_matrix_shifted) recon = fftshift(ifft2(img_propagated)) centerx, centery = centroids[CC, :] reconcut = numpy.real(recon[numpy.max([0, centerx-Npixel]).astype(int): numpy.min([Xrange-1, centerx+Npixel]).astype(int), numpy.max([0, centery-Npixel]).astype(int): numpy.min([Yrange-1, centery+Npixel]).astype(int)]) focused_CC[CC, 0:reconcut.shape[0], 0:reconcut.shape[1]] = reconcut CC_size[CC] = numpy.sum(get_CC_size(reconcut)) if len(focused_CC): add_record(evt["analysis"], "analysis", "focused_CC", focused_CC[0]) add_record(evt["analysis"], "analysis", "focus distance", focus_distance) add_record(evt["analysis"], "analysis", "CC_size", CC_size) add_record(evt["analysis"], "analysis", "propagation length", prop_length)
def fourierTransform(self, fromPos, toPos, only = []): self.checkToPos(toPos) if len(only) > 0: self.allFid[toPos] = np.array([fftshift(fft(self.allFid[fromPos][fidIndex])) for fidIndex in only]) else: self.allFid[toPos] = np.array([fftshift(fft(fid)) for fid in self.allFid[fromPos]]) self.frequency = np.linspace(-self.sweepWidthTD2/2,self.sweepWidthTD2/2,len(self.allFid[fromPos][0]))
def f2(file1, file2): from scipy.fftpack import fftshift (imgarr1,w,h) = pgm.pgmread(file1) (imgarr2,w,h) = pgm.pgmread(file2) imgarr1 = np.float32(imgarr1) imgarr2 = np.float32(imgarr2) print imgarr1.shape, imgarr2.shape # dftArr1 = dft_2d_from_1d(imgarr1) dftArr2 = dft_2d_from_1d(imgarr2) # absArr1 = np.abs(dftArr1) absArr2 = np.abs(dftArr2) phaseArr1 = np.angle(dftArr1) phaseArr2 = np.angle(dftArr2) # newArr1 = absArr1 * np.exp(1j * phaseArr2) newArr2 = absArr2 * np.exp(1j * phaseArr1) #print 'Error : ', np.sum((newArr1 - dftArr1)**2) #print 'Error : ', np.sum((newArr2 - dftArr2)**2) # idftArr1 = idft_2d_from_1d(newArr1) idftArr2 = idft_2d_from_1d(newArr2) idftArr1 = np.round(idftArr1.real) idftArr2 = np.round(idftArr2.real) # dftArrAbs1 = np.abs(fftshift(dftArr1)) dftArrAbs2 = np.abs(fftshift(dftArr2)) # plt.figure() plt.subplot(121) plt.title(file1) plt.imshow(imgarr1, cmap=cm.gray) #plt.colorbar() plt.subplot(122) plt.title(file2) plt.imshow(imgarr2, cmap=cm.gray) #plt.colorbar() # plt.figure() plt.subplot(121) plt.title('DFT of ' + file1) plt.imshow(np.int32(np.log(dftArrAbs1)), cmap=cm.gray) plt.colorbar() plt.subplot(122) plt.title('DFT of ' + file2) plt.imshow(np.int32(np.log(dftArrAbs2)), cmap=cm.gray) plt.colorbar() # plt.figure() plt.subplot(121) plt.title('IDFT1') plt.imshow(np.int32(idftArr1), cmap=cm.gray) #plt.colorbar() plt.subplot(122) plt.title('IDFT2') plt.imshow(np.int32(idftArr2), cmap=cm.gray)
def plot_fft_shifted(x, y, *args, **kwargs): import pylab symmetric = False if "symmetric" in kwargs: symmetric = kwargs.pop("symmetric") if symmetric and np.mod(x.shape[0],2)==0: pylab.plot(fftp.fftshift(x)[1:], fftp.fftshift(y)[1:], *args, **kwargs) else: pylab.plot(fftp.fftshift(x), fftp.fftshift(y), *args, **kwargs)
def test_definition(self): x = [0,1,2,3,4,-4,-3,-2,-1] y = [-4,-3,-2,-1,0,1,2,3,4] assert_array_almost_equal(fftshift(x),y) assert_array_almost_equal(ifftshift(y),x) x = [0,1,2,3,4,-5,-4,-3,-2,-1] y = [-5,-4,-3,-2,-1,0,1,2,3,4] assert_array_almost_equal(fftshift(x),y) assert_array_almost_equal(ifftshift(y),x)
def plot_all_domains(inputfile, fs): #fs= float(50/3 * 1000000.0) fs=25*1000000.0 if inputflag==1: [x,y, mag, phase,z] = filereader(inputfile,int(fs)) del x, y, phase #mag=butter_lowpass_filter(mag, upper_cut, fs, 6) #mag = butter_bandpass_filter(mag, lower_cut, upper_cut, fs, order=5) #print "done with bandpass filter" ceps, _ = complex_cepstrum(mag) t = [i for i in range(0,len(mag))] fig = plt.figure(figsize=(12,10)) ax0 = fig.add_subplot(311) ax0.plot(t, mag) ax0.set_ylim(0,0.18) ax0.set_xlabel('[time domain] time (1 unit=10^-7 sec)') ax0.set_ylabel('amplitude modulus') #ax0.set_xlim(0.0, 0.05) ax1 = fig.add_subplot(312) ax1.plot(t, ceps) ax1.set_xlabel('[cepstral domain] quefrency in 1 unit') ax1.set_ylabel('magnitude') ax1.set_ylim(-80,80) ax1.set_xscale('log') ax2 = fig.add_subplot(313) ''' f, Pxx_den = signal.periodogram(mag, fs) ax2.plot(f, Pxx_den) ax2.set_xlabel('frequency') ax2.set_ylabel('magnitude') ax2.set_ylim(0,7e-8) ax2.set_xscale('log') plt.savefig(outputfile+'.pdf') ''' from scipy.fftpack import fft, fftfreq, fftshift N=len(mag) freqs = fftfreq(N, 1.0/fs) freqs = fftshift(freqs) yf= 1.0/N *fft(mag) yf = fftshift(yf) ax2.plot(freqs, np.abs(yf)) #print "freqs is ", freqs #print "FFT vals are", np.abs(yf) ax2.set_xlabel('[spectral domain] frequency') ax2.set_ylabel('magnitude (log)') ax2.set_yscale('log') ax2.set_xlim(0,500000) ax2.set_ylim(10e-9,10e-1) plt.savefig(outputfile+'.pdf')
def test_Eady(self, atol=5e-2, nz=20, Ah=0.): """ Eady setup """ ########### # prepare parameters for Eady ########### nz = nz zin = np.arange(nz+1, dtype=np.float64)/nz N2 = np.full(nz, 1.) f0 = 1. beta = 0. Nx = 10 Ny = 1 dx = 1e-1 dy = 1e-1 k = fft.fftshift( fft.fftfreq(Nx, dx) ) l = fft.fftshift( fft.fftfreq(Ny, dy) ) vbar = np.zeros(nz+1) ubar = zin etax = np.zeros(2) etay = np.zeros(2) z, growth_rate, vertical_modes = \ modes.instability_analysis_from_N2_profile( .5*(zin[1:]+zin[:-1]), N2, f0, beta, k, l, zin, ubar, vbar, etax, etay, depth=1., sort='LI', num=2 ) self.assertEqual(nz+1, vertical_modes.shape[0], msg='modes array must be in the right shape') self.assertTrue(np.all( np.diff( growth_rate.reshape((growth_rate.shape[0], len(k)*len(l))).imag.max(axis=1) ) <= 0.), msg='imaginary part of modes should be descending') mode_amplitude1 = (np.absolute(vertical_modes[:, 0])**2).sum(axis=0) self.assertTrue(np.allclose(1., mode_amplitude1), msg='mode1 should be normalized to amplitude of 1 at all horizontal wavenumber points') mode_amplitude2 = (np.absolute(vertical_modes[:, 1])**2).sum(axis=0) self.assertTrue(np.allclose(1., mode_amplitude2), msg='mode2 should be normalized to amplitude of 1 at all horizontal wavenumber points') ######### # Analytical solution for Eady growth rate ######### growthEady = np.zeros(len(k)) for i in range(len(k)): if (k[i]==0) or ((np.tanh(.5*k[i])**-1 - .5*k[i]) * (.5*k[i] - np.tanh(.5*k[i])) < 0): growthEady[i] = 0. else: growthEady[i] = ubar.max() * np.sqrt( (np.tanh(.5*k[i])**-1 - .5*k[i]) * (.5*k[i] - np.tanh(.5*k[i])) ) self.assertTrue( np.allclose(growth_rate.imag[0, 0, :], growthEady, atol=atol), msg='The numerical growth rates should be close to the analytical Eady solution' )
def gravity(self): ''' Evaluate the gravitational field, with a call to Bose.gravity() Gravitaional field is the convolution of the density and the log of distance ''' den = abs(self.psi)**2. #calculate the probability density #return the convolution, after multiplying by scaled gravity and #correcting for grid scaling (due to 2 forward FFTs, and only one inverse return self.G*self.dx*self.dy*(ff.fftshift(ff.ifft2(ff.fft2(ff.fftshift(den) )*abs(ff.fft2(ff.fftshift(-self.log))))))
def alex_power_spec(map1, map2=None, deltal = 1, pixsize = 5.0): dims = np.shape(map1) if (map2 != None): spec = fftpack.fftshift(fftpack.fft2(map1)) * np.conj(fftpack.fftshift(fftpack.fft2(map2))) * (pi*pixsize/10800./60.)**2.0 * (dims[0]*dims[1]) else: spec = np.abs(fftpack.fftshift(fftpack.fft2(map1))*(pi*pixsize/10800./60.))**2.0 * (dims[0]*dims[1]) spec1d = radial_data(spec, annulus_width = deltal) return spec1d
def _FilterElectrons(self,sign): ''' Routine that uses the Fourier transform to filter positrons/electrons Options: sign=1 Leaves electrons sign=-1 Leaves positrons ''' print ' ' print ' Filter Electron routine ' print ' ' min_Px = np.pi*self.X_gridDIM/(2*self.min_X) dPx = 2*np.abs(min_Px)/self.X_gridDIM px_Vector = fftpack.fftshift ( np.linspace(min_Px, np.abs(min_Px) - dPx, self.X_gridDIM )) min_Py = np.pi*self.Y_gridDIM/(2*self.min_Y) dPy = 2*np.abs(min_Py)/self.Y_gridDIM py_Vector = fftpack.fftshift ( np.linspace(min_Py, np.abs(min_Py) - dPy, self.Y_gridDIM )) px = px_Vector[np.newaxis,:] py = py_Vector[:,np.newaxis] sqrtp = sign*2*np.sqrt( self.mass*self.mass*self.c**4 + self.c*self.c*px*px + self.c*self.c*py*py ) aa = sign*self.mass*self.c*self.c/sqrtp bb = sign*(px/sqrtp - 1j*py/sqrtp) cc = sign*(px/sqrtp + 1j*py/sqrtp) ElectronProjector = np.matrix([ [0.5+aa , 0. , 0. , bb ], [0. , 0.5+aa , cc , 0. ], [0. , bb , 0.5-aa , 0. ], [cc , 0. , 0. , 0.5-aa] ]) psi1_fft = fftpack.fft2( self.Psi1_init ) psi2_fft = fftpack.fft2( self.Psi2_init ) psi3_fft = fftpack.fft2( self.Psi3_init ) psi4_fft = fftpack.fft2( self.Psi4_init ) psi1_fft_electron = ElectronProjector[0,0]*psi1_fft + ElectronProjector[0,1]*psi2_fft +\ ElectronProjector[0,2]*psi3_fft + ElectronProjector[0,3]*psi4_fft psi2_fft_electron = ElectronProjector[1,0]*psi1_fft + ElectronProjector[1,1]*psi2_fft +\ ElectronProjector[1,2]*psi3_fft + ElectronProjector[1,3]*psi4_fft psi3_fft_electron = ElectronProjector[2,0]*psi1_fft + ElectronProjector[2,1]*psi2_fft +\ ElectronProjector[2,2]*psi3_fft + ElectronProjector[2,3]*psi4_fft psi4_fft_electron = ElectronProjector[3,0]*psi1_fft + ElectronProjector[3,1]*psi2_fft +\ ElectronProjector[3,2]*psi3_fft + ElectronProjector[3,3]*psi4_fft self.Psi1_init = fftpack.ifft2( psi1_fft_electron ) self.Psi2_init = fftpack.ifft2( psi2_fft_electron ) self.Psi3_init = fftpack.ifft2( psi3_fft_electron ) self.Psi4_init = fftpack.ifft2( psi4_fft_electron )
def myconv2(A, B, zeropadding = False): # TO DO: zero padding to get rid of aliasing! if zeropadding: origdim = A.shape nextpow = pow(2, numpy.ceil(numpy.log(numpy.max(origdim))/numpy.log(2))+1) A = zeropad(A, nextpow.astype(int), nextpow.astype(int)) B = zeropad(B, nextpow.astype(int), nextpow.astype(int)) output = fftshift(ifft2( numpy.multiply(fft2(fftshift(A)), fft2(fftshift(B)) ))) if zeropadding: output = output[nextpow/2 - origdim[0]/2: nextpow/2 + origdim[0]/2,nextpow/2 - origdim[1]/2: nextpow/2 + origdim[1]/2] return output
def add_noise(self, temp): """ Add per-pixel Gaussian random noise. """ self.noise = random.normal(0,temp,[self.npix,self.npix]) self.Fnoise = ft.fftshift(ft.fft2(self.noise)) self.Txy = self.Txy + self.noise self.Fxy = ft.fftshift(ft.fft2(self.Txy)) self.Clnoise = ((temp*self.mapsize_rad/self.npix)*self.Bl)**-2.e0 self.Pknoise = np.interp(self.modk, self.k, self.Clnoise)
def pdf(self,s): values=s*self.filter #create the signal volume Sq=np.zeros((self.sz,self.sz,self.sz)) #fill q-space for i in range(self.dn): qx,qy,qz=self.q[i] Sq[qx,qy,qz]+=values[i] #apply fourier transform Pr=fftshift(np.abs(np.real(fftn(fftshift(Sq),(self.sz,self.sz,self.sz))))) return Pr
def fftshift(x): # Wrapper for fftshift that handles CXData objects if isinstance(x, CXData): l=[] for i in xrange(len(x)): l.append(spf.fftshift(x.data[i])) return CXData(data=l) elif isinstance(x, np.ndarray): return spf.fftshift(x) else: raise Exception('Unknown data type passed to fftshift')
def test_inverse(self): for n in [1,4,9,100,211]: x = random((n,)) assert_array_almost_equal(ifftshift(fftshift(x)),x)
# Plot the window and its frequency response: from scipy import signal from scipy.fftpack import fft, fftshift import matplotlib.pyplot as plt window = signal.cosine(51) plt.plot(window) plt.title("Cosine window") plt.ylabel("Amplitude") plt.xlabel("Sample") plt.figure() A = fft(window, 2048) / (len(window) / 2.0) freq = np.linspace(-0.5, 0.5, len(A)) response = 20 * np.log10(np.abs(fftshift(A / abs(A).max()))) plt.plot(freq, response) plt.axis([-0.5, 0.5, -120, 0]) plt.title("Frequency response of the cosine window") plt.ylabel("Normalized magnitude [dB]") plt.xlabel("Normalized frequency [cycles per sample]") plt.show()
# Simple Moving Average low pass filter ntaps = 1000 coeffs = np.ones(ntaps) filt_out = sig.lfilter(coeffs, ntaps, out) plt.plot(filt_out) # exponential MAF alpha = 0.999 filt_out2 = sig.lfilter([1 - alpha], [1, -alpha], out) plt.plot(filt_out2) # frequency response of simple moving avg w, h = sig.freqz(coeffs, whole=True, fs=Fs) plt.figure() db_mag = hf.db(h) plt.plot((w - Fs / 2) / 1e3, fft.fftshift(db_mag), label='simple moving avg') plt.xlabel('Frequency [kHz]') plt.ylabel('Magnitude [dB]') plt.title('Filter Frequency Response') # both mag and phase plot # hf.responsePlot(w, h, 'simple moving avg frequency response') # frequency response of simple moving avg w, h = sig.freqz([1 - alpha], [1, -alpha], whole=True, fs=Fs) # plt.figure() db_mag = hf.db(h) plt.plot((w - Fs / 2) / 1e3, fft.fftshift(db_mag), label='exponential MAF') plt.legend() # example spectrum plt.figure()
for i in np.arange(1990, 2021, 1): r.append(Time('{}-01-01 00:00:00'.format(i), format='iso').jd - 2451544.5) r = np.array(r) ######################################################################### x = eph[0] y = eph[7] # number of signal points N = len(eph[0]) # sample spacing T = (x.max() - x.min()) / N yf = fft(y) xf = fftfreq(N, T) xf = fftshift(xf) yplot = fftshift(yf) fig, ax = plt.subplots(2, 1) ax[0].plot(x, y) ax[0].set_xlabel('Time') ax[0].set_ylabel('Amplitude') #ax[0].set_ticks(r) #ax[0].set_ticklabels(['{}'.format(i) for i in np.arange(1990,2021,1)], rotation=90) ax[1].plot(xf, 1.0 / N * np.abs(yplot), 'r') # plotting the spectrum ax[1].set_xlabel(r'Freq ($day^{-1}$)') ax[1].set_ylabel('|Y(freq)|') #plt.plot(xf, 1.0/N * np.abs(yplot)) plt.grid() ax[1].set_xlim(0.00, 0.01) plt.savefig('freq_x.png', dpi=100)
import cv2 import numpy, math import scipy.fftpack as fftim from PIL import Image # Opening the image and converting it to grayscale. a = Image.open('../Figures/endothelium.png').convert('L') # Performing FFT. b = fftim.fft2(a) # Shifting the Fourier frequency image. c = fftim.fftshift(b) # Intializing variables for convolution function. M = c.shape[0] N = c.shape[1] # H is defined and values in H are initialized to 1. H = numpy.ones((M, N)) center1 = M / 2 center2 = N / 2 d_0 = 30.0 # cut-off radius t1 = 2 * d_0 # Defining the convolution function for GHPF. for i in range(1, M): for j in range(1, N): r1 = (i - center1)**2 + (j - center2)**2 # Euclidean distance from # origin is computed. r = math.sqrt(r1) # Using cut-off radius to # eliminate low frequency.
def profileFit(r, Nmin, mu): """ This function calculates the power spectrum profile using a shifted exponential decay model. """ f = N0 * np.exp(-mu * r) + Nmin return f #--Main Program testImage = skio.imread('testBiofilmImage.tif') # perform the Fourier Transform fft1 = scfft.fft2(testImage) fft2 = scfft.fftshift(fft1) # calculate the power spectrum ps = np.abs(fft2) ps = 20 * np.log10(ps) ps = ps.astype(int) h, w = ps.shape # make sure all power spectrum values greater than or equal to # zero for r in range(h): for c in range(w): if ps[r, c] < 0: ps[r, c] = 0 # define angles thetaMax = 85
y1_filt[len(y1) - 1]) / 3 y2_filt[len(y2) - 2] = (y2_filt[len(y2) - 3] + y2_filt[len(y2) - 2] + y2_filt[len(y2) - 1]) / 3 # Transformada de fourier: # yn_fft x_fft: realizam a trasnformada de fourier no espectro de frequência # yn_fft_plot x_fft_plot: inicialmente é usado um 'shift'(deslocamento) para jogar as # componentes negativas que estão após as componentes positivas quando usamos # numpy.fft.fftshift, para o início do array. # yn_fft_plot x_fft_plot: são usados novamente para agora selecionar somente as frequências # positivas e suas componentes y1_fft = fft(y1_filt) y2_fft = fft(y2_filt) x_fft = fftfreq(N, T) x_fft_plot = fftshift(x_fft) x_fft_plot = x_fft_plot[N / 2:N] y1_fft_plot = fftshift(y1_fft) y2_fft_plot = fftshift(y2_fft) y1_fft_plot = np.abs(y1_fft_plot[N / 2:N]) y2_fft_plot = np.abs(y2_fft_plot[N / 2:N]) # Transformada de fourier na metade de todo período: N_half = int(N / 2) t_half = float(t_final + t_inicial) / 2 x_half_fft = fftfreq(N_half, T) x_half_fft = fftshift(x_half_fft) x_half_fft = x_half_fft[math.floor(N_half / 2):N_half] y1_half_1_fft = fft(y1_filt[0:N_half])
def get_shifted_fourier_chart(img): fourier = fftpack.fft2(img) fourier_shifted = fftpack.fftshift( fourier ) # shift so that low spatial frequencies are in the center. fourier_abs = np.abs(fourier_shifted) #This array that we use is the absolute value of the shifted fourier transform return fourier_shifted, fourier_abs
def reconstruction(self): """main reconstruction function""" #initiate time counters timestart = time.time() timershow = 0 #for measuring the time interval from the last results indication Showstep = 0.5 #time interval between showing results timercheck = 0 #for measuring the time interval from the last inputs check Checkstep = 0.25 #time interval between checking inputs (including stop) while self.Stop and self.Results['Step'] < self.Args[ 'ret_iterations'] and self.Results['G'] > self.Args['G_goal']: (self.Results['pulse'], self.Results['gate'], self.Results['G'], self.Results['frog_out']) = PCGPA.PCGPA_step( self.Results['pulse'], self.Results['gate'], self.Results['frog_in'], Type=self.Args['type']) if self.Args['fix_fund_spec']: """fixing the fundumental spectrum""" pulse_w = np.sqrt(self.Results['Sfund']) * np.exp( 1j * np.angle(fftshift(fft(fftshift(self.Results['pulse']))))) pulse_t = ifftshift(ifft(ifftshift(pulse_w))) if self.Args['type'] == 'SHG-FROG': gate_t = np.copy(pulse_t) elif self.Args['type'] == 'TG-FROG': gate_t = np.abs(np.abs(np.copy(pulse_t)))**2 self.Results['pulse'] = pulse_t #self.Results['pulse_w']=pulse_w self.Results['gate'] = gate_t #recalculate frog_sim and G for the corrected pulse (self.Results['G'], self.Results['frog_out']) = PCGPA.PCGPA_G( self.Results['pulse'], self.Results['gate'], self.Results['frog_in']) if self.Results['Step'] == 0: self.Results['G_best'] = self.Results['G'] self.Results['pulse_best'] = self.Results['pulse'] self.Results['gate_best'] = self.Results['gate'] self.Results['frog_out_best'] = self.Results['frog_out'] self.Results['pulse_w_best'] = fftshift( fft(fftshift(self.Results['pulse_best']))) #save the best reconstruction if self.Results['G'] < self.Results['G_best'] and self.Results[ 'Step'] > 0: (self.Results['pulse'], self.Results['gate']) = PCGPA.shift2zerodelay( self.Results['pulse'], self.Results['gate']) self.Results['G_best'] = self.Results['G'] self.Results['pulse_best'] = self.Results['pulse'] self.Results['gate_best'] = self.Results['gate'] self.Results['frog_out_best'] = self.Results['frog_out'] #shift to 0 delay self.Results['Time'] = time.time() - timestart if (self.Results['Time'] - timershow) > Showstep: timershow = self.Results['Time'] self.Results['pulse_w_best'] = fftshift( fft(fftshift(self.Results['pulse_best']))) self.showresults() if (self.Results['Time'] - timercheck) > Checkstep: timercheck = self.Results['Time'] self.app.processEvents() if self.Results['Step'] == 0: self.showresults() self.Results['Step'] += 1
def update_data(self, x, taps, psd, syms, table): try: eqdata_key = 'dtv_atsc_equalizer0::taps' symdata_key = 'dtv_atsc_equalizer0::data' rs_nump_key = 'dtv_atsc_rs_decoder0::num_packets' rs_numbp_key = 'dtv_atsc_rs_decoder0::num_bad_packets' rs_numerrs_key = 'dtv_atsc_rs_decoder0::num_errors_corrected' vt_metrics_key = 'dtv_atsc_viterbi_decoder0::decoder_metrics' snr_key = 'probe2_f0::SNR' data = self.radio.getKnobs([]) eqdata = data[eqdata_key] symdata = data[symdata_key] rs_num_packets = data[rs_nump_key] rs_num_bad_packets = data[rs_numbp_key] rs_num_errors_corrected = data[rs_numerrs_key] vt_decoder_metrics = data[vt_metrics_key] snr_est = data[snr_key] vt_decoder_metrics = scipy.mean(vt_decoder_metrics.value) self._viterbi_metric.pop() self._viterbi_metric.insert(0, vt_decoder_metrics) except: sys.stderr.write("Lost connection, exiting") sys.exit(1) ntaps = len(eqdata.value) taps.set_ydata(eqdata.value) taps.set_xdata(xrange(ntaps)) self._sp0.set_xlim(0, ntaps) self._sp0.set_ylim(min(eqdata.value), max(eqdata.value)) fs = 6.25e6 freq = scipy.linspace(-fs / 2, fs / 2, 10000) H = fftpack.fftshift(fftpack.fft(eqdata.value, 10000)) HdB = 20.0 * scipy.log10(abs(H)) psd.set_ydata(HdB) psd.set_xdata(freq) self._sp1.set_xlim(0, fs / 2) self._sp1.set_ylim([min(HdB), max(HdB)]) self._sp1.set_yticks([min(HdB), max(HdB)]) self._sp1.set_yticklabels(["min", "max"]) nsyms = len(symdata.value) syms.set_ydata(symdata.value) syms.set_xdata(nsyms * [ 0, ]) self._sp2.set_xlim([-1, 1]) self._sp2.set_ylim([-10, 10]) per = float(rs_num_bad_packets.value) / float(rs_num_packets.value) ber = float(rs_num_errors_corrected.value) / float( 187 * rs_num_packets.value) table._cells[(1, 0)]._text.set_text("{0}".format(rs_num_packets.value)) table._cells[(1, 1)]._text.set_text("{0:.2g}".format(ber)) table._cells[(1, 2)]._text.set_text("{0:.2g}".format(per)) table._cells[(1, 3)]._text.set_text("{0:.1f}".format( scipy.mean(self._viterbi_metric))) table._cells[(1, 4)]._text.set_text("{0:.4f}".format(snr_est.value[0])) return (taps, psd, syms, table)
import scipy.misc import numpy, math import scipy.fftpack as fftim from scipy.misc.pilutil import Image # opening the image and converting it to grayscale a = Image.open('../Figures/endothelium.png').convert('L') # a is converted to an ndarray b = scipy.misc.fromimage(a) # performing FFT c = fftim.fft2(b) # shifting the Fourier frequency image d = fftim.fftshift(c) # intializing variables for convolution function M = d.shape[0] N = d.shape[1] # H is defined and # values in H are initialized to 1 H = numpy.ones((M, N)) center1 = M / 2 center2 = N / 2 d_0 = 30.0 # cut-off radius # defining the convolution function for IHPF for i in range(1, M): for j in range(1, N): r1 = (i - center1)**2 + (j - center2)**2 # euclidean distance from # origin is computed r = math.sqrt(r1)
############################################################# # 4. Data & Globals ############################################################# data_N = 40 data_m = m_e.value data_L = 0.1e-3 x_samples = 10000 x_spacing = (2. * data_L) / x_samples data_X = np.linspace(0, x_spacing * x_samples, x_samples) data_T = np.linspace(0, 200e-6, 500) data_K = fftshift(fftfreq(x_samples, x_spacing)) CACHE = { 'psiT': {}, 'psikT': {} } ############################################################# # 5. Lab-Specific Functions ############################################################# def terminate(): # Any memory clearing logic and stuff global CACHE purge_tree(CACHE)
def __init__(self, rho=False, K=False, N=256, C=2e-6, f=5, kernel=True, Mtot=1., L=1., hbar_=1e-6, mpart=4e-6, hbar=4e-12, dt=1e-3, label='g'): self.label = label self.N = N # grid cells self.hbar_ = hbar_ self.hbar = hbar self.mpart = mpart # density matrix, NxN complex numbers, diagonal sum is 1 NOT Mtot if rho: self.rho = rho else: self.rho = np.zeros((N, N)) + 0j self.C = C # poisson constant self.Mtot = Mtot # total mass self.L = L # side length self.dx = L / N self.x = self.dx * (.5 + np.arange(-self.N / 2, self.N / 2)) self.sig_x = self.dx * f self.T_scale = np.pi * 2. / np.sqrt(np.abs( C * Mtot / L)) # time scaling factor self.kx = 2 * np.pi * sp.fftfreq(N, d=L / N) Kj, Ki = np.meshgrid(-self.kx, self.kx) dK2 = Ki**2 - Kj**2 self.HK = np.exp(self.hbar_ * dK2 * dt * self.T_scale / 4. * 1.0j) #kinetic term for Hamiltonian self.u = hbar_ * sp.fftshift(self.kx) self.du = self.u[1] - self.u[0] self.omega0 = np.sqrt(np.abs(self.C * self.Mtot / self.L)) self.u_c = self.L * self.omega0 / (2. * np.pi) self.dt = dt self.K = None if kernel: if K is None: self.setKernel() else: self.refer2Kernel(K) # Husimi kernel
def getRhoU(self): rho_u = sp.ifft(sp.fft(sp.ifft(sp.fft(self.rho, axis=3), axis=2), axis=1), axis=0) return sp.fftshift(self.Mtot * np.abs(np.einsum("aacc->ac", rho_u)))
#plotting the mean intensity of each image as we cycle through images for i in radians: image = Image.open("./imagesbeads " + str(mode_num) + str(i) + ".tiff") imarray = np.asarray(image, dtype='uint16') fft2 = fftpack.fft2(imarray) masked_image = fftpack.fftshift(fft2) * ring_mask mean_pixel = np.mean(abs(masked_image)) avfreq_vals.append(mean_pixel) return avfreq_vals out_mask = MakeMask(radius, cut) in_mask = (MakeMask(radius, cut * 0.6)) ring_mask = out_mask * ((in_mask - 1) * -1) fft2 = fftpack.fft2(imarray) masked_image = fftpack.fftshift(fft2) * ring_mask plot_spectrum(masked_image) plt.show() #print(av_freq(mode_num1)) plt.title('Fourier transform') #print('mean pixel value of this is', np.mean(abs(masked_image))) #print(av_freq(mode_num1)) #print(av_intensity(mode_num1)) plt.plot( [1, 2, 3, 4, 5, 6, 7, 8], av_freq(mode_num1), 'ro', ) plt.show()
def main(): # Create images folder Path("Imgs").mkdir(exist_ok=True) # Carga traza STEAD # st = '../Data_STEAD/Train_data.hdf5' # # with h5py.File(st, 'r') as h5_file: # grp = h5_file['earthquake']['local'] # for idx, dts in enumerate(grp): # st_trace = grp[dts][:, 0] / np.max(np.abs(grp[dts][:, 0])) # break # 1984 trazas de 12600 muestras f = '../Data_Shaker/large shaker NEES_130910161319 (1).sgy' with segyio.open(f, ignore_geometry=True) as segy: segy.mmap() traces = segyio.tools.collect(segy.trace[:]) # fs = segy.header[0][117] NO ES LA REAL # Sampling frequency fs = 200 # Number of traces to plot n = 4 # Traces to plot trtp = [] # Init rng rng = default_rng() # Traces to plot numbers trtp_ids = rng.choice(len(traces), size=n, replace=False) trtp_ids.sort() # Retrieve selected traces for idx, trace in enumerate(traces): if idx in trtp_ids: trtp.append(trace) # Data len N = traces.shape[1] # Time axis for signal plot t_ax = np.arange(N) / fs # Frequency axis for FFT plot xf = np.linspace(-fs / 2.0, fs / 2.0 - 1 / fs, N) # Figure to plot plt.figure() # Plot n random traces with their spectrum for idx, trace in enumerate(trtp): yf = sfft.fftshift(sfft.fft(trace)) plt.clf() plt.subplot(211) plt.plot(t_ax, trace) plt.title(f'Traza Shaker y espectro #{trtp_ids[idx]}') plt.xlabel('Tiempo [s]') plt.ylabel('Amplitud [-]') plt.grid(True) plt.subplot(212) plt.plot(xf, np.abs(yf) / np.max(np.abs(yf))) plt.xlabel('Frecuencia [Hz]') plt.ylabel('Amplitud [-]') plt.grid(True) plt.tight_layout() plt.savefig(f'Imgs/Shaker_{trtp_ids[idx]}')
def deconvolve(star, psf): star_fft = fftpack.fftshift(fftpack.fftn(star)) psf_fft = fftpack.fftshift(fftpack.fftn(psf)) return fftpack.fftshift( fftpack.ifftn(fftpack.ifftshift(star_fft / psf_fft)))
def getpowerspectrum(g): gback = fftpack.fft2(g) gback2 = fftpack.fftshift(gback) gback2 = np.abs(gback2)**2 ps2 = radialProfile.azimuthalAverage(gback2) return ps2
def main(): tstart = time.time() tb = pfb_top_block() tb.run() tend = time.time() print "Run time: %f" % (tend - tstart) if 1: fig_in = pylab.figure(1, figsize=(16, 9), facecolor="w") fig1 = pylab.figure(2, figsize=(16, 9), facecolor="w") fig2 = pylab.figure(3, figsize=(16, 9), facecolor="w") fig3 = pylab.figure(4, figsize=(16, 9), facecolor="w") Ns = 650 Ne = 20000 fftlen = 8192 winfunc = scipy.blackman fs = tb._fs # Plot the input signal on its own figure d = tb.snk_i.data()[Ns:Ne] spin_f = fig_in.add_subplot(2, 1, 1) X, freq = mlab.psd(d, NFFT=fftlen, noverlap=fftlen / 4, Fs=fs, window=lambda d: d * winfunc(fftlen), scale_by_freq=True) X_in = 10.0 * scipy.log10(abs(fftpack.fftshift(X))) f_in = scipy.arange(-fs / 2.0, fs / 2.0, fs / float(X_in.size)) pin_f = spin_f.plot(f_in, X_in, "b") spin_f.set_xlim([min(f_in), max(f_in) + 1]) spin_f.set_ylim([-200.0, 50.0]) spin_f.set_title("Input Signal", weight="bold") spin_f.set_xlabel("Frequency (Hz)") spin_f.set_ylabel("Power (dBW)") Ts = 1.0 / fs Tmax = len(d) * Ts t_in = scipy.arange(0, Tmax, Ts) x_in = scipy.array(d) spin_t = fig_in.add_subplot(2, 1, 2) pin_t = spin_t.plot(t_in, x_in.real, "b") pin_t = spin_t.plot(t_in, x_in.imag, "r") spin_t.set_xlabel("Time (s)") spin_t.set_ylabel("Amplitude") Ncols = int(scipy.floor(scipy.sqrt(tb._M))) Nrows = int(scipy.floor(tb._M / Ncols)) if (tb._M % Ncols != 0): Nrows += 1 # Plot each of the channels outputs. Frequencies on Figure 2 and # time signals on Figure 3 fs_o = tb._fs / tb._M Ts_o = 1.0 / fs_o Tmax_o = len(d) * Ts_o for i in xrange(len(tb.snks)): # remove issues with the transients at the beginning # also remove some corruption at the end of the stream # this is a bug, probably due to the corner cases d = tb.snks[i].data()[Ns:Ne] sp1_f = fig1.add_subplot(Nrows, Ncols, 1 + i) X, freq = mlab.psd(d, NFFT=fftlen, noverlap=fftlen / 4, Fs=fs_o, window=lambda d: d * winfunc(fftlen), scale_by_freq=True) X_o = 10.0 * scipy.log10(abs(X)) f_o = freq p2_f = sp1_f.plot(f_o, X_o, "b") sp1_f.set_xlim([min(f_o), max(f_o) + 1]) sp1_f.set_ylim([-200.0, 50.0]) sp1_f.set_title(("Channel %d" % i), weight="bold") sp1_f.set_xlabel("Frequency (Hz)") sp1_f.set_ylabel("Power (dBW)") x_o = scipy.array(d) t_o = scipy.arange(0, Tmax_o, Ts_o) sp2_o = fig2.add_subplot(Nrows, Ncols, 1 + i) p2_o = sp2_o.plot(t_o, x_o.real, "b") p2_o = sp2_o.plot(t_o, x_o.imag, "r") sp2_o.set_xlim([min(t_o), max(t_o) + 1]) sp2_o.set_ylim([-2, 2]) sp2_o.set_title(("Channel %d" % i), weight="bold") sp2_o.set_xlabel("Time (s)") sp2_o.set_ylabel("Amplitude") sp3 = fig3.add_subplot(1, 1, 1) p3 = sp3.plot(t_o, x_o.real) sp3.set_xlim([min(t_o), max(t_o) + 1]) sp3.set_ylim([-2, 2]) sp3.set_title("All Channels") sp3.set_xlabel("Time (s)") sp3.set_ylabel("Amplitude") pylab.show()
from smst.utils import audio (fs, x) = audio.read_wav('../../../sounds/soprano-E4.wav') N = 1024 x1 = np.blackman(N) * x[40000:40000 + N] plt.figure(1, figsize=(9.5, 6)) X = np.array([]) x2 = np.zeros(N) plt.subplot(4, 1, 1) plt.title('x (soprano-E4.wav)') plt.plot(x1, lw=1.5) plt.axis([0, N, min(x1), max(x1)]) X = fft(fftshift(x1)) mX = 20 * np.log10(np.abs(X[0:N / 2])) pX = np.angle(X[0:N / 2]) plt.subplot(4, 1, 2) plt.title('mX = magnitude spectrum') plt.plot(mX, 'r', lw=1.5) plt.axis([0, N / 2, min(mX), max(mX)]) plt.subplot(4, 1, 3) plt.title('pX1 = phase spectrum') plt.plot(pX, 'c', lw=1.5) plt.axis([0, N / 2, min(pX), max(pX)]) pX1 = np.unwrap(pX) plt.subplot(4, 1, 4)
def __init__(self, gridDIM, amplitude, dt, timeSteps, skipFrames = 1,frameSaveMode='Density'): X_amplitude,Y_amplitude = amplitude X_gridDIM, Y_gridDIM = gridDIM self.dX = 2.*X_amplitude/np.float(X_gridDIM) self.dY = 2.*Y_amplitude/np.float(Y_gridDIM) self.X_amplitude = X_amplitude self.Y_amplitude = Y_amplitude self.X_gridDIM = X_gridDIM self.Y_gridDIM = Y_gridDIM self.min_X = -X_amplitude self.min_Y = -Y_amplitude self.timeSteps = timeSteps self.skipFrames = skipFrames self.frameSaveMode = frameSaveMode rangeX = np.linspace(-X_amplitude, X_amplitude - self.dX, X_gridDIM ) rangeY = np.linspace(-Y_amplitude, Y_amplitude - self.dY, Y_gridDIM ) self.X = fftpack.fftshift(rangeX)[np.newaxis, : ] self.Y = fftpack.fftshift(rangeY)[:, np.newaxis ] self.X_GPU = gpuarray.to_gpu( np.ascontiguousarray( self.X + 0.*self.Y, dtype = np.complex128) ) self.Y_GPU = gpuarray.to_gpu( np.ascontiguousarray( self.Y + 0.*self.X, dtype = np.complex128) ) # min_Px = np.pi*self.X_gridDIM/(2*self.min_X) Px_amplitude = np.pi/self.dX self.dPx = 2*Px_amplitude/self.X_gridDIM Px_range = np.linspace( -Px_amplitude, Px_amplitude - self.dPx, self.X_gridDIM ) Py_amplitude = np.pi/self.dY self.dPy = 2*Py_amplitude/self.Y_gridDIM Py_range = np.linspace( -Py_amplitude, Py_amplitude - self.dPy, self.Y_gridDIM ) self.Px = fftpack.fftshift(Px_range)[np.newaxis,:] self.Py = fftpack.fftshift(Py_range)[:,np.newaxis] self.Px_GPU = gpuarray.to_gpu( np.ascontiguousarray( self.Px + 0.*self.Py, dtype = np.complex128) ) self.Py_GPU = gpuarray.to_gpu( np.ascontiguousarray( self.Py + 0.*self.Px, dtype = np.complex128) ) self.dt = dt #................ Strings: mass,c,dt must be defined in children class.................... self.CUDA_constants_essential = '__constant__ double mass=%f; '%self.mass self.CUDA_constants_essential += '__constant__ double c=%f; '%self.c self.CUDA_constants_essential += '__constant__ double dt=%f; '%self.dt self.CUDA_constants_essential += '__constant__ double dX=%f; '%self.dX self.CUDA_constants_essential += '__constant__ double dY=%f; '%self.dY self.CUDA_constants_essential += '__constant__ double dPx=%f; '%self.dPx self.CUDA_constants_essential += '__constant__ double dPy=%f; '%self.dPy self.CUDA_constants = self.CUDA_constants_essential #+ self.CUDA_constants_additional #................ CUDA Kernels ........................................................... self.DiracPropagatorK = SourceModule(BaseCUDAsource_K%self.CUDA_constants,arch="sm_20").get_function( "Kernel" ) self.DiracPropagatorA = \ SourceModule( DiracPropagatorA_source%( self.CUDA_constants, self.Potential_0_String, self.Potential_1_String, self.Potential_2_String, self.Potential_3_String),arch="sm_20").get_function( "DiracPropagatorA_Kernel" ) self.Potential_0_Average_Function = \ SourceModule( Potential_0_Average_source%( self.CUDA_constants,self.Potential_0_String) ).get_function("Kernel" ) self.DiracAbsorbBoundary_xy = \ SourceModule(BaseCUDAsource_AbsorbBoundary_xy,arch="sm_20").get_function( "AbsorbBoundary_Kernel" ) #...........................FFT PLAN................................................. self.plan_Z2Z_2D = cuda_fft.Plan_Z2Z( (self.X_gridDIM,self.Y_gridDIM) )
import numpy as np import matplotlib.pylab as plt from scipy.fftpack import fft, fftfreq, fft2, ifft2, fftshift, ifftshift from matplotlib.colors import LogNorm from scipy import ndimage # Guarda la imagene en un arreglo imagen = plt.imread('moonlanding.png') # Encuentra la transformada de Fourier de las imagen transformadaImagen = fft2(imagen) transformadaShift = fftshift(transformadaImagen) # Genera el plot de la transformada de fourier de las imagen plt.figure() plt.imshow(np.abs(transformadaShift), norm=LogNorm(vmin=5)) plt.colorbar() plt.savefig("Transformada.pdf") # Funcion que me devuelve el punto medio de la lista def mitadPunto(transformadaImagen): x = np.shape(transformadaImagen)[0] // 2
reduces the spectral leakage, making the "real" frequency information more visible in the plot of the frequency component of the FFT. """ import matplotlib.pyplot as plt import numpy as np from scipy.fftpack import fft2, fftshift from skimage import img_as_float from skimage.color import rgb2gray from skimage.data import astronaut from skimage.filters import window image = img_as_float(rgb2gray(astronaut())) wimage = image * window('hann', image.shape) image_f = np.abs(fftshift(fft2(image))) wimage_f = np.abs(fftshift(fft2(wimage))) fig, axes = plt.subplots(2, 2, figsize=(8, 8)) ax = axes.ravel() ax[0].set_title("Original image") ax[0].imshow(image, cmap='gray') ax[1].set_title("Windowed image") ax[1].imshow(wimage, cmap='gray') ax[2].set_title("Original FFT (frequency)") ax[2].imshow(np.log(image_f), cmap='magma') ax[3].set_title("Window + FFT (frequency)") ax[3].imshow(np.log(wimage_f), cmap='magma') plt.show()
y = signal.detrend(qqq) alldays = DayLocator() months = MonthLocator() month_formatter = DateFormatter("%b %Y") fig = plt.figure() ax = fig.add_subplot(211) ax.xaxis.set_minor_locator(alldays) ax.xaxis.set_major_locator(months) ax.xaxis.set_major_formatter(month_formatter) amps = np.abs(fftpack.fftshift(fftpack.rfft(y))) amps[amps < amps.max()] = 0 def residuals(p, y, x): A,k,theta = p err = y-A * np.sin(2* np.pi* k * x + theta) return err filtered = -fftpack.irfft(fftpack.ifftshift(amps)) N = len(qqq) f = np.linspace(-N/2, N/2, N) p0 = [filtered.max(), f[amps.argmax()]/N, np.pi/3] plsq = optimize.leastsq(residuals, p0, args=(filtered, dates)) p = plsq[0] print p
def RGB(self): image = np.log10(0.1 + abs(self.image)).astype(float) image = fp.fftshift(image.copy()) return image / image.max() #Normalized between 0-1
def main(): ### Parse commandline arguments parser = argparse.ArgumentParser( description= 'Processes time domain data to perform frequency domain analysis') parser.add_argument('-p', '--path', metavar='path', default="./data", help='define path of input files') parser.add_argument('-f1', '--filename1', metavar='filename', default="test", help='set filename for test dump') parser.add_argument('-f2', '--filename2', metavar='filename', default="bg", help='set filename for background dump') parser.add_argument('-fs', '--fsampling', metavar='N', type=float, default=2e6, help='set sampling frequency of input data') parser.add_argument('-n', '--fftsize', metavar='N', type=int, default=16383, help='set FFT size') parser.add_argument('-na', '--nall', action='store_false', help='disabilitates overall frequency plot') parser.add_argument('-s', '--step', action='store_true', help='abilitates step by step frequency plot') parser.add_argument( '-d', '--diff', action='store_true', help= 'performs difference between spectrum with board and spectrum without board' ) parser.add_argument('-g', '--spg', action='store_true', help='show spectrogram') parser.add_argument('-P', '--peaks', action='store_true', help='abilitates peak search') parser.add_argument( '-t', '--Pth', metavar='dB', type=int, default=-90, help='set power threshold for peak search (in dB) - default: -90 ') parser.add_argument('-e', '--epeaks', action='store_true', help='exports peak search, -P option must be selected') parser.add_argument('-fP', '--fpeaks', metavar='filename', default="scan", help='set filename for peak export (default: scan)') parser.add_argument('-w', '--efft', action='store_true', help='exports data inside compressed .npz files') parser.add_argument('-l', '--load', action='store_true', help='load data from compressed .npz files') parser.add_argument( '-fw', '--fftname', metavar='filename', default="fft_export", help='choose filename for FFT export/load (default: fft_export)') parser.add_argument( '-fg', '--spgname', metavar='filename', default="spg_export", help='choose filename for spectrogram export/load (default: spg_export)' ) parser.add_argument('frequency', metavar='f', type=int, nargs=2, default=[26, 28], help='frequency range') args = parser.parse_args() ### Options export_fft = args.efft load_fft = args.load diff = args.diff find_peaks = args.peaks export_peaks = args.epeaks plot_step = args.step plot_all = args.nall show_spectrogram = args.spg ### Parameters fmin = args.frequency[0] #minimum center frequency in MHz (MIN:25) fmax = args.frequency[1] #maximum center frequency in MHz (MAX: 1000) if fmax < fmin: print("Error: fmin larger than fmax") quit() path = args.path + "/" #path of acquired data data_filename = args.filename1 diff_filename = args.filename2 #difference filename Pth = args.Pth #set power threshold in negative dB peaks_filename = args.fpeaks #filename of peaks export fft_filename = args.fftname Fs = args.fsampling #data sampling frequency dT = 1 / Fs #sampling rate fft_size = args.fftsize #FFT size spg_filename = args.spgname f = fftfreq(fft_size, d=dT) #x-axis for FFT f = fftshift(f) peaks = peaks1 = peaks2 = [] if (export_peaks): suffix = str(dt.datetime.now()).replace(" ", "_").replace( ":", "").replace("-", "")[:-7] + ".txt" scan = path + peaks_filename + "_" + suffix #path of scan output scan1 = path + peaks_filename + "1_" + suffix #path of scan output scan2 = path + peaks_filename + "2_" + suffix #path of scan output else: scan = "" scan1 = "" scan2 = "" if (load_fft == False): for f0 in range(fmin, fmax + 1, int(Fs / 1e6)): #### the step is used to avoid repetitions (default Fs is 2e6) #### ### Open file 1 data = ldcomplex(path + data_filename + str(f0) + ".dat") ### FFT spectrum, Welch average method if (diff): ### Open file 2 data2 = ldcomplex(path + diff_filename + str(f0) + ".dat") ### Compute difference between averaged FFts _, P1 = welch(data, Fs, 'hanning', fft_size, None, None, 'constant', True, 'spectrum') _, P2 = welch(data2, Fs, 'hanning', fft_size, None, None, 'constant', True, 'spectrum') P1 = fftshift(P1) P2 = fftshift(P2) P = np.square(np.sqrt(P1) - np.sqrt(P2)) if (show_spectrogram): fsg, tsg, Sxx1 = spectrogram(data, Fs, scaling='spectrum', nperseg=1024) _, _, Sxx2 = spectrogram(data2, Fs, scaling='spectrum', nperseg=1024) Sxx = np.square(np.sqrt(Sxx1) - np.sqrt(Sxx2)) else: _, P = welch(data, Fs, 'hanning', fft_size, None, None, 'constant', True, 'spectrum') P = fftshift(P) if (show_spectrogram): fsg, tsg, Sxx = spectrogram(data, Fs, scaling='spectrum', nperseg=1024) if (plot_all or export_fft or export_peaks): ## APPEND DATA FOR GLOBAL PLOT if f0 == fmin: f_global = f / 1e6 + f0 P_global = P if (show_spectrogram): fsg_global = fftshift(fsg / 1e6 + f0) Sxx_global = fftshift(Sxx) if (diff): P1_global = P1 P2_global = P2 if (show_spectrogram): Sxx1_global = fftshift(Sxx1) Sxx2_global = fftshift(Sxx2) else: f_global = np.append(f_global, f / 1e6 + f0) P_global = np.append(P_global, P) if (show_spectrogram): fsg_global = np.append(fsg_global, fftshift(fsg / 1e6 + f0)) Sxx_global = np.concatenate( (Sxx_global, fftshift(Sxx)), axis=0) if (diff): P1_global = np.append(P1_global, P1) P2_global = np.append(P2_global, P2) if (show_spectrogram): Sxx1_global = np.concatenate( (Sxx1_global, fftshift(Sxx1)), axis=0) Sxx2_global = np.concatenate( (Sxx2_global, fftshift(Sxx2)), axis=0) ### PLOT (f0) if (plot_step): f1 = plt.figure(1) if (diff): plt.subplots_adjust(left=0.12, bottom=0.08, right=0.95, top=0.93, wspace=0.28, hspace=0.34) plt.subplot(2, 2, 1) if (find_peaks): peaks1 = peakscannerdb(P1, Pth, export=False) peaks2 = peakscannerdb(P2, Pth, export=False) ldplotdb(f / 1e6 + f0, P1, f0, "1 ", peaks1) plt.subplot(2, 2, 2) ldplotdb(f / 1e6 + f0, P2, f0, "2 ", peaks2) plt.subplot(2, 1, 2) if (find_peaks): peaks = peakscannerdb(P, Pth, export=False) ldplotdb(f / 1e6 + f0, P, f0, "", peaks) plt.ion() #interactive plot plt.show() if (show_spectrogram): f2 = plt.figure(2) if (diff): plt.subplots_adjust(left=0.12, bottom=0.08, right=0.95, top=0.93, wspace=0.28, hspace=0.34) plt.subplot(2, 2, 1) ldmesh(tsg, fftshift(fsg / 1e6 + f0), fftshift(Sxx1), f0, "1 ") plt.subplot(2, 2, 2) ldmesh(tsg, fftshift(fsg / 1e6 + f0), fftshift(Sxx2), f0, "2 ") plt.subplot(2, 1, 2) ldmesh(tsg, fftshift(fsg / 1e6 + f0), fftshift(Sxx), f0) plt.show() raw_input("Press any key to continue...") plt.close(f1) if (show_spectrogram): plt.close(f2) else: fft_dict = np.load(path + fft_filename + ".npz") f_global = fft_dict['f'] P_global = fft_dict['P'] if (show_spectrogram): spg_dict = np.load(path + spg_filename + ".npz") tsg = spg_dict['tsg'] fsg_global = spg_dict['fsg'] Sxx_global = spg_dict['Sxx'] if (diff): fft_dict = np.load(path + fft_filename + "_P1" + ".npz") P1_global = fft_dict['P'] fft_dict = np.load(path + fft_filename + "_P2" + ".npz") P2_global = fft_dict['P'] if (show_spectrogram): spg_dict = np.load(path + spg_filename + "_S1" + ".npz") Sxx1_global = spg_dict['Sxx'] spg_dict = np.load(path + spg_filename + "_S2" + ".npz") Sxx2_global = spg_dict['Sxx'] if ((plot_all and find_peaks) or export_peaks): peaks = peakscannerdb(P_global, Pth, export_peaks, f_global, scan) if (diff): peaks1 = peakscannerdb(P1_global, Pth, export_peaks, f_global, scan1) peaks2 = peakscannerdb(P2_global, Pth, export_peaks, f_global, scan2) if (export_fft and not (load_fft)): np.savez_compressed(path + fft_filename, f=f_global, P=P_global) if (show_spectrogram): np.savez_compressed(path + spg_filename, tsg=tsg, fsg=fsg_global, Sxx=Sxx_global) if (diff): np.savez_compressed(path + fft_filename + "_P1", f=f_global, P=P1_global) np.savez_compressed(path + fft_filename + "_P2", f=f_global, P=P2_global) if (show_spectrogram): np.savez_compressed(path + spg_filename + "_S1", tsg=tsg, fsg=fsg_global, Sxx=Sxx1_global) np.savez_compressed(path + spg_filename + "_S2", tsg=tsg, fsg=fsg_global, Sxx=Sxx2_global) ### PLOT (from fmin-Fs/2 to fmax+Fs/2) if (plot_all): f1 = plt.figure(1) if (diff): plt.subplots_adjust(left=0.12, bottom=0.08, right=0.95, top=0.93, wspace=0.28, hspace=0.34) plt.subplot(2, 2, 1) ldplotdb(f_global, P1_global, (fmax + fmin) / 2, "1 ", peaks1) plt.subplot(2, 2, 2) ldplotdb(f_global, P2_global, (fmax + fmin) / 2, "2 ", peaks2) plt.subplot(2, 1, 2) ldplotdb(f_global, P_global, (fmax + fmin) / 2, "", peaks) plt.ion() #interactive plot plt.show() if (show_spectrogram): f2 = plt.figure(2) if (diff): plt.subplots_adjust(left=0.12, bottom=0.08, right=0.95, top=0.93, wspace=0.28, hspace=0.34) plt.subplot(2, 2, 1) ldmesh(tsg, fsg_global, Sxx1_global, (fmax + fmin) / 2, "1 ") plt.subplot(2, 2, 2) ldmesh(tsg, fsg_global, Sxx2_global, (fmax + fmin) / 2, "2 ") plt.subplot(2, 1, 2) ldmesh(tsg, fsg_global, Sxx_global, (fmax + fmin) / 2) plt.show() raw_input("Press any key to close...") plt.close(f1) if (show_spectrogram): plt.close(f2)
def applyFilter( self, parameter_ratio=0.2, mode='highpass', shape="radial", customFilter=None, isSpatial=True ): #radius_ratio is ratio of radius of filter to smallest side of image """Applies a mask of passed shape with parameter of shape(side of square or radius of circle) This can be bypassed by passing a customFilter that is taken in fourier domain if it's a spatial filter and multiplied If the passed customFilter is an fft domain filter of class iImageFFT, it is directly multiplied """ if customFilter is None: if not shape in ['radial', 'square']: shape = 'radial' #default radial shape forced image = fp.fftshift(self.image.copy()) parameter = parameter_ratio * min( self.image.shape ) / 2 #parameter ratio times min of shape of 2d V Channel x0, y0 = np.asarray(image.shape) / 2 #center of image radius = parameter side = parameter #used in two types of filter masks def is_inside(i, j): #Check if i,j is inside the filter radius if shape == 'square': #return true if pixel (i,j) is inside the square mask of side `side` if ((i > x0 - side and i < x0 + side) and (j > y0 - side and j < y0 + side)): return True else: return False elif shape == 'radial': if ((x0 - i)**2 + (y0 - j)**2)**0.5 < radius: return True #return true if point i,j is inside the radial makk else: return False if mode == 'highpass': def inner(i, j): return 0 def outer(i, j): return image[i, j] elif mode == 'lowpass': def inner(i, j): return image[i, j] def outer(i, j): return 0 else: raise NotImplementedError #other modes of filters are not implemented image = np.asarray([[ inner(i, j) if is_inside(i, j) else outer(i, j) for j in range(image.shape[1]) ] for i in range(image.shape[0])]) self.image = fp.ifftshift(image) return self else: #if custom filter is passed if isinstance(customFilter, iImage): filter = (customFilter.pad( target=self).fft().image.astype('float')) elif isinstance(customFilter, np.ndarray) and isSpatial: filter = (iImage(customFilter).pad( target=self.image).fft().image.astype('float')) elif isinstance(customFilter, iImageFFT): assert (customFilter.image.shape == self.image.shape ), "passed customFilter of type iImageFFT \ should be of shape of the target image or \ pass spatial filter of type np.ndarray or iImage so \ it can be padded to required image shape automatically" # filter=customFilter.image.astype('float') filter = customFilter.image else: raise TypeError( "filter can be spatial 2d numpy.ndarray or iImageFFT object of same shape as target iImageFFT object only" ) # filter=filter/filter.max() #normalize the filter filter = abs(filter) #Taking absolute values of filter self.image *= filter #multiply the image with the fft filter return self
# Plot the window and its frequency response: from scipy import signal from scipy.fftpack import fft, fftshift import matplotlib.pyplot as plt window = signal.triang(51) plt.plot(window) plt.title("Triangular window") plt.ylabel("Amplitude") plt.xlabel("Sample") plt.figure() A = fft(window, 2048) / (len(window) / 2.0) freq = np.linspace(-0.5, 0.5, len(A)) response = np.abs(fftshift(A / abs(A).max())) response = 20 * np.log10(np.maximum(response, 1e-10)) plt.plot(freq, response) plt.axis([-0.5, 0.5, -120, 0]) plt.title("Frequency response of the triangular window") plt.ylabel("Normalized magnitude [dB]") plt.xlabel("Normalized frequency [cycles per sample]")
f1 = fs / 4 f2 = f1 + (10 * fs / N) a2dB = -250 a2 = 10**(a2dB / 20) x1 = np.sin(2 * np.pi * f1 * tt) x2 = a2 * np.sin(2 * np.pi * f2 * tt) x = x1 + x2 xw = np.transpose(np.vstack([x * this_win for this_win in ventanas])) X = fft(xw, axis=0) modX = np.abs(fftshift(X)) * 2 / N center = int(np.floor(N / 2)) modX = modX[center:N] modX = 20 * np.log10(modX) freq = np.linspace(0, 0.5, len(modX)) plt.figure("Modulo bitonal", figsize=(10, 10)) plt.suptitle('Mediciones para ejercicio 2b (a2=-250dB y f2 = f1 + (10*fs/N))', fontsize=20) for ii in range(V): plt.subplot(3, 2, ii + 1) plt.tight_layout(pad=2, w_pad=0.5, h_pad=5) plt.plot(freq, modX[:, ii], label=ventanas_names[ii]) plt.title(ventanas_names[ii], fontsize=20) plt.xlim(0.2, 0.3) plt.xlabel("Frecuencia normalizada", fontsize=20) plt.ylabel("Amplitud en dB", fontsize=20)
kind='quadratic') Fc = interp1d(datos_incompletos[:, 0], datos_incompletos[:, 1], kind='cubic') # datos basicos de la senal periodo = datos_senal[1, 0] - datos_senal[0, 0] frecuencia = 1 / periodo n = len(datos_senal[:, 0]) # numero de datos frecuencias = np.linspace(-frecuencia / 2, frecuencia / 2, n) # vector de frecuencias # crear arreglos con todos los valores de k y n kk, nn = np.meshgrid(np.arange(n), np.arange(n)) theta = -2 * np.pi * kk * nn / n # Theta es lo que va en la exponencial transformada = np.sum(datos_senal[:, 1] * np.exp(1j * theta), 1) # hacer las sumas de la transformada transformada = fftshift( transformada) # rotar el arreglo para que coincida con las frecuencias print( "Frecuencias calculadas con codigo propio teniendo en cuenta la resolucion de frecuencia y al frecuencia de Nyquist" ) fig, ax = plt.subplots(figsize=(10, 6)) ax.plot(datos_senal[:, 0], datos_senal[:, 1]) ax.set_xlabel('t') plt.grid() fig.savefig('CaceresAlejandra_signal.pdf', type='pdf') fig, ax = plt.subplots(figsize=(10, 6)) ax.plot(frecuencias, np.abs(transformada)) ax.set_yscale('log') ax.set_xlim([-3000, 3000])