Python QgsProcessingUtils.getFeatures方法代码示例

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        filename = self.getParameterValue(self.INPUT)
        inputLayer = QgsProcessingUtils.mapLayerFromString(filename, context)
        method = self.getParameterValue(self.METHOD)
        filename2 = self.getParameterValue(self.INTERSECT)
        selectLayer = QgsProcessingUtils.mapLayerFromString(filename2, context)
        predicates = self.getParameterValue(self.PREDICATE)
        precision = self.getParameterValue(self.PRECISION)

        oldSelection = set(inputLayer.selectedFeatureIds())
        inputLayer.removeSelection()
        index = QgsProcessingUtils.createSpatialIndex(inputLayer, context)

        if 'disjoint' in predicates:
            disjoinSet = []
            for feat in QgsProcessingUtils.getFeatures(inputLayer, context):
                disjoinSet.append(feat.id())

        geom = QgsGeometry()
        selectedSet = []
        features = QgsProcessingUtils.getFeatures(selectLayer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(selectLayer, context)
        for current, f in enumerate(features):
            geom = vector.snapToPrecision(f.geometry(), precision)
            bbox = geom.boundingBox()
            bbox.grow(0.51 * precision)
            intersects = index.intersects(bbox)

            request = QgsFeatureRequest().setFilterFids(intersects).setSubsetOfAttributes([])
            for feat in inputLayer.getFeatures(request):
                tmpGeom = vector.snapToPrecision(feat.geometry(), precision)

                res = False
                for predicate in predicates:
                    if predicate == 'disjoint':
                        if tmpGeom.intersects(geom):
                            try:
                                disjoinSet.remove(feat.id())
                            except:
                                pass  # already removed
                    else:
                        res = getattr(tmpGeom, predicate)(geom)
                        if res:
                            selectedSet.append(feat.id())
                            break

            feedback.setProgress(int(current * total))

        if 'disjoint' in predicates:
            selectedSet = selectedSet + disjoinSet

        if method == 1:
            selectedSet = list(oldSelection.union(selectedSet))
        elif method == 2:
            selectedSet = list(oldSelection.difference(selectedSet))

        inputLayer.selectByIds(selectedSet)
        self.setOutputValue(self.OUTPUT, filename)

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        filename = self.getParameterValue(self.INPUT)
        layer = QgsProcessingUtils.mapLayerFromString(filename, context)
        filename = self.getParameterValue(self.INTERSECT)
        selectLayer = QgsProcessingUtils.mapLayerFromString(filename, context)
        predicates = self.getParameterValue(self.PREDICATE)
        precision = self.getParameterValue(self.PRECISION)

        index = QgsProcessingUtils.createSpatialIndex(layer, context)

        output = self.getOutputFromName(self.OUTPUT)
        writer = output.getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        if 'disjoint' in predicates:
            disjoinSet = []
            for feat in QgsProcessingUtils.getFeatures(layer, context):
                disjoinSet.append(feat.id())

        selectedSet = []
        features = QgsProcessingUtils.getFeatures(selectLayer, context)
        total = 100.0 / selectLayer.featureCount() if selectLayer.featureCount() else 0
        for current, f in enumerate(features):
            geom = vector.snapToPrecision(f.geometry(), precision)
            bbox = geom.boundingBox()
            bbox.grow(0.51 * precision)
            intersects = index.intersects(bbox)
            request = QgsFeatureRequest().setFilterFids(intersects).setSubsetOfAttributes([])
            for feat in layer.getFeatures(request):
                tmpGeom = vector.snapToPrecision(feat.geometry(), precision)
                res = False
                for predicate in predicates:
                    if predicate == 'disjoint':
                        if tmpGeom.intersects(geom):
                            try:
                                disjoinSet.remove(feat.id())
                            except:
                                pass  # already removed
                    else:
                        res = getattr(tmpGeom, predicate)(geom)
                        if res:
                            selectedSet.append(feat.id())
                            break

            feedback.setProgress(int(current * total))

        if 'disjoint' in predicates:
            selectedSet = selectedSet + disjoinSet

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / layer.featureCount() if layer.featureCount() else 0
        for current, f in enumerate(features):
            if f.id() in selectedSet:
                writer.addFeature(f, QgsFeatureSink.FastInsert)
            feedback.setProgress(int(current * total))
        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def convertUnsupportedFormats(self, context, feedback):
        i = 0
        feedback.setProgressText(self.tr('Converting outputs'))
        for out in self.outputs:
            if isinstance(out, OutputVector):
                if out.compatible is not None:
                    layer = QgsProcessingUtils.mapLayerFromString(out.compatible, context)
                    if layer is None:
                        # For the case of memory layer, if the
                        # getCompatible method has been called
                        continue
                    writer = out.getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)
                    features = QgsProcessingUtils.getFeatures(layer, context)
                    for feature in features:
                        writer.addFeature(feature, QgsFeatureSink.FastInsert)
            elif isinstance(out, OutputRaster):
                if out.compatible is not None:
                    layer = QgsProcessingUtils.mapLayerFromString(out.compatible, context)
                    format = self.getFormatShortNameFromFilename(out.value)
                    orgFile = out.compatible
                    destFile = out.value
                    crsid = layer.crs().authid()
                    settings = QgsSettings()
                    path = str(settings.value('/GdalTools/gdalPath', ''))
                    envval = str(os.getenv('PATH'))
                    if not path.lower() in envval.lower().split(os.pathsep):
                        envval += '%s%s' % (os.pathsep, path)
                        os.putenv('PATH', envval)
                    command = 'gdal_translate -of %s -a_srs %s %s %s' % (format, crsid, orgFile, destFile)
                    if os.name == 'nt':
                        command = command.split(" ")
                    else:
                        command = [command]
                    proc = subprocess.Popen(
                        command,
                        shell=True,
                        stdout=subprocess.PIPE,
                        stdin=subprocess.PIPE,
                        stderr=subprocess.STDOUT,
                        universal_newlines=False,
                    )
                    proc.communicate()

            elif isinstance(out, OutputTable):
                if out.compatible is not None:
                    layer = QgsProcessingUtils.mapLayerFromString(out.compatible, context)
                    writer = out.getTableWriter(layer.fields())
                    features = QgsProcessingUtils.getFeatures(layer, context)
                    for feature in features:
                        writer.addRecord(feature)
            feedback.setProgress(100 * i / float(len(self.outputs)))

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        filename = self.getParameterValue(self.INPUT)

        layer = QgsProcessingUtils.mapLayerFromString(filename, context)
        field = self.getParameterValue(self.FIELD)
        method = self.getParameterValue(self.METHOD)

        index = layer.fields().lookupField(field)

        features = QgsProcessingUtils.getFeatures(layer, context)
        featureCount = QgsProcessingUtils.featureCount(layer, context)
        unique = QgsProcessingUtils.uniqueValues(layer, index, context)
        value = int(self.getParameterValue(self.NUMBER))
        if method == 0:
            if value > featureCount:
                raise GeoAlgorithmExecutionException(
                    self.tr('Selected number is greater that feature count. '
                            'Choose lesser value and try again.'))
        else:
            if value > 100:
                raise GeoAlgorithmExecutionException(
                    self.tr("Percentage can't be greater than 100. Set "
                            "correct value and try again."))
            value = value / 100.0

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(),
                                                                     layer.crs(), context)

        selran = []
        total = 100.0 / (featureCount * len(unique))
        features = QgsProcessingUtils.getFeatures(layer, context)

        classes = defaultdict(list)
        for i, feature in enumerate(features):
            attrs = feature.attributes()
            classes[attrs[index]].append(feature)
            feedback.setProgress(int(i * total))

        for subset in classes.values():
            selValue = value if method != 1 else int(round(value * len(subset), 0))
            selran.extend(random.sample(subset, selValue))

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
        for (i, feat) in enumerate(selran):
            writer.addFeature(feat)
            feedback.setProgress(int(i * total))
        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)

        fields = layer.fields()
        fields.append(QgsField('node_index', QVariant.Int))
        fields.append(QgsField('distance', QVariant.Double))
        fields.append(QgsField('angle', QVariant.Double))

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
        for current, f in enumerate(features):
            input_geometry = f.geometry()
            if not input_geometry:
                writer.addFeature(f)
            else:
                points = vector.extractPoints(input_geometry)

                for i, point in enumerate(points):
                    distance = input_geometry.distanceToVertex(i)
                    angle = math.degrees(input_geometry.angleAtVertex(i))
                    attrs = f.attributes()
                    attrs.append(i)
                    attrs.append(distance)
                    attrs.append(angle)
                    output_feature = QgsFeature()
                    output_feature.setAttributes(attrs)
                    output_feature.setGeometry(QgsGeometry.fromPoint(point))
                    writer.addFeature(output_feature)

            feedback.setProgress(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)
        max_iterations = self.getParameterValue(self.MAX_ITERATIONS)
        angle_tolerance = self.getParameterValue(self.ANGLE_TOLERANCE)
        writer = self.getOutputFromName(
            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

        for current, input_feature in enumerate(features):
            output_feature = input_feature
            input_geometry = input_feature.geometry()
            if input_geometry:
                output_geometry = input_geometry.orthogonalize(1.0e-8, max_iterations, angle_tolerance)
                if not output_geometry:
                    raise GeoAlgorithmExecutionException(
                        self.tr('Error orthogonalizing geometry'))

                output_feature.setGeometry(output_geometry)

            writer.addFeature(output_feature)
            feedback.setProgress(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
        fieldName = self.getParameterValue(self.FIELD)
        idx = layer.fields().lookupField(fieldName)

        fields = layer.fields()
        fields[idx] = QgsField(fieldName, QVariant.Double, '', 24, 15)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)

        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
        for current, f in enumerate(features):
            value = f[idx]
            try:
                if '%' in value:
                    f[idx] = float(value.replace('%', '')) / 100.0
                else:
                    f[idx] = float(value)
            except:
                f[idx] = None

            writer.addFeature(f)
            feedback.setProgress(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        filename = self.getParameterValue(self.INPUT)
        layer = QgsProcessingUtils.mapLayerFromString(filename, context)
        method = self.getParameterValue(self.METHOD)

        features = QgsProcessingUtils.getFeatures(layer, context)
        featureCount = QgsProcessingUtils.featureCount(layer, context)
        value = int(self.getParameterValue(self.NUMBER))

        if method == 0:
            if value > featureCount:
                raise GeoAlgorithmExecutionException(
                    self.tr('Selected number is greater than feature count. '
                            'Choose a lower value and try again.'))
        else:
            if value > 100:
                raise GeoAlgorithmExecutionException(
                    self.tr("Percentage can't be greater than 100. Set a "
                            "different value and try again."))
            value = int(round(value / 100.0000, 4) * featureCount)

        selran = random.sample(list(range(featureCount)), value)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(),
                                                                     layer.crs(), context)

        total = 100.0 / featureCount
        for i, feat in enumerate(features):
            if i in selran:
                writer.addFeature(feat)
            feedback.setProgress(int(i * total))
        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        delta_x = self.getParameterValue(self.DELTA_X)
        delta_y = self.getParameterValue(self.DELTA_Y)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

        for current, input_feature in enumerate(features):
            output_feature = input_feature
            input_geometry = input_feature.geometry()
            if input_geometry:
                output_geometry = input_geometry
                output_geometry.translate(delta_x, delta_y)
                if not output_geometry:
                    raise GeoAlgorithmExecutionException(
                        self.tr('Error translating geometry'))

                output_feature.setGeometry(output_geometry)

            writer.addFeature(output_feature)
            feedback.setProgress(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)

        writer = self.getOutputFromName(
            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / layer.featureCount() if layer.featureCount() else 0

        for current, inFeat in enumerate(features):
            outFeat = QgsFeature()
            attrs = inFeat.attributes()
            outFeat.setAttributes(attrs)

            inGeom = inFeat.geometry()
            if inGeom:
                outGeom = inGeom.mergeLines()
                if outGeom is None:
                    raise GeoAlgorithmExecutionException(
                        self.tr('Error merging lines'))

                outFeat.setGeometry(outGeom)

            writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
            feedback.setProgress(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def layerOmmb(self, layer, context, writer, feedback):
        req = QgsFeatureRequest().setSubsetOfAttributes([])
        features = QgsProcessingUtils.getFeatures(layer, context, req)
        total = 100.0 / layer.featureCount() if layer.featureCount() else 0
        newgeometry = QgsGeometry()
        first = True
        for current, inFeat in enumerate(features):
            if first:
                newgeometry = inFeat.geometry()
                first = False
            else:
                newgeometry = newgeometry.combine(inFeat.geometry())
            feedback.setProgress(int(current * total))

        geometry, area, angle, width, height = newgeometry.orientedMinimumBoundingBox()

        if geometry:
            outFeat = QgsFeature()

            outFeat.setGeometry(geometry)
            outFeat.setAttributes([area,
                                   width * 2 + height * 2,
                                   angle,
                                   width,
                                   height])
            writer.addFeature(outFeat, QgsFeatureSink.FastInsert)

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)
        iterations = self.getParameterValue(self.ITERATIONS)
        offset = self.getParameterValue(self.OFFSET)
        max_angle = self.getParameterValue(self.MAX_ANGLE)

        writer = self.getOutputFromName(
            self.OUTPUT_LAYER).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(), context)

        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)

        for current, input_feature in enumerate(features):
            output_feature = input_feature
            if input_feature.geometry():
                output_geometry = input_feature.geometry().smooth(iterations, offset, -1, max_angle)
                if not output_geometry:
                    raise GeoAlgorithmExecutionException(
                        self.tr('Error smoothing geometry'))

                output_feature.setGeometry(output_geometry)

            writer.addFeature(output_feature)
            feedback.setProgress(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def regularMatrix(self, context, inLayer, inField, targetLayer, targetField,
                      nPoints, feedback):
        index = QgsProcessingUtils.createSpatialIndex(targetLayer, context)

        inIdx = inLayer.fields().lookupField(inField)

        distArea = QgsDistanceArea()

        first = True
        features = QgsProcessingUtils.getFeatures(inLayer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(inLayer, context)
        for current, inFeat in enumerate(features):
            inGeom = inFeat.geometry()
            inID = str(inFeat.attributes()[inIdx])
            featList = index.nearestNeighbor(inGeom.asPoint(), nPoints)
            if first:
                first = False
                data = ['ID']
                for i in range(len(featList)):
                    data.append('DIST_{0}'.format(i + 1))
                self.writer.addRecord(data)

            data = [inID]
            for i in featList:
                request = QgsFeatureRequest().setFilterFid(i)
                outFeat = next(targetLayer.getFeatures(request))
                outGeom = outFeat.geometry()
                dist = distArea.measureLine(inGeom.asPoint(),
                                            outGeom.asPoint())
                data.append(str(float(dist)))
            self.writer.addRecord(data)

            feedback.setProgress(int(current * total))

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon,
                                                                     layer.crs(), context)

        outFeat = QgsFeature()
        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
        for current, f in enumerate(features):
            outGeomList = []
            if f.geometry().isMultipart():
                outGeomList = f.geometry().asMultiPolyline()
            else:
                outGeomList.append(f.geometry().asPolyline())

            polyGeom = self.removeBadLines(outGeomList)
            if len(polyGeom) != 0:
                outFeat.setGeometry(QgsGeometry.fromPolygon(polyGeom))
                attrs = f.attributes()
                outFeat.setAttributes(attrs)
                writer.addFeature(outFeat)

            feedback.setProgress(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsProcessingUtils [as 别名]
# 或者: from qgis.core.QgsProcessingUtils import getFeatures [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
        crsId = self.getParameterValue(self.TARGET_CRS)
        targetCrs = QgsCoordinateReferenceSystem()
        targetCrs.createFromUserInput(crsId)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(),
                                                                     targetCrs, context)

        layerCrs = layer.crs()
        crsTransform = QgsCoordinateTransform(layerCrs, targetCrs)

        outFeat = QgsFeature()
        features = QgsProcessingUtils.getFeatures(layer, context)
        total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
        for current, f in enumerate(features):
            geom = f.geometry()
            geom.transform(crsTransform)
            outFeat.setGeometry(geom)
            outFeat.setAttributes(f.attributes())
            writer.addFeature(outFeat)

            feedback.setProgress(int(current * total))

        del writer

        self.crs = targetCrs