Python QgsVectorLayer.updateFields方法代码示例

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
    def testUpdatedFields(self):
        """Test when referenced layer update its fields
        https://issues.qgis.org/issues/20893
        """

        ml = QgsVectorLayer("Point?srid=EPSG:4326&field=a:int", "mem", "memory")
        self.assertEqual(ml.isValid(), True)
        QgsProject.instance().addMapLayer(ml)

        ml.startEditing()
        f1 = QgsFeature(ml.fields())
        f1.setGeometry(QgsGeometry.fromWkt('POINT(2 3)'))
        ml.addFeatures([f1])
        ml.commitChanges()

        vl = QgsVectorLayer("?query=select a, geometry from mem", "vl", "virtual")
        self.assertEqual(vl.isValid(), True)

        # add one more field
        ml.dataProvider().addAttributes([QgsField('newfield', QVariant.Int)])
        ml.updateFields()

        self.assertEqual(ml.featureCount(), vl.featureCount())
        self.assertEqual(vl.fields().count(), 1)

        geometry = next(vl.getFeatures()).geometry()
        self.assertTrue(geometry)

        point = geometry.asPoint()
        self.assertEqual(point.x(), 2)
        self.assertEqual(point.y(), 3)

        QgsProject.instance().removeMapLayer(ml)

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
def nodeCreateMemoryLayer(nodename, position='bottom',target_node=None,source="Point",crs=None,indexfieldname='id'):
    if target_node == None:
        target_node = QgsProject.instance().layerTreeRoot()
    else:
         if oeq_global.isStringOrUnicode(target_node):
            target_node = nodeByName(target_node)
            if len(target_node) == 0:
                return None
            target_node = target_node[0]

    if path == None:
        path= oeq_global.OeQ_project_path()
    if crs == None:
        crs = config.project_crs
    new_layer = QgsVectorLayer(source + '?crs=' + crs, nodename, "memory")
    new_layer.setProviderEncoding('System')
    QgsMapLayerRegistry.instance().addMapLayer(new_layer, True)
    #oeq_global.OeQ_wait_for_renderer(60000)
    new_node = nodeMove(nodename,position,target_node)
    new_layer = new_node.layer()
    dataprovider = new_layer.dataProvider()
    dataprovider.addAttributes([QgsField(indexfieldname,  QVariant.Int)])
    new_layer.updateFields()
    #oeq_global.OeQ_unlockQgis()

    return new_node

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [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())

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [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())

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
def createReprojectedLayer(layer, crs):
    """
    Creates a reprojected layer
    layer: layer used
    crs: crs used
    """
    temp = QgsVectorLayer('%s?crs=%s'% ('Multipolygon', crs.authid()), 'temp', 'memory')
    if not layer.isValid():
        raise GeoAlgorithmExecutionException('Problema ao criar camada reprojetada!')
        return None
    
    provider = temp.dataProvider()
    provider.addAttributes(layer.dataProvider().fields().toList())
    temp.updateFields()
    
    coordinateTransformer = QgsCoordinateTransform(layer.crs(), crs)
    features = []
    for feature in layer.getFeatures():
        feat = QgsFeature(feature)
        geom = feat.geometry()
        geom.transform(coordinateTransformer)
        feat.setGeometry(geom)
        features.append(feat)
        
    provider.addFeatures(features)
    
    return temp

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
def create_neighbors_layer():
    vl = QgsVectorLayer("Polygon", LAYER_NEIGHBORS, "memory")
    pr = vl.dataProvider()
    vl.startEditing()
    pr.addAttributes( [ QgsField(FIELD_UUID, QVariant.String),
                    QgsField(FIELD_NEIGHBORS_UUID,  QVariant.String),
                    QgsField(FIELD_SV,  QVariant.Double)] )
    vl.updateFields()
    return vl

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
def create_layer(name, attributes):
    layer = QgsVectorLayer("Polygon", name, "memory")
    pr = layer.dataProvider()
    layer.startEditing()
    pr.addAttributes(attributes)
    layer.updateFields()
    layer.commitChanges()
    QgsMapLayerRegistry.instance().addMapLayer(layer) 
    return layer

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
 def createGridLayer(self, name, layerType, crsAuthId):
     layer = QgsVectorLayer('%s?crs=%s'% (layerType, crsAuthId), name, 'memory')
     if not layer.isValid():
         self.aux.errorOccurred.emit(self.aux.getMemoryLayerErrorMessage())
         return
     provider = layer.dataProvider()
     provider.addAttributes([QgsField(self.aux.getIndexFieldName(), QVariant.String), QgsField('mi', QVariant.String)])
     layer.updateFields()
     return layer

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
    def fill_attribute_table(self):

        # Ouvrir le shapefile
        cliffs = QgsVectorLayer(self.output_path + os.sep + "cliffs.shp", "cliffs_points", "ogr")
        caps = cliffs.dataProvider().capabilities()
        prov = cliffs.dataProvider()

        # Ouvrir tous les rasters pour obtenir les coefficients de transformation
        orientation = gdal.Open(self.output_path + os.sep + "slope.tif")
        inclinaison = gdal.Open(self.output_path + os.sep + "aspect.tif")
        prox_wetland = gdal.Open(self.output_path + os.sep + "create_prox_raster_wl.tif")
        prox_water = gdal.Open(self.output_path + os.sep + "create_prox_raster_w.tif")
        score = gdal.Open(self.output_path + os.sep + "raster_output.tif")

        # Ajouter tous les nouveaux attributs
        if caps & QgsVectorDataProvider.AddAttributes:
            cliffs.dataProvider().addAttributes([
                QgsField("ORIENT", QVariant.Int),
                QgsField("INCLIN", QVariant.Int),
                QgsField("PROX_MH", QVariant.Int),
                QgsField("PROX_LAC", QVariant.Int),
                QgsField("POINTAGE", QVariant.Int)
            ])
        cliffs.updateFields()

        patches = cliffs.getFeatures()
        if caps & QgsVectorDataProvider.ChangeAttributeValues:
            for patch in patches:
                pt = patch.geometry().asPoint()

                # Valeurs des attributs
                rept = self.invert_affine(orientation.GetGeoTransform(), pt)
                attr_ori = self.aspect_data[rept[::-1]]

                rept = self.invert_affine(inclinaison.GetGeoTransform(), pt)
                attr_inc = self.falaises_data[rept[::-1]]

                rept = self.invert_affine(prox_wetland.GetGeoTransform(), pt)
                attr_wet = self.wetland_prox_data[rept[::-1]]

                rept = self.invert_affine(prox_water.GetGeoTransform(), pt)
                attr_wat = self.wetland_prox_data[rept[::-1]]

                rept = self.invert_affine(score.GetGeoTransform(), pt)
                attr_sco = self.results_raster[rept[::-1]]

                # Inscrire les modifications
                prov.changeAttributeValues({patch.id(): {prov.fieldNameMap()['ORIENT']: int(attr_ori),
                                                         prov.fieldNameMap()['INCLIN']: int(attr_inc),
                                                         prov.fieldNameMap()['PROX_MH']: int(attr_wet),
                                                         prov.fieldNameMap()['PROX_LAC']: int(attr_wat),
                                                         prov.fieldNameMap()['POINTAGE']: int(attr_sco)
                                                         }})

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
 def copySelected(self, layer, mem_layer, geom_type):
     ''' Copy from selected layer to memory layer 
     '''
     self.manageMemLayers()
     
     # Create memory layer if not already set
     if mem_layer is None: 
         uri = geom_type+"?crs=epsg:25831" 
         mem_layer = QgsVectorLayer(uri, "selected_"+layer.name(), "memory")                     
      
         # Copy attributes from main layer to memory layer
         attrib_names = layer.dataProvider().fields()
         names_list = attrib_names.toList()
         newattributeList = []
         for attrib in names_list:
             aux = mem_layer.fieldNameIndex(attrib.name())
             if aux == -1:
                 newattributeList.append(QgsField(attrib.name(), attrib.type()))
         mem_layer.dataProvider().addAttributes(newattributeList)
         mem_layer.updateFields()
         
         # Insert layer in the top of the TOC           
         root = QgsProject.instance().layerTreeRoot()           
         QgsMapLayerRegistry.instance().addMapLayer(mem_layer, False)
         node_layer = QgsLayerTreeLayer(mem_layer)
         root.insertChildNode(0, node_layer)                 
  
     # Prepare memory layer for editing
     mem_layer.startEditing()
     
     # Iterate over selected features   
     cfeatures = []
     for sel_feature in layer.selectedFeatures():
         attributes = []
         attributes.extend(sel_feature.attributes())
         cfeature = QgsFeature()    
         cfeature.setGeometry(sel_feature.geometry())
         cfeature.setAttributes(attributes)
         cfeatures.append(cfeature)
                  
     # Add features, commit changes and refresh canvas
     mem_layer.dataProvider().addFeatures(cfeatures)             
     mem_layer.commitChanges()
     self.iface.mapCanvas().refresh() 
     self.iface.mapCanvas().zoomToSelected(layer)
     
     # Make sure layer is always visible 
     self.iface.legendInterface().setLayerVisible(mem_layer, True)
                 
     return mem_layer

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
 def generateMemoryLayer(self, targetLayer, fieldDict):
     epsg = 'EPSG:'+ str(targetLayer.crs().postgisSrid())
     if self.geometryText.has_key(targetLayer.wkbType()):
         geometry = self.wkbText[targetLayer.wkbType()]
     else:
         geometry = self.geometryText[targetLayer.geometryType()]
     name = targetLayer.name()
     memoryLayer = QgsVectorLayer(geometry + '?crs=' + epsg, name, "memory")
     memoryLayer.startEditing()#to add field it needs to be in editing mode
     for fieldName in fieldDict:
         field = QgsField(fieldName, fieldDict[fieldName])
         memoryLayer.dataProvider().addAttributes([field])
     memoryLayer.updateFields()
     memoryLayer.commitChanges()
     return  memoryLayer

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
def create_memory_layer(
        layer_name, geometry, coordinate_reference_system=None, fields=None):
    """Create a vector memory layer.

    :param layer_name: The name of the layer.
    :type layer_name: str

    :param geometry: The geometry of the layer.
    :rtype geometry: QGis.WkbType

    :param coordinate_reference_system: The CRS of the memory layer.
    :type coordinate_reference_system: QgsCoordinateReferenceSystem

    :param fields: Fields of the vector layer. Default to None.
    :type fields: QgsFields

    :return: The memory layer.
    :rtype: QgsVectorLayer
    """

    if geometry == QGis.Point:
        type_string = 'MultiPoint'
    elif geometry == QGis.Line:
        type_string = 'MultiLineString'
    elif geometry == QGis.Polygon:
        type_string = 'MultiPolygon'
    elif geometry == QGis.NoGeometry:
        type_string = 'none'
    else:
        raise Exception(
            'Layer is whether Point nor Line nor Polygon, I got %s' % geometry)

    uri = '%s?index=yes&uuid=%s' % (type_string, str(uuid4()))
    if coordinate_reference_system:
        crs = coordinate_reference_system.authid().lower()
        uri += '&crs=%s' % crs
    memory_layer = QgsVectorLayer(uri, layer_name, 'memory')
    memory_layer.keywords = {
        'inasafe_fields': {}
    }

    if fields:
        data_provider = memory_layer.dataProvider()
        data_provider.addAttributes(fields)
        memory_layer.updateFields()

    return memory_layer

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
class LayerMaker(object):
    def __init__(self, layer_name):
        self.layer = QgsVectorLayer("LineString", layer_name, "memory")
        self.pr = self.layer.dataProvider()
        self.layer.startEditing()
        self.pr.addAttributes([QgsField("elevation", QVariant.Double)])
        self.layer.updateFields()

    def add_features(self, feature_descr_list):
        features = []
        for fd in feature_descr_list:
            feature = QgsFeature()
            feature.setGeometry(fd.geom)
            feature.setAttributes([fd.elev])
            features.append(feature)
        self.pr.addFeatures(features)
        self.layer.commitChanges()

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
def duplicateInMemory(layer, newName="", addToRegistry=False):
    """Return a memory copy of a layer

    layer: QgsVectorLayer that shall be copied to memory.
    new_name: The name of the copied layer.
    add_to_registry: if True, the new layer will be added to the QgsMapRegistry

    Returns an in-memory copy of a layer.
    """
    if newName is "":
        newName = layer.name() + " (Memory)"

    if layer.type() == QgsMapLayer.VectorLayer:
        geomType = layer.geometryType()
        if geomType == QgsWkbTypes.PointGeometry:
            strType = "Point"
        elif geomType == QgsWkbTypes.LineGeometry:
            strType = "Line"
        elif geomType == QgsWkbTypes.PolygonGeometry:
            strType = "Polygon"
        else:
            raise RuntimeError("Layer is whether Point nor Line nor Polygon")
    else:
        raise RuntimeError("Layer is not a VectorLayer")

    crs = layer.crs().authid().lower()
    myUuid = str(uuid.uuid4())
    uri = "%s?crs=%s&index=yes&uuid=%s" % (strType, crs, myUuid)
    memLayer = QgsVectorLayer(uri, newName, "memory")
    memProvider = memLayer.dataProvider()

    provider = layer.dataProvider()
    fields = layer.fields().toList()
    memProvider.addAttributes(fields)
    memLayer.updateFields()

    for ft in provider.getFeatures():
        memProvider.addFeatures([ft])

    if addToRegistry:
        if memLayer.isValid():
            QgsProject.instance().addMapLayer(memLayer)
        else:
            raise RuntimeError("Layer invalid")

    return memLayer

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import updateFields [as 别名]
def duplicateInMemory(layer, newName='', addToRegistry=False):
    """Return a memory copy of a layer

    layer: QgsVectorLayer that shall be copied to memory.
    new_name: The name of the copied layer.
    add_to_registry: if True, the new layer will be added to the QgsMapRegistry

    Returns an in-memory copy of a layer.
    """
    if newName is '':
        newName = layer.name() + ' (Memory)'

    if layer.type() == QgsMapLayer.VectorLayer:
        geomType = layer.geometryType()
        if geomType == QGis.Point:
            strType = 'Point'
        elif geomType == QGis.Line:
            strType = 'Line'
        elif geomType == QGis.Polygon:
            strType = 'Polygon'
        else:
            raise RuntimeError('Layer is whether Point nor Line nor Polygon')
    else:
        raise RuntimeError('Layer is not a VectorLayer')

    crs = layer.crs().authid().lower()
    myUuid = unicode(uuid.uuid4())
    uri = '%s?crs=%s&index=yes&uuid=%s' % (strType, crs, myUuid)
    memLayer = QgsVectorLayer(uri, newName, 'memory')
    memProvider = memLayer.dataProvider()

    provider = layer.dataProvider()
    fields = provider.fields().toList()
    memProvider.addAttributes(fields)
    memLayer.updateFields()

    for ft in provider.getFeatures():
        memProvider.addFeatures([ft])

    if addToRegistry:
        if memLayer.isValid():
            QgsMapLayerRegistry.instance().addMapLayer(memLayer)
        else:
            raise RuntimeError('Layer invalid')

    return memLayer