Skip to main content
`Ctrl`+`K`

# Source code for silx.gui.data.ArrayTableWidget

    # /*##########################################################################
    #
    # Copyright (c) 2016-2021 European Synchrotron Radiation Facility
    #
    # Permission is hereby granted, free of charge, to any person obtaining a copy
    # of this software and associated documentation files (the "Software"), to deal
    # in the Software without restriction, including without limitation the rights
    # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    # copies of the Software, and to permit persons to whom the Software is
    # furnished to do so, subject to the following conditions:
    #
    # The above copyright notice and this permission notice shall be included in
    # all copies or substantial portions of the Software.
    #
    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    # THE SOFTWARE.
    #
    # ###########################################################################*/
    """This module defines a widget designed to display data arrays with any
    number of dimensions as 2D frames (images, slices) in a table view.
    The dimensions not displayed in the table can be browsed using improved
    sliders.

    The widget uses a TableView that relies on a custom abstract item
    model: :class:`silx.gui.data.ArrayTableModel`.
    """
    import sys

    from silx.gui import qt
    from silx.gui.widgets.TableWidget import TableView
    from .ArrayTableModel import ArrayTableModel
    from silx.gui.widgets.FrameBrowser import HorizontalSliderWithBrowser

    __authors__ = ["V.A. Sole", "P. Knobel"]
    __license__ = "MIT"
    __date__ = "24/01/2017"

    class AxesSelector(qt.QWidget):
        """Widget with two combo-boxes to select two dimensions among
        all possible dimensions of an n-dimensional array.

        The first combobox contains values from :math:`0` to :math:`n-2`.

        The choices in the 2nd CB depend on the value selected in the first one.
        If the value selected in the first CB is :math:`m`, the second one lets you
        select values from :math:`m+1` to :math:`n-1`.

        The two axes can be used to select the row axis and the column axis t
        display a slice of the array data in a table view.
        """

        sigDimensionsChanged = qt.Signal(int, int)
        """Signal emitted whenever one of the comboboxes is changed.
        The signal carries the two selected dimensions."""

        def __init__(self, parent=None, n=None):
            qt.QWidget.__init__(self, parent)
            self.layout = qt.QHBoxLayout(self)
            self.layout.setContentsMargins(0, 2, 0, 2)
            self.layout.setSpacing(10)

            self.rowsCB = qt.QComboBox(self)
            self.columnsCB = qt.QComboBox(self)

            self.layout.addWidget(qt.QLabel("Rows dimension", self))
            self.layout.addWidget(self.rowsCB)
            self.layout.addWidget(qt.QLabel("    ", self))
            self.layout.addWidget(qt.QLabel("Columns dimension", self))
            self.layout.addWidget(self.columnsCB)
            self.layout.addStretch(1)

            self._slotsAreConnected = False
            if n is not None:
                self.setNDimensions(n)

        def setNDimensions(self, n):
            """Initialize combo-boxes depending on number of dimensions of array.
            Initially, the rows dimension is the second-to-last one, and the
            columns dimension is the last one.

            Link the CBs together. MAke them emit a signal when their value is
            changed.

            :param int n: Number of dimensions of array
            """
            # remember the number of dimensions and the rows dimension
            self.n = n
            self._rowsDim = n - 2

            # ensure slots are disconnected before (re)initializing widget
            if self._slotsAreConnected:
                self.rowsCB.currentIndexChanged.disconnect(self._rowDimChanged)
                self.columnsCB.currentIndexChanged.disconnect(self._colDimChanged)

            self._clear()
            self.rowsCB.addItems([str(i) for i in range(n - 1)])
            self.rowsCB.setCurrentIndex(n - 2)
            if n >= 1:
                self.columnsCB.addItem(str(n - 1))
                self.columnsCB.setCurrentIndex(0)

            # reconnect slots
            self.rowsCB.currentIndexChanged.connect(self._rowDimChanged)
            self.columnsCB.currentIndexChanged.connect(self._colDimChanged)
            self._slotsAreConnected = True

            # emit new dimensions
            if n > 2:
                self.sigDimensionsChanged.emit(n - 2, n - 1)

        def setDimensions(self, row_dim, col_dim):
            """Set the rows and columns dimensions.

            The rows dimension must be lower than the columns dimension.

            :param int row_dim: Rows dimension
            :param int col_dim: Columns dimension
            """
            if row_dim >= col_dim:
                raise IndexError("Row dimension must be lower than column dimension")
            if not (0 <= row_dim < self.n - 1):
                raise IndexError("Row dimension must be between 0 and %d" % (self.n - 2))
            if not (row_dim < col_dim <= self.n - 1):
                raise IndexError(
                    "Col dimension must be between %d and %d" % (row_dim + 1, self.n - 1)
                )

            # set the rows dimension; this triggers an update of columnsCB
            self.rowsCB.setCurrentIndex(row_dim)
            # columnsCB first item is "row_dim + 1". So index of "col_dim" is
            # col_dim - (row_dim + 1)
            self.columnsCB.setCurrentIndex(col_dim - row_dim - 1)

        def getDimensions(self):
            """Return a 2-tuple of the rows dimension and the columns dimension.

            :return: 2-tuple of axes numbers (row_dimension, col_dimension)
            """
            return self._getRowDim(), self._getColDim()

        def _clear(self):
            """Empty the combo-boxes"""
            self.rowsCB.clear()
            self.columnsCB.clear()

        def _getRowDim(self):
            """Get rows dimension, selected in :attr:`rowsCB`"""
            # rows combobox contains elements "0", ..."n-2",
            # so the selected dim is always equal to the index
            return self.rowsCB.currentIndex()

        def _getColDim(self):
            """Get columns dimension, selected in :attr:`columnsCB`"""
            # columns combobox contains elements "row_dim+1", "row_dim+2", ..., "n-1"
            # so the selected dim is equal to row_dim + 1 + index
            return self._rowsDim + 1 + self.columnsCB.currentIndex()

        def _rowDimChanged(self):
            """Update columns combobox when the rows dimension is changed.

            Emit :attr:`sigDimensionsChanged`"""
            old_col_dim = self._getColDim()
            new_row_dim = self._getRowDim()

            # clear cols CB
            self.columnsCB.currentIndexChanged.disconnect(self._colDimChanged)
            self.columnsCB.clear()
            # refill cols CB
            for i in range(new_row_dim + 1, self.n):
                self.columnsCB.addItem(str(i))

            # keep previous col dimension if possible
            new_col_cb_idx = old_col_dim - (new_row_dim + 1)
            if new_col_cb_idx < 0:
                # if row_dim is now greater than the previous col_dim,
                # we select a new col_dim = row_dim + 1 (first element in cols CB)
                new_col_cb_idx = 0
            self.columnsCB.setCurrentIndex(new_col_cb_idx)

            # reconnect slot
            self.columnsCB.currentIndexChanged.connect(self._colDimChanged)

            self._rowsDim = new_row_dim

            self.sigDimensionsChanged.emit(self._getRowDim(), self._getColDim())

        def _colDimChanged(self):
            """Emit :attr:`sigDimensionsChanged`"""
            self.sigDimensionsChanged.emit(self._getRowDim(), self._getColDim())

    def _get_shape(array_like):
        """Return shape of an array like object.

        In case the object is a nested sequence (list of lists, tuples...),
        the size of each dimension is assumed to be uniform, and is deduced from
        the length of the first sequence.

        :param array_like: Array like object: numpy array, hdf5 dataset,
            multi-dimensional sequence
        :return: Shape of array, as a tuple of integers
        """
        if hasattr(array_like, "shape"):
            return array_like.shape

        shape = []
        subsequence = array_like
        while hasattr(subsequence, "__len__"):
            shape.append(len(subsequence))
            subsequence = subsequence[0]

        return tuple(shape)

    class ArrayTableWidget(qt.QWidget):
        """This widget is designed to display data of 2D frames (images, slices)
        in a table view. The widget can load any n-dimensional array, and display
        any 2-D frame/slice in the array.

        The index of the dimensions orthogonal to the displayed frame can be set
        interactively using a browser widget (sliders, buttons and text entries).

        To set the data, use :meth:`setArrayData`.
        To select the perspective, use :meth:`setPerspective` or
        use :meth:`setFrameAxes`.
        To select the frame, use :meth:`setFrameIndex`.

        .. image:: img/ArrayTableWidget.png
        """

        def __init__(self, parent=None):
            """

            :param parent: parent QWidget
            :param labels: list of labels for each dimension of the array
            """
            qt.QWidget.__init__(self, parent)
            self.mainLayout = qt.QVBoxLayout(self)
            self.mainLayout.setContentsMargins(0, 0, 0, 0)
            self.mainLayout.setSpacing(0)

            self.browserContainer = qt.QWidget(self)
            self.browserLayout = qt.QGridLayout(self.browserContainer)
            self.browserLayout.setContentsMargins(0, 0, 0, 0)
            self.browserLayout.setSpacing(0)

            self._dimensionLabelsText = []
            """List of text labels sorted in the increasing order of the dimension
            they apply to."""
            self._browserLabels = []
            """List of QLabel widgets."""
            self._browserWidgets = []
            """List of HorizontalSliderWithBrowser widgets."""

            self.axesSelector = AxesSelector(self)

            self.view = TableView(self)

            self.mainLayout.addWidget(self.browserContainer)
            self.mainLayout.addWidget(self.axesSelector)
            self.mainLayout.addWidget(self.view)

            self.model = ArrayTableModel(self)
            self.view.setModel(self.model)

        def setArrayData(self, data, labels=None, copy=True, editable=False):
            """Set the data array. Update frame browsers and labels.

            :param data: Numpy array or similar object (e.g. nested sequence,
                h5py dataset...)
            :param labels: list of labels for each dimension of the array, or
                boolean ``True`` to use default labels ("dimension 0",
                "dimension 1", ...). `None` to disable labels (default).
            :param bool copy: If *True*, store a copy of *data* in the model. If
                *False*, store a reference to *data* if possible (only possible if
                *data* is a proper numpy array or an object that implements the
                same methods).
            :param bool editable: Flag to enable editing data. Default is *False*
            """
            self._data_shape = _get_shape(data)

            n_widgets = len(self._browserWidgets)
            n_dimensions = len(self._data_shape)

            # Reset text of labels
            self._dimensionLabelsText = []
            for i in range(n_dimensions):
                if labels in [True, 1]:
                    label_text = "Dimension %d" % i
                elif labels is None or i >= len(labels):
                    label_text = ""
                else:
                    label_text = labels[i]
                self._dimensionLabelsText.append(label_text)

            # not enough widgets, create new ones (we need n_dim - 2)
            for i in range(n_widgets, n_dimensions - 2):
                browser = HorizontalSliderWithBrowser(self.browserContainer)
                self.browserLayout.addWidget(browser, i, 1)
                self._browserWidgets.append(browser)
                browser.valueChanged.connect(self._browserSlot)
                browser.setEnabled(False)
                browser.hide()

                label = qt.QLabel(self.browserContainer)
                self._browserLabels.append(label)
                self.browserLayout.addWidget(label, i, 0)
                label.hide()

            n_widgets = len(self._browserWidgets)
            for i in range(n_widgets):
                label = self._browserLabels[i]
                browser = self._browserWidgets[i]

                if (i + 2) < n_dimensions:
                    label.setText(self._dimensionLabelsText[i])
                    browser.setRange(0, self._data_shape[i] - 1)
                    browser.setEnabled(True)
                    browser.show()
                    if labels is not None:
                        label.show()
                    else:
                        label.hide()
                else:
                    browser.setEnabled(False)
                    browser.hide()
                    label.hide()

            # set model
            self.model.setArrayData(data, copy=copy, editable=editable)
            # some linux distributions need this call
            self.view.setModel(self.model)
            if editable:
                self.view.enableCut()
                self.view.enablePaste()

            # initialize & connect axesSelector
            self.axesSelector.setNDimensions(n_dimensions)
            self.axesSelector.sigDimensionsChanged.connect(self.setFrameAxes)

        def setArrayColors(self, bgcolors=None, fgcolors=None):
            """Set the colors for all table cells by passing an array
            of RGB or RGBA values (integers between 0 and 255).

            The shape of the colors array must be consistent with the data shape.

            If the data array is n-dimensional, the colors array must be
            (n+1)-dimensional, with the first n-dimensions identical to the data
            array dimensions, and the last dimension length-3 (RGB) or
            length-4 (RGBA).

            :param bgcolors: RGB or RGBA colors array, defining the background color
                for each cell in the table.
            :param fgcolors: RGB or RGBA colors array, defining the foreground color
                (text color) for each cell in the table.
            """
            self.model.setArrayColors(bgcolors, fgcolors)

        def displayAxesSelector(self, isVisible):
            """Allow to display or hide the axes selector.

            :param bool isVisible: True to display the axes selector.
            """
            self.axesSelector.setVisible(isVisible)

        def setFrameIndex(self, index):
            """Set the active slice/image index in the n-dimensional array.

            A frame is a 2D array extracted from an array. This frame is
            necessarily parallel to 2 axes, and orthogonal to all other axes.

            The index of a frame is a sequence of indices along the orthogonal
            axes, where the frame intersects the respective axis. The indices
            are listed in the same order as the corresponding dimensions of the
            data array.

            For example, it the data array has 5 dimensions, and we are
            considering frames whose parallel axes are the 2nd and 4th dimensions
            of the array, the frame index will be a sequence of length 3
            corresponding to the indices where the frame intersects the 1st, 3rd
            and 5th axes.

            :param index: Sequence of indices defining the active data slice in
                a n-dimensional array. The sequence length is :math:`n-2`
            :raise: IndexError if any index in the index sequence is out of bound
                on its respective axis.
            """
            self.model.setFrameIndex(index)

        def _resetBrowsers(self, perspective):
            """Adjust limits for browsers based on the perspective and the
            size of the corresponding dimensions. Reset the index to 0.
            Update the dimension in the labels.

            :param perspective: Sequence of axes/dimensions numbers (0-based)
                defining the axes orthogonal to the frame.
            """
            # for 3D arrays we can accept an int rather than a 1-tuple
            if not hasattr(perspective, "__len__"):
                perspective = [perspective]

            # perspective must be sorted
            perspective = sorted(perspective)

            n_dimensions = len(self._data_shape)
            for i in range(n_dimensions - 2):
                browser = self._browserWidgets[i]
                label = self._browserLabels[i]
                browser.setRange(0, self._data_shape[perspective[i]] - 1)
                browser.setValue(0)
                label.setText(self._dimensionLabelsText[perspective[i]])

        def setPerspective(self, perspective):
            """Set the *perspective* by specifying which axes are orthogonal
            to the frame.

            For the opposite approach (defining parallel axes), use
            :meth:`setFrameAxes` instead.

            :param perspective: Sequence of unique axes numbers (0-based) defining
                the orthogonal axes. For a n-dimensional array, the sequence
                length is :math:`n-2`. The order is of the sequence is not taken
                into account (the dimensions are displayed in increasing order
                in the widget).
            """
            self.model.setPerspective(perspective)
            self._resetBrowsers(perspective)

        def setFrameAxes(self, row_axis, col_axis):
            """Set the *perspective* by specifying which axes are parallel
            to the frame.

            For the opposite approach (defining orthogonal axes), use
            :meth:`setPerspective` instead.

            :param int row_axis: Index (0-based) of the first dimension used as a frame
                axis
            :param int col_axis: Index (0-based) of the 2nd dimension used as a frame
                axis
            """
            self.model.setFrameAxes(row_axis, col_axis)
            n_dimensions = len(self._data_shape)
            perspective = tuple(set(range(0, n_dimensions)) - {row_axis, col_axis})
            self._resetBrowsers(perspective)

        def _browserSlot(self, value):
            index = []
            for browser in self._browserWidgets:
                if browser.isEnabled():
                    index.append(browser.value())
            self.setFrameIndex(index)
            self.view.reset()

        def getData(self, copy=True):
            """Return a copy of the data array, or a reference to it if
            *copy=False* is passed as parameter.

            :param bool copy: If *True* (default), return a copy of the data. If
                *False*, return a reference.
            :return: Numpy array of data, or reference to original data object
                if *copy=False*
            """
            return self.model.getData(copy=copy)

    def main():
        import numpy

        a = qt.QApplication([])
        d = numpy.random.normal(0, 1, (4, 5, 1000, 1000))
        for j in range(4):
            for i in range(5):
                d[j, i, :, :] += i + 10 * j
        w = ArrayTableWidget()
        if "2" in sys.argv:
            print("sending a single image")
            w.setArrayData(d[0, 0])
        elif "3" in sys.argv:
            print("sending 5 images")
            w.setArrayData(d[0])
        else:
            print("sending 4 * 5 images ")
            w.setArrayData(d, labels=True)
        w.show()
        a.exec()

    if __name__ == "__main__":
        main()