Python QgsVectorLayer.setLayerTransparency方法代码示例

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import setLayerTransparency [as 别名]
    def drawLimits2 (self):
        self.dlg.listWidget.clear()
        #comprobate if the layer already exists and delete it
        for lyr in QgsMapLayerRegistry.instance().mapLayers().values():
            if lyr.name() == "Limites":
                QgsMapLayerRegistry.instance().removeMapLayer( lyr.id() )
                break

        #crete a vector layer with a expecific name and color
        v_layer = QgsVectorLayer("Polygon", "Limites", "memory")
        v_layer.setLayerTransparency(70)
        symbols =v_layer.rendererV2().symbols()
        symbol=symbols[0]
        symbol.setColor(QColor('green'))
        #create the provider and add the layer
        pr = v_layer.dataProvider()
        poly = QgsFeature()
        #draw the lines between the buttons in order
        points = self.tool.polygon
        #print points[0].x()
        poly.setGeometry(QgsGeometry.fromPolygon([self.tool.polygon]))
        #add the lines to the provider and update the layer
        pr.addFeatures([poly])
        v_layer.updateExtents()
        QgsMapLayerRegistry.instance().addMapLayers([v_layer])

        #add the points to the QlistWidget
        for i in range (len(self.tool.polygon)):
            self.addItem(i)

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import setLayerTransparency [as 别名]
    def envelope2layer(self, envelope):
        """Transform metadata envelope into a QGIS layer."""
        # layer
        md_lyr = QgsVectorLayer("Polygon?crs=epsg:4326",
                                "Metadata envelope",
                                "memory")
        md_lyr.setLayerTransparency(75)
        symbols = md_lyr.rendererV2().symbols()
        symbol = symbols[0]
        symbol.setColor(QColor.fromRgb(255,20,147))

        if envelope.get("type") == "Polygon":
            # parse coordinates
            coords = envelope.get("coordinates")[0]
            poly_pts = [QgsPoint(round(i[0], 3),
                                 round(i[1], 3))
                        for i in coords]
            # add geometry to layer
            poly = QgsFeature()
            poly.setGeometry(QgsGeometry.fromPolygon([poly_pts]))
            md_lyr.dataProvider().addFeatures([poly])
            md_lyr.updateExtents()
        elif envelope.get("type") == "MultiPolygon":
            coords = envelope.get("bbox")
            bbox = QgsRectangle(round(coords[0], 3),
                                round(coords[1], 3),
                                round(coords[2], 3),
                                round(coords[3], 3),)
            poly = QgsFeature()
            poly.setGeometry(QgsGeometry.fromWkt(bbox.asWktPolygon()))
            md_lyr.dataProvider().addFeatures([poly])
            md_lyr.updateExtents()
        elif envelope.get("type") == "Point":
            return md_lyr
        else:
            pass
        # method ending
        return md_lyr

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import setLayerTransparency [as 别名]

#.........这里部分代码省略.........
        self.mRasterLayer2.setRenderer(myMultiBandRenderer2)
        self.mMapRegistry.addMapLayer(self.mRasterLayer2)

        # to match blend modes test comparisons background
        self.mCanvas = CANVAS
        self.mCanvas.setCanvasColor(QColor(152, 219, 249))
        self.mMap = self.mCanvas.map()
        self.mMap.resize(QSize(400, 400))
        self.mapSettings = self.mCanvas.mapSettings()
        self.mapSettings.setOutputSize(QSize(400, 400))

    def testVectorBlending(self):
        """Test that blend modes work for vector layers."""

        #Add vector layers to map
        myLayers = []
        myLayers.append(self.mLineLayer.id())
        myLayers.append(self.mPolygonLayer.id())
        self.mapSettings.setLayers(myLayers)
        self.mapSettings.setExtent(self.mPointLayer.extent())

        #Set blending modes for both layers
        self.mLineLayer.setBlendMode(QPainter.CompositionMode_Difference)
        self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_Difference)

        checker = QgsRenderChecker()
        checker.setControlName("expected_vector_blendmodes")
        checker.setMapSettings(self.mapSettings)

        myResult = checker.runTest("vector_blendmodes");
        myMessage = ('vector blending failed')
        assert myResult, myMessage

        #Reset layers
        self.mLineLayer.setBlendMode(QPainter.CompositionMode_SourceOver)
        self.mPolygonLayer.setBlendMode(QPainter.CompositionMode_SourceOver)

    def testVectorFeatureBlending(self):
        """Test that feature blend modes work for vector layers."""

        #Add vector layers to map
        myLayers = []
        myLayers.append(self.mLineLayer.id())
        myLayers.append(self.mPolygonLayer.id())
        self.mapSettings.setLayers(myLayers)
        self.mapSettings.setExtent(self.mPointLayer.extent())

        #Set feature blending for line layer
        self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_Plus)

        checker = QgsRenderChecker()
        checker.setControlName("expected_vector_featureblendmodes")
        checker.setMapSettings(self.mapSettings)

        myResult = checker.runTest("vector_featureblendmodes");
        myMessage = ('vector feature blending failed')
        assert myResult, myMessage

        #Reset layers
        self.mLineLayer.setFeatureBlendMode(QPainter.CompositionMode_SourceOver)

    def testVectorLayerTransparency(self):
        """Test that layer transparency works for vector layers."""

        #Add vector layers to map
        myLayers = []
        myLayers.append(self.mLineLayer.id())
        myLayers.append(self.mPolygonLayer.id())
        self.mapSettings.setLayers(myLayers)
        self.mapSettings.setExtent(self.mPointLayer.extent())

        #Set feature blending for line layer
        self.mLineLayer.setLayerTransparency( 50 )

        checker = QgsRenderChecker()
        checker.setControlName("expected_vector_layertransparency")
        checker.setMapSettings(self.mapSettings)

        myResult = checker.runTest("vector_layertransparency");
        myMessage = ('vector layer transparency failed')
        assert myResult, myMessage

    def testRasterBlending(self):
        """Test that blend modes work for raster layers."""
        #Add raster layers to map
        myLayers = []
        myLayers.append(self.mRasterLayer1.id())
        myLayers.append(self.mRasterLayer2.id())
        self.mapSettings.setLayers(myLayers)
        self.mapSettings.setExtent(self.mRasterLayer1.extent())

        #Set blending mode for top layer
        self.mRasterLayer1.setBlendMode(QPainter.CompositionMode_Plus)
        checker = QgsRenderChecker()
        checker.setControlName("expected_raster_blendmodes")
        checker.setMapSettings(self.mapSettings)

        myResult = checker.runTest("raster_blendmodes");
        myMessage = ('raster blending failed')
        assert myResult, myMessage

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import setLayerTransparency [as 别名]
    def get_access_isochrones(self):
        """
        Making the accessibility isochrones in few steps:
        - make a grid of points aroung the origin point,
        - snap each point (using OSRM locate function) on the road network,
        - get the time-distance between the origin point and each of these pts
            (using OSRM table function),
        - make an interpolation grid to extract polygons corresponding to the
            desired time intervals (using matplotlib library),
        - render the polygon.
        """
        try:
            self.host = check_host(self.lineEdit_host.text())
            self.profile = check_profile_name(self.lineEdit_profileName.text())
        except (ValueError, AssertionError) as err:
            self.iface.messageBar().pushMessage(
                "Error", "Please provide a valid non-empty URL", duration=10)
            return

        if 'clicking' in self.comboBox_method.currentText():
            pts = self.get_points_from_canvas()
        elif 'selecting' in self.comboBox_method.currentText():
            layer = self.comboBox_pointlayer.currentLayer()
            pts, _ = get_coords_ids(
                layer, '', on_selected=self.checkBox_selectedFt.isChecked())
            pts = tuple(pts)

        if not pts:
            return

        max_time = self.spinBox_max.value()
        interval_time = self.spinBox_intervall.value()
        nb_inter = int(round(max_time / interval_time)) + 1
        levels = tuple([nb for nb in xrange(0, int(
            max_time + 1) + interval_time, interval_time)][:nb_inter])

        self.make_prog_bar()
        self.max_points = 750 if len(pts) == 1 else 250
        self.polygons = []

        pts = [{"point": pt, "max": max_time, "levels": levels,
                "host": self.host, "profile": self.profile, "max_points": self.max_points}
                for pt in pts]

        pool = ThreadPool(processes=4 if len(pts) >= 4 else len(pts))

        try:
            self.polygons = [i for i in pool.map(prep_access, pts)]
        except Exception as err:
            self.display_error(err, 1)
            return

        if len(self.polygons) == 1:
            self.polygons = self.polygons[0]
        else:
            self.polygons = np.array(self.polygons).transpose().tolist()
            self.polygons = [QgsGeometry.unaryUnion(polys) for polys in self.polygons]

        isochrone_layer = QgsVectorLayer(
            "MultiPolygon?crs=epsg:4326&field=id:integer"
            "&field=min:integer(10)"
            "&field=max:integer(10)",
            "isochrone_osrm_{}".format(self.nb_isocr), "memory")
        data_provider = isochrone_layer.dataProvider()
        # Add the features to the layer to display :
        features = []
        levels = levels[1:]
        self.progress.setValue(8.5)
        for i, poly in enumerate(self.polygons):
            if not poly: continue
            ft = QgsFeature()
            ft.setGeometry(poly)
            ft.setAttributes(
                [i, levels[i] - interval_time, levels[i]])
            features.append(ft)
        data_provider.addFeatures(features[::-1])
        self.nb_isocr += 1
        self.progress.setValue(9.5)

        # Render the value :
        renderer = self.prepare_renderer(
            levels, interval_time, len(self.polygons))
        isochrone_layer.setRendererV2(renderer)
        isochrone_layer.setLayerTransparency(25)
        self.iface.messageBar().clearWidgets()
        QgsMapLayerRegistry.instance().addMapLayer(isochrone_layer)

        self.add_final_pts(pts)
        self.iface.setActiveLayer(isochrone_layer)

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import setLayerTransparency [as 别名]
 def run(self):
     """Run method that performs all the real work"""
     self.dlg.layerComboBox.clear()
     self.dlg.sheetTypeComboBox.clear()
     self.dlg.scaleComboBox.clear()  
     #self.dlg.label_2.setText('')        
     Alllayers = self.iface.legendInterface().layers()
     #layer_list = []
     lcount=0
     for layer in Alllayers:
         xyCrs = layer.crs()
         if xyCrs.projectionAcronym()=='longlat':
             lcount=lcount+1
             self.dlg.layerComboBox.addItem(layer.name(),layer)
             
     self.dlg.sheetTypeComboBox.addItem('Indian and Adjoining Countries Series Maps')    
     self.dlg.sheetTypeComboBox.addItem('Open Series Maps')    
     
     scale_list=['1:1M','1:250,000','1:125,000','1:50,000','1:25,000']
     self.dlg.scaleComboBox.addItems(scale_list)
     # show the dialog
     self.dlg.show()
     # Run the dialog event loop
     result = self.dlg.exec_()
     # See if OK was pressed
     if result:
         global scaleID
         global sheetw
         global sheeth
         if lcount>0:
             scaleID=self.dlg.scaleComboBox.currentIndex()+1
             maptype= self.dlg.sheetTypeComboBox.currentIndex()+1
             if maptype==1:                
                 sheetw,sheeth=setFactor1(scaleID)
             if maptype==2:
                 sheetw,sheeth=setFactor2(scaleID)               
             index = self.dlg.layerComboBox.currentIndex()
             clayer = self.dlg.layerComboBox.itemData(index)
             e=clayer.extent()
             a,b,c=degDec2dms(e.xMinimum())
             slongs=dmstosec(a,b,c)
             a,b,c=degDec2dms(e.xMaximum())
             elongs=dmstosec(a,b,c)
             a,b,c=degDec2dms(e.yMinimum())
             slats=dmstosec(a,b,c)
             a,b,c=degDec2dms(e.yMaximum())
             elats=dmstosec(a,b,c)
             slongs,elongs,slats,elats=CalculateExtentInTermsOfSheet(slongs,elongs,slats,elats)
             Xgrids=int(elongs-slongs)//sheetw # // is used for modular division
             Ygrids=int(elats-slats)//sheeth
             layer = QgsVectorLayer("Polygon?crs=EPSG:4326", "TopoSheets", "memory")
             global poly
             global pr
             pr = layer.dataProvider() 
             pr.addAttributes([QgsField("id",QVariant.Int),QgsField("SheetNo",QVariant.String),QgsField("Inside",QVariant.String)])
             layer.updateFields()
            
             poly = QgsFeature()
             CalculateSheet(maptype,slats,slongs,Xgrids,Ygrids)
             n=0
             # check intersection of selected layer feature with sheets
             fieldIdx = pr.fields().indexFromName('Inside' )
             updateMap = {}
             for f in clayer.getFeatures():
                 for a in layer.getFeatures():
                     if a.geometry().intersects(f.geometry()):
                         n=n+1
                         updateMap[a.id()] = { fieldIdx:1 }
             pr.changeAttributeValues(updateMap)
             
             # set the layer symbology
             values = (
             ('In', True,True,QColor.fromRgb(95,254,99)),
             ('Out', False,False,'yellow'),
             )
             # create a category for each item in values
             ranges=[]
             for label, lower, upper, color in values:
                 symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
                 symbol.setColor(QColor(color))
                 rng = QgsRendererRangeV2(lower, upper, symbol, label)
                 ranges.append(rng)
             expression = 'Inside' # field name
             renderer = QgsGraduatedSymbolRendererV2(expression, ranges)
             layer.setRendererV2(renderer)
             
             # set layer transparence and dolabelling
             layer.setLayerTransparency(65)              
             layer.updateExtents()
             QgsMapLayerRegistry.instance().addMapLayers([layer])
             layer.setCustomProperty("labeling", "pal")
             layer.setCustomProperty("labeling/enabled", "true")
             layer.setCustomProperty("labeling/fontFamily", "Arial")
             layer.setCustomProperty("labeling/fontSize", "10")
             layer.setCustomProperty("labeling/fieldName", "SheetNo")
             layer.setCustomProperty("labeling/placement", "1")
             iface.mapCanvas().refresh()
         else:
             iface.messageBar().pushMessage("Error", "No layers loaded, Load layer with Geographic Corrdinates", level=QgsMessageBar.CRITICAL)
         pass

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import setLayerTransparency [as 别名]
# raster layer
world_wmts_url = "contextualWMSLegend=0&crs=EPSG:4326&dpiMode=7&"\
                 "featureCount=10&format=image/jpeg&layers=opengeo:countries&"\
                 "styles=&tileMatrixSet=EPSG:4326&"\
                 "url=http://suite.opengeo.org/geoserver/gwc/service/wmts?request%3DGetCapabilities"
world_lyr = QgsRasterLayer(world_wmts_url, "Countries", 'wms')
print(world_lyr.isValid())

# vector layer
geojson_contributors = path.join(
                               path.dirname(QgsApplication.developersMapFilePath()),
                                            'contributors.json')

layer = QgsVectorLayer(geojson_contributors, "QGIS Contributors", "ogr")
layer.setLayerTransparency(35)
print(layer.isValid())

# managing map canvas
map_canvas = QgsMapCanvas(new_dialog)
map_canvas.setMinimumSize(800, 600)
map_canvas.mapRenderer().setDestinationCrs(crs_wgs84)
QgsMapLayerRegistry.instance().addMapLayers([layer, world_lyr], 0)
map_canvas_layer_list = [QgsMapCanvasLayer(layer), QgsMapCanvasLayer(world_lyr)]
map_canvas.setExtent(layer.extent())
map_canvas.setLayerSet(map_canvas_layer_list)

new_dialog.show()

print(dir(map_canvas.map))
print(map_canvas.layers())