* implemented a combobox to choose which color gradient you want to use and provide a few

* changing the filter does not reset/recomputes min/max (so that colors are comparable between two slices of the same array)
* always use a gradient defined outside of DataArrayModel. There is no hardcoded gradient anymore.
* you can set the gradient and bg_value independently of each other
* vmin and vmax are computed by ignoring -inf/+inf so that the whole array is not the same color in those cases.
* nan values display as Grey so that they stand out more
* fixed background color in compare() being wrong after changing axes order by drag-and-dropping them (closes #89)
* refactored ArrayComparator and SessionComparator dialogs to both use a ComparatorWidget to reduce code duplication
* compare() will color values depending on relative difference instead of absolute difference as this is usually more useful
* like for arraywidget, better color behavior in the presence of -inf/+inf
* use nan_equal to compare arrays so that identical arrays are not marked different when they contain nans
* changed stack axis name: arrays -> array and sessions -> session. It makes for more natural selections.



Sorry for the massive commit. It is all interlinked so it is too hard to commit piecemeal now that I did not commit intermediate steps.

Author: gdementen

larray_editor/arrayadapter.py

@@ -25,7 +25,7 @@ def __init__(self, axes_model, xlabels_model, ylabels_model, data_model,
         # set data
         if data is None:
             data = np.empty((0, 0), dtype=np.int8)
-        self.set_data(data, bg_gradient, bg_value)
+        self.set_data(data, bg_value, current_filter)
 
     def set_changes(self, changes=None):
         assert isinstance(changes, dict)
@@ -99,18 +99,17 @@ def get_bg_value_2D(self, shape_2D):
     # XXX: or create two methods?:
     # - set_data (which reset the current filter)
     # - update_data (which sets new data but keeps current filter unchanged)
-    def set_data(self, data, bg_gradient=None, bg_value=None, current_filter=None):
+    def set_data(self, data, bg_value=None, current_filter=None):
         if data is None:
             data = la.LArray([])
         if current_filter is None:
             self.current_filter = {}
         self.changes = {}
         self.la_data = la.aslarray(data)
         self.bg_value = la.aslarray(bg_value) if bg_value is not None else None
-        self.bg_gradient = bg_gradient
-        self.update_filtered_data(current_filter)
+        self.update_filtered_data(current_filter, reset_minmax=True)
 
-    def update_filtered_data(self, current_filter=None):
+    def update_filtered_data(self, current_filter=None, reset_minmax=False):
         if current_filter is not None:
             assert isinstance(current_filter, dict)
             self.current_filter = current_filter
@@ -126,8 +125,8 @@ def update_filtered_data(self, current_filter=None):
         self.axes_model.set_data(axes)
         self.xlabels_model.set_data(xlabels)
         self.ylabels_model.set_data(ylabels)
-        self.data_model.set_data(data_2D, changes_2D)
-        self.data_model.set_background(self.bg_gradient, bg_value_2D)
+        self.data_model.set_data(data_2D, changes_2D, reset_minmax=reset_minmax)
+        self.data_model.set_bg_value(bg_value_2D)
 
     def get_data(self):
         return self.la_data

larray_editor/arraymodel.py

@@ -1,13 +1,12 @@
 from __future__ import absolute_import, division, print_function
 
 import numpy as np
+from larray_editor.utils import (get_font, from_qvariant, to_qvariant, to_text_string,
+                                 is_float, is_number, LinearGradient, SUPPORTED_FORMATS, scale_to_01range)
 from qtpy.QtCore import Qt, QModelIndex, QAbstractTableModel
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QMessageBox
 
-from larray_editor.utils import (get_font, from_qvariant, to_qvariant, to_text_string,
-                                 is_float, is_number, LinearGradient, SUPPORTED_FORMATS)
-
 LARGE_SIZE = 5e5
 LARGE_NROWS = 1e5
 LARGE_COLS = 60
@@ -50,8 +49,8 @@ def __init__(self, parent=None, data=None, readonly=False, font=None):
     def _set_data(self, data, changes=None):
         raise NotImplementedError()
 
-    def set_data(self, data, changes=None):
-        self._set_data(data, changes)
+    def set_data(self, data, changes=None, **kwargs):
+        self._set_data(data, changes, **kwargs)
         self.reset()
 
     def rowCount(self, parent=QModelIndex()):
@@ -216,15 +215,13 @@ def __init__(self, parent=None, data=None, readonly=False, format="%.3f", font=N
         AbstractArrayModel.__init__(self, parent, data, readonly, font)
         self._format = format
 
-        # Backgroundcolor settings (HSV --> Hue, Saturation, Value, Alpha-channel)
-        self.hsv_min = [0.99, 0.7, 1.0, 0.6]
-        self.hsv_max = [0.66, 0.7, 1.0, 0.6]
-        self.bgcolor_enabled = True
-
         self.minvalue = minvalue
         self.maxvalue = maxvalue
-        self.set_data(data)
-        self.set_background(bg_gradient, bg_value)
+        self._set_data(data)
+        self._set_bg_gradient(bg_gradient)
+        self._set_bg_value(bg_value)
+        # XXX: unsure this is necessary at all in __init__
+        self.reset()
 
     def get_format(self):
         """Return current format"""
@@ -235,7 +232,7 @@ def get_data(self):
         """Return data"""
         return self._data
 
-    def _set_data(self, data, changes=None):
+    def _set_data(self, data, changes=None, reset_minmax=True):
         if changes is None:
             changes = {}
         self.changes = changes
@@ -260,62 +257,51 @@ def _set_data(self, data, changes=None):
         if dtype in (np.complex64, np.complex128):
             self.color_func = np.abs
         else:
-            # XXX: this is a no-op (it returns the array itself) for most types (I think all non complex types)
-            #      => use an explicit nop?
-            # def nop(v):
-            #     return v
-            # self.color_func = nop
-            self.color_func = np.real
+            self.color_func = None
         # --------------------------------------
         self.total_rows, self.total_cols = self._data.shape
-        self.reset_minmax()
+        if reset_minmax:
+            self.reset_minmax()
         self._compute_rows_cols_loaded()
 
     def reset_minmax(self):
-        # this will be awful to get right, because ideally, we should
-        # include self.changes.values() and ignore values corresponding to
-        # self.changes.keys()
         data = self.get_values()
         try:
-            color_value = self.color_func(data)
+            color_value = self.color_func(data) if self.color_func is not None else data
+            # 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.nanmin(color_value))
             self.vmax = float(np.nanmax(color_value))
-            if self.vmax == self.vmin:
-                self.vmin -= 1
-            self.bgcolor_enabled = True
-            self.bg_gradient = LinearGradient([(self.vmin, self.hsv_min), (self.vmax, self.hsv_max)])
-
-        # a) ValueError for empty arrays
-        # b) AssertionError for fail of LinearGradient.init
-        #    -> for very large float number (e.g. 1664780726569649730), doing self.vmin -= 1 does nothing.
-        #       Then, vman = vmin and LinearGradient.init fails
-        except (TypeError, ValueError, AssertionError):
+            self.bgcolor_possible = True
+        # ValueError for empty arrays, TypeError for object/string arrays
+        except (TypeError, ValueError):
             self.vmin = None
             self.vmax = None
-            self.bgcolor_enabled = False
-            self.bg_gradient = None
+            self.bgcolor_possible = False
 
     def set_format(self, format):
         """Change display format"""
         self._format = format
         self.reset()
 
-    def set_background(self, bg_gradient=None, bg_value=None):
+    def set_bg_gradient(self, bg_gradient):
+        self._set_bg_gradient(bg_gradient)
+        self.reset()
+
+    def _set_bg_gradient(self, bg_gradient):
         if bg_gradient is not None and not isinstance(bg_gradient, LinearGradient):
             raise ValueError("Expected None or LinearGradient instance for `bg_gradient` argument")
+        self.bg_gradient = bg_gradient
+
+    def set_bg_value(self, bg_value):
+        self._set_bg_value(bg_value)
+        self.reset()
+
+    def _set_bg_value(self, bg_value):
         if bg_value is not None and not (isinstance(bg_value, np.ndarray) and bg_value.shape == self._data.shape):
             raise ValueError("Expected None or 2D Numpy ndarray with shape {} for `bg_value` argument"
                              .format(self._data.shape))
-        # self.bg_gradient must never be None
-        if bg_gradient is not None:
-            self.bg_gradient = bg_gradient
         self.bg_value = bg_value
-        self.reset()
-
-    def bgcolor(self, state):
-        """Toggle backgroundcolor"""
-        self.bgcolor_enabled = state > 0
-        self.reset()
 
     def get_value(self, index):
         i, j = index.row(), index.column()
@@ -354,12 +340,14 @@ def data(self, index, role=Qt.DisplayRole):
             else:
                 return to_qvariant(self._format % value)
         elif role == Qt.BackgroundColorRole:
-            if self.bgcolor_enabled and value is not np.ma.masked:
+            if self.bgcolor_possible and self.bg_gradient is not None and value is not np.ma.masked:
                 if self.bg_value is None:
-                    return self.bg_gradient[float(self.color_func(value))]
+                    v = float(self.color_func(value) if self.color_func is not None else value)
+                    v = scale_to_01range(v, self.vmin, self.vmax)
                 else:
                     i, j = index.row(), index.column()
-                    return self.bg_gradient[self.bg_value[i, j]]
+                    v = self.bg_value[i, j]
+                return self.bg_gradient[v]
         # elif role == Qt.ToolTipRole:
         #     return to_qvariant("{}\n{}".format(repr(value),self.get_labels(index)))
         return to_qvariant()
@@ -469,11 +457,13 @@ def set_values(self, left, top, right, bottom, values):
 
         # Update vmin/vmax if necessary
         if self.vmin is not None and self.vmax is not None:
-            colorval = self.color_func(values)
-            old_colorval = self.color_func(oldvalues)
+            colorval = self.color_func(values) if self.color_func is not None else values
+            old_colorval = self.color_func(oldvalues) if self.color_func is not None else oldvalues
             if np.any(((old_colorval == self.vmax) & (colorval < self.vmax)) |
                       ((old_colorval == self.vmin) & (colorval > self.vmin))):
                 self.reset_minmax()
+            # this is faster, when the condition is False (which should be most of the cases) than computing
+            # subset_max and checking if subset_max > self.vmax
             if np.any(colorval > self.vmax):
                 self.vmax = float(np.nanmax(colorval))
             if np.any(colorval < self.vmin):

larray_editor/arraywidget.py

@@ -74,19 +74,20 @@
 from itertools import chain
 
 import numpy as np
-from qtpy.QtCore import Qt, QPoint, QItemSelection, QItemSelectionModel, Signal
-from qtpy.QtGui import QDoubleValidator, QIntValidator, QKeySequence, QFontMetrics, QCursor
+from qtpy.QtCore import Qt, QPoint, QItemSelection, QItemSelectionModel, Signal, QSize
+from qtpy.QtGui import (QDoubleValidator, QIntValidator, QKeySequence, QFontMetrics, QCursor, QPixmap, QPainter,
+                        QLinearGradient, QColor, QIcon)
 from qtpy.QtWidgets import (QApplication, QTableView, QItemDelegate, QLineEdit, QCheckBox,
                             QMessageBox, QMenu, QLabel, QSpinBox, QWidget, QToolTip, QShortcut, QScrollBar,
-                            QHBoxLayout, QVBoxLayout, QGridLayout, QSizePolicy, QFrame)
+                            QHBoxLayout, QVBoxLayout, QGridLayout, QSizePolicy, QFrame, QComboBox)
 
 try:
     import xlwings as xw
 except ImportError:
     xw = None
 
 from larray_editor.utils import (keybinding, create_action, clear_layout, get_font, from_qvariant, to_qvariant,
-                                 is_number, is_float, _, ima)
+                                 is_number, is_float, _, ima, LinearGradient)
 from larray_editor.arrayadapter import LArrayDataAdapter
 from larray_editor.arraymodel import LabelsArrayModel, DataArrayModel
 from larray_editor.combo import FilterComboBox, FilterMenu
@@ -505,10 +506,30 @@ def __init__(self, parent, data_scrollbar):
         self.rangeChanged.connect(data_scrollbar.setRange)
 
 
+available_gradients = [
+    # Hue, Saturation, Value, Alpha-channel
+    ('red-blue', LinearGradient([(0, [0.99, 0.7, 1.0, 0.6]), (1, [0.66, 0.7, 1.0, 0.6])])),
+    ('blue-red', LinearGradient([(0, [0.66, 0.7, 1.0, 0.6]), (1, [0.99, 0.7, 1.0, 0.6])])),
+    ('red-white-blue', LinearGradient([(0, [.99, .85, 1., .6]),
+                                       (0.5 - 1e-16, [.99, .15, 1., .6]),
+                                       (0.5, [1., 0., 1., 1.]),
+                                       (0.5 + 1e-16, [.66, .15, 1., .6]),
+                                       (1, [.66, .85, 1., .6])])),
+    ('blue-white-red', LinearGradient([(0, [.66, .85, 1., .6]),
+                                       (0.5 - 1e-16, [.66, .15, 1., .6]),
+                                       (0.5, [1., 0., 1., 1.]),
+                                       (0.5 + 1e-16, [.99, .15, 1., .6]),
+                                       (1, [.99, .85, 1., .6])])),
+]
+gradient_map = dict(available_gradients)
+
+
+
 class ArrayEditorWidget(QWidget):
-    def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient=None,
+    def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient='blue-red',
                  minvalue=None, maxvalue=None):
         QWidget.__init__(self, parent)
+        assert bg_gradient in gradient_map
         readonly = np.isscalar(data)
         self.readonly = readonly
 
@@ -613,10 +634,33 @@ def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient
         self.scientific_checkbox = scientific
         btn_layout.addWidget(scientific)
 
-        bgcolor = QCheckBox(_('Background color'))
-        bgcolor.stateChanged.connect(self.model_data.bgcolor)
-        self.bgcolor_checkbox = bgcolor
-        btn_layout.addWidget(bgcolor)
+        gradient_chooser = QComboBox()
+        gradient_chooser.setMaximumSize(120, 20)
+        gradient_chooser.setIconSize(QSize(100, 20))
+
+        pixmap = QPixmap(100, 15)
+        pixmap.fill(Qt.white)
+        gradient_chooser.addItem(QIcon(pixmap), " ")
+
+        pixmap.fill(Qt.transparent)
+        painter = QPainter(pixmap)
+        for name, gradient in available_gradients:
+            qgradient = gradient.as_qgradient()
+
+            # * fill with white because gradient can be transparent and if we do not "start from whilte", it skews the
+            #   colors.
+            # * 1 and 13 instead of 0 and 15 to have a transparent border around/between the gradients
+            painter.fillRect(0, 1, 100, 13, Qt.white)
+            painter.fillRect(0, 1, 100, 13, qgradient)
+            gradient_chooser.addItem(QIcon(pixmap), name, gradient)
+
+        # without this, we can crash python :)
+        del painter, pixmap
+        # select default gradient
+        gradient_chooser.setCurrentText(bg_gradient)
+        gradient_chooser.currentIndexChanged.connect(self.gradient_changed)
+        btn_layout.addWidget(gradient_chooser)
+        self.gradient_chooser = gradient_chooser
 
         # Set widget layout
         layout = QVBoxLayout()
@@ -625,11 +669,16 @@ def __init__(self, parent, data=None, readonly=False, bg_value=None, bg_gradient
         layout.addLayout(btn_layout)
         layout.setContentsMargins(0, 0, 0, 0)
         self.setLayout(layout)
-        self.set_data(data, bg_value=bg_value, bg_gradient=bg_gradient)
+        self.set_data(data, bg_value=bg_value)
+        self.model_data.set_bg_gradient(gradient_map[bg_gradient])
 
         # See http://doc.qt.io/qt-4.8/qt-draganddrop-fridgemagnets-dragwidget-cpp.html for an example
         self.setAcceptDrops(True)
 
+    def gradient_changed(self, index):
+        gradient = self.gradient_chooser.itemData(index) if index > 0 else None
+        self.model_data.set_bg_gradient(gradient)
+
     def mousePressEvent(self, event):
         self.dragLabel = self.childAt(event.pos()) if event.button() == Qt.LeftButton else None
         self.dragStartPosition = event.pos()
@@ -692,7 +741,10 @@ def dropEvent(self, event):
                 new_axes = la_data.axes.copy()
                 new_axes.insert(new_index, new_axes.pop(new_axes[previous_index]))
                 la_data = la_data.transpose(new_axes)
-                self.set_data(la_data, self.model_data.bg_gradient, self.model_data.bg_value)
+                bg_value = self.data_adapter.bg_value
+                if bg_value is not None:
+                    bg_value = bg_value.transpose(new_axes)
+                self.set_data(la_data, bg_value)
 
                 event.setDropAction(Qt.MoveAction)
                 event.accept()
@@ -701,9 +753,9 @@ def dropEvent(self, event):
         else:
             event.ignore()
 
-    def set_data(self, data=None, bg_gradient=None, bg_value=None):
+    def set_data(self, data=None, bg_value=None):
         # update adapter
-        self.data_adapter.set_data(data, bg_gradient=bg_gradient, bg_value=bg_value)
+        self.data_adapter.set_data(data, bg_value=bg_value)
         la_data = self.data_adapter.get_data()
         axes = la_data.axes
         display_names = axes.display_names
@@ -756,8 +808,7 @@ def _update_digits_scientific(self, data):
         self.scientific_checkbox.setChecked(use_scientific)
         self.scientific_checkbox.setEnabled(is_number(dtype))
 
-        self.bgcolor_checkbox.setChecked(self.model_data.bgcolor_enabled)
-        self.bgcolor_checkbox.setEnabled(self.model_data.bgcolor_enabled)
+        self.gradient_chooser.setEnabled(self.model_data.bgcolor_possible)
 
     def choose_scientific(self, data):
         # max_digits = self.get_max_digits()