def highpass_filter(self,suffix_in='n',suffix_out='f',highpass_val=.011):
for i,epi in enumerate(self.func_names):
general_cleaner(epi+suffix_out,1)
shell_command(['3dFourier','-prefix',epi+suffix_out,'-highpass',
str(highpass_val),epi+suffix_in+'+orig'])
self.highpass_filtered = True
return suffix_out
def reconstruct_anat(self,rawdir_searchexp='./*/'):
if self.data_type == 'cni':
general_cleaner(self.anat_name,1)
# create afni anat from nifti:
if not self.raw_anat:
self.raw_anat = self.__cni_find_raws([self.anat_scan_num])[0]
shell_command(['3dcopy',self.raw_anat,self.anat_name])
elif self.data_type == 'lucas':
# guess the rawdir based on the search expression.
# the default is the first directory in the subject directory... (typically works!)
currentdir = os.getcwd()
rawdir = glob.glob(rawdir_searchexp)[0]
os.chdir(rawdir)
dicomdirs = glob.glob('./*/')
axialdir,saggitaldir = [],[]
for dir in dicomdirs:
os.chdir(dir)
dicomfiles = glob.glob('./*')
if len(files) == 24: axialdir = dir
if len(files) == 116: saggitaldir = dir
os.chdir('../')
saginfo = self.__runto3d(saggitaldir,prefix=self.anat_name,keepfiles=True)
axiinfo = self.__runto3d(axialdir,prefix='axialtemp',keepfiles=False)
self.__isparse(axiinfo)
os.chdir(currentdir)
self.reconstructed_anat = True
def warp_functionals(self, dset_names=[], suffix_in='f'):
for i, epi in enumerate(dset_names):
shell_command(['adwarp','-apar',self.anat_name+'+tlrc','-dpar',epi+suffix_in+'+orig', \
'-dxyz',str(self.talairach_dxyz)])
return {
'dset_out': [(x + suffix_in + '+tlrc') for x in dset_names],
'suffix_out': suffix_out
}
def convert_to_nifti(self,suffix_in='_masked',suffix_out='_masked',orig=False):
for epi in self.func_names:
if not orig:
shell_command(['3dAFNItoNIFTI','-prefix',epi+suffix_in,epi+suffix_out+'+tlrc'])
else:
shell_command(['3dAFNItoNIFTI','-prefix',epi+suffix_in,epi+suffix_out+'+orig'])
self.converted_to_nifti = True
return suffix_out
def __lucas_3dtshift(self,
dset_names,
suffix_out='_cropts',
suffix_in='_crop'):
for name in dset_names:
shell_command([
'3dTshift', '-slice', '0', '-prefix', name + suffix_out,
name + suffix_in + '+orig'
])
general_cleaner(name + suffix_in, 1)
return suffix_out
def correct_motion(self,dset_names=[],motion_labels=[],suffix_out='m',suffix_in=''):
if len(motion_labels) != len(dset_names):
print('\nWARNING: Motion labels not equal to number of functionals.\n')
else:
for i,(label,epi) in enumerate(zip(motion_labels,dset_names)):
# clean out motion files:
general_cleaner(label,0)
general_cleaner(epi+suffix_out,1)
# run 3dvolreg for each functional:
shell_command(['3dvolreg','-Fourier','-twopass','-prefix',epi+suffix_out,'-base',
'3','-dfile',label+'.1D',epi+suffix_in+'+orig'])
return {'dset_out':[(x+suffix_out+'+orig') for x in dset_names],'suffix_out':suffix_out}
def command(self):
if len(self.motion_labels) != len(self.dset_labels):
print('\nWARNING: Motion labels not equal to number of functionals.\n')
else:
for i,(label,epi) in enumerate(zip(self.motion_labels,self.dset_labels)):
# clean out motion files:
general_cleaner(label,0)
general_cleaner(epi+self.suffix_out,1)
# run 3dvolreg for each functional:
shell_command(['3dvolreg','-Fourier','-twopass','-prefix',epi+self.suffix_out,'-base',
'3','-dfile',label+'.1D',epi+self.suffix_in+'+orig'])
return {'dset_out':[(x+self.suffix_out) for x in self.dset_labels],
'suffix_out':self.suffix_out,'motion_files':[label for label in self.motion_labels]}
def correct_motion(self,suffix_out='m',suffix_in=''):
# ensure motion labels and functionals match:
if len(self.motion_labels) != len(self.func_names):
print('\nWARNING: Motion labels not equal to number of functionals.\n')
else:
for i,(label,epi) in enumerate(zip(self.motion_labels,self.func_names)):
# clean out motion files:
general_cleaner(label,0)
general_cleaner(epi+suffix_out,1)
# run 3dvolreg for each functional:
shell_command(['3dvolreg','-Fourier','-twopass','-prefix',epi+suffix_out,'-base', \
'3','-dfile',label+'.1D',epi+suffix_in+'+orig'])
self.corrected_motion = True
return suffix_out
def __lucas_3dtcat(self,
pfiles_trs,
dset_names,
nslices,
isvalues,
tr_time,
leadin,
leadout,
spiral=True,
suffix_out='_crop'):
for group, name in zip(pfiles_trs, dset_names):
catcmd = ['3dTcat', '-prefix', name + suffix_out]
for i, [pfile, ntr] in enumerate(group):
if spiral:
shell_command(['sprlioadd','-0','-m','0',pfile,name+str(i),\
str(ntr),str(nslices)])
general_cleaner(name + str(i), 1)
shell_command(['to3d','-epan','-prefix',name+str(i),\
'-xFOV','120R-120L','-yFOV','120A-120P',\
'-zSLAB',str(isvalues[0])+'I-'+str(isvalues[1])+'S',\
'-time:tz',str(ntr),str(nslices),str(tr_time)+'s',\
'seqplus','3D:0:0:64:64:'+str(ntr*nslices)+':'+name+str(i)])
general_cleaner(name + str(i), 0)
general_cleaner(name + str(i) + suffix_out, 1)
shell_command(['3dTcat','-prefix',name+str(i)+suffix_out,\
name+str(i)+'orig['+str(leadin)+'..'+str(ntr+1-leadout)+']'])
general_cleaner(name + str(i), 1)
catcmd.extend([name + str(i) + suffix_out + '+orig'])
shell_command(catcmd)
return suffix_out
def __runto3d(self,dicomdir,prefix='',keepfiles=True,dicomprefix='I*',movedir='../../'):
basedir = os.getcwd()
os.chdir(dicomdir)
if not prefix: print 'ERROR: no prefix specified. Will now crash...\n'
general_cleaner(prefix,1)
shell_command(['to3d','-prefix',prefix,dicomprefix])
headerinfo = shell_command(['3dinfo',prefix+'+orig'],ioflag=1)
if keepfiles:
shutil.move(prefix+'+orig.HEAD',movedir)
shutil.move(prefix+'+orig.BRIK',movedir)
else:
general_cleaner(prefix,1)
os.chdir(basedir)
return headerinfo
def highpass_filter(self,
dset_names=[],
suffix_in='n',
suffix_out='f',
highpass_val=.011):
for i, epi in enumerate(dset_names):
general_cleaner(epi + suffix_out, 1)
shell_command([
'3dFourier', '-prefix', epi + suffix_out, '-highpass',
str(highpass_val), epi + suffix_in + '+orig'
])
return {
'dset_out': [(x + suffix_out + '+orig') for x in dset_names],
'suffix_out': suffix_out
}
def blur_functionals(self,
dset_names=[],
suffix_in='m',
suffix_out='b',
kernel=4):
for epi in dset_names:
general_cleaner(epi + suffix_out, 1)
shell_command([
'3dmerge', '-prefix', epi + suffix_out, '-1blur_fwhm',
str(kernel), '-doall', epi + suffix_in + '+orig'
])
return {
'dset_out': [(x + suffix_out + '+orig') for x in dset_names],
'suffix_out': suffix_out
}
def output_nii(self):
output_path = os.path.join(self.save_dir,self.output_filename)
if self.use_mask:
newnii = nib.Nifti1Image(self.solution_shaped,self.mask_affine)
else:
newnii = nib.Nifti1Image(self.solution_shaped,self.raw_affine)
general_cleaner(output_path+'.nii',0)
general_cleaner(output_path,1)
newnii.to_filename(output_path+'.nii')
#EXTRA:
shell_command(['3dcopy',output_path+'.nii',output_path])
shell_command(['adwarp','-apar',os.path.join(self.save_dir,'TT_N27+tlrc'),'-dpar',output_path+'+orig','-overwrite'])
self.output_complete = True
def command(self):
for dset in self.dset_labels:
shell_command(['3dAFNItoNIFTI','-prefix',dset,dset+self.afni_format])
return {'dset_out':[(x+'.nii') for x in self.dset_labels]}
def command(self):
currentdir = os.getcwd()
for epi in self.dset_labels:
os.chdir('../'+self.scripts_dir)
if not os.path.exists('./talairach_mask+tlrc.HEAD'):
shutil.copy(self.talairach_path+'.HEAD','./'+self.talairach_path.split('/')[-1]+'.HEAD')
shutil.copy(self.talairach_path+'.BRIK.gz','./'+self.talairach_path.split('/')[-1]+'.BRIK.gz')
shell_command(['3dresample','-dxyz',str(self.talairach_dxyz),str(self.talairach_dxyz),
str(talairach_dxyz),'-prefix','talairach_resamp','-inset',
talairach_path.split('/')[-1]])
shell_command(['3dAutomask','-prefix','talairach_mask','-clfrac','0.1','talairach_resamp+tlrc'])
shell_command(['3dAFNItoNIFTI','-prefix','talairach_mask','talairach_mask+tlrc'])
os.chdir(currentdir)
general_cleaner(epi+self.suffix_out,1)
shell_command(['3dcalc','-a',epi+self.suffix_in+'+tlrc','-b',
'../'+self.scripts_dir+'/talairach_mask+tlrc',
'-expr', 'a*step(b)','-prefix',epi+self.suffix_out])
shell_command(['3dAFNItoNIFTI','-prefix',epi+self.suffix_out,epi+self.suffix_out+'+tlrc'])
return {'dset_out':[(x+suffix_out) for x in dset_labels],'suffix_out':suffix_out}
def mask_warped_functionals(self,dset_names=[],scripts_dir=[],talairach_path=[],
talairach_dxyz=[],suffix_in='f',suffix_out='_masked'):
currentdir = os.getcwd()
for epi in dset_names:
os.chdir('../'+scripts_dir)
if not os.path.exists('./talairach_mask+tlrc.HEAD'):
shutil.copy(talairach_path+'.HEAD','./'+talairach_path.split('/')[-1]+'.HEAD')
shutil.copy(talairach_path+'.BRIK.gz','./'+talairach_path.split('/')[-1]+'.BRIK.gz')
shell_command(['3dresample','-dxyz',str(talairach_dxyz),str(talairach_dxyz), \
str(talairach_dxyz),'-prefix','talairach_resamp','-inset', \
talairach_path.split('/')[-1]])
shell_command(['3dAutomask','-prefix','talairach_mask','-clfrac','0.1','talairach_resamp+tlrc'])
shell_command(['3dAFNItoNIFTI','-prefix','talairach_mask','talairach_mask+tlrc'])
os.chdir(currentdir)
general_cleaner(epi+suffix_out,1)
shell_command(['3dcalc','-a',epi+suffix_in+'+tlrc','-b','../'+scripts_dir+'/talairach_mask+tlrc',
'-expr', 'a*step(b)','-prefix',epi+suffix_out])
shell_command(['3dAFNItoNIFTI','-prefix',epi+suffix_out,epi+suffix_out+'+tlrc'])
return {'dset_out':[(x+suffix_out+'tlrc') for x in dset_names],'suffix_out':suffix_out}
def __parse_psizes(self,pfiles):
sizes = []
for file in pfiles:
size = shell_command(['du','-b',file],ioflag=1)
size = size.strip(' \n\t')
sizes.append([file,int(size[0])])
# calculate TR from filesize + hardcoded bytes per TR:
for i in range(len(sizes)):
sizes[i][1] = int(math.floor(sizes[i][1]/self.tr_bytes))
return sizes
def mask(self,suffix_in='f',suffix_out='_masked'):
print os.getcwd()
currentdir = os.getcwd()
for epi in self.func_names:
os.chdir('../'+self.scripts_dir)
if not os.path.exists('./talairach_mask+tlrc.HEAD'):
shutil.copy(self.talairach_path+'.HEAD','./'+self.talairach_path.split('/')[-1]+'.HEAD')
shutil.copy(self.talairach_path+'.BRIK.gz','./'+self.talairach_path.split('/')[-1]+'.BRIK.gz')
shell_command(['3dresample','-dxyz',str(self.talairach_dxyz),str(self.talairach_dxyz), \
str(self.talairach_dxyz),'-prefix','talairach_resamp','-inset', \
self.talairach_path.split('/')[-1]])
shell_command(['3dAutomask','-prefix','talairach_mask','-clfrac','0.1','talairach_resamp+tlrc'])
shell_command(['3dAFNItoNIFTI','-prefix','talairach_mask','talairach_mask+tlrc'])
os.chdir(currentdir)
general_cleaner(epi+suffix_out,1)
shell_command(['3dcalc','-a',epi+suffix_in+'+tlrc','-b','../'+self.scripts_dir+'/talairach_mask+tlrc', \
'-expr', 'a*step(b)','-prefix',epi+suffix_out])
shell_command(['3dAFNItoNIFTI','-prefix',epi+suffix_out,epi+suffix_out+'+tlrc'])
self.masked = True
return suffix_out
def convert_dset_to_nifti(self,dset_in=[]):
for dset in dset_in:
shell_command(['3dAFNItoNIFTI','-prefix',dset[:-5],dset])
return {'dset_out':[(x[:-5]+'.nii') for x in dset_in]}
def reconstruct_funcs_cni(self,
dset_names=[],
raw_funcs=[],
leadin=[],
leadouts=[]):
general_cleaner(dset_names, 1)
if len(raw_funcs) != len(dset_names):
print(
'\nWARNING: Functional labels not equal to number of functionals.\n'
)
else:
for i, (name, raw) in enumerate(zip(dset_names, raw_funcs)):
if type(raw) == type([]):
for j, nraw in enumerate(raw):
shell_command([
'3dTcat', '-prefix', name + str(j), nraw + '[' +
str(leadin) + '..' + str(leadouts[i][j]) + ']'
])
cat = [(name + str(j) + '+orig') for j in range(len(raw))]
cmd = ['3dTcat', '-prefix', name]
cmd = cmd.extend(cat)
shell_command(cmd)
elif os.path.exists('./' + raw):
shell_command([
'3dTcat', '-prefix', name,
raw + '[' + str(leadin) + '..' + str(leadouts[i]) + ']'
])
return {
'dset_out': [(x + '+orig') for x in dset_names],
'suffix_out': ''
}
def normalize_functionals(self,dset_names=[],suffix_in='b',suffix_out='n',calc_precision='float'):
for i,epi in enumerate(dset_names):
general_cleaner(epi+suffix_out,1)
general_cleaner(epi+'_average',1)
shell_command(['3dTstat','-prefix',epi+'_average',epi+suffix_in+'+orig'])
shell_command(['3drefit','-abuc',epi+'_average+orig'])
shell_command(['3dcalc','-datum',calc_precision,'-a',epi+suffix_in+'+orig',
'-b',epi+'_average+orig','-expr','((a-b)/b)*100',
'-prefix',epi+suffix_out])
return {'dset_out':[(x+suffix_out+'+orig') for x in dset_names],'suffix_out':suffix_out}
def command(self):
for i,epi in enumerate(self.dset_labels):
general_cleaner(epi+self.suffix_out,1)
general_cleaner(epi+'_average',1)
shell_command(['3dTstat','-prefix',epi+'_average',epi+self.suffix_in+'+orig'])
shell_command(['3drefit','-abuc',epi+'_average+orig'])
shell_command(['3dcalc','-datum',self.calc_precision,'-a',epi+self.suffix_in+'+orig',
'-b',epi+'_average+orig','-expr','((a-b)/b)*100',
'-prefix',epi+self.suffix_out])
return {'dset_out':[(x+self.suffix_out) for x in self.dset_labels],'suffix_out':self.suffix_out}
def normalize(self,suffix_in='m',suffix_out='n',calc_precision='float'):
for i,epi in enumerate(self.func_names):
general_cleaner(epi+suffix_out,1)
general_cleaner(epi+'_average',1)
shell_command(['3dTstat','-prefix',epi+'_average',epi+suffix_in+'+orig'])
shell_command(['3drefit','-abuc',epi+'_average+orig'])
shell_command(['3dcalc','-datum',calc_precision,'-a',epi+suffix_in+'+orig',
'-b',epi+'_average+orig','-expr','((a-b)/b)*100',
'-prefix',epi+suffix_out])
self.normalized = True
return suffix_out
def commands(self):
general_cleaner(self.dset_labels,1)
if len(self.raw_funcs) != len(self.dset_labels):
print('\nWARNING: Functional labels not equal to number of functionals.\n')
else:
for i,(name,raw) in enumerate(zip(self.dset_labels,self.raw_funcs)):
if type(raw) == type([]):
for j,nraw in enumerate(raw):
shell_command(['3dTcat','-prefix',name+str(j),nraw+'['+str(self.leadin)+'..'+str(self.leadouts[i][j])+']'])
cat = [(name+str(j)+'+orig') for j in range(len(raw))]
cmd = ['3dTcat','-prefix',name]
cmd = cmd.extend(cat)
shell_command(cmd)
elif os.path.exists('./'+raw):
shell_command(['3dTcat','-prefix',name,raw+'['+str(self.leadin)+'..'+str(self.leadouts[i])+']'])
def reconstruct_funcs(self):
general_cleaner(self.func_names,1)
if self.data_type == 'cni':
if not self.raw_funcs:
self.raw_funcs = self.__cni_find_raws(self.func_scan_nums)
pprint(self.raw_funcs)
if len(self.raw_funcs) != len(self.func_names):
print('\nWARNING: Functional labels not equal to number of functionals.\n')
else:
for i,(name,raw) in enumerate(zip(self.func_names,self.raw_funcs)):
if type(raw) == type([]):
for j,nraw in enumerate(raw):
shell_command(['3dTcat','-prefix',name+str(j),nraw+'['+str(self.leadin)+'..'+str(self.leadouts[i][j])+']'])
cat = [(name+str(j)+'+orig') for j in range(len(raw))]
cmd = ['3dTcat','-prefix',name]
cmd = cmd.extend(cat)
shell_command(cmd)
elif os.path.exists('./'+raw):
shell_command(['3dTcat','-prefix',name,raw+'['+str(self.leadin)+'..'+str(self.leadouts[i])+']'])
elif self.raw_funcs_alt:
cur_alt = self.raw_funcs_alt[i]
if os.path.exists('./'+cur_alt):
shell_command(['3dTcat','-prefix',name,cur_alt+'['+str(self.leadin)+'..'+str(self.leadouts[i])+']'])
else:
print 'ERROR: No alternate found, original not found.\n'
else:
print 'ERROR: original raw not found, no alternates defined.\n'
elif self.data_type == 'lucas':
allpfiles = glob.glob('*.mag')
pfile_sizes = self.__parse_psizes(allpfiles)
if not len(self.func_names) == len(self.pfiles_by_func):
print 'ERROR: functional name labels and pfiles by functional index do not match.\n'
else:
pfiles_trs = self.__assign_pfiles(self,pfile_sizes)
setattr(self,'pfiles_trs',pfiles_trs)
self.__lucas_3dtcat()
self.__lucas_3dtshift()
self.reconstructed_funcs = True
def rip_funcs_info(funcs):
trs = []
slices = []
for func in funcs:
if type(func) == type([]):
[sub_trs,sub_slices] = rip_funcs_info(func)
trs.append(sub_trs)
slices.append(sub_slices)
else:
info = shell_command(['3dinfo',func],ioflag=True)
linedinfo = info.split('\n')
rip_line = []
rip_parse = []
for line in linedinfo:
if line.find('Number of time steps') != -1:
rip_line = line.split(' ')
for item in rip_line:
if len(item) != 0:
rip_parse.append(item)
trs.append(int(rip_parse[5]))
slices.append(int(rip_parse[17]))
return [trs,slices]
def warp_functionals(self,suffix_in='f'):
for i,epi in enumerate(self.func_names):
shell_command(['adwarp','-apar',self.anat_name+'+tlrc','-dpar',epi+suffix_in+'+orig', \
'-dxyz',str(self.talairach_dxyz)])
self.warped_functionals = True
return suffix_in
def warp_anatomical(self, anat_name=[], talairach_path=[]):
shell_command(['@auto_tlrc','-warp_orig_vol','-suffix','NONE','-base', \
talairach_path,'-input',anat_name+'+orig.'])
return {'dset_out': anat_name + '+tlrc'}
def warp_anatomical(self):
# tailarach warp that sucker:
shell_command(['@auto_tlrc','-warp_orig_vol','-suffix','NONE','-base', \
self.talairach_path,'-input',self.anat_name+'+orig.'])
self.warped_anatomical = True
def reconstruct_anat_cni(self, anat_name=[], raw_anat=[]):
general_cleaner(anat_name, 1)
shell_command(['3dcopy', raw_anat, anat_name])
return {'dset_out': anat_name + '+orig'}
