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 __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 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 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 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 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 gen_cl(ramp, val, ramp_val, label):
sym = QgsFillSymbolV2.createSimple({})
sym.setColor(ramp.color(ramp_val))
cat = QgsRendererCategoryV2(val, sym, label)
return cat
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"
def gen_cl(color, val, label):
sym = QgsFillSymbolV2.createSimple({})
sym.setColor(QColor(*color))
cat = QgsRendererCategoryV2(val, sym, label)
return cat
