Merge branch 'master' into enh/vbm

* master: (24 commits)
  Doctests fix
  Fixed tests.
  in fact masking wasn't working, HistogramRegistration takes mask as numpy not nibabel
  allow similarity computation without mask
  Added [xor] metadata to afni.AutoTcorrelate
  added mask_source option to afni.AutoTcorrelate
  added mask_source option to afni.AutoTcorrelate
  fix fugue for not necessarly wanted output
  fix forward_warping input
  add Complex to __init__.py
  fix Complex doc
  fslcomplex interface + fix line removed inadvertently
  adding doctest to sigloss
  typo
  fixing abspath bug
  bugfix abspath
  added SigLoss to __init__
  added fsl sigloss to utils
  allow FUGUE to run without in_file
  allow FUGUE to run without in_file
  ...

Author: bpinsard

nipype/interfaces/afni/preprocess.py

@@ -320,7 +320,13 @@ class AutoTcorrelateInputSpec(AFNICommandInputSpec):
     mask = File(exists=True, desc="mask of voxels",
                 argstr="-mask %s")
     mask_only_targets = traits.Bool(desc="use mask only on targets voxels",
-                                    argstr="-mask_only_targets")
+                                    argstr="-mask_only_targets",
+                                    xor=['mask_source'])
+                                    
+    mask_source = File(exists=True, 
+                        desc="mask for source voxels", 
+                        argstr="-mask_source %s",
+                        xor=['mask_only_targets'])
 
     out_file = File("%s_similarity_matrix.1D", desc='output image file name',
                     argstr='-prefix %s', name_source="in_file", usedefault=True)

nipype/interfaces/afni/tests/test_preprocess.py

@@ -18,7 +18,7 @@ def test_allineate():
                      environ = dict(usedefault=True,),
                      ignore_exception = dict(usedefault=True,),
                      in_file = dict(argstr='-source %s',mandatory=True,),
-                     matrix = dict(argstr='-1dmatrix_apply %s',),
+                     in_matrix = dict(argstr='-1Dmatrix_apply %s',),
                      out_file = dict(argstr='-prefix %s'),
                      outputtype = dict(),
                      )

nipype/interfaces/fsl/__init__.py

@@ -15,7 +15,8 @@
 from .utils import (Smooth, Merge, ExtractROI, Split, ImageMaths, ImageMeants,
                     ImageStats, FilterRegressor, Overlay, Slicer,
                     PlotTimeSeries, PlotMotionParams, ConvertXFM,
-                    SwapDimensions, PowerSpectrum, Reorient2Std)
+                    SwapDimensions, PowerSpectrum, SigLoss, Reorient2Std,
+                    Complex)
 from .dti import (EddyCorrect, BEDPOSTX, DTIFit, ProbTrackX, VecReg, ProjThresh,
                   FindTheBiggest, DistanceMap, TractSkeleton, XFibres,
                   MakeDyadicVectors)

nipype/interfaces/fsl/preprocess.py

@@ -1188,14 +1188,15 @@ def _gen_filename(self, name):
 class FUGUEInputSpec(FSLCommandInputSpec):
     in_file = File(exists=True, argstr='--in=%s',
                    desc='filename of input volume')
-    unwarped_file = File(argstr='--unwarp=%s', genfile=True,
-                         desc='apply unwarping and save as filename', hash_files=False)
-
-    save_warped = traits.Bool(desc='apply forward warp and save')
-
-    warped_file = File(argstr='--warp=%s', genfile=True,
-                         desc='apply forward warp and save as filename', hash_files=False)
-
+    unwarped_file = File(
+        argstr='--unwarp=%s', genfile=True,
+        desc='apply unwarping and save as filename', hash_files=False)
+    forward_warping = traits.Bool(
+        False, usedefault=True,
+        desc='apply forward warping instead of unwarping')
+    warped_file = File(argstr='--warp=%s', 
+                       desc='apply forward warping and save as filename',
+                       hash_files=False)
     phasemap_file = File(exists=True, argstr='--phasemap=%s',
                          desc='filename for input phase image')
     dwell_to_asym_ratio = traits.Float(argstr='--dwelltoasym=%.10f',
@@ -1211,7 +1212,7 @@ class FUGUEInputSpec(FSLCommandInputSpec):
 
     save_shift = traits.Bool(desc='output pixel shift volume')
 
-    shift_out_file = traits.File(argstr='--saveshift=%s', genfile=True,
+    shift_out_file = traits.File(argstr='--saveshift=%s', 
                            desc='filename for saving pixel shift volume', hash_files=False)
 
     shift_in_file = File(exists=True, argstr='--loadshift=%s',
@@ -1247,25 +1248,20 @@ class FUGUEInputSpec(FSLCommandInputSpec):
                              desc='apply intensity correction only')
     mask_file = File(exists=True, argstr='--mask=%s',
                      desc='filename for loading valid mask')
-    save_unmasked_fmap = traits.Either(traits.Bool,
-                                       traits.File,
-                                       argstr='--unmaskfmap=%s',
-                                       requires=['fmap_out_file'],
-                                       desc='saves the unmasked fieldmap when using --savefmap', hash_files=False)
-    save_unmasked_shift = traits.Either(traits.Bool,
-                                       traits.File,
-                                       argstr='--unmaskshift=%s',
-                                       requires=['shift_out_file'],
-                                       desc='saves the unmasked shiftmap when using --saveshift', hash_files=False)
-    nokspace = traits.Bool(
-        argstr='--nokspace', desc='do not use k-space forward warping')
+    save_unmasked_fmap = traits.Bool(argstr='--unmaskfmap',
+                                     requires=['fmap_out_file'],
+                                     desc='saves the unmasked fieldmap when using --savefmap')
+    save_unmasked_shift = traits.Bool(argstr='--unmaskshift',
+                                      requires=['shift_out_file'],
+                                      desc='saves the unmasked shiftmap when using --saveshift')
+    nokspace = traits.Bool(argstr='--nokspace', desc='do not use k-space forward warping')
 
 
 class FUGUEOutputSpec(TraitedSpec):
-    unwarped_file = File(exists=True, desc='unwarped file')
+    unwarped_file = File(desc='unwarped file')
+    warped_file = File(desc='forward warped file')
     shift_out_file = File(desc='voxel shift map file')
-    warped_file = File(desc='warped file')
-
+    fmap_out_file = File(desc='fieldmap file')
 
 class FUGUE(FSLCommand):
     """Use FSL FUGUE to unwarp epi's with fieldmaps
@@ -1299,43 +1295,40 @@ def _parse_inputs(self, skip=None):
 
     def _list_outputs(self):
         outputs = self._outputs().get()
-        out_file = self.inputs.unwarped_file
-        if not isdefined(out_file):
-            out_file = self._gen_fname(self.inputs.in_file,
-                                      suffix='_unwarped')
-        outputs['unwarped_file'] = os.path.abspath(out_file)
-
-        if isdefined(self.inputs.save_shift) and self.inputs.save_shift:
-            shift_out = self.inputs.shift_out_file
-            if not isdefined(shift_out):
-                shift_out = self._gen_fname(
-                    self.inputs.in_file, suffix='_shift')
+        if self.inputs.forward_warping:
+            out_field = 'warped_file'
+        else: 
+            out_field = 'unwarped_file'
 
-            outputs['shift_out_file'] = os.path.abspath(shift_out)
-
-        if isdefined(self.inputs.save_warped) and self.inputs.save_warped:
-            warped_out = self.inputs.warped_file
-            if not isdefined(warped_out):
-                warped_out = self._gen_fname(
-                    self.inputs.in_file, suffix='_fwdwarp')
-
-            outputs['warped_file'] = os.path.abspath(warped_out)
-            del outputs['unwarped_file']
+        out_file = getattr(self.inputs,out_field)
+        if not isdefined(out_file):
+            if isdefined(self.inputs.in_file):
+                out_file = self._gen_fname(self.inputs.in_file,
+                                           suffix='_'+out_field[:-5])
+        if isdefined(out_file):
+            outputs[out_field] = os.path.abspath(out_file)
+        if isdefined(self.inputs.fmap_out_file):
+            outputs['fmap_out_file'] = os.path.abspath(self.inputs.fmap_out_file)
+        if isdefined(self.inputs.shift_out_file):
+            outputs['shift_out_file'] = os.path.abspath(self.inputs.shift_out_file)
 
         return outputs
 
     def _gen_filename(self, name):
-        if name == 'unwarped_file':
+        if name == 'unwarped_file' and not self.inputs.forward_warping:
             return self._list_outputs()['unwarped_file']
-
-        if name == 'warped_file':
+        if name == 'warped_file' and self.inputs.forward_warping:
             return self._list_outputs()['warped_file']
-
-        if name == 'shift_out_file':
-            return self._list_outputs()['shift_out_file']
-
         return None
 
+    def _parse_inputs(self,skip=None):
+        if skip==None:
+            skip=[]
+        if self.inputs.forward_warping or not isdefined(self.inputs.in_file):
+            skip+=['unwarped_file']
+        if not self.inputs.forward_warping or not isdefined(self.inputs.in_file):
+            skip+=['warped_file']
+        return super(FUGUE,self)._parse_inputs(skip=skip)
 
 class PRELUDEInputSpec(FSLCommandInputSpec):
     complex_phase_file = File(exists=True, argstr='--complex=%s',

nipype/interfaces/fsl/tests/test_preprocess.py

@@ -503,8 +503,8 @@ def test_fugue():
                      phase_conjugate = dict(argstr='--phaseconj',),
                      phasemap_file = dict(argstr='--phasemap=%s',),
                      poly_order = dict(argstr='--poly=%d',),
-                     save_unmasked_fmap = dict(requires=['fmap_out_file'],argstr='--unmaskfmap=%s',),
-                     save_unmasked_shift = dict(requires=['shift_out_file'],argstr='--unmaskshift=%s',),
+                     save_unmasked_fmap = dict(requires=['fmap_out_file'],argstr='--unmaskfmap',),
+                     save_unmasked_shift = dict(requires=['shift_out_file'],argstr='--unmaskshift',),
                      shift_in_file = dict(argstr='--loadshift=%s',),
                      shift_out_file = dict(argstr='--saveshift=%s',),
                      smooth2d = dict(argstr='--smooth2=%.2f',),

nipype/interfaces/fsl/utils.py

@@ -1152,6 +1152,54 @@ def _list_outputs(self):
                                                   basename='maskexf')
         return outputs
 
+class SigLossInputSpec(FSLCommandInputSpec):
+    in_file = File(mandatory=True,
+                   exists=True,
+                   argstr='-i %s',
+                   desc='b0 fieldmap file')
+    out_file = File(argstr='-s %s',
+                    desc='output signal loss estimate file',
+                    genfile=True)
+    
+    mask_file = File(exists=True,
+                     argstr='-m %s',
+                     desc='brain mask file')
+    echo_time = traits.Float(argstr='--te=%f',
+                             desc='echo time in seconds')
+    slice_direction = traits.Enum('x','y','z',
+                                  argstr='-d %s',
+                                  desc='slicing direction')
+class SigLossOuputSpec(TraitedSpec):
+    out_file = File(exists=True,
+                    desc='signal loss estimate file')
+
+class SigLoss(FSLCommand):
+    """Estimates signal loss from a field map (in rad/s)
+
+    Examples
+    --------
+    >>> sigloss = SigLoss()
+    >>> sigloss.inputs.in_file = "phase.nii"
+    >>> sigloss.inputs.echo_time = 0.03
+    >>> res = sigloss.run() # doctest: +SKIP
+    """
+    input_spec = SigLossInputSpec
+    output_spec = SigLossOuputSpec
+    _cmd = 'sigloss'
+
+    def _list_outputs(self):
+        outputs = self.output_spec().get()
+        outputs['out_file'] = self.inputs.out_file
+        if not isdefined(outputs['out_file']) and isdefined(self.inputs.in_file):
+            outputs['out_file']=self._gen_fname(self.inputs.in_file,
+                                                suffix='_sigloss')
+        return outputs
+    
+    def _gen_filename(self, name):
+        if name=='out_file':
+            return self._list_outputs()['out_file']
+        return None
+    
 class Reorient2StdInputSpec(FSLCommandInputSpec):
     in_file = File(exists=True, mandatory=True, argstr="%s")
     out_file = File(genfile=True, hash_files=False, argstr="%s")
@@ -1188,3 +1236,130 @@ def _list_outputs(self):
         else:
             outputs['out_file'] = os.path.abspath(self.inputs.out_file)
         return outputs
+
+
+class ComplexInputSpec(FSLCommandInputSpec):
+    complex_in_file = File(exists=True, argstr="%s", position=2)
+    complex_in_file2 = File(exists=True, argstr="%s", position=3)
+
+    real_in_file = File(exists=True, argstr="%s", position=2)
+    imaginary_in_file = File(exists=True, argstr="%s", position=3)
+    magnitude_in_file = File(exists=True, argstr="%s", position=2)
+    phase_in_file = File(exists=True, argstr='%s', position=3)
+
+    _ofs = ['complex_out_file',
+            'magnitude_out_file','phase_out_file',
+            'real_out_file','imaginary_out_file']
+    _conversion = ['real_polar','real_cartesian',
+                   'complex_cartesian','complex_polar',
+                   'complex_split','complex_merge',]
+
+    complex_out_file = File(genfile=True, argstr="%s", position=-3, 
+                            xor=_ofs+_conversion[:2])
+    magnitude_out_file = File(genfile=True, argstr="%s", position=-4,
+                              xor=_ofs[:1]+_ofs[3:]+_conversion[1:])
+    phase_out_file = File(genfile=True, argstr="%s", position=-3,
+                          xor=_ofs[:1]+_ofs[3:]+_conversion[1:])
+    real_out_file = File(genfile=True, argstr="%s", position=-4,
+                         xor=_ofs[:3]+_conversion[:1]+_conversion[2:])
+    imaginary_out_file = File(genfile=True, argstr="%s", position=-3,
+                              xor=_ofs[:3]+_conversion[:1]+_conversion[2:])
+
+    start_vol = traits.Int(position=-2, argstr='%d')
+    end_vol = traits.Int(position=-1, argstr='%d')
+
+    real_polar = traits.Bool(
+        argstr = '-realpolar', xor = _conversion, position=1,)
+#        requires=['complex_in_file','magnitude_out_file','phase_out_file'])
+    real_cartesian = traits.Bool(
+        argstr = '-realcartesian', xor = _conversion, position=1,)
+#        requires=['complex_in_file','real_out_file','imaginary_out_file'])
+    complex_cartesian = traits.Bool(
+        argstr = '-complex', xor = _conversion, position=1,)
+#        requires=['real_in_file','imaginary_in_file','complex_out_file'])
+    complex_polar = traits.Bool(
+        argstr = '-complexpolar', xor = _conversion, position=1,)
+#        requires=['magnitude_in_file','phase_in_file',
+#                  'magnitude_out_file','phase_out_file'])
+    complex_split = traits.Bool(
+        argstr = '-complexsplit', xor = _conversion, position=1,)
+#        requires=['complex_in_file','complex_out_file'])
+    complex_merge = traits.Bool(
+        argstr = '-complexmerge', xor = _conversion + ['start_vol','end_vol'],
+        position=1,)
+#        requires=['complex_in_file','complex_in_file2','complex_out_file'])
+
+class ComplexOuputSpec(TraitedSpec):
+    magnitude_out_file = File()
+    phase_out_file = File()
+    real_out_file = File()
+    imaginary_out_file = File()
+    complex_out_file = File()
+    
+    
+class Complex(FSLCommand):
+    """fslcomplex is a tool for converting complex data
+    Examples
+    --------
+    >>> cplx = Complex()
+    >>> cplx.inputs.complex_in_file = "complex.nii"
+    >>> cplx.real_polar = True
+    >>> res = cplx.run() # doctest: +SKIP
+
+    """
+    _cmd = 'fslcomplex'
+    input_spec = ComplexInputSpec
+    output_spec = ComplexOuputSpec
+
+    def _parse_inputs(self, skip=None):
+        if skip == None:
+            skip = []
+        if self.inputs.real_cartesian:
+            skip += self.inputs._ofs[:3]
+        elif self.inputs.real_polar:
+            skip += self.inputs._ofs[:1]+self.inputs._ofs[3:]
+        else:
+            skip += self.inputs._ofs[1:]
+        return super(Complex,self)._parse_inputs(skip)
+
+    def _gen_filename(self, name):
+        if name == 'complex_out_file':
+            if self.inputs.complex_cartesian:
+                in_file = self.inputs.real_in_file
+            elif self.inputs.complex_polar:
+                in_file = self.inputs.magnitude_in_file
+            elif self.inputs.complex_split or self.inputs.complex_merge:
+                in_file = self.inputs.complex_in_file
+            else:
+                return None
+            return self._gen_fname(in_file, suffix="_cplx")
+        elif name =='magnitude_out_file':
+            return self._gen_fname(self.inputs.complex_in_file, suffix="_mag")
+        elif name =='phase_out_file':
+            return self._gen_fname(self.inputs.complex_in_file,suffix="_phase")
+        elif name =='real_out_file':
+            return self._gen_fname(self.inputs.complex_in_file, suffix="_real")
+        elif name =='imaginary_out_file':
+            return self._gen_fname(self.inputs.complex_in_file, suffix="_imag")
+        return None
+
+    def _get_output(self,name):
+        output = getattr(self.inputs,name)
+        if not isdefined(output):
+            output = self._gen_filename(name)
+        return os.path.abspath(output)
+
+    def _list_outputs(self):
+        outputs = self.output_spec().get()
+        if self.inputs.complex_cartesian or self.inputs.complex_polar or \
+                self.inputs.complex_split or self.inputs.complex_merge:
+            outputs['complex_out_file'] = self._get_output('complex_out_file')
+        elif self.inputs.real_cartesian:
+            outputs['real_out_file'] = self._get_output('real_out_file')
+            outputs['imaginary_out_file'] = self._get_output('imaginary_out_file')
+        elif self.inputs.real_polar:
+            outputs['magnitude_out_file'] = self._get_output('magnitude_out_file')
+            outputs['phase_out_file'] = self._get_output('phase_out_file')
+        return outputs
+
+