Python QgsFeatureRequest.setFlags方法代码示例

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
    def updateGui(self, feature):
        # The important part: get the feature iterator with an expression
        request = QgsFeatureRequest().setFilterExpression ( u'"pand_id" = \'' + unicode(feature['gebouwnummer']) + '\'' )
        request.setFlags( QgsFeatureRequest.NoGeometry )
        features = self.geomLayer.getFeatures( request )

        atr = None
        fields = self.geomLayer.pendingFields()
        field_names = [field.name() for field in fields]
        for elem in features:
            self.editFeature = elem
            atr = dict(zip(field_names, elem.attributes()))

        if atr is not None:
            atr = {i:j for i,j in atr.items() if j }
            self.newGroupBox.hide()
            self.editGroupBox.show()
            self.verwijderWidget.show()
            self.showValues(feature, atr)
            self.actionButtonBox.setDisabled(True)

        else:
            self.newGroupBox.show()
            self.editGroupBox.hide()
            self.verwijderWidget.hide()

            self.editFeature = None
            self.statusNieuwLabel.setText(unicode(feature['status']))
            self.pandidLabel.setText(unicode(feature['gebouwnummer']))

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
def writeTmpLayer(layer, restrictToExtent, iface, extent):
    fields = layer.fields()
    usedFields = []
    for count, field in enumerate(fields):
        fieldIndex = fields.indexFromName(unicode(field.name()))
        editorWidget = layer.editorWidgetSetup(fieldIndex).type()
        addField = False
        try:
            if layer.renderer().classAttribute() == field.name():
                addField = True
        except:
            pass
        if layer.customProperty("labeling/fieldName") == field.name():
            addField = True
        if (editorWidget != 'Hidden'):
            addField = True
        if addField:
            usedFields.append(count)
    uri = TYPE_MAP[layer.wkbType()]
    crs = layer.crs()
    if crs.isValid():
        uri += '?crs=' + crs.authid()
    for field in usedFields:
        fieldIndex = layer.fields().indexFromName(unicode(
            layer.fields().field(field).name()))
        editorWidget = layer.editorWidgetSetup(fieldIndex).type()
        fieldType = layer.fields().field(field).type()
        fieldName = layer.fields().field(field).name()
        if (editorWidget == 'Hidden'):
            fieldName = "q2wHide_" + fieldName
        fieldType = "double" if (fieldType == QVariant.Double or
                                 fieldType == QVariant.Int) else ("string")
        uri += '&field=' + unicode(fieldName) + ":" + fieldType
    newlayer = QgsVectorLayer(uri, layer.name(), 'memory')
    writer = newlayer.dataProvider()
    outFeat = QgsFeature()
    if restrictToExtent and extent == "Canvas extent":
        canvas = iface.mapCanvas()
        extent = canvas.extent()
        canvasCRS = canvas.mapSettings().destinationCrs()
        layerCRS = layer.crs()
        try:
            transform = QgsCoordinateTransform(canvasCRS, layerCRS,
                                               QgsProject.instance())
        except:
            transform = QgsCoordinateTransform(canvasCRS, layerCRS)
        projectedExtent = transform.transformBoundingBox(extent)
        request = QgsFeatureRequest(projectedExtent)
        request.setFlags(QgsFeatureRequest.ExactIntersect)
        features = layer.getFeatures(request)
    else:
        features = layer.getFeatures()
    for feature in features:
        if feature.geometry() is not None:
            outFeat.setGeometry(feature.geometry())
        attrs = [feature[f] for f in usedFields]
        if attrs:
            outFeat.setAttributes(attrs)
        writer.addFeatures([outFeat])
    return newlayer

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
    def testGetFeaturesFilterRectTests(self):
        extent = QgsRectangle(-70, 67, -60, 80)
        request = QgsFeatureRequest().setFilterRect(extent)
        features = [f['pk'] for f in self.source.getFeatures(request)]
        all_valid = (all(f.isValid() for f in self.source.getFeatures(request)))
        assert set(features) == set([2, 4]), 'Got {} instead'.format(features)
        self.assertTrue(all_valid)

        # test that results match QgsFeatureRequest.acceptFeature
        for f in self.source.getFeatures():
            self.assertEqual(request.acceptFeature(f), f['pk'] in set([2, 4]))

        # test with an empty rectangle
        extent = QgsRectangle()
        request = QgsFeatureRequest().setFilterRect(extent)
        features = [f['pk'] for f in self.source.getFeatures(request)]
        all_valid = (all(f.isValid() for f in self.source.getFeatures(request)))
        assert set(features) == set([1, 2, 3, 4, 5]), 'Got {} instead'.format(features)
        self.assertTrue(all_valid)

        # ExactIntersection flag set, but no filter rect set. Should be ignored.
        request = QgsFeatureRequest()
        request.setFlags(QgsFeatureRequest.ExactIntersect)
        features = [f['pk'] for f in self.source.getFeatures(request)]
        all_valid = (all(f.isValid() for f in self.source.getFeatures(request)))
        assert set(features) == set([1, 2, 3, 4, 5]), 'Got {} instead'.format(features)
        self.assertTrue(all_valid)

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
 def findFeaturesAt(mapPoint, layerConfig, mapTool):
     """
     To find features from a given position in a given layer
     :param mapPoint: the map position
     :param layerConfig: the layer in which we are looking for features
     :param mapTool: a QgsMapTool instance
     :return: features found in layer
     """
     if layerConfig is None:
         return None
     tolerance = layerConfig.tolerance
     if layerConfig.unit == QgsTolerance.Pixels:
         layTolerance = Finder.calcCanvasTolerance(mapTool.toCanvasCoordinates(mapPoint), layerConfig.layer, mapTool,
                                                   tolerance)
     elif layerConfig.unit == QgsTolerance.ProjectUnits:
         layTolerance = Finder.calcMapTolerance(mapPoint, layerConfig.layer, mapTool, tolerance)
     else:
         layTolerance = tolerance
     layPoint = mapTool.toLayerCoordinates(layerConfig.layer, mapPoint)
     searchRect = QgsRectangle(layPoint.x() - layTolerance, layPoint.y() - layTolerance,
                               layPoint.x() + layTolerance, layPoint.y() + layTolerance)
     request = QgsFeatureRequest()
     request.setFilterRect(searchRect)
     request.setFlags(QgsFeatureRequest.ExactIntersect)
     features = []
     for feature in layerConfig.layer.getFeatures(request):
         if layerConfig.layer.geometryType() == QGis.Polygon:
             dist, nearest, vertex = feature.geometry().closestSegmentWithContext(mapPoint)
             if QgsGeometry.fromPoint(nearest).intersects(searchRect):
                 features.append(QgsFeature(feature))
         else:
             features.append(QgsFeature(feature))
     return features

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
def clone_layer(layer, keep_selection=True):
    """Duplicate the layer by taking the same source and copying keywords.

    :param keep_selection: If we should keep the selection. Default to true.
    :type keep_selection: bool

    :param layer: Layer to be duplicated.
    :type layer: QgsMapLayer

    :return: The new QgsMapLayer object.
    :rtype: QgsMapLayer
    """
    if is_vector_layer(layer):
        new_layer = QgsVectorLayer(
            layer.source(), layer.name(), layer.providerType())
        if keep_selection and layer.selectedFeatureCount() > 0:
            request = QgsFeatureRequest()
            request.setFilterFids(layer.selectedFeatureIds())
            request.setFlags(QgsFeatureRequest.NoGeometry)
            iterator = layer.getFeatures(request)
            new_layer.setSelectedFeatures([k.id() for k in iterator])
    else:
        new_layer = QgsRasterLayer(
            layer.source(), layer.name(), layer.providerType())

    new_layer.keywords = copy_layer_keywords(layer.keywords)

    return layer

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
 def featureCount(self):
     if not self.subsetString():
         return len(self._features)
     else:
         req = QgsFeatureRequest()
         req.setFlags(QgsFeatureRequest.NoGeometry)
         req.setSubsetOfAttributes([])
         return len([f for f in self.getFeatures(req)])

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
 def uniqueValues(self, fieldIndex, limit=1):
     results = set()
     if fieldIndex >= 0 and fieldIndex < self.fields().count():
         req = QgsFeatureRequest()
         req.setFlags(QgsFeatureRequest.NoGeometry)
         req.setSubsetOfAttributes([fieldIndex])
         for f in self.getFeatures(req):
             results.add(f.attributes()[fieldIndex])
     return results

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
 def getLayerFeature(self):
     layerFeature = QgsFeature()
     featReq = QgsFeatureRequest().setFilterFid(self.layerFeatureId)
     if not self.featureLayer.hasGeometryType():
         featReq.setFlags(QgsFeatureRequest.NoGeometry)
     if self.featureLayer.getFeatures(featReq).nextFeature(layerFeature):
         return layerFeature
     else:
         return None

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
    def test_sql2(self):
        l2 = QgsVectorLayer(os.path.join(self.testDataDir, "france_parts.shp"), "france_parts", "ogr", False)
        self.assertEqual(l2.isValid(), True)
        QgsProject.instance().addMapLayer(l2)

        query = toPercent("SELECT * FROM france_parts")
        l4 = QgsVectorLayer("?query=%s&uid=ObjectId" % query, "tt", "virtual")
        self.assertEqual(l4.isValid(), True)

        self.assertEqual(l4.dataProvider().wkbType(), 3)
        self.assertEqual(l4.dataProvider().crs().postgisSrid(), 4326)

        n = 0
        r = QgsFeatureRequest(QgsRectangle(-1.677, 49.624, -0.816, 49.086))
        for f in l4.getFeatures(r):
            self.assertEqual(f.geometry() is not None, True)
            self.assertEqual(f.attributes()[0], 2661)
            n += 1
        self.assertEqual(n, 1)

        # use uid
        query = toPercent("SELECT * FROM france_parts")
        l5 = QgsVectorLayer("?query=%s&geometry=geometry:polygon:4326&uid=ObjectId" % query, "tt", "virtual")
        self.assertEqual(l5.isValid(), True)

        idSum = sum(f.id() for f in l5.getFeatures())
        self.assertEqual(idSum, 10659)

        r = QgsFeatureRequest(2661)
        idSum2 = sum(f.id() for f in l5.getFeatures(r))
        self.assertEqual(idSum2, 2661)

        r = QgsFeatureRequest()
        r.setFilterFids([2661, 2664])
        self.assertEqual(sum(f.id() for f in l5.getFeatures(r)), 2661 + 2664)

        # test attribute subset
        r = QgsFeatureRequest()
        r.setFlags(QgsFeatureRequest.SubsetOfAttributes)
        r.setSubsetOfAttributes([1])
        s = [(f.id(), f.attributes()[1]) for f in l5.getFeatures(r)]
        self.assertEqual(sum([x[0] for x in s]), 10659)
        self.assertEqual(sum([x[1] for x in s]), 3064.0)

        # test NoGeometry
        # by request flag
        r = QgsFeatureRequest()
        r.setFlags(QgsFeatureRequest.NoGeometry)
        self.assertEqual(all([not f.hasGeometry() for f in l5.getFeatures(r)]), True)

        # test subset
        self.assertEqual(l5.dataProvider().featureCount(), 4)
        l5.setSubsetString("ObjectId = 2661")
        idSum2 = sum(f.id() for f in l5.getFeatures(r))
        self.assertEqual(idSum2, 2661)
        self.assertEqual(l5.dataProvider().featureCount(), 1)

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
    def layerData(self, layer, request={}, offset=0):
        # Retrieve the data for a layer
        first = True
        data = {}
        fields = []
        fieldTypes = []
        fr = QgsFeatureRequest()
        if request:
            if 'exact' in request and request['exact']:
                fr.setFlags(QgsFeatureRequest.ExactIntersect)
            if 'nogeom' in request and request['nogeom']:
                fr.setFlags(QgsFeatureRequest.NoGeometry)
            if 'fid' in request:
                fr.setFilterFid(request['fid'])
            elif 'extents' in request:
                fr.setFilterRect(QgsRectangle(*request['extents']))
            if 'attributes' in request:
                fr.setSubsetOfAttributes(request['attributes'])

        # IMPORTANT - we do not use `for f in layer.getFeatures(fr):` as we need
        # to verify that existing attributes and geometry are correctly cleared
        # from the feature when calling nextFeature()
        it = layer.getFeatures(fr)
        f = QgsFeature()
        while it.nextFeature(f):
            if first:
                first = False
                for field in f.fields():
                    fields.append(str(field.name()))
                    fieldTypes.append(str(field.typeName()))
            if sys.version_info.major == 2:
                fielddata = dict((name, str(f[name])) for name in fields)
            else:
                fielddata = dict((name, str(f[name])) for name in fields)
            g = f.geometry()
            if not g.isEmpty():
                fielddata[geomkey] = str(g.exportToWkt())
            else:
                fielddata[geomkey] = "None"

            fielddata[fidkey] = f.id()
            id = fielddata[fields[0]]
            description = fielddata[fields[1]]
            fielddata['id'] = id
            fielddata['description'] = description
            data[f.id() + offset] = fielddata

        if 'id' not in fields:
            fields.insert(0, 'id')
        if 'description' not in fields:
            fields.insert(1, 'description')
        fields.append(fidkey)
        fields.append(geomkey)
        return fields, fieldTypes, data

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
    def search(self):
        project = QgsProject.instance()
        layerId, ok = project.readEntry(self.pluginName, 'layerId')
        fieldName, ok = project.readEntry(self.pluginName, 'fieldName')
        pattern = self.searchText.text()

        self.layer = QgsMapLayerRegistry.instance().mapLayer(layerId)
        if self.layer is None:
            self.iface.messageBar().pushMessage(self.name,
                self.tr("Choose a layer first in settings dialog."),
                QgsMessageBar.WARNING, 3)
            self.showSettings()
            return

        if fieldName == "":
            self.iface.messageBar().pushMessage(self.name,
                self.tr("Choose a field first in settings dialog."),
                QgsMessageBar.WARNING, 3)
            self.showSettings()
            return
        fields = self.layer.dataProvider().fields()
        fieldIndex = fields.indexFromName(fieldName)

        # create feature request
        featReq = QgsFeatureRequest()
        featReq.setFlags(QgsFeatureRequest.NoGeometry)
        featReq.setSubsetOfAttributes([fieldIndex])
        iterator = self.layer.getFeatures(featReq)

        # process search
        f = QgsFeature()
        results = []
        self.continueSearch = True
        while iterator.nextFeature(f) and self.continueSearch:
            if self.evaluate(f[fieldName], pattern):
                results.append(f.id())
            QCoreApplication.processEvents()

        # process results
        if self.continueSearch:
            msg = self.tr("{} features found").format(len(results))

            legend = self.iface.legendInterface()
            if (not legend.isLayerVisible(self.layer)):
                msg += self.tr(' - The layer named {} is not visible').format(self.layer.name())

            self.iface.messageBar().pushMessage(self.name,
                msg,
                QgsMessageBar.INFO, 2)

            self.processResults(results)

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
 def getFeatIdList(self, currentLayer):
     #getting all features ids
     if self.mFieldExpressionWidget.currentText() == '':
         featIdList = currentLayer.allFeatureIds()
     elif not self.mFieldExpressionWidget.isValidExpression():
         self.iface.messageBar().pushMessage(self.tr('Warning!'), self.tr('Invalid attribute filter!'), level=QgsMessageBar.WARNING, duration=2)
         return []
     else:
         request = QgsFeatureRequest().setFilterExpression(self.mFieldExpressionWidget.asExpression())
         request.setFlags(QgsFeatureRequest.NoGeometry)
         featIdList = [i.id() for i in currentLayer.getFeatures(request)]
     #sort is faster than sorted (but sort is just available for lists)
     featIdList.sort()
     return featIdList

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
 def removeLastFeatures(self):
   self.isIniEditable = self.layerPolygon.isEditable()
   if not self.isIniEditable:
     self.layerPolygon.startEditing()
   exp = QgsExpression( '"id_add" = {}'.format( self.getMaximumValueAdd() ) )
   request = QgsFeatureRequest( exp )
   request.setFlags( QgsFeatureRequest.NoGeometry )
   it = self.layerPolygon.getFeatures( request )
   for feat in it:
     self.layerPolygon.deleteFeature( feat.id()  )
   self.layerPolygon.commitChanges()
   if self.isIniEditable:
     self.layerPolygon.startEditing()
   self.layerPolygon.updateExtents()
   self.dockWidgetGui.btnRemoveLastFeatures.setEnabled( False )

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
    def draw (self, resetStyle = False):
        xField = self.xProperty.currentText()
        yField = self.yProperty.currentText()
        
        #X-Axis limits
        self.xMinTime.setVisible (xField == 'Time')
        self.xMaxTime.setVisible (xField == 'Time')
        self.xMinFloat.setVisible(xField != 'Time')
        self.xMaxFloat.setVisible(xField != 'Time')
        self.xMin = self.xMinFloat if xField != 'Time' else self.xMinTime
        self.xMax = self.xMaxFloat if xField != 'Time' else self.xMaxTime
        #Y-Axis limits
        self.yMinTime.setVisible (yField == 'Time')
        self.yMaxTime.setVisible (yField == 'Time')
        self.yMinFloat.setVisible(yField != 'Time')
        self.yMaxFloat.setVisible(yField != 'Time')
        self.yMin = self.yMinFloat if yField != 'Time' else self.yMinTime
        self.yMax = self.yMaxFloat if yField != 'Time' else self.yMaxTime 
        
        ySorted = self.ySorted.isChecked()
        
        self.plotWidget.clean (xField = xField,
                               yField = yField,
                               resetStyle = resetStyle)

        request = QgsFeatureRequest ()
        request.setFlags(QgsFeatureRequest.NoGeometry)
                
        for foi in self.foiList:
            request.setFilterExpression("foi = '%s'" % foi)
            if ySorted:
                dataSerie = [(f.attribute(yField),f.attribute(xField)) for f in self.layer.getFeatures(request)]
            else:
                dataSerie = [(f.attribute(xField),f.attribute(yField)) for f in self.layer.getFeatures(request)]
            dataSerie.sort()
            
            if len (dataSerie):
                if ySorted:
                    y,x = map(list, zip(*dataSerie))
                else:
                    x,y = map(list, zip(*dataSerie))
                self.plotWidget.plot(x,y, f.attribute('name'))
                self.plotWidget.applyTimeFormat (self.timeFormat.text())
                self.plotWidget.draw ()
        
        styles = self.StylesTable (self.plotWidget.ax.get_lines())
        self.stylesTable.setModel (styles)
        styles.dataChanged.connect(self.plotWidget.draw)

# 需要导入模块: from qgis.core import QgsFeatureRequest [as 别名]
# 或者: from qgis.core.QgsFeatureRequest import setFlags [as 别名]
def is25d(layer, canvas, restrictToExtent, extent):
    if layer.type() != layer.VectorLayer:
        return False
    if layer.geometryType() != QgsWkbTypes.PolygonGeometry:
        return False
    vts = layer.customProperty("VectorTilesReader/vector_tile_source")
    if vts is not None:
        return False
    renderer = layer.renderer()
    if isinstance(renderer, Qgs25DRenderer):
        return True
    symbols = []
    if isinstance(renderer, QgsCategorizedSymbolRenderer):
        categories = renderer.categories()
        for category in categories:
            symbols.append(category.symbol())
    elif isinstance(renderer, QgsGraduatedSymbolRenderer):
        ranges = renderer.ranges()
        for range in ranges:
            symbols.append(range.symbol())
    elif isinstance(renderer, QgsRuleBasedRenderer):
        rules = renderer.rootRule().children()
        for rule in rules:
            symbols.append(rule.symbol())
    else:
        renderContext = QgsRenderContext.fromMapSettings(canvas.mapSettings())
        fields = layer.fields()
        if restrictToExtent and extent == "Canvas extent":
            request = QgsFeatureRequest(canvas.extent())
            request.setFlags(QgsFeatureRequest.ExactIntersect)
            features = layer.getFeatures(request)
        else:
            features = layer.getFeatures()
        renderer.startRender(renderContext, fields)
        for feature in features:
            symbol = renderer.symbolForFeature(feature, renderContext)
            symbols.append(symbol)
        renderer.stopRender(renderContext)
    for sym in symbols:
        sl1 = sym.symbolLayer(1)
        sl2 = sym.symbolLayer(2)
        if (isinstance(sl1, QgsGeometryGeneratorSymbolLayer) and
                isinstance(sl2, QgsGeometryGeneratorSymbolLayer)):
            return True
    return False