def updateDisplayedMarkers(self):
rowcnt = self.resultsTable.rowCount()
if self.showAllCheckBox.checkState():
for id in range(rowcnt):
item = self.resultsTable.item(id, 0).data(Qt.UserRole)
if item.marker is None:
item.marker = QgsVertexMarker(self.canvas)
pt = self.canvasPointXY(item.lat, item.lon)
item.marker.setCenter(pt)
item.marker.setIconSize(18)
item.marker.setPenWidth(2)
item.marker.setIconType(QgsVertexMarker.ICON_CROSS)
else: # Only selected rows will be displayed
indices = [
x.row()
for x in self.resultsTable.selectionModel().selectedRows()
]
for id in range(rowcnt):
item = self.resultsTable.item(id, 0).data(Qt.UserRole)
if id in indices:
if item.marker is None:
item.marker = QgsVertexMarker(self.canvas)
pt = self.canvasPointXY(item.lat, item.lon)
item.marker.setCenter(pt)
item.marker.setIconSize(18)
item.marker.setPenWidth(2)
item.marker.setIconType(QgsVertexMarker.ICON_CROSS)
elif item.marker is not None:
self.canvas.scene().removeItem(item.marker)
item.marker = None
def init_config_form(self):
''' Custom form initial configuration '''
# Set snapping
self.canvas = self.iface.mapCanvas()
self.emit_point = QgsMapToolEmitPoint(self.canvas)
self.canvas.setMapTool(self.emit_point)
self.snapper = QgsMapCanvasSnapper(self.canvas)
# Vertex marker
self.vertex_marker = QgsVertexMarker(self.canvas)
self.vertex_marker.setColor(QColor(255, 0, 255))
self.vertex_marker.setIconSize(11)
self.vertex_marker.setIconType(
QgsVertexMarker.ICON_CROSS) # or ICON_CROSS, ICON_X, ICON_BOX
self.vertex_marker.setPenWidth(3)
btn_orientation = self.dialog.findChild(QPushButton, "btn_orientation")
btn_orientation.clicked.connect(self.orientation)
self.set_icon(btn_orientation, "133")
btn_snapping = self.dialog.findChild(QPushButton, "btn_snapping")
btn_snapping.clicked.connect(self.snapping)
self.set_icon(btn_snapping, "129")
# Set layers dimensions, node and connec
self.layer_dimensions = self.controller.get_layer_by_tablename(
"v_edit_dimensions")
self.layer_node = self.controller.get_layer_by_tablename("v_edit_node")
self.layer_connec = self.controller.get_layer_by_tablename(
"v_edit_connec")
self.create_map_tips()
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 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 __init__(self, data_dock, params):
QgsMapTool.__init__(self, data_dock.iface.mapCanvas())
self.iface = data_dock.iface
""":type : QgisInterface"""
self.data_dock = data_dock
""":type : DataDock"""
self.params = params
self.elev = -1
self.vertex_marker = QgsVertexMarker(self.canvas())
self.rubber_band = QgsRubberBand(self.data_dock.iface.mapCanvas(),
QGis.Polygon)
self.mouse_clicked = False
self.snapper = None
self.clicked_pt = None
self.snap_results = None
self.adj_links_fts = None
self.selected_node_ft = None
self.selected_node_ft_lay = None
self.mouse_pt = None
self.layer_selft = {}
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 __init__(self, parentInstance):
self.parentInstance = parentInstance
self.iface = parentInstance.iface
self.mapCanvas = self.iface.mapCanvas()
self.lineOfSight = QgsRubberBand(self.mapCanvas,
QgsWkbTypes.LineGeometry)
self.sightDirection = QgsRubberBand(self.mapCanvas,
QgsWkbTypes.LineGeometry)
self.pointOfView = QgsVertexMarker(self.mapCanvas)
self.cursor = QgsVertexMarker(self.mapCanvas)
self.sightDirection.setColor(QColor(CURSOR_COLOR))
self.lineOfSight.setColor(QColor(CURSOR_COLOR))
self.pointOfView.setColor(QColor(CURSOR_COLOR))
self.cursor.setColor(QColor(CURSOR_COLOR))
self.lineOfSight.setWidth(2)
self.sightDirection.setWidth(1)
self.sightDirection.setLineStyle(Qt.DashLine)
self.pointOfView.setIconType(QgsRubberBand.ICON_CIRCLE)
self.cursor.setIconType(QgsRubberBand.ICON_CIRCLE)
self.pointOfView.setIconSize(20)
self.cursor.setIconSize(20)
self.cursor.setPenWidth(2)
self.pointOfView.setPenWidth(2)
self.samples_datasource = ''
self.delete()
def draw(self, rows, con, args, geomType, canvasItemList, mapCanvas):
''' draw the result '''
resultNodesVertexMarkers = canvasItemList['markers']
table = """%(edge_table)s_vertices_pgr""" % args
srid, geomType = Utils.getSridAndGeomType(con, table, 'the_geom')
Utils.setTransformQuotes(args, srid, args['canvas_srid'])
for row in rows:
cur2 = con.cursor()
if args['version'] < 2.1:
args['result_node_id'] = row[1]
args['result_edge_id'] = row[2]
args['result_cost'] = row[3]
else:
args['result_node_id'] = row[3]
args['result_edge_id'] = row[4]
args['result_cost'] = row[5]
query2 = """
SELECT ST_AsText(%(transform_s)s the_geom %(transform_e)s)
FROM %(edge_table)s_vertices_pgr
WHERE id = %(result_node_id)d
""" % args
cur2.execute(query2)
row2 = cur2.fetchone()
if (row2):
geom = QgsGeometry().fromWkt(str(row2[0]))
pt = geom.asPoint()
vertexMarker = QgsVertexMarker(mapCanvas)
vertexMarker.setColor(Qt.red)
vertexMarker.setPenWidth(2)
vertexMarker.setIconSize(5)
vertexMarker.setCenter(QgsPointXY(pt))
resultNodesVertexMarkers.append(vertexMarker)
def 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()
if settings.captureShowLocation:
if self.marker is None:
self.marker = QgsVertexMarker(self.canvas)
self.marker.setIconSize(18)
self.marker.setPenWidth(2)
self.marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.marker.setCenter(pt)
else:
self.removeMarker()
try:
msg = self.formatCoord(pt, self.settings.delimiter)
formatString = self.coordFormatString()
if msg is not None:
clipboard = QApplication.clipboard()
clipboard.setText(msg)
self.iface.messageBar().pushMessage(
"",
"{} coordinate {} copied to the clipboard".format(
formatString, msg),
level=Qgis.Info,
duration=4)
except Exception as e:
self.iface.messageBar().pushMessage(
"",
"Invalid coordinate: {}".format(e),
level=Qgis.Warning,
duration=4)
def canvasPressEvent(self, e):
'''
override, remember feature on click and move marker (create one if not
drawn yet)
'''
if self._picked_feature is None:
features = QgsMapToolIdentify(self.canvas).identify(
e.pos().x(),
e.pos().y(), self._layers,
QgsMapToolIdentify.TopDownStopAtFirst)
if len(features) == 0:
return
feature = features[0].mFeature
self._picked_feature = feature.id()
# there is a feature -> drag it
self._dragging = True
self.canvas.setCursor(self.drag_cursor)
# not marked yet -> mark position
if not self._marker:
color = QColor(0, 0, 255)
color.setAlpha(100)
self._marker = QgsVertexMarker(self.canvas)
self._marker.setColor(color)
self._marker.setIconSize(10)
self._marker.setIconType(QgsVertexMarker.ICON_CIRCLE)
self._marker.setPenWidth(10)
point = self.toMapCoordinates(e.pos())
self._marker.setCenter(point)
def action_rotation(self):
# Set map tool emit point and signals
self.emit_point = QgsMapToolEmitPoint(self.canvas)
self.canvas.setMapTool(self.emit_point)
self.snapper = QgsMapCanvasSnapper(self.canvas)
self.canvas.xyCoordinates.connect(self.action_rotation_mouse_move)
self.emit_point.canvasClicked.connect(
self.action_rotation_canvas_clicked)
# Store user snapping configuration
self.snapper_manager = SnappingConfigManager(self.iface)
self.snapper_manager.store_snapping_options()
# Clear snapping
self.snapper_manager.clear_snapping()
# Set snapping
layer = self.controller.get_layer_by_tablename("v_edit_arc")
self.snapper_manager.snap_to_layer(layer)
layer = self.controller.get_layer_by_tablename("v_edit_connec")
self.snapper_manager.snap_to_layer(layer)
layer = self.controller.get_layer_by_tablename("v_edit_node")
self.snapper_manager.snap_to_layer(layer)
# Set marker
color = QColor(255, 100, 255)
self.vertex_marker = QgsVertexMarker(self.canvas)
self.vertex_marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.vertex_marker.setColor(color)
self.vertex_marker.setIconSize(15)
self.vertex_marker.setPenWidth(3)
def __init__(self, data_dock, params):
QgsMapTool.__init__(self, data_dock.iface.mapCanvas())
self.iface = data_dock.iface
""":type : QgisInterface"""
self.data_dock = data_dock
""":type : DataDock"""
self.params = params
self.mouse_pt = None
self.mouse_clicked = False
self.first_click = False
self.rubber_band = QgsRubberBand(self.canvas(), False)
self.rubber_band.setColor(QColor(255, 128, 128))
self.rubber_band.setWidth(1)
self.rubber_band.setBrushStyle(Qt.Dense4Pattern)
self.rubber_band.reset()
self.snapper = None
self.snapped_feat_id = None
self.snapped_vertex = None
self.snapped_vertex_nr = None
self.vertex_marker = QgsVertexMarker(self.canvas())
self.elev = None
self.diameter_dialog = None
def __init__(self, iface, action, plugin_dir, spinbox):
self.canvas = iface.mapCanvas()
self.iface = iface
self.action = action
self.icon_path = os.path.join(plugin_dir,"icons")
self.spinbox = spinbox
self.rubberBand = QgsRubberBand(self.canvas, QgsWkbTypes.GeometryType(3))
self.rubberBand.setWidth(3)
self.rubberBand.setStrokeColor(QColor(254,0,0))
self.snap_mark = QgsVertexMarker(self.canvas)
self.snap_mark.setColor(QColor(0, 0, 255))
self.snap_mark.setPenWidth(2)
self.snap_mark.setIconType(QgsVertexMarker.ICON_BOX)
self.snap_mark.setIconSize(10)
QgsMapToolIdentify.__init__(self, self.canvas)
self.selectFeatureMode = True
self.firstPointMode = False
self.secondPointMode = False
self.objectSizeMode = False
self.firstPoint_locate = None
self.linestring = None
self.dist = self.spinbox.value()
self.canvas.layersChanged.connect(self.setPolygonLayers)
def __init__(self, button, iface, projectDirectory, netwName, parent):
QgsMapTool.__init__(self, iface.mapCanvas())
self.iface = iface
self.ProjectDirectory = projectDirectory
self.NetworkName = netwName
self.parent = parent
self.setAction(button)
self.startMarker = QgsVertexMarker(self.iface.mapCanvas())
self.startMarker.setColor(QColor(255, 87, 51))
self.startMarker.setIconSize(15)
self.startMarker.setIconType(
QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.startMarker.setPenWidth(3)
self.startMarker.hide()
self.endMarker = QgsVertexMarker(self.iface.mapCanvas())
self.endMarker.setColor(QColor(255, 87, 51))
self.endMarker.setIconSize(15)
self.endMarker.setIconType(
QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.endMarker.setPenWidth(3)
self.endMarker.hide()
self.snapper = None
self.rubberBand1 = None
self.rubberBand2 = None
self.resetProperties()
def __init__(self, button, iface, projectDirectory, netwName):
QgsMapTool.__init__(self, iface.mapCanvas())
self.iface = iface
self.ProjectDirectory = projectDirectory
self.NetworkName = netwName
self.toolbarButton = button
self.snapper = None
self.vertexMarker = QgsVertexMarker(self.iface.mapCanvas())
self.vertexMarker.setColor(QColor(255, 87, 51))
self.vertexMarker.setIconSize(15)
self.vertexMarker.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.vertexMarker.setPenWidth(3)
self.vertexMarker.hide()
self.mouseClicked = False
self.clickedPoint = None
self.objectSnapped = None
self.selectedFeature = None
self.selectedLayer = None
self.newPositionVector = QgsVector(0, 0)
self.rubberBand = None
self.newVertexMarker = QgsVertexMarker(self.iface.mapCanvas())
self.newVertexMarker.setColor(QColor(55, 198, 5))
self.newVertexMarker.setIconSize(15)
self.newVertexMarker.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.newVertexMarker.setPenWidth(3)
self.newVertexMarker.hide()
def mouse_move(self, event):
_, match = self.snap(event)
# snap indicator
if not match.isValid():
if self.snapping_marker is not None:
self.iface.mapCanvas().scene().removeItem(self.snapping_marker)
self.snapping_marker = None
return
# TODO QGIS 3: see if vertices can be removed
# we have a valid match
if self.snapping_marker is None:
self.snapping_marker = QgsVertexMarker(self.iface.mapCanvas())
self.snapping_marker.setPenWidth(3)
self.snapping_marker.setColor(QColor(Qt.magenta))
if match.hasVertex():
if match.layer():
icon_type = QgsVertexMarker.ICON_BOX # vertex snap
else:
icon_type = QgsVertexMarker.ICON_X # intersection snap
else:
icon_type = QgsVertexMarker.ICON_DOUBLE_TRIANGLE # must be segment snap
self.snapping_marker.setIconType(icon_type)
self.snapping_marker.setCenter(match.point())
def setPointer(self, point):
self.removePointer()
self.pointer = QgsVertexMarker(self.iface.mapCanvas())
self.pointer.setColor(QColor(255, 255, 0))
self.pointer.setIconSize(10)
self.pointer.setPenWidth(5)
self.pointer.setCenter(point)
def __init__(self, data_dock, params):
QgsMapTool.__init__(self, data_dock.iface.mapCanvas())
self.iface = data_dock.iface
""":type : QgisInterface"""
self.data_dock = data_dock
""":type : DataDock"""
self.params = params
self.elev = -1
self.vertex_marker = QgsVertexMarker(self.canvas())
# Stroke
self.rubber_band = QgsRubberBand(self.data_dock.iface.mapCanvas())
self.rubber_band.setColor(QColor(255, 0, 0, 255))
self.rubber_band.setWidth(2)
self.mouse_clicked = False
self.snapper = None
self.clicked_pt = None
self.snap_results = None
self.adj_links_fts = None
self.selected_node_ft = None
self.selected_node_ft_lay = None
self.mouse_pt = None
self.pump_valve_selected = False
self.pump_or_valve = None
self.pump_valve_ft = None
self.adj_junctions = None
self.delta_vec = None
self.adj_pipes_fts_d = {}
def selection_start(self):
self.is_selecting = True
self.dlg.rdb_layers_active.setEnabled(False)
self.dlg.rdb_layers_all.setEnabled(False)
self.emit_point = QgsMapToolEmitPoint(self.canvas)
self.canvas.setMapTool(self.emit_point)
# Snapper
self.snapper_manager = snap_manager.GwSnapManager(self.iface)
self.snapper = self.snapper_manager.get_snapper()
# Vertex marker
self.vertex_marker = QgsVertexMarker(self.canvas)
self.vertex_marker.setColor(QColor(255, 100, 255))
self.vertex_marker.setIconSize(15)
self.vertex_marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.vertex_marker.setPenWidth(3)
# Store user snapping configuration
self.previous_snapping = self.snapper_manager.get_snapping_options()
if self.selection_type == SelectionType.ACTIVE:
tools_log.log_info("single selector")
self.activate_snapping(self.emit_point)
elif self.selection_type == SelectionType.ALL:
tools_log.log_info("all selector")
# Store user snapping configuration
if tools_qt.is_checked(self.dlg, self.dlg.chk_layer_arc) or \
tools_qt.is_checked(self.dlg, self.dlg.chk_layer_connec) or \
tools_qt.is_checked(self.dlg, self.dlg.chk_layer_node):
self.set_user_config()
self.activate_snapping(self.emit_point)
def __init__(self, canvas, iface):
QgsMapToolEmitPoint.__init__(self, canvas)
# qgis interface
self.canvas = canvas
self.iface = iface
# snap marker
self.snap_mark = QgsVertexMarker(self.canvas)
self.snap_mark.setColor(QColor(0, 0, 255))
self.snap_mark.setPenWidth(2)
self.snap_mark.setIconType(QgsVertexMarker.ICON_BOX)
self.snap_mark.setIconSize(10)
# rectangle
self.rubberBand = QgsRubberBand(self.canvas,
QgsWkbTypes.GeometryType(3))
self.rubberBand.setWidth(3)
self.rubberBand.setStrokeColor(QColor(254, 0, 0))
# initialize variable
self.rubberBand_width = 0
self.rubberBand_height = 0
self.rubberBand_angle = 0
self.reset()
def zoomToPressed(self):
try:
'''We convert the w3w address into a EPSG:4326 coord'''
w3wCoord = str(self.coordBox.text()).replace(" ", "")
json = self.w3w.forwardGeocode(w3wCoord)
lat = float(json["geometry"]["lat"])
lon = float(json["geometry"]["lng"])
'''
We convert the 4326 coord into a coord in the CRS of the canvas
'''
canvasCrs = self.canvas.mapSettings().destinationCrs()
epsg4326 = QgsCoordinateReferenceSystem("EPSG:4326")
transform4326 = QgsCoordinateTransform(epsg4326, canvasCrs)
center = transform4326.transform(lon, lat)
'''We zoom to that coord and set a marker'''
self.canvas.zoomByFactor(1, center)
self.canvas.refresh()
if self.marker is None:
self.marker = QgsVertexMarker(self.canvas)
self.marker.setCenter(center)
self.marker.setIconSize(8)
self.marker.setPenWidth(4)
'''Allow user to remove marker'''
self.removeMarkerButton.setDisabled(False)
self.coordBox.setStyleSheet("QLineEdit{background: white}")
except Exception as e:
self.coordBox.setStyleSheet("QLineEdit{background: yellow}")
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 = ""
locale = QSettings().value("locale/userLocale").toString()[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 canvasMoveEvent(self, event):
if self.rb:
self.canvas.scene().removeItem(self.rb)
if self.vx:
self.canvas.scene().removeItem(self.vx)
layerPoint = self.toLayerCoordinates(self.layer, event.pos())
(closestPointID,
closestFeature) = finder.closestpoint(self.layer, layerPoint)
polyline = closestFeature.geometry().asPolyline()
shortestDistance = QgsGeometry.fromPointXY(
polyline[closestPointID]).distance(
QgsGeometry.fromPointXY(layerPoint))
if closestPointID and shortestDistance < self.threshold:
self.rb = QgsRubberBand(self.canvas, False)
linePart = polyline[closestPointID - 1:closestPointID + 2]
self.rb.setToGeometry(QgsGeometry.fromPolylineXY(linePart), None)
self.rb.setColor(QColor(0, 0, 255))
self.rb.setWidth(3)
self.vx = QgsVertexMarker(self.canvas)
self.vx.setCenter(QgsPointXY(polyline[closestPointID]))
self.vx.setColor(QColor(0, 255, 0))
self.vx.setIconSize(5)
self.vx.setIconType(
QgsVertexMarker.ICON_X) # or ICON_CROSS, ICON_BOX
self.vx.setPenWidth(3)
def clicked(self, pt, b):
'''Capture the coordinate when the mouse button has been released,
format it, and copy it to the clipboard.'''
if settings.externalMapShowLocation:
if self.marker is None:
self.marker = QgsVertexMarker(self.canvas)
self.marker.setIconSize(18)
self.marker.setPenWidth(2)
self.marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.marker.setCenter(pt)
else:
self.removeMarker()
canvasCRS = self.canvas.mapSettings().destinationCrs()
transform = QgsCoordinateTransform(canvasCRS, epsg4326,
QgsProject.instance())
pt4326 = transform.transform(pt.x(), pt.y())
lat = pt4326.y()
lon = pt4326.x()
if settings.googleEarthMapProvider():
f = tempfile.NamedTemporaryFile(mode='w',
suffix=".kml",
delete=False)
f.write('<?xml version="1.0" encoding="UTF-8"?>')
f.write(
'<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2" xmlns:kml="http://www.opengis.net/kml/2.2" xmlns:atom="http://www.w3.org/2005/Atom">'
)
f.write('<Document>')
f.write(' <name>QGIS Location</name>')
f.write(' <description>{:.8f}, {:.8f}</description>'.format(
lon, lat))
f.write(' <Placemark>')
f.write(' <name>QGIS Location</name>')
f.write(' <Point>')
f.write(
' <coordinates>{:.8f},{:.8f},0</coordinates>'.format(
lon, lat))
f.write(' </Point>')
f.write(' </Placemark>')
f.write('</Document>')
f.write('</kml>')
f.close()
if platform.system() == 'Windows':
os.startfile(f.name)
else:
webbrowser.open(f.name)
self.iface.messageBar().pushMessage(
"",
"Viewing Coordinate %f,%f in Google Earth" % (lat, lon),
level=Qgis.Info,
duration=3)
else:
mapprovider = settings.getMapProviderString(lat, lon)
url = QUrl(mapprovider).toString()
webbrowser.open(url, new=2)
self.iface.messageBar().pushMessage(
"",
"Viewing Coordinate %f,%f in external map" % (lat, lon),
level=Qgis.Info,
duration=3)
def __init__(self, iface, controller, group):
""" Class constructor """
self.group_layers = group
self.iface = iface
self.canvas = self.iface.mapCanvas()
# Call superclass constructor and set current action
QgsMapTool.__init__(self, self.canvas)
self.controller = controller
self.rubber_band = QgsRubberBand(self.canvas, QGis.Polygon)
mFillColor = QColor(254, 178, 76, 63)
self.rubber_band.setColor(mFillColor)
self.rubber_band.setWidth(1)
self.reset()
self.snapper = QgsMapCanvasSnapper(self.canvas)
self.selected_features = []
# Vertex marker
self.vertex_marker = QgsVertexMarker(self.canvas)
self.vertex_marker.setColor(QColor(255, 0, 255))
self.vertex_marker.setIconSize(11)
self.vertex_marker.setIconType(
QgsVertexMarker.ICON_CROSS) # or ICON_CROSS, ICON_X, ICON_BOX
self.vertex_marker.setPenWidth(3)
def __init__(self, data_dock, params):
QgsMapTool.__init__(self, data_dock.iface.mapCanvas())
self.iface = data_dock.iface
""":type : QgisInterface"""
self.dock_widget = data_dock
""":type : DataDock"""
self.params = params
self.elev = None
self.vertex_marker = QgsVertexMarker(self.canvas())
self.mouse_clicked = False
self.snapper = None
self.clicked_pt = None
self.snap_results = None
self.selected_node_ft = None
self.selected_node_ft_lay = None
self.mouse_pt = None
self.pump_valve_selected = False
self.pump_or_valve = None
self.pump_valve_ft = None
self.adj_links_fts = None
self.adj_junctions = None
self.delta_vec = QgsVector(0, 0)
self.adj_links_fts_d = {}
# self.rubber_bands_d = {}
# self.rubber_bands_geoms_d = {}
self.rubber_band = None
self.logger = logging.getLogger('Logger1')
def __init__(self, iface, controller):
""" Class constructor """
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.controller = controller
# Call superclass constructor and set current action
QgsMapTool.__init__(self, self.canvas)
self.dragging = False
# Vertex marker
color = QColor(255, 100, 255)
self.vertex_marker = QgsVertexMarker(self.canvas)
self.vertex_marker.setIconType(QgsVertexMarker.ICON_CIRCLE)
self.vertex_marker.setColor(color)
self.vertex_marker.setIconSize(15)
self.vertex_marker.setPenWidth(3)
# Rubber band
self.rubber_band = QgsRubberBand(self.canvas, QGis.Line)
self.rubber_band.setColor(color)
self.rubber_band.setWidth(1)
# Select rectangle
self.select_rect = QRect()
# TODO: Parametrize
self.connec_group = ["Wjoin", "Tap", "Fountain", "Greentap"]
#self.snapperManager = SnappingConfigManager(self.iface)
self.snapper = QgsMapCanvasSnapper(self.canvas)
def add_point(self):
""" Create the appropriate map tool and connect to the corresponding signal """
active_layer = self.iface.activeLayer()
if active_layer is None:
active_layer = self.controller.get_layer_by_tablename('version')
self.iface.setActiveLayer(active_layer)
# Vertex marker
self.vertex_marker = QgsVertexMarker(self.canvas)
self.vertex_marker.setColor(QColor(255, 100, 255))
self.vertex_marker.setIconSize(15)
self.vertex_marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.vertex_marker.setPenWidth(3)
# Snapper
if self.snapper_manager is None:
self.snapper_manager = SnappingConfigManager(self.iface)
self.snapper = self.snapper_manager.get_snapper()
if self.snapper_manager.controller is None:
self.snapper_manager.set_controller(self.controller)
self.emit_point = QgsMapToolEmitPoint(self.canvas)
self.previous_map_tool = self.canvas.mapTool()
self.canvas.setMapTool(self.emit_point)
self.canvas.xyCoordinates.connect(self.mouse_move)
self.xyCoordinates_conected = True
self.emit_point.canvasClicked.connect(partial(self.get_xy))
def zoomToPressed(self):
try:
w3wCoord = str(self.coordBox.text()).replace(" ", "")
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
json = self.w3w.forwardGeocode(w3wCoord)
lat = float(json["geometry"]["lat"])
lon = float(json["geometry"]["lng"])
canvasCrs = self.canvas.mapSettings().destinationCrs()
epsg4326 = QgsCoordinateReferenceSystem("EPSG:4326")
transform4326 = QgsCoordinateTransform(epsg4326, canvasCrs, QgsProject.instance())
center = transform4326.transform(lon, lat)
self.canvas.zoomByFactor(1, center)
self.canvas.refresh()
if self.marker is None:
self.marker = QgsVertexMarker(self.canvas)
self.marker.setCenter(center)
self.marker.setIconSize(8)
self.marker.setPenWidth(4)
self.removeMarkerButton.setDisabled(False)
self.coordBox.setStyleSheet("QLineEdit{background: white}")
except Exception as e:
raise
self.coordBox.setStyleSheet("QLineEdit{background: yellow}")
finally:
QApplication.restoreOverrideCursor()
def AdjNxtWpt(self):
if self.WptVertexSignal == True:
self.iface.mapCanvas().scene().removeItem(self.WptVertex)
del self.WptVertex
self.WptVertexSignal = False
if self.NxtWptRubber == True:
self.iface.mapCanvas().scene().removeItem(self.rdue)
del self.rdue
self.iface.mapCanvas().scene().removeItem(self.rtre)
del self.rtre
self.NxtWptRubber = False
canvas = self.iface.mapCanvas()
mapRenderer = canvas.mapRenderer()
crsSrc = QgsCoordinateReferenceSystem(4326) # NMEA is in WGS 84
crsDest = mapRenderer.destinationCrs()
xform = QgsCoordinateTransform(crsSrc, crsDest)
WptValue = int(self.lcdNumberWpt.value())
try:
Wpt = self.pts[WptValue - 1]
except IndexError:
return
self.WptVertex = QgsVertexMarker(self.iface.mapCanvas())
self.WptVertex.setIconSize(20)
self.WptVertex.setIconType(QgsVertexMarker.ICON_X)
self.WptVertex.setPenWidth(20)
self.WptVertex.setCenter(xform.transform(Wpt))
self.WptVertexSignal = True
if WptValue != 1:
Wpt2 = self.pts[WptValue - 2]
self.rdue = QgsRubberBand(self.iface.mapCanvas(),
False) # False = not a polygon
pointsdue = [xform.transform(Wpt), xform.transform(Wpt2)]
self.rdue.setColor(QtGui.QColor(255, 0, 0))
self.rdue.setWidth(8)
self.rdue.setLineStyle(QtCore.Qt.PenStyle(QtCore.Qt.DotLine))
self.rdue.setToGeometry(QgsGeometry.fromPolyline(pointsdue),
None) #creation of NextWayPoint rubberband
self.rtre = QgsRubberBand(self.iface.mapCanvas(), False)
pointstre = self.pts[0:WptValue - 1]
for i in xrange(len(pointstre)):
pointstre[i] = xform.transform(pointstre[i])
self.rtre.setColor(QtGui.QColor(127, 0, 255))
self.rtre.setWidth(8)
self.rtre.setLineStyle(QtCore.Qt.PenStyle(QtCore.Qt.DotLine))
self.rtre.setToGeometry(QgsGeometry.fromPolyline(pointstre), None)
self.NxtWptRubber = True
def __init__(self, iface, action, geometryClass):
self.canvas = iface.mapCanvas()
self.iface = iface
self.action = action
self.geometryClass = geometryClass
obj_color = QColor(254, 0, 0)
obj_color_alpha = QColor(254, 0, 0)
obj_color_alpha.setAlpha(60)
vert_color = QColor(0, 0, 255)
QgsMapTool.__init__(self, self.canvas)
self.rubberBand = QgsRubberBand(self.canvas,
QgsWkbTypes.GeometryType(3))
self.rubberBand.setWidth(1)
self.rubberBand.setStrokeColor(obj_color)
self.rubberBand.setFillColor(obj_color_alpha)
self.rubberBand_click = QgsRubberBand(self.canvas,
QgsWkbTypes.GeometryType(3))
self.rubberBand_click.setWidth(0)
self.rubberBand_click.setFillColor(obj_color_alpha)
# snap marker
self.snap_mark = QgsVertexMarker(self.canvas)
self.snap_mark.setColor(vert_color)
self.snap_mark.setPenWidth(2)
self.snap_mark.setIconType(QgsVertexMarker.ICON_BOX)
self.snap_mark.setIconSize(10)
self.points = []
def addVertex(self, pt):
self.rubberBand.addPoint(pt)
m = QgsVertexMarker(self.canvas)
m.setCenter(pt)
self.vertexMarkers.append(m)
#if self.yx: pt = QgsPoint(pt.y(),pt.x())
self.captureList.append (pt)
return len(self.captureList)
def draw(self, rows, con, args, geomType, canvasItemList, mapCanvas):
''' draw the result '''
resultNodesVertexMarkers = canvasItemList['markers']
schema = """%(edge_schema)s""" % args
table = """%(edge_table)s_vertices_pgr""" % args
srid, geomType = Utils.getSridAndGeomType(con, schema, table, 'the_geom')
Utils.setTransformQuotes(args, srid, args['canvas_srid'])
for row in rows:
cur2 = con.cursor()
if args['version'] < 2.1:
args['result_node_id'] = row[1]
args['result_edge_id'] = row[2]
args['result_cost'] = row[3]
else:
args['result_node_id'] = row[3]
args['result_edge_id'] = row[4]
args['result_cost'] = row[5]
query2 = sql.SQL("""
SELECT ST_AsText(%(transform_s)s the_geom %(transform_e)s)
FROM %(edge_table)s_vertices_pgr
WHERE id = %(result_node_id)d
""").format(**args)
cur2.execute(query2)
row2 = cur2.fetchone()
if (row2):
geom = QgsGeometry().fromWkt(str(row2[0]))
pt = geom.asPoint()
vertexMarker = QgsVertexMarker(mapCanvas)
vertexMarker.setColor(Qt.red)
vertexMarker.setPenWidth(2)
vertexMarker.setIconSize(5)
vertexMarker.setCenter(QgsPointXY(pt))
resultNodesVertexMarkers.append(vertexMarker)
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
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 _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 __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 clicked(self, pt, b):
'''Capture the coordinate when the mouse button has been released,
format it, and copy it to the clipboard.'''
if settings.captureShowLocation:
if self.marker is None:
self.marker = QgsVertexMarker(self.canvas)
self.marker.setIconSize(18)
self.marker.setPenWidth(2)
self.marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.marker.setCenter(pt)
else:
self.removeMarker();
try:
if self.capture4326:
canvasCRS = self.canvas.mapSettings().destinationCrs()
transform = QgsCoordinateTransform(canvasCRS, epsg4326, QgsProject.instance())
pt4326 = transform.transform(pt.x(), pt.y())
self.capturesig.emit(pt4326)
return
msg = self.formatCoord(pt, self.settings.delimiter)
formatString = self.coordFormatString()
if msg != None:
clipboard = QApplication.clipboard()
clipboard.setText(msg)
self.iface.messageBar().pushMessage("", "{} coordinate {} copied to the clipboard".format(formatString, msg), level=Qgis.Info, duration=4)
except Exception as e:
self.iface.messageBar().pushMessage("", "Invalid coordinate: {}".format(e), level=Qgis.Warning, duration=4)
def __init__(self, iface, settings, action, index_action):
""" Class constructor """
# Call ParentMapTool constructor
super(ExtractRasterValue, self).__init__(iface, settings, action, index_action)
self.dragging = False
# 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)
# Rubber band
self.rubberBand = QgsRubberBand(self.canvas, True)
mFillColor = QColor(100, 0, 0)
self.rubberBand.setColor(mFillColor)
self.rubberBand.setWidth(3)
mBorderColor = QColor(254, 58, 29)
self.rubberBand.setBorderColor(mBorderColor)
# Select rectangle
self.selectRect = QRect()
# Init
self.vectorLayer = None
self.rasterLayer = None
def startCapturing(self):
self.clearScene()
self.rubberBand = QgsRubberBand(self.canvas, QGis.Polygon)
self.rubberBand.setWidth(2)
self.rubberBand.setFillColor(QColor(220, 0, 0, 120))
self.rubberBand.setBorderColor(QColor(220, 0, 0))
self.rubberBand.setLineStyle(Qt.DotLine)
self.rubberBand.show()
self.tempRubberBand = QgsRubberBand(self.canvas, QGis.Polygon)
self.tempRubberBand.setWidth(2)
self.tempRubberBand.setFillColor(QColor(0, 0, 0, 0))
self.tempRubberBand.setBorderColor(QColor(220, 0, 0))
self.tempRubberBand.setLineStyle(Qt.DotLine)
self.tempRubberBand.show()
self.vertexMarker = QgsVertexMarker(self.canvas)
self.vertexMarker.setIconType(1)
self.vertexMarker.setColor(QColor(220, 0, 0))
self.vertexMarker.setIconSize(16)
self.vertexMarker.setPenWidth(3)
self.vertexMarker.show()
self.capturing = 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 _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 __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 = ""
locale = QSettings().value("locale/userLocale").toString()[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 setPointer(self, point):
self.removePointer()
self.pointer = QgsVertexMarker(self.iface.mapCanvas())
self.pointer.setColor(QColor(255, 255, 0))
self.pointer.setIconSize(10)
self.pointer.setPenWidth(5)
self.pointer.setCenter(point)
def clicked_end_b(self, point):
self.end_b = self.clickTool.toMapCoordinates(self.clickTool.toCanvasCoordinates(point))
self.vm_eb = QgsVertexMarker(self.canvas)
self.vm_eb.setCenter(point)
self.lineEdit_eb.setText("%s, %s" % (str(round(self.end_b.x(), 3)),
str(round(self.end_b.y(), 3))))
self.clickTool.deactivate()
self.show()
def adj_clicked_start_b(self, point):
self.adj_start_b = self.clickTool.toMapCoordinates(self.clickTool.toCanvasCoordinates(point))
self.adj_lineEditB.setText("%s, %s" % (str(round(self.adj_start_b.x(), 3)),
str(round(self.adj_start_b.y(), 3))))
self.vm_sb = QgsVertexMarker(self.canvas)
self.vm_sb.setCenter(point)
self.clickTool.deactivate()
self.show()
def clicked_start_a(self, point):
self.start_a = self.clickTool.toMapCoordinates(self.clickTool.toCanvasCoordinates(point))
self.vm_sa = QgsVertexMarker(self.canvas)
self.vm_sa.setCenter(point)
self.lineEdit_sa.setText("%s, %s" % (str(round(self.start_a.x(), 3)),
str(round(self.start_a.y(), 3))))
self.clickTool.deactivate()
self.show()
def __loadRubber(self):
"""
To load te rubber band for mouse tracking on map
"""
self.__marker = QgsVertexMarker(self.__canvas)
self.__marker.setIconSize(5)
self.__marker.setIconType(QgsVertexMarker.ICON_BOX)
self.__marker.setPenWidth(3)
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 __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 __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)
def update_canvas(self, point):
"""Update the canvas and add vertex marker.
:param point:
:return: None
"""
x, y = point
scale = 120
rect = QgsRectangle(float(x) - scale, float(y) - scale, float(x) + scale, float(y) + scale)
self.canvas.setExtent(rect)
self.marker = QgsVertexMarker(self.canvas)
self.marker.setIconSize(15)
self.marker.setPenWidth(2)
self.marker.setCenter(QgsPointXY(int(x), int(y)))
self.canvas.refresh()
self.canvas.extentsChanged.connect(self.remove_marker)
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
def clicked(self, pt, b):
'''Capture the coordinate when the mouse button has been released,
format it, and copy it to the clipboard.'''
if settings.externalMapShowLocation:
if self.marker is None:
self.marker = QgsVertexMarker(self.canvas)
self.marker.setIconSize(18)
self.marker.setPenWidth(2)
self.marker.setIconType(QgsVertexMarker.ICON_CROSS)
self.marker.setCenter(pt)
else:
self.removeMarker();
canvasCRS = self.canvas.mapSettings().destinationCrs()
transform = QgsCoordinateTransform(canvasCRS, epsg4326, QgsProject.instance())
pt4326 = transform.transform(pt.x(), pt.y())
lat = pt4326.y()
lon = pt4326.x()
if settings.googleEarthMapProvider():
f = tempfile.NamedTemporaryFile(mode='w', suffix=".kml", delete=False)
f.write('<?xml version="1.0" encoding="UTF-8"?>')
f.write('<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2" xmlns:kml="http://www.opengis.net/kml/2.2" xmlns:atom="http://www.w3.org/2005/Atom">')
f.write('<Document>')
f.write(' <name>QGIS Location</name>')
f.write(' <description>{:.8f}, {:.8f}</description>'.format(lon, lat))
f.write(' <Placemark>')
f.write(' <name>QGIS Location</name>')
f.write(' <Point>')
f.write(' <coordinates>{:.8f},{:.8f},0</coordinates>'.format(lon, lat))
f.write(' </Point>')
f.write(' </Placemark>')
f.write('</Document>')
f.write('</kml>')
f.close()
if platform.system() == 'Windows':
os.startfile(f.name)
else:
webbrowser.open(f.name)
self.iface.messageBar().pushMessage("", "Viewing Coordinate %f,%f in Google Earth" % (lat, lon), level=Qgis.Info, duration=3)
else:
mapprovider = settings.getMapProviderString(lat, lon)
url = QUrl(mapprovider).toString()
webbrowser.open(url, new=2)
self.iface.messageBar().pushMessage("", "Viewing Coordinate %f,%f in external map" % (lat, lon), level=Qgis.Info, duration=3)
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 __init__(self, iface, settings, action, index_action):
''' Class constructor '''
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.settings = settings
self.index_action = index_action
self.elem_type_type = self.settings.value('insert_values/'+str(index_action)+'_elem_type_type')
QgsMapTool.__init__(self, self.canvas)
self.setAction(action)
# Set rubber band features
self.rubberBand = QgsRubberBand(self.canvas, QGis.Line)
mFillColor = QColor(255, 0, 0);
self.rubberBand.setColor(mFillColor)
self.rubberBand.setWidth(2)
self.reset()
# Vertex marker
self.vertexMarker = QgsVertexMarker(self.canvas)
self.vertexMarker.setColor(QColor(0, 255, 0))
self.vertexMarker.setIconSize(9)
self.vertexMarker.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
self.vertexMarker.setPenWidth(5)
# Snapper
self.snapper = QgsMapCanvasSnapper(self.canvas)
# Control button state
self.mCtrl = False
self.started = False
# Tracing options
self.firstTimeOnSegment = True
self.lastPointMustStay = False
self.lastPoint = None
# Change map tool cursor
self.cursor = QCursor()
self.cursor.setShape(Qt.CrossCursor)
self.parent().setCursor(self.cursor)
class MarkerCursor(QObject):
def __init__(self, mapCanvas, srsOL):
QObject.__init__(self)
self.__srsOL = srsOL
self.__canvas = mapCanvas
self.__marker = None
self.__showMarker = True
def __del__(self):
self.reset()
def __refresh(self, pointCenter):
if self.__marker is not None:
self.reset()
self.__marker = QgsVertexMarker(self.__canvas)
self.__marker.setCenter(pointCenter)
self.__marker.setIconType(QgsVertexMarker.ICON_X)
self.__marker.setPenWidth(4)
def setVisible(self, visible):
self.__showMarker = visible
def reset(self):
self.__canvas.scene().removeItem(self.__marker)
del self.__marker
self.__marker = None
@pyqtSlot(str)
def changeMarker(self, strListExtent):
if not self.__showMarker:
return
# left, bottom, right, top
left, bottom, right, top = [float(item) for item in
strListExtent.split(',')]
pointCenter = QgsRectangle(QgsPointXY(left, top),
QgsPointXY(right, bottom)).center()
crsCanvas = self.__canvas.mapSettings().destinationCrs()
if self.__srsOL != crsCanvas:
coodTrans = QgsCoordinateTransform(self.__srsOL, crsCanvas,
QgsProject.instance())
pointCenter = coodTrans.transform(
pointCenter,
QgsCoordinateTransform.ForwardTransform)
self.__refresh(pointCenter)
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
super(ArkGrid, self).initGui()
self.dock = GridDock()
self.dock.initGui(self.iface, Qt.LeftDockWidgetArea, self.pluginAction)
self._createGridAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/newGrid.png'), self.tr(u'Create New Grid'), self.showGridWizard)
self._identifyGridAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/identifyCoordinates.png'), self.tr(u'Identify Grid Coordinates'), self._triggerMapTool)
self._identifyGridAction.setCheckable(True)
self._panToAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/panToSelected.svg'), self.tr(u'Pan to map point'), self.panMapToPoint)
self._pasteMapPointAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/pastePoint.png'), self.tr(u'Paste Map Point'), self.pasteMapPointFromClipboard)
self._addMapPointAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/addPoint.png'), self.tr(u'Add point to current layer'), self.addMapPointToLayer)
self._updateLayerAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/updateLayer.png'), self.tr(u'Update Layer Coordinates'), self.showUpdateLayerDialog)
self._importDelimitedAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/updateLayer.png'), self.tr(u'Import Delimited Text File'), self.showDelimitedTextDialog)
#self._translateFeaturesAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/translateFeature.png'), self.tr(u'Translate features'), self.showTranslateFeaturesDialog)
self._settingsWizardAction = self.dock.toolbar.addAction(QIcon(':/plugins/ark/grid/settings.svg'), self.tr(u'Run Settings Wizard'), self.configure)
self.dock.widget.gridSelectionChanged.connect(self.changeGrid)
self.dock.widget.mapPointChanged.connect(self.convertMapPoint)
self.dock.widget.copyMapPointSelected.connect(self.copyMapPointToClipboard)
self.dock.widget.localPointChanged.connect(self.convertLocalPoint)
self.dock.widget.copyLocalPointSelected.connect(self.copyLocalPointToClipboard)
self._setReadOnly(True)
self._mapTool = ArkMapToolEmitPoint(self.mapCanvas())
self._mapTool.setAction(self._identifyGridAction)
self._mapTool.canvasClicked.connect(self.pointSelected)
self._vertexMarker = QgsVertexMarker(self.mapCanvas())
self._vertexMarker.setIconType(QgsVertexMarker.ICON_CROSS)
# If the project changes make sure we stay updated
self.iface.projectRead.connect(self.loadProject)
self.iface.newProjectCreated.connect(self.closeProject)
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 __init__(self, canvas):
super(MapToolEmitPoint, self).__init__(canvas)
self._vertexMarker = QgsVertexMarker(canvas)
self._vertexMarker.setIconType(QgsVertexMarker.ICON_NONE)
