FIX: fixed colors for arrays with a lot of nan

the whole sample is nan but not the entire array

Author: gdementen

larray_editor/arraymodel.py

@@ -327,8 +327,13 @@ def reset_minmax(self):
                 color_value = color_value.astype(float)
             # ignore nan, -inf, inf (setting them to 0 or to very large numbers is not an option)
             color_value = color_value[np.isfinite(color_value)]
-            self.vmin = float(np.min(color_value))
-            self.vmax = float(np.max(color_value))
+            if color_value.size:
+                self.vmin = float(np.min(color_value))
+                self.vmax = float(np.max(color_value))
+            else:
+                self.vmin = np.nan
+                self.vmax = np.nan
+
             self.bgcolor_possible = True
         # ValueError for empty arrays, TypeError for object/string arrays
         except (TypeError, ValueError):
@@ -398,16 +403,23 @@ def data(self, index, role=Qt.DisplayRole):
                 if self.bg_value is None:
                     try:
                         v = self.color_func(value) if self.color_func is not None else value
-                        if -np.inf < v < self.vmin:
-                            # TODO: this is suboptimal, as it can reset many times (though in practice, it is usually
-                            #       ok). When we get buffering, we will need to compute vmin/vmax on the whole buffer
-                            #       at once, eliminating this problem (and we could even compute final colors directly
-                            #       all at once)
-                            self.vmin = v
-                            self.reset()
-                        elif self.vmax < v < np.inf:
-                            self.vmax = v
-                            self.reset()
+                        if np.isnan(v):
+                            v = np.nan
+                        else:
+                            do_reset = False
+                            if np.isnan(self.vmin) or -np.inf < v < self.vmin:
+                                # TODO: this is suboptimal, as it can reset many times (though in practice, it is
+                                #       usually ok). When we get buffering, we will need to compute vmin/vmax on the
+                                #       whole buffer at once, eliminating this problem (and we could even compute final
+                                #       colors directly all at once)
+                                self.vmin = v
+                                do_reset = True
+                            if np.isnan(self.vmax) or self.vmax < v < np.inf:
+                                self.vmax = v
+                                do_reset = True
+
+                            if do_reset:
+                                self.reset()
                         v = scale_to_01range(v, self.vmin, self.vmax)
                     except TypeError:
                         v = np.nan

larray_editor/tests/test_api_larray.py

@@ -99,6 +99,10 @@ def make_demo(width=20, ball_radius=5, path_radius=5, steps=30):
 extreme_array = la.Array([-la.inf, -1, 0, la.nan, 1, la.inf])
 array_scalar = la.Array(0)
 arr_all_nan = la.Array([la.nan, la.nan])
+# this is crafted so that the entire 500 points sample is all nan but
+# other values need coloring
+arr_full_buffer_nan_should_not_be_all_white = la.ndtest(1000, dtype=float)
+arr_full_buffer_nan_should_not_be_all_white['a0'::2] = la.nan
 arr_empty = la.Array([])
 arr_empty_2d = la.Array([[], []])
 arr_obj = la.ndtest((2, 3)).astype(object)

larray_editor/utils.py

@@ -271,7 +271,7 @@ def __getitem__(self, key):
         Parameters
         ----------
         key : float
-            must be between 0 and 1
+            must be between 0 and 1 to return a color from the gradient. Otherwise, will return nan_color.
 
         Returns
         -------
@@ -488,10 +488,10 @@ def scale_to_01range(value, vmin, vmax):
         Value to scale.
     vmin : any numeric type
         Minimum used to do the scaling. This is the minimum value that is valid for value, *excluding -inf*.
-        vmin must be <= vmax.
+        vmin must be <= vmax. vmin and vmax can be `nan`, in which case scale_to_01range will return `nan`.
     vmax : any numeric type
         Maximum used to do the scaling. This is the maximum value that is valid for value, *excluding +inf*.
-        vmax must be >= vmin.
+        vmax must be >= vmin. vmin and vmax can be `nan`, in which case scale_to_01range will return `nan`.
 
     Returns
     -------
@@ -515,7 +515,7 @@ def scale_to_01range(value, vmin, vmax):
     array([ 0. ,  1. ,  0.5,  0. ,  0.1,  1. ])
     """
     if hasattr(value, 'shape') and value.shape:
-        if (np.isnan(vmin) and np.isnan(vmax)) or (vmin == vmax):
+        if np.isnan(vmin) or np.isnan(vmax) or (vmin == vmax):
             return np.where(np.isnan(value), np.nan, 0)
         else:
             assert vmin < vmax
@@ -531,7 +531,7 @@ def scale_to_01range(value, vmin, vmax):
             return 0.0
         elif value == +np.inf:
             return 1.0
-        elif vmin == vmax:
+        elif np.isnan(vmin) or np.isnan(vmax) or (vmin == vmax):
             return 0.0
         else:
             assert vmin < vmax