def get_processed_images(caps_directory, subjects, sessions): import os import re from clinica.utils.input_files import T1_FS_T_DESTRIEUX from clinica.utils.inputs import clinica_file_reader from clinica.utils.longitudinal import get_long_id from clinica.utils.participant import get_unique_subjects [list_participant_id, list_list_session_ids] = get_unique_subjects( subjects, sessions ) list_long_id = [ get_long_id(list_session_ids) for list_session_ids in list_list_session_ids ] image_ids = [] if os.path.isdir(caps_directory): t1_freesurfer_files = clinica_file_reader( list_participant_id, list_long_id, caps_directory, T1_FS_T_DESTRIEUX, False, ) image_ids = [ re.search(r"(sub-[a-zA-Z0-9]+)_(long-[a-zA-Z0-9]+)", file).group() for file in t1_freesurfer_files ] return image_ids
def _get_full_image(self) -> torch.Tensor: """ Allows to get the an example of the image mode corresponding to the dataset. Useful to compute the number of elements if mode != image. Returns: image tensor of the full image first image. """ import nibabel as nib from clinica.utils.inputs import clinica_file_reader participant_id = self.df.loc[0, "participant_id"] session_id = self.df.loc[0, "session_id"] cohort = self.df.loc[0, "cohort"] try: image_path = self._get_image_path(participant_id, session_id, cohort) image = torch.load(image_path) except IndexError: file_type = self.preprocessing_dict["file_type"] results = clinica_file_reader([participant_id], [session_id], self.caps_dict[cohort], file_type) image_nii = nib.load(results[0]) image_np = image_nii.get_fdata() image = ToTensor()(image_np) return 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 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 get_to_process_with_atlases(caps_directory: str, subjects: list, sessions: list, atlas_dir_path: str) -> list: import itertools import os from pathlib import Path from clinica.utils.filemanip import extract_image_ids from clinica.utils.input_files import T1_FS_DESTRIEUX from clinica.utils.inputs import clinica_file_reader initial_list_to_process = [] atlas_list = [] for path in Path(atlas_dir_path).rglob("*rh*6p0.gcs"): atlas_name = path.name.split(".")[1].split("_")[0] atlas_list.append(atlas_name) if os.path.isdir(caps_directory): for atlas in atlas_list: atlas_info = dict({ "pattern": "t1/freesurfer_cross_sectional/sub-*_ses-*/stats/rh." + atlas + ".stats", "description": atlas + "-based segmentation", "needed_pipeline": "t1-freesurfer", }) t1_freesurfer_output = clinica_file_reader( subjects, sessions, caps_directory, T1_FS_DESTRIEUX, False) t1_freesurfer_files = clinica_file_reader( subjects, sessions, caps_directory, atlas_info, False) image_ids = extract_image_ids(t1_freesurfer_files) image_ids_2 = extract_image_ids(t1_freesurfer_output) to_process = list(set(image_ids_2) - set(image_ids)) initial_list_to_process.append(([atlas], to_process)) list_to_process = [] for i in initial_list_to_process: if list(itertools.product(i[0], i[1])) != []: list_to_process = list_to_process + list( itertools.product(i[0], i[1])) return list_to_process
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.""" 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 get_images(self): """ Returns: a list of filenames """ from clinica.utils.input_files import pet_volume_normalized_suvr_pet from clinica.utils.inputs import clinica_file_reader if self._images is not None: return self._images if self._input_params["image_type"] == "T1w": if self._input_params["fwhm"] == 0: fwhm_key_value = "" else: fwhm_key_value = f"_fwhm-{self._input_params['fwhm']}mm" self._images = [ path.join( self._input_params["caps_directory"], "subjects", self._subjects[i], self._sessions[i], "t1", "spm", "dartel", f"group-{self._input_params['group_label']}", f"{self._subjects[i]}_{self._sessions[i]}_T1w" f"_segm-graymatter_space-Ixi549Space_modulated-{self._input_params['modulated']}{fwhm_key_value}_probability.nii.gz", ) for i in range(len(self._subjects)) ] for image in self._images: if not path.exists(image): raise Exception("File %s doesn't exists." % image) elif self._input_params["image_type"] == "PET": caps_files_information = pet_volume_normalized_suvr_pet( acq_label=self._input_params["acq_label"], group_label=self._input_params["group_label"], suvr_reference_region=self. _input_params["suvr_reference_region"], use_brainmasked_image=True, use_pvc_data=self._input_params["use_pvc_data"], fwhm=self._input_params["fwhm"], ) self._images = clinica_file_reader( self._subjects, self._sessions, self._input_params["caps_directory"], caps_files_information, ) else: raise ValueError( f"Unknown image type (given value: {self._input_params['image_type']})" ) return self._images
def _get_image_path(self, participant: str, session: str, cohort: str) -> str: """ Gets the path to the tensor image (*.pt) Args: participant: ID of the participant. session: ID of the session. cohort: Name of the cohort. Returns: image_path: path to the tensor containing the whole image. """ from clinica.utils.inputs import clinica_file_reader # Try to find .nii.gz file try: file_type = self.preprocessing_dict["file_type"] results = clinica_file_reader([participant], [session], self.caps_dict[cohort], file_type) filepath = results[0] image_filename = path.basename(filepath[0]).replace( ".nii.gz", ".pt") folder, _ = compute_folder_and_file_type(self.preprocessing_dict) image_dir = path.join( self.caps_dict[cohort], "subjects", participant, session, "deeplearning_prepare_data", "image_based", folder, ) image_path = path.join(image_dir, image_filename) # Try to find .pt file except ClinicaCAPSError: file_type = self.preprocessing_dict["file_type"] file_type["pattern"] = file_type["pattern"].replace( ".nii.gz", ".pt") results = clinica_file_reader([participant], [session], self.caps_dict[cohort], file_type) filepath = results[0] image_path = filepath[0] return image_path
def get_processed_images(caps_directory, subjects, sessions): import os from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import T1_FS_DESTRIEUX from clinica.utils.filemanip import extract_image_ids image_ids = [] if os.path.isdir(caps_directory): t1_freesurfer_files = clinica_file_reader(subjects, sessions, caps_directory, T1_FS_DESTRIEUX, False) image_ids = extract_image_ids(t1_freesurfer_files) return image_ids
def get_processed_images(caps_directory, subjects, sessions): import os from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import T1W_LINEAR_CROPPED from clinica.utils.filemanip import extract_image_ids image_ids = [] if os.path.isdir(caps_directory): cropped_files = clinica_file_reader(subjects, sessions, caps_directory, T1W_LINEAR_CROPPED, False) image_ids = extract_image_ids(cropped_files) return image_ids
def get_processed_images(caps_directory, subjects, sessions): import os from clinica.utils.filemanip import extract_image_ids from clinica.utils.input_files import DWI_PREPROC_NII from clinica.utils.inputs import clinica_file_reader image_ids = [] if os.path.isdir(caps_directory): preproc_files = clinica_file_reader(subjects, sessions, caps_directory, DWI_PREPROC_NII, False) image_ids = extract_image_ids(preproc_files) return image_ids
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 __getitem__(self, idx): if self.use_extracted_tensors: image = self.tensor_dataset[idx] image = self.pt_transform(image) else: subject = self.df.loc[idx, "participant_id"] session = self.df.loc[idx, "session_id"] image_path = clinica_file_reader([subject], [session], self.img_dir, T1W_LINEAR_CROPPED)[0] image = nib.load(image_path[0]) image = self.nii_transform(image) sample = { "image": image, "participant_id": subject, "session_id": session } return sample
def get_processed_images(caps_directory, subjects, sessions): import os from clinica.utils.filemanip import extract_image_ids from clinica.utils.inputs import clinica_file_reader information = { "pattern": os.path.join( "t1_extensive", "*_*_space-Ixi549Space_desc-SkullStripped_T1w.nii*", ), "description": "Skull-stripped T1w in Ixi549Space space.", "needed_pipeline": "t1-volume-tissue-segmentation", } image_ids = [] if os.path.isdir(caps_directory): skull_stripped_files = clinica_file_reader(subjects, sessions, caps_directory, information, False) image_ids = extract_image_ids(skull_stripped_files) return image_ids
def build_input_node(self): """Build and connect an input node to the pipelines. """ import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe import clinica.utils.input_files as input_files from clinica.utils.dwi import check_dwi_volume from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.inputs import clinica_file_reader all_errors = [] try: t1w_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, input_files.T1W_NII) except ClinicaException as e: all_errors.append(e) try: dwi_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, input_files.DWI_NII) except ClinicaException as e: all_errors.append(e) # bval files try: bval_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, input_files.DWI_BVAL) except ClinicaException as e: all_errors.append(e) # bvec files try: bvec_files = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, input_files.DWI_BVEC) 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 BIDS directory.\n' for msg in all_errors: error_message += str(msg) raise ClinicaBIDSError(error_message) # Perform the check after potential issue while reading inputs for (dwi, bvec, bval) in zip(dwi_files, bvec_files, bval_files): check_dwi_volume(in_dwi=dwi, in_bvec=bvec, in_bval=bval) read_input_node = npe.Node(name="LoadingCLIArguments", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True), iterables=[('T1w', t1w_files), ('dwi', dwi_files), ('bvec', bvec_files), ('bval', bval_files)], synchronize=True) self.connect([ (read_input_node, self.input_node, [('T1w', 'T1w')]), (read_input_node, self.input_node, [('dwi', 'dwi')]), (read_input_node, self.input_node, [('bvec', 'bvec')]), (read_input_node, self.input_node, [('bval', 'bval')]) ])
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.""" 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 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 DeepLearningPrepareData(caps_directory, tsv_file, n_proc, parameters): import os from os import path from clinica.utils.inputs import check_caps_folder, clinica_file_reader from clinica.utils.nipype import container_from_filename from clinica.utils.participant import get_subject_session_list from joblib import Parallel, delayed from torch import save as save_tensor from clinicadl.utils.exceptions import ClinicaDLArgumentError from clinicadl.utils.preprocessing import write_preprocessing from .extract_utils import check_mask_list, compute_folder_and_file_type logger = getLogger("clinicadl") # Get subject and session list check_caps_folder(caps_directory) logger.debug(f"CAPS directory : {caps_directory}.") is_bids_dir = False sessions, subjects = get_subject_session_list(caps_directory, tsv_file, is_bids_dir, False, None) if parameters["prepare_dl"]: logger.info( f"{parameters['mode']}s will be extracted in Pytorch tensor from {len(sessions)} images." ) else: logger.info( f"Images will be extracted in Pytorch tensor from {len(sessions)} images." ) logger.info( f"Information for {parameters['mode']} will be saved in output JSON file and will be used " f"during training for on-the-fly extraction.") logger.debug(f"List of subjects: \n{subjects}.") logger.debug(f"List of sessions: \n{sessions}.") # Select the correct filetype corresponding to modality # and select the right folder output name corresponding to modality logger.debug( f"Selected images are preprocessed with {parameters['preprocessing']} pipeline`." ) mod_subfolder, file_type = compute_folder_and_file_type(parameters) parameters["file_type"] = file_type # Input file: input_files = clinica_file_reader(subjects, sessions, caps_directory, file_type)[0] def write_output_imgs(output_mode, container, subfolder): # Write the extracted tensor on a .pt file for filename, tensor in output_mode: output_file_dir = path.join( caps_directory, container, "deeplearning_prepare_data", subfolder, mod_subfolder, ) if not path.exists(output_file_dir): os.makedirs(output_file_dir) output_file = path.join(output_file_dir, filename) save_tensor(tensor, output_file) logger.debug(f" Output tensor saved at {output_file}") if parameters["mode"] == "image" or not parameters["prepare_dl"]: def prepare_image(file): from .extract_utils import extract_images logger.debug(f" Processing of {file}.") container = container_from_filename(file) subfolder = "image_based" output_mode = extract_images(file) logger.debug(f" Image extracted.") write_output_imgs(output_mode, container, subfolder) Parallel(n_jobs=n_proc)(delayed(prepare_image)(file) for file in input_files) elif parameters["prepare_dl"] and parameters["mode"] == "slice": def prepare_slice(file): from .extract_utils import extract_slices logger.debug(f" Processing of {file}.") container = container_from_filename(file) subfolder = "slice_based" output_mode = extract_slices( file, slice_direction=parameters["slice_direction"], slice_mode=parameters["slice_mode"], discarded_slices=parameters["discarded_slices"], ) logger.debug(f" {len(output_mode)} slices extracted.") write_output_imgs(output_mode, container, subfolder) Parallel(n_jobs=n_proc)(delayed(prepare_slice)(file) for file in input_files) elif parameters["prepare_dl"] and parameters["mode"] == "patch": def prepare_patch(file): from .extract_utils import extract_patches logger.debug(f" Processing of {file}.") container = container_from_filename(file) subfolder = "patch_based" output_mode = extract_patches( file, patch_size=parameters["patch_size"], stride_size=parameters["stride_size"], ) logger.debug(f" {len(output_mode)} patches extracted.") write_output_imgs(output_mode, container, subfolder) Parallel(n_jobs=n_proc)(delayed(prepare_patch)(file) for file in input_files) elif parameters["prepare_dl"] and parameters["mode"] == "roi": def prepare_roi(file): from .extract_utils import extract_roi logger.debug(f" Processing of {file}.") container = container_from_filename(file) subfolder = "roi_based" if parameters["preprocessing"] == "custom": if not parameters["roi_custom_template"]: raise ClinicaDLArgumentError( "A custom template must be defined when the modality is set to custom." ) parameters["roi_template"] = parameters["roi_custom_template"] parameters["roi_mask_pattern"] = parameters[ "roi_custom_mask_pattern"] else: from .extract_utils import PATTERN_DICT, TEMPLATE_DICT parameters["roi_template"] = TEMPLATE_DICT[ parameters["preprocessing"]] parameters["roi_mask_pattern"] = PATTERN_DICT[ parameters["preprocessing"]] parameters["masks_location"] = path.join( caps_directory, "masks", f"tpl-{parameters['roi_template']}") if len(parameters["roi_list"]) == 0: raise ClinicaDLArgumentError( "A list of regions of interest must be given.") else: check_mask_list( parameters["masks_location"], parameters["roi_list"], parameters["roi_mask_pattern"], None if parameters["use_uncropped_image"] is None else not parameters["use_uncropped_image"], ) output_mode = extract_roi( file, masks_location=parameters["masks_location"], mask_pattern=parameters["roi_mask_pattern"], cropped_input=None if parameters["use_uncropped_image"] is None else not parameters["use_uncropped_image"], roi_names=parameters["roi_list"], uncrop_output=parameters["uncropped_roi"], ) logger.debug(f" ROI extracted.") write_output_imgs(output_mode, container, subfolder) Parallel(n_jobs=n_proc)(delayed(prepare_roi)(file) for file in input_files) else: raise NotImplementedError( f"Extraction is not implemented for mode {parameters['mode']}.") # Save parameters dictionary preprocessing_json_path = write_preprocessing(parameters, caps_directory) logger.info(f"Preprocessing JSON saved at {preprocessing_json_path}.")
def build_input_node_longitudinal(self): import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe import clinica.utils.input_files as input_files from clinica.iotools.utils.data_handling import ( check_relative_volume_location_in_world_coordinate_system, ) from clinica.utils.exceptions import ClinicaException from clinica.utils.inputs import clinica_file_reader read_parameters_node = npe.Node( name="LoadingCLIArguments", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True ), synchronize=True, ) all_errors = [] try: read_parameters_node.inputs.pet = clinica_file_reader( self.subjects, self.sessions, self.bids_directory, input_files.bids_pet_nii(self.parameters["acq_label"]), ) except ClinicaException as e: all_errors.append(e) try: read_parameters_node.inputs.orig_nu = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_LONG_ORIG_NU, ) except ClinicaException as e: all_errors.append(e) try: read_parameters_node.inputs.white_surface_right = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_LONG_SURF_R, ) except ClinicaException as e: all_errors.append(e) try: read_parameters_node.inputs.white_surface_left = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_LONG_SURF_L, ) except ClinicaException as e: all_errors.append(e) try: read_parameters_node.inputs.destrieux_left = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_LONG_DESTRIEUX_PARC_L, ) except ClinicaException as e: all_errors.append(e) try: read_parameters_node.inputs.destrieux_right = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_LONG_DESTRIEUX_PARC_R, ) except ClinicaException as e: all_errors.append(e) try: read_parameters_node.inputs.desikan_left = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_LONG_DESIKAN_PARC_L, ) except ClinicaException as e: all_errors.append(e) try: read_parameters_node.inputs.desikan_right = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_LONG_DESIKAN_PARC_R, ) 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) check_relative_volume_location_in_world_coordinate_system( "T1w-MRI (orig_nu.mgz)", read_parameters_node.inputs.orig_nu, self.parameters["acq_label"] + " PET", read_parameters_node.inputs.pet, self.bids_directory, self.parameters["acq_label"], ) # fmt: off self.connect( [ (read_parameters_node, self.input_node, [("pet", "pet"), ("orig_nu", "orig_nu"), ("white_surface_left", "white_surface_left"), ("white_surface_right", "white_surface_right"), ("destrieux_left", "destrieux_left"), ("destrieux_right", "destrieux_right"), ("desikan_left", "desikan_left"), ("desikan_right", "desikan_right")]) ] )
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 DeepLearningPrepareData(caps_directory, tsv_file, parameters): import os from os import path from clinica.utils.exceptions import ( ClinicaBIDSError, ClinicaCAPSError, ClinicaException, ) from clinica.utils.input_files import ( T1W_EXTENSIVE, T1W_LINEAR, T1W_LINEAR_CROPPED, pet_linear_nii, ) from clinica.utils.inputs import check_caps_folder, clinica_file_reader from clinica.utils.nipype import container_from_filename from clinica.utils.participant import get_subject_session_list from torch import save as save_tensor from clinicadl.utils.preprocessing import write_preprocessing from .extract_utils import ( check_mask_list, extract_images, extract_patches, extract_roi, extract_slices, ) logger = getLogger("clinicadl") # Get subject and session list check_caps_folder(caps_directory) input_dir = caps_directory logger.debug(f"CAPS directory : {input_dir}.") is_bids_dir = False sessions, subjects = get_subject_session_list(input_dir, tsv_file, is_bids_dir, False, None) logger.info( f"{parameters['mode']}s will be extracted in Pytorch tensor from {len(sessions)} images." ) logger.debug(f"List of subjects: \n{subjects}.") logger.debug(f"List of sessions: \n{sessions}.") # Select the correct filetype corresponding to modality # and select the right folder output name corresponding to modality logger.debug( f"Selected images are preprocessed with {parameters['preprocessing']} pipeline`." ) if parameters["preprocessing"] == "t1-linear": mod_subfolder = "t1_linear" if parameters["use_uncropped_image"]: FILE_TYPE = T1W_LINEAR else: FILE_TYPE = T1W_LINEAR_CROPPED if parameters["preprocessing"] == "t1-extensive": mod_subfolder = "t1_extensive" FILE_TYPE = T1W_EXTENSIVE parameters["uncropped_image"] = None if parameters["preprocessing"] == "pet-linear": mod_subfolder = "pet_linear" FILE_TYPE = pet_linear_nii( parameters["acq_label"], parameters["suvr_reference_region"], parameters["use_uncropped_image"], ) if parameters["preprocessing"] == "custom": mod_subfolder = "custom" FILE_TYPE = { "pattern": f"*{parameters['custom_suffix']}", "description": "Custom suffix", } parameters["use_uncropped_image"] = None parameters["file_type"] = FILE_TYPE # Input file: input_files = clinica_file_reader(subjects, sessions, caps_directory, FILE_TYPE) # Loop on the images for file in input_files: logger.debug(f" Processing of {file}.") container = container_from_filename(file) # Extract the wanted tensor if parameters["mode"] == "image": subfolder = "image_based" output_mode = extract_images(file) logger.debug(f" Image extracted.") elif parameters["mode"] == "slice": subfolder = "slice_based" output_mode = extract_slices( file, slice_direction=parameters["slice_direction"], slice_mode=parameters["slice_mode"], discarded_slices=parameters["discarded_slices"], ) logger.debug(f" {len(output_mode)} slices extracted.") elif parameters["mode"] == "patch": subfolder = "patch_based" output_mode = extract_patches( file, patch_size=parameters["patch_size"], stride_size=parameters["stride_size"], ) logger.debug(f" {len(output_mode)} patches extracted.") elif parameters["mode"] == "roi": subfolder = "roi_based" if parameters["preprocessing"] == "custom": parameters["roi_template"] = parameters["roi_custom_template"] if parameters["roi_custom_template"] is None: raise ValueError( "A custom template must be defined when the modality is set to custom." ) else: from .extract_utils import TEMPLATE_DICT parameters["roi_template"] = TEMPLATE_DICT[ parameters["preprocessing"]] parameters["masks_location"] = path.join( caps_directory, "masks", f"tpl-{parameters['roi_template']}") if len(parameters["roi_list"]) == 0: raise ValueError("A list of regions must be given.") else: check_mask_list( parameters["masks_location"], parameters["roi_list"], parameters["roi_custom_mask_pattern"], None if parameters["use_uncropped_image"] is None else not parameters["use_uncropped_image"], ) output_mode = extract_roi( file, masks_location=parameters["masks_location"], mask_pattern=parameters["roi_custom_mask_pattern"], cropped_input=None if parameters["use_uncropped_image"] is None else not parameters["use_uncropped_image"], roi_list=parameters["roi_list"], uncrop_output=parameters["uncropped_roi"], ) logger.debug(f" ROI extracted.") # Write the extracted tensor on a .pt file for tensor in output_mode: output_file_dir = path.join( caps_directory, container, "deeplearning_prepare_data", subfolder, mod_subfolder, ) if not path.exists(output_file_dir): os.makedirs(output_file_dir) output_file = path.join(output_file_dir, tensor[0]) save_tensor(tensor[1], output_file) logger.debug(f" Output tensor saved at {output_file}") # Save parameters dictionary preprocessing_json_path = write_preprocessing(parameters, caps_directory) logger.info(f"Preprocessing JSON saved at {preprocessing_json_path}.")
def preprocessing_t1w(bids_directory, caps_directory, tsv, working_directory=None): """ This preprocessing pipeline includes globally three steps: 1) N4 bias correction (performed with ANTS). 2) Linear registration to MNI (MNI icbm152 nlinear sym template) (performed with ANTS) - RegistrationSynQuick. 3) Cropping the background (in order to save computational power). 4) Histogram-based intensity normalization. This is a custom function performed by the binary ImageMath included with ANTS. Parameters ---------- bids_directory: str Folder with BIDS structure. caps_directory: str Folder where CAPS structure will be stored. working_directory: str Folder containing a temporary space to save intermediate results. """ from clinica.utils.inputs import check_bids_folder from clinica.utils.participant import get_subject_session_list from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import T1W_NII from clinicadl.tools.inputs.input import fetch_file from os.path import dirname, join, abspath, split, exists from os import pardir check_bids_folder(bids_directory) input_dir = bids_directory is_bids_dir = True base_dir = working_directory root = dirname(abspath(join(abspath(__file__), pardir))) path_to_mask = join(root, 'resources', 'masks') ref_template = join(path_to_mask, 'mni_icbm152_t1_tal_nlin_sym_09c.nii') 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(ref_template)): try: fetch_file(url2, ref_template) except IOError as err: print( 'Unable to download required template (mni_icbm152) for processing:', err) if not (exists(ref_crop)): try: fetch_file(url1, ref_crop) except IOError as err: print( 'Unable to download required template (ref_crop) for processing:', err) sessions, subjects = get_subject_session_list(input_dir, tsv, is_bids_dir, False, base_dir) from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException from clinica.utils.inputs import clinica_file_reader from clinica.utils.input_files import T1W_NII import nipype.pipeline.engine as npe import nipype.interfaces.utility as nutil from nipype.interfaces import ants from clinica.utils.filemanip import get_subject_id # Inputs from anat/ folder # ======================== # T1w file: try: t1w_files = clinica_file_reader(subjects, sessions, bids_directory, T1W_NII) except ClinicaException as e: err = 'Clinica faced error(s) while trying to read files in your CAPS directory.\n' + str( e) raise ClinicaBIDSError(err) def get_input_fields(): """"Specify the list of possible inputs of this pipelines. Returns: A list of (string) input fields name. """ return ['t1w'] read_node = npe.Node( name="ReadingFiles", iterables=[ ('t1w', t1w_files), ], synchronize=True, interface=nutil.IdentityInterface(fields=get_input_fields())) image_id_node = npe.Node(interface=nutil.Function( input_names=['bids_or_caps_file'], output_names=['image_id'], function=get_subject_id), name='ImageID') ## The core (processing) nodes # 1. N4biascorrection by ANTS. It uses nipype interface. n4biascorrection = npe.Node(name='n4biascorrection', interface=ants.N4BiasFieldCorrection( dimension=3, save_bias=True, bspline_fitting_distance=600)) # 2. `RegistrationSynQuick` by *ANTS*. It uses nipype interface. ants_registration_node = npe.Node(name='antsRegistrationSynQuick', interface=ants.RegistrationSynQuick()) ants_registration_node.inputs.fixed_image = ref_template ants_registration_node.inputs.transform_type = 'a' ants_registration_node.inputs.dimension = 3 # 3. Crop image (using nifti). It uses custom interface, from utils file from .T1_linear_utils import crop_nifti cropnifti = npe.Node(name='cropnifti', interface=nutil.Function( function=crop_nifti, input_names=['input_img', 'ref_crop'], output_names=['output_img', 'crop_template'])) cropnifti.inputs.ref_crop = ref_crop #### Deprecrecated #### #### This step was not used in the final version #### # 4. Histogram-based intensity normalization. This is a custom function # performed by the binary `ImageMath` included with *ANTS*. # from .T1_linear_utils import ants_histogram_intensity_normalization # # ## histogram-based intensity normalization # intensitynorm = npe.Node( # name='intensitynormalization', # interface=nutil.Function( # input_names=['image_dimension', 'crop_template', 'input_img'], # output_names=['output_img'], # function=ants_histogram_intensity_normalization # ) # ) # intensitynorm.inputs.image_dimension = 3 ## DataSink and the output node from .T1_linear_utils import (container_from_filename, get_data_datasink) # Create node to write selected files into the CAPS from nipype.interfaces.io import DataSink get_ids = npe.Node(interface=nutil.Function( input_names=['image_id'], output_names=['image_id_out', 'subst_ls'], function=get_data_datasink), name="GetIDs") # Find container path from t1w filename # ===================================== container_path = npe.Node(nutil.Function( input_names=['bids_or_caps_filename'], output_names=['container'], function=container_from_filename), name='ContainerPath') write_node = npe.Node(name="WriteCaps", interface=DataSink()) write_node.inputs.base_directory = caps_directory write_node.inputs.parameterization = False ## Connectiong the workflow from clinica.utils.nipype import fix_join wf = npe.Workflow(name='t1_linear_dl', base_dir=working_directory) wf.connect([ (read_node, image_id_node, [('t1w', 'bids_or_caps_file')]), (read_node, container_path, [('t1w', 'bids_or_caps_filename')]), (image_id_node, ants_registration_node, [('image_id', 'output_prefix') ]), (read_node, n4biascorrection, [("t1w", "input_image")]), (n4biascorrection, ants_registration_node, [('output_image', 'moving_image')]), (ants_registration_node, cropnifti, [('warped_image', 'input_img')]), (ants_registration_node, write_node, [('out_matrix', 'affine_mat')]), # Connect to DataSink (container_path, write_node, [(('container', fix_join, 't1_linear'), 'container')]), (image_id_node, get_ids, [('image_id', 'image_id')]), (get_ids, write_node, [('image_id_out', '@image_id')]), (get_ids, write_node, [('subst_ls', 'substitutions')]), #(get_ids, write_node, [('regexp_subst_ls', 'regexp_substitutions')]), (n4biascorrection, write_node, [('output_image', '@outfile_corr')]), (ants_registration_node, write_node, [('warped_image', '@outfile_reg') ]), (cropnifti, write_node, [('output_img', '@outfile_crop')]), ]) return wf
def build_input_node(self): """Build and connect an input node to the pipelines. References: https://lcni.uoregon.edu/kb-articles/kb-0003 """ import nipype.interfaces.utility as nutil import nipype.pipeline.engine as npe import json import numpy as np from clinica.utils.stream import cprint from clinica.utils.inputs import clinica_file_reader from clinica.utils.exceptions import ClinicaBIDSError, ClinicaException import clinica.utils.input_files as input_files # Reading BIDS files # ================== read_node = npe.Node(name="ReadingBIDS", interface=nutil.IdentityInterface( fields=self.get_input_fields(), mandatory_inputs=True)) # Store all the potentials errors all_errors = [] if ('unwarping' in self.parameters) and self.parameters['unwarping']: # Magnitude 1 file try: read_node.inputs.magnitude1 = clinica_file_reader( self.subjects, self.sessions, self.bids_directory, input_files.FMAP_MAGNITUDE1_NII) except ClinicaException as e: all_errors.append(e) # Phasediff file try: read_node.inputs.phasediff = clinica_file_reader( self.subjects, self.sessions, self.bids_directory, input_files.FMAP_PHASEDIFF_NII) except ClinicaException as e: all_errors.append(e) # Bold files try: read_node.inputs.bold = clinica_file_reader( self.subjects, self.sessions, self.bids_directory, input_files.FMRI_BOLD_NII) except ClinicaException as e: all_errors.append(e) # T1w-MRI files try: read_node.inputs.T1w = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, input_files.T1W_NII) except ClinicaException as e: all_errors.append(e) # Reading BIDS json # ================= read_node.inputs.et = [] read_node.inputs.blipdir = [] read_node.inputs.tert = [] read_node.inputs.time_repetition = [] read_node.inputs.num_slices = [] read_node.inputs.slice_order = [] read_node.inputs.ref_slice = [] read_node.inputs.time_acquisition = [] if self.parameters['unwarping']: # From phasediff json file try: phasediff_json = clinica_file_reader( self.subjects, self.sessions, self.bids_directory, input_files.FMAP_PHASEDIFF_JSON) for json_f in phasediff_json: with open(json_f) as json_file: data = json.load(json_file) # SPM echo times read_node.inputs.et.append( [data['EchoTime1'], data['EchoTime2']]) # SPM blip direction # TODO: Verifiy that it is the correct way to get the # blipdir blipdir_raw = data['PhaseEncodingDirection'] if len(blipdir_raw) > 1 and blipdir_raw[1] == '-': read_node.inputs.blipdir.append(-1) else: read_node.inputs.blipdir.append(1) except ClinicaException as e: all_errors.append(e) # From func json file try: func_json = clinica_file_reader(self.subjects, self.sessions, self.bids_directory, input_files.FMRI_BOLD_JSON) for json_f in func_json: with open(json_f) as json_file: data = json.load(json_file) # SPM Total readout time read_node.inputs.tert.append( 1 / data['BandwidthPerPixelPhaseEncode']) # SPM Repetition time read_node.inputs.time_repetition.append( data['RepetitionTime']) # Number of slices slice_timing = data['SliceTiming'] read_node.inputs.num_slices.append(len(slice_timing)) # Slice order slice_order = np.argsort(slice_timing) + 1 read_node.inputs.slice_order.append(slice_order.tolist()) read_node.inputs.ref_slice.append( np.argmin(slice_timing) + 1) read_node.inputs.time_acquisition.append( data['RepetitionTime'] - data['RepetitionTime'] / float(len(slice_timing))) 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 BIDS directory.\n' for msg in all_errors: error_message += str(msg) raise ClinicaBIDSError(error_message) if ('unwarping' in self.parameters) and self.parameters['unwarping']: self.connect([ # Reading BIDS json (read_node, self.input_node, [('et', 'et')]), (read_node, self.input_node, [('blipdir', 'blipdir')]), (read_node, self.input_node, [('tert', 'tert')]), # Reading BIDS files (read_node, self.input_node, [('phasediff', 'phasediff')]), (read_node, self.input_node, [('magnitude1', 'magnitude1')]), ]) self.connect([ # Reading BIDS json (read_node, self.input_node, [('time_repetition', 'time_repetition')]), (read_node, self.input_node, [('num_slices', 'num_slices')]), (read_node, self.input_node, [('slice_order', 'slice_order')]), (read_node, self.input_node, [('ref_slice', 'ref_slice')]), (read_node, self.input_node, [('time_acquisition', 'time_acquisition')]), # Reading BIDS files (read_node, self.input_node, [('bold', 'bold')]), (read_node, self.input_node, [('T1w', 'T1w')]), ])
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.stream import cprint from clinica.utils.exceptions import ClinicaCAPSError, ClinicaException from clinica.utils.inputs import clinica_file_reader import clinica.utils.input_files as input_files import re all_errors = [] # Inputs from t1-freesurfer pipeline # ================================== # White matter segmentation try: wm_mask_files = clinica_file_reader(self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_WM) except ClinicaException as e: all_errors.append(e) # Desikan parcellation try: aparc_aseg_files = clinica_file_reader(self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_DESIKAN) except ClinicaException as e: all_errors.append(e) # Destrieux parcellation try: aparc_aseg_a2009s_files = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_DESTRIEUX) except ClinicaException as e: all_errors.append(e) # Inputs from dwi-preprocessing pipeline # ====================================== # Preprocessed DWI try: dwi_files = clinica_file_reader(self.subjects, self.sessions, self.caps_directory, input_files.DWI_PREPROC_NII) except ClinicaException as e: all_errors.append(e) # B0 brainmask try: dwi_brainmask_files = clinica_file_reader( self.subjects, self.sessions, self.caps_directory, input_files.DWI_PREPROC_BRAINMASK) except ClinicaException as e: all_errors.append(e) # Preprocessed bvec try: bvec_files = clinica_file_reader(self.subjects, self.sessions, self.caps_directory, input_files.DWI_PREPROC_BVEC) except ClinicaException as e: all_errors.append(e) # Preprocessed bval try: bval_files = clinica_file_reader(self.subjects, self.sessions, self.caps_directory, input_files.DWI_PREPROC_BVAL) 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 ClinicaCAPSError(error_message) # Check space of DWI dataset dwi_file_spaces = [ re.search('.*_space-(.*)_preproc.nii.*', file, re.IGNORECASE).group(1) for file in dwi_files ] # 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).') # Used only for for T1-B0 registration if dwi_file_spaces[0] == 'b0': # Brain extracted T1w t1_brain_files = clinica_file_reader(self.subjects, self.sessions, self.caps_directory, input_files.T1_FS_BRAIN) list_atlas_files = [[aparc_aseg, aparc_aseg_a2009] for aparc_aseg, aparc_aseg_a2009 in zip( aparc_aseg_files, aparc_aseg_a2009s_files)] list_grad_fsl = [(bvec, bval) for bvec, bval in zip(bvec_files, bval_files)] p_id_images_to_process = [ re.search(r'(sub-[a-zA-Z0-9]+)', caps_file).group() for caps_file in dwi_files ] s_id_images_to_process = [ re.search(r'(ses-[a-zA-Z0-9]+)', caps_file).group() for caps_file in dwi_files ] images_to_process = ', '.join( p_id[4:] + '|' + s_id[4:] for p_id, s_id in zip( p_id_images_to_process, s_id_images_to_process)) cprint('The pipeline will be run on the following subject(s): %s' % images_to_process) if dwi_file_spaces[0] == 'b0': self.parameters['dwi_space'] = 'b0' read_node = npe.Node(name="ReadingFiles", iterables=[('wm_mask_file', wm_mask_files), ('t1_brain_file', t1_brain_files), ('dwi_file', dwi_files), ('dwi_brainmask_file', dwi_brainmask_files), ('grad_fsl', list_grad_fsl), ('atlas_files', list_atlas_files)], synchronize=True, interface=nutil.IdentityInterface( fields=self.get_input_fields())) 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')]), ]) elif dwi_file_spaces[0] == 'T1w': self.parameters['dwi_space'] = 'T1w' read_node = npe.Node(name="ReadingFiles", iterables=[('wm_mask_file', wm_mask_files), ('dwi_file', dwi_files), ('dwi_brainmask_file', dwi_brainmask_files), ('grad_fsl', list_grad_fsl), ('atlas_files', list_atlas_files)], synchronize=True, interface=nutil.IdentityInterface( fields=self.get_input_fields())) 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')]), ]) 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.""" 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 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.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')])])