def test_rotate(self): # image rotated 9 degrees in first axis input_img = nbload(os.path.join(test_data_directory, 'img_rot.nii')) base_img = nbload(os.path.join(test_data_directory, 'img.nii')) registered_img, xfm_pred = transform(input_img, base_img, output_transform=True) xfm_true = np.linalg.inv(load_afni_xfm(os.path.join(test_data_directory, 'rotmat.aff12.1D'))) self.assertTrue(np.allclose(xfm_true, xfm_pred, rtol=0.01, atol=0.01))
def test_motion_correct(self): reference_path = os.path.join(test_data_directory, 'img.nii') reference_img = nbload(reference_path) input_img = nbload(os.path.join(test_data_directory, 'img_rot.nii')) mc = MotionCorrect() mc.load_reference(reference_path) registered_img = mc.run(input_img) self.assertTrue(np.corrcoef(reference_img.get_data().flatten(), registered_img.get_data().flatten())[0,1]>0.99)
def test_motion_correct_shift(self): input_img = nbload(os.path.join(test_data_directory, 'img.nii')) # base image is identical base_img = nbload(os.path.join(test_data_directory, 'img.nii')) base_affine = base_img.affine[:] base_affine[0,3] += 10 output_img = transform(input_img, Nifti1Image(base_img.get_data(), base_affine)) self.assertTrue(np.allclose(input_img.get_data(), output_img.get_data()))
def __init__(self, subject, model_name=None, **kwargs):
'''
This should set up the class instance to be ready to take an image input
and output the detrended gray matter activation
To do this, it needs:
wm_mask_funcref: white matter masks in functional reference space
gm_mask_funcref: gray matter masks in functional reference space
funcref_nifti1: the functional reference image
input_affine: affine transform for the input images
since we'll be dealing with raw pixel data, we need to
have a predetermined image orientation
'''
self.subj_dir = get_subject_directory(subject)
self.subject = subject
self.funcref_nifti1 = nbload(os.path.join(self.subj_dir, 'funcref.nii'))
try:
model_path = os.path.join(self.subj_dir, 'model-%s.pkl'%model_name)
pca_path = os.path.join(self.subj_dir, 'pca-%s.pkl'%model_name)
with open(model_path, 'r') as f:
model = cPickle.load(f)
self.model = model
with open(pca_path, 'r') as f:
pca = cPickle.load(f)
self.pca = pca
except IOError:
warnings.warn('''Could not load...\n\tModel from %s\nand\n\tPCA from %s. Load them manually before running.''' % (model_path, pca_path))
def __init__(self, subject, xfm_name, pre_mask_name, roi_names, **kwargs): ''' Extract activity from an ROI Input -------- subject (str) subject ID xfm_name (str) pycortex transform ID pre_mask_name (str) ROI masks returned by pycortex are in volume space, but activity is provided as a vector of gray matter activity. pre_mask_name is the name of the mask that was applied to the raw image volume to produce the gray matter activity vector. roi_names (list of str) names of the ROIs to extract Returns -------- roi_activities (list of float) mean activity in the requested ROIs ''' subj_dir = get_subject_directory(subject) pre_mask_path = os.path.join(subj_dir, pre_mask_name+'.nii') # mask in zyx pre_mask = nbload(pre_mask_path).get_data().T.astype(bool) # returns masks in zyx roi_masks, roi_dict = cortex.get_roi_masks(subject, xfm_name, roi_names) self.masks = dict() for name, mask_value in roi_dict.iteritems(): roi_mask = roi_masks==mask_value self.masks[name] = secondary_mask(pre_mask, roi_mask)
def __init__(self, subject=None, reference_name='funcref.nii', **kwargs):
if not subject is None:
funcref_path = os.path.join(get_subject_directory(subject), reference_name)
funcref = nbload(funcref_path)
self.affine = funcref.affine[:]
else:
warnings.warn('No subject provided. Set affine attribute manually before calling run.')
def __init__(self, subject, mask1_name, mask2_name, **kwargs): ''' Input: ----- mask1_path: path to a boolean mask in xyz format mask2_path: path to a boolean mask in xyz format Initialization will generate a boolean vector that selects elements from the vector output of mask1 applied to a volume that are also in mask2. ''' subj_dir = get_subject_directory(subject) mask1_path = os.path.join(subj_dir, mask1_name+'.nii') mask2_path = os.path.join(subj_dir, mask2_name+'.nii') mask1 = nbload(mask1_path).get_data().astype(bool) # in xyz mask2 = nbload(mask2_path).get_data().astype(bool) # in xyz self.mask = secondary_mask(mask1, mask2, order='F')
def test_raw_to_nifti(self): with open(os.path.join(test_data_directory, 'img_rot.PixelData'), 'r') as f: raw_image_binary = f.read() raw_to_nifti = RawToNifti() funcref_path = os.path.join(test_data_directory, 'img_rot.nii') raw_to_nifti.affine = nbload(funcref_path).affine volume = raw_to_nifti.run(raw_image_binary) self.assertTrue(isinstance(volume, Nifti1Image))
def test_transform_identity(self): # load test image input_img = nbload(os.path.join(test_data_directory, 'img.nii')) # base image is identical base_path = os.path.join(test_data_directory, 'img.nii') output_img = transform(input_img, base_path) self.assertTrue(np.allclose(input_img.get_data(), output_img.get_data())) self.assertTrue(isinstance(output_img, Nifti1Image))
def test_get_activity_in_mask(self):
input_fpath = os.path.join(test_data_directory, 'img_rot.PixelData')
with open(input_fpath, 'r') as f:
raw_image_binary = f.read()
ref_img = nbload(os.path.join(test_data_directory, 'img.nii'))
wm_mask = nbload(os.path.join(test_data_directory, 'wm_mask.nii'))
gm_mask = nbload(os.path.join(test_data_directory, 'gm_mask.nii'))
wm = WMDetrend()
raw_to_volume = RawToVolume()
wm.funcref_nifti1 = ref_img
wm.masks = { 'wm': wm_mask.get_data().astype(bool),
'gm': gm_mask.get_data().astype(bool)
}
d = raw_to_volume.run(raw_image_binary)
mask_activity = wm.get_activity_in_masks(d['raw_image_volume'])
ref_wm = ref_img.get_data().T[wm.masks['wm'].T]
self.assertTrue(np.corrcoef(mask_activity['wm'], ref_wm)[0,1]>0.99)
def load_mask(self, mask_path): mask_nifti1 = nbload(mask_path) self.mask_affine = mask_nifti1.affine self.mask = mask_nifti1.get_data().astype(bool)
def load_reference(self, reference_path): self.reference_path = reference_path self.reference_affine = nbload(self.reference_path).affine
def transform(inp, base, output_transform=False):
if type(base)==str:
base_path = base
else:
base_path = str(uuid4())+'.nii'
nbsave(base, base_path)
if type(inp)==str:
inp_path = inp
else:
inp_path = str(uuid4())+'.nii'
nbsave(inp, inp_path)
out_path = str(uuid4())+'.nii'
params = [
{
'name': 'input file path',
'position': 'last',
'value': inp_path
},
{
'name': 'reference path',
'flag': 'base',
'value': base_path
},
{
'name': 'output file path',
'flag': 'prefix',
'value': out_path
}
]
if output_transform:
transform_path = str(uuid4())+'.aff12.1D'
params.append({
'name': 'transform path',
'flag': '1Dmatrix_save',
'value': transform_path
})
cmd = generate_command('3dvolreg', params)
devnull = open(os.devnull, 'w')
ret = call(cmd, stdout=devnull, stderr=STDOUT, close_fds=True)
if ret>0:
print ' '.join(cmd)
out_img = nbload(out_path)
out_img.get_data()
os.remove(out_path)
if inp is not inp_path:
os.remove(inp_path)
if base is not base_path:
os.remove(base_path)
if output_transform:
xfm = load_afni_xfm(transform_path)
os.remove(transform_path)
return out_img, xfm
else:
return out_img
