def crosscorr_phase_angle(sig1, sig2, x, max_length=10000): """Return the cross correlation phase angle between 2 signals Parameters ---------- sig1 : array signal of length L sig2 : array another signal of length L x : array time axis for the signals sig1 and sig2 max_length : int, optional Maximum length for the signals, signals are resampled otherwise. Default is 10 000. """ assert len(sig1) == len(sig2) == len(x), \ "The signals don't have the same length." sig_length = len(sig1) # Resample if signal is too big thus slowing down correlation computation if sig_length > max_length: sig1, x = resample(sig1, max_length, x) sig2 = resample(sig2, max_length) sig_length = max_length corr = np.correlate(sig1, sig2, mode="same") xmean = sig_length/2 return float(argmax(corr) - xmean)/sig_length*x[-1] # *x[-1] to scale
def extract_data(i): global id_legend, _id, t, intra_trace, extra_trace, img_fname if i < n_datum and i>=0: _id = datum.keys()[i] # 'a0' or 's1' etc. img_fname = img_path+datum[_id][0] igor_trace = datum[_id][1] extra_id_0 = _id + '1_Ax1_Vm' # Axon extra_id_1 = _id + '1_Ch2_Vm' # Dendrite intra_id = _id + '1_Ch1_Vm' t = igor_trace[intra_id].axis[0] * 1e6 t = t[::-1] intra_trace = igor_trace[intra_id].data * 1e3 # unit(mV) extra_trace = np.zeros((len(t),2)) extra_trace[:,0] = igor_trace[extra_id_0].data * 1e6 # unit(uV) Axon (left) extra_trace[:,1] = igor_trace[extra_id_1].data * 1e6 # unit(uV) Dendrite (right) ##################### down-sampling ##################### N = 2 # down sampling 2 folds intra_trace,t_d = resample(intra_trace, intra_trace.shape[0]/N, t) extra_trace,t_d = resample(extra_trace, extra_trace.shape[0]/N, t) t = t_d print 'estimated fs ',1/(t[2]-t[1]) ###################### filtering process ##################### fs = np.ceil(1/(t[2]-t[1])) print('sampling frequency %f' % fs) b, a = butter_bandpass(200,3000,fs,6) extra_trace = filtfilt(b, a, extra_trace.T, padlen=150, padtype="even") extra_trace = extra_trace.T ############################################################### return _id, t, intra_trace, extra_trace, img_fname elif i<0: print('out of range, cannot less than 0') elif i >= n_datum: print('out of range, cannot less than %d' % n_datum)
def stochasticModel(x, w, N, stocf): # x: input array sound, w: analysis window, N: FFT size, # stocf: decimation factor of mag spectrum for stochastic analysis # y: output sound hN = N / 2 # size of positive spectrum hM = (w.size) / 2 # half analysis window size pin = hM # initialize sound pointer in middle of analysis window fftbuffer = np.zeros(N) # initialize buffer for FFT yw = np.zeros(w.size) # initialize output sound frame w = w / sum(w) # normalize analysis window ws = hanning(w.size) * 2 # synthesis window # -----analysis----- xw = x[pin - hM : pin + hM] * w # window the input sound X = fft(xw) # compute FFT mX = 20 * np.log10(abs(X[:hN])) # magnitude spectrum of positive frequencies mXenv = resample(np.maximum(-200, mX), mX.size * stocf) # decimate the mag spectrum pX = np.angle(X[:hN]) # -----synthesis----- mY = resample(mXenv, hN) # interpolate to original size pY = 2 * np.pi * np.random.rand(hN) # generate phase random values Y = np.zeros(N, dtype=complex) Y[:hN] = 10 ** (mY / 20) * np.exp(1j * pY) # generate positive freq. Y[hN + 1 :] = 10 ** (mY[:0:-1] / 20) * np.exp(-1j * pY[:0:-1]) # generate negative freq. fftbuffer = np.real(ifft(Y)) # inverse FFT y = ws * fftbuffer * N / 2 # overlap-add return mX, pX, mY, pY, y
def upsample_sig(self): # Check that the upsample value is more than 0 # upsample the signal self.cur_signal_up = signal.resample(self.cur_signal_raw, self.cur_signal_raw.size*self.N_up) tmpr = signal.resample(np.real(self.cur_signal_raw), self.cur_signal_raw.size*self.N_up) # change signal to magnitude of signal according to user specs if self.sig_type == 'm': self.cur_signal_up = self.sig_mag(self.cur_signal_up) # if the user asked to filter, add observation to average if self.filter_on: self.filter_sig() # if this is our first CIR, save it for reference, and flip flag if self.is_first_obs: self.start_time = self.cur_time self.num_taps = self.cur_signal_raw.size self.up_sig_len = self.cur_signal_up.size self.ref_complex_cir = self.cur_signal_up.copy() self.__init_mats() self.is_first_obs = 0
def main(): X,Y = [],[] Y2 = [] index = 0 with open(sys.argv[1],'r') as fp: lines = [i.strip().split() for i in fp.readlines() if i] for line in lines: y = float(line[1]) x = index index += 1 Y.append(y) X.append(x) if x > 1500 and x < 1700: print x,y,y-y*3*math.exp(-(x-1600)**2/1500) Y2.append(y-y*3*math.exp(-(x-1600)**2/1500)) else: Y2.append(y) y = signal.resample(Y,100) y2 = signal.resample(Y2,100) y = [i/max(y) for i in y] y2 = [i/max(y2) for i in y2] with open("%s.resampled" %sys.argv[1], 'w') as fp: fp.write('x,y\n') fp.write('\n'.join(["%s,%s" % (x,y) for x,y in zip(range(len(y)),y)])) with open("%s.resampled.absorber" %sys.argv[1], 'w') as fp: fp.write('x,y\n') fp.write('\n'.join(["%s,%s" % (x,y) for x,y in zip(range(len(y2)),y2)]))
def stochasticModel(x, H, stocf): # stochastic analysis/synthesis of a sound, one frame at a time # x: input array sound, H: hop size, # stocf: decimation factor of mag spectrum for stochastic analysis # returns y: output sound N = H*2 # FFT size w = hanning(N) # analysis/synthesis window x = np.append(np.zeros(H),x) # add zeros at beginning to center first window at sample 0 x = np.append(x,np.zeros(H)) # add zeros at the end to analyze last sample pin = 0 # initialize sound pointer in middle of analysis window pend = x.size-N # last sample to start a frame y = np.zeros(x.size) # initialize output array while pin<=pend: #-----analysis----- xw = x[pin:pin+N]*w # window the input sound X = fft(xw) # compute FFT mX = 20 * np.log10(abs(X[:H])) # magnitude spectrum of positive frequencies mYst = resample(np.maximum(-200, mX), mX.size*stocf) # decimate the mag spectrum #-----synthesis----- mY = resample(mYst, H) # interpolate to original size pY = 2*np.pi*np.random.rand(H) # generate phase random values Y = np.zeros(N, dtype = complex) Y[:H] = 10**(mY/20) * np.exp(1j*pY) # generate positive freq. Y[H+1:] = 10**(mY[:0:-1]/20) * np.exp(-1j*pY[:0:-1]) # generate negative freq. fftbuffer = np.real(ifft(Y)) # inverse FFT y[pin:pin+N] += w*fftbuffer # overlap-add pin += H y = np.delete(y, range(H)) # delete half of first window which was added y = np.delete(y, range(y.size-H, y.size)) # delete half of last window which was added # advance sound pointer return y
def subsample_align_upsampling(self, sig_tx, sig_rx, n_up=32): """ Returns an aligned version of sig_tx and sig_rx by cropping and subsample alignment Using upsampling """ assert (sig_tx.shape[0] == sig_rx.shape[0]) if sig_tx.shape[0] % 2 == 1: sig_tx = sig_tx[:-1] sig_rx = sig_rx[:-1] sig1_up = signal.resample(sig_tx, sig_tx.shape[0] * n_up) sig2_up = signal.resample(sig_rx, sig_rx.shape[0] * n_up) off_meas = self.lag_upsampling(sig2_up, sig1_up, n_up=1) off = int(abs(off_meas)) if off_meas > 0: sig1_up = sig1_up[:-off] sig2_up = sig2_up[off:] elif off_meas < 0: sig1_up = sig1_up[off:] sig2_up = sig2_up[:-off] sig_tx = signal.resample(sig1_up, sig1_up.shape[0] / n_up).astype(np.complex64) sig_rx = signal.resample(sig2_up, sig2_up.shape[0] / n_up).astype(np.complex64) return sig_tx, sig_rx
def data_parser(theta,kappa,tt,ch,tt_ch): theta_r = np.array([[resample(theta.values.squeeze()[i,950:1440],50)] for i in range(0,theta.shape[0])]) theta_r = zscore(theta_r.squeeze(),axis=None) kappa_r = np.array([[resample(kappa.values.squeeze()[i,950:1440],50)] for i in range(0,kappa.shape[0])]) kappa_r = zscore(kappa_r.squeeze(),axis=None) kappa_df = pd.DataFrame(kappa_r) theta_df = pd.DataFrame(theta_r) both_df = pd.concat([theta_df,kappa_df],axis=1) if tt_ch == 'tt': # trial type clean = np.nan_to_num(tt) !=0 tt_c = tt[clean.squeeze()].values else : # choice clean = np.nan_to_num(ch) !=0 tt_c = ch[clean.squeeze()].values # tt_c = tt[tt.values !=0|3].values both = both_df.values # both_c = both[clean.squeeze(),:] both_c = both[clean.squeeze(),:] # keeping one hot vector for now (incase we want it later) # labs = np.eye(3)[tt_c.astype(int)-1] # y[np.arange(3), a] = 1 # labs = labs.squeeze() return both_c, tt_c, clean
def rx_oversampled(frames, ref_frame, modulated_frame, x_preamble, data, rx_kernel, demapper, timeslots, fft_len, cp_len, cs_len): ref_frame_os = signal.resample(ref_frame, 2 * len(ref_frame)) x_preamble_os = signal.resample(x_preamble, 2 * len(x_preamble)) nyquist_frame_len = cp_len + 2 * fft_len + cs_len + cp_len + timeslots * fft_len + cs_len n_frames = np.shape(frames)[0] sync_frames = np.zeros((n_frames, nyquist_frame_len), dtype=np.complex) print('nyquist sampled frame len', nyquist_frame_len, 'with n_frames', n_frames) f_start = cp_len + 2 * fft_len + cs_len d_start = f_start + cp_len print('data start: ', d_start) for i, f in enumerate(frames[0:2]): tf = np.roll(f, 1) tf[0] = 0 ff = signal.resample(tf, len(f) // 2) sframe = synchronize_time(ff, ref_frame_os, x_preamble_os, 2 * fft_len, 2 * cp_len) sframe = signal.resample(sframe, len(sframe) // 2) sframe = synchronize_freq_offsets(sframe, modulated_frame, x_preamble, fft_len, cp_len, samp_rate=3.125e6) print(len(sframe), len(ref_frame)) rx_preamble = sframe[cp_len:cp_len + 2 * fft_len] avg_phase = calculate_avg_phase(rx_preamble, x_preamble) # m, c = calculate_avg_phase(rx_preamble, x_preamble) # avg_phase = calculate_avg_phase(sframe, ref_frame) # phase_eqs = m * np.arange(-cp_len, len(sframe) - cp_len) + c # sframe *= np.exp(-1j * phase_eqs) # sframe *= np.exp(-1j * avg_phase) sync_frames[i] = sframe rx_data_frame = sframe[d_start:d_start + fft_len * timeslots] # # rx_data_frame *= np.exp(-1j * avg_phase) # demodulate_frame(rx_data_frame, modulated_frame, rx_kernel, demapper, data, timeslots, fft_len) for i, f in enumerate(sync_frames[0:3]): rx_data_frame = f[d_start:d_start + fft_len * timeslots] demodulate_frame(rx_data_frame, modulated_frame, rx_kernel, demapper, data, timeslots, fft_len)
def filter(self): ''' resamples time series :return:resampled time series with sampling frequency set to resamplerate ''' # samplerate = self.time_series.attrs['samplerate'] samplerate = float(self.time_series['samplerate']) time_axis_length = np.squeeze(self.time_series.coords['time'].shape) new_length = int(np.round(time_axis_length*self.resamplerate/samplerate)) print new_length if self.time_axis_index<0: self.time_axis_index = self.time_series.get_axis_num('time') time_axis = self.time_series.coords[ self.time_series.dims[self.time_axis_index] ] try: time_axis_data = time_axis.data['time'] # time axis can be recarray with one of the arrays being time except (KeyError ,IndexError) as excp: # if we get here then most likely time axis is ndarray of floats time_axis_data = time_axis.data time_idx_array = np.arange(len(time_axis)) if self.round_to_original_timepoints: filtered_array, new_time_idx_array = resample(self.time_series.data, new_length, t=time_idx_array, axis=self.time_axis_index, window=self.window) # print new_time_axis new_time_idx_array = np.rint(new_time_idx_array).astype(np.int) new_time_axis = time_axis[new_time_idx_array] else: filtered_array, new_time_axis = resample(self.time_series.data, new_length, t=time_axis_data, axis=self.time_axis_index, window=self.window) coords = [] for i, dim_name in enumerate(self.time_series.dims): if i != self.time_axis_index: coords.append(self.time_series.coords[dim_name].copy()) else: coords.append((dim_name,new_time_axis)) filtered_time_series = xray.DataArray(filtered_array, coords=coords) # filtered_time_series.attrs['samplerate'] = self.resamplerate filtered_time_series['samplerate'] = self.resamplerate return TimeSeriesX(filtered_time_series)
def resample(self, times=2): from scipy.signal import resample self.flux, self.freq = resample(self.flux, int(len(self.flux)/times), t=self.freq) if hasattr(self, "fluxcal"): self.fluxcal = resample(self.fluxcal, int(len(self.fluxcal)/times)) if hasattr(self, "baseline"): self.baseline = resample(self.baseline, int(len(self.baseline)/times))
def lag_upsampling(self, sig_orig, sig_rec, n_up): if n_up != 1: sig_orig_up = signal.resample(sig_orig, sig_orig.shape[0] * n_up) sig_rec_up = signal.resample(sig_rec, sig_rec.shape[0] * n_up) else: sig_orig_up = sig_orig sig_rec_up = sig_rec l = self.lag(sig_orig_up, sig_rec_up) l_orig = float(l) / n_up return l_orig
def RotateVector_45degree(newN,vec): from scipy import ndimage as ndi from scipy import signal N = vec.shape[0] newvec = numpy.zeros((newN,newN,3),float) for i in range(3): temp = signal.resample(signal.resample(vec[:,:,i],N*4,axis=0),N*4,axis=1) temp = ndi.rotate(temp,45,mode='wrap') newvec[:,:,i] = signal.resample(signal.resample(temp,newN,axis=0),newN,axis=1) return newvec
def resample_via_fft(curve, samples): """ resample_via_fft(curve, samples) Resample the curve using scily signal processing utility via Fourier and zero padding """ rx = resample(curve[0,:], samples) ry = resample(curve[1,:], samples) # rsig = resample(curve, samples, axis=0) return np.array([rx, ry])
def resample_with_gaussian_blur(input_array,sigma_for_gaussian,resampling_factor): sz=input_array.shape gauss_temp=ndimage.gaussian_filter(input_array,sigma=sigma_for_gaussian) resam_temp=sg.resample(gauss_temp,axis=1,num=sz[1]/resampling_factor) resam_temp=sg.resample(resam_temp,axis=2,num=sz[2]/resampling_factor) return (resam_temp)
def fft_gauss_blur_img(img, scale, std_cut_off=5): old_img_size = img.shape[0] new_img_size = np.round( img.shape[0]*scale ) std = guassianDownSampleSTD( old_img_size , new_img_size, std_cut_off, old_img_size ) sr = sig.resample( img, old_img_size, window = ('gaussian', std) ) sr = sig.resample( sr, old_img_size, window = ('gaussian', std), axis=1) return sr
def fft_resample_img(img, nPix, std_cut_off = None): #this is only for square images if not std_cut_off is None: oldSize = np.size(img,0) std = guassianDownSampleSTD( oldSize, nPix, stdCutOff, oldSize ) sr = sig.resample(img, nPix, window = ('gaussian', std)) sr = sig.resample(sr, nPix, window = ('gaussian', std ), axis = 1) else: sr = sig.resample( img, nPix, window = ('boxcar') ) sr = sig.resample( sr, nPix, window = ('boxcar'), axis = 1) return sr
def stftMorph(x1, x2, fs, w1, N1, w2, N2, H1, smoothf, balancef): """ Morph of two sounds using the STFT x1, x2: input sounds, fs: sampling rate w1, w2: analysis windows, N1, N2: FFT sizes, H1: hop size smoothf: smooth factor of sound 2, bigger than 0 to max of 1, where 1 is no smothing, balancef: balance between the 2 sounds, from 0 to 1, where 0 is sound 1 and 1 is sound 2 returns y: output sound """ if (N2/2*smoothf < 3): # raise exception if decimation factor too small raise ValueError("Smooth factor too small") if (smoothf > 1): # raise exception if decimation factor too big raise ValueError("Smooth factor above 1") if (balancef > 1 or balancef < 0): # raise exception if balancef outside 0-1 raise ValueError("Balance factor outside range") if (H1 <= 0): # raise error if hop size 0 or negative raise ValueError("Hop size (H1) smaller or equal to 0") M1 = w1.size # size of analysis window hM1_1 = int(math.floor((M1+1)/2)) # half analysis window size by rounding hM1_2 = int(math.floor(M1/2)) # half analysis window size by floor L = int(x1.size/H1) # number of frames for x1 x1 = np.append(np.zeros(hM1_2),x1) # add zeros at beginning to center first window at sample 0 x1 = np.append(x1,np.zeros(hM1_1)) # add zeros at the end to analyze last sample pin1 = hM1_1 # initialize sound pointer in middle of analysis window w1 = w1 / sum(w1) # normalize analysis window M2 = w2.size # size of analysis window hM2_1 = int(math.floor((M2+1)/2)) # half analysis window size by rounding hM2_2 = int(math.floor(M2/2)) # half analysis window size by floor2 H2 = int(x2.size/L) # hop size for second sound x2 = np.append(np.zeros(hM2_2),x2) # add zeros at beginning to center first window at sample 0 x2 = np.append(x2,np.zeros(hM2_1)) # add zeros at the end to analyze last sample pin2 = hM2_1 # initialize sound pointer in middle of analysis window y = np.zeros(x1.size) # initialize output array for l in range(L): #-----analysis----- mX1, pX1 = DFT.dftAnal(x1[pin1-hM1_1:pin1+hM1_2], w1, N1) # compute dft mX2, pX2 = DFT.dftAnal(x2[pin2-hM2_1:pin2+hM2_2], w2, N2) # compute dft #-----transformation----- mX2smooth = resample(np.maximum(-200, mX2), int(mX2.size*smoothf)) # smooth spectrum of second sound mX2 = resample(mX2smooth, mX1.size) # generate back the same size spectrum mY = balancef * mX2 + (1-balancef) * mX1 # generate output spectrum #-----synthesis----- y[pin1-hM1_1:pin1+hM1_2] += H1*DFT.dftSynth(mY, pX1, M1) # overlap-add to generate output sound pin1 += H1 # advance sound pointer pin2 += H2 # advance sound pointer y = np.delete(y, range(hM1_2)) # delete half of first window which was added in stftAnal y = np.delete(y, range(y.size-hM1_1, y.size)) # add zeros at the end to analyze last sample return y
def resample(signal, prev_sample_rate, new_sample_rate): if prev_sample_rate == new_sample_rate: return signal rate_factor = new_sample_rate/float(prev_sample_rate) num_samples = int(len(signal.T)*rate_factor) if signal.ndim == 2: result = numpy.empty((len(signal), num_samples), dtype=signal.dtype) for si, s in enumerate(signal): result[si] = scisig.resample(s, num_samples) return result else: return scisig.resample(signal, num_samples)
def _forward_dataset_helper(self, ds): # local binding num = self.__num pos = None if not self.__position_attr is None: # we know something about sample position pos = ds.sa[self.__position_attr].value rsamples, pos = resample(ds.samples, self.__num, t=pos, window=self.__window_args) else: # we know nothing about samples position rsamples = resample(ds.samples, self.__num, t=None, window=self.__window_args) # new dataset that reuses that feature and dataset attributes of the # source mds = Dataset(rsamples, fa=ds.fa, a=ds.a) # the tricky part is what to do with the samples attributes, since their # number has changes if self.__attr_strategy == 'remove': # nothing to be done pass elif self.__attr_strategy == 'sample': step = int(len(ds) / num) sa = dict([(k, ds.sa[k].value[0::step][:num]) for k in ds.sa]) mds.sa.update(sa) elif self.__attr_strategy == 'resample': # resample the attributes themselves sa = {} for k in ds.sa: v = ds.sa[k].value if pos is None: sa[k] = resample(v, self.__num, t=None, window=self.__window_args) else: if k == self.__position_attr: # position attr will be handled separately at the end continue sa[k] = resample(v, self.__num, t=pos, window=self.__window_args)[0] # inject them all mds.sa.update(sa) else: raise ValueError("Unkown attribute handling strategy '%s'." % self.__attr_strategy) if not pos is None: # we got the new sample positions and can store them mds.sa[self.__position_attr] = pos return mds
def resample(self, sampling_times): [self.x, self.time] = signal.resample( self.x, len(sampling_times), sampling_times) [self.y, self.time] = signal.resample( self.y, len(sampling_times), sampling_times) [self.z, self.time] = signal.resample( self.z, len(sampling_times), sampling_times)
def audio_loop(file, p, ratio, end, chunk_size, stop_proc): time.sleep(0.5) proc = psutil.Process(os.getpid()) proc.nice(-5) time.sleep(0.02) print ('audio file is ' + str(file)) while True: #chunk = 2048/2 wf = wave.open(file, 'rb') time.sleep(0.03) data = wf.readframes(chunk_size.value) time.sleep(0.03) stream = p.open( format = p.get_format_from_width(wf.getsampwidth()), channels = wf.getnchannels(), rate = wf.getframerate(), output = True, frames_per_buffer = chunk_size.value) while data != '' and stop_proc.value == 0: #need to try locking here for multiprocessing array = numpy.fromstring(data, dtype=numpy.int16) result = numpy.reshape(array, (array.size/2, 2)) #split data into seperate channels and resample final = numpy.ones((1024,2)) reshapel = signal.resample(result[:, 0], 1024) final[:, 0] = reshapel reshaper = signal.resample(result[:, 1], 1024) final[:, 1] = reshaper out_data = final.flatten().astype(numpy.int16).tostring() #data = signal.resample(array, chunk_size.value*ratio.value) #stream.write(data.astype(int).tostring()) stream.write(out_data) round_data = (int)(chunk_size.value*ratio.value) if round_data % 2 != 0: round_data += 1 data = wf.readframes(round_data) stream.stop_stream() stream.close() wf.close() p.terminate() if end or stop_proc.value == 1: break stream.stop_stream() stream.close() wf.close() p.terminate()
def resample(self, num, axis=0, window=None): """Resample timeseries data for a signal onto a different time base. This routine uses scipy.signal's resample function which creates an interpolation with the option of filtering by specifying the window keyword. See help(scipy.signal.resample) for details.""" if self['time'] is not None: (self['signal'], self['time']) = resample(self['signal'], num, t=self['time'], axis=0, window=None) else: self['signal'] = resample(self['signal'], num, axis=0, window=None)
def demodulate(sdr_samples, sample_rate, ignore=0): t = np.arange(len(sdr_samples)) / sample_rate demod = np.exp(-2j*pi*freq_offset*t) y = sdr_samples * demod threshold = 0.04 y = y[abs(y) > threshold] from scipy import signal #should be imported already? sig = angle(y[1:] * conj(y[:-1])) h = signal.firwin(256,5000.0,nyq=sample_rate/2.0) sigf = signal.fftconvolve(sig, h) if ignore > 0: sigf = sigf[ignore:-ignore] downsample = 24 sigfd = sigf[::downsample] fs_down = fs sigfdd = signal.resample(sigfd, len(sigfd) * float(fs_down) / (sample_rate / float(downsample))) return sigfdd
def resample(audio, target_sample_rate): """ Resamples audio to a specified sample rate. This function should only be used for relatively short audio segments, say not longer than a second or so. It uses the `scipy.signal.resample` method to perform the resampling, which computes a length-M DFT and a length-N inverse DFT, where M and N are the input and output length, respectively. M and N may not be powers of two, and they may even be prime, which can make this function slow if M or N is too large. """ if audio.sample_rate == target_sample_rate: # do not need to resample return audio else: # need to resample # We put this import here instead of at the top of this module # so the module can be used in Python environments that don't # include SciPy as long as this function is not called. import scipy.signal as signal ratio = target_sample_rate / audio.sample_rate num_samples = int(round(len(audio.samples) * ratio)) samples = signal.resample(audio.samples, num_samples) return Bunch(samples=samples, sample_rate=target_sample_rate)
def stochasticModelSynth(stocEnv, H, N): """ Stochastic synthesis of a sound stocEnv: stochastic envelope; H: hop size; N: fft size returns y: output sound """ if not(UF.isPower2(N)): # raise error if N not a power of two raise ValueError("N is not a power of two") hN = N/2+1 # positive size of fft No2 = N/2 # half of N L = stocEnv[:,0].size # number of frames ysize = H*(L+3) # output sound size y = np.zeros(ysize) # initialize output array ws = 2*hanning(N) # synthesis window pout = 0 # output sound pointer for l in range(L): mY = resample(stocEnv[l,:], hN) # interpolate to original size pY = 2*np.pi*np.random.rand(hN) # generate phase random values Y = np.zeros(N, dtype = complex) # initialize synthesis spectrum Y[:hN] = 10**(mY/20) * np.exp(1j*pY) # generate positive freq. Y[hN:] = 10**(mY[-2:0:-1]/20) * np.exp(-1j*pY[-2:0:-1]) # generate negative freq. fftbuffer = np.real(ifft(Y)) # inverse FFT y[pout:pout+N] += ws*fftbuffer # overlap-add pout += H y = np.delete(y, range(No2)) # delete half of first window y = np.delete(y, range(y.size-No2, y.size)) # delete half of the last window return y
def convolve_scalogram(ana, wf, sampling_rate,optimize_fft): n = wf.shape[0] sig = ana.magnitude ana_sr=ana.sampling_rate.rescale('Hz').magnitude if optimize_fft: sig=sig-sig.mean() # Remove mean before padding nfft=int(2**np.ceil(np.log(sig.size)/np.log(2))) sig=np.r_[sig,np.zeros(nfft-sig.size)] # pad signal with 0 to a power of 2 length sig=resample(sig,int(sig.size*sampling_rate/ana_sr)) # resample in time domain sigf=fftpack.fft(sig,n) # Compute fft with a power of 2 length else: sigf=fftpack.fft(sig) # subsampling in fft domain (attention factor) factor = (sampling_rate/ana.sampling_rate).simplified.magnitude x=(n-1)//2 if np.mod(n,2)==0: sigf = np.concatenate([sigf[0:x+2], sigf[-x:]])*factor else: sigf = np.concatenate([sigf[0:x+1], sigf[-x:]])*factor # windowing ??? #win = fftpack.ifftshift(np.hamming(n)) #sigf *= win # Convolve (mult. in Fourier space) wt_tmp=fftpack.ifft(sigf[:,np.newaxis]*wf,axis=0) # and shift wt = fftpack.fftshift(wt_tmp,axes=[0]) return wt
def stochasticResidualAnal(x, N, H, sfreq, smag, sphase, fs, stocf): """ Subtract sinusoids from a sound and approximate the residual with an envelope x: input sound, N: fft size, H: hop-size sfreq, smag, sphase: sinusoidal frequencies, magnitudes and phases fs: sampling rate; stocf: stochastic factor, used in the approximation returns stocEnv: stochastic approximation of residual """ hN = N/2 # half of fft size x = np.append(np.zeros(hN),x) # add zeros at beginning to center first window at sample 0 x = np.append(x,np.zeros(hN)) # add zeros at the end to analyze last sample bh = blackmanharris(N) # synthesis window w = bh/ sum(bh) # normalize synthesis window L = sfreq.shape[0] # number of frames, this works if no sines pin = 0 for l in range(L): xw = x[pin:pin+N] * w # window the input sound X = fft(fftshift(xw)) # compute FFT Yh = UF_C.genSpecSines(N*sfreq[l,:]/fs, smag[l,:], sphase[l,:], N) # generate spec sines Xr = X-Yh # subtract sines from original spectrum mXr = 20*np.log10(abs(Xr[:hN])) # magnitude spectrum of residual mXrenv = resample(np.maximum(-200, mXr), mXr.size*stocf) # decimate the mag spectrum if l == 0: # if first frame stocEnv = np.array([mXrenv]) else: # rest of frames stocEnv = np.vstack((stocEnv, np.array([mXrenv]))) pin += H # advance sound pointer return stocEnv
def make_step(self, size_in, size_out, dt, rng): assert size_in[0] == 0 assert size_out[0] == 1 rate = 1. / dt orig_rate, orig = readwav(self.path) new_size = int(orig.size * (rate / orig_rate)) wave = resample(orig, new_size) wave -= wave.mean() # Normalize wave to desired rms wave_rms = npext.rms(wave) wave *= (self.rms / wave_rms) if self.at_end == 'loop': def step_wavfileloop(t): idx = int(t * rate) % wave.size return wave[idx] return step_wavfileloop elif self.at_end == 'stop': def step_wavfilestop(t): idx = int(t * rate) if idx > wave.size: return 0. else: return wave[idx] return step_wavfilestop
def to_envelopes(path,num_bands,freq_lims,window_length=None,time_step=None): sr, proc = preproc(path,alpha=0.97) proc = proc/sqrt(mean(proc**2))*0.03; bandLo = [ freq_lims[0]*exp(log(freq_lims[1]/freq_lims[0])/num_bands)**x for x in range(num_bands)] bandHi = [ freq_lims[0]*exp(log(freq_lims[1]/freq_lims[0])/num_bands)**(x+1) for x in range(num_bands)] if window_length is not None and time_step is not None: use_windows = True nperseg = int(window_length*sr) noverlap = int(time_step*sr) window = hanning(nperseg+2)[1:nperseg+1] step = nperseg - noverlap indices = arange(0, proc.shape[-1]-nperseg+1, step) num_frames = len(indices) envelopes = zeros((num_bands,num_frames)) else: use_windows=False sr_env = 120 t = len(proc)/sr numsamp = ceil(t * sr_env) envelopes = [] for i in range(num_bands): b, a = butter(2,(bandLo[i]/(sr/2),bandHi[i]/(sr/2)), btype = 'bandpass') env = filtfilt(b,a,proc) env = abs(hilbert(env)) if use_windows: window_sums = [] for k,ind in enumerate(indices): seg = env[ind:ind+nperseg] * window window_sums.append(sum(seg)) envelopes[i,:] = window_sums else: env = resample(env,numsamp) envelopes.append(env) return array(envelopes).T
def ups(array): y = sg.resample(array, 600) y = pd.DataFrame(y) return (y)
#else: # transforms[i] = [0,0,0] prev_gray = curr_gray #plt.plot(np.arange(transforms.shape[0]) * 1/29.97,transforms[:,0]) #plt.plot(np.arange(transforms.shape[0]) * 1/29.97,transforms[:,1]) #plt.plot(np.arange(transforms.shape[0]) * 1/29.97,transforms[:,2]) transforms = np.genfromtxt('test_clips/GX016017.MP4' + "opticalflowH6.csv", delimiter=',') mysample = transforms[0:100, 2] * 59.94 N = 0 resampled = resample(mysample, 400) sampleB = integrator.get_raw_data("z")[N:400 + N] testcorr = np.correlate(sampleB, resampled, "full") plt.plot(testcorr) print(np.argmax(testcorr) - 400) maxcorr = np.argmax(testcorr) - 400 #plt.plot(resampled) #plt.plot(integrator.get_raw_data("z")[0:400]) plt.plot(np.arange(mysample.shape[0]) * interval - 3.1 / 60, mysample) #plt.figure()
counter=counter+1 yClass=[] for i in range(0,len(y)): temp=[0] * 11 temp[y[i]]=1 yClass.append(temp) Xnew=[] counter=0 for i in X: f = signal.resample(i, 8000) counter=1+counter Xnew.append(f) Xtest= np.array(Xnew) ytest= np.array(yClass) b = Xtest[:, :, newaxis] Xtest=b model = tf.keras.models.load_model('model1.h5') #Model name here. pred= model.predict(Xtest,verbose=1) #########
def GetAPTs(filename, ti1=0, ti2=1, pval=100, pad=False, interpol=False, norm=False): print('Generating Pulse Train From File:') print(filename) print('\n') ## Spectral arrays. Specx = np.zeros(shape=2048, dtype=complex) Specy = np.zeros(shape=2048, dtype=complex) ndt = 2048 # Unpack the datas. Horder, xp, ixp, yp, iyp = np.genfromtxt(filename, unpack=True) # Get x and y spectral components. specx = xp + 1j * ixp specy = yp + 1j * iyp # Shift the spectra. Specx[:1024] = specx Specy[:1024] = specy for idx, energy in enumerate(Horder): if energy < 12.0: Specx[idx] = 0 Specy[idx] = 0 if energy > 45: Specx[idx] = 0 Specy[idx] = 0 if pad == True: # Try zero padding hard core before ifft. Specx = np.pad(Specx, (pval, pval), 'constant', constant_values=(0, 0)) Specy = np.pad(Specy, (pval, pval), 'constant', constant_values=(0, 0)) # Get the padded fields. Ex = np.fft.ifft(Specx) Ey = np.fft.ifft(Specy) else: # Get the fields. Ex = np.fft.ifft(Specx) Ey = np.fft.ifft(Specy) # Shift the fields to center them at t=0. fl = len(Ex) / 2 Ex = np.hstack((Ex[-fl:], Ex[:-fl])) Ey = np.hstack((Ey[-fl:], Ey[:-fl])) # Now, get the real part of the fields. Ex = np.real(Ex) Ey = np.real(Ey) if interpol == True: # Try interpolating. Ex = signal.resample(Ex, len(Ex) * 3) Ey = signal.resample(Ey, len(Ey) * 3) # Create the time array. dw = Horder[2] - Horder[1] # Frequency step size. wmax = (Horder[-1] + dw) * omega # Max frequency. t = np.linspace(0, len(Ex), len(Ex)) * np.pi / wmax # Time array. dt = t[2] - t[1] tmax = t[-1] + dt tplot = (t - tmax / 2) / t_period if norm == True: Ex = Ex / np.max(np.abs(Ex)) Ey = Ey / np.max(np.abs(Ey)) # for idx, stuff in enumerate(Ex): # print(idx, tplot[idx], np.sqrt(stuff**2 + Ey[idx]**2)) # Truncate arrays to a single cycle of the IR field. tind = ((tplot >= ti1) & (tplot <= ti2)) tplot = tplot[tind] Ex = Ex[tind] Ey = Ey[tind] # # Try padding the arrays for asthetics. # tpre = np.linspace(tplot[0], tplot[0]-0.25, 50) # tpost = np.linspace(tplot[-1], tplot[-1]+0.25, 50) # tplot = np.concatenate((tpre, tplot, tpost)) # Ex = np.pad(Ex, (50, 50), 'constant', constant_values=(Ex[0], Ex[-1])) # Ey = np.pad(Ey, (50, 50), 'constant', constant_values=(Ey[0], Ey[-1])) return tplot, Ex, Ey
def convert(files, ids, genders, ecg_channel_name, dataset_name, i_patient): """ Extracts segments from the ECG recordings and saves them as .npy files The segments of every patient will be stored in a separate folder. args: files (list of str): list of paths to the .edf recordings ids (pd.Dataframe): internal patient ids genders (pd.Dataframe): gender of each patient ecg_channel_name (str) name of the channel with ECG-data in the .edf files dataset_name (str): name of dataset ('shhs' or 'mesa') i_patient (int): counter """ for file in files: i_patient += 1 # Load index of file in meta-data if dataset_name == 'shhs': meta_idx = int( np.argwhere(ids.values == int(file.split('-')[1][:-4]))) elif dataset_name == 'mesa': meta_idx = int( np.argwhere(ids.values == int(file.split('-')[-1][:-4]))) else: raise Exception('Invalid dataset name. Select "shhs" or "mesa".') # Get gender of patient from meta-data gender = GENDER_DICT[genders.values[meta_idx]] patient_id = str(ids.values[meta_idx]).zfill(6) # Create new folder for the patient patient_folder = os.path.join( target_folder, '{}-{}-{}'.format(dataset_name, patient_id, gender)) os.makedirs(patient_folder, exist_ok=True) # Load .edf file with pyedflib.EdfReader(file) as f: n = f.signals_in_file signal_labels = f.getSignalLabels() # Select ECG channel for i_channel in range(n): if signal_labels[i_channel] == ecg_channel_name: channel = i_channel # Load ECG channel signal = f.readSignal(channel) # Get sample frequency fs = f.getSampleFrequency(channel) # Set start 60 Minutes in the recording to avoid noise in the beginning start = 60 * 60 * fs # use only inner 5 hours where signal is cleaner stop = min( len(signal) - seg_len * fs - 60 * 60 * fs, 6 * 60 * 60 * fs) if stop < start: print("WARNING: stop < start for file {}".format(file)) continue seg_indices = np.linspace(start, stop, num=config['num_segs_per_patient'], dtype=np.int) for i_segment, ind in enumerate(seg_indices): local_idx = str(i_segment).zfill(2) target_path = os.path.join(patient_folder, '{}.npy'.format(local_idx)) segment = signal[ind:ind + seg_len * fs] if plot_output: plt.title("{}/{}, time: {:.2f}h/{:.2f}h".format( i_patient, n_files_total, ind / (fs * 3600), len(signal) / (fs * 3600))) plt.plot(segment) plt.show() # Resample if fs != config['new_fs']: if abs(fs - config['new_fs']) > 20: print( "Warning, this is a big resampling, fs: {}, source: {}, target: {}" .format(fs, file, target_path)) num = int(seg_len * new_fs) segment = resample(segment, num=num) # Save if save: np.save(file=target_path, arr=segment) # Logging if i_patient % config['log_interval'] == 0: time_left = (((time.time() - t_start) / i_patient) * (n_files_total - i_patient)) / 3600 print("\nProcessed file {} of {}".format( i_patient, n_files_total)) print(target_path, fs, len(segment), "{}/{}".format(i_patient, n_files_total), "\nTime elapsed {:.2f}s".format(time.time() - t_start), "Estimated time left: {:.2f} hours".format(time_left)) return i_patient
def preprocess(data, factor, low_perc=5, up_perc=80): ''' Preprocess gcamp data based on https://github.com/lucastheis/c2s/blob/master/c2s/c2s.py#L166 Main differences: - Simple linear regression to remove trends - Allows standardization to differ in lower and upper percentiles - Additional tools for managing camera and spike times :param data: dict containing 'calcium' input gcamp (required) [n] 'fps' original fps (required) [1] 'cam_times' original camera times (optional) [n] 'spike_times' spike times in seconds (optional) [m] :param factor: factor to upsample data. will produce upsampled data of size [factor * n] :param low_perc: lower percentile to normalize dff :param up_perc: upper percentile to normalize dff :return: dict with upsampled data and binned spikes (if spike_times provided) ''' if 'cam_times' in data: assert data['calcium'].shape[0] == data['cam_times'].shape[ 0], "gcamp and camera times must be same length" data = deepcopy(data) x = np.arange(data['calcium'].shape[0]) regr = linear_model.LinearRegression() regr.fit(x.reshape(-1, 1), data['calcium']) a = regr.coef_ b = regr.intercept_ data['calcium'] = data['calcium'] - (a * x + b) calcium_low_perc = np.percentile(data['calcium'], low_perc) calcium_high_perc = np.percentile(data['calcium'], up_perc) if calcium_high_perc - calcium_low_perc > 0.: data['calcium'] = (data['calcium'] - calcium_low_perc ) / float(calcium_high_perc - calcium_low_perc) # normalize sampling rate if factor > 1: # number of samples after update of sampling rate num_samples = data['calcium'].shape[0] * factor # resample calcium signal data['calcium'] = resample(data['calcium'].ravel(), num_samples) data['fps'] = data['fps'] * factor if 'cam_times' in data: data['cam_times'] = time_adjustment(data['cam_times'], factor, data['fps']) else: data['cam_times'] = np.arange( 0, data['calcium'].shape[0] / data['fps'], (1.0 / data['fps'])) data['cam_times'] = data['cam_times'][np.arange( data['calcium'].shape[0])] if 'spike_times' in data: data['spikes_per_bin'] = bin_spikes(data['cam_times'], data['spike_times']) return data
def samples_at(self, rate): new_samples = np.frombuffer(self.bytes_chunks, dtype=np.float32) return signal.resample(new_samples, rate * self.duration)
def my_resample(x, origin_fs, target_fs): from scipy.signal import resample origin_l = len(x) target_l = np.int32((1. * origin_l / origin_fs * target_fs)) xx = resample(x, target_l) return xx
def resample(signal, fs, new_fs): """Resample `signal` from `fs` to `new_fs`.""" new_signal = dsp.resample(signal, int(len(signal) * new_fs / fs)) return new_signal
def __resize_matrix_resample(self, groupsrc, groupdst, M): from scipy.signal import resample x_resampled = resample(M, len(groupsrc), window='blk') xy_resampled = resample( x_resampled.transpose(), len(groupdst), window='blk').transpose() return np.minimum(np.maximum(xy_resampled, 0), 1)
def main(): # Args parser = argparse.ArgumentParser() parser.add_argument("--model_name", default='models/XXL_lr000001_bs32.pth', help="Classifier model path") parser.add_argument( "--classifier", default='XXL', help="Choose classifier architecture, C, S, XS, XL, XXL, XXXL") args = parser.parse_args() # Select training device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Load specified Classifier if args.classifier == 'XS': net = Classifier_XS() elif args.classifier == 'S': net = Classifier_S() elif args.classifier == 'XL': net = Classifier_XL() elif args.classifier == 'XXL': net = Classifier_XXL() elif args.classifier == 'XXXL': net = Classifier_XXXL() else: net = Classifier() net.to(device) # Load parameters from trained model net.load_state_dict( torch.load('../../STEAD_ANN/models/' + args.model_name + '.pth')) net.eval() # Load Belgica data f = scipy.io.loadmat( "../../Data_Belgica/mat_2018_08_19_00h28m05s_Parkwind_HDAS_2Dmap_StrainData_2D.mat" ) # Read data data = f['Data_2D'] fs = 10 total = 0 seis, ns = 0, 0 # For every trace in the file for trace in data: # Resample resamp_trace = signal.resample(trace, 6000) # Normalize resamp_trace = resamp_trace / np.max(np.abs(resamp_trace)) # Numpy to Torch resamp_trace = torch.from_numpy(resamp_trace).to(device).unsqueeze(0) # Prediction outputs = net(resamp_trace.float()) predicted = torch.round(outputs.data).item() # Count traces total += 1 if predicted: seis += 1 else: ns += 1 # Average 5km of measurements avg_data = np.mean(data[3500:4001, :], 0) # Filter average data avg_data_filtered1 = butter_bandpass_filter(avg_data, 0.5, 1, fs, order=5) avg_data_filtered2 = butter_bandpass_filter(avg_data, 0.2, 0.6, fs, order=5) avg_data_filtered3 = butter_bandpass_filter(avg_data, 0.1, 0.3, fs, order=5) # Resample avg_data = signal.resample(avg_data, 6000) avg_data_filtered1 = signal.resample(avg_data_filtered1, 6000) avg_data_filtered2 = signal.resample(avg_data_filtered2, 6000) avg_data_filtered3 = signal.resample(avg_data_filtered3, 6000) # Normalize avg_data = avg_data / np.max(np.abs(avg_data)) avg_data_filtered1 = avg_data_filtered1 / np.max( np.abs(avg_data_filtered1)) avg_data_filtered2 = avg_data_filtered2 / np.max( np.abs(avg_data_filtered2)) avg_data_filtered3 = avg_data_filtered3 / np.max( np.abs(avg_data_filtered3)) # Numpy to Torch avg_data = torch.from_numpy(avg_data).to(device).unsqueeze(0) avg_data_filtered1 = torch.from_numpy(avg_data_filtered1).to( device).unsqueeze(0) avg_data_filtered2 = torch.from_numpy(avg_data_filtered2).to( device).unsqueeze(0) avg_data_filtered3 = torch.from_numpy(avg_data_filtered3).to( device).unsqueeze(0) # Prediction output = net(avg_data.float()) output_filtered1 = net(avg_data_filtered1.float()) output_filtered2 = net(avg_data_filtered2.float()) output_filtered3 = net(avg_data_filtered3.float()) predicted = torch.round(output.data).item() predicted_filtered1 = torch.round(output_filtered1.data).item() predicted_filtered2 = torch.round(output_filtered2.data).item() predicted_filtered3 = torch.round(output_filtered3.data).item() # Results print(f'Inferencia Belgica:\n\n' f'Total traces: {total}\n' f'Total predicted seismic traces: {seis}\n' f'Total predicted noise traces: {ns}\n') print(f'Average predicted: {predicted}\n' f'Average filtered predicted 1: {predicted_filtered1}\n' f'Average filtered predicted 2: {predicted_filtered2}\n' f'Average filtered predicted 3: {predicted_filtered3}\n')
data = pd.concat([train, test], sort=False) sub = pd.read_csv('data/提交结果示例.csv') y = train.groupby('fragment_id')['behavior_id'].min() train['mod'] = (train.acc_x**2 + train.acc_y**2 + train.acc_z**2)**.5 train['modg'] = (train.acc_xg**2 + train.acc_yg**2 + train.acc_zg**2)**.5 test['mod'] = (test.acc_x**2 + test.acc_y**2 + test.acc_z**2)**.5 test['modg'] = (test.acc_xg**2 + test.acc_yg**2 + test.acc_zg**2)**.5 x = np.zeros((7292, 60, 8, 1)) t = np.zeros((7500, 60, 8, 1)) for i in tqdm(range(7292)): tmp = train[train.fragment_id == i][:60] x[i, :, :, 0] = resample( tmp.drop(['fragment_id', 'time_point', 'behavior_id'], axis=1), 60, np.array(tmp.time_point))[0] for i in tqdm(range(7500)): tmp = test[test.fragment_id == i][:60] t[i, :, :, 0] = resample(tmp.drop(['fragment_id', 'time_point'], axis=1), 60, np.array(tmp.time_point))[0] kfold = StratifiedKFold(5, shuffle=True) def Net(): emb_size = 6 input = Input(shape=(60, 8, 1)) input_1_1 = Lambda(lambda x: x[:, :, 1:, :])(input) input_1_2 = Lambda(lambda x: x[:, :, 0, :])(input)
def _resample_fs(cls, data, new_fs, old_fs): fs_ratio = new_fs / old_fs new_length = int(np.round(len(data) * fs_ratio)) return signal.resample(data, new_length)
def resample(data, fs, new_fs=44150): resampled = signal.resample(data, int(len(data)*new_fs/fs)) return resampled
def proc_file(file): fobj = bu.hsDat(file, load=True) vperp = fobj.dat[:, 0] elec3 = fobj.dat[:, 1] try: phi_dg = fobj.attribs['phi_dg'] except: phi_dg = 0.0 inds = np.abs(full_freqs - fspin) < 200.0 cut = int(0.1 * fsamp) zeros = np.zeros_like(elec3[:cut]) voltages = [ zeros, zeros, zeros, elec3[:cut], -1.0 * elec3[:cut], zeros, zeros, zeros ] efield = bu.trap_efield(voltages, only_x=True)[0] drive_amp, drive_phase = bu.get_sine_amp_phase(efield) elec3_fft = np.fft.rfft(elec3) true_fspin = np.average(full_freqs[inds], weights=np.abs(elec3_fft)[inds]) carrier_amp, carrier_phase_mod = \ bu.demod(vperp, true_fspin, fsamp, plot=plot_carrier_demod, \ filt=True, bandwidth=bandwidth, notch_freqs=notch_freqs, notch_qs=notch_qs, \ tukey=True, tukey_alpha=5.0e-4, \ detrend=True, detrend_order=1, harmind=2.0) # b1, a1 = signal.butter(3, np.array(libration_filt_band)*2.0/fsamp, btype='bandpass') sos = signal.butter(3, libration_filt_band, btype='bandpass', fs=fsamp, output='sos') # carrier_phase_mod_filt = signal.filtfilt(b1, a1, carrier_phase_mod) carrier_phase_mod_filt = signal.sosfiltfilt(sos, carrier_phase_mod) if len(libration_filt_band): libration_inds = (full_freqs > libration_filt_band[0]) \ * (full_freqs < libration_filt_band[1]) else: libration_inds = np.abs(full_freqs - libration_guess) < 0.5 * libration_bandwidth phase_mod_fft = np.fft.rfft(carrier_phase_mod) * fac lib_fit_x = full_freqs[libration_inds] lib_fit_y = np.abs(phase_mod_fft[libration_inds]) try: try: peaks = bu.find_fft_peaks(lib_fit_x, lib_fit_y, delta_fac=5.0, window=50) ind = np.argmax(peaks[:, 1]) except: peaks = bu.find_fft_peaks(lib_fit_x, lib_fit_y, delta_fac=3.0, window=100) ind = np.argmax(peaks[:, 1]) true_libration_freq = peaks[ind, 0] except: true_libration_freq = lib_fit_x[np.argmax(lib_fit_y)] libration_amp, libration_phase = \ bu.demod(carrier_phase_mod, true_libration_freq, fsamp, \ plot=plot_libration_demod, filt=True, \ filt_band=libration_filt_band, \ bandwidth=libration_bandwidth, \ tukey=False, tukey_alpha=5.0e-4, \ detrend=False, detrend_order=1.0, harmind=1.0) libration_ds, time_vec_ds = \ signal.resample(carrier_phase_mod_filt, t=time_vec, num=out_nsamp) libration_amp_ds, time_vec_ds = \ signal.resample(libration_amp, t=time_vec, num=out_nsamp) libration_ds = libration_ds[out_cut:int(-1 * out_cut)] libration_amp_ds = libration_amp_ds[out_cut:int(-1 * out_cut)] time_vec_ds = time_vec_ds[out_cut:int(-1 * out_cut)] if plot_downsample: plt.plot(time_vec, carrier_phase_mod_filt, color='C0', label='Original') plt.plot(time_vec_ds, libration_ds, color='C0', ls='--', label='Downsampled') plt.plot(time_vec, libration_amp, color='C1') #, label='Original') plt.plot(time_vec_ds, libration_amp_ds, color='C1', ls='--') #, label='Downsampled') plt.legend() plt.show() input() return (time_vec_ds, libration_ds, libration_amp_ds, \ true_libration_freq, phi_dg, drive_amp)
def main(): # Args parser = argparse.ArgumentParser() parser.add_argument("--model_name", default='Default_model', help="Classifier model path") parser.add_argument("--classifier", default='C', help="Choose classifier architecture, C, CBN") args = parser.parse_args() # Select training device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Load specified Classifier if args.classifier == 'CBN': net = ClassConvBN() elif args.classifier == 'C': net = ClassConv() else: net = ClassConv() print('Bad Classifier option, running classifier C') net.to(device) # Load parameters from trained model net.load_state_dict(torch.load('../../STEAD_CNN/models/' + args.model_name + '.pth')) net.eval() # Load Francia data file 1 f = scipy.io.loadmat("../../Data_Francia/Earthquake_1p9_Var_BP_2p5_15Hz.mat") # Read data data = f["StrainFilt"] # time= f["Time"] # distance = f["Distance_fiber"] # Sampling frequency fs = 100 total = 0 tr_seismic, tr_noise = 0, 0 fil_seismic, fil_noise = 0, 0 # For every trace in the file for trace in data: if np.max(np.abs(trace)): # Filter fil_trace = butter_bandpass_filter(trace, 0.5, 1, fs, order=5) # Resample resamp_trace = signal.resample(trace, 6000) resamp_fil_trace = signal.resample(fil_trace, 6000) # Normalize resamp_trace = resamp_trace / np.max(np.abs(resamp_trace)) resamp_fil_trace = resamp_fil_trace / np.max(np.abs(resamp_fil_trace)) # Numpy to Torch resamp_trace = torch.from_numpy(resamp_trace).to(device).unsqueeze(0) resamp_fil_trace = torch.from_numpy(resamp_fil_trace).to(device).unsqueeze(0) # Prediction out_trace = net(resamp_trace.float()) out_fil_trace = net(resamp_fil_trace.float()) pred_trace = torch.round(out_trace.data).item() pred_fil_trace = torch.round(out_fil_trace.data).item() # Count traces total += 1 if pred_trace: tr_seismic += 1 else: tr_noise += 1 if pred_fil_trace: fil_seismic += 1 else: fil_noise += 1 # Results print(f'Inferencia Francia:\n\n' f'Total traces: {total}\n' f'Predicted seismic: {tr_seismic}, predicted noise: {tr_noise}\n' f'Predicted fil_seismic: {fil_seismic}, predicted fil_noise: {fil_noise}\n')
def feature_extractor(pair_of_attrs, pair_of_attr_names): attr1 = pair_of_attrs[0] # attr2 = pair_of_attrs[1] attr1_name = pair_of_attr_names[0] # attr2_name = pair_of_attr_names[1] attr1_df = pd.DataFrame({attr1_name: attr1}) # attr2_df = pd.DataFrame({attr2_name: attr2}) content_ratio1 = content_ratio(attr1) # content_ratio2 = content_ratio(attr2) # print(content_ratio1) # print(content_ratio2) # all attrs in table1 tbl1_attrs = attr1_df.keys() # all attrs in table2 # tbl2_attrs = attr2_df.keys() distributions1 = {} # distributions2 = {} for attr in tbl1_attrs: content_histogram_tbl1 = content_histogram(attr1_df, attr) distributions1[attr] = content_histogram_tbl1 # for attr in tbl2_attrs: # content_histogram_tbl2 = content_histogram(attr2_df, attr) # distributions2[attr] = content_histogram_tbl2 # table1 attr1_histog = [] for distr in distributions1: # print(distr) if distr == attr1_name: # distributions1[distr].sort_values(distr) for index, row in distributions1[distr].iterrows(): # print(row) # for key in row.keys(): attr1_histog.append(row[distr]) # # table2 # attr2_histog = [] # for distr in distributions2: # # print(distr) # if distr == attr2_name: # # distributions2[distr].sort_values(distr) # for index, row in distributions2[distr].iterrows(): # attr2_histog.append(row[distr]) attr1_histog.sort() # attr2_histog.sort() # print(attr1_histog) # print(attr2_histog) # resample using fft resample_dimension = 20 attr1_histog_re = signal.resample(attr1_histog, resample_dimension) # attr2_histog_re = signal.resample(attr2_histog, resample_dimension) # print(attr1_histog_re) # # print(attr2_histog_re) # visualize_histograms_pair(attr1_name, attr1_histog_re, attr2_name, attr2_histog_re, resample_dimension) # print(_get_col_dtype(attr1_df[attr1_name])) # print(_get_col_dtype(attr2_df[attr2_name])) average_cell_len1 = average_cell_len(attr1) # average_cell_len2 = average_cell_len(attr2) percentage_of_num1, percentage_of_alphabetic1 = percentage_of_num_alphabetic( attr1) # percentage_of_num2, percentage_of_alphabetic2 = percentage_of_num_alphabetic(attr2) attr1_features = [content_ratio1] attr1_features.extend(attr1_histog_re) attr1_features.append(average_cell_len1) attr1_features.append(percentage_of_num1) attr1_features.append(percentage_of_alphabetic1) # attr2_features = [content_ratio2] # attr2_features.extend(attr2_histog_re) # attr2_features.append(average_cell_len2) # attr2_features.append(percentage_of_num2) # attr2_features.append(percentage_of_alphabetic2) attr1_features_dict = ['attr_histogram'] * resample_dimension attr1_features_dict = [ 'content_ratio', *attr1_features_dict, 'average_cell_len', 'percentage_of_num', 'percentage_of_alphabetic' ] return attr1_features, attr1_features_dict
import numpy as np import matplotlib.pyplot as plot import scipy.signal as sg import wave from scipy.io.wavfile import read rate, signal = read("../Xe.wav") maxIndex = len(signal) plot.figure() for frames in range(0, 20): signalArray = [] signalTQ = [] for k in range(6000 + frames * 256, 6300 + frames * 256): signalArray.append(signal[k]) signalArray = sg.resample(signalArray, 300) for k in range(0, 149): # day la K 0..150 sig = 0 for y in range(0, 299 - k): sig = sig + signalArray[y] * signalArray[y + k] # day la R(k) signalTQ.append(sig) plot.figure(1) plot.clf() # plot.subplot(111) plot.plot(signalTQ, color="purple") plot.grid(True) plot.figure(2) plot.clf() plot.subplot(311)
def get_data(self): # Function to get force data from txt file filename = input( "Enter Force File Name with full Path if not in Working Directory (Ex: User/File.txt): " ) print(" ") file1 = open(filename) # set file name f1 = file1.readlines() # read file DataBegin = 19 # Begin at line 19 to get force data for i in range(DataBegin, len(f1)): cnt = 0 for x in range(len(f1[i])): if (f1[i][x] == '\t'): if (cnt == 0): self.time_abs.append(float( f1[i][0:x])) # Add to time list temp = x + 1 if (cnt == 1): self.forceX.append(float( f1[i][temp:x])) # Add to Attila X list temp = x + 1 if (cnt == 2): self.forceY.append(float( f1[i][temp:x])) # Add to Attila Y list temp = x + 1 if (cnt == 3): self.forceZ.append(float( f1[i][temp:x])) # Add to Attila Z list temp = x + 1 if (cnt == 4): temp = x + 1 if (cnt == 5): temp = x + 1 if (cnt == 6): if (f1[17][29] == 'x'): self.forceX2.append(float( f1[i][temp:x])) # Add to Ryan X list temp = x + 1 if (cnt == 7): if (f1[17][34] == 'x'): self.forceX2.append(float( f1[i][temp:x])) # Add to Ryan X list if (f1[17][32] == 'y'): self.forceY2.append(float( f1[i][temp:x])) # Add to Ryan Y list temp = x + 1 if (cnt == 8): if (f1[17][37] == 'y'): self.forceY2.append(float( f1[i][temp:x])) # Add to Ryan Y list if (f1[17][35] == 'z'): self.forceZ2.append(float( f1[i][temp:x])) # Add to Ryan Z list temp = x + 1 if (cnt == 9): if (f1[17][40] == 'z'): self.forceZ2.append(float( f1[i][temp:x])) # Add to Ryan Z list cnt = cnt + 1 #Get sampling rates to downsample data video_SR = input("Input Video Sampling Rate (Hz): ") data_SR = input("Input Data Sampling Rate (Hz): ") print(" ") #Set dwonsample trigger downsample = int(data_SR) / int(video_SR) up_samp = 0 if downsample - int(downsample) != 0: up_samp = 1 #Declare lists for graphing data self.graph = [0] * (self.total_frames) self.graph = range(len(self.graph)) self.graphMax = [0] * (self.total_frames) self.graphMin = [0] * (self.total_frames) self.graphX = [0] * (self.total_frames) self.graphY = [0] * (self.total_frames) self.graphZ = [0] * (self.total_frames) self.graphX2 = [0] * (self.total_frames) self.graphY2 = [0] * (self.total_frames) self.graphZ2 = [0] * (self.total_frames) #Downsample data to video rate if up_samp == 0: cnt = 0 for i in range(len(self.time_abs)): if cnt == downsample: self.time_DS.append(self.time_abs[i]) self.forceX_DS.append(self.forceX[i]) self.forceY_DS.append(self.forceY[i]) self.forceZ_DS.append(self.forceZ[i]) self.forceX2_DS.append(self.forceX2[i]) self.forceY2_DS.append(self.forceY2[i]) self.forceZ2_DS.append(self.forceZ2[i]) cnt = 0 cnt += 1 #if resampling is needed if up_samp == 1: #find least common multiples and factors lcm = np.lcm(int(data_SR), int(video_SR)) data_factor = int(lcm / int(data_SR)) video_factor = int(lcm / int(video_SR)) #resample data to a factor of data_factor f_time = np.linspace(0, max(self.time_abs), int(data_factor * len(self.time_abs))) f_X = signal.resample(self.forceX, data_factor * len(self.forceX)) f_Y = signal.resample(self.forceY, data_factor * len(self.forceY)) f_Z = signal.resample(self.forceZ, data_factor * len(self.forceZ)) f_X2 = signal.resample(self.forceX2, data_factor * len(self.forceX2)) f_Y2 = signal.resample(self.forceY2, data_factor * len(self.forceY2)) f_Z2 = signal.resample(self.forceZ2, data_factor * len(self.forceZ2)) #downsample data to video_factor cnt = 0 for i in range(len(f_time)): if cnt == video_factor: self.time_DS.append(f_time[i]) self.forceX_DS.append(f_X[i]) self.forceY_DS.append(f_Y[i]) self.forceZ_DS.append(f_Z[i]) self.forceX2_DS.append(f_X2[i]) self.forceY2_DS.append(f_Y2[i]) self.forceZ2_DS.append(f_Z2[i]) cnt = 0 cnt += 1 #create data lists to grah if self.contact_plate == "Attila": self.list_creator(self.forceZ_DS, self.graphZ, self.frame_number1) else: self.list_creator(self.forceZ2_DS, self.graphZ2, self.frame_number1) count = 0 for x in range(self.frame_number1, self.total_frames - 1): if count == len(self.time_DS): break self.graphX[self.frame_number1 + count] = self.forceX_DS[self.frame_test + count] self.graphY[self.frame_number1 + count] = self.forceY_DS[self.frame_test + count] self.graphX2[self.frame_number1 + count] = self.forceX2_DS[self.frame_test + count] self.graphY2[self.frame_number1 + count] = self.forceY2_DS[self.frame_test + count] if self.contact_plate == "Attila": self.graphZ2[self.frame_number1 + count] = self.forceZ2_DS[self.frame_test + count] if self.contact_plate == "Ryan": self.graphZ[self.frame_number1 + count] = self.forceZ_DS[self.frame_test + count] count += 1 #Reverse Y data if inversed rev_Y = input("Reverse Y axis? (Y/N): ") if rev_Y == "Y": for x in range(len(self.graphY2)): self.graphY[x] = -1 * self.graphY[x] self.graphY2[x] = -1 * self.graphY2[x] #Reverse X data if inversed rev_X = input("Reverse X axis? (Y/N): ") print(" ") if rev_X == "Y": for x in range(len(self.graphX2)): self.graphX[x] = -1 * self.graphX[x] self.graphX2[x] = -1 * self.graphX2[x] #If trimming video, set data to trim points if self.trim == "Y": length = len(self.graph[self.trim_1:self.trim_2]) self.graph = self.time_DS[0:length] self.graphX = self.graphX[self.trim_1:self.trim_2] self.graphY = self.graphY[self.trim_1:self.trim_2] self.graphZ = self.graphZ[self.trim_1:self.trim_2] self.graphX2 = self.graphX2[self.trim_1:self.trim_2] self.graphY2 = self.graphY2[self.trim_1:self.trim_2] self.graphZ2 = self.graphZ2[self.trim_1:self.trim_2]
def resample(cls, frames, org_fs, dst_fs): return signal.resample(frames, int((frames.size * dst_fs) / org_fs))
def resample_signal(msignal, n_sample): return resample(msignal, n_sample)
def apply(self, data): axis = data.ndim - 1 if data.shape[-1] > self.f: return resample(data, self.f, axis=axis) return data
globals()[VarName] = np.load(FilePath) x_syn_peak, y_syn_peak = augment_train_set(xraw_test_peak[0:49, :], y_test_peak[0:49, :], 100) x_syn_per, y_syn_per = augment_train_set(xraw_test_per[0:49, :], y_test_per[0:49, :], 100) x_syn_osc, y_syn_osc = augment_train_set(xraw_test_osc[0:49, :], y_test_osc[0:49, :], 100) FolderPath_output = os.path.abspath(os.path.join(os.getcwd(), "./output_data/")) np.save(FolderPath_output + "/x_syn_peak.npy", x_syn_peak) np.save(FolderPath_output + "/x_syn_per.npy", x_syn_per) np.save(FolderPath_output + "/x_syn_osc.npy", x_syn_osc) x_syn_peak = signal.resample(x_syn_peak, 10000, axis=1) x_syn_peak = preprocessing.scale(x_syn_peak) n_syn_norm = len(x_syn_peak) x_syn_per = signal.resample(x_syn_per, 10000, axis=1) x_syn_per = preprocessing.scale(x_syn_per) x_syn_osc = signal.resample(x_syn_osc, 10000, axis=1) x_syn_osc = preprocessing.scale(x_syn_osc) #=============================================================================# ########### produce data: reality-augmented simulation faulty data ############ #=============================================================================# n_syn = 2000 # synthetic time series to be produced Syn_norm = ['peak', 'per'] FolderPath1 = ['v110', 'v90', 'v70', 'v50', 'v20'] FolderPath2 = ['normal', 'WF']
from numpy.random import normal from numpy import log10, finfo, arange import matplotlib.pyplot as plt from scipy.fftpack import fft from scipy.signal.windows import get_window from scipy.signal import decimate, resample eps = finfo("float").eps def normalise(x): return (x-min(x))/(max(x)-min(x)) sr = 44100 mean = 0 std = 1 N = 2**14 noise = normal(mean, std, size=N) noisedec = resample(decimate(noise, 2), N) window = get_window('blackmanharris', N, fftbins=False) noisefft = abs(fft(noise * window))[:int(N/2)] noisefftdec = abs(fft(noisedec * window))[:int(N/2)] noisefft = 20*log10(normalise(noisefft) + eps) noisefftdec = 20*log10(normalise(noisefftdec) + eps) f = arange(int(N/2))/N*sr fig, ax = plt.subplots(2, 1, figsize=(16,9)) ax[0].plot(f,noisefft) ax[1].plot(f,noisefftdec) plt.show()
def interpolate_peaks(data, peaks, sample_rate, desired_sample_rate=1000.0, working_data={}): '''interpolate detected peak positions and surrounding data points Function that enables high-precision mode by taking the estimated peak position, then upsampling the peak position +/- 100ms to the specified sampling rate, subsequently estimating the peak position with higher accuracy. Parameters ---------- data : 1d list or array list or array containing heart rate data peaks : 1d list or array list or array containing x-positions of peaks in signal sample_rate : int or float the sample rate of the signal (in Hz) desired_sampled-rate : int or float the sample rate to which to upsample. Must be sample_rate < desired_sample_rate Returns ------- working_data : dict working_data dictionary object containing all of heartpy's temp objects Examples -------- Given the output of a normal analysis and the first five peak-peak intervals: >>> import heartpy as hp >>> data, _ = hp.load_exampledata(0) >>> wd, m = hp.process(data, 100.0) >>> wd['peaklist'][0:5] [63, 165, 264, 360, 460] Now, the resolution is at max 10ms as that's the distance between data points. We can use the high precision mode for example to approximate a more precise position, for example if we had recorded at 1000Hz: >>> wd = interpolate_peaks(data = data, peaks = wd['peaklist'], ... sample_rate = 100.0, desired_sample_rate = 1000.0, working_data = wd) >>> wd['peaklist'][0:5] [63.5, 165.4, 263.6, 360.4, 460.2] As you can see the accuracy of peak positions has increased. Note that you cannot magically upsample nothing into something. Be reasonable. ''' assert desired_sample_rate > sample_rate, "desired sample rate is lower than actual sample rate \ this would result in downsampling which will hurt accuracy." num_samples = int(0.1 * sample_rate) ratio = sample_rate / desired_sample_rate interpolation_slices = [(x - num_samples, x + num_samples) for x in peaks] peaks = [] for i in interpolation_slices: slice = data[i[0]:i[1]] resampled = resample( slice, int(len(slice) * (desired_sample_rate / sample_rate))) peakpos = np.argmax(resampled) peaks.append((i[0] + (peakpos * ratio))) working_data['peaklist'] = peaks return working_data
def scopeplot(x, width=800, height=400, range_=None, cmap=None, plot=None): """ Plot a signal using brightness to indicate density. Parameters ---------- x : array_like, 1-D The signal to be plotted width, height : int, optional The width and height of the output image in pixels. Default is 800×400. range_ : float or 2-tuple of floats, optional The vertical range of the plot. If a tuple, it is (xmin, xmax). If a single number, the range is (-range, range). If None, it autoscales. cmap : str or matplotlib.colors.LinearSegmentedColormap, optional A matplotlib colormap for Grayscale by default. plot : bool or str or None, optional If plot is None, the X image array is returned. if plot is True, the image is plotted directly. If plot is a string, it represents a filename to save the image to using matplotlib's `imsave`. Returns ------- X : ndarray of shape (width, height) A 2D array of amplitude 0 to 1, representing the density of the signal at that point. """ if cmap is None: cmap = 'gray' x = asarray(x) N = len(x) # Add zeros to end to reduce circular Gibbs effects MIN_PAD = 5 # TODO: what should this be? Seems subjective. # Make input an optimal length for fast processing pad_amount = next_fast_len(N + MIN_PAD) - N x = pad(x, (0, pad_amount), 'constant') # Resample such that signal evenly divides into chunks of equal length new_size = int(round(_ceildiv(RS * N, width) * width / N * len(x))) print('new size: {}'.format(new_size)) x = resample(x, new_size) if not range_: range_ = 1.1 * np.amax(np.abs(x)) if np.size(range_) == 1: xmin, xmax = -range_, +range_ elif np.size(range_) == 2: xmin, xmax = range_ else: raise ValueError('range_ not understood') spp = _ceildiv(N * RS, width) # samples per pixel norm = 1 / spp # Pad some zeros at beginning for overlap x = pad(x, (spp // 2, 0), 'constant') X = np.empty((width, height)) if spp % 2: # N is odd chunksize = 2 * spp # (even) else: # N is even chunksize = 2 * spp + 1 # (odd) print('spp: {}, chunk size: {}'.format(spp, chunksize)) for n in range(0, width): chunk = x[n * spp:n * spp + chunksize] assert len(chunk) # don't send empties try: h = _ihist(chunk, bins=height, range_=(xmin, xmax)) except ValueError: print('argh', len(chunk)) else: X[n] = h * norm assert np.amax(X) <= 1.001, np.amax(X) X = X**(0.4) # TODO: SUBJECTIVE if isinstance(plot, str): plt.imsave(plot, X.T, cmap=cmap, origin='lower', format='png') elif plot: fig = plt.figure() ax = fig.add_subplot(1, 1, 1) ax.imshow(X.T, origin='lower', aspect='auto', cmap=cmap, extent=(0, len(x), xmin, xmax), interpolation='nearest') # norm=LogNorm(vmin=0.01, vmax=300)) else: return X
def stftMorph(self, x1, x2, fs, w1, N1, w2, N2, H1, smoothf, balancef): """ Morph of two sounds using the STFT x1, x2: input sounds, fs: sampling rate w1, w2: analysis windows, N1, N2: FFT sizes, H1: hop size smoothf: smooth factor of sound 2, bigger than 0 to max of 1, where 1 is no smothing, balancef: balance between the 2 sounds, from 0 to 1, where 0 is sound 1 and 1 is sound 2 returns y: output sound """ if (N2 / 2 * smoothf < 3): # raise exception if decimation factor too small raise ValueError("Smooth factor too small") if (smoothf > 1): # raise exception if decimation factor too big raise ValueError("Smooth factor above 1") if (balancef > 1 or balancef < 0): # raise exception if balancef outside 0-1 raise ValueError("Balance factor outside range") if (H1 <= 0): # raise error if hop size 0 or negative raise ValueError("Hop size (H1) smaller or equal to 0") M1 = w1.size # size of analysis window hM1_1 = math.floor( (M1 + 1) // 2) # half analysis window size by rounding hM1_2 = math.floor(M1 // 2) # half analysis window size by floor L = x1.size // H1 # number of frames for x1 x1 = np.append( np.zeros(hM1_2), x1) # add zeros at beginning to center first window at sample 0 x1 = np.append( x1, np.zeros(hM1_1)) # add zeros at the end to analyze last sample pin1 = hM1_1 # initialize sound pointer in middle of analysis window w1 = w1 / sum(w1) # normalize analysis window M2 = w2.size # size of analysis window hM2_1 = math.floor( (M2 + 1) / 2) # half analysis window size by rounding hM2_2 = math.floor(M2 / 2) # half analysis window size by floor2 H2 = x2.size // L # hop size for second sound x2 = np.append( np.zeros(hM2_2), x2) # add zeros at beginning to center first window at sample 0 x2 = np.append( x2, np.zeros(hM2_1)) # add zeros at the end to analyze last sample pin2 = hM2_1 # initialize sound pointer in middle of analysis window y = np.zeros(x1.size) # initialize output array for l in range(L): #-----analysis----- mX1, pX1 = DFT.dftAnal(x1[pin1 - hM1_1:pin1 + hM1_2], w1, N1) # compute dft mX2, pX2 = DFT.dftAnal(x2[pin2 - hM2_1:pin2 + hM2_2], w2, N2) # compute dft #-----transformation----- mX2smooth = resample(np.maximum(-200, mX2), int( mX2.size * smoothf)) # smooth spectrum of second sound mX2 = resample(mX2smooth, mX1.size) # generate back the same size spectrum mY = balancef * mX2 + (1 - balancef) * mX1 # generate output spectrum #-----synthesis----- y[pin1 - hM1_1:pin1 + hM1_2] += H1 * DFT.dftSynth( mY, pX1, M1) # overlap-add to generate output sound pin1 += H1 # advance sound pointer pin2 += H2 # advance sound pointer y = np.delete(y, range( hM1_2)) # delete half of first window which was added in stftAnal y = np.delete( y, range(y.size - hM1_1, y.size)) # add zeros at the end to analyze last sample # write morphed sound data outputFullPath = outputPath + morphedFileName #path4Writing = getRightPath(outputFullPath) #sf.write(path4Writing, y, RATE) # write sound file in env commUtill.writeSoundFile(outputFullPath, y, RATE) return outputFullPath
def main(): # Args parser = argparse.ArgumentParser() parser.add_argument("--model_name", default='CBN_10epch', help="Classifier model path") parser.add_argument("--classifier", default='CBN', help="Choose classifier architecture, C, CBN") args = parser.parse_args() # Select training device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Load specified Classifier if args.classifier == 'CBN': net = ClassConvBN() elif args.classifier == 'C': net = ClassConv() else: net = ClassConv() print('Bad Classifier option, running classifier C') net.to(device) # Load parameters from trained model net.load_state_dict(torch.load('../../STEAD_CNN/models/' + args.model_name + '.pth')) net.eval() # Load Nevada data file 1 f = '../../Data_Utah/FORGE_78-32_iDASv3-P11_UTC190419001218.sgy' # Read data with segyio.open(f, ignore_geometry=True) as segy: segy.mmap() # Traces data = segyio.tools.collect(segy.trace[:]) # Sampling frequency fs = segy.header[0][117] total = 0 tr_seismic, tr_noise = 0, 0 fil_seismic, fil_noise = 0, 0 seis_traces = [] seis_fil_traces = [] noise_traces = [] noise_fil_traces = [] # For every trace in the file for idx, trace in enumerate(data): # Filter fil_trace = butter_bandpass_filter(trace, 0.5, 1, fs, order=5) # Resample resamp_trace = signal.resample(trace, 6000) resamp_fil_trace = signal.resample(fil_trace, 6000) # Normalize resamp_trace = resamp_trace / np.max(np.abs(resamp_trace)) resamp_fil_trace = resamp_fil_trace / np.max(np.abs(resamp_fil_trace)) # Numpy to Torch resamp_trace = torch.from_numpy(resamp_trace).to(device).unsqueeze(0) resamp_fil_trace = torch.from_numpy(resamp_fil_trace).to(device).unsqueeze(0) # Prediction out_trace = net(resamp_trace.float()) out_fil_trace = net(resamp_fil_trace.float()) pred_trace = torch.round(out_trace.data).item() pred_fil_trace = torch.round(out_fil_trace.data).item() # Count traces total += 1 if pred_trace: tr_seismic += 1 seis_traces.append(idx) else: tr_noise += 1 noise_traces.append(idx) if pred_fil_trace: fil_seismic += 1 seis_fil_traces.append(idx) else: fil_noise += 1 noise_fil_traces.append(idx) seis_tr_id = np.random.choice(seis_traces, 1) seis_fil_tr_id = np.random.choice(seis_fil_traces, 1) noise_tr_id = np.random.choice(seis_traces, 1) noise_fil_tr_id = np.random.choice(seis_fil_traces, 1) plt.figure() plt.plot(data[seis_tr_id]) plt.savefig('seis_trace1.png') plt.clf() plt.plot(data[seis_fil_tr_id]) plt.savefig('seis_fil_trace1.png') plt.clf() plt.plot(data[noise_tr_id]) plt.savefig('noise_trace1.png') plt.clf() plt.plot(data[noise_fil_tr_id]) plt.savefig('noise_fil_trace1.png') # Results print(f'Inferencia Utah:\n\n' f'File: FORGE_78-32_iDASv3-P11_UTC190419001218.sgy\n' f'Total traces: {total}\n' f'Predicted seismic: {tr_seismic}, predicted noise: {tr_noise}\n' f'Predicted fil_seismic: {fil_seismic}, predicted fil_noise: {fil_noise}\n')
import scipy.signal as sg import wave from scipy import signal # from master.scikits.talkbox.linpred.levinson_lpc import levinson,lpc from scikits.talkbox.linpred.levinson_lpc import lpc from scipy.io.wavfile import read rate, signal = read("../Xe.wav") signalA = [] for i in range(6000, 6512): signalA.append(signal[i]) signalA = np.array(signalA) p = 14 a, e, k = lpc(signalA, p, -1) a = np.append(a, np.zeros(512-14)) data_freq = np.fft.fft(a, 512) data_freq = sg.resample(data_freq,512) magSpectrum = np.abs(data_freq) # magDb = 1/magSpectrum magDb = -np.log(magSpectrum) signalArray = [] signalDK = [] for k in range(6000, 6900): signalArray.append(signal[k]) signalArray = sg.resample(signalArray, 900) for k in range(0, 149): # day la K 0..150 sig = 0 for m in range(0, 299): sig = sig + np.abs(signalArray[m] - signalArray[ m - k]) # day la D(k) signalDK.append(sig) # plot.plot(signalDK) plot.subplot(311)
def main(): cfg.device = torch.device('cuda') torch.backends.cudnn.benchmark = False max_per_image = 100 num_classes = 80 if cfg.dataset == 'coco' else 4 dictionary = np.load(cfg.dictionary_file) colors = COCO_COLORS if cfg.dataset == 'coco' else DETRAC_COLORS names = COCO_NAMES if cfg.dataset == 'coco' else DETRAC_NAMES for j in range(len(names)): col_ = [c * 255 for c in colors[j]] colors[j] = tuple(col_) print('Creating model and recover from checkpoint ...') if 'hourglass' in cfg.arch: model = exkp(n=5, nstack=2, dims=[256, 256, 384, 384, 384, 512], modules=[2, 2, 2, 2, 2, 4], num_classes=num_classes) else: raise NotImplementedError model = load_demo_model(model, cfg.ckpt_dir) model = model.to(cfg.device) model.eval() # Loading COCO validation images annotation_file = '{}/annotations/instances_{}.json'.format( cfg.data_dir, cfg.data_type) coco = COCO(annotation_file) # Load all annotations cats = coco.loadCats(coco.getCatIds()) nms = [cat['name'] for cat in cats] catIds = coco.getCatIds(catNms=nms) imgIds = coco.getImgIds(catIds=catIds) annIds = coco.getAnnIds(catIds=catIds) all_anns = coco.loadAnns(ids=annIds) for annotation in all_anns: if annotation['iscrowd'] == 1 or type( annotation['segmentation']) != list: continue img = coco.loadImgs(annotation['image_id'])[0] image_path = '%s/images/%s/%s' % (cfg.data_dir, cfg.data_type, img['file_name']) w_img = int(img['width']) h_img = int(img['height']) if w_img < 1 or h_img < 1: continue polygons = annotation['segmentation'][0] gt_bbox = annotation['bbox'] gt_x1, gt_y1, gt_w, gt_h = gt_bbox contour = np.array(polygons).reshape((-1, 2)) # Downsample the contour to fix number of vertices fixed_contour = resample(contour, num=cfg.num_vertices) # Indexing from the left-most vertex, argmin x-axis idx = np.argmin(fixed_contour[:, 0]) indexed_shape = np.concatenate( (fixed_contour[idx:, :], fixed_contour[:idx, :]), axis=0) clockwise_flag = check_clockwise_polygon(indexed_shape) if not clockwise_flag: fixed_contour = np.flip(indexed_shape, axis=0) else: fixed_contour = indexed_shape.copy() fixed_contour[:, 0] = np.clip(fixed_contour[:, 0], gt_x1, gt_x1 + gt_w) fixed_contour[:, 1] = np.clip(fixed_contour[:, 1], gt_y1, gt_y1 + gt_h) contour_mean = np.mean(fixed_contour, axis=0) contour_std = np.std(fixed_contour, axis=0) # norm_shape = (fixed_contour - contour_mean) / np.sqrt(np.sum(contour_std ** 2.)) # plot gt mean and std # image = cv2.imread(image_path) # # cv2.ellipse(image, center=(int(contour_mean[0]), int(contour_mean[1])), # # axes=(int(contour_std[0]), int(contour_std[1])), # # angle=0, startAngle=0, endAngle=360, color=(0, 255, 0), # # thickness=2) # cv2.rectangle(image, pt1=(int(contour_mean[0] - contour_std[0] / 2.), int(contour_mean[1] - contour_std[1] / 2.)), # pt2=(int(contour_mean[0] + contour_std[0] / 2.), int(contour_mean[1] + contour_std[1] / 2.)), # color=(0, 255, 0), thickness=2) # cv2.polylines(image, [fixed_contour.astype(np.int32)], True, (0, 0, 255)) # cv2.rectangle(image, pt1=(int(min(fixed_contour[:, 0])), int(min(fixed_contour[:, 1]))), # pt2=(int(max(fixed_contour[:, 0])), int(max(fixed_contour[:, 1]))), # color=(255, 0, 0), thickness=2) # cv2.imshow('GT segments', image) # if cv2.waitKey() & 0xFF == ord('q'): # break image = cv2.imread(image_path, cv2.IMREAD_COLOR) original_image = image.copy() height, width = image.shape[0:2] padding = 127 if 'hourglass' in cfg.arch else 31 imgs = {} for scale in cfg.test_scales: new_height = int(height * scale) new_width = int(width * scale) if cfg.img_size > 0: img_height, img_width = cfg.img_size, cfg.img_size center = np.array([new_width / 2., new_height / 2.], dtype=np.float32) scaled_size = max(height, width) * 1.0 scaled_size = np.array([scaled_size, scaled_size], dtype=np.float32) else: img_height = (new_height | padding) + 1 img_width = (new_width | padding) + 1 center = np.array([new_width // 2, new_height // 2], dtype=np.float32) scaled_size = np.array([img_width, img_height], dtype=np.float32) img = cv2.resize(image, (new_width, new_height)) trans_img = get_affine_transform(center, scaled_size, 0, [img_width, img_height]) img = cv2.warpAffine(img, trans_img, (img_width, img_height)) img = img.astype(np.float32) / 255. img -= np.array( COCO_MEAN if cfg.dataset == 'coco' else DETRAC_MEAN, dtype=np.float32)[None, None, :] img /= np.array(COCO_STD if cfg.dataset == 'coco' else DETRAC_STD, dtype=np.float32)[None, None, :] img = img.transpose( 2, 0, 1)[None, :, :, :] # from [H, W, C] to [1, C, H, W] # if cfg.test_flip: # img = np.concatenate((img, img[:, :, :, ::-1].copy()), axis=0) imgs[scale] = { 'image': torch.from_numpy(img).float(), 'center': np.array(center), 'scale': np.array(scaled_size), 'fmap_h': np.array(img_height // 4), 'fmap_w': np.array(img_width // 4) } with torch.no_grad(): segmentations = [] predicted_codes = [] start_time = time.time() for scale in imgs: imgs[scale]['image'] = imgs[scale]['image'].to(cfg.device) output = model(imgs[scale]['image'])[-1] segms, codes_ = ctsegm_scale_decode_debug( *output, torch.from_numpy(dictionary.astype(np.float32)).to( cfg.device), K=cfg.test_topk) segms = segms.detach().cpu().numpy().reshape( 1, -1, segms.shape[2])[0] codes_ = codes_.detach().cpu().numpy().reshape( 1, -1, codes_.shape[2])[0] top_preds = {} code_preds = {} for j in range(cfg.num_vertices): segms[:, 2 * j:2 * j + 2] = transform_preds( segms[:, 2 * j:2 * j + 2], imgs[scale]['center'], imgs[scale]['scale'], (imgs[scale]['fmap_w'], imgs[scale]['fmap_h'])) segms[:, cfg.num_vertices * 2:cfg.num_vertices * 2 + 2] = transform_preds( segms[:, cfg.num_vertices * 2:cfg.num_vertices * 2 + 2], imgs[scale]['center'], imgs[scale]['scale'], (imgs[scale]['fmap_w'], imgs[scale]['fmap_h'])) segms[:, cfg.num_vertices * 2 + 2:cfg.num_vertices * 2 + 4] = transform_preds( segms[:, cfg.num_vertices * 2 + 2:cfg.num_vertices * 2 + 4], imgs[scale]['center'], imgs[scale]['scale'], (imgs[scale]['fmap_w'], imgs[scale]['fmap_h'])) clses = segms[:, -1] for j in range(num_classes): inds = (clses == j) top_preds[j + 1] = segms[inds, :cfg.num_vertices * 2 + 5].astype(np.float32) top_preds[j + 1][:, :cfg.num_vertices * 2 + 4] /= scale code_preds[j + 1] = codes_[inds, :] segmentations.append(top_preds) predicted_codes.append(code_preds) segms_and_scores = { j: np.concatenate([d[j] for d in segmentations], axis=0) for j in range(1, num_classes + 1) } # a Dict label: segments codes_and_scores = { j: np.concatenate([d[j] for d in predicted_codes], axis=0) for j in range(1, num_classes + 1) } # a Dict label: segments scores = np.hstack([ segms_and_scores[j][:, cfg.num_vertices * 2 + 4] for j in range(1, num_classes + 1) ]) if len(scores) > max_per_image: kth = len(scores) - max_per_image thresh = np.partition(scores, kth)[kth] for j in range(1, num_classes + 1): keep_inds = (segms_and_scores[j][:, cfg.num_vertices * 2 + 4] >= thresh) segms_and_scores[j] = segms_and_scores[j][keep_inds] codes_and_scores[j] = codes_and_scores[j][keep_inds] # Use opencv functions to output a video output_image = original_image for lab in segms_and_scores: for idx in range(len(segms_and_scores[lab])): res = segms_and_scores[lab][idx] c_ = codes_and_scores[lab][idx] # for res in segms_and_scores[lab]: contour, bbox, score = res[:-5], res[-5:-1], res[-1] bbox[0] = np.clip(bbox[0], 0, w_img) bbox[1] = np.clip(bbox[1], 0, h_img) bbox[2] = np.clip(bbox[2], 0, w_img) bbox[3] = np.clip(bbox[3], 0, h_img) if score > cfg.detect_thres: text = names[lab] # + ' %.2f' % score # label_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_COMPLEX, thickness=2, fontScale=0.5) polygon = contour.reshape((-1, 2)) # use bb tools to draw predictions color = random.choice(COLOR_WORLD) bb.add(output_image, bbox[0], bbox[1], bbox[2], bbox[3], text, color) cv2.polylines(output_image, [polygon.astype(np.int32)], True, RGB_DICT[color], thickness=2) # color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)) # contour_mean = np.mean(polygon, axis=0) # contour_std = np.std(polygon, axis=0) # center_x, center_y = np.mean(polygon, axis=0).astype(np.int32) # text_location = [bbox[0] + 1, bbox[1] + 1, # bbox[1] + label_size[0][0] + 1, # bbox[0] + label_size[0][1] + 1] # cv2.rectangle(output_image, pt1=(int(bbox[0]), int(bbox[1])), # pt2=(int(bbox[2]), int(bbox[3])), # color=color, thickness=1) # cv2.rectangle(output_image, pt1=(int(np.min(polygon[:, 0])), int(np.min(polygon[:, 1]))), # pt2=(int(np.max(polygon[:, 0])), int(np.max(polygon[:, 1]))), # color=(0, 255, 0), thickness=1) # cv2.polylines(output_image, [polygon.astype(np.int32)], True, color, thickness=2) # cv2.putText(output_image, text, org=(int(text_location[0]), int(text_location[3])), # fontFace=cv2.FONT_HERSHEY_COMPLEX, thickness=2, fontScale=0.5, # color=(255, 0, 0)) # cv2.putText(output_image, text, org=(int(bbox[0]), int(bbox[1])), # fontFace=cv2.FONT_HERSHEY_COMPLEX, thickness=1, fontScale=0.5, # color=color) # show the histgram for predicted codes fig = plt.figure() plt.plot(np.arange(cfg.n_codes), c_.reshape((-1, )), color='green', marker='o', linestyle='dashed', linewidth=2, markersize=6) plt.ylabel('Value of each coefficient') plt.xlabel('All predicted {} coefficients'.format( cfg.n_codes)) plt.title( 'Distribution of the predicted coefficients for {}' .format(text)) plt.show() cv2.imshow('Results', output_image) if cv2.waitKey() & 0xFF == ord('q'): break