def group_analysis_signs(design, contrast, mask, signs=None): """ This function refits the EM model with a vector of signs. Used in the permutation tests. Returns the maximum of the T-statistic within mask Parameters ---------- design: one of 'block', 'event' contrast: str mask: array-like signs: ndarray, optional Defaults to np.ones. Should have shape (*,nsubj) where nsubj is the number of effects combined in the group analysis. Returns ------- minT: np.ndarray, minima of T statistic within mask, one for each vector of signs maxT: np.ndarray, maxima of T statistic within mask, one for each vector of signs """ maska = np.asarray(mask).astype(np.bool) # Which subjects have this (contrast, design) pair? subjects = futil.subject_dirs(design, contrast) sd = np.array([np.array(load_image(pjoin(s, "sd.nii")))[:,maska] for s in subjects]) Y = np.array([np.array(load_image(pjoin(s, "effect.nii")))[:,maska] for s in subjects]) if signs is None: signs = np.ones((1, Y.shape[0])) maxT = np.empty(signs.shape[0]) minT = np.empty(signs.shape[0]) for i, sign in enumerate(signs): signY = sign[:,np.newaxis] * Y varest = onesample.estimate_varatio(signY, sd) random_var = varest['random'] adjusted_var = sd**2 + random_var adjusted_sd = np.sqrt(adjusted_var) results = onesample.estimate_mean(Y, adjusted_sd) T = results['t'] minT[i], maxT[i] = np.nanmin(T), np.nanmax(T) return minT, maxT
def group_analysis(design, contrast): """ Compute group analysis effect, t, sd for `design` and `contrast` Saves to disk in 'group' analysis directory Parameters ---------- design : {'block', 'event'} contrast : str contrast name """ array = np.array # shorthand # Directory where output will be written odir = futil.ensure_dir(futil.DATADIR, 'group', design, contrast) # Which subjects have this (contrast, design) pair? subj_con_dirs = futil.subj_des_con_dirs(design, contrast) if len(subj_con_dirs) == 0: raise ValueError('No subjects for %s, %s' % (design, contrast)) # Assemble effects and sds into 4D arrays sds = [] Ys = [] for s in subj_con_dirs: sd_img = load_image(pjoin(s, "sd.nii")) effect_img = load_image(pjoin(s, "effect.nii")) sds.append(sd_img.get_data()) Ys.append(effect_img.get_data()) sd = array(sds) Y = array(Ys) # This function estimates the ratio of the fixed effects variance # (sum(1/sd**2, 0)) to the estimated random effects variance # (sum(1/(sd+rvar)**2, 0)) where rvar is the random effects variance. # The EM algorithm used is described in: # # Worsley, K.J., Liao, C., Aston, J., Petre, V., Duncan, G.H., # Morales, F., Evans, A.C. (2002). \'A general statistical # analysis for fMRI data\'. NeuroImage, 15:1-15 varest = onesample.estimate_varatio(Y, sd) random_var = varest['random'] # XXX - if we have a smoother, use # random_var = varest['fixed'] * smooth(varest['ratio']) # Having estimated the random effects variance (and possibly smoothed it), # the corresponding estimate of the effect and its variance is computed and # saved. # This is the coordmap we will use coordmap = futil.load_image_ds105("fiac_00", "wanatomical.nii").coordmap adjusted_var = sd**2 + random_var adjusted_sd = np.sqrt(adjusted_var) results = onesample.estimate_mean(Y, adjusted_sd) for n in ['effect', 'sd', 't']: im = api.Image(results[n], copy(coordmap)) save_image(im, pjoin(odir, "%s.nii" % n))
def group_analysis(design, contrast): """ Compute group analysis effect, t, sd for `design` and `contrast` Saves to disk in 'group' analysis directory Parameters ---------- design : {'block', 'event'} contrast : str contrast name """ array = np.array # shorthand # Directory where output will be written odir = futil.ensure_dir(futil.DATADIR, 'group', design, contrast) # Which subjects have this (contrast, design) pair? subj_con_dirs = futil.subj_des_con_dirs(design, contrast) if len(subj_con_dirs) == 0: raise ValueError('No subjects for %s, %s' % (design, contrast)) # Assemble effects and sds into 4D arrays sds = [] Ys = [] for s in subj_con_dirs: sd_img = load_image(pjoin(s, "sd.nii")) effect_img = load_image(pjoin(s, "effect.nii")) sds.append(sd_img.get_data()) Ys.append(effect_img.get_data()) sd = array(sds) Y = array(Ys) # This function estimates the ratio of the fixed effects variance # (sum(1/sd**2, 0)) to the estimated random effects variance # (sum(1/(sd+rvar)**2, 0)) where rvar is the random effects variance. # The EM algorithm used is described in: # # Worsley, K.J., Liao, C., Aston, J., Petre, V., Duncan, G.H., # Morales, F., Evans, A.C. (2002). \'A general statistical # analysis for fMRI data\'. NeuroImage, 15:1-15 varest = onesample.estimate_varatio(Y, sd) random_var = varest['random'] # XXX - if we have a smoother, use # random_var = varest['fixed'] * smooth(varest['ratio']) # Having estimated the random effects variance (and possibly smoothed it), # the corresponding estimate of the effect and its variance is computed and # saved. # This is the coordmap we will use coordmap = futil.load_image_fiac("fiac_00","wanatomical.nii").coordmap adjusted_var = sd**2 + random_var adjusted_sd = np.sqrt(adjusted_var) results = onesample.estimate_mean(Y, adjusted_sd) for n in ['effect', 'sd', 't']: im = api.Image(results[n], copy(coordmap)) save_image(im, pjoin(odir, "%s.nii" % n))
def testrun(self): funcim = load_image(funcfile) fmriims = FmriImageList.from_image(funcim, volume_start_times=2.) f1 = ExperimentalQuantitative("f1", lambda t:t) f2 = ExperimentalQuantitative("f1", lambda t:t**2) f3 = ExperimentalQuantitative("f1", lambda t:t**3) f = f1 + f2 + f3 c = Contrast(f1, f) c.compute_matrix(fmriims.volume_start_times) c2 = Contrast(f1 + f2, f) c2.compute_matrix(fmriims.volume_start_times) outputs = [] outputs.append(model.output_AR1(self.ar1, fmriims, clobber=True)) outputs.append(model.output_resid(self.resid_OLS, fmriims, clobber=True)) ols = model.OLS(fmriims, f, outputs) ols.execute() outputs = [] out_fn = os.path.join(self.out_dir, 'out.nii') outputs.append(model.output_T(out_fn, c, fmriims, clobber=True)) outputs.append(model.output_F(self.F, c2, fmriims, clobber=True)) outputs.append(model.output_resid(self.resid, fmriims, clobber=True)) rho = load_image(self.ar1) ar = model.AR1(fmriims, f, rho, outputs) ar.execute()
def test_save1(): # A test to ensure that when a file is saved, the affine and the # data agree. This image comes from a NIFTI file img = load_image(funcfile) save_image(img, tmpfile.name) img2 = load_image(tmpfile.name) yield assert_true, np.allclose(img.affine, img2.affine) yield assert_equal, img.shape, img2.shape yield assert_true, np.allclose(np.asarray(img2), np.asarray(img))
def test_save1(): # A test to ensure that when a file is saved, the affine and the # data agree. This image comes from a NIFTI file img = load_image(funcfile) with InTemporaryDirectory(): save_image(img, TMP_FNAME) img2 = load_image(TMP_FNAME) assert_array_almost_equal(img.affine, img2.affine) assert_equal(img.shape, img2.shape) assert_array_almost_equal(img2.get_data(), img.get_data()) del img2
def fixed_effects(subj, design): """ Fixed effects (within subject) for OpenfMRI ds105 model Finds run by run estimated model results, creates fixed effects results image per subject. Parameters ---------- subj : int subject number 1..6 inclusive design : {'standard'} design type """ # First, find all the effect and standard deviation images # for the subject and this design type path_dict = futil.path_info_design(subj, design) rootdir = path_dict['rootdir'] # The output directory fixdir = pjoin(rootdir, "fixed") # Fetch results images from run estimations results = futil.results_table(path_dict) # Get our hands on the relevant coordmap to save our results coordmap = futil.load_image_ds105("_%02d" % subj, "wanatomical.nii").coordmap # Compute the "fixed" effects for each type of contrast for con in results: fixed_effect = 0 fixed_var = 0 for effect, sd in results[con]: effect = load_image(effect).get_data() sd = load_image(sd).get_data() var = sd**2 # The optimal, in terms of minimum variance, combination of the # effects has weights 1 / var # # XXX regions with 0 variance are set to 0 # XXX do we want this or np.nan? ivar = np.nan_to_num(1. / var) fixed_effect += effect * ivar fixed_var += ivar # Now, compute the fixed effects variance and t statistic fixed_sd = np.sqrt(fixed_var) isd = np.nan_to_num(1. / fixed_sd) fixed_t = fixed_effect * isd # Save the results odir = futil.ensure_dir(fixdir, con) for a, n in zip([fixed_effect, fixed_sd, fixed_t], ['effect', 'sd', 't']): im = api.Image(a, copy(coordmap)) save_image(im, pjoin(odir, '%s.nii' % n))
def fixed_effects(subj, design): """ Fixed effects (within subject) for FIAC model Finds run by run estimated model results, creates fixed effects results image per subject. Parameters ---------- subj : int subject number 1..6 inclusive design : {'standard'} design type """ # First, find all the effect and standard deviation images # for the subject and this design type path_dict = futil.path_info_design(subj, design) rootdir = path_dict['rootdir'] # The output directory fixdir = pjoin(rootdir, "fixed") # Fetch results images from run estimations results = futil.results_table(path_dict) # Get our hands on the relevant coordmap to save our results coordmap = futil.load_image_fiac("_%02d" % subj, "wanatomical.nii").coordmap # Compute the "fixed" effects for each type of contrast for con in results: fixed_effect = 0 fixed_var = 0 for effect, sd in results[con]: effect = load_image(effect).get_data() sd = load_image(sd).get_data() var = sd ** 2 # The optimal, in terms of minimum variance, combination of the # effects has weights 1 / var # # XXX regions with 0 variance are set to 0 # XXX do we want this or np.nan? ivar = np.nan_to_num(1. / var) fixed_effect += effect * ivar fixed_var += ivar # Now, compute the fixed effects variance and t statistic fixed_sd = np.sqrt(fixed_var) isd = np.nan_to_num(1. / fixed_sd) fixed_t = fixed_effect * isd # Save the results odir = futil.ensure_dir(fixdir, con) for a, n in zip([fixed_effect, fixed_sd, fixed_t], ['effect', 'sd', 't']): im = api.Image(a, copy(coordmap)) save_image(im, pjoin(odir, '%s.nii' % n))
def get_fmri_anat(path_dict): """Get the images for a given subject/run. Returns ------- fmri : ndarray anat : NIPY image """ fmri = np.array(load_image(pjoin("%(rootdir)s/swafunctional_%(run)02d.nii") % path_dict)) anat = load_image(pjoin(DATADIR, "fiac_%(subj)02d", "wanatomical.nii") % path_dict) return fmri, anat
def test_write(): fp, fname = mkstemp('.nii') img = load_image(funcfile) save_image(img, fname) test = FmriImageList.from_image(load_image(fname)) yield nose.tools.assert_equal, test[0].affine.shape, (4,4) yield nose.tools.assert_equal, img[0].affine.shape, (5,4) yield nose.tools.assert_true, np.allclose(test[0].affine, img[0].affine[1:]) # Under windows, if you don't close before delete, you get a # locking error. os.close(fp) os.remove(fname)
def setUp(self): self.fd = np.asarray(load_image(funcfile)) self.fi = FmriImageList.from_image(load_image(funcfile)) # I think it makes more sense to use fd instead of fi for GLM # purposes -- reduces some noticeable overhead in creating the # array from FmriImageList # create a design matrix, model and contrast matrix self.design = noise((self.fd.shape[0],3)) self.model = ols_model(self.design) self.cmatrix = np.array([[1,0,0],[0,1,0]])
def test_write(): fname = 'myfile.nii' img = load_image(funcfile) with InTemporaryDirectory(): save_image(img, fname) test = FmriImageList.from_image(load_image(fname)) assert_equal(test[0].affine.shape, (4,4)) assert_equal(img[0].affine.shape, (5,4)) # Check the affine... A = np.identity(4) A[:3,:3] = img[:,:,:,0].affine[:3,:3] A[:3,-1] = img[:,:,:,0].affine[:3,-1] assert_true(np.allclose(test[0].affine, A)) del test
def test_write(): fname = "myfile.nii" img = load_image(funcfile) with InTemporaryDirectory(): save_image(img, fname) test = FmriImageList.from_image(load_image(fname)) assert_equal(test[0].affine.shape, (4, 4)) assert_equal(img[0].affine.shape, (5, 4)) # Check the affine... A = np.identity(4) A[:3, :3] = img[:, :, :, 0].affine[:3, :3] A[:3, -1] = img[:, :, :, 0].affine[:3, -1] assert_true(np.allclose(test[0].affine, A)) del test
def test_space_time_realign(): path, fname = psplit(funcfile) original_affine = load_image(funcfile).affine path, fname = psplit(funcfile) froot, _ = fname.split('.', 1) with InTemporaryDirectory(): # Make another image with .nii extension and extra dot in filename save_image(load_image(funcfile), 'my.test.nii') for in_fname, out_fname in ((funcfile, froot + '_mc.nii.gz'), ('my.test.nii', 'my.test_mc.nii.gz')): xforms = reg.space_time_realign(in_fname, 2.0, out_name='.') assert_true(np.allclose(xforms[0].as_affine(), np.eye(4), atol=1e-7)) assert_false(np.allclose(xforms[-1].as_affine(), np.eye(4), atol=1e-3)) img = load_image(out_fname) npt.assert_almost_equal(original_affine, img.affine)
def group_analysis(design, contrast): """ Compute group analysis effect, sd and t for a given contrast and design type """ array = np.array # shorthand # Directory where output will be written odir = futil.ensure_dir(futil.DATADIR, 'group', design, contrast) # Which subjects have this (contrast, design) pair? subjects = futil.subject_dirs(design, contrast) sd = array([array(load_image(pjoin(s, "sd.nii"))) for s in subjects]) Y = array([array(load_image(pjoin(s, "effect.nii"))) for s in subjects]) # This function estimates the ratio of the # fixed effects variance (sum(1/sd**2, 0)) # to the estimated random effects variance # (sum(1/(sd+rvar)**2, 0)) where # rvar is the random effects variance. # The EM algorithm used is described in # # Worsley, K.J., Liao, C., Aston, J., Petre, V., Duncan, G.H., # Morales, F., Evans, A.C. (2002). \'A general statistical # analysis for fMRI data\'. NeuroImage, 15:1-15 varest = onesample.estimate_varatio(Y, sd) random_var = varest['random'] # XXX - if we have a smoother, use # random_var = varest['fixed'] * smooth(varest['ratio']) # Having estimated the random effects variance (and # possibly smoothed it), the corresponding # estimate of the effect and its variance is # computed and saved. # This is the coordmap we will use coordmap = futil.load_image_fiac("fiac_00","wanatomical.nii").coordmap adjusted_var = sd**2 + random_var adjusted_sd = np.sqrt(adjusted_var) results = onesample.estimate_mean(Y, adjusted_sd) for n in ['effect', 'sd', 't']: im = api.Image(results[n], coordmap.copy()) save_image(im, pjoin(odir, "%s.nii" % n))
def fixed_effects(subj, design): """ Fixed effects (within subject) for FIAC model """ # First, find all the effect and standard deviation images # for the subject and this design type path_dict = futil.path_info2(subj, design) rootdir = path_dict['rootdir'] # The output directory fixdir = pjoin(rootdir, "fixed") results = futil.results_table(path_dict) # Get our hands on the relevant coordmap to # save our results coordmap = futil.load_image_fiac("fiac_%02d" % subj, "wanatomical.nii").coordmap # Compute the "fixed" effects for each type of contrast for con in results: fixed_effect = 0 fixed_var = 0 for effect, sd in results[con]: effect = load_image(effect); sd = load_image(sd) var = np.array(sd)**2 # The optimal, in terms of minimum variance, combination of the # effects has weights 1 / var # # XXX regions with 0 variance are set to 0 # XXX do we want this or np.nan? ivar = np.nan_to_num(1. / var) fixed_effect += effect * ivar fixed_var += ivar # Now, compute the fixed effects variance and t statistic fixed_sd = np.sqrt(fixed_var) isd = np.nan_to_num(1. / fixed_sd) fixed_t = fixed_effect * isd # Save the results odir = futil.ensure_dir(fixdir, con) for a, n in zip([fixed_effect, fixed_sd, fixed_t], ['effect', 'sd', 't']): im = api.Image(a, coordmap.copy()) save_image(im, pjoin(odir, '%s.nii' % n))
def test_save3(): # A test to ensure that when a file is saved, the affine # and the data agree. In this case, things don't agree: # i) the pixdim is off # ii) makes the affine off step = np.array([3.45,2.3,4.5,6.9]) shape = (13,5,7,3) mni_xyz = mni_csm(3).coord_names cmap = AT(CS('jkli'), CS(('t',) + mni_xyz[::-1]), from_matvec(np.diag([0,3,5,1]), step)) data = np.random.standard_normal(shape) img = api.Image(data, cmap) # with InTemporaryDirectory(): with InTemporaryDirectory(): save_image(img, TMP_FNAME) tmp = load_image(TMP_FNAME) # Detach image from file so we can delete it data = tmp.get_data().copy() img2 = api.Image(data, tmp.coordmap, tmp.metadata) del tmp assert_equal(tuple([img.shape[l] for l in [3,2,1,0]]), img2.shape) a = np.transpose(np.asarray(img), [3,2,1,0]) assert_false(np.allclose(img.affine, img2.affine)) assert_true(np.allclose(a, img2.get_data()))
def permutation_test(design, contrast, mask=GROUP_MASK, nsample=1000): """ Perform a permutation (sign) test for a given design type and contrast. It is a Monte Carlo test because we only sample nsample possible sign arrays. Parameters ---------- design: one of ['block', 'event'] contrast: str nsample: int Returns ------- min_vals: np.ndarray max_vals: np.ndarray """ maska = np.asarray(mask).astype(np.bool) subjects = futil.subject_dirs(design, contrast) Y = np.array([np.array(load_image(pjoin(s, "effect.nii")))[:,maska] for s in subjects]) nsubj = Y.shape[0] signs = 2*np.greater(np.random.sample(size=(nsample, nsubj)), 0.5) - 1 min_vals, max_vals = group_analysis_signs(design, contrast, maska, signs) return min_vals, max_vals
def setup(): tmp_img = load_image(funcfile) # For now, img is an Image # instead of an XYZImage A = np.identity(4) A[:3,:3] = tmp_img.affine[:3,:3] A[:3,-1] = tmp_img.affine[:3,-1] xyz_data = tmp_img.get_data() xyz_img = XYZImage(xyz_data, A, tmp_img.axes.coord_names[:3] + ('t',)) # If load_image returns an XYZImage, I'd really be # starting from xyz_img, so from here # Here, I'm just doing this so I know that # img.shape[0] is the number of volumes img = image_rollaxis(Image(xyz_img._data, xyz_img.coordmap), 't') data_dict['nimages'] = img.shape[0] # It might be worth to make # data a public attribute of Image/XYZImage # and we might rename get_data-> data_as_array = np.asarray(self.data) # Then, the above would not access a private attribute # Below, I am just making a mask # because I already have img, I # know I can do this # In principle, though, the pca function # will just take another XYZImage as a mask img_data = img.get_data() first_frame = img_data[0] mask = XYZImage(np.greater(np.asarray(first_frame), 500).astype(np.float64), A, xyz_img.axes.coord_names[:3]) data_dict['fmridata'] = xyz_img data_dict['mask'] = mask data_dict['img'] = img print data_dict['mask'].shape, np.sum(np.array(data_dict['mask']))
def test_subcoordmap(): img = load_image(funcfile) subcoordmap = img[3].coordmap xform = img.coordmap.affine[:,1:] nose.tools.assert_true(np.allclose(subcoordmap.affine[1:], xform[1:])) ## XXX FIXME: why is it [0,0] entry instead of [0] below? nose.tools.assert_true(np.allclose(subcoordmap.affine[0], [0,0,0,img.coordmap([3,0,0,0])[0,0]]))
def test_save2b(): # A test to ensure that when a file is saved, the affine and the # data agree. This image comes from a NIFTI file This example has # a non-diagonal affine matrix for the spatial part, but is # 'diagonal' for the space part. this should raise a warnings # about 'non-diagonal' affine matrix # make a 5x5 transformatio step = np.array([3.45,2.3,4.5,6.9]) A = np.random.standard_normal((4,4)) B = np.diag(list(step)+[1]) B[:4,:4] = A shape = (13,5,7,3) cmap = api.AffineTransform.from_params('ijkt', 'xyzt', B) data = np.random.standard_normal(shape) img = api.Image(data, cmap) save_image(img, tmpfile.name) img2 = load_image(tmpfile.name) yield assert_false, np.allclose(img.affine, img2.affine) yield assert_true, np.allclose(img.affine[:3,:3], img2.affine[:3,:3]) yield assert_equal, img.shape, img2.shape yield assert_true, np.allclose(np.asarray(img2), np.asarray(img))
def adj_from_nii(maskfile, num_time_points, numt=0, numx=1, numy=1, numz=1, regions=None): """ Construct adjacency array from .nii mask file INPUT: maskfile: Path to mask file (.nii) Other parameters are passed directly to prepare_adj (see that function for docs) OUTPUT: adj: An array containing adjacency information """ mask = load_image(maskfile)._data newmask = np.zeros(np.append(num_time_points, mask.shape)) for i in range(num_time_points): newmask[i] = mask adj = prepare_adj(newmask, numt, numx, numy, numz, regions) adj = convert_to_array(adj) return adj
def test_model_out_img(): # Model output image cmap = load_image(anatfile).coordmap shape = (2,3,4) fname = 'myfile.nii' with InTemporaryDirectory(): moi = ModelOutputImage(fname, cmap, shape) for i in range(shape[0]): moi[i] = i for i in range(shape[0]): assert_array_equal(moi[i], i) moi.save() assert_raises(ValueError, moi.__setitem__, 0, 1) assert_raises(ValueError, moi.__getitem__, 0) new_img = load_image(fname) for i in range(shape[0]): assert_array_equal(new_img[i].get_data(), i)
def test_labels1(): img = load_image(funcfile) parcelmap = fromarray(np.asarray(img[0]), 'kji', 'zyx') parcelmap = (np.asarray(parcelmap) * 100).astype(np.int32) v = 0 for i, d in fmri_generator(img, parcels(parcelmap)): v += d.shape[1] assert_equal(v, parcelmap.size)
def test_subcoordmap(): img = load_image(funcfile) subcoordmap = img[3].coordmap xform = img.affine[:, 1:] assert_true(np.allclose(subcoordmap.affine[1:], xform[1:])) assert_true( np.allclose(subcoordmap.affine[0], [0, 0, 0, img.coordmap([3, 0, 0, 0])[0]]))
def setup(): img = load_image(funcfile) arr = img.get_data() #arr = np.rollaxis(arr, 3) data['nimages'] = arr.shape[3] data['fmridata'] = arr frame = data['fmridata'][...,0] data['mask'] = (frame > 500).astype(np.float64)
def test_space_time_realign(): path, fname = psplit(funcfile) original_affine = load_image(funcfile).affine path, fname = psplit(funcfile) froot, _ = fname.split('.', 1) with InTemporaryDirectory(): # Make another image with .nii extension and extra dot in filename save_image(load_image(funcfile), 'my.test.nii') for in_fname, out_fname in ((funcfile, froot + '_mc.nii.gz'), ('my.test.nii', 'my.test_mc.nii.gz')): xforms = reg.space_time_realign(in_fname, 2.0, out_name='.') assert_true( np.allclose(xforms[0].as_affine(), np.eye(4), atol=1e-7)) assert_false( np.allclose(xforms[-1].as_affine(), np.eye(4), atol=1e-3)) img = load_image(out_fname) npt.assert_almost_equal(original_affine, img.affine)
def setup(): img = load_image(funcfile) arr = np.array(img) #arr = np.rollaxis(arr, 3) data['nimages'] = arr.shape[3] data['fmridata'] = arr frame = data['fmridata'][...,0] data['mask'] = (frame > 500).astype(np.float64)
def test_labels1(): img = load_image(funcfile) data = img.get_data() parcelmap = Image(img[0].get_data(), AfT("kji", "zyx", np.eye(4))) parcelmap = (parcelmap.get_data() * 100).astype(np.int32) v = 0 for i, d in axis0_generator(data, parcels(parcelmap)): v += d.shape[1] assert_equal(v, parcelmap.size)
def test_write(): fp, fname = mkstemp('.nii') img = load_image(funcfile) save_image(img, fname) test = FmriImageList.from_image(load_image(fname)) yield assert_equal, test[0].affine.shape, (4,4) yield assert_equal, img[0].affine.shape, (5,4) # Check the affine... A = np.identity(4) A[:3,:3] = img[:,:,:,0].affine[:3,:3] A[:3,-1] = img[:,:,:,0].affine[:3,-1] yield assert_true, np.allclose(test[0].affine, A) # Under windows, if you don't close before delete, you get a # locking error. os.close(fp) os.remove(fname)
def test_model_out_img(): # Model output image cmap = load_image(anatfile).coordmap shape = (2, 3, 4) fname = 'myfile.nii' with InTemporaryDirectory(): moi = ModelOutputImage(fname, cmap, shape) for i in range(shape[0]): moi[i] = i for i in range(shape[0]): assert_array_equal(moi[i], i) moi.save() assert_raises(ValueError, moi.__setitem__, 0, 1) assert_raises(ValueError, moi.__getitem__, 0) new_img = load_image(fname) for i in range(shape[0]): assert_array_equal(new_img[i].get_data(), i) del new_img
def test_labels1(): img = load_image(funcfile) data = img.get_data() parcelmap = Image(img[0].get_data(), AfT('kji', 'zyx', np.eye(4))) parcelmap = (parcelmap.get_data() * 100).astype(np.int32) v = 0 for i, d in axis0_generator(data, parcels(parcelmap)): v += d.shape[1] assert_equal(v, parcelmap.size)
def test_image_list(): img = load_image(funcfile) exp_shape = (17, 21, 3, 20) imglst = ImageList.from_image(img, axis=-1) # Test empty ImageList emplst = ImageList() yield assert_equal(len(emplst.list), 0) # Test non-image construction a = np.arange(10) yield assert_raises(ValueError, ImageList, a) yield assert_raises(ValueError, ImageList.from_image, img, None) # check all the axes for i in range(4): order = range(4) order.remove(i) order.insert(0,i) img_re_i = img.reordered_reference(order).reordered_axes(order) imglst_i = ImageList.from_image(img, axis=i) yield assert_equal(imglst_i.list[0].shape, img_re_i.shape[1:]) # check the affine as well yield assert_almost_equal(imglst_i.list[0].affine, img_re_i.affine[1:,1:]) yield assert_equal(img.shape, exp_shape) # length of image list should match number of frames yield assert_equal(len(imglst.list), img.shape[3]) # check the affine A = np.identity(4) A[:3,:3] = img.affine[:3,:3] A[:3,-1] = img.affine[:3,-1] yield assert_almost_equal(imglst.list[0].affine, A) # Slicing an ImageList should return an ImageList sublist = imglst[2:5] yield assert_true(isinstance(sublist, ImageList)) # Except when we're indexing one element yield assert_true(isinstance(imglst[0], Image)) # Verify array interface # test __array__ yield assert_true(isinstance(np.asarray(sublist), np.ndarray)) # Test __setitem__ sublist[2] = sublist[0] yield assert_equal(np.asarray(sublist[0]).mean(), np.asarray(sublist[2]).mean()) # Test iterator for x in sublist: yield assert_true(isinstance(x, Image)) yield assert_equal(x.shape, exp_shape[:3])
def test_iter(): img = load_image(funcfile) img_shape = img.shape exp_shape = (img_shape[0],) + img_shape[2:] j = 0 for i, d in axis0_generator(img.get_data()): j += 1 assert_equal(d.shape, exp_shape) del(i); gc.collect() assert_equal(j, img_shape[1])
def compare_results(subj, run, other_root, mask_fname): """ Find and compare calculated results images from a previous run This scipt checks that another directory containing results of this same analysis are similar in the sense of numpy ``allclose`` within a brain mask. Parameters ---------- subj : int subject number (1..6) run : int run number (1..12) other_root : str path to previous run estimation mask_fname: path to a mask image defining area in which to compare differences """ # Get information for this subject and run path_dict = path_info_run(subj, run) # Get mask msk = load_image(mask_fname).get_data().copy().astype(bool) # Get results directories for this run rootdir = path_dict['rootdir'] res_dir = pjoin(rootdir, 'results_run%03d' % run) if not isdir(res_dir): return for dirpath, dirnames, filenames in os.walk(res_dir): for fname in filenames: froot, ext = splitext(fname) if froot in ('effect', 'sd', 'F', 't'): this_fname = pjoin(dirpath, fname) other_fname = this_fname.replace(DATADIR, other_root) if not exists(other_fname): print(this_fname, 'present but ', other_fname, 'missing') continue this_arr = load_image(this_fname).get_data() other_arr = load_image(other_fname).get_data() ok = np.allclose(this_arr[msk], other_arr[msk]) if not ok and froot in ('effect', 'sd', 't'): # Maybe a sign flip ok = np.allclose(this_arr[msk], -other_arr[msk]) if not ok: print('Difference between', this_fname, other_fname)
def test_iter(): img = load_image(funcfile) img_shape = img.shape exp_shape = (img_shape[0],) + img_shape[2:] j = 0 for i, d in fmri_generator(img): j += 1 yield assert_equal(d.shape, exp_shape) del(i); gc.collect() yield assert_equal(j, img_shape[1])
def compare_results(subj, run, other_root, mask_fname): """ Find and compare calculated results images from a previous run This scipt checks that another directory containing results of this same analysis are similar in the sense of numpy ``allclose`` within a brain mask. Parameters ---------- subj : int subject number (0..4, 6..15) run : int run number (1..4) other_root : str path to previous run estimation mask_fname: path to a mask image defining area in which to compare differences """ # Get information for this subject and run path_dict = path_info_run(subj, run) # Get mask msk = load_image(mask_fname).get_data().copy().astype(bool) # Get results directories for this run rootdir = path_dict['rootdir'] res_dir = pjoin(rootdir, 'results_%02d' % run) if not isdir(res_dir): return for dirpath, dirnames, filenames in os.walk(res_dir): for fname in filenames: froot, ext = splitext(fname) if froot in ('effect', 'sd', 'F', 't'): this_fname = pjoin(dirpath, fname) other_fname = this_fname.replace(DATADIR, other_root) if not exists(other_fname): print(this_fname, 'present but ', other_fname, 'missing') continue this_arr = load_image(this_fname).get_data() other_arr = load_image(other_fname).get_data() ok = np.allclose(this_arr[msk], other_arr[msk]) if not ok and froot in ('effect', 'sd', 't'): # Maybe a sign flip ok = np.allclose(this_arr[msk], -other_arr[msk]) if not ok: print('Difference between', this_fname, other_fname)
def test_is_image(): # tests for tests for image img = load_image(anatfile) yield assert_true(is_image(img)) class C(object): pass yield assert_false(is_image(C())) class C(object): def __array__(self): pass yield assert_false(is_image(C())) class C(object): coordmap = None def __array__(self): pass yield assert_true(is_image(img))
def get_fmri(path_dict): """Get the images for a given subject/run. Returns ------- fmri : ndarray anat : NIPY image """ fmri_im = load_image( pjoin("%(rootdir)s/swafunctional_%(run)02d.nii") % path_dict) # Make sure we know the order of the coordinates fmri_im = fmri_im.reordered_world('xyzt').reordered_axes('ijkl') return fmri_im
def test_save4(): # Same as test_save3 except we have reordered the 'ijk' input axes. shape = (13,5,7,3) step = np.array([3.45,2.3,4.5,6.9]) # When the input coords are in the 'ljki' order, the affines get # rearranged. Note that the 'start' below, must be 0 for # non-spatial dimensions, because we have no way to store them in # most cases. For example, a 'start' of [1,5,3,1] would be lost on # reload cmap = api.Affine.from_start_step('lkji', 'tzyx', [2,5,3,1], step) data = np.random.standard_normal(shape) img = api.Image(data, cmap) save_image(img, tmpfile.name) img2 = load_image(tmpfile.name) P = np.array([[0,0,0,1,0], [0,0,1,0,0], [0,1,0,0,0], [1,0,0,0,0], [0,0,0,0,1]]) res = np.dot(P, np.dot(img.affine, P.T)) # the step part of the affine should be set correctly yield assert_array_almost_equal, res[:4,:4], img2.affine[:4,:4] # start in the spatial dimensions should be set correctly yield assert_array_almost_equal, res[:3,-1], img2.affine[:3,-1] # start in the time dimension should not be 2 as in img, but 0 # because NIFTI dosen't have a time start yield assert_false, (res[3,-1] == img2.affine[3,-1]) yield assert_true, (res[3,-1] == 2) yield assert_true, (img2.affine[3,-1] == 0) # shapes should be reversed because img has coordinates reversed yield assert_equal, img.shape[::-1], img2.shape # data should be transposed because coordinates are reversed yield (assert_array_almost_equal, np.transpose(np.asarray(img2),[3,2,1,0]), np.asarray(img)) # coordinate names should be reversed as well yield assert_equal, img2.coordmap.input_coords.coord_names, \ img.coordmap.input_coords.coord_names[::-1] yield assert_equal, img2.coordmap.input_coords.coord_names, \ ['i', 'j', 'k', 'l']
def get_fmri(path_dict): """Get the images for a given subject/run. Parameters ---------- path_dict : dict containing key 'rootdir', 'run' Returns ------- fmri : ndarray anat : NIPY image """ fmri_im = load_image( pjoin("%(rootdir)s/swafunctional_%(run)02d.nii") % path_dict) return fmri_im
def get_fmri(path_dict): """Get the images for a given subject/run. Parameters ---------- path_dict : dict containing key 'fsldir', 'run' Returns ------- fmri : ndarray anat : NIPY image """ fmri_im = load_image( pjoin("%(fsldir)s/task001_run%(run)03d.feat/filtered_func_data.nii.gz") % path_dict) return fmri_im
def test_save2(): # A test to ensure that when a file is saved, the affine and the # data agree. This image comes from a NIFTI file shape = (13, 5, 7, 3) step = np.array([3.45, 2.3, 4.5, 6.93]) cmap = api.AffineTransform.from_start_step('ijkt', 'xyzt', [1, 3, 5, 0], step) data = np.random.standard_normal(shape) img = api.Image(data, cmap) with InTemporaryDirectory(): save_image(img, TMP_FNAME) img2 = load_image(TMP_FNAME) assert_array_almost_equal(img.affine, img2.affine) assert_equal(img.shape, img2.shape) assert_array_almost_equal(img2.get_data(), img.get_data()) del img2
def seg_recovery(y_pred, filename): label = load_image(PRE_LABEL_PATH + filename) shape = label.get_data().shape segment = np.zeros(shape) h1 = y_pred[0].around() h2 = y_pred[1].around() area = crop_setting['3d' + str(shape[2])] segment[area['x'][0]:area['x'][1], area['y'][0]:area['y'][1], area['z1'][0]:area['z1'][1], 0] = h1[0] segment[area['x'][0]:area['x'][1], area['y'][0]:area['y'][1], area['z2'][0]:area['z2'][1], 1] = h2[0] img = Image(segment, label.coordmap) save_image(img, OUTPUT + filename)
def adj_from_nii(maskfile, num_time_points, numt=0, numx=1, numy=1, numz=1, regions=None): from nipy.io.api import load_image from nipy.core.api import Image mask = load_image(maskfile)._data return adj_from_3dmask(mask=mask, num_time_points=num_time_points, numt=numt, numx=numx, numy=numy, numz=numz, regions=regions)
def test_run(): ar1_fname = 'ar1_out.nii' funcim = load_image(funcfile) fmriims = FmriImageList.from_image(funcim, volume_start_times=2.) one_vol = fmriims[0] # Formula - with an intercept t = Term('t') f = Formula([t, t**2, t**3, 1]) # Design matrix and contrasts time_vector = make_recarray(fmriims.volume_start_times, 't') con_defs = dict(c=t, c2=t + t**2) desmtx, cmatrices = f.design(time_vector, contrasts=con_defs) # Run with Image and ImageList for inp_img in (rollimg(funcim, 't'), fmriims): with InTemporaryDirectory(): # Run OLS model outputs = [] outputs.append(model.output_AR1(ar1_fname, fmriims)) outputs.append(model.output_resid('resid_OLS_out.nii', fmriims)) ols = model.OLS(fmriims, f, outputs) ols.execute() # Run AR1 model outputs = [] outputs.append(model.output_T('T_out.nii', cmatrices['c'], fmriims)) outputs.append( model.output_F('F_out.nii', cmatrices['c2'], fmriims)) outputs.append(model.output_resid('resid_AR_out.nii', fmriims)) rho = load_image(ar1_fname) ar = model.AR1(fmriims, f, rho, outputs) ar.execute() f_img = load_image('F_out.nii') assert_equal(f_img.shape, one_vol.shape) f_data = f_img.get_data() assert_true(np.all((f_data >= 0) & (f_data < 30))) resid_img = load_image('resid_AR_out.nii') assert_equal(resid_img.shape, funcim.shape) assert_array_almost_equal(np.mean(resid_img.get_data()), 0, 3) e_img = load_image('T_out_effect.nii') sd_img = load_image('T_out_sd.nii') t_img = load_image('T_out_t.nii') t_data = t_img.get_data() assert_array_almost_equal(t_data, e_img.get_data() / sd_img.get_data()) assert_true(np.all(np.abs(t_data) < 6)) # Need to delete to help windows delete temporary files del rho, resid_img, f_img, e_img, sd_img, t_img, f_data, t_data
def test_save4(): # Same as test_save3 except we have reordered the 'ijk' input axes. shape = (13, 5, 7, 3) step = np.array([3.45, 2.3, 4.5, 6.9]) # When the input coords are in the 'ljki' order, the affines get # rearranged. Note that the 'start' below, must be 0 for # non-spatial dimensions, because we have no way to store them in # most cases. For example, a 'start' of [1,5,3,1] would be lost on # reload mni_xyz = mni_csm(3).coord_names cmap = AT(CS('tkji'), CS((('t', ) + mni_xyz[::-1])), from_matvec(np.diag([2., 3, 5, 1]), step)) data = np.random.standard_normal(shape) img = api.Image(data, cmap) with InTemporaryDirectory(): save_image(img, TMP_FNAME) tmp = load_image(TMP_FNAME) data = tmp.get_data().copy() # Detach image from file so we can delete it img2 = api.Image(data, tmp.coordmap, tmp.metadata) del tmp P = np.array([[0, 0, 0, 1, 0], [0, 0, 1, 0, 0], [0, 1, 0, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 0, 1]]) res = np.dot(P, np.dot(img.affine, P.T)) # the step part of the affine should be set correctly assert_array_almost_equal(res[:4, :4], img2.affine[:4, :4]) # start in the spatial dimensions should be set correctly assert_array_almost_equal(res[:3, -1], img2.affine[:3, -1]) # start in the time dimension should be 3.45 as in img, because NIFTI stores # the time offset in hdr[``toffset``] assert_not_equal(res[3, -1], img2.affine[3, -1]) assert_equal(res[3, -1], 3.45) # shapes should be reversed because img has coordinates reversed assert_equal(img.shape[::-1], img2.shape) # data should be transposed because coordinates are reversed assert_array_almost_equal(np.transpose(img2.get_data(), [3, 2, 1, 0]), img.get_data()) # coordinate names should be reversed as well assert_equal(img2.coordmap.function_domain.coord_names, img.coordmap.function_domain.coord_names[::-1]) assert_equal(img2.coordmap.function_domain.coord_names, ('i', 'j', 'k', 't'))
def test_save2b(): # A test to ensure that when a file is saved, the affine and the # data agree. This image comes from a NIFTI file. This example has a # non-diagonal affine matrix for the spatial part, but is 'diagonal' for the # space part. # # make a 5x5 transformation (for 4d image) step = np.array([3.45, 2.3, 4.5, 6.9]) A = np.random.standard_normal((3, 3)) B = np.diag(list(step) + [1]) B[:3, :3] = A shape = (13, 5, 7, 3) cmap = api.vox2mni(B) data = np.random.standard_normal(shape) img = api.Image(data, cmap) with InTemporaryDirectory(): save_image(img, TMP_FNAME) img2 = load_image(TMP_FNAME) assert_array_almost_equal(img.affine, img2.affine) assert_equal(img.shape, img2.shape) assert_array_almost_equal(img2.get_data(), img.get_data()) del img2
def test_save3(): # A test to ensure that when a file is saved, the affine # and the data agree. In this case, things don't agree: # i) the pixdim is off # ii) makes the affine off step = np.array([3.45, 2.3, 4.5, 6.9]) shape = (13, 5, 7, 3) mni_xyz = mni_csm(3).coord_names cmap = AT(CS('jkli'), CS(('t', ) + mni_xyz[::-1]), from_matvec(np.diag([0, 3, 5, 1]), step)) data = np.random.standard_normal(shape) img = api.Image(data, cmap) # with InTemporaryDirectory(): with InTemporaryDirectory(): save_image(img, TMP_FNAME) tmp = load_image(TMP_FNAME) # Detach image from file so we can delete it data = tmp.get_data().copy() img2 = api.Image(data, tmp.coordmap, tmp.metadata) del tmp assert_equal(tuple([img.shape[l] for l in [3, 2, 1, 0]]), img2.shape) a = np.transpose(img.get_data(), [3, 2, 1, 0]) assert_false(np.allclose(img.affine, img2.affine)) assert_true(np.allclose(a, img2.get_data()))
import os from mgni.smooth import smooth import json mode = 'SVR' # SVC or SVR root = '/data/fmri/simu/' # roi_name = '%s_Fusiform_posterior_AAL.nii' % mode roi_name = '%s_wholebrain.nii' % mode mask = '/home/matteo/science/fmri/roi/example_mask.nii' roi = '/home/matteo/science/fmri/roi/example_mask.nii' # roi = '/home/matteo/science/fmri/roi/AAL/rFusiform_posterior_AAL.nii' n_subjects = 16 fwhm = 10 img_mask = load_image(mask) img_mask = Image(img_mask.get_data().astype(np.float64), img_mask.coordmap, img_mask.header) img_roi = load_image(roi) img_roi = Image(img_roi.get_data().astype(np.float64), img_roi.coordmap, img_roi.header) ind_roi = img_roi.get_data().astype(bool) & img_mask.get_data().astype(bool) ind_noroi = ~img_roi.get_data().astype(bool) & img_mask.get_data().astype(bool) roi_data = np.random.randn(np.sum(ind_roi)) for i in range(1, n_subjects + 1): print('subject %02g' % i) s_dir = os.path.join(root, '%02g' % i)
def load_image(self, filename): self.img = load_image(filename) self.filename = filename print 'Opening file:', filename self.axes_order = self._axes_order_from_orientation() self.update_data()
def group_analysis_signs(design, contrast, mask, signs=None): """ Refit the EM model with a vector of signs. Used in the permutation tests. Returns the maximum of the T-statistic within mask Parameters ---------- design: one of 'block', 'event' contrast: str name of contrast to estimate mask : ``Image`` instance or array-like image containing mask, or array-like signs: ndarray, optional Defaults to np.ones. Should have shape (*,nsubj) where nsubj is the number of effects combined in the group analysis. Returns ------- minT: np.ndarray, minima of T statistic within mask, one for each vector of signs maxT: np.ndarray, maxima of T statistic within mask, one for each vector of signs """ if api.is_image(mask): maska = mask.get_data() else: maska = np.asarray(mask) maska = maska.astype(np.bool) # Which subjects have this (contrast, design) pair? subj_con_dirs = futil.subj_des_con_dirs(design, contrast) # Assemble effects and sds into 4D arrays sds = [] Ys = [] for s in subj_con_dirs: sd_img = load_image(pjoin(s, "sd.nii")) effect_img = load_image(pjoin(s, "effect.nii")) sds.append(sd_img.get_data()[maska]) Ys.append(effect_img.get_data()[maska]) sd = np.array(sds) Y = np.array(Ys) if signs is None: signs = np.ones((1, Y.shape[0])) maxT = np.empty(signs.shape[0]) minT = np.empty(signs.shape[0]) for i, sign in enumerate(signs): signY = sign[:, np.newaxis] * Y varest = onesample.estimate_varatio(signY, sd) random_var = varest['random'] adjusted_var = sd**2 + random_var adjusted_sd = np.sqrt(adjusted_var) results = onesample.estimate_mean(Y, adjusted_sd) T = results['t'] minT[i], maxT[i] = np.nanmin(T), np.nanmax(T) return minT, maxT
def test_resample_img2img(): fimg = load_image(funcfile) aimg = load_image(anatfile) resimg = resample_img2img(fimg, fimg) yield assert_true, np.allclose(resimg.get_data(), fimg.get_data()) yield assert_raises, ValueError, resample_img2img, fimg, aimg
from numpy.testing import assert_array_almost_equal from nipy.testing import funcfile def setup(): # Suppress warnings during tests to reduce noise warnings.simplefilter("ignore") def teardown(): # Clear list of warning filters warnings.resetwarnings() # Module globals FIMG = load_image(funcfile) # Put time on first axis FIMG = rollimg(FIMG, 't') FDATA = FIMG.get_data() FIL = FmriImageList.from_image(FIMG) # I think it makes more sense to use FDATA instead of FIL for GLM # purposes -- reduces some noticeable overhead in creating the # array from FmriImageList # create a design matrix, model and contrast matrix DESIGN = noise((FDATA.shape[0], 3)) MODEL = OLSModel(DESIGN) CMATRIX = np.array([[1, 0, 0], [0, 1, 0]])
def load_image_ds105(*path): """Return a NIPY image from a set of path components. """ return load_image(pjoin(DATADIR, *path))