def test_niml_dset_voxsel(self):
if not externals.exists('nibabel'):
return
# This is actually a bit of an integration test.
# It tests storing and retrieving searchlight results.
# Imports are inline here so that it does not mess up the header
# and makes the other unit tests more modular
# XXX put this in a separate file?
from mvpa2.misc.surfing import volgeom, surf_voxel_selection, queryengine
from mvpa2.measures.searchlight import Searchlight
from mvpa2.support.nibabel import surf
from mvpa2.measures.base import Measure
from mvpa2.datasets.mri import fmri_dataset
class _Voxel_Count_Measure(Measure):
# used to check voxel selection results
is_trained = True
def __init__(self, dtype, **kwargs):
Measure.__init__(self, **kwargs)
self.dtype = dtype
def _call(self, dset):
return self.dtype(dset.nfeatures)
sh = (20, 20, 20)
vg = volgeom.VolGeom(sh, np.identity(4))
density = 20
outer = surf.generate_sphere(density) * 10. + 5
inner = surf.generate_sphere(density) * 5. + 5
intermediate = outer * .5 + inner * .5
xyz = intermediate.vertices
radius = 50
sel = surf_voxel_selection.run_voxel_selection(radius, vg, inner,
outer)
qe = queryengine.SurfaceVerticesQueryEngine(sel)
for dtype in (int, float):
sl = Searchlight(_Voxel_Count_Measure(dtype), queryengine=qe)
ds = fmri_dataset(vg.get_empty_nifti_image(1))
r = sl(ds)
_, fn = tempfile.mkstemp('.niml.dset', 'dset')
niml_dset.write(fn, r)
rr = niml_dset.read(fn)
os.remove(fn)
assert_array_equal(r.samples, rr.samples)
def test_agreement_surface_volume(self):
'''test agreement between volume-based and surface-based
searchlights when using euclidean measure'''
# import runner
def sum_ds(ds):
return np.sum(ds)
radius = 3
# make a small dataset with a mask
sh = (10, 10, 10)
msk = np.zeros(sh)
for i in xrange(0, sh[0], 2):
msk[i, :, :] = 1
vg = volgeom.VolGeom(sh, np.identity(4), mask=msk)
# make an image
nt = 6
img = vg.get_masked_nifti_image(6)
ds = fmri_dataset(img, mask=msk)
# run the searchlight
sl = sphere_searchlight(sum_ds, radius=radius)
m = sl(ds)
# now use surface-based searchlight
v = volsurf.from_volume(ds)
source_surf = v.intermediate_surface
node_msk = np.logical_not(np.isnan(source_surf.vertices[:, 0]))
# check that the mask matches with what we used earlier
assert_array_equal(msk.ravel() + 0., node_msk.ravel() + 0.)
source_surf_nodes = np.nonzero(node_msk)[0]
sel = surf_voxel_selection.voxel_selection(
v,
float(radius),
source_surf=source_surf,
source_surf_nodes=source_surf_nodes,
distance_metric='euclidean')
qe = queryengine.SurfaceVerticesQueryEngine(sel)
sl = Searchlight(sum_ds, queryengine=qe)
r = sl(ds)
# check whether they give the same results
assert_array_equal(r.samples, m.samples)
def test_surf_voxel_selection(self):
vol_shape = (10, 10, 10)
vol_affine = np.identity(4)
vol_affine[0, 0] = vol_affine[1, 1] = vol_affine[2, 2] = 5
vg = volgeom.VolGeom(vol_shape, vol_affine)
density = 10
outer = surf.generate_sphere(density) * 25. + 15
inner = surf.generate_sphere(density) * 20. + 15
vs = volsurf.VolSurfMaximalMapping(vg, outer, inner)
nv = outer.nvertices
# select under variety of parameters
# parameters are distance metric (dijkstra or euclidean),
# radius, and number of searchlight centers
params = [('d', 1., 10), ('d', 1., 50), ('d', 1., 100), ('d', 2., 100),
('e', 2., 100), ('d', 2., 100), ('d', 20, 100),
('euclidean', 5, None), ('dijkstra', 10, None)]
# function that indicates for which parameters the full test is run
test_full = lambda x: len(x[0]) > 1 or x[2] == 100
expected_labs = ['grey_matter_position', 'center_distances']
voxcount = []
tested_double_features = False
for param in params:
distance_metric, radius, ncenters = param
srcs = range(0, nv, nv // (ncenters or nv))
sel = surf_voxel_selection.voxel_selection(
vs,
radius,
source_surf_nodes=srcs,
distance_metric=distance_metric)
# see how many voxels were selected
vg = sel.volgeom
datalin = np.zeros((vg.nvoxels, 1))
mp = sel
for k, idxs in mp.iteritems():
if idxs is not None:
datalin[idxs] = 1
voxcount.append(np.sum(datalin))
if test_full(param):
assert_equal(np.sum(datalin), np.sum(sel.get_mask()))
assert_true(len('%s%r' % (sel, sel)) > 0)
# see if voxels containing inner and outer
# nodes were selected
for sf in [inner, outer]:
for k, idxs in mp.iteritems():
xyz = np.reshape(sf.vertices[k, :], (1, 3))
linidx = vg.xyz2lin(xyz)
# only required if xyz is actually within the volume
assert_equal(linidx in idxs, vg.contains_lin(linidx))
# check that it has all the attributes
labs = sel.aux_keys()
assert_true(all([lab in labs for lab in expected_labs]))
if externals.exists('h5py'):
# some I/O testing
fd, fn = tempfile.mkstemp('.h5py', 'test')
os.close(fd)
h5save(fn, sel)
sel2 = h5load(fn)
os.remove(fn)
assert_equal(sel, sel2)
else:
sel2 = sel
# check that mask is OK even after I/O
assert_array_equal(sel.get_mask(), sel2.get_mask())
# test I/O with surfaces
# XXX the @tempfile decorator only supports a single filename
# hence this method does not use it
fd, outerfn = tempfile.mkstemp('outer.asc', 'test')
os.close(fd)
fd, innerfn = tempfile.mkstemp('inner.asc', 'test')
os.close(fd)
fd, volfn = tempfile.mkstemp('vol.nii', 'test')
os.close(fd)
surf.write(outerfn, outer, overwrite=True)
surf.write(innerfn, inner, overwrite=True)
img = sel.volgeom.get_empty_nifti_image()
img.to_filename(volfn)
sel3 = surf_voxel_selection.run_voxel_selection(
radius,
volfn,
innerfn,
outerfn,
source_surf_nodes=srcs,
distance_metric=distance_metric)
outer4 = surf.read(outerfn)
inner4 = surf.read(innerfn)
vsm4 = vs = volsurf.VolSurfMaximalMapping(vg, inner4, outer4)
# check that two ways of voxel selection match
sel4 = surf_voxel_selection.voxel_selection(
vsm4,
radius,
source_surf_nodes=srcs,
distance_metric=distance_metric)
assert_equal(sel3, sel4)
os.remove(outerfn)
os.remove(innerfn)
os.remove(volfn)
# compare sel3 with other selection results
# NOTE: which voxels are precisely selected by sel can be quite
# off from those in sel3, as writing the surfaces imposes
# rounding errors and the sphere is very symmetric, which
# means that different neighboring nodes are selected
# to select a certain number of voxels.
sel3cmp_difference_ratio = [(sel, .2), (sel4, 0.)]
for selcmp, ratio in sel3cmp_difference_ratio:
nunion = ndiff = 0
for k in selcmp.keys():
p = set(sel3.get(k))
q = set(selcmp.get(k))
nunion += len(p.union(q))
ndiff += len(p.symmetric_difference(q))
assert_true(float(ndiff) / float(nunion) <= ratio)
# check searchlight call
# as of late Aug 2012, this is with the fancy query engine
# as implemented by Yarik
mask = sel.get_mask()
keys = None if ncenters is None else sel.keys()
dset_data = np.reshape(np.arange(vg.nvoxels), vg.shape)
dset_img = nb.Nifti1Image(dset_data, vg.affine)
dset = fmri_dataset(samples=dset_img, mask=mask)
qe = queryengine.SurfaceVerticesQueryEngine(
sel,
# you can optionally add additional
# information about each near-disk-voxels
add_fa=['center_distances', 'grey_matter_position'])
# test i/o ensuring that when loading it is still trained
if externals.exists('h5py'):
fd, qefn = tempfile.mkstemp('qe.hdf5', 'test')
os.close(fd)
h5save(qefn, qe)
qe = h5load(qefn)
os.remove(qefn)
assert_false('ERROR' in repr(qe)) # to check if repr works
voxelcounter = _Voxel_Count_Measure()
searchlight = Searchlight(
voxelcounter,
queryengine=qe,
roi_ids=keys,
nproc=1,
enable_ca=['roi_feature_ids', 'roi_center_ids'])
sl_dset = searchlight(dset)
selected_count = sl_dset.samples[0, :]
mp = sel
for i, k in enumerate(sel.keys()):
# check that number of selected voxels matches
assert_equal(selected_count[i], len(mp[k]))
assert_equal(searchlight.ca.roi_center_ids, sel.keys())
assert_array_equal(sl_dset.fa['center_ids'], qe.ids)
# check nearest node is *really* the nearest node
allvx = sel.get_targets()
intermediate = outer * .5 + inner * .5
for vx in allvx:
nearest = sel.target2nearest_source(vx)
xyz = intermediate.vertices[nearest, :]
sqsum = np.sum((xyz - intermediate.vertices)**2, 1)
idx = np.argmin(sqsum)
assert_equal(idx, nearest)
if not tested_double_features: # test only once
# see if we have multiple features for the same voxel, we would get them all
dset1 = dset.copy()
dset1.fa['dset'] = [1]
dset2 = dset.copy()
dset2.fa['dset'] = [2]
dset_ = hstack((dset1, dset2), 'drop_nonunique')
dset_.sa = dset1.sa
# dset_.a.imghdr = dset1.a.imghdr
assert_true('imghdr' in dset_.a.keys())
assert_equal(dset_.a['imghdr'].value,
dset1.a['imghdr'].value)
roi_feature_ids = searchlight.ca.roi_feature_ids
sl_dset_ = searchlight(dset_)
# and we should get twice the counts
assert_array_equal(sl_dset_.samples, sl_dset.samples * 2)
# compare old and new roi_feature_ids
assert (len(roi_feature_ids) == len(
searchlight.ca.roi_feature_ids))
nfeatures = dset.nfeatures
for old, new in zip(roi_feature_ids,
searchlight.ca.roi_feature_ids):
# each new ids should comprise of old ones + (old + nfeatures)
# since we hstack'ed two datasets
assert_array_equal(
np.hstack([(x, x + nfeatures) for x in old]), new)
tested_double_features = True
# check whether number of voxels were selected is as expected
expected_voxcount = [22, 93, 183, 183, 183, 183, 183, 183, 183]
assert_equal(voxcount, expected_voxcount)