def filters_bank(M, N, J, L=8): filters = {} filters['psi'] = [] offset_unpad = 0 for j in range(J): for theta in range(L): psi = {} psi['j'] = j psi['theta'] = theta psi_signal = morlet_2d(M, N, 0.8 * 2**j, (int(L - L / 2 - 1) - theta) * np.pi / L, 3.0 / 4.0 * np.pi / 2**j,offset=offset_unpad) # The 5 is here just to match the LUA implementation :) psi_signal_fourier = fft.fft2(psi_signal) for res in range(j + 1): psi_signal_fourier_res = crop_freq(psi_signal_fourier, res) psi[res] = torch.FloatTensor(np.stack((np.real(psi_signal_fourier_res), np.imag(psi_signal_fourier_res)), axis=2)) # Normalization to avoid doing it with the FFT! psi[res].div_(M * N // 2**(2 * j)) filters['psi'].append(psi) filters['phi'] = {} phi_signal = gabor_2d(M, N, 0.8 * 2**(J - 1), 0, 0, offset=offset_unpad) phi_signal_fourier = fft.fft2(phi_signal) filters['phi']['j'] = J for res in range(J): phi_signal_fourier_res = crop_freq(phi_signal_fourier, res) filters['phi'][res] = torch.FloatTensor(np.stack((np.real(phi_signal_fourier_res), np.imag(phi_signal_fourier_res)), axis=2)) filters['phi'][res].div_(M * N // 2 ** (2 * J)) return filters
def phase_cor( A, B ): """ find the 2D correlation between images A and B. This is much faster than any of the other scipy correlation methods which insist on working in the spatial domain. """ return ( ifft2( fft2(A)*numpy.conj(fft2(B)) ) ).real
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 convolve2D_fft(theta,F): func = KS_kernel_real #func = gaussian_real assert theta.shape == F.shape N1,N2 = theta.shape dtheta1 = theta[1,1].real - theta[0,0].real theta1 = dtheta1*(numpy.arange(2*N1)-N1) theta1 = fftpack.ifftshift(theta1) dtheta2 = theta[1,1].imag - theta[0,0].imag theta2 = dtheta2*(numpy.arange(2*N2)-N2) theta2 = fftpack.ifftshift(theta2) theta_kernel = numpy.zeros((2*N1,2*N2),dtype=complex) theta_kernel += theta1.reshape((2*N1,1)) theta_kernel += 1j*theta2 kernel = func(theta_kernel) dA = dtheta1 * dtheta2 F_fft = fftpack.fft2(F, (2*N1,2*N2) ) * dA F_fft *= fftpack.fft2(kernel,(2*N1,2*N2) ) out = fftpack.ifft2(F_fft) return out[:N1,:N2]
def drawPic(): m = 200 n = 200 a = 20 b = 20 r = 1 vp0 = 1500 variance = 0.08 dx = 3 C = np.zeros((m, n)) au = autocorrelation_func(a, b) for i in xrange(m): for j in xrange(n): C[i, j] = au.gaussian((i-(m-1)/2.)*dx, (j-(n-1)/2.)*dx) S = fft2(C) # power spectral density z = np.random.randn(m, n) Z = fft2(z) G = np.sqrt(dx * S) GZ = G * Z gz = ifft2(GZ) A = np.real(gz) K = np.real(A) f = plt.figure() plt.imshow(K) return f
def _storeLensKernel(self): ''' This is an internal function that will store the lensing kernel for the given stamp dimensions when the simulator is initialized. ''' N=self.lensN scale=self.lensScale i=np.array(range(0,N)) j=np.array(range(0,N)) xo=(0.5+i-(N)/2.0) # pixels! yo=(0.5+j-(N)/2.0) xMesh, yMesh = np.meshgrid(xo,yo) r2Mesh = (xMesh**2.+yMesh**2.) kX=(1./pi)*xMesh/r2Mesh # pixels! kY=(1./pi)*yMesh/r2Mesh self.ftKernelX=ff.fft2(kX) self.ftKernelY=ff.fft2(kY) del(xMesh) del(yMesh) del(r2Mesh) del(kX) del(kY)
def filters_bank(M, N, J, L=8): filters = {} filters['psi'] = [] offset_unpad = 0 for j in range(J): for theta in range(L): psi = {} psi['j'] = j psi['theta'] = theta psi_signal = morlet_2d(M, N, 0.8 * 2**j, (int(L - L / 2 - 1) - theta) * np.pi / L, 3.0 / 4.0 * np.pi / 2**j,offset=offset_unpad) # The 5 is here just to match the LUA implementation :) psi_signal_fourier = fft.fft2(psi_signal) for res in range(j + 1): psi_signal_fourier_res = crop_freq(psi_signal_fourier, res) psi[res] = tf.constant(np.stack((np.real(psi_signal_fourier_res), np.imag(psi_signal_fourier_res)), axis=2)) psi[res] = tf.div(psi[res], (M * N // 2**(2 * j)), name="psi_theta%s_j%s" % (theta, j)) filters['psi'].append(psi) filters['phi'] = {} phi_signal = gabor_2d(M, N, 0.8 * 2**(J - 1), 0, 0, offset=offset_unpad) phi_signal_fourier = fft.fft2(phi_signal) filters['phi']['j'] = J for res in range(J): phi_signal_fourier_res = crop_freq(phi_signal_fourier, res) filters['phi'][res] = tf.constant(np.stack((np.real(phi_signal_fourier_res), np.imag(phi_signal_fourier_res)), axis=2)) filters['phi'][res] = tf.div(filters['phi'][res], (M * N // 2 ** (2 * J)), name="phi_res%s" % res) return filters
def _getCrossCorrelation(self, ref, mask, fft_ref = False, fft_mask = False): """ Computes the cross correlation between reference and mask images. For parameter description, refer to <self._getDriftValue()> """ # Images should be square and of same dimensions at this point. assert(ref.shape==mask.shape) if not fft_ref: four_ref = fft2(ref) else: four_ref = ref if not fft_mask: # Crop the mask and replace the edges with 0.0 values. Helps the crosscorrelation. if self.cropping: size = min(mask.shape) crop = self.cropping mask_cropped = np.copy(mask[crop:(size-crop), crop:(size-crop)]) mask_padded = np.pad(mask_cropped, crop, mode='constant') four_mask = fft2(mask_padded) else: four_mask = fft2(mask) else: four_mask = mask # Conjugate the mask. four_mask_conj = np.conjugate(four_mask) # Compute pointwise product of reference and mask. product = np.multiply(four_mask_conj, four_ref) # Compute ifft of this product xcorr = ifft2(product) # Take the absolute value xcorr_abs = np.absolute(xcorr) return xcorr_abs
def convolution_fourier_RGB(img, fil_fft, fftsize): channelR = np.zeros((img.shape[0],img.shape[1]), 'double') channelG = np.zeros((img.shape[0],img.shape[1]), 'double') channelB = np.zeros((img.shape[0],img.shape[1]), 'double') for x in range(img.shape[0]): for y in range(img.shape[1]): channelR[x,y] = img[x,y][0] channelG[x,y] = img[x,y][1] channelB[x,y] = img[x,y][2] matrixR_fft = fftpack.fft2(channelR, (fftsize, fftsize)) matrixG_fft = fftpack.fft2(channelG, (fftsize, fftsize)) matrixB_fft = fftpack.fft2(channelB, (fftsize, fftsize)) matrixR_fil_fft = matrixR_fft * fil_fft; matrixG_fil_fft = matrixG_fft * fil_fft; matrixB_fil_fft = matrixB_fft * fil_fft; matrixR_fil = np.real(fftpack.ifft2(matrixR_fil_fft)) matrixG_fil = np.real(fftpack.ifft2(matrixG_fil_fft)) matrixB_fil = np.real(fftpack.ifft2(matrixB_fil_fft)) img_fil = np.zeros((matrixR_fil.shape[0], matrixR_fil.shape[1], 3), 'double') for x in range(matrixR_fil.shape[0]): for y in range(matrixR_fil.shape[1]): img_fil[x,y,0] = matrixR_fil[x,y] img_fil[x,y,1] = matrixG_fil[x,y] img_fil[x,y,2] = matrixB_fil[x,y] return img_fil
def mvd_wiener(initImg, imgList, psfList, iterNum, mu, positiveOnly=True): if positiveOnly: initImg[initImg < 0.0] = 0.0 viewNum = len(imgList) fftFactor = np.sqrt(initImg.shape[0]*initImg.shape[1]) mu = mu * fftFactor I = np.sum(np.abs(initImg)) e = fft2(initImg) e_img_old = initImg e_img = initImg if iterNum == 0: return e_img # pre-compute spectra ijList = [fft2(img) for img in imgList] pjList = [fft2(pad_and_center_psf(psf, initImg.shape)) for psf in psfList] for i in xrange(iterNum): c_all = np.zeros(e.shape, dtype=float) for j in xrange(viewNum): ij = ijList[j] pj = pjList[j] sj = e * pj cj = (np.conj(pj) * (ij - sj))/(np.square(np.abs(pj)) + mu**2) c_all = c_all + cj / float(viewNum) e = e + c_all e_img = np.real(ifft2(e)) if positiveOnly: e_img[e_img < 0.0] = 0.0 e_img = e_img / np.sum(np.abs(e_img)) * I e = fft2(e_img) print 'iter #%d, total change: %f.' %\ (i+1, np.sum(np.abs(e_img_old-e_img))/I) e_img_old = e_img return e_img
def frankotchellappa(dzdx, dzdy): rows, cols = dzdx.shape # The following sets up matrices specifying frequencies in the x and y # directions corresponding to the Fourier transforms of the gradient # data. They range from -0.5 cycles/pixel to + 0.5 cycles/pixel. # The scaling of this is irrelevant as long as it represents a full # circle domain. This is functionally equivalent to any constant * pi pi_over_2 = np.pi / 2.0 row_grid = np.linspace(-pi_over_2, pi_over_2, rows) col_grid = np.linspace(-pi_over_2, pi_over_2, cols) wy, wx = np.meshgrid(row_grid, col_grid, indexing='ij') # Quadrant shift to put zero frequency at the appropriate edge wx = ifftshift(wx) wy = ifftshift(wy) # Fourier transforms of gradients DZDX = fft2(dzdx) DZDY = fft2(dzdy) # Integrate in the frequency domain by phase shifting by pi/2 and # weighting the Fourier coefficients by their frequencies in x and y and # then dividing by the squared frequency denom = (wx ** 2 + wy ** 2) Z = (-1j * wx * DZDX - 1j * wy * DZDY) / denom Z = np.nan_to_num(Z) return np.real(ifft2(Z))
def inverseFilter(img,fftsize): im = np.mean(img,2)/255. fftsize = 1024 im_fft = fftpack.fft2(im, (fftsize, fftsize)) #Complementary of a Gaussian filter SZ = 1024 sigma = 0.25 [xx,yy]=np.meshgrid(np.linspace(-4,4,SZ),np.linspace(-4,4,SZ)) gaussian = np.exp(-0.5*(xx*xx+yy*yy)/(sigma*sigma)) fil =1.-fftpack.fftshift(gaussian/np.max(gaussian)) fil_fft = fil im_fil_fft = im_fft * fil_fft im_fil = np.real(fftpack.ifft2(im_fil_fft)) hs=np.floor(SZ/2.) #Careful with the crop. Because we work directly in the Fourier domain there is no padding. im_crop = im_fil[0:im.shape[0], 0:im.shape[1]] F=fftpack.fft2(im_crop,(1024,1024)) H=fil_fft tol= 1e-2 I = F/H print np.min(I) I=np.where(np.abs(H)<tol,0,I) i_reconstructed = np.real(fftpack.ifft2(I)) plt.imshow(i_reconstructed[:im.shape[0],:im.shape[1]],cmap="gray")
def getGeneralStatistics(self, hara=False, zern=False, tamura=False, only1D=None): generalStatistics = [] if self.rows == 1 and self.columns == 1: for index in range(3): generalStatistics.append(self.image[0, 0, index]) return generalStatistics if not only1D is None: im = only1D generalStatistics.extend(self._calculateStatistics(im, haralick=hara, zernike=zern)) fourierTransform = np.abs(fftpack.fft2(im)) # fourierTransform generalStatistics.extend(self._calculateStatistics(fourierTransform)) waveletTransform = pywt.dwt2(im, "sym5")[0] generalStatistics.extend(self._calculateStatistics(waveletTransform)) waveletFourierTransform = pywt.dwt2(fourierTransform, "sym5")[0] generalStatistics.extend(self._calculateStatistics(waveletFourierTransform)) if tamura: generalStatistics.extend(self.get3Dstatistics(tamura=True)) return generalStatistics for index in range(3): im = self.image[:, :, index] generalStatistics.extend(self._calculateStatistics(im, haralick=hara, zernike=zern)) fourierTransform = np.abs(fftpack.fft2(im)) # fourierTransform generalStatistics.extend(self._calculateStatistics(fourierTransform)) waveletTransform = pywt.dwt2(im, "sym5")[0] generalStatistics.extend(self._calculateStatistics(waveletTransform)) waveletFourierTransform = pywt.dwt2(fourierTransform, "sym5")[0] generalStatistics.extend(self._calculateStatistics(waveletFourierTransform)) if tamura: generalStatistics.extend(self.get3Dstatistics(tamura=True)) return generalStatistics
def correlate_layer(pattern_layer, source_layer): """ Normalized Cross-Correlation for a single channel of an RGB image (or a greyscale image). Normalization is done as follows: normalized = (x - mean(x)) / std(x) pattern_layer - Two-dimensional ndarray, single channel of pattern image source_layer - Two-dimensional ndarray, single channel of source image """ # http://bit.ly/WsRveH if pattern_layer.std() == 0: normalized_pattern = pattern_layer else: normalized_pattern = ((pattern_layer - np.mean(pattern_layer)) / (np.std(pattern_layer) * pattern_layer.size)) if source_layer.std() == 0: normalized_source = source_layer else: normalized_source = ((source_layer - np.mean(source_layer)) / np.std(source_layer)) #Take the fft of both Images, padding the pattern out with 0's # to be the same shape as the source pattern_fft = fftpack.fft2(normalized_pattern, source_layer.shape) source_fft = fftpack.fft2(normalized_source) # Perform the correlation in the frequency domain, which just the # inverse FFT of the pattern matrix's conjugate * the source matrix # http://en.wikipedia.org/wiki/Cross-correlation#Properties return fftpack.ifft2(pattern_fft.conjugate() * source_fft)
def solve(self, u, v, dx, dy): import numexpr as ne nx, ny = u.shape assert u.shape == tuple(self.shape) fu = fft2(u) fv = fft2(v) mpx = self.mpx mmx = self.mmx dpx = self.dpx dmx = self.dmx mpy = self.mpy mmy = self.mmy dpy = self.dpy dmy = self.dmy d = ne.evaluate("fu*mmy * dmx + fv * mmx * dmy") lapl = ne.evaluate("mpy * mmy * dpx * dmx + mpx*mmx *dpy *dmy") lapl[0, 0] = 1.0 p = d / lapl px = np.real(ifft2(mpy * dpx * p)) py = np.real(ifft2(mpx * dpy * p)) # self.p = np.real(ifft2(p)) u -= px v -= py return px, py
def colorize_by_power(self, image): """ Colorize the image mode-by-mode according to the power in each mode. The top third of modes are colored red, the middle third green, and the lower third blue. For RGB images, a grayscale equivalent is computed and colorized. """ print "colorizing....." if len(image.shape) == 3: power = fft2(np.sum(image, axis=2))**2 elif len(image.shape) == 2: power = fft2(image)**2 else: raise Exception("Invalid image shape: {}".foramt(image.shape)) thirds = (power.max() - power.min())/3.0 third_cut = power.min() + thirds twothird_cut = third_cut + thirds lower = power < third_cut upper = power > twothird_cut middle = ~(lower | upper) colorized = np.zeros((power.shape[0], power.shape[1], 3), dtype=np.uint8) for color, region in enumerate([upper, middle, lower]): new_channel = ifft2(np.where(region, power, 0.0)) shifted = (new_channel - new_channel.min()) scaled = 255.0*shifted/shifted.max() colorized[..., color] = ifft2(np.where(region, power, 0.0)) return colorized
def shift_inner(arr, nx, ny, window=False, padding='reflect'): """ Shifts an array by nx and ny respectively. """ if ((nx % 1. == 0.) and (ny % 1. ==0)): return sp.roll(sp.roll(arr, int(ny), axis=0), int(nx), axis=1) else: atype = arr.dtype if padding: x, y = arr.shape pwx, pwy = int(pow(2., np.ceil(np.log2(1.5*arr.shape[0])))), int(pow(2., np.ceil(np.log2(1.5*arr.shape[1])))) pwx2, pwy2 = (pwx-x)/2, (pwy-y)/2 if pad=='zero': arr = pad.with_constant(arr, pad_width=((pwx2, pwx2), (pwy2, pwy2))) else: arr = pad.with_reflect(arr, pad_width=((pwx2, pwx2), (pwy2, pwy2))) phaseFactor = sp.exp(complex(0., -2.*sp.pi)*(ny*spf.fftfreq(arr.shape[0])[:, np.newaxis]+nx*spf.fftfreq(arr.shape[1])[np.newaxis, :])) if window: window = spf.fftshift(CXData._tukeywin(arr.shape[0], alpha=0.35)) arr = spf.ifft2(spf.fft2(arr)*phaseFactor*window) else: arr = spf.ifft2(spf.fft2(arr)*phaseFactor) if padding: arr = arr[pwx/4:3*pwx/4, pwy/4:3*pwy/4] if atype == 'complex': return arr else: return np.real(arr)
def tsvd_fft(B, PSF, center=None, tol=None,i=None): """TSVD_FFT Truncated SVD image deblurring using the FFT algorithm. X, tol = tsvd_fft(B, PSF, center, tol) Compute restoration using an FFT-based truncated spectral factorization. Input: B Array containing blurred image. PSF Array containing the point spread function. Optional Inputs: center [row, col] = indices of center of PSF. tol Regularization parameter (truncation tolerance). Default parameter chosen by generalized cross validation. Output: X Array containing computed restoration. tol Regularization parameter used to construct restoration.""" # # compute the center of the PSF if it is not provided # if center is None: center = array(PSF.shape) / 2 # # if PSF is smaller than B, pad it to the same size as B # if PSF.size < B.size: PSF = padarray(PSF, array(B.shape) - array(PSF.shape), direction='post') # # Use the FFT to compute the eigenvalues of the BCCB blurring matrix. # S = fft2( circshift(PSF, 0-center) ) # # If a regularization parameter is not given, use GCV to find one. # bhat = fft2(B) if i !=None: ev=abs(S.flatten()) ev.sort() ev=ev[::-1] tol=ev[i] elif tol is None: tol = gcv_tsvd(S.flatten('f'), bhat.flatten('f')) # # Compute the TSVD regularized solution. # idx = where(abs(S) >= tol) Sfilt = zeros(shape(bhat),'d') Sfilt[idx] = 1 / S[idx] X = real(ifft2(bhat * Sfilt)) return X, sorted(S.flatten())[::-1]
def tik_fft(B, PSF, center=None, alpha=None,sigma=None): """TIK_FFT Tikhonov image deblurring using the FFT algorithm. X, alpha = tik_fft(B, PSF, center, alpha) Compute restoration using an FFT-based Tikhonov filter, with the identity matrix as the regularization operator. Input: B Array containing blurred image. PSF Array containing the point spread function. Optional Inputs: center [row, col] = indices of center of PSF. alpha Regularization parameter. Default parameter chosen by generalized cross validation. Output: X Array containing computed restoration. alpha Regularization parameter used to construct restoration. """ # # compute the center of the PSF if it is not provided # if center is None: center = array(PSF.shape) / 2 # # if PSF is smaller than B, pad it to the same size as B # if PSF.size < B.size: PSF = padarray(PSF, array(B.shape) - array(PSF.shape), direction='post') # # Use the FFT to compute the eigenvalues of the BCCB blurring matrix. # S = fft2( circshift(PSF, 0-center) ) s = S.flatten('f') bhat = fft2(B) bhat = bhat.flatten('f') # # If a regularization parameter is not given, use GCV to find one. # ## if alpha is None: def tik_fft_obj(alpha,B,PSF,sigma): return abs(norm(tik_fft(B, PSF,alpha=abs(alpha)),2)-sigma) if alpha is None: alpha = gcv_tik(s, bhat) print "alpha:", alpha,log10(alpha) # # Compute the Tikhonov regularized solution. # D = conj(s)*s + abs(alpha**2) bhat = conj(s) * bhat xhat = bhat / D xhat = reshape(asmatrix(xhat), shape(B), 'f') X = real(ifft2(xhat)) return X
def gauss_smooth(arr, w): """ Smooths an input array by w pixels """ alpha = w/2.3548 pix = arr.shape[0] ker = sp.exp(-(alpha**-2.)*sp.hypot(*sp.ogrid[-pix/2:pix/2,-pix/2:pix/2])**2.) return sp.real(spf.fftshift(spf.ifft2( spf.fft2(arr)*spf.fft2(ker) )))
def xcorr2(a2,b2): """ 2D cross correlation (unnormalized) """ from scipy.fftpack import fftshift, fft2, ifft2 from scipy import conj a2 = a2 - a2.mean() b2 = b2 - b2.mean() Nfft = (a2.shape[0] + b2.shape[0] - 1, a2.shape[1] + b2.shape[1] - 1) c = ifft2(fft2(a2,shape=Nfft) * fft2(nx.rot90(b2,2),shape=Nfft)) #c = fftshift(ifft2(fft2(a2,shape=Nfft)*conj(fft2(b2,shape=Nfft))).real,axes=(0,1)) return c.real
def FilterElectrons(self,sign, Psi): ''' 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 ' ' px = self.c*self.Px py = self.c*self.Py m = self.mass c= self.c energy = np.sqrt( (m*c**2)**2 + px**2 + py**2 ) EP_11 = 1. + sign*m*c**2/energy EP_12 = 0. EP_13 = 0. EP_14 = sign*(px - 1j*py)/energy EP_21 = 0. EP_22 = 1. + sign*m*c**2/energy EP_23 = sign*(px + 1j*py)/energy EP_24 = 0. EP_31 = 0. EP_32 = sign*(px - 1j*py)/energy EP_33 = 1. - sign*m*c**2/energy EP_34 = 0. EP_41 = sign*(px + 1j*py)/energy EP_42 = 0. EP_43 = 0. EP_44 = 1. - sign*m*c**2/energy #Psi1, Psi2, Psi3, Psi4 = Psi psi1_fft = fftpack.fft2( Psi[0] ) psi2_fft = fftpack.fft2( Psi[1] ) psi3_fft = fftpack.fft2( Psi[2] ) psi4_fft = fftpack.fft2( Psi[3] ) psi1_fft_electron = EP_11*psi1_fft + EP_12*psi2_fft + EP_13*psi3_fft + EP_14*psi4_fft psi2_fft_electron = EP_21*psi1_fft + EP_22*psi2_fft + EP_23*psi3_fft + EP_24*psi4_fft psi3_fft_electron = EP_31*psi1_fft + EP_32*psi2_fft + EP_33*psi3_fft + EP_34*psi4_fft psi4_fft_electron = EP_41*psi1_fft + EP_42*psi2_fft + EP_43*psi3_fft + EP_44*psi4_fft return np.array([ fftpack.ifft2( psi1_fft_electron ), fftpack.ifft2( psi2_fft_electron ), fftpack.ifft2( psi3_fft_electron ), fftpack.ifft2( psi4_fft_electron ) ])
def powerspectrum(img, windowing=True): "Power spectrum of image" if windowing: window = np.hanning(img.shape[0])[:,np.newaxis] F = fftpack.fft2(np.dot(window,window.T)*img) else: F = fftpack.fft2(img) F = fftpack.fftshift(F) ps = np.abs(F)**2 return ps
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 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 _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 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 compute_pspec(self): ''' Compute the 2D power spectrum. ''' mvc_fft = fft2(self.centroid.astype("f8")) - \ self.linewidth * fft2(self.moment0.astype("f8")) mvc_fft = fftshift(mvc_fft) self.ps2D = np.abs(mvc_fft) ** 2. return self
def integration_and_analysis(zeta0, phi0, f_zeta_t, f_phi_t, M, kxgrid, kygrid, ktgrid, dt, time, damping, storage, wmax, wmin): ''' Perform the 4th order Runge-Kutta integration scheme for surface and potential. zeta0: surface at time step n. phi0: potential at time step n. f_zeta_t, f_phi_t: functions with Euler eqs of M-order to be solved found with derive_euler_equation_functions(M). time: time in which the integration takes place damping: non-linear damping factor in Euler eqs. Return: surface and potential at time step n+1. Other variables like the orders of phi can easily be returned! ''' zeta = zeta0 phi = phi0 rk1_zeta, rk1_phi, phi_m = tderiv_surface_potential(zeta, phi, f_zeta_t, f_phi_t, M, kxgrid, kygrid, ktgrid, time, damping, return_phi_m = 1) zeta = zeta0 + rk1_zeta*dt/2 phi = phi0 + rk1_phi*dt/2 rk2_zeta, rk2_phi = tderiv_surface_potential(zeta, phi, f_zeta_t, f_phi_t, M, kxgrid, kygrid, ktgrid, time + dt/2, damping) zeta = zeta0 + rk2_zeta*dt/2 phi = phi0 + rk2_phi*dt/2 rk3_zeta, rk3_phi = tderiv_surface_potential(zeta, phi, f_zeta_t, f_phi_t, M, kxgrid, kygrid, ktgrid, time + dt/2, damping) zeta = zeta0 + rk3_zeta*dt phi = phi0 + rk3_phi*dt rk4_zeta, rk4_phi = tderiv_surface_potential(zeta, phi, f_zeta_t, f_phi_t, M, kxgrid, kygrid, ktgrid, time + dt, damping) dzeta_dt = 1/6 * (rk1_zeta + rk4_zeta + 2*(rk2_zeta + rk3_zeta)) dphi_dt = 1/6 * (rk1_phi + rk4_phi + 2*(rk2_phi + rk3_phi)) kernel = monitor_conserved_quantities(phi0, zeta0, dzeta_dt, kxgrid, kygrid) print('Total Energy: ' + str(kernel['kin'] + kernel['poten']) + ' Total Mass:' + str(kernel['mass'])) zeta_next = np.real(ifft2(dealias(fft2(zeta0 + dt*dzeta_dt), M))) #We transform, dealias, then transform back as real. phi_next = np.real(ifft2(dealias(fft2(phi0 + dt*dphi_dt), M))) storage, wmax, wmin = detect_rogue_waves(zeta0, zeta_next, wmax, wmin, sig_h, storage, time) return zeta_next, phi_next, phi_m, storage, wmax, wmin
img = thresh cv.imshow('Frame',gray) if cv.waitKey(1) == 27: break cap.release() cv.destroyAllWindows() print(img.shape) img = np.float32(img) #template = np.float32(template) A_ = fft.fft2(img) shift_A = fft.fftshift(A_) A_mag = 20*np.log(np.abs(shift_A)+1) ## mask ## rows, cols = img.shape crow, ccol = int(rows / 2), int(cols / 2) mask = np.ones((rows, cols), np.uint8) r = 80 center = [crow, ccol] x, y = np.ogrid[:rows, :cols] mask_area = (x - center[0]) ** 2 + (y - center[1]) ** 2 <= r*r mask[mask_area] = 0
A_k = np.abs(1./math.sqrt(k_x*k_x+k_y*k_y)) phi_k = np.random.uniform(0.0,2.*math.pi) for j in range(ny): f[:,j] = f[:,j] + A_k*np.cos(k_x*x+k_y*y[j]+phi_k) k_x = -kx*2*math.pi/(xmax-xmin); k_y = ky*2*math.pi/(ymax-ymin) A_k = np.abs(1./math.sqrt(k_x*k_x+k_y*k_y)) phi_k = np.random.uniform(0.0,2.*math.pi) for j in range(ny): f[:,j] = f[:,j] + A_k*np.cos(k_x*x+k_y*y[j]+phi_k)#2-D field; must have both kxky>0 and kxky<0 #plt.figure() #plt.contourf(f) #plt.colorbar() #plt.show() print ( 'power in real space=', sum(sum(abs(f)*abs(f)))/(nx*ny) ) fft_f = fft2(f) fft_fs = fftshift(fft_f) #arranges ks in correct order -N/2,..,0,..N/2 plt.figure() kx = 2*math.pi*np.linspace(-nx/2,nx/2,nx); ky = 2*math.pi*np.linspace(-ny/2,ny/2,ny) KX, KY = np.meshgrid(kx,ky,indexing='ij') #plt.contourf(KX, KY, np.log10(np.abs(fft_fs)*np.abs(fft_fs)/(nx*nx*ny*ny)),40) #plt.colorbar() #plt.show() print ( 'power in k-space=', sum(sum(abs(fft_f)*abs(fft_f)))/(nx*ny*nx*ny) ) kabs = np.zeros(nx*ny/2); Energy = np.zeros(nx*ny/2) for l in range(nx): for m in range(int(ny/2)): kabs[m+l*ny/2] = math.sqrt( (l-nx/2)*(l-nx/2) + m*m ) Energy[m+l*ny/2] = 2.*np.abs(fft_fs[l,m+ny/2])*np.abs(fft_fs[l,m+ny/2])/(nx*ny*nx*ny) plt.loglog(kabs,Energy,'o',kabs,1.e-2*kabs**-2) plt.grid()
ax[0].imshow(contrasted1, cmap='gray') ax[0].set(xlabel='', ylabel = '', title = 'Brightness 1') ax[1].imshow(contrasted2, cmap='gray') ax[1].set(xlabel='', ylabel = '', title = 'Brightness 2') ax[2].imshow(contrasted3, cmap='gray') ax[2].set(xlabel='', ylabel = '', title = 'Brightness 3') plt.show() ''' ''' Take the Fourier transform of each of the images ''' fourier1 = fftpack.fft2(contrasted1) fourier2 = fftpack.fft2(contrasted2) fourier3 = fftpack.fft2(contrasted3) ''' Plot the Fourier transform against the original image, and then the detected lines fig, ax = plt.subplots(ncols=3,nrows=2,figsize =(8,2.5)) ax[0][0].imshow(cropped1, cmap='gray') ax[0][0].set(xlabel='', ylabel = '', title = 'Brightness 1') ax[0][1].imshow(cropped2, cmap='gray') ax[0][1].set(xlabel='', ylabel = '', title = 'Brightness 2') ax[0][2].imshow(cropped3, cmap='gray') ax[0][2].set(xlabel='', ylabel = '', title = 'Brightness 3')
print("p:", p) #check if Katz compliant if not mojette.isKatzCriterion(M, M, angles): print("Warning: Katz Criterion not met") #create test image #lena, mask = imageio.lena(N, p, True, np.uint32, True) lena, mask = imageio.phantom(N, p, True, np.uint32, True) #lena, mask = imageio.cameraman(N, p, True, np.uint32, True) #------------------------------- #k-space #2D FFT print("Creating kSpace") fftLena = fftpack.fft2(lena) #the '2' is important fftLenaShifted = fftpack.fftshift(fftLena) #power spectrum powSpectLena = np.abs(fftLenaShifted) #add noise to kSpace noise = finite.noise(fftLenaShifted, SNR) if addNoise: fftLenaShifted += noise #Recover full image with noise print("Actual noisy image") reconLena = fftpack.ifft2(fftLenaShifted) #the '2' is important reconLena = np.abs(reconLena) reconNoise = lena - reconLena
def main(): # Read the FITS file hdulist = fits.open('../Data/WISE_data.fit') image = hdulist[0] data = image.section[:][:] # Uncomment this block to plot the column density map # plt.title("WISE 12 um Survey \n (centered at (198,32) )") # plt.xlabel("Galactic longitude l (deg)") # plt.ylabel("Galactic latitude b (deg)") # plt.imshow(data,extent=(-2.35,2.35,-2.35,2.35)) # plt.show() n = len(data[0]) # Power spectrum calculation tba = np.average(data) thetab = np.zeros((n, n), float) for i in range(n): for j in range(n): thetab[i][j] = (data[i][j] - tba) * np.sin(i * np.pi / n) * np.sin( j * np.pi / n) # Autocorrelation and Fourier transform autocorr = correlate2d(thetab, thetab, mode='full') / n**4 power2D = fftpack.fft2(autocorr) power2D = fftpack.fftshift(power2D) power2D = np.abs(power2D) n = len(power2D[0]) # Create a grid of k values corresponding to the 2D power spectrum image kx = np.linspace(-1, 1, n) ky = np.linspace(-1, 1, n) kx = np.outer(np.ones(n), kx) ky = np.outer(ky, np.ones(n)) k = np.zeros((n, n)) for i in range(n): for j in range(n): k[i][j] = np.sqrt(kx[i][j]**2 + ky[i][j]**2) # Azimuthal averaging k1D, power1D = azimuthal_average.aave(k, power2D, int(n / 2)) k1D = np.log10(k1D[1:]) power1D = np.log10(power1D[1:]) # Fit the log-log power spectrum to a linear function fit = stats.linregress(k1D[2:20], power1D[2:20]) slope = fit[0] intercept = fit[1] error = fit[4] x = np.linspace(k1D[0], k1D[50], 1000) y = slope * x + intercept power1D = 10**(power1D) k1D = 10**(k1D) x = 10**(x) y = 10**(y) plt.loglog(k1D, power1D, label="Calculation") plt.loglog(x, y, label="Fit") plt.title("WISE Survey Power Spectrum \n beta=" + str('%.2f' % slope)) plt.legend() plt.ylabel("P(k) (arbitrary units)") plt.xlabel("k (deg^-1)") plt.show() print("beta=" + str(slope)) print("error=" + str(error))
G=np.fft.fftshift(G) return G # lê imagem de entrada (f) em escala de cinza #f = misc.face(gray=True) f= cv2.imread('Lenna.png',0) plt.figure() cmap = 'gray' plt.title('imagem original') plt.imshow(f, cmap=cmap) plt.colorbar() #calculando a FFT 2D F = fp.fft2(f) #tratando a FFT para os gráficos Fm = np.absolute(F) Fm /= Fm.max() Fm = fp.fftshift(Fm) Fm = np.log(Fm) #mostrando a FFT em escala logaritmica plt.figure() plt.title('FFT em escala log') plt.imshow(Fm, cmap=cmap) plt.colorbar() # gerando a funcao gaussiana (o filtro) sigma = 5
def simulate(self, options, crop=False, zrange=(-100, 100), zstep=10, **kwargs): from multiprocessing import cpu_count, Pool results = dict() def save(key, _image, e_field=True): image = _image.copy() if e_field: image = np.square(image) image = np.real(image) results[key] = image pattern = self.slm_pattern(crop=False, **kwargs) # do not crop in the process save("pattern", pattern, e_field=False) slm_field = np.exp(1j * pattern * np.pi) pre_mask = fftshift(fft2(ifftshift(slm_field))) save("pre_mask", pre_mask) self.mask.calibrate(self.field) post_mask = self.mask(pre_mask.copy()) save("post_mask", post_mask) obj_field = fftshift(fft2(ifftshift(post_mask))) save("excitation_xz", obj_field) if "excitation_xy" in options: from tqdm import tqdm y = np.arange(*zrange, step=zstep) xy = np.zeros((self.field.shape[1], len(y)), dtype=obj_field.dtype) kz = self.field.kz() """ # defocus term defocus = np.einsum("ji,k->jik", kz, y) defocus = np.exp(1j * defocus) # scan over z f = np.einsum("ji,jik->jik", post_mask, defocus) # back to real space f = ifftshift(f, axes=(0, 1)) f = fft2(f, axes=(0, 1)) f = fftshift(f, axes=(0, 1)) # E field to intensity f = np.square(f) f = np.real(f) # select XY view xy = f.max(axis=0) """ logger.info("iterating over Y axis") """ for i, iy in tqdm(enumerate(y), total=len(y)): f = post_mask * np.exp(1j * kz * iy) f = fftshift(fft2(ifftshift(f))) f = np.square(f) f = np.real(f) xy[:, i] = f.max(axis=0) """ with Pool(cpu_count()) as pool: func = partial(self._simulate_xy, post_mask=post_mask, kz=kz) xy = [ r for r in tqdm(pool.imap_unordered(func, y), total=len(y)) ] xy.sort(key=lambda x: x[0]) xy = np.vstack([i for _, i in xy]) save("excitation_xy", xy.T) if crop: for key, image in results.items(): results[key] = image[self.field._roi()] return results
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/fft1.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.zeros((M,N)) center1 = M/2 center2 = N/2 d_0 = 30.0 # minimum cut-off radius d_1 = 50.0 # maximum cut-off radius # defining the convolution function for bandpass 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
def focal_ratio(img, xthreshold=None, ythreshold=0.001, wave=None, pixel=None, center=True, rebin=2, background_fit=True, background_fit_order=2, disp=False, ymin=1e-4): ''' Compute the focal ratio from a PSF image using MTF = |OTF| Parameters ---------- img : array PSF image threshold : float Threshold to determine the cutoff of the OTF. Default is 0.001 wave : float Wavelength, in meters. Default is None pixel : float Pixel size, in meters. Default is None center : bool Recenter the PSF. Default value is True rebin : int Rebin factor for accurate recentering. Must be even. Default is 2 background_fit : bool Fit and subtract the background from the OTF. Default is True background_fit_order : bool Order of the polynomial to fit the background in the OTF. Default is 2 disp : bool Display a summary plot. Default is False ymin : float Minimal y value in the summary plot. Default is 1e-4 Returns ------- sampling : float Sampling of the PSF, in pixels fratio : float Focal ratio of the system. Computed only if wave and pixel are both provided. ''' dim = img.shape[-1] if center: # image oversampling for subpixel accuracy on the image center # determination if rebin: if ((rebin % 2) != 0) and (rebin != 1): raise ValueError('rebin must be even') else: rebin = 1 # oversampling tmp = fft.fftshift(fft.ifft2(fft.fftshift(img))) dim1 = dim * rebin tmp = np.pad(tmp, (dim1-dim)//2, mode='constant') img_big = fft.fftshift(fft.fft2(fft.fftshift(tmp))).real # find maximum imax = np.argmax(img_big) cy, cx = np.unravel_index(imax, img_big.shape) sx, sy = dim1 // 2 - cx, dim1 // 2 - cy # recenter img_big = imutils.shift(img_big, (sx, sy)) # OTF otf = fft.fftshift(fft.ifft2(fft.fftshift(img_big)).real) otf = otf[(dim1-dim)//2:(dim1+dim)//2, (dim1-dim)//2:(dim1+dim)//2] else: # PSF already centered otf = fft.fftshift(np.abs(fft.ifft2(fft.fftshift(img)))) if background_fit: # background subtraction using a linear fit on the first OTF # points otf_1d, r = imutils.profile(otf, ptype='mean', step=1, exact=False) dimfit = background_fit_order + 2 u = np.arange(1, dimfit+1, dtype=np.float) v = otf_1d[1:dimfit+1] coeffs = np.polyfit(u, v, background_fit_order) poly = np.poly1d(coeffs) fit = poly(np.arange(dimfit+1)) if fit[0] >= otf_1d[0]: print('Background lower than 0. No correction') otf_corr = otf / otf.max() else: otf_corr = otf.copy() otf_corr[dim//2, dim//2] = fit[0] otf_corr = otf_corr / fit[0] else: otf_corr = otf / otf.max() # first value of OTF below threshold otf_corr_1d, r = imutils.profile(otf_corr, ptype='mean', step=1, rmax=dim//2-1) if not xthreshold: xthreshold = r.max() rmax = r[(r <= xthreshold) & (otf_corr_1d >= ythreshold)].max() # sampling sampling = dim/rmax # theoretical OTF # pupil = aperture.disc(512, 512, diameter=True, strict=True, cpix=True) # psf_th = np.abs(mft.mft(pupil, 512, dim, dim/sampling))**2 # otf_th = fft.fftshift(np.abs(fft.ifft2(fft.fftshift(psf_th)))).real # otf_th = otf_th / otf_th.max() # otf_th_1d = otf_th[dim//2, dim//2:] # otf_th_r = np.arange(dim//2) # compute uncertainty related to image sampling sampling_min = dim / (rmax + 1) sampling_max = dim / (rmax - 1) print(f'Sampling: {sampling:.2f} ({sampling_min:.2f}-{sampling_max:.2f})') # focal ratio fratio = None if wave is not None and pixel is not None: fratio = sampling * pixel / wave # compute uncertainty related to image sampling fratio_min = sampling_min * pixel / wave fratio_max = sampling_max * pixel / wave print(f'F ratio: {fratio:.2f} ({fratio_min:.2f}-{fratio_max:.2f})') # display result if disp: otf = otf / otf.max() otf_1d, r_otf = imutils.profile(otf, ptype='mean', step=1, rmax=dim//2-1) otf_corr_1d, r = imutils.profile(otf_corr, ptype='mean', step=1, rmax=dim//2-1) plt.figure('OTF', figsize=(8, 8)) plt.clf() plt.imshow(otf_corr, norm=colors.LogNorm(vmin=1e-4, vmax=1)) plt.title('OTF') plt.tight_layout() plt.figure('F ratio estimation', figsize=(12, 9)) plt.clf() plt.semilogy(r_otf, otf_1d, lw=2, marker='+', label='MTF') plt.semilogy(r_otf, otf_corr_1d, lw=2, linestyle='--', marker='+', label='MTF (corrected)') # plt.semilogy(otf_th_r, otf_th_1d, lw=2, linestyle='-', color='k', label='MTF (theoretical)') plt.axhline(ythreshold, linestyle='--', color='r', lw=1) plt.axvline(rmax, linestyle='--', color='r', lw=1) if fratio: plt.title(f'Sampling = {sampling:.2f} pix / ($\lambda/D$) - F ratio = {fratio:.2f}') else: plt.title(f'Sampling = {sampling:.2f} pix / ($\lambda/D$)') plt.xlim(0, xthreshold) plt.xlabel('Cutoff pixel') plt.gca().xaxis.set_major_locator(ticker.MultipleLocator(5)) plt.gca().xaxis.set_minor_locator(ticker.MultipleLocator(1)) if fratio: plt.gca().spines.top.set_visible(False) plt.gca().xaxis.set_ticks_position('bottom') secax = plt.gca().secondary_xaxis('top') secax.set_xlim(plt.xlim()) secax.xaxis.set_major_locator(ticker.MultipleLocator(1)) secax.xaxis.set_minor_locator(ticker.MultipleLocator(1)) secax.xaxis.set_major_formatter(lambda x, pos: f'{dim / x * pixel / wave:.2f}') secax.tick_params(axis='x', bottom=False, top=True, labelbottom=False, labeltop=True, rotation=75) plt.ylim(ymin, 1) plt.ylabel('MTF') plt.legend(loc='center left') plt.tight_layout() return sampling, fratio
@author: IIST """ import numpy as np import math from PIL import Image from scipy import fftpack as fftp import imageio import cmath from matplotlib import pyplot as plt img = Image.open( 'C:/Users/IIST/Downloads/Ragja/7_SC18M003_Ragja_IP2018/Book.tif') img.load() data = np.asarray(img, dtype="float64") image_fft = fftp.fft2(data) a = 0.1 k = 0.00025 T = 1 H = np.zeros((688, 688), dtype="complex") for u in range(1, 689): for v in range(1, 689): den = u**2 + v**2 exponent = k * (den**(5 / 6)) H[u - 1, v - 1] = math.exp(-exponent) final_image2 = image_fft * H image2 = np.fft.ifft2(final_image2) imgfinal = Image.fromarray((image2).astype('uint')) #imgfinal.save('equalized_image.png')
def fftclean(cube_array, cut=np.array([[443, 449, 436, 441], [458, 462, 465, 470], [440, 445, 451, 456], [461, 466, 451, 455], [428, 430, 452, 454], [475, 478, 452, 454], [489, 495, 452, 458], [411, 418, 449, 453]]), zoom=[410, 460, 410, 460], plot=1, n=1, m=1, taper=1): ''' Allows for simple FFT cleaning by removing two boxes around the FFT image. Remember to use taper_cube() before running! INPUT: cube_array : name of 3D numpy array that needs to be tapered. Remember to use taper_cube! cut1 : first box to be removed Default: [417,430, 410,421] cut2 : secpnd box to be removed Default: [430,443, 438,450] zoom : Zoom into central spike Default: [410,460,410,460] plot : Show diagnostic plot Default: True OUTPUT: imput array after filtering and diagnostic plot if plot=1. AUTHOR: Alex ''' dim = cube_array.shape[-1] frame_median = np.tile(np.median(cube_array, axis=[2, 1]), (dim, dim, 1)).T red_cube_array, frame_median = taper_cube(cube_array, taper=taper) #make image for mask. im_fft = (fftpack.fft2(red_cube_array)) if plot: #take power to visualize what we are looking at. We only use this for images. im_po = fftpack.fftshift((np.conjugate(im_fft) * im_fft).real) im_mean = np.mean(im_po) im_std = np.std(im_po) im_mean_im = np.median(red_cube_array[0]) im_std_im = np.std(red_cube_array) mask = np.empty_like(red_cube_array[0]) * 0 + 1 for k in range((cut.shape[0])): mask[cut[k, 0]:cut[k, 1], cut[k, 2]:cut[k, 3]] = 0 if plot: im_po_mask = im_po * mask #use FFT and not power to apply mask and get clean image im_fft = fftpack.fftshift(im_fft) im_fft_mask = im_fft * mask im_mask = fftpack.ifft2(fftpack.ifftshift(im_fft_mask)).real + frame_median if plot: plt.subplot(221) plt.imshow(red_cube_array[0], vmin=im_mean_im - n * im_std_im, vmax=im_mean_im + n * im_std_im) plt.colorbar() plt.subplot(222) plt.imshow(im_po[0], vmin=im_mean - m * im_std, vmax=im_mean + m * im_std) #plt.xlim(zoom[0],zoom[1]) #plt.ylim(zoom[2],zoom[3]) plt.colorbar() plt.subplot(223) plt.imshow(im_mask[0], vmin=frame_median[0, 0, 0] - n * im_std_im, vmax=frame_median[0, 0, 0] + n * im_std_im) plt.colorbar() plt.subplot(224) plt.imshow(im_po_mask[0], vmin=im_mean - m * im_std, vmax=im_mean + m * im_std) #plt.xlim(zoom[0],zoom[1]) #plt.ylim(zoom[2],zoom[3]) plt.colorbar() plt.show() return im_mask
plt.imshow(triangulos, cmap='Greys_r') plt.savefig("imagenes.pdf") #EL SIGUIENTE METODO ES PARA PASAR LA IMAGEN DE 3D A 2D FUE SACADO DEL BLOG :https://stackoverflow.com/questions/12201577/how-can-i-convert-an-rgb-image-into-grayscale-in-python def rgb2gray(rgb): r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2] gray = 0.2989 * r + 0.5870 * g + 0.1140 * b return gray transformada_barcelona = fftpack.fft2(rgb2gray(barcelona)) transformada_paris = fftpack.fft2(rgb2gray(paris)) transformada_fractal = fftpack.fft2(rgb2gray(fractal)) transformada_triangulos = fftpack.fft2(rgb2gray(triangulos)) plt.figure() plt.subplot(221) plt.imshow(np.log10(np.abs(transformada_barcelona**2))) plt.subplot(222) plt.imshow(np.log10(np.abs(transformada_paris**2))) plt.subplot(223) plt.imshow(np.log10(np.abs(transformada_fractal**2))) plt.subplot(224)
def real_fft2d(self, image, *args, **kwargs): padshape = numpy.asarray(image.shape)*1 padimage = apImage.frame_constant(image, padshape, image.mean()) fft = fftpack.fft2(padimage, *args, **kwargs) return fft
def psd2d(sigs, t, x, dt=None, dx=None, nfft=256, noverlap=None, nensemble=1, istart=0, tstart=None, window='hanning', detrend='constant'): """ Estimate 2D cross power spectral density using Welch's method. ---------- sigs : 2D-array Time series of measurement values t : 1D-array Time for sigs x : 1D-array Locations for sigs dt : float, optional Sampling time of the `sigs` time series in units of sec. Defaults to None. dx : float, optional Sampling space of the `sigs` time series in units of m. Defaults to None. nfft : int, optional Length of each segment and Length of the FFT used. noverlap : int, optional Number of points to overlap between segments. If None, ``noverlap = nperseg // 8``. Defaults to None. nensemble: int, optional Number of ensembles Defaults to 1. istart: int, optional Start index in the specified axis of sigs. Defaults to 0. tstart: float, optional Start time of sigs. If None, t[istart] is used. Defaults to None. window : str or tuple or array_like, optional Desired window to use. See `get_window` for a list of windows and required parameters. Defaults to 'hanning'. detrend : str or function or False, optional Specifies how to detrend each segment. If `detrend` is a string, it is passed as the ``type`` argument to `detrend`. If it is a function, it takes a segment and returns a detrended segment. If `detrend` is False, no detrending is done. Defaults to 'constant'. Returns ------- ft : ndarray Array of sample frequencies in time domain. fx : ndarray Array of sample frequencies in space domain. Ptx : ndarray (2D) Power spectral density or power spectrum of x. Pxx(f, tave). See Also -------- Notes ----- see welch """ nt = len(t) nx = len(x) if dt is None: dt = (t[-1] - t[0]) / (nt - 1) if dx is None: dx = (x[-1] - x[0]) / (nx - 1) if len(t) < nfft: warnings.warn( 'nfft = {0}, is greater than len(t) = {1}, using nfft = {2}'. format(nfft, nt, nt)) nfft = len(t) if tstart is not None: indx = np.where(t >= tstart)[0] istart = indx[0] if noverlap is None: noverlap = nfft // 2 elif noverlap >= nfft: raise ValueError('noverlap must be less than nfft.') step = nfft - noverlap iend = step * (nensemble - 1) + nfft + istart if iend > nt: nnew = (nt - nfft - istart) / step + 1 warnings.warn( 'nensemble = {0} exceed boundary, using nensemble = {1}'.format( nt, nnew)) nfft = nnew Ptx = np.zeros((nfft, nx)) if sigs.size == 0: return np.empty(nfreq), tave, Pxx win_t = dsp.get_window(window, nfft) scale_t = dt / (win_t * win_t).sum() win_x = dsp.get_window(window, nx) scale_x = dx / (win_x * win_x).sum() scale = scale_t * scale_x if not detrend: detrend_func = lambda seg: seg elif not hasattr(detrend, '__call__'): detrend_func = lambda seg: dsp.detrend(seg, type=detrend) else: detrend_func = detrend work = np.empty((nfft, nx), dtype=complex) spc = np.zeros((nfft, nx), dtype=complex) for ne in range(nensemble): i0 = istart + noverlap * ne i1 = i0 + nfft for j in range(nx): work[:, j] = win_x[j] * win_t * detrend_func(sigs[i0:i1, j]) spc = fft.fft2(work) Ptx = Ptx + (spc * spc.conj()).real Ptx = scale * Ptx / nensemble Ptx = fft.fftshift(Ptx) ft = fft.fftfreq(nfft, dt) ft = fft.fftshift(ft) fx = fft.fftfreq(nx, dx) fx = fft.fftshift(fx) return ft, fx, Ptx
from scipy import fftpack #import pyfits import numpy as np import pylab as py import radialProfile image = Image.open('agujero.jpg') # Take the fourier transform of the image. F1 = fftpack.fft2(image) # Now shift the quadrants around so that low spatial frequencies are in # the center of the 2D fourier transformed image. F2 = fftpack.fftshift( F1 ) # Calculate a 2D power spectrum psd2D = np.abs( F2 )**2 # Calculate the azimuthally averaged 1D power spectrum psd1D = radialProfile.azimuthalAverage(psd2D) # Now plot up both py.figure(1) py.clf() py.imshow( np.log10( image ), cmap=py.cm.Greys) py.figure(2) py.clf() py.imshow( np.log10( psf2D )) py.figure(3)
def power_spectrum(inputTestName, outputTestName, cb=True, plot=True): """ cb : True if the spectrum is computed on the whole chla_final image cb : False if teh sppectrum is computed only on the restricted area contianing the inpainted image. plot= True enables the visualization of 20 images sampled randomly. plot = False disables the visualization of 20 images sampled randomly. """ #outputTestName = '../data/cloud/DatasetNN_cloud.nc' #inputTestName = '../data/cloud/BaseTest_cloud.nc' PSD2D = [] PSD1D = [] if cb == True: outputTest = xr.open_dataset(outputTestName) chla_final = outputTest.yfinal.values.squeeze() for i in range(chla_final.shape[0]): chlaF = chla_final[i, :, :] # CALCUL DU SPECTRE DE PUISSANCE # Take the fourier transform of the image. F1 = fftpack.fft2(chlaF) # Now shift the quadrants around so that low spatial frequencies are in # the center of the 2D fourier transformed image. F2 = fftpack.fftshift(F1) # Calculate a 2D power spectrum psd2D = np.abs(F2)**2 PSD2D.append( psd2D.tolist()) # array contenant les a 2D power spectrum # Calculate the azimuthally averaged 1D power spectrum psd1D = azimuthalAverage(psd2D) PSD1D.append(psd1D.tolist()) if plot == True: # Visualisation de 20 images tirées aléatoirement nim = 20 idx = np.random.randint(0, chla_final.shape[0], nim) for i, ind in enumerate(idx): fig, ax = plt.subplots(ncols=3) ax[0].imshow(np.log10(chla_final[ind, :, :])) ax[1].imshow(np.log10(np.array(PSD2D[ind]))) ax[2].plot(PSD1D[ind]) elif cb == False: CHLAFC, chla_finalV = inpainted_region(inputTestName, outputTestName) for i in range(chla_finalV.shape[0]): chlaFC = np.array(CHLAFC[i]) # CALCUL DU SPECTRE DE PUISSANCE # Take the fourier transform of the image. F1 = fftpack.fft2(chlaFC) # Now shift the quadrants around so that low spatial frequencies are in # the center of the 2D fourier transformed image. F2 = fftpack.fftshift(F1) # Calculate a 2D power spectrum psd2D = np.abs(F2)**2 PSD2D.append( psd2D.tolist()) # array contenant les a 2D power spectrum # Calculate the azimuthally averaged 1D power spectrum psd1D = azimuthalAverage(psd2D) PSD1D.append(psd1D.tolist()) if plot == True: # Visualisation de 20 images tirées aléatoirement nim = 20 ii = np.random.randint(0, chla_finalV.shape[0], nim) for i, ind in enumerate(ii): fig, ax = plt.subplots(ncols=3) ax[0].imshow(np.array(CHLAFC[ind])) ax[1].imshow(np.log10(np.array(PSD2D[ind]))) ax[2].plot(PSD1D[ind]) else: print("cb est un booléen ! ") return PSD2D, PSD1D
def fourier(self): F1 = fftpack.fft2(self.image) F2 = fftpack.fftshift(F1) return F2
def fft_denoise(file_name): """ ====================== Image denoising by FFT ====================== Denoise an image (:download:`../../../../data/moonlanding.png`) by implementing a blur with an FFT. Implements, via FFT, the following convolution: .. math:: f_1(t) = \int dt'\, K(t-t') f_0(t') .. math:: \tilde{f}_1(\omega) = \tilde{K}(\omega) \tilde{f}_0(\omega) """ ############################################################ # Read and plot the image ############################################################ im = plt.imread(file_name).astype(float) im = im[:, :, 0] plt.figure() plt.imshow(im, plt.cm.gray) plt.title('Original image') ############################################################ # Compute the 2d FFT of the input image ############################################################ im_fft = fftpack.fft2(im) # Show the results def plot_spectrum(im_fft): from matplotlib.colors import LogNorm # A logarithmic colormap plt.imshow(np.abs(im_fft), norm=LogNorm(vmin=5)) plt.colorbar() plt.figure() plot_spectrum(im_fft) plt.title('Fourier transform') ############################################################ # Filter in FFT ############################################################ # In the lines following, we'll make a copy of the original spectrum and # truncate coefficients. # Define the fraction of coefficients (in each direction) we keep keep_fraction = 0.1 # Call ff a copy of the original transform. Numpy arrays have a copy # method for this purpose. im_fft2 = im_fft.copy() # Set r and c to be the number of rows and columns of the array. r, c = im_fft2.shape # Set to zero all rows with indices between r*keep_fraction and # r*(1-keep_fraction): im_fft2[int(r * keep_fraction):int(r * (1 - keep_fraction))] = 0 # Similarly with the columns: im_fft2[:, int(c * keep_fraction):int(c * (1 - keep_fraction))] = 0 plt.figure() plot_spectrum(im_fft2) plt.title('Filtered Spectrum') ############################################################ # Reconstruct the final image ############################################################ # Reconstruct the denoised image from the filtered spectrum, keep only the # real part for display. im_new = fftpack.ifft2(im_fft2).real plt.figure() plt.imshow(im_new, plt.cm.gray) plt.title('Reconstructed Image') ############################################################ # Easier and better: :func:`scipy.ndimage.gaussian_filter` ############################################################ # # Implementing filtering directly with FFTs is tricky and time consuming. # We can use the Gaussian filter from :mod:`scipy.ndimage` from scipy import ndimage im_blur = ndimage.gaussian_filter(im, 4) plt.figure() plt.imshow(im_blur, plt.cm.gray) plt.title('Blurred image') plt.show()
img_1 = cv2.imread('Fig0441(a)(characters_test_pattern).tif', 0) figure() plt.imshow(img_1, cmap=plt.get_cmap('gray'), vmin=0, vmax=255) title('Original Image') show() height = np.size(img_1, 0) #generate height and width = np.size(img_1, 1) #width to loop over them img = np.zeros((height * 2, width * 2)) img_2 = img.copy() img_2[:img_1.shape[0], :img_1.shape[1]] -= img_1 a = scipy.misc.toimage(img_2).convert('L') b = scipy.misc.fromimage(a) c = fftim.fft2(b) d = fftim.fftshift(c) magnitude_spectrum = 20 * np.log(np.abs(d)) cv2.circle(magnitude_spectrum, (688, 688), 10, (0, 0, 255), 5) cv2.circle(magnitude_spectrum, (688, 688), 15, (0, 0, 255), 5) cv2.circle(magnitude_spectrum, (688, 688), 60, (0, 0, 255), 5) cv2.circle(magnitude_spectrum, (688, 688), 160, (0, 0, 255), 5) cv2.circle(magnitude_spectrum, (688, 688), 460, (0, 0, 255), 5) font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(magnitude_spectrum, '460', (788, 200), font, 2, (0, 0, 255), 5, cv2.LINE_AA) cv2.putText(magnitude_spectrum, '160', (750, 550), font, 2, (0, 0, 255), 5, cv2.LINE_AA) cv2.putText(magnitude_spectrum, '60', (750, 650), font, 2, (0, 0, 255), 5,
#face sources and vertex sources #By picking sources we may pick vortex (curly face) or charge (divergency vertex) sources sourcef = np.zeros((N,N)) sourcef[pos(L/2 + .1),pos(L/2)] = -1/dx**2 #sourcef[pos(L/2 - .1),pos(L/2)] = 1/dx**2 sourcev = np.zeros((N,N)) #make charges ''' sourcev = sourcef sourcef = np.zeros((N,N)) ''' # face and vertex potentials phikf = fft2(sourcef) / L2 phikf[0,:]=0 phikf[:,0]=0 phikv = fft2(sourcev) / L2 phikv[0,:]=0 phikv[:,0]=0 phiv= np.real(ifft2(phikv)) phif= np.real(ifft2(phikf)) # A = curl phif + grad phiv is a 2D helmholtz decomposition # curl uses backards difference, grad uses forward difference. It's how it works out # curl: face -> edge is the transpose of curl: edge -> face and takes backwards to forwards difference Akx = Dby * phikf + Dfx * phikv Aky = - Dbx * phikf + Dfy * phikv
cC = imCShape[1] if len(imCShape) >2: imC = imC[:,:,1] plt.figure() plt.imshow(im, plt.cm.gray) plt.title('Original image') ############################################################ # Compute the 2d FFT of the input image ############################################################ from scipy import fftpack im_fft = fftpack.fft2(im) imC_fft = fftpack.fft2(imC) # Show the results def plot_spectrum(im_fft): from matplotlib.colors import LogNorm # A logarithmic colormap plt.imshow(np.abs(im_fft), norm=LogNorm(vmin=5)) plt.colorbar() plt.figure() plot_spectrum(im_fft) plt.title('Fourier transform') ############################################################
mask = pfft.fftshift(convert_locations_to_mask(samples, SOS.shape)) image = pysap.Image(data=np.abs(SOS)) image.show() ############################################################################# # Generate the kspace # ------------------- # # From the 2D brain slice and the acquistion mask, we generate the acquisition # measurments, the observed kspace. # We then reconstruct the zero order solution. # Generate the subsampled kspace Sl = np.asarray([Smaps[l] * SOS for l in range(Smaps.shape[0])]) kspace_data = np.asarray([mask * pfft.fft2(Sl[l]) for l in range(Sl.shape[0])]) mask = pysap.Image(data=pfft.fftshift(mask)) mask.show() # Get the locations of the kspace samples kspace_loc = convert_mask_to_locations(pfft.fftshift(mask.data)) ############################################################################# # FISTA optimization # ------------------ # # We now want to refine the zero order solution using a FISTA optimization. # Here no cost function is set, and the optimization will reach the
feliz = plt.imread("cara_03_grisesMF.png") print(np.shape(feliz)) def LowP(imagen, corte=.1): r, M = np.shape(imagen) if (M % 2 != 0): M += 1 h = np.sin(2 * np.pi * corte * (imagen - (M / 2))) / (imagen - (M / 2)) w = 0.54 - 0.46 * np.cos(2 * np.pi * imagen / M) im = w * h return im Fseria = fft2(seria).real Fseria = np.log10(abs(Fseria)) print(np.shape(Fseria)) print(Fseria) filtro = LowP(Fseria) IFseria = ifft2(filtro).real plt.figure() plt.subplot(2, 2, 1) plt.imshow(seria) plt.subplot(2, 2, 2) plt.imshow(filtro) plt.subplot(2, 2, 3) plt.imshow(IFseria) plt.subplot(2, 2, 4)
def GiveSpectralIndexMap(self, GaussPars=[(1, 1, 0)], ResidCube=None, GiveComponents=False, ChannelWeights=None): # convert to radians ex, ey, pa = GaussPars ex *= np.pi / 180 / np.sqrt(2) / 2 ey *= np.pi / 180 / np.sqrt(2) / 2 # pa -= 180.0 pa *= np.pi / 180 / np.sqrt(2) / 2 # get in terms of number of cells CellSizeRad = self.GD['Image']['Cell'] * np.pi / 648000 # ex /= self.GD['Image']['Cell'] * np.pi / 648000 # ey /= self.GD['Image']['Cell'] * np.pi / 648000 # get Gaussian kernel GaussKern = ModFFTW.GiveGauss(self.Npix, CellSizeRad=CellSizeRad, GaussPars=(ex, ey, pa), parallel=False) # import matplotlib.pyplot as plt # plt.imshow(GaussKern) # plt.show() # normalise # GaussKern /= np.sum(GaussKern.flatten()) # take FT Fs = np.fft.fftshift iFs = np.fft.ifftshift # evaluate model ModelImage = self.GiveModelImage(self.GridFreqs) # pad GausKern and take FT GaussKern = np.pad(GaussKern, self.Npad, mode='constant') FTshape, _ = GaussKern.shape from scipy import fftpack as FT GaussKernhat = FT.fft2(iFs(GaussKern)) # pad and FT of ModelImage ModelImagehat = np.zeros((self.Nchan, FTshape, FTshape), dtype=np.complex128) ConvModelImage = np.zeros((self.Nchan, self.Npix, self.Npix), dtype=np.float64) I = slice(self.Npad, -self.Npad) for i in xrange(self.Nchan): tmp_array = np.pad(ModelImage[i, 0], self.Npad, mode='constant') ModelImagehat[i] = FT.fft2(iFs(tmp_array)) * GaussKernhat ConvModelImage[i] = Fs(FT.ifft2(ModelImagehat[i]))[I, I].real if ResidCube is not None: ConvModelImage += ResidCube.squeeze() RMS = np.std(ResidCube.flatten()) Threshold = self.GD["SPIMaps"]["AlphaThreshold"] * RMS else: RMS = np.abs(np.min(ModelImage.flatten()) ) # base cutoff on smallest value in model Threshold = self.GD["SPIMaps"]["AlphaThreshold"] * RMS # get minimum along any freq axis MinImage = np.amin(ConvModelImage, axis=0) MaskIndices = np.argwhere(MinImage > Threshold) FitCube = ConvModelImage[:, MaskIndices[:, 0], MaskIndices[:, 1]] if ChannelWeights is None: weights = np.ones(self.Nchan, dtype=np.float32) else: weights = ChannelWeights.astype(np.float32) if ChannelWeights.size != self.Nchan: import warnings warnings.warn( "The provided channel weights are of incorrect length. Ignoring weights.", RuntimeWarning) weights = np.ones(self.Nchan, dtype=np.float32) try: import traceback from africanus.model.spi.dask import fit_spi_components NCPU = self.GD["Parallel"]["NCPU"] if NCPU: from multiprocessing.pool import ThreadPool import dask dask.config.set(pool=ThreadPool(NCPU)) else: import multiprocessing NCPU = multiprocessing.cpu_count() import dask.array as da _, ncomps = FitCube.shape FitCubeDask = da.from_array(FitCube.T.astype(np.float64), chunks=(ncomps // NCPU, self.Nchan)) weightsDask = da.from_array(weights.astype(np.float64), chunks=(self.Nchan)) freqsDask = da.from_array(np.array(self.GridFreqs).astype( np.float64), chunks=(self.Nchan)) alpha, varalpha, Iref, varIref = fit_spi_components( FitCubeDask, weightsDask, freqsDask, self.RefFreq, dtype=np.float64).compute() except Exception as e: traceback_str = traceback.format_exc(e) print>>log, "Warning - Failed at importing africanus spi fitter. This could be an issue with the dask " \ "version. Falling back to (slow) scipy version" print >> log, "Original traceback - ", traceback_str alpha, varalpha, Iref, varIref = self.FreqMachine.FitSPIComponents( FitCube, self.GridFreqs, self.RefFreq) _, _, nx, ny = ModelImage.shape alphamap = np.zeros([nx, ny]) Irefmap = np.zeros([nx, ny]) alphastdmap = np.zeros([nx, ny]) Irefstdmap = np.zeros([nx, ny]) alphamap[MaskIndices[:, 0], MaskIndices[:, 1]] = alpha Irefmap[MaskIndices[:, 0], MaskIndices[:, 1]] = Iref alphastdmap[MaskIndices[:, 0], MaskIndices[:, 1]] = np.sqrt(varalpha) Irefstdmap[MaskIndices[:, 0], MaskIndices[:, 1]] = np.sqrt(varIref) if GiveComponents: return alphamap[None, None], alphastdmap[None, None], alpha else: return alphamap[None, None], alphastdmap[None, None]
def test_fft_fractal(): import matplotlib.pyplot as plt import matplotlib.cm as cm from matplotlib import rcParams import numpy as np from scipy import fftpack # this sets the size of the array. array_power =10 array_size = 2**array_power # get now the beta value (that is, the slope of the # 1D power spectrum in log-log space) beta = 1.5 print "array size is: " + str(array_size) # first make a random array randarray = np.random.rand(array_size,array_size) plt.imshow(randarray) plt.show() # initialize the array for the inverse fourier transform freq_scaled_real = np.zeros((array_size,array_size)) freq_scaled_imaginary = np.zeros((array_size,array_size)) # print randarray # now get the FFT of the random surface F1 = fftpack.fft2(randarray) # get the FFT transformed data #F2 = fftpack.fftshift( F1 ) #plt.imshow(F2.real) #plt.show() #F2_backshift = np.fft.ifftshift(F2) #reconstruct = np.fft.ifft2(F2_backshift) #print "orig: " #print randarray #print "reconstruct: " #print reconstruct #plt.imshow(np.fft.ifft2(F2)) #plt.show() # get the frequency coordinate freq = np.fft.fftfreq(array_size) #freq = np.fft.fftshift(freqs) radial_freq = np.zeros((array_size,array_size)) scaling = np.zeros((array_size,array_size)) print "Frequency: " + str(freq) for row in range (0,array_size): for col in range (0,array_size): radial_freq[row][col] = np.sqrt(freq[row]**2+freq[col]**2) if (radial_freq[row][col] == 0): freq_scaled_real[row][col] = 0 freq_scaled_imaginary[row][col] = 0 scaling[row][col] = 0 else: freq_scaled_real[row][col] = F1.real[row][col]/(radial_freq[row][col]**beta) freq_scaled_imaginary[row][col] = F1.imag[row][col]/(radial_freq[row][col]**beta) scaling[row][col] = 1/(radial_freq[row][col]**beta) #print "radial freq: " #print radial_freq #plt.imshow(freq_scaled_real) #plt.show() freq_scaled = freq_scaled_real + 1j*freq_scaled_imaginary #print "freq_scaled_real" #print freq_scaled_real #print "freq_scaled_imaginary" #print freq_scaled_imaginary #print "And freq_scaled: " #print freq_scaled #freq_scaled_backshift = np.fft.ifftshift(freq_scaled) fractal_surf = np.fft.ifft2(freq_scaled) print "Factal surf is: " #print fractal_surf real_fracsurf = fractal_surf.real plt.imshow(real_fracsurf) plt.show()
plt.show() ############################ img = np.array(Image.open('Lenna.png'))[:, :, 0] show(img, 'original') sigma = 0.05 mu = 0 img = img + sigma * np.random.randn(img.shape[0], img.shape[1]) + mu show(img, "img with noise") H_ = H(img.shape[0], img.shape[1]) plot(np.abs(H_), 'H(u,v) amp') plot(np.angle(H_), 'H(u,v) phase') F_img = fftpack.fft2(img) G = H_ * F_img # 2-d的dft相乘时域也是圆周卷积吗?? G_r = fftpack.ifft2(G) show(np.abs(G_r), 'After H(u,v)') # %% # 反向滤波 r0 = [1, 0.8, 0.5, 0.3] for r in r0: xs = int(r * H_.shape[0]) ys = int(r * H_.shape[1]) H__ = np.ones(H_.shape) H__[:xs, :ys] = H_[:xs, :ys] img_rev = fftpack.ifft2(G / H__) psnr = PSNR(img_rev, img) show(np.abs(img_rev), 'Inverse Filter : r0 = {} : PSNR = {} dB'.format(r, psnr))
phi = np.zeros((N, N)) def pos(x): return int(N * x / L) source = np.zeros((N, N)) source[pos(.4), 0] = -20 / dx**2 source[pos(.6), 0] = 20 / dx**2 L = (4 - np.exp(1.j * kxv * dx) - np.exp(-1.j * kxv * dx) - np.exp(1.j * kyv * dx) - np.exp(-1.j * kyv * dx)) / dx**2 L[0, 0] = 1 #freaks out at k=0 iters = 5 phik = fft2(source) / L phik[0, 0] = 0 phi = np.real(ifft2(phik)) phi0 = np.copy(phi) for i in range(iters): print i sourceeff = source - 100 * np.sin(phi) phik = fft2(sourceeff) / L phik[0, 0] = 0 phi = np.real(ifft2(phik)) import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D fig = plt.figure()
def start(self, image_color, region): """ image: numpy array of shape (width, height) for complete image region: bounding box of shape (width, height) Explanations: F as 2D Fourier transform of input image f H as 2D Fourier transform of filter h G = F * H^{*}, where {*} denotes the complex conjugate """ image = np.sum(image_color, 2) / 3 assert len( image.shape ) == 2, "Grayscale MOSSE is only defined for grayscale images" self.frame = 0 self.region = region self.region_shape = (region.height, region.width) self.region_center = (region.height // 2, region.width // 2) self.search_region = region.rescale(self.search_size, round_coordinates=True) self.search_region_shape = (self.search_region.height, self.search_region.width) self.search_region_center = (self.search_region.height // 2, self.search_region.width // 2) patch = self.crop_patch(image) # pre-process the patch patch = pre_process(patch) # Fourier transform of patch F = fft2(patch) # initialise G as 2D Gaussian centered on the target Sigma = np.eye(2) * self.sigma**2 mu = [self.search_region_center[0], self.search_region_center[1]] x, y = np.mgrid[0:self.search_region.height:1, 0:self.search_region.width:1] pos = np.dstack((x, y)) r = multivariate_normal(mu, Sigma) g = r.pdf(pos) self.G = fft2(g) # compute numerator A and denominator B for H = A/B A = self.G * np.conj(F) B = F * np.conj(F) image_center = (self.region.xpos + self.region_center[1], self.region.ypos + self.region_center[0]) for angle in np.arange(-20, 20, 5): img_tmp = rotateImage(image_color, angle, image_center) # Rotate img_tmp = np.sum(img_tmp, 2) / 3 patch = self.crop_patch(img_tmp) patch = pre_process(patch) F = fft2(patch) A += self.G * np.conj(F) B += F * np.conj(F) # compute filter self.A = A self.B = B self.H_conj = self.A / (self.B + self.epsilon) if self.save_img and self.frame % self.save_frame == 0: plot(image_color, g.real, self.search_region, "{0}_{1}".format(self.name, self.frame))
# coding: utf-8 # In[3]: import numpy as np import matplotlib.pyplot as plt from scipy.fftpack import ifft2, fft2, fftshift, fftfreq from scipy import misc imagenA = misc.imread('arbol.PNG') FourierA = fft2(imagenA) FourierA = FourierA/np.max(FourierA) # Guardar imagen fig, ax = plt.subplots(figsize=(10,6)) ax.imshow(fftshift(np.abs(FourierA))) fig.savefig('CaceresAlejandra_FT2D.pdf', type='pdf') n = len(FourierA) print (n) # In[ ]:
init_ampl = np.sqrt(im_bin) ## Square of amplitude init_ampl = init_ampl.astype(np.uint8) ## Cast back to uint8 PS_shape = Beam_shape(SIZE_X, SIZE_Y, 255, 0) u = np.zeros((SIZE_X, SIZE_Y), dtype=complex) ampl = np.zeros((SIZE_X, SIZE_Y), dtype=complex) ampl = join_phase_ampl(2 * np.pi * np.random.rand(SIZE_X, SIZE_Y) - np.pi, init_ampl) images = [] error = [] for x in range(20): u = sfft.fft2(ampl) u = sfft.fftshift(u) #The SLM renders the phase as multiple of 255 (255=2pi, 0 = 0pi). Some values of pi aren't permitted (discrete phase pattern) phase = np.round((np.angle(u) + np.pi) * 255 / (2 * np.pi)) ## For plotting algorithm evol. SLM_phase = phase ## End of plotting #Back to the range [-pi,pi] but keeping the discretization imposed by the SLM (integers in [0,255]) phase = phase / 255 * (2 * np.pi) - np.pi u = join_phase_ampl(phase, PS_shape.T) ampl = sfft.ifft2(u) #ampl = sfft.ifftshift(ampl)