def resample(s, up, down, axis=0, fc='nn', **kwargs): r""" Resample a signal from rate "down" to rate "up" Parameters ---------- s : array_like The data to be resampled. up : int The upsampling factor. down : int The downsampling factor. axis : int, optional The axis of `x` that is resampled. Default is 0. As : float (optional) Stopband attenuation in dB N : float (optional) Filter order (length of impulse response in samples) df : float (optional) Transition band width, normalized to Nyquist (fs/2) beta : float (optional) The beta parameter of the Kaiser window Returns ------- resampled_x : array The resampled array. Notes ----- The function keeps a global cache of filters, since they are determined entirely by up, down, fc, beta, and L. If a filter has previously been used it is looked up instead of being recomputed. """ # from design parameters, find the generative parameters N, beta, As = disambiguate_params(**kwargs) # check if a resampling filter with the chosen parameters already exists params = (up, down, fc, beta, N) if params in _precomputed_filters.keys(): # if so, use it. filt = _precomputed_filters[params] else: # if not, generate filter, store it, use it filt = compute_filt(up, down, fc, beta=beta, N=N) _precomputed_filters[params] = filt return sig.resample_poly(s, up, down, window=np.array(filt), axis=axis)
def resample_to_24000_hz(samples, input_rate): case = _24000_HZ_SPECIAL_CASES.get(float(input_rate)) if case is not None: # input rate is a special case for which we can resample # efficiently using a polyphase filter up, down, filter_ = case # print('Resampling from {} Hz to 24000 Hz...'.format(input_rate)) return signal.resample_poly(samples, up, down, window=filter_) else: return resampy.resample(samples, input_rate, 24000)
def _resample_nnresample2(s, up, down, beta=5.0, L=16001, axis=0): # type: (np.ndarray, float, float, float, int, int) -> np.ndarray """ Taken from https://github.com/jthiem/nnresample Resample a signal from rate "down" to rate "up" Parameters ---------- x : array_like The data to be resampled. up : int The upsampling factor. down : int The downsampling factor. beta : float Beta factor for Kaiser window. Determines tradeoff between stopband attenuation and transition band width L : int FIR filter order. Determines stopband attenuation. The higher the better, ath the cost of complexity. axis : int, optional The axis of `x` that is resampled. Default is 0. Returns ------- resampled_x : array The resampled array. Notes ----- The function keeps a global cache of filters, since they are determined entirely by up, down, beta, and L. If a filter has previously been used it is looked up instead of being recomputed. """ # check if a resampling filter with the chosen parameters already exists params = (up, down, beta, L) if params in _precomputed_filters.keys(): # if so, use it. filt = _precomputed_filters[params] else: # if not, generate filter, store it, use it filt = _nnresample_compute_filt(up, down, beta, L) _precomputed_filters[params] = filt return sig.resample_poly(s, up, down, window=np.array(filt), axis=axis)
def resample_poly(samples, input_rate, output_rate, N): # Ensure that `input_rate` and `output_rate` are integers, since `math.gcd` # rejects floats. input_rate = int(input_rate) output_rate = int(output_rate) gcd = math.gcd(input_rate, output_rate) up = output_rate / gcd down = input_rate / gcd # The following filter design code is from the `resample_poly` function # of `scipy.signal.signaltools`, but with the fixed factor of 10 in the # `half_len` calculation replaced by `N`. max_rate = max(up, down) f_c = 1. / max_rate # cutoff of FIR filter (rel. to Nyquist) half_len = N * max_rate # reasonable cutoff for our sinc-like function h = signal.firwin(2 * half_len + 1, f_c, window=('kaiser', 5.0)) return signal.resample_poly(samples, up, down, window=h)
def __init__(self, timeaxis, timecourse, padvalue=30.0, upsampleratio=100, doplot=False, debug=False, method='univariate'): self.upsampleratio = upsampleratio self.padvalue = padvalue self.initstep = timeaxis[1] - timeaxis[0] self.initstart = timeaxis[0] self.initend = timeaxis[-1] self.hiresstep = self.initstep / np.float64(self.upsampleratio) self.hires_x = np.arange(timeaxis[0] - self.padvalue, self.initstep * len(timeaxis) + self.padvalue, self.hiresstep) self.hiresstart = self.hires_x[0] self.hiresend = self.hires_x[-1] if method == 'poly': self.hires_y = 0.0 * self.hires_x self.hires_y[int(self.padvalue // self.hiresstep) + 1:-(int(self.padvalue // self.hiresstep) + 1)] = \ signal.resample_poly(timecourse, np.int(self.upsampleratio * 10), 10) elif method == 'fourier': self.hires_y = 0.0 * self.hires_x self.hires_y[int(self.padvalue // self.hiresstep) + 1:-(int(self.padvalue // self.hiresstep) + 1)] = \ signal.resample(timecourse, self.upsampleratio * len(timeaxis)) else: self.hires_y = doresample(timeaxis, timecourse, self.hires_x, method=method) self.hires_y[:int(self.padvalue // self.hiresstep)] = self.hires_y[int(self.padvalue // self.hiresstep)] self.hires_y[-int(self.padvalue // self.hiresstep):] = self.hires_y[-int(self.padvalue // self.hiresstep)] if debug: print('fastresampler __init__:') print(' padvalue:, ', self.padvalue) print(' initstep, hiresstep:', self.initstep, self.hiresstep) print(' initial axis limits:', self.initstart, self.initend) print(' hires axis limits:', self.hiresstart, self.hiresend) # self.hires_y[:int(self.padvalue // self.hiresstep)] = 0.0 # self.hires_y[-int(self.padvalue // self.hiresstep):] = 0.0 if doplot: fig = pl.figure() ax = fig.add_subplot(111) ax.set_title('fastresampler initial timecourses') pl.plot(timeaxis, timecourse, self.hires_x, self.hires_y) pl.legend(('input', 'hires')) pl.show()
def compute_irasa(sig, fs=None, f_range=(1, 30), hset=None, **spectrum_kwargs): """Separate the aperiodic and periodic components using the IRASA method. Parameters ---------- sig : 1d array Time series. fs : float The sampling frequency of sig. f_range : tuple or None Frequency range. hset : 1d array Resampling factors used in IRASA calculation. If not provided, defaults to values from 1.1 to 1.9 with an increment of 0.05. spectrum_kwargs : dict Optional keywords arguments that are passed to `compute_spectrum`. Returns ------- freqs : 1d array Frequency vector. psd_aperiodic : 1d array The aperiodic component of the power spectrum. psd_periodic : 1d array The periodic component of the power spectrum. Notes ----- Irregular-Resampling Auto-Spectral Analysis (IRASA) is described in Wen & Liu (2016). Briefly, it aims to separate 1/f and periodic components by resampling time series, and computing power spectra, effectively averaging away any activity that is frequency specific. References ---------- Wen, H., & Liu, Z. (2016). Separating Fractal and Oscillatory Components in the Power Spectrum of Neurophysiological Signal. Brain Topography, 29(1), 13–26. DOI: 10.1007/s10548-015-0448-0 """ # Check & get the resampling factors, with rounding to avoid floating point precision errors hset = np.arange(1.1, 1.95, 0.05) if not hset else hset hset = np.round(hset, 4) # The `nperseg` input needs to be set to lock in the size of the FFT's if 'nperseg' not in spectrum_kwargs: spectrum_kwargs['nperseg'] = int(4 * fs) # Calculate the original spectrum across the whole signal freqs, psd = compute_spectrum(sig, fs, **spectrum_kwargs) # Do the IRASA resampling procedure psds = np.zeros((len(hset), *psd.shape)) for ind, h_val in enumerate(hset): # Get the up-sampling / down-sampling (h, 1/h) factors as integers rat = fractions.Fraction(str(h_val)) up, dn = rat.numerator, rat.denominator # Resample signal sig_up = signal.resample_poly(sig, up, dn, axis=-1) sig_dn = signal.resample_poly(sig, dn, up, axis=-1) # Calculate the power spectrum using the same params as original freqs_up, psd_up = compute_spectrum(sig_up, h_val * fs, **spectrum_kwargs) freqs_dn, psd_dn = compute_spectrum(sig_dn, fs / h_val, **spectrum_kwargs) # Geometric mean of h and 1/h psds[ind, :] = np.sqrt(psd_up * psd_dn) # Now we take the median resampled spectra, as an estimate of the aperiodic component psd_aperiodic = np.median(psds, axis=0) # Subtract aperiodic from original, to get the periodic component psd_periodic = psd - psd_aperiodic # Restrict spectrum to requested range if f_range: psds = np.array([psd_aperiodic, psd_periodic]) freqs, (psd_aperiodic, psd_periodic) = trim_spectrum(freqs, psds, f_range) return freqs, psd_aperiodic, psd_periodic
def demo_rsHRF(input_file, mask_file, output_dir, para, p_jobs, file_type=".nii", mode="bids", wiener=False, temporal_mask=[]): # book-keeping w.r.t parameter values if 'localK' not in para or para['localK'] == None: if para['TR'] <= 2: para['localK'] = 1 else: para['localK'] = 2 # creating the output-directory if not already present if not os.path.isdir(output_dir): os.mkdir(output_dir) # for four-dimensional input if mode != 'time-series': if mode == 'bids' or mode == 'bids w/ atlas': name = input_file.split('/')[-1].split('.')[0] v1 = spm_dep.spm.spm_vol(input_file) else: name = input_file.split('/')[-1].split('.')[0] v1 = spm_dep.spm.spm_vol(input_file) if mask_file != None: if mode == 'bids': mask_name = mask_file.split('/')[-1].split('.')[0] v = spm_dep.spm.spm_vol(mask_file) else: mask_name = mask_file.split('/')[-1].split('.')[0] v = spm_dep.spm.spm_vol(mask_file) if file_type == ".nii" or file_type == ".nii.gz": brain = spm_dep.spm.spm_read_vols(v) else: brain = v.agg_data().flatten(order='F') if ((file_type == ".nii" or file_type == ".nii.gz") and \ v1.header.get_data_shape()[:-1] != v.header.get_data_shape()) or \ ((file_type == ".gii" or file_type == ".gii.gz") and \ v1.agg_data().shape[0]!= v.agg_data().shape[0]): raise ValueError('Inconsistency in input-mask dimensions' + '\n\tinput_file == ' + name + file_type + '\n\tmask_file == ' + mask_name + file_type) else: if file_type == ".nii" or file_type == ".nii.gz": data = v1.get_data() else: data = v1.agg_data() else: print('No atlas provided! Generating mask file...') if file_type == ".nii" or file_type == ".nii.gz": data = v1.get_data() brain = np.nanvar(data.reshape(-1, data.shape[3]), -1, ddof=0) else: data = v1.agg_data() brain = np.nanvar(data, -1, ddof=0) print('Done') voxel_ind = np.where(brain > 0)[0] mask_shape = data.shape[:-1] nobs = data.shape[-1] data1 = np.reshape(data, (-1, nobs), order='F').T bold_sig = stats.zscore(data1[:, voxel_ind], ddof=1) # for time-series input else: name = input_file.split('/')[-1].split('.')[0] data1 = (np.loadtxt(input_file, delimiter=",")) if data1.ndim == 1: data1 = np.expand_dims(data1, axis=1) nobs = data1.shape[0] bold_sig = stats.zscore(data1, ddof=1) if len(temporal_mask) > 0 and len(temporal_mask) != nobs: raise ValueError('Inconsistency in temporal_mask dimensions.\n' + 'Size of mask: ' + str(len(temporal_mask)) + '\n' + 'Size of time-series: ' + str(nobs)) bold_sig = np.nan_to_num(bold_sig) bold_sig_deconv = processing. \ rest_filter. \ rest_IdealFilter(bold_sig, para['TR'], para['passband_deconvolve']) bold_sig = processing. \ rest_filter. \ rest_IdealFilter(bold_sig, para['TR'], para['passband']) data_deconv = np.zeros(bold_sig.shape) event_number = np.zeros((1, bold_sig.shape[1])) print('Retrieving HRF ...') #Estimate HRF for the fourier / hanning / gamma / cannon basis functions if not (para['estimation'] == 'sFIR' or para['estimation'] == 'FIR'): bf = basis_functions.basis_functions.get_basis_function( bold_sig.shape, para) beta_hrf, event_bold = utils.hrf_estimation.compute_hrf(bold_sig, para, temporal_mask, p_jobs, bf=bf) hrfa = np.dot(bf, beta_hrf[np.arange(0, bf.shape[1]), :]) #Estimate HRF for FIR and sFIR else: para['T'] = 1 beta_hrf, event_bold = utils.hrf_estimation.compute_hrf( bold_sig, para, temporal_mask, p_jobs) hrfa = beta_hrf[:-1, :] nvar = hrfa.shape[1] PARA = np.zeros((3, nvar)) for voxel_id in range(nvar): hrf1 = hrfa[:, voxel_id] PARA[:, voxel_id] = \ parameters.wgr_get_parameters(hrf1, para['TR'] / para['T']) print('Done') print('Deconvolving HRF ...') if para['T'] > 1: hrfa_TR = signal.resample_poly(hrfa, 1, para['T']) else: hrfa_TR = hrfa for voxel_id in range(nvar): hrf = hrfa_TR[:, voxel_id] if not wiener: H = np.fft.fft(np.append(hrf, np.zeros( (nobs - max(hrf.shape), 1))), axis=0) M = np.fft.fft(bold_sig_deconv[:, voxel_id]) data_deconv[:, voxel_id] = \ np.fft.ifft(H.conj() * M / (H * H.conj() + .1*np.mean((H * H.conj())))) else: data_deconv[:, voxel_id] = iterative_wiener_deconv.rsHRF_iterative_wiener_deconv( bold_sig_deconv[:, voxel_id], hrf) event_number[:, voxel_id] = np.amax(event_bold[voxel_id].shape) print('Done') print('Saving Output ...') # setting the output-path if mode == 'bids' or mode == 'bids w/ atlas': layout_output = BIDSLayout(output_dir) entities = parse_file_entities(input_file) sub_save_dir = layout_output.build_path(entities).rsplit('/', 1)[0] else: sub_save_dir = output_dir if not os.path.isdir(sub_save_dir): os.makedirs(sub_save_dir, exist_ok=True) dic = {'para': para, 'hrfa': hrfa, 'event_bold': event_bold, 'PARA': PARA} ext = '_hrf.mat' if mode == "time-series": dic["event_number"] = event_number dic["data_deconv"] = data_deconv ext = '_hrf_deconv.mat' name = name.rsplit('_bold', 1)[0] sio.savemat(os.path.join(sub_save_dir, name + ext), dic) HRF_para_str = ['height', 'T2P', 'FWHM'] if mode != "time-series": mask_data = np.zeros(mask_shape).flatten(order='F') for i in range(3): fname = os.path.join(sub_save_dir, name + '_' + HRF_para_str[i]) mask_data[voxel_ind] = PARA[i, :] mask_data = mask_data.reshape(mask_shape, order='F') spm_dep.spm.spm_write_vol(v1, mask_data, fname, file_type) mask_data = mask_data.flatten(order='F') fname = os.path.join(sub_save_dir, name + '_eventnumber') mask_data[voxel_ind] = event_number mask_data = mask_data.reshape(mask_shape, order='F') spm_dep.spm.spm_write_vol(v1, mask_data, fname, file_type) mask_data = np.zeros(data.shape) dat3 = np.zeros(data.shape[:-1]).flatten(order='F') for i in range(nobs): fname = os.path.join(sub_save_dir, name + '_deconv') dat3[voxel_ind] = data_deconv[i, :] dat3 = dat3.reshape(data.shape[:-1], order='F') if file_type == ".nii" or file_type == ".nii.gz": mask_data[:, :, :, i] = dat3 else: mask_data[:, i] = dat3 dat3 = dat3.flatten(order='F') spm_dep.spm.spm_write_vol(v1, mask_data, fname, file_type) pos = 0 while pos < hrfa_TR.shape[1]: if np.any(hrfa_TR[:, pos]): break pos += 1 event_plot = lil_matrix((1, nobs)) if event_bold.size: event_plot[:, event_bold[pos]] = 1 else: print("No Events Detected!") return 0 event_plot = np.ravel(event_plot.toarray()) plt.figure() plt.plot(para['TR'] * np.arange(1, np.amax(hrfa_TR[:, pos].shape) + 1), hrfa_TR[:, pos], linewidth=1) plt.xlabel('time (s)') plt.savefig(os.path.join(sub_save_dir, name + '_hrf_plot.png')) plt.figure() plt.plot(para['TR'] * np.arange(1, nobs + 1), np.nan_to_num(stats.zscore(bold_sig[:, pos], ddof=1)), linewidth=1) plt.plot(para['TR'] * np.arange(1, nobs + 1), np.nan_to_num(stats.zscore(data_deconv[:, pos], ddof=1)), color='r', linewidth=1) markerline, stemlines, baseline = \ plt.stem(para['TR'] * np.arange(1, nobs + 1), event_plot) plt.setp(baseline, 'color', 'k', 'markersize', 1) plt.setp(stemlines, 'color', 'k') plt.setp(markerline, 'color', 'k', 'markersize', 3, 'marker', 'd') plt.legend(['BOLD', 'Deconvolved BOLD', 'Events'], loc='best') plt.xlabel('time (s)') plt.savefig(os.path.join(sub_save_dir, name + '_deconvolution_plot.png')) print('Done') return 0
parser.add_argument( '--not_requiem', action='store_false', help='use new waveform generator method from WORLD version 0.2.2') args = parser.parse_args() # load wav file wav_path = Path(args.inFILE) print('input wave path ', wav_path) fs, x_int16 = wavread(wav_path) x = x_int16 / (2**15 - 1) print('fs', fs) if 0: # resample fs_new = 16000 x = signal.resample_poly(x, fs_new, fs) fs = fs_new if 0: # low-cut B = signal.firwin(127, [0.01], pass_zero=False) A = np.array([1.0]) if 0: import matplotlib.pyplot as plt w, H = signal.freqz(B, A) fig, (ax1, ax2) = plt.subplots(2, figsize=(16, 6)) ax1.plot(w / np.pi, abs(H)) ax1.set_ylabel('magnitude') ax2.plot(w / np.pi, np.unwrap(np.angle(H))) ax2.set_ylabel('unwrapped phase') plt.show()
f = np.linspace(-Fs / 2.0, Fs / 2.0, len(psd)) plt.figure(5) plt.plot(f, psd) plt.show() # correct coarse frequency offset max_freq = f[np.argmax(psd)] Ts = 1 / Fs # sample period t = np.arange(0, Ts * len(samples), Ts) # create time vector # use -1j instead of 1j to subtract the frequency # divide by 2 due to the given frequency is twice as large as the actual offset samples = samples * np.exp(-1j * 2 * np.pi * max_freq * t / 2.0) # interpolation allows shifting by a fractional amount of samples InterpFactor = 16 samples_interpolated = signal.resample_poly(samples, InterpFactor, 1) plt.figure(6) plt.subplot(211) plt.plot(samples, '.-') plt.subplot(212) plt.plot(samples_interpolated, '.-') plt.show() # mueller-muller clock recovery pll with interpolation mu = 0 out = np.zeros(len(samples) + 10, dtype=np.complex) out_rail = np.zeros( len(samples) + 10, dtype=np.complex) # used to save 2 previous values plus current value i_in = 0 # input sample index i_out = 2 # output index; first two outputs are 0
def custom_resampling(self, audio): audio = signal.resample_poly( audio, 1, self.sampling_rate // self.resampling_rate) audio = tf.convert_to_tensor(audio, dtype=tf.float32) return audio
def read_delsys(fname, fname2='', sensors=None, freq_trc=150, emg=True, imu=False, resample=[1200, 150], freqs=[20, 20, 450], show_msg=True, show=False, ax=None, suptitle=''): """Read Delsys csv file from Cortex MAC (Asynchronous device data file). Parameters ---------- fname : string Full file name of the Delsys csv file from Cortex file to be opened. fname2 : string, optional (default = '') Full file name of the text file to be saved with data if desired. If both parameters `emg` and `imu` are True, you must input a list with the two full file names (EMG and IMU). If fname2 is '', no file is saved. If fname2 is '=', the original file name will be used but its extension will be .emg and .imu for the files with EMG data and with IMU data (if parameters `emg` and `imu` are True). sensors : list of strings, optional Names of the sensors to be used as column names for the EMG and IM data. freq_trc : number, optional (default = 150) Sampling frequency of the markers data emg : bool, optional (default = True) Read and save EMG data imu : bool, optional (default = False) Read and save IMU data resample : list with two numbers, optional (default = [1200, 150]) Whether to resample the data to have the given frequencies. The list order is [freq_emg, freq_imu]. Enter 0 (zero) to not resample. It's used signal.resample_poly scipy function. For the EMG signal, if the parameter frequency is lower than 1000 Hz, first it will be calculated the linear envelope with a low-pass frequency given by parameter freqs[0] (but first the EMG data will be band-pass filtered with frequencies given by parameters freqs[1], freqs[2]. freqs : list of three numbers, optional (default = [20, 20, 450]) Frequencies to be used at the linear envelope calculation if desired. See the parameter `resample`. show_msg : bool, optional (default = True) Whether to print messages about the execution of the intermediary steps (True) or not (False). show : bool, optional (default = False) if True (1), plot data in matplotlib figure. ax : a matplotlib.axes.Axes instance, optional (default = None). suptitle : string, optional (default = '') If string, shows string as suptitle. If empty, doesn't show suptitle. Returns ------- data : 1 or 2 pandas dataframe df_emg and df_imu if paramters `emg` and `imu`. The units of df_emg will be mV (the raw signal is multiplied by 1000). The units of the IMU data are according to Delsys specification. """ with open(file=fname, mode='rt', newline=None) as f: if show_msg: print('Opening file "{}" ... '.format(fname), end='') file = f.read().splitlines() if file[0] != 'Cortex generated Asynchronous device data file (.add)': print( '\n"{}" is not a valid Delsys from Cortex file.'.format(fname)) if emg and imu: return None, None elif emg: return None elif imu: return None # find start and final lines of data in file idx = file.index('[Devices]') + 2 count = int(file[idx].split('=')[1]) devices = [ name.split(', ')[-1] for name in file[idx + 1:idx + 1 + count] ] if sensors is None: sensors = devices idx = idx + 3 + count count2 = int(file[idx].split('=')[1]) channels = [name for name in file[idx + 1:idx + 1 + count2]] n_im = int((count2 - count) / count) # indexes for ini_emg, end_emg, ini_im, end_im idxs = np.zeros((count, 4), dtype=int) for i, device in enumerate(devices): idxs[i, 0] = file.index(device) + 3 idxs[i, 1] = file[idxs[i, 0]:].index('') + idxs[i, 0] - 1 idxs[:, 2] = idxs[:, 1] + 3 idxs[:, 3] = np.r_[idxs[1:, 0] - 6, np.array(len(file) - 3, dtype=int, ndmin=1)] # read emg data if emg: nrows_emg = int(np.min(idxs[:, 1] - idxs[:, 0]) + 1) f.seek(0) t_emg = pd.read_csv(f, sep=',', header=None, names=None, index_col=None, usecols=[2], skiprows=idxs[0, 0], nrows=nrows_emg, squeeze=True, dtype=np.float32, encoding='utf-8', engine='c').values # the above is faster than simply: # np.array([x.split(',')[2] for x in file[idxs[0, 0]:idxs[0, 1]+1]], dtype=np.float32) # and faster than: # np.loadtxt(f, dtype=np.float32, comments=None, delimiter=',', skiprows=idxs[0, 0], usecols=2, max_rows=nrows_emg) freq_emg = np.mean(freq_trc / np.diff(t_emg)) if resample[0]: fr = Fraction(resample[0] / freq_emg).limit_denominator(1000) nrows_emg = int( np.ceil(nrows_emg * fr.numerator / fr.denominator)) freq_emg2 = resample[0] else: freq_emg2 = freq_emg ys = np.empty((nrows_emg, count), dtype=np.float32) for i, sensor in enumerate(sensors): f.seek(0) y = pd.read_csv(f, sep=',', header=None, names=[sensor], index_col=None, usecols=[3], skiprows=idxs[i, 0], nrows=len(t_emg), squeeze=True, dtype=np.float32, encoding='utf-8', engine='c').values if resample[0]: if resample[0] < 1000: y = linear_envelope(y, freq_emg, fc_bp=[freqs[1], freqs[2]], fc_lp=freqs[0], method='rms') y = signal.resample_poly(y, fr.numerator, fr.denominator) ys[:, i] = y * 1000 df_emg = pd.DataFrame(data=ys, columns=sensors) df_emg.index = df_emg.index / freq_emg2 df_emg.index.name = 'Time' # read IM data if imu: nrows_imu = int(np.min(idxs[:, 3] - idxs[:, 2]) + 1) cols = [ sensor + channel.split(',')[3] for sensor in sensors for channel in channels[1:int(count2 / count)] ] f.seek(0) t_imu = pd.read_csv(f, sep=',', header=None, names=None, index_col=None, usecols=[2], skiprows=idxs[0, 2], nrows=nrows_imu, squeeze=True, dtype=np.float32, encoding='utf-8', engine='c').values freq_imu = np.mean(freq_trc / np.diff(t_imu)) if resample[1]: fr = Fraction(resample[1] / freq_imu).limit_denominator(1000) nrows_imu = int( np.ceil(nrows_imu * fr.numerator / fr.denominator)) freq_imu = resample[1] ys = np.empty((nrows_imu, count2 - count), dtype=np.float32) for i, sensor in enumerate(sensors): f.seek(0) cs = slice(int(n_im * i), int((n_im * (i + 1)))) y = pd.read_csv(f, sep=',', header=None, names=cols[cs], index_col=None, usecols=range(3, 12), skiprows=idxs[i, 2], nrows=len(t_imu), squeeze=False, dtype=np.float32, encoding='utf-8', engine='c').values if resample[1]: y2 = np.empty((nrows_imu, y.shape[1]), dtype=np.float32) for c in range(y.shape[1]): y2[:, c] = signal.resample_poly(y[:, c], fr.numerator, fr.denominator) else: y2 = y ys[:, cs] = y2 df_imu = pd.DataFrame(data=ys, columns=cols) df_imu.index = df_imu.index / freq_imu df_imu.index.name = 'Time' if show_msg: print('done.') # save file if len(fname2): if isinstance(fname2, list): fname2_emg = fname2[0] fname2_imu = fname2[1] else: if emg: fname2_emg = fname2 if imu: fname2_imu = fname2 if emg and fname2_emg == '=': name, extension = os.path.splitext(fname) fname2_emg = name + '.emg' if imu and fname2_imu == '=': name, extension = os.path.splitext(fname) fname2_imu = name + '.imu' if emg: df_emg.to_csv(fname2_emg, sep='\t', float_format='%.6f') if show_msg: print('Saving file "{}" ... '.format(fname2_emg), end='') if imu: df_imu.to_csv(fname2_imu, sep='\t', float_format='%.6f') if show_msg: print('\nSaving file "{}" ... '.format(fname2_imu), end='') if show_msg: print('done.') if show and emg: _plot_df_emg(df_emg, ax=None, suptitle=suptitle) if emg and imu: return df_emg, df_imu elif emg: return df_emg elif imu: return df_imu
def compute_unit_template_features(recording, sorting, unit_ids=None, channel_ids=None, feature_names=None, max_channels_per_features=1, recovery_slope_window=0.7, upsampling_factor=1, invert_waveforms=False, as_dataframe=False, **kwargs): """ Use SpikeInterface/spikefeatures to compute features for the unit template. These consist of a set of 1D features: - peak to valley (peak_to_valley), time between peak and valley - halfwidth (halfwidth), width of peak at half its amplitude - peak trough ratio (peak_trough_ratio), amplitude of peak over amplitude of trough - repolarization slope (repolarization_slope), slope between trough and return to base - recovery slope (recovery_slope), slope after peak towards baseline And 2D features: - unit_spread - propagation velocity To be implemented The metrics are computed on 'negative' waveforms, if templates are saved as positive, pass keyword 'invert_waveforms'. Parameters ---------- recording: RecordingExtractor The recording extractor sorting: SortingExtractor The sorting extractor unit_ids: list List of unit ids to compute features channel_ids: list List of channels ids to compute templates on which features are computed feature_names: list List of feature names to be computed. If None, all features are computed max_channels_per_features: int Maximum number of channels to compute features on (default 1). If channel_ids is used, this parameter is ignored upsampling_factor: int Factor with which to upsample the template resolution (default 1) invert_waveforms: bool Invert templates before computing features (default False) recovery_slope_window: float Window after peak in ms wherein to compute recovery slope (default 0.7) as_dataframe: bool IfTrue, output is returned as a pandas dataframe, otherwise as a dictionary **kwargs: Keyword arguments A dictionary with default values can be retrieved with: st.postprocessing.get_waveforms_params(): grouping_property: str Property to group channels. E.g. if the recording extractor has the 'group' property and 'grouping_property' is 'group', then waveforms are computed group-wise. ms_before: float Time period in ms to cut waveforms before the spike events ms_after: float Time period in ms to cut waveforms after the spike events dtype: dtype The numpy dtype of the waveforms compute_property_from_recording: bool If True and 'grouping_property' is given, the property of each unit is assigned as the corresponding property of the recording extractor channel on which the average waveform is the largest max_channels_per_waveforms: int or None Maximum channels per waveforms to return. If None, all channels are returned n_jobs: int Number of parallel jobs (default 1) max_spikes_per_unit: int The maximum number of spikes to extract per unit memmap: bool If True, waveforms are saved as memmap object (recommended for long recordings with many channels) seed: int Random seed for extracting random waveforms save_property_or_features: bool If True (default), waveforms are saved as features of the sorting extractor object recompute_info: bool If True, waveforms are recomputed (default False) verbose: bool If True output is verbose Returns ------- features: dict or pandas.DataFrame The computed features as a dictionary or a pandas.DataFrame (if as_dataframe is True) """ # ------------------- SETUP ------------------------------ if isinstance(unit_ids, (int, np.integer)): unit_ids = [unit_ids] elif unit_ids is None: unit_ids = sorting.get_unit_ids() elif not isinstance(unit_ids, (list, np.ndarray)): raise Exception("unit_ids is is invalid") if isinstance(channel_ids, (int, np.integer)): channel_ids = [channel_ids] if channel_ids is None: channel_ids = recording.get_channel_ids() assert np.all([u in sorting.get_unit_ids() for u in unit_ids]), "Invalid unit_ids" assert np.all([ch in recording.get_channel_ids() for ch in channel_ids]), "Invalid channel_ids" params_dict = update_all_param_dicts_with_kwargs(kwargs) save_property_or_features = params_dict['save_property_or_features'] if feature_names is None: feature_names = sf.all_1D_features else: bad_features = [] for m in feature_names: if m not in sf.all_1D_features: bad_features.append(m) if len(bad_features) > 0: raise ValueError(f"Improper feature names: {str(bad_features)}. The following features names can be " f"calculated: {str(sf.all_1D_features)}") templates = np.array(get_unit_templates(recording, sorting, unit_ids=unit_ids, channel_ids=channel_ids, mode='median', **kwargs)) # -------------------- PROCESS TEMPLATES ----------------------------- if upsampling_factor > 1: upsampling_factor = int(upsampling_factor) processed_templates = resample_poly(templates, up=upsampling_factor, down=1, axis=2) resampled_fs = recording.get_sampling_frequency() * upsampling_factor else: processed_templates = templates resampled_fs = recording.get_sampling_frequency() if invert_waveforms: processed_templates = -processed_templates features_dict = dict() for feat in feature_names: features_dict[feat] = [] # --------------------- COMPUTE FEATURES ------------------------------ for unit_id, unit in enumerate(unit_ids): template = processed_templates[unit_id] max_channel_idxs = select_max_channels_from_templates(template, recording, max_channels_per_features) template_channels = template[max_channel_idxs] if len(template_channels.shape) == 1: template_channels = template_channels[np.newaxis, :] feat_list = sf.calculate_features(waveforms=template_channels, sampling_frequency=resampled_fs, feature_names=feature_names, recovery_slope_window=recovery_slope_window) for feat, feat_val in feat_list.items(): features_dict[feat].append(feat_val) # ---------------------- DEAL WITH OUTPUT ------------------------- if save_property_or_features: for feat_name, feat_val in features_dict.items(): sorting.set_units_property(unit_ids=unit_ids, property_name=feat_name, values=feat_val) if as_dataframe: features = pandas.DataFrame.from_dict(features_dict) features = features.rename(index={original_idx: unit_ids[i] for i, original_idx in enumerate(range(len(features)))}) else: features = features_dict return features
def cool_distributed_cpgs(mode): """ main function to manipulate neurons/synapses in distributed recurrent networks loads previously fitted output weights computes correlation between neural trajectories as a similarity measure :return: nothing """ # load output weights out_dir = '/Users/robert/project_src/cooling/single_cpg_manipulation' weight_suffix1 = 'outunit1_parallel_weights_force.npy' weight_suffix2 = 'outunit2_parallel_weights_force.npy' weight_suffix3 = 'Wrec1_parallel_weights_force.npy' weight_suffix4 = 'Wrec2_parallel_weights_force.npy' Wout1 = np.load(os.path.join(out_dir, weight_suffix1)) Wout2 = np.load(os.path.join(out_dir, weight_suffix2)) Wrec1 = np.load(os.path.join(out_dir, weight_suffix3)) Wrec2 = np.load(os.path.join(out_dir, weight_suffix4)) # create network with same parameters t_max = 2000.0 dt = 1.0 nw1 = rn.Network(N=800, g=1.5, pc=1.0) nw1.Wrec = Wrec1 nw2 = rn.Network(N=800, g=1.5, pc=1.0, seed=5432) nw2.Wrec = Wrec2 def ext_inp(t): return np.zeros(nw1.N) # run dynamics at reference temperature and compute neural/behavioral trajectory ref_t1, ref_rates1 = nw1.simulate_network(T=t_max, dt=dt, external_input=ext_inp) ref_t2, ref_rates2 = nw2.simulate_network(T=t_max, dt=dt, external_input=ext_inp) neuron_out1 = np.dot(Wout1, ref_rates1) neuron_out2 = np.dot(Wout2, ref_rates2) ref_behavior = np.array([neuron_out1, neuron_out2]) fig1 = plt.figure(1) ax1 = fig1.add_subplot(1, 1, 1) ax1.plot(neuron_out1, neuron_out2, 'k', linewidth=0.5, label='ref') # run dynamics at different temperatures using some Q10 for tau # and compute neural/behavioral trajectories if mode == 'sweep': dT_steps = [-0.2, -0.5, -1.0, -1.5, -2.0, -2.5, -3.0, -3.5, -4.0, -4.5, -5.0] elif mode == 'vis': dT_steps = [-1.0, -3.0, -5.0] # dT_steps = [-0.5, -1.0, -2.0] cooled_behaviors = [] for i, dT in enumerate(dT_steps): cooled_q = _q(dT) cooled_nw = rn.Network(N=800, g=1.5, pc=1.0, q=cooled_q) cooled_nw.Wrec = Wrec1 cooled_t, cooled_rates = cooled_nw.simulate_network(T=t_max/cooled_q, dt=dt, external_input=ext_inp) cooled_behavior = np.dot(Wout1, cooled_rates) target_length = len(ref_behavior[1]) original_length = len(cooled_behavior) cooled_behavior_resampled = resample_poly(cooled_behavior, target_length, original_length) cooled_behaviors.append(np.array([cooled_behavior_resampled, ref_behavior[1]])) label_str = 'dT = %.1f' % dT ax1.plot(cooled_behavior_resampled, ref_behavior[1], linewidth=0.5, label=label_str) ax1.legend() ax1.set_xlabel('Output (a.u.)') # measure similarity of neural/behavioral trajectories as a function of temperature behavior_similarities = [] for i in range(len(dT_steps)): similarity = rn.measure_trajectory_similarity(ref_behavior, cooled_behaviors[i]) behavior_similarities.append(similarity) fig2 = plt.figure(2) ax2 = fig2.add_subplot(1, 1, 1) ax2.plot(dT_steps, behavior_similarities, 'ro-', label='behavior') ax2.set_xlim(ax2.get_xlim()[::-1]) ax2.set_xlabel('Temperature change') ax2.set_ylabel('Corr. coeff.') ax2.legend() plt.show()
def signal_envelope(signal, srate, cutoff=20., method='hilbert', comp_factor=1. / 3, resample=125, rescale=True): """Compute the broadband envelope of the input signal. Several methods are available: - Hilbert -> abs -> low-pass (-> resample) - Rectify -> low-pass (-> resample) - subenvelopes -> sum The envelope can also be compressed by raising to a certain power factor. Parameters ---------- signal : ndarray (nsamples,) 1-dimensional input signal srate : float Original sampling rate of the signal cutoff : float (default 20Hz) Cutoff frequency (transition will be 10 Hz) In Hz method : str {'hilbert', 'rectify', 'subs'} Method to be used comp_factor : float (default 1/3) Compression factor (final envelope = env**comp_factor) resample : float (default 125Hz) New sampling rate of envelope (must be 2*cutoff < .. <= srate) Explicitly set to False or None to skip resampling Returns ------- env : ndarray (nsamples_env,) Envelope """ print("Computing envelope...") if method.lower() == 'subs': raise NotImplementedError else: if method.lower() == 'hilbert': # Get modulus of hilbert transform out = abs(scisig.hilbert(signal)) elif method.lower() == 'rectify': # Rectify signal out = abs(signal) else: raise ValueError( "Method can only be 'hilbert', 'rectify' or 'subs'.") # Non linear compression before filtering to avoid NaN out = np.power(out + np.finfo(float).eps, comp_factor) # Design low-pass filter ntaps = fir_order( 10, srate, ripples=1e-3) # + 1 -> using odd ntaps for Type I filter, # so I have an integer group delay (instead of half) b = scisig.firwin(ntaps, cutoff, fs=srate) # Filter with convolution out = scisig.convolve(np.pad(out, (len(b) // 2, len(b) // 2), mode='edge'), b, mode='valid') #out = scisig.filtfilt(b, [1.0], signal) # This attenuates twice as much #out = scisig.lfilter(b, [1.0], pad(signal, (0, len(b)//2), mode=edge))[len(b)//2:] # slower than scipy.signal.convolve method # Resample if resample: if not 2 * cutoff < resample < srate: raise ValueError( "Chose resampling rate more carefully, must be > %.1f Hz" % (cutoff)) if srate // resample == srate / resample: env = scisig.resample_poly(out, 1, srate // resample) else: dur = (len(signal) - 1) / srate new_n = int(np.ceil(resample * dur)) env = scisig.resample(out, new_n) # Scale output between 0 and 1: if rescale: return minmax_scale(env) else: return env
def create_stream(EEG_data, sampling_rate, compressionbit=True, hashbit=True, check_quality=True): warnings.warn( 'You are using version 1 of CFS, CFS version 1 is deprecated and will not be supported by Z3Score in the future.', RuntimeWarning) SRATE = 100 #Hz LOWPASS = 45.0 #Hz HIGHPASS = 0.3 #Hz LOWPASSEOG = 12.0 #Hz Fs = sampling_rate / 2.0 one = np.array(1) bEEG = firwin(51, [HIGHPASS / Fs, LOWPASS / Fs], pass_zero=False, window='hamming', scale=True) bEOG = firwin(51, [HIGHPASS / Fs, LOWPASSEOG / Fs], pass_zero=False, window='hamming', scale=True) eogL = lfilter(bEOG, one, EEG_data[2, :]) eogR = lfilter(bEOG, one, EEG_data[3, :]) eeg = (lfilter(bEEG, one, EEG_data[0, :]) + lfilter(bEEG, one, EEG_data[1, :])) / 2.0 if sampling_rate != 100: P = 100 Q = sampling_rate eogL = resample_poly(eogL, P, Q) eogR = resample_poly(eogR, P, Q) eeg = resample_poly(eeg, P, Q) totalEpochs = int(len(eogL) / 30.0 / SRATE) data_length = 32 * 32 * 3 * totalEpochs mean_power = np.empty((3, totalEpochs)) data = np.empty([data_length], dtype=np.float32) window = np.hamming(128) epochSize = 32 * 32 * 3 #STFT based spectrogram computation for i in range(totalEpochs): for j in range(0, 3000 - 128 - 1, 90): tIDX = int(j / 90) frame1 = abs( np.fft.fft(eeg[i * 3000 + j:i * 3000 + j + 128] * window)) frame2 = abs( np.fft.fft(eogL[i * 3000 + j:i * 3000 + j + 128] * window)) frame3 = abs( np.fft.fft(eogR[i * 3000 + j:i * 3000 + j + 128] * window)) mean_power[:, i] = [ np.mean(frame1), np.mean(frame2), np.mean(frame3) ] data[i * epochSize + tIDX * 32:i * epochSize + tIDX * 32 + 32] = frame1[0:32] data[i * epochSize + 32 * 32 + tIDX * 32:i * epochSize + 32 * 32 + tIDX * 32 + 32] = frame2[0:32] data[i * epochSize + 32 * 32 * 2 + tIDX * 32:i * epochSize + 32 * 32 * 2 + tIDX * 32 + 32] = frame3[0:32] quality = np.sum(mean_power > 800, 1) * 100 / totalEpochs if np.any(quality > 10) and check_quality: print( "Warning: Electrode Falloff detected, use qc_cfs function to check which channel is problematic" ) signature = bytearray( struct.pack('<3sBBBBh??', b'CFS', 1, 32, 32, 3, totalEpochs, compressionbit, hashbit)) data = data.tostring() raw_digest = [] if hashbit: shaHash = hashlib.sha1() shaHash.update(data) raw_digest = shaHash.digest() if compressionbit: data = zlib.compress(data) if hashbit: stream = signature + raw_digest + data else: stream = signature + data return stream
def create_stream_v2(C3, C4, EOGL, EOGR, EMG, sampling_rates, compressionbit=True, hashbit=True, check_quality=True): SRATE = 100 # Hz LOWPASS = 35.0 # Hz HIGHPASS = 0.3 # Hz LOWPASSEOG = 35.0 # Hz LOWPASSEMG = 80.0 # Hz channels = 5 # 2EEG 2EOG 1EMG if (sampling_rates[0] < 100 or sampling_rates[1] < 100 or sampling_rates[2] < 200): raise RuntimeError("Sampling rate too low.") Fs_EEG = sampling_rates[0] / 2.0 Fs_EOG = sampling_rates[1] / 2.0 Fs_EMG = sampling_rates[2] / 2.0 one = np.array(1) bEEG = firwin(51, [HIGHPASS / Fs_EEG, LOWPASS / Fs_EEG], pass_zero=False, window='hamming', scale=True) bEOG = firwin(51, [HIGHPASS / Fs_EOG, LOWPASSEOG / Fs_EOG], pass_zero=False, window='hamming', scale=True) bEMG = firwin(51, [HIGHPASS / Fs_EMG, LOWPASSEMG / Fs_EMG], pass_zero=False, window='hamming', scale=True) eogL = lfilter(bEOG, one, EOGL) eogR = lfilter(bEOG, one, EOGR) eeg = (lfilter(bEEG, one, C3) + lfilter(bEEG, one, C4)) / 2.0 emg = lfilter(bEMG, one, EMG) if sampling_rates[0] != 100: P = 100 Q = sampling_rates[0] eeg = resample_poly(eeg, P, Q) if sampling_rates[1] != 100: P = 100 Q = sampling_rates[1] eogL = resample_poly(eogL, P, Q) eogR = resample_poly(eogR, P, Q) if sampling_rates[2] != 200: P = 200 Q = sampling_rates[2] emg = resample_poly(emg, P, Q) totalEpochs = int(len(eogL) / 30.0 / SRATE) data_length = 32 * 32 * (channels - 1) * totalEpochs data = np.empty([data_length], dtype=np.float32) window_eog = np.hamming(128) window_eeg = np.hamming(128) window_emg = np.hamming(256) epochSize = 32 * 32 * (channels - 1) data_frame = np.empty([32, 32, channels - 1]) mean_power = np.empty([channels - 1, totalEpochs]) # spectrogram computation for i in range(totalEpochs): frame1 = stft(eeg[i * 3000:(i + 1) * 3000], window=window_eeg, noverlap=36, boundary=None, nperseg=128, return_onesided=True, padded=False) frame2 = stft(eogL[i * 3000:(i + 1) * 3000], window=window_eog, noverlap=36, boundary=None, nperseg=128, return_onesided=True, padded=False) frame3 = stft(eogR[i * 3000:(i + 1) * 3000], window=window_eog, noverlap=36, boundary=None, nperseg=128, return_onesided=True, padded=False) frame4 = stft(emg[i * 6000:(i + 1) * 6000], window=window_emg, noverlap=71, boundary=None, nperseg=256, return_onesided=True, padded=False) data_frame[:, :, 0] = abs(frame1[2][1:33, 0:32]) * np.sum(window_eeg) # EEG data_frame[:, :, 1] = abs(frame2[2][1:33, 0:32]) * np.sum( window_eog) # EOG-L data_frame[:, :, 2] = abs(frame3[2][1:33, 0:32]) * np.sum( window_eog) # EOG-R data_frame[:, :, 3] = block_reduce( abs(frame4[2][1:129, :]) * np.sum(window_emg), (4, 1), np.mean) # EMG mean_power[:, i] = np.mean(data_frame, (0, 1)) data[i * epochSize:(i + 1) * epochSize] = np.reshape(data_frame, epochSize, order='F') quality = np.sum(mean_power > 800, 1) * 100 / totalEpochs if np.any(quality > 10) and check_quality: print( "Warning: Electrode Falloff detected, use qc_cfs function to check which channel is problematic" ) signature = bytearray( struct.pack('<3sBBBBh??', b'CFS', 2, 32, 32, (channels - 1), totalEpochs, compressionbit, hashbit)) data = data.tostring() raw_digest = [] if hashbit: shaHash = hashlib.sha1() shaHash.update(data) raw_digest = shaHash.digest() if compressionbit: data = zlib.compress(data) if hashbit: stream = signature + raw_digest + data else: stream = signature + data return stream
maxi = np.max(i) maxq = np.max(q) print("Samples " + str(len(i))) [i_filt, W, h] = LPF(i, fc, Fs) [q_filt, W, h] = LPF(q, fc, Fs) plt.plot(i, '.-') plt.plot(q, '.-') plt.grid() plt.show() samples_i = sig.resample_poly(i_filt, 4, 1) samples_q = sig.resample_poly(q_filt, 4, 1) si = samples_i[154::32] sq = samples_q[154::32] """ for o in range(32): plt.plot(samples_i[o+150::32], samples_q[o+150::32], '.') """ plt.plot(si, sq, '.') plt.show()
def pdm_to_pcm(input_file, out_file, pdm_sample_rate, pcm_sample_rate, desired_max_abs, preserve_all_channels=False, verbose=False, apply_recording_conditioning=False): if verbose: print("PDM -> PCM") binary_file = open(input_file, "rb") if verbose: print('File length: ' + str(os.stat(input_file).st_size) + ' bytes') # Read the whole file at once input_data = bytearray(binary_file.read()) nsamples = len(input_data) input_data = np.unpackbits(input_data) multi_channel_pdm = np.reshape(input_data, (len(input_data) // 8, -1)).T non_zero_channel = [] if not preserve_all_channels: for ch in range(8): if sum(multi_channel_pdm[ch]) != 0: non_zero_channel.append(ch) if verbose: print('Keeping channel ' + str(ch)) else: for ch in range(8): non_zero_channel.append(ch) if verbose: print('Keeping channel ' + str(ch)) nchannels = len(non_zero_channel) upsample_ratio , downsample_ratio = up_down_ratio(pdm_sample_rate, pcm_sample_rate) seconds = np.round(float(nsamples) / float(pdm_sample_rate), 3) if verbose: print("Number of sample: " + str(nsamples) + ' ~ ' + str(seconds) + ' seconds.') print("Input rate: " + str(pdm_sample_rate) + 'Hz') print("Output rate: " + str(pcm_sample_rate) + 'Hz') print("Channel count: " + str(nchannels)) print("Upsample ratio: " + str(upsample_ratio)) print("Downsample ratio: " + str(downsample_ratio)) pcm = np.zeros((nchannels, (nsamples*upsample_ratio // downsample_ratio)), dtype=np.float64) factors = get_prime_factors(downsample_ratio) factors = np.flipud(factors) for ch in range(nchannels): if verbose: print('processing channel ' + str(ch)) pdm_ch = non_zero_channel[ch] pdm = np.zeros(nsamples, dtype=np.float64) pdm = multi_channel_pdm[pdm_ch]*2.0 pdm -= np.ones(len(multi_channel_pdm[ch])) # TODO do this in chunks to save memory if upsample_ratio != 1: t = signal.resample_poly(pdm, upsample_ratio, 1) else: t = pdm for f in factors: t = decimate(t, f, zero_phase = True, n = 21) pcm[ch] = t[:len(pcm[ch] )] if apply_recording_conditioning: # high pass filter to removed everything below 30Hz b, a = butter_highpass(30., pcm_sample_rate, order=5) for ch in range(nchannels): pcm[ch] = signal.filtfilt(b, a, pcm[ch], padlen = 1000, padtype='even') pcm[ch][0] = 0.0 # Scale the output to the requested level m = np.amax(pcm) # make it full scale pcm /= m pcm *= desired_max_abs scipy.io.wavfile.write(out_file, pcm_sample_rate, pcm.T) return
#phase corrections phase_cor = [] for ph_ga, ph_cc in zip(harmonics_phase_ga, harmonics_phase_cc): phase_cor.append(ph_cc/ph_ga) #resampled spectrum upsample_factor = int(round(ff_cc)) downsample_factor = int(round(ff_ga)) new_fs = frequency_ratio*fs_cc up_fs = upsample_factor*fs_cc #gcd_fs = fs_cc*upsample_factor//gcd(upsample_factor, downsample_factor) ff_max = max(int(round(ff_cc)),int(round(ff_ga))) cutoff_frequency = up_fs/(2*ff_max) cutoff_frequency_n = cutoff_frequency*2/(up_fs) fir_filter = firwin(240,cutoff_frequency_n,window='hamming') wav_ga_resampled = resample_poly(wav_ga,int(round(ff_cc)),int(round(ff_ga)),window=fir_filter) #hamming_3 = windows.hamming(wav_ga_resampled.size) #wav_ga_resampled = wav_ga_resampled*hamming_3 y_res = fft(wav_ga_resampled) freq_res = fftfreq(y_res.size,1/new_fs) new_bins = [int((freq * y_res.size)/new_fs) for freq in frequencies_cc] #plt.figure(2) #w,h = freqz(fir_filter, fs=up_fs) #plt.plot(w[:10],abs(h[:10])) #print(fir_filter) #harmonics mapping and filtering #print(y_res.size,y_cc.size) synthesis_spectrum = np.zeros(y_cc.size,dtype=complex) #for i in range(len(bins)-1) : #if synthesis_spectrum[bins[i]:bins[i+1]].shape==y_res[int(frequencies_cc[1:][i]):int(frequencies_cc[1:][i])].shape: #synthesis_spectrum[bins[i]:bins[i+1]] = y_res[bins[i]+freq_shifts[i]:bins[i+1]+freq_shifts[i+1]]#*gains[i]*exp(1j*phase_cor[i])
plt.close('all') #%% parameters numBits = 1000 fs = 1000 f = 200 upsqrt = 2 up = upsqrt**2 down = 1 #%% initialization bits = np.random.randint(0,4,numBits) qpskSyms = np.exp(1j*bits*2*np.pi/4) rx = sps.resample_poly(qpskSyms, up, down) #%% checks plt.figure('Spectrum') plt.plot(20*np.log10(sp.fft.fftshift(np.abs(sp.fft.fft(rx))))) plt.figure('Symbols, Original') plt.plot(np.real(qpskSyms), np.imag(qpskSyms), 'r.') plt.figure('Symbols, Received') plt.plot(np.real(rx), np.imag(rx), 'r.') plt.figure('Symbols, Absolute Rx') plt.plot(np.abs(rx))
def preprocUS(data, t, xd): """Analog time-gain compensation is typically applied followed by an anti-aliasing filter (low-pass) and then A/D conversion. The input data is already digitized here, so no need for anti-alias filtering. Following A/D conversion, one would ideally begin beamforming, however the summing process in beamforming can produce very high values if low frequencies are included. This can result in the generation of a dynamic range in the data that exceeds what's allowable by the number of bits, thereby yielding data loss. Therefore it's necessary to high-pass filter before beamforming. In addition, beamforming is more accurate with a higher sampling rate because the calculated beamforming delays are more accurately achieved. Hence interpolation is used to upsample the signal. Finally, apodization is applied before the beamformer. This preprocessing function therefore consists of: 1) time-gain compensation 2) filtering 3) interpolation 4) apodization In the filtering step I've appied a band-pass, as higher frequencies are also problematic and are usually addressed after beamforming. inputs: data - transmission number x receive channel x time index t - time vector [s] xd - dector position vector [m] outputs: dataApod - processed data t2 - new time vectors """ sampleRate = 1 / (t[1] - t[0]) samplesPerAcq = data.shape[2] a0 = 0.4 # get time-gain compensation vectors based on estimate for propagation # distance to each element zd = t * c0 / 2 zd2 = zd**2 dist1 = zd tgc = np.zeros((numProbeChan, samplesPerAcq)) for r in range(numProbeChan): dist2 = np.sqrt(xd[r]**2 + zd2) propDist = dist1 + dist2 tgc[r, :] = getTGC(a0, propDist) # apply tgc dataAmp = np.zeros(data.shape) for m in range(numTxBeams): dataAmp[m, :, :] = data[m, :, :] * tgc # retrieve filter coefficients filtOrd = 201 lc, hc = 0.5e6, 2.5e6 lc = lc / (sampleRate / 2) # normalize to nyquist frequency hc = hc / (sampleRate / 2) B = signal.firwin(filtOrd, [lc, hc], pass_zero=False) # band-pass filter # specify interpolation factor interpFact = 4 sampleRate = sampleRate * interpFact samplesPerAcq2 = samplesPerAcq * interpFact # get apodization window apodWin = signal.tukey(numProbeChan) # np.ones(numProbeChan) # process dataApod = np.zeros((numTxBeams, numProbeChan, samplesPerAcq2)) for m in range(numTxBeams): for n in range(numProbeChan): w = dataAmp[m, n, :] dataFilt = signal.lfilter(B, 1, w) dataInterp = signal.resample_poly(dataFilt, interpFact, 1) dataApod[m, n, :] = apodWin[n] * dataInterp # create new time vector based on interpolation and filter delay freqs, delay = signal.group_delay((B, 1)) delay = int(delay[0]) * interpFact t2 = np.arange(samplesPerAcq2) / sampleRate + t[0] - delay / sampleRate # remove signal before t = 0 f = np.where(t2 < 0)[0] t2 = np.delete(t2, f) dataApod = dataApod[:, :, f[-1] + 1:] return dataApod, t2
def reconstruct(binfile, outfile): # Read in data and settings uid = int(binfile.split('.')[0]) SOI = 0 recon = [] with open(binfile, 'rb') as fh: SOI = fh.read(2) ## For you to modify print(outfile) print(SOI) if SOI != bytes.fromhex("FFD1"): raise Exception("Start of File marker not found!") M = int.from_bytes(fh.read(2), "big") N = int.from_bytes(fh.read(2), "big") recon = [] #np.zeros(2,M,N,3) temp = [] quality = int.from_bytes(fh.read(2), "big") skipper = int.from_bytes(fh.read(2), "big") rate = int.from_bytes(fh.read(2), "big") SOI = fh.read(2) count = 0 up = 4 while SOI != bytes.fromhex("FFD2"): if SOI != bytes.fromhex("FFD8"): raise Exception("Start of Image marker not found!") bits = () L = 0 if SOI != bytes.fromhex("FFDA"): SOI = fh.read(2) for _ in range(5): ba = bitarray.bitarray() for b in iter(lambda: fh.read(2), bytes.fromhex("FFDA")): #print(b) ba.frombytes(b) #if L <= 0: # print(L,'\n\nreading bits\n:',ba,'\n') bits = (*bits, ba) #print('run:',L,'inside loop\n\n\n',bits) L += 1 ba = bitarray.bitarray() for b in iter(lambda: fh.read(2), bytes.fromhex("FFD9")): ba.frombytes(b) bits = (*bits, ba) #print('lenth of bits is :',len(bits)) #print('in run:',count,'the bits are:\n',bits,'\n\n\n') #for i in range(len(bits)): # print(i,' run: ',bits[i],'\n\n\n\n\n') x = decode_image(bits, M, N, quality) temp.append(x) #x = Image.fromarray(x.astype(np.uint8)) count += 1 if count % skipper == 0: for i in range(skipper - 1): h = (x + temp[count - 2]) / 2 h = signal.resample_poly(h, up, 1, axis=0, padtype='mean') h = signal.resample_poly(h, up, 1, axis=1, padtype='mean') recon.append(Image.fromarray(h.astype(np.uint8))) x = signal.resample_poly(x, up, 1, axis=0, padtype='mean') x = signal.resample_poly(x, up, 1, axis=1, padtype='mean') recon.append(Image.fromarray(x.astype( np.uint8))) #Image.fromarray(np_im) SOI = fh.read(2) #print('\n:second:',recon.shape) # signal.resample_poly(Y, up, 1, padtype='mean') for i in range(len(recon)): im_ = recon[i] rec_fname = "frame_{:02d}.tiff".format(i + 1) im_.save(rec_fname, save_all=True) #recon[0].save(outfile,save_all=True, append_images=recon[1:]) GIF_save(path='', framerate=rate) ##########3 with open(binfile, 'rb') as f: B = fh.read() # Check length if len(B) == 0: print("Empty data!") msg = "empty data component" ffail = str(uid) + '.fail' with open(ffail, 'w') as f: f.write(msg) return ffail if (len(B) - 4) != np.frombuffer(B[:4], dtype='<u4')[0]: print("Length of received bytes ({}) != length header ({})".format( len(B) - 4, np.frombuffer(B[:4], dtype='<u4')[0])) msg = "length mismatch" ffail = str(uid) + '.fail' with open(ffail, 'w') as f: f.write(msg) return ffail data_out = B[4:] # Drop uint containing bit length ## Save as the given filename # Write output with open(outfile + '1', 'wb') as f: # Drop initial uint containing bit length f.write(data_out) return outfile
def resample(x, sr1=25, sr2=125, axis=0): a, b = Fraction(sr1, sr2)._numerator, Fraction(sr1, sr2)._denominator return resample_poly(x, a, b, axis).astype(np.float32)
def get_network_input(channels, S, T, fs=8000, fs_out=100000, fds=100, Tsil=[0.5, 0.2]): ''' Obtain the input to the all excictatory neurons in the network given spectral (S) and temporal (T) part of the kernel. Implementation based on (Hyafil, et al., 2015) Inputs: channels: auditory channels from the model of subcortical processing (128 x N) S: spectral component of the STRF filter (1 x 32) T: temporal component of the STRF filter (1 x 6) fs: sampling rate of the auditory channels input X (default: 8kHz). fs_out: output sampling rate in Hz (i.e. simulation sampling freq, default: 100kHz) fds: sampling rate of the STRF kernel in Hz (default: 100 Hz) Tsil: added silence [before onset, after the end] in s Outputs: Iext: auditory input to the model (84 x N matrix) dt: simulation timestep, in ms ''' # Silence from seconds -> samples Tsil = (np.array(Tsil) * fs).astype(np.int) nchan = S.shape[1] # Auditory channels to be used. Here, every 4th to obtain 32 channels projected to Ge neurons. ch_idx = (np.arange(1, nchan + 1) * np.ceil(channels.shape[1] / nchan) - 1).astype(np.int) # Obtain input to Ge neurons GE_input = channels[:, ch_idx].T # Obtain input to Te neurons TE_input = channels[:, ch_idx].T TE_input = np.dot(S, TE_input) # Process input through spectral weights # Downsample the resulting signal to match the temporal resolution of STRF (here 100 Hz) TE_input = signal.resample_poly(smooth(TE_input[0, :], np.int(fs / fds)), fds, fs) # Filter the resulting signal using temporal portion of the STRF kernel TE_input = signal.lfilter(T[0, :], np.array([1, 0, 0, 0, 0, 0]), TE_input) # Upsample to the original sampling rate (padding) TE_input = np.concatenate( [np.ones(np.int(fs / fds)) * i for i in TE_input]) TE_input = np.tile( TE_input, (10, 1)) # Tile the resulting signal x10, input to Te cells # Control step # If one input is longer than the other (due to resampling rounding) # crop both to the length of the shorter one. TE_input = TE_input[:, :min([TE_input.shape[1], GE_input.shape[1]])] GE_input = GE_input[:, :min([TE_input.shape[1], GE_input.shape[1]])] # Pre-allocate matrix of network inputs in the simulations Iext = np.zeros((84, sum(Tsil) + TE_input.shape[1])) # Popualte with the obtained inputs to Te and Ge neurons (incl. silence before and after) Iext[:10, Tsil[0]:(-1 * Tsil[1])] = TE_input[:, :] Iext[20:52, Tsil[0]:(-1 * Tsil[1])] = GE_input[:, :] # Upsampling to the desired fs_out if fs_out > fs: Iext = signal.resample_poly(Iext, fs_out, fs, axis=1) dt = 1000. / fs_out # in ms else: dt = 1000. / fs # in ms return Iext, dt
def up_sample_example(iq_mat, label, up): iq_mat = signal.resample_poly(iq_mat, up, down=1, axis=0) return iq_mat, label
def recognize_one_audio(input_path): # load audio logger.info('Loading wavfile...') wav, sr = sf.read(input_path) if wav.dtype != np.float32: wav = wav.astype(np.float32) if wav.ndim == 2 : if args.stereo: wav = np.transpose(wav,(1,0)) # stereo to batch else: wav = (wav[:,0][np.newaxis,:] + wav[:,1][np.newaxis,:])/2 # convert to mono else: wav = wav[np.newaxis,:] calc_time(wav.shape[1], sr) # convert sample rate logger.info('Converting sample rate...') if not sr == DESIRED_SR : if args.ailia_audio: wav = ailia.audio.resample(wav,sr,DESIRED_SR) else: wav = signal.resample_poly(wav, DESIRED_SR, sr, axis=1) # apply preenphasis filter logger.info('Generating input feature...') wav = preemphasis(wav) input_feature = tfconvert(wav, WINDOW_LEN, HOP_LEN, MULT) # create instance if not args.onnx : logger.info('Use ailia') env_id = args.env_id logger.info(f'env_id: {env_id}') memory_mode = ailia.get_memory_mode(reuse_interstage=True) session = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id, memory_mode=memory_mode) else : logger.info('Use onnxruntime') import onnxruntime session = onnxruntime.InferenceSession(WEIGHT_PATH) # inference logger.info('Start inference...') if args.benchmark: logger.info('BENCHMARK mode') for c in range(5) : start = int(round(time.time() * 1000)) sep = src_sep(input_feature, session) end = int(round(time.time() * 1000)) logger.info("\tprocessing time {} ms".format(end-start)) else: sep = src_sep(input_feature, session) # postprocessing logger.info('Start postprocessing...') if LPF_CUTOFF > 0 : sep = lowpass(sep, LPF_CUTOFF, DESIRED_SR) out_wav = inv_preemphasis(sep).clip(-1.,1.) out_wav = out_wav.swapaxes(0,1) # save sapareted signal savepath = get_savepath(args.savepath, input_path) logger.info(f'saved at : {savepath}') sf.write(savepath, out_wav, DESIRED_SR) logger.info('Saved separated signal. ') logger.info('Script finished successfully.')
def pcm_to_pdm(in_wav_file, out_pdm_file, pdm_sample_rate, verbose = False): pcm_sample_rate, pcm = scipy.io.wavfile.read(in_wav_file, 'r') nsamples = pcm.shape[0] multi_channel_pcm = pcm.T if len(multi_channel_pcm.shape ) == 1: multi_channel_pcm = np.reshape(multi_channel_pcm, (1, nsamples)) # FIXME this need a handler for float types first_sample = multi_channel_pcm[0][0] if isinstance( first_sample, ( int, np.int16, np.int32 ) ): pcm_full_scale = np.iinfo(first_sample).max if verbose: print("Full scale PCM value: " + str(pcm_full_scale) + ' (Integer type PCM)') else: pcm_full_scale = 1.0 if verbose: print("Full scale PCM value: " + str(pcm_full_scale) + ' (Float type PCM)') nchannels = multi_channel_pcm.shape[0] upsample_ratio , downsample_ratio = up_down_ratio(pcm_sample_rate, pdm_sample_rate) if nchannels > 8: print("Error: More than 8 channels is not supported, found " + str(nchannels) + ".") return seconds = np.round(float(nsamples) / float(pcm_sample_rate), 3) if verbose: print("PCM -> PDM") print("Number of sample: " + str(nsamples) + ' ~ ' + str(seconds) + ' seconds.') print("Channel count: " + str(nchannels)) print("Upsample ratio: " + str(upsample_ratio)) print("Downsample ratio: " + str(downsample_ratio)) # Stability limit pdm_magnitude_stability_limit = 0.4 # This seems to be safe output_length = nsamples*upsample_ratio // downsample_ratio pdm_samples = np.zeros((8, output_length)) max_abs_pcm_all_channels = 0. for ch in range(nchannels): if verbose: print('processing channel ' + str(ch)) pcm = multi_channel_pcm[ch] # limit the max pcm input to 0.4 - for stability of the modulator pcm = np.asarray(pcm, dtype=np.float64) / pcm_full_scale max_abs_pcm = max(abs(pcm)) max_abs_pcm_all_channels = max(max_abs_pcm, max_abs_pcm_all_channels) if max_abs_pcm >= pdm_magnitude_stability_limit: pcm /= max(abs(pcm)) pcm *= pdm_magnitude_stability_limit if verbose: print('Abs max sample: '+ str(max_abs_pcm) +' limiting the abs max sample to 0.4') else : if verbose: print('No sample limiting applied') # TODO do this in chunks to save memory up_sampled_pcm = signal.resample_poly(pcm, upsample_ratio, downsample_ratio) pdm_samples[ch] = delta_sigma_5th_order(up_sampled_pcm, output_length ) # Write output to file # Convert from [-1, 1] -> [0, 1] range pdm_samples[ch] = (pdm_samples[ch]*0.5) + np.ones(len(pdm_samples[ch]))*0.5 # pdm_samples = np.flip(pdm_samples, 0) pdm_samples = np.flipud(pdm_samples) my_bytes = np.array(pdm_samples, dtype=np.uint8) b = np.packbits(my_bytes.T, axis = -1) print("Max abs value {}".format(max_abs_pcm_all_channels)) fp = open(out_pdm_file,'wb') b.tofile(fp) return
def load_edf_file(filename, channels): # Load EDF file f = pyedflib.EdfReader(filename) # Channel labels channel_labels = f.getSignalLabels() # Sampling frequencies fss = f.getSampleFrequencies() # Pre-allocation of x x = [] # Extract channels for channel in channels: # Is channel referenced? if any([x in channel_alias[channel] for x in channel_labels]): channel_idx = channel_labels.index( next( filter(lambda i: i in channel_alias[channel], channel_labels))) # Gain factor # TODO: check if this makes sense g = f.getPhysicalMaximum(channel_idx) / f.getDigitalMaximum( channel_idx) # Read signal sig = g * f.readSignal(channel_idx) # Else: reference channels elif any([x in unref_channel_alias[channel] for x in channel_labels]): channel_idx = channel_labels.index( next( filter(lambda i: i in unref_channel_alias[channel], channel_labels))) ref_idx = channel_labels.index( next( filter(lambda i: i in ref_channel_alias[channel], channel_labels))) # Gain factor # TDO: check if this makes sense g = f.getPhysicalMaximum(channel_idx) / f.getDigitalMaximum( channel_idx) g_ref = f.getPhysicalMaximum(ref_idx) / f.getDigitalMaximum( ref_idx) # Assuming fs for signal and reference is identical sig = g * f.readSignal(channel_idx) - g_ref * f.readSignal(ref_idx) # Else empty else: sig = [] # If not empty if len(sig) != 0: # Resampling fs = fss[channel_idx] if fs != des_fs[channel]: resample_frac = Fraction(des_fs[channel] / fs).limit_denominator(100) sig = resample_poly(sig, resample_frac.numerator, resample_frac.denominator) # Filter signals if hp_fs[channel] != 0: sig_filtered = psg_highpass_filter(sig, hp_fs[channel], des_fs[channel], order=16) else: sig_filtered = sig # Scale signal sig_scaled = rescale(sig_filtered, 'soft') x.append(sig_scaled) # Replace empty with zeros N = max([len(s) for s in x]) for i, channel in enumerate(channels): if len(x[i]) == 0: x[i] = np.zeros(N) data = {'x': x, 'fs': [des_fs[x] for x in channels], 'channels': channels} f._close() return data
def resampling_poly(self, audio): audio = signal.resample_poly(audio, 1, 2) # resample 8kHz audio = tf.convert_to_tensor(audio, dtype=tf.float32) return audio
dist_in_samp = my_int(ds_config['distance'] * ds_config['target_fs']) w_in_samp = my_int(ds_config['width'] * ds_config['target_fs']) hw_in_samp = my_int(ds_config['width'] * ds_config['target_fs'] / 2) my_win = sig.gaussian(hw_in_samp + 1, (hw_in_samp - 1) / 5) my_win = np.diff(my_win) * sig.gaussian(hw_in_samp, (hw_in_samp - 1) / 5) for this_rec in records: data, field = wf.rdsamp(os.path.join(rec_path, this_rec)) pq_ratio = ds_config['target_fs'] / field['fs'] resample_frac = Fraction(pq_ratio).limit_denominator(20) #recalculo el ratio real pq_ratio = resample_frac.numerator / resample_frac.denominator data = sig.resample_poly(data, resample_frac.numerator, resample_frac.denominator) detection_sig = np.abs( sig.filtfilt(my_win, 1, data[:my_int( np.min([ data.shape[0], ds_config['explore_win'] * ds_config['target_fs'] ])), :], axis=0)) this_scale = np.repeat(np.nan, field['n_sig']).reshape(field['n_sig'], 1) for ii in range(field['n_sig']): posible_beats, _ = sig.find_peaks(detection_sig[:, ii],
fsResample = 16000 # リサンプリングの周波数 (Hz) FFT_LENGTH = 4096 # STFT時のFFT長 (points) HOP_LENGTH = 2048 # STFT時のフレームシフト長 (points) N_SOURCES = 2 # 音源数 N_ITER = 100 # ILRMAにおける推定回数(内部パラメタ) N_BASES = 10 # ILRMAにおける基底数(内部パラメタ) # ### 混合音の作成 ### # sig: signal x channel x source という3次元アレイ fs, sig_src1 = wavfile.read(SRC_WAV1) fs, sig_src2 = wavfile.read(SRC_WAV2) sig_src2 = sig_src2[:len(sig_src1)] sig = np.stack([sig_src1, sig_src2], axis=1) # 元の音源をリサンプリング (多項式補完) sig_src1 = signal.resample_poly(sig[:, :, 0], fsResample, fs) sig_src2 = signal.resample_poly(sig[:, :, 1], fsResample, fs) sig_resample = np.stack([sig_src1, sig_src2], axis=1) # 混合信号を作成 # 各チャネルごとに、音源の足し算 mix1 = sig_resample[:, 0, 0] + sig_resample[:, 0, 1] # 第0チャネル (left) mix2 = sig_resample[:, 1, 0] + sig_resample[:, 1, 1] # 第1チャネル (right) mixed = np.stack([mix1, mix2], axis=1) # ### 音源分離の実行 ### # 分析窓 win_a = pra.hamming(FFT_LENGTH) # 合成窓: 分析窓を事前に並べておく win_s = pra.transform.compute_synthesis_window(win_a, HOP_LENGTH)
def __call__(self, data): signal, label, orig_fs = data return resample_poly(signal, self.fs, orig_fs), label, self.fs
def demo_4d_rsHRF(input_file, mask_file, output_dir, para, mode='bids'): if not os.path.isdir(output_dir): os.mkdir(output_dir) if mode == 'bids': name = input_file.filename.split('/')[-1].split('.')[0] v = spm_dep.spm.spm_vol(mask_file.filename) elif mode == 'bids w/ atlas': name = input_file.filename.split('/')[-1].split('.')[0] v = spm_dep.spm.spm_vol(mask_file) else: name = input_file.split('/')[-1].split('.')[0] v = spm_dep.spm.spm_vol(mask_file) brain = spm_dep.spm.spm_read_vols(v) voxel_ind = np.where(brain > 0)[0] temporal_mask = [] if mode == 'bids' or mode == 'bids w/ atlas': v1 = spm_dep.spm.spm_vol(input_file.filename) else: v1 = spm_dep.spm.spm_vol(input_file) if v1.header.get_data_shape()[:-1] != v.header.get_data_shape(): print('The dimension of your mask is different than ' 'the one of your fMRI data!') return else: data = v1.get_data() nobs = data.shape[3] data1 = np.reshape(data, (-1, nobs), order='F').T bold_sig = stats.zscore(data1[:, voxel_ind], ddof=1) bold_sig = np.nan_to_num(bold_sig) bold_sig = processing. \ rest_filter. \ rest_IdealFilter(bold_sig, para['TR'], para['passband']) data_deconv = np.zeros(bold_sig.shape) event_number = np.zeros((1, bold_sig.shape[1])) print('Retrieving HRF ...') if 'canon' in para['estimation']: beta_hrf, bf, event_bold = \ canon.canon_hrf2dd.wgr_rshrf_estimation_canonhrf2dd_par2( bold_sig, para, temporal_mask ) hrfa = np.dot(bf, beta_hrf[np.arange(0, bf.shape[1]), :]) elif 'FIR' in para['estimation']: para['T'] = 1 hrfa, event_bold = sFIR. \ smooth_fir. \ wgr_rsHRF_FIR(bold_sig, para, temporal_mask) nvar = hrfa.shape[1] PARA = np.zeros((3, nvar)) for voxel_id in range(nvar): hrf1 = hrfa[:, voxel_id] PARA[:, voxel_id] = \ parameters.wgr_get_parameters(hrf1, para['TR'] / para['T']) print('Done') print('Deconvolving HRF ...') T = np.around(para['len'] / para['TR']) if para['T'] > 1: hrfa_TR = signal.resample_poly(hrfa, 1, para['T']) else: hrfa_TR = hrfa for voxel_id in range(nvar): hrf = hrfa_TR[:, voxel_id] H = np.fft.fft(np.append(hrf, np.zeros( (nobs - max(hrf.shape), 1))), axis=0) M = np.fft.fft(bold_sig[:, voxel_id]) data_deconv[:, voxel_id] = \ np.fft.ifft(H.conj() * M / (H * H.conj() + .1*np.mean((H * H.conj())))) event_number[:, voxel_id] = np.amax(event_bold[voxel_id].shape) if mode == 'bids' or mode == 'bids w/ atlas': try: sub_save_dir = os.path.join(output_dir, 'sub-' + input_file.subject, 'session-' + input_file.session, input_file.modality) except AttributeError as e: sub_save_dir = os.path.join(output_dir, 'sub-' + input_file.subject, input_file.modality) else: sub_save_dir = output_dir if not os.path.isdir(sub_save_dir): os.makedirs(sub_save_dir, exist_ok=True) sio.savemat(os.path.join(sub_save_dir, name + '_hrf.mat'), { 'para': para, 'hrfa': hrfa, 'event_bold': event_bold, 'PARA': PARA }) HRF_para_str = ['Height.nii', 'Time2peak.nii', 'FWHM.nii'] data = np.zeros(v.get_data().shape).flatten(order='F') for i in range(3): fname = os.path.join(sub_save_dir, name + '_' + HRF_para_str[i]) data[voxel_ind] = PARA[i, :] data = data.reshape(v.get_data().shape, order='F') spm_dep.spm.spm_write_vol(v, data, fname) data = data.flatten(order='F') fname = os.path.join(sub_save_dir, name + '_event_number.nii') data[voxel_ind] = event_number data = data.reshape(v.get_data().shape, order='F') spm_dep.spm.spm_write_vol(v, data, fname) data = np.zeros(v1.get_data().shape) dat3 = np.zeros(v1.header.get_data_shape()[:-1]).flatten(order='F') for i in range(nobs): fname = os.path.join(sub_save_dir, name + '_deconv') dat3[voxel_ind] = data_deconv[i, :] dat3 = dat3.reshape(v1.header.get_data_shape()[:-1], order='F') data[:, :, :, i] = dat3 dat3 = dat3.flatten(order='F') spm_dep.spm.spm_write_vol(v1, data, fname) event_plot = lil_matrix((1, nobs)) event_plot[:, event_bold[0]] = 1 event_plot = np.ravel(event_plot.toarray()) plt.figure() plt.plot(para['TR'] * np.arange(1, np.amax(hrfa[:, 0].shape) + 1), hrfa[:, 0], linewidth=1) plt.xlabel('time (s)') plt.savefig(os.path.join(sub_save_dir, name + '_plot_1.png')) plt.figure() plt.plot(para['TR'] * np.arange(1, nobs + 1), np.nan_to_num(stats.zscore(bold_sig[:, 0], ddof=1)), linewidth=1) plt.plot(para['TR'] * np.arange(1, nobs + 1), np.nan_to_num(stats.zscore(data_deconv[:, 0], ddof=1)), color='r', linewidth=1) markerline, stemlines, baseline = \ plt.stem(para['TR'] * np.arange(1, nobs + 1), event_plot) plt.setp(baseline, 'color', 'k', 'markersize', 1) plt.setp(stemlines, 'color', 'k', 'markersize', 1) plt.setp(markerline, 'color', 'k', 'markersize', 3, 'marker', 'd') plt.legend(['BOLD', 'deconvolved', 'events']) plt.xlabel('time (s)') plt.savefig(os.path.join(sub_save_dir, name + '_plot_2.png'))
def resample(x, up, dn): '''rational resampling by a factor of up/dn''' return signal.resample_poly(x, up, dn, padtype='line')
from scipy import signal from scipy.io import wavfile import numpy as np ########################################## #miscellaneous useful functions, in python ########################################## samplerate, data = wavfile.read( 'C:/Apps/INSTINCT/Out/decimateTest/AU-ALIC01-170421-115000.wav') print("done 1") up = 5 down = 8 data_resamp = signal.resample_poly(data, up, down) print("done 2") wavfile.write( 'C:/Apps/INSTINCT/Out/decimateTest/AU-ALIC01-170421-115000_python.wav', int(samplerate * up / down), np.asarray(data_resamp, dtype=np.int16)) print("done 3")