def expand(self, audio): ori_len = audio.shape[0] tmp = resample(audio, r=0.5, type='sinc_best') down_len = tmp.shape[0] tmp = resample(tmp, r=(ori_len + 1) / float(down_len), type='sinc_best') tmp = librosa.stft(audio, 1024) phase = np.divide(tmp, np.abs(tmp)) spec_input = np.abs(librosa.stft(audio, 1024))[0:n_input, ::] spec_input = spec_input[::, 0:spec_input.shape[1] // n_len * n_len] spec_input = np.split(spec_input, spec_input.shape[1] // n_len, axis=1) spec_input = np.asarray(spec_input) spec_input = np.expand_dims(spec_input, axis=-1) feed_dict = {self.input_op: np.log1p(spec_input) / 12.0} debug = self.sess.run(self.debug_op, feed_dict=feed_dict) np.save('debug.npy', debug) S = self.sess.run(self.eva_op, feed_dict=feed_dict) S[S >= 5e3] = 5e3 S[S <= 0] = 0 print('mean', np.mean(S)) print(np.sum(np.isinf(S))) S = np.squeeze(np.concatenate(np.split(S, S.shape[0]), axis=2), axis=(0, -1)) phase = phase[..., :S.shape[1]] print(phase.shape) print(S.shape) print(np.sum(np.isinf(np.multiply(S, phase)))) X = librosa.istft(np.multiply(S, phase)) return X
def __stream_audio_realtime(filepath, rate=44100): total_chunks = 0 format = pyaudio.paInt16 channels = 1 if sys.platform == 'darwin' else 2 record_cap = 10 # seconds p = pyaudio.PyAudio() stream = p.open(format=format, channels=channels, rate=rate, input=True, frames_per_buffer=ASR.chunk_size) print "o\t recording\t\t(Ctrl+C to stop)" try: desired_rate = float(desired_sample_rate) / rate # desired_sample_rate is an INT. convert to FLOAT for division. for i in range(0, rate/ASR.chunk_size*record_cap): data = stream.read(ASR.chunk_size) _raw_data = numpy.fromstring(data, dtype=numpy.int16) _resampled_data = resample(_raw_data, desired_rate, "sinc_best").astype(numpy.int16).tostring() total_chunks += len(_resampled_data) stdout.write("\r bytes sent: \t%d" % total_chunks) stdout.flush() yield _resampled_data stdout.write("\n\n") except KeyboardInterrupt: pass finally: print "x\t done recording" stream.stop_stream() stream.close() p.terminate()
def resample(y, orig_sr, target_sr, res_type='sinc_fastest'): """Resample a signal from orig_sr to target_sr Arguments: y -- (ndarray) audio time series orig_sr -- (int) original sample rate of y target_sr -- (int) target sample rate res_type -- (str) resample type (see below) Returns y_hat: y_hat -- (ndarray) y resampled from orig_sr to target_sr Notes: if scikits.samplerate is installed, resample will use res_type otherwise, it will fall back on scip.signal.resample """ if orig_sr == target_sr: return y if _HAS_SAMPLERATE: y_hat = samplerate.resample(y, float(target_sr) / orig_sr, res_type) else: n_samples = len(y) * target_sr / orig_sr y_hat = scipy.signal.resample(y, n_samples, axis=-1) return y_hat
def prepareData(self): if self.newSampleRate is not None: resamplingFactor = float(self.newSampleRate) / float( self.sampleRate) elif self.filterb is None: print("skipping data preparation, nothing to do") return newChannels = [None for x in xrange(len(self.channels))] for i, channel in itertools.izip(xrange(len(self.channels)), self.channels): print("channel {0}".format(i)) newData = channel if self.filterb is not None: print(" lowpass") newData = signal.lfilter(self.filterb, self.filtera, channel) if self.newSampleRate is not None: print(" resampling") newData = samplerate.resample( numpy.array(channel), resamplingFactor, 'sinc_best' if self.filterb is None else 'sinc_medium') newChannels[i] = newData self.channels = newChannels if self.newSampleRate is not None: self.sampleRate = self.newSampleRate
def play(self): if not self.sound: self.sound = pygame.mixer.Sound(self.file) self.freq = self.info.rate if resampleOk: (freq,format,channels) = pygame.mixer.get_init() if freq != self.freq: print "reload sound ",self.file self.freq = self.info.rate self.sound = pygame.mixer.Sound(self.file) if self.freq != freq: snd_array = pygame.sndarray.array(self.sound) samples = len(snd_array)/2 samples = int(samples*freq*1.0/(self.info.rate)) print "start resampling ",self.file," from ",self.info.rate," to ",freq," len ",len(snd_array)/2," visée ",samples # if samples != len(snd_array): # snd_array = np.resize(snd_array,(samples,2)) snd_array = resample(snd_array, freq*1.0/self.info.rate, "sinc_fastest").astype(snd_array.dtype) # datal = signal.resample(snd_array[0::2],samples).astype(snd_array.dtype) # datar = signal.resample(snd_array[1::2],samples).astype(snd_array.dtype) # snd_array = np.resize(snd_array,(len(datal)*2,2)) # snd_array[0::2] = datal # snd_array[1::2] = datar # print "end resampling ",snd_array self.sound = pygame.sndarray.make_sound(snd_array) self.freq = freq if self.volume: self.sound.set_volume(self.volume) self.channel = self.sound.play() self.playTime = time.time() if self.event: self.channel.set_endevent(self.event)
def resample(source, source_sf, target_sf): if source_sf != target_sf: from scikits import samplerate ratio = float(target_sf) / source_sf return samplerate.resample(source, ratio, RESAMPLE_TYPE) else: return source
def __stream_audio_realtime(filepath, rate=44100): total_chunks = 0 format = pyaudio.paInt16 channels = 1 if sys.platform == 'darwin' else 2 record_cap = 10 # seconds p = pyaudio.PyAudio() stream = p.open(format=format, channels=channels, rate=rate, input=True, frames_per_buffer=ASR.chunk_size) print "o\t recording\t\t(Ctrl+C to stop)" try: desired_rate = float( desired_sample_rate ) / rate # desired_sample_rate is an INT. convert to FLOAT for division. for i in range(0, rate / ASR.chunk_size * record_cap): data = stream.read(ASR.chunk_size) _raw_data = numpy.fromstring(data, dtype=numpy.int16) _resampled_data = resample(_raw_data, desired_rate, "sinc_best").astype( numpy.int16).tostring() total_chunks += len(_resampled_data) stdout.write("\r bytes sent: \t%d" % total_chunks) stdout.flush() yield _resampled_data stdout.write("\n\n") except KeyboardInterrupt: pass finally: print "x\t done recording" stream.stop_stream() stream.close() p.terminate()
def strfpak_resample(sound,slice_rate,resample_type): ''' Resample a sound object using scikits.samplerate.resample. Sound is upsampled to nearest multiple of slice_rate; if sound.samplerate == slice_rate, no resampling is done. Sound is also converted to float. Currently, error is less than 10dB max, mostly very good. ''' from scikits.samplerate import resample from copy import deepcopy # Calculate the resampling frequency for STRFPAK 5.3: # round up to the nearest multiple of 'slice_rate' input_freq = floor(sound.samplerate) output_freq = ceil(input_freq/slice_rate)*slice_rate # Copy so that we don't alter original object sound2 = deepcopy(sound) # Scale factor -- MATLAB makes .wav data be -1:1, scipy does integer sound2.data = sound2.data/float(2**15) # Resample if necessary if output_freq > input_freq: sound2.data = resample(sound2.data,output_freq/input_freq, resample_type) sound2.samplerate = output_freq # Pad because matlab resampling works differently sound2.data = sound2._zeropad(0,2) return sound2
def record(self, signals, Fs): ''' This simulates the recording of the signals by the microphones. In particular, if the microphones and the room simulation do not use the same sampling frequency, down/up-sampling is done here. Arguments: ---------- signals: An ndarray with as many lines as there are microphones. Fs: the sampling frequency of the signals. ''' if signals.shape[0] != self.M: raise NameError('The signals array should have as many lines as there are microphones.') if signals.ndim != 2: raise NameError('The signals should be a 2D array.') if Fs != self.Fs: from scikits.samplerate import resample Fs_ratio = self.Fs/float(Fs) newL = int(Fs_ratio*signals.shape[1])-1 self.signals = np.zeros((self.M, newL)) # scikits.samplerate resample function considers columns as channels (hence the transpose) for m in range(self.M): self.signals[m] = resample(signals[m], Fs_ratio, 'sinc_best') else: self.signals = signals
def convert_wav(File, ofile): import scikits.audiolab as audiolab from scikits.samplerate import resample # lastest scikits.audiolab include sound record lib, based on python-alsaaudio # if you want make the down sample rate using scipy.signal #import scipy.signal #using audiolab to read wav file Signal, fs = audiolab.wavread(File)[:2] #changing the original sample rate to 16000fs fast mode Signal = resample(Signal, fr/float(fs), 'sinc_best') #changing sample rate from audio file using scipy this is a bit slow #Signal=scipy.signal.resample(Signal,int(round(len(Getsignal)*fr)/float(fs)),window=None) # file Format type fmt = audiolab.Format('flac', 'pcm16') nchannels = 1 # convert into the file .flac ofile = audiolab.Sndfile(FileNameTmp, 'w', fmt, nchannels, fr) #writing in the file ofile.write_frames(Signal) # return ofile
def wav_convert(data, SR, tar_freq): # If the input signal is stereo, make it mono. if ndim(data) == 2: # Mix stereo signal into a mono signal buff01 = 0.49 * (data[:, 0] + data[:, 1]) wave_ts = array(buff01) else: wave_ts = array(data[:]) wave_ts = array(wave_ts) # Set a sampling rate up_SR = 44100 # Compute a ratio to feed into resample function ratio = float(float(tar_freq)/float(up_SR)) # Resample the file. wave_ts = resample(wave_ts, ratio , 'linear') # Transpose the data list. wave_ts = transpose(wave_ts) # Return wave_ts signal return wave_ts
def wav_convert(data, SR, tar_freq): # If the input signal is stereo, make it mono. if ndim(data) == 2: buff01 = 0.49 * (data[:, 0] + data[:, 1]) wave_ts = array(buff01) else: wave_ts = array(data[:]) wave_ts = array(wave_ts) # print "Shape of wave_ts", shape(wave_ts) up_SR = 44100 ratio = float(float(tar_freq)/float(up_SR)) print tar_freq print float(float(tar_freq)/float(up_SR)) wave_ts = resample(wave_ts, ratio , 'linear') # SR_div = int(floor(up_SR/tar_freq)) # wave_ts = sig.decimate(wave_ts, SR_div) # Transpose the data list. wave_ts = transpose(wave_ts) print 'length wave_ts', shape(wave_ts) return wave_ts
def analyze(sig, samplerate=8000, resample_to=8000): e_min_scale = 0.3 e_min_distance = 1 e_a_scale = 0.5 e_W_ms = 2000 min_len = 30 if samplerate != resample_to: print("resampling") sig = srate.resample(sig, resample_to/samplerate, 'sinc_best') frames,frame_size = ad.frames(sig, samplerate, 64) #ac_peaks = [ad.ac_peaks(frame) for frame in frames] #energy = ad.energies(frames, ...) #energy = log_energy print("getting normalized spectra") normalized_spectrum = ad.normalized_spectrum(frames, samplerate) print("spectral entropy") spectral_entropy = np.fromiter(ad.entropy(frame) for frame in normalized_spectrum) entopy_t = np.percentile(spectral_entropy, 80) se_segments = ad.segments_to_seconds(ad.entropy_segment_indexes(spectral_entropy, entropy_t)) print("energy based computations") energy, smooth, en_a, en_t, en_lmin = ad.energy_thresholds(sig, noise_dist=e_min_distance, a_scale=e_a_scale, min_scale=e_min_scale, W_ms=e_W_ms) energy_segments = ad.get_voice_segments(smooth, en_t, ad.get_segment_indexes(smooth, en_t, min_len=10)) #energy_t = ad.thresholds(frames) #entropy_t = ad.entropy_t(frames) #energy_indexes = ad.get_segment_indexes(x, t, min_len=30) #entropy_indexes = ad.get_entropy_indexes(x, t, min_len=30) #combination_indexes = ad.get_combined_indexes(x, t, min_len=30) return spectral_entropy, se_t, se_segments, energy, en_t, energy_segments
def listen(stream, queue): try: while not exit: stream.start_stream() print('Listening...') for i in range(0,size): data = stream.read(frame) ar = numpy.fromstring(data, dtype=numpy.int16) data2 = resample(ar, (16000./48000.), 'linear') q.put(data2) # samps = numpy.fromstring(data, dtype=numpy.int16) # print (samps, q.qsize()) rms = audioop.rms(data, 2) print rms stream.stop_stream() if exit: sys.exit() q.join() except IOError: print('ERROR!!!!') pass stream.stop_stream() stream.close() pyaud.terminate() print "----------------------------------------------------------------------------------------------------------------"
def calculate_attributes(self): source = self.source freq = self.frequency sampling_rate = float(source.sampling_rate) fft_sampling_rate = sampling_rate/float(source.fft_step_size) window_length = float(source.fft_window_size)/sampling_rate # FIXME real time should be passed in as an extra field self.start = window_length if self.first_frame > 0: self.start += (self.first_frame - 1)/fft_sampling_rate self.length = window_length if len(freq) > 1: # if 'length' not in self.__dict__: # print self.__dict__ # print self.__dict__['length'] self.length += (len(freq) - 1)/fft_sampling_rate # print self.length self.end = self.start + self.length for k in ('frequency','amplitude'): a = getattr(self,k) setattr(self, k+'_min', min(a)) setattr(self, k+'_max', max(a)) setattr(self, k+'_mean', sum(a)/len(a)) freq_window = 2 # seconds freq_fft_size = 128 resampled_freq = resample(freq, freq_window*freq_fft_size/fft_sampling_rate, 'sinc_fastest') # FIXME truncate array? self.freq_fft = abs(rfft(resampled_freq,n=freq_fft_size,overwrite_x=True))[1:]
def generate_scale(self): """ Given the initial note, middle C, create the rest of the musical scale by resampling. Returns: Dictionary of musical scale with the key being the name of the note and the value being the corresponding sound object. """ pygame.mixer.init() wav = util.get_app_path() + "res/piano-c.wav" sound = pygame.mixer.Sound(wav) pygame.mixer.set_num_channels(32) sndarray = pygame.sndarray.array(sound) ratio_dict = {'low_c': 1, 'c_sharp': .944, 'd': .891, 'd_sharp':.841, 'e':.794, 'f':.749, 'f_sharp': .707, 'g': .667, 'g_sharp': .63, 'a': .594, 'a_sharp': .561, 'b':.53, 'high_c':.5} # Generate the Sound objects from the dictionary. scale = {} for key,value in ratio_dict.iteritems(): smp = resample(sndarray, value,"sinc_fastest").astype(sndarray.dtype) # Use the key, currently a string, as a variable scale[key] = pygame.sndarray.make_sound(smp) self.scale_dict=scale
def calculate_attributes(self): source = self.source freq = self.frequency sampling_rate = float(source.sampling_rate) fft_sampling_rate = sampling_rate / float(source.fft_step_size) window_length = float(source.fft_window_size) / sampling_rate # FIXME real time should be passed in as an extra field self.start = window_length if self.first_frame > 0: self.start += (self.first_frame - 1) / fft_sampling_rate self.length = window_length if len(freq) > 1: # if 'length' not in self.__dict__: # print self.__dict__ # print self.__dict__['length'] self.length += (len(freq) - 1) / fft_sampling_rate # print self.length self.end = self.start + self.length for k in ('frequency', 'amplitude'): a = getattr(self, k) setattr(self, k + '_min', min(a)) setattr(self, k + '_max', max(a)) setattr(self, k + '_mean', sum(a) / len(a)) freq_window = 2 # seconds freq_fft_size = 128 resampled_freq = resample(freq, freq_window * freq_fft_size / fft_sampling_rate, 'sinc_fastest') # FIXME truncate array? self.freq_fft = abs( rfft(resampled_freq, n=freq_fft_size, overwrite_x=True))[1:]
def train_codebook(basedirectory, spectral, desired_fs, clfs, n_samples): """Train the codebooks. Arguments: :param basedirectory: root directory of the audio corpus :param spectral: Spectral feature extraction. Object should be picklable and implement the \c Spectral abc; i.e. provide a \c transform method. :param clfs: list of clusterers. valid clusterers have a \c fit method and a \c predict method. optionally, for soft vq, also implement a \c predict_proba method. :param n_samples: number of spectral frames to sample from the audio corpus. :returns: a list of Codebook objects, of same length as the output of spectral_func """ wavs = list(rglob(basedirectory, '*.wav')) np.random.shuffle(wavs) inds = None idx = 0 X = None for i, wav in enumerate(wavs): if i % 10 == 0 and i > 0: print 'samples: {3}/{4}; loading file: {0} ({1}/{2})'.format( wavs[i], i+1, len(wavs), X.shape[0], n_samples ) sig, fs, _ = audiolab.wavread(wav) start, stop = trim_silence(sig, fs) specs = spectral.transform(samplerate.resample(sig[start:stop], desired_fs/fs, 'sinc_best')) if inds is None: inds = [0] + list(np.cumsum([spec.shape[1] for spec in specs])) spec = np.hstack(specs) if idx + spec.shape[0] >= n_samples: spec = spec[:n_samples - idx, :] if X is None: X = spec else: X = np.vstack((X, spec)) idx += spec.shape[0] if idx >= n_samples: break cdbs = [Codebook(clf) for clf in clfs] for i, cdb in enumerate(cdbs): cdb.train(X[:, inds[i]:inds[i+1]]) return cdbs
def resample_noise_file(sr_audio, sr_noise, data_noise): start1 = time.time() if sr_noise != 0: resampling_rate = float(sr_audio) / float(sr_noise) data_noise = resample(data_noise, resampling_rate, "sinc_best").astype(np.int16) end1 = time.time() # print("0:", end1-start1) return data_noise
def resample(self, samplerate, resample_type="sinc_best"): """ Returns a resampled version of the sound. """ if not have_scikits_samplerate: raise ImportError("Need scikits.samplerate package for resampling") y = array(resample(self, float(samplerate / self.samplerate), resample_type), dtype=float64) return Sound(y, samplerate=samplerate)
def TestGBPDN2(): # ________________________________________ print 'Test: generalized basis pursuit decomposition' fs = 8000. btmp,fstmp,fmt = audiolab.wavread('glockenspiel.wav') b = samplerate.resample(btmp, fs/fstmp,'sinc_best') L = len(b) A = GaborBlock(L,1024) B = GaborBlock(A.M,64) C = DictionaryUnion(A,B) b = np.hstack((b,np.zeros(C.M-L))) # pad to block boundary spow = 10*np.log10(b.conj().dot(b)) # additive white noise snr = 15 nvar = np.sum(np.abs(b)**2)/(10**(snr/10)) # 1e-2 n = np.sqrt(nvar)*np.random.randn(C.M)/np.sqrt(C.M) tonemap = np.reshape(range(A.N),(A.N/A.fftLen,A.fftLen)).transpose() transmap = np.reshape(range(B.N),(B.N/B.fftLen,B.fftLen)).transpose() f,fgrad = BP_factory() #f,fgrad = TT_factory(tonemap,transmap) xe = GBPDN_momentum(C,b+n,f,fgrad,maxerr=nvar,maxits=200,stoptol=1e-3,muinit=1e-1,momentum=0.9,smoothinit=1e-5,anneal=0.96) ye = np.real(C.dot(xe)) r = b-ye; rpow = 10*np.log10(r.conj().dot(r)) print 'SNR = %f' % (spow-rpow) ynoise = np.array(samplerate.resample(b+n,fstmp/fs,'sinc_best'),dtype='float64') ydenoise = np.array(samplerate.resample(ye,fstmp/fs,'sinc_best'),dtype='float64') yetone = np.real(A.dot(xe[:tonemap.size])) yetone = np.array(samplerate.resample(yetone,fstmp/fs,'sinc_best'),dtype='float64') yetrans = np.real(B.dot(xe[tonemap.size:])) yetrans = np.array(samplerate.resample(yetrans,fstmp/fs,'sinc_best'),dtype='float64') print 'Error (should be <= %f): %f' % (nvar,np.sum((r)**2)) print '----------------------------------------'
def resample(x, fs_old, fs_new, axis=0, algorithm='scipy'): """Resample signal If available resampling is done using scikit samplerate. Otherwise, scipy's FFT-based resample function will be used. Converters available in scikits.samplerate: - sinc_medium - linear - sinc_fastest - zero_order_hold - sinc_best """ if fs_old == fs_new: return x else: ratio = float(fs_new) / fs_old if use_scikits_resample and algorithm != 'scipy': if algorithm == 'scikits': algo = 'sinc_medium' else: algo = algorithm if axis == 0: tmp = sks.resample(x, ratio, algo) else: tmp = sks.resample(x.T, ratio, algo) if tmp.dtype != x.dtype: tmp = tmp.astype(x.dtype, casting='safe') return tmp else: if axis == 0: n_samples_new = int(np.round(x.shape[0] * ratio)) return signal.resample(x, n_samples_new) else: n_samples_new = int(np.round(x.shape[1] * ratio)) return signal.resample(x, n_samples_new, axis=axis)
def play(self): if have_sk_audiolab and have_sk_samplerate: play( np.array(resample(self.data, 44100. / self.fs, 'sinc_best'), dtype=np.float64)) else: print( 'Warning: scikits.audiolab and scikits.samplerate are required to play audiofiles.' )
def resample(y, orig_sr, target_sr, res_type='sinc_fastest', fix=True, **kwargs): """Resample a time series from orig_sr to target_sr :usage: >>> # Downsample from 22 KHz to 8 KHz >>> y, sr = librosa.load('file.wav', sr=22050) >>> y_8k = librosa.resample(y, sr, 8000) :parameters: - y : np.ndarray [shape=(n,)] audio time series - orig_sr : int > 0 [scalar] original sampling rate of ``y`` - target_sr : int > 0 [scalar] target sampling rate - res_type : str resample type (see note) - fix : bool adjust the length of the resampled signal to be of size exactly ``ceil(target_sr * len(y) / orig_sr)`` - *kwargs* If ``fix==True``, additional keyword arguments to pass to :func:`librosa.util.fix_length()`. :returns: - y_hat : np.ndarray [shape=(n * target_sr / orig_sr,)] ``y`` resampled from ``orig_sr`` to ``target_sr`` .. note:: If `scikits.samplerate` is installed, :func:`librosa.core.resample` will use ``res_type``. Otherwise, it will fall back on `scipy.signal.resample` """ if orig_sr == target_sr: return y n_samples = int(np.ceil(y.shape[-1] * float(target_sr) / orig_sr)) if _HAS_SAMPLERATE: y_hat = samplerate.resample(y.T, float(target_sr) / orig_sr, res_type).T else: y_hat = scipy.signal.resample(y, n_samples, axis=-1) if fix: y_hat = util.fix_length(y_hat, n_samples, **kwargs) return np.ascontiguousarray(y_hat, dtype=y.dtype)
def resample(self, samplerate, resample_type='sinc_best'): ''' Returns a resampled version of the sound. ''' if not have_scikits_samplerate: raise ImportError('Need scikits.samplerate package for resampling') y = array(resample(self, float(samplerate / self.samplerate), resample_type), dtype=float64) return Sound(y, samplerate=samplerate)
def set_note(self, note, hstring): octave = note[-1:] self.note_dict[note]['octave']=octave pure_note = note.strip(octave) ratio = self.note_dict[note]['ratio'] globals()[note] = resample(hstring, ratio, "sinc_best").astype(hstring.dtype) globals()[note+"_note"] = self.pygame.sndarray.make_sound(globals()[note]) globals()[note+"_note"].set_volume(.15) self.note_dict[note]['snd_arry']=note+"_note"
def resample(self, samplerate, resample_type='sinc_best'): ''' Returns a resampled version of the sound. ''' if not have_scikits_samplerate: raise ImportError('Need scikits.samplerate package for resampling') y = np.array(resample(self, float(samplerate / self.samplerate), resample_type), dtype=np.float64) return Sound(y, samplerate=samplerate)
def rce2wav(rcefile, samplerate, resample=None, split=False, splitsuffixes=None): """ a rce file is a raw, float64 file containing pressure level at each frame. FORMAT: 1 double: number of sources Each frame then contains the data for each source, interleaved rcefile : path to the .rce file samplerate : samplerate of the simulation (sim.samplerate) resample : INT (new samplerate). If given, file will be resampled to this sample-rate. NOTE: an .rce file is simply raw data. To load it: numpy.fromfile(path, dtype=float). The samplerate is not saved with the data, but it is the same used by the simulation. """ def name_with_suffix(origname, ext='wav', suffix=""): if suffix: suffix = "-%s" % str(suffix) base = os.path.splitext(origname)[0] return "%s%s.%s" % (base, suffix, ext) raw = rce2array(rcefile) from e import audiosample if resample is not None: try: from scikits import samplerate raw = samplerate.resample(raw, resample / samplerate, 'sync_fast') samplerate = resample except ImportError: warnings.warn( "resampling not available (install scikits.samplerate to enable). Keeping original samplerate" ) numch = raw.shape[1] if len(raw.shape) > 1 else 1 if not split or numch == 1: out = name_with_suffix(rcefile) audiosample.Sample(raw, samplerate).write(out) return out else: outs = [] if splitsuffixes is None: splitsuffixes = [str(i) for i in range(numch)] else: splitsuffixes = splitsuffixes[:numch] for i, suffix in enumerate(splitsuffixes): out = name_with_suffix(rcefile, suffix=suffix) outs.append(out) audiosample.Sample(raw[:, i], samplerate).write(out) return outs
def playSound(self, pitch, noteIndex): self.getControlVals() toneArray = self.soundArrays[self.selectedSound] if self.attack != 0: changedArray = resample(toneArray*self.attack, pitch,"sinc_fastest").astype(toneArray.dtype) else: changedArray = resample(toneArray, pitch,"sinc_fastest").astype(toneArray.dtype)#makes correct type newSound = pygame.sndarray.make_sound(changedArray) newSound.set_volume(self.volume) if (self.isRecording and self.songCount < len(self.songs) and self.selectedSong != None): currentTime = time.time() timePlayed = currentTime - self.startTime self.makeRecording(newSound,timePlayed,noteIndex,self.volume, self.length,self.fade,self.isSustained) if self.isSustained: self.length = -1 if self.fade != 0: newSound.play(0,self.length,0).fadeout(self.fade) elif self.isSustained: newSound.play(0,-1,0) else: newSound.play(0,self.length,0)
def resample(s, fs, fs_new, algorithm='sinc_best'): ''' sinc_medium : Band limited sinc interpolation, medium quality, 121dB SNR, 90% BW. linear : Linear interpolator, very fast, poor quality. sinc_fastest : Band limited sinc interpolation, fastest, 97dB SNR, 80% BW. zero_order_hold : Zero order hold interpolator, very fast, poor quality. sinc_best : Band limited sinc interpolation, best quality, 145dB SNR, 96% BW. ''' from scikits.samplerate import resample if fs_new == fs: return s return resample(s, fs_new / fs, 'sinc_best')
def load_song(song_path): """ Loads an individual song, normalizes it, and returns it. """ fs, data = wavfile.read(song_path) data = data.mean(axis=1).flatten() data = samplerate.resample(data, TARGET_FS / fs, 'linear') # Normalize data = data / np.max(data) * .95 print "\t- Loaded %s" % song_path return data
def _map(f, n_filters=40, n_ceps=13, fs=8000, downsample='sinc_best', win=0.025, shift=0.01, delta_order=2, energy=True, vad=True, dtype='float32', get_spec=False, get_mspec=True, get_mfcc=False, robust=True): ''' Return ------ (name, features, vad, sum1, sum2) ''' try: audio_path, segments = f # load audio data s, _ = speech.read(audio_path) # check frequency for downsampling (if necessary) if _ is not None: if fs is not None and fs != _: if fs < _: # downsample s = resample(s, fs / _, 'sinc_best') else: raise ValueError('Cannot perform upsample from frequency: ' '{}Hz to {}Hz'.format(_, fs)) else: fs = _ N = len(s) features = [] for name, start, end, channel in segments: start = int(float(start) * fs) end = int(N if end < 0 else end * fs) data = s[start:end, channel] if s.ndim > 1 else s[start:end] tmp = speech_features_extraction(data.ravel(), fs=fs, n_filters=n_filters, n_ceps=n_ceps, win=win, shift=shift, delta_order=delta_order, energy=energy, vad=vad, dtype=dtype, get_spec=get_spec, get_mspec=get_mspec, get_mfcc=get_mfcc) if tmp is not None: features.append((name,) + tmp) else: msg = 'Ignore segments: %s, error: NaN values' % name warnings.warn(msg) return features except Exception, e: msg = 'Ignore file: %s, error: %s' % (f[0], str(e)) warnings.warn(msg) if robust: return None else: import traceback; traceback.print_exc() raise e
def resample_data(self): for i_series in xrange(8): X_series = np.array(self.train_X_series[i_series]).astype(np.float32) X_series = resample(X_series, 250.0/500.0, 'sinc_fastest') self.train_X_series[i_series] = X_series y_series = np.array(self.train_y_series[i_series]).astype(np.int32) # take later predictions -> # shift all predictions backwards compared to data. # this ensures you are not using data from the future to make a prediciton # rather in a bad case maybe you do not even have all data up to the sample # to make the prediction y_series = y_series[1::2] # maybe some border effects remove predictions y_series = y_series[-len(X_series):] self.train_y_series[i_series] = y_series
def test_mono(): fs = 16000. fr = 8000. f0 = 440. # Create a small stereo audio array with dephased channel x = np.sin(2 * np.pi * f0/fs * np.arange(0, 2 * fs)) # Upsampled reference z_r = np.sin(2 * np.pi * f0/fr * np.arange(0, 2 * fr)) z = resample(x, fr /fs, 'sinc_best') assert np.max(np.abs(z_r[10:-1] - z[10:])) < 1e-2
def resample_data(self): for i_series in xrange(8): X_series = np.array(self.train_X_series[i_series]).astype( np.float32) X_series = resample(X_series, 250.0 / 500.0, 'sinc_fastest') self.train_X_series[i_series] = X_series y_series = np.array(self.train_y_series[i_series]).astype(np.int32) # take later predictions -> # shift all predictions backwards compared to data. # this ensures you are not using data from the future to make a prediciton # rather in a bad case maybe you do not even have all data up to the sample # to make the prediction y_series = y_series[1::2] # maybe some border effects remove predictions y_series = y_series[-len(X_series):] self.train_y_series[i_series] = y_series
def create_specgram_image_of_audio_file(fid): # Read wav file wave_obj = wave.open(fid, 'r') # Vectorize the wave file sample_vec = np.fromstring(wave_obj.readframes(wave_obj.getnframes()), np.short)/32780.0 sample_rate = wave_obj.getframerate() # get sample rate wave_obj.close() # Re-sample the vector to 22050 Hz if not sample_rate == 22050: sample_vec = resample(sample_vec, FS/sample_rate, 'sinc_best') num_of_samples = len(sample_vec) # Normalize the vector sample_vec = 0.9*sample_vec/sample_vec.max() # Create spectrogram # the window size (FFT size) is 512, and FFT HOP size is 128 -> 128/512 = 0.25 meaning a 75% overlap num_of_specgram_frames = int((num_of_samples-FFT_SIZE)/FFT_HOP_SIZE) + 1 # Hanning window function window = 0.5 * (1.0 - np.cos(np.array(range(FFT_SIZE))*2.0*np.pi/(FFT_SIZE-1))) # Apply STFT specgram = [] for j in range(num_of_specgram_frames): vec = sample_vec[j*FFT_HOP_SIZE: j*FFT_HOP_SIZE + FFT_SIZE] * window real_fft = np.fft.rfft(vec, FFT_SIZE) real_fft = abs(real_fft[:int(FFT_SIZE/2)]) specgram.append(real_fft) # Create spectrogram image specgram_transposed = np.transpose(np.array(specgram)) specgram_image = np.zeros_like(specgram_transposed) for i in range(specgram_transposed.shape[0]): specgram_image[i] = specgram_transposed[-i - 1] if np.max(specgram_image) <= 0.0: print('Problem: np.max(specgram_image) <= 0.0') else: specgram_image /= np.max(specgram_image) return specgram_image
def TestBPDN2(): # ________________________________________ print 'Test: basis pursuit decomposition' fs = 8000 btmp = audiolab.wavread('glockenspiel.wav')[0] b = samplerate.resample(btmp, fs/44100.,'sinc_best') L = len(b) A = GaborBlock(L,1024) B = GaborBlock(A.M,64) C = DictionaryUnion(A,B) b = np.hstack((b,np.zeros(C.M-L))) e = 1e-2 x = BPDN(C,b,e,100) ye = np.real(C.dot(x)) print 'Error (should be <= %f): %f' % (e,np.sum((b-ye)**2)) print '----------------------------------------' xtone = x[:A.N] xtrans = x[A.N:] ytone = np.real(A.dot(xtone)) ytrans = np.real(B.dot(xtrans)) audiolab.wavwrite(ytone,'ytone.wav',fs) audiolab.wavwrite(ytrans,'ytrans.wav',fs) # tonal decomp m = np.log10(np.abs(A.conj().transpose().dot(ytone))) tfgrid = np.reshape(range(0,A.N),(A.N/A.fftLen,A.fftLen)) tfgrid = tfgrid[:,:A.fftLen/2+1] pyplot.subplot(2,1,1) pyplot.imshow(m[tfgrid].transpose(), aspect='auto', interpolation='bilinear', origin='lower') # transient decomp m = np.log10(np.abs(B.conj().transpose().dot(ytrans))) tfgrid = np.reshape(range(0,B.N),(B.N/B.fftLen,B.fftLen)) tfgrid = tfgrid[:,:B.fftLen/2+1] pyplot.subplot(2,1,2) pyplot.imshow(m[tfgrid].transpose(), aspect='auto', interpolation='bilinear', origin='lower') pyplot.show()
def resample_audio(samples, current_sample_rate, new_sample_rate): '''Resamples audio samples Given an audio sample and the current sample rate, resample to a new sample rate. Args: samples: The audio samples from wavfile.read(<file>)[0] current_sample_rate: The current sample rate from wavfile.read(<file>)[1] new_sample_rate: The new sample rate Returns: A tuple with the new sample rate and the new audio samples. This is exactly similar to wavfile.read(<filename>) ''' return new_sample_rate, resample(samples, new_sample_rate / current_sample_rate, 'sinc_best')
def resample(y, orig_sr, target_sr, res_type='sinc_fastest'): """Resample a time series from orig_sr to target_sr :usage: >>> # Downsample from 22 KHz to 8 KHz >>> y, sr = librosa.load('file.wav', sr=22050) >>> y_8k = librosa.resample(y, sr, 8000) :parameters: - y : np.ndarray audio time series - orig_sr : int original sampling rate of ``y`` - target_sr : int target sampling rate - res_type : str resample type (see note) :returns: - y_hat : np.ndarray ``y`` resampled from ``orig_sr`` to ``target_sr`` .. note:: If scikits.samplerate is installed, resample will use res_type otherwise, it will fall back on scipy.signal.resample """ if orig_sr == target_sr: return y if _HAS_SAMPLERATE: y_hat = samplerate.resample(y.T, float(target_sr) / orig_sr, res_type).T else: n_samples = y.shape[-1] * target_sr / orig_sr y_hat = scipy.signal.resample(y, n_samples, axis=-1) return np.ascontiguousarray(y_hat)
def resample(self, target_fs, mode="sinc_best"): """ Resample the signal. One implication of the signal being digital, is that the resulting sampling frequency is not guaranteed to be exactly at `target_fs`. This method wraps :func:`~samplerate.resample` :param target_fs: The new sampling frequency :type target_fs: float :param mode: to be passed to :func:`~scikits.samplerate.resample` :type mode: str :return: """ # num = target_fs * self.size / self.fs ratio = target_fs / self.fs out = resample(self,ratio,mode) real_fs = out.size * self.fs / float(self.size) out = self._copy_attrs_to_array(out, fs=real_fs) return out
def load_wav(filename): ''' ''' f = open(filename, "r") nchannels, samplewidth, framerate, nframes,\ _, _ = f.getparams() frames = f.readframes(nframes) f.close() if samplewidth == 1: dtype = np.uint8 maxvalue = 2 ** 8 elif samplewidth == 2: dtype = np.int16 maxvalue = 2 ** (16 - 1) elif samplewidth == 4: dtype = np.int32 maxvalue = 2 ** (32 - 1) else: print "Error: unsupported samplewidth {}".format(samplewidth) return None all_samples = np.fromstring(frames, dtype) combined_samples = np.zeros(nframes) for i in xrange(nchannels): a = combined_samples b = all_samples[i::nchannels] condition = np.less(np.abs(a), np.abs(b)) combined_samples = np.choose(condition, [a, b]) normalized_samples = combined_samples / maxvalue if dtype == np.uint8: normalized_samples = 2 * normalized_samples - 1 desired_framerate = 16384. resampled_samples = resample(normalized_samples, desired_framerate / framerate, 'sinc_best') return Signal(resampled_samples, desired_framerate, filename)
def generate_scale(self): """ Given the initial note, middle C, create the rest of the musical scale by resampling. Returns: Dictionary of musical scale with the key being the name of the note and the value being the corresponding sound object. """ pygame.mixer.init() wav = util.get_app_path() + "res/piano-c.wav" sound = pygame.mixer.Sound(wav) pygame.mixer.set_num_channels(32) sndarray = pygame.sndarray.array(sound) ratio_dict = { 'low_c': 1, 'c_sharp': .944, 'd': .891, 'd_sharp': .841, 'e': .794, 'f': .749, 'f_sharp': .707, 'g': .667, 'g_sharp': .63, 'a': .594, 'a_sharp': .561, 'b': .53, 'high_c': .5 } # Generate the Sound objects from the dictionary. scale = {} for key, value in ratio_dict.iteritems(): smp = resample(sndarray, value, "sinc_fastest").astype(sndarray.dtype) # Use the key, currently a string, as a variable scale[key] = pygame.sndarray.make_sound(smp) self.scale_dict = scale
def resample(y, orig_sr, target_sr, fix=True, scale=False): """Resample a time series from orig_sr to target_sr Args: y : np.ndarray [shape=(n,) or shape=(2, n)] audio time series. Can be mono or stereo. orig_sr : number > 0 [scalar] original sampling rate of `y` target_sr : number > 0 [scalar] target sampling rate fix : bool adjust the length of the resampled signal to be of size exactly `ceil(target_sr * len(y) / orig_sr)` scale : bool Scale the resampled signal so that `y` and `y_hat` have approximately equal total energy. Returns y_hat : np.ndarray [shape=(n * target_sr / orig_sr,)] `y` resampled from `orig_sr` to `target_sr` """ if y.ndim > 1: return np.vstack([resample(yi, orig_sr, target_sr, fix=fix) for yi in y]) valid_audio(y, mono=True) if orig_sr == target_sr: return y ratio = float(target_sr) / orig_sr n_samples = int(np.ceil(y.shape[-1] * ratio)) try: # Try to use scikits.samplerate if available import scikits.samplerate as samplerate y_hat = samplerate.resample(y.T, ratio, 'sinc_best').T except ImportError: warnings.warn('Could not import scikits.samplerate. ' 'Falling back to scipy.signal') import scipy.signal y_hat = scipy.signal.resample(y, n_samples, axis=-1) if fix: y_hat = fix_length(y_hat, n_samples) if scale: y_hat /= np.sqrt(ratio) return np.ascontiguousarray(y_hat, dtype=y.dtype)
def resample(y, orig_sr, target_sr, res_type='sinc_fastest'): """Resample a signal from orig_sr to target_sr :usage: >>> # Downsample from 22 KHz to 8 KHz >>> y, sr = librosa.load('file.wav', sr=22050) >>> y_8k = librosa.resample(y, sr, 8000) :parameters: - y : np.ndarray audio time series - orig_sr : int original sampling rate of ``y`` - target_sr : int target sampling rate - res_type : str resample type (see note) :returns: - y_hat : np.ndarray ``y`` resampled from ``orig_sr`` to ``target_sr`` .. note:: If scikits.samplerate is installed, resample will use res_type otherwise, it will fall back on scipy.signal.resample """ if orig_sr == target_sr: return y if _HAS_SAMPLERATE: y_hat = samplerate.resample(y.T, float(target_sr) / orig_sr, res_type).T else: n_samples = y.shape[-1] * target_sr / orig_sr y_hat = scipy.signal.resample(y, n_samples, axis=-1) return y_hat
def prepareData(self): if self.newSampleRate is not None: resamplingFactor = float(self.newSampleRate)/float(self.sampleRate) elif self.filterb is None: print("skipping data preparation, nothing to do") return newChannels = [None for x in xrange(len(self.channels))] for i, channel in itertools.izip(xrange(len(self.channels)), self.channels): print("channel {0}".format(i)) newData = channel if self.filterb is not None: print(" lowpass") newData = signal.lfilter(self.filterb, self.filtera, channel) if self.newSampleRate is not None: print(" resampling") newData = samplerate.resample(numpy.array(channel), resamplingFactor, 'sinc_best' if self.filterb is None else 'sinc_medium') newChannels[i] = newData self.channels = newChannels if self.newSampleRate is not None: self.sampleRate = self.newSampleRate
def test_multi_channel(): fs = 16000. fr = 8000. f0 = 440. # Create a small stereo audio array with dephased channel xleft = np.sin(2 * np.pi * f0/fs * np.arange(0, 2 * fs)) xright = np.cos(2 * np.pi * f0/fs * np.arange(0, 2 * fs)) y = np.empty((xleft.size, 2), np.float) y[:,0] = xleft y[:,1] = xright # Upsampled reference z_rleft = np.sin(2 * np.pi * f0/fr * np.arange(0, 2 * fr)) z_rright = np.cos(2 * np.pi * f0/fr * np.arange(0, 2 * fr)) z_r = np.vstack((z_rleft, z_rright)).T z = resample(y, fr /fs, 'sinc_best') assert np.max(np.abs(z_r[100:-100] - z[100:-99])) < 1e-2
def main(dbFilename, targetFs, force=False): util.createDirectory(NormalizeDir) rirDb = json.load(open(dbFilename)) bar = util.ConsoleProgressBar() bar.start('Normalize RIRs') i = 0 for rirId, rir in rirDb.items(): targetFilename = os.path.join(NormalizeDir, rir['id'] + '.wav') if not force: if rir['filename'] == targetFilename and \ rir['fs'] == targetFs and \ targetFilename: continue x, fs_x = sf.read(os.path.join(ImportDir, rir['id'] + '.wav'), dtype='float32') y, fs_y = x, fs_x if fs_y != targetFs: y = resample(y, targetFs / fs_y, 'sinc_best') fs_y = targetFs rir['length_org'] = len(y) / fs_y y = util.trimSilence(y, 0.001, trimRight=False) y = util.normalizeAmplitude(y) sf.write(targetFilename, y, fs_y) rir['filename'] = targetFilename rir['fs'] = fs_y rir['length'] = len(y) / fs_y i += 1 bar.progress(i / len(rirDb)) bar.end() with open(dbFilename, 'w') as dbFile: json.dump(rirDb, dbFile, sort_keys=True, indent=4)
def resample(self): plotBA = False if type(self.original) is list: self.original = numpy.asarray(self.original) if self.logs : self.logs.write("Rec.py : resampling recording") aa,b,c=mlab.specgram(self.original,NFFT=256,Fs=self.sample_rate) to_sample = self.calc_resample_factor() self.original = resample(self.original, float(to_sample)/float(self.sample_rate) , 'sinc_best') if plotBA: a,b,c=mlab.specgram(self.original,NFFT=256,Fs=to_sample) figure(figsize=(25,15)) subplot(211) imshow(20*log10(numpy.flipud(aa)), interpolation='nearest', aspect='auto') subplot(212) imshow(20*log10(numpy.flipud(a)),interpolation='nearest', aspect='auto') savefig(''+self.filename+'.png', dpi=100) close() self.samples = len(self.original) self.sample_rate = to_sample
def analyze(sig, samplerate=8000, resample_to=8000): e_min_scale = 0.3 e_min_distance = 1 e_a_scale = 0.5 e_W_ms = 2000 min_len = 30 if samplerate != resample_to: print("resampling") sig = srate.resample(sig, resample_to / samplerate, 'sinc_best') frames, frame_size = ad.frames(sig, samplerate, 64) #ac_peaks = [ad.ac_peaks(frame) for frame in frames] #energy = ad.energies(frames, ...) #energy = log_energy print("getting normalized spectra") normalized_spectrum = ad.normalized_spectrum(frames, samplerate) print("spectral entropy") spectral_entropy = np.fromiter( ad.entropy(frame) for frame in normalized_spectrum) entopy_t = np.percentile(spectral_entropy, 80) se_segments = ad.segments_to_seconds( ad.entropy_segment_indexes(spectral_entropy, entropy_t)) print("energy based computations") energy, smooth, en_a, en_t, en_lmin = ad.energy_thresholds( sig, noise_dist=e_min_distance, a_scale=e_a_scale, min_scale=e_min_scale, W_ms=e_W_ms) energy_segments = ad.get_voice_segments( smooth, en_t, ad.get_segment_indexes(smooth, en_t, min_len=10)) #energy_t = ad.thresholds(frames) #entropy_t = ad.entropy_t(frames) #energy_indexes = ad.get_segment_indexes(x, t, min_len=30) #entropy_indexes = ad.get_entropy_indexes(x, t, min_len=30) #combination_indexes = ad.get_combined_indexes(x, t, min_len=30) return spectral_entropy, se_t, se_segments, energy, en_t, energy_segments
def perform_mfcc_on_filename(filename, opts): (samplerate, sig) = read_audio_to_numpy(filename) opts['samplerate'] = samplerate if sig.ndim > 1: # Mix to mono # TODO: Multi-channel nchannels = sig.shape[1] sig = n.mean(sig, axis=1) else: nchannels = 1 print "Read %s with sample rate %s, #channels = %d" % (filename, samplerate, nchannels) if (samplerate != desired_samplerate and not FORCE_RESAMPLE): print "%s has the wrong samplerate, ignoring" % filename return None if (samplerate != desired_samplerate and FORCE_RESAMPLE): origsig = sig sig = resample(origsig, 1.0 * desired_samplerate/samplerate, 'sinc_best') print "Resampled file from rate %d to rate %d, shape %s to %s" % (samplerate, desired_samplerate, origsig.shape, sig.shape) mfcc_feat = mfcc(sig, **opts) print "Computed mfccs on %s" % filename return mfcc_feat
def batchChordGenerate(taskList, prefix): ''' inputs: a list of lists each sublist contains the following values @ indices: 0 : vox collection index 1 : vox sample index 2 : a list: [sample #, transposition semitones, transposition cents] 3 : ... and so on ... ''' for i, t in enumerate(taskList): print "begin task for vocal gesture " + p(t[0]) + '_' + p(t[1]) # grab the vocal gesture: gestur = vox[t[0]][t[1]] # compute clicks to be applied in all files: idx, l = clicks(gestur) clk = [idx, l] # compute envelope to be applied to all files: env = envelope(gestur, 10, 30) env *= (1 / env.max()) # normalize envelope # proceed with computing: fp = prefix + '_' + p(i) + '__' + p(t[0]) + '_' + p(t[1]) + '__' sr = None enc = None for j in xrange(2, len(t)): fname = fp + str(j - 2) + '__' + str(t[j][0]) + '.wav' print " computing " + str(j) + ' : ' + fname transpratio = tr(t[j][1], t[j][2]) # print " transposition : " + str(t[j][1]) + ' ' + str(t[j][2]) + ' = ' + str(transpratio) rezs = [] # array of np.arrays containing transposed resonances for f in coll_safe[t[j][0]]: # print " file : " + f x, sr, enc = wavread(f) rezs.append(resample(x, transpratio, 'sinc_best')) wavwrite(resonancesChord(None, rezs, 30, clk, env), fname, 44100, 'pcm24') return
def preprocess(db, stations, comps, goal_day, params, responses=None): """ Fetches data for each ``stations`` and each ``comps`` using the data_availability table in the database. To correct for instrument responses, make sure to set ``remove_response`` to "Y" in the config and to provide the ``responses`` DataFrame. :Example: >>> from msnoise.api import connect, get_params, preload_instrument_responses >>> from msnoise.preprocessing import preprocess >>> db = connect() >>> params = get_params(db) >>> responses = preload_instrument_responses(db) >>> st = preprocess(db, ["YA.UV06","YA.UV10"], ["Z",], "2010-09-01", params, responses) >>> st 2 Trace(s) in Stream: YA.UV06.00.HHZ | 2010-09-01T00:00:00.000000Z - 2010-09-01T23:59:59.950000Z | 20.0 Hz, 1728000 samples YA.UV10.00.HHZ | 2010-09-01T00:00:00.000000Z - 2010-09-01T23:59:59.950000Z | 20.0 Hz, 1728000 samples :type db: :class:`sqlalchemy.orm.session.Session` :param db: A :class:`~sqlalchemy.orm.session.Session` object, as obtained by :func:`msnoise.api.connect`. :type stations: list of str :param stations: a list of station names, in the format NET.STA. :type comps: list of str :param comps: a list of component names, in Z,N,E,1,2. :type goal_day: str :param goal_day: the day of data to load, ISO 8601 format: e.g. 2016-12-31. :type params: class :param params: an object containing the config parameters, as obtained by :func:`msnoise.api.get_params`. :type responses: :class:`pandas.DataFrame` :param responses: a DataFrame containing the instrument responses, as obtained by :func:`msnoise.api.preload_instrument_responses`. :rtype: :class:`obspy.core.stream.Stream` :return: A Stream object containing all traces. """ datafiles = {} output = Stream() for station in stations: datafiles[station] = {} net, sta = station.split('.') gd = datetime.datetime.strptime(goal_day, '%Y-%m-%d') files = get_data_availability(db, net=net, sta=sta, starttime=gd, endtime=gd) for comp in comps: datafiles[station][comp] = [] for file in files: if file.comp[-1] not in comps: continue fullpath = os.path.join(file.path, file.file) datafiles[station][file.comp[-1]].append(fullpath) for istation, station in enumerate(stations): net, sta = station.split(".") for comp in comps: files = eval("datafiles['%s']['%s']" % (station, comp)) if len(files) != 0: logging.debug("%s.%s Reading %i Files" % (station, comp, len(files))) stream = Stream() for file in sorted(files): try: st = read(file, dytpe=np.float, starttime=UTCDateTime(gd), endtime=UTCDateTime(gd) + 86400) except: logging.debug("ERROR reading file %s" % file) continue for tr in st: if len(tr.stats.channel) == 2: tr.stats.channel += tr.stats.location tr.stats.location = "00" tmp = st.select(network=net, station=sta, component=comp) if not len(tmp): for tr in st: tr.stats.network = net st = st.select(network=net, station=sta, component=comp) else: st = tmp for tr in st: tr.data = tr.data.astype(np.float) tr.stats.network = tr.stats.network.upper() tr.stats.station = tr.stats.station.upper() tr.stats.channel = tr.stats.channel.upper() stream += st del st stream.sort() try: # HACK not super clean... should find a way to prevent the # same trace id with different sps to occur stream.merge(method=1, interpolation_samples=3, fill_value=None) except: logging.debug("Error while merging...") traceback.print_exc() continue stream = stream.split() if not len(stream): continue logging.debug("%s Checking sample alignment" % stream[0].id) for i, trace in enumerate(stream): stream[i] = check_and_phase_shift(trace) logging.debug("%s Checking Gaps" % stream[0].id) if len(getGaps(stream)) > 0: max_gap = params.preprocess_max_gap * stream[ 0].stats.sampling_rate only_too_long = False while getGaps(stream) and not only_too_long: too_long = 0 gaps = getGaps(stream) for gap in gaps: if int(gap[-1]) <= max_gap: try: stream[gap[0]] = stream[gap[0]].__add__( stream[gap[1]], method=1, fill_value="interpolate") stream.remove(stream[gap[1]]) except: stream.remove(stream[gap[1]]) break else: too_long += 1 if too_long == len(gaps): only_too_long = True stream = stream.split() for tr in stream: if tr.stats.sampling_rate < (params.goal_sampling_rate - 1): stream.remove(tr) taper_length = 20.0 # seconds for trace in stream: if trace.stats.npts < 4 * taper_length * trace.stats.sampling_rate: stream.remove(trace) else: trace.detrend(type="demean") trace.detrend(type="linear") trace.taper(max_percentage=None, max_length=1.0) if not len(stream): logging.debug(" has only too small traces, skipping...") continue for trace in stream: logging.debug("%s Highpass at %.2f Hz" % (trace.id, params.preprocess_highpass)) trace.filter("highpass", freq=params.preprocess_highpass, zerophase=True) if trace.stats.sampling_rate != params.goal_sampling_rate: logging.debug("%s Lowpass at %.2f Hz" % (trace.id, params.preprocess_lowpass)) trace.filter("lowpass", freq=params.preprocess_lowpass, zerophase=True, corners=8) if params.resampling_method == "Resample": logging.debug( "%s Downsample to %.1f Hz" % (trace.id, params.goal_sampling_rate)) trace.data = resample( trace.data, params.goal_sampling_rate / trace.stats.sampling_rate, 'sinc_fastest') elif params.resampling_method == "Decimate": decimation_factor = trace.stats.sampling_rate / params.goal_sampling_rate if not int(decimation_factor) == decimation_factor: logging.warning( "%s CANNOT be decimated by an integer factor, consider using Resample or Lanczos methods" " Trace sampling rate = %i ; Desired CC sampling rate = %i" % (trace.id, trace.stats.sampling_rate, params.goal_sampling_rate)) sys.stdout.flush() sys.exit() logging.debug("%s Decimate by a factor of %i" % (trace.id, decimation_factor)) trace.data = trace.data[::int(decimation_factor)] elif params.resampling_method == "Lanczos": logging.debug( "%s Downsample to %.1f Hz" % (trace.id, params.goal_sampling_rate)) trace.data = np.array(trace.data) trace.interpolate( method="lanczos", sampling_rate=params.goal_sampling_rate, a=1.0) trace.stats.sampling_rate = params.goal_sampling_rate if params.remove_response: logging.debug('%s Removing instrument response' % stream[0].id) response = responses[responses["channel_id"] == stream[0].id] if len(response) > 1: response = response[ response["start_date"] <= UTCDateTime(gd)] if len(response) > 1: response = response[ response["end_date"] >= UTCDateTime(gd)] elif len(response) == 0: logging.info("No instrument response information " "for %s, skipping" % stream[0].id) continue try: datalesspz = response["paz"].values[0] except: logging.error("Bad instrument response information " "for %s, skipping" % stream[0].id) continue stream.simulate( paz_remove=datalesspz, remove_sensitivity=True, pre_filt=params.response_prefilt, paz_simulate=None, ) for tr in stream: tr.data = tr.data.astype(np.float32) output += stream del stream del files clean_scipy_cache() return output
def _downsample_and_upsample(data): ds = numpy.array([resample(x, 0.5, 'sinc_best') for x in data[0]]) us = numpy.array([resample(x, 2, 'sinc_best') for x in ds]) return (us, )
def preprocess(db, stations, comps, goal_day, params, responses=None): datafiles = {} output = Stream() for station in stations: datafiles[station] = {} net, sta = station.split('.') gd = datetime.datetime.strptime(goal_day, '%Y-%m-%d') files = get_data_availability(db, net=net, sta=sta, starttime=gd, endtime=gd) for comp in comps: datafiles[station][comp] = [] for file in files: if file.comp[-1] not in comps: continue fullpath = os.path.join(file.path, file.file) datafiles[station][file.comp[-1]].append(fullpath) for istation, station in enumerate(stations): net, sta = station.split(".") for comp in comps: files = eval("datafiles['%s']['%s']" % (station, comp)) if len(files) != 0: logging.debug("%s.%s Reading %i Files" % (station, comp, len(files))) stream = Stream() for file in sorted(files): st = read(file, dytpe=np.float, starttime=UTCDateTime(gd), endtime=UTCDateTime(gd) + 86400) tmp = st.select(network=net, station=sta, component=comp) if not len(tmp): for tr in st: tr.stats.network = net st = st.select(network=net, station=sta, component=comp) else: st = tmp for tr in st: tr.data = tr.data.astype(np.float) stream += st del st stream.sort() stream.merge(method=1, interpolation_samples=3, fill_value=None) stream = stream.split() logging.debug("Checking sample alignment") for i, trace in enumerate(stream): stream[i] = check_and_phase_shift(trace) logging.debug("Checking Gaps") if len(getGaps(stream)) > 0: max_gap = 10 only_too_long = False while getGaps(stream) and not only_too_long: too_long = 0 gaps = getGaps(stream) for gap in gaps: if int(gap[-1]) <= max_gap: stream[gap[0]] = stream[gap[0]].__add__( stream[gap[1]], method=1, fill_value="interpolate") stream.remove(stream[gap[1]]) break else: too_long += 1 if too_long == len(gaps): only_too_long = True stream = stream.split() taper_length = 20.0 # seconds for trace in stream: if trace.stats.npts < 4 * taper_length * trace.stats.sampling_rate: stream.remove(trace) else: trace.detrend(type="demean") trace.detrend(type="linear") trace.taper(max_percentage=None, max_length=1.0) if not len(stream): logging.debug(" has only too small traces, skipping...") continue for trace in stream: logging.debug("%s.%s Highpass at %.2f Hz" % (station, comp, params.preprocess_highpass)) trace.filter("highpass", freq=params.preprocess_highpass, zerophase=True) if trace.stats.sampling_rate != params.goal_sampling_rate: logging.debug( "%s.%s Lowpass at %.2f Hz" % (station, comp, params.preprocess_lowpass)) trace.filter("lowpass", freq=params.preprocess_lowpass, zerophase=True, corners=8) if params.resampling_method == "Resample": logging.debug( "%s.%s Downsample to %.1f Hz" % (station, comp, params.goal_sampling_rate)) trace.data = resample( trace.data, params.goal_sampling_rate / trace.stats.sampling_rate, 'sinc_fastest') elif params.resampling_method == "Decimate": decimation_factor = trace.stats.sampling_rate / params.goal_sampling_rate if not int(decimation_factor) == decimation_factor: logging.warning( "%s.%s CANNOT be decimated by an integer factor, consider using Resample or Lanczos methods" " Trace sampling rate = %i ; Desired CC sampling rate = %i" % (station, comp, trace.stats.sampling_rate, params.goal_sampling_rate)) sys.stdout.flush() sys.exit() logging.debug("%s.%s Decimate by a factor of %i" % (station, comp, decimation_factor)) trace.data = trace.data[::int(decimation_factor)] elif params.resampling_method == "Lanczos": logging.debug( "%s.%s Downsample to %.1f Hz" % (station, comp, params.goal_sampling_rate)) trace.data = np.array(trace.data) trace.interpolate( method="lanczos", sampling_rate=params.goal_sampling_rate, a=1.0) trace.stats.sampling_rate = params.goal_sampling_rate if get_config(db, 'remove_response', isbool=True): logging.debug('%s Removing instrument response' % stream[0].id) response_prefilt = eval(get_config(db, 'response_prefilt')) response = responses[responses["channel_id"] == stream[0].id] if len(response) > 1: response = response[ response["start_date"] < UTCDateTime(gd)] response = response[ response["end_date"] > UTCDateTime(gd)] elif len(response) == 0: logging.info("No instrument response information " "for %s, exiting" % stream[0].id) sys.exit() datalesspz = response["paz"].values[0] stream.simulate( paz_remove=datalesspz, remove_sensitivity=True, pre_filt=response_prefilt, paz_simulate=None, ) for tr in stream: tr.data = tr.data.astype(np.float32) output += stream del stream del files clean_scipy_cache() return 0, output