def on_ions_updated(self, new_ions):
qmodel = QStandardItemModel()
qmodel.setColumnCount(2)
qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion'))
qmodel.setHorizontalHeaderItem(1, QStandardItem('Abundance (%)'))
root = qmodel.invisibleRootItem()
element_keyfunc = lambda x: x.isotope.element
sorted_ions = sorted(new_ions, key=element_keyfunc)
for element, ions in itertools.groupby(sorted_ions, key=element_keyfunc):
element_item = QStandardItem(element)
element_item.setCheckable(True)
element_item.setCheckState(2)
root.appendRow(element_item)
for ion in ions:
ion_name = QStandardItem(ion.name)
ion_name.setData(ion,32)
ion_name.emitDataChanged()
ion_abundance = QStandardItem(str(ion.isotope.abundance))
element_item.appendRow([ion_name, ion_abundance])
self.ionlistTree.setModel(qmodel)
self.ionlistTree.expandAll()
self.addionsButton.setEnabled(True)
self._qmodel=qmodel
def on_analyses_viewmodel_updated(self, view_model):
qmodel = QStandardItemModel()
qmodel.itemChanged.connect(self.on_qmodel_itemChanged)
qmodel.setColumnCount(5)
qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion'))
qmodel.setHorizontalHeaderItem(1, QStandardItem('Method'))
qmodel.setHorizontalHeaderItem(2, QStandardItem('Start'))
qmodel.setHorizontalHeaderItem(3, QStandardItem('End'))
qmodel.setHorizontalHeaderItem(4, QStandardItem('Reason'))
root = qmodel.invisibleRootItem()
for ion, analysis in view_model.analyses.items():
ion_name = QStandardItem(ion.name)
ion_name.setData(ion, Qt.UserRole)
method = QStandardItem(analysis.method)
start = QStandardItem(str(round(analysis.range.start,2)))
end = QStandardItem(str(round(analysis.range.end,2)))
reason = QStandardItem(analysis.reason)
root.appendRow([ion_name, method, start, end, reason])
self.rangedTable.setModel(qmodel)
self.rangedTable.setItemDelegateForColumn(1, MethodsComboDelegate(view_model.methods, self.rangedTable))
for row in range(0, qmodel.rowCount()):
self.rangedTable.openPersistentEditor(qmodel.index(row, 1))
self.rangedTable.setColumnWidth(1, 95)
self.rangedTable.setContextMenuPolicy(3)
self.rangedTable.customContextMenuRequested.connect(self._context_menu_requested)
shortcut = QShortcut(QKeySequence('Del'), self.rangedTable, self._delete_ion,self._delete_ion, context=0)
def _show_apis(self, apis, recommend=False):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(apis), 4)
model.setColumnCount(4)
for api in apis:
model.setData(model.index(row, 0), QVariant(get_api_name(api)))
model.setData(model.index(row, 1), QVariant(api['protocols']))
model.setData(model.index(row, 2), QVariant(api['provider']))
model.setData(model.index(row, 3), QVariant(api['version']))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("Module"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Protocol"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Version"))
# model.setHeaderData(0, Qt.Horizontal, QVariant("API"))
# model.setHeaderData(1, Qt.Horizontal, QVariant("Protocols"))
# model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
# model.setHeaderData(3, Qt.Horizontal, QVariant("Version"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
if recommend:
self.recommendLabel.show()
self.add_btn.show()
def _show_related_mashups(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
apis = []
objs = []
for mashup in self.related_mashups:
apis.extend(mashup["related_mashups"])
for api in apis:
objs.append(api)
mashups = self.data_source.mashups_by_api(api)
objs.extend(mashups)
row = 0
model = QStandardItemModel(len(objs), 4)
model.setColumnCount(4)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 0), QVariant(get_api_name(obj)))
model.setData(model.index(row, 1), QVariant(obj['protocols']))
model.setData(model.index(row, 2), QVariant(obj['provider']))
else:
model.setData(model.index(row, 3), QVariant(get_mashup_name(obj)))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("API"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Protocols"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Mashup"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.switch_btn_apis.show()
def _show_mashups(self, mashups):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(mashups), 4)
model.setColumnCount(4)
for mashup in mashups:
model.setData(model.index(row, 0), QVariant(get_mashup_name(mashup)))
model.setData(model.index(row, 1), QVariant(mashup['title']))
model.setData(model.index(row, 2), QVariant(mashup['self']))
model.setData(model.index(row, 3), QVariant(mashup['description']))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("Workflow"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Short Description"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Detailed Info"))
# model.setHeaderData(0, Qt.Horizontal, QVariant("Info"))
# model.setHeaderData(1, Qt.Horizontal, QVariant("Title"))
# model.setHeaderData(2, Qt.Horizontal, QVariant("self"))
# model.setHeaderData(3, Qt.Horizontal, QVariant("Description"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.add_btn.show()
def init_cmd_table(self):
model = QStandardItemModel()
model.setColumnCount(3)
model.setHeaderData(0, Qt.Horizontal, "Command")
model.setHeaderData(1, Qt.Horizontal, "Tag")
model.setHeaderData(2, Qt.Horizontal, "Description")
import json
print sys.path[0]
os.chdir(sys.path[0])
f = file('command.txt')
cmds = json.load(f)
f.close()
for cmd in cmds:
l = []
for field in cmd:
if type(field) is types.ListType:
f = '\n'.join(field)
else:
f = field
l.append(QStandardItem(f))
model.appendRow(l)
self.tableView.setModel(model)
self.tableView.resizeRowsToContents()
self.model = model
class OWConfusionMatrix(widget.OWWidget):
name = "Confusion Matrix"
description = "Shows a confusion matrix."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
inputs = [{"name": "Evaluation Results",
"type": Orange.evaluation.testing.Results,
"handler": "set_results"}]
outputs = [{"name": "Selected Data",
"type": Orange.data.Table}]
quantities = ["Number of instances",
"Observed and expected instances",
"Proportion of predicted",
"Proportion of true"]
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.results = None
self.learners = []
self._invalidated = False
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")
combo = gui.comboBox(box, self, "selected_quantity",
items=self.quantities,
callback=self._update)
box = gui.widgetBox(self.controlArea, "Selection")
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",
"Append class predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Append predicted class probabilities",
callback=self._invalidate)
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
cb = gui.checkBox(box, self, "autocommit", "Commit automatically")
gui.setStopper(self, b, cb, "_invalidated", callback=self.commit)
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.addWidget(QLabel("Predicted"), 0, 1, Qt.AlignCenter)
grid.addWidget(VerticalLabel("Correct Class"), 1, 0, Qt.AlignCenter)
self.tablemodel = QStandardItemModel()
self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers,
)
self.tableview.setModel(self.tablemodel)
self.tableview.selectionModel().selectionChanged.connect(
self._invalidate
)
grid.addWidget(self.tableview, 1, 1)
self.mainArea.layout().addLayout(grid)
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 isinstance(data.domain.class_var,
Orange.data.DiscreteVariable):
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
headers = class_values + [unicodedata.lookup("N-ARY SUMMATION")]
# NOTE: The 'fitter_names' is set in 'Test Learners' widget.
if hasattr(results, "fitter_names"):
self.learners = results.fitter_names
else:
self.learners = ["L %i" % (i + 1) for i in range(nmodels)]
self.tablemodel.setVerticalHeaderLabels(headers)
self.tablemodel.setHorizontalHeaderLabels(headers)
self.tablemodel.setRowCount(len(class_values) + 1)
self.tablemodel.setColumnCount(len(class_values) + 1)
self.selected_learner = [0]
self._update()
def clear(self):
self.learners = []
self.results = None
self.data = None
self.tablemodel.clear()
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 and self.data:
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]
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)
else:
data = None
self.send("Selected Data", data)
self._invalidated = False
def _invalidate(self):
if self.autocommit:
self.commit()
else:
self._invalidated = True
def _learner_changed(self):
# The selected learner has changed
self._update()
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:
priors = numpy.outer(rowsum, colsum) / total
value = lambda i, j: \
"{} / {:5.3f}".format(cmatrix[i, j], priors[i, j])
elif self.selected_quantity == 2:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / colsum[i])
if colsum[i] else "N/A")
elif self.selected_quantity == 3:
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)
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)))
class MultipleSelectTreeView(QListView):
"""
Custom QListView implementation that displays checkable items from a
multiple select column type.
"""
def __init__(self, column, parent=None):
"""
Class constructor.
:param column: Multiple select column object.
:type column: MultipleSelectColumn
:param parent: Parent widget for the control.
:type parent: QWidget
"""
QListView.__init__(self, parent)
#Disable editing of lookup values
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.column = column
self._item_model = QStandardItemModel(self)
self._value_list = self.column.value_list
#Stores lookup objects based on primary keys
self._lookup_cache = {}
self._initialize()
self._association = self.column.association
self._first_parent_col = self._association.first_reference_column.name
self._second_parent_col = self._association.second_reference_column.name
#Association model
self._assoc_cls = entity_model(self._association)
def reset_model(self):
"""
Resets the item model.
"""
self._item_model.clear()
self._item_model.setColumnCount(2)
def clear(self):
"""
Clears all items in the model.
"""
self._item_model.clear()
@property
def association(self):
"""
:return: Returns the association object corresponding to the column.
:rtype: AssociationEntity
"""
return self._association
@property
def value_list(self):
"""
:return: Returns the ValueList object corresponding to the configured
column object.
:rtype: ValueList
"""
return self._value_list
@property
def item_model(self):
"""
:return: Returns the model corresponding to the checkable items.
:rtype: QStandardItemModel
"""
return self._item_model
def _add_item(self, id, value):
"""
Adds a row corresponding to id and corresponding value from a lookup
table.
:param id: Primary key of a lookup record.
:type id: int
:param value: Lookup value
:type value: str
"""
value_item = QStandardItem(value)
value_item.setCheckable(True)
id_item = QStandardItem(str(id))
self._item_model.appendRow([value_item, id_item])
def _initialize(self):
#Populate list with lookup items
self.reset_model()
#Add all lookup values in the value list table
vl_cls = entity_model(self._value_list)
if not vl_cls is None:
vl_obj = vl_cls()
res = vl_obj.queryObject().all()
for r in res:
self._lookup_cache[r.id] = r
self._add_item(r.id, r.value)
self.setModel(self._item_model)
def clear_selection(self):
"""
Unchecks all items in the view.
"""
for i in range(self._item_model.rowCount()):
value_item = self._item_model.item(i, 0)
if value_item.checkState() == Qt.Checked:
value_item.setCheckState(Qt.Unchecked)
if value_item.rowCount() > 0:
value_item.removeRow(0)
def selection(self):
"""
:return: Returns a list of selected items.
:rtype: list
"""
selection = []
for i in range(self._item_model.rowCount()):
value_item = self._item_model.item(i, 0)
if value_item.checkState() == Qt.Checked:
id_item = self._item_model.item(i, 1)
id = int(id_item.text())
#Get item from the lookup cache and append to selection
if id in self._lookup_cache:
lookup_rec = self._lookup_cache[id]
selection.append(lookup_rec)
return selection
def set_selection(self, models):
"""
Checks items corresponding to the specified models.
:param models: List containing model values in the view for selection.
:type models: list
"""
for m in models:
search_value = m.value
v_items = self._item_model.findItems(search_value)
#Loop through result and check items
for vi in v_items:
if vi.checkState() == Qt.Unchecked:
vi.setCheckState(Qt.Checked)
class OWKMeans(widget.OWWidget):
name = "k-Means"
description = "k-means clustering algorithm with silhouette-based " \
"quality estimation."
icon = "icons/KMeans.svg"
priority = 2100
inputs = [("Data", Table, "set_data")]
outputs = [("Annotated Data", Table, widget.Default),
("Centroids", Table)]
INIT_KMEANS, INIT_RANDOM = range(2)
INIT_METHODS = "Initialize with KMeans++", "Random initialization"
SILHOUETTE, INTERCLUSTER, DISTANCES = range(3)
SCORING_METHODS = [("Silhouette", lambda km: km.silhouette, False),
("Inter-cluster distance",
lambda km: km.inter_cluster, True),
("Distance to centroids",
lambda km: km.inertia, True)]
OUTPUT_CLASS, OUTPUT_ATTRIBUTE, OUTPUT_META = range(3)
OUTPUT_METHODS = ("Class", "Feature", "Meta")
resizing_enabled = False
k = Setting(8)
k_from = Setting(2)
k_to = Setting(8)
optimize_k = Setting(False)
max_iterations = Setting(300)
n_init = Setting(10)
smart_init = Setting(INIT_KMEANS)
scoring = Setting(SILHOUETTE)
append_cluster_ids = Setting(True)
place_cluster_ids = Setting(OUTPUT_CLASS)
output_name = Setting("Cluster")
auto_run = Setting(False)
def __init__(self):
super().__init__()
self.data = None
self.km = None
self.optimization_runs = []
box = gui.widgetBox(self.controlArea, "Number of Clusters")
layout = QGridLayout()
bg = gui.radioButtonsInBox(
box, self, "optimize_k", [], orientation=layout,
callback=self.update)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed", addToLayout=False),
1, 1)
sb = gui.widgetBox(None, margin=0, orientation="horizontal")
self.fixedSpinBox = gui.spin(
sb, self, "k", minv=2, maxv=30,
controlWidth=60, alignment=Qt.AlignRight, callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(
gui.appendRadioButton(bg, "Optimized", addToLayout=False), 2, 1)
ftobox = gui.widgetBox(None, orientation="horizontal")
ftobox.layout().setMargin(0)
layout.addWidget(ftobox)
gui.spin(
ftobox, self, "k_from", minv=2, maxv=29,
controlWidth=60, alignment=Qt.AlignRight,
callback=self.update_from)
gui.widgetLabel(ftobox, " To: ")
self.fixedSpinBox = gui.spin(
ftobox, self, "k_to", minv=3, maxv=30,
controlWidth=60, alignment=Qt.AlignRight,
callback=self.update_to)
gui.rubber(ftobox)
layout.addWidget(gui.widgetLabel(None, "Scoring: "),
5, 1, Qt.AlignRight)
layout.addWidget(
gui.comboBox(
None, self, "scoring", label="Scoring",
items=list(zip(*self.SCORING_METHODS))[0],
callback=self.update), 5, 2)
box = gui.widgetBox(self.controlArea, "Initialization")
gui.comboBox(
box, self, "smart_init", items=self.INIT_METHODS,
callback=self.update)
layout = QGridLayout()
box2 = gui.widgetBox(box, orientation=layout)
box2.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "),
0, 0, Qt.AlignLeft)
sb = gui.widgetBox(None, margin=0, orientation="horizontal")
layout.addWidget(sb, 0, 1)
gui.lineEdit(
sb, self, "n_init", controlWidth=60,
valueType=int, validator=QIntValidator(),
callback=self.update)
layout.addWidget(gui.widgetLabel(None, "Maximal iterations: "),
1, 0, Qt.AlignLeft)
sb = gui.widgetBox(None, margin=0, orientation="horizontal")
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb, self, "max_iterations",
controlWidth=60, valueType=int,
validator=QIntValidator(),
callback=self.update)
box = gui.widgetBox(self.controlArea, "Output")
gui.comboBox(box, self, "place_cluster_ids",
label="Append cluster id as ", orientation="horizontal",
callback=self.send_data, items=self.OUTPUT_METHODS)
gui.lineEdit(box, self, "output_name",
label="Name ", orientation="horizontal",
callback=self.send_data)
gui.auto_commit(self.controlArea, self, "auto_run", "Run",
checkbox_label="Run after any change ",
orientation="horizontal")
gui.rubber(self.controlArea)
self.table_model = QStandardItemModel(self)
self.table_model.setHorizontalHeaderLabels(["k", "Score"])
self.table_model.setColumnCount(2)
self.table_box = gui.widgetBox(
self.mainArea, "Optimization Report", addSpace=0)
table = self.table_view = QTableView(self.table_box)
table.setHorizontalScrollMode(QTableView.ScrollPerPixel)
table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.verticalHeader().hide()
table.setItemDelegateForColumn(1, gui.TableBarItem(self))
table.setModel(self.table_model)
table.selectionModel().selectionChanged.connect(
self.table_item_selected)
table.setColumnWidth(0, 40)
table.setColumnWidth(1, 120)
table.horizontalHeader().setStretchLastSection(True)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.mainArea.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Preferred)
self.table_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
self.table_view.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.MinimumExpanding)
self.table_box.layout().addWidget(self.table_view)
self.hide_show_opt_results()
def adjustSize(self):
self.ensurePolished()
s = self.sizeHint()
self.resize(s)
def hide_show_opt_results(self):
[self.mainArea.hide, self.mainArea.show][self.optimize_k]()
QTimer.singleShot(100, self.adjustSize)
def sizeHint(self):
s = self.controlArea.sizeHint()
if self.optimize_k and not self.mainArea.isHidden():
s.setWidth(s.width() + self.mainArea.sizeHint().width() +
4 * self.childrenRect().x())
return s
def update_k(self):
self.optimize_k = False
self.update()
def update_from(self):
self.k_to = max(self.k_from + 1, self.k_to)
self.optimize_k = True
self.update()
def update_to(self):
self.k_from = min(self.k_from, self.k_to - 1)
self.optimize_k = True
self.update()
def set_optimization(self):
self.updateOptimizationGui()
self.update()
def check_data_size(self, n):
if n > len(self.data):
self.error("Not enough unique data instances ({}) for given "
"number of clusters ({}).".format(len(self.data), n))
return False
return True
def run_optimization(self):
# Disabling is needed since this function is not reentrant
# Fast clicking on, say, "To: " causes multiple calls
try:
self.controlArea.setDisabled(True)
self.optimization_runs = []
if self.check_data_size(self.k_to):
self.optimization_runs = []
kmeans = KMeans(
init=['random', 'k-means++'][self.smart_init],
n_init=self.n_init,
max_iter=self.max_iterations)
with self.progressBar(self.k_to - self.k_from + 1) as progress:
for k in range(self.k_from, self.k_to + 1):
progress.advance()
kmeans.params["n_clusters"] = k
self.optimization_runs.append((k, kmeans(self.data)))
finally:
self.controlArea.setDisabled(False)
self.show_results()
self.send_data()
def cluster(self):
if not self.check_data_size(self.k):
return
self.km = KMeans(
n_clusters=self.k,
init=['random', 'k-means++'][self.smart_init],
n_init=self.n_init,
max_iter=self.max_iterations)(self.data)
self.send_data()
def run(self):
self.error()
if not self.data:
return
if self.optimize_k:
self.run_optimization()
else:
self.cluster()
commit = run
def show_results(self):
minimize = self.SCORING_METHODS[self.scoring][2]
k_scores = [(k, self.SCORING_METHODS[self.scoring][1](run)) for
k, run in self.optimization_runs]
scores = list(zip(*k_scores))[1]
if minimize:
best_score, worst_score = min(scores), max(scores)
else:
best_score, worst_score = max(scores), min(scores)
best_run = scores.index(best_score)
score_span = (best_score - worst_score) or 1
max_score = max(scores)
nplaces = min(5, int(abs(math.log(max(max_score, 1e-10)))) + 2)
fmt = "{{:.{}}}".format(nplaces)
model = self.table_model
model.setRowCount(len(k_scores))
for i, (k, score) in enumerate(k_scores):
item = model.item(i, 0)
if item is None:
item = QStandardItem()
item.setData(k, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
model.setItem(i, 0, item)
item = model.item(i, 1)
if item is None:
item = QStandardItem()
item.setData(fmt.format(score), Qt.DisplayRole)
bar_ratio = 0.95 * (score - worst_score) / score_span
item.setData(bar_ratio, gui.TableBarItem.BarRole)
model.setItem(i, 1, item)
self.table_view.resizeRowsToContents()
self.table_view.selectRow(best_run)
self.table_view.show()
if minimize:
self.table_box.setTitle("Scoring (smaller is better)")
else:
self.table_box.setTitle("Scoring (bigger is better)")
QTimer.singleShot(0, self.adjustSize)
def update(self):
self.hide_show_opt_results()
self.run()
def selected_row(self):
indices = self.table_view.selectedIndexes()
rows = {ind.row() for ind in indices}
if len(rows) == 1:
return rows.pop()
def table_item_selected(self):
row = self.selected_row()
if row is not None:
self.send_data(row)
def send_data(self, row=None):
if self.optimize_k:
if row is None:
row = self.selected_row()
km = self.optimization_runs[row][1]
else:
km = self.km
if not self.data or not km:
self.send("Annotated Data", None)
self.send("Centroids", None)
return
clust_var = DiscreteVariable(
self.output_name, values=["C%d" % (x + 1) for x in range(km.k)])
clust_ids = km(self.data)
domain = self.data.domain
attributes, classes = domain.attributes, domain.class_vars
meta_attrs = domain.metas
if self.place_cluster_ids == self.OUTPUT_CLASS:
if classes:
meta_attrs += classes
classes = [clust_var]
elif self.place_cluster_ids == self.OUTPUT_ATTRIBUTE:
attributes += (clust_var, )
else:
meta_attrs += (clust_var, )
domain = Domain(attributes, classes, meta_attrs)
new_table = Table.from_table(domain, self.data)
new_table.get_column_view(clust_var)[0][:] = clust_ids.X.ravel()
centroids = Table(Domain(km.pre_domain.attributes), km.centroids)
self.send("Annotated Data", new_table)
self.send("Centroids", centroids)
@check_sql_input
def set_data(self, data):
self.data = data
if data is None:
self.table_model.setRowCount(0)
else:
self.data = data
self.run()
def send_report(self):
self.report_items((
("Number of clusters",
self.optimization_runs[self.selected_row()][1].k
if self.optimize_k else self.k),
("Optimization",
self.optimize_k != 0 and
"{}, {} re-runs limited to {} steps".format(
self.INIT_METHODS[self.smart_init].lower(),
self.n_init, self.max_iterations)),
("Cluster ID in output",
self.append_cluster_ids and
"'{}' (as {})".format(
self.output_name,
self.OUTPUT_METHODS[self.place_cluster_ids].lower()))
))
if self.data:
self.report_data("Data", self.data)
if self.optimize_k:
self.report_table(
"Scoring by {}".format(self.SCORING_METHODS[self.scoring][0]
),
self.table_view)
class OWConfusionMatrix(widget.OWWidget):
"""Confusion matrix widget"""
name = "Confusion Matrix"
description = "Display a confusion matrix constructed from " \
"the results of classifier evaluations."
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"
]
settingsHandler = settings.ClassValuesContextHandler()
selected_learner = settings.Setting([0], schema_only=True)
selection = settings.ContextSetting(set())
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
UserAdviceMessages = [
widget.Message(
"Clicking on cells or in headers outputs the corresponding "
"data instances", "click_cell")
]
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(box,
self,
"selected_learner",
"learners",
callback=self._learner_changed)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box,
self,
"selected_quantity",
items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box,
self,
"Select Correct",
callback=self.select_correct,
autoDefault=False)
gui.button(box,
self,
"Select Misclassified",
callback=self.select_wrong,
autoDefault=False)
gui.button(box,
self,
"Clear Selection",
callback=self.select_none,
autoDefault=False)
self.outputbox = box = gui.vBox(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 Selected",
"Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
"""Initial size"""
return QSize(750, 490)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def _init_table(self, nclasses):
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, nclasses)
self.tableview.setSpan(2, 0, nclasses, 1)
font = self.tablemodel.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setFont(bold_font)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
if p < len(self.headers) - 1:
item.setData("br"[j == 1], BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(nclasses + 3)
self.tablemodel.setColumnCount(nclasses + 3)
def set_results(self, results):
"""Set the input results."""
prev_sel_learner = self.selected_learner.copy()
self.clear()
self.warning()
self.closeContext()
data = None
if results is not None and results.data is not None:
data = results.data
if data is not None and not data.domain.has_discrete_class:
self.warning("Confusion Matrix cannot show 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 None:
self.report_button.setDisabled(True)
else:
self.report_button.setDisabled(False)
nmodels = results.predicted.shape[0]
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 = [
"Learner #{}".format(i + 1) for i in range(nmodels)
]
self._init_table(len(class_values))
self.openContext(data.domain.class_var)
if not prev_sel_learner or prev_sel_learner[0] >= len(
self.learners):
self.selected_learner[:] = [0]
else:
self.selected_learner[:] = prev_sel_learner
self._update()
self._set_selection()
self.unconditional_commit()
def clear(self):
"""Reset the widget, clear controls"""
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
self.learners = []
def select_correct(self):
"""Select the diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_wrong(self):
"""Select the off-diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, 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):
"""Reset selection"""
self.tableview.selectionModel().clear()
def cell_clicked(self, model_index):
"""Handle cell click event"""
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def commit(self):
"""Output data instances corresponding to selected cells"""
if self.results is not None and self.data is not None \
and self.selected_learner:
indices = self.tableview.selectedIndexes()
indices = {(ind.row() - 2, ind.column() - 2) for ind in indices}
actual = self.results.actual
learner_name = self.learners[self.selected_learner[0]]
predicted = self.results.predicted[self.selected_learner[0]]
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[self.selected_learner[0],
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):
indices = self.tableview.selectedIndexes()
self.selection = {(ind.row() - 2, ind.column() - 2) for ind in indices}
self.commit()
def _set_selection(self):
selection = QItemSelection()
index = self.tableview.model().index
for row, col in self.selection:
sel = index(row + 2, col + 2)
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def _learner_changed(self):
self._update()
self._set_selection()
self.commit()
def _update(self):
def _isinvalid(x):
return isnan(x) or isinf(x)
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
cmatrix = confusion_matrix(self.results, self.selected_learner[0])
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
n = len(cmatrix)
diag = numpy.diag_indices(n)
colors = cmatrix.astype(numpy.double)
colors[diag] = 0
if self.selected_quantity == 0:
normalized = cmatrix.astype(numpy.int)
formatstr = "{}"
div = numpy.array([colors.max()])
else:
if self.selected_quantity == 1:
normalized = 100 * cmatrix / colsum
div = colors.max(axis=0)
else:
normalized = 100 * cmatrix / rowsum[:, numpy.newaxis]
div = colors.max(axis=1)[:, numpy.newaxis]
formatstr = "{:2.1f} %"
div[div == 0] = 1
colors /= div
colors[diag] = normalized[diag] / normalized[diag].max()
for i in range(n):
for j in range(n):
val = normalized[i, j]
col_val = colors[i, j]
item = self._item(i + 2, j + 2)
item.setData(
"NA" if _isinvalid(val) else formatstr.format(val),
Qt.DisplayRole)
bkcolor = QColor.fromHsl(
[0, 240][i == j], 160,
255 if _isinvalid(col_val) else int(255 -
30 * col_val))
item.setData(QBrush(bkcolor), Qt.BackgroundRole)
item.setData("trbl", BorderRole)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
bold_font = self.tablemodel.invisibleRootItem().font()
bold_font.setBold(True)
def _sum_item(value, border=""):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
item.setData(border, BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
return item
for i in range(n):
self._set_item(n + 2, i + 2, _sum_item(int(colsum[i]), "t"))
self._set_item(i + 2, n + 2, _sum_item(int(rowsum[i]), "l"))
self._set_item(n + 2, n + 2, _sum_item(int(rowsum.sum())))
def send_report(self):
"""Send report"""
if self.results is not None and self.selected_learner:
self.report_table(
"Confusion matrix for {} (showing {})".format(
self.learners[self.selected_learner[0]],
self.quantities[self.selected_quantity].lower()),
self.tableview)
class OWConfusionMatrix(widget.OWWidget):
"""Confusion matrix widget"""
name = "Confusion Matrix"
description = "Display a confusion matrix constructed from " \
"the results of classifier evaluations."
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"]
settingsHandler = settings.ClassValuesContextHandler()
selected_learner = settings.Setting([0], schema_only=True)
selection = settings.ContextSetting(set())
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
UserAdviceMessages = [
widget.Message(
"Clicking on cells or in headers outputs the corresponding "
"data instances",
"click_cell")]
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.vBox(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 Selected", "Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
"""Initial size"""
return QSize(750, 490)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def _init_table(self, nclasses):
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, nclasses)
self.tableview.setSpan(2, 0, nclasses, 1)
font = self.tablemodel.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setFont(bold_font)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
if p < len(self.headers) - 1:
item.setData("br"[j == 1], BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(nclasses + 3)
self.tablemodel.setColumnCount(nclasses + 3)
def set_results(self, results):
"""Set the input results."""
prev_sel_learner = self.selected_learner.copy()
self.clear()
self.warning()
self.closeContext()
data = None
if results is not None and results.data is not None:
data = results.data
if data is not None and not data.domain.has_discrete_class:
self.warning("Confusion Matrix cannot show 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 None:
self.report_button.setDisabled(True)
else:
self.report_button.setDisabled(False)
nmodels = results.predicted.shape[0]
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 = ["Learner #{}".format(i + 1)
for i in range(nmodels)]
self._init_table(len(class_values))
self.openContext(data.domain.class_var)
if not prev_sel_learner or prev_sel_learner[0] >= len(self.learners):
self.selected_learner[:] = [0]
else:
self.selected_learner[:] = prev_sel_learner
self._update()
self._set_selection()
self.unconditional_commit()
def clear(self):
"""Reset the widget, clear controls"""
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
self.learners = []
def select_correct(self):
"""Select the diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_wrong(self):
"""Select the off-diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, 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):
"""Reset selection"""
self.tableview.selectionModel().clear()
def cell_clicked(self, model_index):
"""Handle cell click event"""
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def commit(self):
"""Output data instances corresponding to selected cells"""
if self.results is not None and self.data is not None \
and self.selected_learner:
indices = self.tableview.selectedIndexes()
indices = {(ind.row() - 2, ind.column() - 2) for ind in indices}
actual = self.results.actual
learner_name = self.learners[self.selected_learner[0]]
predicted = self.results.predicted[self.selected_learner[0]]
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[self.selected_learner[0],
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):
indices = self.tableview.selectedIndexes()
self.selection = {(ind.row() - 2, ind.column() - 2) for ind in indices}
self.commit()
def _set_selection(self):
selection = QItemSelection()
index = self.tableview.model().index
for row, col in self.selection:
sel = index(row + 2, col + 2)
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def _learner_changed(self):
self._update()
self._set_selection()
self.commit()
def _update(self):
def _isinvalid(x):
return isnan(x) or isinf(x)
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
cmatrix = confusion_matrix(self.results, self.selected_learner[0])
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
n = len(cmatrix)
diag = numpy.diag_indices(n)
colors = cmatrix.astype(numpy.double)
colors[diag] = 0
if self.selected_quantity == 0:
normalized = cmatrix.astype(numpy.int)
formatstr = "{}"
div = numpy.array([colors.max()])
else:
if self.selected_quantity == 1:
normalized = 100 * cmatrix / colsum
div = colors.max(axis=0)
else:
normalized = 100 * cmatrix / rowsum[:, numpy.newaxis]
div = colors.max(axis=1)[:, numpy.newaxis]
formatstr = "{:2.1f} %"
div[div == 0] = 1
colors /= div
colors[diag] = normalized[diag] / normalized[diag].max()
for i in range(n):
for j in range(n):
val = normalized[i, j]
col_val = colors[i, j]
item = self._item(i + 2, j + 2)
item.setData(
"NA" if _isinvalid(val) else formatstr.format(val),
Qt.DisplayRole)
bkcolor = QColor.fromHsl(
[0, 240][i == j], 160,
255 if _isinvalid(col_val) else int(255 - 30 * col_val))
item.setData(QBrush(bkcolor), Qt.BackgroundRole)
item.setData("trbl", BorderRole)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
bold_font = self.tablemodel.invisibleRootItem().font()
bold_font.setBold(True)
def _sum_item(value, border=""):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
item.setData(border, BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
return item
for i in range(n):
self._set_item(n + 2, i + 2, _sum_item(int(colsum[i]), "t"))
self._set_item(i + 2, n + 2, _sum_item(int(rowsum[i]), "l"))
self._set_item(n + 2, n + 2, _sum_item(int(rowsum.sum())))
def send_report(self):
"""Send report"""
if self.results is not None and self.selected_learner:
self.report_table(
"Confusion matrix for {} (showing {})".
format(self.learners[self.selected_learner[0]],
self.quantities[self.selected_quantity].lower()),
self.tableview)
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)
UserAdviceMessages = [
widget.Message(
"Clicking on cells or in headers outputs the corresponding "
"data instances",
"click_cell")]
def __init__(self):
super().__init__()
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()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
return QSize(750, 490)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
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 = ["Learner #%i" % (i + 1)
for i in range(nmodels)]
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(
0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, len(class_values))
self.tableview.setSpan(2, 0, len(class_values), 1)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setData(QBrush(QColor(208, 208, 208)),
Qt.BackgroundColorRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(len(class_values) + 3)
self.tablemodel.setColumnCount(len(class_values) + 3)
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(2, 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(2, 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 cell_clicked(self, model_index):
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
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() - 2, ind.column() - 2) 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
indices = self.tableview.selectedIndexes()
self._update()
selection = QItemSelection()
for sel in indices:
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
self.commit()
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
for i, row in enumerate(cmatrix):
for j, _ in enumerate(row):
item = self._item(i + 2, j + 2)
item.setData(value(i, j), Qt.DisplayRole)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
model = self.tablemodel
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 + 2, i + 2, sum_item(int(colsum[i])))
model.setItem(i + 2, N + 2, sum_item(int(rowsum[i])))
model.setItem(N + 2, N + 2, sum_item(int(total)))
def main(icon_spec):
app = QApplication(sys.argv)
main_window = QMainWindow()
def sigint_handler(*args):
main_window.close()
signal.signal(signal.SIGINT, sigint_handler)
# the timer enables triggering the sigint_handler
signal_timer = QTimer()
signal_timer.start(100)
signal_timer.timeout.connect(lambda: None)
tool_bar = QToolBar()
main_window.addToolBar(Qt.TopToolBarArea, tool_bar)
table_view = QTableView()
table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
table_view.setSelectionMode(QAbstractItemView.SingleSelection)
table_view.setSortingEnabled(True)
main_window.setCentralWidget(table_view)
proxy_model = QSortFilterProxyModel()
proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
proxy_model.setFilterKeyColumn(1)
table_view.setModel(proxy_model)
proxy_model.layoutChanged.connect(table_view.resizeRowsToContents)
item_model = QStandardItemModel()
proxy_model.setSourceModel(item_model)
# get all icons and their available sizes
QIcon.setThemeName("gnome")
icons = []
all_sizes = set([])
for context, icon_names in icon_spec:
for icon_name in icon_names:
icon = QIcon.fromTheme(icon_name)
sizes = []
for size in icon.availableSizes():
size = (size.width(), size.height())
sizes.append(size)
all_sizes.add(size)
sizes.sort()
icons.append({
'context': context,
'icon_name': icon_name,
'icon': icon,
'sizes': sizes,
})
all_sizes = list(all_sizes)
all_sizes.sort()
# input field for filter
def filter_changed(value):
proxy_model.setFilterRegExp(value)
table_view.resizeRowsToContents()
filter_line_edit = QLineEdit()
filter_line_edit.setMaximumWidth(200)
filter_line_edit.setPlaceholderText('Filter name')
filter_line_edit.setToolTip('Filter name optionally using regular expressions (' + QKeySequence(QKeySequence.Find).toString() + ')')
filter_line_edit.textChanged.connect(filter_changed)
tool_bar.addWidget(filter_line_edit)
# actions to toggle visibility of available sizes/columns
def action_toggled(index):
column = 2 + index
table_view.setColumnHidden(column, not table_view.isColumnHidden(column))
table_view.resizeColumnsToContents()
table_view.resizeRowsToContents()
signal_mapper = QSignalMapper()
for i, size in enumerate(all_sizes):
action = QAction('%dx%d' % size, tool_bar)
action.setCheckable(True)
action.setChecked(True)
tool_bar.addAction(action)
action.toggled.connect(signal_mapper.map)
signal_mapper.setMapping(action, i)
# set tool tip and handle key sequence
tool_tip = 'Toggle visibility of column'
if i < 10:
digit = ('%d' % (i + 1))[-1]
tool_tip += ' (%s)' % QKeySequence('Ctrl+%s' % digit).toString()
action.setToolTip(tool_tip)
signal_mapper.mapped.connect(action_toggled)
# label columns
header_labels = ['context', 'name']
for width, height in all_sizes:
header_labels.append('%dx%d' % (width, height))
item_model.setColumnCount(len(header_labels))
item_model.setHorizontalHeaderLabels(header_labels)
# fill rows
item_model.setRowCount(len(icons))
for row, icon_data in enumerate(icons):
# context
item = QStandardItem(icon_data['context'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 0, item)
# icon name
item = QStandardItem(icon_data['icon_name'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 1, item)
for index_in_all_sizes, size in enumerate(all_sizes):
column = 2 + index_in_all_sizes
if size in icon_data['sizes']:
# icon as pixmap to keep specific size
item = QStandardItem('')
pixmap = icon_data['icon'].pixmap(size[0], size[1])
item.setData(pixmap, Qt.DecorationRole)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
else:
# single space to be sortable against icons
item = QStandardItem(' ')
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
table_view.resizeColumnsToContents()
# manually set row heights because resizeRowsToContents is not working properly
for row, icon_data in enumerate(icons):
if len(icon_data['sizes']) > 0:
max_size = icon_data['sizes'][-1]
table_view.setRowHeight(row, max_size[1])
# enable focus find (ctrl+f) and toggle columns (ctrl+NUM)
def main_window_keyPressEvent(self, event, old_keyPressEvent=QMainWindow.keyPressEvent):
if event.matches(QKeySequence.Find):
filter_line_edit.setFocus()
return
if event.modifiers() == Qt.ControlModifier and event.key() >= Qt.Key_0 and event.key() <= Qt.Key_9:
index = event.key() - Qt.Key_1
if event.key() == Qt.Key_0:
index += 10
action = signal_mapper.mapping(index)
if action:
action.toggle()
return
old_keyPressEvent(self, event)
main_window.keyPressEvent = new.instancemethod(main_window_keyPressEvent, table_view, None)
# enable copy (ctrl+c) name of icon to clipboard
def table_view_keyPressEvent(self, event, old_keyPressEvent=QTableView.keyPressEvent):
if event.matches(QKeySequence.Copy):
selection_model = self.selectionModel()
if selection_model.hasSelection():
index = selection_model.selectedRows()[0]
source_index = self.model().mapToSource(index)
item = self.model().sourceModel().item(source_index.row(), 1)
icon_name = item.data(Qt.EditRole)
app.clipboard().setText(icon_name.toString())
return
old_keyPressEvent(self, event)
table_view.keyPressEvent = new.instancemethod(table_view_keyPressEvent, table_view, None)
print 'Icon Theme: ', QIcon.themeName()
print 'Theme Search Paths:'
for item in QIcon.themeSearchPaths():
print item
main_window.showMaximized()
return app.exec_()
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):
super().__init__()
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()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
return QSize(750, 490)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
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 = [
"Learner #%i" % (i + 1) for i in range(nmodels)
]
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(0,
gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, len(class_values))
self.tableview.setSpan(2, 0, len(class_values), 1)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setData(QBrush(QColor(208, 208, 208)),
Qt.BackgroundColorRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(len(class_values) + 3)
self.tablemodel.setColumnCount(len(class_values) + 3)
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(2, 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(2, 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 cell_clicked(self, model_index):
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
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() - 2, ind.column() - 2) 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
indices = self.tableview.selectedIndexes()
self._update()
selection = QItemSelection()
for sel in indices:
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
self.commit()
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
for i, row in enumerate(cmatrix):
for j, _ in enumerate(row):
item = self._item(i + 2, j + 2)
item.setData(value(i, j), Qt.DisplayRole)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
model = self.tablemodel
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 + 2, i + 2, sum_item(int(colsum[i])))
model.setItem(i + 2, N + 2, sum_item(int(rowsum[i])))
model.setItem(N + 2, N + 2, sum_item(int(total)))
class TemplateDocumentSelector(QDialog, Ui_frmDocumentSelector):
"""
Dialog for selecting a document template from the saved list.
"""
def __init__(self, parent=None, selectMode=True):
QDialog.__init__(self, parent)
self.setupUi(self)
self.notifBar = NotificationBar(self.vlNotification)
if selectMode:
self.buttonBox.setVisible(True)
self.manageButtonBox.setVisible(False)
currHeight = self.size().height()
self.resize(200, currHeight)
else:
self.buttonBox.setVisible(False)
self.manageButtonBox.setVisible(True)
self.setWindowTitle(
QApplication.translate("TemplateDocumentSelector",
"Template Manager"))
#Configure manage buttons
btnEdit = self.manageButtonBox.button(QDialogButtonBox.Ok)
btnEdit.setText(
QApplication.translate("TemplateDocumentSelector", "Edit..."))
btnEdit.setIcon(QIcon(":/plugins/stdm/images/icons/edit.png"))
btnDelete = self.manageButtonBox.button(QDialogButtonBox.Save)
btnDelete.setText(
QApplication.translate("TemplateDocumentSelector", "Delete"))
btnDelete.setIcon(QIcon(":/plugins/stdm/images/icons/delete.png"))
#Connect signals
self.buttonBox.accepted.connect(self.onAccept)
btnEdit.clicked.connect(self.onEditTemplate)
btnDelete.clicked.connect(self.onDeleteTemplate)
#Get saved document templates then add to the model
templates = documentTemplates()
self._docItemModel = QStandardItemModel(parent)
self._docItemModel.setColumnCount(2)
for name, path in templates.iteritems():
docNameItem = self._createDocNameItem(name)
filePathItem = QStandardItem(path)
self._docItemModel.appendRow([docNameItem, filePathItem])
self.lstDocs.setModel(self._docItemModel)
def _createDocNameItem(self, docName):
"""
Create a template document standard item.
"""
#Set icon
icon = QIcon()
icon.addPixmap(QPixmap(":/plugins/stdm/images/icons/document.png"),
QIcon.Normal, QIcon.Off)
dnItem = QStandardItem(icon, docName)
return dnItem
def onEditTemplate(self):
"""
Slot raised to edit document template.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document template to edit"))
return
templateName, filePath = self.documentMapping()
docName,ok = QInputDialog.getText(self, \
QApplication.translate("TemplateDocumentSelector","Edit Template"), \
QApplication.translate("TemplateDocumentSelector","Please enter the new template name below"), \
text = templateName)
if ok and docName == "":
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Template name cannot be empty"))
return
elif docName == templateName:
return
elif ok and docName != "":
result, newTemplatePath = self._editTemplate(filePath, docName)
if result:
#Update view
mIndices = self._selectedMappings()
docNameItem = self._docItemModel.itemFromIndex(mIndices[0])
filePathItem = self._docItemModel.itemFromIndex(mIndices[1])
docNameItem.setText(docName)
filePathItem.setText(newTemplatePath)
self.notifBar.insertInfoNotification(QApplication.translate("TemplateDocumentSelector", \
"'{0}' template has been successfully updated".format(docName)))
else:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Error: '{0}' template could not be updated".format(templateName)))
def onDeleteTemplate(self):
"""
Slot raised to delete document template.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document template to delete"))
return
templateName, filePath = self.documentMapping()
result = QMessageBox.warning(self, QApplication.translate("TemplateDocumentSelector", \
"Confirm delete"),
QApplication.translate("TemplateDocumentSelector", \
"Are you sure you want to delete '{0}' template?" \
"This action cannot be undone.\nClick Yes to proceed " \
"or No to cancel.".format(templateName)),
QMessageBox.Yes|QMessageBox.No)
if result == QMessageBox.No:
return
status = self._deleteDocument(filePath)
if status:
#Remove item from list using model index row number
selectedDocNameIndices = self.lstDocs.selectionModel(
).selectedRows(0)
row = selectedDocNameIndices[0].row()
self._docItemModel.removeRow(row)
self.notifBar.insertInfoNotification(QApplication.translate("TemplateDocumentSelector", \
"'{0}' template has been successfully removed".format(templateName)))
else:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Error: '{0}' template could not be removed".format(templateName)))
def onAccept(self):
"""
Slot raised to close the dialog only when a selection has been made by the user.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document"))
return
self.accept()
def _selectedMappings(self):
"""
Returns the model indices for the selected row.
"""
selectedDocNameIndices = self.lstDocs.selectionModel().selectedRows(0)
selectedFilePathIndices = self.lstDocs.selectionModel().selectedRows(1)
if len(selectedDocNameIndices) == 0:
return None
docNameIndex = selectedDocNameIndices[0]
filePathIndex = selectedFilePathIndices[0]
return (docNameIndex, filePathIndex)
def documentMapping(self):
"""
Returns a tuple containing the selected document name and the corresponding file name.
"""
mIndices = self._selectedMappings()
if mIndices == None:
return None
docNameItem = self._docItemModel.itemFromIndex(mIndices[0])
filePathItem = self._docItemModel.itemFromIndex(mIndices[1])
return (docNameItem.text(), filePathItem.text())
def _editTemplate(self, templatePath, newName):
"""
Updates the template document to use the new name.
"""
templateFile = QFile(templatePath)
if not templateFile.open(QIODevice.ReadOnly):
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Open Operation Error"), \
"{0}\n{1}".format(QApplication.translate("TemplateDocumentSelector","Cannot read template file."), \
templateFile.errorString()
))
return (False, "")
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
composerElement = templateDoc.documentElement()
titleAttr = composerElement.attributeNode("title")
if not titleAttr.isNull():
titleAttr.setValue(newName)
#Try remove file
status = templateFile.remove()
if not status:
return (False, "")
#Create new file
newTemplatePath = self._composerTemplatesPath(
) + "/" + newName + ".sdt"
newTemplateFile = QFile(newTemplatePath)
if not newTemplateFile.open(QIODevice.WriteOnly):
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Save Operation Error"), \
"{0}\n{1}".format(QApplication.translate("TemplateDocumentSelector","Could not save template file."), \
newTemplateFile.errorString()
))
return (False, "")
if newTemplateFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Save Error"), \
QApplication.translate("TemplateDocumentSelector","Could not save template file."))
return (False, "")
newTemplateFile.close()
return (True, newTemplatePath)
def _deleteDocument(self, templatePath):
"""
Delete the document template from the file system.
"""
docFile = QFile(templatePath)
return docFile.remove()
def _composerTemplatesPath(self):
"""
Reads the path of composer templates in the registry.
"""
regConfig = RegistryConfig()
keyName = "ComposerTemplates"
valueCollection = regConfig.read([keyName])
if len(valueCollection) == 0:
return None
else:
return valueCollection[keyName]
class TemplateDocumentSelector(QDialog,Ui_frmDocumentSelector):
"""
Dialog for selecting a document template from the saved list.
"""
def __init__(self, parent=None,selectMode=True, filter_data_source=''):
QDialog.__init__(self,parent)
self.setupUi(self)
self.notifBar = NotificationBar(self.vlNotification)
self._mode = selectMode
#Filter templates by the specified table name
self._filter_data_source = filter_data_source
#Document templates in current profile
self._profile_templates = []
self._current_profile = current_profile()
#Load current profile templates
self._load_current_profile_templates()
if selectMode:
self.buttonBox.setVisible(True)
self.manageButtonBox.setVisible(False)
currHeight = self.size().height()
self.resize(200,currHeight)
else:
self.buttonBox.setVisible(False)
self.manageButtonBox.setVisible(True)
self.setWindowTitle(
QApplication.translate(
"TemplateDocumentSelector",
"Template Manager"
)
)
#Configure manage buttons
btnEdit = self.manageButtonBox.button(QDialogButtonBox.Ok)
btnEdit.setText(QApplication.translate("TemplateDocumentSelector","Edit..."))
btnEdit.setIcon(QIcon(":/plugins/stdm/images/icons/edit.png"))
btnDelete = self.manageButtonBox.button(QDialogButtonBox.Save)
btnDelete.setText(QApplication.translate("TemplateDocumentSelector","Delete"))
btnDelete.setIcon(QIcon(":/plugins/stdm/images/icons/delete.png"))
#Connect signals
self.buttonBox.accepted.connect(self.onAccept)
btnEdit.clicked.connect(self.onEditTemplate)
btnDelete.clicked.connect(self.onDeleteTemplate)
#Get saved document templates then add to the model
templates = documentTemplates()
self._docItemModel = QStandardItemModel(parent)
self._docItemModel.setColumnCount(2)
#Append current profile templates to the model.
for dt in self._profile_templates:
if self._template_contains_filter_table(dt):
doc_name_item = self._createDocNameItem(dt.name)
file_path_item = QStandardItem(dt.path)
self._docItemModel.appendRow([doc_name_item,file_path_item])
self.lstDocs.setModel(self._docItemModel)
def _load_current_profile_templates(self):
# Loads only those templates that refer to tables in the current
# profile.
if self._current_profile is None:
return
#Get saved document templates then add to the model
templates = documentTemplates()
profile_tables = self._current_profile.table_names()
#Get templates for the current profile
for name, path in templates.iteritems():
doc_temp = _DocumentTemplate.build_from_path(name, path)
if doc_temp.data_source is None:
continue
#Assert data source is in the current profile
if doc_temp.data_source.referenced_table_name in profile_tables:
self._add_doc_temp(doc_temp)
#self._profile_templates.append(doc_temp)
if doc_temp.data_source._dataSourceName in user_non_profile_views():
self._add_doc_temp(doc_temp)
#self._profile_templates.append(doc_temp)
def _add_doc_temp(self, doc_temp):
found = False
for template in self._profile_templates:
if template.name == doc_temp.name:
found = True
break
if not found:
self._profile_templates.append(doc_temp)
def _template_contains_filter_table(self, document_template):
#Returns true if the template refers to the filter data source
#If no filter data source defined then always return True
if document_template.data_source._dataSourceName in user_non_profile_views():
return True
if not self._filter_data_source:
return True
referenced_table = document_template.referenced_table_name
if referenced_table == self._filter_data_source:
return True
return False
@property
def mode(self):
return self._mode
@property
def filter_data_source(self):
return self._filter_data_source
def _createDocNameItem(self,docName):
"""
Create a template document standard item.
"""
#Set icon
icon = QIcon()
icon.addPixmap(
QPixmap(
":/plugins/stdm/images/icons/document.png"
),
QIcon.Normal,
QIcon.Off
)
dnItem = QStandardItem(icon,docName)
return dnItem
def onEditTemplate(self):
"""
Slot raised to edit document template.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document template to edit"))
return
templateName,filePath = self.documentMapping()
docName,ok = QInputDialog.getText(self, \
QApplication.translate("TemplateDocumentSelector","Edit Template"), \
QApplication.translate("TemplateDocumentSelector","Please enter the new template name below"), \
text = templateName)
if ok and docName == "":
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Template name cannot be empty"))
return
elif docName == templateName:
return
elif ok and docName != "":
result,newTemplatePath = self._editTemplate(filePath, docName)
if result:
#Update view
mIndices = self._selectedMappings()
docNameItem = self._docItemModel.itemFromIndex(mIndices[0])
filePathItem = self._docItemModel.itemFromIndex(mIndices[1])
docNameItem.setText(docName)
filePathItem.setText(newTemplatePath)
self.notifBar.insertSuccessNotification(QApplication.translate("TemplateDocumentSelector", \
"'{0}' template has been successfully updated".format(docName)))
else:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Error: '{0}' template could not be updated".format(templateName)))
def onDeleteTemplate(self):
"""
Slot raised to delete document template.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document template to delete"))
return
templateName,filePath = self.documentMapping()
result = QMessageBox.warning(self, QApplication.translate("TemplateDocumentSelector", \
"Confirm delete"),
QApplication.translate("TemplateDocumentSelector", \
"Are you sure you want to delete '{0}' template?" \
"This action cannot be undone.\nClick Yes to proceed " \
"or No to cancel.".format(templateName)),
QMessageBox.Yes|QMessageBox.No)
if result == QMessageBox.No:
return
status = self._deleteDocument(filePath)
if status:
#Remove item from list using model index row number
selectedDocNameIndices = self.lstDocs.selectionModel().selectedRows(0)
row = selectedDocNameIndices[0].row()
self._docItemModel.removeRow(row)
self.notifBar.insertSuccessNotification(QApplication.translate("TemplateDocumentSelector", \
"'{0}' template has been successfully removed".format(templateName)))
else:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Error: '{0}' template could not be removed".format(templateName)))
def onAccept(self):
"""
Slot raised to close the dialog only when a selection has been made by the user.
"""
self.notifBar.clear()
if self.documentMapping() == None:
self.notifBar.insertErrorNotification(QApplication.translate("TemplateDocumentSelector", \
"Please select a document"))
return
self.accept()
def _selectedMappings(self):
"""
Returns the model indices for the selected row.
"""
selectedDocNameIndices = self.lstDocs.selectionModel().selectedRows(0)
selectedFilePathIndices = self.lstDocs.selectionModel().selectedRows(1)
if len(selectedDocNameIndices) == 0:
return None
docNameIndex = selectedDocNameIndices[0]
filePathIndex = selectedFilePathIndices[0]
return (docNameIndex,filePathIndex)
def documentMapping(self):
"""
Returns a tuple containing the selected document name and the corresponding file name.
"""
mIndices = self._selectedMappings()
if mIndices == None:
return None
docNameItem = self._docItemModel.itemFromIndex(mIndices[0])
filePathItem = self._docItemModel.itemFromIndex(mIndices[1])
return (docNameItem.text(),filePathItem.text())
def _editTemplate(self,templatePath,newName):
"""
Updates the template document to use the new name.
"""
templateFile = QFile(templatePath)
if not templateFile.open(QIODevice.ReadOnly):
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Open Operation Error"), \
"{0}\n{1}".format(QApplication.translate("TemplateDocumentSelector","Cannot read template file."), \
templateFile.errorString()
))
return (False,"")
templateDoc = QDomDocument()
if templateDoc.setContent(templateFile):
composerElement = templateDoc.documentElement()
titleAttr = composerElement.attributeNode("_title")
if not titleAttr.isNull():
titleAttr.setValue(newName)
#Try remove file
status = templateFile.remove()
if not status:
return (False,"")
#Create new file
newTemplatePath = self._composerTemplatesPath() + "/" + newName + ".sdt"
newTemplateFile = QFile(newTemplatePath)
if not newTemplateFile.open(QIODevice.WriteOnly):
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Save Operation Error"), \
"{0}\n{1}".format(QApplication.translate("TemplateDocumentSelector","Could not save template file."), \
newTemplateFile.errorString()
))
return (False,"")
if newTemplateFile.write(templateDoc.toByteArray()) == -1:
QMessageBox.critical(self, QApplication.translate("TemplateDocumentSelector","Save Error"), \
QApplication.translate("TemplateDocumentSelector","Could not save template file."))
return (False,"")
newTemplateFile.close()
return (True,newTemplatePath)
def _deleteDocument(self,templatePath):
"""
Delete the document template from the file system.
"""
docFile = QFile(templatePath)
return docFile.remove()
def _composerTemplatesPath(self):
"""
Reads the path of composer templates in the registry.
"""
regConfig = RegistryConfig()
keyName = "ComposerTemplates"
valueCollection = regConfig.read([keyName])
if len(valueCollection) == 0:
return None
else:
return valueCollection[keyName]
class OWConfusionMatrix(widget.OWWidget):
name = "Confusion Matrix"
description = "Shows a confusion matrix."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
inputs = [{
"name": "Evaluation Results",
"type": Orange.evaluation.Results,
"handler": "set_results"
}]
outputs = [{"name": "Selected Data", "type": 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 = []
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.tableview = QTableView(editTriggers=QTableView.NoEditTriggers)
self.tableview.setModel(self.tablemodel)
self.tableview.selectionModel().selectionChanged.connect(
self._invalidate)
grid.addWidget(self.tableview, 1, 1)
self.mainArea.layout().addLayout(grid)
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 isinstance(data.domain.class_var,
Orange.data.DiscreteVariable):
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
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(headers)
self.tablemodel.setHorizontalHeaderLabels(headers)
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()
# 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)
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)))
class AbstractSTREnityListView(QListView):
"""
A widget for listing and selecting one or more STR entities.
.. versionadded:: 1.7
"""
def __init__(self, parent=None, **kwargs):
super(AbstractSTREnityListView, self).__init__(parent)
self._model = QStandardItemModel(self)
self._model.setColumnCount(1)
self.setModel(self._model)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self._model.itemChanged.connect(self._on_item_changed)
self._profile = kwargs.get('profile', None)
self._social_tenure = kwargs.get('social_tenure', None)
# Load appropriate entities to the view
if not self._profile is None:
self._load_profile_entities()
# Load entities in the STR definition
if not self._social_tenure is None:
self._select_str_entities()
def _on_item_changed(self, item):
# Emit signals when an item has been (de)selected. To be
# implemented by subclasses.
pass
@property
def profile(self):
"""
:return: Returns the current profile object in the configuration.
:rtype: Profile
"""
return self._profile
@profile.setter
def profile(self, profile):
"""
Sets the current profile object in the configuration.
:param profile: Profile object.
:type profile: Profile
"""
self._profile = profile
self._load_profile_entities()
@property
def social_tenure(self):
"""
:return: Returns the profile's social tenure entity.
:rtype: SocialTenure
"""
return self._social_tenure
@social_tenure.setter
def social_tenure(self, social_tenure):
"""
Set the social_tenure entity.
:param social_tenure: A profile's social tenure entity.
:type social_tenure: SocialTenure
"""
self._social_tenure = social_tenure
self._select_str_entities()
def _select_str_entities(self):
"""
Select the entities defined in the STR. E.g. parties for party
entity and spatial units for spatial unit entity. Default
implementation does nothing, to be implemented by subclasses.
"""
pass
def _load_profile_entities(self):
# Reset view
self.clear()
# Populate entity items in the view
for e in self._profile.user_entities():
self._add_entity(e)
def _add_entity(self, entity):
# Add entity item to view
item = QStandardItem(
QIcon(':/plugins/stdm/images/icons/table.png'),
entity.short_name
)
item.setCheckable(True)
item.setCheckState(Qt.Unchecked)
self._model.appendRow(item)
def select_entities(self, entities):
"""
Checks STR entities in the view and emit the entity_selected
signal for each item selected.
:param entities: Collection of STR entities.
:type entities: list
"""
# Clear selection
self.clear_selection()
for e in entities:
name = e.short_name
self.select_entity(name)
def selected_entities(self):
"""
:return: Returns a list of selected entity short names.
:rtype: list
"""
selected_items = []
for i in range(self._model.rowCount()):
item = self._model.item(i)
if item.checkState() == Qt.Checked:
selected_items.append(item.text())
return selected_items
def clear(self):
"""
Remove all party items in the view.
"""
self._model.clear()
self._model.setColumnCount(1)
def clear_selection(self):
"""
Uncheck all items in the view.
"""
for i in range(self._model.rowCount()):
item = self._model.item(i)
if item.checkState() == Qt.Checked:
item.setCheckState(Qt.Unchecked)
def select_entity(self, name):
"""
Selects a party entity with the given short name.
:param name: Entity short name
:type name: str
"""
items = self._model.findItems(name)
if len(items) > 0:
item = items[0]
if item.checkState() == Qt.Unchecked:
item.setCheckState(Qt.Checked)
def deselect_entity(self, name):
"""
Deselects an entity with the given short name.
:param name: Entity short name
:type name: str
"""
items = self._model.findItems(name)
if len(items) > 0:
item = items[0]
if item.checkState() == Qt.Checked:
item.setCheckState(Qt.Unchecked)
class PluginRepositoriesGUI(QWidget):
PATH_COLUMN = 1
ACTIVE_COLUMN = 0
AUTO_UPDATE_COLUMN = 2
STATUS_COLUMN = 3
addRepository = pyqtSignal()
checkForUpdates = pyqtSignal()
def __init__(self, logger, parent):
super(PluginRepositoriesGUI, self).__init__(parent)
self.logger = logger
self._gitHandler = GitHandler(logger)
layout = QVBoxLayout(self)
self._reposTable = QTreeView(self)
self._reposTable.setIndentation(0)
self._reposTable.header().setStretchLastSection(False)
self._reposModel = QStandardItemModel(self._reposTable)
self._initModel()
self._reposTable.setModel(self._reposModel)
self._reposTable.setSelectionMode(QTreeView.ExtendedSelection)
self._reposTable.selectionModel().selectionChanged.connect(self._selectionChanged)
layout.addWidget(self._reposTable)
buttonLayout = QHBoxLayout()
addButton = QPushButton("Add...")
addButton.clicked.connect(self.addRepository)
self._removeButton = QPushButton("Remove")
self._removeButton.setEnabled(False)
self._removeButton.clicked.connect(self._removeSelected)
refreshButton = QPushButton("Check Status")
refreshButton.clicked.connect(self.checkForUpdates)
buttonLayout.addWidget(addButton)
buttonLayout.addWidget(self._removeButton)
buttonLayout.addWidget(refreshButton)
layout.addLayout(buttonLayout)
self._statusWidget = QWidget(self)
self._statusWidget.setVisible(False)
statusLayout = QHBoxLayout(self._statusWidget)
statusLayout.setContentsMargins(0, 0, 0, 0)
self._statusLabel = QLabel(self)
statusLayout.addWidget(self._statusLabel)
layout.addWidget(self._statusWidget)
def clear(self):
self._initModel()
def _updateStatusItem(self, item, path, outdated=None, upToDate=None):
# first check fresh results, then the ones from repositories
if upToDate and path in upToDate:
item.setText(upToDate[path])
if upToDate[path] == GitHandler.UP_TO_DATE_REASON:
item.setData(QColor(0, 255, 0), Qt.DecorationRole)
else:
item.setData(QColor(255, 0, 0), Qt.DecorationRole)
elif outdated and path in outdated:
item.setText("Repository can be updated")
item.setData(QColor(255, 215, 0), Qt.DecorationRole)
elif get_settings().get_plugin_repositories().isUpToDate(path):
item.setText("No updates (for details, check status)")
item.setData(QColor(0, 255, 0), Qt.DecorationRole)
elif get_settings().get_plugin_repositories().isOutdated(path):
item.setText("Repository can be updated")
item.setData(QColor(255, 215, 0), Qt.DecorationRole)
else:
item.setData(None, Qt.DecorationRole)
def updateStatusItems(self, outdated=None, upToDate=None):
for row in xrange(self._reposModel.rowCount()):
path = convert_string(self._reposModel.item(row, self.PATH_COLUMN).data(Qt.DisplayRole).toString())
self._updateStatusItem(self._reposModel.item(row, self.STATUS_COLUMN), path, outdated, upToDate)
def _initModel(self):
from PyQt4.QtCore import QStringList
self._reposModel.clear()
stringList = QStringList([u"Active", u"Path", u"Auto Update", u"Status"])
self._reposModel.setColumnCount(stringList.count())
self._reposModel.setHorizontalHeaderLabels(stringList)
def appendRepository(self, path, active, autoUpdate, canAutoUpdate = None):
activeItem = QStandardItem()
activeItem.setEditable(False)
activeItem.setCheckState(Qt.Checked if active else Qt.Unchecked)
activeItem.setCheckable(True)
pathItem = QStandardItem()
pathItem.setData(path, Qt.DisplayRole)
pathItem.setEditable(False)
autoUpdateItem = QStandardItem()
autoUpdateItem.setEditable(False)
if canAutoUpdate == None:
canAutoUpdate = self._gitHandler.hasGit(path)
if canAutoUpdate:
autoUpdateItem.setCheckState(Qt.Checked if autoUpdate else Qt.Unchecked)
autoUpdateItem.setCheckable(True)
statusItem = QStandardItem()
self._updateStatusItem(statusItem, path)
self._reposModel.appendRow([activeItem, pathItem, autoUpdateItem, statusItem])
def resizeColumns(self):
self._reposTable.resizeColumnToContents(self.ACTIVE_COLUMN)
self._reposTable.resizeColumnToContents(self.AUTO_UPDATE_COLUMN)
self._reposTable.header().setResizeMode(self.PATH_COLUMN, QHeaderView.Stretch)
self._reposTable.header().setResizeMode(self.STATUS_COLUMN, QHeaderView.ResizeToContents)
def getTable(self):
return self._reposTable
@loggingSlot(QItemSelection, QItemSelection)
def _selectionChanged(self, _sel, _desel):
selection = self._reposTable.selectionModel().selectedRows()
self._removeButton.setEnabled(len(selection) > 0)
@loggingSlot()
def _removeSelected(self):
selection = self._reposTable.selectionModel().selectedRows()
for index in selection:
self._reposTable.model().removeRow(index.row())
def setStatus(self, msg, _progress=False):
if msg:
self._statusLabel.setText(msg)
self._statusWidget.setVisible(True)
else:
self._statusWidget.setVisible(False)
class DirDocumentTypeSelector(QDialog):
"""
Dialog for selecting supporting documents from a given directory. Default
filter searches for PDF files only.
"""
def __init__(self, dir, doc_types, parent=None, filters=None):
super(DirDocumentTypeSelector, self).__init__(parent)
self.setWindowTitle(
self.tr('Documents in Folder')
)
self._filters = filters
# Use PDF as default filter
if not self._filters:
self._filters = ['*.pdf']
self._init_ui()
self._dir = QDir(dir)
self._dir.setNameFilters(self._filters)
self._doc_types = doc_types
self._attr_model = QStandardItemModel(self)
self._sel_doc_types = OrderedDict()
# Notification bar
self._notif_bar = NotificationBar(self.vl_notif)
self.resize(320, 350)
# Load documents
self.load_document_types()
@property
def selected_document_types(self):
"""
:return: Returns a dictionary of the document types and the
corresponding file paths as selected by the user.
:rtype: dict
"""
return self._sel_doc_types
def _init_ui(self):
# Draw UI widgets
layout = QVBoxLayout()
# Add layout for notification bar
self.vl_notif = QVBoxLayout()
layout.addLayout(self.vl_notif)
self.lbl_info = QLabel()
self.lbl_info.setObjectName('lbl_info')
self.lbl_info.setText(self.tr(
'The selected document types have been found in the directory, '
'check/uncheck to specify which ones to upload.'
))
self.lbl_info.setWordWrap(True)
layout.addWidget(self.lbl_info)
self.lst_docs = QListView()
layout.addWidget(self.lst_docs)
self.lbl_warning = QLabel()
self.lbl_warning.setTextFormat(Qt.RichText)
self.lbl_warning.setText(self.tr(
'<html><head/><body><p><span style=" font-style:italic;">'
'* Previously uploaded documents will be replaced.</span></p>'
'</body></html>'
))
self.lbl_warning.setWordWrap(True)
layout.addWidget(self.lbl_warning)
self.btn_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel
)
layout.addWidget(self.btn_box)
self.setLayout(layout)
# Connect signals
self.btn_box.accepted.connect(
self.set_selected_document_types
)
self.btn_box.rejected.connect(
self.reject
)
def set_selected_document_types(self):
"""
Sets the collections of accepted document types and their
corresponding file paths and accepts the dialog.
"""
self._sel_doc_types = OrderedDict()
for i in range(self._attr_model.rowCount()):
doc_type_item = self._attr_model.item(i, 0)
if doc_type_item.checkState() == Qt.Checked:
path_item = self._attr_model.item(i, 1)
self._sel_doc_types[doc_type_item.text()] = path_item.text()
if len(self._sel_doc_types) == 0:
self._notif_bar.clear()
msg = self.tr('No matching documents found or selected.')
self._notif_bar.insertWarningNotification(msg)
return
self.accept()
def load_document_types(self):
"""
Load all document types to the list view and enable/check the items
for those types that have been found.
"""
self._attr_model.clear()
self._attr_model.setColumnCount(2)
file_infos = self._dir.entryInfoList(
QDir.Readable | QDir.Files,
QDir.Name
)
# Index file info based on name
idx_file_infos = {fi.completeBaseName().lower(): fi for fi in file_infos}
for d in self._doc_types:
doc_type_item = QStandardItem(d)
doc_type_item.setCheckable(True)
path_item = QStandardItem()
item_enabled = False
check_state = Qt.Unchecked
dl = d.lower()
if dl in idx_file_infos:
item_enabled = True
check_state = Qt.Checked
path = idx_file_infos[dl].filePath()
path_item.setText(path)
doc_type_item.setToolTip(path)
doc_type_item.setEnabled(item_enabled)
doc_type_item.setCheckState(check_state)
self._attr_model.appendRow([doc_type_item, path_item])
self.lst_docs.setModel(self._attr_model)
class ModelAtrributesView(QListView):
"""
Custom QListView implementation that displays checkable model attributes.
"""
def __init__(self, parent=None, dataModel=None):
QListView.__init__(self, parent)
self._dataModel = dataModel
self._selectedDisplayMapping = OrderedDict()
self._attrModel = QStandardItemModel(self)
def dataModel(self):
"""
Returns the data model instance.
"""
return self._dataModel
def setDataModel(self, dataModel):
"""
Sets the data model. Should be a callable class rather than the class
instance.
"""
if callable(dataModel):
self._dataModel = dataModel
else:
self._dataModel = dataModel.__class__
def load(self):
"""
Load the model's attributes into the list view.
"""
if self._dataModel == None:
return
try:
self._loadAttrs(self._dataModel.displayMapping())
except AttributeError:
#Ignore error if model does not contain the displayMapping static method
pass
def _loadAttrs(self, attrMapping):
"""
Loads display mapping into the list view.
"""
self._attrModel.clear()
self._attrModel.setColumnCount(2)
for attrName, displayName in attrMapping.iteritems():
#Exclude row ID in the list, other unique identifier attributes in the model can be used
if attrName != "id":
displayNameItem = QStandardItem(displayName)
displayNameItem.setCheckable(True)
attrNameItem = QStandardItem(attrName)
self._attrModel.appendRow([displayNameItem, attrNameItem])
self.setModel(self._attrModel)
def selectedMappings(self):
"""
Return a dictionary of field names and their corresponding display values.
"""
selectedAttrs = {}
for i in range(self._attrModel.rowCount()):
displayNameItem = self._attrModel.item(i, 0)
if displayNameItem.checkState() == Qt.Checked:
attrNameItem = self._attrModel.item(i, 1)
selectedAttrs[attrNameItem.text()] = displayNameItem.text()
return selectedAttrs
def _create_model(self, rows, columns):
model = QStandardItemModel()
model.setColumnCount(columns)
model.setRowCount(rows)
return model
class FrameInfoViewer(QTreeView):
""" Main tree for frame info """
frame_changed = pyqtSignal(SBFrame)
def __init__(self, parent):
super(QTreeView, self).__init__(parent)
self.setAutoScroll(True)
self.source_files = {}
self.focus_signal = None
self.header().setResizeMode(QHeaderView.ResizeToContents)
self._show_args = None
self.frame_data = QStandardItemModel()
self.setModel(self.frame_data)
self.setAlternatingRowColors(True)
self.top_frame = None
self.frames = {}
def set_focus_signal(self, signal):
""" set callback to focus source file line"""
self.focus_signal = signal
def clear(self):
""" clear the widget"""
self.frame_data.clear()
self.frame_data.setColumnCount(2)
self.frame_data.setHorizontalHeaderLabels(['', ''])
def show_frame_info(self, process):
""" show the frame info """
if not self.isVisible:
return
#TODO: no update if top frame is the same
self.clear()
root = self.frame_data.invisibleRootItem()
self.source_files.clear()
self.frames.clear()
if process is None or not process.is_alive:
return
#if process.num_of_threads == 1:
for thread in process:
thread_name = thread.GetName()
if not thread_name:
thread_name = '[No Thread]'
thread_row = QStandardItem(thread_name)
thread_row.setEditable(False)
thread_row.setSelectable(False)
dummy = QStandardItem('')
dummy.setEditable(False)
dummy.setSelectable(False)
root.appendRow([thread_row, dummy])
if len(thread.frames):
self.top_frame = thread.frames[0]
self.frame_changed.emit(self.top_frame)
for frame in thread.frames:
# first show the frame on the top of call stack.
frame_idx = '#%d: ' % frame.idx
frame_info = ''
selectable = False
if frame.name:
frame_idx += frame.name
if self._show_args.isChecked():
args = ','.join([str(x) for x in frame.args])
frame_info += ' (%s)' % args
line = frame.line_entry
if line:
file_info = ' at %s:%d' % (str(line.GetFileSpec()), line.GetLine())
frame_info += file_info
selectable = True
else:
frame_info += str(frame.module.GetFileSpec())
if frame.is_inlined:
frame_info += ' (inlined)'
col_idx = QStandardItem(frame_idx)
self.source_files[col_idx] = line
self.frames[col_idx] = frame
col_idx.setEditable(False)
col_idx.setSelectable(selectable)
col_info = QStandardItem(frame_info)
col_info.setEditable(False)
col_info.setSelectable(selectable)
thread_row.appendRow([col_idx, col_info])
self.expandToDepth(1)
def frame_up(self):
""" set frame to one level up """
pass
def frame_down(self):
""" set frame to one level down """
pass
def set_show_args(self, widget):
""" set the checkbox of showing func args"""
self._show_args = widget
def mousePressEvent(self, event):
""" overrided """
idx = self.indexAt(event.pos())
if idx.isValid() and self.focus_signal:
model = idx.model()
idx = idx.sibling(idx.row(), 0)
if idx.isValid():
item = model.itemFromIndex(idx)
if item and item.isSelectable():
if item in self.source_files:
file_info = self.source_files[item]
if self.focus_signal:
self.focus_signal.emit(file_info.GetFileSpec().fullpath,
file_info.GetLine())
self.frame_changed.emit(self.frames[item])
else:
logging.error('frame cannot find associated source file')
QTreeView.mousePressEvent(self, event)
def main(icon_spec):
app = QApplication(sys.argv)
main_window = QMainWindow()
def sigint_handler(*args):
main_window.close()
signal.signal(signal.SIGINT, sigint_handler)
# the timer enables triggering the sigint_handler
signal_timer = QTimer()
signal_timer.start(100)
signal_timer.timeout.connect(lambda: None)
tool_bar = QToolBar()
main_window.addToolBar(Qt.TopToolBarArea, tool_bar)
table_view = QTableView()
table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
table_view.setSelectionMode(QAbstractItemView.SingleSelection)
table_view.setSortingEnabled(True)
main_window.setCentralWidget(table_view)
proxy_model = QSortFilterProxyModel()
proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
proxy_model.setFilterKeyColumn(1)
table_view.setModel(proxy_model)
proxy_model.layoutChanged.connect(table_view.resizeRowsToContents)
item_model = QStandardItemModel()
proxy_model.setSourceModel(item_model)
# get all icons and their available sizes
QIcon.setThemeName("gnome")
icons = []
all_sizes = set([])
for context, icon_names in icon_spec:
for icon_name in icon_names:
icon = QIcon.fromTheme(icon_name)
sizes = []
for size in icon.availableSizes():
size = (size.width(), size.height())
sizes.append(size)
all_sizes.add(size)
sizes.sort()
icons.append({
'context': context,
'icon_name': icon_name,
'icon': icon,
'sizes': sizes,
})
all_sizes = list(all_sizes)
all_sizes.sort()
# input field for filter
def filter_changed(value):
proxy_model.setFilterRegExp(value)
table_view.resizeRowsToContents()
filter_line_edit = QLineEdit()
filter_line_edit.setMaximumWidth(200)
filter_line_edit.setPlaceholderText('Filter name')
filter_line_edit.setToolTip(
'Filter name optionally using regular expressions (' +
QKeySequence(QKeySequence.Find).toString() + ')')
filter_line_edit.textChanged.connect(filter_changed)
tool_bar.addWidget(filter_line_edit)
# actions to toggle visibility of available sizes/columns
def action_toggled(index):
column = 2 + index
table_view.setColumnHidden(column,
not table_view.isColumnHidden(column))
table_view.resizeColumnsToContents()
table_view.resizeRowsToContents()
signal_mapper = QSignalMapper()
for i, size in enumerate(all_sizes):
action = QAction('%dx%d' % size, tool_bar)
action.setCheckable(True)
action.setChecked(True)
tool_bar.addAction(action)
action.toggled.connect(signal_mapper.map)
signal_mapper.setMapping(action, i)
# set tool tip and handle key sequence
tool_tip = 'Toggle visibility of column'
if i < 10:
digit = ('%d' % (i + 1))[-1]
tool_tip += ' (%s)' % QKeySequence('Ctrl+%s' % digit).toString()
action.setToolTip(tool_tip)
signal_mapper.mapped.connect(action_toggled)
# label columns
header_labels = ['context', 'name']
for width, height in all_sizes:
header_labels.append('%dx%d' % (width, height))
item_model.setColumnCount(len(header_labels))
item_model.setHorizontalHeaderLabels(header_labels)
# fill rows
item_model.setRowCount(len(icons))
for row, icon_data in enumerate(icons):
# context
item = QStandardItem(icon_data['context'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 0, item)
# icon name
item = QStandardItem(icon_data['icon_name'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 1, item)
for index_in_all_sizes, size in enumerate(all_sizes):
column = 2 + index_in_all_sizes
if size in icon_data['sizes']:
# icon as pixmap to keep specific size
item = QStandardItem('')
pixmap = icon_data['icon'].pixmap(size[0], size[1])
item.setData(pixmap, Qt.DecorationRole)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
else:
# single space to be sortable against icons
item = QStandardItem(' ')
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
table_view.resizeColumnsToContents()
# manually set row heights because resizeRowsToContents is not working properly
for row, icon_data in enumerate(icons):
if len(icon_data['sizes']) > 0:
max_size = icon_data['sizes'][-1]
table_view.setRowHeight(row, max_size[1])
# enable focus find (ctrl+f) and toggle columns (ctrl+NUM)
def main_window_keyPressEvent(self,
event,
old_keyPressEvent=QMainWindow.keyPressEvent):
if event.matches(QKeySequence.Find):
filter_line_edit.setFocus()
return
if event.modifiers() == Qt.ControlModifier and event.key(
) >= Qt.Key_0 and event.key() <= Qt.Key_9:
index = event.key() - Qt.Key_1
if event.key() == Qt.Key_0:
index += 10
action = signal_mapper.mapping(index)
if action:
action.toggle()
return
old_keyPressEvent(self, event)
main_window.keyPressEvent = new.instancemethod(main_window_keyPressEvent,
table_view, None)
# enable copy (ctrl+c) name of icon to clipboard
def table_view_keyPressEvent(self,
event,
old_keyPressEvent=QTableView.keyPressEvent):
if event.matches(QKeySequence.Copy):
selection_model = self.selectionModel()
if selection_model.hasSelection():
index = selection_model.selectedRows()[0]
source_index = self.model().mapToSource(index)
item = self.model().sourceModel().item(source_index.row(), 1)
icon_name = item.data(Qt.EditRole)
app.clipboard().setText(icon_name.toString())
return
old_keyPressEvent(self, event)
table_view.keyPressEvent = new.instancemethod(table_view_keyPressEvent,
table_view, None)
print 'Icon Theme: ', QIcon.themeName()
print 'Theme Search Paths:'
for item in QIcon.themeSearchPaths():
print item
main_window.showMaximized()
return app.exec_()
class ModelAtrributesView(QListView):
"""
Custom QListView implementation that displays checkable model attributes.
"""
def __init__(self,parent=None,dataModel = None):
QListView.__init__(self, parent)
self._dataModel = dataModel
self._selectedDisplayMapping = OrderedDict()
self._modelDisplayMapping = OrderedDict()
self._attrModel = QStandardItemModel(self)
def dataModel(self):
"""
Returns the data model instance.
"""
return self._dataModel
def setDataModel(self,dataModel):
"""
Sets the data model. Should be a callable class rather than the class.
instance.
"""
if callable(dataModel):
self._dataModel = dataModel
else:
self._dataModel = dataModel.__class__
def modelDisplayMapping(self):
"""
Returns the column name and display name collection.
"""
return self._modelDisplayMapping
def setModelDisplayMapping(self, dataMapping):
"""
Sets the mapping dictionary for the table object
"""
if dataMapping != None:
self._modelDisplayMapping=dataMapping
def load(self, sort=False):
"""
Load the model's attributes into the list view.
"""
if self._dataModel == None:
return
try:
self._loadAttrs(self._dataModel.displayMapping(), sort)
except AttributeError:
#Ignore error if model does not contain the displayMapping static method
pass
def load_mapping(self, mapping, sort=False):
"""
Load collection containing column name and corresponding display name.
"""
self._modelDisplayMapping = mapping
self._loadAttrs(mapping, sort)
def sort(self):
"""
Sorts display name in ascending order.
"""
self._attrModel.sort(0)
def _loadAttrs(self, attrMapping, sort=False):
"""
Loads display mapping into the list view.
Specify to sort display names in ascending order once items have been
added to the model.
"""
self._attrModel.clear()
self._attrModel.setColumnCount(2)
for attrName,displayName in attrMapping.iteritems():
#Exclude row ID in the list, other unique identifier attributes in the model can be used
if attrName != "id":
displayNameItem = QStandardItem(displayName)
displayNameItem.setCheckable(True)
attrNameItem = QStandardItem(attrName)
self._attrModel.appendRow([displayNameItem,attrNameItem])
self.setModel(self._attrModel)
if sort:
self._attrModel.sort(0)
def selectedMappings(self):
"""
Return a dictionary of field names and their corresponding display values.
"""
selectedAttrs = {}
for i in range(self._attrModel.rowCount()):
displayNameItem = self._attrModel.item(i,0)
if displayNameItem.checkState() == Qt.Checked:
attrNameItem = self._attrModel.item(i,1)
selectedAttrs[attrNameItem.text()] = displayNameItem.text()
return selectedAttrs
class route:
def __init__(self, name='', desc='', survey_date=None, run_no=''):
self.name = name
self.desc = desc
self.survey_date = survey_date
self.run_no = run_no
self.model = QStandardItemModel()
#self.model=route_model.route_model()
self.model.setColumnCount(len(cols))
[self.model.setHeaderData(cols[c], Qt.Horizontal, c) for c in cols]
#def add_section(self,label,snode,rev,length,rbt,ch,desc,wkt,row=0):
# #self.model.insertRow(row,[make_cell(label),make_cell(rev,True),make_cell(desc,True),make_cell(ch),make_cell(snode),make_cell(length),make_cell(rbt),make_cell(wkt)])
def add_section(self,
label,
rev,
desc,
ch,
snode,
length,
rbt,
wkt,
row=0):
self.model.insertRow(row, [
make_cell(label),
make_cell(rev, True),
make_cell(desc, True),
make_cell(ch),
make_cell(snode),
make_cell(length),
make_cell(rbt),
make_cell(wkt)
])
#converts to qgis features
def to_features(self, layer):
return [
self.to_feat(i, layer) for i in range(0, self.model.rowCount())
]
def remove_rows(self, rows):
# removing changes following row numbers.Start with highest row number.
for r in reversed(sorted(rows)):
self.model.takeRow(r)
#key like [route_att:feature_att]
def add_feat(self, f, transform, row, rev, key):
geom = f.geometry()
geom.transform(transform)
snode = f[key['snode']]
if rev:
geom = reversed_geom(geom)
snode = f[key['enode']]
#chainage will be recalculated so irrelevant
self.add_section(f[key['section_label']], rev,
f[key['section_description']], 0, snode,
f[key['section_length']], f[key['roundabout']],
geom.exportToWkt(), row)
# g.geometry().asWkt()))) for qgis 3
#make qgis feature from row of model
def to_feat(self, row, layer):
feat = QgsFeature(layer.fields())
for c in cols:
if c != 'wkt':
feat.setAttribute(c, self.get_val(row, cols[c]))
feat.setAttribute('route', self.name)
feat.setAttribute('route_description', self.desc)
feat.setAttribute('survey_date', self.desc)
feat.setAttribute('run_no', self.run_no)
if self.get_val(row, cols['reversed']):
geom = reversed_geom(
QgsGeometry.fromWkt(self.get_val(row, cols['wkt'])))
else:
geom = QgsGeometry.fromWkt(self.get_val(row, cols['wkt']))
feat.setGeometry(geom)
return feat
def get_val(self, row, col):
return self.model.item(row, col).data(Qt.EditRole)
def __eq__(self, other):
return self.name == other.name and self.desc == other.desc and self.run_no == other.run_no #and self.survey_date=other.survey_date
#def __add__(self,other):
# if self==other:
# r=route(self.name,self.desc,self.survey_date,self.run_no)
# else:
# raise ValueError('conflicting route data')
def consume_other(self, other):
if self == other:
for i in other.model.rowCount():
self.model.appendRow(other.model.takeRow(i))
else:
raise ValueError('conflicting route data')
class STRPartyListView(QListView):
"""
A widget for listing and selecting STR party entities.
.. versionadded:: 1.5
"""
party_selected = pyqtSignal(QStandardItem)
party_deselected = pyqtSignal(QStandardItem)
def __init__(self, parent=None, profile=None, social_tenure=None):
super(STRPartyListView, self).__init__(parent)
self._model = QStandardItemModel(self)
self._model.setColumnCount(1)
self.setModel(self._model)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self._model.itemChanged.connect(self._on_item_changed)
self._profile = profile
if not self._profile is None:
self._load_profile_entities()
self._social_tenure = social_tenure
if not self._social_tenure is None:
self.select_parties(self._social_tenure.parties)
def _on_item_changed(self, item):
# Emit signals when an item has been (de)selected.
if item.checkState() == Qt.Checked:
self.party_selected.emit(item)
elif item.checkState() == Qt.Unchecked:
self.party_deselected.emit(item)
@property
def profile(self):
"""
:return: Returns the current profile object in the configuration.
:rtype: Profile
"""
return self._profile
@profile.setter
def profile(self, profile):
"""
Sets the current profile object in the configuration.
:param profile: Profile object.
:type profile: Profile
"""
self._profile = profile
self._load_profile_entities()
@property
def social_tenure(self):
"""
:return: Returns the profile's social tenure entity.
:rtype: SocialTenure
"""
return self._social_tenure
@social_tenure.setter
def social_tenure(self, social_tenure):
"""
Set the social_tenure entity.
:param social_tenure: A profile's social tenure entity.
:type social_tenure: SocialTenure
"""
self._social_tenure = social_tenure
self.select_parties(self._social_tenure.parties)
def _load_profile_entities(self):
# Reset view
self.clear()
# Populate entity items in the view
for e in self._profile.user_entities():
self._add_entity(e)
def _add_entity(self, party):
# Add entity item to view
item = QStandardItem(QIcon(':/plugins/stdm/images/icons/table.png'),
party.short_name)
item.setCheckable(True)
item.setCheckState(Qt.Unchecked)
self._model.appendRow(item)
def select_parties(self, parties):
"""
Checks party entities in the view and emit the party_selected
signal for each item selected.
:param parties: Collection of STR party entities.
:type parties: list
"""
# Clear selection
self.clear_selection()
for p in parties:
name = p.short_name
self.select_party(name)
def parties(self):
"""
:return: Returns a list of selected party names.
:rtype: list
"""
selected_items = []
for i in range(self._model.rowCount()):
item = self._model.item(i)
if item.checkState() == Qt.Checked:
selected_items.append(item.text())
return selected_items
def clear(self):
"""
Remove all party items in the view.
"""
self._model.clear()
self._model.setColumnCount(1)
def clear_selection(self):
"""
Uncheck all items in the view.
"""
for i in range(self._model.rowCount()):
item = self._model.item(i)
if item.checkState() == Qt.Checked:
item.setCheckState(Qt.Unchecked)
def select_party(self, name):
"""
Selects a party entity with the given short name.
:param name: Entity short name
:type name: str
"""
items = self._model.findItems(name)
if len(items) > 0:
item = items[0]
if item.checkState() == Qt.Unchecked:
item.setCheckState(Qt.Checked)
def deselect_party(self, name):
"""
Deselects a party entity with the given short name.
:param name: Entity short name
:type name: str
"""
items = self._model.findItems(name)
if len(items) > 0:
item = items[0]
if item.checkState() == Qt.Checked:
item.setCheckState(Qt.Unchecked)
class ConsoleWidget(QWidget):
_RECORD_ROLE = Qt.UserRole + 1
def __init__(self, parent, logger):
super(ConsoleWidget, self).__init__(parent)
self.logger = logger
self._errorColor = QVariant(QColor(180, 0, 0))
self._warningColor = QVariant(QColor(170, 100, 0))
self._records = []
self._initModel()
self._initUI()
get_notification_center().connectLogMessage(self._addLogMessage)
def _initUI(self):
layout = QVBoxLayout(self)
split = QSplitter(Qt.Vertical, self)
layout.setContentsMargins(0, 0, 0, 0)
console = QTreeView(self)
console.setSortingEnabled(False)
console.setHeaderHidden(False)
console.setAlternatingRowColors(True)
console.setIndentation(0)
console.setUniformRowHeights(True)
console.setObjectName(u"__console_log")
console.setFrameShape(QFrame.StyledPanel)
#if getPlatform() == PLATFORM_MAC:
# console.setStyleSheet("QFrame#__console_log{border-width: 1px; border-top-style: none; border-right-style: none; border-bottom-style: solid; border-left-style: none; border-color:palette(mid)}");
console.setModel(self._logModel)
console.header().setStretchLastSection(False)
console.header().setResizeMode(3, QHeaderView.Stretch)
console.selectionModel().selectionChanged.connect(self._selectionChanged)
split.addWidget(console)
detailsWidget = QWidget(self)
detailsLayout = QVBoxLayout(detailsWidget)
detailsLayout.setContentsMargins(0, 0, 0, 0)
detailsLayout.setSpacing(0)
detailsLayout.addWidget(QLabel(u"Details:", self))
self._detailsView = QTextEdit(self)
self._detailsView.setReadOnly(True)
self._detailsView.setWordWrapMode(QTextOption.NoWrap)
detailsLayout.addWidget(self._detailsView, 1)
split.addWidget(detailsWidget)
layout.addWidget(split, 1)
@loggingSlot(QItemSelection, QItemSelection)
def _selectionChanged(self, newSel, _oldSel):
if len(newSel.indexes()) == 0:
self._detailsView.clear()
else:
index = newSel.indexes()[0]
record = self._records[index.row()]
try:
logMsg = convert_string(record.msg) % record.args
except:
logMsg = convert_string(record.msg) + ', '.join(str(arg) for arg in record.args)
msg = u"%s - In %s:%d: %s" % (strftime("%H:%M:%S", localtime(record.created)),
record.pathname,
record.lineno,
logMsg)
if record.exc_info:
out = StringIO()
traceback.print_tb(record.exc_info[2], file=out)
msg += u"\nStack trace:\n" + out.getvalue() + formatException(record.exc_info) + u"\n"
self._detailsView.setPlainText(msg)
def _initModel(self):
self._logModel = QStandardItemModel(self)
self._logModel.setColumnCount(5)
self._logModel.setHorizontalHeaderLabels([u"Time", u"Level", u"Component", u"Message", u"Source"])
for record in getCachedLogRecords():
self._addLogMessage(record)
def _createItem(self, text, error, toolTip=None):
item = QStandardItem()
item.setEditable(False)
item.setText(text)
if error is 1:
item.setData(self._warningColor, Qt.ForegroundRole)
elif error is 2:
item.setData(self._errorColor, Qt.ForegroundRole)
if toolTip is None:
toolTip = text
item.setData(QVariant(toolTip), Qt.ToolTipRole)
return item
@loggingSlot(object)
def _addLogMessage(self, record):
self._records.append(record)
msg = record.msg
if not isinstance(msg, basestring):
msg = unicode(msg)
try:
msg = convert_string(msg) % record.args
except:
msg = u"(Error formatting log message) " +\
convert_string(msg) +\
', '.join(unicode(v) for v in record.args)
dirname = os.path.dirname(record.pathname)
source = u"%s:%d" % (os.path.join(os.path.basename(dirname), os.path.basename(record.pathname)), record.lineno)
fullsource = u"%s:%d" % (record.pathname, record.lineno)
component = record.name
if component.startswith("lunchinator."):
component = component[12:]
error = 1 if record.levelno == logging.WARNING else 2 if record.levelno == logging.ERROR else 0
self._logModel.appendRow([self._createItem(strftime("%H:%M:%S", localtime(record.created)), error),
self._createItem(record.levelname, error),
self._createItem(component, error),
self._createItem(msg, error),
self._createItem(source, error, fullsource)])