Python QgsVertexMarker.setIconSize方法代码示例

# 需要导入模块: from qgis.gui import QgsVertexMarker [as 别名]
# 或者: from qgis.gui.QgsVertexMarker import setIconSize [as 别名]
    def wtkClicked(self):
       wktStr = self.ui.wktTxt.toPlainText()
       geom = QgsGeometry.fromWkt(wktStr)
       if geom is None: return

       self.manualLoc_lam72 = geom
       self.manualLocationName = wktStr

       self.ui.manualLocationTxt.setText(wktStr)
   
       if geom.type() == QGis.Point: 
          marker = QgsVertexMarker(self.iface.mapCanvas())
          marker.setCenter( geom.asPoint() )
          marker.setColor(QtGui.QColor(0, 255, 255))
          marker.setIconSize(5)
       else:
          marker = QgsRubberBand(self.iface.mapCanvas(), geom.type() == QGis.Polygon )
          marker.setToGeometry(geom , None)
          marker.setColor(QtGui.QColor(0, 255, 255))
          marker.setFillColor(QtGui.QColor(0, 255, 255, 100))
          marker.setWidth(3)    
       self._clearGraphicLayer()
       self.graphicsLayer.append(marker)

       self.ui.inputGeomTabs.setCurrentWidget(self.ui.drawInputTab)

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

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

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