def controleer_spjoin_plancap(layer, fld_join_count):
"""Controleer of spjoin geslaagd is (Join_Count moet in principe overal 1 zijn) voor plancap"""
i_dubbel, i_leeg = 0, 0
##layer.startEditing()
for i, feature in enumerate(layer.getFeatures()):
JOIN_COUNT = feature[fld_join_count] if feature[fld_join_count] else 0
PLAN_ID = feature["PLANID"] if feature["PLANID"] else None
##print_log("{} - {}".format(PLAN_ID, JOIN_COUNT), "i")
if JOIN_COUNT >= 2:
i_dubbel += 1
print_log(
"planid '{}' valt in {} bemalingsgebieden!".format(
PLAN_ID, JOIN_COUNT), "w", g_iface)
if JOIN_COUNT == 0:
i_leeg += 1
##layer.commitChanges()
if i_dubbel == 1:
print_log(
"{} plancap valt in meerdere hoofdbemalingsgebieden! Zie selectie in layer 'plancap overlap'"
.format(i_dubbel), "w")
if i_dubbel > 1:
print_log(
"{} plancaps vallen in meerdere hoofdbemalingsgebieden! Zie selectie in layer 'plancap overlap'"
.format(i_dubbel), "w")
if i_leeg == 1:
print_log(
"{} plancaps valt niet in een hoofdbemalingsgebied\n".format(
i_leeg), "w")
if i_leeg > 1:
print_log(
"{} plancaps vallen niet in een hoofdbemalingsgebied\n".format(
i_leeg), "w")
def controleer_spjoin_plancap(layer, fld_join_count):
"""Controleer of spjoin geslaagd is (Join_Count moet in principe overal 1 zijn) voor plancap"""
i_dubbel, i_leeg = 0, 0
##layer.startEditing()
for i, feature in enumerate(layer.getFeatures()):
JOIN_COUNT = feature[fld_join_count] if feature[fld_join_count] else 0
PLAN_ID = feature["PLANID"] if feature["PLANID"] else None
##print_log("{} - {}".format(PLAN_ID, JOIN_COUNT), "i")
if JOIN_COUNT >= 2:
i_dubbel += 1
print_log(
"planid '{}' valt in {} bemalingsgebieden!".format(
PLAN_ID, int(JOIN_COUNT)), "i", g_iface)
if JOIN_COUNT == 0:
i_leeg += 1
##layer.commitChanges()
if i_dubbel == 1:
print_log(
"{} woningbouwplan valt in meerdere hoofdbemalingsgebieden. Let op: dit woningbouwplan wordt dubbel meegeteld! Zie layer 'plancap overlap' (waar veld \"count\" > 1)"
.format(i_dubbel), "w")
if i_dubbel > 1:
print_log(
"{} woningbouwplannen vallen in meerdere hoofdbemalingsgebieden. Let op: deze woningbouwplannen worden dubbel meegeteld! Zie layer 'plancap overlap' (waar veld \"count\" > 1)"
.format(i_dubbel), "w")
if i_leeg == 1:
print_log(
"{} woningbouwplan valt niet in een hoofdbemalingsgebied\n".format(
i_leeg), "i")
if i_leeg > 1:
print_log(
"{} woningbouwplannen vallen buiten een hoofdbemalingsgebied\n".
format(i_leeg), "i")
def bepaal_b_VIEW(fc, wildcard):
"""Bepaal of extra gemaal bron (Spoc_views) gebruikt is in stap 1.
Dat gebeurt door te controleren of de extra velden zijn aangemaakt"""
if len(arcpy.ListFields(fc, wildcard)) > 0:
return True
else:
print_log("geen [{}] gevonden in {}".format(wildcard, fc), "i")
return False
def main(INP_EINDRESULTAAT, GEODYN_EINDRESULTAAT):
"""Eindresultaat importeren naar Oracle"""
print_log("\ttruncate Oracle tabel '{}'...".format(GEODYN_EINDRESULTAAT),
"i")
arcpy.TruncateTable_management(GEODYN_EINDRESULTAAT)
print_log("\tvul Oracle tabel '{}'...".format(GEODYN_EINDRESULTAAT), "i")
arcpy.Append_management(INP_EINDRESULTAAT, GEODYN_EINDRESULTAAT, "NO_TEST")
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 bereken_onderbemaling(layer):
"""bereken onderbemalingen voor SUM_WAARDE, SUM_BLA, etc..
Maakt selectie op basis van veld [ONTV_VAN] -> VAN_KNOOPN IN ('ZRE-123424', 'ZRE-234')"""
# sum values op basis van selectie [ONTV_VAN]
layer.startEditing()
for feature in layer.getFeatures():
VAN_KNOOPN = feature["VAN_KNOOPN"]
ONTV_VAN = feature["K_ONTV_VAN"]
if not str(ONTV_VAN) in ["NULL", "", " "
]: # check of sprake is van onderbemaling
print_log("K_ONTV_VAN = {}".format(ONTV_VAN), "d")
where_clause = '"VAN_KNOOPN" IN ({})'.format(ONTV_VAN)
##where_clause = '"VAN_KNOOPN" = '+"'MERG10'"
print_log("where_clause = {}".format(where_clause), "d")
expr = QgsExpression(where_clause)
it = layer.getFeatures(QgsFeatureRequest(expr)) # iterator object
layer.setSelectedFeatures([i.id() for i in it])
print_log("sel = {}".format([i.id() for i in it]), "d")
AW_15_24_O = sum([
float(f["AW_15_24_G"]) for f in layer.selectedFeatures()
if str(f["AW_15_24_G"]) not in ["NULL", "nan", "", " "]
])
AW_25_50_O = sum([
float(f["AW_25_50_G"]) for f in layer.selectedFeatures()
if str(f["AW_25_50_G"]) not in ["NULL", "nan", "", " "]
])
DWR_ONBG = sum([
float(f["DWR_GEBIED"]) for f in layer.selectedFeatures()
if str(f["DWR_GEBIED"]) not in ["NULL", "nan", "", " "]
])
X_WON_ONBG = sum([
float(f["X_WON_GEB"]) for f in layer.selectedFeatures()
if str(f["X_WON_GEB"]) not in ["NULL", "nan", "", " "]
])
X_VE_ONBG = sum([
float(f["X_VE_GEB"]) for f in layer.selectedFeatures()
if str(f["X_VE_GEB"]) not in ["NULL", "nan", "", " "]
])
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("AW_15_24_O"),
AW_15_24_O)
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("AW_25_50_O"),
AW_25_50_O)
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("DWR_ONBG"),
DWR_ONBG)
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("X_WON_ONBG"),
X_WON_ONBG)
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("X_VE_ONBG"),
X_VE_ONBG)
layer.commitChanges()
layer.setSelectedFeatures([])
print_log(
"Onderbemalingen succesvol berekend voor Plancap, drinkwater, woningen en ve's",
"i")
def vervang_None_door_0_voor_velden_in_lijst(l, layer):
"""Vervang alle None-waarden met 0 voor velden in lijst"""
blokje_log("Data voorbereiden en berekeningen uitvoeren...", "i")
print_log("Vervang None met 0 voor alle velden in lijst {}...".format(l),
"i")
layer.startEditing()
for fld in l:
for f in layer.getFeatures():
try:
if str(f[fld]) in ["NULL", "", " ", "nan"]:
layer.changeAttributeValue(f.id(),
layer.fieldNameIndex(fld), 0)
except Exception as e:
print_log(
"fout bij omzetten None-waarden naar 0 bij veld {}. {}".
format(fld, e), "w", g_iface)
layer.commitChanges()
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 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_bemalingsgebieden(inp_polygon, inp_knooppunten):
'''Controleer of knoopunten in bemalingsgebied liggen.'''
processing.runalg("qgis:selectbylocation", inp_knooppunten, inp_polygon,
u'intersects', 0, 0)
inp_knooppunten.invertSelection()
ids = []
if inp_knooppunten.fields().indexFromName('VAN_KNOOPN') == -1:
field = 0
else:
field = 'VAN_KNOOPN'
for feature in inp_knooppunten.selectedFeatures():
ids.append(feature[field])
if len(ids) == 1:
print_log(
"1 rioolgemaal ligt niet in een bemalingsgebied {}".format(ids),
"w")
elif len(ids) > 1:
print_log(
"{} rioolgemalen liggen niet in een bemalingsgebied {}".format(
len(ids), ids), "w")
inp_knooppunten.setSelectedFeatures([])
def bereken_onderbemaling2(layer):
"""bereken onderbemalingen voor SUM_WAARDE, SUM_BLA, etc..
Maakt selectie op basis van veld [ONTV_VAN] -> VAN_KNOOPN IN ('ZRE-123424', 'ZRE-234')"""
# sum values op basis van selectie [ONTV_VAN]
layer.startEditing()
for feature in layer.getFeatures():
VAN_KNOOPN = feature["VAN_KNOOPN"]
ONTV_VAN = feature["K_ONTV_VAN"]
if not str(ONTV_VAN) in ["NULL", "", " "
]: # check of sprake is van onderbemaling
print_log("K_ONTV_VAN = {}".format(ONTV_VAN), "i")
where_clause = '"VAN_KNOOPN" IN ({})'.format(ONTV_VAN)
##where_clause = '"VAN_KNOOPN" = '+"'MERG10'"
print_log("where_clause = {}".format(where_clause), "i")
expr = QgsExpression(where_clause)
it = layer.getFeatures(QgsFeatureRequest(expr)) # iterator object
layer.setSelectedFeatures([i.id() for i in it])
print_log("sel = {}".format([i.id() for i in it]), "i")
POC_B_M3_O = sum([
float(f["POC_B_M3_G"]) for f in layer.selectedFeatures()
if str(f["POC_B_M3_G"]) not in ["NULL", "nan", "", " "]
]) # POC_B_M3_O = sum(POC_B_M3_G)
POC_O_M3_O = sum([
float(f["POC_O_M3_G"]) for f in layer.selectedFeatures()
if str(f["POC_O_M3_G"]) not in ["NULL", "nan", "", " "]
]) # POC_O_M3_O = sum(POC_O_M3_G)
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("POC_B_M3_O"),
POC_B_M3_O)
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("POC_O_M3_O"),
POC_O_M3_O)
layer.commitChanges()
layer.setSelectedFeatures([])
print_log(
"Onderbemalingen succesvol berekend voor POC ontwerp en POC beschikbaar",
"i")
INP_EINDRESULTAAT = sys.argv[1]
# load from settings
gdb = settings.gdb
log_dir = settings.log_dir # log_dir
GEODYN_EINDRESULTAAT = settings.GEODYN_EINDRESULTAAT_ORACLE
# set env
arcpy.env.overwriteOutput = True
# logging
LOGGING_LEVEL = logging.INFO
if not os.path.exists(log_dir): os.mkdir(log_dir)
strftime = datetime.strftime(datetime.now(), "%Y%m%d-%H.%M")
logFileName = 'GeoDyn_{}.log'.format(strftime)
logFile = os.path.join(log_dir, logFileName)
logging.basicConfig(filename=logFile, level=LOGGING_LEVEL)
logging.getLogger().setLevel(LOGGING_LEVEL)
# start timer
fTimeStart = start_timer()
# print belangrijke informatie
print_log("\nworkspace = {}".format(gdb), "i")
print_log("logfile = {}\n".format(logFile), "i")
# run main
main(INP_EINDRESULTAAT, GEODYN_EINDRESULTAAT)
# end timer
end_timer(fTimeStart)
def bereken_onderbemaling2(layer, l_K_ONTV_VAN):
"""bereken onderbemalingen voor SUM_WAARDE..
Maakt selectie op basis van dict ONTV_VAN 1 niveau diep -> VAN_KNOOPN IN ('ZRE-123424', 'ZRE-234')"""
d_K_ONTV_VAN, d_K_ONTV_VAN_n1 = l_K_ONTV_VAN
layer.startEditing()
for feature in layer.getFeatures():
VAN_KNOOPN = feature["VAN_KNOOPN"]
# onderbemaling alle niveau's
ONTV_VAN = d_K_ONTV_VAN.get(VAN_KNOOPN,
"") # was feature["K_ONTV_VAN"]
if not str(ONTV_VAN) in ["NULL", "", " "
]: # check of sprake is van onderbemaling
print_log(
"VAN_KNOOPN = {} ontvangt van {}".format(VAN_KNOOPN, ONTV_VAN),
"i")
where_clause = '"VAN_KNOOPN" IN ({})'.format(ONTV_VAN)
print_log("where_clause = {}".format(where_clause), "i")
expr = QgsExpression(where_clause)
it = layer.getFeatures(QgsFeatureRequest(expr)) # iterator object
layer.setSelectedFeatures([i.id() for i in it])
POC_O_M3_O = sum([
float(f["POC_O_M3_G"]) for f in layer.selectedFeatures()
if str(f["POC_O_M3_G"]) not in ["NULL", "nan", "", " "]
]) # POC_O_M3_O = sum(POC_O_M3_G)
print_log("sum POC_O_M3_O = {}".format(POC_O_M3_O), "d")
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("POC_O_M3_O"),
POC_O_M3_O)
# onderbemaling 1 niveau
ONTV_VAN_1n = d_K_ONTV_VAN_n1.get(VAN_KNOOPN, "")
if not str(ONTV_VAN_1n) in ["NULL", "", " "
]: # check of sprake is van onderbemaling
print_log(
"VAN_KNOOPN = {} ontvangt van {}".format(
VAN_KNOOPN, ONTV_VAN_1n), "i")
where_clause = '"VAN_KNOOPN" IN ({})'.format(ONTV_VAN_1n)
##where_clause = '"VAN_KNOOPN" = '+"'MERG10'"
print_log("where_clause = {}".format(where_clause), "i")
expr = QgsExpression(where_clause)
it = layer.getFeatures(QgsFeatureRequest(expr)) # iterator object
layer.setSelectedFeatures([i.id() for i in it])
K_INST_TOT_O = sum([
float(f["K_INST_TOT"]) for f in layer.selectedFeatures()
if str(f["K_INST_TOT"]) not in ["NULL", "nan", "", " "]
]) # K_INST_TOT_O = sum(K_INST_TOT)
print_log("sum IN_DWA_POC = {}".format(K_INST_TOT_O), "d")
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("IN_DWA_POC"),
K_INST_TOT_O)
layer.commitChanges()
layer.setSelectedFeatures([])
print_log(
"Onderbemalingen succesvol berekend voor POC ontwerp en POC beschikbaar",
"i")
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 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"])
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 lis2graph(layer):
"""Maakt Graph met LIS-netwerk en bepaalt onderbemalingen.
Vult [ONTV_VAN] en [X_OBEMAL].
Gebruikt [LOOST_OP] en [VAN_KNOOPN] als edge (relation) en VAN_KNOOPN als node"""
# graph aanmaken
graph = Graph()
graph_rev = Graph()
d_K_ONTV_VAN = {} # alle onderliggende gemalen
d_K_ONTV_VAN_n1 = {
} # alle onderliggende gemalen op 1 niveau diep ivm optellen overcapaciteit
print_log("netwerk opslaan als graph...", "i")
for feature in layer.getFeatures(): # .getFeatures()
VAN_KNOOPN = feature["VAN_KNOOPN"]
LOOST_OP = feature["K_LOOST_OP"]
graph.add_node(VAN_KNOOPN)
graph_rev.add_node(VAN_KNOOPN)
if LOOST_OP != None:
graph.add_edge(VAN_KNOOPN, LOOST_OP,
1) # richting behouden voor bovenliggende gebied
graph_rev.add_edge(
LOOST_OP, VAN_KNOOPN,
1) # richting omdraaien voor onderliggende gebied
edges_as_tuple = list(
graph.distances) # lijst met tuples: [('A', 'B'), ('C', 'B')]
print_log("onderbemaling bepalen voor rioolgemalen en zuiveringen...", "i")
where_clause = "Join_Count > 0"
layer.startEditing()
for i, feature in enumerate(layer.getFeatures()): # .getFeatures()
if not feature["count"] >= 1: continue
VAN_KNOOPN = feature["VAN_KNOOPN"]
nodes = dijkstra(graph, VAN_KNOOPN)[0]
print_log("nodes for {}: {}".format(VAN_KNOOPN, nodes), 'd')
K_KNP_EIND, X_OPPOMP = [(key, value) for key, value in sorted(
nodes.iteritems(), key=lambda (k, v): (v, k))][-1]
print_log(
"endnode for {}: {},{}".format(VAN_KNOOPN, K_KNP_EIND, X_OPPOMP),
'd')
d_edges = dijkstra(graph_rev,
VAN_KNOOPN)[1] # {'B': 'A', 'C': 'B', 'D': 'C'}
l_onderliggende_gemalen = str(list(d_edges)) # [u'ZRE-123',u'ZRE-234']
l_onderliggende_gemalen = l_onderliggende_gemalen.replace(
"u'", "'").replace("[", "").replace("]", "")
layer.changeAttributeValue(
feature.id(), layer.fieldNameIndex("K_ONTV_VAN"),
l_onderliggende_gemalen) # K_ONTV_VAN = 'ZRE-1','ZRE-2'
layer.changeAttributeValue(
feature.id(), layer.fieldNameIndex("X_OBEMAL"),
len(list(d_edges))) # X_OBEMAL = 2 (aantal onderbemalingen)
layer.changeAttributeValue(
feature.id(), layer.fieldNameIndex("X_OPPOMP"), X_OPPOMP + 1
) # X_OPPOMP = 1 (aantal keer oppompen tot rwzi) met shortestPath ('RWZI','ZRE-4')
layer.changeAttributeValue(
feature.id(), layer.fieldNameIndex("K_KNP_EIND"), K_KNP_EIND
) # eindbemalingsgebied / overnamepunt. bepaald uit netwerk.
d_K_ONTV_VAN[VAN_KNOOPN] = l_onderliggende_gemalen
# onderbemalingen 1 niveau diep
l_onderliggende_gemalen_n1 = [
start for start, end in edges_as_tuple if end == VAN_KNOOPN
] # dus start['A', 'C'] uit tuples[('A', 'B'),('C', 'B')] als end == 'B'
d_K_ONTV_VAN_n1[VAN_KNOOPN] = str(l_onderliggende_gemalen_n1).replace(
"u'", "'").replace("[", "").replace(
"]", "") # naar str() en verwijder u'tjes en haken
layer.commitChanges()
return [d_K_ONTV_VAN, d_K_ONTV_VAN_n1]
def controleer_spjoin(layer, fld_join_count):
"""Controleer of spjoin geslaagd is (Join_Count moet in principe overal 1 zijn).
Vult VAN_KNOOPN voor lege bemalingsgebieden met 'LEEG-<OBJID>'."""
i_dubbel, i_leeg = 0, 0
layer.startEditing()
for i, feature in enumerate(layer.getFeatures()):
JOIN_COUNT = feature[fld_join_count] if feature[fld_join_count] else 0
VAN_KNOOPN = feature["VAN_KNOOPN"] if feature["VAN_KNOOPN"] else None
print_log("{} - {}".format(VAN_KNOOPN, JOIN_COUNT), "d")
if JOIN_COUNT == 0 and VAN_KNOOPN != None: # uitzondering: rwzi later aangevuld
##feature.setAttribute("count", 1)
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("count"), 1)
JOIN_COUNT = 1
if JOIN_COUNT >= 2:
i_dubbel += 1
print_log(
"bemalingsgebied '{}' bevat {} rioolgemalen!".format(
VAN_KNOOPN, JOIN_COUNT), "i")
if JOIN_COUNT == 0:
i_leeg += 1
##feature.setAttribute("VAN_KNOOPN", "LEEG-{}".format(i))
layer.changeAttributeValue(feature.id(),
layer.fieldNameIndex("VAN_KNOOPN"),
"LEEG-{}".format(i))
layer.commitChanges()
if i_dubbel == 1:
print_log(
"{} bemalingsgebied bevat 2 of meer rioolgemalen, zie veld 'count' in eindresultaat"
.format(i_dubbel), "w")
if i_dubbel > 1:
print_log(
"{} bemalingsgebieden bevatten 2 of meer rioolgemalen, zie veld 'count' in eindresultaat"
.format(i_dubbel), "w")
if i_leeg == 1:
print_log("{} bemalingsgebied is leeg\n".format(i_leeg), "w")
if i_leeg > 1:
print_log("{} bemalingsgebieden zijn leeg\n".format(i_leeg), "w")
if i_leeg >= 1:
print_log(
"lege bemalingsgebieden voorzien van VAN_KNOOPN-> 'LEEG-<OBJID>'",
"i")
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
