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 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()
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)
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)
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 loadLines(self, lines, points, markers, suffix):
no = self.project.readEntry("TUVIEW", "lines{0}no".format(suffix))[0]
if no:
no = int(no)
for i in range(no):
a = self.project.readEntry("TUVIEW", 'lines{0}x{1}'.format(suffix, i))[0]
a = a.split('~~')
b = self.project.readEntry("TUVIEW", 'lines{0}y{1}'.format(suffix, i))[0]
b = b.split('~~')
points.clear()
for j in range(len(a)):
x = float(a[j])
y = float(b[j])
point = QgsPoint(x, y)
points.append(point)
if i + 1 == no:
marker = QgsVertexMarker(self.tuView.canvas)
if suffix == 'cs':
marker.setColor(Qt.red)
marker.setIconSize(10)
marker.setIconType(QgsVertexMarker.ICON_BOX)
else: # 'q'
marker.setColor(Qt.blue)
marker.setIconSize(12)
marker.setIconType(QgsVertexMarker.ICON_DOUBLE_TRIANGLE)
marker.setCenter(QgsPointXY(point))
markers.append(marker)
line = QgsRubberBand(self.tuView.canvas, False)
line.setWidth(2)
if suffix == 'cs':
line.setColor(QColor(Qt.red))
else: # 'q'
line.setColor(QColor(Qt.blue))
line.setToGeometry(QgsGeometry.fromPolyline(points), None)
lines.append(line)
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 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 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 _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 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 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
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 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 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 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 _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 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 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 _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 show(self):
# visualize lines
multiline = QgsGeometry().fromMultiPolylineXY(self.lines)
self.rb_line.setToGeometry(multiline, None)
# visualize points
for p in self.points:
marker = QgsVertexMarker(self.canvas)
marker.setCenter(p)
marker.setIconType(QgsVertexMarker.ICON_BOX)
marker.setColor(self.color)
marker.setVisible(True)
self.vertex_markers.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 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 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 add_marker(self, point):
"""
Adds a clicked marker to the map canvas.
:param point: point clicked by the user.
:type point: QgsPointXY
"""
new_marker = QgsVertexMarker(self.canvas)
new_marker.setCenter(point)
new_marker.setIconType(QgsVertexMarker.ICON_CROSS)
new_marker.setIconSize(10)
new_marker.setFillColor(QColor('#485bea'))
new_marker.setColor(QColor('#000000'))
self.markers.append(new_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 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(QgsPointXY(x,y))
m.setColor(QColor(255,255,0))
m.setIconSize(1)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(10)
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)
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)
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)
def loadPoints(self, points, markers):
a = self.project.readEntry("TUVIEW", "pointsx")[0]
if a:
a = a.split('~~')
b = self.project.readEntry("TUVIEW", "pointsy")[0]
b = b.split('~~')
for i in range(len(a)):
x = float(a[i])
y = float(b[i])
point = QgsPointXY(x, y)
points.append(point)
marker = QgsVertexMarker(self.tuView.canvas)
marker.setColor(Qt.red)
marker.setFillColor(Qt.red)
marker.setIconSize(10)
marker.setIconType(QgsVertexMarker.ICON_CIRCLE)
marker.setCenter(QgsPointXY(point))
markers.append(marker)
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 loadPoints(self, points, markers):
a = self.project.readEntry("TUVIEW", "pointsx")[0]
if a:
a = a.split('~~')
b = self.project.readEntry("TUVIEW", "pointsy")[0]
b = b.split('~~')
for i in range(len(a)):
x = float(a[i])
y = float(b[i])
point = QgsPoint(x, y)
points.append(point)
marker = QgsVertexMarker(self.tuView.canvas)
marker.setColor(Qt.red)
marker.setFillColor(Qt.red)
marker.setIconSize(10)
marker.setIconType(QgsVertexMarker.ICON_CIRCLE)
marker.setCenter(QgsPointXY(point))
markers.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 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 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 _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
"""
match = self.snap_point(event, False)
for marker in self.highlightedPoints:
self.canvas.scene().removeItem(marker)
self.highlightedPoints = []
if match.isValid():
marker = QgsVertexMarker(self.canvas)
marker.setCenter(match.point())
marker.setColor(QColor("#FFFF33"))
marker.setIconSize(10)
marker.setIconType(QgsVertexMarker.ICON_X)
marker.setPenWidth(2)
self.highlightedPoints.append(marker)
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 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 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")
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 MapToolIndentifyItems(QgsMapToolIdentify):
def __init__(self, plugin):
super(MapToolIndentifyItems, self).__init__(plugin.mapCanvas())
mToolName = self.tr('Identify feature')
self._menu = QMenu(plugin.mapCanvas())
self._menu.hovered.connect(self._highlight)
self._actions = []
self._highlights = []
self._plugin = plugin
self._vertexMarker = QgsVertexMarker(plugin.mapCanvas())
self._vertexMarker.setIconType(QgsVertexMarker.ICON_CROSS)
def collection(self):
return self._plugin.project().collection('plan')
def deactivate(self):
self._reset()
super(MapToolIndentifyItems, self).deactivate()
def canvasPressEvent(self, e):
self._reset()
def canvasReleaseEvent(self, e):
self._reset()
if e.button() != Qt.LeftButton:
return
mapPoint = self.toMapCoordinates(e.pos())
self._vertexMarker.setCenter(mapPoint)
layers = [self.collection().layer('points'), self.collection().layer('lines'),
self.collection().layer('polygons')]
results = self.identify(e.x(), e.y(), layers, QgsMapToolIdentify.TopDownAll)
if (len(results) < 1):
return
# Build the set of unique items identified
items = set()
for result in results:
feature = result.mFeature
siteCode = feature.attribute('site')
classCode = feature.attribute('class')
itemId = feature.attribute('id')
items.add(Item(siteCode, classCode, itemId))
action = QAction('Plan Items', self._menu)
action.setData('top')
self._menu.addAction(action)
site = ''
for item in sorted(items):
if item.siteCode() != site:
site = item.siteCode()
self._menu.addSeparator()
action = QAction('Site ' + site + ':', self._menu)
action.setData('top')
self._menu.addAction(action)
action = IdentifyItemAction(item, self._plugin, self._menu)
action.setData('top')
action.zoomToItemSelected.connect(self._zoom)
action.panToItemSelected.connect(self._pan)
action.filterItemSelected.connect(self._filterItem)
action.excludeFilterItemSelected.connect(self._excludeFilterItem)
action.highlightItemSelected.connect(self._highlightItem)
action.addHighlightItemSelected.connect(self._addHighlightItem)
action.editItemSelected.connect(self._editInBuffers)
action.deleteItemSelected.connect(self._delete)
action.openDrawingsSelected.connect(self._openDrawings)
self._actions.append(action)
self._menu.addAction(action)
self._menu.addSeparator()
action = ClipboardAction('Map: ', mapPoint.toString(3), self._menu)
action.setData('top')
self._menu.addAction(action)
if self._plugin.grid().mapTransformer is not None:
localPoint = self._plugin.grid().mapTransformer.map(mapPoint)
self._menu.addAction(ClipboardAction('Local: ', localPoint.toString(3), self._menu))
menuPos = QPoint(e.globalX() + 100, e.globalY() - 50)
selected = self._menu.exec_(menuPos)
self._reset(resetVertex=False)
def keyPressEvent(self, e):
if (e.key() == Qt.Key_Escape):
self._reset()
self.canvas().unsetMapTool(self)
def _reset(self, resetVertex=True):
self._menu.clear()
del self._highlights[:]
del self._actions[:]
if resetVertex and self._vertexMarker:
self._vertexMarker.setCenter(QgsPointV2())
def _highlight(self, item):
if item.data() == 'top':
del self._highlights[:]
else:
return
if not isinstance(item, IdentifyItemAction):
return
request = item.item.featureRequest()
for feature in self.collection().layer('polygons').getFeatures(request):
self._addHighlight(self._plugin.mapCanvas(), feature.geometry(), self.collection().layer('polygons'))
for feature in self.collection().layer('lines').getFeatures(request):
self._addHighlight(self._plugin.mapCanvas(), feature.geometry(), self.collection().layer('lines'))
for feature in self.collection().layer('points').getFeatures(request):
self._addHighlight(self._plugin.mapCanvas(), feature.geometry(), self.collection().layer('points'))
def _addHighlight(self, canvas, geometry, layer):
hl = QgsHighlight(canvas, geometry, layer)
color = QColor(QSettings().value('/Map/highlight/color', QGis.DEFAULT_HIGHLIGHT_COLOR.name(), str))
alpha = QSettings().value('/Map/highlight/colorAlpha', QGis.DEFAULT_HIGHLIGHT_COLOR.alpha(), int)
buff = QSettings().value('/Map/highlight/buffer', QGis.DEFAULT_HIGHLIGHT_BUFFER_MM, float)
minWidth = QSettings().value('/Map/highlight/minWidth', QGis.DEFAULT_HIGHLIGHT_MIN_WIDTH_MM, float)
hl.setColor(color)
color.setAlpha(alpha)
hl.setFillColor(color)
hl.setBuffer(buff)
hl.setMinWidth(minWidth)
self._highlights.append(hl)
def _zoom(self, item):
self.project().zoomToItem(item, highlight=True)
def _pan(self, item):
self.project().moveToItem(item, highlight=True)
def _filterItem(self, item):
self.project().filterItem(item)
def _excludeFilterItem(self, item):
self.project().excludeFilterItem(item)
def _highlightItem(self, item):
self.project().highlightItem(item)
def _addHighlightItem(self, item):
self.project().addHighlightItem(item)
def _openDrawings(self, item):
self.project().loadDrawing(item)
def _editInBuffers(self, item):
self.project().editInBuffers(item)
def _delete(self, item):
self.project().deleteItem(item)
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 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 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 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 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("")
