def exportImages(layer, field, layerFileName):
field_index = layer.fields().indexFromName(field)
widget = layer.editorWidgetSetup(field_index).type()
if widget != 'Photo':
return
fr = QgsFeatureRequest()
fr.setSubsetOfAttributes([field_index])
for feature in layer.getFeatures(fr):
photo_file_name = feature.attribute(field)
if type(photo_file_name) is not unicode:
continue
source_file_name = photo_file_name
if not os.path.isabs(source_file_name):
prj_fname = QgsProject.instance().fileName()
source_file_name = os.path.join(os.path.dirname(prj_fname),
source_file_name)
photo_file_name = re.sub(r'[\\/:]', '_', photo_file_name).strip()
photo_file_name = os.path.join(os.path.dirname(layerFileName),
'..', 'images', photo_file_name)
try:
shutil.copyfile(source_file_name, photo_file_name)
except IOError as e:
pass
def _getXYvalues(self, ts_layer, dateField, valueField):
# utility function used to get the X and Y values
x, y = [], []
# get indexes of date (x) and value (y) fields
dateIdx, valueIdx = None, None
for idx, fld in enumerate(ts_layer.dataProvider().fields()):
if fld.name().lower() == dateField:
dateIdx = idx
elif fld.name().lower() == valueField:
valueIdx = idx
if dateIdx is None or valueIdx is None:
QgsMessageLog.logMessage("field %s -> index %s, field %s -> index %s. Exiting" % (dateField, dateIdx, valueField, valueIdx), "PSTimeSeriesViewer")
return
# fetch and loop through all the features
request = QgsFeatureRequest()
request.setSubsetOfAttributes([dateIdx, valueIdx])
for f in ts_layer.getFeatures( request ):
# get x and y values
a = f.attributes()
x.append( QDate.fromString( a[ dateIdx ], "yyyyMMdd" ).toPyDate() )
y.append( float(a[ valueIdx ]) )
return x, y
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
field_names = self.parameterAsFields(parameters, self.FIELDS, context)
fields = QgsFields()
field_indices = []
for field_name in field_names:
field_index = source.fields().lookupField(field_name)
if field_index < 0:
feedback.reportError(self.tr('Invalid field name {}').format(field_name))
continue
field = source.fields()[field_index]
fields.append(field)
field_indices.append(field_index)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.NoGeometry, QgsCoordinateReferenceSystem())
results = {}
values = set()
if len(field_indices) == 1:
# one field, can use provider optimised method
values = tuple([v] for v in source.uniqueValues(field_indices[0]))
else:
# have to scan whole table
# TODO - add this support to QgsVectorDataProvider so we can run it on
# the backend
request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes(field_indices)
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(source.getFeatures(request, QgsProcessingFeatureSource.FlagSkipGeometryValidityChecks)):
if feedback.isCanceled():
break
value = tuple(f.attribute(i) for i in field_indices)
values.add(value)
feedback.setProgress(int(current * total))
if sink:
for value in values:
if feedback.isCanceled():
break
f = QgsFeature()
f.setAttributes([attr for attr in value])
sink.addFeature(f, QgsFeatureSink.FastInsert)
results[self.OUTPUT] = dest_id
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT_HTML_FILE, context)
if output_file:
self.createHTML(output_file, values)
results[self.OUTPUT_HTML_FILE] = output_file
results[self.TOTAL_VALUES] = len(values)
results[self.UNIQUE_VALUES] = ';'.join([','.join([str(attr) for attr in v]) for v in
values])
return results
def featureCount(self):
if not self.subsetString():
return len(self._features)
else:
req = QgsFeatureRequest()
req.setFlags(QgsFeatureRequest.NoGeometry)
req.setSubsetOfAttributes([])
return len([f for f in self.getFeatures(req)])
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
radius = self.parameterAsDouble(parameters, self.RADIUS, context)
kernel_shape = self.parameterAsEnum(parameters, self.KERNEL, context)
pixel_size = self.parameterAsDouble(parameters, self.PIXEL_SIZE, context)
decay = self.parameterAsDouble(parameters, self.DECAY, context)
output_values = self.parameterAsEnum(parameters, self.OUTPUT_VALUE, context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
output_format = QgsRasterFileWriter.driverForExtension(os.path.splitext(outputFile)[1])
weight_field = self.parameterAsString(parameters, self.WEIGHT_FIELD, context)
radius_field = self.parameterAsString(parameters, self.RADIUS_FIELD, context)
attrs = []
kde_params = QgsKernelDensityEstimation.Parameters()
kde_params.source = source
kde_params.radius = radius
kde_params.pixelSize = pixel_size
# radius field
if radius_field:
kde_params.radiusField = radius_field
attrs.append(source.fields().lookupField(radius_field))
# weight field
if weight_field:
kde_params.weightField = weight_field
attrs.append(source.fields().lookupField(weight_field))
kde_params.shape = kernel_shape
kde_params.decayRatio = decay
kde_params.outputValues = output_values
kde = QgsKernelDensityEstimation(kde_params, outputFile, output_format)
if kde.prepare() != QgsKernelDensityEstimation.Success:
raise QgsProcessingException(
self.tr('Could not create destination layer'))
request = QgsFeatureRequest()
request.setSubsetOfAttributes(attrs)
features = source.getFeatures(request)
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(features):
if feedback.isCanceled():
break
if kde.addFeature(f) != QgsKernelDensityEstimation.Success:
feedback.reportError(self.tr('Error adding feature with ID {} to heatmap').format(f.id()))
feedback.setProgress(int(current * total))
if kde.finalise() != QgsKernelDensityEstimation.Success:
raise QgsProcessingException(
self.tr('Could not save destination layer'))
return {self.OUTPUT: outputFile}
def uniqueValues(self, fieldIndex, limit=1):
results = set()
if fieldIndex >= 0 and fieldIndex < self.fields().count():
req = QgsFeatureRequest()
req.setFlags(QgsFeatureRequest.NoGeometry)
req.setSubsetOfAttributes([fieldIndex])
for f in self.getFeatures(req):
results.add(f.attributes()[fieldIndex])
return results
def test_sql2(self):
l2 = QgsVectorLayer(os.path.join(self.testDataDir, "france_parts.shp"), "france_parts", "ogr", False)
self.assertEqual(l2.isValid(), True)
QgsProject.instance().addMapLayer(l2)
query = toPercent("SELECT * FROM france_parts")
l4 = QgsVectorLayer("?query=%s&uid=ObjectId" % query, "tt", "virtual")
self.assertEqual(l4.isValid(), True)
self.assertEqual(l4.dataProvider().wkbType(), 3)
self.assertEqual(l4.dataProvider().crs().postgisSrid(), 4326)
n = 0
r = QgsFeatureRequest(QgsRectangle(-1.677, 49.624, -0.816, 49.086))
for f in l4.getFeatures(r):
self.assertEqual(f.geometry() is not None, True)
self.assertEqual(f.attributes()[0], 2661)
n += 1
self.assertEqual(n, 1)
# use uid
query = toPercent("SELECT * FROM france_parts")
l5 = QgsVectorLayer("?query=%s&geometry=geometry:polygon:4326&uid=ObjectId" % query, "tt", "virtual")
self.assertEqual(l5.isValid(), True)
idSum = sum(f.id() for f in l5.getFeatures())
self.assertEqual(idSum, 10659)
r = QgsFeatureRequest(2661)
idSum2 = sum(f.id() for f in l5.getFeatures(r))
self.assertEqual(idSum2, 2661)
r = QgsFeatureRequest()
r.setFilterFids([2661, 2664])
self.assertEqual(sum(f.id() for f in l5.getFeatures(r)), 2661 + 2664)
# test attribute subset
r = QgsFeatureRequest()
r.setFlags(QgsFeatureRequest.SubsetOfAttributes)
r.setSubsetOfAttributes([1])
s = [(f.id(), f.attributes()[1]) for f in l5.getFeatures(r)]
self.assertEqual(sum([x[0] for x in s]), 10659)
self.assertEqual(sum([x[1] for x in s]), 3064.0)
# test NoGeometry
# by request flag
r = QgsFeatureRequest()
r.setFlags(QgsFeatureRequest.NoGeometry)
self.assertEqual(all([not f.hasGeometry() for f in l5.getFeatures(r)]), True)
# test subset
self.assertEqual(l5.dataProvider().featureCount(), 4)
l5.setSubsetString("ObjectId = 2661")
idSum2 = sum(f.id() for f in l5.getFeatures(r))
self.assertEqual(idSum2, 2661)
self.assertEqual(l5.dataProvider().featureCount(), 1)
def spatialindex(layer):
"""Creates a spatial index for the passed vector layer.
"""
request = QgsFeatureRequest()
request.setSubsetOfAttributes([])
if ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED) and layer.selectedFeatureCount() > 0:
idx = QgsSpatialIndex(layer.selectedFeaturesIterator(request))
else:
idx = QgsSpatialIndex(layer.getFeatures(request))
return idx
def selectByAttribute(self, value):
layer = getLayerFromId(self.LOCALITIES_LAYER)
field_index = self.TAXON_FIELD_INDEX
field_name = layer.fields()[int(field_index)].name()
selected = []
filter = QgsExpression.createFieldEqualityExpression(field_name, str(value))
request = QgsFeatureRequest().setFilterExpression(filter)
request.setSubsetOfAttributes([])
for feature in layer.getFeatures(request):
selected.append(feature.id())
layer.selectByIds(selected)
def layerData(self, layer, request={}, offset=0):
# Retrieve the data for a layer
first = True
data = {}
fields = []
fieldTypes = []
fr = QgsFeatureRequest()
if request:
if 'exact' in request and request['exact']:
fr.setFlags(QgsFeatureRequest.ExactIntersect)
if 'nogeom' in request and request['nogeom']:
fr.setFlags(QgsFeatureRequest.NoGeometry)
if 'fid' in request:
fr.setFilterFid(request['fid'])
elif 'extents' in request:
fr.setFilterRect(QgsRectangle(*request['extents']))
if 'attributes' in request:
fr.setSubsetOfAttributes(request['attributes'])
# IMPORTANT - we do not use `for f in layer.getFeatures(fr):` as we need
# to verify that existing attributes and geometry are correctly cleared
# from the feature when calling nextFeature()
it = layer.getFeatures(fr)
f = QgsFeature()
while it.nextFeature(f):
if first:
first = False
for field in f.fields():
fields.append(str(field.name()))
fieldTypes.append(str(field.typeName()))
if sys.version_info.major == 2:
fielddata = dict((name, str(f[name])) for name in fields)
else:
fielddata = dict((name, str(f[name])) for name in fields)
g = f.geometry()
if not g.isEmpty():
fielddata[geomkey] = str(g.exportToWkt())
else:
fielddata[geomkey] = "None"
fielddata[fidkey] = f.id()
id = fielddata[fields[0]]
description = fielddata[fields[1]]
fielddata['id'] = id
fielddata['description'] = description
data[f.id() + offset] = fielddata
if 'id' not in fields:
fields.insert(0, 'id')
if 'description' not in fields:
fields.insert(1, 'description')
fields.append(fidkey)
fields.append(geomkey)
return fields, fieldTypes, data
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
radius = self.getParameterValue(self.RADIUS)
kernel_shape = self.getParameterValue(self.KERNEL)
pixel_size = self.getParameterValue(self.PIXEL_SIZE)
decay = self.getParameterValue(self.DECAY)
output_values = self.getParameterValue(self.OUTPUT_VALUE)
output = self.getOutputValue(self.OUTPUT_LAYER)
output_format = raster.formatShortNameFromFileName(output)
weight_field = self.getParameterValue(self.WEIGHT_FIELD)
radius_field = self.getParameterValue(self.RADIUS_FIELD)
attrs = []
kde_params = QgsKernelDensityEstimation.Parameters()
kde_params.vectorLayer = layer
kde_params.radius = radius
kde_params.pixelSize = pixel_size
# radius field
if radius_field:
kde_params.radiusField = radius_field
attrs.append(layer.fields().lookupField(radius_field))
# weight field
if weight_field:
kde_params.weightField = weight_field
attrs.append(layer.fields().lookupField(weight_field))
kde_params.shape = kernel_shape
kde_params.decayRatio = decay
kde_params.outputValues = output_values
kde = QgsKernelDensityEstimation(kde_params, output, output_format)
if kde.prepare() != QgsKernelDensityEstimation.Success:
raise GeoAlgorithmExecutionException(
self.tr('Could not create destination layer'))
request = QgsFeatureRequest()
request.setSubsetOfAttributes(attrs)
features = vector.features(layer, request)
total = 100.0 / len(features)
for current, f in enumerate(features):
if kde.addFeature(f) != QgsKernelDensityEstimation.Success:
raise GeoAlgorithmExecutionException(
self.tr('Error adding feature to heatmap'))
progress.setPercentage(int(current * total))
if kde.finalise() != QgsKernelDensityEstimation.Success:
raise GeoAlgorithmExecutionException(
self.tr('Could not save destination layer'))
def search(self):
project = QgsProject.instance()
layerId, ok = project.readEntry(self.pluginName, 'layerId')
fieldName, ok = project.readEntry(self.pluginName, 'fieldName')
pattern = self.searchText.text()
self.layer = QgsMapLayerRegistry.instance().mapLayer(layerId)
if self.layer is None:
self.iface.messageBar().pushMessage(self.name,
self.tr("Choose a layer first in settings dialog."),
QgsMessageBar.WARNING, 3)
self.showSettings()
return
if fieldName == "":
self.iface.messageBar().pushMessage(self.name,
self.tr("Choose a field first in settings dialog."),
QgsMessageBar.WARNING, 3)
self.showSettings()
return
fields = self.layer.dataProvider().fields()
fieldIndex = fields.indexFromName(fieldName)
# create feature request
featReq = QgsFeatureRequest()
featReq.setFlags(QgsFeatureRequest.NoGeometry)
featReq.setSubsetOfAttributes([fieldIndex])
iterator = self.layer.getFeatures(featReq)
# process search
f = QgsFeature()
results = []
self.continueSearch = True
while iterator.nextFeature(f) and self.continueSearch:
if self.evaluate(f[fieldName], pattern):
results.append(f.id())
QCoreApplication.processEvents()
# process results
if self.continueSearch:
msg = self.tr("{} features found").format(len(results))
legend = self.iface.legendInterface()
if (not legend.isLayerVisible(self.layer)):
msg += self.tr(' - The layer named {} is not visible').format(self.layer.name())
self.iface.messageBar().pushMessage(self.name,
msg,
QgsMessageBar.INFO, 2)
self.processResults(results)
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)
radius = self.getParameterValue(self.RADIUS)
kernel_shape = self.getParameterValue(self.KERNEL)
pixel_size = self.getParameterValue(self.PIXEL_SIZE)
decay = self.getParameterValue(self.DECAY)
output_values = self.getParameterValue(self.OUTPUT_VALUE)
output = self.getOutputValue(self.OUTPUT_LAYER)
output_format = raster.formatShortNameFromFileName(output)
weight_field = self.getParameterValue(self.WEIGHT_FIELD)
radius_field = self.getParameterValue(self.RADIUS_FIELD)
attrs = []
kde_params = QgsKernelDensityEstimation.Parameters()
kde_params.vectorLayer = layer
kde_params.radius = radius
kde_params.pixelSize = pixel_size
# radius field
if radius_field:
kde_params.radiusField = radius_field
attrs.append(layer.fields().lookupField(radius_field))
# weight field
if weight_field:
kde_params.weightField = weight_field
attrs.append(layer.fields().lookupField(weight_field))
kde_params.shape = kernel_shape
kde_params.decayRatio = decay
kde_params.outputValues = output_values
kde = QgsKernelDensityEstimation(kde_params, output, output_format)
if kde.prepare() != QgsKernelDensityEstimation.Success:
raise GeoAlgorithmExecutionException(
self.tr('Could not create destination layer'))
request = QgsFeatureRequest()
request.setSubsetOfAttributes(attrs)
features = QgsProcessingUtils.getFeatures(layer, context, request)
total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
for current, f in enumerate(features):
if kde.addFeature(f) != QgsKernelDensityEstimation.Success:
QgsMessageLog.logMessage(self.tr('Error adding feature with ID {} to heatmap').format(f.id()), self.tr('Processing'), QgsMessageLog.CRITICAL)
feedback.setProgress(int(current * total))
if kde.finalise() != QgsKernelDensityEstimation.Success:
raise GeoAlgorithmExecutionException(
self.tr('Could not save destination layer'))
def layerData(layer, request={}, offset=0):
first = True
data = {}
fields = []
fieldTypes = []
fr = QgsFeatureRequest()
if request:
if 'exact' in request and request['exact']:
fr.setFlags(QgsFeatureRequest.ExactIntersect)
if 'nogeom' in request and request['nogeom']:
fr.setFlags(QgsFeatureRequest.NoGeometry)
if 'fid' in request:
fr.setFilterFid(request['fid'])
elif 'extents' in request:
fr.setFilterRect(QgsRectangle(*request['extents']))
if 'attributes' in request:
fr.setSubsetOfAttributes(request['attributes'])
for f in layer.getFeatures(fr):
if first:
first = False
for field in f.fields():
fields.append(str(field.name()))
fieldTypes.append(str(field.typeName()))
fielddata = dict((name, unicode(f[name])) for name in fields)
g = f.geometry()
if g:
fielddata[geomkey] = str(g.exportToWkt())
else:
fielddata[geomkey] = "None"
fielddata[fidkey] = f.id()
id = fielddata[fields[0]]
description = fielddata[fields[1]]
fielddata['id'] = id
fielddata['description'] = description
data[f.id() + offset] = fielddata
if 'id' not in fields:
fields.insert(0, 'id')
if 'description' not in fields:
fields.insert(1, 'description')
fields.append(fidkey)
fields.append(geomkey)
return fields, fieldTypes, data
def __retrieve_map_avail_feats(self):
qstring = self.prefs.ORBIT['MARSIS']+' = '+ str(self.id)
req=QgsFeatureRequest().setFilterExpression(qstring)
req.setSubsetOfAttributes([self.layer.fieldNameIndex(self.prefs.ORBIT['MARSIS']), self.layer.fieldNameIndex('point_id')])
fit=self.layer.getFeatures(req)
feats=[ f for f in fit ]
feats.sort(key=lambda x: x.attribute('point_id'), reverse=False)
ii = 0
self.map_avail_ids = []
self.map_avail_feats = []
self.map_avail_feats_d = {}
for f in feats:
self.map_avail_feats.append(f.id())
self.map_avail_ids.append(f.attribute('point_id'))
self.map_avail_feats_d[f.attribute('point_id')] = ii
self.add_feature_point(f)
ii = ii + 1
def read(self, feature_type, bbox = None, attributes = None, geometry=True, feature_filter=None):
if not isinstance(feature_type, FeatureType):
raise TypeError()
lyr = self._connectlayer(feature_type)
request = None
if bbox or attributes is not None or not geometry or feature_filter:
request = QgsFeatureRequest()
if bbox:
rect = QgsRectangle(*bbox)
request.setFilterRect(rect)
if attributes:
request.setSubsetOfAttributes(attributes, lyr.pendingFields())
if not geometry:
request.setFlags(QgsFeatureRequest.NoGeometry)
if feature_filter:
request.setFilterExpression(feature_filter)
#lyr.setSubsetString(feature_filter)
# return listoffeatures
# filter is maybe a QgsFeatureRequest
# http://docs.qgis.org/testing/en/docs/pyqgis_developer_cookbook/vector.html#iterating-over-a-subset-of-features
return list(lyr.getFeatures(request) if request else lyr.getFeatures())
def searchFieldInLayer(self, layer, searchStr, comparisonMode, selectedField):
'''Do a string search on a specific column in the table.'''
if self.killed:
return
request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes([selectedField], layer.fields())
if comparisonMode == 0: # Searching for an exact match
request.setFilterExpression('"{}" LIKE \'{}\''.format(selectedField,searchStr))
elif comparisonMode == 1: # contains string
request.setFilterExpression('"{}" ILIKE \'%{}%\''.format(selectedField,searchStr))
else: # begins with string
request.setFilterExpression('"{}" ILIKE \'{}%\''.format(selectedField,searchStr))
for feature in layer.getFeatures(request):
# Check to see if it has been aborted
if self.killed is True:
return
f = feature.attribute(selectedField)
self.foundmatch.emit(layer, feature, selectedField, str(f))
self.found += 1
if self.found >= self.maxResults:
self.killed=True
return
def processAlgorithm(self, progress):
fileName = self.getParameterValue(self.INPUT)
layer = dataobjects.getObjectFromUri(fileName)
fieldName = self.getParameterValue(self.FIELD)
value = self.getParameterValue(self.VALUE)
selected = layer.selectedFeaturesIds()
if len(selected) == 0:
GeoAlgorithmExecutionException(
self.tr('There is no selection in the input layer. '
'Select one feature and try again.'))
ft = layer.selectedFeatures()[0]
geom = ft.geometry()
attrSum = ft[fieldName]
idx = QgsSpatialIndex(layer.getFeatures(QgsFeatureRequest.setSubsetOfAttributes([])))
req = QgsFeatureRequest()
completed = False
while not completed:
intersected = idx.intersects(geom.boundingBox())
if len(intersected) < 0:
progress.setInfo(self.tr('No adjacent features found.'))
break
req = QgsFeatureRequest().setFilterFids(intersected).setSubsetOfAttributes([fieldName], layer.fields())
for ft in layer.getFeatures(req):
tmpGeom = ft.geometry()
if tmpGeom.touches(geom):
geom = tmpGeom.combine(geom)
selected.append(i)
attrSum += ft[fieldName]
if attrSum >= value:
completed = True
break
layer.selectByIds(selected)
self.setOutputValue(self.OUTPUT, fileName)
def _polygonsToKml(self):
settings = QgsSettings()
altitude = settings.value('getools/polygonAltitude', 0.0, float)
extrude = settings.value('getools/polygonExtrude', False, bool)
tessellate = settings.value('getools/polygonTessellate', False, bool)
altitudeMode = settings.value('getools/polygonAltitudeMode',
'clampToGround', str)
name = settings.value('getools/plygonName', '', str)
description = settings.value('getools/polygonDescription', '', str)
fields = self.data.fields()
idxName = fields.indexFromName(name)
idxDescription = fields.indexFromName(description)
overrideStyle = settings.value(
'QgsCollapsibleGroupBox/getools/grpPolygonStyle/checked', False,
bool)
if overrideStyle:
styleMap, style = defaultStyle(self.data)
else:
styleMap, style = kmlStyle(self.data)
if styleMap is None:
self.error = style
return False
layerName = utils.encodeForXml(self.data.name())
kmlFile = utils.tempFileName('{}.kml'.format(
utils.safeLayerName(self.data.name())))
with open(kmlFile, 'w', encoding='utf-8') as f:
f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
f.write(
'<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2">\n'
)
f.write(' <Document>\n')
f.write(' <name>{}</name>\n'.format(layerName))
f.write(' <description>QGIS vector — {}</description>\n'.format(
layerName))
f.write('{}\n'.format(style))
request = QgsFeatureRequest()
request.setDestinationCrs(GEO_CRS,
QgsProject.instance().transformContext())
if self.onlySelected:
request.setFilterFids(self.data.selectedFeatureIds())
attrs = []
if idxName != -1:
attrs.append(idxName)
if idxDescription != -1:
attrs.append(idxDescription)
if len(attrs) > 0:
request.setSubsetOfAttributes(attrs)
for styleId, expression in styleMap.items():
if expression != 'all':
request.setFilterExpression(expression)
for feat in self.data.getFeatures(request):
geom = feat.geometry()
parts = geom.asGeometryCollection()
f.write(' <Placemark>\n')
if idxName != -1:
f.write(' <name>{}</name>\n'.format(feat[name]))
if idxDescription != -1:
f.write(' <description>{}</description>\n'.format(
feat[description]))
f.write(' <styleUrl>#{}</styleUrl>\n'.format(styleId))
geometry = []
for part in parts:
geometry.append(' <Polygon>\n')
geometry.append(
' <extrude>{}</extrude>\n'.format(extrude))
geometry.append(
' <tessellate>{}</tessellate>\n'.format(
tessellate))
geometry.append(
' <gx:altitudeMode>{}</gx:altitudeMode>\n'.
format(altitudeMode))
geometry.append(' <outerBoundaryIs>\n')
geometry.append(' <LinearRing>\n')
geometry.append(' <coordinates>\n')
polygon = part.constGet()
ring = polygon.exteriorRing()
for p in ring.points():
geometry.append(' {},{},{}\n'.format(
p.x(), p.y(),
p.z() if p.is3D() else altitude))
geometry.append(' </coordinates>\n')
geometry.append(' </LinearRing>\n')
geometry.append(' </outerBoundaryIs>\n')
for i in range(polygon.numInteriorRings()):
ring = polygon.interiorRing(i)
geometry.append(' <innerBoundaryIs>\n')
geometry.append(' <LinearRing>\n')
geometry.append(' <coordinates>\n')
for p in ring.points():
geometry.append(' {},{},{}\n'.format(
p.x(), p.y(),
p.z() if p.is3D() else altitude))
geometry.append(' </coordinates>\n')
geometry.append(' </LinearRing>\n')
geometry.append(' </innerBoundaryIs>\n')
geometry.append(' </Polygon>\n')
if geom.isMultipart():
f.write(' <MultiGeometry>\n')
f.write(''.join(geometry))
f.write(' </MultiGeometry>\n')
else:
f.write(''.join(geometry))
f.write(' </Placemark>\n')
f.write(' </Document>\n')
f.write('</kml>\n')
self.fileName = os.path.normpath(kmlFile)
return True
def processAlgorithm(self, parameters, context, feedback):
sourceA = self.parameterAsSource(parameters, self.INPUT, context)
sourceB = self.parameterAsSource(parameters, self.OVERLAY, context)
geomType = QgsWkbTypes.multiType(sourceA.wkbType())
fieldsA = self.parameterAsFields(parameters, self.INPUT_FIELDS, context)
fieldsB = self.parameterAsFields(parameters, self.OVERLAY_FIELDS, context)
fieldListA = QgsFields()
field_indices_a = []
if len(fieldsA) > 0:
for f in fieldsA:
idxA = sourceA.fields().lookupField(f)
if idxA >= 0:
field_indices_a.append(idxA)
fieldListA.append(sourceA.fields()[idxA])
else:
fieldListA = sourceA.fields()
field_indices_a = [i for i in range(0, fieldListA.count())]
fieldListB = QgsFields()
field_indices_b = []
if len(fieldsB) > 0:
for f in fieldsB:
idxB = sourceB.fields().lookupField(f)
if idxB >= 0:
field_indices_b.append(idxB)
fieldListB.append(sourceB.fields()[idxB])
else:
fieldListB = sourceB.fields()
field_indices_b = [i for i in range(0, fieldListB.count())]
fieldListB = vector.testForUniqueness(fieldListA, fieldListB)
for b in fieldListB:
fieldListA.append(b)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fieldListA, geomType, sourceA.sourceCrs())
outFeat = QgsFeature()
indexB = QgsSpatialIndex(sourceB.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([]).setDestinationCrs(sourceA.sourceCrs())), feedback)
total = 100.0 / sourceA.featureCount() if sourceA.featureCount() else 1
count = 0
for featA in sourceA.getFeatures(QgsFeatureRequest().setSubsetOfAttributes(field_indices_a)):
if feedback.isCanceled():
break
if not featA.hasGeometry():
continue
geom = featA.geometry()
atMapA = featA.attributes()
intersects = indexB.intersects(geom.boundingBox())
request = QgsFeatureRequest().setFilterFids(intersects)
request.setDestinationCrs(sourceA.sourceCrs())
request.setSubsetOfAttributes(field_indices_b)
engine = None
if len(intersects) > 0:
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(geom.geometry())
engine.prepareGeometry()
for featB in sourceB.getFeatures(request):
if feedback.isCanceled():
break
tmpGeom = featB.geometry()
if engine.intersects(tmpGeom.geometry()):
out_attributes = [featA.attributes()[i] for i in field_indices_a]
out_attributes.extend([featB.attributes()[i] for i in field_indices_b])
int_geom = QgsGeometry(geom.intersection(tmpGeom))
if int_geom.wkbType() == QgsWkbTypes.Unknown or QgsWkbTypes.flatType(int_geom.geometry().wkbType()) == QgsWkbTypes.GeometryCollection:
int_com = geom.combine(tmpGeom)
int_geom = QgsGeometry()
if int_com:
int_sym = geom.symDifference(tmpGeom)
int_geom = QgsGeometry(int_com.difference(int_sym))
if int_geom.isEmpty() or not int_geom.isGeosValid():
raise QgsProcessingException(
self.tr('GEOS geoprocessing error: One or '
'more input features have invalid '
'geometry.'))
try:
if int_geom.wkbType() in wkbTypeGroups[wkbTypeGroups[int_geom.wkbType()]]:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(out_attributes)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
raise QgsProcessingException(
self.tr('Feature geometry error: One or more '
'output features ignored due to invalid '
'geometry.'))
count += 1
feedback.setProgress(int(count * total))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
t_troncon = self.parameterAsSource(parameters, self.SEGMENTS_TABLE,
context)
g_troncon = self.parameterAsSource(parameters, self.GEOM_SEGMENTS,
context)
t_obs = self.parameterAsSource(parameters, self.OBSERVATION_TABLE,
context)
g_obs = self.parameterAsVectorLayer(parameters, self.GEOM_OBSERVATION,
context)
# Get troncon ids and file ids
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project()))
exp_context.appendScope(t_troncon.createExpressionContextScope())
exp_str = '"id_geom_troncon" IS NOT NULL'
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression %s has eval error: %s').format(
exp.expression(), exp.evalErrorString()))
request = QgsFeatureRequest(exp, exp_context)
request.setSubsetOfAttributes(
['id', 'aab', 'aad', 'aaf', 'abq', 'id_file', 'id_geom_troncon'],
t_troncon.fields())
has_geo_troncon = False
troncons = {}
file_ids = []
for tro in t_troncon.getFeatures(request):
troncons[tro['id']] = tro
file_ids.append(tro['id_file'])
has_geo_troncon = True
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
if not has_geo_troncon:
raise QgsProcessingException(tr('* ERROR: No troncon geometries'))
# Get observation ids
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project()))
exp_context.appendScope(t_obs.createExpressionContextScope())
exp_str = ('"id_troncon" IN ({}) AND '
'"id_file" IN ({})').format(
','.join([str(i) for i in troncons.keys()]),
','.join([str(i) for i in file_ids]))
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression {} has eval error: {}').format(
exp.expression(), exp.evalErrorString()))
obs_ids = []
request = QgsFeatureRequest(exp, exp_context)
for obs in t_obs.getFeatures(request):
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
troncon = troncons[obs['id_troncon']]
# verifying ITV file
if troncon['id_file'] != obs['id_file']:
continue
obs_ids.append(obs['id'])
if not obs_ids:
raise QgsProcessingException(
tr('* ERROR: No observations to geolocalize found'))
# Check observations already geolocalised on troncon
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project()))
exp_context.appendScope(QgsExpressionContextUtils.layerScope(g_obs))
exp_str = '"id" IN ({})'.format(','.join([str(i) for i in obs_ids]))
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression {} has eval error: {}').format(
exp.expression(), exp.evalErrorString()))
request = QgsFeatureRequest(exp, exp_context)
geo_observations = []
for obs in g_obs.getFeatures(request):
geo_observations.append(obs['id'])
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
# build observation geometry based on table
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(
QgsExpressionContextUtils.projectScope(context.project()))
exp_context.appendScope(t_obs.createExpressionContextScope())
exp_str = ('"id_troncon" IN ({}) AND '
'"id_file" IN ({})').format(
','.join([str(i) for i in troncons.keys()]),
','.join([str(i) for i in file_ids]))
if geo_observations:
exp_str += ' AND id NOT IN ({})'.format(','.join(
[str(i) for i in geo_observations]))
exp = QgsExpression(exp_str)
exp.prepare(exp_context)
if exp.hasEvalError():
raise QgsProcessingException(
tr('* ERROR: Expression {} has eval error: {}').format(
exp.expression(), exp.evalErrorString()))
request = QgsFeatureRequest(exp, exp_context)
features = []
fields = provider_fields(g_obs.fields())
for obs in t_obs.getFeatures(request):
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
troncon = troncons[obs['id_troncon']]
# verifying ITV file
if troncon['id_file'] != obs['id_file']:
continue
geo_req = QgsFeatureRequest()
geo_req.setFilterFid(troncon['id_geom_troncon'])
for g_tro in g_troncon.getFeatures(geo_req):
# Stop the algorithm if cancel button has been clicked
if feedback.isCanceled():
return {self.OBSERVATIONS_CREATED: None}
geom = g_tro.geometry()
pt = None
if troncon['aab'] == troncon['aad']:
pt = geom.interpolate(geom.length() * obs['i'] /
troncon['abq'])
else:
pt = geom.interpolate(geom.length() *
(1 - obs['i'] / troncon['abq']))
fet = QgsFeature(fields)
fet.setGeometry(pt)
fet.setAttribute('id', obs['id'])
features.append(fet)
# Ajout des objets observations
if features:
g_obs.startEditing()
(res, outFeats) = g_obs.dataProvider().addFeatures(features)
if not res or not outFeats:
raise QgsProcessingException(
tr('* ERREUR: lors de l\'enregistrement '
'des regards {}').format(', '.join(
g_obs.dataProvider().errors())))
if not g_obs.commitChanges():
raise QgsProcessingException(
tr('* ERROR: Commit {}.').format(g_obs.commitErrors()))
# Returns empty dict if no outputs
return {self.OBSERVATIONS_CREATED: len(features)}
def execute_in_place_run(alg, active_layer, parameters, context=None, feedback=None, raise_exceptions=False):
"""Executes an algorithm modifying features in-place in the input layer.
The input layer must be editable or an exception is raised.
:param alg: algorithm to run
:type alg: QgsProcessingAlgorithm
:param active_layer: the editable layer
:type active_layer: QgsVectoLayer
:param parameters: parameters of the algorithm
:type parameters: dict
:param context: context, defaults to None
:param context: QgsProcessingContext, optional
:param feedback: feedback, defaults to None
:param feedback: QgsProcessingFeedback, optional
:raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project
:return: a tuple with true if success and results
:rtype: tuple
"""
if feedback is None:
feedback = QgsProcessingFeedback()
if context is None:
context = dataobjects.createContext(feedback)
if active_layer is None or not active_layer.isEditable():
raise QgsProcessingException(tr("Layer is not editable or layer is None."))
if not alg.supportInPlaceEdit(active_layer):
raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
parameters['OUTPUT'] = 'memory:'
try:
new_feature_ids = []
active_layer.beginEditCommand(alg.displayName())
req = QgsFeatureRequest(QgsExpression(r"$id < 0"))
req.setFlags(QgsFeatureRequest.NoGeometry)
req.setSubsetOfAttributes([])
# Checks whether the algorithm has a processFeature method
if hasattr(alg, 'processFeature'): # in-place feature editing
# Make a clone or it will crash the second time the dialog
# is opened and run
alg = alg.create()
if not alg.prepare(parameters, context, feedback):
raise QgsProcessingException(tr("Could not prepare selected algorithm."))
# Check again for compatibility after prepare
if not alg.supportInPlaceEdit(active_layer):
raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
field_idxs = range(len(active_layer.fields()))
feature_iterator = active_layer.getFeatures(QgsFeatureRequest(active_layer.selectedFeatureIds())) if parameters['INPUT'].selectedFeaturesOnly else active_layer.getFeatures()
for f in feature_iterator:
# need a deep copy, because python processFeature implementations may return
# a shallow copy from processFeature
input_feature = QgsFeature(f)
new_features = alg.processFeature(input_feature, context, feedback)
new_features = QgsVectorLayerUtils.makeFeaturesCompatible(new_features, active_layer)
if len(new_features) == 0:
active_layer.deleteFeature(f.id())
elif len(new_features) == 1:
new_f = new_features[0]
if not f.geometry().equals(new_f.geometry()):
active_layer.changeGeometry(f.id(), new_f.geometry())
if f.attributes() != new_f.attributes():
active_layer.changeAttributeValues(f.id(), dict(zip(field_idxs, new_f.attributes())), dict(zip(field_idxs, f.attributes())))
new_feature_ids.append(f.id())
else:
active_layer.deleteFeature(f.id())
# Get the new ids
old_ids = set([f.id() for f in active_layer.getFeatures(req)])
if not active_layer.addFeatures(new_features):
raise QgsProcessingException(tr("Error adding processed features back into the layer."))
new_ids = set([f.id() for f in active_layer.getFeatures(req)])
new_feature_ids += list(new_ids - old_ids)
results, ok = {}, True
else: # Traditional 'run' with delete and add features cycle
results, ok = alg.run(parameters, context, feedback)
if ok:
result_layer = QgsProcessingUtils.mapLayerFromString(results['OUTPUT'], context)
# TODO: check if features have changed before delete/add cycle
active_layer.deleteFeatures(active_layer.selectedFeatureIds())
new_features = []
for f in result_layer.getFeatures():
new_features.extend(QgsVectorLayerUtils.
makeFeaturesCompatible([f], active_layer))
# Get the new ids
old_ids = set([f.id() for f in active_layer.getFeatures(req)])
if not active_layer.addFeatures(new_features):
raise QgsProcessingException(tr("Error adding processed features back into the layer."))
new_ids = set([f.id() for f in active_layer.getFeatures(req)])
new_feature_ids += list(new_ids - old_ids)
active_layer.endEditCommand()
if ok and new_feature_ids:
active_layer.selectByIds(new_feature_ids)
elif not ok:
active_layer.rollBack()
return ok, results
except QgsProcessingException as e:
active_layer.endEditCommand()
active_layer.rollBack()
if raise_exceptions:
raise e
QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical)
if feedback is not None:
feedback.reportError(getattr(e, 'msg', str(e)))
return False, {}
def processAlgorithm(self, parameters, context, feedback):
input_layer = self.parameterAsVectorLayer(parameters, self.INPUT_LAYER, context)
facies_field = self.parameterAsExpression(parameters, self.FACIES_FIELD, context)
name_field = self.parameterAsExpression(parameters, self.NAME_FIELD, context)
self._output_layer = self.parameterAsVectorLayer(parameters, self.OUTPUT_LAYER, context)
params = {
'INPUT': input_layer,
'DISTANCE': 0,
'OUTPUT': 'TEMPORARY_OUTPUT'
}
results = processing.run(
"native:buffer",
params,
context=context,
feedback=feedback,
is_child_algorithm=True)
params = {
'INPUT': results['OUTPUT'],
'FIELD': [name_field, facies_field],
'OUTPUT': 'TEMPORARY_OUTPUT'
}
results = processing.run(
"native:collect",
params,
context=context,
feedback=feedback,
is_child_algorithm=True,
)
params = {
'INPUT': results['OUTPUT'],
'OUTPUT': 'TEMPORARY_OUTPUT'
}
results = processing.run(
"native:promotetomulti",
params,
context=context,
feedback=feedback,
is_child_algorithm=True,
)
if input_layer.crs() != self.output_layer.crs():
feedback.pushInfo(
'Le CRS de la couche de destination est différent. Reprojection en {}…'.format(
self.output_layer.crs().authid()))
params = {
'INPUT': results['OUTPUT'],
'TARGET_CRS': self.output_layer.crs(),
'OUTPUT': 'TEMPORARY_OUTPUT'
}
results = processing.run(
"native:reprojectlayer",
params,
context=context,
feedback=feedback,
is_child_algorithm=True)
params = {
'INPUT': results['OUTPUT'],
'DISTANCE': 0,
'OUTPUT': 'memory:'
}
results = processing.run(
"native:buffer",
params,
context=context,
feedback=feedback,
is_child_algorithm=True)
layer = QgsProcessingUtils.mapLayerFromString(results['OUTPUT'], context, True)
self.output_layer.startEditing()
request = QgsFeatureRequest()
request.setSubsetOfAttributes([name_field, facies_field], input_layer.fields())
for input_feature in layer.getFeatures(request):
if feedback.isCanceled():
break
output_feature = QgsFeature(self.output_layer.fields())
geometry = QgsGeometry(input_feature.geometry())
output_feature.setGeometry(geometry)
output_feature.setAttribute('nom', input_feature[name_field])
output_feature.setAttribute('facies', input_feature[facies_field])
self.output_layer.addFeature(output_feature)
self.output_layer.commitChanges()
self.set_style()
return {}
def qgisTestUnlinks(self):
# this function checks the validity of unlinks using QGIS
start_time = time.time()
lfh.addFields(self.unlinks_layer, ['line1', 'line2'],
[QVariant.LongLong, QVariant.LongLong])
line1 = lfh.getFieldIndex(self.unlinks_layer, 'line1')
line2 = lfh.getFieldIndex(self.unlinks_layer, 'line2')
# unlinksindex = createIndex(self.unlinks_layer)
axialindex = lfh.createIndex(self.axial_layer)
print("Preparing the map: %s" % str(time.time() - start_time))
# prepare unlinks to test
self.verificationProgress.emit(5)
threshold = self.verification_settings['unlink_dist']
chunk = 100.0 / float(self.unlinks_layer.featureCount())
steps = chunk / 6.0
progress = 0.0
if self.user_id == '':
features = self.unlinks_layer.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes([line1, line2]))
else:
field = lfh.getFieldIndex(self.unlinks_layer, self.user_id)
features = self.unlinks_layer.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes(
[field, line1, line2]))
# run unlinks tests
for feature in features:
has_problem = False
geom = feature.geometry()
id1 = feature.attribute('line1')
id2 = feature.attribute('line2')
if self.user_id == '':
id = feature.id()
else:
id = feature.attribute(self.user_id)
# geometry is valid (generally)
if not geom.isGeosValid() or geom.isEmpty():
has_problem = True
self.axial_errors['invalid geometry'].append(id)
progress += steps
self.verificationProgress.emit(progress)
# no line id
if id1 is NULL or id2 is NULL:
has_problem = True
self.unlink_errors['no line id'].append(id)
progress += steps
self.verificationProgress.emit(progress)
# same line id
if id1 == id2 and id1 is not NULL:
has_problem = True
self.unlink_errors['same line id'].append(id)
progress += steps
self.verificationProgress.emit(progress)
# duplicate geometry with other unlinks
if self.user_id == '':
request = QgsFeatureRequest().setSubsetOfAttributes([])
else:
field = lfh.getFieldIndex(self.unlinks_layer, self.user_id)
request = QgsFeatureRequest().setSubsetOfAttributes([field])
targets = self.unlinks_layer.getFeatures(request)
for target in targets:
if self.user_id == '':
tid = target.id()
else:
tid = target.attribute(self.user_id)
if tid != id and geom.isGeosEqual(target.geometry()):
has_problem = True
self.unlink_errors['duplicate geometry'].append(id)
progress += steps
self.verificationProgress.emit(progress)
# get intersection results
if self.unlink_type == QgsWkbTypes.PointGeometry and threshold > 0:
buff = geom.buffer(threshold, 4)
else:
buff = geom
box = buff.boundingBox()
request = QgsFeatureRequest()
if axialindex:
# should be faster to retrieve from index (if available)
ints = axialindex.intersects(box)
request.setFilterFids(ints)
else:
# can retrieve objects using bounding box
request.setFilterRect(box)
if self.axial_id == '':
request.setSubsetOfAttributes([])
else:
field = lfh.getFieldIndex(self.axial_layer, self.axial_id)
request.setSubsetOfAttributes([field])
axiallines = self.axial_layer.getFeatures(request)
intersects = []
for line in axiallines:
if self.axial_id == '':
id_b = line.id()
else:
id_b = line.attribute(self.axial_id)
if line.geometry().intersects(buff):
intersects.append(id_b)
# 'unmatched line id'
if id_b != id1 and id_b != id2:
has_problem = True
self.unlink_errors['unmatched line id'].append(id)
progress += steps
self.verificationProgress.emit(progress)
# 'multiple lines'
if len(intersects) > 2:
has_problem = True
self.unlink_errors['multiple lines'].append(id)
# 'single line'
elif len(intersects) == 1:
has_problem = True
self.unlink_errors['single line'].append(id)
# 'no lines'
elif len(intersects) == 0:
has_problem = True
self.unlink_errors['no lines'].append(id)
progress += steps
self.verificationProgress.emit(progress)
if has_problem:
self.problem_nodes.append((id, id1, id2))
def fetch_values_from_layer(self): # pylint: disable=too-many-locals, too-many-branches, too-many-statements
"""
(Re)fetches plot values from the source layer.
"""
# Note: we keep things nice and efficient and only iterate a single time over the layer!
if not self.context_generator:
context = QgsExpressionContext()
context.appendScopes(
QgsExpressionContextUtils.globalProjectLayerScopes(
self.source_layer))
else:
context = self.context_generator.createExpressionContext()
# add a new scope corresponding to the source layer -- this will potentially overwrite any other
# layer scopes which may be present in the context (e.g. from atlas layers), but we need to ensure
# that source layer fields and attributes are present in the context
context.appendScope(
self.source_layer.createExpressionContextScope())
self.settings.data_defined_properties.prepare(context)
self.fetch_layout_properties(context)
def add_source_field_or_expression(field_or_expression):
field_index = self.source_layer.fields().lookupField(
field_or_expression)
if field_index == -1:
expression = QgsExpression(field_or_expression)
if not expression.hasParserError():
expression.prepare(context)
return expression, expression.needsGeometry(
), expression.referencedColumns()
return None, False, {field_or_expression}
x_expression, x_needs_geom, x_attrs = add_source_field_or_expression(self.settings.properties['x_name']) if \
self.settings.properties[
'x_name'] else (None, False, set())
y_expression, y_needs_geom, y_attrs = add_source_field_or_expression(self.settings.properties['y_name']) if \
self.settings.properties[
'y_name'] else (None, False, set())
z_expression, z_needs_geom, z_attrs = add_source_field_or_expression(self.settings.properties['z_name']) if \
self.settings.properties[
'z_name'] else (None, False, set())
additional_info_expression, additional_needs_geom, additional_attrs = add_source_field_or_expression(
self.settings.layout['additional_info_expression']
) if self.settings.layout['additional_info_expression'] else (None,
False,
set())
attrs = set().union(
self.settings.data_defined_properties.referencedFields(), x_attrs,
y_attrs, z_attrs, additional_attrs)
request = QgsFeatureRequest()
if self.settings.data_defined_properties.property(
PlotSettings.PROPERTY_FILTER).isActive():
expression = self.settings.data_defined_properties.property(
PlotSettings.PROPERTY_FILTER).asExpression()
request.setFilterExpression(expression)
request.setExpressionContext(context)
request.setSubsetOfAttributes(attrs, self.source_layer.fields())
if not x_needs_geom and not y_needs_geom and not z_needs_geom and not additional_needs_geom and not self.settings.data_defined_properties.hasActiveProperties(
):
request.setFlags(QgsFeatureRequest.NoGeometry)
visible_geom_engine = None
if self.settings.properties.get(
'visible_features_only',
False) and self.visible_region is not None:
ct = QgsCoordinateTransform(
self.visible_region.crs(), self.source_layer.crs(),
QgsProject.instance().transformContext())
try:
rect = ct.transformBoundingBox(self.visible_region)
request.setFilterRect(rect)
except QgsCsException:
pass
elif self.settings.properties.get(
'visible_features_only',
False) and self.polygon_filter is not None:
ct = QgsCoordinateTransform(
self.polygon_filter.crs(), self.source_layer.crs(),
QgsProject.instance().transformContext())
try:
rect = ct.transformBoundingBox(
self.polygon_filter.geometry.boundingBox())
request.setFilterRect(rect)
g = self.polygon_filter.geometry
g.transform(ct)
visible_geom_engine = QgsGeometry.createGeometryEngine(
g.constGet())
visible_geom_engine.prepareGeometry()
except QgsCsException:
pass
if self.selected_features_only:
it = self.source_layer.getSelectedFeatures(request)
else:
it = self.source_layer.getFeatures(request)
# Some plot types don't draw individual glyphs for each feature, but aggregate them instead.
# In that case it doesn't make sense to evaluate expressions for settings like marker size or color for each
# feature. Instead, the evaluation should be executed only once for these settings.
aggregating = self.settings.plot_type in ['box', 'histogram']
executed = False
xx = []
yy = []
zz = []
additional_hover_text = []
marker_sizes = []
colors = []
stroke_colors = []
stroke_widths = []
for f in it:
if visible_geom_engine and not visible_geom_engine.intersects(
f.geometry().constGet()):
continue
self.settings.feature_ids.append(f.id())
context.setFeature(f)
x = None
if x_expression:
x = x_expression.evaluate(context)
if x == NULL or x is None:
continue
elif self.settings.properties['x_name']:
x = f[self.settings.properties['x_name']]
if x == NULL or x is None:
continue
y = None
if y_expression:
y = y_expression.evaluate(context)
if y == NULL or y is None:
continue
elif self.settings.properties['y_name']:
y = f[self.settings.properties['y_name']]
if y == NULL or y is None:
continue
z = None
if z_expression:
z = z_expression.evaluate(context)
if z == NULL or z is None:
continue
elif self.settings.properties['z_name']:
z = f[self.settings.properties['z_name']]
if z == NULL or z is None:
continue
if additional_info_expression:
additional_hover_text.append(
additional_info_expression.evaluate(context))
elif self.settings.layout['additional_info_expression']:
additional_hover_text.append(
f[self.settings.layout['additional_info_expression']])
if x is not None:
xx.append(x)
if y is not None:
yy.append(y)
if z is not None:
zz.append(z)
if self.settings.data_defined_properties.isActive(
PlotSettings.PROPERTY_MARKER_SIZE):
default_value = self.settings.properties['marker_size']
context.setOriginalValueVariable(default_value)
value, _ = self.settings.data_defined_properties.valueAsDouble(
PlotSettings.PROPERTY_MARKER_SIZE, context, default_value)
marker_sizes.append(value)
if self.settings.data_defined_properties.isActive(
PlotSettings.PROPERTY_STROKE_WIDTH):
default_value = self.settings.properties['marker_width']
context.setOriginalValueVariable(default_value)
value, _ = self.settings.data_defined_properties.valueAsDouble(
PlotSettings.PROPERTY_STROKE_WIDTH, context, default_value)
stroke_widths.append(value)
if self.settings.data_defined_properties.isActive(
PlotSettings.PROPERTY_COLOR) and (not aggregating
or not executed):
default_value = QColor(self.settings.properties['in_color'])
value, conversion_success = self.settings.data_defined_properties.valueAsColor(
PlotSettings.PROPERTY_COLOR, context, default_value)
if conversion_success:
# We were given a valid color specification, use that color
colors.append(value.name())
else:
try:
# Attempt to interpret the value as a list of color specifications
value_list = self.settings.data_defined_properties.value(
PlotSettings.PROPERTY_COLOR, context)
color_list = [
QgsSymbolLayerUtils.decodeColor(item).name()
for item in value_list
]
colors.extend(color_list)
except TypeError:
# Not a list of color specifications, use the default color instead
colors.append(default_value.name())
if self.settings.data_defined_properties.isActive(
PlotSettings.PROPERTY_STROKE_COLOR) and (not aggregating
or not executed):
default_value = QColor(self.settings.properties['out_color'])
value, conversion_success = self.settings.data_defined_properties.valueAsColor(
PlotSettings.PROPERTY_STROKE_COLOR, context, default_value)
if conversion_success:
# We were given a valid color specification, use that color
stroke_colors.append(value.name())
else:
try:
# Attempt to interpret the value as a list of color specifications
value_list = self.settings.data_defined_properties.value(
PlotSettings.PROPERTY_STROKE_COLOR, context)
color_list = [
QgsSymbolLayerUtils.decodeColor(item).name()
for item in value_list
]
stroke_colors.extend(color_list)
except TypeError:
# Not a list of color specifications, use the default color instead
stroke_colors.append(default_value.name())
executed = True
self.settings.additional_hover_text = additional_hover_text
self.settings.x = xx
self.settings.y = yy
self.settings.z = zz
if marker_sizes:
self.settings.data_defined_marker_sizes = marker_sizes
if colors:
self.settings.data_defined_colors = colors
if stroke_colors:
self.settings.data_defined_stroke_colors = stroke_colors
if stroke_widths:
self.settings.data_defined_stroke_widths = stroke_widths
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
source_fields_parameter = self.parameterAsFields(
parameters, self.INPUT_FIELD, context)
target = self.parameterAsVectorLayer(parameters, self.OUTPUT, context)
target_fields_parameter = self.parameterAsFields(
parameters, self.OUTPUT_FIELD, context)
action_on_duplicate = self.parameterAsEnum(parameters,
self.ACTION_ON_DUPLICATE,
context)
results = {
self.OUTPUT: None,
self.APPENDED_COUNT: None,
self.UPDATED_COUNT: None,
self.SKIPPED_COUNT: None
}
target_value_dict = dict()
source_field_unique_values = ''
target_field_unique_values = ''
source_field_type = None
target_field_type = None
if source_fields_parameter:
source_field_unique_values = source_fields_parameter[0]
source_field_type = source.fields().field(
source_field_unique_values).type()
if target_fields_parameter:
target_field_unique_values = target_fields_parameter[0]
target_field_type = target.fields().field(
target_field_unique_values).type()
if source_field_type != target_field_type:
feedback.pushInfo(
"\nWARNING: Source and target fields to compare have different field types."
)
if source_field_unique_values and target_field_unique_values and action_on_duplicate == self.NO_ACTION:
feedback.reportError(
"\nWARNING: Since you have chosen source and target fields to compare, you need to choose a valid action to apply on duplicate features before running this algorithm."
)
return results
if action_on_duplicate != self.NO_ACTION and not (
source_field_unique_values and target_field_unique_values):
feedback.reportError(
"\nWARNING: Since you have chosen an action on duplicate features, you need to choose both source and target fields for comparing values before running this algorithm."
)
return results
caps = target.dataProvider().capabilities()
if not (caps & QgsVectorDataProvider.AddFeatures):
feedback.reportError(
"\nWARNING: The target layer does not support appending features to it! Choose another target layer."
)
return results
if action_on_duplicate == self.UPDATE_EXISTING_FEATURE and not (
caps & QgsVectorDataProvider.ChangeAttributeValues
and caps & QgsVectorDataProvider.ChangeGeometries):
feedback.reportError(
"\nWARNING: The target layer does not support updating its features! Choose another action for duplicate features or choose another target layer."
)
return results
editable_before = False
if target.isEditable():
editable_before = True
feedback.reportError(
"\nWARNING: You need to close the edit session on layer '{}' before running this algorithm."
.format(target.name()))
return results
# Define a mapping between source and target layer
mapping = dict()
for target_idx in target.fields().allAttributesList():
target_field = target.fields().field(target_idx)
source_idx = source.fields().indexOf(target_field.name())
if source_idx != -1:
mapping[target_idx] = source_idx
# Build dict of target field values so that we can search easily later {value1: [id1, id2], ...}
if target_field_unique_values:
for f in target.getFeatures():
if f[target_field_unique_values] in target_value_dict:
target_value_dict[f[target_field_unique_values]].append(
int(f.id()))
else:
target_value_dict[f[target_field_unique_values]] = [
int(f.id())
]
# Prepare features for the Copy and Paste
results[self.APPENDED_COUNT] = 0
total = 100.0 / source.featureCount() if source.featureCount() else 0
features = source.getFeatures()
destType = target.geometryType()
destIsMulti = QgsWkbTypes.isMultiType(target.wkbType())
new_features = list()
updated_features = dict()
updated_geometries = dict()
updated_features_count = 0
updated_geometries_count = 0
skipped_features_count = 0 # To properly count features that were skipped
duplicate_features_set = set(
) # To properly count features that were updated
for current, in_feature in enumerate(features):
if feedback.isCanceled():
break
target_feature_exists = False
duplicate_target_value = None
# If skip is the action, skip as soon as possible
if source_field_unique_values:
duplicate_target, duplicate_target_value = self.find_duplicate_value(
in_feature[source_field_unique_values], source_field_type,
target_value_dict, target_field_type)
if duplicate_target:
if action_on_duplicate == self.SKIP_FEATURE:
request = QgsFeatureRequest(
target_value_dict[duplicate_target_value]
) # Get target feature ids
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes(
[]) # Note: this adds a new flag
skipped_features_count += len(
[f for f in target.getFeatures(request)])
continue
target_feature_exists = True
attrs = {
target_idx: in_feature[source_idx]
for target_idx, source_idx in mapping.items()
}
geom = QgsGeometry()
if in_feature.hasGeometry() and target.isSpatial():
# Convert geometry to match destination layer
# Adapted from QGIS qgisapp.cpp, pasteFromClipboard()
geom = in_feature.geometry()
if not geom.isNull():
if destType != QgsWkbTypes.UnknownGeometry:
newGeometry = geom.convertToType(destType, destIsMulti)
if newGeometry.isNull():
continue # Couldn't convert
geom = newGeometry
# Avoid intersection if enabled in digitize settings
geom.avoidIntersections(
QgsProject.instance().avoidIntersectionsLayers())
if target_feature_exists and action_on_duplicate == self.UPDATE_EXISTING_FEATURE:
for t_f in target.getFeatures(
target_value_dict[duplicate_target_value]):
duplicate_features_set.add(t_f.id())
updated_features[t_f.id()] = attrs
if target.isSpatial():
updated_geometries[t_f.id()] = geom
else: # Append
new_feature = QgsVectorLayerUtils().createFeature(
target, geom, attrs)
new_features.append(new_feature)
feedback.setProgress(int(current * total))
# Do the Copy and Paste
res_add_features = False
try:
with edit(target):
target.beginEditCommand("Appending/Updating features...")
if updated_features:
for k, v in updated_features.items():
if target.changeAttributeValues(k, v):
updated_features_count += 1
else:
feedback.reportError(
"\nERROR: Target feature (id={}) couldn't be updated to the following attributes: {}."
.format(k, v))
if updated_geometries:
for k, v in updated_geometries.items():
if target.changeGeometry(k, v):
updated_geometries_count += 1
else:
feedback.reportError(
"\nERROR: Target feature's geometry (id={}) couldn't be updated."
.format(k))
if new_features:
res_add_features = target.addFeatures(new_features)
target.endEditCommand()
except QgsEditError as e:
if not editable_before:
# Let's close the edit session to prepare for a next run
target.rollBack()
feedback.reportError(
"\nERROR: No features could be appended/updated to/in '{}', because of the following error:\n{}\n"
.format(target.name(), repr(e)))
return results
if action_on_duplicate == self.SKIP_FEATURE:
feedback.pushInfo(
"\nSKIPPED FEATURES: {} duplicate features were skipped while copying features to '{}'!"
.format(skipped_features_count, target.name()))
results[self.SKIPPED_COUNT] = skipped_features_count
if action_on_duplicate == self.UPDATE_EXISTING_FEATURE:
feedback.pushInfo(
"\nUPDATED FEATURES: {} out of {} duplicate features were updated while copying features to '{}'!"
.format(updated_features_count, len(duplicate_features_set),
target.name()))
results[self.UPDATED_COUNT] = updated_features_count
if not new_features:
feedback.pushInfo(
"\nFINISHED WITHOUT APPENDED FEATURES: There were no features to append to '{}'."
.format(target.name()))
else:
if res_add_features:
feedback.pushInfo(
"\nAPPENDED FEATURES: {} out of {} features from input layer were successfully appended to '{}'!"
.format(len(new_features), source.featureCount(),
target.name()))
results[self.APPENDED_COUNT] = len(new_features)
else: # TODO do we really need this else message below?
feedback.reportError(
"\nERROR: The {} features from input layer could not be appended to '{}'. Sometimes this might be due to NOT NULL constraints that are not met."
.format(source.featureCount(), target.name()))
results[self.OUTPUT] = target
return results
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
value_field_name = self.parameterAsString(parameters,
self.VALUES_FIELD_NAME,
context)
category_field_names = self.parameterAsFields(
parameters, self.CATEGORIES_FIELD_NAME, context)
value_field_index = source.fields().lookupField(value_field_name)
if value_field_index >= 0:
value_field = source.fields().at(value_field_index)
else:
value_field = None
category_field_indexes = [
source.fields().lookupField(n) for n in category_field_names
]
# generate output fields
fields = QgsFields()
for c in category_field_indexes:
fields.append(source.fields().at(c))
def addField(name):
"""
Adds a field to the output, keeping the same data type as the value_field
"""
field = QgsField(value_field)
field.setName(name)
fields.append(field)
if value_field is None:
field_type = 'none'
fields.append(QgsField('count', QVariant.Int))
elif value_field.isNumeric():
field_type = 'numeric'
fields.append(QgsField('count', QVariant.Int))
fields.append(QgsField('unique', QVariant.Int))
fields.append(QgsField('min', QVariant.Double))
fields.append(QgsField('max', QVariant.Double))
fields.append(QgsField('range', QVariant.Double))
fields.append(QgsField('sum', QVariant.Double))
fields.append(QgsField('mean', QVariant.Double))
fields.append(QgsField('median', QVariant.Double))
fields.append(QgsField('stddev', QVariant.Double))
fields.append(QgsField('minority', QVariant.Double))
fields.append(QgsField('majority', QVariant.Double))
fields.append(QgsField('q1', QVariant.Double))
fields.append(QgsField('q3', QVariant.Double))
fields.append(QgsField('iqr', QVariant.Double))
elif value_field.type() in (QVariant.Date, QVariant.Time,
QVariant.DateTime):
field_type = 'datetime'
fields.append(QgsField('count', QVariant.Int))
fields.append(QgsField('unique', QVariant.Int))
fields.append(QgsField('empty', QVariant.Int))
fields.append(QgsField('filled', QVariant.Int))
# keep same data type for these fields
addField('min')
addField('max')
else:
field_type = 'string'
fields.append(QgsField('count', QVariant.Int))
fields.append(QgsField('unique', QVariant.Int))
fields.append(QgsField('empty', QVariant.Int))
fields.append(QgsField('filled', QVariant.Int))
# keep same data type for these fields
addField('min')
addField('max')
fields.append(QgsField('min_length', QVariant.Int))
fields.append(QgsField('max_length', QVariant.Int))
fields.append(QgsField('mean_length', QVariant.Double))
request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
if value_field is not None:
attrs = [value_field_index]
else:
attrs = []
attrs.extend(category_field_indexes)
request.setSubsetOfAttributes(attrs)
features = source.getFeatures(
request, QgsProcessingFeatureSource.FlagSkipGeometryValidityChecks)
total = 50.0 / source.featureCount() if source.featureCount() else 0
if field_type == 'none':
values = defaultdict(lambda: 0)
else:
values = defaultdict(list)
for current, feat in enumerate(features):
if feedback.isCanceled():
break
feedback.setProgress(int(current * total))
attrs = feat.attributes()
cat = tuple([attrs[c] for c in category_field_indexes])
if field_type == 'none':
values[cat] += 1
continue
if field_type == 'numeric':
if attrs[value_field_index] == NULL:
continue
else:
value = float(attrs[value_field_index])
elif field_type == 'string':
if attrs[value_field_index] == NULL:
value = ''
else:
value = str(attrs[value_field_index])
elif attrs[value_field_index] == NULL:
value = NULL
else:
value = attrs[value_field_index]
values[cat].append(value)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.NoGeometry,
QgsCoordinateReferenceSystem())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
if field_type == 'none':
self.saveCounts(values, sink, feedback)
elif field_type == 'numeric':
self.calcNumericStats(values, sink, feedback)
elif field_type == 'datetime':
self.calcDateTimeStats(values, sink, feedback)
else:
self.calcStringStats(values, sink, feedback)
return {self.OUTPUT: dest_id}
def execute_in_place_run(alg, parameters, context=None, feedback=None, raise_exceptions=False):
"""Executes an algorithm modifying features in-place in the input layer.
:param alg: algorithm to run
:type alg: QgsProcessingAlgorithm
:param parameters: parameters of the algorithm
:type parameters: dict
:param context: context, defaults to None
:type context: QgsProcessingContext, optional
:param feedback: feedback, defaults to None
:type feedback: QgsProcessingFeedback, optional
:param raise_exceptions: useful for testing, if True exceptions are raised, normally exceptions will be forwarded to the feedback
:type raise_exceptions: boo, default to False
:raises QgsProcessingException: raised when there is no active layer, or it cannot be made editable
:return: a tuple with true if success and results
:rtype: tuple
"""
if feedback is None:
feedback = QgsProcessingFeedback()
if context is None:
context = dataobjects.createContext(feedback)
active_layer = parameters['INPUT']
# Run some checks and prepare the layer for in-place execution by:
# - getting the active layer and checking that it is a vector
# - making the layer editable if it was not already
# - selecting all features if none was selected
# - checking in-place support for the active layer/alg/parameters
# If one of the check fails and raise_exceptions is True an exception
# is raised, else the execution is aborted and the error reported in
# the feedback
try:
if active_layer is None:
raise QgsProcessingException(tr("There is not active layer."))
if not isinstance(active_layer, QgsVectorLayer):
raise QgsProcessingException(tr("Active layer is not a vector layer."))
if not active_layer.isEditable():
if not active_layer.startEditing():
raise QgsProcessingException(tr("Active layer is not editable (and editing could not be turned on)."))
if not alg.supportInPlaceEdit(active_layer):
raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
except QgsProcessingException as e:
if raise_exceptions:
raise e
QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical)
if feedback is not None:
feedback.reportError(getattr(e, 'msg', str(e)), fatalError=True)
return False, {}
if not active_layer.selectedFeatureIds():
active_layer.selectAll()
# Make sure we are working on selected features only
parameters['INPUT'] = QgsProcessingFeatureSourceDefinition(active_layer.id(), True)
parameters['OUTPUT'] = 'memory:'
req = QgsFeatureRequest(QgsExpression(r"$id < 0"))
req.setFlags(QgsFeatureRequest.NoGeometry)
req.setSubsetOfAttributes([])
# Start the execution
# If anything goes wrong and raise_exceptions is True an exception
# is raised, else the execution is aborted and the error reported in
# the feedback
try:
new_feature_ids = []
active_layer.beginEditCommand(alg.displayName())
# Checks whether the algorithm has a processFeature method
if hasattr(alg, 'processFeature'): # in-place feature editing
# Make a clone or it will crash the second time the dialog
# is opened and run
alg = alg.create()
if not alg.prepare(parameters, context, feedback):
raise QgsProcessingException(tr("Could not prepare selected algorithm."))
# Check again for compatibility after prepare
if not alg.supportInPlaceEdit(active_layer):
raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
field_idxs = range(len(active_layer.fields()))
iterator_req = QgsFeatureRequest(active_layer.selectedFeatureIds())
iterator_req.setInvalidGeometryCheck(context.invalidGeometryCheck())
feature_iterator = active_layer.getFeatures(iterator_req)
step = 100 / len(active_layer.selectedFeatureIds()) if active_layer.selectedFeatureIds() else 1
for current, f in enumerate(feature_iterator):
feedback.setProgress(current * step)
if feedback.isCanceled():
break
# need a deep copy, because python processFeature implementations may return
# a shallow copy from processFeature
input_feature = QgsFeature(f)
new_features = alg.processFeature(input_feature, context, feedback)
new_features = QgsVectorLayerUtils.makeFeaturesCompatible(new_features, active_layer)
if len(new_features) == 0:
active_layer.deleteFeature(f.id())
elif len(new_features) == 1:
new_f = new_features[0]
if not f.geometry().equals(new_f.geometry()):
active_layer.changeGeometry(f.id(), new_f.geometry())
if f.attributes() != new_f.attributes():
active_layer.changeAttributeValues(f.id(), dict(zip(field_idxs, new_f.attributes())), dict(zip(field_idxs, f.attributes())))
new_feature_ids.append(f.id())
else:
active_layer.deleteFeature(f.id())
# Get the new ids
old_ids = set([f.id() for f in active_layer.getFeatures(req)])
if not active_layer.addFeatures(new_features):
raise QgsProcessingException(tr("Error adding processed features back into the layer."))
new_ids = set([f.id() for f in active_layer.getFeatures(req)])
new_feature_ids += list(new_ids - old_ids)
results, ok = {}, True
else: # Traditional 'run' with delete and add features cycle
# There is no way to know if some features have been skipped
# due to invalid geometries
if context.invalidGeometryCheck() == QgsFeatureRequest.GeometrySkipInvalid:
selected_ids = active_layer.selectedFeatureIds()
else:
selected_ids = []
results, ok = alg.run(parameters, context, feedback)
if ok:
result_layer = QgsProcessingUtils.mapLayerFromString(results['OUTPUT'], context)
# TODO: check if features have changed before delete/add cycle
new_features = []
# Check if there are any skipped features
if context.invalidGeometryCheck() == QgsFeatureRequest.GeometrySkipInvalid:
missing_ids = list(set(selected_ids) - set(result_layer.allFeatureIds()))
if missing_ids:
for f in active_layer.getFeatures(QgsFeatureRequest(missing_ids)):
if not f.geometry().isGeosValid():
new_features.append(f)
active_layer.deleteFeatures(active_layer.selectedFeatureIds())
for f in result_layer.getFeatures():
new_features.extend(QgsVectorLayerUtils.
makeFeaturesCompatible([f], active_layer))
# Get the new ids
old_ids = set([f.id() for f in active_layer.getFeatures(req)])
if not active_layer.addFeatures(new_features):
raise QgsProcessingException(tr("Error adding processed features back into the layer."))
new_ids = set([f.id() for f in active_layer.getFeatures(req)])
new_feature_ids += list(new_ids - old_ids)
active_layer.endEditCommand()
if ok and new_feature_ids:
active_layer.selectByIds(new_feature_ids)
elif not ok:
active_layer.rollBack()
return ok, results
except QgsProcessingException as e:
active_layer.endEditCommand()
active_layer.rollBack()
if raise_exceptions:
raise e
QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical)
if feedback is not None:
feedback.reportError(getattr(e, 'msg', str(e)), fatalError=True)
return False, {}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
radius = self.parameterAsDouble(parameters, self.RADIUS, context)
kernel_shape = self.parameterAsEnum(parameters, self.KERNEL, context)
pixel_size = self.parameterAsDouble(parameters, self.PIXEL_SIZE,
context)
decay = self.parameterAsDouble(parameters, self.DECAY, context)
output_values = self.parameterAsEnum(parameters, self.OUTPUT_VALUE,
context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
output_format = QgsRasterFileWriter.driverForExtension(
os.path.splitext(outputFile)[1])
weight_field = self.parameterAsString(parameters, self.WEIGHT_FIELD,
context)
radius_field = self.parameterAsString(parameters, self.RADIUS_FIELD,
context)
attrs = []
kde_params = QgsKernelDensityEstimation.Parameters()
kde_params.source = source
kde_params.radius = radius
kde_params.pixelSize = pixel_size
# radius field
if radius_field:
kde_params.radiusField = radius_field
attrs.append(source.fields().lookupField(radius_field))
# weight field
if weight_field:
kde_params.weightField = weight_field
attrs.append(source.fields().lookupField(weight_field))
kde_params.shape = kernel_shape
kde_params.decayRatio = decay
kde_params.outputValues = output_values
kde = QgsKernelDensityEstimation(kde_params, outputFile, output_format)
if kde.prepare() != QgsKernelDensityEstimation.Success:
raise QgsProcessingException(
self.tr('Could not create destination layer'))
request = QgsFeatureRequest()
request.setSubsetOfAttributes(attrs)
features = source.getFeatures(request)
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(features):
if feedback.isCanceled():
break
if kde.addFeature(f) != QgsKernelDensityEstimation.Success:
feedback.reportError(
self.tr(
'Error adding feature with ID {} to heatmap').format(
f.id()))
feedback.setProgress(int(current * total))
if kde.finalise() != QgsKernelDensityEstimation.Success:
raise QgsProcessingException(
self.tr('Could not save destination layer'))
return {self.OUTPUT: outputFile}
def test_sql2(self):
l2 = QgsVectorLayer(os.path.join(self.testDataDir, "france_parts.shp"),
"france_parts", "ogr",
QgsVectorLayer.LayerOptions(False))
self.assertEqual(l2.isValid(), True)
QgsProject.instance().addMapLayer(l2)
query = toPercent("SELECT * FROM france_parts")
l4 = QgsVectorLayer("?query=%s&uid=ObjectId" % query, "tt", "virtual")
self.assertEqual(l4.isValid(), True)
self.assertEqual(l4.dataProvider().wkbType(), 6)
self.assertEqual(l4.dataProvider().crs().postgisSrid(), 4326)
n = 0
r = QgsFeatureRequest(QgsRectangle(-1.677, 49.624, -0.816, 49.086))
for f in l4.getFeatures(r):
self.assertEqual(f.geometry() is not None, True)
self.assertEqual(f.attributes()[0], 2661)
n += 1
self.assertEqual(n, 1)
# use uid
query = toPercent("SELECT * FROM france_parts")
l5 = QgsVectorLayer(
"?query=%s&geometry=geometry:polygon:4326&uid=ObjectId" % query,
"tt", "virtual")
self.assertEqual(l5.isValid(), True)
idSum = sum(f.id() for f in l5.getFeatures())
self.assertEqual(idSum, 10659)
r = QgsFeatureRequest(2661)
idSum2 = sum(f.id() for f in l5.getFeatures(r))
self.assertEqual(idSum2, 2661)
r = QgsFeatureRequest()
r.setFilterFids([2661, 2664])
self.assertEqual(sum(f.id() for f in l5.getFeatures(r)), 2661 + 2664)
# test attribute subset
r = QgsFeatureRequest()
r.setFlags(QgsFeatureRequest.SubsetOfAttributes)
r.setSubsetOfAttributes([1])
s = [(f.id(), f.attributes()[1]) for f in l5.getFeatures(r)]
self.assertEqual(sum([x[0] for x in s]), 10659)
self.assertEqual(sum([x[1] for x in s]), 3064.0)
# test NoGeometry
# by request flag
r = QgsFeatureRequest()
r.setFlags(QgsFeatureRequest.NoGeometry)
self.assertEqual(all([not f.hasGeometry() for f in l5.getFeatures(r)]),
True)
# test subset
self.assertEqual(l5.dataProvider().featureCount(), 4)
l5.setSubsetString("ObjectId = 2661")
idSum2 = sum(f.id() for f in l5.getFeatures(r))
self.assertEqual(idSum2, 2661)
self.assertEqual(l5.dataProvider().featureCount(), 1)
def processAlgorithm(self, parameters, context, feedback):
sourceA = self.parameterAsSource(parameters, self.INPUT, context)
sourceB = self.parameterAsSource(parameters, self.OVERLAY, context)
geomType = QgsWkbTypes.multiType(sourceA.wkbType())
fieldsA = self.parameterAsFields(parameters, self.INPUT_FIELDS,
context)
fieldsB = self.parameterAsFields(parameters, self.OVERLAY_FIELDS,
context)
fieldListA = QgsFields()
field_indices_a = []
if len(fieldsA) > 0:
for f in fieldsA:
idxA = sourceA.fields().lookupField(f)
if idxA >= 0:
field_indices_a.append(idxA)
fieldListA.append(sourceA.fields()[idxA])
else:
fieldListA = sourceA.fields()
field_indices_a = [i for i in range(0, fieldListA.count())]
fieldListB = QgsFields()
field_indices_b = []
if len(fieldsB) > 0:
for f in fieldsB:
idxB = sourceB.fields().lookupField(f)
if idxB >= 0:
field_indices_b.append(idxB)
fieldListB.append(sourceB.fields()[idxB])
else:
fieldListB = sourceB.fields()
field_indices_b = [i for i in range(0, fieldListB.count())]
output_fields = QgsProcessingUtils.combineFields(
fieldListA, fieldListB)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, output_fields,
geomType, sourceA.sourceCrs())
outFeat = QgsFeature()
indexB = QgsSpatialIndex(
sourceB.getFeatures(QgsFeatureRequest().setSubsetOfAttributes(
[]).setDestinationCrs(sourceA.sourceCrs(),
context.transformContext())), feedback)
total = 100.0 / sourceA.featureCount() if sourceA.featureCount() else 1
count = 0
for featA in sourceA.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes(field_indices_a)):
if feedback.isCanceled():
break
if not featA.hasGeometry():
continue
geom = featA.geometry()
atMapA = featA.attributes()
intersects = indexB.intersects(geom.boundingBox())
request = QgsFeatureRequest().setFilterFids(intersects)
request.setDestinationCrs(sourceA.sourceCrs(),
context.transformContext())
request.setSubsetOfAttributes(field_indices_b)
engine = None
if len(intersects) > 0:
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(geom.constGet())
engine.prepareGeometry()
for featB in sourceB.getFeatures(request):
if feedback.isCanceled():
break
tmpGeom = featB.geometry()
if engine.intersects(tmpGeom.constGet()):
out_attributes = [
featA.attributes()[i] for i in field_indices_a
]
out_attributes.extend(
[featB.attributes()[i] for i in field_indices_b])
int_geom = QgsGeometry(geom.intersection(tmpGeom))
if int_geom.wkbType(
) == QgsWkbTypes.Unknown or QgsWkbTypes.flatType(
int_geom.wkbType(
)) == QgsWkbTypes.GeometryCollection:
int_com = geom.combine(tmpGeom)
int_geom = QgsGeometry()
if int_com:
int_sym = geom.symDifference(tmpGeom)
int_geom = QgsGeometry(int_com.difference(int_sym))
if int_geom.isEmpty() or not int_geom.isGeosValid():
raise QgsProcessingException(
self.tr('GEOS geoprocessing error: One or '
'more input features have invalid '
'geometry.'))
try:
if QgsWkbTypes.geometryType(int_geom.wkbType(
)) == QgsWkbTypes.geometryType(geomType):
int_geom.convertToMultiType()
outFeat.setGeometry(int_geom)
outFeat.setAttributes(out_attributes)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
raise QgsProcessingException(
self.tr('Feature geometry error: One or more '
'output features ignored due to invalid '
'geometry.'))
count += 1
feedback.setProgress(int(count * total))
return {self.OUTPUT: dest_id}
def testSubsetStringFids(self):
"""
- tests that feature ids are stable even if a subset string is set
- tests that the subset string is correctly set on the ogr layer event when reloading the data source (issue #17122)
"""
tmpfile = os.path.join(self.basetestpath, 'subsetStringFids.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('type', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('value', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(0)
f.SetField(0, 1)
f.SetField(1, 11)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(1)
f.SetField(0, 1)
f.SetField(1, 12)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(2)
f.SetField(0, 1)
f.SetField(1, 13)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(3)
f.SetField(0, 2)
f.SetField(1, 14)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(4)
f.SetField(0, 2)
f.SetField(1, 15)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(5)
f.SetField(0, 2)
f.SetField(1, 16)
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer(tmpfile + "|subset=type=2", 'test', 'ogr')
self.assertTrue(vl.isValid())
self.assertTrue(vl.fields().at(vl.fields().count() - 1).name() == "orig_ogc_fid")
req = QgsFeatureRequest()
req.setFilterExpression("value=16")
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertTrue(f.id() == 5)
# Ensure that orig_ogc_fid is still retrieved even if attribute subset is passed
req = QgsFeatureRequest()
req.setSubsetOfAttributes([])
it = vl.getFeatures(req)
ids = []
while it.nextFeature(f):
ids.append(f.id())
self.assertTrue(len(ids) == 3)
self.assertTrue(3 in ids)
self.assertTrue(4 in ids)
self.assertTrue(5 in ids)
# Check that subset string is correctly set on reload
vl.reload()
self.assertTrue(vl.fields().at(vl.fields().count() - 1).name() == "orig_ogc_fid")
def testSubsetStringFids(self):
"""
- tests that feature ids are stable even if a subset string is set
- tests that the subset string is correctly set on the ogr layer event when reloading the data source (issue #17122)
"""
tmpfile = os.path.join(self.basetestpath, 'subsetStringFids.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('type', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('value', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(0)
f.SetField(0, 1)
f.SetField(1, 11)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(1)
f.SetField(0, 1)
f.SetField(1, 12)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(2)
f.SetField(0, 1)
f.SetField(1, 13)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(3)
f.SetField(0, 2)
f.SetField(1, 14)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(4)
f.SetField(0, 2)
f.SetField(1, 15)
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f.SetFID(5)
f.SetField(0, 2)
f.SetField(1, 16)
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer(tmpfile + "|subset=type=2", 'test', 'ogr')
self.assertTrue(vl.isValid())
self.assertTrue(vl.fields().at(vl.fields().count() - 1).name() == "orig_ogc_fid")
req = QgsFeatureRequest()
req.setFilterExpression("value=16")
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertTrue(f.id() == 5)
# Ensure that orig_ogc_fid is still retrieved even if attribute subset is passed
req = QgsFeatureRequest()
req.setSubsetOfAttributes([])
it = vl.getFeatures(req)
ids = []
while it.nextFeature(f):
ids.append(f.id())
self.assertTrue(len(ids) == 3)
self.assertTrue(3 in ids)
self.assertTrue(4 in ids)
self.assertTrue(5 in ids)
# Check that subset string is correctly set on reload
vl.reload()
self.assertTrue(vl.fields().at(vl.fields().count() - 1).name() == "orig_ogc_fid")
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
field_names = self.parameterAsFields(parameters, self.FIELDS, context)
fields = QgsFields()
field_indices = []
for field_name in field_names:
field_index = source.fields().lookupField(field_name)
if field_index < 0:
feedback.reportError(
self.tr('Invalid field name {}').format(field_name))
continue
field = source.fields()[field_index]
fields.append(field)
field_indices.append(field_index)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.NoGeometry,
QgsCoordinateReferenceSystem())
results = {}
values = set()
if len(field_indices) == 1:
# one field, can use provider optimised method
values = tuple([v] for v in source.uniqueValues(field_indices[0]))
else:
# have to scan whole table
# TODO - add this support to QgsVectorDataProvider so we can run it on
# the backend
request = QgsFeatureRequest().setFlags(
QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes(field_indices)
total = 100.0 / source.featureCount() if source.featureCount(
) else 0
for current, f in enumerate(source.getFeatures(request)):
if feedback.isCanceled():
break
value = tuple(f.attribute(i) for i in field_indices)
values.add(value)
feedback.setProgress(int(current * total))
if sink:
for value in values:
if feedback.isCanceled():
break
f = QgsFeature()
f.setAttributes([attr for attr in value])
sink.addFeature(f, QgsFeatureSink.FastInsert)
results[self.OUTPUT] = dest_id
output_file = self.parameterAsFileOutput(parameters,
self.OUTPUT_HTML_FILE,
context)
if output_file:
self.createHTML(output_file, values)
results[self.OUTPUT_HTML_FILE] = output_file
results[self.TOTAL_VALUES] = len(values)
results[self.UNIQUE_VALUES] = ';'.join(
[','.join([str(attr) for attr in v]) for v in values])
return results
def processAlgorithm(self, progress):
layerA = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_A))
splitLayer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_B))
sameLayer = self.getParameterValue(self.INPUT_A) == self.getParameterValue(self.INPUT_B)
fieldList = layerA.fields()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList,
QgsWkbTypes.multiType(layerA.wkbType()), layerA.crs())
spatialIndex = QgsSpatialIndex()
splitGeoms = {}
request = QgsFeatureRequest()
request.setSubsetOfAttributes([])
for aSplitFeature in vector.features(splitLayer, request):
splitGeoms[aSplitFeature.id()] = aSplitFeature.geometry()
spatialIndex.insertFeature(aSplitFeature)
# honor the case that user has selection on split layer and has setting "use selection"
outFeat = QgsFeature()
features = vector.features(layerA)
if len(features) == 0:
total = 100
else:
total = 100.0 / float(len(features))
for current, inFeatA in enumerate(features):
inGeom = inFeatA.geometry()
attrsA = inFeatA.attributes()
outFeat.setAttributes(attrsA)
if inGeom.isMultipart():
inGeoms = []
for g in inGeom.asGeometryCollection():
inGeoms.append(g)
else:
inGeoms = [inGeom]
lines = spatialIndex.intersects(inGeom.boundingBox())
if len(lines) > 0: # has intersection of bounding boxes
splittingLines = []
engine = QgsGeometry.createGeometryEngine(inGeom.geometry())
engine.prepareGeometry()
for i in lines:
try:
splitGeom = splitGeoms[i]
except:
continue
# check if trying to self-intersect
if sameLayer:
if inFeatA.id() == i:
continue
if engine.intersects(splitGeom.geometry()):
splittingLines.append(splitGeom)
if len(splittingLines) > 0:
for splitGeom in splittingLines:
splitterPList = None
outGeoms = []
split_geom_engine = QgsGeometry.createGeometryEngine(splitGeom.geometry())
split_geom_engine.prepareGeometry()
while len(inGeoms) > 0:
inGeom = inGeoms.pop()
if inGeom.isEmpty(): # this has been encountered and created a run-time error
continue
if split_geom_engine.intersects(inGeom.geometry()):
inPoints = vector.extractPoints(inGeom)
if splitterPList == None:
splitterPList = vector.extractPoints(splitGeom)
try:
result, newGeometries, topoTestPoints = inGeom.splitGeometry(splitterPList, False)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
self.tr('Geometry exception while splitting'))
result = 1
# splitGeometry: If there are several intersections
# between geometry and splitLine, only the first one is considered.
if result == 0: # split occurred
if inPoints == vector.extractPoints(inGeom):
# bug in splitGeometry: sometimes it returns 0 but
# the geometry is unchanged
outGeoms.append(inGeom)
else:
inGeoms.append(inGeom)
for aNewGeom in newGeometries:
inGeoms.append(aNewGeom)
else:
outGeoms.append(inGeom)
else:
outGeoms.append(inGeom)
inGeoms = outGeoms
parts = []
for aGeom in inGeoms:
passed = True
if QgsWkbTypes.geometryType( aGeom.wkbType() ) == QgsWkbTypes.LineGeometry:
numPoints = aGeom.geometry().numPoints()
if numPoints <= 2:
if numPoints == 2:
passed = not aGeom.geometry().isClosed() # tests if vertex 0 = vertex 1
else:
passed = False
# sometimes splitting results in lines of zero length
if passed:
parts.append(aGeom)
if len(parts) > 0:
outFeat.setGeometry(QgsGeometry.collectGeometry(parts))
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
def run_checks():
self.assertEqual([f.name() for f in vl.fields()],
['fid', 'type', 'value'])
# expression
req = QgsFeatureRequest()
req.setFilterExpression("value=16")
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter fid
req = QgsFeatureRequest()
req.setFilterFid(5)
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter fids
req = QgsFeatureRequest()
req.setFilterFids([5])
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# check with subset of attributes
req = QgsFeatureRequest()
req.setFilterFids([5])
req.setSubsetOfAttributes([2])
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes()[2], 16)
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter rect and expression
req = QgsFeatureRequest()
req.setFilterExpression("value=16 or value=14")
req.setFilterRect(QgsRectangle(4.5, 4.5, 5.5, 5.5))
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# filter rect and fids
req = QgsFeatureRequest()
req.setFilterFids([3, 5])
req.setFilterRect(QgsRectangle(4.5, 4.5, 5.5, 5.5))
it = vl.getFeatures(req)
f = QgsFeature()
self.assertTrue(it.nextFeature(f))
self.assertEqual(f.id(), 5)
self.assertEqual(f.attributes(), [5, 2, 16])
self.assertEqual([field.name() for field in f.fields()],
['fid', 'type', 'value'])
self.assertEqual(f.geometry().asWkt(), 'Point (5 5)')
# Ensure that orig_ogc_fid is still retrieved even if attribute subset is passed
req = QgsFeatureRequest()
req.setSubsetOfAttributes([])
it = vl.getFeatures(req)
ids = []
geoms = {}
while it.nextFeature(f):
ids.append(f.id())
geoms[f.id()] = f.geometry().asWkt()
self.assertCountEqual(ids, [3, 4, 5])
self.assertEqual(geoms, {
3: 'Point (3 3)',
4: 'Point (4 4)',
5: 'Point (5 5)'
})
def execute_in_place_run(alg, parameters, context=None, feedback=None, raise_exceptions=False):
"""Executes an algorithm modifying features in-place in the input layer.
:param alg: algorithm to run
:type alg: QgsProcessingAlgorithm
:param parameters: parameters of the algorithm
:type parameters: dict
:param context: context, defaults to None
:type context: QgsProcessingContext, optional
:param feedback: feedback, defaults to None
:type feedback: QgsProcessingFeedback, optional
:param raise_exceptions: useful for testing, if True exceptions are raised, normally exceptions will be forwarded to the feedback
:type raise_exceptions: boo, default to False
:raises QgsProcessingException: raised when there is no active layer, or it cannot be made editable
:return: a tuple with true if success and results
:rtype: tuple
"""
if feedback is None:
feedback = QgsProcessingFeedback()
if context is None:
context = dataobjects.createContext(feedback)
# Only feature based algs have sourceFlags
try:
if alg.sourceFlags() & QgsProcessingFeatureSource.FlagSkipGeometryValidityChecks:
context.setInvalidGeometryCheck(QgsFeatureRequest.GeometryNoCheck)
except AttributeError:
pass
active_layer = parameters['INPUT']
# Run some checks and prepare the layer for in-place execution by:
# - getting the active layer and checking that it is a vector
# - making the layer editable if it was not already
# - selecting all features if none was selected
# - checking in-place support for the active layer/alg/parameters
# If one of the check fails and raise_exceptions is True an exception
# is raised, else the execution is aborted and the error reported in
# the feedback
try:
if active_layer is None:
raise QgsProcessingException(tr("There is not active layer."))
if not isinstance(active_layer, QgsVectorLayer):
raise QgsProcessingException(tr("Active layer is not a vector layer."))
if not active_layer.isEditable():
if not active_layer.startEditing():
raise QgsProcessingException(tr("Active layer is not editable (and editing could not be turned on)."))
if not alg.supportInPlaceEdit(active_layer):
raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
except QgsProcessingException as e:
if raise_exceptions:
raise e
QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical)
if feedback is not None:
feedback.reportError(getattr(e, 'msg', str(e)), fatalError=True)
return False, {}
if not active_layer.selectedFeatureIds():
active_layer.selectAll()
# Make sure we are working on selected features only
parameters['INPUT'] = QgsProcessingFeatureSourceDefinition(active_layer.id(), True)
parameters['OUTPUT'] = 'memory:'
req = QgsFeatureRequest(QgsExpression(r"$id < 0"))
req.setFlags(QgsFeatureRequest.NoGeometry)
req.setSubsetOfAttributes([])
# Start the execution
# If anything goes wrong and raise_exceptions is True an exception
# is raised, else the execution is aborted and the error reported in
# the feedback
try:
new_feature_ids = []
active_layer.beginEditCommand(alg.displayName())
# Checks whether the algorithm has a processFeature method
if hasattr(alg, 'processFeature'): # in-place feature editing
# Make a clone or it will crash the second time the dialog
# is opened and run
alg = alg.create()
if not alg.prepare(parameters, context, feedback):
raise QgsProcessingException(tr("Could not prepare selected algorithm."))
# Check again for compatibility after prepare
if not alg.supportInPlaceEdit(active_layer):
raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
field_idxs = range(len(active_layer.fields()))
iterator_req = QgsFeatureRequest(active_layer.selectedFeatureIds())
iterator_req.setInvalidGeometryCheck(context.invalidGeometryCheck())
feature_iterator = active_layer.getFeatures(iterator_req)
step = 100 / len(active_layer.selectedFeatureIds()) if active_layer.selectedFeatureIds() else 1
for current, f in enumerate(feature_iterator):
feedback.setProgress(current * step)
if feedback.isCanceled():
break
# need a deep copy, because python processFeature implementations may return
# a shallow copy from processFeature
input_feature = QgsFeature(f)
new_features = alg.processFeature(input_feature, context, feedback)
new_features = QgsVectorLayerUtils.makeFeaturesCompatible(new_features, active_layer)
if len(new_features) == 0:
active_layer.deleteFeature(f.id())
elif len(new_features) == 1:
new_f = new_features[0]
if not f.geometry().equals(new_f.geometry()):
active_layer.changeGeometry(f.id(), new_f.geometry())
if f.attributes() != new_f.attributes():
active_layer.changeAttributeValues(f.id(), dict(zip(field_idxs, new_f.attributes())), dict(zip(field_idxs, f.attributes())))
new_feature_ids.append(f.id())
else:
active_layer.deleteFeature(f.id())
# Get the new ids
old_ids = set([f.id() for f in active_layer.getFeatures(req)])
if not active_layer.addFeatures(new_features):
raise QgsProcessingException(tr("Error adding processed features back into the layer."))
new_ids = set([f.id() for f in active_layer.getFeatures(req)])
new_feature_ids += list(new_ids - old_ids)
results, ok = {}, True
else: # Traditional 'run' with delete and add features cycle
# There is no way to know if some features have been skipped
# due to invalid geometries
if context.invalidGeometryCheck() == QgsFeatureRequest.GeometrySkipInvalid:
selected_ids = active_layer.selectedFeatureIds()
else:
selected_ids = []
results, ok = alg.run(parameters, context, feedback)
if ok:
result_layer = QgsProcessingUtils.mapLayerFromString(results['OUTPUT'], context)
# TODO: check if features have changed before delete/add cycle
new_features = []
# Check if there are any skipped features
if context.invalidGeometryCheck() == QgsFeatureRequest.GeometrySkipInvalid:
missing_ids = list(set(selected_ids) - set(result_layer.allFeatureIds()))
if missing_ids:
for f in active_layer.getFeatures(QgsFeatureRequest(missing_ids)):
if not f.geometry().isGeosValid():
new_features.append(f)
active_layer.deleteFeatures(active_layer.selectedFeatureIds())
for f in result_layer.getFeatures():
new_features.extend(QgsVectorLayerUtils.
makeFeaturesCompatible([f], active_layer))
# Get the new ids
old_ids = set([f.id() for f in active_layer.getFeatures(req)])
if not active_layer.addFeatures(new_features):
raise QgsProcessingException(tr("Error adding processed features back into the layer."))
new_ids = set([f.id() for f in active_layer.getFeatures(req)])
new_feature_ids += list(new_ids - old_ids)
active_layer.endEditCommand()
if ok and new_feature_ids:
active_layer.selectByIds(new_feature_ids)
elif not ok:
active_layer.rollBack()
return ok, results
except QgsProcessingException as e:
active_layer.endEditCommand()
active_layer.rollBack()
if raise_exceptions:
raise e
QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical)
if feedback is not None:
feedback.reportError(getattr(e, 'msg', str(e)), fatalError=True)
return False, {}
def processAlgorithm(self, progress):
layerA = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_A))
splitLayer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_B))
sameLayer = self.getParameterValue(
self.INPUT_A) == self.getParameterValue(self.INPUT_B)
fieldList = layerA.fields()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fieldList, layerA.wkbType(), layerA.crs())
spatialIndex = QgsSpatialIndex()
splitGeoms = {}
request = QgsFeatureRequest()
request.setSubsetOfAttributes([])
for aSplitFeature in vector.features(splitLayer, request):
splitGeoms[aSplitFeature.id()] = aSplitFeature.geometry()
spatialIndex.insertFeature(aSplitFeature)
# honor the case that user has selection on split layer and has setting "use selection"
outFeat = QgsFeature()
features = vector.features(layerA)
if len(features) == 0:
total = 100
else:
total = 100.0 / float(len(features))
multiGeoms = 0 # how many multi geometries were encountered
for current, inFeatA in enumerate(features):
inGeom = inFeatA.geometry()
if inGeom.isMultipart():
multiGeoms += 1
# MultiGeometries are not allowed because the result of a splitted part cannot be clearly defined:
# 1) add both new parts as new features
# 2) store one part as a new feature and the other one as part of the multi geometry
# 2a) which part should be which, seems arbitrary
else:
attrsA = inFeatA.attributes()
outFeat.setAttributes(attrsA)
inGeoms = [inGeom]
lines = spatialIndex.intersects(inGeom.boundingBox())
if len(lines) > 0: # has intersection of bounding boxes
splittingLines = []
engine = QgsGeometry.createGeometryEngine(
inGeom.geometry())
engine.prepareGeometry()
for i in lines:
try:
splitGeom = splitGeoms[i]
except:
continue
# check if trying to self-intersect
if sameLayer:
if inFeatA.id() == i:
continue
if engine.intersects(splitGeom.geometry()):
splittingLines.append(splitGeom)
if len(splittingLines) > 0:
for splitGeom in splittingLines:
splitterPList = None
outGeoms = []
split_geom_engine = QgsGeometry.createGeometryEngine(
splitGeom.geometry())
split_geom_engine.prepareGeometry()
while len(inGeoms) > 0:
inGeom = inGeoms.pop()
if split_geom_engine.intersects(
inGeom.geometry()):
inPoints = vector.extractPoints(inGeom)
if splitterPList == None:
splitterPList = vector.extractPoints(
splitGeom)
try:
result, newGeometries, topoTestPoints = inGeom.splitGeometry(
splitterPList, False)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_WARNING,
self.
tr('Geometry exception while splitting'
))
result = 1
# splitGeometry: If there are several intersections
# between geometry and splitLine, only the first one is considered.
if result == 0: # split occurred
if inPoints == vector.extractPoints(
inGeom):
# bug in splitGeometry: sometimes it returns 0 but
# the geometry is unchanged
QgsMessageLog.logMessage(
"appending")
outGeoms.append(inGeom)
else:
inGeoms.append(inGeom)
for aNewGeom in newGeometries:
inGeoms.append(aNewGeom)
else:
QgsMessageLog.logMessage(
"appending else")
outGeoms.append(inGeom)
else:
outGeoms.append(inGeom)
inGeoms = outGeoms
for aGeom in inGeoms:
passed = True
if QgsWkbTypes.geometryType( aGeom.wkbType() ) == QgsWkbTypes.LineGeometry \
and not QgsWkbTypes.isMultiType(aGeom.wkbType()):
passed = len(aGeom.asPolyline()) > 2
if not passed:
passed = (len(aGeom.asPolyline()) == 2
and aGeom.asPolyline()[0] !=
aGeom.asPolyline()[1])
# sometimes splitting results in lines of zero length
if passed:
outFeat.setGeometry(aGeom)
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
if multiGeoms > 0:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('Feature geometry error: %s input features ignored due to multi-geometry.'
) % str(multiGeoms))
del writer
def data( self ):
if self._dataLoaded:
return self._x, self._y, self._z
self._dataLoaded=True
self._x = None
self._y = None
self._z = None
self._gridShape=None
self._gridTested=False
self._dataLoaded=True
source=self._source
zField=self._zField
if source is None or zField is None or zField == '':
return self._x, self._y, self._z
discardTolerance=self._discardTolerance
feedback=self._feedback
total = source.featureCount()
percent = 100.0 / total if total > 0 else 0
count = 0
x = list()
y = list()
z = list()
try:
if source.fields().lookupField(zField) >= 0:
zField='"'+zField.replace('"','""')+'"'
expression=QgsExpression(zField)
if expression.hasParserError():
raise ContourError(tr("Cannot parse")+" "+zField)
fields=source.fields()
context=QgsExpressionContext()
context.setFields(fields)
if not expression.prepare(context):
raise ContourError(tr("Cannot evaluate value")+ " "+zField)
request = QgsFeatureRequest()
request.setSubsetOfAttributes( expression.referencedColumns(),fields)
if self._sourceFids is not None:
request.setFilterFids(self._sourceFids)
for current,feat in enumerate(source.getFeatures( request )):
try:
if feedback.isCanceled():
raise ContourError('Cancelled by user')
feedback.setProgress(int(current * percent))
context.setFeature(feat)
zval=expression.evaluate(context)
try:
zval=float(zval)
except ValueError:
raise ContourError(tr("Z value {0} is not number")
.format(zval))
if zval is not None:
fgeom = feat.geometry()
if QgsWkbTypes.flatType(fgeom.wkbType()) != QgsWkbTypes.Point:
raise ContourError(tr("Invalid geometry type for contouring - must be point geometry"))
geom=fgeom.asPoint()
x.append(geom.x())
y.append(geom.y())
z.append(zval)
except Exception as ex:
raise
count = count + 1
npt=len(x)
if npt > 0:
x=np.array(x)
y=np.array(y)
z=np.array(z)
if discardTolerance > 0:
index=ContourUtils.discardDuplicatePoints(
x,y,discardTolerance,self.crs().isGeographic())
npt1=len(index)
if npt1 < npt:
x=x[index]
y=y[index]
z=z[index]
feedback.pushInfo(tr("{0} near duplicate points discarded - tolerance {1}")
.format(npt-npt1,discardTolerance))
except ContourError as ce:
feedback.reportError(ce.message())
feedback.setProgress(0)
return self._x,self._y,self._z
finally:
feedback.setProgress(0)
if len(x) < 3:
feedback.reportError(tr("Too few points to contour"))
return self._x, self._y, self._z
self._x=x
self._y=y
self._z=z
return self._x, self._y, self._z
def setSelectFeatures(canvas,
selectGeometry,
doContains,
doDifference,
singleSelect=None):
"""
QgsMapCanvas* canvas,
QgsGeometry* selectGeometry,
bool doContains,
bool doDifference,
bool singleSelect
"""
if selectGeometry.type() != QGis.Polygon:
return
vlayer = getCurrentVectorLayer(canvas)
if vlayer == None:
return
#toLayerCoordinates will throw an exception for any 'invalid' points in
#the rubber band.
#For example, if you project a world map onto a globe using EPSG 2163
#and then click somewhere off the globe, an exception will be thrown.
selectGeomTrans = QgsGeometry(selectGeometry)
if canvas.mapSettings().hasCrsTransformEnabled():
try:
ct = QgsCoordinateTransform(canvas.mapSettings().destinationCrs(),
vlayer.crs())
selectGeomTrans.transform(ct)
except QgsCsException as cse:
Q_UNUSED(cse)
#catch exception for 'invalid' point and leave existing selection unchanged
"""
QgsLogger::warning( "Caught CRS exception " + QString( __FILE__ ) + ": " + QString::number( __LINE__ ) );
QgisApp::instance()->messageBar()->pushMessage(
QObject::tr( "CRS Exception" ),
QObject::tr( "Selection extends beyond layer's coordinate system" ),
QgsMessageBar::WARNING,
QgisApp::instance()->messageTimeout() );
"""
return
QApplication.setOverrideCursor(Qt.WaitCursor)
"""
QgsDebugMsg( "Selection layer: " + vlayer->name() );
QgsDebugMsg( "Selection polygon: " + selectGeomTrans.exportToWkt() );
QgsDebugMsg( "doContains: " + QString( doContains ? "T" : "F" ) );
QgsDebugMsg( "doDifference: " + QString( doDifference ? "T" : "F" ) );
"""
context = QgsRenderContext().fromMapSettings(canvas.mapSettings())
r = vlayer.rendererV2()
if r:
r.startRender(context, vlayer.pendingFields())
request = QgsFeatureRequest()
request.setFilterRect(selectGeomTrans.boundingBox())
request.setFlags(QgsFeatureRequest.ExactIntersect)
if r:
request.setSubsetOfAttributes(r.usedAttributes(),
vlayer.pendingFields())
else:
request.setSubsetOfAttributes(QgsAttributeList)
fit = vlayer.getFeatures(request)
newSelectedFeatures = [] #QgsFeatureIds
f = QgsFeature()
closestFeatureId = 0 #QgsFeatureId
foundSingleFeature = False
#double closestFeatureDist = std::numeric_limits<double>::max();
closestFeatureDist = sys.float_info.max
while fit.nextFeature(f):
# make sure to only use features that are visible
if r and not r.willRenderFeature(f):
continue
g = QgsGeometry(f.geometry())
if doContains:
if not selectGeomTrans.contains(g):
continue
else:
if not selectGeomTrans.intersects(g):
continue
if singleSelect:
foundSingleFeature = True
distance = float(g.distance(selectGeomTrans))
if (distance <= closestFeatureDist):
closestFeatureDist = distance
closestFeatureId = f.id()
else:
newSelectedFeatures.insert(0, f.id())
if singleSelect and foundSingleFeature:
newSelectedFeatures.insert(0, closestFeatureId)
if r:
r.stopRender(context)
#QgsDebugMsg( "Number of new selected features: " + QString::number( newSelectedFeatures.size() )
if doDifference:
layerSelectedFeatures = vlayer.selectedFeaturesIds()
selectedFeatures = [] #QgsFeatureIds
deselectedFeatures = [] # QgsFeatureIds
# i = QgsFeatureIds.const_iterator(newSelectedFeatures.constEnd())
# while i != newSelectedFeatures.constBegin():
# i = i - 1
# if layerSelectedFeatures.contains(i):
# deselectedFeatures.insert(0, i)
# else:
# selectedFeatures.insert(0, i)
for item in newSelectedFeatures:
if item in layerSelectedFeatures:
deselectedFeatures.insert(0, item)
else:
selectedFeatures.insert(0, item)
vlayer.modifySelection(selectedFeatures, deselectedFeatures)
else:
vlayer.setSelectedFeatures(newSelectedFeatures)
QApplication.restoreOverrideCursor()
"""
def processAlgorithm(self, parameters, context, feedback):
# Get variables from dialog
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
field_name = self.parameterAsString(parameters, self.FIELD, context)
kneighbors = self.parameterAsInt(parameters, self.KNEIGHBORS, context)
use_field = bool(field_name)
field_index = -1
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 20))
current = 0
# Get properties of the field the grouping is based on
if use_field:
field_index = source.fields().lookupField(field_name)
if field_index >= 0:
fields.append(source.fields()[field_index]) # Add a field with the name of the grouping field
# Initialize writer
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Polygon, source.sourceCrs())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
success = False
fid = 0
# Get unique values of grouping field
unique_values = source.uniqueValues(field_index)
total = 100.0 / float(source.featureCount() * len(unique_values))
for unique in unique_values:
points = []
filter = QgsExpression.createFieldEqualityExpression(field_name, unique)
request = QgsFeatureRequest().setFilterExpression(filter)
request.setSubsetOfAttributes([])
# Get features with the grouping attribute equal to the current grouping value
features = source.getFeatures(request)
for in_feature in features:
if feedback.isCanceled():
break
# Add points or vertices of more complex geometry
points.extend(extract_points(in_feature.geometry()))
current += 1
feedback.setProgress(int(current * total))
# A minimum of 3 points is necessary to proceed
if len(points) >= 3:
out_feature = QgsFeature()
the_hull = concave_hull(points, kneighbors)
if the_hull:
vertex = [QgsPointXY(point[0], point[1]) for point in the_hull]
poly = QgsGeometry().fromPolygonXY([vertex])
out_feature.setGeometry(poly)
# Give the polygon the same attribute as the point grouping attribute
out_feature.setAttributes([fid, unique])
sink.addFeature(out_feature, QgsFeatureSink.FastInsert)
success = True # at least one polygon created
fid += 1
if not success:
raise QgsProcessingException('No hulls could be created. Most likely there were not at least three unique points in any of the groups.')
else:
# Field parameter provided but can't read from it
raise QgsProcessingException('Unable to find grouping field')
else:
# Not grouped by field
# Initialize writer
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Polygon, source.sourceCrs())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
points = []
request = QgsFeatureRequest()
request.setSubsetOfAttributes([])
features = source.getFeatures(request) # Get all features
total = 100.0 / source.featureCount() if source.featureCount() else 0
for in_feature in features:
if feedback.isCanceled():
break
# Add points or vertices of more complex geometry
points.extend(extract_points(in_feature.geometry()))
current += 1
feedback.setProgress(int(current * total))
# A minimum of 3 points is necessary to proceed
if len(points) >= 3:
out_feature = QgsFeature()
the_hull = concave_hull(points, kneighbors)
if the_hull:
vertex = [QgsPointXY(point[0], point[1]) for point in the_hull]
poly = QgsGeometry().fromPolygonXY([vertex])
out_feature.setGeometry(poly)
out_feature.setAttributes([0])
sink.addFeature(out_feature, QgsFeatureSink.FastInsert)
else:
# the_hull returns None only when there are less than three points after cleaning
raise QgsProcessingException('At least three unique points are required to create a concave hull.')
else:
raise QgsProcessingException('At least three points are required to create a concave hull.')
return {self.OUTPUT: dest_id}
def analysis_summary(aggregate_hazard, analysis, callback=None):
"""Compute the summary from the aggregate hazard to analysis.
Source layer :
| haz_id | haz_class | aggr_id | aggr_name | total_feature |
Target layer :
| analysis_id |
Output layer :
| analysis_id | count_hazard_class | affected_count | total |
:param aggregate_hazard: The layer to aggregate vector layer.
:type aggregate_hazard: QgsVectorLayer
:param analysis: The target vector layer where to write statistics.
:type analysis: QgsVectorLayer
:param callback: A function to all to indicate progress. The function
should accept params 'current' (int), 'maximum' (int) and 'step' (str).
Defaults to None.
:type callback: function
:return: The new target layer with summary.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = summary_3_analysis_steps['output_layer_name']
processing_step = summary_3_analysis_steps['step_name']
source_fields = aggregate_hazard.keywords['inasafe_fields']
target_fields = analysis.keywords['inasafe_fields']
target_compulsory_fields = [
analysis_id_field,
analysis_name_field,
]
check_inputs(target_compulsory_fields, target_fields)
source_compulsory_fields = [
aggregation_id_field,
aggregation_name_field,
hazard_id_field,
hazard_class_field,
total_field
]
check_inputs(source_compulsory_fields, source_fields)
absolute_values = create_absolute_values_structure(
aggregate_hazard, ['all'])
hazard_class = source_fields[hazard_class_field['key']]
hazard_class_index = aggregate_hazard.fieldNameIndex(hazard_class)
unique_hazard = aggregate_hazard.uniqueValues(hazard_class_index)
hazard_keywords = aggregate_hazard.keywords['hazard_keywords']
classification = hazard_keywords['classification']
total = source_fields[total_field['key']]
flat_table = FlatTable('hazard_class')
# First loop over the aggregate_hazard layer
request = QgsFeatureRequest()
request.setSubsetOfAttributes(
[hazard_class, total], aggregate_hazard.fields())
request.setFlags(QgsFeatureRequest.NoGeometry)
for area in aggregate_hazard.getFeatures():
hazard_value = area[hazard_class_index]
value = area[total]
if not value or isinstance(value, QPyNullVariant) or isnan(value):
# For isnan, see ticket #3812
value = 0
if not hazard_value or isinstance(hazard_value, QPyNullVariant):
hazard_value = 'NULL'
flat_table.add_value(
value,
hazard_class=hazard_value
)
# We summarize every absolute values.
for field, field_definition in absolute_values.iteritems():
value = area[field]
if not value or isinstance(value, QPyNullVariant):
value = 0
field_definition[0].add_value(
value,
all='all'
)
analysis.startEditing()
shift = analysis.fields().count()
counts = [
total_affected_field,
total_not_affected_field,
total_not_exposed_field,
total_field]
add_fields(
analysis,
absolute_values,
counts,
unique_hazard,
hazard_count_field)
affected_sum = 0
not_affected_sum = 0
not_exposed_sum = 0
for area in analysis.getFeatures(request):
total = 0
for i, val in enumerate(unique_hazard):
if not val or isinstance(val, QPyNullVariant):
val = 'NULL'
sum = flat_table.get_value(hazard_class=val)
total += sum
analysis.changeAttributeValue(area.id(), shift + i, sum)
affected = post_processor_affected_function(
classification=classification, hazard_class=val)
if affected == not_exposed_class['key']:
not_exposed_sum += sum
elif affected:
affected_sum += sum
else:
not_affected_sum += sum
# Affected field
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard), affected_sum)
# Not affected field
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard) + 1, not_affected_sum)
# Not exposed field
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard) + 2, not_exposed_sum)
# Total field
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard) + 3, total)
# Any absolute postprocessors
for i, field in enumerate(absolute_values.itervalues()):
value = field[0].get_value(
all='all'
)
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard) + 4 + i, value)
# Sanity check ± 1 to the result. Disabled for now as it seems ± 1 is not
# enough. ET 13/02/17
# total_computed = (
# affected_sum + not_affected_sum + not_exposed_sum)
# if not -1 < (total_computed - total) < 1:
# raise ComputationError
analysis.commitChanges()
analysis.keywords['title'] = layer_purpose_analysis_impacted['name']
if qgis_version() >= 21600:
analysis.setName(analysis.keywords['title'])
else:
analysis.setLayerName(analysis.keywords['title'])
analysis.keywords['layer_purpose'] = layer_purpose_analysis_impacted['key']
check_layer(analysis)
return analysis
def execute_in_place_run(alg, active_layer, parameters, context=None, feedback=None, raise_exceptions=False):
"""Executes an algorithm modifying features in-place in the input layer.
The input layer must be editable or an exception is raised.
:param alg: algorithm to run
:type alg: QgsProcessingAlgorithm
:param active_layer: the editable layer
:type active_layer: QgsVectoLayer
:param parameters: parameters of the algorithm
:type parameters: dict
:param context: context, defaults to None
:param context: QgsProcessingContext, optional
:param feedback: feedback, defaults to None
:param feedback: QgsProcessingFeedback, optional
:raises QgsProcessingException: raised when the layer is not editable or the layer cannot be found in the current project
:return: a tuple with true if success and results
:rtype: tuple
"""
if feedback is None:
feedback = QgsProcessingFeedback()
if context is None:
context = dataobjects.createContext(feedback)
if active_layer is None or not active_layer.isEditable():
raise QgsProcessingException(tr("Layer is not editable or layer is None."))
if not alg.supportInPlaceEdit(active_layer):
raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
parameters['OUTPUT'] = 'memory:'
try:
new_feature_ids = []
active_layer.beginEditCommand(alg.name())
req = QgsFeatureRequest(QgsExpression(r"$id < 0"))
req.setFlags(QgsFeatureRequest.NoGeometry)
req.setSubsetOfAttributes([])
# Checks whether the algorithm has a processFeature method
if hasattr(alg, 'processFeature'): # in-place feature editing
# Make a clone or it will crash the second time the dialog
# is opened and run
alg = alg.create()
if not alg.prepare(parameters, context, feedback):
raise QgsProcessingException(tr("Could not prepare selected algorithm."))
# Check again for compatibility after prepare
if not alg.supportInPlaceEdit(active_layer):
raise QgsProcessingException(tr("Selected algorithm and parameter configuration are not compatible with in-place modifications."))
field_idxs = range(len(active_layer.fields()))
feature_iterator = active_layer.getFeatures(QgsFeatureRequest(active_layer.selectedFeatureIds())) if parameters['INPUT'].selectedFeaturesOnly else active_layer.getFeatures()
for f in feature_iterator:
new_features = alg.processFeature(f, context, feedback)
new_features = make_features_compatible(new_features, active_layer)
if len(new_features) == 0:
active_layer.deleteFeature(f.id())
elif len(new_features) == 1:
new_f = new_features[0]
if not f.geometry().equals(new_f.geometry()):
active_layer.changeGeometry(f.id(), new_f.geometry())
if f.attributes() != new_f.attributes():
active_layer.changeAttributeValues(f.id(), dict(zip(field_idxs, new_f.attributes())), dict(zip(field_idxs, f.attributes())))
new_feature_ids.append(f.id())
else:
active_layer.deleteFeature(f.id())
# Get the new ids
old_ids = set([f.id() for f in active_layer.getFeatures(req)])
if not active_layer.addFeatures(new_features):
raise QgsProcessingException(tr("Error adding processed features back into the layer."))
new_ids = set([f.id() for f in active_layer.getFeatures(req)])
new_feature_ids += list(new_ids - old_ids)
results, ok = {}, True
else: # Traditional 'run' with delete and add features cycle
results, ok = alg.run(parameters, context, feedback)
if ok:
result_layer = QgsProcessingUtils.mapLayerFromString(results['OUTPUT'], context)
# TODO: check if features have changed before delete/add cycle
active_layer.deleteFeatures(active_layer.selectedFeatureIds())
new_features = []
for f in result_layer.getFeatures():
new_features.extend(make_features_compatible([f], active_layer))
# Get the new ids
old_ids = set([f.id() for f in active_layer.getFeatures(req)])
if not active_layer.addFeatures(new_features):
raise QgsProcessingException(tr("Error adding processed features back into the layer."))
new_ids = set([f.id() for f in active_layer.getFeatures(req)])
new_feature_ids += list(new_ids - old_ids)
active_layer.endEditCommand()
if ok and new_feature_ids:
active_layer.selectByIds(new_feature_ids)
elif not ok:
active_layer.rollBack()
return ok, results
except QgsProcessingException as e:
active_layer.endEditCommand()
active_layer.rollBack()
if raise_exceptions:
raise e
QgsMessageLog.logMessage(str(sys.exc_info()[0]), 'Processing', Qgis.Critical)
if feedback is not None:
feedback.reportError(getattr(e, 'msg', str(e)))
return False, {}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
line_source = self.parameterAsSource(parameters, self.LINES, context)
sameLayer = parameters[self.INPUT] == parameters[self.LINES]
(sink, dest_id) = self.parameterAsSink(
parameters, self.OUTPUT, context, source.fields(),
QgsWkbTypes.multiType(source.wkbType()), source.sourceCrs())
spatialIndex = QgsSpatialIndex()
splitGeoms = {}
request = QgsFeatureRequest()
request.setSubsetOfAttributes([])
request.setDestinationCrs(source.sourceCrs())
for aSplitFeature in line_source.getFeatures(request):
if feedback.isCanceled():
break
splitGeoms[aSplitFeature.id()] = aSplitFeature.geometry()
spatialIndex.insertFeature(aSplitFeature)
# honor the case that user has selection on split layer and has setting "use selection"
outFeat = QgsFeature()
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 100
for current, inFeatA in enumerate(features):
if feedback.isCanceled():
break
inGeom = inFeatA.geometry()
attrsA = inFeatA.attributes()
outFeat.setAttributes(attrsA)
if inGeom.isMultipart():
inGeoms = []
for g in inGeom.asGeometryCollection():
inGeoms.append(g)
else:
inGeoms = [inGeom]
lines = spatialIndex.intersects(inGeom.boundingBox())
if len(lines) > 0: # has intersection of bounding boxes
splittingLines = []
engine = QgsGeometry.createGeometryEngine(inGeom.geometry())
engine.prepareGeometry()
for i in lines:
try:
splitGeom = splitGeoms[i]
except:
continue
# check if trying to self-intersect
if sameLayer:
if inFeatA.id() == i:
continue
if engine.intersects(splitGeom.geometry()):
splittingLines.append(splitGeom)
if len(splittingLines) > 0:
for splitGeom in splittingLines:
splitterPList = None
outGeoms = []
split_geom_engine = QgsGeometry.createGeometryEngine(
splitGeom.geometry())
split_geom_engine.prepareGeometry()
while len(inGeoms) > 0:
if feedback.isCanceled():
break
inGeom = inGeoms.pop()
if inGeom.isNull(
): # this has been encountered and created a run-time error
continue
if split_geom_engine.intersects(inGeom.geometry()):
inPoints = vector.extractPoints(inGeom)
if splitterPList is None:
splitterPList = vector.extractPoints(
splitGeom)
try:
result, newGeometries, topoTestPoints = inGeom.splitGeometry(
splitterPList, False)
except:
feedback.reportError(
self.
tr('Geometry exception while splitting'
))
result = 1
# splitGeometry: If there are several intersections
# between geometry and splitLine, only the first one is considered.
if result == 0: # split occurred
if inPoints == vector.extractPoints(
inGeom):
# bug in splitGeometry: sometimes it returns 0 but
# the geometry is unchanged
outGeoms.append(inGeom)
else:
inGeoms.append(inGeom)
for aNewGeom in newGeometries:
inGeoms.append(aNewGeom)
else:
outGeoms.append(inGeom)
else:
outGeoms.append(inGeom)
inGeoms = outGeoms
parts = []
for aGeom in inGeoms:
if feedback.isCanceled():
break
passed = True
if QgsWkbTypes.geometryType(
aGeom.wkbType()) == QgsWkbTypes.LineGeometry:
numPoints = aGeom.geometry().numPoints()
if numPoints <= 2:
if numPoints == 2:
passed = not aGeom.geometry().isClosed(
) # tests if vertex 0 = vertex 1
else:
passed = False
# sometimes splitting results in lines of zero length
if passed:
parts.append(aGeom)
if len(parts) > 0:
outFeat.setGeometry(QgsGeometry.collectGeometry(parts))
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def analysis_summary(aggregate_hazard, analysis):
"""Compute the summary from the aggregate hazard to analysis.
Source layer :
| haz_id | haz_class | aggr_id | aggr_name | total_feature |
Target layer :
| analysis_name |
Output layer :
| analysis_name | count_hazard_class | affected_count | total |
:param aggregate_hazard: The layer to aggregate vector layer.
:type aggregate_hazard: QgsVectorLayer
:param analysis: The target vector layer where to write statistics.
:type analysis: QgsVectorLayer
:return: The new target layer with summary.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
source_fields = aggregate_hazard.keywords['inasafe_fields']
target_fields = analysis.keywords['inasafe_fields']
target_compulsory_fields = [
analysis_name_field,
]
check_inputs(target_compulsory_fields, target_fields)
source_compulsory_fields = [
aggregation_id_field, aggregation_name_field, hazard_id_field,
hazard_class_field, total_field
]
check_inputs(source_compulsory_fields, source_fields)
absolute_values = create_absolute_values_structure(aggregate_hazard,
['all'])
hazard_class = source_fields[hazard_class_field['key']]
hazard_class_index = aggregate_hazard.fields().lookupField(hazard_class)
unique_hazard = list(aggregate_hazard.uniqueValues(hazard_class_index))
hazard_keywords = aggregate_hazard.keywords['hazard_keywords']
hazard = hazard_keywords['hazard']
classification = hazard_keywords['classification']
exposure_keywords = aggregate_hazard.keywords['exposure_keywords']
exposure = exposure_keywords['exposure']
total = source_fields[total_field['key']]
flat_table = FlatTable('hazard_class')
# First loop over the aggregate_hazard layer
request = QgsFeatureRequest()
request.setSubsetOfAttributes([hazard_class, total],
aggregate_hazard.fields())
request.setFlags(QgsFeatureRequest.NoGeometry)
for area in aggregate_hazard.getFeatures():
hazard_value = area[hazard_class_index]
value = area[total]
if (value == '' or value is None or isnan(value)
or (hasattr(value, 'isNull') and value.isNull())):
# For isnan, see ticket #3812
value = 0
if (hazard_value == '' or hazard_value is None or
(hasattr(hazard_value, 'isNull') and hazard_value.isNull())):
hazard_value = 'NULL'
flat_table.add_value(value, hazard_class=hazard_value)
# We summarize every absolute values.
for field, field_definition in list(absolute_values.items()):
value = area[field]
if (value == '' or value is None
or (hasattr(value, 'isNull') and value.isNull())):
value = 0
field_definition[0].add_value(value, all='all')
analysis.startEditing()
shift = analysis.fields().count()
counts = [
total_affected_field, total_not_affected_field, total_exposed_field,
total_not_exposed_field, total_field
]
dynamic_structure = [
[hazard_count_field, unique_hazard],
]
add_fields(analysis, absolute_values, counts, dynamic_structure)
affected_sum = 0
not_affected_sum = 0
not_exposed_sum = 0
# Summarization
summary_values = {}
for key, summary_rule in list(summary_rules.items()):
input_field = summary_rule['input_field']
case_field = summary_rule['case_field']
if aggregate_hazard.fields().lookupField(input_field['field_name']) \
== -1:
continue
if aggregate_hazard.fields().lookupField(case_field['field_name']) \
== -1:
continue
summary_value = 0
for area in aggregate_hazard.getFeatures():
case_value = area[case_field['field_name']]
if case_value in summary_rule['case_values']:
summary_value += area[input_field['field_name']]
summary_values[key] = summary_value
for area in analysis.getFeatures(request):
total = 0
for i, val in enumerate(unique_hazard):
if (val == '' or val is None
or (hasattr(val, 'isNull') and val.isNull())):
val = 'NULL'
sum = flat_table.get_value(hazard_class=val)
total += sum
analysis.changeAttributeValue(area.id(), shift + i, sum)
affected = post_processor_affected_function(
exposure=exposure,
hazard=hazard,
classification=classification,
hazard_class=val)
if affected == not_exposed_class['key']:
not_exposed_sum += sum
elif affected:
affected_sum += sum
else:
not_affected_sum += sum
# Total Affected field
analysis.changeAttributeValue(area.id(), shift + len(unique_hazard),
affected_sum)
# Total Not affected field
analysis.changeAttributeValue(area.id(),
shift + len(unique_hazard) + 1,
not_affected_sum)
# Total Exposed field
analysis.changeAttributeValue(area.id(),
shift + len(unique_hazard) + 2,
total - not_exposed_sum)
# Total Not exposed field
analysis.changeAttributeValue(area.id(),
shift + len(unique_hazard) + 3,
not_exposed_sum)
# Total field
analysis.changeAttributeValue(area.id(),
shift + len(unique_hazard) + 4, total)
# Any absolute postprocessors
for i, field in enumerate(absolute_values.values()):
value = field[0].get_value(all='all')
analysis.changeAttributeValue(area.id(),
shift + len(unique_hazard) + 5 + i,
value)
# Summarizer of custom attributes
for key, summary_value in list(summary_values.items()):
summary_field = summary_rules[key]['summary_field']
field = create_field_from_definition(summary_field)
analysis.addAttribute(field)
field_index = analysis.fields().lookupField(field.name())
# noinspection PyTypeChecker
analysis.keywords['inasafe_fields'][summary_field['key']] = (
summary_field['field_name'])
analysis.changeAttributeValue(area.id(), field_index,
summary_value)
# Sanity check ± 1 to the result. Disabled for now as it seems ± 1 is not
# enough. ET 13/02/17
# total_computed = (
# affected_sum + not_affected_sum + not_exposed_sum)
# if not -1 < (total_computed - total) < 1:
# raise ComputationError
analysis.commitChanges()
analysis.keywords['title'] = layer_purpose_analysis_impacted['name']
if qgis_version() >= 21600:
analysis.setName(analysis.keywords['title'])
else:
analysis.setLayerName(analysis.keywords['title'])
analysis.keywords['layer_purpose'] = layer_purpose_analysis_impacted['key']
check_layer(analysis)
return analysis
def processing(self):
#get and check layer
active_layer = self.get_active_layer()
if not active_layer:
# may be need to disable form?
return
data_provider = active_layer.dataProvider()
#check edit mode
if not active_layer.isEditable():
QMessageBox.warning(
self, self.tr('FieldPyculator warning'),
self.
tr('Layer is not in edit mode! Please start editing the layer!'
))
return
start = datetime.datetime.now()
new_ns = {}
#run global code
if self.ui.grpGlobalExpression.isChecked():
try:
code = unicode(self.ui.txtGlobalExp.toPlainText())
bytecode = compile(code, '<string>', 'exec')
exec bytecode in new_ns
except:
QMessageBox.critical(
self, self.tr('FieldPyculator code execute error'),
(self.tr('Global code block can\'t be executed!\n{0}: {1}')
).format(unicode(sys.exc_info()[0].__name__),
unicode(sys.exc_info()[1])))
return
code = unicode(self.ui.txtFieldExp.toPlainText())
#TODO: check 'result' existing in text of code???!!!
#replace all fields tags
field_map = data_provider.fields()
for field in field_map:
field_name = unicode(field.name())
replval = '__attr[\'' + field_name + '\']'
code = code.replace('<' + field_name + '>', replval)
#replace all special vars
code = code.replace('$id', '__id')
code = code.replace('$geom', '__geom')
#is it need: $area, $length, $x, $y????
#print code #debug
#search needed vars (hmmm... comments?!)
need_id = code.find('__id') != -1
need_geom = code.find('__geom') != -1
need_attrs = code.find('__attr') != -1
#compile
try:
bytecode = compile(code, '<string>', 'exec')
except:
QMessageBox.critical(
self, self.tr('FieldPyculator code execute error'),
(self.tr('Field code block can\'t be executed!\n{0}: {1}')
).format(unicode(sys.exc_info()[0].__name__),
unicode(sys.exc_info()[1])))
return
#get num of updating field
field_num = data_provider.fieldNameIndex(
self.ui.cmbUpdateField.currentText())
#setup progress bar
self.ui.prgTotal.setValue(0)
#run
if not self.ui.chkOnlySelected.isChecked():
features_for_update = data_provider.featureCount()
request = QgsFeatureRequest()
if not need_geom:
request.setFlags(QgsFeatureRequest.NoGeometry)
if need_attrs:
request.setSubsetOfAttributes(data_provider.attributeIndexes())
else:
request.setSubsetOfAttributes([])
features = active_layer.getFeatures(request)
else:
features_for_update = active_layer.selectedFeatureCount()
features = active_layer.selectedFeatures()
if features_for_update > 0:
self.ui.prgTotal.setMaximum(features_for_update)
for feat in features:
feat_id = feat.id()
#add needed vars
if need_id:
new_ns['__id'] = feat_id
if need_geom:
geom = feat.geometry()
new_ns['__geom'] = geom
if need_attrs:
fields = feat.fields()
attr = {}
for a in fields:
attr[a.name()] = feat[a.name()]
new_ns['__attr'] = attr
#clear old result
if self.RESULT_VAR_NAME in new_ns:
del new_ns[self.RESULT_VAR_NAME]
#exec
try:
exec bytecode in new_ns
except:
QMessageBox.critical(
self, self.tr('FieldPyculator code execute error'),
self.
tr('Field code block can\'t be executed for feature {2}!\n{0}: {1}'
).format(unicode(sys.exc_info()[0].__name__),
unicode(sys.exc_info()[1]), unicode(feat_id)))
return
#check result
if not self.RESULT_VAR_NAME in new_ns:
QMessageBox.critical(
self, self.tr('FieldPyculator code execute error'),
self.
tr('Field code block does not return \'{0}\' variable! Please declare this variable in your code!'
).format(self.RESULT_VAR_NAME))
return
#try assign
try:
active_layer.changeAttributeValue(feat_id, field_num,
new_ns[self.RESULT_VAR_NAME])
except:
QMessageBox.critical(
self, self.tr('FieldPyculator code execute error'),
self.
tr('Result value can\'t be assigned to the feature {2}!\n{0}: {1}'
).format(unicode(sys.exc_info()[0].__name__),
unicode(sys.exc_info()[1]), unicode(feat_id)))
return
self.ui.prgTotal.setValue(self.ui.prgTotal.value() + 1)
stop = datetime.datetime.now()
#workaround for python < 2.7
td = stop - start
if sys.version_info[:2] < (2, 7):
total_sec = (td.microseconds +
(td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
else:
total_sec = td.total_seconds()
QMessageBox.information(
self, self.tr('FieldPyculator code executed successfully'),
(self.tr('Updated {0} features for {1} seconds')).format(
unicode(features_for_update), unicode(total_sec)))
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
value_field_name = self.parameterAsString(parameters, self.VALUES_FIELD_NAME, context)
category_field_names = self.parameterAsFields(parameters, self.CATEGORIES_FIELD_NAME, context)
value_field_index = source.fields().lookupField(value_field_name)
if value_field_index >= 0:
value_field = source.fields().at(value_field_index)
else:
value_field = None
category_field_indexes = [source.fields().lookupField(n) for n in category_field_names]
# generate output fields
fields = QgsFields()
for c in category_field_indexes:
fields.append(source.fields().at(c))
def addField(name):
"""
Adds a field to the output, keeping the same data type as the value_field
"""
field = QgsField(value_field)
field.setName(name)
fields.append(field)
if value_field is None:
field_type = 'none'
fields.append(QgsField('count', QVariant.Int))
elif value_field.isNumeric():
field_type = 'numeric'
fields.append(QgsField('count', QVariant.Int))
fields.append(QgsField('unique', QVariant.Int))
fields.append(QgsField('min', QVariant.Double))
fields.append(QgsField('max', QVariant.Double))
fields.append(QgsField('range', QVariant.Double))
fields.append(QgsField('sum', QVariant.Double))
fields.append(QgsField('mean', QVariant.Double))
fields.append(QgsField('median', QVariant.Double))
fields.append(QgsField('stddev', QVariant.Double))
fields.append(QgsField('minority', QVariant.Double))
fields.append(QgsField('majority', QVariant.Double))
fields.append(QgsField('q1', QVariant.Double))
fields.append(QgsField('q3', QVariant.Double))
fields.append(QgsField('iqr', QVariant.Double))
elif value_field.type() in (QVariant.Date, QVariant.Time, QVariant.DateTime):
field_type = 'datetime'
fields.append(QgsField('count', QVariant.Int))
fields.append(QgsField('unique', QVariant.Int))
fields.append(QgsField('empty', QVariant.Int))
fields.append(QgsField('filled', QVariant.Int))
# keep same data type for these fields
addField('min')
addField('max')
else:
field_type = 'string'
fields.append(QgsField('count', QVariant.Int))
fields.append(QgsField('unique', QVariant.Int))
fields.append(QgsField('empty', QVariant.Int))
fields.append(QgsField('filled', QVariant.Int))
# keep same data type for these fields
addField('min')
addField('max')
fields.append(QgsField('min_length', QVariant.Int))
fields.append(QgsField('max_length', QVariant.Int))
fields.append(QgsField('mean_length', QVariant.Double))
request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
if value_field is not None:
attrs = [value_field_index]
else:
attrs = []
attrs.extend(category_field_indexes)
request.setSubsetOfAttributes(attrs)
features = source.getFeatures(request, QgsProcessingFeatureSource.FlagSkipGeometryValidityChecks)
total = 50.0 / source.featureCount() if source.featureCount() else 0
if field_type == 'none':
values = defaultdict(lambda: 0)
else:
values = defaultdict(list)
for current, feat in enumerate(features):
if feedback.isCanceled():
break
feedback.setProgress(int(current * total))
attrs = feat.attributes()
cat = tuple([attrs[c] for c in category_field_indexes])
if field_type == 'none':
values[cat] += 1
continue
if field_type == 'numeric':
if attrs[value_field_index] == NULL:
continue
else:
value = float(attrs[value_field_index])
elif field_type == 'string':
if attrs[value_field_index] == NULL:
value = ''
else:
value = str(attrs[value_field_index])
elif attrs[value_field_index] == NULL:
value = NULL
else:
value = attrs[value_field_index]
values[cat].append(value)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.NoGeometry, QgsCoordinateReferenceSystem())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
if field_type == 'none':
self.saveCounts(values, sink, feedback)
elif field_type == 'numeric':
self.calcNumericStats(values, sink, feedback)
elif field_type == 'datetime':
self.calcDateTimeStats(values, sink, feedback)
else:
self.calcStringStats(values, sink, feedback)
return {self.OUTPUT: dest_id}
def _remove_features(layer):
"""Remove features which do not have information for InaSAFE or an invalid
geometry.
:param layer: The vector layer.
:type layer: QgsVectorLayer
"""
# Get the layer purpose of the layer.
layer_purpose = layer.keywords['layer_purpose']
layer_subcategory = layer.keywords.get(layer_purpose)
compulsory_field = get_compulsory_fields(layer_purpose, layer_subcategory)
inasafe_fields = layer.keywords['inasafe_fields']
# Compulsory fields can be list of field name or single field name.
# We need to iterate through all of them
field_names = inasafe_fields.get(compulsory_field['key'])
if not isinstance(field_names, list):
field_names = [field_names]
for field_name in field_names:
if not field_name:
message = 'Keyword %s is missing from %s' % (
compulsory_field['key'], layer_purpose)
raise InvalidKeywordsForProcessingAlgorithm(message)
index = layer.fields().lookupField(field_name)
request = QgsFeatureRequest()
request.setSubsetOfAttributes([field_name], layer.fields())
layer.startEditing()
i = 0
for feature in layer.getFeatures(request):
feat_attr = feature.attributes()[index]
if (feat_attr is None
or (hasattr(feat_attr, 'isNull') and feat_attr.isNull())):
if layer_purpose == 'hazard':
# Remove the feature if the hazard is null.
layer.deleteFeature(feature.id())
i += 1
elif layer_purpose == 'aggregation':
# Put the ID if the value is null.
layer.changeAttributeValue(feature.id(), index,
str(feature.id()))
elif layer_purpose == 'exposure':
# Put an empty value, the value mapping will take care of
# it in the 'other' group.
layer.changeAttributeValue(feature.id(), index, '')
# Check if there is en empty geometry.
geometry = feature.geometry()
if not geometry:
layer.deleteFeature(feature.id())
i += 1
continue
# Check if the geometry is empty.
if geometry.isEmpty():
layer.deleteFeature(feature.id())
i += 1
continue
# Check if the geometry is valid.
if not geometry.isGeosValid():
# polygonize can produce some invalid geometries
# For instance a polygon like this, sharing a same point :
# _______
# | ___|__
# | |__| |
# |________|
# layer.deleteFeature(feature.id())
# i += 1
pass
# TODO We need to add more tests
# like checking if the value is in the value_mapping.
layer.commitChanges()
if i:
LOGGER.critical('Features which have been removed from %s : %s' %
(layer.keywords['layer_purpose'], i))
else:
LOGGER.info(
'No feature has been removed from %s during the vector layer '
'preparation' % layer.keywords['layer_purpose'])
def search_data(self, **kwargs):
"""
Get plot geometries associated with parcels, both collected and official, zoom to them, activate map swipe tool
and fill comparison table.
:param kwargs: key-value (field name-field value) to search in parcel tables, both collected and official
Normally, keys are parcel_number, old_parcel_number or FMI, but if duplicates are found, an
additional t_id disambiguates only for the collected source. In the Official source we assume
we will not find duplicates, if there are, we will choose the first record found an will not deal
with letting the user choose one of the duplicates by hand (as we do for the collected source).
"""
self.chk_show_all_plots.setEnabled(False)
self.chk_show_all_plots.setChecked(True)
self.initialize_tools_and_layers() # Reset any filter on layers
already_zoomed_in = False
self.clear_result_table()
search_field = self.cbo_parcel_fields.currentData()
search_value = list(kwargs.values())[0]
# Get OFFICIAL parcel's t_id and get related plot(s)
expression = QgsExpression("{}='{}'".format(search_field,
search_value))
request = QgsFeatureRequest(expression)
field_idx = self.utils._official_layers[PARCEL_TABLE][LAYER].fields(
).indexFromName(ID_FIELD)
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes([field_idx
]) # Note: this adds a new flag
official_parcels = [
feature for feature in self.utils._official_layers[PARCEL_TABLE]
[LAYER].getFeatures(request)
]
if len(official_parcels) > 1:
# We do not expect duplicates in the official source!
pass # We'll choose the first one anyways
elif len(official_parcels) == 0:
print("No parcel found!", search_field, search_value)
official_plot_t_ids = []
if official_parcels:
official_plot_t_ids = self.utils.ladm_data.get_plots_related_to_parcels(
self.utils._official_db, [official_parcels[0][ID_FIELD]],
field_name=ID_FIELD,
plot_layer=self.utils._official_layers[PLOT_TABLE][LAYER],
uebaunit_table=self.utils._official_layers[UEBAUNIT_TABLE]
[LAYER])
if official_plot_t_ids:
self._current_official_substring = "\"{}\" IN ('{}')".format(
ID_FIELD,
"','".join([str(t_id) for t_id in official_plot_t_ids]))
self.parent.request_zoom_to_features(
self.utils._official_layers[PLOT_TABLE][LAYER], list(),
official_plot_t_ids)
already_zoomed_in = True
# Now get COLLECTED parcel's t_id and get related plot(s)
collected_parcel_t_id = None
if 'collected_parcel_t_id' in kwargs:
# This is the case when this panel is called and we already know the parcel number is duplicated
collected_parcel_t_id = kwargs['collected_parcel_t_id']
search_criterion_collected = {
ID_FIELD: collected_parcel_t_id
} # As there are duplicates, we need to use t_ids
else:
# This is the case when:
# + Either this panel was called and we know the parcel number is not duplicated, or
# + This panel was shown without knowing about duplicates (e.g., individual parcel search) and we still
# need to discover whether we have duplicates for this search criterion
search_criterion_collected = {search_field: search_value}
request = QgsFeatureRequest(expression)
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes(
[ID_FIELD], self.utils._layers[PARCEL_TABLE]
[LAYER].fields()) # Note this adds a new flag
collected_parcels = self.utils._layers[PARCEL_TABLE][
LAYER].getFeatures(request)
collected_parcels_t_ids = [
feature[ID_FIELD] for feature in collected_parcels
]
if collected_parcels_t_ids:
collected_parcel_t_id = collected_parcels_t_ids[0]
if len(collected_parcels_t_ids
) > 1: # Duplicates in collected source after a search
QApplication.restoreOverrideCursor(
) # Make sure cursor is not waiting (it is if on an identify)
QCoreApplication.processEvents()
dlg_select_parcel = SelectDuplicateParcelDialog(
self.utils, collected_parcels_t_ids, self.parent)
dlg_select_parcel.exec_()
if dlg_select_parcel.parcel_t_id: # User selected one of the duplicated parcels
collected_parcel_t_id = dlg_select_parcel.parcel_t_id
search_criterion_collected = {
ID_FIELD: collected_parcel_t_id
}
else:
return # User just cancelled the dialog, there is nothing more to do
search_criterion_official = {search_field: search_value}
self.fill_table(search_criterion_official, search_criterion_collected)
if collected_parcel_t_id is not None:
plot_t_ids = self.utils.ladm_data.get_plots_related_to_parcels(
self.utils._db, [collected_parcel_t_id],
field_name=ID_FIELD,
plot_layer=self.utils._layers[PLOT_TABLE][LAYER],
uebaunit_table=self.utils._layers[UEBAUNIT_TABLE][LAYER])
if plot_t_ids:
self._current_substring = "{} IN ('{}')".format(
ID_FIELD, "','".join([str(t_id) for t_id in plot_t_ids]))
if not already_zoomed_in:
self.parent.request_zoom_to_features(
self.utils._layers[PLOT_TABLE][LAYER], list(),
plot_t_ids)
# Send a custom mouse move on the map to make the map swipe tool's limit appear on the canvas
# Activate Swipe Tool
self.utils.qgis_utils.activate_layer_requested.emit(
self.utils._official_layers[PLOT_TABLE][LAYER])
if official_plot_t_ids: # Otherwise the map swipe tool doesn't add any value :)
self.parent.activate_map_swipe_tool()
plots = self.utils.ladm_data.get_features_from_t_ids(
self.utils._layers[PLOT_TABLE][LAYER], plot_t_ids,
True)
plots_extent = QgsRectangle()
for plot in plots:
plots_extent.combineExtentWith(
plot.geometry().boundingBox())
coord_x = plots_extent.xMaximum() - (plots_extent.xMaximum(
) - plots_extent.xMinimum()) / 9 # 90%
coord_y = plots_extent.yMaximum() - (plots_extent.yMaximum(
) - plots_extent.yMinimum()) / 2 # 50%
coord_transform = self.utils.iface.mapCanvas(
).getCoordinateTransform()
map_point = coord_transform.transform(coord_x, coord_y)
widget_point = map_point.toQPointF().toPoint()
global_point = self.utils.canvas.mapToGlobal(widget_point)
self.utils.canvas.mousePressEvent(
QMouseEvent(QEvent.MouseButtonPress, global_point,
Qt.LeftButton, Qt.LeftButton,
Qt.NoModifier))
self.utils.canvas.mouseMoveEvent(
QMouseEvent(QEvent.MouseMove,
widget_point + QPoint(1, 0), Qt.NoButton,
Qt.LeftButton, Qt.NoModifier))
self.utils.canvas.mouseReleaseEvent(
QMouseEvent(QEvent.MouseButtonRelease,
widget_point + QPoint(1, 0), Qt.LeftButton,
Qt.LeftButton, Qt.NoModifier))
# Once the query is done, activate the checkbox to alternate all plots/only selected plot
self.chk_show_all_plots.setEnabled(True)
def processAlgorithm(self, parameters, context, feedback):
sourceA = self.parameterAsSource(parameters, self.INPUT, context)
sourceB = self.parameterAsSource(parameters, self.INTERSECT, context)
fieldsA = self.parameterAsFields(parameters, self.INPUT_FIELDS,
context)
fieldsB = self.parameterAsFields(parameters, self.INTERSECT_FIELDS,
context)
fieldListA = QgsFields()
field_indices_a = []
if len(fieldsA) > 0:
for f in fieldsA:
idxA = sourceA.fields().lookupField(f)
if idxA >= 0:
field_indices_a.append(idxA)
fieldListA.append(sourceA.fields()[idxA])
else:
fieldListA = sourceA.fields()
field_indices_a = [i for i in range(0, fieldListA.count())]
fieldListB = QgsFields()
field_indices_b = []
if len(fieldsB) > 0:
for f in fieldsB:
idxB = sourceB.fields().lookupField(f)
if idxB >= 0:
field_indices_b.append(idxB)
fieldListB.append(sourceB.fields()[idxB])
else:
fieldListB = sourceB.fields()
field_indices_b = [i for i in range(0, fieldListB.count())]
fieldListB = vector.testForUniqueness(fieldListA, fieldListB)
for b in fieldListB:
fieldListA.append(b)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fieldListA,
QgsWkbTypes.Point,
sourceA.sourceCrs())
spatialIndex = QgsSpatialIndex(
sourceB.getFeatures(QgsFeatureRequest().setSubsetOfAttributes(
[]).setDestinationCrs(sourceA.sourceCrs())), feedback)
outFeat = QgsFeature()
features = sourceA.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes(field_indices_a))
total = 100.0 / sourceA.featureCount() if sourceA.featureCount() else 0
for current, inFeatA in enumerate(features):
if feedback.isCanceled():
break
if not inFeatA.hasGeometry():
continue
inGeom = inFeatA.geometry()
has_intersections = False
lines = spatialIndex.intersects(inGeom.boundingBox())
engine = None
if len(lines) > 0:
has_intersections = True
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(inGeom.geometry())
engine.prepareGeometry()
if has_intersections:
request = QgsFeatureRequest().setFilterFids(lines)
request.setDestinationCrs(sourceA.sourceCrs())
request.setSubsetOfAttributes(field_indices_b)
for inFeatB in sourceB.getFeatures(request):
if feedback.isCanceled():
break
tmpGeom = inFeatB.geometry()
points = []
if engine.intersects(tmpGeom.geometry()):
tempGeom = inGeom.intersection(tmpGeom)
out_attributes = [
inFeatA.attributes()[i] for i in field_indices_a
]
out_attributes.extend(
[inFeatB.attributes()[i] for i in field_indices_b])
if tempGeom.type() == QgsWkbTypes.PointGeometry:
if tempGeom.isMultipart():
points = tempGeom.asMultiPoint()
else:
points.append(tempGeom.asPoint())
for j in points:
outFeat.setGeometry(tempGeom.fromPoint(j))
outFeat.setAttributes(out_attributes)
sink.addFeature(outFeat,
QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def analysis_summary(aggregate_hazard, analysis, callback=None):
"""Compute the summary from the aggregate hazard to analysis.
Source layer :
| haz_id | haz_class | aggr_id | aggr_name | total_feature |
Target layer :
| analysis_id |
Output layer :
| analysis_id | count_hazard_class | affected_count | total |
:param aggregate_hazard: The layer to aggregate vector layer.
:type aggregate_hazard: QgsVectorLayer
:param analysis: The target vector layer where to write statistics.
:type analysis: QgsVectorLayer
:param callback: A function to all to indicate progress. The function
should accept params 'current' (int), 'maximum' (int) and 'step' (str).
Defaults to None.
:type callback: function
:return: The new target layer with summary.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = summary_3_analysis_steps['output_layer_name']
processing_step = summary_3_analysis_steps['step_name']
source_fields = aggregate_hazard.keywords['inasafe_fields']
target_fields = analysis.keywords['inasafe_fields']
target_compulsory_fields = [
analysis_id_field,
analysis_name_field,
]
check_inputs(target_compulsory_fields, target_fields)
source_compulsory_fields = [
aggregation_id_field,
aggregation_name_field,
hazard_id_field,
hazard_class_field,
total_field
]
check_inputs(source_compulsory_fields, source_fields)
absolute_values = create_absolute_values_structure(
aggregate_hazard, ['all'])
hazard_class = source_fields[hazard_class_field['key']]
hazard_class_index = aggregate_hazard.fieldNameIndex(hazard_class)
unique_hazard = aggregate_hazard.uniqueValues(hazard_class_index)
hazard_keywords = aggregate_hazard.keywords['hazard_keywords']
classification = hazard_keywords['classification']
total = source_fields[total_field['key']]
flat_table = FlatTable('hazard_class')
# First loop over the aggregate_hazard layer
request = QgsFeatureRequest()
request.setSubsetOfAttributes(
[hazard_class, total], aggregate_hazard.fields())
request.setFlags(QgsFeatureRequest.NoGeometry)
for area in aggregate_hazard.getFeatures():
hazard_value = area[hazard_class_index]
value = area[total]
if not value or isinstance(value, QPyNullVariant) or isnan(value):
# For isnan, see ticket #3812
value = 0
if not hazard_value or isinstance(hazard_value, QPyNullVariant):
hazard_value = 'NULL'
flat_table.add_value(
value,
hazard_class=hazard_value
)
# We summarize every absolute values.
for field, field_definition in absolute_values.iteritems():
value = area[field]
if not value or isinstance(value, QPyNullVariant):
value = 0
field_definition[0].add_value(
value,
all='all'
)
analysis.startEditing()
shift = analysis.fields().count()
counts = [
total_affected_field,
total_not_affected_field,
total_not_exposed_field,
total_field]
add_fields(
analysis,
absolute_values,
counts,
unique_hazard,
hazard_count_field)
affected_sum = 0
not_affected_sum = 0
not_exposed_sum = 0
for area in analysis.getFeatures(request):
total = 0
for i, val in enumerate(unique_hazard):
if not val or isinstance(val, QPyNullVariant):
val = 'NULL'
sum = flat_table.get_value(hazard_class=val)
total += sum
analysis.changeAttributeValue(area.id(), shift + i, sum)
affected = post_processor_affected_function(
classification=classification, hazard_class=val)
if affected == not_exposed_class['key']:
not_exposed_sum += sum
elif affected:
affected_sum += sum
else:
not_affected_sum += sum
# Affected field
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard), affected_sum)
# Not affected field
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard) + 1, not_affected_sum)
# Not exposed field
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard) + 2, not_exposed_sum)
# Total field
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard) + 3, total)
# Any absolute postprocessors
for i, field in enumerate(absolute_values.itervalues()):
value = field[0].get_value(
all='all'
)
analysis.changeAttributeValue(
area.id(), shift + len(unique_hazard) + 4 + i, value)
# Sanity check ± 1 to the result. Disabled for now as it seems ± 1 is not
# enough. ET 13/02/17
# total_computed = (
# affected_sum + not_affected_sum + not_exposed_sum)
# if not -1 < (total_computed - total) < 1:
# raise ComputationError
analysis.commitChanges()
analysis.keywords['title'] = layer_purpose_analysis_impacted['name']
if qgis_version() >= 21600:
analysis.setName(analysis.keywords['title'])
else:
analysis.setLayerName(analysis.keywords['title'])
analysis.keywords['layer_purpose'] = layer_purpose_analysis_impacted['key']
check_layer(analysis)
return analysis
def search_data(self, **kwargs):
"""
Get plot geometries associated with parcels, both collected and supplies, zoom to them, fill comparison table
and activate map swipe tool.
To fill the comparison table we build two search dicts, one for supplies (already given because the alphanumeric
search is on supplies db source), and another one for collected. For the latter, we have 3 cases. We specify
them below (inline).
:param kwargs: key-value (field name-field value) to search in parcel tables, both collected and supplies
Normally, keys are parcel_number, old_parcel_number or FMI, but if duplicates are found, an
additional t_id disambiguates only for the collected source. In the supplies source we assume
we will not find duplicates, if there are, we will choose the first record found an will not deal
with letting the user choose one of the duplicates by hand (as we do for the collected source).
"""
self.chk_show_all_plots.setEnabled(False)
self.chk_show_all_plots.setChecked(True)
self.initialize_tools_and_layers() # Reset any filter on layers
plots_supplies = list()
plots_collected = list()
self.clear_result_table()
search_option = self.cbo_parcel_fields.currentData()
search_field_supplies = get_supplies_search_options(
self.utils._supplies_db.names)[search_option]
search_field_collected = get_collected_search_options(
self.utils._db.names)[search_option]
search_value = list(kwargs.values())[0]
# Build search criterion for both supplies and collected
search_criterion_supplies = {search_field_supplies: search_value}
# Get supplies parcel's t_id and get related plot(s)
expression_supplies = QgsExpression("{}='{}'".format(
search_field_supplies, search_value))
request = QgsFeatureRequest(expression_supplies)
field_idx = self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PARCEL_T].fields().indexFromName(
self.utils._supplies_db.names.T_ID_F)
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes([field_idx
]) # Note: this adds a new flag
supplies_parcels = [
feature for feature in self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PARCEL_T].getFeatures(request)
]
if len(supplies_parcels) > 1:
# We do not expect duplicates in the supplies source!
pass # We'll choose the first one anyways
elif len(supplies_parcels) == 0:
self.logger.info(
__name__, "No supplies parcel found! Search: {}={}".format(
search_field_supplies, search_value))
supplies_plot_t_ids = []
if supplies_parcels:
supplies_plot_t_ids = self.utils.ladm_data.get_plots_related_to_parcels_supplies(
self.utils._supplies_db,
[supplies_parcels[0][self.utils._supplies_db.names.T_ID_F]],
self.utils._supplies_db.names.T_ID_F,
self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T])
if supplies_plot_t_ids:
self._current_supplies_substring = "\"{}\" IN ('{}')".format(
self.utils._supplies_db.names.T_ID_F,
"','".join([str(t_id) for t_id in supplies_plot_t_ids]))
plots_supplies = self.utils.ladm_data.get_features_from_t_ids(
self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T],
self.utils._supplies_db.names.T_ID_F, supplies_plot_t_ids,
True)
# Now get COLLECTED parcel's t_id to build the search dict for collected
collected_parcel_t_id = None
if 'collected_parcel_t_id' in kwargs:
# This is the case when this panel is called and we already know the parcel number is duplicated
collected_parcel_t_id = kwargs['collected_parcel_t_id']
search_criterion_collected = {
self.utils._db.names.T_ID_F: collected_parcel_t_id
} # As there are duplicates, we need to use t_ids
else:
# This is the case when:
# + Either this panel was called and we know the parcel number is not duplicated, or
# + This panel was shown without knowing about duplicates (e.g., individual parcel search) and we still
# need to discover whether we have duplicates for this search criterion
search_criterion_collected = {search_field_collected: search_value}
expression_collected = QgsExpression("{}='{}'".format(
search_field_collected, search_value))
request = QgsFeatureRequest(expression_collected)
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes(
[self.utils._db.names.T_ID_F],
self.utils._layers[self.utils._db.names.LC_PARCEL_T].fields(
)) # Note this adds a new flag
collected_parcels = self.utils._layers[
self.utils._db.names.LC_PARCEL_T].getFeatures(request)
collected_parcels_t_ids = [
feature[self.utils._db.names.T_ID_F]
for feature in collected_parcels
]
if collected_parcels_t_ids:
collected_parcel_t_id = collected_parcels_t_ids[0]
if len(collected_parcels_t_ids
) > 1: # Duplicates in collected source after a search
QApplication.restoreOverrideCursor(
) # Make sure cursor is not waiting (it is if on an identify)
QCoreApplication.processEvents()
dlg_select_parcel = SelectDuplicateParcelDialog(
self.utils, collected_parcels_t_ids, self.parent)
dlg_select_parcel.exec_()
if dlg_select_parcel.parcel_t_id: # User selected one of the duplicated parcels
collected_parcel_t_id = dlg_select_parcel.parcel_t_id
search_criterion_collected = {
self.utils._db.names.T_ID_F: collected_parcel_t_id
}
else:
return # User just cancelled the dialog, there is nothing more to do
self.fill_table(search_criterion_supplies, search_criterion_collected)
# Now get related plot(s) for both collected and supplies,
if collected_parcel_t_id is not None:
plot_t_ids = self.utils.ladm_data.get_plots_related_to_parcels(
self.utils._db, [collected_parcel_t_id],
self.utils._db.names.T_ID_F,
plot_layer=self.utils._layers[self.utils._db.names.LC_PLOT_T],
uebaunit_table=self.utils._layers[
self.utils._db.names.COL_UE_BAUNIT_T])
if plot_t_ids:
self._current_substring = "{} IN ('{}')".format(
self.utils._db.names.T_ID_F,
"','".join([str(t_id) for t_id in plot_t_ids]))
plots_collected = self.utils.ladm_data.get_features_from_t_ids(
self.utils._layers[self.utils._db.names.LC_PLOT_T],
self.utils._db.names.T_ID_F, plot_t_ids, True)
# Zoom to combined extent
plot_features = plots_supplies + plots_collected # Feature list
plots_extent = QgsRectangle()
for plot in plot_features:
plots_extent.combineExtentWith(plot.geometry().boundingBox())
if not plots_extent.isEmpty():
self.utils.iface.mapCanvas().zoomToFeatureExtent(plots_extent)
if plots_supplies and plots_collected: # Otherwise the map swipe tool doesn't add any value :)
# Activate Swipe Tool
self.utils.app.gui.activate_layer(self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T])
self.parent.activate_map_swipe_tool()
# Send a custom mouse move on the map to make the map swipe tool's limit appear on the canvas
coord_x = plots_extent.xMaximum() - (plots_extent.xMaximum(
) - plots_extent.xMinimum()) / 9 # 90%
coord_y = plots_extent.yMaximum() - (plots_extent.yMaximum(
) - plots_extent.yMinimum()) / 2 # 50%
coord_transform = self.utils.iface.mapCanvas(
).getCoordinateTransform()
map_point = coord_transform.transform(coord_x, coord_y)
widget_point = map_point.toQPointF().toPoint()
global_point = self.utils.canvas.mapToGlobal(widget_point)
self.utils.canvas.mousePressEvent(
QMouseEvent(QEvent.MouseButtonPress, global_point,
Qt.LeftButton, Qt.LeftButton, Qt.NoModifier))
self.utils.canvas.mouseMoveEvent(
QMouseEvent(QEvent.MouseMove, widget_point + QPoint(1, 0),
Qt.NoButton, Qt.LeftButton, Qt.NoModifier))
self.utils.canvas.mouseReleaseEvent(
QMouseEvent(QEvent.MouseButtonRelease,
widget_point + QPoint(1, 0), Qt.LeftButton,
Qt.LeftButton, Qt.NoModifier))
# Once the query is done, activate the checkbox to alternate all plots/only selected plot
self.chk_show_all_plots.setEnabled(True)
def qgisUpdateIDs(self, unlinktype):
# create spatial index
unlinksindex = lfh.createIndex(self.unlinks_layer)
axialindex = lfh.createIndex(self.axial_layer)
# add line id columns if necessary
lfh.addFields(self.unlinks_layer, ['line1', 'line2'],
[QVariant.Int, QVariant.Int])
line1 = lfh.getFieldIndex(self.unlinks_layer, 'line1')
line2 = lfh.getFieldIndex(self.unlinks_layer, 'line2')
update_id = False
if self.user_id == '':
features = self.unlinks_layer.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes([line1, line2]))
else:
update_id = not lfh.isValidIdField(self.unlinks_layer,
self.user_id)
field = lfh.getFieldIndex(self.unlinks_layer, self.user_id)
features = self.unlinks_layer.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes(
[field, line1, line2]))
# run unlinks tests
chunk = 100.0 / float(self.unlinks_layer.featureCount())
steps = chunk / 3.0
progress = 0.0
for feature in features:
geom = feature.geometry()
# get intersection results
if unlinktype == QgsWkbTypes.PointGeometry and self.threshold > 0.0:
buff = geom.buffer(self.threshold, 4)
else:
buff = geom
box = buff.boundingBox()
request = QgsFeatureRequest()
if axialindex:
# should be faster to retrieve from index (if available)
ints = axialindex.intersects(box)
request.setFilterFids(ints)
else:
# can retrieve objects using bounding box
request.setFilterRect(box)
if self.axial_id == '':
request.setSubsetOfAttributes([])
else:
ax_field = lfh.getFieldIndex(self.axial_layer, self.axial_id)
request.setSubsetOfAttributes([ax_field])
axiallines = self.axial_layer.getFeatures(request)
progress += steps
self.verificationProgress.emit(progress)
# parse intersection results
intersects = []
for line in axiallines:
if self.axial_id == '':
id_b = line.id()
else:
id_b = line.attribute(self.axial_id)
if buff.intersects(line.geometry()):
intersects.append(id_b)
progress += steps
self.verificationProgress.emit(progress)
# update line ids in unlinks table
attrs = {line1: NULL, line2: NULL}
if len(intersects) == 1:
attrs = {line1: intersects[0]}
elif len(intersects) > 1:
attrs = {line1: intersects[0], line2: intersects[1]}
if update_id and field:
attrs[field] = feature.id()
self.unlinks_layer.dataProvider().changeAttributeValues(
{feature.id(): attrs})
progress += steps
self.verificationProgress.emit(progress)
self.unlinks_layer.updateFields()
def _remove_features(layer):
"""Remove features which do not have information for InaSAFE or an invalid
geometry.
:param layer: The vector layer.
:type layer: QgsVectorLayer
"""
# Get the layer purpose of the layer.
layer_purpose = layer.keywords['layer_purpose']
layer_subcategory = layer.keywords.get(layer_purpose)
compulsory_field = get_compulsory_fields(layer_purpose, layer_subcategory)
inasafe_fields = layer.keywords['inasafe_fields']
# Compulsory fields can be list of field name or single field name.
# We need to iterate through all of them
field_names = inasafe_fields.get(compulsory_field['key'])
if not isinstance(field_names, list):
field_names = [field_names]
for field_name in field_names:
if not field_name:
message = 'Keyword %s is missing from %s' % (
compulsory_field['key'], layer_purpose)
raise InvalidKeywordsForProcessingAlgorithm(message)
index = layer.fieldNameIndex(field_name)
request = QgsFeatureRequest()
request.setSubsetOfAttributes([field_name], layer.pendingFields())
layer.startEditing()
i = 0
for feature in layer.getFeatures(request):
if isinstance(feature.attributes()[index], QPyNullVariant):
if layer_purpose == 'hazard':
# Remove the feature if the hazard is null.
layer.deleteFeature(feature.id())
i += 1
elif layer_purpose == 'aggregation':
# Put the ID if the value is null.
layer.changeAttributeValue(
feature.id(), index, str(feature.id()))
elif layer_purpose == 'exposure':
# Put an empty value, the value mapping will take care of
# it in the 'other' group.
layer.changeAttributeValue(
feature.id(), index, '')
# Check if there is en empty geometry.
geometry = feature.geometry()
if not geometry:
layer.deleteFeature(feature.id())
i += 1
continue
# Check if the geometry is empty.
if geometry.isGeosEmpty():
layer.deleteFeature(feature.id())
i += 1
continue
# Check if the geometry is valid.
if not geometry.isGeosValid():
# polygonize can produce some invalid geometries
# For instance a polygon like this, sharing a same point :
# _______
# | ___|__
# | |__| |
# |________|
# layer.deleteFeature(feature.id())
# i += 1
pass
# TODO We need to add more tests
# like checking if the value is in the value_mapping.
layer.commitChanges()
LOGGER.debug(tr(
'Features which have been removed from %s : %s'
% (layer.keywords['layer_purpose'], i)))
def selection_changed(self):
"""
Triggered when the selection in the meshblock layer changes
"""
if not self.task or not self.district_registry:
return
request = QgsFeatureRequest().setFilterFids(
self.meshblock_layer.selectedFeatureIds()).setFlags(
QgsFeatureRequest.NoGeometry)
counts = defaultdict(int)
for f in self.meshblock_layer.getFeatures(request):
electorate = f['staged_electorate']
if self.task == 'GN':
pop = f['offline_pop_gn']
elif self.task == 'GS':
pop = f['offline_pop_gs']
else:
pop = f['offline_pop_m']
counts[electorate] += pop
html = """<h3>Target Electorate: <a href="#">{}</a></h3><p>""".format(
self.district_registry.get_district_title(self.target_electorate))
request = QgsFeatureRequest()
request.setFilterExpression(
QgsExpression.createFieldEqualityExpression('type', self.task))
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes(
['electorate_id', 'estimated_pop', 'stats_nz_pop'],
self.district_registry.source_layer.fields())
original_populations = {}
for f in self.district_registry.source_layer.getFeatures(request):
estimated_pop = f['stats_nz_pop']
if estimated_pop is None or estimated_pop == NULL:
# otherwise just use existing estimated pop as starting point
estimated_pop = f['estimated_pop']
original_populations[f['electorate_id']] = estimated_pop
overall = 0
for electorate, pop in counts.items():
if self.target_electorate:
if electorate != self.target_electorate:
overall += pop
# use stats nz pop as initial estimate, if available
estimated_pop = original_populations[electorate]
estimated_pop -= pop
variance = LinzElectoralDistrictRegistry.get_variation_from_quota_percent(
self.quota, estimated_pop)
html += """\n{}: <span style="font-weight:bold">-{}</span> (after: {}, {}{}%)<br>""".format(
self.district_registry.get_district_title(electorate),
pop, int(estimated_pop), '+' if variance > 0 else '',
variance)
else:
html += """\n{}: <span style="font-weight:bold">{}</span><br>""".format(
self.district_registry.get_district_title(electorate), pop)
if self.target_electorate:
estimated_pop = original_populations[self.target_electorate]
estimated_pop += overall
variance = LinzElectoralDistrictRegistry.get_variation_from_quota_percent(
self.quota, estimated_pop)
html += """\n{}: <span style="font-weight:bold">+{}</span> (after: {}, {}{}%)<br>""".format(
self.district_registry.get_district_title(
self.target_electorate), overall, int(estimated_pop),
'+' if variance > 0 else '', variance)
html += '</p>'
self.frame.setHtml(html)
def processAlgorithm(self, progress):
layerA = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_A))
splitLayer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_B))
sameLayer = self.getParameterValue(self.INPUT_A) == self.getParameterValue(self.INPUT_B)
fieldList = layerA.fields()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fieldList,
layerA.wkbType(), layerA.crs())
spatialIndex = QgsSpatialIndex()
splitGeoms = {}
request = QgsFeatureRequest()
request.setSubsetOfAttributes([])
for aSplitFeature in vector.features(splitLayer, request):
splitGeoms[aSplitFeature.id()] = aSplitFeature.geometry()
spatialIndex.insertFeature(aSplitFeature)
# honor the case that user has selection on split layer and has setting "use selection"
outFeat = QgsFeature()
features = vector.features(layerA)
if len(features) == 0:
total = 100
else:
total = 100.0 / float(len(features))
multiGeoms = 0 # how many multi geometries were encountered
for current, inFeatA in enumerate(features):
inGeom = inFeatA.geometry()
if inGeom.isMultipart():
multiGeoms += 1
# MultiGeometries are not allowed because the result of a splitted part cannot be clearly defined:
# 1) add both new parts as new features
# 2) store one part as a new feature and the other one as part of the multi geometry
# 2a) which part should be which, seems arbitrary
else:
attrsA = inFeatA.attributes()
outFeat.setAttributes(attrsA)
inGeoms = [inGeom]
lines = spatialIndex.intersects(inGeom.boundingBox())
if len(lines) > 0: # has intersection of bounding boxes
splittingLines = []
engine = QgsGeometry.createGeometryEngine(inGeom.geometry())
engine.prepareGeometry()
for i in lines:
try:
splitGeom = splitGeoms[i]
except:
continue
# check if trying to self-intersect
if sameLayer:
if inFeatA.id() == i:
continue
if engine.intersects(splitGeom.geometry()):
splittingLines.append(splitGeom)
if len(splittingLines) > 0:
for splitGeom in splittingLines:
splitterPList = None
outGeoms = []
split_geom_engine = QgsGeometry.createGeometryEngine(splitGeom.geometry())
split_geom_engine.prepareGeometry()
while len(inGeoms) > 0:
inGeom = inGeoms.pop()
if split_geom_engine.intersects(inGeom.geometry()):
inPoints = vector.extractPoints(inGeom)
if splitterPList == None:
splitterPList = vector.extractPoints(splitGeom)
try:
result, newGeometries, topoTestPoints = inGeom.splitGeometry(splitterPList, False)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
self.tr('Geometry exception while splitting'))
result = 1
# splitGeometry: If there are several intersections
# between geometry and splitLine, only the first one is considered.
if result == 0: # split occurred
if inPoints == vector.extractPoints(inGeom):
# bug in splitGeometry: sometimes it returns 0 but
# the geometry is unchanged
QgsMessageLog.logMessage("appending")
outGeoms.append(inGeom)
else:
inGeoms.append(inGeom)
for aNewGeom in newGeometries:
inGeoms.append(aNewGeom)
else:
QgsMessageLog.logMessage("appending else")
outGeoms.append(inGeom)
else:
outGeoms.append(inGeom)
inGeoms = outGeoms
for aGeom in inGeoms:
passed = True
if QgsWkbTypes.geometryType( aGeom.wkbType() ) == QgsWkbTypes.LineGeometry \
and not QgsWkbTypes.isMultiType(aGeom.wkbType()):
passed = len(aGeom.asPolyline()) > 2
if not passed:
passed = (len(aGeom.asPolyline()) == 2 and
aGeom.asPolyline()[0] != aGeom.asPolyline()[1])
# sometimes splitting results in lines of zero length
if passed:
outFeat.setGeometry(aGeom)
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
if multiGeoms > 0:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Feature geometry error: %s input features ignored due to multi-geometry.') % str(multiGeoms))
del writer
def processAlgorithm(self, parameters, context, feedback):
layerA = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.INPUT_A), context)
splitLayer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.INPUT_B), context)
sameLayer = self.getParameterValue(
self.INPUT_A) == self.getParameterValue(self.INPUT_B)
fieldList = layerA.fields()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fieldList, QgsWkbTypes.multiType(layerA.wkbType()), layerA.crs(),
context)
spatialIndex = QgsSpatialIndex()
splitGeoms = {}
request = QgsFeatureRequest()
request.setSubsetOfAttributes([])
for aSplitFeature in QgsProcessingUtils.getFeatures(
splitLayer, context, request):
splitGeoms[aSplitFeature.id()] = aSplitFeature.geometry()
spatialIndex.insertFeature(aSplitFeature)
# honor the case that user has selection on split layer and has setting "use selection"
outFeat = QgsFeature()
features = QgsProcessingUtils.getFeatures(layerA, context)
if QgsProcessingUtils.featureCount(layerA, context) == 0:
total = 100
else:
total = 100.0 / layerA.featureCount() if layerA.featureCount(
) else 0
for current, inFeatA in enumerate(features):
inGeom = inFeatA.geometry()
attrsA = inFeatA.attributes()
outFeat.setAttributes(attrsA)
if inGeom.isMultipart():
inGeoms = []
for g in inGeom.asGeometryCollection():
inGeoms.append(g)
else:
inGeoms = [inGeom]
lines = spatialIndex.intersects(inGeom.boundingBox())
if len(lines) > 0: # has intersection of bounding boxes
splittingLines = []
engine = QgsGeometry.createGeometryEngine(inGeom.geometry())
engine.prepareGeometry()
for i in lines:
try:
splitGeom = splitGeoms[i]
except:
continue
# check if trying to self-intersect
if sameLayer:
if inFeatA.id() == i:
continue
if engine.intersects(splitGeom.geometry()):
splittingLines.append(splitGeom)
if len(splittingLines) > 0:
for splitGeom in splittingLines:
splitterPList = None
outGeoms = []
split_geom_engine = QgsGeometry.createGeometryEngine(
splitGeom.geometry())
split_geom_engine.prepareGeometry()
while len(inGeoms) > 0:
inGeom = inGeoms.pop()
if inGeom.isNull(
): # this has been encountered and created a run-time error
continue
if split_geom_engine.intersects(inGeom.geometry()):
inPoints = vector.extractPoints(inGeom)
if splitterPList is None:
splitterPList = vector.extractPoints(
splitGeom)
try:
result, newGeometries, topoTestPoints = inGeom.splitGeometry(
splitterPList, False)
except:
QgsMessageLog.logMessage(
self.
tr('Geometry exception while splitting'
), self.tr('Processing'),
QgsMessageLog.WARNING)
result = 1
# splitGeometry: If there are several intersections
# between geometry and splitLine, only the first one is considered.
if result == 0: # split occurred
if inPoints == vector.extractPoints(
inGeom):
# bug in splitGeometry: sometimes it returns 0 but
# the geometry is unchanged
outGeoms.append(inGeom)
else:
inGeoms.append(inGeom)
for aNewGeom in newGeometries:
inGeoms.append(aNewGeom)
else:
outGeoms.append(inGeom)
else:
outGeoms.append(inGeom)
inGeoms = outGeoms
parts = []
for aGeom in inGeoms:
passed = True
if QgsWkbTypes.geometryType(
aGeom.wkbType()) == QgsWkbTypes.LineGeometry:
numPoints = aGeom.geometry().numPoints()
if numPoints <= 2:
if numPoints == 2:
passed = not aGeom.geometry().isClosed(
) # tests if vertex 0 = vertex 1
else:
passed = False
# sometimes splitting results in lines of zero length
if passed:
parts.append(aGeom)
if len(parts) > 0:
outFeat.setGeometry(QgsGeometry.collectGeometry(parts))
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, parameters, context, feedback):
# Get variables from dialog
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
field_name = self.parameterAsString(parameters, self.FIELD, context)
kneighbors = self.parameterAsInt(parameters, self.KNEIGHBORS, context)
use_field = bool(field_name)
field_index = -1
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 20))
current = 0
# Get properties of the field the grouping is based on
if use_field:
field_index = source.fields().lookupField(field_name)
if field_index >= 0:
fields.append(
source.fields()[field_index]
) # Add a field with the name of the grouping field
# Initialize writer
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Polygon,
source.sourceCrs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
success = False
fid = 0
# Get unique values of grouping field
unique_values = source.uniqueValues(field_index)
total = 100.0 / float(
source.featureCount() * len(unique_values))
for unique in unique_values:
points = []
filter = QgsExpression.createFieldEqualityExpression(
field_name, unique)
request = QgsFeatureRequest().setFilterExpression(filter)
request.setSubsetOfAttributes([])
# Get features with the grouping attribute equal to the current grouping value
features = source.getFeatures(request)
for in_feature in features:
if feedback.isCanceled():
break
# Add points or vertices of more complex geometry
points.extend(extract_points(in_feature.geometry()))
current += 1
feedback.setProgress(int(current * total))
# A minimum of 3 points is necessary to proceed
if len(points) >= 3:
out_feature = QgsFeature()
the_hull = concave_hull(points, kneighbors)
if the_hull:
vertex = [
QgsPointXY(point[0], point[1])
for point in the_hull
]
poly = QgsGeometry().fromPolygonXY([vertex])
out_feature.setGeometry(poly)
# Give the polygon the same attribute as the point grouping attribute
out_feature.setAttributes([fid, unique])
sink.addFeature(out_feature,
QgsFeatureSink.FastInsert)
success = True # at least one polygon created
fid += 1
if not success:
raise QgsProcessingException(
'No hulls could be created. Most likely there were not at least three unique points in any of the groups.'
)
else:
# Field parameter provided but can't read from it
raise QgsProcessingException('Unable to find grouping field')
else:
# Not grouped by field
# Initialize writer
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Polygon,
source.sourceCrs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
points = []
request = QgsFeatureRequest()
request.setSubsetOfAttributes([])
features = source.getFeatures(request) # Get all features
total = 100.0 / source.featureCount() if source.featureCount(
) else 0
for in_feature in features:
if feedback.isCanceled():
break
# Add points or vertices of more complex geometry
points.extend(extract_points(in_feature.geometry()))
current += 1
feedback.setProgress(int(current * total))
# A minimum of 3 points is necessary to proceed
if len(points) >= 3:
out_feature = QgsFeature()
the_hull = concave_hull(points, kneighbors)
if the_hull:
vertex = [
QgsPointXY(point[0], point[1]) for point in the_hull
]
poly = QgsGeometry().fromPolygonXY([vertex])
out_feature.setGeometry(poly)
out_feature.setAttributes([0])
sink.addFeature(out_feature, QgsFeatureSink.FastInsert)
else:
# the_hull returns None only when there are less than three points after cleaning
raise QgsProcessingException(
'At least three unique points are required to create a concave hull.'
)
else:
raise QgsProcessingException(
'At least three points are required to create a concave hull.'
)
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
poly_source = self.parameterAsSource(parameters, self.POLYGONS, context)
if poly_source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.POLYGONS))
point_source = self.parameterAsSource(parameters, self.POINTS, context)
if point_source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.POINTS))
weight_field = self.parameterAsString(parameters, self.WEIGHT, context)
weight_field_index = -1
if weight_field:
weight_field_index = point_source.fields().lookupField(weight_field)
class_field = self.parameterAsString(parameters, self.CLASSFIELD, context)
class_field_index = -1
if class_field:
class_field_index = point_source.fields().lookupField(class_field)
field_name = self.parameterAsString(parameters, self.FIELD, context)
fields = poly_source.fields()
if fields.lookupField(field_name) < 0:
fields.append(QgsField(field_name, QVariant.LongLong))
field_index = fields.lookupField(field_name)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, poly_source.wkbType(), poly_source.sourceCrs(), QgsFeatureSink.RegeneratePrimaryKey)
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
point_attribute_indices = []
if weight_field_index >= 0:
point_attribute_indices.append(weight_field_index)
if class_field_index >= 0:
point_attribute_indices.append(class_field_index)
features = poly_source.getFeatures()
total = 100.0 / poly_source.featureCount() if poly_source.featureCount() else 0
for current, polygon_feature in enumerate(features):
if feedback.isCanceled():
break
count = 0
output_feature = QgsFeature()
if polygon_feature.hasGeometry():
geom = polygon_feature.geometry()
engine = QgsGeometry.createGeometryEngine(geom.constGet())
engine.prepareGeometry()
count = 0
classes = set()
request = QgsFeatureRequest().setFilterRect(geom.boundingBox()).setDestinationCrs(poly_source.sourceCrs(), context.transformContext())
request.setSubsetOfAttributes(point_attribute_indices)
for point_feature in point_source.getFeatures(request):
if feedback.isCanceled():
break
if engine.contains(point_feature.geometry().constGet()):
if weight_field_index >= 0:
weight = point_feature[weight_field_index]
try:
count += float(weight)
except:
# Ignore fields with non-numeric values
pass
elif class_field_index >= 0:
point_class = point_feature[class_field_index]
if point_class not in classes:
classes.add(point_class)
else:
count += 1
output_feature.setGeometry(geom)
attrs = polygon_feature.attributes()
if class_field_index >= 0:
score = len(classes)
else:
score = count
if field_index == len(attrs):
attrs.append(score)
else:
attrs[field_index] = score
output_feature.setAttributes(attrs)
sink.addFeature(output_feature, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
poly_source = self.parameterAsSource(parameters, self.POLYGONS,
context)
if poly_source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.POLYGONS))
point_source = self.parameterAsSource(parameters, self.POINTS, context)
if point_source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.POINTS))
weight_field = self.parameterAsString(parameters, self.WEIGHT, context)
weight_field_index = -1
if weight_field:
weight_field_index = point_source.fields().lookupField(
weight_field)
class_field = self.parameterAsString(parameters, self.CLASSFIELD,
context)
class_field_index = -1
if class_field:
class_field_index = point_source.fields().lookupField(class_field)
field_name = self.parameterAsString(parameters, self.FIELD, context)
fields = poly_source.fields()
if fields.lookupField(field_name) < 0:
fields.append(QgsField(field_name, QVariant.Int))
field_index = fields.lookupField(field_name)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
poly_source.wkbType(),
poly_source.sourceCrs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
spatialIndex = QgsSpatialIndex(
point_source.getFeatures(QgsFeatureRequest().setSubsetOfAttributes(
[]).setDestinationCrs(poly_source.sourceCrs(),
context.transformContext())), feedback)
point_attribute_indices = []
if weight_field_index >= 0:
point_attribute_indices.append(weight_field_index)
if class_field_index >= 0:
point_attribute_indices.append(class_field_index)
features = poly_source.getFeatures()
total = 100.0 / poly_source.featureCount() if poly_source.featureCount(
) else 0
for current, polygon_feature in enumerate(features):
if feedback.isCanceled():
break
count = 0
output_feature = QgsFeature()
if polygon_feature.hasGeometry():
geom = polygon_feature.geometry()
engine = QgsGeometry.createGeometryEngine(geom.constGet())
engine.prepareGeometry()
count = 0
classes = set()
points = spatialIndex.intersects(geom.boundingBox())
if len(points) > 0:
request = QgsFeatureRequest().setFilterFids(
points).setDestinationCrs(poly_source.sourceCrs(),
context.transformContext())
request.setSubsetOfAttributes(point_attribute_indices)
for point_feature in point_source.getFeatures(request):
if feedback.isCanceled():
break
if engine.contains(
point_feature.geometry().constGet()):
if weight_field_index >= 0:
weight = point_feature.attributes(
)[weight_field_index]
try:
count += float(weight)
except:
# Ignore fields with non-numeric values
pass
elif class_field_index >= 0:
point_class = point_feature.attributes(
)[class_field_index]
if point_class not in classes:
classes.add(point_class)
else:
count += 1
output_feature.setGeometry(geom)
attrs = polygon_feature.attributes()
if class_field_index >= 0:
score = len(classes)
else:
score = count
if field_index == len(attrs):
attrs.append(score)
else:
attrs[field_index] = score
output_feature.setAttributes(attrs)
sink.addFeature(output_feature, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
