def fuser(sp): print('Apply the nifty-seg fusion method {}'.format(sp.target_pfo)) pfo_tmp = sp.scaffoldings_pfo assert os.path.exists(pfo_tmp) if sp.fuser_controller['Fuse']: print('- Fuse {} '.format(sp.target_name)) # file-names and file-paths of the resulting stacks: fin_stack_segm = '{0}_stack_warp_segm_{1}.nii.gz'.format( sp.target_name, sp.parameters_tag) fin_stack_warp = '{0}_stack_warp_mod_{1}.nii.gz'.format( sp.target_name, sp.parameters_tag) pfi_4d_stack_warp_segm = jph(pfo_tmp, fin_stack_segm) pfi_4d_stack_warp_mod = jph(pfo_tmp, fin_stack_warp) assert os.path.exists(pfi_4d_stack_warp_segm) assert os.path.exists(pfi_4d_stack_warp_mod) # ------------ MV ------------ pfi_output_MV = jph( pfo_tmp, 'result_{0}_MV_{1}.nii.gz'.format(sp.target_name, sp.parameters_tag)) if 'MV' in sp.fuser_options['Fusion_methods']: cmd_mv = 'seg_LabFusion -in {0} -out {1} -MV'.format( pfi_4d_stack_warp_segm, pfi_output_MV) print_and_run(cmd_mv, short_path_output=False) assert check_path_validity(pfi_output_MV, timeout=5000, interval=5) # -------- STAPLE ------------ if 'STAPLE' in sp.fuser_options['Fusion_methods']: for key_staple in sp.fuser_options['STAPLE_params'].keys(): pfi_output_STAPLE = jph( pfo_tmp, 'result_{0}_STAPLE_{1}_{2}.nii.gz'.format( sp.target_name, key_staple, sp.parameters_tag)) beta = sp.fuser_options['STAPLE_params'][key_staple] if beta is None: cmd_staple = 'seg_LabFusion -in {0} -STAPLE -out {1}'.format( pfi_4d_stack_warp_segm, pfi_output_STAPLE) else: cmd_staple = 'seg_LabFusion -in {0} -STAPLE -out {1} -MRF_beta {2}'.format( pfi_4d_stack_warp_segm, pfi_output_STAPLE, beta) print_and_run(cmd_staple, short_path_output=False) assert check_path_validity(pfi_output_STAPLE, timeout=5000, interval=5) # ------------ STEPS ------------ if 'STEPS' in sp.fuser_options['Fusion_methods']: # select the path to target: if len(sp.propagation_options['N_rigid_modalities']) > 0: if len(sp.propagation_options['N_rigid_mod_diff_bfc']) > 0: pfi_target = jph( pfo_tmp, 'target_nrigid_{}_mod_BFC.nii.gz'.format( sp.target_name)) else: pfi_target = jph( pfo_tmp, 'target_nrigid_{}_mod.nii.gz'.format(sp.target_name)) else: pfi_target = sp.propagation_options[ 'N_rigid_modalities'] = jph( pfo_tmp, 'target_aff_{}_mod.nii.gz'.format(sp.target_name)) assert os.path.exists(pfi_target) for key_steps in sp.fuser_options['STEPS_params'].keys(): pfi_output_STEPS = jph( pfo_tmp, 'result_{0}_STEPS_{1}_{2}.nii.gz'.format( sp.target_name, key_steps, sp.parameters_tag)) k, n, beta = sp.fuser_options['STEPS_params'][key_steps] if beta is None: cmd_steps = 'seg_LabFusion -in {0} -out {1} -STEPS {2} {3} {4} {5} -prop_update'.format( pfi_4d_stack_warp_segm, pfi_output_STEPS, k, n, pfi_target, pfi_4d_stack_warp_mod) else: cmd_steps = 'seg_LabFusion -in {0} -out {1} -STEPS {2} {3} {4} {5} -MRF_beta {5} -prop_update '.\ format(pfi_4d_stack_warp_segm, pfi_output_STEPS, k, n, pfi_target, pfi_4d_stack_warp_mod, str(beta)) print_and_run(cmd_steps, short_path_output=False) assert check_path_validity(pfi_output_STEPS, timeout=1000, interval=10) if sp.fuser_controller['Save_results']: print('- save result for target subject {}'.format(sp.target_name)) pfo_automatic_segmentations_results = jph( sp.target_pfo, sp.arch_segmentations_name_folder, sp.arch_automatic_segmentations_name_folder) cmd0 = 'mkdir -p {}'.format( jph(sp.target_pfo, sp.arch_segmentations_name_folder)) cmd1 = 'mkdir -p {}'.format(pfo_automatic_segmentations_results) print_and_run(cmd0) print_and_run(cmd1) for filename in os.listdir(pfo_tmp): if filename.startswith('result_'): cmd = 'cp {0} {1}'.format( jph(pfo_tmp, filename), jph(pfo_automatic_segmentations_results, filename.replace('result_', ''))) print_and_run(cmd)
def process_MSME_per_subject(sj, controller): print('\nProcessing MSME, subject {} started.\n'.format(sj)) if sj not in list_all_subjects(pfo_subjects_parameters): raise IOError( 'Subject {} does not have a subject parameter ready.'.format(sj)) sj_parameters = pickle.load(open(jph(pfo_subjects_parameters, sj), 'r')) study = sj_parameters['study'] category = sj_parameters['category'] pfo_input_sj = jph(root_study_rabbits, '02_nifti', study, category, sj) pfo_output_sj = jph(root_study_rabbits, 'A_data', study, category, sj) if not os.path.exists(pfo_input_sj): raise IOError('Input folder Subject does not exist.') # -- 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_MSME') 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)) pfi_msme_nifti = jph(pfo_input_sj, sj + '_MSME', sj + '_MSME.nii.gz') if not os.path.exists(pfi_msme_nifti): print( 'MSME modality not given in the input folder after Nifti conversion. Bypass methods involving MSME' ) return if controller['squeeze']: print('- Processing MSME: squeeze {}'.format(sj)) assert os.path.exists(pfi_msme_nifti) pfi_msme = jph(pfo_tmp, sj + '_MSME.nii.gz') squeeze_image_from_path(pfi_msme_nifti, pfi_msme, copy_anyway=True) if controller['orient_to_standard']: print('- Processing MSME: orient to standard {}'.format(sj)) pfi_msme = jph(pfo_tmp, sj + '_MSME.nii.gz') assert check_path_validity(pfi_msme) cmd = 'fslreorient2std {0} {0}'.format(pfi_msme) print_and_run(cmd) set_translational_part_to_zero(pfi_msme, pfi_msme) if controller['extract_first_timepoint']: print('- Processing MSME: extract first layers {}'.format(sj)) pfi_msme = jph(pfo_tmp, sj + '_MSME.nii.gz') assert os.path.exists(pfi_msme) pfi_msme_original_first_layer = jph(pfo_tmp, sj + '_MSME_tp0.nii.gz') cmd0 = 'seg_maths {0} -tp 0 {1}'.format(pfi_msme, pfi_msme_original_first_layer) print_and_run(cmd0) if controller['register_tp0_to_S0']: print('- Processing MSME: create ficticious original MSME mask {}'. format(sj)) pfi_msme_original_first_layer = jph(pfo_tmp, sj + '_MSME_tp0.nii.gz') print('- Processing MSME: register tp0 to S0 {}'.format(sj)) pfi_s0 = jph(pfo_mod, sj + '_S0.nii.gz') pfi_s0_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz') pfi_msme_tp0 = jph(pfo_tmp, sj + '_MSME_tp0.nii.gz') assert os.path.exists(pfi_s0) assert os.path.exists(pfi_s0_mask) assert check_path_validity(pfi_msme_tp0) pfi_transf_msme_on_s0 = jph(pfo_tmp, sj + '_msme_on_S0_rigid.txt') pfi_warped_msme_on_s0 = jph(pfo_tmp, sj + '_MSME_tp0_up.nii.gz') cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -aff {3} -res {4} -omp {5} -rigOnly'.format( pfi_s0, pfi_s0_mask, pfi_msme_tp0, pfi_transf_msme_on_s0, pfi_warped_msme_on_s0, num_cores_run) print_and_run(cmd) if controller['register_msme_to_S0']: pfi_s0 = jph(pfo_mod, sj + '_S0.nii.gz') pfi_msme = jph(pfo_tmp, sj + '_MSME.nii.gz') pfi_transf_msme_on_s0 = jph(pfo_tmp, sj + '_msme_on_S0_rigid.txt') assert os.path.exists(pfi_s0) assert os.path.exists(pfi_msme) assert check_path_validity(pfi_transf_msme_on_s0) pfi_msme_upsampled = jph(pfo_tmp, sj + '_MSMEinS0.nii.gz') cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 1'.format( pfi_s0, pfi_msme, pfi_transf_msme_on_s0, pfi_msme_upsampled) print_and_run(cmd) if controller['get_mask_for_original_msme']: print('- Processing MSME: get mask for original msme:') # Start from the S0 mask (this will be saved as an extra mask as MSMEinS0 mask). pfi_s0_mask = jph(pfo_mask, '{}_S0_roi_mask.nii.gz'.format(sj)) pfi_warped_msme_on_s0 = jph(pfo_tmp, sj + '_MSME_tp0_up.nii.gz') assert os.path.exists(pfi_s0_mask), pfi_s0_mask assert os.path.exists(pfi_warped_msme_on_s0), pfi_warped_msme_on_s0 pfi_msme_up_lesion_mask = jph( pfo_tmp, '{}_msme_up_lesions_mask.nii.gz'.format(sj)) pfi_msme_up_reg_mask = jph(pfo_tmp, '{}_msme_up_reg_mask.nii.gz'.format(sj)) # Crop it properly to the MSMEinS0. percentile_lesion_mask_extractor( im_input_path=pfi_warped_msme_on_s0, im_output_path=pfi_msme_up_lesion_mask, im_mask_foreground_path=pfi_s0_mask, percentiles=(10, 98), safety_on=False) cmd = 'seg_maths {0} -sub {1} {2}'.format(pfi_s0_mask, pfi_msme_up_lesion_mask, pfi_msme_up_reg_mask) print_and_run(cmd) # Register MSMEinS0 with an approximative new mask over the original with no mask. pfi_msme_original_first_layer = jph(pfo_tmp, '{}_MSME_tp0.nii.gz'.format(sj)) pfi_msme_original_pre_mask = jph( pfo_tmp, '{}_MSME_tp0_pre_mask.nii.gz'.format(sj)) percentile_lesion_mask_extractor_only_from_image_path( pfi_msme_original_first_layer, pfi_msme_original_pre_mask, percentile_range=(30, 95)) # TODO, personal attribute? pfi_warped_msme_on_s0_back_on_msme = jph( pfo_tmp, '{}_warped_msme_on_s0_back_on_msme.nii.gz'.format(sj)) pfi_affine_msme_on_s0_back_on_msme = jph( pfo_tmp, '{}_affine_msme_on_s0_back_on_msme.txt'.format(sj)) cmd = 'reg_aladin -ref {0} -rmask {1} -flo {2} -fmask {3} -res {4} -aff {5} -omp {6} -rigOnly'.format( pfi_msme_original_first_layer, pfi_msme_original_pre_mask, pfi_warped_msme_on_s0, pfi_s0_mask, pfi_warped_msme_on_s0_back_on_msme, pfi_affine_msme_on_s0_back_on_msme, num_cores_run) print_and_run(cmd) # Apply transformation to the S0 roi_mask and to S0 reg_mask for ma in ['roi_mask', 'reg_mask']: S0_mask = jph(pfo_mask, '{0}_S0_{1}.nii.gz'.format(sj, ma)) assert os.path.exists(S0_mask) MSME_mask = jph(pfo_mask, '{0}_MSME_{1}.nii.gz'.format(sj, ma)) cmd = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format( pfi_msme_original_first_layer, S0_mask, pfi_affine_msme_on_s0_back_on_msme, MSME_mask) print_and_run(cmd) # print('back-propagate the S0 mask on the MSME:') # pfi_aff = jph(pfo_tmp, sj + '_msme_on_S0_rigid.txt') # assert os.path.exists(pfi_aff) # # this very same transformation must be used to back propagate the segmentations! # pfi_inv_aff = jph(pfo_tmp, sj + '_S0_on_msmse_rigid.txt') # cmd0 = 'reg_transform -invAff {0} {1}'.format(pfi_aff, pfi_inv_aff) # print_and_run(cmd0) # pfi_S0_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz') # pfi_msme = jph(pfo_tmp, sj + '_MSME.nii.gz') # assert os.path.exists(pfi_S0_mask) # assert os.path.exists(pfi_msme) # pfi_mask_on_msme = jph(pfo_mask, sj + '_MSME_roi_mask.nii.gz') # cmd1 = 'reg_resample -ref {0} -flo {1} -trans {2} -res {3} -inter 0'.format( # pfi_msme, pfi_S0_mask, pfi_inv_aff, pfi_mask_on_msme) # print_and_run(cmd1) # print('Dilate:') # assert check_path_validity(pfi_mask_on_msme) # dil_factor = 0 # cmd0 = 'seg_maths {0} -dil {1} {2}'.format(pfi_mask_on_msme, dil_factor, pfi_mask_on_msme) # print_and_run(cmd0) if controller['bfc']: print('- get bfc correction each slice:') pfi_msme_original = jph(pfo_tmp, sj + '_MSME.nii.gz') assert check_path_validity(pfi_msme_original) print('-- un-pack slices') im = nib.load(pfi_msme_original) tps = im.shape[-1] for tp in range(tps): pfi_tp = jph(pfo_tmp, sj + '_MSME_tp{}.nii.gz'.format(tp)) cmd0 = 'seg_maths {0} -tp {1} {2}'.format(pfi_msme_original, tp, pfi_tp) print_and_run(cmd0) print('-- bias-field correct the first slice') # bfc_param = subject[sj][3] bfc_param = [0.001, (50, 50, 50, 50), 0.15, 0.01, 400, (4, 4, 4), 3] pfi_tp0 = jph(pfo_tmp, sj + '_MSME_tp0.nii.gz') pfi_tp0_bfc = jph(pfo_tmp, sj + '_MSME_tp0_bfc.nii.gz') pfi_mask_on_msme = jph(pfo_mask, sj + '_MSME_roi_mask.nii.gz') assert os.path.exists(pfi_mask_on_msme) bias_field_correction(pfi_tp0, pfi_tp0_bfc, pfi_mask=pfi_mask_on_msme, 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) print('-- get the bias field from the bfc corrected') bias_field = jph(pfo_tmp, sj + '_bfc.nii.gz') cmd0 = 'seg_maths {0} -div {1} {2}'.format(pfi_tp0_bfc, pfi_tp0, bias_field) cmd1 = 'seg_maths {0} -removenan {0}'.format(bias_field) print_and_run(cmd0) print_and_run(cmd1) assert check_path_validity(bias_field) print('-- correct all the remaining slices') for tp in range(1, tps): pfi_tp = jph(pfo_tmp, sj + '_MSME_tp{}.nii.gz'.format(tp)) pfi_tp_bfc = jph(pfo_tmp, sj + '_MSME_tp{}_bfc.nii.gz'.format(tp)) cmd0 = 'seg_maths {0} -mul {1} {2}'.format(pfi_tp, bias_field, pfi_tp_bfc) print_and_run(cmd0) check_path_validity(pfi_tp_bfc) print('-- pack together all the images in a stack') cmd = 'seg_maths {0} -merge {1} {2} '.format(pfi_tp0_bfc, tps - 1, 4) for tp in range(1, tps): pfi_tp_bfc = jph(pfo_tmp, sj + '_MSME_tp{}_bfc.nii.gz'.format(tp)) cmd += pfi_tp_bfc + ' ' pfi_stack = jph(pfo_tmp, sj + '_MSME_BFC.nii.gz') cmd += pfi_stack print_and_run(cmd) if controller['bfc_up']: print('- get bfc correction each slice:') pfi_msme_upsampled = jph(pfo_tmp, sj + '_MSMEinS0.nii.gz') assert check_path_validity(pfi_msme_upsampled) print('-- un-pack slices') im = nib.load(pfi_msme_upsampled) tps = im.shape[-1] for tp in range(tps): pfi_up_tp = jph(pfo_tmp, sj + '_MSMEinS0_tp{}.nii.gz'.format(tp)) cmd0 = 'seg_maths {0} -tp {1} {2}'.format(pfi_msme_upsampled, tp, pfi_up_tp) print_and_run(cmd0) print('-- bias-field correct the first slice') # bfc_param = subject[sj][3] bfc_param = [0.001, (50, 50, 50, 50), 0.15, 0.01, 400, (4, 4, 4), 3] pfi_up_tp0 = jph(pfo_tmp, sj + '_MSMEinS0_tp0.nii.gz') pfi_up_tp0_bfc = jph(pfo_tmp, sj + '_MSMEinS0_tp0_BFC.nii.gz') pfi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz') bias_field_correction(pfi_up_tp0, pfi_up_tp0_bfc, pfi_mask=pfi_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) print('-- get the bias field from the bfc corrected') bias_field_up = jph(pfo_tmp, sj + '_bfc_up.nii.gz') cmd0 = 'seg_maths {0} -div {1} {2}'.format(pfi_up_tp0_bfc, pfi_up_tp0, bias_field_up) cmd1 = 'seg_maths {0} -removenan {0}'.format(bias_field_up) print_and_run(cmd0) print_and_run(cmd1) assert check_path_validity(bias_field_up) print('-- correct all the remaining slices') for tp in range(1, tps): pfi_up_tp = jph(pfo_tmp, sj + '_MSMEinS0_tp{}.nii.gz'.format(tp)) pfi_up_tp_bfc = jph(pfo_tmp, sj + '_MSMEinS0_tp{}_bfc.nii.gz'.format(tp)) cmd0 = 'seg_maths {0} -mul {1} {2}'.format(pfi_up_tp, bias_field_up, pfi_up_tp_bfc) print_and_run(cmd0) check_path_validity(pfi_up_tp_bfc) print('-- pack together all the images in a stack') cmd_merge = 'seg_maths {0} -merge {1} {2} '.format( pfi_up_tp0_bfc, tps - 1, 4) for tp in range(1, tps): pfi_up_tp_bfc = jph(pfo_tmp, sj + '_MSMEinS0_tp{}_bfc.nii.gz'.format(tp)) cmd_merge += pfi_up_tp_bfc + ' ' pfi_stack_up = jph(pfo_tmp, sj + '_MSMEinS0_BFC.nii.gz') cmd_merge += pfi_stack_up print_and_run(cmd_merge) if controller['save_results']: print( 'save results - save only the bias field corrected as they proved to have the same results.' ) pfi_msme_nifti = jph(pfo_tmp, sj + '_MSME.nii.gz') # original pfi_msme_bfc = jph(pfo_tmp, sj + '_MSME_BFC.nii.gz') # original bfc pfi_msme_up = jph(pfo_tmp, sj + '_MSMEinS0.nii.gz') # up pfi_msme_up_bfc = jph(pfo_tmp, sj + '_MSMEinS0_BFC.nii.gz') # up bfc assert check_path_validity(pfi_msme_nifti) assert check_path_validity(pfi_msme_bfc) assert check_path_validity(pfi_msme_up) assert check_path_validity(pfi_msme_up_bfc) # pfi_final = jph(pfo_mod, sj + '_MSME.nii.gz') pfi_final_bfc = jph(pfo_mod, sj + '_MSME.nii.gz') # pfi_final_up = jph(pfo_mod, sj + '_MSMEinS0.nii.gz') pfi_final_bfc_up = jph(pfo_mod, sj + '_MSMEinS0.nii.gz') # cmd0 = 'cp {0} {1}'.format(pfi_msme_nifti, pfi_final) # cmd2 = 'cp {0} {1}'.format(pfi_msme_up, pfi_final_up) cmd1 = 'cp {0} {1}'.format(pfi_msme_bfc, pfi_final_bfc) cmd3 = 'cp {0} {1}'.format(pfi_msme_up_bfc, pfi_final_bfc_up) # print_and_run(cmd0) # print_and_run(cmd2) print_and_run(cmd1) print_and_run(cmd3) if controller['save_results_tp0']: print('save results - timepoint zero, only the bfc') # pfi_msme_nifti = jph(pfo_tmp, sj + '_MSME.nii.gz') # original # pfi_msme_up = jph(pfo_tmp, sj + '_MSMEinS0.nii.gz') # up pfi_msme_bfc = jph(pfo_tmp, sj + '_MSME_BFC.nii.gz') # original bfc pfi_msme_up_bfc = jph(pfo_tmp, sj + '_MSMEinS0_BFC.nii.gz') # up bfc # assert check_path_validity(pfi_msme_nifti) # assert check_path_validity(pfi_msme_up) assert check_path_validity(pfi_msme_bfc) assert check_path_validity(pfi_msme_up_bfc) pfo_tp0 = jph(pfo_mod, 'MSME_tp0') # pfi_final_tp0 = jph(pfo_tp0, sj + '_MSME_tp0.nii.gz') # pfi_final_up_tp0 = jph(pfo_tp0, sj + '_MSMEinS0_tp0.nii.gz') pfi_final_bfc_tp0 = jph(pfo_tp0, sj + '_MSME_tp0.nii.gz') pfi_final_bfc_up_tp0 = jph(pfo_tp0, sj + '_MSMEinS0_tp0.nii.gz') cmd0 = 'mkdir -p {}'.format(pfo_tp0) # cmd1 = 'seg_maths {0} -tp 0 {1}'.format(pfi_msme_nifti, pfi_final_tp0) # cmd3 = 'seg_maths {0} -tp 0 {1}'.format(pfi_msme_up, pfi_final_up_tp0) cmd2 = 'seg_maths {0} -tp 0 {1}'.format(pfi_msme_bfc, pfi_final_bfc_tp0) cmd4 = 'seg_maths {0} -tp 0 {1}'.format(pfi_msme_up_bfc, pfi_final_bfc_up_tp0) print_and_run(cmd0) # print_and_run(cmd1) # print_and_run(cmd3) print_and_run(cmd2) print_and_run(cmd4)
def test_check_path_validity_root(): assert check_path_validity(root_dir)
def process_T2_map_per_subject(sj, controller): print('\nProcessing T2 map {} 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_input_sj_MSME = jph(root_study_rabbits, '02_nifti', study, category, sj, sj + '_MSME') pfo_output_sj = jph(root_study_rabbits, 'A_data', study, category, sj) pfo_mod = jph(pfo_output_sj, 'mod') # input sanity check: if not os.path.exists(pfo_input_sj_MSME): print('MSME modality not given in the input folder after Nifti conversion. Bypass methods involving MSME') return if not os.path.exists(pfo_output_sj): raise IOError('Output folder MSME does not exist.') if not os.path.exists(pfo_mod): raise IOError('Output folder MSME does not exist.') # -- Generate intermediate and output folder pfo_tmp = jph(pfo_output_sj, 'z_tmp', 'z_T2map') print_and_run('mkdir -p {}'.format(pfo_tmp)) suffix = ['', 'inS0'] if controller['get_acquisition_echo_time']: pfi_visu_pars = jph(pfo_input_sj_MSME, sj + '_MSME_visu_pars.npy') assert check_path_validity(pfi_visu_pars) pfi_echo_times = jph(pfo_tmp, sj + '_echo_times.txt') visu_pars_dict = np.load(pfi_visu_pars) np.savetxt(fname=pfi_echo_times, X=visu_pars_dict.item().get('VisuAcqEchoTime'), fmt='%10.2f', newline=' ') if controller['process_each_MSME_input']: pfi_echo_times = jph(pfo_tmp, '{}_echo_times.txt'.format(sj)) assert os.path.exists(pfi_echo_times) TE = np.loadtxt(pfi_echo_times) echo_delta = TE[2] - TE[1] # original for s in suffix: pfi_original_MSME = jph(pfo_mod, '{}_MSME{}.nii.gz'.format(sj, s)) check_path_validity(pfi_original_MSME) pfi_T2map = jph(pfo_tmp, '{}_T2map{}.nii.gz'.format(sj, s)) cmd1 = root_fit_apps + 'fit_qt2 -source {0} -TE {1} -t2map {2}'.format(pfi_original_MSME, echo_delta, pfi_T2map) print cmd1 print_and_run(cmd1) if controller['correct_origin']: # some versions of niftyfit for fit_qt2 are dividing by 0 in the origin. for s in suffix: pfi_T2map = jph(pfo_tmp, sj + '_T2map{}.nii.gz'.format(s)) check_path_validity(pfi_T2map) pfi_T2map_corrected = jph(pfo_tmp, sj + '_corrected_T2map{}.nii.gz'.format(s)) # clean upper outliers (Mean + 2 * StandardDeviation) ... They are more than outliers! im_s = nib.load(pfi_T2map) places_not_outliers = im_s.get_data() < 1000 # np.mean(im_s.get_data()) + 2 * np.std(im_s.get_data()) im_s.get_data()[:] = places_not_outliers * im_s.get_data() im_corrected = set_new_data(im_s, places_not_outliers * im_s.get_data()) nib.save(im_corrected, pfi_T2map_corrected) if controller['save_results']: # Save the bias field corrected '', and '_up' in the name _T2map and _T2map_up for s in suffix: pfi_source = jph(pfo_tmp, sj + '_corrected_T2map{}.nii.gz'.format(s)) pfi_destination = jph(pfo_mod, sj + '_T2map.nii.gz') cmd = 'cp {0} {1}'.format(pfi_source, pfi_destination) print_and_run(cmd)
def test_check_path_validity_for_a_nifti_image(): assert check_path_validity(jph(pfo_tmp_test, 'dummy_image.nii.gz'))
def test_check_path_validity_not_existing_path(): with assert_raises(IOError): check_path_validity('/Spammer/path_to_spam')
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 process_g_ratio_per_subject(sj, controller): print('\nProcessing g-ratio {} 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'] DWI_suffix = sj_parameters['names_architecture']['DWI'] # default is DWI pfo_input_sj_DWI = jph(root_study_rabbits, '02_nifti', study, category, sj, '{}_{}'.format(sj, DWI_suffix)) pfo_input_sj_MSME = jph(root_study_rabbits, '02_nifti', study, category, sj, sj + '_MSME') pfo_output_sj = jph(root_study_rabbits, 'A_data', study, category, sj) # input sanity check: 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' ) return if not os.path.exists(pfo_input_sj_MSME): print( 'MSME modality not given in the input folder after Nifti conversion. Bypass methods involving MSME' ) return if not os.path.exists(pfo_output_sj): raise IOError( 'Output folder subject {} does not exist.'.format(pfo_output_sj)) # -- 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_gr{}'.format(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['transpose_bvals_bvects']: print('- Transpose b-vals and b-vects') 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)) assert check_path_validity(pfi_bvals) assert check_path_validity(pfi_bvects) pfi_transposed_bvals = jph( pfo_tmp, '{}_{}_DwEffBval_T.txt'.format(sj, DWI_suffix)) pfi_transposed_vects = jph( pfo_tmp, '{}_{}_DwGradVec_T.txt'.format(sj, DWI_suffix)) m = np.loadtxt(pfi_bvals) np.savetxt(fname=pfi_transposed_bvals, X=m.T, delimiter=' ', newline=' ', fmt='%10.8f') m = np.loadtxt(pfi_bvects) np.savetxt(fname=pfi_transposed_vects, X=m.T, fmt='%10.8f') if controller['get_acquisition_echo_time']: pfi_visu_pars = jph(pfo_input_sj_MSME, sj + '_MSME_visu_pars.npy') assert check_path_validity(pfi_visu_pars), pfi_visu_pars pfi_echo_times = jph(pfo_tmp, sj + '_echo_times.txt') visu_pars_dict = np.load(pfi_visu_pars) np.savetxt(fname=pfi_echo_times, X=visu_pars_dict.item().get('VisuAcqEchoTime'), fmt='%10.2f', newline=' ') if controller['noddi']: print('- Noddi execution') # check if there is a DWI already processed in the TMP folder of the same subject: pfo_tmp_dwi = jph(pfo_output_sj, 'z_tmp', 'z_' + DWI_suffix) pfi_dwi_eddy_corrected = jph( pfo_tmp_dwi, '{}_{}_eddy.nii.gz'.format(sj, DWI_suffix)) pfi_roi_mask = jph(pfo_mask, '{}_S0_roi_mask.nii.gz'.format(sj)) pfi_transposed_bvals = jph( pfo_tmp, '{}_{}_DwEffBval_T.txt'.format(sj, DWI_suffix)) pfi_transposed_vects = jph( pfo_tmp, '{}_{}_DwGradVec_T.txt'.format(sj, DWI_suffix)) pfi_echo_times = jph(pfo_tmp, '{}_echo_times.txt'.format(sj)) assert check_path_validity( pfi_dwi_eddy_corrected), 'Need to run process_DWI first?' assert check_path_validity(pfi_transposed_bvals) assert check_path_validity(pfi_transposed_vects) assert check_path_validity(pfi_roi_mask) assert check_path_validity(pfi_echo_times) pfi_output_noddi = jph(pfo_tmp, '{}_nod.nii.gz'.format(sj)) cmd = root_fit_apps + 'fit_dwi -source {0} -mask {1} -bval {2} -bvec {3} -TE {4} -mcmap {5} -nod'.format( pfi_dwi_eddy_corrected, pfi_roi_mask, pfi_transposed_bvals, pfi_transposed_vects, pfi_echo_times, pfi_output_noddi) print_and_run(cmd) if controller['save_T2times']: if sj_parameters['category'] == 'ex_vivo': t2_times = (8, 50, 60) # (15, 80, 110) 30, 160, 200 - 14, 70, 100 elif sj_parameters['category'] == 'in_vivo': t2_times = (10, 60, 80) else: t2_times = (10, 60, 80) pfi_T2_times = jph(pfo_tmp, sj + '_t2_times.txt') np.savetxt(fname=pfi_T2_times, X=np.array(t2_times), fmt='%10.10f', newline=' ') if controller['fit_msme']: pfi_msme_inS0 = jph(pfo_mod, sj + '_MSMEinS0.nii.gz') pfi_roi_mask = jph(pfo_mask, sj + '_S0_roi_mask.nii.gz') pfi_echo_times = jph(pfo_tmp, sj + '_echo_times.txt') pfi_T2_times = jph(pfo_tmp, sj + '_t2_times.txt') assert check_path_validity( pfi_msme_inS0), 'Need to run process_MSME first?' assert check_path_validity(pfi_roi_mask) assert check_path_validity(pfi_echo_times) assert check_path_validity(pfi_T2_times) pfi_mwf = jph(pfo_tmp, sj + '_vmvf.nii.gz') cmd = root_fit_apps + 'fit_qt2 -source {0} -mask {1} -nc 3 -TElist {2} -T2list {3} -mwf {4}'.format( pfi_msme_inS0, pfi_roi_mask, pfi_echo_times, pfi_T2_times, pfi_mwf) print cmd print_and_run(cmd) assert check_path_validity(pfi_mwf) if not os.path.exists(pfi_mwf): raise IOError('Something went wrong in using fit_qt2...') if controller['extract_first_tp_noddi']: pfi_noddi = jph(pfo_tmp, sj + '_nod.nii.gz') assert check_path_validity(pfi_noddi) pfi_vin = jph(pfo_tmp, sj + '_vin.nii.gz') cmd = 'seg_maths {0} -tp 0 {1}'.format(pfi_noddi, pfi_vin) print_and_run(cmd) if controller['compute_gratio']: pfi_mwf = jph(pfo_tmp, sj + '_vmvf.nii.gz') pfi_vin = jph(pfo_tmp, sj + '_vin.nii.gz') assert check_path_validity(pfi_mwf) assert check_path_validity(pfi_vin) pfi_tmp = jph(pfo_tmp, sj + '_tmp_g_ratio.nii.gz') pfi_g_ratio = jph(pfo_tmp, sj + '_g_ratio.nii.gz') cmd1 = 'seg_maths {0} -mul -1. {1}'.format(pfi_mwf, pfi_tmp) cmd2 = 'seg_maths {0} -add 1.0 {0}'.format(pfi_tmp) cmd3 = 'seg_maths {0} -mul {1} {0}'.format(pfi_tmp, pfi_vin) cmd4 = 'seg_maths {0} -div {1} {1}'.format(pfi_mwf, pfi_tmp) cmd5 = 'seg_maths {0} -add 1.0 {0}'.format(pfi_tmp) cmd6 = 'seg_maths {0} -recip {0}'.format(pfi_tmp) cmd7 = 'seg_maths {0} -sqrt {0}'.format(pfi_tmp) cmd8 = 'seg_maths {0} -uthr 0.999999999 {1}'.format( pfi_tmp, pfi_g_ratio) print_and_run(cmd1) print_and_run(cmd2) print_and_run(cmd3) print_and_run(cmd4) print_and_run(cmd5) print_and_run(cmd6) print_and_run(cmd7) print_and_run(cmd8) if controller['save_results']: pfi_g_ratio = jph(pfo_tmp, sj + '_g_ratio.nii.gz') assert check_path_validity(pfi_g_ratio) pfi_g_ratio_final = jph(pfo_mod, sj + '_g_ratio.nii.gz') cmd = 'cp {} {} '.format(pfi_g_ratio, pfi_g_ratio_final) print_and_run(cmd)
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