[WIP] Major refactor (nipype-1.5 ?)

CHANGES

@@ -1,6 +1,8 @@
 Next release
 ============
 
+* ENH: The name_source feature now available for all Interfaces derived from BaseInterface
+       (https://github.com/nipy/nipype/pull/1240)
 * FIX: Prevent crash when tvtk is loaded - ETS_TOOLKIT=null (https://github.com/nipy/nipype/pull/973)
 * ENH: New interfaces in dipy: RESTORE, EstimateResponseSH, CSD and StreamlineTractography
        (https://github.com/nipy/nipype/pull/1090)

nipype/algorithms/icc.py

@@ -1,36 +1,54 @@
+# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
+# vi: set ft=python sts=4 ts=4 sw=4 et:
+"""
+Algorithms to compute the Interclass Correlation Coefficient
+
+    Change directory to provide relative paths for doctests
+    >>> import os
+    >>> filepath = os.path.dirname( os.path.realpath( __file__ ) )
+    >>> datadir = os.path.realpath(os.path.join(filepath, '../testing/data'))
+    >>> os.chdir(datadir)
+
+"""
+
 from __future__ import division
-from builtins import range
+import os
+import numpy as np
 from numpy import ones, kron, mean, eye, hstack, dot, tile
 from scipy.linalg import pinv
-from ..interfaces.base import BaseInterfaceInputSpec, TraitedSpec, \
-    BaseInterface, traits, File
 import nibabel as nb
-import numpy as np
-import os
 
+from builtins import range
+from ..interfaces.base import (traits, File, BaseInterface, BaseInputSpec,
+                               TraitedSpec)
 
-class ICCInputSpec(BaseInterfaceInputSpec):
+class ICCInputSpec(BaseInputSpec):
     subjects_sessions = traits.List(traits.List(File(exists=True)),
                                     desc="n subjects m sessions 3D stat files",
                                     mandatory=True)
     mask = File(exists=True, mandatory=True)
+    icc_map = File('icc_map.nii', desc='name of output ICC map')
+    session_var_map = File('session_var_map.nii', desc="variance between sessions")
+    session_F_map = File('session_F_map.nii', desc="F map of sessions")
+    subject_var_map = File('subject_var_map.nii', desc="variance between subjects")
 
 
 class ICCOutputSpec(TraitedSpec):
     icc_map = File(exists=True)
     session_var_map = File(exists=True, desc="variance between sessions")
+    session_F_map = File(exists=True, desc="variance between sessions")
     subject_var_map = File(exists=True, desc="variance between subjects")
 
 
 class ICC(BaseInterface):
-    '''
+    """
     Calculates Interclass Correlation Coefficient (3,1) as defined in
     P. E. Shrout & Joseph L. Fleiss (1979). "Intraclass Correlations: Uses in
     Assessing Rater Reliability". Psychological Bulletin 86 (2): 420-428. This
     particular implementation is aimed at relaibility (test-retest) studies.
-    '''
-    input_spec = ICCInputSpec
-    output_spec = ICCOutputSpec
+    """
+    _input_spec = ICCInputSpec
+    _output_spec = ICCOutputSpec
 
     def _run_interface(self, runtime):
         maskdata = nb.load(self.inputs.mask).get_data()
@@ -44,48 +62,46 @@ def _run_interface(self, runtime):
         session_var = np.zeros(session_datas[0][0].shape)
         subject_var = np.zeros(session_datas[0][0].shape)
 
-        for x in range(icc.shape[0]):
-            Y = all_data[x, :, :]
-            icc[x], subject_var[x], session_var[x], session_F[x], _, _ = ICC_rep_anova(Y)
+        for i in range(icc.shape[0]):
+            data = all_data[i, :, :]
+            icc[i], subject_var[i], session_var[i], session_F[i], _, _ = ICC_rep_anova(data)
 
         nim = nb.load(self.inputs.subjects_sessions[0][0])
         new_data = np.zeros(nim.shape)
         new_data[maskdata] = icc.reshape(-1,)
         new_img = nb.Nifti1Image(new_data, nim.affine, nim.header)
-        nb.save(new_img, 'icc_map.nii')
+        nb.save(new_img, self.inputs.icc_map)
 
         new_data = np.zeros(nim.shape)
         new_data[maskdata] = session_var.reshape(-1,)
         new_img = nb.Nifti1Image(new_data, nim.affine, nim.header)
-        nb.save(new_img, 'session_var_map.nii')
+        nb.save(new_img, self.inputs.session_var_map)
 
         new_data = np.zeros(nim.shape)
         new_data[maskdata] = subject_var.reshape(-1,)
         new_img = nb.Nifti1Image(new_data, nim.affine, nim.header)
-        nb.save(new_img, 'subject_var_map.nii')
+        nb.save(new_img, self.inputs.subject_var_map.nii)
 
+        new_data = np.zeros(nim.shape)
+        new_data[maskdata] = session_F.reshape(-1,)
+        new_img = nb.Nifti1Image(new_data, nim.affine, nim.header)
+        nb.save(new_img, self.inputs.session_F_map)
         return runtime
 
-    def _list_outputs(self):
-        outputs = self._outputs().get()
-        outputs['icc_map'] = os.path.abspath('icc_map.nii')
-        outputs['sessions_F_map'] = os.path.abspath('sessions_F_map.nii')
-        outputs['session_var_map'] = os.path.abspath('session_var_map.nii')
-        outputs['subject_var_map'] = os.path.abspath('subject_var_map.nii')
-        return outputs
-
 
-def ICC_rep_anova(Y):
-    '''
-    the data Y are entered as a 'table' ie subjects are in rows and repeated
+def ICC_rep_anova(data):
+    """
+    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]
-    '''
+    .. math::
+
+      Y = XB + E with X = [FaTor / Subjects]
+    """
 
-    [nb_subjects, nb_conditions] = Y.shape
+    [nb_subjects, nb_conditions] = data.shape
     dfc = nb_conditions - 1
     dfe = (nb_subjects - 1) * dfc
     dfr = nb_subjects - 1
@@ -94,25 +110,25 @@ def ICC_rep_anova(Y):
     # ------------------------------------
 
     # Sum Square Total
-    mean_Y = mean(Y)
-    SST = ((Y - mean_Y) ** 2).sum()
+    mean_Y = mean(data)
+    SST = ((data - mean_Y) ** 2).sum()
 
     # create the design matrix for the different levels
     x = kron(eye(nb_conditions), ones((nb_subjects, 1)))  # sessions
     x0 = tile(eye(nb_subjects), (nb_conditions, 1))  # subjects
     X = hstack([x, x0])
 
     # Sum Square Error
-    predicted_Y = dot(dot(dot(X, pinv(dot(X.T, X))), X.T), Y.flatten('F'))
-    residuals = Y.flatten('F') - predicted_Y
+    predicted_Y = dot(dot(dot(X, pinv(dot(X.T, X))), X.T), data.flatten('F'))
+    residuals = data.flatten('F') - predicted_Y
     SSE = (residuals ** 2).sum()
 
-    residuals.shape = Y.shape
+    residuals.shape = data.shape
 
     MSE = SSE / dfe
 
     # Sum square session effect - between colums/sessions
-    SSC = ((mean(Y, 0) - mean_Y) ** 2).sum() * nb_subjects
+    SSC = ((mean(data, 0) - mean_Y) ** 2).sum() * nb_subjects
     MSC = SSC / dfc / nb_subjects
 
     session_effect_F = MSC / MSE

nipype/algorithms/mesh.py

@@ -21,10 +21,11 @@
 
 from .. import logging
 from ..external.six import string_types
-from ..interfaces.base import (BaseInterface, traits, TraitedSpec, File,
-                               BaseInterfaceInputSpec)
+from ..interfaces.base import (traits, File, GenFile, BaseInterface, BaseInputSpec,
+                               TraitedSpec)
 from ..interfaces.vtkbase import tvtk
 from ..interfaces import vtkbase as VTKInfo
+
 IFLOGGER = logging.getLogger('interface')
 
 
@@ -39,16 +40,15 @@ def __init__(self, **inputs):
         super(TVTKBaseInterface, self).__init__(**inputs)
 
 
-class WarpPointsInputSpec(BaseInterfaceInputSpec):
+class WarpPointsInputSpec(BaseInputSpec):
     points = File(exists=True, mandatory=True,
                   desc='file containing the point set')
     warp = File(exists=True, mandatory=True,
                 desc='dense deformation field to be applied')
     interp = traits.Enum('cubic', 'nearest', 'linear', usedefault=True,
                          mandatory=True, desc='interpolation')
-    out_points = File(name_source='points', name_template='%s_warped',
-                      output_name='out_points', keep_extension=True,
-                      desc='the warped point set')
+    out_points = GenFile(template='{points}_warped', keep_extension=True,
+                         desc='the warped point set')
 
 
 class WarpPointsOutputSpec(TraitedSpec):
@@ -72,22 +72,8 @@ class WarpPoints(TVTKBaseInterface):
         res = wp.run()
 
     """
-    input_spec = WarpPointsInputSpec
-    output_spec = WarpPointsOutputSpec
-
-    def _gen_fname(self, in_file, suffix='generated', ext=None):
-        fname, fext = op.splitext(op.basename(in_file))
-
-        if fext == '.gz':
-            fname, fext2 = op.splitext(fname)
-            fext = fext2 + fext
-
-        if ext is None:
-            ext = fext
-
-        if ext[0] == '.':
-            ext = ext[1:]
-        return op.abspath('%s_%s.%s' % (fname, suffix, ext))
+    _input_spec = WarpPointsInputSpec
+    _output_spec = WarpPointsOutputSpec
 
     def _run_interface(self, runtime):
         import nibabel as nb
@@ -122,19 +108,14 @@ def _run_interface(self, runtime):
         newpoints = [p + d for p, d in zip(points, disps)]
         mesh.points = newpoints
         w = tvtk.PolyDataWriter()
+
         VTKInfo.configure_input_data(w, mesh)
-        w.file_name = self._gen_fname(self.inputs.points, suffix='warped', ext='.vtk')
+        w.file_name = self.inputs.out_points
         w.write()
         return runtime
 
-    def _list_outputs(self):
-        outputs = self._outputs().get()
-        outputs['out_points'] = self._gen_fname(self.inputs.points, suffix='warped',
-                                                ext='.vtk')
-        return outputs
 
-
-class ComputeMeshWarpInputSpec(BaseInterfaceInputSpec):
+class ComputeMeshWarpInputSpec(BaseInputSpec):
     surface1 = File(exists=True, mandatory=True,
                     desc=('Reference surface (vtk format) to which compute '
                           'distance.'))
@@ -184,8 +165,8 @@ class ComputeMeshWarp(TVTKBaseInterface):
 
     """
 
-    input_spec = ComputeMeshWarpInputSpec
-    output_spec = ComputeMeshWarpOutputSpec
+    _input_spec = ComputeMeshWarpInputSpec
+    _output_spec = ComputeMeshWarpOutputSpec
 
     def _triangle_area(self, A, B, C):
         A = np.array(A)
@@ -248,18 +229,15 @@ def _run_interface(self, runtime):
         VTKInfo.configure_input_data(writer, out_mesh)
         writer.write()
 
-        self._distance = np.average(errvector, weights=weights)
-        return runtime
+        _distance = np.average(errvector, weights=weights)
 
-    def _list_outputs(self):
-        outputs = self._outputs().get()
-        outputs['out_file'] = op.abspath(self.inputs.out_file)
-        outputs['out_warp'] = op.abspath(self.inputs.out_warp)
-        outputs['distance'] = self._distance
-        return outputs
+        self.outputs.out_file = op.abspath(self.inputs.out_file)
+        self.outputs.out_warp = op.abspath(self.inputs.out_warp)
+        self.outputs.distance = _distance
+        return runtime
 
 
-class MeshWarpMathsInputSpec(BaseInterfaceInputSpec):
+class MeshWarpMathsInputSpec(BaseInputSpec):
     in_surf = File(exists=True, mandatory=True,
                    desc=('Input surface in vtk format, with associated warp '
                          'field as point data (ie. from ComputeMeshWarp'))
@@ -273,18 +251,16 @@ class MeshWarpMathsInputSpec(BaseInterfaceInputSpec):
     operation = traits.Enum('sum', 'sub', 'mul', 'div', usedefault=True,
                             desc='operation to be performed')
 
-    out_warp = File('warp_maths.vtk', usedefault=True,
-                    desc='vtk file based on in_surf and warpings mapping it '
-                    'to out_file')
-    out_file = File('warped_surf.vtk', usedefault=True,
+    out_warp = GenFile(template='{in_surf}_warping', keep_extension=True,
+                       desc='vtk file based on in_surf and warpings mapping it to out_file')
+    out_file = File(template='{in_surf}_warped', keep_extension=True,
                     desc='vtk with surface warped')
 
 
 class MeshWarpMathsOutputSpec(TraitedSpec):
     out_warp = File(exists=True, desc=('vtk file with the vertex-wise '
                                        'mapping of surface1 to surface2'))
-    out_file = File(exists=True,
-                    desc='vtk with surface warped')
+    out_file = File(exists=True, desc='vtk with surface warped')
 
 
 class MeshWarpMaths(TVTKBaseInterface):
@@ -309,8 +285,8 @@ class MeshWarpMaths(TVTKBaseInterface):
 
     """
 
-    input_spec = MeshWarpMathsInputSpec
-    output_spec = MeshWarpMathsOutputSpec
+    _input_spec = MeshWarpMathsInputSpec
+    _output_spec = MeshWarpMathsOutputSpec
 
     def _run_interface(self, runtime):
         r1 = tvtk.PolyDataReader(file_name=self.inputs.in_surf)
@@ -370,12 +346,6 @@ def _run_interface(self, runtime):
         writer.write()
         return runtime
 
-    def _list_outputs(self):
-        outputs = self._outputs().get()
-        outputs['out_file'] = op.abspath(self.inputs.out_file)
-        outputs['out_warp'] = op.abspath(self.inputs.out_warp)
-        return outputs
-
 
 class P2PDistance(ComputeMeshWarp):
     """