class VizRank(OWWidget):
name = "Rank projections (Scatter Plot)"
def __init__(self, parent_widget):
super().__init__()
self.parent_widget = parent_widget
self.want_control_area = False
self.running = False
self.progress = None
self.k = 10
self.projectionTable = QTableView()
self.mainArea.layout().addWidget(self.projectionTable)
self.projectionTable.setSelectionBehavior(QTableView.SelectRows)
self.projectionTable.setSelectionMode(QTableView.SingleSelection)
self.projectionTable.setSortingEnabled(True)
self.projectionTableModel = QStandardItemModel(self)
self.projectionTable.setModel(self.projectionTableModel)
self.projectionTable.selectionModel().selectionChanged.connect(
self.on_selection_changed)
self.button = gui.button(self.mainArea, self, "Start evaluation",
callback=self.toggle, default=True)
self.resize(380, 512)
self._initialize()
def _initialize(self):
self.running = False
self.projectionTableModel.clear()
self.projectionTableModel.setHorizontalHeaderLabels(
["Score", "Feature 1", "Feature 2"])
self.projectionTable.setColumnWidth(0, 60)
self.projectionTable.setColumnWidth(1, 120)
self.projectionTable.setColumnWidth(2, 120)
self.button.setText("Start evaluation")
self.button.setEnabled(False)
self.pause = False
self.data = None
self.attrs = []
self.scores = []
self.i, self.j = 0, 0
if self.progress:
self.progress.finish()
self.progress = None
self.information(0)
if self.parent_widget.data:
if not self.parent_widget.data.domain.class_var:
self.information(
0, "Data with a class variable is required.")
return
if len(self.parent_widget.data.domain.attributes) < 2:
self.information(
0, 'At least 2 unique features are needed.')
return
self.button.setEnabled(True)
def on_selection_changed(self, selected, deselected):
"""Called when the ranks view selection changes."""
a1 = selected.indexes()[1].data()
a2 = selected.indexes()[2].data()
self.parent_widget.update_attr(attributes=(a1, a2))
def toggle(self):
self.running ^= 1
if self.running:
self.button.setText("Pause")
self.run()
else:
self.button.setText("Continue")
self.button.setEnabled(False)
def run(self):
graph = self.parent_widget.graph
y_full = self.parent_widget.data.Y
norm = 1 / (len(y_full) * self.k)
if not self.attrs:
self.attrs = self.score_heuristic()
if not self.progress:
self.progress = gui.ProgressBar(
self, len(self.attrs) * (len(self.attrs) - 1) / 2)
for i in range(self.i, len(self.attrs)):
ind1 = graph.attribute_name_index[self.attrs[i]]
for j in range(self.j, i):
if not self.running:
self.i, self.j = i, j
if not self.projectionTable.selectedIndexes():
self.projectionTable.selectRow(0)
self.button.setEnabled(True)
return
ind2 = graph.attribute_name_index[self.attrs[j]]
X = graph.scaled_data[[ind1, ind2], :]
valid = graph.get_valid_list([ind1, ind2])
X = X[:, valid].T
y = y_full[valid]
knn = NearestNeighbors(n_neighbors=self.k).fit(X)
ind = knn.kneighbors(return_distance=False)
score = norm * np.sum(y[ind] == y.reshape(-1, 1))
pos = bisect_left(self.scores, score)
self.projectionTableModel.insertRow(
len(self.scores) - pos,
[QStandardItem("{:.4f}".format(score)),
QStandardItem(self.attrs[j]),
QStandardItem(self.attrs[i])])
self.scores.insert(pos, score)
self.progress.advance()
self.j = 0
self.progress.finish()
if not self.projectionTable.selectedIndexes():
self.projectionTable.selectRow(0)
self.button.setText("Finished")
self.button.setEnabled(False)
def score_heuristic(self):
X = self.parent_widget.graph.scaled_data.T
Y = self.parent_widget.data.Y
dom = Orange.data.Domain([ContinuousVariable(str(i))
for i in range(X.shape[1])],
self.parent_widget.data.domain.class_vars)
data = Orange.data.Table(dom, X, Y)
weights = ReliefF(n_iterations=100, k_nearest=self.k)(data)
attrs = sorted(
zip(weights,
(x.name for x in self.parent_widget.data.domain.attributes)
),
reverse=True)
return [a for _, a in attrs]
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 DlgAixmIap(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.resize(290, 136)
self.setWindowTitle("Instrument Approach Procedure (IAP)")
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
verticalLayoutDlg = QVBoxLayout(self)
verticalLayoutDlg.setObjectName(("verticalLayoutDlg"))
self.groupBox = GroupBox(self)
verticalLayoutDlg.addWidget(self.groupBox)
self.pnlAerodrome = ComboBoxPanel(self.groupBox)
self.pnlAerodrome.Caption = "Aerodrome"
self.groupBox.Add = self.pnlAerodrome
self.pnlDesignator = TextBoxPanel(self.groupBox)
self.pnlDesignator.Caption = "Designator"
self.groupBox.Add = self.pnlDesignator
self.pnlAcCategory = ComboBoxPanel(self.groupBox)
self.pnlAcCategory.Caption = "Ac. Category"
self.groupBox.Add = self.pnlAcCategory
self.pnlTransID = TextBoxPanel(self.groupBox)
self.pnlTransID.Caption = "ransitional Identifier"
self.groupBox.Add = self.pnlTransID
self.pnlType = ComboBoxPanel(self.groupBox)
self.pnlType.Caption = "Type"
self.groupBox.Add = self.pnlType
self.pnlRunway = ComboBoxPanel(self.groupBox)
self.pnlRunway.Caption = "Runway Direction"
self.groupBox.Add = self.pnlRunway
self.pnlMSA = ComboBoxPanel(self.groupBox)
self.pnlMSA.Caption = "MSA Group"
self.groupBox.Add = self.pnlMSA
self.pnlRNP = NumberBoxPanel(self.groupBox)
self.pnlRNP.Caption = "RNP"
self.groupBox.Add = self.pnlRNP
self.tableLayoutPanel = Frame(self.groupBox)
self.groupBox.Add = self.tableLayoutPanel
self.txtDescription = TextBoxPanel(self.tableLayoutPanel, True)
self.txtDescription.Caption = "Description"
self.tableLayoutPanel.Add = self.txtDescription
self.txtDescrComFail = TextBoxPanel(self.tableLayoutPanel, True)
self.txtDescrComFail.Caption = "Communication Failure"
self.tableLayoutPanel.Add = self.txtDescrComFail
self.txtRemarks = TextBoxPanel(self.tableLayoutPanel, True)
self.txtRemarks.Caption = "Remarks"
self.tableLayoutPanel.Add = self.txtRemarks
self.gbOcaOch = GroupBox(self.groupBox, "HL")
self.gbOcaOch.Caption = "Minimum OCA/OCH"
self.groupBox.Add = self.gbOcaOch
self.gridOcah = QTableView(self.gbOcaOch)
self.gridOcahModel = StandardItemModel(None, [
"Ac. Category", "Approach Type", "OCA", "OCH", "OCH Ref.",
"Remarks"
])
self.gridOcah.setModel(self.gridOcahModel)
self.gbOcaOch.Add = self.gridOcah
self.pnlProcButtons = Frame(self.gbOcaOch)
self.gbOcaOch.Add = self.pnlProcButtons
self.btnAdd = QPushButton(self.pnlProcButtons)
icon = QIcon()
icon.addPixmap(QPixmap("Resource/add.png"), QIcon.Normal, QIcon.Off)
self.btnAdd.setIcon(icon)
self.pnlProcButtons.Add = self.btnAdd
self.btnEdit = QPushButton(self.pnlProcButtons)
icon = QIcon()
icon.addPixmap(QPixmap("Resource/mIconEditableEdits.png"),
QIcon.Normal, QIcon.Off)
self.btnEdit.setIcon(icon)
self.pnlProcButtons.Add = self.btnEdit
self.btnRemove = QPushButton(self.pnlProcButtons)
icon = QIcon()
icon.addPixmap(QPixmap("Resource/remove.png"), QIcon.Normal, QIcon.Off)
self.btnRemove.setIcon(icon)
self.pnlProcButtons.Add = self.btnRemove
self.btnBoxOkCancel = QDialogButtonBox(self)
self.btnBoxOkCancel.setObjectName(("btnBoxOkCancel"))
self.btnBoxOkCancel.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.connect(self.btnBoxOkCancel, SIGNAL("accepted()"), self.acceptDlg)
self.connect(self.btnBoxOkCancel, SIGNAL("rejected()"), self.reject)
verticalLayoutDlg.addWidget(self.btnBoxOkCancel)
self.btnAdd.clicked.connect(self.btnAdd_Click)
self.btnEdit.clicked.connect(self.btnEdit_Click)
self.btnRemove.clicked.connect(self.btnRemove_Click)
self.gridOcah.pressed.connect(self.gridOcah_pressed)
self.data = None
self.table = None
self.selected = None
self.minimums = None
def gridOcah_pressed(self):
self.method_7()
def btnAdd_Click(self):
dataBaseIapOcaOch = DataBaseIapOcaOch()
if (not DlgAixmOcaOch.smethod_0(dataBaseIapOcaOch)):
return
self.minimums.Add(dataBaseIapOcaOch)
self.gridOcahModel.Refresh(self.minimums)
self.method_7()
def btnEdit_Click(self):
selectedIndexes = self.gridOcah.selectedIndexes()
selectedRow = selectedIndexes[0].row()
if (DlgAixmOcaOch.smethod_0(self.minimums[selectedRow])):
self.gridOcahModel.Refresh(self.minimums)
self.method_7()
def btnRemove_Click(self):
selectedIndexes = self.gridOcah.selectedIndexes()
selectedRow = selectedIndexes[0].row()
self.minimums.pop(selectedRow)
self.gridOcahModel.Refresh(self.minimums)
self.method_7()
def acceptDlg(self):
strS = None
selectedItem = self.pnlAerodrome.SelectedItem
num = (self.pnlAcCategory.SelectedIndex >=
0) and self.pnlAcCategory.SelectedIndex or -1
for row in self.table:
flag = True
if (self.selected != None and row == self.selected):
flag = False
if (row["ahpEnt"] != selectedItem):
flag = False
if (not self.pnlDesignator.Value == row["txtDesig"]):
flag = False
if (num != (row["codeCatAcft"] == None) and -1
or int(row["codeCatAcft"])):
flag = False
strS = (row["codeTransId"] == None) and "" or row["codeTransId"]
if (not self.pnlTransID.Value == strS):
flag = False
if (not flag):
continue
str1 = "Cannot create a duplicate procedure entry.\n\nAerodrome = {0}\nDesignator = {1}".format(
self.pnlAerodrome.SelectedItem, self.pnlDesignator.Value)
if (self.pnlAcCategory.SelectedIndex >= 0):
str1 = String.Concat([
str1, "\nAc. Category = {0}".format(
self.pnlAcCategory.SelectedItem)
])
if (not String.IsNullOrEmpty(self.pnlTransID.Value)):
str1 = String.Concat([
str1, "\nTransition Identifier = {0}".format(
self.pnlTransID.Value)
])
QMessageBox.warning(self, "Error", str1)
return
self.accept()
def method_5(self):
self.data.method_35(self.pnlRunway.Items,
self.pnlAerodrome.SelectedItem)
# self.pnlRunway.comboBox.insertItem(0, "");
def method_6(self):
self.btnEdit_Click()
def method_7(self):
self.btnEdit.setEnabled(len(self.gridOcah.selectedIndexes()) == 1)
self.btnRemove.setEnabled(len(self.gridOcah.selectedIndexes()) == 1)
@staticmethod
def smethod_0(dataBaseIAPs_0, dataBaseProcedureData_0, dataRow_0):
flag = False
dlgAixmIap = DlgAixmIap()
dlgAixmIap.data = dataBaseProcedureData_0
dlgAixmIap.table = dataBaseIAPs_0
dlgAixmIap.selected = dataRow_0
dataBaseProcedureData_0.method_51(dlgAixmIap.pnlAerodrome)
dataBaseProcedureData_0.method_47(dlgAixmIap.pnlMSA)
dlgAixmIap.pnlAcCategory.Items = CodeCatAcftAixm.Items
dlgAixmIap.pnlType.Items = CodeTypeIapAixm.Items
# dlgAixmIap.pnlAcCategory.Insert(0, "");
# dlgAixmIap.pnlMSA.Items.Insert(0, "");
if (dataRow_0 != None and len(dataRow_0) != 0):
dlgAixmIap.pnlAerodrome.SelectedIndex = dlgAixmIap.pnlAerodrome.IndexOf(
dataRow_0["ahpEnt"])
if (dlgAixmIap.pnlAerodrome.SelectedIndex >= 0):
dataBaseProcedureData_0.method_35(
dlgAixmIap.pnlRunway, dlgAixmIap.pnlAerodrome.SelectedItem)
# dlgAixmIap.pnlRunway.Insert(0, "");
dlgAixmIap.pnlDesignator.Value = dataRow_0["txtDesig"]
if (dataRow_0["codeCatAcft"] != None):
dlgAixmIap.pnlAcCategory.SelectedIndex = dlgAixmIap.pnlAcCategory.method_3(
dataRow_0["codeCatAcft"])
if (dataRow_0["codeTransId"] != None):
dlgAixmIap.pnlTransID.Value = dataRow_0["codeTransId"]
if (dataRow_0["rdnEnt"] != None):
dlgAixmIap.pnlRunway.SelectedIndex = dlgAixmIap.pnlRunway.IndexOf(
dataRow_0["rdnEnt"])
if (dataRow_0["mgpEnt"] != None):
dlgAixmIap.pnlMSA.SelectedIndex = dlgAixmIap.pnlMSA.IndexOf(
dataRow_0["mgpEnt"])
if (dataRow_0["codeRnp"] != None):
dlgAixmIap.pnlRNP.Value = dataRow_0["codeRnp"]
if (dataRow_0["txtDescrComFail"] != None):
dlgAixmIap.txtDescrComFail.Value = dataRow_0["txtDescrComFail"]
dlgAixmIap.pnlType.SelectedIndex = dlgAixmIap.pnlType.method_3(
dataRow_0["codeTypeRte"])
if (dataRow_0["txtDescrMiss"] != None):
dlgAixmIap.txtDescription.Value = dataRow_0["txtDescrMiss"]
if (dataRow_0["txtRmk"] != None):
dlgAixmIap.txtRemarks.Value = dataRow_0["txtRmk"]
dlgAixmIap.minimums = dataRow_0["ocah"]
if (dlgAixmIap.minimums == None):
dlgAixmIap.minimums = DataBaseIapOcaOchs()
dlgAixmIap.gridOcahModel.DataSource = dlgAixmIap.minimums
resultDlg = dlgAixmIap.exec_()
if resultDlg == 1:
dataRow0 = dataRow_0 == None or len(dataRow_0) == 0
strS = []
if (not dataRow0):
for i in range(len(dataBaseIAPs_0.nameList)):
strS.append(None)
# strS = new string[dataBaseIAPs_0.Columns.Count];
i = 0
for name in dataBaseIAPs_0.nameList:
strS[i] = dataRow_0[name]
i += 1
else:
dataRow_0 = dataBaseIAPs_0.NewRow()
dataRow_0["ahpEnt"] = dlgAixmIap.pnlAerodrome.SelectedItem
if (dataRow0):
dataRow_0["oldAhpEnt"] = dataRow_0["ahpEnt"]
dataRow_0["txtDesig"] = dlgAixmIap.pnlDesignator.Value
if (dataRow0):
dataRow_0["oldTxtDesig"] = dataRow_0["txtDesig"]
if (dlgAixmIap.pnlAcCategory.SelectedIndex >= 0):
dataRow_0[
"codeCatAcft"] = dlgAixmIap.pnlAcCategory.SelectedItem
else:
dataRow_0["codeCatAcft"] = None
if (dataRow0):
dataRow_0["oldCodeCatAcft"] = dataRow_0["codeCatAcft"]
if (not String.IsNullOrEmpty(dlgAixmIap.pnlTransID.Value)):
dataRow_0["codeTransId"] = dlgAixmIap.pnlTransID.Value
else:
dataRow_0["codeTransId"] = None
if (dataRow0):
dataRow_0["oldCodeTransId"] = dataRow_0["codeTransId"]
if (dlgAixmIap.pnlRunway.SelectedIndex >= 0):
dataRow_0["rdnEnt"] = dlgAixmIap.pnlRunway.SelectedItem
else:
dataRow_0["rdnEnt"] = None
if (dlgAixmIap.pnlMSA.SelectedIndex >= 0):
dataRow_0["mgpEnt"] = dlgAixmIap.pnlMSA.SelectedItem
else:
dataRow_0["mgpEnt"] = None
if (not math.isnan(dlgAixmIap.pnlRNP.Value)
and not math.isinf(dlgAixmIap.pnlRNP.Value)):
dataRow_0["codeRnp"] = dlgAixmIap.pnlRNP.Value
else:
dataRow_0["codeRnp"] = None
dataRow_0["codeTypeRte"] = dlgAixmIap.pnlType.SelectedItem
if (not String.IsNullOrEmpty(dlgAixmIap.txtDescrComFail.Value)):
dataRow_0["txtDescrComFail"] = dlgAixmIap.txtDescrComFail.Value
else:
dataRow_0["txtDescrComFail"] = None
if (not String.IsNullOrEmpty(dlgAixmIap.txtDescription.Value)):
dataRow_0["txtDescrMiss"] = dlgAixmIap.txtDescription.Value
else:
dataRow_0["txtDescrMiss"] = None
if (not String.IsNullOrEmpty(dlgAixmIap.txtRemarks.Value)):
dataRow_0["txtRmk"] = dlgAixmIap.txtRemarks.Value
else:
dataRow_0["txtRmk"] = None
dataRow_0["ocah"] = dlgAixmIap.minimums
if (dataRow0):
dataRow_0["procLegs"] = DataBaseProcedureLegs()
dataRow_0["procLegsEx"] = DataBaseProcedureLegsEx()
if (not dataRow0):
num = 1
while (num < len(strS)):
if (not strS[num] == dataRow_0[dataRow_0.nameList[num]]):
dataRow_0["changed"] = "True"
if (dataRow0):
dataBaseIAPs_0.RowsAdd(dataRow_0)
flag = True
return flag
else:
num += 1
else:
dataRow_0["new"] = "True"
if (dataRow0):
dataBaseIAPs_0.RowsAdd(dataRow_0)
flag = True
return flag
return flag
class VizRank(OWWidget):
name = "Rank projections (Scatter Plot)"
want_control_area = False
def __init__(self, parent_widget):
super().__init__()
self.parent_widget = parent_widget
self.running = False
self.progress = None
self.k = 10
self.projectionTable = QTableView()
self.mainArea.layout().addWidget(self.projectionTable)
self.projectionTable.setSelectionBehavior(QTableView.SelectRows)
self.projectionTable.setSelectionMode(QTableView.SingleSelection)
self.projectionTable.setSortingEnabled(True)
self.projectionTableModel = QStandardItemModel(self)
self.projectionTable.setModel(self.projectionTableModel)
self.projectionTable.selectionModel().selectionChanged.connect(
self.on_selection_changed)
self.button = gui.button(self.mainArea,
self,
"Start evaluation",
callback=self.toggle,
default=True)
self.resize(380, 512)
self._initialize()
def _initialize(self):
self.running = False
self.projectionTableModel.clear()
self.projectionTableModel.setHorizontalHeaderLabels(
["Score", "Feature 1", "Feature 2"])
self.projectionTable.setColumnWidth(0, 60)
self.projectionTable.setColumnWidth(1, 120)
self.projectionTable.setColumnWidth(2, 120)
self.button.setText("Start evaluation")
self.button.setEnabled(False)
self.pause = False
self.data = None
self.attrs = []
self.scores = []
self.i, self.j = 0, 0
if self.progress:
self.progress.finish()
self.progress = None
self.information(0)
if self.parent_widget.data:
if not self.parent_widget.data.domain.class_var:
self.information(
0, "Data with a class variable is required.")
return
if len(self.parent_widget.data.domain.attributes) < 2:
self.information(0,
'At least 2 unique features are needed.')
return
if len(self.parent_widget.data) < 2:
self.information(0, 'At least 2 instances are needed.')
return
self.button.setEnabled(True)
def on_selection_changed(self, selected, deselected):
"""Called when the ranks view selection changes."""
a1 = selected.indexes()[1].data()
a2 = selected.indexes()[2].data()
self.parent_widget.update_attr(attributes=(a1, a2))
def toggle(self):
self.running ^= 1
if self.running:
self.button.setText("Pause")
self.run()
else:
self.button.setText("Continue")
self.button.setEnabled(False)
def run(self):
graph = self.parent_widget.graph
y_full = self.parent_widget.data.Y
if not self.attrs:
self.attrs = self.score_heuristic()
if not self.progress:
self.progress = gui.ProgressBar(
self,
len(self.attrs) * (len(self.attrs) - 1) / 2)
for i in range(self.i, len(self.attrs)):
ind1 = graph.attribute_name_index[self.attrs[i]]
for j in range(self.j, i):
if not self.running:
self.i, self.j = i, j
if not self.projectionTable.selectedIndexes():
self.projectionTable.selectRow(0)
self.button.setEnabled(True)
return
ind2 = graph.attribute_name_index[self.attrs[j]]
X = graph.scaled_data[[ind1, ind2], :]
valid = graph.get_valid_list([ind1, ind2])
X = X[:, valid].T
if X.shape[0] < self.k:
self.progress.advance()
continue
y = y_full[valid]
n_neighbors = min(self.k, len(X) - 1)
knn = NearestNeighbors(n_neighbors=n_neighbors).fit(X)
ind = knn.kneighbors(return_distance=False)
if self.parent_widget.data.domain.has_discrete_class:
score = np.sum(y[ind] == y.reshape(-1, 1)) / (
len(y_full) * n_neighbors)
else:
score = r2_score(y, np.mean(
y[ind], axis=1)) * (len(y) / len(y_full))
pos = bisect_left(self.scores, score)
self.projectionTableModel.insertRow(
len(self.scores) - pos, [
QStandardItem("{:.4f}".format(score)),
QStandardItem(self.attrs[j]),
QStandardItem(self.attrs[i])
])
self.scores.insert(pos, score)
self.progress.advance()
self.j = 0
self.progress.finish()
if not self.projectionTable.selectedIndexes():
self.projectionTable.selectRow(0)
self.button.setText("Finished")
self.button.setEnabled(False)
def score_heuristic(self):
X = self.parent_widget.graph.scaled_data.T
Y = self.parent_widget.data.Y
dom = Domain(
[ContinuousVariable(str(i)) for i in range(X.shape[1])],
self.parent_widget.data.domain.class_vars)
data = Table(dom, X, Y)
relief = ReliefF if isinstance(dom.class_var,
DiscreteVariable) else RReliefF
weights = relief(n_iterations=100, k_nearest=self.k)(data)
attrs = sorted(zip(
weights,
(x.name for x in self.parent_widget.data.domain.attributes)),
reverse=True)
return [a for _, a in attrs]
class MobileWidget(QWidget):
"""
Mobile widget
"""
RefreshScreen = pyqtSignal()
RefreshAutomatic = pyqtSignal(bool)
TapOn = pyqtSignal(int, int)
def __init__(self, parent=None):
"""
Constructor
"""
super(MobileWidget, self).__init__(parent)
self.origWidth = 0
self.origHeight = 0
self.imagePath = None
self.createActions()
self.createWidget()
self.createToolbar()
self.center()
def createActions(self):
"""
Create qt actions
"""
self.refreshAction = QtHelper.createAction(self,
self.tr("&Refresh"),
self.refreshScreen,
icon=None)
self.refreshAction.setEnabled(False)
self.copyAction = QtHelper.createAction(self,
self.tr("&Copy"),
self.copyItem,
icon=None)
def createWidget(self):
"""
Create qt widget
"""
self.screenResolutionLabel = QLabel(self)
self.screenTapLabel = QLabel(self)
mobileLayout = QVBoxLayout()
self.mobileDockToolbar = QToolBar(self)
self.mobileDockToolbar.setStyleSheet("QToolBar { border: 0px }")
self.mobileDockToolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.mobileImageLabel = QLabel(self)
self.mobileImageLabel.setMouseTracking(True)
self.mobileImageLabel.installEventFilter(self)
self.mobileImageLabel.setScaledContents(True)
self.mobileImageLabel.mousePressEvent = self.pixelSelect
self.refreshCheckbox = QCheckBox("Automatic Refresh", self)
self.refreshCheckbox.setEnabled(False)
self.refreshCheckbox.stateChanged.connect(self.onRefreshChanged)
self.clickCheckbox = QCheckBox("Enable Tap", self)
self.clickCheckbox.setEnabled(False)
self.model = DomModel(QDomDocument(), self)
self.mobileTreeView = QTreeView(self)
self.mobileTreeView.setMinimumWidth(300)
self.mobileTreeView.setModel(self.model)
self.mobileTreeView.clicked.connect(self.onTreeViewClicked)
header = ["Attribute", "Value"]
self.tableModel = MyTableModel(self, [], header)
self.mobileTableView = QTableView(self)
self.mobileTableView.setSelectionMode(
QAbstractItemView.SingleSelection)
self.mobileTableView.setModel(self.tableModel)
self.mobileTableView.setContextMenuPolicy(Qt.CustomContextMenu)
self.mobileTableView.customContextMenuRequested.connect(
self.onContextMenuEvent)
self.mobileTableView.setMinimumWidth(300)
mobileViewLayout = QHBoxLayout()
mobileViewLayout.addWidget(self.mobileImageLabel)
mobileViewLayout.addWidget(self.mobileTreeView)
mobileViewLayout.addWidget(self.mobileTableView)
mobileLayout.addWidget(self.mobileDockToolbar)
mobileLayout.addLayout(mobileViewLayout)
self.setLayout(mobileLayout)
def createToolbar(self):
"""
Create qt toolbar
"""
self.mobileDockToolbar.setObjectName("Toolbar")
self.mobileDockToolbar.addWidget(self.refreshCheckbox)
self.mobileDockToolbar.addWidget(self.clickCheckbox)
self.mobileDockToolbar.addSeparator()
self.mobileDockToolbar.addAction(self.refreshAction)
self.mobileDockToolbar.addSeparator()
self.mobileDockToolbar.addWidget(self.screenResolutionLabel)
self.mobileDockToolbar.addSeparator()
self.mobileDockToolbar.addWidget(self.screenTapLabel)
self.mobileDockToolbar.addSeparator()
self.mobileDockToolbar.setIconSize(QSize(16, 16))
def center(self):
"""
Center the dialog
"""
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def eventFilter(self, srcEvent, event):
"""
On event filtering
"""
if srcEvent == self.mobileImageLabel:
if event.type() == QEvent.MouseMove:
x = event.pos().x()
y = event.pos().y()
pixmap = self.mobileImageLabel.pixmap()
if pixmap is not None:
x_scaled = int((self.origWidth * x) / pixmap.width())
y_scaled = int((self.origHeight * y) / pixmap.height())
self.mobileImageLabel.setToolTip("%sx%s" %
(x_scaled, y_scaled))
return False
def onContextMenuEvent(self, event):
"""
On context menu event
"""
menu = QMenu(self)
menu.addAction(self.copyAction)
menu.popup(QCursor.pos())
def copyItem(self):
"""
Copy the item
"""
indexes = self.mobileTableView.selectedIndexes()
if len(indexes):
data = self.tableModel.mylist[indexes[0].row()][
indexes[0].column()]
clipboard = QApplication.clipboard()
clipboard.setText(data)
def onTreeViewClicked(self, qindex):
"""
On click in the treeview
"""
item = qindex.internalPointer()
attributes = []
node = item.node()
attributeMap = node.attributes()
nodeName = node.nodeName()
bounds_str = None
for i in range(0, attributeMap.count()):
attribute = attributeMap.item(i)
attributes.append((attribute.nodeName(), attribute.nodeValue()))
if attribute.nodeName() == 'bounds':
bounds_str = attribute.nodeValue()
self.tableModel.mylist = attributes
if sys.version_info > (3, ):
self.tableModel.beginResetModel()
self.tableModel.endResetModel()
else:
self.tableModel.reset()
self.mobileTableView.resizeColumnsToContents()
self.mobileTableView.resizeRowsToContents()
# redraw image with rectangle
if bounds_str is not None:
xy = bounds_str.split('][')[0].split('[')[1]
wh = bounds_str.split('][')[1].split(']')[0]
x, y = xy.split(',')
w, h = wh.split(',')
# get label size
pixmap = self.mobileImageLabel.pixmap()
xlabel = pixmap.width()
ylabel = pixmap.height()
# resize the rectangle
y_scaled = (pixmap.height() * int(y)) / self.origHeight
x_scaled = (pixmap.width() * int(x)) / self.origWidth
h_scaled = (pixmap.height() * (int(h) - int(y))) / self.origHeight
w_scaled = (pixmap.width() * (int(w) - int(x))) / self.origWidth
# finally reload
self.reloadScreen(x=int(x_scaled),
y=int(y_scaled),
w=int(w_scaled),
h=int(h_scaled))
def onDeviceReady(self):
"""
On device ready
"""
self.refreshAction.setEnabled(True)
self.refreshCheckbox.setEnabled(True)
self.clickCheckbox.setEnabled(True)
def refreshScreen(self):
"""
Refresh the screen
"""
self.RefreshScreen.emit()
def onRefreshChanged(self, state):
"""
On refresh changed
"""
if state == Qt.Checked:
self.RefreshAutomatic.emit(True)
else:
self.RefreshAutomatic.emit(False)
def pixelSelect(self, event):
"""
Select pixel to click
"""
position = QPoint(event.pos().x(), event.pos().y())
x = event.pos().x()
y = event.pos().y()
pixmap = self.mobileImageLabel.pixmap()
x_scaled = int((self.origWidth * x) / pixmap.width())
y_scaled = int((self.origHeight * y) / pixmap.height())
self.screenTapLabel.setText("Tap on (%s,%s)" % (x_scaled, y_scaled))
if self.clickCheckbox.isChecked():
self.TapOn.emit(x_scaled, y_scaled)
def drawRectangle(self, x=0, y=0, w=0, h=0):
"""
Draw a rectangle
"""
self.mobileImageLabel.update()
pixmap = self.mobileImageLabel.pixmap()
if pixmap is not None:
p = QPainter(pixmap)
pen = QPen(Qt.red, 2, Qt.SolidLine)
p.setPen(pen)
p.drawRect(x, y, w, h)
p.end()
def reloadScreen(self, x, y, w, h):
"""
Reload the screen
"""
if self.imagePath is not None:
self.updateScreen(filename=self.imagePath,
xmlPath='',
x=x,
y=y,
w=w,
h=h,
reloadMode=True)
def updateScreen(self,
filename,
xmlPath,
x=0,
y=0,
w=0,
h=0,
reloadMode=False):
"""
Update the screen
"""
self.imagePath = filename
if not reloadMode:
self.tableModel.mylist = []
self.tableModel.beginResetModel()
self.tableModel.endResetModel()
pixmap = QPixmap(filename)
if pixmap is not None:
self.origWidth = pixmap.width()
self.origHeight = pixmap.height()
self.screenResolutionLabel.setText(
"Resolution=%sx%s" % (self.origWidth, self.origHeight))
#portrait
if self.origWidth < self.origHeight:
pixmap = pixmap.scaledToHeight(Settings.getInt(
'MobileAndroid', 'resolution-screen-height'),
mode=Qt.SmoothTransformation)
self.mobileImageLabel.setPixmap(pixmap)
else:
pixmap = pixmap.scaledToWidth(Settings.getInt(
'MobileAndroid', 'resolution-screen-width'),
mode=Qt.SmoothTransformation)
self.mobileImageLabel.setPixmap(pixmap)
self.drawRectangle(x=x, y=y, w=w, h=h)
self.resize(pixmap.width(), pixmap.height())
# convert xml to dict
if len(xmlPath):
f = QFile(xmlPath)
if f.open(QIODevice.ReadOnly):
document = QDomDocument()
if document.setContent(f):
newModel = DomModel(document, self)
self.mobileTreeView.setModel(newModel)
self.mobileTreeView.expandAll()
self.mobileTreeView.resizeColumnToContents(0)
f.close()
class DictValueDialog(QtHelper.EnhancedQDialog, Logger.ClassLogger):
"""
Dict dialog
"""
def __init__(self, parent, testParams, variables, advancedMode=False ):
"""
Operator to fill parameter description
@param dataArgs:
@type dataArgs:
@param parent:
@type parent:
"""
super(DictValueDialog, self).__init__(parent)
self.advancedMode = advancedMode
self.testParams = testParams
self.variables = variables
self.createDialog()
self.createConnections()
self.createActions()
def createDialog (self):
"""
Create qt dialog
"""
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStyleSheet( """QDialogButtonBox {
dialogbuttonbox-buttons-have-icons: 1;
dialog-ok-icon: url(:/ok.png);
dialog-cancel-icon: url(:/test-close-black.png);
}""")
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
mainLayout = QVBoxLayout()
self.dictTable = QTableView(self)
self.model = DictTableModel(self, advancedMode=self.advancedMode)
self.dictTable.setModel(self.model)
self.dictTable.setFrameShape(QFrame.StyledPanel)
self.dictTable.setShowGrid(True)
self.dictTable.setGridStyle (Qt.DotLine)
self.dictTable.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.dictTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.dictTable.setContextMenuPolicy(Qt.CustomContextMenu)
self.dictTable.verticalHeader().setVisible(False)
self.dictTable.horizontalHeader().setHighlightSections(False)
self.dictTable.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.dictTable.horizontalHeader().setStretchLastSection(True)
self.dictTable.setColumnWidth(COL_KEY, 200)
# delegate item on advanced mode
if self.advancedMode:
self.dictTable.setItemDelegateForColumn( COL_KEY, ItemComboDelegate(self, COL_KEY) )
self.dictTable.setItemDelegateForColumn( COL_VALUE, ItemComboDelegate(self, COL_VALUE) )
mainLayout.addWidget(self.dictTable)
mainLayout.addWidget(self.buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle(self.tr("Dict configuration"))
self.setMinimumWidth(500)
self.center()
def getInputs(self):
"""
Get test inputs
"""
return self.testParams.parameters.table().model.getData()
def getOutputs(self):
"""
Get test outputs
"""
return self.testParams.parametersOutput.table().model.getData()
def createConnections (self):
"""
Create qt connections
"""
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.dictTable.customContextMenuRequested.connect(self.onPopupMenu)
def getValue(self):
"""
Return value
"""
return self.model.getData()
def createActions (self):
"""
Actions defined:
* add
* del
"""
self.addAction = QtHelper.createAction(self, self.tr("&Add"), self.addKey, icon = QIcon(":/test-parameter-add.png"),
tip = self.tr('Add a new key') )
self.delAction = QtHelper.createAction(self, self.tr("&Delete"), self.delKey, icon = QIcon(":/test-parameter-del.png"),
tip = self.tr('Delete the selected key') )
self.delAllAction = QtHelper.createAction(self, self.tr("&Delete All"), self.delKeys, icon = QIcon(":/test-parameter-del.png"),
tip = self.tr('Delete the selected key') )
def addKey(self):
"""
Add key
"""
self.delAllAction.setEnabled(True)
index = self.dictTable.currentIndex()
if not index.isValid():
row = self.model.rowCount()
else:
row = index.row()
data = self.model.getData()
if self.advancedMode:
tpl = { 'key': { 'operator': '', 'value': '', 'type': '' }, 'value': { 'operator': '', 'value': '', 'type': '' } }
else:
tpl = { 'key': 'my key', 'value': 'my value' }
# add data to model
data.insert(row + 1, tpl)
self.model.reset()
def clear (self):
"""
clear contents
"""
self.model.setDataModel( [] )
def delKey(self):
"""
Delete key
"""
# get selected proxy indexes
indexes = self.dictTable.selectedIndexes()
if not indexes:
return
if indexes:
answer = QMessageBox.question(self, self.tr("Remove"), self.tr("Do you want to remove selected key?"),
QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.Yes:
self.removeValues(indexes)
def removeValues(self, indexes):
"""
Remove values from data
@param indexes:
@type indexes:
"""
if not indexes:
return
# extract name, name are unique
datas = self.model.getData()
allNames = []
# remove duplicate index
cleanIndexes = {}
for index in indexes:
if index.row() not in cleanIndexes:
cleanIndexes[index.row()] = index
#for cleanIndex in cleanIndexes.keys():
for cleanIndex in list(cleanIndexes.keys()): # for python3 support
allNames.append( datas[cleanIndex]['key'] )
self.trace('Key to remove: %s' % allNames)
for paramName in allNames:
self.removeValue( paramName=paramName )
def removeValue(self, paramName):
"""
Remove one parameter according to the name passed on argument
"""
datas = self.model.getData()
i = None
for i in xrange(len(datas)):
if datas[i]['key'] == paramName:
break
if i is not None:
param = datas.pop( i )
del param
self.model.reset()
def delKeys(self):
"""
Clear all keys
"""
reply = QMessageBox.question(self,
self.tr("Clear all keys"), self.tr("Are you sure ?"),
QMessageBox.Yes | QMessageBox.No
)
if reply == QMessageBox.Yes:
data = self.model.getData()
try:
for i in xrange(len(data)):
data.pop()
except Exception as e:
pass
self.model.reset()
self.delAllAction.setEnabled(False)
def onPopupMenu(self, pos):
"""
Display menu on right click
@param pos:
@type pos:
"""
self.menu = QMenu(self.dictTable)
index = self.dictTable.currentIndex()
indexes = self.dictTable.selectedIndexes()
if not indexes:
self.menu.addAction( self.delAction )
self.menu.addAction( self.addAction )
self.menu.addSeparator()
self.menu.addAction( self.delAllAction )
self.menu.addSeparator()
else:
self.menu.addAction( self.delAction )
self.menu.addAction( self.addAction )
self.menu.addSeparator()
self.menu.addAction( self.delAllAction )
self.menu.addSeparator()
self.menu.popup( self.mapToGlobal(pos) )
def loadData(self, data):
"""
Load data
"""
if isinstance(data, dict):
data = [data]
self.model.setDataModel( data )
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 QgsAttributeTableDialog(QDialog):
'''
classdocs
'''
def __init__(self, parent, vectorlayer):
QDialog.__init__(self, parent)
# self.w = QDialog(self)
self.baseLayer = vectorlayer
self.canChangeAttributes = self.validate(
QgsVectorDataProvider.ChangeAttributeValues)
self.canDeleteFeatures = self.validate(
QgsVectorDataProvider.DeleteFeatures)
self.canAddAttributes = self.validate(
QgsVectorDataProvider.AddAttributes)
self.canDeleteAttributes = self.validate(
QgsVectorDataProvider.DeleteAttributes)
self.canAddFeatures = self.validate(QgsVectorDataProvider.AddFeatures)
gridLayout = QGridLayout(self)
self.setLayout(gridLayout)
self.setWindowTitle("Attribute Table")
self.setFixedSize(QSize(800, 600))
editorToolbar = QToolBar()
editorToolbar.setFixedSize(QSize(768, 48))
self.actionToggleEditing = QAction(QIcon("Resource\\edit.png"),
"ToggleEditing", self)
self.actionToggleEditing.triggered.connect(self.toggleEditing)
if (self.canChangeAttributes or self.canDeleteFeatures
or self.canAddAttributes or self.canDeleteAttributes
or self.canAddFeatures) and (not self.baseLayer.isReadOnly()):
self.actionToggleEditing.setEnabled(True)
else:
self.actionToggleEditing.setEnabled(False)
self.actionToggleEditing.setCheckable(True)
editorToolbar.addAction(self.actionToggleEditing)
self.actionSave = QAction(QIcon("Resource\\filesave.png"),
"Save Edits", self)
self.actionSave.triggered.connect(self.saveEditing)
self.actionSave.setCheckable(False)
self.actionSave.setEnabled(False)
editorToolbar.addAction(self.actionSave)
self.actiondeleteRows = QAction(
QIcon("Resource\\mActionDeleteSelected.png"),
"Delete selected features", self)
self.actiondeleteRows.triggered.connect(self.deleteRows)
self.actiondeleteRows.setCheckable(False)
self.actiondeleteRows.setEnabled(False)
editorToolbar.addAction(self.actiondeleteRows)
self.actionUnselectAll = QAction(
QIcon("Resource\\mActionDeselectAll.png"), "Unselect All", self)
self.actionUnselectAll.triggered.connect(self.unselectAll)
self.actionUnselectAll.setCheckable(False)
self.actionUnselectAll.setEnabled(True)
editorToolbar.addAction(self.actionUnselectAll)
self.actionSelectedToZoom = QAction(
QIcon("Resource\\mActionZoomToSelected.png"),
"Zoom map to the selected rows", self)
self.actionSelectedToZoom.triggered.connect(self.selectedToZoom)
self.actionSelectedToZoom.setCheckable(False)
self.actionSelectedToZoom.setEnabled(True)
editorToolbar.addAction(self.actionSelectedToZoom)
gridLayout.addWidget(editorToolbar, 0, 0, 1, 1)
self.model = QStandardItemModel()
# self.model.itemChanged.connect(self.attributeChanged)
self.attributeTable = QTableView(self)
self.attributeTable.setModel(self.model)
self.attributeTable.setColumnWidth(0, 200)
self.attributeTable.setColumnWidth(1, 160)
self.attributeTable.clicked.connect(self.tableSelectionChanged)
self.attributeTable.setSortingEnabled(True)
self.changeItemList = []
self.selectRows = []
self.isSave = True
self.initTable()
gridLayout.addWidget(self.attributeTable, 1, 0, 1, 1)
# self.attributeTable.selectionChanged.connect(self.selectFeature)
def tableSelectionChanged(self):
idxList = self.attributeTable.selectedIndexes()
if idxList != None and len(idxList) > 0:
self.baseLayer.removeSelection()
fidList = []
for idx in idxList:
fid = int(self.model.item(idx.row()).text())
fidList.append(fid)
self.baseLayer.setSelectedFeatures(fidList)
def toggleEditing(self):
if self.baseLayer != None:
if not self.actionToggleEditing.isChecked():
if self.isSave:
self.baseLayer.commitChanges()
self.actionSave.setEnabled(False)
self.actiondeleteRows.setEnabled(False)
self.model.itemChanged.disconnect(self.attributeChanged)
self.toggleEditingTable(False)
else:
button = QMessageBox.warning(
self, "Stop Editing",
"Do you want to save the changes to layer?",
QMessageBox.Save | QMessageBox.Discard
| QMessageBox.Cancel)
if (button == QMessageBox.Cancel):
self.actionToggleEditing.setChecked(True)
elif button == QMessageBox.Save:
self.saveEditing()
self.baseLayer.commitChanges()
self.actionSave.setEnabled(False)
self.actiondeleteRows.setEnabled(False)
self.model.itemChanged.disconnect(
self.attributeChanged)
self.toggleEditingTable(False)
else:
self.initTable()
self.baseLayer.commitChanges()
self.actionSave.setEnabled(False)
self.actiondeleteRows.setEnabled(False)
self.model.itemChanged.disconnect(
self.attributeChanged)
self.toggleEditingTable(False)
# self.isEditable = False
else:
self.actionSave.setEnabled(True)
self.actiondeleteRows.setEnabled(True)
self.baseLayer.startEditing()
self.toggleEditingTable(True)
self.model.itemChanged.connect(self.attributeChanged)
# self.isEditable = True
def toggleEditingTable(self, isEditable):
columnCount = self.model.columnCount()
rowCount = self.model.rowCount()
col = 0
while col < columnCount:
row = 0
while row < rowCount:
self.model.item(row, col).setEditable(isEditable)
row += 1
col += 1
def attributeChanged(self, standardItem):
self.isSave = False
# if not self.isDelete:
self.changeItemList.append(standardItem)
# featureId = standardItem.row()
# self.baseLayer.changeAttributeValue(featureId,
# standardItem.column(), standardItem.text())
def saveEditing(self):
self.isSave = True
if len(self.changeItemList) > 0:
for standardItem in self.changeItemList:
featureId = standardItem.row()
self.baseLayer.changeAttributeValue(featureId,
standardItem.column(),
standardItem.text())
self.changeItemList = []
if len(self.selectRows) > 0:
for id in self.selectRows:
self.baseLayer.deleteFeature(id)
self.selectRows = []
def initTable(self):
self.model.clear()
# header = QHeaderView(Qt.Horizontal)
# headerModel = QStandardItemModel()
layer = self.baseLayer
fields = layer.pendingFields()
headersList = ["fid"]
for field in fields:
headersList.append(field.name())
self.model.setHorizontalHeaderLabels(headersList)
# headerModel.setHorizontalHeaderLabels(headersList)
# header.setModel(headerModel)
# self.attributeTable.setHorizontalHeader(header)
if len(layer.selectedFeatures()) > 0:
features = layer.selectedFeatures()
else:
features = layer.getFeatures()
for feature in features:
record = [QStandardItem(str(feature.id()))]
for field in feature.fields():
name = field.name()
attribute = feature.attribute(name).toString()
stdItemValue = QStandardItem(attribute)
stdItemValue.setEditable(False)
record.append(stdItemValue)
self.model.appendRow(record)
def deleteRows(self):
if len(self.attributeTable.selectedIndexes()) > 0:
self.isSave = False
selectedIndexs = self.attributeTable.selectedIndexes()
k = -1
self.selectRows = []
for index in selectedIndexs:
if k != index.row():
k = index.row()
self.selectRows.append(k)
for row in self.selectRows:
self.model.takeRow(row)
def unselectAll(self):
if len(self.attributeTable.selectedIndexes()) > 0:
self.attributeTable.clearSelection()
def selectedToZoom(self):
if len(self.attributeTable.selectedIndexes()) > 0:
self.baseLayer.removeSelection()
selectedIndexs = self.attributeTable.selectedIndexes()
k = -1
self.selectRows = []
for index in selectedIndexs:
if k != index.row():
k = index.row()
self.selectRows.append(k)
self.baseLayer.setSelectedFeatures(self.selectRows)
# for row in self.selectRows:
# self.model.takeRow(row)
define._canvas.zoomToSelected(self.baseLayer)
def validate(self, condition):
if self.baseLayer.dataProvider().capabilities() & condition:
return True
else:
return False
