本文整理汇总了Python中qgis.core.QgsVectorLayer.addAttribute方法的典型用法代码示例。如果您正苦于以下问题:Python QgsVectorLayer.addAttribute方法的具体用法?Python QgsVectorLayer.addAttribute怎么用?Python QgsVectorLayer.addAttribute使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类qgis.core.QgsVectorLayer
的用法示例。
在下文中一共展示了QgsVectorLayer.addAttribute方法的12个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: testFieldsWithSpecialCharacters
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
def testFieldsWithSpecialCharacters(self):
ml = QgsVectorLayer("Point?srid=EPSG:4326&field=123:int", "mem_with_nontext_fieldnames", "memory")
self.assertEqual(ml.isValid(), True)
QgsProject.instance().addMapLayer(ml)
ml.startEditing()
self.assertTrue(ml.addAttribute(QgsField('abc:123', QVariant.String)))
self.assertTrue(ml.addAttribute(QgsField('map', QVariant.String))) # matches QGIS expression function name
f1 = QgsFeature(ml.fields())
f1.setGeometry(QgsGeometry.fromWkt('POINT(0 0)'))
f1.setAttributes([1, 'a', 'b'])
f2 = QgsFeature(ml.fields())
f2.setGeometry(QgsGeometry.fromWkt('POINT(1 1)'))
f2.setAttributes([2, 'c', 'd'])
ml.addFeatures([f1, f2])
ml.commitChanges()
vl = QgsVectorLayer("?query=select * from mem_with_nontext_fieldnames", "vl", "virtual")
self.assertEqual(vl.isValid(), True)
self.assertEqual(vl.fields().at(0).name(), '123')
self.assertEqual(vl.fields().at(1).name(), 'abc:123')
self.assertEqual(vl.featureCount(), 2)
features = [f for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression('"abc:123"=\'c\''))]
self.assertEqual(len(features), 1)
self.assertEqual(features[0].attributes(), [2, 'c', 'd'])
features = [f for f in vl.getFeatures(QgsFeatureRequest().setFilterExpression('"map"=\'b\''))]
self.assertEqual(len(features), 1)
self.assertEqual(features[0].attributes(), [1, 'a', 'b'])
vl2 = QgsVectorLayer("?query=select * from mem_with_nontext_fieldnames where \"abc:123\"='c'", "vl", "virtual")
self.assertEqual(vl2.isValid(), True)
self.assertEqual(vl2.fields().at(0).name(), '123')
self.assertEqual(vl2.fields().at(1).name(), 'abc:123')
self.assertEqual(vl2.featureCount(), 1)
features = [f for f in vl2.getFeatures()]
self.assertEqual(len(features), 1)
self.assertEqual(features[0].attributes(), [2, 'c', 'd'])
vl3 = QgsVectorLayer("?query=select * from mem_with_nontext_fieldnames where \"map\"='b'", "vl", "virtual")
self.assertEqual(vl3.isValid(), True)
self.assertEqual(vl3.fields().at(0).name(), '123')
self.assertEqual(vl3.fields().at(1).name(), 'abc:123')
self.assertEqual(vl3.featureCount(), 1)
features = [f for f in vl3.getFeatures()]
self.assertEqual(len(features), 1)
self.assertEqual(features[0].attributes(), [1, 'a', 'b'])
QgsProject.instance().removeMapLayer(ml)
示例2: create_layer
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
def create_layer(self, parameters, name, is_memory, dest_crs, layer_style=None):
save_as = parameters.file_path
file_format = parameters.file_format
# save paramaters
serialized = base64.b64encode(parameters.serialize(with_style=False, with_geometry=False))
# save geometry
layer = QgsVectorLayer("MultiPolygon?crs=%s" % dest_crs.authid(), name, "memory")
pr = layer.dataProvider()
layer.startEditing()
layer.addAttribute(QgsField("params", QVariant.String))
fet1 = QgsFeature(0)
fet1.setFields(layer.fields())
fet1.setAttribute("params", str(serialized)[2:-1])
fet1.setGeometry(parameters.geometry)
pr.addFeatures([fet1])
layer.commitChanges()
# copy layer style
if layer_style is not None:
self.set_layer_style(layer, layer_style)
if is_memory:
return layer
if os.path.isfile(save_as):
# delete first if already exists
if save_as.endswith(".shp"):
QgsVectorFileWriter.deleteShapeFile(save_as)
else:
os.unlink(save_as)
# create the disk layer
QgsMessageLog.logMessage("Mask saving '{}' as {}".format(save_as, file_format),
'Extensions')
error = QgsVectorFileWriter.writeAsVectorFormat(layer, save_as, "System", dest_crs,
file_format)
if error == 0:
nlayer = QgsVectorLayer(save_as, name, "ogr")
if not nlayer.dataProvider().isValid():
return None
if not nlayer.hasGeometryType():
return None
# force CRS
nlayer.setCrs(dest_crs)
# copy layer style
layer_style = self.get_layer_style(layer)
self.set_layer_style(nlayer, layer_style)
return nlayer
else:
raise RuntimeError(error)
return None
示例3: add_flooded_field
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [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 qgis.PyQt.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.addAttribute(flood_class_field)
layer.commitChanges()
layer.startEditing()
flood_class_idx = layer.fields().lookupField('floodclass')
flood_class_expression = QgsExpression('to_int(state)')
context = QgsExpressionContext()
context.setFields(layer.fields())
flood_class_expression.prepare(context)
# 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.fields().lookupField('flooded')
flood_flag_expression = QgsExpression('state > 0')
flood_flag_expression.prepare(context)
for feature in layer.getFeatures():
context.setFeature(feature)
feature[flood_class_idx] = flood_class_expression.evaluate(context)
feature[flooded_idx] = flood_flag_expression.evaluate(context)
layer.updateFeature(feature)
layer.commitChanges()
return layer
示例4: testEditGeoJsonAddFieldAndThenAddFeatures
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
def testEditGeoJsonAddFieldAndThenAddFeatures(self):
""" Test bugfix of https://issues.qgis.org/issues/18596 (adding a new field)"""
datasource = os.path.join(self.basetestpath, 'testEditGeoJsonAddField.json')
with open(datasource, 'wt') as f:
f.write("""{
"type": "FeatureCollection",
"features": [
{ "type": "Feature", "properties": { "x": 1 }, "geometry": { "type": "Point", "coordinates": [ 0, 0 ] } } ] }""")
vl = QgsVectorLayer(datasource, 'test', 'ogr')
self.assertTrue(vl.isValid())
self.assertTrue(vl.startEditing())
self.assertTrue(vl.addAttribute(QgsField('strfield', QVariant.String)))
self.assertTrue(vl.commitChanges())
self.assertEqual(len(vl.dataProvider().fields()), 1 + 1)
self.assertEqual([f.name() for f in vl.dataProvider().fields()], ['x', 'strfield'])
f = QgsFeature()
self.assertTrue(vl.getFeatures(QgsFeatureRequest()).nextFeature(f))
self.assertIsNone(f['strfield'])
self.assertEqual([field.name() for field in f.fields()], ['x', 'strfield'])
self.assertTrue(vl.startEditing())
vl.changeAttributeValue(f.id(), 1, 'x')
self.assertTrue(vl.commitChanges())
f = QgsFeature()
self.assertTrue(vl.getFeatures(QgsFeatureRequest()).nextFeature(f))
self.assertEqual(f['strfield'], 'x')
self.assertEqual([field.name() for field in f.fields()], ['x', 'strfield'])
# Completely reload file
vl = QgsVectorLayer(datasource, 'test', 'ogr')
self.assertEqual(len(vl.fields()), 2)
示例5: testEditGeoJsonAddField
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
def testEditGeoJsonAddField(self):
""" Test bugfix of https://issues.qgis.org/issues/18596 (adding a new field)"""
datasource = os.path.join(self.basetestpath, 'testEditGeoJsonAddField.json')
with open(datasource, 'wt') as f:
f.write("""{
"type": "FeatureCollection",
"features": [
{ "type": "Feature", "properties": { "x": 1 }, "geometry": { "type": "Point", "coordinates": [ 0, 0 ] } } ] }""")
vl = QgsVectorLayer(datasource, 'test', 'ogr')
self.assertTrue(vl.isValid())
self.assertTrue(vl.startEditing())
self.assertTrue(vl.addAttribute(QgsField('strfield', QVariant.String)))
self.assertTrue(vl.commitChanges())
self.assertEqual(len(vl.dataProvider().fields()), 1 + 1)
f = QgsFeature()
self.assertTrue(vl.getFeatures(QgsFeatureRequest()).nextFeature(f))
self.assertIsNone(f['strfield'])
# Completely reload file
vl = QgsVectorLayer(datasource, 'test', 'ogr')
# As we didn't set any value to the new field, it is not written at
# all in the GeoJSON file, so it has disappeared
self.assertEqual(len(vl.fields()), 1)
示例6: testSaveFields
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
def testSaveFields(self):
# Create a new memory layer with no fields
myMemoryLayer = QgsVectorLayer(("Point?crs=epsg:4326&index=yes"), "test", "memory")
# Add some fields to the layer
myFields = [
QgsField("TestInt", QVariant.Int, "integer", 2, 0),
QgsField("TestLong", QVariant.LongLong, "long", -1, 0),
QgsField("TestDbl", QVariant.Double, "double", 8, 6),
QgsField("TestString", QVariant.String, "string", 50, 0),
QgsField("TestDate", QVariant.Date, "date"),
QgsField("TestTime", QVariant.Time, "time"),
QgsField("TestDateTime", QVariant.DateTime, "datetime"),
]
assert myMemoryLayer.startEditing()
for f in myFields:
assert myMemoryLayer.addAttribute(f)
assert myMemoryLayer.commitChanges()
myMemoryLayer.updateFields()
# Export the layer to a layer-definition-XML
qlr = QgsMapLayer.asLayerDefinition([myMemoryLayer])
assert qlr is not None
# Import the layer from the layer-definition-XML
layers = QgsMapLayer.fromLayerDefinition(qlr)
assert layers is not None
myImportedLayer = layers[0]
assert myImportedLayer is not None
# Check for the presence of the fields
importedFields = myImportedLayer.fields()
assert importedFields is not None
for f in myFields:
assert f == importedFields.field(f.name())
示例7: testSaveFields
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
def testSaveFields(self):
# Create a new memory layer with no fields
myMemoryLayer = QgsVectorLayer(
('Point?crs=epsg:4326&index=yes'),
'test',
'memory')
# Add some fields to the layer
myFields = [QgsField('TestInt', QVariant.Int, 'integer', 2, 0),
QgsField('TestDbl', QVariant.Double, 'double', 8, 6),
QgsField('TestString', QVariant.String, 'string', 50, 0),
QgsField('TestDate', QVariant.Date, 'date'),
QgsField('TestTime', QVariant.Time, 'time'),
QgsField('TestDateTime', QVariant.DateTime, 'datetime')]
assert myMemoryLayer.startEditing()
for f in myFields:
assert myMemoryLayer.addAttribute(f)
assert myMemoryLayer.commitChanges()
myMemoryLayer.updateFields()
# Export the layer to a layer-definition-XML
qlr = QgsMapLayer.asLayerDefinition([myMemoryLayer])
assert qlr is not None
# Import the layer from the layer-definition-XML
layers = QgsMapLayer.fromLayerDefinition(qlr)
assert layers is not None
myImportedLayer = layers[0]
assert myImportedLayer is not None
# Check for the presence of the fields
importedFields = myImportedLayer.fields()
assert importedFields is not None
for f in myFields:
assert f == importedFields.field(f.name())
示例8: testAddingTwoIntFieldsWithWidth
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
def testAddingTwoIntFieldsWithWidth(self):
""" Test buggfix for https://issues.qgis.org/issues/19009 """
tmpfile = os.path.join(self.basetestpath, 'testRequestWithoutGeometryOnLayerMixedGeometry.gpkg')
ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['SPATIAL_INDEX=NO'])
lyr.CreateField(ogr.FieldDefn('a', ogr.OFTInteger))
ds = None
vl = QgsVectorLayer(u'{}'.format(tmpfile) + "|layername=" + "test", 'test', u'ogr')
self.assertTrue(vl.isValid())
vl.startEditing()
self.assertTrue(vl.addAttribute(QgsField("b", QVariant.Int, "integer", 10)))
self.assertTrue(vl.commitChanges())
vl.startEditing()
self.assertTrue(vl.addAttribute(QgsField("c", QVariant.Int, "integer", 10)))
self.assertTrue(vl.commitChanges())
示例9: f
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [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)
示例10: AutoFieldsTests
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [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 )
#.........这里部分代码省略.........
示例11: sampling
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
def sampling(self, outPath, tableName): # main process
# open sampling points layer
pointLayer = self.sampItems[str(self.inSample.currentText())][0]
pointProvider = pointLayer.dataProvider()
allAttrs = pointProvider.attributeIndexes()
sRs = pointLayer.crs()
# create destination layer: first create list of selected fields
fieldList = QgsFields()
for i in range(len(self.fields)):
if self.fields[i][0] == "point": #copying fields from source layer
field = pointProvider.fields()[pointProvider.fieldNameIndex(self.sampItems[self.fields[i][1]][self.fields[i][2]][0])]
field.setName(self.sampItems[self.fields[i][1]][self.fields[i][2]][1])
elif self.fields[i][0] == "poly": #copying fields from polygon layers
polyLayer = self.polyItems[self.fields[i][1]][0]
polyProvider = polyLayer.dataProvider()
field = polyProvider.fields()[polyProvider.fieldNameIndex(self.polyItems[self.fields[i][1]][self.fields[i][2]][0])]
field.setName(self.polyItems[self.fields[i][1]][self.fields[i][2]][1])
else: #creating fields for raster layers
field = QgsField(self.rastItems[self.fields[i][1]][self.fields[i][2]][1], QVariant.Double, "real", 20, 5, "")
##### Better data type fit will be implemented in next versions
fieldList.append(field)
# create temporary memory layer (as it's currently impossible to set GPKG table name when writting features to QgsVectorFileWriter directly)
memLayer = QgsVectorLayer("Point?crs=epsg:%d" % sRs.postgisSrid(), 'temp layer', 'memory')
memLayer.startEditing()
for field in fieldList:
memLayer.addAttribute(field)
memLayer.commitChanges()
self.statusLabel.setText(self.tr("Writing data to the new layer..."))
self.repaint()
# process point after point...
pointFeat = QgsFeature()
np = 0
snp = pointProvider.featureCount()
for pointFeat in pointProvider.getFeatures():
np += 1
if snp<100 or ( snp<5000 and ( np // 10.0 == np / 10.0 ) ) or ( np // 100.0 == np / 100.0 ): # display each or every 10th or every 100th point:
self.statusLabel.setText(self.tr("Processing point %s of %s") % (np, snp))
self.repaint()
# convert multipoint[0] to point
pointGeom = pointFeat.geometry()
if pointGeom.wkbType() == QgsWkbTypes.MultiPoint:
pointPoint = pointGeom.asMultiPoint()[0]
else:
pointPoint = pointGeom.asPoint()
outFeat = QgsFeature()
outFeat.setGeometry(pointGeom)
# ...and next loop inside: field after field
bBox = QgsRectangle(pointPoint.x()-0.001,pointPoint.y()-0.001,pointPoint.x()+0.001,pointPoint.y()+0.001) # reuseable rectangle buffer around the point feature
previousPolyLayer = None # reuse previous feature if it's still the same layer
previousPolyFeat = None # reuse previous feature if it's still the same layer
previousRastLayer = None # reuse previous raster multichannel sample if it's still the same layer
previousRastSample = None # reuse previous raster multichannel sample if it's still the same layer
attrs = []
for i in range(len(self.fields)):
field = self.fields[i]
if field[0] == "point":
attr = pointFeat.attributes()[pointProvider.fieldNameIndex(self.sampItems[field[1]][field[2]][0])]
attrs += [attr]
elif field[0] == "poly":
polyLayer = self.polyItems[field[1]][0]
polyProvider = polyLayer.dataProvider()
if polyLayer == previousPolyLayer:
polyFeat = previousPolyFeat
else:
polyFeat = None
pointGeom = QgsGeometry().fromPointXY(pointPoint)
for iFeat in polyProvider.getFeatures(QgsFeatureRequest().setFilterRect(bBox)):
if pointGeom.intersects(iFeat.geometry()):
polyFeat = iFeat
if polyFeat:
attr = polyFeat.attributes()[polyProvider.fieldNameIndex(self.polyItems[field[1]][field[2]][0])]
else:
attr = None
attrs += [attr] #only last one if more polygons overlaps!! This way we avoid attribute list overflow
previousPolyLayer = polyLayer
previousPolyFeat = polyFeat
else: # field source is raster
rastLayer = self.rastItems[field[1]][0]
if rastLayer == previousRastLayer:
rastSample = previousRastSample
else:
rastSample = rastLayer.dataProvider().identify(pointPoint, QgsRaster.IdentifyFormatValue).results()
try:
#bandName = self.rastItems[field[1]][field[2]][0] #depreciated
bandNo = field[2]
attr = float(rastSample[bandNo]) ##### !! float() - I HAVE TO IMPLEMENT RASTER TYPE HANDLING!!!!
except: # point is out of raster extent
attr = None
attrs += [attr]
previousRastLayer = rastLayer
previousRastSample = rastSample
outFeat.initAttributes(len(attrs))
outFeat.setAttributes(attrs)
memLayer.dataProvider().addFeature(outFeat)
# write the memlayer to the output file
so=QgsVectorFileWriter.SaveVectorOptions()
so.fileEncoding = 'UTF-8'
if outPath.upper().endswith('SHP'):
#.........这里部分代码省略.........
示例12: mesh_canvas
# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import addAttribute [as 别名]
class mesh_canvas(QgsMapCanvas):
def __init__(self,iface,tile_name,tile_credit,tile_url,tile_zmin,tile_zmax,tile_bbox):
QgsMapCanvas.__init__(self)
self.iface = iface
self.setWheelAction(QgsMapCanvas.WheelZoom,1)
self.setDestinationCrs(self.iface.mapCanvas().mapSettings().destinationCrs())
self.setCrsTransformEnabled(True)
self.iface.mapCanvas().destinationCrsChanged.connect(self.onCrsChanged)
self.iface.mapCanvas().extentsChanged.connect(self.onExtentsChanged)
self.iface.mapCanvas().scaleChanged.connect(self.onScaleChanged)
layerdef = TileLayerDefinition(tile_name,
tile_credit,
tile_url,
zmin=tile_zmin,
zmax=tile_zmax,
bbox=tile_bbox)
creditVisibility=True
plugin = plugins.get("TileLayerPlugin")
self.chirin_layer = TileLayer(plugin,layerdef, creditVisibility)
QgsMapLayerRegistry.instance().addMapLayer(self.chirin_layer,False)
self.meshPolyLayer = QgsVectorLayer("polygon?crs=postgis:4612",u"地域メッシュインデックス","memory")
renderer = self.meshPolyLayer.rendererV2()
renderer.symbols()[0].symbolLayers()[0].setFillColor(QtGui.QColor(0,0,0,0))
renderer.symbols()[0].symbolLayers()[0].setBorderWidth(0.1)
self.meshPolyLayer.label().setLabelField(0,0)
self.meshPolyLayer.startEditing()
self.meshPolyLayer.addAttribute(QgsField("meshC",QtCore.QVariant.String))
self.meshPolyLayer.commitChanges()
QgsMapLayerRegistry.instance().addMapLayer(self.meshPolyLayer,False)
main_crs = self.iface.mapCanvas().mapSettings().destinationCrs()
self.Trs_laln = QgsCoordinateTransform(main_crs,QgsCoordinateReferenceSystem(4612))
self.redraw_mesh()
layers = []
layers.append(QgsMapCanvasLayer(self.meshPolyLayer))
layers.append(QgsMapCanvasLayer(self.chirin_layer))
self.setLayerSet(layers)
self.setExtent( self.iface.mapCanvas().extent() )
self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self.resize(self.iface.mapCanvas().size()/2)
def onCrsChanged(self):
main_crs = self.iface.mapCanvas().mapSettings().destinationCrs()
self.setDestinationCrs(main_crs)
def onExtentsChanged(self):
self.setExtent( self.iface.mapCanvas().extent() )
self.redraw_mesh()
self.refresh()
def onScaleChanged(self):
self.resize(self.iface.mapCanvas().size()/2)
def PPopend(self):
self.iface.mapCanvas().extentsChanged.disconnect()
self.iface.mapCanvas().scaleChanged.disconnect()
def res_mesh_index(self,latitude,longitude):
x1d = math.floor(longitude - 100)
x2d = math.floor((longitude - x1d - 100 ) * 8 )
x3d = math.floor((longitude - x1d - 100 - x2d/8.0 )*80 )
y1d = math.floor(latitude*1.5)
y2d = math.floor((latitude*1.5 - y1d ) * 8 )
y3d = math.floor((latitude*1.5 - y1d - y2d/8.0 )*80 )
return (x1d,x2d,x3d,y1d,y2d,y3d)
def res_extent_mesh(self):
main_crs = self.iface.mapCanvas().mapSettings().destinationCrs()
self.Trs_laln.setSourceCrs(main_crs)
my_rect = self.iface.mapCanvas().extent()
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,
#.........这里部分代码省略.........