STY: clarify/streamline code based on feedback

Author: grlee77

bin/parrec2nii

@@ -68,6 +68,17 @@ def get_opt_parser():
                    """The magnetic field strength of the recording, only needed
                    for --dwell-time. The field strength must be supplied
                    because it is not encoded in the PAR/REC format.""")))
+    p.add_option(
+        Option("-i", "--dimension-info", action="store_true", dest="dim_info",
+               default=False,
+               help=one_line(
+                   """Export .PAR dimension labels corresponding to the fourth
+                   dimension of the data.  The dimension info will be stored in
+                   JSON format with a filename matching the input .PAR, but
+                   with the extension .ordering.json.  Only labels that vary
+                   along the 4th dimension are exported.  (e.g. for a single
+                   a single volume structural scan there are no dynamic labels
+                   and no output file will be created)""")))
     p.add_option(
         Option("--origin", action="store", dest="origin", default="scanner",
                help=one_line(
@@ -135,22 +146,14 @@ def error(msg, exit_code):
     sys.exit(exit_code)
 
 
-def sort_info_to_lists(sort_info):
-    sort_info = deepcopy(sort_info)
-    # convert from elements from numpy array to lists for easy JSON export
-    for key in sort_info:
-        ndim = sort_info[key].ndim
-        if ndim == 1:
-            sort_info[key] = list(sort_info[key])
-        elif ndim == 2:
-            k = sort_info[key]
-            k_list = []
-            for row in range(k.shape[0]):
-                k_list.append(list(k[row]))
-            sort_info[key] = k_list
-        else:
-            raise ValueError("only 1D and 2D arrays supported")
-    return sort_info
+def convert_arrays_to_lists(input_dict):
+    # convert dictionary of numpy arrays to a dictionary of lists
+    output_dict = deepcopy(input_dict)
+    for key, value in output_dict.items():
+        if not isinstance(value, np.ndarray):
+            raise ValueError("all dictionary entries must be numpy arrays")
+        output_dict[key] = value.tolist()
+    return output_dict
 
 
 def proc_file(infile, opts):
@@ -282,17 +285,13 @@ def proc_file(infile, opts):
                         fid.write('%s ' % val)
                     fid.write('\n')
 
-    opts.dim_info = True  # TODO: remove hard-coded value
-    if opts.dim_info and pr_img.dataobj._dim_4_labels is not None:
-        labels = pr_img.dataobj._dim_4_labels
-    elif opts.dim_info and pr_img.dataobj._dim_3_4_labels is not None:
-        labels = pr_img.dataobj._dim_3_4_labels
-    else:
-        labels = None
-    if labels is not None and len(labels) > 0:
-        sort_info = sort_info_to_lists(labels)
-        with open(basefilename + '.ordering.json', 'w') as fid:
-            json.dump(sort_info, fid, sort_keys=True, indent=4)
+    # export data labels varying along the 4th dimensions
+    if opts.dim_info:
+        labels = pr_img.header.get_dimension_labels(collapse_slices=True)
+        if len(labels) > 0:
+            labels = convert_arrays_to_lists(labels)
+            with open(basefilename + '.ordering.json', 'w') as fid:
+                json.dump(labels, fid, sort_keys=True, indent=4)
 
     # write out dwell time if requested
     if opts.dwell_time:

nibabel/parrec.py

@@ -257,7 +257,7 @@ def _unique_rows(a):
     if a.ndim != 2:
         raise ValueError("expected 2D input")
     b = np.ascontiguousarray(a).view(
-            np.dtype((np.void, a.dtype.itemsize * a.shape[1])))
+        np.dtype((np.void, a.dtype.itemsize * a.shape[1])))
     return np.unique(b).view(a.dtype).reshape(-1, a.shape[1])
 
 
@@ -581,21 +581,6 @@ def __init__(self, file_like, header, mmap=True, scaling='dv'):
         self._slice_scaling = header.get_data_scaling(scaling)
         self._rec_shape = header.get_rec_shape()
 
-        try:
-            # store additional slice & volume label information
-            self._dim_4_labels = header.sorted_labels(
-                    sorted_indices=self._slice_indices,
-                    collapse_slices=True)
-            self._dim_3_4_labels = None
-        except:
-            # if non-unique slice orientations or image angulations, need to
-            # also keep labels for the 3rd (slice) dimension
-            self._dim_4_labels = None
-            self._dim_3_4_labels = header.sorted_labels(
-                sorted_indices=self._slice_indices,
-                collapse_slices=False)
-
-
     @property
     def shape(self):
         return self._shape
@@ -1141,25 +1126,27 @@ def get_sorted_slice_indices(self):
         n_used = np.prod(self.get_data_shape()[2:])
         return sort_order[:n_used]
 
-    def sorted_labels(self, sorted_indices=None, collapse_slices=True):
-        """ return a dictionary of lists of the varying values in
-        ``self.image_defs``.  This is useful for custom data sorting.  only
-        keys that have more than 1 unique value across the dataset will exist
-        in the returned `sort_info` dictionary.
+    def get_dimension_labels(self, collapse_slices=True):
+        """ Dynamic labels corresponding to the final data dimension(s).
+
+        This is useful for custom data sorting.  A subset of the info in
+        ``self.image_defs`` is returned in an order that matches the final
+        data dimension(s).  Only labels that have more than one unique value
+        across the dataset will be returned.
 
         Parameters
         ----------
-        sorted_indices : array, optional
-            sorted slice indices as returned by
-            ``self.get_sorted_slice_indices``.
         collapse_slices : bool, optional
-            if True, only return indices corresponding to the first slice
+            If True, only return volume indices (corresponding to the first
+            slice).  If False, return indices corresponding to individual
+            slices as well (with shape matching self.shape[2:]).
 
         Returns
         -------
         sort_info : dict
             Each key corresponds to a dynamically varying sequence dimension.
-            The ordering of values corresponds to that in sorted_indices.
+            The ordering of each value corresponds to that returned by
+            ``self.get_sorted_slice_indices``.
         """
 
         # define which keys to store sorting info for
@@ -1176,21 +1163,25 @@ def sorted_labels(self, sorted_indices=None, collapse_slices=True):
                         'gradient orientation number',
                         'diffusion b value number']
 
-        if sorted_indices is None:
-            sorted_indices = self.get_sorted_slice_indices()
+        sorted_indices = self.get_sorted_slice_indices()
+        image_defs = self.image_defs
 
         if collapse_slices:
             dynamic_keys.remove('slice number')
 
-        non_unique_keys = []
+        # remove dynamic keys that may not be present in older .PAR versions
+        for key in dynamic_keys:
+            if key not in image_defs.dtype.fields:
+                dynamic_keys.remove(key)
 
+        non_unique_keys = []
         for key in dynamic_keys:
-            ndim = self.image_defs[key].ndim
+            ndim = image_defs[key].ndim
             if ndim == 1:
-                num_unique = len(np.unique(self.image_defs[key]))
+                num_unique = len(np.unique(image_defs[key]))
             elif ndim == 2:
                 # for 2D cases, e.g. 'image angulation'
-                num_unique = len(_unique_rows(self.image_defs[key]))
+                num_unique = len(_unique_rows(image_defs[key]))
             else:
                 raise ValueError("unexpected image_defs shape > 2D")
             if num_unique > 1:
@@ -1203,18 +1194,19 @@ def sorted_labels(self, sorted_indices=None, collapse_slices=True):
             if 'image angulation' in non_unique_keys:
                 raise ValueError("for non-unique image angulation, need "
                                  "collapse_slice=False")
-            if 'image image_display_orientation' in non_unique_keys:  # ???
+            if 'image_display_orientation' in non_unique_keys:  # ???
                 raise ValueError("for non-unique display orientation, need "
                                  "collapse_slice=False")
-            sl1_indices = self.image_defs['slice number'][sorted_indices] == 1
+            sl1_indices = image_defs['slice number'][sorted_indices] == 1
 
         sort_info = {}
         for key in non_unique_keys:
-
             if collapse_slices:
-                sort_info[key] = self.image_defs[key][sorted_indices][sl1_indices]
+                sort_info[key] = image_defs[key][sorted_indices][sl1_indices]
             else:
-                sort_info[key] = self.image_defs[key][sorted_indices]
+                value = image_defs[key][sorted_indices]
+                sort_info[key] = value.reshape(self.get_data_shape()[2:],
+                                               order='F')
         return sort_info