Python core.QgsSymbolV2类代码示例

    def prepare_ordered_marker(self, coords, idx):
        """
        Try to display nice marker on a point layer, showing the order of
        the path computed by OSRM.
        """
        self.tsp_marker_lr = QgsVectorLayer(
            "Point?crs=epsg:4326&field=id:integer"
            "&field=TSP_nb:integer(20)&field=Origin_nb:integer(20)",
            "tsp_markers_osrm{}".format(self.nb_route), "memory")
        symbol = QgsSymbolV2.defaultSymbol(self.tsp_marker_lr.geometryType())
        symbol.setSize(4.5)
        symbol.setColor(QtGui.QColor("yellow"))

        ordered_pts = \
            [coords[i["waypoint_index"]] for i in self.parsed['waypoints']]
        print("ordered_pts : ", ordered_pts)

        features = []
        for nb, pt in enumerate(ordered_pts):
            ft = QgsFeature()
            ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(pt)))
            ft.setAttributes([nb, nb + 1, coords.index(pt)])
            features.append(ft)
        self.tsp_marker_lr.dataProvider().addFeatures(features)

        pal_lyr = QgsPalLayerSettings()
        pal_lyr.readFromLayer(self.tsp_marker_lr)
        pal_lyr.enabled = True
        pal_lyr.fieldName = 'TSP_nb'
        pal_lyr.placement= QgsPalLayerSettings.OverPoint
        pal_lyr.setDataDefinedProperty(QgsPalLayerSettings.Size,True,True,'12','')
        pal_lyr.writeToLayer(self.tsp_marker_lr)

        self.tsp_marker_lr.setRendererV2(QgsSingleSymbolRendererV2(symbol))
        QgsMapLayerRegistry.instance().addMapLayer(self.tsp_marker_lr)

    def run(self):
        """Specific stuff at tool activating."""

        s = QSettings()
        layer = iface.mapCanvas().currentLayer()
        if not layer:
            return
        if findButtonByActionName("Afficher avancement de la saisie").isChecked():

            # define a lookup: value -> (color, label)
            completion = {0: ("#ddd", "Aucune saisie"), 1: ("#7a7", "Saisie partielle"), 2: ("#0c0", "Saisie complète")}

            # create a category for each item
            categories = []
            for completion_code, (color, label) in completion.items():
                symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
                symbol.setColor(QColor(color))
                category = QgsRendererCategoryV2(completion_code, symbol, label)
                categories.append(category)

            # create the renderer and assign it to a layer
            expression = "lgd_compl"  # field name
            renderer = QgsCategorizedSymbolRendererV2(expression, categories)
            styleName = pluginDirectory + "/" + layer.name() + ".qml"
            if not s.value("layer_lgd_style/" + layer.name()):
                layer.saveNamedStyle(styleName)
                layer.setRendererV2(renderer)
                s.setValue("layer_lgd_style/" + layer.name(), 1)
        else:
            styleName = pluginDirectory + "/" + layer.name() + ".qml"
            layer.loadNamedStyle(styleName)
            s.setValue("layer_lgd_style/" + layer.name() + "/", 0)
        layer.triggerRepaint()

def simple_polygon_without_brush(layer, width='0.26', color=QColor('black')):
    """Simple style to apply a border line only to a polygon layer.

    :param layer: The layer to style.
    :type layer: QgsVectorLayer

    :param color: Color to use for the line. Default to black.
    :type color: QColor

    :param width: Width to use for the line. Default to '0.26'.
    :type width: str
    """
    registry = QgsSymbolLayerV2Registry.instance()
    line_metadata = registry.symbolLayerMetadata("SimpleLine")
    symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())

    # Line layer
    line_layer = line_metadata.createSymbolLayer(
        {
            'width': width,
            'color': color.name(),
            'offset': '0',
            'penstyle': 'solid',
            'use_custom_dash': '0',
            'joinstyle': 'bevel',
            'capstyle': 'square'
        })

    # Replace the default layer with our custom line
    symbol.deleteSymbolLayer(0)
    symbol.appendSymbolLayer(line_layer)

    renderer = QgsSingleSymbolRendererV2(symbol)
    layer.setRendererV2(renderer)

    def update_syms(self, catalogue):
        self.syms = {}

        for flag in set(catalogue.data['Cluster_Flag'].tolist()):
            for index in set(catalogue.data['Cluster_Index'].tolist()):

                # main shock
                point = QgsMarkerSymbolV2.createSimple(
                    {'color': 'blue', 'name': 'square'})

                if index:  # belongs to a cluster
                    color = self.catalogue_model.cluster_color(index)

                    # non poissonian
                    if flag:
                        point = QgsMarkerSymbolV2.createSimple(
                            {'color': 'blue', 'name': 'triangle'})
                    color.setAlpha(125 + 125 * abs(flag))
                    point.setSize(3)
                    point.setColor(color)
                else:
                    point = QgsSymbolV2.defaultSymbol(QGis.Point)
                    point.setColor(QtGui.QColor("0,0,0,125"))
                    point.setSize(1.5)
                self.syms[self.Cluster(index, flag)] = point

	def setCategorizedStyle(vl, categories, field, **kwargs):
		""" set a categorized style """
		# make a symbol for each category
		categoryV2List = []
		for label, value, attrs in categories:
			symbolV2 = QgsSymbolV2.defaultSymbol( vl.geometryType() )
			if 'color' in attrs:
				symbolV2.setColor( attrs['color'] )
			if 'size' in attrs:
				symbolV2.setSize( attrs['size'] )

			# in QGis > 1.8 QgsMarkerSymbolV2 has 2 scale methods: ScaleArea and ScaleDiameter
			if 'sizeScaleMethod' in kwargs and hasattr(symbolV2, 'setScaleMethod'):
				symbolV2.setScaleMethod( kwargs['sizeScaleMethod'] )

			categoryV2 = QgsRendererCategoryV2( value, symbolV2, label )
			categoryV2List.append( categoryV2 )

		# create the renderer
		renderer = QgsCategorizedSymbolRendererV2( field, categoryV2List )

		# set size scale field
		if 'sizeScaleField' in kwargs:
			renderer.setSizeScaleField( kwargs['sizeScaleField'] )

		# set the renderer for the layer
		vl.setRendererV2( renderer )
		Utils.iface.legendInterface().refreshLayerSymbology(vl)

 def apply(self, layer):
     symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
     symbol_layer = QgsSimpleFillSymbolLayerV2.create({'color': self.color})
     if self.border_style:
         symbol_layer.setBorderStyle(self.border_style)
     self.renderer = QgsSingleSymbolRendererV2(symbol)
     self.renderer.symbols()[0].changeSymbolLayer(0, symbol_layer)
     super(SimpleFillSymbology, self).apply(layer)

 def create_join_renderer(self, layer, field, classes, mode, color='PuBu'):
     symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
     style = QgsStyleV2().defaultStyle()
     colorRamp = style.colorRampRef(color)
     renderer = QgsGraduatedSymbolRendererV2.createRenderer(layer, field, classes, mode, symbol, colorRamp)
     label_format = self.create_join_label_format(2)
     renderer.setLabelFormat(label_format)
     return renderer

def prepare_route_symbol(nb_route):
    colors = ['#1f78b4', '#ffff01', '#ff7f00',
              '#fb9a99', '#b2df8a', '#e31a1c']
    p = nb_route % len(colors)
    my_symb = QgsSymbolV2.defaultSymbol(1)
    my_symb.setColor(QColor(colors[p]))
    my_symb.setWidth(1.2)
    return my_symb

def hazard_class_style(layer, classification, display_null=False):
    """Set colors to the layer according to the hazard.

    :param layer: The layer to style.
    :type layer: QgsVectorLayer

    :param display_null: If we should display the null hazard zone. Default to
        False.
    :type display_null: bool

    :param classification: The hazard classification to use.
    :type classification: dict safe.definitions.hazard_classifications
    """
    categories = []

    # Conditional styling
    attribute_table_styles = []

    for hazard_class, (color, label) in classification.iteritems():
        if hazard_class == not_exposed_class['key'] and not display_null:
            # We don't want to display the null value (not exposed).
            # We skip it.
            continue

        symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
        symbol.setColor(color)
        if is_line_layer(layer):
            symbol.setWidth(line_width_exposure)
        category = QgsRendererCategoryV2(hazard_class, symbol, label)
        categories.append(category)

        style = QgsConditionalStyle()
        style.setName(hazard_class)
        style.setRule("hazard_class='%s'" % hazard_class)
        symbol = QgsSymbolV2.defaultSymbol(QGis.Point)
        symbol.setColor(color)
        symbol.setSize(3)
        style.setSymbol(symbol)
        attribute_table_styles.append(style)

    layer.conditionalStyles().setFieldStyles(
        'hazard_class', attribute_table_styles)
    renderer = QgsCategorizedSymbolRendererV2(
        hazard_class_field['field_name'], categories)
    layer.setRendererV2(renderer)

 def __init__(self):
     QgsFeatureRendererV2.__init__(self, "CatalogueCompletenessRenderer")
     complete = QgsSymbolV2.defaultSymbol(QGis.Point)
     uncomplete = QgsMarkerSymbolV2.createSimple(
         {'color': 'blue', 'name': 'triangle'})
     uncomplete.setSize(3)
     complete.setSize(1.5)
     complete.setColor(QtGui.QColor(255, 0, 0, 125))
     self.syms = [complete, uncomplete]

    def applySymbology(self):
        self.getConnection()
        vlayer = qgis.utils.iface.mapCanvas().currentLayer()
        if vlayer == None:
            return

        fields = vlayer.dataProvider().fields()
        classField = None
        for f in fields:
            if f.name() == "classtype":
                classField = 'classtype'
            elif f.name() == "result":
                classField = 'result'
        print classField

        class_loaded = False
        for layer in QgsMapLayerRegistry.instance().mapLayers().values():
            if  layer.name() == "class":
                vlayerClass = layer
                class_loaded = True
        if not class_loaded:
            uriSubClass = QgsDataSourceURI()
            uriSubClass.setConnection(self.serverName, "5432", self.database, self.usr , self.pw)
            uriSubClass.setDataSource("classification", "class", None, "", "id")
            vlayerClass = QgsVectorLayer(uriSubClass.uri(), "class", "postgres")
            QgsMapLayerRegistry.instance().addMapLayer(vlayerClass)

        for field in fields:
            index = vlayer.fieldNameIndex(field.name())
            if field.name() == classField:
                vlayer.editFormConfig().setWidgetType(index, 'ValueRelation')
                vlayer.editFormConfig().setWidgetConfig(index, {'Layer': vlayerClass.id(), 'Key': 'id', 'Value': 'classname'})

        useJoin = True
        if useJoin:
            joinObject = QgsVectorJoinInfo()
            joinObject.joinLayerId = vlayerClass.id()
            joinObject.joinFieldName = 'id'
            joinObject.targetFieldName = classField
            joinObject.memoryCache = True
            vlayer.addJoin(joinObject)
            self.join.append(joinObject)
            categories = []
            iter = vlayerClass.getFeatures()
            for feature in iter:
                classname = feature['classname']
                color = QColor(feature['red'], feature['green'], feature['blue'])
                sym = QgsSymbolV2.defaultSymbol(vlayer.geometryType())
                sym.setColor(QColor(color))
                category = QgsRendererCategoryV2(classname, sym, classname)
                categories.append(category)
            field = "class_classname"
            renderer = QgsCategorizedSymbolRendererV2(field, categories)
            vlayer.setRendererV2(renderer)

        qgis.utils.iface.messageBar().pushMessage("Information", "Editor widget set", level = qgis.gui.QgsMessageBar.INFO, duration = 5)
        qgis.utils.iface.setActiveLayer(vlayer)

    def test_setRendererV2(self):
        layer = createLayerWithOnePoint()

        self.rendererChanged = False
        layer.rendererChanged.connect(self.onRendererChanged)

        r = QgsSingleSymbolRendererV2(QgsSymbolV2.defaultSymbol(QGis.Point))
        layer.setRendererV2(r)
        self.assertTrue(self.rendererChanged)
        self.assertEquals(layer.rendererV2(), r)

    def commitClicked(self):
        feature = self.listWidget.currentItem().feature
        geom = None
        self.attributesTable.setRowCount(len(feature))
        for idx, attrname in enumerate(feature):
            value = feature[attrname]
            font = QFont()
            font.setBold(True)
            font.setWeight(75)
            item = QTableWidgetItem(attrname)
            item.setFont(font)
            self.attributesTable.setItem(idx, 0, item);
            self.attributesTable.setItem(idx, 1, QTableWidgetItem(str(value)));
            if geom is None:
                try:
                    geom = QgsGeometry.fromWkt(value)
                except:
                    pass

        self.attributesTable.resizeRowsToContents()
        self.attributesTable.horizontalHeader().setMinimumSectionSize(150)
        self.attributesTable.horizontalHeader().setStretchLastSection(True)

        settings = QSettings()
        prjSetting = settings.value('/Projections/defaultBehaviour')
        settings.setValue('/Projections/defaultBehaviour', '')
        types = ["Point", "LineString", "Polygon"]
        layers = []
        if geom is not None:
            geomtype = types[int(geom.type())]
            layer = loadLayerNoCrsDialog(geomtype + "?crs=EPSG:4326", "temp", "memory")
            pr = layer.dataProvider()
            feat = QgsFeature()
            feat.setGeometry(geom)
            pr.addFeatures([feat])
            layer.updateExtents()
            layer.selectAll()
            layer.setExtent(layer.boundingBoxOfSelected())
            layer.invertSelection()
            symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
            symbol.setColor(Qt.green)
            symbol.setAlpha(0.5)
            if QGis.QGIS_VERSION_INT < 29900:
                layer.setRendererV2(QgsSingleSymbolRendererV2(symbol))
            else:
                layer.setRenderer(QgsSingleSymbolRenderer(symbol))
            self.mapCanvas.setRenderFlag(False)
            self.mapCanvas.setLayerSet([QgsMapCanvasLayer(layer)])
            QgsMapLayerRegistry.instance().addMapLayer(layer, False)
            self.mapCanvas.setExtent(layer.extent())
            self.mapCanvas.setRenderFlag(True)
            layers.append(layer)
        else:
            self.mapCanvas.setLayerSet([])
        settings.setValue('/Projections/defaultBehaviour', prjSetting)

    def test_setRendererV2( self ):
        layer = createLayerWithOnePoint()

        self.rendererChanged = False
        QObject.connect( layer, SIGNAL( "rendererChanged()" ),
                         self.onRendererChanged )

        r = QgsSingleSymbolRendererV2( QgsSymbolV2.defaultSymbol( QGis.Point ) )
        layer.setRendererV2( r )
        assert self.rendererChanged == True
        assert layer.rendererV2() == r

    def make_OD_markers(nb, xo, yo, xd, yd, list_coords=None):
        """
        Prepare the Origin (green), Destination (red) and Intalternative_geometriesermediates (grey)
        markers.
        """
        OD_layer = QgsVectorLayer(
            "Point?crs=epsg:4326&field=id_route:integer&field=role:string(80)",
            "markers_osrm{}".format(nb), "memory")
        features = []
        fet = QgsFeature()
        fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(float(xo), float(yo))))
        fet.setAttributes([nb, 'Origin'])
        features.append(fet)
        fet = QgsFeature()
        fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(float(xd), float(yd))))
        fet.setAttributes([nb, 'Destination'])
        features.append(fet)
        marker_rules = [
            ('Origin', '"role" LIKE \'Origin\'', '#50b56d', 4),
            ('Destination', '"role" LIKE \'Destination\'', '#d31115', 4),
        ]
        if list_coords:
            for i, pt in enumerate(list_coords):
                fet = QgsFeature()
                fet.setGeometry(
                    QgsGeometry.fromPoint(QgsPoint(float(pt[0]), float(pt[1])))
                    )
                fet.setAttributes([nb, 'Via point n°{}'.format(i)])
                features.append(fet)
            marker_rules.insert(
                1, ('Intermediate', '"role" LIKE \'Via point%\'', 'grey', 2))
        OD_layer.dataProvider().addFeatures(features)

        symbol = QgsSymbolV2.defaultSymbol(OD_layer.geometryType())
        renderer = QgsRuleBasedRendererV2(symbol)
        root_rule = renderer.rootRule()
        for label, expression, color_name, size in marker_rules:
            rule = root_rule.children()[0].clone()
            rule.setLabel(label)
            rule.setFilterExpression(expression)
            rule.symbol().setColor(QtGui.QColor(color_name))
            rule.symbol().setSize(size)
            root_rule.appendChild(rule)

        root_rule.removeChildAt(0)
        OD_layer.setRendererV2(renderer)
        return OD_layer