def update_syms(self, catalogue):
self.syms = {}
for flag in set(catalogue.data['Cluster_Flag'].tolist()):
for index in set(catalogue.data['Cluster_Index'].tolist()):
# main shock
point = QgsMarkerSymbolV2.createSimple(
{'color': 'blue', 'name': 'square'})
if index: # belongs to a cluster
color = self.catalogue_model.cluster_color(index)
# non poissonian
if flag:
point = QgsMarkerSymbolV2.createSimple(
{'color': 'blue', 'name': 'triangle'})
color.setAlpha(125 + 125 * abs(flag))
point.setSize(3)
point.setColor(color)
else:
point = QgsSymbolV2.defaultSymbol(QGis.Point)
point.setColor(QtGui.QColor("0,0,0,125"))
point.setSize(1.5)
self.syms[self.Cluster(index, flag)] = point
def legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer("Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPoint(QgsPoint(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPoint(QgsPoint(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRendererV2("attr", [QgsRendererCategoryV2(1, QgsMarkerSymbolV2.createSimple({"color": "255,0,0"}), "red"),
QgsRendererCategoryV2(2, QgsMarkerSymbolV2.createSimple({"color": "0,0,255"}), "blue")])
ptLayer.setRendererV2(r)
QgsMapLayerRegistry.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.mapSettings.layers()
layers = [ptLayer.id()] + layers
self.mapSettings.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mapSettings.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsMapLayerRegistry.instance().removeMapLayer(ptLayer.id())
def testConvertFromCategorisedRenderer(self):
# Test converting categorised renderer to rule based
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategoryV2(1, QgsMarkerSymbolV2(), "id 1"))
cats.append(QgsRendererCategoryV2(2, QgsMarkerSymbolV2(), "id 2"))
cats.append(
QgsRendererCategoryV2('a\'b', QgsMarkerSymbolV2(), "id a'b"))
cats.append(
QgsRendererCategoryV2('a\nb', QgsMarkerSymbolV2(), "id a\\nb"))
cats.append(
QgsRendererCategoryV2('a\\b', QgsMarkerSymbolV2(), "id a\\\\b"))
cats.append(
QgsRendererCategoryV2('a\tb', QgsMarkerSymbolV2(), "id a\\tb"))
c = QgsCategorizedSymbolRendererV2("id", cats)
r = QgsRuleBasedRendererV2.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"id" = 2')
self.assertEqual(r.rootRule().children()[2].filterExpression(),
'"id" = \'a\'\'b\'')
self.assertEqual(r.rootRule().children()[3].filterExpression(),
'"id" = \'a\\nb\'')
self.assertEqual(r.rootRule().children()[4].filterExpression(),
'"id" = \'a\\\\b\'')
self.assertEqual(r.rootRule().children()[5].filterExpression(),
'"id" = \'a\\tb\'')
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategoryV2(1, QgsMarkerSymbolV2(), "result 1"))
cats.append(QgsRendererCategoryV2(2, QgsMarkerSymbolV2(), "result 2"))
c = QgsCategorizedSymbolRendererV2("id + 1", cats)
r = QgsRuleBasedRendererV2.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'id + 1 = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'id + 1 = 2')
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategoryV2(1, QgsMarkerSymbolV2(), "result 1"))
cats.append(QgsRendererCategoryV2(2, QgsMarkerSymbolV2(), "result 2"))
c = QgsCategorizedSymbolRendererV2('"id"', cats)
r = QgsRuleBasedRendererV2.convertFromRenderer(c)
self.assertEqual(r.rootRule().children()[0].filterExpression(),
'"id" = 1')
self.assertEqual(r.rootRule().children()[1].filterExpression(),
'"id" = 2')
def buildRenderer(self, xAttr, yAttr):
color = QColor(randint(0, 255), randint(0, 255), randint(0, 255))
symbol = QgsMarkerSymbolV2.createSimple({})
symbol.deleteSymbolLayer(0)
prop = QgsDataDefined()
prop.setField("size")
prop.setActive(True)
symbol_layer = QgsSimpleMarkerSymbolLayerV2()
symbol_layer.setColor(color)
symbol_layer.setOutputUnit(QgsSymbolV2.MapUnit)
symbol_layer.setDataDefinedProperty("size", prop)
symbol.appendSymbolLayer(symbol_layer)
symbol_layer = QgsVectorFieldSymbolLayer()
symbol_layer.setColor(color)
symbol_layer.VectorFieldType(QgsVectorFieldSymbolLayer.Cartesian)
symbol_layer.AngleUnits(QgsVectorFieldSymbolLayer.Degrees)
symbol_layer.setScale(2.0)
symbol_layer.setXAttribute(xAttr)
symbol_layer.setYAttribute(yAttr)
subSymbol = self.subRenderer(color)
symbol_layer.setSubSymbol(subSymbol)
symbol.appendSymbolLayer(symbol_layer)
renderer = QgsSingleSymbolRendererV2(symbol)
return renderer
def testSize(self):
# test size and setSize
# create a marker symbol with a single layer
markerSymbol = QgsMarkerSymbolV2()
markerSymbol.deleteSymbolLayer(0)
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10))
self.assertEqual(markerSymbol.size(), 10)
markerSymbol.setSize(20)
self.assertEqual(markerSymbol.size(), 20)
self.assertEqual(markerSymbol.symbolLayer(0).size(), 20)
# add additional layers
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10))
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 30))
self.assertEqual(markerSymbol.size(), 30)
markerSymbol.setSize(3)
self.assertEqual(markerSymbol.size(), 3)
# layer sizes should maintain relative size
self.assertEqual(markerSymbol.symbolLayer(0).size(), 2)
self.assertEqual(markerSymbol.symbolLayer(1).size(), 1)
self.assertEqual(markerSymbol.symbolLayer(2).size(), 3)
def testAngle(self):
# test angle and setAngle
# create a marker symbol with a single layer
markerSymbol = QgsMarkerSymbolV2()
markerSymbol.deleteSymbolLayer(0)
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10, 90))
self.assertEqual(markerSymbol.angle(), 90)
markerSymbol.setAngle(100)
self.assertEqual(markerSymbol.angle(), 100)
self.assertEqual(markerSymbol.symbolLayer(0).angle(), 100)
# add additional layers
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10, 130))
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10, 150))
# should take first layer's angle
self.assertEqual(markerSymbol.angle(), 100)
markerSymbol.setAngle(10)
self.assertEqual(markerSymbol.angle(), 10)
# layer angles should maintain relative angle
self.assertEqual(markerSymbol.symbolLayer(0).angle(), 10)
self.assertEqual(markerSymbol.symbolLayer(1).angle(), 40)
self.assertEqual(markerSymbol.symbolLayer(2).angle(), 60)
def testSizeUnit(self):
# test sizeUnit and setSizeUnit
# create a marker symbol with a single layer
markerSymbol = QgsMarkerSymbolV2()
markerSymbol.deleteSymbolLayer(0)
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10))
self.assertEqual(markerSymbol.sizeUnit(), QgsSymbolV2.MM)
markerSymbol.setSizeUnit(QgsSymbolV2.MapUnit)
self.assertEqual(markerSymbol.sizeUnit(), QgsSymbolV2.MapUnit)
self.assertEqual(
markerSymbol.symbolLayer(0).sizeUnit(), QgsSymbolV2.MapUnit)
# add additional layers
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10))
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 30))
# should now be mixed size units
self.assertEqual(markerSymbol.sizeUnit(), QgsSymbolV2.Mixed)
markerSymbol.setSizeUnit(QgsSymbolV2.Pixel)
self.assertEqual(markerSymbol.sizeUnit(), QgsSymbolV2.Pixel)
# all layers should have size unit set
self.assertEqual(
markerSymbol.symbolLayer(0).sizeUnit(), QgsSymbolV2.Pixel)
self.assertEqual(
markerSymbol.symbolLayer(1).sizeUnit(), QgsSymbolV2.Pixel)
self.assertEqual(
markerSymbol.symbolLayer(2).sizeUnit(), QgsSymbolV2.Pixel)
def getmap(self):
if self.canvas:
settings = self.canvas.mapSettings()
layers = settings.layers()
if GPS.isConnected:
try:
gpslayer = QgsMapLayerRegistry.instance().mapLayersByName(
"__gps_layer")[0]
except IndexError:
gpslayer = QgsVectorLayer("Point", "__gps_layer", "memory")
symbol = QgsMarkerSymbolV2.createSimple({
'name': 'circle',
'color': 'blue',
"size": '5'
})
gpslayer.rendererV2().setSymbol(symbol)
QgsMapLayerRegistry.instance().addMapLayer(gpslayer, False)
layers.append(gpslayer.id())
settings.setLayers(layers)
map_pos = QgsPoint(GPS.gpsinfo("longitude"),
GPS.gpsinfo("latitude"))
# map_pos = QgsPoint(115.72589,-32.29597)
geom = QgsGeometry.fromPoint(map_pos)
feature = QgsFeature()
feature.setGeometry(geom)
gpslayer.startEditing()
gpslayer.addFeature(feature)
# gpslayer.commitChanges()
self.renderjob = QgsMapRendererParallelJob(settings)
self.renderjob.finished.connect(self.rendermap)
self.renderjob.start()
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 getmap(self):
if self.canvas:
settings = self.canvas.mapSettings()
layers = settings.layers()
if GPS.isConnected:
try:
gpslayer = QgsMapLayerRegistry.instance().mapLayersByName("__gps_layer")[0]
except IndexError:
gpslayer = QgsVectorLayer("Point", "__gps_layer", "memory")
symbol = QgsMarkerSymbolV2.createSimple({'name': 'circle', 'color': 'blue', "size": '5'})
gpslayer.rendererV2().setSymbol(symbol)
QgsMapLayerRegistry.instance().addMapLayer(gpslayer, False)
layers.append(gpslayer.id())
settings.setLayers(layers)
map_pos = QgsPoint(GPS.gpsinfo("longitude"), GPS.gpsinfo("latitude"))
# map_pos = QgsPoint(115.72589,-32.29597)
geom = QgsGeometry.fromPoint(map_pos)
feature = QgsFeature()
feature.setGeometry(geom)
gpslayer.startEditing()
gpslayer.addFeature(feature)
# gpslayer.commitChanges()
self.renderjob = QgsMapRendererParallelJob(settings)
self.renderjob.finished.connect(self.rendermap)
self.renderjob.start()
def createMarkerSymbol():
symbol = QgsMarkerSymbolV2.createSimple({
"color": "100,150,50",
"name": "square",
"size": "3.0"
})
return symbol
def createMarkerSymbol():
symbol = QgsMarkerSymbolV2.createSimple({
"color": "100,150,50",
"name": "square",
"size": "3.0"
})
return symbol
def make_svg_link_sym_renderer(self, icon_name, svg_size=7, line_width=0.2):
symbol = QgsLineSymbolV2().createSimple({})
symbol.deleteSymbolLayer(0)
# Line
line_sym_lay = QgsSimpleLineSymbolLayerV2()
line_sym_lay.setWidth(line_width)
symbol.appendSymbolLayer(line_sym_lay)
# Symbol
self.marker_sym = QgsMarkerSymbolV2.createSimple({})
self.marker_sym.deleteSymbolLayer(0)
# marker_sym_lay = QgsSimpleMarkerSymbolLayerV2()
current_dir = os.path.dirname(__file__)
svg_props = dict()
svg_props['name'] = os.path.join(current_dir, icon_name)
svg_props['size'] = str(svg_size)
marker_sym_lay = QgsSvgMarkerSymbolLayerV2().create(svg_props)
self.marker_sym.appendSymbolLayer(marker_sym_lay)
marker_line_sym_lay = QgsMarkerLineSymbolLayerV2()
marker_line_sym_lay.setSubSymbol(self.marker_sym) # Causes crash !!!
marker_line_sym_lay.setPlacement(QgsMarkerLineSymbolLayerV2.CentralPoint)
symbol.appendSymbolLayer(marker_line_sym_lay)
renderer = QgsSingleSymbolRendererV2(symbol)
return renderer
def symbolForCode(code, size):
try:
symbol = QgsMarkerSymbolV2()
for i in range(symbol.symbolLayerCount()):
symbol.takeSymbolLayer(0)
echelonCode = code[3] + code[8:10]
echelonLayer = getSymbolLayer('Echelon', echelonCode, size)
if echelonLayer is not None:
symbol.insertSymbolLayer(0, echelonLayer)
#print 'echelon: %s %s' % (echelonCode, str(echelonLayer is not None))
amplifierCode = code[3] + code[8:10]
amplifierLayer = getSymbolLayer('Amplifier', amplifierCode, size)
if amplifierLayer is not None:
symbol.insertSymbolLayer(0, amplifierLayer)
#print 'amplifier: %s %s' % (amplifierCode, str(amplifierLayer is not None))
hqtffdCode = code[3:6] + code[7]
hqtffdLayer = getSymbolLayer('HQTFFD', hqtffdCode, size)
if hqtffdLayer is not None:
symbol.insertSymbolLayer(0, hqtffdLayer)
#print 'hqtffd: %s %s' % (hqtffdCode, str(hqtffdLayer is not None))
ocaCode = code[2:7] + '2'
ocaLayer = getSymbolLayer('OCA', ocaCode, size)
if ocaLayer is not None:
symbol.insertSymbolLayer(0, ocaLayer)
#print 'oca: %s %s' % (ocaCode, str(ocaLayer is not None))
mainCode = code[4:6] + code[10:16]
mainLayer = getSymbolLayer('Appendices', mainCode, size)
if mainLayer is not None:
symbol.insertSymbolLayer(0, mainLayer)
#print 'main: %s %s' % (mainCode, str(mainLayer is not None))
modifier1Code = code[4:6] + code[16:18] + '1'
modifier1Layer = getSymbolLayer('Appendices', modifier1Code, size)
if modifier1Layer is not None:
symbol.insertSymbolLayer(0, modifier1Layer)
modifier2Code = code[4:6] + code[18:20] + '2'
modifier2Layer = getSymbolLayer('Appendices', modifier2Code, size)
if modifier2Layer is not None:
symbol.insertSymbolLayer(0, modifier2Layer)
frameCode = '%s_%s_%s' % (code[2], code[3:6], code[0])
frameLayer = getSymbolLayer('Frames', frameCode, size)
if frameLayer is not None:
symbol.insertSymbolLayer(0, frameLayer)
#print 'frame: %s %s' % (frameCode, str(frameLayer is not None))
if symbol.symbolLayerCount() == 0:
symbol = None
except Exception as e:
symbol = None
return symbol
def __init__(self):
QgsFeatureRendererV2.__init__(self, "CatalogueCompletenessRenderer")
complete = QgsSymbolV2.defaultSymbol(QGis.Point)
uncomplete = QgsMarkerSymbolV2.createSimple(
{'color': 'blue', 'name': 'triangle'})
uncomplete.setSize(3)
complete.setSize(1.5)
complete.setColor(QtGui.QColor(255, 0, 0, 125))
self.syms = [complete, uncomplete]
def getDefaultSymbol(size):
symbol = QgsMarkerSymbolV2()
symbolLayer = QgsSvgMarkerSymbolLayerV2()
symbolLayer.setPath(
os.path.join(os.path.dirname(__file__), 'svg', 'question.svg'))
symbolLayer.setSizeUnit(3)
symbolLayer.setSize(size)
symbol.insertSymbolLayer(0, symbolLayer)
return symbol
def create_qlayer(self):
layer= QgsVectorLayer("Point"+self.crs, self.prefix+"-nodes", "memory")
# nice clean black dot
symbol = QgsMarkerSymbolV2.createSimple({'outline_style':'no',
'name': 'circle',
'size_unit':'MM',
'size':'1',
'color': 'black'})
layer.rendererV2().setSymbol(symbol)
return layer
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 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 make_graduated_sym_renderer(self, layer, field_name, ranges_colors=None):
feats = layer.getFeatures()
min_val = sys.float_info.max
max_val = -min_val
# Find values range
for feat in feats:
attr = feat.attribute(field_name)
val = float(attr)
if val < min_val:
min_val = val
if val > max_val:
max_val = val
# Define colors
if ranges_colors is None:
ranges_colors = []
colors = [
QColor(0, 255, 0),
QColor(128, 255, 0),
QColor(255, 255, 0),
QColor(255, 128, 0),
QColor(255, 0, 0)]
intv_nr = len(colors)
intv = (max_val - min_val) / intv_nr
for c in range(intv_nr):
vrange = [min_val + intv * c, min_val + intv * (c + 1)]
if c == len(colors) - 1:
vrange[1] = max_val
ranges_colors.append([vrange, colors[c]])
range_list = []
for range_col in ranges_colors:
r_min = range_col[0][0]
r_max = range_col[0][1]
title = str(r_min) + ' - ' + str(r_max)
range_list.append(symbology_from_range(layer, r_min, r_max, range_col[1], title))
renderer = QgsGraduatedSymbolRendererV2(field_name, range_list)
# Line
symbol = QgsMarkerSymbolV2().createSimple({})
symbol.deleteSymbolLayer(0)
mark_sym_lay = QgsSimpleMarkerSymbolLayerV2()
symbol.appendSymbolLayer(mark_sym_lay)
# renderer.setSourceSymbol(symbol)
renderer.updateSymbols(symbol)
return renderer
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 _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 testRefineWithCategories(self):
# Test refining rule with categories (refs #10815)
# First, try with a field based category (id)
cats = []
cats.append(QgsRendererCategoryV2(1, QgsMarkerSymbolV2(), "id 1"))
cats.append(QgsRendererCategoryV2(2, QgsMarkerSymbolV2(), "id 2"))
c = QgsCategorizedSymbolRendererV2("id", cats)
QgsRuleBasedRendererV2.refineRuleCategories(self.r2, c)
assert self.r2.children()[0].filterExpression() == '"id" = 1'
assert self.r2.children()[1].filterExpression() == '"id" = 2'
# Next try with an expression based category
cats = []
cats.append(QgsRendererCategoryV2(1, QgsMarkerSymbolV2(), "result 1"))
cats.append(QgsRendererCategoryV2(2, QgsMarkerSymbolV2(), "result 2"))
c = QgsCategorizedSymbolRendererV2("id + 1", cats)
QgsRuleBasedRendererV2.refineRuleCategories(self.r1, c)
assert self.r1.children()[0].filterExpression() == 'id + 1 = 1'
assert self.r1.children()[1].filterExpression() == 'id + 1 = 2'
# Last try with an expression which is just a quoted field name
cats = []
cats.append(QgsRendererCategoryV2(1, QgsMarkerSymbolV2(), "result 1"))
cats.append(QgsRendererCategoryV2(2, QgsMarkerSymbolV2(), "result 2"))
c = QgsCategorizedSymbolRendererV2('"id"', cats)
QgsRuleBasedRendererV2.refineRuleCategories(self.r3, c)
assert self.r3.children()[0].filterExpression() == '"id" = 1'
assert self.r3.children()[1].filterExpression() == '"id" = 2'
def testRefineWithRanges(self):
#Test refining rule with ranges (refs #10815)
#First, try with a field based category (id)
ranges = []
ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1"))
ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2"))
g = QgsGraduatedSymbolRendererV2("id", ranges)
QgsRuleBasedRendererV2.refineRuleRanges(self.r2, g)
assert self.r2.children()[0].filterExpression() == '"id" >= 0.0000 AND "id" <= 1.0000'
assert self.r2.children()[1].filterExpression() == '"id" > 1.0000 AND "id" <= 2.0000'
#Next try with an expression based range
ranges = []
ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1"))
ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2"))
g = QgsGraduatedSymbolRendererV2("id / 2", ranges)
QgsRuleBasedRendererV2.refineRuleRanges(self.r1, g)
assert self.r1.children()[0].filterExpression() == '(id / 2) >= 0.0000 AND (id / 2) <= 1.0000'
assert self.r1.children()[1].filterExpression() == '(id / 2) > 1.0000 AND (id / 2) <= 2.0000'
#Last try with an expression which is just a quoted field name
ranges = []
ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1"))
ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2"))
g = QgsGraduatedSymbolRendererV2('"id"', ranges)
QgsRuleBasedRendererV2.refineRuleRanges(self.r3, g)
assert self.r3.children()[0].filterExpression() == '"id" >= 0.0000 AND "id" <= 1.0000'
assert self.r3.children()[1].filterExpression() == '"id" > 1.0000 AND "id" <= 2.0000'
def testConvertFromGraduatedRenderer(self):
# Test converting graduated renderer to rule based
# First, try with a field based category (id)
ranges = []
ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1"))
ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2"))
g = QgsGraduatedSymbolRendererV2("id", ranges)
r = QgsRuleBasedRendererV2.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" >= 0.000000 AND "id" <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" > 1.000000 AND "id" <= 2.000000')
# Next try with an expression based range
ranges = []
ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1"))
ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2"))
g = QgsGraduatedSymbolRendererV2("id / 2", ranges)
r = QgsRuleBasedRendererV2.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '(id / 2) >= 0.000000 AND (id / 2) <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '(id / 2) > 1.000000 AND (id / 2) <= 2.000000')
# Last try with an expression which is just a quoted field name
ranges = []
ranges.append(QgsRendererRangeV2(0, 1, QgsMarkerSymbolV2(), "0-1"))
ranges.append(QgsRendererRangeV2(1, 2, QgsMarkerSymbolV2(), "1-2"))
g = QgsGraduatedSymbolRendererV2('"id"', ranges)
r = QgsRuleBasedRendererV2.convertFromRenderer(g)
self.assertEqual(r.rootRule().children()[0].filterExpression(), '"id" >= 0.000000 AND "id" <= 1.000000')
self.assertEqual(r.rootRule().children()[1].filterExpression(), '"id" > 1.000000 AND "id" <= 2.000000')
def make_simple_node_sym_renderer(self, size=2):
symbol = QgsMarkerSymbolV2().createSimple({})
symbol.deleteSymbolLayer(0)
# Point
sim_marker_sym_lay = QgsSimpleMarkerSymbolLayerV2()
sim_marker_sym_lay.setColor(QColor(0, 0, 0))
sim_marker_sym_lay.setFillColor(QColor(0, 0, 0))
sim_marker_sym_lay.setSize(size)
symbol.appendSymbolLayer(sim_marker_sym_lay)
renderer = QgsSingleSymbolRendererV2(symbol)
return renderer
def addLayer(self):
uri = QgsDataSourceURI()
# set host name, port, database name, username and password
#uri.setConnection("localhost", "5432", "jguelat", "jguelat", "")
uri.setConnection("local_jguelat", "", "", "")
# set database schema, table name, geometry column and optionally subset (WHERE clause)
uri.setDataSource("public", self.tableCombo.currentText(), "geom", "species_id = " + self.speciesCombo.currentText())
#vlayer = self.iface.addVectorLayer(uri.uri(), "Species " + self.speciesCombo.currentText(), "postgres")
vlayer = QgsVectorLayer(uri.uri(), "Species " + self.speciesCombo.currentText(), "postgres")
props = vlayer.rendererV2().symbol().symbolLayer(0).properties()
props['size'] = '3'
props['color'] = 'blue'
vlayer.rendererV2().setSymbol(QgsMarkerSymbolV2.createSimple(props))
QgsMapLayerRegistry.instance().addMapLayer(vlayer)
QgsMessageLog.logMessage("Tout est OK", 'BirdChooser', QgsMessageLog.INFO)
def createLayerControle(proj):
layerStopLine = QgsVectorLayer("Point?crs=" + proj,
CONST_NOM_LAYER_PT_CONTROLE, "memory")
# Style
# Symbologie des stations
symbolPoint = QgsMarkerSymbolV2.createSimple({
'name': 'square',
'color_border': '255,216,0'
})
symbolPoint.setColor(QColor.fromRgb(255, 216, 0)) #F 216,7,96
symbolPoint.setSize(2)
layerStopLine.rendererV2().setSymbol(symbolPoint)
return layerStopLine
def test_point_ordered_symbol_bound_offset(self):
# Test ordered placements for point using symbol bounds offset
self.layer = TestQgsPalLabeling.loadFeatureLayer('point_ordered_placement')
# Make a big symbol
symbol = QgsMarkerSymbolV2.createSimple({u'color': u'31,120,180,255',
u'outline_color': u'0,0,0,0',
u'outline_style': u'solid',
u'size': u'10',
u'name': u'rectangle',
u'size_unit': u'MM'})
renderer = QgsSingleSymbolRendererV2(symbol)
self.layer.setRendererV2(renderer)
self._TestMapSettings = self.cloneMapSettings(self._MapSettings)
self.lyr.placement = QgsPalLayerSettings.OrderedPositionsAroundPoint
self.lyr.dist = 2
self.lyr.offsetType = QgsPalLayerSettings.FromSymbolBounds
self.checkTest()
self.removeMapLayer(self.layer)
self.layer = None
def testInitialSizeSymbolMapUnits(self):
"""Test initial size of legend with a symbol size in map units"""
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
QgsMapLayerRegistry.instance().addMapLayers([point_layer])
marker_symbol = QgsMarkerSymbolV2.createSimple({
'color': '#ff0000',
'outline_style': 'no',
'size': '5',
'size_unit': 'MapUnit'
})
point_layer.setRendererV2(QgsSingleSymbolRendererV2(marker_symbol))
s = QgsMapSettings()
s.setLayers([point_layer.id()])
s.setCrsTransformEnabled(False)
composition = QgsComposition(s)
composition.setPaperSize(297, 210)
composer_map = QgsComposerMap(composition, 20, 20, 80, 80)
composer_map.setFrameEnabled(True)
composition.addComposerMap(composer_map)
composer_map.setNewExtent(point_layer.extent())
legend = QgsComposerLegend(composition)
legend.setSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameOutlineWidth(2)
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
composition.addComposerLegend(legend)
legend.setComposerMap(composer_map)
checker = QgsCompositionChecker('composer_legend_mapunits',
composition)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testComposition()
self.assertTrue(result, message)
QgsMapLayerRegistry.instance().removeMapLayers([point_layer.id()])
def testSizeMapUnitScale(self):
# test sizeMapUnitScale and setSizeMapUnitScale
# create a marker symbol with a single layer
markerSymbol = QgsMarkerSymbolV2()
markerSymbol.deleteSymbolLayer(0)
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10))
markerSymbol.symbolLayer(0).setSizeMapUnitScale(
QgsMapUnitScale(10000, 20000))
self.assertEqual(markerSymbol.sizeMapUnitScale(),
QgsMapUnitScale(10000, 20000))
markerSymbol.setSizeMapUnitScale(QgsMapUnitScale(1000, 2000))
self.assertEqual(markerSymbol.sizeMapUnitScale(),
QgsMapUnitScale(1000, 2000))
self.assertEqual(
markerSymbol.symbolLayer(0).sizeMapUnitScale(),
QgsMapUnitScale(1000, 2000))
# add additional layers
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 10))
markerSymbol.appendSymbolLayer(
QgsSimpleMarkerSymbolLayerV2('star', QColor(255, 0, 0),
QColor(0, 255, 0), 30))
# should take first layer's map unit scale
self.assertEqual(markerSymbol.sizeMapUnitScale(),
QgsMapUnitScale(1000, 2000))
markerSymbol.setSizeMapUnitScale(QgsMapUnitScale(3000, 4000))
self.assertEqual(markerSymbol.sizeMapUnitScale(),
QgsMapUnitScale(3000, 4000))
# all layers should have size unit set
self.assertEqual(
markerSymbol.symbolLayer(0).sizeMapUnitScale(),
QgsMapUnitScale(3000, 4000))
self.assertEqual(
markerSymbol.symbolLayer(1).sizeMapUnitScale(),
QgsMapUnitScale(3000, 4000))
self.assertEqual(
markerSymbol.symbolLayer(2).sizeMapUnitScale(),
QgsMapUnitScale(3000, 4000))
def test_point_ordered_symbol_bound_offset(self):
# Test ordered placements for point using symbol bounds offset
self.layer = TestQgsPalLabeling.loadFeatureLayer(
'point_ordered_placement')
# Make a big symbol
symbol = QgsMarkerSymbolV2.createSimple({
u'color': u'31,120,180,255',
u'outline_color': u'0,0,0,0',
u'outline_style': u'solid',
u'size': u'10',
u'name': u'rectangle',
u'size_unit': u'MM'
})
renderer = QgsSingleSymbolRendererV2(symbol)
self.layer.setRendererV2(renderer)
self._TestMapSettings = self.cloneMapSettings(self._MapSettings)
self.lyr.placement = QgsPalLayerSettings.OrderedPositionsAroundPoint
self.lyr.dist = 2
self.lyr.offsetType = QgsPalLayerSettings.FromSymbolBounds
self.checkTest()
self.removeMapLayer(self.layer)
self.layer = None
def testInitialSizeSymbolMapUnits(self):
"""Test initial size of legend with a symbol size in map units"""
point_path = os.path.join(TEST_DATA_DIR, 'points.shp')
point_layer = QgsVectorLayer(point_path, 'points', 'ogr')
QgsMapLayerRegistry.instance().addMapLayers([point_layer])
marker_symbol = QgsMarkerSymbolV2.createSimple({'color': '#ff0000', 'outline_style': 'no', 'size': '5', 'size_unit': 'MapUnit'})
point_layer.setRendererV2(QgsSingleSymbolRendererV2(marker_symbol))
s = QgsMapSettings()
s.setLayers([point_layer.id()])
s.setCrsTransformEnabled(False)
composition = QgsComposition(s)
composition.setPaperSize(297, 210)
composer_map = QgsComposerMap(composition, 20, 20, 80, 80)
composer_map.setFrameEnabled(True)
composition.addComposerMap(composer_map)
composer_map.setNewExtent(point_layer.extent())
legend = QgsComposerLegend(composition)
legend.setSceneRect(QRectF(120, 20, 80, 80))
legend.setFrameEnabled(True)
legend.setFrameOutlineWidth(2)
legend.setBackgroundColor(QColor(200, 200, 200))
legend.setTitle('')
composition.addComposerLegend(legend)
legend.setComposerMap(composer_map)
checker = QgsCompositionChecker(
'composer_legend_mapunits', composition)
checker.setControlPathPrefix("composer_legend")
result, message = checker.testComposition()
self.assertTrue(result, message)
QgsMapLayerRegistry.instance().removeMapLayers([point_layer.id()])
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_point'"
)
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_point', '" + virtual_layer_name +
"', current_user)")
self.controller.execute_sql(sql)
uri = "Point?crs=epsg:" + str(self.srid)
virtual_layer = QgsVectorLayer(uri, virtual_layer_name, "memory")
props = {'color': 'red', 'color_border': 'red', 'size': '1.5'}
s = QgsMarkerSymbolV2.createSimple(props)
virtual_layer.setRendererV2(QgsSingleSymbolRendererV2(s))
virtual_layer.updateExtents()
QgsProject.instance().setSnapSettingsForLayer(virtual_layer.id(), True,
0, 0, 1.0, False)
QgsMapLayerRegistry.instance().addMapLayer(virtual_layer)
self.iface.mapCanvas().refresh()
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 legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer(
"Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)",
"points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPoint(QgsPoint(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPoint(QgsPoint(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRendererV2("attr", [
QgsRendererCategoryV2(
1, QgsMarkerSymbolV2.createSimple({"color": "255,0,0"}),
"red"),
QgsRendererCategoryV2(
2, QgsMarkerSymbolV2.createSimple({"color": "0,0,255"}),
"blue")
])
ptLayer.setRendererV2(r)
QgsMapLayerRegistry.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.mapSettings.layers()
layers = [ptLayer.id()] + layers
self.mapSettings.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mapSettings.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsMapLayerRegistry.instance().removeMapLayer(ptLayer.id())
def apply(self, layer):
symbol = QgsMarkerSymbolV2.createSimple({'name': self.shape,
'color': self.color})
self.renderer = QgsSingleSymbolRendererV2(symbol)
super(SimpleSymbology, self).apply(layer)
def symbolForCode(code, size):
'''
This method returns the marker corresponding to a given MIL-STD-2525 code
'''
try:
'''Here we create the marker symbol instance'''
symbol = QgsMarkerSymbolV2()
'''
A symbol in QGIS, for all types of geometries (in this case it's a
point symbol), is composed of a set of symbol layers.
The default symbol contains one default layer. We do not want it, so
we remove all the previous symbol layers.
'''
for i in range(symbol.symbolLayerCount()):
symbol.takeSymbolLayer(0)
'''
Now we just take the different parts of the MIL-STD-2525 code and
convert it into a symbol layer. Is symbol layer is created from a
corresponding SVG file, and by adding all of the to the marker symbol,
we get the compound marker to use.
'''
echelonCode = code[3] + code[8:10]
echelonLayer = getSymbolLayer('Echelon', echelonCode, size)
if echelonLayer is not None:
symbol.insertSymbolLayer(0, echelonLayer)
amplifierCode = code[3] + code[8:10]
amplifierLayer = getSymbolLayer('Amplifier', amplifierCode, size)
if amplifierLayer is not None:
symbol.insertSymbolLayer(0, amplifierLayer)
hqtffdCode = code[3:6] + code[7]
hqtffdLayer = getSymbolLayer('HQTFFD', hqtffdCode, size)
if hqtffdLayer is not None:
symbol.insertSymbolLayer(0, hqtffdLayer)
ocaCode = code[2:7] + '2'
ocaLayer = getSymbolLayer('OCA', ocaCode, size)
if ocaLayer is not None:
symbol.insertSymbolLayer(0, ocaLayer)
mainCode = code[4:6] + code[10:16]
mainLayer = getSymbolLayer('Appendices', mainCode, size)
if mainLayer is not None:
symbol.insertSymbolLayer(0, mainLayer)
modifier1Code = code[4:6] + code[16:18] + '1'
modifier1Layer = getSymbolLayer('Appendices', modifier1Code, size)
if modifier1Layer is not None:
symbol.insertSymbolLayer(0, modifier1Layer)
modifier2Code = code[4:6] + code[18:20] + '2'
modifier2Layer = getSymbolLayer('Appendices', modifier2Code, size)
if modifier2Layer is not None:
symbol.insertSymbolLayer(0, modifier2Layer)
frameCode = '%s_%s_%s' % (code[2], code[3:6], code[0])
frameLayer = getSymbolLayer('Frames', frameCode, size)
if frameLayer is not None:
symbol.insertSymbolLayer(0, frameLayer)
if symbol.symbolLayerCount() == 0:
symbol = None
except Exception as e:
symbol = None
return symbol
def wplaceAnnotationsButton_click(self):
annotations = self.getSelectedAnnotations()
for anno in annotations:
annoData = anno.data(1)
annotation = QgsTextAnnotationItem(self.iface.mapCanvas())
#Make data accessible from annotation
annotation.setData(1, annoData)
doc = annotation.document()
#"layer": self.getLayer(),
#"srid": crs.postgisSrid(),
#"label": label[0:256] ,
#"content": annotation.document().toHtml().replace("'","''"),
doc.setHtml(annoData.get('content', None))
annotation.setDocument(doc)
#"frame_color":annotation.frameColor().name(),
color = QColor()
color.setNamedColor(annoData.get('frame_color'))
annotation.setFrameColor(color)
#"bg_color": annotation.frameBackgroundColor().name(),
color = QColor()
color.setNamedColor(annoData.get('bg_color'))
annotation.setFrameBackgroundColor(color)
#"frame_width": frame_size.width(),
#"frame_height": frame_size.height(),
size = QSizeF()
size.setWidth(annoData.get('frame_width'))
size.setHeight(annoData.get('frame_height'))
annotation.setFrameSize(size)
#"frame_border_width": annotation.frameBorderWidth(),
width = float(annoData.get('frame_border_width'))
annotation.setFrameBorderWidth(width)
#"map_position_x": map_position_x,
#"map_position_y": map_position_y,
map_position_x = float(annoData.get('map_position_x'))
map_position_y = float(annoData.get('map_position_y'))
annotation.setMapPosition(QgsPoint(map_position_x, map_position_y))
#"offset_x": ref_offset.x(),
#"offset_y": ref_offset.y(),
offset_x = float(annoData.get('offset_x'))
offset_y = float(annoData.get('offset_y'))
annotation.setOffsetFromReferencePoint(QPointF(offset_x, offset_y))
#"marker_symbol": json.dumps(self.dumpMarkerSymbol(marker))
marker_symbol = annoData.get('marker_symbol')
new_marker_symbol = QgsMarkerSymbolV2()
#'color':marker.color().name(),
color = QColor()
color.setNamedColor(marker_symbol.get('color'))
new_marker_symbol.setColor(color)
#'alpha':marker.alpha(),
alpha = float(marker_symbol.get('alpha'))
new_marker_symbol.setAlpha(alpha)
#'output_unit': marker.outputUnit(),
output_unit = marker_symbol.get('output_unit')
new_marker_symbol.setOutputUnit(output_unit)
#'angle': marker.angle(),
angle = float(marker_symbol.get('angle'))
new_marker_symbol.setAngle(angle)
#'size': marker.size(),
size = float(marker_symbol.get('size'))
new_marker_symbol.setSize(size)
#'size_unit': marker.sizeUnit(),
size_unit = marker_symbol.get('size_unit')
new_marker_symbol.setSizeUnit(size_unit)
#'symbol_layers': [self.dumpSymbolLayer(layer) for layer in marker.symbolLayers()]
for properties in marker_symbol.get('symbol_layers'):
print properties
#properties = json.loads(properties)
new_symbol_layer = QgsSimpleMarkerSymbolLayerV2()
new_symbol_layer.restoreDataDefinedProperties(properties)
new_marker_symbol.appendSymbolLayer(new_symbol_layer)
annotation.setMarkerSymbol(new_marker_symbol)
def showNodes(self):
"""
Parse the geometry of a selected layer and show its vertices (nodes)
"""
mr = self.layerRegistry
# Get the selected layer for which to show nodes
selectedIndex = self.dlg.comboLayers.currentIndex()
selectedLayer = self.dlg.comboLayers.itemData(selectedIndex)
registeredLayers = self.layerRegistry.mapLayersByName('Noeuds')
featuresCount = int(selectedLayer.featureCount())
# Remove the node layer if already existing
if mr.mapLayersByName('Noeuds'):
mr.removeMapLayer(mr.mapLayersByName('Noeuds')[0].id())
# Create memory layer to display nodes
self.nodeLayer = QgsVectorLayer("Point?crs=EPSG:2056", "Noeuds",
"memory")
self.nodeLayerProvider = self.nodeLayer.dataProvider()
# Create rendering style
nodeSymbol = QgsMarkerSymbolV2.defaultSymbol(
self.nodeLayer.geometryType())
nodeSymbol.setColor(QColor('#CC3300'))
nodeSymbol.setSize(2.0)
nodeRenderer = QgsSingleSymbolRendererV2(nodeSymbol)
self.nodeLayer.setRendererV2(nodeRenderer)
# Select features visible in current map canvas extent
if self.dlg.chkSelectByCanvasExtent.checkState():
extent = self.canvas.extent()
rect = QgsRectangle(extent.xMinimum(), extent.yMinimum(),
extent.xMaximum(), extent.yMaximum())
request = QgsFeatureRequest()
request.setFilterRect(rect)
featureIterator = selectedLayer.getFeatures(request)
# Select all features
else:
featureIterator = selectedLayer.getFeatures()
# Create progress bar
progressMessageBar = self.messageBar.createMessage(
unicode("Création des noeuds...", "utf-8"))
progress = QProgressBar()
progress.setMinimum(0)
progress.setMaximum(featuresCount)
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.messageBar.pushWidget(progressMessageBar,
self.iface.messageBar().INFO)
# Iterate over feature
k = 0
for feature in featureIterator:
k += 1
progress.setValue(k)
geom = feature.geometry()
feat = QgsFeature()
# Adapt procedure for each geometry type
if (geom):
type = geom.wkbType()
# LineString
if type == QGis.WKBLineString:
for point in geom.asPolyline():
feat.setGeometry(QgsGeometry.fromPoint(point))
self.nodeLayerProvider.addFeatures([feat])
# MultiLineString
elif type == QGis.WKBMultiLineString:
for line in geom.asMultiPolyline():
for vertex in line:
feat.setGeometry(
QgsGeometry.fromPoint(
QgsPoint(vertex[0], vertex[1])))
self.nodeLayerProvider.addFeatures([feat])
# Polygon
elif type == QGis.WKBPolygon:
polygons = geom.asPolygon()
for polygon in polygons:
for vertex in polygon:
feat.setGeometry(
QgsGeometry.fromPoint(
QgsPoint(vertex[0], vertex[1])))
self.nodeLayerProvider.addFeatures([feat])
# MultiPolygon
elif type == QGis.WKBMultiPolygon:
multiPoly = geom.asMultiPolygon()
for polygons in multiPoly:
for polygon in polygons:
for vertex in polygon:
feat.setGeometry(
QgsGeometry.fromPoint(
QgsPoint(vertex[0], vertex[1])))
self.nodeLayerProvider.addFeatures([feat])
else:
self.messageBar.pushMessage(
"Cartotools : ",
unicode("Type de géométrie non" + "supporté: " + str(type),
"utf-8"),
level=QgsMessageBar.CRITICAL)
self.messageBar.clearWidgets()
self.layerRegistry.addMapLayer(self.nodeLayer)
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 extract_layers(self, tree):
"""Return a list of RFU layers."""
# Create vector layers..
l_vertex = QgsVectorLayer(r"Point?crs=epsg:4326&index=yes",
u"Sommet RFU", r"memory")
l_edge = QgsVectorLayer(r"LineString?crs=epsg:4326&index=yes",
u"Limite RFU", r"memory")
p_vertex = l_vertex.dataProvider()
p_edge = l_edge.dataProvider()
# Define default style renderer..
renderer_vertex = QgsRuleBasedRendererV2(QgsMarkerSymbolV2())
vertex_root_rule = renderer_vertex.rootRule()
vertex_rules = (
((u"Borne, borne à puce, pierre, piquet, clou ou broche"),
(u"$id >= 0 AND \"som_nature\" IN ('Borne',"
u"'Borne à puce', 'Pierre', 'Piquet', 'Clou ou broche')"),
r"#EC0000", 2.2),
((u"Axe cours d'eau, axe fossé, haut de talus, pied de talus"),
(u"$id >= 0 AND \"som_nature\" IN ('Axe cours d\'\'eau',"
u"'Axe fossé', 'Haut de talus', 'Pied de talus')"), r"#EE8012",
2.2), ((u"Angle de bâtiment, axe de mur, angle de mur, "
u"angle de clôture, pylône et toute autre valeur"),
(u"$id >= 0 AND \"som_nature\" NOT IN ('Borne',"
u"'Borne à puce', 'Pierre', 'Piquet', 'Clou ou broche',"
u"'Axe cours d\'\'eau', 'Axe fossé', 'Haut de talus',"
u"'Pied de talus')"), r"#9784EC",
2.2), (u"Temporaire", r"$id < 0", "cyan", 2.4))
for label, expression, color, size in vertex_rules:
rule = vertex_root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(color))
rule.symbol().setSize(size)
vertex_root_rule.appendChild(rule)
vertex_root_rule.removeChildAt(0)
l_vertex.setRendererV2(renderer_vertex)
renderer_edge = QgsRuleBasedRendererV2(QgsLineSymbolV2())
edge_root_rule = renderer_edge.rootRule()
edge_rules = ((r"Limite", r"$id >= 0", "#0A0AFF", 0.5),
(r"Temporaire", r"$id < 0", "cyan", 1))
for label, expression, color, width in edge_rules:
rule = edge_root_rule.children()[0].clone()
rule.setLabel(label)
rule.setFilterExpression(expression)
rule.symbol().setColor(QColor(color))
rule.symbol().setWidth(width)
edge_root_rule.appendChild(rule)
edge_root_rule.removeChildAt(0)
l_edge.setRendererV2(renderer_edge)
# Add fields..
p_vertex.addAttributes([
QgsField(r"@id_noeud", QVariant.Int),
# QgsField(r"@changeset", QVariant.Int),
# QgsField(r"@timestamp", QVariant.Date),
QgsField(r"@version", QVariant.Int),
QgsField(r"som_ge_createur", QVariant.String),
QgsField(r"som_nature", QVariant.String),
QgsField(r"som_precision_rattachement", QVariant.Int),
QgsField(r"som_coord_est", QVariant.Double),
QgsField(r"som_coord_nord", QVariant.Double),
QgsField(r"som_representation_plane", QVariant.String),
# QgsField(r"date_creation", QVariant.Date)
])
p_edge.addAttributes([
QgsField(r"@id_arc", QVariant.Int),
# QgsField(r"@id_noeud_debut", QVariant.Int),
# QgsField(r"@id_noeud_fin", QVariant.Int),
# QgsField(r"@changeset", QVariant.Int),
# QgsField(r"@timestamp", QVariant.Date),
QgsField(r"@version", QVariant.Int),
QgsField(r"lim_ge_createur", QVariant.String),
# QgsField(r"lim_date_creation", QVariant.Date)
])
# Add features from xml tree..
# ..to vertex layer..
fts_vertex = []
for e in tree.findall(r"sommet"):
ft_vertex = QgsFeature()
ft_vertex.setGeometry(QgsGeometry.fromWkt(e.attrib[r"geometrie"]))
_id_noeud = int(e.attrib[r"id_noeud"])
# _changeset = int(e.attrib[r"changeset"])
# _timestamp = QDateTime(datetime.strptime(
# e.attrib[r"timestamp"], r"%Y-%m-%d %H:%M:%S.%f"))
_version = int(e.attrib[r"version"])
som_ge_createur = unicode(e.find(r"./som_ge_createur").text)
som_nature = unicode(e.find(r"./som_nature").text)
som_prec_rattcht = int(
e.find(r"./som_precision_rattachement").text)
som_coord_est = float(e.find(r"./som_coord_est").text)
som_coord_nord = float(e.find(r"./som_coord_nord").text)
som_repres_plane = unicode(
e.find(r"./som_representation_plane").text)
# som_date_creation = QDate(datetime.strptime(
# e.find(r"./som_date_creation").text, r"%Y-%m-%d").date())
ft_vertex.setAttributes([
_id_noeud,
# _changeset,
# _timestamp,
_version,
som_ge_createur,
som_nature,
som_prec_rattcht,
som_coord_est,
som_coord_nord,
som_repres_plane,
# som_date_creation
])
fts_vertex.append(ft_vertex)
# ..to edge layer..
fts_edge = []
for e in tree.findall(r"limite"):
ft_edge = QgsFeature()
ft_edge.setGeometry(QgsGeometry.fromWkt(e.attrib[r"geometrie"]))
_id_arc = int(e.attrib[r"id_arc"])
# _id_noeud_debut = int(e.attrib[r"id_noeud_debut"])
# _id_noeud_fin = int(e.attrib[r"id_noeud_fin"])
# _changeset = int(e.attrib[r"changeset"])
# _timestamp = QDateTime(datetime.strptime(
# e.attrib[r"timestamp"], r"%Y-%m-%d %H:%M:%S.%f"))
_version = int(e.attrib[r"version"])
lim_ge_createur = unicode(e.find(r"./lim_ge_createur").text)
# lim_date_creation = QDate(datetime.strptime(
# e.find(r"./lim_date_creation").text, r"%Y-%m-%d").date())
ft_edge.setAttributes([
_id_arc,
# _id_noeud_debut,
# _id_noeud_fin,
# _changeset,
# _timestamp,
_version,
lim_ge_createur,
# lim_date_creation
])
fts_edge.append(ft_edge)
# Add features to layers..
p_vertex.addFeatures(fts_vertex)
p_edge.addFeatures(fts_edge)
# Update fields..
l_vertex.updateFields()
l_edge.updateFields()
# Update layer's extent..
l_vertex.updateExtents()
l_edge.updateExtents()
# Check if valid..
if not l_vertex.isValid() or not l_edge.isValid():
raise Exception(
u"Une erreur est survenue lors du chargement de la couche.")
# Set labelling...
palyr = QgsPalLayerSettings()
palyr.enabled = True
# palyr.readFromLayer(l_vertex)
palyr.fieldName = r"$id" # Expression $id
palyr.placement = 1 # ::OverPoint
palyr.quadOffset = 2 # ::QuadrantAboveRight
palyr.setDataDefinedProperty(80, True, True, r"1",
"") # ::OffsetUnits -> ::MM
palyr.xOffset = 2.0
palyr.yOffset = -1.0
palyr.writeToLayer(l_vertex)
# Then return layers..
return [l_vertex, l_edge]
# coding: utf-8
from qgis.core import QgsMarkerSymbolV2
from qgis.gui import QgsSizeScaleWidget
from qgis.utils import iface
layer = iface.activeLayer()
canvas = iface.mapCanvas()
marker_symbol_v2 = QgsMarkerSymbolV2.createSimple({"color": "blue", "name": "triangle"})
size_scale_widget = QgsSizeScaleWidget(layer, marker_symbol_v2)
size_scale_widget.setMapCanvas(canvas)
size_scale_widget.show()
