Ejemplo n.º 1
0
def write_profiles_xyz(gp, profiles_xyz, output_xyz):
    """
    """
    workspace = os.path.dirname(output_xyz)
    fc_name = os.path.basename(output_xyz)
    gp.CreateFeatureClass_management(workspace, fc_name, "Point",
                                "#", "DISABLED", "DISABLED", "#")
    gp.addfield(output_xyz, 'proident', "TEXT")
    gp.addfield(output_xyz, 'xcoord', "DOUBLE")
    gp.addfield(output_xyz, 'ycoord', "DOUBLE")
    gp.addfield(output_xyz, 'zcoord', "DOUBLE")
    gp.addfield(output_xyz, 'p_order', "SHORT")

    rows = gp.InsertCursor(output_xyz)
    point = gp.CreateObject("Point")

    for point_id, attributes in profiles_xyz.items():
        for index, point_xy in enumerate(attributes):
            row = rows.NewRow()
            point.x = point_xy[0]
            point.y = point_xy[1]
            row.shape = point
            row.SetValue('proident', point_id)
            row.SetValue('xcoord', point.x)
            row.SetValue('ycoord', point.y)
            row.SetValue('zcoord', point_xy[2])
            row.SetValue('p_order', index + 1)

            rows.InsertRow(row)
    del rows
    del row
Ejemplo n.º 2
0
def create_centroids(gp, multipoints, output_fc, mp_ident):
    """creates a centerpoint fc out of a multipoint fc
    """
    gp.AddXY_management(multipoints)

    mpoint_desc = gp.describe(multipoints)
    center_points = {}

    row = gp.SearchCursor(multipoints)
    for item in nens.gp.gp_iterator(row):
        feat = item.GetValue(mpoint_desc.ShapeFieldName)
        item_id = item.GetValue(mp_ident)
        xcoord, ycoord = calculate_xy(gp, feat)
        
        center_points[item_id] = {"xcoord": xcoord, "ycoord": ycoord}

    workspace = os.path.dirname(output_fc)
    fc_name = os.path.basename(output_fc)
    gp.CreateFeatureClass_management(workspace, fc_name, "Point",
                                "#", "DISABLED", "DISABLED", "#")
    gp.addfield(output_fc, 'proident', "TEXT")
    gp.addfield(output_fc, 'xcoord', "DOUBLE")
    gp.addfield(output_fc, 'ycoord', "DOUBLE")

    rows = gp.InsertCursor(output_fc)
    point = gp.CreateObject("Point")

    for point_id, attributes in center_points.items():
        row = rows.NewRow()
        point.x = attributes['xcoord']
        point.y = attributes['ycoord']
        row.shape = point
        row.SetValue('proident', point_id)
        row.SetValue('xcoord', point.x)
        row.SetValue('ycoord', point.y)

        rows.InsertRow(row)
    del rows
    del row
Ejemplo n.º 3
0
def write_profiles_yz(gp, profiles_yz, output_yz):
    """
    """
    workspace = os.path.dirname(output_yz)
    table_name = os.path.basename(output_yz)
    gp.CreateTable_management(workspace, table_name)
    gp.addfield(output_yz, 'proident', "TEXT")
    gp.addfield(output_yz, 'dist_mid', "DOUBLE")
    gp.addfield(output_yz, 'bed_lvl', "DOUBLE")
    gp.addfield(output_yz, 'p_order', "SHORT")
    gp.addfield(output_yz, 'target_lvl', "DOUBLE")
    gp.addfield(output_yz, 'water_lvl', "DOUBLE")
    gp.addfield(output_yz, 'xcoord', "DOUBLE")
    gp.addfield(output_yz, 'ycoord', "DOUBLE")

    rows = gp.InsertCursor(output_yz)
    for attributes in profiles_yz:
        row = rows.NewRow()
        row.SetValue('proident', attributes['proident'])
        row.SetValue('dist_mid', float(attributes['dist_mid']))
        row.SetValue('bed_lvl', float(attributes['bed_lvl']))
        row.SetValue('p_order', int(attributes['p_order']))
        row.SetValue('target_lvl', float(attributes['target_lvl']))
        row.SetValue('water_lvl', float(attributes['water_lvl']))
        row.SetValue('xcoord', float(attributes['xcoord']))
        row.SetValue('ycoord', float(attributes['ycoord']))


        rows.InsertRow(row)
    del rows
    del row
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
Ejemplo n.º 5
0
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__)

        #read conversion settings
        modeltype = "RR+RR_CF"

        #---------------------------------------------------------------------
        #check inputfields
        log.info("Getting commandline parameters")

        if len(sys.argv) == 8:
            peilgebieden_feature = sys.argv[1]
            rr_dataset = sys.argv[2]
            afvoerkunstwerken = sys.argv[4]
            koppelpunten = sys.argv[5]
            settings = sys.argv[6]
            output_dir = sys.argv[7]
        else:
            log.error("Usage: python rural_rr_rrcf_conversie.py \
            <peilgebieden_feature> <rr_dataset> <rr_afvoer> \
            <afvoerkunstwerken> <koppelpunten> <settings>")
            sys.exit(1)

        rr_dataset = rr_dataset.replace("\\", "/")
        rr_dataset = rr_dataset.replace("'", "")
        sys.argv[2] = rr_dataset

        log.info("output_dir: " + output_dir)

        #add extra logfile
        fileHandler2 = logging.FileHandler(output_dir + '\\rr_rrcf_convert.log')
        logging.getLogger("nens.turtle").addHandler(fileHandler2)

        #---------------------------------------------------------------------
        #check input parameters
        log.info('Checking presence of input files')
        if not(gp.exists(peilgebieden_feature)):
            log.error("input_toetspunten " + peilgebieden_feature + " does not exist!")
            sys.exit(5)

        #----------------------------------------------------------------------------------------
        #default settings
        if settings == "#":
            location_script = os.path.dirname(sys.argv[0])
            settings = os.path.join(location_script, config.get('RR', 'rr_rrcf_default_settings'))

        rr_config = mainutils.read_config(settings, os.path.basename(settings))

        if not rr_config.get("column.peilgebied", 'paved_runoff_coefficient'):
            log.warning("paved_runoff_coefficient not available in rr+rrcf-settings, default will be used")
            rr_config.set("column.peilgebied", 'paved_runoff_coefficient', "-")
            rr_config.set("default.peilgebied", 'paved_runoff_coefficient', '0.2')

        #----------------------------------------------------------------------------------------
        # Create workspace
        workspace = config.get('GENERAL', 'location_temp')

        configfilename = os.path.join(workspace, "rr_rrcf_settings_temp.ini")
        configfile = open(configfilename, "wb")
        rr_config.write(configfile)
        configfile.close()
        settings = configfilename
        #----------------------------------------------------------------------------------------
        #checking if feature class contains polygons
        log.info("Checking if feature contains polygons")
        pg_obj = gp.describe(peilgebieden_feature)
        if pg_obj.ShapeType != "Polygon":
            log.error(peilgebieden_feature + " does not contain polygons, please add a feature class with polygons")
            log.error(" - gp message: " + gp.GetMessages(2))
            sys.exit(5)

        # If rr_afvoer is empty, ignore this table, because trrrlib will crash
        if sys.argv[3] != '#':
            if turtlebase.arcgis.fc_is_empty(gp, sys.argv[3]):
                log.warning("rr_afvoer is empty, this table will be ignored")
                sys.argv[3] = '#'

        # add xy coordinates
        xcoord = 'XCOORD'
        ycoord = 'YCOORD'
        if not turtlebase.arcgis.is_fieldname(gp, peilgebieden_feature, xcoord):
            gp.addfield(peilgebieden_feature, xcoord, "Double")
        if not turtlebase.arcgis.is_fieldname(gp, peilgebieden_feature, ycoord):
            gp.addfield(peilgebieden_feature, ycoord, "Double")
        add_xy_coords(gp, peilgebieden_feature, xcoord, ycoord)

        #checking if feature class contains points
        if afvoerkunstwerken != "#":
            log.info("Checking if feature contains points")
            ak_obj = gp.describe(afvoerkunstwerken)
            log.debug("ShapeType afvoerkunstwerken = " + ak_obj.ShapeType)
            if ak_obj.ShapeType != "Point":
                log.error(afvoerkunstwerken + " does not contain points, please add a feature class with points")
                log.error(" - gp message: " + gp.GetMessages(2))
                sys.exit(5)

        #check op punten
        if koppelpunten != "#":
            log.info("Checking if feature contains points")
            kp_obj = gp.describe(koppelpunten)
            log.debug("ShapeType koppelpunten = " + kp_obj.ShapeType)
            if kp_obj.ShapeType != "Point":
                log.error(koppelpunten + " does not contain points, please add a feature class with points")
                log.debug(gp.GetMessages(2))
                sys.exit()

        #copy settings to output directory
        shutil.copyfile(settings, output_dir + '\\RR_RRCF_Settings.ini')

        drainage = config.get('RR', 'drainage')
        log.info("drainage type is " + drainage)

        #export rrcf connection to output folder. Convert feature class to shape
        output_shapefiles = output_dir + '\\shapefiles'
        if not os.path.isdir(output_shapefiles):
            os.makedirs(output_shapefiles)
        log.debug("export rrcf connection nodes to" + output_shapefiles)

        gp.Select_analysis(koppelpunten, output_shapefiles + "\\rrcf_connection.shp")
        log.debug("features exported")

        output_sobek = output_dir + "\\sobek_input"
        if not os.path.isdir(output_sobek):
            os.makedirs(output_sobek)

        log.debug("from trrrlib import trrrlib")
        trrrlib.main({}, sys.argv[1:6] + [settings] + [output_sobek] + [drainage] + [modeltype])
        if os.path.isfile(output_sobek + "/struct.def"):
            os.remove(output_sobek + "/struct.def")
        if os.path.isfile(output_sobek + "/profile.dat"):
            os.remove(output_sobek + "/profile.dat")
        log.info("*********************************************************")
        log.info(modeltype + " Conversie compleet")
        log.info("*********************************************************")

        mainutils.log_footer()
    except:
        log.error(traceback.format_exc())
        sys.exit(1)

    finally:
        logging_config.cleanup()
        del gp
Ejemplo n.º 6
0
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()
Ejemplo n.º 7
0
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) == 5:
            input_polygon_fc = sys.argv[1]
            input_channel_fc = sys.argv[2]
            input_landuse_fc = sys.argv[3]
            output_channel = sys.argv[4]
        else:
            log.warning("usage: python geo_genereren_afv_opp.py <input peilgebieden> <input watergangen> <input landgebruik> <output waterlijnen met oppervlak>")
            sys.exit(1)

        #---------------------------------------------------------------------
        # Check geometry input parameters
        log.info("Check geometry of input parameters")
        geometry_check_list = []

        #log.debug(" - check <input >: %s" % argument1)
        gpg_obj = gp.describe(input_polygon_fc)
        if gpg_obj.ShapeType != 'Polygon':
            geometry_check_list.append("input peilgebieden does not contain polygons, it contains shapetype: %s" % gpg_obj.ShapeType)
        else:
            log.info(" - input peilgebieden is correct")

        ovk_obj = gp.describe(input_channel_fc)
        if ovk_obj.ShapeType != 'Polyline':
            geometry_check_list.append("input channel does not contain polyline, it contains shapetype: %s" % ovk_obj.ShapeType)
        else:
            log.info(" - input channel is correct")

        lu_obj = gp.describe(input_landuse_fc)
        if lu_obj.ShapeType != 'Polygon':
            geometry_check_list.append("input landuse does not contain polygons, it contains shapetype: %s" % lu_obj.ShapeType)
        else:
            log.info(" - input landuse is correct")
        #"<check geometry from input data, append to list if incorrect>"

        if len(geometry_check_list) > 0:
            log.error("check input: %s" % geometry_check_list)
            sys.exit(2)
        #---------------------------------------------------------------------
        # Check required fields in input data
        log.info("Check required fields in input data")

        missing_fields = []
        ovk_field = config.get('general', 'ovkident')
        gpg_field = config.get('general', 'gpgident')
        landuse_type = config.get('afv_opp', 'landuse_type')

        if not turtlebase.arcgis.is_fieldname(gp, input_polygon_fc, ovk_field):
            log.error("missing field '%s' in %s" % (ovk_field, input_polygon_fc))
            missing_fields.append("%s: %s" % (input_polygon_fc, ovk_field))

        if not turtlebase.arcgis.is_fieldname(gp, input_channel_fc, ovk_field):
            log.error("missing field '%s' in %s" % (ovk_field, input_channel_fc))
            missing_fields.append("%s: %s" % (input_channel_fc, ovk_field))

        if not turtlebase.arcgis.is_fieldname(gp, input_landuse_fc, 'type'):
            log.error("missing field 'type' in %s" % input_landuse_fc)
            missing_fields.append("%s: TYPE" % (input_landuse_fc))

        if len(missing_fields) > 0:
            log.error("missing fields in input data: %s" % missing_fields)
            sys.exit(2)
        #---------------------------------------------------------------------
        # Environments

        log.info(" - intersect areas with landuse")
        output_intersect_landuse = workspace_gdb + "/landuse_intersect"
        log.info(output_intersect_landuse)
        gp.intersect_analysis(input_polygon_fc + "; " + input_landuse_fc, output_intersect_landuse)

        landuse_type_list = check_for_landuse_types(gp, output_intersect_landuse, "TYPE")
        if len(landuse_type_list) == 0:
            log.error("missing landuse types 'rural' and 'urban'")
            sys.exit(3)

        #log.info(turtlebase.arcgis.is_fieldname(gp, output_intersect_landuse, 'OPP_LA'))
        if not turtlebase.arcgis.is_fieldname(gp, output_intersect_landuse, 'OPP_LA'):
            log.info("create field OPP_LA")
            gp.addfield(output_intersect_landuse, 'OPP_LA', 'Double')
        if not turtlebase.arcgis.is_fieldname(gp, output_intersect_landuse, 'OPP_ST'):
            log.info("create field OPP_ST")
            gp.addfield(output_intersect_landuse, 'OPP_ST', 'Double')

        if 'urban' in landuse_type_list:
            log.info(" - calculate urban area")
            landuse_urban_lyr = turtlebase.arcgis.get_random_layer_name()
            gp.MakeFeatureLayer_management(output_intersect_landuse, landuse_urban_lyr, " TYPE = 'urban' ")
            turtlebase.arcgis.calculate_area(gp, landuse_urban_lyr, "OPP_ST")

        if 'rural' in landuse_type_list:
            log.info(" - calculate rural area")
            landuse_rural_lyr = turtlebase.arcgis.get_random_layer_name()
            gp.MakeFeatureLayer_management(output_intersect_landuse, landuse_rural_lyr, " TYPE = 'rural' ")
            turtlebase.arcgis.calculate_area(gp, landuse_rural_lyr, "OPP_LA")

        output_dissolve_landuse = workspace_gdb + "/dissolve"
        #tempfiles.append(output_dissolve_landuse)
        log.info("check if output fields exist")
        field_rural = "Sum_OPP_LA"
        field_urban = "Sum_OPP_ST"
        if turtlebase.arcgis.is_fieldname(gp, output_intersect_landuse, field_rural):
            log.info(" - %s already exists, delete field" % field_rural)
            gp.deletefield_management(output_intersect_landuse, field_rural)
        if turtlebase.arcgis.is_fieldname(gp, output_intersect_landuse, field_urban):
            gp.deletefield_management(output_intersect_landuse, field_urban)

        log.info(" - dissolve rural and urban areas")
        remove_null_values(gp, output_intersect_landuse, "OPP_LA")
        remove_null_values(gp, output_intersect_landuse, "OPP_ST")

        gp.Dissolve_management(output_intersect_landuse, output_dissolve_landuse, ovk_field, "OPP_LA sum; OPP_ST sum", "MULTI_PART")

        log.info("Copy landuse area to output")
        dissolve_dict = nens.gp.get_table(gp, output_dissolve_landuse, primary_key=ovk_field.lower())
        output_channel_fc = turtlebase.arcgis.get_random_file_name(workspace_gdb)
        calculate_area_fields(gp, input_channel_fc, output_channel_fc, ovk_field, dissolve_dict, field_rural, field_urban)

        # add from and to coordinates
        log.info("Calculate coordinates")
        update_to_and_from_coordinates(gp, output_channel_fc, ovk_field.lower())
        log.info(" - copy output")
        gp.FeatureclassToFeatureclass_conversion(output_channel_fc, os.path.dirname(output_channel), os.path.basename(output_channel))
        #---------------------------------------------------------------------
        # 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()
    except:
        log.error(traceback.format_exc())
        sys.exit(1)

    finally:
        logging_config.cleanup()
        del gp