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 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(self, reg_aladin_exe):
"""Method running the process for the spider on the inputs data."""
if reg_aladin_exe.endswith('reg_aladin'):
exe_path = reg_aladin_exe
elif os.path.isdir(reg_aladin_exe):
exe_path = os.path.join(reg_aladin_exe, "reg_aladin")
if not os.path.exists(exe_path):
raise Exception("Executable '%s' not found" % (exe_path))
else:
output_folder = os.path.join(self.jobdir, 'outputs')
if not os.path.exists(output_folder):
os.makedirs(output_folder)
for scan_id in self.scans_id:
prefix_str = '%s_reg2_%s' % (scan_id, self.xnat_scan_ref)
reg_folder = os.path.join(output_folder, prefix_str)
if not os.path.exists(reg_folder):
os.makedirs(reg_folder)
ipath = os.path.join(self.jobdir, 'inputs', scan_id, 'NIFTI',
'*.nii.gz')
input_fpath = glob.glob(ipath)[0]
self.time_writer("Register %s to %s" %
(input_fpath, self.reference[0]))
output_name = "%s.nii" % (prefix_str)
affine_name = "%s_affine_transformation.txt" % (prefix_str)
output_fpath = os.path.join(reg_folder, output_name)
affine_fpath = os.path.join(reg_folder, affine_name)
cmd = REG_ALADIN_CMD.format(exe_path=exe_path,
reference=self.reference[0],
input=input_fpath,
output=output_fpath,
affine=affine_fpath,
args=RA_ARGS)
self.run_system_cmd(cmd)
XnatUtils.gzip_nii(reg_folder)
self.outputs.append(reg_folder)
self.make_pdf()
def run(self):
"""Method running the process for the spider on the inputs data."""
output_folder = XnatUtils.makedir(os.path.join(self.jobdir, 'outputs'))
dcm_folder = XnatUtils.makedir(os.path.join(output_folder, 'OsiriX'))
pdfs_dir = XnatUtils.makedir(os.path.join(output_folder, 'pdfs'))
fpages = list()
# Load dicom headers
if not os.path.isfile(self.inputs['dcm']):
err = "DICOM File %s not found."
raise Exception(err % self.inputs['dcm'])
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,
dicom_file=self.inputs['dcm'],
out_dcm=dcm_folder,
acq=str(nb_acq),
suffix=PSUFFIX,
)
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)
mat_lines = PDF_TEMPLATE.format(
matlab_code=self.matlab_code,
subject=self.xnat_subject,
output=folder,
model=self.model,
out_pdf=pdfs_dir,
acq=str(nb_acq),
)
matlab_script = os.path.join(output_folder,
'run_pdf_%d.m' % nb_acq)
with open(matlab_script, "w") as f:
f.writelines(mat_lines)
XnatUtils.run_matlab(matlab_script, verbose=True)
pdf_pages = XnatUtils.find_files(pdfs_dir, '.pdf')
# Merge all pdfs into one:
pdf_page = os.path.join(output_folder, str(nb_acq),
'VerdictMapAcq%d.pdf' % nb_acq)
self.merge_pdf_pages(pdf_pages, pdf_page)
fpages.append(pdf_page)
# Merge PDFs:
if len(fpages) > 1:
self.merge_pdf_pages(fpages, self.pdf_final)
else:
shutil.move(fpages[0], self.pdf_final)
# 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(os.path.join(output_folder, '1', 'AMICO',
self.model))
if self.nb_acquisition == 2:
XnatUtils.gzip_nii(os.path.join(output_folder, '2', 'AMICO',
self.model))
def run(self, openmp_core=1):
"""Method running the process for the spider on the inputs data."""
output_folder = XnatUtils.makedir(os.path.join(self.jobdir, 'outputs'),
subdir=False)
# Sort the DICOM T2 to convert the registered modalities NIFTI to DICOM
dcm_obj_sorted = dict()
for dcm_file in self.target['dcm']:
# Load dicom headers
if not os.path.isfile(dcm_file):
err = "DICOM File %s not found after download."
raise Exception(err % dcm_file)
t2_dcm_obj = dicom.read_file(dcm_file)
dcm_obj_sorted[t2_dcm_obj[0x00200032].value[2]] = t2_dcm_obj
dcm_obj_sorted_list = [dcm_obj_sorted[key] for key in
sorted(dcm_obj_sorted)]
# REG ALADIN:
for scan_id, res_dict in self.sources.items():
# Organise folders for ouput
sc_dir = os.path.join(output_folder, scan_id)
reg_folder = XnatUtils.makedir(sc_dir, subdir=False)
ala_dir = os.path.join(reg_folder, 'REG_ALA')
aff_dir = os.path.join(reg_folder, 'AFF')
reg_dir = os.path.join(reg_folder, 'REG_F3D')
cpp_dir = os.path.join(reg_folder, 'CPP')
ala_folder = XnatUtils.makedir(ala_dir, subdir=False)
aff_folder = XnatUtils.makedir(aff_dir, subdir=False)
f3d_folder = XnatUtils.makedir(reg_dir, subdir=False)
cpp_folder = XnatUtils.makedir(cpp_dir, subdir=False)
self.time_writer("reg_aladin with ref %s and flo %s" %
(self.target['nii'], res_dict['nii']))
aladin_output = os.path.join(ala_folder, "%s_2_%s_reg_aladin.nii" %
(scan_id, ARGS.target_id))
affine_fpath = os.path.join(aff_folder,
"%s_2_%s_affine_transformation.txt" %
(scan_id, ARGS.target_id))
cmd = REG_ALADIN_CMD.format(exe_path=self.reg_aladin_exe,
ref=self.target['nii'],
flo=res_dict['nii'],
res=aladin_output,
aff=affine_fpath,
omp=openmp_core,
args=ARGS.args_reg_aladin)
self.run_system_cmd(cmd)
# Check that the affine file exists:
if not os.path.exists(affine_fpath):
err = 'Reg_aladin failed. File %s not found.'
raise Exception(err % affine_fpath)
# REG_F3D
self.time_writer("reg_f3d with ref %s and flo %s and aff %s" %
(self.target['nii'],
res_dict['nii'],
affine_fpath))
f3d_output = os.path.join(f3d_folder, "%s_2_%s_reg_f3d.nii" %
(scan_id, ARGS.target_id))
f3d_cpp = os.path.join(cpp_folder, "%s_2_%s_reg_f3d_cpp.nii" %
(scan_id, ARGS.target_id))
cmd = REG_F3D_CMD.format(exe_path=self.reg_f3d_exe,
ref=self.target['nii'],
flo=res_dict['nii'],
res=f3d_output,
cpp=f3d_cpp,
aff=affine_fpath,
omp=openmp_core,
args=ARGS.args_regf3d)
self.run_system_cmd(cmd)
XnatUtils.gzip_nii(ala_folder)
XnatUtils.gzip_nii(f3d_folder)
XnatUtils.gzip_nii(cpp_folder)
self.outputs[scan_id] = [{'label': 'reg_aladin_results',
'image': aladin_output+'.gz'},
{'label': 'reg_f3d_results',
'image': f3d_output+'.gz'}]
# Generate DICOM version of the reg_f3d results:
convert_nifti_2_dicoms(f3d_output+'.gz', dcm_obj_sorted_list,
self.sources[scan_id]['dcm'],
os.path.join(output_folder, 'OSIRIX'),
label=("%s_reg_f3d" % scan_id))
# 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 main():
""" Main function."""
# Run the env_source:
if os.path.isFile(ENV_SOURCE):
os.system('sh {}'.format(ENV_SOURCE))
if len(JOB_DIR) > 0 and not os.path.exists(JOB_DIR):
os.makedirs(JOB_DIR)
dcm_folder = XnatUtils.makedir(os.path.join(JOB_DIR, 'OsiriX'))
fpages = list()
# Number of acquisition:
acquisition = 2 if len(B3000_FILES) > 1 else 1
project, subject, session = LABEL.split('-x-')[:3]
pdf_final = os.path.join(JOB_DIR, '%s_registration_VERDICT.pdf' % session)
output_folder = XnatUtils.makedir(os.path.join(JOB_DIR, 'outputs'))
osirix_folder = XnatUtils.makedir(os.path.join(output_folder, 'OsiriX'))
for acq_ind in range(1, acquisition + 1):
# Step 1:
# Transform the 4D Nifti into 3D images for registration:
print('Splitting nifti {} ...'.format(fpath))
ori_3d = split_nifti_4D_3Ds(fpath)
# b3000:
ori_nii = B3000_FILES[acq_ind]
# Convert the original NIFTI from b3000 to dicom:
convert_nifti_2_dicom(
ori_nii, B3000_DCM[acq_ind], B3000_DCM[acq_ind], osirix_folder,
'b3000', label=("b3000_{}_reg".format(str(acq_ind))))
# Other scans:
for index, fpath in enumerate([B2000_FILES, B1500_FILES,
B500_FILES, B90_FILES]):
# Step 1:
# Transform the 4D Nifti into 3D images for registration:
print('Splitting nifti {} ...'.format(fpath))
fpath_3d = split_nifti_4D_3Ds(fpath)
if 'b3000' not in scan_info['type'].lower():
outdir = XnatUtils.makedir(os.path.join(output_folder,
scan_info['ID']))
# Step 2-3-4 see register nifti
self.time_writer('Registration nifti ...')
nii_reg = self.register_nifti(
self.acquisitions[i][index],
self.acquisitions[i][index-1],
outdir, i)
self.acquisitions[i][index]['reg'] = nii_reg
# Generate DICOM version of the reg_f3d results:
convert_nifti_2_dicom(
nii_reg,
self.acquisitions[i][index-1]['dicom'],
self.acquisitions[i][index]['dicom'],
osirix_folder,
scan_info['type'],
label=("%s_%s_reg"
% (scan_info['ID'],
scan_info['type'].replace(' ', '_'))))
else:
# Generate big niftis
self.generate_big_nifti()
# 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(os.path.join(JOB_DIR, '1', 'AMICO', '${model}'))
if ACQ2_FILE and os.path.exists(ACQ2_FILE):
XnatUtils.gzip_nii(os.path.join(JOB_DIR, '2', 'AMICO', '${model}'))
