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 apply(self, layer):
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol_layer = QgsSimpleFillSymbolLayerV2.create({'color': self.color})
if self.border_style:
symbol_layer.setBorderStyle(self.border_style)
self.renderer = QgsSingleSymbolRendererV2(symbol)
self.renderer.symbols()[0].changeSymbolLayer(0, symbol_layer)
super(SimpleFillSymbology, self).apply(layer)
def testQgsSimpleFillSymbolLayerV2(self):
'''Create a new style from a .sld file and match test.
'''
mTestName = QString('QgsSimpleFillSymbolLayerV2')
mFilePath = QDir.toNativeSeparators(
QString('%1/symbol_layer/%2.sld').arg(unitTestDataPath(),
mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile(mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile, True)
mFile.close()
mSymbolLayer = QgsSimpleFillSymbolLayerV2.createFromSld(
mDoc.elementsByTagName('PolygonSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSimpleFillSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.SolidPattern
mValue = mSymbolLayer.brushStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QString(u'#ffaa7f')
mValue = mSymbolLayer.borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.DotLine
mValue = mSymbolLayer.borderStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 0.26
mValue = mSymbolLayer.borderWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue, mValue)
assert mExpectedValue == mValue, mMessage
def __init__(self, vectorLayer, parent=None):
QgsSimpleFillSymbolLayerV2Widget.__init__(self, vectorLayer, parent)
#Set symbol layer for the widget
self._symLayer = QgsSimpleFillSymbolLayerV2()
self._symLayer.setColor(Qt.cyan)
self._symLayer.setFillColor(Qt.yellow)
self.setSymbolLayer(self._symLayer)
self._btnFillColor = self.findChild(QPushButton, "btnChangeColor")
if self._btnFillColor != None:
self._btnFillColor.colorChanged.disconnect()
self._btnFillColor.colorChanged.connect(self.onSetFillColor)
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 __init__(self, vectorLayer, parent=None, symbol_layer=None):
QgsSimpleFillSymbolLayerV2Widget.__init__(self, vectorLayer, parent)
#Set symbol layer for the widget
self._sym_layer = symbol_layer
if self._sym_layer is None:
self._sym_layer = QgsSimpleFillSymbolLayerV2()
self._sym_layer.setColor(Qt.cyan)
self._sym_layer.setFillColor(Qt.yellow)
self.setSymbolLayer(self._sym_layer)
self.remove_data_defined_properties_button()
self._btnFillColor = self.findChild(QPushButton, "btnChangeColor")
if not self._btnFillColor is None:
self._btnFillColor.colorChanged.disconnect()
self._btnFillColor.colorChanged.connect(self.onSetFillColor)
def testQgsSimpleFillSymbolLayerV2(self):
'''Create a new style from a .sld file and match test.
'''
mTestName = QString ('QgsSimpleFillSymbolLayerV2')
mFilePath = QDir.toNativeSeparators(
QString('%1/symbol_layer/%2.sld').arg(
unitTestDataPath(), mTestName))
mDoc = QDomDocument(mTestName)
mFile = QFile (mFilePath)
mFile.open(QIODevice.ReadOnly)
mDoc.setContent(mFile,True)
mFile.close()
mSymbolLayer = QgsSimpleFillSymbolLayerV2.createFromSld(
mDoc.elementsByTagName('PolygonSymbolizer').item(0).toElement())
mExpectedValue = type(QgsSimpleFillSymbolLayerV2())
mValue = type(mSymbolLayer)
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue,mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.SolidPattern
mValue = mSymbolLayer.brushStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue,mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = QString(u'#ffaa7f')
mValue = mSymbolLayer.borderColor().name()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue,mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = Qt.DotLine
mValue = mSymbolLayer.borderStyle()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue,mValue)
assert mExpectedValue == mValue, mMessage
mExpectedValue = 0.26
mValue = mSymbolLayer.borderWidth()
mMessage = 'Expected "%s" got "%s"' % (mExpectedValue,mValue)
assert mExpectedValue == mValue, mMessage
def set_vector_graduated_style(vector_layer, style):
"""Set graduated 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, QgsMapLayer
:param style: Dictionary of the form as in the example below
:type style: dict
:returns: None - Sets and saves style for vector_layer
Example style::
{'target_field': 'DMGLEVEL',
'style_classes':
[{'transparency': 1, 'max': 1.5, 'colour': '#fecc5c',
'min': 0.5, 'label': '[0.5 - 1.5] Low damage', 'size' : 1},
{'transparency': 55, 'max': 2.5, 'colour': '#fd8d3c',
'min': 1.5, 'label': '[1.5 - 2.5] Medium damage', 'size' : 1},
{'transparency': 80, 'max': 3.5, 'colour': '#f31a1c',
'min': 2.5, 'label': '[2.5 - 3.5] High damage', 'size' : 1}]}
.. note:: The transparency and size keys are optional. Size applies
to points only.
.. note:: you can optionally pass border_color also, if not color 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()
range_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 'min' not in style_class:
raise StyleError('Style info should provide a "min" entry')
if 'max' not in style_class:
raise StyleError('Style info should provide a "max" entry')
try:
min_val = float(style_class['min'])
except TypeError:
raise StyleError('Class break lower bound should be a number.'
'I got %s' % style_class['min'])
try:
max_val = float(style_class['max'])
except TypeError:
raise StyleError('Class break upper bound should be a number.'
'I got %s' % style_class['max'])
color = style_class['colour']
label = style_class['label']
color = QtGui.QColor(color)
# 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
try:
value = style_class['border_color']
border_color = QtGui.QColor(value)
except KeyError:
border_color = color
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.
pass
try:
value = style_class['border_wdth']
symbol_layer.setBorderWidth(value)
except (NameError, KeyError):
# use QGIS default border size
# NameError is when symbol_layer is not defined (lines for example)
# KeyError is when borderWidth is not defined
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(color)
# .. 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)
range_renderer = QgsRendererRangeV2(min_val, max_val, symbol, label)
range_list.append(range_renderer)
renderer = QgsGraduatedSymbolRendererV2('', range_list)
renderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval)
renderer.setClassAttribute(target_field)
vector_layer.setRendererV2(renderer)
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
.. 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 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_graduated_style(vector_layer, style):
"""Set graduated 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, QgsMapLayer
:param style: Dictionary of the form as in the example below
:type style: dict
:returns: None - Sets and saves style for vector_layer
Example style::
{'target_field': 'DMGLEVEL',
'style_classes':
[{'transparency': 1, 'max': 1.5, 'colour': '#fecc5c',
'min': 0.5, 'label': '[0.5 - 1.5] Low damage', 'size' : 1},
{'transparency': 55, 'max': 2.5, 'colour': '#fd8d3c',
'min': 1.5, 'label': '[1.5 - 2.5] Medium damage', 'size' : 1},
{'transparency': 80, 'max': 3.5, 'colour': '#f31a1c',
'min': 2.5, 'label': '[2.5 - 3.5] High damage', 'size' : 1}]}
.. note:: The transparency and size keys are optional. Size applies
to points only.
"""
myTargetField = style['target_field']
myClasses = style['style_classes']
myGeometryType = vector_layer.geometryType()
myRangeList = []
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 'min' not in myClass:
raise StyleError('Style info should provide a "min" entry')
if 'max' not in myClass:
raise StyleError('Style info should provide a "max" entry')
try:
myMin = float(myClass['min'])
except TypeError:
raise StyleError('Class break lower bound should be a number.'
'I got %s' % myClass['min'])
try:
myMax = float(myClass['max'])
except TypeError:
raise StyleError('Class break upper bound should be a number.'
'I got %s' % myClass['max'])
myColour = myClass['colour']
myLabel = myClass['label']
myColour = QtGui.QColor(myColour)
# noinspection PyArgumentList
mySymbol = QgsSymbolV2.defaultSymbol(myGeometryType)
# We need to create a custom symbol layer as
# the border colour of a symbol can not be set otherwise
# noinspection PyArgumentList
if myGeometryType == QGis.Point:
mySymbolLayer = QgsSimpleMarkerSymbolLayerV2()
mySymbolLayer.setBorderColor(myColour)
mySymbolLayer.setSize(mySize)
mySymbol.changeSymbolLayer(0, mySymbolLayer)
elif myGeometryType == QGis.Polygon:
mySymbolLayer = QgsSimpleFillSymbolLayerV2()
mySymbolLayer.setBorderColor(myColour)
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)
myRange = QgsRendererRangeV2(myMin, myMax, mySymbol, myLabel)
myRangeList.append(myRange)
myRenderer = QgsGraduatedSymbolRendererV2('', myRangeList)
myRenderer.setMode(QgsGraduatedSymbolRendererV2.EqualInterval)
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()
def __getQgsPolygonSymbolLayer(self, msstyle):
props = {}
type_marker = ''
symbol = msstyle.get('symbol', False)
if symbol:
(type_marker, symbolname, msSymbol,
props) = self.__getMsSymbol(symbol, props, True)
opacity = self.__getMsOpacity(msstyle)
color = self.__getMsColor(msstyle, props, opacity)
self.__getMsOutlinecolor(msstyle, props, opacity)
self.__getMsLinecap(msstyle, props)
self.__getMsLinejoin(msstyle, props)
self.__getMsPattern(msstyle, props)
self.__getMsWidth(msstyle, props)
self.__getMsOutline(msstyle, props)
self.__getMsScale(msstyle, props)
offset = self.__getMsOffset(msstyle, props)
if not type_marker:
#-linea sencilla exterior-#
#-relleno simple (sin estilo de relleno preconfigurados)-#
if not color:
self.deleteProperties(props, _qgis.SIMPLE_LINE_SYMBOL_LAYER)
qgsSymbol = QgsSimpleLineSymbolLayerV2.create(props)
else:
self.deleteProperties(props, _qgis.SIMPLE_FILL_SYMBOL_LAYER)
qgsSymbol = QgsSimpleFillSymbolLayerV2.create(props)
#-relleno de gradientes-#
#el gradiente es para renderer por categorias continuas
#no aplica, porque aca es para gradiente de un simbolo
else:
props_parent = {}
self.__setMsOffsetXY(offset, props)
self.__getMsAngle(msstyle, props, props_parent)
gap = self.__getMsGap(msstyle)
size = self.__getMsSize(msstyle, props)
self.__getMarkerDisplacementAndRotate(msstyle, gap, size,
props_parent)
geomtransform = msstyle.get('geomtransform', '').lower()
if geomtransform == 'centroid':
#-relleno de centroides-#
self.__getMsAnchorpoint(msSymbol, props)
qgsSubSymbol = self.__getQgsMarkerSubSymbol(
type_marker, msSymbol, size, props)
#self.deleteProperties(props_parent, _qgis.CENTROID_FILL_SYMBOL_LAYER)
qgsSymbol = QgsCentroidFillSymbolLayerV2.create({})
qgsSymbol.setSubSymbol(qgsSubSymbol)
elif not color:
#-Linea exterior:linea de marcador-#
self.__getMsAnchorpoint(msSymbol, props)
qgsSubSymbol = self.__getQgsMarkerSubSymbol(
type_marker, msSymbol, size, props)
self.deleteProperties(props_parent,
_qgis.MARKER_LINE_SYMBOL_LAYER)
qgsSymbol = QgsMarkerLineSymbolLayerV2.create(props_parent)
qgsSymbol.setSubSymbol(qgsSubSymbol)
elif type_marker == _ms.MS_SYMBOL_HATCH:
if not props['use_custom_dash']:
#-relleno simple (con estilo de relleno)-#
self.deleteProperties(props,
_qgis.SIMPLE_LINE_SYMBOL_LAYER)
qgsSymbol = QgsSimpleLineSymbolLayerV2.create(props)
else:
#-Patron de relleno de linea-#
self.deleteProperties(props,
_qgis.SIMPLE_LINE_SYMBOL_LAYER)
qgsSubSymbol = self.__getSubSymbol(
QgsLineSymbolV2, QgsSimpleLineSymbolLayerV2, QGis.Line,
props)
self.deleteProperties(props_parent,
_qgis.LINE_PATTERN_FILL_SYMBOL_LAYER)
qgsSymbol = QgsLinePatternFillSymbolLayer.create(
props_parent)
qgsSymbol.setSubSymbol(qgsSubSymbol)
elif type_marker == _ms.MS_SYMBOL_PIXMAP:
#-relleno de imagen raster-#
self.deleteProperties(props, _qgis.RASTER_FILL_SYMBOL_LAYER)
qgsSymbol = QgsRasterFillSymbolLayer.create(props)
elif type_marker == _ms.MS_SYMBOL_SVG:
#-relleno SVG-#
self.deleteProperties(props, _qgis.SIMPLE_LINE_SYMBOL_LAYER)
qgsSubSymbol = self.__getSubSymbol(QgsLineSymbolV2,
QgsSimpleLineSymbolLayerV2,
QGis.Line, props)
self.deleteProperties(props_parent,
_qgis.SVG_FILL_SYMBOL_LAYER)
qgsSymbol = QgsSVGFillSymbolLayer.create(props_parent)
qgsSymbol.setSubSymbol(qgsSubSymbol)
else:
#-patron de relleno de puntos-#
self.__getMsAnchorpoint(msSymbol, props)
qgsSubSymbol = self.__getQgsMarkerSubSymbol(
type_marker, msSymbol, size, props)
self.deleteProperties(props_parent,
_qgis.POINT_PATTERN_FILL_SYMBOL_LAYER)
qgsSymbol = QgsPointPatternFillSymbolLayer.create(props_parent)
qgsSymbol.setSubSymbol(qgsSubSymbol)
#qgsSymbol.setAlpha((opacity*1.0)/100)
#print(props)
return qgsSymbol
