def populateList(self): model = QStandardItemModel() for option in self.selectedoptions: item = QStandardItem(option) model.appendRow(item) self.lstLayers.setModel(model)
def __addFirstRowToModel(self, oldModel, newRow): """ :type oldModel: QAbstractItemModel :type newRow: list :return: QStandardItemModel """ model = QStandardItemModel(self) items = [] for str in newRow: items.append(QStandardItem(str)) model.appendRow(items) for i in xrange(oldModel.rowCount()): items = [] for j in xrange(oldModel.columnCount()): index = QModelIndex(oldModel.index(i, j)) data = oldModel.data(index) item = QStandardItem(data) items.append(item) model.appendRow(items) return model
class PrvTreeviewNest(QTreeView): def __init__(self): super(PrvTreeviewNest, self).__init__() loadUi('treeview_nest.ui') # row can be 0 even when it's more than 0. self._datamodel = QStandardItemModel(0, 2) self.setModel(self._datamodel) for i in range(4): self.add_widget(i + 1) self.show() def add_widget(self, n): std_item = QStandardItem('{}th item'.format(n)) self._datamodel.setItem(n, 0, std_item) node_widget = QPushButton('{}th button'.format(n)) qindex_widget = self._datamodel.index(n, 1, QModelIndex()) self.setIndexWidget(qindex_widget, node_widget) if n == 2: std_item_child = QStandardItem('child') std_item.appendRow(std_item_child) node_widget_child = QPushButton('petit button') qindex_widget_child = self._datamodel.index(n, 1, QModelIndex()) self.setIndexWidget(qindex_widget_child, node_widget_child)
def __init__(self, widget, parent=None): QStandardItemModel.__init__(self, parent) self.setHorizontalHeaderLabels(self.labels) items = [(name, getattr(widget, name)) for name in dir(widget) if not name.startswith('_')] for name, value in sorted(items): self.appendRow(self.makeRowItems(name, value))
def __init__(self): QStandardItemModel.__init__(self) self.layout_changed_sig.connect(self.layout_changed) self.layout_change_to_conn_sig.connect(self.layout_change_to_conn) self.layout_change_to_rule_sig.connect(self.layout_change_to_rule) self.setHorizontalHeaderLabels((u"协议簇",u"类型",u"本地地址", u"本地端口",u"远程地址", u"远程端口", u"状态",u"进程ID",u"进程名"))
def __init__(self, velat, sections, parent=None, change_balance=True): QStandardItemModel.__init__(self, parent) self._velat = velat self._sections = sections self._new_item_name = "this new item" self._new_item_title = "New item" self._change_balance = change_balance
def __init__(self): QStandardItemModel.__init__(self) self.layout_changed_sig.connect(self.layout_changed) self.layout_change_to_conn_sig.connect(self.layout_change_to_conn) self.layout_change_to_rule_sig.connect(self.layout_change_to_rule) self.setHorizontalHeaderLabels(("Family","Type","Local address&port","Remote address&port", "Status","Pid","Name"))
def setupChecklist(widget, names, checks = None): tp = type(widget) # Prepare checks if checks is None: checks = [] for name in names: checks.append(Qt.Unchecked) else: newChecks = [] for check in checks: if check: newChecks.append(Qt.Checked) else: newChecks.append(Qt.Unchecked) checks = newChecks ## QListView if tp is QListView: model = QStandardItemModel() for i in xrange(len(names)): item = QStandardItem(names[i]) item.setCheckable(True) item.setCheckState(checks[i]) model.appendRow(item) widget.setModel(model) ## QListWidget elif tp is QListWidget: for i in xrange(len(names)): item = QListWidgetItem(names[i]) item.setFlags(Qt.ItemFlags(48)) # 48 = checkable(16), enabled(32) item.setCheckState(checks[i]) widget.addItem(item) ## NOT SUPPORTED else: raise TypeError('Class ' + str(tp) + ' is not supported.')
def __init__( self, terms, parent ): items = {} model = QStandardItemModel(parent) for term in terms: parts = str(term).split('.') for i in range(len(parts)): parent_key = '.'.join(parts[:i]) item_key = '.'.join(parts[:i+1]) if ( item_key in items ): continue parent_item = items.get(parent_key) item = QStandardItem(parts[i]) if ( parent_item ): parent_item.appendRow(item) else: model.appendRow(item) items[item_key] = item self._model = model super(XQueryCompleter, self).__init__(model, parent)
def _select_tags(self): tag_dialog = SelectTagsDialog() # if the user has their own taglist, use it user_tag_list = os.path.join(os.path.expanduser("~"), '.plugin_tags.txt') if os.path.exists(user_tag_list): tag_file = user_tag_list else: tag_file = os.path.join(str(self.plugin_builder_path), 'taglist.txt') with open(tag_file) as tf: tags = tf.readlines() model = QStandardItemModel() for tag in tags: item = QStandardItem(tag[:-1]) model.appendRow(item) tag_dialog.listView.setModel(model) tag_dialog.show() ok = tag_dialog.exec_() if ok: selected = tag_dialog.listView.selectedIndexes() seltags = [] for tag in selected: seltags.append(tag.data()) taglist = ", ".join(seltags) self.dialog.tags.setText(taglist)
def test_tooltree(self): tree = ToolTree() role = tree.actionRole() model = QStandardItemModel() tree.setModel(model) item = QStandardItem("One") item.setData(QAction("One", tree), role) model.appendRow([item]) cat = QStandardItem("A Category") item = QStandardItem("Two") item.setData(QAction("Two", tree), role) cat.appendRow([item]) item = QStandardItem("Three") item.setData(QAction("Three", tree), role) cat.appendRow([item]) model.appendRow([cat]) def p(action): print "triggered", action.text() tree.triggered.connect(p) tree.show() self.app.exec_()
def __init__(self, parent=None, items=None): QStandardItemModel.__init__(self, parent) if items is not None: self.insertColumn(0, items) self.__timer = QTimer(self)
def __loadRules(self, the_rules, tree_view): model = QStandardItemModel(self) for r in the_rules: item = QStandardItem(r) model.appendRow(item) model.setHeaderData(0, Qt.Horizontal, "Regular Expression") tree_view.setModel(model)
class CurvePanel(QListView): def __init__(self, curve_source): QListView.__init__(self) self.curve_source = curve_source self.setViewMode(QListView.IconMode) self.setIconSize(QSize(64,64)) self.model = QStandardItemModel() for curve in curve_source._curves: self.add_curve(curve) self.setModel(self.model) self.setWrapping(True) self.show() def edit(self, index, trigger, event): if trigger == QAbstractItemView.DoubleClicked: item = self.model.item(index.row()) curve = item.curve print curve.name() return True else: return False def add_new_curve(self): pass def add_curve(self, curve): name = curve.name() plot = self._create_plot(name) item = PlotItem(plot) item.curve = curve self.model.appendRow(item) def _create_plot(self, xcurve_name): index = self.curve_source.index() return Plot.of(xcurve_name, index.name()).from_(self.curve_source)
def __display_table_rslt(self, table_rows): ''' controls table_comp_rslt widget fill the widget with table_rows list @param table_rows: [] ''' rows_count = len(table_rows) model = QStandardItemModel(rows_count, 3) model.setHorizontalHeaderLabels(TAB_LABELS) # fill model with data for row in range(rows_count): for col in range(3): item = QStandardItem() item.setData(str(table_rows[row][col]), Qt.DisplayRole) model.setItem(row, col, item) # self.table_comp_rslt.clearContents() if self.table_comp_rslt.isSortingEnabled(): self.table_comp_rslt.setSortingEnabled(False) proxy = numsort.NumberSortModel() proxy.setSourceModel(model) self.table_comp_rslt.setModel(proxy) self.table_comp_rslt.resizeColumnsToContents() self.table_comp_rslt.setSortingEnabled(True)
def __init__(self,parrent=None): super(MainWindow,self).__init__(parrent) self.setupUi(self) QtCore.QObject.connect(self.loadFile, QtCore.SIGNAL(mainWindow._fromUtf8("clicked()")), self.loadFile_btn_Kliked) QtCore.QObject.connect(self.testPlagia_btn, QtCore.SIGNAL(mainWindow._fromUtf8("clicked()")), self.plagiaStrat_btn) QtCore.QObject.connect(self.repport_btn, QtCore.SIGNAL(mainWindow._fromUtf8("clicked()")), self.repport) QtCore.QObject.connect(self.sava_btn, QtCore.SIGNAL(mainWindow._fromUtf8("clicked()")), self.saveFile) QtCore.QObject.connect(self.actionNew_File, QtCore.SIGNAL(mainWindow._fromUtf8("triggered()")), self.loadFile_btn_Kliked) QtCore.QObject.connect(self.actionADD_user, QtCore.SIGNAL(mainWindow._fromUtf8("triggered()")), self.addUser) QtCore.QObject.connect(self.actionSetting, QtCore.SIGNAL(mainWindow._fromUtf8("triggered()")), self.setting) #QtCore.QObject.connect(self.docs_Rsult_ListView, QtCore.SIGNAL(mainWindow._fromUtf8("clicked()")), self.listViewChange) QtCore.QObject.connect(self.docs_Rsult_ListView, QtCore.SIGNAL(mainWindow._fromUtf8("clicked(QModelIndex)")), self.listViewChange) QtCore.QObject.connect(self.docs_Rsult_ListView_2, QtCore.SIGNAL(mainWindow._fromUtf8("clicked(QModelIndex)")), self.listViewWebChange) self.userName_label.setText(self.userName) self.dialogDoc=addDocImpl.AddDocD() self.addUserDia=AddUserDia() self.settingD=SettingDiaIm() self.dialogMe=errorDiaImpl.ErrorDia() self.modelList=QStandardItemModel(self.docs_Rsult_ListView) self.modelListWeb=QStandardItemModel(self.docs_Rsult_ListView_2) self.setting=self.dataM.getSetting() self.sava_btn.setEnabled(False) self.repport_btn.setEnabled(False)
def __init__(self, __parent = None, event=False, fm = False): """ Model constructor. Create the default QStandardItem's for the default nodes. """ QStandardItemModel.__init__(self, __parent) EventHandler.__init__(self) self.__parent = __parent self.VFS = VFS.Get() self.ch = False # init translation self.translation() # creating qstandarditem for the default nodes (the four displayed nodes when dff is launched) self.root_item = self.invisibleRootItem() tmp = self.VFS.GetNode("/").children() item_list = [] for i in tmp: node_item = QStandardItem(i.name()) node_item.setData(QVariant(long(i.this)), Qt.UserRole + 1) node_item.setData(QVariant(False), Qt.UserRole + 2) item_list.append(node_item) if len(item_list): self.root_item.appendRows(item_list) if event: self.VFS.connection(self)
def __init__(self, __parent = None): QStandardItemModel.__init__(self, __parent) self.__parent = __parent self.regmap = {} self.indexmap = {} if self.createRegMap(): self.createRootItems()
def createComboBoxWithStrings(self, array): dbList = QComboBox() dbsListModel = QStandardItemModel(dbList) for f in array: item = QStandardItem(f) dbsListModel.appendRow(item) dbList.setModel(dbsListModel) return dbList
class BreakpointsViewer(QTreeView): """ showing bps """ 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.bp_data = QStandardItemModel() self.setModel(self.bp_data) self.setAlternatingRowColors(True) def set_focus_signal(self, signal): """ set callback to focus source file line""" self.focus_signal = signal def clear(self): """ clear the widget""" self.bp_data.clear() self.bp_data.setHorizontalHeaderLabels(['ID', 'Hits', 'Ignore Count', 'Condition']) def update_bp_info(self, target): """ update breakpoint info """ self.clear() root = self.bp_data.invisibleRootItem() for breakpoint in target.breakpoint_iter(): if not breakpoint.IsValid() or breakpoint.IsInternal(): continue bp_item = QStandardItem(str(breakpoint.id)) bp_row =[bp_item, QStandardItem(str(breakpoint.GetHitCount())), QStandardItem(str(breakpoint.GetIgnoreCount())), QStandardItem(str(breakpoint.GetCondition()))] for loc in breakpoint: loc_row = [QStandardItem(str(loc.GetID())), QStandardItem(str(loc.GetAddress().GetLineEntry()))] bp_item.appendRow(loc_row) root.appendRow(bp_row) self.expandToDepth(1) 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 populateList(self): model = QStandardItemModel() for i, option in enumerate(self.options): item = QStandardItem(option) item.setCheckState(Qt.Checked if i in self.selectedoptions else Qt.Unchecked) item.setCheckable(True) model.appendRow(item) self.lstLayers.setModel(model)
def __init__(self, name, layer_type, neurons_count, inputs, minWeight, maxWeight, *__args): QStandardItemModel.__init__(self, *__args) self.setHorizontalHeaderLabels(LayerModel.DEFAULT_HEADER) self.name = name self.type = layer_type self.minWeight = minWeight self.maxWeight = maxWeight self.set_neurons(neurons_count) self.set_input_neurons(inputs)
def on_show_history_wifi_name(self): self.history_wifi_list = get_history_connected_wifi() model = QStandardItemModel(self.showWIFIListView) # Get each history wifi name for wifi_name in self.history_wifi_list: item = QStandardItem(wifi_name) # Add the item to the model model.appendRow(item) self.showWIFIListView.setModel(model) self.showWIFIListView.show()
def __init__(self, *args): COMCUPluginBase.__init__(self, BrickletGPSV2, *args) self.setupUi(self) self.gps = self.device self.cbe_universal = CallbackEmulator(self.get_universal, self.cb_universal, self.increase_error_count) self.cbe_universal_gps = CallbackEmulator( self.get_universal_gps, self.cb_universal_gps, self.increase_error_count ) self.cbe_universal_glo = CallbackEmulator( self.get_universal_glo, self.cb_universal_glo, self.increase_error_count ) self.qtcb_pps.connect(self.cb_pps) self.gps.register_callback(self.gps.CALLBACK_PULSE_PER_SECOND, self.qtcb_pps.emit) self.format_combobox.currentIndexChanged.connect(self.format_changed) self.show_pos.clicked.connect(self.show_pos_clicked) self.hot_start.clicked.connect(lambda: self.restart_clicked(0)) self.warm_start.clicked.connect(lambda: self.restart_clicked(1)) self.cold_start.clicked.connect(lambda: self.restart_clicked(2)) self.factory_reset.clicked.connect(lambda: self.restart_clicked(3)) self.had_fix = False self.last_lat = 0 self.last_ns = "U" self.last_long = 0 self.last_ew = "U" self.gps_counter = 0 self.glo_counter = 0 self.gps_model = QStandardItemModel(32, 3, self) self.gps_table.setModel(self.gps_model) self.gps_model.setHorizontalHeaderItem(0, QStandardItem(u"Elevation (°)")) self.gps_model.setHorizontalHeaderItem(1, QStandardItem(u"Azimuth (°)")) self.gps_model.setHorizontalHeaderItem(2, QStandardItem(u"SNR (dB)")) for i in range(32): self.gps_model.setVerticalHeaderItem(i, QStandardItem(u"Sat " + str(i + 1))) self.gps_table.horizontalHeader().setResizeMode(QHeaderView.Stretch) self.glo_model = QStandardItemModel(32, 3, self) self.glo_table.setModel(self.glo_model) self.glo_model.setHorizontalHeaderItem(0, QStandardItem(u"Elevation (°)")) self.glo_model.setHorizontalHeaderItem(1, QStandardItem(u"Azimuth (°)")) self.glo_model.setHorizontalHeaderItem(2, QStandardItem(u"SNR (dB)")) for i in range(32): self.glo_model.setVerticalHeaderItem(i, QStandardItem(u"Sat " + str(i + 1 + 64))) self.glo_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
def __init__(self): QStandardItemModel.__init__(self) role_names = { self.foo: "", self.nama: "nama", self.userPicture: "userpicture", self.address: "address", self.realname: "realname", self.locked: "locked" } self.setRoleNames(role_names)
def __init__(self): """ Constructor. """ QStandardItemModel.__init__(self) self._rowItemMap = dict() self._itemRowMap = dict() self.setColumnCount(4) # principal, content, properties, administration self._headers = [self.tr(constants.PRINCIPAL_COLUMN_NAME), self.tr(constants.CONTENT_PRIVILEGE_COLUMN_NAME), self.tr(constants.PROPERTY_PRIVILEGE_COLUMN_NAME), self.tr(constants.ADMINISTRATION_PRIVILEGE_COLUMN_NAME)]
def _configure_model(self): model = QStandardItemModel(0, 3, self) # Set headers headers = [ self.tr('Name'), self.tr('Data Type'), self.tr('Description') ] model.setHorizontalHeaderLabels(headers) self.setModel(model)
def __init__(self, model): """ Constructor. @param model: The repository model. @type model: L{<RepositoryModel>datafinder.gui.user.models.repository.repository.RepositoryModel} """ QStandardItemModel.__init__(self) self._model = model self._currentResult = SPECIAL_PRINCIPALS self.enableCurrentResult()
def __init__(self): QStandardItemModel.__init__(self) self.rootItem = self.invisibleRootItem() self.setHorizontalHeaderLabels(['Element']) self.files = {} import Icons self.icons = { 'file' : QIcon(QPixmap(Icons.ncFile)), 'variable' : QIcon(QPixmap(Icons.ncVar)), 'dimension' : QIcon(QPixmap(Icons.ncDim)), 'attribute' : QIcon(QPixmap(Icons.ncAtt)) }
def update_commands(self,meas_prog_list_byname): global Regexprogramfile Regexprogramfile="("+"|".join(meas_prog_list_byname)+")" self.valid_list_of_commands = self.get_list_of_commands() #initiate syntax highlighting for the macro editor self.highlighter = MacroHighlighter(self.ui.macro_textbox.document(),self.valid_list_of_commands) #update the list of available macro commands in the user interface model=QStandardItemModel() parentItem = model.invisibleRootItem() for command in self.valid_list_of_commands: parentItem.appendRow(QStandardItem(command.label)) self.ui.macrocommandtree.setModel(model)
def __init__(self): super().__init__() self.data = None self.km = None self.optimization_runs = [] box = gui.vBox(self.controlArea, "Number of Clusters") layout = QGridLayout() self.n_clusters = bg = gui.radioButtonsInBox(box, self, "optimize_k", [], orientation=layout, callback=self.update) layout.addWidget( gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1) sb = gui.hBox(None, margin=0) 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 from", addToLayout=False), 2, 1) ftobox = gui.hBox(None) ftobox.layout().setContentsMargins(0, 0, 0, 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.vBox(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.hBox(None, margin=0) 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.hBox(None, margin=0) layout.addWidget(sb, 1, 1) gui.lineEdit(sb, self, "max_iterations", controlWidth=60, valueType=int, validator=QIntValidator(), callback=self.update) box = gui.vBox(self.controlArea, "Output") gui.comboBox(box, self, "place_cluster_ids", label="Append cluster ID as:", orientation=Qt.Horizontal, callback=self.send_data, items=self.OUTPUT_METHODS) gui.lineEdit(box, self, "output_name", label="Name:", orientation=Qt.Horizontal, callback=self.send_data) gui.separator(self.buttonsArea, 30) self.apply_button = gui.auto_commit(self.buttonsArea, self, "auto_run", "Apply", box=None) gui.rubber(self.controlArea) self.table_model = QStandardItemModel(self) self.table_model.setHorizontalHeaderLabels(["k", "Score"]) self.table_model.setColumnCount(2) self.table_box = gui.vBox(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 __init__(self, parent=None): super(CheckableComboBox, self).__init__(parent) self.view().pressed.connect(self.handleItemPressed) self.setModel(QStandardItemModel(self))
class ConfigManagerDialog(ui_configmanager.Ui_ProjectInstallerDialog, QDialog): def __init__(self, roamapp, parent=None): super(ConfigManagerDialog, self).__init__(parent) self.setupUi(self) self.bar = roam.messagebaritems.MessageBar(self) self.roamapp = roamapp # Nope! self.projectwidget.roamapp = roamapp self.projectwidget.bar = self.bar self.treemodel = QStandardItemModel() self.projectList.setModel(self.treemodel) self.projectList.setHeaderHidden(True) self.projectList.selectionModel().currentChanged.connect( self.nodeselected) self.projectwidget.adjustSize() self.setWindowFlags(Qt.Window) self.projectwidget.projectupdated.connect(self.projectupdated) self.projectwidget.setaboutinfo() self.projectwidget.projects_page.projectlocationchanged.connect( self.loadprojects) self.setuprootitems() ConfigEvents.deleteForm.connect(self.delete_form) def raiseerror(self, *exinfo): self.bar.pushError(*exinfo) import roam.errors roam.errors.send_exception(exinfo) def setuprootitems(self): rootitem = self.treemodel.invisibleRootItem() self.roamnode = RoamNode() rootitem.appendRow(self.roamnode) self.projectsnode = ProjectsNode(folder=None) rootitem.appendRow(self.projectsnode) self.pluginsnode = PluginsNode() pluginpath = os.path.join(self.roamapp.apppath, "plugins") rootitem.appendRow(self.pluginsnode) self.pluginsnode.add_plugin_paths([pluginpath]) def delete_form(self): index = self.projectList.currentIndex() node = index.data(Qt.UserRole) if not node.type() == Treenode.FormNode: return title, removemessage = node.removemessage delete = node.canremove if node.canremove and removemessage: button = QMessageBox.warning(self, title, removemessage, QMessageBox.Yes | QMessageBox.No) delete = button == QMessageBox.Yes print "Delete" if delete: parentindex = index.parent() newindex = self.treemodel.index(index.row(), 0, parentindex) if parentindex.isValid(): parent = parentindex.data(Qt.UserRole) parent.delete(index.row()) print parentindex self.projectList.setCurrentIndex(parentindex) def delete_project(self): index = self.projectList.currentIndex() node = index.data(Qt.UserRole) if node.type() == Treenode.ProjectNode: self.projectwidget._closeqgisproject() title, removemessage = node.removemessage delete = node.canremove if node.canremove and removemessage: button = QMessageBox.warning(self, title, removemessage, QMessageBox.Yes | QMessageBox.No) delete = button == QMessageBox.Yes if delete: parentindex = index.parent() newindex = self.treemodel.index(index.row(), 0, parentindex) if parentindex.isValid(): parent = parentindex.data(Qt.UserRole) parent.delete(index.row()) self.projectList.setCurrentIndex(newindex) def addprojectfolders(self, folders): self.projectwidget.projects_page.setprojectfolders(folders) def loadprojects(self, projectpath): projects = roam.project.getProjects([projectpath]) self.projectsnode.loadprojects(projects, projectsbase=projectpath) index = self.treemodel.indexFromItem(self.projectsnode) self.projectList.setCurrentIndex(index) self.projectList.expand(index) def nodeselected(self, index, _): node = index.data(Qt.UserRole) if node is None: return project = node.project if project and not self.projectwidget.project == project: # Only load the project if it's different the current one. self.projectwidget.setproject(project) node.create_children() validateresults = list(project.validate()) if validateresults: text = "Here are some reasons we found: \n\n" for message in validateresults: text += "- {} \n".format(message) self.projectwidget.reasons_label.setText(text) if node.nodetype == Treenode.RoamNode: self.projectwidget.projectlabel.setText( "IntraMaps Roam Config Manager") if node.nodetype == Treenode.AddNew: try: item = node.additem() except ValueError: return newindex = self.treemodel.indexFromItem(item) self.projectList.setCurrentIndex(newindex) return self.projectwidget.projectbuttonframe.setVisible(not project is None) self.projectwidget.setpage(node.page, node) def projectupdated(self): index = self.projectList.currentIndex() node = find_node(index) node.refresh()
def __init__(self, parent=None): super().__init__(parent) self.train_data = None self.test_data = None #: An Ordered dictionary with current inputs and their testing #: results. self.learners = OrderedDict() sbox = gui.widgetBox(self.controlArea, "Sampling") rbox = gui.radioButtons(sbox, self, "resampling", callback=self._param_changed) gui.appendRadioButton(rbox, "Cross validation") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:", callback=self._param_changed) gui.appendRadioButton(rbox, "Leave one out") gui.appendRadioButton(rbox, "Random sampling") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test", callback=self._param_changed) gui.widgetLabel(ibox, "Relative training set size:") gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100, ticks=20, vertical=False, callback=self._param_changed) gui.appendRadioButton(rbox, "Test on train data") gui.appendRadioButton(rbox, "Test on test data") rbox.layout().addSpacing(5) gui.button(rbox, self, "Apply", callback=self.apply) gui.rubber(self.controlArea) self.view = QTreeView(rootIsDecorated=False, uniformRowHeights=True, wordWrap=True, editTriggers=QTreeView.NoEditTriggers) self.result_model = QStandardItemModel() self.view.setModel(self.result_model) self._update_header() box = gui.widgetBox(self.mainArea, "Evaluation Results") box.layout().addWidget(self.view)
def initParametersPan(self): ui = Ui_GeoDetermine() self.parametersPanel = ui FlightPlanBaseDlg.initParametersPan(self) self.parametersPanel.pnlStartPosP = PositionPanel( self.parametersPanel.gbStartPosP, None, None, "Degree") # self.parametersPanel.pnlStartPosP.degreeFormat = "ddmmss.ssssH" self.parametersPanel.pnlStartPosP.alwwaysShowString = "Degree" # self.parametersPanel.pnlWaypoint.groupBox.setTitle("FAWP") self.parametersPanel.pnlStartPosP.btnCalculater.hide() self.parametersPanel.pnlStartPosP.hideframe_Altitude() # self.parametersPanel.pnlStartPosP.showframe_ID() self.parametersPanel.pnlStartPosP.setObjectName("pnlStartPosP") self.connect(self.parametersPanel.pnlStartPosP, SIGNAL("positionChanged"), self.autoCalcFinishMagVar) ui.verticalLayout_gbStartPosP.addWidget( self.parametersPanel.pnlStartPosP) self.parametersPanel.pnlVarStartP = DegreesBoxPanel(self) self.parametersPanel.pnlVarStartP.CaptionLabel = "Magnetic Variation" self.connect(self.parametersPanel.pnlVarStartP, SIGNAL("btnDegreeBoxPanel_clicked"), self.method_32_P) self.connect(self.parametersPanel.pnlVarStartP, SIGNAL("txtDegreeBox_textChanged"), self.txtDegreeBox_textChangedP) ui.verticalLayout_gbStartPosP.addWidget( self.parametersPanel.pnlVarStartP) self.parametersPanel.pnlVarFinishP = DegreesBoxPanel(self) self.parametersPanel.pnlVarFinishP.ButtonVisible = False self.parametersPanel.pnlVarFinishP.Enabled = False self.parametersPanel.pnlVarFinishP.CaptionLabel = "Magnetic Variation at Finish" ui.vLayout_grbParametersP.insertWidget( 1, self.parametersPanel.pnlVarFinishP) # self.connect(self.parametersPanel.pnlVarStartP, SIGNAL("btnDegreeBoxPanel_clicked"), self.method_32_P) self.parametersPanel.pnlStartPosBD = PositionPanel( self.parametersPanel.gbFinishPosBD, None, None, "Degree") # self.parametersPanel.pnlStartPosBD.groupBox.setTitle("FAWP") # self.parametersPanel.pnlStartPosBD.degreeFormat = "ddmmss.ssssH" self.parametersPanel.pnlStartPosBD.alwwaysShowString = "Degree" self.parametersPanel.pnlStartPosBD.btnCalculater.hide() self.parametersPanel.pnlStartPosBD.hideframe_Altitude() self.parametersPanel.pnlStartPosBD.showframe_ID() self.parametersPanel.pnlStartPosBD.setObjectName("pnlStartPosBD") ui.verticalLayout_gbStartPosBD.insertWidget( 0, self.parametersPanel.pnlStartPosBD) self.connect(self.parametersPanel.pnlStartPosBD, SIGNAL("positionChanged"), self.positionChangedStartBD) self.parametersPanel.pnlVarStartBD = DegreesBoxPanel(self) self.parametersPanel.pnlVarStartBD.CaptionLabel = "Magnetic Variation" # self.parametersPanel.pnlVarStartBD.Enabled = False self.connect(self.parametersPanel.pnlVarStartBD, SIGNAL("btnDegreeBoxPanel_clicked"), self.method_34_BD) # self.connect(self.parametersPanel.pnlVarStartBD, SIGNAL("txtDegreeBox_textChanged"), self.txtDegreeBox_textChangedP) ui.verticalLayout_gbStartPosBD.addWidget( self.parametersPanel.pnlVarStartBD) self.parametersPanel.pnlFinishPosBD = PositionPanel( self.parametersPanel.gbFinishPosBD, None, None, "Degree") # self.parametersPanel.pnlStartPosBD.groupBox.setTitle("FAWP") # self.parametersPanel.pnlFinishPosBD.degreeFormat = "ddmmss.ssssH" self.parametersPanel.pnlFinishPosBD.alwwaysShowString = "Degree" self.parametersPanel.pnlFinishPosBD.btnCalculater.hide() self.parametersPanel.pnlFinishPosBD.hideframe_Altitude() self.parametersPanel.pnlFinishPosBD.showframe_ID() self.parametersPanel.pnlFinishPosBD.setObjectName("pnlFinishPosBD") ui.verticalLayout_gbFinishPosBD.insertWidget( 0, self.parametersPanel.pnlFinishPosBD) self.connect(self.parametersPanel.pnlFinishPosBD, SIGNAL("positionChanged"), self.positionChangedFinishBD) self.parametersPanel.pnlVarFinishBD = DegreesBoxPanel(self) self.parametersPanel.pnlVarFinishBD.CaptionLabel = "Magnetic Variation" # self.parametersPanel.pnlVarFinishBD.Enabled = False self.connect(self.parametersPanel.pnlVarFinishBD, SIGNAL("btnDegreeBoxPanel_clicked"), self.method_36_BD) # self.connect(self.parametersPanel.pnlVarFinishBD, SIGNAL("txtDegreeBox_textChanged"), self.txtDegreeBox_textChangedP) ui.verticalLayout_gbFinishPosBD.addWidget( self.parametersPanel.pnlVarFinishBD) self.parametersPanel.pnlPositionMVD = PositionPanel( self.parametersPanel.tabGeoDetermineMV, None, None, "Degree") self.parametersPanel.pnlPositionMVD.groupBox.setTitle("Position") self.parametersPanel.pnlPositionMVD.alwwaysShowString = "Degree" self.parametersPanel.pnlPositionMVD.btnCalculater.hide() self.parametersPanel.pnlPositionMVD.setObjectName("pnlPositionMVD") ui.verticalLayout_3.insertWidget(0, self.parametersPanel.pnlPositionMVD) self.connect(self.parametersPanel.pnlPositionMVD, SIGNAL("positionChanged"), self.method_28_MVD) self.connect(self.parametersPanel.txtForwardTP, SIGNAL("Event_0"), self.txtForwardTP_textChanged) self.connect(self.parametersPanel.chbAutoFinishMagVar, SIGNAL("Event_0"), self.chbAutoFinishMagVar_clicked) self.connect(self.parametersPanel.txtDistanceP, SIGNAL("Event_0"), self.autoCalcFinishMagVar) self.connect(self.parametersPanel.txtForwardMP, SIGNAL("Event_0"), self.txtForwardMP_textChanged) self.parametersPanel.btnResultP.clicked.connect( self.btnResultP_clicked) self.parametersPanel.tabGeneral.currentChanged.connect( self.tabGeneral_CurrentChanged) self.parametersPanel.chbAutoVarBD.clicked.connect( self.chbAutoVarBD_clicked) self.parametersPanel.dtpDate.dateChanged.connect(self.method_28_MVD) self.connect(self.parametersPanel.cmbModel, SIGNAL("Event_0"), self.method_28_MVD) self.parametersPanel.btnDtpDate.clicked.connect( self.btnDtpDate_clicked) self.resultModelP = QStandardItemModel() self.parametersPanel.tblResultP.setModel(self.resultModelP) self.resultModelBD = QStandardItemModel() self.parametersPanel.tblResultBD.setModel(self.resultModelBD) self.ttt = 0 self.txtForwardTP_textChanged() self.setHistoryData() self.autoVarSet = False self.dateBD = QDate.currentDate() self.modelBD = MagneticModel.WMM2010 self.parametersPanel.btnResultBD.setVisible(False) self.parametersPanel.dtpDate.setDate(QDate.currentDate()) self.calendar = QCalendarWidget() self.calendar.clicked.connect(self.calendar_clicked) self.menu = QMenu() layout = QVBoxLayout(self.menu) layout.addWidget(self.calendar)
def __init__(self, iface, db, parent=None): QWidget.__init__(self, parent) self.iface = iface self.db = db self.allowMultiColumnPk = isinstance( db, PGDatabase ) # at the moment only PostGIS allows a primary key to span multiple columns, spatialite doesn't self.setupUi(self) self.setWindowTitle( u"%s - %s [%s]" % (self.windowTitle(), db.connection().connectionName(), db.connection().typeNameString())) self.defaultLayerName = 'QueryLayer' if self.allowMultiColumnPk: self.uniqueColumnCheck.setText( self.trUtf8("Column(s) with unique values")) else: self.uniqueColumnCheck.setText( self.trUtf8("Column with unique values")) self.editSql.setFocus() self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.initCompleter() # allow to copy results copyAction = QAction("copy", self) self.viewResult.addAction(copyAction) copyAction.setShortcuts(QKeySequence.Copy) copyAction.triggered.connect(self.copySelectedResults) self.btnExecute.clicked.connect(self.executeSql) self.btnClear.clicked.connect(self.clearSql) self.presetStore.clicked.connect(self.storePreset) self.presetDelete.clicked.connect(self.deletePreset) self.presetCombo.activated[str].connect(self.loadPreset) self.presetCombo.activated[str].connect(self.presetName.setText) self.updatePresetsCombobox() self.geomCombo.setEditable(True) self.geomCombo.lineEdit().setReadOnly(True) self.uniqueCombo.setEditable(True) self.uniqueCombo.lineEdit().setReadOnly(True) self.uniqueModel = QStandardItemModel(self.uniqueCombo) self.uniqueCombo.setModel(self.uniqueModel) if self.allowMultiColumnPk: self.uniqueCombo.setItemDelegate(QStyledItemDelegate()) self.uniqueModel.itemChanged.connect( self.uniqueChanged) # react to the (un)checking of an item self.uniqueCombo.lineEdit().textChanged.connect( self.uniqueTextChanged ) # there are other events that change the displayed text and some of them can not be caught directly # hide the load query as layer if feature is not supported self._loadAsLayerAvailable = self.db.connector.hasCustomQuerySupport() self.loadAsLayerGroup.setVisible(self._loadAsLayerAvailable) if self._loadAsLayerAvailable: self.layerTypeWidget.hide() # show if load as raster is supported self.loadLayerBtn.clicked.connect(self.loadSqlLayer) self.getColumnsBtn.clicked.connect(self.fillColumnCombos) self.loadAsLayerGroup.toggled.connect(self.loadAsLayerToggled) self.loadAsLayerToggled(False) self._createViewAvailable = self.db.connector.hasCreateSpatialViewSupport( ) self.btnCreateView.setVisible(self._createViewAvailable) if self._createViewAvailable: self.btnCreateView.clicked.connect(self.createView) self.queryBuilderFirst = True self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif")) self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder) self.presetName.textChanged.connect(self.nameChanged)
class OWTestLearners(widget.OWWidget): name = "Test & Score" description = "Cross-validation accuracy estimation." icon = "icons/TestLearners1.svg" priority = 100 inputs = [("Learner", Learner, "set_learner", widget.Multiple), ("Data", Table, "set_train_data", widget.Default), ("Test Data", Table, "set_test_data"), ("Preprocessor", Preprocess, "set_preprocessor")] outputs = [("Predictions", Orange.data.Table), ("Evaluation Results", Orange.evaluation.Results)] settingsHandler = settings.ClassValuesContextHandler() #: Resampling/testing types KFold, LeaveOneOut, ShuffleSplit, TestOnTrain, TestOnTest = 0, 1, 2, 3, 4 #: Selected resampling type resampling = settings.Setting(0) #: Number of folds for K-fold cross validation k_folds = settings.Setting(10) #: Number of repeats for ShuffleSplit sampling n_repeat = settings.Setting(10) #: ShuffleSplit sampling p sample_p = settings.Setting(75) TARGET_AVERAGE = "(Average over classes)" class_selection = settings.ContextSetting(TARGET_AVERAGE) def __init__(self): super().__init__() self.data = None self.test_data = None self.preprocessor = None self.train_data_missing_vals = False self.test_data_missing_vals = False #: An Ordered dictionary with current inputs and their testing #: results. self.learners = OrderedDict() sbox = gui.widgetBox(self.controlArea, "Sampling") rbox = gui.radioButtons(sbox, self, "resampling", callback=self._param_changed) gui.appendRadioButton(rbox, "Cross validation") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:", callback=self.kfold_changed) gui.appendRadioButton(rbox, "Leave one out") gui.appendRadioButton(rbox, "Random sampling") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test", callback=self.shuffle_split_changed) gui.widgetLabel(ibox, "Relative training set size:") gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=99, ticks=20, vertical=False, labelFormat="%d %%", callback=self.shuffle_split_changed) gui.appendRadioButton(rbox, "Test on train data") gui.appendRadioButton(rbox, "Test on test data") rbox.layout().addSpacing(5) self.apply_button = gui.button(rbox, self, "Apply", callback=self.apply, default=True) self.cbox = gui.widgetBox(self.controlArea, "Target class") self.class_selection_combo = gui.comboBox( self.cbox, self, "class_selection", items=[], sendSelectedValue=True, valueType=str, callback=self._on_target_class_changed, contentsLength=8) gui.rubber(self.controlArea) self.view = QTreeView(rootIsDecorated=False, uniformRowHeights=True, wordWrap=True, editTriggers=QTreeView.NoEditTriggers) header = self.view.header() header.setResizeMode(QHeaderView.ResizeToContents) header.setDefaultAlignment(Qt.AlignCenter) header.setStretchLastSection(False) self.result_model = QStandardItemModel(self) self.result_model.setHorizontalHeaderLabels(["Method"]) self.view.setModel(self.result_model) self.view.setItemDelegate(ItemDelegate()) box = gui.widgetBox(self.mainArea, "Evaluation Results") box.layout().addWidget(self.view) def sizeHint(self): return QSize(780, 1) def set_learner(self, learner, key): """ Set the input `learner` for `key`. """ if key in self.learners and learner is None: # Removed del self.learners[key] else: self.learners[key] = Input(learner, None, None) self._invalidate([key]) def set_train_data(self, data): """ Set the input training dataset. """ self.error(0) self.information(0) if data and not data.domain.class_var: self.error(0, "Train data input requires a class variable") data = None if isinstance(data, SqlTable): if data.approx_len() < AUTO_DL_LIMIT: data = Table(data) else: self.information(0, "Train data has been sampled") data_sample = data.sample_time(1, no_cache=True) data_sample.download_data(AUTO_DL_LIMIT, partial=True) data = Table(data_sample) self.warning(4) self.train_data_missing_vals = data is not None and \ np.isnan(data.Y).any() if self.train_data_missing_vals or self.test_data_missing_vals: self.warning( 4, self._get_missing_data_warning(self.train_data_missing_vals, self.test_data_missing_vals)) if data: data = RemoveNaNClasses(data) self.data = data self.closeContext() if data is not None: self._update_class_selection() self.openContext(data.domain.class_var) self._invalidate() def set_test_data(self, data): """ Set the input separate testing dataset. """ self.error(1) self.information(1) if data and not data.domain.class_var: self.error(1, "Test data input requires a class variable") data = None if isinstance(data, SqlTable): if data.approx_len() < AUTO_DL_LIMIT: data = Table(data) else: self.information(1, "Test data has been sampled") data_sample = data.sample_time(1, no_cache=True) data_sample.download_data(AUTO_DL_LIMIT, partial=True) data = Table(data_sample) self.warning(4) self.test_data_missing_vals = data is not None and \ np.isnan(data.Y).any() if self.train_data_missing_vals or self.test_data_missing_vals: self.warning( 4, self._get_missing_data_warning(self.train_data_missing_vals, self.test_data_missing_vals)) if data: data = RemoveNaNClasses(data) self.test_data = data if self.resampling == OWTestLearners.TestOnTest: self._invalidate() def _get_missing_data_warning(self, train_missing, test_missing): return "Instances with unknown target values were removed from{}data"\ .format(train_missing * test_missing * " " or train_missing * " train " or test_missing * " test ") def set_preprocessor(self, preproc): """ Set the input preprocessor to apply on the training data. """ self.preprocessor = preproc self._invalidate() def handleNewSignals(self): """Reimplemented from OWWidget.handleNewSignals.""" self._update_class_selection() self.apply() def kfold_changed(self): self.resampling = OWTestLearners.KFold self._param_changed() def shuffle_split_changed(self): self.resampling = OWTestLearners.ShuffleSplit self._param_changed() def _param_changed(self): self._invalidate() def _update_results(self): """ Run/evaluate the learners. """ self.warning([1, 2]) self.error(2) if self.data is None: return class_var = self.data.domain.class_var if self.resampling == OWTestLearners.TestOnTest: if self.test_data is None: self.warning(2, "Missing separate test data input") return elif self.test_data.domain.class_var != class_var: self.error(2, ("Inconsistent class variable between test " + "and train data sets")) return # items in need of an update items = [(key, slot) for key, slot in self.learners.items() if slot.results is None] learners = [slot.learner for _, slot in items] if len(items) == 0: return if self.test_data is not None and \ self.resampling != OWTestLearners.TestOnTest: self.warning( 1, "Test data is present but unused. " "Select 'Test on test data' to use it.") rstate = 42 def update_progress(finished): self.progressBarSet(100 * finished) common_args = dict(store_data=True, preprocessor=self.preprocessor, callback=update_progress) self.setStatusMessage("Running") self.progressBarInit() try: if self.resampling == OWTestLearners.KFold: warnings = [] results = Orange.evaluation.CrossValidation( self.data, learners, k=self.k_folds, random_state=rstate, warnings=warnings, **common_args) if warnings: self.warning(2, warnings[0]) elif self.resampling == OWTestLearners.LeaveOneOut: results = Orange.evaluation.LeaveOneOut( self.data, learners, **common_args) elif self.resampling == OWTestLearners.ShuffleSplit: train_size = self.sample_p / 100 results = Orange.evaluation.ShuffleSplit( self.data, learners, n_resamples=self.n_repeat, train_size=train_size, test_size=None, random_state=rstate, **common_args) elif self.resampling == OWTestLearners.TestOnTrain: results = Orange.evaluation.TestOnTrainingData( self.data, learners, **common_args) elif self.resampling == OWTestLearners.TestOnTest: results = Orange.evaluation.TestOnTestData( self.data, self.test_data, learners, **common_args) else: assert False except RuntimeError as e: self.error(2, str(e)) self.setStatusMessage("") self.progressBarFinished() return learner_key = { slot.learner: key for key, slot in self.learners.items() } for learner, result in zip(learners, split_by_model(results)): stats = None if class_var.is_discrete: scorers = classification_stats.scores elif class_var.is_continuous: scorers = regression_stats.scores else: scorers = None if scorers: ex = result.failed[0] if ex: stats = [Try.Fail(ex)] * len(scorers) result = Try.Fail(ex) else: stats = [Try(lambda: score(result)) for score in scorers] result = Try.Success(result) key = learner_key[learner] self.learners[key] = \ self.learners[key]._replace(results=result, stats=stats) self.setStatusMessage("") self.progressBarFinished() def _update_header(self): # Set the correct horizontal header labels on the results_model. headers = ["Method"] if self.data is not None: if self.data.domain.has_discrete_class: headers.extend(classification_stats.headers) else: headers.extend(regression_stats.headers) # remove possible extra columns from the model. for i in reversed(range(len(headers), self.result_model.columnCount())): self.result_model.takeColumn(i) self.result_model.setHorizontalHeaderLabels(headers) def _update_stats_model(self): # Update the results_model with up to date scores. # Note: The target class specific scores (if requested) are # computed as needed in this method. model = self.view.model() # clear the table model, but preserving the header labels for r in reversed(range(model.rowCount())): model.takeRow(r) target_index = None if self.data is not None: class_var = self.data.domain.class_var if class_var.is_discrete and \ self.class_selection != self.TARGET_AVERAGE: target_index = class_var.values.index(self.class_selection) else: class_var = None errors = [] has_missing_scores = False for key, slot in self.learners.items(): name = learner_name(slot.learner) head = QStandardItem(name) head.setData(key, Qt.UserRole) if isinstance(slot.results, Try.Fail): head.setToolTip(str(slot.results.exception)) head.setText("{} (error)".format(name)) head.setForeground(QtGui.QBrush(Qt.red)) errors.append("{name} failed with error:\n" "{exc.__class__.__name__}: {exc!s}".format( name=name, exc=slot.results.exception)) row = [head] if class_var is not None and class_var.is_discrete and \ target_index is not None: if slot.results is not None and slot.results.success: ovr_results = results_one_vs_rest(slot.results.value, target_index) stats = [ Try(lambda: score(ovr_results)) for score in classification_stats.scores ] else: stats = None else: stats = slot.stats if stats is not None: for stat in stats: item = QStandardItem() if stat.success: item.setText("{:.3f}".format(stat.value[0])) else: item.setToolTip(str(stat.exception)) has_missing_scores = True row.append(item) model.appendRow(row) if errors: self.error(3, "\n".join(errors)) else: self.error(3) if has_missing_scores: self.warning(3, "Some scores could not be computed") else: self.warning(3) def _update_class_selection(self): self.class_selection_combo.setCurrentIndex(-1) self.class_selection_combo.clear() if not self.data: return if self.data.domain.has_discrete_class: self.cbox.setVisible(True) class_var = self.data.domain.class_var items = [self.TARGET_AVERAGE] + class_var.values self.class_selection_combo.addItems(items) class_index = 0 if self.class_selection in class_var.values: class_index = class_var.values.index(self.class_selection) + 1 self.class_selection_combo.setCurrentIndex(class_index) self.class_selection = items[class_index] else: self.cbox.setVisible(False) def _on_target_class_changed(self): self._update_stats_model() def _invalidate(self, which=None): # Invalidate learner results for `which` input keys # (if None then all learner results are invalidated) if which is None: which = self.learners.keys() model = self.view.model() statmodelkeys = [ model.item(row, 0).data(Qt.UserRole) for row in range(model.rowCount()) ] for key in which: self.learners[key] = \ self.learners[key]._replace(results=None, stats=None) if key in statmodelkeys: row = statmodelkeys.index(key) for c in range(1, model.columnCount()): item = model.item(row, c) if item is not None: item.setData(None, Qt.DisplayRole) item.setData(None, Qt.ToolTipRole) self.apply_button.setEnabled(True) def apply(self): self.apply_button.setEnabled(False) self._update_header() # Update the view to display the model names self._update_stats_model() self._update_results() self._update_stats_model() self.commit() def commit(self): valid = [ slot for slot in self.learners.values() if slot.results is not None and slot.results.success ] if valid: # Evaluation results combined = results_merge([slot.results.value for slot in valid]) combined.learner_names = [ learner_name(slot.learner) for slot in valid ] # Predictions & Probabilities predictions = combined.get_augmented_data(combined.learner_names) else: combined = None predictions = None self.send("Evaluation Results", combined) self.send("Predictions", predictions)
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 DlgSqlWindow(QWidget, Ui_Dialog): nameChanged = pyqtSignal(str) def __init__(self, iface, db, parent=None): QWidget.__init__(self, parent) self.iface = iface self.db = db self.allowMultiColumnPk = isinstance( db, PGDatabase ) # at the moment only PostGIS allows a primary key to span multiple columns, spatialite doesn't self.setupUi(self) self.setWindowTitle( u"%s - %s [%s]" % (self.windowTitle(), db.connection().connectionName(), db.connection().typeNameString())) self.defaultLayerName = 'QueryLayer' if self.allowMultiColumnPk: self.uniqueColumnCheck.setText( self.trUtf8("Column(s) with unique values")) else: self.uniqueColumnCheck.setText( self.trUtf8("Column with unique values")) self.editSql.setFocus() self.editSql.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.initCompleter() # allow to copy results copyAction = QAction("copy", self) self.viewResult.addAction(copyAction) copyAction.setShortcuts(QKeySequence.Copy) copyAction.triggered.connect(self.copySelectedResults) self.btnExecute.clicked.connect(self.executeSql) self.btnClear.clicked.connect(self.clearSql) self.presetStore.clicked.connect(self.storePreset) self.presetDelete.clicked.connect(self.deletePreset) self.presetCombo.activated[str].connect(self.loadPreset) self.presetCombo.activated[str].connect(self.presetName.setText) self.updatePresetsCombobox() self.geomCombo.setEditable(True) self.geomCombo.lineEdit().setReadOnly(True) self.uniqueCombo.setEditable(True) self.uniqueCombo.lineEdit().setReadOnly(True) self.uniqueModel = QStandardItemModel(self.uniqueCombo) self.uniqueCombo.setModel(self.uniqueModel) if self.allowMultiColumnPk: self.uniqueCombo.setItemDelegate(QStyledItemDelegate()) self.uniqueModel.itemChanged.connect( self.uniqueChanged) # react to the (un)checking of an item self.uniqueCombo.lineEdit().textChanged.connect( self.uniqueTextChanged ) # there are other events that change the displayed text and some of them can not be caught directly # hide the load query as layer if feature is not supported self._loadAsLayerAvailable = self.db.connector.hasCustomQuerySupport() self.loadAsLayerGroup.setVisible(self._loadAsLayerAvailable) if self._loadAsLayerAvailable: self.layerTypeWidget.hide() # show if load as raster is supported self.loadLayerBtn.clicked.connect(self.loadSqlLayer) self.getColumnsBtn.clicked.connect(self.fillColumnCombos) self.loadAsLayerGroup.toggled.connect(self.loadAsLayerToggled) self.loadAsLayerToggled(False) self._createViewAvailable = self.db.connector.hasCreateSpatialViewSupport( ) self.btnCreateView.setVisible(self._createViewAvailable) if self._createViewAvailable: self.btnCreateView.clicked.connect(self.createView) self.queryBuilderFirst = True self.queryBuilderBtn.setIcon(QIcon(":/db_manager/icons/sql.gif")) self.queryBuilderBtn.clicked.connect(self.displayQueryBuilder) self.presetName.textChanged.connect(self.nameChanged) def updatePresetsCombobox(self): self.presetCombo.clear() names = [] entries = QgsProject.instance().subkeyList('DBManager', 'savedQueries') for entry in entries: name = QgsProject.instance().readEntry( 'DBManager', 'savedQueries/' + entry + '/name')[0] names.append(name) for name in sorted(names): self.presetCombo.addItem(name) self.presetCombo.setCurrentIndex(-1) def storePreset(self): query = self._getSqlQuery() if query == "": return name = self.presetName.text() QgsProject.instance().writeEntry( 'DBManager', 'savedQueries/q' + unicode(name.__hash__()) + '/name', name) QgsProject.instance().writeEntry( 'DBManager', 'savedQueries/q' + unicode(name.__hash__()) + '/query', query) index = self.presetCombo.findText(name) if index == -1: self.presetCombo.addItem(name) self.presetCombo.setCurrentIndex(self.presetCombo.count() - 1) else: self.presetCombo.setCurrentIndex(index) def deletePreset(self): name = self.presetCombo.currentText() QgsProject.instance().removeEntry( 'DBManager', 'savedQueries/q' + unicode(name.__hash__())) self.presetCombo.removeItem(self.presetCombo.findText(name)) self.presetCombo.setCurrentIndex(-1) def loadPreset(self, name): query = QgsProject.instance().readEntry( 'DBManager', 'savedQueries/q' + unicode(name.__hash__()) + '/query')[0] name = QgsProject.instance().readEntry( 'DBManager', 'savedQueries/q' + unicode(name.__hash__()) + '/name')[0] self.editSql.setText(query) def loadAsLayerToggled(self, checked): self.loadAsLayerGroup.setChecked(checked) self.loadAsLayerWidget.setVisible(checked) if checked: self.fillColumnCombos() def clearSql(self): self.editSql.clear() self.editSql.setFocus() def executeSql(self): sql = self._getSqlQuery() if sql == "": return QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) # delete the old model old_model = self.viewResult.model() self.viewResult.setModel(None) if old_model: old_model.deleteLater() cols = [] quotedCols = [] try: # set the new model model = self.db.sqlResultModel(sql, self) self.viewResult.setModel(model) self.lblResult.setText( self.tr("%d rows, %.1f seconds") % (model.affectedRows(), model.secs())) cols = self.viewResult.model().columnNames() for col in cols: quotedCols.append(self.db.connector.quoteId(col)) except BaseError as e: QApplication.restoreOverrideCursor() DlgDbError.showError(e, self) self.uniqueModel.clear() self.geomCombo.clear() return self.setColumnCombos(cols, quotedCols) self.update() QApplication.restoreOverrideCursor() def loadSqlLayer(self): hasUniqueField = self.uniqueColumnCheck.checkState() == Qt.Checked if hasUniqueField: if self.allowMultiColumnPk: checkedCols = [] for item in self.uniqueModel.findItems("*", Qt.MatchWildcard): if item.checkState() == Qt.Checked: checkedCols.append(item.data()) uniqueFieldName = ",".join(checkedCols) elif self.uniqueCombo.currentIndex() >= 0: uniqueFieldName = self.uniqueModel.item( self.uniqueCombo.currentIndex()).data() else: uniqueFieldName = None else: uniqueFieldName = None hasGeomCol = self.hasGeometryCol.checkState() == Qt.Checked if hasGeomCol: geomFieldName = self.geomCombo.currentText() else: geomFieldName = None query = self._getSqlQuery() if query == "": return # remove a trailing ';' from query if present if query.strip().endswith(';'): query = query.strip()[:-1] QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) from qgis.core import QgsMapLayer, QgsMapLayerRegistry layerType = QgsMapLayer.VectorLayer if self.vectorRadio.isChecked( ) else QgsMapLayer.RasterLayer # get a new layer name names = [] for layer in QgsMapLayerRegistry.instance().mapLayers().values(): names.append(layer.name()) layerName = self.layerNameEdit.text() if layerName == "": layerName = self.defaultLayerName newLayerName = layerName index = 1 while newLayerName in names: index += 1 newLayerName = u"%s_%d" % (layerName, index) # create the layer layer = self.db.toSqlLayer(query, geomFieldName, uniqueFieldName, newLayerName, layerType, self.avoidSelectById.isChecked()) if layer.isValid(): QgsMapLayerRegistry.instance().addMapLayers([layer], True) QApplication.restoreOverrideCursor() def fillColumnCombos(self): query = self._getSqlQuery() if query == "": return QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) # get a new alias aliasIndex = 0 while True: alias = "_%s__%d" % ("subQuery", aliasIndex) escaped = re.compile('\\b("?)' + re.escape(alias) + '\\1\\b') if not escaped.search(query): break aliasIndex += 1 # remove a trailing ';' from query if present if query.strip().endswith(';'): query = query.strip()[:-1] # get all the columns cols = [] quotedCols = [] connector = self.db.connector sql = u"SELECT * FROM (%s\n) AS %s LIMIT 0" % ( unicode(query), connector.quoteId(alias)) c = None try: c = connector._execute(None, sql) cols = connector._get_cursor_columns(c) for col in cols: quotedCols.append(connector.quoteId(col)) except BaseError as e: QApplication.restoreOverrideCursor() DlgDbError.showError(e, self) self.uniqueModel.clear() self.geomCombo.clear() return finally: if c: c.close() del c self.setColumnCombos(cols, quotedCols) QApplication.restoreOverrideCursor() def setColumnCombos(self, cols, quotedCols): # get sensible default columns. do this before sorting in case there's hints in the column order (eg, id is more likely to be first) try: defaultGeomCol = next( col for col in cols if col in ['geom', 'geometry', 'the_geom', 'way']) except: defaultGeomCol = None try: defaultUniqueCol = [col for col in cols if 'id' in col][0] except: defaultUniqueCol = None colNames = sorted(zip(cols, quotedCols)) newItems = [] uniqueIsFilled = False for (col, quotedCol) in colNames: item = QStandardItem(col) item.setData(quotedCol) item.setEnabled(True) item.setCheckable(self.allowMultiColumnPk) item.setSelectable(not self.allowMultiColumnPk) if self.allowMultiColumnPk: matchingItems = self.uniqueModel.findItems(col) if matchingItems: item.setCheckState(matchingItems[0].checkState()) uniqueIsFilled = uniqueIsFilled or matchingItems[ 0].checkState() == Qt.Checked else: item.setCheckState(Qt.Unchecked) newItems.append(item) if self.allowMultiColumnPk: self.uniqueModel.clear() self.uniqueModel.appendColumn(newItems) self.uniqueChanged() else: previousUniqueColumn = self.uniqueCombo.currentText() self.uniqueModel.clear() self.uniqueModel.appendColumn(newItems) if self.uniqueModel.findItems(previousUniqueColumn): self.uniqueCombo.setEditText(previousUniqueColumn) uniqueIsFilled = True oldGeometryColumn = self.geomCombo.currentText() self.geomCombo.clear() self.geomCombo.addItems(cols) self.geomCombo.setCurrentIndex( self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly)) # set sensible default columns if the columns are not already set try: if self.geomCombo.currentIndex() == -1: self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol)) except: pass items = self.uniqueModel.findItems(defaultUniqueCol) if items and not uniqueIsFilled: if self.allowMultiColumnPk: items[0].setCheckState(Qt.Checked) else: self.uniqueCombo.setEditText(defaultUniqueCol) try: pass except: pass def copySelectedResults(self): if len(self.viewResult.selectedIndexes()) <= 0: return model = self.viewResult.model() # convert to string using tab as separator text = model.headerToString("\t") for idx in self.viewResult.selectionModel().selectedRows(): text += "\n" + model.rowToString(idx.row(), "\t") QApplication.clipboard().setText(text, QClipboard.Selection) QApplication.clipboard().setText(text, QClipboard.Clipboard) def initCompleter(self): dictionary = None if self.db: dictionary = self.db.connector.getSqlDictionary() if not dictionary: # use the generic sql dictionary from .sql_dictionary import getSqlDictionary dictionary = getSqlDictionary() wordlist = [] for name, value in dictionary.iteritems(): wordlist += value # concat lists wordlist = list(set(wordlist)) # remove duplicates api = QsciAPIs(self.editSql.lexer()) for word in wordlist: api.add(word) api.prepare() self.editSql.lexer().setAPIs(api) def displayQueryBuilder(self): dlg = QueryBuilderDlg(self.iface, self.db, self, reset=self.queryBuilderFirst) self.queryBuilderFirst = False r = dlg.exec_() if r == QDialog.Accepted: self.editSql.setText(dlg.query) def createView(self): name, ok = QInputDialog.getText(None, "View name", "View name") if ok: try: self.db.connector.createSpatialView(name, self._getSqlQuery()) except BaseError as e: DlgDbError.showError(e, self) def _getSqlQuery(self): sql = self.editSql.selectedText() if len(sql) == 0: sql = self.editSql.text() return sql def uniqueChanged(self): # when an item is (un)checked, simply trigger an update of the combobox text self.uniqueTextChanged(None) def uniqueTextChanged(self, text): # Whenever there is new text displayed in the combobox, check if it is the correct one and if not, display the correct one. checkedItems = [] for item in self.uniqueModel.findItems("*", Qt.MatchWildcard): if item.checkState() == Qt.Checked: checkedItems.append(item.text()) label = ", ".join(checkedItems) if text != label: self.uniqueCombo.setEditText(label)
def randomize_groups(self): #participant_list_form = Participant_list() #participant_list_form.show() #participant_list_form.ui3.label.setText("sdsdfdsf") #ex2.ui.label_6.setText("test") participant_list_form = ex3 # participant_list_form = Participant_list() # participant_list_form.show() tv = participant_list_form.ui3.tableView # set the table model tablemdata = 0 #tabledata.append([2, 2, 2, 2, 2]) # tabledata.remove([0]) # tabledata.append([1, 1, 1, 1, 1]) # table.model().layoutChanged.emit() tablemodel = MyTableModel(tabledata, header, self) rowcount = int(tablemodel.rowCount(None)) tvmodel = tv.model() nums = [x+1 for x in range(rowcount)] random.shuffle(nums) print nums #iterating list #print i+1 % groups_to_create # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # init widgets view = ex8.ui8.treeView view.setSelectionBehavior(QAbstractItemView.SelectRows) model = QStandardItemModel() model.setHorizontalHeaderLabels(header) view.setModel(model) view.setUniformRowHeights(True) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # populate data groups_to_create = int(self.ui.lineEdit.text()) participants_in_group = int(self.ui.lineEdit_2.text()) divider = 0 group = 1 parent1 = QStandardItem('Grupa {}'.format(group)) for i, val in enumerate(nums): if divider == participants_in_group: divider = 0 group = group + 1 parent1 = QStandardItem('Grupa {}'.format(group)) divider = divider + 1 if val != 0: print "Grupa " + str(group) + " Osoby: " + str(val) self.tableindex_id = tablemodel.index (val-1,1) self.tableindex_surname = tablemodel.index (val-1,2) child1 = QStandardItem(str(val)+' '+" ") child2 = QStandardItem(str(tablemodel.data(self.tableindex_id, Qt.DisplayRole))) child3 = QStandardItem(str(tablemodel.data(self.tableindex_surname, Qt.DisplayRole))) parent1.appendRow([child1, child2, child3]) model.appendRow(parent1) # span container columns view.setFirstColumnSpanned(i, view.rootIndex(), True) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # expand third container index = model.indexFromItem(parent1) view.expand(index) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # select last row selmod = view.selectionModel() index2 = model.indexFromItem(child3) selmod.select(index2, QItemSelectionModel.Select | QItemSelectionModel.Rows) # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ print i+1 if i+1 > 3: print i / groups_to_create else: print i / groups_to_create #index = tablemodel.index(row, 1) print nums
def __init__(self, *args): QWidget.__init__(self, *args) self.setContentsMargins(0, 0, 0, 0) gridLayout = QGridLayout() gridLayout.setContentsMargins(0, 0, 0, 0) gridLayout.setSpacing(1) model = QStandardItemModel(self) model.rowsInserted.connect(self.__changed) model.rowsRemoved.connect(self.__changed) model.dataChanged.connect(self.__changed) self._listView = QListView(self) self._listView.setModel(model) # self._listView.setDragEnabled(True) self._listView.setDropIndicatorShown(True) self._listView.setDragDropMode(QListView.InternalMove) self._listView.viewport().setAcceptDrops(True) self._listView.setMinimumHeight(100) gridLayout.addWidget(self._listView, 0, 0, 2, 2) vButtonLayout = QVBoxLayout() self._upAction = QAction("\u2191", self, toolTip="Move up") self._upButton = QToolButton(self) self._upButton.setDefaultAction(self._upAction) self._upButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding) self._downAction = QAction("\u2193", self, toolTip="Move down") self._downButton = QToolButton(self) self._downButton.setDefaultAction(self._downAction) self._downButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding) vButtonLayout.addWidget(self._upButton) vButtonLayout.addWidget(self._downButton) gridLayout.addLayout(vButtonLayout, 0, 2, 2, 1) hButtonLayout = QHBoxLayout() self._addAction = QAction("+", self) self._addButton = QToolButton(self) self._addButton.setDefaultAction(self._addAction) self._removeAction = QAction("-", self) self._removeButton = QToolButton(self) self._removeButton.setDefaultAction(self._removeAction) hButtonLayout.addWidget(self._addButton) hButtonLayout.addWidget(self._removeButton) hButtonLayout.addStretch(10) gridLayout.addLayout(hButtonLayout, 2, 0, 1, 2) self.setLayout(gridLayout) self._addAction.triggered.connect(self._onAddAction) self._removeAction.triggered.connect(self._onRemoveAction) self._upAction.triggered.connect(self._onUpAction) self._downAction.triggered.connect(self._onDownAction)
class GeoDetermineDlg(FlightPlanBaseDlg): HistoryDataP = [] HistoryDataBD = [] HistoryDataMV = [] def __init__(self, parent): FlightPlanBaseDlg.__init__(self, parent) self.setObjectName("HoldingRnavDlg") self.surfaceType = SurfaceTypes.GeoDetermine self.initParametersPan() self.setWindowTitle(SurfaceTypes.GeoDetermine) self.resize(540, 550) self.surfaceList = None self.date = QDate.currentDate() self.model = MagneticModel.WMM2010 geo = Geo() self.resultLayerList = [] self.resultPoint3d = None self.resultLat = None self.resultLon = None def uiStateInit(self): self.ui.grbMostCritical.setVisible(False) self.ui.grbResult_2.setVisible(False) self.ui.btnUpdateQA.setVisible(False) self.ui.btnUpdateQA_2.setVisible(False) self.ui.btnExportResult.setVisible(False) self.ui.btnEvaluate.setVisible(False) self.ui.btnPDTCheck.setVisible(False) self.ui.frm_cmbObstSurface.setVisible(False) self.ui.tabCtrlGeneral.removeTab(1) icon = QIcon() icon.addPixmap(QPixmap(("Resource/Calculator.bmp")), QIcon.Normal, QIcon.Off) self.ui.btnConstruct.setIcon(icon) self.ui.btnConstruct.setToolTip("Calculate") return FlightPlanBaseDlg.uiStateInit(self) def tblHistory_Click(self, modelIndex): if modelIndex != None: if self.parametersPanel.tabGeneral.currentIndex() == 0: dataList = GeoDetermineDlg.HistoryDataP[modelIndex.row()] self.parametersPanel.pnlStartPosP.Point3d = Point3D( float(dataList[1][1]), float(dataList[1][0])) self.parametersPanel.pnlVarStartP.Value = float(dataList[1][2]) self.parametersPanel.txtForwardTP.Value = float(dataList[1][3]) self.parametersPanel.txtForwardMP.Value = float(dataList[1][4]) self.parametersPanel.txtDistanceP.Value = Distance( float(dataList[1][5]), DistanceUnits.NM) self.parametersPanel.pnlVarFinishP.Value = float( dataList[1][9]) self.method_29_P() self.resultModelP.setItem(0, 0, QStandardItem(Captions.LATITUDE)) self.resultModelP.setItem(0, 1, QStandardItem(dataList[1][7])) self.resultModelP.setItem(1, 0, QStandardItem(Captions.LONGITUDE)) self.resultModelP.setItem(1, 1, QStandardItem(dataList[1][8])) self.resultModelP.setItem( 2, 0, QStandardItem(Captions.REVERSE_TRUE_BEARING)) self.resultModelP.setItem(2, 1, QStandardItem(dataList[1][10])) self.resultModelP.setItem( 3, 0, QStandardItem(Captions.REVERSE_MAGNETIC_BEARING)) self.resultModelP.setItem(3, 1, QStandardItem(dataList[1][11])) elif self.parametersPanel.tabGeneral.currentIndex() == 1: dataList = GeoDetermineDlg.HistoryDataBD[modelIndex.row()] self.parametersPanel.pnlStartPosBD.ID = dataList[1][0] self.parametersPanel.pnlStartPosBD.Point3d = Point3D( float(dataList[1][2]), float(dataList[1][1])) self.parametersPanel.pnlVarStartBD.Value = float( dataList[1][3]) self.parametersPanel.pnlFinishPosBD.ID = dataList[1][4] self.parametersPanel.pnlFinishPosBD.Point3d = Point3D( float(dataList[1][6]), float(dataList[1][5])) self.parametersPanel.pnlVarFinishBD.Value = float( dataList[1][7]) self.method_31_BD() self.resultModelBD.setItem( 0, 0, QStandardItem(Captions.FORWARD_TRUE_BEARING)) self.resultModelBD.setItem(0, 1, QStandardItem(dataList[1][8])) self.resultModelBD.setItem( 1, 0, QStandardItem(Captions.FORWARD_MAGNETIC_BEARING)) self.resultModelBD.setItem(1, 1, QStandardItem(dataList[1][9])) self.resultModelBD.setItem( 2, 0, QStandardItem(Captions.REVERSE_TRUE_BEARING)) self.resultModelBD.setItem(2, 1, QStandardItem(dataList[1][10])) self.resultModelBD.setItem( 3, 0, QStandardItem(Captions.REVERSE_MAGNETIC_BEARING)) self.resultModelBD.setItem(3, 1, QStandardItem(dataList[1][11])) self.resultModelBD.setItem( 2, 0, QStandardItem(Captions.DISTANCE_BETWEEN_POSITIONS)) self.resultModelBD.setItem(2, 1, QStandardItem(dataList[1][12])) self.resultModelBD.setItem( 3, 0, QStandardItem(Captions.DISTANCE_BETWEEN_POSITIONS)) self.resultModelBD.setItem(3, 1, QStandardItem(dataList[1][13])) else: dataList = GeoDetermineDlg.HistoryDataMV[modelIndex.row()] self.parametersPanel.pnlPositionMVD.Point3d = Point3D( float(dataList[1][1]), float(dataList[1][0])) self.parametersPanel.pnlPositionMVD.txtAltitudeM.setText( dataList[1][2]) self.parametersPanel.txtResult.Value = dataList[1][6] def calculateP(self): degree = None degree1 = None degree2 = None degree3 = None num = None result, degree, degree1 = self.parametersPanel.pnlStartPosP.method_3() if (result): # self.pnlVarStart.Value.smethod_17(); num1 = float(self.parametersPanel.pnlVarFinishP.Value) value = float(self.parametersPanel.txtForwardTP.Value) value1 = float(self.parametersPanel.txtForwardTP.Value) distance = self.parametersPanel.txtDistanceP.Value result, degree2, degree3, num = Geo.smethod_6( self.parametersPanel.cmbCalculationTypeP.SelectedItem, degree, degree1, value, distance) if (result): num2 = MathHelper.smethod_3(num - num1) self.method_29_P() self.resultPoint3d = Point3D(degree3, degree2) self.resultLat = degree2 self.resultLon = degree3 latStr = Degrees(degree2, None, None, DegreesType.Latitude).ToString() self.resultModelP.setItem(0, 0, QStandardItem(Captions.LATITUDE)) self.resultModelP.setItem(0, 1, QStandardItem(latStr)) lonStr = Degrees(degree3, None, None, DegreesType.Longitude).ToString() if String.Str2QString(lonStr).mid(0, 1) == "0": lonStr = String.Str2QString(lonStr).mid( 1, String.Str2QString(lonStr).length() - 1) self.resultModelP.setItem(1, 0, QStandardItem(Captions.LONGITUDE)) self.resultModelP.setItem(1, 1, QStandardItem(lonStr)) self.resultModelP.setItem( 2, 0, QStandardItem(Captions.REVERSE_TRUE_BEARING)) self.resultModelP.setItem(2, 1, QStandardItem(str(round(num, 4)))) self.resultModelP.setItem( 3, 0, QStandardItem(Captions.REVERSE_MAGNETIC_BEARING)) self.resultModelP.setItem(3, 1, QStandardItem(str(round(num2, 4)))) dataList = [] dataList.append([ "Latitude (Start)", "Longitude (Start)", "Variation (Start)", "Forward (° T)", "Forward (° M)", "Distance (nm)", "Distance (km)", "Latitude (Finish)", "Longitude (Finish)", "Variation (Finish)", "Reverse (° T)", "Reverse (° M)" ]) dataList.append([ str(degree), str(degree1), str(self.parametersPanel.pnlVarStartP.Value), str(self.parametersPanel.txtForwardTP.Value), str(self.parametersPanel.txtForwardMP.Value), str(distance.NauticalMiles), str(distance.Kilometres), str(degree2), str(degree3), str(self.parametersPanel.pnlVarFinishP.Value), str(round(num, 4)), str(round(num2, 4)) ]) GeoDetermineDlg.HistoryDataP.append(dataList) self.setDataInHistoryModel(dataList) self.method_28_P(degree2, degree3) def calculateBD(self): degree = None degree1 = None degree2 = None degree3 = None num = None result, degree, degree1 = self.parametersPanel.pnlStartPosBD.method_3() if (result): num2 = self.parametersPanel.pnlVarStartBD.Value result1, degree2, degree3 = self.parametersPanel.pnlFinishPosBD.method_3( ) if (result1): num3 = self.parametersPanel.pnlVarFinishBD.Value result2, distance, num, num1 = Geo.smethod_4( self.parametersPanel.cmbCalculationTypeBD.SelectedItem, degree, degree1, degree2, degree3) if define._units == QGis.Meters: QgisHelper.convertMeasureUnits(QGis.Degrees) distance = Distance( MathHelper.calcDistance( self.parametersPanel.pnlStartPosBD.Point3d, self.parametersPanel.pnlFinishPosBD.Point3d)) QgisHelper.convertMeasureUnits(QGis.Meters) else: distance = Distance( MathHelper.calcDistance( self.parametersPanel.pnlStartPosBD.Point3d, self.parametersPanel.pnlFinishPosBD.Point3d)) if result2: num4 = MathHelper.smethod_3(num - num2) num5 = MathHelper.smethod_3(num1 - num3) self.method_31_BD() self.resultModelBD.setItem( 0, 0, QStandardItem(Captions.FORWARD_TRUE_BEARING)) self.resultModelBD.setItem( 0, 1, QStandardItem(str(round(num, 4)))) self.resultModelBD.setItem( 1, 0, QStandardItem(Captions.FORWARD_MAGNETIC_BEARING)) self.resultModelBD.setItem( 1, 1, QStandardItem(str(round(num4, 4)))) self.resultModelBD.setItem( 2, 0, QStandardItem(Captions.REVERSE_TRUE_BEARING)) self.resultModelBD.setItem( 2, 1, QStandardItem(str(round(num1, 4)))) self.resultModelBD.setItem( 3, 0, QStandardItem(Captions.REVERSE_MAGNETIC_BEARING)) self.resultModelBD.setItem( 3, 1, QStandardItem(str(round(num5, 4)))) self.resultModelBD.setItem( 4, 0, QStandardItem(Captions.DISTANCE_BETWEEN_POSITIONS)) self.resultModelBD.setItem( 4, 1, QStandardItem( str(round(distance.NauticalMiles, 4)) + " nm")) self.resultModelBD.setItem( 5, 0, QStandardItem(Captions.DISTANCE_BETWEEN_POSITIONS)) self.resultModelBD.setItem( 5, 1, QStandardItem( str(round(distance.Kilometres, 4)) + " km")) dataList = [] dataList.append([ "ID (Start)", "Latitude (Start)", "Longitude (Start)", "Variation (Start)", "ID (Finish)", "Latitude (Finish)", "Longitude (Finish)", "Variation (Finish)", "Forward (° T)", "Forward (° M)", "Reverse (° T)", "Reverse (° M)", "Distance (nm)", "Distance (km)" ]) dataList.append([ self.parametersPanel.pnlStartPosBD.ID, str(degree), str(degree1), str(self.parametersPanel.pnlVarStartBD.Value), self.parametersPanel.pnlFinishPosBD.ID, str(degree2), str(degree3), str(self.parametersPanel.pnlVarFinishBD.Value), str(num), str(num4), str(round(num, 4)), str(round(num2, 4)), str(distance.NauticalMiles), str(distance.Kilometres) ]) GeoDetermineDlg.HistoryDataBD.append(dataList) self.setDataInHistoryModel(dataList) self.method_28_BD() def calculateMVD(self): degree = None degree1 = None degree2 = None result, degree, degree1 = self.parametersPanel.pnlPositionMVD.method_3( ) # position.method_1(out degree, out degree1); altitude = self.parametersPanel.pnlPositionMVD.Altitude() result, degree2 = Geo.smethod_7( degree, degree1, altitude, self.parametersPanel.cmbModel.SelectedIndex, self.parametersPanel.dtpDate.date()) if (result): self.parametersPanel.txtResult.Value = str(round( degree2, 4)) #.method_1(Formats.VariationFormat); date = self.parametersPanel.dtpDate.date() dataList = [] dataList.append([ "Latitude", "Longitude", "Altitude (m)", "Altitude (ft)", "Date", "Magnetic Model", "Magnetic Variation" ]) dataList.append([ str(degree), str(degree1), str(altitude.Metres), str(altitude.Feet), date.toString(), self.parametersPanel.cmbModel.SelectedItem, self.parametersPanel.txtResult.Value ]) GeoDetermineDlg.HistoryDataMV.append(dataList) self.setDataInHistoryModel(dataList) def autoCalcFinishMagVar(self): try: if self.parametersPanel.chbAutoFinishMagVar.Checked: finishPt = None finishLat = None finishLon = None degree3 = None num = None result, degree, degree1 = self.parametersPanel.pnlStartPosP.method_3( ) if (result): value = float(self.parametersPanel.txtForwardTP.Value) value1 = float(self.parametersPanel.txtForwardTP.Value) distance = self.parametersPanel.txtDistanceP.Value result1, degree2, degree3, num = Geo.smethod_6( self.parametersPanel.cmbCalculationTypeP.SelectedItem, degree, degree1, value, distance) if (result1): finishPt = Point3D(degree3, degree2) finishLat = degree2 finishLon = degree3 if finishPt != None and self.model != None and self.date != None: # result, degree, degree1 = self.parametersPanel.pnlStartPosP.method_3(); result2, degree2 = Geo.smethod_7(finishLat, finishLon, Altitude(0), self.model, self.date) if (result2): degree2 = round(degree2, 2) self.parametersPanel.pnlVarFinishP.Value = degree2 except: pass def btnConstruct_Click(self): # flag = FlightPlanBaseDlg.btnConstruct_Click(self) # if not flag: # return if self.parametersPanel.tabGeneral.currentIndex() == 0: self.autoCalcFinishMagVar() self.calculateP() elif self.parametersPanel.tabGeneral.currentIndex() == 1: self.calculateBD() else: self.calculateMVD() def initParametersPan(self): ui = Ui_GeoDetermine() self.parametersPanel = ui FlightPlanBaseDlg.initParametersPan(self) self.parametersPanel.pnlStartPosP = PositionPanel( self.parametersPanel.gbStartPosP, None, None, "Degree") # self.parametersPanel.pnlStartPosP.degreeFormat = "ddmmss.ssssH" self.parametersPanel.pnlStartPosP.alwwaysShowString = "Degree" # self.parametersPanel.pnlWaypoint.groupBox.setTitle("FAWP") self.parametersPanel.pnlStartPosP.btnCalculater.hide() self.parametersPanel.pnlStartPosP.hideframe_Altitude() # self.parametersPanel.pnlStartPosP.showframe_ID() self.parametersPanel.pnlStartPosP.setObjectName("pnlStartPosP") self.connect(self.parametersPanel.pnlStartPosP, SIGNAL("positionChanged"), self.autoCalcFinishMagVar) ui.verticalLayout_gbStartPosP.addWidget( self.parametersPanel.pnlStartPosP) self.parametersPanel.pnlVarStartP = DegreesBoxPanel(self) self.parametersPanel.pnlVarStartP.CaptionLabel = "Magnetic Variation" self.connect(self.parametersPanel.pnlVarStartP, SIGNAL("btnDegreeBoxPanel_clicked"), self.method_32_P) self.connect(self.parametersPanel.pnlVarStartP, SIGNAL("txtDegreeBox_textChanged"), self.txtDegreeBox_textChangedP) ui.verticalLayout_gbStartPosP.addWidget( self.parametersPanel.pnlVarStartP) self.parametersPanel.pnlVarFinishP = DegreesBoxPanel(self) self.parametersPanel.pnlVarFinishP.ButtonVisible = False self.parametersPanel.pnlVarFinishP.Enabled = False self.parametersPanel.pnlVarFinishP.CaptionLabel = "Magnetic Variation at Finish" ui.vLayout_grbParametersP.insertWidget( 1, self.parametersPanel.pnlVarFinishP) # self.connect(self.parametersPanel.pnlVarStartP, SIGNAL("btnDegreeBoxPanel_clicked"), self.method_32_P) self.parametersPanel.pnlStartPosBD = PositionPanel( self.parametersPanel.gbFinishPosBD, None, None, "Degree") # self.parametersPanel.pnlStartPosBD.groupBox.setTitle("FAWP") # self.parametersPanel.pnlStartPosBD.degreeFormat = "ddmmss.ssssH" self.parametersPanel.pnlStartPosBD.alwwaysShowString = "Degree" self.parametersPanel.pnlStartPosBD.btnCalculater.hide() self.parametersPanel.pnlStartPosBD.hideframe_Altitude() self.parametersPanel.pnlStartPosBD.showframe_ID() self.parametersPanel.pnlStartPosBD.setObjectName("pnlStartPosBD") ui.verticalLayout_gbStartPosBD.insertWidget( 0, self.parametersPanel.pnlStartPosBD) self.connect(self.parametersPanel.pnlStartPosBD, SIGNAL("positionChanged"), self.positionChangedStartBD) self.parametersPanel.pnlVarStartBD = DegreesBoxPanel(self) self.parametersPanel.pnlVarStartBD.CaptionLabel = "Magnetic Variation" # self.parametersPanel.pnlVarStartBD.Enabled = False self.connect(self.parametersPanel.pnlVarStartBD, SIGNAL("btnDegreeBoxPanel_clicked"), self.method_34_BD) # self.connect(self.parametersPanel.pnlVarStartBD, SIGNAL("txtDegreeBox_textChanged"), self.txtDegreeBox_textChangedP) ui.verticalLayout_gbStartPosBD.addWidget( self.parametersPanel.pnlVarStartBD) self.parametersPanel.pnlFinishPosBD = PositionPanel( self.parametersPanel.gbFinishPosBD, None, None, "Degree") # self.parametersPanel.pnlStartPosBD.groupBox.setTitle("FAWP") # self.parametersPanel.pnlFinishPosBD.degreeFormat = "ddmmss.ssssH" self.parametersPanel.pnlFinishPosBD.alwwaysShowString = "Degree" self.parametersPanel.pnlFinishPosBD.btnCalculater.hide() self.parametersPanel.pnlFinishPosBD.hideframe_Altitude() self.parametersPanel.pnlFinishPosBD.showframe_ID() self.parametersPanel.pnlFinishPosBD.setObjectName("pnlFinishPosBD") ui.verticalLayout_gbFinishPosBD.insertWidget( 0, self.parametersPanel.pnlFinishPosBD) self.connect(self.parametersPanel.pnlFinishPosBD, SIGNAL("positionChanged"), self.positionChangedFinishBD) self.parametersPanel.pnlVarFinishBD = DegreesBoxPanel(self) self.parametersPanel.pnlVarFinishBD.CaptionLabel = "Magnetic Variation" # self.parametersPanel.pnlVarFinishBD.Enabled = False self.connect(self.parametersPanel.pnlVarFinishBD, SIGNAL("btnDegreeBoxPanel_clicked"), self.method_36_BD) # self.connect(self.parametersPanel.pnlVarFinishBD, SIGNAL("txtDegreeBox_textChanged"), self.txtDegreeBox_textChangedP) ui.verticalLayout_gbFinishPosBD.addWidget( self.parametersPanel.pnlVarFinishBD) self.parametersPanel.pnlPositionMVD = PositionPanel( self.parametersPanel.tabGeoDetermineMV, None, None, "Degree") self.parametersPanel.pnlPositionMVD.groupBox.setTitle("Position") self.parametersPanel.pnlPositionMVD.alwwaysShowString = "Degree" self.parametersPanel.pnlPositionMVD.btnCalculater.hide() self.parametersPanel.pnlPositionMVD.setObjectName("pnlPositionMVD") ui.verticalLayout_3.insertWidget(0, self.parametersPanel.pnlPositionMVD) self.connect(self.parametersPanel.pnlPositionMVD, SIGNAL("positionChanged"), self.method_28_MVD) self.connect(self.parametersPanel.txtForwardTP, SIGNAL("Event_0"), self.txtForwardTP_textChanged) self.connect(self.parametersPanel.chbAutoFinishMagVar, SIGNAL("Event_0"), self.chbAutoFinishMagVar_clicked) self.connect(self.parametersPanel.txtDistanceP, SIGNAL("Event_0"), self.autoCalcFinishMagVar) self.connect(self.parametersPanel.txtForwardMP, SIGNAL("Event_0"), self.txtForwardMP_textChanged) self.parametersPanel.btnResultP.clicked.connect( self.btnResultP_clicked) self.parametersPanel.tabGeneral.currentChanged.connect( self.tabGeneral_CurrentChanged) self.parametersPanel.chbAutoVarBD.clicked.connect( self.chbAutoVarBD_clicked) self.parametersPanel.dtpDate.dateChanged.connect(self.method_28_MVD) self.connect(self.parametersPanel.cmbModel, SIGNAL("Event_0"), self.method_28_MVD) self.parametersPanel.btnDtpDate.clicked.connect( self.btnDtpDate_clicked) self.resultModelP = QStandardItemModel() self.parametersPanel.tblResultP.setModel(self.resultModelP) self.resultModelBD = QStandardItemModel() self.parametersPanel.tblResultBD.setModel(self.resultModelBD) self.ttt = 0 self.txtForwardTP_textChanged() self.setHistoryData() self.autoVarSet = False self.dateBD = QDate.currentDate() self.modelBD = MagneticModel.WMM2010 self.parametersPanel.btnResultBD.setVisible(False) self.parametersPanel.dtpDate.setDate(QDate.currentDate()) self.calendar = QCalendarWidget() self.calendar.clicked.connect(self.calendar_clicked) self.menu = QMenu() layout = QVBoxLayout(self.menu) layout.addWidget(self.calendar) def chbAutoFinishMagVar_clicked(self): if self.parametersPanel.chbAutoFinishMagVar.Checked: self.parametersPanel.pnlVarFinishP.Enabled = False else: self.parametersPanel.pnlVarFinishP.Enabled = True def calendar_clicked(self, date): self.parametersPanel.dtpDate.setDate(date) def btnDtpDate_clicked(self): rcRect = self.parametersPanel.btnDtpDate.geometry() ptPoint = rcRect.bottomLeft() self.menu.exec_(self.mapToGlobal(ptPoint)) def positionChangedStartBD(self): if (self.parametersPanel.chbAutoVarBD.isChecked() and self.autoVarSet): self.method_29_BD() self.method_31_BD() def positionChangedFinishBD(self): if (self.parametersPanel.chbAutoVarBD.isChecked() and self.autoVarSet): self.method_30_BD() self.method_31_BD() def chbAutoVarBD_clicked(self): if (self.parametersPanel.chbAutoVarBD.isChecked() and not self.autoVarSet): result, self.dateBD, self.modelBD = DlgMagneticVariationParameters.smethod_0( self.dateBD, self.modelBD) self.parametersPanel.chbAutoVarBD.setChecked(result) self.autoVarSet = self.parametersPanel.chbAutoVarBD.isChecked() if (self.parametersPanel.chbAutoVarBD.isChecked()): self.method_29_BD() self.method_30_BD() self.method_31_BD() def tabGeneral_CurrentChanged(self): if self.parametersPanel.tabGeneral.currentIndex() == 0: self.stdItemModelHistory.clear() if len(GeoDetermineDlg.HistoryDataP) > 0: self.setDataInHistoryModel(GeoDetermineDlg.HistoryDataP, True) pass elif self.parametersPanel.tabGeneral.currentIndex() == 1: self.stdItemModelHistory.clear() if len(GeoDetermineDlg.HistoryDataBD) > 0: self.setDataInHistoryModel(GeoDetermineDlg.HistoryDataBD, True) pass else: self.stdItemModelHistory.clear() if len(GeoDetermineDlg.HistoryDataMV) > 0: self.setDataInHistoryModel(GeoDetermineDlg.HistoryDataMV, True) pass def setHistoryData(self): if len(self.HistoryDataP) > 0: self.setDataInHistoryModel(GeoDetermineDlg.HistoryDataP, True) pass def btnResultP_clicked(self): self.resultModelP.clear() self.parametersPanel.pnlVarStartP.Value = self.parametersPanel.pnlVarFinishP.Value self.parametersPanel.pnlVarFinishP.Value = 0.0 self.parametersPanel.pnlStartPosP.Point3d = self.resultPoint3d def txtForwardTP_textChanged(self): if self.ttt == 0: self.ttt = 1 if self.ttt == 2: self.ttt = 0 if self.ttt == 1: try: value = float(self.parametersPanel.txtForwardTP.Value) self.parametersPanel.txtForwardMP.Value = MathHelper.smethod_3( value - float(self.parametersPanel.pnlVarStartP.Value)) self.autoCalcFinishMagVar() except: self.parametersPanel.txtForwardMP.Value = 0.0 def txtForwardMP_textChanged(self): if self.ttt == 0: self.ttt = 2 if self.ttt == 1: self.ttt = 0 if self.ttt == 2: try: value = float(self.parametersPanel.txtForwardMP.Value) self.parametersPanel.txtForwardTP.Value = MathHelper.smethod_3( value + float(self.parametersPanel.pnlVarStartP.Value)) except: self.parametersPanel.txtForwardTP.Value = 0.0 def txtDegreeBox_textChangedP(self): try: value = float(self.parametersPanel.txtForwardTP.Value) self.parametersPanel.txtForwardMP.Value = MathHelper.smethod_3( value - float(self.parametersPanel.pnlVarStartP.Value)) except: self.parametersPanel.txtForwardMP.Value = 0.0 def method_28_P(self, degrees_Lat, degrees_Lon): point3d = None point3d1 = None self.surfaceType = SurfaceTypes.GeoDeterminePosition flag = FlightPlanBaseDlg.btnConstruct_Click(self) if not flag: return if define._units == QGis.Meters: point3d0 = self.parametersPanel.pnlStartPosP.Point3d point3d = QgisHelper.CrsTransformPoint(point3d0.get_X(), point3d0.get_Y(), define._latLonCrs, define._xyCrs) point3d1 = QgisHelper.CrsTransformPoint(degrees_Lon, degrees_Lat, define._latLonCrs, define._xyCrs) else: point3d = self.parametersPanel.pnlStartPosP.Point3d point3d1 = Point3D(degrees_Lon, degrees_Lat) constructionLayer = None mapUnits = define._canvas.mapUnits() if self.parametersPanel.chbMarkPointsP.isChecked(): constructionLayer = AcadHelper.createVectorLayer( SurfaceTypes.GeoDeterminePosition + "_MarkPoint", QGis.Point) AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, point3d) AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, point3d1) # if mapUnits == QGis.Meters: # constructionLayer = QgsVectorLayer("point?crs=%s"%define._xyCrs.authid (), SurfaceTypes.GeoDeterminePosition + "_MarkPoint", "memory") # else: # constructionLayer = QgsVectorLayer("point?crs=%s"%define._latLonCrs.authid (), SurfaceTypes.GeoDeterminePosition + " MarkPoint", "memory") # # shpPath = "" # if define.obstaclePath != None: # shpPath = define.obstaclePath # elif define.xmlPath != None: # shpPath = define.xmlPath # else: # shpPath = define.appPath # er = QgsVectorFileWriter.writeAsVectorFormat(constructionLayer, shpPath + "/" + SurfaceTypes.GeoDeterminePosition + "_MarkPoint" + ".shp", "utf-8", constructionLayer.crs()) # constructionLayer = QgsVectorLayer(shpPath + "/" + SurfaceTypes.GeoDeterminePosition + "_MarkPoint" + ".shp", SurfaceTypes.GeoDeterminePosition + " MarkPoint", "ogr") # # constructionLayer.startEditing() # # feature = QgsFeature() # feature.setGeometry(QgsGeometry.fromPoint(point3d)) # constructionLayer.addFeature(feature) # feature.setGeometry(QgsGeometry.fromPoint(point3d1)) # constructionLayer.addFeature(feature) # constructionLayer.commitChanges() QgisHelper.appendToCanvas(define._canvas, [constructionLayer], SurfaceTypes.GeoDeterminePosition) self.resultLayerList.append(constructionLayer) if self.parametersPanel.chbDrawLineP.isChecked(): constructionLayer1 = AcadHelper.createVectorLayer( SurfaceTypes.GeoDeterminePosition + "_Line", QGis.Line) AcadHelper.setGeometryAndAttributesInLayer(constructionLayer1, [point3d, point3d1]) QgisHelper.appendToCanvas(define._canvas, [constructionLayer1], SurfaceTypes.GeoDeterminePosition) self.resultLayerList.append(constructionLayer1) def method_28_BD(self): point3d = None point3d1 = None self.surfaceType = SurfaceTypes.GeoDetermineBD flag = FlightPlanBaseDlg.btnConstruct_Click(self) if not flag: return if define._units == QGis.Meters: point3d0 = self.parametersPanel.pnlStartPosBD.Point3d point3dF0 = self.parametersPanel.pnlFinishPosBD.Point3d point3d = QgisHelper.CrsTransformPoint(point3d0.get_X(), point3d0.get_Y(), define._latLonCrs, define._xyCrs) point3d1 = QgisHelper.CrsTransformPoint(point3dF0.get_X(), point3dF0.get_Y(), define._latLonCrs, define._xyCrs) else: point3d = self.parametersPanel.pnlStartPosBD.Point3d point3d1 = self.parametersPanel.pnlFinishPosBD.Point3d constructionLayer = None mapUnits = define._canvas.mapUnits() if self.parametersPanel.chbMarkPointsBD.isChecked(): constructionLayer = AcadHelper.createVectorLayer( SurfaceTypes.GeoDetermineBD + "_MarkPoint", QGis.Point) AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, point3d) AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, point3d1) # if mapUnits == QGis.Meters: # constructionLayer = QgsVectorLayer("point?crs=%s"%define._xyCrs.authid (), SurfaceTypes.GeoDetermineBD + "_MarkPoint", "memory") # else: # constructionLayer = QgsVectorLayer("point?crs=%s"%define._latLonCrs.authid (), SurfaceTypes.GeoDetermineBD + " MarkPoint", "memory") # # shpPath = "" # if define.obstaclePath != None: # shpPath = define.obstaclePath # elif define.xmlPath != None: # shpPath = define.xmlPath # else: # shpPath = define.appPath # er = QgsVectorFileWriter.writeAsVectorFormat(constructionLayer, shpPath + "/" + QString(SurfaceTypes.GeoDetermineBD).replace(" ", "") + "_MarkPoint" + ".shp", "utf-8", constructionLayer.crs()) # constructionLayer = QgsVectorLayer(shpPath + "/" + QString(SurfaceTypes.GeoDetermineBD).replace(" ", "") + "_MarkPoint" + ".shp", SurfaceTypes.GeoDetermineBD + " MarkPoint", "ogr") # # constructionLayer.startEditing() # # # feature = QgsFeature() # feature.setGeometry(QgsGeometry.fromPoint(point3d)) # constructionLayer.addFeature(feature) # feature.setGeometry(QgsGeometry.fromPoint(point3d1)) # constructionLayer.addFeature(feature) # constructionLayer.commitChanges() QgisHelper.appendToCanvas(define._canvas, [constructionLayer], SurfaceTypes.GeoDetermineBD) self.resultLayerList.append(constructionLayer) if self.parametersPanel.chbDrawLineBD.isChecked(): constructionLayer = AcadHelper.createVectorLayer( SurfaceTypes.GeoDetermineBD + "_Line", QGis.Line) AcadHelper.setGeometryAndAttributesInLayer(constructionLayer, [point3d, point3d1]) QgisHelper.appendToCanvas(define._canvas, [constructionLayer], SurfaceTypes.GeoDetermineBD) self.resultLayerList.append(constructionLayer) def method_28_MVD(self): self.parametersPanel.txtResult.Value = "" def method_29_P(self): self.resultModelP.clear() self.resultModelP.setHorizontalHeaderLabels(["Type", "Value"]) def method_29_BD(self): degree = None degree1 = None degree2 = None if (self.parametersPanel.pnlStartPosBD.IsValid()): result, degree, degree1 = self.parametersPanel.pnlStartPosBD.method_3( ) result, degree2 = Geo.smethod_7(degree, degree1, Altitude(0), self.modelBD, self.dateBD) if (result): degree2 = round(degree2, 2) self.parametersPanel.pnlVarStartBD.Value = degree2 def method_30_BD(self): degree = None degree1 = None degree2 = None if (self.parametersPanel.pnlFinishPosBD.IsValid()): result, degree, degree1 = self.parametersPanel.pnlFinishPosBD.method_3( ) result, degree2 = Geo.smethod_7(degree, degree1, Altitude(0), self.modelBD, self.dateBD) if (result): degree2 = round(degree2, 2) self.parametersPanel.pnlVarFinishBD.Value = degree2 def method_31_BD(self): self.resultModelBD.clear() self.resultModelBD.setHorizontalHeaderLabels(["Type", "Value"]) def method_32_P(self): startPos = self.parametersPanel.pnlStartPosP.Point3d result, self.date, self.model = DlgMagneticVariationParameters.smethod_0( self.date, self.model) if self.parametersPanel.pnlStartPosP.IsValid() and result: result, degree, degree1 = self.parametersPanel.pnlStartPosP.method_3( ) result, degree2 = Geo.smethod_7(degree, degree1, Altitude(0), self.model, self.date) if (result): degree2 = round(degree2, 2) self.parametersPanel.pnlVarStartP.Value = degree2 try: self.parametersPanel.txtForwardMP.Value = MathHelper.smethod_3( float(self.parametersPanel.txtForwardTP.Value) - degree2) except: self.parametersPanel.txtForwardMP.Value = 0.0 self.method_29_P() def method_34_BD(self): startPos = self.parametersPanel.pnlStartPosBD.Point3d result, self.dateBD, self.modelBD = DlgMagneticVariationParameters.smethod_0( self.dateBD, self.modelBD) if self.parametersPanel.pnlStartPosBD.IsValid() and result: self.method_29_BD() self.method_31_BD() def method_36_BD(self): startPos = self.parametersPanel.pnlFinishPosBD.Point3d result, self.dateBD, self.modelBD = DlgMagneticVariationParameters.smethod_0( self.dateBD, self.modelBD) if self.parametersPanel.pnlFinishPosBD.IsValid() and result: self.method_30_BD() self.method_31_BD()
class SelectionSetsWidget(QFrame): """ Widget for managing multiple stored item selections """ selectionModified = Signal(bool) def __init__(self, parent): QFrame.__init__(self, parent) self.setContentsMargins(0, 0, 0, 0) layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(1) self._setNameLineEdit = QLineEdit(self) layout.addWidget(self._setNameLineEdit) self._setListView = QListView(self) self._listModel = QStandardItemModel(self) self._proxyModel = QSortFilterProxyModel(self) self._proxyModel.setSourceModel(self._listModel) self._setListView.setModel(self._proxyModel) self._setListView.setItemDelegate(ListItemDelegate(self)) self._setNameLineEdit.textChanged.connect( self._proxyModel.setFilterFixedString) self._completer = QCompleter(self._listModel, self) self._setNameLineEdit.setCompleter(self._completer) self._listModel.itemChanged.connect(self._onSetNameChange) layout.addWidget(self._setListView) buttonLayout = QHBoxLayout() self._addAction = QAction("+", self, toolTip="Add a new sort key") self._updateAction = QAction("Update", self, toolTip="Update/save current selection") self._removeAction = QAction("\u2212", self, toolTip="Remove selected sort key.") self._addToolButton = QToolButton(self) self._updateToolButton = QToolButton(self) self._removeToolButton = QToolButton(self) self._updateToolButton.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) self._addToolButton.setDefaultAction(self._addAction) self._updateToolButton.setDefaultAction(self._updateAction) self._removeToolButton.setDefaultAction(self._removeAction) buttonLayout.addWidget(self._addToolButton) buttonLayout.addWidget(self._updateToolButton) buttonLayout.addWidget(self._removeToolButton) layout.addLayout(buttonLayout) self.setLayout(layout) self._addAction.triggered.connect(self.addCurrentSelection) self._updateAction.triggered.connect(self.updateSelectedSelection) self._removeAction.triggered.connect(self.removeSelectedSelection) self._setListView.selectionModel().selectionChanged.connect( self._onListViewSelectionChanged) self.selectionModel = None self._selections = [] def sizeHint(self): size = QFrame.sizeHint(self) return QSize(size.width(), 150) def _onSelectionChanged(self, selected, deselected): self.setSelectionModified(True) def _onListViewSelectionChanged(self, selected, deselected): try: index = self._setListView.selectedIndexes()[0] except IndexError: return self.commitSelection(self._proxyModel.mapToSource(index).row()) def _onSetNameChange(self, item): self.selections[item.row()].name = str(item.text()) def _setButtonStates(self, val): self._updateToolButton.setEnabled(val) def setSelectionModel(self, selectionModel): if self.selectionModel: self.selectionModel.selectionChanged.disconnect( self._onSelectionChanged) self.selectionModel = selectionModel self.selectionModel.selectionChanged.connect(self._onSelectionChanged) def addCurrentSelection(self): item = self.addSelection( SelectionByKey(self.selectionModel.selection(), name="New selection", key=(1, 2, 3, 10))) index = self._proxyModel.mapFromSource(item.index()) self._setListView.setCurrentIndex(index) self._setListView.edit(index) self.setSelectionModified(False) def removeSelectedSelection(self): i = self._proxyModel.mapToSource( self._setListView.currentIndex()).row() self._listModel.takeRow(i) del self.selections[i] def updateCurentSelection(self): i = self._proxyModel.mapToSource( self._setListView.selectedIndex()).row() self.selections[i].setSelection(self.selectionModel.selection()) self.setSelectionModified(False) def addSelection(self, selection, name=""): self._selections.append(selection) item = QStandardItem(selection.name) item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled) self._listModel.appendRow(item) self.setSelectionModified(False) return item def updateSelectedSelection(self): i = self._proxyModel.mapToSource( self._setListView.currentIndex()).row() self.selections[i].setSelection(self.selectionModel.selection()) self.setSelectionModified(False) def setSelectionModified(self, val): self._selectionModified = val self._setButtonStates(val) self.selectionModified.emit(bool(val)) def commitSelection(self, index): selection = self.selections[index] selection.select(self.selectionModel) def setSelections(self, selections): self._listModel.clear() for selection in selections: self.addSelection(selection) def selections(self): return self._selections selections = property(selections, setSelections)
def __init__(self, parent): QFrame.__init__(self, parent) self.setContentsMargins(0, 0, 0, 0) layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(1) self._setNameLineEdit = QLineEdit(self) layout.addWidget(self._setNameLineEdit) self._setListView = QListView(self) self._listModel = QStandardItemModel(self) self._proxyModel = QSortFilterProxyModel(self) self._proxyModel.setSourceModel(self._listModel) self._setListView.setModel(self._proxyModel) self._setListView.setItemDelegate(ListItemDelegate(self)) self._setNameLineEdit.textChanged.connect( self._proxyModel.setFilterFixedString) self._completer = QCompleter(self._listModel, self) self._setNameLineEdit.setCompleter(self._completer) self._listModel.itemChanged.connect(self._onSetNameChange) layout.addWidget(self._setListView) buttonLayout = QHBoxLayout() self._addAction = QAction("+", self, toolTip="Add a new sort key") self._updateAction = QAction("Update", self, toolTip="Update/save current selection") self._removeAction = QAction("\u2212", self, toolTip="Remove selected sort key.") self._addToolButton = QToolButton(self) self._updateToolButton = QToolButton(self) self._removeToolButton = QToolButton(self) self._updateToolButton.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) self._addToolButton.setDefaultAction(self._addAction) self._updateToolButton.setDefaultAction(self._updateAction) self._removeToolButton.setDefaultAction(self._removeAction) buttonLayout.addWidget(self._addToolButton) buttonLayout.addWidget(self._updateToolButton) buttonLayout.addWidget(self._removeToolButton) layout.addLayout(buttonLayout) self.setLayout(layout) self._addAction.triggered.connect(self.addCurrentSelection) self._updateAction.triggered.connect(self.updateSelectedSelection) self._removeAction.triggered.connect(self.removeSelectedSelection) self._setListView.selectionModel().selectionChanged.connect( self._onListViewSelectionChanged) self.selectionModel = None self._selections = []
def __init__(self, parent=None, dict={}): QStandardItemModel.__init__(self, parent) self.setHorizontalHeaderLabels(["Key", "Value"]) self.set_dict(dict)
class OWTestLearners(widget.OWWidget): name = "Test Learners" description = "" icon = "icons/TestLearners1.svg" priority = 100 inputs = [("Learner", Orange.classification.Fitter, "set_learner", widget.Multiple), ("Data", Orange.data.Table, "set_train_data", widget.Default), ("Test Data", Orange.data.Table, "set_test_data")] outputs = [("Evaluation Results", testing.Results)] #: Resampling/testing types KFold, LeaveOneOut, Bootstrap, TestOnTrain, TestOnTest = 0, 1, 2, 3, 4 #: Selected resampling type resampling = settings.Setting(0) #: Number of folds for K-fold cross validation k_folds = settings.Setting(10) #: Number of repeats for bootstrap sampling n_repeat = settings.Setting(10) #: Bootstrap sampling p sample_p = settings.Setting(75) def __init__(self, parent=None): super().__init__(parent) self.train_data = None self.test_data = None #: An Ordered dictionary with current inputs and their testing #: results. self.learners = OrderedDict() sbox = gui.widgetBox(self.controlArea, "Sampling") rbox = gui.radioButtons(sbox, self, "resampling", callback=self._param_changed) gui.appendRadioButton(rbox, "Cross validation") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:", callback=self._param_changed) gui.appendRadioButton(rbox, "Leave one out") gui.appendRadioButton(rbox, "Random sampling") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test", callback=self._param_changed) gui.widgetLabel(ibox, "Relative training set size:") gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100, ticks=20, vertical=False, callback=self._param_changed) gui.appendRadioButton(rbox, "Test on train data") gui.appendRadioButton(rbox, "Test on test data") rbox.layout().addSpacing(5) gui.button(rbox, self, "Apply", callback=self.apply) gui.rubber(self.controlArea) self.view = QTreeView(rootIsDecorated=False, uniformRowHeights=True, wordWrap=True, editTriggers=QTreeView.NoEditTriggers) self.result_model = QStandardItemModel() self.view.setModel(self.result_model) self._update_header() box = gui.widgetBox(self.mainArea, "Evaluation Results") box.layout().addWidget(self.view) def set_learner(self, learner, key): if key in self.learners and learner is None: del self.learners[key] else: self.learners[key] = Input(learner, None, ()) self._update_stats_model() def set_train_data(self, data): self.train_data = data self._update_header() self._invalidate() def set_test_data(self, data): self.test_data = data if self.resampling == OWTestLearners.TestOnTest: self._invalidate() def handleNewSignals(self): self.update_results() self.commit() def _param_changed(self): self._invalidate() def update_results(self): self.warning(1, "") if self.train_data is None: return # items in need of an update items = [(key, input) for key, input in self.learners.items() if input.results is None] learners = [input.learner for _, input in items] self.setStatusMessage("Running") if self.test_data is not None and \ self.resampling != OWTestLearners.TestOnTest: self.warning(1, "Select 'Test on test data' to use the test data") # TODO: Test each learner individually if self.resampling == OWTestLearners.KFold: results = testing.CrossValidation(self.train_data, learners, k=self.k_folds, store_data=True) elif self.resampling == OWTestLearners.LeaveOneOut: results = testing.LeaveOneOut(self.train_data, learners, store_data=True) elif self.resampling == OWTestLearners.Bootstrap: p = self.sample_p / 100.0 results = testing.Bootstrap(self.train_data, learners, n_resamples=self.n_repeat, p=p, store_data=True) elif self.resampling == OWTestLearners.TestOnTrain: results = testing.TestOnTrainingData(self.train_data, learners, store_data=True) elif self.resampling == OWTestLearners.TestOnTest: if self.test_data is None: return results = testing.TestOnTestData(self.train_data, self.test_data, learners, store_data=True) else: assert False results = list(split_by_model(results)) class_var = self.train_data.domain.class_var if is_discrete(class_var): test_stats = classification_stats else: test_stats = regression_stats self._update_header() stats = [test_stats(res) for res in results] for (key, input), res, stat in zip(items, results, stats): self.learners[key] = input._replace(results=res, stats=stat) self.setStatusMessage("") self._update_stats_model() def _update_header(self): headers = ["Method"] if self.train_data is not None: if is_discrete(self.train_data.domain.class_var): if len(self.train_data.domain.class_var.values) == 2: headers.extend(classification_stats.headers_binary) headers.extend(classification_stats.headers) else: headers.extend(regression_stats.headers) for i in reversed(range(len(headers), self.result_model.columnCount())): self.result_model.takeColumn(i) self.result_model.setHorizontalHeaderLabels(headers) def _update_stats_model(self): model = self.view.model() for r in reversed(range(model.rowCount())): model.takeRow(r) for input in self.learners.values(): name = learner_name(input.learner) row = [] head = QStandardItem() head.setData(name, Qt.DisplayRole) row.append(head) for stat in input.stats: item = QStandardItem() item.setData(float(stat[0]), Qt.DisplayRole) row.append(item) model.appendRow(row) self.view.resizeColumnToContents(0) def _invalidate(self, which=None): if which is None: which = self.learners.keys() all_keys = list(self.learners.keys()) model = self.view.model() for key in which: self.learners[key] = \ self.learners[key]._replace(results=None, stats=None) if key in self.learners: row = all_keys.index(key) for c in range(1, model.columnCount()): item = model.item(row, c) if item is not None: item.setData(None, Qt.DisplayRole) def apply(self): self.update_results() self.commit() def commit(self): results = [ val.results for val in self.learners.values() if val.results is not None ] if results: combined = results_merge(results) combined.fitter_names = [ learner_name(val.learner) for val in self.learners.values() ] else: combined = None self.send("Evaluation Results", combined)
def __init__(self): super().__init__() self.data = None self.test_data = None self.preprocessor = None self.train_data_missing_vals = False self.test_data_missing_vals = False #: An Ordered dictionary with current inputs and their testing #: results. self.learners = OrderedDict() sbox = gui.widgetBox(self.controlArea, "Sampling") rbox = gui.radioButtons(sbox, self, "resampling", callback=self._param_changed) gui.appendRadioButton(rbox, "Cross validation") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:", callback=self.kfold_changed) gui.appendRadioButton(rbox, "Leave one out") gui.appendRadioButton(rbox, "Random sampling") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test", callback=self.shuffle_split_changed) gui.widgetLabel(ibox, "Relative training set size:") gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=99, ticks=20, vertical=False, labelFormat="%d %%", callback=self.shuffle_split_changed) gui.appendRadioButton(rbox, "Test on train data") gui.appendRadioButton(rbox, "Test on test data") rbox.layout().addSpacing(5) self.apply_button = gui.button(rbox, self, "Apply", callback=self.apply, default=True) self.cbox = gui.widgetBox(self.controlArea, "Target class") self.class_selection_combo = gui.comboBox( self.cbox, self, "class_selection", items=[], sendSelectedValue=True, valueType=str, callback=self._on_target_class_changed, contentsLength=8) gui.rubber(self.controlArea) self.view = QTreeView(rootIsDecorated=False, uniformRowHeights=True, wordWrap=True, editTriggers=QTreeView.NoEditTriggers) header = self.view.header() header.setResizeMode(QHeaderView.ResizeToContents) header.setDefaultAlignment(Qt.AlignCenter) header.setStretchLastSection(False) self.result_model = QStandardItemModel(self) self.result_model.setHorizontalHeaderLabels(["Method"]) self.view.setModel(self.result_model) self.view.setItemDelegate(ItemDelegate()) box = gui.widgetBox(self.mainArea, "Evaluation Results") box.layout().addWidget(self.view)
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, "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.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 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.setItemDelegate(BorderedItemDelegate(Qt.white)) view.clicked.connect(self.cell_clicked) grid.addWidget(view, 0, 0) self.mainArea.layout().addLayout(grid)
class QMapManager(QDialog): def __init__(self, config, parent=None): QDialog.__init__(self, parent) curdir = os.path.abspath(os.path.dirname(__file__)) PyQt4.uic.loadUi(os.path.join(curdir, 'manager.ui'), self) self.model = QStandardItemModel() self.projectsmodel = QStandardItemModel() self.projectlist.setModel(self.projectsmodel) self.clientlist.setModel(self.model) self.clientlist.selectionModel().selectionChanged.connect(self.update) self.installbutton.pressed.connect(self.installToClient) self.mapper = QDataWidgetMapper() self.mapper.setModel(self.model) self.mapper.addMapping(self.installpath, 1) self.config = config self.populateProjects() self.populateClients() def installToClient(self): index = self.clientlist.selectionModel().currentIndex() item = self.model.itemFromIndex(index) print "Deploying to " + item.text() build.deployTargetByName(item.text()) def update(self, selected, deselected): index = selected.indexes()[0] self.mapper.setCurrentModelIndex(index) item = self.model.itemFromIndex(index) settings = item.data() for row in xrange(0, self.projectsmodel.rowCount()): index = self.projectsmodel.index(row, 0) item = self.projectsmodel.itemFromIndex(index) item.setCheckState(Qt.Unchecked) projects = settings['projects'] for project in projects: if project == "All": i = 0 while self.projectsmodel.item(i): item = self.projectsmodel.item(i) item.setCheckState(Qt.Checked) i += 1 break projectitem = self.projectsmodel.findItems(project)[0] projectitem.setCheckState(Qt.Checked) def populateClients(self): row = 0 for client, settings in self.config['clients'].iteritems(): name = QStandardItem(client) name.setData(settings) path = QStandardItem(settings['path']) self.model.insertRow(row, [name, path]) row += 1 def populateProjects(self): row = 0 for project in getProjects(): projectitem = QStandardItem(project.name) projectitem.setCheckable(True) self.projectsmodel.insertRow(row, projectitem) row += 1
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 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 DevicesDialog(QDialog, Ui_DevicesDialog): def __init__(self, parent = None): QDialog.__init__(self) self.setupUi(self) self.selectedDevice = None self.listdevices = {} self.devices = Devices() self.logical = Logical() self.combodevice = TreeComboBox() self.gridLayout.addWidget(self.combodevice, 0, 1, 1, 1) self.__model = QStandardItemModel() lidx = 0 if len(self.logical): logicalitems = QStandardItem(self.tr("Logical drives")) self.__model.appendRow(logicalitems) for lidx in range(0, len(self.logical)): logicalitem = QStandardItem(self.logical[lidx].model()) logicalitems.appendRow(logicalitem) self.listdevices[lidx] = self.logical[lidx] lidx += 1 if len(self.devices): physicalitems = QStandardItem(self.tr("Physical drives")) self.__model.appendRow(physicalitems) for pidx in range(0, len(self.devices)): model = self.devices[pidx].model() if model != "Unknown": physicalitem = QStandardItem(self.devices[pidx].blockDevice() + " (" + model + ")") else: physicalitem = QStandardItem(self.devices[pidx].blockDevice()) physicalitems.appendRow(physicalitem) self.listdevices[lidx+pidx] = self.devices[pidx] self.combodevice.setModel(self.__model) self.combodevice.view().expandAll() if len(self.devices): self.setDeviceInformations(self.devices[0], True) self.selectedDevice = self.devices[0] self.connect(self.combodevice, SIGNAL("currentIndexChanged(int)"), self.deviceChanged) def __del__(self): del self.devices del self.logical def setDeviceInformations(self, device, init=False): self.blockdevice.setText(QString.fromUtf8(device.blockDevice())) self.model.setText(QString.fromUtf8(device.model())) self.serial.setText(QString.fromUtf8(device.serialNumber())) self.size.setText(str(device.size())) def deviceChanged(self, index): parent = self.combodevice.view().currentIndex().parent() if parent != QModelIndex(): if parent.row() == 1: index += len(self.logical) self.setDeviceInformations(self.listdevices[index]) self.selectedDevice = self.listdevices[index]
class OWMPR(OWWidget): name = 'ModelMap Projection Rank' description = "Rank projections according to the " \ "class-related projection quality" icon = "icons/ModelMap.svg" inputs = [('Data', Table, 'set_data', Default)] outputs = [('Features', AttributeList)] want_main_area = False settingsHandler = DomainContextHandler() variable_changed = Signal() def __init__(self): super().__init__() self.data = None self.progress = None self.infoa = gui.widgetLabel(self.controlArea, "No data loaded.") self.projectionTable = QTableView() self.controlArea.layout().addWidget(self.projectionTable) self.projectionTable.setSelectionBehavior(QTableView.SelectRows) self.projectionTable.setSelectionMode(QTableView.SingleSelection) self.projectionTable.setSortingEnabled(True) self.projectionTableModel = QStandardItemModel(self) self.projectionTableModel.setHorizontalHeaderLabels( ["P-Index", "", ""]) self.projectionTable.setModel(self.projectionTableModel) self.projectionTable.setColumnWidth(0, 90) self.projectionTable.sortByColumn(0, Qt.DescendingOrder) self.projectionTable.selectionModel().selectionChanged.connect( self.on_selection_changed) gui.button(self.controlArea, self, "Rank Projections", callback=self.rank, default=True) self.resize(370, 600) def set_data(self, data): self.data = data self.infoa.setText("Data set: {}".format(data.name) if self. data else "No data loaded.") def rank(self): if self.progress: return disc = Orange.preprocess.discretize.EqualWidth(n=10) ndomain = Orange.data.Domain([ disc(self.data, attr) if attr.is_continuous else attr for attr in self.data.domain.attributes ], self.data.domain.class_vars) t = self.data.from_table(ndomain, self.data) attrs = t.domain.attributes tables = {} l = 0 self.progress = gui.ProgressBar(self, len(attrs) * (len(attrs) - 1) / 2) for i in range(len(attrs)): for j in range(i): ct = np.array( contingency.get_contingency(t, attrs[j], attrs[i])) pindex, _, _ = p_index(ct) tables[i, j] = ct item = QStandardItem() item.setData(float(pindex), Qt.DisplayRole) self.projectionTableModel.setItem(l, 0, item) item = QStandardItem() item.setData(attrs[i].name, Qt.DisplayRole) self.projectionTableModel.setItem(l, 1, item) item = QStandardItem() item.setData(attrs[j].name, Qt.DisplayRole) self.projectionTableModel.setItem(l, 2, item) self.progress.advance() l += 1 self.progress.finish() self.progress = None def on_selection_changed(self, selected, deselected): """Called when the ranks view selection changes.""" a1 = selected.indexes()[1].data() a2 = selected.indexes()[2].data() d = self.data.domain self.send("Features", AttributeList([d[a1], d[a2]]))
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.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, "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.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 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.setItemDelegate(BorderedItemDelegate(Qt.white)) 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 None: self.report_button.setDisabled(True) else: self.report_button.setDisabled(False) 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) 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(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): def isinvalid(x): return isnan(x) or isinf(x) # 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() 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() hue = [0, 240] 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( hue[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) model = self.tablemodel font = model.invisibleRootItem().font() bold_font = QFont(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 N = len(colsum) for i in range(N): model.setItem(N + 2, i + 2, sum_item(int(colsum[i]), "t")) model.setItem(i + 2, N + 2, sum_item(int(rowsum[i]), "l")) model.setItem(N + 2, N + 2, sum_item(int(total))) def send_report(self): if self.results is not None and self.selected_learner: index = self.selected_learner[0] self.report_table( "Confusion matrix for {} (showing {})".format( self.learners[index], self.quantities[self.selected_quantity].lower()), self.tablemodel)
class QtWidgetRegistry(QObject, WidgetRegistry): """ A QObject wrapper for `WidgetRegistry` A QStandardItemModel instance containing the widgets in a tree (of depth 2). The items in a model can be quaries using standard roles (DisplayRole, BackgroundRole, DecorationRole ToolTipRole). They also have QtWidgetRegistry.CATEGORY_DESC_ROLE, QtWidgetRegistry.WIDGET_DESC_ROLE, which store Category/WidgetDescription respectfully. Furthermore QtWidgetRegistry.WIDGET_ACTION_ROLE stores an default QAction which can be used for widget creation action. """ CATEGORY_DESC_ROLE = Qt.UserRole + 1 """Category Description Role""" WIDGET_DESC_ROLE = Qt.UserRole + 2 """Widget Description Role""" WIDGET_ACTION_ROLE = Qt.UserRole + 3 """Widget Action Role""" BACKGROUND_ROLE = Qt.UserRole + 4 """Background color for widget/category in the canvas (different from Qt.BackgroundRole) """ category_added = Signal(str, CategoryDescription) """signal: category_added(name: str, desc: CategoryDescription) """ widget_added = Signal(str, str, WidgetDescription) """signal widget_added(category_name: str, widget_name: str, desc: WidgetDescription) """ reset = Signal() """signal: reset() """ def __init__(self, other_or_parent=None, parent=None): if isinstance(other_or_parent, QObject) and parent is None: parent, other_or_parent = other_or_parent, None QObject.__init__(self, parent) WidgetRegistry.__init__(self, other_or_parent) # Should the QStandardItemModel be subclassed? self.__item_model = QStandardItemModel(self) for i, desc in enumerate(self.categories()): cat_item = self._cat_desc_to_std_item(desc) self.__item_model.insertRow(i, cat_item) for j, wdesc in enumerate(self.widgets(desc.name)): widget_item = self._widget_desc_to_std_item(wdesc, desc) cat_item.insertRow(j, widget_item) def model(self): """ Return the widget descriptions in a Qt Item Model instance (QStandardItemModel). .. note:: The model should not be modified outside of the registry. """ return self.__item_model def item_for_widget(self, widget): """Return the QStandardItem for the widget. """ if isinstance(widget, str): widget = self.widget(widget) cat = self.category(widget.category) cat_ind = self.categories().index(cat) cat_item = self.model().item(cat_ind) widget_ind = self.widgets(cat).index(widget) return cat_item.child(widget_ind) def action_for_widget(self, widget): """ Return the QAction instance for the widget (can be a string or a WidgetDescription instance). """ item = self.item_for_widget(widget) return item.data(self.WIDGET_ACTION_ROLE) def create_action_for_item(self, item): """ Create a QAction instance for the widget description item. """ name = item.text() tooltip = item.toolTip() whatsThis = item.whatsThis() icon = item.icon() if icon: action = QAction(icon, name, self, toolTip=tooltip, whatsThis=whatsThis, statusTip=name) else: action = QAction(name, self, toolTip=tooltip, whatsThis=whatsThis, statusTip=name) widget_desc = item.data(self.WIDGET_DESC_ROLE) action.setData(widget_desc) action.setProperty("item", item) return action def _insert_category(self, desc): """ Override to update the item model and emit the signals. """ priority = desc.priority priorities = [c.priority for c, _ in self.registry] insertion_i = bisect.bisect_right(priorities, priority) WidgetRegistry._insert_category(self, desc) cat_item = self._cat_desc_to_std_item(desc) self.__item_model.insertRow(insertion_i, cat_item) self.category_added.emit(desc.name, desc) def _insert_widget(self, category, desc): """ Override to update the item model and emit the signals. """ assert (isinstance(category, CategoryDescription)) categories = self.categories() cat_i = categories.index(category) _, widgets = self._categories_dict[category.name] priorities = [w.priority for w in widgets] insertion_i = bisect.bisect_right(priorities, desc.priority) WidgetRegistry._insert_widget(self, category, desc) cat_item = self.__item_model.item(cat_i) widget_item = self._widget_desc_to_std_item(desc, category) cat_item.insertRow(insertion_i, widget_item) self.widget_added.emit(category.name, desc.name, desc) def _cat_desc_to_std_item(self, desc): """ Create a QStandardItem for the category description. """ item = QStandardItem() item.setText(desc.name) if desc.icon: icon = desc.icon else: icon = "icons/default-category.svg" icon = icon_loader.from_description(desc).get(icon) item.setIcon(icon) if desc.background: background = desc.background else: background = DEFAULT_COLOR background = NAMED_COLORS.get(background, background) brush = QBrush(QColor(background)) item.setData(brush, self.BACKGROUND_ROLE) tooltip = desc.description if desc.description else desc.name item.setToolTip(tooltip) item.setFlags(Qt.ItemIsEnabled) item.setData(desc, self.CATEGORY_DESC_ROLE) return item def _widget_desc_to_std_item(self, desc, category): """ Create a QStandardItem for the widget description. """ item = QStandardItem(desc.name) item.setText(desc.name) if desc.icon: icon = desc.icon else: icon = "icons/default-widget.svg" icon = icon_loader.from_description(desc).get(icon) item.setIcon(icon) # This should be inherited from the category. background = None if desc.background: background = desc.background elif category.background: background = category.background else: background = DEFAULT_COLOR if background is not None: background = NAMED_COLORS.get(background, background) brush = QBrush(QColor(background)) item.setData(brush, self.BACKGROUND_ROLE) tooltip = tooltip_helper(desc) style = "ul { margin-top: 1px; margin-bottom: 1px; }" tooltip = TOOLTIP_TEMPLATE.format(style=style, tooltip=tooltip) item.setToolTip(tooltip) item.setWhatsThis(whats_this_helper(desc)) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable) item.setData(desc, self.WIDGET_DESC_ROLE) # Create the action for the widget_item action = self.create_action_for_item(item) item.setData(action, self.WIDGET_ACTION_ROLE) return item
class ClusterWidget(QSplitter): def __init__(self, peaks, parent=None): QSplitter.__init__(self, Qt.Vertical, parent) self.peaks = peaks self.choosenOne = [pe for pe in self.peaks if pe is not None][0] #self.peakModel = QStandardItemModel() self.identificationModel = QStandardItemModel() self.setupUi() self.setModel() self.connect(self.calcCorr, SIGNAL('pressed()'), self.setRankValue) #self.setRankValue() def setupUi(self): self.widget = MSView( MSQtCanvas(self.peaks, "peaks@%s" % str(self.peaks[0]), labels={ 'bottom': 'RT(s)', 'left': 'INTENSITY' }, flags='peak')) self.tableView = QTableView() self.tableView.horizontalHeader().setStretchLastSection(True) self.tableView.setSortingEnabled(True) self.corr = QLabel("Nan") self.calcCorr = QPushButton("r_coef:") #v = QVBoxLayout(self) self.addWidget(self.widget) self.wid = QWidget() vb = QVBoxLayout() vb.addWidget(self.calcCorr) vb.addWidget(self.corr) hb = QHBoxLayout(self.wid) #if self.choosenOne.formulas: hb.addWidget(self.tableView) #else: # hb.addWidget(QLabel("Identification not performed yet...")) hb.addLayout(vb) self.addWidget(self.wid) def setModel(self): from gui.MetBaseGui import MSStandardItem #we assume that the different peaks have the same identifiers #TODO: may have to merge several stuffs later if self.choosenOne.formulas: self.identificationModel.setHorizontalHeaderLabels( ["score", "formula", "diff mass", "names"]) for i, f in enumerate(self.choosenOne.formulas.iterkeys()): self.identificationModel.setItem( i, 0, MSStandardItem(str(self.choosenOne.formulas[f]["score"]))) self.identificationModel.setItem(i, 1, QStandardItem(str(f))) self.identificationModel.setItem( i, 2, MSStandardItem(str( self.choosenOne.formulas[f]["diffmass"]))) self.identificationModel.setItem( i, 3, QStandardItem(self.choosenOne.formulas[f]["names"])) if self.choosenOne.formulas[f]["names"] != 'Not Found': for j in xrange(4): self.identificationModel.item(i, j).setBackground( QBrush(Qt.green)) else: for j in xrange(4): self.identificationModel.item(i, j).setBackground( QBrush(Qt.red)) self.tableView.setModel(self.identificationModel) def setRankValue(self): #m = qApp.instance().model #m.pearsonIntraCalculation() #peaks =[] #for spl in m: # peaks+=[p.r_coef for p in spl.mappedPeaks if p.r_coef] #if not self.choosenOne.r_coef: self.choosenOne.pCalcBasedOnPeakShape() #from _bisect import bisect_left #x = bisect_left(sorted(peaks), self.choosenOne.r_coef) s = '<br><b>%f</b></br>' % np.round(self.choosenOne.r_coef, 4) #s+='<br><b>Rank: </b>%d</br>'%abs(len(peaks)-x) self.corr.setText(s)
class SubPowerWidget(QWidget): """ @brief Zeigt alle Unterkräfte in einer Baumstruktur an. """ def __init__(self, template, character, parent=None): super(SubPowerWidget, self).__init__(parent) self.__storage = template self.__character = character self.__model = QStandardItemModel() # Das ungenutzte Model dient dazu, alle Unterkräfte aufzunehmen, die ich nicht darstellen möchte. Ist einfacher, als diese im View zu verstecken. self.__modelUnused = QStandardItemModel() self._layout = QVBoxLayout() self.setLayout(self._layout) self.__view = QTreeView() self.__view.setHeaderHidden(True) self.__view.setModel(self.__model) self._layout.addWidget(self.__view) self._typ = "Subpower" categories = self.__storage.categories(self._typ) self.__items = {} self.__rootItem = QStandardItem() self.__rootItem = self.__model.invisibleRootItem() self.__rootItemUnused = QStandardItem() self.__rootItemUnused = self.__modelUnused.invisibleRootItem() for item in categories: categoryItem = QStandardItem(item) self.__rootItem.appendRow(categoryItem) ## Ich benötige diese Items auch im ungenutzten Model. categoryItemUnused = QStandardItem(item) self.__rootItemUnused.appendRow(categoryItemUnused) traitList = list(self.__character.traits[self._typ][item].items()) traitList.sort() for trait in traitList: traitItem = QStandardItem(trait[1].name) traitItem.setCheckable(True) ## Unhashable Type self.__items[trait[1]] = traitItem categoryItem.appendRow(traitItem) ## Funktioniert mit PySide nicht: #trait[1].availableChanged.connect(traitItem.setEnabled) ## Funktioniert auch mit PySide: trait[1].availableChanged.connect( lambda enable, item=traitItem: item.setEnabled(enable)) trait[1].valueChanged.connect(lambda val, trait=trait[ 1], item=traitItem: self.__setItemValue(trait, item)) self.__model.itemChanged.connect(self.__getItemValue) self.__character.speciesChanged.connect(self.hideOrShowToolPage) self.__character.breedChanged.connect(self.hideOrShowToolPage) self.__character.factionChanged.connect(self.hideOrShowToolPage) def __setItemValue(self, trait, item): """ Setzt den Wert der Angezeigten Items. """ if trait.value == 0: item.setCheckState(Qt.Unchecked) elif trait.value == 1: item.setCheckState(Qt.PartiallyChecked) else: item.setCheckState(Qt.Checked) def __getItemValue(self, item): """ Setzt den Wert der Eigenschaft im Speicher. """ for trait in self.__items.items(): if id(trait[1]) == id(item): trait[0].value = item.checkState() break def hideOrShowToolPage(self, res): """ Alle Eigenschaften, die nicht zur Verfügung stehen, werden verborgen, indem sie in ein anderes Model verschoben werden. \bug Möglicher Fehler in PySide: Der Aufruf von QStandardItem.model() führt beim Beenden des Programms zu einem Segmentation Fault. """ # Versteckt alle Unterkräfte, die zu gewähltem Charakter nicht passen. for item in self.__items.items(): if ((item[0].species and item[0].species != self.__character.species) or (item[0].only and self.__character.breed not in item[0].only and self.__character.faction not in item[0].only)): #self.__view.setRowHidden(item[1].index().row(), item[1].parent().index(), True) #Debug.debug(item[1].model()) ## Hier wird beispielsweise besagter Aufruf getätigt, der zu einem segfault führt. if item[1].model() == self.__model: parent = item[1].parent() itemUnused = parent.takeRow(item[1].index().row()) parentUnused = self.__modelUnused.findItems( parent.text())[0] parentUnused.appendRow(itemUnused) else: #self.__view.setRowHidden(item[1].index().row(), item[1].parent().index(), False) if item[1].model() == self.__modelUnused: parent = item[1].parent() itemUsed = parent.takeRow(item[1].index().row()) parentUsed = self.__model.findItems(parent.text())[0] parentUsed.appendRow(itemUsed) ## Versteckt alle Elternzeilen, wenn sie keine Kinder enthalten. for i in range(self.__model.rowCount()): categoryItem = self.__model.item(i) if categoryItem.hasChildren(): self.__view.setRowHidden(categoryItem.index().row(), self.__rootItem.index(), False) else: self.__view.setRowHidden(categoryItem.index().row(), self.__rootItem.index(), True)
class OWTestLearners(widget.OWWidget): name = "Test Learners" description = "Cross-validation accuracy estimation." icon = "icons/TestLearners1.svg" priority = 100 inputs = [("Learner", Orange.classification.Learner, "set_learner", widget.Multiple), ("Data", Orange.data.Table, "set_train_data", widget.Default), ("Test Data", Orange.data.Table, "set_test_data")] outputs = [("Evaluation Results", Orange.evaluation.Results)] settingsHandler = settings.ClassValuesContextHandler() #: Resampling/testing types KFold, LeaveOneOut, Bootstrap, TestOnTrain, TestOnTest = 0, 1, 2, 3, 4 #: Selected resampling type resampling = settings.Setting(0) #: Number of folds for K-fold cross validation k_folds = settings.Setting(10) #: Number of repeats for bootstrap sampling n_repeat = settings.Setting(10) #: Bootstrap sampling p sample_p = settings.Setting(75) class_selection = settings.ContextSetting("(None)") def __init__(self, parent=None): super().__init__(parent) self.train_data = None self.test_data = None #: An Ordered dictionary with current inputs and their testing #: results. self.learners = OrderedDict() sbox = gui.widgetBox(self.controlArea, "Sampling") rbox = gui.radioButtons( sbox, self, "resampling", callback=self._param_changed ) gui.appendRadioButton(rbox, "Cross validation") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:", callback=self.kfold_changed) gui.appendRadioButton(rbox, "Leave one out") gui.appendRadioButton(rbox, "Random sampling") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test", callback=self.bootstrap_changed) gui.widgetLabel(ibox, "Relative training set size:") gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100, ticks=20, vertical=False, labelFormat="%d %%", callback=self.bootstrap_changed) gui.appendRadioButton(rbox, "Test on train data") gui.appendRadioButton(rbox, "Test on test data") rbox.layout().addSpacing(5) gui.button(rbox, self, "Apply", callback=self.apply) self.cbox = gui.widgetBox(self.controlArea, "Target class") self.class_selection_combo = gui.comboBox(self.cbox, self, "class_selection", items=[], callback=self._select_class, sendSelectedValue=True, valueType=str) gui.rubber(self.controlArea) self.view = QTreeView( rootIsDecorated=False, uniformRowHeights=True, wordWrap=True, editTriggers=QTreeView.NoEditTriggers ) header = self.view.header() header.setResizeMode(QHeaderView.ResizeToContents) header.setDefaultAlignment(Qt.AlignCenter) header.setStretchLastSection(False) self.result_model = QStandardItemModel() self.view.setModel(self.result_model) self.view.setItemDelegate(ItemDelegate()) self._update_header() box = gui.widgetBox(self.mainArea, "Evaluation Results") box.layout().addWidget(self.view) def set_learner(self, learner, key): if key in self.learners and learner is None: del self.learners[key] else: self.learners[key] = Input(learner, None, ()) self._update_stats_model() def set_train_data(self, data): self.error(0) if data and not data.domain.class_var: self.error(0, "Train data input requires a class variable") data = None self.train_data = data self.closeContext() if data is not None: self.openContext(data.domain.class_var) self._update_header() self._update_class_selection() self._invalidate() def set_test_data(self, data): self.error(1) if data and not data.domain.class_var: self.error(1, "Test data input requires a class variable") data = None self.test_data = data if self.resampling == OWTestLearners.TestOnTest: self._invalidate() def handleNewSignals(self): self.update_results() self.commit() def kfold_changed(self): self.resampling = OWTestLearners.KFold self._param_changed() def bootstrap_changed(self): self.resampling = OWTestLearners.Bootstrap self._param_changed() def _param_changed(self): self._invalidate() def update_results(self): self.warning([1, 2]) self.error(2) if self.train_data is None: return if self.resampling == OWTestLearners.TestOnTest: if self.test_data is None: self.warning(2, "Missing separate test data input") return elif self.test_data.domain.class_var != \ self.train_data.domain.class_var: self.error(2, ("Inconsistent class variable between test " + "and train data sets")) return # items in need of an update items = [(key, input) for key, input in self.learners.items() if input.results is None] learners = [input.learner for _, input in items] self.setStatusMessage("Running") if self.test_data is not None and \ self.resampling != OWTestLearners.TestOnTest: self.warning(1, "Test data is present but unused. " "Select 'Test on test data' to use it.") # TODO: Test each learner individually try: if self.resampling == OWTestLearners.KFold: results = Orange.evaluation.CrossValidation( self.train_data, learners, k=self.k_folds, store_data=True ) elif self.resampling == OWTestLearners.LeaveOneOut: results = Orange.evaluation.LeaveOneOut( self.train_data, learners, store_data=True ) elif self.resampling == OWTestLearners.Bootstrap: p = self.sample_p / 100.0 results = Orange.evaluation.Bootstrap( self.train_data, learners, n_resamples=self.n_repeat, p=p, store_data=True ) elif self.resampling == OWTestLearners.TestOnTrain: results = Orange.evaluation.TestOnTrainingData( self.train_data, learners, store_data=True ) elif self.resampling == OWTestLearners.TestOnTest: if self.test_data is None: return results = Orange.evaluation.TestOnTestData( self.train_data, self.test_data, learners, store_data=True ) else: assert False except Exception as e: self.error(2, str(e)) return self.results = results results = list(split_by_model(results)) class_var = self.train_data.domain.class_var if class_var.is_discrete: stats = [classification_stats(self.one_vs_rest(res)) for res in results] else: stats = [regression_stats(res) for res in results] self._update_header() for (key, input), res, stat in zip(items, results, stats): self.learners[key] = input._replace(results=res, stats=stat) self.setStatusMessage("") self._update_stats_model() def _update_header(self): headers = ["Method"] if self.train_data is not None: if self.train_data.domain.class_var.is_discrete: headers.extend(classification_stats.headers) else: headers.extend(regression_stats.headers) for i in reversed(range(len(headers), self.result_model.columnCount())): self.result_model.takeColumn(i) self.result_model.setHorizontalHeaderLabels(headers) def _update_stats_model(self): model = self.view.model() for r in reversed(range(model.rowCount())): model.takeRow(r) for input in self.learners.values(): name = learner_name(input.learner) row = [] head = QStandardItem() head.setData(name, Qt.DisplayRole) row.append(head) for stat in input.stats: item = QStandardItem() item.setData(" {:.3f} ".format(stat[0]), Qt.DisplayRole) row.append(item) model.appendRow(row) def _update_class_selection(self): self.class_selection_combo.clear() if not self.train_data: return if self.train_data.domain.class_var.is_discrete: self.cbox.setVisible(True) values = self.train_data.domain.class_var.values self.class_selection_combo.addItem("(None)") self.class_selection_combo.addItems(values) class_index = 0 if self.class_selection in self.train_data.domain.class_var.values: class_index = self.train_data.domain.class_var.values.index(self.class_selection)+1 else: self.class_selection = '(None)' self.class_selection_combo.setCurrentIndex(class_index) self.previous_class_selection = "(None)" else: self.cbox.setVisible(False) def one_vs_rest(self, res): if self.class_selection != '(None)' and self.class_selection != 0: class_ = self.train_data.domain.class_var.values.index(self.class_selection) actual = res.actual == class_ predicted = res.predicted == class_ return Results( nmethods=1, domain=self.train_data.domain, actual=actual, predicted=predicted) else: return res def _select_class(self): if self.previous_class_selection == self.class_selection: return results = list(split_by_model(self.results)) items = [(key, input) for key, input in self.learners.items()] learners = [input.learner for _, input in items] class_var = self.train_data.domain.class_var if class_var.is_discrete: stats = [classification_stats(self.one_vs_rest(res)) for res in results] else: stats = [regression_stats(res) for res in results] for (key, input), res, stat in zip(items, results, stats): self.learners[key] = input._replace(results=res, stats=stat) self.setStatusMessage("") self._update_stats_model() self.previous_class_selection = self.class_selection def _invalidate(self, which=None): if which is None: which = self.learners.keys() all_keys = list(self.learners.keys()) model = self.view.model() for key in which: self.learners[key] = \ self.learners[key]._replace(results=None, stats=None) if key in self.learners: row = all_keys.index(key) for c in range(1, model.columnCount()): item = model.item(row, c) if item is not None: item.setData(None, Qt.DisplayRole) def apply(self): self.update_results() self.commit() def commit(self): results = [val.results for val in self.learners.values() if val.results is not None] if results: combined = results_merge(results) combined.learner_names = [learner_name(val.learner) for val in self.learners.values()] else: combined = None self.send("Evaluation Results", combined)
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(3) 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(True) def __init__(self): super().__init__() self.data = None self.km = None self.optimization_runs = [] box = gui.vBox(self.controlArea, "Number of Clusters") layout = QGridLayout() self.n_clusters = bg = gui.radioButtonsInBox(box, self, "optimize_k", [], orientation=layout, callback=self.update) layout.addWidget( gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1) sb = gui.hBox(None, margin=0) 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 from", addToLayout=False), 2, 1) ftobox = gui.hBox(None) ftobox.layout().setContentsMargins(0, 0, 0, 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.vBox(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.hBox(None, margin=0) 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.hBox(None, margin=0) layout.addWidget(sb, 1, 1) gui.lineEdit(sb, self, "max_iterations", controlWidth=60, valueType=int, validator=QIntValidator(), callback=self.update) box = gui.vBox(self.controlArea, "Output") gui.comboBox(box, self, "place_cluster_ids", label="Append cluster ID as:", orientation=Qt.Horizontal, callback=self.send_data, items=self.OUTPUT_METHODS) gui.lineEdit(box, self, "output_name", label="Name:", orientation=Qt.Horizontal, callback=self.send_data) gui.separator(self.buttonsArea, 30) self.apply_button = gui.auto_commit(self.buttonsArea, self, "auto_run", "Apply", box=None) gui.rubber(self.controlArea) self.table_model = QStandardItemModel(self) self.table_model.setHorizontalHeaderLabels(["k", "Score"]) self.table_model.setColumnCount(2) self.table_box = gui.vBox(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, msg_group): msg_group.add_message( "not_enough_data", "Too few ({}) unique data instances for {} clusters") if n > len(self.data): msg_group.not_enough_data(len(self.data), n) return False else: msg_group.not_enough_data.clear() 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 not self.check_data_size(self.k_from, self.Error): return self.check_data_size(self.k_to, self.Warning) k_to = min(self.k_to, len(self.data)) kmeans = KMeans( init=['random', 'k-means++'][self.smart_init], n_init=self.n_init, max_iter=self.max_iterations, compute_silhouette_score=self.scoring == self.SILHOUETTE) with self.progressBar(k_to - self.k_from + 1) as progress: for k in range(self.k_from, 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, self.Error): 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.clear_messages() 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, np.floor(abs(math.log(max(max_score, 1e-10)))) + 2) fmt = "{{:.{}f}}".format(int(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) if not np.isnan(score) else 'out-of-memory error', 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): k_clusters = self.k if self.optimize_k and self.optimization_runs and self.selected_row( ) is not None: k_clusters = self.optimization_runs[self.selected_row()][1].k self.report_items( (("Number of clusters", k_clusters), ("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)
def data(self, index, role): """ \reimp Nodes' pointers are encapsulated in QStandardItem (role : Qt.UserRole + 1). Most of the data can only be retrieved only if the node is retrieved: * The node name * The node icon * ... To do so, the TreeModel.data() method calls the QStandardItemModel.data() method by passing the `index` parameter and `Qt.UserRole + 1` or `Qt.UserRole + 2` to it. In the second case, it retrieves a boolean used to know if the node is already expended and returns directly. \param index the index of the data we want to get \param role the role of the data we want to retrieve \return a QVariant containing the data, or an invalid QVariant if the data could not be retrieved. """ if not index.isValid(): return QVariant() # Qt.UserRole + 2 contain a boolean indicating if the node has already been expanded # in the tree. if role == Qt.UserRole + 3: return QStandardItemModel.data(self, index, role) if role == Qt.UserRole + 2: return QStandardItemModel.data(self, index, role) # call QStandardItemModel.data method with a Qt.UserRole + 1 to get the pointer on the node # (returns a invalid QVariant if the node or the data is None) data = QStandardItemModel.data(self, index, Qt.UserRole + 1) if not data.isValid(): return data # getting the node or returning an invalid QVariant() if the node is not valid uid, valid = data.toULongLong() if not valid: return QVariant() node = self.VFS.getNodeById(uid) if node is None: return QVariant() # if role == UserRole + 1, it means that the node itself must be returned (the pointer # on the node, encapsulated in a QVariant() if role == (Qt.UserRole + 1): return data # in other cases, returns the requires data : icon, color, etc. or an invalid QVariant() # if the role does not correpond to anything. if role == Qt.DisplayRole: display = QString.fromUtf8(node.name()) if self.displayCount: display += QString(" (" + str(node.totalChildrenCount()) + ")") return QVariant(display) if role == Qt.DecorationRole: pixmap = QPixmap(node.icon()) if node.hasChildren(): try: pfsobj = node.children()[0].fsobj( ).this #XXX fsobj have uid now except AttributeError: pfsobj = None try: nfsobj = node.fsobj().this except AttributeError: nfsobj = None if pfsobj != nfsobj: pixmap = pixmap.scaled(QSize(128, 128), Qt.KeepAspectRatio) painter = QPainter(pixmap) rootPixmap = QPixmap(":root") painter.drawPixmap(0, 0, rootPixmap) painter.end() return QVariant(QIcon(pixmap)) if role == Qt.BackgroundRole: if index == self.currentIndex: palette = QPalette().color(QPalette.Highlight) return QVariant(QColor(palette)) if role == Qt.ForegroundRole: if (index == self.currentIndex) and not node.isDeleted(): palette = QPalette().color(QPalette.HighlightedText) return QVariant(QColor(palette)) if node.isDeleted(): return QVariant(QColor(Qt.red)) if self.ch == True: if role == Qt.CheckStateRole: if index.column() == 0: if node.uid() in self.selection.get(): return Qt.Checked else: return Qt.Unchecked return QVariant()
def __init__(self, header, editable=False, parent=None): self.header = header self.editable = editable QStandardItemModel.__init__(self, 0, len(self.header), parent)