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()
log.info("location temp: %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)
#----------------------------------------------------------------------------------------
#get argv
log.info("Getting command parameters... ")
if len(sys.argv) == 7:
input_peilgebieden_feature = sys.argv[1] #from HydroBase
input_lgn = sys.argv[2]
input_conversiontable_dbf = sys.argv[3]
input_watershape = sys.argv[4]
output_table = sys.argv[5] #RR_oppervlak in HydroBase
output_crop_table = sys.argv[6]
else:
log.error("Arguments: <LGN raster> <peilgebied HydroBase-table> <conversiontable dbf> <output HydroBase-table>")
sys.exit(1)
#----------------------------------------------------------------------------------------
# Check geometry input parameters
log.info("Check geometry of input parameters")
geometry_check_list = []
lgn_desc = gp.describe(input_lgn)
if lgn_desc.DataType == 'RasterDataset' or lgn_desc.DataType == 'RasterLayer':
if lgn_desc.PixelType[0] not in ["S", "U"]:
errormsg = "input %s is not an integer raster!" % input_lgn
log.error(errormsg)
geometry_check_list.append(errormsg)
# Create shapefile from input raster
else:
log.info("Input LGN is a raster, convert to feature class")
temp_lgn_fc = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.RasterToPolygon_conversion(input_lgn, temp_lgn_fc, "NO_SIMPLIFY")
elif lgn_desc.DataType == 'ShapeFile' or lgn_desc.DataType == 'FeatureClass':
if lgn_desc.ShapeType != 'Polygon':
errormsg = "input %s is not an integer raster!" % input_lgn
log.error(errormsg)
geometry_check_list.append(errormsg)
else:
# Copy shapefile to workspace
log.info("Input LGN is a feature class, copy to workspace")
temp_lgn_fc = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Select_analysis(input_lgn, temp_lgn_fc)
else:
log.error("datatype of LGN is %s , must be a ShapeFile, FeatureClass, RasterDataset or RasterLayer" % lgn_desc.DataType)
sys.exit(5)
if not(gp.exists(input_peilgebieden_feature)):
errormsg = "input %s does not exist!" % input_peilgebieden_feature
log.error(errormsg)
geometry_check_list.append(errormsg)
if not(gp.exists(input_conversiontable_dbf)):
errormsg = "input %s does not exist!" % input_conversiontable_dbf
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")
missing_fields = []
"<check required fields from input data, append them to list if missing>"
gpgident = config.get('GENERAL', 'gpgident')
if not turtlebase.arcgis.is_fieldname(gp, input_peilgebieden_feature, gpgident):
log.debug(" - missing: %s in %s" % (gpgident, input_peilgebieden_feature))
missing_fields.append("%s: %s" % (input_peilgebieden_feature, gpgident))
hectares = config.get('OppervlakteParameters', 'input_oppervlak_area')
verhard_ha = config.get('OppervlakteParameters', 'input_oppervlak_verhard')
onvsted_ha = config.get('OppervlakteParameters', 'input_oppervlak_onvsted')
kassen_ha = config.get('OppervlakteParameters', 'input_oppervlak_kassen')
onvland_ha = config.get('OppervlakteParameters', 'input_oppervlak_onvland')
openwat_ha = config.get('OppervlakteParameters', 'input_oppervlak_openwat')
lgn_id = config.get('OppervlakteParameters', 'input_field_lgncode')
conversion_fields = [lgn_id, verhard_ha, onvsted_ha, kassen_ha, onvland_ha, openwat_ha, hectares]
for conversion_field in conversion_fields:
if not turtlebase.arcgis.is_fieldname(gp, input_conversiontable_dbf, conversion_field):
log.debug(" - missing: %s in %s" % (conversion_field, input_conversiontable_dbf))
missing_fields.append("%s: %s" % (input_conversiontable_dbf, conversion_field))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#----------------------------------------------------------------------------------------
# 2a) copy input targetlevel areas to workspace
log.info("A) Create feature class input_peilgebieden_feature -> tempfile_peilgebied")
peilgebieden_temp = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.select_analysis(input_peilgebieden_feature, peilgebieden_temp)
# 2b) intersect(lgn+peilgebieden)
log.info("B) Intersect lgn_shape + tempfile_peilgebied -> lgn_peilgebieden")
intersect_temp = os.path.join(workspace_gdb, 'intersect_lgn_gpg')
gp.Union_analysis("%s;%s" % (temp_lgn_fc, peilgebieden_temp), intersect_temp)
# 3a) Read conversiontable into memory"
log.info("C-1) Read conversiontable into memory")
conversion = nens.gp.get_table(gp, input_conversiontable_dbf, primary_key=lgn_id.lower())
# 3b) calculate areas for lgn_id
log.info("C-2) Calculate areas for tempfile_LGN_peilgebied using conversiontable")
#read gpgident from file
lgn_fieldnames = nens.gp.get_table_def(gp, temp_lgn_fc)
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")
gewastypen = {1: config.get('OppervlakteParameters', 'grass_area'),
2: config.get('OppervlakteParameters', 'corn_area'),
3: config.get('OppervlakteParameters', 'potatoes_area'),
4: config.get('OppervlakteParameters', 'sugarbeet_area'),
5: config.get('OppervlakteParameters', 'grain_area'),
6: config.get('OppervlakteParameters', 'miscellaneous_area'),
7: config.get('OppervlakteParameters', 'nonarable_land_area'),
8: config.get('OppervlakteParameters', 'greenhouse_area'),
9: config.get('OppervlakteParameters', 'orchard_area'),
10: config.get('OppervlakteParameters', 'bulbous_plants_area'),
11: config.get('OppervlakteParameters', 'foliage_forest_area'),
12: config.get('OppervlakteParameters', 'pine_forest_area'),
13: config.get('OppervlakteParameters', 'nature_area'),
14: config.get('OppervlakteParameters', 'fallow_area'),
15: config.get('OppervlakteParameters', 'vegetables_area'),
16: config.get('OppervlakteParameters', 'flowers_area'),
}
output_with_area = {}
output_gewas_areas = {}
unknown_lgn_codes = {}
source_str = "lgn:" + os.path.basename(input_lgn) + " pg:" + os.path.basename(input_peilgebieden_feature)
if len(source_str) > 50:
source_str = source_str[:50]
date_str = time.strftime('%x')
calc_count = 0
rows = gp.UpdateCursor(intersect_temp)
for row in nens.gp.gp_iterator(rows):
value_gpgident = row.GetValue(gpgident)
if value_gpgident == "":
continue
value_gridcode = row.GetValue(gridcode)
if value_gridcode == 0:
if value_gpgident in output_with_area:
output_with_area[value_gpgident][hectares] += float(row.shape.Area) / 10000
else:
output_with_area[value_gpgident] = {gpgident : value_gpgident, hectares : float(row.shape.Area) / 10000}
continue
value_lgn_id = int(value_gridcode)
value_peilgeb_area = float(row.shape.Area) / 10000 #Area is in m2
if 'gewastype' in conversion[value_lgn_id]:
gewastype = conversion[value_lgn_id]['gewastype']
else:
gewastype = 1
#add to area
if value_gpgident in output_with_area:
add_to_area, gewastype_ha, error = conv_ha(conversion, value_lgn_id, float(value_peilgeb_area), gewastype)
for key in add_to_area.keys(): #all relevant keys
if key in output_with_area[value_gpgident]:
output_with_area[value_gpgident][key] += float(add_to_area[key])
else:
output_with_area[value_gpgident][key] = float(add_to_area[key])
else:
output_with_area[value_gpgident], gewastype_ha, error = conv_ha(conversion, value_lgn_id, float(value_peilgeb_area), gewastype)
output_with_area[value_gpgident][gpgident] = value_gpgident #set GPGIDENT
if error and not(value_lgn_id in unknown_lgn_codes):
log.warning(" - Warning: lgncode " + str(value_lgn_id) + " not known (check conversiontable)")
unknown_lgn_codes[value_lgn_id] = 1
if gewastype != 0:
if value_gpgident not in output_gewas_areas:
output_gewas_areas[value_gpgident] = {gpgident: value_gpgident}
for key in gewastypen.keys():
output_gewas_areas[value_gpgident][gewastypen[key]] = 0
output_gewas_areas[value_gpgident][gewastypen[gewastype]] += gewastype_ha
output_with_area[value_gpgident]['LGN_SOURCE'] = source_str
output_with_area[value_gpgident]['LGN_DATE'] = date_str
calc_count = calc_count + 1
if calc_count % 100 == 0:
log.info("Calculating field nr " + str(calc_count))
#----------------------------------------------------------------------------------------
if input_watershape != "#":
log.info("C-3) Calculate open water from watershape")
# 1) intersect(watershape+peilgebieden)
log.info("- intersect water_shape + tempfile_peilgebied -> watershape_peilgebieden")
watershape_intersect = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Intersect_analysis("%s;%s" % (input_watershape, peilgebieden_temp), watershape_intersect)
source_watershape = os.path.basename(input_watershape)
if len(source_watershape) > 50:
source_watershape = source_watershape[:50]
watershape_areas = {}
rows = gp.SearchCursor(watershape_intersect)
for row in nens.gp.gp_iterator(rows):
water_area_ha = float(row.shape.Area) / 10000 #Area is in m2
peilgebied_id = row.GetValue(gpgident)
if peilgebied_id in watershape_areas:
subtotal_area = watershape_areas[peilgebied_id]['area']
#overwrite key with sum areas
watershape_areas[peilgebied_id] = {'area': subtotal_area + water_area_ha}
else:
#create new key with area
watershape_areas[peilgebied_id] = {'area': water_area_ha}
#update outputtable
for peilgebied_id in output_with_area.keys():
if peilgebied_id in watershape_areas:
output_with_area[peilgebied_id]['OPNWT_GBKN'] = watershape_areas[peilgebied_id]['area']
output_with_area[peilgebied_id]['GBKN_DATE'] = date_str
output_with_area[peilgebied_id]['GBKN_SOURCE'] = source_watershape
#----------------------------------------------------------------------------------------
# 4) put dictionary area into output_table (HydroBase)
log.info("D) Saving results... ")
#definition of fields
areaFields = {gpgident: {'type': 'TEXT', 'length': '30'},
'VERHRD_LGN':{'type': 'DOUBLE'},
'ONVSTD_LGN':{'type': 'DOUBLE'},
'KASSEN_LGN':{'type': 'DOUBLE'},
'ONVLND_LGN':{'type': 'DOUBLE'},
'OPENWT_LGN':{'type': 'DOUBLE'},
'HECTARES':{'type': 'DOUBLE'},
'OPNWT_GBKN':{'type': 'DOUBLE'},
'LGN_SOURCE':{'type': 'TEXT', 'length': '50'},
'LGN_DATE':{'type': 'TEXT', 'length': '50'},
'GBKN_DATE':{'type': 'TEXT', 'length': '50'},
'GBKN_SOURCE':{'type': 'TEXT', 'length': '50'}}
#check if output_table exists. if not, create with correct rows
log.info("Checking table...")
if not(gp.exists(output_table)):
try:
gp.CreateTable(os.path.dirname(output_table), os.path.basename(output_table))
except Exception, e:
log.error("Error: creating table " + output_table)
log.debug(e)
sys.exit(14)
#check if output_table has the correct rows
log.info("Checking fields...")
for field_name, field_settings in areaFields.items():
if 'length' in field_settings:
if not turtlebase.arcgis.is_fieldname(gp, output_table, field_name):
gp.AddField(output_table, field_name, field_settings['type'], '#', '#', field_settings['length'])
else:
if not turtlebase.arcgis.is_fieldname(gp, output_table, field_name):
gp.AddField(output_table, field_name, field_settings['type'])
#----------------------------------------------------------------------------------------
#log.info(output_with_area)
turtlebase.arcgis.write_result_to_output(output_table, gpgident.lower(), output_with_area)
#----------------------------------------------------------------------------------------
# 5) Calculate crop areas
if output_crop_table != "#":
log.info("E) Calculate crop areas... ")
#definition of fields
cropFields = {gpgident: {'type': 'TEXT', 'length': '30'},
'GRAS_HA':{'type': 'DOUBLE'},
'MAIS_HA':{'type': 'DOUBLE'},
'AARDAPL_HA':{'type': 'DOUBLE'},
'BIET_HA':{'type': 'DOUBLE'},
'GRAAN_HA':{'type': 'DOUBLE'},
'OVERIG_HA':{'type': 'DOUBLE'},
'NIETAGR_HA':{'type': 'DOUBLE'},
'GLAST_HA':{'type': 'DOUBLE'},
'BOOMGRD_HA':{'type': 'DOUBLE'},
'BOLLEN_HA':{'type': 'DOUBLE'},
'LOOFBOS_HA':{'type': 'DOUBLE'},
'NLDBOS_HA':{'type': 'DOUBLE'},
'NATUUR_HA':{'type': 'DOUBLE'},
'BRAAK_HA':{'type': 'DOUBLE'},
'GROENTN_HA':{'type': 'DOUBLE'},
'BLOEMEN_HA':{'type': 'DOUBLE'}}
#check if output_table exists. if not, create with correct rows
log.info("Checking table...")
if not(gp.exists(output_crop_table)):
try:
gp.CreateTable(os.path.dirname(output_crop_table), os.path.basename(output_crop_table))
except Exception, e:
log.error("Error: creating table " + output_crop_table)
log.debug(e)
sys.exit(14)
#check if output_table has the correct rows
log.info("Checking fields...")
for field_name, field_settings in cropFields.items():
if 'length' in field_settings:
if not turtlebase.arcgis.is_fieldname(gp, output_crop_table, field_name):
gp.AddField(output_crop_table, field_name, field_settings['type'], '#', '#', field_settings['length'])
else:
if not turtlebase.arcgis.is_fieldname(gp, output_crop_table, field_name):
gp.AddField(output_crop_table, field_name, field_settings['type'])
write_result_to_output(gp, output_crop_table, gpgident.lower(), output_gewas_areas)
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)
#----------------------------------------------------------------------------------------
#ernst rekenklasse
ernst_drainage = ernst()
#----------------------------------------------------------------------------------------
#check inputfields
log.info("Getting commandline parameters... ")
if len(sys.argv) == 7:
file_input_peilgebieden_feature = sys.argv[1] #shape
file_input_peilvakgegevens = sys.argv[2] #[ZOMERPEIL],[WINTERPEIL]
file_input_kwelstroom = sys.argv[3] #[KWELSTROOM]
file_input_maaiveldkarakteristiek = sys.argv[4] #[MV_HGT_50]
file_input_bodemsoort = sys.argv[5] #shape
file_output = sys.argv[6]
else:
log.error("Usage: python rural_drainageparameter.py <peilgebieden shape> <peilvakgegevens> <kwelstroom> <maaiveldkarakteristiek> <bodemsoort shape> <outputtabel HydroBase>")
sys.exit(1)
#----------------------------------------------------------------------------------------
# Check geometry
log.info("Check geometry of input parameters")
if not turtlebase.arcgis.is_file_of_type(gp, file_input_peilgebieden_feature, 'Polygon'):
log.error("Input %s does not contain polygons" % file_input_peilgebieden_feature)
sys.exit(1)
if not turtlebase.arcgis.is_file_of_type(gp, file_input_bodemsoort, 'Polygon'):
log.error("Input %s does not contain polygons" % file_input_bodemsoort)
sys.exit(1)
#----------------------------------------------------------------------------------------
# Check required fields
log.info("Check required fields in input data")
peilgebied_id = config.get('GENERAL', 'gpgident')
pawn_code = config.get('Ernst', 'input_bodemsoort_code')
missing_fields = []
check_fields = {file_input_peilgebieden_feature: peilgebied_id,
file_input_peilvakgegevens: peilgebied_id,
file_input_peilvakgegevens: config.get('Ernst', 'peilvakgegevens_zomerpeil'),
file_input_peilvakgegevens: config.get('Ernst', 'peilvakgegevens_winterpeil'),
file_input_kwelstroom: peilgebied_id,
file_input_kwelstroom: config.get('Ernst', 'kwelstroom_kwelstroom'),
file_input_maaiveldkarakteristiek: peilgebied_id,
file_input_maaiveldkarakteristiek: config.get('Ernst', 'maaiveldkarakteristiek_value'),
file_input_bodemsoort: pawn_code}
for input_file, field in check_fields.items():
if not turtlebase.arcgis.is_fieldname(gp, input_file, field):
log.error("Missing field %s in %s" % (field, input_file))
missing_fields.append("missing %s in %s" % (field, input_file))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#----------------------------------------------------------------------------------------
# Check record count
log.info("Check records of input parameters")
count_area = turtlebase.arcgis.fc_records(gp, file_input_peilgebieden_feature)
count_surface_level_table = turtlebase.arcgis.fc_records(gp, file_input_peilvakgegevens)
count_seepage = turtlebase.arcgis.fc_records(gp, file_input_kwelstroom)
count_scurve = turtlebase.arcgis.fc_records(gp, file_input_maaiveldkarakteristiek)
if count_surface_level_table != count_area:
log.error("input %s (%s records) contains not the same records as %s (%s records)" % (file_input_peilvakgegevens, count_surface_level_table,
file_input_peilgebieden_feature, count_area))
sys.exit(2)
if count_seepage != count_area:
log.error("input %s (%s records) contains not the same records as %s (%s records)" % (file_input_kwelstroom, count_seepage,
file_input_peilgebieden_feature, count_area))
sys.exit(2)
if count_scurve != count_area:
log.error("input %s (%s records) contains not the same records as %s (%s records)" % (file_input_maaiveldkarakteristiek,
count_scurve, file_input_peilgebieden_feature, count_area))
sys.exit(2)
#----------------------------------------------------------------------------------------
#A: bodemsoort
log.info("A-1) Copy peilgebieden to temporary workspace")
temp_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.select_analysis(file_input_peilgebieden_feature, temp_peilgebieden)
log.info("A-2) Copy bodemsoort to temporary workspace")
temp_bodemsoort = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.select_analysis(file_input_bodemsoort, temp_bodemsoort)
log.info("A-3) Intersect bodemsoort + peilgebieden -> peilg+bodem")
temp_intersect_bodem_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Intersect_analysis(temp_peilgebieden + "; " + temp_bodemsoort, temp_intersect_bodem_peilgebieden)
log.info("A-4) Dissolve peilg+bodem")
temp_dissolve_bodem_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Dissolve_management (temp_intersect_bodem_peilgebieden, temp_dissolve_bodem_peilgebieden, peilgebied_id + " ;" + pawn_code, "")
log.info("A-5) Read peilg+bodem(dissolve)")
log.info(" - reading shape")
peilv_grondsoort = {}
row = gp.SearchCursor(temp_dissolve_bodem_peilgebieden)
for item in nens.gp.gp_iterator(row):
area_id = item.GetValue(peilgebied_id)
soil_id = item.GetValue(pawn_code)
area = item.Shape.Area
data_row = {'pawn_code': soil_id, 'area': area}
if not(peilv_grondsoort.has_key(area_id)):
peilv_grondsoort[area_id] = {'grondsoort':[]}
peilv_grondsoort[area_id]['grondsoort'].append(data_row)
log.info(" - sorting")
for key in peilv_grondsoort.keys():
peilv_grondsoort[key]['grondsoort'].sort(sort_area_rev)
peilv_grondsoort[key]['area'] = sum_grondsoort(peilv_grondsoort[key]['grondsoort'])
# ---------------------------------------------------------------------------
#B: ernst parameters
#inlezen van shape files: [ZOMERPEIL, WINTERPEIL, KWELSTROOM, MV_HGT_50]
log.info("B-1) Reading inputfile peilvakgegevens")
data_set = {}
row = gp.SearchCursor(file_input_peilvakgegevens)
for item in nens.gp.gp_iterator(row):
field_id = item.GetValue(peilgebied_id)
data_set[field_id] = {}
data_set[field_id]['zomerpeil'] = item.GetValue(config.get('Ernst', 'peilvakgegevens_zomerpeil'))
data_set[field_id]['winterpeil'] = item.GetValue(config.get('Ernst', 'peilvakgegevens_winterpeil'))
if (data_set[field_id]['zomerpeil'] < float(config.get('Ernst', 'validate_min_zomerpeil'))) or (data_set[field_id]['zomerpeil'] > float(config.get('Ernst', 'validate_max_zomerpeil'))):
log.error("zomerpeil has a non-valid value of " + str(data_set[field_id]['zomerpeil']))
sys.exit(5)
if (data_set[field_id]['winterpeil'] < float(config.get('Ernst', 'validate_min_winterpeil'))) or (data_set[field_id]['zomerpeil'] > float(config.get('Ernst', 'validate_max_winterpeil'))):
log.error("winterpeil has a non-valid value of " + str(data_set[field_id]['winterpeil']))
sys.exit(5)
#inlezen van shape files: [ZOMERPEIL, WINTERPEIL, KWELSTROOM, MV_HGT_50]
log.info("B-2) Reading inputfile kwelstroom")
row = gp.SearchCursor(file_input_kwelstroom)
for item in nens.gp.gp_iterator(row):
field_id = item.GetValue(peilgebied_id)
if not(data_set.has_key(field_id)):
log.error("non-matching kwelstroom and peilvakgegevens, check if peilvakgegevens has key '" + field_id + "'")
sys.exit(9)
data_set[field_id]['kwel'] = item.GetValue(config.get('Ernst', 'kwelstroom_kwelstroom'))
#inlezen van shape files: [ZOMERPEIL, WINTERPEIL, KWELSTROOM, MV_HGT_50]
log.info("B-3) Reading inputfile maaiveldkarakteristiek")
row = gp.SearchCursor(file_input_maaiveldkarakteristiek)
for item in nens.gp.gp_iterator(row):
field_id = item.GetValue(peilgebied_id)
if not(data_set.has_key(field_id)):
log.error("non-matching maaiveldkarakteristiek and peilvakgegevens, check if peilvakgegevens has key '" + field_id + "'")
sys.exit(9)
data_set[field_id]['maaiveld'] = item.GetValue(config.get('Ernst', 'maaiveldkarakteristiek_value'))
# ---------------------------------------------------------------------------
#check input: each record should contain all fields (count: 4)
log.info("B-4) Checking input")
for key, value in data_set.items():
if len(value.items()) != 4:
log.error(key, value)
log.error("check if inputfiles match with eachother!")
sys.exit(6)
# ---------------------------------------------------------------------------
#bepaling drooglegging: [DL] = [MV_HGT_50] - max([WINTERPEIL], [ZOMERPEIL])
#bepaling drainageweerstand [ALFA_LZ] = xx * [DL} - yy, waarbij xx, yy afhangen van de klasse
#bepaling INF_OPWAT, OPP_AFVOER
log.info("B-6) preparing data for output")
data_set_output = {}
import time
date_str = time.strftime("%d %B %Y %H:%M:%S")
log.info("Calculating GRONDSOORT, drooglegging, ALFA_LZ, INF_OPWAT, OPP_AFVOER... ")
log.info(" - Datum-string: " + date_str)
for key, item in data_set.items():
#print key, item
data_set[key]['drooglegging'] = ernst_drainage.calc_dl(item['maaiveld'], item['zomerpeil'], item['winterpeil'])
data_set_output[key] = {}
data_set_output[key][peilgebied_id] = key #important!
data_set_output[key][config.get('Ernst', 'output_alfa_lz')] = ernst_drainage.calc_alfa(data_set[key]['kwel'], data_set[key]['drooglegging'])
data_set_output[key][config.get('Ernst', 'output_inf_opwat')] = 500 #of dataset['key']['ALFA_LZ']*1.5
data_set_output[key][config.get('Ernst', 'output_opp_afvoer')] = 0.5
grondsrt_str = ""
try:
data_set_output[key][config.get('Ernst', 'output_grondsoort')] = peilv_grondsoort[key]['grondsoort'][0]['pawn_code']
for idx in range(min(len(peilv_grondsoort[key]['grondsoort']), 5)):
grondsrt_str = grondsrt_str + str(peilv_grondsoort[key]['grondsoort'][idx]['pawn_code']) + "(" + str(int(100 * peilv_grondsoort[key]['grondsoort'][idx]['area'] / peilv_grondsoort[key]['area'])) + "%) "
except Exception, e:
log.warning(e)
log.warning("id " + key + " has no " + config.get('Ernst', 'output_grondsoort') + " value!")
data_set_output[key][config.get('Ernst', 'output_grondsoort')] = -1
source_str = "grondsrt:" + grondsrt_str + "pv:" + os.path.basename(file_input_peilvakgegevens) + " kwel:" + os.path.basename(file_input_kwelstroom) + " mv:" + os.path.basename(file_input_maaiveldkarakteristiek)
if len(source_str) > 50:
source_str = source_str[:50]
data_set_output[key]['SOURCE'] = source_str
data_set_output[key]['DATE_TIME'] = date_str
# ---------------------------------------------------------------------------
#C: output
#add cols [ALFA_LZ], [INF_OPWAT], [OPP_AFVOER]
drainageFields = {peilgebied_id: {'type': 'TEXT', 'length': '30'},
config.get('Ernst', 'output_alfa_lz'):{'type': 'DOUBLE'},
config.get('Ernst', 'output_inf_opwat'):{'type': 'DOUBLE'},
config.get('Ernst', 'output_opp_afvoer'):{'type': 'DOUBLE'},
config.get('Ernst', 'output_grondsoort'):{'type': 'INTEGER'},
'SOURCE':{'type': 'TEXT', 'length': '256'},
'DATE_TIME':{'type': 'TEXT', 'length': '40'},
'COMMENTS':{'type': 'TEXT', 'length': '256'}}
#check if output_table exists. if not, create with correct rows
log.info("C-1) Checking output table... ")
if not(gp.exists(file_output)):
gp.CreateTable(os.path.dirname(file_output), os.path.basename(file_output))
#check if output_table has the correct rows
log.info("C-2) Checking fields... ")
for field_name, field_settings in drainageFields.items():
if field_settings.has_key('length'):
if not turtlebase.arcgis.is_fieldname(gp, file_output, field_name):
gp.AddField(file_output, field_name, field_settings['type'], '#', '#', field_settings['length'])
else:
if not turtlebase.arcgis.is_fieldname(gp, file_output, field_name):
gp.AddField(file_output, field_name, field_settings['type'])
# ---------------------------------------------------------------------------
# Write results to output table
log.info("Write results to output table")
turtlebase.arcgis.write_result_to_output(file_output, peilgebied_id, data_set_output)
#----------------------------------------------------------------------------------------
# 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)
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
"""
nodig voor deze tool:
"""
if len(sys.argv) == 4:
user_input = sys.argv[1]
flip_field = sys.argv[2].lower()
output_shape = sys.argv[3]
else:
log.warning("usage: <user_input> <output_shape>")
sys.exit(1)
tempfiles = []
input_shape = turtlebase.arcgis.get_random_file_name(workspace, '.shp')
gp.Select_analysis(user_input, input_shape)
#---------------------------------------------------------------------
# Check geometry input parameters
log.info("Check geometry of input parameters")
geometry_check_list = []
#log.debug(" - check <input >: %s" % argument1)
if not turtlebase.arcgis.is_file_of_type(gp, input_shape, 'Polyline'):
log.error("%s is not a %s feature class!" % (input_shape, 'Polyline'))
geometry_check_list.append("%s -> (%s)" % (input_shape, 'Polyline'))
if len(geometry_check_list) > 0:
log.error("check input: %s" % geometry_check_list)
sys.exit(2)
#---------------------------------------------------------------------
# Check required fields in input data
ovk_field = config.get('general', 'ovkident').lower()
missing_fields = []
check_fields = {input_shape: ['Sum_OPP_LA', 'Sum_OPP_ST',
ovk_field, 'from_x', 'from_y', 'to_x', 'to_y', flip_field]}
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)
#---------------------------------------------------------------------
#create output:
fields_to_add = [(ovk_field, 'TEXT'),
('incoming', 'SHORT'),
('examined', 'SHORT'),
('terminal', 'SHORT'),
('som_sted', 'DOUBLE'),
('som_land', 'DOUBLE'),
('som_totaal', 'DOUBLE'),
('bottleneck', 'SHORT'),
(flip_field, 'SHORT')]
gp.select_analysis(input_shape, output_shape)
new_feat = {}
new_geometry = {}
log.info("Inlezen geometrie en omdraaien van de geometrie")
fieldnames_dict = nens.gp.get_table_def(gp, input_shape)
log.debug(fieldnames_dict)
desc = gp.describe(input_shape)
count = 0
rows = gp.SearchCursor(input_shape)
row = rows.Next()
while row:
flip_boolean = row.getValue(flip_field)
if flip_boolean == 1:
count += 1
#read features
feat = row.getValue(desc.ShapeFieldName)
ovkident = row.getValue(ovk_field)
new_feat = flip_geometry(gp, feat, ovkident, new_feat)
##new_feat = feat
#store geometry information in dictionary
if ovkident not in new_geometry:
new_geometry[ovkident] = {}
#store all information from the attribute table
for column in fields_to_add:
column = column[0]
#columns with from en to for x and y need to be switched as well
if column == 'from_x':
lookup_column = 'to_x'
elif column == 'from_y':
lookup_column = 'to_y'
elif column == 'to_y':
lookup_column = 'from_y'
elif column == 'to_x':
lookup_column = 'from_x'
else:
# no switch needed
lookup_column = column
if column != 'opm':
if lookup_column in fieldnames_dict:
update_value = row.getValue(lookup_column)
try:
float_value = float(update_value)
new_geometry[ovkident][column] = float_value
except:
log.debug("geen float")
new_geometry[ovkident][column] = row.getValue(lookup_column)
log.debug(new_geometry[ovkident][column])
#waterlijn wordt opgeslagen in dictionary
if column == 'opm':
new_geometry[ovkident][column] = "Lijn is omgedraaid"
log.info("Opslaan van waterlijn: " + str(ovkident))
row = rows.Next()
del row, rows
#remove the lines that are going to be flipped
removed_lines = turtlebase.arcgis.get_random_file_name(workspace_gdb)
#alleen als er inderdaad lijnen gedraaid worden moet de tempfile aangemaakt worden.
gp.select_analysis(input_shape, removed_lines)
#first remove lines that are going to be duplicate in the end result. lines are
# remove from a copy of the input file.
row = gp.UpdateCursor(removed_lines)
log.info("Verwijder dubbele rijen")
for item in nens.gp.gp_iterator(row):
if item.getValue(flip_field) == 1:
row.DeleteRow(item)
temp_shape = turtlebase.arcgis.get_random_file_name(workspace_gdb)
tempfiles.append(temp_shape)
#creates new lines in workspace with same name as output_shape
count = create_line_from_dict(gp, workspace_gdb, new_feat, fields_to_add, new_geometry, temp_shape)
if count == 0:
log.warning("Er zijn geen lijnen omgedraaid")
log.warning("Door de gebruiker is in de kolom " + str(flip_field) + " geen 1 ingevuld")
else:
tempfiles.append(removed_lines)
#merge new lines with output
gp.Merge_management(temp_shape + ";" + removed_lines, output_shape)
#---------------------------------------------------------------------
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
turtlebase.arcgis.remove_tempfiles(gp, log, tempfiles)
log.info("workspace deleted")
except:
log.debug("failed to delete %s" % workspace_gdb)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
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()
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)
#------------------------------------------------
log.info("Reading and checking input")
rekenpunten = sys.argv[1]
waterlijnen = sys.argv[2]
peilgebieden = sys.argv[3] #optioneel
output_bergingstakken = sys.argv[4]
gpgident = config.get('General', 'gpgident')
if turtlebase.arcgis.is_fieldname(gp, peilgebieden, gpgident):
peilgebieden_list = nens.gp.get_table(gp, peilgebieden, primary_key=gpgident.lower())
else:
log.error("field %s is missing in %s", gpgident, peilgebieden)
sys.exit(1)
if not turtlebase.arcgis.is_fieldname(gp, rekenpunten, gpgident):
log.error("field %s is missing in %s", gpgident, rekenpunten)
sys.exit(1)
log.info("Controleer of de opgegeven bestandsnamen arcgis compatibel zijn")
for argv in sys.argv[1:]:
turtlebase.filenames.check_filename(argv)
#uitlezen x en y coordinaat van de rekenpunten
log.info("Inlezen rekenpunten")
rekenpunten_x_y_coordinaten = bepalen_x_y_coordinaat(gp, rekenpunten, gpgident)
log.info("Kopieer " + waterlijnen + " naar de workspace")
waterlijnen_lokaal = turtlebase.arcgis.get_random_file_name(workspace_gdb)
log.debug("Kopieer de waterlijnen naar een lokale directory ")
gp.select_analysis(waterlijnen, waterlijnen_lokaal)
log.info("Bereken eindpunten van potentiele bergingstakken rondom rekenpunten")
dict_stars = create_dict_stars_around_rekenpunten(peilgebieden_list, config, rekenpunten_x_y_coordinaten)
joined_dictionaries = join_dictionaries(dict_stars, rekenpunten_x_y_coordinaten)
star = turtlebase.arcgis.get_random_file_name(workspace_gdb)
log.info("Aanmaken potentiele bergingstakken vanuit rekenpunt ")
createLineFromPoints(gp, joined_dictionaries, 'gpgident', star)
intersect = turtlebase.arcgis.get_random_file_name(workspace_gdb)
log.info("Bereken kruisingen van potentiele bergingstakken met waterlijnen")
#Buffer_analysis (in_features, out_feature_class, buffer_distance_or_field, line_side, line_end_type, dissolve_option, dissolve_field)
gp.Intersect_analysis(star + ";" + waterlijnen_lokaal, intersect, "#", "#", "POINT")
intersect_x_y_coordinaten = bepalen_x_y_coordinaat(gp, intersect, gpgident)
remainingpoints_to_be_removed_from_star = remove_duplicate_values_from_dictionaries(rekenpunten_x_y_coordinaten, intersect_x_y_coordinaten)
#nu remainingpoints_to_be_removed_from_star dictionary de keys vergelijken met de id in star en dan record verwijderen
log.info("Bepaal overgebleven eindpunten van bergingstakken")
remove_records_from_shapefile_based_on_keys_in_dict(gp, star, gpgident, remainingpoints_to_be_removed_from_star)
star_punten = turtlebase.arcgis.get_random_file_name(workspace_gdb)
#nu worden coordinaten uitgelezen uit de star_punten shape (lijnen)
log.info("Bereken ideale bergingstak")
create_points_from_dict(gp, dict_stars, star_punten, gpgident)
intersect2 = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Intersect_analysis(star_punten + ";" + star, intersect2, "#", "#", "POINT")
log.info("Bereken afstand potentiele bergingstakken naar waterlijn")
log.debug("Als eerste wordt een buffer aangemaakt ")
buffer_star = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Buffer_analysis(rekenpunten, buffer_star, int(config.get('bergingstakken', 'length_of_breach')))
snijpunt_waterlijn = turtlebase.arcgis.get_random_file_name(workspace_gdb)
log.debug("Nu intersect van de buffer met de waterlijnen. Deze punten worden gebruikt om de afstand naar de waterlijn te berekenen ")
gp.Intersect_analysis(buffer_star + ";" + waterlijnen_lokaal, snijpunt_waterlijn, "#", "#", "POINT")
log.debug("Nu wegschrijven van de coordinaten van de snijpunten met de waterlijn naar een dictionary")
snijpunten_waterlijn_dict = bepalen_x_y_coordinaat_meerdere_punten(gp, snijpunt_waterlijn, gpgident)
log.debug("Nu wegschrijven van de coordinaten van de overgebleven punten van de ster naar een dictionary")
punten_star_dict = bepalen_x_y_coordinaat_meerdere_punten(gp, intersect2, gpgident)
log.debug("Er zijn 2 of meer punten op de waterlijn waarnaar de punten van de ster een afstand hebben")
log.debug("Berekend wordt welke de minimale afstand oplevert tussen punt van de ster en waterlijn")
#nu afstand berekenen mbv de distance calculator uit vorige script tussen snijpunten_waterlijn_dict en intersect2
minimaldistance_dict_star_points = calculate_distance_between_points(snijpunten_waterlijn_dict, punten_star_dict)
log.info("Berekend wordt welk punt van de bergingstak het verst van de waterlijn verwijderd is")
list_with_ideal_points = bepaal_ideale_punt_bergingstak(minimaldistance_dict_star_points)
out_data = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Copy_management (star, out_data)
log.info("Selecteer de bergingstakken die loodrecht op waterlijn staan")
remove_records_from_shapefile_not_in_list(gp, star, gpgident, list_with_ideal_points)
#koppel de lijnen aan de RR_oppervlak tabel en neem de openwat_HA waarden over
log.debug("De gpgident wordt weer teruggehaald ui de unieke peilgebiedid")
clean_up_star(gp, star, gpgident)
#intersect van star met zichzelf. als er iets overblijft dan geef een warning met de betreffende peilgebied id, mededeling
# voor de gebruiker dat hij/zij daar even handmatig wat aan aan moet passen.
log.info("Creeeren out_shape bergingstakken")
log.info('%s star' %star)
log.info('%s star'% output_bergingstakken)
gp.select_analysis(star, output_bergingstakken)
log.info("Check of er bergingstakken zijn die overlappen ")
try:
intersect3 = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Intersect_analysis(output_bergingstakken, intersect3, "#", "#", "POINT")
#loop door de output van de intersect en geeft de GPGident weer als deze in de attribute table staat
row = gp.SearchCursor(intersect3)
for item in nens.gp.gp_iterator(row):
gpg_ident = item.getValue(gpgident)
log.warning("In peilgebied " + str(gpg_ident) + " overlapt de bergingstak met een andere bergingstak. Pas dit handmatig aan!")
except (RuntimeError, TypeError, NameError):
log.info('Geen overlap aanwezig')
#----------------------------------------------------------------------------------------
# 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)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
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__)
#---------------------------------------------------------------------
# Input parameters
if len(sys.argv) == 5:
hydrobase = sys.argv[1]
input_kwelkaart = sys.argv[2]
input_bodemkaart = sys.argv[3]
output_waterbalance = sys.argv[4]
else:
log.error("usage: <hydrobase> <input_kwelkaart> <input_bodemkaart> <output_waterbalance>")
sys.exit(1)
peilgebieden_fc = os.path.join(hydrobase, 'RR_Features',
config.get('waterbalans',
'peilgebieden_fc'))
if not gp.exists(peilgebieden_fc):
log.error("Features '%s' is not available in the hydrobase" % config.get('waterbalans', 'peilgebieden_fc'))
sys.exit(1)
rr_peilgebied = os.path.join(hydrobase,
config.get('waterbalans',
'rr_peilgebied'))
if not gp.exists(rr_peilgebied):
log.error("Table '%s' is not available in the hydrobase" % config.get('waterbalans', 'rr_peilgebied'))
sys.exit(1)
rr_oppervlak = os.path.join(hydrobase,
config.get('waterbalans',
'rr_oppervlak'))
if not gp.exists(rr_oppervlak):
log.error("Table '%s' is not available in the hydrobase" % config.get('waterbalans', 'rr_oppervlak'))
sys.exit(1)
if input_kwelkaart == '#':
rr_kwelwegzijging = os.path.join(hydrobase,
config.get('waterbalans',
'rr_kwelwegzijging'))
if not gp.exists(rr_kwelwegzijging):
log.error("No seepage data available")
sys.exit(1)
else:
rr_kwelwegzijging = '#'
if input_bodemkaart == '#':
rr_grondsoort = os.path.join(hydrobase,
config.get('waterbalans',
'rr_grondsoort'))
if not gp.exists(rr_grondsoort):
log.error("No soil data available")
sys.exit(1)
else:
rr_grondsoort = '#'
#---------------------------------------------------------------------
# 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 = {}
gpgident = config.get("general", "gpgident").lower()
gafident = config.get("waterbalance", "gafident").lower()
gafnaam = config.get("waterbalance", "gafnaam").lower()
check_fields = {peilgebieden_fc: [gpgident, gafident, gafnaam],
rr_peilgebied: [gpgident, "zomerpeil", "winterpeil"]}
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("Check numbers of fields in input data")
errorcode = 0
nr_gpg = turtlebase.arcgis.fc_records(gp, peilgebieden_fc)
if nr_gpg == 0:
log.error("%s fc is empty" % peilgebieden_fc)
errorcode += 1
nr_peilgebied = turtlebase.arcgis.fc_records(gp, rr_peilgebied)
if not nr_peilgebied == nr_gpg:
log.error("%s (%s records) does not contain the same amount of records as %s (%s)" % (rr_peilgebied, nr_peilgebied,
peilgebieden_fc, nr_gpg))
errorcode += 1
nr_oppervlak = turtlebase.arcgis.fc_records(gp, rr_oppervlak)
if not nr_oppervlak == nr_gpg:
log.error("%s (%s records) does not contain the same amount of records as %s (%s)" % (rr_oppervlak, nr_oppervlak,
peilgebieden_fc, nr_gpg))
errorcode += 1
if rr_grondsoort != '#':
nr_grondsoort = turtlebase.arcgis.fc_records(gp, rr_grondsoort)
if not nr_grondsoort == nr_gpg:
log.error("%s (%s records) does not contain the same amount of records as %s (%s)" % (rr_grondsoort, nr_grondsoort,
peilgebieden_fc, nr_gpg))
errorcode += 1
else:
nr_grondsoort = 0
if rr_kwelwegzijging != '#':
nr_kwelwegzijging = turtlebase.arcgis.fc_records(gp, rr_kwelwegzijging)
if not nr_kwelwegzijging == nr_gpg:
log.error("%s (%s records) does not contain the same amount of records as %s (%s)" % (rr_kwelwegzijging, nr_kwelwegzijging,
peilgebieden_fc, nr_gpg))
errorcode += 1
else:
nr_kwelwegzijging = 0
if errorcode > 0:
log.error("%s errors found, see above" % errorcode)
sys.exit(1)
log.info("Join tables")
log.info(" - read %s" % peilgebieden_fc)
peilgebieden = nens.gp.get_table(gp, peilgebieden_fc, primary_key=gpgident, no_shape=True)
log.info(" - join %s" % rr_peilgebied)
nens.gp.join_on_primary_key(gp, peilgebieden, rr_peilgebied, gpgident)
log.info(" - join %s" % rr_oppervlak)
nens.gp.join_on_primary_key(gp, peilgebieden, rr_oppervlak, gpgident)
if rr_grondsoort != '#':
log.info(" - join %s" % rr_grondsoort)
nens.gp.join_on_primary_key(gp, peilgebieden, rr_grondsoort, gpgident)
if rr_kwelwegzijging != '#':
log.info(" - join %s" % rr_kwelwegzijging)
nens.gp.join_on_primary_key(gp, peilgebieden, rr_kwelwegzijging, gpgident)
required_keys = ["verhard_ha", "onvsted_ha", "kassen_ha",
"openwat_ha", "gras_ha", "natuur_ha", "zomerpeil",
"winterpeil", "shape_area", "hectares"]
#---------------------------------------------------------------------
# Calculate Kwel/Wegzijging
if input_kwelkaart == '#' == input_bodemkaart:
pass
else:
workspace = config.get('GENERAL', 'location_temp')
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)
if input_kwelkaart != '#':
# Check out Spatial Analyst extension license
gp.CheckOutExtension("Spatial")
kwel_table = os.path.join(workspace_gdb, 'kwel_zs_table')
#poldershape = os.path.join(workspace_gdb, 'polders')
#gp.Dissolve_management(peilgebieden_fc, poldershape, gafident)
gp.ZonalStatisticsAsTable_sa(peilgebieden_fc, gafident, input_kwelkaart, kwel_table, "DATA")
kwelwegzijging = nens.gp.get_table(gp, kwel_table, primary_key=gafident, no_shape=True)
#log.info(kwelwegzijging)
if input_bodemkaart != '#':
temp_bodemsoort = os.path.join(workspace_gdb, "temp_bodem")
gp.select_analysis(input_bodemkaart, temp_bodemsoort)
temp_peilgebied = os.path.join(workspace_gdb, "temp_peilgebied")
gp.select_analysis(peilgebieden_fc, temp_peilgebied)
intersect_bodem = os.path.join(workspace_gdb, "intersect_bodem")
gp.Intersect_analysis("%s;%s" % (temp_peilgebied, temp_bodemsoort), intersect_bodem)
bodemsoorten_polders = sort_bodemsoorten(gp, intersect_bodem, gafident)
"""
WAARDES INVULLEN VAN KWEL EN BODEM IN DICT!
"""
#---------------------------------------------------------------------
# Waterbalance
polders = {}
log.info("Extract data for waterbalance")
for k, v in peilgebieden.items():
for required_key in required_keys:
if required_key not in v.keys():
log.error("Cannot find %s for gpgident: %s" % (required_key, k))
sys.exit(1)
if 'grondsoort' not in v:
grondsoort = 0
else:
grondsoort = v['grondsoort']
if 'kwelstroom' not in v:
kwelstroom = 0
else:
kwelstroom = v['kwelstroom']
if v[gafident] in polders:
polders[v[gafident]]["peilgebieden"].append((k, v["shape_area"], v["verhard_ha"], v["onvsted_ha"], v["kassen_ha"],
v["openwat_ha"], v["gras_ha"], v["natuur_ha"], v['hectares'], grondsoort, kwelstroom))
else:
polders[v[gafident]] = {"peilgebieden": [(k, v["shape_area"], v["verhard_ha"], v["onvsted_ha"], v["kassen_ha"],
v["openwat_ha"], v["gras_ha"], v["natuur_ha"], v['hectares'], grondsoort, kwelstroom)]}
waterbalance = {}
log.info("Calculate data for waterbalance")
for polder, attributes in polders.items():
main_gpg, sum_area = max_gpg(attributes['peilgebieden'])
kwelstroom, verhard_ha, onvsted_ha, kassen_ha, openwat_ha, gras_ha, natuur_ha = calculate_averages(attributes['peilgebieden'], sum_area)
if input_bodemkaart == '#':
bod1, bod2, bod3 = calculate_soiltypes(attributes['peilgebieden'])
else:
bod1 = "Bodem 1"
bod2 = "Bodem 2"
bod3 = "Bodem 3"
if input_kwelkaart != '#':
if polder in kwelwegzijging:
kwelstroom = kwelwegzijging[polder]['mean']
else:
kwelstroom = 0
log.warning("%s has no seepage data" % polder)
if kwelstroom > 0:
kwel = kwelstroom
wegz = 0
else:
wegz = -1 * kwelstroom
kwel = 0
winterp = peilgebieden[main_gpg]['winterpeil']
zomerp = peilgebieden[main_gpg]['zomerpeil']
sum_ha = sum_area / 10000
waterbalance[polder] = [("Code", polder, "TEXT"), ("Naam", polder, "TEXT"),
("Main_GPG", main_gpg, "TEXT"), ("Bodemh", -999, "DOUBLE"),
("Kwel", kwel, "DOUBLE"), ("Wegz", wegz, "DOUBLE"),
("Winterpeil", winterp, "DOUBLE"), ("Zomerpeil", zomerp, "DOUBLE"),
("Totaal_ha", sum_ha, "DOUBLE"), ("Verhard_ha", verhard_ha, "DOUBLE"),
("Onvsted_ha", onvsted_ha, "DOUBLE"), ("Kassen_ha", kassen_ha, "DOUBLE"),
("Openwat_ha", openwat_ha, "DOUBLE"), ("Gras_ha", gras_ha, "DOUBLE"),
("Natuur_ha", natuur_ha, "DOUBLE"), ("Bodem1", bod1, "TEXT"),
("Bodem2", bod2, "TEXT"), ("Bodem3", bod3, "TEXT")]
log.info("Write output table")
gp.CreateTable(os.path.dirname(output_waterbalance), os.path.basename(output_waterbalance))
for key, values in waterbalance.items():
for attribute in values:
log.info(" - add field %s" % attribute[0])
gp.AddField(output_waterbalance, attribute[0], attribute[2])
break
log.info("Inserting new records")
update_count = 0
nsertCursor = gp.InsertCursor(output_waterbalance)
for key, values in waterbalance.items():
newRow = nsertCursor.NewRow()
for attribute in values:
newRow.SetValue(attribute[0], attribute[1])
nsertCursor.InsertRow(newRow)
update_count += 1
log.info(" - %s records have been inserted" % update_count)
log.info("Finished")
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
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) == 5:
# input parameter
input_external_weir = sys.argv[1]
input_voronoi_polygon = sys.argv[2]
input_rrcf_waterlevel = sys.argv[3]
# output parameters
output_table_external_weir = sys.argv[4]
else:
log.error("usage: <input_external_weir> <input_voronoi_polygon> <input rrcf waterlevel> <output_table_external_weir>")
sys.exit(1)
temp_voronoi = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.select_analysis(input_voronoi_polygon, temp_voronoi)
#----------------------------------------------------------------------------------------
# Check geometry input parameters
log.info("Check geometry of input parameters")
geometry_check_list = []
log.debug(" - check input_external_weir: %s" % input_external_weir)
if gp.describe(input_external_weir).ShapeType != 'Point':
log.error("Input_external_weir is not a point feature class!")
geometry_check_list.append(input_external_weir + " -> (Point)")
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)")
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")
missing_fields = []
if not turtlebase.arcgis.is_fieldname(gp, temp_voronoi, config.get('toetsing_overstorten', 'calculation_point_ident')):
log.debug(" - missing: %s in %s" % (config.get('toetsing_overstorten', 'calculation_point_ident'), temp_voronoi))
missing_fields.append("%s: %s" % (temp_voronoi, config.get('toetsing_overstorten', 'calculation_point_ident')))
if not turtlebase.arcgis.is_fieldname(gp, input_rrcf_waterlevel, config.get('toetsing_overstorten', 'field_waterstand')):
log.debug(" - missing: %s in %s" % (config.get('toetsing_overstorten', 'field_waterstand'), input_rrcf_waterlevel))
missing_fields.append("%s: %s" % (input_rrcf_waterlevel, config.get('toetsing_overstorten', 'field_waterstand')))
if not turtlebase.arcgis.is_fieldname(gp, input_external_weir, config.get('toetsing_overstorten', 'overstort_ident')):
log.debug(" - missing: %s in %s" % (config.get('toetsing_overstorten', 'overstort_ident'), input_external_weir))
missing_fields.append("%s: %s" % (input_external_weir, config.get('toetsing_overstorten', 'overstort_ident')))
if not turtlebase.arcgis.is_fieldname(gp, input_external_weir, config.get('toetsing_overstorten', 'drempelhoogte')):
log.debug(" - missing: %s in %s" % (config.get('toetsing_overstorten', 'drempelhoogte'), input_external_weir))
missing_fields.append("%s: %s" % (input_external_weir, config.get('toetsing_overstorten', 'drempelhoogte')))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#----------------------------------------------------------------------------------------
# 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('toetsing_overstorten', 'calculation_point_ident').lower())
log.debug(waterlevel_dict)
# Add fields to output
if not turtlebase.arcgis.is_fieldname(gp, temp_voronoi, config.get('toetsing_overstorten', 'field_waterstand')):
log.info(" - add field %s" % config.get('toetsing_overstorten', 'field_waterstand'))
gp.addfield(temp_voronoi, "%s" % config.get('toetsing_overstorten', 'field_waterstand'), "double")
# copy waterlevel to voronoi polygons
field_config_waterstand = config.get('toetsing_overstorten', 'field_waterstand').lower()
field_calculation_point_ident = config.get('toetsing_overstorten', 'calculation_point_ident')
rows = gp.UpdateCursor(temp_voronoi)
for row in nens.gp.gp_iterator(rows):
row_id = row.GetValue(field_calculation_point_ident)
if waterlevel_dict.has_key(row_id):
log.debug(waterlevel_dict[row_id])
row.SetValue(field_config_waterstand, waterlevel_dict[row_id][field_config_waterstand])
rows.UpdateRow(row)
#----------------------------------------------------------------------------------------
# Join external weirs to voronoi using spatial location (spatial join)
log.info("join waterlevel to external weirs using a spatial location")
temp_spatial_join = turtlebase.arcgis.get_random_file_name(workspace_gdb)
#gp.SpatialJoin_analysis(input_external_weir, temp_voronoi, temp_spatial_join, "JOIN_ONE_TO_ONE", "#", "#", "INTERSECTS")
gp.Intersect_Analysis(input_external_weir + ';' + temp_voronoi, temp_spatial_join)
external_weir_dict = nens.gp.get_table(gp, temp_spatial_join, primary_key=config.get('toetsing_overstorten', 'overstort_ident').lower())
result_dict = {}
for k, v in external_weir_dict.items():
waterlevel = v[config.get('toetsing_overstorten', 'field_waterstand').lower()]
weir_height = v[config.get('toetsing_overstorten', 'drempelhoogte').lower()]
if waterlevel is None or weir_height is None:
waterlevel = -999
weir_height = -999
result_value = 9
else:
if float(waterlevel) > float(weir_height):
result_value = 1
else:
result_value = 0
result_dict[k] = {config.get('toetsing_overstorten', 'overstort_ident'): k,
config.get('toetsing_overstorten', 'field_waterstand'): waterlevel,
config.get('toetsing_overstorten', 'drempelhoogte'): weir_height,
config.get('toetsing_overstorten', 'field_toetsing_overlast_stedelijk'): result_value}
#----------------------------------------------------------------------------------------
# Create output table
if not gp.exists(output_table_external_weir):
log.info("Create new output table")
temp_result_table = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.CreateTable_management(os.path.dirname(temp_result_table), os.path.basename(temp_result_table))
copy_table = True
else:
temp_result_table = output_table_external_weir
copy_table = False
fields_to_add = [config.get('toetsing_overstorten', 'field_waterstand'),
config.get('toetsing_overstorten', 'drempelhoogte'),
config.get('toetsing_overstorten', 'field_toetsing_overlast_stedelijk')]
if not turtlebase.arcgis.is_fieldname(gp, temp_result_table, config.get('toetsing_overstorten', 'overstort_ident')):
log.debug(" - add field %s to %s" % (config.get('toetsing_overstorten', 'overstort_ident'), temp_result_table))
gp.addfield_management(temp_result_table, config.get('toetsing_overstorten', 'overstort_ident'), '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, config.get('toetsing_overstorten', 'overstort_ident').lower(), result_dict)
if copy_table == True:
gp.TableToTable_conversion(temp_result_table, os.path.dirname(output_table_external_weir), os.path.basename(output_table_external_weir))
#----------------------------------------------------------------------------------------
# Delete temporary workspace geodatabase
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)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
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)
#---------------------------------------------------------------------
# Input parameters
"""
nodig voor deze tool:
"""
tempfiles = []
if len(sys.argv) == 6:
input_hydrovak = sys.argv[1]
optional_area = sys.argv[2][:10]
output_shapefile = sys.argv[3]
optional_bottleneck_points = sys.argv[4]
optional_terminal_points = sys.argv[5]
else:
log.warning("usage: <input_hydrovak> <output_shapefile> <optional_bottleneck_points> <optional_terminal_points> <optional_area>")
sys.exit(1)
tolerance_points = float(config.get('netwerkanalyse', 'tolerance_points'))
input_shapefile = turtlebase.arcgis.get_random_file_name(workspace , ".shp")
tempfiles.append(input_shapefile)
gp.select_analysis(input_hydrovak, input_shapefile)
#---------------------------------------------------------------------
# Check required fields in input data
ovk_field = config.get('general', 'ovkident')
if not turtlebase.arcgis.is_fieldname(gp, input_shapefile, "ovkident"):
errormsg = "fieldname %s not available in %s" % (
"ovkident", input_shapefile)
log.error(errormsg)
#---------------------------------------------------------------------
# add from and to coordinates
update_to_and_from_coordinates(gp, input_shapefile, ovk_field)
network_data = read_table(gp, config, input_shapefile, optional_area)
g = turtlebase.network.import_dbf_into_graph(config, network_data,
tolerance_points, optional_area)
turtlebase.network.let_it_stream(g)
#create output:
fields_to_add = [('incoming', 'SHORT'),
('examined', 'SHORT'),
('terminal', 'SHORT'),
('som_oppvl', 'DOUBLE'),
('bottleneck', 'SHORT'),
('flip', 'SHORT')]
gp.select_analysis(input_shapefile, output_shapefile)
#fields_to_add = {'incoming':"SHORT",'examined':"SHORT",'terminal':"SHORT", 'cum_urban':"DOUBLE", 'cum_rural':"DOUBLE", 'bottleneck':"SHORT", 'flip':"SHORT"} #'ovkident':"TEXT",
for field_to_add in fields_to_add:
field_name = field_to_add[0]
field_type = field_to_add[1]
if turtlebase.arcgis.is_fieldname(gp, output_shapefile, field_name):
gp.DeleteField_management(output_shapefile, field_name)
gp.AddField_management(output_shapefile, field_name, field_type)
log.info("Adding field %s" % field_name)
else:
gp.AddField_management(output_shapefile, field_name, field_type)
log.info("Adding field %s" % field_name)
turtlebase.network.save_result_shapefile(gp, config, g, output_shapefile)
log.info("Recognizing bottlenecks")
log.debug("create field to store bottlenecks")
row = gp.UpdateCursor(output_shapefile)
for item in nens.gp.gp_iterator(row):
examined = item.getValue(config.get('netwerkanalyse', 'examined'))
incoming = item.getValue(config.get('netwerkanalyse', 'incoming'))
terminal = item.getValue(config.get('netwerkanalyse', 'terminal'))
if terminal == 1 and examined == 0:
item.SetValue(config.get('netwerkanalyse', 'bottleneck'), incoming)
if incoming > 1 and examined == 0:
item.SetValue(config.get('netwerkanalyse', 'bottleneck'), incoming)
row.UpdateRow(item)
# als de gebruiker heeft aangegeven de terminal points als puntenbestand te hebben
# moeten eerst de begin x en begin y worden opgeslagen in een dictionary. daarvan
# kan dan een puntenbestand gemaakt worden met functie
if optional_bottleneck_points != '#':
temp_shape = turtlebase.arcgis.get_random_file_name(workspace , ".shp")
tempfiles.append(temp_shape)
log.info("Creating bottleneck points file")
create_point_file_from_polyline(gp, config, output_shapefile, temp_shape, 'bottlenecks')
gp.Select_analysis(temp_shape, optional_bottleneck_points)
# als de gebruiker heeft aangegeven de terminal points als puntenbestand te hebben
# moeten eerst de begin x en begin y worden opgeslagen in een dictionary. daarvan
# kan dan een puntenbestand gemaakt worden met functie
if optional_terminal_points != "#":
temp_shape2 = turtlebase.arcgis.get_random_file_name(workspace , ".shp")
tempfiles.append(temp_shape2)
log.info("Creating terminal points file")
create_point_file_from_polyline(gp, config, output_shapefile, temp_shape2, 'terminals')
gp.Select_analysis(temp_shape2, optional_terminal_points)
#---------------------------------------------------------------------
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
turtlebase.arcgis.remove_tempfiles(gp, log, tempfiles)
log.info("workspace deleted")
except:
log.debug("failed to delete %s" % workspace_gdb)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
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()
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)
#----------------------------------------------------------------------------------------
if len(sys.argv) == 4:
log.info("Reading and checking input")
waterlijnen = sys.argv[1]
peilgebieden = sys.argv[2]
output_file = sys.argv[3]
else:
log.error("usage: <waterlijnen> <peilgebieden> <output_file>")
sys.exit(1)
#----------------------------------------------------------------------------------------
# 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>"
gpgident = config.get('GENERAL', 'gpgident')
check_fields = {peilgebieden: [gpgident]}
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)
#----------------------------------------------------------------------------------------
try:
#bepaald centroide van peilvakken en stop in dictionary
#dict wordt {<gpgident>:[centroid:<centroid>]}
peilgebieden_centroides_dict = bepalen_centroides(gp, peilgebieden, gpgident)
# Eerst een intersect van de peilgebiden met de waterlijnen
#extract de shapefiles uit de geodatabase
log.info("Kopieer " + waterlijnen + " naar de workspace")
waterlijnen_lokaal = turtlebase.arcgis.get_random_file_name(workspace_gdb)
log.debug("Kopieer de waterlijnen naar een lokale directory")
gp.select_analysis(waterlijnen, waterlijnen_lokaal)
intersect = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Intersect_analysis(waterlijnen_lokaal + ";" + peilgebieden, intersect)
log.info("Reading line features")
#nu uitlezen van de nodes van de waterlijnen
waterlijnen_nodes_dict = reading_line_features_nodes(gp, waterlijnen_lokaal)
nodes = turtlebase.arcgis.get_random_file_name(workspace_gdb)
create_point_file_from_dict(gp, waterlijnen_nodes_dict, nodes, "nodes_id")
#nu koppel de nodes aan de peilgebieden dmv een spatial join
spat_jn_nodes = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.SpatialJoin_analysis(nodes, peilgebieden, spat_jn_nodes)
#uitlezen van de nodes van de waterlijnen inclusief gpgident
waterlijnen_nodes_dict = reading_line_feature_nodes_to_dict_according_to_peilgebied(gp, spat_jn_nodes, gpgident)
#uitlezen van de vertices van de waterlijnen
waterlijnen_vertex_dict = reading_line_features_vertices(gp, intersect, gpgident, peilgebieden_centroides_dict)
#bereken het punt het dichtst bij de centroide van een peilgebied. Kijk eerst naar de nodes, dan naar vertices en indien geen waterlijn aanwezig maak dan
# centroide punt aan van het peilgebied
dictionary_with_closest_point_to_centroid_on_waterlijn = calculate_minimal_distance_between_points(gp, peilgebieden_centroides_dict, waterlijnen_nodes_dict, waterlijnen_vertex_dict)
output_centroid_file = turtlebase.arcgis.get_random_file_name(workspace_gdb)
create_point_file_from_dict(gp, dictionary_with_closest_point_to_centroid_on_waterlijn, output_centroid_file, gpgident)
gp.select_analysis(output_centroid_file, output_file)
except Exception, e:
errormsg = traceback.extract_tb(sys.exc_traceback)
log.error(errormsg)
log.error(e)
sys.exit(1)
#----------------------------------------------------------------------------------------
# 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)
mainutils.log_footer()