def test_spline_detrend_plotting(self): """ Tests the plotting of the spline detrend operation. """ tr = obspy.read()[0].filter("highpass", freq=2) tr.data += 6000 + 4 * tr.times() ** 2 - 0.1 * tr.times() ** 3 - \ 0.00001 * tr.times() ** 5 # Use an first order spline to see a difference to the polynomial # picture. with ImageComparison(self.path_images, 'degree_1_spline_detrend.png') as ic: spline(tr.data, order=1, dspline=1500, plot=ic.name)
def test_spline_detrend(self): """ Simple test for the spline detrending. """ coeffs = [(1, 2, 3), (2, -4), (-3, 2, -5, 15), (-10, 20, -1, 2, 15)] data = np.linspace(-5, 5, 100) for c in coeffs: # Create data. d = np.polyval(c, data) original_ptp = np.ptp(d) # Detrend with a spline of the same order as the polynomial. # This should be very very similar. detrended = spline(d, order=len(c) - 1, dspline=10) # Not as good as for the polynomial detrending. self.assertLess(np.ptp(detrended) * 1E4, original_ptp)
def xcorr2(tr1, tr2, window_seconds=3600, window_overlap=0, interval_seconds=86400, flo=0.9, fhi=1.1, clip_to_2std=False, one_bit_normalize=False, verbose=1, logger=None): sr1 = tr1.stats.sampling_rate sr2 = tr2.stats.sampling_rate tr1_d_all = tr1.data # refstn tr2_d_all = tr2.data lentr1_all = tr1_d_all.shape[0] lentr2_all = tr2_d_all.shape[0] window_samples_1 = window_seconds * sr1 window_samples_2 = window_seconds * sr2 interval_samples_1 = interval_seconds * sr1 interval_samples_2 = interval_seconds * sr2 itr1s = 0 itr2s = 0 resll = [] intervalCount = 0 windowsPerInterval = [ ] # Stores the number of windows processed per interval intervalStartSeconds = [] intervalEndSeconds = [] while itr1s < lentr1_all and itr2s < lentr2_all: itr1e = min(lentr1_all, itr1s + interval_samples_1) itr2e = min(lentr2_all, itr2s + interval_samples_2) sr = max(sr1, sr2) xcorlen = int(2 * window_seconds * sr - 1) fftlen = 2**(int(np.log2(xcorlen)) + 1) windowCount = 0 wtr1s = int(itr1s) wtr2s = int(itr2s) resl = [] while wtr1s < itr1e and wtr2s < itr2e: wtr1e = int(min(itr1e, wtr1s + window_samples_1)) wtr2e = int(min(itr2e, wtr2s + window_samples_2)) # Discard small windows if wtr1e - wtr1s < window_samples_1 or wtr2e - wtr2s < window_samples_2: wtr1s = wtr1e wtr2s = wtr2e continue # end if # Discard windows with masked regions, i.e. with gaps if (not (np.ma.is_masked(tr1_d_all[wtr1s:wtr1e]) or np.ma.is_masked(tr2_d_all[wtr2s:wtr2e]))): tr1_d = np.array(tr1_d_all[wtr1s:wtr1e], dtype=np.float32) tr2_d = np.array(tr2_d_all[wtr2s:wtr2e], dtype=np.float32) # detrend tr1_d = spline(tr1_d, 2, 1000) tr2_d = spline(tr2_d, 2, 1000) # zero-mean tr1_d -= np.mean(tr1_d) tr2_d -= np.mean(tr2_d) # clip to +/- 2*std if (clip_to_2std): std_tr1 = np.std(tr1_d) std_tr2 = np.std(tr2_d) clip_indices_tr1 = np.fabs(tr1_d) > 2 * std_tr1 clip_indices_tr2 = np.fabs(tr2_d) > 2 * std_tr2 tr1_d[clip_indices_tr1] = 2 * std_tr1 * np.sign( tr1_d[clip_indices_tr1]) tr2_d[clip_indices_tr2] = 2 * std_tr2 * np.sign( tr2_d[clip_indices_tr2]) # end if # apply zero-phase band-pass tr1_d = bandpass(tr1_d, flo, fhi, sr1, zerophase=True) tr2_d = bandpass(tr2_d, flo, fhi, sr2, zerophase=True) # taper #tr1_d = taper(tr1_d, int(sr1 / flo)) #tr2_d = taper(tr2_d, int(sr2 / flo)) # 1-bit normalization if (one_bit_normalize): tr1_d = np.sign(tr1_d) tr2_d = np.sign(tr2_d) # end if if (sr1 < sr2): fftlen2 = fftlen fftlen1 = int((fftlen2 * 1.0 * sr1) / sr) outdims2 = np.array([fftlen2]) outdims1 = np.array([fftlen1]) rf = zeropad_ba( fftn(zeropad(tr1_d, fftlen1), shape=outdims1), fftlen2) * fftn(zeropad(ndflip(tr2_d), fftlen2), shape=outdims2) elif (sr1 > sr2): fftlen1 = fftlen fftlen2 = int((fftlen1 * 1.0 * sr2) / sr) outdims2 = np.array([fftlen2]) outdims1 = np.array([fftlen1]) rf = fftn(zeropad(tr1_d, fftlen1), shape=outdims1) * zeropad_ba( fftn(zeropad(ndflip(tr2_d), fftlen2), shape=outdims2), fftlen1) else: fftlen = 2**(int(np.log2(2 * window_samples_1 - 1)) + 1) outdims = np.array([fftlen]) rf = fftn(zeropad(tr1_d, fftlen), shape=outdims) * fftn( zeropad(ndflip(tr2_d), fftlen), shape=outdims) # end if resl.append(rf) windowCount += 1 # end if wtr1s += int(window_samples_1 - window_samples_1 * window_overlap) wtr2s += int(window_samples_2 - window_samples_2 * window_overlap) # end while (windows within interval) if (verbose > 1): if (logger): logger.info('\tProcessed %d windows in interval %d' % (windowCount, intervalCount)) # end fi if (np.fabs(itr1e - itr1s) < sr1): itr1s = itr1e itr2s = itr2e continue # end if intervalStartSeconds.append(itr1s / sr1) intervalEndSeconds.append(itr1e / sr1) itr1s = itr1e itr2s = itr2e intervalCount += 1 # Append an array of zeros if no windows were processed for the current interval if (windowCount == 0): resl.append(np.zeros(fftlen)) if (verbose == 1): if (logger): logger.info( '\tWarning: No windows processed due to gaps in data in current interval' ) # end if # end if windowsPerInterval.append(windowCount) step = np.sign(np.fft.fftfreq(fftlen, 1.0 / sr)) mean = reduce((lambda tx, ty: tx + ty), resl) / len(resl) mean = mean + step * mean # compute analytic mean = ifftn(mean) # Compute magnitude of mean mean = np.abs(mean) normFactor = np.max(mean) # mean can be 0 for a null result if (normFactor > 0): mean /= normFactor #end if resll.append(mean[:xcorlen]) # end while (iteration over intervals) if (len(resll)): return np.array(resll), np.array(windowsPerInterval), \ np.array(intervalStartSeconds, dtype='i8'), \ np.array(intervalEndSeconds, dtype='i8') else: return None, None, None, None
def _run_interface(self, runtime): print("Linear detrending") print("=================") # Output from previous preprocessing step ref_path = self.inputs.in_file # Load data dataimg = nib.load(ref_path) data = dataimg.get_data() tp = data.shape[3] # GLM: regress out nuisance covariates new_data_det = data.copy() gm = nib.load(self.inputs.gm_file[0]).get_data().astype(np.uint32) from scipy import signal for index, value in np.ndenumerate(gm): if value == 0: continue Ydet = signal.detrend(data[index[0], index[1], index[2], :].reshape(tp, 1), axis=0) new_data_det[index[0], index[1], index[2], :] = Ydet[:, 0] img = nib.Nifti1Image(new_data_det, dataimg.get_affine(), dataimg.get_header()) nib.save(img, os.path.abspath("fMRI_detrending.nii.gz")) if self.inputs.mode == "quadratic": print("Quadratic detrending") print("=================") from obspy.signal.detrend import polynomial # GLM: regress out nuisance covariates new_data_det2 = new_data_det.copy() for index, value in np.ndenumerate(gm): if value == 0: continue Ydet = polynomial(new_data_det2[index[0], index[1], index[2], :], order=2) img = nib.Nifti1Image(new_data_det2, dataimg.get_affine(), dataimg.get_header()) nib.save(img, os.path.abspath("fMRI_detrending.nii.gz")) if self.inputs.mode == "cubic": print("Cubic-spline detrending") print("=================") from obspy.signal.detrend import spline # GLM: regress out nuisance covariates new_data_det2 = new_data_det.copy() for index, value in np.ndenumerate(gm): if value == 0: continue Ydet = spline(new_data_det2[index[0], index[1], index[2], :], order=3) img = nib.Nifti1Image(new_data_det2, dataimg.get_affine(), dataimg.get_header()) nib.save(img, os.path.abspath("fMRI_detrending.nii.gz")) print("[ DONE ]") return runtime