本文整理汇总了Python中qgis.core.QgsGeometry类的典型用法代码示例。如果您正苦于以下问题:Python QgsGeometry类的具体用法?Python QgsGeometry怎么用?Python QgsGeometry使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了QgsGeometry类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: regularMatrix
def regularMatrix(self, writer, provider1, provider2, index1, index2, nearest, distArea, sindex, progressBar):
inFeat = QgsFeature()
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
first = True
start = 15.00
add = 85.00 / provider1.featureCount()
fit1 = provider1.getFeatures()
while fit1.nextFeature(inFeat):
inGeom = inFeat.geometry()
inID = inFeat.attributes()[index1]
if first:
featList = sindex.nearestNeighbor(inGeom.asPoint(), nearest)
first = False
data = ["ID"]
for i in featList:
provider2.getFeatures(QgsFeatureRequest().setFilterFid(int(i)).setSubsetOfAttributes([index2])).nextFeature(outFeat)
data.append(unicode(outFeat.attributes()[index2]))
writer.writerow(data)
data = [unicode(inID)]
for j in featList:
provider2.getFeatures(QgsFeatureRequest().setFilterFid(int(j))).nextFeature(outFeat)
outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(), outGeom.asPoint())
data.append(unicode(float(dist)))
writer.writerow(data)
start = start + add
progressBar.setValue(start)
del writer
示例2: setUpClass
def setUpClass(cls):
"""Run before all tests"""
# Register the provider
r = QgsProviderRegistry.instance()
metadata = QgsProviderMetadata(PyProvider.providerKey(), PyProvider.description(), PyProvider.createProvider)
assert r.registerProvider(metadata)
assert r.providerMetadata(PyProvider.providerKey()) == metadata
# Create test layer
cls.vl = cls.createLayer()
assert (cls.vl.isValid())
cls.source = cls.vl.dataProvider()
# poly layer
cls.poly_vl = QgsVectorLayer('Polygon?crs=epsg:4326&field=pk:integer&key=pk',
'test', 'pythonprovider')
assert (cls.poly_vl.isValid())
cls.poly_provider = cls.poly_vl.dataProvider()
f1 = QgsFeature()
f1.setAttributes([1])
f1.setGeometry(QgsGeometry.fromWkt('Polygon ((-69.03664108 81.35818902, -69.09237722 80.24346619, -73.718477 80.1319939, -73.718477 76.28620011, -74.88893598 76.34193625, -74.83319983 81.35818902, -69.03664108 81.35818902))'))
f2 = QgsFeature()
f2.setAttributes([2])
f2.setGeometry(QgsGeometry.fromWkt('Polygon ((-67.58750139 81.1909806, -66.30557012 81.24671674, -66.30557012 76.89929767, -67.58750139 76.89929767, -67.58750139 81.1909806))'))
f3 = QgsFeature()
f3.setAttributes([3])
f3.setGeometry(QgsGeometry.fromWkt('Polygon ((-68.36780737 75.78457483, -67.53176524 72.60761475, -68.64648808 73.66660144, -70.20710006 72.9420316, -68.36780737 75.78457483))'))
f4 = QgsFeature()
f4.setAttributes([4])
cls.poly_provider.addFeatures([f1, f2, f3, f4])
示例3: testNoSliverPolygons
def testNoSliverPolygons(self):
# create a layer with some polygons that will be used as a source for "avoid intersections"
l = QgsVectorLayer('MultiPolygon', 'test_layer', 'memory')
assert l.isValid()
QgsProject.instance().addMapLayer(l)
QgsProject.instance().writeEntry("Digitizing", "/AvoidIntersectionsList", [l.id()])
features = []
for i, wkt in enumerate(feat_wkt):
f = QgsFeature(i + 1)
f.setGeometry(QgsGeometry.fromWkt(wkt))
features.append(f)
l.dataProvider().addFeatures(features)
assert l.pendingFeatureCount() == 7
# create a geometry and remove its intersections with other geometries
g = QgsGeometry.fromWkt(newg_wkt)
assert g.avoidIntersections() == 0
# the resulting multi-polygon must have exactly three parts
# (in QGIS 2.0 it has one more tiny part that appears at the border between two of the original polygons)
mpg = g.asMultiPolygon()
assert len(mpg) == 3
示例4: 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')
示例5: testDeleteMultipleFeatures
def testDeleteMultipleFeatures(self):
# test deleting multiple features from an edit buffer
# make a layer with two features
layer = createEmptyLayer()
self.assertTrue(layer.startEditing())
# add two features
f1 = QgsFeature(layer.fields(), 1)
f1.setGeometry(QgsGeometry.fromPoint(QgsPointXY(1, 2)))
f1.setAttributes(["test", 123])
self.assertTrue(layer.addFeature(f1))
f2 = QgsFeature(layer.fields(), 2)
f2.setGeometry(QgsGeometry.fromPoint(QgsPointXY(2, 4)))
f2.setAttributes(["test2", 246])
self.assertTrue(layer.addFeature(f2))
layer.commitChanges()
layer.startEditing()
self.assertEqual(layer.editBuffer().deletedFeatureIds(), [])
self.assertFalse(layer.editBuffer().isFeatureDeleted(1))
self.assertFalse(layer.editBuffer().isFeatureDeleted(2))
# delete features
layer.deleteFeatures([1, 2])
# test contents of buffer
self.assertEqual(set(layer.editBuffer().deletedFeatureIds()), set([1, 2]))
self.assertTrue(layer.editBuffer().isFeatureDeleted(1))
self.assertTrue(layer.editBuffer().isFeatureDeleted(2))
示例6: testPartNum
def testPartNum(self):
# test geometry_part_num variable
s = QgsLineSymbol()
s.deleteSymbolLayer(0)
sym_layer = QgsGeometryGeneratorSymbolLayer.create({'geometryModifier': 'segments_to_lines($geometry)'})
sym_layer.setSymbolType(QgsSymbol.Line)
s.appendSymbolLayer(sym_layer)
marker_line = QgsMarkerLineSymbolLayer(False)
marker_line.setPlacement(QgsMarkerLineSymbolLayer.FirstVertex)
f = QgsFontUtils.getStandardTestFont('Bold', 24)
marker = QgsFontMarkerSymbolLayer(f.family(), 'x', 24, QColor(255, 255, 0))
marker.setDataDefinedProperty(QgsSymbolLayer.PropertyCharacter, QgsProperty.fromExpression('@geometry_part_num'))
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
marker_line.setSubSymbol(marker_symbol)
marker_line.setAverageAngleLength(0)
line_symbol = QgsLineSymbol()
line_symbol.changeSymbolLayer(0, marker_line)
sym_layer.setSubSymbol(line_symbol)
# rendering test
g = QgsGeometry.fromWkt('LineString(0 0, 10 0, 10 10, 0 10)')
rendered_image = self.renderGeometry(s, g, buffer=4)
assert self.imageCheck('part_num_variable', 'part_num_variable', rendered_image)
marker.setDataDefinedProperty(QgsSymbolLayer.PropertyCharacter,
QgsProperty.fromExpression('@geometry_part_count'))
# rendering test
g = QgsGeometry.fromWkt('LineString(0 0, 10 0, 10 10, 0 10)')
rendered_image = self.renderGeometry(s, g, buffer=4)
assert self.imageCheck('part_count_variable', 'part_count_variable', rendered_image)
示例7: 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}
示例8: _rectangleGridLine
def _rectangleGridLine(self, writer, width, height, originX, originY,
hSpacing, vSpacing):
ft = QgsFeature()
columns = int(math.floor(float(width) / hSpacing))
rows = int(math.floor(float(height) / vSpacing))
# Longitude lines
for col in xrange(0, columns + 1):
polyline = []
x = originX + (col * hSpacing)
for row in xrange(0, rows + 1):
y = originY + (row * vSpacing)
polyline.append(QgsPoint(x, y))
ft.setGeometry(QgsGeometry.fromPolyline(polyline))
ft.setAttributes([x, originY, x, originY + (rows * vSpacing)])
writer.addFeature(ft)
# Latitude lines
for row in xrange(0, rows + 1):
polyline = []
y = originY + (row * vSpacing)
for col in xrange(0, columns + 1):
x = originX + (col * hSpacing)
polyline.append(QgsPoint(x, y))
ft.setGeometry(QgsGeometry.fromPolyline(polyline))
ft.setAttributes([originX, y, originX + (col * hSpacing), y])
writer.addFeature(ft)
示例9: processAlgorithm
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
tolerance = self.getParameterValue(self.TOLERANCE)
pointsBefore = 0
pointsAfter = 0
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.pendingFields().toList(), layer.wkbType(), layer.crs())
features = vector.features(layer)
total = 100.0 / len(features)
for current, f in enumerate(features):
featGeometry = QgsGeometry(f.geometry())
attrs = f.attributes()
pointsBefore += self.geomVertexCount(featGeometry)
newGeometry = featGeometry.simplify(tolerance)
pointsAfter += self.geomVertexCount(newGeometry)
feature = QgsFeature()
feature.setGeometry(newGeometry)
feature.setAttributes(attrs)
writer.addFeature(feature)
progress.setPercentage(int(current * total))
del writer
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Simplify: Input geometries have been simplified from %s to %s points' % (pointsBefore, pointsAfter)))
示例10: diamonds
def diamonds(self, writer, features, width, height, rotation):
ft = QgsFeature()
xOffset = width / 2.0
yOffset = height / 2.0
if rotation is not None:
phi = rotation * math.pi / 180
for current, feat in enumerate(features):
point = feat.geometry().asPoint()
x = point.x()
y = point.y()
points = [(0.0, -yOffset), (-xOffset, 0.0), (0.0, yOffset), (xOffset, 0.0)]
polygon = [[QgsPoint(i[0] * math.cos(phi) + i[1] * math.sin(phi) + x,
-i[0] * math.sin(phi) + i[1] * math.cos(phi) + y) for i in points]]
ft.setGeometry(QgsGeometry.fromPolygon(polygon))
ft.setAttributes(feat.attributes())
writer.addFeature(ft)
else:
for current, feat in enumerate(features):
point = feat.geometry().asPoint()
x = point.x()
y = point.y()
points = [(0.0, -yOffset), (-xOffset, 0.0), (0.0, yOffset), (xOffset, 0.0)]
polygon = [[QgsPoint(i[0] + x, i[1] + y) for i in points]]
ft.setGeometry(QgsGeometry.fromPolygon(polygon))
ft.setAttributes(feat.attributes())
writer.addFeature(ft)
示例11: ovals
def ovals(self, writer, features, width, height, rotation, segments):
ft = QgsFeature()
xOffset = width / 2.0
yOffset = height / 2.0
if rotation is not None:
phi = rotation * math.pi / 180
for current, feat in enumerate(features):
point = feat.geometry().asPoint()
x = point.x()
y = point.y()
points = []
for t in [(2 * math.pi) / segments * i for i in range(segments)]:
points.append((xOffset * math.cos(t), yOffset * math.sin(t)))
polygon = [[QgsPoint(i[0] * math.cos(phi) + i[1] * math.sin(phi) + x,
-i[0] * math.sin(phi) + i[1] * math.cos(phi) + y) for i in points]]
ft.setGeometry(QgsGeometry.fromPolygon(polygon))
ft.setAttributes(feat.attributes())
writer.addFeature(ft)
else:
for current, feat in enumerate(features):
point = feat.geometry().asPoint()
x = point.x()
y = point.y()
points = []
for t in [(2 * math.pi) / segments * i for i in range(segments)]:
points.append((xOffset * math.cos(t), yOffset * math.sin(t)))
polygon = [[QgsPoint(i[0] + x, i[1] + y) for i in points]]
ft.setGeometry(QgsGeometry.fromPolygon(polygon))
ft.setAttributes(feat.attributes())
writer.addFeature(ft)
示例12: processAlgorithm
def processAlgorithm(self, parameters, context, feedback):
layerA = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(Difference.INPUT), context)
layerB = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(Difference.OVERLAY), context)
geomType = QgsWkbTypes.multiType(layerA.wkbType())
writer = self.getOutputFromName(
Difference.OUTPUT).getVectorWriter(layerA.fields(), geomType, layerA.crs(), context)
outFeat = QgsFeature()
index = QgsProcessingUtils.createSpatialIndex(layerB, context)
selectionA = QgsProcessingUtils.getFeatures(layerA, context)
total = 100.0 / layerA.featureCount() if layerA.featureCount() else 0
for current, inFeatA in enumerate(selectionA):
geom = inFeatA.geometry()
diff_geom = QgsGeometry(geom)
attrs = inFeatA.attributes()
intersections = index.intersects(geom.boundingBox())
request = QgsFeatureRequest().setFilterFids(intersections).setSubsetOfAttributes([])
for inFeatB in layerB.getFeatures(request):
tmpGeom = inFeatB.geometry()
if diff_geom.intersects(tmpGeom):
diff_geom = QgsGeometry(diff_geom.difference(tmpGeom))
try:
outFeat.setGeometry(diff_geom)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
QgsMessageLog.logMessage(self.tr('Feature geometry error: One or more output features ignored due to invalid geometry.'), self.tr('Processing'), QgsMessageLog.WARNING)
continue
feedback.setProgress(int(current * total))
del writer
示例13: test_snappointstogrid
def test_snappointstogrid(self):
"""Check that this runs correctly"""
polygon_layer = self._make_layer('Polygon')
f1 = QgsFeature(polygon_layer.fields())
f1.setAttributes([1])
f1.setGeometry(QgsGeometry.fromWkt('POLYGON((1.2 1.2, 1.2 2.2, 2.2 2.2, 2.2 1.2, 1.2 1.2))'))
f2 = QgsFeature(polygon_layer.fields())
f2.setAttributes([2])
f2.setGeometry(QgsGeometry.fromWkt('POLYGON((1.1 1.1, 1.1 2.1, 2.1 2.1, 2.1 1.1, 1.1 1.1))'))
self.assertTrue(f2.isValid())
self.assertTrue(polygon_layer.startEditing())
self.assertTrue(polygon_layer.addFeatures([f1, f2]))
self.assertEqual(polygon_layer.featureCount(), 2)
polygon_layer.commitChanges()
self.assertEqual(polygon_layer.featureCount(), 2)
QgsProject.instance().addMapLayers([polygon_layer])
polygon_layer.selectByIds([next(polygon_layer.getFeatures()).id()])
self.assertEqual(polygon_layer.selectedFeatureCount(), 1)
old_features, new_features = self._alg_tester(
'native:snappointstogrid',
polygon_layer,
{
'HSPACING': 0.5,
'VSPACING': 0.5,
}
)
g = [f.geometry() for f in new_features][0]
self.assertEqual(g.asWkt(), 'Polygon ((1 1, 1 2, 2 2, 2 1, 1 1))')
# Check selected
self.assertEqual(polygon_layer.selectedFeatureIds(), [1])
示例14: linearMatrix
def linearMatrix(self, writer, provider1, provider2, index1, index2, nearest, distArea, matType, sindex, progressBar):
inFeat = QgsFeature()
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
start = 15.00
add = 85.00 / provider1.featureCount()
fit1 = provider1.getFeatures()
while fit1.nextFeature(inFeat):
inGeom = inFeat.geometry()
inID = inFeat.attributes()[index1]
featList = sindex.nearestNeighbor(inGeom.asPoint(), nearest)
distList = []
vari = 0.00
for i in featList:
provider2.getFeatures(QgsFeatureRequest().setFilterFid(int(i)).setSubsetOfAttributes([index2])).nextFeature(outFeat)
outID = outFeat.attributes()[index2]
outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(), outGeom.asPoint())
if dist > 0:
if matType == "Linear":
writer.writerow([unicode(inID), unicode(outID), unicode(dist)])
else:
distList.append(float(dist))
if matType == "Summary":
mean = sum(distList) / len(distList)
for i in distList:
vari = vari + ((i - mean) * (i - mean))
vari = sqrt(vari / len(distList))
writer.writerow([unicode(inID), unicode(mean), unicode(vari), unicode(min(distList)), unicode(max(distList))])
start = start + add
progressBar.setValue(start)
del writer
示例15: densifyGeometry
def densifyGeometry(self, geometry, pointsNumber, isPolygon):
output = []
if isPolygon:
if geometry.isMultipart():
polygons = geometry.asMultiPolygon()
for poly in polygons:
p = []
for ring in poly:
p.append(self.densify(ring, pointsNumber))
output.append(p)
return QgsGeometry.fromMultiPolygon(output)
else:
rings = geometry.asPolygon()
for ring in rings:
output.append(self.densify(ring, pointsNumber))
return QgsGeometry.fromPolygon(output)
else:
if geometry.isMultipart():
lines = geometry.asMultiPolyline()
for points in lines:
output.append(self.densify(points, pointsNumber))
return QgsGeometry.fromMultiPolyline(output)
else:
points = geometry.asPolyline()
output = self.densify(points, pointsNumber)
return QgsGeometry.fromPolyline(output)