def fill_table(self, dict_parcels, types_change_detection): num_rows = 0 for type in types_change_detection: # We didn't use COUNT_KEY because for duplicate parcels the count (t_ids) differs from number of parcels num_rows += len( dict_parcels[type][DICT_KEY_PARCEL_T_PARCEL_NUMBER_F]) self.tbl_changes_all_parcels.clearContents() self.tbl_changes_all_parcels.setRowCount(num_rows) self.tbl_changes_all_parcels.setSortingEnabled(False) row = 0 filter_parcels = None for type in types_change_detection: filter_parcels = dict_parcels[type] if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE: inverse = False else: inverse = True # Take the supplies db as base db base_db = self.utils._supplies_db if inverse else self.utils._db self.compared_parcels_data = self.utils.get_compared_parcels_data( inverse) for parcel_number, parcel_attrs in self.compared_parcels_data.items( ): if filter_parcels and parcel_number in filter_parcels[ DICT_KEY_PARCEL_T_PARCEL_NUMBER_F]: item = QTableWidgetItem( parcel_number) if parcel_number else QTableWidgetItem( QgsApplication.nullRepresentation()) item.setData( Qt.UserRole, { base_db.names.T_ID_F: parcel_attrs[base_db.names.T_ID_F], 'inverse': inverse }) self.tbl_changes_all_parcels.setItem(row, 0, item) status = parcel_attrs[PARCEL_STATUS] status_display = parcel_attrs[PARCEL_STATUS_DISPLAY] if filter_parcels: # If we are on the supplies DB, "new" parcels are "missing" parcels from the collected db perspective if filter_parcels[ SOURCE_DB] == SUPPLIES_DB_SOURCE and parcel_attrs[ PARCEL_STATUS_DISPLAY] == CHANGE_DETECTION_NEW_PARCEL: status_display = CHANGE_DETECTION_MISSING_PARCEL status = CHANGE_DETECTION_MISSING_PARCEL item = QTableWidgetItem(status_display) item.setData( Qt.UserRole, { base_db.names.T_ID_F: parcel_attrs[base_db.names.T_ID_F], 'inverse': inverse }) self.tbl_changes_all_parcels.setItem(row, 1, item) color = STATUS_COLORS[status] self.tbl_changes_all_parcels.item(row, 1).setBackground(color) row += 1 self.tbl_changes_all_parcels.setSortingEnabled(True) # Go for parcel ids and then for plot ids parcel_ids_collected = list() parcel_ids_supplies = list() for type in types_change_detection: filter_parcels = dict_parcels[type] if filter_parcels: if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE: parcel_ids_collected.extend( filter_parcels[self.utils._db.names.T_ID_F]) else: parcel_ids_supplies.extend( filter_parcels[self.utils._supplies_db.names.T_ID_F]) plot_ids_collected = list() if parcel_ids_collected: plot_ids_collected = self.utils.ladm_data.get_plots_related_to_parcels( self.utils._db, parcel_ids_collected, None, # Get QGIS plot ids self.utils._layers[self.utils._db.names.OP_PLOT_T][LAYER], self.utils._layers[self.utils._db.names.COL_UE_BAUNIT_T] [LAYER]) plot_ids_supplies = list() if parcel_ids_supplies: plot_ids_supplies = self.utils.ladm_data.get_plots_related_to_parcels_supplies( self.utils._supplies_db, parcel_ids_supplies, None, # Get QGIS plot ids self.utils._supplies_layers[ self.utils._supplies_db.names.GC_PLOT_T][LAYER]) # Now that we've got plot ids, select them and zoom to them (combining the extent from both plot layers) if plot_ids_collected: self.utils._layers[self.utils._db.names.OP_PLOT_T][ LAYER].selectByIds(plot_ids_collected) if plot_ids_supplies: self.utils._supplies_layers[ self.utils._supplies_db.names.GC_PLOT_T][LAYER].selectByIds( plot_ids_supplies) self.zoom_to_selected_plots()
def __init__(self, iface, parent=None): super(PersistorDialog, self).__init__(parent) # Set up the user interface from Designer. self.setupUi(self) self.iface = iface self.DISP_TEMP_LAYERS = read_setting(PLUGIN_NAME + '/DISP_TEMP_LAYERS', bool) self.DEBUG = config.get_debug_mode() self.pixel_size = ['0', 'm', ''] self.layers_df = None # Catch and redirect python errors directed at the log messages python error tab. QgsApplication.messageLog().messageReceived.connect(errorCatcher) if not os.path.exists(TEMPDIR): os.mkdir(TEMPDIR) # Setup for validation messagebar on gui----------------------------- # leave this message bar for bailouts self.messageBar = QgsMessageBar(self) self.validationLayout = QtWidgets.QFormLayout( self) # new layout to gui if isinstance(self.layout(), QtWidgets.QFormLayout): # create a validation layout so multiple messages can be added and # cleaned up. self.layout().insertRow(0, self.validationLayout) self.layout().insertRow(0, self.messageBar) else: # for use with Vertical/horizontal layout box self.layout().insertWidget(0, self.messageBar) # GUI Runtime Customisation ------------------------------------------- self.setWindowIcon( QtGui.QIcon(':/plugins/pat/icons/icon_persistor.svg')) self.mcboRasterLayer.setFilters(QgsMapLayerProxyModel.RasterLayer) self.mcboRasterLayer.setExcludedProviders(['wms']) #self.setMapLayers() self.cboMethod.addItems( ['Target Probability', 'Target Over All Years']) self.cboMethod.setCurrentIndex(1) for ea_cbo in [ self.cboAllYearTargetPerc, self.cboUpperPerc, self.cboLowerPerc ]: ea_cbo.addItems(['{}%'.format(ea) for ea in range(50, -55, -5)]) ea_cbo.setCurrentIndex( ea_cbo.findText('10%', QtCore.Qt.MatchFixedString)) self.cboLowerPerc.setCurrentIndex( self.cboLowerPerc.findText('-10%', QtCore.Qt.MatchFixedString)) for ea_tab in [self.tabUpper, self.tabLower]: ea_tab.setColumnCount(2) ea_tab.hideColumn(0) # don't need to display the unique layer ID ea_tab.setHorizontalHeaderItem(0, QTableWidgetItem("ID")) ea_tab.setHorizontalHeaderItem(1, QTableWidgetItem("0 Raster(s)")) ea_tab.horizontalHeader().setSectionResizeMode( QtWidgets.QHeaderView.Stretch) ea_tab.hideColumn(0) # don't need to display the unique layer ID
def AddFileRowToManager(self, name, filename, load_id=None, islocal=False, klv_folder=None): ''' Add file Video to new Row ''' # We limit the number of videos due to the buffer if self.VManager.rowCount() > 5: qgsu.showUserAndLogMessage( QCoreApplication.translate( "ManagerDock", "You must delete some video from the list before adding a new one" )) return self.islocal = islocal self.klv_folder = klv_folder self.isStreaming = False w = QWidget() layout = QVBoxLayout() pbar = QProgressBar() layout.addWidget(pbar) w.setLayout(layout) rowPosition = self.VManager.rowCount() pbar.setGeometry(0, 0, 300, 30) pbar.setValue(0) pbar.setMaximumHeight(30) if load_id is None: row_id = 0 if rowPosition != 0: row_id = int(self.VManager.item(rowPosition - 1, 0).text()) + 1 else: row_id = load_id self.VManager.insertRow(rowPosition) self.VManager.setItem(rowPosition, 0, QTableWidgetItem(str(row_id))) self.VManager.setItem(rowPosition, 1, QTableWidgetItem(name)) self.VManager.setItem( rowPosition, 2, QTableWidgetItem( QCoreApplication.translate("ManagerDock", "Loading"))) self.VManager.setItem(rowPosition, 3, QTableWidgetItem(filename)) self.VManager.setItem(rowPosition, 4, QTableWidgetItem("-")) self.VManager.setCellWidget(rowPosition, 5, w) self.VManager.setVisible(False) self.VManager.horizontalHeader().setStretchLastSection(True) self.VManager.setVisible(True) # resolve if it is a stream if "://" in filename: self.isStreaming = True if not self.isStreaming: # Disable row if not exist video file if not os.path.exists(filename): self.ToggleActiveRow(rowPosition, value="Missing source file") for j in range(self.VManager.columnCount()): try: self.VManager.item(rowPosition, j).setFlags(Qt.NoItemFlags | Qt.ItemIsEnabled) self.VManager.item(rowPosition, j).setBackground( QColor(211, 211, 211)) except Exception: self.VManager.cellWidget(rowPosition, j).setStyleSheet( "background-color:rgb(211,211,211);") pass return pbar.setValue(30) info = FFMpeg().probe(filename) if info is None: qgsu.showUserAndLogMessage( QCoreApplication.translate("ManagerDock", "Failed loading FFMPEG ! ")) return info.format.duration # init non-blocking metadata buffered reader self.meta_reader[str(rowPosition)] = BufferedMetaReader( filename, pass_time=self.pass_time) qgsu.showUserAndLogMessage( "", "buffered non-blocking metadata reader initialized.", onlyLog=True) pbar.setValue(60) try: # init point we can center the video on self.initialPt[str(rowPosition)] = getVideoLocationInfo( filename, islocal, klv_folder) if not self.initialPt[str(rowPosition)]: self.VManager.setItem( rowPosition, 4, QTableWidgetItem( QCoreApplication.translate( "ManagerDock", "Start location not available."))) self.ToggleActiveRow(rowPosition, value="Not MISB") pbar.setValue(99) return else: self.VManager.setItem( rowPosition, 4, QTableWidgetItem(self.initialPt[str(rowPosition)][2])) except Exception: qgsu.showUserAndLogMessage( QCoreApplication.translate( "ManagerDock", "This video don't have Metadata ! ")) pbar.setValue(99) self.ToggleActiveRow(rowPosition, value="Not MISB") return pbar.setValue(90) dtm_path = parser['GENERAL']['DTM_file'] if self.initialPt[str(rowPosition)] and dtm_path != '': try: initElevationModel(self.initialPt[str(rowPosition)][0], self.initialPt[str(rowPosition)][1], dtm_path) qgsu.showUserAndLogMessage("", "Elevation model initialized.", onlyLog=True) except Exception: None else: self.meta_reader[str(rowPosition)] = StreamMetaReader(filename) qgsu.showUserAndLogMessage("", "StreamMetaReader initialized.", onlyLog=True) self.initialPt[str(rowPosition)] = None pbar.setValue(100) if islocal: self.ToggleActiveRow(rowPosition, value="Ready Local") else: self.ToggleActiveRow(rowPosition, value="Ready") # Add video to settings list AddVideoToSettings(str(row_id), filename)
def run(self): """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = NewRaptorDialog() self.dlg.cmbSpecies.currentTextChanged.connect( self.evt_cmbSpecies_changed) mc = self.iface.mapCanvas() self.dlg.spbLatitude.setValue(mc.center().y()) self.dlg.spbLongitude.setValue(mc.center().x()) self.dlg.dteLast.setDate(QDate.currentDate()) map_layers = [] for lyr in mc.layers(): map_layers.append(lyr.name()) missing_layers = [] if not "Raptor Nests" in map_layers: missing_layers.append("Raptor Nests") if not "Raptor Buffer" in map_layers: missing_layers.append("Raptor Buffer") if not "Linear Buffer" in map_layers: missing_layers.append("Linear Buffer") if missing_layers: msg = "The following layers are misisng from this project\n" for lyr in missing_layers: msg += "\n{}".format(lyr) QMessageBox.critical(self.dlg, "Missing layers", msg) return # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. lyrNests = QgsProject.instance().mapLayersByName("Raptor Nests")[0] lyrBuffer = QgsProject.instance().mapLayersByName( "Raptor Buffer")[0] lyrLinear = QgsProject.instance().mapLayersByName( "Linear Buffer")[0] idxNestID = lyrNests.fields().indexOf("Nest_ID") valNestID = lyrNests.maximumValue(idxNestID) + 1 valLat = self.dlg.spbLatitude.value() valLng = self.dlg.spbLongitude.value() valSpecies = self.dlg.cmbSpecies.currentText() valBuffer = self.dlg.spbBuffer.value() valStatus = self.dlg.cmbStatus.currentText() valLast = self.dlg.dteLast.date() QMessageBox.information( self.dlg, "Message", "New Nest ID: {}\n\nLatitude: {}\nLongitude: {}\nSpecies: {}\nBuffer: {}\nStatus: {}\nLast Survey: {}" .format(valNestID, valLat, valLng, valSpecies, valBuffer, valStatus, valLast)) ftrNest = QgsFeature(lyrNests.fields()) ftrNest.setAttribute("lat_y_dd", valLat) ftrNest.setAttribute("long_x_dd", valLng) ftrNest.setAttribute("recentspec", valSpecies) ftrNest.setAttribute("buf_dist", valBuffer) ftrNest.setAttribute("recentstat", valStatus) ftrNest.setAttribute("lastsurvey", valLast) ftrNest.setAttribute("Nest_ID", valNestID) geom = QgsGeometry(QgsPoint(valLng, valLat)) ftrNest.setGeometry(geom) pr = lyrNests.dataProvider() pr.addFeatures([ftrNest]) lyrNests.reload() pr = lyrBuffer.dataProvider() buffer = geom.buffer(valBuffer, 10) ftrNest.setGeometry(buffer) pr.addFeatures([ftrNest]) lyrBuffer.reload() dlgTable = DlgTable() dlgTable.setWindowTitle( "Impacts Table for Nest {}".format(valNestID)) # Find linear projects that will be impacted and report them in the table bb = buffer.boundingBox() linears = lyrLinear.getFeatures(bb) for linear in linears: valID = linear.attribute("Project") valType = linear.attribute("type") valDistance = linear.geometry().distance(geom) if valDistance < valBuffer: # Populate table with linear data row = dlgTable.tblImpacts.rowCount() dlgTable.tblImpacts.insertRow(row) dlgTable.tblImpacts.setItem(row, 0, QTableWidgetItem(str(valID))) dlgTable.tblImpacts.setItem(row, 1, QTableWidgetItem(valType)) twi = QTableWidgetItem("{:4.5f}".format(valDistance)) twi.setTextAlignment(QtCore.Qt.AlignRight) dlgTable.tblImpacts.setItem(row, 2, twi) dlgTable.tblImpacts.sortItems(2) dlgTable.show() dlgTable.exec_() else: QMessageBox.information(self.dlg, "Message", "Should only run if cancelled")
def restoreSettings(self): settings = QgsSettings() font = QFontDatabase.systemFont(QFontDatabase.FixedFont) self.spinBox.setValue(settings.value("pythonConsole/fontsize", font.pointSize(), type=int)) self.spinBoxEditor.setValue(settings.value("pythonConsole/fontsizeEditor", font.pointSize(), type=int)) self.fontComboBox.setCurrentFont(QFont(settings.value("pythonConsole/fontfamilytext", font.family()))) self.fontComboBoxEditor.setCurrentFont(QFont(settings.value("pythonConsole/fontfamilytextEditor", font.family()))) self.preloadAPI.setChecked(settings.value("pythonConsole/preloadAPI", True, type=bool)) self.lineEdit.setText(settings.value("pythonConsole/preparedAPIFile", "", type=str)) itemTable = settings.value("pythonConsole/userAPI", []) if itemTable: self.tableWidget.setRowCount(0) for i in range(len(itemTable)): self.tableWidget.insertRow(i) self.tableWidget.setColumnCount(2) pathSplit = itemTable[i].split("/") apiName = pathSplit[-1][0:-4] self.tableWidget.setItem(i, 0, QTableWidgetItem(apiName)) self.tableWidget.setItem(i, 1, QTableWidgetItem(itemTable[i])) self.autoSaveScript.setChecked(settings.value("pythonConsole/autoSaveScript", False, type=bool)) self.autoCompThreshold.setValue(settings.value("pythonConsole/autoCompThreshold", 2, type=int)) self.autoCompThresholdEditor.setValue(settings.value("pythonConsole/autoCompThresholdEditor", 2, type=int)) self.groupBoxAutoCompletionEditor.setChecked( settings.value("pythonConsole/autoCompleteEnabledEditor", True, type=bool)) self.groupBoxAutoCompletion.setChecked(settings.value("pythonConsole/autoCompleteEnabled", True, type=bool)) self.enableObjectInspector.setChecked(settings.value("pythonConsole/enableObjectInsp", False, type=bool)) self.autoCloseBracketEditor.setChecked(settings.value("pythonConsole/autoCloseBracketEditor", False, type=bool)) self.autoCloseBracket.setChecked(settings.value("pythonConsole/autoCloseBracket", False, type=bool)) self.autoInsertionImportEditor.setChecked( settings.value("pythonConsole/autoInsertionImportEditor", True, type=bool)) self.autoInsertionImport.setChecked(settings.value("pythonConsole/autoInsertionImport", True, type=bool)) if settings.value("pythonConsole/autoCompleteSource") == 'fromDoc': self.autoCompFromDoc.setChecked(True) elif settings.value("pythonConsole/autoCompleteSource") == 'fromAPI': self.autoCompFromAPI.setChecked(True) elif settings.value("pythonConsole/autoCompleteSource") == 'fromDocAPI': self.autoCompFromDocAPI.setChecked(True) if settings.value("pythonConsole/autoCompleteSourceEditor") == 'fromDoc': self.autoCompFromDocEditor.setChecked(True) elif settings.value("pythonConsole/autoCompleteSourceEditor") == 'fromAPI': self.autoCompFromAPIEditor.setChecked(True) elif settings.value("pythonConsole/autoCompleteSourceEditor") == 'fromDocAPI': self.autoCompFromDocAPIEditor.setChecked(True) # Setting font lexer color self.defaultFontColor.setColor(QColor(settings.value("pythonConsole/defaultFontColor", QColor(Qt.black)))) self.defaultFontColorEditor.setColor( QColor(settings.value("pythonConsole/defaultFontColorEditor", QColor(Qt.black)))) self.keywordFontColor.setColor(QColor(settings.value("pythonConsole/keywordFontColor", QColor(Qt.darkGreen)))) self.keywordFontColorEditor.setColor( QColor(settings.value("pythonConsole/keywordFontColorEditor", QColor(Qt.darkGreen)))) self.classFontColor.setColor(QColor(settings.value("pythonConsole/classFontColor", QColor(Qt.blue)))) self.classFontColorEditor.setColor( QColor(settings.value("pythonConsole/classFontColorEditor", QColor(Qt.blue)))) self.methodFontColor.setColor(QColor(settings.value("pythonConsole/methodFontColor", QColor(Qt.darkGray)))) self.methodFontColorEditor.setColor( QColor(settings.value("pythonConsole/methodFontColorEditor", QColor(Qt.darkGray)))) self.decorFontColor.setColor(QColor(settings.value("pythonConsole/decorFontColor", QColor(Qt.darkBlue)))) self.decorFontColorEditor.setColor( QColor(settings.value("pythonConsole/decorFontColorEditor", QColor(Qt.darkBlue)))) self.commentFontColor.setColor(QColor(settings.value("pythonConsole/commentFontColor", QColor(Qt.gray)))) self.commentFontColorEditor.setColor( QColor(settings.value("pythonConsole/commentFontColorEditor", QColor(Qt.gray)))) self.commentBlockFontColor.setColor( QColor(settings.value("pythonConsole/commentBlockFontColor", QColor(Qt.gray)))) self.commentBlockFontColorEditor.setColor( QColor(settings.value("pythonConsole/commentBlockFontColorEditor", QColor(Qt.gray)))) self.paperBackgroundColor.setColor( QColor(settings.value("pythonConsole/paperBackgroundColor", QColor(Qt.white)))) self.paperBackgroundColorEditor.setColor( QColor(settings.value("pythonConsole/paperBackgroundColorEditor", QColor(Qt.white)))) self.caretLineColor.setColor(QColor(settings.value("pythonConsole/caretLineColor", QColor("#fcf3ed")))) self.caretLineColorEditor.setColor( QColor(settings.value("pythonConsole/caretLineColorEditor", QColor("#fcf3ed")))) self.cursorColor.setColor(QColor(settings.value("pythonConsole/cursorColor", QColor(Qt.black)))) self.cursorColorEditor.setColor(QColor(settings.value("pythonConsole/cursorColorEditor", QColor(Qt.black)))) self.stderrFontColor.setColor(QColor(settings.value("pythonConsole/stderrFontColor", QColor(Qt.red)))) self.singleQuoteFontColor.setColor(settings.value("pythonConsole/singleQuoteFontColor", QColor(Qt.blue))) self.singleQuoteFontColorEditor.setColor( settings.value("pythonConsole/singleQuoteFontColorEditor", QColor(Qt.blue))) self.doubleQuoteFontColor.setColor(settings.value("pythonConsole/doubleQuoteFontColor", QColor(Qt.blue))) self.doubleQuoteFontColorEditor.setColor( settings.value("pythonConsole/doubleQuoteFontColorEditor", QColor(Qt.blue))) self.tripleSingleQuoteFontColor.setColor( settings.value("pythonConsole/tripleSingleQuoteFontColor", QColor(Qt.blue))) self.tripleSingleQuoteFontColorEditor.setColor( settings.value("pythonConsole/tripleSingleQuoteFontColorEditor", QColor(Qt.blue))) self.tripleDoubleQuoteFontColor.setColor( settings.value("pythonConsole/tripleDoubleQuoteFontColor", QColor(Qt.blue))) self.tripleDoubleQuoteFontColorEditor.setColor( settings.value("pythonConsole/tripleDoubleQuoteFontColorEditor", QColor(Qt.blue)))
def update_local_data_sources(self, local_layers, local_raster_layers): # update table names lookup local_layers += local_raster_layers self.update_data_sources_table_names() self.local_data_sources.update_local_data_sources(local_layers) # update GUI self.ui.tblLocalLayers.setRowCount(0) for data_source, layers in list(self.local_data_sources.iteritems()): layer_names = [] for layer in layers: layer_names.append(str(layer.name())) layers_item = QTableWidgetItem(", ".join(layer_names)) layers_item.setToolTip("\n".join(layer_names)) data_source_item = QTableWidgetItem(data_source) data_source_item.setToolTip(data_source) # find a better table name if there are multiple layers with same # data source? table_name = layers[0].name() if data_source in self.data_sources_table_names: # use current table name if available to keep changes by user table_name = self.data_sources_table_names[data_source] table_name_item = QTableWidgetItem(self.launder_pg_name(table_name)) if layers[0].providerType() == 'gdal': geometry_type_item = QTableWidgetItem('Raster') else: wkbType = layers[0].wkbType() if wkbType not in self.GEOMETRY_TYPES: QMessageBox.warning(self.iface.mainWindow(), self.tr("Unsupported geometry type"), self.tr( "Unsupported geometry type '{type}' in layer '{layer}'").format(type=self.__wkbTypeString(wkbType), layer=layers[0].name())) continue geometry_type_item = QTableWidgetItem(self.GEOMETRY_TYPES[wkbType]) if layers[0].providerType() == "ogr": geometry_type_item.setToolTip( self.tr("Note: OGR features will be converted to MULTI-type")) srid_item = QTableWidgetItem(layers[0].crs().authid()) row = self.ui.tblLocalLayers.rowCount() self.ui.tblLocalLayers.insertRow(row) self.ui.tblLocalLayers.setItem( row, self.COLUMN_LAYERS, layers_item) self.ui.tblLocalLayers.setItem( row, self.COLUMN_DATA_SOURCE, data_source_item) self.ui.tblLocalLayers.setItem( row, self.COLUMN_TABLE_NAME, table_name_item) self.ui.tblLocalLayers.setItem( row, self.COLUMN_GEOMETRY_TYPE, geometry_type_item) self.ui.tblLocalLayers.setItem(row, self.COLUMN_SRID, srid_item) if self.local_data_sources.count() > 0: self.ui.tblLocalLayers.resizeColumnsToContents() self.ui.tblLocalLayers.setColumnWidth(self.COLUMN_LAYERS, 100) self.ui.tblLocalLayers.setColumnWidth(self.COLUMN_DATA_SOURCE, 100) self.ui.tblLocalLayers.sortItems(self.COLUMN_DATA_SOURCE) self.ui.tblLocalLayers.setSortingEnabled(False) else: self.ui.btnUploadData.setEnabled(False) self.statusBar().showMessage(self.tr("Updated local data sources"))
def showFeatureAttributes(self): conflictItem = self.lastSelectedItem self.oursgeom = None self.theirsgeom = None geoms = (self.oursgeom, self.theirsgeom) self.currentConflictedAttributes = [] attribs = list(conflictItem.origin.keys()) self.attributesTable.setRowCount(len(attribs)) self.conflicted = [] for idx, name in enumerate(attribs): font = QFont() font.setBold(True) font.setWeight(75) item = QTableWidgetItem(name) item.setFont(font) self.attributesTable.setItem(idx, 3, item) self.attributesTable.setItem(idx, 4, ValueItem(None, False)) try: values = (conflictItem.origin[name], conflictItem.local[name], conflictItem.remote[name]) except Exception: #Local has been deleted self._afterSolve(False) self.solveModifyAndDelete(conflictItem.conflict.path, self.REMOTE) return except TypeError: #Remote has been deleted self._afterSolve(False) self.solveModifyAndDelete(conflictItem.conflict.path, self.LOCAL) return try: geom = QgsGeometry.fromWkt(values[0]) except: geom = None if geom is not None: self.theirsgeom = QgsGeometry().fromWkt(values[1]) self.oursgeom = QgsGeometry.fromWkt(values[2]) geoms = (self.oursgeom, self.theirsgeom) ok = values[0] == values[1] or values[1] == values[2] or values[ 0] == values[2] for i, v in enumerate(values): self.attributesTable.setItem(idx, i, ValueItem(v, not ok, geoms)) if not ok: self.conflicted.append(name) else: if values[0] == values[1]: newvalue = values[2] else: newvalue = values[1] self.attributesTable.setItem(idx, 4, ValueItem(newvalue, False, geoms)) self.attributesTable.resizeRowsToContents() self.attributesTable.horizontalHeader().setMinimumSectionSize(150) self.attributesTable.horizontalHeader().setStretchLastSection(True)
def reloadProject(self): """ Load all layers from the map layer registry into the table. """ self.unsupportedLayersList = list() self.photoNamingTable.setRowCount(0) self.layersTable.setRowCount(0) self.layersTable.setSortingEnabled(False) for layer in self.project.mapLayers().values(): layer_source = LayerSource(layer) count = self.layersTable.rowCount() self.layersTable.insertRow(count) item = QTableWidgetItem(layer.name()) item.setData(Qt.UserRole, layer_source) item.setData(Qt.EditRole, layer.name()) self.layersTable.setItem(count, 0, item) cmb = QComboBox() set_available_actions(cmb, layer_source) cbx = QCheckBox() cbx.setEnabled(layer_source.can_lock_geometry) cbx.setChecked(layer_source.is_geometry_locked) # it's more UI friendly when the checkbox is centered, an ugly workaround to achieve it cbx_widget = QWidget() cbx_layout = QHBoxLayout() cbx_layout.setAlignment(Qt.AlignCenter) cbx_layout.setContentsMargins(0, 0, 0, 0) cbx_layout.addWidget(cbx) cbx_widget.setLayout(cbx_layout) # NOTE the margin is not updated when the table column is resized, so better rely on the code above # cbx.setStyleSheet("margin-left:50%; margin-right:50%;") self.layersTable.setCellWidget(count, 1, cbx_widget) self.layersTable.setCellWidget(count, 2, cmb) if not layer_source.is_supported: self.unsupportedLayersList.append(layer_source) self.layersTable.item(count, 0).setFlags(Qt.NoItemFlags) self.layersTable.cellWidget(count, 1).setEnabled(False) self.layersTable.cellWidget(count, 2).setEnabled(False) cmb.setCurrentIndex(cmb.findData(SyncAction.REMOVE)) # make sure layer_source is the same instance everywhere self.photoNamingTable.addLayerFields(layer_source) self.layersTable.resizeColumnsToContents() self.layersTable.sortByColumn(0, Qt.AscendingOrder) self.layersTable.setSortingEnabled(True) # Remove the tab when not yet suported in QGIS if Qgis.QGIS_VERSION_INT < 31300: self.tabWidget.removeTab(self.tabWidget.count() - 1) # Load Map Themes for theme in self.project.mapThemeCollection().mapThemes(): self.mapThemeComboBox.addItem(theme) self.layerComboBox.setFilters(QgsMapLayerProxyModel.RasterLayer) self.__project_configuration = ProjectConfiguration(self.project) self.createBaseMapGroupBox.setChecked( self.__project_configuration.create_base_map) if self.__project_configuration.base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER: self.singleLayerRadioButton.setChecked(True) else: self.mapThemeRadioButton.setChecked(True) self.mapThemeComboBox.setCurrentIndex( self.mapThemeComboBox.findText( self.__project_configuration.base_map_theme)) layer = QgsProject.instance().mapLayer( self.__project_configuration.base_map_layer) self.layerComboBox.setLayer(layer) self.mapUnitsPerPixel.setText( str(self.__project_configuration.base_map_mupp)) self.tileSize.setText( str(self.__project_configuration.base_map_tile_size)) self.onlyOfflineCopyFeaturesInAoi.setChecked( self.__project_configuration.offline_copy_only_aoi) if self.unsupportedLayersList: self.unsupportedLayersLabel.setVisible(True) unsupported_layers_text = '<b>{}: </b>'.format(self.tr('Warning')) unsupported_layers_text += self.tr( "There are unsupported layers in your project which will not be available in QField." ) unsupported_layers_text += self.tr( " If needed, you can create a Base Map to include those layers in your packaged project." ) self.unsupportedLayersLabel.setText(unsupported_layers_text)
def run_stats(self): self.progressBar_stats.setValue(0) self.label_progressStats.setText('') # noinspection PyArgumentList QApplication.processEvents() blurred_layer = self.comboBox_blurredLayer.currentLayer() stats_layer = self.comboBox_statsLayer.currentLayer() try: if not blurred_layer or not stats_layer: raise NoLayerProvidedException crs_blurred_layer = blurred_layer.crs() crs_stats_layer = stats_layer.crs() if crs_blurred_layer != crs_stats_layer: raise DifferentCrsException( epsg1=crs_blurred_layer.authid(), epsg2=crs_stats_layer.authid()) if blurred_layer == stats_layer: raise NoLayerProvidedException if not blurred_layer or not stats_layer: raise NoLayerProvidedException nb_feature_stats = stats_layer.featureCount() nb_feature_blurred = blurred_layer.featureCount() features_stats = {} label_preparing = tr('Preparing index on the stats layer') label_creating = tr('Creating index on the stats layer') label_calculating = tr('Calculating') if Qgis.QGIS_VERSION_INT < 20700: self.label_progressStats.setText('%s 1/3' % label_preparing) for i, feature in enumerate(stats_layer.getFeatures()): features_stats[feature.id()] = feature percent = int((i + 1) * 100 / nb_feature_stats) self.progressBar_stats.setValue(percent) # noinspection PyArgumentList QApplication.processEvents() self.label_progressStats.setText('%s 2/3' % label_creating) # noinspection PyArgumentList QApplication.processEvents() index = QgsSpatialIndex() for i, f in enumerate(stats_layer.getFeatures()): index.insertFeature(f) percent = int((i + 1) * 100 / nb_feature_stats) self.progressBar_stats.setValue(percent) # noinspection PyArgumentList QApplication.processEvents() self.label_progressStats.setText('%s 3/3' % label_calculating) else: # If QGIS >= 2.7, we can speed up the spatial index. # From 1 min 15 to 7 seconds on my PC. self.label_progressStats.setText('%s 1/2' % label_creating) # noinspection PyArgumentList QApplication.processEvents() index = QgsSpatialIndex(stats_layer.getFeatures()) self.label_progressStats.setText('%s 2/2' % label_calculating) # noinspection PyArgumentList QApplication.processEvents() self.tab = [] for i, feature in enumerate(blurred_layer.getFeatures()): count = 0 ids = index.intersects(feature.geometry().boundingBox()) for unique_id in ids: request = QgsFeatureRequest().setFilterFid(unique_id) f = next(stats_layer.getFeatures(request)) if f.geometry().intersects(feature.geometry()): count += 1 self.tab.append(count) percent = int((i + 1) * 100 / nb_feature_blurred) self.progressBar_stats.setValue(percent) # noinspection PyArgumentList QApplication.processEvents() stats = Stats(self.tab) items_stats = [ 'Count(blurred),%d' % nb_feature_blurred, 'Count(stats),%d' % nb_feature_stats, 'Min,%d' % stats.min(), 'Average,%f' % stats.average(), 'Max,%d' % stats.max(), 'Median,%f' % stats.median(), 'Range,%d' % stats.range(), 'Variance,%f' % stats.variance(), 'Standard deviation,%f' % stats.standard_deviation() ] self.tableWidget.clear() self.tableWidget.setColumnCount(2) labels = ['Parameters', 'Values'] self.tableWidget.setHorizontalHeaderLabels(labels) self.tableWidget.setRowCount(len(items_stats)) for i, item in enumerate(items_stats): s = item.split(',') self.tableWidget.setItem(i, 0, QTableWidgetItem(s[0])) self.tableWidget.setItem(i, 1, QTableWidgetItem(s[1])) self.tableWidget.resizeRowsToContents() self.draw_plot(self.tab) except GeoPublicHealthException as e: self.label_progressStats.setText('') display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
def buscar(self): self.datos = self.dlg.leBusqueda_4.text() envio = {} envio['folio'] = self.datos envio['solicitante'] = self.datos resp = self.guardarOperacion(nuevo=self.nuevo, url=(self.CFG.urlOptenerTramites), envio=envio) #print(resp) self.dlg.twOperaciones_9.clearContents() self.dlg.twOperaciones_9.setRowCount(0) if resp == []: self.createAlert('Ingrese un Folio correcta o un nombre correcto', QMessageBox().Critical, "Solicitud") # mostrar usuarios en tabla self.dlg.twOperaciones_9.setRowCount(len(resp)) for x in range(0, len(resp)): item2 = QTableWidgetItem(str(resp[x]['fecha_solcitud'])) item3 = QTableWidgetItem(str(resp[x]['clave_catastral'])) item4 = QTableWidgetItem(str(resp[x]['solicita_localidad'])) item5 = QTableWidgetItem(str(resp[x]['folio_inicio'])) item6 = QTableWidgetItem(str(resp[x]['propietario'])) item7 = QTableWidgetItem(str(resp[x]['solicita_nombre'])) item8 = QTableWidgetItem(str(resp[x]['idTramite'])) item9 = QTableWidgetItem(str(resp[x]['solicita_tel'])) item10 = QTableWidgetItem(str(resp[x]['solicita_municipio'])) item11 = QTableWidgetItem(str(resp[x]['id'])) item12 = QTableWidgetItem(str(resp[x]['solicita_colonia'])) item13 = QTableWidgetItem(str(resp[x]['solicita_fraccionamiento'])) item14 = QTableWidgetItem(str(resp[x]['solicita_correo'])) item15 = QTableWidgetItem(str(resp[x]['solicita_calle'])) self.dlg.twOperaciones_9.setItem(x, 0, item2) self.dlg.twOperaciones_9.setItem(x, 1, item3) self.dlg.twOperaciones_9.setItem(x, 2, item4) self.dlg.twOperaciones_9.setItem(x, 3, item5) self.dlg.twOperaciones_9.setItem(x, 4, item6) self.dlg.twOperaciones_9.setItem(x, 5, item7) self.dlg.twOperaciones_9.setItem(x, 6, item8) self.dlg.twOperaciones_9.setItem(x, 7, item9) self.dlg.twOperaciones_9.setItem(x, 8, item10) self.dlg.twOperaciones_9.setItem(x, 9, item11) self.dlg.twOperaciones_9.setItem(x, 10, item12) self.dlg.twOperaciones_9.setItem(x, 11, item13) self.dlg.twOperaciones_9.setItem(x, 12, item14) self.dlg.twOperaciones_9.setItem(x, 13, item15)
def readMapping(self,filename): if self.dlg.interlinkTable.rowCount()!=0: tree = ET.parse(filename) root = tree.getroot() filedata=root.find('file')[0] self.dlg.interlinkNameSpace.setText(filedata.get("namespace")) self.dlg.interlinkOwlClassInput.setText(filedata.get("class")) for neighbor in root.iter('column'): name=neighbor.get("name") proptype=neighbor.get("prop") propiri=neighbor.get("propiri") concept=neighbor.get("concept") query=neighbor.get("query") triplestoreurl=neighbor.get("triplestoreurl") valuemappings={} for vmap in neighbor.findall("valuemapping"): valuemappings[vmap.get("from")]=vmap.get("to") for row in range(self.dlg.interlinkTable.rowCount()): columnname=self.dlg.interlinkTable.item(row,3).text() if columnname==name: if propiri!=None: item=QTableWidgetItem(propiri) item.setText(propiri) item.setData(1,propiri) self.dlg.interlinkTable.setItem(row,4,item) if proptype!=None: comboboxx=self.dlg.interlinkTable.cellWidget(row,5) if proptype=="annotation": comboboxx.setCurrentIndex(comboboxx.findText("AnnotationProperty", QtCore.Qt.MatchFixedString)) elif proptype=="obj": comboboxx.setCurrentIndex(comboboxx.findText("ObjectProperty", QtCore.Qt.MatchFixedString)) elif proptype=="data": comboboxx.setCurrentIndex(comboboxx.findText("DataProperty", QtCore.Qt.MatchFixedString)) elif proptype=="subclass": comboboxx.setCurrentIndex(comboboxx.findText("SubClass", QtCore.Qt.MatchFixedString)) else: comboboxx.setCurrentIndex(comboboxx.findText("Automatic", QtCore.Qt.MatchFixedString)) if concept!=None: item=QTableWidgetItem(concept) item.setText(concept) item.setData(1,concept) self.dlg.interlinkTable.setItem(row,6,item) if valuemappings!={} and valuemappings!=None: item=QTableWidgetItem("ValueMap{}") item.setText("ValueMap{}") item.setData(1,valuemappings) if query!=None: item.setData(2,query) item.setData(3,triplestoreurl) self.dlg.interlinkTable.setItem(row,7,item) elif query!=None: item=QTableWidgetItem("ValueMap{}") item.setText("ValueMap{}") item.setData(2,query) item.setData(3,triplestoreurl) if valuemappings!={} and valuemappings!=None: item.setData(1,valuemappings) self.dlg.interlinkTable.setItem(row,7,item) else: msgBox=QMessageBox() msgBox.setText("Please first load a dataset to enrich before loading a mapping file") msgBox.exec()
def loadLayerForEnrichment(self): layers = QgsProject.instance().layerTreeRoot().children() selectedLayerIndex = self.chooseLayerEnrich.currentIndex() if len(layers) == 0: return layer = layers[selectedLayerIndex].layer() self.enrichTableResult.hide() while self.enrichTableResult.rowCount() > 0: self.enrichTableResult.removeRow(0) self.enrichTable.show() self.addEnrichedLayerRowButton.setEnabled(True) fieldnames = [field.name() for field in layer.fields()] while self.enrichTable.rowCount() > 0: self.enrichTable.removeRow(0) row = 0 self.enrichTable.setColumnCount(9) self.enrichTable.setHorizontalHeaderLabels([ "Column", "EnrichmentConcept", "TripleStore", "Strategy", "content", "ID Column", "ID Property", "ID Domain", "Language" ]) for field in fieldnames: item = QTableWidgetItem(field) item.setFlags(QtCore.Qt.ItemIsEnabled) currentRowCount = self.enrichTable.rowCount() self.enrichTable.insertRow(row) self.enrichTable.setItem(row, 0, item) cbox = QComboBox() cbox.addItem("No Enrichment") cbox.addItem("Keep Local") cbox.addItem("Keep Remote") cbox.addItem("Replace Local") cbox.addItem("Merge") cbox.addItem("Ask User") cbox.addItem("Exclude") self.enrichTable.setCellWidget(row, 3, cbox) cbox = QComboBox() cbox.addItem("Enrich Value") cbox.addItem("Enrich URI") cbox.addItem("Enrich Both") self.enrichTable.setCellWidget(row, 4, cbox) cbox = QComboBox() for fieldd in fieldnames: cbox.addItem(fieldd) self.enrichTable.setCellWidget(row, 5, cbox) itemm = QTableWidgetItem( "http://www.w3.org/2000/01/rdf-schema#label") self.enrichTable.setItem(row, 6, itemm) itemm = QTableWidgetItem("") self.enrichTable.setItem(row, 7, itemm) itemm = QTableWidgetItem("") self.enrichTable.setItem(row, 8, itemm) celllayout = QHBoxLayout() upbutton = QPushButton("Up") removebutton = QPushButton("Remove", self) removebutton.clicked.connect(self.deleteEnrichRow) downbutton = QPushButton("Down") celllayout.addWidget(upbutton) celllayout.addWidget(downbutton) celllayout.addWidget(removebutton) w = QWidget() w.setLayout(celllayout) optitem = QTableWidgetItem() #self.enrichTable.setCellWidget(row,4,w) #self.enrichTable.setItem(row,3,cbox) row += 1 self.originalRowCount = row
def applyFilter(self, table, index, filter_value, filter_operation): if filter_value == None: table.filters[index] = None else: if isinstance(filter_value, QDateEdit): table.filters[index] = filter_value.date() elif isinstance(filter_value, QTimeEdit): table.filters[index] = filter_value.time() elif isinstance(filter_value, QDateTimeEdit): table.filters[index] = filter_value.dateTime() else: table.filters[index] = filter_value.text() table.filter_op[index] = filter_operation.currentIndex() nb_elts = 0 for i in range(0, table.rowCount()): table.setRowHidden(i, False) nb_elts += 1 hidden_rows = [] for nb_col in range(0, table.columnCount()): filtered = False header = table.horizontalHeaderItem(nb_col).text() valid = False if table.filters[nb_col] is not None: if type(table.filters[nb_col]) in [QDate, QTime, QDateTime]: valid = True else: if table.filters[nb_col].strip(): valid = True if valid: filtered = True items = None if table.types[nb_col] in [10]:# If it's a string filter_type = None if table.filter_op[nb_col] == 0: # Contain filter_type = Qt.MatchContains if table.filter_op[nb_col] == 1: # Equal filter_type = Qt.MatchFixedString items = table.findItems(table.filters[nb_col], filter_type) elif table.types[nb_col] in [14, 15, 16]: # If it's a date/time items = [] for nb_row in range(0, table.rowCount()): item = table.item(nb_row, nb_col) if table.filter_op[nb_col] == 0: # = if item.data(QTableWidgetItem.Type) == table.filters[nb_col]: items.append(item) if table.filter_op[nb_col] == 1: # > if item.data(QTableWidgetItem.Type) > table.filters[nb_col]: items.append(item) if table.filter_op[nb_col] == 2: # < if item.data(QTableWidgetItem.Type) < table.filters[nb_col]: items.append(item) else: # If it's a number items = [] for nb_row in range(0, table.rowCount()): item = table.item(nb_row, nb_col) if item.text().strip(): if table.filter_op[nb_col] == 0: # = if float(item.text()) == float(table.filters[nb_col]): items.append(item) if table.filter_op[nb_col] == 1: # > if float(item.text()) > float(table.filters[nb_col]): items.append(item) if table.filter_op[nb_col] == 2: # < if float(item.text()) < float(table.filters[nb_col]): items.append(item) rows = [] for item in items: if item.column() == nb_col: rows.append(item.row()) for i in range(0, table.rowCount()): if i not in rows: if i not in hidden_rows: nb_elts -= 1 table.setRowHidden(i, True) hidden_rows.append(i) if filtered: if header[len(header)-1] != '*': table.setHorizontalHeaderItem(nb_col, QTableWidgetItem(header+'*')) else: if header[len(header)-1] == '*': header = header[:-1] table.setHorizontalHeaderItem(nb_col, QTableWidgetItem(header)) title = self.tabWidget.tabText(self.tabWidget.currentIndex()) for i in reversed(range(len(title))): if title[i] == ' ': break title = title[:-1] title += '('+str(nb_elts)+')' self.tabWidget.setTabText(self.tabWidget.currentIndex(), title)
def addLayer(self, layer, headers, types, features): tab = QWidget() tab.layer = layer p1_vertical = QVBoxLayout(tab) p1_vertical.setContentsMargins(0,0,0,0) table = QTableWidget() table.itemSelectionChanged.connect(self.highlight_features) table.title = layer.name() table.crs = layer.crs() table.setColumnCount(len(headers)) if len(features) > 0: table.setRowCount(len(features)) nbrow = len(features) self.loadingWindow.show() self.loadingWindow.setLabelText(table.title) self.loadingWindow.activateWindow() self.loadingWindow.showNormal() # Table population m = 0 for feature in features: n = 0 for cell in feature.attributes(): item = QTableWidgetItem() item.setData(Qt.DisplayRole, cell) item.setFlags(item.flags() ^ Qt.ItemIsEditable) item.feature = feature table.setItem(m, n, item) n += 1 m += 1 self.loadingWindow.setValue(int((float(m)/nbrow)*100)) QApplication.processEvents() else: table.setRowCount(0) table.setHorizontalHeaderLabels(headers) table.horizontalHeader().setSectionsMovable(True) table.types = types table.filter_op = [] table.filters = [] for i in range(0, len(headers)): table.filters.append('') table.filter_op.append(0) header = table.horizontalHeader() header.setContextMenuPolicy(Qt.CustomContextMenu) header.customContextMenuRequested.connect(partial(self.filterMenu, table)) table.setSortingEnabled(True) p1_vertical.addWidget(table) # Status bar to display informations (ie: area) tab.sb = QStatusBar() p1_vertical.addWidget(tab.sb) title = table.title # We reduce the title's length to 20 characters if len(title)>20: title = title[:20]+'...' # We add the number of elements to the tab's title. title += ' ('+str(len(features))+')' self.tabWidget.addTab(tab, title) # Add the tab to the conatiner self.tabWidget.setTabToolTip(self.tabWidget.indexOf(tab), table.title) # Display a tooltip with the layer's full name
def update_srs_table_content(dockwidget, srs_table): with block_signals_to(dockwidget.QTableW_StraRS): # init table dockwidget.QTableW_StraRS.setRowCount(srs_table["row_count"]) dockwidget.QTableW_StraRS.setColumnCount(srs_table["column_count"]) # enter data onto Table for n, key in enumerate(srs_table["header"]): if key == "Pix Val": for m, item in enumerate( srs_table["color_table"]["Pixel Value"]): item_table = QTableWidgetItem(str(item)) item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) dockwidget.QTableW_StraRS.setItem(m, n, item_table) if key == "Color": for m in range(srs_table["row_count"]): item_table = QTableWidgetItem() item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) item_table.setBackground( QColor(srs_table["color_table"]["Red"][m], srs_table["color_table"]["Green"][m], srs_table["color_table"]["Blue"][m], srs_table["color_table"]["Alpha"][m])) dockwidget.QTableW_StraRS.setItem(m, n, item_table) if key == "Num Samples": for m in range(srs_table["row_count"]): item_table = QTableWidgetItem(srs_table["num_samples"][m]) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) item_table.setToolTip( "Total number of samples for this class, this is generated\n" "automatically based on the area proportion by the activated\n" "classes, overall standard error and its standard deviation." ) if not srs_table["On"][m]: item_table.setForeground(QColor("lightGrey")) item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) dockwidget.QTableW_StraRS.setItem(m, n, item_table) if key == "Std Dev": for m in range(srs_table["row_count"]): item_table = QTableWidgetItem(srs_table["std_dev"][m]) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) item_table.setToolTip( "Set the standard deviation for this class") if not srs_table["On"][m]: item_table.setForeground(QColor("lightGrey")) item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) dockwidget.QTableW_StraRS.setItem(m, n, item_table) if key == "On": for m in range(srs_table["row_count"]): item_table = QTableWidgetItem() item_table.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) item_table.setToolTip("Enable/disable this class") if srs_table["On"][m]: item_table.setCheckState(Qt.Checked) else: item_table.setCheckState(Qt.Unchecked) dockwidget.QTableW_StraRS.setItem(m, n, item_table) # hidden row labels dockwidget.QTableW_StraRS.verticalHeader().setVisible(False) # add Header dockwidget.QTableW_StraRS.setHorizontalHeaderLabels( srs_table["header"]) # adjust size of Table dockwidget.QTableW_StraRS.resizeColumnsToContents() dockwidget.QTableW_StraRS.resizeRowsToContents() # set label total samples total_num_samples = sum( [int(x) for x in mask(srs_table["num_samples"], srs_table["On"])]) dockwidget.TotalNumSamples.setText(str(total_num_samples)) # set maximum and reset the value in progress bar status dockwidget.widget_generate_StraRS.QPBar_GenerateSampling.setValue(0) dockwidget.widget_generate_StraRS.QPBar_GenerateSampling.setMaximum( total_num_samples)
def run_stats(self): """Main function which do the process.""" # Get the common fields. self.admin_layer = self.cbx_aggregation_layer.currentLayer() if self.use_point_layer: # If we use a point layer. point_layer = self.cbx_case_layer.currentLayer() else: # If we use a column with number of case. case_column = self.cbx_case_field.currentField() index_case = self.admin_layer.fields().indexFromName(case_column) #Replace laer.fieldNameIndex(name) to layer.fields().lookup\Field(name) #http://learn.openwaterfoundation.org/owf-app-geoprocessor-python-doc-dev/resources/migrate-qgis2-qgis3/ if not self.use_area: # If we don't use density. population = self.cbx_population_field.currentField() index_population = self.admin_layer.fields().indexFromName(population) self.name_field=self.le_new_column.text() if not self.name_field: self.name_field = self.le_new_column.placeholderText() # Add new column. add_nb_intersections = self.checkBox_addNbIntersections.isChecked() # Ratio ratio = self.cbx_ratio.currentText() ratio = ratio.replace(' ', '') # Output. self.output_file_path = self.le_output_filepath.text() try: self.button_box_ok.setDisabled(True) # noinspection PyArgumentList QApplication.setOverrideCursor(Qt.WaitCursor) # noinspection PyArgumentList QApplication.processEvents() if not self.admin_layer: QMessageBox.information(None, "DEBUG:", str("There is no layer")) raise NoLayerProvidedException if not self.admin_layer and self.use_point_layer: QMessageBox.information(None, "DEBUG:", str("There is no layer")) raise NoLayerProvidedException crs_admin_layer = self.admin_layer.crs() if self.use_point_layer: crs_point_layer = point_layer.crs() if crs_admin_layer != crs_point_layer: QMessageBox.information(None, "DEBUG:", str("CRS of two layers are not the same. Please set CRS.")) raise DifferentCrsException( epsg1=crs_point_layer.authid(), epsg2=crs_admin_layer.authid()) if not self.use_point_layer and not self.use_area: if index_population == index_case: QMessageBox.information(None, "DEBUG:", str("You are using the same variable for case and population. Please change.")) raise FieldException(field_1='Population', field_2='Case') try: ratio = float(ratio) except ValueError: QMessageBox.information(None, "DEBUG:", str("The variable is not number.")) raise NotANumberException(suffix=ratio) # Output if not self.output_file_path: temp_file = NamedTemporaryFile( delete=False, suffix='-geohealth.shp') self.output_file_path = temp_file.name temp_file.flush() temp_file.close() else: with open(self.output_file_path, 'w') as document: pass admin_layer_provider = self.admin_layer.dataProvider() fields = self.admin_layer.fields() if admin_layer_provider.fields().indexFromName(self.name_field) != -1: QMessageBox.information(None, "DEBUG:", str("The field name already exist.")) raise FieldExistingException(field=self.name_field) fields.append(QgsField(self.name_field, QVariant.Double)) if add_nb_intersections: fields.append(QgsField('nb_of_intersections', QVariant.Int)) data = [] file_writer = QgsVectorFileWriter( self.output_file_path, 'utf-8', fields, QgsWkbTypes.Polygon, self.admin_layer.crs(), 'ESRI Shapefile') if self.use_point_layer: total_case = point_layer.featureCount() else: total_case = 0 for i, feature in enumerate(self.admin_layer.getFeatures()): attributes = feature.attributes() if self.use_point_layer: count = 0 for f in point_layer.getFeatures(): if f.geometry().intersects(feature.geometry()): count += 1 else: count = int(attributes[index_case]) total_case += count try: if self.use_area: area = feature.geometry().area() value = float(count) / area * ratio else: try: population = float(attributes[index_population]) except ValueError: QMessageBox.information(None, "DEBUG:", str("This is not a number.")) raise NotANumberException( suffix=attributes[index_population]) value = float(count) / population * ratio except ZeroDivisionError: value = None except TypeError: value = None data.append(value) attributes.append(value) if add_nb_intersections: attributes.append(count) new_feature = QgsFeature() new_geom = QgsGeometry(feature.geometry()) new_feature.setAttributes(attributes) new_feature.setGeometry(new_geom) file_writer.addFeature(new_feature) del file_writer self.output_layer = QgsVectorLayer( self.output_file_path, self.name_field, 'ogr') QgsProject.instance().addMapLayer(self.output_layer) if self.checkBox_incidence_runStats.isChecked(): stats = Stats(data) items_stats = [ 'Incidence null,%d' % stats.null_values(), 'Count(point),%d' % total_case, 'Count(polygon),%d' % self.admin_layer.featureCount(), 'Min,%d' % stats.min(), 'Average,%f' % stats.average(), 'Max,%d' % stats.max(), 'Median,%f' % stats.median(), 'Range,%d' % stats.range(), 'Variance,%f' % stats.variance(), 'Standard deviation,%f' % stats.standard_deviation() ] self.tableWidget.clear() self.tableWidget.setColumnCount(2) labels = ['Parameters', 'Values'] self.tableWidget.setHorizontalHeaderLabels(labels) self.tableWidget.setRowCount(len(items_stats)) for i, item in enumerate(items_stats): s = item.split(',') self.tableWidget.setItem(i, 0, QTableWidgetItem(s[0])) self.tableWidget.setItem(i, 1, QTableWidgetItem(s[1])) self.tableWidget.resizeRowsToContents() self.draw_plot(data) else: self.hide() if self.symbology.isChecked(): self.add_symbology() self.signalStatus.emit(3, tr('Successful process')) except GeoPublicHealthException as e: display_message_bar(msg=e.msg, level=e.level, duration=e.duration) finally: self.button_box_ok.setDisabled(False) # noinspection PyArgumentList QApplication.restoreOverrideCursor() # noinspection PyArgumentList QApplication.processEvents()
def configureDialog(self, p_layertype, p_wkbtype, p_Multitype=False, p_Z=False, p_M=False, p_EditMode=False, p_Canvas=None): """ Init dialog controls """ self.layertype = p_layertype self.wkbtype = p_wkbtype self.has_Z = p_Z self.has_M = p_M self.isMultiType = p_Multitype self.isEditMode = p_EditMode self.mapCanvas = p_Canvas self.projectCrsId = self.mapCanvas.mapSettings().destinationCrs( ).srsid() self.highLighter = HighlightFeature( self.mapCanvas, self.layertype == QgsWkbTypes.PointGeometry, self.layertype == QgsWkbTypes.PolygonGeometry, self.projectCrsId) self.valueChecker = ValueChecker(self.twPoints, self.layertype) # Hide working with parts for any point geometry and simple line geometry if self.layertype == QgsWkbTypes.PointGeometry or \ (self.layertype == QgsWkbTypes.LineGeometry and not self.isMultiType): self.partButtonsFrame.hide() self.partsFrame.hide() self.gridMainLayout.setHorizontalSpacing(0) # Else activate multipart controls else: self.partButtonsFrame.show() self.partsFrame.show() self.gridMainLayout.setHorizontalSpacing(3) # Set enabled state Add ring button only for polygons self.toolButtonAddRing.setEnabled( self.layertype == QgsWkbTypes.PolygonGeometry) # Disable add parts buttons for not multipolygone (only add ring enabled) self.toolButtonAddPart.setEnabled(self.isMultiType) model = self.listParts.model() model.blockSignals(True) model.insertRows(0, 1) model.setData(model.index(0), '1', QtCore.Qt.EditRole) model.blockSignals(False) self.__contursCount = 1 self.prev_row = 0 if self.has_Z and self.has_M: tableColumns = 4 headerLabels = ['X', 'Y', 'Z', 'M'] elif self.has_Z != self.has_M: tableColumns = 3 if self.has_Z: headerLabels = ['X', 'Y', 'Z'] else: headerLabels = ['X', 'Y', 'M'] else: tableColumns = 2 headerLabels = ['X', 'Y'] modelColumns = self.twPoints.model().columnCount() if tableColumns > modelColumns: self.twPoints.model().insertColumns(2, tableColumns - modelColumns) elif tableColumns < modelColumns: self.twPoints.model().removeColumns(2, modelColumns - tableColumns) for i in range(len(headerLabels)): if self.twPoints.horizontalHeaderItem(i) is not None: self.twPoints.horizontalHeaderItem(i).setText(headerLabels[i]) else: item = QTableWidgetItem() item.setText(headerLabels[i]) self.twPoints.setHorizontalHeaderItem(i, item) # Resize grid. Set column's width equal. Resize the section to fill the available space. for i in range(self.twPoints.columnCount()): self.twPoints.setColumnWidth( i, self.twPoints.width() / self.twPoints.columnCount()) self.twPoints.horizontalHeader().setSectionResizeMode( i, QHeaderView.Stretch) # Disable OK button. Wait for entering valid coordinates self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False) # Disable choose CRS button while not selected rb_ChooseCrs self.l_OtherCrsName.setEnabled(self.rb_OtherCrs.isChecked()) self.pb_OtherCrs.setEnabled(self.rb_OtherCrs.isChecked()) settings = QSettings() rb_checked = settings.value("/Plugin-NumericalDigitize/Projection", "LayerCrs", type=str) if rb_checked == "ProjectCrs": self.featureCrsId = self.projectCrsId self.rb_ProjectCrs.setChecked(True) elif rb_checked == "OtherCrs": self.otherCrsId = settings.value( "/Plugin-NumericalDigitize/OtherCrsId", -1, type=int) self.featureCrsId = self.otherCrsId self.__displayAuthid() self.rb_OtherCrs.setChecked(True) else: self.featureCrsId = self.mapCanvas.currentLayer().crs().srsid() self.rb_LayerCrs.setChecked(True) self.selectedCRS.emit(self.featureCrsId)
def treeItemChanged(self, current, previous): qgsgeom1 = None qgsgeom2 = None crs = "EPSG:4326" if not isinstance(current, FeatureItem): self.attributesTable.clear() self.attributesTable.setRowCount(0) return color = { "MODIFIED": QColor(255, 170, 0), "ADDED": Qt.green, "REMOVED": Qt.red, "NO_CHANGE": Qt.white } path = current.layername + "/" + current.featureid featurediff = self.changes[path].featurediff() self.attributesTable.clear() self.attributesTable.verticalHeader().show() self.attributesTable.horizontalHeader().show() self.attributesTable.setRowCount(len(featurediff)) self.attributesTable.setVerticalHeaderLabels( [a["attributename"] for a in featurediff]) self.attributesTable.setHorizontalHeaderLabels( ["Old value", "New value", "Change type"]) for i, attrib in enumerate(featurediff): try: if attrib["changetype"] == "MODIFIED": oldvalue = attrib["oldvalue"] newvalue = attrib["newvalue"] elif attrib["changetype"] == "ADDED": newvalue = attrib["newvalue"] oldvalue = "" elif attrib["changetype"] == "REMOVED": oldvalue = attrib["oldvalue"] newvalue = "" else: oldvalue = newvalue = attrib["oldvalue"] except: oldvalue = newvalue = "" self.attributesTable.setItem(i, 0, DiffItem(oldvalue)) self.attributesTable.setItem(i, 1, DiffItem(newvalue)) try: self.attributesTable.setItem(i, 2, QTableWidgetItem("")) if qgsgeom1 is None or qgsgeom2 is None: if "crs" in attrib: crs = attrib["crs"] qgsgeom1 = QgsGeometry.fromWkt(oldvalue) qgsgeom2 = QgsGeometry.fromWkt(newvalue) if qgsgeom1 is not None and qgsgeom2 is not None: widget = QWidget() btn = QPushButton() btn.setText("View detail") btn.clicked.connect(lambda: self.viewGeometryChanges( qgsgeom1, qgsgeom2, crs)) label = QLabel() label.setText(attrib["changetype"]) layout = QHBoxLayout(widget) layout.addWidget(label) layout.addWidget(btn) layout.setContentsMargins(0, 0, 0, 0) widget.setLayout(layout) self.attributesTable.setCellWidget(i, 2, widget) else: self.attributesTable.setItem( i, 2, QTableWidgetItem(attrib["changetype"])) else: self.attributesTable.setItem( i, 2, QTableWidgetItem(attrib["changetype"])) except: self.attributesTable.setItem( i, 2, QTableWidgetItem(attrib["changetype"])) for col in range(3): self.attributesTable.item(i, col).setBackgroundColor( color[attrib["changetype"]]) self.attributesTable.resizeColumnsToContents() self.attributesTable.horizontalHeader().setResizeMode( QHeaderView.Stretch)
def loadStats(self): names = self.getLayerNames() data = getLastSearch() valueList, itemList, amountList, lenghtList, areaList, areaTotalList = [], [], [], [], [], [] valueList, itemList, amountList, lenghtList, areaList, areaTotalList = [], [], [], [], [], [] for i in names: item_id = getID(i) item = nvdbFagdata(item_id) if data[1] == "kommune": kommuneID = getKommuneID(data[0]) item.filter({'kommune': kommuneID}) elif data[1] == "kontraktsomrade": item.filter({'kontraktsomrade': data[0]}) else: fylkeID = getFylkeID(data[0]) item.filter({'fylke': fylkeID}) if data[2] != "Alle": item.filter({'vegsystemreferanse': [data[2][0]]}) for v in item.statistikk().items(): valueList.append(v) itemList.append(item) for itemobj in itemList: while itemobj is not None: area = itemobj.nesteNvdbFagObjekt() if area is None: break else: areaList.append(area.egenskapverdi('Areal')) continue else: print("TEST") break for i in range(len(valueList)): v = valueList[i] if v[0] == "antall": amountList.append(v[1]) else: lenghtList.append(v[1]) for i in range(len(amountList)): areaTotal = 0 for u in range(amountList[i]): if areaList[u] is not None: if isinstance(areaList[u], str): pass else: areaTotal += areaList[u] else: pass areaTotalList.append(areaTotal) areaList = areaList[amountList[i]:] # Row count self.dlg.statsTable.setRowCount(len(names) + 1) # Column count self.dlg.statsTable.setColumnCount(4) self.dlg.statsTable.setItem(0, 0, QTableWidgetItem("Navn")) self.dlg.statsTable.setItem(0, 1, QTableWidgetItem("Mengde")) self.dlg.statsTable.setItem(0, 2, QTableWidgetItem("Lengde")) self.dlg.statsTable.setItem(0, 3, QTableWidgetItem("Areal")) for i in range(len(names) + 1): if i == len(names): break self.dlg.statsTable.setItem(i + 1, 0, QTableWidgetItem(names[i])) self.dlg.statsTable.setItem(i + 1, 1, QTableWidgetItem(str(amountList[i]))) self.dlg.statsTable.setItem( i + 1, 2, QTableWidgetItem(str(round(int(lenghtList[i]))))) self.dlg.statsTable.setItem( i + 1, 3, QTableWidgetItem(str(round(int(areaTotalList[i]))))) # Table will fit the screen horizontally self.dlg.statsTable.horizontalHeader().setStretchLastSection(True) self.dlg.statsTable.horizontalHeader().setSectionResizeMode( QHeaderView.Stretch) self.successMessage("Viser statistikk for layers innenfor " + data[1] + ":") self.successMessage(data[0]) self.successMessage("Vegsystemreferanse:") self.successMessage(data[2])
def fill_table(self, filter_parcels=dict()): if not filter_parcels or (filter_parcels and filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE): inverse = False else: inverse = True # Take the official db as base db self.compared_parcels_data = self.utils.get_compared_parcels_data( inverse) self.tbl_changes_all_parcels.clearContents() self.tbl_changes_all_parcels.setRowCount( len(filter_parcels[PARCEL_NUMBER_FIELD] ) if filter_parcels else len(self.compared_parcels_data)) self.tbl_changes_all_parcels.setSortingEnabled(False) row = 0 for parcel_number, parcel_attrs in self.compared_parcels_data.items(): if not filter_parcels or (filter_parcels and parcel_number in filter_parcels[PARCEL_NUMBER_FIELD]): item = QTableWidgetItem( parcel_number) if parcel_number else QTableWidgetItem( QgsApplication.nullRepresentation()) item.setData(Qt.UserRole, { ID_FIELD: parcel_attrs[ID_FIELD], 'inverse': inverse }) self.tbl_changes_all_parcels.setItem(row, 0, item) status = parcel_attrs[PARCEL_STATUS] status_display = parcel_attrs[PARCEL_STATUS_DISPLAY] if filter_parcels: # If we are on the official DB, "new" parcels are "missing" parcels from the collected db perspective if filter_parcels[ SOURCE_DB] == OFFICIAL_DB_SOURCE and parcel_attrs[ PARCEL_STATUS_DISPLAY] == CHANGE_DETECTION_NEW_PARCEL: status_display = CHANGE_DETECTION_MISSING_PARCEL status = CHANGE_DETECTION_MISSING_PARCEL item = QTableWidgetItem(status_display) item.setData(Qt.UserRole, { ID_FIELD: parcel_attrs[ID_FIELD], 'inverse': inverse }) self.tbl_changes_all_parcels.setItem(row, 1, item) color = STATUS_COLORS[status] self.tbl_changes_all_parcels.item(row, 1).setBackground(color) row += 1 self.tbl_changes_all_parcels.setSortingEnabled(True) # Zoom and flash features if filter_parcels: plot_layer = None if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE: plot_layer = self.utils._layers[PLOT_TABLE][LAYER] else: plot_layer = self.utils._official_layers[PLOT_TABLE][LAYER] plot_ids = self.utils.ladm_data.get_plots_related_to_parcels( self.utils._db if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE else self.utils._official_db, filter_parcels[ID_FIELD], None, # Get QGIS plot ids plot_layer, self.utils._layers[UEBAUNIT_TABLE][LAYER] if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE else self.utils._official_layers[UEBAUNIT_TABLE][LAYER]) self.parent.request_zoom_to_features(plot_layer, ids=plot_ids, duration=3000) # plot_layer.select(plot_ids) else: self.utils.qgis_utils.activate_layer_requested.emit( self.utils._layers[PLOT_TABLE][LAYER]) self.utils.iface.zoomToActiveLayer() self.select_related_plots_listed(False)
def show_results(self, api_results, pg_connections=dict()): """Display the results in a table.""" logger.info("Results manager called. Displaying the results") tbl_result = self.tbl_result # Get the name (and other informations) of all databases whose # connection is set up in QGIS if pg_connections == {}: pg_connections = self.pg_connections else: pass # Set table rows if api_results.get("total") >= 10: tbl_result.setRowCount(10) else: tbl_result.setRowCount(api_results.get("total")) # dimensions (see https://github.com/isogeo/isogeo-plugin-qgis/issues/276) hheader = tbl_result.horizontalHeader() # make the entire width of the table is occupied hheader.setSectionResizeMode(1) # make date and icone columns width adapted to their content # so title and adding columns occupy the rest of the available width hheader.setSectionResizeMode(1, 3) hheader.setSectionResizeMode(2, 3) vheader = tbl_result.verticalHeader() # Looping inside the table lines. For each of them, showing the title, # abstract, geometry type, and a button that allow to add the data # to the canvas. count = 0 for i in api_results.get("results"): md = Metadata.clean_attributes(i) # get metadata's keywords from tags, they will be displayed in QGIS # 'layer properties' if the layer is added to the canvas md.keywords = [ md.tags.get(kw) for kw in md.tags if kw.startswith("keyword:isogeo") ] # COLUMN 1 - Title and abstract # Displaying the metadata title inside a button title = md.title_or_name() if title: btn_md_title = QPushButton( plg_tools.format_button_title(title)) else: btn_md_title = QPushButton( self.tr("Undefined", context=__class__.__name__)) btn_md_title.setStyleSheet("font: italic") # Connecting the button to the full metadata popup btn_md_title.pressed.connect(partial(self.md_asked.emit, md._id)) # Putting the abstract as a tooltip on this button if md.abstract: btn_md_title.setToolTip(md.abstract[:300]) else: pass # Insert it in column 1 tbl_result.setCellWidget(count, 0, btn_md_title) # COLUMN 2 - Data last update lbl_date = QLabel(tbl_result) lbl_date.setText(plg_tools.handle_date(md._modified)) lbl_date.setMargin(5) lbl_date.setAlignment(Qt.AlignCenter) tbl_result.setCellWidget(count, 1, lbl_date) # COLUMN 3 - Geometry type lbl_geom = QLabel(tbl_result) if md.geometry: if md.geometry == "TIN": tbl_result.setItem(count, 2, QTableWidgetItem("TIN")) elif md.geometry in known_geom_list: for geom_type in self.pix_geom_dict: if md.geometry in geom_type: geom_item = self.pix_geom_dict.get(geom_type) lbl_geom.setPixmap(geom_item.get("pix")) lbl_geom.setToolTip( self.tr(geom_item.get("tooltip"), context=__class__.__name__)) else: continue else: tbl_result.setItem( count, 2, QTableWidgetItem( self.tr("Unknown geometry", context=__class__.__name__)), ) else: if "rasterDataset" in md.type: lbl_geom.setPixmap(pix_rastr) lbl_geom.setToolTip( self.tr("Raster", context=__class__.__name__)) elif "service" in md.type: lbl_geom.setPixmap(pix_serv) lbl_geom.setToolTip( self.tr("Service", context=__class__.__name__)) else: lbl_geom.setPixmap(pix_nogeo) lbl_geom.setToolTip( self.tr("Unknown geometry", context=__class__.__name__)) lbl_geom.setAlignment(Qt.AlignCenter) tbl_result.setCellWidget(count, 2, lbl_geom) # COLUMN 4 - Add options add_options_dict = {} # Build metadata portal URL if the setting is checked in "Settings" tab add_portal_md_url = int( qsettings.value("isogeo/settings/add_metadata_url_portal", 0)) portal_base_url = self.form_mng.input_portal_url.text() portal_md_url = "" if add_portal_md_url and portal_base_url != "": portal_md_url = portal_base_url + md._id else: pass # Files and PostGIS direct access if md.format: # If the data is a vector and the path is available, store # useful information in the dict if md.format in li_formats_vect and md.path: add_path = self._filepath_builder(md.path) if add_path: params = [ "vector", add_path, md.title, md.abstract, md.keywords, portal_md_url, ] add_options_dict[self.tr( "Data file", context=__class__.__name__)] = params else: pass # Same if the data is a raster elif md.format in li_formats_rastr and md.path: add_path = self._filepath_builder(md.path) if add_path: params = [ "raster", add_path, md.title, md.abstract, md.keywords, portal_md_url, ] add_options_dict[self.tr( "Data file", context=__class__.__name__)] = params else: pass # If the data is a postGIS table and the connexion has # been saved in QGIS. elif md.format == "postgis": if md.path: base_name = md.path else: base_name = "No path" if base_name in pg_connections.keys(): params = {} params["base_name"] = base_name schema_table = md.name if schema_table is not None and "." in schema_table: params["schema"] = schema_table.split(".")[0] params["table"] = schema_table.split(".")[1] params["abstract"] = md.abstract params["title"] = md.title params["keywords"] = md.keywords params["md_portal_url"] = portal_md_url add_options_dict[self.tr( "PostGIS table", context=__class__.__name__)] = params else: pass else: pass else: logger.debug( "Metadata {} has a format ({}) but it's not handled hear or path is" "missing".format(md._id, md.format)) pass # Associated service layers if md.type == "vectorDataset" or md.type == "rasterDataset": for layer in md.serviceLayers: service = layer.get("service") if service is not None: srv_details = { "path": service.get("path", "NR"), "formatVersion": service.get("formatVersion"), } # WMTS if service.get("format") == "wmts": params = self.layer_adder.build_wmts_url( layer, srv_details, rsc_type="ds_dyn_lyr_srv") # EFS, EMS, WMS or WFS elif service.get("format") in list( self.service_dict.keys()): url_builder = self.service_dict.get( service.get("format")).get("url_builder") params = url_builder( layer, srv_details, rsc_type="ds_dyn_lyr_srv", mode="quicky", ) else: params = [0] logger.debug( "Service with no format detected for '{}' metadata : {}" .format(md._id, service)) pass if params[0] != 0: basic_md = [ md.title, md.abstract, md.keywords, portal_md_url, ] params.append(basic_md) add_options_dict["{} : {}".format( params[0], params[1])] = params else: pass # New association mode. For services metadata sheet, the layers # are stored in the purposely named include: "layers". elif md.type == "service": if md.layers is not None: srv_details = { "path": md.path, "formatVersion": md.formatVersion, } # WMTS if md.format == "wmts": for layer in md.layers: name_url = self.layer_adder.build_wmts_url( layer, srv_details, rsc_type="service") if name_url[0] != 0: btn_label = "WMTS : {}".format(name_url[1]) add_options_dict[btn_label] = name_url else: continue # EFS, EMS, WMS or WFS elif md.format in list(self.service_dict.keys()): url_builder = self.service_dict.get( md.format).get("url_builder") for layer in md.layers: name_url = url_builder(layer, srv_details, rsc_type="service", mode="quicky") if name_url[0] != 0: add_options_dict[name_url[5]] = name_url else: continue else: pass else: pass # Now the plugin has tested every possibility for the layer to be # added. The "Add" column has to be filled accordingly. # If the data can't be added, just insert "can't" text. if add_options_dict == {}: text = self.tr("Can't be added", context=__class__.__name__) fake_button = QPushButton(text) fake_button.setStyleSheet("text-align: left") fake_button.setEnabled(False) tbl_result.setCellWidget(count, 3, fake_button) # If the data can be added else: data_info = {"limitations": None, "layer": None} # retrieves data limitations data_info["limitations"] = md.limitations # If there is only one way for the data to be added, insert a button. if len(add_options_dict) == 1: text = list(add_options_dict.keys())[0] params = add_options_dict.get(text) option_type = text.split(" : ")[0] # services if option_type.lower() in list(self.service_dict.keys()): icon = self.service_dict.get( option_type.lower()).get("ico") # PostGIS table elif option_type.startswith( self.tr("PostGIS table", context=__class__.__name__)): icon = ico_pgis # Data file elif option_type.startswith( self.tr("Data file", context=__class__.__name__)): icon = ico_file # Unkown option else: logger.debug( "Undefined add option type : {}/{} --> {}".format( option_type, text, params)) # create the add button with the icon corresponding to the add option add_button = QPushButton(icon, option_type) add_button.setStyleSheet("text-align: left") # connect the widget to the adding method from LayerAdder class data_info["layer"] = ("info", params, count) add_button.pressed.connect( partial(self.lim_checker.check, data_info)) tbl_result.setCellWidget(count, 3, add_button) # Else, add a combobox, storing all possibilities. else: combo = QComboBox() for option in add_options_dict: option_type = option.split(" : ")[0] # services if option_type.lower() in list( self.service_dict.keys()): icon = self.service_dict.get( option_type.lower()).get("ico") # PostGIS table elif option.startswith( self.tr("PostGIS table", context=__class__.__name__)): icon = ico_pgis # Data file elif option.startswith( self.tr("Data file", context=__class__.__name__)): icon = ico_file # Unkown option else: logger.debug( "Undefined add option type : {}/{} --> {}". format(option_type, text, params)) # add a combobox item with the icon corresponding to the add option combo.addItem(icon, option, add_options_dict.get(option)) # connect the widget to the adding method from LayerAdder class data_info["layer"] = ("index", count) combo.activated.connect( partial(self.lim_checker.check, data_info)) combo.model().sort( 0) # sort alphabetically on option prefix. see: #113 tbl_result.setCellWidget(count, 3, combo) # make the widget (button or combobox) width the same as the column width tbl_result.cellWidget(count, 3).setFixedWidth(hheader.sectionSize(3)) count += 1 # dimensions bis (see https://github.com/isogeo/isogeo-plugin-qgis/issues/276) # last column take the width of his content hheader.setSectionResizeMode(3, 3) # the height of the row adapts to the content without falling below 30px vheader.setMinimumSectionSize(30) vheader.setSectionResizeMode(3) # method ending return None
def getTableItem(content, editingDisabled=True): item = QTableWidgetItem(content) if editingDisabled: item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) return item
def evaluatePipeline(self, point, button): if button == Qt.LeftButton: self.rbPipeline.addPoint(point) self.rbPipeline.show() elif button == Qt.RightButton: pipeline = self.rbPipeline.asGeometry() self.dlg.tblImpacts.setRowCount(0) lyrRaptor = QgsProject.instance().mapLayersByName( "Raptor Buffer")[0] raptors = lyrRaptor.getFeatures(pipeline.boundingBox()) for raptor in raptors: valConstraint = raptor.attribute("recentspec") valID = raptor.attribute("Nest_ID") valStatus = raptor.attribute("recentstat") valDistance = pipeline.distance(raptor.geometry().centroid()) if raptor.geometry().intersects(pipeline): row = self.dlg.tblImpacts.rowCount() self.dlg.tblImpacts.insertRow(row) self.dlg.tblImpacts.setItem( row, 0, QTableWidgetItem(valConstraint)) self.dlg.tblImpacts.setItem(row, 1, QTableWidgetItem(str(valID))) self.dlg.tblImpacts.setItem(row, 2, QTableWidgetItem(valStatus)) self.dlg.tblImpacts.setItem( row, 3, QTableWidgetItem("{:4.5f}".format(valDistance))) lyrEagle = QgsProject.instance().mapLayersByName("BAEA Buffer")[0] eagles = lyrEagle.getFeatures(pipeline.boundingBox()) for eagle in eagles: valConstraint = "BAEA Nest" valID = eagle.attribute("nest_id") valStatus = eagle.attribute("status") valDistance = pipeline.distance(eagle.geometry().centroid()) if eagle.geometry().intersects(pipeline): row = self.dlg.tblImpacts.rowCount() self.dlg.tblImpacts.insertRow(row) self.dlg.tblImpacts.setItem( row, 0, QTableWidgetItem(valConstraint)) self.dlg.tblImpacts.setItem(row, 1, QTableWidgetItem(str(valID))) self.dlg.tblImpacts.setItem(row, 2, QTableWidgetItem(valStatus)) self.dlg.tblImpacts.setItem( row, 3, QTableWidgetItem("{:4.5f}".format(valDistance))) lyrBUOWL = QgsProject.instance().mapLayersByName("BUOWL Buffer")[0] buowls = lyrBUOWL.getFeatures(pipeline.boundingBox()) for buowl in buowls: valConstraint = "BUOWL Habitat" valID = buowl.attribute("habitat_id") valStatus = buowl.attribute("recentstat") valDistance = pipeline.distance(buowl.geometry().buffer( -0.001, 5)) if buowl.geometry().intersects(pipeline): row = self.dlg.tblImpacts.rowCount() self.dlg.tblImpacts.insertRow(row) self.dlg.tblImpacts.setItem( row, 0, QTableWidgetItem(valConstraint)) self.dlg.tblImpacts.setItem(row, 1, QTableWidgetItem(str(valID))) self.dlg.tblImpacts.setItem(row, 2, QTableWidgetItem(valStatus)) self.dlg.tblImpacts.setItem( row, 3, QTableWidgetItem("{:4.5f}".format(valDistance))) self.dlg.show() self.rbPipeline.reset()
def _open_function(self, index): # this '0' refers to the index of the item in the selected row self.function_selected = index.sibling(index.row(), 0).data() # Control no clickable items if self.function_selected in self.no_clickable_items: return if 'reports' in index.parent().data().lower(): # this '1' refers to the index of the item in the selected row function_name = index.sibling(index.row(), 0).data() self.function_selected = index.sibling(index.row(), 1).data() self.dlg_reports = GwToolboxReportsUi() tools_gw.load_settings(self.dlg_reports) # Set listeners self.dlg_reports.btn_export_path.clicked.connect(self._select_file_report) self.dlg_reports.btn_export.clicked.connect(partial(self._export_reports, self.dlg_reports, self.dlg_reports.tbl_reports, self.dlg_reports.txt_export_path)) self.dlg_reports.rejected.connect(partial(tools_gw.close_dialog, self.dlg_reports)) self.dlg_reports.btn_close.clicked.connect(self.dlg_reports.reject) extras = f'"filterText":null, "listId":"{self.function_selected}"' body = tools_gw.create_body(extras=extras) json_result = tools_gw.execute_procedure('gw_fct_getreport', body) if not json_result or json_result['status'] == 'Failed': return False layout = self.dlg_reports.findChild(QGridLayout, 'lyt_filters') order = 0 for field in json_result['body']['data']['fields']: label = None widget = None if 'label' in field and field['label']: label = QLabel() label.setObjectName('lbl_' + field['widgetname']) label.setText(field['label'].capitalize()) if 'stylesheet' in field and field['stylesheet'] is not None and 'label' in field['stylesheet']: label = tools_gw.set_stylesheet(field, label) if 'tooltip' in field: label.setToolTip(field['tooltip']) else: label.setToolTip(field['label'].capitalize()) if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead': completer = QCompleter() widget = tools_gw.add_lineedit(field) widget = tools_gw.set_widget_size(widget, field) widget = tools_gw.set_data_type(field, widget) widget.textChanged.connect(partial(self._update_tbl_reports)) if field['widgettype'] == 'typeahead': widget = tools_gw.set_typeahead(field, self.dlg_reports, widget, completer) elif field['widgettype'] == 'combo': widget = tools_gw.add_combo(field) widget = tools_gw.set_widget_size(widget, field) widget.currentIndexChanged.connect(partial(self._update_tbl_reports)) elif field['widgettype'] == 'check': widget = tools_gw.add_checkbox(field) widget.stateChanged.connect(partial(self._update_tbl_reports)) elif field['widgettype'] == 'datetime': widget = tools_gw.add_calendar(self.dlg_reports, field) widget.valueChanged.connect(partial(self._update_tbl_reports)) elif field['widgettype'] == 'list': numrows = len(field['value']) numcols = len(field['value'][0]) self.dlg_reports.tbl_reports.setColumnCount(numcols) self.dlg_reports.tbl_reports.setRowCount(numrows) i = 0 dict_keys = {} for key in field['value'][0].keys(): dict_keys[i] = f"{key}" self.dlg_reports.tbl_reports.setHorizontalHeaderItem(i, QTableWidgetItem(f"{key}")) i = i + 1 for row in range(numrows): for column in range(numcols): column_name = dict_keys[column] self.dlg_reports.tbl_reports.setItem(row, column, QTableWidgetItem(f"{field['value'][row][column_name]}")) continue order = order + 1 if label: layout.addWidget(label, 0, order) if widget: layout.addWidget(widget, 1, order) self.dlg_reports.setWindowTitle(f"{function_name}") tools_gw.open_dialog(self.dlg_reports, dlg_name='reports') elif 'giswater' in index.parent().data().lower(): self.dlg_functions = GwToolboxManagerUi() tools_gw.load_settings(self.dlg_functions) self.dlg_functions.progressBar.setVisible(False) self.dlg_functions.btn_cancel.hide() self.dlg_functions.btn_close.show() self.dlg_functions.btn_cancel.clicked.connect(self._cancel_task) self.dlg_functions.cmb_layers.currentIndexChanged.connect(partial(self.set_selected_layer, self.dlg_functions, self.dlg_functions.cmb_layers)) self.dlg_functions.rbt_previous.toggled.connect(partial(self._rbt_state, self.dlg_functions.rbt_previous)) self.dlg_functions.rbt_layer.toggled.connect(partial(self._rbt_state, self.dlg_functions.rbt_layer)) self.dlg_functions.rbt_layer.setChecked(True) extras = f'"filterText":"{self.function_selected}"' extras += ', "isToolbox":true' body = tools_gw.create_body(extras=extras) json_result = tools_gw.execute_procedure('gw_fct_gettoolbox', body) if not json_result or json_result['status'] == 'Failed': return False status = self._populate_functions_dlg(self.dlg_functions, json_result['body']['data']['processes']) if not status: self.function_selected = index.sibling(index.row(), 1).data() message = "Function not found" tools_qgis.show_message(message, parameter=self.function_selected) return # Disable tab log tools_gw.disable_tab_log(self.dlg_functions) # Connect signals self.dlg_functions.mainTab.currentChanged.connect(partial(self._manage_btn_run)) self.dlg_functions.btn_run.clicked.connect(partial(self._execute_function, self.function_selected, self.dlg_functions, self.dlg_functions.cmb_layers, json_result['body']['data']['processes'])) self.dlg_functions.btn_close.clicked.connect(partial(tools_gw.close_dialog, self.dlg_functions)) self.dlg_functions.rejected.connect(partial(tools_gw.close_dialog, self.dlg_functions)) self.dlg_functions.btn_cancel.clicked.connect(partial(self.remove_layers)) # Open form and set title self.dlg_functions.setWindowTitle(f"{self.function_selected}") tools_gw.open_dialog(self.dlg_functions, dlg_name='toolbox')
def setMapLayers(self): """ Run through all loaded layers to find ones which should be excluded.""" if self.tabUpper.rowCount() == 0 and self.tabLower.rowCount() == 0: # reset to show all pixel sizes. self.mcboRasterLayer.setExceptedLayerList([]) self.pixel_size = ['0', 'm', ''] else: # the layers already in the list used_up_layers = [ self.tabUpper.item(row, 0).text() for row in range(0, self.tabUpper.rowCount()) ] used_low_layers = [ self.tabLower.item(row, 0).text() for row in range(0, self.tabLower.rowCount()) ] # loop through the pick list if self.cboMethod.currentText() == 'Target Over All Years': tab_obj_list = [self.tabUpper] used_layers = used_up_layers else: tab_obj_list = [self.tabUpper, self.tabLower] # get layers common to both lists. used_layers = list(set(used_up_layers) & set(used_low_layers)) if self.layers_df is None: self.layers_df = build_layer_table() # get the used layers dataframe containing geometry df_used = self.layers_df[self.layers_df['layer_id'].isin( used_up_layers + used_low_layers)] df_sub = self.layers_df[(self.layers_df['provider'] == 'gdal') & ( self.layers_df['layer_type'] == 'RasterLayer')] # Find layers that don't overlap, have a different pixel size or have already been added (via list of layer id's). df_sub = df_sub[((df_sub['layer_id'].isin(used_layers)) | (df_sub['pixel_size'] != self.pixel_size[0])) | (~df_sub.intersects(df_used.unary_union))] if len(df_sub['layer'].tolist()) > 0: self.mcboRasterLayer.setExceptedLayerList( df_sub['layer'].tolist()) self.tabUpper.horizontalHeader().setStyleSheet('color:black') if self.tabUpper.rowCount() == 0: self.tabUpper.setHorizontalHeaderItem( 1, QTableWidgetItem("{} Raster(s)".format( self.tabUpper.rowCount()))) else: self.tabUpper.setHorizontalHeaderItem( 1, QTableWidgetItem("{} Raster(s) with {}{} pixels".format( self.tabUpper.rowCount(), *self.pixel_size[:2]))) self.tabLower.horizontalHeader().setStyleSheet('color:black') self.tabLower.setHorizontalHeaderItem( 1, QTableWidgetItem("{} Raster(s)".format(self.tabLower.rowCount()))) self.cmdAdd.setEnabled(len(self.mcboRasterLayer) > 0) self.cmdDel.setEnabled(self.tabUpper.rowCount() > 0) self.cmdAddLower.setEnabled(len(self.mcboRasterLayer) > 0) self.cmdDelLower.setEnabled(self.tabLower.rowCount() > 0)
def create_table(self): from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa header = ["Classification Name", "Color", "Thematic Class", ""] # clear table self.tableBtnsConfig.clear() # init table self.tableBtnsConfig.setRowCount(len(self.table_buttons)) self.tableBtnsConfig.setColumnCount(4) # hidden row labels self.tableBtnsConfig.verticalHeader().setVisible(False) # add Header self.tableBtnsConfig.setHorizontalHeaderLabels(header) # insert items for n, h in enumerate(header): if h == "Classification Name": for m, (key, item) in enumerate(self.table_buttons.items()): if m + 1 in self.buttons_config: item_table = QTableWidgetItem( self.buttons_config[m + 1]["name"]) else: item_table = QTableWidgetItem(str(item)) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) item_table.setToolTip( "Classification button ID: {}".format(key)) self.tableBtnsConfig.setItem(m, n, item_table) if h == "Color": for m, item in enumerate(self.table_buttons.values()): item_table = QTableWidgetItem() if m + 1 in self.buttons_config: item_table.setBackground( QColor(self.buttons_config[m + 1]["color"])) item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) self.tableBtnsConfig.setItem(m, n, item_table) if h == "Thematic Class": for m, item in enumerate(self.table_buttons.values()): if valid_file_selected_in( AcATaMa.dockwidget.QCBox_ThematicRaster): if m + 1 in self.buttons_config and self.buttons_config[ m + 1]["thematic_class"] is not None: item_table = QTableWidgetItem( self.buttons_config[m + 1]["thematic_class"]) else: item_table = QTableWidgetItem(str(item)) item_table.setToolTip( "Click to open the pixel value/color table of the thematic classes" ) else: item_table = QTableWidgetItem("none") item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) item_table.setForeground(QColor("lightGrey")) item_table.setToolTip( "No thematic layer, if you want enable the thematic classes,\n" "select first a valid thematic layer in thematic tab" ) item_h = QTableWidgetItem(h) item_h.setForeground(QColor("lightGrey")) self.tableBtnsConfig.setHorizontalHeaderItem(2, item_h) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) self.tableBtnsConfig.setItem(m, n, item_table) if h == "": for m, item in enumerate(self.table_buttons.values()): item_table = QTableWidgetItem() path = ':/plugins/AcATaMa/icons/trash.svg' icon = QIcon(path) item_table.setIcon(icon) item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) item_table.setToolTip("Clean this row") self.tableBtnsConfig.setItem(m, n, item_table) # set the minimum width to 0 for headers self.tableBtnsConfig.horizontalHeader().setMinimumSectionSize(0) # adjust size of Table self.tableBtnsConfig.resizeColumnsToContents() self.tableBtnsConfig.resizeRowsToContents() # adjust the dialog based on table content dialog_width = self.tableBtnsConfig.horizontalHeader().length() + 50 self.resize(dialog_width, self.height())
def run(self): """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = NewRaptorDialog() # self.dlg.cmbSpecies.currentTextChanged.connect( self.evt_cmbSpecies_changed) mc = self.iface.mapCanvas() self.dlg.spbLatitude.setValue(mc.center().y()) self.dlg.spbLongitude.setValue(mc.center().x()) self.dlg.dteLast.setDate(QDate.currentDate()) # Lista de camada do mapa map_layers = [] for lyr in mc.layers(): map_layers.append(lyr.name()) # Coloca o nome dos layrs em uma caixa de mensagem, com o titulo camadas #QMessageBox.information(self.dlg, "Layers", str(map_layers)) # cria uma caixa de mensagem caso não achar alguams das layrs descritas abaixo missing_layers = [] if not 'Raptor Nests' in map_layers: missing_layers.append('Raptor Nests') if not 'Raptor Buffer' in map_layers: missing_layers.append('Raptor Buffer') if not 'Linear Buffer' in map_layers: missing_layers.append('Linear Buffer') if missing_layers: msg = 'The following layres are missing from ths project\n' for lyr in missing_layers: msg += f'\n {lyr}' QMessageBox.critical(self.dlg, 'Missing layers', msg) # o return barra a execução das demais linhas de códigos return # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. # irá retornar uma lista com o as camdas com nome Raptor Nests, mas iremos pegar apenas a primeira camadd lyrNests = QgsProject.instance().mapLayersByName('Raptor Nests')[0] lyrBuffer = QgsProject.instance().mapLayersByName( 'Raptor Buffer')[0] lyrLinear = QgsProject.instance().mapLayersByName( 'Linear Buffer')[0] # Irá pegar o ultimo valor de índice idxNestID = lyrNests.fields().indexOf('Nest_ID') valNestID = lyrNests.maximumValue(idxNestID) + 1 # Irá pegar os valores que foram digitados na caixa de texto valLat = self.dlg.spbLatitude.value() valLng = self.dlg.spbLongitude.value() valSpecies = self.dlg.cmbSpecies.currentText() valBuffer = self.dlg.spbBuffer.value() valStatus = self.dlg.cmbStatus.currentText() valLast = self.dlg.dteLast.date() QMessageBox.information( self.dlg, 'Message', f'New Nest ID: {valNestID}\n \nLatitude: {valLat} ' f'\nLongitude: {valLng} \nSpecies: {valSpecies} ' f'\nBuffer: {valBuffer} \nStatus: {valStatus} \nLast: {valLast}' ) # cria um novo objeto da classe QgsFeature, no qual a classe terá os mesmoa campos do lyrnet.fildes # (objeto da Layer Raptor Nests) ftrNest = QgsFeature(lyrNests.fields()) # Irá começar a adicoanr atributos de acordo com o nome dos campos da layer Raptor Nests ftrNest.setAttribute('lat_y_dd', valLat) ftrNest.setAttribute('long_x_dd', valLng) ftrNest.setAttribute('recentspec', valSpecies) ftrNest.setAttribute('buf_dist', valBuffer) ftrNest.setAttribute('recentstat', valStatus) ftrNest.setAttribute('lastsurvey', valLast) ftrNest.setAttribute('Nest_ID', valNestID) # colcoando o tipo de geometria geom = QgsGeometry(QgsPoint(valLng, valLat)) ftrNest.setGeometry(geom) # Cada tipo de dados pode ter um provedor diferente, o qgis tem extensões para varios tipos de provedor, # a função abaixo pega o provedor e inclui os dados de acordo com o proveor pr = lyrNests.dataProvider() pr.addFeatures([ftrNest]) lyrNests.reload() # Adiconando a camada de buffer pr = lyrBuffer.dataProvider() buffer = geom.buffer(valBuffer, 10) ftrNest.setGeometry(buffer) pr.addFeatures([ftrNest]) lyrBuffer.reload() dlgTable = DlgTable() dlgTable.setWindowTitle(f"Impacts Table for Nest {valNestID}") # Find linear projects that will impacted and report then in the table bb = buffer.boundingBox() linears = lyrLinear.getFeatures(bb) for linear in linears: valID = linear.attribute('Project') valType = linear.attribute('type') valDistance = linear.geometry().distance(geom) if valDistance < valBuffer: #populate table with Linear data row = dlgTable.tblImpacts.rowCount() dlgTable.tblImpacts.insertRow(row) dlgTable.tblImpacts.setItem(row, 0, QTableWidgetItem(str(valID))) dlgTable.tblImpacts.setItem(row, 1, QTableWidgetItem(valType)) twi = QTableWidgetItem(f"{valDistance:4.5f}") twi.setTextAlignment(QtCore.Qt.AlignRight) dlgTable.tblImpacts.setItem(row, 2, twi) dlgTable.tblImpacts.sortItems(2) dlgTable.show() dlgTable.exec_() else: QMessageBox.information(self.dlg, "Message", "Should only run if cancelled")
def create_table(self): from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa header = ["Pix Val", "Color", "Select"] # get color table from raster thematic_table = { "color_table": get_color_table( AcATaMa.dockwidget.QCBox_ThematicRaster.currentLayer(), band=int(AcATaMa.dockwidget.QCBox_band_ThematicRaster. currentText()), nodata=int(AcATaMa.dockwidget.nodata_ThematicRaster.value())) } if not thematic_table["color_table"]: # clear table self.tableOfClasses.setRowCount(0) self.tableOfClasses.setColumnCount(0) return thematic_table["row_count"] = len( list(thematic_table["color_table"].values())[0]) # init table self.tableOfClasses.setRowCount(thematic_table["row_count"]) self.tableOfClasses.setColumnCount(3) # hidden row labels self.tableOfClasses.verticalHeader().setVisible(False) # add Header self.tableOfClasses.setHorizontalHeaderLabels(header) # insert items for n, h in enumerate(header): if h == "Pix Val": for m, item in enumerate( thematic_table["color_table"]["Pixel Value"]): item_table = QTableWidgetItem(str(item)) item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter) self.tableOfClasses.setItem(m, n, item_table) if h == "Color": for m in range(thematic_table["row_count"]): item_table = QTableWidgetItem() item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) item_table.setBackground( QColor(thematic_table["color_table"]["Red"][m], thematic_table["color_table"]["Green"][m], thematic_table["color_table"]["Blue"][m], thematic_table["color_table"]["Alpha"][m])) self.tableOfClasses.setItem(m, n, item_table) if h == "Select": for m in range(thematic_table["row_count"]): item_table = QPushButton("Select this") item_table.clicked.connect(self.select_clicked) self.tableOfClasses.setCellWidget(m, n, item_table) # adjust size of Table self.tableOfClasses.resizeColumnsToContents() self.tableOfClasses.resizeRowsToContents() # adjust the dialog based on table content dialog_width = self.tableOfClasses.horizontalHeader().length() + 50 self.resize(dialog_width, self.height())
def ToggleActiveRow(self, row, value="Playing"): ''' Toggle Active row manager video status ''' self.VManager.setItem( row, 2, QTableWidgetItem(QCoreApplication.translate("ManagerDock", value))) return
def run(self): """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = NuevoNidoDialog() #QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr una vez" ) self.dlg.Cb_Estado.currentTextChanged.connect( self.evt_Cb_Estado_change) #Codigo que siempre se ejecuta la primera vez que se ejecuta #QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr siempre" ) #Crear conexion al Map Canvas mc = self.iface.mapCanvas() self.dlg.SpbD_Coord_X.setValue(mc.center().x()) self.dlg.SpbD_Coord_Y.setValue(mc.center().y()) self.dlg.DtE_Fecha.setDate(QDate.currentDate()) #Revisar capas cargadas map_layers = [] for lyr in mc.layers(): map_layers.append(lyr.name()) missing_layers = [] if not "Avistamientos" in map_layers: missing_layers.append("Avistamientos") if not "Buffer Nidos" in map_layers: missing_layers.append("Buffer Nidos") if not "Buffer Lineal" in map_layers: missing_layers.append("Buffer Lineal") if missing_layers: mag = "Las siguientes capas falta en este proyecto" for lyr in missing_layers: mag += f"\n{lyr}" QMessageBox.critical(self.dlg, "Capas Faltantes", mag) return # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Do something useful here - delete the line containing pass and # substitute with your code. #QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr si presiona Ok" ) lyrNido = QgsProject.instance().mapLayersByName("Avistamientos")[0] lyrBuffer = QgsProject.instance().mapLayersByName( "Buffer Nidos")[0] idxNidoId = lyrNido.fields().indexOf("nidoID") valNidoId = lyrNido.maximumValue(idxNidoId) + 1 lyrLineal = QgsProject.instance().mapLayersByName( "Buffer Lineal")[0] #QMessageBox.information(self.dlg, "Mensaje", f"Nuevo Nido Id = {valNidoId}") valX = self.dlg.SpbD_Coord_X.value() valY = self.dlg.SpbD_Coord_Y.value() valEsp = self.dlg.Cb_Especie.currentText() valEst = self.dlg.Cb_Estado.currentText() valBuff = self.dlg.Spb_BuffDist.value() valFecha = self.dlg.DtE_Fecha.date() #QMessageBox.information(self.dlg, "Mensaje", f"Nuevo Nido Id = {valNidoId}\nCoord X = {valX}\nCoord Y = {valY}\nEspecie = {valEsp}\nEstado = {valEst}\nBuffer = {valBuff}\nFecha = {valFecha}") ftrNido = QgsFeature(lyrNido.fields()) ftrNido.setAttribute("id", valNidoId) ftrNido.setAttribute("coord_x", valX) ftrNido.setAttribute("coord_y", valY) ftrNido.setAttribute("fecha", valFecha) ftrNido.setAttribute("especie", valEsp) ftrNido.setAttribute("estado", valEst) ftrNido.setAttribute("nidoID", valNidoId) ftrNido.setAttribute("dist_buf", valBuff) geom = QgsGeometry(QgsPoint(valX, valY)) ftrNido.setGeometry(geom) pr = lyrNido.dataProvider() pr.addFeatures([ftrNido]) lyrNido.reload() #Agregar el buffer pr = lyrBuffer.dataProvider() buffer = geom.buffer(valBuff, 10) ftrNido.setGeometry(buffer) pr.addFeatures([ftrNido]) lyrBuffer.reload() dlgTabla = DlgTabla() dlgTabla.setWindowTitle(f"Tabla de Impactos para Nido {valNidoId}") bb = buffer.boundingBox() lineales = lyrLineal.getFeatures(bb) for lineal in lineales: valID = lineal.attribute("Proyecto") valTipo = lineal.attribute("Tipo") valDistancia = lineal.geometry().distance(geom) if valDistancia < valBuff: fila = dlgTabla.Tbw_Impactos.rowCount() dlgTabla.Tbw_Impactos.insertRow(fila) dlgTabla.Tbw_Impactos.setItem(fila, 0, QTableWidgetItem(str(valID))) dlgTabla.Tbw_Impactos.setItem(fila, 1, QTableWidgetItem(valTipo)) #dlgTabla.Tbw_Impactos.setItem(fila, 2, QTableWidgetItem(f"{valDistancia:.2f}")) #"{:.2f}".format(valDistancia) twi = QTableWidgetItem(f"{valDistancia:.2f}") twi.setTextAlignment(QtCore.Qt.AlignRight) dlgTabla.Tbw_Impactos.setItem(fila, 2, twi) dlgTabla.Tbw_Impactos.sortItems(2) dlgTabla.show() dlgTabla.exec_() else: QMessageBox.information( self.dlg, "Mensaje", "Esto solo debe correr si presiona Cancel")