本文整理汇总了Python中qgis.core.QgsVectorLayer.pendingFields方法的典型用法代码示例。如果您正苦于以下问题:Python QgsVectorLayer.pendingFields方法的具体用法?Python QgsVectorLayer.pendingFields怎么用?Python QgsVectorLayer.pendingFields使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类qgis.core.QgsVectorLayer
的用法示例。
在下文中一共展示了QgsVectorLayer.pendingFields方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: createReferencingLayer
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def createReferencingLayer():
layer = QgsVectorLayer("Point?field=fldtxt:string&field=foreignkey:integer", "referencinglayer", "memory")
pr = layer.dataProvider()
f1 = QgsFeature()
f1.setFields(layer.pendingFields())
f1.setAttributes(["test1", 123])
f1.setGeometry(QgsGeometry.fromPoint(QgsPoint(100, 200)))
f2 = QgsFeature()
f2.setFields(layer.pendingFields())
f2.setAttributes(["test2", 123])
f2.setGeometry(QgsGeometry.fromPoint(QgsPoint(101, 201)))
assert pr.addFeatures([f1, f2])
return layer
示例2: add_flooded_field
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def add_flooded_field(self, shapefile_path):
"""Create the layer from the local shp adding the flooded field.
.. versionadded:: 3.3
Use this method to add a calculated field to a shapefile. The shapefile
should have a field called 'count' containing the number of flood
reports for the field. The field values will be set to 0 if the count
field is < 1, otherwise it will be set to 1.
:param shapefile_path: Path to the shapefile that will have the flooded
field added.
:type shapefile_path: basestring
:return: A vector layer with the flooded field added.
:rtype: QgsVectorLayer
"""
layer = QgsVectorLayer(
shapefile_path, self.tr('Jakarta Floods'), 'ogr')
# Add a calculated field indicating if a poly is flooded or not
# from PyQt4.QtCore import QVariant
layer.startEditing()
# Add field with integer from 0 to 4 which represents the flood
# class. Its the same as 'state' field except that is being treated
# as a string.
# This is used for cartography
flood_class_field = QgsField('floodclass', QVariant.Int)
layer.dataProvider().addAttributes([flood_class_field])
layer.commitChanges()
layer.startEditing()
flood_class_idx = layer.fieldNameIndex('floodclass')
flood_class_expression = QgsExpression('to_int(state)')
flood_class_expression.prepare(layer.pendingFields())
# Add field with boolean flag to say if the area is flooded
# This is used by the impact function
flooded_field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([flooded_field])
layer.commitChanges()
layer.startEditing()
flooded_idx = layer.fieldNameIndex('flooded')
flood_flag_expression = QgsExpression('state > 0')
flood_flag_expression.prepare(layer.pendingFields())
for feature in layer.getFeatures():
feature[flood_class_idx] = flood_class_expression.evaluate(feature)
feature[flooded_idx] = flood_flag_expression.evaluate(feature)
layer.updateFeature(feature)
layer.commitChanges()
return layer
示例3: createReferencingLayer
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def createReferencingLayer():
layer = QgsVectorLayer("Point?field=fldtxt:string&field=foreignkey:integer",
"referencinglayer", "memory")
pr = layer.dataProvider()
f1 = QgsFeature()
f1.setFields(layer.pendingFields())
f1.setAttributes(["test1", 123])
f2 = QgsFeature()
f2.setFields(layer.pendingFields())
f2.setAttributes(["test2", 123])
f3 = QgsFeature()
f3.setFields(layer.pendingFields())
f3.setAttributes(["foobar'bar", 124])
assert pr.addFeatures([f1, f2, f3])
return layer
示例4: createReferencedLayer
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def createReferencedLayer():
layer = QgsVectorLayer(
"Point?field=x:string&field=y:integer&field=z:integer",
"referencedlayer", "memory")
pr = layer.dataProvider()
f1 = QgsFeature()
f1.setFields(layer.pendingFields())
f1.setAttributes(["foo", 123, 321])
f2 = QgsFeature()
f2.setFields(layer.pendingFields())
f2.setAttributes(["bar", 456, 654])
f3 = QgsFeature()
f3.setFields(layer.pendingFields())
f3.setAttributes(["foobar'bar", 789, 554])
assert pr.addFeatures([f1, f2, f3])
return layer
示例5: add_flooded_field
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def add_flooded_field(self, shapefile_path):
"""Create the layer from the local shp adding the flooded field.
.. versionadded:: 3.3
Use this method to add a calculated field to a shapefile. The shapefile
should have a field called 'count' containing the number of flood
reports for the field. The field values will be set to 0 if the count
field is < 1, otherwise it will be set to 1.
:param shapefile_path: Path to the shapefile that will have the flooded
field added.
:type shapefile_path: basestring
:return: A vector layer with the flooded field added.
:rtype: QgsVectorLayer
"""
layer = QgsVectorLayer(
shapefile_path, self.tr('Jakarta Floods'), 'ogr')
# Add a calculated field indicating if a poly is flooded or not
# from PyQt4.QtCore import QVariant
layer.startEditing()
field = QgsField('flooded', QVariant.Int)
layer.dataProvider().addAttributes([field])
layer.commitChanges()
layer.startEditing()
idx = layer.fieldNameIndex('flooded')
expression = QgsExpression('state > 0')
expression.prepare(layer.pendingFields())
for feature in layer.getFeatures():
feature[idx] = expression.evaluate(feature)
layer.updateFeature(feature)
layer.commitChanges()
return layer
示例6: __createMemoryLayer
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [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()
示例7: processAlgorithm
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def processAlgorithm(self, progress):
layers = self.getParameterValue(self.INPUT_DATASOURCES)
query = self.getParameterValue(self.INPUT_QUERY)
uid_field = self.getParameterValue(self.INPUT_UID_FIELD)
geometry_field = self.getParameterValue(self.INPUT_GEOMETRY_FIELD)
geometry_type = self.getParameterValue(self.INPUT_GEOMETRY_TYPE)
geometry_crs = self.getParameterValue(self.INPUT_GEOMETRY_CRS)
df = QgsVirtualLayerDefinition()
layerIdx = 1
if layers:
for layerSource in layers.split(';'):
layer = dataobjects.getObjectFromUri(layerSource)
if layer:
df.addSource('input{}'.format(layerIdx), layer.id())
if query == '':
raise GeoAlgorithmExecutionException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
else:
df.setQuery(query)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NullGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs:
crs = QgsCoordinateReferenceSystem(geometry_crs)
if crs.isValid():
df.setGeometrySrid(crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise GeoAlgorithmExecutionException(vLayer.dataProvider().error().message())
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
vLayer.pendingFields().toList(),
# Create a point layer (without any points) if 'no geometry' is chosen
vLayer.wkbType() if geometry_type != 1 else 1,
vLayer.crs())
features = vector.features(vLayer)
total = 100.0 / len(features)
outFeat = QgsFeature()
for current, inFeat in enumerate(features):
outFeat.setAttributes(inFeat.attributes())
if geometry_type != 1:
outFeat.setGeometry(inFeat.geometry())
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
示例8: loadData
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def loadData(self, resultFile, chunkId):
""" Load data to the map """
if isMimeTypeVector(self.mimeType, True) != None:
# Memory layer:
geometryTypes = ["Point","LineString","Polygon","Unknown", "NoGeometry"]
vlayer = QgsVectorLayer(resultFile, "chunk", "ogr")
if self.__bFirstChunk:
self.__bFirstChunk = False
self.__geometryType = geometryTypes[vlayer.geometryType()]
self.__bGeomMulti = vlayer.wkbType() in [4,5,6,11,12,13]
self.__memoryLayer = QgsVectorLayer(self.__geometryType,"Streamed data","memory")
self.__memoryLayer.dataProvider().addAttributes(vlayer.pendingFields().values())
self.__memoryLayer.updateFieldMap()
provider = vlayer.dataProvider()
allAttrs = provider.attributeIndexes()
vlayer.select(allAttrs)
# Visualize temporal geometries during the downloading process
# Don't add temporal geometries if last chunk
if self.DEBUG: print "Loaded chunkId:",chunkId
res = self.__memoryLayer.dataProvider().addFeatures( [feat for feat in vlayer] )
self.__deliveredChunks += 1
if not self.allChunksDelivered():
inFeat = QgsFeature()
inGeom = QgsGeometry()
self.createTempGeometry(chunkId, self.__geometryType)
while provider.nextFeature( inFeat ):
inGeom = inFeat.geometry()
featList = self.extractAsSingle(self.__geometryType, inGeom) if self.__bGeomMulti else [inGeom]
for geom in featList:
self.addTempGeometry(chunkId, self.__geometryType, geom)
else:
self.finishLoading()
# Raster data
elif isMimeTypeRaster(self.mimeType, True) != None:
# We can directly attach the new layer
if self.__bFirstChunk:
self.__bFirstChunk = False
self.__groupIndex = self.__legend.addGroup("Streamed-raster")
rLayer = QgsRasterLayer(resultFile, "raster_"+str(chunkId))
bLoaded = QgsMapLayerRegistry.instance().addMapLayer(rLayer)
self.stretchRaster(rLayer)
self.__legend.moveLayer(rLayer, self.__groupIndex + 1)
self.__deliveredChunks += 1
if self.allChunksDelivered():
self.finishLoading()
示例9: test_ExpressionFieldNestedCircular
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def test_ExpressionFieldNestedCircular(self):
""" test circular virtual field definitions """
myShpFile = os.path.join(TEST_DATA_DIR, 'points.shp')
layer = QgsVectorLayer(myShpFile, 'Points', 'ogr')
self.assertTrue(layer.isValid())
cnt = layer.pendingFields().count() # NOQA
idx = layer.addExpressionField('"exp3"*2', QgsField('exp1', QVariant.LongLong)) # NOQA
idx = layer.addExpressionField('"exp1"-1', QgsField('exp2', QVariant.LongLong)) # NOQA
idx = layer.addExpressionField('"exp2"*3', QgsField('exp3', QVariant.LongLong)) # NOQA
# really just testing that this doesn't hang/crash... there's no good result here!
fet = next(layer.getFeatures(QgsFeatureRequest().setSubsetOfAttributes(['exp2'], layer.fields())))
self.assertEqual(fet['Class'], NULL)
示例10: processAlgorithm
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def processAlgorithm(self, progress):
self.progress = progress
self.progress.setPercentage(0)
file_path = self.getParameterValue(self.FILE)
# Creating the dict for columns
white_list_values = {}
for layer in self.LAYERS:
value = self.getParameterValue(self.WHITE_LIST[layer])
# Delete space and tabs in OSM keys
# Processing return a 'None' value as unicode
value = re.sub('\s', '', value)
if value == '' or value == 'None':
value = None
if value:
if value != ',':
white_list_values[layer] = value.split(',')
else:
white_list_values[layer] = ','
else:
white_list_values[layer] = None
# Call the OSM Parser and connect signals
parser = OsmParser(file_path, self.LAYERS, white_list_values)
parser.signalText.connect(self.set_info)
parser.signalPercentage.connect(self.set_percentage)
# Start to parse
layers = parser.parse()
layers_outputs = {}
for key, values in layers.iteritems():
layer = QgsVectorLayer(values['geojsonFile'], "test", "ogr")
output_parameter = self.getOutputValue(self.OUTPUT_LAYERS[key])
layers_outputs[key] = QgsVectorFileWriter(
output_parameter,
'UTF-8',
layer.pendingFields(),
values['geomType'],
layer.crs())
for feature in layer.getFeatures():
layers_outputs[key].addFeature(feature)
示例11: rotation_test
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def rotation_test(self):
# We will create a polygon layer with a rotated rectangle.
# Then we will make it the object layer for the atlas,
# rotate the map and test that the bounding rectangle
# is smaller than the bounds without rotation.
polygonLayer = QgsVectorLayer('Polygon', 'test_polygon', 'memory')
poly = QgsFeature(polygonLayer.pendingFields())
points = [(10, 15), (15, 10), (45, 40), (40, 45)]
poly.setGeometry(QgsGeometry.fromPolygon([[QgsPointXY(x[0], x[1]) for x in points]]))
polygonLayer.dataProvider().addFeatures([poly])
QgsProject.instance().addMapLayer(polygonLayer)
# Recreating the composer locally
composition = QgsComposition(QgsProject.instance())
composition.setPaperSize(297, 210)
# the atlas map
atlasMap = QgsComposerMap(composition, 20, 20, 130, 130)
atlasMap.setFrameEnabled(True)
atlasMap.setLayers([polygonLayer])
atlasMap.setNewExtent(QgsRectangle(0, 0, 100, 50))
composition.addComposerMap(atlasMap)
# the atlas
atlas = composition.atlasComposition()
atlas.setCoverageLayer(polygonLayer)
atlas.setEnabled(True)
composition.setAtlasMode(QgsComposition.ExportAtlas)
atlasMap.setAtlasDriven(True)
atlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
atlasMap.setAtlasMargin(0.0)
# Testing
atlasMap.setMapRotation(0.0)
atlas.firstFeature()
nonRotatedExtent = QgsRectangle(atlasMap.currentMapExtent())
atlasMap.setMapRotation(45.0)
atlas.firstFeature()
rotatedExtent = QgsRectangle(atlasMap.currentMapExtent())
assert rotatedExtent.width() < nonRotatedExtent.width() * 0.9
assert rotatedExtent.height() < nonRotatedExtent.height() * 0.9
QgsProject.instance().removeMapLayer(polygonLayer)
示例12: storyDescriptionLinkClicked
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def storyDescriptionLinkClicked(self, url):
url = url.toString()
if url == "search":
dlg = SearchDialog()
dlg.exec_()
if dlg.mapstory is not None:
story = Story.storyFromNumberId(dlg.mapstory)
if story is None:
QMessageBox.warning(iface.mainWindow(), "MapStory", "Cannot get MapStory data.\nCheck that the provided ID is correct.")
else:
self.updateCurrentStory(story)
elif url == "download":
outDir = QFileDialog.getExistingDirectory(self,
self.tr("Select output directory"),
"."
)
if not outDir:
return
QDir().mkpath(outDir)
settings = QSettings()
systemEncoding = settings.value('/UI/encoding', 'System')
startProgressBar(len(self.story.storyLayers()), "Download layers for off-line use:")
for i, layer in enumerate(self.story.storyLayers()):
filename = os.path.join(outDir, layer.name() + ".shp")
uri = "%s?srsname=%s&typename=geonode:%s&version=1.0.0&request=GetFeature&service=WFS" % (layer.wfsUrl(), layer.crs(), layer.name())
qgslayer = QgsVectorLayer(uri, layer.name(), "WFS")
writer = QgsVectorFileWriter(filename, systemEncoding,
qgslayer.pendingFields(),
qgslayer.dataProvider().geometryType(),
qgslayer.crs())
for feat in qgslayer.getFeatures():
writer.addFeature(feat)
del writer
fieldname = self._getTimeField(qgslayer)
if fieldname is not None:
filename = os.path.join(outDir, layer.name() + ".timefield")
with open(filename, "w") as f:
f.write(fieldname)
setProgress(i+1)
closeProgressBar()
iface.messageBar().pushMessage("MapStory", "Layers have been correctly saved as QGIS project.", level=QgsMessageBar.INFO, duration=3)
示例13: f
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
def f():
crs = iface.mapCanvas().mapRenderer().destinationCrs()
uri = "%s?srsname=%s&typename=geonode:%s&version=1.0.0&request=GetFeature&service=WFS" % (url, crs.authid(), name)
qgslayer = QgsVectorLayer(uri, name, "WFS")
if not qgslayer.isValid():
raise Exception ("Layer at %s is not a valid layer" % uri)
fieldname = self._getTimeField(qgslayer)
if fieldname is None:
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
else:
memlayer = QgsVectorLayer("%s?crs=%s" % (GEOM_TYPE_MAP[qgslayer.wkbType()], crs.authid()), name, "memory")
memlayer.startEditing()
for field in qgslayer.pendingFields():
memlayer.addAttribute(field)
for feat in qgslayer.getFeatures():
memlayer.addFeatures([feat])
memlayer.commitChanges()
QgsMapLayerRegistry.instance().addMapLayers([memlayer])
memlayer.setSelectedFeatures([])
addWfsAnimation(memlayer, fieldname)
示例14: run
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
#.........这里部分代码省略.........
c_stop_name = 0
c_stop_lat = 0
c_stop_lon = 0
counter = 0
text_file = os.path.join(GTFSDir, StopsFile)
#text_file = 'C:/UWGIS/Geog569/Data/Test/stops.txt'
##
EPSG_code = 4326
EPSG_code_WM = 3857
StopsShapefilePath = os.path.join(GTFSDir, StopsShapefileName + ".shp")
StopsShapefilePathWM = os.path.join(GTFSDir, StopsShapefileName + "WM.shp")
###export_shp = "C:/UWGIS/Geog569/Data/Test/stoptest1.shp"
spatialReference = osgeo.osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be
spatialReference.ImportFromEPSG(int(EPSG_code)) #here we define this reference to be the EPSG code
driver = osgeo.ogr.GetDriverByName('ESRI Shapefile') # will select the driver for our shp-file creation.
shapeData = driver.CreateDataSource(StopsShapefilePath) #so there we will store our data
layer = shapeData.CreateLayer('layer', spatialReference, osgeo.ogr.wkbPoint) #this will create a corresponding layer for our data with given spatial information.
layer_defn = layer.GetLayerDefn() # gets parameters of the current shapefile
index = 0
spatialReferenceWM = osgeo.osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be
spatialReferenceWM.ImportFromEPSG(int(EPSG_code_WM)) #here we define this reference to be the EPSG code
driver = osgeo.ogr.GetDriverByName('ESRI Shapefile') # will select the driver for our shp-file creation.
shapeDataWM = driver.CreateDataSource(StopsShapefilePathWM) #so there we will store our data
layerWM = shapeDataWM.CreateLayer('layerWM', spatialReferenceWM, osgeo.ogr.wkbPoint) #this will create a corresponding layer for our data with given spatial information.
layerWM_defn = layerWM.GetLayerDefn() # gets parameters of the current shapefile
index = 0
###print "two"
fieldnames = []
with open(text_file, 'r') as f:
first_line = f.readline()
fl = first_line.split(",")
for fn in fl:
fieldnames.append(fn)
for f in fl:
#print f
if f == "stop_id":
c_stop_id = counter
if f == "stop_name":
c_stop_name = counter
if f == "stop_lat":
c_stop_lat = counter
print "c_stop_lat"
print c_stop_lat
if f == "stop_lon":
c_stop_lon = counter
new_field = ogr.FieldDefn(f, ogr.OFTString) #we will create a new field with the content of our header
print "three"
layer.CreateField(new_field)
##layerWM.CreateField(new_field)
counter = counter + 1
print "four"
stop_layer = QgsVectorLayer(StopsShapefilePath, "stop_layer", "ogr")
stop_layer.startEditing()
#stop_layer = iface.addVectorLayer(StopsShapefilePath, "stop_layer", "ogr")
if not stop_layer:
print "Layer failed to load!"
##for line in text_file:
with open(text_file, 'r') as f:
lines = f.readlines()
#print "len(line)"
#print len(line)
#l = str(line).split(",")
#print line
for line in lines:
#print line
l = str(line).split(",")
#print l[0]
#print "c_stop_lat, c_stop_lon"
#print c_stop_lat, c_stop_lon
if l[c_stop_id] != "stop_id":
stop_id = l[c_stop_id]
if l[c_stop_name] != "stop_name":
stop_name = l[c_stop_name]
if l[c_stop_lat] != "stop_lat":
stop_lat = float(l[c_stop_lat])
if l[c_stop_lon] != "stop_lon":
stop_lon = float(l[c_stop_lon])
##DICT_stop_lon [l[c_stop_id]] = l[c_stop_lon]
##print(stop_lat, stop_lon)
if type(stop_lat) == float:
if type (stop_lon) == float:
print(stop_lat, stop_lon)
caps = stop_layer.dataProvider().capabilities()
caps_string = stop_layer.dataProvider().capabilitiesString()
print caps_string
# Check if a particular capability is supported:
##caps & QgsVectorDataProvider.DeleteFeatures
# Print 2 if DeleteFeatures is supported
#caps = layer.dataProvider().capabilities()
if caps & QgsVectorDataProvider.AddFeatures:
feat = QgsFeature(stop_layer.pendingFields())
#feat.setAttributes([0, 'hello'])
#feat.setAttributes(['stop_id', str(stop_id)])
#feat.setAttributes([0, 'hello'])
# Or set a single attribute by key or by index:
#feat.setAttribute('stop_id', stop_id)
feat.setAttribute(2, 'hello')
feat.setGeometry(QgsGeometry.fromPoint(QgsPoint(float(stop_lon), float(stop_lat))))
(res, outFeats) = stop_layer.dataProvider().addFeatures([feat])
top_layer.commitChanges()
开发者ID:MikeStrongGIS,项目名称:FindTransitAccessibleTrailheads,代码行数:104,代码来源:zzTransitAccessibleTrailheads+-+Copy.py
示例15: InputNetworkTabManager
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import pendingFields [as 别名]
#.........这里部分代码省略.........
iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL)
return
# show layer in the canvas
QgsMapLayerRegistry.instance().addMapLayer(self.roadLayer)
# now layer is available
self.roadLayerId = self.roadLayer.id()
else:
message = self.tr("Input network does not exist: %s" % inputLayerFile)
iface.messageBar().pushMessage(message, QgsMessageBar.WARNING)
self.roadLayer = None
self.roadLayerId = None
# avoid emitting signal in case of reset of indexes
try:
# to avoid add multiple listener, remove previous listener
self.gui.inputLayer_lineEdit.returnPressed.disconnect(self.saveTabOnProject)
self.gui.roadType_CBox.currentIndexChanged.disconnect(self.saveTabOnProject)
self.gui.roadLenght_CBox.currentIndexChanged.disconnect(self.saveTabOnProject)
self.gui.roadGradient_CBox.currentIndexChanged.disconnect(self.saveTabOnProject)
except (Exception) as ex:
pass
# set text of loaded layer
if self.roadLayer:
self.gui.inputLayer_lineEdit.setText(self.roadLayer.publicSource())
else:
self.gui.inputLayer_lineEdit.setText(inputLayerFile)
# now populare combo boxes with layer colums
if self.roadLayer:
fieldNames = sorted([field.name() for field in self.roadLayer.pendingFields().toList()])
else:
fieldNames = []
unknownIndex = -1
self.gui.roadType_CBox.clear()
self.gui.roadLenght_CBox.clear()
self.gui.roadGradient_CBox.clear()
self.gui.roadType_CBox.addItems(fieldNames)
self.gui.roadLenght_CBox.addItems(fieldNames)
self.gui.roadGradient_CBox.addItems(fieldNames)
# select the combobox item as in the project file... if not available then "Please select"
index = self.gui.roadType_CBox.findText(columnRoadType)
self.gui.roadType_CBox.setCurrentIndex( index if index >= 0 else unknownIndex )
index = self.gui.roadLenght_CBox.findText(columnRoadLenght)
self.gui.roadLenght_CBox.setCurrentIndex( index if index >= 0 else unknownIndex )
index = self.gui.roadGradient_CBox.findText(columnRoadSlope)
self.gui.roadGradient_CBox.setCurrentIndex( index if index >= 0 else unknownIndex )
# add all modification events to notify project modification
self.gui.inputLayer_lineEdit.returnPressed.connect(self.saveTabOnProject)
self.gui.roadType_CBox.currentIndexChanged.connect(self.saveTabOnProject)
self.gui.roadLenght_CBox.currentIndexChanged.connect(self.saveTabOnProject)
self.gui.roadGradient_CBox.currentIndexChanged.connect(self.saveTabOnProject)
#
# set parameters for vechicle count/speed columns
#