def create_workflow_to_resample_baw_files(name="ResampleBAWOutputs"):
"""
This function...
:param name:
:return:
"""
workflow = Workflow(name)
inputs_to_resample = ["t1_file", "t2_file", "hncma_file", "abc_file"]
other_inputs = ["reference_file", "acpc_transform"]
label_maps = ["hncma_file", "abc_file"]
input_spec = Node(IdentityInterface(inputs_to_resample + other_inputs),
name="input_spec")
output_spec = Node(IdentityInterface(inputs_to_resample),
name="output_spec")
for input in inputs_to_resample:
node = Node(BRAINSResample(), "Resample_{0}".format(input))
node.inputs.pixelType = "short"
node.inputs.inverseTransform = True
node.inputs.outputVolume = input + ".nii.gz"
if input in label_maps:
node.inputs.interpolationMode = "NearestNeighbor"
workflow.connect([
(input_spec, node, [("reference_file", "referenceVolume"),
("acpc_transform", "warpTransform"),
("{0}".format(input), "inputVolume")]),
(node, output_spec, [("outputVolume", "{0}".format(input))])
])
return workflow
def make_workflow():
flairs = [os.path.abspath(i) for i in glob.glob(args.flair)]
weights = [os.path.abspath(i) for i in glob.glob(args.weights)]
weights_source = Node(interface=IdentityInterface(fields=['weights']),
name='weights_source')
weights_source.inputs.weights = weights
data_source = Node(IdentityInterface(fields=['flairs']),
name='data_source')
data_source.iterables = ('flairs', flairs)
sink = Node(interface=DataSink(), name='sink')
sink.inputs.base_directory = wmh_dir
sink.inputs.substitutions = [
('_flairs_', ''),
('_FLAIR.nii.gz/', '/'),
]
sink.inputs.regexp_substitutions = [
('\.\..*\.\.', ''),
]
test_wf = ibbmTum_wf.get_test_wf(row_st=192, cols_st=192, thres_mask=10)
wmh = Workflow(name='wmh', base_dir=wf_temp)
wmh.connect(weights_source, 'weights', test_wf, 'inputspec.weights')
wmh.connect(data_source, 'flairs', test_wf, 'inputspec.flair')
wmh.connect(test_wf, 'outputspec.wmh_mask', sink, '@pred')
return wmh
def crop_wf(usemodel):
"""Create a workflow to to crop the image. This workflow requires a
model image (e.g. an MNI standard) and points on that image. The model
is registered to the T1 image, and the points transformed into T1 space.
The image is cut to a box containing all of the transformed points.
All cuts are in voxel coordinates.
:return: A :py:mod:`nipype` workflow
Workflow inputs/outputs
:param inputspec.T1: The T1 image to remove the neck from
:param inputspec.model: The reference image to register to the T1 image
:param inputspec.points: Points file (tsv file with x, y, z, and index (ignored),
representing the limits in model space
:return: A :py:mod:`nipype` node
"""
name = 'crop'
wf = pe.Workflow(name)
inputspec = pe.Node(IdentityInterface(['T1', 'model', 'points']), name='inputspec')
cut = pe.Node(CutImage(neckonly=False), name='cut')
outputspec = pe.Node(IdentityInterface(['cropped']), name='outputspec')
if usemodel:
trpoints = _tr_points_wf()
wf.connect([(inputspec, trpoints, [('T1', 'inputspec.T1'),
('model', 'inputspec.model'),
('points', 'inputspec.points')]),
(trpoints, cut, [('outputspec.out_points', 'points_file')])])
else:
wf.connect([(inputspec, cut, [('points', 'points_file')])])
wf.connect([(inputspec, cut, [('T1', 'in_file')]),
(cut, outputspec, [('out_file', 'cropped')])])
return wf
def init_mpm_wf(me_params, mtsat_params):
inputnode = Node(IdentityInterface(fields=['pdw_file', 't1w_file', 'mtw_file',
'pdw_cal', 't1w_cal', 'mtw_cal']),
name='inputnode')
outputnode = Node(IdentityInterface(fields=['pd_map', 'r1_map', 'r2s_map', 'mtsat_map']),
name='outputnode')
bet = Node(BET(mask=True, no_output=True), name='brain_mask')
mpm = Node(MPMR2s(sequence=me_params, verbose=True), name='MPM_R2s')
mtsat = Node(MTSat(sequence=mtsat_params, verbose=True), name='MPM_MTSat')
wf = Workflow(name='Multi-Parametric-Mapping')
wf.connect([(inputnode, bet, [('t1w_file', 'in_file')]),
(inputnode, mpm, [('pdw_file', 'pdw_file'),
('t1w_file', 't1w_file'),
('mtw_file', 'mtw_file')]),
(bet, mpm, [('mask_file', 'mask_file')]),
(mpm, mtsat, [('s0_pdw', 'pdw_file'),
('s0_t1w', 't1w_file'),
('s0_mtw', 'mtw_file')]),
(bet, mtsat, [('mask_file', 'mask_file')]),
(mpm, outputnode, [('r2s_map', 'r2s_map')]),
(mtsat, outputnode, [('s0_map', 'pd_map'),
('r1_map', 'r1_map'),
('delta_map', 'mtsat_map')])])
return wf
def neck_removal_wf(usemodel):
"""Create a workflow to to remove the neck. This workflow requires a
model image (e.g. an MNI standard) and points on that image. The model
is registered to the T1 image, and the points transformed into T1 space.
The inferior most transformed point is used to determine the cutting
plane, which is aligned with the voxel coordinates.
:return: A :py:mod:`nipype` workflow
Workflow inputs/outputs
:param inputspec.T1: The T1 image to remove the neck from
:param inputspec.model: The reference image to register to the T1 image
:param inputspec.limits: Points in model roughly indicating the ideal cutting plane
:return: A :py:mod:`nipype` node
"""
name = 'neck_removal'
wf = pe.Workflow(name)
inputspec = pe.Node(IdentityInterface(['T1', 'model', 'limits']), name='inputspec')
wpoints = pe.Node(Function(input_names=['limits'], output_names=['points'], function=writepoints), name='write_points')
cut = pe.Node(CutImage(neckonly=True), name='cut')
outputspec = pe.Node(IdentityInterface(['cropped']), name='outputspec')
if usemodel:
trpoints = _tr_points_wf()
wf.connect([(inputspec, trpoints, [('T1', 'inputspec.T1'),
('model', 'inputspec.model')]),
(wpoints, trpoints, [('points', 'inputspec.points')]),
(trpoints, cut, [('outputspec.out_points', 'points_file')])])
else:
wf.connect([(wpoints, cut, [('points', 'points_file')])])
wf.connect([(inputspec, wpoints, [('limits', 'limits')]),
(inputspec, cut, [('T1', 'in_file')]),
(cut, outputspec, [('out_file', 'cropped')])])
return wf
def init_b1_mcf(rf_pulse=None, scale=150):
inputnode = Node(IdentityInterface(fields=['2db1map_file', 'ref_file']),
name='inputnode')
outputnode = Node(IdentityInterface(fields=['b1_plus', 'b1_pulse']),
name='outputnode')
b1_b1 = Node(ExtractROI(t_min=0, t_size=1), name='b1_extract_b1')
b1_filter = Node(Filter(filter_spec='Gauss,3.0'), name='b1_filter')
b1_mag = Node(ExtractROI(t_min=1, t_size=1), name='b1_extract_mag')
b1_reg = Node(FLIRT(out_file='b1mag_reg.nii.gz',
out_matrix_file='b1mag_reg.mat'),
name='b1_reg')
b1_invert = Node(ConvertXFM(invert_xfm=True), name='b1_invert')
b1_apply = Node(FLIRT(apply_xfm=True), name='b1_reg_apply')
b1_scale = Node(ImageMaths(op_string='-div %f' % scale), name='b1_scale')
wf = Workflow(name='b1_prep')
wf.connect([(inputnode, b1_b1, [('2db1map_file', 'in_file')]),
(inputnode, b1_mag, [('2db1map_file', 'in_file')]),
(inputnode, b1_reg, [('ref_file', 'in_file')]),
(inputnode, b1_apply, [('ref_file', 'reference')]),
(b1_mag, b1_reg, [('roi_file', 'reference')]),
(b1_reg, b1_invert, [('out_matrix_file', 'in_file')]),
(b1_invert, b1_apply, [('out_file', 'in_matrix_file')]),
(b1_b1, b1_filter, [('roi_file', 'in_file')]),
(b1_filter, b1_apply, [('out_file', 'in_file')]),
(b1_apply, b1_scale, [('out_file', 'in_file')]),
(b1_scale, outputnode, [('out_file', 'b1_plus')])])
if rf_pulse:
b1_rf = Node(RFProfile(rf=rf_pulse, out_file='b1_rf.nii.gz'),
name='b1_rf')
wf.connect([(b1_scale, b1_rf, [('out_file', 'in_file')]),
(b1_rf, outputnode, [('out_file', 'b1_pulse')])])
return wf
def create_ffx_workflow(name="mni_ffx",
space="mni",
contrasts=None,
exp_info=None):
"""Return a workflow object to execute a fixed-effects mode."""
if contrasts is None:
contrasts = []
if exp_info is None:
exp_info = lyman.default_experiment_parameters()
inputnode = Node(IdentityInterface([
"copes", "varcopes", "masks", "means", "dofs", "ss_files", "anatomy",
"reg_file", "timeseries"
]),
name="inputnode")
# Fit the fixedfx model for each contrast
ffxmodel = Node(FFXModel(contrasts=contrasts), "ffxmodel")
# Calculate the fixed effects Rsquared maps
ffxsummary = Node(FFXSummary(), "ffxsummary")
# Plot the fixedfx results
report = Node(FFXReport(space=space), "report")
# Save the experiment info
saveparams = Node(SaveParameters(exp_info=exp_info), "saveparams")
outputnode = Node(
IdentityInterface([
"flame_results", "r2_files", "tsnr_file", "mean_file",
"summary_report", "json_file", "zstat_report"
]), "outputs")
ffx = Workflow(name=name)
ffx.connect([
(inputnode, ffxmodel, [("copes", "copes"), ("varcopes", "varcopes"),
("dofs", "dofs"), ("masks", "masks"),
("reg_file", "reg_file")]),
(inputnode, ffxsummary, [("ss_files", "ss_files"), ("means", "means"),
("timeseries", "timeseries")]),
(inputnode, report, [("anatomy", "anatomy"), ("masks", "masks")]),
(inputnode, saveparams, [("timeseries", "in_file")]),
(ffxmodel, report, [("zstat_files", "zstat_files")]),
(ffxsummary, report, [("r2_files", "r2_files"),
("tsnr_file", "tsnr_file")]),
(ffxmodel, outputnode, [("flame_results", "flame_results")]),
(ffxsummary, outputnode, [("r2_files", "r2_files"),
("tsnr_file", "tsnr_file"),
("mean_file", "mean_file")]),
(report, outputnode, [("summary_files", "summary_report"),
("zstat_files", "zstat_report")]),
(saveparams, outputnode, [("json_file", "json_file")]),
])
return ffx, inputnode, outputnode
def create_bbregister_workflow(name="bbregister",
contrast_type="t2",
partial_brain=False,
init_with="fsl"):
"""Find a linear transformation to align the EPI file with the anatomy."""
in_fields = ["subject_id", "timeseries"]
if partial_brain:
in_fields.append("whole_brain_template")
inputnode = Node(IdentityInterface(in_fields), "inputs")
# Take the mean over time to get a target volume
meanvol = MapNode(fsl.MeanImage(), "in_file", "meanvol")
# Do a rough skullstrip using BET
skullstrip = MapNode(fsl.BET(), "in_file", "bet")
# Estimate the registration to Freesurfer conformed space
func2anat = MapNode(
fs.BBRegister(contrast_type=contrast_type,
init=init_with,
epi_mask=True,
registered_file=True,
out_reg_file="func2anat_tkreg.dat",
out_fsl_file="func2anat_flirt.mat"), "source_file",
"func2anat")
# Make an image for quality control on the registration
report = MapNode(CoregReport(), "in_file", "coreg_report")
# Define the workflow outputs
outputnode = Node(IdentityInterface(["tkreg_mat", "flirt_mat", "report"]),
"outputs")
bbregister = Workflow(name=name)
# Connect the registration
bbregister.connect([
(inputnode, func2anat, [("subject_id", "subject_id")]),
(inputnode, report, [("subject_id", "subject_id")]),
(inputnode, meanvol, [("timeseries", "in_file")]),
(meanvol, skullstrip, [("out_file", "in_file")]),
(skullstrip, func2anat, [("out_file", "source_file")]),
(func2anat, report, [("registered_file", "in_file")]),
(func2anat, outputnode, [("out_reg_file", "tkreg_mat")]),
(func2anat, outputnode, [("out_fsl_file", "flirt_mat")]),
(report, outputnode, [("out_file", "report")]),
])
# Possibly connect the full_fov image
if partial_brain:
bbregister.connect([
(inputnode, func2anat, [("whole_brain_template",
"intermediate_file")]),
])
return bbregister
def create_reg_workflow(name="reg",
space="mni",
regtype="model",
method="fsl",
residual=False,
cross_exp=False):
"""Flexibly register files into one of several common spaces."""
# Define the input fields flexibly
if regtype == "model":
fields = ["copes", "varcopes", "sumsquares"]
elif regtype == "timeseries":
fields = ["timeseries"]
if cross_exp:
fields.extend(["first_rigid"])
fields.extend(["means", "masks", "rigids"])
if space == "mni":
fields.extend(["affine", "warpfield"])
else:
fields.extend(["tkreg_rigid"])
inputnode = Node(IdentityInterface(fields), "inputnode")
# Grap the correct interface class dynamically
interface_name = "{}{}Registration".format(space.upper(),
regtype.capitalize())
reg_interface = globals()[interface_name]
transform = Node(reg_interface(method=method), "transform")
# Sanity check on inputs
if regtype == "model" and residual:
raise ValueError("residual and regtype=model does not make sense")
# Set the kind of timeseries
if residual:
transform.inputs.residual = True
outputnode = Node(IdentityInterface(["out_files"]), "outputnode")
# Define the workflow
regflow = Workflow(name=name)
# Connect the inputs programatically
for field in fields:
regflow.connect(inputnode, field, transform, field)
# The transform node only ever has one output
regflow.connect(transform, "out_files", outputnode, "out_files")
return regflow, inputnode, outputnode
def make_neuromet1_workflow(self):
# Infosource: Iterate through subject names
infosource = Node(interface=IdentityInterface(fields=['subject_id']),
name="infosource")
infosource.iterables = ('subject_id', self.subject_list)
# unidensource, return for every subject uni and den
unidensource = Node(interface=IdentityInterface(fields=['uniden']),
name="unidensource")
unidensource.iterables = ('uniden', ['UNI', 'DEN'])
info = dict(t1=[['subject_id', 'subject_id', 'uniden']])
datasource = Node(interface=DataGrabber(
infields=['subject_id', 'uniden'], outfields=['t1']),
name='datasource')
datasource.inputs.base_directory = self.w_dir
datasource.inputs.template = '{prefix}%s/{prefix}%s.%s_mp2rage_orig.nii.gz'.format(
prefix=self.subject_prefix)
datasource.inputs.template_args = info
datasource.inputs.sort_filelist = False
sink = self.make_sink()
segment = self.make_segment()
mask = self.make_mask()
neuromet = Workflow(name=self.subject_prefix, base_dir=self.temp_dir)
neuromet.connect(infosource, 'subject_id', datasource, 'subject_id')
neuromet.connect(unidensource, 'uniden', datasource, 'uniden')
neuromet.connect(datasource, 't1', segment, 'ro.in_file')
# neuromet.connect()
neuromet.connect(segment, 'spm_tissues_split.gm', mask,
'sum_tissues1.in_file')
neuromet.connect(segment, 'spm_tissues_split.wm', mask,
'sum_tissues1.operand_files')
neuromet.connect(segment, 'spm_tissues_split.csf', mask,
'sum_tissues2.operand_files')
neuromet.connect(segment, 'spm_tissues_split.gm', sink, '@gm')
neuromet.connect(segment, 'spm_tissues_split.wm', sink, '@wm')
neuromet.connect(segment, 'spm_tissues_split.csf', sink, '@csf')
neuromet.connect(segment, 'seg.bias_corrected_images', sink,
'@biascorr')
# neuromet.connect(comb_imgs, 'uni_brain_den_surr_add.out_file', sink, '@img')
neuromet.connect(mask, 'gen_mask.out_file', sink, '@mask')
neuromet.connect(segment, 'ro.out_file', sink, '@ro')
return neuromet
def workflow_spec(name="{workflow_name}", exp_info=None):
"""Return a Nipype workflow for MR processing.
Parameters
----------
name : string
workflow object name
exp_info : dict
dictionary with experimental information
"""
workflow = Workflow(name)
if exp_info is None:
exp_info = fitz.default_experiment_parameters()
# Define the inputs for the preprocessing workflow
in_fields = [""] # "timeseries"]
inputnode = Node(IdentityInterface(in_fields), "inputs")
"""
# Define Actual Nipype Nodes, Workflows, etc.
# e.g. The start of an example SPM preproc workflow
# --------------------------------------------------
slicetiming = pe.Node(interface=spm.SliceTiming(), name="slicetiming")
slicetiming.inputs.ref_slice = 1
realign = pe.Node(interface=spm.Realign(), name="realign")
realign.inputs.register_to_mean = True
"""
workflow.connect([
"""
(inputnode, slicetiming,
[('timeseries', 'in_files')]),
(slicetiming, realign,
[('timecorrected_files', 'in_files')]),
"""
])
output_fields = [""] # realigned_files", "realignment_parameters"]
outputnode = Node(IdentityInterface(output_fields), "outputs")
workflow.connect([
"""
(realign, outputnode,
[("realigned_files", "realigned_files"),
("realignment_parameters", "realignment_parameters")]),
"""
])
# Return the workflow itself and input and output nodes.
return workflow, inputnode, outputnode
def create_machine_learning_workflow(name="CreateEdgeProbabilityMap",
resample=True,
plugin_args=None):
"""
This function...
:param name:
:param resample:
:param plugin_args:
:return:
"""
workflow = Workflow(name)
input_spec = Node(IdentityInterface([
"rho", "phi", "theta", "posteriors", "t1_file", "acpc_transform",
"gm_classifier_file", "wm_classifier_file"
]),
name="input_spec")
predict_edge_probability = Node(PredictEdgeProbability(),
name="PredictEdgeProbability")
if plugin_args:
predict_edge_probability.plugin_args = plugin_args
workflow.connect([(input_spec, predict_edge_probability,
[("t1_file", "t1_file"),
("gm_classifier_file", "gm_classifier_file"),
("wm_classifier_file", "wm_classifier_file")])])
if resample:
collect_features = Node(CollectFeatureFiles(),
name="CollectFeatureFiles")
collect_features.inputs.inverse_transform = True
workflow.connect([(input_spec, collect_features,
[("rho", "rho"), ("phi", "phi"), ("theta", "theta"),
("posteriors", "posterior_files"),
("t1_file", "reference_file"),
("acpc_transform", "transform_file")])])
workflow.connect([(collect_features, predict_edge_probability,
[("feature_files", "additional_files")])])
else:
print("workflow not yet created")
# TODO: create workflow that does not resample the input images
return
output_spec = Node(IdentityInterface(
["gm_probability_map", "wm_probability_map"]),
name="output_spec")
workflow.connect(predict_edge_probability, "gm_edge_probability",
output_spec, "gm_probability_map")
workflow.connect(predict_edge_probability, "wm_edge_probability",
output_spec, "wm_probability_map")
return workflow
def create_slicetime_workflow(name="slicetime",
TR=2,
slice_order="up",
interleaved=False):
inputnode = Node(IdentityInterface(["timeseries"]), "inputs")
if isinstance(interleaved, str) and interleaved.lower() == "siemens":
sliceorder = MapNode(SiemensSliceOrder(), "in_file", "sliceorder")
slicetimer_set_interleaved = False
slicetimer_iterfields = ["in_file", "custom_order"]
elif isinstance(interleaved, bool):
sliceorder = None
slicetimer_set_interleaved = interleaved
slicetimer_iterfields = ["in_file"]
else:
raise ValueError("interleaved must be True, False, or 'siemens'")
slicetimer = MapNode(fsl.SliceTimer(time_repetition=TR),
slicetimer_iterfields, "slicetime")
if slicetimer_set_interleaved:
slicetimer.inputs.interleaved = True
if slice_order == "down":
slicetimer.inputs.index_dir = True
elif slice_order != "up":
raise ValueError("slice_order must be 'up' or 'down'")
outputnode = Node(IdentityInterface(["timeseries"]), "outputs")
slicetime = Workflow(name)
slicetime.connect([
(inputnode, slicetimer, [("timeseries", "in_file")]),
(slicetimer, outputnode, [("slice_time_corrected_file", "timeseries")
]),
])
if sliceorder is not None:
slicetime.connect([
(inputnode, sliceorder, [("timeseries", "in_file")]),
(sliceorder, slicetimer, [("out_file", "custom_order")]),
])
return slicetime
def make_simple_workflow():
wf = Workflow(name="test")
node1 = Node(IdentityInterface(fields=["foo"]), name="node1")
node2 = MapNode(IdentityInterface(fields=["foo"]),
name="node2",
iterfield=["foo"])
node3 = Node(IdentityInterface(fields=["foo"]), name="node3")
wf.connect([
(node1, node2, [("foo", "foo")]),
(node2, node3, [("foo", "foo")]),
])
return wf, node1, node2, node3
def _tr_points_wf():
wf = pe.Workflow('trpointswf')
inputspec = pe.Node(IdentityInterface(['T1', 'model', 'points']), 'inputspec')
reg = pe.Node(ants_registration_affine_node(write_composite_transform=False), name='register')
convertpoints = pe.Node(ConvertPoints(in_format='tsv', out_format='ants'), 'convert_points')
trpoints = pe.Node(ApplyTransformsToPoints(dimension=3), name='transform_points')
convertpoints2 = pe.Node(ConvertPoints(in_format='ants', out_format='tsv'), 'convert_points2')
outputspec = pe.Node(IdentityInterface(['out_points']), 'outputspec')
wf.connect([(inputspec, reg, [('T1', 'moving_image'),
('model', 'fixed_image')]),
(inputspec, convertpoints, [('points', 'in_file')]),
(reg, trpoints, [('forward_transforms', 'transforms')]),
(convertpoints, trpoints, [('out_file', 'input_file')]),
(trpoints, convertpoints2, [('output_file', 'in_file')]),
(convertpoints2, outputspec, [('out_file', 'out_points')])])
return wf
def create_surface_projection_workflow(name="surfproj", exp_info=None):
"""Project the group mask and thresholded zstat file onto the surface."""
if exp_info is None:
exp_info = lyman.default_experiment_parameters()
inputnode = Node(IdentityInterface(["zstat_file", "mask_file"]), "inputs")
# Sample the zstat image to the surface
hemisource = Node(IdentityInterface(["mni_hemi"]), "hemisource")
hemisource.iterables = ("mni_hemi", ["lh", "rh"])
zstatproj = Node(
freesurfer.SampleToSurface(sampling_method=exp_info["sampling_method"],
sampling_range=exp_info["sampling_range"],
sampling_units=exp_info["sampling_units"],
smooth_surf=exp_info["surf_smooth"],
subject_id="fsaverage",
mni152reg=True,
target_subject="fsaverage"), "zstatproj")
# Sample the mask to the surface
maskproj = Node(
freesurfer.SampleToSurface(sampling_range=exp_info["sampling_range"],
sampling_units=exp_info["sampling_units"],
subject_id="fsaverage",
mni152reg=True,
target_subject="fsaverage"), "maskproj")
if exp_info["sampling_method"] == "point":
maskproj.inputs.sampling_method = "point"
else:
maskproj.inputs.sampling_method = "max"
outputnode = Node(IdentityInterface(["surf_zstat", "surf_mask"]),
"outputs")
# Define and connect the workflow
proj = Workflow(name)
proj.connect([
(inputnode, zstatproj, [("zstat_file", "source_file")]),
(inputnode, maskproj, [("mask_file", "source_file")]),
(hemisource, zstatproj, [("mni_hemi", "hemi")]),
(hemisource, maskproj, [("mni_hemi", "hemi")]),
(zstatproj, outputnode, [("out_file", "surf_zstat")]),
(maskproj, outputnode, [("out_file", "surf_mask")]),
])
return proj
def amide_noe(zfrqs, name='Amide_NOE'):
inputnode = Node(IdentityInterface(fields=['zspec_file', 'mask_file']),
name='inputnode')
outputnode = Node(IdentityInterface(fields=['diff_file', 'DS', 'MT', 'Amide', 'NOE']),
name='outputnode')
# Repeat 2-pool fit
f0_indices = (np.abs(zfrqs) > 9.9) | (np.abs(zfrqs) < 1.1)
sequence = {'MTSat': {'pulse': {'p1': 0.4,
'p2': 0.3,
'bandwidth': 0.39},
'Trf': 0.02,
'TR': 4,
'FA': 5,
'sat_f0': zfrqs[f0_indices].tolist(),
'sat_angle': np.repeat(180.0, len(f0_indices)).tolist()}}
backg_select = Node(Select(volumes=np.where(f0_indices)[0].tolist(), out_file='bg_zspec.nii.gz'),
name='backg_select')
def init_complex_mcf(name='', ref=False, fix_ge=True, negate=True):
inputnode = Node(
IdentityInterface(fields=['real_file', 'imag_file', 'ref_file']),
name='inputnode')
outputnode = Node(
IdentityInterface(fields=['x_file', 'ref_file', 'mask_file']),
name='outputnode')
ri = Node(Complex(fix_ge=fix_ge,
negate=negate,
magnitude_out_file=name + '_mag.nii.gz',
real_out_file=name + '_r.nii.gz',
imag_out_file=name + '_i.nii.gz'),
name='ri_' + name)
moco = Node(MCFLIRT(mean_vol=not ref, save_mats=True), name='moco_' + name)
apply_r = Node(ApplyXfm4D(four_digit=True), name='apply_r' + name)
apply_i = Node(ApplyXfm4D(four_digit=True), name='apply_i' + name)
x = Node(Complex(complex_out_file=name + '_x.nii.gz'), name='x_' + name)
f = Node(Filter(complex_in=True, complex_out=True, filter_spec='Tukey'),
name='filter_' + name)
wf = Workflow(name='prep_' + name)
wf.connect([(inputnode, ri, [('real_file', 'real')]),
(inputnode, ri, [('imag_file', 'imag')]),
(ri, moco, [('magnitude_out_file', 'in_file')]),
(ri, apply_r, [('real_out_file', 'in_file')]),
(ri, apply_i, [('imag_out_file', 'in_file')]),
(moco, apply_r, [('mat_dir', 'trans_dir')]),
(moco, apply_i, [('mat_dir', 'trans_dir')]),
(apply_r, x, [('out_file', 'real')]),
(apply_i, x, [('out_file', 'imag')]),
(x, f, [('complex_out_file', 'in_file')]),
(f, outputnode, [('out_file', 'x_file')])])
if not ref:
mask = Node(BET(mask=True, no_output=True), name='mask')
wf.connect([(moco, mask, [('mean_img', 'in_file')]),
(moco, apply_r, [('mean_img', 'ref_vol')]),
(moco, apply_i, [('mean_img', 'ref_vol')]),
(moco, outputnode, [('mean_img', 'ref_file')]),
(mask, outputnode, [('mask_file', 'mask_file')])])
else:
wf.connect([(inputnode, moco, [('ref_file', 'ref_file')]),
(inputnode, apply_r, [('ref_file', 'ref_vol')]),
(inputnode, apply_i, [('ref_file', 'ref_vol')])])
return wf
def make_infosource(self):
# Infosource: Iterate through subject names
infosource = Node(interface=IdentityInterface(fields=['subject_id']),
name="infosource")
infosource.iterables = ('subject_id', self.subject_list)
return infosource
def create_identity_interface_node(inputs, name):
"""
This function...
:param inputs:
:param name:
:return:
"""
return Node(IdentityInterface(inputs), name=name)
def create_filtering_workflow(name="filter",
hpf_cutoff=128,
TR=2,
output_name="timeseries"):
"""Scale and high-pass filter the timeseries."""
inputnode = Node(IdentityInterface(["timeseries", "mask_file"]), "inputs")
# Grand-median scale within the brain mask
scale = MapNode(ScaleTimeseries(statistic="median", target=10000),
["in_file", "mask_file"], "scale")
# Gaussian running-line filter
if hpf_cutoff is None:
hpf_sigma = -1
else:
hpf_sigma = (hpf_cutoff / 2.0) / TR
filter = MapNode(fsl.TemporalFilter(highpass_sigma=hpf_sigma), "in_file",
"filter")
# Possibly replace the mean
# (In later versions of FSL, the highpass filter removes the
# mean component. Put it back, but be flexible so this isn't
# broken on older versions of FSL).
replacemean = MapNode(ReplaceMean(output_name=output_name),
["orig_file", "filtered_file"], "replacemean")
# Compute a final mean functional volume
meanfunc = MapNode(fsl.MeanImage(out_file="mean_func.nii.gz"), "in_file",
"meanfunc")
outputnode = Node(IdentityInterface(["timeseries", "mean_file"]),
"outputs")
filtering = Workflow(name)
filtering.connect([
(inputnode, scale, [("timeseries", "in_file"),
("mask_file", "mask_file")]),
(scale, filter, [("out_file", "in_file")]),
(scale, replacemean, [("out_file", "orig_file")]),
(filter, replacemean, [("out_file", "filtered_file")]),
(replacemean, meanfunc, [("out_file", "in_file")]),
(replacemean, outputnode, [("out_file", "timeseries")]),
(meanfunc, outputnode, [("out_file", "mean_file")]),
])
return filtering
def create_realignment_workflow(name="realignment"):
"""Motion and slice-time correct the timeseries and summarize."""
inputnode = Node(IdentityInterface(["timeseries"]), "inputs")
# Get the middle volume of each run for motion correction
extractref = MapNode(ExtractRealignmentTarget(), "in_file", "extractref")
# Motion correct to middle volume of each run
mcflirt = MapNode(
fsl.MCFLIRT(cost="normcorr",
interpolation="spline",
save_mats=True,
save_rms=True,
save_plots=True), ["in_file", "ref_file"], "mcflirt")
# Generate a report on the motion correction
mcreport = MapNode(RealignmentReport(),
["target_file", "realign_params", "displace_params"],
"mcreport")
# Define the outputs
outputnode = Node(
IdentityInterface(
["timeseries", "example_func", "report", "motion_file"]),
"outputs")
# Define and connect the sub workflow
realignment = Workflow(name)
realignment.connect([
(inputnode, extractref, [("timeseries", "in_file")]),
(inputnode, mcflirt, [("timeseries", "in_file")]),
(extractref, mcflirt, [("out_file", "ref_file")]),
(extractref, mcreport, [("out_file", "target_file")]),
(mcflirt, mcreport, [("par_file", "realign_params"),
("rms_files", "displace_params")]),
(mcflirt, outputnode, [("out_file", "timeseries")]),
(extractref, outputnode, [("out_file", "example_func")]),
(mcreport, outputnode, [("realign_report", "report"),
("motion_file", "motion_file")]),
])
return realignment
def create_unwarp_workflow(name="unwarp", fieldmap_pe=("y", "y-")):
"""Unwarp functional timeseries using reverse phase-blipped images."""
inputnode = Node(IdentityInterface(["timeseries", "fieldmap"]), "inputs")
# Calculate the shift field
# Note that setting readout_times to 1 will give a fine
# map of the field, but the units will be off
# Since we don't write out the map of the field itself, it does
# not seem worth it to add another parameter for the readout times.
# (It does require that they are the same, but when wouldn't they be?)
topup = MapNode(
fsl.TOPUP(encoding_direction=fieldmap_pe,
readout_times=[1] * len(fieldmap_pe)), ["in_file"], "topup")
# Unwarp the timeseries
applytopup = MapNode(fsl.ApplyTOPUP(method="jac", in_index=[
1
]), ["in_files", "in_topup_fieldcoef", "in_topup_movpar", "encoding_file"],
"applytopup")
# Make a figure summarize the unwarping
report = MapNode(UnwarpReport(), ["orig_file", "corrected_file"],
"unwarp_report")
# Define the outputs
outputnode = Node(IdentityInterface(["timeseries", "report"]), "outputs")
# Define and connect the workflow
unwarp = Workflow(name)
unwarp.connect([
(inputnode, topup, [("fieldmap", "in_file")]),
(inputnode, applytopup, [("timeseries", "in_files")]),
(topup, applytopup, [("out_fieldcoef", "in_topup_fieldcoef"),
("out_movpar", "in_topup_movpar"),
("out_enc_file", "encoding_file")]),
(inputnode, report, [("fieldmap", "orig_file")]),
(topup, report, [("out_corrected", "corrected_file")]),
(applytopup, outputnode, [("out_corrected", "timeseries")]),
(report, outputnode, [("out_file", "report")]),
])
return unwarp
def cert(zfrqs):
inputnode = Node(IdentityInterface(fields=['cert_180', 'cert_360', 'mask_file']),
name='inputnode')
outputnode = Node(IdentityInterface(fields=['cert_spectrum', 'cert_amide']),
name='outputnode')
cert_sub = Node(ImageMaths(op_string='-sub', out_file='cert.nii.gz'),
name='cert_subtract')
amide_index = (np.abs(zfrqs - 3.5)).argmin()
amide = Node(ExtractROI(t_min=amide_index, t_size=1),
name='amide_extract')
cert = Workflow(name='CERT')
cert.connect([(inputnode, cert_sub, [('cert_360', 'in_file'), ('cert_180', 'in_file2')]),
(cert_sub, amide, [('out_file', 'in_file')]),
(cert_sub, outputnode, [('out_file', 'cert_spectrum')]),
(amide, outputnode, [('roi_file', 'cert_amide')])
])
return cert
def cert(zfrqs):
inputnode = Node(IdentityInterface(fields=['cert_180', 'cert_360', 'mask_file']),
name='inputnode')
outputnode = Node(IdentityInterface(fields=['cert_spectrum', 'cert_amide']),
name='outputnode')
cert_sub = Node(ImageMaths(op_string='-sub', out_file='cert.nii.gz'),
name='cert_subtract', iterfield=['in_file'])
amide_index = (np.abs(zfrqs - 3.5)).argmin()
amide = Node(Select(volumes=[amide_index], out_file='amide.nii.gz'),
name='select_amide')
cert = Workflow(name='CERT')
cert.connect([(inputnode, cert_sub, [('cert_360', 'in_file'), ('cert_180', 'in_file2')]),
(cert_sub, amide, [('out_file', 'in_file')]),
(cert_sub, outputnode, [('out_file', 'cert_spectrum')]),
(amide, outputnode, [('out_file', 'cert_amide')])
])
return cert
def create_confound_extraction_workflow(name="confounds", wm_components=6):
"""Extract nuisance variables from anatomical sources."""
inputnode = Node(
IdentityInterface(
["timeseries", "brain_mask", "reg_file", "subject_id"]), "inputs")
# Find the subject's Freesurfer segmentation
# Grab the Freesurfer aparc+aseg file as an anatomical brain mask
getaseg = Node(
io.SelectFiles({"aseg": "{subject_id}/mri/aseg.mgz"},
base_directory=os.environ["SUBJECTS_DIR"]), "getaseg")
# Select and erode the white matter to get deep voxels
selectwm = Node(fs.Binarize(erode=3, wm=True), "selectwm")
# Transform the mask into functional space
transform = MapNode(fs.ApplyVolTransform(inverse=True, interp="nearest"),
["reg_file", "source_file"], "transform")
# Extract eigenvariates of the timeseries from WM and whole brain
extract = MapNode(ExtractConfounds(n_components=wm_components),
["timeseries", "brain_mask", "wm_mask"], "extract")
outputnode = Node(IdentityInterface(["confound_file"]), "outputs")
confounds = Workflow(name)
confounds.connect([
(inputnode, getaseg, [("subject_id", "subject_id")]),
(getaseg, selectwm, [("aseg", "in_file")]),
(selectwm, transform, [("binary_file", "target_file")]),
(inputnode, transform, [("reg_file", "reg_file"),
("timeseries", "source_file")]),
(transform, extract, [("transformed_file", "wm_mask")]),
(inputnode, extract, [("timeseries", "timeseries"),
("brain_mask", "brain_mask")]),
(extract, outputnode, [("out_file", "confound_file")]),
])
return confounds
def runNipypeBet(controller, subject_list, anatomical_id, proj_directory):
infosource = Node(IdentityInterface(fields=['subject_id']),
name="infosource")
infosource.iterables = [('subject_id', subject_list)]
#anat_file = opj('{subject_id}','{subject_id}_{anatomical_id}.nii')
seperator = ''
concat_words = ('{subject_id}_', anatomical_id, '.nii.gz')
anat_file_name = seperator.join(concat_words)
if controller.b_radiological_convention.get() == True:
anat_file = opj('{subject_id}', anat_file_name)
else:
anat_file = opj('{subject_id}', 'Intermediate_Files', 'Original_Files',
anat_file_name)
templates = {'anat': anat_file}
selectfiles = Node(SelectFiles(templates, base_directory=proj_directory),
name="selectfiles")
skullstrip = Node(BET(robust=True,
frac=0.5,
vertical_gradient=0,
output_type='NIFTI_GZ'),
name="skullstrip")
# Datasink - creates output folder for important outputs
datasink = Node(DataSink(base_directory=proj_directory), name="datasink")
wf_sub = Workflow(name="wf_sub")
wf_sub.base_dir = proj_directory
wf_sub.connect(infosource, "subject_id", selectfiles, "subject_id")
wf_sub.connect(selectfiles, "anat", skullstrip, "in_file")
wf_sub.connect(skullstrip, "out_file", datasink, "bet.@out_file")
substitutions = [('%s_brain' % (anatomical_id), 'brain')]
# Feed the substitution strings to the DataSink node
datasink.inputs.substitutions = substitutions
# Run the workflow again with the substitutions in place
wf_sub.run(plugin='MultiProc')
return 'brain'
def with_runs(self, runs: t.List[str]):
self.runselector = Node(IdentityInterface(fields=['run']),
name="RunSelector")
self.runselector.iterables = ('run', runs)
self.report_creator.inputs.runs = runs
fields = self.last_join.interface._fields
self.pipeline_quality_measures_join_runs = create_flatten_identity_join_node(
name="JoinPipelinesQualityMeasuresOverRuns",
fields=fields,
joinsource=self.runselector,
flatten_fields=fields)
self.connections += [
(self.runselector, self.bidsgrabber, [('run', 'run')]),
(self.runselector, self.pipelines_quality_measures, [('run', 'run')
]),
(self.last_join, self.pipeline_quality_measures_join_runs,
list(zip(fields, fields)))
]
self.last_join = self.pipeline_quality_measures_join_runs
def create_corthick_wf():
import nipype.pipeline.engine as pe # pypeline engine
import os
from nipype import IdentityInterface
from nipype.interfaces.ants.segmentation import KellyKapowski
from nipype.interfaces.io import DataSink
corthick_wf = pe.Workflow(name='corthick_wf')
inputspec = pe.Node(IdentityInterface(
fields=['seg_file', 'wmprob_file', 'out_dir'], mandatory_inputs=False),
name='inputspec')
DiReCT = pe.Node(KellyKapowski(), name='DiReCt')
sinker = pe.Node(DataSink(parameterization=True), name='sinker')
corthick_wf.connect([
(inputspec, DiReCT, [('seg_file', 'segmentation_image'),
('wmprob_file', 'white_matter_prob_image')]),
(inputspec, sinker, [('out_dir', 'base_directory')]),
(DiReCT, sinker, [('cortical_thickness', 'out.@thick'),
('warped_white_matter', 'out.@wm')]),
])
return corthick_wf
def analysis_steps(self):
self.analysis = type('', (), {})()
# Get files
subj_list = [
subj.split('_')[:-1] for subj in next(os.walk(self.proj_dir))[1]
]
# TODO limit the subj_list to those without sw processed files.
# for parallelization by subject, use idnetityInterface
self.analysis.infosource = Node(
IdentityInterface(fields=['subj_id', 'task']), name="infosource")
self.analysis.infosource.iterables = [('subject_id', subj_list),
('task', self.task_names)]
templates = {
'anat': '{subj_id}/t1/{subj_id}_t1*.nii',
'func': '{subj_id}/{task}*/{subj_id}_{task}*.nii'
}
self.analysis.sf = Node(SelectFiles(templates), name='selectfiles')
self.analysis.sf.inputs.base_directory = self.proj_dir
# Realign
self.analysis.realign = Node(spm.Realign(register_to_mean=True,
fwhm=self.opts.fwhm),
name='realign')
# Coregister
self.analysis.coreg = Node(spm.Coregister(), name='coregistration')
# Normalize
self.analysis.norm12 = Node(spm.Normalize12(
bias_regularization=1e-05, affine_regularization_type='mni'),
name='normalize')
#Smooth
self.analysis.smooth = Node(spm.Smooth(), name='smooth')
#smooth.inputs.in_files = 'functional.nii'
self.analysis.smooth.inputs.fwhm = self.opts.smooth_fwhm