def build_input_node(self): """Build and connect an input node to the pipeline.""" import os from clinica.utils.filemanip import save_participants_sessions from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process if self.parameters["longitudinal"]: self.build_input_node_longitudinal() else: self.build_input_node_cross_sectional() # Save subjects to process in <WD>/<Pipeline.name>/participants.tsv folder_participants_tsv = os.path.join(self.base_dir, self.name) save_participants_sessions( self.subjects, self.sessions, folder_participants_tsv ) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( "List available in %s" % os.path.join(folder_participants_tsv, "participants.tsv") ) cprint("The pipeline will last approximately a few hours per image.")
def build_input_node(self): """Build and connect an input node to the pipeline.""" import nipype.pipeline.engine as npe import nipype.interfaces.utility as nutil from clinica.utils.exceptions import ClinicaException, ClinicaCAPSError from clinica.utils.inputs import clinica_file_reader, clinica_group_reader from clinica.utils.input_files import t1_volume_i_th_iteration_group_template, t1_volume_dartel_input_tissue from clinica.utils.ux import print_images_to_process read_input_node = npe.Node(name="LoadingCLIArguments", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True)) all_errors = [] # Dartel Input Tissues # ==================== d_input = [] for tissue_number in self.parameters['tissues']: try: current_file = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_dartel_input_tissue(tissue_number)) d_input.append(current_file) except ClinicaException as e: all_errors.append(e) # Dartel Templates # ================ dartel_iter_templates = [] for i in range(1, 7): try: current_iter = clinica_group_reader( self.caps_directory, t1_volume_i_th_iteration_group_template( self.parameters['group_id'], i)) dartel_iter_templates.append(current_iter) except ClinicaException as e: all_errors.append(e) if len(all_errors) > 0: error_message = 'Clinica faced error(s) while trying to read files in your CAPS/BIDS directories.\n' for msg in all_errors: error_message += str(msg) raise ClinicaCAPSError(error_message) read_input_node.inputs.dartel_input_images = d_input read_input_node.inputs.dartel_iteration_templates = dartel_iter_templates if len(self.subjects): print_images_to_process(self.subjects, self.sessions) self.connect([(read_input_node, self.input_node, [('dartel_input_images', 'dartel_input_images')]), (read_input_node, self.input_node, [('dartel_iteration_templates', 'dartel_iteration_templates')])])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.filemanip import save_participants_sessions from clinica.utils.input_files import ( DWI_BVAL, DWI_BVEC, DWI_JSON, DWI_NII, T1W_NII, ) from clinica.utils.inputs import clinica_list_of_files_reader from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process list_bids_files = clinica_list_of_files_reader( self.subjects, self.sessions, self.bids_directory, [T1W_NII, DWI_JSON, DWI_NII, DWI_BVEC, DWI_BVAL], raise_exception=True, ) # Save subjects to process in <WD>/<Pipeline.name>/participants.tsv folder_participants_tsv = os.path.join(self.base_dir, self.name) save_participants_sessions(self.subjects, self.sessions, folder_participants_tsv) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( f"List available in {os.path.join(folder_participants_tsv, 'participants.tsv')}" ) cprint( "Computational time will depend of the number of volumes in your DWI dataset and the use of CUDA." ) read_node = npe.Node( name="ReadingFiles", iterables=[ ("t1w", list_bids_files[0]), ("dwi_json", list_bids_files[1]), ("dwi", list_bids_files[2]), ("bvec", list_bids_files[3]), ("bval", list_bids_files[4]), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields()), ) # fmt: off self.connect([ (read_node, self.input_node, [("t1w", "t1w"), ("dwi", "dwi"), ("dwi_json", "dwi_json"), ("bvec", "bvec"), ("bval", "bval")]), ])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from colorama import Fore from clinica.utils.exceptions import ClinicaCAPSError, ClinicaException from clinica.utils.input_files import t1_volume_template_tpm_in_mni from clinica.utils.inputs import clinica_file_reader from clinica.utils.stream import cprint from clinica.utils.ux import ( print_groups_in_caps_directory, print_images_to_process, ) # Check that group already exists if not os.path.exists( os.path.join(self.caps_directory, "groups", f"group-{self.parameters['group_label']}")): print_groups_in_caps_directory(self.caps_directory) raise ClinicaException( f"%{Fore.RED}Group {self.parameters['group_label']} does not exist. " f"Did you run t1-volume or t1-volume-create-dartel pipeline?{Fore.RESET}" ) try: gm_mni = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_template_tpm_in_mni(self.parameters["group_label"], 1, True), ) except ClinicaException as e: final_error_str = "Clinica faced error(s) while trying to read files in your CAPS directory.\n" final_error_str += str(e) raise ClinicaCAPSError(final_error_str) read_parameters_node = npe.Node( name="LoadingCLIArguments", interface=nutil.IdentityInterface(fields=self.get_input_fields(), mandatory_inputs=True), ) read_parameters_node.inputs.file_list = gm_mni read_parameters_node.inputs.atlas_list = self.parameters["atlases"] if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint("The pipeline will last a few seconds per image.") self.connect([ (read_parameters_node, self.input_node, [("file_list", "file_list") ]), (read_parameters_node, self.input_node, [("atlas_list", "atlas_list")]), ])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.stream import cprint from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import T1W_LINEAR from clinica.utils.input_files import T1W_LINEAR_CROPPED from clinica.utils.ux import print_images_to_process if self.parameters.get('use_uncropped_image'): FILE_TYPE = T1W_LINEAR else: FILE_TYPE = T1W_LINEAR_CROPPED # T1w_Linear file: try: t1w_files = clinica_file_reader(self.subjects, self.sessions, self.caps_directory, FILE_TYPE) except ClinicaException as e: err = 'Clinica faced error(s) while trying to read files in your CAPS directory.\n' + str( e) raise ClinicaBIDSError(err) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint('The pipeline will last approximately 30 seconds per image.' ) # Replace by adequate computational time. if self.parameters.get('extract_method') == 'slice': self.slice_direction = self.parameters.get('slice_direction') self.slice_mode = self.parameters.get('slice_mode') else: self.slice_direction = 'axial' self.slice_mode = 'rgb' if self.parameters.get('extract_method') == 'patch': self.patch_size = self.parameters.get('patch_size') self.stride_size = self.parameters.get('stride_size') else: self.patch_size = 50 self.stride_size = 50 # The reading node # ------------------------- read_node = npe.Node( name="ReadingFiles", iterables=[ ('input_nifti', t1w_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields())) self.connect([ (read_node, self.input_node, [('input_nifti', 'input_nifti')]), ])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os import nipype.pipeline.engine as npe import nipype.interfaces.utility as nutil from clinica.utils.inputs import clinica_file_reader from clinica.utils.exceptions import ClinicaException from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process all_errors = [] t1w_in_ixi549space = { "pattern": os.path.join( "t1", "spm", "segmentation", "normalized_space", "*_*_space-Ixi549Space_T1w.nii*", ), "description": "Tissue probability map in native space", "needed_pipeline": "t1-volume-tissue-segmentation", } try: t1w_files = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1w_in_ixi549space, ) except ClinicaException as e: all_errors.append(e) # Raise all errors if some happened if len(all_errors) > 0: error_message = "Clinica faced errors while trying to read files in your CAPS directory.\n" for msg in all_errors: error_message += str(msg) raise RuntimeError(error_message) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint("The pipeline will last a few seconds per image.") read_node = npe.Node( name="ReadingFiles", iterables=[ ("norm_t1w", t1w_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields()), ) self.connect([ (read_node, self.input_node, [("norm_t1w", "norm_t1w")]), ])
def build_input_node(self): """Build and connect an input node to the pipeline. Raise: ClinicaBIDSError: If there are duplicated files or missing files for any subject """ import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.iotools.utils.data_handling import ( check_volume_location_in_world_coordinate_system, ) from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.input_files import T1W_NII from clinica.utils.inputs import clinica_file_reader from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process # Inputs from anat/ folder # ======================== # T1w file: try: t1w_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, T1W_NII) except ClinicaException as e: err = f"Clinica faced error(s) while trying to read files in your BIDS directory.\n{str(e)}" raise ClinicaBIDSError(err) check_volume_location_in_world_coordinate_system( t1w_files, self.bids_directory, skip_question=self.parameters["skip_question"], ) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( "The pipeline will last approximately 10 minutes per image.") read_node = npe.Node( name="ReadingFiles", iterables=[ ("t1w", t1w_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields()), ) self.connect([ (read_node, self.input_node, [("t1w", "t1w")]), ])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os from colorama import Fore import nipype.pipeline.engine as npe import nipype.interfaces.utility as nutil from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import t1_volume_template_tpm_in_mni from clinica.utils.exceptions import ClinicaCAPSError, ClinicaException from clinica.utils.stream import cprint from clinica.utils.ux import print_groups_in_caps_directory, print_images_to_process # Check that group already exists if not os.path.exists( os.path.join(self.caps_directory, 'groups', 'group-' + self.parameters['group_id'])): print_groups_in_caps_directory(self.caps_directory) raise ClinicaException( '%sGroup %s does not exist. Did you run t1-volume or t1-volume-create-dartel pipeline?%s' % (Fore.RED, self.parameters['group_id'], Fore.RESET)) try: gm_mni = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_template_tpm_in_mni(self.parameters['group_id'], 1, True)) except ClinicaException as e: final_error_str = 'Clinica faced error(s) while trying to read files in your CAPS directory.\n' final_error_str += str(e) raise ClinicaCAPSError(final_error_str) read_parameters_node = npe.Node(name="LoadingCLIArguments", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True)) read_parameters_node.inputs.file_list = gm_mni read_parameters_node.inputs.atlas_list = self.parameters['atlases'] if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint('The pipeline will last a few seconds per image.') self.connect([(read_parameters_node, self.input_node, [('file_list', 'file_list')]), (read_parameters_node, self.input_node, [('atlas_list', 'atlas_list')])])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os from colorama import Fore import nipype.pipeline.engine as npe import nipype.interfaces.utility as nutil from clinica.utils.inputs import clinica_file_reader, clinica_group_reader from clinica.utils.input_files import ( t1_volume_final_group_template, t1_volume_native_tpm, t1_volume_deformation_to_template) from clinica.utils.exceptions import ClinicaCAPSError, ClinicaException from clinica.utils.stream import cprint from clinica.utils.ux import print_groups_in_caps_directory, print_images_to_process # Check that group already exists if not os.path.exists( os.path.join(self.caps_directory, 'groups', 'group-' + self.parameters['group_id'])): print_groups_in_caps_directory(self.caps_directory) raise ClinicaException( '%sGroup %s does not exist. Did you run t1-volume or t1-volume-create-dartel pipeline?%s' % (Fore.RED, self.parameters['group_id'], Fore.RESET)) all_errors = [] read_input_node = npe.Node(name="LoadingCLIArguments", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True)) # Segmented Tissues # ================= tissues_input = [] for tissue_number in self.parameters['tissues']: try: native_space_tpm = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_native_tpm(tissue_number)) tissues_input.append(native_space_tpm) except ClinicaException as e: all_errors.append(e) # Tissues_input has a length of len(self.parameters['mask_tissues']). Each of these elements has a size of # len(self.subjects). We want the opposite : a list of size len(self.subjects) whose elements have a size of # len(self.parameters['mask_tissues']. The trick is to iter on elements with zip(*my_list) tissues_input_rearranged = [] for subject_tissue_list in zip(*tissues_input): tissues_input_rearranged.append(subject_tissue_list) read_input_node.inputs.native_segmentations = tissues_input_rearranged # Flow Fields # =========== try: read_input_node.inputs.flowfield_files = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_deformation_to_template(self.parameters['group_id'])) except ClinicaException as e: all_errors.append(e) # Dartel Template # ================ try: read_input_node.inputs.template_file = clinica_group_reader( self.caps_directory, t1_volume_final_group_template(self.parameters['group_id'])) except ClinicaException as e: all_errors.append(e) if len(all_errors) > 0: error_message = 'Clinica faced error(s) while trying to read files in your CAPS/BIDS directories.\n' for msg in all_errors: error_message += str(msg) raise ClinicaCAPSError(error_message) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint('The pipeline will last a few minutes per image.') self.connect([(read_input_node, self.input_node, [('native_segmentations', 'native_segmentations')]), (read_input_node, self.input_node, [('flowfield_files', 'flowfield_files')]), (read_input_node, self.input_node, [('template_file', 'template_file')])])
def build_input_node(self): """Build and connect an input node to the pipeline.""" from os import pardir from os.path import abspath, dirname, exists, join import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.exceptions import ( ClinicaBIDSError, ClinicaCAPSError, ClinicaException, ) from clinica.utils.filemanip import extract_subjects_sessions_from_filename from clinica.utils.input_files import ( T1W_NII, T1W_TO_MNI_TRANSFROM, bids_pet_nii, ) from clinica.utils.inputs import ( RemoteFileStructure, clinica_file_reader, fetch_file, ) from clinica.utils.pet import get_suvr_mask from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process # from clinica.iotools.utils.data_handling import check_volume_location_in_world_coordinate_system # Import references files root = dirname(abspath(join(abspath(__file__), pardir, pardir))) path_to_mask = join(root, "resources", "masks") url_aramis = "https://aramislab.paris.inria.fr/files/data/img_t1_linear/" FILE1 = RemoteFileStructure( filename="mni_icbm152_t1_tal_nlin_sym_09c.nii", url=url_aramis, checksum= "93359ab97c1c027376397612a9b6c30e95406c15bf8695bd4a8efcb2064eaa34", ) FILE2 = RemoteFileStructure( filename="ref_cropped_template.nii.gz", url=url_aramis, checksum= "67e1e7861805a8fd35f7fcf2bdf9d2a39d7bcb2fd5a201016c4d2acdd715f5b3", ) self.ref_template = join(path_to_mask, FILE1.filename) self.ref_crop = join(path_to_mask, FILE2.filename) self.ref_mask = get_suvr_mask(self.parameters["suvr_reference_region"]) if not (exists(self.ref_template)): try: fetch_file(FILE1, path_to_mask) except IOError as err: cprint( msg= f"Unable to download required template (mni_icbm152) for processing: {err}", lvl="error", ) if not (exists(self.ref_crop)): try: fetch_file(FILE2, path_to_mask) except IOError as err: cprint( msg= f"Unable to download required template (ref_crop) for processing: {err}", lvl="error", ) # Inputs from BIDS directory # pet file: PET_NII = bids_pet_nii(self.parameters["acq_label"]) try: pet_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, PET_NII) except ClinicaException as e: err = ( "Clinica faced error(s) while trying to read pet files in your BIDS directory.\n" + str(e)) raise ClinicaBIDSError(err) # T1w file: try: t1w_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, T1W_NII) except ClinicaException as e: err = ( "Clinica faced error(s) while trying to read t1w files in your BIDS directory.\n" + str(e)) raise ClinicaBIDSError(err) # Inputs from t1-linear pipeline # Transformation files from T1w files to MNI: try: t1w_to_mni_transformation_files = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, T1W_TO_MNI_TRANSFROM) except ClinicaException as e: err = ( "Clinica faced error(s) while trying to read transformation files in your CAPS directory.\n" + str(e)) raise ClinicaCAPSError(err) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint("The pipeline will last approximately 3 minutes per image.") read_input_node = npe.Node( name="LoadingCLIArguments", iterables=[ ("t1w", t1w_files), ("pet", pet_files), ("t1w_to_mni", t1w_to_mni_transformation_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields()), ) # fmt: off self.connect([ (read_input_node, self.input_node, [("t1w", "t1w")]), (read_input_node, self.input_node, [("pet", "pet")]), (read_input_node, self.input_node, [("t1w_to_mni", "t1w_to_mni")]), ])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os import sys from colorama import Fore import nipype.pipeline.engine as npe import nipype.interfaces.utility as nutil from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import t1_volume_dartel_input_tissue from clinica.utils.exceptions import ClinicaException from clinica.utils.stream import cprint from clinica.utils.ux import print_groups_in_caps_directory, print_images_to_process, print_begin_image representative_output = os.path.join( self.caps_directory, 'groups', 'group-' + self.parameters['group_label'], 't1', 'group-' + self.parameters['group_label'] + '_template.nii.gz') if os.path.exists(representative_output): cprint( "%sDARTEL template for %s already exists. Currently, Clinica does not propose to overwrite outputs " "for this pipeline.%s" % (Fore.YELLOW, self.parameters['group_label'], Fore.RESET)) print_groups_in_caps_directory(self.caps_directory) sys.exit(0) # Check that there is at least 2 subjects if len(self.subjects) <= 1: raise ClinicaException( '%sThis pipeline needs at least 2 images to create DARTEL template but ' 'Clinica only found %s.%s' % (Fore.RED, len(self.subjects), Fore.RESET)) read_parameters_node = npe.Node(name="LoadingCLIArguments", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True)) all_errors = [] d_input = [] for tissue_number in self.parameters['dartel_tissues']: try: current_file = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_dartel_input_tissue(tissue_number)) d_input.append(current_file) except ClinicaException as e: all_errors.append(e) # Raise all errors if some happened if len(all_errors) > 0: error_message = 'Clinica faced errors while trying to read files in your BIDS or CAPS directories.\n' for msg in all_errors: error_message += str(msg) raise RuntimeError(error_message) # d_input is a list of size len(self.parameters['dartel_tissues']) # Each element of this list is a list of size len(self.subjects) read_parameters_node.inputs.dartel_inputs = d_input if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( 'Computational time for DARTEL creation will depend on the number of images.' ) print_begin_image('group-' + self.parameters['group_label']) self.connect([(read_parameters_node, self.input_node, [('dartel_inputs', 'dartel_input_images')])])
def build_input_node(self): """Build and connect an input node to the pipeline. """ from os import pardir from os.path import dirname, join, abspath, exists from colorama import Fore import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.filemanip import extract_subjects_sessions_from_filename from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import T1W_NII from clinica.utils.inputs import fetch_file, RemoteFileStructure from clinica.utils.ux import print_images_to_process from clinica.utils.stream import cprint root = dirname(abspath(join(abspath(__file__), pardir, pardir))) path_to_mask = join(root, 'resources', 'masks') url_aramis = 'https://aramislab.paris.inria.fr/files/data/img_t1_linear/' FILE1 = RemoteFileStructure( filename='ref_cropped_template.nii.gz', url=url_aramis, checksum= '67e1e7861805a8fd35f7fcf2bdf9d2a39d7bcb2fd5a201016c4d2acdd715f5b3') FILE2 = RemoteFileStructure( filename='mni_icbm152_t1_tal_nlin_sym_09c.nii', url=url_aramis, checksum= '93359ab97c1c027376397612a9b6c30e95406c15bf8695bd4a8efcb2064eaa34') self.ref_template = join(path_to_mask, FILE2.filename) self.ref_crop = join(path_to_mask, FILE1.filename) if not (exists(self.ref_template)): try: fetch_file(FILE2, path_to_mask) except IOError as err: cprint( 'Unable to download required template (mni_icbm152) for processing:', err) if not (exists(self.ref_crop)): try: fetch_file(FILE1, path_to_mask) except IOError as err: cprint( 'Unable to download required template (ref_crop) for processing:', err) # Display image(s) already present in CAPS folder # =============================================== processed_ids = self.get_processed_images(self.caps_directory, self.subjects, self.sessions) if len(processed_ids) > 0: cprint( "%sClinica found %s image(s) already processed in CAPS directory:%s" % (Fore.YELLOW, len(processed_ids), Fore.RESET)) for image_id in processed_ids: cprint("%s\t%s%s" % (Fore.YELLOW, image_id.replace('_', ' |Â '), Fore.RESET)) cprint("%s\nImage(s) will be ignored by Clinica.\n%s" % (Fore.YELLOW, Fore.RESET)) input_ids = [ p_id + '_' + s_id for p_id, s_id in zip(self.subjects, self.sessions) ] to_process_ids = list(set(input_ids) - set(processed_ids)) self.subjects, self.sessions = extract_subjects_sessions_from_filename( to_process_ids) # Inputs from anat/ folder # ======================== # T1w file: try: t1w_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, T1W_NII) except ClinicaException as e: err = 'Clinica faced error(s) while trying to read files in your BIDS directory.\n' + str( e) raise ClinicaBIDSError(err) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint('The pipeline will last approximately 6 minutes per image.') read_node = npe.Node( name="ReadingFiles", iterables=[ ('t1w', t1w_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields())) self.connect([ (read_node, self.input_node, [('t1w', 't1w')]), ])
def build_input_node(self): """Build and connect an input node to the pipeline. Raise: ClinicaBIDSError: If there are duplicated files or missing files for any subject """ import os import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from colorama import Fore from clinica.iotools.utils.data_handling import ( check_volume_location_in_world_coordinate_system, ) from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.filemanip import ( extract_subjects_sessions_from_filename, save_participants_sessions, ) from clinica.utils.input_files import T1W_NII from clinica.utils.inputs import clinica_file_reader from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process # Display image(s) already present in CAPS folder # =============================================== processed_ids = self.get_processed_images(self.caps_directory, self.subjects, self.sessions) if len(processed_ids) > 0: cprint(f"{Fore.YELLOW}Clinica found {len(processed_ids)} image(s) " f"already processed in CAPS directory:{Fore.RESET}") for image_id in processed_ids: cprint( f"{Fore.YELLOW}\t{image_id.replace('_', ' |Â ')}{Fore.RESET}" ) if self.overwrite_caps: output_folder = "<CAPS>/subjects/<participant_id>/<session_id>/t1/freesurfer_cross_sectional" cprint( f"{Fore.YELLOW}\nOutput folders in {output_folder} will be recreated.\n{Fore.RESET}" ) else: cprint( f"{Fore.YELLOW}\nImage(s) will be ignored by Clinica.\n{Fore.RESET}" ) input_ids = [ p_id + "_" + s_id for p_id, s_id in zip(self.subjects, self.sessions) ] to_process_ids = list(set(input_ids) - set(processed_ids)) self.subjects, self.sessions = extract_subjects_sessions_from_filename( to_process_ids) # Inputs from anat/ folder # ======================== # T1w file: try: t1w_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, T1W_NII) except ClinicaException as e: err_msg = ( "Clinica faced error(s) while trying to read files in your BIDS directory.\n" + str(e)) raise ClinicaBIDSError(err_msg) # Save subjects to process in <WD>/<Pipeline.name>/participants.tsv folder_participants_tsv = os.path.join(self.base_dir, self.name) save_participants_sessions(self.subjects, self.sessions, folder_participants_tsv) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint("List available in %s" % os.path.join(folder_participants_tsv, "participants.tsv")) cprint("The pipeline will last approximately 10 hours per image.") read_node = npe.Node( name="ReadingFiles", iterables=[ ("t1w", t1w_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields()), ) check_volume_location_in_world_coordinate_system( t1w_files, self.bids_directory) self.connect([ (read_node, self.input_node, [("t1w", "t1w")]), ])
def build_input_node(self): """Build and connect an input node to the pipeline.""" from colorama import Fore import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.exceptions import ClinicaException from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import (t1_volume_template_tpm_in_mni, pet_volume_normalized_suvr_pet) from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process, print_begin_image all_errors = [] if self.parameters['orig_input_data'] == 'pet-volume': if not (self.parameters["acq_label"] and self.parameters["suvr_reference_region"]): raise ValueError( f"Missing value(s) in parameters from pet-volume pipeline. Given values:\n" f"- acq_label: {self.parameters['acq_label']}\n" f"- suvr_reference_region: {self.parameters['suvr_reference_region']}\n" f"- use_pvc_data: {self.parameters['use_pvc_data']}\n") self.parameters['measure_label'] = self.parameters['acq_label'] information_dict = pet_volume_normalized_suvr_pet( acq_label=self.parameters["acq_label"], group_label=self.parameters["group_label_dartel"], suvr_reference_region=self.parameters["suvr_reference_region"], use_brainmasked_image=True, use_pvc_data=self.parameters["use_pvc_data"], fwhm=self.parameters['full_width_at_half_maximum']) elif self.parameters['orig_input_data'] == 't1-volume': self.parameters['measure_label'] = 'graymatter' information_dict = t1_volume_template_tpm_in_mni( self.parameters['group_label_dartel'], 0, True) elif self.parameters['orig_input_data'] == 'custom-pipeline': if self.parameters['custom_file'] is None: raise ClinicaException( f"{Fore.RED}Custom pipeline was selected but no 'custom_file' was specified.{Fore.RESET}" ) # If custom file are grabbed, information of fwhm is irrelevant and should not appear on final filenames self.parameters['full_width_at_half_maximum'] = None information_dict = { 'pattern': self.parameters['custom_file'], 'description': 'custom file provided by user' } else: raise ValueError( f"Input data {self.parameters['orig_input_data']} unknown.") try: input_files = clinica_file_reader(self.subjects, self.sessions, self.caps_directory, information_dict) except ClinicaException as e: all_errors.append(e) if len(all_errors) > 0: error_message = 'Clinica faced errors while trying to read files in your CAPS directories.\n' for msg in all_errors: error_message += str(msg) raise ClinicaException(error_message) read_parameters_node = npe.Node(name="LoadingCLIArguments", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True), synchronize=True) read_parameters_node.inputs.input_files = input_files if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( 'The pipeline will last a few minutes. Images generated by SPM will popup during the pipeline.' ) print_begin_image(f"group-{self.parameters['group_label']}") self.connect([(read_parameters_node, self.input_node, [('input_files', 'input_files')])])
def build_input_node(self): """Build and connect an input node to the pipeline.""" from os import pardir from os.path import abspath, dirname, exists, join import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.filemanip import extract_subjects_sessions_from_filename from clinica.utils.input_files import T1W_NII from clinica.utils.inputs import ( RemoteFileStructure, clinica_file_reader, fetch_file, ) from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process root = dirname(abspath(join(abspath(__file__), pardir, pardir))) path_to_mask = join(root, "resources", "masks") url_aramis = "https://aramislab.paris.inria.fr/files/data/img_t1_linear/" FILE1 = RemoteFileStructure( filename="ref_cropped_template.nii.gz", url=url_aramis, checksum= "67e1e7861805a8fd35f7fcf2bdf9d2a39d7bcb2fd5a201016c4d2acdd715f5b3", ) FILE2 = RemoteFileStructure( filename="mni_icbm152_t1_tal_nlin_sym_09c.nii", url=url_aramis, checksum= "93359ab97c1c027376397612a9b6c30e95406c15bf8695bd4a8efcb2064eaa34", ) self.ref_template = join(path_to_mask, FILE2.filename) self.ref_crop = join(path_to_mask, FILE1.filename) if not (exists(self.ref_template)): try: fetch_file(FILE2, path_to_mask) except IOError as err: cprint( msg= f"Unable to download required template (mni_icbm152) for processing: {err}", lvl="error", ) if not (exists(self.ref_crop)): try: fetch_file(FILE1, path_to_mask) except IOError as err: cprint( msg= f"Unable to download required template (ref_crop) for processing: {err}", lvl="error", ) # Display image(s) already present in CAPS folder # =============================================== processed_ids = self.get_processed_images(self.caps_directory, self.subjects, self.sessions) if len(processed_ids) > 0: cprint( msg= f"Clinica found {len(processed_ids)} image(s) already processed in CAPS directory:", lvl="warning", ) for image_id in processed_ids: cprint(msg=f"{image_id.replace('_', ' |Â ')}", lvl="warning") cprint(msg=f"Image(s) will be ignored by Clinica.", lvl="warning") input_ids = [ p_id + "_" + s_id for p_id, s_id in zip(self.subjects, self.sessions) ] to_process_ids = list(set(input_ids) - set(processed_ids)) self.subjects, self.sessions = extract_subjects_sessions_from_filename( to_process_ids) # Inputs from anat/ folder # ======================== # T1w file: try: t1w_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, T1W_NII) except ClinicaException as e: err = ( "Clinica faced error(s) while trying to read files in your BIDS directory.\n" + str(e)) raise ClinicaBIDSError(err) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint("The pipeline will last approximately 6 minutes per image.") read_node = npe.Node( name="ReadingFiles", iterables=[ ("t1w", t1w_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields()), ) self.connect([ (read_node, self.input_node, [("t1w", "t1w")]), ])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os from os.path import join, exists from colorama import Fore import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.inputs import clinica_file_reader, clinica_group_reader from clinica.utils.input_files import ( t1_volume_final_group_template, t1_volume_native_tpm, t1_volume_native_tpm_in_mni, t1_volume_deformation_to_template, bids_pet_nii, T1W_NII) from clinica.utils.exceptions import ClinicaException from clinica.utils.ux import print_groups_in_caps_directory, print_images_to_process from clinica.iotools.utils.data_handling import check_relative_volume_location_in_world_coordinate_system from clinica.utils.filemanip import save_participants_sessions from clinica.utils.pet import read_psf_information, get_suvr_mask from clinica.utils.stream import cprint # Check that group already exists if not exists( join(self.caps_directory, 'groups', 'group-' + self.parameters['group_label'])): print_groups_in_caps_directory(self.caps_directory) raise ClinicaException( '%sGroup %s does not exist. Did you run t1-volume or t1-volume-create-dartel pipeline?%s' % (Fore.RED, self.parameters['group_label'], Fore.RESET)) # Tissues DataGrabber # ==================== all_errors = [] # Grab reference mask reference_mask_file = get_suvr_mask( self.parameters['suvr_reference_region']) # PET from BIDS directory try: pet_bids = clinica_file_reader( self.subjects, self.sessions, self.bids_directory, bids_pet_nii(self.parameters['acq_label'])) except ClinicaException as e: all_errors.append(e) # Native T1w-MRI try: t1w_bids = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, T1W_NII) except ClinicaException as e: all_errors.append(e) # mask_tissues tissues_input = [] for tissue_number in self.parameters['mask_tissues']: try: current_file = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_native_tpm_in_mni(tissue_number, False)) tissues_input.append(current_file) except ClinicaException as e: all_errors.append(e) # Tissues_input has a length of len(self.parameters['mask_tissues']). Each of these elements has a size of # len(self.subjects). We want the opposite: a list of size len(self.subjects) whose elements have a size of # len(self.parameters['mask_tissues']. The trick is to iter on elements with zip(*my_list) tissues_input_final = [] for subject_tissue_list in zip(*tissues_input): tissues_input_final.append(subject_tissue_list) tissues_input = tissues_input_final # Flowfields try: flowfields_caps = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_deformation_to_template( self.parameters['group_label'])) except ClinicaException as e: all_errors.append(e) # Dartel Template try: final_template = clinica_group_reader( self.caps_directory, t1_volume_final_group_template(self.parameters['group_label'])) except ClinicaException as e: all_errors.append(e) if self.parameters['pvc_psf_tsv'] is not None: iterables_psf = read_psf_information( self.parameters['pvc_psf_tsv'], self.subjects, self.sessions) self.parameters['apply_pvc'] = True else: iterables_psf = [[]] * len(self.subjects) self.parameters['apply_pvc'] = False if self.parameters['apply_pvc']: # pvc tissues input pvc_tissues_input = [] for tissue_number in self.parameters['pvc_mask_tissues']: try: current_file = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_native_tpm(tissue_number)) pvc_tissues_input.append(current_file) except ClinicaException as e: all_errors.append(e) if len(all_errors) == 0: pvc_tissues_input_final = [] for subject_tissue_list in zip(*pvc_tissues_input): pvc_tissues_input_final.append(subject_tissue_list) pvc_tissues_input = pvc_tissues_input_final else: pvc_tissues_input = [] if len(all_errors) > 0: error_message = 'Clinica faced error(s) while trying to read files in your CAPS/BIDS directories.\n' for msg in all_errors: error_message += str(msg) raise ClinicaException(error_message) check_relative_volume_location_in_world_coordinate_system( 'T1w-MRI', t1w_bids, self.parameters['acq_label'] + ' PET', pet_bids, self.bids_directory, self.parameters['acq_label']) # Save subjects to process in <WD>/<Pipeline.name>/participants.tsv folder_participants_tsv = os.path.join(self.base_dir, self.name) save_participants_sessions(self.subjects, self.sessions, folder_participants_tsv) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint('List available in %s' % os.path.join(folder_participants_tsv, 'participants.tsv')) cprint( 'The pipeline will last approximately 10 minutes per image.') read_input_node = npe.Node( name="LoadingCLIArguments", interface=nutil.IdentityInterface(fields=self.get_input_fields(), mandatory_inputs=True), iterables=[('pet_image', pet_bids), ('t1_image_native', t1w_bids), ('mask_tissues', tissues_input), ('psf', iterables_psf), ('flow_fields', flowfields_caps), ('pvc_mask_tissues', pvc_tissues_input)], synchronize=True) read_input_node.inputs.reference_mask = reference_mask_file read_input_node.inputs.dartel_template = final_template self.connect([(read_input_node, self.input_node, [('pet_image', 'pet_image'), ('t1_image_native', 't1_image_native'), ('mask_tissues', 'mask_tissues'), ('flow_fields', 'flow_fields'), ('dartel_template', 'dartel_template'), ('reference_mask', 'reference_mask'), ('psf', 'psf'), ('pvc_mask_tissues', 'pvc_mask_tissues')])])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os import sys import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.exceptions import ClinicaException from clinica.utils.input_files import t1_volume_dartel_input_tissue from clinica.utils.inputs import clinica_file_reader from clinica.utils.stream import cprint from clinica.utils.ux import ( print_begin_image, print_groups_in_caps_directory, print_images_to_process, ) representative_output = os.path.join( self.caps_directory, "groups", f"group-{self.parameters['group_label']}", "t1", f"group-{self.parameters['group_label']}_template.nii.gz", ) if os.path.exists(representative_output): cprint( msg= (f"DARTEL template for {self.parameters['group_label']} already exists. " "Currently, Clinica does not propose to overwrite outputs for this pipeline." ), lvl="warning", ) print_groups_in_caps_directory(self.caps_directory) sys.exit(0) # Check that there is at least 2 subjects if len(self.subjects) <= 1: raise ClinicaException( "This pipeline needs at least 2 images to create DARTEL " f"template but Clinica only found {len(self.subjects)}.") read_parameters_node = npe.Node( name="LoadingCLIArguments", interface=nutil.IdentityInterface(fields=self.get_input_fields(), mandatory_inputs=True), ) all_errors = [] d_input = [] for tissue_number in self.parameters["dartel_tissues"]: try: current_file = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_dartel_input_tissue(tissue_number), ) d_input.append(current_file) except ClinicaException as e: all_errors.append(e) # Raise all errors if some happened if len(all_errors) > 0: error_message = "Clinica faced errors while trying to read files in your BIDS or CAPS directories.\n" for msg in all_errors: error_message += str(msg) raise RuntimeError(error_message) # d_input is a list of size len(self.parameters['dartel_tissues']) # Each element of this list is a list of size len(self.subjects) read_parameters_node.inputs.dartel_inputs = d_input if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( "Computational time for DARTEL creation will depend on the number of images." ) print_begin_image(f"group-{self.parameters['group_label']}") # fmt: off self.connect([(read_parameters_node, self.input_node, [("dartel_inputs", "dartel_input_images")])])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os import re import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe import clinica.utils.input_files as input_files from clinica.utils.exceptions import ClinicaCAPSError, ClinicaException from clinica.utils.filemanip import save_participants_sessions from clinica.utils.inputs import clinica_list_of_files_reader from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process # Read CAPS files list_caps_files = clinica_list_of_files_reader( self.subjects, self.sessions, self.caps_directory, [ # Inputs from t1-freesurfer pipeline input_files.T1_FS_WM, # list_caps_files[0] input_files.T1_FS_DESIKAN, # list_caps_files[1] input_files.T1_FS_DESTRIEUX, # list_caps_files[2] input_files.T1_FS_BRAIN, # list_caps_files[3] # Inputs from dwi-preprocessing pipeline input_files.DWI_PREPROC_NII, # list_caps_files[4] input_files.DWI_PREPROC_BRAINMASK, # list_caps_files[5] input_files.DWI_PREPROC_BVEC, # list_caps_files[6] input_files.DWI_PREPROC_BVAL, # list_caps_files[7] ], raise_exception=True, ) # Check space of DWI dataset dwi_file_spaces = [ re.search(".*_space-(.*)_preproc.nii.*", file, re.IGNORECASE).group(1) for file in list_caps_files[4] ] # Return an error if all the DWI files are not in the same space if any(a != dwi_file_spaces[0] for a in dwi_file_spaces): raise ClinicaCAPSError( "Preprocessed DWI files are not all in the same space. " "Please process them separately using the appropriate subjects/sessions `.tsv` file (-tsv option)." ) list_atlas_files = [ [aparc_aseg, aparc_aseg_a2009] for aparc_aseg, aparc_aseg_a2009 in zip( list_caps_files[1], list_caps_files[2] ) ] list_grad_fsl = [ (bvec, bval) for bvec, bval in zip(list_caps_files[6], list_caps_files[7]) ] # Save subjects to process in <WD>/<Pipeline.name>/participants.tsv folder_participants_tsv = os.path.join(self.base_dir, self.name) save_participants_sessions( self.subjects, self.sessions, folder_participants_tsv ) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( "Computational time will depend of the number of volumes in your DWI dataset and " "the number of streamlines you selected." ) if dwi_file_spaces[0] == "b0": self.parameters["dwi_space"] = "b0" read_node = npe.Node( name="ReadingFiles", iterables=[ ("wm_mask_file", list_caps_files[0]), ("t1_brain_file", list_caps_files[3]), ("dwi_file", list_caps_files[4]), ("dwi_brainmask_file", list_caps_files[5]), ("grad_fsl", list_grad_fsl), ("atlas_files", list_atlas_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields()), ) # fmt: off self.connect( [ (read_node, self.input_node, [("t1_brain_file", "t1_brain_file")]), (read_node, self.input_node, [("wm_mask_file", "wm_mask_file")]), (read_node, self.input_node, [("dwi_file", "dwi_file")]), (read_node, self.input_node, [("dwi_brainmask_file", "dwi_brainmask_file")]), (read_node, self.input_node, [("grad_fsl", "grad_fsl")]), (read_node, self.input_node, [("atlas_files", "atlas_files")]), ] ) # fmt: on elif dwi_file_spaces[0] == "T1w": self.parameters["dwi_space"] = "T1w" read_node = npe.Node( name="ReadingFiles", iterables=[ ("wm_mask_file", list_caps_files[0]), ("dwi_file", list_caps_files[4]), ("dwi_brainmask_file", list_caps_files[5]), ("grad_fsl", list_grad_fsl), ("atlas_files", list_atlas_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=self.get_input_fields()), ) # fmt: off self.connect( [ (read_node, self.input_node, [("wm_mask_file", "wm_mask_file")]), (read_node, self.input_node, [("dwi_file", "dwi_file")]), (read_node, self.input_node, [("dwi_brainmask_file", "dwi_brainmask_file")]), (read_node, self.input_node, [("grad_fsl", "grad_fsl")]), (read_node, self.input_node, [("atlas_files", "atlas_files")]), ] ) # fmt: on else: raise ClinicaCAPSError( "Bad preprocessed DWI space. Please check your CAPS folder." )
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe import clinica.utils.input_files as input_files from clinica.utils.filemanip import save_participants_sessions from clinica.utils.inputs import clinica_list_of_files_reader from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process list_caps_files = clinica_list_of_files_reader( self.subjects, self.sessions, self.caps_directory, [ input_files.DWI_PREPROC_NII, input_files.DWI_PREPROC_BVEC, input_files.DWI_PREPROC_BVAL, input_files.DWI_PREPROC_BRAINMASK, ], raise_exception=True, ) # Save subjects to process in <WD>/<Pipeline.name>/participants.tsv folder_participants_tsv = os.path.join(self.base_dir, self.name) save_participants_sessions(self.subjects, self.sessions, folder_participants_tsv) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( f"List available in {os.path.join(folder_participants_tsv, 'participants.tsv')}" ) cprint( "The pipeline will last approximately 20 minutes per image.") read_input_node = npe.Node( name="LoadingCLIArguments", interface=nutil.IdentityInterface(fields=self.get_input_fields(), mandatory_inputs=True), iterables=[ ("preproc_dwi", list_caps_files[0]), ("preproc_bvec", list_caps_files[1]), ("preproc_bval", list_caps_files[2]), ("b0_mask", list_caps_files[3]), ], synchronize=True, ) self.connect([ (read_input_node, self.input_node, [("b0_mask", "b0_mask")]), (read_input_node, self.input_node, [("preproc_dwi", "preproc_dwi") ]), (read_input_node, self.input_node, [("preproc_bval", "preproc_bval")]), (read_input_node, self.input_node, [("preproc_bvec", "preproc_bvec")]), ])
def build_input_node(self): """Build and connect an input node to the pipeline. """ from os import pardir from os.path import dirname, join, abspath, split, exists import sys import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.utils.inputs import check_bids_folder from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import T1W_NII from clinica.utils.inputs import fetch_file from clinica.utils.ux import print_images_to_process from clinica.utils.stream import cprint root = dirname(abspath(join(abspath(__file__), pardir, pardir))) path_to_mask = join(root, 'resources', 'masks') self.ref_template = join( path_to_mask, 'mni_icbm152_t1_tal_nlin_sym_09c.nii') self.ref_crop = join(path_to_mask, 'ref_cropped_template.nii.gz') url1 = "https://aramislab.paris.inria.fr/files/data/img_t1_linear/ref_cropped_template.nii.gz" url2 = "https://aramislab.paris.inria.fr/files/data/img_t1_linear/mni_icbm152_t1_tal_nlin_sym_09c.nii" if not(exists(self.ref_template)): try: fetch_file(url2, self.ref_template) except IOError as err: cprint('Unable to download required template (mni_icbm152) for processing:', err) if not(exists(self.ref_crop)): try: fetch_file(url1, self.ref_crop) except IOError as err: cprint('Unable to download required template (ref_crop) for processing:', err) # Inputs from anat/ folder # ======================== # T1w file: try: t1w_files = clinica_file_reader( self.subjects, self.sessions, self.bids_directory, T1W_NII) except ClinicaException as e: err = 'Clinica faced error(s) while trying to read files in your BIDS directory.\n' + str(e) raise ClinicaBIDSError(err) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint('The pipeline will last approximately 6 minutes per image.') read_node = npe.Node( name="ReadingFiles", iterables=[ ('t1w', t1w_files), ], synchronize=True, interface=nutil.IdentityInterface( fields=self.get_input_fields()) ) self.connect([ (read_node, self.input_node, [('t1w', 't1w')]), ])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os from os.path import exists, join import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.iotools.utils.data_handling import ( check_relative_volume_location_in_world_coordinate_system, ) from clinica.utils.exceptions import ClinicaException from clinica.utils.filemanip import save_participants_sessions from clinica.utils.input_files import ( T1W_NII, bids_pet_nii, t1_volume_deformation_to_template, t1_volume_final_group_template, t1_volume_native_tpm, t1_volume_native_tpm_in_mni, ) from clinica.utils.inputs import clinica_file_reader, clinica_group_reader from clinica.utils.pet import get_suvr_mask, read_psf_information from clinica.utils.stream import cprint from clinica.utils.ux import ( print_groups_in_caps_directory, print_images_to_process, ) # Check that group already exists if not exists( join(self.caps_directory, "groups", f"group-{self.parameters['group_label']}")): print_groups_in_caps_directory(self.caps_directory) raise ClinicaException( f"Group {self.parameters['group_label']} does not exist. " "Did you run t1-volume or t1-volume-create-dartel pipeline?") # Tissues DataGrabber # ==================== all_errors = [] # Grab reference mask reference_mask_file = get_suvr_mask( self.parameters["suvr_reference_region"]) # PET from BIDS directory try: pet_bids = clinica_file_reader( self.subjects, self.sessions, self.bids_directory, bids_pet_nii(self.parameters["acq_label"]), ) except ClinicaException as e: all_errors.append(e) # Native T1w-MRI try: t1w_bids = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, T1W_NII) except ClinicaException as e: all_errors.append(e) # mask_tissues tissues_input = [] for tissue_number in self.parameters["mask_tissues"]: try: current_file = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_native_tpm_in_mni(tissue_number, False), ) tissues_input.append(current_file) except ClinicaException as e: all_errors.append(e) # Tissues_input has a length of len(self.parameters['mask_tissues']). Each of these elements has a size of # len(self.subjects). We want the opposite: a list of size len(self.subjects) whose elements have a size of # len(self.parameters['mask_tissues']. The trick is to iter on elements with zip(*my_list) tissues_input_final = [] for subject_tissue_list in zip(*tissues_input): tissues_input_final.append(subject_tissue_list) tissues_input = tissues_input_final # Flowfields try: flowfields_caps = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_deformation_to_template( self.parameters["group_label"]), ) except ClinicaException as e: all_errors.append(e) # Dartel Template try: final_template = clinica_group_reader( self.caps_directory, t1_volume_final_group_template(self.parameters["group_label"]), ) except ClinicaException as e: all_errors.append(e) if self.parameters["pvc_psf_tsv"] is not None: iterables_psf = read_psf_information( self.parameters["pvc_psf_tsv"], self.subjects, self.sessions, self.parameters["acq_label"], ) self.parameters["apply_pvc"] = True else: iterables_psf = [[]] * len(self.subjects) self.parameters["apply_pvc"] = False if self.parameters["apply_pvc"]: # pvc tissues input pvc_tissues_input = [] for tissue_number in self.parameters["pvc_mask_tissues"]: try: current_file = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, t1_volume_native_tpm(tissue_number), ) pvc_tissues_input.append(current_file) except ClinicaException as e: all_errors.append(e) if len(all_errors) == 0: pvc_tissues_input_final = [] for subject_tissue_list in zip(*pvc_tissues_input): pvc_tissues_input_final.append(subject_tissue_list) pvc_tissues_input = pvc_tissues_input_final else: pvc_tissues_input = [] if len(all_errors) > 0: error_message = "Clinica faced error(s) while trying to read files in your CAPS/BIDS directories.\n" for msg in all_errors: error_message += str(msg) raise ClinicaException(error_message) check_relative_volume_location_in_world_coordinate_system( "T1w-MRI", t1w_bids, self.parameters["acq_label"] + " PET", pet_bids, self.bids_directory, self.parameters["acq_label"], skip_question=self.parameters["skip_question"], ) # Save subjects to process in <WD>/<Pipeline.name>/participants.tsv folder_participants_tsv = os.path.join(self.base_dir, self.name) save_participants_sessions(self.subjects, self.sessions, folder_participants_tsv) if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint("List available in %s" % os.path.join(folder_participants_tsv, "participants.tsv")) cprint( "The pipeline will last approximately 10 minutes per image.") read_input_node = npe.Node( name="LoadingCLIArguments", interface=nutil.IdentityInterface(fields=self.get_input_fields(), mandatory_inputs=True), iterables=[ ("pet_image", pet_bids), ("t1_image_native", t1w_bids), ("mask_tissues", tissues_input), ("psf", iterables_psf), ("flow_fields", flowfields_caps), ("pvc_mask_tissues", pvc_tissues_input), ], synchronize=True, ) read_input_node.inputs.reference_mask = reference_mask_file read_input_node.inputs.dartel_template = final_template # fmt: off self.connect([(read_input_node, self.input_node, [("pet_image", "pet_image"), ("t1_image_native", "t1_image_native"), ("mask_tissues", "mask_tissues"), ("flow_fields", "flow_fields"), ("dartel_template", "dartel_template"), ("reference_mask", "reference_mask"), ("psf", "psf"), ("pvc_mask_tissues", "pvc_mask_tissues")])])
def build_input_node(self): """Build and connect an input node to the pipeline.""" import os from colorama import Fore import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe from clinica.iotools.utils.data_handling import check_volume_location_in_world_coordinate_system from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.filemanip import extract_subjects_sessions_from_filename, save_participants_sessions from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import T1W_NII from clinica.utils.stream import cprint from clinica.utils.ux import print_images_to_process, print_begin_image gic = '*' if self.parameters['group_id_caps'] is not None: gic = self.parameters['group_id_caps'] all_errors = [] if self.parameters['feature_type'] == 'fdg': try: input_files = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, { 'pattern': '*_pet_space-Ixi549Space_suvr-pons_mask-brain_fwhm-' + str(self.parameters['full_width_at_half_maximum']) + 'mm_pet.nii*', 'description': 'pons normalized FDG PET image in MNI space (brain masked)', 'needed_pipeline': 'pet-volume' }) except ClinicaException as e: all_errors.append(e) elif self.parameters['feature_type'] == 'graymatter': try: input_files = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, { 'pattern': 't1/spm/dartel/group-' + gic + '/*_T1w_segm-graymatter_space-Ixi549Space_modulated-on_fwhm-' + str(self.parameters['full_width_at_half_maximum']) + 'mm_probability.nii.*', 'description': 'probability map of gray matter segmentation based on T1w image in MNI space', 'needed_pipeline': 't1-volume or t1-volume-existing-template' }) except ClinicaException as e: all_errors.append(e) else: if not self.parameters['custom_files']: raise ClinicaException( Fore.RED + '[Error] You did not specify the --custom_files flag in the command line for the feature type ' + Fore.Blue + self.parameters['feature_type'] + Fore.RED + '! Clinica can\'t ' + 'know what file to use in your analysis ! Type: \n\t' + Fore.BLUE + 'clinica run statistics-volume\n' + Fore.RED + ' to have help on how to use the command line.' + Fore.RESET) try: # If custom file are grabbed, information of fwhm is irrelevant and should not appear on final filenames self.parameters['full_width_at_half_maximum'] = None input_files = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, { 'pattern': self.parameters['custom_files'], 'description': 'custom file provided by user' }) except ClinicaException as e: all_errors.append(e) if len(all_errors) > 0: error_message = 'Clinica faced errors while trying to read files in your BIDS or CAPS directories.\n' for msg in all_errors: error_message += str(msg) raise ClinicaException(error_message) read_parameters_node = npe.Node(name="LoadingCLIArguments", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True), synchronize=True) read_parameters_node.inputs.input_files = input_files if len(self.subjects): print_images_to_process(self.subjects, self.sessions) cprint( 'The pipeline will last a few minutes. Images generated by SPM will popup during the pipeline.' ) print_begin_image('group-' + self.parameters['group_id']) self.connect([(read_parameters_node, self.input_node, [('input_files', 'input_files')])])