def setUp(self): myShpFile = os.path.join(TEST_DATA_DIR, 'rectangles.shp') layer = QgsVectorLayer(myShpFile, 'Points', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(layer) # Create rulebased style sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'}) sym2 = QgsFillSymbolV2.createSimple({'color': '#71bd6c'}) sym3 = QgsFillSymbolV2.createSimple({'color': '#1f78b4'}) self.r1 = QgsRuleBasedRendererV2.Rule(sym1, 0, 0, '"id" = 1') self.r2 = QgsRuleBasedRendererV2.Rule(sym2, 0, 0, '"id" = 2') self.r3 = QgsRuleBasedRendererV2.Rule(sym3, 0, 0, 'ELSE') self.rootrule = QgsRuleBasedRendererV2.Rule(None) self.rootrule.appendChild(self.r1) self.rootrule.appendChild(self.r2) self.rootrule.appendChild(self.r3) self.renderer = QgsRuleBasedRendererV2(self.rootrule) layer.setRendererV2(self.renderer) self.mapsettings = CANVAS.mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52)) rendered_layers = [layer.id()] self.mapsettings.setLayers(rendered_layers)
def setUp(self): self.iface = get_iface() myShpFile = os.path.join(TEST_DATA_DIR, 'rectangles.shp') layer = QgsVectorLayer(myShpFile, 'Points', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(layer) # Create rulebased style sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'}) sym2 = QgsFillSymbolV2.createSimple({'color': '#71bd6c'}) sym3 = QgsFillSymbolV2.createSimple({'color': '#1f78b4'}) self.r1 = QgsRuleBasedRendererV2.Rule(sym1, 0, 0, '"id" = 1') self.r2 = QgsRuleBasedRendererV2.Rule(sym2, 0, 0, '"id" = 2') self.r3 = QgsRuleBasedRendererV2.Rule(sym3, 0, 0, 'ELSE') self.rootrule = QgsRuleBasedRendererV2.Rule(None) self.rootrule.appendChild(self.r1) self.rootrule.appendChild(self.r2) self.rootrule.appendChild(self.r3) self.renderer = QgsRuleBasedRendererV2(self.rootrule) layer.setRendererV2(self.renderer) self.mapsettings = self.iface.mapCanvas().mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52)) rendered_layers = [layer.id()] self.mapsettings.setLayers(rendered_layers)
def setStyleGrilleControle(layerGrille, idList): # Symbologie: cellule a controler props1 = {'color': '241,241,241,0', 'size': '0', 'color_border': '255,0,0'} symbol1 = QgsFillSymbolV2.createSimple(props1) #props2 = {'color': '255,127,0,0', 'size':'0', 'color_border' : '255,127,0', 'width_border':'1'} #symbol2 = QgsFillSymbolV2.createSimple(props2) # Symbologie: cellule a griser props3 = { 'color': '180,180,180', 'size': '1', 'color_border': '180,180,180' } symbol3 = QgsFillSymbolV2.createSimple(props3) symbol3.setAlpha(0.70) # On definit les règles de symbologie txtRule = ' in (' for i in range(len(idList)): id = idList[i] txtRule = txtRule + str(id) + ', ' txtRule = txtRule[0:len(txtRule) - 2] txtRule = txtRule + ')' cell_rules = (('A controler', CONST_ATTRIBUT_ID + ' ' + txtRule, symbol1), ('Pass', CONST_ATTRIBUT_ID + ' not ' + txtRule, symbol3)) # create a new rule-based renderer symbol = QgsSymbolV2.defaultSymbol(layerGrille.geometryType()) renderer = QgsRuleBasedRendererV2(symbol) # get the "root" rule root_rule = renderer.rootRule() for label, expression, symbol in cell_rules: # create a clone (i.e. a copy) of the default rule rule = root_rule.children()[0].clone() # set the label, expression and color rule.setLabel(label) rule.setFilterExpression(expression) # rule.symbol().setColor(QColor(color_name)) rule.setSymbol(symbol) # append the rule to the list of rules root_rule.appendChild(rule) # delete the default rule root_rule.removeChildAt(0) # apply the renderer to the layer layerGrille.setRendererV2(renderer) return layerGrille
def setStyleGrilleSaisie(layerGrille, currid): props1 = { 'color': '241,241,241,0', 'size': '0', 'color_border': '255,0,0', 'width_border': '0.5' } symbol1 = QgsFillSymbolV2.createSimple(props1) props2 = {'color': '255,127,0,0', 'size': '0', 'color_border': '255,127,0'} symbol2 = QgsFillSymbolV2.createSimple(props2) # On definit les règles de symbologie cell_rules = (('Cellule en cours', CONST_ATTRIBUT_ID + ' = ' + str(currid), symbol1), ('Autre cellule', CONST_ATTRIBUT_ID + ' != ' + str(currid), symbol2)) # create a new rule-based renderer symbol = QgsSymbolV2.defaultSymbol(layerGrille.geometryType()) renderer = QgsRuleBasedRendererV2(symbol) # get the "root" rule root_rule = renderer.rootRule() for label, expression, symbol in cell_rules: # create a clone (i.e. a copy) of the default rule rule = root_rule.children()[0].clone() # set the label, expression and color rule.setLabel(label) rule.setFilterExpression(expression) # rule.symbol().setColor(QColor(color_name)) rule.setSymbol(symbol) # append the rule to the list of rules root_rule.appendChild(rule) # delete the default rule root_rule.removeChildAt(0) # apply the renderer to the layer layerGrille.setRendererV2(renderer) return layerGrille
def test_3(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({ 'arrow_width': '7', 'head_width': '6', 'head_height': '8', 'head_type': '0', 'arrow_type': '1', 'is_curved': '0' }) fill_sym = QgsFillSymbolV2.createSimple({ 'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1' }) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() ms = self.mapsettings ms.setExtent(QgsRectangle(-101, 35, -99, 37)) renderchecker.setMapSettings(ms) renderchecker.setControlName('expected_arrowsymbollayer_3') self.assertTrue(renderchecker.runTest('arrowsymbollayer_3'))
def __init__(self, methodName): """Run once on class initialization.""" unittest.TestCase.__init__(self, methodName) self.mapSettings = QgsMapSettings() # create composition self.mComposition = QgsComposition(self.mapSettings) self.mComposition.setPaperSize(297, 210) # create polygon = QPolygonF() polygon.append(QPointF(0.0, 0.0)) polygon.append(QPointF(100.0, 0.0)) polygon.append(QPointF(200.0, 100.0)) polygon.append(QPointF(100.0, 200.0)) self.mComposerPolygon = QgsComposerPolygon(polygon, self.mComposition) self.mComposition.addComposerPolygon(self.mComposerPolygon) # style props = {} props["color"] = "green" props["style"] = "solid" props["style_border"] = "solid" props["color_border"] = "black" props["width_border"] = "10.0" props["joinstyle"] = "miter" style = QgsFillSymbolV2.createSimple(props) self.mComposerPolygon.setPolygonStyleSymbol(style)
def geraMapaBacia(self, cotrecho, cobacia, dist): # manda gerar a tabela montante_jusante.area_mont_x na base de dados (x é o código do trecho) # gera o string sql string_sql = 'SELECT gera_tabela_topologica(\'area_mont\', ' + str(cotrecho) + ', \'' + cobacia + '\', ' + '{0:.6f}'.format(dist) + ')' # estabelece uma conexão com a base de dados PostGIS com dados da conexao da camada hidrografia armazenados em self.uri_ex conn = psycopg2.connect(host=self.uri_ex.host(), port=self.uri_ex.port(), database=self.uri_ex.database(), user=self.uri_ex.username(), password=self.uri_ex.password()) # executa o comando sql, que gera a tabela montante_jusante.area_montante_xxx, onde xxx é o id do trecho cur = conn.cursor() cur.execute(string_sql) # se assegura que as alterações da base de dados foram feitas e fecha o cursor e a conexão conn.commit() cur.close() conn.close() # seleciona a tabela montante_jusante.area_mont_xxx - coluna geomproj self.uri.setDataSource('montante_jusante', 'area_mont_' + str(cotrecho) , 'geomproj') #gera o titulo do mapa titulo = 'Area a montante de ' + str(cotrecho) #gera o mapa e acrescenta ao projeto mapa = QgsVectorLayer(self.uri.uri(), titulo, 'postgres') if not mapa.isValid(): raise ErroMapaInvalido QgsMapLayerRegistry.instance().addMapLayer(mapa) # faz com que a cor das bordas das areas de contribuicao seja a do interior e refresca o mapa propriedades = mapa.rendererV2().symbol().symbolLayers()[0].properties() propriedades['outline_color'] = propriedades['color'] mapa.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(propriedades))
def on_mPageStyleButton_clicked(self): if self.timeStart != 0: self.timeEnd = time.time() print self.timeEnd if self.timeEnd - self.timeStart <= 2: self.timeStart = 0 return if ( not self.mComposition ): return coverageLayer = None # use the atlas coverage layer, if any if ( self.mComposition.atlasComposition().enabled() ): coverageLayer = self.mComposition.atlasComposition().coverageLayer() newSymbol = self.mComposition.pageStyleSymbol().clone() if ( not newSymbol ): newSymbol = QgsFillSymbolV2() d = QgsSymbolV2SelectorDialog( newSymbol, QgsStyleV2.defaultStyle(), coverageLayer, self) d.setExpressionContext( self.mComposition.createExpressionContext() ) if ( d.exec_() == QDialog.Accepted ): self.mComposition.setPageStyleSymbol( newSymbol ) self.updatePageStyle() self.timeStart = time.time()
def createChoropleth(self, layer, min, max, num_classes=10): myTargetField = HASC().valueField myRangeList = [] myOpacity = 1 step = (max - min) / num_classes col_step = 256 / (num_classes - 1) for i in range(num_classes): label = str(min + step * i) + " - " + str(min + step * (i + 1)) hex_level = hex(int(col_step * i)).split('x')[1] if (len(hex_level) < 2): hex_level = "0" + hex_level colour = "#" + hex_level + hex_level + hex_level symbol = QgsFillSymbolV2.createSimple({ 'color': colour, 'color_border': colour, 'width_border': '0' }) symbol.setAlpha(myOpacity) myRangeList.append( QgsRendererRangeV2(min + step * i, min + step * (i + 1), symbol, label)) renderer = QgsGraduatedSymbolRendererV2('', myRangeList) renderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval) renderer.setClassAttribute(myTargetField) layer.setRendererV2(renderer)
def test_1(self): sym = self.lines_layer.rendererV2().symbol() sym_layer = QgsArrowSymbolLayer.create({ 'head_length': '6.5', 'head_thickness': '6.5' }) dd = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("arrow_width", dd) dd2 = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("head_length", dd2) dd3 = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("head_thickness", dd3) fill_sym = QgsFillSymbolV2.createSimple({ 'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1' }) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_1') self.assertTrue(renderchecker.runTest('arrowsymbollayer_1'))
def test_2(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({ 'arrow_width': '5', 'head_length': '4', 'head_thickness': '6', 'head_type': '2' }) fill_sym = QgsFillSymbolV2.createSimple({ 'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1' }) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_2') self.assertTrue(renderchecker.runTest('arrowsymbollayer_2'))
def test_unrepeated(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({ 'arrow_width': '7', 'head_length': '6', 'head_thickness': '8', 'head_type': '0', 'arrow_type': '0' }) # no repetition sym_layer.setIsRepeated(False) fill_sym = QgsFillSymbolV2.createSimple({ 'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1' }) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() ms = self.mapsettings ms.setExtent(QgsRectangle(-119, 17, -82, 50)) renderchecker.setMapSettings(ms) renderchecker.setControlName('expected_arrowsymbollayer_4') self.assertTrue(renderchecker.runTest('arrowsymbollayer_4'))
def setUp(self): self.iface = get_iface() polys_shp = os.path.join(TEST_DATA_DIR, 'polys.shp') points_shp = os.path.join(TEST_DATA_DIR, 'points.shp') lines_shp = os.path.join(TEST_DATA_DIR, 'lines.shp') self.polys_layer = QgsVectorLayer(polys_shp, 'Polygons', 'ogr') self.points_layer = QgsVectorLayer(points_shp, 'Points', 'ogr') self.lines_layer = QgsVectorLayer(lines_shp, 'Lines', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(self.polys_layer) QgsMapLayerRegistry.instance().addMapLayer(self.lines_layer) QgsMapLayerRegistry.instance().addMapLayer(self.points_layer) # Create style sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'}) sym2 = QgsLineSymbolV2.createSimple({'color': '#fdbf6f'}) sym3 = QgsMarkerSymbolV2.createSimple({'color': '#fdbf6f'}) self.polys_layer.setRendererV2(QgsSingleSymbolRendererV2(sym1)) self.lines_layer.setRendererV2(QgsSingleSymbolRendererV2(sym2)) self.points_layer.setRendererV2(QgsSingleSymbolRendererV2(sym3)) self.mapsettings = self.iface.mapCanvas().mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-133, 22, -70, 52))
def test_add_symbol_to_legend(self): """Test we can add a symbol to the legend.""" layer, _ = load_layer('test_floodimpact.tif') map_legend = MapLegend(layer) symbol = QgsFillSymbolV2() symbol.setColor(QtGui.QColor(12, 34, 56)) map_legend.add_symbol( symbol, minimum=0, # expect 2.0303 in legend maximum=2.02030, label='Foo') path = unique_filename( prefix='addSymbolToLegend', suffix='.png', dir=temp_dir('test')) map_legend.get_legend().save(path, 'PNG') LOGGER.debug(path) # As we have discovered, different versions of Qt and # OS platforms cause different output, so myControlImages is a list # of 'known good' renders. tolerance = 0 # to allow for version number changes in disclaimer flag, message = check_images( 'addSymbolToLegend', path, tolerance) message += ( '\nWe want these images to match, if they do already, copy the ' 'test image generated to create a new control image.') self.assertTrue(flag, message)
def geraMapaBacia(self, cotrecho, cobacia, dist): # manda gerar a tabela montante_jusante.area_mont_x na base de dados (x é o código do trecho) # gera o string sql string_sql = 'SELECT gera_tabela_topologica(\'area_mont\', ' + str( cotrecho) + ', \'' + cobacia + '\', ' + '{0:.6f}'.format( dist) + ')' # estabelece uma conexão com a base de dados PostGIS com dados da conexao da camada hidrografia armazenados em self.uri_ex conn = psycopg2.connect(host=self.uri_ex.host(), port=self.uri_ex.port(), database=self.uri_ex.database(), user=self.uri_ex.username(), password=self.uri_ex.password()) # executa o comando sql, que gera a tabela montante_jusante.area_montante_xxx, onde xxx é o id do trecho cur = conn.cursor() cur.execute(string_sql) # se assegura que as alterações da base de dados foram feitas e fecha o cursor e a conexão conn.commit() cur.close() conn.close() # seleciona a tabela montante_jusante.area_mont_xxx - coluna geomproj self.uri.setDataSource('montante_jusante', 'area_mont_' + str(cotrecho), 'geomproj') #gera o titulo do mapa titulo = 'Area a montante de ' + str(cotrecho) #gera o mapa e acrescenta ao projeto mapa = QgsVectorLayer(self.uri.uri(), titulo, 'postgres') if not mapa.isValid(): raise ErroMapaInvalido QgsMapLayerRegistry.instance().addMapLayer(mapa) # faz com que a cor das bordas das areas de contribuicao seja a do interior e refresca o mapa propriedades = mapa.rendererV2().symbol().symbolLayers()[0].properties( ) propriedades['outline_color'] = propriedades['color'] mapa.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(propriedades))
def create_qlayer(self): layer=QgsVectorLayer("Polygon"+self.crs,self.prefix+"-cells","memory") # transparent red, no border # but this is the wrong class... symbol = QgsFillSymbolV2.createSimple({'outline_style':'no', 'style':'solid', 'color': '249,0,0,78'}) layer.rendererV2().setSymbol(symbol) return layer
def get_default_symbol( geom_type): symbol = QgsSymbolV2.defaultSymbol(geom_type) if symbol is None: if geom_type == QGis.Point: symbol = QgsMarkerSymbolV2() elif geom_type == QGis.Line: symbol = QgsLineSymbolV2() elif geom_type == QGis.Polygon: symbol = QgsFillSymbolV2() return symbol
def validatedDefaultSymbol(geometryType): symbol = QgsSymbolV2.defaultSymbol(geometryType) if symbol is None: if geometryType == QGis.Point: symbol = QgsMarkerSymbolV2() elif geometryType == QGis.Line: symbol = QgsLineSymbolV2() elif geometryType == QGis.Polygon: symbol = QgsFillSymbolV2() return symbol
def _validated_default_symbol(self, geometryType): """Validates that the symbol is of the correct type, (point, line or polygon and then returning a Qgis type symbol)""" symbol = QgsSymbolV2.defaultSymbol(geometryType) if symbol is None: if geometryType == QGis.Point: symbol = QgsMarkerSymbolV2() elif geometryType == QGis.Line: symbol = QgsLineSymbolV2() elif geometryType == QGis.Polygon: symbol = QgsFillSymbolV2() return symbol
def setUp(self): #Create some simple symbols self.fill_symbol = QgsFillSymbolV2.createSimple({'color': '#ffffff'}) self.line_symbol = QgsLineSymbolV2.createSimple({ 'color': '#ffffff', 'line_width': '3' }) self.marker_symbol = QgsMarkerSymbolV2.createSimple({ 'color': '#ffffff', 'size': '3' }) self.report = "<h1>Python QgsSymbolV2 Tests</h1>\n"
def addParcelleMap(self): ''' Add content in the first page with a map and basic information ''' # First add headers for key, item in self.composerTemplates.items(): if 'sticky' in item: self.buildComposerLabel(key, item, 0) # Get feature extent exp = QgsExpression('"geo_parcelle" = \'%s\'' % self.geo_parcelle) request = QgsFeatureRequest(exp) extent = None features = self.layer.getFeatures(request) for feature in features: geom = feature.geometry() peri = geom.length() buf = peri / 20 extent = geom.buffer(buf, 5).boundingBox() # Add memory layer to highlight parcelle if extent: if self.redlineLayer: QgsMapLayerRegistry.instance().removeMapLayer( self.redlineLayer.id()) crs = self.layer.crs().authid() vl = QgsVectorLayer("Polygon?crs=" + crs, "temporary", "memory") pr = vl.dataProvider() vl.startEditing() pr.addFeatures([f for f in self.layer.getFeatures(request)]) vl.commitChanges() vl.updateExtents() props = vl.rendererV2().symbol().symbolLayer(0).properties() props['outline_width'] = u'1' props['outline_color'] = u'0,85,255,255' props['outline_style'] = u'solid' props['style'] = u'no' vl.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(props)) QgsMapLayerRegistry.instance().addMapLayer(vl) self.redlineLayer = vl # Add composer map & to parcelle miLayers = self.mInstance.layers() miLayers.insert(0, vl.id()) self.mInstance.setLayers(miLayers) cm = QgsComposerMap(self.currentComposition, 6, 15, 286, 190) if extent: cm.zoomToExtent(extent) cm.setFrameEnabled(True) cm.setBackgroundEnabled(True) self.currentComposition.addItem(cm)
def prepare_renderer(levels, inter_time, lenpoly): cats = [('{} - {} min'.format(levels[i] - inter_time, levels[i]), levels[i] - inter_time, levels[i]) for i in xrange(lenpoly)] # label, lower bound, upper bound colors = get_isochrones_colors(len(levels)) ranges = [] for ix, cat in enumerate(cats): symbol = QgsFillSymbolV2() symbol.setColor(QtGui.QColor(colors[ix])) rng = QgsRendererRangeV2(cat[1], cat[2], symbol, cat[0]) ranges.append(rng) expression = 'max' return QgsGraduatedSymbolRendererV2(expression, ranges)
def testSymbolColor(self): # Create rulebased style sym1 = QgsFillSymbolV2.createSimple({'color': '#ff0000'}) renderer = QgsSingleSymbolRendererV2(sym1) renderer.symbols()[0].symbolLayers()[0].setDataDefinedProperty('color', 'set_color_part( @symbol_color, \'value\', "Value" * 4)') self.layer.setRendererV2(renderer) # Setup rendering check renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_symbol_color_variable') result = renderchecker.runTest('symbol_color_variable', 50) self.assertTrue(result)
def testPartCount(self): # Create rulebased style sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'}) renderer = QgsSingleSymbolRendererV2(sym1) renderer.symbols()[0].symbolLayers()[0].setDataDefinedProperty('color', 'color_rgb( (@geometry_part_count - 1) * 200, 0, 0 )') self.layer.setRendererV2(renderer) # Setup rendering check renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_geometry_part_count') result = renderchecker.runTest('part_geometry_part_count') self.assertTrue(result)
def test_2(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({'arrow_width': '5', 'head_length': '4', 'head_thickness': '6', 'head_type': '2'}) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_2') self.assertTrue(renderchecker.runTest('arrowsymbollayer_2'))
def geraMapaBacia(self, cotrecho, cobacia, dist, id_trecho): # seleciona a tabela area_contrib_eq - coluna geomproj self.uri.setDataSource('public', 'area_contrib', 'geomproj') # gera o string sql string_sql = '"cotrecho" IN (SELECT * FROM tr_md(\'' + cobacia + '\', ' + '{0:f}'.format(dist) + '))' self.uri.setSql(string_sql) #gera o titulo do mapa titulo = 'Area a montante de ' + str(cotrecho) #gera o mapa e acrescenta ao projeto mapa = QgsVectorLayer(self.uri.uri(), titulo, 'postgres') if not mapa.isValid(): raise ErroMapaInvalido QgsMapLayerRegistry.instance().addMapLayer(mapa) # faz com que a cor das bordas das areas de contribuicao seja a do interior e refresca o mapa propriedades = mapa.rendererV2().symbol().symbolLayers()[0].properties() propriedades['outline_color'] = propriedades['color'] mapa.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(propriedades))
def setUp(self): myShpFile = os.path.join(TEST_DATA_DIR, 'polys_overlapping.shp') layer = QgsVectorLayer(myShpFile, 'Polygons', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(layer) # Create style sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'}) self.renderer = QgsSingleSymbolRendererV2(sym1) layer.setRendererV2(self.renderer) self.mapsettings = CANVAS.mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-133, 22, -70, 52)) rendered_layers = [layer.id()] self.mapsettings.setLayers(rendered_layers)
def setUp(self): myShpFile = os.path.join(TEST_DATA_DIR, 'polys_overlapping.shp') layer = QgsVectorLayer(myShpFile, 'Polys', 'ogr') QgsMapLayerRegistry.instance().addMapLayer(layer) # Create rulebased style sym1 = QgsFillSymbolV2.createSimple({'color': '#fdbf6f'}) self.renderer = QgsSingleSymbolRendererV2(sym1) layer.setRendererV2(self.renderer) rendered_layers = [layer.id()] self.mapsettings = CANVAS.mapSettings() self.mapsettings.setOutputSize(QSize(400, 400)) self.mapsettings.setOutputDpi(96) self.mapsettings.setExtent(QgsRectangle(-163, 22, -70, 52)) self.mapsettings.setLayers(rendered_layers)
def test_3(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({'arrow_width': '7', 'head_length': '6', 'head_thickness': '8', 'head_type': '0', 'arrow_type': '1', 'is_curved': '0'}) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() ms = self.mapsettings ms.setExtent(QgsRectangle(-101, 35, -99, 37)) renderchecker.setMapSettings(ms) renderchecker.setControlName('expected_arrowsymbollayer_3') self.assertTrue(renderchecker.runTest('arrowsymbollayer_3'))
def test_1(self): sym = self.lines_layer.rendererV2().symbol() sym_layer = QgsArrowSymbolLayer.create({'head_size': '6.5'}) dd = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("arrow_width", dd) dd2 = QgsDataDefined("(@geometry_point_num % 4) * 2") sym_layer.setDataDefinedProperty("head_size", dd2) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() renderchecker.setMapSettings(self.mapsettings) renderchecker.setControlName('expected_arrowsymbollayer_1') self.assertTrue(renderchecker.runTest('arrowsymbollayer_1'))
def createLayerGrille(uriGrille): layerGrille = QgsVectorLayer(uriGrille, CONST_NOM_LAYER_GRILLE, "ogr") fieldIndex = getFieldIndex(layerGrille) if fieldIndex < 0: caps = layerGrille.dataProvider().capabilities() if caps & QgsVectorDataProvider.AddAttributes: layerGrille.dataProvider().addAttributes( [QgsField(CONST_ATTRIBUT_ID, QVariant.Int)]) layerGrille.updateFields() # Style props = {'color': '241,241,241,0', 'size': '1', 'color_border': '255,0,0'} s = QgsFillSymbolV2.createSimple(props) layerGrille.setRendererV2(QgsSingleSymbolRendererV2(s)) return layerGrille
def geraMapaBacia(self, cotrecho, cobacia, dist, id_trecho): # seleciona a tabela area_contrib_eq - coluna geomproj self.uri.setDataSource('public', 'area_contrib', 'geomproj') # gera o string sql string_sql = '"cotrecho" IN (SELECT * FROM tr_md(\'' + cobacia + '\', ' + '{0:f}'.format( dist) + '))' self.uri.setSql(string_sql) #gera o titulo do mapa titulo = 'Area a montante de ' + str(cotrecho) #gera o mapa e acrescenta ao projeto mapa = QgsVectorLayer(self.uri.uri(), titulo, 'postgres') if not mapa.isValid(): raise ErroMapaInvalido QgsMapLayerRegistry.instance().addMapLayer(mapa) # faz com que a cor das bordas das areas de contribuicao seja a do interior e refresca o mapa propriedades = mapa.rendererV2().symbol().symbolLayers()[0].properties( ) propriedades['outline_color'] = propriedades['color'] mapa.rendererV2().setSymbol(QgsFillSymbolV2.createSimple(propriedades))
def test_unrepeated(self): sym = self.lines_layer.rendererV2().symbol() # double headed sym_layer = QgsArrowSymbolLayer.create({'arrow_width': '7', 'head_width': '6', 'head_height': '8', 'head_type': '0', 'arrow_type': '0'}) # no repetition sym_layer.setIsRepeated(False) fill_sym = QgsFillSymbolV2.createSimple({'color': '#8bcfff', 'outline_color': '#000000', 'outline_style': 'solid', 'outline_width': '1'}) sym_layer.setSubSymbol(fill_sym) sym.changeSymbolLayer(0, sym_layer) rendered_layers = [self.lines_layer.id()] self.mapsettings.setLayers(rendered_layers) renderchecker = QgsMultiRenderChecker() ms = self.mapsettings ms.setExtent(QgsRectangle(-119, 17, -82, 50)) renderchecker.setMapSettings(ms) renderchecker.setControlName('expected_arrowsymbollayer_4') self.assertTrue(renderchecker.runTest('arrowsymbollayer_4'))
def create_virtual_layer(self, virtual_layer_name): sql = ("SELECT value FROM " + self.controller.schema_name + ".config_param_user" " WHERE cur_user = current_user AND parameter = 'virtual_layer_polygon'") row = self.controller.get_row(sql) if not row: sql = ("INSERT INTO "+self.schema_name + ".config_param_user (parameter, value, cur_user) " " VALUES ('virtual_layer_polygon', '"+virtual_layer_name+"', current_user)") self.controller.execute_sql(sql) srid = self.controller.plugin_settings_value('srid') uri = "Polygon?crs=epsg:" + str(srid) virtual_layer = QgsVectorLayer(uri, virtual_layer_name, "memory") props = {'color': '0, 0, 0', 'style': 'no', 'style_border': 'solid', 'color_border': '255, 0, 0'} s = QgsFillSymbolV2.createSimple(props) virtual_layer.setRendererV2(QgsSingleSymbolRendererV2(s)) virtual_layer.updateExtents() QgsProject.instance().setSnapSettingsForLayer(virtual_layer.id(), True, 2, 0, 1.0, False) QgsMapLayerRegistry.instance().addMapLayer(virtual_layer) self.iface.mapCanvas().refresh()
def __init__(self, iface, name, color, attributes, layer_group=None, out_color=None, w="0.1", visible=True): "..." if out_color is None: out_color = color WGS84Layer.__init__(self, iface, name, "Polygon", visible, layer_group) props = self.layer.rendererV2().symbol().symbolLayer(0).properties() props['color'] = color props['outline_color'] = out_color props['outline_width'] = w fill_symbol = QgsFillSymbolV2.createSimple(props) self.layer.rendererV2().setSymbol(fill_symbol) WGS84Layer.refresh_legend(self) self.set_attributes(attributes)
def testCase(self): self.TEST_DATA_DIR = unitTestDataPath() vectorFileInfo = QFileInfo( self.TEST_DATA_DIR + "/france_parts.shp") mVectorLayer = QgsVectorLayer( vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr" ) QgsMapLayerRegistry.instance().addMapLayers( [mVectorLayer] ) # create composition with composer map mMapRenderer = QgsMapRenderer() layerStringList = [] layerStringList.append( mVectorLayer.id() ) mMapRenderer.setLayerSet( layerStringList ) mMapRenderer.setProjectionsEnabled( True ) mMapRenderer.setMapUnits( QGis.Meters ) # select epsg:2154 crs = QgsCoordinateReferenceSystem() crs.createFromSrid( 2154 ) mMapRenderer.setDestinationCrs( crs ) self.mComposition = QgsComposition( mMapRenderer ) self.mComposition.setPaperSize( 297, 210 ) # fix the renderer, fill with green props = { "color": "0,127,0" } fillSymbol = QgsFillSymbolV2.createSimple( props ) renderer = QgsSingleSymbolRendererV2( fillSymbol ) mVectorLayer.setRendererV2( renderer ) # the atlas map self.mAtlasMap = QgsComposerMap( self.mComposition, 20, 20, 130, 130 ) self.mAtlasMap.setFrameEnabled( True ) self.mComposition.addComposerMap( self.mAtlasMap ) # the atlas self.mAtlas = self.mComposition.atlasComposition() self.mAtlas.setCoverageLayer( mVectorLayer ) self.mAtlas.setEnabled( True ) self.mComposition.setAtlasMode( QgsComposition.ExportAtlas ) # an overview mOverview = QgsComposerMap( self.mComposition, 180, 20, 50, 50 ) mOverview.setFrameEnabled( True ) mOverview.setOverviewFrameMap( self.mAtlasMap.id() ) self.mComposition.addComposerMap( mOverview ) nextent = QgsRectangle( 49670.718, 6415139.086, 699672.519, 7065140.887 ) mOverview.setNewExtent( nextent ) # set the fill symbol of the overview map props2 = { "color": "127,0,0,127" } fillSymbol2 = QgsFillSymbolV2.createSimple( props2 ) mOverview.setOverviewFrameMapSymbol( fillSymbol2 ) # header label self.mLabel1 = QgsComposerLabel( self.mComposition ) self.mComposition.addComposerLabel( self.mLabel1 ) self.mLabel1.setText( "[% \"NAME_1\" %] area" ) self.mLabel1.setFont( QgsFontUtils.getStandardTestFont() ) self.mLabel1.adjustSizeToText() self.mLabel1.setSceneRect( QRectF( 150, 5, 60, 15 ) ) qWarning( "header label font: %s exactMatch:%s" % ( self.mLabel1.font().toString(), self.mLabel1.font().exactMatch() ) ) # feature number label self.mLabel2 = QgsComposerLabel( self.mComposition ) self.mComposition.addComposerLabel( self.mLabel2 ) self.mLabel2.setText( "# [%$feature || ' / ' || $numfeatures%]" ) self.mLabel2.setFont( QgsFontUtils.getStandardTestFont() ) self.mLabel2.adjustSizeToText() self.mLabel2.setSceneRect( QRectF( 150, 200, 60, 15 ) ) qWarning( "feature number label font: %s exactMatch:%s" % ( self.mLabel2.font().toString(), self.mLabel2.font().exactMatch() ) ) self.filename_test() self.autoscale_render_test() self.autoscale_render_test_old_api() self.fixedscale_render_test() self.predefinedscales_render_test() self.hidden_render_test()
def gen_cl(color, val, label): sym = QgsFillSymbolV2.createSimple({}) sym.setColor(QColor(*color)) cat = QgsRendererCategoryV2(val, sym, label) return cat
def gen_cl(ramp, val, ramp_val, label): sym = QgsFillSymbolV2.createSimple({}) sym.setColor(ramp.color(ramp_val)) cat = QgsRendererCategoryV2(val, sym, label) return cat
def add_source_layers(self, sources): """ :param list sources: a list of nrmllib Source Models (e.g. SimpleFaultSource) """ source_type = collections.namedtuple( 'SourceType', 'layer_type transform color') geometries = { 'PointSource': source_type( 'Point', lambda x: x.geometry.wkt, "255,255,255,185"), 'AreaSource': source_type( 'Polygon', lambda x: x.geometry.wkt, '0,255,255,185'), 'SimpleFaultSource': source_type( 'Polygon', lambda x: simple_surface_from_source(x).wkt, '0,50,255,185'), 'ComplexFaultSource': source_type( 'MultiPolygon', lambda _: NotImplementedError, '50,50,50,185')} source_dict = collections.defaultdict(list) for s in sources: source_dict[s.__class__.__name__].append(s) for stype, sources in source_dict.items(): layer = QgsVectorLayer( '%s?crs=epsg:4326' % ( geometries[stype].layer_type), stype, 'memory') QgsMapLayerRegistry.instance().addMapLayer(layer) pr = layer.dataProvider() layer.startEditing() fields = [QgsField("source_id", QVariant.String)] pr.addAttributes(fields) qgs_fields = QgsFields() for field in fields: qgs_fields.append(field) features = [] for src in sources: fet = QgsFeature() fet.setFields(qgs_fields) fet['source_id'] = src.id if stype == 'SimpleFaultSource': self.sources[src.id] = _nrml_to_hazardlib(src, 1.) fet.setGeometry(QgsGeometry.fromWkt( geometries[stype].transform(src))) features.append(fet) pr.addFeatures(features) layer.commitChanges() layer.updateExtents() symbol = QgsFillSymbolV2.createSimple( {'style': 'diagonal_x', 'color': geometries[stype].color, 'style_border': 'solid'}) layer.setRendererV2(QgsSingleSymbolRendererV2(symbol)) self.source_layers[stype] = layer self.reset_map()
def testCase(self): self.TEST_DATA_DIR = unitTestDataPath() tmppath = tempfile.mkdtemp() for file in glob.glob( os.path.join(self.TEST_DATA_DIR, 'france_parts.*')): shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath) vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp") mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr") QgsMapLayerRegistry.instance().addMapLayers([mVectorLayer]) # create composition with composer map self.mapSettings = QgsMapSettings() layerStringList = [] layerStringList.append(mVectorLayer.id()) self.mapSettings.setLayers(layerStringList) self.mapSettings.setCrsTransformEnabled(True) self.mapSettings.setMapUnits(QGis.Meters) # select epsg:2154 crs = QgsCoordinateReferenceSystem() crs.createFromSrid(2154) self.mapSettings.setDestinationCrs(crs) self.mComposition = QgsComposition(self.mapSettings) self.mComposition.setPaperSize(297, 210) # fix the renderer, fill with green props = {"color": "0,127,0"} fillSymbol = QgsFillSymbolV2.createSimple(props) renderer = QgsSingleSymbolRendererV2(fillSymbol) mVectorLayer.setRendererV2(renderer) # the atlas map self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130) self.mAtlasMap.setFrameEnabled(True) self.mComposition.addComposerMap(self.mAtlasMap) # the atlas self.mAtlas = self.mComposition.atlasComposition() self.mAtlas.setCoverageLayer(mVectorLayer) self.mAtlas.setEnabled(True) self.mComposition.setAtlasMode(QgsComposition.ExportAtlas) # an overview mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50) mOverview.setFrameEnabled(True) mOverview.setOverviewFrameMap(self.mAtlasMap.id()) self.mComposition.addComposerMap(mOverview) nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887) mOverview.setNewExtent(nextent) # set the fill symbol of the overview map props2 = {"color": "127,0,0,127"} fillSymbol2 = QgsFillSymbolV2.createSimple(props2) mOverview.setOverviewFrameMapSymbol(fillSymbol2) # header label self.mLabel1 = QgsComposerLabel(self.mComposition) self.mComposition.addComposerLabel(self.mLabel1) self.mLabel1.setText("[% \"NAME_1\" %] area") self.mLabel1.setFont(QgsFontUtils.getStandardTestFont()) self.mLabel1.adjustSizeToText() self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15)) qWarning( "header label font: %s exactMatch:%s" % (self.mLabel1.font().toString(), self.mLabel1.font().exactMatch())) # feature number label self.mLabel2 = QgsComposerLabel(self.mComposition) self.mComposition.addComposerLabel(self.mLabel2) self.mLabel2.setText("# [%$feature || ' / ' || $numfeatures%]") self.mLabel2.setFont(QgsFontUtils.getStandardTestFont()) self.mLabel2.adjustSizeToText() self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15)) qWarning( "feature number label font: %s exactMatch:%s" % (self.mLabel2.font().toString(), self.mLabel2.font().exactMatch())) self.filename_test() self.autoscale_render_test() self.autoscale_render_test_old_api() self.fixedscale_render_test() self.predefinedscales_render_test() self.hidden_render_test() self.legend_test() shutil.rmtree(tmppath, True)
def download(self, url): # Test if permalink is valid pattern = r"^(https?:\/\/(\w+[\w\-\.\:\/])+)\?((\&+)?(\w+)\=?([\w\-\.\:\,]+?)?)+(\&+)?$" if not re.match(pattern, self.url): raise Exception(u"Le permalien n'est pas valide.") # Extract params from url params = parse_qs(urlparse(self.url).query) # Check mandatory parameters try: context = str(params[r"context"][0]) center = params[r"centre"][0] except: raise Exception(u"Les paramètres \'Context\' et \'Centre\' sont obligatoires.") auth_contexts = [r"metropole", r"guadeloupe", r"stmartin", r"stbarthelemy", r"guyane", r"reunion", r"mayotte"] # Check if context is valid if context not in auth_contexts: raise Exception(u"La valeur \'%s\' est incorrecte.\n\n" u"\'Context\' doit prentre une des %s valeurs suivantes: " u"%s" % (context, len(auth_contexts), ", ".join(auth_contexts))) self.zone = context if self.zone in [r"guadeloupe", r"stmartin", r"stbarthelemy"]: self.zone = r"antilles" # Check if XY are valid if not re.match(r"^\-?\d+,\-?\d+$", center): raise Exception(u"Les coordonnées XY du centre sont incorrectes.") # Extract XY (¢re) xcenter = int(center.split(r",")[0]) ycenter = int(center.split(r",")[1]) # Compute the bbox xmin = xcenter - self.conn.extract_lim / 2 xmax = xcenter + self.conn.extract_lim / 2 ymin = ycenter - self.conn.extract_lim / 2 ymax = ycenter + self.conn.extract_lim / 2 # Transform coordinates in WGS84 bbox = tools.reproj(QgsRectangle(xmin, ymin, xmax, ymax), 3857, 4326) # Extract RFU (Send the request) resp = self.conn.extraction(bbox.xMinimum(), bbox.yMinimum(), bbox.xMaximum(), bbox.yMaximum()) if resp.code != 200: raise Exception(resp.read()) tree = EltTree.fromstring(resp.read()) # Check if error err = tree.find(r"./erreur") if err: raise Exception(err.text) # Create the layer: "Masque d'extraction" self.l_bbox = QgsVectorLayer(r"Polygon?crs=epsg:4326&index=yes", u"Zone de travail", r"memory") p_bbox = self.l_bbox.dataProvider() simple_symbol = QgsFillSymbolV2.createSimple({ r"color": r"116,97,87,255", r"style": r"b_diagonal", r"outline_style": r"no"}) renderer_bbox = QgsInvertedPolygonRenderer(QgsSingleSymbolRendererV2(simple_symbol)) self.l_bbox.setRendererV2(renderer_bbox) ft_bbox = QgsFeature() ft_bbox.setGeometry(QgsGeometry.fromRect(QgsRectangle(bbox.xMinimum(), bbox.yMinimum(), bbox.xMaximum(), bbox.yMaximum()))) p_bbox.addFeatures([ft_bbox]) self.l_bbox.updateFields() self.l_bbox.updateExtents() # Create layers.. self.layers = self.extract_layers(tree) self.l_vertex = self.layers[0] self.l_edge = self.layers[1] # Add layer to the registry self.map_layer_registry.addMapLayers([self.l_vertex, self.l_edge, self.l_bbox]) # Set the map canvas layer set self.canvas.setLayerSet([QgsMapCanvasLayer(self.l_vertex), QgsMapCanvasLayer(self.l_edge), QgsMapCanvasLayer(self.l_bbox)]) # Set extent self.canvas.setExtent(QgsRectangle(bbox.xMinimum(), bbox.yMinimum(), bbox.xMaximum(), bbox.yMaximum())) self.features_vertex_backed_up = \ dict((ft[r"fid"], ft) for ft in self.get_features(self.l_vertex)) self.features_edge_backed_up = \ dict((ft[r"fid"], ft) for ft in self.get_features(self.l_edge)) # Get Capabitilies resp = self.conn.get_capabilities(self.zone) if resp.code != 200: raise Exception(resp.read()) tree = EltTree.fromstring(resp.read()) err = tree.find(r"./erreur") if err: raise Exception(err.text) for entry in tree.findall(r"./classe_rattachement/classe"): t = (entry.attrib[r"som_precision_rattachement"], entry.text) self.precision_class.append(t) for entry in tree.findall(r"./representation_plane_sommet_autorise/representation_plane_sommet"): t = (entry.attrib[r"som_representation_plane"], entry.attrib[r"epsg_crs_id"], entry.text) self.ellips_acronym.append(t) for entry in tree.findall(r"./nature_sommet_conseille/nature"): self.nature.append(entry.text) for entry in tree.findall(r"./som_ge_createur_autorise/som_ge_createur"): t = (entry.attrib[r"num_ge"], entry.text) self.auth_creator.append(t) try: ft = next(ft for ft in self.l_vertex.getFeatures()) ft_attrib = tools.attrib_as_kv(ft.fields(), ft.attributes()) self.dflt_ellips_acronym = ft_attrib[r"som_representation_plane"] except: self.dflt_ellips_acronym = None for i, e in enumerate(self.ellips_acronym): self.projComboBox.addItem(e[2]) if not self.dflt_ellips_acronym: continue if self.dflt_ellips_acronym == e[0]: # Check projection in combobox self.projComboBox.setCurrentIndex(i) # Activate 'On The Fly' self.canvas.setCrsTransformEnabled(True) # Then change the CRS in canvas crs = QgsCoordinateReferenceSystem(int(e[1]), QgsCoordinateReferenceSystem.EpsgCrsId) self.canvas.setDestinationCrs(crs) # Then, start editing mode.. for layer in self.layers: if not layer.isEditable(): layer.startEditing() self.projComboBox.setDisabled(False) self.permalinkLineEdit.setDisabled(True) self.downloadPushButton.setDisabled(True) self.resetPushButton.setDisabled(False) self.uploadPushButton.setDisabled(False) self.downloadPushButton.clicked.disconnect(self.on_downloaded) self.permalinkLineEdit.returnPressed.disconnect(self.on_downloaded) self.resetPushButton.clicked.connect(self.on_reset) self.uploadPushButton.clicked.connect(self.on_uploaded) self.downloaded.emit() return True
def aggregate(self, theSafeImpactLayer): """Do any requested aggregation post processing. Performs Aggregation postprocessing step by * creating a copy of the dataset clipped by the impactlayer bounding box * stripping all attributes beside the aggregation attribute * delegating to the appropriate aggregator for raster and vectors :raises: ReadLayerError """ if not self.isValid: raise InvalidAggregatorError myMessage = m.Message( m.Heading(self.tr('Aggregating results'), **PROGRESS_UPDATE_STYLE), m.Paragraph(self.tr( 'This may take a little while - we are aggregating the impact' ' by %1').arg(self.layer.name()))) self._sendMessage(myMessage) myQGISImpactLayer = safe_to_qgis_layer(theSafeImpactLayer) if not myQGISImpactLayer.isValid(): myMessage = self.tr('Error when reading %1').arg(myQGISImpactLayer) # noinspection PyExceptionInherit raise ReadLayerError(myMessage) myLayerName = str(self.tr('%1 aggregated to %2').arg( myQGISImpactLayer.name()).arg(self.layer.name())) #delete unwanted fields myProvider = self.layer.dataProvider() myFields = myProvider.fields() #mark important attributes as needed self._setPersistantAttributes() myUnneededAttributes = [] for i in myFields: if (myFields[i].name() not in self.attributes.values()): myUnneededAttributes.append(i) LOGGER.debug('Removing this attributes: ' + str(myUnneededAttributes)) # noinspection PyBroadException try: self.layer.startEditing() myProvider.deleteAttributes(myUnneededAttributes) self.layer.commitChanges() # FIXME (Ole): Disable pylint check for the moment # Need to work out what exceptions we will catch here, though. except: # pylint: disable=W0702 myMessage = self.tr('Could not remove the unneeded fields') LOGGER.debug(myMessage) del myUnneededAttributes, myProvider, myFields self.keywordIO.update_keywords( self.layer, {'title': myLayerName}) self.statisticsType, self.statisticsClasses = ( self.keywordIO.get_statistics(myQGISImpactLayer)) #call the correct aggregator if myQGISImpactLayer.type() == QgsMapLayer.VectorLayer: self._aggregateVectorImpact(myQGISImpactLayer, theSafeImpactLayer) elif myQGISImpactLayer.type() == QgsMapLayer.RasterLayer: self._aggregateRasterImpact(myQGISImpactLayer) else: myMessage = self.tr('%1 is %2 but it should be either vector or ' 'raster').\ arg(myQGISImpactLayer.name()).arg(myQGISImpactLayer.type()) # noinspection PyExceptionInherit raise ReadLayerError(myMessage) # show a styled aggregation layer if self.showIntermediateLayers: if self.statisticsType == 'sum': #style layer if we are summing myProvider = self.layer.dataProvider() myAttr = self._sumFieldName() myAttrIndex = myProvider.fieldNameIndex(myAttr) myProvider.select([myAttrIndex], QgsRectangle(), False) myFeature = QgsFeature() myHighestVal = 0 while myProvider.nextFeature(myFeature): myAttrMap = myFeature.attributeMap() myVal, ok = myAttrMap[myAttrIndex].toInt() if ok and myVal > myHighestVal: myHighestVal = myVal myClasses = [] myColors = ['#fecc5c', '#fd8d3c', '#f31a1c'] myStep = int(myHighestVal / len(myColors)) myCounter = 0 for myColor in myColors: myMin = myCounter myCounter += myStep myMax = myCounter myClasses.append( {'min': myMin, 'max': myMax, 'colour': myColor, 'transparency': 30, 'label': '%s - %s' % (myMin, myMax)}) myCounter += 1 myStyle = {'target_field': myAttr, 'style_classes': myClasses} set_vector_graduated_style(self.layer, myStyle) else: #make style of layer pretty much invisible myProps = {'style': 'no', 'color_border': '0,0,0,127', 'width_border': '0.0' } # noinspection PyCallByClass,PyTypeChecker,PyArgumentList mySymbol = QgsFillSymbolV2.createSimple(myProps) myRenderer = QgsSingleSymbolRendererV2(mySymbol) self.layer.setRendererV2(myRenderer) self.layer.saveDefaultStyle()
raster_legend = atlas_legend.modelV2().rootGroup().addLayer(raster_layer) QgsLegendRenderer.setNodeLegendStyle(raster_legend, QgsComposerLegendStyle.Hidden) atlas_legend.updateLegend() # atlas_legend.refreshLayerLegend(raster_legend) stats_table = composition.getComposerItemById("stats_table").multiFrame() stats_table.setContentMode(QgsComposerHtml.ManualHtml) title_label = composition.getComposerItemById("title_label") title_text = title_label.text() description_label = composition.getComposerItemById("description_label") description_text = description_label.text() # Set a rule based style to highlight the atlas feature normal_style = QgsFillSymbolV2().createSimple( { "color": "#000000", "color_border": "#000000", "width_border": "0.25", "style": "no", } ) highlight_style = QgsFillSymbolV2().createSimple( { "color": "#000000", "color_border": "#ff0000", "width_border": "0.85", "style": "no", } ) highlight_rule = QgsRuleBasedRendererV2.Rule(highlight_style) highlight_rule.setFilterExpression("$id = @atlas_featureid") highlight_renderer = QgsRuleBasedRendererV2(normal_style) highlight_renderer.rootRule().appendChild(highlight_rule)
def setUp(self): #Create some simple symbols self.fill_symbol = QgsFillSymbolV2.createSimple({'color': '#ffffff'}) self.line_symbol = QgsLineSymbolV2.createSimple({'color': '#ffffff', 'line_width': '3'}) self.marker_symbol = QgsMarkerSymbolV2.createSimple({'color': '#ffffff', 'size': '3'}) self.report = "<h1>Python QgsSymbolV2 Tests</h1>\n"
def setUp(self): # Create some simple symbols self.fill_symbol = QgsFillSymbolV2.createSimple({"color": "#ffffff"}) self.line_symbol = QgsLineSymbolV2.createSimple({"color": "#ffffff", "line_width": "3"}) self.marker_symbol = QgsMarkerSymbolV2.createSimple({"color": "#ffffff", "size": "3"}) self.report = "<h1>Python QgsSymbolV2 Tests</h1>\n"