def testQgsGraduatedSymbolRenderer_3(self):
"""Test QgsGraduatedSymbolRenderer: Reading attribute data, calculating classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
# Test retrieving data values from a layer
ml = createMemoryLayer((1.2, 0.5, 5.0, 1.0, 1.0, 1.2))
renderer.setClassAttribute("value")
# Equal interval calculations
renderer.updateClasses(ml, renderer.EqualInterval, 3)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.5000-2.0000,2.0000-3.5000,3.5000-5.0000,)',
'Equal interval classification not correct')
# Quantile classes
renderer.updateClasses(ml, renderer.Quantile, 3)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.5000-1.0000,1.0000-1.2000,1.2000-5.0000,)',
'Quantile classification not correct')
renderer.updateClasses(ml, renderer.Quantile, 4)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.5000-1.0000,1.0000-1.1000,1.1000-1.2000,1.2000-5.0000,)',
'Quantile classification not correct')
def testQgsGraduatedSymbolRenderer_1(self):
"""Test QgsGraduatedSymbolRenderer: Basic get/set functions """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
self.assertEqual(symbol.dump(),
renderer.sourceSymbol().dump(),
"Get/set renderer source symbol")
attr = '"value"*"value"'
renderer.setClassAttribute(attr)
self.assertEqual(attr, renderer.classAttribute(),
"Get/set renderer class attribute")
for m in (
QgsGraduatedSymbolRenderer.Custom,
QgsGraduatedSymbolRenderer.EqualInterval,
QgsGraduatedSymbolRenderer.Quantile,
QgsGraduatedSymbolRenderer.Jenks,
QgsGraduatedSymbolRenderer.Pretty,
QgsGraduatedSymbolRenderer.StdDev,
):
renderer.setMode(m)
self.assertEqual(m, renderer.mode(), "Get/set renderer mode")
format = createLabelFormat()
renderer.setLabelFormat(format)
self.assertEqual(dumpLabelFormat(format),
dumpLabelFormat(renderer.labelFormat()),
"Get/set renderer label format")
ramp = createColorRamp()
renderer.setSourceColorRamp(ramp)
self.assertEqual(dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
renderer.setSourceColorRamp(ramp)
self.assertEqual(dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
# test for classificatio with varying size
renderer.setGraduatedMethod(QgsGraduatedSymbolRenderer.GraduatedSize)
renderer.setSourceColorRamp(None)
renderer.addClassLowerUpper(0, 2)
renderer.addClassLowerUpper(2, 4)
renderer.addClassLowerUpper(4, 6)
renderer.setSymbolSizes(2, 13)
self.assertEqual(renderer.maxSymbolSize(), 13)
self.assertEqual(renderer.minSymbolSize(), 2)
refSizes = [2, (13 + 2) * .5, 13]
ctx = QgsRenderContext()
for idx, symbol in enumerate(renderer.symbols(ctx)):
self.assertEqual(symbol.size(), refSizes[idx])
def testQgsGraduatedSymbolRenderer_1(self):
"""Test QgsGraduatedSymbolRenderer: Basic get/set functions """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
self.assertEqual(symbol.dump(), renderer.sourceSymbol().dump(), "Get/set renderer source symbol")
attr = '"value"*"value"'
renderer.setClassAttribute(attr)
self.assertEqual(attr, renderer.classAttribute(), "Get/set renderer class attribute")
for m in (
QgsGraduatedSymbolRenderer.Custom,
QgsGraduatedSymbolRenderer.EqualInterval,
QgsGraduatedSymbolRenderer.Quantile,
QgsGraduatedSymbolRenderer.Jenks,
QgsGraduatedSymbolRenderer.Pretty,
QgsGraduatedSymbolRenderer.StdDev,
):
renderer.setMode(m)
self.assertEqual(m, renderer.mode(), "Get/set renderer mode")
format = createLabelFormat()
renderer.setLabelFormat(format)
self.assertEqual(
dumpLabelFormat(format),
dumpLabelFormat(renderer.labelFormat()),
"Get/set renderer label format")
ramp = createColorRamp()
renderer.setSourceColorRamp(ramp)
self.assertEqual(
dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
renderer.setSourceColorRamp(ramp)
self.assertEqual(
dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
# test for classificatio with varying size
renderer.setGraduatedMethod(QgsGraduatedSymbolRenderer.GraduatedSize)
renderer.setSourceColorRamp(None)
renderer.addClassLowerUpper(0, 2)
renderer.addClassLowerUpper(2, 4)
renderer.addClassLowerUpper(4, 6)
renderer.setSymbolSizes(2, 13)
self.assertEqual(renderer.maxSymbolSize(), 13)
self.assertEqual(renderer.minSymbolSize(), 2)
refSizes = [2, (13 + 2) * .5, 13]
ctx = QgsRenderContext()
for idx, symbol in enumerate(renderer.symbols(ctx)):
self.assertEqual(symbol.size(), refSizes[idx])
def testQgsGraduatedSymbolRenderer_3(self):
"""Test QgsGraduatedSymbolRenderer: Reading attribute data, calculating classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
# Test retrieving data values from a layer
ml = createMemoryLayer((1.2, 0.5, 5.0, 1.0, 1.0, 1.2))
# ... by attribute
renderer.setClassAttribute("value")
self.assertEqual(renderer.classAttribute(), "value",
"Error in set/get classAttribute")
data = renderer.getDataValues(ml)
datastr = ':'.join([str(x) for x in data])
self.assertEqual(datastr, '1.2:0.5:5.0:1.0:1.0:1.2',
"Error returning field data")
# ... by expression
renderer.setClassAttribute('"value"*"value"')
self.assertEqual(renderer.classAttribute(), '"value"*"value"',
"Error in set/get classAttribute")
data = renderer.getDataValues(ml)
datastr = ':'.join([str(x) for x in data])
self.assertEqual(datastr, '1.44:0.25:25.0:1.0:1.0:1.44',
"Error returning field expression")
renderer.setClassAttribute("value")
# Equal interval calculations
renderer.updateClasses(ml, renderer.EqualInterval, 3)
self.assertEqual(dumpRangeBreaks(renderer.ranges()),
'(0.5000-2.0000,2.0000-3.5000,3.5000-5.0000,)',
'Equal interval classification not correct')
# Quantile classes
renderer.updateClasses(ml, renderer.Quantile, 3)
self.assertEqual(dumpRangeBreaks(renderer.ranges()),
'(0.5000-1.0000,1.0000-1.2000,1.2000-5.0000,)',
'Quantile classification not correct')
renderer.updateClasses(ml, renderer.Quantile, 4)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.5000-1.0000,1.0000-1.1000,1.1000-1.2000,1.2000-5.0000,)',
'Quantile classification not correct')
def testQgsGraduatedSymbolRenderer_3(self):
"""Test QgsGraduatedSymbolRenderer: Reading attribute data, calculating classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
# Test retrieving data values from a layer
ml = createMemoryLayer((1.2, 0.5, 5.0, 1.0, 1.0, 1.2))
# ... by attribute
renderer.setClassAttribute("value")
self.assertEqual(renderer.classAttribute(), "value", "Error in set/get classAttribute")
data = renderer.getDataValues(ml)
datastr = ':'.join([str(x) for x in data])
self.assertEqual(datastr, '1.2:0.5:5.0:1.0:1.0:1.2', "Error returning field data")
# ... by expression
renderer.setClassAttribute('"value"*"value"')
self.assertEqual(renderer.classAttribute(), '"value"*"value"', "Error in set/get classAttribute")
data = renderer.getDataValues(ml)
datastr = ':'.join([str(x) for x in data])
self.assertEqual(datastr, '1.44:0.25:25.0:1.0:1.0:1.44', "Error returning field expression")
renderer.setClassAttribute("value")
# Equal interval calculations
renderer.updateClasses(ml, renderer.EqualInterval, 3)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.5000-2.0000,2.0000-3.5000,3.5000-5.0000,)',
'Equal interval classification not correct')
# Quantile classes
renderer.updateClasses(ml, renderer.Quantile, 3)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.5000-1.0000,1.0000-1.2000,1.2000-5.0000,)',
'Quantile classification not correct')
renderer.updateClasses(ml, renderer.Quantile, 4)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.5000-1.0000,1.0000-1.1000,1.1000-1.2000,1.2000-5.0000,)',
'Quantile classification not correct')
def testQgsGraduatedSymbolRenderer_2(self):
"""Test QgsGraduatedSymbolRenderer: Adding /removing/editing classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
symbol.setColor(QColor(255, 0, 0))
# Add class without start and end ranges
renderer.addClass(symbol.clone())
renderer.addClass(symbol.clone())
renderer.updateRangeLabel(1, 'Second range')
renderer.updateRangeLowerValue(1, 10.0)
renderer.updateRangeUpperValue(1, 25.0)
renderer.updateRangeRenderState(1, False)
symbol.setColor(QColor(0, 0, 255))
renderer.updateRangeSymbol(1, symbol.clone())
# Add as a rangeobject
symbol.setColor(QColor(0, 255, 0))
range = QgsRendererRange(20.0, 25.5, symbol.clone(), 'Third range',
False)
renderer.addClassRange(range)
# Add class by lower and upper
renderer.addClassLowerUpper(25.5, 30.5)
# (Update label for sorting tests)
renderer.updateRangeLabel(3, 'Another range')
self.assertEqual(
dumpRangeLabels(renderer.ranges()),
'(0.0 - 0.0,Second range,Third range,Another range,)',
'Added ranges labels not correct')
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'Added ranges lower/upper values not correct')
# Check that clone function works
renderer2 = renderer.clone()
self.assertEqual(dumpGraduatedRenderer(renderer),
dumpGraduatedRenderer(renderer2),
"clone function doesn't replicate renderer properly")
# Check save and reload from Dom works
doc = QDomDocument()
element = renderer.save(doc)
renderer2 = QgsGraduatedSymbolRenderer.create(element)
self.assertEqual(
dumpGraduatedRenderer(renderer), dumpGraduatedRenderer(renderer2),
"Save/create from DOM doesn't replicate renderer properly")
# Check sorting
renderer.sortByLabel()
self.assertEqual(
dumpRangeList(renderer.ranges(), labelsOnly=True),
'(0.0 - 0.0,Another range,Second range,Third range,)',
'sortByLabel not correct')
renderer.sortByValue()
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'sortByValue not correct')
renderer.sortByValue(Qt.DescendingOrder)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,10.0000-25.0000,0.0000-0.0000,)',
'sortByValue descending not correct')
# Check deleting
renderer.deleteClass(2)
self.assertEqual(dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,0.0000-0.0000,)',
'deleteClass not correct')
renderer.deleteAllClasses()
self.assertEqual(len(renderer.ranges()), 0,
"deleteAllClasses didn't delete all")
def testQgsGraduatedSymbolRenderer_2(self):
"""Test QgsGraduatedSymbolRenderer: Adding /removing/editing classes """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
symbol.setColor(QColor(255, 0, 0))
# Add class without start and end ranges
renderer.addClass(symbol.clone())
renderer.addClass(symbol.clone())
renderer.updateRangeLabel(1, 'Second range')
renderer.updateRangeLowerValue(1, 10.0)
renderer.updateRangeUpperValue(1, 25.0)
renderer.updateRangeRenderState(1, False)
symbol.setColor(QColor(0, 0, 255))
renderer.updateRangeSymbol(1, symbol.clone())
# Add as a rangeobject
symbol.setColor(QColor(0, 255, 0))
range = QgsRendererRange(20.0, 25.5, symbol.clone(), 'Third range', False)
renderer.addClassRange(range)
# Add class by lower and upper
renderer.addClassLowerUpper(25.5, 30.5)
# (Update label for sorting tests)
renderer.updateRangeLabel(3, 'Another range')
self.assertEqual(
dumpRangeLabels(renderer.ranges()),
'(0.0 - 0.0,Second range,Third range,Another range,)',
'Added ranges labels not correct')
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'Added ranges lower/upper values not correct')
# Check that clone function works
renderer2 = renderer.clone()
self.assertEqual(
dumpGraduatedRenderer(renderer),
dumpGraduatedRenderer(renderer2),
"clone function doesn't replicate renderer properly"
)
# Check save and reload from Dom works
doc = QDomDocument()
element = renderer.save(doc, QgsReadWriteContext())
renderer2 = QgsGraduatedSymbolRenderer.create(element, QgsReadWriteContext())
self.assertEqual(
dumpGraduatedRenderer(renderer),
dumpGraduatedRenderer(renderer2),
"Save/create from DOM doesn't replicate renderer properly"
)
# Check sorting
renderer.sortByLabel()
self.assertEqual(
dumpRangeList(renderer.ranges(), labelsOnly=True),
'(0.0 - 0.0,Another range,Second range,Third range,)',
'sortByLabel not correct')
renderer.sortByValue()
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(0.0000-0.0000,10.0000-25.0000,20.0000-25.5000,25.5000-30.5000,)',
'sortByValue not correct')
renderer.sortByValue(Qt.DescendingOrder)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,10.0000-25.0000,0.0000-0.0000,)',
'sortByValue descending not correct')
# Check deleting
renderer.deleteClass(2)
self.assertEqual(
dumpRangeBreaks(renderer.ranges()),
'(25.5000-30.5000,20.0000-25.5000,0.0000-0.0000,)',
'deleteClass not correct')
renderer.deleteAllClasses()
self.assertEqual(len(renderer.ranges()), 0, "deleteAllClasses didn't delete all")
def testQgsGraduatedSymbolRenderer_1(self):
"""Test QgsGraduatedSymbolRenderer: Basic get/set functions """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
self.assertEqual(symbol.dump(),
renderer.sourceSymbol().dump(),
"Get/set renderer source symbol")
attr = '"value"*"value"'
renderer.setClassAttribute(attr)
self.assertEqual(attr, renderer.classAttribute(),
"Get/set renderer class attribute")
for m in (
QgsGraduatedSymbolRenderer.Custom,
QgsGraduatedSymbolRenderer.EqualInterval,
QgsGraduatedSymbolRenderer.Quantile,
QgsGraduatedSymbolRenderer.Jenks,
QgsGraduatedSymbolRenderer.Pretty,
QgsGraduatedSymbolRenderer.StdDev,
):
renderer.setMode(m)
self.assertEqual(m, renderer.mode(), "Get/set renderer mode")
format = createLabelFormat()
renderer.setLabelFormat(format)
self.assertEqual(dumpLabelFormat(format),
dumpLabelFormat(renderer.labelFormat()),
"Get/set renderer label format")
ramp = createColorRamp()
renderer.setSourceColorRamp(ramp)
self.assertEqual(dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
renderer.setInvertedColorRamp(True)
self.assertTrue(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
renderer.setInvertedColorRamp(False)
self.assertFalse(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
value = '"value"*2'
exp = QgsSymbolLayerUtils.fieldOrExpressionToExpression(value)
valuestr = QgsSymbolLayerUtils.fieldOrExpressionFromExpression(exp)
renderer.setRotationField(value)
self.assertEqual(valuestr, renderer.rotationField(),
"Get/set renderer rotation field")
value = '"value"*3'
exp = QgsSymbolLayerUtils.fieldOrExpressionToExpression(value)
valuestr = QgsSymbolLayerUtils.fieldOrExpressionFromExpression(exp)
renderer.setSizeScaleField(value)
self.assertEqual(valuestr, renderer.sizeScaleField(),
"Get/set renderer size scale field")
renderer.setSourceColorRamp(ramp)
self.assertEqual(dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
for sm in (
QgsSymbol.ScaleArea,
QgsSymbol.ScaleDiameter,
):
renderer.setScaleMethod(sm)
self.assertEqual(str(sm), str(renderer.scaleMethod()),
"Get/set renderer scale method")
# test for classificatio with varying size
renderer.setGraduatedMethod(QgsGraduatedSymbolRenderer.GraduatedSize)
renderer.setSourceColorRamp(None)
renderer.addClassLowerUpper(0, 2)
renderer.addClassLowerUpper(2, 4)
renderer.addClassLowerUpper(4, 6)
renderer.setSymbolSizes(2, 13)
self.assertEqual(renderer.maxSymbolSize(), 13)
self.assertEqual(renderer.minSymbolSize(), 2)
refSizes = [2, (13 + 2) * .5, 13]
ctx = QgsRenderContext()
for idx, symbol in enumerate(renderer.symbols2(ctx)):
self.assertEqual(symbol.size(), refSizes[idx])
def testQgsGraduatedSymbolRenderer_1(self):
"""Test QgsGraduatedSymbolRenderer: Basic get/set functions """
# Create a renderer
renderer = QgsGraduatedSymbolRenderer()
symbol = createMarkerSymbol()
renderer.setSourceSymbol(symbol.clone())
self.assertEqual(symbol.dump(), renderer.sourceSymbol().dump(), "Get/set renderer source symbol")
attr = '"value"*"value"'
renderer.setClassAttribute(attr)
self.assertEqual(attr, renderer.classAttribute(), "Get/set renderer class attribute")
for m in (
QgsGraduatedSymbolRenderer.Custom,
QgsGraduatedSymbolRenderer.EqualInterval,
QgsGraduatedSymbolRenderer.Quantile,
QgsGraduatedSymbolRenderer.Jenks,
QgsGraduatedSymbolRenderer.Pretty,
QgsGraduatedSymbolRenderer.StdDev,
):
renderer.setMode(m)
self.assertEqual(m, renderer.mode(), "Get/set renderer mode")
format = createLabelFormat()
renderer.setLabelFormat(format)
self.assertEqual(
dumpLabelFormat(format),
dumpLabelFormat(renderer.labelFormat()),
"Get/set renderer label format")
ramp = createColorRamp()
renderer.setSourceColorRamp(ramp)
self.assertEqual(
dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
renderer.setInvertedColorRamp(True)
self.assertTrue(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
renderer.setInvertedColorRamp(False)
self.assertFalse(renderer.invertedColorRamp(),
"Get/set renderer inverted color ramp")
value = '"value"*2'
exp = QgsSymbolLayerUtils.fieldOrExpressionToExpression(value)
valuestr = QgsSymbolLayerUtils.fieldOrExpressionFromExpression(exp)
renderer.setRotationField(value)
self.assertEqual(valuestr, renderer.rotationField(),
"Get/set renderer rotation field")
value = '"value"*3'
exp = QgsSymbolLayerUtils.fieldOrExpressionToExpression(value)
valuestr = QgsSymbolLayerUtils.fieldOrExpressionFromExpression(exp)
renderer.setSizeScaleField(value)
self.assertEqual(valuestr, renderer.sizeScaleField(),
"Get/set renderer size scale field")
renderer.setSourceColorRamp(ramp)
self.assertEqual(
dumpColorRamp(ramp),
dumpColorRamp(renderer.sourceColorRamp()),
"Get/set renderer color ramp")
for sm in (
QgsSymbol.ScaleArea,
QgsSymbol.ScaleDiameter,
):
renderer.setScaleMethod(sm)
self.assertEqual(str(sm), str(renderer.scaleMethod()),
"Get/set renderer scale method")
# test for classificatio with varying size
renderer.setGraduatedMethod(QgsGraduatedSymbolRenderer.GraduatedSize)
renderer.setSourceColorRamp(None)
renderer.addClassLowerUpper(0, 2)
renderer.addClassLowerUpper(2, 4)
renderer.addClassLowerUpper(4, 6)
renderer.setSymbolSizes(2, 13)
self.assertEqual(renderer.maxSymbolSize(), 13)
self.assertEqual(renderer.minSymbolSize(), 2)
refSizes = [2, (13 + 2) * .5, 13]
ctx = QgsRenderContext()
for idx, symbol in enumerate(renderer.symbols2(ctx)):
self.assertEqual(symbol.size(), refSizes[idx])
class LayerBase(QgsVectorLayer):
"""QGIS layer base class (read-only memory based).
:param fileName: path to input file
:param storageFormat: storage format for layer (Memory or SQLite)
"""
def __init__(self, fileName, storageFormat):
self._fileName = fileName
self._layerName = os.path.splitext(os.path.basename(self._fileName))[0]
self.storageFormat = storageFormat
# create point layer (WGS-84, EPSG:4326)
super(LayerBase, self).__init__('Point?crs=epsg:4326', self._layerName,
"memory")
self._aliases = [] # list of attribute aliases
self._provider = self.dataProvider()
# import errors
self._errs = {}
# layer is empty, no data loaded
self._loaded = False
self.metadata = None
# layer type not defined
self.layerType = None
# style
self._style = Style()
self._renderer = None
def load(self, reader):
"""Load input data by specified reader.
:param reader: reader class used for reading input data
"""
if self._loaded:
return # data already loaded
# create progress bar widget
progressMessageBar = iface.messageBar().createMessage(
self.tr("Loading data..."))
progress = QtWidgets.QProgressBar()
progress.setMaximum(100)
progressMessageBar.layout().addWidget(progress)
iface.messageBar().pushWidget(progressMessageBar, Qgis.Info)
# load items as new point features (inform user about progress)
i = 0
count = reader.count()
start = time.clock()
prev = None # previous feature
self.startEditing()
for item in reader:
i += 1
if i == 1 and not self._aliases:
# set attributes from data item if needed
self._aliases = self._setAttrbsDefs(
limit=item.keys(), defs=reader.attributeDefs())
feat = self._item2feat(item)
if not feat:
# error appeared
continue
feat.setId(i)
self.addFeature(feat)
if i % 100 == 0:
percent = i / float(count) * 100
progress.setValue(percent)
# add features (attributes recalculated if requested)
self.commitChanges()
if self.storageFormat != "memory":
self._writeToOgrDataSource()
self.reload()
# finish import
endtime = time.clock() - start
progress.setValue(100)
iface.messageBar().clearWidgets()
if self._errs:
# report errors if any
iface.messageBar().pushMessage(
self.tr("Info"),
self.
tr("{} invalid measurement(s) skipped (see message log for details)"
).format(sum(self._errs.values())),
level=Qgis.Info,
duration=5)
for attr in list(self._errs.keys()):
QgsMessageLog.logMessage(
"{}: {} measurement(s) skipped (invalid {})".format(
self._fileName, self._errs[attr], attr),
tag=PLUGIN_NAME)
# inform user about successful import
iface.messageBar().pushMessage(
self.tr("Data loaded"),
self.tr("{} features loaded (in {:.2f} sec).").format(
self.featureCount(), endtime),
level=Qgis.Success,
duration=3)
# data loaded (avoid multiple imports)
self._loaded = True
# switch to read-only mode
self.setReadOnly(True)
def _writeToOgrDataSource(self):
fileExt = self.storageFormat.lower()
filePath = os.path.splitext(self._fileName)[0] + '.{}'.format(fileExt)
writer, msg = QgsVectorFileWriter.writeAsVectorFormat(
self,
filePath,
self._provider.encoding(),
self._provider.crs(),
driverName=self.storageFormat)
if writer != QgsVectorFileWriter.NoError:
raise LoadError(
self.tr("Unable to create SQLite datasource: {}").format(msg))
# set datasource to new OGR datasource
self.setDataSource(filePath, self._layerName, 'ogr')
self._provider = self.dataProvider()
# create metadata layer
if self.metadata and 'table' in self.metadata:
ds = ogr.Open(filePath, True)
layer_name = self.metadata['table']
layer = ds.GetLayerByName(layer_name)
if layer is None:
layer = ds.CreateLayer(layer_name, None, ogr.wkbNone)
layer_defn = layer.GetLayerDefn()
if 'columns' in self.metadata:
for key in self.metadata['columns']:
field = ogr.FieldDefn(key, ogr.OFTString)
layer.CreateField(field)
feat = ogr.Feature(layer_defn)
for key, value in list(self.metadata['columns'].items()):
feat.SetField(key, value)
layer.CreateFeature(feat)
feat = None
def _addError(self, etype):
"""Add error message.
:param etype: error type (HDOP, SAT, ...)
"""
if etype not in self._errs:
self._errs[etype] = 0
self._errs[etype] += 1
def _item2feat(self, item):
"""Create QgsFeature from data item.
"""
raise NotImplementedError()
def _setAttrbsDefs(self, limit=[], defs=None):
"""Set attributes definition from CSV file if available.
:param limit: limit to list of attributes
:returns: list of aliases
"""
def addAttribute(row, attrbs, aliases):
attrbs.append(
QgsField(row['attribute'],
eval("QVariant.{}".format(row['qtype']))))
if 'alias' in row and row['alias']:
aliases.append(row['alias'].replace('_', ' '))
def processAttributes(csv_attrbs, limit):
attrbs = []
aliases = []
if limit:
# limit attributes based on input file (first feature) - ERS/PEI format specific
for name in limit:
# first try full name match
found = False
for row in csv_attrbs:
if row['attribute'] == name:
addAttribute(row, attrbs, aliases)
found = True
break
if found:
continue
for row in csv_attrbs:
# full name match is not required see
# https://gitlab.com/opengeolabs/qgis-radiation-toolbox-plugin/issues/41#note_136183930
if row['attribute'] == name[:len(
row['attribute']
)] or name == row['attribute'][:len(name)]:
row_modified = copy.copy(row)
row_modified[
'attribute'] = name # force (full) attribute name from input file
if row_modified['alias']:
row_modified['alias'] = '{} ({})'.format(
name, row_modified['alias'])
addAttribute(row_modified, attrbs, aliases)
break
else:
# add all attributes
for row in csv_attrbs:
addAttribute(row, attrbs, aliases)
return attrbs, aliases
if not defs:
# predefined attributes (CSV file)
# Safecast, ERS
csv_file = self._attributesCSVFile()
if not os.path.exists(csv_file):
return []
with open(csv_file) as fd:
csv_attrbs = list(csv.DictReader(fd, delimiter=';'))
attrbs, aliases = processAttributes(csv_attrbs, limit)
else:
# data-driven attributes
# PEI
attrbs, aliases = processAttributes(defs, limit)
if limit and len(attrbs) != len(limit):
raise LoadError("Number of attributes differs {} vs {}".format(
len(attrbs), len(limit)))
if aliases and self.storageFormat != "memory":
aliases.insert(0, "FID")
# set attributes
self._provider.addAttributes(attrbs)
self.updateFields()
return aliases
def setAliases(self):
"""Set aliases
"""
for i in range(0, len(self._aliases)):
self.setFieldAlias(i, self._aliases[i])
def setStyle(self, idx):
"""Set layer style.
:param int idx: style (combobox) index
"""
try:
style = self._style[idx]
except (IndexError, KeyError):
return None
if 'file' in style:
# QML style
stylePath = style['file']
if not os.path.isfile(stylePath):
raise StyleError(
self.tr("Style '{}' not found").format(stylePath))
self.loadNamedStyle(stylePath)
elif 'colorramp' in style:
if not self._renderer:
# symbol (store transparent)
symbol = QgsSymbol.defaultSymbol(self.geometryType())
symbol.symbolLayer(0).setStrokeColor(QColor("transparent"))
# renderer
self._renderer = QgsGraduatedSymbolRenderer()
self._renderer.setSourceSymbol(symbol)
print(self._renderer.sourceSymbol())
self._renderer.setClassAttribute(style['attribute'])
self._renderer.setMode(
QgsGraduatedSymbolRenderer.EqualInterval)
self._renderer.updateClasses(
self, QgsGraduatedSymbolRenderer.EqualInterval,
style['classes'])
self.setRenderer(self._renderer)
self._renderer.updateColorRamp(style['colorramp'])
else:
raise StyleError(self.tr("Undefined style"))
def style(self):
"""Get style.
:return: style class
"""
return self._style
def _attributesCSVFile(self):
return os.path.join(
os.path.dirname(__file__),
os.path.splitext(inspect.getfile(self.__class__))[0] + '.csv')
