actual global signal calculation

Author: Shoshana Berleant

nipype/interfaces/nilearn.py

@@ -73,7 +73,7 @@ def _run_interface(self, runtime):
 
         region_signals = masker.fit_transform(self.inputs.in_file)
 
-        if global_masker:
+        if global_masker != None:
             self.inputs.class_labels.insert(0, 'global')
             global_masker.fit()
             global_signal= global_masker.transform(self.inputs.in_file)
@@ -87,26 +87,19 @@ def _run_interface(self, runtime):
 
     def _process_inputs(self):
         ''' validate and  process inputs into useful form '''
-
         import nilearn.input_data as nl
+        import nilearn.image as nli
+
+        label_datas = [nb.load(nifti) for nifti in self.inputs.label_files]
+        label_data = nli.concat_imgs(label_datas)
 
         # determine form of label files, choose appropriate nilearn masker
-        if len(self.inputs.label_files) > 1: # list of 3D nifti images
-            masker = nl.NiftiMapsMasker(self.inputs.label_files)
-            n_labels = len(self.inputs.label_files)
-        else: # list of size one, containing either a 3d or a 4d file
-            self.label_data = nb.load(self.inputs.label_files[0])
-            if len(self.label_data.shape) == 4: # 4d file
-                masker = nl.NiftiMapsMasker(self.label_data)
-                n_labels = self.label_data.shape[3]
-            else: # 3d file
-                if np.amax(self.label_data.get_data()) > 1: # 3d label file
-                    masker = nl.NiftiLabelsMasker(self.label_data)
-                    # assuming consecutive positive integers for regions
-                    n_labels = np.amax(self.label_data.get_data())
-                else: # most probably a single probability map for one label
-                    masker = nl.NiftiMapsMasker(self.label_data)
-                    n_labels = 1
+        if len(label_datas) == 1 and np.amax(label_data.get_data()) > 1: # 3d label file
+            n_labels = np.amax(label_data.get_data())
+            masker = nl.NiftiLabelsMasker(label_data)
+        else: # one 4d file
+            n_labels = label_data.get_data().shape[3]
+            masker = nl.NiftiMapsMasker(label_data)
         masker.set_params(detrend=self.inputs.detrend)
 
         # check label list size
@@ -117,20 +110,15 @@ def _process_inputs(self):
                                                     n_labels,
                                                     self.inputs.label_files))
 
+        global_masker = None
         if self.inputs.include_global:
-            all_ones_mask = nb.Nifti1Image(np.ones(self._label_data_shape()), np.eye(4))
-            global_masker = nl.NiftiLabelsMasker(all_ones_mask, detrend=self.inputs.detrend)
-        else:
-            global_masker = False
+            global_label_data = label_data.get_data().clip(0, 1).sum(axis=3)
+            global_label_data = global_label_data[:, :, :, np.newaxis] # add back 4th dimension
+            global_label_data = nb.Nifti1Image(global_label_data, np.eye(4))
+            global_masker = nl.NiftiMapsMasker(global_label_data, detrend=self.inputs.detrend)
 
         return masker, global_masker
 
-    def _label_data_shape(self):
-        if self.label_data:
-            return self.label_data.shape
-        else:
-            return nb.load(self.inputs.label_files[0]).shape
-
     def _list_outputs(self):
         outputs = self._outputs().get()
         outputs['out_file'] = self.inputs.out_file

nipype/interfaces/tests/test_nilearn.py

@@ -27,6 +27,7 @@ class TestSignalExtraction(unittest.TestCase):
         'out_file': 'signals.tsv'
     }
     labels = ['csf', 'gray', 'white']
+    global_labels = ['global'] + labels
 
     def setUp(self):
         self.orig_dir = os.getcwd()
@@ -60,20 +61,14 @@ def test_signal_extraction_equiv_4d(self):
 
     @skipif(no_nilearn)
     def test_signal_extraction_4d(self):
-        self._test_4d_label([[-5.0652173913, -5.44565217391, 5.50543478261],
-                             [-7.02173913043, 11.1847826087, -4.33152173913],
-                             [-19.0869565217, 21.2391304348, -4.57608695652],
-                             [5.19565217391, -3.66304347826, -1.51630434783],
-                             [-12.0, 3., 0.5]], self.fake_4d_label_data)
+        self._test_4d_label(self.fourd_wanted, self.fake_4d_label_data)
 
     @skipif(no_nilearn)
-    def test_signal_extraction_include_global(self):
+    def test_signal_extraction_global(self):
         # wanted
-        wanted_global = [[3./8], [-3./8], [1./8], [-7./8], [-9./8]]
+        wanted_global = [[-4./6], [-1./6], [3./6], [-1./6], [-7./6]]
         for i, vals in enumerate(self.base_wanted):
             wanted_global[i].extend(vals)
-        wanted_labels = ['global']
-        wanted_labels.extend(self.labels)
 
         # run
         iface.SignalExtraction(in_file=self.filenames['in_file'],
@@ -82,18 +77,30 @@ def test_signal_extraction_include_global(self):
                                include_global=True).run()
 
         # assert
-        self.assert_expected_output(wanted_labels, wanted_global)
+        self.assert_expected_output(self.global_labels, wanted_global)
+
+    @skipif(no_nilearn)
+    def test_signal_extraction_4d_global(self):
+        # wanted
+        wanted_global = [[3./8], [-3./8], [1./8], [-7./8], [-9./8]]
+        for i, vals in enumerate(self.fourd_wanted):
+            wanted_global[i].extend(vals)
 
-    def _test_4d_label(self, wanted, fake_labels):
+        # run
+        self._test_4d_label(wanted_global, self.fake_4d_label_data, include_global=True)
+
+    def _test_4d_label(self, wanted, fake_labels, include_global=False):
         # setup
         utils.save_toy_nii(fake_labels, self.filenames['4d_label_file'])
 
         # run
         iface.SignalExtraction(in_file=self.filenames['in_file'],
                                label_files=self.filenames['4d_label_file'],
-                               class_labels=self.labels).run()
+                               class_labels=self.labels,
+                               include_global=include_global).run()
 
-        self.assert_expected_output(self.labels, wanted)
+        wanted_labels = self.global_labels if include_global else self.labels
+        self.assert_expected_output(wanted_labels, wanted)
 
     def assert_expected_output(self, labels, wanted):
         with open(self.filenames['out_file'], 'r') as output:
@@ -159,3 +166,10 @@ def tearDown(self):
 
                                     [[0.3, 0.3, 0.4],
                                      [0.3, 0.4, 0.3]]]])
+
+
+    fourd_wanted = [[-5.0652173913, -5.44565217391, 5.50543478261],
+                    [-7.02173913043, 11.1847826087, -4.33152173913],
+                    [-19.0869565217, 21.2391304348, -4.57608695652],
+                    [5.19565217391, -3.66304347826, -1.51630434783],
+                    [-12.0, 3., 0.5]]