def plot_phase(self, finalfreq): #MOVER # plot different spectrum types: plt.phase_spectrum(self.output_signal, Fs=self.fs, color='C1') plt.xlabel('f(Hz)') plt.ylabel('rad') plt.xlim(0, finalfreq) plt.show()
def plot_snd(fn): print "load file:", fn raw = load_sound_files(fn) s = np.array(raw) N = 5 i = 1 figsize = (5, 7) plt.figure(figsize=figsize) plt.subplot(N, 1, i) plt.title(fn) #plt.plot(t, s) librosa.display.waveplot(s, sr=22050) #plt.plot(s) i = i + 1 plt.subplot(N, 1, i) #sp = librosa.core.spectrum(s,Fs=Fs) #plt.plot(sp) plt.ylabel("magnitude_spectrum") plt.magnitude_spectrum(s, Fs=Fs) #plt.subplot(4, 1, 3) #plt.magnitude_spectrum(s, Fs=Fs, scale='dB') i = i + 1 plt.subplot(N, 1, i) plt.title("STFT-amp") #plt.angle_spectrum(s, Fs=Fs) a, amax, amin = get_amp(s) print "STFT-amp shape:", a.shape ave = np.average(a, axis=1) print "min:", amin, "max:", amax, "ave of amp:", ave plt.plot(a) #plt.plot(ave) fingerprints = a.reshape(1, 2048)[0] #.astype(np.float32) print "fingerprint:", fingerprints.shape, len( fingerprints), fingerprints[:10] i = i + 1 plt.subplot(N, 1, i) plt.title("MFCC") mfccs = librosa.feature.mfcc(y=s, sr=Fs, n_mfcc=24) print "MFCC:", mfccs.shape, len(mfccs) plt.plot(mfccs) i = i + 1 plt.subplot(N, 1, i) plt.title("phase_spectrum") plt.phase_spectrum(s, Fs=Fs) plt.tight_layout() plt.show() png = "%s.png" % (fn.split("/")[-1].split(".")[0]) plt.savefig(png)
def rectangularPulse(A, tStart, tEnd, t0, t1): y = [] time = np.arange(t0, t1, 1 / 100) for x in time: if x > tStart and x < tEnd: y.append(A) else: y.append(0) #time domain plt.figure() plt.plot(time, y) plt.xlabel('time') plt.ylabel('amplitude') #magnitude plot Y = np.fft.fft(y) plt.figure() plt.xlabel('index') plt.ylabel('magnitude') plt.plot(abs(Y)) #phase spectrum plt.figure() plt.xlabel('Frequency') plt.ylabel('Phase (Radians)') plt.phase_spectrum(y)
def plot_transfer_function(in_data, out_data, fs): # plot_magn_and phase? L = len(out_data) in_pad = pad_input_to_output_length(in_data, out_data) in_fft = fft(in_pad) / L out_fft = fft(out_data) / L # t = np.linspace(0, L, L) / fs tf = out_fft / in_fft fn = fs / 2 # ? fv = np.linspace(0, 1, np.floor(L / 2) + 1) * fn fig, ax = plt.subplots() #ax.semilogy(fv, np.abs(tf[:len(fv)])*2) #plt.plot(fv, 20*np.log10(np.abs(tf[:len(fv)]))) #ax.semilogy(fv, 20*np.log10(np.abs(tf[:len(fv)]))) ax.grid() #plt.plot(t, in_pad, t, out_data) #plt.plot(fv, np.imag(tf[:len(fv)])) #plt.yscale("symlog") #plt.plot(np.angle(tf)) spectrum, freqs, line = plt.phase_spectrum(out_data, fs) #spectrum, freqs, line = plt.magnitude_spectrum(tf, fs) #pxx, freqs = plt.psd(tf, NFFT=None, Fs=fs) # in_data, out_data #spectrum, freqs, line = plt.angle_spectrum(tf, fs) plt.plot(freqs, spectrum) plt.show()
def plot_Phase(self, sensor: str): """ Plots Phase Function of a single sensor. :param sensor: The value of the column name from the loaded files where the desired information is. [SENSOR NAME] :param sampling_freq: The signal sampling frequency. :return Return Instance so that it can be linearly written in code. """ plt.phase_spectrum(x=self.data_read[sensor], Fs=self.sampling_rate) # Setup Plot Parameters. plt.title('Phase Function of ' + sensor) plt.show() return self # Return Instance so that it can be linearly written in code.
def plotWavAnalysisDeep(): """ Read .WAV files, then plot a full analysis of the signal as in: https://matplotlib.org/gallery/lines_bars_and_markers/spectrum_demo.html#sphx-glr-gallery-lines-bars-and-markers-spectrum-demo-py Plot 1: """ # Cut to the last ~30 seconds of the song since it had the most interesting # spectrogram. rate, data = wavfile.read('./Give_Love_A_Try.wav') f, t, Sxx = signal.spectrogram(data,rate) myfft = sf.sfft2(f) Interval = t[t.size-1] - t[0] Fs = len(myfft) # no. of samples s = np.abs(myfft)[:len(myfft)//2] # Real signal symmetry only requires half the samples # plot time signal: plt.subplot(3,2,1) plt.title("Signal") plt.plot(s , color='C0') plt.xlabel("Time") plt.ylabel("Amplitude") # plot different spectrum types: plt.subplot(3,2,3) plt.title("Magnitude Spectrum") plt.magnitude_spectrum(s, Fs=Fs, color='C1') plt.subplot(3,2,4) plt.title("Logarithmic Magnitude Spectrum") plt.magnitude_spectrum(s, Fs=Fs, scale='dB', color='C1') plt.subplot(3,2,5) plt.title("Phase Spectrum") plt.phase_spectrum(s, Fs=Fs, color='C2') plt.subplot(3,2,6) plt.title("Anlge Spectrum") plt.angle_spectrum(s, Fs=Fs, color='C2') plt.tight_layout() plt.show()
def plotStep(): A=1 t0=0 t=np.linspace(-5,5,100) fs=100 x=myStep(A,t0,t) plt.figure() plt.plot(x) plt.xlabel('Time') plt.ylabel('Amplitude') plt.figure() plt.phase_spectrum(x,fs) plt.figure() plt.magnitude_spectrum(x,fs)
def generate_spectres(path, signal, Fs, stypeName): spectrum = np.fft.fft(signal) # Transformada de Fourier #freqs = np.fft.fftfreq(len(signal), 1/Fs) # Frequências do Sinal freqs = np.fft.fftfreq(len(spectrum)) magnitude = np.abs(spectrum) # Amplitude do Sinal #phase = np.angle(spectrum) # Fase do Sinal plt.subplot(2, 1, 1) #plt.magnitude_spectrum(signal,Fs=0.01, color='C1') plt.plot(freqs, magnitude) plt.title('Espectros do Sinal') plt.ylabel("Magnitude") plt.xlabel('Frequência (Hz)') plt.subplot(2, 1, 2) plt.phase_spectrum(signal, Fs=Fs, color='C2') #plt.plot(freqs, phase) plt.xlabel('Frequência (Hz)') plt.ylabel("Fase") plt.tight_layout() plt.savefig(path + "Amplitude_Fase_" + stypeName) plt.show()
def simulate_over_R_G(): # SET R TO AT LEAST 10 ** 4 FOR AN EFFECT ON THE SIMULATION! print_band_gap_frequencies(C0, L0, C, L, CELL_LEN) gammas = [] for i in range(-10, 3): r = R * (10**i) g = r abcd_simulator = ABCDSimulator(r, L0, g, C0, L, C, CELL_LEN, CELLS_NUM, START_FREQ, END_FREQ, V_end, I_end) abcd_simulator.run() abcd_simulator.plot_s_params() gammas.append(abcd_simulator.gamma_arr) plt.figure(1) title = f'Gamma vs frequency over different R,G' plt.suptitle(title, fontSize=FONT_SIZE) for i in range(-10, 3): r = R * (10**i) plt.phase_spectrum(gammas[10 + i], label=f'R=G={r}') plt.xlabel('Frequency (Hz)') plt.ylabel('Gamma (Db)') plt.legend(loc='best') plt.show()
# Load the data and calculate the time of each sample samplerate, data = wavfile.read('bark of the pine tree.wav') times = np.arange(len(data)) / float(samplerate) # You can tweak the figsize (width, height) in inches plt.figure(figsize=(width, height)) plt.title('wav file in time domain') #plt.fill_between(times, data[:,0], data, color='b') plt.xlim(times[0], times[-1]) plt.xlabel('time (s)') plt.ylabel('amplitude') plt.plot(times, data) plt.savefig('plot.jpeg', dpi=80) plt.show() # Plot the signal read from wav file plt.figure(figsize=(width, height)) #first arg - length. second - height. plt.title('Spectrogram of a wav file') plt.specgram(data, Fs=samplerate) #left channel only plt.xlabel('Time') plt.ylabel('Frequency') plt.show() #spectre = np.fft.fft(data) #freq = np.fft.fftfreq(data.size, 1/samplerate) plt.figure(figsize=(width, height)) #first arg - length. second - height. plt.title('phase of a wav file') plt.phase_spectrum(data, Fs=samplerate)
def phase_spectrum(*args, **kwargs): r"""starkplot wrapper for phase_spectrum""" return _pyplot.phase_spectrum(*args, **kwargs)
def plotInFrequency(y, fs): N = len(y) Y = np.fft.fft(y) Y = abs(Y) N = int(np.ceil(N / 2)) Y = Y[:N] f = np.arange(0, fs / 2, fs / 2 / N) plt.plot(f, Y) plt.grid() plt.title('Magnitude Spectrum(first version)') plt.xlabel('Frequency') plt.ylabel('Magnitude') plt.figure() x = np.array([1, -2, 0, 1]) X = np.fft.fft(x) y = myCosine(2, 5, 0, 1, 2, 100) #A=2,f=5,ph0=0,t0=1,t1=2,fs=100 plotInTime(y, 100) plotInFrequency(y, 100) plt.title('Magnitude Spectrum(second version)') plt.magnitude_spectrum(y, 100) plt.grid() plt.figure() plt.title('Phase Spectrum') plt.phase_spectrum(y, 100) plt.grid() #We have 2 versions for the magnitude,the first one is computted manually #,and the second one is provided by the matplot library
cnse = cnse[:len(t)] s = 0.1 * np.sin(2 * np.pi * t) + cnse plt.subplot(3, 2, 1) plt.plot(t, s) plt.subplot(3, 2, 3) plt.magnitude_spectrum(s, Fs=Fs) plt.subplot(3, 2, 4) plt.magnitude_spectrum(s, Fs=Fs, scale='dB') plt.subplot(3, 2, 5) plt.angle_spectrum(s, Fs=Fs) plt.subplot(3, 2, 6) plt.phase_spectrum(s, Fs=Fs) plt.show() print("Test04-----------Start------------------") x = np.array([0, 1, 2, 3, 4]) y = np.array([-1, 0.2, 0.9, 2.1, 1.2]) A = np.vstack([x, np.ones(len(x))]).T m, c = np.linalg.lstsq(A, y)[0] plt.plot(x, y, 'o', label='Original data', markersize=10) plt.plot(x, m * x + c, 'r', label='Fitted line') plt.legend() plt.show()
plt.figure(figsize=(12, 4)) plt.plot(n, s) plt.title('Sinal Modulado') plt.xlabel('Tempo(s)') plt.ylabel('Amplitude') plt.grid() plt.show() # Graficos de espectros plt.subplot(2, 1, 1) plt.magnitude_spectrum(s, Fs=Fs, color='C1') plt.title('Espectros do Sinal Modulado') plt.ylabel("Magnitude") plt.xlabel('Frequência (Hz)') plt.subplot(2, 1, 2) plt.phase_spectrum(s, Fs=Fs, color='C2') plt.xlabel('Frequência (Hz)') plt.ylabel("Fase") plt.tight_layout() plt.show() # Demodulação do sinal fa = 10 h = s * np.cos(2 * np.pi * fa * n) plt.figure(figsize=(12, 4)) plt.plot(n, h) plt.title('Sinal Demodulado') plt.xlabel('Tempo(s)') plt.ylabel('Amplitude') plt.grid() plt.show()
import matplotlib.pyplot as plt import numpy as np Fs = 100 T = 1 / Fs N = 50 n = np.arange(0, N) w = .1 * np.pi x_n = np.cos(w * n) X_w = np.fft.fft(x_n / len(x_n)) X_w = X_w[range(int(len(x_n)))] tp = len(x_n) val = np.arange(int(tp / 2)) tim_per = tp / Fs fre = val / tim_per plt.subplot(311) plt.plot(x_n) plt.subplot(312) plt.magnitude_spectrum(x_n) plt.subplot(313) plt.phase_spectrum(x_n) plt.show()
plt.title("STFT: %s" % dictionary[key]) plt.xlabel("Frequency [Hz]") plt.ylabel("Amplitude [g]") plt.grid("True", which='both') plt.semilogx(np.arange(len(data_fft)) / 2 / fs, data_fft / fs) plt.tight_layout() plt.savefig("./data/%s.png" % key[4:], format='png') plt.figure(figsize=(10, 10)) plt.subplot(2, 1, 1) plt.title("Widmo Amplitudowo-częstotliwościowe: {}".format( dictionary[key])) plt.ylabel("Amplituda") plt.xlabel("Częstotliwość [Hz]") spectrum = Spectrum(stft) frequencyArray = np.linspace(0, fs / 2, len(spectrum)) plt.grid(True, which='both') plt.semilogx(frequencyArray, spectrum) plt.subplot(2, 1, 2) plt.title("Widmo fazowo-czętotliwościowe: {}".format(dictionary[key])) plt.phase_spectrum(stft, Fs=fs) plt.grid(True, which='both') plt.tight_layout(pad=1.1) plt.savefig('./a/zad4{}.png'.format(dictionary[key]), format='png') peaks = sg.find_peaks(spectrum, threshold=0.05 * np.max(spectrum)) print("in: \"{}\" peaks where found at: {}".format( dictionary[key], [str(i) + "Hz" for i in peaks[0]]))
#Make Equal length Spectrums pad_to1 = highestPowerof2(len(sig1)) pad_to2 = highestPowerof2(len(sig2)) pad_to = min(pad_to1,pad_to2) if fs1 != fs2: print('Unable to Calculate. (Sampling Freqs are different)') sys.exit(0) #Signal 1 sig1 = sig1/max(sig1) spectrum1, freqs1, line1 = plot.magnitude_spectrum(sig1, Fs = fs1, scale = 'dB', pad_to = pad_to) spectrum_db1 = 20*np.log10(spectrum1) phase1,freqs_phase1,line_phase1 = plot.phase_spectrum(sig1, Fs = fs1, pad_to = pad_to) #Signal 2 sig2 = sig2/max(sig2) spectrum2, freqs2, line2 = plot.magnitude_spectrum(sig2, Fs = fs2, scale = 'dB', pad_to = pad_to) spectrum_db2 = 20*np.log10(spectrum2) phase2,freqs_phase2,line_phase2 = plot.phase_spectrum(sig2, Fs = fs2, pad_to = pad_to) #1st Spectrum Plot plot.subplot(221) y_max1 = max(spectrum_db1)+5 y_min1 = max(min(spectrum_db1)-5,-100) plot.ylim([y_min1,y_max1]) plot.title(args.i1.split('/')[-1] + ' Spectrum')
print("====== ZAD 4 ======") plt.figure(figsize=(10,10)) plt.subplot(2, 1, 1) plt.title("Widmo Amplitudowo-częstotliwościowe") plt.ylabel("Amplituda") plt.xlabel("Częstotliwość [Hz]") spectrum = Spectrum(signalOutput) frequencyArray = np.linspace(0, fs/2, len(spectrum)) plt.grid(True, which='both') plt.plot(frequencyArray, spectrum) plt.subplot(2, 1, 2) plt.title("Widmo fazowo-czętotliwościowe") plt.phase_spectrum(signalOutput, Fs=fs) plt.grid(True, which='both') plt.tight_layout(pad=1.1) plt.savefig('./lab2data/zad4.png', format='png') plt.figure() plt.title("Widmo Uśredniane amplitudowo") plt.xlabel("częstotliwość [Hz]") plt.ylabel("Magnitude") [frequencies, Pxx] = sg.welch(signalOutput, fs=fs, window= 'hamming') plt.plot(frequencies, Pxx) plt.savefig('./lab2data/zad4Averaged.png', format='png')
import numpy as np np.random.seed(0) dt = 0.01 Fs = 1 / dt t = np.arange(0, 10, dt) nse = np.random.randn(len(t)) r = np.exp(-t / 0.05) cnse = np.convolve(nse, r) * dt cnse = cnse[:len(t)] s = 0.1 * np.sin(2 * np.pi * t) + cnse plt.subplot(3, 2, 1) plt.plot(t, s) plt.subplot(3, 2, 3) plt.magnitude_spectrum(s, Fs=Fs) plt.subplot(3, 2, 4) plt.magnitude_spectrum(s, Fs=Fs, scale='dB') plt.subplot(3, 2, 5) plt.angle_spectrum(s, Fs=Fs) plt.subplot(3, 2, 6) plt.phase_spectrum(s, Fs=Fs) plt.show()
stim_downsamp = signal.decimate(stim, int(samp_freq / 5000)) rEMG_downsamp = signal.decimate(rEMG, int(samp_freq / 5000)) lEMG_downsamp = signal.decimate(lEMG, int(samp_freq / 5000)) plt.subplot(2, 1, 1) plt.plot(stim) plt.subplot(2, 1, 2) plt.plot(stim_downsamp) plt.subplot(2, 3, 1) plt.plot(rEMG[0:500]) plt.subplot(2, 3, 2) plt.magnitude_spectrum(rEMG, 25000) plt.xlim([0, 2500]) plt.subplot(2, 3, 3) plt.phase_spectrum(rEMG, 25000) plt.xlim([0, 2500]) plt.subplot(2, 3, 4) plt.plot(rEMG_downsamp[0:100]) plt.subplot(2, 3, 5) plt.magnitude_spectrum(rEMG_downsamp, 5000) plt.subplot(2, 3, 6) plt.phase_spectrum(rEMG_downsamp, 5000) # the above plots look good. downsampling seems to work # desired_freq = 2000 # secs = len(stim)/samp_freq # Number of seconds in signal X # samps = int(round(secs*desired_freq)) # Number of samples to downsample # resample_stim = signal.resample(stim, samps)