def spjoin_bronbestanden_aan_bemalingsgebieden(polygon_lis, inp_drinkwater_bag,
inp_ve_belasting, inp_plancap,
inp_polygon, PLANCAP_OVERLAP,
STATS_DRINKWATER, STATS_VE,
STATS_PLANCAP):
# joining DRINKWATER_BAG to POLYGONS
print_log("spatialjoin DRINKWATER_BAG to POLYGONS...", "i")
processing.runalg("qgis:joinattributesbylocation", inp_polygon,
inp_drinkwater_bag, u'intersects', 0, 1, 'sum', 1,
STATS_DRINKWATER)
stats_drinkwater = QgsVectorLayer(STATS_DRINKWATER, "stats_drinkwater",
"ogr")
stats_drinkwater = add_layer(stats_drinkwater)
# extra stapje om om te reken van liter/hr naar m3/hr voor part. en zakelijk drinkwater in STAT-tabel.
add_field_from_dict_label(stats_drinkwater, "stap2tmp", d_velden_tmp)
bereken_veld(stats_drinkwater, "SUMPAR_M3U", d_velden_tmp)
bereken_veld(stats_drinkwater, "SUMZAK_M3U", d_velden_tmp)
# check for overlap between PLANCAP_RIGO and inp_polygon
print_log("spatialjoin PLANCAP_RIGO to POLYGONS...", "i")
processing.runalg("qgis:joinattributesbylocation", inp_plancap,
inp_polygon, u'intersects', 0, 1, 'sum', 1,
PLANCAP_OVERLAP)
plancap_overlap = QgsVectorLayer(PLANCAP_OVERLAP, "plancap_overlap", "ogr")
plancap_overlap = add_layer(plancap_overlap, False)
controleer_spjoin_plancap(plancap_overlap, "count")
# joining PLANCAP_RIGO to POLYGONS
processing.runalg("qgis:joinattributesbylocation", inp_polygon,
inp_plancap, u'intersects', 0, 1, 'sum', 1,
STATS_PLANCAP)
stats_plancap = QgsVectorLayer(STATS_PLANCAP, "stats_plancap", "ogr")
stats_plancap = add_layer(stats_plancap)
# joining VE to POLYGONS
if inp_ve_belasting.name() == "no data":
stats_ve = None
print_log(
"'no data' geselecteerd als input voor vervuilingseenheden. Berekeningen met VE's worden overgeslagen",
"w", g_iface)
else:
print_log("spatialjoin VE_BELASTING to POLYGONS...", "i")
processing.runalg("qgis:joinattributesbylocation", inp_polygon,
inp_ve_belasting, u'intersects', 0, 1, 'sum', 1,
STATS_VE)
stats_ve = QgsVectorLayer(STATS_VE, "stats_ve", "ogr")
stats_ve = add_layer(stats_ve)
return stats_drinkwater, stats_ve, stats_plancap
def controleer_hoofdbemalingsgebieden(polygon_lis):
"""Controleer of hoofdbemalingsgebieden overlappen."""
# Intersect_analysis (in_features, out_feature_class, {join_attributes}, {cluster_tolerance}, {output_type})
##arcpy.Intersect_analysis (POLYGON_LIS, POLYGON_LIS_OVERLAP)
processing.runalg("saga:polygonselfintersection", polygon_lis,
"VAN_KNOOPN", POLYGON_LIS_OVERLAP)
polygon_lis_overlap = QgsVectorLayer(POLYGON_LIS_OVERLAP,
"bemalingsgebieden overlap", "ogr")
##QgsMapLayerRegistry.instance().addMapLayer(polygon_lis_overlap)
expr = QgsExpression("\"VAN_KNOOPN\" {}".format("IS NULL"))
it = polygon_lis_overlap.getFeatures(
QgsFeatureRequest(expr)) # iterator object
polygon_lis_overlap.setSelectedFeatures([i.id() for i in it])
if polygon_lis_overlap.selectedFeatureCount() > 0:
polygon_lis_overlap = add_layer(polygon_lis_overlap, False)
print_log(
"{} bemalingsgebieden met overlap! Zie selectie in layer 'bemalingsgebieden overlap'"
.format(polygon_lis_overlap.selectedFeatureCount() * 2),
'w',
iface=g_iface)
for feature in polygon_lis_overlap.selectedFeatures():
print_log(
"\toverlap tussen bemalingsgebieden {}".format(feature["ID"]),
"i")
else:
print_log("geen overlap gevonden tussen bemalingsgebieden", "i")
QgsMapLayerRegistry.instance().removeMapLayer(
polygon_lis_overlap.name())
return polygon_lis_overlap
def genereer_knooppunten(iface, inp_polygon, sel_afvoerrelaties):
'''Genereert knooppunten op basis van afvoerrelaties (lijn-bestand) waarbij 1 knooppunt per bemalingsgebied is toegestaan.
Alleen knooppunten die afvoeren naar een andere bemalingsgebied worden meegenomen.
Van ieder knooppunt wordt het eindpunt bepaald, oftewel het overnamepunt.
De knooppunten worden ruimtelijk gekoppeld aan bemalingsgebieden.
resultaat: vlakkenbestand POLYGON_LIS met velden K_LOOST_OP en ONTVANGT_VAN.
'''
# afvoerrelaties selecteren die niet binnen 1 bemalingsgebied vallen
sel_afvoerrelaties.selectAll()
processing.runalg("qgis:selectbylocation", sel_afvoerrelaties, inp_polygon,
u'within', 0, 2)
print_log(
"{} features selected".format(
sel_afvoerrelaties.selectedFeatureCount()), 'd')
point_layer = QgsVectorLayer("Point?crs=epsg:28992", "knooppunten",
"memory")
pr = point_layer.dataProvider()
point_layer.dataProvider().addAttributes([
QgsField("VAN_KNOOPN", QVariant.String),
QgsField("BEGIN_EIND", QVariant.Int)
])
point_layer.updateFields()
feat = QgsFeature(point_layer.pendingFields())
for i, feature in enumerate(
sel_afvoerrelaties.selectedFeatures()): # .getFeatures()
geom = feature.geometry().asPolyline()
start_point = QgsPoint(geom[0])
end_point = QgsPoint(geom[-1])
feat.setGeometry(QgsGeometry.fromPoint(start_point))
feat.setAttribute("VAN_KNOOPN", feature['VAN_KNOOPN'])
feat.setAttribute("BEGIN_EIND", 0)
pr.addFeatures([feat])
##point_layer.changeAttributeValue(i, 0, "hoi")
##i += 1
feat.setGeometry(QgsGeometry.fromPoint(end_point))
feat.setAttribute("VAN_KNOOPN", feature['VAN_KNOOPN'])
feat.setAttribute("BEGIN_EIND", 1)
##point_layer.changeAttributeValue(i, 1, 99)
pr.addFeatures([feat])
##point_layer.updateFields()
point_layer = add_layer(point_layer)
##QgsMapLayerRegistry.instance().addMapLayer(point_layer)
return point_layer
def create_new_inp_polygon(inp_polygon):
'''Copy shapefile, delete all fields except OBJECTID.
If OBJECTID does not excist: add field and calculate.'''
# copy shapefile
INP_POLYGON_COPY = os.path.join(gdb, "inp_polygon_copy.shp")
QgsVectorFileWriter.writeAsVectorFormat(
inp_polygon, INP_POLYGON_COPY, "utf-8",
QgsCoordinateReferenceSystem(28992), "ESRI Shapefile")
vl = QgsVectorLayer(INP_POLYGON_COPY, "inp_polygon_copy", "ogr")
add_layer(vl)
# remove old fields except OBJECTID
fields = vl.dataProvider().fields()
fList = []
for fld in fields:
##if fld.name() <> 'OBJECTID': # condition removed. can cause problems if OBJECTID is not unique
fList.append(vl.fieldNameIndex(fld.name())) # hoe index opvragen?
vl.dataProvider().deleteAttributes(fList)
vl.updateFields()
# add new OBJECTID
if vl.fieldNameIndex('OBJECTID') == -1:
# add OBJECTID
fld = QgsField('OBJECTID', QVariant.Int)
vl.dataProvider().addAttributes([fld])
vl.updateFields()
# set OBJECTID
vl.startEditing()
for i, feature in enumerate(vl.getFeatures()):
feature['OBJECTID'] = i
vl.updateFeature(feature)
##pr.changeAttributeValues({feature.id(): {pr.fieldNameMap()['OBJECTID']: 1}})
vl.commitChanges()
return vl
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_, 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"])