def stim_pro(feat_ptr, output, orig_size, fps, i): """Sugar function for parallel computing.""" print i # scanning parameter TR = 1 # movie fps #fps = 15 time_unit = 1.0 / fps # HRF config hrf_times = np.arange(0, 35, time_unit) hrf_signal = hrf.biGammaHRF(hrf_times) hrf_signal = hrf_signal.astype(np.float16) # procssing r_idx = i / orig_size[1] c_idx = i % orig_size[1] tmp_list = [] for p in feat_ptr: tmp_list.append(p[r_idx, c_idx, ...]) ts = np.concatenate(tmp_list, axis=1) # log-transform # memory saving trick ts += 1 ts = np.log(ts) # convolved with HRF convolved = np.apply_along_axis(np.convolve, 1, ts, hrf_signal) # remove time points after the end of the scanning run n_to_remove = len(hrf_times) - 1 convolved = convolved[:, :-n_to_remove] # temporal down-sample vol_times = np.arange(0, ts.shape[1], fps) output[r_idx, c_idx, ...] = convolved[:, vol_times]
def get_stim_seq(stimulus, output_filename): """Get stimulus sequence by compute structural similarity between adjacent frames. """ fps = 15 stim_len = stimulus.shape[0] stim_seq = np.zeros((stim_len, )) img_w, img_h = stimulus.shape[2], stimulus.shape[3] for i in range(1, stim_len): pim = img_recon(stimulus[i - 1, ...]) nim = img_recon(stimulus[i, ...]) pim = rgb2gray(pim) nim = rgb2gray(nim) stim_seq[i] = compare_ssim(pim, nim, multichannel=False) # convolved with HRF time_unit = 1.0 / fps # HRF config hrf_times = np.arange(0, 35, time_unit) hrf_signal = hrf.biGammaHRF(hrf_times) convolved_seq = np.convolve(stim_seq, hrf_signal) # remove time points after the end of the scanning run n_to_remove = len(hrf_times) - 1 convolved_seq = convolved_seq[:-n_to_remove] # temporal down-sample vol_times = np.arange(0, stim_len, fps) dseq = convolved_seq[vol_times] np.save(output_filename, dseq)
def stim_pro(feat_ptr, output, orig_size, fps, fact, sal_ts, i, using_hrf=True): """Sugar function for parallel computing.""" print i # scanning parameter TR = 1 # movie fps #fps = 15 time_unit = 1.0 / fps # HRF config hrf_times = np.arange(0, 35, time_unit) hrf_signal = hrf.biGammaHRF(hrf_times) # procssing bsize = orig_size[1] * orig_size[2] for p in range(len(feat_ptr)): if not p: ts = feat_ptr[p][:, i * bsize:(i + 1) * bsize] else: ts = np.concatenate( [ts, feat_ptr[p][:, i * bsize:(i + 1) * bsize]], axis=0) ts = ts.T if sal_ts: ts = ts * sal_ts # log-transform ts = np.log(ts + 1) if using_hrf: # convolved with HRF convolved = np.apply_along_axis(np.convolve, 1, ts, hrf_signal) # remove time points after the end of the scanning run n_to_remove = len(hrf_times) - 1 convolved = convolved[:, :-n_to_remove] # temporal down-sample vol_times = np.arange(0, ts.shape[1], fps) ndts = convolved[:, vol_times] else: # temporal down-sample dts = down_sample(ts, (1, fps)) # shift time series ndts = np.zeros_like(dts) delay_time = 4 ndts[:, delay_time:] = dts[:, :(-1 * delay_time)] # reshape to 3D ndts = ndts.reshape(orig_size[1], orig_size[2], ts.shape[1] / fps) # get start index idx = i * bsize channel_idx, row, col = vutil.node2feature(idx, orig_size) # spatial down-sample if fact: ndts = down_sample(ndts, (fact, fact, 1)) output[channel_idx, ...] = ndts
def feat_tr_pro(in_file, out_dir, out_dim=None, using_hrf=True): """Get TRs from input 3D dataset (the third dim is time). Input ----- in_file : absolute path of input file out_dir : output directory out_dim : spatial resolution of output, a tuple of (row, col) """ # load stimulus time courses feat_ts = np.load(in_file, mmap_mode='r') ts_shape = feat_ts.shape print 'Original data shape : ', ts_shape # scanning parameter TR = 1 # movie fps fps = 15 time_unit = 1.0 / fps # HRF config hrf_times = np.arange(0, 35, time_unit) hrf_signal = hrf.biGammaHRF(hrf_times) # reshape to 2D for convenience feat_ts = feat_ts.reshape(-1, ts_shape[2]) # log-transform feat_ts = np.log(feat_ts + 1) if using_hrf: # convolved with HRF convolved = np.apply_along_axis(np.convolve, 1, feat_ts, hrf_signal) # remove time points after the end of the scanning run n_to_remove = len(hrf_times) - 1 convolved = convolved[:, :-n_to_remove] # temporal down-sample vol_times = np.arange(0, feat_ts.shape[1], fps) dconvolved = convolved[:, vol_times] else: # temporal down-sample dts = down_sample(feat_ts, (1, fps)) # shift time series dconvolved = np.zeros_like(dts) delay_time = 4 dconvolved[:, delay_time:] = dts[:, :(-1 * delay_time)] # reshape to 3D dconvolved3d = dconvolved.reshape(ts_shape[0], ts_shape[1], -1) # spatial down-sample if out_dim: ds_mark = '_%s_%s' % (out_dim[0], out_dim[1]) dconvolved3d = img_resize(dconvolved3d, out_dim) #im_min, im_max = dconvolved3d.min(), dconvolved3d.max() #im_std = (dconvolved3d - im_min) / (im_max - im_min) #resized_im = resize(im_std, out_dim, order=1) #dconvolved3d = resized_im * (im_max - im_min) + im_min else: ds_mark = '' print 'Output data shape : ', dconvolved3d.shape # save TRs fname = os.path.basename(in_file) fname = fname.split('.') out_file_name = '.'.join([fname[0] + '_trs%s' % (ds_mark), fname[1]]) out_file = os.path.join(out_dir, out_file_name) print 'Save TR data into file ', out_file np.save(out_file, dconvolved3d)