# coding: utf-8
# /*##########################################################################
#
# Copyright (c) 2017 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.
#
# ###########################################################################*/
"""
Module containing widgets displaying stats from items of a plot.
"""
__authors__ = ["H. Payno"]
__license__ = "MIT"
__date__ = "12/06/2018"
import functools
import logging
import numpy
from collections import OrderedDict
import silx.utils.weakref
from silx.gui import qt
from silx.gui import icons
from silx.gui.plot.items.curve import Curve as CurveItem
from silx.gui.plot.items.histogram import Histogram as HistogramItem
from silx.gui.plot.items.image import ImageBase as ImageItem
from silx.gui.plot.items.scatter import Scatter as ScatterItem
from silx.gui.plot import stats as statsmdl
from silx.gui.widgets.TableWidget import TableWidget
from silx.gui.plot.stats.statshandler import StatsHandler, StatFormatter
logger = logging.getLogger(__name__)
[docs]class StatsTable(TableWidget):
"""
TableWidget displaying for each curves contained by the Plot some
information:
* legend
* minimal value
* maximal value
* standard deviation (std)
:param parent: The widget's parent.
:param plot: :class:`.PlotWidget` instance on which to operate
"""
COMPATIBLE_KINDS = {
'curve': CurveItem,
'image': ImageItem,
'scatter': ScatterItem,
'histogram': HistogramItem
}
COMPATIBLE_ITEMS = tuple(COMPATIBLE_KINDS.values())
def __init__(self, parent=None, plot=None):
TableWidget.__init__(self, parent)
"""Next freeID for the curve"""
self.plot = None
self._displayOnlyActItem = False
self._statsOnVisibleData = False
self._lgdAndKindToItems = {}
"""Associate to a tuple(legend, kind) the items legend"""
self.callbackImage = None
self.callbackScatter = None
self.callbackCurve = None
"""Associate the curve legend to his first item"""
self._statsHandler = None
self._legendsSet = []
"""list of legends actually displayed"""
self._resetColumns()
self.setColumnCount(len(self._columns))
self.setSelectionBehavior(qt.QAbstractItemView.SelectRows)
self.setPlot(plot)
self.setSortingEnabled(True)
def _resetColumns(self):
self._columns_index = OrderedDict([('legend', 0), ('kind', 1)])
self._columns = self._columns_index.keys()
self.setColumnCount(len(self._columns))
[docs] def setStats(self, statsHandler):
"""
:param statsHandler: Set the statistics to be displayed and how to
format them using
:rtype: :class:`StatsHandler`
"""
_statsHandler = statsHandler
if statsHandler is None:
_statsHandler = StatsHandler(statFormatters=())
if isinstance(_statsHandler, (list, tuple)):
_statsHandler = StatsHandler(_statsHandler)
assert isinstance(_statsHandler, StatsHandler)
self._resetColumns()
self.clear()
for statName, stat in list(_statsHandler.stats.items()):
assert isinstance(stat, statsmdl.StatBase)
self._columns_index[statName] = len(self._columns_index)
self._statsHandler = _statsHandler
self._columns = self._columns_index.keys()
self.setColumnCount(len(self._columns))
self._updateItemObserve()
self._updateAllStats()
def getStatsHandler(self):
return self._statsHandler
def _updateAllStats(self):
for (legend, kind) in self._lgdAndKindToItems:
self._updateStats(legend, kind)
@staticmethod
def _getKind(myItem):
if isinstance(myItem, CurveItem):
return 'curve'
elif isinstance(myItem, ImageItem):
return 'image'
elif isinstance(myItem, ScatterItem):
return 'scatter'
elif isinstance(myItem, HistogramItem):
return 'histogram'
else:
return None
[docs] def setPlot(self, plot):
"""
Define the plot to interact with
:param plot: the plot containing the items on which statistics are
applied
:rtype: :class:`.PlotWidget`
"""
if self.plot:
self._dealWithPlotConnection(create=False)
self.plot = plot
self.clear()
if self.plot:
self._dealWithPlotConnection(create=True)
self._updateItemObserve()
def _updateItemObserve(self):
if self.plot:
self.clear()
if self._displayOnlyActItem is True:
activeCurve = self.plot.getActiveCurve(just_legend=False)
activeScatter = self.plot._getActiveItem(kind='scatter',
just_legend=False)
activeImage = self.plot.getActiveImage(just_legend=False)
if activeCurve:
self._addItem(activeCurve)
if activeImage:
self._addItem(activeImage)
if activeScatter:
self._addItem(activeScatter)
else:
[self._addItem(curve) for curve in self.plot.getAllCurves()]
[self._addItem(image) for image in self.plot.getAllImages()]
scatters = self.plot._getItems(kind='scatter',
just_legend=False,
withhidden=True)
[self._addItem(scatter) for scatter in scatters]
histograms = self.plot._getItems(kind='histogram',
just_legend=False,
withhidden=True)
[self._addItem(histogram) for histogram in histograms]
def _dealWithPlotConnection(self, create=True):
"""
Manage connection to plot signals
Note: connection on Item are managed by the _removeItem function
"""
if self.plot is None:
return
if self._displayOnlyActItem:
if create is True:
if self.callbackImage is None:
self.callbackImage = functools.partial(self._activeItemChanged, 'image')
self.callbackScatter = functools.partial(self._activeItemChanged, 'scatter')
self.callbackCurve = functools.partial(self._activeItemChanged, 'curve')
self.plot.sigActiveImageChanged.connect(self.callbackImage)
self.plot.sigActiveScatterChanged.connect(self.callbackScatter)
self.plot.sigActiveCurveChanged.connect(self.callbackCurve)
else:
if self.callbackImage is not None:
self.plot.sigActiveImageChanged.disconnect(self.callbackImage)
self.plot.sigActiveScatterChanged.disconnect(self.callbackScatter)
self.plot.sigActiveCurveChanged.disconnect(self.callbackCurve)
self.callbackImage = None
self.callbackScatter = None
self.callbackCurve = None
else:
if create is True:
self.plot.sigContentChanged.connect(self._plotContentChanged)
else:
self.plot.sigContentChanged.disconnect(self._plotContentChanged)
if create is True:
self.plot.sigPlotSignal.connect(self._zoomPlotChanged)
else:
self.plot.sigPlotSignal.disconnect(self._zoomPlotChanged)
[docs] def clear(self):
"""
Clear all existing items
"""
lgdsAndKinds = list(self._lgdAndKindToItems.keys())
for lgdAndKind in lgdsAndKinds:
self._removeItem(legend=lgdAndKind[0], kind=lgdAndKind[1])
self._lgdAndKindToItems = {}
qt.QTableWidget.clear(self)
self.setRowCount(0)
# It have to called befor3e accessing to the header items
self.setHorizontalHeaderLabels(self._columns)
if self._statsHandler is not None:
for columnId, name in enumerate(self._columns):
item = self.horizontalHeaderItem(columnId)
if name in self._statsHandler.stats:
stat = self._statsHandler.stats[name]
text = stat.name[0].upper() + stat.name[1:]
if stat.description is not None:
tooltip = stat.description
else:
tooltip = ""
else:
text = name[0].upper() + name[1:]
tooltip = ""
item.setToolTip(tooltip)
item.setText(text)
if hasattr(self.horizontalHeader(), 'setSectionResizeMode'): # Qt5
self.horizontalHeader().setSectionResizeMode(qt.QHeaderView.ResizeToContents)
else: # Qt4
self.horizontalHeader().setResizeMode(qt.QHeaderView.ResizeToContents)
self.setColumnHidden(self._columns_index['kind'], True)
def _addItem(self, item):
assert isinstance(item, self.COMPATIBLE_ITEMS)
if (item.getLegend(), self._getKind(item)) in self._lgdAndKindToItems:
self._updateStats(item.getLegend(), self._getKind(item))
return
self.setRowCount(self.rowCount() + 1)
indexTable = self.rowCount() - 1
kind = self._getKind(item)
self._lgdAndKindToItems[(item.getLegend(), kind)] = {}
# the get item will manage the item creation of not existing
_createItem = self._getItem
for itemName in self._columns:
_createItem(name=itemName, legend=item.getLegend(), kind=kind,
indexTable=indexTable)
self._updateStats(legend=item.getLegend(), kind=kind)
callback = functools.partial(
silx.utils.weakref.WeakMethodProxy(self._updateStats),
item.getLegend(), kind)
item.sigItemChanged.connect(callback)
self.setColumnHidden(self._columns_index['kind'],
item.getLegend() not in self._legendsSet)
self._legendsSet.append(item.getLegend())
def _getItem(self, name, legend, kind, indexTable):
if (legend, kind) not in self._lgdAndKindToItems:
self._lgdAndKindToItems[(legend, kind)] = {}
if not (name in self._lgdAndKindToItems[(legend, kind)] and
self._lgdAndKindToItems[(legend, kind)]):
if name in ('legend', 'kind'):
_item = qt.QTableWidgetItem(type=qt.QTableWidgetItem.Type)
if name == 'legend':
_item.setText(legend)
else:
assert name == 'kind'
_item.setText(kind)
else:
if self._statsHandler.formatters[name]:
_item = self._statsHandler.formatters[name].tabWidgetItemClass()
else:
_item = qt.QTableWidgetItem()
tooltip = self._statsHandler.stats[name].getToolTip(kind=kind)
if tooltip is not None:
_item.setToolTip(tooltip)
_item.setFlags(qt.Qt.ItemIsEnabled | qt.Qt.ItemIsSelectable)
self.setItem(indexTable, self._columns_index[name], _item)
self._lgdAndKindToItems[(legend, kind)][name] = _item
return self._lgdAndKindToItems[(legend, kind)][name]
def _removeItem(self, legend, kind):
if (legend, kind) not in self._lgdAndKindToItems or not self.plot:
return
self.firstItem = self._lgdAndKindToItems[(legend, kind)]['legend']
del self._lgdAndKindToItems[(legend, kind)]
self.removeRow(self.firstItem.row())
self._legendsSet.remove(legend)
self.setColumnHidden(self._columns_index['kind'],
legend not in self._legendsSet)
def _updateCurrentStats(self):
for lgdAndKind in self._lgdAndKindToItems:
self._updateStats(lgdAndKind[0], lgdAndKind[1])
def _updateStats(self, legend, kind, event=None):
if self._statsHandler is None:
return
assert kind in ('curve', 'image', 'scatter', 'histogram')
if kind == 'curve':
item = self.plot.getCurve(legend)
elif kind == 'image':
item = self.plot.getImage(legend)
elif kind == 'scatter':
item = self.plot.getScatter(legend)
elif kind == 'histogram':
item = self.plot.getHistogram(legend)
else:
raise ValueError('kind not managed')
if not item or (item.getLegend(), kind) not in self._lgdAndKindToItems:
return
assert isinstance(item, self.COMPATIBLE_ITEMS)
statsValDict = self._statsHandler.calculate(item, self.plot,
self._statsOnVisibleData)
lgdItem = self._lgdAndKindToItems[(item.getLegend(), kind)]['legend']
assert lgdItem
rowStat = lgdItem.row()
for statName, statVal in list(statsValDict.items()):
assert statName in self._lgdAndKindToItems[(item.getLegend(), kind)]
tableItem = self._getItem(name=statName, legend=item.getLegend(),
kind=kind, indexTable=rowStat)
tableItem.setText(str(statVal))
def currentChanged(self, current, previous):
if current.row() >= 0:
legendItem = self.item(current.row(), self._columns_index['legend'])
assert legendItem
kindItem = self.item(current.row(), self._columns_index['kind'])
kind = kindItem.text()
if kind == 'curve':
self.plot.setActiveCurve(legendItem.text())
elif kind == 'image':
self.plot.setActiveImage(legendItem.text())
elif kind == 'scatter':
self.plot._setActiveItem('scatter', legendItem.text())
elif kind == 'histogram':
# active histogram not managed by the plot actually
pass
else:
raise ValueError('kind not managed')
qt.QTableWidget.currentChanged(self, current, previous)
[docs] def setDisplayOnlyActiveItem(self, displayOnlyActItem):
"""
:param bool displayOnlyActItem: True if we want to only show active
item
"""
if self._displayOnlyActItem == displayOnlyActItem:
return
self._displayOnlyActItem = displayOnlyActItem
self._dealWithPlotConnection(create=False)
self._updateItemObserve()
self._dealWithPlotConnection(create=True)
[docs] def setStatsOnVisibleData(self, b):
"""
.. warning:: When visible data is activated we will process to a simple
filtering of visible data by the user. The filtering is a
simple data sub-sampling. No interpolation is made to fit
data to boundaries.
:param bool b: True if we want to apply statistics only on visible data
"""
if self._statsOnVisibleData != b:
self._statsOnVisibleData = b
self._updateCurrentStats()
def _activeItemChanged(self, kind):
"""Callback used when plotting only the active item"""
assert kind in ('curve', 'image', 'scatter', 'histogram')
self._updateItemObserve()
def _plotContentChanged(self, action, kind, legend):
"""Callback used when plotting all the plot items"""
if kind not in ('curve', 'image', 'scatter', 'histogram'):
return
if kind == 'curve':
item = self.plot.getCurve(legend)
elif kind == 'image':
item = self.plot.getImage(legend)
elif kind == 'scatter':
item = self.plot.getScatter(legend)
elif kind == 'histogram':
item = self.plot.getHistogram(legend)
else:
raise ValueError('kind not managed')
if action == 'add':
if item is None:
raise ValueError('Item from legend "%s" do not exists' % legend)
self._addItem(item)
elif action == 'remove':
self._removeItem(legend, kind)
def _zoomPlotChanged(self, event):
if self._statsOnVisibleData is True:
if 'event' in event and event['event'] == 'limitsChanged':
self._updateCurrentStats()