nipy · effigies · Oct 28, 2019 · Aug 18, 2019 · Aug 18, 2019 · Aug 31, 2019
diff --git a/nibabel/gifti/gifti.py b/nibabel/gifti/gifti.py
@@ -680,6 +680,45 @@ def get_arrays_from_intent(self, intent):
         it = intent_codes.code[intent]
         return [x for x in self.darrays if x.intent == it]
 
+    def agg_data(self, intent_code=None):
+        """
+        Retrun a numpy arrary of aggregated GiftiDataArray of the same intent code
+        or
+        Retrun GiftiDataArray in tuples for surface files
+
         The cache can effect the behavior of the image, because if the cache is 
         full, or you have an array image, then modifying the returned array 
         will modify the result of future calls to ``get_fdata()``.  For example 
         you might do this: 
         >>> import os 
         >>> import nibabel as nib 
         >>> from nibabel.testing import data_path 
         >>> img_fname = os.path.join(data_path, 'example4d.nii.gz') 
         >>> img = nib.load(img_fname) # This is a proxy image 
         >>> nib.is_proxy(img.dataobj) 
         True 
         The array is not yet cached by a call to "get_fdata", so: 
         >>> img.in_memory 
         False 
         After we call ``get_fdata`` using the default `caching` == 'fill', the 
         cache contains a reference to the returned array ``data``: 
         >>> data = img.get_fdata() 
         >>> img.in_memory 
         True 
         We modify an element in the returned data array: 
         >>> data[0, 0, 0, 0] 
         0.0 
         >>> data[0, 0, 0, 0] = 99 
         >>> data[0, 0, 0, 0] 
         99.0 
         The next time we call 'get_fdata', the method returns the cached 
         reference to the (modified) array: 
         >>> data_again = img.get_fdata() 
         >>> data_again is data 
         True 
         >>> data_again[0, 0, 0, 0] 
         99.0 
         If you had *initially* used `caching` == 'unchanged' then the returned 
         ``data`` array would have been loaded from file, but not cached, and: 
         >>> img = nib.load(img_fname)  # a proxy image again 
         >>> data = img.get_fdata(caching='unchanged') 
         >>> img.in_memory 
         False 
         >>> data[0, 0, 0] = 99 
         >>> data_again = img.get_fdata(caching='unchanged') 
         >>> data_again is data 
         False 
         >>> data_again[0, 0, 0, 0] 
         0.0 
         The cache can effect the behavior of the image, because if the cache is 
         full, or you have an array image, then modifying the returned array 
         will modify the result of future calls to ``get_fdata()``.  For example 
         you might do this: 
  
         >>> import os 
         >>> import nibabel as nib 
         >>> from nibabel.testing import data_path 
         >>> img_fname = os.path.join(data_path, 'example4d.nii.gz') 
  
         >>> img = nib.load(img_fname) # This is a proxy image 
         >>> nib.is_proxy(img.dataobj) 
         True 
  
         The array is not yet cached by a call to "get_fdata", so: 
  
         >>> img.in_memory 
         False 
  
         After we call ``get_fdata`` using the default `caching` == 'fill', the 
         cache contains a reference to the returned array ``data``: 
  
         >>> data = img.get_fdata() 
         >>> img.in_memory 
         True 
  
         We modify an element in the returned data array: 
  
         >>> data[0, 0, 0, 0] 
         0.0 
         >>> data[0, 0, 0, 0] = 99 
         >>> data[0, 0, 0, 0] 
         99.0 
  
         The next time we call 'get_fdata', the method returns the cached 
         reference to the (modified) array: 
  
         >>> data_again = img.get_fdata() 
         >>> data_again is data 
         True 
         >>> data_again[0, 0, 0, 0] 
         99.0 
  
         If you had *initially* used `caching` == 'unchanged' then the returned 
         ``data`` array would have been loaded from file, but not cached, and: 
  
         >>> img = nib.load(img_fname)  # a proxy image again 
         >>> data = img.get_fdata(caching='unchanged') 
         >>> img.in_memory 
         False 
         >>> data[0, 0, 0] = 99 
         >>> data_again = img.get_fdata(caching='unchanged') 
         >>> data_again is data 
         False 
         >>> data_again[0, 0, 0, 0] 
         0.0 
+        Parameters
+        ----------
+        intent_code : None, string, integer or tuple of string, optional
+            Intent code, or string describing code.
+            Accept tuple that contains multiple intents to specify the order.
+
+        Returns
+        -------
+        all_data : tuple of ndarray or ndarray
+            If the input is a tuple, the returned tuple will match the order.
+        """
+
+        # Allow multiple intents to specify the order
+        # e.g., agg_data(('pointset', 'triangle')) ensures consistent order
+
+        if isinstance(intent_code, tuple):
+            return tuple(self.agg_data(intent_code=code) for code in intent_code)
+
+        darrays = self.darrays if intent_code is None else self.get_arrays_from_intent(intent_code)
+        all_data = tuple(da.data for da in darrays)
+        all_intent = {da.intent for da in darrays}
+
+        # Gifti files allows usually one or more data array of the same intent code
+        # surf.gii is a special case of having two data array of different intent code
+
+        if self.numDA > 1 and len(all_intent) == 1:
+            if all_intent== 'NIFTI_INTENT_TIME_SERIES':  # stack when the gifti is a timeseries
+                return np.column_stack(all_data)
+            else:
+                return all_data
+        else:
+            return all_data
+
     @deprecate_with_version(
         'getArraysFromIntent method deprecated. '
         "Use get_arrays_from_intent instead.",