def main(iface, layers, workspace, d_velden_):
"""Hoofdmenu:
1.) Kopie maken INPUT_POLYGON_LIS
2.) Spatial joins tussen POLYGON_LIS en de externe gegevens bronnen.
3.) Velden toevoegen en gegevens overnemen
4.) Bereken onderbemaling voor DRINKWATER, PLANCAP en VE's
5.) alle None vervangen door 0
6.) berekeningen uitvoeren
7.) resultaat omzetten naar template (als "template" bestaat)
8.) add results to map
"""
global g_iface, INP_SKIP_SPJOIN, gdb, l_src_None_naar_0_omzetten, d_velden_tmp, d_velden
d_velden = d_velden_
g_iface = iface
INP_SKIP_SPJOIN = False
# laod from settings
gdb = workspace
l_src_None_naar_0_omzetten = settings.l_fld_None_naar_0_omzetten # velden waarvan waardes worden omgezet van None naar 0
d_velden_tmp = settings.d_velden_tmp # tijdelijke velden
# layers
inp_knooppunten, inp_afvoerrelaties, inp_drinkwater_bag, inp_ve_belasting, inp_plancap, inp_verhard_opp, inp_polygon = layers
for i, layer in enumerate(layers):
print_log("input {}:\t{}".format(i, layer.name()), "d")
# tussenresultaten
EINDRESULTAAT = os.path.join(gdb, "eindresultaat.shp")
POLYGON_LIS = os.path.join(gdb, "POLYGON_LIS.shp")
DRINKWATER_POLYGON_LIS = os.path.join(gdb,
"SpJoin_DRINKWATER2POLYGON_LIS.shp")
PLANCAP_POLYGON_LIS = os.path.join(gdb, "SpJoin_PLANCAP2POLYGON_LIS.shp")
VE_POLYGON_LIS = os.path.join(gdb, "SpJoin_VE2POLYGON_LIS.shp")
PLANCAP_OVERLAP = os.path.join(gdb, "PLANCAP_OVERLAP.shp")
STATS_DRINKWATER = os.path.join(gdb, "STATS_DRINKWATER.shp")
STATS_PLANCAP = os.path.join(gdb, "STATS_PLANCAP.shp")
STATS_VE = os.path.join(gdb, "STATS_VE.shp")
EXP_VERHARD_OPP = os.path.join(gdb, "EXP_VERHARD_OPP.shp")
VERHARD_OPP_INTERSECT = os.path.join(gdb, "VERHARD_OPP_INTERSECT.shp")
STATS_VERHARD_OPP = os.path.join(gdb, "STATS_VERHARD_OPP.shp")
# ##########################################################################
# 1.) export input INP_POLYGON_LIS to result POLYGON_LIS
tussenresultaat = QgsVectorLayer(POLYGON_LIS, "tussenresultaat", "ogr")
if EINDRESULTAAT:
QgsVectorFileWriter.deleteShapeFile(EINDRESULTAAT)
QgsVectorFileWriter.writeAsVectorFormat(tussenresultaat, EINDRESULTAAT,
"utf-8", tussenresultaat.crs(),
"ESRI Shapefile")
polygon_lis = QgsVectorLayer(EINDRESULTAAT, "eindresultaat", "ogr")
polygon_lis = add_layer(polygon_lis)
# ##########################################################################
# 2.) Velden toevoegen en gegevens overnemen
add_field_from_dict_label(polygon_lis, "st2a", d_velden)
# ##########################################################################
# 3.) Spatial joins tussen polygon_lis en de externe gegevens bronnen
if INP_SKIP_SPJOIN:
blokje_log(
"Skip SpatialJoin met externe inputs en gebruik bestaande STAT-tabellen.",
"i")
stats_drinkwater = QgsVectorLayer(STATS_DRINKWATER, "stats_drinkwater",
"ogr")
stats_ve = QgsVectorLayer(STATS_VE, "stats_ve", "ogr")
stats_plancap = QgsVectorLayer(STATS_PLANCAP, "stats_plancap", "ogr")
stats_drinkwater = add_layer(stats_drinkwater)
stats_ve = add_layer(stats_ve)
stats_plancap = add_layer(stats_plancap)
# for layer in [stats_drinkwater, stats_ve, stats_plancap]:
# layer = add_layer(layer)
else:
blokje_log(
"Start SpatialJoin externe bronnen met hoofdbemalingsgebieden... (1 tot 5 minuten)",
"i")
stats_drinkwater, stats_ve, stats_plancap = spjoin_bronbestanden_aan_bemalingsgebieden(
polygon_lis, inp_drinkwater_bag, inp_ve_belasting, inp_plancap,
inp_polygon, PLANCAP_OVERLAP, STATS_DRINKWATER, STATS_VE,
STATS_PLANCAP)
blokje_log(
"Velden toevoegen en voorbereiden voor berekening onderbemaling...",
"i")
# join stat_fields to polygon_lis
join_field(polygon_lis, stats_drinkwater, "PAR_RESULT", "SUMPAR_M3U",
"OBJECTID", "OBJECTID")
join_field(polygon_lis, stats_drinkwater, "ZAK_RESULT", "SUMZAK_M3U",
"OBJECTID", "OBJECTID")
join_field(polygon_lis, stats_drinkwater, "X_WON_GEB", "count", "OBJECTID",
"OBJECTID")
join_field(polygon_lis, stats_plancap, "AW_15_24_G", "sumExtra_A",
"OBJECTID", "OBJECTID") # SUM_Extra_AFW_2015_tm_2024
join_field(polygon_lis, stats_plancap, "AW_25_50_G", "sumExtra_1",
"OBJECTID", "OBJECTID") # SUM_Extra_AFW_2025_tm_2050
if stats_ve:
join_field(polygon_lis, stats_ve, "X_VE_GEB", "sumGRONDSL", "OBJECTID",
"OBJECTID")
# bereken drinkwater per gebied (input voor onderbemalingen) en LEDIG_U (ledigingstijd)
##bereken_veld(polygon_lis, "DWR_GEBIED", d_velden)
bereken_veld_label(polygon_lis, "02_ber", d_velden)
# ##########################################################################
# 4.) Bereken onderbemaling voor DRINKWATER en PLANCAP en VE's
blokje_log("bereken onderbemalingen voor drinkwater, plancap en ve's...",
"i")
bereken_onderbemaling(polygon_lis)
vervang_None_door_0_voor_velden_in_lijst(l_src_None_naar_0_omzetten,
polygon_lis)
# ##########################################################################
# 6.) berekeningen uitvoeren
# bereken dwa prognose & drinkwater per gebied
# "bereken": "b2a"
bereken_veld_label(polygon_lis, "04_ber", d_velden)
bereken_veld_label(polygon_lis, "04a_ber", d_velden)
# Vergelijk geschat en gemeten zonder
# "bereken": "b2b"
bereken_veld_label(polygon_lis, "05_ber", d_velden)
# bereken verhard opp
blokje_log("Bepaal verhard oppervlak binnen bemalingsgebieden...", "i")
bepaal_verhard_oppervlak(polygon_lis, inp_verhard_opp,
VERHARD_OPP_INTERSECT)
vervang_None_door_0_voor_velden_in_lijst([
"HA_GEM_G", "HA_VGS_G", "HA_HWA_G", "HA_OPW_G", "HA_NAG_G", "HA_OBK_G"
], polygon_lis)
# bereken velden afhankelijk van verhard opp
bereken_veld_label(polygon_lis, '07_ber', d_velden)
bereken_veld_label(polygon_lis, '08_ber', d_velden)
# bepaal onderbemaling2 afhankelijk van verhard opp
bereken_onderbemaling2(polygon_lis)
vervang_None_door_0_voor_velden_in_lijst(
["POC_B_M3_O", "POC_O_M3_O", "POC_B_M3_G", "POC_O_M3_G"], polygon_lis)
bereken_veld_label(polygon_lis, '10_ber', d_velden)
bereken_veld_label(polygon_lis, '11_ber', d_velden)
# update_datetime UPDATED
update_datetime(polygon_lis, "UPDATED")
# add field aliasses
for fld in d_velden:
index = polygon_lis.fieldNameIndex(fld)
if index != -1:
##pprint_log("update {} with alias '{}'".format(fld, d_velden[fld]["field_alias"]), "i")
polygon_lis.addAttributeAlias(index, d_velden[fld]["field_alias"])
def bepaal_verhard_oppervlak(polygon_lis, inp_verhard_opp,
VERHARD_OPP_INTERSECT):
layers = [polygon_lis]
if inp_verhard_opp.name() == "no data":
verhard_opp_intersect = None
print_log(
"'no data' geselecteerd als input voor verhard oppervlak opgegeven. Berekeningen verhard opp. worden overgeslagen",
"w", g_iface)
else:
print_log(
"Intersect {}...".format(";".join(
[polygon_lis.name(),
inp_verhard_opp.name()])), "i")
# eerst totaal verhard opp (ha) bepalen per bemalingsgebied
if not INP_SKIP_SPJOIN:
processing.runalg("saga:intersect", inp_verhard_opp, polygon_lis,
True, VERHARD_OPP_INTERSECT)
verhard_opp_intersect = QgsVectorLayer(VERHARD_OPP_INTERSECT,
"verhard_opp_intersect", "ogr")
verhard_opp_intersect = add_layer(verhard_opp_intersect)
layers.append(verhard_opp_intersect)
add_field_from_dict(verhard_opp_intersect, "HA_BEM_G", d_velden_tmp)
# opp ha berekenen
for layer in layers:
print_log("opp ha berekenen voor {}...".format(layer.name()), "i")
##d = QgsDistanceArea()
provider = layer.dataProvider()
updateMap = {}
fieldIdx = provider.fields().indexFromName('HA_BEM_G')
for f in provider.getFeatures():
opp_ha = f.geometry().area() / 10000
##opp_ha = d.measurePolygon(f.geometry().asPolygon()[0])/10000
updateMap[f.id()] = {fieldIdx: opp_ha}
provider.changeAttributeValues(updateMap)
# toevoegen velden voor PI's
add_field_from_dict_label(polygon_lis, "st3a", d_velden)
if verhard_opp_intersect == None:
return # berekeningen overslaan
print_log("bereken stats totaal opp ...", "i")
STATS_VERHARD_OPP_TOT = os.path.join(gdb, "STATS_VERHARD_OPP_TOT.csv")
if not INP_SKIP_SPJOIN:
processing.runalg("qgis:statisticsbycategories", VERHARD_OPP_INTERSECT,
"HA_BEM_G", "VAN_KNOOPN", STATS_VERHARD_OPP_TOT)
stats_verh_opp_tot = QgsVectorLayer(STATS_VERHARD_OPP_TOT,
"stats_verh_opp_totaal", "ogr")
stats_verh_opp_tot = add_layer(stats_verh_opp_tot)
# overhalen verhard opp (ha) naar eindresultaat
join_field(polygon_lis, stats_verh_opp_tot, "HA_VER_G", "sum",
"VAN_KNOOPN", "category")
# per categorie verhard opp (ha) bepalen per bemalingsgebied
for aansluiting in ["GEM", "HWA", "NAG", "OBK", "VGS"]:
STAT_NAME = os.path.join(
gdb, "{}_{}.csv".format("STATS_VERHARD_OPP", aansluiting))
where_clause = "\"AANGESL_OP\" = '{}'".format(aansluiting)
expr = QgsExpression(where_clause)
it = verhard_opp_intersect.getFeatures(QgsFeatureRequest(expr))
verhard_opp_intersect.setSelectedFeatures([i.id() for i in it])
if verhard_opp_intersect.selectedFeatureCount() == 0:
print_log(
"geen aansluiting op '{}' gevonden voor verhard opp".format(
aansluiting), "w")
continue
processing.runalg("qgis:statisticsbycategories", verhard_opp_intersect,
"HA_BEM_G", "VAN_KNOOPN", STAT_NAME)
layer = QgsVectorLayer(STAT_NAME,
"{}_{}".format("stats_verh_opp",
aansluiting), "ogr")
layer = add_layer(layer)
# velden overhalen naar eindresultaat en PI berekenen
fld_ha = "HA_{}_G".format(aansluiting)
join_field(polygon_lis, layer, fld_ha, "sum", "VAN_KNOOPN", "category")
def koppel_knooppunten_aan_bemalingsgebieden(iface, d_velden, inp_polygon,
knooppunten, inp_knooppunten):
# knooppunten koppelen aan bemalingsgebieden / gebieden voorzien van code. (sp.join)
# beginpunten selecteren (sel1)
expr = QgsExpression("\"BEGIN_EIND\" = {}".format(0))
it = knooppunten.getFeatures(QgsFeatureRequest(expr)) # iterator object
knooppunten.setSelectedFeatures([i.id() for i in it])
print_log("{} selected".format(knooppunten.selectedFeatureCount()), "d")
# bug 26L error. executing algoritm spatial join #5: export selection to prevent
QgsVectorFileWriter.writeAsVectorFormat(
knooppunten, os.path.join(gdb, "knooppunten_sel1.shp"), "utf-8",
knooppunten.crs(), "ESRI Shapefile", True)
knooppunten_sel1 = QgsVectorLayer(
os.path.join(gdb, "knooppunten_sel1.shp"), "knooppunten_sel1", "ogr")
add_layer(knooppunten_sel1)
# eindpunten selecteren (sel2)
expr = QgsExpression("\"BEGIN_EIND\" = {}".format(1))
it = knooppunten.getFeatures(QgsFeatureRequest(expr)) # iterator object
knooppunten.setSelectedFeatures([i.id() for i in it])
print_log("{} selected".format(knooppunten.selectedFeatureCount()), "d")
# bug 26L error. executing algoritm spatial join #5: export selection to prevent
QgsVectorFileWriter.writeAsVectorFormat(
knooppunten, os.path.join(gdb, "knooppunten_sel2.shp"), "utf-8",
knooppunten.crs(), "ESRI Shapefile", True)
knooppunten_sel2 = QgsVectorLayer(
os.path.join(gdb, "knooppunten_sel2.shp"), "knooppunten_sel2", "ogr")
add_layer(knooppunten_sel2)
# bemalingsgebieden selecteren die alleen eindpunten bevatten, maar geen beginpunten (eindpunt / rwzi)
# 1.) selecteer bemalingsgebieden met eindpunten
processing.runalg("qgis:selectbylocation", inp_polygon, knooppunten_sel2,
['intersects'], 0, 0)
# 2.) verwijder van selectie alles gebieden met beginpunten
processing.runalg("qgis:selectbylocation", inp_polygon, knooppunten_sel1,
['intersects'], 0, 2)
# exporteer als eindgebieden
EINDGEBIEDEN = os.path.join(gdb, "eindgebieden.shp")
QgsVectorFileWriter.writeAsVectorFormat(inp_polygon, EINDGEBIEDEN, "utf-8",
inp_polygon.crs(),
"ESRI Shapefile", True)
eindgebieden = QgsVectorLayer(EINDGEBIEDEN, "eindgebieden", "ogr")
add_layer(eindgebieden)
# nu bepalen wat de (juiste) ontbrekende knooppunten zijn om toe te voegen (moet eindpunt zijn van afvoerrelatie)
# 1.) bepaal eindknooppunten van eindgebieden
processing.runalg("qgis:selectbylocation", knooppunten_sel2, eindgebieden,
['intersects'], 0, 0)
# 2.) bepaal welke knooppunten dit zijn in kikker bestand voor juiste code VANKNOOPN
processing.runalg("qgis:selectbylocation", inp_knooppunten,
knooppunten_sel2, ['intersects'], 1, 0)
# extra knooppunten eindgebied toevoegen aan sel1 (beginpunten)
pr = knooppunten_sel1.dataProvider()
feat = QgsFeature(knooppunten_sel1.pendingFields())
for feature in inp_knooppunten.selectedFeatures():
feat.setGeometry(feature.geometry())
feat.setAttribute("VAN_KNOOPN", feature['VAN_KNOOPN'])
pr.addFeatures([feat])
# remove selections
inp_knooppunten.setSelectedFeatures([])
inp_polygon.setSelectedFeatures([])
knooppunten_sel1.setSelectedFeatures([])
# create polygon lis
processing.runalg("qgis:joinattributesbylocation", inp_polygon,
knooppunten_sel1, u'intersects', 0, 0, '', 1,
POLYGON_LIS)
processing.runalg("qgis:joinattributesbylocation", inp_polygon,
knooppunten_sel1, u'intersects', 0, 1, 'sum', 1,
POLYGON_LIS_SUM)
polygon_lis_sum = QgsVectorLayer(POLYGON_LIS_SUM, "polygon_kikker_sum",
"ogr")
polygon_lis = QgsVectorLayer(POLYGON_LIS, "polygon_kikker", "ogr")
polygon_lis.dataProvider().addAttributes([QgsField('count', QVariant.Int)])
polygon_lis.updateFields()
polygon_lis = add_layer(polygon_lis)
##fields_to_uppercase(polygon_lis) # created for sqlite usage which defaults to lowercase...
polygon_lis_sum = add_layer(polygon_lis_sum)
# join field met summary gegevens
join_field(input_table=polygon_lis,
join_table=polygon_lis_sum,
field_to_calc="count",
field_to_copy="count",
joinfield_input_table="OBJECTID",
joinfield_join_table="OBJECTID")
print_log(
"Bepaal in welk bemalingsgebied het eindpunt van afvoerrelatie ligt...",
'i')
knooppunten_sel2.setSelectedFeatures([])
processing.runalg("qgis:joinattributesbylocation", knooppunten_sel2,
polygon_lis, u'intersects', 0, 0, '', 1, EINDKNOOPPUNTEN)
eindknooppunten = QgsVectorLayer(EINDKNOOPPUNTEN, "eindknooppunten", "ogr")
eindknooppunten = add_layer(eindknooppunten)
##QgsMapLayerRegistry.instance().addMapLayer(eindknooppunten)
# invullen veld LOOST_OP met code bemalingsgebied.
add_field_from_dict_label(polygon_lis, "st1a", d_velden)
join_field(polygon_lis, eindknooppunten, "K_LOOST_OP", "VAN_KNOO_1",
"VAN_KNOOPN", "VAN_KNOOPN")
return polygon_lis
def main(iface, layers, workspace, d_velden):
''' 1.) Knooppunten exporteren, velden toevoegen.
# relaties selecteren die naar ander bemalingsgebied afvoeren. (niet volledig binnen 1 bemalingsgebied vallen)
# knooppunten selecteren die op ander bemalingsgebied afvoeren (op basis van selectie afvoerrelaties)
# knooppunten koppelen aan bemalingsgebieden / gebieden voorzien van code. (sp.join)
# eindpunten genereren van afvoerrelatie (line_to_point, select if not intersect with knooppunt)
# eindpunten voorzien van bemalingsgebied (sp.join)
# invullen veld LOOST_OP met code bemalingsgebied. '''
global g_iface, gdb, KNOOPPUNTEN, EINDKNOOPPUNTEN, POLYGON_LIS_OVERLAP, POLYGON_LIS, POLYGON_LIS_SUM, log_dir
g_iface = iface
gdb = workspace
# tussenresultaten
KNOOPPUNTEN = os.path.join(
gdb, "knooppunten.shp"
) # begin- en eindpunten van afvoerrelaties (lijn-bestand).
EINDKNOOPPUNTEN = os.path.join(
gdb,
"EINDKNOOPPUNTEN.shp") # Alle knooppunten met daarbij het eindpunt
POLYGON_LIS_OVERLAP = os.path.join(
gdb, "POLYGON_LIS_OVERLAP.shp") # bestand met gaten.
# eindresultaat
POLYGON_LIS = os.path.join(gdb, "POLYGON_LIS.shp")
POLYGON_LIS_SUM = os.path.join(gdb, "POLYGON_LIS_SUM.shp")
# laod from settings
log_dir = settings.log_dir
##INP_FIELDS_XLS = settings.INP_FIELDS_XLS
##INP_FIELDS_XLS_SHEET = settings.INP_FIELDS_XLS_SHEET
INP_FIELDS_CSV = settings.INP_FIELDS_CSV
inp_knooppunten, inp_afvoerrelaties, inp_drinkwater_bag, inp_ve_belasting, inp_plancap, inp_verhard_opp, inp_polygon = layers
for i, layer in enumerate(layers):
print_log("input {}:\t{}".format(i, layer.name()), "d")
print_log("inp_afvoerrelatie = {}".format(inp_afvoerrelaties.name()), "i")
# inp_polygon kopieren naar lege shapefile met objectid
inp_polygon = create_new_inp_polygon(inp_polygon)
# bemalingsgebieden controleren
controleer_bemalingsgebieden(inp_polygon, inp_knooppunten)
blokje_log("Knooppunten genereren...", "i")
# genereer knooppunten uit afvoerrelaties
point_layer = genereer_knooppunten(iface, inp_polygon, inp_afvoerrelaties)
blokje_log("Knooppunten koppelen aan bemalingsgebieden...", "i")
polygon_lis = koppel_knooppunten_aan_bemalingsgebieden(
iface, d_velden, inp_polygon, point_layer, inp_knooppunten)
##return None, None
# ##########################################################################
# 2.) Graph vullen met LIS [LOOST_OP], onderbemaling bepalen en wegschrijven in [ONTV_VAN]
blokje_log("Bepaal onderbemaling en aantal keer oppompen...", "i")
l_K_ONTV_VAN = lis2graph(polygon_lis)
# ##########################################################################
# 3.) Controleer overlap HOOFDBEMALINGSGEBIEDEN
blokje_log("Controleer topologie bemalingsgebieden...", "i")
controleer_spjoin(polygon_lis, "count")
polygon_lis_overlap = controleer_hoofdbemalingsgebieden(polygon_lis)
# ##########################################################################
# 4.) Velden overnemen uit Kikker
blokje_log("Overige velden overnemen uit knooppunten Kikker...", "i")
##add_field_from_dict_label(polygon_lis, "st1b", d_velden)
join_field(polygon_lis, inp_knooppunten, "K_BEM_GEB", "NAAM", "VAN_KNOOPN",
"VAN_KNOOPN")
join_field(polygon_lis, inp_knooppunten, "K_INST_TOT", "CAP_INST_M",
"VAN_KNOOPN", "VAN_KNOOPN")
join_field(polygon_lis, inp_knooppunten, "K_BR_ST_M3", "BERGING_M3",
"VAN_KNOOPN", "VAN_KNOOPN")
join_field(polygon_lis, inp_knooppunten, "K_OSH", "LAAGSTE_OS",
"VAN_KNOOPN", "VAN_KNOOPN")
return l_K_ONTV_VAN, inp_polygon
def main(iface, layers, workspace, d_velden_, l_K_ONTV_VAN, inp_polygon):
"""Hoofdmenu:
1.) Kopie maken INPUT_POLYGON_LIS
2.) Spatial joins tussen POLYGON_LIS en de externe gegevens bronnen.
3.) Velden toevoegen en gegevens overnemen
4.) Bereken onderbemaling voor DRINKWATER, PLANCAP en VE's
5.) alle None vervangen door 0
6.) berekeningen uitvoeren
7.) resultaat omzetten naar template (als "template" bestaat)
8.) add results to map
"""
global g_iface, INP_SKIP_SPJOIN, gdb, l_src_None_naar_0_omzetten, d_velden_tmp, d_velden
d_velden = d_velden_
g_iface = iface
INP_SKIP_SPJOIN = False
# laod from settings
gdb = workspace
l_src_None_naar_0_omzetten = settings.l_fld_None_naar_0_omzetten # velden waarvan waardes worden omgezet van None naar 0
d_velden_tmp = settings.d_velden_tmp # tijdelijke velden
# layers
inp_knooppunten, inp_afvoerrelaties, inp_drinkwater_bag, inp_ve_belasting, inp_plancap, inp_verhard_opp, old_inp_polygon = layers
for i, layer in enumerate(layers):
print_log("input {}:\t{}".format(i, layer.name()), "d")
# tussenresultaten
EINDRESULTAAT = os.path.join(gdb, "eindresultaat.shp")
POLYGON_LIS = os.path.join(gdb, "POLYGON_LIS.shp")
DRINKWATER_POLYGON_LIS = os.path.join(gdb,
"SpJoin_DRINKWATER2POLYGON_LIS.shp")
PLANCAP_POLYGON_LIS = os.path.join(gdb, "SpJoin_PLANCAP2POLYGON_LIS.shp")
VE_POLYGON_LIS = os.path.join(gdb, "SpJoin_VE2POLYGON_LIS.shp")
PLANCAP_OVERLAP = os.path.join(gdb, "PLANCAP_OVERLAP.shp")
STATS_DRINKWATER = os.path.join(gdb, "STATS_DRINKWATER.shp")
STATS_PLANCAP = os.path.join(gdb, "STATS_PLANCAP.shp")
STATS_VE = os.path.join(gdb, "STATS_VE.shp")
EXP_VERHARD_OPP = os.path.join(gdb, "EXP_VERHARD_OPP.shp")
VERHARD_OPP_INTERSECT = os.path.join(gdb, "VERHARD_OPP_INTERSECT.shp")
STATS_VERHARD_OPP = os.path.join(gdb, "STATS_VERHARD_OPP.shp")
INP_POLYGON_COPY = os.path.join(gdb, "inp_polygon_copy.shp")
# ##########################################################################
# 1.) export input INP_POLYGON_LIS to result POLYGON_LIS
tussenresultaat = QgsVectorLayer(POLYGON_LIS, "tussenresultaat", "ogr")
if EINDRESULTAAT:
QgsVectorFileWriter.deleteShapeFile(EINDRESULTAAT)
QgsVectorFileWriter.writeAsVectorFormat(tussenresultaat, EINDRESULTAAT,
"utf-8", tussenresultaat.crs(),
"ESRI Shapefile")
##QgsVectorFileWriter.writeAsVectorFormat(tussenresultaat, os.path.join(gdb,"eindresultaat"), "utf-8", tussenresultaat.crs(), "SQLite", False, None ,["SPATIALITE=YES"])
# ##########################
##EINDRESULTAAT = os.path.join(gdb,'eindresultaat.sqlite')
polygon_lis = QgsVectorLayer(EINDRESULTAAT, "eindresultaat", "ogr")
polygon_lis = add_layer(polygon_lis)
fields_to_uppercase(polygon_lis)
# ##########################################################################
# 2.) Velden toevoegen en gegevens overnemen
add_field_from_dict_label(polygon_lis, "st2a", d_velden)
# copy VAN_KNOOPN -> K_KNP_NR
bereken_veld(polygon_lis, "K_KNP_NR",
{"K_KNP_NR": {
"expression": "[VAN_KNOOPN]"
}})
# overige velden kikker toevoegen (uitgegrijst omdat nog geen geschikt bronveld is gevonden in Kikker #
##join_field(polygon_lis, inp_knooppunten, "K_BERG_VL", "BERGV_KNP_", "VAN_KNOOPN", "VAN_KNOOPN") # Verloren berging stelsel (m3)
##join_field(polygon_lis, inp_knooppunten, "K_BR_RZ_M3", "BERG_STR_M", "VAN_KNOOPN", "VAN_KNOOPN") # Berging randvoorziening (G) (m3)
# ##########################################################################
# 3.) Spatial joins tussen polygon_lis en de externe gegevens bronnen
if INP_SKIP_SPJOIN:
blokje_log(
"Skip SpatialJoin met externe inputs en gebruik bestaande STAT-tabellen.",
"i")
stats_drinkwater = QgsVectorLayer(STATS_DRINKWATER, "stats_drinkwater",
"ogr")
stats_ve = QgsVectorLayer(STATS_VE, "stats_ve", "ogr")
stats_plancap = QgsVectorLayer(STATS_PLANCAP, "stats_plancap", "ogr")
stats_drinkwater = add_layer(stats_drinkwater)
stats_ve = add_layer(stats_ve)
stats_plancap = add_layer(stats_plancap)
# for layer in [stats_drinkwater, stats_ve, stats_plancap]:
# layer = add_layer(layer)
else:
blokje_log(
"Start SpatialJoin externe bronnen met hoofdbemalingsgebieden... (1 tot 5 minuten)",
"i")
stats_drinkwater, stats_ve, stats_plancap = spjoin_bronbestanden_aan_bemalingsgebieden(
polygon_lis, inp_drinkwater_bag, inp_ve_belasting, inp_plancap,
inp_polygon, PLANCAP_OVERLAP, STATS_DRINKWATER, STATS_VE,
STATS_PLANCAP)
blokje_log(
"Velden toevoegen en voorbereiden voor berekening onderbemaling...",
"i")
# join stat_fields to polygon_lis
join_field(polygon_lis, stats_drinkwater, "PAR_RESULT", "SUMPAR_M3U",
"OBJECTID", "OBJECTID")
join_field(polygon_lis, stats_drinkwater, "ZAK_RESULT", "SUMZAK_M3U",
"OBJECTID", "OBJECTID")
join_field(polygon_lis, stats_drinkwater, "X_WON_GEB", "count", "OBJECTID",
"OBJECTID")
join_field(polygon_lis, stats_plancap, "AW_15_24_G", "sumExtra_A",
"OBJECTID", "OBJECTID") # SUM_Extra_AFW_2015_tm_2024
join_field(polygon_lis, stats_plancap, "AW_25_50_G", "sumExtra_1",
"OBJECTID", "OBJECTID") # SUM_Extra_AFW_2025_tm_2050
if stats_ve:
join_field(polygon_lis, stats_ve, "X_VE_GEB", "sumGRONDSL", "OBJECTID",
"OBJECTID")
# bereken drinkwater per gebied (input voor onderbemalingen) en LEDIG_U (ledigingstijd)
bereken_veld_label(polygon_lis, "02_ber", d_velden)
# ##########################################################################
# 4.) Bereken onderbemaling voor DRINKWATER en PLANCAP en VE's
blokje_log("bereken onderbemalingen voor drinkwater, plancap en ve's...",
"i")
bereken_onderbemaling(polygon_lis, l_K_ONTV_VAN[0])
vervang_None_door_0_voor_velden_in_lijst(l_src_None_naar_0_omzetten,
polygon_lis)
# ##########################################################################
# 6.) berekeningen uitvoeren
# bereken dwa prognose & drinkwater per gebied
# "bereken": "b2a"
bereken_veld_label(polygon_lis, "04_ber", d_velden)
bereken_veld_label(polygon_lis, "04a_ber", d_velden)
# Vergelijk geschat en gemeten zonder
# "bereken": "b2b"
bereken_veld_label(polygon_lis, "05_ber", d_velden)
# bereken verhard opp
blokje_log("Bepaal verhard oppervlak binnen bemalingsgebieden...", "i")
bepaal_verhard_oppervlak(polygon_lis, inp_verhard_opp,
VERHARD_OPP_INTERSECT)
vervang_None_door_0_voor_velden_in_lijst([
"HA_GEM_G", "HA_VGS_G", "HA_HWA_G", "HA_OPW_G", "HA_NAG_G", "HA_OBK_G"
], polygon_lis)
# bereken velden afhankelijk van verhard opp
bereken_veld_label(polygon_lis, '07_ber', d_velden)
bereken_veld_label(polygon_lis, '08_ber', d_velden)
# bepaal onderbemaling2 afhankelijk van verhard opp
blokje_log(
"bereken onderbemalingen voor pompovercapaciteit ontwerp en berekend...",
"i")
bereken_onderbemaling2(polygon_lis, l_K_ONTV_VAN)
vervang_None_door_0_voor_velden_in_lijst(
##["POC_B_M3_O", "POC_O_M3_O","POC_B_M3_G", "POC_O_M3_G"], polygon_lis)
["POC_O_M3_O", "POC_O_M3_G", "IN_DWA_POC"],
polygon_lis)
bereken_veld_label(polygon_lis, '10_ber', d_velden)
bereken_veld_label(polygon_lis, '11_ber', d_velden)
# update_datetime UPDATED
update_datetime(polygon_lis, "UPDATED")
# delete fields
del_fld_names = ['BEGIN_EIND', 'VAN_KNOOPN', 'count']
del_fld_index = [
polygon_lis.fieldNameIndex(fld) for fld in del_fld_names
if polygon_lis.fieldNameIndex(fld) != -1
]
print_log("deleting fields {} with index {}".format(
del_fld_names, del_fld_index))
polygon_lis.dataProvider().deleteAttributes(del_fld_index)
polygon_lis.updateFields()
# add field aliasses
for fld in d_velden:
index = polygon_lis.fieldNameIndex(fld)
if index != -1:
try:
print_log(
"update {} with alias '{}'".format(
fld, d_velden[fld]["field_alias"]), "d")
except Exception as e:
print_log(e, "d") # UnicodeEncodeError?...
polygon_lis.addAttributeAlias(index, d_velden[fld]["field_alias"])