def test_loadSettings():
contents = """
set random_setting true
any lines that don't start with "set" should be ignored
# regardless of whether they are commented or not
set fmri(blah) 0.66
set something "quoted"
set somethingelse 'quotedagain'
set fmri_thing(no) none
# set comment commented out
set athing with spaces in the value
"""
expected = collections.OrderedDict((
('random_setting', 'true'),
('blah', '0.66'),
('something', 'quoted'),
('somethingelse', 'quotedagain'),
('fmri_thing(no)', 'none'),
('athing', 'with spaces in the value'),
))
contents = textwrap.dedent(contents).strip()
with pytest.raises(Exception):
featanalysis.loadSettings('no file')
with tests.testdir() as testdir:
featdir = op.join(testdir, 'analysis.feat')
designfsf = op.join(featdir, 'design.fsf')
tests.make_dummy_file(designfsf, contents)
assert featanalysis.loadSettings(featdir) == expected
assert featanalysis.loadFsf(designfsf) == expected
def test_getFirstLevelEVs_realdata():
featdir = op.join(datadir, '1stlevel_realdata.feat')
settings = featanalysis.loadSettings(featdir)
matrix = featdesign.loadDesignMat(op.join(featdir, 'design.mat'))
expected = [(featdesign.NormalEV, {
'index': 0,
'origIndex': 0
}), (featdesign.TemporalDerivativeEV, {
'index': 1
}), (featdesign.NormalEV, {
'index': 2,
'origIndex': 1
}), (featdesign.TemporalDerivativeEV, {
'index': 3
})]
evs = featdesign.getFirstLevelEVs(featdir, settings, matrix)
assert len(evs) == 4
for i, (evtype, atts) in enumerate(expected):
assert isinstance(evs[i], evtype)
for k, v in atts.items():
assert getattr(evs[i], k) == v
del evs
evs = None
def test_FEATFSFDesign():
for featdir in TEST_ANALYSES.keys():
nev = TEST_ANALYSES[featdir]['nevs']
shape = TEST_ANALYSES[featdir]['shape']
desshape = TEST_ANALYSES[featdir]['designShape']
featdir = op.join(datadir, featdir)
settings = featanalysis.loadSettings(featdir)
# We can't load the voxelwise EVs
# here, because all of the .nii.gz
# files in the test directory are
# stubs. Voxelwise EVs get tested
# in the test_FEATFSFDesign_firstLevelVoxelwiseEV
# function
des = featdesign.FEATFSFDesign(featdir, loadVoxelwiseEVs=False)
# Can also specify the design.fsf settings
featdesign.FEATFSFDesign(featdir,
settings=settings,
loadVoxelwiseEVs=False)
rvox = tests.random_voxels(shape)
assert len(des.getEVs()) == nev
assert des.getDesign().shape == desshape
assert des.getDesign(rvox).shape == desshape
del des
des = None
def test_getThresholds():
datadir = op.join(op.dirname(__file__), 'testdata', 'test_feat')
featdir = op.join(datadir, '1stlevel_1.feat')
settings = featanalysis.loadSettings(featdir)
thresholds = featanalysis.getThresholds(settings)
assert np.isclose(thresholds['p'], 0.05)
assert np.isclose(thresholds['z'], 2.3)
def test_loadDesign():
datadir = op.join(op.dirname(__file__), 'testdata', 'test_feat')
featdir = op.join(datadir, '1stlevel_1.feat')
settings = featanalysis.loadSettings(featdir)
design = featanalysis.loadDesign(featdir, settings)
assert isinstance(design, featdesign.FEATFSFDesign)
assert len(design.getEVs()) == 10
assert design.getDesign().shape == (45, 10)
def test_isFirstLevelAnalysis():
datadir = op.join(op.dirname(__file__), 'testdata', 'test_feat')
featdirs = ['1stlevel_1.feat', '1stlevel_2.feat', '1stlevel_3.feat',
'2ndlevel_1.gfeat', '2ndlevel_2.gfeat']
for featdir in featdirs:
expected = featdir.startswith('1')
featdir = op.join(datadir, featdir)
settings = featanalysis.loadSettings(featdir)
assert featanalysis.isFirstLevelAnalysis(settings) == expected
def test_getHigherLevelEVs_1():
featdir = op.join(datadir, '2ndlevel_1.gfeat')
settings = featanalysis.loadSettings(featdir)
matrix = featdesign.loadDesignMat(op.join(featdir, 'design.mat'))
evs = featdesign.getHigherLevelEVs(featdir, settings, matrix)
assert len(evs) == 1
assert isinstance(evs[0], featdesign.NormalEV)
assert evs[0].index == 0
assert evs[0].origIndex == 0
def test_loadClusterResults():
datadir = op.join(op.dirname(__file__), 'testdata', 'test_feat')
featdirs = [
'1stlevel_1.feat', '1stlevel_2.feat', '1stlevel_3.feat',
'2ndlevel_1.gfeat/cope1.feat', '2ndlevel_1.gfeat/cope2.feat',
'2ndlevel_2.gfeat/cope1.feat', '2ndlevel_2.gfeat/cope2.feat'
]
ncontrasts = [2, 2, 2, 1, 1, 1, 1]
nclusters = [[1, 5], [2, 2], [3, 5], [7], [1], [10], [27]]
with pytest.raises(Exception):
featanalysis.loadClusterResults('notafeatdir')
for i, featdir in enumerate(featdirs):
firstlevel = featdir.startswith('1')
featdir = op.join(datadir, featdir)
with tests.testdir() as testdir:
# For higher level analyses, the
# loadClusterResults function peeks
# at the FEAT input data file
# header, so we have to generate it.
newfeatdir = op.join(testdir, 'analysis.feat')
shutil.copytree(op.join(datadir, featdir), newfeatdir)
featdir = newfeatdir
if not firstlevel:
datafile = op.join(featdir, 'filtered_func_data.nii.gz')
data = np.random.randint(1, 10, (91, 109, 91))
xform = np.array([[-2, 0, 0, 90], [0, 2, 0, -126],
[0, 0, 2, -72], [0, 0, 0, 1]])
fslimage.Image(data, xform=xform).save(datafile)
settings = featanalysis.loadSettings(featdir)
for c in range(ncontrasts[i]):
clusters = featanalysis.loadClusterResults(
featdir, settings, c)
assert len(clusters) == nclusters[i][c]
# Test calling the function on a feat dir
# which doesn't have any cluster results
if i == len(featdirs) - 1:
for clustfile in glob.glob(op.join(featdir, 'cluster*txt')):
os.remove(clustfile)
assert featanalysis.loadClusterResults(featdir, settings,
0) is None
def test_getFirstLevelEVs_2():
featdir = op.join(datadir, '1stlevel_2.feat')
settings = featanalysis.loadSettings(featdir)
matrix = featdesign.loadDesignMat(op.join(featdir, 'design.mat'))
expected = [(featdesign.NormalEV, {
'index': 0,
'origIndex': 0
}), (featdesign.TemporalDerivativeEV, {
'index': 1
}), (featdesign.NormalEV, {
'index': 2,
'origIndex': 1
}), (featdesign.TemporalDerivativeEV, {
'index': 3
}), (featdesign.VoxelwiseEV, {
'index': 4,
'origIndex': 2
}), (featdesign.MotionParameterEV, {
'index': 5,
'motionIndex': 0
}), (featdesign.MotionParameterEV, {
'index': 6,
'motionIndex': 1
}), (featdesign.MotionParameterEV, {
'index': 7,
'motionIndex': 2
}), (featdesign.MotionParameterEV, {
'index': 8,
'motionIndex': 3
}), (featdesign.MotionParameterEV, {
'index': 9,
'motionIndex': 4
}), (featdesign.MotionParameterEV, {
'index': 10,
'motionIndex': 5
})]
evs = featdesign.getFirstLevelEVs(featdir, settings, matrix)
assert len(evs) == 11
for i, (evtype, atts) in enumerate(expected):
assert isinstance(evs[i], evtype)
for k, v in atts.items():
assert getattr(evs[i], k) == v
del evs
evs = None
def test_getFirstLevelEVs_3():
featdir = op.join(datadir, '1stlevel_3.feat')
settings = featanalysis.loadSettings(featdir)
matrix = featdesign.loadDesignMat(op.join(featdir, 'design.mat'))
expected = [(featdesign.NormalEV, {
'index': 0,
'origIndex': 0
}), (featdesign.TemporalDerivativeEV, {
'index': 1
}), (featdesign.NormalEV, {
'index': 2,
'origIndex': 1
}), (featdesign.BasisFunctionEV, {
'index': 3
}), (featdesign.BasisFunctionEV, {
'index': 4
}), (featdesign.VoxelwiseConfoundEV, {
'index': 5,
'voxIndex': 0
}), (featdesign.MotionParameterEV, {
'index': 6,
'motionIndex': 0
}), (featdesign.MotionParameterEV, {
'index': 7,
'motionIndex': 1
}), (featdesign.MotionParameterEV, {
'index': 8,
'motionIndex': 2
}), (featdesign.MotionParameterEV, {
'index': 9,
'motionIndex': 3
}), (featdesign.MotionParameterEV, {
'index': 10,
'motionIndex': 4
}), (featdesign.MotionParameterEV, {
'index': 11,
'motionIndex': 5
}), (featdesign.MotionParameterEV, {
'index': 12,
'motionIndex': 6
}), (featdesign.MotionParameterEV, {
'index': 13,
'motionIndex': 7
}), (featdesign.MotionParameterEV, {
'index': 14,
'motionIndex': 8
}), (featdesign.MotionParameterEV, {
'index': 15,
'motionIndex': 9
}), (featdesign.MotionParameterEV, {
'index': 16,
'motionIndex': 10
}), (featdesign.MotionParameterEV, {
'index': 17,
'motionIndex': 11
}), (featdesign.MotionParameterEV, {
'index': 18,
'motionIndex': 12
}), (featdesign.MotionParameterEV, {
'index': 19,
'motionIndex': 13
}), (featdesign.MotionParameterEV, {
'index': 20,
'motionIndex': 14
}), (featdesign.MotionParameterEV, {
'index': 21,
'motionIndex': 15
}), (featdesign.MotionParameterEV, {
'index': 22,
'motionIndex': 16
}), (featdesign.MotionParameterEV, {
'index': 23,
'motionIndex': 17
}), (featdesign.MotionParameterEV, {
'index': 24,
'motionIndex': 18
}), (featdesign.MotionParameterEV, {
'index': 25,
'motionIndex': 19
}), (featdesign.MotionParameterEV, {
'index': 26,
'motionIndex': 20
}), (featdesign.MotionParameterEV, {
'index': 27,
'motionIndex': 21
}), (featdesign.MotionParameterEV, {
'index': 28,
'motionIndex': 22
}), (featdesign.MotionParameterEV, {
'index': 29,
'motionIndex': 23
}), (featdesign.ConfoundEV, {
'index': 30,
'confIndex': 0
}), (featdesign.ConfoundEV, {
'index': 31,
'confIndex': 1
})]
evs = featdesign.getFirstLevelEVs(featdir, settings, matrix)
assert len(evs) == 32
for i, (evtype, atts) in enumerate(expected):
assert isinstance(evs[i], evtype)
for k, v in atts.items():
assert getattr(evs[i], k) == v
del evs
evs = None
def test_FEATImage_attributes():
# TEst bad input
with pytest.raises(Exception):
featimage.FEATImage('baddir')
for featdir in TEST_ANALYSES.keys():
shape = TEST_ANALYSES[featdir]['shape']
xform = TEST_ANALYSES[featdir]['xform']
with tests.testdir() as testdir:
if 'realdata' not in featdir:
featdir = tests.make_mock_feat_analysis(op.join(
datadir, featdir),
testdir,
shape,
xform,
pes=False,
copes=False,
zstats=False,
residuals=False,
clustMasks=False)
else:
featdir = op.join(datadir, featdir)
# Now create a FEATImage. We validate its
# attributes against the values returned by
# the functions in featdesign/featanalysis.
fi = featimage.FEATImage(featdir)
settings = featanalysis.loadSettings(featdir)
design = featdesign.FEATFSFDesign(featdir, settings)
desmat = design.getDesign()
evnames = [ev.title for ev in design.getEVs()]
contrastnames, contrasts = featanalysis.loadContrasts(featdir)
assert np.all(np.isclose(fi.shape, shape))
assert np.all(np.isclose(fi.voxToWorldMat, xform))
assert fi.getFEATDir() == featdir
assert fi.getAnalysisName() == op.splitext(op.basename(featdir))[0]
assert fi.isFirstLevelAnalysis(
) == featanalysis.isFirstLevelAnalysis(settings)
assert fi.getTopLevelAnalysisDir(
) == featanalysis.getTopLevelAnalysisDir(featdir)
assert fi.getReportFile() == featanalysis.getReportFile(featdir)
assert fi.hasStats() == featanalysis.hasStats(featdir)
assert fi.numPoints() == desmat.shape[0]
assert fi.numEVs() == desmat.shape[1]
assert fi.evNames() == evnames
assert fi.numContrasts() == len(contrasts)
assert fi.contrastNames() == contrastnames
assert fi.contrasts() == contrasts
assert np.all(np.isclose(fi.getDesign(), desmat))
assert fi.thresholds() == featanalysis.getThresholds(settings)
for ci in range(len(contrasts)):
result = fi.clusterResults(ci)
expect = featanalysis.loadClusterResults(featdir, settings, ci)
assert len(result) == len(expect)
assert all([
rc.nvoxels == ec.nvoxels for rc, ec in zip(result, expect)
])
def test_loadClusterResults():
datadir = op.join(op.dirname(__file__), 'testdata', 'test_feat')
featdirs = ['1stlevel_1.feat', '1stlevel_2.feat', '1stlevel_3.feat',
'2ndlevel_1.gfeat/cope1.feat', '2ndlevel_1.gfeat/cope2.feat',
'2ndlevel_2.gfeat/cope1.feat', '2ndlevel_2.gfeat/cope2.feat']
ncontrasts = [2, 2, 2, 1, 1, 1, 1]
nclusters = [[1, 5], [2, 2], [3, 5], [7], [1], [10], [27]]
with pytest.raises(Exception):
featanalysis.loadClusterResults('notafeatdir')
for i, featdir in enumerate(featdirs):
firstlevel = featdir.startswith('1')
featdir = op.join(datadir, featdir)
with tests.testdir() as testdir:
# work from a copy of the test data directory
newfeatdir = op.join(testdir, 'analysis.feat')
shutil.copytree(op.join(datadir, featdir), newfeatdir)
featdir = newfeatdir
# For higher level analyses, the
# loadClusterResults function peeks
# at the FEAT input data file
# header, so we have to generate it.
if not firstlevel:
datafile = op.join(featdir, 'filtered_func_data.nii.gz')
data = np.random.randint(1, 10, (91, 109, 91))
xform = np.array([[-2, 0, 0, 90],
[ 0, 2, 0, -126],
[ 0, 0, 2, -72],
[ 0, 0, 0, 1]])
fslimage.Image(data, xform=xform).save(datafile)
settings = featanalysis.loadSettings(featdir)
for c in range(ncontrasts[i]):
clusters = featanalysis.loadClusterResults(
featdir, settings, c)
assert len(clusters) == nclusters[i][c]
# Test calling the function on a feat dir
# which doesn't have any cluster results
if i == len(featdirs) - 1:
for clustfile in glob.glob(op.join(featdir, 'cluster*txt')):
os.remove(clustfile)
assert featanalysis.loadClusterResults(
featdir, settings, 0) is None
# The above loop just checks that the number of
# clusters loaded for each analysis was correct.
# Below we check that the cluster data was loaded
# correctly, just for one analysis
featdir = op.join(datadir, '1stlevel_1.feat')
settings = featanalysis.loadSettings(featdir)
cluster = featanalysis.loadClusterResults(featdir, settings, 0)[0]
expected = {
'index' : 1,
'nvoxels' : 296,
'p' : 1.79e-27,
'logp' : 26.7,
'zmax' : 6.03,
'zmaxx' : 34,
'zmaxy' : 10,
'zmaxz' : 1,
'zcogx' : 31.4,
'zcogy' : 12.3,
'zcogz' : 1.72,
'copemax' : 612,
'copemaxx' : 34,
'copemaxy' : 10,
'copemaxz' : 1,
'copemean' : 143
}
for k, v in expected.items():
assert np.isclose(v, getattr(cluster, k))
info_dct = {
info_temp[i]: info_temp[i + 1]
for i in range(0, len(info_temp), 2)
}
num_pts = int(info_dct['dim4'])
# get full path to $FSLDIR
FSLDIR = os.path.expandvars('$FSLDIR')
# get path of output design.fsf file
feat_subdir = os.path.split(snakemake.output.design_fsf)[0]
# set variables
# load in design.fsf
design = FA.loadSettings(snakemake.input.feat_dir)
for ev in range(len(snakemake.input.event_files)):
evTemp = ev + 1
evName = design['evtitle%d' % evTemp]
evFile = snakemake.input.event_files[ev]
#evFile = [evf for evf in snakemake.input.event_files if evf == 'trial-%s_onsets.txt'%evName]
custom = [('custom%d' % evTemp, '"%s"' % evFile)]
design.update(custom)
# begin tedious process of rebuilding design.fsf
feat_files = [('feat_files(1)', '"%s"' % snakemake.input.func_file)]
design.update(feat_files)
npts = [('npts', '%d' % num_pts)]
design.update(npts)
tr = [('tr', '%f' % snakemake.params.TR)]
roiResampleFilename = os.path.split(outFileROI)[-1].replace(
"desc-th0_", "desc-th0-resample_")
roiResampleFile = os.path.join(args.output_dir, "temp",
roiResampleFilename)
roiImg = load_img(outFileROI)
print('Resampling %s to %s' % (os.path.split(outFileROI)[-1],
os.path.split(funcFile)[-1]))
resampledROIImg = resample_to_img(roiImg, funcImg)
print('Saving resampled file: %s' % roiResampleFilename)
resampledROIImg.to_filename(roiResampleFile)
# load in design.fsf
evNames = []
#data.featanalysis.loadSettings(designFile)
design = FA.loadSettings(args.feat_dir)
numEVs = int(design['evs_orig'])
for ev in range(numEVs):
evTemp = ev + 1
evNames.append(design['evtitle%d' % evTemp])
# load in events.tsv file
eventsFilename = os.path.split(funcFile)[-1].replace(
"space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz",
"events.tsv")
print('Events file: %s' % eventsFilename)
eventsFile = os.path.join(bidsDir, eventsFilename)
taskTimings = read_tsv(eventsFile)
for ev in range(len(evNames)):
evTemp = ev + 1
