def draw(self, rows, con, args, geomType, canvasItemList, mapCanvas):
''' draw the result '''
resultNodesVertexMarkers = canvasItemList['markers']
schema = """%(edge_schema)s""" % args
table = """%(edge_table)s_vertices_pgr""" % args
srid, geomType = Utils.getSridAndGeomType(con, schema, table, 'the_geom')
Utils.setTransformQuotes(args, srid, args['canvas_srid'])
for row in rows:
cur2 = con.cursor()
if args['version'] < 2.1:
args['result_node_id'] = row[1]
args['result_edge_id'] = row[2]
args['result_cost'] = row[3]
else:
args['result_node_id'] = row[3]
args['result_edge_id'] = row[4]
args['result_cost'] = row[5]
query2 = sql.SQL("""
SELECT ST_AsText(%(transform_s)s the_geom %(transform_e)s)
FROM %(edge_table)s_vertices_pgr
WHERE id = %(result_node_id)d
""").format(**args)
cur2.execute(query2)
row2 = cur2.fetchone()
if (row2):
geom = QgsGeometry().fromWkt(str(row2[0]))
pt = geom.asPoint()
vertexMarker = QgsVertexMarker(mapCanvas)
vertexMarker.setColor(Qt.red)
vertexMarker.setPenWidth(2)
vertexMarker.setIconSize(5)
vertexMarker.setCenter(QgsPointXY(pt))
resultNodesVertexMarkers.append(vertexMarker)
class MapToolEmitPoint(MapToolInteractive):
"""Tool to emit mouse clicks as map points."""
canvasClicked = pyqtSignal(QgsPointV2, Qt.MouseButton)
def __init__(self, canvas):
super(MapToolEmitPoint, self).__init__(canvas)
self._vertexMarker = QgsVertexMarker(canvas)
self._vertexMarker.setIconType(QgsVertexMarker.ICON_NONE)
def deactivate(self):
self._vertexMarker.setCenter(QgsPoint())
super(MapToolEmitPoint, self).deactivate()
def canvasReleaseEvent(self, e):
super(MapToolEmitPoint, self).canvasReleaseEvent(e)
if e.isAccepted():
return
# Emit mode
mapPoint, mapPointV2, snapped = self._snapCursorPoint(e.pos())
self._vertexMarker.setCenter(mapPoint)
self.canvasClicked.emit(mapPointV2, e.button())
e.accept()
def setVertexIcon(self, iconType, iconSize=None, penWidth=None, color=None):
self._vertexMarker.setIconType(iconType)
if iconSize is not None:
self._vertexMarker.setIconSize(iconSize)
if iconSize is not None:
self._vertexMarker.setPenWidth(penWidth)
if iconSize is not None:
self._vertexMarker.setColor(color)
def zoomAndShowWKT(self, wtk):
geom = QgsGeometry.fromWkt(wtk)
canvas = self.iface.mapCanvas()
self.clear()
r = QgsRubberBand(canvas, geom.type() == 3 )
r.setToGeometry(geom, None)
r.setColor(QColor(0, 0, 255))
r.setFillColor(QColor(0, 0, 255, 50))
r.setWidth(3)
pt = geom.pointOnSurface().asPoint()
m = QgsVertexMarker(canvas)
m.setCenter( pt )
m.setColor(QColor(0, 0, 255))
m.setIconSize(5)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(3)
if geom.type() == 3 or geom.type() == 2:
rec = geom.boundingBox()
canvas.setExtent(rec)
else:
self.moveMapTo( pt[0], pt[1], 0)
self.graphics.append(r)
self.graphics.append(m)
self._refresh_layers()
class ArkMapToolEmitPoint(ArkMapToolInteractive):
canvasClicked = pyqtSignal(QgsPoint, Qt.MouseButton)
_vertexMarker = None # QgsVertexMarker
def __init__(self, canvas):
super(ArkMapToolEmitPoint, self).__init__(canvas)
self._vertexMarker = QgsVertexMarker(canvas)
self._vertexMarker.setIconType(QgsVertexMarker.ICON_NONE)
def deactivate(self):
self._vertexMarker.setCenter(QgsPoint())
super(ArkMapToolEmitPoint, self).deactivate()
def canvasReleaseEvent(self, e):
super(ArkMapToolEmitPoint, self).canvasReleaseEvent(e)
if e.isAccepted():
return
# Emit mode
mapPoint, snapped = self._snapCursorPoint(e.pos())
self._vertexMarker.setCenter(mapPoint)
self.canvasClicked.emit(mapPoint, e.button())
e.accept()
def setVertexIcon(self, iconType, iconSize=None, penWidth=None, color=None):
self._vertexMarker.setIconType(iconType)
if iconSize is not None:
self._vertexMarker.setIconSize(iconSize)
if iconSize is not None:
self._vertexMarker.setPenWidth(penWidth)
if iconSize is not None:
self._vertexMarker.setColor(color)
class MarkerErrorGeometry():
def __init__(self, mapCanvas):
self.__canvas = mapCanvas
self.__marker = None
def __del__(self):
self.reset()
def __createMarker(self, point):
self.__marker = QgsVertexMarker(self.__canvas)
self.__marker.setCenter(point)
self.__marker.setIconType(QgsVertexMarker.ICON_X)
self.__marker.setPenWidth(3)
def setGeom(self, p):
if self.__marker is not None:
self.reset()
if self.__marker is None:
self.__createMarker(p)
else:
self.__marker.setCenter(p)
def reset(self):
if self.__marker is not None:
self.__canvas.scene().removeItem(self.__marker)
del self.__marker
self.__marker = None
def pointToVertexMarker(self, point):
canvas = self.iface.mapCanvas()
m = QgsVertexMarker(canvas)
m.setCenter(point)
m.setPenWidth(2.5)
m.point = point # save the original point for use in zooming
return m
def canvasPressEvent(self, e):
'''
override, finish line segment when map is clicked
'''
if (e.button() == Qt.RightButton):
if self._moving:
self.rubberband.removeLastPoint()
geom = self.rubberband.asGeometry()
self.drawn.emit(self.transform_from_map(geom))
self.reset()
return
self._moving = False
self._drawing = True
point = self.toMapCoordinates(e.pos())
if self.snap_geometry:
point = self._snap(point)
self.rubberband.addPoint(point, True)
if self.draw_markers:
marker = QgsVertexMarker(self.canvas)
marker.setCenter(point)
marker.setColor(self.color)
marker.setIconSize(8)
marker.setIconType(QgsVertexMarker.ICON_CIRCLE)
marker.setPenWidth(4)
self.markers.append(marker)
class MarkerErrorGeometry():
def __init__(self, mapCanvas):
self.__canvas = mapCanvas
self.__marker = None
def __del__(self):
self.reset()
def __createMarker(self, point):
self.__marker = QgsVertexMarker(self.__canvas)
self.__marker.setCenter(point)
self.__marker.setIconType(QgsVertexMarker.ICON_X)
self.__marker.setPenWidth(3)
def setGeom(self, p):
if self.__marker is not None:
self.reset()
if self.__marker is None:
self.__createMarker(p)
else:
self.__marker.setCenter(p)
def reset(self):
if self.__marker is not None:
self.__canvas.scene().removeItem(self.__marker)
del self.__marker
self.__marker = None
def draw(self, rows, con, args, geomType, canvasItemList, mapCanvas):
''' draw the result '''
resultNodesVertexMarkers = canvasItemList['markers']
table = """%(edge_table)s_vertices_pgr""" % args
srid, geomType = Utils.getSridAndGeomType(con, table, 'the_geom')
Utils.setTransformQuotes(args, srid, args['canvas_srid'])
for row in rows:
cur2 = con.cursor()
if args['version'] < 2.1:
args['result_node_id'] = row[1]
args['result_edge_id'] = row[2]
args['result_cost'] = row[3]
else:
args['result_node_id'] = row[3]
args['result_edge_id'] = row[4]
args['result_cost'] = row[5]
query2 = """
SELECT ST_AsText(%(transform_s)s the_geom %(transform_e)s)
FROM %(edge_table)s_vertices_pgr
WHERE id = %(result_node_id)d
""" % args
cur2.execute(query2)
row2 = cur2.fetchone()
if (row2):
geom = QgsGeometry().fromWkt(str(row2[0]))
pt = geom.asPoint()
vertexMarker = QgsVertexMarker(mapCanvas)
vertexMarker.setColor(Qt.red)
vertexMarker.setPenWidth(2)
vertexMarker.setIconSize(5)
vertexMarker.setCenter(QgsPointXY(pt))
resultNodesVertexMarkers.append(vertexMarker)
def _zoomLoc(self, txt):
self._clearGraphicsLayer()
locations = self.gp.fetchLocation(txt)
if type( locations ) is list and len(locations):
loc = locations[0]
LowerLeftX = loc['BoundingBox']['LowerLeft']['X_Lambert72']
LowerLeftY = loc['BoundingBox']['LowerLeft']['Y_Lambert72']
UpperRightX = loc['BoundingBox']['UpperRight']['X_Lambert72']
UpperRightY = loc['BoundingBox']['UpperRight']['Y_Lambert72']
self.gh.zoomtoRec(QgsPoint(LowerLeftX,LowerLeftY),QgsPoint(UpperRightX, UpperRightY), 31370)
xlb, ylb = loc["Location"]["X_Lambert72"], loc["Location"]["Y_Lambert72"]
x, y = self.gh.prjPtToMapCrs(QgsPoint( xlb , ylb), 31370)
m = QgsVertexMarker(self.iface.mapCanvas())
self.graphicsLayer.append(m)
m.setCenter(QgsPoint(x,y))
m.setColor(QtGui.QColor(255,255,0))
m.setIconSize(1)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(9)
elif type( locations ) is str:
self.bar.pushMessage(
QtCore.QCoreApplication.translate("geopunt4QgisAdresDialog","Waarschuwing"),
locations, level=QgsMessageBar.WARNING, duration=3)
else:
self.bar.pushMessage("Error",
QtCore.QCoreApplication.translate("geopunt4QgisAdresDialog","onbekende fout"),
level=QgsMessageBar.CRITICAL, duration=3)
def where(self):
my_dir = dir()
if self.dlg.APIKEY.text() == '':
self.iface.messageBar().pushMessage(
"Please enter OS API key",
level=Qgis.Success, duration=7)
elif self.dlg.APIKEY.text() != '':
canvas = iface.mapCanvas()
crsSrc = QgsCoordinateReferenceSystem("EPSG:4326")
crsDest = QgsCoordinateReferenceSystem(iface.mapCanvas().mapSettings().destinationCrs().authid())
transformContext = QgsProject.instance().transformContext()
xform = QgsCoordinateTransform(crsSrc, crsDest, transformContext)
min = xform.transform(QgsPointXY(addtable['LNG'][self.dlg.comboBoxadd.currentIndex()],addtable['LAT'][self.dlg.comboBoxadd.currentIndex()]))
x, y = min
scale = 300
rect = QgsRectangle(float(x) - scale, float(y) - scale, float(x) + scale, float(y) + scale)
vertex_items = [ i for i in canvas.scene().items() if issubclass(type(i), QgsVertexMarker)]
for ver in vertex_items:
if ver not in startmarkers and ver in canvas.scene().items():
canvas.scene().removeItem(ver)
canvas.setExtent(rect)
marker = QgsVertexMarker(canvas)
marker.setIconSize(15)
marker.setPenWidth(2)
marker.setCenter(QgsPointXY(int(x), int(y)))
canvas.refresh()
#canvas.extentsChanged.connect(self.clearm)
for varis in dir():
if varis not in my_dir and varis != "my_dir":
del varis
def showFlandersPointOnCanvas(self):
try:
self.__setMapSrs()
inputtext = self.dlg.lineEditFlanders.text().encode("utf8").strip()
params = urllib.urlencode({"q": inputtext})
result2 = urllib2.urlopen(self.location + params).read()
doc = json.loads(result2)
if len(doc) > 0 and len(doc["LocationResult"]) > 0:
x = doc["LocationResult"][0]["Location"]["X_Lambert72"]
y = doc["LocationResult"][0]["Location"]["Y_Lambert72"]
canv = self.iface.mapCanvas()
canv.clear()
marker = QgsVertexMarker(canv)
marker.setPenWidth(3)
marker.setIconType(QgsVertexMarker.ICON_CROSS) # or, ICON_X ICON_BOX
point = QgsPoint(x, y)
marker.setCenter(point)
self.markers.append(marker)
scale = 100
# Create a rectangle to cover the new extent
rect = QgsRectangle(
doc["LocationResult"][0]["BoundingBox"]["LowerLeft"]["X_Lambert72"],
doc["LocationResult"][0]["BoundingBox"]["LowerLeft"]["Y_Lambert72"],
doc["LocationResult"][0]["BoundingBox"]["UpperRight"]["X_Lambert72"],
doc["LocationResult"][0]["BoundingBox"]["UpperRight"]["Y_Lambert72"],
)
# Set the extent to our new rectangle
canv.setExtent(rect)
canv.refresh()
# QMessageBox.information( self.iface.mainWindow(),"Info", "x, y = %s" %str(x) + ", " + str(y) )
# keeps the window alive
self.run()
else:
QMessageBox.information(self.iface.mainWindow(), "Info", "Geen locatie gevonden voor: %s" % inputtext)
except:
QMessageBox.warning(self.iface.mainWindow(), "Warning", "error: %s" % sys.exc_info()[0])
def createMarker( colorRGB, penWidth, iconSize, iconType ):
marker = QgsVertexMarker( self.canvas )
marker.setColor( QColor( colorRGB['R'], colorRGB['G'] , colorRGB['B'] ) )
marker.setPenWidth( penWidth )
marker.setIconSize( iconSize )
marker.setIconType( iconType )
return marker
def _setPointMarker(self, pointgeom):
m = QgsVertexMarker(self.qgisIface.mapCanvas())
m.setColor(QColor(self.config['marker_color']))
m.setIconType(self.config['marker_icon'])
m.setPenWidth(self.config['marker_width'])
m.setIconSize(self.config['marker_size'])
m.setCenter(pointgeom.asPoint())
return m
def crearNuevoMarcaVert(self):
marcador = QgsVertexMarker(iface.mapCanvas())
marcador.setColor(QColor(0,255,0))
marcador.setIconSize(5)
marcador.setIconType(QgsVertexMarker.ICON_BOX)
marcador.setPenWidth(3)
return marcador
def addMarker(iface, pnt, clr=QColor(255, 255, 0), ico=QgsVertexMarker.ICON_BOX ):
m = QgsVertexMarker(iface.mapCanvas())
m.setCenter(pnt)
m.setColor(clr)
m.setIconSize(1)
m.setIconType(ico)
m.setPenWidth(9)
return m
def _setPointMarker(self, pointgeom):
m = QgsVertexMarker(self.qgisIface.mapCanvas())
m.setColor(QColor(self.config['marker_color']))
m.setIconType(self.config['marker_icon'])
m.setPenWidth(self.config['marker_width'])
m.setIconSize(self.config['marker_size'])
m.setCenter(pointgeom.asPoint())
return m
class CaptureCoordinate(QgsMapToolEmitPoint):
'''Class to interact with the map canvas to capture the coordinate
when the mouse button is pressed.'''
capturePoint = pyqtSignal(QgsPointXY)
captureStopped = pyqtSignal()
def __init__(self, canvas):
QgsMapToolEmitPoint.__init__(self, canvas)
self.canvas = canvas
self.vertex = None
def activate(self):
'''When activated set the cursor to a crosshair.'''
self.canvas.setCursor(Qt.CrossCursor)
self.snapcolor = QgsSettings().value( "/qgis/digitizing/snap_color" , QColor( Qt.magenta ) )
def deactivate(self):
self.removeVertexMarker()
self.captureStopped.emit()
def snappoint(self, qpoint):
match = self.canvas.snappingUtils().snapToMap(qpoint)
if match.isValid():
if self.vertex is None:
self.vertex = QgsVertexMarker(self.canvas)
self.vertex.setIconSize(12)
self.vertex.setPenWidth(2)
self.vertex.setColor(self.snapcolor)
self.vertex.setIconType(QgsVertexMarker.ICON_BOX)
self.vertex.setCenter(match.point())
return (match.point()) # Returns QgsPointXY
else:
self.removeVertexMarker()
return self.toMapCoordinates(qpoint) # QPoint input, returns QgsPointXY
def canvasMoveEvent(self, event):
'''Capture the coordinate as the user moves the mouse over
the canvas.'''
self.snappoint(event.originalPixelPoint()) # input is QPoint
def canvasReleaseEvent(self, event):
'''Capture the coordinate when the mouse button has been released,
format it, and copy it to the clipboard. pt is QgsPointXY'''
pt = self.snappoint(event.originalPixelPoint())
self.removeVertexMarker()
try:
canvasCRS = self.canvas.mapSettings().destinationCrs()
transform = QgsCoordinateTransform(canvasCRS, epsg4326, QgsProject.instance())
pt4326 = transform.transform(pt.x(), pt.y())
self.capturePoint.emit(pt4326)
except Exception as e:
pass
def removeVertexMarker(self):
if self.vertex is not None:
self.canvas.scene().removeItem(self.vertex)
self.vertex = None
def _addMarker(self, pnt, clr=QColor(255, 255, 0)):
m = QgsVertexMarker(self.iface.mapCanvas())
m.setCenter(pnt)
m.setColor(clr)
m.setIconSize(1)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(9)
self.graphicsLayer.append(m)
return m
def init_vertexmarker(styleName, canvas):
vmStyle = VERTEXMARKERSTYLES[styleName]
vertexmarker = QgsVertexMarker(canvas)
vertexmarker.setColor(vmStyle["color"])
vertexmarker.setIconSize(vmStyle["iconsize"])
vertexmarker.setIconType(vmStyle["icontype"])
vertexmarker.setPenWidth(vmStyle["penwidth"])
vertexmarker.show()
return vertexmarker
def newTrackPoint(self, pos):
tp = QgsVertexMarker(self.canvas)
tp.setCenter(pos)
tp.setIconType(QgsVertexMarker.ICON_CROSS)
tp.setColor(self.trackColor)
tp.setZValue(self.zValue() - 0.1)
tp.setIconSize(3)
tp.setPenWidth(3)
return tp
def createMarker(colorRGB, penWidth, iconSize, iconType):
marker = QgsVertexMarker(self.canvas)
marker.setColor(QColor(colorRGB['R'], colorRGB['G'],
colorRGB['B']))
marker.setPenWidth(penWidth)
marker.setIconSize(iconSize)
marker.setIconType(iconType)
return marker
def _addMarker(self, pnt, clr=QColor(255,255,0)):
m = QgsVertexMarker(self.iface.mapCanvas())
m.setCenter( pnt )
m.setColor(clr)
m.setIconSize(1)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(9)
self.graphicsLayer.append(m)
return m
def renderTest(self, painter):
m = QgsVertexMarker(self.iface.mapCanvas())
m.setCenter(QgsPointXY(float(randrange(4000000)), float(5000000)))
m.setColor(QColor(0, 255, 0))
m.setIconSize(5)
m.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
m.setPenWidth(3)
# use painter for drawing to map canvas
print("TestPlugin: renderTest called!")
def addPointGraphic(self, xy, color="#FFFF00", size=1, pen=10, markerType=QgsVertexMarker.ICON_BOX ):
"create a point Graphic at location xy and return it"
x, y = list( xy )[:2]
m = QgsVertexMarker(self.canvas)
m.setCenter(QgsPoint(x,y))
m.setColor(QColor(color))
m.setIconSize(size)
m.setIconType(markerType)
m.setPenWidth(pen)
return m
def addPointGraphic(self, xy, color="#FFFF00", size=1, pen=10, markerType=QgsVertexMarker.ICON_BOX ):
"create a point Graphic at location xy and return it"
x, y = list( xy )[:2]
m = QgsVertexMarker(self.canvas)
m.setCenter(QgsPoint(x,y))
m.setColor(QColor(color))
m.setIconSize(size)
m.setIconType(markerType)
m.setPenWidth(pen)
return m
def addPointGraphic(self, xy, color="#FFFF00", size=1, pen=10, markerType=QgsVertexMarker.ICON_BOX ):
"create a point Graphic at location xy and return it"
pt = QgsPointXY(xy[0], xy[1]) if isinstance( xy, Iterable) else QgsPointXY(xy)
m = QgsVertexMarker(self.canvas)
m.setCenter(pt)
m.setColor(QColor(color))
m.setIconSize(size)
m.setIconType(markerType)
m.setPenWidth(pen)
return m
def addTempGeometry(self, chunkId, geometryType, geometry):
""" Add geometries as rubber bands or vertex objects """
if geometryType == "Polygon" or geometryType == "LineString":
self.__tmpGeometry[chunkId].addGeometry(geometry, None)
elif geometryType == "Point":
vertex = QgsVertexMarker(self.iface.mapCanvas())
vertex.setCenter(geometry.asPoint())
vertex.setColor(QColor(0,255,0))
vertex.setIconSize(6)
vertex.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
vertex.setPenWidth(3)
self.__tmpGeometry[chunkId].append(vertex)
def _createSnappableMarkers(self):
if (not self._showSnappableVertices or not self._snappingEnabled):
return
extent = self.canvas().extent()
for vertex in self._snappableVertices.asMultiPoint():
if (extent.contains(vertex)):
marker = QgsVertexMarker(self.canvas())
marker.setIconType(QgsVertexMarker.ICON_X)
marker.setColor(Qt.gray)
marker.setPenWidth(1)
marker.setCenter(vertex)
self._snappableMarkers.append(marker)
def addTempGeometry(self, chunkId, geometryType, geometry):
""" Add geometries as rubber bands or vertex objects """
if geometryType == "Polygon" or geometryType == "LineString":
self.__tmpGeometry[chunkId].addGeometry(geometry, None)
elif geometryType == "Point":
vertex = QgsVertexMarker(self.iface.mapCanvas())
vertex.setCenter(geometry.asPoint())
vertex.setColor(QColor(0,255,0))
vertex.setIconSize(6)
vertex.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
vertex.setPenWidth(3)
self.__tmpGeometry[chunkId].append(vertex)
def _createSnappableMarkers(self):
if (not self._showSnappableVertices or not self._snappingEnabled):
return
extent = self.canvas().extent()
for vertex in self._snappableVertices.asMultiPoint():
if (extent.contains(vertex)):
marker = QgsVertexMarker(self.canvas())
marker.setIconType(QgsVertexMarker.ICON_X)
marker.setColor(Qt.gray)
marker.setPenWidth(1)
marker.setCenter(vertex)
self._snappableMarkers.append(marker)
def canvasPressEvent(self, e):
self.point = self.toMapCoordinates(e.pos())
m = QgsVertexMarker(self.canvas)
m.setCenter(self.point)
m.setColor(QColor(0, 255, 0))
m.setIconSize(5)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(3)
self.points.append(self.point)
self.isEmittingPoint = True
self.showPoly()
class StartEndMarker(object):
def __init__(self, canvas, waypoints, color):
self.canvas = canvas
self.color = color
self.start_vertex_marker = QgsVertexMarker(self.canvas)
self.end_vertex_marker = QgsVertexMarker(self.canvas)
self.update_markers(waypoints)
def update_markers(self, steps):
"""
Update start and end vertex markers on canvas.
:param steps: waypoints in the mission
:type: list
"""
if len(steps) > 1:
self.start_vertex_marker.setCenter(QgsPointXY(steps[0].x(), steps[0].y()))
self.start_vertex_marker.setColor(self.color)
self.start_vertex_marker.setIconSize(14)
self.start_vertex_marker.setIconType(QgsVertexMarker.ICON_CIRCLE) # ICON_BOX, ICON_CROSS, ICON_X
self.start_vertex_marker.setPenWidth(2)
self.start_vertex_marker.show()
self.end_vertex_marker.setCenter(QgsPointXY(steps[-1].x(), steps[-1].y()))
self.end_vertex_marker.setColor(self.color)
self.end_vertex_marker.setIconSize(14)
self.end_vertex_marker.setIconType(QgsVertexMarker.ICON_BOX) # ICON_BOX, ICON_CROSS, ICON_X
self.end_vertex_marker.setPenWidth(2)
self.end_vertex_marker.show()
else:
self.start_vertex_marker.hide()
self.end_vertex_marker.hide()
def hide_markers(self):
""" hide vertex markers. """
self.start_vertex_marker.hide()
self.end_vertex_marker.hide()
def close_markers(self):
""" Remove vertex markers from canvas."""
self.hide_markers()
self.canvas.scene().removeItem(self.start_vertex_marker)
self.canvas.scene().removeItem(self.end_vertex_marker)
self.start_vertex_marker = None
self.end_vertex_marker = None
def markVertex(self, x, y, color=Qt.red):
try:
#self.info.err(None,"markVertex",self.sender().objectName())
marker = QgsVertexMarker(self.iface.mapCanvas())
marker.setCenter(QgsPointXY(x, y))
marker.setColor(color)
marker.setIconSize(7)
marker.setIconType(
QgsVertexMarker.ICON_BOX) # See the enum IconType from http://www.qgis.org/api/classQgsVertexMarker.html
marker.setPenWidth(3)
marker.show()
return marker
except Exception as e:
self.info.err(e)
def updateTrack(self):
if self.pos and self.trackLen:
if len(self.track) >= self.trackLen:
tpr = self.track.popleft()
self.canvas.scene().removeItem(tpr)
del(tpr)
tp = QgsVertexMarker(self.canvas)
tp.setCenter(self.pos)
tp.setIconType(QgsVertexMarker.ICON_CROSS)
tp.setColor(self.trackColor)
tp.setZValue(self.zValue() - 0.1)
tp.setIconSize(3)
tp.setPenWidth(3)
self.track.append(tp)
def createVertex(self, center):
""" Creates a new vertex at the given map coordinates.
:param center:
:type center: QPoint
:return: QgsVertexMarker
"""
vertex = QgsVertexMarker(self.canvas)
vertex.setIconType(self.VERTEX_SHAPE)
vertex.setColor(QColor(self.VERTEX_COLOR))
vertex.setPenWidth(self.VERTEX_PEN_WIDTH)
vertex.setIconSize(self.VERTEX_SIZE)
vertex.setCenter(center)
return vertex
def set_feature_vertex_marker(map_canvas, lon, lat, color=VERTEX_COLOR):
"""
Sets single feature vertex
:param map_canvas: Map canvas object
:param lat: Vertex latitude value
:param lon: Vertex longitude value
:param color: Vertex color
:return marker: Vertex object
:rtype marker: Object
"""
marker = QgsVertexMarker(map_canvas)
marker.setCenter(QgsPointXY(lon, lat))
marker.setColor(QColor(color))
marker.setIconType(QgsVertexMarker.ICON_CIRCLE)
marker.setPenWidth(4)
return marker
def onSelectionChanged(self):
selPois = self._getSelectedPois()
canvas = self.iface.mapCanvas()
self.clearGraphicsLayer()
pts = [ self.gh.prjPtToMapCrs( n['location']['points'][0]['Point']['coordinates'], 4326)
for n in selPois ]
for pt in pts:
x,y = pt
m = QgsVertexMarker(canvas)
self.graphicsLayer.append(m)
m.setCenter(QgsPoint(x,y))
m.setColor(QtGui.QColor(255,255,0))
m.setIconSize(1)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(10)
def onSelectionChanged(self):
selPois = self._getSelectedPois()
canvas = self.iface.mapCanvas()
self.clearGraphicsLayer()
pts = [ self.gh.prjPtToMapCrs( n['location']['points'][0]['Point']['coordinates'], 4326)
for n in selPois ]
for pt in pts:
x,y = pt
m = QgsVertexMarker(canvas)
self.graphicsLayer.append(m)
m.setCenter(QgsPointXY(x,y))
m.setColor(QColor(255,255,0))
m.setIconSize(1)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(10)
class PointMapTool(QgsMapToolEmitPoint):
def __init__(self, canvas):
super(PointMapTool, self).__init__(canvas)
self.canvas = canvas
self.marker = QgsVertexMarker(canvas)
self.marker.setColor(QColor(0, 0, 255))
self.marker.setPenWidth(3)
def canvasPressEvent(self, e):
self.point = self.toMapCoordinates(e.pos())
self.marker.setCenter(self.point)
def deactivate(self):
super(PointMapTool, self).deactivate()
self.deactivated.emit()
self.canvas.scene().removeItem(self.marker)
class MarkerCursor(QObject):
def __init__(self, mapCanvas, srsOL):
QObject.__init__(self)
self.__srsOL = srsOL
self.__canvas = mapCanvas
self.__marker = None
self.__showMarker = True
def __del__(self):
self.reset()
def __refresh(self, pointCenter):
if self.__marker is not None:
self.reset()
self.__marker = QgsVertexMarker(self.__canvas)
self.__marker.setCenter(pointCenter)
self.__marker.setIconType(QgsVertexMarker.ICON_X)
self.__marker.setPenWidth(4)
def setVisible(self, visible):
self.__showMarker = visible
def reset(self):
self.__canvas.scene().removeItem(self.__marker)
del self.__marker
self.__marker = None
@pyqtSlot(str)
def changeMarker(self, strListExtent):
if not self.__showMarker:
return
# left, bottom, right, top
left, bottom, right, top = [float(item) for item in
strListExtent.split(',')]
pointCenter = QgsRectangle(QgsPointXY(left, top),
QgsPointXY(right, bottom)).center()
crsCanvas = self.__canvas.mapSettings().destinationCrs()
if self.__srsOL != crsCanvas:
try:
coodTrans = core.QgsCoordinateTransform(self.__srsOL, crsCanvas)
pointCenter = coodTrans.transform(pointCenter, core.QgsCoordinateTransform.ForwardTransform)
except:
pass
self.__refresh(pointCenter)
class MarkerCursor(QObject):
def __init__(self, mapCanvas, srsOL):
QObject.__init__(self)
self.__srsOL = srsOL
self.__canvas = mapCanvas
self.__marker = None
self.__showMarker = True
def __del__(self):
self.reset()
def __refresh(self, pointCenter):
if self.__marker is not None:
self.reset()
self.__marker = QgsVertexMarker(self.__canvas)
self.__marker.setCenter(pointCenter)
self.__marker.setIconType(QgsVertexMarker.ICON_X)
self.__marker.setPenWidth(4)
def setVisible(self, visible):
self.__showMarker = visible
def reset(self):
self.__canvas.scene().removeItem(self.__marker)
del self.__marker
self.__marker = None
@pyqtSlot(str)
def changeMarker(self, strListExtent):
if not self.__showMarker:
return
# left, bottom, right, top
left, bottom, right, top = [float(item) for item in
strListExtent.split(',')]
pointCenter = QgsRectangle(QgsPointXY(left, top),
QgsPointXY(right, bottom)).center()
crsCanvas = self.__canvas.mapSettings().destinationCrs()
if self.__srsOL != crsCanvas:
coodTrans = QgsCoordinateTransform(self.__srsOL, crsCanvas,
QgsProject.instance())
pointCenter = coodTrans.transform(
pointCenter,
QgsCoordinateTransform.ForwardTransform)
self.__refresh(pointCenter)
def mouseMoved(self, event):
pClicked = QPoint( event.pos().x(), event.pos().y() )
( _, snappedPoints ) = self.networkAnalyzer.getSnapper().snapPoint( pClicked, [] )
for marker in self.highLightedPoints:
self.canvas.scene().removeItem( marker )
self.highLightedPoints = []
if len( snappedPoints ) > 0:
for point in snappedPoints:
marker = QgsVertexMarker( self.canvas )
marker.setCenter( point.snappedVertex )
marker.setColor( QColor( "#FFFF33" ) )
marker.setIconSize( 10 )
marker.setIconType( QgsVertexMarker.ICON_X )
marker.setPenWidth( 2 )
self.highLightedPoints.append(marker)
def markers(self):
if not self._markers:
line_points = self.line_points
line_points = line_points if line_points else self.points
for point in line_points:
index = line_points.index(point)
is_extreme_point = index == 0 or index == len(line_points) - 1
marker = QgsVertexMarker(self.canvas)
marker.setColor(self._line_color)
marker.setFillColor(
self._poly_color if not is_extreme_point else Qt.red)
marker.setOpacity(1)
marker.setPenWidth(1)
marker.setIconSize(5)
marker.setIconType(QgsVertexMarker.ICON_CIRCLE)
marker.setCenter(point)
self._markers.append(marker)
return self._markers
def add_vertexmarker_borehole(self, boreholeno, keepExistingMarkers=False):
""" Warning - this method fails silently on error """
if not keepExistingMarkers:
self.remove_canvas_items()
db = JupiterDb()
x, y = db.get_xy(boreholeno)
#JupiterAux.msg_box('x,y = {}, {}'.format(x, y))
# Add new vertexmarker
vm = QgsVertexMarker(iface.mapCanvas())
vm.setCenter(QgsPoint(x, y))
vm.setColor(QColor(0, 255, 0, 255))
vm.setIconSize(30)
vm.setIconType(
QgsVertexMarker.ICON_CROSS) # ICON_BOX, ICON_CROSS, ICON_X
vm.setPenWidth(2)
class MgrsDockWidget(BASE, WIDGET):
epsg4326 = QgsCoordinateReferenceSystem('EPSG:4326')
def __init__(self, canvas, parent=None):
super(MgrsDockWidget, self).__init__(parent)
self.setupUi(self)
self.canvas = canvas
self.marker = None
self.btnZoom.setIcon(
QIcon(':/images/themes/default/mActionZoomIn.svg'))
self.btnRemoveMarker.setIcon(
QIcon(':/images/themes/default/mIconClear.svg'))
self.leMgrsCoordinate.returnPressed.connect(self.zoomToPressed)
self.btnZoom.clicked.connect(self.zoomToPressed)
self.btnRemoveMarker.clicked.connect(self.removeMarker)
self.btnRemoveMarker.setDisabled(True)
def zoomToPressed(self):
mgrsCoord = str(self.leMgrsCoordinate.text()).strip()
lat, lon = mgrs.toWgs(mgrsCoord)
canvasCrs = self.canvas.mapSettings().destinationCrs()
transform4326 = QgsCoordinateTransform(self.epsg4326, canvasCrs)
center = transform4326.transform(lon, lat)
self.canvas.zoomByFactor(1, center)
self.canvas.refresh()
if self.marker is None:
self.marker = QgsVertexMarker(self.canvas)
self.marker.setCenter(center)
self.marker.setIconSize(8)
self.marker.setPenWidth(4)
self.btnRemoveMarker.setDisabled(False)
def removeMarker(self):
self.canvas.scene().removeItem(self.marker)
self.marker = None
def closeEvent(self, evt):
if self.marker is not None:
self.canvas.scene().removeItem(self.marker)
self.marker = None
def mouseMoved(self, event):
pClicked = QPoint(event.pos().x(), event.pos().y())
(_, snappedPoints) = self.networkAnalyzer.getSnapper().snapPoint(
pClicked, [])
for marker in self.highLightedPoints:
self.canvas.scene().removeItem(marker)
self.highLightedPoints = []
if len(snappedPoints) > 0:
for point in snappedPoints:
marker = QgsVertexMarker(self.canvas)
marker.setCenter(point.snappedVertex)
marker.setColor(QColor("#FFFF33"))
marker.setIconSize(10)
marker.setIconType(QgsVertexMarker.ICON_X)
marker.setPenWidth(2)
self.highLightedPoints.append(marker)
def createVertexMarker(self):
"""
Function creates vertex marker that is used for marking new point on
map.
"""
# get qgis settings
settings = QSettings()
qgsLineRed = settings.value("/Qgis/digitizing/line_color_red", 255)
qgsLineGreen = settings.value("/Qgis/digitizing/line_color_green", 0)
qgsLineBlue = settings.value("/Qgis/digitizing/line_color_blue", 0)
qgsMarkerSize = settings.value("/Qgis/digitizing/marker_size", 5)
verMarker = QgsVertexMarker(self.canvas)
verMarker.setIconSize(13)
verMarker.setIconType(QgsVertexMarker.ICON_CROSS)
verMarker.setColor(QColor(qgsLineRed, qgsLineGreen, qgsLineBlue))
verMarker.setPenWidth(2)
return verMarker
def _addGeometryError(self, error):
self._geometryErrors.append(error)
if (self._tip != ''):
self._tip += '\n'
self._tip += error.what()
if (error.hasWhere()):
marker = QgsVertexMarker(self.canvas())
marker.setCenter(error.where())
marker.setIconType(QgsVertexMarker.ICON_X)
marker.setPenWidth(2)
marker.setToolTip(error.what())
marker.setColor(Qt.green)
marker.setZValue(marker.zValue() + 1)
self._geometryErrorMarkers.append(marker)
self._iface.mainWindow().statusBar().showMessage(error.what())
if (self._tip != ''):
self._iface.mainWindow().statusBar().setToolTip(self._tip)
def canvasMoveEvent(self, event):
"""
Whenever the mouse is moved update the rubberband and the snapping.
:param event: QMouseEvent with coordinates
"""
point_clicked = QPoint(event.pos().x(), event.pos().y())
(_, snapped_points) = self.networkAnalyzer.getSnapper().snapPoint(point_clicked, [])
for marker in self.highLightedPoints:
self.canvas.scene().removeItem(marker)
self.highLightedPoints = []
if len(snapped_points) > 0:
for point in snapped_points:
marker = QgsVertexMarker(self.canvas)
marker.setCenter(point.snappedVertex)
marker.setColor(QColor("#FFFF33"))
marker.setIconSize(10)
marker.setIconType(QgsVertexMarker.ICON_X)
marker.setPenWidth(2)
self.highLightedPoints.append(marker)
class LineTool(QgsMapTool):
"""
A basic point tool that can be connected to actions in order to handle
point based actions.
"""
geometryComplete = pyqtSignal(object)
locationChanged = pyqtSignal(object)
def __init__(self, canvas):
super(LineTool, self).__init__(canvas)
self.m1 = None
self.m2 = None
self.p1 = None
self.p2 = None
self.band = QgsRubberBand(canvas, QgsWkbTypes.LineGeometry)
self.band.setWidth(3)
self.band.setColor(Qt.red)
self.cursor = QCursor(
QPixmap(
[
"16 16 3 1",
" c None",
". c #FF0000",
"+ c #FFFFFF",
" ",
" +.+ ",
" ++.++ ",
" +.....+ ",
" +. .+ ",
" +. . .+ ",
" +. . .+ ",
" ++. . .++",
" ... ...+... ...",
" ++. . .++",
" +. . .+ ",
" +. . .+ ",
" ++. .+ ",
" ++.....+ ",
" ++.++ ",
" +.+ ",
]
)
)
def canvasReleaseEvent(self, event):
if self.m2 and self.m1:
self.reset()
point = self.snappoint(event.pos())
if not self.m1:
self.m1 = QgsVertexMarker(self.canvas())
self.m1.setIconType(1)
self.m1.setColor(Qt.blue)
self.m1.setIconSize(6)
self.m1.setPenWidth(3)
self.m1.setCenter(point)
self.p1 = point
return
if not self.m2:
self.m2 = QgsVertexMarker(self.canvas())
self.m2.setIconType(1)
self.m2.setColor(Qt.red)
self.m2.setIconSize(6)
self.m2.setPenWidth(3)
self.m2.setCenter(point)
self.p2 = point
if self.m2 and self.m1:
geom = QgsGeometry.fromPolylineXY([self.p1, self.p2])
self.band.setToGeometry(geom, None)
self.geometryComplete.emit(geom)
def canvasMoveEvent(self, event):
point = self.snappoint(event.pos())
self.locationChanged.emit(point)
def snappoint(self, point):
utils = self.canvas().snappingUtils()
match = utils.snapToMap(point)
if match.isValid():
return match.point()
else:
return self.canvas().getCoordinateTransform().toMapCoordinates(point)
def activate(self):
self.canvas().setCursor(self.cursor)
self.reset()
def deactivate(self):
"""
Deactivate the tool.
"""
pass
def reset(self):
self.band.reset()
self.canvas().scene().removeItem(self.m1)
self.canvas().scene().removeItem(self.m2)
self.m1 = None
self.m2 = None
self.p1 = None
self.p2 = None
class gazetteerSearch:
def __init__(self, iface):
self.dock = None
self.results = []
# Save reference to the QGIS interface
self.iface = iface
self.iface.newProjectCreated.connect(self._hideMarker)
self.iface.projectRead.connect(self._hideMarker)
self.canvas = self.iface.mapCanvas()
self.marker = QgsVertexMarker(self.iface.mapCanvas())
self.marker.setIconSize(20)
self.marker.setPenWidth(3)
self.marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.marker.hide()
# Create the dialog and keep reference
self.widget = gazetteerSearchDialog()
self.widget.runSearch.connect(self.runSearch)
self.widget.ui.clearButton.pressed.connect(self.clearResults)
self.widget.zoomRequested.connect(self.zoomTo)
# initialize plugin directory
self.plugin_dir = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/python/plugins/gazetteersearch"
# initialize locale
localePath = ""
if QGis.QGIS_VERSION_INT < 10900:
locale = QSettings().value("locale/userLocale").toString()[0:2]
else:
locale = QSettings().value("locale/userLocale")[0:2]
if QFileInfo(self.plugin_dir).exists():
localePath = self.plugin_dir + "/i18n/gazetteersearch_" + locale + ".qm"
if QFileInfo(localePath).exists():
self.translator = QTranslator()
self.translator.load(localePath)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
def initGui(self):
# Create action that will start plugin configuration
self.action = QAction(QIcon(":/plugins/gazetteersearch/icon.png"), \
u"Gazetteer Search", self.iface.mainWindow())
# connect the action to the run method
self.action.triggered.connect(self.run)
# Add toolbar button and menu item
self.iface.addToolBarIcon(self.action)
self.iface.addPluginToMenu(u"&Gazetteer Search", self.action)
def unload(self):
# Remove the plugin menu item and icon
self.iface.removePluginMenu(u"&Gazetteer Search",self.action)
self.iface.removeToolBarIcon(self.action)
self.iface.mapCanvas().scene().removeItem(self.marker)
self.marker = None
def _hideMarker(self):
self.marker.hide()
# run method that performs all the real work
def run(self):
if not self.dock:
self.dock = QDockWidget("Gazetteer Search", self.iface.mainWindow())
self.dock.setWidget(self.widget)
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock)
self.gazetteers = common.getGazetteers()
for gazetter in self.gazetteers.iterkeys():
self.widget.addGazetter(gazetter)
if len(self.gazetteers) == 1:
self.widget.hideGazetteers()
else:
self.dock.show()
def runSearch(self, searchString, selectedGazetteer):
searchString = searchString.encode('utf-8')
gazetteer_config = self.gazetteers[str(selectedGazetteer)]
gazetteer = self.getGazetteerModule(gazetteer_config)
url = common.prepareURL(gazetteer.url, gazetteer.params, searchString)
def callback(data):
try:
self.results = list(gazetteer.parseRequestResults(data, self.iface))
except:
self.results = []
if len(self.results) == 0:
self.widget.addError('No results found for "%s"' % searchString)
for res in self.results:
self.widget.addResult(res.description)
common.search(url, callback)
def clearResults(self):
self.widget.clearResults()
self.marker.hide()
def getGazetteerModule(self, config):
gazetteer_module = config['gazetteer']
imported_gazetteer = import_module('gazetteersearch.gazetteers.%s' % gazetteer_module)
return imported_gazetteer
def zoomTo(self, name):
for res in self.results:
if unicode(res.description) == unicode(name):
dest_crs = self.canvas.mapRenderer().destinationCrs()
if QGis.QGIS_VERSION_INT < 10900:
src_crs = QgsCoordinateReferenceSystem()
src_crs.createFromEpsg(res.epsg)
else:
src_crs = QgsCoordinateReferenceSystem(res.epsg, QgsCoordinateReferenceSystem.EpsgCrsId)
transform = QgsCoordinateTransform(src_crs, dest_crs)
new_point = transform.transform(res.x, res.y)
x = new_point.x()
y = new_point.y()
self.canvas.setExtent(QgsRectangle(x,y,x,y))
self.canvas.zoomScale(res.zoom)
self.canvas.refresh()
self.marker.setCenter(new_point)
self.marker.show()
return
class PdokServicesPlugin(object):
def __init__(self, iface):
# Save reference to the QGIS interface
self.iface = iface
# docked or dialog, defaults to dialog
# 2018 may: RD: deprecating Docked window, as the content is getting to big anyway
# if isinstance(QSettings().value("/pdokservicesplugin/docked"), QVariant):
# self.docked = QSettings().value("/pdokservicesplugin/docked", QVariant(False))
# else:
# self.docked = QSettings().value("/pdokservicesplugin/docked", False)
#
# # Create the dialog and keep reference
# if "True" == self.docked or "true" == self.docked or True is self.docked:
# self.dlg = PdokServicesPluginDockWidget()
# self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dlg)
# else:
# self.dlg = PdokServicesPluginDialog(parent=self.iface.mainWindow())
self.dlg = PdokServicesPluginDialog(parent=self.iface.mainWindow())
# initialize plugin directory
self.plugin_dir = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path() + "/python/plugins/pdokservicesplugin"
# initialize locale
localePath = ""
if isinstance(QSettings().value("locale/userLocale"), QVariant):
locale = QSettings().value("locale/userLocale").value()[0:2]
else:
locale = QSettings().value("locale/userLocale")[0:2]
if QFileInfo(self.plugin_dir).exists():
localePath = self.plugin_dir + "/i18n/pdokservicesplugin_" + locale + ".qm"
if QFileInfo(localePath).exists():
self.translator = QTranslator()
self.translator.load(localePath)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
self.currentLayer = None
self.SETTINGS_SECTION = '/pdokservicesplugin/'
self.pointer = None
self.pdokgeocoder = PDOKGeoLocator(self.iface)
self.geocoderSourceModel = None
def getSettingsValue(self, key, default=''):
if QSettings().contains(self.SETTINGS_SECTION + key):
key = self.SETTINGS_SECTION + key
if Qgis.QGIS_VERSION_INT < 10900: # qgis <= 1.8
return str(QSettings().value(key).toString())
else:
return str(QSettings().value(key))
else:
return default
def setSettingsValue(self, key, value):
key = self.SETTINGS_SECTION + key
if Qgis.QGIS_VERSION_INT < 10900:
# qgis <= 1.8
QSettings().setValue(key, QVariant(value))
else:
QSettings().setValue(key, value)
def initGui(self):
# Create action that will start plugin configuration
self.run_action = QAction(QIcon(":/plugins/pdokservicesplugin/icon.png"), \
u"Pdok Services Plugin", self.iface.mainWindow())
self.servicesLoaded = False
# connect the action to the run method
# 2018 may: RD: deprecating Docked window, as the content is getting to big anyway
# if "True" == self.docked or "true" == self.docked or True == self.docked:
# self.run_action.triggered.connect(self.showAndRaise)
# self.dlg.radioDocked.setChecked(True)
# # docked the dialog is immidiately visible, so should run NOW
# else:
# self.run_action.triggered.connect(self.run)
# self.dlg.radioDocked.setChecked(False)
# self.setupfq()
self.run_action.triggered.connect(self.run)
#self.dlg.radioDocked.setChecked(False)
self.setupfq()
# Add toolbar button and menu item
#self.iface.addToolBarIcon(self.action)
self.toolbar = self.iface.addToolBar("PDOK services plugin")
self.toolbar.setObjectName("PDOK services plugin")
self.toolbar.addAction(self.run_action)
self.toolbarSearch = QLineEdit()
self.toolbarSearch.setMaximumWidth(200)
self.toolbarSearch.setAlignment(Qt.AlignLeft)
self.toolbarSearch.setPlaceholderText("PDOK Locatieserver zoek")
self.toolbar.addWidget(self.toolbarSearch)
self.toolbarSearch.returnPressed.connect(self.searchAddressFromToolbar)
# address/point cleanup
self.clean_action = QAction(QIcon(":/plugins/pdokservicesplugin/eraser.png"), \
u"Cleanup", self.eraseAddress())
self.toolbar.addAction(self.clean_action)
self.clean_action.triggered.connect(self.eraseAddress)
self.iface.addPluginToMenu(u"&Pdok Services Plugin", self.run_action)
# about
self.aboutAction = QAction(QIcon(":/plugins/pdokservicesplugin/help.png"), \
"About", self.iface.mainWindow())
self.aboutAction.setWhatsThis("Pdok Services Plugin About")
self.iface.addPluginToMenu(u"&Pdok Services Plugin", self.aboutAction)
self.aboutAction.triggered.connect(self.about)
self.dlg.ui.btnLoadLayer.clicked.connect(self.loadService)
self.dlg.geocoderSearch.returnPressed.connect(self.searchAddress)
self.dlg.geocoderSearch.textEdited.connect(self.searchAddress)
self.dlg.geocoderSearch.setPlaceholderText("PDOK Locatieserver zoek, bv postcode of postcode huisnummer")
self.dlg.geocoderResultSearch.textChanged.connect(self.filterGeocoderResult)
self.dlg.geocoderResultSearch.setPlaceholderText("een of meer zoekwoorden uit resultaat")
#self.dlg.radioDocked.toggled.connect(self.set_docked)
self.dlg.btnCheckPdokJson.clicked.connect(self.checkPdokJson)
#self.iface.mapCanvas().renderStarting.connect(self.extentsChanged)
ui = self.dlg.ui
cbxs = [ui.cbx_gem, ui.cbx_wpl, ui.cbx_weg, ui.cbx_pcd, ui.cbx_adr, ui.cbx_pcl, ui.cbx_hmp]
# connect all fq checkboxes with suggest, so upon a change in fq filter we re-search
for cbx in cbxs:
cbx.stateChanged.connect(self.searchAddress)
self.run(True)
# for now hiding the pointer as soon as the extent changes
#def extentsChanged(self):
# self.removePointer()
def checkPdokJson(self):
myversion = self.getSettingsValue('pdokversion', '1')
msgtxt = ''
msglvl = 0 # QgsMessageBar.INFO
try:
response = urllib.request.urlopen('http://www.qgis.nl/pdok.version')
str_response = response.read().decode('utf-8')
pdokversion = json.loads(str_response)
if pdokversion > int(myversion):
response = urllib.request.urlopen('http://www.qgis.nl/pdok.json')
str_response = response.read().decode('utf-8')
pdokjson = json.loads(str_response)
with open(self.plugin_dir +'/pdok.json', 'w') as outfile:
json.dump(pdokjson, outfile)
msgtxt = "De laatste versie is opgehaald en zal worden gebruikt " + \
str(pdokversion) + ' (was ' + myversion +')'
self.servicesLoaded = False # reset reading of json
self.run()
self.setSettingsValue('pdokversion', pdokversion)
else:
msgtxt = "Geen nieuwere versie beschikbaar dan " + str(pdokversion)
except Exception as e:
#print e
msgtxt = "Fout bij ophalen van service info. Netwerk probleem?"
msglvl = 2 # QgsMessageBar.CRITICAL
# msg
if hasattr(self.iface, 'messageBar'):
self.iface.messageBar().pushMessage("PDOK services update", msgtxt, level=msglvl, duration=10)
else: # 1.8
QMessageBox.information(self.iface.mainWindow(), "Pdok Services Plugin", msgtxt)
# def set_docked(self, foo):
# self.setSettingsValue('docked', self.dlg.radioDocked.isChecked())
# #if Qgis.QGIS_VERSION_INT < 10900:
# # # qgis <= 1.8
# # QSettings().setValue("/pdokservicesplugin/docked", QVariant(self.dlg.radioDocked.isChecked()))
# #else:
# # QSettings().setValue("/pdokservicesplugin/docked", self.dlg.radioDocked.isChecked())
def showAndRaise(self):
self.dlg.show()
self.dlg.raise_()
# also remove the pointer
self.removePointer()
def about(self):
infoString = "Written by Richard Duivenvoorde\nEmail - [email protected]\n"
infoString += "Company - Zuidt - http://www.zuidt.nl\n"
infoString += "Source: https://github.com/rduivenvoorde/pdokservicesplugin"
QMessageBox.information(self.iface.mainWindow(), "Pdok Services Plugin About", infoString)
def unload(self):
self.removePointer()
# Remove the plugin menu item and icon
self.iface.removePluginMenu(u"&Pdok Services Plugin",self.run_action)
del self.toolbarSearch
def showService(self, selectedIndexes):
if len(selectedIndexes)==0:
self.currentLayer = None
self.dlg.ui.layerInfo.setHtml('')
self.dlg.ui.comboSelectProj.clear()
return
# needed to scroll To the selected row incase of using the keyboard / arrows
self.dlg.servicesView.scrollTo(self.dlg.servicesView.selectedIndexes()[0])
# itemType holds the data (== column 1)
self.currentLayer = self.dlg.servicesView.selectedIndexes()[1].data(Qt.UserRole)
if isinstance(self.currentLayer, QVariant):
self.currentLayer = self.currentLayer.toMap()
# QGIS 1.8: QVariants
currentLayer = {}
for key in list(self.currentLayer.keys()):
val = self.currentLayer[key]
currentLayer[str(key)]=str(val.toString())
self.currentLayer = currentLayer
url = self.currentLayer['url']
title = self.currentLayer['title']
style = ''
if 'style' in self.currentLayer:
style = self.currentLayer['style']
title = title + ' [' + style + ']'
servicetitle = self.currentLayer['servicetitle']
layername = self.currentLayer['layers']
abstract = self.currentLayer['abstract']
stype = self.currentLayer['type'].upper()
minscale =''
if 'minscale' in self.currentLayer and self.currentLayer['minscale'] != None and self.currentLayer['minscale'] != '':
minscale = "min. schaal 1:"+self.currentLayer['minscale']
maxscale = ''
if 'maxscale' in self.currentLayer and self.currentLayer['maxscale'] != None and self.currentLayer['maxscale'] != '':
maxscale = "max. schaal 1:"+self.currentLayer['maxscale']
self.dlg.ui.layerInfo.setText('')
self.dlg.ui.btnLoadLayer.setEnabled(True)
self.dlg.ui.layerInfo.setHtml('<h4>%s</h4><h3>%s</h3><lu><li>%s</li><li> </li><li>%s</li><li>%s</li><li>%s</li><li>%s</li><li>%s</li><li>%s</li></lu>' % (servicetitle, title, abstract, stype, url, layername, style, minscale, maxscale))
self.dlg.ui.comboSelectProj.clear()
if stype=="WMS":
try:
crs = self.currentLayer['crs']
except KeyError:
crs = 'EPSG:28992'
crs = crs.split(',')
self.dlg.ui.comboSelectProj.addItems(crs)
for i in range(len(crs)):
if crs[i] == 'EPSG:28992':
self.dlg.ui.comboSelectProj.setCurrentIndex(i)
if stype=="WMTS":
tilematrixsets = self.currentLayer['tilematrixsets'].split(',')
self.dlg.ui.comboSelectProj.addItems(tilematrixsets)
for i in range(len(tilematrixsets)):
if tilematrixsets[i].startswith('EPSG:28992'):
self.dlg.ui.comboSelectProj.setCurrentIndex(i)
def loadService(self):
if self.currentLayer == None:
return
servicetype = self.currentLayer['type']
url = self.currentLayer['url']
# some services have an url with query parameters in it, we have to urlencode those:
location,query = urllib.parse.splitquery(url)
url = location
if query != None and query != '':
url +=('?'+urllib.parse.quote_plus(query))
title = self.currentLayer['title']
if 'style' in self.currentLayer:
style = self.currentLayer['style']
title = title + ' [' + style + ']'
else:
style = '' # == default for this service
layers = self.currentLayer['layers']
# mmm, tricky: we take the first one while we can actually want png/gif or jpeg
if servicetype == "wms":
imgformat = self.currentLayer['imgformats'].split(',')[0]
if self.dlg.ui.comboSelectProj.currentIndex() == -1:
crs = 'EPSG:28992'
else:
crs = self.dlg.ui.comboSelectProj.currentText()
if Qgis.QGIS_VERSION_INT < 10900:
# qgis <= 1.8
uri = url
self.iface.addRasterLayer(
uri, # service uri
title, # name for layer (as seen in QGIS)
"wms", # dataprovider key
[layers], # array of layername(s) for provider (id's)
[""], # array of stylename(s) NOTE: ignoring styles here!!!
imgformat, # image format searchstring
crs) # crs code searchstring
else:
# qgis > 1.8
uri = "crs="+crs+"&layers="+layers+"&styles="+style+"&format="+imgformat+"&url="+url;
self.iface.addRasterLayer(uri, title, "wms")
elif servicetype == "wmts":
if Qgis.QGIS_VERSION_INT < 10900:
QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ("Sorry, dit type layer: '"+servicetype.upper()+"' \nkan niet worden geladen in deze versie van QGIS.\nMisschien kunt u QGIS 2.0 installeren (die kan het WEL)?\nOf is de laag niet ook beschikbaar als wms of wfs?"), QMessageBox.Ok, QMessageBox.Ok)
return
if self.dlg.ui.comboSelectProj.currentIndex() == -1:
tilematrixset = 'EPSG:28992'
else:
tilematrixset = self.dlg.ui.comboSelectProj.currentText()
imgformat = self.currentLayer['imgformats'].split(',')[0]
# special case for luchtfoto
#if layers=="luchtfoto":
# # tileMatrixSet=nltilingschema&crs=EPSG:28992&layers=luchtfoto&styles=&format=image/jpeg&url=http://geodata1.nationaalgeoregister.nl/luchtfoto/wmts/1.0.0/WMTSCapabilities.xml
# # {u'layers': u'luchtfoto', u'imgformats': u'image/jpeg', u'title': u'PDOK-achtergrond luchtfoto', u'url': u'http://geodata1.nationaalgeoregister.nl/luchtfoto/wms', u'abstract': u'', u'tilematrixsets': u'nltilingschema', u'type': u'wmts'}
# uri = "tileMatrixSet="+tilematrixsets+"&crs=EPSG:28992&layers="+layers+"&styles=&format="+imgformat+"&url="+url
#else:
# uri = "tileMatrixSet="+tilematrixsets+"&crs=EPSG:28992&layers="+layers+"&styles=&format="+imgformat+"&url="+url;
#uri = "tileMatrixSet="+tilematrixsets+"&crs=EPSG:28992&layers="+layers+"&styles=default&format="+imgformat+"&url="+url;
if tilematrixset.startswith('EPSG:'):
crs=tilematrixset
i = crs.find(':', 5)
if i > -1:
crs=crs[:i]
elif tilematrixset.startswith('OGC:1.0'):
crs='EPSG:3857'
uri = "tileMatrixSet="+tilematrixset+"&crs="+crs+"&layers="+layers+"&styles=default&format="+imgformat+"&url="+url;
#print "############ PDOK URI #################"
#print uri
self.iface.addRasterLayer(uri, title, "wms")
elif servicetype == "wfs":
location, query = urllib.parse.splitquery(url)
#uri = location+"?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME="+layers+"&SRSNAME=EPSG:28992"
#uri = location + "?SERVICE=WFS&REQUEST=GetFeature&TYPENAME=" + layers + "&SRSNAME=EPSG:28992"
# adding a bbox paramater forces QGIS to NOT cache features but retrieve new features all the time
# QGIS will update the BBOX to the right value
#uri += "&BBOX=-10000,310000,290000,650000"
uri = " pagingEnabled='true' restrictToRequestBBOX='1' srsname='EPSG:28992' typename='"+layers+"' url='"+url+"' version='2.0.0' "
self.iface.addVectorLayer(uri, title, "WFS")
elif servicetype == "wcs":
# cache=AlwaysCache&crs=EPSG:28992&format=GeoTIFF&identifier=ahn25m:ahn25m&url=http://geodata.nationaalgeoregister.nl/ahn25m/wcs
uri = ''
# cache=AlwaysCache
# cache=PreferNetwork
# cache=AlwaysNetwork
# cache=AlwaysNetwork&crs=EPSG:28992&format=GeoTIFF&identifier=ahn25m:ahn25m&url=http://geodata.nationaalgeoregister.nl/ahn25m/wcs
#uri = "cache=AlwaysNetwork&crs=EPSG:28992&format=image/tiff&version=1.1.1&identifier="+layers+"&url="+url
# working for ahn1 ahn2 and ahn3: GEOTIFF_FLOAT32
format = 'GEOTIFF_FLOAT32'
# working for ahn25m is only image/tiff
if layers=='ahn25m':
format = 'image/tiff'
# we handcrated some wcs layers with 2 different image formats: tiff (RGB) and tiff (float32):
if 'imgformats' in self.currentLayer:
format = self.currentLayer['imgformats'].split(',')[0]
uri = "cache=AlwaysNetwork&crs=EPSG:28992&format="+format+"&version=1.1.2&identifier=" + layers + "&url=" + url
#uri = "cache=AlwaysNetwork&crs=EPSG:28992&format=image/tiff&version=1.1.2&identifier=" + layers + "&url=" + url
self.iface.addRasterLayer(uri, title, "wcs")
else:
QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ("Sorry, dit type layer: '"+servicetype.upper()+"' \nkan niet worden geladen door de plugin of door QGIS.\nIs het niet beschikbaar als wms, wmts of wfs?"), QMessageBox.Ok, QMessageBox.Ok)
return
def filterGeocoderResult(self, string):
#print "filtering geocoder results: %s" % string
self.dlg.geocoderResultView.selectRow(0)
self.geocoderProxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.geocoderProxyModel.setFilterFixedString(string)
def searchAddressFromToolbar(self):
self.removePointer()
self.geocoderSourceModel.clear()
self.geocode()
def searchAddress(self):
self.removePointer()
#print "search geocoder for: %s" % self.dlg.geocoderSearch.text()
self.geocoderSourceModel.clear()
#self.geocode(self.dlg.geocoderSearch.text())
self.suggest()
def eraseAddress(self):
"""
clean the input and remove the pointer
"""
self.removePointer()
if self.geocoderSourceModel is not None:
self.geocoderSourceModel.clear()
if self.dlg.geocoderSearch is not None:
self.dlg.geocoderSearch.clear()
if self.toolbarSearch is not None:
self.toolbarSearch.clear()
def filterLayers(self, string):
# remove selection if one row is selected
self.dlg.servicesView.selectRow(0)
#self.currentLayer = None
self.proxyModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.proxyModel.setFilterFixedString(string)
#def addSourceRow(self, service, layer):
def addSourceRow(self, serviceLayer):
# you can attache different "data's" to to an QStandarditem
# default one is the visible one:
itemType = QStandardItem("%s" % (serviceLayer["type"].upper()) )
# userrole is a free form one:
# only attach the data to the first item
# service layer = a dict/object with all props of the layer
itemType.setData( serviceLayer, Qt.UserRole )
itemType.setToolTip("%s - %s" % (serviceLayer["type"].upper() ,serviceLayer["title"] ))
# only wms services have styles (sometimes)
layername = serviceLayer["title"]
if 'style' in serviceLayer:
itemLayername = QStandardItem("%s [%s]" % (serviceLayer["title"], serviceLayer["style"]) )
layername = "%s [%s]" % (serviceLayer["title"], serviceLayer["style"])
else:
itemLayername = QStandardItem("%s" % (serviceLayer["title"]))
itemLayername.setToolTip("%s - %s" % (serviceLayer["type"].upper() ,serviceLayer["servicetitle"] ))
# itemFilter is the item used to search filter in. That is why layername is a combi of layername + filter here
itemFilter = QStandardItem("%s %s %s %s" % (serviceLayer["type"], layername, serviceLayer["servicetitle"], serviceLayer["abstract"]) )
itemServicetitle = QStandardItem("%s" % (serviceLayer["servicetitle"]))
itemServicetitle.setToolTip("%s - %s" % (serviceLayer["type"].upper() ,serviceLayer["title"] ))
self.sourceModel.appendRow( [ itemLayername, itemType, itemServicetitle, itemFilter ] )
# run method that performs all the real work
def run(self, hiddenDialog=False):
# enable possible remote pycharm debugging
#import pydevd
#pydevd.settrace('localhost', port=5678, stdoutToServer=True, stderrToServer=True)
# last viewed/selected tab
if QSettings().contains("/pdokservicesplugin/currenttab"):
if Qgis.QGIS_VERSION_INT < 10900:
# qgis <= 1.8
self.dlg.tabs.widget(QSettings().value("/pdokservicesplugin/currenttab").toInt()[0])
else:
self.dlg.tabs.widget(int(QSettings().value("/pdokservicesplugin/currenttab")))
if self.servicesLoaded == False:
pdokjson = os.path.join(os.path.dirname(__file__), ".", "pdok.json")
f = open(pdokjson, 'r', encoding='utf-8')
self.pdok = json.load(f)
f.close()
self.proxyModel = QSortFilterProxyModel()
self.sourceModel = QStandardItemModel()
self.proxyModel.setSourceModel(self.sourceModel)
# filter == search on itemFilter column:
self.proxyModel.setFilterKeyColumn(3)
self.dlg.servicesView.setModel(self.proxyModel)
self.dlg.servicesView.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.geocoderProxyModel = QSortFilterProxyModel()
self.geocoderSourceModel = QStandardItemModel()
self.geocoderProxyModel.setSourceModel(self.geocoderSourceModel)
self.geocoderProxyModel.setFilterKeyColumn(0)
self.dlg.geocoderResultView.setModel(self.geocoderProxyModel)
self.dlg.geocoderResultView.setEditTriggers(QAbstractItemView.NoEditTriggers)
#{"services":[
# {"naam":"WMS NHI","url":"http://geodata.nationaalgeoregister.nl/nhi/ows","layers":["dmlinks","dmnodes"],"type":"wms"},
# {"naam":"WMS NHI","url":"http://geodata.nationaalgeoregister.nl/nhi/ows","layers":["dmlinks","dmnodes"],"type":"wms"}
# ]}
#
for service in self.pdok["services"]:
# service[layer] was an array
if isinstance(service["layers"], str) or isinstance(service["layers"], str):
self.addSourceRow(service)
self.dlg.layerSearch.textChanged.connect(self.filterLayers)
self.dlg.layerSearch.setPlaceholderText("woord uit laagnaam, type of service ")
self.dlg.servicesView.selectionModel().selectionChanged.connect(self.showService)
self.dlg.servicesView.doubleClicked.connect(self.loadService)
# actually I want to load a service when doubleclicked on header
# but as I cannot get this to work, let's disable clicking it then
self.dlg.servicesView.verticalHeader().setSectionsClickable(False)
self.dlg.servicesView.horizontalHeader().setSectionsClickable(False)
#self.dlg.geocoderResultView.doubleClicked.connect(self.zoomToAddress)
self.dlg.geocoderResultView.selectionModel().selectionChanged.connect(self.zoomToAddress)
# hide itemFilter column:
self.dlg.servicesView.hideColumn(3)
self.servicesLoaded = True;
self.sourceModel.setHeaderData(2, Qt.Horizontal, "Service")
self.sourceModel.setHeaderData(1, Qt.Horizontal, "Type")
self.sourceModel.setHeaderData(0, Qt.Horizontal, "Laagnaam [style]")
self.sourceModel.horizontalHeaderItem(2).setTextAlignment(Qt.AlignLeft)
self.sourceModel.horizontalHeaderItem(1).setTextAlignment(Qt.AlignLeft)
self.sourceModel.horizontalHeaderItem(0).setTextAlignment(Qt.AlignLeft)
#self.dlg.servicesView.verticalHeader().hide()
#self.dlg.servicesView.resizeColumnsToContents()
self.dlg.servicesView.setColumnWidth(0, 300) # set name to 300px (there are some huge layernames)
self.dlg.servicesView.horizontalHeader().setStretchLastSection(True)
# show the dialog ?
if not hiddenDialog:
self.dlg.show()
# Run the dialog event loop
#result = self.dlg.exec_()
if Qgis.QGIS_VERSION_INT < 10900:
# qgis <= 1.8
QSettings().setValue("/pdokservicesplugin/currenttab", QVariant(self.dlg.tabs.currentIndex()))
else:
QSettings().setValue("/pdokservicesplugin/currenttab", self.dlg.tabs.currentIndex())
self.removePointer()
def setupfq(self):
"""
Setup the fq checkboxes in the gui, by looking into the settings for the
'pdokservicesplugin/checkedfqs' key, which contains a list of type strings
like ['weg','adres']
"""
checked_fqs = self.getSettingsValue('checkedfqs', [])
#self.info('setup fq: {}'.format(checked_fqs))
if len(checked_fqs) > 0: # else there is not saved state... take gui defaults
self.dlg.ui.cbx_gem.setChecked('gemeente' in checked_fqs)
self.dlg.ui.cbx_wpl.setChecked('woonplaats' in checked_fqs)
self.dlg.ui.cbx_weg.setChecked('weg' in checked_fqs)
self.dlg.ui.cbx_pcd.setChecked('postcode' in checked_fqs)
self.dlg.ui.cbx_adr.setChecked('adres' in checked_fqs)
self.dlg.ui.cbx_pcl.setChecked('perceel' in checked_fqs)
self.dlg.ui.cbx_hmp.setChecked('hectometerpaal' in checked_fqs)
def createfq(self):
"""
This creates a fq-string (Filter Query, see https://github.com/PDOK/locatieserver/wiki/Zoekvoorbeelden-Locatieserver)
Based on the checkboxes in the dialog.
Defaults to ''
Example: 'fq=+type:adres+type:gemeente' (only gemeente AND addresses)
:return:
"""
fqlist = []
if self.dlg.ui.cbx_gem.isChecked():
fqlist.append('gemeente')
if self.dlg.ui.cbx_wpl.isChecked():
fqlist.append('woonplaats')
if self.dlg.ui.cbx_weg.isChecked():
fqlist.append('weg')
if self.dlg.ui.cbx_pcd.isChecked():
fqlist.append('postcode')
if self.dlg.ui.cbx_adr.isChecked():
fqlist.append('adres')
if self.dlg.ui.cbx_pcl.isChecked():
fqlist.append('perceel')
if self.dlg.ui.cbx_hmp.isChecked():
fqlist.append('hectometerpaal')
self.setSettingsValue('checkedfqs', fqlist)
#self.info(self.getSettingsValue('checkedfqs', ['leeg?']))
fq = ''
if len(fqlist) > 0:
fq = '&fq=+type:' + '+type:'.join(fqlist)
return fq
def suggest(self):
self.dlg.ui.lookupinfo.setHtml('')
search_text = self.dlg.geocoderSearch.text()
if len(search_text) <= 1:
# QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ( \
# "meer input aub: {}".format(search_text)
# ), QMessageBox.Ok, QMessageBox.Ok)
return
# QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ( \
# "zoeken: {}".format(search_text)
# ), QMessageBox.Ok, QMessageBox.Ok)
results = self.pdokgeocoder.suggest(search_text, self.createfq())
if len(results) == 0:
# ignore, as we are suggesting, maybe more characters will reveal something...
return
for result in results:
#print address
adrestekst = QStandardItem("%s" % (result["adrestekst"]))
adrestekst.setData(result, Qt.UserRole)
type = QStandardItem("%s" % (result["type"]))
id = QStandardItem("%s" % (result["id"]))
score = QStandardItem("%s" % (result["score"]))
adrestekst.setData(result, Qt.UserRole)
self.geocoderSourceModel.appendRow([adrestekst, type])
self.geocoderSourceModel.setHeaderData(0, Qt.Horizontal, "Resultaat")
self.geocoderSourceModel.setHeaderData(1, Qt.Horizontal, "Type")
self.geocoderSourceModel.horizontalHeaderItem(0).setTextAlignment(Qt.AlignLeft)
self.dlg.geocoderResultView.resizeColumnsToContents()
self.dlg.geocoderResultView.horizontalHeader().setStretchLastSection(True)
def geocode(self):
self.dlg.geocoderSearch.setText(self.toolbarSearch.text())
self.suggest()
if self.dlg.geocoderResultView.model().rowCount()>0:
self.dlg.geocoderResultView.selectRow(0)
self.zoomToAddress()
else:
QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ( \
"Niets gevonden.\nProbeer een andere spelling, of alleen postcode/huisnummer?\n\nSelecteer meer (Locatieserver) 'typen' in de PdokServicesPlugin dialoog.\n\nOf gebruik de 'PDOK geocoder'-tab in de PdokServicesPlugin dialoog."
), QMessageBox.Ok, QMessageBox.Ok)
# def geocode(self):
# self.dlg.ui.lookupinfo.setHtml('')
# search_text = self.toolbarSearch.text()
# addresses = self.pdokgeocoder.search(search_text)
# if len(addresses) == 0:
# QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ( \
# "Niets gevonden. Probeer een andere spelling of alleen postcode/huisnummer."
# ), QMessageBox.Ok, QMessageBox.Ok)
# return
# for address in addresses:
# #print address
# adrestekst = QStandardItem("%s" % (address["adrestekst"]))
# adrestekst.setData(address, Qt.UserRole)
# straat = QStandardItem("%s" % (address["straat"]))
# nummer = QStandardItem("%s" % (address["nummer"]))
# postcode = QStandardItem("%s" % (address["postcode"]))
# plaats = QStandardItem("%s" % (address["plaats"]))
# gemeente = QStandardItem("%s" % (address["gemeente"]))
# provincie = QStandardItem("%s" % (address["provincie"]))
# self.geocoderSourceModel.appendRow([adrestekst, straat, nummer, postcode, plaats, gemeente, provincie])
#
# self.dlg.geocoderResultView.selectRow(0)
# self.zoomToAddress()
#
# self.geocoderSourceModel.setHeaderData(0, Qt.Horizontal, "Resultaat")
# self.geocoderSourceModel.setHeaderData(1, Qt.Horizontal, "Straat")
# self.geocoderSourceModel.setHeaderData(2, Qt.Horizontal, "Nr")
# self.geocoderSourceModel.setHeaderData(3, Qt.Horizontal, "Postcode")
# self.geocoderSourceModel.setHeaderData(4, Qt.Horizontal, "Plaats")
# self.geocoderSourceModel.setHeaderData(5, Qt.Horizontal, "Gemeente")
# self.geocoderSourceModel.setHeaderData(6, Qt.Horizontal, "Provincie")
#
# self.geocoderSourceModel.horizontalHeaderItem(0).setTextAlignment(Qt.AlignLeft)
# self.geocoderSourceModel.horizontalHeaderItem(1).setTextAlignment(Qt.AlignLeft)
# self.geocoderSourceModel.horizontalHeaderItem(2).setTextAlignment(Qt.AlignLeft)
# self.geocoderSourceModel.horizontalHeaderItem(3).setTextAlignment(Qt.AlignLeft)
# self.geocoderSourceModel.horizontalHeaderItem(4).setTextAlignment(Qt.AlignLeft)
# self.geocoderSourceModel.horizontalHeaderItem(5).setTextAlignment(Qt.AlignLeft)
# self.geocoderSourceModel.horizontalHeaderItem(6).setTextAlignment(Qt.AlignLeft)
#
# self.dlg.geocoderResultView.resizeColumnsToContents()
# self.dlg.geocoderResultView.horizontalHeader().setStretchLastSection(True)
def zoomToAddress(self):
# get x,y from data of record
self.removePointer()
data = self.dlg.geocoderResultView.selectedIndexes()[0].data(Qt.UserRole)
if 'centroide_rd' in data: # free OR lookup service
geom = QgsGeometry.fromWkt(data['centroide_rd'])
adrestekst = data['adrestekst']
else:
# no centroid yet, probably only object id, retrieve it via lookup service
id = data['id']
data = self.pdokgeocoder.lookup(id)
geom = QgsGeometry.fromWkt(data['centroide_rd'])
adrestekst = data['adrestekst']
lookup_data= data['data']
lis = ''
for key in lookup_data.keys():
lis = lis + '<li>{}: {}</li>'.format(key, lookup_data[key])
self.dlg.ui.lookupinfo.setHtml(
'<h4>{}</h4><lu>{}</lu>'.format(adrestekst, lis))
# just always transform from 28992 to mapcanvas crs
crs = self.iface.mapCanvas().mapSettings().destinationCrs()
crs28992 = QgsCoordinateReferenceSystem()
crs28992.createFromId(28992)
crsTransform = QgsCoordinateTransform(crs28992, crs, QgsProject.instance())
z = 1587
if adrestekst.lower().startswith('adres'):
z = 794
elif adrestekst.lower().startswith('perceel'):
z = 794
elif adrestekst.lower().startswith('hectometer'):
z = 1587
elif adrestekst.lower().startswith('straat'):
z = 3175
elif adrestekst.lower().startswith('postcode'):
z = 6350
elif adrestekst.lower().startswith('woonplaats'):
z = 25398
elif adrestekst.lower().startswith('gemeente'):
z = 50797
elif adrestekst.lower().startswith('provincie'):
z = 812750
geom.transform(crsTransform)
center = geom.asPoint()
self.setPointer(center)
# zoom to with center is actually setting a point rectangle and then zoom
rect = QgsRectangle(center, center)
self.iface.mapCanvas().setExtent(rect)
self.iface.mapCanvas().zoomScale(z)
self.iface.mapCanvas().refresh()
def setPointer(self, point):
self.removePointer()
self.pointer = QgsVertexMarker(self.iface.mapCanvas())
self.pointer.setColor(QColor(255, 255, 0))
self.pointer.setIconSize(10)
self.pointer.setPenWidth(5)
self.pointer.setCenter(point)
def removePointer(self):
if self.pointer is not None:
self.iface.mapCanvas().scene().removeItem(self.pointer)
def info(self, msg=""):
QgsMessageLog.logMessage('{}'.format(msg), 'PDOK-services Plugin', Qgis.Info)
class MincutMapTool(ParentMapTool):
''' Button 26. User select one node or arc.
Execute SQL function: 'gw_fct_mincut'
This function fills 3 temporary tables with id's: node_id, arc_id and valve_id
Returns and integer: error code
Get these id's and select them in its corresponding layers '''
def __init__(self, iface, settings, action, index_action):
''' Class constructor '''
# Call ParentMapTool constructor
super(MincutMapTool, self).__init__(iface, settings, action, index_action)
# Vertex marker
self.vertexMarker = QgsVertexMarker(self.canvas)
self.vertexMarker.setColor(QColor(255, 25, 25))
self.vertexMarker.setIconSize(11)
self.vertexMarker.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.vertexMarker.setPenWidth(5)
''' QgsMapTools inherited event functions '''
def canvasMoveEvent(self, event):
# Hide highlight
self.vertexMarker.hide()
# Get the click
x = event.pos().x()
y = event.pos().y()
eventPoint = QPoint(x,y)
# Snapping
(retval,result) = self.snapper.snapToBackgroundLayers(eventPoint) #@UnusedVariable
self.current_layer = None
# That's the snapped point
if result <> []:
# Check Arc or Node
for snapPoint in result:
if snapPoint.layer.name() == self.layer_node.name() or snapPoint.layer.name() == self.layer_arc.name():
# Get the point
point = QgsPoint(result[0].snappedVertex)
# Add marker
self.vertexMarker.setCenter(point)
self.vertexMarker.show()
# Data for function
self.current_layer = result[0].layer
self.snappFeat = next(result[0].layer.getFeatures(QgsFeatureRequest().setFilterFid(result[0].snappedAtGeometry)))
# Change symbol
if snapPoint.layer.name() == self.layer_node.name():
self.vertexMarker.setIconType(QgsVertexMarker.ICON_CIRCLE)
else:
self.vertexMarker.setIconType(QgsVertexMarker.ICON_BOX)
break
def canvasReleaseEvent(self, event):
''' With left click the digitizing is finished '''
if event.button() == Qt.LeftButton and self.current_layer is not None:
# Get selected layer type: 'arc' or 'node'
if self.current_layer.name() == self.layer_arc.name():
elem_type = 'arc'
elif self.current_layer.name() == self.layer_node.name():
elem_type = 'node'
else:
message = "Current layer not valid"
self.controller.show_warning(message, context_name='ui_message')
return
feature = self.snappFeat
elem_id = feature.attribute(elem_type+'_id')
# Execute SQL function
function_name = "gw_fct_mincut"
sql = "SELECT "+self.schema_name+"."+function_name+"('"+str(elem_id)+"', '"+elem_type+"');"
result = self.controller.execute_sql(sql)
print sql
if result:
# Get 'arc' and 'node' list and select them
self.mg_flow_trace_select_features(self.layer_arc, 'arc')
self.mg_flow_trace_select_features(self.layer_node, 'node')
# Refresh map canvas
self.iface.mapCanvas().refresh()
def mg_flow_trace_select_features(self, layer, elem_type):
sql = "SELECT * FROM "+self.schema_name+".anl_mincut_"+elem_type+" ORDER BY "+elem_type+"_id"
rows = self.controller.get_rows(sql)
if rows:
# Build an expression to select them
aux = "\""+elem_type+"_id\" IN ("
for elem in rows:
aux += elem[0] + ", "
aux = aux[:-2] + ")"
# Get a featureIterator from this expression:
expr = QgsExpression(aux)
if expr.hasParserError():
message = "Expression Error: " + str(expr.parserErrorString())
self.controller.show_warning(message, context_name='ui_message')
return
it = layer.getFeatures(QgsFeatureRequest(expr))
# Build a list of feature id's from the previous result
id_list = [i.id() for i in it]
# Select features with these id's
layer.setSelectedFeatures(id_list)
def activate(self):
# Check button
self.action().setChecked(True)
# Store user snapping configuration
self.snapperManager.storeSnappingOptions()
# Clear snapping
self.snapperManager.clearSnapping()
# Set snapping to arc and node
self.snapperManager.snapToArc()
self.snapperManager.snapToNode()
# Change cursor
self.canvas.setCursor(self.cursor)
# Show help message when action is activated
if self.show_help:
message = "Select a node or pipe and click on it, the valves minimum cut polygon is computed"
self.controller.show_info(message, context_name='ui_message' )
# Control current layer (due to QGIS bug in snapping system)
try:
if self.canvas.currentLayer().type() == QgsMapLayer.VectorLayer:
self.canvas.setCurrentLayer(self.layer_arc)
except:
self.canvas.setCurrentLayer(self.layer_arc)
def deactivate(self):
# Check button
self.action().setChecked(False)
# Restore previous snapping
self.snapperManager.recoverSnappingOptions()
# Recover cursor
self.canvas.setCursor(self.stdCursor)
# Remove highlight
self.h = None
class geopunt4QgisElevationDialog(QDialog):
def __init__(self, iface):
QDialog.__init__(self, None)
self.setWindowFlags( self.windowFlags() & ~Qt.WindowContextHelpButtonHint )
self.iface = iface
# initialize locale
locale = QSettings().value("locale/userLocale", "en")
if not locale: locale == 'en'
else: locale = locale[0:2]
localePath = os.path.join(os.path.dirname(__file__), 'i18n', 'geopunt4qgis_{}.qm'.format(locale))
if os.path.exists(localePath):
self.translator = QTranslator()
self.translator.load(localePath)
QCoreApplication.installTranslator(self.translator)
self._initGui()
def _initGui(self):
"""setup the user interface"""
self.ui = Ui_elevationDlg()
self.ui.setupUi(self)
#get settings
self.s = QSettings()
self.loadSettings()
self.gh = geometryHelper( self.iface )
self.eh = elevationHelper( self.iface, self.startDir)
#setup a message bar
self.bar = QgsMessageBar()
self.bar.setSizePolicy( QSizePolicy.Minimum, QSizePolicy.Fixed )
self.ui.verticalLayout.addWidget(self.bar)
self.ui.buttonBox.addButton(QPushButton("Sluiten"), QDialogButtonBox.RejectRole )
for btn in self.ui.buttonBox.buttons():
btn.setAutoDefault(0)
##graph global vars
self.Rubberline = None
self.profile = None
self.pt = None
self.ax = None
self.ano = None
self.anoLbl = None
self.counter = 0
self.xscaleUnit = (1, "m")
# a figure instance to plot on
self.figure = Figure()
#create the Canvas widget and toolbar and set graphWgt as parent
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
###
#self.ui.toolbar.layout().insertWidget(0, self.toolbar)
self.ui.graphWgt.layout().addWidget(self.canvas)
self.createCanvasToolbar()
#events
self.ui.drawBtn.clicked.connect(self.drawBtnClicked)
self.figure.canvas.mpl_connect('motion_notify_event', self.showGraphMotion)
self.ui.saveLineBtn.clicked.connect(self.saveLineClicked)
self.ui.savePntBtn.clicked.connect(self.savePntClicked)
self.ui.addDHMbtn.clicked.connect(self.addDHMasWMS)
self.ui.refreshBtn.clicked.connect( self.onRefresh )
self.ui.buttonBox.helpRequested.connect(self.openHelp)
self.rejected.connect(self.clean )
def createCanvasToolbar (self):
'''
1 Reset original view
2 Back to previous view
3 Forward to next view
4 Pan axes with left mouse, zoom with right
5 Zoom to rectangle
6 Save the figure
7 Edit curves line and axes parameters
'''
self.toolbar.setVisible(False)
toolbarBtns = self.ui.toolbar.findChildren(QToolButton)
self.ui.toolbar.setStyleSheet("""QToolButton {border-width: 2px; border-style: outset;
border-color: #fbd837; border-radius: 5px ; background-color: white }
QToolButton:pressed { border-style: inset; background-color: grey } """)
toolbarBtns[0].setToolTip(QCoreApplication.translate("geopunt4QgisElevationDialog", "Keer terug naar overzicht"))
toolbarBtns[0].setIcon( QIcon(":/plugins/geopunt4Qgis/images/full_extent.png"))
toolbarBtns[0].clicked.connect( self.toolbar.home )
toolbarBtns[1].setToolTip(QCoreApplication.translate("geopunt4QgisElevationDialog", "Vorige"))
toolbarBtns[1].setIcon( QIcon(":/plugins/geopunt4Qgis/images/previous.png"))
toolbarBtns[1].clicked.connect( self.toolbar.back )
toolbarBtns[2].setToolTip(QCoreApplication.translate("geopunt4QgisElevationDialog", "Volgende"))
toolbarBtns[2].setIcon( QIcon(":/plugins/geopunt4Qgis/images/next.png"))
toolbarBtns[2].clicked.connect( self.toolbar.forward )
toolbarBtns[3].setToolTip(QCoreApplication.translate("geopunt4QgisElevationDialog", "Pannen"))
toolbarBtns[3].setIcon( QIcon(":/plugins/geopunt4Qgis/images/pan.png"))
toolbarBtns[3].clicked.connect( self.toolbar.pan )
toolbarBtns[4].setToolTip(QCoreApplication.translate("geopunt4QgisElevationDialog", "Zoom naar rechthoek"))
toolbarBtns[4].setIcon( QIcon(":/plugins/geopunt4Qgis/images/rectangleZoom.png"))
toolbarBtns[4].clicked.connect( self.toolbar.zoom )
toolbarBtns[5].setToolTip(QCoreApplication.translate("geopunt4QgisElevationDialog", "Opslaan als afbeelding"))
toolbarBtns[5].setIcon( QIcon(":/plugins/geopunt4Qgis/images/save.png"))
toolbarBtns[5].clicked.connect( self.save_fig ) #semf.toolbar.save_figure
toolbarBtns[6].setToolTip(QCoreApplication.translate("geopunt4QgisElevationDialog", "Vorm grafiek aanpassen"))
toolbarBtns[6].setIcon( QIcon(":/plugins/geopunt4Qgis/images/wrench.png"))
toolbarBtns[6].clicked.connect( self.toolbar.edit_parameters)
toolbarBtns[7].setIcon( QIcon(":/plugins/geopunt4Qgis/images/fill.png"))
toolbarBtns[7].setToolTip( QCoreApplication.translate("geopunt4QgisElevationDialog", "Kies de vulkleur"))
toolbarBtns[7].clicked.connect( self.setFill)
def loadSettings(self):
self.timeout = int( self.s.value("geopunt4qgis/timeout" ,15))
if settings().proxyUrl:
self.proxy = settings().proxyUrl
else:
self.proxy = ""
self.samplesSavetoFile = int( self.s.value("geopunt4qgis/samplesSavetoFile" , 1))
sampleLayer = self.s.value("geopunt4qgis/sampleLayerTxt", "")
if sampleLayer:
self.sampleLayerTxt = sampleLayer
self.profileLineSavetoFile = int( self.s.value("geopunt4qgis/profileLineSavetoFile" , 1))
profileLineLayer= self.s.value("geopunt4qgis/profileLineLayerTxt", "")
if profileLineLayer:
self.profileLineLayerTxt = profileLineLayer
self.startDir = self.s.value("geopunt4qgis/startDir", os.path.expanduser("~"))
self.elevation = elevation(self.timeout, self.proxy )
def resizeEvent(self, event):
QDialog.resizeEvent(self, event)
if self.ax: self.figure.tight_layout()
#eventhandlers
def save_fig(self):
formats = (
"Joint Photographic Experts Group (*.jpg) (*.jpg);;Scalable Vector Grapics (*.svg) (*.svg);;"+
"Portable Document Format (*.pdf) (*.pdf);;Tagged Image File Format (*.tif) (*.tif)"+
";;Encapsulated Postscript (*.eps) (*.eps)")
if not(sys.platform == 'win32'):
formats += ";;Portable Network Graphics (*.png) (*.png)"
fileName, __ = QFileDialog.getSaveFileName( self , "Save File", self.startDir, formats);
self.figure.savefig(fileName)
def onRefresh(self):
if self.ano:
self.ano.remove()
self.ano = None
if self.anoLbl:
self.anoLbl.remove()
self.anoLbl = None
self.plot()
def onResize(self, event):
self.figure.tight_layout()
def openHelp(self):
webbrowser.open_new_tab("http://www.geopunt.be/voor-experts/geopunt-plug-ins/functionaliteiten/hoogteprofiel")
def drawBtnClicked(self):
self.clean()
#self.reSetFigure()
self.tool = lineTool(self.iface, self.callBack )
self.iface.mapCanvas().setMapTool(self.tool)
self.showMinimized()
self.counter += 1
def showGraphMotion(self, event):
if self.ax == None: return
if event.xdata != None and event.ydata != None:
if self.ano != None:
self.ano.remove()
self.ano = None
if self.anoLbl != None:
self.anoLbl.remove()
self.anoLbl = None
xdata = np.array( [n[0] for n in self.profile ] ) * self.xscaleUnit[0]
ydata = np.array( [n[3] for n in self.profile ] )# if n[3] > -9999 ]
zx = np.interp( event.xdata, xdata, ydata )
xmax = np.max( xdata )
xmin = np.min( xdata )
zmax = np.max( ydata )
zmin = np.max( [n[3] for n in self.profile if n[3] > -9999 ] )
if event.xdata <= xmax and event.xdata >= xmin :
self.ano = self.ax.arrow( event.xdata , -9999, 0, zx + 9999, fc="k", ec="k" )
box_props = dict(boxstyle="Round,pad=0.3", fc="cyan", ec="b", lw=2)
self.anoLbl = self.ax.annotate( str( round(zx, 2)) + " m", xy= (event.xdata, zx ) ,
xytext= (event.xdata , zx + (0.2 * ( zmax - zmin )) ),
bbox=box_props )
self.setMapPt( event.xdata / self.xscaleUnit[0] )
else:
self.setMapPt()
event.canvas.draw()
def saveLineClicked(self):
if not hasattr(self, 'profileLineLayerTxt'):
layerName, accept = QInputDialog.getText(None,
QCoreApplication.translate("geopunt4Qgis", 'Laag toevoegen'),
QCoreApplication.translate("geopunt4Qgis", 'Geef een naam voor de laag op:') )
if accept == False:
return
else:
self.profileLineLayerTxt = layerName
if self.profile != None and self.Rubberline != None:
title = self.ax.get_title()
self.eh.save_profile( self.Rubberline.asGeometry(), self.profile, title,
self.profileLineLayerTxt, self.profileLineSavetoFile, sender=self )
def savePntClicked(self):
if not hasattr(self, 'sampleLayerTxt'):
layerName, accept = QInputDialog.getText(None,
QCoreApplication.translate("geopunt4Qgis", 'Laag toevoegen'),
QCoreApplication.translate("geopunt4Qgis", 'Geef een naam voor de laag op:') )
if accept == False:
return
else:
self.sampleLayerTxt = layerName
if self.profile != None:
title = self.ax.get_title()
self.eh.save_sample_points( self.profile, title,
self.sampleLayerTxt, self.samplesSavetoFile, sender=self )
def setFill( self ):
if self.profile == None: return
if self.ax == None: return
clr = QColorDialog.getColor( Qt.white, self, QCoreApplication.translate(
"geopunt4QgisElevationDialog", "Kies de vulkleur") )
if clr.isValid():
xdata = np.array( [n[0] for n in self.profile ] ) * self.xscaleUnit[0]
ydata = np.array( [n[3] for n in self.profile ] )
self.ax.fill_between( xdata, ydata, -9999, color=clr.name() )
def addDHMasWMS(self):
crs = self.gh.getGetMapCrs(self.iface).authid()
if crs != 'EPSG:31370' or crs != 'EPSG:3857' or crs != 'EPSG:3043':
crs = 'EPSG:31370'
dhmUrl = "url=https://geoservices.informatievlaanderen.be/raadpleegdiensten/DHMV/wms&layers=DHMVII_DTM_1m&&format=image/png&styles=default&crs="+ crs
try:
rlayer = QgsRasterLayer(dhmUrl, 'Hoogtemodel', 'wms')
if rlayer.isValid():
rlayer.renderer().setOpacity(0.8)
QgsProject.instance().addMapLayer(rlayer)
else: self.bar.pushMessage("Error",
QCoreApplication.translate("geopunt4QgisElevationDialog", "Kan WMS niet laden"),
level=Qgis.Critical, duration=10)
except:
self.bar.pushMessage("Error", str( sys.exc_info()[1] ), level=Qgis.Critical, duration=10)
return
def plot(self):
if self.Rubberline == None: return
wgsLine = self.gh.prjLineFromMapCrs( self.Rubberline.asGeometry() )
lineString = [ list(n) for n in wgsLine.asPolyline()]
nrSamples = self.ui.nrOfSampleSpin.value()
#try:
self.profile = self.elevation.fetchElevaton( lineString, 4326, nrSamples)
#except geopuntError as ge:
# self.bar.pushMessage("Error", ge.message, level=Qgis.Critical, duration=10)
# return
if np.max( [n[0] for n in self.profile ] ) > 1000: self.xscaleUnit = (0.001 , "km" )
else: self.xscaleUnit = (1 , "m" )
xdata = np.array( [n[0] for n in self.profile ] ) * self.xscaleUnit[0]
ydata = np.array( [n[3] for n in self.profile ] )
#need at least 3 values
if len(xdata) <= 2 or len([n for n in self.profile if n[3] > -9999 ]) <= 2:
self.bar.pushMessage("Error",
QCoreApplication.translate(
"geopunt4QgisElevationDialog", "Er werd geen of onvoldoende data gevonden"),
level=Qgis.Warning, duration=5)
self.profile = None
return
ymin = np.min( [n[3] for n in self.profile if n[3] > -9999 ] )
ymax = np.max( ydata )
# create an axis
self.ax = self.figure.add_subplot(111)
# discards the old graph
self.ax.hold(False)
# plot data
self.ax.plot( xdata, ydata,'r*')
self.ax.fill_between(xdata, ydata, -9999, color='#F8E6E0' )
self.ax.set_ylim([ymin , ymax])
self.ax.set_xlim([0 , None ])
self.ax.set_ylabel("hoogte (m)")
self.ax.set_xlabel("afstand (%s)" % self.xscaleUnit[1] )
self.ax.set_title("Hoogteprofiel " + str( self.counter) )
# refresh canvas
self.figure.tight_layout()
self.canvas.draw()
def callBack(self, geom):
self.iface.mapCanvas().unsetMapTool(self.tool)
self.Rubberline = geom
self.showNormal()
self.activateWindow()
self.plot()
self.ui.saveWgt.setEnabled(True)
def setMapPt(self, dist=None ):
if self.pt: self.iface.mapCanvas().scene().removeItem(self.pt)
if dist==None: return
if self.Rubberline == None: return
# dist is measured in lambert 72 in meters
lb72Line = self.gh.prjLineFromMapCrs( self.Rubberline.asGeometry() , 31370 )
lb72pt = lb72Line.interpolate(dist).asPoint()
pt = self.gh.prjPtToMapCrs(lb72pt, 31370)
self.pt = QgsVertexMarker(self.iface.mapCanvas())
self.pt.setCenter( pt )
self.pt.setColor(QColor(0,255,250))
self.pt.setIconSize(5)
self.pt.setIconType(QgsVertexMarker.ICON_BOX ) # or ICON_CROSS, ICON_X
self.pt.setPenWidth(7)
if self.xscaleUnit[0] != 1:
msg= "lengte= %s %s" % (round( dist * self.xscaleUnit[0], 2) , self.xscaleUnit[1])
else:
msg= "lengte= %s %s" % (int( dist * self.xscaleUnit[0]) , self.xscaleUnit[1])
self.ui.mgsLbl.setText( msg )
def clean(self):
if self.pt:
self.iface.mapCanvas().scene().removeItem(self.pt)
if self.Rubberline:
self.iface.mapCanvas().scene().removeItem(self.Rubberline)
if self.ano:
self.ano.remove()
self.ano = None
if self.anoLbl:
self.anoLbl.remove()
self.anoLbl = None
if self.ax:
self.ax.hold(False)
self.ax.clear()
self.ax = None
self.figure.clf()
self.canvas.draw()
self.ui.saveWgt.setEnabled(False)
self.profile = None
self.Rubberline = None
self.ui.mgsLbl.setText("")
class ArkMapToolInteractive(QgsMapTool):
_active = False
_dragging = False
_panningEnabled = False
_zoomingEnabled = False
_zoomRubberBand = None #QgsRubberBand()
_zoomRect = None # QRect()
_snappingEnabled = False
_snapper = None #QgsMapCanvasSnapper()
_snappingMarker = None # QgsVertexMarker()
_showSnappableVertices = False
_snappableVertices = [] # [QgsPoint()]
_snappableMarkers = [] # [QgsVertexMarker()]
def __init__(self, canvas, snappingEnabled=False, showSnappableVertices=False):
super(ArkMapToolInteractive, self).__init__(canvas)
self._snappingEnabled = snappingEnabled
self._showSnappableVertices = showSnappableVertices
def __del__(self):
if self._active:
self.deactivate()
def isActive(self):
return self._active
def activate(self):
super(ArkMapToolInteractive, self).activate()
self._active = True
self._startSnapping()
def deactivate(self):
self._active = False
if self._snappingEnabled:
self._stopSnapping()
if (self._zoomRubberBand is not None):
self.canvas().scene().removeItem(self._zoomRubberBand)
self._zoomRubberBand = None
super(ArkMapToolInteractive, self).deactivate()
def setAction(self, action):
super(ArkMapToolInteractive, self).setAction(action)
self.action().triggered.connect(self._activate)
def _activate(self):
self.canvas().setMapTool(self)
def panningEnabled(self):
return self._panningEnabled
def setPanningEnabled(self, enabled):
self._panningEnabled = enabled
def zoomingEnabled(self):
return self._zoomingEnabled
def setZoomingEnabled(self, enabled):
self._zoomingEnabled = enabled
def snappingEnabled(self):
return self._snappingEnabled
def setSnappingEnabled(self, enabled):
if (self._snappingEnabled == enabled):
return
self._snappingEnabled = enabled
if not self._active:
return
if enabled:
self._startSnapping()
else:
self._stopSnapping()
def _startSnapping(self):
self._snapper = QgsMapCanvasSnapper()
self._snapper.setMapCanvas(self.canvas())
if self._showSnappableVertices:
self._startSnappableVertices()
def _stopSnapping(self):
self._deleteSnappingMarker()
self._snapper = None
if self._showSnappableVertices:
self._stopSnappableVertices()
def showSnappableVertices(self):
return self._showSnappableVertices
def setShowSnappableVertices(self, show):
if (self._showSnappableVertices == show):
return
self._showSnappableVertices = show
if not self._active:
return
if show:
self._startSnappableVertices()
else:
self._stopSnappableVertices()
def _startSnappableVertices(self):
self.canvas().layersChanged.connect(self._layersChanged)
self.canvas().extentsChanged.connect(self._redrawSnappableMarkers)
QgsProject.instance().snapSettingsChanged.connect(self._layersChanged)
self._layersChanged()
def _stopSnappableVertices(self):
self._deleteSnappableMarkers()
self._snappableLayers = []
self.canvas().layersChanged.disconnect(self._layersChanged)
self.canvas().extentsChanged.disconnect(self._redrawSnappableMarkers)
QgsProject.instance().snapSettingsChanged.disconnect(self._layersChanged)
def canvasMoveEvent(self, e):
super(ArkMapToolInteractive, self).canvasMoveEvent(e)
if not self._active:
return
e.ignore()
if (self._panningEnabled and e.buttons() & Qt.LeftButton):
# Pan map mode
if not self._dragging:
self._dragging = True
self.setCursor(QCursor(Qt.ClosedHandCursor))
self.canvas().panAction(e)
e.accept()
elif (self._zoomingEnabled and e.buttons() & Qt.RightButton):
# Zoom map mode
if not self._dragging:
self._dragging = True
self.setCursor(QCursor(Qt.ClosedHandCursor))
self._zoomRubberBand = QgsRubberBand(self.canvas(), QGis.Polygon)
color = QColor(Qt.blue)
color.setAlpha(63)
self._zoomRubberBand.setColor(color)
self._zoomRect = QRect(0, 0, 0, 0)
self._zoomRect.setTopLeft(e.pos())
self._zoomRect.setBottomRight(e.pos())
if self._zoomRubberBand is not None:
self._zoomRubberBand.setToCanvasRectangle(self._zoomRect)
self._zoomRubberBand.show()
e.accept()
elif self._snappingEnabled:
mapPoint, snapped = self._snapCursorPoint(e.pos())
if (snapped):
self._createSnappingMarker(mapPoint)
else:
self._deleteSnappingMarker()
def canvasReleaseEvent(self, e):
super(ArkMapToolInteractive, self).canvasReleaseEvent(e)
e.ignore()
if (e.button() == Qt.LeftButton):
if self._dragging:
# Pan map mode
self.canvas().panActionEnd(e.pos())
self.setCursor(capture_point_cursor)
self._dragging = False
e.accept()
elif (e.button() == Qt.RightButton):
if self._dragging:
# Zoom mode
self._zoomRect.setBottomRight(e.pos())
if (self._zoomRect.topLeft() != self._zoomRect.bottomRight()):
coordinateTransform = self.canvas().getCoordinateTransform()
ll = coordinateTransform.toMapCoordinates(self._zoomRect.left(), self._zoomRect.bottom())
ur = coordinateTransform.toMapCoordinates(self._zoomRect.right(), self._zoomRect.top())
r = QgsRectangle()
r.setXMinimum(ll.x())
r.setYMinimum(ll.y())
r.setXMaximum(ur.x())
r.setYMaximum(ur.y())
r.normalize()
if (r.width() != 0 and r.height() != 0):
self.canvas().setExtent(r)
self.canvas().refresh()
self._dragging = False
if (self._zoomRubberBand is not None):
self.canvas().scene().removeItem(self._zoomRubberBand)
self._zoomRubberBand = None
e.accept()
def keyPressEvent(self, e):
super(ArkMapToolInteractive, self).keyPressEvent(e)
if (e.key() == Qt.Key_Escape):
self.canvas().unsetMapTool(self)
e.accept()
def _snapCursorPoint(self, cursorPoint):
res, snapResults = self._snapper.snapToBackgroundLayers(cursorPoint)
if (res != 0 or len(snapResults) < 1):
return self.toMapCoordinates(cursorPoint), False
else:
# Take a copy as QGIS will delete the result!
snappedVertex = QgsPoint(snapResults[0].snappedVertex)
return snappedVertex, True
def _createSnappingMarker(self, snapPoint):
if (self._snappingMarker is None):
self._snappingMarker = QgsVertexMarker(self.canvas())
self._snappingMarker.setIconType(QgsVertexMarker.ICON_CROSS)
self._snappingMarker.setColor(Qt.magenta)
self._snappingMarker.setPenWidth(3)
self._snappingMarker.setCenter(snapPoint)
def _deleteSnappingMarker(self):
if (self._snappingMarker is not None):
self.canvas().scene().removeItem(self._snappingMarker)
self._snappingMarker = None
def _createSnappableMarkers(self):
if (not self._showSnappableVertices or not self._snappingEnabled):
return
extent = self.canvas().extent()
for vertex in self._snappableVertices.asMultiPoint():
if (extent.contains(vertex)):
marker = QgsVertexMarker(self.canvas())
marker.setIconType(QgsVertexMarker.ICON_X)
marker.setColor(Qt.gray)
marker.setPenWidth(1)
marker.setCenter(vertex)
self._snappableMarkers.append(marker)
def _deleteSnappableMarkers(self):
for marker in self._snappableMarkers:
self.canvas().scene().removeItem(marker)
del self._snappableMarkers[:]
def _layersChanged(self):
if (not self._showSnappableVertices or not self._snappingEnabled):
return
self._buildSnappableLayers()
self._deleteSnappableMarkers()
self._createSnappableMarkers()
def _redrawSnappableMarkers(self):
if (not self._showSnappableVertices or not self._snappingEnabled):
return
self._deleteSnappableMarkers()
self._createSnappableMarkers()
def _buildSnappableLayers(self):
if (not self._showSnappableVertices or not self._snappingEnabled):
return
vertices = []
for layer in self.canvas().layers():
ok, enabled, type, units, tolerance, avoid = QgsProject.instance().snapSettingsForLayer(layer.id())
if (ok and enabled and not layer.isEditable()):
for feature in layer.getFeatures():
geometry = feature.geometry()
if geometry is None:
pass
elif geometry.type() == QGis.Point:
vertices.extend([geometry.asPoint()])
elif geometry.type() == QGis.Line:
vertices.extend(geometry.asPolyline())
elif geometry.type() == QGis.Polygon:
lines = geometry.asPolygon()
for line in lines:
vertices.extend(line)
self._snappableVertices = QgsGeometry.fromMultiPoint(vertices)
self._snappableVertices.simplify(0)
class MoveNodeMapTool(ParentMapTool):
''' Button 16. Move node
Execute SQL function: 'gw_fct_node2arc' '''
def __init__(self, iface, settings, action, index_action, controller, srid):
''' Class constructor '''
# Call ParentMapTool constructor
super(MoveNodeMapTool, self).__init__(iface, settings, action, index_action)
self.srid = srid
# Vertex marker
self.vertexMarker = QgsVertexMarker(self.canvas)
self.vertexMarker.setColor(QColor(0, 255, 0))
self.vertexMarker.setIconSize(9)
self.vertexMarker.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.vertexMarker.setPenWidth(5)
# Rubber band
self.rubberBand = QgsRubberBand(self.canvas, QGis.Line)
mFillColor = QColor(255, 0, 0);
self.rubberBand.setColor(mFillColor)
self.rubberBand.setWidth(3)
self.reset()
def reset(self):
# Clear selected features
layer = self.canvas.currentLayer()
if layer is not None:
layer.removeSelection()
# Graphic elements
self.rubberBand.reset()
def move_node(self, node_id, point):
''' Move selected node to the current point '''
if self.srid is None:
self.srid = self.settings.value('db/srid')
if self.schema_name is None:
self.schema_name = self.settings.value('db/schema_name')
# Update node geometry
the_geom = "ST_GeomFromText('POINT("+str(point.x())+" "+str(point.y())+")', "+str(self.srid)+")";
sql = "UPDATE "+self.schema_name+".node SET the_geom = "+the_geom
sql+= " WHERE node_id = '"+node_id+"'"
status = self.controller.execute_sql(sql)
if status:
# Execute SQL function and show result to the user
function_name = "gw_fct_node2arc"
sql = "SELECT "+self.schema_name+"."+function_name+"('"+str(node_id)+"');"
self.controller.execute_sql(sql)
else:
message = "Move node: Error updating geometry"
self.controller.show_warning(message, context_name='ui_message')
# Refresh map canvas
self.canvas.currentLayer().triggerRepaint()
''' QgsMapTool inherited event functions '''
def activate(self):
''' Called when set as currently active map tool '''
# Check button
self.action().setChecked(True)
# Store user snapping configuration
self.snapperManager.storeSnappingOptions()
# Clear snapping
self.snapperManager.clearSnapping()
# Set snapping to node
self.snapperManager.snapToNode()
self.snapperManager.snapToArc()
# Change pointer
cursor = QCursor()
cursor.setShape(Qt.CrossCursor)
# Get default cursor
self.stdCursor = self.parent().cursor()
# And finally we set the mapTool's parent cursor
self.parent().setCursor(cursor)
# Reset
self.reset()
# Show help message when action is activated
if self.show_help:
message = "Select the disconnected node by clicking on it, move the pointer to desired location inside a pipe and click again"
self.controller.show_info(message, context_name='ui_message' )
# Control current layer (due to QGIS bug in snapping system)
try:
if self.canvas.currentLayer().type() == QgsMapLayer.VectorLayer:
self.canvas.setCurrentLayer(self.layer_node)
except:
self.canvas.setCurrentLayer(self.layer_node)
def deactivate(self):
''' Called when map tool is being deactivated '''
# Check button
self.action().setChecked(False)
# Restore previous snapping
self.snapperManager.recoverSnappingOptions()
# Recover cursor
self.canvas.setCursor(self.stdCursor)
try:
self.rubberBand.reset(QGis.Line)
except AttributeError:
pass
def canvasMoveEvent(self, event):
''' Mouse movement event '''
# Hide highlight
self.vertexMarker.hide()
# Get the click
x = event.pos().x()
y = event.pos().y()
eventPoint = QPoint(x,y)
# Node layer
layer = self.canvas.currentLayer()
if layer is None:
return
# Select node or arc
if layer.selectedFeatureCount() == 0:
# Snap to node
(retval,result) = self.snapper.snapToBackgroundLayers(eventPoint) #@UnusedVariable
# That's the snapped point
if result <> [] and (result[0].layer.name() == self.layer_node.name()):
point = QgsPoint(result[0].snappedVertex)
# Add marker
self.vertexMarker.setColor(QColor(0, 255, 0))
self.vertexMarker.setCenter(point)
self.vertexMarker.show()
# Set a new point to go on with
#self.appendPoint(point)
self.rubberBand.movePoint(point)
else:
point = QgsMapToPixel.toMapCoordinates(self.canvas.getCoordinateTransform(), x, y)
self.rubberBand.movePoint(point)
else:
# Snap to arc
result = []
(retval,result) = self.snapper.snapToBackgroundLayers(eventPoint) #@UnusedVariable
# That's the snapped point
if (result <> []) and (result[0].layer.name() == self.layer_arc.name()) and (result[0].snappedVertexNr == -1):
point = QgsPoint(result[0].snappedVertex)
# Add marker
self.vertexMarker.setColor(QColor(255, 0, 0))
self.vertexMarker.setCenter(point)
self.vertexMarker.show()
# Select the arc
self.layer_arc.removeSelection()
self.layer_arc.select([result[0].snappedAtGeometry])
# Bring the rubberband to the cursor i.e. the clicked point
self.rubberBand.movePoint(point)
else:
# Bring the rubberband to the cursor i.e. the clicked point
point = QgsMapToPixel.toMapCoordinates(self.canvas.getCoordinateTransform(), x, y)
self.rubberBand.movePoint(point)
def canvasReleaseEvent(self, event):
''' Mouse release event '''
if event.button() == Qt.LeftButton:
# Get the click
x = event.pos().x()
y = event.pos().y()
eventPoint = QPoint(x,y)
# Node layer
layer = self.canvas.currentLayer()
# Select node or arc
if layer.selectedFeatureCount() == 0:
# Snap to node
(retval,result) = self.snapper.snapToBackgroundLayers(eventPoint) #@UnusedVariable
# That's the snapped point
if result <> [] and (result[0].layer.name() == self.layer_node.name()):
point = QgsPoint(result[0].snappedVertex)
layer.select([result[0].snappedAtGeometry])
# Hide highlight
self.vertexMarker.hide()
# Set a new point to go on with
self.rubberBand.addPoint(point)
else:
# Snap to arc
(retval,result) = self.snapper.snapToBackgroundLayers(eventPoint) #@UnusedVariable
# That's the snapped point
if (result <> []) and (result[0].layer.name() == self.layer_arc.name()):
point = QgsPoint(result[0].snappedVertex)
# Get selected feature (at this moment it will have one and only one)
feature = layer.selectedFeatures()[0]
node_id = feature.attribute('node_id')
# Move selected node to the released point
self.move_node(node_id, point)
# Rubberband reset
self.reset()
# Refresh map canvas
self.iface.mapCanvas().refresh()
elif event.button() == Qt.RightButton:
self.reset()
class DeleteNodeMapTool(ParentMapTool):
''' Button 17. User select one node.
Execute SQL function: 'gw_fct_delete_node' '''
def __init__(self, iface, settings, action, index_action):
''' Class constructor '''
# Call ParentMapTool constructor
super(DeleteNodeMapTool, self).__init__(iface, settings, action, index_action)
# Vertex marker
self.vertexMarker = QgsVertexMarker(self.canvas)
self.vertexMarker.setColor(QColor(255, 25, 25))
self.vertexMarker.setIconSize(12)
self.vertexMarker.setIconType(QgsVertexMarker.ICON_CIRCLE) # or ICON_CROSS, ICON_X
self.vertexMarker.setPenWidth(5)
''' QgsMapTools inherited event functions '''
def canvasMoveEvent(self, event):
# Hide highlight
self.vertexMarker.hide()
# Get the click
x = event.pos().x()
y = event.pos().y()
eventPoint = QPoint(x, y)
# Snapping
(retval, result) = self.snapper.snapToBackgroundLayers(eventPoint) # @UnusedVariable
# That's the snapped point
if result <> []:
# Check Arc or Node
for snapPoint in result:
if snapPoint.layer.name() == self.layer_node.name():
# Get the point
point = QgsPoint(result[0].snappedVertex)
# Add marker
self.vertexMarker.setCenter(point)
self.vertexMarker.show()
break
def canvasReleaseEvent(self, event):
# With left click the digitizing is finished
if event.button() == Qt.LeftButton:
# Get the click
x = event.pos().x()
y = event.pos().y()
eventPoint = QPoint(x, y)
snappFeat = None
# Snapping
(retval, result) = self.snapper.snapToBackgroundLayers(eventPoint) # @UnusedVariable
# That's the snapped point
if result <> []:
# Check Arc or Node
for snapPoint in result:
if snapPoint.layer.name() == self.layer_node.name():
# Get the point
point = QgsPoint(result[0].snappedVertex)
snappFeat = next(
result[0].layer.getFeatures(QgsFeatureRequest().setFilterFid(result[0].snappedAtGeometry)))
break
if snappFeat is not None:
# Get selected features and layer type: 'node'
feature = snappFeat
node_id = feature.attribute('node_id')
# Execute SQL function and show result to the user
function_name = "gw_fct_delete_node"
sql = "SELECT " + self.schema_name + "." + function_name + "('" + str(node_id) + "');"
status = self.controller.execute_sql(sql)
if status:
message = "Node deleted successfully"
self.controller.show_warning(message, context_name='ui_message' )
# Refresh map canvas
self.iface.mapCanvas().refresh()
def activate(self):
# Check button
self.action().setChecked(True)
# Store user snapping configuration
self.snapperManager.storeSnappingOptions()
# Clear snapping
self.snapperManager.clearSnapping()
# Set snapping to node
self.snapperManager.snapToNode()
# Change cursor
self.canvas.setCursor(self.cursor)
# Show help message when action is activated
if self.show_help:
message = "Select the node inside a pipe by clicking on it and it will be removed"
self.controller.show_warning(message, context_name='ui_message')
# Control current layer (due to QGIS bug in snapping system)
try:
if self.canvas.currentLayer().type() == QgsMapLayer.VectorLayer:
self.canvas.setCurrentLayer(self.layer_node)
except:
self.canvas.setCurrentLayer(self.layer_node)
def deactivate(self):
# Check button
self.action().setChecked(False)
# Restore previous snapping
self.snapperManager.recoverSnappingOptions()
# Recover cursor
self.canvas.setCursor(self.stdCursor)
# Removehighlight
self.h = None
class LineMapTool(QgsMapTool):
def __init__(self, iface, settings, action, index_action):
''' Class constructor '''
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.settings = settings
self.index_action = index_action
self.elem_type_type = self.settings.value('insert_values/'+str(index_action)+'_elem_type_type')
QgsMapTool.__init__(self, self.canvas)
self.setAction(action)
# Set rubber band features
self.rubberBand = QgsRubberBand(self.canvas, QGis.Line)
mFillColor = QColor(255, 0, 0);
self.rubberBand.setColor(mFillColor)
self.rubberBand.setWidth(2)
self.reset()
# Vertex marker
self.vertexMarker = QgsVertexMarker(self.canvas)
self.vertexMarker.setColor(QColor(0, 255, 0))
self.vertexMarker.setIconSize(9)
self.vertexMarker.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.vertexMarker.setPenWidth(5)
# Snapper
self.snapper = QgsMapCanvasSnapper(self.canvas)
# Control button state
self.mCtrl = False
self.started = False
# Tracing options
self.firstTimeOnSegment = True
self.lastPointMustStay = False
self.lastPoint = None
# Change map tool cursor
self.cursor = QCursor()
self.cursor.setShape(Qt.CrossCursor)
self.parent().setCursor(self.cursor)
def keyPressEvent(self, event):
''' We need to know, if ctrl-key is pressed '''
if event.key() == Qt.Key_Control:
self.mCtrl = True
def keyReleaseEvent(self, event):
''' Ctrl-key is released '''
if event.key() == Qt.Key_Control:
self.mCtrl = False
# Remove the last added point when the delete key is pressed
if event.key() == Qt.Key_Backspace:
self.rubberBand.removeLastPoint()
def reset(self):
self.start_point = self.end_point = None
self.isEmittingPoint = False
self.rubberBand.reset(QGis.Line)
''' QgsMapTools inherited event functions '''
def canvasPressEvent(self, event):
''' On left click, we add a point '''
if event.button() == 1:
# layer = self.canvas.currentLayer()
layer = self.iface.activeLayer()
# Declare, that are we going to work
self.started = True
if layer <> None:
x = event.pos().x()
y = event.pos().y()
selPoint = QPoint(x,y)
# Check something snapped
(retval,result) = self.snapper.snapToBackgroundLayers(selPoint) #@UnusedVariable
# The point we want to have, is either from snapping result
if result <> []:
point = result[0].snappedVertex
# If we snapped something, it's either a vertex
if result[0].snappedVertexNr <> -1:
self.firstTimeOnSegment = True
# Or a point on a segment, so we have to declare, that a point on segment is found
else:
self.firstTimeOnSegment = False
# Or its some point from out in the wild
else:
point = QgsMapToPixel.toMapCoordinates(self.canvas.getCoordinateTransform(), x, y)
self.firstTimeOnSegment = True
# Bring the rubberband to the cursor i.e. the clicked point
self.rubberBand.movePoint(point)
# Set a new point to go on with
self.appendPoint(point)
# Try to remember that this point was on purpose i.e. clicked by the user
self.lastPointMustStay = True
self.firstTimeOnSegment = True
def canvasMoveEvent(self, event):
# Hide highlight
self.vertexMarker.hide()
# Get the click
x = event.pos().x()
y = event.pos().y()
eventPoint = QPoint(x,y)
# Snapping
(retval,result) = self.snapper.snapToBackgroundLayers(eventPoint) #@UnusedVariable
# That's the snapped point
if result <> []:
point = QgsPoint(result[0].snappedVertex)
# Add marker
self.vertexMarker.setCenter(point)
self.vertexMarker.show()
# Check tracing
if self.started:
# Only if the ctrl key is pressed
if self.mCtrl == True:
# So if we have found a snapping
if result <> []:
# If it is a vertex, not a point on a segment
if result[0].snappedVertexNr <> -1:
self.rubberBand.movePoint(point)
self.appendPoint(point)
self.lastPointMustStay = True
# The next point found, may be on a segment
self.firstTimeOnSegment = True
# We are on a segment
else:
self.rubberBand.movePoint(point)
# If we are on a new segment, we add the point in any case
if self.firstTimeOnSegment:
self.appendPoint(point)
self.lastPointMustStay = True
self.firstTimeOnSegment = False
# if we are not on a new segment, we have to test, if this point is really needed
else:
# but only if we have already enough points
if self.rubberBand.numberOfVertices() >=3:
num_vertexs = self.rubberBand.numberOfVertices()
lastRbP = self.rubberBand.getPoint(0, num_vertexs-2)
nextToLastRbP = self.rubberBand.getPoint(0, num_vertexs-3)
if not self.pointOnLine(lastRbP, nextToLastRbP, QgsPoint(point)):
self.appendPoint(point)
self.lastPointMustStay = False
else:
if not self.lastPointMustStay:
self.rubberBand.removeLastPoint()
self.rubberBand.movePoint(point)
else:
self.appendPoint(point)
self.lastPointMustStay = False
self.firstTimeOnSegment = False
else:
#if nothing specials happens, just update the rubberband to the cursor position
point = QgsMapToPixel.toMapCoordinates(self.canvas.getCoordinateTransform (), x, y)
self.rubberBand.movePoint(point)
else:
''' In "not-tracing" state, just update the rubberband to the cursor position
but we have still to snap to act like the "normal" digitize tool '''
if result <> []:
point = QgsPoint(result[0].snappedVertex)
# Add marker
self.vertexMarker.setCenter(point)
self.vertexMarker.show()
else:
point = QgsMapToPixel.toMapCoordinates(self.canvas.getCoordinateTransform(), x, y)
self.rubberBand.movePoint(point)
def canvasReleaseEvent(self, event):
''' With right click the digitizing is finished '''
if event.button() == 2:
# layer = self.canvas.currentLayer()
layer = self.iface.activeLayer()
x = event.pos().x()
y = event.pos().y()
if layer <> None and self.started == True:
selPoint = QPoint(x,y)
(retval,result) = self.snapper.snapToBackgroundLayers(selPoint) #@UnusedVariable
if result <> []:
point = result[0].snappedVertex #@UnusedVariable
else:
point = QgsMapToPixel.toMapCoordinates(self.canvas.getCoordinateTransform(), x, y) #@UnusedVariable
self.sendGeometry()
def appendPoint(self, point):
''' Don't add the point if it is identical to the last point we added '''
if not (self.lastPoint == point) :
self.rubberBand.addPoint(point)
self.lastPoint = QgsPoint(point)
else:
pass
def sendGeometry(self):
#layer = self.canvas.currentLayer()
layer = self.iface.activeLayer()
coords = []
self.rubberBand.removeLastPoint()
if QGis.QGIS_VERSION_INT >= 10700:
[coords.append(self.rubberBand.getPoint(0, i)) for i in range(self.rubberBand.numberOfVertices())]
else:
[coords.append(self.rubberBand.getPoint(0,i)) for i in range(1,self.rubberBand.numberOfVertices())]
# On the Fly reprojection, not necessary any more, mapToLayerCoordinates is clever enough on its own
#layerEPSG = layer.srs().epsg()
#projectEPSG = self.canvas.mapRenderer().destinationSrs().epsg()
#if layerEPSG != projectEPSG:
coords_tmp = coords[:]
coords = []
for point in coords_tmp:
transformedPoint = self.canvas.mapRenderer().mapToLayerCoordinates( layer, point );
coords.append(transformedPoint)
# Filter duplicated points
coords_tmp = coords[:]
coords = []
lastPt = None
for pt in coords_tmp:
if (lastPt <> pt) :
coords.append(pt)
lastPt = pt
# Add geometry to feature.
g = QgsGeometry().fromPolyline(coords)
self.rubberBand.reset(QGis.Line)
self.started = False
# Write the feature
self.createFeature(g)
def createFeature(self, geom):
# layer = self.canvas.currentLayer()
layer = self.iface.activeLayer()
provider = layer.dataProvider()
f = QgsFeature()
if (geom.isGeosValid()):
f.setGeometry(geom)
else:
reply = QMessageBox.question(self.iface.mainWindow(), 'Feature not valid',
"The geometry of the feature you just added isn't valid. Do you want to use it anyway?",
QMessageBox.Yes, QMessageBox.No)
if reply == QMessageBox.Yes:
f.setGeometry(geom)
else:
return False
# Add attribute fields to feature.
fields = layer.pendingFields()
try: #API-Break 1.8 vs. 2.0 handling
attr = f.initAttributes(len(fields)) #@UnusedVariable
for i in range(len(fields)):
f.setAttribute(i, provider.defaultValue(i))
except AttributeError: #<=1.8
# Add attributefields to feature.
for i in fields:
f.addAttribute(i, provider.defaultValue(i))
idx = layer.fieldNameIndex('epa_type')
f[idx] = self.elem_type_type
# Upload changes
layer.startEditing()
layer.addFeature(f)
# Control PostgreSQL exceptions
boolOk = layer.commitChanges()
# Update canvas
self.canvas.refresh()
# Capture edit exception
if boolOk:
# Spatial query to retrieve last added line, start searchingcandidates
cands = layer.getFeatures(QgsFeatureRequest().setFilterRect(f.geometry().boundingBox()))
# Iterate on candidates
for line_feature in cands:
if line_feature.geometry().equals(f.geometry()):
# Highlight
layer.setSelectedFeatures([line_feature.id()])
# Open form
self.iface.openFeatureForm(layer, line_feature)
break
else:
# Delete
layer.rollBack()
# User error
msg = "Error adding PIPE: Typically this occurs if\n the first point is not located in a existing\n node or feature is out of the defined sectors."
QMessageBox.information(None, "PostgreSQL error:", msg)
def activate(self):
self.canvas.setCursor(self.cursor)
def deactivate(self):
try:
self.rubberBand.reset(QGis.Line)
except AttributeError:
pass
class Result(object):
def __init__(self,iface,description=None,x=None,y=None,zoom=None,epsg=None):
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.description = unicode(description)
self.x = float(x)
self.y = float(y)
self.zoom = int(zoom)
self.epsg = int(epsg)
self.marker = QgsVertexMarker(self.canvas)
self.marker.setIconSize(20)
self.marker.setPenWidth(3)
self.marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.marker.setColor(QColor('green'))
self._active = False
self._visible = False
self._xtrans = None
self._ytrans = None
@property
def active(self):
return self._active
@active.setter
def active(self,value):
if value == True:
self._active = True
self.marker.setColor(QColor('red'))
self.marker.updateCanvas()
else:
self._active = False
self.marker.setColor(QColor('green'))
self.marker.updateCanvas()
@property
def visible(self):
return self._visible
@visible.setter
def visible(self,value):
if value == True:
if self.x is not None and self.y is not None:
self._visible = True
dest_crs = self.canvas.mapRenderer().destinationCrs()
src_crs = QgsCoordinateReferenceSystem()
src_crs.createFromEpsg(self.epsg)
transform = QgsCoordinateTransform(src_crs, dest_crs)
new_point = transform.transform(self.x, self.y)
self._xtrans = new_point.x()
self._ytrans = new_point.y()
self.marker.setCenter(new_point)
self.marker.show()
else:
self._visible = False
raise ValueError("Can't show marker without x and y coordinates.")
else:
self._visible = False
self.marker.hide()
def unload(self):
self.canvas.scene().removeItem(self.marker)
self.marker = None
def zoomTo(self):
if self._xtrans is not None and self._ytrans is not None:
r = QgsRectangle(self._xtrans,self._ytrans,self._xtrans,self._ytrans)
self.canvas.setExtent(r)
self.canvas.zoomScale(self.zoom)
self.canvas.refresh()
else:
raise ValueError("Point does not have x and y coordinates")
