def test_query_engine():
data = np.arange(54)
# indices in 3D
ind = np.transpose((np.ones((3, 3, 3)).nonzero()))
# sphere generator for 3 elements diameter
sphere = ne.Sphere(1)
# dataset with just one "space"
ds = Dataset([data, data], fa={'s_ind': np.concatenate((ind, ind))})
# and the query engine attaching the generator to the "index-space"
qe = ne.IndexQueryEngine(s_ind=sphere)
# cannot train since the engine does not know about the second space
assert_raises(ValueError, qe.train, ds)
# now do it again with a full spec
ds = Dataset([data, data],
fa={
's_ind': np.concatenate((ind, ind)),
't_ind': np.repeat([0, 1], 27)
})
qe = ne.IndexQueryEngine(s_ind=sphere, t_ind=None)
qe.train(ds)
# internal representation check
# YOH: invalid for new implementation with lookup tables (dictionaries)
#assert_array_equal(qe._searcharray,
# np.arange(54).reshape(qe._searcharray.shape) + 1)
# should give us one corner, collapsing the 't_ind'
assert_array_equal(qe(s_ind=(0, 0, 0)), [0, 1, 3, 9, 27, 28, 30, 36])
# directly specifying an index for 't_ind' without having an ROI
# generator, should give the same corner, but just once
assert_array_equal(qe(s_ind=(0, 0, 0), t_ind=0), [0, 1, 3, 9])
# just out of the mask -- no match
assert_array_equal(qe(s_ind=(3, 3, 3)), [])
# also out of the mask -- but single match
assert_array_equal(qe(s_ind=(2, 2, 3), t_ind=1), [53])
# query by id
assert_array_equal(qe(s_ind=(0, 0, 0), t_ind=0), qe[0])
assert_array_equal(qe(s_ind=(0, 0, 0), t_ind=[0, 1]), qe(s_ind=(0, 0, 0)))
# should not fail if t_ind is outside
assert_array_equal(qe(s_ind=(0, 0, 0), t_ind=[0, 1, 10]),
qe(s_ind=(0, 0, 0)))
# should fail if asked about some unknown thing
assert_raises(ValueError, qe.__call__, s_ind=(0, 0, 0), buga=0)
# Test by using some literal feature atttribute
ds.fa['lit'] = ['roi1', 'ro2', 'r3'] * 18
# should work as well as before
assert_array_equal(qe(s_ind=(0, 0, 0)), [0, 1, 3, 9, 27, 28, 30, 36])
# should fail if asked about some unknown (yet) thing
assert_raises(ValueError, qe.__call__, s_ind=(0, 0, 0), lit='roi1')
# Create qe which can query literals as well
qe_lit = ne.IndexQueryEngine(s_ind=sphere, t_ind=None, lit=None)
qe_lit.train(ds)
# should work as well as before
assert_array_equal(qe_lit(s_ind=(0, 0, 0)), [0, 1, 3, 9, 27, 28, 30, 36])
# and subselect nicely -- only /3 ones
assert_array_equal(qe_lit(s_ind=(0, 0, 0), lit='roi1'),
[0, 3, 9, 27, 30, 36])
assert_array_equal(qe_lit(s_ind=(0, 0, 0), lit=['roi1', 'ro2']),
[0, 1, 3, 9, 27, 28, 30, 36])
def test_cached_query_engine():
"""Test cached query engine
"""
sphere = ne.Sphere(1)
# dataset with just one "space"
ds = datasets['3dlarge']
qe0 = ne.IndexQueryEngine(myspace=sphere)
qec = ne.CachedQueryEngine(qe0)
# and ground truth one
qe = ne.IndexQueryEngine(myspace=sphere)
results_ind = []
results_kw = []
def cmp_res(res1, res2):
comp = [x == y for x, y in zip(res1, res2)]
ok_(np.all(comp))
for iq, q in enumerate((qe, qec)):
q.train(ds)
# sequential train on the same should be ok in both cases
q.train(ds)
res_ind = [q[fid] for fid in xrange(ds.nfeatures)]
res_kw = [q(myspace=x) for x in ds.fa.myspace]
# test if results match
cmp_res(res_ind, res_kw)
results_ind.append(res_ind)
results_kw.append(res_kw)
# now check if results of cached were the same as of regular run
cmp_res(results_ind[0], results_ind[1])
# Now do sanity checks
assert_raises(ValueError, qec.train, ds[:, :-1])
assert_raises(ValueError, qec.train, ds.copy())
ds2 = ds.copy()
qec.untrain()
qec.train(ds2)
# should be the same results on the copy
cmp_res(results_ind[0], [qec[fid] for fid in xrange(ds.nfeatures)])
cmp_res(results_kw[0], [qec(myspace=x) for x in ds.fa.myspace])
ok_(qec.train(ds2) is None)
