import matplotlib.pyplot as plt def load_data(path): f = open(path, 'rb') d = pickle.load(f) f.close() return d def mag2db(mag): return 20 * np.log(mag) d_noise = np.array(load_data("./data/data_clip_noise.dat")) d_true = np.array(load_data("./data/data_clip_true.dat")) N_noise = len(d_noise) N_true = len(d_true) Fs = 25.2 xf_noise = fftshift(fftfreq(N_noise, 1 / Fs)) yf_noise = fftshift(fft(d_noise)) xf_true = fftshift(fftfreq(N_true, 1 / Fs)) yf_true = fftshift(fft(d_true)) plt.plot(xf_noise, mag2db(abs(yf_noise)), label="noise") plt.plot(xf_true, mag2db(abs(yf_true)), label="detected data") plt.legend() plt.show()
###################################################################### # Denoise image and reduce shadows # ================================ import matplotlib.pyplot as plt import numpy as np from skimage.data import gravel from skimage.filters import difference_of_gaussians, window from scipy.fft import fftn, fftshift image = gravel() wimage = image * window('hann', image.shape) # window image to improve FFT filtered_image = difference_of_gaussians(image, 1, 12) filtered_wimage = filtered_image * window('hann', image.shape) im_f_mag = fftshift(np.abs(fftn(wimage))) fim_f_mag = fftshift(np.abs(fftn(filtered_wimage))) fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(8, 8)) ax[0, 0].imshow(image, cmap='gray') ax[0, 0].set_title('Original Image') ax[0, 1].imshow(np.log(im_f_mag), cmap='magma') ax[0, 1].set_title('Original FFT Magnitude (log)') ax[1, 0].imshow(filtered_image, cmap='gray') ax[1, 0].set_title('Filtered Image') ax[1, 1].imshow(np.log(fim_f_mag), cmap='magma') ax[1, 1].set_title('Filtered FFT Magnitude (log)') plt.show() ###################################################################### # Enhance edges in an image
window = signal.hann(51) plt.plot(window) plt.title("Hann 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 Hann window") plt.ylabel("Normalized magnitude [dB]") plt.xlabel("Normalized frequency [cycles per sample]") plt.show()
#Gráfico de ambas funciones respecto al tiempo plt.plot(t, f, color="red", label="f(t)") plt.plot(t, g, color="blue", label="g(t)") plt.title("Función f(t) y g(t)") plt.xlabel('tiempo (s)') plt.ylabel('f(t) y g(t)') plt.grid() plt.legend() plt.savefig("funciones.png") plt.show() #Calculo de la transformada de fourier de ambas funciones Fw = fourier.fft(f, norm="ortho") Fw = fourier.fftshift(Fw) Gw = fourier.fft(g, norm="ortho") Gw = fourier.fftshift(Gw) #Calculo de las frencuencias de ambas funciones freq_F = fourier.fftfreq(len(f), 2) freq_F = fourier.fftshift(freq_F) freq_G = fourier.fftfreq(len(g), 3) freq_G = fourier.fftshift(freq_G) #Gráfico de ambas transformadas plt.plot(freq_F, abs(Fw)) plt.title("Transformada de f(t)") plt.xlabel('Frecuencia (Hz)')
import numpy as np window = signal.kaiser(51, beta=14) plt.plot(window) plt.title(r"Kaiser window ($\beta$=14)") 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(r"Frequency response of the Kaiser window ($\beta$=14)") plt.ylabel("Normalized magnitude [dB]") plt.xlabel("Normalized frequency [cycles per sample]") plt.show()
def test_kmat(self): """ Test that the real-space and Fourier-space pattern generation models agree. i.e. that D_i(x) = amp * (1 + m * cos(2*pi*f + phi_i)) * S(r) matches the result given using the fourier space matrix [[D_1(k)], [D_2(k)], [D_3(k)]] = M * [[S(k)], [S(k-p)], [S(k+p)]] :return: """ # set options dx = 0.065 sim_options = {'pixel_size': 0.065, 'wavelength': 0.5, 'na': 1.3} # set values for SIM images frqs = np.array([[3.5785512, 2.59801082]]) phases = np.array([[0, 2 * np.pi / 3, 3 * np.pi / 3]]) mods = np.array([[0.85, 0.26, 0.19]]) amps = np.array([[1.11, 1.23, 0.87]]) nangles, nphases = phases.shape # ground truth image ny = 512 nx = ny gt = np.random.rand(ny, nx) # calculate sim patterns using real space method x = tools.get_fft_pos(nx, dx) y = tools.get_fft_pos(ny, dx) xx, yy = np.meshgrid(x, y) sim_rs = np.zeros((nangles, nphases, ny, nx)) sim_rs_ft = np.zeros((nangles, nphases, ny, nx), dtype=np.complex) for ii in range(nangles): for jj in range(nphases): pattern = amps[ii, jj] * (1 + mods[ii, jj] * np.cos( 2 * np.pi * (xx * frqs[ii, 0] + yy * frqs[ii, 1]) + phases[ii, jj])) sim_rs[ii, jj] = gt * pattern sim_rs_ft[ii, jj] = fft.fftshift( fft.fft2(fft.ifftshift(sim_rs[ii, jj]))) # calculate SIM patterns using Fourier space method # frq shifted gt images gt_ft_shifted = np.zeros((nangles, nphases, ny, nx), dtype=np.complex) for ii in range(nangles): gt_ft_shifted[ii, 0] = fft.fftshift(fft.fft2(fft.ifftshift(gt))) gt_ft_shifted[ii, 1] = tools.translate_ft(gt_ft_shifted[ii, 0], -frqs[ii], dx) gt_ft_shifted[ii, 2] = tools.translate_ft(gt_ft_shifted[ii, 0], frqs[ii], dx) sim_fs_ft = np.zeros(gt_ft_shifted.shape, dtype=np.complex) for ii in range(nangles): kmat = sim.get_kmat(phases[ii], mods[ii], amps[ii]) sim_fs_ft[ii] = sim.mult_img_matrix(gt_ft_shifted[ii], kmat) sim_fs_rs = np.zeros(gt_ft_shifted.shape) for ii in range(nangles): for jj in range(nphases): sim_fs_rs[ii, jj] = fft.fftshift( fft.ifft2(fft.ifftshift(sim_fs_ft[ii, jj]))).real # fx = tools.get_fft_frqs(nx, dx) # dfx = fx[1] - fx[0] # fy = tools.get_fft_frqs(ny, dx) # extent = sim.get_extent(fy, fx) # # fig, fig_ax = plt.subplots(ncols=2, nrows=2, constrained_layout=True) # ii = 0 # jj = 1 # # fig_ax[0][0].imshow(np.abs(sim_rs_ft[ii, jj])**2, norm=PowerNorm(gamma=0.1), extent=extent) # plt.title('calculated in real space') # # fig_ax[0][1].imshow(np.abs(sim_fs_ft[ii, jj])**2, norm=PowerNorm(gamma=0.1), extent=extent) # plt.title('calculated in fourier space') # # fig_ax[1][0].imshow(sim_rs[ii, jj]) # plt.title('real space') # # fig_ax[1][1].imshow(sim_fs_rs[ii, jj]) # plt.title('real space (calculated in Fourier space)') np.testing.assert_allclose(sim_fs_ft, sim_rs_ft, atol=1e-10) np.testing.assert_allclose(sim_fs_rs, sim_rs, atol=1e-12)
w = 1 N = 100 Bx = 2 * 3 * np.sqrt(2) * w Δx = Bx / N x = np.linspace(-Bx / 2, Bx / 2, N) # Espacio real Bf = 1 / Δx # Ancho de banda en frecuencia Δf = Bf / N # Muestreo en frecuencia f = np.linspace(-Bf / 2, Bf / 2, N) # Espacio de Fourier # In[3]: g = np.exp(-x**2 / w**2) / np.sqrt(np.pi * w) # Función en el espacio real Ga = np.sqrt(w) * np.exp(-(np.pi * w * f)**2) # Transformada analítica Gn = abs(fftshift(fft(g))) * Δx # Transformada numérica # In[4]: plt.plot(x, g) # In[5]: plt.plot(f, Ga, '.', color='red') plt.plot(f, Gn, color='orange') # In[6]: Gn = abs(fft(g)) * Δx # Transformada numérica sin fftshift # In[7]:
def save(self, results_dir: str) -> None: """averages out the stored statistics from all the drops and store them in a matlab file. Theoretical values (if available) are stored as well. If 'plot' is True, then plot results. Args: results_dir (str): the desired directory to save matlab file in. """ filename = os.path.join(results_dir, "statistics.mat") """for rx_modem_idx in range(self.__scenario.num_transmitters): print(f"\n\tResults for Rx {rx_modem_idx}") for snr, ber, fer in zip( self.snr_loop, self.bit_error_sum[rx_modem_idx], self.block_error_sum[rx_modem_idx] ): print(f"\t{self.snr_type.value} = {snr}dB\tBER = {ber:e}, \tfer = {fer:e}")""" mat_dict = { "snr_type": self.snr_type.name, "snr_vector": self.snr_loop, "ber_mean": self.average_bit_error_rate, "fer_mean": self.average_block_error_rate, "ber_lower": self.bit_error_min, "ber_upper": self.bit_error_max, "fer_lower": self.block_error_min, "fer_upper": self.block_error_max, } if self.__calc_transmit_spectrum: for idx, (periodogram, frequency) in enumerate( zip(self._periodogram_tx, self._frequency_range_tx)): if periodogram is not None and frequency is not None: mat_dict["frequency_tx_" + str(idx)] = fft.fftshift(frequency) mat_dict["power_spectral_density_tx_" + str(idx)] = fft.fftshift(periodogram) / np.amax( periodogram) if self.__calc_transmit_stft: for idx, (time, freq, power) in enumerate(self._stft_tx): if time is not None and freq is not None and power is not None: mat_dict["stft_time_tx_" + str(idx)] = time mat_dict["stft_frequency_tx" + str(idx)] = freq mat_dict["stft_power_tx" + str(idx)] = power if self.__calc_receive_spectrum: for idx, (periodogram, frequency) in enumerate( zip(self._periodogram_rx, self._frequency_range_rx)): mat_dict["frequency_rx_" + str(idx)] = fft.fftshift(frequency) mat_dict["power_spectral_density_rx_" + str( idx)] = fft.fftshift(periodogram) / np.amax(periodogram) if self.__calc_receive_stft: for idx, (time, freq, power) in enumerate(self._stft_rx): if time is not None and freq is not None and power is not None: mat_dict["stft_time_rx_" + str(idx)] = time mat_dict["stft_frequency_rx_" + str(idx)] = freq mat_dict["stft_power_rx_" + str(idx)] = power ber_theory = np.nan * np.ones( (self.__scenario.num_transmitters, self.__scenario.num_receivers, self.__num_snr_loops), dtype=float) fer_theory = np.nan * np.ones( (self.__scenario.num_transmitters, self.__scenario.num_receivers, self.__num_snr_loops), dtype=float) theory_notes = [[np.nan for _ in self.__scenario.receivers] for _ in self.__scenario.transmitters] if self.theoretical_results is not None: for tx_idx, rx_idx in zip(range(self.__scenario.num_transmitters), range(self.__scenario.num_receivers)): link_theory = self.theoretical_results[tx_idx, rx_idx] if link_theory is not None: if 'ber' in link_theory: ber_theory[tx_idx, rx_idx, :] = link_theory['ber'] if 'fer' in link_theory: fer_theory[tx_idx, rx_idx, :] = link_theory['fer'] if 'notes' in link_theory: theory_notes[tx_idx][rx_idx] = link_theory['notes'] mat_dict["ber_theory"] = ber_theory mat_dict["fer_theory"] = fer_theory mat_dict["theory_notes"] = theory_notes # Save results in matlab file sio.savemat(filename, mat_dict)
def log_fft(current, data, data_len, transformer): tmp = current[0][transformer][0][ "output"][:data_len] if current is not None else data[0][0][ "desired"][:data_len] return np.log(np.abs(f.fftshift(f.fftn(tmp)))**2)
def plot(self, title: Optional[str] = None, angle: bool = False, axes: Optional[np.ndarray] = None, space: Union['time', 'frequency', 'both'] = 'both', legend: bool = True) -> Optional[plt.figure]: """Plot the current signal in time- and frequency-domain. Args: title (str, optional): Figure title. angle (bool, optional): Plot the angle of complex frequency bins. axes (Optional[np.ndarray], optional): Axes to which the graphs should be plotted to. If none are provided, the routine will create a new figure. space (Union['time', 'frequency', 'both'], optional): Signal space to be plotted. By default, both spaces are visualized. Returns: Optional[plt.figure]: The created matplotlib figure. `None`, if axes were provided. """ title = "Signal Model" if title is None else title figure: Optional[plt.figure] = None axes = np.array([[axes]], dtype=object) if isinstance( axes, plt.Axes) else axes with Executable.style_context(): # Create a new figure if no axes were provided if axes is None: num_axes = 2 if space == 'both' else 1 figure, axes = plt.subplots(self.num_streams, num_axes, squeeze=False) figure.suptitle(title) # Generate timestamps for time-domain plotting timestamps = self.timestamps # Infer the axis indices to account for different plot time_axis_idx = 0 frequency_axis_idx = 1 if space == 'both' else 0 for stream_idx, stream_samples in enumerate(self.__samples): # Plot time space if space in {'both', 'time'}: axes[stream_idx, time_axis_idx].plot(timestamps, stream_samples.real, label='Real') axes[stream_idx, time_axis_idx].plot(timestamps, stream_samples.imag, label='Imag') axes[stream_idx, time_axis_idx].set_xlabel('Time-Domain [s]') if legend: axes[stream_idx, time_axis_idx].legend(loc="upper left", fancybox=True, shadow=True) # Plot frequency space if space in {'both', 'frequency'}: frequencies = fftshift( fftfreq(self.num_samples, 1 / self.sampling_rate)) bins = fftshift(fft(stream_samples)) axes[stream_idx, frequency_axis_idx].plot(frequencies, np.abs(bins)) axes[stream_idx, frequency_axis_idx].set_ylabel('Abs') axes[stream_idx, frequency_axis_idx].set_xlabel( 'Frequency-Domain [Hz]') if angle: phase = axes[stream_idx, frequency_axis_idx].twinx() phase.plot(frequencies, np.angle(bins)) phase.set_ylabel('Angle [Rad]') return figure
def FFT(x): # return np.abs(np.array([fftshift(fftfreq(FS)),fftshift(fft(x))])) return fftshift(fft(x))
fnames_cal = glob.glob( '/media/apn/datadrive/hydrogen-line/2020-05-16-firstlight/*terminated*.bin') fs = 5e6 # sampling rate # offset measured in bytes # count measured in samples offset_sec = 0.5 # skip turn on artifacts sec_to_read = 1 d = [ np.fromfile( fname, dtype = np.complex64, count = int(sec_to_read*fs), offset = int(8* offset_sec* fs )) for fname in fnames_cal ] psd = [ welch( _d, fs = fs, nperseg = 2**10, noverlap = None, detrend = 'linear', window = 'hamming', return_onesided = False ) for _d in d ] # psd is a list each element is f,p # fftsshift for ease of use f,p = psd[0] f = fftshift(f) p = fftshift(p) cal_fit_db = spectralBaseline( f, db10(p), band_edge = 1.6e6, band_notches = [[ -0.05e6, 0.05e6 ]] ) #useidx = np.where( np.logical_and( np.abs(f)<1.6e6 , np.abs(f)>0.05e6) )[0] #poly_fit_order=2 # tried 4 and results didn't work well. #cal_fit = polynomial.polyfit( f[useidx]/1e6, db10(p[useidx]), poly_fit_order ) #cal_fit_val = polynomial.polyval( f/1e6, cal_fit) center_freq_idx = np.argmin( np.abs( f )) cal = cal_fit_db - cal_fit_db[ center_freq_idx ]
def return_shiffetd_fft(Image): fft_im = fft.fft2(Image) fft_im_sh = fft.fftshift(fft_im) return fft_im_sh
def _fft(image): """shifted fft 2D """ return fftshift(fftn(fftshift(image)))
# Grid in the plane of the aperture x_in = np.linspace(-2, 2, 1000) # 1000 by 1000 grid to get detail in the pattern dx = (max(x_in) - min(x_in)) / len(x_in) y_in = np.linspace(-2, 2, 1000) dy = (max(y_in) - min(y_in)) / len(y_in) x_in, y_in = np.meshgrid(x_in, y_in) grid_in = np.vstack((x_in.flatten(), y_in.flatten())).T # The Electric field in the plane of the aperture E_in = np.array([E_0 * double_sq(g[0], g[1]) for g in grid_in ]) # two small square holes in the aperture plane E_in = np.reshape(E_in, (len(x_in), len(y_in))) # The output frequencies X_out = fftshift(fftfreq(len(x_in), dx)) Y_out = fftshift(fftfreq(len(y_in), dy)) X_out *= z / k # Converting from conjugate units to centimetres Y_out *= z / k E_out = fftshift(fft2(E_in)) # reordering the data for better plotting I_out = np.power(np.abs(E_out), 2) # Calculating the output intensity plt.pcolormesh(X_out, Y_out, I_out, shading='nearest', cmap='gray') plt.colorbar() plt.show()
"E1": 0.15, "B2": 0.15, "G3": 0.15, "D4": 0.08, "A5": 0.08, "E6": 0.04 } for record in records: # one file at a time samplerate, data = wavfile.read(record) N = len(data) T = 1.0 / samplerate yf = fft(data) xf = fftfreq(N, T) xf = fftshift(xf) yplot = fftshift(yf) size = len(xf) # To better visualize the output, only low frequencies are seen # because that's the domain of guitar strings, usually. start = int(9 * size / 20) end = int(11 * size / 20) xf = xf[start:end] yplot = yplot[start:end] yplot = 1.0 / N * np.abs(yplot) plt.plot(xf, yplot)
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.fft 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()
# We next show how rotation and scaling differences, but not translation # differences, are apparent in the frequency magnitude spectra of the images. # These differences can be recovered by treating the magnitude spectra as # images themselves, and applying the same log-polar + phase correlation # approach taken above. # First, band-pass filter both images image = difference_of_gaussians(image, 5, 20) rts_image = difference_of_gaussians(rts_image, 5, 20) # window images wimage = image * window('hann', image.shape) rts_wimage = rts_image * window('hann', image.shape) # work with shifted FFT magnitudes image_fs = np.abs(fftshift(fft2(wimage))) rts_fs = np.abs(fftshift(fft2(rts_wimage))) # Create log-polar transformed FFT mag images and register shape = image_fs.shape radius = shape[0] // 8 # only take lower frequencies warped_image_fs = warp_polar(image_fs, radius=radius, output_shape=shape, scaling='log', order=0) warped_rts_fs = warp_polar(rts_fs, radius=radius, output_shape=shape, scaling='log', order=0) warped_image_fs = warped_image_fs[:shape[0] // 2, :] # only use half of FFT warped_rts_fs = warped_rts_fs[:shape[0] // 2, :] shifts, error, phasediff = phase_cross_correlation(warped_image_fs, warped_rts_fs, upsample_factor=10)
import math import skimage from skimage import io, viewer, color, data, filters, feature, morphology from pathlib import Path import matplotlib.pyplot as plt import numpy as np from scipy.fft import ifft, fft, ifft2, fft2, fftshift from scipy import signal scan_gs_bird = np.load('scan_gs_bird.npy') scan_gs_sample2 = np.load('scan_gs_Sample2.npy') cropped_sample2 = scan_gs_sample2[0:4000, 0:4000] scan_gs_sample2_FT = fft2(cropped_sample2) shifted_FT = fftshift(scan_gs_sample2_FT) window_width = 100 one_d_window = np.hamming(len(scan_gs_sample2_FT)) window = np.sqrt(np.dot(one_d_window, one_d_window.T))**window_width low_passed_scan_FrequencyDomain = shifted_FT * window low_passed_scan = ifft2(low_passed_scan_FrequencyDomain) plottable_lps = np.abs(low_passed_scan) fig, ax = plt.subplots(ncols=2, figsize=(8, 2.5)) fig.suptitle('213 time my dudes') ax[0].imshow(cropped_sample2, cmap='binary') ax[0].set_title('Original') ax[0].axis('off')
#configure pluto sample_rate = 60e6 center_freq = 2.45e9 exponent = 10 num_samples = 2**exponent sdr = adi.Pluto("ip:192.168.2.1") sdr.sample_rate = int(sample_rate) sdr.rx_rf_bandwidth = int(sample_rate) sdr.rx_lo = int(center_freq) sdr.rx_buffer_size = num_samples for x in range(15): data = sdr.rx() shifted_spectrum = fftshift(fft(data)) print(shifted_spectrum) spec2 = abs(np.square(np.real(shifted_spectrum))) + abs( np.square(np.imag(shifted_spectrum))) #plt.figure(0) #plt.specgram(abs(shifted_spectrum),scale='dB') #plt.figure(1) plt.draw() plt.pause(0.001) time.sleep(0.001) plt.specgram(spec2, scale='dB') print("done") plt.show()
def algoritmo_clasifica_cpw(dataset, conjunto, BPFI_cte, BPFO_cte, fs): DE, FE, t_DE, t_FE, RPM, samples_s_DE, samples_s_FE = lee_dataset(dataset) fr = RPM / 60 if math.isnan(fr): fr = 29.95 if conjunto == 'DE': datos = DE * np.hamming(len(DE)) dt = t_DE[1] - t_DE[0] kurt = kurtosis(datos) elif conjunto == 'FE': datos = FE * np.hamming(len(FE)) dt = t_FE[1] - t_FE[0] kurt = kurtosis(datos) else: print('Tipo de conjunto erroneo') ceps = complex_cepstrum(datos) BPFI = BPFI_cte * fr BPFO = BPFO_cte * fr title = 'Envelope spectrum' fSpecCeps, xSpecCeps, fSpecGCeps, BPFI_coordsCeps, BPFO_coordsCeps = envelope_spectrum( ceps, fs, BPFI, BPFO, title, 1) fft_envspec = fftshift(fft(detrend(xSpecCeps))) fft_envspec_norm = abs(fft_envspec) / np.max(abs(fft_envspec)) frec_ceps = fftshift(fftfreq(len(xSpecCeps), dt)) fig = plt.figure(figsize=(20, 10)) plt.plot(frec_ceps, fft_envspec_norm) BPFI_coords = np.arange(BPFI, fs / 8, BPFI) for xc in BPFI_coords: if xc == BPFI_coords[0]: plt.axvline(x=xc, color='r', linestyle='--', lw=1.5, alpha=0.5, label='BPFI') else: plt.axvline(x=xc, color='r', linestyle='--', lw=1.5, alpha=0.5) BPFO_coords = np.arange(BPFO, fs / 8, BPFO) for xc2 in BPFO_coords: if xc2 == BPFO_coords[0]: plt.axvline(x=xc2, color='g', linestyle='--', lw=1.5, alpha=0.5, label='BPFO') else: plt.axvline(x=xc2, color='g', linestyle='--', lw=1.5, alpha=0.5) plt.xlim(0, fs / 2) plt.legend(fontsize=12) fft_envspec_norm_pos = fft_envspec_norm[len(fft_envspec_norm) // 2:len(fft_envspec_norm)] frec_pos = frec_ceps[len(frec_ceps) // 2:len(frec_ceps)] maximos, frec_max = busca_maximos_locales(frec_pos, fft_envspec_norm_pos, BPFI, BPFO, fr, fs) por_comunes_BPFI, por_comunes_BPFO = por_comunes_fft( frec_max, BPFI_coords, BPFO_coords, fr) print(kurt) print(por_comunes_BPFI, por_comunes_BPFO) # CLASIFICACIÓN clasificacion = '' if por_comunes_BPFI > 70 and por_comunes_BPFI > 10 + por_comunes_BPFO and kurt > 20: clasificacion = 'MUY probable: fallo en inner race' elif por_comunes_BPFO > 70 and por_comunes_BPFO > 10 + por_comunes_BPFI and 15 > kurt > 2: clasificacion = 'MUY probable: fallo en outer race' elif abs(por_comunes_BPFI - por_comunes_BPFO) < 10 and kurt < 3: clasificacion = 'MUY probable: sano' elif por_comunes_BPFI < 50 and por_comunes_BPFO < 50 and abs( por_comunes_BPFO - por_comunes_BPFO) > 10 and kurt < 3: clasificacion = 'Probablemente sano' elif por_comunes_BPFO > 50 and por_comunes_BPFO > por_comunes_BPFI and 15 > kurt > 2: clasificacion = 'Probablemente fallo en outer race' elif por_comunes_BPFI > 50 and por_comunes_BPFI > por_comunes_BPFO and kurt > 20: clasificacion = 'Probablemente fallo en inner race' elif kurt > 20: clasificacion = 'No concluyente, posible fallo en inner race' elif 15 > kurt > 2: clasificacion = 'No concluyente, posible fallo en outer race' else: clasificacion = 'No concluyente' return clasificacion
r0 = 100 N = 1000 x = np.linspace(-200, 200, N) Δx = x[1] - x[0] y = np.linspace(-200, 200, N) Δy = y[1] - y[0] X, Y = np.meshgrid(x, y) circ = X**2 + Y**2 < r0**2 # Función circ # In[3]: plt.axes(projection='3d').plot_surface(X, Y, circ, cmap='viridis') # In[4]: fftU = fftshift( fft2(1 - circ)) * Δx * Δy # Transformada de Fourier del campo de entrada fx = fftshift(fftfreq(N, Δx)) Δfx = fx[1] - fx[0] fy = fftshift(fftfreq(N, Δy)) Δfy = fy[1] - fy[0] Fx, Fy = np.meshgrid(fx, fy) # In[5]: z = 5 α = 2 * np.pi * np.sqrt(abs(1 - (Fx**2 + Fy**2))) H = np.exp(1j * α * z) # Función de transferencia U = (ifft2(fftU * H)) * Δfx * Δfy # Campo a una distancia z # In[6]:
offset=int(8 * offset_sec * fs)) for fname in fnames_cal ] psd = [ welch(_d, fs=fs, nperseg=2**10, noverlap=None, detrend='linear', window='hamming', return_onesided=False) for _d in d ] # psd is a list each element is f,p # fftsshift for ease of use f, p = psd[0] f = fftshift(f) p = fftshift(p) cool_fit_db = spectralBaseline(f, db10(p), band_edge=1.6e6, band_notches=[[-0.05e6, 0.05e6], [-0.2e6, 0.4e6]]) plt.figure() plt.plot(f / 1e6, db10(p)) plt.plot(f / 1e6, cool_fit_db) zero_freq_idx = np.argmin(np.abs(f)) plt.figure() plt.plot(f / 1e6, db10(p) - cal_fit_db + cal_fit_db[zero_freq_idx])
def _get_frequency_peaks(time, signal, sfreq, min_peak_height=100): sp = fftshift(fft(signal)) freq = fftshift(fftfreq(time.shape[-1], 1 / sfreq)) peaks_idx, _ = find_peaks(sp, height=min_peak_height) return np.array(list(set(np.abs(freq[peaks_idx]))))
def fourierTest(mu1, mu2, pos, states_s, states_u, ang, Data): import numpy as np from scipy.fft import fft, fftfreq, fftshift import matplotlib.pyplot as plt signal_s = [] signal_u = [] fig1, ax1 = plt.subplots() fig12, ax12 = plt.subplots() fig2, ax2 = plt.subplots() fig22, ax22 = plt.subplots() fig3, ax3 = plt.subplots() fig32, ax32 = plt.subplots() if len(states_s): for i in states_s: if abs(i[-1, 1]) < abs(pos[0] - mu1): if len(i[0, :0:-1]) % 2: temp = fft(i[0, :1:-1] - pos[0] + i[1, :1:-1] * 1.j) l = len(i[0, :1:-1]) signal_s.append(temp) else: temp = fft(i[0, :0:-1] - pos[0] + i[1, :0:-1] * 1.j) l = len(i[0, :0:-1]) signal_s.append(temp) xf = fftfreq(l, Data['prnt_out_dt']) xf = fftshift(xf) yf = fftshift(temp) ax1.plot( xf[abs(yf) > 0.01 * max(abs(yf))], 100.0 / l * np.real(yf[abs(yf) > 0.01 * max(abs(yf))])) ax12.plot( xf[abs(yf) > 0.01 * max(abs(yf))], 100.0 / l * np.imag(yf[abs(yf) > 0.01 * max(abs(yf))])) if len(states_u): for i in states_u: if abs(i[-1, 1]) < abs(pos[0] - mu1): if len(i[0, :-1]) % 2: temp = fft(i[0, :-2] - pos[0] + i[1, :-2] * 1.j) l = len(i[0, :-2]) signal_u.append(temp) else: temp = fft(i[0, :-1] - pos[0] + i[1, :-1] * 1.j) l = len(i[0, :-1]) signal_u.append(temp) xf = fftfreq(l, Data['prnt_out_dt']) xf = fftshift(xf) yf = fftshift(temp) ax2.plot( xf[abs(yf) > 0.01 * max(abs(yf))], 100.0 / l * np.real(yf[abs(yf) > 0.01 * max(abs(yf))])) ax22.plot( xf[abs(yf) > 0.01 * max(abs(yf))], 100.0 / l * np.imag(yf[abs(yf) > 0.01 * max(abs(yf))])) if len(states_u) and len(states_s) and Data['d'] == 1: for i in range(len(states_s)): if len(states_s[i][0, :-1]) % 2: vecx1 = states_s[i][0, :1:-1] vecy1 = states_s[i][1, :1:-1] else: vecx1 = states_s[i][0, :0:-1] vecy1 = states_s[i][1, :0:-1] if len(states_u[i][0, :-1]) % 2: vecx2 = states_u[i][0, :-2] vecy2 = states_u[i][1, :-2] else: vecx2 = states_u[i][0, :-1] vecy2 = states_u[i][1, :-1] vecx = np.append(vecx1, vecx2) vecy = np.append(vecy1, vecy2) temp = fft(vecx - pos[0] + vecy * 1.j) l = len(vecx) signal_s.append(temp) xf = fftfreq(l, Data['prnt_out_dt']) xf = fftshift(xf) yf = fftshift(temp) ax3.plot(xf[abs(yf) > 0.01 * max(abs(yf))], 100.0 / l * np.real(yf[abs(yf) > 0.01 * max(abs(yf))])) ax32.plot(xf[abs(yf) > 0.01 * max(abs(yf))], 100.0 / l * np.imag(yf[abs(yf) > 0.01 * max(abs(yf))])) plt.show()
def digitize(x): if bitdepth is 0: return x a = (2**bitdepth-1) return float64(int32(a*x/max(x)))/a def dB(x): return 10*log10(x) def add_detail(x): if x =='0': return 'non-digitalized' return x+' bit' X = linspace(-7, 7, nsamples) #plot(X,f(X)) bds = [0, 8, 12, 16] for bitdepth in bds: plot(dB(abs(fft.fftshift(fft.fft(digitize(f(X))))))) legend(map(lambda x:add_detail(str(x)),bds),loc='upper left') xlabel('frequency domain (a.u.)') ylabel('signal (dB)') #ns = [512, 1024, 2048] #bitdepth = 8 #for nsamples in ns: # X = linspace(-7, 7, nsamples) # K = X*nsamples/512.0 # plot(K,dB(abs(fft.fftshift(fft.fft(digitize(f(X))))))) #legend(map(str,ns))
def shift(self): """This method shifts the image mean (the zero-frequency component) towards the center of the image""" self._plotting = np.abs(fft.fftshift(self._data))