我们从Python开源项目中，提取了以下24个代码示例，用于说明如何使用scipy.fftpack.rfft()。
def stft(X, fftsize=128, step="half", mean_normalize=True, real=False, compute_onesided=True): """ Compute STFT for 1D real valued input X """ if real: local_fft = fftpack.rfft cut = -1 else: local_fft = fftpack.fft cut = None if compute_onesided: cut = fftsize // 2 + 1 if mean_normalize: X -= X.mean() if step == "half": X = halfoverlap(X, fftsize) else: X = overlap(X, fftsize, step) size = fftsize win = 0.54 - .46 * np.cos(2 * np.pi * np.arange(size) / (size - 1)) X = X * win[None] X = local_fft(X)[:, :cut] return X
def run_mgc_example(): import matplotlib.pyplot as plt fs, x = wavfile.read("test16k.wav") pos = 3000 fftlen = 1024 win = np.blackman(fftlen) / np.sqrt(np.sum(np.blackman(fftlen) ** 2)) xw = x[pos:pos + fftlen] * win sp = 20 * np.log10(np.abs(np.fft.rfft(xw))) mgc_order = 20 mgc_alpha = 0.41 mgc_gamma = -0.35 mgc_arr = win2mgc(xw, order=mgc_order, alpha=mgc_alpha, gamma=mgc_gamma, verbose=True) xwsp = 20 * np.log10(np.abs(np.fft.rfft(xw))) sp = mgc2sp(mgc_arr, mgc_alpha, mgc_gamma, fftlen) plt.plot(xwsp) plt.plot(20. / np.log(10) * np.real(sp), "r") plt.xlim(1, len(xwsp)) plt.show()
def stft(X, fftsize=128, step="half", mean_normalize=True, real=False, compute_onesided=True): """ Compute STFT for 1D real valued input X """ if real: local_fft = fftpack.rfft cut = -1 else: local_fft = fftpack.fft cut = None if compute_onesided: cut = fftsize // 2 if mean_normalize: X -= X.mean() if step == "half": X = halfoverlap(X, fftsize) else: X = overlap(X, fftsize, step) size = fftsize win = 0.54 - .46 * np.cos(2 * np.pi * np.arange(size) / (size - 1)) X = X * win[None] X = local_fft(X)[:, :cut] return X
def amp_freq(timeSeries): freq = spfft.rfftfreq(len(timeSeries),1) fft = spfft.rfft(timeSeries) amp = np.abs(fft) indmax = np.where(amp==np.max(amp))[0][0] oi = (np.sum(amp[indmax-1:indmax+1]))/np.sum(amp) indmax = np.where(amp==np.max(amp))[0][0] dfreq = freq[indmax]*1000 # Sampling frequency = 1/1ms = 1/0.001= 1000 return oi,dfreq
def bandpass(data_list, min_hz, max_hz): fft_list = rfft(data_list) # Filter for i in range(len(fft_list)): if not (min_hz < i/2+1 < max_hz): fft_list[i] = 0 result_vals = irfft(fft_list) return result_vals
def remove_freq_range(data_list, min_hz, max_hz): fft_list = rfft(data_list) # Filter for i in range(len(fft_list)): if (min_hz < i / 2 + 1 < max_hz): fft_list[i] = 0 result_vals = irfft(fft_list) return result_vals
def calc_fft(data): return rfft(data)
def high_filter(data, sample_rate=1000): f_signal = rfft(data) l = int(len(f_signal)*50.0/sample_rate); cut_f_signal = f_signal.copy() cut_f_signal[l:len(f_signal)-1] = 0 cut_signal = irfft(cut_f_signal) return cut_signal
def low_filter(data, sample_rate=1000): f_signal = rfft(data) l = int(len(f_signal)*5.0/sample_rate); cut_f_signal = f_signal.copy() cut_f_signal[0:l+1] = 0 cut_f_signal[len(f_signal) + 1 - l :] = 0 cut_signal = irfft(cut_f_signal) return cut_signal
def simple_lf_filter(signal, sample_rate=1000): W = fftfreq(signal.size, d=1/float(sample_rate)) f_signal = rfft(signal) cut_f_signal = f_signal.copy() cut_f_signal[(W<5)] = 0 return irfft(cut_f_signal).astype('int16')
def simple_hf_filter(signal, sample_rate=1000): W = fftfreq(signal.size, d=1/float(sample_rate)) f_signal = rfft(signal) cut_f_signal = f_signal.copy() cut_f_signal[(W>70)] = 0 return irfft(cut_f_signal).astype('int16')
def _get_curve(self): """ No transfer_function correction :return: """ iq_data = self._get_filtered_iq_data() # get iq data (from scope) if not self.running_state in ["running_single", "running_continuous"]: self.pyrpl.scopes.free(self.scope) # free scope if not continuous if self.baseband: # In baseband, where the 2 real inputs are stored in the real and # imaginary part of iq_data, we need to make 2 different FFTs. Of # course, we could do it naively by calling twice fft, however, # this is not optimal: # x = rand(10000) # y = rand(10000) # %timeit fftpack.fft(x) # --> 74.3 us (143 us with numpy) # %timeit fftpack.fft(x + 1j*y) # --> 163 us (182 us with numpy) # A convenient option described in Oppenheim/Schafer p. # 333-334 consists in taking the right combinations of # negative/positive/real/imaginary part of the complex fft, # however, an optimized function for real FFT is already provided: # %timeit fftpack.rfft(x) # --> 63 us (72.7 us with numpy) # --> In fact, we will use numpy.rfft insead of # scipy.fftpack.rfft because the output # format is directly a complex array, and thus, easier to handle. fft1 = np.fft.fftpack.rfft(np.real(iq_data), self.data_length*self.PADDING_FACTOR) fft2 = np.fft.fftpack.rfft(np.imag(iq_data), self.data_length*self.PADDING_FACTOR) cross_spectrum = np.conjugate(fft1)*fft2 res = np.array([abs(fft1)**2, abs(fft2)**2, np.real(cross_spectrum), np.imag(cross_spectrum)]) # at some point, we need to cache the tf for performance self._last_curve_raw = res # for debugging purpose return res/abs(self.transfer_function(self.frequencies))**2 else: # Realize the complex fft of iq data res = scipy.fftpack.fftshift(scipy.fftpack.fft(iq_data, self.data_length*self.PADDING_FACTOR)) # at some point we need to cache the tf for performance self._last_curve_raw = np.abs(res)**2 # for debugging purpose return self._last_curve_raw/abs(self.transfer_function( self.frequencies))**2 #/ abs(self.transfer_function( #self.frequencies))**2 # [self.useful_index()]
