def makeModel(self, results, index = 2): getAttr = [lambda obj: obj.name, lambda obj: obj.size[0]*(1024**obj.size[1]), lambda obj: obj.seed, lambda obj: obj.leach] col = len(results) ascending = False if index == self.currentColumnSort[0] and self.currentColumnSort[1] else True self.currentColumnSort = [index, ascending] model = QStandardItemModel(col, 4, self) columnHeaderItems = [QStandardItem(column) for column in "Name", "Size", "Seeds", "Leachs"] columnHeaderItems[index].setIcon(self.ascendingIcon if ascending else self.descendingIcon) for i in range(4): model.setHorizontalHeaderItem(i, columnHeaderItems[i]) if results: results = list_to_tree(results, lambda x, y: getAttr[index](x) > getAttr[index](y)) if ascending: results = results.postOrder() else: results = results.preOrder() self.results = results for i in range(col): result = results[i] size = from_bit_to(result.size[0]*1024**result.size[1]) model.setItem(i, 0, QStandardItem(result.name)) model.setItem(i, 1, QStandardItem(size)) model.setItem(i, 2, QStandardItem(str(result.seed))) model.setItem(i, 3, QStandardItem(str(result.leach))) return model
def _guiUpdate_table(self,uuid): "" self.dbconn=DbConn() # self.uuid=self.dbconn.get_uuid() uuid='' self.meta=self.dbconn.get_meta_kv()[uuid] keys=self.meta.keys() model=QStandardItemModel() model.setHorizontalHeaderItem(0,QStandardItem("Attribute")) model.setHorizontalHeaderItem(1,QStandardItem("Value")) for k in keys: name=self.meta[k]['Attribute'] item1 = QStandardItem(k) item2 = QStandardItem(name) item1.setCheckable(True) model.appendRow([item1,item2]) # model.itemChanged.connect(lambda: on_item_changed()) self.model=model self.ui.metaeditor.setModel(model) self.ui.metaeditor.setEditTriggers(QAbstractItemView.NoEditTriggers) self.ui.metaeditor.sortByColumn(1) self.ui.metaeditor.resizeColumnsToContents()
def on_ions_updated(self, new_ions): qmodel = QStandardItemModel() qmodel.setColumnCount(2) qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion')) qmodel.setHorizontalHeaderItem(1, QStandardItem('Abundance (%)')) root = qmodel.invisibleRootItem() element_keyfunc = lambda x: x.isotope.element sorted_ions = sorted(new_ions, key=element_keyfunc) for element, ions in itertools.groupby(sorted_ions, key=element_keyfunc): element_item = QStandardItem(element) element_item.setCheckable(True) element_item.setCheckState(2) root.appendRow(element_item) for ion in ions: ion_name = QStandardItem(ion.name) ion_name.setData(ion,32) ion_name.emitDataChanged() ion_abundance = QStandardItem(str(ion.isotope.abundance)) element_item.appendRow([ion_name, ion_abundance]) self.ionlistTree.setModel(qmodel) self.ionlistTree.expandAll() self.addionsButton.setEnabled(True) self._qmodel=qmodel
def on_analyses_viewmodel_updated(self, view_model): qmodel = QStandardItemModel() qmodel.itemChanged.connect(self.on_qmodel_itemChanged) qmodel.setColumnCount(5) qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion')) qmodel.setHorizontalHeaderItem(1, QStandardItem('Method')) qmodel.setHorizontalHeaderItem(2, QStandardItem('Start')) qmodel.setHorizontalHeaderItem(3, QStandardItem('End')) qmodel.setHorizontalHeaderItem(4, QStandardItem('Reason')) root = qmodel.invisibleRootItem() for ion, analysis in view_model.analyses.items(): ion_name = QStandardItem(ion.name) ion_name.setData(ion, Qt.UserRole) method = QStandardItem(analysis.method) start = QStandardItem(str(round(analysis.range.start,2))) end = QStandardItem(str(round(analysis.range.end,2))) reason = QStandardItem(analysis.reason) root.appendRow([ion_name, method, start, end, reason]) self.rangedTable.setModel(qmodel) self.rangedTable.setItemDelegateForColumn(1, MethodsComboDelegate(view_model.methods, self.rangedTable)) for row in range(0, qmodel.rowCount()): self.rangedTable.openPersistentEditor(qmodel.index(row, 1)) self.rangedTable.setColumnWidth(1, 95) self.rangedTable.setContextMenuPolicy(3) self.rangedTable.customContextMenuRequested.connect(self._context_menu_requested) shortcut = QShortcut(QKeySequence('Del'), self.rangedTable, self._delete_ion,self._delete_ion, context=0)
def _guiUpdate_status(self,data): "" model=QStandardItemModel() model.setHorizontalHeaderItem(0,QStandardItem("attribute")) model.setHorizontalHeaderItem(1,QStandardItem("status")) for key in data.keys(): value=data[key] item1 = QStandardItem(key) item2 = QStandardItem(value) # item1.setCheckable(True) model.appendRow([item1,item2]) self.ui.outStatus.setModel(model) self.ui.outStatus.setEditTriggers(QAbstractItemView.NoEditTriggers) self.ui.outStatus.resizeColumnsToContents()
class Menu(TreeViewTela): def __init__(self, altura, parent=None): super().__init__(altura, parent) self._model = QStandardItemModel(0, 1) self._model.setHorizontalHeaderItem(0, QStandardItem("Menu")) self._itemsFuncoes = [] def setMenu(self, menu): self._adicionarSubMenu(menu, self._model.invisibleRootItem()) self.setSelecionado(self._model.index(0,0)) def getMenuSelecionado(self): sel = self.getSelecionado() s = '' while sel.isValid(): s = '/' + sel.data() + s sel = sel.parent() return s def getFuncaoItem(self, item): for i in self._itemsFuncoes: if i.item == item.data(): return i.funcao def getFuncaoItemSelecionado(self): return self.getFuncaoItem(self.getSelecionado()) def _adicionarSubMenu(self, subMenu, pai): if isinstance(subMenu, ItemFuncao): item = QStandardItem(subMenu.item) self._itemsFuncoes.append(subMenu) pai.appendRow(item) elif isinstance(subMenu, str): pai.appendRow(QStandardItem(subMenu)) elif isinstance(subMenu, (tuple, list)): for i in subMenu: self._adicionarSubMenu(i, pai) else: for key, value in subMenu.items(): p = QStandardItem(key) pai.appendRow(p) self._adicionarSubMenu(value, p)
def update(self): model = QStandardItemModel() model.setHorizontalHeaderItem(0, QStandardItem(i18n.get('account'))) model.setHorizontalHeaderItem(1, QStandardItem(i18n.get('message'))) self.list_.setModel(model) now = int(time.time()) interval = self.base.core.get_queue_interval() * 60 if self.last_timestamp: est_time = ((self.last_timestamp + interval) - now) / 60 else: est_time = 0 row = 0 for status in self.base.core.list_statuses_queue(): username = get_username_from(status.account_id) protocol_image = "%s.png" % get_protocol_from(status.account_id) item = QStandardItem(QString.fromUtf8(username)) item.setIcon(QIcon(self.base.load_image(protocol_image, True))) model.setItem(row, 0, item) model.setItem(row, 1, QStandardItem(QString.fromUtf8(status.text))) row += 1 humanized_interval = self.base.humanize_time_intervals( self.base.core.get_queue_interval()) humanized_est_time = self.base.humanize_time_intervals(est_time) warning = i18n.get('messages_will_be_send') % humanized_interval next_message = ' '.join( [i18n.get('next_message_should_be_posted_in'), humanized_est_time]) self.caption.setText(warning) if row == 0: self.estimated_time.setText('') else: self.estimated_time.setText(next_message) self.list_.horizontalHeader().setResizeMode(1, QHeaderView.Stretch) self.list_.resizeColumnsToContents() self.__enable()
def _guiUpdate_UUID(self): "" self.dbconn=DbConn() self.uuid=self.dbconn.get_uuid() keys=self.uuid.keys() model=QStandardItemModel() model.setHorizontalHeaderItem(0,QStandardItem("UUID")) model.setHorizontalHeaderItem(1,QStandardItem("Path")) def on_item_changed(): i = 0 list=[] while model.item(i): if not model.item(i,0).checkState(): "" # return else: # print model.item(i,0).text() list.append(model.item(i,0).text()) i += 1 self.UUIDList=list for key in keys: name=self.uuid[key]['Path'] item1 = QStandardItem(key) item2 = QStandardItem(name) # item1.setCheckable(True) model.appendRow([item1,item2]) model.itemChanged.connect(lambda: on_item_changed()) self.ui.model=model self.ui.inUUIDList.setModel(model) self.ui.inUUIDList.setEditTriggers(QAbstractItemView.NoEditTriggers) self.ui.inUUIDList.sortByColumn(1) self.ui.inUUIDList.resizeColumnsToContents()
def update(self): model = QStandardItemModel() model.setHorizontalHeaderItem(0, QStandardItem(i18n.get('account'))) model.setHorizontalHeaderItem(1, QStandardItem(i18n.get('message'))) self.list_.setModel(model) now = int(time.time()) interval = self.base.core.get_queue_interval() * 60 if self.last_timestamp: est_time = ((self.last_timestamp + interval) - now) / 60 else: est_time = 0 row = 0 for status in self.base.core.list_statuses_queue(): username = get_username_from(status.account_id) protocol_image = "%s.png" % get_protocol_from(status.account_id) item = QStandardItem(QString.fromUtf8(username)) item.setIcon(QIcon(self.base.load_image(protocol_image, True))) model.setItem(row, 0, item) model.setItem(row, 1, QStandardItem(QString.fromUtf8(status.text))) row += 1 humanized_interval = self.base.humanize_time_intervals(self.base.core.get_queue_interval()) humanized_est_time = self.base.humanize_time_intervals(est_time) warning = i18n.get('messages_will_be_send') % humanized_interval next_message = ' '.join([i18n.get('next_message_should_be_posted_in'), humanized_est_time]) self.caption.setText(warning) if row == 0: self.estimated_time.setText('') else: self.estimated_time.setText(next_message) self.list_.horizontalHeader().setResizeMode(1, QHeaderView.Stretch) self.list_.resizeColumnsToContents() self.__enable()
def _guiInit(self): "" keys=self.uuid.keys() # self.selUUIDList=[] model=QStandardItemModel() model.setHorizontalHeaderItem(0,QStandardItem("UUID")) model.setHorizontalHeaderItem(1,QStandardItem("Path")) def on_item_changed(): i = 0 list=[] while model.item(i): if not model.item(i,0).checkState(): "" # return else: list.append(model.item(i,0).text()) i += 1 self.UUIDList=list for key in keys: name=self.uuid[key]['Path'] item1 = QStandardItem(key) item2 = QStandardItem(name) item1.setCheckable(True) model.appendRow([item1,item2]) model.itemChanged.connect(lambda: on_item_changed()) self.ui.inUUIDList.setModel(model) self.ui.inUUIDList.setEditTriggers(QAbstractItemView.NoEditTriggers) self.ui.inUUIDList.sortByColumn(1)
class LookupValueSelector(QDialog, Ui_LookupValueSelector): """ A dialog that enables to select a value and code from a lookup. .. versionadded:: 1.5 """ def __init__(self, parent, lookup_entity_name, profile=None): """ """ QDialog.__init__(self, parent, Qt.WindowTitleHint|Qt.WindowCloseButtonHint) self.setupUi(self) self.value_and_code = None if profile is None: self._profile = current_profile() else: self._profile = profile self.lookup_entity = self._profile.entity_by_name( '{}_{}'.format(self._profile.prefix, lookup_entity_name) ) self.notice = NotificationBar(self.notice_bar) self._view_model = QStandardItemModel() self.value_list_box.setModel(self._view_model) header_item = QStandardItem(lookup_entity_name) self._view_model.setHorizontalHeaderItem(0, header_item) self.populate_value_list_view() self.selected_code = None self.selected_value_code = None self.value_list_box.clicked.connect(self.validate_selected_code) def populate_value_list_view(self): self.value_and_code = self.lookup_entity.values for value, code in self.value_and_code.iteritems(): value_code = QStandardItem('{} ({})'.format(value, code.code)) value_code.setData(code.code) self._view_model.appendRow(value_code) def validate_selected_code(self): self.notice.clear() self.selected_code_value() if self.selected_code == '': notice = QApplication.tr(self, 'The selected value has no code.') self.notice.insertWarningNotification(notice) def selected_code_value(self): index = self.value_list_box.currentIndex() item = self._view_model.itemFromIndex(index) self.selected_code = item.data() self.selected_value_code = item.text() def accept(self): self.selected_code_value() self.done(1) def reject(self): self.selected_code = None self.selected_value_code = None self.done(0)
class FileTypes(base2, form2): def __init__(self, parent=None): super(base2, self).__init__(parent) self.setupUi(self) self.model = QStandardItemModel() self.model.itemChanged.connect(self.on_item_changed) self.model.setHorizontalHeaderItem(0, QStandardItem("")) self.model_init() self.saveButton.clicked.connect(self.save) self.okCancelBox.accepted.connect(self.accept) self.okCancelBox.rejected.connect(self.reject) self.treeView.setContextMenuPolicy(Qt.CustomContextMenu) self.treeView.customContextMenuRequested.connect(self.openMenu) self.treeView.setToolTip( 'Here you can select file types that you want to find. Also you can\nadd new category or file type. Click right button on it.' ) def model_init(self): categories = {} if not categories: with open('categories.json') as f: categories = load(f) for element in categories: catItem = QStandardItem(element.keys()[0]) catItem.setCheckable(True) catItem.setCheckState(element[element.keys()[0]]) for type_name, check_state in element["Types"].items(): typeItem = QStandardItem(type_name) typeItem.setCheckable(True) typeItem.setCheckState(check_state) catItem.appendRow(typeItem) self.model.appendRow(catItem) self.treeView.setModel(self.model) self.submit_file_types() def quit(self): self.close() def on_item_changed(self, item): if item.checkState() == Qt.Checked: if item.hasChildren(): for row in range(item.rowCount()): item.child(row).setCheckState(Qt.Checked) else: item.parent().setCheckState(Qt.PartiallyChecked) elif item.checkState() == Qt.Unchecked: if item.hasChildren(): for row in range(item.rowCount()): item.child(row).setCheckState(Qt.Unchecked) else: children = range(item.parent().rowCount()) children.pop(item.index().row()) for row in children: if item.parent().child(row).checkState(): return item.parent().setCheckState(Qt.Unchecked) def submit_file_types(self): categories = [] root = self.model.invisibleRootItem() for num_cat in range(root.rowCount()): category = root.child(num_cat, 0) categories.append({ str(category.text()): category.checkState(), "Types": {} }) for num_type in range(category.rowCount()): type = category.child(num_type, 0) categories[-1]["Types"].update( {str(type.text()): type.checkState()}) return categories def openMenu(self, position): level = 0 index = self.treeView.selectedIndexes()[0] while index.parent().isValid(): index = index.parent() level += 1 menu = QMenu() if level == 0: menu.addAction(self.tr("Add category"), self.add_category) menu.addAction(self.tr("Add type"), self.add_type) menu.addAction(self.tr("Remove"), self.remove) elif level == 1: menu.addAction(self.tr("Add type"), self.add_type) menu.addAction(self.tr("Remove"), self.remove) menu.exec_(self.treeView.viewport().mapToGlobal(position)) def add_category(self): text, ok = QInputDialog.getText(self, 'Create new category', 'Category name:') if ok: catItem = QStandardItem(text) catItem.setCheckable(True) self.model.appendRow(catItem) #self.label.setText(unicode(text)) def add_type(self): text, ok = QInputDialog.getText(self, 'Add new type', 'Postfix:') if ok: catType = QStandardItem(text) catType.setCheckable(True) index = self.treeView.selectedIndexes()[0] if self.model.itemFromIndex(index).hasChildren(): self.model.itemFromIndex(index).appendRow(catType) else: self.model.itemFromIndex(index).parent().appendRow(catType) def save(self): with open('categories.json', 'w') as f: dump(self.submit_file_types(), f) def remove(self): index = self.treeView.selectedIndexes()[0] parent = self.model.itemFromIndex(index).parent() if parent: self.model.removeRow(index.row(), parent.index()) else: parent = self.model.invisibleRootItem() self.model.removeRow(index.row(), parent.index()) @staticmethod def call(): dialog = FileTypes() result = dialog.exec_() categories = dialog.submit_file_types() return categories, result == QDialog.Accepted
item = QStandardItem(str(i)) parent.appendRow(item) parent.appendRow(QStandardItem(str(i+1))) parent = item""" """model = QStandardItemModel(10, 4) for i in range(10): for j in range(4): item = QStandardItem("({0}, {1})".format(i, j)) model.setItem(i, j, item) if i == 1: item.appendRow([QStandardItem("..({0}, {1})".format(i*3, k)) for k in range(4)]) """ model = QStandardItemModel(2,1) model.setHorizontalHeaderItem(0,QStandardItem("Menu")) cadastro = QStandardItem("Cadastro") model.setItem(0,0,cadastro) pesquisa = QStandardItem("Pesquisa") model.setItem(1,0,pesquisa) for i in ["Usuarios", "Empresas"]: cadastro.appendRow(QStandardItem(i)) pesquisa.appendRow(QStandardItem(i)) parent = QModelIndex() """model = QDirModel() model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot) parent = model.index(QDir.currentPath())"""
def find_rules(self): if self.data is None or not len(self.data): return if self._is_running: return self._is_running = True data = self.data self.table.model().clear() n_examples = len(data) NumericItem = self.NumericItem StandardItem = self.StandardItem filterSearch = self.filterSearch itemsetMin = self.filterAntecedentMin + self.filterConsequentMin itemsetMax = self.filterAntecedentMax + self.filterConsequentMax isSizeMatch = self.isSizeMatch isRegexMatch = self.isRegexMatch X, mapping = OneHot.encode(data, self.classify) self.error(911) if X is None: self.error(911, 'Need some discrete data to work with.') self.onehot_mapping = mapping ITEM_FMT = '{}' if issparse(data.X) else '{}={}' names = { item: ('{}={}' if var is data.domain.class_var else ITEM_FMT).format( var.name, val) for item, var, val in OneHot.decode(mapping, data, mapping) } # Items that consequent must include if classifying class_items = { item for item, var, val in OneHot.decode(mapping, data, mapping) if var is data.domain.class_var } if self.classify else set() assert bool(class_items) == bool(self.classify) model = QStandardItemModel(self.table) for col, (label, tooltip) in enumerate([ ("Supp", "Support"), ("Conf", "Confidence (support / antecedent support)"), ("Covr", "Coverage (antecedent support / number of examples)"), ("Strg", "Strength (consequent support / antecedent support)"), ("Lift", "Lift (number of examples * confidence / consequent support)"), ("Levr", "Leverage ((support * number of examples - antecedent support * consequent support) / (number of examples)²)" ), ("Antecedent", None), ("", None), ("Consequent", None) ]): item = QStandardItem(label) item.setToolTip(tooltip) model.setHorizontalHeaderItem(col, item) #~ # Aggregate rules by common (support,confidence) for scatterplot #~ scatter_agg = defaultdict(list) # Find itemsets nRules = 0 itemsets = {} with self.progressBar(self.maxRules + 1) as progress: for itemset, support in frequent_itemsets(X, self.minSupport / 100): itemsets[itemset] = support if class_items and not class_items & itemset: continue # Filter itemset by joined filters before descending into it itemset_str = ' '.join(names[i] for i in itemset) if (filterSearch and (len(itemset) < itemsetMin or itemsetMax < len(itemset) or not isRegexMatch(itemset_str, itemset_str))): continue for rule in association_rules(itemsets, self.minConfidence / 100, itemset): left, right, support, confidence = rule if class_items and right - class_items: continue if filterSearch and not isSizeMatch(len(left), len(right)): continue left_str = ', '.join(names[i] for i in sorted(left)) right_str = ', '.join(names[i] for i in sorted(right)) if filterSearch and not isRegexMatch(left_str, right_str): continue # All filters matched, calculate stats and add table row _, _, _, _, coverage, strength, lift, leverage = next( rules_stats((rule, ), itemsets, n_examples)) support_item = NumericItem(support / n_examples) # Set row data on first column support_item.setData( (itemset - class_items, class_items and (class_items & itemset).pop()), self.ROW_DATA_ROLE) left_item = StandardItem(left_str, len(left)) left_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) model.appendRow([ support_item, NumericItem(confidence), NumericItem(coverage), NumericItem(strength), NumericItem(lift), NumericItem(leverage), left_item, StandardItem('→'), StandardItem(right_str, len(right)) ]) #~ scatter_agg[(round(support / n_examples, 2), round(confidence, 2))].append((left, right)) nRules += 1 progress.advance() if nRules >= self.maxRules: break if nRules >= self.maxRules: break # Populate the TableView table = self.table table.setHidden(True) table.setSortingEnabled(False) proxy_model = self.proxy_model proxy_model.setSourceModel(model) table.setModel(proxy_model) for i in range(model.columnCount()): table.resizeColumnToContents(i) table.setSortingEnabled(True) table.setHidden(False) self.nRules = nRules self.nFilteredRules = proxy_model.rowCount( ) # TODO: continue; also add in owitemsets self.nSelectedRules = 0 self.nSelectedExamples = 0 self._is_running = False
def set_groups(self, keys, groups, relevant_keys, relevant_items, all_values, uniquepos): """Set the current data groups and update the Group widget """ layout = QVBoxLayout() header_widths = [] header_views = [] palette = self.palette() all_values = all_values.keys() def for_print(rd): attrs = [] for d in rd: attr = Orange.data.ContinuousVariable(next(inactive_name_gen)) attr.attributes.update(d) attrs.append(attr) return Orange.data.Domain(attrs, None) for separatev, domain in [(None, for_print(relevant_items))] + groups: label = None if separatev is not None: ann_vals = " <b>|</b> ".join(["<b>{0}</ b> = {1}".format(key,val) \ for key, val in zip(keys, separatev)]) label = QLabel(ann_vals) model = QStandardItemModel() for i, attr in enumerate(domain.attributes): item = QStandardItem() if separatev is not None: isunique = uniquepos[separatev][i] else: isunique = all(a[i] for a in uniquepos.values()) if str(attr.name).startswith( "!!missing " ): # TODO: Change this to not depend on name header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \ for key in all_values if key not in relevant_items[i]] header_text = "\n".join( header_text) if header_text else "Empty" item.setData(header_text, Qt.DisplayRole) item.setFlags(Qt.NoItemFlags) item.setData(QColor(Qt.red), Qt.ForegroundRole) item.setData( palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole) item.setData("Missing feature.", Qt.ToolTipRole) elif str(attr.name).startswith("!!inactive "): header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \ for key in all_values if key in relevant_items[i]] header_text = "\n".join( header_text) if header_text else "No descriptor" item.setData(header_text, Qt.DisplayRole) item.setData( palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole) else: header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \ for key in all_values if key not in relevant_items[i]] header_text = "\n".join( header_text) if header_text else "Empty" item.setData(header_text, Qt.DisplayRole) item.setData(attr.name, Qt.ToolTipRole) if not isunique: item.setData(QColor(Qt.red), Qt.ForegroundRole) model.setHorizontalHeaderItem(i, item) attr_count = len(domain.attributes) view = MyHeaderView(Qt.Horizontal) view.setResizeMode(QHeaderView.Fixed) view.setModel(model) hint = view.sizeHint() view.setMaximumHeight(hint.height()) widths = [view.sectionSizeHint(i) for i in range(attr_count)] header_widths.append(widths) header_views.append(view) if label: layout.addWidget(label) layout.addWidget(view) layout.addSpacing(8) # Make all header sections the same width width_sum = 0 max_header_count = max([h.count() for h in header_views]) for i in range(max_header_count): max_width = max([w[i] for w in header_widths if i < len(w)] or [0]) for view in header_views: if i < view.count(): view.resizeSection(i, max_width) width_sum += max_width + 2 for h in header_views: h.setMinimumWidth(h.length() + 4) widget = QWidget() widget.setLayout(layout) widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Maximum) layout.activate() max_width = max(h.length() for h in header_views) + 20 left, _, right, _ = self.getContentsMargins() widget.setMinimumWidth(width_sum) widget.setMinimumWidth(max_width + left + right) self.groups_scroll_area.setWidget(widget)
class GPSV2(COMCUPluginBase, Ui_GPSV2): qtcb_pps = pyqtSignal() 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) self.fix_led_off_action = QAction('Off', self) self.fix_led_off_action.triggered.connect( lambda: self.gps.set_fix_led_config(BrickletGPSV2. FIX_LED_CONFIG_OFF)) self.fix_led_on_action = QAction('On', self) self.fix_led_on_action.triggered.connect( lambda: self.gps.set_fix_led_config(BrickletGPSV2.FIX_LED_CONFIG_ON )) self.fix_led_show_heartbeat_action = QAction('Show Heartbeat', self) self.fix_led_show_heartbeat_action.triggered.connect( lambda: self.gps.set_fix_led_config(BrickletGPSV2. FIX_LED_CONFIG_SHOW_HEARTBEAT)) self.fix_led_show_fix_action = QAction('Show Fix', self) self.fix_led_show_fix_action.triggered.connect( lambda: self.gps.set_fix_led_config(BrickletGPSV2. FIX_LED_CONFIG_SHOW_FIX)) self.fix_led_show_pps_action = QAction('Show PPS', self) self.fix_led_show_pps_action.triggered.connect( lambda: self.gps.set_fix_led_config(BrickletGPSV2. FIX_LED_CONFIG_SHOW_PPS)) self.extra_configs += [(1, 'Fix LED:', [ self.fix_led_off_action, self.fix_led_on_action, self.fix_led_show_heartbeat_action, self.fix_led_show_fix_action, self.fix_led_show_pps_action ])] def cb_pps(self): self.fix.setStyleSheet("QLabel { color : green; }") QTimer.singleShot(200, self.cb_pps_off) def cb_pps_off(self): self.fix.setStyleSheet("") def get_universal(self): return self.gps.get_coordinates( ), self.gps.get_status(), self.gps.get_altitude(), self.gps.get_motion( ), self.gps.get_date_time() def get_universal_gps(self): counter = self.gps_counter self.gps_counter = (self.gps_counter + 1) % 33 if counter == 0: return counter, self.gps.get_satellite_system_status( self.gps.SATELLITE_SYSTEM_GPS) else: return counter, self.gps.get_satellite_status( self.gps.SATELLITE_SYSTEM_GPS, counter) def get_universal_glo(self): counter = self.glo_counter self.glo_counter = (self.glo_counter + 1) % 33 if counter == 0: return counter, self.gps.get_satellite_system_status( self.gps.SATELLITE_SYSTEM_GLONASS) else: return counter, self.gps.get_satellite_status( self.gps.SATELLITE_SYSTEM_GLONASS, counter) def cb_universal_gps(self, data): try: counter, x = data if counter == 0: self.update_dop(self.gps_fix, self.gps_dop, self.gps_satallites_used, x) else: self.update_table(self.gps_model, counter, x) except: pass def cb_universal_glo(self, data): try: counter, x = data if counter == 0: self.update_dop(self.glo_fix, self.glo_dop, self.glo_satallites_used, x) else: self.update_table(self.glo_model, counter, x) except: pass def update_dop(self, fix, dop, used, data): if data.fix == 1: fix.setText("No Fix") elif data.fix == 2: fix.setText("2D Fix") elif data.fix == 3: fix.setText("3D Fix") else: fix.setText("Unknown") str_pdop = '%.2f' % (data.pdop / 100.0, ) str_hdop = '%.2f' % (data.hdop / 100.0, ) str_vdop = '%.2f' % (data.vdop / 100.0, ) dop.setText( str(str_vdop) + ' / ' + str(str_hdop) + ' / ' + str(str_pdop)) if len(data.satellite_numbers) == 0: used.setText('None') else: used.setText(', '.join(map(str, data.satellite_numbers))) def update_table(self, table_model, num, data): table_model.setItem(num - 1, 0, QStandardItem(str(data.elevation))) table_model.setItem(num - 1, 1, QStandardItem(str(data.azimuth))) table_model.setItem(num - 1, 2, QStandardItem(str(data.snr))) def cb_universal(self, data): try: coordinates, status, altitude, motion, date_time = data self.cb_coordinates(*coordinates) self.cb_status(*status) self.cb_altitude(*altitude) self.cb_motion(*motion) self.cb_date_time(*date_time) except: pass def show_pos_clicked(self): if self.had_fix: google_str = self.last_ns + self.make_dd_dddddd( self.last_lat, True) + '+' + self.last_ew + self.make_dd_dddddd( self.last_long, True) QDesktopServices.openUrl( QUrl('https://maps.google.com/maps?q=' + google_str)) else: QDesktopServices.openUrl( QUrl('http://www.google.com/moon/')) # :-) def format_changed(self, index): self.cb_coordinates(self.last_lat, self.last_ns, self.last_long, self.last_ew) def restart_clicked(self, restart_type): if restart_type > 0: self.had_fix = False # don't show cached data self.last_lat = 0 self.last_ns = 'U' self.last_long = 0 self.last_ew = 'U' self.satellites_view.setText('0') self.latitude.setText("Unknown") self.ns.setText('U') self.longitude.setText("Unknown") self.ew.setText('U') self.gps_dop.setText("Unknown") self.glo_dop.setText("Unknown") self.gps_satallites_used.setText("None") self.glo_satallites_used.setText("None") self.gps_fix.setText("No Fix") self.glo_fix.setText("No Fix") self.fix.setText("No") for i in range(32): self.gps_model.setItem(i, 0, QStandardItem('0')) self.gps_model.setItem(i, 1, QStandardItem('0')) self.gps_model.setItem(i, 2, QStandardItem('0')) self.glo_model.setItem(i, 0, QStandardItem('0')) self.glo_model.setItem(i, 1, QStandardItem('0')) self.glo_model.setItem(i, 2, QStandardItem('0')) self.altitude.setText("Unknown") self.course.setText("(Unknown)") self.speed.setText("Unknown") if restart_type > 1: self.time.setText("Unknown") self.gps.restart(restart_type) def get_fix_led_config_async(self, config): if config == BrickletGPSV2.FIX_LED_CONFIG_OFF: self.fix_led_off_action.trigger() elif config == BrickletGPSV2.FIX_LED_CONFIG_ON: self.fix_led_on_action.trigger() elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_HEARTBEAT: self.fix_led_show_heartbeat_action.trigger() elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_FIX: self.fix_led_show_fix_action.trigger() elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_PPS: self.fix_led_show_pps_action.trigger() def start(self): async_call(self.gps.get_fix_led_config, None, self.get_fix_led_config_async, self.increase_error_count) self.cbe_universal.set_period(250) self.cbe_universal_gps.set_period(100) self.cbe_universal_glo.set_period(100) def stop(self): self.cbe_universal.set_period(0) self.cbe_universal_gps.set_period(0) self.cbe_universal_glo.set_period(0) def destroy(self): pass @staticmethod def has_device_identifier(device_identifier): return device_identifier == BrickletGPSV2.DEVICE_IDENTIFIER def make_ddmm_mmmmm(self, degree): dd = degree / 1000000 mm = (degree % 1000000) * 60 / 1000000.0 mmmmm = (mm - int(mm)) * 100000 dd_str = str(dd) mm_str = str(int(mm)) mmmmm_str = str(int(mmmmm + 0.5)) while len(mm_str) < 2: mm_str = '0' + mm_str while len(mmmmm_str) < 5: mmmmm_str = '0' + mmmmm_str return u'{0}° {1}.{2}’'.format(dd_str, mm_str, mmmmm_str) def make_dd_dddddd(self, degree, url=False): if url: return '%2.6f' % (degree / 1000000.0) else: return u'%2.6f°' % (degree / 1000000.0) def make_ddmmss_sss(self, degree): dd = degree / 1000000 mm = (degree % 1000000) * 60 / 1000000.0 ss = (mm - int(mm)) * 60 sss = (ss - int(ss)) * 1000 dd_str = str(dd) mm_str = str(int(mm)) ss_str = str(int(ss)) sss_str = str(int(sss + 0.5)) while len(mm_str) < 2: mm_str = '0' + mm_str while len(ss_str) < 2: ss_str = '0' + ss_str while len(sss_str) < 3: sss_str = '0' + sss_str return u'{0}° {1}’ {2}.{3}’’'.format(dd_str, mm_str, ss_str, sss_str) def cb_coordinates(self, lat, ns, long_, ew): if not self.had_fix: return self.last_lat = lat self.last_ns = ns self.last_long = long_ self.last_ew = ew if not ns in ('N', 'S'): self.latitude.setText("Unknown") self.ns.setText('U') else: self.ns.setText(ns) if self.format_combobox.currentIndex() == 0: self.latitude.setText(self.make_ddmmss_sss(lat)) elif self.format_combobox.currentIndex() == 1: self.latitude.setText(self.make_dd_dddddd(lat)) elif self.format_combobox.currentIndex() == 2: self.latitude.setText(self.make_ddmm_mmmmm(lat)) if not ew in ('E', 'W'): self.longitude.setText("Unknown") self.ew.setText('U') else: self.ew.setText(ew) if self.format_combobox.currentIndex() == 0: self.longitude.setText(self.make_ddmmss_sss(long_)) elif self.format_combobox.currentIndex() == 1: self.longitude.setText(self.make_dd_dddddd(long_)) elif self.format_combobox.currentIndex() == 2: self.longitude.setText(self.make_ddmm_mmmmm(long_)) def cb_status(self, has_fix, satellites_view): if has_fix: self.fix.setText("Yes") self.had_fix = True else: self.fix.setText("No") self.satellites_view.setText(str(satellites_view)) def cb_altitude(self, altitude, geoidal_separation): if not self.had_fix: return self.altitude.setText('%.2f m (Geoidal Separation: %.2f m)' % (altitude / 100.0, geoidal_separation / 100.0)) def cb_motion(self, course, speed): if not self.had_fix: return self.course.setText(u'(%.2f°)' % (course / 100.0, )) self.speed.setText('%.2f km/h' % (speed / 100.0, )) def cb_date_time(self, date, time): yy = date % 100 yy += 2000 date /= 100 mm = date % 100 date /= 100 dd = date time /= 1000 ss = time % 100 time /= 100 mins = time % 100 time /= 100 hh = time try: date_str = str(datetime.datetime(yy, mm, dd, hh, mins, ss)) + " UTC" except: date_str = "Unknown" self.time.setText(date_str)
class GPS(COMCUPluginBase, Ui_GPS): qtcb_pps = pyqtSignal() 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 cb_pps(self): self.fix.setStyleSheet("QLabel { color : green; }") QTimer.singleShot(200, self.cb_pps_off) def cb_pps_off(self): self.fix.setStyleSheet("QLabel { color : black; }") def get_universal(self): return ( self.gps.get_coordinates(), self.gps.get_status(), self.gps.get_altitude(), self.gps.get_motion(), self.gps.get_date_time(), ) def get_universal_gps(self): counter = self.gps_counter self.gps_counter = (self.gps_counter + 1) % 33 if counter == 0: return counter, self.gps.get_satellite_system_status(self.gps.SATELLITE_SYSTEM_GPS) else: return counter, self.gps.get_satellite_status(self.gps.SATELLITE_SYSTEM_GPS, counter) def get_universal_glo(self): counter = self.glo_counter self.glo_counter = (self.glo_counter + 1) % 33 if counter == 0: return counter, self.gps.get_satellite_system_status(self.gps.SATELLITE_SYSTEM_GLONASS) else: return counter, self.gps.get_satellite_status(self.gps.SATELLITE_SYSTEM_GLONASS, counter) def cb_universal_gps(self, data): try: counter, x = data if counter == 0: self.update_dop(self.gps_fix, self.gps_dop, self.gps_satallites_used, x) else: self.update_table(self.gps_model, counter, x) except: pass def cb_universal_glo(self, data): try: counter, x = data if counter == 0: self.update_dop(self.glo_fix, self.glo_dop, self.glo_satallites_used, x) else: self.update_table(self.glo_model, counter, x) except: pass def update_dop(self, fix, dop, used, data): if data.fix == 1: fix.setText("No Fix") elif data.fix == 2: fix.setText("2D Fix") elif data.fix == 3: fix.setText("3D Fix") else: fix.setText("Error") str_pdop = "%.2f" % (data.pdop / 100.0,) str_hdop = "%.2f" % (data.hdop / 100.0,) str_vdop = "%.2f" % (data.vdop / 100.0,) dop.setText(str(str_pdop) + " / " + str(str_hdop) + " / " + str(str_vdop)) sats = [] for sat in data.satellites: if sat != 0: sats.append(sat) if len(sats) == 0: used.setText("None") else: used.setText(", ".join(map(str, sats))) def update_table(self, table_model, num, data): table_model.setItem(num - 1, 0, QStandardItem(str(data.elevation))) table_model.setItem(num - 1, 1, QStandardItem(str(data.azimuth))) table_model.setItem(num - 1, 2, QStandardItem(str(data.snr))) def cb_universal(self, data): try: coordinates, status, altitude, motion, date_time = data self.cb_coordinates(*coordinates) self.cb_status(*status) self.cb_altitude(*altitude) self.cb_motion(*motion) self.cb_date_time(*date_time) except: pass def show_pos_clicked(self): if self.had_fix: google_str = ( self.last_ns + self.make_dd_dddddd(self.last_lat, True) + "+" + self.last_ew + self.make_dd_dddddd(self.last_long, True) ) QDesktopServices.openUrl(QUrl("https://maps.google.com/maps?q=" + google_str)) else: QDesktopServices.openUrl(QUrl("http://www.google.com/moon/")) # :-) def format_changed(self, index): self.cb_coordinates(self.last_lat, self.last_ns, self.last_long, self.last_ew) def restart_clicked(self, restart_type): if restart_type > 0: self.had_fix = False # don't show cached data self.last_lat = 0 self.last_ns = "U" self.last_long = 0 self.last_ew = "U" self.satellites_view.setText("0") self.latitude.setText("Unknown") self.ns.setText("U") self.longitude.setText("Unknown") self.ew.setText("U") self.gps_dop.setText("Unknown") self.glo_dop.setText("Unknown") self.gps_satallites_used.setText("None") self.glo_satallites_used.setText("None") self.gps_fix.setText("No Fix") self.glo_fix.setText("No Fix") self.fix.setText("No") for i in range(32): self.gps_model.setItem(i, 0, QStandardItem("0")) self.gps_model.setItem(i, 1, QStandardItem("0")) self.gps_model.setItem(i, 2, QStandardItem("0")) self.glo_model.setItem(i, 0, QStandardItem("0")) self.glo_model.setItem(i, 1, QStandardItem("0")) self.glo_model.setItem(i, 2, QStandardItem("0")) self.altitude.setText("Unknown") self.course.setText("(Unknown)") self.speed.setText("Unknown") if restart_type > 1: self.time.setText("Unknown") self.gps.restart(restart_type) def start(self): self.cbe_universal.set_period(250) self.cbe_universal_gps.set_period(100) self.cbe_universal_glo.set_period(100) def stop(self): self.cbe_universal.set_period(0) self.cbe_universal_gps.set_period(0) self.cbe_universal_glo.set_period(0) def destroy(self): pass def get_url_part(self): return "gps" @staticmethod def has_device_identifier(device_identifier): return device_identifier == BrickletGPSV2.DEVICE_IDENTIFIER def make_ddmm_mmmmm(self, degree): dd = degree / 1000000 mm = (degree % 1000000) * 60 / 1000000.0 mmmmm = (mm - int(mm)) * 100000 dd_str = str(dd) mm_str = str(int(mm)) mmmmm_str = str(int(mmmmm + 0.5)) while len(mm_str) < 2: mm_str = "0" + mm_str while len(mmmmm_str) < 5: mmmmm_str = "0" + mmmmm_str return u"{0}° {1}.{2}’".format(dd_str, mm_str, mmmmm_str) def make_dd_dddddd(self, degree, url=False): if url: return "%2.6f" % (degree / 1000000.0) else: return u"%2.6f°" % (degree / 1000000.0) def make_ddmmss_sss(self, degree): dd = degree / 1000000 mm = (degree % 1000000) * 60 / 1000000.0 ss = (mm - int(mm)) * 60 sss = (ss - int(ss)) * 1000 dd_str = str(dd) mm_str = str(int(mm)) ss_str = str(int(ss)) sss_str = str(int(sss + 0.5)) while len(mm_str) < 2: mm_str = "0" + mm_str while len(ss_str) < 2: ss_str = "0" + ss_str while len(sss_str) < 3: sss_str = "0" + sss_str return u"{0}° {1}’ {2}.{3}’’".format(dd_str, mm_str, ss_str, sss_str) def cb_coordinates(self, lat, ns, long_, ew): if not self.had_fix: return self.last_lat = lat self.last_ns = ns self.last_long = long_ self.last_ew = ew if not ns in ("N", "S"): self.latitude.setText("Unknown") self.ns.setText("U") else: self.ns.setText(ns) if self.format_combobox.currentIndex() == 0: self.latitude.setText(self.make_ddmmss_sss(lat)) elif self.format_combobox.currentIndex() == 1: self.latitude.setText(self.make_dd_dddddd(lat)) elif self.format_combobox.currentIndex() == 2: self.latitude.setText(self.make_ddmm_mmmmm(lat)) if not ew in ("E", "W"): self.longitude.setText("Unknown") self.ew.setText("U") else: self.ew.setText(ew) if self.format_combobox.currentIndex() == 0: self.longitude.setText(self.make_ddmmss_sss(long_)) elif self.format_combobox.currentIndex() == 1: self.longitude.setText(self.make_dd_dddddd(long_)) elif self.format_combobox.currentIndex() == 2: self.longitude.setText(self.make_ddmm_mmmmm(long_)) def cb_status(self, has_fix, satellites_view): if has_fix: self.fix.setText("Yes") self.had_fix = True else: self.fix.setText("No") self.satellites_view.setText(str(satellites_view)) def cb_altitude(self, altitude, geoidal_separation): if not self.had_fix: return self.altitude.setText("%.2f m (Geoidal Separation: %.2f m)" % (altitude / 100.0, geoidal_separation / 100.0)) def cb_motion(self, course, speed): if not self.had_fix: return self.course.setText(u"(%.2f°)" % (course / 100.0,)) self.speed.setText("%.2f km/h" % (speed / 100.0,)) def cb_date_time(self, date, time): yy = date % 100 yy += 2000 date /= 100 mm = date % 100 date /= 100 dd = date time /= 1000 ss = time % 100 time /= 100 mins = time % 100 time /= 100 hh = time try: date_str = str(datetime.datetime(yy, mm, dd, hh, mins, ss)) + " UTC" except: date_str = "Unknown" self.time.setText(date_str)
def set_groups(self, keys, groups, relevant_keys, relevant_items, all_values, uniquepos): """Set the current data groups and update the Group widget """ layout = QVBoxLayout() header_widths = [] header_views = [] palette = self.palette() all_values = all_values.keys() def for_print(rd): attrs = [] for d in rd: attr = Orange.data.ContinuousVariable(next(inactive_name_gen)) attr.attributes.update(d) attrs.append(attr) return Orange.data.Domain(attrs, None) for separatev, domain in [(None, for_print(relevant_items))] + groups: label = None if separatev is not None: ann_vals = " <b>|</b> ".join(["<b>{0}</ b> = {1}".format(key,val) \ for key, val in zip(keys, separatev)]) label = QLabel(ann_vals) model = QStandardItemModel() for i, attr in enumerate(domain.attributes): item = QStandardItem() if separatev is not None: isunique = uniquepos[separatev][i] else: isunique = all(a[i] for a in uniquepos.values()) if str(attr.name).startswith("!!missing "): # TODO: Change this to not depend on name header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \ for key in all_values if key not in relevant_items[i]] header_text = "\n".join(header_text) if header_text else "Empty" item.setData(header_text, Qt.DisplayRole) item.setFlags(Qt.NoItemFlags) item.setData(QColor(Qt.red), Qt.ForegroundRole) item.setData(palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole) item.setData("Missing feature.", Qt.ToolTipRole) elif str(attr.name).startswith("!!inactive "): header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \ for key in all_values if key in relevant_items[i]] header_text = "\n".join(header_text) if header_text else "No descriptor" item.setData(header_text, Qt.DisplayRole) item.setData(palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole) else: header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \ for key in all_values if key not in relevant_items[i]] header_text = "\n".join(header_text) if header_text else "Empty" item.setData(header_text, Qt.DisplayRole) item.setData(attr.name, Qt.ToolTipRole) if not isunique: item.setData(QColor(Qt.red), Qt.ForegroundRole) model.setHorizontalHeaderItem(i, item) attr_count = len(domain.attributes) view = MyHeaderView(Qt.Horizontal) view.setResizeMode(QHeaderView.Fixed) view.setModel(model) hint = view.sizeHint() view.setMaximumHeight(hint.height()) widths = [view.sectionSizeHint(i) for i in range(attr_count)] header_widths.append(widths) header_views.append(view) if label: layout.addWidget(label) layout.addWidget(view) layout.addSpacing(8) # Make all header sections the same width width_sum = 0 max_header_count = max([h.count() for h in header_views]) for i in range(max_header_count): max_width = max([w[i] for w in header_widths if i < len(w)] or [0]) for view in header_views: if i < view.count(): view.resizeSection(i, max_width) width_sum += max_width + 2 for h in header_views: h.setMinimumWidth(h.length() + 4) widget = QWidget() widget.setLayout(layout) widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Maximum) layout.activate() max_width = max(h.length() for h in header_views) + 20 left, _, right, _ = self.getContentsMargins() widget.setMinimumWidth(width_sum) widget.setMinimumWidth(max_width + left + right) self.groups_scroll_area.setWidget(widget)
class TreeLegend(QObject): toggledLegend = pyqtSignal(list) descriptionLegend = pyqtSignal(str) def __init__(self, treeView): def init(): self.setHeader() self.tree.setModel(self.model) self.headerView.setMovable(False) self.headerView.setClickable(True) self.tree.setSelectionMode(0) # no selection super(TreeLegend, self).__init__() self.tree = treeView # self.hasConnect = self.layer = self.legendItems = None self.visibleItems = [] self.model = QStandardItemModel(0, 1) self.headerView = self.tree.header() # init() self._connect() def __del__(self): if self.hasConnect: self._connect(False) self.model.clear() self.layer.legendChanged.disconnect(self.updateLegendItems) def _connect(self, isConnect=True): ss = [{ 'signal': self.tree.clicked, 'slot': self.toggleItem }, { 'signal': self.headerView.sectionClicked, 'slot': self.toggleHeader }, { 'signal': self.headerView.sectionDoubleClicked, 'slot': self.emitDescription }] if isConnect: self.hasConnect = True for item in ss: item['signal'].connect(item['slot']) else: self.hasConnect = False for item in ss: item['signal'].disconnect(item['slot']) def setHeader(self, data=None): if data is None: self.model.clear() nameHeader = 'Select Raster Layer(Palette)' font = QFont() font.setStrikeOut(False) headerModel = QStandardItem(nameHeader) headerModel.setData(font, Qt.FontRole) tip = "Raster with Palette(Single Band)" headerModel.setData(tip, Qt.ToolTipRole) self.model.setHorizontalHeaderItem(0, headerModel) else: headerModel = self.model.horizontalHeaderItem(0) label = "%s" % data['name'] formatMgs = "Layer: %s\nSource: %s\nNumber Class: %d\nWidth: %d\nHeight: %d\nRes.X: %f\nRes.Y: %f\n\n* Double click copy to Clipboard" dataMsg = (data['name'], data['source'], data['num_class'], data['width'], data['height'], data['resX'], data['resY']) tip = formatMgs % dataMsg headerModel.setData(data, Qt.UserRole) headerModel.setData(label, Qt.DisplayRole) headerModel.setData(tip, Qt.ToolTipRole) def setLayer(self, layer): self.legendItems = layer.legendSymbologyItems() total = len(self.legendItems) self.visibleItems = [True for x in range(total)] data = { 'name': layer.name(), 'source': layer.source(), 'num_class': total, 'width': layer.width(), 'height': layer.height(), 'resX': layer.rasterUnitsPerPixelX(), 'resY': layer.rasterUnitsPerPixelY() } self.setHeader(data) # if not self.layer is None: self.layer.legendChanged.disconnect(self.updateLegendItems) layer.legendChanged.connect(self.updateLegendItems) self.layer = layer def setLegend(self, values): def setHeader(): headerModel = self.model.horizontalHeaderItem(0) data = headerModel.data(Qt.UserRole) data['num_class'] = len(values) self.setHeader(data) def createItem(item): (pixel, total) = item (legend, color) = self.legendItems[pixel] name = "[%d] %s" % (pixel, legend) tip = "Value pixel: %d\nTotal pixels: %d\nClass name: %s" % ( pixel, total, legend) pix = QPixmap(16, 16) pix.fill(color) font.setStrikeOut(not self.visibleItems[pixel]) # itemModel = QStandardItem(QIcon(pix), name) itemModel.setEditable(False) itemModel.setData(font, Qt.FontRole) itemModel.setData(tip, Qt.ToolTipRole) itemModel.setData(item, Qt.UserRole) # return itemModel setHeader() self.model.removeRows(0, self.model.rowCount()) # font = QFont() for item in values: self.model.appendRow(createItem(item)) def setEnabled(self, isEnable=True): self._connect(isEnable) self.tree.setEnabled(isEnable) def getLayerName(self): headerModel = self.model.horizontalHeaderItem(0) return headerModel.data(Qt.UserRole)['name'] @pyqtSlot() def updateLegendItems(self): self.legendItems = self.layer.legendSymbologyItems() # Refresh legend rows = self.model.rowCount() row = 0 while row < rows: index = self.model.index(row, 0) (pixel, total) = self.model.data(index, Qt.UserRole) (legend, color) = self.legendItems[pixel] pix = QPixmap(16, 16) pix.fill(color) self.model.setData(index, QIcon(pix), Qt.DecorationRole) row += 1 @pyqtSlot('QModelIndex') def toggleItem(self, index): font = index.data(Qt.FontRole) strike = not font.strikeOut() font.setStrikeOut(strike) self.model.setData(index, font, Qt.FontRole) # (pixel, total) = index.data(Qt.UserRole) visible = not strike self.visibleItems[pixel] = visible # self.toggledLegend.emit(self.visibleItems) @pyqtSlot(int) def toggleHeader(self, logical): rowCount = self.model.rowCount() if rowCount == 0: return header = self.model.horizontalHeaderItem(0) font = header.data(Qt.FontRole) strike = not font.strikeOut() font.setStrikeOut(strike) header.setData(font, Qt.FontRole) # items = [] row = 0 while row < self.model.rowCount(): index = self.model.index(row, 0) self.model.setData(index, font, Qt.FontRole) items.append(index.data(Qt.UserRole)) row += 1 visible = not strike for item in items: (pixel, total) = item self.visibleItems[pixel] = visible # self.toggledLegend.emit(self.visibleItems) @pyqtSlot(int) def emitDescription(self): def getDescription(): data = self.model.horizontalHeaderItem(0).data(Qt.UserRole) formatMgs = "Layer: %s\nSource: %s\nNumber Class: %d\nWidth: %d\nHeight: %d\nRes.X: %f\nRes.Y: %f" dataMsg = (data['name'], data['source'], data['num_class'], data['width'], data['height'], data['resX'], data['resY']) descHeader = formatMgs % dataMsg # descItems = ["Value pixel;Total pixels;Class name"] rows = self.model.rowCount() row = 0 while row < rows: index = self.model.index(row, 0) (pixel, total) = self.model.data(index, Qt.UserRole) (legend, color) = self.legendItems[pixel] descItems.append("%d;%d;%s" % (pixel, total, legend)) row += 1 return "%s\n\n%s" % (descHeader, '\n'.join(descItems)) if self.model.rowCount() > 0: self.descriptionLegend.emit(getDescription())
class LookupValueSelector(QDialog, Ui_LookupValueSelector): """ A dialog that enables to select a value and code from a lookup. .. versionadded:: 1.5 """ def __init__(self, parent, lookup_entity_name, profile=None): """ Initializes LookupValueSelector. :param parent: The parent of the dialog. :type parent: QWidget :param lookup_entity_name: The lookup entity name :type lookup_entity_name: String :param profile: The current profile object :type profile: Object """ QDialog.__init__(self, parent, Qt.WindowTitleHint | Qt.WindowCloseButtonHint) self.setupUi(self) self.value_and_code = None if profile is None: self._profile = current_profile() else: self._profile = profile self.lookup_entity = self._profile.entity_by_name( '{}_{}'.format(self._profile.prefix, lookup_entity_name) ) self.notice = NotificationBar(self.notice_bar) self._view_model = QStandardItemModel() self.value_list_box.setModel(self._view_model) header_item = QStandardItem(lookup_entity_name) self._view_model.setHorizontalHeaderItem(0, header_item) self.populate_value_list_view() self.selected_code = None self.selected_value_code = None self.value_list_box.clicked.connect(self.validate_selected_code) def populate_value_list_view(self): """ Populates the lookup values and codes. """ self.value_and_code = self.lookup_entity.values for value, code in self.value_and_code.iteritems(): u_value = unicode(value) code_value = self.lookup_entity.values[u_value] value_code = QStandardItem('{} ({})'.format( code_value.value, code.code ) ) value_code.setData(code.code) self._view_model.appendRow(value_code) def validate_selected_code(self): """ Validate the selected code for the presence of Code or not. """ self.notice.clear() self.selected_code_value() if self.selected_code == '': notice = QApplication.tr(self, 'The selected value has no code.') self.notice.insertWarningNotification(notice) def selected_code_value(self): """ Get the selected lookup value. """ index = self.value_list_box.currentIndex() item = self._view_model.itemFromIndex(index) self.selected_code = item.data() self.selected_value_code = item.text() def accept(self): """ Overridden QDialog accept method. """ self.selected_code_value() self.done(1) def reject(self): """ Overridden QDialog accept method. """ self.selected_code = None self.selected_value_code = None self.done(0)
class LookupValueSelector(QDialog, Ui_LookupValueSelector): """ A dialog that enables to select a value and code from a lookup. .. versionadded:: 1.5 """ def __init__(self, parent, lookup_entity_name, profile=None): """ Initializes LookupValueSelector. :param parent: The parent of the dialog. :type parent: QWidget :param lookup_entity_name: The lookup entity name :type lookup_entity_name: String :param profile: The current profile object :type profile: Object """ QDialog.__init__(self, parent, Qt.WindowTitleHint | Qt.WindowCloseButtonHint) self.setupUi(self) self.value_and_code = None if profile is None: self._profile = current_profile() else: self._profile = profile self.lookup_entity = self._profile.entity_by_name('{}_{}'.format( self._profile.prefix, lookup_entity_name)) self.notice = NotificationBar(self.notice_bar) self._view_model = QStandardItemModel() self.value_list_box.setModel(self._view_model) header_item = QStandardItem(lookup_entity_name) self._view_model.setHorizontalHeaderItem(0, header_item) self.populate_value_list_view() self.selected_code = None self.selected_value_code = None self.value_list_box.clicked.connect(self.validate_selected_code) def populate_value_list_view(self): """ Populates the lookup values and codes. """ self.value_and_code = self.lookup_entity.values for value, code in self.value_and_code.iteritems(): u_value = unicode(value) code_value = self.lookup_entity.values[u_value] value_code = QStandardItem('{} ({})'.format( code_value.value, code.code)) value_code.setData(code.code) self._view_model.appendRow(value_code) def validate_selected_code(self): """ Validate the selected code for the presence of Code or not. """ self.notice.clear() self.selected_code_value() if self.selected_code == '': notice = QApplication.tr(self, 'The selected value has no code.') self.notice.insertWarningNotification(notice) def selected_code_value(self): """ Get the selected lookup value. """ index = self.value_list_box.currentIndex() item = self._view_model.itemFromIndex(index) self.selected_code = item.data() self.selected_value_code = item.text() def accept(self): """ Overridden QDialog accept method. """ self.selected_code_value() self.done(1) def reject(self): """ Overridden QDialog accept method. """ self.selected_code = None self.selected_value_code = None self.done(0)
class MainWindow(QMainWindow): def __init__(self): QMainWindow.__init__(self) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.setCentralWidget(self.ui.mangaTableView) self.newMangaDialog = NewMangaDialog() self.mangaDownloadDialog = MangaDownloadDialog() self.mangaTableModel = QStandardItemModel(0, 3, self) self.mangaTableModel.setHorizontalHeaderItem(0, QStandardItem(QString("Manga"))) self.mangaTableModel.setHorizontalHeaderItem(1, QStandardItem(QString("Latest Chapter"))) self.mangaTableModel.setHorizontalHeaderItem(2, QStandardItem(QString("Status"))) self.ui.mangaTableView.setModel(self.mangaTableModel) newMangaAction = QAction(QIcon("./icon/add.ico"),'New Manga', self) newMangaAction.setShortcut('Ctrl+N') newMangaAction.triggered.connect(self.newMangaDialog.show) removeMangaAction = QAction(QIcon("./icon/delete.ico"),'Remove Manga', self) removeMangaAction.setShortcut('Delete') preferencesAction = QAction(QIcon("./icon/preferences.ico"),'Preferences', self) aboutAction = QAction(QIcon("./icon/about.ico"),'About', self) self.ui.toolBar.addAction(newMangaAction) self.ui.toolBar.addAction(removeMangaAction) self.ui.toolBar.addSeparator() self.ui.toolBar.addAction(preferencesAction) self.ui.toolBar.addSeparator() self.ui.toolBar.addAction(aboutAction) self.progressBar = QProgressBar(self.ui.statusbar) self.ui.statusbar.addPermanentWidget(self.progressBar) self.progressBar.hide() def closeEvent(self, QCloseEvent): mangaList = [] for i in range(self.mangaTableModel.rowCount()): mangaList.append({ "name" : str(self.mangaTableModel.item(i, 0).text()), "latestChapter" : str(self.mangaTableModel.item(i, 1).text()), "status" : "Updated", "link" : "/trial.html" }) self.emit(SIGNAL("applicationClosed"),mangaList) def initializeProgressBar(self, size): self.progressBar.setRange(0, size) self.progressBar.setValue(0) self.progressBar.show() def updateProgressBar(self, value): self.progressBar.setValue(value) def updateStatusBar(self, msg): self.ui.statusbar.showMessage(msg) def updateMangaTable(self, chapter): isFound = False for i in range(self.mangaTableModel.rowCount()): mangaItem = self.mangaTableModel.item(i) if mangaItem.text() == chapter["name"]: self.mangaTableModel.item(i, 1).setText(chapter["latestChapter"]) self.mangaTableModel.item(i, 2).setText(chapter["status"]) isFound = True break if not isFound: self.addRowToMangaTable(chapter) def addMangaListToMangaTable(self, mangaList): for i in range(len(mangaList)): self.addRowToMangaTable(mangaList[i]) def addRowToMangaTable(self, manga): i = self.mangaTableModel.rowCount() mangaItem = QStandardItem(QString(manga["name"])) latestChapterItem = QStandardItem(QString(manga["latestChapter"])) statusItem = QStandardItem(QString(manga["status"])) brush = QBrush(QColor(255, 255, 255)) if i%2==0 else QBrush(QColor(200, 200, 200)) mangaItem.setBackground(brush) latestChapterItem.setBackground(brush) statusItem.setBackground(brush) self.mangaTableModel.setItem(i, 0, mangaItem) self.mangaTableModel.setItem(i, 1, latestChapterItem) self.mangaTableModel.setItem(i, 2, statusItem)
def find_rules(self): if self.data is None: return data = self.data self.table.model().clear() n_examples = len(data) NumericItem = self.NumericItem StandardItem = self.StandardItem filterSearch = self.filterSearch itemsetMin = self.filterAntecedentMin + self.filterConsequentMin itemsetMax = self.filterAntecedentMax + self.filterConsequentMax isSizeMatch = self.isSizeMatch isRegexMatch = self.isRegexMatch X, mapping = OneHot.encode(data, self.classify) self.onehot_mapping = mapping names = {item: '{}={}'.format(var.name, val) for item, var, val in OneHot.decode(mapping, data, mapping)} # Items that consequent must include if classifying class_items = {item for item, var, val in OneHot.decode(mapping, data, mapping) if var is data.domain.class_var} if self.classify else set() assert bool(class_items) == bool(self.classify) model = QStandardItemModel(self.table) for col, (label, tooltip) in enumerate([("Supp", "Support"), ("Conf", "Confidence (support / antecedent support)"), ("Covr", "Coverage (antecedent support / number of examples)"), ("Strg", "Strength (consequent support / antecedent support)"), ("Lift", "Lift (number of examples * confidence / consequent support)"), ("Levr", "Leverage ((support * number of examples - antecedent support * consequent support) / (number of examples)²)"), ("Antecedent", None), ("", None), ("Consequent", None)]): item = QStandardItem(label) item.setToolTip(tooltip) model.setHorizontalHeaderItem(col, item) #~ # Aggregate rules by common (support,confidence) for scatterplot #~ scatter_agg = defaultdict(list) # Find itemsets nRules = 0 itemsets = {} progress = gui.ProgressBar(self, self.maxRules + 1) for itemset, support in frequent_itemsets(X, self.minSupport / 100): itemsets[itemset] = support if class_items and not class_items & itemset: continue # Filter itemset by joined filters before descending into it itemset_str = ' '.join(names[i] for i in itemset) if (filterSearch and (len(itemset) < itemsetMin or itemsetMax < len(itemset) or not isRegexMatch(itemset_str, itemset_str))): continue for rule in gen_assoc_rules(itemsets, self.minConfidence / 100, itemset): (left, right), support, confidence = rule if class_items and right - class_items: continue if filterSearch and not isSizeMatch(len(left), len(right)): continue left_str = ' '.join(names[i] for i in sorted(left)) right_str = ' '.join(names[i] for i in sorted(right)) if filterSearch and not isRegexMatch(left_str, right_str): continue # All filters matched, calculate stats and add table row _, _, _, coverage, strength, lift, leverage = next( rules_stats((rule,), itemsets, n_examples)) support_item = NumericItem(support / n_examples) # Set row data on first column support_item.setData((itemset - class_items, class_items and (class_items & itemset).pop()), self.ROW_DATA_ROLE) left_item = StandardItem(left_str, len(left)) left_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) model.appendRow([support_item, NumericItem(confidence), NumericItem(coverage), NumericItem(strength), NumericItem(lift), NumericItem(leverage), left_item, StandardItem('→'), StandardItem(right_str, len(right))]) #~ scatter_agg[(round(support / n_examples, 2), round(confidence, 2))].append((left, right)) nRules += 1 progress.advance() if nRules >= self.maxRules: break if nRules >= self.maxRules: break # Populate the TableView table = self.table table.setHidden(True) table.setSortingEnabled(False) proxy_model = self.proxy_model proxy_model.setSourceModel(model) table.setModel(proxy_model) for i in range(model.columnCount()): table.resizeColumnToContents(i) table.setSortingEnabled(True) table.setHidden(False) progress.finish() self.nRules = nRules self.nFilteredRules = proxy_model.rowCount() # TODO: continue; also add in owitemsets self.nSelectedRules = 0 self.nSelectedExamples = 0
def _guiUpdate_metaTable(self,uuid): dbconn=DbConn() meta=dbconn.get_meta_kv() stream=meta[str(uuid)] print stream model=QStandardItemModel() model.setHorizontalHeaderItem(0,QStandardItem("Attribute")) model.setHorizontalHeaderItem(1,QStandardItem("Value")) while model.rowCount() > 0: model.removeRow(0) for k in stream.keys(): name=stream[k] # print name # print k item1 = QStandardItem(k) item2 = QStandardItem(name) # item=QTableWidgetItem() # item.setText(1,name) # item.setText(2,k) # self.ui.metaEditor # model.appendRow([item1,item2]) # self.ui.metaEditor.appendI model.appendRow([item1,item2]) self.ui.metaEditor.setModel(model) # self.ui.metaEditor.addTopLevelItem(item) # self.ui.metaEditor. # model.itemChanged.connect(lambda: on_item_changed()) self.metamodel=model # self.ui.met self.ui.metaEditor.setModel(model) # self.ui.metaEditor.setEditTriggers(QAbstractItemView.NoEditTriggers) # self.ui.metaEditor.sortByColumn(1) self.ui.metaEditor.resizeColumnsToContents()