Python scipy.fftpack.fft2() Examples
The following are 15
code examples of scipy.fftpack.fft2().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
scipy.fftpack
, or try the search function
.
Example #1
Source File: fft.py From pysteps with BSD 3-Clause "New" or "Revised" License | 6 votes |
def get_numpy(shape, fftn_shape=None, **kwargs): import numpy.fft as numpy_fft f = { "fft2": numpy_fft.fft2, "ifft2": numpy_fft.ifft2, "rfft2": numpy_fft.rfft2, "irfft2": lambda X: numpy_fft.irfft2(X, s=shape), "fftshift": numpy_fft.fftshift, "ifftshift": numpy_fft.ifftshift, "fftfreq": numpy_fft.fftfreq, } if fftn_shape is not None: f["fftn"] = numpy_fft.fftn fft = SimpleNamespace(**f) return fft
Example #2
Source File: fft.py From pysteps with BSD 3-Clause "New" or "Revised" License | 6 votes |
def get_scipy(shape, fftn_shape=None, **kwargs): import numpy.fft as numpy_fft import scipy.fftpack as scipy_fft # use numpy implementation of rfft2/irfft2 because they have not been # implemented in scipy.fftpack f = { "fft2": scipy_fft.fft2, "ifft2": scipy_fft.ifft2, "rfft2": numpy_fft.rfft2, "irfft2": lambda X: numpy_fft.irfft2(X, s=shape), "fftshift": scipy_fft.fftshift, "ifftshift": scipy_fft.ifftshift, "fftfreq": scipy_fft.fftfreq, } if fftn_shape is not None: f["fftn"] = scipy_fft.fftn fft = SimpleNamespace(**f) return fft
Example #3
Source File: test_basic.py From Computable with MIT License | 5 votes |
def test_regression_244(self): """fft returns wrong result with axes parameter.""" # fftn (and hence fft2) used to break when both axes and shape were # used x = numpy.ones((4,4,2)) y = fft2(x, shape=(8,8), axes=(-3,-2)) y_r = numpy.fft.fftn(x, s=(8, 8), axes=(-3, -2)) assert_array_almost_equal(y, y_r)
Example #4
Source File: test_basic.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def test_regression_244(self): """fft returns wrong result with axes parameter.""" # fftn (and hence fft2) used to break when both axes and shape were # used x = numpy.ones((4,4,2)) y = fft2(x, shape=(8,8), axes=(-3,-2)) y_r = numpy.fft.fftn(x, s=(8, 8), axes=(-3, -2)) assert_array_almost_equal(y, y_r)
Example #5
Source File: test_basic.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def test_invalid_sizes(self): assert_raises(ValueError, fft2, [[]]) assert_raises(ValueError, fft2, [[1,1],[2,2]], (4, -3))
Example #6
Source File: correlation.py From lenstronomy with MIT License | 5 votes |
def correlation_2D(image): """ #TODO document normalization output in units :param image: 2d image :return: 2d fourier transform """ # 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) return np.abs(F2)
Example #7
Source File: filters_bank.py From DeepLearningImplementations with MIT License | 5 votes |
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
Example #8
Source File: filters_bank_pytorch.py From DeepLearningImplementations with MIT License | 5 votes |
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
Example #9
Source File: covariance.py From PyRate with Apache License 2.0 | 5 votes |
def _calc_power_spectrum(phase): """ Helper function to assist with memory re-allocation during FFT calculation """ fft_phase = fft2(phase) pspec = real(fft_phase) ** 2 + imag(fft_phase) ** 2 return pspec.astype(dtype=np.float32)
Example #10
Source File: aps.py From PyRate with Apache License 2.0 | 5 votes |
def _slp_filter(phase, cutoff, rows, cols, x_size, y_size, params): """ Function to perform spatial low pass filter """ cx = np.floor(cols/2) cy = np.floor(rows/2) # fft for the input image imf = fftshift(fft2(phase)) # calculate distance distfact = 1.0e3 # to convert into meters [xx, yy] = np.meshgrid(range(cols), range(rows)) xx = (xx - cx) * x_size # these are in meters as x_size in meters yy = (yy - cy) * y_size dist = np.sqrt(xx ** 2 + yy ** 2)/distfact # km if params[cf.SLPF_METHOD] == 1: # butterworth low pass filter H = 1. / (1 + ((dist / cutoff) ** (2 * params[cf.SLPF_ORDER]))) else: # Gaussian low pass filter H = np.exp(-(dist ** 2) / (2 * cutoff ** 2)) outf = imf * H out = np.real(ifft2(ifftshift(outf))) out[np.isnan(phase)] = np.nan return out # out is units of phase, i.e. mm # TODO: use tiles here and distribute amongst processes
Example #11
Source File: signaltools.py From lambda-packs with MIT License | 4 votes |
def hilbert2(x, N=None): """ Compute the '2-D' analytic signal of `x` Parameters ---------- x : array_like 2-D signal data. N : int or tuple of two ints, optional Number of Fourier components. Default is ``x.shape`` Returns ------- xa : ndarray Analytic signal of `x` taken along axes (0,1). References ---------- .. [1] Wikipedia, "Analytic signal", http://en.wikipedia.org/wiki/Analytic_signal """ x = atleast_2d(x) if x.ndim > 2: raise ValueError("x must be 2-D.") if iscomplexobj(x): raise ValueError("x must be real.") if N is None: N = x.shape elif isinstance(N, int): if N <= 0: raise ValueError("N must be positive.") N = (N, N) elif len(N) != 2 or np.any(np.asarray(N) <= 0): raise ValueError("When given as a tuple, N must hold exactly " "two positive integers") Xf = fftpack.fft2(x, N, axes=(0, 1)) h1 = zeros(N[0], 'd') h2 = zeros(N[1], 'd') for p in range(2): h = eval("h%d" % (p + 1)) N1 = N[p] if N1 % 2 == 0: h[0] = h[N1 // 2] = 1 h[1:N1 // 2] = 2 else: h[0] = 1 h[1:(N1 + 1) // 2] = 2 exec("h%d = h" % (p + 1), globals(), locals()) h = h1[:, newaxis] * h2[newaxis, :] k = x.ndim while k > 2: h = h[:, newaxis] k -= 1 x = fftpack.ifft2(Xf * h, axes=(0, 1)) return x
Example #12
Source File: signaltools.py From GraphicDesignPatternByPython with MIT License | 4 votes |
def hilbert2(x, N=None): """ Compute the '2-D' analytic signal of `x` Parameters ---------- x : array_like 2-D signal data. N : int or tuple of two ints, optional Number of Fourier components. Default is ``x.shape`` Returns ------- xa : ndarray Analytic signal of `x` taken along axes (0,1). References ---------- .. [1] Wikipedia, "Analytic signal", http://en.wikipedia.org/wiki/Analytic_signal """ x = atleast_2d(x) if x.ndim > 2: raise ValueError("x must be 2-D.") if iscomplexobj(x): raise ValueError("x must be real.") if N is None: N = x.shape elif isinstance(N, int): if N <= 0: raise ValueError("N must be positive.") N = (N, N) elif len(N) != 2 or np.any(np.asarray(N) <= 0): raise ValueError("When given as a tuple, N must hold exactly " "two positive integers") Xf = fftpack.fft2(x, N, axes=(0, 1)) h1 = zeros(N[0], 'd') h2 = zeros(N[1], 'd') for p in range(2): h = eval("h%d" % (p + 1)) N1 = N[p] if N1 % 2 == 0: h[0] = h[N1 // 2] = 1 h[1:N1 // 2] = 2 else: h[0] = 1 h[1:(N1 + 1) // 2] = 2 exec("h%d = h" % (p + 1), globals(), locals()) h = h1[:, newaxis] * h2[newaxis, :] k = x.ndim while k > 2: h = h[:, newaxis] k -= 1 x = fftpack.ifft2(Xf * h, axes=(0, 1)) return x
Example #13
Source File: SO3FFT_Naive.py From lie_learn with MIT License | 4 votes |
def SO3_FFT_analyze(f): """ Compute the complex SO(3) Fourier transform of f. The standard way to define the FT is: \hat{f}^l_mn = (2 J + 1)/(8 pi^2) * int_0^2pi da int_0^pi db sin(b) int_0^2pi dc f(a,b,c) D^{l*}_mn(a,b,c) The normalizing constant comes about because: int_SO(3) D^*(g) D(g) dg = 8 pi^2 / (2 J + 1) where D is any Wigner D function D^l_mn. Note that the factor 8 pi^2 (the volume of SO(3)) goes away if we integrate with the normalized Haar measure. This function computes the FT using the normalized D functions: \tilde{D} = 1/2pi sqrt((2J+1)/2) D where D are the rotation matrices in the basis of complex, seismology-normalized, centered spherical harmonics. Hence, this function computes: \hat{f}^l_mn = \int_SO(3) f(g) \tilde{D}^{l*}_mn(g) dg So that the FT of f = \tilde{D}^l_mn is 1 at (l,m,n) (and zero elsewhere). Args: f: an array of shape (2B, 2B, 2B), where B is the bandwidth. Returns: f_hat: the Fourier transform of f. A list of length B, where entry l contains an 2l+1 by 2l+1 array containing the projections of f onto matrix elements of the l-th irreducible representation of SO(3). Main source: SOFT: SO(3) Fourier Transforms Peter J. Kostelec and Daniel N. Rockmore Further information: Generalized FFTs-a survey of some recent results Maslen & Rockmore Engineering Applications of Noncommutative Harmonic Analysis. 9.5 - Sampling and FFT for SO(3) and SU(2) G.S. Chrikjian, A.B. Kyatkin """ assert f.shape[0] == f.shape[1] assert f.shape[1] == f.shape[2] assert f.shape[0] % 2 == 0 # First, FFT along the alpha and gamma axes (axis 0 and 2, respectively) F = fft2(f, axes=(0, 2)) F = fftshift(F, axes=(0, 2)) # Then, perform the Wigner-d transform return wigner_d_transform_analysis(F)
Example #14
Source File: filter_bank.py From kymatio with BSD 3-Clause "New" or "Revised" License | 4 votes |
def filter_bank(M, N, J, L=8): """ Builds in Fourier the Morlet filters used for the scattering transform. Each single filter is provided as a dictionary with the following keys: * 'j' : scale * 'theta' : angle used Parameters ---------- M, N : int spatial support of the input J : int logscale of the scattering L : int, optional number of angles used for the wavelet transform Returns ------- filters : list A two list of dictionary containing respectively the low-pass and wavelet filters. Notes ----- The design of the filters is optimized for the value L = 8. """ filters = {} filters['psi'] = [] 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, 4.0/L) psi_signal_fourier = fft2(psi_signal) # drop the imaginary part, it is zero anyway psi_signal_fourier = np.real(psi_signal_fourier) for res in range(min(j + 1, max(J - 1, 1))): psi_signal_fourier_res = periodize_filter_fft( psi_signal_fourier, res) psi[res] = psi_signal_fourier_res filters['psi'].append(psi) filters['phi'] = {} phi_signal = gabor_2d(M, N, 0.8 * 2**(J-1), 0, 0) phi_signal_fourier = fft2(phi_signal) # drop the imaginary part, it is zero anyway phi_signal_fourier = np.real(phi_signal_fourier) filters['phi']['j'] = J for res in range(J): phi_signal_fourier_res = periodize_filter_fft(phi_signal_fourier, res) filters['phi'][res] = phi_signal_fourier_res return filters
Example #15
Source File: signaltools.py From Splunking-Crime with GNU Affero General Public License v3.0 | 4 votes |
def hilbert2(x, N=None): """ Compute the '2-D' analytic signal of `x` Parameters ---------- x : array_like 2-D signal data. N : int or tuple of two ints, optional Number of Fourier components. Default is ``x.shape`` Returns ------- xa : ndarray Analytic signal of `x` taken along axes (0,1). References ---------- .. [1] Wikipedia, "Analytic signal", http://en.wikipedia.org/wiki/Analytic_signal """ x = atleast_2d(x) if x.ndim > 2: raise ValueError("x must be 2-D.") if iscomplexobj(x): raise ValueError("x must be real.") if N is None: N = x.shape elif isinstance(N, int): if N <= 0: raise ValueError("N must be positive.") N = (N, N) elif len(N) != 2 or np.any(np.asarray(N) <= 0): raise ValueError("When given as a tuple, N must hold exactly " "two positive integers") Xf = fftpack.fft2(x, N, axes=(0, 1)) h1 = zeros(N[0], 'd') h2 = zeros(N[1], 'd') for p in range(2): h = eval("h%d" % (p + 1)) N1 = N[p] if N1 % 2 == 0: h[0] = h[N1 // 2] = 1 h[1:N1 // 2] = 2 else: h[0] = 1 h[1:(N1 + 1) // 2] = 2 exec("h%d = h" % (p + 1), globals(), locals()) h = h1[:, newaxis] * h2[newaxis, :] k = x.ndim while k > 2: h = h[:, newaxis] k -= 1 x = fftpack.ifft2(Xf * h, axes=(0, 1)) return x