def polygon_to_segments(self, geometry):
# polygons to lines (mutlipart)
boundary = QgsGeometry(geometry.constGet().boundary())
boundaries = boundary.asGeometryCollection()
segments = []
for boundary in boundaries:
if boundary.isMultipart():
lines = boundary.asMultiPolyline()
for line in lines:
for i in range(len(line) - 1):
p1 = QgsPoint(line[i])
p2 = QgsPoint(line[i + 1])
segment = create_normalized_segment(p1, p2)
segment_wkt = segment.asWkt()
segments.append(segment)
else:
line = boundary.asPolyline()
for i in range(len(line) - 1):
p1 = QgsPoint(line[i])
p2 = QgsPoint(line[i + 1])
segment = create_normalized_segment(p1, p2)
segments.append(segment)
return segments
def create_plots_from_boundaries(self):
selected_boundaries = self.__layers[
self.names.LC_BOUNDARY_T].selectedFeatures()
boundary_geometries = [f.geometry() for f in selected_boundaries]
collection = QgsGeometry().polygonize(boundary_geometries)
features = list()
for polygon in collection.asGeometryCollection():
feature = QgsVectorLayerUtils().createFeature(
self.__editing_layer, polygon)
features.append(feature)
if not features:
return EnumPlotCreationResult.NO_PLOTS_CREATED
if not self.__editing_layer.isEditable():
self.__editing_layer.startEditing()
self.__editing_layer.addFeatures(features)
self.__iface.mapCanvas().refresh()
message = QCoreApplication.translate(
"WizardTranslations",
"{} new plot(s) has(have) been created! To finish the creation of the plots, open its attribute table and fill in the mandatory fields."
).format(len(features))
button_text = QCoreApplication.translate("WizardTranslations",
"Open table of attributes")
level = Qgis.Info
layer = self.__editing_layer
filter = '"{}" is Null'.format(self.names.LC_PLOT_T_PLOT_AREA_F)
self.__logger.message_with_button_open_table_attributes_emitted.emit(
message, button_text, level, layer, filter)
# self.close_wizard(show_message=False)
return EnumPlotCreationResult.CREATED
def convertToLineStrings(self, geom):
if QgsWkbTypes.geometryType(geom.wkbType()) == QgsWkbTypes.PointGeometry:
raise QgsProcessingException(
self.tr('Cannot convert from {0} to LineStrings').format(QgsWkbTypes.displayString(geom.wkbType())))
elif QgsWkbTypes.geometryType(geom.wkbType()) == QgsWkbTypes.LineGeometry:
if QgsWkbTypes.isMultiType(geom.wkbType()):
return geom.asGeometryCollection()
else:
#line to line
return [geom]
else:
# polygons to lines
# we just use the boundary here - that consists of all rings in the (multi)polygon
boundary = QgsGeometry(geom.constGet().boundary())
# boundary will be multipart
return boundary.asGeometryCollection()
def convertToLineStrings(self, geom):
if QgsWkbTypes.geometryType(geom.wkbType()) == QgsWkbTypes.PointGeometry:
raise QgsProcessingException(
self.tr('Cannot convert from {0} to LineStrings').format(QgsWkbTypes.displayString(geom.wkbType())))
elif QgsWkbTypes.geometryType(geom.wkbType()) == QgsWkbTypes.LineGeometry:
if QgsWkbTypes.isMultiType(geom.wkbType()):
return geom.asGeometryCollection()
else:
#line to line
return [geom]
else:
# polygons to lines
# we just use the boundary here - that consists of all rings in the (multi)polygon
boundary = QgsGeometry(geom.constGet().boundary())
# boundary will be multipart
return boundary.asGeometryCollection()
def create_plots_from_boundaries(self):
selected_boundaries = self._layers[BOUNDARY_TABLE][
LAYER].selectedFeatures()
boundary_geometries = [f.geometry() for f in selected_boundaries]
collection = QgsGeometry().polygonize(boundary_geometries)
features = list()
for polygon in collection.asGeometryCollection():
feature = QgsVectorLayerUtils().createFeature(
self._layers[self.EDITING_LAYER_NAME][LAYER], polygon)
features.append(feature)
if features:
if not self._layers[self.EDITING_LAYER_NAME][LAYER].isEditable():
self._layers[self.EDITING_LAYER_NAME][LAYER].startEditing()
self._layers[self.EDITING_LAYER_NAME][LAYER].addFeatures(features)
self.iface.mapCanvas().refresh()
message = QCoreApplication.translate(
"QGISUtils",
"{} new plot(s) has(have) been created! To finish the creation of the plots, open its attribute table and fill in the mandatory fields."
).format(len(features))
button_text = QCoreApplication.translate(
"QGISUtils", "Open table of attributes")
level = Qgis.Info
layer = self._layers[self.EDITING_LAYER_NAME][LAYER]
filter = '"{}" is Null and "{}" is Null'.format(
PLOT_REGISTRY_AREA_FIELD, PLOT_CALCULATED_AREA_FIELD)
self.qgis_utils.message_with_open_table_attributes_button_emitted.emit(
message, button_text, level, layer, filter)
self.close_wizard(show_message=False)
else:
message = QCoreApplication.translate(
"QGISUtils",
"No plot could be created. Make sure selected boundaries are closed!"
)
self.close_wizard(message)
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())
fields = vector.combineFields(sourceA.fields(), sourceB.fields())
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, geomType, sourceA.sourceCrs())
featA = QgsFeature()
featB = QgsFeature()
outFeat = QgsFeature()
indexA = QgsSpatialIndex(sourceA, feedback)
indexB = QgsSpatialIndex(sourceB.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([]).setDestinationCrs(sourceA.sourceCrs())), feedback)
total = 100.0 / (sourceA.featureCount() * sourceB.featureCount()) if sourceA.featureCount() and sourceB.featureCount() else 1
count = 0
for featA in sourceA.getFeatures():
if feedback.isCanceled():
break
lstIntersectingB = []
geom = featA.geometry()
atMapA = featA.attributes()
intersects = indexB.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
else:
request = QgsFeatureRequest().setFilterFids(intersects).setSubsetOfAttributes([])
request.setDestinationCrs(sourceA.sourceCrs())
engine = QgsGeometry.createGeometryEngine(geom.geometry())
engine.prepareGeometry()
for featB in sourceB.getFeatures(request):
atMapB = featB.attributes()
tmpGeom = featB.geometry()
if engine.intersects(tmpGeom.geometry()):
int_geom = geom.intersection(tmpGeom)
lstIntersectingB.append(tmpGeom)
if not int_geom:
# There was a problem creating the intersection
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
int_geom = QgsGeometry()
else:
int_geom = QgsGeometry(int_geom)
if int_geom.wkbType() == QgsWkbTypes.Unknown or QgsWkbTypes.flatType(int_geom.geometry().wkbType()) == QgsWkbTypes.GeometryCollection:
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
else:
# Geometry list: prevents writing error
# in geometries of different types
# produced by the intersection
# fix #3549
if int_geom.wkbType() in wkbTypeGroups[wkbTypeGroups[int_geom.wkbType()]]:
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
# the remaining bit of featA's geometry
# if there is nothing left, this will just silently fail and we're good
diff_geom = QgsGeometry(geom)
if len(lstIntersectingB) != 0:
intB = QgsGeometry.unaryUnion(lstIntersectingB)
diff_geom = diff_geom.difference(intB)
if diff_geom.wkbType() == QgsWkbTypes.Unknown or QgsWkbTypes.flatType(diff_geom.geometry().wkbType()) == QgsWkbTypes.GeometryCollection:
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
count += 1
feedback.setProgress(int(count * total))
length = len(sourceA.fields())
atMapA = [None] * length
for featA in sourceB.getFeatures(QgsFeatureRequest().setDestinationCrs(sourceA.sourceCrs())):
if feedback.isCanceled():
break
add = False
geom = featA.geometry()
diff_geom = QgsGeometry(geom)
atMap = [None] * length
atMap.extend(featA.attributes())
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMap)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
else:
request = QgsFeatureRequest().setFilterFids(intersects).setSubsetOfAttributes([])
request.setDestinationCrs(sourceA.sourceCrs())
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(diff_geom.geometry())
engine.prepareGeometry()
for featB in sourceA.getFeatures(request):
atMapB = featB.attributes()
tmpGeom = featB.geometry()
if engine.intersects(tmpGeom.geometry()):
add = True
diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
else:
try:
# Ihis only happens if the bounding box
# intersects, but the geometry doesn't
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
if add:
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(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):
sourceA = self.parameterAsSource(parameters, self.INPUT, context)
sourceB = self.parameterAsSource(parameters, self.OVERLAY, context)
geomType = QgsWkbTypes.multiType(sourceA.wkbType())
fields = QgsProcessingUtils.combineFields(sourceA.fields(), sourceB.fields())
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, geomType, sourceA.sourceCrs())
featA = QgsFeature()
featB = QgsFeature()
outFeat = QgsFeature()
indexA = QgsSpatialIndex(sourceA, feedback)
indexB = QgsSpatialIndex(sourceB.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([]).setDestinationCrs(sourceA.sourceCrs(), context.transformContext())), feedback)
total = 100.0 / (sourceA.featureCount() * sourceB.featureCount()) if sourceA.featureCount() and sourceB.featureCount() else 1
count = 0
for featA in sourceA.getFeatures():
if feedback.isCanceled():
break
lstIntersectingB = []
geom = featA.geometry()
atMapA = featA.attributes()
intersects = indexB.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
geom.convertToMultiType()
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
else:
request = QgsFeatureRequest().setFilterFids(intersects).setSubsetOfAttributes([])
request.setDestinationCrs(sourceA.sourceCrs(), context.transformContext())
engine = QgsGeometry.createGeometryEngine(geom.constGet())
engine.prepareGeometry()
for featB in sourceB.getFeatures(request):
atMapB = featB.attributes()
tmpGeom = featB.geometry()
if engine.intersects(tmpGeom.constGet()):
int_geom = geom.intersection(tmpGeom)
lstIntersectingB.append(tmpGeom)
if not int_geom:
# There was a problem creating the intersection
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
int_geom = QgsGeometry()
else:
int_geom = QgsGeometry(int_geom)
if int_geom.wkbType() == QgsWkbTypes.Unknown or QgsWkbTypes.flatType(int_geom.wkbType()) == QgsWkbTypes.GeometryCollection:
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
int_geom.convertToMultiType()
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
else:
# Geometry list: prevents writing error
# in geometries of different types
# produced by the intersection
# fix #3549
if QgsWkbTypes.geometryType(int_geom.wkbType()) == QgsWkbTypes.geometryType(geomType):
try:
int_geom.convertToMultiType()
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
# the remaining bit of featA's geometry
# if there is nothing left, this will just silently fail and we're good
diff_geom = QgsGeometry(geom)
if len(lstIntersectingB) != 0:
intB = QgsGeometry.unaryUnion(lstIntersectingB)
diff_geom = diff_geom.difference(intB)
if diff_geom.wkbType() == QgsWkbTypes.Unknown or QgsWkbTypes.flatType(diff_geom.wkbType()) == QgsWkbTypes.GeometryCollection:
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
try:
diff_geom.convertToMultiType()
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
count += 1
feedback.setProgress(int(count * total))
length = len(sourceA.fields())
atMapA = [None] * length
for featA in sourceB.getFeatures(QgsFeatureRequest().setDestinationCrs(sourceA.sourceCrs(), context.transformContext())):
if feedback.isCanceled():
break
add = False
geom = featA.geometry()
diff_geom = QgsGeometry(geom)
atMap = [None] * length
atMap.extend(featA.attributes())
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
geom.convertToMultiType()
outFeat.setGeometry(geom)
outFeat.setAttributes(atMap)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
else:
request = QgsFeatureRequest().setFilterFids(intersects).setSubsetOfAttributes([])
request.setDestinationCrs(sourceA.sourceCrs(), context.transformContext())
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(diff_geom.constGet())
engine.prepareGeometry()
for featB in sourceA.getFeatures(request):
atMapB = featB.attributes()
tmpGeom = featB.geometry()
if engine.intersects(tmpGeom.constGet()):
add = True
diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
else:
try:
# Ihis only happens if the bounding box
# intersects, but the geometry doesn't
diff_geom.convertToMultiType()
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
if add:
try:
diff_geom.convertToMultiType()
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
feedback.pushInfo(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, progress):
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Union.INPUT))
vlayerB = dataobjects.getObjectFromUri(
self.getParameterValue(Union.INPUT2))
GEOS_EXCEPT = True
FEATURE_EXCEPT = True
vproviderA = vlayerA.dataProvider()
fields = vector.combineVectorFields(vlayerA, vlayerB)
names = [field.name() for field in fields]
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, str(names))
writer = self.getOutputFromName(Union.OUTPUT).getVectorWriter(
fields, vproviderA.geometryType(), vproviderA.crs())
inFeatA = QgsFeature()
inFeatB = QgsFeature()
outFeat = QgsFeature()
indexA = vector.spatialindex(vlayerB)
indexB = vector.spatialindex(vlayerA)
count = 0
nElement = 0
featuresA = vector.features(vlayerA)
nFeat = len(featuresA)
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 50)
nElement += 1
lstIntersectingB = []
geom = QgsGeometry(inFeatA.geometry())
atMapA = inFeatA.attributes()
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
raise GeoAlgorithmExecutionException(
self.tr('Feature exception while computing union'))
else:
for id in intersects:
count += 1
request = QgsFeatureRequest().setFilterFid(id)
inFeatB = vlayerB.getFeatures(request).next()
atMapB = inFeatB.attributes()
tmpGeom = QgsGeometry(inFeatB.geometry())
if geom.intersects(tmpGeom):
int_geom = geom.intersection(tmpGeom)
lstIntersectingB.append(tmpGeom)
if int_geom is None:
# There was a problem creating the intersection
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while computing '
'intersection'))
else:
int_geom = QgsGeometry(int_geom)
if int_geom.wkbType() == 0:
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
outFeat.setGeometry(int_geom)
attrs = []
attrs.extend(atMapA)
attrs.extend(atMapB)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except Exception, err:
raise GeoAlgorithmExecutionException(
self.tr(
'Feature exception while computing union'))
try:
# the remaining bit of inFeatA's geometry
# if there is nothing left, this will just silently fail and we're good
diff_geom = QgsGeometry(geom)
if len(lstIntersectingB) != 0:
intB = QgsGeometry.unaryUnion(lstIntersectingB)
diff_geom = diff_geom.difference(intB)
if diff_geom.wkbType() == 0:
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except Exception, err:
raise GeoAlgorithmExecutionException(
self.tr('Feature exception while computing union'))
def union(union_a, union_b, callback=None):
"""Union of two vector layers.
Issue https://github.com/inasafe/inasafe/issues/3186
Note : This algorithm is copied from :
https://github.com/qgis/QGIS/blob/master/python/plugins/processing/algs/
qgis/Union.py
:param union_a: The vector layer for the union.
:type union_a: QgsVectorLayer
:param union_b: The vector layer for the union.
:type union_b: 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 clip vector layer.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = union_steps['output_layer_name']
processing_step = union_steps['step_name'] # NOQA
output_layer_name = output_layer_name % (
union_a.keywords['layer_purpose'],
union_b.keywords['layer_purpose']
)
fields = union_a.fields()
fields.extend(union_b.fields())
writer = create_memory_layer(
output_layer_name,
union_a.geometryType(),
union_a.crs(),
fields
)
keywords_union_1 = union_a.keywords
keywords_union_2 = union_b.keywords
inasafe_fields_union_1 = keywords_union_1['inasafe_fields']
inasafe_fields_union_2 = keywords_union_2['inasafe_fields']
inasafe_fields = inasafe_fields_union_1
inasafe_fields.update(inasafe_fields_union_2)
# use to avoid modifying original source
writer.keywords = dict(union_a.keywords)
writer.keywords['inasafe_fields'] = inasafe_fields
writer.keywords['title'] = output_layer_name
writer.keywords['layer_purpose'] = 'aggregate_hazard'
writer.keywords['hazard_keywords'] = keywords_union_1.copy()
writer.keywords['aggregation_keywords'] = keywords_union_2.copy()
skip_field = inasafe_fields_union_2[aggregation_id_field['key']]
not_null_field_index = writer.fieldNameIndex(skip_field)
writer.startEditing()
# Begin copy/paste from Processing plugin.
# Please follow their code as their code is optimized.
# The code below is not following our coding standards because we want to
# be able to track any diffs from QGIS easily.
index_a = create_spatial_index(union_b)
index_b = create_spatial_index(union_a)
count = 0
n_element = 0
# Todo fix callback
# nFeat = len(union_a.getFeatures())
for in_feat_a in union_a.getFeatures():
# progress.setPercentage(nElement / float(nFeat) * 50)
n_element += 1
list_intersecting_b = []
geom = geometry_checker(in_feat_a.geometry())
at_map_a = in_feat_a.attributes()
intersects = index_a.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
_write_feature(at_map_a, geom, writer, not_null_field_index)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
LOGGER.debug(
tr('Feature geometry error: One or more output features '
'ignored due to invalid geometry.'))
else:
request = QgsFeatureRequest().setFilterFids(intersects)
engine = QgsGeometry.createGeometryEngine(geom.geometry())
engine.prepareGeometry()
for in_feat_b in union_b.getFeatures(request):
count += 1
at_map_b = in_feat_b.attributes()
tmp_geom = geometry_checker(in_feat_b.geometry())
if engine.intersects(tmp_geom.geometry()):
int_geom = geometry_checker(geom.intersection(tmp_geom))
list_intersecting_b.append(QgsGeometry(tmp_geom))
if not int_geom:
# There was a problem creating the intersection
# LOGGER.debug(
# tr('GEOS geoprocessing error: One or more input '
# 'features have invalid geometry.'))
pass
int_geom = QgsGeometry()
else:
int_geom = QgsGeometry(int_geom)
if int_geom.wkbType() == QgsWKBTypes.Unknown\
or QgsWKBTypes.flatType(
int_geom.geometry().wkbType()) == \
QgsWKBTypes.GeometryCollection:
# Intersection produced different geometry types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(geometry_checker(i))
try:
_write_feature(
at_map_a + at_map_b,
int_geom,
writer,
not_null_field_index,
)
except:
LOGGER.debug(
tr('Feature geometry error: One or '
'more output features ignored due '
'to invalid geometry.'))
else:
# Geometry list: prevents writing error
# in geometries of different types
# produced by the intersection
# fix #3549
if int_geom.wkbType() in wkb_type_groups[
wkb_type_groups[int_geom.wkbType()]]:
try:
_write_feature(
at_map_a + at_map_b,
int_geom,
writer,
not_null_field_index)
except:
LOGGER.debug(
tr('Feature geometry error: One or more '
'output features ignored due to '
'invalid geometry.'))
# the remaining bit of inFeatA's geometry
# if there is nothing left, this will just silently fail and we
# are good
diff_geom = QgsGeometry(geom)
if len(list_intersecting_b) != 0:
int_b = QgsGeometry.unaryUnion(list_intersecting_b)
diff_geom = geometry_checker(diff_geom.difference(int_b))
if diff_geom is None or \
diff_geom.isGeosEmpty() or not diff_geom.isGeosValid():
# LOGGER.debug(
# tr('GEOS geoprocessing error: One or more input '
# 'features have invalid geometry.'))
pass
if diff_geom is not None and (
diff_geom.wkbType() == 0 or QgsWKBTypes.flatType(
diff_geom.geometry().wkbType()) ==
QgsWKBTypes.GeometryCollection):
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(geometry_checker(i))
try:
_write_feature(
at_map_a,
diff_geom,
writer,
not_null_field_index)
except:
LOGGER.debug(
tr('Feature geometry error: One or more output features '
'ignored due to invalid geometry.'))
length = len(union_a.fields())
# nFeat = len(union_b.getFeatures())
for in_feat_a in union_b.getFeatures():
# progress.setPercentage(nElement / float(nFeat) * 100)
geom = geometry_checker(in_feat_a.geometry())
atMap = [None] * length
atMap.extend(in_feat_a.attributes())
intersects = index_b.intersects(geom.boundingBox())
lstIntersectingA = []
for id in intersects:
request = QgsFeatureRequest().setFilterFid(id)
inFeatB = union_a.getFeatures(request).next()
tmpGeom = QgsGeometry(geometry_checker(inFeatB.geometry()))
if geom.intersects(tmpGeom):
lstIntersectingA.append(tmpGeom)
if len(lstIntersectingA) == 0:
res_geom = geom
else:
intA = QgsGeometry.unaryUnion(lstIntersectingA)
res_geom = geom.difference(intA)
if res_geom is None:
# LOGGER.debug(
# tr('GEOS geoprocessing error: One or more input features '
# 'have null geometry.'))
pass
continue # maybe it is better to fail like @gustry
# does below ....
if res_geom.isGeosEmpty() or not res_geom.isGeosValid():
# LOGGER.debug(
# tr('GEOS geoprocessing error: One or more input features '
# 'have invalid geometry.'))
pass
try:
_write_feature(atMap, res_geom, writer, not_null_field_index)
except:
# LOGGER.debug(
# tr('Feature geometry error: One or more output features '
# 'ignored due to invalid geometry.'))
pass
n_element += 1
# End of copy/paste from processing
writer.commitChanges()
fill_hazard_class(writer)
check_layer(writer)
return writer
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Union.INPUT))
vlayerB = dataobjects.getObjectFromUri(
self.getParameterValue(Union.INPUT2))
geomType = vlayerA.wkbType()
fields = vector.combineVectorFields(vlayerA, vlayerB)
writer = self.getOutputFromName(Union.OUTPUT).getVectorWriter(
fields, geomType, vlayerA.crs())
inFeatA = QgsFeature()
inFeatB = QgsFeature()
outFeat = QgsFeature()
indexA = vector.spatialindex(vlayerB)
indexB = vector.spatialindex(vlayerA)
count = 0
nElement = 0
featuresA = vector.features(vlayerA)
nFeat = len(featuresA)
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 50)
nElement += 1
lstIntersectingB = []
geom = inFeatA.geometry()
atMapA = inFeatA.attributes()
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
else:
request = QgsFeatureRequest().setFilterFids(intersects)
engine = QgsGeometry.createGeometryEngine(geom.geometry())
engine.prepareGeometry()
for inFeatB in vlayerB.getFeatures(request):
count += 1
atMapB = inFeatB.attributes()
tmpGeom = inFeatB.geometry()
if engine.intersects(tmpGeom.geometry()):
int_geom = geom.intersection(tmpGeom)
lstIntersectingB.append(tmpGeom)
if not int_geom:
# There was a problem creating the intersection
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('GEOS geoprocessing error: One or more input features have invalid geometry.'
))
int_geom = QgsGeometry()
else:
int_geom = QgsGeometry(int_geom)
if int_geom.wkbType(
) == QgsWkbTypes.Unknown or QgsWkbTypes.flatType(
int_geom.geometry().wkbType(
)) == QgsWkbTypes.GeometryCollection:
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
else:
# Geometry list: prevents writing error
# in geometries of different types
# produced by the intersection
# fix #3549
if int_geom.wkbType() in wkbTypeGroups[
wkbTypeGroups[int_geom.wkbType()]]:
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
# the remaining bit of inFeatA's geometry
# if there is nothing left, this will just silently fail and we're good
diff_geom = QgsGeometry(geom)
if len(lstIntersectingB) != 0:
intB = QgsGeometry.unaryUnion(lstIntersectingB)
diff_geom = diff_geom.difference(intB)
if diff_geom.isGeosEmpty() or not diff_geom.isGeosValid():
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.
tr('GEOS geoprocessing error: One or more input features have invalid geometry.'
))
if diff_geom.wkbType() == 0 or QgsWkbTypes.flatType(
diff_geom.geometry().wkbType(
)) == QgsWkbTypes.GeometryCollection:
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
length = len(vlayerA.fields())
atMapA = [None] * length
featuresA = vector.features(vlayerB)
nFeat = len(featuresA)
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 100)
add = False
geom = inFeatA.geometry()
diff_geom = QgsGeometry(geom)
atMap = [None] * length
atMap.extend(inFeatA.attributes())
intersects = indexB.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
else:
request = QgsFeatureRequest().setFilterFids(intersects)
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(diff_geom.geometry())
engine.prepareGeometry()
for inFeatB in vlayerA.getFeatures(request):
atMapB = inFeatB.attributes()
tmpGeom = inFeatB.geometry()
if engine.intersects(tmpGeom.geometry()):
add = True
diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
if diff_geom.isGeosEmpty(
) or not diff_geom.isGeosValid():
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.
tr('GEOS geoprocessing error: One or more input features have invalid geometry.'
))
else:
try:
# Ihis only happends if the bounding box
# intersects, but the geometry doesn't
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
if add:
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.
tr('Feature geometry error: One or more output features ignored due to invalid geometry.'
))
nElement += 1
del writer
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(self.getParameterValue(Union.INPUT))
vlayerB = dataobjects.getObjectFromUri(self.getParameterValue(Union.INPUT2))
geomType = vlayerA.wkbType()
fields = vector.combineVectorFields(vlayerA, vlayerB)
writer = self.getOutputFromName(Union.OUTPUT).getVectorWriter(fields, geomType, vlayerA.crs())
inFeatA = QgsFeature()
inFeatB = QgsFeature()
outFeat = QgsFeature()
indexA = vector.spatialindex(vlayerB)
indexB = vector.spatialindex(vlayerA)
count = 0
nElement = 0
featuresA = vector.features(vlayerA)
nFeat = len(featuresA)
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 50)
nElement += 1
lstIntersectingB = []
geom = inFeatA.geometry()
atMapA = inFeatA.attributes()
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr("Feature geometry error: One or more output features ignored due to invalid geometry."),
)
else:
request = QgsFeatureRequest().setFilterFids(intersects)
engine = QgsGeometry.createGeometryEngine(geom.geometry())
engine.prepareGeometry()
for inFeatB in vlayerB.getFeatures(request):
count += 1
atMapB = inFeatB.attributes()
tmpGeom = inFeatB.geometry()
if engine.intersects(tmpGeom.geometry()):
int_geom = geom.intersection(tmpGeom)
lstIntersectingB.append(tmpGeom)
if not int_geom:
# There was a problem creating the intersection
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr("GEOS geoprocessing error: One or more input features have invalid geometry."),
)
int_geom = QgsGeometry()
else:
int_geom = QgsGeometry(int_geom)
if (
int_geom.wkbType() == QgsWkbTypes.Unknown
or QgsWkbTypes.flatType(int_geom.geometry().wkbType()) == QgsWkbTypes.GeometryCollection
):
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr(
"Feature geometry error: One or more output features ignored due to invalid geometry."
),
)
else:
# Geometry list: prevents writing error
# in geometries of different types
# produced by the intersection
# fix #3549
if int_geom.wkbType() in wkbTypeGroups[wkbTypeGroups[int_geom.wkbType()]]:
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr(
"Feature geometry error: One or more output features ignored due to invalid geometry."
),
)
# the remaining bit of inFeatA's geometry
# if there is nothing left, this will just silently fail and we're good
diff_geom = QgsGeometry(geom)
if len(lstIntersectingB) != 0:
intB = QgsGeometry.unaryUnion(lstIntersectingB)
diff_geom = diff_geom.difference(intB)
if diff_geom.isGeosEmpty() or not diff_geom.isGeosValid():
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.tr("GEOS geoprocessing error: One or more input features have invalid geometry."),
)
if (
diff_geom.wkbType() == 0
or QgsWkbTypes.flatType(diff_geom.geometry().wkbType()) == QgsWkbTypes.GeometryCollection
):
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr("Feature geometry error: One or more output features ignored due to invalid geometry."),
)
length = len(vlayerA.fields())
atMapA = [None] * length
featuresA = vector.features(vlayerB)
nFeat = len(featuresA)
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 100)
add = False
geom = inFeatA.geometry()
diff_geom = QgsGeometry(geom)
atMap = [None] * length
atMap.extend(inFeatA.attributes())
intersects = indexB.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr("Feature geometry error: One or more output features ignored due to invalid geometry."),
)
else:
request = QgsFeatureRequest().setFilterFids(intersects)
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(diff_geom.geometry())
engine.prepareGeometry()
for inFeatB in vlayerA.getFeatures(request):
atMapB = inFeatB.attributes()
tmpGeom = inFeatB.geometry()
if engine.intersects(tmpGeom.geometry()):
add = True
diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
if diff_geom.isGeosEmpty() or not diff_geom.isGeosValid():
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.tr("GEOS geoprocessing error: One or more input features have invalid geometry."),
)
else:
try:
# Ihis only happends if the bounding box
# intersects, but the geometry doesn't
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr(
"Feature geometry error: One or more output features ignored due to invalid geometry."
),
)
if add:
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr("Feature geometry error: One or more output features ignored due to invalid geometry."),
)
nElement += 1
del writer
def union(union_a, union_b, callback=None):
"""Union of two vector layers.
Issue https://github.com/inasafe/inasafe/issues/3186
Note : This algorithm is copied from :
https://github.com/qgis/QGIS/blob/master/python/plugins/processing/algs/
qgis/Union.py
:param union_a: The vector layer for the union.
:type union_a: QgsVectorLayer
:param union_b: The vector layer for the union.
:type union_b: 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 clip vector layer.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = union_steps['output_layer_name']
processing_step = union_steps['step_name']
output_layer_name = output_layer_name % (
union_a.keywords['layer_purpose'],
union_b.keywords['layer_purpose']
)
fields = union_a.fields()
fields.extend(union_b.fields())
writer = create_memory_layer(
output_layer_name,
union_a.geometryType(),
union_a.crs(),
fields
)
keywords_union_1 = union_a.keywords
keywords_union_2 = union_b.keywords
inasafe_fields_union_1 = keywords_union_1['inasafe_fields']
inasafe_fields_union_2 = keywords_union_2['inasafe_fields']
inasafe_fields = inasafe_fields_union_1
inasafe_fields.update(inasafe_fields_union_2)
# use to avoid modifying original source
writer.keywords = dict(union_a.keywords)
writer.keywords['inasafe_fields'] = inasafe_fields
writer.keywords['title'] = output_layer_name
writer.keywords['layer_purpose'] = 'aggregate_hazard'
writer.keywords['hazard_keywords'] = keywords_union_1.copy()
writer.keywords['aggregation_keywords'] = keywords_union_2.copy()
skip_field = inasafe_fields_union_2[aggregation_id_field['key']]
not_null_field_index = writer.fieldNameIndex(skip_field)
writer.startEditing()
# Begin copy/paste from Processing plugin.
# Please follow their code as their code is optimized.
# The code below is not following our coding standards because we want to
# be able to track any diffs from QGIS easily.
index_a = create_spatial_index(union_b)
index_b = create_spatial_index(union_a)
count = 0
n_element = 0
# Todo fix callback
# nFeat = len(union_a.getFeatures())
for in_feat_a in union_a.getFeatures():
# progress.setPercentage(nElement / float(nFeat) * 50)
n_element += 1
list_intersecting_b = []
geom = geometry_checker(in_feat_a.geometry())
at_map_a = in_feat_a.attributes()
intersects = index_a.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
_write_feature(at_map_a, geom, writer, not_null_field_index)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
LOGGER.debug(
tr('Feature geometry error: One or more output features '
'ignored due to invalid geometry.'))
else:
request = QgsFeatureRequest().setFilterFids(intersects)
engine = QgsGeometry.createGeometryEngine(geom.geometry())
engine.prepareGeometry()
for in_feat_b in union_b.getFeatures(request):
count += 1
at_map_b = in_feat_b.attributes()
tmp_geom = geometry_checker(in_feat_b.geometry())
if engine.intersects(tmp_geom.geometry()):
int_geom = geometry_checker(geom.intersection(tmp_geom))
list_intersecting_b.append(QgsGeometry(tmp_geom))
if not int_geom:
# There was a problem creating the intersection
# LOGGER.debug(
# tr('GEOS geoprocessing error: One or more input '
# 'features have invalid geometry.'))
pass
int_geom = QgsGeometry()
else:
int_geom = QgsGeometry(int_geom)
if int_geom.wkbType() == QgsWKBTypes.Unknown\
or QgsWKBTypes.flatType(
int_geom.geometry().wkbType()) == \
QgsWKBTypes.GeometryCollection:
# Intersection produced different geometry types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(geometry_checker(i))
try:
_write_feature(
at_map_a + at_map_b,
int_geom,
writer,
not_null_field_index,
)
except:
LOGGER.debug(
tr('Feature geometry error: One or '
'more output features ignored due '
'to invalid geometry.'))
else:
# Geometry list: prevents writing error
# in geometries of different types
# produced by the intersection
# fix #3549
if int_geom.wkbType() in wkb_type_groups[
wkb_type_groups[int_geom.wkbType()]]:
try:
_write_feature(
at_map_a + at_map_b,
int_geom,
writer,
not_null_field_index)
except:
LOGGER.debug(
tr('Feature geometry error: One or more '
'output features ignored due to '
'invalid geometry.'))
# the remaining bit of inFeatA's geometry
# if there is nothing left, this will just silently fail and we
# are good
diff_geom = QgsGeometry(geom)
if len(list_intersecting_b) != 0:
int_b = QgsGeometry.unaryUnion(list_intersecting_b)
diff_geom = geometry_checker(diff_geom.difference(int_b))
if diff_geom is None or \
diff_geom.isGeosEmpty() or not diff_geom.isGeosValid():
# LOGGER.debug(
# tr('GEOS geoprocessing error: One or more input '
# 'features have invalid geometry.'))
pass
if diff_geom is not None and (
diff_geom.wkbType() == 0 or QgsWKBTypes.flatType(
diff_geom.geometry().wkbType()) ==
QgsWKBTypes.GeometryCollection):
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(geometry_checker(i))
try:
_write_feature(
at_map_a,
diff_geom,
writer,
not_null_field_index)
except:
LOGGER.debug(
tr('Feature geometry error: One or more output features '
'ignored due to invalid geometry.'))
length = len(union_a.fields())
at_map_a = [None] * length
# nFeat = len(union_b.getFeatures())
for in_feat_a in union_b.getFeatures():
# progress.setPercentage(nElement / float(nFeat) * 100)
add = False
geom = geometry_checker(in_feat_a.geometry())
atMap = [None] * length
atMap.extend(in_feat_a.attributes())
intersects = index_b.intersects(geom.boundingBox())
lstIntersectingA = []
for id in intersects:
request = QgsFeatureRequest().setFilterFid(id)
inFeatB = union_a.getFeatures(request).next()
atMapB = inFeatB.attributes()
tmpGeom = QgsGeometry(geometry_checker(inFeatB.geometry()))
if geom.intersects(tmpGeom):
lstIntersectingA.append(tmpGeom)
if len(lstIntersectingA) == 0:
res_geom = geom
else:
intA = QgsGeometry.unaryUnion(lstIntersectingA)
res_geom = geom.difference(intA)
if res_geom is None:
# LOGGER.debug(
# tr('GEOS geoprocessing error: One or more input features '
# 'have null geometry.'))
pass
continue # maybe it is better to fail like @gustry
# does below ....
if res_geom.isGeosEmpty() or not res_geom.isGeosValid():
# LOGGER.debug(
# tr('GEOS geoprocessing error: One or more input features '
# 'have invalid geometry.'))
pass
try:
_write_feature(atMap, res_geom, writer, not_null_field_index)
except:
# LOGGER.debug(
# tr('Feature geometry error: One or more output features '
# 'ignored due to invalid geometry.'))
pass
n_element += 1
# End of copy/paste from processing
writer.commitChanges()
fill_hazard_class(writer)
check_layer(writer)
return writer
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(self.getParameterValue(Union.INPUT))
vlayerB = dataobjects.getObjectFromUri(self.getParameterValue(Union.INPUT2))
GEOS_EXCEPT = True
FEATURE_EXCEPT = True
vproviderA = vlayerA.dataProvider()
fields = vector.combineVectorFields(vlayerA, vlayerB)
names = [field.name() for field in fields]
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, str(names))
writer = self.getOutputFromName(Union.OUTPUT).getVectorWriter(
fields, vproviderA.geometryType(), vproviderA.crs()
)
inFeatA = QgsFeature()
inFeatB = QgsFeature()
outFeat = QgsFeature()
indexA = vector.spatialindex(vlayerB)
indexB = vector.spatialindex(vlayerA)
count = 0
nElement = 0
featuresA = vector.features(vlayerA)
nFeat = len(featuresA)
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 50)
nElement += 1
found = False
geom = QgsGeometry(inFeatA.geometry())
diff_geom = QgsGeometry(geom)
atMapA = inFeatA.attributes()
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
raise GeoAlgorithmExecutionException(self.tr("Feature exception while computing union"))
else:
for id in intersects:
count += 1
request = QgsFeatureRequest().setFilterFid(id)
inFeatB = vlayerB.getFeatures(request).next()
atMapB = inFeatB.attributes()
tmpGeom = QgsGeometry(inFeatB.geometry())
if geom.intersects(tmpGeom):
found = True
int_geom = geom.intersection(tmpGeom)
if int_geom is None:
# There was a problem creating the intersection
raise GeoAlgorithmExecutionException(
self.tr("Geometry exception while computing " "intersection")
)
else:
int_geom = QgsGeometry(int_geom)
if diff_geom.intersects(tmpGeom):
diff_geom = diff_geom.difference(tmpGeom)
if diff_geom is None:
# It's possible there was an error here?
diff_geom = QgsGeometry()
else:
diff_geom = QgsGeometry(diff_geom)
if int_geom.wkbType() == 0:
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
outFeat.setGeometry(int_geom)
attrs = []
attrs.extend(atMapA)
attrs.extend(atMapB)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except Exception, err:
raise GeoAlgorithmExecutionException(self.tr("Feature exception while computing union"))
else:
# This only happends if the bounding box intersects,
# but the geometry doesn't
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
# Also shoudn't ever happen
raise GeoAlgorithmExecutionException(self.tr("Feature exception while computing union"))
if found:
try:
if diff_geom.wkbType() == 0:
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except Exception, err:
raise GeoAlgorithmExecutionException(self.tr("Feature exception while computing union"))
def processAlgorithm(self, parameters, context, feedback):
vlayerA = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(Union.INPUT), context)
vlayerB = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(Union.INPUT2), context)
geomType = vlayerA.wkbType()
fields = vector.combineFields(vlayerA.fields(), vlayerB.fields())
writer = self.getOutputFromName(Union.OUTPUT).getVectorWriter(fields, geomType, vlayerA.crs(), context)
inFeatA = QgsFeature()
inFeatB = QgsFeature()
outFeat = QgsFeature()
indexA = QgsProcessingUtils.createSpatialIndex(vlayerB, context)
indexB = QgsProcessingUtils.createSpatialIndex(vlayerA, context)
count = 0
nElement = 0
featuresA = QgsProcessingUtils.getFeatures(vlayerA, context)
nFeat = QgsProcessingUtils.featureCount(vlayerA, context)
for inFeatA in featuresA:
feedback.setProgress(nElement / float(nFeat) * 50)
nElement += 1
lstIntersectingB = []
geom = inFeatA.geometry()
atMapA = inFeatA.attributes()
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
QgsMessageLog.logMessage(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'),
self.tr('Processing'), QgsMessageLog.INFO)
else:
request = QgsFeatureRequest().setFilterFids(intersects)
engine = QgsGeometry.createGeometryEngine(geom.geometry())
engine.prepareGeometry()
for inFeatB in vlayerB.getFeatures(request):
count += 1
atMapB = inFeatB.attributes()
tmpGeom = inFeatB.geometry()
if engine.intersects(tmpGeom.geometry()):
int_geom = geom.intersection(tmpGeom)
lstIntersectingB.append(tmpGeom)
if not int_geom:
# There was a problem creating the intersection
QgsMessageLog.logMessage(self.tr('GEOS geoprocessing error: One or more input features have invalid geometry.'),
self.tr('Processing'), QgsMessageLog.INFO)
int_geom = QgsGeometry()
else:
int_geom = QgsGeometry(int_geom)
if int_geom.wkbType() == QgsWkbTypes.Unknown or QgsWkbTypes.flatType(int_geom.geometry().wkbType()) == QgsWkbTypes.GeometryCollection:
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
QgsMessageLog.logMessage(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'),
self.tr('Processing'), QgsMessageLog.INFO)
else:
# Geometry list: prevents writing error
# in geometries of different types
# produced by the intersection
# fix #3549
if int_geom.wkbType() in wkbTypeGroups[wkbTypeGroups[int_geom.wkbType()]]:
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
QgsMessageLog.logMessage(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'),
self.tr('Processing'), QgsMessageLog.INFO)
# the remaining bit of inFeatA's geometry
# if there is nothing left, this will just silently fail and we're good
diff_geom = QgsGeometry(geom)
if len(lstIntersectingB) != 0:
intB = QgsGeometry.unaryUnion(lstIntersectingB)
diff_geom = diff_geom.difference(intB)
if diff_geom.wkbType() == 0 or QgsWkbTypes.flatType(diff_geom.geometry().wkbType()) == QgsWkbTypes.GeometryCollection:
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
QgsMessageLog.logMessage(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'),
self.tr('Processing'), QgsMessageLog.INFO)
length = len(vlayerA.fields())
atMapA = [None] * length
featuresA = QgsProcessingUtils.getFeatures(vlayerB, context)
nFeat = QgsProcessingUtils.featureCount(vlayerB, context)
for inFeatA in featuresA:
feedback.setProgress(nElement / float(nFeat) * 100)
add = False
geom = inFeatA.geometry()
diff_geom = QgsGeometry(geom)
atMap = [None] * length
atMap.extend(inFeatA.attributes())
intersects = indexB.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
QgsMessageLog.logMessage(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'),
self.tr('Processing'), QgsMessageLog.INFO)
else:
request = QgsFeatureRequest().setFilterFids(intersects)
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(diff_geom.geometry())
engine.prepareGeometry()
for inFeatB in vlayerA.getFeatures(request):
atMapB = inFeatB.attributes()
tmpGeom = inFeatB.geometry()
if engine.intersects(tmpGeom.geometry()):
add = True
diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
else:
try:
# Ihis only happens if the bounding box
# intersects, but the geometry doesn't
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
QgsMessageLog.logMessage(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'),
self.tr('Processing'), QgsMessageLog.INFO)
if add:
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
QgsMessageLog.logMessage(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'),
self.tr('Processing'), QgsMessageLog.INFO)
nElement += 1
del writer
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(self.getParameterValue(Union.INPUT))
vlayerB = dataobjects.getObjectFromUri(self.getParameterValue(Union.INPUT2))
geomType = vlayerA.wkbType()
fields = vector.combineVectorFields(vlayerA, vlayerB)
writer = self.getOutputFromName(Union.OUTPUT).getVectorWriter(fields,
geomType,
vlayerA.crs())
inFeatA = QgsFeature()
inFeatB = QgsFeature()
outFeat = QgsFeature()
indexA = vector.spatialindex(vlayerB)
indexB = vector.spatialindex(vlayerA)
count = 0
nElement = 0
featuresA = vector.features(vlayerA)
nFeat = len(featuresA) if len(featuresA) > 0 else 1
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 50)
nElement += 1
lstIntersectingB = []
geom = QgsGeometry(inFeatA.geometry())
atMapA = inFeatA.attributes()
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
else:
for id in intersects:
count += 1
request = QgsFeatureRequest().setFilterFid(id)
inFeatB = vlayerB.getFeatures(request).next()
atMapB = inFeatB.attributes()
tmpGeom = QgsGeometry(inFeatB.geometry())
if geom.intersects(tmpGeom):
int_geom = geom.intersection(tmpGeom)
lstIntersectingB.append(tmpGeom)
if int_geom is None:
# There was a problem creating the intersection
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('GEOS geoprocessing error: One or more input features have invalid geometry.'))
int_geom = QgsGeometry()
else:
int_geom = QgsGeometry(int_geom)
# TODO: the result may have a different dimension (e.g. intersection of two polygons may result in a single point)
# or the result may be a collection of geometries (e.g. intersection of two polygons results in three polygons and one linestring).
# We need to filter out all acceptable geometries into a single (possibly multi-part) geometry - and we need
# to do it consistently also in the code further below
if int_geom.wkbType() == QGis.WKBUnknown or QgsWKBTypes.flatType(int_geom.geometry().wkbType()) == QgsWKBTypes.GeometryCollection:
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
else:
# Geometry list: prevents writing error
# in geometries of different types
# produced by the intersection
# fix #3549
if int_geom.wkbType() in wkbTypeGroups[wkbTypeGroups[int_geom.wkbType()]]:
try:
outFeat.setGeometry(int_geom)
outFeat.setAttributes(atMapA + atMapB)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
# the remaining bit of inFeatA's geometry
# if there is nothing left, this will just silently fail and we're good
diff_geom = QgsGeometry(geom)
if len(lstIntersectingB) != 0:
intB = QgsGeometry.unaryUnion(lstIntersectingB)
diff_geom = diff_geom.difference(intB)
if diff_geom is None:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('GEOS geoprocessing error: One or more input features have invalid geometry.'))
diff_geom = QgsGeometry()
if diff_geom.isGeosEmpty() or not diff_geom.isGeosValid():
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('GEOS geoprocessing error: One or more input features have invalid geometry.'))
# TODO: correctly handly different output geometry types (see todo above)
if diff_geom.wkbType() == 0 or QgsWKBTypes.flatType(diff_geom.geometry().wkbType()) == QgsWKBTypes.GeometryCollection:
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
length = len(vlayerA.fields())
atMapA = [None] * length
featuresA = vector.features(vlayerB)
nFeat = len(featuresA) if len(featuresA) else 1
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 100)
add = False
geom = QgsGeometry(inFeatA.geometry())
atMap = [None] * length
atMap.extend(inFeatA.attributes())
intersects = indexB.intersects(geom.boundingBox())
lstIntersectingA = []
for id in intersects:
request = QgsFeatureRequest().setFilterFid(id)
inFeatB = vlayerA.getFeatures(request).next()
atMapB = inFeatB.attributes()
tmpGeom = QgsGeometry(inFeatB.geometry())
if geom.intersects(tmpGeom):
lstIntersectingA.append(tmpGeom)
if len(lstIntersectingA) == 0:
res_geom = geom
else:
intA = QgsGeometry.unaryUnion(lstIntersectingA)
res_geom = geom.difference(intA)
if res_geom is None:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('GEOS geoprocessing error: One or more input features have invalid geometry.'))
res_geom = QgsGeometry()
if res_geom.isGeosEmpty() or not res_geom.isGeosValid():
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('GEOS geoprocessing error: One or more input features have invalid geometry.'))
# TODO: correctly handly different output geometry types (see todo above)
try:
outFeat.setGeometry(res_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'))
nElement += 1
del writer
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(self.getParameterValue(Union.INPUT))
vlayerB = dataobjects.getObjectFromUri(self.getParameterValue(Union.INPUT2))
GEOS_EXCEPT = True
FEATURE_EXCEPT = True
vproviderA = vlayerA.dataProvider()
fields = vector.combineVectorFields(vlayerA, vlayerB)
names = [field.name() for field in fields]
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, unicode(names))
writer = self.getOutputFromName(Union.OUTPUT).getVectorWriter(fields,
vproviderA.geometryType(), vproviderA.crs())
inFeatA = QgsFeature()
inFeatB = QgsFeature()
outFeat = QgsFeature()
indexA = vector.spatialindex(vlayerB)
indexB = vector.spatialindex(vlayerA)
count = 0
nElement = 0
featuresA = vector.features(vlayerA)
nFeat = len(featuresA)
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 50)
nElement += 1
lstIntersectingB = []
geom = QgsGeometry(inFeatA.geometry())
atMapA = inFeatA.attributes()
intersects = indexA.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except:
# This really shouldn't happen, as we haven't
# edited the input geom at all
raise GeoAlgorithmExecutionException(
self.tr('Feature exception while computing union'))
else:
for id in intersects:
count += 1
request = QgsFeatureRequest().setFilterFid(id)
inFeatB = vlayerB.getFeatures(request).next()
atMapB = inFeatB.attributes()
tmpGeom = QgsGeometry(inFeatB.geometry())
if geom.intersects(tmpGeom):
int_geom = geom.intersection(tmpGeom)
lstIntersectingB.append(tmpGeom)
if int_geom is None:
# There was a problem creating the intersection
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while computing '
'intersection'))
else:
int_geom = QgsGeometry(int_geom)
if int_geom.wkbType() == QGis.WKBUnknown or QgsWKBTypes.flatType(int_geom.geometry().wkbType()) == QgsWKBTypes.GeometryCollection:
# Intersection produced different geomety types
temp_list = int_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
int_geom = QgsGeometry(i)
try:
outFeat.setGeometry(int_geom)
attrs = []
attrs.extend(atMapA)
attrs.extend(atMapB)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
except Exception as err:
raise GeoAlgorithmExecutionException(
self.tr('Feature exception while computing union'))
try:
# the remaining bit of inFeatA's geometry
# if there is nothing left, this will just silently fail and we're good
diff_geom = QgsGeometry(geom)
if len(lstIntersectingB) != 0:
intB = QgsGeometry.unaryUnion(lstIntersectingB)
diff_geom = diff_geom.difference(intB)
if diff_geom.wkbType() == 0 or QgsWKBTypes.flatType(int_geom.geometry().wkbType()) == QgsWKBTypes.GeometryCollection:
temp_list = diff_geom.asGeometryCollection()
for i in temp_list:
if i.type() == geom.type():
diff_geom = QgsGeometry(i)
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMapA)
writer.addFeature(outFeat)
except Exception as err:
raise GeoAlgorithmExecutionException(
self.tr('Feature exception while computing union'))
length = len(vproviderA.fields())
featuresA = vector.features(vlayerB)
nFeat = len(featuresA)
for inFeatA in featuresA:
progress.setPercentage(nElement / float(nFeat) * 100)
add = False
geom = QgsGeometry(inFeatA.geometry())
diff_geom = QgsGeometry(geom)
atMap = [None] * length
atMap.extend(inFeatA.attributes())
intersects = indexB.intersects(geom.boundingBox())
if len(intersects) < 1:
try:
outFeat.setGeometry(geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except Exception as err:
raise GeoAlgorithmExecutionException(
self.tr('Feature exception while computing union'))
else:
for id in intersects:
request = QgsFeatureRequest().setFilterFid(id)
inFeatB = vlayerA.getFeatures(request).next()
atMapB = inFeatB.attributes()
tmpGeom = QgsGeometry(inFeatB.geometry())
try:
if diff_geom.intersects(tmpGeom):
add = True
diff_geom = QgsGeometry(
diff_geom.difference(tmpGeom))
else:
# Ihis only happends if the bounding box
# intersects, but the geometry doesn't
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except Exception as err:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while computing intersection'))
if add:
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(atMap)
writer.addFeature(outFeat)
except Exception as err:
raise err
FEATURE_EXCEPT = False
nElement += 1
del writer
if not GEOS_EXCEPT:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
self.tr('Geometry exception while computing intersection'))
if not FEATURE_EXCEPT:
ProcessingLog.addToLog(ProcessingLog.LOG_WARNING,
self.tr('Feature exception while computing intersection'))
