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.inputs import clinica_group_reader
t_map = clinica_group_reader(
self.caps_directory,
{
"pattern": self.parameters["t_map"] + "*",
"description": "statistics t map",
"needed_pipeline": "statistics-volume",
},
)
read_parameters_node = npe.Node(
name="LoadingCLIArguments",
interface=nutil.IdentityInterface(fields=self.get_input_fields(),
mandatory_inputs=True),
)
read_parameters_node.inputs.t_map = t_map
self.connect([(read_parameters_node, self.input_node, [("t_map",
"t_map")])])
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
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 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
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."""
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,
pet_volume_normalized_suvr_pet)
from clinica.utils.exceptions import ClinicaCAPSError, ClinicaException
from clinica.utils.ux import print_groups_in_caps_directory
# Check that group already exists
if not os.path.exists(
os.path.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 pet-volume, t1-volume or t1-volume-create-dartel pipeline?%s'
% (Fore.RED, self.parameters['group_label'], Fore.RESET))
read_parameters_node = npe.Node(name="LoadingCLIArguments",
interface=nutil.IdentityInterface(
fields=self.get_input_fields(),
mandatory_inputs=True))
all_errors = []
if self.parameters['orig_input_data'] == 't1-volume':
caps_files_information = {
'pattern':
os.path.join(
't1', 'spm', 'dartel',
'group-' + self.parameters['group_label'],
'*_T1w_segm-graymatter_space-Ixi549Space_modulated-on_probability.nii.gz'
),
'description':
'graymatter tissue segmented in T1w MRI in Ixi549 space',
'needed_pipeline':
't1-volume-tissue-segmentation'
}
elif 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")
caps_files_information = pet_volume_normalized_suvr_pet(
acq_label=self.parameters["acq_label"],
suvr_reference_region=self.parameters["suvr_reference_region"],
use_brainmasked_image=False,
use_pvc_data=self.parameters["use_pvc_data"],
fwhm=0)
else:
raise ValueError(
f"Image type {self.parameters['orig_input_data']} unknown.")
try:
input_image = clinica_file_reader(self.subjects, self.sessions,
self.caps_directory,
caps_files_information)
except ClinicaException as e:
all_errors.append(e)
try:
dartel_input = clinica_group_reader(
self.caps_directory,
t1_volume_final_group_template(self.parameters['group_label']))
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 directories.\n'
for msg in all_errors:
error_message += str(msg)
raise ClinicaCAPSError(error_message)
read_parameters_node.inputs.dartel_input = dartel_input
read_parameters_node.inputs.input_image = input_image
self.connect([(read_parameters_node, self.input_node,
[('dartel_input', 'dartel_input')]),
(read_parameters_node, self.input_node,
[('input_image', 'input_image')])])
def build_input_node(self):
"""Build and connect an input node to the pipelines.
"""
from colorama import Fore
from os.path import join, split, realpath, exists
import nipype.interfaces.utility as nutil
import nipype.pipeline.engine as npe
from .pet_volume_utils import read_psf_information
from clinica.utils.inputs import clinica_file_reader, clinica_group_reader, insensitive_glob
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)
from clinica.utils.exceptions import ClinicaException
from clinica.utils.ux import print_groups_in_caps_directory
from clinica.iotools.utils.data_handling import check_relative_volume_location_in_world_coordinate_system
import clinica.utils.input_files as input_files
# Check that group already exists
if not exists(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)
)
# Tissues DataGrabber
# ====================
all_errors = []
# Grab reference mask
if self.parameters['pet_tracer'] == 'fdg':
reference_mask_template = 'region-pons_eroded-6mm_mask.nii*'
self.parameters['suvr_region'] = 'pons'
pet_file_to_grab = input_files.PET_FDG_NII
elif self.parameters['pet_tracer'] == 'av45':
reference_mask_template = 'region-cerebellumPons_eroded-6mm_mask.nii*'
self.parameters['suvr_region'] = 'cerebellumPons'
pet_file_to_grab = input_files.PET_AV45_NII
else:
raise NotImplementedError('Only "fdg" or "av45" tracers are currently accepted (given tracer "%s").' %
self.parameters['pet_tracer'])
reference_mask_path = join(split(realpath(__file__))[0], '../../resources/masks', reference_mask_template)
reference_mask_file = insensitive_glob(reference_mask_path)
if len(reference_mask_file) != 1:
all_errors.append('An error happened while trying to get reference mask ' + str(reference_mask_path))
else:
reference_mask_file = reference_mask_file[0]
# PET from BIDS directory
try:
pet_bids = clinica_file_reader(self.subjects,
self.sessions,
self.bids_directory,
pet_file_to_grab)
except ClinicaException as e:
all_errors.append(e)
# Native T1w-MRI
try:
t1w_bids = clinica_file_reader(self.subjects,
self.sessions,
self.bids_directory,
input_files.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_id']))
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_id']))
except ClinicaException as e:
all_errors.append(e)
if self.parameters['psf_tsv'] is not None:
iterables_fwhm = read_psf_information(self.parameters['psf_tsv'], self.subjects, self.sessions)
self.parameters['apply_pvc'] = True
else:
iterables_fwhm = [[]] * 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['pet_tracer'] + ' PET', pet_bids,
self.bids_directory,
self.parameters['pet_tracer'])
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),
('fwhm', iterables_fwhm),
('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')]),
(read_input_node, self.input_node, [('t1_image_native', 't1_image_native')]),
(read_input_node, self.input_node, [('mask_tissues', 'mask_tissues')]),
(read_input_node, self.input_node, [('flow_fields', 'flow_fields')]),
(read_input_node, self.input_node, [('dartel_template', 'dartel_template')]),
(read_input_node, self.input_node, [('reference_mask', 'reference_mask')]),
(read_input_node, self.input_node, [('fwhm', 'fwhm')]),
(read_input_node, self.input_node, [('pvc_mask_tissues', 'pvc_mask_tissues')])])
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.exceptions import ClinicaCAPSError, ClinicaException
from clinica.utils.input_files import (
pet_volume_normalized_suvr_pet,
t1_volume_final_group_template,
)
from clinica.utils.inputs import clinica_file_reader, clinica_group_reader
from clinica.utils.ux import print_groups_in_caps_directory
# Check that group already exists
if not os.path.exists(
os.path.join(
self.caps_directory, "groups", "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 pet-volume, t1-volume or t1-volume-create-dartel pipeline?"
)
read_parameters_node = npe.Node(
name="LoadingCLIArguments",
interface=nutil.IdentityInterface(
fields=self.get_input_fields(), mandatory_inputs=True
),
)
all_errors = []
if self.parameters["orig_input_data"] == "t1-volume":
caps_files_information = {
"pattern": os.path.join(
"t1",
"spm",
"dartel",
"group-" + self.parameters["group_label"],
"*_T1w_segm-graymatter_space-Ixi549Space_modulated-on_probability.nii.gz",
),
"description": "graymatter tissue segmented in T1w MRI in Ixi549 space",
"needed_pipeline": "t1-volume-tissue-segmentation",
}
elif 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"
)
caps_files_information = pet_volume_normalized_suvr_pet(
acq_label=self.parameters["acq_label"],
suvr_reference_region=self.parameters["suvr_reference_region"],
use_brainmasked_image=False,
use_pvc_data=self.parameters["use_pvc_data"],
fwhm=0,
)
else:
raise ValueError(
f"Image type {self.parameters['orig_input_data']} unknown."
)
try:
input_image = clinica_file_reader(
self.subjects,
self.sessions,
self.caps_directory,
caps_files_information,
)
except ClinicaException as e:
all_errors.append(e)
try:
dartel_input = clinica_group_reader(
self.caps_directory,
t1_volume_final_group_template(self.parameters["group_label"]),
)
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 directories.\n"
for msg in all_errors:
error_message += str(msg)
raise ClinicaCAPSError(error_message)
read_parameters_node.inputs.dartel_input = dartel_input
read_parameters_node.inputs.input_image = input_image
# fmt: off
self.connect(
[
(read_parameters_node, self.input_node, [("dartel_input", "dartel_input")]),
(read_parameters_node, self.input_node, [("input_image", "input_image")]),
]
)
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
from clinica.utils.exceptions import ClinicaCAPSError, ClinicaException
from clinica.utils.ux import print_groups_in_caps_directory
# 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 pet-volume, t1-volume or t1-volume-create-dartel pipeline?%s' %
(Fore.RED, self.parameters['group_id'], Fore.RESET)
)
read_parameters_node = npe.Node(name="LoadingCLIArguments",
interface=nutil.IdentityInterface(fields=self.get_input_fields(),
mandatory_inputs=True))
all_errors = []
if self.parameters['image_type'] == 't1':
caps_files_information = {
'pattern': os.path.join('t1', 'spm', 'dartel', 'group-' + self.parameters['group_id'],
'*_T1w_segm-graymatter_space-Ixi549Space_modulated-on_probability.nii.gz'),
'description': 'graymatter tissue segmented in T1w MRI in Ixi549 space',
'needed_pipeline': 't1-volume-tissue-segmentation'
}
elif self.parameters['image_type'] is 'pet':
if self.parameters['no_pvc']:
caps_files_information = {
'pattern': os.path.join('pet', 'preprocessing', 'group-' + self.parameters['group_id'],
'*_pet_space-Ixi549Space_suvr-pons_pet.nii.gz'),
'description': self.parameters['pet_tracer'] + ' PET in Ixi549 space',
'needed_pipeline': 'pet-volume'
}
else:
caps_files_information = {
'pattern': os.path.join('pet', 'preprocessing', 'group-' + self.parameters['group_id'],
'*_pet_space-Ixi549Space_pvc-rbv_suvr-pons_pet.nii.gz'),
'description': self.parameters['pet_tracer'] + ' PET partial volume corrected (RBV) in Ixi549 space',
'needed_pipeline': 'pet-volume with PVC'
}
else:
raise ValueError('Image type ' + self.parameters['image_type'] + ' unknown.')
try:
input_image = clinica_file_reader(self.subjects,
self.sessions,
self.caps_directory,
caps_files_information)
except ClinicaException as e:
all_errors.append(e)
try:
dartel_input = clinica_group_reader(self.caps_directory,
t1_volume_final_group_template(self.parameters['group_id']))
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 directories.\n'
for msg in all_errors:
error_message += str(msg)
raise ClinicaCAPSError(error_message)
read_parameters_node.inputs.dartel_input = dartel_input
read_parameters_node.inputs.input_image = input_image
self.connect([
(read_parameters_node, self.input_node, [('dartel_input', 'dartel_input')]),
(read_parameters_node, self.input_node, [('input_image', 'input_image')])
])