def exportToMemoryLayer(self, route, srid, valueMaps): vectorLyr = core.QgsVectorLayer( 'LineString?crs=epsg:{0}{1}'.format( srid, self.getMemoryLayerFieldsUrl()), 'rota', "memory") vl = core.QgsProject().instance().addMapLayer(vectorLyr) vl.startEditing() feat = core.QgsFeature(vl.fields()) pavingValueMap = [ valueMap for valueMap in valueMaps if valueMap['attribute'] == 'revestimento' ] pavingValueMap = pavingValueMap[0][ 'valueMap'] if pavingValueMap else {} getPavingValue = lambda code, valueMap=pavingValueMap: list( pavingValueMap.keys())[list(pavingValueMap.values()).index(code)] for step in route: step['covering'] = getPavingValue( step['covering']).split('(')[0].strip() feat.setAttribute('id', step['seq']) feat.setAttribute('nome', step['name']) feat.setAttribute('sigla', step['initials']) feat.setAttribute('revestimento', step['covering']) feat.setAttribute('faixas', step['tracks']) feat.setAttribute('velocidade', step['velocity']) feat.setAttribute('observacao', step['note']) feat.setGeometry(QgsGeometry.fromWkt(step['wkt'])) vl.addFeature(feat) vl.commitChanges() return vl
def mouseClick(self, currentPos, clickedButton): if clickedButton == QtCore.Qt.LeftButton: self.rubberBand.addPoint(core.QgsPointXY(currentPos)) self.isEditing = True return if not ( clickedButton == QtCore.Qt.RightButton and self.rubberBand.numberOfVertices() > 2 ): return self.isEditing = False geometryWkt = self.rubberBand.asGeometry().asWkt()= epsgid = iface.mapCanvas().mapSettings().destinationCrs().authid().replace("EPSG:", "") vectorLayer = core.QgsVectorLayer( "?query=SELECT geom_from_wkt('{0}') as geometry&geometry=geometry:3:{1}".format(geometryWkt, epsgid), "Polygon_Reference", "virtual" ) core.QgsProject.instance().addMapLayer(vectorLayer) for layer in iface.mapCanvas().layers(): try: layer.setSubsetString( "st_intersects(geom,st_geomfromewkt('SRID={0};{1}'))".format(epsgid, geometryWkt) ) except Exception: pass iface.mapCanvas().refresh() self.rubberBand.reset(core.QgsWkbTypes.PolygonGeometry)
def loadPostgresLayer(self, dbName, dbHost, dbPort, dbUser, dbPassword, dbSchema, dbTable, groupParent=None, isGeom=True ): lyr = core.QgsVectorLayer( self.getUri( dbName, dbHost, dbPort, dbUser, dbPassword, dbSchema, dbTable, isGeom ), dbTable, u"postgres" ) if groupParent is None: return core.QgsProject.instance().addMapLayer(lyr) layer = core.QgsProject.instance().addMapLayer(lyr, False) groupParent.addLayer(layer) return layer
def get_map_layer(layer_cfg, project_crs): # Give the absolute path to the layer. We think project.addMapLayer() # automatically generates the correct relative paths. Using a relative # path causes statistics (nodata value, min/max) to not be generated, # resulting in rendering a gray rectangle. # TODO: do we need to worry about differences in path structure between linux # and windows? layer_path = get_layer_fs_path(layer_cfg) if not os.path.isfile(layer_path): raise RuntimeError(f"Layer located at '{layer_path}' does not exist.") # https://qgis.org/pyqgis/master/core/QgsVectorLayer.html if layer_cfg['data_type'] == 'vector': map_layer = qgc.QgsVectorLayer( layer_path, layer_cfg['title'], # layer name as it shows up in QGIS TOC 'ogr' # name of the data provider (e.g. memory, postgresql) ) elif layer_cfg['data_type'] == 'raster': map_layer = create_raster_map_layer(layer_path, layer_cfg) _add_layer_metadata(map_layer, layer_cfg) if style := layer_cfg.get('style'): load_qml_style(map_layer, style)
def create_shp(self, shpfile_path, crsID=None): fileInfo = QFileInfo(shpfile_path) baseName = fileInfo.baseName() try: layer = qgc.QgsVectorLayer(shpfile_path, baseName, "none") except: layer = qgc.QgsVectorLayer(shpfile_path, baseName, "none") sourceCrs = layer.crs() destCrs = None if crsID == None: destCrs = qgc.QgsCoordinateReferenceSystem(4326) else: destCrs = qgc.QgsCoordinateReferenceSystem(crsID) return layer
def createLayer(): atts = [ "id:string(25)", "acquired:string(35)", "thumbnail:string(2000)", "meta_html:string(2000)", "meta_json:string(2000)", "meta_jsize:integer" ] l_fields = map(lambda item: "field=%s" % item, atts) l_fields.insert(0, "Multipolygon?crs=epsg:4326") l_fields.append("index=yes") uri = '&'.join(l_fields) date1 = self.settings['date1'].toString(QtCore.Qt.ISODate) date2 = self.settings['date2'].toString(QtCore.Qt.ISODate) arg = (self.settings['current_asset'].title(), date1, date2) name = "PL {}({} to {})".format(*arg) vl = QgsCore.QgsVectorLayer(uri, name, "memory") # Add layer self.layer = QgsCore.QgsMapLayerRegistry.instance().addMapLayer( vl, addToLegend=False) self.layerTree = QgsCore.QgsProject.instance().layerTreeRoot( ).insertLayer(0, self.layer) # Symbology ns = os.path.join(os.path.dirname(__file__), CatalogPL.styleFile) self.layer.loadNamedStyle(ns) QgsUtils.iface.legendInterface().refreshLayerSymbology(self.layer) self.layerTree.setVisible(QtCore.Qt.Unchecked)
def selectfile(self): """select the import shape or dxf file""" dxfInfo = None importFile = PQtW.QFileDialog.getOpenFileName( None, "Selecteer bestand:", None, "AutoCad (*.dxf);;Shape (*.shp);;GeoPackage (*.gpkg)")[0] self.bestandsnaam.setText(importFile) if importFile: if importFile.endswith('.dxf'): self.layerImportType, ok = DxfDialogObject.getGeometryType() dxfInfo = "|layername=entities|geometrytype=" + self.layerImportType importFileFeat = importFile + dxfInfo if not self.layerImportType or not ok: return self.importLayer = QC.QgsVectorLayer(importFileFeat, "import", "ogr") elif importFile.endswith('.gpkg'): layerNames = [l.GetName() for l in OG.ogr.Open(importFile)] GpkgDialog.layerNames = layerNames layerName, dummy = GpkgDialog.getLayerName() gpkgInfo = "|layername={}".format(layerName) importFileFeat = importFile + gpkgInfo self.importLayer = QC.QgsVectorLayer(importFileFeat, "import", "ogr") else: importFileFeat = importFile self.importLayer = QC.QgsVectorLayer(importFileFeat, "import", "ogr") if self.importLayer.geometryType() < 3: self.layerImportType = self.layerTypes[ self.importLayer.geometryType()] else: return else: return crs = self.importLayer.crs() crs.createFromId(28992) self.importLayer.setCrs(crs) QC.QgsProject.instance().addMapLayer(self.importLayer, True) fields = self.importLayer.fields() for field in fields: self.type.addItem(field.name()) self.label3.setVisible(True) self.type.setVisible(True) self.label6.setVisible(True) self.mapping.setVisible(True)
def trigger_with_vector(): vector_path = '/tmp/populated_places.gpkg' result = qgc.QgsVectorLayer( vector_path, 'vectorlayer', 'ogr', ) return result
def load(self, data): layer = core.QgsVectorLayer(data['query'], data['nome'], "virtual") doc = QDomDocument() doc.setContent(data['qml']) layer.importNamedStyle(doc) layer.triggerRepaint() layer.setCrs(core.QgsCoordinateReferenceSystem(int(data['epsg']))) self.addMapLayer(layer, 0)
def selectfile(self): """select the import shap or dxf file""" dxfInfo = None importFile = PQtW.QFileDialog.getOpenFileName( None, "Selecteer bestand:", None, "AutoCad (*.dxf);;Shape (*.shp);;GeoPackage (*.gpkg)")[0] self.bestandsnaam.setText(importFile) checkBouwlaag = False if importFile.endswith('.dxf'): checkBouwlaag, layerImportType, importBouwlaag, dummy = DxfDialog.getGeometryType( ) if layerImportType == 'lijn': layerType = 'LineString' else: layerType = 'Polygon' dxfInfo = "|layername=entities|geometrytype=" + layerType importFileFeat = importFile + dxfInfo self.importTypeFile = 'DXF' if checkBouwlaag: importFilePolygon = importFile + "|layername=entities|geometrytype=Polygon" self.importPolygonLayer = QC.QgsVectorLayer( importFilePolygon, "import", "ogr") it = self.importPolygonLayer.getFeatures() bouwlaagFeature = next(it) self.bouwlaag.setText(str(importBouwlaag)) self.import_bouwlaag(bouwlaagFeature) elif importFile.endswith('.gpkg'): layerNames = [lyr.GetName() for lyr in ogr.Open(importFile)] GpkgDialog.layerNames = layerNames layerName, dummy = GpkgDialog.getLayerName() gpkgInfo = "|layername={}".format(layerName) importFileFeat = importFile + gpkgInfo self.importTypeFile = 'GPKG' else: importFileFeat = importFile self.importTypeFile = 'SHP' self.importLayer = QC.QgsVectorLayer(importFileFeat, "import", "ogr") QC.QgsProject.instance().addMapLayer(self.importLayer, True) fields = self.importLayer.fields() for field in fields: self.type.addItem(field.name()) if not checkBouwlaag: self.label2.setVisible(True) self.selectId.setVisible(True)
def createLayerPolygon(): atts = [ "id_add:integer", "image:string(200)", "datetime:string(20)", "crs:string(100)" ] l_fields = map( lambda item: "field=%s" % item, atts ) l_fields.insert( 0, "crs=epsg:4326" ) l_fields.append( "index=yes" ) s_fields = '&'.join( l_fields ) self.layerPolygon = QgsCore.QgsVectorLayer( "Polygon?%s" % s_fields, "gimp_selection_polygon", "memory") QgsCore.QgsMapLayerRegistry.instance().addMapLayer( self.layerPolygon ) self.layerPolygon.loadNamedStyle( os.path.join( os.path.dirname( __file__ ), "gimpselectionfeature.qml" ) ) self.iface.legendInterface().refreshLayerSymbology( self.layerPolygon )
def pointBuffer(self,p): infoLayer = self.infoBoxManager.getInfolayer() toInfoLayerProjection = core.QgsCoordinateTransform(self.iface.mapCanvas().mapSettings().destinationCrs(),infoLayer.crs(), core.QgsProject.instance()) toWGS84 = core.QgsCoordinateTransform(infoLayer.crs(),core.QgsCoordinateReferenceSystem(4326), core.QgsProject.instance()) # create layer and replicate fields bufferLayer = core.QgsVectorLayer("Point?crs="+infoLayer.crs().toWkt(), "temporary_points", "memory") #bufferLayer.setCrs(infoLayer.crs()) #This generates alert message bufferLayer.startEditing() bufferLayer.addAttribute(core.QgsField("id",QtCore.QVariant.String)) bufferLayer.addAttribute(core.QgsField("html",QtCore.QVariant.String)) bufferLayer.addAttribute(core.QgsField("icon",QtCore.QVariant.String)) bufferLayer.addAttribute(core.QgsField("fid",QtCore.QVariant.Int)) self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(p))) fetched = 0 self.featsId = self.infoBoxManager.getContextFeatures(toInfoLayerProjection.transform(p)) for featId in self.featsId: feat = infoLayer.getFeatures(core.QgsFeatureRequest(featId)).__next__() if fetched < 200: if infoLayer.geometryType() == core.QgsWkbTypes.PolygonGeometry: fGeom = feat.geometry().pointOnSurface() elif infoLayer.geometryType() == core.QgsWkbTypes.PointGeometry: fGeom = feat.geometry() if fGeom.isMultipart(): multipoint = fGeom.asMultiPoint() point = multipoint[0] else: point = fGeom.asPoint() fetched += 1 newGeom = core.QgsGeometry.fromPointXY(core.QgsPointXY(point)) newFeat = core.QgsFeature() newFeat.setGeometry(newGeom) newFeat.setAttributes([self.infoBoxManager.getInfoField(feat),self.infoBoxManager.getHtml(feat),self.infoBoxManager.getIconPath(feat),self.infoBoxManager.getFeatId(feat)]) bufferLayer.addFeature(newFeat) else: core.QgsMessageLog.logMessage("fetched too much features..... 200 max", tag="go2streetview", level=core.Qgis.Warning) break bufferLayer.commitChanges() core.QgsMessageLog.logMessage("markers context rebuilt", tag="go2streetview", level=core.Qgis.Info) #StreetView markers tmpfile = os.path.join(self.dirPath,"tmp","tmp_markers.geojson") core.QgsVectorFileWriter.writeAsVectorFormat (bufferLayer, tmpfile,"UTF8",toWGS84,"GeoJSON") with open(tmpfile) as f: geojson = f.read().replace('\n','') os.remove(tmpfile) #js = geojson.replace("'",'') #js = js.replace("\n",'\n') js = """this.markersJson = %s""" % json.dumps(geojson) self.view.SV.page().mainFrame().evaluateJavaScript(js) self.view.BE.page().mainFrame().evaluateJavaScript(js) js = """this.readJson() """ self.view.SV.page().mainFrame().evaluateJavaScript(js) self.view.BE.page().mainFrame().evaluateJavaScript(js) core.QgsMessageLog.logMessage("webview markers refreshed", tag="go2streetview", level=core.Qgis.Info)
def create_map(shp_file, csv_f): assert os.path.exists( shp_file ), "I could not locate the shape file. Was the path typed correctly?" s = open(shp_file, 'r+') print("Shape File Located") # Add Georgia Map to Canvas ga_map = qt.QgsVectorLayer(shp_file, "GA Map", "ogr") qt.QgsProject.instance().addMapLayer(ga_map) s.close() csv_uri = csv_f + "?encoding=UTF-8&delimiter=," assert os.path.exists( csv_uri ), "I could not locate the csv file. Was the path typed correctly?" c = open(csv_uri, 'r+') print("Csv File Located") csv_layer = qt.QgsVectorLayer(csv_uri, "2018_SH119", "delimitedtext") qt.QgsProject.instance().addMapLayer(csv_layer) c.close() # Join the layers that are a part of the Map Canvas join_field = 'County' target_field = 'PRECINCT_N' join_object = qt.QgsVectorLayerJoinInfo() join_object.setJoinLayer(csv_layer) join_object.joinLayerId = csv_layer.id() join_object.setJoinFieldName(join_field) join_object.setTargetFieldName(target_field) join_object.setUsingMemoryCache(True) ga_map.addJoin(join_object) # Color Map map_canvas = qt.QgsProject.instance().mapLayersByName("GA Map")[0] map_canvas.renderer().symbol().setColor(QColor("white")) map_canvas.triggerRepaint() print("Map Has Been Initialized") return map_canvas
def createLayerPolygon(): atts = [ "name:string(100)", "filename:string(500)", "meta_html:string(1000)", "meta_json:string(500)", "meta_jsize:integer" ] l_fields = map( lambda item: "field=%s" % item, atts ) l_fields.insert( 0, "crs=epsg:4326" ) l_fields.append( "index=yes" ) s_fields = '&'.join( l_fields ) nameLayer = "catalog_footprint_%s" % str( datetime.datetime.now() ) self.layerCatalog = QgsCore.QgsVectorLayer( "MultiPolygon?%s" % s_fields, nameLayer, "memory") self.idLayerCatalog = self.layerCatalog.id() QgsCore.QgsMapLayerRegistry.instance().addMapLayer( self.layerCatalog ) self.layerCatalog.loadNamedStyle( os.path.join( os.path.dirname( __file__ ), self.styleFile ) ) QgsUtils.iface.legendInterface().refreshLayerSymbology( self.layerCatalog )
def load(self, fileData): unloadedFiles = [] for d in fileData: layer = core.QgsVectorLayer(d['caminho'], d['nome'], 'WFS') if not layer.isValid(): unloadedFiles.append(d) continue self.addMapLayer( layer ) if not unloadedFiles: return self.showErrorMessageBox( ''.join([ '<p>erro: falha ao carregar o seguinte wfs "{0}"</p>'.format(d['caminho']) for d in unloadedFiles ]) )
def _create_temp_vector_layer(active_layer, geom_type, temp_layer_name): """ Creates a temporary vector layer in memory :param active_layer: Current active layer :param geom_type: Current active layer geometry type :param temp_layer_name: Temporary layer name :return temp_mem_layer: Temporary vector layer in memory :return data_provider: Layer data provider :rtype temp_mem_layer: Layer object :rtype data_provider: Data provider object """ active_layer_crs = str(active_layer.crs().authid()) uri = '{0}?crs={1}&field=id:integer&index=yes'.format(geom_type, active_layer_crs) temp_mem_layer = q_core.QgsVectorLayer(uri, temp_layer_name, 'memory') data_provider = temp_mem_layer.dataProvider() temp_mem_layer.startEditing() return temp_mem_layer, data_provider,
def saveShapeFile(self): #The line below is commented to disable saving of static images in local directory to not violate point 10.1.3.b) of https://developers.google.com/maps/terms self.saveImg() #fov = str(int(90/max(1,float(self.pov['zoom'])))) zoom = float(self.pov['zoom']) fov = 3.9018 * pow(zoom, 2) - 42.432 * zoom + 123 urlimg = "http://maps.googleapis.com/maps/api/streetview?size=640x400&location=" + self.pov[ 'lat'] + "," + self.pov['lon'] + "&heading=" + self.pov[ 'heading'] + "&pitch=" + self.pov[ 'pitch'] + "&sensor=false" + "&fov=" + str( fov) + "&key=" + self.parent.APIkey self.cb.setText(urlimg) sfPath = os.path.join(self.sessionDirectory(), "Streetview_snapshots_log.shp") if not os.path.isfile(sfPath): self.createShapefile(sfPath) vlayer = core.QgsVectorLayer(sfPath, "Streetview_snapshots_log", "ogr") testIfLayPresent = None for lay in self.canvas.layers(): if lay.name() == "Streetview_snapshots_log": testIfLayPresent = True if not testIfLayPresent: vlayer.loadNamedStyle(os.path.join(self.path, "snapshotStyle.qml")) #self.iface.actionFeatureAction().trigger() core.QgsProject.instance().addMapLayer(vlayer) set = QtCore.QSettings() set.setValue("/qgis/showTips", True) feat = core.QgsFeature() feat.initAttributes(8) feat.setAttribute( 0, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")) feat.setAttribute(1, self.pov['lon']) feat.setAttribute(2, self.pov['lat']) feat.setAttribute(3, self.pov['heading']) feat.setAttribute(4, self.pov['pitch']) feat.setAttribute(5, self.pov['address']) #self.getAddress()) feat.setAttribute(6, self.snapshotNotes) #feat.setAttribute(7,self.file_name) feat.setAttribute(7, QtCore.QUrl(urlimg).toString()) feat.setGeometry( core.QgsGeometry.fromPointXY( core.QgsPointXY(float(self.pov['lon']), float(self.pov['lat'])))) vlayer.dataProvider().addFeatures([feat]) vlayer.triggerRepaint()
def createNewLayer(self, geometryType, comboBox, fields): fname = QtGui.QFileDialog.getSaveFileName( self, 'Open file', "", "Shapefile (*.shp);;All files (*)") fname = os.path.splitext(str(fname))[0] + '.shp' layername = os.path.splitext(os.path.basename(str(fname)))[0] if (layername == '.shp'): return self.createShapefile(fname, geometryType, fields) vlayer = qgis.QgsVectorLayer(fname, layername, "ogr") qgis.QgsMapLayerRegistry.instance().addMapLayer(vlayer) comboBox.addItem(layername) comboBox.setCurrentIndex(comboBox.count() - 1) self.populateTriangleComboBox() self.iface.actionToggleEditing().trigger() self.iface.actionAddFeature().trigger() self.iface.actionToggleEditing().triggered.connect( self.showDialogAndDisconnect) self.hide()
def load(self, fileData): dbAddress, dbName, dbSchema, layerName = fileData['caminho'].split('/') dbHost, dbPort = dbAddress.split(':') dbUser = fileData['usuario'] dbPassword = fileData['senha'] uri = self.getUri(dbName, dbSchema, layerName, dbHost, dbPort, dbUser, dbPassword, fileData['workUnitGeometry'], fileData['epsg']) layer = core.QgsProject.instance().addMapLayer( core.QgsVectorLayer(uri, layerName, "postgres"), False) layer.setReadOnly(True) database = self.databaseFactory.createPostgres(dbName, dbHost, dbPort, dbUser, dbPassword) mapValues = database.getAttributeValueMap(layerName, dbSchema) self.loadValueMap(layer, mapValues) self.addMapLayer(layer)
def loadView(self, layer, GeomField, KeyField): if self.loadedLayerRefresh(layer): return #test if layer has been already loaded autoGeom = self.guessGeometryField(layer, GeomField) autoKey = self.guessKeyField(layer, suggestion=KeyField) uri = core.QgsDataSourceUri() uri.setConnection(self.PSQLHost, self.PSQLPort, self.PSQLDatabase, self.PSQLUsername, self.PSQLPassword) uri.setDataSource(self.schema, layer, autoGeom, "", autoKey) vlayer = core.QgsVectorLayer(uri.uri(), layer, "postgres") if vlayer.isValid(): core.QgsProject.instance().addMapLayer(vlayer, True) #self.queryLogger(layerName,"VIEW LOAD") else: sqlerror = self.submitCommand(self.getViewDef(layer), log=None) if not sqlerror: sqlerror = "The query returns no features." QMessageBox.information( None, "LAYER ERROR:", "%s\n\nThe layer %s is not valid" % (sqlerror, layer))
def loadSql(self, layerName, sql, GeomField, KeyField): self.submitQuery("__tmp", 'CREATE VIEW "' + self.schema + '"."__tmp" AS ' + sql) autoGeom = self.guessGeometryField("__tmp", suggestion=GeomField) autoKey = self.guessKeyField("__tmp", suggestion=KeyField) self.deleteLayer("__tmp") uri = core.QgsDataSourceUri() uri.setConnection(self.PSQLHost, self.PSQLPort, self.PSQLDatabase, self.PSQLUsername, self.PSQLPassword) uri.setDataSource("", "(" + sql + ")", autoGeom, "", autoKey) vlayer = core.QgsVectorLayer(uri.uri(), layerName, "postgres") if vlayer.isValid(): core.QgsProject.instance().addMapLayer(vlayer, True) self.queryLogger(layerName, sql) else: sqlerror = self.submitCommand(sql, log=None) if not sqlerror: sqlerror = "The query returns no features." QMessageBox.information( None, "LAYER ERROR:", "%s\n\nThe layer %s is not valid" % (sqlerror, layerName))
def __init__(self, shapefile): QtGui.QMainWindow.__init__(self) self.setWindowTitle("Map Viewer") canvas = qgisGui.QgsMapCanvas() canvas.useImageToRender(False) canvas.setCanvasColor(QtCore.Qt.white) canvas.show() layer = qgisCore.QgsVectorLayer(shapefile, "layer1", "ogr") if not layer.isValid(): raise IOError("Invalid shapefile") qgisCore.QgsMapLayerRegistry.instance().addMapLayer(layer) canvas.setExtent(layer.extent()) canvas.setLayerSet([qgisGui.QgsMapCanvasLayer(layer)]) layout = QtGui.QVBoxLayout() layout.addWidget(canvas) contents = QtGui.QWidget() contents.setLayout(layout) self.setCentralWidget(contents)
graph = nx.from_pandas_edgelist(links, edge_attr=True, create_using=nx.DiGraph) # Perform pathfinding within the network path_nodes = nx.dijkstra_path(graph, source=SOURCE_NODE, target=TARGET_NODE, weight=lambda _u, _v, e: e['geometry'].length) # Create a LineString with the path found linestring = ops.linemerge(graph.edges[u,v]['geometry'] for u, v in zip(path_nodes, path_nodes[1:]) ) # Create a new QGIS LineString layer layer = qgs.QgsVectorLayer('LineString?crs=epsg:4326', f'Shortest Path from {SOURCE_NODE} to {TARGET_NODE}', 'memory') # Create QGIS geometry from path LineString geometry = qgs.QgsLineString() geometry.fromWkt(linestring.to_wkt()) # Create new QGIS feature to add onto layer, # from previous geometry feature = qgs.QgsFeature() feature.setGeometry(geometry) # Retrieve data provider of the layer and add feature prov = layer.dataProvider() prov.addFeature(feature)
#!/usr/bin/env python # -*- coding: utf-8 -*- from qgis import core core.QgsApplication.setPrefixPath("/usr", True) core.QgsApplication.initQgis() import os wd = os.path.dirname(__file__) vlayer = core.QgsVectorLayer(wd + "/../data/regioni.shp", "regioni", "ogr") vlayer.isValid() core.QgsMapLayerRegistry.instance().addMapLayer(vlayer) from PyQt4 import QtGui, QtCore img = QtGui.QImage(QtCore.QSize(800, 600), QtGui.QImage.Format_ARGB32_Premultiplied) p = QtGui.QPainter() p.begin(img) p.setRenderHint(QtGui.QPainter.Antialiasing) render = core.QgsMapRenderer() lst = [vlayer.getLayerID()] render.setLayerSet(lst) rect = core.QgsRectangle(render.fullExtent()) rect.scale(1.1) render.setExtent(rect) render.setOutputSize(img.size(), img.logicalDpiX()) img.size() p.isActive()
def init_layer_fields(self, fields, params): layer = QC.QgsVectorLayer(params[0], params[1], params[2]) pr = layer.dataProvider() pr.addAttributes(fields) layer.updateFields() return layer
def __init__(self, parent, boundingbox): super(ExtentDialog, self).__init__(parent) self.setupUi(self) self.superParent = None temp = self.parent() if platform.system() != "Linux": font = QFont() font.setFamily(u"Segoe UI Symbol") self.setFont(font) while self.superParent is None: if issubclass(type(temp), geographicinformationPanel.Ui_geographicinfo): self.superParent = temp else: temp = temp.parent() for info in self.findChildren(qwidgets.QPushButton, qcore.QRegExp('info_*')): info.setIcon(qgui.QIcon(':/resourcesFolder/icons/help_icon.svg')) info.setText('') info.pressed.connect(self.printHelp) self.layers = [] self.maxExt = None self.boundingbox = boundingbox self.outBB = False # Create MapCanvas self.canvas = gui.QgsMapCanvas(self) # Append to Dialog Layout self.toolBar = qwidgets.QToolBar() self.layout = qwidgets.QVBoxLayout(self.frame) self.layout.addWidget(self.toolBar) self.layout.addWidget(self.canvas) # Trigger on scaleChanged self.canvas.scaleChanged.connect(self.scaleChanged) # Trigger on renderStarting self.canvas.renderStarting.connect(self.renderStarting) # Create Map Tools actionFullExt = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/globe.svg'), "Mapa total", self) actionPan = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/pan.svg'), "Mover", self) actionZoomIn = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/zoom_in.svg'), "Aproximar", self) actionZoomOut = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/zoom_out.svg'), "Afastar", self) actionSelect = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/selection.svg'), 'Desenhar', self) actionFromLayer = qwidgets.QAction( qgui.QIcon(':/resourcesFolder/icons/layers.svg'), 'Obter de camada', self) actionFullExt.setCheckable(False) actionPan.setCheckable(True) actionZoomIn.setCheckable(True) actionZoomOut.setCheckable(True) actionSelect.setCheckable(True) actionFullExt.triggered.connect(self.fullext) actionPan.triggered.connect(self.pan) actionZoomIn.triggered.connect(self.zoomIn) actionZoomOut.triggered.connect(self.zoomOut) actionSelect.triggered.connect(self.select) actionFromLayer.triggered.connect(self.chooseLayer) # Add to created ToolBar self.toolBar.addAction(actionFullExt) self.toolBar.addSeparator() self.toolBar.addAction(actionPan) self.toolBar.addAction(actionZoomIn) self.toolBar.addAction(actionZoomOut) self.toolBar.addAction(actionSelect) self.toolBar.addAction(actionFromLayer) self.toolFullExtent = gui.QgsMapToolPan(self.canvas) self.toolFullExtent.setAction(actionFullExt) self.toolPan = gui.QgsMapToolPan(self.canvas) self.toolPan.setAction(actionPan) self.toolZoomIn = gui.QgsMapToolZoom(self.canvas, False) # false = in self.toolZoomIn.setAction(actionZoomIn) self.toolZoomOut = gui.QgsMapToolZoom(self.canvas, True) # true = out self.toolZoomOut.setAction(actionZoomOut) self.toolSelect = SelectionTool(self.canvas, self) self.resourcebox.setChecked(True) self.pan() lugin_path = utils.pluginDirectory('EditorMetadadosMarswInforbiomares') # Load Vector layerpath = os.path.join(plugin_path, "resourcesFolder/World.shp") llayer = core.QgsVectorLayer(layerpath, "WorldLayer", "ogr") # Set Layer Symbology props = { 'color_border': '0,0,0,125', 'style': 'no', 'style_border': 'solid' } #s = core.QgsFillSymbolV2.createSimple(props) s = core.QgsFillSymbol.createSimple(props) #llayer.setRendererV2(core.QgsSingleSymbolRendererV2(s)) llayer.setRenderer(core.QgsSingleSymbolRenderer(s)) # Set CRS - necessary to load Raster - it assumes this default CRS s = qcore.QSettings() oldValidation = str( s.value("/Projections/defaultBehaviour", "useGlobal")) s.setValue("/Projections/defaultBehaviour", "useGlobal") # Load Raster fileName = os.path.join(plugin_path, "resourcesFolder/GMRT.tif") fileInfo = qcore.QFileInfo(fileName) baseName = fileInfo.baseName() layer = core.QgsRasterLayer(fileName, baseName) layer.setCrs( core.QgsCoordinateReferenceSystem( 4326, core.QgsCoordinateReferenceSystem.EpsgCrsId)) s.setValue("/Projections/defaultBehaviour", oldValidation) # Set Raster ColorRamp # layer.setDrawingStyle("SingleBandPseudoColor") # deprecated remove in 2.1.0 please vmin = -5683.08 vmax = 2763.86 vrange = vmax - vmin vadd = vrange // 2 vint = vmin + vadd colDic = { 'brown': '#90330a', 'lightblue': '#d5f5f9', 'blue': '#2099d4' } valueList = [vmin, vint, vmax] lst = [core.QgsColorRampShader.ColorRampItem(valueList[0], qgui.QColor(colDic['blue'])), \ core.QgsColorRampShader.ColorRampItem(valueList[1], qgui.QColor(colDic['lightblue'])), \ core.QgsColorRampShader.ColorRampItem(valueList[2], qgui.QColor(colDic['brown']))] myRasterShader = core.QgsRasterShader() myColorRamp = core.QgsColorRampShader() myColorRamp.setColorRampItemList(lst) myColorRamp.setColorRampType(core.QgsColorRampShader.Interpolated) myRasterShader.setRasterShaderFunction(myColorRamp) myPseudoRenderer = core.QgsSingleBandPseudoColorRenderer( layer.dataProvider(), layer.type(), myRasterShader) layer.setRenderer(myPseudoRenderer) ## Add vector to map #core.QgsMapLayerRegistry.instance().addMapLayer(llayer, False) core.QgsProject.instance().addMapLayer(llayer, False) ## Add raster to map #core.QgsMapLayerRegistry.instance().addMapLayer(layer, False) core.QgsProject.instance().addMapLayer(layer, False) ## Save Max Extent self.maxExt = core.QgsRectangle(-180., -90., 180., 90.) # ---------------------------------- ## Set initial general extent to ZEE or, if one is selected, from the selected boundingbox if self.boundingbox.selectionModel().hasSelection() == False: ## Change button's title self.add_extent.setText(u"Adicionar") initialrect = core.QgsRectangle(-46.63064, 22.52146, 9.64473, 47.31826) else: ## Get selected bounding box coords and resource flag index = self.boundingbox.selectionModel().selectedRows()[0].row() row = self.boundingbox.model().matrix[index] minx = float(row[0].replace(',', '.')) miny = float(row[3].replace(',', '.')) maxx = float(row[1].replace(',', '.')) maxy = float(row[2].replace(',', '.')) if minx == 0. and miny == 0. and maxx == 0. and maxy == 0.: initialrect = core.QgsRectangle(-46.63064, 22.52146, 9.64473, 47.31826) else: ## Set fields with these values self.xMin.setValue(minx) self.xMax.setValue(maxx) self.yMin.setValue(miny) self.yMax.setValue(maxy) self.resourcebox.setChecked(bool(row[4])) ## Set the extent and add a bit of zoom out of the selected extent initialrect = core.QgsRectangle(minx - minx * 0.1, miny - miny * 0.1, maxx + maxx * 0.1, maxy + maxy * 0.1) ## Draw initial extent on the map self.toolSelect.drawRect(minx, miny, maxx, maxy) ## Change button's title self.add_extent.setText(u"Alterar") self.canvas.setExtent(initialrect) # ---------------------------------- ## Append layers to MapCanvas self.layers.append(llayer) self.layers.append(layer) #self.layers.append(gui.QgsMapCanvasLayer(llayer)) #self.layers.append(gui.QgsMapCanvasLayer(layer)) #self.canvas.setLayerSet(self.layers) self.canvas.setLayers([llayer, layer]) ## Set triggers to buttons self.add_extent.clicked.connect(self.add_new_extent) self.btn_close.clicked.connect(lambda: self.done(QDialog.Rejected)) self.finished.connect(self.cleanup) ## Disabled coord fields self.xMin.setEnabled(False) self.xMax.setEnabled(False) self.yMin.setEnabled(False) self.yMax.setEnabled(False)
} xmin, ymin, xmax, ymax = lyrInput.extent().toRectF().getCoords() gridWidth = Tamanho_da_celula_da_grade gridHeight = Tamanho_da_celula_da_grade rows = ceil((ymax - ymin) / gridHeight) cols = ceil((xmax - xmin) / gridWidth) ringXleftOrigin = xmin ringXrightOrigin = xmin + gridWidth ringYtopOrigin = ymax ringYbottomOrigin = ymax - gridHeight fields = [QgsCore.QgsField("id", QtCore.QVariant.Int)] lyrOutput = VectorWriter(Areas_de_Inspecao, None, fields, QgsCore.QGis.WKBPolygon, lyrInput.crs()) lyrIntermediate = QgsCore.QgsVectorLayer("Polygon", "temporary_polygons", "memory") lyrIntermediate.setCrs(lyrInput.crs()) id = 1 progress.setInfo("Gerando grade de cobertura da camada...") progress.setInfo("Numero de linhas: " + str(rows)) progress.setInfo("Numero de colunas: " + str(cols)) for i in range(int(cols)): ringYtop = ringYtopOrigin ringYbottom = ringYbottomOrigin for j in range(int(rows)): points = [ QgsCore.QgsPoint(ringXleftOrigin, ringYtop), QgsCore.QgsPoint(ringXrightOrigin, ringYtop), QgsCore.QgsPoint(ringXrightOrigin, ringYbottom),
def lineBuffer(self,p,polygons = None): dBuffer = self.infoBoxManager.getDistanceBuffer() infoLayer = self.infoBoxManager.getInfolayer() toInfoLayerProjection = core.QgsCoordinateTransform(self.iface.mapCanvas().mapSettings().destinationCrs(),infoLayer.crs(), core.QgsProject.instance()) toWGS84 = core.QgsCoordinateTransform(infoLayer.crs(),core.QgsCoordinateReferenceSystem(4326), core.QgsProject.instance()) # create layer and replicate fields bufferLayer = core.QgsVectorLayer("LineString?crs="+infoLayer.crs().toWkt(), "temporary_lines", "memory") #bufferLayer.setCrs(infoLayer.crs()) #This generates alert message bufferLayer.startEditing() bufferLayer.addAttribute(core.QgsField("id",QtCore.QVariant.String)) bufferLayer.addAttribute(core.QgsField("html",QtCore.QVariant.String)) bufferLayer.addAttribute(core.QgsField("icon",QtCore.QVariant.String)) bufferLayer.addAttribute(core.QgsField("fid",QtCore.QVariant.Int)) fetched = 0 cutBuffer = core.QgsGeometry.fromPointXY(toInfoLayerProjection.transform(core.QgsPointXY(p))).buffer(dBuffer*2,10) self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(p))) if not polygons: self.featsId = self.infoBoxManager.getContextFeatures(toInfoLayerProjection.transform(p)) for featId in self.featsId: feat = infoLayer.getFeatures(core.QgsFeatureRequest(featId)).__next__() if fetched < 1500: if infoLayer.geometryType() == core.QgsWkbTypes.PolygonGeometry: fGeom = feat.geometry().convertToType(core.QgsWkbTypes.LineGeometry) elif infoLayer.geometryType() == core.QgsWkbTypes.LineGeometry: fGeom = feat.geometry() if fGeom: #break on closest point on segment to pov to improve visibility closestResult = fGeom.closestSegmentWithContext(toInfoLayerProjection.transform(p)); fGeom.insertVertex(closestResult[1][0],closestResult[1][1],closestResult[2]) cGeom = fGeom.intersection(cutBuffer) if cGeom.isMultipart(): multigeom = cGeom.asMultiPolyline() for geom in multigeom: newGeom = core.QgsGeometry.fromPolylineXY(geom) newFeat = core.QgsFeature() newFeat.setGeometry(newGeom) newFeat.setAttributes([self.infoBoxManager.getInfoField(feat),self.infoBoxManager.getHtml(feat),self.infoBoxManager.getIconPath(feat),self.infoBoxManager.getFeatId(feat)]) bufferLayer.addFeature(newFeat) else: geom = cGeom.asPolyline() newGeom = core.QgsGeometry.fromPolylineXY(geom) newFeat = core.QgsFeature() newFeat.setGeometry(newGeom) newFeat.setAttributes([self.infoBoxManager.getInfoField(feat),self.infoBoxManager.getHtml(feat),self.infoBoxManager.getIconPath(feat),self.infoBoxManager.getFeatId(feat)]) bufferLayer.addFeature(newFeat) fetched = fetched + len(newGeom.asPolyline()) else: core.QgsMessageLog.logMessage("Null geometry!", tag="go2streetview", level=core.Qgis.Warning) else: core.QgsMessageLog.logMessage("fetched too much features..... 200 max", tag="go2streetview", level=core.Qgis.Warning) break bufferLayer.commitChanges() core.QgsMessageLog.logMessage("line context rebuilt: %s features" % bufferLayer.featureCount(), tag="go2streetview", level=core.Qgis.Info) #StreetView lines tmpfile = os.path.join(self.dirPath, "tmp", "tmp_lines.geojson") core.QgsVectorFileWriter.writeAsVectorFormat(bufferLayer, tmpfile,"UTF8", toWGS84, "GeoJSON") with open(tmpfile) as f: geojson = f.read().replace('\n', '') os.remove(tmpfile) js = """this.linesJson = %s""" % json.dumps(geojson) self.view.SV.page().mainFrame().evaluateJavaScript(js) self.view.BE.page().mainFrame().evaluateJavaScript(js) js = """this.readLinesJson() """ self.view.SV.page().mainFrame().evaluateJavaScript(js) self.view.BE.page().mainFrame().evaluateJavaScript(js) core.QgsMessageLog.logMessage("webview lines refreshed", tag="go2streetview", level=core.Qgis.Info)
#!/usr/bin/env python # -*- coding: utf-8 -*- from PyQt4 import QtGui, QtCore import sys, os from qgis import core, gui core.QgsApplication.setPrefixPath('/usr', True) core.QgsApplication.initQgis() l = core.QgsVectorLayer(sys.argv[1], os.path.basename(sys.argv[1]), 'ogr') app = QtGui.QApplication(sys.argv) canvas = gui.QgsMapCanvas() canvas.resize(800, 600) core.QgsMapLayerRegistry.instance().addMapLayer(l) canvas.setExtent(l.extent()) cl = gui.QgsMapCanvasLayer(l) layers = [cl] canvas.setLayerSet(layers) canvas.show() retval = app.exec_() core.QgsApplication.exitQgis() sys.exit(retval)
def initGui(self): # Create actions that will start plugin configuration self.StreetviewAction = QtWidgets.QAction(QtGui.QIcon(os.path.join(os.path.dirname(__file__), 'res', 'icoStreetview.png')), \ "Click to open Google Street View", self.iface.mainWindow()) #self.StreetviewAction = QtWidgets.QAction(QtGui.QIcon(":/plugins/go2streetview/res/icoStreetview.png"), \ # "Click to open Google Street View", self.iface.mainWindow()) self.StreetviewAction.triggered.connect(self.StreetviewRun) # Add toolbar button and menu item self.iface.addToolBarIcon(self.StreetviewAction) self.iface.addPluginToWebMenu("&go2streetview", self.StreetviewAction) self.dirPath = os.path.dirname( os.path.abspath( __file__ ) ) self.actualPOV = {} self.view = go2streetviewDialog() self.dumView = dumWidget() self.dumView.enter.connect(self.clickOn) self.dumView.iconRif.setPixmap(QtGui.QPixmap(os.path.join(os.path.dirname(__file__), 'res', 'icoStreetview.png'))) #self.dumView.iconRif.setPixmap(QtGui.QPixmap(":/plugins/go2streetview/res/icoStreetview.png")) self.apdockwidget=QtWidgets.QDockWidget("go2streetview" , self.iface.mainWindow() ) self.apdockwidget.setObjectName("go2streetview") self.apdockwidget.setWidget(self.dumView) self.iface.addDockWidget( QtCore.Qt.LeftDockWidgetArea, self.apdockwidget) self.apdockwidget.update() self.viewHeight=self.apdockwidget.size().height() self.viewWidth=self.apdockwidget.size().width() self.snapshotOutput = snapShot(self) self.view.SV.settings().globalSettings().setAttribute(QtWebKit.QWebSettings.DeveloperExtrasEnabled, True); self.view.SV.settings().globalSettings().setAttribute(QtWebKit.QWebSettings.LocalContentCanAccessRemoteUrls, True); self.view.SV.page().networkAccessManager().finished.connect(self.noSVConnectionsPending) self.view.SV.page().statusBarMessage.connect(self.catchJSevents) self.view.BE.page().statusBarMessage.connect(self.catchJSevents) self.view.btnSwitchView.setIcon(QtGui.QIcon(os.path.join(self.dirPath,"res","icoGMaps.png"))) self.view.enter.connect(self.clickOn) self.view.closed.connect(self.closeDialog) self.setButtonBarSignals() self.infoBoxManager = infobox(self) self.infoBoxManager.defined.connect(self.infoLayerDefinedAction) self.apdockwidget.visibilityChanged.connect(self.apdockChangeVisibility) self.iface.projectRead.connect(self.projectReadAction) self.pressed=None self.CTRLPressed=None self.controlShape = gui.QgsRubberBand(self.iface.mapCanvas(),core.QgsWkbTypes.LineGeometry ) self.controlShape.setWidth( 1 ) self.position=gui.QgsRubberBand(self.iface.mapCanvas(),core.QgsWkbTypes.PointGeometry ) self.position.setWidth( 5 ) self.position.setIcon(gui.QgsRubberBand.ICON_CIRCLE) self.position.setIconSize(6) self.position.setColor(QtCore.Qt.red) self.aperture=gui.QgsRubberBand(self.iface.mapCanvas(),core.QgsWkbTypes.LineGeometry ) self.rotateTool = transformGeometry() self.canvas.rotationChanged.connect(self.mapRotationChanged) self.canvas.scaleChanged.connect(self.setPosition) self.dumLayer = core.QgsVectorLayer("Point?crs=EPSG:4326", "temporary_points", "memory") self.actualPOV = {"lat":0.0,"lon":0.0,"heading":0.0,"zoom":1} self.pointWgs84 = None self.mkDirs() self.licenceDlg = snapshotLicenseDialog() self.httpConnecting = None self.S = QtCore.QSettings() terms = self.S.value("go2sv/license", defaultValue = "undef") self.APIkey = self.S.value("go2sv/APIkey", defaultValue = "") self.licenceDlg.APIkey.setText(self.APIkey) if terms == self.version: self.licenseAgree = True self.licenceDlg.checkGoogle.setCheckState(QtCore.Qt.Checked) self.licenceDlg.checkGoogle.setEnabled(False) else: self.licenseAgree = None self.licenceDlg.OKbutton.clicked.connect(self.checkLicenseAction) self.licenceDlg.textBrowser.anchorClicked.connect(self.openExternalUrl) # Register plugin layer type #self.tileLayerType = TileLayerType(self) #QgsPluginLayerRegistry.instance().addPluginLayerType(self.tileLayerType) self.view.SV.page().setNetworkAccessManager(core.QgsNetworkAccessManager.instance()) self.view.BE.page().setNetworkAccessManager(core.QgsNetworkAccessManager.instance()) #setting a webinspector dialog self.webInspectorDialog = QtWidgets.QDialog() self.webInspector = QtWebKitWidgets.QWebInspector(self.webInspectorDialog) self.webInspector.setPage(self.view.BE.page()) self.webInspectorDialog.setLayout(QtWidgets.QVBoxLayout()) self.webInspectorDialog.setWindowTitle("Web Inspector") self.webInspectorDialog.resize(960, 480) self.webInspectorDialog.layout().addWidget(self.webInspector) self.webInspectorDialog.setModal(False) self.webInspectorDialog.hide() core.QgsExpression.registerFunction(get_streetview_url) core.QgsExpression.registerFunction(get_streetview_pov)