本文整理汇总了Python中qgis.core.QgsVectorLayer.addFeature方法的典型用法代码示例。如果您正苦于以下问题:Python QgsVectorLayer.addFeature方法的具体用法?Python QgsVectorLayer.addFeature怎么用?Python QgsVectorLayer.addFeature使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类qgis.core.QgsVectorLayer
的用法示例。
在下文中一共展示了QgsVectorLayer.addFeature方法的10个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __createMemoryLayer
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
def __createMemoryLayer(self, layer_name, gtype, geometries, attributes, fNames, fTypes):
"""
Create a memory layer from parameters
:param layer_name: name for the layer
:param gtype: geometry type of the layer
:param geometries: objects geometries
:param attributes: objects attributes
:param fNames: fields names
:param fTypes: fields types
"""
layerList = QgsMapLayerRegistry.instance().mapLayersByName(layer_name)
if layerList:
QgsMapLayerRegistry.instance().removeMapLayers([layerList[0].id()])
epsg = self.canvas().mapRenderer().destinationCrs().authid()
fieldsParam = ""
for i in range(len(fNames)):
fieldsParam += "&field=" + fNames[i] + ":" + fTypes[i]
layer = QgsVectorLayer(gtype + "?crs=" + epsg + fieldsParam + "&index=yes", layer_name, "memory")
QgsMapLayerRegistry.instance().addMapLayer(layer)
layer.startEditing()
for i in range(len(geometries)):
feature = QgsFeature()
feature.setGeometry(QgsGeometry().fromWkt(geometries[i]))
fields = layer.pendingFields()
feature.setFields(fields)
for j in range(len(fNames)):
feature.setAttribute(fNames[j], attributes[i][j])
layer.addFeature(feature)
layer.commitChanges()
示例2: getmap
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
def getmap(self):
if self.canvas:
settings = self.canvas.mapSettings()
layers = settings.layers()
if GPS.isConnected:
try:
gpslayer = QgsMapLayerRegistry.instance().mapLayersByName("__gps_layer")[0]
except IndexError:
gpslayer = QgsVectorLayer("Point", "__gps_layer", "memory")
symbol = QgsMarkerSymbolV2.createSimple({'name': 'circle', 'color': 'blue', "size": '5'})
gpslayer.rendererV2().setSymbol(symbol)
QgsMapLayerRegistry.instance().addMapLayer(gpslayer, False)
layers.append(gpslayer.id())
settings.setLayers(layers)
map_pos = QgsPoint(GPS.gpsinfo("longitude"), GPS.gpsinfo("latitude"))
# map_pos = QgsPoint(115.72589,-32.29597)
geom = QgsGeometry.fromPoint(map_pos)
feature = QgsFeature()
feature.setGeometry(geom)
gpslayer.startEditing()
gpslayer.addFeature(feature)
# gpslayer.commitChanges()
self.renderjob = QgsMapRendererParallelJob(settings)
self.renderjob.finished.connect(self.rendermap)
self.renderjob.start()
示例3: testNull
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
def testNull(self):
"""
Asserts that 0, '' and NULL are treated as different values on insert
"""
vl = QgsVectorLayer(self.dbconn + ' sslmode=disable key=\'gid\' table="qgis_test"."constraints" sql=', 'test1', 'postgres')
self.assertTrue(vl.isValid())
QgsProject.instance().addMapLayer(vl)
tg = QgsTransactionGroup()
tg.addLayer(vl)
vl.startEditing()
def onError(message):
"""We should not get here. If we do, fail and say why"""
self.assertFalse(True, message)
vl.raiseError.connect(onError)
f = QgsFeature(vl.fields())
f['gid'] = 100
f['val'] = 0
f['name'] = ''
self.assertTrue(vl.addFeature(f))
feature = next(vl.getFeatures('"gid" = 100'))
self.assertEqual(f['val'], feature['val'])
self.assertEqual(f['name'], feature['name'])
示例4: testEditSubsetString
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
def testEditSubsetString(self):
tmpfile = os.path.join(self.basetestpath, 'testEditSubsetString.gpkg')
ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbMultiPolygon)
lyr.CreateField(ogr.FieldDefn('foo', ogr.OFTString))
f = ogr.Feature(lyr.GetLayerDefn())
f['foo'] = 'bar'
lyr.CreateFeature(f)
f = None
f = ogr.Feature(lyr.GetLayerDefn())
f['foo'] = 'baz'
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer('{}|layerid=0'.format(tmpfile), 'test', 'ogr')
self.assertEqual(vl.dataProvider().featureCount(), 2)
# Test adding features
vl.setSubsetString("foo = 'baz'")
self.assertTrue(vl.startEditing())
feature = QgsFeature(vl.fields())
feature['foo'] = 'abc'
vl.addFeature(feature)
vl.commitChanges()
vl.setSubsetString(None)
self.assertEqual(vl.dataProvider().featureCount(), 3)
# Test deleting a feature
vl.setSubsetString("foo = 'baz'")
self.assertTrue(vl.startEditing())
vl.deleteFeature(1)
vl.commitChanges()
vl.setSubsetString(None)
self.assertEqual(vl.dataProvider().featureCount(), 2)
# Test editing a feature
vl.setSubsetString("foo = 'baz'")
self.assertTrue(vl.startEditing())
vl.changeAttributeValue(2, 1, 'xx')
vl.commitChanges()
vl.setSubsetString(None)
self.assertEqual(set((feat['foo'] for feat in vl.getFeatures())), set(['xx', 'abc']))
示例5: test_AddFeatureNullFid
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
def test_AddFeatureNullFid(self):
"""Test gpkg feature with NULL fid can be added"""
tmpfile = os.path.join(self.basetestpath, 'testGeopackageSplitFeatures.gpkg')
ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPolygon)
lyr.CreateField(ogr.FieldDefn('str_field', ogr.OFTString))
ds = None
layer = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=" + "test", 'test', u'ogr')
# Check that pk field has unique constraint
fields = layer.fields()
pkfield = fields.at(0)
self.assertTrue(pkfield.constraints().constraints() & QgsFieldConstraints.ConstraintUnique)
# Test add feature with default Fid (NULL)
layer.startEditing()
f = QgsFeature()
feat = QgsFeature(layer.fields())
feat.setGeometry(QgsGeometry.fromWkt('Polygon ((0 0, 0 1, 1 1, 1 0, 0 0))'))
feat.setAttribute(1, 'test_value')
layer.addFeature(feat)
self.assertTrue(layer.commitChanges())
self.assertEqual(layer.featureCount(), 1)
示例6: testEdit
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
def testEdit(self):
"""Test `with edit(layer):` code"""
ml = QgsVectorLayer("Point?crs=epsg:4236&field=id:integer&field=value:double",
"test_data", "memory")
# Data as list of x, y, id, value
self.assertTrue(ml.isValid())
fields = ml.fields()
# Check insert
with edit(ml):
feat = QgsFeature(fields)
feat['id'] = 1
feat['value'] = 0.9
self.assertTrue(ml.addFeature(feat))
self.assertEqual(next(ml.dataProvider().getFeatures())['value'], 0.9)
# Check update
with edit(ml):
f = next(ml.getFeatures())
f['value'] = 9.9
self.assertTrue(ml.updateFeature(f))
self.assertEqual(next(ml.dataProvider().getFeatures())['value'], 9.9)
# Check for rollBack after exceptions
with self.assertRaises(NameError):
with edit(ml):
f = next(ml.getFeatures())
f['value'] = 3.8
crashycrash() # NOQA
self.assertEqual(next(ml.dataProvider().getFeatures())['value'], 9.9)
self.assertEqual(next(ml.getFeatures())['value'], 9.9)
# Check for `as`
with edit(ml) as l:
f = next(l.getFeatures())
f['value'] = 10
self.assertTrue(l.updateFeature(f))
self.assertEqual(next(ml.dataProvider().getFeatures())['value'], 10)
# Check that we get a QgsEditError exception when the commit fails
with self.assertRaises(QgsEditError):
with edit(ml) as l:
l.rollBack()
示例7: on_btnRun_clicked
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
def on_btnRun_clicked(self):
if self.inputfile == '':
QMessageBox.critical(self,'Map Creator',
'Please specify input coordinate file.')
return
if self.outputfile == '':
QMessageBox.critical(self,'Map Creator',
'Please specify output shapefile.')
return
self.setCursor(Qt.WaitCursor)
#Open coordinate input file
f = open(self.inputfile, 'r')
lines = f.readlines()
f.close()
header = lines[0].split(',')[0]
totfeat = len(lines) - 1
lines.pop(0)
lines.reverse()
#Create vector layer
basename = os.path.basename(self.outputfile)
vlayer = QgsVectorLayer("Polygon", basename, "memory")
vprovider = vlayer.dataProvider()
fld = QgsField(header,QVariant.String)
flds = QgsFields()
flds.append(fld)
vprovider.addAttributes([fld])
vlayer.startEditing()
hull = []
for cnt, line in enumerate(lines):
line = line.rstrip().split(',')
numcoords = int((len(line) - 1) / 2)
hull[:] = []
geom = QgsGeometry()
feat = QgsFeature()
feat.setFields(flds)
for i in range(numcoords):
hull.append(QgsPoint(float(line[i*2+1]),float(line[i*2+2])))
geom = geom.fromMultiPoint(hull)
geom = geom.convexHull()
feat.setGeometry(geom)
feat.setAttribute(header,str(line[0]))
result = vlayer.addFeature(feat)
if not result:
self.setCursor(Qt.ArrowCursor)
QMessageBox.critical(self,'Map Creator', 'Processing error.')
return
self.ui.ProgressBar.setValue(float(cnt+1)/float(totfeat) * 100.0)
QApplication.processEvents()
vlayer.commitChanges()
vlayer.updateExtents()
#Write the output shapefile
if os.path.exists(self.outputfile):
QgsVectorFileWriter.deleteShapeFile(self.outputfile)
result = QgsVectorFileWriter.writeAsVectorFormat(vlayer,
self.outputfile,
'utf-8',
vlayer.crs())
if result != QgsVectorFileWriter.NoError:
QMessageBox.critical(self,'Map Creator','Error creating shapefile.')
else: #Ask to add shapfile to map
name = QFileInfo(self.outputfile).completeBaseName()
result = QMessageBox.question(self,'Map Creator',
'Add shapefile to map?',
QMessageBox.Yes,
QMessageBox.No)
if result == QMessageBox.Yes:
self.iface.addVectorLayer(self.outputfile, name, 'ogr')
self.setCursor(Qt.ArrowCursor)
示例8: AutoFieldsTests
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
class AutoFieldsTests( unittest.TestCase ):
@classmethod
def setUpClass( self ):
self.msg = MessageManager( 'debug', None )
self.msg.show( "Info! SetUp started", 'info', True )
#Initialize QGIS app
app = QgsApplication([], True)
QgsApplication.setPrefixPath("/usr", True)
QgsApplication.initQgis()
#Configure QSettings (organization and application name)
self.settings = QSettings("GeoTux", "QGIS-Plugin-Test")
#Load layer, add field f1, and add layer to Registry
baseDir = os.path.dirname( os.path.realpath( __file__ ) )
self.layerPath = os.path.join( baseDir, 'test_data', 'test_points.shp' )
self.layer = QgsVectorLayer( self.layerPath, 'puntos', 'ogr' )
self.layer.dataProvider().addAttributes([QgsField('f1', QVariant.Double)])
self.layer.updateFields()
QgsMapLayerRegistry.instance().addMapLayer( self.layer )
#Instantiate AutoFieldManager
self.autoFieldManager = AutoFieldManager( self.msg, None, '/AutoFieldsTest', 'GeoTux', 'QGIS-Plugin-Test' )
def readStoredSettings( self, layer, fieldName ):
""" Helper function to get a dictionary of stored QSettings for an AutoField """
dictTmpProperties = {}
autoFieldId = self.autoFieldManager.buildAutoFieldId( layer, fieldName )
self.settings.beginGroup('/AutoFieldsTest/data/' + autoFieldId)
dictTmpProperties['layer'] = self.settings.value( "layer", "", type=str )
dictTmpProperties['field'] = self.settings.value( "field", u"", type=unicode )
dictTmpProperties['expression'] = self.settings.value( "expression", u"", type=unicode )
dictTmpProperties['layer2'] = self.settings.value( "layer2", "", type=str )
dictTmpProperties['field2'] = self.settings.value( "field2", "", type=str )
dictTmpProperties['enabled'] = self.settings.value( "enabled", False, type=bool )
self.settings.endGroup()
return dictTmpProperties
def test01CreateEnabledAutoField( self ):
""" QSettings should be properly stored, AutoField should be enabled """
self.msg.show( "Info! Test 1 started", 'info', True )
self.autoFieldManager.createAutoField(
layer=self.layer,
fieldName=u'f1',
expression=u'$x'
)
dictTmpProperties = self.readStoredSettings( self.layer, u'f1' )
dictExpectedProperties = {
'layer':self.layerPath,
'field':u'f1',
'expression':u'$x',
'layer2':"",
'field2':"",
'enabled':True
}
self.assertEqual( dictTmpProperties, dictExpectedProperties )
def test02AvoidTwoAutoFieldsOnSameField( self ):
""" AutoField should not be created if another one already exists on the same field."""
self.msg.show( "Info! Test 2 started", 'info', True )
res = self.autoFieldManager.createAutoField(
layer=self.layer,
fieldName=u'f1',
expression=u'$y'
)
self.assertFalse( res )
def test03EditAutoFieldLayer( self ):
""" AutoField value should be updated if a feature is added.
Note: It cannot handle the case when writing directly to the provider,
as QGIS doesn't have a SIGNAL for that.
self.layer.dataProvider().addFeatures( [ tmpFeature ] )
"""
self.msg.show( "Info! Test 3 started", 'info', True )
tmpFeature = QgsFeature( self.layer.pendingFields() )
tmpFeature.setGeometry( QgsGeometry.fromPoint( QgsPoint(-74.4, 4.5) ) )
# Either 1:
self.layer.startEditing()
self.layer.addFeature( tmpFeature )
self.layer.commitChanges()
# Or 2:
#with edit( self.layer ):
# self.layer.addFeature( tmpFeature )
addedFeature = self.layer.getFeatures().next()
self.assertEquals( addedFeature['f1'], -74.4 )
#.........这里部分代码省略.........
示例9: mesh_canvas
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
#.........这里部分代码省略.........
laln_rect = self.Trs_laln.transform(my_rect)
x_min = laln_rect.xMinimum()
x_max = laln_rect.xMaximum()
y_min = laln_rect.yMinimum()
y_max = laln_rect.yMaximum()
Lx1d,Lx2d,Lx3d,Ly1d,Ly2d,Ly3d = self.res_mesh_index(y_min, x_min)
Rx1d,Rx2d,Rx3d,Uy1d,Uy2d,Uy3d = self.res_mesh_index(y_max, x_max)
x_range = x_max - x_min
y_range = y_max - y_min
return {"Lx1d":Lx1d,"Lx2d":Lx2d,"Lx3d":Lx3d,
"Rx1d":Rx1d,"Rx2d":Rx2d,"Rx3d":Rx3d,
"Ly1d":Ly1d,"Ly2d":Ly2d,"Ly3d":Ly3d,
"Uy1d":Uy1d,"Uy2d":Uy2d,"Uy3d":Uy3d,
"xRange":x_range,"yRange":y_range}
def draw_m1d(self):
x = self.e_mesh["Lx1d"] -1
while x <= self.e_mesh["Rx1d"] + 1:
y = self.e_mesh["Ly1d"]
while y <= self.e_mesh["Uy1d"]:
f = QgsFeature(self.meshPolyLayer.pendingFields())
f.setGeometry(QgsGeometry.fromPolygon(
[[QgsPoint(x+100,y/1.5),QgsPoint(x+100,(y+1)/1.5),
QgsPoint(x+101,(y+1)/1.5),QgsPoint(x+101,y/1.5)]]))
m1d_str = str(int(y)) + str(int(x))
f.setAttribute("meshC",m1d_str)
self.meshPolyLayer.addFeature(f)
y += 1
x += 1
def draw_m2d(self):
x = self.e_mesh["Lx1d"] + self.e_mesh["Lx2d"] / 8.0 - 1 / 8.0
while x <= self.e_mesh["Rx1d"] + self.e_mesh["Rx2d"] / 8.0 + 1 / 8.0:
x1d = math.floor(x)
x2d = math.floor((x-x1d)*8)
y = self.e_mesh["Ly1d"] + self.e_mesh["Ly2d"] / 8.0 - 1 / 8.0
while y <= self.e_mesh["Uy1d"] + self.e_mesh["Uy2d"] + 1 / 8.0:
y1d = math.floor(y)
y2d = math.floor((y-y1d)*8)
f = QgsFeature(self.meshPolyLayer.pendingFields())
f.setGeometry(QgsGeometry.fromPolygon(
[[QgsPoint(x+100,y/1.5),QgsPoint(x+100,(y+1/8.0)/1.5),
QgsPoint(x+100+1/8.0,(y+1/8.0)/1.5),QgsPoint(x+100+1/8.0,y/1.5)]]))
m1d_str = str(int(y1d)) + str(int(x1d))
m2d_str = str(int(y2d)) + str(int(x2d))
mesh_str = m1d_str + m2d_str
f.setAttribute("meshC",mesh_str)
self.meshPolyLayer.addFeature(f)
y += 1/8.0
x += 1/8.0
示例10: CsvLayer
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addFeature [as 别名]
class CsvLayer():
""" Pretend we are a data provider """
dirty = False
doing_attr_update = False
def __init__(self, csv_path):
""" Initialize the layer by reading the CSV file, creating a memory
layer, and adding records to it """
# Save the path to the file soe we can update it in response to edits
self.csv_path = csv_path
self.csv_file = open(csv_path, 'rb')
self.reader = csv.reader(self.csv_file)
self.header = self.reader.next()
logger(str(self.header))
# Get sample
sample = self.reader.next()
self.field_sample = dict(zip(self.header, sample))
logger("sample %s" % str(self.field_sample))
field_name_types = {}
# create dict of fieldname:type
for key in self.field_sample.keys():
if self.field_sample[key].isdigit():
field_type = 'integer'
else:
try:
float(self.field_sample[key])
field_type = 'real'
except ValueError:
field_type = 'string'
field_name_types[key] = field_type
logger(str(field_name_types))
# Build up the URI needed to create memory layer
self.uri = self.uri = "Point?crs=epsg:4326"
for fld in self.header:
self.uri += '&field={}:{}'.format(fld, field_name_types[fld])
logger(self.uri)
# Create the layer
self.lyr = QgsVectorLayer(self.uri, 'cities.csv', 'memory')
self.add_records()
# done with the csv file
self.csv_file.close()
# Make connections
self.lyr.editingStarted.connect(self.editing_started)
self.lyr.editingStopped.connect(self.editing_stopped)
self.lyr.committedAttributeValuesChanges.connect(self.attributes_changed)
self.lyr.committedFeaturesAdded.connect(self.features_added)
self.lyr.committedFeaturesRemoved.connect(self.features_removed)
self.lyr.geometryChanged.connect(self.geometry_changed)
# Add the layer the map
QgsMapLayerRegistry.instance().addMapLayer(self.lyr)
def add_records(self):
""" Add records to the memory layer by reading the CSV file """
# Return to beginning of csv file
self.csv_file.seek(0)
# Skip the header
self.reader.next()
self.lyr.startEditing()
for row in self.reader:
flds = dict(zip(self.header, row))
# logger("This row: %s" % flds)
feature = QgsFeature()
geometry = QgsGeometry.fromPoint(
QgsPoint(float(flds['X']), float(flds['Y'])))
feature.setGeometry(geometry)
# for key in flds:
# logger("setting attribute for |%s|" % key)
# feature.setAttribute(feature.fieldNameIndex(key), flds[key])
feature.setAttributes(row)
self.lyr.addFeature(feature, True)
self.lyr.commitChanges()
def editing_started(self):
""" Connect to the edit buffer so we can capture geometry and attribute
changes """
self.lyr.editBuffer().committedAttributeValuesChanges.connect(
self.attributes_changed)
def editing_stopped(self):
""" Update the CSV file if changes were committed """
if self.dirty:
logger("Updating the CSV")
features = self.lyr.getFeatures()
tempfile = NamedTemporaryFile(mode='w', delete=False)
writer = csv.writer(tempfile, delimiter=',')
# write the header
writer.writerow(self.header)
for feature in features:
row = []
for fld in self.header:
row.append(feature[feature.fieldNameIndex(fld)])
writer.writerow(row)
tempfile.close()
#.........这里部分代码省略.........