本文整理汇总了Python中qgis.core.QgsFields类的典型用法代码示例。如果您正苦于以下问题:Python QgsFields类的具体用法?Python QgsFields怎么用?Python QgsFields使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了QgsFields类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: processAlgorithm
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}
示例2: testProxyFeatureSink
def testProxyFeatureSink(self):
fields = QgsFields()
fields.append(QgsField('fldtxt', QVariant.String))
fields.append(QgsField('fldint', QVariant.Int))
store = QgsFeatureStore(fields, QgsCoordinateReferenceSystem())
proxy = QgsProxyFeatureSink(store)
self.assertEqual(proxy.destinationSink(), store)
self.assertEqual(len(store), 0)
f = QgsFeature()
f.setAttributes(["test", 123])
f.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(100, 200)))
proxy.addFeature(f)
self.assertEqual(len(store), 1)
self.assertEqual(store.features()[0]['fldtxt'], 'test')
f2 = QgsFeature()
f2.setAttributes(["test2", 457])
f2.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(200, 200)))
f3 = QgsFeature()
f3.setAttributes(["test3", 888])
f3.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(300, 200)))
proxy.addFeatures([f2, f3])
self.assertEqual(len(store), 3)
self.assertEqual(store.features()[1]['fldtxt'], 'test2')
self.assertEqual(store.features()[2]['fldtxt'], 'test3')
示例3: processAlgorithm
def processAlgorithm(self, parameters, context, feedback):
spacing = self.parameterAsDouble(parameters, self.SPACING, context)
inset = self.parameterAsDouble(parameters, self.INSET, context)
randomize = self.parameterAsBool(parameters, self.RANDOMIZE, context)
isSpacing = self.parameterAsBool(parameters, self.IS_SPACING, context)
crs = self.parameterAsCrs(parameters, self.CRS, context)
extent = self.parameterAsExtent(parameters, self.EXTENT, context, crs)
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))
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(extent_geom.constGet())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if feedback.isCanceled():
break
if randomize:
geom = QgsGeometry().fromPointXY(QgsPointXY(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPointXY(QgsPointXY(x, y))
if extent_engine.intersects(geom.constGet()):
f.setAttribute('id', count)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
return {self.OUTPUT: dest_id}
示例4: testExportLayerToExistingDatabase
def testExportLayerToExistingDatabase(self):
fields = QgsFields()
fields.append(QgsField('f1', QVariant.Int))
tmpfile = os.path.join(self.basetestpath, 'testCreateNewGeopackage.gpkg')
options = {}
options['update'] = True
options['driverName'] = 'GPKG'
options['layerName'] = 'table1'
exporter = QgsVectorLayerExporter(tmpfile, "ogr", fields, QgsWkbTypes.Polygon, QgsCoordinateReferenceSystem(3111), False, options)
self.assertFalse(exporter.errorCode(),
'unexpected export error {}: {}'.format(exporter.errorCode(), exporter.errorMessage()))
options['layerName'] = 'table2'
exporter = QgsVectorLayerExporter(tmpfile, "ogr", fields, QgsWkbTypes.Point, QgsCoordinateReferenceSystem(3113), False, options)
self.assertFalse(exporter.errorCode(),
'unexpected export error {} : {}'.format(exporter.errorCode(), exporter.errorMessage()))
del exporter
# make sure layers exist
lyr = QgsVectorLayer('{}|layername=table1'.format(tmpfile), "lyr1", "ogr")
self.assertTrue(lyr.isValid())
self.assertEqual(lyr.crs().authid(), 'EPSG:3111')
self.assertEqual(lyr.wkbType(), QgsWkbTypes.Polygon)
lyr2 = QgsVectorLayer('{}|layername=table2'.format(tmpfile), "lyr2", "ogr")
self.assertTrue(lyr2.isValid())
self.assertEqual(lyr2.crs().authid(), 'EPSG:3113')
self.assertEqual(lyr2.wkbType(), QgsWkbTypes.Point)
示例5: processAlgorithm
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
field_name = self.parameterAsString(parameters, self.FIELD_NAME, context)
values = source.uniqueValues(source.fields().lookupField(field_name))
fields = QgsFields()
field = source.fields()[source.fields().lookupField(field_name)]
field.setName('VALUES')
fields.append(field)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.NoGeometry, QgsCoordinateReferenceSystem())
results = {}
if sink:
for value in values:
if feedback.isCanceled():
break
f = QgsFeature()
f.setAttributes([value])
sink.addFeature(f, QgsFeatureSink.FastInsert)
results[self.OUTPUT] = dest_id
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT_HTML_FILE, context)
if output_file:
self.createHTML(output_file, values)
results[self.OUTPUT_HTML_FILE] = output_file
results[self.TOTAL_VALUES] = len(values)
results[self.UNIQUE_VALUES] = ';'.join([str(v) for v in
values])
return results
示例6: create_points_at
def create_points_at(startpoint, endpoint, distance, geom, fid, force, divide):
"""Creating Points at coordinates along the line
"""
length = geom.length()
def distance_fn():
if divide > 0:
return length / divide
else:
import random
return distance * random.uniform(0.5,2.5)
feats = []
if endpoint > 0:
length = endpoint
# set the first point at startpoint
point = geom.interpolate(startpoint)
field_id = QgsField(name="id", type=QVariant.Int)
field = QgsField(name="dist", type=QVariant.Double)
fields = QgsFields()
fields.append(field_id)
fields.append(field)
feature = QgsFeature(fields)
feature['dist'] = startpoint
feature['id'] = fid
feature.setGeometry(point)
feats.append(feature)
current_distance = 0
while startpoint + current_distance <= length:
step = distance_fn()
# Get a point along the line at the current distance
point = geom.interpolate(startpoint + current_distance)
# Create a new QgsFeature and assign it the new geometry
feature = QgsFeature(fields)
feature['dist'] = (startpoint + step)
feature['id'] = fid
feature.setGeometry(point)
feats.append(feature)
# Increase the distance
current_distance = current_distance + step
# set the last point at endpoint if wanted
if force is True:
end = geom.length()
point = geom.interpolate(end)
feature = QgsFeature(fields)
feature['dist'] = end
feature['id'] = fid
feature.setGeometry(point)
feats.append(feature)
return feats
示例7: save2PointShape
def save2PointShape(shapePath, geodata, attribName,
attribData, label, spatialRef):
"""
:param label:
:param shapePath: Pfad wo Shapefile agespeichert wird
:param geodata: Koordinaten der Punkte
:param attribName: Attributname (Feldname) von zusätzlichen Werten
:param attribData: Werte für Attribute
:param spatialRef: Räumliche Referenz
"""
# define fields for feature attributes. A QgsFields object is needed
fields = QgsFields()
fields.append(QgsField("StuetzenNr", QVariant.String))
fields.append(QgsField(attribName, QVariant.Int))
writer = QgsVectorFileWriter(shapePath, "UTF8", fields, QgsWkbTypes.PointZ,
spatialRef, "ESRI Shapefile")
if writer.hasError() != QgsVectorFileWriter.NoError:
# TODO
raise Exception("Vector Writer")
for idx, (coords, attrib) in enumerate(zip(geodata, attribData)):
feature = QgsFeature()
feature.setFields(fields)
# TODO: Nicht 3D weil Methode fromPoint() nicht existiert. Wird evtl. in der Zukunft implementiert
feature.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(coords[0], coords[1])))
feature.setId(idx)
feature.setAttribute("StuetzenNr", label[idx])
feature.setAttribute(attribName, attrib)
writer.addFeature(feature)
del feature
# delete the writer to flush features to disk
del writer
示例8: processAlgorithm
def processAlgorithm(self, feedback):
extent = str(self.getParameterValue(self.EXTENT)).split(',')
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
extent = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(extent_geom.geometry())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(QgsPoint(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPoint(QgsPoint(x, y))
if extent_engine.intersects(geom.geometry()):
f.setAttribute('id', count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
del writer
示例9: populate_catalogue_layer
def populate_catalogue_layer(self, catalogue):
"""
Populate the catalogue vector layer with data got from `catalogue`
:param catalogue:
a :class:`hmtk.seismicity.catalogue.Catalogue` instance
"""
vl = self.catalogue_layer
pr = vl.dataProvider()
vl.startEditing()
# Set field types (the schema of the vector layer)
fields = []
mock_attributes = ["_magnitude"]
for key in catalogue.data.keys() + mock_attributes:
if key in mock_attributes:
key_norm = key[1:]
else:
key_norm = key
if isinstance(key_norm, numpy.ndarray):
fields.append(QgsField(key, QVariant.Double))
else:
fields.append(QgsField(key, QVariant.String))
pr.addAttributes(fields)
qgs_fields = QgsFields()
for f in fields:
qgs_fields.append(f)
# Create the features
features = []
for i in range(catalogue.get_number_events()):
fet = QgsFeature()
fet.setFields(qgs_fields)
x = catalogue.data['longitude'][i]
y = catalogue.data['latitude'][i]
fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(x, y)))
for key in catalogue.data:
event_data = catalogue.data[key]
if len(event_data):
if isinstance(catalogue.data[key], numpy.ndarray):
fet[key] = float(event_data[i])
else:
fet[key] = str(event_data[i])
fet['_magnitude'] = fet['magnitude'] ** 2
features.append(fet)
pr.addFeatures(features)
vl.commitChanges()
self.event_feature_ids = dict([
(f['eventID'], f.id()) for f in vl.getFeatures()])
# Set the canvas extent to avoid projection problems and to
# pan to the loaded events
vl.updateExtents()
示例10: testLegendKeysWhileCounting
def testLegendKeysWhileCounting(self):
# test determining legend keys for features, while counting features
fields = QgsFields()
fields.append(QgsField('x'))
# setup renderer
renderer = QgsCategorizedSymbolRenderer()
renderer.setClassAttribute('x')
symbol_a = createMarkerSymbol()
symbol_a.setColor(QColor(255, 0, 0))
renderer.addCategory(QgsRendererCategory('a', symbol_a, 'a'))
symbol_b = createMarkerSymbol()
symbol_b.setColor(QColor(0, 255, 0))
renderer.addCategory(QgsRendererCategory('b', symbol_b, 'b'))
symbol_c = createMarkerSymbol()
symbol_c.setColor(QColor(0, 0, 255))
renderer.addCategory(QgsRendererCategory('c', symbol_c, 'c', False))
symbol_d = createMarkerSymbol()
symbol_d.setColor(QColor(255, 0, 255))
renderer.addCategory(QgsRendererCategory(['d', 'e'], symbol_d, 'de'))
# add default category
default_symbol = createMarkerSymbol()
default_symbol.setColor(QColor(255, 255, 255))
renderer.addCategory(QgsRendererCategory('', default_symbol, 'default'))
context = QgsRenderContext()
context.setRendererScale(0) # simulate counting
renderer.startRender(context, fields)
f = QgsFeature(fields)
f.setAttributes(['a'])
keys = renderer.legendKeysForFeature(f, context)
self.assertEqual(keys, {'0'})
f.setAttributes(['b'])
keys = renderer.legendKeysForFeature(f, context)
self.assertEqual(keys, {'1'})
# hidden category, should still return keys
f.setAttributes(['c'])
keys = renderer.legendKeysForFeature(f, context)
self.assertEqual(keys, {'2'})
# list
f.setAttributes(['d'])
keys = renderer.legendKeysForFeature(f, context)
self.assertEqual(keys, {'3'})
f.setAttributes(['e'])
keys = renderer.legendKeysForFeature(f, context)
self.assertEqual(keys, {'3'})
# no matching category
f.setAttributes(['xxx'])
keys = renderer.legendKeysForFeature(f, context)
self.assertFalse(keys)
renderer.stopRender(context)
示例11: processAlgorithm
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
field_names = self.parameterAsFields(parameters, self.FIELDS, context)
fields = QgsFields()
field_indices = []
for field_name in field_names:
field_index = source.fields().lookupField(field_name)
if field_index < 0:
feedback.reportError(self.tr('Invalid field name {}').format(field_name))
continue
field = source.fields()[field_index]
fields.append(field)
field_indices.append(field_index)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.NoGeometry, QgsCoordinateReferenceSystem())
results = {}
values = set()
if len(field_indices) == 1:
# one field, can use provider optimised method
values = tuple([v] for v in source.uniqueValues(field_indices[0]))
else:
# have to scan whole table
# TODO - add this support to QgsVectorDataProvider so we can run it on
# the backend
request = QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes(field_indices)
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(source.getFeatures(request, QgsProcessingFeatureSource.FlagSkipGeometryValidityChecks)):
if feedback.isCanceled():
break
value = tuple(f.attribute(i) for i in field_indices)
values.add(value)
feedback.setProgress(int(current * total))
if sink:
for value in values:
if feedback.isCanceled():
break
f = QgsFeature()
f.setAttributes([attr for attr in value])
sink.addFeature(f, QgsFeatureSink.FastInsert)
results[self.OUTPUT] = dest_id
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT_HTML_FILE, context)
if output_file:
self.createHTML(output_file, values)
results[self.OUTPUT_HTML_FILE] = output_file
results[self.TOTAL_VALUES] = len(values)
results[self.UNIQUE_VALUES] = ';'.join([','.join([str(attr) for attr in v]) for v in
values])
return results
示例12: test_MatchesTrueForFields
def test_MatchesTrueForFields(self):
feature = QgsFeature()
fields = QgsFields()
fields.append(QgsField("testfield", QVariant.Int))
feature.setFields(fields, True)
feature["testfield"] = 20
style = QgsConditionalStyle('"testfield" = @value')
assert style.matches(20, feature)
示例13: testOriginalSymbolForFeature
def testOriginalSymbolForFeature(self):
# test renderer with features
fields = QgsFields()
fields.append(QgsField('x'))
# setup renderer
renderer = QgsCategorizedSymbolRenderer()
renderer.setClassAttribute('x')
symbol_a = createMarkerSymbol()
symbol_a.setColor(QColor(255, 0, 0))
renderer.addCategory(QgsRendererCategory('a', symbol_a, 'a'))
symbol_b = createMarkerSymbol()
symbol_b.setColor(QColor(0, 255, 0))
renderer.addCategory(QgsRendererCategory('b', symbol_b, 'b'))
symbol_c = createMarkerSymbol()
symbol_c.setColor(QColor(0, 0, 255))
renderer.addCategory(QgsRendererCategory('c', symbol_c, 'c', False))
symbol_d = createMarkerSymbol()
symbol_d.setColor(QColor(255, 0, 255))
renderer.addCategory(QgsRendererCategory(['d', 'e'], symbol_d, 'de'))
# add default category
default_symbol = createMarkerSymbol()
default_symbol.setColor(QColor(255, 255, 255))
renderer.addCategory(QgsRendererCategory('', default_symbol, 'default'))
context = QgsRenderContext()
renderer.startRender(context, fields)
f = QgsFeature(fields)
f.setAttributes(['a'])
symbol = renderer.originalSymbolForFeature(f, context)
self.assertEqual(symbol.color(), QColor(255, 0, 0))
f.setAttributes(['b'])
symbol = renderer.originalSymbolForFeature(f, context)
self.assertEqual(symbol.color(), QColor(0, 255, 0))
# list
f.setAttributes(['d'])
symbol = renderer.originalSymbolForFeature(f, context)
self.assertEqual(symbol.color(), QColor(255, 0, 255))
f.setAttributes(['e'])
symbol = renderer.originalSymbolForFeature(f, context)
self.assertEqual(symbol.color(), QColor(255, 0, 255))
# hidden category
f.setAttributes(['c'])
symbol = renderer.originalSymbolForFeature(f, context)
self.assertIsNone(symbol)
# no matching category
f.setAttributes(['xxx'])
symbol = renderer.originalSymbolForFeature(f, context)
self.assertEqual(symbol.color(), QColor(255, 255, 255)) # default symbol
renderer.stopRender(context)
示例14: processAlgorithm
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
extent = self.parameterAsExtent(parameters, self.TARGET_AREA, context)
target_crs = self.parameterAsCrs(parameters, self.TARGET_AREA_CRS, context)
target_geom = QgsGeometry.fromRect(extent)
fields = QgsFields()
fields.append(QgsField('auth_id', QVariant.String, '', 20))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.NoGeometry, QgsCoordinateReferenceSystem())
# make intersection tests nice and fast
engine = QgsGeometry.createGeometryEngine(target_geom.constGet())
engine.prepareGeometry()
layer_bounds = QgsGeometry.fromRect(source.sourceExtent())
crses_to_check = QgsCoordinateReferenceSystem.validSrsIds()
total = 100.0 / len(crses_to_check)
found_results = 0
transform_context = QgsCoordinateTransformContext()
for current, srs_id in enumerate(crses_to_check):
if feedback.isCanceled():
break
candidate_crs = QgsCoordinateReferenceSystem.fromSrsId(srs_id)
if not candidate_crs.isValid():
continue
transform_candidate = QgsCoordinateTransform(candidate_crs, target_crs, transform_context)
transformed_bounds = QgsGeometry(layer_bounds)
try:
if not transformed_bounds.transform(transform_candidate) == 0:
continue
except:
continue
try:
if engine.intersects(transformed_bounds.constGet()):
feedback.pushInfo(self.tr('Found candidate CRS: {}').format(candidate_crs.authid()))
f = QgsFeature(fields)
f.setAttributes([candidate_crs.authid()])
sink.addFeature(f, QgsFeatureSink.FastInsert)
found_results += 1
except:
continue
feedback.setProgress(int(current * total))
if found_results == 0:
feedback.reportError(self.tr('No matching projections found'))
return {self.OUTPUT: dest_id}
示例15: processAlgorithm
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