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