Python QgsVertexMarker.setIconType方法代码示例

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
	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)

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
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

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
    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()

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
 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)

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
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)

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
    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])

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
 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

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
    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

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
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

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
 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

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
 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

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
 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

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
 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)

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
 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)

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconType [as 别名]
 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)