def canvasMoveEvent(self, event):
#Método para receber os eventos canvas move do Qgis
#Parâmetro de entrada: event (Evento que chamou o método)
if self.getRubberBand():
endPoint = self.toMapCoordinates(event.pos())
snapRubberBand = self.getSnapRubberBand()
if not (self.getStopedState()):
if snapRubberBand:
snapRubberBand.hide()
snapRubberBand.reset(
geometryType=core.QgsWkbTypes.PointGeometry)
self.setSnapRubberBand(None)
oldPoint = core.QgsPointXY(event.mapPoint())
event.snapPoint()
point = core.QgsPointXY(event.mapPoint())
if oldPoint != point:
self.createSnapCursor(point)
if self.getRubberBand():
if self.contadorVert == 0:
self.getRubberBand().addPoint(point)
self.contadorVert += 1
else:
self.getRubberBand().addPoint(oldPoint)
if self.getRubberBandToStopState():
self.updateRubberBandToStopState(self.toMapCoordinates(
event.pos()))
def catchJSevents(self,status):
try:
tmpPOV = json.JSONDecoder().decode(status)
except:
tmpPOV = None
if tmpPOV:
if tmpPOV["transport"] == "drag":
self.refreshWidget(tmpPOV['lon'], tmpPOV['lat'])
elif tmpPOV["transport"] == "view":
self.httpConnecting = True
if self.actualPOV["lat"] != tmpPOV["lat"] or self.actualPOV["lon"] != tmpPOV["lon"]:
self.actualPOV = tmpPOV
actualPoint = core.QgsPointXY(float(self.actualPOV['lon']),float(self.actualPOV['lat']))
if self.infoBoxManager.isEnabled():
#self.view.SV.settings().clearMemoryCaches()
#self.view.BE.settings().clearMemoryCaches()
self.writeInfoBuffer(self.transformToCurrentSRS(actualPoint))
else:
self.actualPOV = tmpPOV
self.setPosition()
elif tmpPOV["transport"] == "mapCommand":
feat = self.infoBoxManager.getInfolayer().getFeatures(core.QgsFeatureRequest(tmpPOV["fid"])).__next__()
if tmpPOV["type"] == "edit":
self.iface.openFeatureForm(self.infoBoxManager.getInfolayer(),feat,True)
if tmpPOV["type"] == "select":
self.infoBoxManager.getInfolayer().select(feat.id())
elif tmpPOV["transport"] == "SVLocation":
if tmpPOV["status"] == 'OK':
self.SVLocationResponse = core.QgsPointXY(tmpPOV["lon"],tmpPOV["lat"])
else:
self.SVLocationResponse = "cucu" #core.QgsPointXY()
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 setPosition(self,forcePosition = None):
#if self.apdockwidget.widget().__dict__ == self.dumView.__dict__ or not self.apdockwidget.isVisible():
if not self.apdockwidget.isVisible():
return
try:
actualWGS84 = core.QgsPointXY (float(self.actualPOV['lon']),float(self.actualPOV['lat']))
except:
return
actualSRS = self.transformToCurrentSRS(actualWGS84)
if self.checkFollow.isChecked():
if float(self.actualPOV['heading'])>180:
rotAngle = 360-float(self.actualPOV['heading'])
else:
rotAngle = -float(self.actualPOV['heading'])
self.canvas.setRotation(rotAngle)
self.canvas.setCenter(actualSRS)
self.canvas.refresh()
self.position.reset()
self.position=gui.QgsRubberBand(self.iface.mapCanvas(),core.QgsWkbTypes.PointGeometry )
self.position.setWidth( 4 )
self.position.setIcon(gui.QgsRubberBand.ICON_CIRCLE)
self.position.setIconSize(4)
self.position.setColor(QtCore.Qt.blue)
self.position.addPoint(actualSRS)
CS = self.canvas.mapUnitsPerPixel()*25
zoom = float(self.actualPOV['zoom'])
fov = (3.9018*pow(zoom,2) - 42.432*zoom + 123)/100;
A1x = actualSRS.x()-CS*math.cos(math.pi/2-fov)
A2x = actualSRS.x()+CS*math.cos(math.pi/2-fov)
A1y = actualSRS.y()+CS*math.sin(math.pi/2-fov)
A2y = A1y
self.aperture.reset()
self.aperture=gui.QgsRubberBand(self.iface.mapCanvas(),core.QgsWkbTypes.LineGeometry )
self.aperture.setWidth( 3 )
self.aperture.setColor(QtCore.Qt.blue)
self.aperture.addPoint(core.QgsPointXY(A1x,A1y))
self.aperture.addPoint(actualSRS)
self.aperture.addPoint(core.QgsPointXY(A2x,A2y))
tmpGeom = self.aperture.asGeometry()
angle = float(self.actualPOV['heading'])*math.pi/-180
self.aperture.setToGeometry(self.rotateTool.rotate(tmpGeom,actualSRS,angle),self.dumLayer)
self.updateSVOptions()
self.gswBrowserUrl ="https://maps.google.com/maps?q=&layer=c&cbll="+str(self.actualPOV['lat'])+","+str(self.actualPOV['lon'])+"&cbp=12,"+str(self.actualPOV['heading'])+",0,0,0&z=18"
#Sync Google map
js = "this.map.setCenter(new google.maps.LatLng(%s, %s));" % (str(self.actualPOV['lat']),str(self.actualPOV['lon']))
self.view.BE.page().mainFrame().evaluateJavaScript(js)
js = "this.SVpov.setPosition(new google.maps.LatLng(%s, %s));" % (str(self.actualPOV['lat']),str(self.actualPOV['lon']))
self.view.BE.page().mainFrame().evaluateJavaScript(js)
def canvasMoveEvent(self, event):
if self.snapCursorRubberBand:
self.snapCursorRubberBand.hide()
self.snapCursorRubberBand.reset(
geometryType=core.QgsWkbTypes.PointGeometry)
self.snapCursorRubberBand = None
oldPoint = core.QgsPointXY(event.mapPoint())
event.snapPoint()
point = core.QgsPointXY(event.mapPoint())
if oldPoint != point:
self.createSnapCursor(point)
if self.startPoint:
self.endPoint = core.QgsPointXY(event.mapPoint())
self.showCircle(self.startPoint, self.endPoint)
def drawRect(self, minx, miny, maxx, maxy):
self.tmp_band.reset() #(core.QGis.Polygon)
point1 = core.QgsPointXY(minx, miny)
point2 = core.QgsPointXY(minx, maxy)
point3 = core.QgsPointXY(maxx, maxy)
point4 = core.QgsPointXY(maxx, miny)
self.tmp_band.addPoint(point1, False)
self.tmp_band.addPoint(point2, False)
self.tmp_band.addPoint(point3, False)
self.tmp_band.addPoint(point4, False) # true to update canvas
self.tmp_band.addPoint(point1, True)
self.tmp_band.show()
def place_rubberband(self, xmin, xmax, ymin, ymax):
"""place rubberband on the canvas"""
try:
self.rubberBand.reset()
self.canvas.scene().removeItem(self.rubberBand)
except: #pylint: disable=bare-except
pass
self.rubberBand = RH.init_rubberband('grid', self.canvas, 'polygon')
tempRect = QC.QgsRectangle(QC.QgsPointXY(xmin, ymin),
QC.QgsPointXY(xmax, ymax))
tempGeom = QC.QgsGeometry.fromRect(tempRect)
crs = QC.QgsCoordinateReferenceSystem(GH.PROJECTCRS)
self.rubberBand.reset()
self.rubberBand.setToGeometry(tempGeom, crs)
self.rubberBand.show()
def calculate_geometry(self, dist, xmin, ymin, x, y, gridType):
"""calculate grid polygons"""
points = []
if (x + 1) * dist > self.xWidth and gridType == 'Kaartblad':
xmax = xmin + x * dist + (self.xWidth - x * dist)
else:
xmax = xmin + (x + 1) * dist
if (y + 1) * dist > self.yWidth and gridType == 'Kaartblad':
ymax = ymin + y * dist + (self.yWidth - y * dist)
else:
ymax = ymin + (y + 1) * dist
points.append(QC.QgsPointXY(xmin + x * dist, ymin + y * dist))
points.append(QC.QgsPointXY(xmax, ymin + y * dist))
points.append(QC.QgsPointXY(xmax, ymax))
points.append(QC.QgsPointXY(xmin + x * dist, ymax))
return QC.QgsGeometry.fromMultiPolygonXY([[points]])
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
geomRubber = self.rubberBand.asGeometry()
node_layers = core.QgsProject.instance().layerTreeRoot().findLayers()
if not self.checkValidity(geomRubber):
iface.mapCanvas().refresh()
self.rubberBand.reset(core.QgsWkbTypes.PolygonGeometry)
return
layers = [x.layer() for x in node_layers if x.isVisible()]
for layer in layers:
new_geom = []
layer.startEditing()
features = layer.getFeatures()
for feat in features:
geom = feat.geometry()
if not geom.intersects(geomRubber):
continue
layer.deleteFeature(feat.id())
iface.mapCanvas().refresh()
self.rubberBand.reset(core.QgsWkbTypes.PolygonGeometry)
def showRect(self, start, end):
self.tmp_band.reset() #core.QGis.Polygon)
if start.x() == end.x() or start.y() == end.y():
return
point1 = core.QgsPointXY(start.x(), start.y())
point2 = core.QgsPointXY(start.x(), end.y())
point3 = core.QgsPointXY(end.x(), end.y())
point4 = core.QgsPointXY(end.x(), start.y())
self.tmp_band.addPoint(point1, False)
self.tmp_band.addPoint(point2, False)
self.tmp_band.addPoint(point3, False)
self.tmp_band.addPoint(point4, False) # true to update canvas
self.tmp_band.addPoint(point1, True)
self.tmp_band.show()
def getNearestSVLocation(self,lon,lat):
js = "this.getNearestSVLocation(%f,%f)" %(lon,lat)
if not self.pointWgs84:
self.pointWgs84 = core.QgsPointXY(lon,lat)
self.heading = 0
self.StreetviewRun()
self.openSVDialog()
time.sleep(1)
self.StreetviewRun()
delay = 10
else:
delay = 4
self.SVLocationResponse = None
self.view.SV.page().mainFrame().evaluateJavaScript(js)
start = datetime.datetime.now()
timeout = False
while not (self.SVLocationResponse or timeout):
time.sleep(0.2)
tdiff = datetime.datetime.now()-start
core.QgsMessageLog.logMessage("getNearestSVLocation %f" % tdiff, tag="go2streetview", level=core.Qgis.Info)
print ("getNearestSVLocation", self.SVLocationResponse, tdiff, timeout)
if tdiff.seconds > delay:
timeout = True
return self.SVLocationResponse
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 canvasReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
if not self.startPoint:
self.startPoint = core.QgsPointXY(event.mapPoint())
self.rubberBand = self.getRubberBand()
if event.button() == Qt.RightButton:
self.execute(self.rubberBand.asGeometry(), self.parameters)
self.initVariable()
def make_feature(self, feat_id, rect):
feat = qc.QgsFeature(feat_id)
# feat.setFeatureId(feat_id)
if rect[0] != rect[1] or rect[2] != rect[3]:
print("WARNING: can only deal with point geometries right now")
gPnt = qc.QgsGeometry.fromPointXY(qc.QgsPointXY(rect[0], rect[2]))
feat.setGeometry(gPnt)
return feat
def infoLayerDefinedAction(self):
if self.infoBoxManager.isEnabled():
actualPoint = core.QgsPointXY(float(self.actualPOV['lon']),float(self.actualPOV['lat']))
self.writeInfoBuffer(self.transformToCurrentSRS(actualPoint))
time.sleep(1)
js = "this.overlay.draw()"
self.view.SV.page().mainFrame().evaluateJavaScript(js)
#self.view.BE.page().mainFrame().evaluateJavaScript(js)
else:
js = "this.clearMarkers();this.clearLines();"
self.view.SV.page().mainFrame().evaluateJavaScript(js)
self.view.BE.page().mainFrame().evaluateJavaScript(js)
def startEdition(self, event):
#Método para iniciar a aquisição
#Parâmetro de entrada: event (Evento)
event.snapPoint()
snapRubberBand = self.getSnapRubberBand()
if snapRubberBand:
snapRubberBand.reset(geometryType=core.QgsWkbTypes.PointGeometry)
snapRubberBand.hide()
self.setSnapRubberBand(None)
pointMap = core.QgsPointXY(event.mapPoint())
layer = self.getCanvas().currentLayer()
if layer:
self.startRubberBand(pointMap, layer)
def projectReadAction(self):
#remove current sketches
self.infoBoxManager.restoreIni()
self.scanForCoverageLayer()
if self.infoBoxManager.isEnabled() and self.apdockwidget.widget() != self.dumView:
infoLayer = self.infoBoxManager.getInfolayer()
toInfoLayerProjection = core.QgsCoordinateTransform(core.QgsCoordinateReferenceSystem(4326),
infoLayer.crs(), core.QgsProject.instance())
self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(self.pointWgs84)))
self.infoBoxManager.show()
self.infoBoxManager.raise_()
QtGui.QGuiApplication.processEvents()
self.infoBoxManager.acceptInfoBoxState()
QtGui.QGuiApplication.processEvents()
def getPointsIndexOfTheNearestSegment(self, sourceFeature, targetFeature):
sourceGeometry = sourceFeature.geometry()
targetGeometry = targetFeature.geometry()
firstVertexIdx = 0
lastVertexIdx = len(sourceGeometry.asPolyline())-1
firstVertex = sourceGeometry.vertexAt(0)
lastVertex = sourceGeometry.vertexAt(lastVertexIdx)
distance1 = self.getShortestDistanceBetweenGeometries(
core.QgsGeometry.fromPointXY(core.QgsPointXY(firstVertex.x(), firstVertex.y())),
targetGeometry
)
distance2 = self.getShortestDistanceBetweenGeometries(
core.QgsGeometry.fromPointXY(core.QgsPointXY(lastVertex.x(), lastVertex.y())),
targetGeometry
)
vertexIdx = -1
if distance1 < distance2:
vertexIdx = firstVertexIdx
else:
vertexIdx = lastVertexIdx
adjVetexIdx1, adjVetexIdx2 = sourceGeometry.adjacentVertices(vertexIdx)
adjVetexIdx = adjVetexIdx1 if (adjVetexIdx1 != -1) else adjVetexIdx2
return (adjVetexIdx, vertexIdx)
def snap_to_point(self, pos, layerPt):
"""calculat if there is a point to snap to within the tolerance"""
tolerance = pow(self.calcTolerance(pos), 2)
minDist = tolerance
snapPoint = None
if self.vertexmarker is None:
self.vertexmarker = RH.init_vertexmarker("snappoint", self.canvas)
for geom in self.possibleSnapFeatures:
closestSegm = geom.closestSegmentWithContext(layerPt)
if closestSegm[0] < minDist:
minDist = closestSegm[0]
snapPoint = closestSegm[1]
if snapPoint and snapPoint != QC.QgsPointXY(0, 0):
return snapPoint
def showCircle(self, startPoint, endPoint):
nPoints = 50
x = startPoint.x()
y = startPoint.y()
r = math.sqrt((endPoint.x() - startPoint.x())**2 +
(endPoint.y() - startPoint.y())**2)
self.rubberBand.reset(core.QgsWkbTypes.PolygonGeometry)
for itheta in range(nPoints + 1):
theta = itheta * (2.0 * math.pi / nPoints)
self.rubberBand.addPoint(
core.QgsPointXY(x + r * math.cos(theta),
y + r * math.sin(theta)))
self.rubberBand.closePoints()
def finishEdition(self, event):
#Método para finalizar a aquisição
event.snapPoint()
point = core.QgsPointXY(event.mapPoint())
if self.getRubberBand():
self.getRubberBand().addPoint(point)
if not self.getRubberBand():
return
if self.getRubberBand().numberOfVertices() > 2:
geom = self.getRubberBand().asGeometry()
if not self.controlPressed:
self.acquisitionFinished.emit(geom)
else:
self.doReshape(geom)
self.cancelEdition()
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 apdockChangeVisibility(self,vis):
if not vis:
self.position.reset()
self.aperture.reset()
self.disableControlShape()
try:
self.StreetviewAction.setIcon(QtGui.QIcon(":/plugins/go2streetview/res/icoStreetview_gray.png"))
#self.StreetviewAction.setDisabled(True)
except:
pass
else:
self.StreetviewAction.setEnabled(True)
self.StreetviewAction.setIcon(QtGui.QIcon(":/plugins/go2streetview/res/icoStreetview.png"))
self.setPosition()
if self.infoBoxManager.isEnabled() and self.apdockwidget.widget() != self.dumView:
infoLayer = self.infoBoxManager.getInfolayer()
toInfoLayerProjection = core.QgsCoordinateTransform(core.QgsCoordinateReferenceSystem(4326),infoLayer.crs(), core.QgsProject.instance())
self.enableControlShape(toInfoLayerProjection.transform(core.QgsPointXY(self.pointWgs84)))
def mouseMove(self, currentPos):
if not self.isEditing:
return
self.rubberBand.movePoint(core.QgsPointXY(currentPos))
def printAction(self):
#export tmp imgs of qwebviews
for imgFile,webview in {"tmpSV.png":self.view.SV,"tmpBE.png":self.view.BE}.items():
painter = QtGui.QPainter()
img = QtGui.QImage(webview.size().width(), webview.size().height(), QtGui.QImage.Format_ARGB32)
painter.begin(img)
webview.page().mainFrame().render(painter)
painter.end()
img.save(os.path.join(self.dirPath,"tmp",imgFile))
# portion of code from: http://gis.stackexchange.com/questions/77848/programmatically-load-composer-from-template-and-generate-atlas-using-pyqgis
# Load template
myLayout = core.QgsLayout(core.QgsProject.instance())
myFile = os.path.join(os.path.dirname(__file__), 'res','go2SV_A4.qpt')
myTemplateFile = open(myFile, 'rt')
myTemplateContent = myTemplateFile.read()
myTemplateFile.close()
myDocument = QtXml.QDomDocument()
myDocument.setContent(myTemplateContent)
myLayout.loadFromTemplate(myDocument,core.QgsReadWriteContext())
#MAP
mapFrame = sip.cast(myLayout.itemById('MAP'),core.QgsLayoutItemMap)
mapFrameAspectRatio = mapFrame.extent().width()/mapFrame.extent().height()
newMapFrameExtent = core.QgsRectangle()
actualPosition = self.transformToCurrentSRS(core.QgsPointXY (float(self.actualPOV['lon']),float(self.actualPOV['lat'])))
centerX = actualPosition.x()
centerY = actualPosition.y()
if float(self.actualPOV['heading']) > 360:
head = float(self.actualPOV['heading'])-360
else:
head = float(self.actualPOV['heading'])
newMapFrameExtent.set(centerX - self.iface.mapCanvas().extent().height()*mapFrameAspectRatio/2,centerY - self.iface.mapCanvas().extent().height()/2,centerX + self.iface.mapCanvas().extent().height()*mapFrameAspectRatio/2,centerY + self.iface.mapCanvas().extent().height()/2)
mapFrame.setExtent(newMapFrameExtent)
mapFrame.setMapRotation(self.canvas.rotation())
mapFrame.redraw()
#CURSOR
mapFrameCursor = sip.cast(myLayout.itemById('CAMERA'),core.QgsLayoutItemPicture)
mapFrameCursor.setPicturePath(os.path.join(os.path.dirname(__file__),'res', 'camera.svg'))
mapFrameCursor.setItemRotation(head+self.canvas.rotation(), adjustPosition=True)
#NORTH
mapFrameNorth = sip.cast(myLayout.itemById('NORTH'),core.QgsLayoutItemPicture)
mapFrameNorth.setPicturePath(os.path.join(os.path.dirname(__file__),'res', 'NorthArrow_01.svg'))
mapFrameNorth.setPictureRotation(self.canvas.rotation())
#STREETVIEW AND GM PICS
if self.view.SV.isHidden():
LargePic = os.path.join(os.path.dirname(__file__),'tmp', 'tmpBE.png')
SmallPic = os.path.join(os.path.dirname(__file__),'tmp', 'tmpSV.png')
else:
LargePic = os.path.join(os.path.dirname(__file__),'tmp', 'tmpSV.png')
SmallPic = os.path.join(os.path.dirname(__file__),'tmp', 'tmpBE.png')
SVFrame = sip.cast(myLayout.itemById('LARGE'),core.QgsLayoutItemPicture)
SVFrame.setPicturePath(LargePic)
BEFrame = sip.cast(myLayout.itemById('SMALL'),core.QgsLayoutItemPicture)
BEFrame.setPicturePath(SmallPic)
#DESCRIPTION
DescFrame = sip.cast(myLayout.itemById('DESC'),core.QgsLayoutItemLabel)
info = self.snapshotOutput.getGeolocationInfo()
DescFrame.setText("LAT: %s\nLON: %s\nHEAD: %s\nADDRESS:\n%s" % (info['lat'], info['lon'], head, info['address']))
workDir = core.QgsProject.instance().readPath("./")
fileName, filter = QtWidgets.QFileDialog().getSaveFileName(None,"Save pdf", workDir, "*.pdf");
if fileName:
if QtCore.QFileInfo(fileName).suffix() != "pdf":
fileName += ".pdf"
exporter = core.QgsLayoutExporter(myLayout)
exporter.exportToPdf(fileName,core.QgsLayoutExporter.PdfExportSettings())
def nearest(self, rect, count):
results = self.qsi.nearestNeighbor(qc.QgsPointXY(rect[0], rect[2]),
count)
return results
def zoomToFeatureFunc(self):
featureBox = self.selectedFeature.geometry().boundingBox()
p1 = self.transformToCurrentSRS(core.QgsPointXY(featureBox.xMinimum(),featureBox.yMinimum()),self.selectedLayer.crs())
p2 = self.transformToCurrentSRS(core.QgsPointXY(featureBox.xMaximum(),featureBox.yMaximum()),self.selectedLayer.crs())
self.mapCanvas.setExtent(core.QgsRectangle(p1.x(),p1.y(),p2.x(),p2.y()))
self.mapCanvas.refresh()
def setCoordinate(self, x, y):
self.resetRubberBand()
self.rubberBand.addPoint(core.QgsPointXY(float(x), float(y)))
iface.mapCanvas().refresh()
def zoomToLayerFunc(self):
layerBox = self.selectedLayer.extent()
p1 = self.transformToCurrentSRS(core.QgsPointXY(layerBox.xMinimum(),layerBox.yMinimum()),self.selectedLayer.crs())
p2 = self.transformToCurrentSRS(core.QgsPointXY(layerBox.xMaximum(),layerBox.yMaximum()),self.selectedLayer.crs())
self.mapCanvas.setExtent(core.QgsRectangle(p1.x(),p1.y(),p2.x(),p2.y()))
self.mapCanvas.refresh()
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)
