Python QgsFeature.setFeatureId方法代码示例

# 需要导入模块: from qgis.core import QgsFeature [as 别名]
# 或者: from qgis.core.QgsFeature import setFeatureId [as 别名]
 def __make_test_feature(self, x, y):
     f = QgsFeature()
     wkt = QgsPoint(x, y).wellKnownText()
     geom = QgsGeometry.fromWkt(wkt)
     f.setGeometry(geom)
     f.setFeatureId(self.test_id)
     self.test_id += 1
     f.setValid(True)
     return f

# 需要导入模块: from qgis.core import QgsFeature [as 别名]
# 或者: from qgis.core.QgsFeature import setFeatureId [as 别名]
    def to_shp(self, any_features_list, crs, name ):
        network = QgsVectorLayer('LineString?crs=' + crs.toWkt(), name, "memory")
        pr = network.dataProvider()

        pr.addAttributes(self.layer_fields)

        new_features = []

        for i in any_features_list:
            new_feat = QgsFeature()
            new_feat.setFeatureId(i[0])
            new_feat.setAttributes(i[1])
            new_feat.setGeometry(QgsGeometry.fromWkt(i[2]))
            new_features.append(new_feat)

        network.startEditing()
        pr.addFeatures(new_features)
        network.commitChanges()
        return network

# 需要导入模块: from qgis.core import QgsFeature [as 别名]
# 或者: from qgis.core.QgsFeature import setFeatureId [as 别名]
    def test_resetSnappingIndex(self):
        self.pointsLayer.setDependencies([])
        self.linesLayer.setDependencies([])
        self.pointsLayer2.setDependencies([])

        ms = QgsMapSettings()
        ms.setOutputSize(QSize(100, 100))
        ms.setExtent(QgsRectangle(0, 0, 1, 1))
        self.assertTrue(ms.hasValidSettings())

        u = QgsSnappingUtils()
        u.setMapSettings(ms)
        cfg = u.config()
        cfg.setMode(QgsSnappingConfig.AdvancedConfiguration)
        cfg.setIndividualLayerSettings(self.pointsLayer,
                                       QgsSnappingConfig.IndividualLayerSettings(True,
                                                                                 QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels))
        u.setConfig(cfg)

        m = u.snapToMap(QPoint(95, 100))
        self.assertTrue(m.isValid())
        self.assertTrue(m.hasVertex())
        self.assertEqual(m.point(), QgsPoint(1, 0))

        f = QgsFeature(self.linesLayer.fields())
        f.setFeatureId(1)
        geom = QgsGeometry.fromWkt("LINESTRING(0 0,1 1)")
        f.setGeometry(geom)
        self.linesLayer.startEditing()
        self.linesLayer.addFeatures([f])
        self.linesLayer.commitChanges()

        l1 = len([f for f in self.pointsLayer.getFeatures()])
        self.assertEqual(l1, 4)
        m = u.snapToMap(QPoint(95, 0))
        # snapping not updated
        self.pointsLayer.setDependencies([])
        self.assertEqual(m.isValid(), False)

        # set layer dependencies
        self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())])
        # add another line
        f = QgsFeature(self.linesLayer.fields())
        f.setFeatureId(2)
        geom = QgsGeometry.fromWkt("LINESTRING(0 0,0.5 0.5)")
        f.setGeometry(geom)
        self.linesLayer.startEditing()
        self.linesLayer.addFeatures([f])
        self.linesLayer.commitChanges()
        # check the snapped point is ok
        m = u.snapToMap(QPoint(45, 50))
        self.assertTrue(m.isValid())
        self.assertTrue(m.hasVertex())
        self.assertEqual(m.point(), QgsPoint(0.5, 0.5))
        self.pointsLayer.setDependencies([])

        # test chained layer dependencies A -> B -> C
        cfg.setIndividualLayerSettings(self.pointsLayer2,
                                       QgsSnappingConfig.IndividualLayerSettings(True,
                                                                                 QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels))
        u.setConfig(cfg)
        self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())])
        self.pointsLayer2.setDependencies([QgsMapLayerDependency(self.pointsLayer.id())])
        # add another line
        f = QgsFeature(self.linesLayer.fields())
        f.setFeatureId(3)
        geom = QgsGeometry.fromWkt("LINESTRING(0 0.2,0.5 0.8)")
        f.setGeometry(geom)
        self.linesLayer.startEditing()
        self.linesLayer.addFeatures([f])
        self.linesLayer.commitChanges()
        # check the second snapped point is ok
        m = u.snapToMap(QPoint(75, 100 - 80))
        self.assertTrue(m.isValid())
        self.assertTrue(m.hasVertex())
        self.assertEqual(m.point(), QgsPoint(0.7, 0.8))
        self.pointsLayer.setDependencies([])
        self.pointsLayer2.setDependencies([])

# 需要导入模块: from qgis.core import QgsFeature [as 别名]
# 或者: from qgis.core.QgsFeature import setFeatureId [as 别名]
def addfeaturestolayer(layer, featurecount):
    for count in xrange(featurecount):
        feature = QgsFeature()
        feature.setFeatureId(count)
        layer.dataProvider().addFeatures([feature])
    return layer

# 需要导入模块: from qgis.core import QgsFeature [as 别名]
# 或者: from qgis.core.QgsFeature import setFeatureId [as 别名]
    def __init__(self,layer, tolerance, uid, errors):
        QObject.__init__(self)
        self.layer = layer
        self.feat_count = self.layer.featureCount()
        self.tolerance = tolerance
        self.uid = uid

        self.errors = errors
        self.multiparts = []
        self.points = []
        self.invalids = []

        self.features = []
        self.attributes = {}
        self.geometries = {}
        self.geometries_wkt = {}
        self.geometries_vertices = {}
        # create spatial index object
        self.spIndex = QgsSpatialIndex()
        self.layer_fields = [QgsField(i.name(), i.type()) for i in self.layer.dataProvider().fields()]
        if self.uid is not None:
            self.uid_index = [index for index,field in enumerate(self.layer_fields) if field.name() == self.uid].pop()
        self.fid_to_uid = {}
        self.uid_to_fid = {}
        new_key_count = 0
        f_count = 1
        for f in self.layer.getFeatures():

            self.progress.emit(45 * f_count / self.feat_count)
            f_count += 1

            attr = f.attributes()
            if f.geometry().wkbType() == 5 :
                attr = f.attributes()
                if self.errors and self.uid is not None:
                    self.multiparts.append(attr[self.uid_index])
                    self.uid_to_fid[attr[self.uid_index]] = f.id()
                for multipart in f.geometry().asGeometryCollection():
                    new_key_count += 1
                    if self.uid is not None:
                        self.fid_to_uid[new_key_count] = attr[self.uid_index]
                    attr = f.attributes()
                    new_feat = QgsFeature()
                    new_feat.setAttributes(attr)
                    new_feat.setFeatureId(new_key_count)
                    if self.tolerance:
                        snapped_wkt = make_snapped_wkt(multipart.exportToWkt(), self.tolerance)
                    else:
                        snapped_wkt = multipart.exportToWkt()
                    snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
                    new_feat.setGeometry(snapped_geom)
                    self.features.append(new_feat)
                    self.attributes[new_key_count] = attr
                    self.geometries[new_key_count] = new_feat.geometryAndOwnership()
                    self.geometries_wkt[new_key_count] = snapped_wkt
                    self.geometries_vertices[new_key_count] = [vertex for vertex in vertices_from_wkt_2(snapped_wkt)]
                    # insert features to index
                    self.spIndex.insertFeature(new_feat)
            elif f.geometry().wkbType() == 1:
                if self.errors and self.uid is not None:
                    self.points.append(attr[self.uid_index])
            elif not f.geometry().isGeosValid():
                if self.errors and self.uid is not None:
                    self.invalids.append(attr[self.uid_index])
            elif f.geometry().wkbType() == 2:
                attr = f.attributes()
                if self.tolerance:
                    snapped_wkt = make_snapped_wkt(f.geometry().exportToWkt(), self.tolerance)
                else:
                    snapped_wkt = f.geometry().exportToWkt()
                snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
                f.setGeometry(snapped_geom)
                new_key_count += 1
                f.setFeatureId(new_key_count)
                self.features.append(f)
                self.attributes[f.id()] = attr
                self.geometries[f.id()] = f.geometryAndOwnership()
                self.geometries_wkt[f.id()] = snapped_wkt
                self.geometries_vertices[f.id()] = [vertex for vertex in vertices_from_wkt_2(snapped_wkt)]
                # insert features to index
                self.spIndex.insertFeature(f)
                if self.uid is not None:
                    self.fid_to_uid[f.id()] = attr[self.uid_index]
                    self.uid_to_fid[attr[self.uid_index]] = f.id()