def get_cmds(self, assessor, jobdir):
"""Method to generate the spider command for cluster job.
:param assessor: pyxnat assessor object
:param jobdir: jobdir where the job's output will be generated
:return: command to execute the spider in the job script
"""
assessor_label = assessor.label()
proj_label = assessor.parent().parent().parent().label()
subj_label = assessor.parent().parent().label()
sess_label = assessor.parent().label()
csess = XnatUtils.CachedImageSession(assessor._intf, proj_label,
subj_label, sess_label)
gad_cscans = XnatUtils.get_good_cscans(csess, self.gad_type)
gad = self.get_file_path(gad_cscans[0], SCAN_RESOURCE)
vessels_cscans = XnatUtils.get_good_cscans(csess, self.vessels_type)
vessels = self.get_file_path(vessels_cscans, SCAN_RESOURCE)
vessel_ids = [ves.info()['ID'] for ves in vessels_cscans]
cmd = SPIDER_FORMAT.format(spider=self.spider_path,
assr=assessor_label,
dir=jobdir,
exe=self.exe,
gad=','.join(gad),
vessels=','.join(vessels),
vesselsids=','.join(vessel_ids),
number_core=self.ppn,
working_dir=self.working_dir)
return [cmd]
def finish(self):
"""Method to copy the results in dax.RESULTS_DIR."""
out_dir = os.path.join(self.jobdir, 'outputs')
# Organise the outputs:
ala_dir = XnatUtils.makedir(os.path.join(out_dir, 'REG_ALA'))
aff_dir = XnatUtils.makedir(os.path.join(out_dir, 'AFF'))
reg_dir = XnatUtils.makedir(os.path.join(out_dir, 'REG_F3D'))
cpp_dir = XnatUtils.makedir(os.path.join(out_dir, 'CPP'))
# Copy files:
for scan_id, res_dict in self.sources.items():
for folder in ['REG_ALA', 'REG_F3D', 'AFF', 'CPP']:
old_path = glob.glob(os.path.join(out_dir, scan_id,
folder, '*'))[0]
new_path = os.path.join(out_dir, folder)
shutil.copy(old_path, new_path)
# Zipping all the dicoms in the OSIRIX folder and keep the zip
zip_osirix = os.path.join(out_dir, 'OSIRIX', 'osirix.zip')
results_dict = {'PDF': self.pdf_final,
'REG_ALA': ala_dir,
'AFF': aff_dir,
'REG_F3D': reg_dir,
'CPP': cpp_dir,
'OSIRIX': zip_osirix}
# Upload data:
self.upload_dict(results_dict)
self.end()
def run(self):
"""Method running the process for the spider on the inputs data."""
output_dir = XnatUtils.makedir(os.path.join(self.jobdir, 'outputs'))
osirix_dir = XnatUtils.makedir(os.path.join(self.jobdir, 'OsiriX'))
self.time_writer('Dicom folder: %s' % os.path.dirname(self.inputs[0]))
mat_lines = DEFAULT_ADC_TEMPLATE.format(
matlab_code=self.matlab_code,
input_path=os.path.dirname(self.inputs[0]),
output=output_dir,
pdf_name=self.pdf_final)
matlab_script = os.path.join(output_dir, 'run_matlab_verdict.m')
with open(matlab_script, "w") as f:
f.writelines(mat_lines)
self.run_matlab(matlab_script, verbose=True)
# Zip outputs:
# dcm_files = glob.glob(os.path.join(output_dir, '*', '*.dcm'))
dcm_files = get_dicom_list(output_dir)
for dicom in dcm_files:
shutil.copy(dicom, osirix_dir)
self.time_writer('Zipping OsiriX resource ...')
# Zip the DICOMs output:
initdir = os.getcwd()
# Zip all the files in the directory
zip_name = os.path.join(osirix_dir, 'osirix.zip')
os.chdir(osirix_dir)
os.system('zip -r %s * > /dev/null' % zip_name)
# return to the initial directory:
os.chdir(initdir)
def run(self):
"""Method running the process for the spider on the inputs data."""
matlabdir = os.path.join(self.jobdir, 'MATLAB/')
if not os.path.exists(matlabdir):
os.makedirs(matlabdir)
outputdir = os.path.join(self.jobdir, 'Outputs/')
if not os.path.exists(outputdir):
os.makedirs(outputdir)
matlab_script = os.path.join(matlabdir, 'callfMRIQA_v2.m')
f = open(matlab_script, "w")
try:
lines = ['% Matlab Script to call vufMRIQAGUI function\n',
'addpath(genpath(\''+str(self.fmatlab)+'\'));\n',
'outputdir = \''+str(outputdir)+'\';\n',
'imgfile=\''+str(self.inputs[0])+'\';\n',
'spm_path=\''+str(self.spm)+'\';\n',
'project=\''+str(self.xnat_project)+'\';\n',
'subject=\''+str(self.xnat_subject)+'\';\n',
'session=\''+str(self.xnat_session)+'\';\n',
'scan=\''+str(self.xnat_scan)+'\';\n',
'fMRIQA_Pipeline_v2(imgfile,outputdir,spm_path,project,\
subject,session,scan);\n'
]
f.writelines(lines)
finally:
f.close()
# Running Matlab script:
XnatUtils.run_matlab(matlab_script, True)
print '============================================================\n'
def run(self):
"""Method running the process for the spider on the inputs data."""
# Gzip files
input_file = ''
for filepath in self.inputs:
if filepath.endswith('.nii.gz'):
os.system("gzip -f -d %s" % (filepath))
input_file = filepath[:-3]
self.input_file = input_file
folder = os.path.join(self.jobdir, 'Sample_GM_Segment')
mat_lines = MAT_TEMPLATE.format(
matlab_code=self.matlab_code,
input_file=input_file,
spm12=self.spm12
)
matlab_script = os.path.join(folder, 'run_sample_GM.m')
with open(matlab_script, "w") as _fobj:
_fobj.writelines(mat_lines)
XnatUtils.run_matlab(matlab_script, verbose=True)
# Make report:
self.make_pdf()
# Gzip nii:
XnatUtils.gzip_nii(folder)
def download(self, obj_label, resource, folder):
"""
Return a python list of the files downloaded for the resource on the scan
example:
download(scan_id, "DICOM", "/Users/test")
or
download(assessor_label, "DATA", "/Users/test")
:param obj_label: xnat object label (scan ID or assessor label)
:param resource: folder name under the xnat object
:param folder: download directory
:return: python list of files downloaded
"""
# Open connection to XNAT
xnat = XnatUtils.get_interface(host=self.host,
user=self.user,
pwd=self.pwd)
resource_obj = self.select_obj(intf=xnat,
obj_label=obj_label,
resource=resource)
list_files = XnatUtils.download_files_from_obj(
directory=folder, resource_obj=resource_obj)
# close connection
xnat.disconnect()
return list_files
def has_inputs(self, csess):
"""Method overridden from base class.
By definition:
status = 0 -> NEED_INPUTS,
status = 1 -> NEED_TO_RUN
status = -1 -> NO_DATA
qcstatus needs a value only when -1 or 0.
You need to set qcstatus to a short string that explain
why it's no ready to run. e.g: No NIFTI
:param csess: object csess define in dax.XnatUtils
(see XnatUtils in dax for information)
:return: status, qcstatus
"""
gad_cscans = XnatUtils.get_good_cscans(csess, self.gad_type)
if not gad_cscans:
LOGGER.debug('Vessel Registration: No GAD scan found.')
return -1, 'No GAD found'
elif len(gad_cscans) > 1:
LOGGER.debug('Vessel Registration: Too many GAD scans found.')
return 0, 'Too many GAD found'
vessels_cscans = XnatUtils.get_good_cscans(csess, self.vessels_type)
if not vessels_cscans:
LOGGER.debug('Vessel Registration: No Vessels scans found.')
return -1, 'No Vessels found'
return 1, None
def generate_big_nifti(self):
"""Generate big nifti with all VERDICT acquisition files."""
for i in range(1, len(self.acquisitions.keys()) + 1):
f_img = nib.load(self.acquisitions[i][0]['4D'])
f_img_data = f_img.get_data()
data = np.zeros(
shape=(f_img_data.shape[0],
f_img_data.shape[1],
f_img_data.shape[2],
f_img_data.shape[3]*len(self.acquisitions[i])))
sorted_list = sorted(self.acquisitions[i],
key=lambda k: int(k['ID']))
for index, scan_info in enumerate(sorted_list):
# Open niftis with nibabel
f_img = nib.load(scan_info['reg'])
f_img_data = f_img.get_data()
for vol in range(0, f_img_data.shape[3]):
# Draw
vol_index = index*f_img_data.shape[3] + vol
data[:, :, :, vol_index] = f_img_data[:, :, :, vol]
nii_5d = nib.Nifti1Image(data, affine=f_img.affine)
acq_dir = XnatUtils.makedir(os.path.join(self.jobdir,
'outputs',
'ACQ%d' % i))
filename = '%s_acquisition%d.nii' % (self.xnat_session, i)
nii_file = os.path.join(acq_dir, filename)
nib.save(nii_5d, nii_file)
# gzip the nifti:
XnatUtils.gzip_file(nii_file)
def get_cmds(self, assessor, jobdir):
"""Method to generate the spider command for cluster job.
:param assessor: pyxnat assessor object
:param jobdir: jobdir where the job's output will be generated
:return: command to execute the spider in the job script
"""
proj_label = assessor.parent().parent().parent().label()
subj_label = assessor.parent().parent().label()
sess_label = assessor.parent().label()
csess = XnatUtils.CachedImageSession(assessor._intf, proj_label,
subj_label, sess_label)
target_cscans = XnatUtils.get_good_cscans(csess, self.target_type)
target_id = target_cscans[0].info()['ID']
source_cscans = XnatUtils.get_good_cscans(csess, self.sources_type)
sources_id = ','.join([sc.info()['ID'] for sc in source_cscans])
cmd = SPIDER_FORMAT.format(spider=self.spider_path,
proj=proj_label,
subj=subj_label,
sess=sess_label,
dir=jobdir,
target=target_id,
sources=sources_id,
regaladin=self.regaladin,
number_core=self.ppn,
suffix_proc=self.suffix_proc)
return [cmd]
def get_cmds(self, assessor, jobdir):
"""Method to generate the spider command for cluster job.
:param assessor: pyxnat assessor object
:param jobdir: jobdir where the job's output will be generated
:return: command to execute the spider in the job script
"""
proj_label = assessor.parent().parent().parent().label()
subj_label = assessor.parent().parent().label()
sess_label = assessor.parent().label()
assr_label = assessor.label()
csess = XnatUtils.CachedImageSession(assessor._intf, proj_label,
subj_label, sess_label)
dti_cscans = XnatUtils.get_good_cscans(csess, self.dtitypes)
dtis = ','.join([cscan.info()['ID'] for cscan in dti_cscans])
gif_cassrs = XnatUtils.get_good_cassr(csess, self.giftypes)
working_dir = os.path.join(self.working_dir, assr_label)
cmd = SPIDER_FORMAT.format(spider=self.spider_path,
proj=proj_label,
subj=subj_label,
sess=sess_label,
dir=jobdir,
suffix_proc=self.suffix_proc,
dti=dtis,
gif=gif_cassrs[0].info()['label'],
exe=self.exe,
gif_path=self.exe_args,
number_core=self.ppn,
working_dir=working_dir)
return [cmd]
def get_cmds(self, assessor, jobdir):
"""Method to generate the spider command for cluster job.
:param assessor: pyxnat assessor object
:param jobdir: jobdir where the job's output will be generated
:return: command to execute the spider in the job script
"""
proj_label = assessor.parent().parent().parent().label()
subj_label = assessor.parent().parent().label()
sess_label = assessor.parent().label()
nb_acq = 1
csess = XnatUtils.CachedImageSession(assessor._intf, proj_label,
subj_label, sess_label)
reg_verdict = ''
for cassr in csess.assessors():
if XnatUtils.is_cassessor_good_type(cassr, [self.proctype]):
reg_verdict = cassr
if XnatUtils.has_resource(reg_verdict, 'ACQ2'):
nb_acq = 2
cmd = SPIDER_FORMAT.format(spider=self.spider_path,
proj=proj_label,
subj=subj_label,
sess=sess_label,
dir=jobdir,
nb_acq=nb_acq,
proctype=self.proctype,
mc=self.mc,
camino=self.camino,
scheme=self.scheme_file,
suffix_proc=self.suffix_proc)
return [cmd]
def has_inputs(self, csess):
"""Method overridden from base class.
By definition:
status = 0 -> NEED_INPUTS,
status = 1 -> NEED_TO_RUN
status = -1 -> NO_DATA
qcstatus needs a value only when -1 or 0.
You need to set qcstatus to a short string that explain
why it's no ready to run. e.g: No NIFTI
:param csess: object csess define in dax.XnatUtils
(see XnatUtils in dax for information)
:return: status, qcstatus
"""
# Check that there is only one scan usable with the reference type and
# that the reference file as a NIFTI
verdict_cscans = XnatUtils.get_good_cscans(csess, self.modalities)
if not verdict_cscans:
LOGGER.debug('Processor_Registration_Verdict: \
cannot run at all, no VERDICT image found')
return -1, 'VERDICT not found'
for cscan in verdict_cscans:
if not XnatUtils.has_resource(cscan, 'NIFTI'):
LOGGER.debug('Processor_Registration_Verdict: \
cannot run, no NIFTI found for %s scan', cscan.info()['ID'])
return 0, "Missing NIFTI"
return 1, None
def make_pdf(self):
"""Method to make the PDF for the spider.
:return: None
"""
output_folder = os.path.join(self.jobdir, 'outputs')
pdfs_dir = XnatUtils.makedir(os.path.join(output_folder, 'pdfs'))
fpages = list()
# Run matlab function
for nb_acq in range(1, self.nb_acquisition + 1):
pdf_page = os.path.join(output_folder, str(nb_acq),
'VerdictMapAcq%d.pdf' % nb_acq)
mat_lines = DEFAULT_PDF_MAKER.format(
matlab_code=self.matlab_code,
maps_folder=os.path.join(output_folder, str(nb_acq),
'AMICO', self.model),
subject=self.xnat_subject,
output_folder=pdfs_dir,
acq=nb_acq)
matlab_script = os.path.join(output_folder,
'run_pdf_page_%d.m' % nb_acq)
with open(matlab_script, "w") as f:
f.writelines(mat_lines)
XnatUtils.run_matlab(matlab_script, verbose=True)
# Get all PDFs:
pdf_pages = XnatUtils.find_files(pdfs_dir, '.pdf')
# Merge all pdfs into one:
self.merge_pdf_pages(pdf_pages, pdf_page)
fpages.append(pdf_page)
if len(fpages) > 1:
self.merge_pdf_pages(fpages, self.pdf_final)
else:
shutil.move(fpages[0], self.pdf_final)
def define_spider_process_handler(self):
"""
Define the SpiderProcessHandler for the end of spider
using the init attributes about XNAT
:return: None
"""
# Create the SpiderProcessHandler if first time upload
if self.datatype == 'scan':
self.spider_handler = XnatUtils.SpiderProcessHandler(
self.spider_path,
self.suffix,
self.xnat_project,
self.xnat_subject,
self.xnat_session,
self.xnat_scan,
time_writer=self.time_writer)
else:
self.spider_handler = XnatUtils.SpiderProcessHandler(
self.spider_path,
self.suffix,
self.xnat_project,
self.xnat_subject,
self.xnat_session,
time_writer=self.time_writer)
def test_assessor_out_resources(self):
with XnatUtils.get_interface(host=host) as intf:
cisess = XnatUtils.CachedImageSession(intf, proj_id, subj_id,
sess_id)
for asr in cisess.assessors():
asrobj = intf.select_assessor(proj_id, subj_id, sess_id,
asr.label())
print((asrobj.out_resources()))
def run(self):
"""Method running the process for the spider on the inputs data."""
output_folder = XnatUtils.makedir(os.path.join(self.jobdir, 'outputs'))
osirix_folder = XnatUtils.makedir(os.path.join(output_folder,
'OsiriX'))
for nb_acq in range(1, self.nb_acquisition+1):
folder = os.path.join(output_folder, str(nb_acq))
os.makedirs(folder)
mat_lines = DEFAULT_VERDICT_TEMPLATE.format(
matlab_code=self.matlab_code,
input_path=os.path.dirname(self.inputs[nb_acq]),
subject=self.xnat_subject,
filename=os.path.basename(self.inputs[nb_acq]),
output=folder,
project=self.xnat_project,
camino=self.camino,
spams=self.spams,
scheme_filename=self.scheme_filename,
model=self.model)
matlab_script = os.path.join(output_folder,
'run_verdict_map%d.m' % nb_acq)
with open(matlab_script, "w") as f:
f.writelines(mat_lines)
self.run_matlab(matlab_script, verbose=True)
# Generate Dicom for OsiriX
outdir = os.path.join(output_folder, str(nb_acq), 'AMICO',
self.model)
# Load dicom headers
if not os.path.isfile(self.inputs['dcm']):
err = "DICOM File %s not found."
raise Exception(err % self.inputs['dcm'])
sour_obj = dicom.read_file(self.inputs['dcm'])
# Convert all niftis to dicoms
convert_niftis_2_dicoms(
outdir,
sour_obj,
osirix_folder,
nb_acq)
# Subtract the Cobj to the maps:
subtract_obj_to_map(outdir, sour_obj, osirix_folder, nb_acq)
# Make pdf:
self.make_pdf()
# Zip the DICOMs output:
initdir = os.getcwd()
# Zip all the files in the directory
zip_name = os.path.join(self.jobdir, 'outputs', 'OsiriX', 'osirix.zip')
os.chdir(os.path.join(self.jobdir, 'outputs', 'OsiriX'))
os.system('zip -r %s * > /dev/null' % zip_name)
# return to the initial directory:
os.chdir(initdir)
# Gzip nii:
XnatUtils.gzip_nii(outdir)
def run(self):
"""Method running the process for the spider on the inputs data."""
output_folder = XnatUtils.makedir(os.path.join(self.jobdir, 'outputs'))
osirix_folder = XnatUtils.makedir(os.path.join(output_folder,
'OsiriX'))
for nb_acq in range(1, self.nb_acquisition+1):
folder = os.path.join(output_folder, str(nb_acq))
os.makedirs(folder)
mat_lines = DEFAULT_VERDICT_TEMPLATE.format(
matlab_code=self.matlab_code,
input_path=self.inputs[nb_acq],
output=folder,
scheme_filename=self.scheme_filename,
camino=self.camino)
matlab_script = os.path.join(output_folder,
'run_matlab_adc_%d.m' % nb_acq)
with open(matlab_script, "w") as f:
f.writelines(mat_lines)
self.run_matlab(matlab_script, verbose=True)
# Generate Dicom for OsiriX
res_nii = os.path.join(folder, 'FIT_ADC.nii')
out_nii = os.path.join(folder,
'%s_FIT_ADC_%d.nii' % (self.xnat_session,
nb_acq))
shutil.move(res_nii, out_nii)
# Load dicom headers
if not os.path.isfile(self.inputs['dcm']):
err = "DICOM File %s not found."
raise Exception(err % self.inputs['dcm'])
sour_obj = dicom.read_file(self.inputs['dcm'])
# Convert all niftis to dicoms
convert_nifti_2_dicoms(
out_nii,
sour_obj,
osirix_folder,
nb_acq,
self.xnat_project,
self.xnat_subject,
self.xnat_session)
# Gzip nii:
XnatUtils.gzip_nii(folder)
# Make pdf:
self.make_pdf()
# Zip the DICOMs output:
initdir = os.getcwd()
# Zip all the files in the directory
zip_name = os.path.join(self.jobdir, 'outputs', 'OsiriX', 'osirix.zip')
os.chdir(os.path.join(self.jobdir, 'outputs', 'OsiriX'))
os.system('zip -r %s * > /dev/null' % zip_name)
# return to the initial directory:
os.chdir(initdir)
def run_matlab(self, mat_template, filename):
filepath = os.path.join(self.script_dir, filename)
template = Template(mat_template)
# Write the script
with open(filepath, 'w') as f:
f.write(template.substitute(self.run_inputs))
# Run the script
XnatUtils.run_matlab(filepath, verbose=True)
def run_matlab(self, mat_template, filename):
filepath = os.path.join(self.script_dir, filename)
template = Template(mat_template)
# Write the script
with open(filepath, 'w') as f:
f.write(template.substitute(self.run_inputs))
# Run the script
XnatUtils.run_matlab(filepath, verbose=True)
def test_xnat_parse_session(self):
with XnatUtils.get_interface(host=host) as intf:
intf.connect()
SanityChecks.__prep_project(intf)
yamldoc = YamlDoc().from_string(yamls.proc_a)
csess = XnatUtils.CachedImageSession(intf, proj_id, subj_id,
sess_id)
ap = AutoProcessor(XnatUtils, yamldoc)
ap.parse_session(ap)
def generate_bmask_whole(assessor_obj, assessor, tmpdir):
""" Generating the bmask whole from the assessor outputs."""
jobsdir = os.path.join(tmpdir, assessor['label'])
if not os.path.exists(jobsdir):
os.makedirs(jobsdir)
else:
shutil.rmtree(jobsdir)
os.makedirs(jobsdir)
files = XnatUtils.download_files_from_obj(jobsdir,
assessor_obj.resource('LABELS'))
if len(files) != 1:
raise Exception('Too many niftis downloaded.')
else:
input_nii = files[0]
tiv_files = XnatUtils.download_files_from_obj(jobsdir,
assessor_obj.resource('TIV'))
basepath = os.path.dirname(input_nii)
basename = os.path.basename(input_nii[:-7])
final_seg_mats_sub_cmd = os.path.join(
basepath, "%s_ArtConstruction_0.nii.gz " % basename)
for index, value in enumerate(BM_ARRAY):
output_nii = os.path.join(
basepath, "%s_ArtConstruction_%d.nii.gz " % (basename, index))
val_min = float(value - 0.5)
val_max = float(value + 0.5)
cmd = '%s %s -thr %f -uthr %f -bin %s' % (ARGS.seg_maths_exe,
input_nii, val_min, val_max,
output_nii)
print cmd
os.system(cmd)
final_seg_mats_sub_cmd += "-add %s " % output_nii
# Seg maths add
to_remove_nii = "%s_ToRemove.nii.gz" % basepath
cmd = '%s %s -bin %s' % (ARGS.seg_maths_exe, final_seg_mats_sub_cmd,
to_remove_nii)
print cmd
os.system(cmd)
# Seg maths remove
final_brain = "%s_FinalBrain.nii.gz" % basepath
cmd = '%s %s -sub %s -bin %s' % (ARGS.seg_maths_exe,
' '.join(tiv_files),
to_remove_nii,
final_brain)
print cmd
os.system(cmd)
return final_brain
def needs_run(self, cscan, xnat):
""" needs_run function overridden from base-class
cscan = CacheScan object from XnatUtils
return True or False
"""
scan_info = cscan.info()
if XnatUtils.has_resource(cscan, 'SNAPSHOTS'):
LOGGER.debug('Has snapshot')
return False
if not XnatUtils.has_resource(cscan, self.resourcename):
LOGGER.warn('Preview NIFTI -- '+scan_info['scan_id']+' -- no '+self.resourcename+' resource')
return False
return True
def register_nifti(self, source_info, target_info, output_folder,
acquisition_number):
"""Register the nifti source to the target.
:param source_info: dictionary information of source image
:param target_info: dictionary information of target image
:param output_folder: path to the output folder
:param acquisition_number: index of the acquisition
:return: path to the 4D nifti register
"""
# Variables:
ala_dir = XnatUtils.makedir(os.path.join(output_folder, 'REG_ALA'))
reg_dir = XnatUtils.makedir(os.path.join(output_folder, 'REG_RES'))
b1tob0 = os.path.join(ala_dir, 'b1tob0.txt')
volume_niis = {0: source_info['3D'][0]}
# Step 2:
# Register each scan b0 to the previous one
# (e.g: b3000 <- b2000)
cmd = REG_ALADIN_CMD.format(exe_path=self.reg_aladin_exe,
ref=target_info['3D'][0],
flo=source_info['3D'][0],
res=source_info['3D'][0],
aff=b1tob0,
args=self.args_reg_aladin)
self.run_system_cmd(cmd)
# Step 3:
# Propagate the transformation to the rest of the volume:
for index, volume in enumerate(source_info['3D']):
if index != 0:
vol_nii = os.path.join(reg_dir, 'volume_%s_reg.nii' % index)
cmd = REG_ALADIN_CMD.format(exe_path=self.reg_resample_exe,
ref=target_info['3D'][0],
flo=volume,
res=vol_nii,
aff=b1tob0,
args=self.args_reg_resample)
self.run_system_cmd(cmd)
volume_niis[index] = vol_nii
# Step 4:
# Put back the nifti together as one volume
final_nii = os.path.join(output_folder, '%s_%s_%d_reg.nii'
% (source_info['ID'],
source_info['type'],
acquisition_number))
join_nifti_3Ds_4D(volume_niis, final_nii)
return final_nii
def test_scan_full_object(self):
with SanityChecks.__get_connection() as intf:
scanobj1 = intf.select_scan(proj_id, subj_id, sess_id, scan_id)
csess = XnatUtils.CachedImageSession(intf, proj_id, subj_id, sess_id)
cscan = filter(lambda x: x.label() == scan_id, csess.scans())[0]
scanobj2 = cscan.full_object()
self.assertEqual(scanobj1.label(), scanobj2.label())
def main():
""" Main function."""
if ENV_SOURCE is not None and os.path.isfile(ENV_SOURCE):
os.system('sh {}'.format(ENV_SOURCE))
_working_dir = None
if WORKING_DIR != 'None':
_working_dir = os.path.join(WORKING_DIR, '${assessor_label}')
if not os.path.exists(_working_dir):
os.makedirs(_working_dir)
if XnatUtils.executable_exists(NIFTYPIPE_EXE):
_omp = ''
_wd = ''
if OPENMP_CORE is not None and OPENMP_CORE != 'None':
_omp = OMP.format(number_core=OPENMP_CORE)
if _working_dir is not None:
_wd = WDIR.format(working_dir=_working_dir)
cmd = EXE_CMD.format(
dwis=' '.join(DWIS.split(',')),
bvals=' '.join(BVALS.split(',')),
bvecs=' '.join(BVECS.split(',')),
omp=_omp, wdir=_wd)
os.system(cmd)
make_pdf()
else:
raise Exception("Error: executable %s not found" % (NIFTYPIPE_EXE))
def copy_inputs(self):
self.run_inputs = self.src_inputs
for _input in self.copy_list:
src = self.src_inputs[_input]
if src.startswith('xnat://'):
src = src[len('xnat:/'):]
_res, _file = src.split('/files/')
dst = os.path.join(self.input_dir, _file)
print('DEBUG:downloading from XNAT:'+src+' to '+dst)
try:
xnat = XnatUtils.get_interface(self.host, self.user, self.pwd)
res = xnat.select(_res)
result = res.file(_file).get(dst)
except:
print('ERROR:downloading from XNAT')
return
else:
dst = os.path.join(self.input_dir, os.path.basename(src))
print('DEBUG:copying src:'+src+' to '+dst)
copyfile(src, dst)
self.run_inputs[_input] = dst
return self.run_inputs
def needs_run(self, cscan, xnat):
"""needs_run function overridden from base-class.
cscan = CacheScan object from XnatUtils
return True or False
"""
# Check output
if XnatUtils.has_resource(cscan, 'NIFTI'):
LOGGER.debug('Has NIFTI')
return False
# Check input
if not XnatUtils.has_resource(cscan, 'DICOM'):
LOGGER.debug('no DICOM resource')
return False
return True
def prerun(self, settings_filename=''):
""" prerun function overridden from base-class """
LOGGER.info('loading XNAT...')
self.xnat = XnatUtils.get_interface()
LOGGER.info('loading REDCap...')
self.load_redcap()
LOGGER.info('checking Projects of Prearchive Scans..')
self.load_prearchive()
self.check_projects()
LOGGER.info('do archiving...')
self.load_prearchive()
self.do_archiving()
LOGGER.info('crosscheck redcap...')
self.crosscheck_redcap()
self.xnat.disconnect()
if self.send_an_email:
LOGGER.info('sending email with report of errors')
self.send_report()
LOGGER.info('DONE')
def __init__(self, spider_path, jobdir, scans_id,
xnat_project, xnat_subject, xnat_session,
reg_aladin_exe='reg_aladin', reg_resample_exe='reg_resample',
args_reg_aladin=DEFAULT_ARGS_REG_ALADIN,
args_reg_resample=DEFAULT_ARGS_REG_RESAMPLE,
xnat_host=None, xnat_user=None, xnat_pass=None, suffix=""):
"""Entry point for Spider_Registration_Prostate Class."""
super(Spider_Registration_Verdict, self).__init__(spider_path, jobdir,
xnat_project,
xnat_subject,
xnat_session,
xnat_host,
xnat_user,
xnat_pass, suffix)
# Inputs
self.acquisitions = dict()
self.dicom = ''
self.scans_id = XnatUtils.get_input_list(scans_id, list())
# Outputs
self.pdf_final = os.path.join(self.jobdir, 'Registration_VERDICT.pdf')
# Check Executable:
self.reg_aladin_exe = self.check_executable(reg_aladin_exe,
'reg_aladin')
self.reg_resample_exe = self.check_executable(reg_resample_exe,
'reg_resample')
self.args_reg_aladin = args_reg_aladin
self.args_reg_resample = args_reg_resample
def prerun(self, settings_filename=''):
""" prerun function overridden from base-class """
LOGGER.info('loading XNAT...')
self.xnat = XnatUtils.get_interface()
LOGGER.info('loading REDCap...')
self.load_redcap()
LOGGER.info('checking Projects of Prearchive Session..')
self.load_prearchive()
moving = self.check_projects()
if moving: # wait for moves to complete
LOGGER.info('sessions moving projects, waiting '+str(MOVING_SLEEP_SECS)+' secs')
time.sleep(MOVING_SLEEP_SECS)
else:
LOGGER.info('no sessions changed, continuing to archiving')
LOGGER.info('do archiving...')
self.load_prearchive()
self.do_archiving()
LOGGER.info('crosscheck redcap...')
self.crosscheck_redcap()
self.xnat.disconnect()
if self.send_an_email:
LOGGER.info('sending email with report of errors')
self.send_report()
LOGGER.info('DONE')
def run(self, scan_info, scan_obj):
""" main function to run on scan """
if not len(scan_obj.resource(self.resourcename).files().get()) > 0:
LOGGER.warn('Preview NIFTI -- '+scan_info['scan_id']+' -- No file(s) for '+self.resourcename)
else:
LOGGER.debug("downloading "+self.resourcename+"...")
fpath = XnatUtils.download_biggest_file_from_obj(self.directory, scan_obj.resource(self.resourcename))
if not os.path.exists(fpath):
LOGGER.warn('Preview NIFTI -- '+scan_info['scan_id']+' -- '+self.resourcename+' file size is zero.')
else:
sm_gif = str(os.path.join(self.directory, os.path.splitext(os.path.basename(fpath))[0] + "_sm.gif"))
lg_gif = str(os.path.join(self.directory, os.path.splitext(os.path.basename(fpath))[0] + "_lg.gif"))
# Generate preview from the nifti file
self.generate_preview(fpath, sm_gif, lg_gif)
if os.path.isfile(sm_gif):
LOGGER.debug('GIF Made / upload ...')
scan_obj.resource('SNAPSHOTS').file('snap_t.gif').put(sm_gif, 'GIF', 'THUMBNAIL')
scan_obj.resource('SNAPSHOTS').file('snap.gif').put(lg_gif, 'GIF', 'ORIGINAL')
else:
LOGGER.error('Preview NIFTI -- '+scan_info['scan_id']+' -- GIF FAILED')
self.log_warning_error('GIF failed for NIFTI', scan_info, error=True)
self.clean_directory()
def test_setup_old_assessors(self):
intf = XnatUtils.get_interface(host)
proj_id = 'proj1'
subj_id = 'subj1'
sess_ids = ['sess2', 'sess1']
project = intf.select_project(proj_id)
if not project.exists():
self.assertTrue(False, 'proj1 should be pre-created for this test')
subject = intf.select_subject(proj_id, subj_id)
if not subject.exists():
self.assertTrue(False, 'subj1 should be pre-created for this test')
for s in sess_ids:
session = intf.select_experiment(proj_id, subj_id, s)
if not session.exists():
self.assertTrue(False, 'sess1 should be pre-created for this test')
# delete and recreate scans
scan_descriptors = [('1', 't1'), ('2', 't1'), ('11', 'flair')]
ComponentTestBuild._setup_scans(session, scan_descriptors)
# delete and recreate old assessors
ComponentTestBuild._setup_assessors(proj_id, subj_id, session)
def main():
""" Main function."""
_working_dir = None
if WORKING_DIR != 'None':
_working_dir = os.path.join(WORKING_DIR, '${assessor_label}')
if not os.path.exists(_working_dir):
os.makedirs(_working_dir)
if XnatUtils.executable_exists(NIFTYPIPE_EXE):
_omp = ''
_wd = ''
if OPENMP_CORE is not None and OPENMP_CORE != 'None':
_omp = OMP.format(number_core=OPENMP_CORE)
if _working_dir is not None:
_wd = WDIR.format(working_dir=_working_dir)
cmd = EXE_CMD.format(exe_path=NIFTYPIPE_EXE,
gad=GAD_FILE,
mprage=MPRAGE_FILE,
labels=LABELS_FILE,
brain=BRAIN_FILE,
output=JOB_DIR,
omp=_omp,
wdir=_wd)
os.system(cmd)
rename_outputs()
make_pdf()
else:
raise Exception("Error: executable %s not found" % (NIFTYPIPE_EXE))
def test_assessor_full_object(self):
with SanityChecks.__get_connection() as intf:
assrobj1 = intf.select_assessor(proj_id, subj_id, sess_id, assr_id)
csess = XnatUtils.CachedImageSession(intf, proj_id, subj_id, sess_id)
cassr = filter(lambda x: x.label() == assr_id, csess.assessors())[0]
assrobj2 = cassr.full_object()
self.assertEqual(assrobj1.label(), assrobj2.label())
def main():
""" Main function."""
assr_handler = XnatUtils.AssessorHandler(ASSESSOR)
session = assr_handler.get_session_label()
moda = 'T1 FLAIR'
if T2_FILE:
moda = 'T1 FLAIR T2'
_working_dir = None
if WORKING_DIR != 'None':
_working_dir = os.path.join(WORKING_DIR, ASSESSOR)
if not os.path.exists(_working_dir):
os.makedirs(_working_dir)
if XnatUtils.executable_exists(NIFTYPIPE_EXE):
_omp = ''
_wd = ''
_t2 = ''
if OPENMP_CORE is not None and OPENMP_CORE != 'None':
_omp = OMP.format(number_core=OPENMP_CORE)
if _working_dir is not None:
_wd = WDIR.format(working_dir=_working_dir)
if T2_FILE is not None and T2_FILE != 'None':
_t2 = T2.format(working_dir=T2_FILE)
cmd = EXE_CMD.format(
exe=NIFTYPIPE_EXE, modalities=moda, t2=_t2, omp=_omp, wdir=_wd)
os.system(cmd)
# PDF
make_pdf(session)
else:
raise Exception("Error: executable %s not found" % (NIFTYPIPE_EXE))
def test_setup_old_assessors(self):
intf = XnatUtils.get_interface(host)
proj_id = 'proj1'
subj_id = 'subj1'
sess_ids = ['sess2', 'sess1']
project = intf.select_project(proj_id)
if not project.exists():
self.assertTrue(False, 'proj1 should be pre-created for this test')
subject = intf.select_subject(proj_id, subj_id)
if not subject.exists():
self.assertTrue(False, 'subj1 should be pre-created for this test')
for s in sess_ids:
session = intf.select_experiment(proj_id, subj_id, s)
if not session.exists():
self.assertTrue(False,
'sess1 should be pre-created for this test')
# delete and recreate scans
scan_descriptors = [('1', 't1'), ('2', 't1'), ('11', 'flair')]
ComponentTestBuild._setup_scans(session, scan_descriptors)
# delete and recreate old assessors
ComponentTestBuild._setup_assessors(proj_id, subj_id, session)
def main():
""" Main function."""
_working_dir = None
if WORKING_DIR != 'None':
_working_dir = os.path.join(WORKING_DIR, '${assessor_label}')
if not os.path.exists(_working_dir):
os.makedirs(_working_dir)
if XnatUtils.executable_exists(NIFTYPIPE_EXE):
_omp = '' if OPENMP_CORE == 'None' \
else OMP.format(number_core=OPENMP_CORE)
_wd = '' if _working_dir is not None \
else '--working_dir {0}'.format(_working_dir)
_min = '' if MIN == 'None' else '--min {0}'.format(MIN)
_max = '' if MAX == 'None' else '--max {0}'.format(MAX)
cmd = EXE_CMD.format(exe_path=NIFTYPIPE_EXE,
vessels=" ".join(VESSELS_FILES.split(',')),
output=JOB_DIR,
omp=_omp,
wdir=_wd,
min=_min,
max=_max,
ct='--ct' if CT == '1' else '')
os.system(cmd)
make_pdf()
else:
raise Exception("Error: executable %s not found" % (NIFTYPIPE_EXE))
def main():
""" Main function."""
if ENV_SOURCE is not None and ENV_SOURCE != 'None' \
and os.path.isfile(ENV_SOURCE):
os.system('sh {}'.format(ENV_SOURCE))
_working_dir = None
if WORKING_DIR != 'None':
_working_dir = os.path.join(WORKING_DIR, '${assessor_label}')
if not os.path.exists(_working_dir):
os.makedirs(_working_dir)
if os.path.exists(NIFTYPIPE_EXE) or \
XnatUtils.executable_exists(NIFTYPIPE_EXE):
if OPENMP_CORE is not None and OPENMP_CORE != 'None':
_omp = OMP.format(number_core=OPENMP_CORE)
if _working_dir is not None:
_wd = WDIR.format(working_dir=_working_dir)
cmd = EXE_CMD.format(exe=NIFTYPIPE_EXE,
input=IN_FILE,
output=JOB_DIR,
db_xml=DB_TEMPLATE,
omp=_omp, wdir=_wd)
os.system(cmd)
make_pdf()
else:
raise Exception("Error: %s not found" % (NIFTYPIPE_EXE))
def generate_4D_nifti(folder_path):
"""
Generate a 4D nifti from 3D nifti
:param folder_path: folder containing the .nii files
"""
nii_dict = organise_niftis(fpath)
print "Converting 3D niftis into 4D nifti for folder %s ." % folder_path
matlab_script = os.path.join(folder_path, 'convert3Din4D.m')
f = open(matlab_script, "w")
try:
prefix_str = "{"
for key in nii_dict.keys():
prefix_str += "'%s'," % key
prefix_str = prefix_str[:-1] + "}"
lines = [ "% Matlab Script to call vufMRIQAGUI function\n",
"addpath(genpath('/Users/byvernault/home-local/masimatlab/trunk/xnatspiders/matlab/ext'));\n",
"addpath('/Users/byvernault/Documents/MATLAB');\n",
"folder_niis = '%s';\n" % folder_path,
"prefix = %s;\n" % prefix_str,
"dti = %s;\n" % (1 if ARGS.onedti else 0),
"untouch = %s;\n" % (1 if ARGS.untouch else 0),
"convert3Dto4DNII(folder_niis, prefix, dti, untouch);\n"]
f.writelines(lines)
finally:
f.close()
for key, nii_list in nii_dict.items():
filename = os.path.join(folder_path, "%s_4D.nii.gz" % key)
if os.path.isfile(filename):
print"INFO: NIFTI already created. Skipping ... "
return
#Running Matlab script:
XnatUtils.run_matlab(matlab_script, True)
for key, nii_list in nii_dict.items():
filename = os.path.join(folder_path, "%s_4D.nii" % key)
if not os.path.isfile(filename):
print"ERROR: NO NIFTI CREATED ... "
else:
# copying with fsl the header:
print "Copying geometry from 3D nifti and gzipping the nifti for %s" % filename
cmd = "fslcpgeom %s %s -d" % (nii_list[0], filename)
os.system(cmd)
os.system("gzip %s " % filename)
def test_xnat_has_inputs(self):
with XnatUtils.get_interface(host=host) as intf:
intf.connect()
print((yamls.proc_a))
SanityChecks.__prep_project(intf)
yamldoc = YamlDoc().from_string(yamls.proc_a)
ap = AutoProcessor(XnatUtils, yamldoc)
csess = XnatUtils.CachedImageSession(intf, proj_id, subj_id,
sess_id)
results = []
for cassr in csess.assessors():
has, errors = ap.has_inputs(cassr)
results.append((has, errors))
print(results)
def test_xnat_get_full_object(self):
with XnatUtils.get_interface(host=host) as intf:
intf.connect()
print(map(lambda x: x['name'], intf.get_projects()))
print(map(lambda x: x['label'], intf.get_subjects(proj_id)))
subj = intf.select(XnatUtils.InterfaceTemp.S_XPATH.format(project=proj_id, subject=subj_id))
print(subj.label())
print(subj.parent().label())
def needs_run(self, cscan, xnat):
""" needs_run function overridden from base-class
cscan = CacheScan object from XnatUtils
return True or False
"""
# Check output
if XnatUtils.has_resource(cscan, 'NIFTI'):
LOGGER.debug('Has NIFTI')
return False
# Check input
if not XnatUtils.has_resource(cscan, 'DICOM'):
LOGGER.debug('No DICOM resource')
return False
if XnatUtils.is_cscan_unusable(cscan):
LOGGER.debug('Unusable scan')
return False
return True
def test_setup_session(self):
proj_id = 'proj1'
subj_id = 'subj1'
sess_ids = ['sess1', 'sess2']
intf = XnatUtils.get_interface(host=host)
scan_descriptors = [('1', 't1'), ('2', 't1'), ('11', 'flair'),
('12', 'flair'), ('21', 't2')]
for sess_id in sess_ids:
session = intf.select_experiment(proj_id, subj_id, sess_id)
if not session.exists():
self.assertTrue(False, "no such session")
ComponentTestBuild._setup_scans(session, scan_descriptors)
def test_xnat_get_cached_image_session(self):
with XnatUtils.get_interface(host=host) as intf:
cisess = XnatUtils.CachedImageSession(intf, proj_id, subj_id,
sess_id)
print(cisess)
print((cisess.info()))
for ciscan in cisess.scans():
print((ciscan.info()))
scanobj = ciscan.full_object()
print(scanobj)
for ciassr in cisess.assessors():
print((ciassr.info()))
for cirsrc in ciassr.out_resources():
print((cirsrc.info()))
asrinfo = ciassr.info()
rsrcobj = intf.select_assessor_resource(
asrinfo['project_id'], asrinfo['subject_id'],
asrinfo['session_id'], asrinfo['assessor_label'],
cirsrc.info()['label'])
print(rsrcobj)
sessobj = cisess.full_object()
print(sessobj)
def test_clean_scans_from_test_session(self):
proj_id = 'proj1'
subj_id = 'subj1'
sess_ids = ['sess1', 'sess2']
# subj_id = 'subj2'
# sess_ids = ['sess3', 'sess4']
intf = XnatUtils.get_interface(host=host)
for sess_id in sess_ids:
session = intf.select_experiment(proj_id, subj_id, sess_id)
if not session.exists():
self.assertTrue(False, "no such session")
for scn in session.scans():
scn.delete()
def get_cmds(self, assessor, job_dir_path):
"""
This function generates the spider command for the cluster job
"""
project = assessor.parent().parent().parent().label()
subject = assessor.parent().parent().label()
session = assessor.parent().label()
csess = XnatUtils.CachedImageSession(assessor._intf, project, subject,
session)
xnat = XnatUtils.get_interface()
scan = csess.scans()[0].label()
scan_data = get_scan_resource_uri(xnat, project, subject, session,
scan)
cmd = csai_CMD.format(spider_path=self.spider_path,
job_dir_path=job_dir_path,
assessor_label=assessor.label(),
project=project,
subject=subject,
session=session,
scan_data=scan_data,
suffix_proc=self.suffix_proc,
matlab_utils=self.matlab_utils,
matlab_bin=self.matlab_path)
return [cmd]
def test_clean_assessors_from_test_session(self):
proj_id = 'proj1'
subj_id = 'subj1'
sess_ids = ['sess1', 'sess2']
# subj_id = 'subj2'
# sess_ids = ['sess3', 'sess4']
intf = XnatUtils.get_interface(host=host)
for sess_id in sess_ids:
session = intf.select_experiment(proj_id, subj_id, sess_id)
if not session.exists():
self.assertTrue(False, "no such session")
for asr in session.assessors():
print((assessor_utils.full_label_from_assessor(asr)))
asr.delete()
def needs_run(self, cscan, xnat):
""" needs_run function overridden from base-class
cscan = CacheScan object from XnatUtils
return True or False
"""
_info = cscan.info()
if _info['type'] not in self.scan_types:
return False
# Check for existing EDAT resource
if XnatUtils.has_resource(cscan, 'EDAT'):
LOGGER.debug('Has EDAT')
return False
return True
def test_get_assessor_inputs(self):
class TestAssessor:
class TestAttrs:
def __init__(self, datatype, property):
self.datatype = datatype
self.property = property
def get(self, name):
if name == self.datatype + '/' + self.property:
return json.dumps({'a': 'b'})
else:
raise IndexError("it's an index error")
def __init__(self, datatype, property):
self.attrs = TestAssessor.TestAttrs(datatype, property)
self.datatype_ = datatype
def datatype(self):
return self.datatype_
assr = TestAssessor('proc:genProcData', 'inputs')
assr2 = TestAssessor('something', 'else')
self.assertEqual(XnatUtils.get_assessor_inputs(assr), {'a': 'b'})
self.assertEqual(XnatUtils.get_assessor_inputs(assr2), None)
def __init__(self,
mod_name=DEFAULT_MODULE_NAME,
directory=DEFAULT_TMP_PATH,
email=None,
text_report=DEFAULT_TEXT_REPORT,
limbo=DEFAULT_LIMBO_DIR,
scan_types='fMRI_EDP,fMRI_Posner,fMRI_NBack,fMRI_EmoStroop',
scan_map=DEFAULT_MAP):
super(Module_edat_limbo2xnat, self).__init__(mod_name,
directory,
email,
text_report=text_report)
self.limbo = limbo
self.scan_map = scan_map
self.scan_types = XnatUtils.get_input_list(scan_types, None)
self.xnat = None
def test_create_assessor_with_no_input(self):
with XnatUtils.get_interface(host=host) as intf:
intf.connect()
e = intf.select_experiment(proj_id, subj_id, sess_id)
if not e.exists():
self.assertTrue(
False, "Unexpected: {}//{}//{} does not exist".format(
proj_id, subj_id, sess_id))
proc_a_params = {
'xsitype': asrxsitype,
'proctype': 'Proc_A_v1',
'files': [('SEG', ['seg.gz'])]
}
SessionTools.add_assessor(e, 'proc1-x-subj1-x-sess1-x-2-Proc_A_v1',
proc_a_params, 'no_inputs')
def download_xnat_resource(self, src, dst):
result = None
try:
xnat = XnatUtils.get_interface(self.host, self.user, self.pwd)
try:
res = xnat.select(src)
res.get(dst, extract=True)
result = dst
except:
print('ERROR:downloading from XNAT')
except:
print('ERROR:FAILED to get XNAT connection')
finally:
xnat.disconnect()
return result
def download_xnat_file(self, src, dst):
result = None
try:
xnat = XnatUtils.get_interface(self.host, self.user, self.pwd)
try:
_res, _file = src.split('/files/')
res = xnat.select(_res)
result = res.file(_file).get(dst)
except:
print('ERROR:downloading from XNAT')
except:
print('ERROR:FAILED to get XNAT connection')
finally:
xnat.disconnect()
return result
def upload_converted_images(self, dcm_dir, scan_obj, scan_info):
""" upload images after checking them """
nifti_list = []
bval_path = ''
bvec_path = ''
LOGGER.debug('uploading the NIFTI files to XNAT...')
# Get the NIFTI/bvec/bval files from the folder:
for fpath in glob.glob(os.path.join(dcm_dir, '*')):
if not os.path.isfile(fpath):
continue
if fpath.lower().endswith('.bval'):
bval_path = fpath
elif fpath.lower().endswith('.bvec'):
bvec_path = fpath
elif fpath.endswith('ADC.nii.gz'):
LOGGER.warn('ignoring ADC NIFTI:' + fpath)
elif fpath.lower().endswith('.nii.gz'):
nifti_list.append(fpath)
# Check
success = self.check_outputs(scan_info, nifti_list, bval_path,
bvec_path)
if not success:
print('not successful?')
return
# Upload
XnatUtils.upload_files_to_obj(nifti_list,
scan_obj.resource('NIFTI'),
remove=True)
if os.path.isfile(bval_path) and os.path.isfile(bvec_path):
# BVAL/BVEC
XnatUtils.upload_file_to_obj(bval_path,
scan_obj.resource('BVAL'),
remove=True)
XnatUtils.upload_file_to_obj(bvec_path,
scan_obj.resource('BVEC'),
remove=True)
# more than one NIFTI uploaded
if len(nifti_list) > 1:
LOGGER.warn('dcm2nii:{} multiple NIFTI'.format(
scan_info['scan_id']))
self.log_warning_error('multiple NIFTI', scan_info)
def __init__(self,
spider_path,
jobdir,
xnat_project,
xnat_subject,
xnat_session,
xnat_host=None,
xnat_user=None,
xnat_pass=None,
suffix="",
subdir=True,
skip_finish=False):
"""
Entry point for the Base class for spider
:param spider_path: spider file path
:param jobdir: directory for temporary files
:param xnat_project: project ID on XNAT
:param xnat_subject: subject label on XNAT
:param xnat_session: experiment label on XNAT
:param xnat_host: host for XNAT if not set in environment variables
:param xnat_user: user for XNAT if not set in environment variables
:param xnat_pass: password for XNAT if not set in environment variables
:param suffix: suffix to the assessor creation
:param subdir: create a subdir Temp in the jobdir if the directory isn't empty
"""
# Spider path:
self.spider_path = spider_path
# directory for temporary files + create it
self.jobdir = XnatUtils.makedir(os.path.abspath(jobdir), subdir=subdir)
# to copy results at the end
self.spider_handler = None
# Xnat info:
self.xnat_project = xnat_project
self.xnat_subject = xnat_subject
self.xnat_session = xnat_session
# Xnat connection settings:
self.host = self.get_default_value("host", "XNAT_HOST", xnat_host)
self.user = self.get_default_value("user", "XNAT_USER", xnat_user)
self.pwd = self.get_pwd(xnat_pass, xnat_user)
# Suffix
if not suffix:
self.suffix = ""
else:
# Set the suffix_proc remove any special characters and replace by '_'
self.suffix = re.sub('[^a-zA-Z0-9]', '_', suffix)
# Replace multiple underscores by one
self.suffix = re.sub('_+', '_', self.suffix)
# Remove underscore if at the end of suffix
if self.suffix[-1] == '_': self.suffix = self.suffix[:-1]
# Add an underscore at the beginning if not present
if self.suffix[0] != '_': self.suffix = '_' + self.suffix
# print time writer:
self.time_writer = TimedWriter()
# Export the variable:
os.environ['XNAT_HOST'] = self.host
os.environ['XNAT_USER'] = self.user
os.environ['XNAT_PASS'] = self.pwd
# run the finish or not
self.skip_finish = skip_finish
def __get_connection():
return XnatUtils.get_interface(host=host)
import json
import sys
import pandas
import pyxnat
import argparse
import time
from dax import XnatUtils
from dax import utilities
# Specify and parse command line arguments
parser = argparse.ArgumentParser()
parser.add_argument('project', help='Project name')
args = parser.parse_args()
print('Project: {}'.format(args.project))
xnat = XnatUtils.get_interface()
Assrs = XnatUtils.list_project_assessors(xnat, args.project)
xnat.disconnect()
timestamp = time.strftime("%Y%m%d%H%M%S")
outfile1 = 'status_by_assessor_{}_{}.csv'.format(args.project, timestamp)
outfile2 = 'status_by_session_{}_{}.csv'.format(args.project, timestamp)
R = list()
for assr in Assrs:
#print(assr['assessor_label'])
# Get desired fields
thisR = {}
for key in ('project_label', 'subject_label', 'session_label', 'proctype',
# TODO: daxlauncher.upload()
import logging
from dax import bin, XnatUtils
# Create the launcher
settingspath = '/Users/boydb1/.dax/settings/settings-subjgenproc.yaml'
daxlauncher = bin.read_yaml_settings(settingspath, logging.getLogger())
# Get xnat connection
xnat = XnatUtils.get_interface(host=daxlauncher.xnat_host)
# Build
print('building')
project = 'DepMIND2'
daxlauncher.build_project_subjgenproc(xnat, project)
print('All Done!')
def test_session_full_object(self):
with SanityChecks.__get_connection() as intf:
sessobj1 = intf.select_experiment(proj_id, subj_id, sess_id)
sessobj2 = XnatUtils.CachedImageSession(intf, proj_id, subj_id,
sess_id).full_object()
self.assertEqual(sessobj1.label(), sessobj2.label())
#!python
import sys
import pyxnat
from dax import XnatUtils
source_project = sys.argv[1]
dest_project = sys.argv[2]
subject = sys.argv[3]
xnat = XnatUtils.InterfaceTemp()
# Subject variables
source_subject = xnat.select('/projects/{0}/subjects/{1}'.format(
source_project, subject))
dest_subject = xnat.select('/projects/{0}/subjects/{1}'.format(
dest_project, subject))
dob = source_subject.attrs.get('xnat:demographicData/dob')
gender = source_subject.attrs.get('xnat:demographicData/gender')
handedness = source_subject.attrs.get('xnat:demographicData/handedness')
race = source_subject.attrs.get('xnat:demographicData/race')
#sid = source_subject.attrs.get("xnat:subjectData/fields/field[name='id']/field")
sid = source_subject.xpath(
"/xnat:Subject/xnat:fields/xnat:field[@name='id']/text()[2]")[0]
dest_subject.attrs.set(
'xnat:subjectData/demographics[@xsi:type=xnat:demographicData]/dob', dob)
dest_subject.attrs.set(
'xnat:subjectData/demographics[@xsi:type=xnat:demographicData]/gender',
gender)
