sty: fix examples

Author: satra

examples/dmri_camino_dti.py

@@ -18,15 +18,14 @@
 Import necessary modules from nipype.
 """
 
-import os                                    # system functions
-import nipype.interfaces.io as nio           # Data i/o
-import nipype.interfaces.utility as util     # utility
-import nipype.pipeline.engine as pe          # pypeline engine
+import os  # system functions
+import nipype.interfaces.io as nio  # Data i/o
+import nipype.interfaces.utility as util  # utility
+import nipype.pipeline.engine as pe  # pypeline engine
 import nipype.interfaces.camino as camino
 import nipype.interfaces.fsl as fsl
 import nipype.interfaces.camino2trackvis as cam2trk
 import nipype.algorithms.misc as misc
-
 """
 We use the following functions to scrape the voxel and data dimensions of the input images. This allows the
 pipeline to be flexible enough to accept and process images of varying size. The SPM Face tutorial
@@ -62,21 +61,20 @@ def get_affine(volume):
     nii = nb.load(volume, mmap=NUMPY_MMAP)
     return nii.affine
 
+
 subject_list = ['subj1']
 fsl.FSLCommand.set_default_output_type('NIFTI')
-
-
 """
 Map field names to individual subject runs
 """
 
-info = dict(dwi=[['subject_id', 'data']],
-            bvecs=[['subject_id', 'bvecs']],
-            bvals=[['subject_id', 'bvals']])
-
-infosource = pe.Node(interface=util.IdentityInterface(fields=['subject_id']),
-                     name="infosource")
+info = dict(
+    dwi=[['subject_id', 'data']],
+    bvecs=[['subject_id', 'bvecs']],
+    bvals=[['subject_id', 'bvals']])
 
+infosource = pe.Node(
+    interface=util.IdentityInterface(fields=['subject_id']), name="infosource")
 """Here we set up iteration over all the subjects. The following line
 is a particular example of the flexibility of the system.  The
 ``datasource`` attribute ``iterables`` tells the pipeline engine that
@@ -87,7 +85,6 @@ def get_affine(volume):
 """
 
 infosource.iterables = ('subject_id', subject_list)
-
 """
 Now we create a :class:`nipype.interfaces.io.DataGrabber` object and
 fill in the information from above about the layout of our data.  The
@@ -96,9 +93,10 @@ def get_affine(volume):
 functionality.
 """
 
-datasource = pe.Node(interface=nio.DataGrabber(infields=['subject_id'],
-                                               outfields=list(info.keys())),
-                     name='datasource')
+datasource = pe.Node(
+    interface=nio.DataGrabber(
+        infields=['subject_id'], outfields=list(info.keys())),
+    name='datasource')
 
 datasource.inputs.template = "%s/%s"
 
@@ -109,13 +107,13 @@ def get_affine(volume):
 datasource.inputs.field_template = dict(dwi='%s/%s.nii.gz')
 datasource.inputs.template_args = info
 datasource.inputs.sort_filelist = True
-
 """
 An inputnode is used to pass the data obtained by the data grabber to the actual processing functions
 """
 
-inputnode = pe.Node(interface=util.IdentityInterface(fields=["dwi", "bvecs", "bvals"]), name="inputnode")
-
+inputnode = pe.Node(
+    interface=util.IdentityInterface(fields=["dwi", "bvecs", "bvals"]),
+    name="inputnode")
 """
 Setup for Diffusion Tensor Computation
 --------------------------------------
@@ -126,13 +124,11 @@ def get_affine(volume):
 image2voxel = pe.Node(interface=camino.Image2Voxel(), name="image2voxel")
 fsl2scheme = pe.Node(interface=camino.FSL2Scheme(), name="fsl2scheme")
 fsl2scheme.inputs.usegradmod = True
-
 """
 Second, diffusion tensors are fit to the voxel-order data.
 """
 
 dtifit = pe.Node(interface=camino.DTIFit(), name='dtifit')
-
 """
 Next, a lookup table is generated from the schemefile and the
 signal-to-noise ratio (SNR) of the unweighted (q=0) data.
@@ -141,7 +137,6 @@ def get_affine(volume):
 dtlutgen = pe.Node(interface=camino.DTLUTGen(), name="dtlutgen")
 dtlutgen.inputs.snr = 16.0
 dtlutgen.inputs.inversion = 1
-
 """
 In this tutorial we implement probabilistic tractography using the PICo algorithm.
 PICo tractography requires an estimate of the fibre direction and a model of its
@@ -150,29 +145,25 @@ def get_affine(volume):
 
 picopdfs = pe.Node(interface=camino.PicoPDFs(), name="picopdfs")
 picopdfs.inputs.inputmodel = 'dt'
-
 """
 An FSL BET node creates a brain mask is generated from the diffusion image for seeding the PICo tractography.
 """
 
 bet = pe.Node(interface=fsl.BET(), name="bet")
 bet.inputs.mask = True
-
 """
 Finally, tractography is performed.
 First DT streamline tractography.
 """
 
 trackdt = pe.Node(interface=camino.TrackDT(), name="trackdt")
-
 """
 Now camino's Probablistic Index of connectivity algorithm.
 In this tutorial, we will use only 1 iteration for time-saving purposes.
 """
 
 trackpico = pe.Node(interface=camino.TrackPICo(), name="trackpico")
 trackpico.inputs.iterations = 1
-
 """
 Currently, the best program for visualizing tracts is TrackVis. For this reason, a node is included to
 convert the raw tract data to .trk format. Solely for testing purposes, another node is added to perform the reverse.
@@ -182,21 +173,20 @@ def get_affine(volume):
 cam2trk_dt.inputs.min_length = 30
 cam2trk_dt.inputs.voxel_order = 'LAS'
 
-cam2trk_pico = pe.Node(interface=cam2trk.Camino2Trackvis(), name="cam2trk_pico")
+cam2trk_pico = pe.Node(
+    interface=cam2trk.Camino2Trackvis(), name="cam2trk_pico")
 cam2trk_pico.inputs.min_length = 30
 cam2trk_pico.inputs.voxel_order = 'LAS'
 
 trk2camino = pe.Node(interface=cam2trk.Trackvis2Camino(), name="trk2camino")
-
 """
 Tracts can also be converted to VTK and OOGL formats, for use in programs such as GeomView and Paraview,
 using the following two nodes. For VTK use VtkStreamlines.
 """
 
-procstreamlines = pe.Node(interface=camino.ProcStreamlines(), name="procstreamlines")
+procstreamlines = pe.Node(
+    interface=camino.ProcStreamlines(), name="procstreamlines")
 procstreamlines.inputs.outputtracts = 'oogl'
-
-
 """
 We can also produce a variety of scalar values from our fitted tensors. The following nodes generate the
 fractional anisotropy and diffusivity trace maps and their associated headers.
@@ -206,45 +196,39 @@ def get_affine(volume):
 trace = pe.Node(interface=camino.ComputeTensorTrace(), name='trace')
 dteig = pe.Node(interface=camino.ComputeEigensystem(), name='dteig')
 
-analyzeheader_fa = pe.Node(interface=camino.AnalyzeHeader(), name="analyzeheader_fa")
+analyzeheader_fa = pe.Node(
+    interface=camino.AnalyzeHeader(), name="analyzeheader_fa")
 analyzeheader_fa.inputs.datatype = "double"
 analyzeheader_trace = analyzeheader_fa.clone('analyzeheader_trace')
 
 fa2nii = pe.Node(interface=misc.CreateNifti(), name='fa2nii')
 trace2nii = fa2nii.clone("trace2nii")
-
 """
 Since we have now created all our nodes, we can now define our workflow and start making connections.
 """
 
 tractography = pe.Workflow(name='tractography')
 
 tractography.connect([(inputnode, bet, [("dwi", "in_file")])])
-
 """
 File format conversion
 """
 
 tractography.connect([(inputnode, image2voxel, [("dwi", "in_file")]),
                       (inputnode, fsl2scheme, [("bvecs", "bvec_file"),
-                                               ("bvals", "bval_file")])
-                      ])
-
+                                               ("bvals", "bval_file")])])
 """
 Tensor fitting
 """
 
 tractography.connect([(image2voxel, dtifit, [['voxel_order', 'in_file']]),
-                      (fsl2scheme, dtifit, [['scheme', 'scheme_file']])
-                      ])
-
+                      (fsl2scheme, dtifit, [['scheme', 'scheme_file']])])
 """
 Workflow for applying DT streamline tractogpahy
 """
 
 tractography.connect([(bet, trackdt, [("mask_file", "seed_file")])])
 tractography.connect([(dtifit, trackdt, [("tensor_fitted", "in_file")])])
-
 """
 Workflow for applying PICo
 """
@@ -257,8 +241,6 @@ def get_affine(volume):
 
 # ProcStreamlines might throw memory errors - comment this line out in such case
 tractography.connect([(trackdt, procstreamlines, [("tracked", "in_file")])])
-
-
 """
 Connecting the Fractional Anisotropy and Trace nodes is simple, as they obtain their input from the
 tensor fitting.
@@ -270,32 +252,35 @@ def get_affine(volume):
 
 tractography.connect([(dtifit, fa, [("tensor_fitted", "in_file")])])
 tractography.connect([(fa, analyzeheader_fa, [("fa", "in_file")])])
-tractography.connect([(inputnode, analyzeheader_fa, [(('dwi', get_vox_dims), 'voxel_dims'),
-                                                     (('dwi', get_data_dims), 'data_dims')])])
+tractography.connect([(inputnode, analyzeheader_fa,
+                       [(('dwi', get_vox_dims), 'voxel_dims'),
+                        (('dwi', get_data_dims), 'data_dims')])])
 tractography.connect([(fa, fa2nii, [('fa', 'data_file')])])
 tractography.connect([(inputnode, fa2nii, [(('dwi', get_affine), 'affine')])])
 tractography.connect([(analyzeheader_fa, fa2nii, [('header', 'header_file')])])
 
-
 tractography.connect([(dtifit, trace, [("tensor_fitted", "in_file")])])
 tractography.connect([(trace, analyzeheader_trace, [("trace", "in_file")])])
-tractography.connect([(inputnode, analyzeheader_trace, [(('dwi', get_vox_dims), 'voxel_dims'),
-                                                        (('dwi', get_data_dims), 'data_dims')])])
+tractography.connect([(inputnode, analyzeheader_trace,
+                       [(('dwi', get_vox_dims), 'voxel_dims'),
+                        (('dwi', get_data_dims), 'data_dims')])])
 tractography.connect([(trace, trace2nii, [('trace', 'data_file')])])
-tractography.connect([(inputnode, trace2nii, [(('dwi', get_affine), 'affine')])])
-tractography.connect([(analyzeheader_trace, trace2nii, [('header', 'header_file')])])
+tractography.connect([(inputnode, trace2nii, [(('dwi', get_affine),
+                                               'affine')])])
+tractography.connect([(analyzeheader_trace, trace2nii, [('header',
+                                                         'header_file')])])
 
 tractography.connect([(dtifit, dteig, [("tensor_fitted", "in_file")])])
 
 tractography.connect([(trackpico, cam2trk_pico, [('tracked', 'in_file')])])
 tractography.connect([(trackdt, cam2trk_dt, [('tracked', 'in_file')])])
-tractography.connect([(inputnode, cam2trk_pico, [(('dwi', get_vox_dims), 'voxel_dims'),
-                                                 (('dwi', get_data_dims), 'data_dims')])])
-
-tractography.connect([(inputnode, cam2trk_dt, [(('dwi', get_vox_dims), 'voxel_dims'),
-                                               (('dwi', get_data_dims), 'data_dims')])])
-
+tractography.connect([(inputnode, cam2trk_pico,
+                       [(('dwi', get_vox_dims), 'voxel_dims'),
+                        (('dwi', get_data_dims), 'data_dims')])])
 
+tractography.connect([(inputnode, cam2trk_dt,
+                       [(('dwi', get_vox_dims), 'voxel_dims'),
+                        (('dwi', get_data_dims), 'data_dims')])])
 """
 Finally, we create another higher-level workflow to connect our tractography workflow with the info and datagrabbing nodes
 declared at the beginning. Our tutorial can is now extensible to any arbitrary number of subjects by simply adding
@@ -305,19 +290,16 @@ def get_affine(volume):
 workflow = pe.Workflow(name="workflow")
 workflow.base_dir = os.path.abspath('camino_dti_tutorial')
 workflow.connect([(infosource, datasource, [('subject_id', 'subject_id')]),
-                  (datasource, tractography, [('dwi', 'inputnode.dwi'),
-                                              ('bvals', 'inputnode.bvals'),
-                                              ('bvecs', 'inputnode.bvecs')
-                                              ])
-                  ])
+                  (datasource, tractography,
+                   [('dwi', 'inputnode.dwi'), ('bvals', 'inputnode.bvals'),
+                    ('bvecs', 'inputnode.bvecs')])])
 """
 The following functions run the whole workflow and produce a .dot and .png graph of the processing pipeline.
 """
 
 if __name__ == '__main__':
     workflow.run()
     workflow.write_graph()
-
 """
 You can choose the format of the experted graph with the ``format`` option. For example ``workflow.write_graph(format='eps')``