def calcFFT(self): #Länge des zu transformierenden Vectors bestimmen N = len(self.volt) #Optimale FFT-Länge bestimmen und ggf Zeropadding N_fast = next_fast_len(N) #Kaiser-Bessel-Fenster bestimmen w = win.kaiser(N,12) w = w / w.sum() * N #Normierung damit Amplituden wieder stimmen #Transformieren yf = fft(self.volt*w, N_fast) yf = fftshift(yf) #Abschneiden yf = yf[N_fast//2:] #Skalieren yf = 2/N_fast*abs(yf) #Frequenzachse erzeugen xf = fftfreq(N_fast) xf = fftshift(xf) #Abschneiden xf = xf[N_fast//2:] #Skalieren xf = xf*self.samplingrate #Veröffentlichen der Werte self.spectrum = yf self.freq = xf return '-DONE-'
def test_basic(self): assert_allclose(windows.kaiser(6, 0.5), [0.9403061933191572, 0.9782962393705389, 0.9975765035372042, 0.9975765035372042, 0.9782962393705389, 0.9403061933191572]) assert_allclose(windows.kaiser(7, 0.5), [0.9403061933191572, 0.9732402256999829, 0.9932754654413773, 1.0, 0.9932754654413773, 0.9732402256999829, 0.9403061933191572]) assert_allclose(windows.kaiser(6, 2.7), [0.2603047507678832, 0.6648106293528054, 0.9582099802511439, 0.9582099802511439, 0.6648106293528054, 0.2603047507678832]) assert_allclose(windows.kaiser(7, 2.7), [0.2603047507678832, 0.5985765418119844, 0.8868495172060835, 1.0, 0.8868495172060835, 0.5985765418119844, 0.2603047507678832]) assert_allclose(windows.kaiser(6, 2.7, False), [0.2603047507678832, 0.5985765418119844, 0.8868495172060835, 1.0, 0.8868495172060835, 0.5985765418119844])
def array_factor(number_of_elements, scan_angle, element_spacing, frequency, theta, window_type, side_lobe_level): """ Calculate the array factor for a linear binomial excited array. :param window_type: The string name of the window. :param side_lobe_level: The sidelobe level for Tschebyscheff window (dB). :param number_of_elements: The number of elements in the array. :param scan_angle: The angle to which the main beam is scanned (rad). :param element_spacing: The distance between elements. :param frequency: The operating frequency (Hz). :param theta: The angle at which to evaluate the array factor (rad). :return: The array factor as a function of angle. """ # Calculate the wavenumber k = 2.0 * pi * frequency / c # Calculate the phase psi = k * element_spacing * (cos(theta) - cos(scan_angle)) # Calculate the coefficients if window_type == 'Uniform': coefficients = ones(number_of_elements) elif window_type == 'Binomial': coefficients = binom(number_of_elements - 1, range(0, number_of_elements)) elif window_type == 'Tschebyscheff': warnings.simplefilter("ignore", UserWarning) coefficients = chebwin(number_of_elements, at=side_lobe_level, sym=True) elif window_type == 'Kaiser': coefficients = kaiser(number_of_elements, 6, True) elif window_type == 'Blackman-Harris': coefficients = blackmanharris(number_of_elements, True) elif window_type == 'Hanning': coefficients = hanning(number_of_elements, True) elif window_type == 'Hamming': coefficients = hamming(number_of_elements, True) # Calculate the offset for even/odd offset = int(floor(number_of_elements / 2)) # Odd case if number_of_elements & 1: coefficients = roll(coefficients, offset + 1) coefficients[0] *= 0.5 af = sum(coefficients[i] * cos(i * psi) for i in range(offset + 1)) return af / amax(abs(af)) # Even case else: coefficients = roll(coefficients, offset) af = sum(coefficients[i] * cos((i + 0.5) * psi) for i in range(offset)) return af / amax(abs(af))
def test_basic(self): assert_allclose(windows.kaiser(6, 0.5), [0.9403061933191572, 0.9782962393705389, 0.9975765035372042, 0.9975765035372042, 0.9782962393705389, 0.9403061933191572]) assert_allclose(windows.kaiser(7, 0.5), [0.9403061933191572, 0.9732402256999829, 0.9932754654413773, 1.0, 0.9932754654413773, 0.9732402256999829, 0.9403061933191572]) assert_allclose(windows.kaiser(6, 2.7), [0.2603047507678832, 0.6648106293528054, 0.9582099802511439, 0.9582099802511439, 0.6648106293528054, 0.2603047507678832]) assert_allclose(windows.kaiser(7, 2.7), [0.2603047507678832, 0.5985765418119844, 0.8868495172060835, 1.0, 0.8868495172060835, 0.5985765418119844, 0.2603047507678832]) assert_allclose(windows.kaiser(6, 2.7, False), [0.2603047507678832, 0.5985765418119844, 0.8868495172060835, 1.0, 0.8868495172060835, 0.5985765418119844])
def sinusoid(size, frequency, angle, beta=0): '''Generate an image with pure sinusoid. The amplitude and DC offset are set so that the minimum and maximum values are 0 and 1, respectively. Parameters ---------- size : tuple width and height of the output image frequency : float frequency in cycles per pixel angle : float value in degrees indicating the orientation of the sinusoid beta : float value of the Kaiser window 'beta' parameter Returns ------- numpy.ndarray the generated output image ''' if frequency < 0: raise ValueError('Frequency must be a positive value.') omega = 2.0 * np.pi * frequency / np.min(size) theta = np.deg2rad(angle) y, x = np.meshgrid(np.arange(size[1]), np.arange(size[0])) u = x * np.cos(theta) + y * np.sin(theta) out = np.cos(omega * u) / 2.0 + 0.5 w1 = kaiser(size[0], beta) w2 = kaiser(size[1], beta) window = w1[np.newaxis, :].T @ w2[np.newaxis, :] out *= window return out
def proc_im(im, N_im = 256, noise_scale = 50, kaiser_beta = 4): k0 = np.fft.ifftshift(np.fft.fft2(np.fft.fftshift(im))) k0 += noise_scale * (np.random.standard_normal(k0.shape) + 1j * np.random.standard_normal(k0.shape)) # if np.random.rand() < blur_chance: # win_beta = np.random.rand() * (beta_lims[1] - beta_lims[0]) + beta_lims[0] # window = kaiser(N_im, win_beta, sym=False) # k0 *= np.outer(window, window) window = kaiser(N_im, kaiser_beta, sym=False) k0 *= np.outer(window, window) im = np.fft.ifftshift(np.fft.ifft2(np.fft.fftshift(k0))) return im
def _update_canvas(self): """ Update the figure when the user changes an input value :return: """ # Get the parameters from the form number_of_steps = int(self.number_of_steps.text()) frequency_step = float(self.frequency_step.text()) prf = float(self.prf.text()) target_range = self.target_range.text().split(',') target_rcs = self.target_rcs.text().split(',') target_velocity = self.target_velocity.text().split(',') t_range = [float(r) for r in target_range] t_rcs = [float(r) for r in target_rcs] t_velocity = [float(v) for v in target_velocity] # Get the selected window from the form window_type = self.window_type.currentText() if window_type == 'Kaiser': coefficients = kaiser(number_of_steps, 6, True) elif window_type == 'Blackman-Harris': coefficients = blackmanharris(number_of_steps, True) elif window_type == 'Hanning': coefficients = hanning(number_of_steps, True) elif window_type == 'Hamming': coefficients = hamming(number_of_steps, True) elif window_type == 'Rectangular': coefficients = ones(number_of_steps) # Calculate the base band return signal s = zeros(number_of_steps, dtype=complex) for rng, rcs, v in zip(t_range, t_rcs, t_velocity): s += [sqrt(rcs) * exp(-1j * 4.0 * pi / c * (i * frequency_step) * (rng - v * (i / prf))) for i in range(number_of_steps)] n = next_fast_len(10 * number_of_steps) sf = ifft(s * coefficients, n) * float(n) / float(number_of_steps) # range_resolution = c / (2.0 * number_of_steps * frequency_step) range_unambiguous = c / (2.0 * frequency_step) range_window = linspace(0, range_unambiguous, n) # Clear the axes for the updated plot self.axes1.clear() # Create the line plot self.axes1.plot(range_window, 20.0 * log10(abs(sf) + finfo(float).eps), '') # Set the x and y axis labels self.axes1.set_xlabel("Range (m)", size=12) self.axes1.set_ylabel("Amplitude (dBsm)", size=12) # Turn on the grid self.axes1.grid(linestyle=':', linewidth=0.5) # Set the plot title and labels self.axes1.set_title('Stepped Frequency Range Profile', size=14) # Set the tick label size self.axes1.tick_params(labelsize=12) # Update the canvas self.my_canvas.draw()
sig_xmitt *= hann(tsig.size) # create an interpolator, this allows for sub sample timing of arrivals sig_ier = interp1d(tsig, sig_xmitt, kind=3, bounds_error=False, fill_value=0.) # create time series as a sum of all arrivals x_sig = np.zeros_like(taxis) x_sig += sig_ier(taxis - time_dir) / r_dir x_sig -= sig_ier(taxis - time_surf) / r_surf x_sig -= sig_ier(taxis - time_bottom) / r_bottom # create some noise x_sig += np.random.randn(x_sig.size) * np.sqrt(noise_level) # construct a window for the FFT. This is necassary when we don't know where # the edges of the signal will be. window = kaiser(winwidth, 2.5 * pi) num_overlap = int(np.ceil(winwidth * overlap)) # construct a time axis for the single frequency power num_windows = int(np.floor((taxis.size - winwidth) / (winwidth - num_overlap))) win_position = np.arange(num_windows) * (winwidth - num_overlap) win_time = (win_position + winwidth / 2) / fs win_time += taxis[0] # take a sliding position FFT. This will be done on the DSP processing board. # This is used to extract the single frequency content of the signal over time sig_FT = [] for wp in win_position: sig_FT.append(np.fft.rfft(x_sig[wp: wp + winwidth] * window)) sig_FT = np.array(sig_FT) faxis = np.arange(winwidth // 2 + 1) / winwidth * fs
def spec_track(signal, pitch, parameters): #--------------------------------------------------------------- # Set parameters. #--------------------------------------------------------------- nframe_size = pitch.frame_size * 2 maxpeaks = parameters['shc_maxpeaks'] delta = signal.new_fs / pitch.nfft window_length = int(np.fix(parameters['shc_window'] / delta)) half_window_length = int(np.fix(float(window_length) / 2)) if not (window_length % 2): window_length += 1 max_SHC = int( np.fix((parameters['f0_max'] + parameters['shc_pwidth'] * 2) / delta)) min_SHC = int(np.ceil(parameters['f0_min'] / delta)) num_harmonics = parameters['shc_numharms'] #--------------------------------------------------------------- # Main routine. #--------------------------------------------------------------- cand_pitch = np.zeros((maxpeaks, pitch.nframes)) cand_merit = np.ones((maxpeaks, pitch.nframes)) data = np.append( signal.filtered, np.zeros((1, nframe_size + ((pitch.nframes - 1) * pitch.frame_jump - signal.size)))) #Compute SHC for voiced frame window = kaiser(nframe_size, 0.5) SHC = np.zeros((max_SHC)) row_mat_list = np.array([ np.empty((max_SHC - min_SHC + 1, window_length)) for x in range(num_harmonics + 1) ]) magnitude = np.zeros(int((half_window_length + (pitch.nfft / 2) + 1))) for frame in np.where(pitch.vuv)[0].tolist(): fir_step = frame * pitch.frame_jump data_slice = data[fir_step:fir_step + nframe_size] * window data_slice -= np.mean(data_slice) magnitude[half_window_length:] = np.abs( np.fft.rfft(data_slice, pitch.nfft)) for idx, row_mat in enumerate(row_mat_list): row_mat[:, :] = stride_matrix(magnitude[min_SHC * (idx + 1):], max_SHC - min_SHC + 1, window_length, idx + 1) SHC[min_SHC - 1:max_SHC] = np.sum(np.prod(row_mat_list, axis=0), axis=1) cand_pitch[:, frame], cand_merit[:, frame] = \ peaks(SHC, delta, maxpeaks, parameters) #Extract the pitch candidates of voiced frames for the future pitch selection. spec_pitch = cand_pitch[0, :] voiced_cand_pitch = cand_pitch[:, cand_pitch[0, :] > 0] voiced_cand_merit = cand_merit[:, cand_pitch[0, :] > 0] num_voiced_cand = len(voiced_cand_pitch[0, :]) avg_voiced = np.mean(voiced_cand_pitch[0, :]) std_voiced = np.std(voiced_cand_pitch[0, :]) #Interpolation of the weigthed candidates. delta1 = abs( (voiced_cand_pitch - 0.8 * avg_voiced)) * (3 - voiced_cand_merit) index = delta1.argmin(0) voiced_peak_minmrt = voiced_cand_pitch[index, range(num_voiced_cand)] voiced_merit_minmrt = voiced_cand_merit[index, range(num_voiced_cand)] voiced_peak_minmrt = medfilt(voiced_peak_minmrt, max(1, parameters['median_value'] - 2)) #Replace the lowest merit candidates by the median smoothed ones #computed from highest merit peaks above. voiced_cand_pitch[index, range(num_voiced_cand)] = voiced_peak_minmrt voiced_cand_merit[index, range(num_voiced_cand)] = voiced_merit_minmrt #Use dynamic programming to find best overal path among pitch candidates. #Dynamic weight for transition costs balance between local and #transition costs. weight_trans = parameters['dp5_k1'] * std_voiced / avg_voiced if num_voiced_cand > 2: voiced_pitch = dynamic5(voiced_cand_pitch, voiced_cand_merit, weight_trans, parameters['f0_min']) voiced_pitch = medfilt(voiced_pitch, max(1, parameters['median_value'] - 2)) else: if num_voiced_cand > 0: voiced_pitch = (np.ones((num_voiced_cand))) * 150.0 else: voiced_pitch = np.array([150.0]) cand_pitch[0, 0] = 0 pitch_avg = np.mean(voiced_pitch) pitch_std = np.std(voiced_pitch) spec_pitch[cand_pitch[0, :] > 0] = voiced_pitch[:] if (spec_pitch[0] < pitch_avg / 2): spec_pitch[0] = pitch_avg if (spec_pitch[-1] < pitch_avg / 2): spec_pitch[-1] = pitch_avg spec_voiced = np.array(np.nonzero(spec_pitch)[0]) spec_pitch = scipy_interp.pchip(spec_voiced, spec_pitch[spec_voiced])( range(pitch.nframes)) spec_pitch = lfilter(np.ones((3)) / 3, 1.0, spec_pitch) spec_pitch[0] = spec_pitch[2] spec_pitch[1] = spec_pitch[3] return spec_pitch, pitch_std
# We can compare the window to `kaiser`, which was invented as an alternative # that was easier to calculate [Re991e28c1f6b-3]_ (example adapted from # `here <https://ccrma.stanford.edu/~jos/sasp/Kaiser_DPSS_Windows_Compared.html>`_): import numpy as np import matplotlib.pyplot as plt from scipy.signal import windows, freqz N = 51 fig, axes = plt.subplots(3, 2, figsize=(5, 7)) for ai, alpha in enumerate((1, 3, 5)): win_dpss = windows.dpss(N, alpha) beta = alpha*np.pi win_kaiser = windows.kaiser(N, beta) for win, c in ((win_dpss, 'k'), (win_kaiser, 'r')): win /= win.sum() axes[ai, 0].plot(win, color=c, lw=1.) axes[ai, 0].set(xlim=[0, N-1], title=r'$\alpha$ = %s' % alpha, ylabel='Amplitude') w, h = freqz(win) axes[ai, 1].plot(w, 20 * np.log10(np.abs(h)), color=c, lw=1.) axes[ai, 1].set(xlim=[0, np.pi], title=r'$\beta$ = %0.2f' % beta, ylabel='Magnitude (dB)') for ax in axes.ravel(): ax.grid(True) axes[2, 1].legend(['DPSS', 'Kaiser']) fig.tight_layout() plt.show() # And here are examples of the first four windows, along with their # concentration ratios:
def run(r, srcpd, layout): initial_model_filename = "overthrust_3D_initial_model.h5" tn = 5 so = 6 dtype = np.float32 datakey = "m0" nbl = 40 dt = 1.75 time_axis = TimeAxis(start=0, stop=tn, step=dt) nt = time_axis.num model = overthrust_model_iso(initial_model_filename, datakey, so, nbl, dtype) shape = model.shape grid = model.grid origin = (0, 0, 0) spacing = model.spacing coeffs = kaiser(M=r, beta=6.31) # What we accepted as a parameter was sources per dimension. We are going to lay them out on a grid so square the number nsrc = srcpd * srcpd if layout == 'grid': src_coordinates = define_sources_grid(srcpd, model, r) elif layout == 'hemisphere': src_coordinates = define_sources_hemisphere(srcpd, model) else: print("Invalid layout: %s" % layout) return gridpoints = [ tuple((int(floor((point[i] - origin[i]) / grid.spacing[i])) - r / 2) for i in range(len(point))) for point in src_coordinates ] src = PrecomputedSparseTimeFunction(name="src", grid=grid, npoint=nsrc, r=r, gridpoints=gridpoints, interpolation_coeffs=coeffs, nt=nt) ricker = RickerSource(time_range=time_axis, grid=grid, name="ricker", f0=0.008) for p in range(nsrc): src.data[:, p] = ricker.wavelet m = model.m # Create symbols for forward wavefield, source and receivers u = TimeFunction(name='u', grid=grid, save=None, time_order=2, space_order=so) rec = Receiver(name='rec', grid=grid, time_range=time_axis, npoint=nsrc) s = model.grid.stepping_dim.spacing # Define PDE and update rule eq_time = solve(model.m * u.dt2 - u.laplace + model.damp * u.dt, u.forward) # Time-stepping stencil. eqns = [ Eq(u.forward, eq_time, subdomain=model.grid.subdomains['physdomain']) ] # Construct expression to inject source values src_term = src.inject(field=u.forward, expr=src * s**2 / m) # Create interpolation expression for receivers rec_term = rec.interpolate(expr=u) # Substitute spacing terms to reduce flops op = Operator(eqns + src_term + rec_term, subs=model.spacing_map, name='Forward') op.apply(dt=dt) print("u_norm", np.linalg.norm(u.data))
def _update_canvas(self): """ Update the figure when the user changes an input value :return: """ # Get the parameters from the form bandwidth = float(self.bandwidth.text()) pulsewidth = float(self.pulsewidth.text()) target_range = self.target_range.text().split(',') target_rcs = self.target_rcs.text().split(',') t_range = [float(r) for r in target_range] t_rcs = [float(r) for r in target_rcs] # Get the selected window from the form window_type = self.window_type.currentText() # Number of samples N = int(2 * bandwidth * pulsewidth) * 8 if window_type == 'Kaiser': coefficients = kaiser(N, 6, True) elif window_type == 'Blackman-Harris': coefficients = blackmanharris(N, True) elif window_type == 'Hanning': coefficients = hanning(N, True) elif window_type == 'Hamming': coefficients = hamming(N, True) elif window_type == 'Rectangular': coefficients = ones(N) # Set up the time vector t = linspace(-0.5 * pulsewidth, 0.5 * pulsewidth, N) # Calculate the baseband return signal s = zeros(N, dtype=complex) # Chirp slope alpha = 0.5 * bandwidth / pulsewidth for r, rcs in zip(t_range, t_rcs): s += sqrt(rcs) * exp(1j * 2.0 * pi * alpha * (t - 2.0 * r / c)**2) # Transmit signal st = exp(1j * 2 * pi * alpha * t**2) # Impulse response and matched filtering Hf = fft(conj(st * coefficients)) Si = fft(s) so = fftshift(ifft(Si * Hf)) # Range window range_window = linspace(-0.25 * c * pulsewidth, 0.25 * c * pulsewidth, N) # Clear the axes for the updated plot self.axes1.clear() # Create the line plot self.axes1.plot(range_window, 20.0 * log10(abs(so) / N + finfo(float).eps), '') self.axes1.set_xlim(0, max(t_range) + 100) self.axes1.set_ylim(-60, max(20.0 * log10(abs(so) / N)) + 10) # Set the x and y axis labels self.axes1.set_xlabel("Range (m)", size=12) self.axes1.set_ylabel("Amplitude (dBsm)", size=12) # Turn on the grid self.axes1.grid(linestyle=':', linewidth=0.5) # Set the plot title and labels self.axes1.set_title('Matched Filter Range Profile', size=14) # Set the tick label size self.axes1.tick_params(labelsize=12) # Update the canvas self.my_canvas.draw()
# # a1 = 1 # a2 = 1 # a3 = 1 # # x = np.real(a1 * x1 + a2 * x2 + a3 * x3) # x = x / np.max(np.abs(x)) # # decomposer = EMD(x) # imf = decomposer.decompose() # # n_freq_bins = 256 short_window_length = 127 beta = 3 * np.pi window = kaiser(short_window_length, beta=beta) plt.figure(figsize=(15, 15)) plt.plot(x) plt.show() f, t, Sxx = signal.spectrogram(x, freq) print('f') print(f) print('t') print(t.shape) print('Sxx') print(Sxx.shape) # for i in range(0,5): # print(Sxx[0][i]) _positon = np.argmax(Sxx) print(_positon)
alpha_max = 5 plot_no = 1 fig = plt.figure(1, figsize=(9.5, 7)) M = 21 hM1 = M // 2 hM2 = M // 2 + 1 N = 40 hN = N // 2 fig.suptitle('Kaiser window, M = %i, fft size = %i' % (M, N)) for alpha in range(alpha_max + 1): beta = alpha * np.pi w = kaiser(M, beta, M % 2 == 0) fftbuffer = np.zeros(N) fftbuffer[:hM1] = w[hM2:] fftbuffer[N - hM2:] = w[:hM2] W = fft(fftbuffer) mX = np.zeros(N) mX[:hN] = np.abs(W)[hN:] mX[hN:] = np.abs(W)[:hN] pX = np.zeros(N) pX[:hN] = np.angle(W)[hN:] pX[hN:] = np.angle(W)[:hN]
def pre_processing(self): """ Complete various pre-processing steps for encoded protein sequences before doing any of the DSP-related functions or transformations. Zero-pad the sequences, remove any +/- infinity or NAN values, get the approximate protein spectra and window function parameter names. Parameters ---------- :self (PyDSP object): instance of PyDSP class. Returns ------- None """ #zero-pad encoded sequences so they are all the same length self.protein_seqs = zero_padding(self.protein_seqs) #get shape parameters of proteins seqs self.num_seqs = self.protein_seqs.shape[0] self.signal_len = self.protein_seqs.shape[1] #replace any positive or negative infinity or NAN values with 0 self.protein_seqs[self.protein_seqs == -np.inf] = 0 self.protein_seqs[self.protein_seqs == np.inf] = 0 self.protein_seqs[self.protein_seqs == np.nan] = 0 #replace any NAN's with 0's #self.protein_seqs.fillna(0, inplace=True) self.protein_seqs = np.nan_to_num(self.protein_seqs) #initialise zeros array to store all protein spectra self.fft_power = np.zeros((self.num_seqs, self.signal_len)) self.fft_real = np.zeros((self.num_seqs, self.signal_len)) self.fft_imag = np.zeros((self.num_seqs, self.signal_len)) self.fft_abs = np.zeros((self.num_seqs, self.signal_len)) #list of accepted spectra, window functions and filters all_spectra = ['power', 'absolute', 'real', 'imaginary'] all_windows = [ 'hamming', 'blackman', 'blackmanharris', 'gaussian', 'bartlett', 'kaiser', 'barthann', 'bohman', 'chebwin', 'cosine', 'exponential' 'flattop', 'hann', 'boxcar', 'hanning', 'nuttall', 'parzen', 'triang', 'tukey' ] all_filters = [ 'savgol', 'medfilt', 'symiirorder1', 'lfilter', 'hilbert' ] #set required input parameters, raise error if spectrum is none if self.spectrum == None: raise ValueError( 'Invalid input Spectrum type ({}) not available in valid spectra: {}' .format(self.spectrum, all_spectra)) else: #get closest correct spectra from user input, if no close match then raise error spectra_matches = (get_close_matches(self.spectrum, all_spectra, cutoff=0.4)) if spectra_matches == []: raise ValueError( 'Invalid input Spectrum type ({}) not available in valid spectra: {}' .format(self.spectrum, all_spectra)) else: self.spectra = spectra_matches[0] #closest match in array if self.window_type == None: self.window = 1 #window = 1 is the same as applying no window else: #get closest correct window function from user input window_matches = (get_close_matches(self.window, all_windows, cutoff=0.4)) #check if sym=True or sym=False #get window function specified by window input parameter, if no match then window = 1 if window_matches != []: if window_matches[0] == 'hamming': self.window = hamming(self.signal_len, sym=True) self.window_type = "hamming" elif window_matches[0] == "blackman": self.window = blackman(self.signal_len, sym=True) self.window = "blackman" elif window_matches[0] == "blackmanharris": self.window = blackmanharris(self.signal_len, sym=True) #** self.window_type = "blackmanharris" elif window_matches[0] == "bartlett": self.window = bartlett(self.signal_len, sym=True) self.window_type = "bartlett" elif window_matches[0] == "gaussian": self.window = gaussian(self.signal_len, std=7, sym=True) self.window_type = "gaussian" elif window_matches[0] == "kaiser": self.window = kaiser(self.signal_len, beta=14, sym=True) self.window_type = "kaiser" elif window_matches[0] == "hanning": self.window = hanning(self.signal_len, sym=True) self.window_type = "hanning" elif window_matches[0] == "barthann": self.window = barthann(self.signal_len, sym=True) self.window_type = "barthann" elif window_matches[0] == "bohman": self.window = bohman(self.signal_len, sym=True) self.window_type = "bohman" elif window_matches[0] == "chebwin": self.window = chebwin(self.signal_len, sym=True) self.window_type = "chebwin" elif window_matches[0] == "cosine": self.window = cosine(self.signal_len, sym=True) self.window_type = "cosine" elif window_matches[0] == "exponential": self.window = exponential(self.signal_len, sym=True) self.window_type = "exponential" elif window_matches[0] == "flattop": self.window = flattop(self.signal_len, sym=True) self.window_type = "flattop" elif window_matches[0] == "boxcar": self.window = boxcar(self.signal_len, sym=True) self.window_type = "boxcar" elif window_matches[0] == "nuttall": self.window = nuttall(self.signal_len, sym=True) self.window_type = "nuttall" elif window_matches[0] == "parzen": self.window = parzen(self.signal_len, sym=True) self.window_type = "parzen" elif window_matches[0] == "triang": self.window = triang(self.signal_len, sym=True) self.window_type = "triang" elif window_matches[0] == "tukey": self.window = tukey(self.signal_len, sym=True) self.window_type = "tukey" else: self.window = 1 #window = 1 is the same as applying no window #calculate convolution from protein sequences if self.convolution is not None: if self.window is not None: self.convoled_seqs = signal.convolve( self.protein_seqs, self.window, mode='same') / sum( self.window) if self.filter != None: #get closest correct filter from user input filter_matches = (get_close_matches(self.filter, all_filters, cutoff=0.4)) #set filter attribute according to approximate user input if filter_matches != []: if filter_matches[0] == 'savgol': self.filter = savgol_filter(self.signal_len, self.signal_len) elif filter_matches[0] == 'medfilt': self.filter = medfilt(self.signal_len) elif filter_matches[0] == 'symiirorder1': self.filter = symiirorder1(self.signal_len, c0=1, z1=1) elif filter_matches[0] == 'lfilter': self.filter = lfilter(self.signal_len) elif filter_matches[0] == 'hilbert': self.filter = hilbert(self.signal_len) else: self.filter = "" #no filter
def test_kaiser_float(self): win1 = windows.get_window(7.2, 64) win2 = windows.kaiser(64, 7.2, False) assert_allclose(win1, win2)
def _update_canvas(self): """ Update the figure when the user changes an input value :return: """ # Get the parameters from the form bandwidth = float(self.bandwidth.text()) pulsewidth = float(self.pulsewidth.text()) range_window_length = float(self.range_window_length.text()) target_range = self.target_range.text().split(',') target_rcs = self.target_rcs.text().split(',') t_range = [float(r) for r in target_range] t_rcs = [float(r) for r in target_rcs] # Get the selected window from the form window_type = self.window_type.currentText() # Number of samples number_of_samples = int(ceil(4 * bandwidth * range_window_length / c)) if window_type == 'Kaiser': coefficients = kaiser(number_of_samples, 6, True) elif window_type == 'Blackman-Harris': coefficients = blackmanharris(number_of_samples, True) elif window_type == 'Hanning': coefficients = hanning(number_of_samples, True) elif window_type == 'Hamming': coefficients = hamming(number_of_samples, True) elif window_type == 'Rectangular': coefficients = ones(number_of_samples) # Time sampling t, dt = linspace(-0.5 * pulsewidth, 0.5 * pulsewidth, number_of_samples, retstep=True) # Sampled signal after mixing so = zeros(number_of_samples, dtype=complex) for r, rcs in zip(t_range, t_rcs): so += sqrt(rcs) * exp(1j * 2.0 * pi * bandwidth / pulsewidth * (2 * r / c) * t) # Fourier transform so = fftshift(fft(so * coefficients, 4 * number_of_samples)) # FFT frequencies frequencies = fftshift(fftfreq(4 * number_of_samples, dt)) # Range window range_window = 0.5 * frequencies * c * pulsewidth / bandwidth # Clear the axes for the updated plot self.axes1.clear() # Create the line plot self.axes1.plot( range_window, 20.0 * log10(abs(so) / number_of_samples + finfo(float).eps), '') self.axes1.set_xlim(min(t_range) - 5, max(t_range) + 5) self.axes1.set_ylim( -60, max(20.0 * log10(abs(so) / number_of_samples)) + 10) # Set the x and y axis labels self.axes1.set_xlabel("Range (m)", size=12) self.axes1.set_ylabel("Amplitude (dBsm)", size=12) # Turn on the grid self.axes1.grid(linestyle=':', linewidth=0.5) # Set the plot title and labels self.axes1.set_title('Stretch Processor Range Profile', size=14) # Set the tick label size self.axes1.tick_params(labelsize=12) # Update the canvas self.my_canvas.draw()
def test_kaiser_float(self): win1 = windows.get_window(7.2, 64) win2 = windows.kaiser(64, 7.2, False) assert_allclose(win1, win2)
def spec_track(signal, pitch, parameters): #--------------------------------------------------------------- # Set parameters. #--------------------------------------------------------------- nframe_size = pitch.frame_size*2 maxpeaks = parameters['shc_maxpeaks'] delta = signal.new_fs/pitch.nfft window_length = int(np.fix(parameters['shc_window']/delta)) half_window_length = int(np.fix(float(window_length)/2)) if not(window_length % 2): window_length += 1 max_SHC = int(np.fix((parameters['f0_max']+parameters['shc_pwidth']*2)/delta)) min_SHC = int(np.ceil(parameters['f0_min']/delta)) num_harmonics = parameters['shc_numharms'] #--------------------------------------------------------------- # Main routine. #--------------------------------------------------------------- cand_pitch = np.zeros((maxpeaks, pitch.nframes)) cand_merit = np.ones((maxpeaks, pitch.nframes)) data = np.append(signal.filtered, np.zeros((1, nframe_size + ((pitch.nframes-1)*pitch.frame_jump-signal.size)))) #Compute SHC for voiced frame window = kaiser(nframe_size, 0.5) SHC = np.zeros((max_SHC)) row_mat_list = np.array([np.empty((max_SHC-min_SHC+1, window_length)) for x in range(num_harmonics+1)]) magnitude = np.zeros(int((half_window_length+(pitch.nfft/2)+1))) for frame in np.where(pitch.vuv)[0].tolist(): fir_step = frame*pitch.frame_jump data_slice = data[fir_step:fir_step+nframe_size]*window data_slice -= np.mean(data_slice) magnitude[half_window_length:] = np.abs(np.fft.rfft(data_slice, pitch.nfft)) for idx,row_mat in enumerate(row_mat_list): row_mat[:, :] = stride_matrix(magnitude[min_SHC*(idx+1):], max_SHC-min_SHC+1, window_length, idx+1) SHC[min_SHC-1:max_SHC] = np.sum(np.prod(row_mat_list,axis=0),axis=1) cand_pitch[:, frame], cand_merit[:, frame] = \ peaks(SHC, delta, maxpeaks, parameters) #Extract the pitch candidates of voiced frames for the future pitch selection. spec_pitch = cand_pitch[0, :] voiced_cand_pitch = cand_pitch[:, cand_pitch[0, :] > 0] voiced_cand_merit = cand_merit[:, cand_pitch[0, :] > 0] num_voiced_cand = len(voiced_cand_pitch[0, :]) avg_voiced = np.mean(voiced_cand_pitch[0, :]) std_voiced = np.std(voiced_cand_pitch[0, :]) #Interpolation of the weigthed candidates. delta1 = abs((voiced_cand_pitch - 0.8*avg_voiced))*(3-voiced_cand_merit) index = delta1.argmin(0) voiced_peak_minmrt = voiced_cand_pitch[index, range(num_voiced_cand)] voiced_merit_minmrt = voiced_cand_merit[index, range(num_voiced_cand)] voiced_peak_minmrt = medfilt(voiced_peak_minmrt, max(1, parameters['median_value']-2)) #Replace the lowest merit candidates by the median smoothed ones #computed from highest merit peaks above. voiced_cand_pitch[index, range(num_voiced_cand)] = voiced_peak_minmrt voiced_cand_merit[index, range(num_voiced_cand)] = voiced_merit_minmrt #Use dynamic programming to find best overal path among pitch candidates. #Dynamic weight for transition costs balance between local and #transition costs. weight_trans = parameters['dp5_k1']*std_voiced/avg_voiced if num_voiced_cand > 2: voiced_pitch = dynamic5(voiced_cand_pitch, voiced_cand_merit, weight_trans, parameters['f0_min']) voiced_pitch = medfilt(voiced_pitch, max(1, parameters['median_value']-2)) else: if num_voiced_cand > 0: voiced_pitch = (np.ones((num_voiced_cand)))*150.0 else: voiced_pitch = np.array([150.0]) cand_pitch[0, 0] = 0 pitch_avg = np.mean(voiced_pitch) pitch_std = np.std(voiced_pitch) spec_pitch[cand_pitch[0, :] > 0] = voiced_pitch[:] if (spec_pitch[0] < pitch_avg/2): spec_pitch[0] = pitch_avg if (spec_pitch[-1] < pitch_avg/2): spec_pitch[-1] = pitch_avg spec_voiced = np.array(np.nonzero(spec_pitch)[0]) spec_pitch = scipy_interp.pchip(spec_voiced, spec_pitch[spec_voiced])(range(pitch.nframes)) spec_pitch = lfilter(np.ones((3))/3, 1.0, spec_pitch) spec_pitch[0] = spec_pitch[2] spec_pitch[1] = spec_pitch[3] return spec_pitch, pitch_std