def testGetGeometry(self):
idx = QgsSpatialIndex()
idx2 = QgsSpatialIndex(QgsSpatialIndex.FlagStoreFeatureGeometries)
fid = 0
for y in range(5):
for x in range(10, 15):
ft = QgsFeature()
ft.setId(fid)
ft.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(x, y)))
idx.insertFeature(ft)
idx2.insertFeature(ft)
fid += 1
# not storing geometries, a keyerror should be raised
with self.assertRaises(KeyError):
idx.geometry(-100)
with self.assertRaises(KeyError):
idx.geometry(1)
with self.assertRaises(KeyError):
idx.geometry(2)
with self.assertRaises(KeyError):
idx.geometry(1000)
self.assertEqual(idx2.geometry(1).asWkt(1), 'Point (11 0)')
self.assertEqual(idx2.geometry(2).asWkt(1), 'Point (12 0)')
with self.assertRaises(KeyError):
idx2.geometry(-100)
with self.assertRaises(KeyError):
idx2.geometry(1000)
def poly2nb(self):
lst = []
index = QgsSpatialIndex()
featsA = self.lyr.getFeatures()
featsB = self.lyr.getFeatures()
for ft in featsA:
index.insertFeature(ft)
featB = QgsFeature()
prv = self.lyr.dataProvider()
while featsB.nextFeature(featB):
geomB = featB.constGeometry()
idb = featB.id()
idxs = index.intersects(geomB.boundingBox())
sor = []
for idx in idxs:
rqst = QgsFeatureRequest().setFilterFid(idx)
featA = prv.getFeatures(rqst).next()
ida = featA.id()
geomA = QgsGeometry(featA.geometry())
if idb!=ida:
if geomB.touches(geomA)==True:
sor.append(ida)
lst.append(sor)
return lst
def compute(self, line1, line2, field1, field2, outPath, matType, nearest, progressBar):
layer1 = ftools_utils.getVectorLayerByName(line1)
layer2 = ftools_utils.getVectorLayerByName(line2)
if layer1.id() == layer2.id():
if nearest > 0:
nearest = nearest + 1
provider1 = layer1.dataProvider()
provider2 = layer2.dataProvider()
sindex = QgsSpatialIndex()
inFeat = QgsFeature()
fit2 = provider2.getFeatures()
while fit2.nextFeature(inFeat):
sindex.insertFeature(inFeat)
if nearest < 1:
nearest = layer2.featureCount()
else:
nearest = nearest
index1 = provider1.fieldNameIndex(field1)
index2 = provider2.fieldNameIndex(field2)
distArea = QgsDistanceArea()
#use srs of the first layer (users should ensure that they are both in the same projection)
# sRs = provider1.crs()
# distArea.setSourceSRS(sRs)
f = open(unicode(outPath), "wb")
writer = UnicodeWriter(f)
if matType != "Standard":
if matType == "Linear":
writer.writerow(["InputID", "TargetID", "Distance"])
else:
writer.writerow(["InputID", "MEAN", "STDDEV", "MIN", "MAX"])
self.linearMatrix(writer, provider1, provider2, index1, index2, nearest, distArea, matType, sindex, progressBar)
else:
self.regularMatrix(writer, provider1, provider2, index1, index2, nearest, distArea, sindex, progressBar)
f.close()
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context)
bbox = source.sourceExtent()
sourceIndex = QgsSpatialIndex(source, feedback)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Point, source.sourceCrs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
ids = sourceIndex.intersects(geom.buffer(5, 5).boundingBox())
if len(ids) > 0 and \
vector.checkMinDistance(p, index, minDistance, points):
request = QgsFeatureRequest().setFilterFids(ids).setSubsetOfAttributes([])
for f in source.getFeatures(request):
if feedback.isCanceled():
break
tmpGeom = f.geometry()
if geom.within(tmpGeom):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(self.tr('Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def testIndex(self):
idx = QgsSpatialIndex()
fid = 0
for y in range(5, 15, 5):
for x in range(5, 25, 5):
ft = QgsFeature()
ft.setFeatureId(fid)
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(x, y)))
idx.insertFeature(ft)
fid += 1
# intersection test
rect = QgsRectangle(7.0, 3.0, 17.0, 13.0)
fids = idx.intersects(rect)
myExpectedValue = 4
myValue = len(fids)
myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myValue)
self.assertEqual(myValue, myExpectedValue, myMessage)
fids.sort()
myMessage = ('Expected: %s\nGot: %s\n' %
([1, 2, 5, 6], fids))
assert fids == [1, 2, 5, 6], myMessage
# nearest neighbor test
fids = idx.nearestNeighbor(QgsPoint(8.75, 6.25), 3)
myExpectedValue = 0
myValue = len(fids)
myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myValue)
fids.sort()
myMessage = ('Expected: %s\nGot: %s\n' %
([0, 1, 5], fids))
assert fids == [0, 1, 5], myMessage
def createIndex(provider):
feat = QgsFeature()
index = QgsSpatialIndex()
fit = provider.getFeatures()
while fit.nextFeature(feat):
index.insertFeature(feat)
return index
class LayerIndex:
def __init__(self, layer):
self.__layer = layer
self.__index = QgsSpatialIndex()
feats = vector.features(layer)
for ft in feats:
self.__index.insertFeature(ft)
def contains(self, point):
"""Return true if the point intersects the layer"""
intersects = self.__index.intersects(point.boundingBox())
for i in intersects:
request = QgsFeatureRequest().setFilterFid(i)
feat = self.__layer.getFeatures(request).next()
tmpGeom = QgsGeometry(feat.geometry())
if point.intersects(tmpGeom):
return True
return False
def countIntersection(self,bufferGeom,nb):
"""Return true if the buffer intersects enough entities"""
count = 0
intersects = self.__index.intersects(bufferGeom.boundingBox())
for i in intersects:
request = QgsFeatureRequest().setFilterFid(i)
feat = self.__layer.getFeatures(request).next()
tmpGeom = QgsGeometry(feat.geometry())
if bufferGeom.intersects(tmpGeom):
count += 1
if count >= nb:
return True
return False
def get_spatial_index(data_provider):
"""Create spatial index from a data provider."""
qgs_feature = QgsFeature()
index = QgsSpatialIndex()
qgs_features = data_provider.getFeatures()
while qgs_features.nextFeature(qgs_feature):
index.insertFeature(qgs_feature)
return index
def spatialindex(layer):
"""Creates a spatial index for the passed vector layer.
"""
idx = QgsSpatialIndex()
feats = features(layer)
for ft in feats:
idx.insertFeature(ft)
return idx
def buildReferenceIndex(self, segments):
refDict = {}
index = QgsSpatialIndex()
for i, segment in enumerate(segments):
refDict[i] = segment
feature = QgsFeature(i)
feature.setGeometry(segment)
index.insertFeature(feature)
return refDict, index
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.VECTOR))
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
bbox = layer.extent()
idxLayer = vector.spatialindex(layer)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, layer.crs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
ids = idxLayer.intersects(geom.buffer(5, 5).boundingBox())
if len(ids) > 0 and \
vector.checkMinDistance(pnt, index, minDistance, points):
for i in ids:
f = next(layer.getFeatures(request.setFilterFid(i)))
tmpGeom = f.geometry()
if geom.within(tmpGeom):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
progress.setPercentage(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
del writer
def processAlgorithm(self, feedback):
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
extent = str(self.getParameterValue(self.EXTENT)).split(',')
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
extent = QgsGeometry().fromRect(
QgsRectangle(xMin, yMin, xMax, yMax))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = xMin + (xMax - xMin) * random.random()
ry = yMin + (yMax - yMin) * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(extent) and \
vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
del writer
def processAlgorithm(self, parameters, context, feedback):
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context)
crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context, crs)
extent = QgsGeometry().fromRect(bbox)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Point, crs)
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
if geom.within(extent) and \
vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(self.tr('Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, progress):
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
extent = unicode(self.getParameterValue(self.EXTENT)).split(',')
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
extent = QgsGeometry().fromRect(
QgsRectangle(xMin, yMin, xMax, yMax))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QGis.WKBPoint, mapCRS)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount > 0 else 1
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = xMin + (xMax - xMin) * random.random()
ry = yMin + (yMax - yMin) * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(extent) and \
vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
progress.setPercentage(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
del writer
def createIndex( provider ):
'''
return Spatial Index of line layer features
@param provider: QgsDataProvider
'''
feat = QgsFeature()
index = QgsSpatialIndex()
provider.rewind()
provider.select()
while provider.nextFeature( feat ):
index.insertFeature( feat )
return index
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.VECTOR), context)
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
bbox = layer.extent()
idxLayer = QgsProcessingUtils.createSpatialIndex(layer, context)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
ids = idxLayer.intersects(geom.buffer(5, 5).boundingBox())
if len(ids) > 0 and \
vector.checkMinDistance(pnt, index, minDistance, points):
request = QgsFeatureRequest().setFilterFids(ids).setSubsetOfAttributes([])
for f in layer.getFeatures(request):
tmpGeom = f.geometry()
if geom.within(tmpGeom):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
QgsMessageLog.logMessage(self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'), self.tr('Processing'), QgsMessageLog.INFO)
del writer
class TriangleMesh:
# 0 - 3
# | / |
# 1 - 2
def __init__(self, xmin, ymin, xmax, ymax, x_segments, y_segments):
self.flen = 0
self.quadrangles = []
self.spatial_index = QgsSpatialIndex()
xres = (xmax - xmin) / x_segments
yres = (ymax - ymin) / y_segments
for y in range(y_segments):
for x in range(x_segments):
pt0 = QgsPoint(xmin + x * xres, ymax - y * yres)
pt1 = QgsPoint(xmin + x * xres, ymax - (y + 1) * yres)
pt2 = QgsPoint(xmin + (x + 1) * xres, ymax - (y + 1) * yres)
pt3 = QgsPoint(xmin + (x + 1) * xres, ymax - y * yres)
self._addQuadrangle(pt0, pt1, pt2, pt3)
def _addQuadrangle(self, pt0, pt1, pt2, pt3):
f = QgsFeature(self.flen)
f.setGeometry(QgsGeometry.fromPolygon([[pt0, pt1, pt2, pt3, pt0]]))
self.quadrangles.append(f)
self.spatial_index.insertFeature(f)
self.flen += 1
def intersects(self, geom):
for fid in self.spatial_index.intersects(geom.boundingBox()):
quad = self.quadrangles[fid].geometry()
if quad.intersects(geom):
yield quad
def splitPolygons(self, geom):
for quad in self.intersects(geom):
pts = quad.asPolygon()[0]
tris = [[[pts[0], pts[1], pts[3], pts[0]]], [[pts[3], pts[1], pts[2], pts[3]]]]
if geom.contains(quad):
yield tris[0]
yield tris[1]
else:
for i, tri in enumerate(map(QgsGeometry.fromPolygon, tris)):
if geom.contains(tri):
yield tris[i]
elif geom.intersects(tri):
poly = geom.intersection(tri)
if poly.isMultipart():
for sp in poly.asMultiPolygon():
yield sp
else:
yield poly.asPolygon()
def get_spatial_index(data_provider):
"""Create spatial index from a data provider.
:param data_provider: QGIS data provider name .e.g.'ogr'.
:type data_provider: str
"""
qgs_feature = QgsFeature()
index = QgsSpatialIndex()
# noinspection PyUnresolvedReferences
qgs_features = data_provider.getFeatures()
while qgs_features.nextFeature(qgs_feature):
index.insertFeature(qgs_feature)
return index
def compute_graph(features, feedback, create_id_graph=False, min_distance=0):
""" compute topology from a layer/field """
s = Graph(sort_graph=False)
id_graph = None
if create_id_graph:
id_graph = Graph(sort_graph=True)
# skip features without geometry
features_with_geometry = {f_id: f for (f_id, f) in features.items() if f.hasGeometry()}
total = 70.0 / len(features_with_geometry) if features_with_geometry else 1
index = QgsSpatialIndex()
i = 0
for feature_id, f in features_with_geometry.items():
if feedback.isCanceled():
break
g = f.geometry()
if min_distance > 0:
g = g.buffer(min_distance, 5)
engine = QgsGeometry.createGeometryEngine(g.constGet())
engine.prepareGeometry()
feature_bounds = g.boundingBox()
# grow bounds a little so we get touching features
feature_bounds.grow(feature_bounds.width() * 0.01)
intersections = index.intersects(feature_bounds)
for l2 in intersections:
f2 = features_with_geometry[l2]
if engine.intersects(f2.geometry().constGet()):
s.add_edge(f.id(), f2.id())
s.add_edge(f2.id(), f.id())
if id_graph:
id_graph.add_edge(f.id(), f2.id())
index.insertFeature(f)
i += 1
feedback.setProgress(int(i * total))
for feature_id, f in features_with_geometry.items():
if feedback.isCanceled():
break
if feature_id not in s.node_edge:
s.add_edge(feature_id, None)
return s, id_graph
def create_spatial_index(self, layer):
spatial_index = QgsSpatialIndex()
# features dictionary
centroid_features = {}
features = layer.getFeatures()
for feature in features:
# convert to point feature
point_feature = QgsFeature(layer.fields())
point_feature.setId(feature.id())
point_feature.setAttributes(feature.attributes())
point_feature.setGeometry(feature.geometry().centroid())
centroid_features[point_feature.id()] = point_feature
spatial_index.insertFeature(point_feature)
return (spatial_index, centroid_features)
def create_spatial_index(layer):
"""Helper function to create the spatial index on a vector layer.
This function is mainly used to see the processing time with the decorator.
:param layer: The vector layer.
:type layer: QgsVectorLayer
:return: The index.
:rtype: QgsSpatialIndex
"""
request = QgsFeatureRequest().setSubsetOfAttributes([])
try:
spatial_index = QgsSpatialIndex(layer.getFeatures(request))
except BaseException:
# Spatial index is creating an unknown exception.
# https://github.com/inasafe/inasafe/issues/4304
# or https://gitter.im/inasafe/inasafe?at=5a2903d487680e6230e0359a
LOGGER.warning(
'An Exception has been raised from the spatial index creation. '
'We will clean your layer and try again.')
new_layer = clean_layer(layer)
try:
spatial_index = QgsSpatialIndex(new_layer.getFeatures())
except BaseException:
# We got another exception.
# We try now to insert feature by feature.
# It's slower than the using the feature iterator.
spatial_index = QgsSpatialIndex()
for feature in new_layer.getFeatures(request):
try:
spatial_index.insertFeature(feature)
except BaseException:
LOGGER.critical(
'A feature has been removed from the spatial index.')
# # We tried one time to clean the layer, we can't do more.
# LOGGER.critical(
# 'An Exception has been raised from the spatial index '
# 'creation. Unfortunately, we already try to clean your '
# 'layer. We will stop here the process.')
# raise SpatialIndexCreationError
return spatial_index
class LayerIndex(object):
"""Check an intersection between a QgsGeometry and a QgsVectorLayer."""
def __init__(self, layer):
self.__layer = layer
if QGis.QGIS_VERSION_INT >= 20700:
self.__index = QgsSpatialIndex(layer.getFeatures())
else:
self.__index = QgsSpatialIndex()
for ft in layer.getFeatures():
self.__index.insertFeature(ft)
def contains(self, point):
"""Return true if the point intersects the layer."""
intersects = self.__index.intersects(point.boundingBox())
for i in intersects:
request = QgsFeatureRequest().setFilterFid(i)
feat = self.__layer.getFeatures(request).next()
if point.intersects(QgsGeometry(feat.geometry())):
return True
return False
def count_intersection(self, buffer_geom, nb):
"""Return true if the buffer intersects enough entities."""
count = 0
intersects = self.__index.intersects(buffer_geom.boundingBox())
for i in intersects:
request = QgsFeatureRequest().setFilterFid(i)
feat = self.__layer.getFeatures(request).next()
if buffer_geom.intersects(QgsGeometry(feat.geometry())):
count += 1
if count >= nb:
return True
return False
class breakTool(QObject):
finished = pyqtSignal(object)
error = pyqtSignal(Exception, basestring)
progress = pyqtSignal(float)
warning = pyqtSignal(str)
killed = pyqtSignal(bool)
def __init__(self,layer, tolerance, uid, errors, unlinks):
QObject.__init__(self)
self.layer = layer
self.feat_count = self.layer.featureCount()
self.tolerance = tolerance
self.uid = uid
self.errors = errors
self.errors_features = {}
self.unlinks = unlinks
self.unlinked_features = []
self.unlinks_count = 0
self.ml_keys = {}
self.br_keys = {}
self.features = []
self.attributes = {}
self.geometries = {}
self.geometries_wkt = {}
self.geometries_vertices = {}
# create spatial index object
self.spIndex = QgsSpatialIndex()
self.layer_fields = [QgsField(i.name(), i.type()) for i in self.layer.dataProvider().fields()]
def add_edges(self):
new_key_count = 0
f_count = 1
for f in self.layer.getFeatures():
self.progress.emit(3 * f_count / self.feat_count)
f_count += 1
if self.killed is True:
break
geom_type = f.geometry().wkbType()
if geom_type not in [5,2,1] and f.geometry().geometry().is3D():
f.geometry().geometry().dropZValue()
geom_type = f.geometry().wkbType()
if geom_type == 5:
if self.errors:
self.errors_features[f.id()] = ('multipart', f.geometry().exportToWkt())
for multipart in f.geometry().asGeometryCollection():
new_key_count += 1
attr = f.attributes()
new_feat = QgsFeature()
new_feat.setAttributes(attr)
new_feat.setFeatureId(new_key_count)
if self.tolerance:
snapped_wkt = make_snapped_wkt(multipart.exportToWkt(), self.tolerance)
else:
snapped_wkt = multipart.exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
new_feat.setGeometry(snapped_geom)
self.features.append(new_feat)
self.attributes[new_key_count] = attr
self.geometries[new_key_count] = new_feat.geometryAndOwnership()
self.geometries_wkt[new_key_count] = snapped_wkt
self.geometries_vertices[new_key_count] = [vertex for vertex in vertices_from_wkt_2(snapped_wkt)]
# insert features to index
self.spIndex.insertFeature(new_feat)
self.ml_keys[new_key_count] = f.id()
elif geom_type == 1:
if self.errors:
self.errors_features[f.id()] = ('point', QgsGeometry().exportToWkt())
elif not f.geometry().isGeosValid():
if self.errors:
self.errors_features[f.id()] = ('invalid', QgsGeometry().exportToWkt())
elif geom_type == 2:
attr = f.attributes()
if self.tolerance:
snapped_wkt = make_snapped_wkt(f.geometry().exportToWkt(), self.tolerance)
else:
snapped_wkt = f.geometry().exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
f.setGeometry(snapped_geom)
new_key_count += 1
f.setFeatureId(new_key_count)
self.features.append(f)
self.attributes[f.id()] = attr
self.geometries[f.id()] = f.geometryAndOwnership()
self.geometries_wkt[f.id()] = snapped_wkt
self.geometries_vertices[f.id()] = [vertex for vertex in vertices_from_wkt_2(snapped_wkt)]
# insert features to index
self.spIndex.insertFeature(f)
self.ml_keys[new_key_count] = f.id()
def break_features(self):
broken_features = []
f_count = 1
for fid in self.geometries.keys():
if self.killed is True:
break
f_geom = self.geometries[fid]
f_attrs = self.attributes[fid]
# intersecting lines
gids = self.spIndex.intersects(f_geom.boundingBox())
self.progress.emit((45 * f_count / self.feat_count) + 5)
f_count += 1
f_errors, vertices = self.find_breakages(fid, gids)
if self.errors and f_errors:
original_id = self.ml_keys[fid]
try:
updated_errors = self.errors_features[original_id][0] + f_errors
self.errors_features[original_id] = (updated_errors, self.errors_features[original_id][1])
except KeyError:
self.errors_features[original_id] = (f_errors, self.geometries[fid].exportToWkt())
if f_errors is None:
vertices = [0, len(f_geom.asPolyline()) - 1 ]
if f_errors in ['breakage, overlap', 'breakage', 'overlap', None]:
for ind, index in enumerate(vertices):
if ind != len(vertices) - 1:
points = [self.geometries_vertices[fid][i] for i in range(index, vertices[ind + 1] + 1)]
p = ''
for point in points:
p += point[0] + ' ' + point[1] + ', '
wkt = 'LINESTRING(' + p[:-2] + ')'
self.feat_count += 1
new_fid = self.feat_count
new_feat = [new_fid, f_attrs, wkt]
broken_features.append(new_feat)
self.br_keys[new_fid] = fid
return broken_features
def kill(self):
self.br_killed = True
def find_breakages(self, fid, gids):
f_geom = self.geometries[fid]
# errors checks
must_break = False
is_closed = False
if f_geom.asPolyline()[0] == f_geom.asPolyline()[-1]:
is_closed = True
is_orphan = True
is_duplicate = False
has_overlaps = False
# get breaking points
breakages = []
# is self intersecting
is_self_intersersecting = False
for i in f_geom.asPolyline():
if f_geom.asPolyline().count(i) > 1:
point = QgsGeometry().fromPoint(QgsPoint(i[0], i[1]))
breakages.append(point)
is_self_intersersecting = True
must_break = True
for gid in gids:
g_geom = self.geometries[gid]
if gid < fid:
# duplicate geometry
if f_geom.isGeosEqual(g_geom):
is_duplicate = True
if self.unlinks:
if f_geom.crosses(g_geom):
crossing_point = f_geom.intersection(g_geom)
if crossing_point.wkbType() == 1:
self.unlinks_count += 1
unlinks_attrs = [[self.unlinks_count], [gid], [fid], [crossing_point.asPoint()[0]],
[crossing_point.asPoint()[1]]]
self.unlinked_features.append([self.unlinks_count, unlinks_attrs, crossing_point.exportToWkt()])
elif crossing_point.wkbType() == 4:
for cr_point in crossing_point.asGeometryCollection():
self.unlinks_count += 1
unlinks_attrs = [[self.unlinks_count], [gid], [fid], [cr_point.asPoint()[0]],
[cr_point.asPoint()[1]]]
self.unlinked_features.append([self.unlinks_count, unlinks_attrs, cr_point.exportToWkt()])
if is_duplicate is False:
intersection = f_geom.intersection(g_geom)
# intersecting geometries at point
if intersection.wkbType() == 1 and point_is_vertex(intersection, f_geom):
breakages.append(intersection)
is_orphan = False
must_break = True
# intersecting geometries at multiple points
elif intersection.wkbType() == 4:
for point in intersection.asGeometryCollection():
if point_is_vertex(point, f_geom):
breakages.append(point)
is_orphan = False
must_break = True
# overalpping geometries
elif intersection.wkbType() == 2 and intersection.length() != f_geom.length():
point1 = QgsGeometry.fromPoint(QgsPoint(intersection.asPolyline()[0]))
point2 = QgsGeometry.fromPoint(QgsPoint(intersection.asPolyline()[-1]))
if point_is_vertex(point1, f_geom):
breakages.append(point1)
is_orphan = False
must_break = True
if point_is_vertex(point2, f_geom):
breakages.append(point2)
is_orphan = False
must_break = True
# overalpping multi-geometries
# every feature overlaps with itself as a multilinestring
elif intersection.wkbType() == 5 and intersection.length() != f_geom.length():
point1 = QgsGeometry.fromPoint(QgsPoint(intersection.asGeometryCollection()[0].asPolyline()[0]))
point2 = QgsGeometry.fromPoint(QgsPoint(intersection.asGeometryCollection()[-1].asPolyline()[-1]))
if point_is_vertex(point1, f_geom):
is_orphan = False
has_overlaps = True
breakages.append(point1)
if point_is_vertex(point2, f_geom):
is_orphan = False
has_overlaps = True
breakages.append(point2)
if is_duplicate is True:
return 'duplicate', []
else:
# add first and last vertex
vertices = set([vertex for vertex in find_vertex_index(breakages, f_geom)])
vertices = list(vertices) + [0] + [len(f_geom.asPolyline()) - 1]
vertices = list(set(vertices))
vertices.sort()
if is_orphan:
if is_closed is True:
return 'closed polyline', []
else:
return 'orphan', []
elif is_self_intersersecting:
if has_overlaps:
return 'breakage, overlap', vertices
else:
return 'breakage', vertices
elif has_overlaps or must_break:
if has_overlaps is True and must_break is True:
return 'breakage, overlap', vertices
elif has_overlaps is True and must_break is False:
return 'overlap', vertices
elif has_overlaps is False and must_break is True:
if len(vertices) > 2:
return 'breakage', vertices
else:
return None, []
else:
return None, []
def updateErrors(self, errors_dict):
for k, v in errors_dict.items():
try:
original_id = self.br_keys[k]
try:
original_id = self.ml_keys[k]
except KeyError:
pass
except KeyError:
original_id = None
if original_id:
try:
updated_errors = self.errors_features[original_id][0]
if ', continuous line' not in self.errors_features[original_id][0]:
updated_errors += ', continuous line'
self.errors_features[original_id] = (updated_errors, self.errors_features[original_id][1])
except KeyError:
self.errors_features[original_id] = ('continuous line', self.geometries[original_id].exportToWkt())
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Point, source.sourceCrs())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
featureCount = source.featureCount()
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs(), context.transformContext())
da.setEllipsoid(context.project().ellipsoid())
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
# pick random feature
fid = random.randint(0, featureCount - 1)
f = next(source.getFeatures(request.setFilterFid(fid).setSubsetOfAttributes([])))
fGeom = f.geometry()
if fGeom.isMultipart():
lines = fGeom.asMultiPolyline()
# pick random line
lineId = random.randint(0, len(lines) - 1)
vertices = lines[lineId]
else:
vertices = fGeom.asPolyline()
# pick random segment
if len(vertices) == 2:
vid = 0
else:
vid = random.randint(0, len(vertices) - 2)
startPoint = vertices[vid]
endPoint = vertices[vid + 1]
length = da.measureLine(startPoint, endPoint)
dist = length * random.random()
if dist > minDistance:
d = dist / (length - dist)
rx = (startPoint.x() + d * endPoint.x()) / (1 + d)
ry = (startPoint.y() + d * endPoint.y()) / (1 + d)
# generate random point
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
if vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(self.tr('Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def SpatialIndex(self, mem_layer):
# Create Spatial Index
index = QgsSpatialIndex()
for f in mem_layer.getFeatures():
index.insertFeature(f)
return index
def _raster_to_vector_cells(raster, minimum_threshold, maximum_threshold,
output_crs):
"""Generate vectors features (rectangles) for raster cells.
Cells which are not within threshold (threshold_min < V < threshold_max)
will be excluded. The provided CRS will be used to determine the
CRS of the output vector cells layer.
:param minimum_threshold: The minimum threshold for pixels to be included.
:type minimum_threshold: float
:param maximum_threshold: The maximum threshold for pixels to be included.
:type maximum_threshold: float
:param raster: A raster layer that will be vectorised.
:type raster: QgsRasterLayer
:param output_crs: The CRS to use for the output vector cells layer.
:type output_crs: QgsCoordinateReferenceSystem
:returns: A two-tuple containing a spatial index and a map (dict) where
map keys are feature id's and the value is the feature for that id.
:rtype: (QgsSpatialIndex, dict)
"""
# get raster data
provider = raster.dataProvider()
extent = provider.extent()
raster_cols = provider.xSize()
raster_rows = provider.ySize()
block = provider.block(1, extent, raster_cols, raster_rows)
raster_xmin = extent.xMinimum()
raster_ymax = extent.yMaximum()
cell_width = extent.width() / raster_cols
cell_height = extent.height() / raster_rows
uri = "Polygon?crs=" + output_crs.authid()
vl = QgsVectorLayer(uri, "cells", "memory")
features = []
# prepare coordinate transform to reprojection
ct = QgsCoordinateTransform(raster.crs(), output_crs)
for y in xrange(raster_rows):
for x in xrange(raster_cols):
# only use cells that are within the specified threshold
value = block.value(y, x)
if value < minimum_threshold or value > maximum_threshold:
continue
# construct rectangular polygon feature for the cell
x0 = raster_xmin + (x * cell_width)
x1 = raster_xmin + ((x + 1) * cell_width)
y0 = raster_ymax - (y * cell_height)
y1 = raster_ymax - ((y + 1) * cell_height)
outer_ring = [
QgsPoint(x0, y0),
QgsPoint(x1, y0),
QgsPoint(x1, y1),
QgsPoint(x0, y1),
QgsPoint(x0, y0)
]
# noinspection PyCallByClass
geometry = QgsGeometry.fromPolygon([outer_ring])
geometry.transform(ct)
f = QgsFeature()
f.setGeometry(geometry)
features.append(f)
_, features = vl.dataProvider().addFeatures(features)
# construct a temporary map for fast access to features by their IDs
# (we will be getting feature IDs from spatial index)
flood_cells_map = {}
for f in features:
flood_cells_map[f.id()] = f
# build a spatial index so we can quickly identify
# flood cells overlapping roads
if QGis.QGIS_VERSION_INT >= 20800:
# woohoo we can use bulk insert (much faster)
index = QgsSpatialIndex(vl.getFeatures())
else:
index = QgsSpatialIndex()
for f in vl.getFeatures():
index.insertFeature(f)
return index, flood_cells_map
def enclaveRemover(self):
field_id = self.activeLayer.fieldNameIndex(self.distfield)
self.activeLayer.startEditing()
# Create a dictionary of all features
feature_dict = {f.id(): f for f in self.activeLayer.getFeatures()}
QgsMessageLog.logMessage("Building spatial index...")
# Build a spatial index
index = QgsSpatialIndex()
for f in feature_dict.values():
index.insertFeature(f)
QgsMessageLog.logMessage("Finding neighbors...")
# Loop through all features and find features that touch each feature
for f in feature_dict.values():
geom = f.geometry()
# Find all features that intersect the bounding box of the current feature.
# We use spatial index to find the features intersecting the bounding box
# of the current feature. This will narrow down the features that we need
# to check neighboring features.
intersecting_ids = index.intersects(geom.boundingBox())
# Initalize neighbors list and sum
neighbors = []
neighbors_district = -1
finished = 0
if f[self.distfield] == 0:
QgsMessageLog.logMessage("feature " + str(f.id()) +
" with null distfield found!")
while neighbors_district <> -2 and finished == 0:
finished = 0
for intersecting_id in intersecting_ids:
# Look up the feature from the dictionary
intersecting_f = feature_dict[intersecting_id]
QgsMessageLog.logMessage("Neighbor found!")
# For our purpose we consider a feature as 'neighbor' if it touches or
# intersects a feature. We use the 'disjoint' predicate to satisfy
# these conditions. So if a feature is not disjoint, it is a neighbor.
if (f != intersecting_f and
not intersecting_f.geometry().disjoint(geom)):
if intersecting_f[self.distfield] > 0:
QgsMessageLog.logMessage(
"Neighbor found with > 0!")
if neighbors_district == -1:
neighbors_district = intersecting_f[
self.distfield]
QgsMessageLog.logMessage(
"neighbors_district set to " +
str(neighbors_district))
elif neighbors_district != intersecting_f[
self.distfield]:
neighbors_district = -2
QgsMessageLog.logMessage(
"neighbors_district set to " +
str(neighbors_district) + ", " +
str(intersecting_f[self.distfield]) +
" not matching")
if neighbors_district > 0:
QgsMessageLog.logMessage(
str(f.id()) + " updating district to " +
str(neighbors_district))
self.activeLayer.changeAttributeValue(
f.id(), field_id, neighbors_district)
# Update the layer with new attribute values.
finished = 1
self.activeLayer.commitChanges()
class LeastCommonDenominatorProcedure(WorkerThread):
def __init__(self, parentThread, flayer, tlayer, ffield, tfield):
WorkerThread.__init__(self, parentThread)
self.flayer = flayer
self.tlayer = tlayer
self.ffield = ffield
self.tfield = tfield
self.error = None
self.result = None
self.output_type = None
self.transform = None
self.poly_types = poly_types + multi_poly
self.line_types = line_types + multi_line
self.point_types = point_types + multi_point
def doWork(self):
flayer = self.flayer
tlayer = self.tlayer
ffield = self.ffield
tfield = self.tfield
self.from_layer = get_vector_layer_by_name(flayer)
self.to_layer = get_vector_layer_by_name(tlayer)
EPSG1 = QgsCoordinateReferenceSystem(
int(self.from_layer.crs().authid().split(":")[1]))
EPSG2 = QgsCoordinateReferenceSystem(
int(self.to_layer.crs().authid().split(":")[1]))
if EPSG1 != EPSG2:
self.transform = QgsCoordinateTransform(EPSG1, EPSG2,
QgsProject.instance())
# FIELDS INDICES
idx = self.from_layer.dataProvider().fieldNameIndex(ffield)
fid = self.to_layer.dataProvider().fieldNameIndex(tfield)
# We create an spatial self.index to hold all the features of the layer that will receive the data
# And a dictionary that will hold all the features IDs found to intersect with each feature in the spatial index
self.ProgressMaxValue.emit(self.to_layer.dataProvider().featureCount())
self.ProgressText.emit("Building Spatial Index")
self.ProgressValue.emit(0)
allfeatures = {}
merged = {}
self.index = QgsSpatialIndex()
for i, feature in enumerate(self.to_layer.getFeatures()):
allfeatures[feature.id()] = feature
merged[feature.id()] = feature
self.index.insertFeature(feature)
self.ProgressValue.emit(i)
self.ProgressText.emit("Duplicating Layers")
self.all_attr = {}
# We create the memory layer that will have the analysis result, which is the lowest common
# denominator of both layers
epsg_code = int(self.to_layer.crs().authid().split(":")[1])
if self.from_layer.wkbType(
) in self.poly_types and self.to_layer.wkbType() in self.poly_types:
lcd_layer = QgsVectorLayer(
"MultiPolygon?crs=epsg:" + str(epsg_code), "output", "memory")
self.output_type = "Poly"
elif (self.from_layer.wkbType() in self.poly_types + self.line_types
and self.to_layer.wkbType()
in self.poly_types + self.line_types):
lcd_layer = QgsVectorLayer(
"MultiLineString?crs=epsg:" + str(epsg_code), "output",
"memory")
self.output_type = "Line"
else:
lcd_layer = QgsVectorLayer("MultiPoint?crs=epsg:" + str(epsg_code),
"output", "memory")
self.output_type = "Point"
lcdpr = lcd_layer.dataProvider()
lcdpr.addAttributes([
QgsField("Part_ID", QVariant.Int),
QgsField(ffield,
self.from_layer.fields().field(idx).type()),
QgsField(tfield,
self.to_layer.fields().field(fid).type()),
QgsField("P-" + str(ffield),
QVariant.Double), # percentage of the from field
QgsField("P-" + str(tfield), QVariant.Double),
]) # percentage of the to field
lcd_layer.updateFields()
# PROGRESS BAR
self.ProgressMaxValue.emit(
self.from_layer.dataProvider().featureCount())
self.ProgressText.emit("Running Analysis")
self.ProgressValue.emit(0)
part_id = 1
features = []
areas = {}
for fc, feat in enumerate(self.from_layer.getFeatures()):
geom = feat.geometry()
if geom is not None:
if self.transform is not None:
geom = geom.transform(self.transform)
geometry, statf = self.find_geometry(geom)
uncovered, statf = self.find_geometry(geom)
# uncovered = copy.deepcopy(geometry)
intersecting = self.index.intersects(geometry.boundingBox())
# Find all intersecting parts
for f in intersecting:
g = geometry.intersection(allfeatures[f].geometry())
if g.area() > 0:
feature = QgsFeature()
geo, stati = self.find_geometry(g)
feature.setGeometry(geo)
geo, statt = self.find_geometry(
allfeatures[f].geometry())
perct = stati / statt
percf = stati / statf
areas[f] = statt
feature.setAttributes([
part_id,
feat.attributes()[idx],
allfeatures[f].attributes()[fid], percf, perct
])
features.append(feature)
# prepare the data for the non overlapping
if uncovered is not None:
uncovered = uncovered.difference(g)
aux = merged[f].geometry().difference(g)
if aux is not None:
merged[f].setGeometry(aux)
part_id += 1
# Find the part that does not intersect anything
if uncovered is not None:
if uncovered.area() > 0:
feature = QgsFeature()
geo, stati = self.find_geometry(uncovered)
feature.setGeometry(geo)
perct = 0
percf = stati / statf
feature.setAttributes([
part_id,
feat.attributes()[idx], "", percf, perct
])
features.append(feature)
part_id += 1
self.ProgressValue.emit(fc)
self.ProgressText.emit(
"Running Analysis (" + "{:,}".format(fc) + "/" +
"{:,}".format(self.from_layer.featureCount()) + ")")
# Find the features on TO that have no correspondence in FROM
for f, feature in merged.items():
geom = feature.geometry()
if geom.area() > 0:
feature = QgsFeature()
geo, stati = self.find_geometry(geom)
feature.setGeometry(geo)
perct = stati / areas[f]
percf = 0
feature.setAttributes([
part_id, "", allfeatures[f].attributes()[fid], percf, perct
])
features.append(feature)
part_id += 1
if features:
a = lcdpr.addFeatures(features)
self.result = lcd_layer
self.ProgressValue.emit(self.from_layer.dataProvider().featureCount())
self.finished_threaded_procedure.emit("procedure")
def find_geometry(self, g):
if self.output_type == "Poly":
stat = g.area()
if g.isMultipart():
geometry = QgsGeometry.fromMultiPolygonXY(g.asMultiPolygon())
else:
geometry = QgsGeometry.fromPolygonXY(g.asPolygon())
elif self.output_type == "Line":
stat = g.length()
if g.isMultipart():
geometry = QgsGeometry.fromMultiPolylineXY(g.asMultiPolyLine())
else:
geometry = QgsGeometry.fromPolyline(g.asPoly())
else:
stat = 1
if g.isMultipart():
geometry = QgsGeometry.fromMultiPointXY(g.asMultiPoint())
else:
geometry = QgsGeometry.fromPointXY(g.asPoint())
return geometry, stat
def processAlgorithm(self, parameters, context, feedback):
source_poly = self.parameterAsSource(parameters, self.INPUT_POLYGONS,
context)
source_add = self.parameterAsVectorLayer(parameters,
self.INPUT_ADDITIONAL,
context)
val_field = self.parameterAsString(parameters, self.VALUE_FIELD,
context)
feature_value = self.parameterAsEnum(parameters, self.M_VAL, context)
if feature_value == 0:
m_val = max
elif feature_value == 1:
m_val = min
max_ids = []
att_col_idx = source_add.fields().indexFromName(val_field)
fcount = source_poly.featureCount()
polygons = source_poly.getFeatures()
points = source_add.getFeatures()
index = QgsSpatialIndex(
) # this spatial index contains all the features of the point layer
for point in points:
index.insertFeature(point)
for current, polygon in enumerate(polygons):
if feedback.isCanceled():
break
f = int(current + 1)
pcnt = int(f / fcount * 100 / 1)
feedback.setProgress(pcnt)
ids = []
vals = []
poly_geom = polygon.geometry()
engine = QgsGeometry.createGeometryEngine(poly_geom.constGet())
engine.prepareGeometry()
idx_ids = index.intersects(poly_geom.boundingBox())
for f in source_add.getFeatures(QgsFeatureRequest(idx_ids)):
geom = f.geometry()
if engine.contains(geom.constGet()):
ids.append(f.id())
vals.append(f.attributes()[att_col_idx])
#Note that the three lines below are all in the polygon feature loop so they are executed once for each polygon feature
d = dict(
zip(ids, vals)
) #creates dictionaries with id as key and elevation as value
if d:
n_max = m_val(
d.values()
) #m_val is either max or min depending on combo box selection
max_ids.append([
a for a, b in d.items() if b == n_max
]) #gets ids from each dictionary as keys with highest value
all_max_min_ids = [item for sublist in max_ids for item in sublist
] # creates the flat list from list of lists
method = self.parameterAsEnum(parameters, self.METHOD, context)
if method == 0:
behaviour = QgsVectorLayer.SetSelection
elif method == 1:
behaviour = QgsVectorLayer.AddToSelection
elif method == 2:
behaviour = QgsVectorLayer.RemoveFromSelection
elif method == 3:
behaviour = QgsVectorLayer.IntersectSelection
source_add.selectByIds(all_max_min_ids, behaviour)
return {self.OUTPUT: parameters[self.M_VAL]}
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.VECTOR))
value = float(self.getParameterValue(self.VALUE))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
strategy = self.getParameterValue(self.STRATEGY)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, layer.crs())
da = QgsDistanceArea()
features = vector.features(layer)
for current, f in enumerate(features):
fGeom = f.geometry()
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(value)
else:
pointCount = int(round(value * da.measureArea(fGeom)))
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(fGeom) and \
vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
progress.setPercentage(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random '
'points. Maximum number of attempts exceeded.'))
progress.setPercentage(0)
del writer
def run(self):
"""Experimental impact function."""
self.validate()
self.prepare()
self.provenance.append_step(
'Calculating Step',
'Impact function is calculating the impact.')
# Get parameters from layer's keywords
self.hazard_class_attribute = self.hazard.keyword('field')
self.hazard_class_mapping = self.hazard.keyword('value_map')
self.exposure_class_attribute = self.exposure.keyword(
'structure_class_field')
# Prepare Hazard Layer
hazard_provider = self.hazard.layer.dataProvider()
# Check affected field exists in the hazard layer
affected_field_index = hazard_provider.fieldNameIndex(
self.hazard_class_attribute)
if affected_field_index == -1:
message = tr(
'Field "%s" is not present in the attribute table of the '
'hazard layer. Please change the Affected Field parameter in '
'the IF Option.') % self.hazard_class_attribute
raise GetDataError(message)
srs = self.exposure.layer.crs().toWkt()
exposure_provider = self.exposure.layer.dataProvider()
exposure_fields = exposure_provider.fields()
# Check self.exposure_class_attribute exists in exposure layer
building_type_field_index = exposure_provider.fieldNameIndex(
self.exposure_class_attribute)
if building_type_field_index == -1:
message = tr(
'Field "%s" is not present in the attribute table of '
'the exposure layer. Please change the Building Type '
'Field parameter in the IF Option.'
) % self.exposure_class_attribute
raise GetDataError(message)
# If target_field does not exist, add it:
if exposure_fields.indexFromName(self.target_field) == -1:
exposure_provider.addAttributes(
[QgsField(self.target_field, QVariant.Int)])
target_field_index = exposure_provider.fieldNameIndex(
self.target_field)
exposure_fields = exposure_provider.fields()
# Create layer to store the buildings from E and extent
buildings_are_points = is_point_layer(self.exposure.layer)
if buildings_are_points:
building_layer = QgsVectorLayer(
'Point?crs=' + srs, 'impact_buildings', 'memory')
else:
building_layer = QgsVectorLayer(
'Polygon?crs=' + srs, 'impact_buildings', 'memory')
building_provider = building_layer.dataProvider()
# Set attributes
building_provider.addAttributes(exposure_fields.toList())
building_layer.startEditing()
building_layer.commitChanges()
# Filter geometry and data using the requested extent
requested_extent = QgsRectangle(*self.requested_extent)
# This is a hack - we should be setting the extent CRS
# in the IF base class via safe/engine/core.py:calculate_impact
# for now we assume the extent is in 4326 because it
# is set to that from geo_extent
# See issue #1857
transform = QgsCoordinateTransform(
self.requested_extent_crs, self.hazard.crs())
projected_extent = transform.transformBoundingBox(requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(projected_extent)
# Split building_layer by H and save as result:
# 1) Filter from H inundated features
# 2) Mark buildings as inundated (1) or not inundated (0)
# make spatial index of affected polygons
hazard_index = QgsSpatialIndex()
hazard_geometries = {} # key = feature id, value = geometry
has_hazard_objects = False
for feature in self.hazard.layer.getFeatures(request):
value = feature[affected_field_index]
if value not in self.hazard_class_mapping[self.wet]:
continue
hazard_index.insertFeature(feature)
hazard_geometries[feature.id()] = QgsGeometry(feature.geometry())
has_hazard_objects = True
if not has_hazard_objects:
message = tr(
'There are no objects in the hazard layer with %s '
'value in %s. Please check your data or use another '
'attribute.') % (
self.hazard_class_attribute,
', '.join(self.hazard_class_mapping[self.wet]))
raise GetDataError(message)
# Filter out just those EXPOSURE features in the analysis extents
transform = QgsCoordinateTransform(
self.requested_extent_crs, self.exposure.layer.crs())
projected_extent = transform.transformBoundingBox(requested_extent)
request = QgsFeatureRequest()
request.setFilterRect(projected_extent)
# We will use this transform to project each exposure feature into
# the CRS of the Hazard.
transform = QgsCoordinateTransform(
self.exposure.crs(), self.hazard.crs())
features = []
for feature in self.exposure.layer.getFeatures(request):
# Make a deep copy as the geometry is passed by reference
# If we don't do this, subsequent operations will affect the
# original feature geometry as well as the copy TS
building_geom = QgsGeometry(feature.geometry())
# Project the building geometry to hazard CRS
building_bounds = transform.transform(building_geom.boundingBox())
affected = False
# get tentative list of intersecting hazard features
# only based on intersection of bounding boxes
ids = hazard_index.intersects(building_bounds)
for fid in ids:
# run (slow) exact intersection test
building_geom.transform(transform)
if hazard_geometries[fid].intersects(building_geom):
affected = True
break
new_feature = QgsFeature()
# We write out the original feature geom, not the projected one
new_feature.setGeometry(feature.geometry())
new_feature.setAttributes(feature.attributes())
new_feature[target_field_index] = 1 if affected else 0
features.append(new_feature)
# every once in a while commit the created features
# to the output layer
if len(features) == 1000:
(_, __) = building_provider.addFeatures(features)
features = []
(_, __) = building_provider.addFeatures(features)
building_layer.updateExtents()
# Generate simple impact report
self.buildings = {}
self.affected_buildings = OrderedDict([
(tr('Flooded'), {})
])
buildings_data = building_layer.getFeatures()
building_type_field_index = building_layer.fieldNameIndex(
self.exposure_class_attribute)
for building in buildings_data:
record = building.attributes()
building_type = record[building_type_field_index]
if building_type in [None, 'NULL', 'null', 'Null']:
building_type = 'Unknown type'
if building_type not in self.buildings:
self.buildings[building_type] = 0
for category in self.affected_buildings.keys():
self.affected_buildings[category][
building_type] = OrderedDict([
(tr('Buildings Affected'), 0)])
self.buildings[building_type] += 1
if record[target_field_index] == 1:
self.affected_buildings[tr('Flooded')][building_type][
tr('Buildings Affected')] += 1
# Lump small entries and 'unknown' into 'other' category
# Building threshold #2468
postprocessors = self.parameters['postprocessors']
building_postprocessors = postprocessors['BuildingType'][0]
self.building_report_threshold = building_postprocessors.value[0].value
self._consolidate_to_other()
impact_summary = self.html_report()
# For printing map purpose
map_title = tr('Buildings inundated')
legend_title = tr('Structure inundated status')
style_classes = [
dict(label=tr('Not Inundated'), value=0, colour='#1EFC7C',
transparency=0, size=0.5),
dict(label=tr('Inundated'), value=1, colour='#F31A1C',
transparency=0, size=0.5)]
style_info = dict(
target_field=self.target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
# Convert QgsVectorLayer to inasafe layer and return it.
if building_layer.featureCount() < 1:
raise ZeroImpactException(tr(
'No buildings were impacted by this flood.'))
extra_keywords = {
'impact_summary': impact_summary,
'map_title': map_title,
'legend_title': legend_title,
'target_field': self.target_field,
'buildings_total': self.total_buildings,
'buildings_affected': self.total_affected_buildings
}
self.set_if_provenance()
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
building_layer = Vector(
data=building_layer,
name=tr('Flooded buildings'),
keywords=impact_layer_keywords,
style_info=style_info)
self._impact = building_layer
return building_layer
class sGraph(QObject):
finished = pyqtSignal(object)
error = pyqtSignal(Exception, basestring)
progress = pyqtSignal(float)
warning = pyqtSignal(str)
def __init__(self, edges, source_col='default', target_col='default'):
QObject.__init__(self)
self.edges = edges
self.edge_flds = [i.name() for i in self.edges[0].fields()]
self.edge_qflds = []
for field in self.edges[0].fields():
self.edge_qflds.append(QgsField(field.name(), field.type()))
self.n_edges = len(self.edges)
self.source_col = source_col
self.target_col = target_col
self.topology = {}
self.adj_lines = {}
self.dual_edges = {}
# TODO: do not duplicate key if it is already in attributes e.g. 'identifier'
self.nodes = []
self.edge_attrs = {}
self.edge_geoms = {}
self.node_attrs = {}
self.superNodes = {}
self.superEdges = {}
# create spatial index object
self.spIndex = QgsSpatialIndex()
for f in self.edges:
#self.progress.emit(45 * f_count / self.road_layer_count)
#f_count += 1
attr = f.attributes()
attrs = dict(zip(self.edge_flds, attr))
self.edge_attrs[f.id()] = attrs
f_geom = f.geometry()
vertices = [vertex for vertex in get_vertices(f_geom)]
# TODO: some of the centroids are not correct
self.edge_geoms[f.id()] = {
'wkt': f_geom.exportToWkt(),
'source': f[self.source_col],
'target': f[self.target_col],
'vertices': vertices,
'centroid': pl_midpoint(f_geom),
'angular change': pl_angle(f_geom),
'ends': [vertices[0], vertices[1]]
}
self.node_attrs[f[self.source_col]] = vertices[0]
self.node_attrs[f[self.target_col]] = vertices[-1]
# insert features to index
self.spIndex.insertFeature(f)
# create topology & adjacent lines dictionary
if self.source_col == 'default':
startnode = f.geometry().asPolyline()[0]
else:
startnode = f[self.source_col]
if self.target_col == 'default':
endnode = f.geometry().asPolyline()[-1]
else:
endnode = f[self.target_col]
try:
self.topology[startnode] += [endnode]
except KeyError, e:
self.topology[startnode] = [endnode]
try:
self.topology[endnode] += [startnode]
except KeyError, e:
self.topology[endnode] = [startnode]
self.nodes.append(startnode)
self.nodes.append(endnode)
try:
self.adj_lines[startnode] += [f.id()]
except KeyError, e:
self.adj_lines[startnode] = [f.id()]
def interpolate_polygon_polygon(source, target, wgs84_extent):
""" Transfer values from source polygon layer to the target polygon layer.
This method will do a spatial join: the output layer will contain all
features from target layer, with the addition of attributes of intersecting
feature from the source layer. If there is not intersecting source feature,
the output layer will still contain the target feature, with null
attributes from the source layer.
The intersection test considers only centroids of target features
(not the whole polygon geometry).
If more features from source layer intersect a target feature, only
the first intersecting source feature will be used.
:param source: Source polygon layer
:type source: QgsVectorLayer
:param target: Target polygon layer
:type target: QgsVectorLayer
:param wgs84_extent: Requested extent for analysis, in WGS84 coordinates
:type wgs84_extent: QgsRectangle
:return: output layer
:rtype: QgsVectorLayer
"""
source_field_count = source.dataProvider().fields().count()
target_field_count = target.dataProvider().fields().count()
# Create new layer for writing resulting features.
# It will contain attributes of both target and source layers
result = create_layer(target)
new_fields = source.dataProvider().fields().toList()
new_fields.append(QgsField('polygon_id', QVariant.Int))
result.dataProvider().addAttributes(new_fields)
result.updateFields()
result_fields = result.dataProvider().fields()
# setup transform objects between different CRS
crs_wgs84 = QgsCoordinateReferenceSystem("EPSG:4326")
wgs84_to_source = QgsCoordinateTransform(crs_wgs84, source.crs())
wgs84_to_target = QgsCoordinateTransform(crs_wgs84, target.crs())
source_to_target = QgsCoordinateTransform(source.crs(), target.crs())
# compute extents in CRS of layers
source_extent = wgs84_to_source.transformBoundingBox(wgs84_extent)
target_extent = wgs84_to_target.transformBoundingBox(wgs84_extent)
# cache source layer (in CRS of target layer)
source_index = QgsSpatialIndex()
source_geometries = {} # key = feature ID, value = QgsGeometry
source_attributes = {}
for f in source.getFeatures(QgsFeatureRequest(source_extent)):
f.geometry().transform(source_to_target)
source_index.insertFeature(f)
source_geometries[f.id()] = QgsGeometry(f.geometry())
source_attributes[f.id()] = f.attributes()
# Go through all features in target layer and for each decide
# whether it is intersected by any source feature
result_features = []
for f in target.getFeatures(QgsFeatureRequest(target_extent)):
# we use just centroids of target polygons
centroid_geometry = f.geometry().centroid()
centroid = centroid_geometry.asPoint()
rect = QgsRectangle(
centroid.x(), centroid.y(),
centroid.x(), centroid.y())
ids = source_index.intersects(rect)
has_matching_source = False
for source_id in ids:
if source_geometries[source_id].intersects(centroid_geometry):
# we have found intersection between source and target
f_result = QgsFeature(result_fields)
f_result.setGeometry(f.geometry())
for i in xrange(target_field_count):
f_result[i] = f[i]
for i in xrange(source_field_count):
f_result[i + target_field_count] = source_attributes[
source_id][i]
f_result['polygon_id'] = source_id
result_features.append(f_result)
has_matching_source = True
break # assuming just one source for each target feature
# if there is no intersecting feature from source layer,
# we will keep the source attributes null
if not has_matching_source:
f_result = QgsFeature(result_fields)
f_result.setGeometry(f.geometry())
for i in xrange(target_field_count):
f_result[i] = f[i]
result_features.append(f_result)
if len(result_features) == 1000:
result.dataProvider().addFeatures(result_features)
result_features = []
result.dataProvider().addFeatures(result_features)
return result
class SequenceGenerator:
def __init__(self,
centroid_layer,
trajectory_layer,
feedback,
timezone,
weight_field=None):
centroids = [f for f in centroid_layer.getFeatures()]
self.cell_index = QgsSpatialIndex()
for f in centroids:
self.cell_index.insertFeature(f)
self.id_to_centroid = {
f.id(): [f, [0, 0, 0, 0, 0]]
for (f) in centroids
}
self.timezone = timezone
self.weight_field = weight_field
if weight_field is not None:
self.weightIdx = trajectory_layer.fields().indexFromName(
weight_field)
else:
self.weightIdx = None
self.sequences = {}
n_traj = float(trajectory_layer.featureCount())
for i, traj in enumerate(trajectory_layer.getFeatures()):
self.evaluate_trajectory(traj)
feedback.setProgress(i / n_traj * 100)
def evaluate_trajectory(self, trajectory):
points = trajectory.geometry().asPolyline()
this_sequence = []
weight = 1 if self.weight_field is None else trajectory.attributes(
)[self.weightIdx]
prev_cell_id = None
for i, pt in enumerate(points):
nn_id = self.cell_index.nearestNeighbor(pt, 1)[0]
nearest_cell = self.id_to_centroid[nn_id][0]
nearest_cell_id = nearest_cell.id()
if len(this_sequence) >= 1:
prev_cell_id = this_sequence[-1]
if nearest_cell_id != prev_cell_id:
if (prev_cell_id, nearest_cell_id) in self.sequences:
self.sequences[(prev_cell_id,
nearest_cell_id)] += weight
else:
self.sequences[(prev_cell_id,
nearest_cell_id)] = weight
if nearest_cell_id != prev_cell_id:
# we have changed to a new cell --> up the counter
m = trajectory.geometry().vertexAt(i).m()
if math.isnan(m):
m = 0
t = datetime(1970, 1, 1) + timedelta(
seconds=m) + timedelta(hours=self.timezone)
h = t.hour
self.id_to_centroid[nn_id][1][0] += weight
self.id_to_centroid[nn_id][1][int(h / 6) + 1] += weight
this_sequence.append(nearest_cell_id)
def create_flow_lines(self):
lines = []
for key, value in self.sequences.items():
p1 = self.id_to_centroid[key[0]][0].geometry().asPoint()
p2 = self.id_to_centroid[key[1]][0].geometry().asPoint()
p1 = QgsPoint(p1.x(), p1.y())
p2 = QgsPoint(p2.x(), p2.y())
feat = QgsFeature()
feat.setGeometry(QgsGeometry.fromPolyline([p1, p2]))
feat.setAttributes([key[0], key[1], value])
lines.append(feat)
return lines
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.VECTOR))
pointCount = float(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, layer.crs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
featureCount = layer.featureCount()
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
da = QgsDistanceArea()
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
# pick random feature
fid = random.randint(0, featureCount - 1)
f = next(layer.getFeatures(request.setFilterFid(fid).setSubsetOfAttributes([])))
fGeom = f.geometry()
if fGeom.isMultipart():
lines = fGeom.asMultiPolyline()
# pick random line
lineId = random.randint(0, len(lines) - 1)
vertices = lines[lineId]
else:
vertices = fGeom.asPolyline()
# pick random segment
if len(vertices) == 2:
vid = 0
else:
vid = random.randint(0, len(vertices) - 2)
startPoint = vertices[vid]
endPoint = vertices[vid + 1]
length = da.measureLine(startPoint, endPoint)
dist = length * random.random()
if dist > minDistance:
d = dist / (length - dist)
rx = (startPoint.x() + d * endPoint.x()) / (1 + d)
ry = (startPoint.y() + d * endPoint.y()) / (1 + d)
# generate random point
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
progress.setPercentage(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
del writer
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
# Retrieve the feature source and sink. The 'dest_id' variable is used
# to uniquely identify the feature sink, and must be included in the
# dictionary returned by the processAlgorithm function.
couche_lines = self.parameterAsVectorLayer(parameters, self.LINES,
context)
couche_points = self.parameterAsVectorLayer(parameters, self.NODES,
context)
radius = self.parameterAsDouble(parameters, self.RAYON, context)
# Compute the number of steps to display within the progress bar and
# get features from source
delta = float(radius)
index = QgsSpatialIndex()
lines = couche_lines.getFeatures()
for i in lines:
if i.geometry().isMultipart():
i.setGeometry(
QgsGeometry.fromPolylineXY(
i.geometry().asMultiPolyline()[0]))
index.insertFeature(i)
couche_lines.startEditing()
couche_lines.beginEditCommand(
self.tr("Split polylines at connections"))
points = couche_points.getFeatures()
nb = couche_points.featureCount()
feedback.setProgressText(self.tr("Connecting points to lines..."))
for pos, pt in enumerate(points):
feedback.setProgress(pos * 100.0 / nb)
ptg = pt.geometry()
if ptg.isMultipart():
ptg = QgsGeometry.fromPoint(ptg.asMultiPoint()[0])
coor = ptg.asPoint()
nearest = index.intersects(
QgsRectangle(coor.x() - delta,
coor.y() - delta,
coor.x() + delta,
coor.y() + delta))
dmin = 1e38
if len(nearest) > 0:
for n in nearest:
f = couche_lines.getFeatures(request=QgsFeatureRequest(n))
for g in f:
d = g.geometry().distance(pt.geometry())
if d <= dmin:
dmin = d
gmin = g
gid = g.id()
g = gmin
if g.geometry().distance(pt.geometry()) < delta:
a = g.geometry().closestSegmentWithContext(ptg.asPoint())
if not (a[2] == 0):
geom = g.geometry()
geom.convertToSingleType()
geom_id = g.id()
att = g.attributes()
connexion = QgsFeature()
connexion.setGeometry(
QgsGeometry.fromPolylineXY([ptg.asPoint(), a[1]]))
connexion.setAttributes(att)
couche_lines.addFeature(connexion)
geom.insertVertex(a[1][0], a[1][1], a[2])
geoma = geom.asPolyline()[:a[2] + 1]
geomb = geom.asPolyline()[a[2]:]
feedback.setProgressText(unicode(geomb))
fa = QgsFeature()
fa.setGeometry(QgsGeometry.fromPolylineXY(geoma))
fa.setAttributes(att)
couche_lines.addFeature(fa)
index.insertFeature(fa)
fb = QgsFeature()
fb.setGeometry(QgsGeometry.fromPolylineXY(geomb))
fb.setAttributes(att)
couche_lines.addFeature(fb)
index.insertFeature(fb)
couche_lines.deleteFeature(g.id())
index.deleteFeature(g)
couche_lines.commitChanges()
couche_lines.endEditCommand()
return {self.LINES: 'OK'}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
proximity = self.parameterAsDouble(parameters, self.PROXIMITY, context)
radius = self.parameterAsDouble(parameters, self.DISTANCE, context)
horizontal = self.parameterAsBool(parameters, self.HORIZONTAL, context)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, source.fields(),
source.wkbType(),
source.sourceCrs())
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
def searchRect(p):
return QgsRectangle(p.x() - proximity,
p.y() - proximity,
p.x() + proximity,
p.y() + proximity)
index = QgsSpatialIndex()
# NOTE: this is a Python port of QgsPointDistanceRenderer::renderFeature. If refining this algorithm,
# please port the changes to QgsPointDistanceRenderer::renderFeature also!
clustered_groups = []
group_index = {}
group_locations = {}
for current, f in enumerate(features):
if feedback.isCanceled():
break
if not f.hasGeometry():
continue
point = f.geometry().asPoint()
other_features_within_radius = index.intersects(searchRect(point))
if not other_features_within_radius:
index.insertFeature(f)
group = [f]
clustered_groups.append(group)
group_index[f.id()] = len(clustered_groups) - 1
group_locations[f.id()] = point
else:
# find group with closest location to this point (may be more than one within search tolerance)
min_dist_feature_id = other_features_within_radius[0]
min_dist = group_locations[min_dist_feature_id].distance(point)
for i in range(1, len(other_features_within_radius)):
candidate_id = other_features_within_radius[i]
new_dist = group_locations[candidate_id].distance(point)
if new_dist < min_dist:
min_dist = new_dist
min_dist_feature_id = candidate_id
group_index_pos = group_index[min_dist_feature_id]
group = clustered_groups[group_index_pos]
# calculate new centroid of group
old_center = group_locations[min_dist_feature_id]
group_locations[min_dist_feature_id] = QgsPointXY(
(old_center.x() * len(group) + point.x()) /
(len(group) + 1.0),
(old_center.y() * len(group) + point.y()) /
(len(group) + 1.0))
# add to a group
clustered_groups[group_index_pos].append(f)
group_index[f.id()] = group_index_pos
feedback.setProgress(int(current * total))
current = 0
total = 100.0 / len(clustered_groups) if clustered_groups else 1
feedback.setProgress(0)
fullPerimeter = 2 * math.pi
for group in clustered_groups:
if feedback.isCanceled():
break
count = len(group)
if count == 1:
sink.addFeature(group[0], QgsFeatureSink.FastInsert)
else:
angleStep = fullPerimeter / count
if count == 2 and horizontal:
currentAngle = math.pi / 2
else:
currentAngle = 0
old_point = group_locations[group[0].id()]
for f in group:
if feedback.isCanceled():
break
sinusCurrentAngle = math.sin(currentAngle)
cosinusCurrentAngle = math.cos(currentAngle)
dx = radius * sinusCurrentAngle
dy = radius * cosinusCurrentAngle
# we want to keep any existing m/z values
point = f.geometry().geometry().clone()
point.setX(old_point.x() + dx)
point.setY(old_point.y() + dy)
f.setGeometry(QgsGeometry(point))
sink.addFeature(f, QgsFeatureSink.FastInsert)
currentAngle += angleStep
current += 1
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
class Sampling(object):
# for save all instances
samplings = dict() # {name_in_qgis: class instance}
def __init__(self,
sampling_type,
ThematicR,
CategoricalR,
sampling_method=None,
srs_config=None,
output_file=None):
# set and init variables
# sampling_type => "simple" (simple random sampling),
# "stratified" (stratified random sampling)
self.sampling_type = sampling_type
self.ThematicR = ThematicR
self.CategoricalR = CategoricalR
# for stratified sampling
self.sampling_method = sampling_method
# save some stratified sampling configuration
self.srs_config = srs_config
# set the output dir for save sampling
self.output_file = output_file
# save instance
self.filename = os.path.splitext(
os.path.basename(output_file))[0] # without extension
Sampling.samplings[self.filename] = self
# for save all sampling points
self.points = dict()
@wait_process
def generate_sampling_points(self, pixel_values, number_of_samples,
min_distance, neighbor_aggregation,
attempts_by_sampling, progress_bar,
random_seed):
"""Some code base from (by Alexander Bruy):
https://github.com/qgis/QGIS/blob/release-2_18/python/plugins/processing/algs/qgis/RandomPointsExtent.py
"""
self.pixel_values = pixel_values
self.number_of_samples = number_of_samples # desired
self.total_of_samples = None # total generated
self.min_distance = min_distance
self.neighbor_aggregation = neighbor_aggregation
progress_bar.setValue(0) # init progress bar
self.ThematicR_boundaries = QgsGeometry().fromRect(
self.ThematicR.extent())
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
thematic_CRS = self.ThematicR.qgs_layer.crs()
file_format = \
"GPKG" if self.output_file.endswith(".gpkg") else "ESRI Shapefile" if self.output_file.endswith(".shp") else None
writer = QgsVectorFileWriter(self.output_file, "System", fields,
QgsWkbTypes.Point, thematic_CRS,
file_format)
if self.sampling_type == "simple":
total_of_samples = self.number_of_samples
if self.sampling_type == "stratified":
total_of_samples = sum(self.number_of_samples)
self.samples_in_categories = [0] * len(
self.number_of_samples) # total generated by categories
nPoints = 0
nIterations = 0
self.index = QgsSpatialIndex()
if attempts_by_sampling:
maxIterations = total_of_samples * attempts_by_sampling
else:
maxIterations = float('Inf')
# init the random sampling seed
self.random_seed = random_seed
random.seed(self.random_seed)
points_generated = []
while nIterations < maxIterations and nPoints < total_of_samples:
random_sampling_point = RandomPoint(self.ThematicR.extent())
# checks to the sampling point, else discard and continue
if not self.check_sampling_point(random_sampling_point):
nIterations += 1
continue
if self.sampling_type == "stratified":
self.samples_in_categories[
random_sampling_point.index_pixel_value] += 1
points_generated.append(random_sampling_point)
# it requires tmp save the point to check min distance for the next sample
f = QgsFeature(nPoints)
f.setGeometry(random_sampling_point.QgsGeom)
self.index.insertFeature(f)
self.points[nPoints] = random_sampling_point.QgsPnt
nPoints += 1
nIterations += 1
# update progress bar
progress_bar.setValue(int(nPoints))
# guarantee the random order for the classification
random.shuffle(points_generated)
self.points = dict() # restart
for num_point, point_generated in enumerate(points_generated):
# random sampling point passed the checks, save it
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', num_point + 1)
f.setGeometry(point_generated.QgsGeom)
writer.addFeature(f)
self.points[num_point] = point_generated.QgsPnt
# save the total point generated
self.total_of_samples = len(points_generated)
del writer, self.index
def check_sampling_point(self, sampling_point):
"""Make several checks to the sampling point, else discard
"""
if not sampling_point.in_valid_data(self.ThematicR):
return False
if not sampling_point.in_extent(self.ThematicR_boundaries):
return False
if not sampling_point.in_mim_distance(self.index, self.min_distance,
self.points):
return False
if self.sampling_type == "simple":
if not sampling_point.in_categorical_raster_SimpRS(
self.pixel_values, self.CategoricalR):
return False
if self.sampling_type == "stratified":
if not sampling_point.in_categorical_raster_StraRS(
self.pixel_values, self.number_of_samples,
self.CategoricalR, self.samples_in_categories):
return False
if self.neighbor_aggregation and \
not sampling_point.check_neighbors_aggregation(self.ThematicR, *self.neighbor_aggregation):
return False
return True
def save_config(self, file_out):
from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa
config = configparser.RawConfigParser()
config.add_section('thematic')
config.set('thematic', 'thematic_raster', self.ThematicR.file_path)
config.set('thematic', 'thematic_raster_band',
str(self.ThematicR.band))
config.set('thematic', 'thematic_raster_nodata',
str(self.ThematicR.nodata))
config.add_section('sampling')
config.set('sampling', 'type',
'{} random sampling'.format(self.sampling_type))
if self.sampling_type == "simple":
config.add_section('sampling options')
config.set('sampling options', 'total_of_samples',
self.total_of_samples)
config.set('sampling options', 'min_distance', self.min_distance)
config.add_section('sampling in categorical raster')
if isinstance(self.CategoricalR, Raster):
config.set('sampling in categorical raster',
'categorical_raster', self.CategoricalR.file_path)
config.set('sampling in categorical raster',
'categorical_raster_band', self.CategoricalR.band)
else:
config.set('sampling in categorical raster',
'categorical_raster', 'None')
config.set('sampling in categorical raster',
'categorical_raster_band', 'None')
config.set(
'sampling in categorical raster', 'set_pixel_values',
','.join(map(str, self.pixel_values))
if self.pixel_values is not None else 'None')
if self.sampling_type == "stratified":
config.add_section('categorical raster')
if isinstance(self.CategoricalR, Raster):
config.set('categorical raster', 'categorical_raster',
self.CategoricalR.file_path)
config.set('categorical raster', 'categorical_raster_band',
self.CategoricalR.band)
config.set('categorical raster', 'categorical_raster_nodata',
self.CategoricalR.nodata)
else:
config.set('categorical raster', 'categorical_raster', 'None')
config.set('categorical raster', 'categorical_raster_band',
'None')
config.set('categorical raster', 'categorical_raster_nodata',
'None')
config.add_section('stratified random sampling method')
config.set('stratified random sampling method', 'sampling_method',
self.sampling_method)
if self.sampling_method == "area based proportion":
config.set('stratified random sampling method',
'total_expected_std_error',
self.srs_config["total_std_error"])
config.set('stratified random sampling method', 'total_of_samples',
self.total_of_samples)
config.add_section('num_samples')
for pixel, count in zip(self.pixel_values,
self.samples_in_categories):
if count > 0:
config.set('num_samples', 'pix_val_' + str(pixel),
str(count))
if self.sampling_method == "area based proportion":
config.set('stratified random sampling method',
'total_expected_std_error',
self.srs_config["total_std_error"])
config.add_section('std_dev')
for pixel, count, std_dev in zip(self.pixel_values,
self.samples_in_categories,
self.srs_config["std_dev"]):
if count > 0:
config.set('std_dev', 'pix_val_' + str(pixel),
str(std_dev))
config.add_section('sampling options')
config.set('sampling options', 'min_distance', self.min_distance)
config.add_section('with neighbors aggregation')
config.set(
'with neighbors aggregation', 'min_neighbors_with_the_same_class',
'{1}/{0}'.format(*self.neighbor_aggregation)
if self.neighbor_aggregation is not None else 'None')
config.add_section('generation')
if AcATaMa.dockwidget.widget_generate_SimpRS.button_attempts_by_sampling.isChecked(
):
config.set(
'generation', 'maximum_attempts_by_sampling',
AcATaMa.dockwidget.widget_generate_SimpRS.attempts_by_sampling.
value())
else:
config.set('generation', 'maximum_attempts_by_sampling',
"until reaching the set sampling numbers")
config.set(
'generation', 'random_seed',
self.random_seed if self.random_seed is not None else "automatic")
with open(file_out, 'w') as configfile:
config.write(configfile)
class TriangleMesh:
# 0 - 3
# | / |
# 1 - 2
def __init__(self, xmin, ymin, xmax, ymax, x_segments, y_segments):
self.vbands = []
self.hbands = []
self.vidx = QgsSpatialIndex()
self.hidx = QgsSpatialIndex()
xres = (xmax - xmin) / x_segments
yres = (ymax - ymin) / y_segments
self.xmin, self.ymax, self.xres, self.yres = xmin, ymax, xres, yres
def addVBand(idx, geom):
f = QgsFeature(idx)
f.setGeometry(geom)
self.vbands.append(f)
self.vidx.insertFeature(f)
def addHBand(idx, geom):
f = QgsFeature(idx)
f.setGeometry(geom)
self.hbands.append(f)
self.hidx.insertFeature(f)
for x in range(x_segments):
addVBand(
x,
QgsGeometry.fromRect(
QgsRectangle(xmin + x * xres, ymin, xmin + (x + 1) * xres,
ymax)))
for y in range(y_segments):
addHBand(
y,
QgsGeometry.fromRect(
QgsRectangle(xmin, ymax - (y + 1) * yres, xmax,
ymax - y * yres)))
def vSplit(self, geom):
"""split polygon vertically"""
for idx in self.vidx.intersects(geom.boundingBox()):
geometry = geom.intersection(self.vbands[idx].geometry())
if geometry is not None:
yield idx, geometry
def hIntersects(self, geom):
"""indices of horizontal bands that intersect with geom"""
for idx in self.hidx.intersects(geom.boundingBox()):
if geom.intersects(self.hbands[idx].geometry()):
yield idx
def splitPolygon(self, geom):
xmin, ymax, xres, yres = self.xmin, self.ymax, self.xres, self.yres
polygons = []
for x, vi in self.vSplit(geom):
for y in self.hIntersects(vi):
pt0 = QgsPointXY(xmin + x * xres, ymax - y * yres)
pt1 = QgsPointXY(xmin + x * xres, ymax - (y + 1) * yres)
pt2 = QgsPointXY(xmin + (x + 1) * xres, ymax - (y + 1) * yres)
pt3 = QgsPointXY(xmin + (x + 1) * xres, ymax - y * yres)
quad = QgsGeometry.fromPolygonXY([[pt0, pt1, pt2, pt3, pt0]])
tris = [[[pt0, pt1, pt3, pt0]], [[pt3, pt1, pt2, pt3]]]
if geom.contains(quad):
polygons += tris
else:
for i, tri in enumerate(
map(QgsGeometry.fromPolygonXY, tris)):
if geom.contains(tri):
polygons.append(tris[i])
elif geom.intersects(tri):
poly = geom.intersection(tri)
if poly.isMultipart():
polygons += poly.asMultiPolygon()
else:
polygons.append(poly.asPolygon())
return QgsGeometry.fromMultiPolygonXY(polygons)
def splitPolygonA(self, geom):
xmin, ymax, xres, yres = self.xmin, self.ymax, self.xres, self.yres
for x, vi in self.vSplit(geom):
for y in self.hIntersects(vi):
pt0 = QgsPointXY(xmin + x * xres, ymax - y * yres)
pt1 = QgsPointXY(xmin + x * xres, ymax - (y + 1) * yres)
pt2 = QgsPointXY(xmin + (x + 1) * xres, ymax - (y + 1) * yres)
pt3 = QgsPointXY(xmin + (x + 1) * xres, ymax - y * yres)
quad = QgsGeometry.fromPolygonXY([[pt0, pt1, pt2, pt3, pt0]])
tris = [[[pt0, pt1, pt3, pt0]], [[pt3, pt1, pt2, pt3]]]
if geom.contains(quad):
yield tris[0]
yield tris[1]
else:
for i, tri in enumerate(
map(QgsGeometry.fromPolygonXY, tris)):
if geom.contains(tri):
yield tris[i]
elif geom.intersects(tri):
poly = geom.intersection(tri)
if poly.isMultipart():
for sp in poly.asMultiPolygon():
yield sp
else:
yield poly.asPolygon()
class PW_Abbreviations_Algorithm(QgsProcessingAlgorithm):
INPUT = 'INPUT'
INPUT_MATRIX = 'INPUT MATRIX'
FIELD = 'FIELD'
OUTPUT_FIELD = 'OUTPUT FIELD'
LIST = 'LIST'
RESOLVE_CASE = 'RESOLVE CASE'
RESOLVE_FIRST = 'RESOLVE FIRST'
OUTPUT = 'OUTPUT'
def tr(self, string):
return QCoreApplication.translate('Processing', string)
def createInstance(self):
return PW_Abbreviations_Algorithm()
def name(self):
return 'pw_abbreviations'
def displayName(self):
return self.tr('PW ABBREVIATIONS')
def group(self):
return self.tr('PW')
def groupId(self):
return 'pw'
def shortHelpString(self):
help = """This algorithm expands abbreviations from input features; if text is recognized as abbreviation, the algorithm replaces it by last previous word in the text (in reading order).\
Additionally it changes first letters in the words to capitals and the others to lower. If words in the text are sorted in alphabetical order, the algorithm can recognize words with first letter not matching to its neighborhood and change it to proper letter.\
<hr>
<b>Input abbreviations layer</b>\
<br>The features contain abbreviations to expand.\
<br><br><b>Input sheets layer</b>\
<br>The features with extands of sheets.\
<br><br><b>Text input field</b>\
<br>The field in the input table contains abbreviations to expand.\
<br><br><b>Text output field</b>\
<br>The field in the input table in which the expanded abbreviations will be add.\
<br><br><b>Characters to remove on edges</b>\
<br>If input text starts or ends with character from the list, this character will be remove from text.\
<br><br><b>Resolve first</b>\
<br>Changes first letters in the words to capitals and the others to lower letters.\
<br><br><b>Resolve capitalization</b>\
<br>Recognizes words with first letter not matching to its neighborhood and changes it to proper letter.\
(Alphabetical order of text words is necassery)\
<br><br><b>Output layer</b>\
<br>Location of the output layer.\
"""
return self.tr(help)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Input abbreviations layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT_MATRIX, self.tr('Input sheets layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterField(
self.FIELD,
self.tr('Text input field'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.DataType.String))
self.addParameter(
QgsProcessingParameterField(
self.OUTPUT_FIELD,
self.tr('Text output field'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.DataType.String))
global CharsList
CharsList = [
'.', ',', ':', ';', '/', '\\', '"', "'", '|', '_', '*', '!', '^',
'~', '+', '@', '#', '$', '&', '(', ')', ' ', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '-'
]
global Checklist
Checklist = []
for i in range(0, len(CharsList), 1):
Checklist.append(i)
self.addParameter(
QgsProcessingParameterEnum(
self.LIST,
self.tr('Characters to remove on edges'),
options=CharsList,
allowMultiple=True,
defaultValue=Checklist,
optional=True,
))
self.addParameter(
QgsProcessingParameterBoolean(self.RESOLVE_FIRST,
self.tr('Resolve first')))
self.addParameter(
QgsProcessingParameterBoolean(self.RESOLVE_CASE,
self.tr('Resolve capitalization')))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Output layer')))
def processAlgorithm(self, parameters, context, feedback):
self.source_layer = self.parameterAsLayer(parameters, self.INPUT,
context)
self.feature_source = self.parameterAsSource(parameters, self.INPUT,
context)
self.field = self.parameterAsString(parameters, self.FIELD, context)
self.dest_field = self.parameterAsString(parameters, self.OUTPUT_FIELD,
context)
self.matrix_feature_source = self.parameterAsSource(
parameters, self.INPUT_MATRIX, context)
self.chars_indices = self.parameterAsEnums(parameters, 'LIST', context)
self.case = self.parameterAsBool(parameters, self.RESOLVE_CASE,
context)
self.first = self.parameterAsBool(parameters, self.RESOLVE_FIRST,
context)
(self.sink,
dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
self.feature_source.fields(),
self.feature_source.wkbType(),
self.feature_source.sourceCrs())
feedback.setProgressText('\nsorting sheets in reading order...\n')
matrix_features_iterator = self.matrix_feature_source.getFeatures(
QgsFeatureRequest())
matrix_features = []
for feat in matrix_features_iterator:
matrix_features.append(feat)
SheetsOrderedList = self.PutInOrderFeatures(feedback, matrix_features)
features_iterator = self.feature_source.getFeatures(
QgsFeatureRequest())
self.index = QgsSpatialIndex()
for feat in features_iterator:
self.index.insertFeature(feat)
feedback.setProgressText('\nsorting features in reading order...\n')
OrderedFeatures = []
for sheet in SheetsOrderedList:
if feedback.isCanceled(): break
FirstColumnRect = self.TakeColumnRect(feedback, sheet)[0]
SecondColumnRect = self.TakeColumnRect(feedback, sheet)[1]
FeaturesInFirstColumn = self.index.intersects(FirstColumnRect)
FeaturesInSecondColumn = self.index.intersects(SecondColumnRect)
self.RemoveWrongIds(feedback, FirstColumnRect,
FeaturesInFirstColumn)
self.RemoveWrongIds(feedback, SecondColumnRect,
FeaturesInSecondColumn)
if len(FeaturesInFirstColumn) > 0:
OrderedFeatures = OrderedFeatures + self.PutInOrderFeatures(
feedback,
self.IdsListToFeaturesList(feedback,
FeaturesInFirstColumn))
if len(FeaturesInSecondColumn) > 0:
OrderedFeatures = OrderedFeatures + self.PutInOrderFeatures(
feedback,
self.IdsListToFeaturesList(feedback,
FeaturesInSecondColumn))
global CharsList
self.CharsToRemove = [CharsList[index] for index in self.chars_indices]
feedback.pushCommandInfo('Characters to remove: ' +
str(self.CharsToRemove))
feedback.setProgressText('\nprocessing time calculating...\n')
self.total = len(OrderedFeatures)
self.actual = 0
if self.total > 0: feedback.setProgress(self.actual / self.total * 100)
if OrderedFeatures: lastlong = str(OrderedFeatures[0][self.field])
for feat in OrderedFeatures:
if feedback.isCanceled(): break
lp = OrderedFeatures.index(feat)
string = str(feat[self.field])
feedback.pushCommandInfo('old: ' + string)
string = self.OnEachFeatureChars(feedback, string)
if self.if_short(string,
2): #alternatively it could be a parameter
string = lastlong
else:
if self.first:
string = self.OnEachFeatureResolveFirst(
feedback, string, feat, OrderedFeatures)
if self.case:
string = self.OnEachFeatureCaseSens(feedback, string)
lastlong = string
feedback.pushCommandInfo('new: ' + string)
self.actual = self.actual + 1
feedback.setProgress(self.actual / self.total * 100)
feedback.setProgressText(
str(self.actual) + '/' + str(self.total) + ' ' +
'id: ' + str(feat.id()))
feat[self.dest_field] = string
self.sink.addFeature(feat, QgsFeatureSink.FastInsert)
return {self.OUTPUT: dest_id}
def if_short(self, string, maximum):
bool = True
if len(string) > maximum: bool = False
if string == 'NULL': bool = True
return bool
def most_frequent(self, List):
'''returns most frquent first character, if it is not in list of characters to remove'''
char = ''
#rank of frequency
freq_rank = [{
'char': char,
'count': List.count(char)
} for char in List] #.sort(key = self.sortFreq)
freq_rank.sort(key=self.sortFreq)
for element in freq_rank:
if element['char'] not in self.CharsToRemove:
char = element['char']
break
print(freq_rank)
print('char: ' + char)
return char
def sortFreq(self, element):
return element['count'] * (-1)
def OnEachFeatureResolveFirst(self, feedback, string, feat, featlist):
coms = False
m = 8
list = []
index = featlist.index(feat)
if coms: feedback.pushCommandInfo('index: ' + str(index))
for i in range(0, m, 1):
n = index - int(m / 2) + i
if n < 0: continue
try:
list.append(featlist[n][self.field][0])
except:
continue
if coms: feedback.pushCommandInfo('list: ' + str(list))
most = self.most_frequent(list)
if coms: feedback.pushCommandInfo('most: ' + str(most))
prefix = ''
for i in string:
if (i.isupper() or i == ' '):
prefix += i
else:
break
preflen = len(prefix)
firstmostindex = 0
if preflen == 0:
if string[0] != most.lower():
string = most + string[1:]
elif preflen < len(string):
for i in prefix:
if i == most:
break
else:
firstmostindex = firstmostindex + 1
if firstmostindex < preflen:
string = string[firstmostindex:]
else:
if string[firstmostindex] == most.lower():
string = string[firstmostindex:]
else:
string = most + string[firstmostindex:]
return string
def OnEachFeatureCaseSens(self, feedback, string):
lista = []
listb = []
for word in string.split():
listw = list(word)
for i in range(0, len(listw), 1):
if i == 0: word = listw[i].upper()
else:
word += listw[i].lower()
lista.append(word)
string = ' '.join(lista)
for word in string.split("-"):
listw = list(word)
for i in range(0, len(listw), 1):
if i == 0: word = word[0].upper()
else:
word += listw[i]
listb.append(word)
string = '-'.join(listb)
return string
def OnEachFeatureChars(self, feedback, string):
coms = False
if coms: feedback.pushCommandInfo('string:' + string)
ln = len(string)
for i in range(0, ln - 1, 1):
if coms: feedback.pushCommandInfo('ln: ' + str(ln))
if coms: feedback.pushCommandInfo('i: ' + str(i))
if string[i] not in self.CharsToRemove:
string = string[i:]
break
ln = len(string)
for i in range(1, ln - 1, 1):
if coms: feedback.pushCommandInfo('ln: ' + str(ln))
if coms: feedback.pushCommandInfo('i: ' + str(i))
j = ln - i
if coms: feedback.pushCommandInfo('j: ' + str(j))
if string[j] in self.CharsToRemove:
if coms:
feedback.pushCommandInfo('string[j]: ' + str(string[j]))
string = string[:j]
if coms: feedback.pushCommandInfo('finally string:' + string)
else:
break
return string
def IdsListToFeaturesList(self, feedback, IdsList):
FeatList = []
for id in IdsList:
FeatList.append(self.source_layer.getFeature(id))
return FeatList
def RemoveWrongIds(self, feedback, ColumnRect, IdsList):
for id in IdsList:
if not ColumnRect.contains(
self.source_layer.getFeature(
id).geometry().centroid().asPoint()):
IdsList.remove(id)
def TakeColumnRect(self, feedback, sheet):
"""Returns two rectangles: first and second column"""
bbox = sheet.geometry().boundingBox()
x1, x2, x3, y1, y2 = bbox.xMinimum(), bbox.xMinimum() + (
bbox.xMaximum() - bbox.xMinimum()) / 2, bbox.xMaximum(
), bbox.yMinimum(), bbox.yMaximum()
FirstColumnRect = QgsRectangle(QgsPointXY(x1, y2), QgsPointXY(x2, y1))
SecondColumnRect = QgsRectangle(QgsPointXY(x2, y2), QgsPointXY(x3, y1))
return [FirstColumnRect, SecondColumnRect]
def PutInOrderFeatures(self, feedback, features_list):
""" Function puts features in reading order; from left to right in text lines. Used to arrange matrix features and text features in columns"""
ListByX = features_list.copy()
ListByX.sort(key=self.sortX)
ListByY = features_list.copy()
ListByY.sort(key=self.sortY)
w, h = len(features_list), len(features_list)
matrix = [[None] * w for i in range(h)]
"""This part builds 2D features positions table. Each row and column contains only one feature. Teble is inversed, beacause y canvas coord ascends up"""
for feat in features_list:
x = ListByX.index(feat)
y = ListByY.index(feat)
matrix[y][x] = feat
"""Identifying features lying in the same line; merging and deleting these rows"""
for row in matrix:
if matrix.index(row) < (len(matrix) - 1):
for element in matrix[matrix.index(row) + 1]:
if element != None:
y_upper = element.geometry().centroid().asPoint().y()
for element in row:
if element != None:
if element.geometry().boundingBox().height() / 2 > (
y_upper -
element.geometry().centroid().asPoint().y()):
matrix[matrix.index(row) +
1][row.index(element)] = element
row[row.index(element)] = None
ToDelete = [None] * w
if ToDelete in matrix: matrix.remove(ToDelete)
"""Inverting table order and rewriting features ti list ordered properly"""
matrix.reverse()
OrderedList = []
for row in matrix:
for element in row:
if element != None:
OrderedList.append(element)
return OrderedList
def sortX(self, feat):
return feat.geometry().centroid().asPoint().x()
def sortY(self, feat):
return feat.geometry().centroid().asPoint().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))
proximity = self.parameterAsDouble(parameters, self.PROXIMITY, context)
radius = self.parameterAsDouble(parameters, self.DISTANCE, context)
horizontal = self.parameterAsBool(parameters, self.HORIZONTAL, context)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
source.fields(), source.wkbType(), source.sourceCrs())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
def searchRect(p):
return QgsRectangle(p.x() - proximity, p.y() - proximity, p.x() + proximity, p.y() + proximity)
index = QgsSpatialIndex()
# NOTE: this is a Python port of QgsPointDistanceRenderer::renderFeature. If refining this algorithm,
# please port the changes to QgsPointDistanceRenderer::renderFeature also!
clustered_groups = []
group_index = {}
group_locations = {}
for current, f in enumerate(features):
if feedback.isCanceled():
break
if not f.hasGeometry():
continue
point = f.geometry().asPoint()
other_features_within_radius = index.intersects(searchRect(point))
if not other_features_within_radius:
index.insertFeature(f)
group = [f]
clustered_groups.append(group)
group_index[f.id()] = len(clustered_groups) - 1
group_locations[f.id()] = point
else:
# find group with closest location to this point (may be more than one within search tolerance)
min_dist_feature_id = other_features_within_radius[0]
min_dist = group_locations[min_dist_feature_id].distance(point)
for i in range(1, len(other_features_within_radius)):
candidate_id = other_features_within_radius[i]
new_dist = group_locations[candidate_id].distance(point)
if new_dist < min_dist:
min_dist = new_dist
min_dist_feature_id = candidate_id
group_index_pos = group_index[min_dist_feature_id]
group = clustered_groups[group_index_pos]
# calculate new centroid of group
old_center = group_locations[min_dist_feature_id]
group_locations[min_dist_feature_id] = QgsPointXY((old_center.x() * len(group) + point.x()) / (len(group) + 1.0),
(old_center.y() * len(group) + point.y()) / (len(group) + 1.0))
# add to a group
clustered_groups[group_index_pos].append(f)
group_index[f.id()] = group_index_pos
feedback.setProgress(int(current * total))
current = 0
total = 100.0 / len(clustered_groups) if clustered_groups else 1
feedback.setProgress(0)
fullPerimeter = 2 * math.pi
for group in clustered_groups:
if feedback.isCanceled():
break
count = len(group)
if count == 1:
sink.addFeature(group[0], QgsFeatureSink.FastInsert)
else:
angleStep = fullPerimeter / count
if count == 2 and horizontal:
currentAngle = math.pi / 2
else:
currentAngle = 0
old_point = group_locations[group[0].id()]
for f in group:
if feedback.isCanceled():
break
sinusCurrentAngle = math.sin(currentAngle)
cosinusCurrentAngle = math.cos(currentAngle)
dx = radius * sinusCurrentAngle
dy = radius * cosinusCurrentAngle
# we want to keep any existing m/z values
point = f.geometry().constGet().clone()
point.setX(old_point.x() + dx)
point.setY(old_point.y() + dy)
f.setGeometry(QgsGeometry(point))
sink.addFeature(f, QgsFeatureSink.FastInsert)
currentAngle += angleStep
current += 1
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
class TriangleMesh:
# 0 - 3
# | / |
# 1 - 2
def __init__(self, xmin, ymin, xmax, ymax, x_segments, y_segments):
self.vbands = []
self.hbands = []
self.vidx = QgsSpatialIndex()
self.hidx = QgsSpatialIndex()
xres = (xmax - xmin) / x_segments
yres = (ymax - ymin) / y_segments
self.xmin, self.ymax, self.xres, self.yres = xmin, ymax, xres, yres
def addVBand(idx, geom):
f = QgsFeature(idx)
f.setGeometry(geom)
self.vbands.append(f)
self.vidx.insertFeature(f)
def addHBand(idx, geom):
f = QgsFeature(idx)
f.setGeometry(geom)
self.hbands.append(f)
self.hidx.insertFeature(f)
for x in range(x_segments):
addVBand(x, QgsGeometry.fromRect(QgsRectangle(xmin + x * xres, ymin, xmin + (x + 1) * xres, ymax)))
for y in range(y_segments):
addHBand(y, QgsGeometry.fromRect(QgsRectangle(xmin, ymax - (y + 1) * yres, xmax, ymax - y * yres)))
def vSplit(self, geom):
"""split polygon vertically"""
for idx in self.vidx.intersects(geom.boundingBox()):
yield idx, geom.intersection(self.vbands[idx].geometry())
def hIntersects(self, geom):
"""indices of horizontal bands that intersect with geom"""
for idx in self.hidx.intersects(geom.boundingBox()):
if geom.intersects(self.hbands[idx].geometry()):
yield idx
def splitPolygons(self, geom):
xmin, ymax, xres, yres = self.xmin, self.ymax, self.xres, self.yres
for x, vi in self.vSplit(geom):
for y in self.hIntersects(vi):
pt0 = QgsPoint(xmin + x * xres, ymax - y * yres)
pt1 = QgsPoint(xmin + x * xres, ymax - (y + 1) * yres)
pt2 = QgsPoint(xmin + (x + 1) * xres, ymax - (y + 1) * yres)
pt3 = QgsPoint(xmin + (x + 1) * xres, ymax - y * yres)
quad = QgsGeometry.fromPolygon([[pt0, pt1, pt2, pt3, pt0]])
tris = [[[pt0, pt1, pt3, pt0]], [[pt3, pt1, pt2, pt3]]]
if geom.contains(quad):
yield tris[0]
yield tris[1]
else:
for i, tri in enumerate(map(QgsGeometry.fromPolygon, tris)):
if geom.contains(tri):
yield tris[i]
elif geom.intersects(tri):
poly = geom.intersection(tri)
if poly.isMultipart():
for sp in poly.asMultiPolygon():
yield sp
else:
yield poly.asPolygon()
def __sp_index_factory(layer):
index = QgsSpatialIndex()
for ft in layer.getFeatures():
index.insertFeature(ft)
return index
def run(self):
"""Run the impact function.
:returns: A vector layer with affected areas marked.
:type: safe_layer
"""
hazard_layer = self.hazard.layer
exposure = self.exposure.layer
# Thresholds for tsunami hazard zone breakdown.
low_max = self.parameters['low_threshold'].value
medium_max = self.parameters['medium_threshold'].value
high_max = self.parameters['high_threshold'].value
ranges = ranges_according_thresholds(low_max, medium_max, high_max)
hazard_value_to_class = {}
for i, interval in enumerate(ranges):
hazard_value_to_class[interval] = self.hazard_classes[i]
# Get parameters from layer's keywords
class_field = self.exposure.keyword('field')
# reproject self.extent to the hazard projection
hazard_crs = hazard_layer.crs()
hazard_authid = hazard_crs.authid()
if hazard_authid == 'EPSG:4326':
viewport_extent = self.requested_extent
else:
geo_crs = QgsCoordinateReferenceSystem()
geo_crs.createFromSrid(4326)
viewport_extent = extent_to_geo_array(
QgsRectangle(*self.requested_extent), geo_crs, hazard_crs)
small_raster = align_clip_raster(hazard_layer, viewport_extent)
# Create vector features from the flood raster
hazard_class_attribute = 'hazard'
vector_file_path = reclassify_polygonize(
small_raster.source(), ranges, name_field=hazard_class_attribute)
hazard = QgsVectorLayer(vector_file_path, 'tsunami', 'ogr')
# prepare objects for re-projection of geometries
crs_wgs84 = QgsCoordinateReferenceSystem('EPSG:4326')
hazard_to_exposure = QgsCoordinateTransform(
hazard.crs(), exposure.crs())
wgs84_to_hazard = QgsCoordinateTransform(
crs_wgs84, hazard.crs())
wgs84_to_exposure = QgsCoordinateTransform(
crs_wgs84, exposure.crs())
extent = QgsRectangle(
self.requested_extent[0], self.requested_extent[1],
self.requested_extent[2], self.requested_extent[3])
extent_hazard = wgs84_to_hazard.transformBoundingBox(extent)
extent_exposure = wgs84_to_exposure.transformBoundingBox(extent)
extent_exposure_geom = QgsGeometry.fromRect(extent_exposure)
# make spatial index of hazard
hazard_index = QgsSpatialIndex()
hazard_features = {}
for f in hazard.getFeatures(QgsFeatureRequest(extent_hazard)):
f.geometry().transform(hazard_to_exposure)
hazard_index.insertFeature(f)
hazard_features[f.id()] = QgsFeature(f)
# create impact layer
filename = unique_filename(suffix='.shp')
impact_fields = exposure.dataProvider().fields()
impact_fields.append(QgsField(self.target_field, QVariant.String))
writer = QgsVectorFileWriter(
filename, 'utf-8', impact_fields, QGis.WKBPolygon, exposure.crs())
# iterate over all exposure polygons and calculate the impact
_calculate_landcover_impact(
exposure, extent_exposure, extent_exposure_geom,
hazard_class_attribute, hazard_features, hazard_index,
hazard_value_to_class, impact_fields, writer)
del writer
impact_layer = QgsVectorLayer(filename, 'Impacted Land Cover', 'ogr')
if impact_layer.featureCount() == 0:
raise ZeroImpactException()
zone_field = None
if self.aggregator:
zone_field = self.aggregator.exposure_aggregation_field
impact_data = LandCoverReportMixin(
question=self.question,
impact_layer=impact_layer,
target_field=self.target_field,
ordered_columns=self.hazard_classes,
affected_columns=self.affected_hazard_columns,
land_cover_field=class_field,
zone_field=zone_field
).generate_data()
# Define style for the impact layer
style_classes = [
dict(
label=self.hazard_classes[0] + ': 0m',
value=self.hazard_classes[0],
colour='#00FF00',
border_color='#000000',
transparency=0),
dict(
label=self.hazard_classes[1] + ': >0 - %.1f m' % low_max,
value=self.hazard_classes[1],
colour='#FFFF00',
border_color='#000000',
transparency=0),
dict(
label=self.hazard_classes[2] + ': %.1f - %.1f m' % (
low_max + 0.1, medium_max),
value=self.hazard_classes[2],
colour='#FFB700',
border_color='#000000',
transparency=0),
dict(
label=self.hazard_classes[3] + ': %.1f - %.1f m' % (
medium_max + 0.1, high_max),
value=self.hazard_classes[3],
colour='#FF6F00',
border_color='#000000',
transparency=0),
dict(
label=self.hazard_classes[4] + ' > %.1f m' % high_max,
value=self.hazard_classes[4],
colour='#FF0000',
border_color='#000000',
transparency=0),
]
style_info = dict(
target_field=self.target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
extra_keywords = {
'map_title': self.map_title(),
'target_field': self.target_field
}
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Create vector layer and return
impact_layer = Vector(
data=impact_layer,
name=self.map_title(),
keywords=impact_layer_keywords,
style_info=style_info)
impact_layer.impact_data = impact_data
self._impact = impact_layer
return impact_layer
def addTransportData(self,
shapefile,
startTime,
epsgCode,
roadTypeField,
roadTypeNames,
inputIdField,
speedDataField=None,
speedConversionFactor=None,
totalAADTField=None,
vAADTFields=None):
''' Adds transport data to the object, associates it with a start time and calculates disaggregated hourly mean transport QF
:param shapefile: string: path to input shapefile
:param startTime: datetime: time from which this data should be used
:param roadTypeField: string: Attribute containing the road classification
:param roadTypeNames: dict: How the main road types are identified in the shapefile {'motorway':str, 'primary_road':str, 'secondary_road':str}
:param inputIdField: str: Name of shapefile field containing unique identifiers for each road segment
:param speedDataField: str: shapefile attribute containing speed data (None if not available)
:param speedConversionFactor: float: if speed is read from shapefile, multiply it by this factor to convert it to km/h
:param totalAADTField: str: shapefile attribute containing total Annual Averaged Daily Total traffic count (total across all vechile types) (None if not available)
:param vADDTflds: dict: shapefile attributes to use for each separate vehicle type's AADT
Two variants allowed, one with separate fuels for LGVs and cars, and one without:
Allowed keys 1: diesel_car, petrol_car, diesel_lgv, petrol_lgv, motorcycle, taxi, bus, coach, rigid, artic
Allowed keys 2: total_car, total_lgv, motorcycle, taxi, bus, coach, rigid, artic
:param epsgCode: int: EPSG code of shapefile
:return: QgsVectorLayer: Mean hourly transport heat flux in each output area polygon
'''
# Flags to identify the level of detail of the input data
speedDataAvailable = False # Mean traffic speed available for each road segment
completeInputAADTprovided = False # AADT is broken down into the vehicles listed in completeInputs
modelledTypesAADTprovided = False # AADT data is broken down into the vehicles listed in modelledTypes
self.validateInputs(startTime, shapefile, epsgCode, roadTypeField,
roadTypeNames)
roadTypeLookup = {
roadTypeNames[key]: key
for key in self.roadTypes
} # This is a way to look up our version of the road type, given the shapefile's version of the road type
roadTypeLookup[
'other'] = 'other' # For all other road types that don't match the above
# Establish what speed data is available
# TODO: Use speed in fuel efficiency lookup
fieldsToSample = [
roadTypeField
] # Master list of all the fields to sample from the shapefile. Gets built up as we go along...
if type(speedDataField) is str:
speedDataAvailable = True
try:
speedConversionFactor = float(speedConversionFactor)
except Exception:
raise ValueError('Vehicle speed multiplier must be a number')
fieldsToSample.append(speedDataField)
# Establish what AADT data is available
if type(totalAADTField) is str:
fieldsToSample.append(totalAADTField)
# Validate fields for AADT by vehicle type, if it was provided
if type(vAADTFields) is dict:
allowedKeys1 = self.completeInputs
allowedKeys2 = self.modelledTypes
missingFrom1 = list(
set(allowedKeys1).difference(vAADTFields.keys()))
missingFrom2 = list(
set(allowedKeys2).difference(vAADTFields.keys()))
if len(missingFrom1) == 0:
completeInputAADTprovided = True
elif len(missingFrom2) == 0:
modelledTypesAADTprovided = True
else:
raise ValueError(
'The vehicle AADT field names provided are incomplete. Expected: '
+ str(allowedKeys1) + ' OR ' + str(allowedKeys2) +
'. Got: ' + str(vAADTFields.keys()))
fieldsToSample.extend(vAADTFields.values())
# Make a copy of the shapefile in a temp folder (we wish to change it)
# Ensure the input layer has the right projection when it gets there
shapefile = reprojectVectorLayer(shapefile,
self.transport.templateEpsgCode)
#inputLayer = loadShapeFile(shapefile)
inputLayer = openShapeFileInMemory(shapefile,
self.transport.templateEpsgCode,
'transport')
try:
# Try to delete tempfile but don't explode if fail as QGIS sometimes hangs onto them for slightly too long
rmtree(os.path.dirname(shapefile))
except:
pass
# TODO: Explain to the logger what we are doing with the various fields
# Get lookup between field names and indices
fieldNames = {
a.name(): i
for i, a in enumerate(inputLayer.dataProvider().fields())
}
# Check that the requested field names are actually present in the layer
missingFields = list(set(fieldsToSample).difference(fieldNames.keys()))
if len(missingFields) > 0:
raise ValueError(
'Some of the transport shapefile fields referenced were not found in the shapefile:'
+ str(missingFields))
# Calculate fuel use in each segment
# TODO 2: Support a vehicle age profile (only a static profile is likely to be tractable)
# TODO 1: Get this from the parameters file
vehDate = pd.datetime.strptime(
'2005-01-01', '%Y-%m-%d'
) # For now, just assumes every vehicle was made in 2005 and looks up values from the fuel consumption object
# Come up with a read-across between transport road types and euroclass road types
# Any roads not matching these are assumed to be very minor and are omitted
# TODO: Refine this treatment
# Clone the output layer (populate this with [dis]aggregated data) and create spatial index
outputLayer = duplicateVectorLayer(
self.transport.outputLayer,
targetEPSG=self.transport.templateEpsgCode)
inputIndex = QgsSpatialIndex()
for feat in inputLayer.getFeatures():
inputIndex.insertFeature(feat)
# Get translation to look up internal feature ID based on our preferred ID field
t = shapefile_attributes(outputLayer)[self.transport.templateIdField]
featureMapper = pd.Series(index=map(intOrString, t.values),
data=map(intOrString, t.index))
t = None
# Convert road lengths and AADT data to total fuel use each day on each segment of road
fuelUseDict = calculate_fuel_use(
inputLayer,
inputIdField,
totalAADTField=totalAADTField,
roadTypeField=roadTypeField,
vAADTFields=vAADTFields,
completeInputs=self.completeInputs,
modelParams=self.modelParams,
age=vehDate,
fuelCon=self.fc,
roadTypeLookup=roadTypeLookup,
completeInputAADTprovided=completeInputAADTprovided,
modelledTypesAADTprovided=modelledTypesAADTprovided)
fuelUseData = fuelUseDict['fuelUse']
fuelUseNames = fuelUseDict['names']
allFuelFields = fuelUseNames['petrol'].values()
allFuelFields.extend(fuelUseNames['diesel'].values())
# Get road segment lengths inside each output polygon, along with attributes of each of these intersected segments
intersectedLines = intersecting_amounts([], inputIndex, inputLayer,
outputLayer, inputIdField,
self.transport.templateIdField)
# Add total fuel consumption fields to output layer into which fuel consumption will go]
for newField in allFuelFields:
outputLayer = addNewField(outputLayer, newField)
# Find out where new fields reside
newFieldIndices = [
get_field_index(outputLayer, fn) for fn in fuelUseData.columns
]
# Refer to everything in terms of field index instead
fuelUseData.columns = newFieldIndices
# intersecting_amounts gives us enough information (original segment length and intersected length)
# to disaggregate fuel use into each output feature, and to calculate total fuel use in each output feature
areas = self.transport.getAreas()
outputLayer.startEditing()
fuelConsumption = pd.DataFrame(
index=intersectedLines.keys(),
columns=newFieldIndices) # Results container for each feature
for outfeat_id in intersectedLines.keys():
fuelConsumption[:].loc[outfeat_id] = 0
if len(intersectedLines[outfeat_id]) > 0:
# If there are any areas intersected by this polygon
# Total fuel consumption within this output area
lengths = pd.DataFrame().from_dict(
intersectedLines[outfeat_id]).T
proportionIntersected = lengths['amountIntersected'] / lengths[
'originalAmount']
# Get total of each fuel/vehicle combination by summing across segments in output area
fuelConsumption[:].loc[outfeat_id] = (
fuelUseData[:].loc[lengths.index].multiply(
proportionIntersected, axis=0)).sum(axis=0,
skipna=True)
# Update shapefile attributes one by one. Doing it in bulk via the dataprovider /should/ work too, but doesn't seem to
# Convert to kg fuel per square metre of output area too
[
outputLayer.changeAttributeValue(
featureMapper[outfeat_id], fi,
float(fuelConsumption[fi][outfeat_id]) /
float(areas[outfeat_id])) for fi in newFieldIndices
]
outputLayer.commitChanges()
# This output layer is a set of polygons with associated fuel use and can be treated like any other
# fuel consumption input shapefile
confirmedOutput = self.transport.addInput(
outputLayer,
startTime,
allFuelFields,
self.transport.templateIdField,
epsgCode=epsgCode)
return confirmedOutput
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.VECTOR), context)
pointCount = float(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, layer.crs(), context)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
featureCount = layer.featureCount()
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
da = QgsDistanceArea()
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
# pick random feature
fid = random.randint(0, featureCount - 1)
f = next(
layer.getFeatures(
request.setFilterFid(fid).setSubsetOfAttributes([])))
fGeom = f.geometry()
if fGeom.isMultipart():
lines = fGeom.asMultiPolyline()
# pick random line
lineId = random.randint(0, len(lines) - 1)
vertices = lines[lineId]
else:
vertices = fGeom.asPolyline()
# pick random segment
if len(vertices) == 2:
vid = 0
else:
vid = random.randint(0, len(vertices) - 2)
startPoint = vertices[vid]
endPoint = vertices[vid + 1]
length = da.measureLine(startPoint, endPoint)
dist = length * random.random()
if dist > minDistance:
d = dist / (length - dist)
rx = (startPoint.x() + d * endPoint.x()) / (1 + d)
ry = (startPoint.y() + d * endPoint.y()) / (1 + d)
# generate random point
pnt = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
QgsMessageLog.logMessage(
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'),
self.tr('Processing'), QgsMessageLog.INFO)
del writer
class PyProvider(QgsVectorDataProvider):
next_feature_id = 1
@classmethod
def providerKey(cls):
"""Returns the memory provider key"""
return 'pythonprovider'
@classmethod
def description(cls):
"""Returns the memory provider description"""
return 'Python Test Provider'
@classmethod
def createProvider(cls, uri, providerOptions):
return PyProvider(uri, providerOptions)
# Implementation of functions from QgsVectorDataProvider
def __init__(self, uri='', providerOptions=QgsDataProvider.ProviderOptions()):
super().__init__(uri)
# Use the memory layer to parse the uri
mlayer = QgsVectorLayer(uri, 'ml', 'memory')
self.setNativeTypes(mlayer.dataProvider().nativeTypes())
self._uri = uri
self._fields = mlayer.fields()
self._wkbType = mlayer.wkbType()
self._features = {}
self._extent = QgsRectangle()
self._extent.setMinimal()
self._subset_string = ''
self._crs = mlayer.crs()
self._spatialindex = None
self._provider_options = providerOptions
if 'index=yes'in self._uri:
self.createSpatialIndex()
def featureSource(self):
return PyFeatureSource(self)
def dataSourceUri(self, expandAuthConfig=True):
return self._uri
def storageType(self):
return "Python test memory storage"
def getFeatures(self, request=QgsFeatureRequest()):
return QgsFeatureIterator(PyFeatureIterator(PyFeatureSource(self), request))
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 wkbType(self):
return self._wkbType
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 fields(self):
return self._fields
def addFeatures(self, flist, flags=None):
added = False
f_added = []
for f in flist:
if f.hasGeometry() and (f.geometry().wkbType() != self.wkbType()):
return added, f_added
for f in flist:
_f = QgsFeature(self.fields())
_f.setGeometry(f.geometry())
attrs = [None for i in range(_f.fields().count())]
for i in range(min(len(attrs), len(f.attributes()))):
attrs[i] = f.attributes()[i]
_f.setAttributes(attrs)
_f.setId(self.next_feature_id)
self._features[self.next_feature_id] = _f
self.next_feature_id += 1
added = True
f_added.append(_f)
if self._spatialindex is not None:
self._spatialindex.insertFeature(_f)
if len(f_added):
self.clearMinMaxCache()
self.updateExtents()
return added, f_added
def deleteFeatures(self, ids):
if not ids:
return True
removed = False
for id in ids:
if id in self._features:
if self._spatialindex is not None:
self._spatialindex.deleteFeature(self._features[id])
del self._features[id]
removed = True
if removed:
self.clearMinMaxCache()
self.updateExtents()
return removed
def addAttributes(self, attrs):
try:
for new_f in attrs:
if new_f.type() not in (QVariant.Int, QVariant.Double, QVariant.String, QVariant.Date, QVariant.Time, QVariant.DateTime, QVariant.LongLong, QVariant.StringList, QVariant.List):
continue
self._fields.append(new_f)
for f in self._features.values():
old_attrs = f.attributes()
old_attrs.append(None)
f.setAttributes(old_attrs)
self.clearMinMaxCache()
return True
except Exception:
return False
def renameAttributes(self, renamedAttributes):
result = True
# We need to replace all fields because python bindings return a copy from [] and at()
new_fields = [self._fields.at(i) for i in range(self._fields.count())]
for fieldIndex, new_name in renamedAttributes.items():
if fieldIndex < 0 or fieldIndex >= self._fields.count():
result = False
continue
if self._fields.indexFromName(new_name) >= 0:
#field name already in use
result = False
continue
new_fields[fieldIndex].setName(new_name)
if result:
self._fields = QgsFields()
for i in range(len(new_fields)):
self._fields.append(new_fields[i])
return result
def deleteAttributes(self, attributes):
attrIdx = sorted(attributes, reverse=True)
# delete attributes one-by-one with decreasing index
for idx in attrIdx:
self._fields.remove(idx)
for f in self._features.values():
attr = f.attributes()
del(attr[idx])
f.setAttributes(attr)
self.clearMinMaxCache()
return True
def changeAttributeValues(self, attr_map):
for feature_id, attrs in attr_map.items():
try:
f = self._features[feature_id]
except KeyError:
continue
for k, v in attrs.items():
f.setAttribute(k, v)
self.clearMinMaxCache()
return True
def changeGeometryValues(self, geometry_map):
for feature_id, geometry in geometry_map.items():
try:
f = self._features[feature_id]
f.setGeometry(geometry)
except KeyError:
continue
self.updateExtents()
return True
def allFeatureIds(self):
return list(self._features.keys())
def subsetString(self):
return self._subset_string
def setSubsetString(self, subsetString):
if subsetString == self._subset_string:
return True
self._subset_string = subsetString
self.updateExtents()
self.clearMinMaxCache()
self.dataChanged.emit()
return True
def supportsSubsetString(self):
return True
def createSpatialIndex(self):
if self._spatialindex is None:
self._spatialindex = QgsSpatialIndex()
for f in self._features.values():
self._spatialindex.insertFeature(f)
return True
def capabilities(self):
return QgsVectorDataProvider.AddFeatures | QgsVectorDataProvider.DeleteFeatures | QgsVectorDataProvider.CreateSpatialIndex | QgsVectorDataProvider.ChangeGeometries | QgsVectorDataProvider.ChangeAttributeValues | QgsVectorDataProvider.AddAttributes | QgsVectorDataProvider.DeleteAttributes | QgsVectorDataProvider.RenameAttributes | QgsVectorDataProvider.SelectAtId | QgsVectorDataProvider. CircularGeometries
#/* Implementation of functions from QgsDataProvider */
def name(self):
return self.providerKey()
def extent(self):
if self._extent.isEmpty() and self._features:
self._extent.setMinimal()
if not self._subset_string:
# fast way - iterate through all features
for feat in self._features.values():
if feat.hasGeometry():
self._extent.combineExtentWith(feat.geometry().boundingBox())
else:
for f in self.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([])):
if f.hasGeometry():
self._extent.combineExtentWith(f.geometry().boundingBox())
elif not self._features:
self._extent.setMinimal()
return QgsRectangle(self._extent)
def updateExtents(self):
self._extent.setMinimal()
def isValid(self):
return True
def crs(self):
return self._crs
class PW_OCR_Advanced_Algorithm(QgsProcessingAlgorithm):
# Constants used to refer to parameters and outputs. They will be
# used when calling the algorithm from another algorithm, or when
# calling from the QGIS console.
INPUT = 'INPUT'
RASTER_INPUT = 'RASTER INPUT'
FIELD = 'FIELD'
CONF_FIELD = 'CONF FIELD'
ALL_ACTIVE_RASTERS = 'ALL ACTIVE RASTERS'
PSM = 'PSM'
OEM = 'OEM'
ZERO_CONF = 'ZERO CONF'
OUTPUT = 'OUTPUT'
def tr(self, string):
return QCoreApplication.translate('Processing', string)
def createInstance(self):
return PW_OCR_Advanced_Algorithm()
def name(self):
return 'pw_ocr_adv'
def displayName(self):
return self.tr('PW OCR ADVANCED')
def group(self):
return self.tr('PW')
def groupId(self):
return 'pw'
def shortHelpString(self):
help = """This algorithm recognizes text from raster images inside input polygon features and saves as attribute value of output layer.\
<hr>
<b>Input polygon layer</b>\
<br>The features used to recognize text inside them.\
<br><br><b>Text output field</b>\
<br>The field in the input table in which the recognized text will be add.\
<br><br><b>Confidence output field</b>\
<br>The field in the input table in which the text recognition confidence will be add. Confidence is saved in the list; one value for each word.\
<br><br><b>Run for all raster layers</b>\
<br>The algorithm will recognize text from all active raster layers, if checked.\
<br><br><b>Input raster layer</b>\
<br>If above checkbox unchecked, the algorithm will recognize text only from this raster layer.\
<br>In case of multiband raster images, the only first band will be used.\
<br><br><b>Page Segmentation Mode</b>\
<br><i>Tesseract</i> Page Segmentation Mode.\
<br><br><b>OCR Engine Model</b>\
<br><i>Tesseract</i> OCR Engine Model.\
<br><br><b>Add words recognized with zero confidence</b>\
<br>If there are some words recognized with zero confidence, they will be add too.\
<br><br><b>Output layer</b>\
<br>Location of the output layer with filled text attribute.\
"""
return self.tr(help)
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterFeatureSource(
self.INPUT, self.tr('Input polygon layer'),
[QgsProcessing.TypeVectorPolygon]))
self.addParameter(
QgsProcessingParameterField(
self.FIELD,
self.tr('Text output field'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.DataType.String))
self.addParameter(
QgsProcessingParameterField(
self.CONF_FIELD,
self.tr('Confidence output field'),
parentLayerParameterName=self.INPUT,
type=QgsProcessingParameterField.DataType.String,
optional=True,
))
self.addParameter(
QgsProcessingParameterBoolean(
self.ALL_ACTIVE_RASTERS, self.tr('Run for all raster layers')))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.RASTER_INPUT,
self.tr('Input raster layer'),
optional=True,
))
self.addParameter(
QgsProcessingParameterEnum(
self.PSM,
self.tr('Page Segmentation Mode'),
options=[
'Orientation and script detection (OSD) only.',
'Automatic page segmentation with OSD.',
'Automatic page segmentation, but no OSD, or OCR.',
'Fully automatic page segmentation, but no OSD. (Default if no config)',
'Assume a single column of text of variable sizes.',
'Assume a single uniform block of vertically aligned text.',
'Assume a single uniform block of text.',
'Treat the image as a single text line.',
'Treat the image as a single word.',
'Treat the image as a single word in a circle.',
'Treat the image as a single character.',
'Sparse text. Find as much text as possible in no particular order.',
'Sparse text with OSD.',
'Raw line. Treat the image as a single text line, bypassing hacks that are Tesseract-specific.'
],
defaultValue=3))
self.addParameter(
QgsProcessingParameterEnum(
self.OEM,
self.tr('OCR Engine Model'),
options=['Legacy Tesseract', 'LSTM', '2', '3'],
defaultValue=1))
self.addParameter(
QgsProcessingParameterBoolean(
self.ZERO_CONF,
self.tr('Add words recognized with zero confidence'), True))
self.addParameter(
QgsProcessingParameterFeatureSink(self.OUTPUT,
self.tr('Output layer')))
def processAlgorithm(self, parameters, context, feedback):
self.source_layer = self.parameterAsLayer(parameters, self.INPUT,
context)
self.feature_source = self.parameterAsSource(parameters, self.INPUT,
context)
raster_lyr = self.parameterAsRasterLayer(parameters, self.RASTER_INPUT,
context)
all_rasters = self.parameterAsBool(parameters, self.ALL_ACTIVE_RASTERS,
context)
temp_path = self.parameterAsString(parameters, '', context)
self.dest_field = self.parameterAsString(parameters, self.FIELD,
context)
self.conf_field = self.parameterAsString(parameters, self.CONF_FIELD,
context)
psm = self.parameterAsInt(parameters, 'PSM', context)
oem = self.parameterAsInt(parameters, 'OEM', context)
self.zero_conf = self.parameterAsBool(parameters, self.ZERO_CONF,
context)
(self.sink,
dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
self.feature_source.fields(),
self.feature_source.wkbType(),
self.feature_source.sourceCrs())
if self.source_layer == None:
list = QgsProject.instance().mapLayersByName(
self.feature_source.sourceName())
for lyr in list:
if self.feature_source.sourceCrs() == lyr.sourceCrs():
self.source_layer = lyr
if self.feature_source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
if raster_lyr is None and not all_rasters:
feedback.pushInfo('\nNo raster layer selected!\n')
raise QgsProcessingException(
self.invalidSourceError(parameters, self.RASTER_INPUT))
'''here is tesseract config string'''
self.config = '--psm ' + str(psm) + ' --oem ' + str(oem)
feedback.pushInfo('TESSERACT CONFIG: ' + self.config)
self.conf_treshold = 0
if self.zero_conf:
self.conf_treshold = -1
else:
self.conf_treshold = 0
features = self.feature_source.getFeatures(QgsFeatureRequest())
self.index = QgsSpatialIndex()
for feat in features:
self.index.insertFeature(feat)
feedback.pushInfo('\nprocessing time calculating...\n')
n = []
if not all_rasters and raster_lyr:
n = self.index.intersects(raster_lyr.extent())
else:
for layer in iface.mapCanvas().layers():
if layer.type() == 1:
n = n + self.index.intersects(layer.extent())
self.total = len(n)
self.actual = 0
if self.total > 0: feedback.setProgress(self.actual / self.total * 100)
if not all_rasters:
self.OnThisRaster(feedback, raster_lyr)
else:
for layer in iface.mapCanvas().layers():
if feedback.isCanceled(): break
if layer.type() == 1:
self.OnThisRaster(feedback, layer)
return {self.OUTPUT: dest_id}
def OnThisRaster(self, feedback, Raster_lyr):
idsList = self.index.intersects(Raster_lyr.extent())
if idsList and len(idsList) > 0:
feedback.pushCommandInfo('\nComputing image ' +
str(Raster_lyr.name()) + '.\n')
data = pytesseract.image_to_data(Raster_lyr.source(),
lang='pol',
config=self.config,
output_type=Output.DICT)
text = data['text']
table_of_words = []
for i in range(0, len(text), 1):
pix_centroid_left = data['left'][i] + data['width'][i] / 2
pix_centroid_top = data['top'][i] + data['height'][i] / 2
crs_point = self.PixelCoordsToCRSPoint(feedback, Raster_lyr,
pix_centroid_left,
pix_centroid_top)
element = [crs_point, data['text'][i], data['conf'][i]]
table_of_words.append(element)
for id in idsList:
for feat in self.feature_source.getFeatures(
QgsFeatureRequest()):
if feedback.isCanceled(): break
if int(feat.id()) == id:
self.OnThisFeature(feedback, feat, table_of_words)
break
else:
feedback.pushCommandInfo('\nImage ' + str(Raster_lyr.name()) +
' does not intersect any feature.\n')
def OnThisFeature(self, feedback, feat, table_of_words):
chosen_elements = []
for element in table_of_words:
if feat.geometry().contains(element[0]):
chosen_elements.append(element)
chosen_elements.sort(key=self.sortByX)
strings = []
conf = []
if chosen_elements:
for element in chosen_elements:
if int(element[2]) > self.conf_treshold:
strings.append(element[1])
if int(element[2]) > -1: conf.append(int(element[2]))
string = ' '.join(strings)
feat[self.dest_field] = string
if self.conf_field:
feat[self.conf_field] = str(
conf) #.encode('utf8')#.decode('CP1250')
self.actual = self.actual + 1
feedback.setProgress(self.actual / self.total * 100)
feedback.setProgressText(
str(self.actual) + '/' + str(self.total) + ' ' + 'id: ' +
str(feat.id()))
feedback.pushCommandInfo('\n' + string + '\nConfidence:' + str(conf) +
'\n')
self.sink.addFeature(feat, QgsFeatureSink.FastInsert)
def sortByX(self, element):
return element[0].x()
def PixelCoordsToCRSPoint(self, feedback, lyr, left, top):
rect = lyr.extent()
x = rect.xMinimum() + lyr.rasterUnitsPerPixelY() * left
y = rect.yMaximum() - lyr.rasterUnitsPerPixelX() * top
point = QgsPointXY(x, y)
return point
class ContourTool(object):
def updateReference(self, referenceLayer):
"""
Updates the reference layer and updates the spatial index
"""
self.first_value = None
self.reference = referenceLayer
self.populateIndex()
def populateIndex(self):
"""
Populates the spatial index
"""
#spatial index
self.index = QgsSpatialIndex()
for feat in self.reference.getFeatures():
self.index.insertFeature(feat)
def getCandidates(self, bbox):
"""
Gets candidates using the spatial index to speedup the process
"""
#features that might satisfy the query
ids = self.index.intersects(bbox)
candidates = []
for id in ids:
candidates.append(
next(
self.reference.getFeatures(
QgsFeatureRequest().setFilterFid(id))))
return candidates
def getFeatures(self, geom):
"""
Gets the features that intersect geom to be updated
"""
#features that satisfy the query
ret = []
rect = geom.boundingBox()
candidates = self.getCandidates(rect)
for candidate in candidates:
featGeom = candidate.geometry()
if featGeom.intersects(geom):
ret.append(candidate)
return ret
def getKey(self, item):
"""
Gets the key
"""
return item[0]
def sortFeatures(self, geom, features):
"""
Sorts features according to the distance
"""
#sorting by distance
distances = []
firstPoint = geom.asPolyline()[0]
pointGeom = QgsGeometry.fromPointXY(firstPoint)
for intersected in features:
intersection = geom.intersection(intersected.geometry())
if intersection.type() == QgsWkbTypes.PointGeometry:
distance = intersection.distance(pointGeom)
distances.append((distance, intersected))
ordered = sorted(distances, key=self.getKey)
#returning a list of tuples (distance, feature)
return ordered
def reproject(self, geom, canvasCrs):
"""
Reprojects geom to the reference layer crs
"""
destCrs = self.reference.crs()
if canvasCrs.authid() != destCrs.authid():
coordinateTransformer = QgsCoordinateTransform(canvasCrs, destCrs)
geom.transform(coordinateTransformer)
def setFirstValue(self, value):
self.first_value = value
def assignValues(self, attribute, pace, geom, canvasCrs):
"""
Assigns attribute values to all features that intersect geom.
"""
self.reproject(geom, canvasCrs)
features = self.getFeatures(geom)
if len(features) == 0:
return -2
ordered = self.sortFeatures(geom, features)
if len(ordered) == 0:
return -1
self.reference.startEditing()
#the first feature must have the initial value already assigned
first_feature = ordered[0][1]
#getting the filed index that must be updated
fieldIndex = self.reference.fields().indexFromName(attribute)
#getting the initial value
first_value = first_feature.attribute(attribute)
if not first_value:
first_value_dlg = ContourValue(self)
retorno = first_value_dlg.exec_()
if self.first_value:
id = first_feature.id()
first_value = self.first_value
if not self.reference.changeAttributeValue(
id, fieldIndex, self.first_value):
return 0
else:
return -3
self.first_value = None
for i in range(1, len(ordered)):
#value to be adjusted
value = first_value + pace * i
#feature that will be updated
feature = ordered[i][1]
#feature id that will be updated
id = feature.id()
#actual update in the layer
if not self.reference.changeAttributeValue(id, fieldIndex, value):
return 0
return 1
class PyProvider(QgsVectorDataProvider):
next_feature_id = 1
@classmethod
def providerKey(cls):
"""Returns the memory provider key"""
return 'pythonprovider'
@classmethod
def description(cls):
"""Returns the memory provider description"""
return 'Python Test Provider'
@classmethod
def createProvider(cls, uri, providerOptions):
return PyProvider(uri, providerOptions)
# Implementation of functions from QgsVectorDataProvider
def __init__(self, uri='', providerOptions=QgsDataProvider.ProviderOptions()):
super().__init__(uri)
# Use the memory layer to parse the uri
mlayer = QgsVectorLayer(uri, 'ml', 'memory')
self.setNativeTypes(mlayer.dataProvider().nativeTypes())
self._uri = uri
self._fields = mlayer.fields()
self._wkbType = mlayer.wkbType()
self._features = {}
self._extent = QgsRectangle()
self._extent.setMinimal()
self._subset_string = ''
self._crs = mlayer.crs()
self._spatialindex = None
self._provider_options = providerOptions
if 'index=yes'in self._uri:
self.createSpatialIndex()
def featureSource(self):
return PyFeatureSource(self)
def dataSourceUri(self, expandAuthConfig=True):
return self._uri
def storageType(self):
return "Python test memory storage"
def getFeatures(self, request=QgsFeatureRequest()):
return QgsFeatureIterator(PyFeatureIterator(PyFeatureSource(self), request))
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 wkbType(self):
return self._wkbType
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 fields(self):
return self._fields
def addFeatures(self, flist, flags=None):
added = False
f_added = []
for f in flist:
if f.hasGeometry() and (f.geometry().wkbType() != self.wkbType()):
return added, f_added
for f in flist:
_f = QgsFeature(self.fields())
_f.setGeometry(f.geometry())
attrs = [None for i in range(_f.fields().count())]
for i in range(min(len(attrs), len(f.attributes()))):
attrs[i] = f.attributes()[i]
_f.setAttributes(attrs)
_f.setId(self.next_feature_id)
self._features[self.next_feature_id] = _f
self.next_feature_id += 1
added = True
f_added.append(_f)
if self._spatialindex is not None:
self._spatialindex.insertFeature(_f)
if len(f_added):
self.clearMinMaxCache()
self.updateExtents()
return added, f_added
def deleteFeatures(self, ids):
if not ids:
return True
removed = False
for id in ids:
if id in self._features:
if self._spatialindex is not None:
self._spatialindex.deleteFeature(self._features[id])
del self._features[id]
removed = True
if removed:
self.clearMinMaxCache()
self.updateExtents()
return removed
def addAttributes(self, attrs):
try:
for new_f in attrs:
if new_f.type() not in (QVariant.Int, QVariant.Double, QVariant.String, QVariant.Date, QVariant.Time, QVariant.DateTime, QVariant.LongLong, QVariant.StringList, QVariant.List):
continue
self._fields.append(new_f)
for f in self._features.values():
old_attrs = f.attributes()
old_attrs.append(None)
f.setAttributes(old_attrs)
self.clearMinMaxCache()
return True
except Exception:
return False
def renameAttributes(self, renamedAttributes):
result = True
# We need to replace all fields because python bindings return a copy from [] and at()
new_fields = [self._fields.at(i) for i in range(self._fields.count())]
for fieldIndex, new_name in renamedAttributes.items():
if fieldIndex < 0 or fieldIndex >= self._fields.count():
result = False
continue
if self._fields.indexFromName(new_name) >= 0:
#field name already in use
result = False
continue
new_fields[fieldIndex].setName(new_name)
if result:
self._fields = QgsFields()
for i in range(len(new_fields)):
self._fields.append(new_fields[i])
return result
def deleteAttributes(self, attributes):
attrIdx = sorted(attributes, reverse=True)
# delete attributes one-by-one with decreasing index
for idx in attrIdx:
self._fields.remove(idx)
for f in self._features.values():
attr = f.attributes()
del(attr[idx])
f.setAttributes(attr)
self.clearMinMaxCache()
return True
def changeAttributeValues(self, attr_map):
for feature_id, attrs in attr_map.items():
try:
f = self._features[feature_id]
except KeyError:
continue
for k, v in attrs.items():
f.setAttribute(k, v)
self.clearMinMaxCache()
return True
def changeGeometryValues(self, geometry_map):
for feature_id, geometry in geometry_map.items():
try:
f = self._features[feature_id]
f.setGeometry(geometry)
except KeyError:
continue
self.updateExtents()
return True
def allFeatureIds(self):
return list(self._features.keys())
def subsetString(self):
return self._subset_string
def setSubsetString(self, subsetString):
if subsetString == self._subset_string:
return True
self._subset_string = subsetString
self.updateExtents()
self.clearMinMaxCache()
self.dataChanged.emit()
return True
def supportsSubsetString(self):
return True
def createSpatialIndex(self):
if self._spatialindex is None:
self._spatialindex = QgsSpatialIndex()
for f in self._features.values():
self._spatialindex.insertFeature(f)
return True
def capabilities(self):
return QgsVectorDataProvider.AddFeatures | QgsVectorDataProvider.DeleteFeatures | QgsVectorDataProvider.CreateSpatialIndex | QgsVectorDataProvider.ChangeGeometries | QgsVectorDataProvider.ChangeAttributeValues | QgsVectorDataProvider.AddAttributes | QgsVectorDataProvider.DeleteAttributes | QgsVectorDataProvider.RenameAttributes | QgsVectorDataProvider.SelectAtId | QgsVectorDataProvider. CircularGeometries
#/* Implementation of functions from QgsDataProvider */
def name(self):
return self.providerKey()
def extent(self):
if self._extent.isEmpty() and self._features:
self._extent.setMinimal()
if not self._subset_string:
# fast way - iterate through all features
for feat in self._features.values():
if feat.hasGeometry():
self._extent.combineExtentWith(feat.geometry().boundingBox())
else:
for f in self.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([])):
if f.hasGeometry():
self._extent.combineExtentWith(f.geometry().boundingBox())
elif not self._features:
self._extent.setMinimal()
return QgsRectangle(self._extent)
def updateExtents(self):
self._extent.setMinimal()
def isValid(self):
return True
def crs(self):
return self._crs
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 processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.VECTOR), context)
fieldName = self.getParameterValue(self.FIELD)
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
strategy = self.getParameterValue(self.STRATEGY)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
da = QgsDistanceArea()
features = QgsProcessingUtils.getFeatures(layer, context)
for current, f in enumerate(features):
fGeom = f.geometry()
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(f[fieldName])
else:
pointCount = int(round(f[fieldName] * da.measureArea(fGeom)))
if pointCount == 0:
feedback.pushInfo("Skip feature {} as number of points for it is 0.")
continue
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(fGeom) and \
vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
QgsMessageLog.logMessage(self.tr('Can not generate requested number of random '
'points. Maximum number of attempts exceeded.'), self.tr('Processing'), QgsMessageLog.INFO)
feedback.setProgress(0)
del writer
def processAlgorithm(self, context, feedback):
layerA = dataobjects.getLayerFromString(
self.getParameterValue(self.INPUT_A))
splitLayer = dataobjects.getLayerFromString(
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(),
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 / QgsProcessingUtils.featureCount(layerA, context)
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)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER,
context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE,
context)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point,
source.sourceCrs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
featureCount = source.featureCount()
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs(), context.transformContext())
da.setEllipsoid(context.project().ellipsoid())
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
# pick random feature
fid = random.randint(0, featureCount - 1)
f = next(
source.getFeatures(
request.setFilterFid(fid).setSubsetOfAttributes([])))
fGeom = f.geometry()
if fGeom.isMultipart():
lines = fGeom.asMultiPolyline()
# pick random line
lineId = random.randint(0, len(lines) - 1)
vertices = lines[lineId]
else:
vertices = fGeom.asPolyline()
# pick random segment
if len(vertices) == 2:
vid = 0
else:
vid = random.randint(0, len(vertices) - 2)
startPoint = vertices[vid]
endPoint = vertices[vid + 1]
length = da.measureLine(startPoint, endPoint)
dist = length * random.random()
if dist > minDistance:
d = dist / (length - dist)
rx = (startPoint.x() + d * endPoint.x()) / (1 + d)
ry = (startPoint.y() + d * endPoint.y()) / (1 + d)
# generate random point
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
if vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(
self.tr(
'Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.VECTOR))
fieldName = self.getParameterValue(self.FIELD)
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
strategy = self.getParameterValue(self.STRATEGY)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QGis.WKBPoint, layer.crs())
da = QgsDistanceArea()
features = vector.features(layer)
for current, f in enumerate(features):
fGeom = QgsGeometry(f.geometry())
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(f[fieldName]) if f[fieldName] else 0
else:
if f[fieldName]:
pointCount = int(round(f[fieldName] * da.measure(fGeom)))
else:
pointCount = 0
if strategy == 0 and pointCount == 0:
continue
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount > 0 else 1
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(fGeom) and \
vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
progress.setPercentage(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random '
'points. Maximum number of attempts exceeded.'))
progress.setPercentage(0)
del writer
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER,
context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE,
context)
bbox = source.sourceExtent()
sourceIndex = QgsSpatialIndex(source, feedback)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point,
source.sourceCrs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
ids = sourceIndex.intersects(geom.buffer(5, 5).boundingBox())
if len(ids) > 0 and \
vector.checkMinDistance(p, index, minDistance, points):
request = QgsFeatureRequest().setFilterFids(
ids).setSubsetOfAttributes([])
for f in source.getFeatures(request):
if feedback.isCanceled():
break
tmpGeom = f.geometry()
if geom.within(tmpGeom):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(
self.tr(
'Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def run(self):
"""Risk plugin for classified polygon hazard on land cover.
Counts area of land cover types exposed to hazard zones.
:returns: Impact layer
:rtype: Vector
"""
# Identify hazard and exposure layers
hazard = self.hazard.layer
exposure = self.exposure.layer
type_attr = self.exposure.keyword('field')
self.hazard_class_attribute = self.hazard.keyword('field')
hazard_value_to_class = {}
self.hazard_class_mapping = self.hazard.keyword('value_map')
for key, values in self.hazard_class_mapping.items():
for value in values:
hazard_value_to_class[value] = self.hazard_columns[key]
# prepare objects for re-projection of geometries
crs_wgs84 = QgsCoordinateReferenceSystem('EPSG:4326')
hazard_to_exposure = QgsCoordinateTransform(hazard.crs(),
exposure.crs())
wgs84_to_hazard = QgsCoordinateTransform(crs_wgs84, hazard.crs())
wgs84_to_exposure = QgsCoordinateTransform(crs_wgs84, exposure.crs())
extent = QgsRectangle(self.requested_extent[0],
self.requested_extent[1],
self.requested_extent[2],
self.requested_extent[3])
extent_hazard = wgs84_to_hazard.transformBoundingBox(extent)
extent_exposure = wgs84_to_exposure.transformBoundingBox(extent)
extent_exposure_geom = QgsGeometry.fromRect(extent_exposure)
# make spatial index of hazard
hazard_index = QgsSpatialIndex()
hazard_features = {}
for f in hazard.getFeatures(QgsFeatureRequest(extent_hazard)):
f.geometry().transform(hazard_to_exposure)
hazard_index.insertFeature(f)
hazard_features[f.id()] = QgsFeature(f)
# create impact layer
filename = unique_filename(suffix='.shp')
impact_fields = exposure.dataProvider().fields()
impact_fields.append(QgsField(self.target_field, QVariant.String))
writer = QgsVectorFileWriter(filename, 'utf-8', impact_fields,
QGis.WKBPolygon, exposure.crs())
# Iterate over all exposure polygons and calculate the impact.
_calculate_landcover_impact(exposure, extent_exposure,
extent_exposure_geom,
self.hazard_class_attribute,
hazard_features, hazard_index,
hazard_value_to_class, impact_fields,
writer)
del writer
impact_layer = QgsVectorLayer(filename, 'Impacted Land Cover', 'ogr')
if impact_layer.featureCount() == 0:
raise ZeroImpactException()
zone_field = None
if self.aggregator:
zone_field = self.aggregator.exposure_aggregation_field
# This is not the standard way to use mixins
# Martin preferred to call it directly - normally it is called with
# multiple inheritance. Thats ok but we need to monkey patch the
# notes function as it is not overloaded by this class
mixin = LandCoverReportMixin(
question=self.question,
impact_layer=impact_layer,
target_field=self.target_field,
ordered_columns=self.hazard_columns.values(),
affected_columns=self.affected_hazard_columns,
land_cover_field=type_attr,
zone_field=zone_field)
mixin.notes = self.notes
impact_data = mixin.generate_data()
# Define style for the impact layer
style_classes = [
dict(label=self.hazard_columns['low'],
value=self.hazard_columns['low'],
colour='#acffb6',
border_color='#000000',
transparency=0,
size=0.5),
dict(label=self.hazard_columns['medium'],
value=self.hazard_columns['medium'],
colour='#ffe691',
border_color='#000000',
transparency=0,
size=0.5),
dict(label=self.hazard_columns['high'],
value=self.hazard_columns['high'],
colour='#F31A1C',
border_color='#000000',
transparency=0,
size=0.5),
]
style_info = dict(target_field=self.target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
extra_keywords = {
'map_title': self.map_title(),
'target_field': self.target_field
}
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Create vector layer and return
impact_layer = Vector(data=impact_layer,
name=self.map_title(),
keywords=impact_layer_keywords,
style_info=style_info)
impact_layer.impact_data = impact_data
self._impact = impact_layer
return impact_layer
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
strategy = self.parameterAsEnum(parameters, self.STRATEGY, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE,
context)
expression = QgsExpression(
self.parameterAsString(parameters, self.EXPRESSION, context))
if expression.hasParserError():
raise ProcessingException(expression.parserErrorString())
expressionContext = self.createExpressionContext(parameters, context)
if not expression.prepare(expressionContext):
raise ProcessingException(
self.tr('Evaluation error: {0}').format(
expression.evalErrorString()))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point,
source.sourceCrs())
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs())
da.setEllipsoid(context.project().ellipsoid())
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(source.getFeatures()):
if feedback.isCanceled():
break
expressionContext.setFeature(f)
value = expression.evaluate(expressionContext)
if expression.hasEvalError():
feedback.pushInfo(
self.tr('Evaluation error for feature ID {}: {}').format(
f.id(), expression.evalErrorString()))
continue
fGeom = f.geometry()
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(value)
else:
pointCount = int(round(value * da.measureArea(fGeom)))
if pointCount == 0:
feedback.pushInfo(
"Skip feature {} as number of points for it is 0.")
continue
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount else 1
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPoint(p)
if geom.within(fGeom) and \
vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(
self.tr('Could not generate requested number of random '
'points. Maximum number of attempts exceeded.'))
feedback.setProgress(0)
return {self.OUTPUT: dest_id}
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 run(self):
"""Risk plugin for classified polygon hazard on polygon population.
Counts population in an area exposed to hazard zones and then
computes the proportion of each area that is affected.
The population in each area is then calculated as the proportion
of the original population to the affected area.
:returns: Impact layer
:rtype: Vector
"""
self.validate()
self.prepare()
self.provenance.append_step(
'Calculating Step',
'Impact function is calculating the impact.')
# Identify hazard and exposure layers
hazard = self.hazard.layer
exposure = self.exposure.layer
# prepare objects for re-projection of geometries
crs_wgs84 = QgsCoordinateReferenceSystem("EPSG:4326")
hazard_to_exposure = QgsCoordinateTransform(
hazard.crs(), exposure.crs())
wgs84_to_hazard = QgsCoordinateTransform(
crs_wgs84, hazard.crs())
wgs84_to_exposure = QgsCoordinateTransform(
crs_wgs84, exposure.crs())
extent = QgsRectangle(
self.requested_extent[0], self.requested_extent[1],
self.requested_extent[2], self.requested_extent[3])
extent_hazard = wgs84_to_hazard.transformBoundingBox(extent)
extent_exposure = wgs84_to_exposure.transformBoundingBox(extent)
extent_exposure_geom = QgsGeometry.fromRect(extent_exposure)
# make spatial index of hazard
hazard_index = QgsSpatialIndex()
hazard_features = {}
for feature in hazard.getFeatures(QgsFeatureRequest(extent_hazard)):
feature.geometry().transform(hazard_to_exposure)
hazard_index.insertFeature(feature)
hazard_features[feature.id()] = QgsFeature(feature)
# create impact layer
filename = unique_filename(suffix='.shp')
impact_fields = exposure.dataProvider().fields()
impact_fields.append(QgsField(self.target_field, QVariant.Int))
unaffected_fields = exposure.dataProvider().fields()
unaffected_fields.append(QgsField(self.target_field, QVariant.Int))
writer = QgsVectorFileWriter(
filename, "utf-8", impact_fields, QGis.WKBPolygon, exposure.crs())
# Evaluating the impact
self.evaluate_impact(
exposure,
extent_exposure,
extent_exposure_geom,
hazard_index,
hazard_features,
writer,
unaffected_fields,
impact_fields)
del writer
impact_layer = QgsVectorLayer(filename, "Impacted People", "ogr")
# Generate the report of affected populations in the areas
# To avoid Null
for value in self.all_areas_population.values():
if isinstance(value, QPyNullVariant):
value = 0
self.total_population += value
self.areas = self.all_areas_ids
self.affected_areas = self.all_affected_areas
self.areas_population = self.all_areas_population
# Calculating number of people affected
# This will help area report mixin to know how
# to calculate the all row values before other
# rows values in the report table
self.evaluate_affected_people()
impact_summary = self.html_report()
# Define style for the impact layer
transparent_color = QColor()
transparent_color.setAlpha(0)
# Retrieve the classification that is used by the hazard layer.
vector_hazard_classification = self.hazard.keyword(
'vector_hazard_classification')
# Get the dictionary that contains the definition of the classification
vector_hazard_classification = definition(vector_hazard_classification)
# Get the list classes in the classification
vector_hazard_classes = vector_hazard_classification['classes']
classes = self.hazard_class_mapping
classes_colours = {}
color_mapping = {
'wet': '#F31A1C',
'low': '#1EFC7C',
'medium': '#FFA500',
'high': '#F31A1C'
}
classes_values = {
'wet': 1,
'low': 1,
'medium': 2,
'high': 3
}
# Assigning colors
for vector_hazard_class in vector_hazard_classes:
key = vector_hazard_class['key']
if key in classes.keys() and key in color_mapping.keys():
classes_colours[key] = color_mapping[key]
# Define style info for output polygons showing population counts
style_classes = []
index = 0
for class_key, colour in classes_colours.items():
style_class = dict()
if class_key in classes.keys():
label = classes[class_key][0]
else:
continue
transparency = 0
style_class['label'] = label
style_class['value'] = classes_values[class_key]
style_class['colour'] = colour
style_class['transparency'] = transparency
style_classes.append(style_class)
index = index + 1
style_info = dict(
target_field=self.target_field,
style_classes=style_classes,
style_type='categorizedSymbol')
extra_keywords = {
'impact_summary': impact_summary,
'target_field': self.target_field,
'map_title': tr('Affected People'),
}
self.set_if_provenance()
impact_layer_keywords = self.generate_impact_keywords(extra_keywords)
# Create vector layer and return
impact_layer = Vector(
data=impact_layer,
name=tr('People affected by each hazard zone'),
keywords=impact_layer_keywords,
style_info=style_info)
self._impact = impact_layer
return impact_layer
