def remove_tempfiles_callback(sender, **kwargs): ''' remove older files from wms tempdir ''' request_finished.disconnect(remove_tempfiles_callback) delay = time.time() - 60*60*24 # 1 day delay wms_temp_dir = os.path.join(settings.MEDIA_ROOT,'warp','wms') for tempfile in os.listdir(wms_temp_dir): filePath = os.path.join(wms_temp_dir,tempfile) if os.path.getmtime(filePath) < delay: os.remove(filePath) warp_dir = os.path.join(settings.MEDIA_ROOT,'warp') for tempfile in os.listdir(warp_dir): if tempfile.endswith(('.json', '.geojson', '.xml', '.log')): filePath = os.path.join(warp_dir,tempfile) if os.path.getmtime(filePath) < delay: os.remove(filePath)
def main(): try: gp = mainutils.create_geoprocessor() config = mainutils.read_config(__file__, 'turtle-settings.ini') logfile = mainutils.log_filename(config) logging_config = LoggingConfig(gp, logfile=logfile) mainutils.log_header(__name__) # -------------------------------------------------------------------- # Create workspace workspace = config.get('GENERAL', 'location_temp') if workspace == "-": workspace = tempfile.gettempdir() turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace) if not os.path.isdir(workspace): os.makedirs(workspace) workspace_gdb, errorcode = ( turtlebase.arcgis.create_temp_geodatabase(gp, workspace)) if errorcode == 1: log.error("failed to create a file geodatabase in %s" % workspace) # -------------------------------------------------------------------- # check inputfields log.info("Getting commandline parameters") if len(sys.argv) == 6: input_peilgebieden = sys.argv[1] input_waterlevel_table = sys.argv[2] input_ahn_raster = sys.argv[3] output_inundation = sys.argv[4] output_folder_waterlevel = sys.argv[5] else: log.error("Usage: python rural_inundatie.py <peilgebieden feature>\ <input_waterlevel_table> <input_ahn_raster> <output grid>") sys.exit(1) # -------------------------------------------------------------------- #check input parameters log.info('Checking presence of input files') if not(gp.exists(input_peilgebieden)): log.error("inputfile peilgebieden: %s does not exist!", input_peilgebieden) sys.exit(5) if not(gp.exists(input_waterlevel_table)): log.error("inputfile resultaten: %s does not exist!", input_waterlevel_table) sys.exit(5) if not(gp.exists(input_ahn_raster)): log.error("inputfile hoogtegrid: %s does not exist!", input_ahn_raster) sys.exit(5) log.info('input parameters checked') # -------------------------------------------------------------------- # Check geometry input parameters cellsize = gp.describe(input_ahn_raster).MeanCellHeight log.info("Check geometry of input parameters") geometry_check_list = [] log.debug(" - check level areas: %s" % input_peilgebieden) if gp.describe(input_peilgebieden).ShapeType != 'Polygon': log.error("Input level area is not a polygon feature class!") geometry_check_list.append(input_peilgebieden + " -> (Polygon)") log.debug(" - check ahn raster %s" % input_ahn_raster) if gp.describe(input_ahn_raster).DataType != 'RasterDataset': log.error("Input AHN is not a raster dataset") sys.exit(1) if gp.describe(input_ahn_raster).PixelType[0] not in ['U', 'S']: log.error("Input AHN is a floating point raster,\ for this script an integer is nessecary") geometry_check_list.append(input_ahn_raster + " -> (Integer)") if len(geometry_check_list) > 0: log.error("check input: %s" % geometry_check_list) sys.exit(2) log.info('input format checked') #--------------------------------------------------------------------- # Check required fields in input data log.info("Check required fields in input data") gpgident = config.get('General', 'gpgident') missing_fields = [] # create return period list return_periods = config.get( 'Inundatie', 'herhalingstijden').split(", ") log.debug(" - return periods: %s" % return_periods) # <check required fields from input data, # append them to list if missing>" if not turtlebase.arcgis.is_fieldname( gp, input_peilgebieden, gpgident): log.debug(" - missing: %s in %s", (gpgident, input_peilgebieden)) missing_fields.append("%s: %s", (input_peilgebieden, gpgident)) if not turtlebase.arcgis.is_fieldname( gp, input_waterlevel_table, gpgident): log.debug(" - missing: %s in %s", (gpgident, input_waterlevel_table)) missing_fields.append("%s: %s", (input_waterlevel_table, gpgident)) for return_period in return_periods: if not turtlebase.arcgis.is_fieldname( gp, input_waterlevel_table, "WS_%s" % return_period): log.debug(" - missing: %s in %s" % ("WS_%s", return_period, input_waterlevel_table)) missing_fields.append("%s: %s", (input_waterlevel_table, "WS_%s" % return_period)) if len(missing_fields) > 0: log.error("missing fields in input data: %s" % missing_fields) sys.exit(2) #--------------------------------------------------------------------- # Environments log.info("Setting environments") temp_peilgebieden = ( turtlebase.arcgis.get_random_file_name(workspace_gdb)) log.debug(" - export level areas") gp.select_analysis(input_peilgebieden, temp_peilgebieden) # use extent from level areas gp.extent = gp.describe(temp_peilgebieden).extent # add waterlevel to peilgebieden log.info("Read waterlevels from table") waterlevel_dict = nens.gp.get_table( gp, input_waterlevel_table, primary_key=gpgident.lower()) join_waterlevel_to_level_area( gp, temp_peilgebieden, gpgident, return_periods, waterlevel_dict) #--------------------------------------------------------------------- log.info("A) Create rasters for waterlevels") # Create waterlevel rasters if output_folder_waterlevel == "#": output_folder_waterlevel = workspace_gdb for return_period in return_periods: log.info(" - create raster for ws_%s" % return_period) out_raster_dataset = os.path.join( output_folder_waterlevel, "ws_%s" % return_period) if not gp.exists(out_raster_dataset): input_field = "WS_%s" % return_period gp.FeatureToRaster_conversion(temp_peilgebieden, input_field, out_raster_dataset, int(cellsize)) else: log.error("output waterlevel raster already exists,\ delete this first or change output folder") sys.exit(1) #--------------------------------------------------------------------- log.info("B) Create Inundation raster") inundation_raster_list = [] # create ahn ascii ahn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc") log.debug("ahn ascii: %s" % ahn_ascii) gp.RasterToASCII_conversion(input_ahn_raster, ahn_ascii) # inundatie stedelijk return_period_urban = config.get( 'Inundatie', 'herhalingstijd_inundatie_stedelijk') if config.get('Inundatie', 'percentage_inundatie_stedelijk') != "-": log.debug(" - create inundation urban") waterlevel = "%s/ws_%s" % ( output_folder_waterlevel, return_period_urban) if gp.exists(waterlevel): inundation_urban = turtlebase.arcgis.get_random_file_name( workspace, ".asc") turtlebase.spatial.create_inundation_raster( ahn_ascii, ahn_ascii, waterlevel, 1, return_period_urban, inundation_urban, workspace, use_lgn=False) inundation_raster_list.append(inundation_urban) else: log.error("%s does not exists! check ini-file and tempfolder", waterlevel) # inundatie hoogwaardige landbouw return_period_agriculture = config.get( 'Inundatie', 'herhalingstijd_inundatie_hoogwaardig') if config.get('Inundatie', 'percentage_inundatie_hoogwaardig') != "-": log.debug(" - create inundation agriculture") waterlevel = "%s/ws_%s" % ( output_folder_waterlevel, return_period_agriculture) if gp.exists(waterlevel): # Inundation with lgn inundation_agriculture = ( turtlebase.arcgis.get_random_file_name( workspace, ".asc")) turtlebase.spatial.create_inundation_raster( ahn_ascii, ahn_ascii, waterlevel, 2, return_period_agriculture, inundation_agriculture, workspace, use_lgn=False) inundation_raster_list.append(inundation_agriculture) else: log.error("%s does not exists! check ini-file and tempfolder", waterlevel) # inundatie akkerbouw return_period_rural = config.get( 'Inundatie', 'herhalingstijd_inundatie_akker') if config.get('Inundatie', 'percentage_inundatie_akker') != "-": log.debug(" - create inundation rural") waterlevel = "%s/ws_%s" % ( output_folder_waterlevel, return_period_rural) if gp.exists(waterlevel): inundation_rural = turtlebase.arcgis.get_random_file_name( workspace, ".asc") turtlebase.spatial.create_inundation_raster( ahn_ascii, ahn_ascii, waterlevel, 3, return_period_rural, inundation_rural, workspace, use_lgn=False) inundation_raster_list.append(inundation_rural) else: log.error("%s does not exists! check ini-file and tempfolder", waterlevel) # inundatie grasland return_period_grass = config.get( 'Inundatie', 'herhalingstijd_inundatie_grasland') if config.get('Inundatie', 'percentage_inundatie_grasland') != "-": log.debug(" - create inundation grass") waterlevel = ("%s/ws_%s" % ( output_folder_waterlevel, return_period_grass)) if gp.exists(waterlevel): inundation_grass = turtlebase.arcgis.get_random_file_name( workspace, ".asc") turtlebase.spatial.create_inundation_raster( ahn_ascii, ahn_ascii, waterlevel, 4, return_period_grass, inundation_grass, workspace, use_lgn=False) inundation_raster_list.append(inundation_grass) else: log.error("%s does not exists! check ini-file and tempfolder", waterlevel) if len(inundation_raster_list) > 1: log.info(" - merge inundation rasters") turtlebase.spatial.merge_ascii( inundation_raster_list, output_inundation, workspace) else: log.error("there are no inundation rasters available") #--------------------------------------------------------------------- # Delete temporary workspace geodatabase & ascii files try: log.debug("delete temporary workspace: %s" % workspace_gdb) #gp.delete(workspace_gdb) log.info("workspace deleted") except: log.warning("failed to delete %s" % workspace_gdb) tempfiles = os.listdir(workspace) for tempfile in tempfiles: if tempfile.endswith('.asc'): try: os.remove(os.path.join(workspace, tempfile)) except Exception, e: log.debug(e) mainutils.log_footer()
def main(): try: gp = mainutils.create_geoprocessor() config = mainutils.read_config(__file__, 'turtle-settings.ini') logfile = mainutils.log_filename(config) logging_config = LoggingConfig(gp, logfile=logfile) mainutils.log_header(__name__) #---------------------------------------------------------------------------------------- # Create workspace workspace = config.get('GENERAL', 'location_temp') if workspace == "-": workspace = tempfile.gettempdir() turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace) if not os.path.isdir(workspace): os.makedirs(workspace) workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(gp, workspace) if errorcode == 1: log.error("failed to create a file geodatabase in %s" % workspace) #---------------------------------------------------------------------------------------- # Input parameters if len(sys.argv) == 11: log.info("Reading input parameters") peilgebied = sys.argv[1] input_rr_peilgebied = sys.argv[2] input_rr_maaiveld = sys.argv[3] input_ahn = sys.argv[4] input_lgn = sys.argv[5] conversion = sys.argv[6] input_hymstat = sys.argv[7] output_risk_table = sys.argv[8] output_risico = sys.argv[9] output_risico_inundation = sys.argv[10] else: log.error("usage: <peilgebied> <input_rr_peilgebied> <input_rr_maaiveld> <input_ahn> <input_lgn>\ <conversion> <input_hymstat> <output_risk_table> <output_risico> <output_risico_inundation>") sys.exit(1) #---------------------------------------------------------------------------------------- log.info(" - read Conversion table") conv_list = [d for d in csv.DictReader(open(conversion))] expected_keys = ['LGN', 'K5', 'maxschade', 'sr1', 'sr2', 'sr3', 'sr4', 'sr5', 'sr6', 'sr7', 'sr8', 'sr9'] for k in expected_keys: if k not in conv_list[0].keys(): log.error('could not find key %s in conversion table' % k) sys.exit(2) schadefuncties = {} for item in conv_list: schadefuncties[int(item['LGN'])] = item #---------------------------------------------------------------------------------------- log.info(" - read hymstat table") csv_list = [d for d in csv.DictReader(open(input_hymstat))] expected_hymstat_keys = ['Location', 'Scale par. beta', 'Location par. x0'] for k in expected_hymstat_keys: csv_list[0].keys() if k not in csv_list[0].keys(): log.error('could not find key %s in hymstat table' % k) sys.exit(2) hymstat = {} for item in csv_list: hymstat[item[config.get('risico', 'hymstat_id')]] = item #---------------------------------------------------------------------------------------- # Check geometry input parameters log.info("Check geometry of input parameters") geometry_check_list = [] #log.debug(" - check <input >: %s" % argument1) "<check geometry from input data, append to list if incorrect>" if len(geometry_check_list) > 0: log.error("check input: %s" % geometry_check_list) sys.exit(2) #---------------------------------------------------------------------------------------- # Check required fields in input data log.info("Check required fields in input data") missing_fields = [] #<check required fields from input data, append them to list if missing> check_fields = {}#check_fields = {input_1: [fieldname1, fieldname2], input_2: [fieldname1, fieldname2]} for input_fc, fieldnames in check_fields.items(): for fieldname in fieldnames: if not turtlebase.arcgis.is_fieldname(gp, input_fc, fieldname): errormsg = "fieldname %s not available in %s" % (fieldname, input_fc) log.error(errormsg) missing_fields.append(errormsg) if len(missing_fields) > 0: log.error("missing fields in input data: %s" % missing_fields) sys.exit(2) #---------------------------------------------------------------------------------------- # Environments log.info("Set environments") temp_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb) gp.Select_analysis(peilgebied, temp_peilgebieden) cellsize = gp.describe(input_ahn).MeanCellHeight # use same cell size as AHN gp.extent = gp.describe(temp_peilgebieden).extent # use extent from Peilgebieden gpgident = config.get('GENERAL', 'gpgident') #---------------------------------------------------------------------------------------- # create ahn ascii log.info("Create ascii from ahn") ahn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc") log.debug("ahn ascii: %s" % ahn_ascii) gp.RasterToASCII_conversion(input_ahn, ahn_ascii) #---------------------------------------------------------------------------------------- # create lgn ascii log.info("Create ascii from lgn") #read gpgident from file lgn_desc = gp.describe(input_lgn) if lgn_desc.DataType == 'ShapeFile' or lgn_desc.DataType == 'FeatureClass': lgn_fieldnames = nens.gp.get_table_def(gp, input_lgn) if "gridcode" in lgn_fieldnames: gridcode = "GRIDCODE" elif "grid_code" in lgn_fieldnames: gridcode = "grid_code" else: log.error("Cannot find 'grid_code' or 'gridcode' field in input lgn file") temp_lgn = turtlebase.arcgis.get_random_file_name(workspace_gdb) gp.FeatureToRaster_conversion(input_lgn, gridcode, temp_lgn, cellsize) elif lgn_desc.DataType == 'RasterDataset': temp_lgn = input_lgn if not lgn_desc.MeanCellHeight == cellsize: log.error("LGN cellsize does not match AHN cellsize (%sx%s m)" % cellsize) sys.exit(5) else: log.error("cannot recognize datatype of LGN, must be a fc, shapefile or a raster dataset") sys.exit(5) lgn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc") log.debug("lgn ascii: %s" % lgn_ascii) gp.RasterToASCII_conversion(temp_lgn, lgn_ascii) #---------------------------------------------------------------------------------------- log.info("Create ascii from surface level areas") if not turtlebase.arcgis.is_fieldname(gp, temp_peilgebieden, "ID_INT"): gp.AddField(temp_peilgebieden, "ID_INT", "LONG") id_int = 1 idint_to_peilvakid = {} peilvakid_to_idint = {} if turtlebase.arcgis.is_fieldname(gp, temp_peilgebieden, gpgident): rows = gp.SearchCursor(temp_peilgebieden) for row in nens.gp.gp_iterator(rows): peilvakid = row.GetValue(gpgident) idint_to_peilvakid[id_int] = peilvakid peilvakid_to_idint[peilvakid] = id_int id_int = id_int + 1 #each row gets a new id_int log.info(" - calc value ID_INT") rows = gp.UpdateCursor(temp_peilgebieden) for row in nens.gp.gp_iterator(rows): gpg_ident = row.GetValue(gpgident) id_int = peilvakid_to_idint[gpg_ident] row.SetValue("ID_INT", id_int) rows.UpdateRow(row) log.info("Conversion feature peilgebieden to raster") InField = "ID_INT" temp_peilgebieden_raster = turtlebase.arcgis.get_random_file_name(workspace_gdb) gp.FeatureToRaster_conversion(temp_peilgebieden, InField, temp_peilgebieden_raster, cellsize) peilgeb_asc = turtlebase.arcgis.get_random_file_name(workspace, ".asc") gp.RasterToASCII_conversion(temp_peilgebieden_raster, peilgeb_asc) #---------------------------------------------------------------------------------------- # Read input tables into dictionaries log.info("Read input tables") log.info(" - read RR_Peilgebied") rr_peilgebied = nens.gp.get_table(gp, input_rr_peilgebied, primary_key=gpgident.lower()) log.info(" - read RR_Maaiveld") rr_maaiveld = nens.gp.get_table(gp, input_rr_maaiveld, primary_key=gpgident.lower()) log.info(" - read conversion table between id_int and gpgident") gpg_conv = nens.gp.get_table(gp, temp_peilgebieden, primary_key='id_int') #---------------------------------------------------------------------------------------- log.info("Calculate Risk") temp_risico = turtlebase.arcgis.get_random_file_name(workspace, "risk.asc") temp_risico_in = turtlebase.arcgis.get_random_file_name(workspace, ".asc") risico_tbl = turtlebase.risico.create_risk_grid(ahn_ascii, lgn_ascii, peilgeb_asc, rr_peilgebied, rr_maaiveld, hymstat, gpg_conv, schadefuncties, temp_risico, temp_risico_in, cellsize) risk_result = turtlebase.risico.create_risico_dict(risico_tbl, schadefuncties, primary_key=gpgident) for k in risk_result.keys(): risk_result[k]['SOURCE'] = "hymstat: %s, ahn: %s, lgn: %s" % (os.path.basename(input_hymstat), os.path.basename(input_ahn), os.path.basename(input_lgn)) risk_result[k]['DATE_TIME'] = time.strftime("%d-%m-%Y, %H:%M:%S") gp.ASCIIToRaster_conversion(temp_risico, output_risico, "FLOAT") gp.ASCIIToRaster_conversion(temp_risico_in, output_risico_inundation, "FLOAT") # Schrijf de resultaten weg als een nieuwe tabel if not(gp.exists(output_risk_table)): log.info("creating table " + output_risk_table) gp.CreateTable(os.path.dirname(output_risk_table), os.path.basename(output_risk_table)) risk_fields = nens.gp.get_table_def(gp, output_risk_table) fields_to_add = [{'fieldname': gpgident, 'fieldtype': 'text', 'length': 50}, {'fieldname': 'RIS_GW', 'fieldtype': 'Double'}, {'fieldname': 'RIS_GW_ST', 'fieldtype': 'Double'}, {'fieldname': 'RIS_GW_HL', 'fieldtype': 'Double'}, {'fieldname': 'RIS_GW_AK', 'fieldtype': 'Double'}, {'fieldname': 'RIS_GW_GR', 'fieldtype': 'Double'}, {'fieldname': 'RIS_GW_NT', 'fieldtype': 'Double'}, {'fieldname': 'RIS_IN', 'fieldtype': 'Double'}, {'fieldname': 'RIS_IN_ST', 'fieldtype': 'Double'}, {'fieldname': 'RIS_IN_HL', 'fieldtype': 'Double'}, {'fieldname': 'RIS_IN_AK', 'fieldtype': 'Double'}, {'fieldname': 'RIS_IN_GR', 'fieldtype': 'Double'}, {'fieldname': 'RIS_IN_NT', 'fieldtype': 'Double'}, {'fieldname': 'SOURCE', 'fieldtype': 'text', 'length': 256}, {'fieldname': 'DATE_TIME', 'fieldtype': 'text', 'length': 25}, {'fieldname': 'COMMENTS', 'fieldtype': 'text', 'length': 256}] for field_to_add in fields_to_add: if field_to_add['fieldname'].lower() not in risk_fields: if 'length' in field_to_add: gp.addfield_management(output_risk_table, field_to_add['fieldname'], field_to_add['fieldtype'], "#", "#", field_to_add['length']) else: gp.addfield_management(output_risk_table, field_to_add['fieldname'], field_to_add['fieldtype']) turtlebase.arcgis.write_result_to_output(output_risk_table, gpgident, risk_result) #---------------------------------------------------------------------------------------- # Delete temporary workspace geodatabase & ascii files try: log.debug("delete temporary workspace: %s" % workspace_gdb) gp.delete(workspace_gdb) log.info("workspace deleted") except: log.debug("failed to delete %s" % workspace_gdb) tempfiles = os.listdir(workspace) for tempfile in tempfiles: if tempfile.endswith('.asc') or tempfile.endswith('.prj') : try: os.remove(os.path.join(workspace, tempfile)) log.debug("%s/%s removed" % (workspace, tempfile)) except Exception, e: log.debug(e) mainutils.log_footer()
def main(): try: gp = mainutils.create_geoprocessor() config = mainutils.read_config(__file__, 'turtle-settings.ini') logfile = mainutils.log_filename(config) logging_config = LoggingConfig(gp, logfile=logfile) mainutils.log_header(__name__) #--------------------------------------------------------------------- # Create workspace workspace = config.get('GENERAL', 'location_temp') if workspace == "-": import tempfile workspace = tempfile.gettempdir() log.info("workspace: %s" % workspace) turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace) if not os.path.isdir(workspace): os.makedirs(workspace) workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase( gp, workspace) if errorcode == 1: log.error("failed to create a file geodatabase in %s" % workspace) #--------------------------------------------------------------------- # Input parameters """ nodig voor deze tool: """ if len(sys.argv) == 5: input_level_area_fc = sys.argv[1] input_level_area_table = sys.argv[2] input_ahn_raster = sys.argv[3] output_surface_table = sys.argv[4] else: log.error("usage: <input_level_area_fc> <input_level_area_table> \ <input_ahn_raster> <output_surface_table>") sys.exit(1) #--------------------------------------------------------------------- # Check geometry input parameters cellsize = gp.describe(input_ahn_raster).MeanCellHeight log.info("Check geometry of input parameters") geometry_check_list = [] log.debug(" - check voronoi polygon: %s" % input_level_area_fc) if gp.describe(input_level_area_fc).ShapeType != 'Polygon': log.error("%s is not a polygon feature class!", input_level_area_fc) geometry_check_list.append(input_level_area_fc + " -> (Polygon)") if gp.describe(input_ahn_raster).PixelType[0] not in ['U', 'S']: log.error("Input AHN is a floating point raster, \ for this script an integer is necessary") geometry_check_list.append(input_ahn_raster + " -> (Integer)") if len(geometry_check_list) > 0: log.error("check input: %s" % geometry_check_list) sys.exit(2) else: print "A" #--------------------------------------------------------------------- # Check required fields in input data log.info("Check required fields in input data") missing_fields = [] # <check required fields from input data, # append them to list if missing>" if not turtlebase.arcgis.is_fieldname( gp, input_level_area_fc, config.get( 'maaiveldkarakteristiek', 'input_peilgebied_ident')): log.debug(" - missing: %s in %s" % ( config.get('maaiveldkarakteristiek', 'input_peilgebied_ident'), input_level_area_fc)) missing_fields.append("%s: %s" % ( input_level_area_fc, config.get('maaiveldkarakteristiek', 'input_peilgebied_ident'))) if not turtlebase.arcgis.is_fieldname( gp, input_level_area_table, config.get( 'maaiveldkarakteristiek', 'input_peilgebied_ident')): log.debug(" - missing: %s in %s" % ( config.get('maaiveldkarakteristiek', 'input_peilgebied_ident'), input_level_area_table)) missing_fields.append("%s: %s" % ( input_level_area_table, config.get( 'maaiveldkarakteristiek', 'input_peilgebied_ident'))) if len(missing_fields) > 0: log.error("missing fields in input data: %s" % missing_fields) sys.exit(2) #--------------------------------------------------------------------- # Environments log.info("Set environments") temp_level_area = os.path.join(workspace_gdb, "peilgebieden") gp.select_analysis(input_level_area_fc, temp_level_area) # use extent from level area gp.extent = gp.describe(temp_level_area).extent #--------------------------------------------------------------------- # create ahn ascii log.info("Create ascii from ahn") ahn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc") log.debug("ahn ascii: %s" % ahn_ascii) gp.RasterToASCII_conversion(input_ahn_raster, ahn_ascii) #--------------------------------------------------------------------- # Add ID Int to level area log.info("Create level area ascii") area_id_dict = add_integer_ident(gp, temp_level_area, config.get( 'maaiveldkarakteristiek', 'id_int').lower(), config.get('maaiveldkarakteristiek', 'input_peilgebied_ident')) out_raster_dataset = turtlebase.arcgis.get_random_file_name( workspace_gdb) gp.FeatureToRaster_conversion(temp_level_area, config.get( 'maaiveldkarakteristiek', 'id_int'), out_raster_dataset, cellsize) id_int_ascii = turtlebase.arcgis.get_random_file_name( workspace, ".asc") log.debug("id_int_ascii: %s" % id_int_ascii) gp.RasterToASCII_conversion(out_raster_dataset, id_int_ascii) #--------------------------------------------------------------------- log.info("Read targetlevel table") area_level_dict = nens.gp.get_table( gp, input_level_area_table, primary_key=config.get( 'maaiveldkarakteristiek', 'input_peilgebied_ident').lower()) target_level_dict = {} for k, v in area_level_dict.items(): if k in area_id_dict: id_int = area_id_dict[k][config.get('maaiveldkarakteristiek', 'id_int').lower()] target_level_dict[id_int] = { 'targetlevel': v[config.get( 'maaiveldkarakteristiek', 'field_streefpeil').lower()], 'gpgident': k, } #--------------------------------------------------------------------- log.info("create S-Curve") mv_procent_str = config.get('maaiveldkarakteristiek', 'mv_procent') field_range = mv_procent_str.split(', ') #scurve_dict = turtlebase.spatial.create_scurve(ahn_ascii, # id_int_ascii, target_level_dict, field_range) scurve_dict = turtlebase.spatial.surface_level_statistics( ahn_ascii, id_int_ascii, target_level_dict, field_range) #--------------------------------------------------------------------- log.info("Create output table") create_output_table(gp, output_surface_table, config.get( 'maaiveldkarakteristiek', 'input_peilgebied_ident'), field_range) #--------------------------------------------------------------------- # Add metadata import time date_time_str = time.strftime("%d %B %Y %H:%M:%S") source = input_ahn_raster for k, v in scurve_dict.items(): scurve_dict[k]['date_time'] = date_time_str scurve_dict[k]['source'] = source #--------------------------------------------------------------------- # Write results to output table log.info("Write results to output table") turtlebase.arcgis.write_result_to_output( output_surface_table, config.get( 'maaiveldkarakteristiek', 'input_peilgebied_ident').lower(), scurve_dict) #--------------------------------------------------------------------- # Delete temporary workspace geodatabase & ascii files try: log.debug("delete temporary workspace: %s" % workspace_gdb) #gp.delete(workspace_gdb) log.info("workspace deleted") except: log.warning("failed to delete %s" % workspace_gdb) tempfiles = os.listdir(workspace) for tempfile in tempfiles: if tempfile.endswith('.asc'): try: os.remove(os.path.join(workspace, tempfile)) except Exception, e: log.debug(e) mainutils.log_footer()
def main(): try: gp = mainutils.create_geoprocessor() config = mainutils.read_config(__file__, 'turtle-settings.ini') logfile = mainutils.log_filename(config) logging_config = LoggingConfig(gp, logfile=logfile) mainutils.log_header(__name__) #--------------------------------------------------------------------- # Create workspace workspace = config.get('GENERAL', 'location_temp') if workspace == "-": workspace = tempfile.gettempdir() turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace) if not os.path.isdir(workspace): os.makedirs(workspace) workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase( gp, workspace) if errorcode == 1: log.error("failed to create a file geodatabase in %s" % workspace) # Input parameters if len(sys.argv) == 11: # input parameters input_voronoi_polygon = sys.argv[1] input_rrcf_waterlevel = sys.argv[2] input_ahn_raster = sys.argv[3] input_lgn_raster = sys.argv[4] input_lgn_conversion = sys.argv[5] # output parameters output_result_table = sys.argv[6] # optional output output_inundation = sys.argv[7] if output_inundation == "#": output_inundation = os.path.join(workspace_gdb, "inun_nbw") if len(os.path.basename(output_inundation)) > 13: log.error("filename raster output (%s) cannot contain more than 13 characters" % os.path.basename(output_inundation)) sys.exit(1) output_waterdamage = sys.argv[8] if output_waterdamage == "#": output_waterdamage = os.path.join(workspace_gdb, "damage_nbw") if len(os.path.basename(output_waterdamage)) > 13: log.error("filename raster output (%s) cannot contain more than 13 characters" % os.path.basename(output_waterdamage)) sys.exit(1) output_inundation_total = sys.argv[9] if len(os.path.basename(output_inundation_total)) > 13: log.error("filename raster output (%s) cannot contain more than 13 characters" % os.path.basename(output_inundation_total)) sys.exit(1) output_waterdamage_total = sys.argv[10] if len(os.path.basename(output_waterdamage_total)) > 13: log.error("filename raster output (%s) cannot contain more than 13 characters" % os.path.basename(output_waterdamage_total)) sys.exit(1) else: log.error("usage: <input_voronoi_polygon> <input_rrcf_waterlevel> <input_ahn_raster> \ <input_lgn_raster> <input_lgn_conversion> <output_result_table> \ <output_inundation> <output_waterdamage> <output inundation total> <output waterdamage total>") sys.exit(1) #---------------------------------------------------------------------------------------- temp_voronoi = os.path.join(workspace_gdb, "voronoi") gp.select_analysis(input_voronoi_polygon, temp_voronoi) # Check geometry input parameters cellsize = gp.describe(input_ahn_raster).MeanCellHeight log.info("Check geometry of input parameters") geometry_check_list = [] if input_lgn_conversion != "#": if not gp.exists(input_lgn_conversion): errormsg = "%s does not exist" % input_lgn_conversion log.error(errormsg) geometry_check_list.append(errormsg) log.debug(" - check voronoi polygon: %s" % temp_voronoi) if gp.describe(temp_voronoi).ShapeType != 'Polygon': log.error("Input voronoi is not a polygon feature class!") geometry_check_list.append(temp_voronoi + " -> (Polygon)") log.debug(" - check ahn raster %s" % input_ahn_raster) if gp.describe(input_ahn_raster).DataType != 'RasterDataset': log.error("Input AHN is not a raster dataset") sys.exit(1) if gp.describe(input_ahn_raster).PixelType[0] not in ['U', 'S']: log.error("Input AHN is a floating point raster, for this script an integer is nessecary") geometry_check_list.append(input_ahn_raster + " -> (Integer)") log.debug(" - check lgn raster %s" % input_lgn_raster) if gp.describe(input_lgn_raster).DataType != 'RasterDataset': log.error("Input LGN is not a raster dataset") sys.exit(1) if gp.describe(input_lgn_raster).PixelType[0] not in ['U', 'S']: log.error("Input LGN is a floating point raster, for this script an integer is nessecary") geometry_check_list.append(input_lgn_raster + " -> (Integer)") if gp.describe(input_lgn_raster).MeanCellHeight != float(cellsize): log.error("Cell size of LGN is %s, must be %s" % ( gp.describe(input_lgn_raster).MeanCellHeight, cellsize)) geometry_check_list.append(input_lgn_raster + " -> (Cellsize %s)" % cellsize) if len(geometry_check_list) > 0: log.error("check input: %s" % geometry_check_list) sys.exit(2) #---------------------------------------------------------------------------------------- # Check required fields in database log.info("Check required fields in input data") # create return period list return_periods = config.get('naverwerking_rrcf', 'herhalingstijden').split(", ") log.debug(" - return periods: %s" % return_periods) missing_fields = [] for return_period in return_periods: if not turtlebase.arcgis.is_fieldname(gp, input_rrcf_waterlevel, "WS_%s" % return_period): log.debug(" - missing: %s in %s" % ("WS_%s" % return_period, input_rrcf_waterlevel)) missing_fields.append("%s: %s" % (input_rrcf_waterlevel, "WS_%s" % return_period)) #<check required fields from input data, append them to list if missing>" field_streefpeil = config.get('naverwerking_rrcf', 'field_streefpeil') check_fields = {input_rrcf_waterlevel: [config.get('naverwerking_rrcf', 'calculation_point_ident'), field_streefpeil]} if input_lgn_conversion != "#": check_fields[input_lgn_conversion] = [config.get('naverwerking_rrcf', 'lgn_conv_ident'), config.get('naverwerking_rrcf', 'input_field_k5')] for input_fc, fieldnames in check_fields.items(): for fieldname in fieldnames: if not turtlebase.arcgis.is_fieldname(gp, input_fc, fieldname): errormsg = "fieldname %s not available in %s" % (fieldname, input_fc) log.error(errormsg) missing_fields.append(errormsg) if len(missing_fields) > 0: log.error("missing fields in input data: %s" % missing_fields) sys.exit(2) #--------------------------------------------------------------------- # Environments log.info("Set environments") gp.extent = gp.describe(temp_voronoi).extent # use extent from LGN #--------------------------------------------------------------------- # read waterlevel table as a dictionary log.info("Read waterlevel table") waterlevel_dict = nens.gp.get_table(gp, input_rrcf_waterlevel, primary_key=config.get('naverwerking_rrcf', 'calculation_point_ident').lower()) log.debug(waterlevel_dict) # Add fields to output for return_period in return_periods: if not turtlebase.arcgis.is_fieldname(gp, temp_voronoi, "WS_%s" % return_period): log.info(" - add field WS_%s" % return_period) gp.addfield(temp_voronoi, "WS_%s" % return_period, "double") if not turtlebase.arcgis.is_fieldname(gp, temp_voronoi, field_streefpeil): log.info(" - add field %s" % field_streefpeil) gp.addfield(temp_voronoi, field_streefpeil, "double") # copy waterlevel to voronoi polygons rows = gp.UpdateCursor(temp_voronoi) for row in nens.gp.gp_iterator(rows): row_id = row.GetValue(config.get('naverwerking_rrcf', 'calculation_point_ident')) if row_id in waterlevel_dict: log.debug(waterlevel_dict[row_id]) for return_period in return_periods: row.SetValue("WS_%s" % return_period, waterlevel_dict[row_id]['ws_%s' % return_period]) row.SetValue(field_streefpeil, waterlevel_dict[row_id][field_streefpeil.lower()]) rows.UpdateRow(row) #--------------------------------------------------------------------- # Create waterlevel rasters log.info("Create rasters for waterlevels") for return_period in return_periods: log.info(" - create raster for ws_%s" % return_period) out_raster_dataset = workspace_gdb + "/ws_%s" % return_period gp.FeatureToRaster_conversion(temp_voronoi, "WS_%s" % return_period, out_raster_dataset, cellsize) #--------------------------------------------------------------------- # Create target level raster log.info("Create targetlevel raster") out_raster_targetlevel = os.path.join(workspace_gdb, "targetlv") gp.FeatureToRaster_conversion(temp_voronoi, field_streefpeil, out_raster_targetlevel, cellsize) #--------------------------------------------------------------------- # Create freeboard raster log.info("Create freeboard raster") # create ahn ascii ahn_ascii = os.path.join(workspace, "ahn.asc") log.debug("ahn ascii: %s" % ahn_ascii) gp.RasterToASCII_conversion(input_ahn_raster, ahn_ascii) targetlevel_ascii = os.path.join(workspace, "targetlvl.asc") log.debug("targetlevel ascii: %s" % targetlevel_ascii) gp.RasterToASCII_conversion(out_raster_targetlevel, targetlevel_ascii) freeboard_ascii = os.path.join(workspace, "freeboard.asc") turtlebase.spatial.create_freeboard_raster(ahn_ascii, targetlevel_ascii, freeboard_ascii) #---------------------------------------------------------------------------------------- # Create K5 LGN log.info("Reclass LGN to K5 raster") lgn_ascii = os.path.join(workspace, "lgn.asc") lgn_k5_ascii = os.path.join(workspace, "lgn_k5.asc") gp.RasterToASCII_conversion(input_lgn_raster, lgn_ascii) if input_lgn_conversion != '#': reclass_dict = nens.gp.get_table(gp, input_lgn_conversion, primary_key=config.get('naverwerking_rrcf', 'lgn_conv_ident').lower()) turtlebase.spatial.reclass_lgn_k5(lgn_ascii, lgn_k5_ascii, reclass_dict) else: turtlebase.spatial.reclass_lgn_k5(lgn_ascii, lgn_k5_ascii) #---------------------------------------------------------------------------------------- # Create inundation raster # als ws_ > ahn, dan inundatie inundation_raster_list = [] inundation_total_raster_list = [] log.info("Create inundation rasters") # inundatie stedelijk return_period_urban = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_stedelijk') if config.get('naverwerking_rrcf', 'percentage_inundatie_stedelijk') != "-": log.info(" - create inundation urban") waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_urban) if gp.exists(waterlevel): inundation_urban = os.path.join(workspace, "inun_urban.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 1, return_period_urban, inundation_urban, workspace, use_lgn=True) inundation_raster_list.append(inundation_urban) if output_inundation_total != '#': # Inundation without lgn inundation_total_urban = os.path.join(workspace, "inun_total_urban.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 1, return_period_urban, inundation_total_urban, workspace, use_lgn=False) inundation_total_raster_list.append(inundation_total_urban) else: log.error("%s does not exists! check ini-file and tempfolder" % waterlevel) # inundatie hoogwaardige landbouw return_period_agriculture = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_hoogwaardig') if config.get('naverwerking_rrcf', 'percentage_inundatie_hoogwaardig') != "-": log.info(" - create inundation agriculture") waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_agriculture) if gp.exists(waterlevel): # Inundation with lgn inundation_agriculture = os.path.join(workspace, "inun_agri.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 2, return_period_agriculture, inundation_agriculture, workspace, use_lgn=True) inundation_raster_list.append(inundation_agriculture) if output_inundation_total != '#': # Inundation without lgn inundation_total_agriculture = os.path.join(workspace, "inun_total_agri.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 2, return_period_agriculture, inundation_total_agriculture, workspace, use_lgn=False) inundation_total_raster_list.append(inundation_total_agriculture) else: log.error("%s does not exists! check ini-file and tempfolder" % waterlevel) # inundatie akkerbouw return_period_rural = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_akker') if config.get('naverwerking_rrcf', 'percentage_inundatie_akker') != "-": log.info(" - create inundation rural") waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_rural) if gp.exists(waterlevel): inundation_rural = os.path.join(workspace, "inun_rural.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 3, return_period_rural, inundation_rural, workspace, use_lgn=True) inundation_raster_list.append(inundation_rural) if output_inundation_total != '#': # Inundation without lgn inundation_total_rural = os.path.join(workspace, "inun_total_rural.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 3, return_period_rural, inundation_total_rural, workspace, use_lgn=False) inundation_total_raster_list.append(inundation_total_rural) else: log.error("%s does not exists! check ini-file and tempfolder" % waterlevel) # inundatie grasland return_period_grass = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_grasland') if config.get('naverwerking_rrcf', 'percentage_inundatie_grasland') != "-": log.info(" - create inundation grass") waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_grass) if gp.exists(waterlevel): log.debug("waterlevel grasland = %s" % waterlevel) inundation_grass = os.path.join(workspace, "inun_grass.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 4, return_period_grass, inundation_grass, workspace, use_lgn=True) inundation_raster_list.append(inundation_grass) if output_inundation_total != '#': # Inundation without lgn inundation_total_grass = os.path.join(workspace, "inun_total_grass.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 4, return_period_grass, inundation_total_grass, workspace, use_lgn=False) inundation_total_raster_list.append(inundation_total_grass) else: log.error("%s does not exists! check ini-file and tempfolder" % waterlevel) if len(inundation_raster_list) > 1: log.info("Merge inundation rasters") output_inundation_exists = turtlebase.spatial.merge_ascii(inundation_raster_list, output_inundation, workspace) else: log.error("there are no inundation rasters available") if len(inundation_total_raster_list) > 1: log.info("Merge inundation total rasters") turtlebase.spatial.merge_ascii(inundation_total_raster_list, output_inundation_total, workspace) #---------------------------------------------------------------------------------------- # Create waterdamage raster # als ws_ > freeboard, dan overlast damage_raster_list = [] damage_total_raster_list = [] log.info("Create waterdamage rasters") # overlast stedelijk return_period_urban_damage = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_stedelijk') if config.get('naverwerking_rrcf', 'percentage_overlast_stedelijk') != "-": log.info(" - create waterdamage urban") waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_urban_damage) if gp.exists(waterlevel): damage_urban = os.path.join(workspace, "damage_urban.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, freeboard_ascii, waterlevel, 1, return_period_urban_damage, damage_urban, workspace, use_lgn=True) damage_raster_list.append(damage_urban) if output_waterdamage_total != '#': # Waterdamage without lgn damage_total_urban = os.path.join(workspace, "damage_total_urban.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 1, return_period_urban_damage, damage_total_urban, workspace, use_lgn=False) damage_total_raster_list.append(damage_total_urban) else: log.error("%s does not exists! check ini-file and tempfolder" % waterlevel) # overlast hoogwaardig return_period_agriculture_damage = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_hoogwaardig') if config.get('naverwerking_rrcf', 'percentage_overlast_hoogwaardig') != "-": log.info(" - create waterdamage agriculture") waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_agriculture_damage) if gp.exists(waterlevel): damage_agriculture = workspace + "/damage_agri_%s.asc" % return_period_agriculture_damage turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, freeboard_ascii, waterlevel, 2, return_period_agriculture_damage, damage_agriculture, workspace, use_lgn=True) damage_raster_list.append(damage_agriculture) if output_waterdamage_total != '#': # Waterdamage without lgn damage_total_agriculture = os.path.join(workspace, "damage_total_agri.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 1, return_period_agriculture_damage, damage_total_agriculture, workspace, use_lgn=False) damage_total_raster_list.append(damage_total_agriculture) else: log.error("%s does not exists! check ini-file and tempfolder" % waterlevel) # overlast akker return_period_rural_damage = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_akker') if config.get('naverwerking_rrcf', 'percentage_overlast_akker') != "-": log.info(" - create waterdamage rural") waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_rural_damage) if gp.exists(waterlevel): damage_rural = workspace + "/damage_rural_%s.asc" % return_period_rural_damage turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, freeboard_ascii, waterlevel, 3, return_period_rural_damage, damage_rural, workspace, use_lgn=True) damage_raster_list.append(damage_rural) if output_waterdamage_total != '#': # Waterdamage without lgn damage_total_rural = os.path.join(workspace_gdb, "damage_total_rural.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 1, return_period_rural_damage, damage_total_rural, workspace, use_lgn=False) damage_total_raster_list.append(damage_total_rural) else: log.error("%s does not exists! check ini-file and tempfolder" % waterlevel) # overlast grasland return_period_grass_damage = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_grasland') if config.get('naverwerking_rrcf', 'percentage_overlast_grasland') != "-": log.info(" - create waterdamage grass") waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_grass_damage) if gp.exists(waterlevel): damage_grass = os.path.join(workspace_gdb, "damage_grass.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, freeboard_ascii, waterlevel, 4, return_period_grass_damage, damage_grass, workspace, use_lgn=True) damage_raster_list.append(damage_grass) if output_waterdamage_total != '#': # Waterdamage without lgn damage_total_grass = os.path.join(workspace_gdb, "damage_total_grass.asc") turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 1, return_period_grass_damage, damage_total_grass, workspace, use_lgn=False) damage_total_raster_list.append(damage_total_grass) else: log.error("%s does not exists! check ini-file and tempfolder" % waterlevel) # Merge waterdamage rasters if len(damage_raster_list) > 1: log.info("Merge waterdamage rasters") output_waterdamage_exists = turtlebase.spatial.merge_ascii(damage_raster_list, output_waterdamage, workspace) else: log.error("there are no waterdamage rasters available") if len(damage_total_raster_list) > 1: log.info("Merge waterdamage total rasters") turtlebase.spatial.merge_ascii(damage_total_raster_list, output_waterdamage_total, workspace) #---------------------------------------------------------------------------------------- # calculate percentage inundation """ input: - inundatie / overlast (raster dataset) - input_voronoi_polygon (met GPGIDENT) (feature class) - lgn_k5 (raster dataset) """ gpgident_field = config.get('General', 'gpgident') # dissolve voronoi based on gpgident log.debug("dissolve voronoi polygons, based on gpgident") temp_fc_gpgident = os.path.join(workspace_gdb, "temp_fc_gpgident") gp.Dissolve_management(temp_voronoi, temp_fc_gpgident, gpgident_field) # Calculate area total, gpgident if not turtlebase.arcgis.is_fieldname(gp, temp_fc_gpgident, "area_total"): gp.addfield(temp_fc_gpgident, "area_total", "Double") turtlebase.arcgis.calculate_area(gp, temp_fc_gpgident, "area_total") gpgident_dict = nens.gp.get_table(gp, temp_fc_gpgident, primary_key=gpgident_field.lower()) log.debug("gpgident_dict: %s" % gpgident_dict) # create feature class from lgn k5 ascii output_reclass_lgn = os.path.join(workspace_gdb, "reclass_lgn") gp.ASCIIToRaster_conversion(lgn_k5_ascii, output_reclass_lgn) temp_fc_lgn = os.path.join(workspace_gdb, "fc_lgn") gp.RasterToPolygon_conversion(output_reclass_lgn, temp_fc_lgn, "NO_SIMPLIFY") # union lgn with gpg-areas temp_fc_union_lgn = os.path.join(workspace_gdb, "fc_union_lgn") gp.Union_analysis(temp_fc_gpgident + ";" + temp_fc_lgn, temp_fc_union_lgn) dissolve_lyr = turtlebase.arcgis.get_random_layer_name() gp.MakeFeatureLayer_management(temp_fc_union_lgn, dissolve_lyr, "%s <> ''" % gpgident_field) temp_fc_dissolve_lgn = os.path.join(workspace_gdb, "dissolve_lgn") if turtlebase.arcgis.is_fieldname(gp, dissolve_lyr, "GRIDCODE"): gp.Dissolve_management(dissolve_lyr, temp_fc_dissolve_lgn, "%s; GRIDCODE" % gpgident_field) gridcode = "gridcode" elif turtlebase.arcgis.is_fieldname(gp, dissolve_lyr, "grid_code"): gp.Dissolve_management(dissolve_lyr, temp_fc_dissolve_lgn, "%s; grid_code" % gpgident_field) gridcode = "grid_code" else: log.error("no field GRIDCODE or grid_code available in %s" % dissolve_lyr) sys.exit(2) # Calculate area lgn if not turtlebase.arcgis.is_fieldname(gp, temp_fc_dissolve_lgn, "area_lgn"): gp.addfield(temp_fc_dissolve_lgn, "area_lgn", "Double") turtlebase.arcgis.calculate_area(gp, temp_fc_dissolve_lgn, "area_lgn") lgn_dict = nens.gp.get_table(gp, temp_fc_dissolve_lgn) translate_lgn_dict = translate_dict(lgn_dict, gridcode, 'area_lgn') log.debug("translate_lgn_dict: %s" % translate_lgn_dict) # Create feature class from inundation_grid """ values: 10, 25, 50, 100""" if output_inundation_exists == 0: temp_fc_inundation = os.path.join(workspace_gdb, "inundation") log.info(output_inundation) gp.RasterToPolygon_conversion(output_inundation, temp_fc_inundation, "NO_SIMPLIFY") temp_fc_union_inundation = os.path.join(workspace_gdb, "union_inun") gp.Union_analysis(temp_fc_dissolve_lgn + ";" + temp_fc_inundation, temp_fc_union_inundation) dissolve_inundation_lyr = turtlebase.arcgis.get_random_layer_name() if turtlebase.arcgis.is_fieldname(gp, temp_fc_union_inundation, "GRIDCODE_1"): gp.MakeFeatureLayer_management(temp_fc_union_inundation, dissolve_inundation_lyr, "GRIDCODE_1 > 0") gridcode_1 = "gridcode_1" elif turtlebase.arcgis.is_fieldname(gp, temp_fc_union_inundation, "GRID_CODE1"): gp.MakeFeatureLayer_management(temp_fc_union_inundation, dissolve_inundation_lyr, "GRID_CODE1 > 0") gridcode_1 = "grid_code1" elif turtlebase.arcgis.is_fieldname(gp, temp_fc_union_inundation, "GRID_CODE_1"): gp.MakeFeatureLayer_management(temp_fc_union_inundation, dissolve_inundation_lyr, "GRID_CODE_1 > 0") gridcode_1 = "grid_code_1" else: log.error("No field available named gridcode_1 or grid_code1") log.warning(nens.gp.get_table_def(gp, temp_fc_union_inundation)) sys.exit(1) temp_fc_dissolve_inundation = os.path.join(workspace_gdb, "dissolve_inun") dissolve_string = "%s;%s;%s" % (gpgident_field.upper(), gridcode, gridcode_1) log.debug(" - dissolve layer: %s" % dissolve_inundation_lyr) gp.Dissolve_management(dissolve_inundation_lyr, temp_fc_dissolve_inundation, dissolve_string) # Calculate area inundation if not turtlebase.arcgis.is_fieldname(gp, temp_fc_dissolve_inundation, "area_inund"): gp.addfield(temp_fc_dissolve_inundation, "area_inun", "Double") turtlebase.arcgis.calculate_area(gp, temp_fc_dissolve_inundation, "area_inun") inundation_dict = nens.gp.get_table(gp, temp_fc_dissolve_inundation) translate_inundation_dict = translate_dict(inundation_dict, gridcode_1, 'area_inun') log.debug("translate_inundation_dict: %s" % translate_inundation_dict) else: translate_inundation_dict = {} # Create feature class from waterdamage grid """ values: 10, 15, 25""" if output_waterdamage_exists == 0: try: temp_fc_waterdamage = os.path.join(workspace_gdb, "damage") gp.RasterToPolygon_conversion(output_waterdamage, temp_fc_waterdamage, "NO_SIMPLIFY") waterdamage = True except: log.warning("waterdamage raster is empty") waterdamage = False if waterdamage: temp_fc_union_waterdamage = os.path.join(workspace_gdb, "damage_union") gp.Union_analysis(temp_fc_dissolve_lgn + ";" + temp_fc_waterdamage, temp_fc_union_waterdamage) dissolve_waterdamage_lyr = turtlebase.arcgis.get_random_layer_name() gp.MakeFeatureLayer_management(temp_fc_union_waterdamage, dissolve_waterdamage_lyr, "%s > 0" % gridcode_1) temp_fc_dissolve_waterdamage = os.path.join(workspace_gdb, "dissolve_damage") gp.Dissolve_management(dissolve_waterdamage_lyr, temp_fc_dissolve_waterdamage, "%s; %s; %s" % (gpgident_field, gridcode, gridcode_1)) # Calculate area waterdamage if not turtlebase.arcgis.is_fieldname(gp, temp_fc_dissolve_waterdamage, "area_damag"): gp.addfield(temp_fc_dissolve_waterdamage, "area_damag", "Double") turtlebase.arcgis.calculate_area(gp, temp_fc_dissolve_waterdamage, "area_damag") waterdamage_dict = nens.gp.get_table(gp, temp_fc_dissolve_waterdamage) translate_waterdamage_dict = translate_dict(waterdamage_dict, gridcode_1, 'area_damag') log.debug("translate_waterdamage_dict: %s" % translate_waterdamage_dict) else: translate_waterdamage_dict = {} else: translate_waterdamage_dict = {} no_data_value = float(config.get('naverwerking_rrcf', 'no_data_value')) result_dict = {} log.info("Calculating results") for gpgident, fields in gpgident_dict.items(): # area_total #area_total = fields['area_total'] #set defaults percentage_inundation_urban = no_data_value percentage_inundation_agriculture = no_data_value percentage_inundation_rural = no_data_value percentage_inundation_grass = no_data_value toetsing_inundation_urban = 9 toetsing_inundation_agriculture = 9 toetsing_inundation_rural = 9 toetsing_inundation_grass = 9 percentage_waterdamage_urban = no_data_value percentage_waterdamage_agriculture = no_data_value percentage_waterdamage_rural = no_data_value percentage_waterdamage_grass = no_data_value toetsing_waterdamage_urban = 9 toetsing_waterdamage_agriculture = 9 toetsing_waterdamage_rural = 9 toetsing_waterdamage_grass = 9 if gpgident in translate_inundation_dict: log.debug("Calculate percentage inundation for %s" % gpgident) hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_stedelijk') toetsing_perc = config.get('naverwerking_rrcf', 'percentage_inundatie_stedelijk') toetsing_inundation_urban, percentage_inundation_urban = calculate_toetsing(translate_inundation_dict, gpgident, 1, translate_lgn_dict, hhtijd, toetsing_perc, no_data_value) hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_hoogwaardig') toetsing_perc = config.get('naverwerking_rrcf', 'percentage_inundatie_hoogwaardig') toetsing_inundation_agriculture, percentage_inundation_agriculture = calculate_toetsing(translate_inundation_dict, gpgident, 2, translate_lgn_dict, hhtijd, toetsing_perc, no_data_value) hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_akker') toetsing_perc = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_akker') toetsing_inundation_rural, percentage_inundation_rural = calculate_toetsing(translate_inundation_dict, gpgident, 3, translate_lgn_dict, hhtijd, toetsing_perc, no_data_value) hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_grasland') toetsing_perc = config.get('naverwerking_rrcf', 'percentage_inundatie_grasland') toetsing_inundation_grass, percentage_inundation_grass = calculate_toetsing(translate_inundation_dict, gpgident, 4, translate_lgn_dict, hhtijd, toetsing_perc, no_data_value) if gpgident in translate_waterdamage_dict: log.debug("Calculate percentage waterdamage for %s" % gpgident) hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_stedelijk') toetsing_perc = config.get('naverwerking_rrcf', 'percentage_overlast_stedelijk') toetsing_waterdamage_urban, percentage_waterdamage_urban = calculate_toetsing(translate_inundation_dict, gpgident, 1, translate_lgn_dict, hhtijd, toetsing_perc, no_data_value) hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_hoogwaardig') toetsing_perc = config.get('naverwerking_rrcf', 'percentage_overlast_hoogwaardig') toetsing_waterdamage_agriculture, percentage_waterdamage_agriculture = calculate_toetsing(translate_inundation_dict, gpgident, 2, translate_lgn_dict, hhtijd, toetsing_perc, no_data_value) hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_akker') toetsing_perc = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_akker') toetsing_inundation_rural, percentage_waterdamage_rural = calculate_toetsing(translate_inundation_dict, gpgident, 3, translate_lgn_dict, hhtijd, toetsing_perc, no_data_value) hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_grasland') toetsing_perc = config.get('naverwerking_rrcf', 'percentage_overlast_grasland') toetsing_inundation_grass, percentage_waterdamage_grass = calculate_toetsing(translate_inundation_dict, gpgident, 4, translate_lgn_dict, hhtijd, toetsing_perc, no_data_value) result_dict[gpgident] = { gpgident_field: gpgident, config.get('naverwerking_rrcf', 'field_percentage_inundatie_stedelijk'): percentage_inundation_urban, config.get('naverwerking_rrcf', 'field_percentage_inundatie_hoogwaardig'): percentage_inundation_agriculture, config.get('naverwerking_rrcf', 'field_percentage_inundatie_akker'): percentage_inundation_rural, config.get('naverwerking_rrcf', 'field_percentage_inundatie_grasland'): percentage_inundation_grass, config.get('naverwerking_rrcf', 'field_percentage_overlast_stedelijk'): percentage_waterdamage_urban, config.get('naverwerking_rrcf', 'field_percentage_overlast_hoogwaardig'): percentage_waterdamage_agriculture, config.get('naverwerking_rrcf', 'field_percentage_overlast_akker'): percentage_waterdamage_rural, config.get('naverwerking_rrcf', 'field_percentage_overlast_grasland'): percentage_waterdamage_grass, config.get('naverwerking_rrcf', 'field_toetsing_inundatie_stedelijk'): toetsing_inundation_urban, config.get('naverwerking_rrcf', 'field_toetsing_inundatie_hoogwaardig'): toetsing_inundation_agriculture, config.get('naverwerking_rrcf', 'field_toetsing_inundatie_akker'): toetsing_inundation_rural, config.get('naverwerking_rrcf', 'field_toetsing_inundatie_grasland'): toetsing_inundation_grass, config.get('naverwerking_rrcf', 'field_toetsing_overlast_stedelijk'): toetsing_waterdamage_urban, config.get('naverwerking_rrcf', 'field_toetsing_overlast_hoogwaardig'): toetsing_waterdamage_agriculture, config.get('naverwerking_rrcf', 'field_toetsing_overlast_akker'): toetsing_waterdamage_rural, config.get('naverwerking_rrcf', 'field_toetsing_overlast_grasland'): toetsing_waterdamage_grass, } #--------------------------------------------------------------------- # Create output table if not gp.exists(output_result_table): log.info("Create new output table") temp_result_table = os.path.join(workspace_gdb, "result_table") gp.CreateTable_management(os.path.dirname(temp_result_table), os.path.basename(temp_result_table)) copy_table = True else: temp_result_table = output_result_table copy_table = False fields_to_add = [config.get('naverwerking_rrcf', 'field_percentage_inundatie_stedelijk'), config.get('naverwerking_rrcf', 'field_percentage_inundatie_hoogwaardig'), config.get('naverwerking_rrcf', 'field_percentage_inundatie_akker'), config.get('naverwerking_rrcf', 'field_percentage_inundatie_grasland'), config.get('naverwerking_rrcf', 'field_percentage_overlast_stedelijk'), config.get('naverwerking_rrcf', 'field_percentage_overlast_hoogwaardig'), config.get('naverwerking_rrcf', 'field_percentage_overlast_akker'), config.get('naverwerking_rrcf', 'field_percentage_overlast_grasland'), config.get('naverwerking_rrcf', 'field_toetsing_inundatie_stedelijk'), config.get('naverwerking_rrcf', 'field_toetsing_inundatie_hoogwaardig'), config.get('naverwerking_rrcf', 'field_toetsing_inundatie_akker'), config.get('naverwerking_rrcf', 'field_toetsing_inundatie_grasland'), config.get('naverwerking_rrcf', 'field_toetsing_overlast_stedelijk'), config.get('naverwerking_rrcf', 'field_toetsing_overlast_hoogwaardig'), config.get('naverwerking_rrcf', 'field_toetsing_overlast_akker'), config.get('naverwerking_rrcf', 'field_toetsing_overlast_grasland')] if not turtlebase.arcgis.is_fieldname(gp, temp_result_table, gpgident_field): log.debug(" - add field %s to %s" % (gpgident_field, temp_result_table)) gp.addfield_management(temp_result_table, gpgident_field, 'text') for field in fields_to_add: if not turtlebase.arcgis.is_fieldname(gp, temp_result_table, field): log.debug(" - add field %s to %s" % (field, temp_result_table)) gp.addfield_management(temp_result_table, field, 'double') #---------------------------------------------------------------------------------------- # Write results to output table log.info("Write results to output table") turtlebase.arcgis.write_result_to_output(temp_result_table, gpgident_field.lower(), result_dict) if copy_table == True: gp.TableToTable_conversion(temp_result_table, os.path.dirname(output_result_table), os.path.basename(output_result_table)) #--------------------------------------------------------------------- # Delete temporary workspace geodatabase & ascii files try: log.debug("delete temporary workspace: %s" % workspace_gdb) gp.delete(workspace_gdb) log.info("workspace deleted") except: log.debug("failed to delete %s" % workspace_gdb) tempfiles = os.listdir(workspace) for tempfile in tempfiles: if tempfile.endswith('.asc'): try: os.remove(os.path.join(workspace, tempfile)) except Exception, e: log.debug(e) mainutils.log_footer()
def main(): try: gp = mainutils.create_geoprocessor() config = mainutils.read_config(__file__, 'turtle-settings.ini') logfile = mainutils.log_filename(config) logging_config = LoggingConfig(gp, logfile=logfile) mainutils.log_header(__name__) #--------------------------------------------------------------------- # Create workspace workspace = config.get('GENERAL', 'location_temp') if workspace == "-": workspace = tempfile.gettempdir() turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace) if not os.path.isdir(workspace): os.makedirs(workspace) workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase( gp, workspace) if errorcode == 1: log.error("failed to create a file geodatabase in %s" % workspace) #--------------------------------------------------------------------- # check inputfields log.info("Getting commandline parameters") if len(sys.argv) == 8: input_level_area_fc = sys.argv[1] input_level_area_table = sys.argv[2] input_ahn_raster = sys.argv[3] input_lgn_raster = sys.argv[4] input_lgn_conversion = sys.argv[5] input_onderbemalingen = sys.argv[6] if input_onderbemalingen == "#": use_onderbemalingen = False else: use_onderbemalingen = True output_file = sys.argv[7] else: log.error("Usage: python toetspuntenbepaling.py <ahn-file> \ <lgn-file> <onderbemalingen-optional> \ <peilgebieden-feature> <peilvakgegevens-table> \ <conversietabel> <outputfile-HydroBase>") sys.exit(1) #--------------------------------------------------------------------- # check input parameters log.info('Checking presence of input files') if not(gp.exists(input_level_area_fc)): log.error("inputfile peilgebieden %s does not exist!", input_level_area_fc) sys.exit(5) if not(gp.exists(input_level_area_table)): log.error("inputfile peilvakgegevens %s does not exist!", input_level_area_table) sys.exit(5) if (use_onderbemalingen and not(gp.exists(input_onderbemalingen))): log.error("inputfile onderbemalingen %s does not exist!", input_onderbemalingen) sys.exit(5) log.info('input parameters checked') #--------------------------------------------------------------------- # Check geometry input parameters cellsize = gp.describe(input_ahn_raster).MeanCellHeight log.info("Check geometry of input parameters") geometry_check_list = [] log.debug(" - check level area: %s" % input_level_area_fc) if gp.describe(input_level_area_fc).ShapeType != 'Polygon': errormsg = ("%s is not a polygon feature class!", input_level_area_fc) log.error(errormsg) geometry_check_list.append(errormsg) if turtlebase.arcgis.fc_is_not_empty(gp, input_level_area_fc): errormsg = "input '%s' is empty" % input_level_area_fc log.error(errormsg) sys.exit(1) if turtlebase.arcgis.fc_is_not_empty(gp, input_level_area_table): errormsg = "input '%s' is empty" % input_level_area_table log.error(errormsg) sys.exit(1) if use_onderbemalingen: if turtlebase.arcgis.fc_is_not_empty(gp, input_onderbemalingen): errormsg = "input '%s' is empty" % input_onderbemalingen log.error(errormsg) sys.exit(1) log.debug(" - check ahn raster %s" % input_ahn_raster) if gp.describe(input_ahn_raster).DataType != 'RasterDataset': log.error("Input AHN is not a raster dataset") sys.exit(1) if gp.describe(input_ahn_raster).PixelType[0] not in ['U', 'S']: errormsg = ("Input AHN is a floating point raster, \ for this script an integer is nessecary") log.error(errormsg) geometry_check_list.append(errormsg) log.debug(" - check lgn raster %s" % input_lgn_raster) if gp.describe(input_lgn_raster).DataType != 'RasterDataset': log.error("Input LGN is not a raster dataset") sys.exit(1) if gp.describe(input_lgn_raster).PixelType[0] not in ['U', 'S']: errormsg = ("Input LGN is a floating point raster, \ for this script an integer is nessecary") log.error(errormsg) geometry_check_list.append(errormsg) if int(gp.describe(input_lgn_raster).MeanCellHeight) != int(cellsize): errormsg = ("Cell size of LGN is %s, must be %s" % ( gp.describe(input_lgn_raster).MeanCellHeight, int(cellsize))) log.error(errormsg) geometry_check_list.append(errormsg) if len(geometry_check_list) > 0: log.error("check input: %s" % geometry_check_list) sys.exit(2) #--------------------------------------------------------------------- # Check required fields in input data log.info("Check required fields in input data") gpgident = config.get('GENERAL', 'gpgident').lower() streefpeil = config.get('toetspunten', 'field_streefpeil').lower() missing_fields = [] # check required fields from input data, append them to list if missing if not turtlebase.arcgis.is_fieldname( gp, input_level_area_fc, gpgident): log.debug(" - missing: %s in %s", ( gpgident, input_level_area_fc)) missing_fields.append("%s: %s", ( input_level_area_fc, gpgident)) if not turtlebase.arcgis.is_fieldname( gp, input_level_area_table, gpgident): log.debug(" - missing: %s in %s", ( gpgident, input_level_area_table)) missing_fields.append("%s: %s", ( input_level_area_table, gpgident)) if not turtlebase.arcgis.is_fieldname( gp, input_level_area_table, streefpeil): log.debug(" - missing: %s in %s", ( streefpeil, input_level_area_table)) missing_fields.append("%s: %s", ( input_level_area_table, streefpeil)) if len(missing_fields) > 0: log.error("missing fields in input data: %s", missing_fields) sys.exit(2) #--------------------------------------------------------------------- # Environments log.info("Set environments") temp_level_area = os.path.join(workspace_gdb, "peilgebieden") if input_level_area_fc.endswith(".shp"): log.info("Copy features of level areas to workspace") gp.select_analysis(input_level_area_fc, temp_level_area) else: log.info("Copy level areas to workspace") gp.copy_management(input_level_area_fc, temp_level_area) # use extent from level area gp.extent = gp.describe(temp_level_area).extent #--------------------------------------------------------------------- # Create K5 LGN log.info("Translate LGN to NBW-classes") lgn_ascii = turtlebase.arcgis.get_random_file_name( workspace, ".asc") lgn_k5_ascii = turtlebase.arcgis.get_random_file_name( workspace, ".asc") gp.RasterToASCII_conversion(input_lgn_raster, lgn_ascii) lgn_ident = config.get('toetspunten', 'lgn_conv_ident') if input_lgn_conversion != '#': reclass_dict = nens.gp.get_table(gp, input_lgn_conversion, primary_key=lgn_ident) turtlebase.spatial.reclass_lgn_k5( lgn_ascii, lgn_k5_ascii, reclass_dict) else: turtlebase.spatial.reclass_lgn_k5(lgn_ascii, lgn_k5_ascii) #--------------------------------------------------------------------- # create ahn ascii log.info("Create ascii from ahn") ahn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc") log.debug("ahn ascii: %s" % ahn_ascii) gp.RasterToASCII_conversion(input_ahn_raster, ahn_ascii) #--------------------------------------------------------------------- # Change ahn and lgn if use_ondermalingen == True if use_onderbemalingen: log.info("Cut out level deviations") gridcode_fieldname = "GRIDCODE" if not turtlebase.arcgis.is_fieldname( gp, input_onderbemalingen, gridcode_fieldname): log.debug(" - add field %s" % gridcode_fieldname) gp.addfield_management( input_onderbemalingen, gridcode_fieldname, "Short") row = gp.UpdateCursor(input_onderbemalingen) for item in nens.gp.gp_iterator(row): item.SetValue(gridcode_fieldname, 1) row.UpdateRow(item) onderbemaling_raster = turtlebase.arcgis.get_random_file_name( workspace_gdb) gp.FeatureToRaster_conversion( input_onderbemalingen, gridcode_fieldname, onderbemaling_raster, cellsize) onderbemaling_asc = turtlebase.arcgis.get_random_file_name( workspace, ".asc") gp.RasterToASCII_conversion(onderbemaling_raster, onderbemaling_asc) ahn_ascii = turtlebase.spatial.cut_out_onderbemaling( ahn_ascii, onderbemaling_asc, workspace) lgn_k5_ascii = turtlebase.spatial.cut_out_onderbemaling( lgn_k5_ascii, onderbemaling_asc, workspace) #--------------------------------------------------------------------- # Add ID Int to level area log.info("Create level area ascii") id_int = 'id_int' area_id_dict = add_integer_ident(gp, temp_level_area, id_int, gpgident) out_raster_dataset = turtlebase.arcgis.get_random_file_name( workspace_gdb) gp.FeatureToRaster_conversion(temp_level_area, id_int, out_raster_dataset, cellsize) id_int_ascii = turtlebase.arcgis.get_random_file_name( workspace, ".asc") log.debug("id_int_ascii: %s" % id_int_ascii) gp.RasterToASCII_conversion(out_raster_dataset, id_int_ascii) #--------------------------------------------------------------------- log.info("Read targetlevel table") area_level_dict = nens.gp.get_table(gp, input_level_area_table, primary_key=gpgident) target_level_dict = {} for k, v in area_level_dict.items(): if k in area_id_dict: int_id = area_id_dict[k][id_int] target_level_dict[int_id] = {'targetlevel': v[streefpeil], 'gpgident': k} toetspunten_fields = ["DFLT_I_ST", "DFLT_I_HL", "DFLT_I_AK", "DFLT_I_GR", "DFLT_O_ST", "DFLT_O_HL", "DFLT_O_AK", "DFLT_O_GR", "MTGMV_I_ST", "MTGMV_I_HL", "MTGMV_I_AK", "MTGMV_I_GR", "MTGMV_O_ST", "MTGMV_O_HL", "MTGMV_O_AK", "MTGMV_O_GR"] #--------------------------------------------------------------------- log.info("calculate toetspunten") toetspunten_dict = turtlebase.spatial.calculcate_toetspunten( ahn_ascii, lgn_k5_ascii, id_int_ascii, toetspunten_fields, target_level_dict, onderbemaling="#") #--------------------------------------------------------------------- log.info("Create output table") create_output_table(gp, output_file, gpgident, toetspunten_fields) #--------------------------------------------------------------------- # Add metadata import time date_time_str = time.strftime("%d %B %Y %H:%M:%S") source = input_ahn_raster for area_id, values in toetspunten_dict.items(): toetspunten_dict[area_id]['date_time'] = date_time_str toetspunten_dict[area_id]['source'] = source #--------------------------------------------------------------------- # Write results to output table log.info("Write results to output table") turtlebase.arcgis.write_result_to_output( output_file, gpgident, toetspunten_dict) #--------------------------------------------------------------------- # Delete temporary workspace geodatabase & ascii files try: log.debug("delete temporary workspace: %s" % workspace_gdb) gp.delete(workspace_gdb) log.info("workspace deleted") except: log.warning("failed to delete %s" % workspace_gdb) tempfiles = os.listdir(workspace) for tempfile in tempfiles: if tempfile.endswith('.asc'): try: os.remove(os.path.join(workspace, tempfile)) except Exception, e: log.debug(e) mainutils.log_footer()