QGIS Processing Toolbox script om snel selecties te maken in HWBP faalmechanismen en categorieen

qgis_hwbp_score_filter.py

# note, code is not clean yet so it will have some unused imports
# it expects a vectorlayer with columns like STPH, STBI, etc
# and the scores as -, Iv, IIv, IIIv, IVv, Vv, VIv, VIIv
# if will not be useful if your data is formatted differently
# but maybe then it is an inspiration for creating your own filters ;-)
#
# Rob van Putten | breinbaasnl@gmail.com | feb 2024
#

"""
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""

from qgis.PyQt.QtCore import QCoreApplication
from qgis.core import (
    QgsProcessing,
    QgsFeatureSink,
    QgsProcessingException,
    QgsProcessingAlgorithm,
    QgsProcessingParameterFeatureSource,
    QgsProcessingParameterFeatureSink,
    QgsExpression,
    QgsFeatureRequest,
    QgsVectorLayer,
    QgsProcessingParameterEnum,
)
from qgis import processing
from qgis.utils import iface

FAILUREMECHANISM_NAMES = [
    "STPH",
    "STBI",
    "STBU",
    "STMI",
    "GEKB",
    "GEBU",
    "GABU",
    "ZST",
    "AGK",
    "AWO",
    "HTKW",
    "BSKW",
    "PKW",
    "STKWp",
    "STKWI",
]

CLASS_NAMES = ["Iv", "IIv", "IIIv", "IVv", "Vv", "VIv", "VIIv"]


def create_class_query(failure_mechanism: str, min_class: str) -> str:
    if min_class == "VIIv":
        return f"\"{failure_mechanism}\" = '{min_class}'"

    query = f'"{failure_mechanism}" ='
    for i in range(CLASS_NAMES.index(min_class), len(CLASS_NAMES)):
        if i == CLASS_NAMES.index(min_class):
            query += f"'{CLASS_NAMES[i]}'"
        else:
            query += f" OR \"{failure_mechanism}\"='{CLASS_NAMES[i]}'"

    return query


class ExampleProcessingAlgorithm(QgsProcessingAlgorithm):
    INPUT = "INPUT"
    FAILUREMECHANISM = "FAILUREMECHANISM"
    MINCLASS = "MINCLASS"

    def tr(self, string):
        return QCoreApplication.translate("Processing", string)

    def createInstance(self):
        return ExampleProcessingAlgorithm()

    def name(self):
        return "hwbp_score_filter"

    def displayName(self):
        return self.tr("Score Filter")

    def group(self):
        return self.tr("LeveeLogic")

    def groupId(self):
        return "LeveeLogic"

    def shortHelpString(self):
        return self.tr("Filter toetsresultaten per faalmechanisme op de gewenste categorie. Selecteer hiervoor het gewenste faalmechanisme en de gewenste minimale categorie waarna het filter toegepast zal worden op de geselecteerde shape.")

    def initAlgorithm(self, config=None):
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT,
                self.tr("Input layer"),
                [QgsProcessing.TypeVectorAnyGeometry],
            )
        )

        self.addParameter(
            QgsProcessingParameterEnum(
                name=self.FAILUREMECHANISM,
                description="Faalmechanisme",
                options=FAILUREMECHANISM_NAMES,
                defaultValue=0,
            )
        )

        self.addParameter(
            QgsProcessingParameterEnum(
                name=self.MINCLASS,
                description="categorie ondergrens",
                options=CLASS_NAMES,
                defaultValue=4,
            )
        )

    def processAlgorithm(self, parameters, context, feedback):
        """
        Here is where the processing itself takes place.
        """
        layer = self.parameterAsVectorLayer(parameters, "input", context)
        # get the selected failure mechanism
        f_idx = self.parameterAsInt(parameters, self.FAILUREMECHANISM, context)
        f_str = FAILUREMECHANISM_NAMES[f_idx]
        # get the selected minimal class
        c_idx = self.parameterAsInt(parameters, self.MINCLASS, context)
        c_str = CLASS_NAMES[c_idx]
        expression_str = create_class_query(f_str, c_str)
        layer.setSubsetString(expression_str)

        return {}