def test_volgeom_masking(self):
maskstep = 5
vg = volgeom.VolGeom((2 * maskstep, 2 * maskstep, 2 * maskstep), np.identity(4))
mask = vg.get_empty_array()
sh = vg.shape
# mask a subset of the voxels
rng = range(0, sh[0], maskstep)
for i in rng:
for j in rng:
for k in rng:
mask[i, j, k] = 1
# make a new volgeom instance
vg = volgeom.VolGeom(vg.shape, vg.affine, mask)
data = vg.get_masked_nifti_image(nt=1)
msk = vg.get_masked_nifti_image()
dset = fmri_dataset(data, mask=msk)
vg_dset = volgeom.from_any(dset)
# ensure that the mask is set properly and
assert_equal(vg.nvoxels, vg.nvoxels_mask * maskstep ** 3)
assert_equal(vg_dset, vg)
dilates = range(0, 8, 2)
nvoxels_masks = [] # keep track of number of voxels for each size
for dilate in dilates:
covers_full_volume = dilate * 2 >= maskstep * 3 ** .5 + 1
# constr gets values: None, Sphere(0), 2, Sphere(2), ...
for i, constr in enumerate([Sphere, lambda x:x if x else None]):
dilater = constr(dilate)
img_dilated = vg.get_masked_nifti_image(dilate=dilater)
data = img_dilated.get_data()
assert_array_equal(data, vg.get_masked_array(dilate=dilater))
n = np.sum(data)
# number of voxels in mask is increasing
assert_true(all(n >= p for p in nvoxels_masks))
# results should be identical irrespective of constr
if i == 0:
# - first call with this value of dilate: has to be more
# voxels than very previous dilation value, unless the
# full volume is covered - then it can be equal too
# - every next call: ensure size matches
cmp = lambda x, y:(x >= y if covers_full_volume else x > y)
assert_true(all(cmp(n, p) for p in nvoxels_masks))
nvoxels_masks.append(n)
else:
# same size as previous call
assert_equal(n, nvoxels_masks[-1])
# if dilate is not None or zero, then it should
# have selected all the voxels if the radius is big enough
assert_equal(np.sum(data) == vg.nvoxels, covers_full_volume)
def test_queryengine_io(self, fn):
skip_if_no_external('h5py')
from mvpa2.base.hdf5 import h5save, h5load
vol_shape = (10, 10, 10, 1)
vol_affine = np.identity(4)
vg = volgeom.VolGeom(vol_shape, vol_affine)
# generate some surfaces,
# and add some noise to them
sphere_density = 10
outer = surf.generate_sphere(sphere_density) * 5 + 8
inner = surf.generate_sphere(sphere_density) * 3 + 8
radius = 5.
add_fa = ['center_distances', 'grey_matter_position']
qe = disc_surface_queryengine(radius, vg, inner, outer, add_fa=add_fa)
ds = fmri_dataset(vg.get_masked_nifti_image())
# the following is not really a strong requirement. XXX remove?
assert_raises(ValueError, lambda: qe[qe.ids[0]])
# check that after training it behaves well
qe.train(ds)
i = qe.ids[0]
try:
m = qe[i]
except ValueError, e:
raise AssertionError(
'Failed to query %r from %r after training on %r. Exception was: %r'
% (i, qe, ds, e))
def test_surface_voxel_query_engine(self):
vol_shape = (10, 10, 10, 1)
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)
# make the surfaces
sphere_density = 10
outer = surf.generate_sphere(sphere_density) * 25. + 15
inner = surf.generate_sphere(sphere_density) * 20. + 15
vs = volsurf.VolSurfMaximalMapping(vg, inner, outer)
radius = 10
for fallback, expected_nfeatures in ((True, 1000), (False, 183)):
voxsel = surf_voxel_selection.voxel_selection(vs, radius)
qe = SurfaceVoxelsQueryEngine(voxsel,
fallback_euclidian_distance=fallback)
m = _Voxel_Count_Measure()
sl = Searchlight(m, queryengine=qe)
data = np.random.normal(size=vol_shape)
img = nb.Nifti1Image(data, vol_affine)
ds = fmri_dataset(img)
sl_map = sl(ds)
counts = sl_map.samples
assert_true(np.all(np.logical_and(5 <= counts, counts <= 18)))
assert_equal(sl_map.nfeatures, expected_nfeatures)
def test_h5support(self):
sh = (20, 20, 20)
msk = np.zeros(sh)
for i in xrange(0, sh[0], 2):
msk[i, :, :] = 1
vg = volgeom.VolGeom(sh, np.identity(4), mask=msk)
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
backends = ['native', 'hdf5']
for i, backend in enumerate(backends):
if backend == 'hdf5' and not externals.exists('h5py'):
continue
sel = surf_voxel_selection.run_voxel_selection(
radius, vg, inner, outer, results_backend=backend)
if i == 0:
sel0 = sel
else:
assert_equal(sel0, sel)
def test_volsurf_projections(self):
white = surf.generate_plane((0, 0, 0), (0, 1, 0), (0, 0, 1), 10, 10)
pial = white + np.asarray([[1, 0, 0]])
above = pial + np.asarray([[3, 0, 0]])
vg = volgeom.VolGeom((10, 10, 10), np.eye(4))
vs = volsurf.VolSurfMaximalMapping(vg, white, pial)
dx = pial.vertices - white.vertices
for s, w in ((white, 0), (pial, 1), (above, 4)):
xyz = s.vertices
ws = vs.surf_project_weights(True, xyz)
delta = vs.surf_unproject_weights_nodewise(ws) - xyz
assert_array_equal(delta, np.zeros((100, 3)))
assert_true(np.all(w == ws))
vs = volsurf.VolSurfMaximalMapping(vg, white, pial, nsteps=2)
n2vs = vs.get_node2voxels_mapping()
assert_equal(n2vs, dict((i, {
i: 0.,
i + 100: 1.
}) for i in xrange(100)))
nd = 17
ds_mm_expected = np.sum((above.vertices - pial.vertices[nd, :])**2,
1)**.5
ds_mm = vs.coordinates_to_grey_distance_mm(nd, above.vertices)
assert_array_almost_equal(ds_mm_expected, ds_mm)
ds_mm_nodewise = vs.coordinates_to_grey_distance_mm(
True, above.vertices)
assert_array_equal(ds_mm_nodewise, np.ones((100, )) * 3)
def test_surface_minimal_voxel_selection(self):
# Tests 'minimal' voxel selection.
# It assumes that 'maximal' voxel selection works (which is tested
# in other unit tests)
vol_shape = (10, 10, 10, 1)
vol_affine = np.identity(4)
vg = volgeom.VolGeom(vol_shape, vol_affine)
# generate some surfaces,
# and add some noise to them
sphere_density = 10
nvertices = sphere_density**2 + 2
noise = np.random.uniform(size=(nvertices, 3))
outer = surf.generate_sphere(sphere_density) * 5 + 8 + noise
inner = surf.generate_sphere(sphere_density) * 3 + 8 + noise
radii = [5., 20., 10] # note: no fixed radii at the moment
# Note: a little outside margin is necessary
# as otherwise there are nodes in the minimal case
# that have no voxels associated with them
for radius in radii:
for output_modality in ('surface', 'volume'):
for i, nvm in enumerate(('minimal', 'maximal')):
qe = disc_surface_queryengine(
radius,
vg,
inner,
outer,
node_voxel_mapping=nvm,
output_modality=output_modality)
voxsel = qe.voxsel
if i == 0:
keys_ = voxsel.keys()
voxsel_ = voxsel
else:
keys = voxsel.keys()
# minimal one has a subset
assert_equal(keys, keys_)
# and the subset is quite overlapping
assert_true(len(keys) * .90 < len(keys_))
for k in keys_:
x = set(voxsel_[k])
y = set(voxsel[k])
d = set.symmetric_difference(x, y)
r = float(len(d)) / 2 / len(x)
if type(radius) is float:
assert_equal(x - y, set())
# decent agreement in any case
# between the two sets
assert_true(r < .6)
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_surface_outside_volume_voxel_selection(self, fn):
skip_if_no_external('h5py')
from mvpa2.base.hdf5 import h5save, h5load
vol_shape = (10, 10, 10, 1)
vol_affine = np.identity(4)
vg = volgeom.VolGeom(vol_shape, vol_affine)
# make surfaces that are far away from all voxels
# in the volume
sphere_density = 4
far = 10000.
outer = surf.generate_sphere(sphere_density) * 10 + far
inner = surf.generate_sphere(sphere_density) * 5 + far
vs = volsurf.VolSurfMaximalMapping(vg, inner, outer)
radii = [10., 10] # fixed and variable radii
outside_node_margins = [0, far, True]
for outside_node_margin in outside_node_margins:
for radius in radii:
selector = lambda: surf_voxel_selection.voxel_selection(vs,
radius,
outside_node_margin=outside_node_margin)
if type(radius) is int and outside_node_margin is True:
assert_raises(ValueError, selector)
else:
sel = selector()
if outside_node_margin is True:
# it should have all the keys, but they should
# all be empty
assert_array_equal(sel.keys(), range(inner.nvertices))
for k, v in sel.iteritems():
assert_equal(v, [])
else:
assert_array_equal(sel.keys(), [])
if outside_node_margin is True and \
externals.versions['hdf5'] < '1.8.7':
raise SkipTest("Versions of hdf5 before 1.8.7 have "
"problems with empty arrays")
h5save(fn, sel)
sel_copy = h5load(fn)
assert_array_equal(sel.keys(), sel_copy.keys())
for k in sel.keys():
assert_equal(sel[k], sel_copy[k])
assert_equal(sel, sel_copy)
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_volsurf(self):
vg = volgeom.VolGeom((50, 50, 50), np.identity(4))
density = 40
outer = surf.generate_sphere(density) * 25. + 25
inner = surf.generate_sphere(density) * 20. + 25
# increasingly select more voxels in 'grey matter'
steps_start_stop = [(1, .5, .5), (5, .5, .5), (3, .3, .7), (5, .3, .7),
(5, 0., 1.), (10, 0., 1.)]
mp = None
expected_keys = set(range(density**2 + 2))
selection_counter = []
voxel_counter = []
for sp, sa, so in steps_start_stop:
vs = volsurf.VolSurfMaximalMapping(vg, outer, inner,
(outer + inner) * .5, sp, sa,
so)
n2v = vs.get_node2voxels_mapping()
if mp is None:
mp = n2v
assert_equal(expected_keys, set(n2v.keys()))
counter = 0
for k, v2pos in n2v.iteritems():
for v, pos in v2pos.iteritems():
# should be close to grey matter
assert_true(-1. <= pos <= 2.)
counter += 1
selection_counter.append(counter)
img = vs.voxel_count_nifti_image()
voxel_counter.append(np.sum(img.get_data() > 0))
# hard coded number of expected voxels
selection_expected = [1602, 1602, 4618, 5298, 7867, 10801]
assert_equal(selection_counter, selection_expected)
voxel_expected = [1498, 1498, 4322, 4986, 7391, 10141]
assert_equal(voxel_counter, voxel_expected)
# check that string building works
assert_true(len('%s%r' % (vs, vs)) > 0)
def test_surface_minimal_lowres_voxel_selection(self, fn):
vol_shape = (4, 10, 10, 1)
vol_affine = np.identity(4)
vg = volgeom.VolGeom(vol_shape, vol_affine)
# make surfaces that are far away from all voxels
# in the volume
sphere_density = 10
radius = 10
outer = surf.generate_plane((0, 0, 4), (0, .4, 0), (0, 0, .4), 14, 14)
inner = outer + 2
source = surf.generate_plane((0, 0, 4), (0, .8, 0),
(0, 0, .8), 7, 7) + 1
for i, nvm in enumerate(('minimal', 'minimal_lowres')):
qe = disc_surface_queryengine(radius,
vg,
inner,
outer,
source,
node_voxel_mapping=nvm)
voxsel = qe.voxsel
if i == 0:
voxsel0 = voxsel
else:
assert_equal(voxsel.keys(), voxsel0.keys())
for k in voxsel.keys():
p = voxsel[k]
q = voxsel0[k]
# require at least 60% agreement
delta = set.symmetric_difference(set(p), set(q))
assert_true(len(delta) < .8 * (len(p) + len(q)))
if externals.exists('h5py'):
from mvpa2.base.hdf5 import h5save, h5load
h5save(fn, voxsel)
voxsel_copy = h5load(fn)
assert_equal(voxsel.keys(), voxsel_copy.keys())
for id in qe.ids:
assert_array_equal(voxsel.get(id), voxsel_copy.get(id))
def test_minimal_dataset(self):
vol_shape = (10, 10, 10, 3)
vol_affine = np.identity(4)
vg = volgeom.VolGeom(vol_shape, vol_affine)
data = np.random.normal(size=vol_shape)
msk = np.ones(vol_shape[:3])
msk[:, 1:-1:2, :] = 0
ni_data = nb.Nifti1Image(data, vol_affine)
ni_msk = nb.Nifti1Image(msk, vol_affine)
ds = fmri_dataset(ni_data, mask=ni_msk)
sphere_density = 20
outer = surf.generate_sphere(sphere_density) * 10. + 5
inner = surf.generate_sphere(sphere_density) * 7. + 5
radius = 10
sel = surf_voxel_selection.run_voxel_selection(radius, ds,
inner, outer)
sel_fids = set.union(*(set(sel[k]) for k in sel.keys()))
ds_vox = map(tuple, ds.fa.voxel_indices)
vg = sel.volgeom
sel_vox = map(tuple, vg.lin2ijk(np.asarray(list(sel_fids))))
fid_mask = np.asarray([v in sel_vox for v in ds_vox])
assert_array_equal(fid_mask, sel.get_dataset_feature_mask(ds))
# check if it raises errors
ni_neg_msk = nb.Nifti1Image(1 - msk, vol_affine)
neg_ds = fmri_dataset(ni_data, mask=ni_neg_msk) # inverted mask
assert_raises(ValueError, sel.get_dataset_feature_mask, neg_ds)
min_ds = sel.get_minimal_dataset(ds)
assert_array_equal(min_ds.samples, ds[:, fid_mask].samples)
def test_volsurf_surf_from_volume(self):
aff = np.eye(4)
aff[0, 0] = aff[1, 1] = aff[2, 2] = 3
sh = (40, 40, 40)
vg = volgeom.VolGeom(sh, aff)
p = volsurf.from_volume(vg).intermediate_surface
q = volsurf.VolumeBasedSurface(vg)
centers = [0, 10, 10000, (-1, -1, -1), (5, 5, 5)]
radii = [0, 10, 20, 100]
for center in centers:
for radius in radii:
x = p.circlearound_n2d(center, radius)
y = q.circlearound_n2d(center, radius)
assert_equal(x, y)
def test_surface_voxel_query_engine(self):
vol_shape = (10, 10, 10, 1)
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)
# make the surfaces
sphere_density = 10
outer = surf.generate_sphere(sphere_density) * 25. + 15
inner = surf.generate_sphere(sphere_density) * 20. + 15
vs = volsurf.VolSurfMaximalMapping(vg, inner, outer)
radius = 10
for fallback, expected_nfeatures in ((True, 1000), (False, 183)):
voxsel = surf_voxel_selection.voxel_selection(vs, radius)
qe = SurfaceVoxelsQueryEngine(voxsel,
fallback_euclidean_distance=fallback)
# test i/o and ensure that the loaded instance is trained
if externals.exists('h5py'):
fd, qefn = tempfile.mkstemp('qe.hdf5', 'test')
os.close(fd)
h5save(qefn, qe)
qe = h5load(qefn)
os.remove(qefn)
m = _Voxel_Count_Measure()
sl = Searchlight(m, queryengine=qe)
data = np.random.normal(size=vol_shape)
img = nb.Nifti1Image(data, vol_affine)
ds = fmri_dataset(img)
sl_map = sl(ds)
counts = sl_map.samples
assert_true(np.all(np.logical_and(5 <= counts, counts <= 18)))
assert_equal(sl_map.nfeatures, expected_nfeatures)
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)
def test_volume_mask_dict(self):
# also tests the outside_node_margin feature
sh = (10, 10, 10)
msk = np.zeros(sh)
for i in xrange(0, sh[0], 2):
msk[i, :, :] = 1
vol_affine = np.identity(4)
vol_affine[0, 0] = vol_affine[1, 1] = vol_affine[2, 2] = 2
vg = volgeom.VolGeom(sh, vol_affine, mask=msk)
density = 10
outer = surf.generate_sphere(density) * 10. + 5
inner = surf.generate_sphere(density) * 5. + 5
intermediate = outer * .5 + inner * .5
xyz = intermediate.vertices
radius = 50
outside_node_margins = [None, 0, 100., np.inf, True]
expected_center_count = [87] * 2 + [intermediate.nvertices] * 3
for k, outside_node_margin in enumerate(outside_node_margins):
sel = surf_voxel_selection.run_voxel_selection(
radius,
vg,
inner,
outer,
outside_node_margin=outside_node_margin)
assert_equal(intermediate, sel.source)
assert_equal(len(sel.keys()), expected_center_count[k])
assert_true(
set(sel.aux_keys()).issubset(
set(['center_distances', 'grey_matter_position'])))
msk_lin = msk.ravel()
sel_msk_lin = sel.get_mask().ravel()
for i in xrange(vg.nvoxels):
if msk_lin[i]:
src = sel.target2nearest_source(i)
assert_false((src is None) ^ (sel_msk_lin[i] == 0))
if src is None:
continue
# index of node nearest to voxel i
src_anywhere = sel.target2nearest_source(
i, fallback_euclidean_distance=True)
# coordinates of node nearest to voxel i
xyz_src = xyz[src_anywhere]
# coordinates of voxel i
xyz_trg = vg.lin2xyz(np.asarray([i]))
# distance between node nearest to voxel i, and voxel i
# this should be the smallest distancer
d = volgeom.distance(np.reshape(xyz_src, (1, 3)), xyz_trg)
# distances between all nodes and voxel i
ds = volgeom.distance(xyz, xyz_trg)
# order of the distances
is_ds = np.argsort(ds.ravel())
# go over all the nodes
# require that the node is in the volume
# mask
# index of node nearest to voxel i
ii = np.argmin(ds)
xyz_min = xyz[ii]
lin_min = vg.xyz2lin([xyz_min])
# linear index of voxel that contains xyz_src
lin_src = vg.xyz2lin(np.reshape(xyz_src, (1, 3)))
# when using multi-core support,
# pickling and unpickling can reduce the precision
# a little bit, causing rounding errors
eps = 1e-14
delta = np.abs(ds[ii] - d)
assert_false(delta > eps and ii in sel and i in sel[ii]
and vg.contains_lin(lin_min))
def test_volgeom(self, temp_fn):
sz = (17, 71, 37, 73) # size of 4-D 'brain volume'
d = 2. # voxel size
xo, yo, zo = -6., -12., -20. # origin
mx = np.identity(4, np.float) * d # affine transformation matrix
mx[3, 3] = 1
mx[0, 3] = xo
mx[1, 3] = yo
mx[2, 3] = zo
vg = volgeom.VolGeom(sz, mx) # initialize volgeom
eq_shape_nvoxels = {
(17, 71, 37): (True, True),
(71, 17, 37, 1): (False, True),
(17, 71, 37, 2): (True, True),
(17, 71, 37, 73): (True, True),
(2, 2, 2): (False, False)
}
for other_sz, (eq_shape, eq_nvoxels) in eq_shape_nvoxels.iteritems():
other_vg = volgeom.VolGeom(other_sz, mx)
assert_equal(other_vg.same_shape(vg), eq_shape)
assert_equal(other_vg.nvoxels_mask == vg.nvoxels_mask, eq_nvoxels)
nv = sz[0] * sz[1] * sz[2] # number of voxels
nt = sz[3] # number of time points
assert_equal(vg.nvoxels, nv)
# a couple of hard-coded test cases
# last two are outside the volume
linidxs = [0, 1, sz[2], sz[1] * sz[2], nv - 1, -1, nv]
subidxs = ([(0, 0, 0), (0, 0, 1), (0, 1, 0), (1, 0, 0),
(sz[0] - 1, sz[1] - 1, sz[2] - 1)] +
[(sz[0], sz[1], sz[2])] * 2)
xyzs = ([(xo, yo, zo), (xo, yo, zo + d), (xo, yo + d, zo),
(xo + d, yo, zo),
(xo + d * (sz[0] - 1), yo + d * (sz[1] - 1), zo + d *
(sz[2] - 1))] + [(np.nan, np.nan, np.nan)] * 2)
for i, linidx in enumerate(linidxs):
lin = np.asarray([linidx])
ijk = vg.lin2ijk(lin)
ijk_expected = np.reshape(np.asarray(subidxs[i]), (1, 3))
assert_array_almost_equal(ijk, ijk_expected)
xyz = vg.lin2xyz(lin)
xyz_expected = np.reshape(np.asarray(xyzs[i]), (1, 3))
assert_array_almost_equal(xyz, xyz_expected)
# check that some identities hold
ab, bc, ac = vg.lin2ijk, vg.ijk2xyz, vg.lin2xyz
ba, cb, ca = vg.ijk2lin, vg.xyz2ijk, vg.xyz2lin
identities = [
lambda x: ab(ba(x)), lambda x: bc(cb(x)), lambda x: ac(ca(x)),
lambda x: ba(ab(x)), lambda x: cb(bc(x)), lambda x: ca(ac(x)),
lambda x: bc(ab(ca(x))), lambda x: ba(cb(ac(x)))
]
# 0=lin, 1=ijk, 2=xyz
identities_input = [1, 2, 2, 0, 1, 0, 2, 0]
# voxel indices to test
linrange = [0, 1, sz[2], sz[1] * sz[2]] + range(0, nv, nv // 100)
lin = np.reshape(np.asarray(linrange), (-1, ))
ijk = vg.lin2ijk(lin)
xyz = vg.ijk2xyz(ijk)
for j, identity in enumerate(identities):
inp = identities_input[j]
x = {0: lin, 1: ijk, 2: xyz}[inp]
assert_array_equal(x, identity(x))
# check that masking works
assert_true(vg.contains_lin(lin).all())
assert_false(vg.contains_lin(-lin - 1).any())
assert_true(vg.contains_ijk(ijk).all())
assert_false(vg.contains_ijk(-ijk - 1).any())
# ensure that we have no rounding issues
deltas = [-.51, -.49, 0., .49, .51]
should_raise = [True, False, False, False, True]
for delta, r in zip(deltas, should_raise):
xyz_d = xyz + delta * d
lin_d = vg.xyz2lin(xyz_d)
if r:
assert_raises(AssertionError, assert_array_almost_equal, lin_d,
lin)
else:
assert_array_almost_equal(lin_d, lin)
# some I/O testing
img = vg.get_empty_nifti_image()
img.to_filename(temp_fn)
assert_true(os.path.exists(temp_fn))
vg2 = volgeom.from_any(img)
vg3 = volgeom.from_any(temp_fn)
assert_array_equal(vg.affine, vg2.affine)
assert_array_equal(vg.affine, vg3.affine)
assert_equal(vg.shape[:3], vg2.shape[:3], 0)
assert_equal(vg.shape[:3], vg3.shape[:3], 0)
assert_true(len('%s%r' % (vg, vg)) > 0)
def test_mask_with_keys(self):
vol_shape = (10, 10, 10, 3)
vol_affine = np.identity(4)
vg = volgeom.VolGeom(vol_shape, vol_affine)
data = np.random.normal(size=vol_shape)
msk = np.ones(vol_shape[:3])
msk[:, 1:-1:2, :] = 0
ni_data = nb.Nifti1Image(data, vol_affine)
ni_msk = nb.Nifti1Image(msk, vol_affine)
ds = fmri_dataset(ni_data, mask=ni_msk)
sphere_density = 20
outer = surf.generate_sphere(sphere_density) * 10. + 5
inner = surf.generate_sphere(sphere_density) * 7. + 5
radius = 10
sel = surf_voxel_selection.run_voxel_selection(radius, ds,
inner, outer)
# in the mapping below:
# (tup: None) means that tup as input should raise a KeyError
# (tup: i) with i an int means that tup as input should return i
# elements
qe_ids2nvoxels = {SurfaceVoxelsQueryEngine:
{(1, 2, 3): 13,
tuple(np.arange(0, 200, 2)): 82,
(601,): None,
None: 126},
SurfaceVerticesQueryEngine:
{(1, 2, 3): None,
(205, 209, 210, 214): 36,
None: 126}}
for constructor, ids2nfeatures in qe_ids2nvoxels.iteritems():
qe = constructor(sel)
qe.train(ds)
img = qe.get_masked_nifti_image()
assert_array_equal(img.get_data(),
qe.get_masked_nifti_image(qe.ids).get_data())
img_getter = qe.get_masked_nifti_image
for ids, nfeatures in ids2nfeatures.iteritems():
ids_list = ids if ids is None else list(ids)
if nfeatures is None and ids is not None:
assert_raises(KeyError, img_getter, ids_list)
else:
img = img_getter(ids_list)
nfeatures_found = np.sum(img.get_data())
assert_equal(nfeatures, nfeatures_found)
if constructor is SurfaceVerticesQueryEngine:
expected_image = qe.get_masked_nifti_image(ids_list)
expected_mask = expected_image.get_data()
check_mask_func = lambda x: assert_array_equal(
expected_mask, x)
check_image_func = lambda x: check_mask_func(
x.get_data()) and \
assert_array_equal(x.affine,
expected_image.affine)
check_mask_func(sel.get_mask(ids_list))
check_image_func(sel.get_nifti_image_mask(ids_list))
tups = sel.get_voxel_indices(ids_list)
tups_mask = np.zeros(expected_mask.shape)
for tup in tups:
tups_mask[tup] += 1
assert_array_equal(expected_mask != 0, tups_mask != 0)