def test_reslice():
moving = example_data(infile='functional.nii')
space_defining = example_data(infile='T1.nii')
reslice = spmu.Reslice(matlab_cmd='mymatlab_version')
assert_equal(reslice.inputs.matlab_cmd, 'mymatlab_version')
reslice.inputs.in_file = moving
reslice.inputs.space_defining = space_defining
assert_equal(reslice.inputs.interp, 0)
assert_raises(TraitError, reslice.inputs.trait_set, interp='nearest')
assert_raises(TraitError, reslice.inputs.trait_set, interp=10)
reslice.inputs.interp = 1
script = reslice._make_matlab_command(None)
outfile = fname_presuffix(moving, prefix='r')
assert_equal(reslice.inputs.out_file, outfile)
expected = '\nflags.mean=0;\nflags.which=1;\nflags.mask=0;'
assert_equal(expected in script.replace(' ', ''), True)
expected_interp = 'flags.interp = 1;\n'
assert_equal(expected_interp in script, True)
assert_equal('spm_reslice(invols, flags);' in script, True)
def reslice_mask(self, segmentation, target=None):
for k, v in mask_dict.items():
if segmentation in v:
print('Reslicing eroded {} mask'.format(v[0]))
thresh_map = glob.glob(
os.path.join(
'/'.join(self.img.split('/')[:5]), 't1',
('thresh_' + k + '*' +
self.img.split('/')[4].split('_')[0] + '*t1*')))
# Do the reslicing
coreg = spmu.Reslice()
coreg.inputs.space_defining = self.fsl_file + '.nii.gz' # target
try:
coreg.inputs.in_file = thresh_map[0]
except IndexError:
print('Threshrolded image not available.')
return
coreg.run() # Throwing error, b/c mimicking bash?
def test_reslice():
moving = example_data(infile="functional.nii")
space_defining = example_data(infile="T1.nii")
reslice = spmu.Reslice(matlab_cmd="mymatlab_version")
assert reslice.inputs.matlab_cmd == "mymatlab_version"
reslice.inputs.in_file = moving
reslice.inputs.space_defining = space_defining
assert reslice.inputs.interp == 0
with pytest.raises(TraitError):
reslice.inputs.trait_set(interp="nearest")
with pytest.raises(TraitError):
reslice.inputs.trait_set(interp=10)
reslice.inputs.interp = 1
script = reslice._make_matlab_command(None)
outfile = fname_presuffix(moving, prefix="r")
assert reslice.inputs.out_file == outfile
expected = "\nflags.mean=0;\nflags.which=1;\nflags.mask=0;"
assert expected in script.replace(" ", "")
expected_interp = "flags.interp = 1;\n"
assert expected_interp in script
assert "spm_reslice(invols, flags);" in script
def build_core_nodes(self):
"""Build and connect an output node to the pipeline."""
import nipype.interfaces.spm as spm
import nipype.interfaces.spm.utils as spmutils
import nipype.interfaces.utility as nutil
import nipype.pipeline.engine as npe
from nipype.interfaces.petpvc import PETPVC
from clinica.utils.filemanip import unzip_nii
from clinica.utils.spm import spm_standalone_is_available, use_spm_standalone
from .pet_volume_utils import (
apply_binary_mask,
atlas_statistics,
create_binary_mask,
create_pvc_mask,
get_from_list,
init_input_node,
normalize_to_reference,
pet_pvc_name,
)
if spm_standalone_is_available():
use_spm_standalone()
# Initialize pipeline
# ===================
init_node = npe.Node(
interface=nutil.Function(
input_names=["pet_nii"],
output_names=["pet_nii"],
function=init_input_node,
),
name="init_pipeline",
)
# Unzipping
# =========
unzip_pet_image = npe.Node(
nutil.Function(input_names=["in_file"],
output_names=["out_file"],
function=unzip_nii),
name="unzip_pet_image",
)
unzip_t1_image_native = npe.Node(
nutil.Function(input_names=["in_file"],
output_names=["out_file"],
function=unzip_nii),
name="unzip_t1_image_native",
)
unzip_flow_fields = npe.Node(
nutil.Function(input_names=["in_file"],
output_names=["out_file"],
function=unzip_nii),
name="unzip_flow_fields",
)
unzip_dartel_template = npe.Node(
nutil.Function(input_names=["in_file"],
output_names=["out_file"],
function=unzip_nii),
name="unzip_dartel_template",
)
unzip_reference_mask = npe.Node(
nutil.Function(input_names=["in_file"],
output_names=["out_file"],
function=unzip_nii),
name="unzip_reference_mask",
)
unzip_mask_tissues = npe.MapNode(
nutil.Function(input_names=["in_file"],
output_names=["out_file"],
function=unzip_nii),
name="unzip_mask_tissues",
iterfield=["in_file"],
)
# Coregister PET into T1 native space
# ===================================
coreg_pet_t1 = npe.Node(spm.Coregister(), name="coreg_pet_t1")
# Spatially normalize PET into MNI
# ================================
dartel_mni_reg = npe.Node(spm.DARTELNorm2MNI(), name="dartel_mni_reg")
dartel_mni_reg.inputs.modulate = False
dartel_mni_reg.inputs.fwhm = 0
# Reslice reference region mask into PET
# ======================================
reslice = npe.Node(spmutils.Reslice(), name="reslice")
# Normalize PET values according to reference region
# ==================================================
norm_to_ref = npe.Node(
nutil.Function(
input_names=["pet_image", "region_mask"],
output_names=["suvr_pet_path"],
function=normalize_to_reference,
),
name="norm_to_ref",
)
# Create binary mask from segmented tissues
# =========================================
binary_mask = npe.Node(
nutil.Function(
input_names=["tissues", "threshold"],
output_names=["out_mask"],
function=create_binary_mask,
),
name="binary_mask",
)
binary_mask.inputs.threshold = self.parameters["mask_threshold"]
# Mask PET image
# ==============
apply_mask = npe.Node(
nutil.Function(
input_names=["image", "binary_mask"],
output_names=["masked_image_path"],
function=apply_binary_mask,
),
name="apply_mask",
)
# Smoothing
# =========
if self.parameters["smooth"] is not None and len(
self.parameters["smooth"]) > 0:
smoothing_node = npe.MapNode(spm.Smooth(),
name="smoothing_node",
iterfield=["fwhm", "out_prefix"])
smoothing_node.inputs.fwhm = [[x, x, x]
for x in self.parameters["smooth"]]
smoothing_node.inputs.out_prefix = [
"fwhm-" + str(x) + "mm_" for x in self.parameters["smooth"]
]
# fmt: off
self.connect([
(apply_mask, smoothing_node, [("masked_image_path", "in_files")
]),
(smoothing_node, self.output_node,
[("smoothed_files", "pet_suvr_masked_smoothed")]),
])
# fmt: on
else:
self.output_node.inputs.pet_suvr_masked_smoothed = [[]]
# Atlas Statistics
# ================
atlas_stats_node = npe.MapNode(
nutil.Function(
input_names=["in_image", "in_atlas_list"],
output_names=["atlas_statistics"],
function=atlas_statistics,
),
name="atlas_stats_node",
iterfield=["in_image"],
)
atlas_stats_node.inputs.in_atlas_list = self.parameters["atlases"]
# Connection
# ==========
# fmt: off
self.connect([
(self.input_node, init_node, [("pet_image", "pet_nii")]),
(init_node, unzip_pet_image, [("pet_nii", "in_file")]),
(self.input_node, unzip_t1_image_native, [("t1_image_native",
"in_file")]),
(self.input_node, unzip_flow_fields, [("flow_fields", "in_file")]),
(self.input_node, unzip_dartel_template, [("dartel_template",
"in_file")]),
(self.input_node, unzip_reference_mask, [("reference_mask",
"in_file")]),
(self.input_node, unzip_mask_tissues, [("mask_tissues", "in_file")
]),
(unzip_pet_image, coreg_pet_t1, [("out_file", "source")]),
(unzip_t1_image_native, coreg_pet_t1, [("out_file", "target")]),
(unzip_flow_fields, dartel_mni_reg, [("out_file",
"flowfield_files")]),
(unzip_dartel_template, dartel_mni_reg, [("out_file",
"template_file")]),
(unzip_reference_mask, reslice, [("out_file", "in_file")]),
(unzip_mask_tissues, binary_mask, [("out_file", "tissues")]),
(coreg_pet_t1, dartel_mni_reg, [("coregistered_source",
"apply_to_files")]),
(dartel_mni_reg, reslice, [("normalized_files", "space_defining")
]),
(dartel_mni_reg, norm_to_ref, [("normalized_files", "pet_image")]),
(reslice, norm_to_ref, [("out_file", "region_mask")]),
(norm_to_ref, apply_mask, [("suvr_pet_path", "image")]),
(binary_mask, apply_mask, [("out_mask", "binary_mask")]),
(norm_to_ref, atlas_stats_node, [("suvr_pet_path", "in_image")]),
(coreg_pet_t1, self.output_node, [("coregistered_source",
"pet_t1_native")]),
(dartel_mni_reg, self.output_node, [("normalized_files", "pet_mni")
]),
(norm_to_ref, self.output_node, [("suvr_pet_path", "pet_suvr")]),
(binary_mask, self.output_node, [("out_mask", "binary_mask")]),
(apply_mask, self.output_node, [("masked_image_path",
"pet_suvr_masked")]),
(atlas_stats_node, self.output_node, [("atlas_statistics",
"atlas_statistics")]),
])
# fmt: on
# PVC
# ==========
if self.parameters["apply_pvc"]:
# Unzipping
# =========
unzip_pvc_mask_tissues = npe.MapNode(
nutil.Function(
input_names=["in_file"],
output_names=["out_file"],
function=unzip_nii,
),
name="unzip_pvc_mask_tissues",
iterfield=["in_file"],
)
# Creating Mask to use in PVC
# ===========================
pvc_mask = npe.Node(
nutil.Function(
input_names=["tissues"],
output_names=["out_mask"],
function=create_pvc_mask,
),
name="pvc_mask",
)
# PET PVC
# =======
petpvc = npe.Node(PETPVC(), name="pvc")
petpvc.inputs.pvc = "RBV"
petpvc.inputs.out_file = "pvc.nii"
# Spatially normalize PET into MNI
# ================================
dartel_mni_reg_pvc = npe.Node(spm.DARTELNorm2MNI(),
name="dartel_mni_reg_pvc")
dartel_mni_reg_pvc.inputs.modulate = False
dartel_mni_reg_pvc.inputs.fwhm = 0
# Reslice reference region mask into PET
# ======================================
reslice_pvc = npe.Node(spmutils.Reslice(), name="reslice_pvc")
# Normalize PET values according to reference region
# ==================================================
norm_to_ref_pvc = npe.Node(
nutil.Function(
input_names=["pet_image", "region_mask"],
output_names=["suvr_pet_path"],
function=normalize_to_reference,
),
name="norm_to_ref_pvc",
)
# Mask PET image
# ==============
apply_mask_pvc = npe.Node(
nutil.Function(
input_names=["image", "binary_mask"],
output_names=["masked_image_path"],
function=apply_binary_mask,
),
name="apply_mask_pvc",
)
# Smoothing
# =========
if (self.parameters["smooth"] is not None
and len(self.parameters["smooth"]) > 0):
smoothing_pvc = npe.MapNode(spm.Smooth(),
name="smoothing_pvc",
iterfield=["fwhm", "out_prefix"])
smoothing_pvc.inputs.fwhm = [[x, x, x]
for x in self.parameters["smooth"]
]
smoothing_pvc.inputs.out_prefix = [
"fwhm-" + str(x) + "mm_" for x in self.parameters["smooth"]
]
# fmt: off
self.connect([
(apply_mask_pvc, smoothing_pvc, [("masked_image_path",
"in_files")]),
(smoothing_pvc, self.output_node,
[("smoothed_files", "pet_pvc_suvr_masked_smoothed")]),
])
# fmt: on
else:
self.output_node.inputs.pet_pvc_suvr_masked_smoothed = [[]]
# Atlas Statistics
# ================
atlas_stats_pvc = npe.MapNode(
nutil.Function(
input_names=["in_image", "in_atlas_list"],
output_names=["atlas_statistics"],
function=atlas_statistics,
),
name="atlas_stats_pvc",
iterfield=["in_image"],
)
atlas_stats_pvc.inputs.in_atlas_list = self.parameters["atlases"]
# Connection
# ==========
# fmt: off
self.connect([
(self.input_node, unzip_pvc_mask_tissues, [("pvc_mask_tissues",
"in_file")]),
(unzip_pvc_mask_tissues, pvc_mask, [("out_file", "tissues")]),
(unzip_flow_fields, dartel_mni_reg_pvc, [("out_file",
"flowfield_files")]),
(unzip_dartel_template, dartel_mni_reg_pvc,
[("out_file", "template_file")]),
(unzip_reference_mask, reslice_pvc, [("out_file", "in_file")]),
(coreg_pet_t1, petpvc, [("coregistered_source", "in_file"),
(("coregistered_source", pet_pvc_name,
"RBV"), "out_file")]),
(pvc_mask, petpvc, [("out_mask", "mask_file")]),
(self.input_node, petpvc,
[(("psf", get_from_list, 0), "fwhm_x"),
(("psf", get_from_list, 1), "fwhm_y"),
(("psf", get_from_list, 2), "fwhm_z")]),
(petpvc, dartel_mni_reg_pvc, [("out_file", "apply_to_files")]),
(dartel_mni_reg_pvc, reslice_pvc, [("normalized_files",
"space_defining")]),
(dartel_mni_reg_pvc, norm_to_ref_pvc, [("normalized_files",
"pet_image")]),
(reslice_pvc, norm_to_ref_pvc, [("out_file", "region_mask")]),
(norm_to_ref_pvc, apply_mask_pvc, [("suvr_pet_path", "image")
]),
(binary_mask, apply_mask_pvc, [("out_mask", "binary_mask")]),
(norm_to_ref_pvc, atlas_stats_pvc, [("suvr_pet_path",
"in_image")]),
(petpvc, self.output_node, [("out_file", "pet_pvc")]),
(dartel_mni_reg_pvc, self.output_node, [("normalized_files",
"pet_pvc_mni")]),
(norm_to_ref_pvc, self.output_node, [("suvr_pet_path",
"pet_pvc_suvr")]),
(apply_mask_pvc, self.output_node, [("masked_image_path",
"pet_pvc_suvr_masked")]),
(atlas_stats_pvc, self.output_node,
[("atlas_statistics", "pvc_atlas_statistics")]),
])
# fmt: on
else:
self.output_node.inputs.pet_pvc = [[]]
self.output_node.inputs.pet_pvc_mni = [[]]
self.output_node.inputs.pet_pvc_suvr = [[]]
self.output_node.inputs.pet_pvc_suvr_masked = [[]]
self.output_node.inputs.pvc_atlas_statistics = [[]]
self.output_node.inputs.pet_pvc_suvr_masked_smoothed = [[]]
def create_pipeline_nii_to_conmat(main_path,
filter_gm_threshold=0.9,
pipeline_name="nii_to_conmat",
conf_interval_prob=0.05,
background_val=-1.0,
plot=True,
reslice=False,
resample=False,
min_BOLD_intensity=50,
percent_signal=0.5):
"""
Description:
Pipeline from nifti 4D (after preprocessing) to connectivity matrices
Inputs (inputnode):
* nii_4D_file
* rp_file
* ROI_mask_file
* gm_anat_file
* wm_anat_file
* csf_anat_file
* ROI_coords_file
* ROI_MNI_coords_file
* ROI_labels_file
Comments:
Typically used after nipype preprocessing pipeline and
before conmat_to_graph pipeline
"""
if reslice and resample:
print("Only reslice OR resample can be true, setting reslice to False")
reslice = False
pipeline = pe.Workflow(name=pipeline_name)
pipeline.base_dir = main_path
inputnode = pe.Node(niu.IdentityInterface(fields=[
'nii_4D_file', 'ROI_mask_file', 'rp_file', 'gm_anat_file',
'wm_anat_file', 'csf_anat_file', 'ROI_coords_file',
'ROI_MNI_coords_file', 'ROI_labels_file'
]),
name='inputnode')
# reslice gm
if reslice:
reslice_gm = pe.Node(interface=spmu.Reslice(), name='reslice_gm')
pipeline.connect(inputnode, 'ROI_mask_file', reslice_gm,
'space_defining')
pipeline.connect(inputnode, 'gm_anat_file', reslice_gm, 'in_file')
if resample:
resample_gm = pe.Node(interface=RegResample(), name='resample_gm')
pipeline.connect(inputnode, 'ROI_mask_file', resample_gm, 'ref_file')
pipeline.connect(inputnode, 'gm_anat_file', resample_gm, 'flo_file')
# reslice wm
if reslice:
reslice_wm = pe.Node(interface=spmu.Reslice(), name='reslice_wm')
pipeline.connect(inputnode, 'ROI_mask_file', reslice_wm,
'space_defining')
pipeline.connect(inputnode, 'wm_anat_file', reslice_wm, 'in_file')
if resample:
resample_wm = pe.Node(interface=RegResample(), name='resample_wm')
pipeline.connect(inputnode, 'ROI_mask_file', resample_wm, 'ref_file')
pipeline.connect(inputnode, 'wm_anat_file', resample_wm, 'flo_file')
# reslice csf
if reslice:
reslice_csf = pe.Node(interface=spmu.Reslice(), name='reslice_csf')
pipeline.connect(inputnode, 'ROI_mask_file', reslice_csf,
'space_defining')
pipeline.connect(inputnode, 'csf_anat_file', reslice_csf, 'in_file')
if resample:
resample_csf = pe.Node(interface=RegResample(), name='resample_csf')
pipeline.connect(inputnode, 'ROI_mask_file', resample_csf, 'ref_file')
pipeline.connect(inputnode, 'csf_anat_file', resample_csf, 'flo_file')
# Preprocess pipeline,
filter_ROI_mask_with_GM = pe.Node(interface=IntersectMask(),
name='filter_ROI_mask_with_GM')
filter_ROI_mask_with_GM.inputs.filter_thr = filter_gm_threshold
filter_ROI_mask_with_GM.inputs.background_val = background_val
pipeline.connect(inputnode, 'ROI_mask_file', filter_ROI_mask_with_GM,
'indexed_rois_file')
pipeline.connect(inputnode, 'ROI_coords_file', filter_ROI_mask_with_GM,
'coords_rois_file')
pipeline.connect(inputnode, 'ROI_MNI_coords_file', filter_ROI_mask_with_GM,
'MNI_coords_rois_file')
pipeline.connect(inputnode, 'ROI_labels_file', filter_ROI_mask_with_GM,
'labels_rois_file')
if reslice:
pipeline.connect(reslice_gm, 'out_file', filter_ROI_mask_with_GM,
'filter_mask_file')
elif resample:
pipeline.connect(resample_gm, 'out_file', filter_ROI_mask_with_GM,
'filter_mask_file')
else:
pipeline.connect(inputnode, 'gm_anat_file', filter_ROI_mask_with_GM,
'filter_mask_file')
# Nodes version: use min_BOLD_intensity and
# return coords where signal is strong enough
extract_mean_ROI_ts = pe.Node(interface=ExtractTS(plot_fig=plot),
name='extract_mean_ROI_ts')
extract_mean_ROI_ts.inputs.percent_signal = percent_signal
extract_mean_ROI_ts.inputs.min_BOLD_intensity = min_BOLD_intensity
pipeline.connect(inputnode, 'nii_4D_file', extract_mean_ROI_ts, 'file_4D')
pipeline.connect(filter_ROI_mask_with_GM, 'filtered_indexed_rois_file',
extract_mean_ROI_ts, 'indexed_rois_file')
pipeline.connect(filter_ROI_mask_with_GM, 'filtered_MNI_coords_rois_file',
extract_mean_ROI_ts, 'MNI_coord_rois_file')
pipeline.connect(filter_ROI_mask_with_GM, 'filtered_coords_rois_file',
extract_mean_ROI_ts, 'coord_rois_file')
pipeline.connect(filter_ROI_mask_with_GM, 'filtered_labels_rois_file',
extract_mean_ROI_ts, 'label_rois_file')
# extract white matter signal
compute_wm_ts = pe.Node(interface=ExtractMeanTS(plot_fig=plot),
name='extract_wm_ts')
compute_wm_ts.inputs.suffix = 'wm'
pipeline.connect(inputnode, 'nii_4D_file', compute_wm_ts, 'file_4D')
if reslice:
pipeline.connect(reslice_wm, 'out_file', compute_wm_ts,
'filter_mask_file')
elif resample:
pipeline.connect(resample_wm, 'out_file', compute_wm_ts,
'filter_mask_file')
else:
pipeline.connect(inputnode, 'wm_anat_file', compute_wm_ts,
'filter_mask_file')
# extract csf signal
compute_csf_ts = pe.Node(interface=ExtractMeanTS(plot_fig=plot),
name='extract_csf_ts')
compute_csf_ts.inputs.suffix = 'csf'
pipeline.connect(inputnode, 'nii_4D_file', compute_csf_ts, 'file_4D')
if reslice:
pipeline.connect(reslice_csf, 'out_file', compute_csf_ts,
'filter_mask_file')
elif resample:
pipeline.connect(resample_csf, 'out_file', compute_csf_ts,
'filter_mask_file')
else:
pipeline.connect(inputnode, 'csf_anat_file', compute_csf_ts,
'filter_mask_file')
# regress covariates
regress_covar = pe.Node(interface=RegressCovar(plot_fig=plot),
iterfield=[
'masked_ts_file', 'rp_file', 'mean_wm_ts_file',
'mean_csf_ts_file'
],
name='regress_covar')
pipeline.connect(extract_mean_ROI_ts, 'mean_masked_ts_file', regress_covar,
'masked_ts_file')
pipeline.connect(inputnode, 'rp_file', regress_covar, 'rp_file')
pipeline.connect(compute_wm_ts, 'mean_masked_ts_file', regress_covar,
'mean_wm_ts_file')
pipeline.connect(compute_csf_ts, 'mean_masked_ts_file', regress_covar,
'mean_csf_ts_file')
# compute correlations
compute_conf_cor_mat = pe.Node(interface=ComputeConfCorMat(plot_mat=plot),
name='compute_conf_cor_mat')
compute_conf_cor_mat.inputs.conf_interval_prob = conf_interval_prob
pipeline.connect(regress_covar, 'resid_ts_file', compute_conf_cor_mat,
'ts_file')
pipeline.connect(extract_mean_ROI_ts, 'subj_label_rois_file',
compute_conf_cor_mat, 'labels_file')
return pipeline
def create_pipeline_nii_to_subj_ROI(main_path,
filter_gm_threshold=0.9,
pipeline_name="nii_to_subj_ROI",
background_val=-1.0,
plot=True,
reslice=False,
resample=False,
min_BOLD_intensity=50,
percent_signal=0.5):
"""
Description:
Pipeline from nifti 4D (after preprocessing) to connectivity matrices
Use Grey matter for having a mask for each subject
Inputs (inputnode):
* nii_4D_file
* gm_anat_file
* ROI_mask_file
* ROI_coords_file
* ROI_MNI_coords_file
* ROI_labels_file
Comments:
Typically used after nipype preprocessing pipeline and
before conmat_to_graph pipeline
"""
if reslice and resample:
print("Only reslice OR resample can be true, setting reslice to False")
reslice = False
pipeline = pe.Workflow(name=pipeline_name)
pipeline.base_dir = main_path
inputnode = pe.Node(niu.IdentityInterface(fields=[
'nii_4D_file', 'ROI_mask_file', 'gm_anat_file', 'ROI_coords_file',
'ROI_MNI_coords_file', 'ROI_labels_file'
]),
name='inputnode')
# reslice gm
if reslice:
reslice_gm = pe.Node(interface=spmu.Reslice(), name='reslice_gm')
pipeline.connect(inputnode, 'ROI_mask_file', reslice_gm,
'space_defining')
pipeline.connect(inputnode, 'gm_anat_file', reslice_gm, 'in_file')
if resample:
resample_gm = pe.Node(interface=RegResample(), name='resample_gm')
pipeline.connect(inputnode, 'ROI_mask_file', resample_gm, 'ref_file')
pipeline.connect(inputnode, 'gm_anat_file', resample_gm, 'flo_file')
# Preprocess pipeline,
filter_ROI_mask_with_GM = pe.Node(interface=IntersectMask(),
name='filter_ROI_mask_with_GM')
filter_ROI_mask_with_GM.inputs.filter_thr = filter_gm_threshold
filter_ROI_mask_with_GM.inputs.background_val = background_val
pipeline.connect(inputnode, 'ROI_mask_file', filter_ROI_mask_with_GM,
'indexed_rois_file')
pipeline.connect(inputnode, 'ROI_coords_file', filter_ROI_mask_with_GM,
'coords_rois_file')
pipeline.connect(inputnode, 'ROI_MNI_coords_file', filter_ROI_mask_with_GM,
'MNI_coords_rois_file')
pipeline.connect(inputnode, 'ROI_labels_file', filter_ROI_mask_with_GM,
'labels_rois_file')
if reslice:
pipeline.connect(reslice_gm, 'out_file', filter_ROI_mask_with_GM,
'filter_mask_file')
elif resample:
pipeline.connect(resample_gm, 'out_file', filter_ROI_mask_with_GM,
'filter_mask_file')
else:
pipeline.connect(inputnode, 'gm_anat_file', filter_ROI_mask_with_GM,
'filter_mask_file')
# Nodes version: use min_BOLD_intensity and
# return coords where signal is strong enough
extract_mean_ROI_ts = pe.Node(interface=ExtractTS(plot_fig=plot),
name='extract_mean_ROI_ts')
extract_mean_ROI_ts.inputs.percent_signal = percent_signal
extract_mean_ROI_ts.inputs.min_BOLD_intensity = min_BOLD_intensity
pipeline.connect(inputnode, 'nii_4D_file', extract_mean_ROI_ts, 'file_4D')
pipeline.connect(filter_ROI_mask_with_GM, 'filtered_indexed_rois_file',
extract_mean_ROI_ts, 'indexed_rois_file')
pipeline.connect(filter_ROI_mask_with_GM, 'filtered_MNI_coords_rois_file',
extract_mean_ROI_ts, 'MNI_coord_rois_file')
pipeline.connect(filter_ROI_mask_with_GM, 'filtered_coords_rois_file',
extract_mean_ROI_ts, 'coord_rois_file')
pipeline.connect(filter_ROI_mask_with_GM, 'filtered_labels_rois_file',
extract_mean_ROI_ts, 'label_rois_file')
return pipeline
def build_core_nodes(self):
"""Build and connect an output node to the pipeline."""
import nipype.interfaces.spm as spm
import nipype.interfaces.spm.utils as spmutils
from nipype.interfaces.petpvc import PETPVC
import nipype.interfaces.utility as nutil
import nipype.pipeline.engine as npe
from clinica.utils.filemanip import unzip_nii
from clinica.utils.spm import spm_standalone_is_available, use_spm_standalone
import clinica.pipelines.pet_volume.pet_volume_utils as utils
if spm_standalone_is_available():
use_spm_standalone()
# Initialize pipeline
# ===================
init_node = npe.Node(interface=nutil.Function(
input_names=['pet_nii'],
output_names=['pet_nii'],
function=utils.init_input_node),
name='init_pipeline')
# Unzipping
# =========
unzip_pet_image = npe.Node(nutil.Function(input_names=['in_file'],
output_names=['out_file'],
function=unzip_nii),
name='unzip_pet_image')
unzip_t1_image_native = npe.Node(nutil.Function(
input_names=['in_file'],
output_names=['out_file'],
function=unzip_nii),
name='unzip_t1_image_native')
unzip_flow_fields = npe.Node(nutil.Function(input_names=['in_file'],
output_names=['out_file'],
function=unzip_nii),
name='unzip_flow_fields')
unzip_dartel_template = npe.Node(nutil.Function(
input_names=['in_file'],
output_names=['out_file'],
function=unzip_nii),
name='unzip_dartel_template')
unzip_reference_mask = npe.Node(nutil.Function(
input_names=['in_file'],
output_names=['out_file'],
function=unzip_nii),
name='unzip_reference_mask')
unzip_mask_tissues = npe.MapNode(nutil.Function(
input_names=['in_file'],
output_names=['out_file'],
function=unzip_nii),
name='unzip_mask_tissues',
iterfield=['in_file'])
# Coregister PET into T1 native space
# ===================================
coreg_pet_t1 = npe.Node(spm.Coregister(), name='coreg_pet_t1')
# Spatially normalize PET into MNI
# ================================
dartel_mni_reg = npe.Node(spm.DARTELNorm2MNI(), name='dartel_mni_reg')
dartel_mni_reg.inputs.modulate = False
dartel_mni_reg.inputs.fwhm = 0
# Reslice reference region mask into PET
# ======================================
reslice = npe.Node(spmutils.Reslice(), name='reslice')
# Normalize PET values according to reference region
# ==================================================
norm_to_ref = npe.Node(nutil.Function(
input_names=['pet_image', 'region_mask'],
output_names=['suvr_pet_path'],
function=utils.normalize_to_reference),
name='norm_to_ref')
# Create binary mask from segmented tissues
# =========================================
binary_mask = npe.Node(nutil.Function(
input_names=['tissues', 'threshold'],
output_names=['out_mask'],
function=utils.create_binary_mask),
name='binary_mask')
binary_mask.inputs.threshold = self.parameters['mask_threshold']
# Mask PET image
# ==============
apply_mask = npe.Node(nutil.Function(
input_names=['image', 'binary_mask'],
output_names=['masked_image_path'],
function=utils.apply_binary_mask),
name='apply_mask')
# Smoothing
# =========
if self.parameters['smooth'] is not None and len(
self.parameters['smooth']) > 0:
smoothing_node = npe.MapNode(spm.Smooth(),
name='smoothing_node',
iterfield=['fwhm', 'out_prefix'])
smoothing_node.inputs.fwhm = [[x, x, x]
for x in self.parameters['smooth']]
smoothing_node.inputs.out_prefix = [
'fwhm-' + str(x) + 'mm_' for x in self.parameters['smooth']
]
self.connect([(apply_mask, smoothing_node, [('masked_image_path',
'in_files')]),
(smoothing_node, self.output_node,
[('smoothed_files', 'pet_suvr_masked_smoothed')])])
else:
self.output_node.inputs.pet_suvr_masked_smoothed = [[]]
# Atlas Statistics
# ================
atlas_stats_node = npe.MapNode(nutil.Function(
input_names=['in_image', 'in_atlas_list'],
output_names=['atlas_statistics'],
function=utils.atlas_statistics),
name='atlas_stats_node',
iterfield=['in_image'])
atlas_stats_node.inputs.in_atlas_list = self.parameters['atlases']
# Connection
# ==========
self.connect([
(self.input_node, init_node, [('pet_image', 'pet_nii')]),
(init_node, unzip_pet_image, [('pet_nii', 'in_file')]),
(self.input_node, unzip_t1_image_native, [('t1_image_native',
'in_file')]),
(self.input_node, unzip_flow_fields, [('flow_fields', 'in_file')]),
(self.input_node, unzip_dartel_template, [('dartel_template',
'in_file')]),
(self.input_node, unzip_reference_mask, [('reference_mask',
'in_file')]),
(self.input_node, unzip_mask_tissues, [('mask_tissues', 'in_file')
]),
(unzip_pet_image, coreg_pet_t1, [('out_file', 'source')]),
(unzip_t1_image_native, coreg_pet_t1, [('out_file', 'target')]),
(unzip_flow_fields, dartel_mni_reg, [('out_file',
'flowfield_files')]),
(unzip_dartel_template, dartel_mni_reg, [('out_file',
'template_file')]),
(unzip_reference_mask, reslice, [('out_file', 'in_file')]),
(unzip_mask_tissues, binary_mask, [('out_file', 'tissues')]),
(coreg_pet_t1, dartel_mni_reg, [('coregistered_source',
'apply_to_files')]),
(dartel_mni_reg, reslice, [('normalized_files', 'space_defining')
]),
(dartel_mni_reg, norm_to_ref, [('normalized_files', 'pet_image')]),
(reslice, norm_to_ref, [('out_file', 'region_mask')]),
(norm_to_ref, apply_mask, [('suvr_pet_path', 'image')]),
(binary_mask, apply_mask, [('out_mask', 'binary_mask')]),
(norm_to_ref, atlas_stats_node, [('suvr_pet_path', 'in_image')]),
(coreg_pet_t1, self.output_node, [('coregistered_source',
'pet_t1_native')]),
(dartel_mni_reg, self.output_node, [('normalized_files', 'pet_mni')
]),
(norm_to_ref, self.output_node, [('suvr_pet_path', 'pet_suvr')]),
(binary_mask, self.output_node, [('out_mask', 'binary_mask')]),
(apply_mask, self.output_node, [('masked_image_path',
'pet_suvr_masked')]),
(atlas_stats_node, self.output_node, [('atlas_statistics',
'atlas_statistics')])
])
# PVC
# ==========
if self.parameters['apply_pvc']:
# Unzipping
# =========
unzip_pvc_mask_tissues = npe.MapNode(nutil.Function(
input_names=['in_file'],
output_names=['out_file'],
function=unzip_nii),
name='unzip_pvc_mask_tissues',
iterfield=['in_file'])
# Creating Mask to use in PVC
# ===========================
pvc_mask = npe.Node(nutil.Function(input_names=['tissues'],
output_names=['out_mask'],
function=utils.create_pvc_mask),
name='pvc_mask')
# PET PVC
# =======
petpvc = npe.Node(PETPVC(), name='pvc')
petpvc.inputs.pvc = 'RBV'
petpvc.inputs.out_file = 'pvc.nii'
# Spatially normalize PET into MNI
# ================================
dartel_mni_reg_pvc = npe.Node(spm.DARTELNorm2MNI(),
name='dartel_mni_reg_pvc')
dartel_mni_reg_pvc.inputs.modulate = False
dartel_mni_reg_pvc.inputs.fwhm = 0
# Reslice reference region mask into PET
# ======================================
reslice_pvc = npe.Node(spmutils.Reslice(), name='reslice_pvc')
# Normalize PET values according to reference region
# ==================================================
norm_to_ref_pvc = npe.Node(nutil.Function(
input_names=['pet_image', 'region_mask'],
output_names=['suvr_pet_path'],
function=utils.normalize_to_reference),
name='norm_to_ref_pvc')
# Mask PET image
# ==============
apply_mask_pvc = npe.Node(nutil.Function(
input_names=['image', 'binary_mask'],
output_names=['masked_image_path'],
function=utils.apply_binary_mask),
name='apply_mask_pvc')
# Smoothing
# =========
if self.parameters['smooth'] is not None and len(
self.parameters['smooth']) > 0:
smoothing_pvc = npe.MapNode(spm.Smooth(),
name='smoothing_pvc',
iterfield=['fwhm', 'out_prefix'])
smoothing_pvc.inputs.fwhm = [[x, x, x]
for x in self.parameters['smooth']
]
smoothing_pvc.inputs.out_prefix = [
'fwhm-' + str(x) + 'mm_' for x in self.parameters['smooth']
]
self.connect([(apply_mask_pvc, smoothing_pvc,
[('masked_image_path', 'in_files')]),
(smoothing_pvc, self.output_node,
[('smoothed_files',
'pet_pvc_suvr_masked_smoothed')])])
else:
self.output_node.inputs.pet_pvc_suvr_masked_smoothed = [[]]
# Atlas Statistics
# ================
atlas_stats_pvc = npe.MapNode(nutil.Function(
input_names=['in_image', 'in_atlas_list'],
output_names=['atlas_statistics'],
function=utils.atlas_statistics),
name='atlas_stats_pvc',
iterfield=['in_image'])
atlas_stats_pvc.inputs.in_atlas_list = self.parameters['atlases']
# Connection
# ==========
self.connect([
(self.input_node, unzip_pvc_mask_tissues, [('pvc_mask_tissues',
'in_file')]),
(unzip_pvc_mask_tissues, pvc_mask, [('out_file', 'tissues')]),
(unzip_flow_fields, dartel_mni_reg_pvc, [('out_file',
'flowfield_files')]),
(unzip_dartel_template, dartel_mni_reg_pvc,
[('out_file', 'template_file')]),
(unzip_reference_mask, reslice_pvc, [('out_file', 'in_file')]),
(coreg_pet_t1, petpvc, [('coregistered_source', 'in_file'),
(('coregistered_source',
utils.pet_pvc_name, 'RBV'),
'out_file')]),
(pvc_mask, petpvc, [('out_mask', 'mask_file')]),
(self.input_node, petpvc,
[(('psf', utils.get_from_list, 0), 'fwhm_x'),
(('psf', utils.get_from_list, 1), 'fwhm_y'),
(('psf', utils.get_from_list, 2), 'fwhm_z')]),
(petpvc, dartel_mni_reg_pvc, [('out_file', 'apply_to_files')]),
(dartel_mni_reg_pvc, reslice_pvc, [('normalized_files',
'space_defining')]),
(dartel_mni_reg_pvc, norm_to_ref_pvc, [('normalized_files',
'pet_image')]),
(reslice_pvc, norm_to_ref_pvc, [('out_file', 'region_mask')]),
(norm_to_ref_pvc, apply_mask_pvc, [('suvr_pet_path', 'image')
]),
(binary_mask, apply_mask_pvc, [('out_mask', 'binary_mask')]),
(norm_to_ref_pvc, atlas_stats_pvc, [('suvr_pet_path',
'in_image')]),
(petpvc, self.output_node, [('out_file', 'pet_pvc')]),
(dartel_mni_reg_pvc, self.output_node, [('normalized_files',
'pet_pvc_mni')]),
(norm_to_ref_pvc, self.output_node, [('suvr_pet_path',
'pet_pvc_suvr')]),
(apply_mask_pvc, self.output_node, [('masked_image_path',
'pet_pvc_suvr_masked')]),
(atlas_stats_pvc, self.output_node, [('atlas_statistics',
'pvc_atlas_statistics')])
])
else:
self.output_node.inputs.pet_pvc = [[]]
self.output_node.inputs.pet_pvc_mni = [[]]
self.output_node.inputs.pet_pvc_suvr = [[]]
self.output_node.inputs.pet_pvc_suvr_masked = [[]]
self.output_node.inputs.pvc_atlas_statistics = [[]]
self.output_node.inputs.pet_pvc_suvr_masked_smoothed = [[]]
