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)
