def soilOccupationChange(input_plot_vector, output_plot_vector, footprint_vector, input_tx_files_list, evolutions_list=['0:1:11000:10:50:and', '0:1:12000:10:50:and', '0:1:21000:10:50:and', '0:1:22000:10:50:and', '0:1:23000:10:50:and'], class_label_dico={11000:'Bati', 12000:'Route', 21000:'SolNu', 22000:'Eau', 23000:'Vegetation'}, epsg=2154, no_data_value=0, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster='.tif', extension_vector='.shp', postgis_ip_host='localhost', postgis_num_port=5432, postgis_user_name='postgres', postgis_password='******', postgis_database_name='database', postgis_schema_name='public', postgis_encoding='latin1', path_time_log='', save_results_intermediate=False, overwrite=True):
if debug >= 3:
print('\n' + bold + green + "Evolution de l'OCS par parcelle - Variables dans la fonction :" + endC)
print(cyan + " soilOccupationChange() : " + endC + "input_plot_vector : " + str(input_plot_vector) + endC)
print(cyan + " soilOccupationChange() : " + endC + "output_plot_vector : " + str(output_plot_vector) + endC)
print(cyan + " soilOccupationChange() : " + endC + "footprint_vector : " + str(footprint_vector) + endC)
print(cyan + " soilOccupationChange() : " + endC + "input_tx_files_list : " + str(input_tx_files_list) + endC)
print(cyan + " soilOccupationChange() : " + endC + "evolutions_list : " + str(evolutions_list) + endC)
print(cyan + " soilOccupationChange() : " + endC + "class_label_dico : " + str(class_label_dico) + endC)
print(cyan + " soilOccupationChange() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + " soilOccupationChange() : " + endC + "no_data_value : " + str(no_data_value) + endC)
print(cyan + " soilOccupationChange() : " + endC + "format_raster : " + str(format_raster) + endC)
print(cyan + " soilOccupationChange() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + " soilOccupationChange() : " + endC + "extension_raster : " + str(extension_raster) + endC)
print(cyan + " soilOccupationChange() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + " soilOccupationChange() : " + endC + "postgis_ip_host : " + str(postgis_ip_host) + endC)
print(cyan + " soilOccupationChange() : " + endC + "postgis_num_port : " + str(postgis_num_port) + endC)
print(cyan + " soilOccupationChange() : " + endC + "postgis_user_name : " + str(postgis_user_name) + endC)
print(cyan + " soilOccupationChange() : " + endC + "postgis_password : "******" soilOccupationChange() : " + endC + "postgis_database_name : " + str(postgis_database_name) + endC)
print(cyan + " soilOccupationChange() : " + endC + "postgis_schema_name : " + str(postgis_schema_name) + endC)
print(cyan + " soilOccupationChange() : " + endC + "postgis_encoding : " + str(postgis_encoding) + endC)
print(cyan + " soilOccupationChange() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + " soilOccupationChange() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + " soilOccupationChange() : " + endC + "overwrite : " + str(overwrite) + endC + '\n')
# Définition des constantes
EXTENSION_TEXT = '.txt'
SUFFIX_TEMP = '_temp'
SUFFIX_CUT = '_cut'
AREA_FIELD = 'st_area'
GEOM_FIELD = 'geom'
# Mise à jour du log
starting_event = "soilOccupationChange() : Début du traitement : "
timeLine(path_time_log, starting_event)
print(cyan + "soilOccupationChange() : " + bold + green + "DEBUT DES TRAITEMENTS" + endC + '\n')
# Définition des variables 'basename'
output_plot_basename = os.path.splitext(os.path.basename(output_plot_vector))[0]
# Définition des variables temp
temp_directory = os.path.dirname(output_plot_vector) + os.sep + output_plot_basename + SUFFIX_TEMP
plot_vector_cut = temp_directory + os.sep + output_plot_basename + SUFFIX_CUT + extension_vector
# Définition des variables PostGIS
plot_table = output_plot_basename.lower()
# Fichier .txt associé au fichier vecteur de sortie, sur la liste des évolutions quantifiées
output_evolution_text_file = os.path.splitext(output_plot_vector)[0] + EXTENSION_TEXT
# Nettoyage des traitements précédents
if debug >= 3:
print(cyan + "soilOccupationChange() : " + endC + "Nettoyage des traitements précédents." + endC + '\n')
removeVectorFile(output_plot_vector, format_vector=format_vector)
removeFile(output_evolution_text_file)
cleanTempData(temp_directory)
dropDatabase(postgis_database_name, user_name=postgis_user_name, password=postgis_password, ip_host=postgis_ip_host, num_port=postgis_num_port, schema_name=postgis_schema_name)
#############
# Etape 0/2 # Préparation des traitements
#############
print(cyan + "soilOccupationChange() : " + bold + green + "ETAPE 0/2 - Début de la préparation des traitements." + endC + '\n')
# Découpage du parcellaire à la zone d'étude
cutVector(footprint_vector, input_plot_vector, plot_vector_cut, overwrite=overwrite, format_vector=format_vector)
# Récupération du nom des champs dans le fichier source (pour isoler les champs nouvellement créés par la suite, et les renommer)
attr_names_list_origin = getAttributeNameList(plot_vector_cut, format_vector=format_vector)
new_attr_names_list_origin = attr_names_list_origin
# Préparation de PostGIS
createDatabase(postgis_database_name, user_name=postgis_user_name, password=postgis_password, ip_host=postgis_ip_host, num_port=postgis_num_port, schema_name=postgis_schema_name)
print(cyan + "soilOccupationChange() : " + bold + green + "ETAPE 0/2 - Fin de la préparation des traitements." + endC + '\n')
#############
# Etape 1/2 # Calculs des statistiques à tx
#############
print(cyan + "soilOccupationChange() : " + bold + green + "ETAPE 1/2 - Début des calculs des statistiques à tx." + endC + '\n')
len_tx = len(input_tx_files_list)
tx = 0
# Boucle sur les fichiers d'entrés à t0+x
for input_tx_file in input_tx_files_list:
if debug >= 3:
print(cyan + "soilOccupationChange() : " + endC + bold + "Calcul des statistiques à tx %s/%s." % (tx+1, len_tx) + endC + '\n')
# Statistiques OCS par parcelle
statisticsVectorRaster(input_tx_file, plot_vector_cut, "", 1, True, False, False, [], [], class_label_dico, path_time_log, clean_small_polygons=True, format_vector=format_vector, save_results_intermediate=save_results_intermediate, overwrite=overwrite)
# Récupération du nom des champs dans le fichier parcellaire (avec les champs créés précédemment dans CVR)
attr_names_list_tx = getAttributeNameList(plot_vector_cut, format_vector=format_vector)
# Isolement des nouveaux champs issus du CVR
fields_name_list = []
for attr_name in attr_names_list_tx:
if attr_name not in new_attr_names_list_origin:
fields_name_list.append(attr_name)
# Gestion des nouveaux noms des champs issus du CVR
new_fields_name_list = []
for field_name in fields_name_list:
new_field_name = 't%s_' % tx + field_name
new_field_name = new_field_name[:10]
new_fields_name_list.append(new_field_name)
new_attr_names_list_origin.append(new_field_name)
# Renommage des champs issus du CVR, pour le relancer par la suite sur d'autres dates
renameFieldsVector(plot_vector_cut, fields_name_list, new_fields_name_list, format_vector=format_vector)
tx += 1
print(cyan + "soilOccupationChange() : " + bold + green + "ETAPE 1/2 - Fin des calculs des statistiques à tx." + endC + '\n')
#############
# Etape 2/2 # Caractérisation des changements
#############
print(cyan + "soilOccupationChange() : " + bold + green + "ETAPE 2/2 - Début de la caractérisation des changements." + endC + '\n')
# Pré-traitements dans PostGIS
plot_table = importVectorByOgr2ogr(postgis_database_name, plot_vector_cut, plot_table, user_name=postgis_user_name, password=postgis_password, ip_host=postgis_ip_host, num_port=postgis_num_port, schema_name=postgis_schema_name, epsg=epsg, codage=postgis_encoding)
connection = openConnection(postgis_database_name, user_name=postgis_user_name, password=postgis_password, ip_host=postgis_ip_host, num_port=postgis_num_port, schema_name=postgis_schema_name)
# Requête SQL pour le calcul de la surface des parcelles
sql_query = "ALTER TABLE %s ADD COLUMN %s REAL;\n" % (plot_table, AREA_FIELD)
sql_query += "UPDATE %s SET %s = ST_Area(%s);\n" % (plot_table, AREA_FIELD, GEOM_FIELD)
# Boucle sur les évolutions à quantifier
temp_field = 1
for evolution in evolutions_list:
evolution_split = evolution.split(':')
idx_bef = int(evolution_split[0])
idx_aft = int(evolution_split[1])
label = int(evolution_split[2])
evol = abs(int(evolution_split[3]))
evol_s = abs(int(evolution_split[4]))
combi = evolution_split[5]
class_name = class_label_dico[label]
def_evo_field = "def_evo_%s" % str(temp_field)
if debug >= 3:
print(cyan + "soilOccupationChange() : " + endC + bold + "Caractérisation des changements t%s/t%s pour la classe '%s' (%s)." % (idx_bef, idx_aft, class_name, label) + endC + '\n')
if evol != 0 or evol_s != 0:
# Gestion de l'évolution via le taux
evol_str = str(evol) + ' %'
evo_field = "evo_%s" % str(temp_field)
t0_field = 't%s_' % idx_bef + class_name.lower()[:7]
t1_field = 't%s_' % idx_aft + class_name.lower()[:7]
# Gestion de l'évolution via la surface
evol_s_str = str(evol_s) + ' m²'
evo_s_field = "evo_s_%s" % str(temp_field)
t0_s_field = 't%s_s_' % idx_bef + class_name.lower()[:5]
t1_s_field = 't%s_s_' % idx_aft + class_name.lower()[:5]
# Requête SQL pour le calcul brut de l'évolution
sql_query += "ALTER TABLE %s ADD COLUMN %s REAL;\n" % (plot_table, evo_field)
sql_query += "UPDATE %s SET %s = %s - %s;\n" % (plot_table, evo_field, t1_field, t0_field)
sql_query += "ALTER TABLE %s ADD COLUMN %s REAL;\n" % (plot_table, evo_s_field)
sql_query += "UPDATE %s SET %s = %s - %s;\n" % (plot_table, evo_s_field, t1_s_field, t0_s_field)
sql_query += "ALTER TABLE %s ADD COLUMN %s VARCHAR;\n" % (plot_table, def_evo_field)
sql_query += "UPDATE %s SET %s = 't%s a t%s - %s - aucune evolution';\n" % (plot_table, def_evo_field, idx_bef, idx_aft, class_name)
# Si évolution à la fois via taux et via surface
if evol != 0 and evol_s != 0:
text_evol = "taux à %s" % evol_str
if combi == 'and':
text_evol += " ET "
elif combi == 'or':
text_evol += " OU "
text_evol += "surface à %s" % evol_s_str
sql_where_pos = "%s >= %s %s %s >= %s" % (evo_field, evol, combi, evo_s_field, evol_s)
sql_where_neg = "%s <= -%s %s %s <= -%s" % (evo_field, evol, combi, evo_s_field, evol_s)
# Si évolution uniquement via taux
elif evol != 0:
text_evol = "taux à %s" % evol_str
sql_where_pos = "%s >= %s" % (evo_field, evol)
sql_where_neg = "%s <= -%s" % (evo_field, evol)
# Si évolution uniquement via surface
elif evol_s != 0:
text_evol = "surface à %s" % evol_s_str
sql_where_pos = "%s >= %s" % (evo_s_field, evol_s)
sql_where_neg = "%s <= -%s" % (evo_s_field, evol_s)
sql_query += "UPDATE %s SET %s = 't%s a t%s - %s - evolution positive' WHERE %s;\n" % (plot_table, def_evo_field, idx_bef, idx_aft, class_name, sql_where_pos)
sql_query += "UPDATE %s SET %s = 't%s a t%s - %s - evolution negative' WHERE %s;\n" % (plot_table, def_evo_field, idx_bef, idx_aft, class_name, sql_where_neg)
# Ajout des paramètres de l'évolution quantifiée (temporalités, classe, taux/surface) au fichier texte de sortie
text = "%s --> évolution entre t%s et t%s, pour la classe '%s' (label %s) :\n" % (def_evo_field, idx_bef, idx_aft, class_name, label)
text += " %s --> taux d'évolution brut" % evo_field + " (%)\n"
text += " %s --> surface d'évolution brute" % evo_s_field + " (m²)\n"
text += "Evolution quantifiée : %s\n" % text_evol
appendTextFileCR(output_evolution_text_file, text)
temp_field += 1
# Traitements SQL de l'évolution des classes OCS
executeQuery(connection, sql_query)
closeConnection(connection)
exportVectorByOgr2ogr(postgis_database_name, output_plot_vector, plot_table, user_name=postgis_user_name, password=postgis_password, ip_host=postgis_ip_host, num_port=postgis_num_port, schema_name=postgis_schema_name, format_type=format_vector)
print(cyan + "soilOccupationChange() : " + bold + green + "ETAPE 2/2 - Fin de la caractérisation des changements." + endC + '\n')
# Suppression des fichiers temporaires
if not save_results_intermediate:
if debug >= 3:
print(cyan + "soilOccupationChange() : " + endC + "Suppression des fichiers temporaires." + endC + '\n')
deleteDir(temp_directory)
dropDatabase(postgis_database_name, user_name=postgis_user_name, password=postgis_password, ip_host=postgis_ip_host, num_port=postgis_num_port, schema_name=postgis_schema_name)
print(cyan + "soilOccupationChange() : " + bold + green + "FIN DES TRAITEMENTS" + endC + '\n')
# Mise à jour du log
ending_event = "soilOccupationChange() : Fin du traitement : "
timeLine(path_time_log, ending_event)
return
def imperviousSurfaceFraction(grid_input, grid_output, classif_input, class_imprevious_list, path_time_log, format_vector='ESRI Shapefile', extension_raster=".tif", save_results_intermediate=False, overwrite=True):
print(bold + yellow + "Début du calcul de l'indicateur Impervious Surface Fraction." + endC + "\n")
timeLine(path_time_log, "Début du calcul de l'indicateur Impervious Surface Fraction : ")
if debug >= 3 :
print(bold + green + "imperviousSurfaceFraction() : Variables dans la fonction" + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "grid_input : " + str(grid_input) + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "grid_output : " + str(grid_output) + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "classif_input : " + str(classif_input) + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "class_imprevious_list : " + str(class_imprevious_list) + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "extension_raster : " + str(extension_raster) + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "imperviousSurfaceFraction() : " + endC + "overwrite : " + str(overwrite) + endC)
if not os.path.exists(grid_output) or overwrite:
############################################
### Préparation générale des traitements ###
############################################
if os.path.exists(grid_output):
removeVectorFile(grid_output)
temp_path = os.path.dirname(grid_output) + os.sep + "ImperviousSurfaceFraction"
impermeability_raster = temp_path + os.sep + "impermeability" + extension_raster
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
os.makedirs(temp_path)
##############################
### Calcul de l'indicateur ###
##############################
print(bold + cyan + "Création de la carte d'imperméabilité :" + endC + "\n")
timeLine(path_time_log, " Création de la carte d'imperméabilité : ")
expression = ""
for id_class in class_imprevious_list :
expression += "im1b1==%s or " %(str(id_class))
expression = expression[:-4]
command = "otbcli_BandMath -il %s -out %s uint8 -exp '%s ? 1 : 99'" %(classif_input, impermeability_raster, expression)
if debug >= 3 :
print(command)
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(cyan + "imperviousSurfaceFraction() : " + bold + red + "!!! Une erreur c'est produite au cours de la commande otbcli_BandMath : " + command + ". Voir message d'erreur." + endC, file=sys.stderr)
raise
print(bold + cyan + "Récupération de Impervious Surface Fraction par maille :" + endC + "\n")
timeLine(path_time_log, " Récupération de Impervious Surface Fraction par maille : ")
statisticsVectorRaster(impermeability_raster, grid_input, grid_output, 1, True, False, False, [], [], {99:'Perm', 1:'Imperm'}, path_time_log, True, format_vector, save_results_intermediate, overwrite)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
else:
print(bold + magenta + "Le calcul du Impervious Surface Fraction a déjà eu lieu." + endC + "\n")
print(bold + yellow + "Fin du calcul de l'indicateur Impervious Surface Fraction." + endC + "\n")
timeLine(path_time_log, "Fin du calcul de l'indicateur Impervious Surface Fraction : ")
return
def computeVegetationHeight(
input_grid, output_grid, soil_occupation, height_model,
height_vegetation, divide_vegetation_classes, vegetation_label,
high_vegetation_label, low_vegetation_label, high_vegetation_field,
low_vegetation_field, veg_mean_field, veg_max_field, veg_rate_field,
codage_float, suffix_temp, no_data_value, format_vector, path_time_log,
save_results_intermediate, overwrite):
temp_grid = os.path.splitext(
input_grid)[0] + suffix_temp + os.path.splitext(input_grid)[1]
if height_model != "":
### Récupération de la hauteur de végétation
if debug >= 3:
print(cyan + "computeVegetationHeight() : " + endC + bold +
"Récupération de la hauteur de végétation." + endC + '\n')
if not divide_vegetation_classes:
expression = "im1b1 == %s ? im2b1 : %s" % (vegetation_label,
no_data_value)
else:
expression = "im1b1 == %s or im1b1 == %s ? im2b1 : %s" % (
high_vegetation_label, low_vegetation_label, no_data_value)
command = "otbcli_BandMath -il %s %s -out %s %s -exp '%s'" % (
soil_occupation, height_model, height_vegetation, codage_float,
expression)
if debug >= 3:
print(command)
exit_code = os.system(command)
if exit_code != 0:
raise NameError(
cyan + "computeVegetationHeight() : " + bold + red +
"Erreur lors de la récupération de la hauteur de végétation." +
endC)
### Récupération de la hauteur moyenne de végétation
if debug >= 3:
print(cyan + "computeVegetationHeight() : " + endC + bold +
"Récupération de la hauteur moyenne de végétation." + endC +
'\n')
col_to_delete_list = ["min", "median", "sum", "std", "unique", "range"]
statisticsVectorRaster(height_vegetation, input_grid, temp_grid, 1,
False, False, True, col_to_delete_list, [], {},
path_time_log, True, format_vector,
save_results_intermediate, overwrite)
renameFieldsVector(temp_grid, ['mean'], [veg_mean_field],
format_vector=format_vector)
renameFieldsVector(temp_grid, ['max'], [veg_max_field],
format_vector=format_vector)
else:
print(
cyan + "computeVegetationHeight() : " + bold + yellow +
"Pas de calcul de l'indicateur 'hauteur moyenne de végétation' (pas de MNH en entrée)."
+ endC + '\n')
copyVectorFile(input_grid, temp_grid, format_vector=format_vector)
if divide_vegetation_classes:
### Récupération du taux de végétation haute
if debug >= 3:
print(cyan + "computeVegetationHeight() : " + endC + bold +
"Récupération du taux de végétation haute." + endC + '\n')
sql_statement = "SELECT *, ((%s/(%s+%s))*100) AS %s FROM %s" % (
high_vegetation_field, high_vegetation_field, low_vegetation_field,
veg_rate_field, os.path.splitext(os.path.basename(temp_grid))[0])
command = "ogr2ogr -sql '%s' -dialect SQLITE %s %s" % (
sql_statement, output_grid, temp_grid)
if debug >= 3:
print(command)
exit_code = os.system(command)
if exit_code != 0:
raise NameError(
cyan + "computeVegetationHeight() : " + bold + red +
"Erreur lors de la récupération du taux de végétation haute." +
endC)
else:
print(
cyan + "computeVegetationHeight() : " + bold + yellow +
"Pas de calcul de l'indicateur 'taux de végétation haute' (pas de distinction végétation haute/basse dans l'OCS)."
+ endC + '\n')
copyVectorFile(temp_grid, output_grid, format_vector=format_vector)
return 0
def occupationIndicator(input_grid,
output_grid,
class_label_dico_out,
input_vector_classif,
field_classif_name,
input_soil_occupation,
input_height_model,
class_build_list,
class_road_list,
class_baresoil_list,
class_water_list,
class_vegetation_list,
class_high_vegetation_list,
class_low_vegetation_list,
epsg=2154,
no_data_value=0,
format_raster='GTiff',
format_vector='ESRI Shapefile',
extension_raster='.tif',
extension_vector='.shp',
path_time_log='',
save_results_intermediate=False,
overwrite=True):
if debug >= 3:
print(
'\n' + bold + green +
"Calcul d'indicateurs du taux de classes OCS - Variables dans la fonction :"
+ endC)
print(cyan + " occupationIndicator() : " + endC + "input_grid : " +
str(input_grid) + endC)
print(cyan + " occupationIndicator() : " + endC + "output_grid : " +
str(output_grid) + endC)
print(cyan + " occupationIndicator() : " + endC +
"class_label_dico_out : " + str(class_label_dico_out) + endC)
print(cyan + " occupationIndicator() : " + endC +
"input_vector_classif : " + str(input_vector_classif) + endC)
print(cyan + " occupationIndicator() : " + endC +
"field_classif_name : " + str(field_classif_name) + endC)
print(cyan + " occupationIndicator() : " + endC +
"input_soil_occupation : " + str(input_soil_occupation) + endC)
print(cyan + " occupationIndicator() : " + endC +
"input_height_model : " + str(input_height_model) + endC)
print(cyan + " occupationIndicator() : " + endC +
"class_build_list : " + str(class_build_list) + endC)
print(cyan + " occupationIndicator() : " + endC +
"class_road_list : " + str(class_road_list) + endC)
print(cyan + " occupationIndicator() : " + endC +
"class_baresoil_list : " + str(class_baresoil_list) + endC)
print(cyan + " occupationIndicator() : " + endC +
"class_water_list : " + str(class_water_list) + endC)
print(cyan + " occupationIndicator() : " + endC +
"class_vegetation_list : " + str(class_vegetation_list) + endC)
print(cyan + " occupationIndicator() : " + endC +
"class_high_vegetation_list : " +
str(class_high_vegetation_list) + endC)
print(cyan + " occupationIndicator() : " + endC +
"class_low_vegetation_list : " + str(class_low_vegetation_list) +
endC)
print(cyan + " occupationIndicator() : " + endC + "epsg : " +
str(epsg) + endC)
print(cyan + " occupationIndicator() : " + endC +
"no_data_value : " + str(no_data_value) + endC)
print(cyan + " occupationIndicator() : " + endC +
"format_raster : " + str(format_raster) + endC)
print(cyan + " occupationIndicator() : " + endC +
"format_vector : " + str(format_vector) + endC)
print(cyan + " occupationIndicator() : " + endC +
"extension_raster : " + str(extension_raster) + endC)
print(cyan + " occupationIndicator() : " + endC +
"extension_vector : " + str(extension_vector) + endC)
print(cyan + " occupationIndicator() : " + endC +
"path_time_log : " + str(path_time_log) + endC)
print(cyan + " occupationIndicator() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + " occupationIndicator() : " + endC + "overwrite : " +
str(overwrite) + endC + '\n')
# Définition des constantes
CODAGE_8BITS = 'uint8'
CODAGE_FLOAT = 'float'
NODATA_FIELD = 'nodata'
PREFIX_S = 'S_'
SUFFIX_TEMP = '_temp'
SUFFIX_RASTER = '_raster'
SUFFIX_HEIGHT = '_height'
SUFFIX_VEGETATION = '_vegetation'
VEG_MEAN_FIELD = 'veg_h_mean'
VEG_MAX_FIELD = 'veg_h_max'
VEG_RATE_FIELD = 'veg_h_rate'
MAJ_OCS_FIELD = 'class_OCS'
BUILT_FIELD, BUILT_LABEL = 'built', 1
MINERAL_FIELD, MINERAL_LABEL = 'mineral', 2
BARESOIL_FIELD, BARESOIL_LABEL = 'baresoil', 3
WATER_FIELD, WATER_LABEL = 'water', 4
VEGETATION_FIELD, VEGETATION_LABEL = 'veget', 5
HIGH_VEGETATION_FIELD, HIGH_VEGETATION_LABEL = 'high_veg', 6
LOW_VEGETATION_FIELD, LOW_VEGETATION_LABEL = 'low_veg', 7
# Mise à jour du log
starting_event = "occupationIndicator() : Début du traitement : "
timeLine(path_time_log, starting_event)
print(cyan + "occupationIndicator() : " + bold + green +
"DEBUT DES TRAITEMENTS" + endC + '\n')
# Définition des variables 'basename'
output_grid_basename = os.path.basename(os.path.splitext(output_grid)[0])
output_grid_dirname = os.path.dirname(output_grid)
soil_occupation_basename = os.path.basename(
os.path.splitext(input_soil_occupation)[0])
# Définition des variables temp
temp_directory = output_grid_dirname + os.sep + output_grid_basename
temp_grid = temp_directory + os.sep + output_grid_basename + SUFFIX_TEMP + extension_vector
temp_soil_occupation = temp_directory + os.sep + soil_occupation_basename + SUFFIX_TEMP + SUFFIX_RASTER + extension_raster
temp_height_vegetation = temp_directory + os.sep + output_grid_basename + SUFFIX_HEIGHT + SUFFIX_VEGETATION + extension_raster
# Nettoyage des traitements précédents
if overwrite:
if debug >= 3:
print(cyan + "occupationIndicator() : " + endC +
"Nettoyage des traitements précédents." + endC + '\n')
removeFile(output_grid)
cleanTempData(temp_directory)
else:
if os.path.exists(output_grid):
raise NameError(
cyan + "occupationIndicator() : " + bold + yellow +
"Le fichier de sortie existe déjà et ne sera pas regénéré." +
endC + '\n')
pass
#############
# Etape 0/3 # Préparation des traitements
#############
print(cyan + "occupationIndicator() : " + bold + green +
"ETAPE 0/3 - Début de la préparation des traitements." + endC + '\n')
# Rasterisation de l'information de classification (OCS) si au format vecteur en entrée
if input_vector_classif != "":
if debug >= 3:
print(cyan + "occupationIndicator() : " + endC + bold +
"Rasterisation de l'OCS vecteur." + endC + '\n')
reference_image = input_soil_occupation
soil_occupation_vector_basename = os.path.basename(
os.path.splitext(input_vector_classif)[0])
input_soil_occupation = temp_directory + os.sep + soil_occupation_vector_basename + SUFFIX_RASTER + extension_raster
command = "otbcli_Rasterization -in %s -out %s %s -im %s -background 0 -mode attribute -mode.attribute.field %s" % (
input_vector_classif, input_soil_occupation, CODAGE_8BITS,
reference_image, field_classif_name)
if debug >= 3:
print(command)
exit_code = os.system(command)
if exit_code != 0:
raise NameError(
cyan + "occupationIndicator() : " + bold + red +
"Erreur lors de la rasterisation de l'OCS vecteur." + endC)
# Analyse de la couche OCS raster
class_other_list = identifyPixelValues(input_soil_occupation)
no_data_ocs = getNodataValueImage(input_soil_occupation, 1)
if no_data_ocs != None:
no_data_value = no_data_ocs
# Affectation de nouveaux codes de classification
divide_vegetation_classes = False
if class_high_vegetation_list != [] and class_low_vegetation_list != []:
divide_vegetation_classes = True
col_to_delete_list = [
"minority", PREFIX_S + NODATA_FIELD, PREFIX_S + BUILT_FIELD,
PREFIX_S + MINERAL_FIELD, PREFIX_S + BARESOIL_FIELD,
PREFIX_S + WATER_FIELD
]
class_label_dico = {
int(no_data_value): NODATA_FIELD,
int(BUILT_LABEL): BUILT_FIELD,
int(MINERAL_LABEL): MINERAL_FIELD,
int(BARESOIL_LABEL): BARESOIL_FIELD,
int(WATER_LABEL): WATER_FIELD
}
if not divide_vegetation_classes:
class_label_dico[int(VEGETATION_LABEL)] = VEGETATION_FIELD
col_to_delete_list.append(PREFIX_S + VEGETATION_FIELD)
else:
class_label_dico[int(HIGH_VEGETATION_LABEL)] = HIGH_VEGETATION_FIELD
class_label_dico[int(LOW_VEGETATION_LABEL)] = LOW_VEGETATION_FIELD
col_to_delete_list.append(PREFIX_S + HIGH_VEGETATION_FIELD)
col_to_delete_list.append(PREFIX_S + LOW_VEGETATION_FIELD)
# Gestion de la réaffectation des classes
if debug >= 3:
print(cyan + "occupationIndicator() : " + endC + bold +
"Reaffectation du raster OCS." + endC + '\n')
reaff_class_list = []
macro_reaff_class_list = []
for label in class_build_list:
if label in class_other_list:
class_other_list.remove(label)
reaff_class_list.append(label)
macro_reaff_class_list.append(BUILT_LABEL)
for label in class_road_list:
if label in class_other_list:
class_other_list.remove(label)
reaff_class_list.append(label)
macro_reaff_class_list.append(MINERAL_LABEL)
for label in class_baresoil_list:
if label in class_other_list:
class_other_list.remove(label)
reaff_class_list.append(label)
macro_reaff_class_list.append(BARESOIL_LABEL)
for label in class_water_list:
if label in class_other_list:
class_other_list.remove(label)
reaff_class_list.append(label)
macro_reaff_class_list.append(WATER_LABEL)
if not divide_vegetation_classes:
for label in class_vegetation_list:
if label in class_other_list:
class_other_list.remove(label)
reaff_class_list.append(label)
macro_reaff_class_list.append(VEGETATION_LABEL)
else:
for label in class_high_vegetation_list:
if label in class_other_list:
class_other_list.remove(label)
reaff_class_list.append(label)
macro_reaff_class_list.append(HIGH_VEGETATION_LABEL)
for label in class_low_vegetation_list:
if label in class_other_list:
class_other_list.remove(label)
reaff_class_list.append(label)
macro_reaff_class_list.append(LOW_VEGETATION_LABEL)
# Reste des valeurs de pixel nom utilisé
for label in class_other_list:
reaff_class_list.append(label)
macro_reaff_class_list.append(no_data_value)
reallocateClassRaster(input_soil_occupation, temp_soil_occupation,
reaff_class_list, macro_reaff_class_list,
CODAGE_8BITS)
print(cyan + "occupationIndicator() : " + bold + green +
"ETAPE 0/3 - Fin de la préparation des traitements." + endC + '\n')
#############
# Etape 1/3 # Calcul des indicateurs de taux de classes OCS
#############
print(
cyan + "occupationIndicator() : " + bold + green +
"ETAPE 1/3 - Début du calcul des indicateurs de taux de classes OCS." +
endC + '\n')
if debug >= 3:
print(cyan + "occupationIndicator() : " + endC + bold +
"Calcul des indicateurs de taux de classes OCS." + endC + '\n')
statisticsVectorRaster(temp_soil_occupation, input_grid, temp_grid, 1,
True, True, False, col_to_delete_list, [],
class_label_dico, path_time_log, True,
format_vector, save_results_intermediate, overwrite)
# Fusion des classes végétation dans le cas où haute et basse sont séparées (pour utilisation du taux de végétation dans le logigramme)
if divide_vegetation_classes:
temp_grid_v2 = os.path.splitext(
temp_grid)[0] + "_v2" + extension_vector
sql_statement = "SELECT *, (%s + %s) AS %s FROM %s" % (
HIGH_VEGETATION_FIELD, LOW_VEGETATION_FIELD, VEGETATION_FIELD,
os.path.splitext(os.path.basename(temp_grid))[0])
os.system("ogr2ogr -sql '%s' -dialect SQLITE %s %s" %
(sql_statement, temp_grid_v2, temp_grid))
removeVectorFile(temp_grid, format_vector=format_vector)
copyVectorFile(temp_grid_v2, temp_grid, format_vector=format_vector)
print(cyan + "occupationIndicator() : " + bold + green +
"ETAPE 1/3 - Fin du calcul des indicateurs de taux de classes OCS." +
endC + '\n')
#############
# Etape 2/3 # Calcul de l'indicateur de "hauteur de végétation"
#############
print(
cyan + "occupationIndicator() : " + bold + green +
"ETAPE 2/3 - Début du calcul de l'indicateur de \"hauteur de végétation\"."
+ endC + '\n')
computeVegetationHeight(
temp_grid, output_grid, temp_soil_occupation, input_height_model,
temp_height_vegetation, divide_vegetation_classes, VEGETATION_LABEL,
HIGH_VEGETATION_LABEL, LOW_VEGETATION_LABEL, HIGH_VEGETATION_FIELD,
LOW_VEGETATION_FIELD, VEG_MEAN_FIELD, VEG_MAX_FIELD, VEG_RATE_FIELD,
CODAGE_FLOAT, SUFFIX_TEMP, no_data_value, format_vector, path_time_log,
save_results_intermediate, overwrite)
print(
cyan + "occupationIndicator() : " + bold + green +
"ETAPE 2/3 - Fin du calcul de l'indicateur de \"hauteur de végétation\"."
+ endC + '\n')
#############
# Etape 3/3 # Calcul de l'indicateur de classe majoritaire
#############
print(
cyan + "occupationIndicator() : " + bold + green +
"ETAPE 3/3 - Début du calcul de l'indicateur de classe majoritaire." +
endC + '\n')
if input_height_model != "":
computeMajorityClass(output_grid, temp_directory, NODATA_FIELD,
BUILT_FIELD, MINERAL_FIELD, BARESOIL_FIELD,
WATER_FIELD, VEGETATION_FIELD,
HIGH_VEGETATION_FIELD, LOW_VEGETATION_FIELD,
MAJ_OCS_FIELD, VEG_MEAN_FIELD,
class_label_dico_out, format_vector,
extension_vector, overwrite)
else:
print(
cyan + "occupationIndicator() : " + bold + yellow +
"Pas de calcul de l'indicateur de classe majoritaire demandé (pas de MNH en entrée)."
+ endC + '\n')
print(cyan + "occupationIndicator() : " + bold + green +
"ETAPE 3/3 - Fin du calcul de l'indicateur de classe majoritaire." +
endC + '\n')
####################################################################
# Suppression des fichiers temporaires
if not save_results_intermediate:
if debug >= 3:
print(cyan + "occupationIndicator() : " + endC +
"Suppression des fichiers temporaires." + endC + '\n')
deleteDir(temp_directory)
print(cyan + "occupationIndicator() : " + bold + green +
"FIN DES TRAITEMENTS" + endC + '\n')
# Mise à jour du log
ending_event = "occupationIndicator() : Fin du traitement : "
timeLine(path_time_log, ending_event)
return 0
def computeRoughnessByOcsMnh( grid_input, grid_output, mnh_input, classif_input, class_build_list, epsg, no_data_value, path_time_log, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True):
# Constante
FIELD_H_TYPE = ogr.OFTReal
FIELD_ID_TYPE = ogr.OFTInteger
FIELD_NAME_HSUM = "sum_h"
FIELD_NAME_HRE = "mean_h"
FIELD_NAME_AREA = "nb_area"
FIELD_NAME_ID = "id"
SUFFIX_HEIGHT = '_hauteur'
SUFFIX_BUILT = '_bati'
SUFFIX_TEMP = '_temp'
SUFFIX_MASK = '_mask'
# Mise à jour du Log
timeLine(path_time_log, "Début du calcul de l'indicateur Height of Roughness Elements par OCS et MNT starting : ")
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "Début du calcul de l'indicateur Height of Roughness Elements par OCS et MNT." + endC + "\n")
if debug >= 3:
print(bold + green + "computeRoughnessByOcsMnh() : Variables dans la fonction" + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "grid_input : " + str(grid_input) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "grid_output : " + str(grid_output) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "mnh_input : " + str(mnh_input) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "classif_input : " + str(classif_input) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "class_build_list : " + str(class_build_list) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "no_data_value : " + str(no_data_value) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "overwrite : " + str(overwrite) + endC)
# Test si le vecteur de sortie existe déjà et si il doit être écrasés
check = os.path.isfile(grid_output)
if check and not overwrite: # Si le fichier de sortie existent deja et que overwrite n'est pas activé
print(cyan + "computeRoughnessByOcsMnh() : " + bold + yellow + "Le calcul de Roughness par OCS et MNT a déjà eu lieu." + endC + "\n")
print(cyan + "computeRoughnessByOcsMnh() : " + bold + yellow + "Grid vector output : " + grid_output + " already exists and will not be created again." + endC)
else :
if check:
try:
removeVectorFile(grid_output)
except Exception:
pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée
############################################
### Préparation générale des traitements ###
############################################
# Récuperation de la projection de l'image
epsg_proj = getProjectionImage(classif_input)
if epsg_proj == 0:
epsg_proj = epsg
# Préparation des fichiers temporaires
temp_path = os.path.dirname(grid_output) + os.sep + "RoughnessByOcsAndMnh"
# Nettoyage du repertoire temporaire si il existe
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
os.makedirs(temp_path)
basename = os.path.splitext(os.path.basename(grid_output))[0]
built_height = temp_path + os.sep + basename + SUFFIX_HEIGHT + SUFFIX_BUILT + extension_raster
built_height_temp = temp_path + os.sep + basename + SUFFIX_HEIGHT + SUFFIX_BUILT + SUFFIX_TEMP + extension_raster
classif_built_mask = temp_path + os.sep + basename + SUFFIX_BUILT + SUFFIX_MASK + extension_raster
grid_output_temp = temp_path + os.sep + basename + SUFFIX_TEMP + extension_vector
##############################
### Calcul de l'indicateur ###
##############################
# liste des classes de bati a prendre en compte dans l'expression du BandMath
expression_bati = ""
for id_class in class_build_list :
expression_bati += "im1b1==%s or " %(str(id_class))
expression_bati = expression_bati[:-4]
expression = "(%s) and (im2b1!=%s) and (im2b1>0)" %(expression_bati, str(no_data_value))
# Creation d'un masque vecteur des batis pour la surface des zones baties
command = "otbcli_BandMath -il %s %s -out %s uint8 -exp '%s ? 1 : 0'" %(classif_input, mnh_input, classif_built_mask, expression)
if debug >= 3:
print(command)
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(cyan + "computeRoughnessByOcsMnh() : " + bold + red + "!!! Une erreur c'est produite au cours de la commande otbcli_BandMath : " + command + ". Voir message d'erreur." + endC, file=sys.stderr)
raise
# Récupération de la hauteur du bati
command = "otbcli_BandMath -il %s %s -out %s float -exp '%s ? im2b1 : 0'" %(classif_input, mnh_input, built_height_temp, expression)
if debug >= 3:
print(command)
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(cyan + "computeRoughnessByOcsMnh() : " + bold + red + "!!! Une erreur c'est produite au cours de la commande otbcli_BandMath : " + command + ". Voir message d'erreur." + endC, file=sys.stderr)
raise
command = "gdal_translate -a_srs EPSG:%s -a_nodata %s -of %s %s %s" %(str(epsg_proj), str(no_data_value), format_raster, built_height_temp, built_height)
if debug >= 3:
print(command)
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(cyan + "computeRoughnessByOcsMnh() : " + bold + red + "!!! Une erreur c'est produite au cours de la comande : gdal_translate : " + command + ". Voir message d'erreur." + endC, file=sys.stderr)
raise
# Récupération du nombre de pixel bati de chaque maille pour definir la surface
statisticsVectorRaster(classif_built_mask, grid_input, grid_output_temp, 1, False, False, True, ["min", "max", "median", "mean", "std", "unique", "range"], [], {}, path_time_log, True, format_vector, save_results_intermediate, overwrite)
# Renomer le champ 'sum' en FIELD_NAME_AREA
renameFieldsVector(grid_output_temp, ['sum'], [FIELD_NAME_AREA], format_vector)
# Récupération de la hauteur moyenne du bati de chaque maille
statisticsVectorRaster(built_height, grid_output_temp, grid_output, 1, False, False, True, ["min", "max", "median", 'mean', "std", "unique", "range"], [], {}, path_time_log, True, format_vector, save_results_intermediate, overwrite)
# Renomer le champ 'mean' en FIELD_NAME_HRE
renameFieldsVector(grid_output, ['sum'], [FIELD_NAME_HSUM], format_vector)
# Calcul de la colonne FIELD_NAME_HRE division de FIELD_NAME_HSUM par FIELD_NAME_AREA
field_values_list = getAttributeValues(grid_output, None, None, {FIELD_NAME_ID:FIELD_ID_TYPE, FIELD_NAME_HSUM:FIELD_H_TYPE, FIELD_NAME_AREA:FIELD_H_TYPE}, format_vector)
field_new_values_list = []
for index in range(0, len(field_values_list[FIELD_NAME_ID])) :
value_h = 0.0
if field_values_list[FIELD_NAME_AREA][index] > 0 :
value_h = field_values_list[FIELD_NAME_HSUM][index] / field_values_list[FIELD_NAME_AREA][index]
field_new_values_list.append({FIELD_NAME_HRE:value_h})
# Ajour de la nouvelle colonne calculé FIELD_NAME_HRE
addNewFieldVector(grid_output, FIELD_NAME_HRE, FIELD_H_TYPE, 0, None, None, format_vector)
setAttributeValuesList(grid_output, field_new_values_list, format_vector)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
print(cyan + "computeRoughnessByOcsMnh() : " + endC + "Fin du calcul de l'indicateur Height of Roughness Elements par OCS et MNT." + endC + "\n")
timeLine(path_time_log, "Fin du calcul de l'indicateur Height of Roughness Elements par OCS et MNT ending : ")
return
def createMnh(image_mns_input, image_mnt_input, image_threshold_input, vector_emprise_input, image_mnh_output, automatic, bd_road_vector_input_list, bd_road_buff_list, sql_road_expression_list, bd_build_vector_input_list, height_bias, threshold_bd_value, threshold_delta_h, mode_interpolation, method_interpolation, interpolation_bco_radius, simplify_vector_param, epsg, no_data_value, ram_otb, path_time_log, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True):
# Mise à jour du Log
starting_event = "createMnh() : MNH creation starting : "
timeLine(path_time_log,starting_event)
print(endC)
print(bold + green + "## START : MNH CREATION" + endC)
print(endC)
if debug >= 2:
print(bold + green + "createMnh() : Variables dans la fonction" + endC)
print(cyan + "createMnh() : " + endC + "image_mns_input : " + str(image_mns_input) + endC)
print(cyan + "createMnh() : " + endC + "image_mnt_input : " + str(image_mnt_input) + endC)
print(cyan + "createMnh() : " + endC + "image_threshold_input : " + str(image_threshold_input) + endC)
print(cyan + "createMnh() : " + endC + "vector_emprise_input : " + str(vector_emprise_input) + endC)
print(cyan + "createMnh() : " + endC + "image_mnh_output : " + str(image_mnh_output) + endC)
print(cyan + "createMnh() : " + endC + "automatic : " + str(automatic) + endC)
print(cyan + "createMnh() : " + endC + "bd_road_vector_input_list : " + str(bd_road_vector_input_list) + endC)
print(cyan + "createMnh() : " + endC + "bd_road_buff_list : " + str(bd_road_buff_list) + endC)
print(cyan + "createMnh() : " + endC + "sql_road_expression_list : " + str(sql_road_expression_list) + endC)
print(cyan + "createMnh() : " + endC + "bd_build_vector_input_list : " + str(bd_build_vector_input_list) + endC)
print(cyan + "createMnh() : " + endC + "height_bias : " + str(height_bias) + endC)
print(cyan + "createMnh() : " + endC + "threshold_bd_value : " + str(threshold_bd_value) + endC)
print(cyan + "createMnh() : " + endC + "threshold_delta_h : " + str(threshold_delta_h) + endC)
print(cyan + "createMnh() : " + endC + "mode_interpolation : " + str(mode_interpolation) + endC)
print(cyan + "createMnh() : " + endC + "method_interpolation : " + str(method_interpolation) + endC)
print(cyan + "createMnh() : " + endC + "interpolation_bco_radius : " + str(interpolation_bco_radius) + endC)
print(cyan + "createMnh() : " + endC + "simplify_vector_param : " + str(simplify_vector_param) + endC)
print(cyan + "createMnh() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + "createMnh() : " + endC + "no_data_value : " + str(no_data_value) + endC)
print(cyan + "createMnh() : " + endC + "ram_otb : " + str(ram_otb) + endC)
print(cyan + "createMnh() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "createMnh() : " + endC + "format_raster : " + str(format_raster) + endC)
print(cyan + "createMnh() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "createMnh() : " + endC + "extension_raster : " + str(extension_raster) + endC)
print(cyan + "createMnh() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "createMnh() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "createMnh() : " + endC + "overwrite : " + str(overwrite) + endC)
# LES CONSTANTES
PRECISION = 0.0000001
CODAGE_8B = "uint8"
CODAGE_F = "float"
SUFFIX_CUT = "_cut"
SUFFIX_CLEAN = "_clean"
SUFFIX_SAMPLE = "_sample"
SUFFIX_MASK = "_mask"
SUFFIX_TMP = "_tmp"
SUFFIX_MNS = "_mns"
SUFFIX_MNT = "_mnt"
SUFFIX_ROAD = "_road"
SUFFIX_BUILD = "_build"
SUFFIX_RASTER = "_raster"
SUFFIX_VECTOR = "_vector"
# DEFINIR LES REPERTOIRES ET FICHIERS TEMPORAIRES
repertory_output = os.path.dirname(image_mnh_output)
basename_mnh = os.path.splitext(os.path.basename(image_mnh_output))[0]
sub_repertory_raster_temp = repertory_output + os.sep + basename_mnh + SUFFIX_RASTER + SUFFIX_TMP
sub_repertory_vector_temp = repertory_output + os.sep + basename_mnh + SUFFIX_VECTOR + SUFFIX_TMP
cleanTempData(sub_repertory_raster_temp)
cleanTempData(sub_repertory_vector_temp)
basename_vector_emprise = os.path.splitext(os.path.basename(vector_emprise_input))[0]
basename_mns_input = os.path.splitext(os.path.basename(image_mns_input))[0]
basename_mnt_input = os.path.splitext(os.path.basename(image_mnt_input))[0]
image_mnh_tmp = sub_repertory_raster_temp + os.sep + basename_mnh + SUFFIX_TMP + extension_raster
image_mnh_road = sub_repertory_raster_temp + os.sep + basename_mnh + SUFFIX_ROAD + extension_raster
vector_bd_bati_temp = sub_repertory_vector_temp + os.sep + basename_mnh + SUFFIX_BUILD + SUFFIX_TMP + extension_vector
vector_bd_bati = repertory_output + os.sep + basename_mnh + SUFFIX_BUILD + extension_vector
raster_bd_bati = sub_repertory_vector_temp + os.sep + basename_mnh + SUFFIX_BUILD + extension_raster
removeVectorFile(vector_bd_bati)
image_emprise_mnt_mask = sub_repertory_raster_temp + os.sep + basename_vector_emprise + SUFFIX_MNT + extension_raster
image_mnt_cut = sub_repertory_raster_temp + os.sep + basename_mnt_input + SUFFIX_CUT + extension_raster
image_mnt_clean = sub_repertory_raster_temp + os.sep + basename_mnt_input + SUFFIX_CLEAN + extension_raster
image_mnt_clean_sample = sub_repertory_raster_temp + os.sep + basename_mnt_input + SUFFIX_CLEAN + SUFFIX_SAMPLE + extension_raster
image_emprise_mns_mask = sub_repertory_raster_temp + os.sep + basename_vector_emprise + SUFFIX_MNS + extension_raster
image_mns_cut = sub_repertory_raster_temp + os.sep + basename_mns_input + SUFFIX_CUT + extension_raster
image_mns_clean = sub_repertory_raster_temp + os.sep + basename_mns_input + SUFFIX_CLEAN + extension_raster
vector_bd_road_temp = sub_repertory_vector_temp + os.sep + basename_mnh + SUFFIX_ROAD + SUFFIX_TMP + extension_vector
raster_bd_road_mask = sub_repertory_raster_temp + os.sep + basename_mnh + SUFFIX_ROAD + SUFFIX_MASK + extension_raster
if image_threshold_input != "" :
basename_threshold_input = os.path.splitext(os.path.basename(image_threshold_input))[0]
image_threshold_cut = sub_repertory_raster_temp + os.sep + basename_threshold_input + SUFFIX_CUT + extension_raster
image_threshold_mask = sub_repertory_raster_temp + os.sep + basename_threshold_input + SUFFIX_MASK + extension_raster
# VERIFICATION SI LE FICHIER DE SORTIE EXISTE DEJA
# Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors on ne fait rien
check = os.path.isfile(image_mnh_output)
if check and not overwrite:
print(bold + yellow + "createMnh() : " + endC + "Create mnh %s from %s and %s already done : no actualisation" % (image_mnh_output, image_mns_input, image_mnt_input) + endC)
# Si non, ou si la fonction ecrasement est désative, alors on le calcule
else:
if check:
try: # Suppression de l'éventuel fichier existant
removeFile(image_mnh_output)
except Exception:
pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite
# DECOUPAGE DES FICHIERS MS ET MNT D'ENTREE PAR LE FICHIER D'EMPRISE
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Decoupage selon l'emprise des fichiers %s et %s " %(image_mns_input, image_mnt_input) + endC)
# Fonction de découpe du mns
if not cutImageByVector(vector_emprise_input, image_mns_input, image_mns_cut, None, None, no_data_value, epsg, format_raster, format_vector) :
raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_mns_input + ". Voir message d'erreur." + endC)
# Fonction de découpe du mnt
if not cutImageByVector(vector_emprise_input, image_mnt_input, image_mnt_cut, None, None, no_data_value, epsg, format_raster, format_vector) :
raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_mnt_input + ". Voir message d'erreur." + endC)
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Decoupage des fichiers %s et %s complet" %(image_mns_cut, image_mnt_cut) + endC)
# REBOUCHAGE DES TROUS DANS LE MNT D'ENTREE SI NECESSAIRE
nodata_mnt = getNodataValueImage(image_mnt_cut)
pixelNodataCount = countPixelsOfValue(image_mnt_cut, nodata_mnt)
if pixelNodataCount > 0 :
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Fill the holes MNT for %s" %(image_mnt_cut) + endC)
# Rasterisation du vecteur d'emprise pour creer un masque pour boucher les trous du MNT
rasterizeBinaryVector(vector_emprise_input, image_mnt_cut, image_emprise_mnt_mask, 1, CODAGE_8B)
# Utilisation de SAGA pour boucher les trous
fillNodata(image_mnt_cut, image_emprise_mnt_mask, image_mnt_clean, save_results_intermediate)
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Fill the holes MNT to %s completed" %(image_mnt_clean) + endC)
else :
image_mnt_clean = image_mnt_cut
if debug >= 3:
print(bold + green + "\ncreateMnh() : " + endC + "Fill the holes not necessary MNT for %s" %(image_mnt_cut) + endC)
# REBOUCHAGE DES TROUS DANS LE MNS D'ENTREE SI NECESSAIRE
nodata_mns = getNodataValueImage(image_mns_cut)
pixelNodataCount = countPixelsOfValue(image_mns_cut, nodata_mns)
if pixelNodataCount > 0 :
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Fill the holes MNS for %s" %(image_mns_cut) + endC)
# Rasterisation du vecteur d'emprise pour creer un masque pour boucher les trous du MNS
rasterizeBinaryVector(vector_emprise_input, image_mns_cut, image_emprise_mns_mask, 1, CODAGE_8B)
# Utilisation de SAGA pour boucher les trous
fillNodata(image_mns_cut, image_emprise_mns_mask, image_mns_clean, save_results_intermediate)
if debug >= 3:
print(bold + green + "\ncreateMnh() : " + endC + "Fill the holes MNS to %s completed" %(image_mns_clean) + endC)
else :
image_mns_clean = image_mns_cut
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Fill the holes not necessary MNS for %s" %(image_mns_cut) + endC)
# CALLER LE FICHIER MNT AU FORMAT DU FICHIER MNS
# Commande de mise en place de la geométrie re-echantionage
command = "otbcli_Superimpose -inr " + image_mns_clean + " -inm " + image_mnt_clean + " -mode " + mode_interpolation + " -interpolator " + method_interpolation + " -out " + image_mnt_clean_sample
if method_interpolation.lower() == 'bco' :
command += " -interpolator.bco.radius " + str(interpolation_bco_radius)
if ram_otb > 0:
command += " -ram %d" %(ram_otb)
if debug >= 3:
print(cyan + "createMnh() : " + bold + green + "Réechantillonage du fichier %s par rapport à la reference %s" %(image_mnt_clean, image_mns_clean) + endC)
print(command)
exit_code = os.system(command)
if exit_code != 0:
print(command)
raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du superimpose de l'image : " + image_mnt_input + ". Voir message d'erreur." + endC)
# INCRUSTATION DANS LE MNH DES DONNEES VECTEURS ROUTES
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Use BD road to clean MNH" + endC)
# Creation d'un masque de filtrage des donnes routes (exemple : le NDVI)
if image_threshold_input != "" :
if not cutImageByVector(vector_emprise_input, image_threshold_input, image_threshold_cut, None, None, no_data_value, epsg, format_raster, format_vector) :
raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_threshold_input + ". Voir message d'erreur." + endC)
createBinaryMask(image_threshold_cut, image_threshold_mask, threshold_bd_value, False, CODAGE_8B)
# Execution de la fonction createMacroSamples pour une image correspondant au données routes
if bd_road_vector_input_list != [] :
createMacroSamples(image_mns_clean, vector_emprise_input, vector_bd_road_temp, raster_bd_road_mask, bd_road_vector_input_list, bd_road_buff_list, sql_road_expression_list, path_time_log, basename_mnh, simplify_vector_param, format_vector, extension_vector, save_results_intermediate, overwrite)
if debug >= 3:
print(bold + green + "\ncreateMnh() : " + endC + "File raster from BD road is create %s" %(raster_bd_road_mask) + endC)
# CALCUL DU MNH
# Calcul par bandMath du MNH definir l'expression qui soustrait le MNT au MNS en introduisant le biais et en mettant les valeurs à 0 à une valeur approcher de 0.0000001
delta = ""
if height_bias > 0 :
delta = "+%s" %(str(height_bias))
elif height_bias < 0 :
delta = "-%s" %(str(abs(height_bias)))
else :
delta = ""
# Definition de l'expression
if bd_road_vector_input_list != [] :
if image_threshold_input != "" :
expression = "\"im3b1 > 0 and im4b1 > 0?%s:(im1b1-im2b1%s) > 0.0?im1b1-im2b1%s:%s\"" %(str(PRECISION), delta, delta, str(PRECISION))
command = "otbcli_BandMath -il %s %s %s %s -out %s %s -exp %s" %(image_mns_clean, image_mnt_clean_sample, raster_bd_road_mask, image_threshold_mask, image_mnh_tmp, CODAGE_F, expression)
else :
expression = "\"im3b1 > 0?%s:(im1b1-im2b1%s) > 0.0?im1b1-im2b1%s:%s\"" %(str(PRECISION), delta, delta, str(PRECISION))
command = "otbcli_BandMath -il %s %s %s -out %s %s -exp %s" %(image_mns_clean, image_mnt_clean_sample, raster_bd_road_mask, image_mnh_tmp, CODAGE_F, expression)
else :
expression = "\"(im1b1-im2b1%s) > 0.0?im1b1-im2b1%s:%s\"" %(delta, delta, str(PRECISION))
command = "otbcli_BandMath -il %s %s -out %s %s -exp %s" %(image_mns_clean, image_mnt_clean_sample, image_mnh_tmp, CODAGE_F, expression)
if ram_otb > 0:
command += " -ram %d" %(ram_otb)
if debug >= 3:
print(cyan + "createMnh() : " + bold + green + "Calcul du MNH %s difference du MNS : %s par le MNT :%s" %(image_mnh_tmp, image_mns_clean, image_mnt_clean_sample) + endC)
print(command)
exitCode = os.system(command)
if exitCode != 0:
print(command)
raise NameError(cyan + "createMnh() : " + bold + red + "An error occured during otbcli_BandMath command to compute MNH " + image_mnh_tmp + ". See error message above." + endC)
# DECOUPAGE DU MNH
if bd_build_vector_input_list == []:
image_mnh_road = image_mnh_output
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Decoupage selon l'emprise du fichier mnh %s " %(image_mnh_tmp) + endC)
# Fonction de découpe du mnh
if not cutImageByVector(vector_emprise_input, image_mnh_tmp, image_mnh_road, None, None, no_data_value, epsg, format_raster, format_vector) :
raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_mns_input + ". Voir message d'erreur." + endC)
if debug >= 3:
print(bold + green + "createMnh() : " + endC + "Decoupage du fichier mnh %s complet" %(image_mnh_road) + endC)
# INCRUSTATION DANS LE MNH DES DONNEES VECTEURS BATIS
# Si demander => liste de fichier vecteur bati passé en donnée d'entrée
if bd_build_vector_input_list != []:
# Découpage des vecteurs de bd bati exogenes avec l'emprise
vectors_build_cut_list = []
for vector_build_input in bd_build_vector_input_list :
vector_name = os.path.splitext(os.path.basename(vector_build_input))[0]
vector_build_cut = sub_repertory_vector_temp + os.sep + vector_name + SUFFIX_CUT + extension_vector
vectors_build_cut_list.append(vector_build_cut)
cutoutVectors(vector_emprise_input, bd_build_vector_input_list, vectors_build_cut_list, format_vector)
# Fusion des vecteurs batis découpés
fusionVectors (vectors_build_cut_list, vector_bd_bati_temp)
# Croisement vecteur rasteur entre le vecteur fusion des batis et le MNH créé precedement
statisticsVectorRaster(image_mnh_road, vector_bd_bati_temp, "", 1, False, False, True, ['PREC_PLANI','PREC_ALTI','ORIGIN_BAT','median','sum','std','unique','range'], [], {}, path_time_log, True, format_vector, save_results_intermediate, overwrite)
# Calcul de la colonne delta_H entre les hauteurs des batis et la hauteur moyenne du MNH sous le bati
COLUMN_ID = "ID"
COLUMN_H_BUILD = "HAUTEUR"
COLUMN_H_BUILD_MIN = "Z_MIN"
COLUMN_H_BUILD_MAX = "Z_MAX"
COLUMN_H_MNH = "mean"
COLUMN_H_MNH_MIN = "min"
COLUMN_H_MNH_MAX = "max"
COLUMN_H_DIFF = "H_diff"
field_type = ogr.OFTReal
field_value = 0.0
field_width = 20
field_precision = 2
attribute_name_dico = {}
attribute_name_dico[COLUMN_ID] = ogr.OFTString
attribute_name_dico[COLUMN_H_BUILD] = ogr.OFTReal
attribute_name_dico[COLUMN_H_MNH] = ogr.OFTReal
# Ajouter la nouvelle colonne H_diff
addNewFieldVector(vector_bd_bati_temp, COLUMN_H_DIFF, field_type, field_value, field_width, field_precision, format_vector)
# Recuperer les valeur de hauteur du bati et du mnt dans le vecteur
data_z_dico = getAttributeValues(vector_bd_bati_temp, None, None, attribute_name_dico, format_vector)
# Calculer la difference des Hauteur bati et mnt
field_new_values_dico = {}
for index in range(len(data_z_dico[COLUMN_ID])) :
index_polygon = data_z_dico[COLUMN_ID][index]
delta_h = abs(data_z_dico[COLUMN_H_BUILD][index] - data_z_dico[COLUMN_H_MNH][index])
field_new_values_dico[index_polygon] = {COLUMN_H_DIFF:delta_h}
# Mettre à jour la colonne H_diff dans le vecteur
setAttributeIndexValuesList(vector_bd_bati_temp, COLUMN_ID, field_new_values_dico, format_vector)
# Suppression de tous les polygones bati dons la valeur du delat H est inferieur à threshold_delta_h
column = "'%s, %s, %s, %s, %s, %s, %s, %s'"% (COLUMN_ID, COLUMN_H_BUILD, COLUMN_H_BUILD_MIN, COLUMN_H_BUILD_MAX, COLUMN_H_MNH, COLUMN_H_MNH_MIN, COLUMN_H_MNH_MAX, COLUMN_H_DIFF)
expression = "%s > %s" % (COLUMN_H_DIFF, threshold_delta_h)
filterSelectDataVector(vector_bd_bati_temp, vector_bd_bati, column, expression, overwrite, format_vector)
# Attention!!!! PAUSE pour trie et verification des polygones bati nom deja present dans le MNH ou non
if not automatic :
print(bold + blue + "Application MnhCreation => " + endC + "Vérification manuelle du vecteur bati %s pour ne concerver que les batis non présent dans le MNH courant %s" %(vector_bd_bati_temp, image_mnh_road) + endC)
input(bold + red + "Appuyez sur entree pour continuer le programme..." + endC)
# Creation du masque bati avec pour H la hauteur des batiments
rasterizeVector(vector_bd_bati, raster_bd_bati, image_mnh_road, COLUMN_H_BUILD)
# Fusion du mask des batis et du MNH temporaire
expression = "\"im1b1 > 0.0?im1b1:im2b1\""
command = "otbcli_BandMath -il %s %s -out %s %s -exp %s" %(raster_bd_bati, image_mnh_road, image_mnh_output, CODAGE_F, expression)
if ram_otb > 0:
command += " -ram %d" %(ram_otb)
if debug >= 3:
print(cyan + "createMnh() : " + bold + green + "Amelioration du MNH %s ajout des hauteurs des batis %s" %(image_mnh_road, raster_bd_bati) + endC)
print(command)
exitCode = os.system(command)
if exitCode != 0:
print(command)
raise NameError(cyan + "createMnh() : " + bold + red + "An error occured during otbcli_BandMath command to compute MNH Final" + image_mnh_output + ". See error message above." + endC)
# SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES
# Suppression des fichiers intermédiaires
if not save_results_intermediate :
if bd_build_vector_input_list != []:
removeFile(image_mnh_road)
removeFile(image_threshold_cut)
removeFile(image_threshold_mask)
removeFile(raster_bd_bati)
removeVectorFile(vector_bd_road_temp)
removeVectorFile(vector_bd_bati_temp)
removeVectorFile(vector_bd_bati) # A confirmer!!!
removeFile(raster_bd_road_mask)
removeFile(image_mnh_tmp)
deleteDir(sub_repertory_raster_temp)
deleteDir(sub_repertory_vector_temp)
print(endC)
print(bold + green + "## END : MNH CREATION" + endC)
print(endC)
# Mise à jour du Log
ending_event = "createMnh() : MNH creation ending : "
timeLine(path_time_log,ending_event)
return
def skyViewFactor(grid_input,
grid_output,
mns_input,
classif_input,
class_build_list,
dim_grid_x,
dim_grid_y,
svf_radius,
svf_method,
svf_dlevel,
svf_ndirs,
epsg,
no_data_value,
path_time_log,
format_raster='GTiff',
format_vector='ESRI Shapefile',
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
print(bold + yellow + "Début du calcul de l'indicateur Sky View Factor." +
endC + "\n")
timeLine(path_time_log,
"Début du calcul de l'indicateur Sky View Factor : ")
if debug >= 3:
print(bold + green + "skyViewFactor() : Variables dans la fonction" +
endC)
print(cyan + "skyViewFactor() : " + endC + "grid_input : " +
str(grid_input) + endC)
print(cyan + "skyViewFactor() : " + endC + "grid_output : " +
str(grid_output) + endC)
print(cyan + "skyViewFactor() : " + endC + "mns_input : " +
str(mns_input) + endC)
print(cyan + "skyViewFactor() : " + endC + "class_build_list : " +
str(class_build_list) + endC)
print(cyan + "skyViewFactor() : " + endC + "classif_input : " +
str(classif_input) + endC)
print(cyan + "skyViewFactor() : " + endC + "dim_grid_x : " +
str(dim_grid_x) + endC)
print(cyan + "skyViewFactor() : " + endC + "dim_grid_y : " +
str(dim_grid_y) + endC)
print(cyan + "skyViewFactor() : " + endC + "svf_radius : " +
str(svf_radius) + endC)
print(cyan + "skyViewFactor() : " + endC + "svf_method : " +
str(svf_method) + endC)
print(cyan + "skyViewFactor() : " + endC + "svf_dlevel : " +
str(svf_dlevel) + endC)
print(cyan + "skyViewFactor() : " + endC + "svf_ndirs : " +
str(svf_ndirs) + endC)
print(cyan + "skyViewFactor() : " + endC + "epsg : " + str(epsg) +
endC)
print(cyan + "skyViewFactor() : " + endC + "no_data_value : " +
str(no_data_value) + endC)
print(cyan + "skyViewFactor() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "skyViewFactor() : " + endC + "format_raster : " +
str(format_raster) + endC)
print(cyan + "skyViewFactor() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "skyViewFactor() : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(cyan + "skyViewFactor() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "skyViewFactor() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "skyViewFactor() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Constantes liées aux fichiers
SKY_VIEW_FIELD = 'SkyView'
BASE_FILE_TILE = 'tile_'
BASE_FILE_POLY = 'poly_'
SUFFIX_VECTOR_BUFF = '_buff'
SUFFIX_VECTOR_TEMP = '_temp'
# Constantes liées à l'arborescence
FOLDER_SHP = 'SHP'
FOLDER_SGRD = 'SGRD'
FOLDER_TIF = 'TIF'
SUB_FOLDER_DEM = 'DEM'
SUB_FOLDER_SVF = 'SVF'
SUB_SUB_FOLDER_BUF = 'BUF'
if not os.path.exists(grid_output) or overwrite:
############################################
### Préparation générale des traitements ###
############################################
if os.path.exists(grid_output):
removeVectorFile(grid_output)
temp_path = os.path.dirname(grid_output) + os.sep + "SkyViewFactor"
sky_view_factor_raster = temp_path + os.sep + "sky_view_factor" + extension_raster
cleanTempData(temp_path)
os.makedirs(temp_path + os.sep + FOLDER_SHP)
os.makedirs(temp_path + os.sep + FOLDER_SGRD + os.sep + SUB_FOLDER_DEM)
os.makedirs(temp_path + os.sep + FOLDER_SGRD + os.sep + SUB_FOLDER_SVF)
os.makedirs(temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_DEM)
os.makedirs(temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF)
os.makedirs(temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF +
os.sep + SUB_SUB_FOLDER_BUF)
# Récupération de la résolution du raster d'entrée
pixel_size_x, pixel_size_y = getPixelWidthXYImage(mns_input)
print(bold + "Taille de pixel du fichier '%s' :" % (mns_input) + endC)
print(" pixel_size_x = " + str(pixel_size_x))
print(" pixel_size_y = " + str(pixel_size_y) + "\n")
###############################################
### Création des fichiers emprise et grille ###
###############################################
print(bold + cyan + "Création des fichiers emprise et grille :" + endC)
timeLine(path_time_log,
" Création des fichiers emprise et grille : ")
emprise_file = temp_path + os.sep + "emprise" + extension_vector
quadrillage_file = temp_path + os.sep + "quadrillage" + extension_vector
# Création du fichier d'emprise
createVectorMask(mns_input, emprise_file, no_data_value, format_vector)
# Création du fichier grille
createGridVector(emprise_file, quadrillage_file, dim_grid_x,
dim_grid_y, None, overwrite, epsg, format_vector)
#############################################################
### Extraction des carreaux de découpage et bufferisation ###
#############################################################
print(bold + cyan + "Extraction des carreaux de découpage :" + endC)
timeLine(path_time_log, " Extraction des carreaux de découpage : ")
split_tile_vector_list = splitVector(quadrillage_file,
temp_path + os.sep + FOLDER_SHP,
"", epsg, format_vector,
extension_vector)
split_tile_vector_buff_list = []
# Boucle sur les fichiers polygones quadrillage
for split_tile_vector in split_tile_vector_list:
repertory_temp_output = os.path.dirname(split_tile_vector)
base_name = os.path.splitext(
os.path.basename(split_tile_vector))[0]
split_tile_buff_vector = repertory_temp_output + os.sep + base_name + SUFFIX_VECTOR_BUFF + extension_vector
split_tile_buff_vector_temp = repertory_temp_output + os.sep + base_name + SUFFIX_VECTOR_BUFF + SUFFIX_VECTOR_TEMP + extension_vector
# Bufferisation
bufferVector(split_tile_vector, split_tile_buff_vector_temp,
svf_radius, "", 1.0, 10, format_vector)
# Re-découpage avec l'emprise si la taille intersecte avec l'emprise
if cutVector(emprise_file, split_tile_buff_vector_temp,
split_tile_buff_vector, overwrite, format_vector):
split_tile_vector_buff_list.append(split_tile_buff_vector)
##########################################################
### Découpage du MNS/MNH à l'emprise de chaque carreau ###
##########################################################
print(bold + cyan + "Découpage du raster en tuiles :" + endC)
timeLine(path_time_log, " Découpage du raster en tuiles : ")
# Boucle sur les fichiers polygones quadrillage bufferisés
for i in range(len(split_tile_vector_list)):
print("Traitement de la tuile " + str(int(i) + 1) +
str(len(split_tile_vector_list)) + "...")
split_tile_vector = split_tile_vector_list[i]
repertory_temp_output = os.path.dirname(split_tile_vector)
base_name = os.path.splitext(
os.path.basename(split_tile_vector))[0]
split_tile_buff_vector = repertory_temp_output + os.sep + base_name + SUFFIX_VECTOR_BUFF + extension_vector
dem_tif_file = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_DEM + os.sep + BASE_FILE_TILE + str(
i) + extension_raster
if os.path.exists(split_tile_buff_vector):
cutImageByVector(split_tile_buff_vector, mns_input,
dem_tif_file, pixel_size_x, pixel_size_y,
no_data_value, epsg, format_raster,
format_vector)
##################################################
### Calcul du SVF pour chaque dalle du MNS/MNH ###
##################################################
print(bold + cyan + "Calcul du SVF pour chaque tuile via SAGA :" +
endC)
timeLine(path_time_log,
" Calcul du SVF pour chaque tuile via SAGA : ")
svf_buf_tif_file_list = []
# Boucle sur les tuiles du raster d'entrée créées par chaque polygone quadrillage
for i in range(len(split_tile_vector_list)):
# Calcul de Sky View Factor par SAGA
dem_tif_file = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_DEM + os.sep + BASE_FILE_TILE + str(
i) + extension_raster
svf_buf_tif_file = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF + os.sep + SUB_SUB_FOLDER_BUF + os.sep + BASE_FILE_TILE + str(
i) + extension_raster
if os.path.exists(dem_tif_file):
computeSkyViewFactor(dem_tif_file, svf_buf_tif_file,
svf_radius, svf_method, svf_dlevel,
svf_ndirs, save_results_intermediate)
svf_buf_tif_file_list.append(svf_buf_tif_file)
###################################################################
### Re-découpage des tuiles du SVF avec les tuilles sans tampon ###
###################################################################
print(bold + cyan +
"Re-découpage des tuiles du SVF avec les tuilles sans tampon :" +
endC)
timeLine(
path_time_log,
" Re-découpage des tuiles du SVF avec les tuilles sans tampon : "
)
folder_output_svf = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF + os.sep
# Boucle sur les tuiles du SVF bufferisées
for i in range(len(split_tile_vector_list)):
print("Traitement de la tuile " + str(int(i) + 1) + "/" +
str(len(split_tile_vector_list)) + "...")
split_tile_vector = split_tile_vector_list[i]
svf_buf_tif_file = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF + os.sep + SUB_SUB_FOLDER_BUF + os.sep + BASE_FILE_TILE + str(
i) + extension_raster
base_name = os.path.splitext(os.path.basename(svf_buf_tif_file))[0]
svf_tif_file = folder_output_svf + os.sep + base_name + extension_raster
if os.path.exists(svf_buf_tif_file):
cutImageByVector(split_tile_vector, svf_buf_tif_file,
svf_tif_file, pixel_size_x, pixel_size_y,
no_data_value, epsg, format_raster,
format_vector)
####################################################################
### Assemblage des tuiles du SVF et calcul de l'indicateur final ###
####################################################################
print(
bold + cyan +
"Assemblage des tuiles du SVF et calcul de l'indicateur final :" +
endC)
timeLine(
path_time_log,
" Assemblage des tuiles du SVF et calcul de l'indicateur final : "
)
classif_input_temp = temp_path + os.sep + FOLDER_TIF + os.sep + "classif_input" + SUFFIX_VECTOR_TEMP + extension_raster
sky_view_factor_temp = temp_path + os.sep + FOLDER_TIF + os.sep + "sky_view_factor" + SUFFIX_VECTOR_TEMP + extension_raster # Issu de l'assemblage des dalles
sky_view_factor_temp_temp = temp_path + os.sep + FOLDER_TIF + os.sep + "sky_view_factor" + SUFFIX_VECTOR_TEMP + SUFFIX_VECTOR_TEMP + extension_raster # Issu du redécoupage pour entrer correctement dans le BandMath
sky_view_factor_temp_temp_temp = temp_path + os.sep + FOLDER_TIF + os.sep + "sky_view_factor" + SUFFIX_VECTOR_TEMP + SUFFIX_VECTOR_TEMP + SUFFIX_VECTOR_TEMP + extension_raster # Issu de la suppression des pixels bâti
# Assemblage des tuiles du SVF créées précédemment pour ne former qu'un seul raster SVF
selectAssembyImagesByHold(
emprise_file, [folder_output_svf], sky_view_factor_temp, False,
False, epsg, False, False, False, False, 1.0, pixel_size_x,
pixel_size_y, no_data_value, "_", 2, 8, "", path_time_log,
"_error", "_merge", "_clean", "_stack", format_raster,
format_vector, extension_raster, extension_vector,
save_results_intermediate, overwrite)
# Suppression des valeurs de SVF pour les bâtiments
cutImageByVector(emprise_file, classif_input, classif_input_temp,
pixel_size_x, pixel_size_y, no_data_value, epsg,
format_raster, format_vector)
cutImageByVector(emprise_file, sky_view_factor_temp,
sky_view_factor_temp_temp, pixel_size_x, pixel_size_y,
no_data_value, epsg, format_raster, format_vector)
expression = ""
for id_class in class_build_list:
expression += "im1b1==%s or " % (str(id_class))
expression = expression[:-4]
command = "otbcli_BandMath -il %s %s -out %s float -exp '%s ? -1 : im2b1'" % (
classif_input_temp, sky_view_factor_temp_temp,
sky_view_factor_temp_temp_temp, expression)
if debug >= 3:
print(command)
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(
cyan + "skyViewFactor() : " + bold + red +
"!!! Une erreur c'est produite au cours de la commande otbcli_BandMath : "
+ command + ". Voir message d'erreur." + endC,
file=sys.stderr)
raise
command = "gdal_translate -a_srs EPSG:%s -a_nodata %s -of %s %s %s" % (
str(epsg), str(no_data_value), format_raster,
sky_view_factor_temp_temp_temp, sky_view_factor_raster)
if debug >= 3:
print(command)
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(
cyan + "skyViewFactor() : " + bold + red +
"!!! Une erreur c'est produite au cours de la commande gdal_translate : "
+ command + ". Voir message d'erreur." + endC,
file=sys.stderr)
raise
# Croisement vecteur-raster pour récupérer la moyenne de SVF par polygone du fichier maillage d'entrée
col_to_delete_list = [
"min", "max", "median", "sum", "std", "unique", "range"
]
statisticsVectorRaster(
sky_view_factor_raster, grid_input, grid_output, 1, False, False,
True, col_to_delete_list, [], {}, path_time_log, True,
format_vector, save_results_intermediate, overwrite
) ## Erreur NaN pour polygones entièrement bâtis (soucis pour la suite ?)
renameFieldsVector(grid_output, ['mean'], [SKY_VIEW_FIELD],
format_vector)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
deleteDir(temp_path)
else:
print(bold + magenta + "Le calcul du Sky View Factor a déjà eu lieu." +
endC + "\n")
print(bold + yellow + "Fin du calcul de l'indicateur Sky View Factor." +
endC + "\n")
timeLine(path_time_log, "Fin du calcul de l'indicateur Sky View Factor : ")
return
def computeRoughness(classif_input,
mnh_input,
vector_grid_input,
vector_grid_output,
class_label_dico,
epsg,
path_time_log,
format_raster='GTiff',
format_vector='ESRI Shapefile',
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
# Constante
FIELD_NAME_HRE = "mean_h"
# Mise à jour du Log
timeLine(
path_time_log,
"Début du calcul de l'indicateur Height of Roughness Elements par OCS et MNT starting : "
)
print(
cyan + "computeRoughness() : " + endC +
"Début du calcul de l'indicateur Height of Roughness Elements par OCS et MNT."
+ endC + "\n")
if debug >= 3:
print(bold + green +
"computeRoughness() : Variables dans la fonction" + endC)
print(cyan + "computeRoughness() : " + endC + "classif_input : " +
str(classif_input) + endC)
print(cyan + "computeRoughness() : " + endC + "mnh_input : " +
str(mnh_input) + endC)
print(cyan + "computeRoughness() : " + endC + "vector_grid_input : " +
str(vector_grid_input) + endC)
print(cyan + "computeRoughness() : " + endC + "vector_grid_output : " +
str(vector_grid_output) + endC)
print(cyan + "computeRoughness() : " + endC + "class_label_dico : " +
str(class_label_dico) + endC)
print(cyan + "computeRoughness() : " + endC + "epsg : " + str(epsg) +
endC)
print(cyan + "computeRoughness() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "computeRoughness() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "computeRoughness() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "computeRoughness() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Test si le vecteur de sortie existe déjà et si il doit être écrasés
check = os.path.isfile(vector_grid_output)
if check and not overwrite: # Si le fichier de sortie existent deja et que overwrite n'est pas activé
print(cyan + "computeRoughness() : " + bold + yellow +
"Le calcul de Roughness par OCS et MNT a déjà eu lieu." + endC +
"\n")
print(cyan + "computeRoughness() : " + bold + yellow +
"Grid vector output : " + vector_grid_output +
" already exists and will not be created again." + endC)
else:
if check:
try:
removeVectorFile(vector_grid_output)
except Exception:
pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée
############################################
### Préparation générale des traitements ###
############################################
# Récuperation de la projection de l'image
epsg_proj = getProjectionImage(classif_input)
if epsg_proj == 0:
epsg_proj = epsg
# Liste des classes
#key_class_label_list = list(class_label_dico.keys())
# Préparation des fichiers temporaires
temp_path = os.path.dirname(vector_grid_output) + os.sep + "TEMP_HRE"
# Nettoyage du repertoire temporaire si il existe
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
os.makedirs(temp_path)
buit_height_temp = temp_path + os.sep + "hauteur_bati_temp" + extension_raster
buit_height = temp_path + os.sep + "hauteur_bati" + extension_raster
##############################
### Calcul de l'indicateur ###
##############################
# Récupération de la hauteur du bati
#code_bati = [c for c,v in class_label_dico.items() if v=="bati"][0]
code_bati = list(class_label_dico.keys())[list(
class_label_dico.values()).index("bati")]
command = "otbcli_BandMath -il %s %s -out %s float -exp 'im1b1==%s ? im2b1 : 0'" % (
classif_input, mnh_input, buit_height_temp, str(code_bati))
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(
cyan + "computeRoughness() : " + bold + red +
"!!! Une erreur c'est produite au cours de la commande otbcli_BandMath : "
+ command + ". Voir message d'erreur." + endC,
file=sys.stderr)
raise
command = "gdal_translate -a_srs EPSG:%s -a_nodata 0 -of %s %s %s" % (
str(epsg_proj), format_raster, buit_height_temp, buit_height)
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(
cyan + "computeRoughness() : " + bold + red +
"!!! Une erreur c'est produite au cours de la comande : gdal_translate : "
+ command + ". Voir message d'erreur." + endC,
file=sys.stderr)
raise
# Récupération de la hauteur moyenne du bati de chaque maille
statisticsVectorRaster(
buit_height, vector_grid_input, vector_grid_output, 1, False,
False, True,
["min", "max", "median", "sum", "std", "unique", "range"], [], {},
path_time_log, True, format_vector, save_results_intermediate,
overwrite)
# Renomer le champ 'mean' en FIELD_NAME_HRE
renameFieldsVector(vector_grid_output, ['mean'], [FIELD_NAME_HRE],
format_vector)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
print(
cyan + "computeRoughness() : " + endC +
"Fin du calcul de l'indicateur Height of Roughness Elements par OCS et MNT."
+ endC + "\n")
timeLine(
path_time_log,
"Fin du calcul de l'indicateur Height of Roughness Elements par OCS et MNT ending : "
)
return
def occupationIndicator(classif_input,
mnh_input,
vector_grid_input,
vector_grid_output,
class_label_dico,
epsg,
path_time_log,
format_raster='GTiff',
format_vector='ESRI Shapefile',
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
# Mise à jour du Log
starting_event = "occupationIndicator() : Calcul de l'indicateur occupation du sol/hauteur de végétation starting : "
timeLine(path_time_log, starting_event)
print(
bold + green +
"Début du calcul de l'indicateur 'occupation du sol/hauteur de végétation'."
+ endC + "\n")
if debug >= 3:
print(bold + green +
"occupationIndicator() : Variables dans la fonction" + endC)
print(cyan + "occupationIndicator() : " + endC + "classif_input : " +
str(classif_input) + endC)
print(cyan + "occupationIndicator() : " + endC + "mnh_input : " +
str(mnh_input) + endC)
print(cyan + "occupationIndicator() : " + endC +
"vector_grid_input : " + str(vector_grid_input) + endC)
print(cyan + "occupationIndicator() : " + endC +
"vector_grid_output : " + str(vector_grid_output) + endC)
print(cyan + "occupationIndicator() : " + endC +
"class_label_dico : " + str(class_label_dico) + endC)
print(cyan + "occupationIndicator() : " + endC + "epsg : " +
str(epsg) + endC)
print(cyan + "occupationIndicator() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "occupationIndicator() : " + endC + "format_raster : " +
str(format_raster) + endC)
print(cyan + "occupationIndicator() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "occupationIndicator() : " + endC +
"extension_raster : " + str(extension_raster) + endC)
print(cyan + "occupationIndicator() : " + endC +
"extension_vector : " + str(extension_vector) + endC)
print(cyan + "occupationIndicator() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "occupationIndicator() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Constante
FIELD_OCS_NAME = 'class_OCS'
FIELD_OCS_TYPE = ogr.OFTInteger
FIELD_MAJORITY_NAME = 'majority'
# Test si le vecteur de sortie existe déjà et si il doit être écrasés
check = os.path.isfile(vector_grid_output)
if check and not overwrite: # Si le fichier de sortie existent deja et que overwrite n'est pas activé
print(
bold + yellow +
"Le calcul de l'indicateur occupation du sol/hauteur de végétation a déjà eu lieu. \n"
+ endC)
print(bold + yellow + "Grid vector output : " + vector_grid_output +
" already exists and will not be created again." + endC)
else:
if check:
try:
removeVectorFile(vector_grid_output)
except Exception:
pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée
############################################
### Préparation générale des traitements ###
############################################
# Récuperation de la projection de l'image
epsg_proj = getProjectionImage(classif_input)
if epsg_proj == 0:
epsg_proj = epsg
# Liste des classes
key_class_label_list = list(class_label_dico.keys())
# Préparation des fichiers temporaires
temp_path = os.path.dirname(vector_grid_output) + os.sep + "TEMP_OCS"
# Nettoyage du repertoire temporaire si il existe
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
os.makedirs(temp_path)
tempOCS = temp_path + os.sep + "occupation_du_sol" + extension_vector
tempHveg = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation" + extension_vector
temp_class0 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class0" + extension_vector
temp_class1 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class1" + extension_vector
temp_class2 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class2" + extension_vector
temp_class3 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class3" + extension_vector
temp_class4 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class4" + extension_vector
vegetation_height_temp = temp_path + os.sep + "hauteur_vegetation_temp" + extension_raster
vegetation_height = temp_path + os.sep + "hauteur_vegetation" + extension_raster
##############################
### Calcul de l'indicateur ###
##############################
# Récupération de l'occupation du sol de chaque maille
statisticsVectorRaster(classif_input, vector_grid_input, tempOCS, 1,
True, True, False, [], [], class_label_dico,
path_time_log, True, format_vector,
save_results_intermediate, overwrite)
# Récupération de la hauteur moyenne et la hauteur max de la végétation de chaque maille
command = "otbcli_BandMath -il %s %s -out %s float -exp 'im1b1==%s ? im2b1 : 0'" % (
classif_input, mnh_input, vegetation_height_temp,
str(key_class_label_list[4]))
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(
cyan + "occupationIndicator() : " + bold + red +
"!!! Une erreur c'est produite au cours de la commande otbcli_BandMath : "
+ command + ". Voir message d'erreur." + endC,
file=sys.stderr)
raise
command = "gdal_translate -a_srs EPSG:%s -a_nodata 0 -of %s %s %s" % (
str(epsg_proj), format_raster, vegetation_height_temp,
vegetation_height)
exit_code = os.system(command)
if exit_code != 0:
print(command)
print(
cyan + "occupationIndicator() : " + bold + red +
"!!! Une erreur c'est produite au cours de la comande : gdal_translate : "
+ command + ". Voir message d'erreur." + endC,
file=sys.stderr)
raise
statisticsVectorRaster(vegetation_height, tempOCS, tempHveg, 1, False,
False, True, [], [], {}, path_time_log, True,
format_vector, save_results_intermediate,
overwrite)
# Définir le nom des champs
temp_class_list = []
list_class_str = ""
for class_str in key_class_label_list:
list_class_str += "%s, " % (str(class_label_dico[class_str]))
built_str = class_label_dico[key_class_label_list[0]]
road_str = class_label_dico[key_class_label_list[1]]
water_str = class_label_dico[key_class_label_list[2]]
baresoil_str = class_label_dico[key_class_label_list[3]]
vegetation_str = class_label_dico[key_class_label_list[4]]
vegetation_height_medium_str = "H_moy_" + vegetation_str[0:3]
vegetation_height_max_str = "H_max_" + vegetation_str[0:3]
if debug >= 3:
print("built_str = " + built_str)
print("road_str = " + road_str)
print("water_str = " + water_str)
print("baresoil_str = " + baresoil_str)
print("vegetation_str = " + vegetation_str)
print("vegetation_height_medium_str = " +
vegetation_height_medium_str)
print("vegetation_height_max_str = " + vegetation_height_max_str)
column = "'ID, majority, minority, %s%s, %s, %s'" % (
list_class_str, vegetation_height_max_str,
vegetation_height_medium_str, FIELD_OCS_NAME)
# Ajout d'un champ renvoyant la classe d'OCS attribué à chaque polygone et renomer le champ 'mean'
renameFieldsVector(tempHveg, ['max'], [vegetation_height_max_str],
format_vector)
renameFieldsVector(tempHveg, ['mean'], [vegetation_height_medium_str],
format_vector)
addNewFieldVector(tempHveg, FIELD_OCS_NAME, FIELD_OCS_TYPE, 0, None,
None, format_vector)
# Attribution de la classe 0 => classe majoritaire de bâti ou route ou eau
#expression = "(" + built_str + " >= " + baresoil_str + " AND " + built_str + " >= " + vegetation_str + ") OR (" + road_str + " >= " + baresoil_str + " AND " + road_str + " >= " + vegetation_str + ") OR (" + water_str + " >= " + baresoil_str + " AND " + water_str + " >= " + vegetation_str + ")"
expression = "(" + FIELD_MAJORITY_NAME + " = '" + built_str + "') OR (" + FIELD_MAJORITY_NAME + " = '" + road_str + "') OR (" + FIELD_MAJORITY_NAME + " = '" + water_str + "')"
if debug >= 3:
print(expression)
ret = filterSelectDataVector(tempHveg, temp_class0, column, expression,
format_vector)
if not ret:
raise NameError(
cyan + "occupationIndicator() : " + bold + red +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (expression) + endC)
updateFieldVector(temp_class0, FIELD_OCS_NAME, 0, format_vector)
temp_class_list.append(temp_class0)
# Attribution de la classe 1 => classe majoritaire de sol nu
#expression = "(" + baresoil_str + " > " + built_str + " AND " + baresoil_str + " > " + road_str + " AND " + baresoil_str + " > " + water_str + " AND " + baresoil_str + " >= " + vegetation_str + ")"
expression = "(" + FIELD_MAJORITY_NAME + " = '" + baresoil_str + "')"
if debug >= 3:
print(expression)
ret = filterSelectDataVector(tempHveg, temp_class1, column, expression,
format_vector)
if not ret:
raise NameError(
cyan + "occupationIndicator() : " + bold + red +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (expression) + endC)
updateFieldVector(temp_class1, FIELD_OCS_NAME, 1, format_vector)
temp_class_list.append(temp_class1)
# Attribution de la classe 2 => classe majoritaire de végétation avec Hauteur inferieur à 1
#expression = "(" + vegetation_str + " > " + built_str + " AND " + vegetation_str + " > " + road_str + " AND " + vegetation_str + " > " + water_str + " AND " + vegetation_str + " > " + baresoil_str + ") AND (" + vegetation_height_medium_str + " < 1)"
expression = "(" + FIELD_MAJORITY_NAME + " = '" + vegetation_str + "') AND (" + vegetation_height_medium_str + " < 1)"
if debug >= 3:
print(expression)
ret = filterSelectDataVector(tempHveg, temp_class2, column, expression,
format_vector)
if not ret:
raise NameError(
cyan + "occupationIndicator() : " + bold + red +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (expression) + endC)
updateFieldVector(temp_class2, FIELD_OCS_NAME, 2, format_vector)
temp_class_list.append(temp_class2)
# Attribution de la classe 3 => classe majoritaire de végétation avec Hauteur entre 1 et 5
#expression = "(" + vegetation_str + " > " + built_str + " AND " + vegetation_str + " > " + road_str + " AND " + vegetation_str + " > " + water_str + " AND " + vegetation_str + " > " + baresoil_str + ") AND (" + vegetation_height_medium_str + " >= 1 AND " + vegetation_height_medium_str + " < 5)"
expression = "(" + FIELD_MAJORITY_NAME + " = '" + vegetation_str + "') AND (" + vegetation_height_medium_str + " >= 1 AND " + vegetation_height_medium_str + " < 5)"
if debug >= 3:
print(expression)
ret = filterSelectDataVector(tempHveg, temp_class3, column, expression,
format_vector)
if not ret:
raise NameError(
cyan + "occupationIndicator() : " + bold + red +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (expression) + endC)
updateFieldVector(temp_class3, FIELD_OCS_NAME, 3, format_vector)
temp_class_list.append(temp_class3)
# Attribution de la classe 4 => classe majoritaire de végétation avec Hauteur > 5
#expression = "(" + vegetation_str + " > " + built_str + " AND " + vegetation_str + " > " + road_str + " AND " + vegetation_str + " > " + water_str + " AND " + vegetation_str + " > " + baresoil_str + ") AND (" + vegetation_height_medium_str + " >= 5)"
expression = "(" + FIELD_MAJORITY_NAME + " = '" + vegetation_str + "') AND (" + vegetation_height_medium_str + " >= 5)"
if debug >= 3:
print(expression)
ret = filterSelectDataVector(tempHveg, temp_class4, column, expression,
format_vector)
if not ret:
raise NameError(
cyan + "occupationIndicator() : " + bold + red +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (expression) + endC)
updateFieldVector(temp_class4, FIELD_OCS_NAME, 4, format_vector)
temp_class_list.append(temp_class4)
fusionVectors(temp_class_list, vector_grid_output, format_vector)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
# Mise à jour du Log
print(
bold + green +
"Fin du calcul de l'indicateur 'occupation du sol/hauteur de végétation'."
+ endC + "\n")
ending_event = "occupationIndicator() : Calcul de l'indicateur occupation du sol/hauteur de végétation ending : "
timeLine(path_time_log, ending_event)
return
def main(gui=False):
# Définition des arguments possibles pour l'appel en ligne de commande
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter,
prog="BuiltDifference",
description="\
Info : Create macro samples. \n\
Objectif : Realiser identifier des differences entre la BT topo partie Batie et un MNS. \n\
Example : python BuiltDifference.py -i /mnt/hgfs/Data_Image_Saturn/Test_Methode_CUB_zone_test_NE_1/CUB_zone_test_NE_1.tif \n\
-imns /mnt/hgfs/Data_Image_Saturn/Test_Methode_CUB_zone_test_NE_1/MNS_CUB_zone_test_NE_1.tif \n\
-imnt /mnt/hgfs/Data_Image_Saturn/Test_Methode_CUB_zone_test_NE_1/MNT_CUB_zone_test_NE_1.tif \n\
-o /mnt/hgfs/Data_Image_Saturn/Test_Methode_CUB_zone_test_NE_1/Result/CUB_zone_test_NE_1_diff.tif \n\
-v /mnt/hgfs/Data_Image_Saturn/Test_Methode_CUB_zone_test_NE_1/Result/CUB_zone_test_NE_1_diff_mns.shp \n\
-ibdl /mnt/hgfs/Data_Image_Saturn/BD/BATI_INDIFFERENCIE_033.shp \n\
/mnt/hgfs/Data_Image_Saturn/BD/BATI_INDUSTRIEL_033.shp \n\
-dep 033 \n\
-tndvi 0.3 -tdiff 8.0 -fdif0 5 -fdif1 10 \n\
-log /mnt/hgfs/Data_Image_Saturn/Test_Methode_CUB_zone_test_NE_1/fichierTestLog.txt"
)
# Paramètres généraux
parser.add_argument('-i',
'--image_input',
default="",
help="Image input to treat",
type=str,
required=True)
parser.add_argument('-imns',
'--image_mns',
default="",
help="Image input of MNS",
type=str,
required=True)
parser.add_argument('-imnt',
'--image_mnt',
default="",
help="Image input of MNT",
type=str,
required=True)
parser.add_argument('-o',
'--image_output',
help="Image output result difference",
type=str,
required=False)
parser.add_argument('-v',
'--vector_output',
help="Vector output result difference",
type=str,
required=False)
parser.add_argument(
'-ibdl',
'--bd_vector_input_list',
default="",
nargs="+",
help="List containt bd vector input concatened to create vector sample",
type=str,
required=True)
parser.add_argument('-field',
'--fileld_bd_raster',
default="HAUTEUR",
help="Filled value used to rasterize shape BD",
type=str,
required=False)
parser.add_argument(
'-zone',
'--zone_buff_dico',
nargs="+",
default=["Bati:BATI_INDIFFERENCIE,0:BATI_INDUSTRIEL,0"],
help=
"Dictionary of zone containt bd and buffer, (format : zone:[BD,sizeBuffer][..]), ex. Bati:BATI_INDIFFERENCIE,0:BATI_INDUSTRIEL,0",
type=str,
required=False)
parser.add_argument(
'-dep',
'--departments_list',
default="",
nargs="+",
help=
"List sources departements selected (add a 0 before dep begining by 0), ex. 001 33.",
type=str,
required=True)
parser.add_argument(
'-simp',
'--simple_param_vector',
default=2.0,
help="Parameter of polygons simplification. By default : 2.0",
type=float,
required=False)
parser.add_argument('-tndvi',
'--threshold_ndvi',
default=0.25,
help="Parameter of threshold ndvi. By default : 0.25",
type=float,
required=False)
parser.add_argument(
'-tdiff',
'--threshold_difference',
default=6.0,
help="Parameter of threshold difference mns. By default : 6.0",
type=float,
required=False)
parser.add_argument(
'-fdif0',
'--filter_difference_0',
default=5,
help=
"Parameter of filter clean 0 value, result difference. By default : 5",
type=int,
required=False)
parser.add_argument(
'-fdif1',
'--filter_difference_1',
default=15,
help=
"Parameter of filter clean 1 value, result difference. By default : 15",
type=int,
required=False)
parser.add_argument(
'-chao',
'--channel_order',
nargs="+",
default=['Red', 'Green', 'Blue', 'NIR'],
help=
"Type of multispectral image : rapideye or spot6 or pleiade. By default : [Red,Green,Blue,NIR]",
type=str,
required=False)
parser.add_argument('-vef',
'--format_vector',
default="ESRI Shapefile",
help="Format of the output file.",
type=str,
required=False)
parser.add_argument(
'-rae',
'--extension_raster',
default=".tif",
help="Option : Extension file for image raster. By default : '.tif'",
type=str,
required=False)
parser.add_argument(
'-vee',
'--extension_vector',
default=".shp",
help="Option : Extension file for vector. By default : '.shp'",
type=str,
required=False)
parser.add_argument('-log',
'--path_time_log',
default="",
help="Name of log",
type=str,
required=False)
parser.add_argument(
'-sav',
'--save_results_inter',
action='store_true',
default=False,
help=
"Save or delete intermediate result after the process. By default, False",
required=False)
parser.add_argument(
'-now',
'--overwrite',
action='store_false',
default=True,
help="Overwrite files with same names. By default, True",
required=False)
parser.add_argument(
'-debug',
'--debug',
default=3,
help="Option : Value of level debug trace, default : 3 ",
type=int,
required=False)
args = displayIHM(gui, parser)
# RECUPERATION DES ARGUMENTS
# Récupération des arguments du parser images d'entrées
if args.image_input != None:
image_input = args.image_input
if not os.path.isfile(image_input):
raise NameError(cyan + "BuiltDifference : " + bold + red +
"File %s not existe!" % (image_input) + endC)
if args.image_mns != None:
image_mns = args.image_mns
if not os.path.isfile(image_mns):
raise NameError(cyan + "BuiltDifference : " + bold + red +
"File %s not existe!" % (image_mns) + endC)
if args.image_mnt != None:
image_mnt = args.image_mnt
if not os.path.isfile(image_mnt):
raise NameError(cyan + "BuiltDifference : " + bold + red +
"File %s not existe!" % (image_mnt) + endC)
# Récupération des vecteurs de bd exogenes
if args.bd_vector_input_list != None:
bd_vector_input_list = args.bd_vector_input_list
# Récupération des arguments du parser images de sorties
if args.image_output != None:
image_output = args.image_output
if args.vector_output != None:
vector_output = args.vector_output
# Récupération des info données
if args.departments_list != None:
departments_list = args.departments_list
if args.fileld_bd_raster != None:
fileld_bd_raster = args.fileld_bd_raster
# creation du dictionaire table macro class contenant la BD et le buffer
if args.zone_buff_dico != None:
zone_buffer_dico = extractDico(args.zone_buff_dico)
# Parametres de filtrage
if args.simple_param_vector != None:
simplifie_param = args.simple_param_vector
if args.threshold_ndvi != None:
threshold_ndvi = args.threshold_ndvi
if args.threshold_difference != None:
threshold_difference = args.threshold_difference
if args.filter_difference_0 != None:
filter_difference_0 = args.filter_difference_0
if args.filter_difference_1 != None:
filter_difference_1 = args.filter_difference_1
# Ordre des canaux de l'image ortho
if args.channel_order != None:
channel_order = args.channel_order
# Récupération du format du fichier de sortie
if args.format_vector != None:
format_vector = args.format_vector
# Paramètre de l'extension des images rasters
if args.extension_raster != None:
extension_raster = args.extension_raster
# Récupération de l'extension des fichiers vecteurs
if args.extension_vector != None:
extension_vector = args.extension_vector
# Récupération du nom du fichier log
if args.path_time_log != None:
path_time_log = args.path_time_log
# Ecrasement des fichiers
if args.save_results_inter != None:
save_results_intermediate = args.save_results_inter
if args.overwrite != None:
overwrite = args.overwrite
# Récupération de l'option niveau de debug
if args.debug != None:
global debug
debug = args.debug
if debug >= 3:
print(bold + green + "Variables dans le parser" + endC)
print(cyan + "BuiltDifference : " + endC + "image_input : " +
str(image_input) + endC)
print(cyan + "BuiltDifference : " + endC + "image_mns : " +
str(image_mns) + endC)
print(cyan + "BuiltDifference : " + endC + "image_mnt : " +
str(image_mnt) + endC)
print(cyan + "BuiltDifference : " + endC + "image_output : " +
str(image_output) + endC)
print(cyan + "BuiltDifference : " + endC + "bd_vector_input_list : " +
str(bd_vector_input_list) + endC)
print(cyan + "BuiltDifference : " + endC + "vector_output : " +
str(vector_output) + endC)
print(cyan + "BuiltDifference : " + endC + "zone_buffer_dico : " +
str(zone_buffer_dico) + endC)
print(cyan + "BuiltDifference : " + endC + "departments_list : " +
str(departments_list) + endC)
print(cyan + "BuiltDifference : " + endC + "fileld_bd_raster : " +
str(fileld_bd_raster) + endC)
print(cyan + "BuiltDifference : " + endC + "simple_param_vector : " +
str(simplifie_param) + endC)
print(cyan + "BuiltDifference : " + endC + "threshold_ndvi : " +
str(threshold_ndvi) + endC)
print(cyan + "BuiltDifference : " + endC + "threshold_difference : " +
str(threshold_difference) + endC)
print(cyan + "BuiltDifference : " + endC + "filter_difference_0 : " +
str(filter_difference_0) + endC)
print(cyan + "BuiltDifference : " + endC + "filter_difference_1 : " +
str(filter_difference_1) + endC)
print(cyan + "BuiltDifference : " + endC + "channel_order : " +
str(channel_order) + endC)
print(cyan + "BuiltDifference : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "BuiltDifference : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(cyan + "BuiltDifference : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "BuiltDifference : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "BuiltDifference : " + endC + "save_results_inter : " +
str(save_results_intermediate) + endC)
print(cyan + "BuiltDifference : " + endC + "overwrite: " +
str(overwrite) + endC)
print(cyan + "BuiltDifference : " + endC + "debug: " + str(debug) +
endC)
# EXECUTION DE LA FONCTION
# Si les dossiers de sortie n'existent pas, on les crées
repertory_output = os.path.dirname(image_output)
if not os.path.isdir(repertory_output):
os.makedirs(repertory_output)
repertory_output = os.path.dirname(vector_output)
if not os.path.isdir(repertory_output):
os.makedirs(repertory_output)
# execution de la fonction pour une image
createDifference(image_input, image_mns, image_mnt, bd_vector_input_list,
zone_buffer_dico, departments_list, image_output,
vector_output, fileld_bd_raster, simplifie_param,
threshold_ndvi, threshold_difference, filter_difference_0,
filter_difference_1, path_time_log, format_vector,
extension_raster, extension_vector,
save_results_intermediate, channel_order, overwrite)
# ajouter les valeurs des hauteurs en champs suplementaire au shape
statisticsVectorRaster(image_output, vector_output, "", 1, False, False,
True, [], [], {}, path_time_log, True,
format_vector, save_results_intermediate, overwrite)
def indicateurSI(urbanatlas_input, ucz_output, emprise_file, mask_file,
enter_with_mask, image_file, mnh_file, built_files_list,
hydrography_file, roads_files_list, rpg_file,
indicators_method, ucz_method, dbms_choice, threshold_ndvi,
threshold_ndvi_water, threshold_ndwi2, threshold_bi_bottom,
threshold_bi_top, path_time_log, temp_directory,
extension_raster, extension_vector):
print(
bold + yellow +
"Début de la préparation au calcul de l'indicateur de pourcentage de surfaces imperméables."
+ endC)
step = " Début de la préparation au calcul de l'indicateur de pourcentage de surfaces imperméables : "
timeLine(path_time_log, step)
grid_ready_cleaned = temp_directory + os.sep + os.path.splitext(
os.path.basename(
urbanatlas_input))[0] + "_cut_cleaned" + extension_vector
permeability = temp_directory + os.sep + "permeability" + extension_raster
logCVR = temp_directory + os.sep + "logCVR.txt"
if indicators_method == "BD_exogenes": # Élaboration de la carte d'imperméabilité pour la 1ère méthode de calcul des indicateurs
neochannels = temp_directory + os.sep + os.path.splitext(
os.path.basename(image_file))[0] + "_NDVI" + extension_raster
hydro_shape = temp_directory + os.sep + "eau" + extension_vector
RPG_shape = temp_directory + os.sep + "RPG" + extension_vector
hydro_mask = temp_directory + os.sep + "hydro_mask" + extension_raster
RPG_mask = temp_directory + os.sep + "RPG_mask" + extension_raster
vegetation_mask = mask_file
if not enter_with_mask:
vegetation_mask = temp_directory + os.sep + "vegetation_mask" + extension_raster
print(bold + cyan + " Création du masque de végétation :" +
endC)
os.system(
"otbcli_BandMath -il %s -out %s uint8 -exp 'im1b1>=%s ? 10 : 1'"
% (neochannels, vegetation_mask,
threshold_ndvi)) # Création du masque de végétation
print(bold + cyan + " Création du masque RPG :" + endC)
os.system(
"otbcli_Rasterization -in %s -out %s uint8 -im %s -background 1 -mode binary -mode.binary.foreground 10"
% (RPG_shape, RPG_mask,
vegetation_mask)) # Création du masque RPG (~ sol nu)
print(bold + cyan + " Création du masque d'eau :" + endC)
os.system(
"otbcli_Rasterization -in %s -out %s uint8 -im %s -background 1 -mode binary -mode.binary.foreground 10"
% (hydro_shape, hydro_mask,
vegetation_mask)) # Création du masque d'eau
print(bold + cyan + " Création de la carte d'imperméabilité :" +
endC)
os.system(
"otbcli_BandMath -il %s %s %s -out %s uint8 -exp 'im1b1+im2b1+im3b1>=10 ? 10 : 1'"
% (vegetation_mask, RPG_mask, hydro_mask,
permeability)) # Création de la carte d'imperméabilité
elif indicators_method == "SI_seuillage": # Élaboration de la carte d'imperméabilité pour la 2ème méthode de calcul des indicateurs
neochannels = temp_directory + os.sep + os.path.splitext(
os.path.basename(
image_file))[0] + "_NDVI_NDWI2_BI" + extension_raster
built_shape = temp_directory + os.sep + "bati" + extension_vector
roads_shape = temp_directory + os.sep + "route" + extension_vector
built_mask = temp_directory + os.sep + "built_mask" + extension_raster
roads_mask = temp_directory + os.sep + "roads_mask" + extension_raster
print(bold + cyan + " Création du masque bâti pour nettoyage :" +
endC)
os.system(
"otbcli_Rasterization -in %s -out %s uint8 -im %s -background 1 -mode binary -mode.binary.foreground 10"
% (built_shape, built_mask,
neochannels)) # Création du masque bâti pour nettoyage
print(bold + cyan + " Création du masque route pour nettoyage :" +
endC)
os.system(
"otbcli_Rasterization -in %s -out %s uint8 -im %s -background 1 -mode binary -mode.binary.foreground 10"
% (roads_shape, roads_mask,
neochannels)) # Création du masque route pour nettoyage
print(bold + cyan + " Création de la carte d'imperméabilité :" +
endC)
expression = "((im1b1>=%s) or (im1b1<%s and im1b2>=%s) or (im1b1>=%s and im1b1<%s and im1b3>=%s and im1b3<%s)) and (im2b1==1 and im3b1==1) ? 10 : 1" % (
threshold_ndvi, threshold_ndvi_water, threshold_ndwi2,
threshold_ndvi_water, threshold_ndvi, threshold_bi_bottom,
threshold_bi_top)
os.system("otbcli_BandMath -il %s %s %s -out %s uint8 -exp '%s'" %
(neochannels, built_mask, roads_mask, permeability,
expression)) # Création de la carte d'imperméabilité
else: # Élaboration de la carte d'imperméabilité pour les méthodes 3 et 4 de calcul des indicateurs (utilisant la classif)
image_cut = temp_directory + os.sep + os.path.splitext(
os.path.basename(image_file))[0] + "_cut" + extension_raster
print(bold + cyan + " Création de la carte d'imperméabilité :" +
endC)
os.system(
"otbcli_BandMath -il %s -out %s uint8 -exp 'im1b1>=12000 ? 10 : 1'"
%
(image_cut, permeability)) # Création de la carte d'imperméabilité
print(
bold + cyan +
" Récupération du pourcentage de surfaces imperméables par polygone du maillage :"
+ endC)
statisticsVectorRaster(
permeability, grid_ready_cleaned, "", 1, True, True, False, [], [], {
1: 'Imperm',
10: 'Perm'
}, path_time_log, True, 'ESRI Shapefile', False, True
) # Récupération du pourcentage de surfaces imperméables par polygone du maillage
time.sleep(
10
) # Pause de 10 secondes pour que le système récupère toute la RAM qui a pu être utilisée pour le CVR
step = " Fin de la préparation au calcul de l'indicateur de pourcentage de surfaces imperméables : "
timeLine(path_time_log, step)
print(
bold + yellow +
"Fin de la préparation au calcul de l'indicateur de pourcentage de surfaces imperméables."
+ endC)
print("\n")
return
def indicateurRug(urbanatlas_input, ucz_output, emprise_file, mask_file,
enter_with_mask, image_file, mnh_file, built_files_list,
hydrography_file, roads_files_list, rpg_file,
indicators_method, ucz_method, dbms_choice, threshold_ndvi,
threshold_ndvi_water, threshold_ndwi2, threshold_bi_bottom,
threshold_bi_top, path_time_log, temp_directory,
extension_raster, extension_vector):
print(
bold + yellow +
"Début de la préparation au calcul de l'indicateur de classe de rugosité."
+ endC)
step = " Début de la préparation au calcul de l'indicateur de classe de rugosité : "
timeLine(path_time_log, step)
grid_ready_cleaned = temp_directory + os.sep + os.path.splitext(
os.path.basename(
urbanatlas_input))[0] + "_cut_cleaned" + extension_vector
long_rugosite = temp_directory + os.sep + "z0" + extension_raster
logCVR = temp_directory + os.sep + "logCVR.txt"
if indicators_method == "Resultats_classif": # Élaboration du raster longueur de rugosité pour la 4ème méthode de calcul des indicateurs
image_cut = temp_directory + os.sep + os.path.splitext(
os.path.basename(image_file))[0] + "_cut" + extension_raster
MNH_cut = temp_directory + os.sep + os.path.splitext(
os.path.basename(mnh_file))[0] + "_cut" + extension_raster
print(bold + cyan + " Calcul de la longueur de rugosité :" + endC)
os.system(
"otbcli_BandMath -il %s %s -out %s -exp 'im1b1==11100 ? (im2b1*0.7)*100 : 0.001'"
% (image_cut, MNH_cut,
long_rugosite)) # Calcul de la longueur de rugosité
else: # Élaboration du raster longueur de rugosité pour les 3 premières méthodes de calcul des indicateurs
permeability = temp_directory + os.sep + "permeability" + extension_raster
built_shape = temp_directory + os.sep + "bati" + extension_vector
built_height = temp_directory + os.sep + "built_height" + extension_raster
print(
bold + cyan +
" Rastérisation du bâti issu de la BD TOPO (avec information de hauteur) :"
+ endC)
os.system(
"otbcli_Rasterization -in %s -out %s -im %s -background 0.001 -mode attribute -mode.attribute.field HAUTEUR"
% (built_shape, built_height, permeability)
) # Rastérisation du bâti issu de la BD TOPO (avec information de hauteur)
print(bold + cyan + " Calcul de la longueur de rugosité :" + endC)
os.system(
"otbcli_BandMath -il %s -out %s -exp '(im1b1*0.7)*100'" %
(built_height, long_rugosite)) # Calcul de la longueur de rugosité
print(
bold + cyan +
" Récupération de la longueur de rugosité moyenne par polygone du maillage :"
+ endC)
statisticsVectorRaster(
long_rugosite, grid_ready_cleaned, "", 1, False, False, True, [], [],
{}, logCVR, True, True
) # Récupération de la longueur de rugosité moyenne (~ hauteur de bâti moyenne) par polygone du maillage
time.sleep(
10
) # Pause de 10 secondes pour que le système récupère toute la RAM qui a pu être utilisée pour le CVR
step = " Fin de la préparation au calcul de l'indicateur de classe de rugosité : "
timeLine(path_time_log, step)
print(
bold + yellow +
"Fin de la préparation au calcul de l'indicateur de classe de rugosité."
+ endC)
print("\n")
return
def indicateurRA(urbanatlas_input, ucz_output, emprise_file, mask_file,
enter_with_mask, image_file, mnh_file, built_files_list,
hydrography_file, roads_files_list, rpg_file,
indicators_method, ucz_method, dbms_choice, threshold_ndvi,
threshold_ndvi_water, threshold_ndwi2, threshold_bi_bottom,
threshold_bi_top, path_time_log, temp_directory,
extension_raster, extension_vector):
print(
bold + yellow +
"Début de la préparation au calcul de l'indicateur de rapport d'aspect."
+ endC)
step = " Début de la préparation au calcul de l'indicateur de rapport d'aspect : "
timeLine(path_time_log, step)
grid_ready_cleaned = temp_directory + os.sep + os.path.splitext(
os.path.basename(
urbanatlas_input))[0] + "_cut_cleaned" + extension_vector
permeability = temp_directory + os.sep + "permeability" + extension_raster
built_shape = temp_directory + os.sep + "bati" + extension_vector
built_RA = temp_directory + os.sep + "built_RA" + extension_raster
logCVR = temp_directory + os.sep + "logCVR.txt"
if indicators_method == "Resultats_classif": # Croisement du bâti vectorisé avec le MNH pour récupérer la hauteur moyenne de chaque bâtiment
MNH_cut = temp_directory + os.sep + os.path.splitext(
os.path.basename(mnh_file))[0] + "_cut" + extension_raster
MNH_centimeters = temp_directory + os.sep + "MNH_centimeters" + extension_raster
print(
bold + cyan +
" Basculement des valeurs du MNH des mètres aux centimètres :" +
endC)
os.system(
"otbcli_BandMath -il %s -out %s uint16 -exp 'im1b1*100'" %
(MNH_cut, MNH_centimeters)
) # Basculement des valeurs du MNH des mètres aux centimètres (pour obtenir un raster codé en entier et non en flottant)
print(
bold + cyan +
" Récupération de l'information de hauteur du bâti à partir du MNH :"
+ endC)
statisticsVectorRaster(
MNH_centimeters, built_shape, "", 1, False, False, True, [], [],
{}, logCVR, True, 'ESRI Shapefile', False, True
) # Récupération de l'information de hauteur du bâti à partir du MNH
time.sleep(
10
) # Pause de 10 secondes pour que le système récupère toute la RAM qui a pu être utilisée pour le CVR
print(bold + cyan + " Rastérisation du bâti :" + endC)
pixel_size_x, pixel_size_y = getPixelWidthXYImage(permeability)
os.system(
"gdal_rasterize -burn 10 -init 1 -tr %s %s %s %s" %
(pixel_size_x, pixel_size_y, built_shape, built_RA)
) # Rastérisation du bâti via GDAL plutôt qu'OTB : mauvaise gestion des valeurs de background pour l'OTB (devient NoData)
print(
bold + cyan +
" Récupération de la surface non-bâtie par polygone du maillage :" +
endC)
statisticsVectorRaster(
built_RA, grid_ready_cleaned, "", 1, True, True, False, [], [], {
1: 'NonBati',
10: 'Bati'
}, path_time_log, True, 'ESRI Shapefile', False,
True) # Récupération de la surface non-bâtie par polygone du maillage
time.sleep(
10
) # Pause de 10 secondes pour que le système récupère toute la RAM qui a pu être utilisée pour le CVR
step = " Fin de la préparation au calcul de l'indicateur de rapport d'aspect : "
timeLine(path_time_log, step)
print(
bold + yellow +
"Fin de la préparation au calcul de l'indicateur de rapport d'aspect."
+ endC)
print("\n")
return
