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 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 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 __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 __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 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 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 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 __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 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 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 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)