doc fixes

Author: chrisgorgo

doc/index.rst

@@ -4,31 +4,31 @@
          :width: 100 %
    -  .. container::
 
-      Current neuroimaging software offer users an incredible opportunity to
-      analyze data using a variety of different algorithms. However, this has
-      resulted in a heterogeneous collection of specialized applications
-      without transparent interoperability or a uniform operating interface.
-
-      *Nipype*, an open-source, community-developed initiative under the
-      umbrella of NiPy_, is a Python project that provides a uniform interface
-      to existing neuroimaging software and facilitates interaction between
-      these packages within a single workflow. Nipype provides an environment
-      that encourages interactive exploration of algorithms from different
-      packages (e.g., ANTS_, SPM_, FSL_, FreeSurfer_, Camino_, MRtrix_, MNE_, AFNI_, 
-      Slicer_), eases the design of workflows within and between packages, and
-      reduces the learning curve necessary to use different packages. Nipype is
-      creating a collaborative platform for neuroimaging software development 
-      in a high-level language and addressing limitations of existing pipeline
-      systems.
-
-      *Nipype* allows you to:
-
-      * easily interact with tools from different software packages
-      * combine processing steps from different software packages
-      * develop new workflows faster by reusing common steps from old ones
-      * process data faster by running it in parallel on many cores/machines
-      * make your research easily reproducible
-      * share your processing workflows with the community
+        Current neuroimaging software offer users an incredible opportunity to
+        analyze data using a variety of different algorithms. However, this has
+        resulted in a heterogeneous collection of specialized applications
+        without transparent interoperability or a uniform operating interface.
+
+        *Nipype*, an open-source, community-developed initiative under the
+        umbrella of NiPy_, is a Python project that provides a uniform interface
+        to existing neuroimaging software and facilitates interaction between
+        these packages within a single workflow. Nipype provides an environment
+        that encourages interactive exploration of algorithms from different
+        packages (e.g., ANTS_, SPM_, FSL_, FreeSurfer_, Camino_, MRtrix_, MNE_, AFNI_,
+        Slicer_), eases the design of workflows within and between packages, and
+        reduces the learning curve necessary to use different packages. Nipype is
+        creating a collaborative platform for neuroimaging software development
+        in a high-level language and addressing limitations of existing pipeline
+        systems.
+
+        *Nipype* allows you to:
+
+        * easily interact with tools from different software packages
+        * combine processing steps from different software packages
+        * develop new workflows faster by reusing common steps from old ones
+        * process data faster by running it in parallel on many cores/machines
+        * make your research easily reproducible
+        * share your processing workflows with the community
 
 .. admonition:: Reference
 

nipype/algorithms/icc.py

@@ -78,10 +78,9 @@ def ICC_rep_anova(Y):
     the data Y are entered as a 'table' ie subjects are in rows and repeated
     measures in columns
 
-    --------------------------------------------------------------------------
-                       One Sample Repeated measure ANOVA
-                       Y = XB + E with X = [FaTor / Subjects]
-    --------------------------------------------------------------------------
+    One Sample Repeated measure ANOVA
+                       
+    Y = XB + E with X = [FaTor / Subjects]
     '''
 
     [nb_subjects, nb_conditions] = Y.shape

nipype/algorithms/modelgen.py

@@ -72,9 +72,10 @@ def spm_hrf(RT, P=None, fMRI_T=16):
     % p    - parameters of the response function
 
     the following code using scipy.stats.distributions.gamma
-    doesn't return the same result as the spm_Gpdf function
-    hrf = gamma.pdf(u, p[0]/p[2], scale=dt/p[2]) -
-          gamma.pdf(u, p[1]/p[3], scale=dt/p[3])/p[4]
+    doesn't return the same result as the spm_Gpdf function ::
+    
+        hrf = gamma.pdf(u, p[0]/p[2], scale=dt/p[2]) -
+              gamma.pdf(u, p[1]/p[3], scale=dt/p[3])/p[4]
 
     >>> print spm_hrf(2)
     [  0.00000000e+00   8.65660810e-02   3.74888236e-01   3.84923382e-01

nipype/interfaces/camino/calib.py

@@ -187,22 +187,27 @@ class SFLUTGen(StdOutCommandLine):
 
     The utility outputs two lut's, *_oneFibreSurfaceCoeffs.Bdouble and
     *_twoFibreSurfaceCoeffs.Bdouble. Each of these files contains big-
-    endian doubles as standard. The format of the output is:
-      dimensions    (1 for Watson, 2 for Bingham)
-      order         (the order of the polynomial)
-      coefficient_1
-      coefficient_2
-      ...
-      coefficient_N
+    endian doubles as standard. The format of the output is: ::
+    
+          dimensions    (1 for Watson, 2 for Bingham)
+          order         (the order of the polynomial)
+          coefficient_1
+          coefficient_2
+          ...
+          coefficient_N
+      
     In  the case of the Watson, there is a single set of coefficients,
-    which are ordered:
-      constant, x, x^2, ..., x^order.
+    which are ordered: ::
+    
+          constant, x, x^2, ..., x^order.
+      
     In the case of the Bingham, there are two sets of coefficients (one
-    for each surface), ordered so that:
-      for j = 1 to order
-        for k = 1 to order
-          coeff_i = x^j * y^k
-      where j+k < order
+    for each surface), ordered so that: ::
+    
+          for j = 1 to order
+            for k = 1 to order
+              coeff_i = x^j * y^k
+          where j+k < order
 
     Example
     ---------

nipype/interfaces/camino/connectivity.py

@@ -65,10 +65,13 @@ class Conmat(CommandLine):
     a point in a labeled region. This is done in both directions from the seed
     point. Streamlines are counted if they connect two target regions, one on
     either side of the seed point. Only the labeled region closest to the seed
-    is counted, for example if the  input contains two streamlines:
+    is counted, for example if the  input contains two streamlines: ::
+    
          1: A-----B------SEED---C
          2: A--------SEED-----------
-    then the output would be
+         
+    then the output would be ::
+    
          A,B,C
          0,0,0
          0,0,1
@@ -80,17 +83,22 @@ class Conmat(CommandLine):
 
     The connected target regions can have the same label, as long as the seed
     point is outside of the labeled region and both ends connect to the same
-    label (which may  be in different locations). Therefore this is allowed:
+    label (which may  be in different locations). Therefore this is allowed: ::
+    
          A------SEED-------A
 
     Such fibers will add to the diagonal elements of the matrix. To remove
     these entries, run procstreamlines with -endpointfile before running conmat.
 
     If the seed point is inside a labled region, it counts as one end of the
-    connection.  So
+    connection.  So ::
+    
          ----[SEED inside A]---------B
-    counts as a connection between A and B, while
+         
+    counts as a connection between A and B, while ::
+    
          C----[SEED inside A]---------B
+         
     counts as a connection between A and C, because C is closer to the seed point.
 
     In all cases, distance to the seed point is defined along the streamline path.

nipype/interfaces/camino/convert.py

@@ -635,7 +635,7 @@ class Shredder(StdOutCommandLine):
     Shredder makes an initial offset of offset bytes. It then reads and outputs
     chunksize bytes, skips space bytes, and repeats until there is no more input.
 
-    If  the  chunksize  is  negative, chunks of size |chunksize| are read and the
+    If  the  chunksize  is  negative, chunks of size chunksize are read and the
     byte ordering of each chunk is reversed. The whole chunk will be reversed, so
     the chunk must be the same size as the data type, otherwise the order of the
     values in the chunk, as well as their endianness, will be reversed.

nipype/interfaces/camino/dti.py

@@ -107,25 +107,23 @@ class DTMetric(CommandLine):
     typically obtained from ComputeEigensystem.
 
     The full list of statistics is:
+    
+     - <cl> = (l1 - l2) / l1 , a measure of linearity
+     - <cp> = (l2 - l3) / l1 , a measure of planarity
+     - <cs> = l3 / l1 , a measure of isotropy
+       with: cl + cp + cs = 1
+     - <l1> = first eigenvalue
+     - <l2> = second eigenvalue
+     - <l3> = third eigenvalue
+     - <tr> = l1 + l2 + l3
+     - <md> = tr / 3
+     - <rd> = (l2 + l3) / 2
+     - <fa> = fractional anisotropy. (Basser et al, J Magn Reson B 1996)
+     - <ra> = relative anisotropy (Basser et al, J Magn Reson B 1996)
+     - <2dfa> = 2D FA of the two minor eigenvalues l2 and l3
+       i.e. sqrt( 2 * [(l2 - <l>)^2 + (l3 - <l>)^2] / (l2^2 + l3^2) )
+       with: <l> = (l2 + l3) / 2
 
-     <cl> = (l1 - l2) / l1 , a measure of linearity
-     <cp> = (l2 - l3) / l1 , a measure of planarity
-     <cs> = l3 / l1 , a measure of isotropy
-      with: cl + cp + cs = 1
-
-     <l1> = first eigenvalue
-     <l2> = second eigenvalue
-     <l3> = third eigenvalue
-
-     <tr> = l1 + l2 + l3
-     <md> = tr / 3
-     <rd> = (l2 + l3) / 2
-     <fa> = fractional anisotropy. (Basser et al, J Magn Reson B 1996)
-     <ra> = relative anisotropy (Basser et al, J Magn Reson B 1996)
-
-     <2dfa> = 2D FA of the two minor eigenvalues l2 and l3
-      i.e. sqrt( 2 * [(l2 - <l>)^2 + (l3 - <l>)^2] / (l2^2 + l3^2) )
-           with: <l> = (l2 + l3) / 2
 
     Example
     -------

nipype/interfaces/camino/odf.py

@@ -115,12 +115,16 @@ class LinRecon(StdOutCommandLine):
     Reads  a  linear  transformation from the matrix file assuming the
     imaging scheme specified in the scheme file. Performs the linear
     transformation on the data in every voxel and outputs the result to
-    the standard output. The ouput in every voxel is actually:
+    the standard output. The ouput in every voxel is actually: ::
+    
         [exit code, ln(S(0)), p1, ..., pR]
+        
     where p1, ..., pR are the parameters of the reconstruction.
     Possible exit codes are:
-       0. No problems.
-       6. Bad data replaced by substitution of zero.
+    
+        - 0. No problems.
+        - 6. Bad data replaced by substitution of zero.
+        
     The matrix must be R by N+M where N+M is the number of measurements
     and R is the number of parameters of the reconstruction. The matrix
     file contains binary double-precision floats. The matrix elements
@@ -216,10 +220,11 @@ class MESD(StdOutCommandLine):
     failed.
 
     Other possible exitcodes are:
-     5   - The optimization failed to converge
-    -1   - Background
-    -100 - Something wrong in the MRI data, e.g. negative or zero measurements,
-           so that the optimization could not run.
+    
+        - 5 - The optimization failed to converge
+        - -1 - Background
+        - -100 - Something wrong in the MRI data, e.g. negative or zero measurements,
+          so that the optimization could not run.
 
     The  standard  MESD  implementation  is computationally demanding, particularly
     as the number of measurements increases (computation is approximately O(N^2),
@@ -363,6 +368,7 @@ class SFPeaks(StdOutCommandLine):
     still expect similar performance levels.
 
     The output for each voxel is:
+    
     - exitcode (inherited from the input data).
     - ln(A(0))
     - number of peaks found.
@@ -374,11 +380,13 @@ class SFPeaks(StdOutCommandLine):
     - direction 2 (x, y, z, f, H00, H01, H10, H11).
     - direction 3 (x, y, z, f, H00, H01, H10, H11).
 
-    H is the Hessian of f at the peak. It is the matrix:
-    [d^2f/ds^2 d^2f/dsdt]
-    [d^2f/dtds d^2f/dt^2]
-    = [H00 H01]
-      [H10 H11]
+    H is the Hessian of f at the peak. It is the matrix: ::
+    
+        [d^2f/ds^2 d^2f/dsdt]
+        [d^2f/dtds d^2f/dt^2]
+        = [H00 H01]
+          [H10 H11]
+
     where s and t are orthogonal coordinates local to the peak.
 
     By default the maximum number of peak directions output in each

nipype/interfaces/fsl/epi.py

@@ -224,7 +224,7 @@ class TOPUP(FSLCommand):
     `usage examples
     <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/topup/ExampleTopupFollowedByApplytopup>`_,
     and `exemplary config files
-    <https://github.com/ahheckel/FSL-scripts/blob/master/rsc/fsl/fsl4/topup/b02b0.cnf`_.
+    <https://github.com/ahheckel/FSL-scripts/blob/master/rsc/fsl/fsl4/topup/b02b0.cnf>`_.
 
     Examples
     --------

nipype/interfaces/fsl/preprocess.py

@@ -1256,7 +1256,7 @@ class FUGUE(FSLCommand):
     --------
 
 
-    Unwarping an input image (shift map is known) ::
+    Unwarping an input image (shift map is known)
 
     >>> from nipype.interfaces.fsl.preprocess import FUGUE
     >>> fugue = FUGUE()
@@ -1270,7 +1270,7 @@ class FUGUE(FSLCommand):
     >>> fugue.run() #doctest: +SKIP
 
 
-    Warping an input image (shift map is known) ::
+    Warping an input image (shift map is known)
 
     >>> from nipype.interfaces.fsl.preprocess import FUGUE
     >>> fugue = FUGUE()
@@ -1285,7 +1285,7 @@ class FUGUE(FSLCommand):
     >>> fugue.run() #doctest: +SKIP
 
 
-    Computing the vsm (unwrapped phase map is known) ::
+    Computing the vsm (unwrapped phase map is known)
 
     >>> from nipype.interfaces.fsl.preprocess import FUGUE
     >>> fugue = FUGUE()