NF+BF+TST - try offset for all int scaling

Try subtracting offset for int output (as well as uint output) to see if
it will put values within output range.

Add int_abs when testing for mn / mx sign flip (corner case)

Refactor (u)int to (u)int scaling into own method

Author: matthew-brett

nibabel/arraywriters.py

@@ -23,7 +23,7 @@ def __init__(self, array, out_dtype=None)
 
 import numpy as np
 
-from .casting import shared_range, int_to_float, as_int
+from .casting import shared_range, int_to_float, as_int, int_abs
 from .volumeutils import finite_range, array_to_file
 
 
@@ -277,11 +277,10 @@ def to_fileobj(self, fileobj, order='F', nan2zero=True):
 
     def _do_scaling(self):
         arr = self._array
-        arr_dtype = arr.dtype
         out_dtype = self._out_dtype
         assert out_dtype.kind in 'iu'
         mn, mx = self.finite_range()
-        if arr_dtype.kind == 'f':
+        if arr.dtype.kind == 'f':
             # Float to (u)int scaling
             self._range_scale()
             return
@@ -291,10 +290,21 @@ def _do_scaling(self):
         if mx <= out_max and mn >= out_min: # already in range
             return
         # (u)int to (u)int scaling
+        self._iu2iu()
+
+    def _iu2iu(self):
+        # (u)int to (u)int scaling
+        mn, mx = self.finite_range()
         if self._out_dtype.kind == 'u':
+            # We're checking for a sign flip.  This can only work for uint
+            # output, because, for int output, the abs min of the type is
+            # greater than the abs max, so the data either fit into the range in
+            # the test above, or this test won't pass
             shared_min, shared_max = shared_range(self.scaler_dtype,
                                                   self._out_dtype)
-            if mx <= 0 and abs(mn) <= shared_max: # sign flip enough?
+            # Need abs that deals with max neg ints. abs problem only arises
+            # when all the data is set to max neg integer value
+            if mx <= 0 and int_abs(mn) <= shared_max: # sign flip enough?
                 # -1.0 * arr will be in scaler_dtype precision
                 self.slope = -1.0
                 return
@@ -406,42 +416,20 @@ def to_fileobj(self, fileobj, order='F', nan2zero=True):
                       order=order,
                       nan2zero=nan2zero)
 
-    def _do_scaling(self):
-        """ Calculate / set scaling for floats/(u)ints to (u)ints
-        """
-        arr = self._array
-        arr_dtype = arr.dtype
-        out_dtype = self._out_dtype
-        assert out_dtype.kind in 'iu'
-        mn, mx = self.finite_range()
-        if mn == np.inf : # No valid data
-            return
-        if (mn, mx) == (0.0, 0.0): # Data all zero
-            return
-        if arr_dtype.kind == 'f':
-            # Float to (u)int scaling
-            self._range_scale()
-            return
+    def _iu2iu(self):
         # (u)int to (u)int
-        info = np.iinfo(out_dtype)
-        out_max, out_min = info.max, info.min
-        if mx <= out_max and mn >= out_min: # already in range
+        mn, mx = self.finite_range()
+        shared_min, shared_max = shared_range(self.scaler_dtype,
+                                              self._out_dtype)
+        # range may be greater than the largest integer for this type.
+        # as_int needed to work round numpy 1.4.1 int casting bug
+        type_range = as_int(shared_max) - as_int(shared_min)
+        mn2mx = as_int(mx) - as_int(mn)
+        if mn2mx <= type_range: # offset enough?
+            self.inter = mn - shared_min
             return
-        # (u)int to (u)int scaling
-        if self._out_dtype.kind == 'u':
-            shared_min, shared_max = shared_range(self.scaler_dtype,
-                                                  self._out_dtype)
-            # range may be greater than the largest integer for this type.
-            # as_int needed to work round numpy 1.4.1 int casting bug
-            mn2mx = as_int(mx) - as_int(mn)
-            if mn2mx <= shared_max: # offset enough?
-                self.inter = mn
-                return
-            if mx <= 0 and abs(mn) <= shared_max: # sign flip enough?
-                # -1.0 * arr will be in scaler_dtype precision
-                self.slope = -1.0
-                return
-        self._range_scale()
+        # Try slope options (sign flip) and then range scaling
+        super(SlopeInterArrayWriter, self)._iu2iu()
 
     def _range_scale(self):
         """ Calculate scaling, intercept based on data range and output type """

nibabel/tests/test_arraywriters.py

@@ -312,6 +312,10 @@ def test_no_offset_scale():
     assert_equal(aw.slope, 2)
     aw = SAW(np.array([-128 * 2.0, 127], dtype=np.float32), np.int8)
     assert_equal(aw.slope, 2)
+    # Test that nasty abs behavior does not upset us
+    n = -2**15
+    aw = SAW(np.array([n, n], dtype=np.int16), np.uint8)
+    assert_array_almost_equal(aw.slope, n / 255.0, 5)
 
 
 def test_with_offset_scale():
@@ -325,6 +329,10 @@ def test_with_offset_scale():
     assert_equal((aw.slope, aw.inter), (1, -1)) # offset only
     aw = SIAW(np.array([-1, 255], dtype=np.int16), np.uint8)
     assert_not_equal((aw.slope, aw.inter), (1, -1)) # Too big for offset only
+    aw = SIAW(np.array([-256, -2], dtype=np.int16), np.uint8)
+    assert_equal((aw.slope, aw.inter), (1, -256)) # offset only
+    aw = SIAW(np.array([-256, -2], dtype=np.int16), np.int8)
+    assert_equal((aw.slope, aw.inter), (1, -128)) # offset only
 
 
 def test_io_scaling():