Merge pull request #381 from akeshavan/avscale

enh: fsl avscale and removed nipy FmriRealign4d interleaved

Author: satra

nipype/interfaces/fsl/utils.py

@@ -458,6 +458,64 @@ def aggregate_outputs(self, runtime=None, needed_outputs=None):
         outputs.out_stat = out_stat
         return outputs
 
+class AvScaleInputSpec(FSLCommandInputSpec):
+    mat_file = File(exists=True, argstr="%s", 
+        desc='mat file to read', position=0)
+
+
+class AvScaleOutputSpec(TraitedSpec):
+    rotation_translation_matrix=traits.Any(desc='Rotation and Translation Matrix')
+    scales = traits.Any(desc='Scales (x,y,z)')
+    skews = traits.Any(desc='Skews')
+    average_scaling = traits.Any(desc='Average Scaling')
+    determinant = traits.Any(desc='Determinant')
+    forward_half_transform = traits.Any(desc='Forward Half Transform')
+    backward_half_transform = traits.Any(desc='Backwards Half Transform')
+    left_right_orientation_preserved = traits.Bool(desc='True if LR orientation preserved')
+    
+class AvScale(FSLCommand):
+    """Use FSL avscale command to extract info from mat file output of FLIRT
+
+    Examples
+    --------
+    avscale = AvScale()
+    avscale.inputs.mat_file = 'flirt.mat'
+    res = avscale.run()  # doctest: +SKIP
+
+    """
+    input_spec = AvScaleInputSpec
+    output_spec = AvScaleOutputSpec
+
+    _cmd = 'avscale'
+
+    def _format_arg(self, name, trait_spec, value):
+        return super(AvScale, self)._format_arg(name, trait_spec, value)
+
+    def aggregate_outputs(self, runtime=None, needed_outputs=None):
+        outputs = self._outputs()
+
+        def lines_to_float(lines):
+            out = []
+            for line in lines:
+                values = line.split()
+                out.append([float(val) for val in values])
+            return out
+            
+        out = runtime.stdout.split('\n')
+
+        outputs.rotation_translation_matrix = lines_to_float(out[1:5])
+        outputs.scales = lines_to_float([out[6].split(" = ")[1]])
+        outputs.skews = lines_to_float([out[8].split(" = ")[1]])
+        outputs.average_scaling = lines_to_float([out[10].split(" = ")[1]])
+        outputs.determinant = lines_to_float([out[12].split(" = ")[1]])
+        if out[13].split(": ")[1] == 'preserved':
+            outputs.left_right_orientation_preserved = True
+        else:
+            outputs.left_right_orientation_preserved = False
+        outputs.forward_half_transform = lines_to_float(out[16:20])
+        outputs.backward_half_transform = lines_to_float(out[22:-1])
+
+        return outputs
 
 class OverlayInputSpec(FSLCommandInputSpec):
     transparency = traits.Bool(desc='make overlay colors semi-transparent',

nipype/interfaces/nipy/preprocess.py

@@ -74,29 +74,39 @@ class FmriRealign4dInputSpec(BaseInterfaceInputSpec):
                              desc="File to realign")
     tr = traits.Float(desc="TR in seconds",
                       mandatory=True)
-    slice_order = traits.Either(traits.List(traits.Int),
-                  traits.Enum("ascending", "descending"),
-                  mandatory=True, desc='slice order')
-    interleaved = traits.Bool(desc="True if interleaved",
-                  mandatory=True)
+    slice_order = traits.List(traits.Int(),
+                              desc='0 based slice order', 
+                              requires=["time_interp"])
     tr_slices = traits.Float(desc="TR slices")
     start = traits.Float(0.0, usedefault=True,
                          desc="time offset into TR to align slices to")
-    time_interp = traits.Bool(True, usedefault=True,
-                    desc="Assume smooth changes across time e.g., fmri series")
-    loops = traits.Int(5, usedefault=True, desc="loops within each run")
-    between_loops = traits.Int(5, usedefault=True, desc="loops used to \
+    time_interp = traits.Enum(True, requires=["slice_order"],
+                    desc="Assume smooth changes across time e.g.,\
+                     fmri series. If you don't want slice timing \
+                     correction set this to undefined")
+    loops = traits.Either(traits.Int(5,usedefault=True), 
+                          traits.List(traits.Int), 
+                          usedefault=True, 
+                          desc="loops within each run")
+    between_loops = traits.Either(traits.Int(5),
+                                  traits.List(traits.Int), 
+                                  usedefault=True, desc="loops used to \
                                                           realign different \
                                                           runs")
-    speedup = traits.Int(5, usedefault=True, desc="successive image \
-                                                    sub-sampling factors \
-                                                    for acceleration")
+    speedup = traits.Either(traits.Int(5),
+                            traits.List(traits.Int(5)),
+                            usedefault=True, 
+                            desc="successive image \
+                                  sub-sampling factors \
+                                  for acceleration")
 
 
 class FmriRealign4dOutputSpec(TraitedSpec):
 
-    out_file = OutputMultiPath(File(exists=True), desc="Realigned files")
-    par_file = OutputMultiPath(File(exists=True), desc="Motion parameter files")
+    out_file = OutputMultiPath(File(exists=True), 
+                               desc="Realigned files")
+    par_file = OutputMultiPath(File(exists=True),
+                               desc="Motion parameter files")
 
 
 class FmriRealign4d(BaseInterface):
@@ -110,8 +120,7 @@ class FmriRealign4d(BaseInterface):
     >>> realigner = FmriRealign4d()
     >>> realigner.inputs.in_file = ['functional.nii']
     >>> realigner.inputs.tr = 2
-    >>> realigner.inputs.slice_order = 'ascending'
-    >>> realigner.inputs.interleaved = True
+    >>> realigner.inputs.slice_order = range(0,67)
     >>> res = realigner.run() # doctest: +SKIP
 
     References
@@ -144,7 +153,6 @@ def _run_interface(self, runtime):
 
         R = FR4d(all_ims, tr=self.inputs.tr,
             slice_order=self.inputs.slice_order,
-            interleaved=self.inputs.interleaved,
             tr_slices=TR_slices,
             time_interp=self.inputs.time_interp,
             start=self.inputs.start)