RF: Rework PARRECArrayProxy

Author: effigies

nibabel/parrec.py

@@ -639,32 +639,49 @@ def get_unscaled(self):
                                   self._slice_indices, self._shape,
                                   mmap=self._mmap)
 
-    def __array__(self):
-        with ImageOpener(self.file_like) as fileobj:
-            return _data_from_rec(fileobj,
-                                  self._rec_shape,
-                                  self._dtype,
-                                  self._slice_indices,
-                                  self._shape,
-                                  scalings=self._slice_scaling,
-                                  mmap=self._mmap)
-
-    def __getitem__(self, slicer):
+    def _get_unscaled(self, slicer):
         indices = self._slice_indices
-        if indices[0] != 0 or np.any(np.diff(indices) != 1):
+        if slicer == ():
+            with ImageOpener(self.file_like) as fileobj:
+                rec_data = array_from_file(self._rec_shape, self._dtype, fileobj, mmap=self._mmap)
+                rec_data = rec_data[..., indices]
+                return rec_data.reshape(self._shape, order='F')
+        elif indices[0] != 0 or np.any(np.diff(indices) != 1):
             # We can't load direct from REC file, use inefficient slicing
-            return np.asanyarray(self)[slicer]
+            return self._get_unscaled(())[slicer]
+
         # Slices all sequential from zero, can use fileslice
         # This gives more efficient volume by volume loading, for example
         with ImageOpener(self.file_like) as fileobj:
-            raw_data = fileslice(fileobj, slicer, self._shape, self._dtype, 0,
-                                 'F')
+            return fileslice(fileobj, slicer, self._shape, self._dtype, 0, 'F')
+
+    def _get_scaled(self, dtype, slicer):
+        raw_data = self._get_unscaled(slicer)
+        if self._slice_scaling is None:
+            if dtype is None or raw_data.dtype >= np.dtype(dtype):
+                return raw_data
+            return np.asanyarray(raw_data, dtype=dtype)
+
         # Broadcast scaling to shape of original data
         slopes, inters = self._slice_scaling
         fake_data = strided_scalar(self._shape)
         _, slopes, inters = np.broadcast_arrays(fake_data, slopes, inters)
+
+        if dtype is None:
+            dtype = max(slopes.dtype, inters.dtype)
+
         # Slice scaling to give output shape
-        return raw_data * slopes[slicer] + inters[slicer]
+        return raw_data * slopes.astype(dtype)[slicer] + inters.astype(dtype)[slicer]
+
+
+    def get_scaled(self, dtype=None):
+        return self._get_scaled(dtype=dtype, slicer=())
+
+    def __array__(self):
+        return self._get_scaled(dtype=None, slicer=())
+
+    def __getitem__(self, slicer):
+        return self._get_scaled(dtype=None, slicer=slicer)
 
 
 class PARRECHeader(SpatialHeader):