def db_view_change_style(): in_file =open(os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/setting.sty', 'r') for line in in_file: if line[:4]=="att:": dirstili=line.split (":",2)[2].replace("\n","") if(os.path.exists(dirstili) ==False): dirstili= os.getenv("HOME")+'/.qgis2/python/plugins/Cxf_in/QML_Default' in_file.close() layers = iface.legendInterface().layers() for layer in layers: if layer.name() == "Particelle": layer.loadNamedStyle(dirstili+'/part.qml') elif layer.name() == "Fabbricati": layer.loadNamedStyle(dirstili+'/fab.qml') elif layer.name() == "Strade": layer.loadNamedStyle(dirstili+'/strade.qml') elif layer.name() == "Confine": layer.loadNamedStyle(dirstili+'/conf.qml') elif layer.name() == "Acque": layer.loadNamedStyle(dirstili+'/acque.qml') elif layer.name() == "Linee": layer.loadNamedStyle(dirstili+'/linee.qml') elif layer.name() == "Simboli": layer.loadNamedStyle(dirstili+'/Simboli.qml') elif layer.name() == "Testi": layer.loadNamedStyle(dirstili+'/testo.qml') elif layer.name() == "Fiduciali": layer.loadNamedStyle(dirstili+'/fidu.qml') iface.mapCanvas().refresh()
def processAlgorithm(self, feedback): fileName = self.getParameterValue(self.INPUT) layer = dataobjects.getObjectFromUri(fileName) crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS)) provider = layer.dataProvider() ds = provider.dataSourceUri() p = re.compile("\|.*") dsPath = p.sub("", ds) if dsPath.lower().endswith(".shp"): dsPath = dsPath[:-4] wkt = crs.toWkt() with open(dsPath + ".prj", "w") as f: f.write(wkt) qpjFile = dsPath + ".qpj" if os.path.exists(qpjFile): with open(qpjFile, "w") as f: f.write(wkt) layer.setCrs(crs) iface.mapCanvas().refresh() self.setOutputValue(self.OUTPUT, fileName)
def viewsel( self ): #ocon = sqlite3.connect(globals.dbName) ocur = globals.ocon.cursor() ocur.execute("select distinct Nomefile,Sel from " + globals.schema + "selezione order by Nomefile") lista="(" for d in ocur: if d[1] == "1": lista+="'"+d[0]+"'," lista=lista[:-1]+")" if lista!=")": lista="Nomefile IN "+lista if self.ui.singolfg.isChecked() : lista = lista + " AND ((EXT='') or (Ext is Null))" db_view_sel(self,lista) else: lista="Nomefile=='9999'" db_view_sel(self,lista) iface.mapCanvas().zoomToFullExtent()
def picker_clicked(self): if iface.mapCanvas().mapTool() != self.tool: self.pick_mode = self.PICK_MAP iface.mapCanvas().setMapTool(self.tool) self.clear_plot() else: self.stop_picking()
def get_bounding_box(self): """ Get the geometry of the bbox in WGS84 @rtype: QGsRectangle in WGS84 @return: the extent of the map canvas """ # If mapCanvas is checked if self.radioButton_extentMapCanvas.isChecked(): geom_extent = iface.mapCanvas().extent() if hasattr(iface.mapCanvas(), "mapSettings"): source_crs = iface.mapCanvas().mapSettings().destinationCrs() else: source_crs = iface.mapCanvas().mapRenderer().destinationCrs() else: # Else if a layer is checked layer = self.comboBox_extentLayer.currentLayer() geom_extent = layer.extent() source_crs = layer.crs() geom_extent = QgsGeometry.fromRect(geom_extent) epsg_4326 = QgsCoordinateReferenceSystem('EPSG:4326') crs_transform = QgsCoordinateTransform(source_crs, epsg_4326) geom_extent.transform(crs_transform) return geom_extent.boundingBox()
def manageFinished(self, success, reason): ''' Do action after notify that alg is finished. These are the postprocessing steps 1) merge result to the output layer 2) add the layer to canvas in case it is new 3) notify edn of processing 4) terminate the thread ''' # finish the thread self.thread.quit() # check result if not success: QgsMessageLog.logMessage('Failed execution: {}'.format(reason), 'QTraffic', QgsMessageLog.CRITICAL) iface.messageBar().pushCritical('QTraffic', self.tr("Error executing the algorithm: {}".format(reason))) return # prepare result try: self.alg.addResultToLayer(self.outLayer) except Exception as ex: traceback.print_exc() QgsMessageLog.logMessage('Cannot add result to layer: {}'.format(str(ex)), 'QTraffic', QgsMessageLog.CRITICAL) iface.messageBar().pushCritical('QTraffic', self.tr("Cannot add result to layer")) return # add or refresh rsult vector layer addToInputLayer = self.gui.addToOriginaLayer_RButton.isChecked() if not addToInputLayer: QgsMapLayerRegistry.instance().addMapLayer(self.outLayer) iface.mapCanvas().refresh() # notify the user the end of process iface.messageBar().pushSuccess('QTraffic', self.tr('Alg terminated successfully'))
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 show_neighbors(skip): layer_neighbors = get_layer(LAYER_NEIGHBORS) layer_vols = get_layer(LAYER_VOLUMES) features = load_feature_dict_id(layer_neighbors) features_uuid = load_feature_dict_UUID(layer_vols) idx = 0 for f in features.values(): # Skip first elements. if idx < skip: idx += 1 continue neighbors = f[FIELD_NEIGHBORS_UUID].split(",") selection = [] for x in neighbors: selection.append(features_uuid[x].id()) layer_vols.setSelectedFeatures(selection) box = layer_vols.boundingBoxOfSelected() iface.mapCanvas().setExtent(box) iface.mapCanvas().refresh() reply = QMessageBox.question( None, "Message", "Continue?\n (seeing feature " + str(idx) + ")", QMessageBox.No, QMessageBox.Yes ) if reply == QMessageBox.No: break idx += 1
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 setExpressionObj(self): #set expression calculator if not empty self.expA = dict() self.expB = dict() if bool(self.expressionLayerA) or bool(self.expressionLayerB): if bool(self.expressionLayerA): for field in self.expressionLayerA.keys(): tempDict = {'exp':None,'val':None} tempDict['exp'] = QgsExpression(self.expressionLayerA[field]) da = QgsDistanceArea() da.setSourceCrs(self.vproviderA.crs().srsid()) canvas = iface.mapCanvas() da.setEllipsoidalMode(canvas.mapRenderer().hasCrsTransformEnabled()) da.setEllipsoid(QgsProject.instance().readEntry('Measure', '/Ellipsoid', GEO_NONE)[0]) tempDict['exp'].setGeomCalculator(da) self.expA[field] = tempDict else: for field in self.expressionLayerB.keys(): tempDict = {'exp':None,'val':None} tempDict['exp'] = QgsExpression(self.expressionLayerB[field]) da = QgsDistanceArea() da.setSourceCrs(self.vproviderA.crs().srsid()) canvas = iface.mapCanvas() da.setEllipsoidalMode(canvas.mapRenderer().hasCrsTransformEnabled()) da.setEllipsoid(QgsProject.instance().readEntry('Measure', '/Ellipsoid', GEO_NONE)[0]) tempDict['exp'].setGeomCalculator(da) self.expB[self.mapBFields[field]] = tempDict
def processAlgorithm(self, parameters, context, feedback): fileName = self.getParameterValue(self.INPUT) layer = QgsProcessingUtils.mapLayerFromString(fileName, context) crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS)) provider = layer.dataProvider() ds = provider.dataSourceUri() p = re.compile('\|.*') dsPath = p.sub('', ds) if dsPath.lower().endswith('.shp'): dsPath = dsPath[:-4] wkt = crs.toWkt() with open(dsPath + '.prj', 'w') as f: f.write(wkt) qpjFile = dsPath + '.qpj' if os.path.exists(qpjFile): with open(qpjFile, 'w') as f: f.write(wkt) layer.setCrs(crs) iface.mapCanvas().refresh() self.setOutputValue(self.OUTPUT, fileName)
def get_bounding_box(self): """ Get the geometry of the bbox in WGS84 @rtype: QGsRectangle in WGS84 @return: the extent of the map canvas """ # If mapCanvas is checked if self.radioButton_extentMapCanvas.isChecked(): geom_extent = iface.mapCanvas().extent() if hasattr(iface.mapCanvas(), "mapSettings"): source_crs = iface.mapCanvas().mapSettings().destinationCrs() else: source_crs = iface.mapCanvas().mapRenderer().destinationCrs() else: # Else if a layer is checked index = self.comboBox_extentLayer.currentIndex() layer_id = self.comboBox_extentLayer.itemData(index) layers = iface.legendInterface().layers() for layer in layers: if layer.id() == layer_id: geom_extent = layer.extent() source_crs = layer.crs() break else: # the layer could be deleted before layer_name = self.comboBox_extentLayer.itemText(index) raise NoLayerException(suffix=layer_name) geom_extent = QgsGeometry.fromRect(geom_extent) epsg_4326 = QgsCoordinateReferenceSystem('EPSG:4326') crs_transform = QgsCoordinateTransform(source_crs, epsg_4326) geom_extent.transform(crs_transform) return geom_extent.boundingBox()
def checkSettings(self): s = QSettings() # pixmap preview width self.previewWidth = s.value('TileIndexPlugin/previewWidth', 1000, type=int) # activate/deactivate map canvas event filter self.transparentFix = ( s.value('TileIndexPlugin/transparentFix', True, type=bool ) == True ) # activate/deactivate map canvas event filter if s.value('TileIndexPlugin/contextMenu', True, type=bool): if not self.filterActive: iface.mapCanvas().installEventFilter(self) self.filterActive = True else: if self.filterActive: iface.mapCanvas().removeEventFilter(self) self.filterActive = False # which attribute(s) should we look for to get raster file names? self.locationAttr=['location'] if s.value('TileIndexPlugin/attribute', False, type=bool): # TODO change this attr=s.value('TileIndexPlugin/attributeStr', '', type=str).split(' ') #,QString.SkipEmptyParts) for a in attr: self.locationAttr.append(a)
def stop_picking(self): if self.pick_mode == self.PICK_MAP: iface.mapCanvas().unsetMapTool(self.tool) elif self.pick_mode == self.PICK_LAYER: self.pick_layer.selectionChanged.disconnect(self.on_pick_selection_changed) self.pick_layer = None self.pick_mode = self.PICK_NO
def useLayerExtent(self): CANVAS_KEY = "Use canvas extent" extentsDict = {} extentsDict[CANVAS_KEY] = { "extent": iface.mapCanvas().extent(), "authid": iface.mapCanvas().mapSettings().destinationCrs().authid(), } extents = [CANVAS_KEY] layers = dataobjects.getAllLayers() for layer in layers: authid = layer.crs().authid() if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) and authid is not None: layerName = u"{} [{}]".format(layer.name(), authid) else: layerName = layer.name() extents.append(layerName) extentsDict[layerName] = {"extent": layer.extent(), "authid": authid} (item, ok) = QInputDialog.getItem(self, self.tr("Select extent"), self.tr("Use extent from"), extents, False) if ok: self.setValueFromRect(extentsDict[item]["extent"]) if extentsDict[item]["authid"] != iface.mapCanvas().mapSettings().destinationCrs().authid(): iface.messageBar().pushMessage( self.tr("Warning"), self.tr( "The projection of the chosen layer is not the same as canvas projection! The selected extent might not be what was intended." ), QgsMessageBar.WARNING, 8, )
def loadLayerTable(self, carhabLayer, tableName): # Retrieve layer from provider. uri = QgsDataSourceURI() uri.setDatabase(carhabLayer.dbPath) schema = '' geom_column = 'the_geom' uri.setDataSource(schema, tableName, geom_column) display_name = carhabLayer.getName()+'_'+tableName layer = QgsVectorLayer(uri.uri(), display_name, 'spatialite') crsType = QgsCoordinateReferenceSystem.EpsgCrsId crsVal = 2154 crs = QgsCoordinateReferenceSystem(crsVal, crsType) layer.setCrs(crs) # "Bind" layer to carhab layer. if self.getCarhabLayerByDbPath(carhabLayer.dbPath): layer.setCustomProperty('carhabLayer', carhabLayer.id) # Add layer to map (False to add to group) QgsMapLayerRegistry.instance().addMapLayer(layer, False) iface.mapCanvas().setExtent(layer.extent()) return layer
def filterLayer(layerName, criteria): lyrs = QgsMapLayerRegistry.instance().mapLayers() schema = '' for l in lyrs: if QgsMapLayerRegistry.instance().mapLayer(l).name() == layerName: desc=layers[layerName] uri = QgsDataSourceURI() uri.setDatabase(root+desc[0]) schema = '' table = desc[1] geom_column = desc[2] uri.setDataSource(schema, table, geom_column, criteria) layer=QgsMapLayerRegistry.instance().mapLayer(l) print layer.dataProvider().dataSourceUri() layer.dataProvider().setDataSourceUri(uri.uri()) layer.rendererV2().symbol().setAlpha(1) QgsMapLayerRegistry.instance().reloadAllLayers() layer.dataProvider().reloadData() layer.dataProvider().forceReload() layer.triggerRepaint() QgsMapCanvas().refresh() qgis.utils.iface.mapCanvas().refresh() iface.mapCanvas().refresh() #layer.setDataSource(uri.uri(), table, geom_column) return
def on_scale_changed(): print(scale_widget.scale(), QgsScaleWidget.toString(scale_widget.scale())) print(scale_widget.scaleString(), QgsScaleWidget.toDouble(scale_widget.scaleString())) print(scale_widget.showCurrentScaleButton()) print("Scale changed") iface.mapCanvas().zoomScale(1 / scale_widget.scale())
def closeClicked(self): self.animating = False if isinstance(self.layer, QgsVectorLayer): self.layer.setSubsetString("") else: self.layer.dataProvider().setDataSourceUri(self.originalUri) iface.mapCanvas().refresh() self.setVisible(False)
def show_features(layer, features, neighbors): selection = [] for x in neighbors: selection.append(features[x].id()) layer.setSelectedFeatures(selection) box = layer.boundingBoxOfSelected() iface.mapCanvas().setExtent(box) iface.mapCanvas().refresh()
def testImportFeature(self): '''Simulate user moves and check results.''' # Open python console iface.actionShowPythonDialog().trigger() # Get map tool action that is activated previousActivatedMapToolActionName = iface.mapCanvas().mapTool().action().text() #Add test layers to map registry layerDest = self.addTestVectorLayer() layerSource = self.addTestVectorLayer('test/data/segment2.shp') iface.setActiveLayer(layerDest) # Simulate click on edit mode button self.clickOnWidgetByActionName(iface.actionToggleEditing().text()) # Simulate click on plugin fusion button self.clickOnWidgetByActionName('Import Feature') # Move and click on the feature to import self.clickOnMapPoint(QgsPoint(785519,6528705)) # Feature must have been added if not self.printTest(38, self.featuresCount(layerDest), 'Import feature', 'Features count'): return # End of test ? if self.TESTS_TO_CHECK == 'up_to_import_feature': return # Test undo action self.ctrlZ() if not self.printTest(37, self.featuresCount(layerDest), 'Undo Import feature(Ctrl + z)', 'Features count'): return # End of test ? if self.TESTS_TO_CHECK == 'up_to_undo_import_feat': return # Quit edit mode self.clickOnWidgetByActionName(iface.actionToggleEditing().text()) # Fusion button must be enabled if not self.printTest(False, self.findButtonByActionName('Import Feature').isEnabled(), 'Disable fusion button', 'Fusion button status'): return # Previous map tool button must be re-checked if not self.printTest(True, self.findButtonByActionName(previousActivatedMapToolActionName).isChecked(), 'Check previous map tool button ('+previousActivatedMapToolActionName+')', 'Previous map tool button ('+previousActivatedMapToolActionName+') status'): return # End of test ? if self.TESTS_TO_CHECK == 'up_to_quit_edit_import_feat': return # Clear layers #QgsMapLayerRegistry.instance().removeAllMapLayers() iface.mapCanvas().refresh()
def screenShot(self, imgName = 'debugScreenshot'): '''Shoot screen. :param imgName: Text value of the action to click on. :type imgName: QString :default imgName: 'debugScreenshot.png' ''' iface.mapCanvas().saveAsImage(imgName)
def clear_plot(self): for m in self.markers: iface.mapCanvas().scene().removeItem(m) self.markers = [] for rb in self.rubberbands: iface.mapCanvas().scene().removeItem(rb) self.rubberbands = [] self.plot.clear() self.clear_plot_legend()
def show_features(layer, features): selection = [] for x in features: selection.append(x.id()) layer.setSelectedFeatures(selection) box = layer.boundingBoxOfSelected() box.scale(1.1) iface.mapCanvas().setExtent(box) iface.mapCanvas().refresh()
def processAlgorithm(self, progress): filename = self.getParameterValue(self.INPUT) layer = dataobjects.getObjectFromUri(filename) style = self.getParameterValue(self.STYLE) layer.loadNamedStyle(style) self.setOutputValue(self.OUTPUT, filename) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer)
def OeQ_wait_for_renderer(timeout=10000): """Block loop until signal emitted, or timeout (ms) elapses.""" from PyQt4.QtCore import QEventLoop,QTimer #print 'wait for renderer...', # function call if action timed out def timed_out(render_result_flag): render_result_flag[0]=False loop.quit() #define loop loop = QEventLoop() #define Timer timer=QTimer() #define render_result render_result = [True] OeQ_wait(2) #check wether Canvas is drawing if iface.mapCanvas().isDrawing(): #connect mapCanvasRefreshed and renderComplete events to quit loop iface.mapCanvas().renderComplete.connect(loop.quit) iface.mapCanvas().mapCanvasRefreshed.connect(loop.quit) # if a timeout is defined and other than 0 if bool(timeout): # start timer timer.singleShot(timeout,lambda: timed_out(render_result)) #and jump into the loop loop.exec_() #disconnect after loop has quit iface.mapCanvas().mapCanvasRefreshed.disconnect(loop.quit) iface.mapCanvas().renderComplete.disconnect(loop.quit) #print 'Done' return render_result[0]
def submit_uvc(self, table_name, form_obj, id): result_msg = self.submit(table_name, form_obj, id) if not result_msg == 1: popup(str(result_msg)) return self.db.commit() iface.mapCanvas().currentLayer().triggerRepaint() self.close_db() self.uvc_form.close()
def updateExtent(self): self.setValue(self.tool.rectangle(), iface.mapCanvas().mapSettings().destinationCrs().authid()) self.tool.reset() canvas = iface.mapCanvas() canvas.setMapTool(self.prevMapTool) if self.dialog: self.dialog.showNormal() self.dialog.raise_() self.dialog.activateWindow()
def setSessionProjectionFromProject(self): """ Set the projection from the project. We creates a PROJ4 definition which is transmitted to Grass """ if not Grass7Utils.projectionSet and iface: self.destination_crs = iface.mapCanvas().mapSettings().destinationCrs() proj4 = iface.mapCanvas().mapSettings().destinationCrs().toProj4() command = 'g.proj -c proj4="{}"'.format(proj4) self.commands.append(command) Grass7Utils.projectionSet = True
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 initWidgets(self): # Heavy overload # If there are advanced parameters — show corresponding groupbox for param in self.alg.parameterDefinitions(): if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced: self.grpAdvanced.show() break #widget_context = QgsProcessingParameterWidgetContext() #if iface is not None: # widget_context.setMapCanvas(iface.mapCanvas()) # Create widgets and put them in layouts for param in self.alg.parameterDefinitions(): if param.flags() & QgsProcessingParameterDefinition.FlagHidden: continue print('initWidgets - param.name(): {}'.format(param.name())) if param.isDestination(): # and param.name() != 'OUTPUT_ASC': continue else: wrapper = WidgetWrapperFactory.create_wrapper(param, self.parent) self.wrappers[param.name()] = wrapper #widget = wrapper.widget # 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_python_wrapper = issubclass(wrapper.__class__, WidgetWrapper) if not is_python_wrapper: from qgis.gui import (QgsProcessingContextGenerator, QgsProcessingParameterWidgetContext) widget_context = QgsProcessingParameterWidgetContext() if iface is not None: widget_context.setMapCanvas(iface.mapCanvas()) wrapper.setWidgetContext(widget_context) widget = wrapper.createWrappedWidget(self.processing_context) wrapper.registerProcessingContextGenerator(self.context_generator) else: widget = wrapper.widget #if self.in_place and param.name() in ('INPUT', 'OUTPUT'): # don't show the input/output parameter widgets in in-place mode # we still need to CREATE them, because other wrappers may need to interact # with them (e.g. those parameters which need the input layer for field # selections/crs properties/etc) # continue if widget is not None: if is_python_wrapper: widget.setToolTip(param.toolTip()) if isinstance(param, QgsProcessingParameterFeatureSource): layout = QHBoxLayout() layout.setSpacing(6) layout.setMargin(0) layout.addWidget(widget) button = QToolButton() icon = QIcon(os.path.join(pluginPath, 'images', 'iterate.png')) button.setIcon(icon) button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding) button.setToolTip(self.tr('Iterate over this layer, creating a separate output for every feature in the layer')) button.setCheckable(True) layout.addWidget(button) layout.setAlignment(button, Qt.AlignTop) self.iterateButtons[param.name()] = button button.toggled.connect(self.buttonToggled) widget = QWidget() widget.setLayout(layout) label = None if not is_python_wrapper: label = wrapper.createWrappedLabel() else: label = wrapper.label if label is not None: if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced: self.layoutAdvanced.addWidget(label) else: self.layoutMain.insertWidget( self.layoutMain.count() - 2, label) elif is_python_wrapper: desc = param.description() if isinstance(param, QgsProcessingParameterExtent): desc += self.tr(' (xmin, xmax, ymin, ymax)') if isinstance(param, QgsProcessingParameterPoint): desc += self.tr(' (x, y)') if param.flags() & QgsProcessingParameterDefinition.FlagOptional: desc += self.tr(' [optional]') widget.setText(desc) if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced: self.layoutAdvanced.addWidget(widget) else: self.layoutMain.insertWidget( self.layoutMain.count() - 2, widget) for output in self.alg.destinationParameterDefinitions(): if output.flags() & QgsProcessingParameterDefinition.FlagHidden: continue #if self.in_place and param.name() in ('INPUT', 'OUTPUT'): # continue label = QLabel(output.description()) #print('initWidgets 2 - param.name(): {}'.format(param.name())) widget = DestinationSelectionPanel(output, self.alg) # TODO, overload self.layoutMain.insertWidget(self.layoutMain.count() - 1, label) self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget) if isinstance(output, (QgsProcessingParameterRasterDestination, QgsProcessingParameterFeatureSink, QgsProcessingParameterVectorDestination # alk: checkboxes for Chloe handling ,ChloeCSVParameterFileDestination, ChloeASCParameterFileDestination, ChloeParameterFolderDestination) ): check = QCheckBox() check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file(s) after running algorithm')) def skipOutputChanged(checkbox, skipped): checkbox.setEnabled(not skipped) if skipped: checkbox.setChecked(False) check.setChecked(not widget.outputIsSkipped()) check.setEnabled(not widget.outputIsSkipped()) widget.skipOutputChanged.connect(partial(skipOutputChanged, check)) self.layoutMain.insertWidget(self.layoutMain.count() - 1, check) self.checkBoxes[output.name()] = check # initial state if hasattr(output,'addToMapDefaultState'): check.setChecked(output.addToMapDefaultState) widget.setToolTip(param.toolTip()) self.outputWidgets[output.name()] = widget for wrapper in list(self.wrappers.values()): wrapper.postInitialize(list(self.wrappers.values())) # # alk: checkboxes for Chloe handling # for output in self.alg.destinationParameterDefinitions(): # if output.flags() & QgsProcessingParameterDefinition.FlagHidden: # continue # if isinstance(output, (ChloeCSVParameterFileDestination)) or isinstance(output, (ChloeASCParameterFileDestination)): # check = QCheckBox() # check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file(s) after running algorithm')) # def skipOutputChanged(checkbox, skipped): # checkbox.setEnabled(not skipped) # if skipped: # checkbox.setChecked(False) # check.setChecked(not widget.outputIsSkipped()) # check.setEnabled(not widget.outputIsSkipped()) # widget.skipOutputChanged.connect(partial(skipOutputChanged, check)) # print(str(self.layoutMain)+1) # self.layoutMain.insertWidget(self.layoutMain.count() - 1, check) # self.checkBoxes[output.name()] = check # # connecting alg outputLoading info with checkbox state # self.alg.outputLoading[output.name()] = check.isChecked() # def updateOutputLoadingState(alg, outputName, checkbox, state): # self.alg.outputLoading[outputName] = checkbox.isChecked() # print( outputName + " " + str(checkbox.isChecked()) + " " + str(self.alg.outputLoading) + " " + str(self.alg)) # #print(str(self.alg.parameters)) # check.stateChanged.connect(partial(updateOutputLoadingState, self, output.name(), check)) # alk: addition of wrapper special config handling # for dependancy between wrapper, i.e. changing the value # of a FileSelectionPanel entails the update of another widget for k in self.wrappers: w = self.wrappers[k] if hasattr(w,'getParentWidgetConfig'): print(str(w) + " " + "getParentWidgetConfig") config = w.getParentWidgetConfig() if config != None: p = self.wrappers[config['paramName']] m = getattr(w, config['refreshMethod']) if m!=None: print(str(p) + " " + str(p.widget)) # todo generalize valueChanged handling # to any type of widget componant if isinstance(p.widget, FileSelectionPanel): p.widget.leText.textChanged.connect(m) elif isinstance(p, RasterWidgetWrapper): try: p.combo.valueChanged.connect(m) # QGIS 3.8 version except: p.combo.currentIndexChanged.connect(m) # QGIS LTR 3.4
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.INPUT)) method = self.getParameterValue(self.METHOD) geometryType = layer.geometryType() fields = layer.fields() export_z = False export_m = False if geometryType == QgsWkbTypes.PolygonGeometry: areaName = vector.createUniqueFieldName('area', fields) fields.append(QgsField(areaName, QVariant.Double)) perimeterName = vector.createUniqueFieldName('perimeter', fields) fields.append(QgsField(perimeterName, QVariant.Double)) elif geometryType == QgsWkbTypes.LineGeometry: lengthName = vector.createUniqueFieldName('length', fields) fields.append(QgsField(lengthName, QVariant.Double)) else: xName = vector.createUniqueFieldName('xcoord', fields) fields.append(QgsField(xName, QVariant.Double)) yName = vector.createUniqueFieldName('ycoord', fields) fields.append(QgsField(yName, QVariant.Double)) if QgsWkbTypes.hasZ(layer.wkbType()): export_z = True zName = vector.createUniqueFieldName('zcoord', fields) fields.append(QgsField(zName, QVariant.Double)) if QgsWkbTypes.hasM(layer.wkbType()): export_m = True zName = vector.createUniqueFieldName('mvalue', fields) fields.append(QgsField(zName, QVariant.Double)) writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields.toList(), layer.wkbType(), layer.crs()) ellips = None crs = None coordTransform = None # Calculate with: # 0 - layer CRS # 1 - project CRS # 2 - ellipsoidal if method == 2: ellips = QgsProject.instance().readEntry('Measure', '/Ellipsoid', 'NONE')[0] crs = layer.crs().srsid() elif method == 1: mapCRS = iface.mapCanvas().mapSettings().destinationCrs() layCRS = layer.crs() coordTransform = QgsCoordinateTransform(layCRS, mapCRS) outFeat = QgsFeature() inGeom = QgsGeometry() outFeat.initAttributes(len(fields)) outFeat.setFields(fields) features = vector.features(layer) total = 100.0 / len(features) for current, f in enumerate(features): inGeom = f.geometry() if method == 1: inGeom.transform(coordTransform) (attr1, attr2) = vector.simpleMeasure(inGeom, method, ellips, crs) outFeat.setGeometry(inGeom) attrs = f.attributes() attrs.append(attr1) if attr2 is not None: attrs.append(attr2) # add point z/m if export_z: attrs.append(inGeom.geometry().z()) if export_m: attrs.append(inGeom.geometry().m()) outFeat.setAttributes(attrs) writer.addFeature(outFeat) progress.setPercentage(int(current * total)) del writer
from qgis.utils import iface lyrPts = QgsVectorLayer( "/home/abhishek/MSc.GIS/MSCities_Geo_Pts/MSCities_Geo_Pts.shp", "MSCities_Geo_Pts", "ogr") QgsProject.instance().addMapLayers([lyrPts]) selection = lyrPts.getFeatures( QgsFeatureRequest().setFilterExpression(u'"PLACEFP10" = 81520')) lyrPts.selectByIds([s.id() for s in selection]) iface.mapCanvas().zoomToSelected() iface.mapCanvas().refresh()
def _changeSize(): layer = _layerFromName("2525") r = layer.renderer() r.size = 80 layer.triggerRepaint() iface.mapCanvas().setExtent(layer.extent())
def showEvent(self, event): # Cannot do that in the constructor. The project is not fully setup when # it is called if not self.srsSelectionWidget.crs().isValid(): self.srsSelectionWidget.setCrs(iface.mapCanvas().mapSettings().destinationCrs()) BASE.showEvent(self, event)
def executeAlgorithm(self): config = {} if self.in_place_mode: config['IN_PLACE'] = True alg = self.algorithmTree.selectedAlgorithm().create( config) if self.algorithmTree.selectedAlgorithm( ) is not None else None if alg is not None: ok, message = alg.canExecute() if not ok: dlg = MessageDialog() dlg.setTitle(self.tr('Error executing algorithm')) dlg.setMessage( self.tr('<h3>This algorithm cannot ' 'be run :-( </h3>\n{0}').format(message)) dlg.exec_() return in_place_input_parameter_name = 'INPUT' if hasattr(alg, 'inputParameterName'): in_place_input_parameter_name = alg.inputParameterName() if self.in_place_mode and not [ d for d in alg.parameterDefinitions() if d.name() not in (in_place_input_parameter_name, 'OUTPUT') ]: parameters = {} feedback = MessageBarProgress(algname=alg.displayName()) ok, results = execute_in_place(alg, parameters, feedback=feedback) if ok: iface.messageBar().pushSuccess( '', self.tr( '{algname} completed. %n feature(s) processed.', n=results['__count']).format( algname=alg.displayName())) feedback.close() # MessageBarProgress handles errors return if alg.countVisibleParameters() > 0: dlg = alg.createCustomParametersWidget(self) if not dlg: dlg = AlgorithmDialog(alg, self.in_place_mode, iface.mainWindow()) canvas = iface.mapCanvas() prevMapTool = canvas.mapTool() dlg.show() dlg.exec_() if canvas.mapTool() != prevMapTool: try: canvas.mapTool().reset() except: pass canvas.setMapTool(prevMapTool) else: feedback = MessageBarProgress(algname=alg.displayName()) context = dataobjects.createContext(feedback) parameters = {} ret, results = execute(alg, parameters, context, feedback) handleAlgorithmResults(alg, context, feedback) feedback.close()
def initWidgets(self): # If there are advanced parameters — show corresponding groupbox for param in self.alg.parameterDefinitions(): if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced: self.grpAdvanced.show() break widget_context = QgsProcessingParameterWidgetContext() if iface is not None: widget_context.setMapCanvas(iface.mapCanvas()) # Create widgets and put them in layouts for param in self.alg.parameterDefinitions(): if param.flags() & QgsProcessingParameterDefinition.FlagHidden: continue if param.isDestination(): continue else: wrapper = WidgetWrapperFactory.create_wrapper(param, self.parent) self.wrappers[param.name()] = wrapper # 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_python_wrapper = issubclass(wrapper.__class__, WidgetWrapper) if not is_python_wrapper: wrapper.setWidgetContext(widget_context) widget = wrapper.createWrappedWidget(self.processing_context) wrapper.registerProcessingContextGenerator(self.context_generator) else: widget = wrapper.widget if self.in_place and param.name() in ('INPUT', 'OUTPUT'): # don't show the input/output parameter widgets in in-place mode # we still need to CREATE them, because other wrappers may need to interact # with them (e.g. those parameters which need the input layer for field # selections/crs properties/etc) continue if widget is not None: if is_python_wrapper: widget.setToolTip(param.toolTip()) if isinstance(param, QgsProcessingParameterFeatureSource): layout = QHBoxLayout() layout.setSpacing(6) layout.setMargin(0) layout.addWidget(widget) button = QToolButton() icon = QIcon(os.path.join(pluginPath, 'images', 'iterate.png')) button.setIcon(icon) button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding) button.setToolTip(self.tr('Iterate over this layer, creating a separate output for every feature in the layer')) button.setCheckable(True) layout.addWidget(button) layout.setAlignment(button, Qt.AlignTop) self.iterateButtons[param.name()] = button button.toggled.connect(self.buttonToggled) widget = QWidget() widget.setLayout(layout) label = None if not is_python_wrapper: label = wrapper.createWrappedLabel() else: label = wrapper.label if label is not None: if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced: self.layoutAdvanced.addWidget(label) else: self.layoutMain.insertWidget( self.layoutMain.count() - 2, label) elif is_python_wrapper: desc = param.description() if isinstance(param, QgsProcessingParameterExtent): desc += self.tr(' (xmin, xmax, ymin, ymax)') if isinstance(param, QgsProcessingParameterPoint): desc += self.tr(' (x, y)') if param.flags() & QgsProcessingParameterDefinition.FlagOptional: desc += self.tr(' [optional]') widget.setText(desc) if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced: self.layoutAdvanced.addWidget(widget) else: self.layoutMain.insertWidget( self.layoutMain.count() - 2, widget) for output in self.alg.destinationParameterDefinitions(): if output.flags() & QgsProcessingParameterDefinition.FlagHidden: continue if self.in_place and param.name() in ('INPUT', 'OUTPUT'): continue label = QLabel(output.description()) widget = DestinationSelectionPanel(output, self.alg) self.layoutMain.insertWidget(self.layoutMain.count() - 1, label) self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget) if isinstance(output, (QgsProcessingParameterRasterDestination, QgsProcessingParameterFeatureSink, QgsProcessingParameterVectorDestination)): check = QCheckBox() check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file after running algorithm')) def skipOutputChanged(checkbox, skipped): checkbox.setEnabled(not skipped) if skipped: checkbox.setChecked(False) check.setChecked(not widget.outputIsSkipped()) check.setEnabled(not widget.outputIsSkipped()) widget.skipOutputChanged.connect(partial(skipOutputChanged, check)) self.layoutMain.insertWidget(self.layoutMain.count() - 1, check) self.checkBoxes[output.name()] = check widget.setToolTip(param.toolTip()) self.outputWidgets[output.name()] = widget for wrapper in list(self.wrappers.values()): wrapper.postInitialize(list(self.wrappers.values()))
def pointPicked(self): canvas = iface.mapCanvas() canvas.setMapTool(self.prevMapTool) self.dialog.showNormal() self.dialog.raise_() self.dialog.activateWindow()
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.INPUT_LAYER)) fieldName = self.getParameterValue(self.FIELD_NAME) fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)] width = self.getParameterValue(self.FIELD_LENGTH) precision = self.getParameterValue(self.FIELD_PRECISION) newField = self.getParameterValue(self.NEW_FIELD) formula = self.getParameterValue(self.FORMULA) output = self.getOutputFromName(self.OUTPUT_LAYER) fields = layer.fields() if newField: fields.append(QgsField(fieldName, fieldType, '', width, precision)) writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs()) exp = QgsExpression(formula) da = QgsDistanceArea() da.setSourceCrs(layer.crs().srsid()) da.setEllipsoidalMode( iface.mapCanvas().mapSettings().hasCrsTransformEnabled()) da.setEllipsoid(QgsProject.instance().readEntry( 'Measure', '/Ellipsoid', GEO_NONE)[0]) exp.setGeomCalculator(da) exp.setDistanceUnits(QgsProject.instance().distanceUnits()) exp.setAreaUnits(QgsProject.instance().areaUnits()) exp_context = QgsExpressionContext() exp_context.appendScope(QgsExpressionContextUtils.globalScope()) exp_context.appendScope(QgsExpressionContextUtils.projectScope()) exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer)) if not exp.prepare(exp_context): raise GeoAlgorithmExecutionException( self.tr('Evaluation error: %s' % exp.evalErrorString())) outFeature = QgsFeature() outFeature.initAttributes(len(fields)) outFeature.setFields(fields) error = '' calculationSuccess = True features = vector.features(layer) total = 100.0 / len(features) rownum = 1 for current, f in enumerate(features): rownum = current + 1 exp_context.setFeature(f) exp_context.lastScope().setVariable("row_number", rownum) value = exp.evaluate(exp_context) if exp.hasEvalError(): calculationSuccess = False error = exp.evalErrorString() break else: outFeature.setGeometry(f.geometry()) for fld in f.fields(): outFeature[fld.name()] = f[fld.name()] outFeature[fieldName] = value writer.addFeature(outFeature) progress.setPercentage(int(current * total)) del writer if not calculationSuccess: raise GeoAlgorithmExecutionException( self.tr('An error occurred while evaluating the calculation ' 'string:\n%s' % error))
def executeAlgorithm(self, alg_id, parent, in_place=False, as_batch=False): """Executes a project model with GUI interaction if needed. :param alg_id: algorithm id :type alg_id: string :param parent: parent widget :type parent: QWidget :param in_place: in place flag, defaults to False :type in_place: bool, optional :param as_batch: execute as batch flag, defaults to False :type as_batch: bool, optional """ config = {} if in_place: config['IN_PLACE'] = True alg = QgsApplication.instance().processingRegistry( ).createAlgorithmById(alg_id, config) if alg is not None: ok, message = alg.canExecute() if not ok: dlg = MessageDialog() dlg.setTitle(self.tr('Error executing algorithm')) dlg.setMessage( self.tr('<h3>This algorithm cannot ' 'be run :-( </h3>\n{0}').format(message)) dlg.exec_() return if as_batch: dlg = BatchAlgorithmDialog(alg, iface.mainWindow()) dlg.setAttribute(Qt.WA_DeleteOnClose) dlg.show() dlg.exec_() else: in_place_input_parameter_name = 'INPUT' if hasattr(alg, 'inputParameterName'): in_place_input_parameter_name = alg.inputParameterName() if in_place and not [ d for d in alg.parameterDefinitions() if d.name() not in (in_place_input_parameter_name, 'OUTPUT') ]: parameters = {} feedback = MessageBarProgress(algname=alg.displayName()) ok, results = execute_in_place(alg, parameters, feedback=feedback) if ok: iface.messageBar().pushSuccess( '', self. tr('{algname} completed. %n feature(s) processed.', n=results['__count']).format( algname=alg.displayName())) feedback.close() # MessageBarProgress handles errors return if alg.countVisibleParameters() > 0: dlg = alg.createCustomParametersWidget(parent) if not dlg: dlg = AlgorithmDialog(alg, in_place, iface.mainWindow()) canvas = iface.mapCanvas() prevMapTool = canvas.mapTool() dlg.show() dlg.exec_() if canvas.mapTool() != prevMapTool: try: canvas.mapTool().reset() except Exception: pass canvas.setMapTool(prevMapTool) else: feedback = MessageBarProgress(algname=alg.displayName()) context = dataobjects.createContext(feedback) parameters = {} ret, results = execute(alg, parameters, context, feedback) handleAlgorithmResults(alg, context, feedback) feedback.close()
def processAlgorithm(self, context, feedback): layer = QgsProcessingUtils.mapLayerFromString( self.getParameterValue(self.INPUT_VECTOR), context) startPoint = self.getParameterValue(self.START_POINT) endPoint = self.getParameterValue(self.END_POINT) strategy = self.getParameterValue(self.STRATEGY) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) fields = QgsFields() fields.append(QgsField('start', QVariant.String, '', 254, 0)) fields.append(QgsField('end', QVariant.String, '', 254, 0)) fields.append(QgsField('cost', QVariant.Double, '', 20, 7)) writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter( fields, QgsWkbTypes.LineString, layer.crs(), context) tmp = startPoint.split(',') startPoint = QgsPoint(float(tmp[0]), float(tmp[1])) tmp = endPoint.split(',') endPoint = QgsPoint(float(tmp[0]), float(tmp[1])) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor( distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) multiplier = 3600 director.addStrategy(strategy) builder = QgsGraphBuilder( iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance) feedback.pushInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, [startPoint, endPoint]) feedback.pushInfo(self.tr('Calculating shortest path...')) graph = builder.graph() idxStart = graph.findVertex(snappedPoints[0]) idxEnd = graph.findVertex(snappedPoints[1]) tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) if tree[idxEnd] == -1: raise GeoAlgorithmExecutionException( self.tr('There is no route from start point to end point.')) route = [] cost = 0.0 current = idxEnd while current != idxStart: cost += graph.edge(tree[current]).cost(0) route.append( graph.vertex(graph.edge(tree[current]).inVertex()).point()) current = graph.edge(tree[current]).outVertex() route.append(snappedPoints[0]) route.reverse() self.setOutputValue(self.TRAVEL_COST, cost / multiplier) feedback.pushInfo(self.tr('Writing results...')) geom = QgsGeometry.fromPolyline(route) feat = QgsFeature() feat.setFields(fields) feat['start'] = startPoint.toString() feat['end'] = endPoint.toString() feat['cost'] = cost / multiplier feat.setGeometry(geom) writer.addFeature(feat) del writer
def processAlgorithm(self, progress): layer = dataobjects.getObjectFromUri( self.getParameterValue(self.INPUT_VECTOR)) startPoints = dataobjects.getObjectFromUri( self.getParameterValue(self.START_POINTS)) strategy = self.getParameterValue(self.STRATEGY) travelCost = self.getParameterValue(self.TRAVEL_COST) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) fields = QgsFields() fields.append(QgsField('type', QVariant.String, '', 254, 0)) fields.append(QgsField('start', QVariant.String, '', 254, 0)) feat = QgsFeature() feat.setFields(fields) writerPoints = self.getOutputFromName( self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint, layer.crs()) writerPolygons = self.getOutputFromName( self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs()) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor( distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) director.addStrategy(strategy) builder = QgsGraphBuilder( iface.mapCanvas().mapSettings().destinationCrs(), iface.mapCanvas().hasCrsTransformEnabled(), tolerance) progress.setInfo(self.tr('Loading start points...')) request = QgsFeatureRequest() request.setFlags(request.flags() ^ QgsFeatureRequest.SubsetOfAttributes) features = vector.features(startPoints, request) points = [] for f in features: points.append(f.geometry().asPoint()) progress.setInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, points) progress.setInfo(self.tr('Calculating service areas...')) graph = builder.graph() vertices = [] upperBoundary = [] lowerBoundary = [] total = 100.0 / len(snappedPoints) for i, p in enumerate(snappedPoints): idxStart = graph.findVertex(snappedPoints[i]) origPoint = points[i].toString() tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) for j, v in enumerate(cost): if v > travelCost and tree[j] != -1: vertexId = graph.edge(tree[j]).outVertex() if cost[vertexId] <= travelCost: vertices.append(j) for j in vertices: upperBoundary.append( graph.vertex(graph.edge(tree[j]).inVertex()).point()) lowerBoundary.append( graph.vertex(graph.edge(tree[j]).outVertex()).point()) geomUpper = QgsGeometry.fromMultiPoint(upperBoundary) geomLower = QgsGeometry.fromMultiPoint(lowerBoundary) feat.setGeometry(geomUpper) feat['type'] = 'upper' feat['start'] = origPoint writerPoints.addFeature(feat) feat.setGeometry(geomLower) feat['type'] = 'lower' feat['start'] = origPoint writerPoints.addFeature(feat) upperBoundary.append(startPoint) lowerBoundary.append(startPoint) geomUpper = QgsGeometry.fromMultiPoint(upperBoundary) geomLower = QgsGeometry.fromMultiPoint(lowerBoundary) geom = geomUpper.convexHull() feat.setGeometry(geom) feat['type'] = 'upper' feat['start'] = origPoint writerPolygons.addFeature(feat) geom = geomLower.convexHull() feat.setGeometry(geom) feat['type'] = 'lower' feat['start'] = origPoint writerPolygons.addFeature(feat) vertices[:] = [] upperBoundary[:] = [] lowerBoundary[:] = [] progress.setPercentage(int(i * total)) del writerPoints del writerPolygons
def initWidgets(self): super().initWidgets() widget_context = QgsProcessingParameterWidgetContext() widget_context.setProject(QgsProject.instance()) if iface is not None: widget_context.setMapCanvas(iface.mapCanvas()) widget_context.setBrowserModel(iface.browserModel()) widget_context.setActiveLayer(iface.activeLayer()) widget_context.setMessageBar(self.parent().messageBar()) if isinstance(self.algorithm(), QgsProcessingModelAlgorithm): widget_context.setModel(self.algorithm()) # Create widgets and put them in layouts for param in self.algorithm().parameterDefinitions(): if param.flags() & QgsProcessingParameterDefinition.FlagHidden: continue if param.isDestination(): continue else: wrapper = WidgetWrapperFactory.create_wrapper( param, self.parent()) wrapper.setWidgetContext(widget_context) wrapper.registerProcessingContextGenerator( self.context_generator) self.wrappers[param.name()] = wrapper # 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_python_wrapper = issubclass(wrapper.__class__, WidgetWrapper) if not is_python_wrapper: widget = wrapper.createWrappedWidget( self.processing_context) else: widget = wrapper.widget if self.in_place and param.name() in ('INPUT', 'OUTPUT'): # don't show the input/output parameter widgets in in-place mode # we still need to CREATE them, because other wrappers may need to interact # with them (e.g. those parameters which need the input layer for field # selections/crs properties/etc) continue if widget is not None: if is_python_wrapper: widget.setToolTip(param.toolTip()) label = None if not is_python_wrapper: label = wrapper.createWrappedLabel() else: label = wrapper.label if label is not None: self.addParameterLabel(param, label) elif is_python_wrapper: desc = param.description() if isinstance(param, QgsProcessingParameterExtent): desc += self.tr(' (xmin, xmax, ymin, ymax)') if param.flags( ) & QgsProcessingParameterDefinition.FlagOptional: desc += self.tr(' [optional]') widget.setText(desc) self.addParameterWidget(param, widget) for output in self.algorithm().destinationParameterDefinitions(): if output.flags() & QgsProcessingParameterDefinition.FlagHidden: continue if self.in_place and output.name() in ('INPUT', 'OUTPUT'): continue wrapper = QgsGui.processingGuiRegistry( ).createParameterWidgetWrapper(output, QgsProcessingGui.Standard) wrapper.setWidgetContext(widget_context) wrapper.registerProcessingContextGenerator(self.context_generator) self.wrappers[output.name()] = wrapper label = wrapper.createWrappedLabel() if label is not None: self.addOutputLabel(label) widget = wrapper.createWrappedWidget(self.processing_context) self.addOutputWidget(widget) # def skipOutputChanged(widget, checkbox, skipped): # TODO # enabled = not skipped # # # Do not try to open formats that are write-only. # value = widget.value() # if value and isinstance(value, QgsProcessingOutputLayerDefinition) and isinstance(output, ( # QgsProcessingParameterFeatureSink, QgsProcessingParameterVectorDestination)): # filename = value.sink.staticValue() # if filename not in ('memory:', ''): # path, ext = os.path.splitext(filename) # format = QgsVectorFileWriter.driverForExtension(ext) # drv = gdal.GetDriverByName(format) # if drv: # if drv.GetMetadataItem(gdal.DCAP_OPEN) is None: # enabled = False # # checkbox.setEnabled(enabled) # checkbox.setChecked(enabled) for wrapper in list(self.wrappers.values()): wrapper.postInitialize(list(self.wrappers.values()))
writer.addFeature(outFeat) i += 1 del writer layer = processing.getObject(morans_output) print layer.name() classes = [0, 1, 2, 3, 4] labels = ["not. sig", "HH", "LH", "LL", "HL"] colors = ["#FFFFFF", "#CC0000", "#66CCFF", "#000099", "#F5CCCC"] quads = {} for i in classes: quads[i] = (colors[i], labels[i]) categories = [] for quad, (color, label) in quads.items(): symbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) symbol.setColor(QtGui.QColor(color)) category = QgsRendererCategoryV2(quad, symbol, label) categories.append(category) expression = "MORANS_C" renderer = QgsCategorizedSymbolRendererV2(expression, categories) layer.setRendererV2(renderer) QgsMapLayerRegistry.instance().addMapLayer(layer) iface.mapCanvas().refresh() iface.legendInterface().refreshLayerSymbology(layer) iface.mapCanvas().refresh()
def processAlgorithm(self, progress): layer = self.getParameterValue(self.INPUT_LAYER) mapping = self.getParameterValue(self.FIELDS_MAPPING) output = self.getOutputFromName(self.OUTPUT_LAYER) layer = dataobjects.getObjectFromUri(layer) fields = [] expressions = [] da = QgsDistanceArea() da.setSourceCrs(layer.crs().srsid()) da.setEllipsoidalMode( iface.mapCanvas().mapSettings().hasCrsTransformEnabled()) da.setEllipsoid(QgsProject.instance().readEntry( 'Measure', '/Ellipsoid', GEO_NONE)[0]) exp_context = QgsExpressionContext() exp_context.appendScope(QgsExpressionContextUtils.globalScope()) exp_context.appendScope(QgsExpressionContextUtils.projectScope()) exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer)) for field_def in mapping: fields.append( QgsField(name=field_def['name'], type=field_def['type'], len=field_def['length'], prec=field_def['precision'])) expression = QgsExpression(field_def['expression']) expression.setGeomCalculator(da) expression.setDistanceUnits(QgsProject.instance().distanceUnits()) expression.setAreaUnits(QgsProject.instance().areaUnits()) if expression.hasParserError(): raise GeoAlgorithmExecutionException( self.tr(u'Parser error in expression "{}": {}').format( str(field_def['expression']), str(expression.parserErrorString()))) expression.prepare(exp_context) if expression.hasEvalError(): raise GeoAlgorithmExecutionException( self.tr(u'Evaluation error in expression "{}": {}').format( str(field_def['expression']), str(expression.evalErrorString()))) expressions.append(expression) writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs()) # Create output vector layer with new attributes error = '' calculationSuccess = True inFeat = QgsFeature() outFeat = QgsFeature() features = vector.features(layer) total = 100.0 / len(features) for current, inFeat in enumerate(features): rownum = current + 1 geometry = inFeat.geometry() outFeat.setGeometry(geometry) attrs = [] for i in range(0, len(mapping)): field_def = mapping[i] expression = expressions[i] exp_context.setFeature(inFeat) exp_context.lastScope().setVariable("row_number", rownum) value = expression.evaluate(exp_context) if expression.hasEvalError(): calculationSuccess = False error = expression.evalErrorString() break attrs.append(value) outFeat.setAttributes(attrs) writer.addFeature(outFeat) progress.setPercentage(int(current * total)) del writer if not calculationSuccess: raise GeoAlgorithmExecutionException( self.tr('An error occurred while evaluating the calculation' ' string:\n') + error)
def run(self): """Run method that loads and starts the plugin""" if not iface.building_toolbar: # Set up toolbar iface.building_toolbar = QToolBar(u"Building Tools") iface.addToolBar(iface.building_toolbar, Qt.RightToolBarArea) # Create the dockwidget and dialog and keep reference if not self.dockwidget: self.dockwidget = BuildingsDockwidget() # Connect with close self.dockwidget.closed.connect(self.on_dockwidget_closed) # Show the dockwidget as a tab layerdock = iface.mainWindow().findChild(QDockWidget, "Layers") iface.addDockWidget(Qt.LeftDockWidgetArea, self.dockwidget) iface.mainWindow().tabifyDockWidget(layerdock, self.dockwidget) self.setup_main_toolbar() dw = self.dockwidget # no base layers self.menu_frame = MenuFrame(self.dockwidget) dw.insert_into_frames("menu_frame", self.menu_frame) home_dir = os.path.dirname(__file__) if dw.lst_options.item(0) is None: icon_path = os.path.join(home_dir, "icons", "buildings_plugin.png") item = QListWidgetItem("Buildings") item.setIcon(QIcon(icon_path)) dw.lst_options.addItem(item) dw.lst_options.setCurrentItem(item) icon_path = os.path.join(home_dir, "icons", "capture_source.png") item = QListWidgetItem("Capture Sources") item.setIcon(QIcon(icon_path)) dw.lst_sub_menu.addItem(item) icon_path = os.path.join(home_dir, "icons", "bulk_load.png") item = QListWidgetItem("Bulk Load") item.setIcon(QIcon(icon_path)) dw.lst_sub_menu.addItem(item) icon_path = os.path.join(home_dir, "icons", "edit.png") item = QListWidgetItem("Edit Outlines") item.setIcon(QIcon(icon_path)) dw.lst_sub_menu.addItem(item) icon_path = os.path.join(home_dir, "icons", "settings.png") item = QListWidgetItem("Settings") item.setIcon(QIcon(icon_path)) dw.lst_sub_menu.addItem(item) icon_path = os.path.join(home_dir, "icons", "reference.png") item = QListWidgetItem("Reference Data") item.setIcon(QIcon(icon_path)) dw.lst_sub_menu.addItem(item) canvas = iface.mapCanvas() selectedcrs = "EPSG:2193" target_crs = QgsCoordinateReferenceSystem() target_crs.createFromUserInput(selectedcrs) canvas.setDestinationCrs(target_crs) self.on_click() self.dockwidget.show() self.dockwidget.raise_()
def processAlgorithm(self, parameters, context, feedback): self.feature_source = self.parameterAsSource(parameters, self.INPUT, context) raster_lyr = self.parameterAsRasterLayer(parameters, self.RASTER_INPUT, context) all_rasters = self.parameterAsBool(parameters, self.ALL_ACTIVE_RASTERS, context) temp_path = self.parameterAsString(parameters, '', context) self.dest_field = self.parameterAsString(parameters, self.FIELD, context) psm = self.parameterAsInt(parameters, 'PSM', context) oem = self.parameterAsInt(parameters, 'OEM', context) self.comma = self.parameterAsBool(parameters, 'Remove_comma', context) (self.sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context, self.feature_source.fields(), self.feature_source.wkbType(), self.feature_source.sourceCrs()) self.source_layer = self.feature_source.materialize( QgsFeatureRequest()) feedback.pushInfo('Temporary files path: ' + str(temp_path)) self.source_encod = self.source_layer.dataProvider().encoding() '''context.setDefaultEncoding(self.source_encod) self.output_encod = context.defaultEncoding() feedback.pushInfo('sys.getdefaultencoding(): ' + sys.getdefaultencoding()) feedback.pushInfo('in: ' + self.source_encod + ', out: ' + self.output_encod)''' if self.source_layer == None: list = QgsProject.instance().mapLayersByName( self.feature_source.sourceName()) for lyr in list: if self.feature_source.sourceCrs() == lyr.sourceCrs(): self.source_layer = lyr #feedback.pushInfo('self.source_layer.name(): ' + self.source_layer.name()) if self.feature_source is None: raise QgsProcessingException( self.invalidSourceError(parameters, self.INPUT)) if raster_lyr is None and not all_rasters: feedback.pushInfo('\nNo raster layer selected!\n') raise QgsProcessingException( self.invalidSourceError(parameters, self.RASTER_INPUT)) self.output_temp_tif = os.path.normpath( os.path.join(temp_path, 'output.tif')) self.output_temp_shp = os.path.normpath( os.path.join(temp_path, 'each_feature.shp')) self.output_temp_page = os.path.normpath( os.path.join(temp_path, 'current_page.tif')) '''here is tesseract config string''' self.config = '--psm ' + str(psm) + ' --oem ' + str(oem) feedback.pushInfo('Tessearct config: ' + self.config) '''creating temporary shp file, necessary for clipping''' self.crs = self.feature_source.sourceCrs().authid() layer = QgsVectorLayer( "multipolygon?crs=" + self.crs + "&field=id:integer", "temporary layer", "memory") QgsVectorFileWriter.writeAsVectorFormat( layer, self.output_temp_shp, self.source_encod, self.feature_source.sourceCrs(), "ESRI Shapefile", False) self.temp_shp_layer = QgsVectorLayer(self.output_temp_shp, "temp", "ogr") features = self.feature_source.getFeatures(QgsFeatureRequest()) self.index = QgsSpatialIndex() for feat in features: self.index.insertFeature(feat) feedback.pushInfo('\nprocessing time calculating...\n') n = [] if not all_rasters and raster_lyr: n = self.index.intersects(raster_lyr.extent()) else: for layer in iface.mapCanvas().layers(): if layer.type() == 1: n = n + self.index.intersects(layer.extent()) self.total = len(n) self.actual = 0 if self.total > 0: feedback.setProgress(self.actual / self.total * 100) if not all_rasters: self.OnThisRaster(feedback, raster_lyr) else: for layer in iface.mapCanvas().layers(): if feedback.isCanceled(): break if layer.type() == 1: self.OnThisRaster(feedback, layer) return {self.OUTPUT: dest_id}
def create_point_layer(self): """ Create an temporary point layer in the Qgis canvas """ try: QApplication.setOverrideCursor(Qt.WaitCursor) ## Start the 'wait' cursor if self.list_points: # create layer vl = QgsVectorLayer("Point?crs=" + self.selected_epsg, self.layer_name, "memory") pr = vl.dataProvider() # add fields pr.addAttributes([QgsField("id_point", QVariant.Int), QgsField("nom", QVariant.String), QgsField("pfp", QVariant.Int), QgsField("pfa", QVariant.Int), QgsField("ty", QVariant.String), QgsField("date_rep", QVariant.String), QgsField("ordre", QVariant.String), QgsField("num_carte", QVariant.String), QgsField("coordY", QVariant.Double, "double", 12, 4), QgsField("coordX", QVariant.Double, "double", 12, 4), QgsField("coord_prov", QVariant.String), QgsField("altitudeH", QVariant.Double, "double", 10, 4), QgsField("altitude_prov", QVariant.String), QgsField("coord_code", QVariant.String), QgsField("geoide_cote", QVariant.String), QgsField("geoide_prov", QVariant.String), QgsField("ellips_code", QVariant.String), QgsField("dev_vert_ETA", QVariant.String), QgsField("dev_vert_XI", QVariant.String), QgsField("dev_vert_prov", QVariant.String), QgsField("dev_vert_ETA0", QVariant.String), QgsField("dev_vert_XI0", QVariant.String), QgsField("dev_vert_prov0", QVariant.String), QgsField("code_raumtri", QVariant.String), QgsField("num_cont", QVariant.String), QgsField("flag_gps", QVariant.String), QgsField("num_sess_gps", QVariant.String), QgsField("num_zone", QVariant.String), QgsField("reserve", QVariant.String)]) vl.updateFields() # tell the vector layer to fetch changes from the provider # add features for item in self.list_points: pos_y = float(item[8]) pos_x = float(item[9]) fet = QgsFeature() fet.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(pos_y,pos_x))) fet.setAttributes(list(item)) pr.addFeatures([fet]) # add preconfigured qgis.qml style file plugin_folder = os.path.dirname(os.path.dirname(__file__)) qml_file = Path(plugin_folder) / "qml" / self.qml_style_point if qml_file.is_file(): # Test if file exist, avoid error if he is missing vl.loadNamedStyle(str(qml_file)) # update layer's extent when new features have been added vl.updateExtents() # zoom to the layer extent if self.zoom: canvas = iface.mapCanvas() canvas.setExtent(vl.extent()) # Show in project self.rmv_old_qgs_point_layer() QgsProject.instance().addMapLayer(vl) except: QApplication.restoreOverrideCursor() ## Stop the 'wait' cursor print("Point -> Failed to create a new Qgis point layer (def create_point_layer)") finally: QApplication.restoreOverrideCursor() ## Stop the 'wait' cursor
def setupUi(self): self.checkBoxes = {} self.showAdvanced = False self.wrappers = {} self.valueItems = {} self.dependentItems = {} self.algorithmItem = None self.resize(650, 450) self.buttonBox = QDialogButtonBox() self.buttonBox.setOrientation(Qt.Horizontal) self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok | QDialogButtonBox.Help) self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.verticalLayout = QVBoxLayout() self.verticalLayout.setSpacing(5) self.verticalLayout.setMargin(20) self.bar = QgsMessageBar() self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.verticalLayout.addWidget(self.bar) hLayout = QHBoxLayout() hLayout.setSpacing(5) hLayout.setMargin(0) descriptionLabel = QLabel(self.tr("Description")) self.descriptionBox = QLineEdit() self.descriptionBox.setText(self._alg.displayName()) hLayout.addWidget(descriptionLabel) hLayout.addWidget(self.descriptionBox) self.verticalLayout.addLayout(hLayout) line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) self.verticalLayout.addWidget(line) self.algorithmItem = QgsGui.instance().processingGuiRegistry( ).algorithmConfigurationWidget(self._alg) if self.configuration: self.algorithmItem.setConfiguration(self.configuration) self.verticalLayout.addWidget(self.algorithmItem) widget_context = QgsProcessingParameterWidgetContext() if iface is not None: widget_context.setMapCanvas(iface.mapCanvas()) widget_context.setModel(self.model) widget_context.setModelChildAlgorithmId(self.childId) for param in self._alg.parameterDefinitions(): if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced: self.advancedButton = QPushButton() self.advancedButton.setText( self.tr('Show advanced parameters')) self.advancedButton.clicked.connect( self.showAdvancedParametersClicked) advancedButtonHLayout = QHBoxLayout() advancedButtonHLayout.addWidget(self.advancedButton) advancedButtonHLayout.addStretch() self.verticalLayout.addLayout(advancedButtonHLayout) break for param in self._alg.parameterDefinitions(): if param.isDestination( ) or param.flags() & QgsProcessingParameterDefinition.FlagHidden: continue wrapper = WidgetWrapperFactory.create_wrapper(param, self) self.wrappers[param.name()] = wrapper if issubclass(wrapper.__class__, QgsProcessingModelerParameterWidget): wrapper.setWidgetContext(widget_context) wrapper.registerProcessingContextGenerator( self.context_generator) widget = wrapper else: widget = wrapper.widget if widget is not None: self.valueItems[param.name()] = widget if issubclass(wrapper.__class__, QgsProcessingModelerParameterWidget): label = wrapper.createLabel() else: tooltip = param.description() widget.setToolTip(tooltip) label = wrapper.label self.widget_labels[param.name()] = label if param.flags( ) & QgsProcessingParameterDefinition.FlagAdvanced: label.setVisible(self.showAdvanced) widget.setVisible(self.showAdvanced) self.verticalLayout.addWidget(label) self.verticalLayout.addWidget(widget) for dest in self._alg.destinationParameterDefinitions(): if dest.flags() & QgsProcessingParameterDefinition.FlagHidden: continue if isinstance(dest, (QgsProcessingParameterRasterDestination, QgsProcessingParameterVectorDestination, QgsProcessingParameterFeatureSink, QgsProcessingParameterFileDestination, QgsProcessingParameterFolderDestination)): label = QLabel(dest.description()) item = QgsFilterLineEdit() if hasattr(item, 'setPlaceholderText'): item.setPlaceholderText( self.tr('[Enter name if this is a final result]')) self.verticalLayout.addWidget(label) self.verticalLayout.addWidget(item) self.valueItems[dest.name()] = item label = QLabel(' ') self.verticalLayout.addWidget(label) label = QLabel(self.tr('Parent algorithms')) self.dependenciesPanel = self.getDependenciesPanel() self.verticalLayout.addWidget(label) self.verticalLayout.addWidget(self.dependenciesPanel) self.verticalLayout.addStretch(1000) self.setPreviousValues() self.setWindowTitle(self._alg.displayName()) self.verticalLayout2 = QVBoxLayout() self.verticalLayout2.setSpacing(2) self.verticalLayout2.setMargin(0) self.paramPanel = QWidget() self.paramPanel.setLayout(self.verticalLayout) self.scrollArea = QgsScrollArea() self.scrollArea.setWidget(self.paramPanel) self.scrollArea.setWidgetResizable(True) self.verticalLayout2.addWidget(self.scrollArea) self.verticalLayout2.addWidget(self.buttonBox) self.setLayout(self.verticalLayout2) self.buttonBox.accepted.connect(self.okPressed) self.buttonBox.rejected.connect(self.cancelPressed) self.buttonBox.helpRequested.connect(self.openHelp) QMetaObject.connectSlotsByName(self)
def useCanvasExtent(self): self.setValueFromRect( QgsReferencedRectangle( iface.mapCanvas().extent(), iface.mapCanvas().mapSettings().destinationCrs()))
def __init__(self, parent): super().__init__(parent) self.canvas = iface.mapCanvas() self.dockwidget = wyszukiwarkaDzialekDockWidget() # self.menu = self.tr(PLUGIN_NAME) # self.toolbar = self.iface.addToolBar(PLUGIN_NAME) # self.toolbar.setObjectName(PLUGIN_NAME) self.teryt_search_result_collector = ResultCollectorSingle(self) self.map_point_search_result_collector = self.teryt_search_result_collector self.project = QgsProject.instance() self.wms_layer = None self.module_csv_import = None self.module_teryt_search = None self.module_point_layer_import = None self.module_wms_kieg_initialized = False self.module_map_point_search = MapPointSearch( self, self.teryt_search_result_collector) result_collector_factory = lambda parent, target_layer: ResultCollectorMultiple( self, target_layer) self.module_teryt_search = TerytSearch( self, self.dockwidget.tab_teryt_search_layout, self.teryt_search_result_collector, result_collector_factory, ResultCollectorMultiple.default_layer_factory) self.module_teryt_search.lpis_bbox_found.connect(self.add_wms_lpis) result_collector_factory = lambda parent, target_layer: ResultCollectorMultiple( self, target_layer) self.module_csv_import = CSVImport( self, self.dockwidget.tab_import_csv_layout, result_collector_factory, ResultCollectorMultiple.default_layer_factory) self.module_point_layer_import = PointLayerImport( self, self.dockwidget.tab_import_layer_point_layout) self.wms_kieg_layer = None self.dockwidget.button_wms_kieg.clicked.connect(self.add_wms_kieg) self.module_wms_kieg_initialized = True self.wms_lpis_layer = None self.dockwidget.button_wms_lpis.clicked.connect(self.add_wms_lpis) self.module_wms_lpis_initialized = True icon_info_path = ':/plugins/plugin/info.png' self.dockwidget.label_info_map_point_search.setPixmap( QPixmap(icon_info_path)) self.dockwidget.label_info_map_point_search.setToolTip(( "Wybierz narzędzie i kliknij na mapę.\n" "Narzędzie wyszuka działkę, w której zawierają się współrzędne kliknięcia." )) #Zarejestrowanie we wtyczce iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget) self.uldk_toolbar_action = self.parent.add_action( ":/plugins/gissupport_plugin/uldk/uldk.svg", self.module_name, lambda state: self.dockwidget.setHidden(not state), checkable=True, parent=iface.mainWindow(), add_to_topmenu=True) self.dockwidget.visibilityChanged.connect( self.uldk_toolbar_action.setChecked) self.identify_action = self.parent.add_action( ":/plugins/gissupport_plugin/uldk/uldk_identify.svg", text="Identifykacja ULDK", callback=lambda toggle: iface.mapCanvas().setMapTool( self.module_map_point_search), parent=iface.mainWindow(), checkable=True, add_to_topmenu=False) self.module_map_point_search.setAction(self.identify_action) self.parent.toolbar.addSeparator() self.dockwidget.btnIdentify.setDefaultAction(self.identify_action) self.dockwidget.hide()
def get_map_canvas(): """Return map canvas object """ return iface.mapCanvas()
'enc_edif_comunic_a', 'hid_quebramar_molhe_a', 'loc_edificacao_a', 'sau_area_saude_a', 'lim_outras_unid_protegidas_a', 'edu_edif_religiosa_a', 'tra_edif_constr_aeroportuaria_a', 'hid_reservatorio_hidrico_a', 'lim_unidade_federacao_a', 'tra_descontinuidade_geometrica_a', 'sau_area_servico_social_a', 'lim_area_particular_a', 'enc_area_energia_eletrica_a'] # Pegando o EPSG do projeto canvas = iface.mapCanvas() epsg = int((canvas.mapRenderer().destinationCrs().authid()).split(':')[1]) # Varrer camadas e pegar as geometrias das classes que compoe a cobertura terrestre # Carregar cada feicao na camada temporaria lista = [] cont = 1 for layer in QgsMapLayerRegistry.instance().mapLayers().values(): if layer.name() in classes: for feature in layer.getFeatures(): geom = feature.geometry() if geom: coord = geom.asPolygon() if coord == []: COORD = geom.asMultiPolygon()
def processAlgorithm(self, feedback): layer = dataobjects.getLayerFromString( self.getParameterValue(self.INPUT_VECTOR)) startPoint = self.getParameterValue(self.START_POINT) endPoints = dataobjects.getLayerFromString( self.getParameterValue(self.END_POINTS)) strategy = self.getParameterValue(self.STRATEGY) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) fields = QgsFields() fields.append(QgsField('start', QVariant.String, '', 254, 0)) fields.append(QgsField('end', QVariant.String, '', 254, 0)) fields.append(QgsField('cost', QVariant.Double, '', 20, 7)) feat = QgsFeature() feat.setFields(fields) writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter( fields.toList(), QgsWkbTypes.LineString, layer.crs()) tmp = startPoint.split(',') startPoint = QgsPoint(float(tmp[0]), float(tmp[1])) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor( distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) multiplier = 3600 director.addStrategy(strategy) builder = QgsGraphBuilder( iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance) feedback.pushInfo(self.tr('Loading end points...')) request = QgsFeatureRequest() request.setFlags(request.flags() ^ QgsFeatureRequest.SubsetOfAttributes) features = vector.features(endPoints, request) count = len(features) points = [startPoint] for f in features: points.append(f.geometry().asPoint()) feedback.pushInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, points) feedback.pushInfo(self.tr('Calculating shortest paths...')) graph = builder.graph() idxStart = graph.findVertex(snappedPoints[0]) tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) route = [] total = 100.0 / count for i in range(1, count + 1): idxEnd = graph.findVertex(snappedPoints[i]) if tree[idxEnd] == -1: msg = self.tr( 'There is no route from start point ({}) to end point ({}).' .format(startPoint.toString(), points[i].toString())) feedback.setProgressText(msg) ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, msg) continue cost = 0.0 current = idxEnd while current != idxStart: cost += graph.edge(tree[current]).cost(0) route.append( graph.vertex(graph.edge(tree[current]).inVertex()).point()) current = graph.edge(tree[current]).outVertex() route.append(snappedPoints[0]) route.reverse() geom = QgsGeometry.fromPolyline(route) feat.setGeometry(geom) feat['start'] = startPoint.toString() feat['end'] = points[i].toString() feat['cost'] = cost / multiplier writer.addFeature(feat) route[:] = [] feedback.setProgress(int(i * total)) del writer
def processAlgorithm(self, feedback): extent = self.getParameterValue(self.EXTENT).split(',') xSpace = self.getParameterValue(self.STEP_X) ySpace = self.getParameterValue(self.STEP_Y) bbox = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3])) mapCRS = iface.mapCanvas().mapSettings().destinationCrs() fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) fields.append(QgsField('coord', QVariant.Double, '', 24, 15)) fieldCount = 2 writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.LineString, mapCRS) feat = QgsFeature() feat.initAttributes(fieldCount) feat.setFields(fields) geom = QgsGeometry() idVar = 0 count = 0 count_max = (bbox.yMaximum() - bbox.yMinimum()) / ySpace count_update = count_max * 0.10 y = bbox.yMaximum() while y >= bbox.yMinimum(): pt1 = QgsPoint(bbox.xMinimum(), y) pt2 = QgsPoint(bbox.xMaximum(), y) line = [pt1, pt2] feat.setGeometry(geom.fromPolyline(line)) feat.setAttribute(0, idVar) feat.setAttribute(1, y) writer.addFeature(feat) y = y - ySpace idVar += 1 count += 1 if int(math.fmod(count, count_update)) == 0: feedback.setProgress(int(count / count_max * 50)) feedback.setProgress(50) # counters for progressbar - update every 5% count = 0 count_max = (bbox.xMaximum() - bbox.xMinimum()) / xSpace count_update = count_max * 0.10 x = bbox.xMinimum() while x <= bbox.xMaximum(): pt1 = QgsPoint(x, bbox.yMaximum()) pt2 = QgsPoint(x, bbox.yMinimum()) line = [pt1, pt2] feat.setGeometry(geom.fromPolyline(line)) feat.setAttribute(0, idVar) feat.setAttribute(1, x) writer.addFeature(feat) x = x + xSpace idVar += 1 count += 1 if int(math.fmod(count, count_update)) == 0: feedback.setProgress(50 + int(count / count_max * 50)) del writer
def processAlgorithm(self, progress): extent = str(self.getParameterValue(self.EXTENT)).split(',') spacing = float(self.getParameterValue(self.SPACING)) inset = float(self.getParameterValue(self.INSET)) randomize = self.getParameterValue(self.RANDOMIZE) isSpacing = self.getParameterValue(self.IS_SPACING) extent = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3])) fields = QgsFields() fields.append(QgsField('id', QVariant.Int, '', 10, 0)) mapCRS = iface.mapCanvas().mapSettings().destinationCrs() writer = self.getOutputFromName(self.OUTPUT).getVectorWriter( fields, QgsWkbTypes.Point, mapCRS) if randomize: seed() area = extent.width() * extent.height() if isSpacing: pSpacing = spacing else: pSpacing = sqrt(area / spacing) f = QgsFeature() f.initAttributes(1) f.setFields(fields) count = 0 total = 100.0 / (area / pSpacing) y = extent.yMaximum() - inset extent_geom = QgsGeometry.fromRect(extent) extent_engine = QgsGeometry.createGeometryEngine( extent_geom.geometry()) extent_engine.prepareGeometry() while y >= extent.yMinimum(): x = extent.xMinimum() + inset while x <= extent.xMaximum(): if randomize: geom = QgsGeometry().fromPoint( QgsPoint( uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)), uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)))) else: geom = QgsGeometry().fromPoint(QgsPoint(x, y)) if extent_engine.intersects(geom.geometry()): f.setAttribute('id', count) f.setGeometry(geom) writer.addFeature(f) x += pSpacing count += 1 progress.setPercentage(int(count * total)) y = y - pSpacing del writer
def get_qgis_app(cleanup=True): """ Start one QGIS application to test against. :returns: Handle to QGIS app, canvas, iface and parent. If there are any errors the tuple members will be returned as None. :rtype: (QgsApplication, CANVAS, IFACE, PARENT) If QGIS is already running the handle to that app will be returned. """ global QGIS_APP, PARENT, IFACE, CANVAS # pylint: disable=W0603 if iface: from qgis.core import QgsApplication QGIS_APP = QgsApplication CANVAS = iface.mapCanvas() PARENT = iface.mainWindow() IFACE = iface return QGIS_APP, CANVAS, IFACE, PARENT from qgis.core import QgsApplication from qgis.gui import QgsMapCanvas from qgis.PyQt.QtCore import QSize from qgis.PyQt.QtWidgets import QWidget from .qgis_interface import QgisInterface global QGISAPP # pylint: disable=global-variable-undefined try: QGISAPP except NameError: myGuiFlag = True # All test will run qgis in gui mode # In python3 we need to convert to a bytes object (or should # QgsApplication accept a QString instead of const char* ?) try: argvb = list(map(os.fsencode, sys.argv)) except AttributeError: argvb = sys.argv # Note: QGIS_PREFIX_PATH is evaluated in QgsApplication - # no need to mess with it here. QGISAPP = QgsApplication(argvb, myGuiFlag) QGISAPP.initQgis() s = QGISAPP.showSettings() LOGGER.debug(s) def debug_log_message(message, tag, level): """ Prints a debug message to a log :param message: message to print :param tag: log tag :param level: log message level (severity) :return: """ print('{}({}): {}'.format(tag, level, message)) QgsApplication.instance().messageLog().messageReceived.connect( debug_log_message) if cleanup: import atexit @atexit.register def exitQgis(): # pylint: disable=unused-variable """ Gracefully closes the QgsApplication instance """ try: QGISAPP.exitQgis() # pylint: disable=used-before-assignment QGISAPP = None # pylint: disable=redefined-outer-name except NameError: pass if PARENT is None: # noinspection PyPep8Naming PARENT = QWidget() if CANVAS is None: # noinspection PyPep8Naming CANVAS = QgsMapCanvas(PARENT) CANVAS.resize(QSize(400, 400)) if IFACE is None: # QgisInterface is a stub implementation of the QGIS plugin interface # noinspection PyPep8Naming IFACE = QgisInterface(CANVAS) return QGISAPP, CANVAS, IFACE, PARENT
from qgis.utils import iface # inserire qui il nome del layer geometrico vl = QgsMapLayerRegistry.instance().mapLayersByName('nomeLayerGeom')[0] iface.setActiveLayer(vl) cLayer = iface.mapCanvas().currentLayer() # qui sotto i nomi dei due campi da correlare expr = QgsExpression("\"refGeom\"=[% "refAttr" %]") it = cLayer.getFeatures( QgsFeatureRequest( expr ) ) ids = [i.id() for i in it] cLayer.setSelectedFeatures( ids ) # zoom alla selezione box = cLayer.boundingBoxOfSelected() iface.mapCanvas().setExtent(box) iface.mapCanvas().refresh() -- caso dei pill: from qgis.utils import iface vl = QgsMapLayerRegistry.instance().mapLayersByName('pti_pill')[0] iface.setActiveLayer(vl) cLayer = iface.mapCanvas().currentLayer() expr = QgsExpression("\"pk_uid\"=[% "pk_uid" %]") it = cLayer.getFeatures( QgsFeatureRequest( expr ) ) ids = [i.id() for i in it] cLayer.setSelectedFeatures( ids ) box = cLayer.boundingBoxOfSelected() iface.mapCanvas().setExtent(box) iface.mapCanvas().refresh() -- articolo: -- https://medium.com/tantotanto/qgis-selezionare-geometrie-da-una-tabella-di-attributi-correlata-bea37747a7e2
def selectOnCanvas(self): canvas = iface.mapCanvas() canvas.setMapTool(self.tool) self.dialog.showMinimized()
def processAlgorithm(self, parameters, context, feedback): layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_VECTOR), context) startPoint = self.getParameterValue(self.START_POINT) strategy = self.getParameterValue(self.STRATEGY) travelCost = self.getParameterValue(self.TRAVEL_COST) directionFieldName = self.getParameterValue(self.DIRECTION_FIELD) forwardValue = self.getParameterValue(self.VALUE_FORWARD) backwardValue = self.getParameterValue(self.VALUE_BACKWARD) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) bothValue = self.getParameterValue(self.VALUE_BOTH) defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION) speedFieldName = self.getParameterValue(self.SPEED_FIELD) defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED) tolerance = self.getParameterValue(self.TOLERANCE) tmp = startPoint.split(',') startPoint = QgsPointXY(float(tmp[0]), float(tmp[1])) directionField = -1 if directionFieldName is not None: directionField = layer.fields().lookupField(directionFieldName) speedField = -1 if speedFieldName is not None: speedField = layer.fields().lookupField(speedFieldName) director = QgsVectorLayerDirector(layer, directionField, forwardValue, backwardValue, bothValue, defaultDirection) distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits() multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters) if strategy == 0: strategy = QgsNetworkDistanceStrategy() else: strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed, multiplier * 1000.0 / 3600.0) director.addStrategy(strategy) builder = QgsGraphBuilder(iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance) feedback.pushInfo(self.tr('Building graph...')) snappedPoints = director.makeGraph(builder, [startPoint]) feedback.pushInfo(self.tr('Calculating service area...')) graph = builder.graph() idxStart = graph.findVertex(snappedPoints[0]) tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0) vertices = [] for i, v in enumerate(cost): if v > travelCost and tree[i] != -1: vertexId = graph.edge(tree[i]).outVertex() if cost[vertexId] <= travelCost: vertices.append(i) upperBoundary = [] lowerBoundary = [] for i in vertices: upperBoundary.append(graph.vertex(graph.edge(tree[i]).inVertex()).point()) lowerBoundary.append(graph.vertex(graph.edge(tree[i]).outVertex()).point()) feedback.pushInfo(self.tr('Writing results...')) fields = QgsFields() fields.append(QgsField('type', QVariant.String, '', 254, 0)) fields.append(QgsField('start', QVariant.String, '', 254, 0)) feat = QgsFeature() feat.setFields(fields) geomUpper = QgsGeometry.fromMultiPoint(upperBoundary) geomLower = QgsGeometry.fromMultiPoint(lowerBoundary) writer = self.getOutputFromName( self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint, layer.crs(), context) feat.setGeometry(geomUpper) feat['type'] = 'upper' feat['start'] = startPoint.toString() writer.addFeature(feat, QgsFeatureSink.FastInsert) feat.setGeometry(geomLower) feat['type'] = 'lower' feat['start'] = startPoint.toString() writer.addFeature(feat, QgsFeatureSink.FastInsert) del writer upperBoundary.append(startPoint) lowerBoundary.append(startPoint) geomUpper = QgsGeometry.fromMultiPoint(upperBoundary) geomLower = QgsGeometry.fromMultiPoint(lowerBoundary) writer = self.getOutputFromName( self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context) geom = geomUpper.convexHull() feat.setGeometry(geom) feat['type'] = 'upper' feat['start'] = startPoint.toString() writer.addFeature(feat, QgsFeatureSink.FastInsert) geom = geomLower.convexHull() feat.setGeometry(geom) feat['type'] = 'lower' feat['start'] = startPoint.toString() writer.addFeature(feat, QgsFeatureSink.FastInsert) del writer