class TreeLegend(QObject):
toggledLegend = pyqtSignal(list)
descriptionLegend = pyqtSignal(str)
def __init__(self, treeView):
def init():
self.setHeader()
self.tree.setModel(self.model)
self.headerView.setMovable(False)
self.headerView.setClickable(True)
self.tree.setSelectionMode(0) # no selection
super(TreeLegend, self).__init__()
self.tree = treeView
#
self.hasConnect = self.layer = self.legendItems = None
self.visibleItems = []
self.model = QStandardItemModel(0, 1)
self.headerView = self.tree.header()
#
init()
self._connect()
def __del__(self):
if self.hasConnect:
self._connect(False)
self.model.clear()
self.layer.legendChanged.disconnect(self.updateLegendItems)
def _connect(self, isConnect=True):
ss = [{
'signal': self.tree.clicked,
'slot': self.toggleItem
}, {
'signal': self.headerView.sectionClicked,
'slot': self.toggleHeader
}, {
'signal': self.headerView.sectionDoubleClicked,
'slot': self.emitDescription
}]
if isConnect:
self.hasConnect = True
for item in ss:
item['signal'].connect(item['slot'])
else:
self.hasConnect = False
for item in ss:
item['signal'].disconnect(item['slot'])
def setHeader(self, data=None):
if data is None:
self.model.clear()
nameHeader = 'Select Raster Layer(Palette)'
font = QFont()
font.setStrikeOut(False)
headerModel = QStandardItem(nameHeader)
headerModel.setData(font, Qt.FontRole)
tip = "Raster with Palette(Single Band)"
headerModel.setData(tip, Qt.ToolTipRole)
self.model.setHorizontalHeaderItem(0, headerModel)
else:
headerModel = self.model.horizontalHeaderItem(0)
label = "%s" % data['name']
formatMgs = "Layer: %s\nSource: %s\nNumber Class: %d\nWidth: %d\nHeight: %d\nRes.X: %f\nRes.Y: %f\n\n* Double click copy to Clipboard"
dataMsg = (data['name'], data['source'], data['num_class'],
data['width'], data['height'], data['resX'],
data['resY'])
tip = formatMgs % dataMsg
headerModel.setData(data, Qt.UserRole)
headerModel.setData(label, Qt.DisplayRole)
headerModel.setData(tip, Qt.ToolTipRole)
def setLayer(self, layer):
self.legendItems = layer.legendSymbologyItems()
total = len(self.legendItems)
self.visibleItems = [True for x in range(total)]
data = {
'name': layer.name(),
'source': layer.source(),
'num_class': total,
'width': layer.width(),
'height': layer.height(),
'resX': layer.rasterUnitsPerPixelX(),
'resY': layer.rasterUnitsPerPixelY()
}
self.setHeader(data)
#
if not self.layer is None:
self.layer.legendChanged.disconnect(self.updateLegendItems)
layer.legendChanged.connect(self.updateLegendItems)
self.layer = layer
def setLegend(self, values):
def setHeader():
headerModel = self.model.horizontalHeaderItem(0)
data = headerModel.data(Qt.UserRole)
data['num_class'] = len(values)
self.setHeader(data)
def createItem(item):
(pixel, total) = item
(legend, color) = self.legendItems[pixel]
name = "[%d] %s" % (pixel, legend)
tip = "Value pixel: %d\nTotal pixels: %d\nClass name: %s" % (
pixel, total, legend)
pix = QPixmap(16, 16)
pix.fill(color)
font.setStrikeOut(not self.visibleItems[pixel])
#
itemModel = QStandardItem(QIcon(pix), name)
itemModel.setEditable(False)
itemModel.setData(font, Qt.FontRole)
itemModel.setData(tip, Qt.ToolTipRole)
itemModel.setData(item, Qt.UserRole)
#
return itemModel
setHeader()
self.model.removeRows(0, self.model.rowCount())
#
font = QFont()
for item in values:
self.model.appendRow(createItem(item))
def setEnabled(self, isEnable=True):
self._connect(isEnable)
self.tree.setEnabled(isEnable)
def getLayerName(self):
headerModel = self.model.horizontalHeaderItem(0)
return headerModel.data(Qt.UserRole)['name']
@pyqtSlot()
def updateLegendItems(self):
self.legendItems = self.layer.legendSymbologyItems()
# Refresh legend
rows = self.model.rowCount()
row = 0
while row < rows:
index = self.model.index(row, 0)
(pixel, total) = self.model.data(index, Qt.UserRole)
(legend, color) = self.legendItems[pixel]
pix = QPixmap(16, 16)
pix.fill(color)
self.model.setData(index, QIcon(pix), Qt.DecorationRole)
row += 1
@pyqtSlot('QModelIndex')
def toggleItem(self, index):
font = index.data(Qt.FontRole)
strike = not font.strikeOut()
font.setStrikeOut(strike)
self.model.setData(index, font, Qt.FontRole)
#
(pixel, total) = index.data(Qt.UserRole)
visible = not strike
self.visibleItems[pixel] = visible
#
self.toggledLegend.emit(self.visibleItems)
@pyqtSlot(int)
def toggleHeader(self, logical):
rowCount = self.model.rowCount()
if rowCount == 0:
return
header = self.model.horizontalHeaderItem(0)
font = header.data(Qt.FontRole)
strike = not font.strikeOut()
font.setStrikeOut(strike)
header.setData(font, Qt.FontRole)
#
items = []
row = 0
while row < self.model.rowCount():
index = self.model.index(row, 0)
self.model.setData(index, font, Qt.FontRole)
items.append(index.data(Qt.UserRole))
row += 1
visible = not strike
for item in items:
(pixel, total) = item
self.visibleItems[pixel] = visible
#
self.toggledLegend.emit(self.visibleItems)
@pyqtSlot(int)
def emitDescription(self):
def getDescription():
data = self.model.horizontalHeaderItem(0).data(Qt.UserRole)
formatMgs = "Layer: %s\nSource: %s\nNumber Class: %d\nWidth: %d\nHeight: %d\nRes.X: %f\nRes.Y: %f"
dataMsg = (data['name'], data['source'], data['num_class'],
data['width'], data['height'], data['resX'],
data['resY'])
descHeader = formatMgs % dataMsg
#
descItems = ["Value pixel;Total pixels;Class name"]
rows = self.model.rowCount()
row = 0
while row < rows:
index = self.model.index(row, 0)
(pixel, total) = self.model.data(index, Qt.UserRole)
(legend, color) = self.legendItems[pixel]
descItems.append("%d;%d;%s" % (pixel, total, legend))
row += 1
return "%s\n\n%s" % (descHeader, '\n'.join(descItems))
if self.model.rowCount() > 0:
self.descriptionLegend.emit(getDescription())
class OWConfusionMatrix(widget.OWWidget):
name = "Confusion Matrix"
description = "Display confusion matrix constructed from results " \
"of evaluation of classifiers."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
inputs = [("Evaluation Results", Orange.evaluation.Results, "set_results")]
outputs = [("Selected Data", Orange.data.Table)]
quantities = ["Number of instances",
"Proportion of predicted",
"Proportion of actual"]
selected_learner = settings.Setting([])
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.widgetBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.widgetBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.widgetBox(self.controlArea, "Select")
gui.button(box, self, "Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "None",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit",
"Send Data", "Auto send is on")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.addWidget(QLabel("Predicted"), 0, 1, Qt.AlignCenter)
grid.addWidget(VerticalLabel("Actual Class"), 1, 0, Qt.AlignCenter)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
grid.addWidget(view, 1, 1)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
return QSize(750, 600)
def set_results(self, results):
"""Set the input results."""
self.clear()
self.warning([0, 1])
data = None
if results is not None:
if results.data is not None:
data = results.data
if data is not None and not data.domain.has_discrete_class:
data = None
results = None
self.warning(
0, "Confusion Matrix cannot be used for regression results.")
self.results = results
self.data = data
if data is not None:
class_values = data.domain.class_var.values
elif results is not None:
raise NotImplementedError
if results is not None:
nmodels, ntests = results.predicted.shape
self.headers = class_values + [unicodedata.lookup("N-ARY SUMMATION")]
# NOTE: The 'learner_names' is set in 'Test Learners' widget.
if hasattr(results, "learner_names"):
self.learners = results.learner_names
else:
self.learners = ["L %i" % (i + 1) for i in range(nmodels)]
self.tablemodel.setVerticalHeaderLabels(self.headers)
self.tablemodel.setHorizontalHeaderLabels(self.headers)
if len(' '.join(self.headers)) < 120:
self.tableview.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
else:
self.tableview.horizontalHeader().setDefaultSectionSize(60)
self.tableview.horizontalHeader().setResizeMode(QHeaderView.Interactive)
for i, h in enumerate(self.headers):
self.tablemodel.horizontalHeaderItem(i).setToolTip(h)
self.tablemodel.setRowCount(len(class_values) + 1)
self.tablemodel.setColumnCount(len(class_values) + 1)
self.selected_learner = [0]
self._update()
def clear(self):
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
# method
self.learners = []
def select_correct(self):
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
def select_wrong(self):
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(n):
for j in range(i + 1, n):
index = self.tablemodel.index(i, j)
selection.select(index, index)
index = self.tablemodel.index(j, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
def select_none(self):
self.tableview.selectionModel().clear()
def commit(self):
if self.results is not None and self.data is not None \
and self.selected_learner:
indices = self.tableview.selectedIndexes()
indices = {(ind.row(), ind.column()) for ind in indices}
actual = self.results.actual
selected_learner = self.selected_learner[0]
learner_name = self.learners[selected_learner]
predicted = self.results.predicted[selected_learner]
selected = [i for i, t in enumerate(zip(actual, predicted))
if t in indices]
row_indices = self.results.row_indices[selected]
extra = []
class_var = self.data.domain.class_var
metas = self.data.domain.metas
if self.append_predictions:
predicted = numpy.array(predicted[selected], dtype=object)
extra.append(predicted.reshape(-1, 1))
var = Orange.data.DiscreteVariable(
"{}({})".format(class_var.name, learner_name),
class_var.values
)
metas = metas + (var,)
if self.append_probabilities and \
self.results.probabilities is not None:
probs = self.results.probabilities[selected_learner, selected]
extra.append(numpy.array(probs, dtype=object))
pvars = [Orange.data.ContinuousVariable("p({})".format(value))
for value in class_var.values]
metas = metas + tuple(pvars)
X = self.data.X[row_indices]
Y = self.data.Y[row_indices]
M = self.data.metas[row_indices]
row_ids = self.data.ids[row_indices]
M = numpy.hstack((M,) + tuple(extra))
domain = Orange.data.Domain(
self.data.domain.attributes,
self.data.domain.class_vars,
metas
)
data = Orange.data.Table.from_numpy(domain, X, Y, M)
data.ids = row_ids
data.name = learner_name
else:
data = None
self.send("Selected Data", data)
def _invalidate(self):
self.commit()
def _learner_changed(self):
# The selected learner has changed
self._update()
self._invalidate()
def _update(self):
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
index = self.selected_learner[0]
cmatrix = confusion_matrix(self.results, index)
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
total = rowsum.sum()
if self.selected_quantity == 0:
value = lambda i, j: int(cmatrix[i, j])
elif self.selected_quantity == 1:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / colsum[i])
if colsum[i] else "N/A")
elif self.selected_quantity == 2:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / rowsum[i])
if colsum[i] else "N/A")
else:
assert False
model = self.tablemodel
for i, row in enumerate(cmatrix):
for j, _ in enumerate(row):
item = model.item(i, j)
if item is None:
item = QStandardItem()
item.setData(value(i, j), Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
model.setItem(i, j, item)
font = model.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
def sum_item(value):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
return item
N = len(colsum)
for i in range(N):
model.setItem(N, i, sum_item(int(colsum[i])))
model.setItem(i, N, sum_item(int(rowsum[i])))
model.setItem(N, N, sum_item(int(total)))
