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 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 style_categorized(self, layer, style_by):
# get unique values
fni = layer.fieldNameIndex(style_by)
unique_values = layer.dataProvider().uniqueValues(fni)
# define categories
categories = []
for unique_value in unique_values:
# initialize the default symbol for this geometry type
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
# configure a symbol layer
layer_style = {}
layer_style['color'] = '%d, %d, %d' % (randrange(
0, 256), randrange(0, 256), randrange(0, 256))
layer_style['outline'] = '#000000'
symbol_layer = QgsSimpleFillSymbolLayerV2.create(layer_style)
# replace default symbol layer with the configured one
if symbol_layer is not None:
symbol.changeSymbolLayer(0, symbol_layer)
# create renderer object
category = QgsRendererCategoryV2(unique_value, symbol,
str(unique_value))
# entry for the list of category items
categories.append(category)
# create renderer object
renderer = QgsCategorizedSymbolRendererV2(style_by, categories)
# assign the created renderer to the layer
if renderer is not None:
layer.setRendererV2(renderer)
layer.triggerRepaint()
self.iface.legendInterface().refreshLayerSymbology(layer)
self.iface.mapCanvas().refresh()
def classified_style_from_colormap(layer, cm):
def gen_cl(color, val, label):
sym = QgsFillSymbolV2.createSimple({})
sym.setColor(QColor(*color))
cat = QgsRendererCategoryV2(val, sym, label)
return cat
def closest_val(lst, val):
return min(lst, key=lambda x: abs(x - val))
assert (cm and layer)
idx = layer.pendingFields().indexFromName("CVAL")
vals = layer.uniqueValues(idx)
last_index = cm.item_count() - 1
assert (last_index > 0) # at least 2 values
cl = []
for i in range(1, cm.item_count()): # skip first one
item = cm.item(i)
prev_item = cm.item(i - 1)
label = prev_item.label + " - " + item.label
val = closest_val(vals, prev_item.value)
cl.append(gen_cl(item.color, val, label))
renderer = QgsCategorizedSymbolRendererV2("CVAL", cl)
layer.setRendererV2(renderer)
def setCategorizedStyle(vl, categories, field, **kwargs):
""" set a categorized style """
# make a symbol for each category
categoryV2List = []
for label, value, attrs in categories:
symbolV2 = QgsSymbolV2.defaultSymbol(vl.geometryType())
if 'color' in attrs:
symbolV2.setColor(attrs['color'])
if 'size' in attrs:
symbolV2.setSize(attrs['size'])
# in QGis > 1.8 QgsMarkerSymbolV2 has 2 scale methods: ScaleArea and ScaleDiameter
if 'sizeScaleMethod' in kwargs and hasattr(symbolV2,
'setScaleMethod'):
symbolV2.setScaleMethod(kwargs['sizeScaleMethod'])
categoryV2 = QgsRendererCategoryV2(value, symbolV2, label)
categoryV2List.append(categoryV2)
# create the renderer
renderer = QgsCategorizedSymbolRendererV2(field, categoryV2List)
# set size scale field
if 'sizeScaleField' in kwargs:
renderer.setSizeScaleField(kwargs['sizeScaleField'])
# set the renderer for the layer
vl.setRendererV2(renderer)
Utils.iface.legendInterface().refreshLayerSymbology(vl)
def color_layers(self):
"""
Attempts to assign and color each layer after changing it's renderer to the Categorized Symbol Renderer
TODO: Implement a store value to look up default names to get standardized Color Grading, If possible
:return: None
"""
p = QgsMapLayerRegistry.instance().mapLayers()
regex = re.compile("\n?(\D*)\d*\n?")
for key, val in p.iteritems():
try:
catagories = []
a = regex.match(key)
fcn = QgsVectorGradientColorRampV2()
# renderer.setWeightExpression(a.group(1))
# fcn.setColor1(QColor(255, 255, 255, 0))
# fcn.setColor2(QColor(random.randint(0, 100), random.randint(
# 50, 255), random.randint(50, 255), 255))
fcn.setColor1(QColor(255, 0, 0, 255))
fcn.setColor2(QColor(0, 255, 0, 255))
# self.com.log(str(fcn.stops()), level=0)
fcn.setStops([QgsGradientStop(0.5, QColor(255, 207, 74, 255))])
# renderer.setColorRamp(fcn)
# renderer.setRenderQuality(1) # Max out the quality
# for feature in val.getFeature():
# print feature.attribute(a.group(1))
fni = val.fieldNameIndex(a.group(1))
# This function is accomplishing the Classify Function, due to
# the lack of API implementation
sortedlist = []
for unique in val.dataProvider().uniqueValues(fni):
sortedlist.append(unique)
sortedlist.sort()
for i in sortedlist:
symbol = QgsSymbolV2.defaultSymbol(val.geometryType())
category = QgsRendererCategoryV2(i, symbol, str(i))
catagories.append(category)
renderer = QgsCategorizedSymbolRendererV2(
a.group(1), catagories)
self.com.log(str(renderer.categories()), level=0)
renderer.updateColorRamp(fcn)
# renderer.updateCategoryValue(a.group(1))
val.setRendererV2(renderer)
except AttributeError:
# This will allow the Color step to continue if it hits an
# Object it can't use (Raster layer)
continue
def _apply_symbology_fixed_divisions(self, layer, field, tbl_name, schema,
min_v, max_v, steps):
"""Finds the amount of levels that is necessary to describe the layer,
a maximum of 20 different levels is set"""
if min_v is not None and max_v is not None:
distinct_values = list(np.arange(min_v, max_v, steps))
else:
distinct = self.DB.get_distinct(tbl_name, field, schema)
distinct_values = []
distinct_count = []
for value, count in distinct:
distinct_values.append(value)
distinct_count.append(count)
if len(distinct_values) > 20:
distinct_values.sort()
temp_list = []
for val in range(0, len(distinct_values),
int(round(len(distinct_values) / 20))):
temp_list.append(distinct_values[val])
distinct_values = temp_list
colors = self._create_colors(len(distinct_values))
try:
range_list = []
for i in range(len(distinct_values) - 1):
red, green, blue = colors[i]
range_list.append(
self._make_symbology(
layer, distinct_values[i], distinct_values[i + 1],
str(distinct_values[i]) + ' - ' +
str(distinct_values[i + 1]),
QColor(int(red * 255), int(green * 255),
int(blue * 255), 128)))
renderer = QgsGraduatedSymbolRendererV2(field, range_list)
renderer.setMode(QgsGraduatedSymbolRendererV2.Custom)
except TypeError:
categories = []
for i in range(len(distinct_values)):
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
red, green, blue = colors[i]
symbol.setColor(
QColor(int(red * 255), int(green * 255), int(blue * 255),
128))
symbol.symbolLayer(0).setOutlineColor(
QColor(int(red * 255), int(green * 255), int(blue * 255),
128))
category = QgsRendererCategoryV2(str(distinct_values[i]),
symbol,
str(distinct_values[i]))
categories.append(category)
renderer = QgsCategorizedSymbolRendererV2(field, categories)
#renderer.setMode(QgsCategorizedSymbolRendererV2.Custom)
layer.setRendererV2(renderer)
def __getCategorizedSymbolRenderer(self):
"""docstring for __getCategorizedSymbolRenderer"""
field = self.has_classitem
categories = []
for exp, msclass in zip(self.expressions[::-1],
self.mslayer["classes"][::-1]):
Symbol = SymbolImport(msclass, self.qgslayer, self.geom_type, self.sizeunits, \
self.mssymbols, self.symbolsetpath, self.fontset)
symbol = Symbol.getSymbol()
value = exp[1]
label = msclass.get("name", value)
status = False if msclass.get("status",
'on').lower() == 'off' else True
categories.append(
QgsRendererCategoryV2(value, symbol, label, status))
return QgsCategorizedSymbolRendererV2(field, categories)
def vector_apply_unique_value_renderer(vector_layer, column):
"""Apply colours to each unique value for a vector layer column.
source: https://gis.stackexchange.com/a/175114
Args:
vector_layer (QgsVectorLayer): A vector layer to apply unique symbology to.
column (str): The column containing the unique values
"""
categories = []
uniq_vals = vector_layer.dataProvider().uniqueValues(
vector_layer.fieldNameIndex(column))
randcolors = random_colours(len(uniq_vals))
for i, ea_value in enumerate(uniq_vals):
# initialize the default symbol for this geometry type
symbol = QgsSymbolV2.defaultSymbol(vector_layer.geometryType())
# configure a symbol layer
layer_style = {
'color': '{}, {}, {}'.format(*randcolors[i]),
'outline': '#000000'
}
symbol_layer = QgsSimpleFillSymbolLayerV2.create(layer_style)
# replace default symbol layer with the configured one
if symbol_layer is not None:
symbol.changeSymbolLayer(0, symbol_layer)
# create renderer object
category = QgsRendererCategoryV2(ea_value, symbol, str(ea_value))
# entry for the list of category items
categories.append(category)
# create renderer object
renderer = QgsCategorizedSymbolRendererV2(column, categories)
# assign the created renderer to the layer
if renderer is not None:
vector_layer.setRendererV2(renderer)
# refresh
vector_layer.triggerRepaint()
def hazard_class_style(layer, classification, display_null=False):
"""Set colors to the layer according to the hazard.
:param layer: The layer to style.
:type layer: QgsVectorLayer
:param display_null: If we should display the null hazard zone. Default to
False.
:type display_null: bool
:param classification: The hazard classification to use.
:type classification: dict safe.definitions.hazard_classifications
"""
categories = []
# Conditional styling
attribute_table_styles = []
for hazard_class, (color, label) in classification.iteritems():
if hazard_class == not_exposed_class['key'] and not display_null:
# We don't want to display the null value (not exposed).
# We skip it.
continue
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol.setColor(color)
if is_line_layer(layer):
symbol.setWidth(line_width_exposure)
category = QgsRendererCategoryV2(hazard_class, symbol, label)
categories.append(category)
style = QgsConditionalStyle()
style.setName(hazard_class)
style.setRule("hazard_class='%s'" % hazard_class)
style.setBackgroundColor(transparent)
symbol = QgsSymbolV2.defaultSymbol(QGis.Point)
symbol.setColor(color)
symbol.setSize(3)
style.setSymbol(symbol)
attribute_table_styles.append(style)
layer.conditionalStyles().setFieldStyles(
'hazard_class', attribute_table_styles)
renderer = QgsCategorizedSymbolRendererV2(
hazard_class_field['field_name'], categories)
layer.setRendererV2(renderer)
def classified_style_from_interval(layer, cm):
def ramp_value(first_cm, last_cm, prev_item):
if prev_item < first_cm.value:
ramp_val = 0
elif prev_item > last_cm.value:
ramp_val = 1
else:
ramp_val = (prev_item - first_cm.value) / (last_cm.value -
first_cm.value)
return ramp_val
def gen_cl(ramp, val, ramp_val, label):
sym = QgsFillSymbolV2.createSimple({})
sym.setColor(ramp.color(ramp_val))
cat = QgsRendererCategoryV2(val, sym, label)
return cat
assert (layer)
last_index = cm.item_count() - 1
assert (last_index > 0) # at least 2 values
first_cm = cm.item(0)
last_cm = cm.item(last_index)
idx = layer.pendingFields().indexFromName("CVAL")
vals = layer.uniqueValues(idx)
ramp = QgsVectorGradientColorRampV2(QColor(*first_cm.color),
QColor(*last_cm.color))
cl = []
for i in range(1, len(vals)): # skip first one
item = vals[i]
prev_item = vals[i - 1]
label = str(item) + " - " + str(prev_item)
ramp_val = ramp_value(first_cm, last_cm, prev_item)
cl.append(gen_cl(ramp, prev_item, ramp_val, label))
last_item = vals[-1]
ramp_val = ramp_value(first_cm, last_cm, last_item)
cl.append(gen_cl(ramp, last_item, ramp_val, str(last_item)))
renderer = QgsCategorizedSymbolRendererV2("CVAL", cl)
layer.setRendererV2(renderer)
def showLegend(self, layer, field, setting_list):
if not self.cellstyle:
self.styleManager = QgsMapLayerStyleManager(layer)
self.styleManager.addStyleFromLayer(u'默认')
self.cellstyle = True
ranges = []
flabel = QLabel(field)
fl = QHBoxLayout()
fl.addWidget(flabel)
self.vbox.addLayout(fl)
for bl in setting_list:
widget = QWidget()
widget.setStyleSheet('QWidget {background-color:%s}' %
bl[0].name())
widget.resize(20, 20)
label = QLabel(bl[1])
null_label = QLabel(' ')
c = QGridLayout()
c.setSpacing(3)
c.addWidget(widget, 1, 0)
c.addWidget(null_label, 1, 1)
c.addWidget(label, 1, 2)
self.vbox.addLayout(c)
sym = QgsSymbolV2.defaultSymbol(layer.geometryType())
sym.setColor(bl[0])
rng = QgsRendererCategoryV2(bl[1], sym, label.text())
ranges.append(rng)
self.vbox.addStretch(1)
self.setLayout(self.vbox)
renderer = QgsCategorizedSymbolRendererV2(field, ranges)
layer.setRendererV2(renderer)
self.iface.actionDraw().trigger()
def setLpisStyle(self, layer):
# define a lookup: value -> (color, label)
land_types = {
'L': ('#005900', self.tr('Forest')),
'R': ('#6d4237', self.tr('Arable land')),
'S': ('#fb5858', self.tr('Orchard')),
'V': ('#d875e4', self.tr('Vineyard')),
'C': ('#f2d773', self.tr('Hop-garden')),
'T': ('#329932', self.tr('Permanent grassland')),
'': ('#808080', self.tr('Unknown')),
}
# create a category for each item in land_types
categories = []
for land_type, (color, label) in land_types.items():
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol.setColor(QColor(color))
category = QgsRendererCategoryV2(land_type, symbol, label)
categories.append(category)
# create the renderer and assign it to a layer
expression = 'KULTURAKOD' # field name
renderer = QgsCategorizedSymbolRendererV2(expression, categories)
layer.setRendererV2(renderer)
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 set_vector_categorized_style(vector_layer, style):
"""Set categorized QGIS vector style based on InaSAFE style dictionary.
For **opaque** a value of **0** can be used. For **fully transparent**, a
value of **100** can be used. The calling function should take care to
scale the transparency level to between 0 and 100.
:param vector_layer: A QGIS vector layer that will be styled.
:type vector_layer: QgsVectorLayer
:param style: Dictionary of the form as in the example below.
:type style: dict
:returns: None - Sets and saves style for vector_layer
Example::
{'target_field': 'DMGLEVEL',
'style_classes':
[{'transparency': 1, 'value': 1, 'colour': '#fecc5c',
'label': 'Low damage', 'size' : 1},
{'transparency': 55, 'value': 2, 'colour': '#fd8d3c',
'label': 'Medium damage', 'size' : 1},
{'transparency': 80, 'value': 3, 'colour': '#f31a1c',
'label': 'High damage', 'size' : 1}]}
.. note:: The transparency and size keys are optional. Size applies
to points only.
.. note:: We should change 'value' in style classes to something more
meaningful e.g. discriminant value
.. note:: you can optionally pass border_color also, if not color will be
used
.. note:: you can optionally pass border_width also, if not QGIS defaults
will be used
.. note:: you can optionally pass data_defined also, this has to be a
dictionary of property: expressions like
{'color': 'color_hsv(%s, "pop"/%s*100, %s)' % (hue, max, val)}
"""
target_field = style['target_field']
style_classes = style['style_classes']
geometry_type = vector_layer.geometryType()
category_list = []
for style_class in style_classes:
# Transparency 100: transparent
# Transparency 0: opaque
size = 2 # mm
if 'size' in style_class:
size = style_class['size']
transparency_percent = 0
if 'transparency' in style_class:
transparency_percent = style_class['transparency']
if 'value' not in style_class:
raise StyleError('Style info should provide a "value" entry')
value = style_class['value']
colour = style_class['colour']
label = style_class['label']
colour = QtGui.QColor(colour)
try:
border_color = QtGui.QColor(style_class['border_color'])
except KeyError:
border_color = colour
# noinspection PyArgumentList
symbol = QgsSymbolV2.defaultSymbol(geometry_type)
# We need to create a custom symbol layer as
# the border colour of a symbol can not be set otherwise
# noinspection PyArgumentList
if geometry_type == QGis.Point:
symbol_layer = QgsSimpleMarkerSymbolLayerV2()
symbol_layer.setBorderColor(border_color)
symbol_layer.setSize(size)
symbol.changeSymbolLayer(0, symbol_layer)
elif geometry_type == QGis.Polygon:
symbol_layer = QgsSimpleFillSymbolLayerV2()
symbol_layer.setBorderColor(border_color)
symbol.changeSymbolLayer(0, symbol_layer)
else:
# for lines we do nothing special as the property setting
# below should give us what we require.
symbol_layer = None
try:
symbol_layer.setBorderWidth(style_class['border_width'])
except (NameError, KeyError, AttributeError):
# use QGIS default border size
# NameError is when symbol_layer is not defined (lines for example)
# KeyError is when border_width is not defined
# AttributeError is when setBorderWidth is not defined
# (QgsSimpleMarkerSymbolLayerV2)
if hasattr(symbol_layer, 'setBorderWidth') and \
geometry_type == QGis.Polygon:
symbol_layer.setBorderWidth(0)
# set data defined properties
try:
for prop, expr in style_class['data_defined'].iteritems():
symbol_layer.setDataDefinedProperty(prop, expr)
except (NameError, KeyError):
# NameError is when symbol_layer is not defined (lines for example)
# KeyError is when data_defined is not defined
pass
symbol.setColor(colour)
# .. todo:: Check that vectors use alpha as % otherwise scale TS
# Convert transparency % to opacity
# alpha = 0: transparent
# alpha = 1: opaque
alpha = 1 - transparency_percent / 100.0
symbol.setAlpha(alpha)
category = QgsRendererCategoryV2(value, symbol, label)
category_list.append(category)
renderer = QgsCategorizedSymbolRendererV2('', category_list)
renderer.setClassAttribute(target_field)
vector_layer.setRendererV2(renderer)
vector_layer.saveDefaultStyle()
def testFilter(self):
"""Test filter creation"""
renderer = QgsCategorizedSymbolRendererV2()
renderer.setClassAttribute('field')
renderer.addCategory(
QgsRendererCategoryV2('a', createMarkerSymbol(), 'a'))
renderer.addCategory(
QgsRendererCategoryV2('b', createMarkerSymbol(), 'b'))
renderer.addCategory(
QgsRendererCategoryV2('c', createMarkerSymbol(), 'c'))
# add default category
renderer.addCategory(
QgsRendererCategoryV2('', createMarkerSymbol(), 'default'))
self.assertEqual(renderer.filter(), '')
# remove categories, leaving default
assert renderer.updateCategoryRenderState(0, False)
self.assertEqual(renderer.filter(),
"(\"field\") NOT IN ('a') OR (\"field\") IS NULL")
assert renderer.updateCategoryRenderState(1, False)
self.assertEqual(
renderer.filter(),
"(\"field\") NOT IN ('a','b') OR (\"field\") IS NULL")
assert renderer.updateCategoryRenderState(2, False)
self.assertEqual(
renderer.filter(),
"(\"field\") NOT IN ('a','b','c') OR (\"field\") IS NULL")
# remove default category
assert renderer.updateCategoryRenderState(3, False)
self.assertEqual(renderer.filter(), "FALSE")
# add back other categories, leaving default disabled
assert renderer.updateCategoryRenderState(0, True)
self.assertEqual(renderer.filter(), "(\"field\") IN ('a')")
assert renderer.updateCategoryRenderState(1, True)
self.assertEqual(renderer.filter(), "(\"field\") IN ('a','b')")
assert renderer.updateCategoryRenderState(2, True)
self.assertEqual(renderer.filter(), "(\"field\") IN ('a','b','c')")
renderer.deleteAllCategories()
# just default category
renderer.addCategory(
QgsRendererCategoryV2('', createMarkerSymbol(), 'default'))
self.assertEqual(renderer.filter(), '')
assert renderer.updateCategoryRenderState(0, False)
self.assertEqual(renderer.filter(), 'FALSE')
renderer.deleteAllCategories()
# no default category
renderer.addCategory(
QgsRendererCategoryV2('a', createMarkerSymbol(), 'a'))
renderer.addCategory(
QgsRendererCategoryV2('b', createMarkerSymbol(), 'b'))
renderer.addCategory(
QgsRendererCategoryV2('c', createMarkerSymbol(), 'c'))
self.assertEqual(renderer.filter(), "(\"field\") IN ('a','b','c')")
assert renderer.updateCategoryRenderState(0, False)
self.assertEqual(renderer.filter(), "(\"field\") IN ('b','c')")
assert renderer.updateCategoryRenderState(2, False)
self.assertEqual(renderer.filter(), "(\"field\") IN ('b')")
assert renderer.updateCategoryRenderState(1, False)
self.assertEqual(renderer.filter(), "FALSE")
renderer.deleteAllCategories()
# numeric categories
renderer.addCategory(
QgsRendererCategoryV2(1, createMarkerSymbol(), 'a'))
renderer.addCategory(
QgsRendererCategoryV2(2, createMarkerSymbol(), 'b'))
renderer.addCategory(
QgsRendererCategoryV2(3, createMarkerSymbol(), 'c'))
self.assertEqual(renderer.filter(), '(\"field\") IN (1,2,3)')
assert renderer.updateCategoryRenderState(0, False)
self.assertEqual(renderer.filter(), "(\"field\") IN (2,3)")
assert renderer.updateCategoryRenderState(2, False)
self.assertEqual(renderer.filter(), "(\"field\") IN (2)")
assert renderer.updateCategoryRenderState(1, False)
self.assertEqual(renderer.filter(), "FALSE")
def WPT2Layer(self):
mapUnits = define._canvas.mapUnits()
if define._mapCrs == None:
if mapUnits == QGis.Meters:
resultLayer = QgsVectorLayer(
"Point?crs=EPSG:32633", "WPT_" +
self.surfaceType.replace(" ", "_").replace("-", "_"),
"memory")
else:
resultLayer = QgsVectorLayer(
"Point?crs=EPSG:4326", "WPT_" +
self.surfaceType.replace(" ", "_").replace("-", "_"),
"memory")
else:
resultLayer = QgsVectorLayer(
"Point?crs=%s" % define._mapCrs.authid(),
"WPT_" + self.surfaceType.replace(" ", "_").replace("-", "_"),
"memory")
shpPath = ""
if define.obstaclePath != None:
shpPath = define.obstaclePath
elif define.xmlPath != None:
shpPath = define.xmlPath
else:
shpPath = define.appPath
er = QgsVectorFileWriter.writeAsVectorFormat(
resultLayer,
shpPath + "/" + "RnavTurningSegmentAnalyserWpt" + ".shp", "utf-8",
resultLayer.crs())
resultLayer = QgsVectorLayer(
shpPath + "/" + "RnavTurningSegmentAnalyserWpt" + ".shp",
"WPT_RnavTurningSegmentAnalyser", "ogr")
fieldName = "CATEGORY"
resultLayer.dataProvider().addAttributes(
[QgsField(fieldName, QVariant.String)])
resultLayer.startEditing()
fields = resultLayer.pendingFields()
i = 1
feature = QgsFeature()
feature.setFields(fields)
feature.setGeometry(
QgsGeometry.fromPoint(self.parametersPanel.pnlWaypoint1.Point3d))
feature.setAttribute(fieldName, "Waypoint1")
pr = resultLayer.dataProvider()
pr.addFeatures([feature])
# resultLayer.addFeature(feature)
feature.setGeometry(
QgsGeometry.fromPoint(self.parametersPanel.pnlWaypoint2.Point3d))
feature.setAttribute(fieldName, "Waypoint2")
pr = resultLayer.dataProvider()
pr.addFeatures([feature])
# resultLayer.addFeature(feature)
resultLayer.commitChanges()
renderCatFly = None
if self.parametersPanel.cmbType1.SelectedIndex == 1:
'''FlyOver'''
symbolFlyOver = QgsSymbolV2.defaultSymbol(
resultLayer.geometryType())
symbolFlyOver.deleteSymbolLayer(0)
svgSymLayer = QgsSvgMarkerSymbolLayerV2("Resource/flyover.svg",
10.0, 0.0)
symbolFlyOver.appendSymbolLayer(svgSymLayer)
renderCatFly = QgsRendererCategoryV2(0, symbolFlyOver, "Fly Over")
elif self.parametersPanel.cmbType1.SelectedIndex == 0:
'''FlyBy'''
symbolFlyBy = QgsSymbolV2.defaultSymbol(resultLayer.geometryType())
symbolFlyBy.deleteSymbolLayer(0)
svgSymLayer = QgsSvgMarkerSymbolLayerV2("Resource/flyby.svg", 10.0,
0.0)
symbolFlyBy.appendSymbolLayer(svgSymLayer)
renderCatFly = QgsRendererCategoryV2(0, symbolFlyBy, "Fly By")
else:
return None
WPT_EXPRESION = "CASE WHEN \"CATEGORY\" = 'Waypoint1' THEN 0 " + \
"END"
symRenderer = QgsCategorizedSymbolRendererV2(WPT_EXPRESION,
[renderCatFly])
resultLayer.setRendererV2(symRenderer)
return resultLayer
def style_rungkk(self):
#Select the layers open in TOC
layers = self.iface.legendInterface().layers()
layer_list = []
# Get only vector layer
for layer in layers:
if layer.type() == 0:
layer_list.append(layer.name())
else:
pass
# Add layer_list array to listWidget, clear layer if removed to layer in tools
self.dlgtool.input_layer.clear()
self.dlgtool.input_layer.addItems(layer_list)
# show the dialog
self.dlgtool.show()
# Run the dialog event loop
result = self.dlgtool.exec_()
current_layer = self.dlgtool.input_layer.currentText()
layer = QgsMapLayerRegistry.instance().mapLayersByName(
str(current_layer))[0]
ldlr_field = {
'TXG1':
('#00D000', u'Rừng gỗ tự nhiên núi đất LRTX giàu nguyên sinh'),
'TXB1':
('#00FF00', u'Rừng gỗ tự nhiên núi đất LRTX TB nguyên sinh'),
'RLG1':
('#A0A000', u'Rừng gỗ tự nhiên núi đất LRRL giàu nguyên sinh'),
'RLB1':
('#C0C000', u'Rừng gỗ tự nhiên núi đất LRRL TB nguyên sinh'),
'LKG1': ('#FF505A',
u'Rừng gỗ tự nhiên núi đất LK giàu nguyên sinh'),
'LKB1': ('#FF6982', u'Rừng gỗ tự nhiên núi đất LK TB nguyên sinh'),
'RKG1': ('#FFA0D0',
u'Rừng gỗ tự nhiên núi đất LRLK giàu nguyên sinh'),
'RKB1': ('#FFA0D0',
u'Rừng gỗ tự nhiên núi đất LRLK TB nguyên sinh'),
'TXDG1': ('#00D068',
u'Rừng gỗ tự nhiên núi đá LRTX giàu nguyên sinh'),
'TXDB1': ('#00FF80',
u'Rừng gỗ tự nhiên núi đá LRTX TB nguyên sinh'),
'RNM1': ('#7070FF', u'Rừng gỗ tự nhiên ngập mặn nguyên sinh'),
'RNP1': ('#A850FF', u'Rừng gỗ tự nhiên ngập phèn nguyên sinh'),
'RNN1': ('#E8D0FF', u'Rừng gỗ tự nhiên ngập ngọt nguyên sinh'),
'TXG': ('#00D000', u'Rừng gỗ tự nhiên núi đất LRTX giàu'),
'TXB': ('#00FF00', u'Rừng gỗ tự nhiên núi đất LRTX TB'),
'TXN': ('#90FF90', u'Rừng gỗ tự nhiên núi đất LRTX nghèo'),
'TXK': ('#B0FFB0', u'Rừng gỗ tự nhiên núi đất LRTX nghèo kiệt'),
'TXP': ('#B3FF40', u'Rừng gỗ tự nhiên núi đất LRTX phục hồi'),
'RLG': ('#A0A000', u'Rừng gỗ tự nhiên núi đất LRRL giàu'),
'RLB': ('#C0C000', u'Rừng gỗ tự nhiên núi đất LRRL TB'),
'RLN': ('#E0E000', u'Rừng gỗ tự nhiên núi đất LRRL nghèo'),
'RLK': ('#F0F000', u'Rừng gỗ tự nhiên núi đất LRRL nghèo kiệt'),
'RLP': ('#EBFF00', u'Rừng gỗ tự nhiên núi đất LRRL phục hồi'),
'LKG': ('#FF505A', u'Rừng gỗ tự nhiên núi đất LK giàu'),
'LKB': ('#FF6982', u'Rừng gỗ tự nhiên núi đất LK TB'),
'LKN': ('#FF8690', u'Rừng gỗ tự nhiên núi đất LK nghèo'),
'LKK': ('#FF9A90', u'Rừng gỗ tự nhiên núi đất LK nghèo kiệt'),
'LKP': ('#FFB0B0', u'Rừng gỗ tự nhiên núi đất LK phục hồi'),
'RKG': ('#FFA0D0', u'Rừng gỗ tự nhiên núi đất LRLK giàu'),
'RKB': ('#FFA0D0', u'Rừng gỗ tự nhiên núi đất LRLK TB'),
'RKN': ('#FFA0D0', u'Rừng gỗ tự nhiên núi đất LRLK nghèo'),
'RKK': ('#FFA0D0', u'Rừng gỗ tự nhiên núi đất LRLK nghèo kiệt'),
'RKP': ('#FFA0D0', u'Rừng gỗ tự nhiên núi đất LRLK phục hồi'),
'TXDG': ('#00D068', u'Rừng gỗ tự nhiên núi đá LRTX giàu'),
'TXDB': ('#00FF80', u'Rừng gỗ tự nhiên núi đá LRTX TB'),
'TXDN': ('#60FFB0', u'Rừng gỗ tự nhiên núi đá LRTX nghèo'),
'TXDK': ('#A0FFD0', u'Rừng gỗ tự nhiên núi đá LRTX nghèo kiệt'),
'TXDP': ('#D0FFE8', u'Rừng gỗ tự nhiên núi đá LRTX phục hồi'),
'RNMG': ('#7070FF', u'Rừng gỗ tự nhiên ngập mặn giàu'),
'RNMB': ('#9090FF', u'Rừng gỗ tự nhiên ngập mặn trung bình'),
'RNMN': ('#C0C0FF', u'Rừng gỗ tự nhiên ngập mặn nghèo'),
'RNMP': ('#D0D0FF', u'Rừng gỗ tự nhiên ngập mặn phục hồi'),
'RNPG': ('#A850FF', u'Rừng gỗ tự nhiên ngập phèn giàu'),
'RNPB': ('#C080FF', u'Rừng gỗ tự nhiên ngập phèn trung bình'),
'RNPN': ('#D0A0FF', u'Rừng gỗ tự nhiên ngập phèn nghèo'),
'RNPP': ('#D8B0FF', u'Rừng gỗ tự nhiên ngập phèn phục hồi'),
'RNN': ('#E8D0FF', u'Rừng gỗ tự nhiên ngập ngọt'),
'TLU': ('#D0E0FF', u'Rừng tre/luồng tự nhiên núi đất'),
'NUA': ('#D0E0FF', u'Rừng nứa tự nhiên núi đất'),
'VAU': ('#D0E0FF', u'Rừng vầu tự nhiên núi đất'),
'LOO': ('#D0E0FF', u'Rừng lồ ô tự nhiên núi đất'),
'TNK': ('#D0E0FF', u'Rừng tre nứa khác tự nhiên núi đất'),
'TND': ('#D0E0FF', u'Rừng tre nứa tự nhiên núi đá'),
'HG1': ('#FFD0FF', u'Rừng hỗn giao G-TN tự nhiên núi đất '),
'HG2': ('#FFD0FF', u'Rừng hỗn giao TN-G tự nhiên núi đất '),
'HGD': ('#FFD0FF', u'Rừng hỗn giao tự nhiên núi đá'),
'CD': ('#C0C0FF', u'Rừng cau dừa tự nhiên núi đất'),
'CDD': ('#C0C0FF', u'Rừng cau dừa tự nhiên núi đá'),
'CDN': ('#C0C0FF', u'Rừng cau dừa tự nhiên ngập nước ngọt'),
'RTG': ('#FFD8B0', u'Rừng gỗ trồng núi đất'),
'RTGD': ('#FFC080', u'Rừng gỗ trồng núi đá'),
'RTM': ('#FFC080', u'Rừng gỗ trồng ngập mặn'),
'RTP': ('#FFC080', u'Rừng gỗ trồng ngập phèn'),
'RTC': ('#FFC080', u'Rừng gỗ trồng đất cát'),
'RTTN': ('#FFC080', u'Rừng tre nứa trồng núi đất'),
'RTTND': ('#FFC080', u'Rừng tre nứa trồng núi đá'),
'RTCD': ('#FFC080', u'Rừng cau dừa trồng cạn'),
'RTCDN': ('#FFD8B0', u'Rừng cau dừa trồng ngập nước'),
'RTCDC': ('#FFC080', u'Rừng cau dừa trồng đất cát'),
'RTK': ('#FFC080', u'Rừng trồng khác núi đất'),
'RTKD': ('#FFE490', u'Rừng trồng khác núi đá'),
'DTR': ('#FFE8D0', u'Đất đã trồng trên núi đất'),
'DTRD': ('#FFE8D0', u'Đất đã trồng trên núi đá'),
'DTRM': ('#FFE8D0', u'Đất đã trồng trên đất ngập mặn'),
'DTRP': ('#FFE8D0', u'Đất đã trồng trên đất ngập phèn'),
'DTRN': ('#FFE8D0', u'Đất đã trồng trên đất ngập ngọt'),
'DTRC': ('#FFE8D0', u'Đất đã trồng trên bãi cát'),
'DT2': ('#006000', u'Đất có cây gỗ tái sinh núi đất'),
'DT2D': ('#006000', u'Đất có cây gỗ tái sinh núi đá'),
'DT2M': ('#006000', u'Đất có cây gỗ tái sinh ngập mặn'),
'DT2P': ('#006000', u'Đất có cây tái sinh ngập nước phèn'),
'DT1': ('#00FF00', u'Đất trống núi đất'),
'DT1D': ('#E0E0E0', u'Đất trống núi đá'),
'DT1M': ('#00FF00', u'Đất trống ngập mặn'),
'DT1P': ('#00FF00', u'Đất trống ngập nước phèn'),
'BC1': ('#808080', u'Bãi cát'),
'BC2': ('#00FF00', u'Bãi cát có cây rải rác'),
'NN': ('#FFFF90', u'Đất nông nghiệp núi đất'),
'NND': ('#FFFF90', u'Đất nông nghiệp núi đá'),
'NNM': ('#FFFF90', u'Đất nông nghiệp ngập mặn'),
'NNP': ('#FFFF90', u'Đất nông nghiệp ngập nước ngọt'),
'MN': ('#A0FFFF', u'Mặt nước '),
'DKH': ('#808080', u'Đất khác'),
# Ma bo sung mot so truong hop
'NL': ('#FFFF90', u'Đất nông nghiệp núi đất'),
'NLD': ('#FFFF90', u'Đất nông nghiệp núi đá'),
'NLM': ('#FFFF90', u'Đất nông nghiệp ngập mặn'),
'NLP': ('#FFFF90', u'Đất nông nghiệp ngập nước ngọt'),
'DK': ('#808080', u'Đất khác')
}
# Define style parameters: value, colour, legend
arr = {}
for feature in layer.getFeatures():
name = feature["ldlr"]
arr[name] = ldlr_field[name]
# Define a list for categories
categories = []
# Define symbology depending on layer type, set the relevant style parameters
for classes, (color, label) in arr.items():
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol.setColor(QColor(color))
category = QgsRendererCategoryV2(classes, symbol, label)
categories.append(category)
# Column/field name to be used to read values from
column = 'ldlr'
# Apply the style rendering
renderer = QgsCategorizedSymbolRendererV2(column, categories)
layer.setRendererV2(renderer)
# Refresh the layer
layer.triggerRepaint()
def saveParameters(self):
self.updateDistricts()
layers = self.iface.legendInterface().layers()
selectedLayerIndex = self.dlgparameters.cmbActiveLayer.currentIndex()
selectedLayer = layers[selectedLayerIndex]
self.activeLayer = selectedLayer
self.districts = self.dlgparameters.inpDistricts.value()
self.activedistrict = 1
self.dockwidget.lblActiveDistrict.setText("Active District: " +
str(self.activedistrict))
self.dockwidget.sliderDistricts.setMinimum(1)
self.dockwidget.sliderDistricts.setMaximum(self.districts)
self.dockwidget.sliderDistricts.setValue(1)
self.popfield = self.dlgparameters.cmbPopField.currentText()
self.distfield = self.dlgparameters.cmbDistField.currentText()
# self.dispfield1 = self.dlgparameters.cmbDispField1.currentText()
# self.dispfield2 = self.dlgparameters.cmbDispField1.currentText()
QgsMessageLog.logMessage("Popfield:" + str(self.popfield))
self.totalpop = 0
self.targetpop = 0
for feature in self.activeLayer.getFeatures():
self.totalpop = self.totalpop + feature[self.popfield]
self.targetpop = int(self.totalpop / self.districts)
self.targetpoppct = self.dlgparameters.inpTolerance.value()
targetpoprem = int((self.targetpop / 100) * self.targetpoppct)
self.targetpoplower = int(self.targetpop - targetpoprem)
self.targetpophigher = int(self.targetpop + targetpoprem + 1)
QgsMessageLog.logMessage("TargetPop:" + str(self.targetpop) + "(" +
str(self.targetpoplower) + ", " +
str(self.targetpophigher) + ")")
QgsMessageLog.logMessage("Districts:" + str(self.districts))
self.dockwidget.lblMainInfo.setText("Active Layer: " +
self.activeLayer.name() +
"\nActive District Field: " +
self.distfield +
"\nTarget Population: " +
str(self.targetpop) + " (" +
str(self.targetpoplower) + ", " +
str(self.targetpophigher) + ")")
self.attrdockwidget.tblPop.setRowCount(self.districts + 1)
numDataFields = 0
for d in dataFieldList:
numDataFields = numDataFields + 1
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
2 + numDataFields, QTableWidgetItem(d.name))
self.attrdockwidget.tblPop.setColumnCount(4 + numDataFields)
for r in range(0, self.districts + 1):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Unchecked)
self.attrdockwidget.tblPop.setItem(r, 1, chkBoxItem)
self.attrdockwidget.tblPop.setHorizontalHeaderLabels(
['#', 'Lock', 'Population', 'To Target'])
numDataFields = 0
for d in dataFieldList:
numDataFields = numDataFields + 1
if d.type == 1:
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
3 + numDataFields, QTableWidgetItem(d.name))
else:
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
3 + numDataFields, QTableWidgetItem(d.name + '%'))
if len(districtName) == 0:
self.initializeElectorates()
try:
self.saveParametersToFile()
QgsMessageLog.logMessage("Parameters file saved!")
except:
QgsMessageLog.logMessage("Parameters file could not be saved")
if self.dlgparameters.chkStyleMap.isChecked():
categories = []
for cat in range(0, self.districts + 1):
symbol = QgsSymbolV2.defaultSymbol(
self.activeLayer.geometryType())
layer_style = {}
layer_style['color'] = '%d, %d, %d' % (randrange(
0, 256), randrange(0, 256), randrange(0, 256))
layer_style['outline'] = '#000000'
symbol_layer = QgsSimpleFillSymbolLayerV2.create(layer_style)
# replace default symbol layer with the configured one
if symbol_layer is not None:
symbol.changeSymbolLayer(0, symbol_layer)
# create renderer object
category = QgsRendererCategoryV2(cat, symbol, str(cat))
# entry for the list of category items
categories.append(category)
renderer = QgsCategorizedSymbolRendererV2(self.distfield,
categories)
# assign the created renderer to the layer
if renderer is not None:
self.activeLayer.setRendererV2(renderer)
self.activeLayer.triggerRepaint()
self.updateFieldValues()
self.updateTable()
self.updateLockedFields()
self.updateDistricts()
def set_vector_categorized_style(vector_layer, style):
"""Set categorized QGIS vector style based on InaSAFE style dictionary.
For **opaque** a value of **0** can be used. For **fully transparent**, a
value of **100** can be used. The calling function should take care to
scale the transparency level to between 0 and 100.
:param vector_layer: A QGIS vector layer that will be styled.
:type vector_layer: QgsVectorLayer
:param style: Dictionary of the form as in the example below.
:type style: dict
:returns: None - Sets and saves style for vector_layer
Example::
{'target_field': 'DMGLEVEL',
'style_classes':
[{'transparency': 1, 'value': 1, 'colour': '#fecc5c',
'label': 'Low damage', 'size' : 1},
{'transparency': 55, 'value': 2, 'colour': '#fd8d3c',
'label': 'Medium damage', 'size' : 1},
{'transparency': 80, 'value': 3, 'colour': '#f31a1c',
'label': 'High damage', 'size' : 1}]}
.. note:: The transparency and size keys are optional. Size applies
to points only.
.. note:: We should change 'value' in style classes to something more
meaningful e.g. discriminant value
"""
myTargetField = style['target_field']
myClasses = style['style_classes']
myGeometryType = vector_layer.geometryType()
myCategoryList = []
for myClass in myClasses:
# Transparency 100: transparent
# Transparency 0: opaque
mySize = 2 # mm
if 'size' in myClass:
mySize = myClass['size']
myTransparencyPercent = 0
if 'transparency' in myClass:
myTransparencyPercent = myClass['transparency']
if 'value' not in myClass:
raise StyleError('Style info should provide a "value" entry')
try:
myValue = float(myClass['value'])
except TypeError:
raise StyleError(
'Value should be a number. I got %s' % myClass['value'])
myColour = myClass['colour']
myLabel = myClass['label']
myColour = QtGui.QColor(myColour)
# noinspection PyArgumentList
mySymbol = QgsSymbolV2.defaultSymbol(myGeometryType)
myColourString = "%s, %s, %s" % (
myColour.red(),
myColour.green(),
myColour.blue())
# Work around for the fact that QgsSimpleMarkerSymbolLayerV2
# python bindings are missing from the QGIS api.
# .. see:: http://hub.qgis.org/issues/4848
# We need to create a custom symbol layer as
# the border colour of a symbol can not be set otherwise
# noinspection PyArgumentList
myRegistry = QgsSymbolLayerV2Registry.instance()
if myGeometryType == QGis.Point:
myMetadata = myRegistry.symbolLayerMetadata('SimpleMarker')
# note that you can get a list of available layer properties
# that you can set by doing e.g.
# QgsSimpleMarkerSymbolLayerV2.properties()
mySymbolLayer = myMetadata.createSymbolLayer({
'color_border': myColourString})
mySymbolLayer.setSize(mySize)
mySymbol.changeSymbolLayer(0, mySymbolLayer)
elif myGeometryType == QGis.Polygon:
myMetadata = myRegistry.symbolLayerMetadata('SimpleFill')
mySymbolLayer = myMetadata.createSymbolLayer({
'color_border': myColourString})
mySymbol.changeSymbolLayer(0, mySymbolLayer)
else:
# for lines we do nothing special as the property setting
# below should give us what we require.
pass
mySymbol.setColor(myColour)
# .. todo:: Check that vectors use alpha as % otherwise scale TS
# Convert transparency % to opacity
# alpha = 0: transparent
# alpha = 1: opaque
alpha = 1 - myTransparencyPercent / 100.0
mySymbol.setAlpha(alpha)
myCategory = QgsRendererCategoryV2(myValue, mySymbol, myLabel)
myCategoryList.append(myCategory)
myRenderer = QgsCategorizedSymbolRendererV2('', myCategoryList)
myRenderer.setClassAttribute(myTargetField)
vector_layer.setRendererV2(myRenderer)
vector_layer.saveDefaultStyle()
def set_vector_categorized_style(vector_layer, style):
"""Set categorized QGIS vector style based on InaSAFE style dictionary.
For **opaque** a value of **0** can be used. For **fully transparent**, a
value of **100** can be used. The calling function should take care to
scale the transparency level to between 0 and 100.
:param vector_layer: A QGIS vector layer that will be styled.
:type vector_layer: QgsVectorLayer
:param style: Dictionary of the form as in the example below.
:type style: dict
:returns: None - Sets and saves style for vector_layer
Example::
{'target_field': 'DMGLEVEL',
'style_classes':
[{'transparency': 1, 'value': 1, 'colour': '#fecc5c',
'label': 'Low damage', 'size' : 1},
{'transparency': 55, 'value': 2, 'colour': '#fd8d3c',
'label': 'Medium damage', 'size' : 1},
{'transparency': 80, 'value': 3, 'colour': '#f31a1c',
'label': 'High damage', 'size' : 1}]}
.. note:: The transparency and size keys are optional. Size applies
to points only.
.. note:: We should change 'value' in style classes to something more
meaningful e.g. discriminant value
"""
myTargetField = style['target_field']
myClasses = style['style_classes']
geometry_type = vector_layer.geometryType()
category_list = []
for myClass in myClasses:
# Transparency 100: transparent
# Transparency 0: opaque
mySize = 2 # mm
if 'size' in myClass:
mySize = myClass['size']
myTransparencyPercent = 0
if 'transparency' in myClass:
myTransparencyPercent = myClass['transparency']
if 'value' not in myClass:
raise StyleError('Style info should provide a "value" entry')
try:
myValue = float(myClass['value'])
except TypeError:
raise StyleError('Value should be a number. I got %s' %
myClass['value'])
colour = myClass['colour']
label = myClass['label']
colour = QtGui.QColor(colour)
# noinspection PyArgumentList
symbol = QgsSymbolV2.defaultSymbol(geometry_type)
# We need to create a custom symbol layer as
# the border colour of a symbol can not be set otherwise
# noinspection PyArgumentList
if geometry_type == QGis.Point:
symbol_layer = QgsSimpleMarkerSymbolLayerV2()
symbol_layer.setBorderColor(colour)
symbol_layer.setSize(mySize)
symbol.changeSymbolLayer(0, symbol_layer)
elif geometry_type == QGis.Polygon:
symbol_layer = QgsSimpleFillSymbolLayerV2()
symbol_layer.setBorderColor(colour)
symbol.changeSymbolLayer(0, symbol_layer)
else:
# for lines we do nothing special as the property setting
# below should give us what we require.
pass
symbol.setColor(colour)
# .. todo:: Check that vectors use alpha as % otherwise scale TS
# Convert transparency % to opacity
# alpha = 0: transparent
# alpha = 1: opaque
alpha = 1 - myTransparencyPercent / 100.0
symbol.setAlpha(alpha)
category = QgsRendererCategoryV2(myValue, symbol, label)
category_list.append(category)
renderer = QgsCategorizedSymbolRendererV2('', category_list)
renderer.setClassAttribute(myTargetField)
vector_layer.setRendererV2(renderer)
vector_layer.saveDefaultStyle()