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("")