def fetchResults(self, string, context, feedback): # collect results in main thread, since this method is inexpensive and # accessing the processing registry/current layer is not thread safe if iface.activeLayer() is None or iface.activeLayer().type() != QgsMapLayer.VectorLayer or not iface.activeLayer().selectedFeatureCount(): return for a in QgsApplication.processingRegistry().algorithms(): if not a.flags() & QgsProcessingAlgorithm.FlagSupportsInPlaceEdits: continue if not a.supportInPlaceEdit(iface.activeLayer()): continue if QgsLocatorFilter.stringMatches(a.displayName(), string) or [t for t in a.tags() if QgsLocatorFilter.stringMatches(t, string)] or \ (context.usingPrefix and not string): result = QgsLocatorResult() result.filter = self result.displayString = a.displayName() result.icon = a.icon() result.userData = a.id() if string and QgsLocatorFilter.stringMatches(a.displayName(), string): result.score = float(len(string)) / len(a.displayName()) else: result.score = 0 self.resultFetched.emit(result)
def execute_in_place(alg, parameters, context=None, feedback=None): """Executes an algorithm modifying features in-place in the active layer. The input layer must be editable or an exception is raised. :param alg: algorithm to run :type alg: QgsProcessingAlgorithm :param parameters: parameters of the algorithm :type parameters: dict :param context: context, defaults to None :param context: QgsProcessingContext, optional :param feedback: feedback, defaults to None :param feedback: QgsProcessingFeedback, optional :raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project :return: a tuple with true if success and results :rtype: tuple """ parameters['INPUT'] = QgsProcessingFeatureSourceDefinition( iface.activeLayer().id(), True) ok, results = execute_in_place_run(alg, iface.activeLayer(), parameters, context=context, feedback=feedback) if ok: iface.activeLayer().triggerRepaint() return ok, results
def createWidget(self): if self.dialogType == DIALOG_STANDARD: widget = QWidget() layout = QHBoxLayout() layout.setMargin(0) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(2) self.combo = QgsMapLayerComboBox() layout.addWidget(self.combo) btn = QToolButton() btn.setText('...') btn.setToolTip(self.tr("Select file")) btn.clicked.connect(self.selectFile) layout.addWidget(btn) widget.setLayout(layout) if self.param.optional: self.combo.setAllowEmptyLayer(True) self.combo.setFilters(QgsMapLayerProxyModel.VectorLayer) self.combo.setExcludedProviders(['grass']) try: if iface.activeLayer().type() == QgsMapLayer.VectorLayer: self.combo.setLayer(iface.activeLayer()) except: pass self.combo.currentIndexChanged.connect(lambda: self.widgetValueHasChanged.emit(self)) self.combo.currentTextChanged.connect(lambda: self.widgetValueHasChanged.emit(self)) return widget elif self.dialogType == DIALOG_BATCH: return BatchInputSelectionPanel(self.param, self.row, self.col, self.dialog) else: self.combo = QComboBox() layers = self.dialog.getAvailableValuesOfType(ParameterRaster, OutputRaster) self.combo.setEditable(True) tables = self.dialog.getAvailableValuesOfType(ParameterTable, OutputTable) layers = self.dialog.getAvailableValuesOfType(ParameterVector, OutputVector) if self.param.optional: self.combo.addItem(self.NOT_SELECTED, None) for table in tables: self.combo.addItem(self.dialog.resolveValueDescription(table), table) for layer in layers: self.combo.addItem(self.dialog.resolveValueDescription(layer), layer) widget = QWidget() layout = QHBoxLayout() layout.setMargin(0) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(2) layout.addWidget(self.combo) btn = QToolButton() btn.setText('...') btn.setToolTip(self.tr("Select file")) btn.clicked.connect(self.selectFile) layout.addWidget(btn) widget.setLayout(layout) return widget
def fetchResults(self, string, context, feedback): # collect results in main thread, since this method is inexpensive and # accessing the processing registry/current layer is not thread safe if iface.activeLayer() is None or iface.activeLayer().type() != QgsMapLayer.VectorLayer: return for a in QgsApplication.processingRegistry().algorithms(): if not a.flags() & QgsProcessingAlgorithm.FlagSupportsInPlaceEdits: continue if not a.supportInPlaceEdit(iface.activeLayer()): continue if QgsLocatorFilter.stringMatches(a.displayName(), string) or [t for t in a.tags() if QgsLocatorFilter.stringMatches(t, string)] or \ (context.usingPrefix and not string): result = QgsLocatorResult() result.filter = self result.displayString = a.displayName() result.icon = a.icon() result.userData = a.id() if string and QgsLocatorFilter.stringMatches(a.displayName(), string): result.score = float(len(string)) / len(a.displayName()) else: result.score = 0 self.resultFetched.emit(result)
def __init__(self, alg): super(FieldsCalculatorDialog, self).__init__(None) self.setupUi(self) self.executed = False self._wasExecuted = False self.alg = alg self.layer = None self.cmbInputLayer.setFilters(QgsMapLayerProxyModel.VectorLayer) try: if iface.activeLayer().type() == QgsMapLayerType.VectorLayer: self.cmbInputLayer.setLayer(iface.activeLayer()) except: pass self.cmbInputLayer.layerChanged.connect(self.updateLayer) self.btnBrowse.clicked.connect(self.selectFile) self.mNewFieldGroupBox.toggled.connect(self.toggleExistingGroup) self.mUpdateExistingGroupBox.toggled.connect(self.toggleNewGroup) self.mOutputFieldTypeComboBox.currentIndexChanged.connect( self.setupSpinboxes) # Default values for field width and precision self.mOutputFieldWidthSpinBox.setValue(10) self.mOutputFieldPrecisionSpinBox.setValue(3) # Output is a shapefile, so limit maximum field name length self.mOutputFieldNameLineEdit.setMaxLength(10) self.manageGui()
def eventFilter(self, obj, event): if event is None or self is None or QEvent is None: return False if event.type() == QEvent.ContextMenu: layer = iface.activeLayer() #if layer is not None and layer.type() == QgsMapLayer.VectorLayer: (index,indexStr) = self.checkLayerAttribute( layer, False ) if index != -1: globalPos = iface.mapCanvas().mapToGlobal(event.pos()) myMenu = QMenu() str1 = self.tr("Add selected tile raster layer(s)") str3 = self.tr("Add all tile raster layer(s)") str2 = self.tr("Show tile previews in map") if len(layer.selectedFeatures()) != 0: myMenu.addAction(QIcon(":/plugins/tileindex/icon/mActionAddImage.png"),str1) myMenu.addAction(QIcon(":/plugins/tileindex/icon/mActionAddRasterLayer.png"),str3) myMenu.addAction(QIcon(":/plugins/tileindex/icon/mActionMapTips.png"),str2) selectedAction = myMenu.exec_(globalPos) if selectedAction: if selectedAction.text() == str1: count = self.addSelectedTiles( iface.activeLayer() ) elif selectedAction.text() == str3: self.addAllTiles( iface.activeLayer() ) elif selectedAction.text() == str2: self.showPreview(layer) else: return False return True return False return False
def __init__(self, alg): super(FieldsCalculatorDialog, self).__init__(None) self.setupUi(self) self.executed = False self._wasExecuted = False self.alg = alg self.layer = None self.cmbInputLayer.setFilters(QgsMapLayerProxyModel.VectorLayer) try: if iface.activeLayer().type() == QgsMapLayer.VectorLayer: self.cmbInputLayer.setLayer(iface.activeLayer()) except: pass self.cmbInputLayer.layerChanged.connect(self.updateLayer) self.btnBrowse.clicked.connect(self.selectFile) self.mNewFieldGroupBox.toggled.connect(self.toggleExistingGroup) self.mUpdateExistingGroupBox.toggled.connect(self.toggleNewGroup) self.mOutputFieldTypeComboBox.currentIndexChanged.connect(self.setupSpinboxes) # Default values for field width and precision self.mOutputFieldWidthSpinBox.setValue(10) self.mOutputFieldPrecisionSpinBox.setValue(3) # Output is a shapefile, so limit maximum field name length self.mOutputFieldNameLineEdit.setMaxLength(10) self.manageGui()
def edit_reset_clicked(self): """When bulk load frame btn_reset_save clicked""" self.edit_dialog.ids = [] self.edit_dialog.building_outline_id = None iface.actionSelect().trigger() iface.activeLayer().removeSelection() # reset and disable comboboxes self.edit_dialog.circle_tool = None self.disable_UI_functions()
def mapaPlantillaPdf(self): import time registry = QgsMapLayerRegistry.instance() layers = registry.mapLayers().values() layerName = iface.activeLayer().name() # Add layer to map render myMapRenderer = QgsMapRenderer() myMapRenderer.setLayerSet(layerName) myMapRenderer.setProjectionsEnabled(False) # Load template layer = iface.activeLayer() canvas = iface.mapCanvas() extent = layer.extent() #canvas = QgsMapCanvas() ms = canvas.mapSettings() myComposition = QgsComposition(ms) # uso plantilla if (extent.width() > extent.height()): tipo = 'h' myFile = os.path.join(os.path.dirname(__file__), 'template_h2.qpt') else: # plantilla vertical tipo = 'v' myFile = os.path.join(os.path.dirname(__file__), 'template_v2.qpt') #myFile = '/home/jose/Documentos/pyqgis/template_h.qpt' myTemplateFile = file(myFile, 'rt') myTemplateContent = myTemplateFile.read() myTemplateFile.close() myDocument = QDomDocument() myDocument.setContent(myTemplateContent) myComposition.loadFromTemplate(myDocument) # Sustituir textos substitution_map = {'TITULO': u'TEMÁTICO','EDIFICIO':self.dlg.comboBoxEdificio.currentText(),'FECHA': time.strftime("%d/%m/%Y") ,'AUTOR': u'José Manuel Mira','ORGANISMO': 'Universidad de Alicante'} myComposition.loadFromTemplate(myDocument, substitution_map) # Zoom a capa myMap = myComposition.getComposerMapById(0) myExtent = iface.activeLayer().extent() myMap.setNewExtent(myExtent) # Save image salidaPNG = "mapa_" + layer.name() + "_" + time.strftime("%Y%m%d%H%M%S") + ".png" myImage = myComposition.printPageAsRaster(0) myImage.save(salidaPNG) # export PDF import time salidaPDF = "mapa_" + layer.name() + "_" + time.strftime("%Y%m%d%H%M%S") + ".pdf" myComposition.exportAsPDF(salidaPDF) QMessageBox.information(self.iface.mainWindow(), "Resultado", "Los mapas, " + salidaPNG + " y "+ salidaPDF+ " han sido creados exitosamente.")
def edit_reset_clicked(self): """ When production frame btn_edit_reset clicked """ self.edit_dialog.ids = [] self.edit_dialog.building_outline_id = None # restart editing iface.actionSelect().trigger() iface.activeLayer().removeSelection() # reset and disable comboboxes self.disable_UI_functions()
def setRelSoglia(self, dlg): #Gestisce lo slider che indica la soglia di visualizzazione in base all'overlay temporale delle relazioni soglia = dlg.horizontalSlider.value() if soglia >= 65: expr = "overlay = 'dentro'" if soglia < 65 and soglia >= 45: expr = "overlay = 'parziale'" if soglia < 45 and soglia >= 10: expr = "overlay = 'fuori'" if soglia < 10: expr = "overlay = 'dentro' or overlay = 'parziale' or overlay = 'fuori'" iface.activeLayer().setSubsetString(expr)
def edit_reset_clicked(self): """ When production frame btn_edit_reset clicked """ self.editing_layer.geometryChanged.disconnect(self.geometry_changed) iface.actionCancelEdits().trigger() self.editing_layer.geometryChanged.connect(self.geometry_changed) self.edit_dialog.geoms = {} # restart editing iface.actionToggleEditing().trigger() iface.actionVertexTool().trigger() iface.activeLayer().removeSelection() # reset and disable comboboxes self.disable_UI_functions()
def change_color(): active_layer = iface.activeLayer() renderer = active_layer.rendererV2() symbol = renderer.symbol() symbol.setColor(QColor(Qt.red)) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(active_layer)
def tematico(self): layer = iface.activeLayer() usos = { u"Administración": ("#b3cde3", u"Administración"), "Despacho": ("#fbb4ae", "Despacho"), "Docencia": ("#ccebc5", "Docencia"), "Laboratorio": ("#decbe4", "Laboratorio"), "Salas": ("#fed9a6", "Salas"), "Muros": ("#808080", "Muros"), "": ("white", "Resto")} categorias = [] for estancia, (color, label) in usos.items(): sym = QgsSymbolV2.defaultSymbol(layer.geometryType()) sym.setColor(QColor(color)) category = QgsRendererCategoryV2(estancia, sym, label) categorias.append(category) field = "activresum" index = layer.fieldNameIndex("activresum") # comprueba que existe el campo activresum if (index == -1): QMessageBox.critical(None, "Field error", "No existe el campo activresum. Seleccione la capa adecuada") break renderer = QgsCategorizedSymbolRendererV2(field, categorias) layer.setRendererV2(renderer) QgsMapLayerRegistry.instance().addMapLayer(layer) layer.triggerRepaint() layer.setName(layer.name()[:6] + u' (uso)') # actualizar metadatos layer.setTitle(u"Planta de edificio " + layer.name()[:6] + u' (uso)' ) layer.setAbstract(u"Edificio procedente del Sistema de Informacion Geografica de la Universidad de Alicante (SIGUA)")
def calazim(self): layer = iface.activeLayer() field = QgsField('id', QVariant.Double) cal = QgsAuxiliaryStorage() auxlyr = cal.createAuxiliaryLayer(field, layer) layer.setAuxiliaryLayer(auxlyr) auxLayer = layer.auxiliaryLayer() vdef = QgsPropertyDefinition("azim", 1, "azimute", "calcula angulo azimute", "angulo") auxLayer.addAuxiliaryField(vdef) auxFields = auxLayer.fields() features = layer.getFeatures() for feature in features: geom = feature.geometry() ombb = geom.orientedMinimumBoundingBox() auxFeature = QgsFeature(auxFields) auxFeature['ASPK'] = feature['id'] angazim = ombb[2] if ombb[4] < ombb[3]: angazim = ombb[2] - 90 if angazim < 0: angazim = ombb[2] + 90 auxFeature['angulo_azim'] = angazim ''' auxFeature['lado_lar'] = ombb[3]*1000 auxFeature['lado_alt'] = ombb[4]*1000 auxFeature['ver_boll'] = invertido ''' auxLayer.addFeature(auxFeature) print("testeaqui")
def initMask(self, layout): layer = iface.activeLayer() # load the layer as you want ext = iface.mapCanvas().extent() #ext = layer.extent() xmin = ext.xMinimum() xmax = ext.xMaximum() ymin = ext.yMinimum() ymax = ext.yMaximum() coords = "%f,%f,%f,%f" % (xmin, xmax, ymin, ymax) self.extent = QtWidgets.QLineEdit() self.extent.setText(coords) TitleLayout("Raster extent", self.extent, layout) self.res = QtWidgets.QLineEdit() xres = (xmax - xmin) / 100 yres = (ymax - ymin) / 100 self.res.setText(str(xres) + ',' + str(yres)) TitleLayout("Raster resolution X,Y (m)", self.res, layout) self.valin = QtWidgets.QLineEdit() self.valin.setText(str(50)) TitleLayout("Resolution inside in m", self.valin, layout) self.valout = QtWidgets.QLineEdit() self.valout.setText(str(10000)) TitleLayout("Resolution outside in m", self.valout, layout) self.runLayout = CancelRunLayout(self, "calculate", self.apply_mask, layout) self.runLayout.runButton.setEnabled(True) self.setLayout(layout)
def endDrawLine(self): iface.actionToggleEditing().triggered.disconnect(self.endDrawLine) self.show() vlayer = iface.activeLayer() selection = vlayer.getFeatures() count = vlayer.featureCount() #print("当前选择层有特征数:%d" % count) for feature in selection: geom = feature.geometry() geomSingleType = QgsWkbTypes.isSingleType(geom.wkbType()) if geom.type() == QgsWkbTypes.LineGeometry: if geomSingleType: x = geom.asPolyline() print("Line: ", x, "length: ", geom.length()) pstr_list = [] for index in range(len(x) - 1): resStr = "{},{},{},{}".format(x[index].x(), x[index].y(), x[index + 1].x(), x[index + 1].y()) pstr_list.append(resStr) print(pstr_list) self.startEndPointEdt.setText(';'.join(pstr_list))
def save_color_map(self): """ Save the currently open color-map as a qml-file into the project folder. :return: :rtype: """ from mole import extensions layer = iface.activeLayer() selected_layer = self.layers_dropdown.currentText() if layer.name() != selected_layer: layer = layer_interaction.find_layer_by_name(selected_layer) out_path = os.path.dirname(layer.publicSource()) out_path = os.path.join(out_path, layer.name() + '.qml') self.update_color_values() entry_written = self.color_entry_manager.write_color_map_as_qml(layer.name(), out_path) if entry_written: self.message_label.setStyleSheet(_fromUtf8("color: green;")) self.message_label.setText('Success - Legend was successfully written to \n\t"{}".'.format(out_path)) else: self.message_label.setStyleSheet(_fromUtf8("color: red;")) self.message_label.setText('Failure - Could not write legend to to \n\t"{}".'.format(out_path)) activeextensions = extensions.by_layername(layer.name()) try: activeextensions[0].colortable = out_path except: pass
def paste(self): paste_dect = self.field_list paste_layer = iface.activeLayer() paste_field = paste_layer.fields().names() paste_sel = paste_layer.selectedFeatures() count = paste_layer.selectedFeatureCount() if count != 0: if paste_layer.isEditable(): for paste_feature in paste_sel: for f in paste_field: if str(f) in paste_dect: my_key = str(f) my_value = str(paste_dect.get(my_key)) #print(my_key+"::"+ my_value) paste_feature.setAttribute( paste_feature.fieldNameIndex(my_key), my_value) paste_layer.updateFeature(paste_feature) self.iface.messageBar().pushMessage( "Pasted attributes succesfully") self.field_list = dict() self.pasteAction.setEnabled(False) else: self.iface.messageBar().pushMessage("layer is not editable") else: self.iface.messageBar().pushMessage("Select atleast one feature")
def run(self): """Run method that identifies counties and display""" # Create the dialog with elements (after translation) and keep reference if self.first_start == True: self.first_start = False self.dlg = shapefile_loaderDialog() self.dlg.label.setText("") layer = iface.activeLayer() name1 ="" #cc1 = [] #for i in range(0, 47): feat = layer.getFeature(19) name1 = feat['NAME_1'] #cc1 = feat['CC_1'] #mbsa_id = 1 #mbsa_ind = cc1.index[mbsa_id] #mbsa_name = name1[] message = "YOU ARE FROM {} COUNTY.".format(name1) self.dlg.label.setText(message) # 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. pass
def onOk(self): self.ui.textEdit.clear() self.ui.view.scene().clear() aLayer = iface.activeLayer() if aLayer is None: QMessageBox.warning(self, unicode("DiagLeg"), unicode("Please select a Layer and try again!"), QMessageBox.Ok ); return provider = aLayer.dataProvider() listFields = [] fields = aLayer.pendingFields() for i in range(fields.count()): field = fields[i] listFields.append(field.name()) #First we create the system temp to get the name, and then a .qml created by Qgis when it saved the style f = tempfile.NamedTemporaryFile(delete=True) aLayer.saveNamedStyle(f.name); strTmp=f.name+".qml" self.importDOM(strTmp,listFields) #Remember to delete both files! f.close() b=QFile(strTmp).remove()
def save_color_map(self): """ Save the currently open color-map as a qml-file into the project folder. :return: :rtype: """ from mole import extensions layer = iface.activeLayer() selected_layer = self.layers_dropdown.currentText() if layer.name() != selected_layer: layer = layer_interaction.find_layer_by_name(selected_layer) out_path = os.path.dirname(layer.publicSource()) out_path = os.path.join(out_path, layer.name() + '.qml') self.update_color_values() entry_written = self.color_entry_manager.write_color_map_as_qml( layer.name(), out_path) if entry_written: self.message_label.setStyleSheet(_fromUtf8("color: green;")) self.message_label.setText( 'Success - Legend was successfully written to \n\t"{}".'. format(out_path)) else: self.message_label.setStyleSheet(_fromUtf8("color: red;")) self.message_label.setText( 'Failure - Could not write legend to to \n\t"{}".'.format( out_path)) activeextensions = extensions.by_layername(layer.name()) try: activeextensions[0].colortable = out_path except: pass
def spaceBarPressed(): global myIt, activeLayerId aLayer = iface.activeLayer() if not aLayer or not aLayer.type() == QgsMapLayer.VectorLayer: iface.messageBar().pushInfo( "Feature iterator", "First select a vector layer in the layers panel.") return if activeLayerId != aLayer.id(): activeLayerId = aLayer.id() myIt = None if not myIt: request = QgsFeatureRequest().setFlags( QgsFeatureRequest.NoGeometry).setNoAttributes() myIt = aLayer.getFeatures(request) feat = next(myIt, None) if feat: aLayer.selectByIds([feat.id()]) if aLayer.geometryType() == QgsWkbTypes.PointGeometry: iface.actionPanToSelected().trigger() # Pan to points else: iface.actionZoomToSelected().trigger() # Zoom to the rest else: iface.messageBar().pushInfo("Feature iterator", "We reached the last feature of this layer already.\n" + \ "If you want to restart press the Escape key.")
def run_write_csv(self): """Run method that performs all the real work""" # initializes the logger, makes it available here, but also in the # fmsf_hms_utils operations by using logging.getLogger("fmsf2hms") logger = make_logger() self.dlg = WriteCSVDialog() self.dlg.outputDirectoryButton.clicked.connect( self.select_output_directoy) # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() if result: res_type = self.dlg.buttonGroup.checkedButton().text() out_dir = self.dlg.outputDirectory.text() logger.debug(res_type) layer = iface.activeLayer() dw = HMSDataWriter(layer, res_type) output = dw.write_csv(out_dir) iface.messageBar().pushMessage("Success", "CSV created: " + output, level=Qgis.Success, duration=0)
def dms (lat, lon): """ Add a point at the lat and lon for the current layer using DMS notation """ lat,lon = lat, lon l_lat = lat.upper().split() l_lon = lon.upper().split() # need to add validation tests if l_lat[3] == 'N': ddlat = float(l_lat[0])+(float(l_lat[1])/60)+float(l_lat[2])/3600 elif l_lat[3] == 'S': ddlat = (float(l_lat[0])+float(l_lat[1])/60+float(l_lat[2])/3600)*-1 else: ddlat = '0' if l_lon [3] == 'E': ddlon = float(l_lon[0])+float(l_lon[1])/60+float(l_lon[2])/3600 elif l_lon[3] == 'W': ddlon = (float(l_lon[0])+float(l_lon[1])/60+float(l_lon[2])/3600)*-1 else: ddlon = '0' layer = iface.activeLayer() f = QgsFeature(layer.pendingFields()) geom = QgsGeometry.fromPoint(QgsPoint(ddlon,ddlat)) f.setGeometry(geom) layer.addFeature(f) iface.mapCanvas().refresh()
def __init__(self, alg, in_place=False, parent=None): super().__init__(parent) self.feedback_dialog = None self.in_place = in_place self.active_layer = None self.context = None self.feedback = None self.setAlgorithm(alg) self.setMainWidget(self.getParametersPanel(alg, self)) if not self.in_place: self.runAsBatchButton = QPushButton(QCoreApplication.translate("AlgorithmDialog", "Run as Batch Process…")) self.runAsBatchButton.clicked.connect(self.runAsBatch) self.buttonBox().addButton(self.runAsBatchButton, QDialogButtonBox.ResetRole) # reset role to ensure left alignment else: self.active_layer = iface.activeLayer() self.runAsBatchButton = None has_selection = self.active_layer and (self.active_layer.selectedFeatureCount() > 0) self.buttonBox().button(QDialogButtonBox.Ok).setText(QCoreApplication.translate("AlgorithmDialog", "Modify Selected Features") if has_selection else QCoreApplication.translate("AlgorithmDialog", "Modify All Features")) self.buttonBox().button(QDialogButtonBox.Close).setText(QCoreApplication.translate("AlgorithmDialog", "Cancel")) self.setWindowTitle(self.windowTitle() + ' | ' + self.active_layer.name())
def execute_in_place(alg, parameters, context=None, feedback=None): """Executes an algorithm modifying features in-place, if the INPUT parameter is not defined, the current active layer will be used as INPUT. :param alg: algorithm to run :type alg: QgsProcessingAlgorithm :param parameters: parameters of the algorithm :type parameters: dict :param context: context, defaults to None :param context: QgsProcessingContext, optional :param feedback: feedback, defaults to None :param feedback: QgsProcessingFeedback, optional :raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project :return: a tuple with true if success and results :rtype: tuple """ if feedback is None: feedback = QgsProcessingFeedback() if context is None: context = dataobjects.createContext(feedback) if not 'INPUT' in parameters or not parameters['INPUT']: parameters['INPUT'] = iface.activeLayer() ok, results = execute_in_place_run(alg, parameters, context=context, feedback=feedback) if ok: if isinstance(parameters['INPUT'], QgsProcessingFeatureSourceDefinition): layer = alg.parameterAsVectorLayer({'INPUT': parameters['INPUT'].source}, 'INPUT', context) elif isinstance(parameters['INPUT'], QgsVectorLayer): layer = parameters['INPUT'] if layer: layer.triggerRepaint() return ok, results
def guardarValor(self): autenticado = self.validarAuth() if autenticado: if self.dockwidget.tableWidgetAtributosEdit.rowCount() > 0: #Obtenemos las propiedades de la capa self.capa = iface.activeLayer() self.capaActual = self.capa self.features = self.capaActual.selectedFeatures()[0] #Activamos el modo de edicion self.capaActual.startEditing() for x in range(0, len(self.features.attributes())): self.features[ x] = self.dockwidget.tableWidgetAtributosEdit.item( x, 1).text() self.capaActual.updateFeature(self.features) self.capaActual.commitChanges() self.createAlert('Se guardo correctamente', QMessageBox.Information, 'Edicion de atributos') self.actualizarCapa() else: self.createAlert("Necesitas seleccionar una capa", QMessageBox.Warning, 'Edicion de atributos') elif autenticado == False: self.createAlert("Tu inicio de sesion expiro", QMessageBox.Warning, 'Sesion expiro edicion de atributos') print('se presiono el boton de guarda valor')
def selection_changed(self) -> None: try: # Obtenim una llista de les Features seleccionades a la capa activa del mapa layer = iface.activeLayer() if not layer: return selected_features = layer.selectedFeatures() # Revisem si l'usuari no ha seleccionat res, en aquest cas deixem d'executar if len(selected_features) == 0: return # Get primary key field_id = tools_gw.execute_procedure('gw_fct_getpkeyfield', f"'{layer.name()}'") list_ids = [] # Desem l'ID de l'últim Feature seleccionat i ho mostrem a la consola for i in selected_features: attr_id = i.attribute(field_id) list_ids.append(attr_id) tools_qt.set_widget_text(self.dlg, self.dlg.lbl_selected_items, ','.join(list_ids)) except Exception as e: tools_log.log_warning(f"Exception: {type(e).__name__}, {e}") finally: # Tanquem la subscripció de l'event per evitar la duplicació iface.mapCanvas().selectionChanged.disconnect( self.selection_changed) iface.actionPan().trigger()
def __init__(self, alg, in_place=False, parent=None): super().__init__(parent) self.feedback_dialog = None self.in_place = in_place self.active_layer = None self.context = None self.feedback = None self.setAlgorithm(alg) self.setMainWidget(self.getParametersPanel(alg, self)) if not self.in_place: self.runAsBatchButton = QPushButton( QCoreApplication.translate("AlgorithmDialog", "Run as Batch Process…")) self.runAsBatchButton.clicked.connect(self.runAsBatch) self.buttonBox().addButton(self.runAsBatchButton, QDialogButtonBox.ResetRole ) # reset role to ensure left alignment else: self.active_layer = iface.activeLayer() self.runAsBatchButton = None has_selection = self.active_layer and ( self.active_layer.selectedFeatureCount() > 0) self.buttonBox().button(QDialogButtonBox.Ok).setText( QCoreApplication. translate("AlgorithmDialog", "Modify Selected Features" ) if has_selection else QCoreApplication. translate("AlgorithmDialog", "Modify All Features")) self.buttonBox().button(QDialogButtonBox.Close).setText( QCoreApplication.translate("AlgorithmDialog", "Cancel")) self.setWindowTitle(self.windowTitle() + ' | ' + self.active_layer.name())
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 = CreateLayerFromSelectedDialog() # show the dialog # self.dlg.show() # Run the dialog event loop # Skip the dialog box result = True if result: # Get current active layer and copy style layer = iface.activeLayer() iface.actionCopyLayerStyle().trigger() # Create in memory layer from selected features memory_layer = layer.materialize(QgsFeatureRequest().setFilterFids( layer.selectedFeatureIds())) memory_layer.setName(memory_layer.name() + " Selection") # Add layer and paste style QgsProject.instance().addMapLayer(memory_layer) iface.actionPasteLayerStyle().trigger()
def setCellWrapper(self, row, column, wrapper, context): self.wrappers[row - 1][column] = wrapper widget_context = QgsProcessingParameterWidgetContext() widget_context.setProject(QgsProject.instance()) if iface is not None: widget_context.setActiveLayer(iface.activeLayer()) widget_context.setMapCanvas(iface.mapCanvas()) widget_context.setMessageBar(self.parent.messageBar()) if isinstance(self.alg, QgsProcessingModelAlgorithm): widget_context.setModel(self.alg) wrapper.setWidgetContext(widget_context) wrapper.registerProcessingContextGenerator(self.context_generator) # For compatibility with 3.x API, we need to check whether the wrapper is # the deprecated WidgetWrapper class. If not, it's the newer # QgsAbstractProcessingParameterWidgetWrapper class # TODO QGIS 4.0 - remove is_cpp_wrapper = not issubclass(wrapper.__class__, WidgetWrapper) if is_cpp_wrapper: widget = wrapper.createWrappedWidget(context) else: widget = wrapper.widget self.tblParameters.setCellWidget(row, column, widget)
def updateForCurrentLayer(self): layer = iface.activeLayer() sld = "" geostyler = "" mapbox = "" mapserver = "" warnings = [] if layer is not None: if (isinstance(layer, QgsRasterLayer) or (isinstance(layer, QgsVectorLayer) and layer.isSpatial())): sld, _, sld_warnings = layerStyleAsSld(layer) geostyler, icons, sprites, geostyler_warnings = convert(layer) geostyler = json.dumps(geostyler, indent=4) mapbox, _, mapbox_warnings = layerStyleAsMapbox(layer) mapserver, _, _, mapserverWarnings = layerStyleAsMapfile(layer) warnings = set() warnings.update(sld_warnings) warnings.update(geostyler_warnings) warnings.update(mapbox_warnings) warnings.update(mapserverWarnings) self.txtSld.setText(sld) self.txtGeostyler.setText(geostyler) self.txtMapbox.setText(mapbox) self.txtMapserver.setText(mapserver) self.txtWarnings.setPlainText("\n".join(warnings))
def execute_in_place(alg, parameters, context=None, feedback=None): """Executes an algorithm modifying features in-place, if the INPUT parameter is not defined, the current active layer will be used as INPUT. :param alg: algorithm to run :type alg: QgsProcessingAlgorithm :param parameters: parameters of the algorithm :type parameters: dict :param context: context, defaults to None :param context: QgsProcessingContext, optional :param feedback: feedback, defaults to None :param feedback: QgsProcessingFeedback, optional :raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project :return: a tuple with true if success and results :rtype: tuple """ if not 'INPUT' in parameters or not parameters['INPUT']: parameters['INPUT'] = iface.activeLayer() ok, results = execute_in_place_run(alg, parameters, context=context, feedback=feedback) if ok: parameters['INPUT'].triggerRepaint() return ok, results
def use_active_layer(self): """ Loads coordinates extent of the active layer. """ iface.actionPan().trigger() layers = iface.mapCanvas().layers() chosen_layer = str(self.layersBox.currentText()) for layer in layers: if str(layer.name()) == chosen_layer: crs = self.format_crs_str(layer.crs().authid()) ex_layer = layer.extent() east = round(ex_layer.xMaximum(), 1) north = round(ex_layer.yMaximum(), 1) west = round(ex_layer.xMinimum(), 1) south = round(ex_layer.yMinimum(), 1) spatial_extent = { "west": west, "east": east, "north": north, "south": south, "crs": crs } str_format = str(spatial_extent).replace("'", '"') self.processgraphSpatialExtent.setText(str_format) if not iface.activeLayer(): self.iface.messageBar().pushMessage( "Please open a new layer to get extent from.", duration=5)
def updateField(): maCouche = iface.activeLayer() vYear = u"year_end" vStatus = u"fk_status" for feature in maCouche.getFeatures(QgsFeatureRequest(int([%$id%]))): msgBox = QtGui.QMessageBox() if feature[vStatus] == 13002: text_arch = u"L'objet ID = [%$id%] de la couche '" + str(maCouche.name()) + u"' a déjà été archivé en " + str(feature[vYear]) msgBox.setText(text_arch) msgBox.exec_() if feature[vStatus] != 13002: input_rep = QtGui.QInputDialog() year_end, ok = input_rep.getInt(None, u"Annee d'archivage ", u"indiquez l'ann\xe9e d'archive (4 chiffres)", datetime.now().year, 1800,2999, 1) if ok: if not maCouche.isEditable(): maCouche.startEditing() feature[vStatus] = 13002 feature[vYear] = year_end if iface.openFeatureForm(maCouche, feature): maCouche.updateFeature(feature) text = u"L'objet ID = [%$id%] de la couche '" + str(maCouche.name()) + u"' \xe9t\xe9 archiv\xe9 en " + str(year_end) msgBox.setText(text) msgBox.exec_() else: pass else: pass else: pass
def __init__(self, edit_dialog): """Constructor""" BulkLoadChanges.__init__(self, edit_dialog) # set editing to edit polygon iface.actionSelect().trigger() selecttools = iface.attributesToolBar().findChildren(QToolButton) # selection actions iface.building_toolbar.addSeparator() for sel in selecttools: if sel.text() == "Select Feature(s)": for a in sel.actions()[0:3]: iface.building_toolbar.addAction(a) iface.building_toolbar.show() self.disable_UI_functions() if len(iface.activeLayer().selectedFeatures()) > 0: if self.is_correct_selections(): self.get_selections() self.enable_UI_functions() self.populate_edit_comboboxes() self.select_comboboxes_value() else: self.edit_dialog.ids = [] self.edit_dialog.building_outline_id = None self.disable_UI_functions()
def getParameterValues(self): parameters = {} if self.mainWidget() is None: return parameters for param in self.algorithm().parameterDefinitions(): if param.flags() & QgsProcessingParameterDefinition.FlagHidden: continue if not param.isDestination(): if self.in_place and param.name() == 'INPUT': parameters[param.name()] = iface.activeLayer() continue try: wrapper = self.mainWidget().wrappers[param.name()] except KeyError: continue # For compatibility with 3.x API, we need to check whether the wrapper is # the deprecated WidgetWrapper class. If not, it's the newer # QgsAbstractProcessingParameterWidgetWrapper class # TODO QGIS 4.0 - remove if issubclass(wrapper.__class__, WidgetWrapper): widget = wrapper.widget else: widget = wrapper.wrappedWidget() if widget is None: continue value = wrapper.parameterValue() parameters[param.name()] = value if not param.checkValueIsAcceptable(value): raise AlgorithmDialogBase.InvalidParameterValue( param, widget) else: if self.in_place and param.name() == 'OUTPUT': parameters[param.name()] = 'memory:' continue dest_project = None if not param.flags() & QgsProcessingParameterDefinition.FlagHidden and \ isinstance(param, (QgsProcessingParameterRasterDestination, QgsProcessingParameterFeatureSink, QgsProcessingParameterVectorDestination)): if self.mainWidget().checkBoxes[param.name()].isChecked(): dest_project = QgsProject.instance() value = self.mainWidget().outputWidgets[ param.name()].getValue() if value and isinstance(value, QgsProcessingOutputLayerDefinition): value.destinationProject = dest_project if value: parameters[param.name()] = value return self.algorithm().preprocessParameters(parameters)
def execute_in_place(alg, parameters, context=None, feedback=None): """Executes an algorithm modifying features in-place, if the INPUT parameter is not defined, the current active layer will be used as INPUT. :param alg: algorithm to run :type alg: QgsProcessingAlgorithm :param parameters: parameters of the algorithm :type parameters: dict :param context: context, defaults to None :param context: QgsProcessingContext, optional :param feedback: feedback, defaults to None :param feedback: QgsProcessingFeedback, optional :raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project :return: a tuple with true if success and results :rtype: tuple """ if feedback is None: feedback = QgsProcessingFeedback() if context is None: context = dataobjects.createContext(feedback) if 'INPUT' not in parameters or not parameters['INPUT']: parameters['INPUT'] = iface.activeLayer() ok, results = execute_in_place_run(alg, parameters, context=context, feedback=feedback) if ok: if isinstance(parameters['INPUT'], QgsProcessingFeatureSourceDefinition): layer = alg.parameterAsVectorLayer({'INPUT': parameters['INPUT'].source}, 'INPUT', context) elif isinstance(parameters['INPUT'], QgsVectorLayer): layer = parameters['INPUT'] if layer: layer.triggerRepaint() return ok, results
def filter_selection(self): ''' filter the active layer by selected objects ''' if not self.login: return # either name of layer or group have to match a category active_layer = iface.activeLayer() categories = self.categories.keys() layer_error = (u'Sie müssen im Layerfenster einen ' u'Layer auswählen, wahlweise aus den Gruppen ' u'Einrichtungen oder Filter.') if not active_layer: QtGui.QMessageBox.information(self, 'Fehler', layer_error) return else: layer_name = active_layer.name() if layer_name in categories: category = layer_name else: project_tree = QgsProject.instance().layerTreeRoot() layer_item = project_tree.findLayer(active_layer.id()) group = layer_item.parent() group_name = group.name() if group_name in categories: category = group_name else: QtGui.QMessageBox.information(self, 'Fehler', layer_error) return selected_feats = active_layer.selectedFeatures() if not selected_feats: msg = (u'Im ausgewählten Layer {} sind keine ' u'Einrichtungen selektiert.'.format(layer_name)) QtGui.QMessageBox.information(self, 'Fehler', msg) return parent_group = get_group('Filter') subgroup = get_group(category, parent_group) ids = [str(f.attribute('sel_id')) for f in selected_feats] name, ok = QtGui.QInputDialog.getText( self, 'Filter', 'Name des zu erstellenden Layers', text=get_unique_layer_name(category, subgroup)) if not ok: return subset = 'sel_id in ({})'.format(','.join(ids)) layer = QgsVectorLayer(active_layer.source(), name, "postgres") remove_layer(name, subgroup) QgsMapLayerRegistry.instance().addMapLayer(layer, False) subgroup.addLayer(layer) layer.setSubsetString(subset) symbology = SimpleSymbology(self.colors[category], shape='triangle') symbology.apply(layer) self.copy_editor_attrs(active_layer, layer)
def point_at(x, y): """ Add a point at the x and y for the current layer """ x, y = float(x), float(y) layer = iface.activeLayer() f = QgsFeature(layer.pendingFields()) geom = QgsGeometry.fromPoint(QgsPoint(x, y)) f.setGeometry(geom) layer.addFeature(f) iface.mapCanvas().refresh()
def select_output_file(self): global nameloadfile filename = QFileDialog.getOpenFileName(self.dlg, "Select output file ","", '*.*') nameloadfile = start_rwt.format_rwt_file(filename,self) layer = iface.activeLayer() # Cria uma layer start_rwt.update_rwt_form(layer,self,filename) # if nameloadfile=='StAMPs': # start_rwt.update_stp_rwt_form(layer,self,filename) # print"estou no selectfile:",nameloadfile
def point_at_dms(lat, lon): """ Add a point at the lat and lon for the current layer using DMS notation """ ddlat, ddlon = dms_to_dd(lat, lon) layer = iface.activeLayer() f = QgsFeature(layer.pendingFields()) geom = QgsGeometry.fromPoint(QgsPoint(ddlon, ddlat)) f.setGeometry(geom) layer.addFeature(f) iface.mapCanvas().refresh()
def canvasPressEvent(self, e): #QMessageBox.information(None, "hello", "click!") pt_canvas = e.pos() pt_map = self.toMapCoordinates(pt_canvas) geom = QgsGeometry.fromPoint(pt_map) minDist = 99999999 minName = "" layer = iface.activeLayer() for f in layer.getFeatures(): dist = f.geometry().distance(geom) if dist < minDist: minDist = dist minName = f["name"] QMessageBox.information(None, "Minimal distance", "%s -- only %f" % (minName, minDist))
def execute_in_place(alg, parameters, context=None, feedback=None): """Executes an algorithm modifying features in-place in the active layer. The input layer must be editable or an exception is raised. :param alg: algorithm to run :type alg: QgsProcessingAlgorithm :param parameters: parameters of the algorithm :type parameters: dict :param context: context, defaults to None :param context: QgsProcessingContext, optional :param feedback: feedback, defaults to None :param feedback: QgsProcessingFeedback, optional :raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project :return: a tuple with true if success and results :rtype: tuple """ parameters['INPUT'] = QgsProcessingFeatureSourceDefinition(iface.activeLayer().id(), True) ok, results = execute_in_place_run(alg, iface.activeLayer(), parameters, context=context, feedback=feedback) if ok: iface.activeLayer().triggerRepaint() return ok, results
def change_color(self): layer = iface.activeLayer() # create a new single symbol renderer symbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) renderer = QgsSingleSymbolRendererV2(symbol) # define un simbolo properties = {'color': 'green', 'color_border': 'black'} symbol_layer = QgsSimpleFillSymbolLayerV2.create(properties) # assign the symbol layer to the symbol renderer.symbols()[0].changeSymbolLayer(0, symbol_layer) # assign the renderer to the layer layer.setRendererV2(renderer) self.iface.legendInterface().refreshLayerSymbology(layer) #self.iface.mapCanvas().freeze(True) self.iface.mapCanvas().refresh() layer.triggerRepaint()
def feature_move(x, y): """ Moves a point to the x and y for the current layer """ x, y = float(x), float(y) layer = iface.activeLayer() selection = layer.selectedFeatures() update = False for feature in selection: fgeom = feature.geometry() geom = QgsGeometry.fromPoint(QgsPoint(x, y)) same = fgeom.asPoint() == geom.asPoint() if not same: layer.changeGeometry(feature.id(), geom) update = True if update: iface.mapCanvas().refresh()
def feature_move_dms(lat, lon): """ Add a point at the lat and lon for the current layer using DMS notation """ ddlat, ddlon = dms_to_dd(lat, lon) layer = iface.activeLayer() selection = layer.selectedFeatures() update = False for feature in selection: fgeom = feature.geometry() geom = QgsGeometry.fromPoint(QgsPoint(ddlon, ddlat)) same = fgeom.asPoint() == geom.asPoint() if not same: layer.changeGeometry(feature.id(), geom) update = True if update: iface.mapCanvas().refresh()
def tematico2(self): layer = iface.activeLayer() # array de dptos idx = layer.fieldNameIndex('txt_dpto_sigua') dptosArr = layer.uniqueValues( idx ) total = len(dptosArr) if total < 3: coloresArr = colorbrewer.Set3[3] elif total <= 12: coloresArr = colorbrewer.Set3[total] else: exceso = total - 12 if exceso < 3: coloresArr = colorbrewer.Set3[12] + colorbrewer.Paired[3] else: coloresArr = colorbrewer.Set3[12] + colorbrewer.Paired[exceso] print coloresArr dptoDic = {} for i in range(0, len(dptosArr)): if dptosArr[i] == u"GESTIÓN DE ESPACIOS": dptoDic[dptosArr[i]] = ("white", dptosArr[i]) else: dptoDic[dptosArr[i]] = (coloresArr[i], dptosArr[i]) #print dptoDic categories = [] for estancia, (color, label) in dptoDic.items(): sym = QgsSymbolV2.defaultSymbol(layer.geometryType()) sym.setColor(QColor(color)) category = QgsRendererCategoryV2(estancia, sym, label) categories.append(category) field = "txt_dpto_sigua" renderer = QgsCategorizedSymbolRendererV2(field, categories) layer.setRendererV2(renderer) QgsMapLayerRegistry.instance().addMapLayer(layer) layer.triggerRepaint() layer.setName(layer.name()[:6] + u" (organización)") # actualizar metadatos layer.setTitle(u"Planta de edificio " + layer.name()[:6] + u" (organización)") layer.setAbstract(u"Edificio procedente del Sistema de Información Geográfica de la Universidad de Alicante (SIGUA)")
def labelCodigo(self): layer = iface.activeLayer() palyr = QgsPalLayerSettings() palyr.readFromLayer(layer) palyr.enabled = True palyr.bufferDraw = True palyr.bufferColor = QColor("white") palyr.bufferSize = 1 palyr.scaleVisibility = True palyr.scaleMax = 2000 palyr.isExpression = True palyr.fieldName = 'if( "codigo" NOT LIKE \'%000\', right( "codigo" ,3),"")' palyr.size = 15 palyr.textColor = QColor("black") palyr.drawLabels = True palyr.fitInPolygonOnly = True #solo dibuja las label que caben dentro del poligono palyr.placement = QgsPalLayerSettings.OverPoint palyr.setDataDefinedProperty(QgsPalLayerSettings.Size, True, True, '7', '') palyr.writeToLayer(layer) iface.mapCanvas().refresh()
# coding: utf-8 from PyQt4.QtCore import Qt from qgis.gui import QgsMapTool from qgis.utils import iface class SendPointToolCoordinates(QgsMapTool): """ Enable to return coordinates from clic in a layer. """ def __init__(self, canvas, layer): """ Constructor. """ QgsMapTool.__init__(self, canvas) self.canvas = canvas self.layer = layer self.setCursor(Qt.CrossCursor) def canvasReleaseEvent(self, event): point = self.toLayerCoordinates(self.layer, event.pos()) print(point.x(), point.y()) layer, canvas = iface.activeLayer(), iface.mapCanvas() send_point_tool_coordinates = SendPointToolCoordinates( canvas, layer ) canvas.setMapTool(send_point_tool_coordinates)
# coding: utf-8 from qgis.gui import QgsMultiBandColorRendererWidget from qgis.utils import iface layer = iface.activeLayer() # From a multiband raster multi_band_color_renderer_widget = QgsMultiBandColorRendererWidget( layer ) multi_band_color_renderer_widget.show()
def table(tablename): if not tablename.strip(): layer = iface.activeLayer() else: layer = layer_by_name(tablename) iface.showAttributeTable(layer)
from PyQt4.QtGui import * from PyQt4.QtCore import * from qgis.core import * from qgis.utils import iface wb = QgsVectorLayer('/data/world_borders.shp', 'world_borders', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(wb) active_layer = iface.activeLayer() renderer = active_layer.rendererV2() symbol = renderer.symbol() symbol.setColor(QColor(Qt.red)) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(active_layer) iface.showAttributeTable(iface.activeLayer())
# coding: utf-8 from qgis.core import QgsStyleV2 from qgis.gui import QgsRendererRulePropsDialog from qgis.utils import iface layer = iface.activeLayer() # You need a QgsVectorLayer with Rule-based style canvas = iface.mapCanvas() root_rule = layer.rendererV2().rootRule() renderer_rule_props_dialog = QgsRendererRulePropsDialog( root_rule.children()[1].children()[0], # QgsRuleBasedRendererV2.Rule layer, # QgsVectorLayer QgsStyleV2.defaultStyle(), # QgsStyleV2 None, # parent QWidget, optional canvas # QgsMapCanvas, optional ) renderer_rule_props_dialog.show()
# Looking for all the neighbours of the selected polygon from qgis.utils import iface # Replace the values below with values from your layer. # Change the _NAME_FIELD value to the name of your identifier field _NAME_FIELD = 'NAME_2' layer = iface.activeLayer() # Create a dictionary of all features feature_dict = {f.id(): f for f in layer.getFeatures()} # Set the myfeature value to the value of your polygon myfeature = 'Wade Hampton' # Loop through all features and find features that touch each feature for f in feature_dict.values(): if f[_NAME_FIELD] == myfeature: geom = f.geometry() # Find all features that intersect the bounding box of the current feature. intersecting_ids = index.intersects(geom.boundingBox()) # Initalize neighbors list neighbors = [] for intersecting_id in intersecting_ids: # Look up the feature from the dictionary intersecting_f = feature_dict[intersecting_id] if (f != intersecting_f and not intersecting_f.geometry().disjoint(geom)): neighbors.append(intersecting_f[_NAME_FIELD]) f[_NEW_NEIGHBORS_FIELD] = ','.join(neighbors)
# coding: utf-8 from PyQt4.QtGui import QDialog, QTableView from qgis.core import QgsVectorLayerCache from qgis.gui import (QgsAttributeTableModel, QgsAttributeTableView, QgsAttributeTableFilterModel) from qgis.utils import iface new_dialog = QDialog() new_dialog.resize(800, 600) vector_layer_cache = QgsVectorLayerCache(iface.activeLayer(), 10000) attribute_table_model = QgsAttributeTableModel(vector_layer_cache) attribute_table_model.loadLayer() attribute_table_filter_model = QgsAttributeTableFilterModel( iface.mapCanvas(), attribute_table_model ) attribute_table_view = QgsAttributeTableView(new_dialog) attribute_table_view.setModel(attribute_table_filter_model) new_dialog.show() # Or display the attribute_table_model with QTableView (pure QT solution) table_view = QTableView() table_view.setModel(attribute_table_model) table_view.show()
# coding: utf-8 from qgis.gui import QgsActionMenu from qgis.utils import iface layer = iface.activeLayer() if iface.activeLayer().actions().size() > 0: features = layer.dataProvider().getFeatures() feat1 = features.next() action_menu = QgsActionMenu( layer, feat1 ) print(feat1.id()) action_menu.show() print(action_menu.actions()) feat2 = features.next() action_menu.setFeature(feat2) print(feat2.id()) else: print('No action for this layer')