def divide_taxonomical_intra_rater_tst_retest():
taxonomical_old_labels = []
taxonomical_new_labels = []
for k in nomenclature_taxonomical.keys():
taxonomical_old_labels += nomenclature_taxonomical[k][1]
taxonomical_new_labels += [k] * len(nomenclature_taxonomical[k][1])
# divide auto
nis_app = nis.App()
nis_app.manipulate_labels.relabel(ph.pfi_segm_auto,
ph.pfi_segm_auto_divided_taxonomical,
list_old_labels=taxonomical_old_labels,
list_new_labels=taxonomical_new_labels)
del nis_app
# divide man1
nis_app = nis.App()
nis_app.manipulate_labels.relabel(ph.pfi_segm_man1,
ph.pfi_segm_man1_divided_taxonomical,
list_old_labels=taxonomical_old_labels,
list_new_labels=taxonomical_new_labels)
del nis_app
# divide man2
nis_app = nis.App()
nis_app.manipulate_labels.relabel(ph.pfi_segm_man2,
ph.pfi_segm_man2_divided_taxonomical,
list_old_labels=taxonomical_old_labels,
list_new_labels=taxonomical_new_labels)
del nis_app
def prepare_slim_mask_from_path_to_stack(pfi_target_reg_mask_input,
pfi_brain_mask,
pfi_target_reg_mask_output):
"""
Very simple for the moment:
slim_mask = reg_mask * brain_mask
:param pfi_target_reg_mask_input:
:param pfi_brain_mask:
:param pfi_target_reg_mask_output:
:return:
"""
nis_app = nis.App()
nis_app.manipulate_shape.cut_4d_volume_with_a_1_slice_mask(
pfi_target_reg_mask_input, pfi_brain_mask, pfi_target_reg_mask_output)
def create_eroded_segmentations_if_not_already_created(pfi_segm_non_eroded, pfi_contour, pfi_segm_eroded):
if os.path.exists(pfi_segm_eroded):
print('eroded segmentation for {} already created.'.format(pfi_segm_eroded))
else:
print('Getting contour segmentation {}'.format(pfi_segm_non_eroded))
nis_app = nis.App()
nis_app.manipulate_intensities.get_contour_from_segmentation(pfi_segm_non_eroded, pfi_contour, verbose=1)
cmd = 'seg_maths {} -sub {} {}'.format(pfi_segm_non_eroded, pfi_contour, pfi_segm_eroded)
print('Getting eroded segmentation {}'.format(pfi_segm_non_eroded))
print(cmd)
os.system(cmd)
def flipper(pfo_atlas, atlas_charts_names, sufix_atlas, labels_descriptor):
for chart in atlas_charts_names:
print
print('Flipping chart {}'.format(chart))
pfo_chart = jph(pfo_atlas, chart)
pfo_chart_flipped = jph(pfo_atlas, chart + sufix_atlas)
cmd = 'cp -r {0} {1}'.format(pfo_chart, pfo_chart_flipped)
os.system(cmd)
for root, dirs, files in os.walk(pfo_chart_flipped):
for name in files:
if name.endswith(('.nii', '.nii.gz')):
name_flipped = name.replace(chart, chart + sufix_atlas)
pfi_nii = jph(root, name)
pfi_nii_flipped = jph(root, name_flipped)
print 'old : {}'.format(pfi_nii)
print 'new : {}'.format(pfi_nii_flipped)
flip_left_right_from_path(pfi_nii, pfi_nii_flipped)
os.system('rm {}'.format(pfi_nii))
if '_segm' in name_flipped:
# substitute labels left-right:
ld_dict = labels_descriptor.get_dict()
left_labels = [
l for l in ld_dict.keys()
if 'left' in ld_dict[l][2].lower()
]
right_labels = [l + 1 for l in left_labels]
nis_app = nis.App()
nis_app.manipulate_labels.relabel(
pfi_nii_flipped,
pfi_nii_flipped,
list_old_labels=left_labels + right_labels,
list_new_labels=right_labels + left_labels)
def propagate_segmentation_in_original_space_per_subject(sj, controller):
"""
Movign from the stereotaxic oriented chart to the original chart.
The stereotaxic can be directly retrieved from the multi-atlas if sj is in the template
or it can be a chart in the multi-atlas, or it can be retrived from the 'stereotaxic' folder in
the subject folder (under A_data), after the
:param sj:
:param controller:
:return:
"""
print('\nfrom Stereotaxic orientation to original space - SUBJECT {} started.\n'.format(sj))
sj_parameters = pickle.load(open(jph(pfo_subjects_parameters, sj), 'r'))
study = sj_parameters['study']
category = sj_parameters['category']
folder_selected_segmentation = sj_parameters['names_architecture']['final_segm_strx'] # default 'automatic'
suffix_selected_segmentation = sj_parameters['names_architecture']['suffix_segm'] # default 'MV_P2'
pfo_root_sj_orig = jph(root_study_rabbits, 'A_data', study, category, sj)
pfo_root_sj_strx = jph(root_study_rabbits, 'A_data', study, category, sj, 'stereotaxic')
pfo_mod_orig = jph(pfo_root_sj_orig, 'mod')
pfo_mask_orig = jph(pfo_root_sj_orig, 'masks')
pfo_segm_orig = jph(pfo_root_sj_orig, 'segm')
pfo_mod_strx = jph(pfo_root_sj_strx, 'mod')
pfo_mask_strx = jph(pfo_root_sj_strx, 'masks')
pfo_segm_strx = jph(pfo_root_sj_strx, 'segm')
pfo_tmp = jph(pfo_root_sj_orig, 'z_tmp', 'z_propagator')
print_and_run('mkdir -p {}'.format(pfo_segm_orig))
print_and_run('mkdir -p {}'.format(pfo_tmp))
# recover the source in stereotaxic coordinates (strx):
if sj_parameters['in_atlas']:
if study == 'W8':
pfo_sj_atlas = jph(root_study_rabbits, 'A_MultiAtlas_W8', sj)
elif study == 'ACS' or study == 'PTB' or study == 'TestStudy':
pfo_sj_atlas = jph(root_study_rabbits, 'A_MultiAtlas', sj)
else:
raise IOError('Study for subject {} not feasible.'.format(sj))
pfi_T1_strx = jph(pfo_sj_atlas, 'mod', '{}_T1.nii.gz'.format(sj))
pfi_T1_reg_mask_strx = jph(pfo_sj_atlas, 'masks', '{}_reg_mask.nii.gz'.format(sj))
pfi_T1_segm_strx = jph(pfo_sj_atlas, 'segm', '{}_segm.nii.gz'.format(sj))
else:
pfi_T1_strx = jph(pfo_mod_strx, '{}_T1.nii.gz'.format(sj))
pfi_T1_reg_mask_strx = jph(pfo_mask_strx, '{}_T1_reg_mask.nii.gz'.format(sj))
if folder_selected_segmentation == 'automatic':
pfo_segmentation_strx = jph(pfo_segm_strx, 'automatic')
else:
pfo_segmentation_strx = pfo_segm_strx
pfi_T1_segm_strx = jph(pfo_segmentation_strx, '{}_{}.nii.gz'.format(sj, suffix_selected_segmentation))
for p in [pfi_T1_strx, pfi_T1_reg_mask_strx, pfi_T1_segm_strx]:
assert os.path.exists(p), p
# --> INTRA-modal segmentation:
if controller['Header_alignment_T1strx_to_T1orig']:
print('-> Align header T1strx to origin')
# output header orientati:
pfi_T1_strx_hdo = jph(pfo_tmp, '{}_T1_strx_hdo.nii.gz'.format(sj))
pfi_T1_reg_mask_strx_hdo = jph(pfo_tmp, '{}_T1_reg_mask_strx_hdo.nii.gz'.format(sj))
pfi_T1_segm_strx_hdo = jph(pfo_tmp, '{}_T1_segm_strx_hdo.nii.gz'.format(sj))
angles = sj_parameters['angles']
if isinstance(angles[0], list):
pitch_theta = angles[0][1]
else:
pitch_theta = angles[1]
for strx, strx_hdo in zip([pfi_T1_strx, pfi_T1_reg_mask_strx, pfi_T1_segm_strx],
[pfi_T1_strx_hdo, pfi_T1_reg_mask_strx_hdo, pfi_T1_segm_strx_hdo]):
cmd = 'cp {0} {1}'.format(strx, strx_hdo)
print_and_run(cmd)
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(strx_hdo, strx_hdo,
angle=pitch_theta, principal_axis='pitch')
if controller['Rigid_T1strx_to_T1orig']:
print('-> Align T1strx_hdo (header oriented) to origin')
# fixed
pfi_T1_origin = jph(pfo_mod_orig, '{}_T1.nii.gz'.format(sj))
pfi_T1_reg_mask_origin = jph(pfo_mask_orig, '{}_T1_reg_mask.nii.gz'.format(sj))
# moving
pfi_T1_strx_hdo = jph(pfo_tmp, '{}_T1_strx_hdo.nii.gz'.format(sj))
pfi_T1_reg_mask_strx_hdo = jph(pfo_tmp, '{}_T1_reg_mask_strx_hdo.nii.gz'.format(sj))
assert os.path.exists(pfi_T1_origin), pfi_T1_origin
assert os.path.exists(pfi_T1_reg_mask_origin), pfi_T1_reg_mask_origin
assert os.path.exists(pfi_T1_strx_hdo), pfi_T1_strx_hdo
assert os.path.exists(pfi_T1_reg_mask_strx_hdo), pfi_T1_reg_mask_strx_hdo
pfi_transformation = jph(pfo_tmp, 'T1_strx_to_origin.txt')
pfi_warped_T1_rigid = jph(pfo_tmp, 'T1_strx_to_origin_warped.nii.gz')
cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -res {5} -rigOnly '.format( #
pfi_T1_origin, pfi_T1_reg_mask_origin, pfi_T1_strx_hdo, pfi_T1_reg_mask_strx_hdo,
pfi_transformation, pfi_warped_T1_rigid)
print_and_run(cmd)
if controller['Propagate_T1_segm']:
pfi_T1_origin = jph(pfo_mod_orig, '{}_T1.nii.gz'.format(sj))
pfi_T1_segm_strx_hdo = jph(pfo_tmp, '{}_T1_segm_strx_hdo.nii.gz'.format(sj))
pfi_transformation = jph(pfo_tmp, 'T1_strx_to_origin.txt')
assert os.path.exists(pfi_T1_origin), pfi_T1_origin
assert os.path.exists(pfi_T1_segm_strx_hdo), pfi_T1_segm_strx_hdo
assert os.path.exists(pfi_transformation), pfi_transformation
pfi_warped_T1_segm = jph(pfo_segm_orig, '{}_T1_segm.nii.gz'.format(sj))
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -omp {4} -inter 0'.format(
pfi_T1_origin, pfi_T1_segm_strx_hdo,
pfi_transformation, pfi_warped_T1_segm, num_cores_run)
print_and_run(cmd)
# --> INTER-modal segmentation propagation: -- from here we are only working with the original chart.
if controller['Inter_modal_reg_S0']:
# T1 to S0 - Reference is S0. Floating is T1
# references:
pfi_S0_origin = jph(pfo_mod_orig, '{}_S0.nii.gz'.format(sj))
pfi_S0_reg_mask_origin = jph(pfo_mask_orig, '{}_S0_reg_mask.nii.gz'.format(sj))
angles = sj_parameters['angles']
if isinstance(angles[0], list): # Both S0 and T1 angles are specified: [[y,p,r], [y,p,r]]
pitch_theta_T1 = angles[0][1]
pitch_theta_S0 = angles[1][1]
pitch_theta = pitch_theta_S0 - pitch_theta_T1
# floating oriented header:
pfi_T1_strx_hdoS0 = jph(pfo_tmp, '{}_T1_strx_hdoS0.nii.gz'.format(sj))
pfi_T1_reg_mask_strx_hdoS0 = jph(pfo_tmp, '{}_T1_reg_mask_strx_hdoS0.nii.gz'.format(sj))
pfi_T1_segm_strx_hdoS0 = jph(pfo_tmp, '{}_T1_segm_strx_hdoS0.nii.gz'.format(sj))
for strx, strx_hdo in zip([pfi_T1_strx, pfi_T1_reg_mask_strx, pfi_T1_segm_strx],
[pfi_T1_strx_hdoS0, pfi_T1_reg_mask_strx_hdoS0, pfi_T1_segm_strx_hdoS0]):
cmd = 'cp {0} {1}'.format(strx, strx_hdo)
print_and_run(cmd)
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(strx_hdo, strx_hdo,
angle=pitch_theta, principal_axis='pitch')
pfi_transformation = jph(pfo_tmp, 'T1origin_to_S0origin.txt')
pfi_warped_T1toS0_rigid = jph(pfo_tmp, 'T1origin_to_S0origin_warped.nii.gz')
cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -res {5} -omp {6} -'.format( # rigOnly
pfi_S0_origin, pfi_S0_reg_mask_origin, pfi_T1_strx_hdoS0, pfi_T1_reg_mask_strx_hdoS0,
pfi_transformation, pfi_warped_T1toS0_rigid, num_cores_run
)
print_and_run(cmd)
# result:
pfi_S0_segm = jph(pfo_segm_orig, '{}_S0_segm.nii.gz'.format(sj))
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_S0_origin, pfi_T1_segm_strx_hdoS0, pfi_transformation, pfi_S0_segm)
print_and_run(cmd)
else:
# floating not oriented header:
pfi_transformation = jph(pfo_tmp, 'T1origin_to_S0origin.txt')
pfi_warped_T1toS0_rigid = jph(pfo_tmp, 'T1origin_to_S0origin_warped.nii.gz')
cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -res {5} -omp {6} '.format( # -rigOnly
pfi_S0_origin, pfi_S0_reg_mask_origin, pfi_T1_strx, pfi_T1_reg_mask_strx,
pfi_transformation, pfi_warped_T1toS0_rigid, num_cores_run
)
print_and_run(cmd)
# result:
pfi_S0_segm = jph(pfo_segm_orig, '{}_S0_segm.nii.gz'.format(sj))
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_S0_origin, pfi_T1_segm_strx, pfi_transformation, pfi_S0_segm)
print_and_run(cmd)
if controller['Inter_modal_reg_MSME']:
# MSMEinS0 to MSME: reference is MSME, floating is MSMEinS0 same as S0.
# (same strategy used as before - again hardcoded)
# references:
pfi_MSME_origin = jph(pfo_mod_orig, 'MSME_tp0', '{}_MSME_tp0.nii.gz'.format(sj))
pfi_MSME_reg_mask_origin = jph(pfo_mask_orig, '{}_MSME_reg_mask.nii.gz'.format(sj))
# for safety orient the input to standard:
orient2std(pfi_MSME_origin, pfi_MSME_origin)
orient2std(pfi_MSME_reg_mask_origin, pfi_MSME_reg_mask_origin)
assert os.path.exists(pfi_MSME_origin)
assert os.path.exists(pfi_MSME_reg_mask_origin)
# floating
pfi_MSMEinS0 = jph(pfo_mod_orig, 'MSME_tp0', '{}_MSMEinS0_tp0.nii.gz'.format(sj))
pfi_MSMEinS0_reg_mask = jph(pfo_mask_orig, '{}_S0_reg_mask.nii.gz'.format(sj))
pfi_MSMEinS0_segm = jph(pfo_segm_orig, '{}_S0_segm.nii.gz'.format(sj))
angles = sj_parameters['angles']
if isinstance(angles[0], list) and len(angles) == 3: # all angles specified: [[y,p,r], [y,p,r], [y,p,r]]
pitch_theta_S0 = angles[1][1]
pitch_theta_MSME = angles[2][1]
pitch_theta = pitch_theta_MSME - pitch_theta_S0
# floating oriented header:
pfi_MSMEinS0_hdoMSME = jph(pfo_tmp, '{}_MSMEinS0_strx_hdoS0.nii.gz'.format(sj))
pfi_MSMEinS0_reg_mask_hdoMSME = jph(pfo_tmp, '{}_MSMEinS0_reg_mask_strx_hdoS0.nii.gz'.format(sj))
pfi_MSMEinS0_segm_hdoMSME = jph(pfo_tmp, '{}_MSMEinS0_segm_strx_hdoS0.nii.gz'.format(sj))
for strx, strx_hdo in zip([pfi_MSMEinS0, pfi_MSMEinS0_reg_mask, pfi_MSMEinS0_segm],
[pfi_MSMEinS0_hdoMSME, pfi_MSMEinS0_reg_mask_hdoMSME, pfi_MSMEinS0_segm_hdoMSME]):
cmd = 'cp {0} {1}'.format(strx, strx_hdo)
print_and_run(cmd)
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(strx_hdo, strx_hdo,
angle=pitch_theta, principal_axis='pitch')
pfi_transformation = jph(pfo_tmp, 'MSMEinS0_to_MSME.txt')
pfi_warped_MSMEinS0_to_MSME_rigid = jph(pfo_tmp, 'MSMEinS0_to_MSME_warped.nii.gz')
cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -res {5} -omp {6} '.format( # -rigOnly
pfi_MSME_origin, pfi_MSME_reg_mask_origin, pfi_MSMEinS0_hdoMSME, pfi_MSMEinS0_reg_mask_hdoMSME,
pfi_transformation, pfi_warped_MSMEinS0_to_MSME_rigid, num_cores_run
)
print_and_run(cmd)
# result:
pfi_MSME_segm = jph(pfo_segm_orig, '{}_MSME_segm.nii.gz'.format(sj))
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_MSME_origin, pfi_MSMEinS0_segm_hdoMSME, pfi_transformation, pfi_MSME_segm)
print_and_run(cmd)
else:
pfi_transformation = jph(pfo_tmp, 'MSMEinS0_to_MSME.txt')
pfi_warped_MSMEinS0_to_MSME_rigid = jph(pfo_tmp, 'MSMEinS0_to_MSME_warped.nii.gz')
cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -res {5} -omp {6} '.format( # -rigOnly
pfi_MSME_origin, pfi_MSME_reg_mask_origin, pfi_MSMEinS0, pfi_MSMEinS0_reg_mask,
pfi_transformation, pfi_warped_MSMEinS0_to_MSME_rigid, num_cores_run
)
print_and_run(cmd)
# result:
pfi_MSME_segm = jph(pfo_segm_orig, '{}_MSME_segm.nii.gz'.format(sj))
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_MSME_origin, pfi_MSMEinS0_segm, pfi_transformation, pfi_MSME_segm)
print_and_run(cmd)
assert os.path.exists(pfi_input_anatomy), pfi_input_anatomy
assert os.path.exists(
pfi_input_segmentation_noisy), pfi_input_segmentation_noisy
assert os.path.exists(pfo_output_folder), pfo_output_folder
# Output
log_file_before_cleaning = jph(pfo_output_folder, 'log_before_cleaning.txt')
pfi_output_cleaned_segmentation = jph(pfo_output_folder,
'ellipsoids_segm_cleaned.nii.gz')
log_file_after_cleaning = jph(pfo_output_folder, 'log_after_cleaning.txt')
pfi_differece_cleaned_non_cleaned = jph(
pfo_output_folder, 'difference_half_cleaned_uncleaned.nii.gz')
# ---- PROCESS ----
nl = nil.App()
# get the report before cleaning
nl.check.number_connected_components_per_label(
pfi_input_segmentation_noisy,
where_to_save_the_log_file=log_file_before_cleaning)
print('Wanted final number of components per label:')
im_input_segmentation_noisy = nib.load(pfi_input_segmentation_noisy)
correspondences_labels_components = [
[k, 1] for k in range(np.max(im_input_segmentation_noisy.get_data()) + 1)
]
print(correspondences_labels_components)
# get the cleaned segmentation
nl.manipulate_labels.clean_segmentation(
def extract_brain_tissue_from_multi_atlas_list_stereotaxic(target_name,
multi_atlas_list,
pfo_tmp,
pfi_output_brain_mask,
options):
"""
:param target_name:
:param multi_atlas_list:
:param pfo_tmp:
:param pfi_output_brain_mask:
:param options:
:return:
"""
# controller:
affine_only = True
nrig_options = ' -be 0.98 -jl 0.5 '
steps = {'register' : True,
'propagate' : True,
'stack' : True,
'fuse' : True}
assert os.path.exists(pfo_tmp)
# parameters target:
sj_parameters = pickle.load(open(jph(defs.pfo_subjects_parameters, target_name), 'r'))
study = sj_parameters['study']
category = sj_parameters['category']
# input target:
root_target_sj = jph(defs.root_study_rabbits, 'A_data', study, category, target_name)
pfi_target_sj_T1 = jph(root_target_sj, 'stereotaxic', 'mod', '{}_T1.nii.gz'.format(target_name))
pfi_target_sj_reg_mask = jph(root_target_sj, 'stereotaxic', 'masks', '{}_T1_reg_mask.nii.gz'.format(target_name))
assert os.path.exists(pfi_target_sj_T1), pfi_target_sj_T1
assert os.path.exists(pfi_target_sj_reg_mask), pfi_target_sj_reg_mask
# list of final intermediate output:
list_pfi_brain_mask_registered_on_target = []
list_pfi_T1_registered_on_target = []
for atlas_sj in multi_atlas_list:
# input selected atlas_sj
if atlas_sj in defs.multi_atlas_subjects:
root_atlas_sj = jph(defs.root_atlas, atlas_sj)
pfi_atlas_sj_T1 = jph(root_atlas_sj, 'mod', '{}_T1.nii.gz'.format(atlas_sj))
pfi_atlas_sj_reg_mask = jph(root_atlas_sj, 'masks', '{}_reg_mask.nii.gz'.format(atlas_sj))
pfi_atlas_sj_brain_mask = jph(root_atlas_sj, 'masks', '{}_brain_mask.nii.gz'.format(atlas_sj))
elif atlas_sj in defs.multi_atlas_BT_subjects:
root_atlas_name_BT = jph(defs.root_atlas_BT, atlas_sj)
pfi_atlas_sj_T1 = jph(root_atlas_name_BT, '{}_T1.nii.gz'.format(atlas_sj))
pfi_atlas_sj_reg_mask = jph(root_atlas_name_BT, '{}_reg_mask.nii.gz'.format(atlas_sj))
pfi_atlas_sj_brain_mask = jph(root_atlas_name_BT, '{}_brain_mask.nii.gz'.format(atlas_sj))
else:
raise IOError('Subject {} is not in a known or provided multi-atlas.'.format(atlas_sj))
assert os.path.exists(pfi_atlas_sj_T1), pfi_atlas_sj_T1
assert os.path.exists(pfi_atlas_sj_reg_mask), pfi_atlas_sj_reg_mask
assert os.path.exists(pfi_atlas_sj_brain_mask), pfi_atlas_sj_brain_mask
# intermediate output: AFFINE
pfi_affine_transformation_ref_on_subject = jph(pfo_tmp, 'target{}_floating{}_aff_transformation.txt'.format(target_name, atlas_sj))
pfi_affine_warped_ref_on_subject = jph(pfo_tmp, 'target{}_floating{}_aff_warped.nii.gz'.format(target_name, atlas_sj))
# AFFINE step
cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -res {5} -omp {6} -speeeeed '.format(
pfi_target_sj_T1, pfi_target_sj_reg_mask, pfi_atlas_sj_T1, pfi_atlas_sj_reg_mask,
pfi_affine_transformation_ref_on_subject,
pfi_affine_warped_ref_on_subject,
defs.num_cores_run)
if steps['register']:
print_and_run(cmd)
pfi_final_transformation = pfi_affine_transformation_ref_on_subject
# intermediate output: NON-RIGID
pfi_nrig_cpp_ref_on_subject = jph(pfo_tmp, 'target{}_floating{}_nrigid_cpp.nii.gz'.format(target_name, atlas_sj))
pfi_nrig_warped_ref_on_subject = jph(pfo_tmp, 'target{}_floating{}_nrigid_warped.nii.gz'.format(target_name, atlas_sj))
# NON-RIGID step
if not affine_only:
cmd = 'reg_f3d -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -cpp {5} -res {6} {7} -omp {8}'.format(
pfi_target_sj_T1, pfi_target_sj_reg_mask,
pfi_atlas_sj_T1, pfi_atlas_sj_reg_mask,
pfi_affine_transformation_ref_on_subject,
pfi_nrig_cpp_ref_on_subject,
pfi_nrig_warped_ref_on_subject,
nrig_options,
defs.num_cores_run)
if steps['register']:
print_and_run(cmd)
pfi_final_transformation = pfi_nrig_cpp_ref_on_subject
print('- Propagate registration to brain tissue mask, subject {0} over the target {1}'.format(
atlas_sj, target_name))
# Output brain tissue after affine trasformation, must include the atlas_sj name in the naming.
pfi_brain_tissue_from_multi_atlas_sj = jph(pfo_tmp, 'target{0}_floating{1}_final_warped_brain_mask.nii.gz'.format(
target_name, atlas_sj))
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_target_sj_T1,
pfi_atlas_sj_brain_mask,
pfi_final_transformation,
pfi_brain_tissue_from_multi_atlas_sj)
if steps['propagate']:
print_and_run(cmd)
# Append path to output files ot the respective lists.
list_pfi_brain_mask_registered_on_target.append(pfi_brain_tissue_from_multi_atlas_sj)
if affine_only:
list_pfi_T1_registered_on_target.append(pfi_affine_warped_ref_on_subject)
else:
list_pfi_T1_registered_on_target.append(pfi_nrig_warped_ref_on_subject)
print('\n- Create stack of the brain masks warped over the target {} and merge with MV. '.format(target_name))
pfi_stack_brain_mask = jph(pfo_tmp, 'a_stack_brain_tissues_target{0}_multiAtlas{1}.nii.gz'.format(
target_name, options['method']))
pfi_stack_T1 = jph(pfo_tmp, 'a_stack_T1_target{0}_multiAtlas{1}.nii.gz'.format(
target_name, options['method']))
if steps['stack']:
# Create stack of warped brain mask
nis_app = nis.App()
nis_app.manipulate_shape.stack_list_pfi_images(list_pfi_brain_mask_registered_on_target, pfi_stack_brain_mask)
del nis_app
# Create stack of warped T1
nis_app = nis.App()
nis_app.manipulate_shape.stack_list_pfi_images(list_pfi_T1_registered_on_target, pfi_stack_T1)
del nis_app
if steps['fuse']:
print('\n\n-Labels Fusion')
# merge the roi masks in one (Majority voting for now):
cmd = 'seg_LabFusion -in {0} -out {1} -MV '.format(pfi_stack_brain_mask, pfi_output_brain_mask)
# cmd = 'seg_LabFusion -in {0} -STEPS 3 5 {1} {2} -out {3}'.format(pfi_stack_brain_mask, pfi_target_sj_T1,
# pfi_stack_T1, pfi_output_brain_mask)
print_and_run(cmd)
else:
raise IOError
# ----------------------------------------------------
# ---------- START ----------------------------------
# ----------------------------------------------------
if control['prepare_data']:
pfi_input_T1W = jph(pfo_brainweb, 'A_nifti', subject_id, '{}_T1W.nii.gz'.format(subject_id))
pfi_input_crisp = jph(pfo_brainweb, 'A_nifti', subject_id, '{}_CRISP.nii.gz'.format(subject_id))
assert os.path.exists(pfi_input_T1W), pfi_input_T1W
assert os.path.exists(pfi_input_crisp), pfi_input_crisp
# get mask with only the selected label_brain
nis_app = nis.App()
nis_app.manipulate_labels.assign_all_other_labels_the_same_value(
pfi_input_crisp, pfi_brain_tissue_mask, labels_brain_to_keep, 0
)
nis_app.manipulate_labels.relabel(
pfi_brain_tissue_mask, pfi_brain_tissue_mask, labels_brain_to_keep, [1, ] * len(labels_brain_to_keep)
)
# skull strip
nis_app.math.prod(pfi_brain_tissue_mask, pfi_input_T1W, pfi_skull_stripped)
# get a slice in PNG
im_skull_stripped = nib.load(pfi_skull_stripped)
scipy.misc.toimage(
im_skull_stripped.get_data()[x_lim[0]:x_lim[1], y_slice, :].T
).save(pfi_coronal_slice)
def collect_measurements_tst_retest():
man1_man2 = True
auto_man1 = True
auto_man2 = True
if man1_man2:
print '\n==================='
print '\n\nTaxonomical division inter-rater test-re-test'
print '==================='
print 'Compare man1 with man2 all labels'
nis_app = nis.App()
nis_app.measure.verbose = True
man1_man2_measures_divide_taxonomical = nis_app.measure.dist(
ph.pfi_segm_man1,
ph.pfi_segm_man2,
labels_list=taxonomy_abbreviations.keys(),
labels_names=taxonomy_abbreviations.keys(),
metrics=(dist.dice_score, dist.covariance_distance,
dist.hausdorff_distance,
dist.normalised_symmetric_contour_distance),
where_to_save=ph.pfi_pickled_scoring_man1_man2_all)
print '---------------'
print 'Compare man1 with man2 all labels'
print man1_man2_measures_divide_taxonomical
del nis_app
if auto_man1:
print '\n\n==================='
print 'Compare auto with man1 all labels'
nis_app = nis.App()
nis_app.measure.verbose = True
auto_man1_measures_divide_taxonomical = nis_app.measure.dist(
ph.pfi_segm_auto,
ph.pfi_segm_man1,
labels_list=taxonomy_abbreviations.keys(),
labels_names=taxonomy_abbreviations.keys(),
metrics=(dist.dice_score, dist.covariance_distance,
dist.hausdorff_distance,
dist.normalised_symmetric_contour_distance),
where_to_save=ph.pfi_pickled_scoring_auto_man1_all)
print '---------------'
print 'Compare auto with man1 all labels'
print auto_man1_measures_divide_taxonomical
del nis_app
if auto_man2:
print '\n\n==================='
print 'Compare auto with man2 all labels'
nis_app = nis.App()
nis_app.measure.verbose = True
auto_man2_measures_divide_taxonomical = nis_app.measure.dist(
ph.pfi_segm_auto,
ph.pfi_segm_man2,
labels_list=taxonomy_abbreviations.keys(),
labels_names=taxonomy_abbreviations.keys(),
metrics=(dist.dice_score, dist.covariance_distance,
dist.hausdorff_distance,
dist.normalised_symmetric_contour_distance),
where_to_save=ph.pfi_pickled_scoring_auto_man2_all)
print '---------------'
print 'Compare auto with man2 all labels'
print auto_man2_measures_divide_taxonomical
del nis_app
# Segm:
for se in os.listdir(pfo_segm):
if ch in se:
pfi_se = jph(pfo_segm, se)
adjust_nifti_translation_path(pfi_se, c_m, pfi_se)
adjust_nifti_image_type_path(pfi_se,
np.uint16,
pfi_se,
update_description='')
# for T1 and S0 apply the re-normalisation based on the registration mask.
pfi_reg_mask = jph(pfo_masks, '{}_roi_reg_mask.nii.gz'.format(ch))
pfi_T1 = jph(pfo_mod, '{}_T1.nii.gz'.format(ch))
pfi_S0 = jph(pfo_mod, '{}_S0.nii.gz'.format(ch))
nis_app = nis.App(pfo_mod)
nis_app.manipulate_intensities.normalise_below_label(
pfi_T1,
pfi_T1,
pfi_segm,
)
nis_app.manipulate_intensities.normalise_below_label(
pfi_S0,
pfi_S0,
pfi_segm,
)
''' set the origin in the center of mass of the segmentation of a chart of the atlas '''
if False:
for fi in os.listdir(pfo_multi_atlas):
if fi.endswith('.nii.gz'):
def move_to_stereotaxic_coordinate_per_subject(sj, controller):
print('\nProcessing T1 {} started.\n'.format(sj))
# parameters file sanity check:
if sj not in list_all_subjects(pfo_subjects_parameters):
raise IOError('Subject parameters not known. Subject {}'.format(sj))
sj_parameters = pickle.load(open(jph(pfo_subjects_parameters, sj), 'r'))
study = sj_parameters['study']
category = sj_parameters['category']
pfo_sj = jph(root_study_rabbits, 'A_data', study, category, sj)
pfo_sj_mod = jph(pfo_sj, 'mod')
pfo_sj_masks = jph(pfo_sj, 'masks')
if study == 'W8':
pfo_atlas = root_atlas_W8
options = {'Template_chart_path' : jph(root_atlas_W8, '12503'), # TODO
'Template_name' : '12503'}
elif study == 'ACS' or study == 'PTB' or study == 'TestStudy':
pfo_atlas = root_atlas
options = {'Template_chart_path' : jph(root_atlas, '1305'),
'Template_name' : '1305'}
else:
raise IOError('Study for subject {} not feasible.'.format(sj))
assert os.path.exists(pfo_sj_mod)
assert os.path.exists(pfo_sj_masks)
# reference atlas main modality and mask
pfi_mod_reference_atlas = jph(options['Template_chart_path'], 'mod', '{0}_{1}.nii.gz'.format(
options['Template_name'], 'T1'))
pfi_reg_mask_reference_atlas = jph(options['Template_chart_path'], 'masks', '{0}_reg_mask.nii.gz'.format(
options['Template_name']))
assert os.path.exists(pfi_mod_reference_atlas), pfi_mod_reference_atlas
assert os.path.exists(pfi_reg_mask_reference_atlas), pfi_reg_mask_reference_atlas
pfo_tmp = jph(pfo_sj, 'z_tmp', 'z_sc_aligment'.format(sj))
pfo_sc_sj = jph(pfo_sj, 'stereotaxic')
pfo_sc_sj_mod = jph(pfo_sc_sj, 'mod')
pfo_sc_sj_masks = jph(pfo_sc_sj, 'masks')
subject_is_in_atlas = False # sj_parameters['in_atlas'] # TODO momentary bypass - correct this part!
if subject_is_in_atlas:
pfo_sj_mod_in_atlas = jph(pfo_atlas, sj, 'mod')
pfo_sj_masks_in_atlas = jph(pfo_atlas, sj, 'masks')
pfo_sj_segm_in_atlas = jph(pfo_atlas, sj, 'segm')
assert os.path.exists(pfo_sj_mod_in_atlas), pfo_sj_mod_in_atlas
assert os.path.exists(pfo_sj_masks_in_atlas), pfo_sj_masks_in_atlas
assert os.path.exists(pfo_sj_segm_in_atlas), pfo_sj_segm_in_atlas
print_and_run('mkdir -p {}'.format(pfo_sc_sj))
cmd = 'cp -r {} {}'.format(pfo_sj_mod_in_atlas, pfo_sc_sj)
print_and_run(cmd)
cmd = 'cp -r {} {}'.format(pfo_sj_masks_in_atlas, pfo_sc_sj)
print_and_run(cmd)
cmd = 'cp -r {} {}'.format(pfo_sj_segm_in_atlas, pfo_sc_sj)
print_and_run(cmd)
return
# Initialise folder structure in stereotaxic coordinates
if controller['Initialise_sc_folder']:
print_and_run('mkdir -p {}'.format(pfo_tmp))
print_and_run('mkdir -p {}'.format(pfo_sc_sj))
print_and_run('mkdir -p {}'.format(pfo_sc_sj_mod))
print_and_run('mkdir -p {}'.format(pfo_sc_sj_masks))
if controller['Register_T1']:
print('Orient header histological T1 and reg-mask:')
angles = sj_parameters['angles']
if isinstance(angles[0], list):
pitch_theta = -1 * angles[0][1]
else:
pitch_theta = -1 * angles[1]
pfi_original_T1 = jph(pfo_sj_mod, '{0}_{1}.nii.gz'.format(sj, 'T1'))
assert os.path.exists(pfi_original_T1), pfi_original_T1
pfi_T1_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}.nii.gz'.format(sj, 'T1'))
print_and_run('cp {} {}'.format(pfi_original_T1, pfi_T1_reoriented))
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(pfi_T1_reoriented, pfi_T1_reoriented, angle=pitch_theta,
principal_axis='pitch')
pfi_original_roi_mask_T1 = jph(pfo_sj_masks, '{0}_{1}_{2}.nii.gz'.format(sj, 'T1', 'roi_mask'))
assert os.path.exists(pfi_original_roi_mask_T1), pfi_original_roi_mask_T1
pfi_roi_mask_T1_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}_{2}.nii.gz'.format(sj, 'T1', 'roi_mask'))
print_and_run('cp {} {}'.format(pfi_original_roi_mask_T1, pfi_roi_mask_T1_reoriented))
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(pfi_roi_mask_T1_reoriented, pfi_roi_mask_T1_reoriented,
angle=pitch_theta, principal_axis='pitch')
pfi_original_reg_mask_T1 = jph(pfo_sj_masks, '{0}_{1}_{2}.nii.gz'.format(sj, 'T1', 'reg_mask'))
assert os.path.exists(pfi_original_reg_mask_T1), pfi_original_reg_mask_T1
pfi_reg_mask_T1_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}_{2}.nii.gz'.format(sj, 'T1', 'reg_mask'))
print_and_run('cp {} {}'.format(pfi_original_reg_mask_T1, pfi_reg_mask_T1_reoriented))
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(pfi_reg_mask_T1_reoriented,
pfi_reg_mask_T1_reoriented,
angle=pitch_theta, principal_axis='pitch')
del nis_app
print('Rigid registration T1:')
pfi_transformation_T1_over_T1 = jph(pfo_tmp, 'trans_{0}_over_{1}_mod_{2}_rigid.txt'.format(
sj, options['Template_name'], 'T1'))
pfi_resampled_T1 = jph(pfo_sc_sj_mod, '{0}_T1.nii.gz'.format(sj)) # RESULT
# THIS MUST BE A RIGID REGISTRATION!
cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -res {5} -omp {6} -rigOnly '.format(
pfi_mod_reference_atlas, pfi_reg_mask_reference_atlas, pfi_T1_reoriented, pfi_reg_mask_T1_reoriented,
pfi_transformation_T1_over_T1, pfi_resampled_T1, num_cores_run)
print_and_run(cmd)
del angles, pitch_theta, pfi_original_T1, pfi_T1_reoriented, pfi_original_reg_mask_T1, \
pfi_reg_mask_T1_reoriented, pfi_transformation_T1_over_T1, pfi_resampled_T1, cmd
if controller['Propagate_T1_masks']:
print('Propagate T1 mask:')
pfi_T1_in_sc = jph(pfo_sc_sj_mod, '{0}_T1.nii.gz'.format(sj))
pfi_roi_mask_T1_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}_{2}.nii.gz'.format(sj, 'T1', 'roi_mask'))
pfi_reg_mask_T1_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}_{2}.nii.gz'.format(sj, 'T1', 'reg_mask'))
pfi_transformation_T1_over_T1 = jph(pfo_tmp, 'trans_{0}_over_{1}_mod_{2}_rigid.txt'.format(
sj, options['Template_name'], 'T1'))
assert os.path.exists(pfi_T1_in_sc), pfi_T1_in_sc
assert os.path.exists(pfi_roi_mask_T1_reoriented), pfi_roi_mask_T1_reoriented
assert os.path.exists(pfi_reg_mask_T1_reoriented), pfi_reg_mask_T1_reoriented
assert os.path.exists(pfi_transformation_T1_over_T1), pfi_transformation_T1_over_T1
pfi_final_roi_mask_T1 = jph(pfo_sc_sj_masks, '{}_roi_mask.nii.gz'.format(sj)) # RESULT
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_T1_in_sc, pfi_roi_mask_T1_reoriented, pfi_transformation_T1_over_T1, pfi_final_roi_mask_T1)
print_and_run(cmd)
pfi_final_reg_mask_T1 = jph(pfo_sc_sj_masks, '{0}_{1}_reg_mask.nii.gz'.format(sj, 'T1'))
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_T1_in_sc, pfi_reg_mask_T1_reoriented, pfi_transformation_T1_over_T1, pfi_final_reg_mask_T1)
print_and_run(cmd)
del pfi_T1_in_sc, pfi_reg_mask_T1_reoriented, pfi_transformation_T1_over_T1
if controller['Register_S0']:
print('Orient header histological S0 and its reg-mask:')
angles = sj_parameters['angles']
if isinstance(angles[0], list):
pitch_theta = -1 * angles[1][1]
else:
pitch_theta = -1 * angles[1]
pfi_original_S0 = jph(pfo_sj_mod, '{0}_{1}.nii.gz'.format(sj, 'S0'))
assert os.path.exists(pfi_original_S0), pfi_original_S0
pfi_S0_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}.nii.gz'.format(sj, 'S0'))
print_and_run('cp {} {}'.format(pfi_original_S0, pfi_S0_reoriented))
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(pfi_S0_reoriented,
pfi_S0_reoriented,
angle=pitch_theta, principal_axis='pitch')
pfi_original_reg_mask_S0 = jph(pfo_sj_masks, '{0}_{1}_{2}.nii.gz'.format(sj, 'S0', 'reg_mask'))
assert os.path.exists(pfi_original_reg_mask_S0), pfi_original_reg_mask_S0
pfi_reg_mask_S0_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}_{2}.nii.gz'.format(sj, 'S0', 'reg_mask'))
print_and_run('cp {} {}'.format(pfi_original_reg_mask_S0, pfi_reg_mask_S0_reoriented))
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(pfi_reg_mask_S0_reoriented, pfi_reg_mask_S0_reoriented,
angle=pitch_theta, principal_axis='pitch')
del nis_app
print('Rigid registration S0:')
pfi_transformation_S0_over_T1 = jph(pfo_tmp, 'trans_{0}_over_{1}_mod_{2}_rigid.txt'.format(
sj, options['Template_name'], 'S0'))
pfi_resampled_S0 = jph(pfo_sc_sj_mod, '{0}_S0.nii.gz'.format(sj)) # RESULT
# Try the non rigid and full mask -rigOnly
cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -aff {4} -res {5} -omp {6} '.format( #-rigOnly
pfi_mod_reference_atlas, pfi_reg_mask_reference_atlas, pfi_S0_reoriented, pfi_reg_mask_S0_reoriented,
pfi_transformation_S0_over_T1, pfi_resampled_S0, num_cores_run)
print_and_run(cmd)
del angles, pitch_theta, pfi_original_S0, pfi_S0_reoriented, pfi_original_reg_mask_S0, \
pfi_reg_mask_S0_reoriented, pfi_transformation_S0_over_T1, pfi_resampled_S0, cmd
if controller['Propagate_S0_related_mods_and_mask']:
angles = sj_parameters['angles']
if isinstance(angles[0], list):
pitch_theta = -1 * angles[1][1]
else:
pitch_theta = -1 * angles[1]
pfi_S0_in_sc = jph(pfo_sc_sj_mod, '{0}_S0.nii.gz'.format(sj))
pfi_transformation_S0_over_T1 = jph(pfo_tmp, 'trans_{0}_over_{1}_mod_{2}_rigid.txt'.format(
sj, options['Template_name'], 'S0'))
for mod in ['FA', 'MD', 'V1']:
print('Orient header histological {}:'.format(mod))
pfi_original_MOD = jph(pfo_sj_mod, '{0}_{1}.nii.gz'.format(sj, mod))
assert os.path.exists(pfi_original_MOD), pfi_original_MOD
pfi_MOD_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}.nii.gz'.format(sj, mod))
print_and_run('cp {} {}'.format(pfi_original_MOD, pfi_MOD_reoriented))
if pitch_theta != 0:
nis_app = nis.App()
nis_app.header.apply_small_rotation(pfi_MOD_reoriented, pfi_MOD_reoriented,
angle=pitch_theta, principal_axis='pitch')
del nis_app
print('Resampling {}:'.format(mod))
pfi_final_MOD = jph(pfo_sc_sj_mod, '{0}_{1}.nii.gz'.format(sj, mod)) # RESULT
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 1'.format(
pfi_S0_in_sc, pfi_MOD_reoriented, pfi_transformation_S0_over_T1, pfi_final_MOD)
print_and_run(cmd)
pfi_reg_mask_S0_reoriented = jph(pfo_tmp, 'histo_header_{0}_{1}_{2}.nii.gz'.format(sj, 'S0', 'reg_mask'))
assert os.path.exists(pfi_reg_mask_S0_reoriented), pfi_reg_mask_S0_reoriented
pfi_final_reg_mask_S0_reoriented = jph(pfo_sc_sj_masks, '{0}_{1}_reg_mask.nii.gz'.format(sj, 'S0')) # RESULT
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_S0_in_sc, pfi_reg_mask_S0_reoriented, pfi_transformation_S0_over_T1, pfi_final_reg_mask_S0_reoriented)
print_and_run(cmd)
if controller['Adjustments']:
# work only on the sc newly generated chart:
pfi_sc_T1 = jph(pfo_sc_sj_mod, '{0}_T1.nii.gz'.format(sj))
pfi_sc_S0 = jph(pfo_sc_sj_mod, '{0}_S0.nii.gz'.format(sj))
pfi_sc_FA = jph(pfo_sc_sj_mod, '{0}_FA.nii.gz'.format(sj))
pfi_sc_MD = jph(pfo_sc_sj_mod, '{0}_MD.nii.gz'.format(sj))
pfi_sc_V1 = jph(pfo_sc_sj_mod, '{0}_V1.nii.gz'.format(sj))
assert os.path.exists(pfi_sc_T1), pfi_sc_T1
assert os.path.exists(pfi_sc_S0), pfi_sc_S0
assert os.path.exists(pfi_sc_FA), pfi_sc_FA
assert os.path.exists(pfi_sc_MD), pfi_sc_MD
assert os.path.exists(pfi_sc_V1), pfi_sc_V1
print_and_run('seg_maths {0} -thr 0 {0} '.format(pfi_sc_T1))
print_and_run('seg_maths {0} -thr 0 {0} '.format(pfi_sc_S0))
print_and_run('seg_maths {0} -thr 0 {0} '.format(pfi_sc_FA))
print_and_run('seg_maths {0} -thr 0 {0} '.format(pfi_sc_MD))
print_and_run('seg_maths {0} -abs {0} '.format(pfi_sc_V1))
pfi_sc_roi_mask = jph(pfo_sc_sj_masks, '{}_roi_mask.nii.gz'.format(sj))
assert os.path.exists(pfi_sc_roi_mask), pfi_sc_roi_mask
# create mask for V1:
pfi_V1_mask = jph(pfo_tmp, 'roi_mask_V1_{}.nii.gz'.format(sj))
stack_a_list_of_images_from_list_pfi(
[pfi_sc_roi_mask for _ in range(3)], pfi_V1_mask)
if sj_parameters['options_T1']['crop_roi']:
print_and_run('seg_maths {0} -mul {1} {0} '.format(pfi_sc_T1, pfi_sc_roi_mask))
print_and_run('seg_maths {0} -mul {1} {0} '.format(pfi_sc_S0, pfi_sc_roi_mask))
print_and_run('seg_maths {0} -mul {1} {0} '.format(pfi_sc_FA, pfi_sc_roi_mask))
print_and_run('seg_maths {0} -mul {1} {0} '.format(pfi_sc_MD, pfi_sc_roi_mask))
print_and_run('seg_maths {0} -mul {1} {0} '.format(pfi_sc_V1, pfi_V1_mask))
def run_comparison_inter_rater():
# -- CONTROLLER
label_hippocampus = 31
pfo_root_experiments_input = path_manager.pfo_test_retest_inter_rater_input
pfo_root_experiments_output = path_manager.pfo_test_retest_inter_rater_elaborations
controller = {
'compute_data': True,
'plot_data_table': True,
'see_segmentations': True
}
# -- DATA
pfi_segm_raterH = jph(pfo_root_experiments_input, 'H.nii.gz')
pfi_segm_raterL = jph(pfo_root_experiments_input, 'L.nii.gz')
pfi_segm_auto = jph(pfo_root_experiments_input, 'auto.nii.gz')
assert os.path.exists(pfi_segm_raterH)
assert os.path.exists(pfi_segm_raterL)
assert os.path.exists(pfi_segm_auto)
# -- WORKFLOW
if controller['compute_data']:
raterH_vs_raterL = np.zeros(4)
raterH_vs_auto = np.zeros(4)
raterL_vs_auto = np.zeros(4)
im_raterH = nib.load(pfi_segm_raterH)
im_raterL = nib.load(pfi_segm_raterL)
im_auto = nib.load(pfi_segm_auto)
# dice score:
raterH_vs_raterL[0] = dice_score_one_label(im_raterH, im_raterL,
label_hippocampus)
raterH_vs_auto[0] = dice_score_one_label(im_raterH, im_auto,
label_hippocampus)
raterL_vs_auto[0] = dice_score_one_label(im_raterL, im_auto,
label_hippocampus)
# Covariance distance:
raterH_vs_raterL[1] = covariance_distance(im_raterH,
im_raterL, [
label_hippocampus,
], [
label_hippocampus,
],
factor=10)[label_hippocampus]
raterH_vs_auto[1] = covariance_distance(im_raterH,
im_auto, [
label_hippocampus,
], [
label_hippocampus,
],
factor=10)[label_hippocampus]
raterL_vs_auto[1] = covariance_distance(im_raterL,
im_auto, [
label_hippocampus,
], [
label_hippocampus,
],
factor=10)[label_hippocampus]
# Hausdorff distance:
raterH_vs_raterL[2] = hausdorff_distance_one_label(im_raterH,
im_raterL,
label_hippocampus,
return_mm3=True)
raterH_vs_auto[2] = hausdorff_distance_one_label(im_raterH,
im_auto,
label_hippocampus,
return_mm3=True)
raterL_vs_auto[2] = hausdorff_distance_one_label(im_raterL,
im_auto,
label_hippocampus,
return_mm3=True)
# NSCD:
raterH_vs_raterL[3] = symmetric_contour_distance_one_label(
im_raterH, im_raterL, label_hippocampus, return_mm3=True)
raterH_vs_auto[3] = symmetric_contour_distance_one_label(
im_raterH, im_auto, label_hippocampus, return_mm3=True)
raterL_vs_auto[3] = symmetric_contour_distance_one_label(
im_raterL, im_auto, label_hippocampus, return_mm3=True)
print raterH_vs_raterL
print raterH_vs_auto
print raterL_vs_auto
d = OrderedDict({
'raterH_vs_raterL': raterH_vs_raterL,
'raterH_vs_auto': raterH_vs_auto,
'raterL_vs_auto': raterL_vs_auto
})
df = pa.DataFrame(data=d, index=['Dice', 'CovDist', 'HD', 'NSCD'])
df.T.to_pickle(jph(pfo_root_experiments_output, 'results.pickle'))
if controller['compute_data']:
df = pa.read_pickle(jph(pfo_root_experiments_output, 'results.pickle'))
print df.to_latex()
df.to_latex(jph(pfo_root_experiments_output, 'result_comparison.tex'))
if controller['see_segmentations']:
"""
Colourig idea:
Primary colors: segmentations
- RED 7 auto
- YELLOW 1 L (rater 2)
- BLUE 4 H (rater 1)
Secondary colours: intersections
- Orange 11 auto + H
- Purple 8 auto + L
- Green 5 L + H
Axial slice suggested 181
"""
for f, f_label in zip(['L', 'H', 'auto'], [1, 4, 7]):
# get contours
pfi_segm = jph(pfo_root_experiments_input, '{}.nii.gz'.format(f))
assert os.path.exists(pfi_segm)
pfi_contour = jph(pfo_root_experiments_output,
'{}_contour.nii.gz'.format(f))
nis_app = nis.App()
nis_app.manipulate_intensities.get_contour_from_segmentation(
pfi_segm, pfi_contour, omit_axis='y', verbose=1)
# change labels values:
os.system('seg_maths {0} -bin {0}'.format(pfi_contour))
os.system('seg_maths {0} -mul {1} {0}'.format(
pfi_contour, f_label))
# sum contour together within a single segmentation:
pfi_final_sum = jph(pfo_root_experiments_output, 'sum_contours.nii.gz')
os.system('cp {0} {1}'.format(
jph(pfo_root_experiments_output, '{}_contour.nii.gz'.format('L')),
pfi_final_sum))
for f in ['H', 'auto']:
os.system('seg_maths {0} -add {1} {0}'.format(
pfi_final_sum,
jph(pfo_root_experiments_output,
'{}_contour.nii.gz'.format(f))))
# open them: (anonymised and randomly selected subject 1203, hidden from the rater)
sj = '1203'
pfi_anatomy = jph(path_manager.pfo_multi_atlas, sj, 'mod',
'{}_T1.nii.gz'.format(sj))
assert os.path.exists(pfi_anatomy)
pfi_labels_descriptor = jph(pfo_root_experiments_input,
'label_descriptor.txt')
cmd = 'itksnap -g {0} -s {1} -l {2}'.format(pfi_anatomy, pfi_final_sum,
pfi_labels_descriptor)
os.system(cmd)
def collect_measurements_intra_rater_tst_retest():
print '\n==================='
print '\n\nTaxonomical division inter-rater test-re-test'
print '==================='
print 'Compare man1 with man2 taxonomical'
nis_app = nis.App()
nis_app.measure.verbose = True
man1_man2_measures_divide_taxonomical = nis_app.measure.dist(
ph.pfi_segm_man1_divided_taxonomical,
ph.pfi_segm_man2_divided_taxonomical,
labels_list=nomenclature_taxonomical.keys(),
labels_names=nomenclature_taxonomical.keys(),
metrics=(dist.dice_score, dist.covariance_distance,
dist.hausdorff_distance,
dist.normalised_symmetric_contour_distance),
where_to_save=ph.pfi_pickled_scoring_man1_man2_taxo)
print '---------------'
print 'Compare man1 with man2 divided taxonomical'
print man1_man2_measures_divide_taxonomical
del nis_app
print '\n\n==================='
print 'Compare auto with man1 taxonomical'
nis_app = nis.App()
nis_app.measure.verbose = True
auto_man1_measures_divide_taxonomical = nis_app.measure.dist(
ph.pfi_segm_auto_divided_taxonomical,
ph.pfi_segm_man1_divided_taxonomical,
labels_list=nomenclature_taxonomical.keys(),
labels_names=nomenclature_taxonomical.keys(),
metrics=(dist.dice_score, dist.covariance_distance,
dist.hausdorff_distance,
dist.normalised_symmetric_contour_distance),
where_to_save=ph.pfi_pickled_scoring_auto_man1_taxo)
print '---------------'
print 'Compare auto with man1 divided taxonomical'
print auto_man1_measures_divide_taxonomical
del nis_app
print '\n\n==================='
print 'Compare auto with man2 taxonomical'
nis_app = nis.App()
nis_app.measure.verbose = True
auto_man2_measures_divide_taxonomical = nis_app.measure.dist(
ph.pfi_segm_auto_divided_taxonomical,
ph.pfi_segm_man2_divided_taxonomical,
labels_list=nomenclature_taxonomical.keys(),
labels_names=nomenclature_taxonomical.keys(),
metrics=(dist.dice_score, dist.covariance_distance,
dist.hausdorff_distance,
dist.normalised_symmetric_contour_distance),
where_to_save=ph.pfi_pickled_scoring_auto_man2_taxo)
print '---------------'
print 'Compare auto with man2 divided taxonomical'
print auto_man2_measures_divide_taxonomical
del nis_app
def process_DWI_per_subject(sj, controller):
print('\nProcessing DWI, subject {} started.\n'.format(sj))
if sj not in list_all_subjects(pfo_subjects_parameters):
raise IOError('Subject parameters not known. Subject {}'.format(sj))
sj_parameters = pickle.load(open(jph(pfo_subjects_parameters, sj), 'r'))
DWI_suffix = sj_parameters['names_architecture']['DWI'] # default is DWI
study = sj_parameters['study']
category = sj_parameters['category']
pfo_input_sj_DWI = jph(root_study_rabbits, '02_nifti', study, category, sj,
'{}_{}'.format(sj, DWI_suffix))
pfo_output_sj = jph(root_study_rabbits, 'A_data', study, category, sj)
if not os.path.exists(pfo_input_sj_DWI):
print(
'DWI modality not given in the input folder after Nifti conversion. '
'Bypass methods involving DWI for subject {}'.format(sj))
return
if not os.path.exists(pfo_output_sj):
raise IOError(
'Output folder DWI does not exist. Subject {}'.format(sj))
# -- Generate intermediate and output folders:
pfo_mod = jph(pfo_output_sj, 'mod')
pfo_segm = jph(pfo_output_sj, 'segm')
pfo_mask = jph(pfo_output_sj, 'masks')
pfo_tmp = jph(pfo_output_sj, 'z_tmp', 'z_' + DWI_suffix)
print_and_run('mkdir -p {}'.format(pfo_output_sj))
print_and_run('mkdir -p {}'.format(pfo_mod))
print_and_run('mkdir -p {}'.format(pfo_segm))
print_and_run('mkdir -p {}'.format(pfo_mask))
print_and_run('mkdir -p {}'.format(pfo_tmp))
if controller['squeeze']:
print('- squeeze {}'.format(sj))
pfi_dwi = jph(pfo_input_sj_DWI, '{}_{}.nii.gz'.format(sj, DWI_suffix))
assert os.path.exists(pfi_dwi)
squeeze_image_from_path(pfi_dwi, pfi_dwi)
del pfi_dwi
if controller['orient_to_standard']:
print('- orient to standard {}'.format(sj))
# DWI
pfi_dwi_original = jph(pfo_input_sj_DWI,
'{}_{}.nii.gz'.format(sj, DWI_suffix))
assert check_path_validity(pfi_dwi_original)
pfi_dwi_std = jph(pfo_tmp,
'{}_{}_to_std.nii.gz'.format(sj, DWI_suffix))
orient2std(pfi_dwi_original, pfi_dwi_std)
# S0
if sj_parameters['b0_level'] == 0:
pfi_S0_original = jph(pfo_input_sj_DWI,
'{}_{}_S0.nii.gz'.format(sj, DWI_suffix))
else:
# create the time-point t and save its path under pfi_S0_original
tp = sj_parameters['b0_level']
pfi_DWI_original = jph(pfo_input_sj_DWI,
'{}_{}.nii.gz'.format(sj, DWI_suffix))
assert check_path_validity(pfi_DWI_original)
pfi_S0_original = jph(
pfo_tmp, '{0}_{1}_S0_tp{2}.nii.gz'.format(sj, DWI_suffix, tp))
grab_a_timepoint_path(pfi_DWI_original, pfi_S0_original, tp)
assert check_path_validity(pfi_S0_original)
pfi_S0_std = jph(pfo_tmp,
'{}_{}_S0_to_std.nii.gz'.format(sj, DWI_suffix))
orient2std(pfi_S0_original, pfi_S0_std)
if sj_parameters['DWI_squashed']:
scale_y_value_and_trim(pfi_dwi_std,
pfi_dwi_std,
squeeze_factor=2.218074656188605)
scale_y_value_and_trim(pfi_S0_std,
pfi_S0_std,
squeeze_factor=2.218074656188605)
del pfi_dwi_original, pfi_dwi_std, pfi_S0_original, pfi_S0_std
if controller['create_roi_masks']:
# Ideal pipeline uses the T1_roi_mask, that has been created before.
# Not ideally some data have different orientation for each modality.
# not ideally T1 has not been computed yet - not working in this case.
# Path T1 mask
pfi_sj_T1_roi_mask = jph(pfo_mask, '{}_T1_roi_mask.nii.gz'.format(sj))
assert os.path.exists(
pfi_sj_T1_roi_mask
), 'Mask {} missing. Run T1 pipeline before'.format(pfi_sj_T1_roi_mask)
# Conditional flags: mask creation options
# can_resample_T1 = False # Different modalities are in the same space. It is enough to resample T1.
# need_to_register_mask = False # Different modalities in different spaces. Pure resampling is not working!
#
# if isinstance(sj_parameters['angles'][0], list):
# need_to_register_mask = True
# else:
# can_resample_T1 = True
# # process:
# if can_resample_T1:
# print('- Create roi masks {}'.format(sj))
# pfi_S0 = jph(pfo_tmp, '{}_{}_S0_to_std.nii.gz'.format(sj, DWI_suffix))
# pfi_affine_identity = jph(pfo_tmp, 'id.txt')
# np.savetxt(pfi_affine_identity, np.eye(4), fmt='%d')
# pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
# cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
# pfi_S0,
# pfi_sj_T1_roi_mask,
# pfi_affine_identity,
# pfi_roi_mask)
# print_and_run(cmd)
# del pfi_S0, pfi_affine_identity, pfi_roi_mask, cmd
#
# elif need_to_register_mask:
print('- Register roi masks {}'.format(sj))
pfi_S0 = jph(pfo_tmp, '{}_{}_S0_to_std.nii.gz'.format(sj, DWI_suffix))
assert os.path.exists(pfi_S0), pfi_S0
pfi_T1 = jph(pfo_mod, '{}_T1.nii.gz'.format(sj))
pfi_T1_roi_mask = jph(pfo_mask, '{}_T1_roi_mask.nii.gz'.format(sj))
assert os.path.exists(pfi_T1), pfi_T1
assert os.path.exists(pfi_T1_roi_mask), pfi_T1_roi_mask
pfi_T1_hd_oriented = jph(pfo_tmp,
'{}_T1_hd_oriented_to_S0.nii.gz'.format(sj))
pfi_T1_roi_mask_hd_oriented = jph(
pfo_tmp, '{}_T1_roi_mask_hd_oriented_to_S0.nii.gz'.format(sj))
# check if the orientation angles are different for each modality:
if isinstance(sj_parameters['angles'][0], list):
# re-orient the T1 and the T1-mask on the S0 to better initialise the mask propagation.
angles = sj_parameters['angles'][1]
angle_parameter = angles[1]
nis_app = nis.App()
nis_app.header.apply_small_rotation(pfi_T1,
pfi_T1_hd_oriented,
angle=angle_parameter,
principal_axis='pitch')
nis_app.header.apply_small_rotation(pfi_T1_roi_mask,
pfi_T1_roi_mask_hd_oriented,
angle=angle_parameter,
principal_axis='pitch')
else:
cmd1 = 'cp {0} {1}'.format(pfi_T1, pfi_T1_hd_oriented)
cmd2 = 'cp {0} {1}'.format(pfi_T1_roi_mask,
pfi_T1_roi_mask_hd_oriented)
os.system(cmd1)
os.system(cmd2)
assert check_path_validity(pfi_T1_hd_oriented)
assert check_path_validity(pfi_T1_roi_mask_hd_oriented)
pfi_affine_transformation_ref_on_subject = jph(
pfo_tmp, 'aff_ref_on_' + sj + '_S0.txt')
pfi_3d_warped_ref_on_subject = jph(pfo_tmp,
'warp_ref_on_' + sj + '_S0.nii.gz')
cmd0 = 'reg_aladin -ref {0} -flo {1} -fmask {2} -aff {3} -res {4} -omp {5} -rigOnly; '.format(
pfi_S0, pfi_T1_hd_oriented, pfi_T1_roi_mask_hd_oriented,
pfi_affine_transformation_ref_on_subject,
pfi_3d_warped_ref_on_subject, num_cores_run)
print_and_run(cmd0)
print('- propagate roi masks {}'.format(sj))
assert check_path_validity(pfi_affine_transformation_ref_on_subject)
pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
cmd1 = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_S0, pfi_T1_roi_mask_hd_oriented,
pfi_affine_transformation_ref_on_subject, pfi_roi_mask)
print_and_run(cmd1)
del pfi_S0, pfi_3d_warped_ref_on_subject, pfi_T1, pfi_T1_hd_oriented, pfi_T1_roi_mask, \
pfi_T1_roi_mask_hd_oriented, pfi_affine_transformation_ref_on_subject, pfi_roi_mask, cmd0, cmd1
if controller['adjust_mask']:
print('- adjust mask {}'.format(sj))
pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
assert check_path_validity(pfi_roi_mask)
pfi_roi_mask_dil = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
dil_factor = sj_parameters['options_S0']['mask_dilation']
cmd = 'seg_maths {0} -dil {1} {2}'.format(pfi_roi_mask, dil_factor,
pfi_roi_mask_dil)
print_and_run(cmd)
del pfi_roi_mask, pfi_roi_mask_dil, dil_factor, cmd
if controller['cut_mask_dwi']:
print('- cut mask dwi {}'.format(sj))
pfi_dwi = jph(pfo_tmp, '{}_{}_to_std.nii.gz'.format(sj, DWI_suffix))
pfi_roi_mask = jph(pfo_mask, '{}_S0_roi_mask.nii.gz'.format(sj))
assert check_path_validity(pfi_dwi)
assert check_path_validity(pfi_roi_mask)
pfi_dwi_cropped = jph(pfo_tmp,
'{}_{}_cropped.nii.gz'.format(sj, DWI_suffix))
cut_dwi_image_from_first_slice_mask_path(pfi_dwi, pfi_roi_mask,
pfi_dwi_cropped)
print('cutting done. Input DWI {0}. Output cropped {1}.\n\n'.format(
pfi_dwi, pfi_dwi_cropped))
del pfi_dwi, pfi_roi_mask, pfi_dwi_cropped
if controller['cut_mask_S0']:
print('- cut mask S0 {}'.format(sj))
pfi_S0 = jph(pfo_tmp, '{}_{}_S0_to_std.nii.gz'.format(sj, DWI_suffix))
pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
assert check_path_validity(pfi_S0)
assert check_path_validity(pfi_roi_mask)
pfi_S0_cropped = jph(pfo_tmp, sj + '_S0_cropped.nii.gz')
cmd = 'seg_maths {0} -mul {1} {2}'.format(pfi_S0, pfi_roi_mask,
pfi_S0_cropped)
print_and_run(cmd)
del pfi_S0, pfi_roi_mask, pfi_S0_cropped, cmd
if controller['correct_slope']:
print('- correct slope {}'.format(sj))
# --
pfi_dwi_cropped = jph(pfo_tmp,
'{}_{}_cropped.nii.gz'.format(sj, DWI_suffix))
pfi_slope_txt = jph(pfo_input_sj_DWI,
'{}_{}_slope.txt'.format(sj, DWI_suffix))
assert check_path_validity(pfi_dwi_cropped), pfi_dwi_cropped
assert check_path_validity(pfi_slope_txt), pfi_slope_txt
pfi_dwi_slope_corrected = jph(
pfo_tmp, '{}_{}_slope_corrected.nii.gz'.format(sj, DWI_suffix))
slopes = np.loadtxt(pfi_slope_txt)
slope_corrector_path(slopes, pfi_dwi_cropped, pfi_dwi_slope_corrected)
# --
pfi_S0_cropped = jph(pfo_tmp, sj + '_S0_cropped.nii.gz')
assert check_path_validity(pfi_S0_cropped)
pfi_S0_slope_corrected = jph(pfo_tmp,
sj + '_S0_slope_corrected.nii.gz')
slope_corrector_path(slopes[0], pfi_S0_cropped, pfi_S0_slope_corrected)
del pfi_dwi_cropped, pfi_slope_txt, pfi_dwi_slope_corrected, slopes, pfi_S0_cropped, pfi_S0_slope_corrected
if controller['eddy_current']:
print('- eddy current {}'.format(sj))
pfi_dwi_slope_corrected = jph(
pfo_tmp, '{}_{}_slope_corrected.nii.gz'.format(sj, DWI_suffix))
assert check_path_validity(pfi_dwi_slope_corrected)
pfi_dwi_eddy_corrected = jph(
pfo_tmp, '{}_{}_eddy.nii.gz'.format(sj, DWI_suffix))
cmd = 'eddy_correct {0} {1} 0 '.format(pfi_dwi_slope_corrected,
pfi_dwi_eddy_corrected)
print_and_run(cmd)
del pfi_dwi_slope_corrected, pfi_dwi_eddy_corrected, cmd
elif controller['fsl_tensor_fitting']:
pfi_dwi_slope_corrected = jph(
pfo_tmp, '{}_{}_slope_corrected.nii.gz'.format(sj, DWI_suffix))
pfi_dwi_eddy_corrected = jph(
pfo_tmp, '{}_{}_eddy.nii.gz'.format(sj, DWI_suffix))
cmd = 'cp {0} {1} '.format(pfi_dwi_slope_corrected,
pfi_dwi_eddy_corrected)
print_and_run(cmd)
del pfi_dwi_slope_corrected, pfi_dwi_eddy_corrected, cmd
else:
pass
if controller['fsl_tensor_fitting']:
print('- fsl tensor fitting {}'.format(sj))
pfi_dwi_eddy_corrected = jph(
pfo_tmp, '{}_{}_eddy.nii.gz'.format(sj, DWI_suffix))
pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
pfi_bvals = jph(pfo_input_sj_DWI,
'{}_{}_DwEffBval.txt'.format(sj, DWI_suffix))
pfi_bvects = jph(pfo_input_sj_DWI,
'{}_{}_DwGradVec.txt'.format(sj, DWI_suffix))
if isinstance(sj_parameters['b0_to_use_in_fsldti'], list):
b0_tps_to_keep = sj_parameters['b0_to_use_in_fsldti']
tag = str(b0_tps_to_keep).replace('[',
'').replace(']', '').replace(
',', '').replace(' ', '_')
# out of the initial n uses only the one at the selected timepoint.
bvals = np.loadtxt(pfi_bvals)
bvects = np.loadtxt(pfi_bvects)
num_bzeros = np.sum(bvals == bvals[0])
assert len(b0_tps_to_keep) < num_bzeros
bvals_new = np.concatenate([[
bvals[0],
] * len(b0_tps_to_keep), bvals[num_bzeros:]])
bvect_new = np.vstack([
bvects[0, :].reshape(1, -1),
] * len(b0_tps_to_keep) + [bvects[num_bzeros:, :]])
pfi_bvals_new = jph(
pfo_tmp,
'{}_{}_DwEffBval_s0tp{}.txt'.format(sj, DWI_suffix, tag))
pfi_bvects_new = jph(
pfo_tmp,
'{}_{}_DwGradVec_s0tp{}.txt'.format(sj, DWI_suffix.tag))
np.savetxt(pfi_bvals_new, bvals_new)
np.savetxt(pfi_bvects_new, bvect_new)
im_eddy_corrected = nib.load(pfi_dwi_eddy_corrected)
x, y, z, t = im_eddy_corrected.shape
data_only_one_tp = np.concatenate([
im_eddy_corrected.get_data()[..., b0_tps_to_keep].reshape(
x, y, z, -1),
im_eddy_corrected.get_data()[..., num_bzeros:]
],
axis=3)
np.testing.assert_array_equal(
data_only_one_tp.shape,
[x, y, z, t - num_bzeros + len(b0_tps_to_keep)])
im_eddy_corrected_only_one_b0_tp = set_new_data(
im_eddy_corrected, data_only_one_tp)
pfi_dwi_eddy_corrected_new = jph(
pfo_tmp,
'{}_{}_eddy_s0tp{}.nii.gz'.format(sj, DWI_suffix, tag))
nib.save(im_eddy_corrected_only_one_b0_tp,
pfi_dwi_eddy_corrected_new)
assert check_path_validity(pfi_dwi_eddy_corrected)
assert os.path.exists(pfi_bvals)
assert os.path.exists(pfi_bvects)
assert check_path_validity(pfi_roi_mask)
pfi_analysis_fsl = jph(pfo_tmp, 'fsl_fit_' + sj)
here = os.getcwd()
cmd0 = 'cd {}'.format(pfo_tmp)
cmd1 = 'dtifit -k {0} -b {1} -r {2} -m {3} ' \
'-w --save_tensor -o {4}'.format(pfi_dwi_eddy_corrected_new,
pfi_bvals_new,
pfi_bvects_new,
pfi_roi_mask,
pfi_analysis_fsl)
cmd2 = 'cd {}'.format(here)
print_and_run(cmd0)
print_and_run(cmd1)
print_and_run(cmd2)
else:
assert check_path_validity(pfi_dwi_eddy_corrected)
assert os.path.exists(pfi_bvals)
assert os.path.exists(pfi_bvects)
assert check_path_validity(pfi_roi_mask)
pfi_analysis_fsl = jph(pfo_tmp, 'fsl_fit_' + sj)
here = os.getcwd()
cmd0 = 'cd {}'.format(pfo_tmp)
cmd1 = 'dtifit -k {0} -b {1} -r {2} -m {3} ' \
'-w --save_tensor -o {4}'.format(pfi_dwi_eddy_corrected,
pfi_bvals,
pfi_bvects,
pfi_roi_mask,
pfi_analysis_fsl)
cmd2 = 'cd {}'.format(here)
print_and_run(cmd0)
print_and_run(cmd1)
print_and_run(cmd2)
del pfi_dwi_eddy_corrected, pfi_bvals, pfi_bvects, pfi_roi_mask, pfi_analysis_fsl, cmd0, cmd1, cmd2
if controller['adjust_dtibased_mod']:
print('- adjust dti-based modalities {}'.format(sj))
pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
pfi_roi_mask_4d = jph(pfo_mask, sj + '_S0_roi_mask_4d.nii.gz')
pfi_v1 = jph(pfo_tmp, 'fsl_fit_' + sj + '_V1.nii.gz')
pfi_s0 = jph(pfo_tmp, 'fsl_fit_' + sj + '_S0.nii.gz')
pfi_FA = jph(pfo_tmp, 'fsl_fit_' + sj + '_FA.nii.gz')
pfi_MD = jph(pfo_tmp, 'fsl_fit_' + sj + '_MD.nii.gz')
cmd0, cmd1, cmd2 = None, None, None
for pfi_mod in [pfi_v1, pfi_s0, pfi_FA, pfi_MD]:
assert check_path_validity(pfi_mod)
if 'V1' in pfi_mod:
cmd0 = 'seg_maths {} -abs {}'.format(pfi_mod, pfi_mod)
print_and_run(cmd0)
reproduce_slice_fourth_dimension_path(pfi_roi_mask,
pfi_roi_mask_4d,
num_slices=3)
cmd1 = 'seg_maths {0} -mul {1} {0}'.format(
pfi_mod, pfi_roi_mask_4d, pfi_mod)
print_and_run(cmd1)
else:
cmd0 = 'seg_maths {0} -mul {1} {0}'.format(
pfi_mod, pfi_roi_mask, pfi_mod)
print_and_run(cmd0)
cmd0 = 'seg_maths {0} -removenan {0}'.format(pfi_mod)
print_and_run(cmd0)
cmd1 = 'seg_maths {0} -thr {1} {0}'.format(pfi_mod, '0')
print_and_run(cmd0)
del pfi_roi_mask, pfi_roi_mask_4d, pfi_v1, pfi_s0, pfi_FA, pfi_MD, cmd0, cmd1, cmd2
if controller['bfc_S0']:
print('- bfc S0 {}'.format(sj))
pfi_s0 = jph(pfo_tmp, 'fsl_fit_' + sj + '_S0.nii.gz')
pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
assert check_path_validity(pfi_s0)
assert check_path_validity(pfi_roi_mask)
set_new_data_path(pfi_target_im=pfi_s0,
pfi_image_where_the_new_data=pfi_roi_mask,
pfi_result=pfi_roi_mask)
bfc_param = sj_parameters['bias_field_parameters']
pfi_s0_bfc = jph(pfo_tmp, 'fsl_fit_' + sj + '_S0_bfc.nii.gz')
bias_field_correction(pfi_s0,
pfi_s0_bfc,
pfi_mask=pfi_roi_mask,
prefix='',
convergenceThreshold=bfc_param[0],
maximumNumberOfIterations=bfc_param[1],
biasFieldFullWidthAtHalfMaximum=bfc_param[2],
wienerFilterNoise=bfc_param[3],
numberOfHistogramBins=bfc_param[4],
numberOfControlPoints=bfc_param[5],
splineOrder=bfc_param[6],
print_only=False)
del pfi_s0, pfi_roi_mask, bfc_param, pfi_s0_bfc
if controller['create_lesion_mask']:
print('- create lesion mask {}'.format(sj))
pfi_s0_bfc = jph(pfo_tmp, 'fsl_fit_' + sj + '_S0_bfc.nii.gz')
pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
assert check_path_validity(pfi_s0_bfc)
assert os.path.exists(pfi_roi_mask)
pfi_lesion_mask = jph(pfo_mask, sj + '_S0_lesion_mask.nii.gz')
percentile = sj_parameters['options_S0']['window_percentile']
percentile_lesion_mask_extractor(im_input_path=pfi_s0_bfc,
im_output_path=pfi_lesion_mask,
im_mask_foreground_path=pfi_roi_mask,
percentiles=percentile,
safety_on=False)
del pfi_s0_bfc, pfi_roi_mask, pfi_lesion_mask
if controller['create_reg_masks']:
print('- create reg masks {}'.format(sj))
pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz')
pfi_lesion_mask = jph(pfo_mask, sj + '_S0_lesion_mask.nii.gz')
assert os.path.exists(pfi_roi_mask)
assert check_path_validity(pfi_lesion_mask)
pfi_registration_mask = jph(pfo_mask, sj + '_S0_reg_mask.nii.gz')
cmd = 'seg_maths {0} -sub {1} {2} '.format(
pfi_roi_mask, pfi_lesion_mask,
pfi_registration_mask) # until here seems correct.
print_and_run(cmd)
del pfi_roi_mask, pfi_lesion_mask, pfi_registration_mask, cmd
if controller['save_results']:
print('- save results {}'.format(sj))
pfi_v1 = jph(pfo_tmp, 'fsl_fit_' + sj + '_V1.nii.gz')
pfi_s0 = jph(pfo_tmp, 'fsl_fit_' + sj + '_S0.nii.gz')
pfi_FA = jph(pfo_tmp, 'fsl_fit_' + sj + '_FA.nii.gz')
pfi_MD = jph(pfo_tmp, 'fsl_fit_' + sj + '_MD.nii.gz')
for p in [pfi_v1, pfi_s0, pfi_FA, pfi_MD]:
assert check_path_validity(p)
pfi_v1_new = jph(pfo_mod, sj + '_V1.nii.gz')
pfi_s0_new = jph(pfo_mod, sj + '_S0.nii.gz')
pfi_FA_new = jph(pfo_mod, sj + '_FA.nii.gz')
pfi_MD_new = jph(pfo_mod, sj + '_MD.nii.gz')
for a, b in zip([pfi_v1, pfi_s0, pfi_FA, pfi_MD],
[pfi_v1_new, pfi_s0_new, pfi_FA_new, pfi_MD_new]):
cmd = 'cp {0} {1}'.format(a, b)
print_and_run(cmd)
del pfi_v1, pfi_s0, pfi_FA, pfi_MD, pfi_v1_new, pfi_s0_new, pfi_FA_new, pfi_MD_new
def get_selection_dataset(subset, get_other_tissue_probability=True, keep_fuzzy_uint8=False):
"""
From the dataset converted, it will provide a new dataset with a selection of segmentations.
It will provide 3 images in the subject folder:
> T1
> CRIPS
> 4d volumes with the FUZZY probability of the required subset and the other tissues in one label if required.
:param subset: selection of segmentation as a sublist of names_tissues
:param get_other_tissue_probability: [True] will merge all the other tissue in one label and provide this tissue
probability as well as the others in the stack.
:param keep_fuzzy_uint8: [False] if True fuzzy will be between 0 and 255, if False, result will be between 0 and 1.
:return:
"""
other_tissue = set(bw.names_tissues) - set(subset + ['bck'])
old_labels = [0, ] + [bw.names_tissues.index(k) for k in subset] + [bw.names_tissues.index(k) for k in other_tissue]
new_labels = [0, ] + list(range(1, len(subset) + 1))
labels_mask = [0, ] + [1, ] * len(subset) + [0, ] * len(other_tissue)
if get_other_tissue_probability:
labels_plus_one = np.max(new_labels) + 1
new_labels = new_labels + [labels_plus_one, ] * len(other_tissue)
else:
new_labels = new_labels + [0, ] * len(other_tissue)
os.system('mkdir {}'.format(bw.pfo_data))
for sj in bw.subjects_num_list:
print('Subject {}'.format(sj))
pfo_sj_nifti = os.path.join(bw.pfo_nifti_in_root, 'BW{}'.format(sj))
pfo_sj_nifti_new = os.path.join(bw.pfo_data, 'BW{}'.format(sj))
# os.system('mkdir {}'.format(pfo_sj_nifti_new))
pfi_nifti_T1 = os.path.join(pfo_sj_nifti, 'BW{}_{}.nii.gz'.format(sj, bw.name_T1.upper()))
pfi_nifti_CRISP = os.path.join(pfo_sj_nifti, 'BW{}_{}.nii.gz'.format(sj, bw.name_crisp.upper()))
pfi_nifti_T1_new = os.path.join(pfo_sj_nifti_new, 'BW{}_{}.nii.gz'.format(sj, bw.name_T1.upper()))
pfi_nifti_CRISP_new = os.path.join(pfo_sj_nifti_new, 'BW{}_{}.nii.gz'.format(sj, bw.name_crisp.upper()))
os.system('cp {} {}'.format(pfi_nifti_T1, pfi_nifti_T1_new))
os.system('cp {} {}'.format(pfi_nifti_CRISP, pfi_nifti_CRISP_new))
nis_app = nis.App()
nis_app.manipulate_labels.relabel(pfi_nifti_CRISP_new, pfi_nifti_CRISP_new, old_labels, new_labels)
pfi_nifti_MASK = os.path.join(pfo_sj_nifti_new, 'BW{}_MASK.nii.gz'.format(sj))
os.system('cp {} {}'.format(pfi_nifti_CRISP_new, pfi_nifti_MASK))
nis_app.manipulate_labels.relabel(pfi_nifti_MASK, pfi_nifti_MASK, new_labels, labels_mask)
list_nib_fuzzy_segm = []
for s in subset:
pfi_output_nifti_fuzzy = os.path.join(pfo_sj_nifti, 'BW{}_{}.nii.gz'.format(sj, s))
list_nib_fuzzy_segm.append(nib.load(pfi_output_nifti_fuzzy))
if get_other_tissue_probability:
array_other_tissue = np.zeros_like(list_nib_fuzzy_segm[0].get_data(), dtype=np.int32)
for s_other in other_tissue:
pfi_output_nifti_fuzzy = os.path.join(pfo_sj_nifti, 'BW{}_{}.nii.gz'.format(sj, s_other))
array_other_tissue += nib.load(pfi_output_nifti_fuzzy).get_data()
sum_fuzzy = np.zeros_like(list_nib_fuzzy_segm[0].get_data(), dtype=np.int32)
for a in list_nib_fuzzy_segm:
sum_fuzzy += a.get_data()
if get_other_tissue_probability:
sum_fuzzy += array_other_tissue
if keep_fuzzy_uint8:
if get_other_tissue_probability:
new_data_no_bkg = np.stack([a.get_data().astype(np.uint16) for a in list_nib_fuzzy_segm] + [array_other_tissue], axis=3)
else:
new_data_no_bkg = np.stack([a.get_data().astype(np.uint16) for a in list_nib_fuzzy_segm], axis=3)
sum_probabilities = np.sum(new_data_no_bkg, axis=3)
excedence_matrix = np.zeros_like(new_data_no_bkg)
X, Y, Z = np.where(sum_probabilities > 255)
for x, y, z in zip(X, Y, Z):
pos_max = np.argmax(new_data_no_bkg[x, y, z, :])
excedence_matrix[x, y, z, pos_max] = sum_probabilities[x, y, z] - 255
new_data_no_bkg = new_data_no_bkg - excedence_matrix
sum_fuzzy = np.sum(new_data_no_bkg, axis=3)
assert np.max(sum_fuzzy) <= 255
bkg_data = 255 - sum_fuzzy
new_data = np.stack([bkg_data] + [new_data_no_bkg[...,p] for p in range(len(subset))], axis=3).astype(np.uint8)
new_image = nib.Nifti1Image(new_data, list_nib_fuzzy_segm[0].affine, header=list_nib_fuzzy_segm[0].header)
pfi_nifti_fuzzy_new = os.path.join(pfo_sj_nifti_new, 'BW{}_FUZZY.nii.gz'.format(sj))
nib.save(new_image, pfi_nifti_fuzzy_new)
else:
excedence_matrix = (sum_fuzzy > 255) * (sum_fuzzy - 255)
normaliser_single_slice = 255 * np.ones_like(sum_fuzzy) + excedence_matrix
if get_other_tissue_probability:
new_data_no_bkg = np.nan_to_num(np.stack([a.get_data().astype(np.float64)/normaliser_single_slice for a in list_nib_fuzzy_segm] + [array_other_tissue.astype(np.float64)/normaliser_single_slice], axis=3))
else:
new_data_no_bkg = np.nan_to_num(np.stack([a.get_data().astype(np.float64) / normaliser_single_slice for a in list_nib_fuzzy_segm], axis=3))
assert np.max(new_data_no_bkg) <= 1.0
assert np.min(new_data_no_bkg) >= .0
bkg_data = 1 - np.sum(new_data_no_bkg, axis=3)
new_data = np.stack([bkg_data] + [new_data_no_bkg[..., p] for p in range(new_data_no_bkg.shape[-1])], axis=3).astype(
np.float64)
s = np.sum(new_data, axis=3)
np.testing.assert_array_almost_equal(s, np.ones_like(s), decimal=10)
new_image = nib.Nifti1Image(new_data, list_nib_fuzzy_segm[0].affine)
pfi_nifti_fuzzy_new = os.path.join(pfo_sj_nifti_new, 'BW{}_FUZZY.nii.gz'.format(sj))
nib.save(new_image, pfi_nifti_fuzzy_new)
def open_subject(sj, coordinates, check_dice_if_in_atlas=True):
print('Quality control subject {}, coordinates {}'.format(sj, coordinates))
sj_parameters = pickle.load(open(jph(pfo_subjects_parameters, sj), 'r'))
study = sj_parameters['study']
category = sj_parameters['category']
in_atlas = sj_parameters['in_atlas']
segm_suffix = sj_parameters['names_architecture']['suffix_segm']
if study == 'W8':
pfo_atlas = root_atlas_W8
options = {
'Template_chart_path': jph(root_atlas_W8, '12503'),
'Template_name': '12503'
}
elif study == 'ACS' or study == 'PTB' or study == 'TestStudy':
pfo_atlas = root_atlas
options = {
'Template_chart_path': jph(root_atlas, '1305'),
'Template_name': '1305'
}
else:
raise IOError('Study for subject {} not feasible.'.format(sj))
root_subject = jph(root_study_rabbits, 'A_data', study, category, sj)
if coordinates == 'original':
pfo_sj_mod = jph(root_subject, 'mod')
pfo_sj_segm = jph(root_subject, 'segm')
if not os.path.exists(pfo_sj_mod):
print('\n\n Not existing {}!!'.format(pfo_sj_mod))
if not os.path.exists(pfo_sj_segm):
print('\n\n Not existing {}!!'.format(pfo_sj_mod))
# open T1 in one frame:
cmd = 'itksnap -g {} -o '.format(
jph(pfo_sj_mod, '{}_T1.nii.gz'.format(sj)))
cmd += ' -s {} '.format(
jph(pfo_sj_segm, '{}_T1_segm.nii.gz'.format(sj)))
cmd += ' -l {}'.format(pfi_labels_descriptor)
os.system(cmd)
# open other modalities in the other frame:
cmd = 'itksnap -g {} -o '.format(
jph(pfo_sj_mod, '{}_S0.nii.gz'.format(sj)))
for m in ['FA', 'MD', 'V1']:
cmd += ' {} '.format(jph(pfo_sj_mod, '{}_{}.nii.gz'.format(sj, m)))
cmd += ' -s {} '.format(
jph(pfo_sj_segm, '{}_S0_segm.nii.gz'.format(sj)))
cmd += ' -l {}'.format(pfi_labels_descriptor)
os.system(cmd)
elif coordinates == 'stereotaxic':
pfo_sj_mod = jph(root_subject, 'stereotaxic', 'mod')
pfo_sj_segm = jph(root_subject, 'stereotaxic', 'segm')
if not os.path.exists(pfo_sj_mod):
print('\n\n Not existing {}!!'.format(pfo_sj_mod))
if not os.path.exists(pfo_sj_segm):
print('\n\n Not existing {}!!'.format(pfo_sj_mod))
print pfo_sj_mod
print pfo_sj_segm
pfi_segm = jph(pfo_sj_segm, '{}_segm.nii.gz'.format(sj))
if not os.path.exists(pfi_segm):
pfi_segm = jph(pfo_sj_segm, 'automatic',
'{}_{}.nii.gz'.format(sj, segm_suffix))
cmd = 'itksnap -g {} -o '.format(
jph(pfo_sj_mod, '{}_T1.nii.gz'.format(sj)))
for m in ['FA', 'MD', 'V1', 'S0']:
cmd += ' {} '.format(jph(pfo_sj_mod, '{}_{}.nii.gz'.format(sj, m)))
cmd += ' -s {} '.format(pfi_segm)
cmd += ' -l {}'.format(pfi_labels_descriptor)
os.system(cmd)
if in_atlas and check_dice_if_in_atlas:
pfi_segm_strx = jph(root_subject, 'stereotaxic', 'segm',
'{}_segm.nii.gz'.format(sj))
pfi_segm_from_atlas = jph(pfo_atlas, sj, 'segm',
'{}_segm.nii.gz'.format(sj))
if not os.path.exists(pfi_segm_strx):
print('\n\n Not existing {}!!'.format(pfi_segm_strx))
if not os.path.exists(pfi_segm_from_atlas):
print('\n\n Not existing {}!!'.format(pfi_segm_from_atlas))
nis_app = nis.App()
glob_dc = nis_app.measure.global_dist(
pfi_segm_strx,
pfi_segm_from_atlas,
global_metrics=(global_dice_score, ))
print(
'Subject {} in atlas, has a segmentation aligned with the ground truth. Dice as measure of overlap: '
)
print(glob_dc)
if glob_dc[0] < 0.95:
print('WARNING!!! Possible bugs!')
else:
raise IOError(
'Input variable - corrdinates - can be only original or stereotaxic. Had {}'
.format(coordinates))
def denoise_mif_for_subject(sj, controller):
pfi_DWI = jph(root_intermediate, '{}_DWI_slope_corrected_to_std.nii.gz'.format(sj))
pfi_brain_mask = jph(root_MASKs, '{}_brain.nii.gz'.format(sj))
assert os.path.exists(pfi_DWI)
assert os.path.exists(pfi_brain_mask)
if controller['Denoise']:
pfi_DWI_denoised = jph(root_DWIs_corrected, '{}_DWI.nii.gz'.format(sj))
pfi_DWI_noise = jph(root_intermediate, '{}_noise.nii.gz'.format(sj))
cmd = 'dwidenoise {} {} -noise {} -mask {}'.format(
pfi_DWI, pfi_DWI_denoised, pfi_DWI_noise, pfi_brain_mask)
print_and_run(cmd)
if controller['Get_differences']:
pfi_DWI_denoised = jph(root_DWIs_corrected, '{}_DWI.nii.gz'.format(sj))
pfi_DWI_noise = jph(root_intermediate, '{}_noise.nii.gz'.format(sj))
assert os.path.exists(pfi_DWI_denoised)
assert os.path.exists(pfi_DWI_noise)
pfi_residual = jph(root_intermediate, '{}_residual.nii.gz'.format(sj))
cmd = 'mrcalc {} {} -subtract {}'.format(pfi_DWI, pfi_DWI_denoised, pfi_residual)
print_and_run(cmd)
if controller['Quality_control']:
pfi_residual = jph(root_intermediate, '{}_residual.nii.gz'.format(sj))
assert os.path.exists(pfi_residual)
cmd = 'mrview {}'.format(pfi_residual)
print_and_run(cmd)
if controller['Eddy_correct']:
print('- eddy current {}'.format(sj))
pfi_DWI_denoised = jph(root_DWIs_corrected, '{}_DWI.nii.gz'.format(sj))
assert os.path.exists(pfi_DWI_denoised)
pfi_DWI_denoised_eddy = jph(root_DWIs_corrected, '{}_DWI_eddy.nii.gz'.format(sj))
cmd = 'eddy_correct {0} {1} 0 '.format(pfi_DWI_denoised, pfi_DWI_denoised_eddy)
print_and_run(cmd)
if controller['Quality_control_Eddy']:
pfi_DWI_denoised = jph(root_DWIs_corrected, '{}_DWI.nii.gz'.format(sj))
pfi_DWI_denoised_eddy = jph(root_DWIs_corrected, '{}_DWI_eddy.nii.gz'.format(sj))
assert os.path.exists(pfi_DWI_denoised), pfi_DWI_denoised
assert os.path.exists(pfi_DWI_denoised_eddy), pfi_DWI_denoised_eddy
cmd = 'mrview -load {0} -load {1}'.format(pfi_DWI_denoised, pfi_DWI_denoised_eddy)
print_and_run(cmd)
if controller['Create_multi_timepoints_mask']:
im_dwi = nib.load(pfi_DWI)
pfi_brain_mask_multi_timepoint = jph(root_tmp, '{}_brain_multi_timepoints.nii.gz'.format(sj))
nis_app = nis.App()
nis_app.manipulate_shape.extend_slice_new_dimension(pfi_brain_mask, pfi_output=pfi_brain_mask_multi_timepoint,
new_axis=3, num_slices=im_dwi.shape[-1])
del im_dwi, nis_app
if controller['Grafting_denoised']:
print('- grafting')
pfi_DWI_denoised = jph(root_DWIs_corrected, '{}_DWI.nii.gz'.format(sj))
pfi_residual = jph(root_intermediate, '{}_residual.nii.gz'.format(sj))
pfi_brain_mask_multi_timepoint = jph(root_tmp, '{}_brain_multi_timepoints.nii.gz'.format(sj))
assert os.path.exists(pfi_DWI_denoised)
assert os.path.exists(pfi_residual)
assert os.path.exists(pfi_brain_mask_multi_timepoint)
pfi_DWI_denoised_grafted = jph(root_DWIs_corrected, '{}_DWIg.nii.gz'.format(sj))
nis_app = nis.App()
nis_app.manipulate_intensities.get_grafting(pfi_residual, pfi_DWI_denoised, pfi_DWI_denoised_grafted,
pfi_brain_mask_multi_timepoint)
if controller['Grafting_denoised_Eddy']:
print('- grafting eddy')
pfi_DWI_denoised_eddy = jph(root_DWIs_corrected, '{}_DWI_eddy.nii.gz'.format(sj))
pfi_residual = jph(root_intermediate, '{}_residual.nii.gz'.format(sj))
pfi_brain_mask_multi_timepoint = jph(root_tmp, '{}_brain_multi_timepoints.nii.gz'.format(sj))
assert os.path.exists(pfi_DWI_denoised_eddy)
assert os.path.exists(pfi_residual)
assert os.path.exists(pfi_brain_mask_multi_timepoint)
pfi_DWI_denoised_grafted_eddy = jph(root_DWIs_corrected, '{}_DWIg_eddy.nii.gz'.format(sj))
nis_app = nis.App()
nis_app.manipulate_intensities.get_grafting(pfi_residual, pfi_DWI_denoised_eddy, pfi_DWI_denoised_grafted_eddy,
pfi_brain_mask_multi_timepoint)
def run_separate_brain_regions(controller):
# --- loop over subjects id ----
for sj in path_manager.atlas_subjects:
pfo_elaborations = jph(path_manager.pfo_atlas_validation_leave_one_out,
sj, 'segm', 'elaborations')
os.system('mkdir -p {}'.format(pfo_elaborations))
pfi_segm_manual = jph(path_manager.pfo_atlas_validation_leave_one_out,
sj, 'segm', '{}_segm.nii.gz'.format(sj))
assert os.path.exists(pfi_segm_manual), pfi_segm_manual
if controller['verbose']:
print '\n\n==================='
print 'Grouping segmentation according to given subdivision {}'.format(
sj)
print '===================\n'
# -------------- get the selected nomenclature labels correspondence -----------
nomenclature_old_labels = []
nomenclature_new_labels = []
if controller['Nomenclature'] == 'anatomical':
nomenclature = nomenclature_anatomical
elif controller['Nomenclature'] == 'taxonomical':
nomenclature = nomenclature_taxonomical
for k in nomenclature.keys():
nomenclature_old_labels += nomenclature[k][1]
nomenclature_new_labels += [k] * len(nomenclature[k][1])
# -------------- create ground segmentation divided by selected nomenclature --------------
if controller['Divide_manual_segm']:
pfi_segm_manual_divided_nomenclature = jph(
pfo_elaborations,
sj + '_segm_{}.nii.gz'.format(controller['Nomenclature']))
if controller['verbose']:
print '\n==================='
print '\n\nDivide_manual_segm nomenclature {}, subject {}'.format(
controller['Nomenclature'], sj)
print 'From {0} to {1}'.format(
pfi_segm_manual, pfi_segm_manual_divided_nomenclature)
nis_app = nis.App()
nis_app.manipulate_labels.relabel(
pfi_segm_manual,
pfi_segm_manual_divided_nomenclature,
list_old_labels=nomenclature_old_labels,
list_new_labels=nomenclature_new_labels)
# -------------- create automatic segmentations divided Taxonomical --------------
if controller['Divide_automatic_segm']:
for segm_suffix in param.segm_suffix:
name_segm = '{0}_{1}_{2}'.format(sj, segm_suffix,
param.segm_tags)
pfi_segm_automatic = jph(
path_manager.pfo_atlas_validation_leave_one_out, sj,
'segm', 'automatic', '{}.nii.gz'.format(name_segm))
assert os.path.exists(pfi_segm_automatic), pfi_segm_automatic
pfi_segm_automatic_divided_by_nomenclature = jph(
pfo_elaborations,
'{}_{}.nii.gz'.format(name_segm,
controller['Nomenclature']))
if controller['verbose']:
print('\n===================')
print(
'\nDivide_automatic_segm nomenclature {}, subject {}'.
format(controller['Nomenclature'], sj))
print 'From {0} to {1}'.format(
pfi_segm_automatic,
pfi_segm_automatic_divided_by_nomenclature)
nis_app = nis.App()
nis_app.manipulate_labels.relabel(
pfi_segm_automatic,
pfi_segm_automatic_divided_by_nomenclature,
list_old_labels=nomenclature_old_labels,
list_new_labels=nomenclature_new_labels)
def process_T1_per_subject(sj, steps):
print('\nProcessing T1 {} started.\n'.format(sj))
if sj not in list_all_subjects(pfo_subjects_parameters):
raise IOError('Subject parameters not known. Subject {}'.format(sj))
sj_parameters = pickle.load(open(jph(pfo_subjects_parameters, sj), 'r'))
study = sj_parameters['study']
category = sj_parameters['category']
options_T1 = sj_parameters['options_T1']
suffix_T1_architecture = sj_parameters['names_architecture'][
'T1'] # default is 3D
pfo_input_sj_3D = jph(root_study_rabbits, '02_nifti', study, category, sj,
sj + '_' + suffix_T1_architecture)
pfo_output_sj = jph(root_study_rabbits, 'A_data', study, category, sj)
# select appropriate atlas:
if study == 'ACS' or study == 'PTB' or study == 'TestStudy':
pfo_atlas = root_atlas
elif study == 'W8':
pfo_atlas = root_atlas_W8
else:
raise IOError('Parameter **study** not included in the current logic.')
# input sanity check:
if not os.path.exists(pfo_input_sj_3D):
raise IOError('Input folder nifti data T1 does not exist. {}'.format(
pfo_input_sj_3D))
# -- Generate intermediate and output folder
pfo_mod = jph(pfo_output_sj, 'mod')
pfo_segm = jph(pfo_output_sj, 'segm')
pfo_mask = jph(pfo_output_sj, 'masks')
pfo_tmp = jph(pfo_output_sj, 'z_tmp', 'z_T1' + suffix_T1_architecture)
print_and_run('mkdir -p {}'.format(pfo_output_sj))
print_and_run('mkdir -p {}'.format(pfo_mod))
print_and_run('mkdir -p {}'.format(pfo_segm))
print_and_run('mkdir -p {}'.format(pfo_mask))
print_and_run('mkdir -p {}'.format(pfo_tmp))
reference_subject = options_T1['pivot']
# If the element is in template retrieve the original roi mask and reg mask
if sj_parameters['in_atlas']:
reference_subject = sj
# turn off all the not useful stuff:
options_T1['roi_mask'] = ''
steps['adjust_mask'] = False
steps['create_lesion_maks'] = False
if steps['orient_to_standard']:
print('- orient to standard {}'.format(sj))
pfi_input_original = jph(pfo_input_sj_3D, sj + '_3D.nii.gz')
assert check_path_validity(pfi_input_original)
pfi_std = jph(pfo_tmp, sj + '_to_std.nii.gz')
orient2std(pfi_input_original, pfi_std)
del pfi_input_original, pfi_std
if steps['create_roi_masks']:
pfi_std = jph(pfo_tmp, '{}_to_std.nii.gz'.format(sj))
assert check_path_validity(pfi_std)
# --- Get the reference masks from the stereotaxic orientation ---
# reference subject:
pfi_sj_ref_coord_system = jph(pfo_atlas, reference_subject, 'mod',
'{}_T1.nii.gz'.format(reference_subject))
# original mask
pfi_reference_roi_mask = jph(
pfo_atlas, reference_subject, 'masks',
'{}_roi_mask.nii.gz'.format(reference_subject))
pfi_reference_reg_mask = jph(
pfo_atlas, reference_subject, 'masks',
'{}_reg_mask.nii.gz'.format(reference_subject))
assert check_path_validity(pfi_sj_ref_coord_system)
assert check_path_validity(pfi_reference_roi_mask)
assert check_path_validity(pfi_reference_reg_mask)
# --- Get the angle difference from histological (template) to bicommissural (data) and orient header ---
if isinstance(sj_parameters['angles'][0], list):
angles = sj_parameters['angles'][0]
else:
angles = sj_parameters['angles']
angle_parameter = angles[1]
print('Get initial roi mask using the pivot.')
pfi_sj_ref_coord_system_hd_oriented = jph(
pfo_tmp, 'reference_for_mask_registration.nii.gz')
pfi_reference_roi_mask_hd_oriented = jph(
pfo_tmp, 'reference_for_mask_roi_mask.nii.gz')
pfi_reference_reg_mask_hd_oriented = jph(
pfo_tmp, 'reference_for_mask_reg_mask.nii.gz')
nis_app = nis.App()
nis_app.header.apply_small_rotation(
pfi_sj_ref_coord_system,
pfi_sj_ref_coord_system_hd_oriented,
angle=angle_parameter,
principal_axis='pitch')
nis_app.header.apply_small_rotation(pfi_reference_roi_mask,
pfi_reference_roi_mask_hd_oriented,
angle=angle_parameter,
principal_axis='pitch')
nis_app.header.apply_small_rotation(pfi_reference_reg_mask,
pfi_reference_reg_mask_hd_oriented,
angle=angle_parameter,
principal_axis='pitch')
# set translational part to zero
nis_app.header.modify_translational_part(
pfi_sj_ref_coord_system_hd_oriented,
pfi_sj_ref_coord_system_hd_oriented, np.array([0, 0, 0]))
nis_app.header.modify_translational_part(
pfi_reference_roi_mask_hd_oriented,
pfi_reference_roi_mask_hd_oriented, np.array([0, 0, 0]))
nis_app.header.modify_translational_part(
pfi_reference_reg_mask_hd_oriented,
pfi_reference_reg_mask_hd_oriented, np.array([0, 0, 0]))
assert check_path_validity(pfi_sj_ref_coord_system_hd_oriented)
assert check_path_validity(pfi_reference_roi_mask_hd_oriented)
pfi_affine_transformation_ref_on_subject = jph(
pfo_tmp, 'aff_ref_on_' + sj + '.txt')
pfi_3d_warped_ref_on_subject = jph(pfo_tmp,
'warp_ref_on_' + sj + '.nii.gz')
cmd = 'reg_aladin -ref {0} -flo {1} -fmask {2} -aff {3} -res {4} -omp {5} -speeeeed '.format( # -rigOnly
pfi_std, pfi_sj_ref_coord_system_hd_oriented,
pfi_reference_roi_mask_hd_oriented,
pfi_affine_transformation_ref_on_subject,
pfi_3d_warped_ref_on_subject, num_cores_run)
print_and_run(cmd)
print('- propagate affine registration T1 to roi masks {}'.format(sj))
pfi_roi_mask_not_adjusted = jph(
pfo_tmp, sj + '_T1_roi_mask_not_adjusted.nii.gz')
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_std, pfi_reference_roi_mask_hd_oriented,
pfi_affine_transformation_ref_on_subject,
pfi_roi_mask_not_adjusted)
print_and_run(cmd)
print('- propagate affine registration T1 to reg masks {}'.format(sj))
pfi_reg_mask_not_adjusted = jph(
pfo_tmp, sj + '_T1_reg_mask_not_adjusted.nii.gz')
cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format(
pfi_std, pfi_reference_reg_mask_hd_oriented,
pfi_affine_transformation_ref_on_subject,
pfi_reg_mask_not_adjusted)
print_and_run(cmd)
if sj_parameters['in_atlas']:
# if sj is in multi-atlas just copy the masks as they are in the destination, and then manipulate
pfi_roi_mask = jph(pfo_mask, '{}_T1_roi_mask.nii.gz'.format(sj))
# pfi_reg_mask = jph(pfo_mask, '{}_T1_reg_mask.nii.gz'.format(sj))
cmd = 'cp {} {}'.format(pfi_roi_mask_not_adjusted, pfi_roi_mask)
print_and_run(cmd)
# cmd = 'cp {} {}'.format(pfi_reg_mask_not_adjusted, pfi_reg_mask)
# print_and_run(cmd)
del pfi_std, pfi_sj_ref_coord_system, pfi_reference_roi_mask, \
angle_parameter, angles, pfi_sj_ref_coord_system_hd_oriented, pfi_reference_roi_mask_hd_oriented, \
pfi_affine_transformation_ref_on_subject, pfi_3d_warped_ref_on_subject, cmd
if steps['adjust_mask']:
print('- adjust mask {}'.format(sj))
# Input:
pfi_roi_mask_not_adjusted = jph(
pfo_tmp, sj + '_T1_roi_mask_not_adjusted.nii.gz')
assert os.path.exists(
pfi_roi_mask_not_adjusted), pfi_roi_mask_not_adjusted
# Parameters:
dilation_param = options_T1['mask_dilation']
# Main output:
pfi_roi_mask = jph(pfo_mask, '{}_T1_roi_mask.nii.gz'.format(sj))
if dilation_param < 0: # if negative, erode.
cmd = 'seg_maths {0} -ero {1} {2}'.format(
pfi_roi_mask_not_adjusted, -1 * dilation_param, pfi_roi_mask)
elif dilation_param > 0:
cmd = 'seg_maths {0} -dil {1} {2}'.format(
pfi_roi_mask_not_adjusted, dilation_param, pfi_roi_mask)
else:
cmd = 'cp {} {}'.format(pfi_roi_mask_not_adjusted, pfi_roi_mask)
del dilation_param, pfi_roi_mask_not_adjusted
print_and_run(cmd)
del pfi_roi_mask, cmd
if steps['cut_masks']:
if options_T1['crop_roi']:
print('- cut masks {}'.format(sj))
pfi_std = jph(pfo_tmp, sj + '_to_std.nii.gz')
pfi_roi_mask = jph(pfo_mask, sj + '_T1_roi_mask.nii.gz')
assert check_path_validity(pfi_std)
assert check_path_validity(pfi_roi_mask)
pfi_3d_cropped_roi = jph(pfo_tmp, sj + '_cropped.nii.gz')
cmd = 'seg_maths {0} -mul {1} {2}'.format(pfi_std, pfi_roi_mask,
pfi_3d_cropped_roi)
print '\nCutting newly-created ciccione mask on the subject: subject {0}.\n'.format(
sj)
print_and_run(cmd)
del pfi_std, pfi_roi_mask, pfi_3d_cropped_roi, cmd
else:
pfi_std = jph(pfo_tmp, sj + '_to_std.nii.gz')
assert check_path_validity(pfi_std)
pfi_3d_cropped_roi = jph(pfo_tmp, sj + '_cropped.nii.gz')
cmd = 'cp {0} {1}'.format(pfi_std, pfi_3d_cropped_roi)
print_and_run(cmd)
if steps['step_bfc']:
print('- step bfc {}'.format(sj))
pfi_3d_cropped_roi = jph(pfo_tmp, sj + '_cropped.nii.gz')
assert check_path_validity(pfi_3d_cropped_roi)
pfi_3d_bias_field_corrected = jph(pfo_tmp, sj + '_bfc.nii.gz')
bfc_param = sj_parameters['bias_field_parameters']
pfi_roi_mask = jph(pfo_mask, sj + '_T1_roi_mask.nii.gz')
bias_field_correction(pfi_3d_cropped_roi,
pfi_3d_bias_field_corrected,
pfi_mask=pfi_roi_mask,
prefix='',
convergenceThreshold=bfc_param[0],
maximumNumberOfIterations=bfc_param[1],
biasFieldFullWidthAtHalfMaximum=bfc_param[2],
wienerFilterNoise=bfc_param[3],
numberOfHistogramBins=bfc_param[4],
numberOfControlPoints=bfc_param[5],
splineOrder=bfc_param[6],
print_only=False)
del pfi_3d_cropped_roi, pfi_3d_bias_field_corrected, bfc_param, pfi_roi_mask
if steps['create_lesion_maks']:
print('Extract lesion mask: Subject {}'.format(sj))
# output:
pfi_lesion_mask = jph(pfo_mask, sj + '_T1_lesion_mask.nii.gz')
if options_T1['lesion_mask_method'] == 0:
percentile = sj_parameters['options_T1']['window_percentile']
median_filter = sj_parameters['options_T1']['median_filter']
print(
'remove percentiles, values added manually: percentile {}, median filter {}'
.format(percentile, median_filter))
pfi_3d_bias_field_corrected = jph(pfo_tmp, sj + '_bfc.nii.gz')
pfi_roi_mask = jph(pfo_mask, sj + '_T1_roi_mask.nii.gz')
assert check_path_validity(pfi_3d_bias_field_corrected)
assert check_path_validity(pfi_roi_mask)
percentile_lesion_mask_extractor(
im_input_path=pfi_3d_bias_field_corrected,
im_output_path=pfi_lesion_mask,
im_mask_foreground_path=pfi_roi_mask,
percentiles=percentile,
safety_on=False,
median_filter=median_filter,
pfo_tmp=pfo_tmp)
elif options_T1['lesion_mask_method'] > 0:
K = options_T1['lesion_mask_method']
print(
'remove the first (not background) and the last gaussians after MoG fitting, with K = {}.'
.format(K))
pfi_3d_bias_field_corrected = jph(pfo_tmp, sj + '_bfc.nii.gz')
pfi_roi_mask = jph(pfo_mask, sj + '_T1_roi_mask.nii.gz')
assert os.path.exists(pfi_3d_bias_field_corrected)
assert check_path_validity(pfi_roi_mask)
pfi_mog_segm = jph(pfo_tmp, '{}_mog_segm.nii.gz'.format(sj))
pfi_T1_bfc = nib.load(pfi_3d_bias_field_corrected)
pfi_roi_mask = nib.load(pfi_roi_mask)
im_T1_bfc = nib.load(pfi_T1_bfc)
im_roi_mask = nib.load(pfi_T1_bfc)
c_array, p_array = MoG_array(im_T1_bfc.get_data(),
K=K,
pre_process_median_filter=True,
mask_array=im_roi_mask.get_data(),
pre_process_only_interquartile=True)
c = set_new_data(im_T1_bfc, c_array)
p = set_new_data(im_T1_bfc, p_array)
nib.save(c, '/Users/sebastiano/Desktop/zzz.nii.gz')
old_labels = list(range(K)) # [0, 1, 2, 3, 4]
new_labels = [
1,
] * len(old_labels)
new_labels[0], new_labels[1], new_labels[-1] = 0, 0, 0
im_crisp = set_new_data(c,
np.copy(
relabeller(c.get_data(), old_labels,
new_labels)),
new_dtype=np.uint8)
nib.save(im_crisp, pfi_mog_segm)
# final tuning:
cmd0 = 'seg_maths {0} -ero 3 {0}'.format(pfi_mog_segm,
pfi_mog_segm)
cmd1 = 'seg_maths {0} -fill {0}'.format(pfi_mog_segm)
cmd2 = 'seg_maths {0} -dil 3 {0}'.format(pfi_mog_segm)
cmd3 = 'seg_maths {0} -fill {0}'.format(pfi_mog_segm)
print_and_run(cmd0)
print_and_run(cmd1)
print_and_run(cmd2)
print_and_run(cmd3)
# pfi_lesion_mask IS pfi_roi_mask - pfi_mog_segm
pfi_mog_segm_and_roi = jph(pfo_tmp, '{}_T1_MoGsegm_and_roi.nii.gz')
cmd11 = 'seg_maths {0} -mul {1} {2}'.format(
pfi_roi_mask, pfi_mog_segm, pfi_mog_segm_and_roi)
print_and_run(cmd11)
cmd22 = 'seg_maths {0} -sub {1} {2}'.format(
pfi_roi_mask, pfi_mog_segm_and_roi, pfi_lesion_mask)
print_and_run(cmd22)
if steps['create_reg_mask']:
if sj_parameters['in_atlas']:
print('Get registration mask: Subject {} is in atlas'.format(sj))
pfi_reg_mask_not_adjusted = jph(
pfo_tmp, '{}_T1_reg_mask_not_adjusted.nii.gz'.format(sj))
assert os.path.exists(pfi_reg_mask_not_adjusted), \
'Processing T1, subject {}. Run the step create_roi_mask first'.format(sj)
pfi_reg_mask = jph(pfo_mask, '{}_T1_reg_mask.nii.gz'.format(sj))
cmd = 'cp {} {}'.format(pfi_reg_mask_not_adjusted, pfi_reg_mask)
print_and_run(cmd)
else:
print('Create registration mask: Subject {}'.format(sj))
# output:
pfi_reg_mask = jph(pfo_mask, sj + '_T1_reg_mask.nii.gz')
# registration mask is defined as the difference between roi_mask and lesion_mask
pfi_roi_mask = jph(pfo_mask, sj + '_T1_roi_mask.nii.gz')
pfi_lesion_mask = jph(pfo_mask, sj + '_T1_lesion_mask.nii.gz')
assert os.path.exists(pfi_roi_mask), pfi_roi_mask
assert os.path.exists(pfi_lesion_mask), pfi_lesion_mask
pfi_roi_mask_and_lesion_mask = jph(
pfo_tmp, '{}_T1_ROI_and_LM.nii.gz'.format(sj))
cmd11 = 'seg_maths {0} -mul {1} {2}'.format(
pfi_roi_mask, pfi_lesion_mask, pfi_roi_mask_and_lesion_mask)
print_and_run(cmd11)
cmd22 = 'seg_maths {0} -sub {1} {2}'.format(
pfi_roi_mask, pfi_roi_mask_and_lesion_mask, pfi_reg_mask)
print_and_run(cmd22)
if steps['save_results']:
print('- save results {}'.format(sj))
pfi_3d_bias_field_corrected = jph(pfo_tmp, sj + '_bfc.nii.gz')
assert check_path_validity(pfi_3d_bias_field_corrected)
pfi_3d_final_destination = jph(pfo_mod, sj + '_T1.nii.gz')
cmd = 'cp {0} {1}'.format(pfi_3d_bias_field_corrected,
pfi_3d_final_destination)
print_and_run(cmd)
del pfi_3d_bias_field_corrected, pfi_3d_final_destination, cmd
