def SampleLocalExtraction(image_input, sample_points, emprise_local_sample, vector_sample_local_output, name_column, band_name, ram_otb=0, format_vector='ESRI Shapefile', extension_vector=".shp", save_results_intermediate=False):
# Creation de la zone local
empr_xmin, empr_xmax, empr_ymin, empr_ymax = getEmpriseImage(image_input)
createEmpriseShapeReduced(sample_points, empr_xmin, empr_ymin, empr_xmax, empr_ymax, emprise_local_sample, format_vector)
# Extract sample
command = "otbcli_SampleExtraction -in %s -vec %s -outfield prefix -outfield.prefix.name %s -out %s -field %s" %(image_input, emprise_local_sample, band_name, vector_sample_local_output, name_column)
if ram_otb > 0:
command += " -ram %d" %(ram_otb)
print(command)
exitCode = os.system(command)
if exitCode != 0:
raise NameError(cyan + "SampleLocalExtraction() : " + bold + red + "An error occured during otbcli_SampleExtraction command. See error message above." + endC)
# Clean temp file
if not save_results_intermediate :
removeVectorFile(emprise_local_sample)
return
def processTDCfilesSmoothAndFusion(coastline_vectors_input_list, vector_rocky_input, vector_all_output, vector_withrocky_output, generalize_param_method, generalize_param_threshold, name_column_fusion, path_time_log, epsg=2154, format_vector='ESRI Shapefile', extension_vector='.shp', save_results_intermediate=False, overwrite=True):
# Mise à jour du Log
starting_event = "processTDCfilesSmoothAndFusion() : Create final coastline starting : "
timeLine(path_time_log,starting_event)
print(endC)
print(bold + green + "## START : POST TRAITEMENT TDC" + endC)
print(endC)
if debug >= 2:
print(bold + green + "processTDCfilesSmoothAndFusion() : Variables dans la fonction" + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "coastline_vectors_input_list : " + str(coastline_vectors_input_list) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "vector_rocky_input : " + str(vector_rocky_input) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "vector_all_output : " + str(vector_all_output) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "vector_withrocky_output : " + str(vector_withrocky_output) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "generalize_param_method : " + str(generalize_param_method) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "generalize_param_threshold : " + str(generalize_param_threshold) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "name_column_fusion : " + str(name_column_fusion) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "processTDCfilesSmoothAndFusion() : " + endC + "overwrite : " + str(overwrite) + endC)
SUFFIX_SMOOTH = "_smooth"
SUFFIX_TMP = "_tmp"
SUFFIX_SMOOTH = "_smooth"
SUFFIX_FUSION = "_fusion"
repertory_output = os.path.dirname(vector_all_output)
file_name = os.path.splitext(os.path.basename(vector_all_output))[0]
vector_fusion = repertory_output + os.sep + file_name + SUFFIX_FUSION + extension_vector
repertory_temp = repertory_output + os.sep + file_name + SUFFIX_TMP
if not os.path.exists(repertory_temp):
os.makedirs(repertory_temp)
# Vérification de l'existence du vecteur de sortie
check = os.path.isfile(vector_all_output)
# Si oui et si la vérification est activée, passage à l'étape suivante
if check and not overwrite :
print(cyan + "processTDCfilesSmoothAndFusion() : " + bold + green + "Vector general coastline already existe : " + str(vector_all_output) + "." + endC)
# Si non ou si la vérification est désactivée, application des traitements de lissage et de la fusion
else:
# Tentative de suppresion des fichiers
try:
removeVectorFile(vector_all_output)
removeVectorFile(vector_withrocky_output)
except Exception:
# Ignore l'exception levée si le fichier n'existe pas (et ne peut donc pas être supprimé)
pass
# Pour tous les fichiers vecteurs d'entrée appliquer le traitement de lissage par GRASS
param_generalize_dico = {"method":generalize_param_method, "threshold":generalize_param_threshold}
vectors_temp_output_list = []
for input_vector in coastline_vectors_input_list :
vector_name = os.path.splitext(os.path.basename(input_vector))[0]
output_temp_vector = repertory_temp + os.sep + vector_name + SUFFIX_TMP + extension_vector
output_smooth_vector = repertory_temp + os.sep + vector_name + SUFFIX_SMOOTH + extension_vector
vectors_temp_output_list.append(output_temp_vector)
xmin, xmax, ymin, ymax = getEmpriseFile(input_vector, format_vector)
projection = getProjection(input_vector, format_vector)
if projection is None:
projection = epsg
# Init GRASS
if debug >= 3:
print(cyan + "processTDCfilesSmoothAndFusion() : " + bold + green + "Initialisation de GRASS " + endC)
initializeGrass(repertory_temp, xmin, xmax, ymin, ymax, 1, 1, projection)
# Generalize GRASS
if debug >= 3:
print(cyan + "processTDCfilesSmoothAndFusion() : " + bold + green + "Applying smooth GRASS for vector : " + str(input_vector) + endC)
smoothGeomGrass(input_vector, output_smooth_vector, param_generalize_dico, format_vector, overwrite)
geometries2multigeometries(output_smooth_vector, output_temp_vector, name_column_fusion, format_vector)
# Init GRASS
if debug >= 3:
print(cyan + "processTDCfilesSmoothAndFusion() : " + bold + green + "Cloture de GRASS " + endC)
cleanGrass(repertory_temp)
if debug >= 3:
print(cyan + "processTDCfilesSmoothAndFusion() : " + bold + green + "Fusion de tous les vecteurs lissés : " + str(vectors_temp_output_list) + endC)
# Fusion de tous les fichiers vecteurs temp
fusionVectors(vectors_temp_output_list, vector_fusion, format_vector)
# Suppression du champ "cat" introduit par l'application GRASS
deleteFieldsVector(vector_fusion, vector_all_output, ["cat"], format_vector)
# Re-met à jour le champ id avec un increment
updateIndexVector(vector_all_output, "id", format_vector)
# Nettoyage des zones rocheuses sur la ligne de trait de côte
if vector_rocky_input != "" and vector_withrocky_output != "":
if debug >= 3:
print("\n" + cyan + "processTDCfilesSmoothAndFusion() : " + bold + green + "Creation d'un trait de côte generale sans les zones rocheuses : " + str(vector_withrocky_output) + endC)
differenceVector(vector_rocky_input, vector_all_output, vector_withrocky_output, overwrite, format_vector)
# Suppression des fichiers intermédiaires
if not save_results_intermediate :
if debug >= 3:
print(cyan + "processTDCfilesSmoothAndFusion() : " + bold + green + "Suppression des fichiers temporaires " + endC)
if os.path.exists(repertory_temp):
shutil.rmtree(repertory_temp)
removeVectorFile(vector_fusion)
print(endC)
print(bold + green + "## END : POST TRAITEMENT TDC" + endC)
print(endC)
# Mise à jour du Log
ending_event = "processTDCfilesSmoothAndFusion() : Create final coastline ending : "
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 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 classifyVector(vector_input, classif_vector_output, list_feat, expression, input_cfield, output_cfield, path_time_log, format_vector='ESRI Shapefile', extension_vector=".shp", extension_xml = ".xml", extension_model = ".model", save_results_intermediate=False, overwrite=True):
# Constante
SUFFIX_OUT = "_out"
SUFFIX_TRAIN = "_train"
# Mise à jour du Log
starting_event = "classifyVector() : Classification vecteur starting : "
timeLine(path_time_log,starting_event)
print(endC)
print(bold + green + "## START : classifyVector" + endC)
print(endC)
if debug >= 2:
print(bold + green + "classifyVector() : Variables dans la fonction" + endC)
print(cyan + "classifyVector() : " + endC + "vector_input : " + str(vector_input) + endC)
print(cyan + "classifyVector() : " + endC + "classif_vector_output : " + str(classif_vector_output) + endC)
print(cyan + "classifyVector() : " + endC + "list_feat : " + str(list_feat) + endC)
print(cyan + "classifyVector() : " + endC + "input_cfield : " + str(input_cfield) + endC)
print(cyan + "classifyVector() : " + endC + "output_cfield : " + str(output_cfield) + endC)
print(cyan + "classifyVector() : " + endC + "expression : " + str(expression) + endC)
print(cyan + "classifyVector() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "classifyVector() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "classifyVector() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "classifyVector() : " + endC + "extension_xml : " + str(extension_xml) + endC)
print(cyan + "classifyVector() : " + endC + "extension_model : " + str(extension_model) + endC)
print(cyan + "classifyVector() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "classifyVector() : " + endC + "overwrite : " + str(overwrite) + endC)
# Creation des chemins d'enregistrement des calculs:
repertory_output = os.path.dirname(vector_input)
name = os.path.splitext(os.path.basename(vector_input))[0]
layer_name = name
vector_output_train_tmp = repertory_output + os.sep + name + SUFFIX_TRAIN + extension_vector
outstats = repertory_output + os.sep + name + extension_xml
model = repertory_output + os.sep + name + extension_model
# Vérification si le vecteur de sortie est définie
if classif_vector_output == "" :
classif_vector_output = repertory_output + os.sep + name + SUFFIX_OUT + extension_vector
# Vérification de l'existence d'une couche vecteur classée
check = os.path.isfile(classif_vector_output)
# Si oui et si la vérification est activée, passage à l'étape suivante
if check and not overwrite :
print(cyan + "classifyVector() : " + bold + green + "vector already classified" + "." + endC)
# Si non ou si la vérification est désactivée, application du filtre
else:
# Tentative de suppresion du fichier
try:
removeVectorFile(classif_vector_output, format_vector=format_vector)
except Exception:
# Ignore l'exception levée si le fichier n'existe pas (et ne peut donc pas être supprimé)
pass
if debug >= 3:
print(cyan + "classifyVector() : " + bold + green + "Applying classified segmenation", "..." , '\n' + endC)
# Recuperation du driver pour le format shape fichier entrée
driver_input = ogr.GetDriverByName(format_vector)
# Ouverture du fichier shape en lecture
data_source_input = driver_input.Open(vector_input, 1) # 1 means writeable.
if data_source_input is None:
print(cyan + "classifyVector() : " + bold + red + "Impossible d'ouvrir le fichier vecteur : " + vector_input + endC, file=sys.stderr)
sys.exit(1) # exit with an error code
# Recuperer la couche (une couche contient les segments)
layer_input = data_source_input.GetLayer(0)
# Vérification de l'existence de la colonne col (retour = -1 : elle n'existe pas)
layer_definition = layer_input.GetLayerDefn() # GetLayerDefn => returns the field names of the user defined (created) fields
id_field = layer_definition.GetFieldIndex(output_cfield)
if id_field != -1 :
print(cyan + "classifyVector() : " + bold + yellow + "Attention le champs de classification existe déjà" + output_cfield + endC)
layer_input.DeleteField(id_field)
# Fermeture du fichier vector_input
layer_input.SyncToDisk()
data_source_input.Destroy()
# Selection du fichier vecteur d'apprentissage
if overwrite:
overwrite_str = "-overwrite"
command = "ogr2ogr -f '%s' %s %s %s -where \"%s\" " % (format_vector, overwrite_str, vector_output_train_tmp ,vector_input, expression)
if debug >= 2:
print(command)
exit_code = os.system(command)
if exitCode!= 0:
print(command)
raise NameError (cyan + "classifyVector() : " + bold + red + "ogr2ogr. Selection du fichier vecteur d'apprentissage erreur." + endC)
# Les champs utilisés pour la calssification
# Exemple : list_feat = ['meanB0' , 'meanB1' , 'meanB2' , 'meanB3' , 'varB0' , 'varB1' , 'varB2' , 'varB3']
feat = str ("-feat")
feat += " " + str(''.join(list_feat))
# Classification :
# 1) Calculer les statistiques
command = "otbcli_ComputeOGRLayersFeaturesStatistics -inshp %s -outstats %s " %(segmented_input, outstats)
command += "%s" %(feat)
if debug >= 2:
print(command)
exitCode = os.system(command)
if exitCode!= 0:
print(command)
raise NameError (cyan + "classifyVector() : " + bold + red + "otbcli_ComputeOGRLayersFeaturesStatistics. See error message above." + endC)
# 2) Générer le model
command = "otbcli_TrainVectorClassifier -io.vd %s -io.stats %s -io.out %s -cfield %s " %(vector_output_train_tmp, outstats, model, input_cfield)
command += "%s" %(feat)
if debug >= 2:
print(command)
exitCode = os.system(command)
if exitCode!= 0:
print(command)
raise NameError (cyan + "classifyVector() : " + bold + red + "otbcli_TrainVectorClassifier. See error message above." + endC)
# 3) Produire la classifictaion
command = "otbcli_VectorClassifier -in %s -instat %s -model %s -cfield %s -out %s " %(segmented_input, outstats, model, output_cfield, classif_vector_output)
command += "%s" %(feat)
if debug >= 2:
print(command)
exitCode = os.system(command)
if exitCode!= 0:
print(command)
raise NameError (cyan + "classifyVector() : " + bold + red + "otbcli_VectorClassifier. See error message above." + endC)
# Suppression des données intermédiaires
if not save_results_intermediate:
# Supression du fichier temporaire de segmentation
if os.path.isfile(vector_output_train_tmp) :
removeFile(vector_output_train_tmp)
print(endC)
print(bold + green + "## END : classifyVector" + endC)
print(endC)
# Mise à jour du Log
ending_event = "classifyVector() : Classifictaion vector ending : "
timeLine(path_time_log,ending_event)
return
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 classificationLczSql(input_division, input_hre, input_ocs, output_lcz, id_field='id', epsg=2154, format_vector='ESRI Shapefile', postgis_ip_host='localhost', postgis_num_port=5432, postgis_user_name='postgres', postgis_password='******', postgis_database_name='lcz_db', postgis_schema_name='public', postgis_encoding='UTF-8', path_time_log='', save_results_intermediate=False, overwrite=True):
if debug >= 3:
print('\n' + bold + green + "Classification LCZ via SQL - Variables dans la fonction :" + endC)
print(cyan + " classificationLczSql() : " + endC + "input_division : " + str(input_division) + endC)
print(cyan + " classificationLczSql() : " + endC + "input_hre : " + str(input_hre) + endC)
print(cyan + " classificationLczSql() : " + endC + "input_ocs : " + str(input_ocs) + endC)
print(cyan + " classificationLczSql() : " + endC + "output_lcz : " + str(output_lcz) + endC)
print(cyan + " classificationLczSql() : " + endC + "id_field : " + str(id_field) + endC)
print(cyan + " classificationLczSql() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + " classificationLczSql() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + " classificationLczSql() : " + endC + "postgis_ip_host : " + str(postgis_ip_host) + endC)
print(cyan + " classificationLczSql() : " + endC + "postgis_num_port : " + str(postgis_num_port) + endC)
print(cyan + " classificationLczSql() : " + endC + "postgis_user_name : " + str(postgis_user_name) + endC)
print(cyan + " classificationLczSql() : " + endC + "postgis_password : "******" classificationLczSql() : " + endC + "postgis_database_name : " + str(postgis_database_name) + endC)
print(cyan + " classificationLczSql() : " + endC + "postgis_schema_name : " + str(postgis_schema_name) + endC)
print(cyan + " classificationLczSql() : " + endC + "postgis_encoding : " + str(postgis_encoding) + endC)
print(cyan + " classificationLczSql() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + " classificationLczSql() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + " classificationLczSql() : " + endC + "overwrite : " + str(overwrite) + endC + '\n')
# Définition des constantes
SUFFIX_TEMP = '_temp'
# Mise à jour du log
starting_event = "classificationLczSql() : Début du traitement : "
timeLine(path_time_log, starting_event)
print(cyan + "classificationLczSql() : " + bold + green + "DEBUT DES TRAITEMENTS" + endC + '\n')
# Définition des variables
hre_field = 'mean_h'
bur_field = 'built'
ror_field = 'mineral'
bsr_field = 'baresoil'
war_field = 'water'
ver_field = 'veget'
vhr_field = 'veg_h_rate'
lcz_field = 'lcz'
div_table = 'i_div'
hre_table = 'i_hre'
ocs_table = 'i_ocs'
lcz_table = 'o_lcz'
# Nettoyage des traitements précédents
if overwrite:
if debug >= 3:
print(cyan + "classificationLczSql() : " + endC + "Nettoyage des traitements précédents." + endC + '\n')
removeVectorFile(output_lcz)
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)
else:
if os.path.exists(output_lcz):
print(cyan + "classificationLczSql() : " + bold + yellow + "Le fichier de sortie existe déjà et ne sera pas regénéré." + endC + '\n')
raise
pass
####################################################################
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)
div_table = importVectorByOgr2ogr(postgis_database_name, input_division, div_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)
hre_table = importVectorByOgr2ogr(postgis_database_name, input_hre, hre_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)
ocs_table = importVectorByOgr2ogr(postgis_database_name, input_ocs, ocs_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)
query = "DROP TABLE IF EXISTS %s;\n" % lcz_table
query += "CREATE TABLE %s AS\n" % lcz_table
query += " SELECT d.%s AS %s, h.%s AS hre, o.%s AS bur, o.%s AS ror, o.%s AS bsr, o.%s AS war, o.%s AS ver, o.%s AS vhr, d.geom AS geom\n" % (id_field, id_field, hre_field, bur_field, ror_field, bsr_field, war_field, ver_field, vhr_field)
query += " FROM %s AS d, %s AS h, %s AS o\n" % (div_table, hre_table, ocs_table)
query += " WHERE d.%s = h.%s AND d.%s = o.%s;\n" % (id_field, id_field, id_field, id_field)
query += "ALTER TABLE %s ADD COLUMN %s VARCHAR(8);\n" % (lcz_table, lcz_field)
query += "UPDATE %s SET %s = 'urban' WHERE bur > 5;\n" % (lcz_table, lcz_field)
query += "UPDATE %s SET %s = 'natural' WHERE bur <= 5;\n" % (lcz_table, lcz_field)
query += "UPDATE %s SET %s = 'low_ocs' WHERE %s = 'natural' AND (bur + ror + bsr + war + ver) <= 60;\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '1' WHERE %s = 'urban' AND (hre > 25) AND (bur > 40);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '4' WHERE %s = 'urban' AND (hre > 25) AND (bur <= 40);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '2' WHERE %s = 'urban' AND (hre > 10 AND hre <= 25) AND (bur > 40);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '5' WHERE %s = 'urban' AND (hre > 10 AND hre <= 25) AND (bur <= 40);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '7' WHERE %s = 'urban' AND (hre <= 10) AND (bur > 70);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '3' WHERE %s = 'urban' AND (hre <= 10) AND (bur > 40 AND bur <= 70);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '6' WHERE %s = 'urban' AND (hre <= 10) AND (bur > 20 AND bur <= 40) AND (ver > 10);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '8' WHERE %s = 'urban' AND (hre <= 10) AND (bur > 20 AND bur <= 40) AND (ver <= 10);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = '9' WHERE %s = 'urban' AND (hre <= 10) AND (bur <= 20);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = 'A' WHERE %s = 'natural' AND ((ver >= ror) AND (ver >= bsr) AND (ver >= war)) AND (vhr > 50);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = 'B' WHERE %s = 'natural' AND ((ver >= ror) AND (ver >= bsr) AND (ver >= war)) AND (vhr > 25 AND vhr <= 50);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = 'C' WHERE %s = 'natural' AND ((ver >= ror) AND (ver >= bsr) AND (ver >= war)) AND (vhr > 10 AND vhr <= 25);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = 'D' WHERE %s = 'natural' AND ((ver >= ror) AND (ver >= bsr) AND (ver >= war)) AND (vhr <= 10);\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = 'E' WHERE %s = 'natural' AND ((ror >= bsr) AND (ror >= war) AND (ror >= ver));\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = 'F' WHERE %s = 'natural' AND ((bsr >= ror) AND (bsr >= war) AND (bsr >= ver));\n" % (lcz_table, lcz_field, lcz_field)
query += "UPDATE %s SET %s = 'G' WHERE %s = 'natural' AND ((war >= ror) AND (war >= bsr) AND (war >= ver));\n" % (lcz_table, lcz_field, lcz_field)
query += "ALTER TABLE %s ALTER COLUMN %s TYPE INTEGER;\n" % (lcz_table, id_field)
query += "ALTER TABLE %s ALTER COLUMN hre TYPE NUMERIC(6,2);\n" % lcz_table
query += "ALTER TABLE %s ALTER COLUMN bur TYPE NUMERIC(6,2);\n" % lcz_table
query += "ALTER TABLE %s ALTER COLUMN ror TYPE NUMERIC(6,2);\n" % lcz_table
query += "ALTER TABLE %s ALTER COLUMN bsr TYPE NUMERIC(6,2);\n" % lcz_table
query += "ALTER TABLE %s ALTER COLUMN war TYPE NUMERIC(6,2);\n" % lcz_table
query += "ALTER TABLE %s ALTER COLUMN ver TYPE NUMERIC(6,2);\n" % lcz_table
query += "ALTER TABLE %s ALTER COLUMN vhr TYPE NUMERIC(6,2);\n" % lcz_table
if debug >= 3:
print('\n' + query)
executeQuery(connection, query)
closeConnection(connection)
exportVectorByOgr2ogr(postgis_database_name, output_lcz, lcz_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)
####################################################################
# Suppression des fichiers temporaires
if not save_results_intermediate:
if debug >= 3:
print('\n' + cyan + "classificationLczSql() : " + endC + "Suppression des fichiers temporaires." + endC + '\n')
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 + "classificationLczSql() : " + bold + green + "FIN DES TRAITEMENTS" + endC + '\n')
# Mise à jour du log
ending_event = "classificationLczSql() : Fin du traitement : "
timeLine(path_time_log, ending_event)
return 0
def vectorsPreparation(emprise_file, classif_input, grid_input, built_input_list, roads_input_list, grid_output, grid_output_cleaned, built_output, roads_output, col_code_ua, col_item_ua, epsg, path_time_log, format_vector='ESRI Shapefile', extension_vector=".shp", save_results_intermediate=False, overwrite=True):
print(bold + yellow + "Début de la préparation des fichiers vecteurs." + endC + "\n")
timeLine(path_time_log, "Début de la préparation des fichiers vecteurs : ")
if debug >= 3 :
print(bold + green + "vectorsPreparation() : Variables dans la fonction" + endC)
print(cyan + "vectorsPreparation() : " + endC + "emprise_file : " + str(emprise_file) + endC)
print(cyan + "vectorsPreparation() : " + endC + "classif_input : " + str(classif_input) + endC)
print(cyan + "vectorsPreparation() : " + endC + "grid_input : " + str(grid_input) + endC)
print(cyan + "vectorsPreparation() : " + endC + "built_input_list : " + str(built_input_list) + endC)
print(cyan + "vectorsPreparation() : " + endC + "roads_input_list : " + str(roads_input_list) + endC)
print(cyan + "vectorsPreparation() : " + endC + "grid_output : " + str(grid_output) + endC)
print(cyan + "vectorsPreparation() : " + endC + "grid_output_cleaned : " + str(grid_output_cleaned) + endC)
print(cyan + "vectorsPreparation() : " + endC + "built_output : " + str(built_output) + endC)
print(cyan + "vectorsPreparation() : " + endC + "roads_output : " + str(roads_output) + endC)
print(cyan + "vectorsPreparation() : " + endC + "col_code_ua : " + str(col_code_ua) + endC)
print(cyan + "vectorsPreparation() : " + endC + "col_item_ua : " + str(col_item_ua) + endC)
print(cyan + "vectorsPreparation() : " + endC + "epsg : " + str(epsg))
print(cyan + "vectorsPreparation() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "vectorsPreparation() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "vectorsPreparation() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "vectorsPreparation() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "vectorsPreparation() : " + endC + "overwrite : " + str(overwrite) + endC)
FOLDER_TEMP = 'TEMP'
SUFFIX_VECTOR_REPROJECT = '_reproject'
SUFFIX_VECTOR_INTERSECT = '_intersect'
SUFFIX_VECTOR_MERGE = '_merge'
SUFFIX_VECTOR_SELECT = '_select'
if not os.path.exists(grid_output) or not os.path.exists(built_output) or not os.path.exists(roads_output) or overwrite:
############################################
### Préparation générale des traitements ###
############################################
path_grid_temp = os.path.dirname(grid_output) + os.sep + FOLDER_TEMP
path_built_temp = os.path.dirname(built_output) + os.sep + FOLDER_TEMP
path_roads_temp = os.path.dirname(roads_output) + os.sep + FOLDER_TEMP
if os.path.exists(path_grid_temp):
shutil.rmtree(path_grid_temp)
if os.path.exists(path_built_temp):
shutil.rmtree(path_built_temp)
if os.path.exists(path_roads_temp):
shutil.rmtree(path_roads_temp)
if not os.path.exists(path_grid_temp):
os.mkdir(path_grid_temp)
if not os.path.exists(path_built_temp):
os.mkdir(path_built_temp)
if not os.path.exists(path_roads_temp):
os.mkdir(path_roads_temp)
basename_grid = os.path.splitext(os.path.basename(grid_output))[0]
basename_built = os.path.splitext(os.path.basename(built_output))[0]
basename_roads = os.path.splitext(os.path.basename(roads_output))[0]
# Variables pour ajout colonne ID
field_name = 'ID' # Attention ! Nom fixé en dur dans les scripts indicateurs, pas dans le script final
field_type = ogr.OFTInteger
##############################################
### Traitements sur le vecteur Urban Atlas ###
##############################################
if not os.path.exists(grid_output) or overwrite :
if os.path.exists(grid_output):
removeVectorFile(grid_output)
if os.path.exists(grid_output_cleaned):
removeVectorFile(grid_output_cleaned)
# MAJ projection
grid_reproject = path_grid_temp + os.sep + basename_grid + SUFFIX_VECTOR_REPROJECT + extension_vector
updateProjection(grid_input, grid_reproject, projection=epsg)
# Découpage du fichier Urban Atlas d'entrée à l'emprise de la zone d'étude
grid_output_temp = os.path.splitext(grid_output)[0] + "_temp" + extension_vector
cutVector(emprise_file, grid_reproject, grid_output_temp, overwrite, format_vector)
# Suppression des très petits polygones qui introduisent des valeurs NaN
pixel_size = getPixelSizeImage(classif_input)
min_size_area = pixel_size * 2
cleanMiniAreaPolygons(grid_output_temp, grid_output, min_size_area, '', format_vector)
if not save_results_intermediate:
if os.path.exists(grid_output_temp):
removeVectorFile(grid_output_temp, format_vector)
# Ajout d'un champ ID
addNewFieldVector(grid_output, field_name, field_type, 0, None, None, format_vector)
updateIndexVector(grid_output, field_name, format_vector)
# Suppression des polygones eau et routes (uniquement pour le calcul des indicateurs)
column = "'%s, %s, %s'" % (field_name, col_code_ua, col_item_ua)
expression = "%s NOT IN ('12210', '12220', '12230', '50000')" % (col_code_ua)
ret = filterSelectDataVector(grid_output, grid_output_cleaned, column, expression, format_vector)
if not ret :
raise NameError (cyan + "vectorsPreparation : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" %(expression) + endC)
#########################################
### Traitements sur les vecteurs bâti ###
#########################################
if not os.path.exists(built_output) or overwrite :
if os.path.exists(built_output):
removeVectorFile(built_output)
# MAJ projection
built_reproject_list=[]
for built_input in built_input_list:
built_reproject = path_built_temp + os.sep + os.path.splitext(os.path.basename(built_input))[0] + SUFFIX_VECTOR_REPROJECT + extension_vector
updateProjection(built_input, built_reproject, projection=epsg)
built_reproject_list.append(built_reproject)
# Sélection des entités bâti dans l'emprise de l'étude
built_intersect_list = []
for built_reproject in built_reproject_list:
built_intersect = path_built_temp + os.sep + os.path.splitext(os.path.basename(built_reproject))[0] + SUFFIX_VECTOR_INTERSECT + extension_vector
intersectVector(emprise_file, built_reproject, built_intersect, format_vector)
built_intersect_list.append(built_intersect)
# Fusion des couches bâti de la BD TOPO
built_merge = path_built_temp + os.sep + basename_built + SUFFIX_VECTOR_MERGE + extension_vector
built_select = path_built_temp + os.sep + basename_built + SUFFIX_VECTOR_SELECT + extension_vector
fusionVectors(built_intersect_list, built_merge)
# Suppression des polygones où la hauteur du bâtiment est à 0
column = "HAUTEUR"
expression = "HAUTEUR > 0"
ret = filterSelectDataVector(built_merge, built_select, column, expression, format_vector)
if not ret :
raise NameError (cyan + "vectorsPreparation : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" %(expression) + endC)
# Découpage des bati d'entrée à l'emprise de la zone d'étude
cutVector(emprise_file, built_select, built_output, overwrite, format_vector)
# Ajout d'un champ ID
addNewFieldVector(built_output, field_name, field_type, 0, None, None, format_vector)
updateIndexVector(built_output, field_name, format_vector)
###########################################
### Traitements sur les vecteurs routes ###
###########################################
if not os.path.exists(roads_output) or overwrite :
if os.path.exists(roads_output):
removeVectorFile(roads_output)
# MAJ projection
roads_reproject_list=[]
for roads_input in roads_input_list:
roads_reproject = path_roads_temp + os.sep + os.path.splitext(os.path.basename(roads_input))[0] + SUFFIX_VECTOR_REPROJECT + extension_vector
updateProjection(roads_input, roads_reproject, projection=epsg)
roads_reproject_list.append(roads_reproject)
# Sélection des entités routes dans l'emprise de l'étude
roads_intersect_list = []
for roads_reproject in roads_reproject_list:
roads_intersect = path_roads_temp + os.sep + os.path.splitext(os.path.basename(roads_reproject))[0] + SUFFIX_VECTOR_INTERSECT + extension_vector
intersectVector(emprise_file, roads_reproject, roads_intersect, format_vector)
roads_intersect_list.append(roads_intersect)
# Fusion des couches route de la BD TOPO
roads_merge = path_roads_temp + os.sep + basename_roads + SUFFIX_VECTOR_MERGE + extension_vector
roads_select = path_roads_temp + os.sep + basename_roads + SUFFIX_VECTOR_SELECT + extension_vector
fusionVectors(roads_intersect_list, roads_merge)
# Sélection des entités suivant la nature de la route dans la couche routes de la BD TOPO
column = "NATURE"
expression = "NATURE IN ('Autoroute', 'Bretelle', 'Quasi-autoroute', 'Route 1 chausse', 'Route 2 chausses', 'Route a 1 chaussee', 'Route a 2 chaussees', 'Route à 1 chaussée', 'Route à 2 chaussées')"
ret = filterSelectDataVector (roads_merge, roads_select, column, expression, format_vector)
if not ret :
raise NameError (cyan + "vectorsPreparation : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" %(expression) + endC)
# Découpage des routes d'entrée à l'emprise de la zone d'étude
cutVectorAll(emprise_file, roads_select, roads_output, overwrite, format_vector)
# Ajout d'un champ ID
addNewFieldVector(roads_output, field_name, field_type, 0, None, None, format_vector)
updateIndexVector(roads_output, field_name, format_vector)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
if os.path.exists(path_grid_temp):
shutil.rmtree(path_grid_temp)
if os.path.exists(path_built_temp):
shutil.rmtree(path_built_temp)
if os.path.exists(path_roads_temp):
shutil.rmtree(path_roads_temp)
else:
print(bold + magenta + "La préparation des fichiers vecteurs a déjà eu lieu.\n" + endC)
print(bold + yellow + "Fin de la préparation des fichiers vecteurs.\n" + endC)
timeLine(path_time_log, "Fin de la préparation des fichiers vecteurs : ")
return
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 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 estimateQualityClassification(image_input,
vector_cut_input,
vector_sample_input,
vector_output,
nb_dot,
no_data_value,
column_name_vector,
column_name_ref,
column_name_class,
path_time_log,
epsg=2154,
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 = "estimateQualityClassification() : Masks creation starting : "
timeLine(path_time_log, starting_event)
print(endC)
print(bold + green +
"## START : CREATE PRINT POINTS FILE FROM CLASSIF IMAGE" + endC)
print(endC)
if debug >= 2:
print(bold + green +
"estimateQualityClassification() : Variables dans la fonction" +
endC)
print(cyan + "estimateQualityClassification() : " + endC +
"image_input : " + str(image_input) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"vector_cut_input : " + str(vector_cut_input) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"vector_sample_input : " + str(vector_sample_input) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"vector_output : " + str(vector_output) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"nb_dot : " + str(nb_dot) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"no_data_value : " + str(no_data_value) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"column_name_vector : " + str(column_name_vector) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"column_name_ref : " + str(column_name_ref) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"column_name_class : " + str(column_name_class) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"path_time_log : " + str(path_time_log) + endC)
print(cyan + "estimateQualityClassification() : " + endC + "epsg : " +
str(epsg) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"format_raster : " + str(format_raster) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"format_vector : " + str(format_vector) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"extension_raster : " + str(extension_raster) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"extension_vector : " + str(extension_vector) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "estimateQualityClassification() : " + endC +
"overwrite : " + str(overwrite) + endC)
# ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES
CODAGE = "uint16"
SUFFIX_STUDY = '_study'
SUFFIX_CUT = '_cut'
SUFFIX_TEMP = '_temp'
SUFFIX_SAMPLE = '_sample'
repertory_output = os.path.dirname(vector_output)
base_name = os.path.splitext(os.path.basename(vector_output))[0]
vector_output_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector
raster_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_raster
vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector
raster_cut = repertory_output + os.sep + base_name + SUFFIX_CUT + extension_raster
vector_sample_temp = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + extension_vector
# Mise à jour des noms de champs
input_ref_col = ""
val_ref = 0
if (column_name_vector != "") and (not column_name_vector is None):
input_ref_col = column_name_vector
if (column_name_ref != "") and (not column_name_ref is None):
val_ref_col = column_name_ref
if (column_name_class != "") and (not column_name_class is None):
val_class_col = column_name_class
# ETAPE 1 : DEFINIR UN SHAPE ZONE D'ETUDE
if (not vector_cut_input is None) and (vector_cut_input != "") and (
os.path.isfile(vector_cut_input)):
cutting_action = True
vector_study = vector_cut_input
else:
cutting_action = False
createVectorMask(image_input, vector_study)
# ETAPE 2 : DECOUPAGE DU RASTEUR PAR LE VECTEUR D'EMPRISE SI BESOIN
if cutting_action:
# Identification de la tailles de pixels en x et en y
pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input)
# Si le fichier de sortie existe deja le supprimer
if os.path.exists(raster_cut):
removeFile(raster_cut)
# Commande de découpe
if not cutImageByVector(vector_study, image_input, raster_cut,
pixel_size_x, pixel_size_y, no_data_value, 0,
format_raster, format_vector):
raise NameError(
cyan + "estimateQualityClassification() : " + bold + red +
"Une erreur c'est produite au cours du decoupage de l'image : "
+ image_input + endC)
if debug >= 2:
print(cyan + "estimateQualityClassification() : " + bold + green +
"DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" %
(image_input, vector_study) + endC)
else:
raster_cut = image_input
# ETAPE 3 : CREATION DE LISTE POINTS AVEC DONNEE ISSU D'UN FICHIER RASTER
# Gémotrie de l'image
cols, rows, bands = getGeometryImage(raster_cut)
xmin, xmax, ymin, ymax = getEmpriseImage(raster_cut)
pixel_width, pixel_height = getPixelWidthXYImage(raster_cut)
if debug >= 2:
print("cols : " + str(cols))
print("rows : " + str(rows))
print("bands : " + str(bands))
print("xmin : " + str(xmin))
print("ymin : " + str(ymin))
print("xmax : " + str(xmax))
print("ymax : " + str(ymax))
print("pixel_width : " + str(pixel_width))
print("pixel_height : " + str(pixel_height))
# ETAPE 3-1 : CAS CREATION D'UN FICHIER DE POINTS PAR TIRAGE ALEATOIRE DANS LA MATRICE IMAGE
if (vector_sample_input is None) or (vector_sample_input == ""):
is_sample_file = False
# Les dimensions de l'image
nb_pixels = abs(cols * rows)
# Tirage aléatoire des points
drawn_dot_list = []
while len(drawn_dot_list) < nb_dot:
val = random.randint(0, nb_pixels)
if not val in drawn_dot_list:
drawn_dot_list.append(val)
# Creation d'un dico index valeur du tirage et attibuts pos_x, pos_y et value pixel
points_random_value_dico = {}
points_coordonnees_list = []
for point in drawn_dot_list:
pos_y = point // cols
pos_x = point % cols
coordonnees_list = [pos_x, pos_y]
points_coordonnees_list.append(coordonnees_list)
# Lecture dans le fichier raster des valeurs
values_list = getPixelsValueListImage(raster_cut,
points_coordonnees_list)
print(values_list)
for idx_point in range(len(drawn_dot_list)):
val_class = values_list[idx_point]
coordonnees_list = points_coordonnees_list[idx_point]
pos_x = coordonnees_list[0]
pos_y = coordonnees_list[1]
coor_x = xmin + (pos_x * abs(pixel_width))
coor_y = ymax - (pos_y * abs(pixel_height))
point_attr_dico = {
"Ident": idx_point,
val_ref_col: int(val_ref),
val_class_col: int(val_class)
}
points_random_value_dico[idx_point] = [[coor_x, coor_y],
point_attr_dico]
if debug >= 4:
print("idx_point : " + str(idx_point))
print("pos_x : " + str(pos_x))
print("pos_y : " + str(pos_y))
print("coor_x : " + str(coor_x))
print("coor_y : " + str(coor_y))
print("val_class : " + str(val_class))
print("")
# ETAPE 3-2 : CAS D'UN FICHIER DE POINTS DEJA EXISTANT MISE A JOUR DE LA DONNEE ISSU Du RASTER
else:
# Le fichier de points d'analyses existe
is_sample_file = True
cutVectorAll(vector_study, vector_sample_input, vector_sample_temp,
format_vector)
if input_ref_col != "":
points_coordinates_dico = readVectorFilePoints(
vector_sample_temp, [input_ref_col], format_vector)
else:
points_coordinates_dico = readVectorFilePoints(
vector_sample_temp, [], format_vector)
# Création du dico
points_random_value_dico = {}
points_coordonnees_list = []
for index_key in points_coordinates_dico:
# Recuperer les valeurs des coordonnees
coord_info_list = points_coordinates_dico[index_key]
coor_x = coord_info_list[0]
coor_y = coord_info_list[1]
pos_x = int(round((coor_x - xmin) / abs(pixel_width)))
pos_y = int(round((ymax - coor_y) / abs(pixel_height)))
coordonnees_list = [pos_x, pos_y]
points_coordonnees_list.append(coordonnees_list)
# Lecture dans le fichier raster des valeurs
values_list = getPixelsValueListImage(raster_cut,
points_coordonnees_list)
for index_key in points_coordinates_dico:
# Récuperer les valeurs des coordonnees
coord_info_list = points_coordinates_dico[index_key]
coor_x = coord_info_list[0]
coor_y = coord_info_list[1]
# Récupérer la classe de référence dans le vecteur d'entrée
if input_ref_col != "":
label = coord_info_list[2]
val_ref = label.get(input_ref_col)
# Récupérer la classe issue du raster d'entrée
val_class = values_list[index_key]
# Création du dico contenant identifiant du point, valeur de référence, valeur du raster d'entrée
point_attr_dico = {
"Ident": index_key,
val_ref_col: int(val_ref),
val_class_col: int(val_class)
}
if debug >= 4:
print("point_attr_dico: " + str(point_attr_dico))
points_random_value_dico[index_key] = [[coor_x, coor_y],
point_attr_dico]
# ETAPE 4 : CREATION ET DECOUPAGE DU FICHIER VECTEUR RESULTAT PAR LE SHAPE D'ETUDE
# Creer le fichier de points
if is_sample_file and os.path.exists(vector_sample_temp):
attribute_dico = {val_class_col: ogr.OFTInteger}
# Recopie du fichier
removeVectorFile(vector_output_temp)
copyVectorFile(vector_sample_temp, vector_output_temp)
# Ajout des champs au fichier de sortie
for field_name in attribute_dico:
addNewFieldVector(vector_output_temp, field_name,
attribute_dico[field_name], 0, None, None,
format_vector)
# Préparation des donnees
field_new_values_list = []
for index_key in points_random_value_dico:
point_attr_dico = points_random_value_dico[index_key][1]
point_attr_dico.pop(val_ref_col, None)
field_new_values_list.append(point_attr_dico)
# Ajout des donnees
setAttributeValuesList(vector_output_temp, field_new_values_list,
format_vector)
else:
# Définir les attibuts du fichier résultat
attribute_dico = {
"Ident": ogr.OFTInteger,
val_ref_col: ogr.OFTInteger,
val_class_col: ogr.OFTInteger
}
createPointsFromCoordList(attribute_dico, points_random_value_dico,
vector_output_temp, epsg, format_vector)
# Découpage du fichier de points d'echantillons
cutVectorAll(vector_study, vector_output_temp, vector_output,
format_vector)
# ETAPE 5 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES
# Suppression des données intermédiaires
if not save_results_intermediate:
if cutting_action:
removeFile(raster_cut)
else:
removeVectorFile(vector_study)
removeFile(raster_study)
if is_sample_file:
removeVectorFile(vector_sample_temp)
removeVectorFile(vector_output_temp)
print(endC)
print(bold + green +
"## END : CREATE PRINT POINTS FILE FROM CLASSIF IMAGE" + endC)
print(endC)
# Mise à jour du Log
ending_event = "estimateQualityClassification() : Masks creation ending : "
timeLine(path_time_log, ending_event)
return
def createEmprise(input_dir,
output_file,
is_not_assembled,
is_all_polygons_used,
is_not_date,
is_optimize_emprise,
is_optimize_emprise_nodata,
no_data_value,
size_erode,
path_time_log,
separ_name="_",
pos_date=1,
nb_char_date=8,
separ_date="",
epsg=2154,
format_vector='ESRI Shapefile',
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
# Affichage des paramètres
if debug >= 3:
print(bold + green +
"Variables dans le createEmprise - Variables générales" + endC)
print(cyan + "createEmprise() : " + endC + "input_dir : " +
str(input_dir))
print(cyan + "createEmprise() : " + endC + "output_file : " +
str(output_file))
print(cyan + "createEmprise() : " + endC + "is_not_assembled : " +
str(is_not_assembled))
print(cyan + "createEmprise() : " + endC + "is_all_polygons_used : " +
str(is_all_polygons_used))
print(cyan + "createEmprise() : " + endC + "is_not_date : " +
str(is_not_date))
print(cyan + "createEmprise() : " + endC + "is_optimize_emprise : " +
str(is_optimize_emprise))
print(cyan + "createEmprise() : " + endC +
"is_optimize_emprise_nodata : " +
str(is_optimize_emprise_nodata))
print(cyan + "createEmprise() : " + endC + "no_data_value : " +
str(no_data_value))
print(cyan + "createEmprise() : " + endC + "size_erode : " +
str(size_erode))
print(cyan + "createEmprise() : " + endC + "path_time_log : " +
str(path_time_log))
print(cyan + "createEmprise() : " + endC + "separ_name : " +
str(separ_name))
print(cyan + "createEmprise() : " + endC + "pos_date : " +
str(pos_date))
print(cyan + "createEmprise() : " + endC + "nb_char_date : " +
str(nb_char_date))
print(cyan + "createEmprise() : " + endC + "separ_date : " +
str(separ_date))
print(cyan + "createEmprise() : " + endC + "epsg : " + str(epsg))
print(cyan + "createEmprise() : " + endC + "format_vector : " +
str(format_vector))
print(cyan + "createEmprise() : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(cyan + "createEmprise() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "createEmprise() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate))
print(cyan + "createEmprise() : " + endC + "overwrite : " +
str(overwrite))
# Constantes
EXT_LIST_HDF5 = ['h5', 'H5', 'he5', 'HE5', 'hdf5', 'HDF5']
EXT_LIST = EXT_LIST_HDF5 + [
'tif', 'TIF', 'tiff', 'TIFF', 'ecw', 'ECW', 'jp2', 'JP2', 'dim', 'DIM',
'asc', 'ASC'
]
SUFFIX_DETAILLEE = "_detail"
SUFFIX_MASK_ZERO = "_mask_zeros"
SUFFIX_TMP = "_tmp"
CODAGE_8B = "uint8"
ATTR_NAME_ID = "Id"
ATTR_NAME_NOMIMAGE = "NomImage"
ATTR_NAME_DATEACQUI = "DateAcqui"
ATTR_NAME_HEUREACQUI = "HeureAcqui"
ATTR_NAME_REFDOSSIER = "RefDossier"
# Variables
points_list = []
name_image_list = []
name_rep_list = []
ref_dossier_list = []
date_list = []
heure_list = []
optimize_emprise_nodata_shape_list = []
polygons_attr_coord_dico = {}
pos_date = pos_date - 1
repertory_output = os.path.dirname(output_file)
file_name = os.path.splitext(os.path.basename(output_file))[0]
extension = os.path.splitext(output_file)[1]
file_vector_detail = repertory_output + os.sep + file_name + SUFFIX_DETAILLEE + extension
# Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors passe au masque suivant
check = os.path.isfile(output_file)
if check and not overwrite:
print(
bold + yellow + "createEmprise() : " + endC +
"Le fichier vecteur d'emprise %s existe déjà : pas d'actualisation"
% (output_file) + 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
removeVectorFile(output_file)
removeVectorFile(file_vector_detail)
except Exception:
pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite
# Récuperer tous les sous répertoires
sub_rep_list = getSubRepRecursifList(input_dir)
sub_rep_list.append(input_dir)
# Parcours de chaque dossier image du dossier en entrée
for repertory in sub_rep_list:
if os.path.isdir(repertory):
if debug >= 2:
print(cyan + "createEmprises() : " + endC + bold + green +
"Traitement de : " + endC + repertory)
# Récupération des images du dossier en entrée
imagettes_jp2_tif_ecw_list = []
imagettes_list = os.listdir(repertory)
for elt1 in imagettes_list:
path_image = repertory + os.sep + elt1
if (os.path.isfile(path_image)) and (len(
elt1.rsplit('.', 1)) == 2) and (elt1.rsplit(
'.', 1)[1] in EXT_LIST):
if elt1.rsplit('.', 1)[1] in EXT_LIST_HDF5:
elt1_new = os.path.splitext(
elt1)[0] + extension_raster
path_image_new = repertory + os.sep + elt1_new
h5ToGtiff(path_image, path_image_new)
imagettes_jp2_tif_ecw_list.append(elt1_new)
else:
imagettes_jp2_tif_ecw_list.append(elt1)
# Pour le cas ou le repertoire contient des fichiers images
if not imagettes_jp2_tif_ecw_list == []:
# Cas ou chaque emprise d'image est un polygone
if is_not_assembled or is_optimize_emprise or is_optimize_emprise_nodata:
for imagette in imagettes_jp2_tif_ecw_list:
# Récupération des emprises de l'image
path_image = repertory + os.sep + imagette
path_info_acquisition = repertory
xmin, xmax, ymin, ymax = getEmpriseImage(
path_image)
coord_list = [
xmin, ymax, xmax, ymax, xmax, ymin, xmin, ymin,
xmin, ymax
]
# Saisie des données
points_list.append(coord_list)
# Récupération du nom de l'image pour la création des champs
input_image_name = os.path.splitext(
os.path.basename(path_image))[0]
name_image_list.append(input_image_name)
# Cas optimisation de l'emprise en elevant les nodata
if is_optimize_emprise_nodata:
path_info_acquisition = path_image
optimize_emprise_nodata_shape = repertory_output + os.sep + input_image_name + extension_vector
optimize_emprise_tmp1_shape = repertory_output + os.sep + input_image_name + SUFFIX_TMP + str(
1) + extension_vector
optimize_emprise_tmp2_shape = repertory_output + os.sep + input_image_name + SUFFIX_TMP + str(
2) + extension_vector
optimize_emprise_tmp3_shape = repertory_output + os.sep + input_image_name + SUFFIX_TMP + str(
3) + extension_vector
optimize_emprise_tmp4_shape = repertory_output + os.sep + input_image_name + SUFFIX_TMP + str(
4) + extension_vector
binary_mask_zeros_raster = repertory_output + os.sep + input_image_name + SUFFIX_MASK_ZERO + extension_raster
optimize_emprise_nodata_shape_list.append(
optimize_emprise_nodata_shape)
# Création masque binaire pour séparer les no data des vraies valeurs
no_data_value_img = getNodataValueImage(
path_image)
if no_data_value_img == None:
no_data_value_img = no_data_value
createBinaryMaskMultiBand(
path_image, binary_mask_zeros_raster,
no_data_value_img, CODAGE_8B)
# Vectorisation du masque binaire true data/false data -> polygone avec uniquement les vraies valeurs
if os.path.exists(
optimize_emprise_nodata_shape):
removeVectorFile(
optimize_emprise_nodata_shape)
polygonizeRaster(binary_mask_zeros_raster,
optimize_emprise_tmp1_shape,
input_image_name,
ATTR_NAME_ID, format_vector)
# Nettoyage des polygones parasites pour ne garder que le polygone pricipale si l'option "all" n'est pas demandée
if not is_all_polygons_used:
geometry_list = getGeomPolygons(
optimize_emprise_tmp1_shape, None,
None, format_vector)
geometry_orded_dico = {}
geometry_orded_list = []
for geometry in geometry_list:
area = geometry.GetArea()
geometry_orded_dico[area] = geometry
geometry_orded_list.append(area)
geometry_orded_list.sort()
if len(geometry_orded_list) > 0:
max_area = geometry_orded_list[
len(geometry_orded_list) - 1]
geom_max = geometry_orded_dico[
max_area]
attribute_dico = {
ATTR_NAME_ID: ogr.OFTInteger
}
polygons_attr_geom_dico = {}
polygons_attr_geom_dico[str(1)] = [
geom_max, {
ATTR_NAME_ID: str(1)
}
]
createPolygonsFromGeometryList(
attribute_dico,
polygons_attr_geom_dico,
optimize_emprise_tmp2_shape, epsg,
format_vector)
else:
print(
cyan + "createEmprise() : " +
bold + yellow +
" Attention!!! Fichier non traite (ne contient pas de polygone): "
+ optimize_emprise_tmp1_shape +
endC)
optimize_emprise_tmp2_shape = optimize_emprise_tmp1_shape
else:
optimize_emprise_tmp2_shape = optimize_emprise_tmp1_shape
# Nettoyage des polygones simplification et supression des trous
cleanRingVector(optimize_emprise_tmp2_shape,
optimize_emprise_tmp3_shape,
format_vector)
simplifyVector(optimize_emprise_tmp3_shape,
optimize_emprise_tmp4_shape, 2,
format_vector)
if size_erode != 0.0:
bufferVector(
optimize_emprise_tmp4_shape,
optimize_emprise_nodata_shape,
size_erode * -1, "", 1.0, 10,
format_vector)
else:
copyVectorFile(
optimize_emprise_tmp4_shape,
optimize_emprise_nodata_shape,
format_vector)
# Nettoyage des fichier intermediaires
if not save_results_intermediate:
removeFile(binary_mask_zeros_raster)
removeVectorFile(
optimize_emprise_tmp1_shape)
removeVectorFile(
optimize_emprise_tmp2_shape)
removeVectorFile(
optimize_emprise_tmp3_shape)
removeVectorFile(
optimize_emprise_tmp4_shape)
# Recuperation de la date et l'heure d'acquisition
# Gestion de l'emprise optimisé nodata on utilise le nom de l'image pour la date d'acquisition sion c'est le nom du repertoire
getDataToFiels(
path_info_acquisition, is_not_date,
is_optimize_emprise
or is_optimize_emprise_nodata, separ_name,
pos_date, nb_char_date, separ_date,
points_list, ref_dossier_list, name_rep_list,
date_list, heure_list)
# Cas ou l'on prend l'emprise globale des images un seul plolygone correspondant a l'emprise globale
else:
# Récupération des emprises des images du dossier
liste_x_l = []
liste_y_b = []
liste_x_r = []
liste_y_t = []
for imagette in imagettes_jp2_tif_ecw_list:
path_image = repertory + os.sep + imagette
xmin, xmax, ymin, ymax = getEmpriseImage(
path_image)
liste_x_l.append(xmin)
liste_x_r.append(xmax)
liste_y_b.append(ymin)
liste_y_t.append(ymax)
# Récupération des min et max de la liste des imagettes
# Coin haut gauche
xmin_l_t = str(min(liste_x_l))
# Coin bas gauche
ymin_l_b = str(min(liste_y_b))
xmin_l_b = xmin_l_t
# Coin bas doite
xmax_r_b = str(max(liste_x_r))
# Coin haut droite
ymax_r_t = str(max(liste_y_t))
xmax_r_t = xmax_r_b
ymax_r_b = ymin_l_b
ymin_l_t = ymax_r_t
coord_list = [
xmin_l_t, ymin_l_t, xmin_l_b, ymin_l_b, xmax_r_b,
ymax_r_b, xmax_r_t, ymax_r_t, xmin_l_t, ymin_l_t
]
points_list.append(coord_list)
# Récupération du nom du répertoire pour création des champs
getDataToFiels(repertory, is_not_date,
is_optimize_emprise, separ_name,
pos_date, nb_char_date, separ_date,
points_list, ref_dossier_list,
name_rep_list, date_list, heure_list)
# Préparation des attribute_dico et polygons_attr_coord_dico
if is_not_assembled:
attribute_dico = {
ATTR_NAME_ID: ogr.OFTInteger,
ATTR_NAME_NOMIMAGE: ogr.OFTString,
ATTR_NAME_DATEACQUI: ogr.OFTDate,
ATTR_NAME_HEUREACQUI: ogr.OFTString
}
for i in range(len(points_list)):
polygons_attr_coord_dico[str(i)] = [
points_list[i], {
ATTR_NAME_ID: i + 1,
ATTR_NAME_NOMIMAGE: name_image_list[i],
ATTR_NAME_DATEACQUI: date_list[i],
ATTR_NAME_HEUREACQUI: heure_list[i]
}
]
else:
attribute_dico = {
ATTR_NAME_NOMIMAGE: ogr.OFTString,
ATTR_NAME_REFDOSSIER: ogr.OFTString,
ATTR_NAME_DATEACQUI: ogr.OFTDate,
ATTR_NAME_HEUREACQUI: ogr.OFTString
}
for i in range(len(points_list)):
polygons_attr_coord_dico[str(i)] = [
points_list[i], {
ATTR_NAME_NOMIMAGE: name_rep_list[i],
ATTR_NAME_REFDOSSIER: ref_dossier_list[i],
ATTR_NAME_DATEACQUI: date_list[i],
ATTR_NAME_HEUREACQUI: heure_list[i]
}
]
# Cas optimisation de l'emprise en elevant les nodata
colum = ""
if is_optimize_emprise_nodata:
if is_not_assembled:
file_vector = output_file
else:
file_vector = file_vector_detail
# Fusion des polygones d'emprises images optimisées sans nodata
polygons_attr_geom_dico = {}
i = 0
for shape_file in optimize_emprise_nodata_shape_list:
geom_list = getGeomPolygons(shape_file, ATTR_NAME_ID, 1,
format_vector)
if not is_all_polygons_used:
if geom_list is not None and len(geom_list) > 0:
geom = geom_list[0]
polygons_attr_geom_dico[str(i)] = [
geom, polygons_attr_coord_dico[str(i)][1]
]
else:
j = 1
for geom in geom_list:
polygons_attr_geom_dico[str(i + 1000000 * j)] = [
geom, polygons_attr_coord_dico[str(i)][1]
]
j += 1
i += 1
createPolygonsFromGeometryList(attribute_dico,
polygons_attr_geom_dico,
file_vector, epsg, format_vector)
# Suppression des fichiers intermediaires
if not save_results_intermediate:
for vector_to_del in optimize_emprise_nodata_shape_list:
removeVectorFile(vector_to_del)
else:
# Utilisation de createPolygonsFromCoordList()
if is_optimize_emprise:
file_vector = file_vector_detail
else:
file_vector = output_file
# Creation des polygones a partir de la liste des coordonnées des emprises
createPolygonsFromCoordList(attribute_dico,
polygons_attr_coord_dico, file_vector,
epsg, format_vector)
# Cas fusion des polygones pour avoir une emprise constituée d'un seul polygone
if not is_not_assembled:
if is_optimize_emprise or is_optimize_emprise_nodata or is_all_polygons_used:
column_name = ""
if is_all_polygons_used:
column_name = ATTR_NAME_DATEACQUI
elif is_optimize_emprise or is_optimize_emprise_nodata:
column_name = ATTR_NAME_NOMIMAGE
# Fusion des polygones
if is_all_polygons_used and is_not_date:
fusionNeighbourPolygonsBySameValue(file_vector,
output_file,
column_name,
format_vector)
#dissolveVector(file_vector, output_file, column_name, format_vector)
else:
if not geometries2multigeometries(file_vector, output_file,
column_name,
format_vector):
copyVectorFile(file_vector, output_file, format_vector)
# Suppression des fichiers intermediaires
if not save_results_intermediate:
removeVectorFile(file_vector_detail)
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 sobelToOuvrages(input_im_seuils_dico, output_dir, input_cut_vector, no_data_value, path_time_log, format_raster='GTiff', format_vector="ESRI Shapefile", extension_raster=".tif", extension_vector=".shp", save_results_intermediate=True, overwrite=True):
# Constantes
REPERTORY_TEMP = "temp_sobel"
CODAGE_8B = "uint8"
ID = "id"
# Mise à jour du Log
starting_event = "sobelToOuvrages() : Select Sobel to ouvrages starting : "
timeLine(path_time_log,starting_event)
# Création du répertoire de sortie s'il n'existe pas déjà
if not os.path.exists(output_dir + os.sep + REPERTORY_TEMP):
os.makedirs(output_dir + os.sep + REPERTORY_TEMP)
# Affichage des paramètres
if debug >= 3:
print(bold + green + "Variables dans SobelToOuvrages - Variables générales" + endC)
print(cyan + "sobelToOuvrages() : " + endC + "input_im_seuils_dico : " + str(input_im_seuils_dico) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "output_dir : " + str(output_dir) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "input_cut_vector : " + str(input_cut_vector) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "format_raster : " + str(format_raster) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "extension_raster : " + str(extension_raster) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "sobelToOuvrages() : " + endC + "overwrite : " + str(overwrite) + endC)
sobel_ouvrages_shp_list = []
for elt in input_im_seuils_dico.split():
raw_image = elt.split(":")[0]
sobel_image = elt.split(":")[1].split(",")[0]
for i in range(1,len(elt.split(":")[1].split(","))):
seuil = elt.split(":")[1].split(",")[i]
# Initialisation des noms des fichiers en sortie
image_name = os.path.splitext(os.path.basename(raw_image))[0]
sobel_binary_mask = output_dir + os.sep + REPERTORY_TEMP + os.sep + "bin_mask_sobel_" + image_name + "_" + str(seuil) + extension_raster
sobel_binary_mask_vector_name = "bin_mask_vect_sobel_" + image_name + "_" + str(seuil)
sobel_binary_mask_vector = output_dir + os.sep + REPERTORY_TEMP + os.sep + sobel_binary_mask_vector_name + extension_vector
sobel_binary_mask_vector_cleaned = output_dir + os.sep + REPERTORY_TEMP + os.sep + "bin_mask_vect_sobel_cleaned_" + image_name + "_" + str(seuil) + extension_vector
sobel_decoup = output_dir + os.sep + "sobel_decoup_" + image_name + "_" + str(seuil) + extension_vector
binary_mask_zeros_name = "b_mask_zeros_vect_" + image_name
binary_mask_zeros_raster = output_dir + os.sep + REPERTORY_TEMP + os.sep + "b_mask_zeros_" + image_name + extension_raster
binary_mask_zeros_vector = output_dir + os.sep + REPERTORY_TEMP + os.sep + binary_mask_zeros_name + extension_vector
binary_mask_zeros_vector_simpl = output_dir + os.sep + REPERTORY_TEMP + os.sep + "b_mask_zeros_vect_simpl_" + image_name + extension_vector
true_values_buffneg = output_dir + os.sep + REPERTORY_TEMP + os.sep + "true_values_buffneg_" + image_name + extension_vector
ouvrages_decoup_final = output_dir + os.sep + "ouvrages_sobel_" + image_name + "_" + str(seuil) + extension_vector
# Création du masque binaire
createBinaryMask(sobel_image, sobel_binary_mask, float(seuil), True)
# Découpe du masque binaire par le shapefile de découpe en entrée
cutImageByVector(input_cut_vector, sobel_binary_mask, sobel_decoup, None, None, no_data_value, 0, format_raster, format_vector)
# Vectorisation du masque binaire Sobel découpé
polygonizeRaster(sobel_decoup, sobel_binary_mask_vector, sobel_binary_mask_vector_name)
# Création masque binaire pour séparer les no data des vraies valeurs
nodata_value = getNodataValueImage(raw_image)
if no_data_value == None :
no_data_value = 0
createBinaryMaskMultiBand(raw_image, binary_mask_zeros_raster, no_data_value, CODAGE_8B)
# Vectorisation du masque binaire true data/false data -> polygone avec uniquement les vraies valeurs
if os.path.exists(binary_mask_zeros_vector):
removeVectorFile(binary_mask_zeros_vector, format_vector)
# Polygonisation
polygonizeRaster(binary_mask_zeros_raster, binary_mask_zeros_vector, binary_mask_zeros_name, ID, format_vector)
# Simplification du masque obtenu
simplifyVector(binary_mask_zeros_vector, binary_mask_zeros_vector_simpl, 2, format_vector)
# Buffer négatif sur ce polygone
bufferVector(binary_mask_zeros_vector_simpl, true_values_buffneg, -2, "", 1.0, 10, format_vector)
cleanMiniAreaPolygons(sobel_binary_mask_vector, sobel_binary_mask_vector_cleaned, 15, ID, format_vector)
# Découpe par le buffer négatif autour des true data
cutVectorAll(true_values_buffneg, sobel_binary_mask_vector_cleaned, ouvrages_decoup_final, overwrite, format_vector)
sobel_ouvrages_shp_list.append(ouvrages_decoup_final)
return sobel_ouvrages_shp_list
def populationVulnerability(
input_division,
input_footprint,
input_population,
input_built,
output_vulnerability,
id_div='id',
id_pop='IdINSPIRE',
id_blt='ID',
stake_field='Ind',
health_vuln_field_list=['Ind_0_3', 'Ind_4_5', 'Ind_65_79', 'Ind_80p'],
social_vuln_field_list=['Men_pauv'],
height_field='HAUTEUR',
built_sql_filter="NATURE LIKE 'Indiff%renci%e' AND (USAGE1 LIKE 'Indiff%renci%e' OR USAGE1 LIKE 'R%sidentiel' OR USAGE2 LIKE 'R%sidentiel' OR USAGE2 IS NULL) AND HAUTEUR IS NOT NULL AND ST_Area(geom) >= 20",
epsg=2154,
format_vector='ESRI Shapefile',
postgis_ip_host='localhost',
postgis_num_port=5432,
postgis_user_name='postgres',
postgis_password='******',
postgis_database_name='uhi_vuln',
postgis_schema_name='public',
postgis_encoding='UTF-8',
path_time_log='',
save_results_intermediate=False,
overwrite=True):
if debug >= 3:
print('\n' + bold + green +
"Vulnérabilité des populations - Variables dans la fonction :" +
endC)
print(cyan + " populationVulnerability() : " + endC +
"input_division : " + str(input_division) + endC)
print(cyan + " populationVulnerability() : " + endC +
"input_footprint : " + str(input_footprint) + endC)
print(cyan + " populationVulnerability() : " + endC +
"input_population : " + str(input_population) + endC)
print(cyan + " populationVulnerability() : " + endC +
"input_built : " + str(input_built) + endC)
print(cyan + " populationVulnerability() : " + endC +
"output_vulnerability : " + str(output_vulnerability) + endC)
print(cyan + " populationVulnerability() : " + endC + "id_div : " +
str(id_div) + endC)
print(cyan + " populationVulnerability() : " + endC + "id_pop : " +
str(id_pop) + endC)
print(cyan + " populationVulnerability() : " + endC + "id_blt : " +
str(id_blt) + endC)
print(cyan + " populationVulnerability() : " + endC +
"stake_field : " + str(stake_field) + endC)
print(cyan + " populationVulnerability() : " + endC +
"health_vuln_field_list : " + str(health_vuln_field_list) + endC)
print(cyan + " populationVulnerability() : " + endC +
"social_vuln_field_list : " + str(social_vuln_field_list) + endC)
print(cyan + " populationVulnerability() : " + endC +
"height_field : " + str(height_field) + endC)
print(cyan + " populationVulnerability() : " + endC +
"built_sql_filter : " + str(built_sql_filter) + endC)
print(cyan + " populationVulnerability() : " + endC + "epsg : " +
str(epsg) + endC)
print(cyan + " populationVulnerability() : " + endC +
"format_vector : " + str(format_vector) + endC)
print(cyan + " populationVulnerability() : " + endC +
"postgis_ip_host : " + str(postgis_ip_host) + endC)
print(cyan + " populationVulnerability() : " + endC +
"postgis_num_port : " + str(postgis_num_port) + endC)
print(cyan + " populationVulnerability() : " + endC +
"postgis_user_name : " + str(postgis_user_name) + endC)
print(cyan + " populationVulnerability() : " + endC +
"postgis_password : "******" populationVulnerability() : " + endC +
"postgis_database_name : " + str(postgis_database_name) + endC)
print(cyan + " populationVulnerability() : " + endC +
"postgis_schema_name : " + str(postgis_schema_name) + endC)
print(cyan + " populationVulnerability() : " + endC +
"postgis_encoding : " + str(postgis_encoding) + endC)
print(cyan + " populationVulnerability() : " + endC +
"path_time_log : " + str(path_time_log) + endC)
print(cyan + " populationVulnerability() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + " populationVulnerability() : " + endC +
"overwrite : " + str(overwrite) + endC + '\n')
# Définition des constantes
PREFIX_STAND = 'S_'
STAKE_IND_FIELD = 'enjeu'
HEALTH_VULN_IND_FIELD = 'vuln_san'
SOCIAL_VULN_IND_FIELD = 'vuln_soc'
GLOBAL_VULN_IND_FIELD = 'vuln_glo'
# Mise à jour du log
starting_event = "populationVulnerability() : Début du traitement : "
timeLine(path_time_log, starting_event)
print(cyan + "populationVulnerability() : " + bold + green +
"DEBUT DES TRAITEMENTS" + endC + '\n')
# Définition des variables tables/champs PostGIS
div_table = 'i_division'
ftp_table = 'i_footprint'
pop_table = 'i_population'
blt_table = 'i_built'
vuln_table = 'o_vulnerability'
clean_pop_table = 't_clean_pop'
clean_blt_table = 't_clean_blt'
inter_pop_blt_table = 't_inter_pop_blt'
inter_popblt_div_table = 't_inter_popblt_div'
div_no_pop_table = 't_div_with_no_pop'
built_area_field = 'surf_bati'
floor_area_field = 'surf_habit'
inter_area_field = 'surf_inter'
# Définition de variables diverses
pop_fields_to_treat = [stake_field
] + health_vuln_field_list + social_vuln_field_list
pop_fields_to_keep = [id_pop] + pop_fields_to_treat
blt_fields_to_keep = [id_blt] + [height_field]
pop_fields_to_treat_str = stake_field
for health_vuln_field in health_vuln_field_list:
pop_fields_to_treat_str += ', ' + health_vuln_field
for social_vuln_field in social_vuln_field_list:
pop_fields_to_treat_str += ', ' + social_vuln_field
# Nettoyage des traitements précédents
if overwrite:
if debug >= 3:
print(cyan + "populationVulnerability() : " + endC +
"Nettoyage des traitements précédents." + endC + '\n')
removeVectorFile(output_vulnerability, format_vector=format_vector)
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)
else:
if os.path.exists(output_vulnerability):
print(cyan + "populationVulnerability() : " + bold + yellow +
"Le fichier de sortie existe déjà et ne sera pas regénéré." +
endC + '\n')
raise
pass
####################################################################
#############
# Etape 1/5 # Préparation de la base de données PostGIS
#############
print(
cyan + "populationVulnerability() : " + bold + green +
"ETAPE 1/5 - Début de la préparation de la base de données PostGIS." +
endC + '\n')
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)
div_table = importVectorByOgr2ogr(postgis_database_name,
input_division,
div_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)
ftp_table = importVectorByOgr2ogr(postgis_database_name,
input_footprint,
ftp_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)
pop_table = importVectorByOgr2ogr(postgis_database_name,
input_population,
pop_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)
blt_table = importVectorByOgr2ogr(postgis_database_name,
input_built,
blt_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)
cursor = connection.cursor()
query = "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
div_table, div_table)
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
ftp_table, ftp_table)
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
pop_table, pop_table)
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
blt_table, blt_table)
if debug >= 3:
print(query)
executeQuery(connection, query)
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 1/5 - Fin de la préparation de la base de données PostGIS." +
endC + '\n')
#############
# Etape 2/5 # Préparation des données
#############
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 2/5 - Début de la préparation des données." + endC + '\n')
# Préparation donnée bâti = sélection à la zone d'étude + suppression du bâti non-habitation + MAJ champ hauteur + ajout champ surface habitable
select_query = ""
for blt_field in blt_fields_to_keep:
select_query += "b.%s, " % blt_field
query = "DROP TABLE IF EXISTS %s;\n" % clean_blt_table
query += "CREATE TABLE %s AS\n" % clean_blt_table
query += " SELECT %s, b.geom\n" % select_query[:-2]
query += " FROM (\n"
query += " SELECT *\n"
query += " FROM %s\n" % blt_table
query += " WHERE %s\n" % built_sql_filter
query += " ) AS b, %s AS f\n" % ftp_table
query += " WHERE ST_Intersects(b.geom, f.geom);\n"
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
clean_blt_table, clean_blt_table)
query += "UPDATE %s SET %s = 3 WHERE %s < 3;\n" % (
clean_blt_table, height_field, height_field)
query += "ALTER TABLE %s ADD COLUMN %s NUMERIC(12,6);\n" % (
clean_blt_table, built_area_field)
query += "UPDATE %s SET %s = ST_Area(geom);\n" % (clean_blt_table,
built_area_field)
query += "ALTER TABLE %s ADD COLUMN %s NUMERIC(12,6);\n" % (
clean_blt_table, floor_area_field)
query += "UPDATE %s SET %s = ((%s * %s) / 3);\n" % (
clean_blt_table, floor_area_field, height_field, built_area_field)
if debug >= 3:
print(query)
executeQuery(connection, query)
blt_fields_to_keep.append(built_area_field)
blt_fields_to_keep.append(floor_area_field)
# Préparation donnée population = sélection à la zone d'étude + nettoyage de champs
select_query = ""
for pop_field in pop_fields_to_keep:
select_query += "p.%s, " % pop_field
query = "DROP TABLE IF EXISTS %s;\n" % clean_pop_table
query += "CREATE TABLE %s AS\n" % clean_pop_table
query += " SELECT %s, p.geom\n" % select_query[:-2]
query += " FROM %s AS p, %s AS f\n" % (pop_table, ftp_table)
query += " WHERE ST_Intersects(p.geom, f.geom);\n"
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
clean_pop_table, clean_pop_table)
if debug >= 3:
print(query)
executeQuery(connection, query)
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 2/5 - Fin de la préparation des données." + endC + '\n')
#############
# Etape 3/5 # Intersect de données
#############
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 3/5 - Début de l'intersect de données." + endC + '\n')
# Calcul du prorata de population par bâtiment
select_query = ""
for blt_field in blt_fields_to_keep:
select_query += "b.%s, " % blt_field
for pop_field in pop_fields_to_keep:
select_query += "p.%s, " % pop_field
query = "DROP TABLE IF EXISTS %s;\n" % inter_pop_blt_table
query += "CREATE TABLE %s AS\n" % inter_pop_blt_table
query += " SELECT %s, ST_Intersection(b.geom, p.geom) AS geom\n" % select_query[:
-2]
query += " FROM %s AS b, %s AS p\n" % (clean_blt_table, clean_pop_table)
query += " WHERE ST_Intersects(b.geom, p.geom);\n"
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
inter_pop_blt_table, inter_pop_blt_table)
query += "ALTER TABLE %s ADD COLUMN %s NUMERIC(12,6);\n" % (
inter_pop_blt_table, inter_area_field)
query += "UPDATE %s SET %s = ST_Area(geom);\n" % (inter_pop_blt_table,
inter_area_field)
for pop_field in pop_fields_to_treat:
query += "UPDATE %s SET %s = (%s * (%s / %s));\n" % (
inter_pop_blt_table, pop_field, pop_field, inter_area_field,
built_area_field)
if debug >= 3:
print(query)
executeQuery(connection, query)
# Somme de population par polygone division
select_query = "SUM(i.%s) AS %s, " % (floor_area_field, floor_area_field)
for pop_field in pop_fields_to_treat:
select_query += "SUM(i.%s) AS %s, " % (pop_field, pop_field)
query = "DROP TABLE IF EXISTS %s;\n" % inter_popblt_div_table
query += "CREATE TABLE %s AS\n" % inter_popblt_div_table
query += " SELECT d.%s, %s, d.geom\n" % (id_div, select_query[:-2])
query += " FROM %s AS d, %s AS i\n" % (div_table, inter_pop_blt_table)
query += " WHERE ST_Intersects(d.geom, i.geom)\n"
query += " GROUP BY d.%s, d.geom;\n" % id_div
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
inter_popblt_div_table, inter_popblt_div_table)
if debug >= 3:
print(query)
executeQuery(connection, query)
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 3/5 - Fin de l'intersect de données." + endC + '\n')
#############
# Etape 4/5 # Préparation du fichier final
#############
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 4/5 - Début de la préparation du fichier final." + endC +
'\n')
# Nouvelle table avec les géométries sans données population
query = "DROP TABLE IF EXISTS %s;\n" % div_no_pop_table
query += "CREATE TABLE %s AS\n" % div_no_pop_table
query += " SELECT DISTINCT %s, geom\n" % id_div
query += " FROM %s\n" % div_table
query += " WHERE %s NOT IN\n" % id_div
query += " (SELECT DISTINCT %s\n" % id_div
query += " FROM %s);\n" % inter_popblt_div_table
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
div_no_pop_table, div_no_pop_table)
query += "ALTER TABLE %s ADD COLUMN %s NUMERIC(12,6) DEFAULT 0;\n" % (
div_no_pop_table, floor_area_field)
for pop_field in pop_fields_to_treat:
query += "ALTER TABLE %s ADD COLUMN %s NUMERIC(8,6) DEFAULT 0;\n" % (
div_no_pop_table, pop_field)
if debug >= 3:
print(query)
executeQuery(connection, query)
# Union de tables pour reconstituer la table finale
query = "DROP TABLE IF EXISTS %s;\n" % vuln_table
query += "CREATE TABLE %s AS\n" % vuln_table
query += " SELECT %s, %s, %s, geom\n" % (id_div, floor_area_field,
pop_fields_to_treat_str)
query += " FROM %s\n" % inter_popblt_div_table
query += " UNION\n"
query += " SELECT %s, %s, %s, geom\n" % (id_div, floor_area_field,
pop_fields_to_treat_str)
query += " FROM %s;\n" % div_no_pop_table
query += "CREATE INDEX IF NOT EXISTS %s_geom_gist ON %s USING GIST (geom);\n" % (
vuln_table, vuln_table)
if debug >= 3:
print(query)
executeQuery(connection, query)
# Standardisation des données
for pop_field in pop_fields_to_treat:
pop_stand_field = PREFIX_STAND + pop_field[:8]
cursor.execute("SELECT min(%s) FROM %s;" % (pop_field, vuln_table))
min_value = cursor.fetchone()
cursor.execute("SELECT max(%s) FROM %s;" % (pop_field, vuln_table))
max_value = cursor.fetchone()
pop_stand_calc = "((%s - %s) / (%s - %s))" % (
pop_field, min_value[0], max_value[0], min_value[0])
query = "ALTER TABLE %s ADD COLUMN %s NUMERIC(8,6);\n" % (
vuln_table, pop_stand_field)
query += "UPDATE %s SET %s = %s;\n" % (vuln_table, pop_stand_field,
pop_stand_calc)
if debug >= 3:
print(query)
executeQuery(connection, query)
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 4/5 - préparation du fichier final." + endC + '\n')
#############
# Etape 5/5 # Calcul des indicateurs
#############
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 5/5 - Début du calcul des indicateurs." + endC + '\n')
# Calcul indice enjeu
stake_stand_field = PREFIX_STAND + stake_field[:8]
cursor.execute("SELECT max(%s) FROM %s;" % (stake_stand_field, vuln_table))
max_enjeu = cursor.fetchone()
query = "ALTER TABLE %s ADD COLUMN %s NUMERIC(8,6);\n" % (vuln_table,
STAKE_IND_FIELD)
query += "UPDATE %s SET %s = (%s / %s);\n" % (
vuln_table, STAKE_IND_FIELD, stake_stand_field, max_enjeu[0])
if debug >= 3:
print(query)
executeQuery(connection, query)
# Indice de vulnérabilité sanitaire
health_vuln_pop_sum = ""
for health_vuln_field in health_vuln_field_list:
pop_stand_field = PREFIX_STAND + health_vuln_field[:8]
health_vuln_pop_sum += "%s + " % pop_stand_field
health_vuln_pop_sum = health_vuln_pop_sum[:-3]
cursor.execute("SELECT max(%s) FROM %s;" %
(health_vuln_pop_sum, vuln_table))
max_health_vuln_pop_sum = cursor.fetchone()
query = "ALTER TABLE %s ADD COLUMN %s NUMERIC(8,6);\n" % (
vuln_table, HEALTH_VULN_IND_FIELD)
query += "UPDATE %s SET %s = ((%s) / %s);\n" % (
vuln_table, HEALTH_VULN_IND_FIELD, health_vuln_pop_sum,
max_health_vuln_pop_sum[0])
if debug >= 3:
print(query)
executeQuery(connection, query)
# Indice de vulnérabilité sociale
social_vuln_pop_sum = ""
for social_vuln_field in social_vuln_field_list:
pop_stand_field = PREFIX_STAND + social_vuln_field[:8]
social_vuln_pop_sum += "%s + " % pop_stand_field
social_vuln_pop_sum = social_vuln_pop_sum[:-3]
cursor.execute("SELECT max(%s) FROM %s;" %
(social_vuln_pop_sum, vuln_table))
max_social_vuln_pop_sum = cursor.fetchone()
query = "ALTER TABLE %s ADD COLUMN %s NUMERIC(8,6);\n" % (
vuln_table, SOCIAL_VULN_IND_FIELD)
query += "UPDATE %s SET %s = ((%s) / %s);\n" % (
vuln_table, SOCIAL_VULN_IND_FIELD, social_vuln_pop_sum,
max_social_vuln_pop_sum[0])
if debug >= 3:
print(query)
executeQuery(connection, query)
# Indice de vulnérabilité globale
cursor.execute("SELECT max(%s + %s) FROM %s;" %
(HEALTH_VULN_IND_FIELD, SOCIAL_VULN_IND_FIELD, vuln_table))
max_pop_vuln_glo_sum = cursor.fetchone()
query = "ALTER TABLE %s ADD COLUMN %s NUMERIC(8,6);\n" % (
vuln_table, GLOBAL_VULN_IND_FIELD)
query += "UPDATE %s SET %s = ((%s + %s) / %s);\n" % (
vuln_table, GLOBAL_VULN_IND_FIELD, HEALTH_VULN_IND_FIELD,
SOCIAL_VULN_IND_FIELD, max_pop_vuln_glo_sum[0])
if debug >= 3:
print(query)
executeQuery(connection, query)
print(cyan + "populationVulnerability() : " + bold + green +
"ETAPE 5/5 - Fin du calcul des indicateurs." + endC + '\n')
closeConnection(connection)
exportVectorByOgr2ogr(postgis_database_name,
output_vulnerability,
vuln_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)
####################################################################
# Suppression des fichiers temporaires
if not save_results_intermediate:
if debug >= 3:
print(cyan + "populationVulnerability() : " + endC +
"Suppression des fichiers temporaires." + endC + '\n')
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 + "populationVulnerability() : " + bold + green +
"FIN DES TRAITEMENTS" + endC + '\n')
# Mise à jour du log
ending_event = "populationVulnerability() : Fin du traitement : "
timeLine(path_time_log, ending_event)
return 0
if not enter_with_mask and (indicators_method == "BD_exogenes" or indicators_method == "SI_seuillage"):
print(bold + " Seuil de NDVI pour l'extraction de la végétation : " + endC + str(threshold_ndvi))
if indicators_method == "SI_seuillage":
print(bold + " Seuil de NDVI pour l'extraction de l'eau : " + endC + str(threshold_ndvi_water))
print(bold + " Seuil de NDWI2 pour l'extraction de l'eau : " + endC + str(threshold_ndwi2))
print(bold + " Seuil inférieur du BI pour l'extraction du sol nu : " + endC + str(threshold_bi_bottom))
print(bold + " Seuil supérieur du BI pour l'extraction du sol nu : " + endC + str(threshold_bi_top))
print("\n")
######################################################
### Préparations diverses en amont des traitements ###
######################################################
if os.path.exists(ucz_output):
removeVectorFile(ucz_output)
temp_directory = os.path.dirname(ucz_output) + os.sep + "TEMP"
if os.path.exists(temp_directory):
print(bold + "Des données temporaires existent, veillez à les conserver si vous reprenez un traitement en cours..." + endC)
clean_temp = raw_input(bold + blue + "Nettoyer le dossier temporaire ? (Y/N) :" + endC + " ")
while clean_temp not in ("Y","N"):
print(bold + yellow + "Attention : veuillez répondre par Y ou N." + endC)
clean_temp = raw_input(bold + blue + "Nettoyer le dossier temporaire ? (Y/N) :" + endC + " ")
print("\n")
if clean_temp == "Y":
shutil.rmtree(temp_directory)
if not os.path.exists(temp_directory):
try:
def rastersPreparation(emprise_file, classif_input, mns_input, mnh_input, classif_output, mns_output, mnh_output, 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 de la préparation des fichiers rasters.\n" + endC)
timeLine(path_time_log, "Début de la préparation des fichiers rasters : ")
if debug >= 3 :
print(bold + green + "rastersPreparation() : Variables dans la fonction" + endC)
print(cyan + "rastersPreparation() : " + endC + "emprise_file : " + str(emprise_file) + endC)
print(cyan + "rastersPreparation() : " + endC + "classif_input : " + str(classif_input) + endC)
print(cyan + "rastersPreparation() : " + endC + "mns_input : " + str(mns_input) + endC)
print(cyan + "rastersPreparation() : " + endC + "mnh_input : " + str(mnh_input) + endC)
print(cyan + "rastersPreparation() : " + endC + "classif_output : " + str(classif_output) + endC)
print(cyan + "rastersPreparation() : " + endC + "mns_output : " + str(mns_output) + endC)
print(cyan + "rastersPreparation() : " + endC + "mnh_output : " + str(mnh_output) + endC)
print(cyan + "rastersPreparation() : " + endC + "epsg : " + str(epsg))
print(cyan + "rastersPreparation() : " + endC + "no_data_value : " + str(no_data_value))
print(cyan + "rastersPreparation() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "rastersPreparation() : " + endC + "format_raster : " + str(format_raster) + endC)
print(cyan + "rastersPreparation() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "rastersPreparation() : " + endC + "extension_raster : " + str(extension_raster) + endC)
print(cyan + "rastersPreparation() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "rastersPreparation() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "rastersPreparation() : " + endC + "overwrite : " + str(overwrite) + endC)
SUFFIX_VECTOR_BUFF = '_buff'
if not os.path.exists(classif_output) or not os.path.exists(mns_output) or not os.path.exists(mnh_output) or overwrite:
############################################
### Préparation générale des traitements ###
############################################
if not os.path.exists(os.path.dirname(classif_output)):
os.makedirs(os.path.dirname(classif_output))
if not os.path.exists(os.path.dirname(mns_output)):
os.makedirs(os.path.dirname(mns_output))
if not os.path.exists(os.path.dirname(mnh_output)):
os.makedirs(os.path.dirname(mnh_output))
emprise_buffer = os.path.splitext(emprise_file)[0] + SUFFIX_VECTOR_BUFF + extension_vector
buffer_dist = 10
bufferVector(emprise_file, emprise_buffer, buffer_dist, "", 1.0, 10, format_vector)
###################################
### Traitements sur les rasters ###
###################################
images_input_list = [classif_input, mns_input, mnh_input]
images_output_list = [classif_output, mns_output, mnh_output]
cutRasterImages(images_input_list, emprise_buffer, images_output_list, 0, 0, epsg, no_data_value, "", False, path_time_log, format_raster, format_vector, extension_raster, extension_vector, save_results_intermediate, overwrite)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
if os.path.exists(emprise_buffer):
removeVectorFile(emprise_buffer)
else:
print(bold + magenta + "La préparation des fichiers rasters a déjà eu lieu.\n" + endC)
print(bold + yellow + "Fin de la préparation des fichiers rasters.\n" + endC)
timeLine(path_time_log, "Fin de la préparation des fichiers rasters : ")
return
def heightOfRoughnessElements(grid_input, grid_output, built_input, height_field, id_field, epsg, project_encoding, server_postgis, port_number, user_postgis, password_postgis, database_postgis, schema_postgis, path_time_log, format_vector='ESRI Shapefile', save_results_intermediate=False, overwrite=True):
print(bold + yellow + "Début du calcul de l'indicateur Height of Roughness Elements." + endC + "\n")
timeLine(path_time_log, "Début du calcul de l'indicateur Height of Roughness Elements : ")
if debug >= 3:
print(bold + green + "heightOfRoughnessElements() : Variables dans la fonction" + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "grid_input : " + str(grid_input) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "grid_output : " + str(grid_output) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "built_input : " + str(built_input) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "height_field : " + str(height_field) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "id_field : " + str(id_field) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "project_encoding : " + str(project_encoding) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "server_postgis : " + str(server_postgis) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "port_number : " + str(port_number) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "user_postgis : " + str(user_postgis) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "password_postgis : " + str(password_postgis) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "database_postgis : " + str(database_postgis) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "schema_postgis : " + str(schema_postgis) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "heightOfRoughnessElements() : " + endC + "overwrite : " + str(overwrite) + endC)
print("\n")
if not os.path.exists(grid_output) or overwrite:
############################################
### Préparation générale des traitements ###
############################################
print(bold + cyan + "Préparation au calcul de Height of Roughness Elements :" + endC)
timeLine(path_time_log, " Préparation au calcul de Height of Roughness Elements : ")
if os.path.exists(grid_output):
removeVectorFile(grid_output)
# Création de la base de données PostGIS
# ~ dropDatabase(database_postgis, user_name=user_postgis, password=password_postgis, ip_host=server_postgis, num_port=port_number, schema_name=schema_postgis) # Conflits avec autres indicateurs (Aspect Ratio / Terrain Roughness Class)
createDatabase(database_postgis, user_name=user_postgis, password=password_postgis, ip_host=server_postgis, num_port=port_number, schema_name=schema_postgis)
# Import des fichiers shapes maille et bati dans la base de données PostGIS
table_name_maille = importVectorByOgr2ogr(database_postgis, grid_input, 'hre_maille', user_name=user_postgis, password=password_postgis, ip_host=server_postgis, num_port=str(port_number), schema_name=schema_postgis, epsg=str(epsg), codage=project_encoding)
table_name_bati = importVectorByOgr2ogr(database_postgis, built_input, 'hre_bati', user_name=user_postgis, password=password_postgis, ip_host=server_postgis, num_port=str(port_number), schema_name=schema_postgis, epsg=str(epsg), codage=project_encoding)
# Gestion de l'ID
connection = openConnection(database_postgis, user_name=user_postgis, password=password_postgis, ip_host=server_postgis, num_port=port_number, schema_name=schema_postgis)
attr_names_list = getAttributeNameList(built_input, format_vector=format_vector)
if id_field not in attr_names_list:
id_field = 'ogc_fid'
# ~ id_query = "ALTER TABLE %s ADD COLUMN %s SERIAL PRIMARY KEY" % (table_name_bati, id_field)
# ~ executeQuery(connection, id_query)
###############################################
### Calcul de l'indicateur par requêtes SQL ###
###############################################
print(bold + cyan + "Calcul de Height of Roughness Elements :" + endC)
timeLine(path_time_log, " Calcul de Height of Roughness Elements : ")
# Création des index spatiaux (accélère les requêtes spatiales)
query = """
--CREATE INDEX IF NOT EXISTS maille_geom_gist ON %s USING GIST (geom);
--CREATE INDEX IF NOT EXISTS bati_geom_gist ON %s USING GIST (geom);
""" % (table_name_maille, table_name_bati)
# Intersect entre les tables maille et bâti (pour chaque maille, on récupère le bâti qui intersect)
query += """
DROP TABLE IF EXISTS hre_decoup;
CREATE TABLE hre_decoup AS
SELECT b.%s as ID, b.%s as hauteur, ST_Intersection(b.geom, m.geom) as geom
FROM %s as b, %s as m
WHERE ST_Intersects(b.geom, m.geom)
AND (ST_GeometryType(b.geom) = 'ST_Polygon' OR ST_GeometryType(b.geom) = 'ST_MultiPolygon')
AND (ST_GeometryType(m.geom) = 'ST_Polygon' OR ST_GeometryType(m.geom) = 'ST_MultiPolygon');
CREATE INDEX IF NOT EXISTS decoup_geom_gist ON hre_decoup USING GIST (geom);
""" % (id_field, height_field, table_name_bati, table_name_maille)
# Table intermédiaire de calculs d'indicateurs secondaires
query += """
DROP TABLE IF EXISTS hre_temp;
CREATE TABLE hre_temp AS
SELECT d.ID, st_area(d.geom) as surface, (st_area(d.geom) * d.hauteur) as volume, d.geom as geom
FROM hre_decoup as d;
CREATE INDEX IF NOT EXISTS temp_geom_gist ON hre_temp USING GIST (geom);
"""
# Table intermédiaire de calcul de mean_h seulement pour les mailles intersectant du bâti
query += """
DROP TABLE IF EXISTS hre_maille_bis;
CREATE TABLE hre_maille_bis AS
SELECT m.ID as ID, ((sum(t.volume) / count(t.geom)) / (sum(t.surface) / count(t.geom))) as mean_h, m.geom as geom
FROM %s as m, hre_temp as t
WHERE ST_Intersects(m.geom, t.geom)
AND (ST_GeometryType(m.geom) = 'ST_Polygon' OR ST_GeometryType(m.geom) = 'ST_MultiPolygon')
AND (ST_GeometryType(t.geom) = 'ST_Polygon' OR ST_GeometryType(t.geom) = 'ST_MultiPolygon')
GROUP BY m.ID, m.geom;
CREATE INDEX IF NOT EXISTS maille_bis_geom_gist ON hre_maille_bis USING GIST (geom);
""" % (table_name_maille)
# Table intermédiaire seulement pour les mailles n'intersectant pas de bâti (par défaut, mean_h = 0)
query += """
DROP TABLE IF EXISTS hre_maille_ter;
CREATE TABLE hre_maille_ter AS
SELECT DISTINCT ID as ID, geom as geom
FROM %s
WHERE ID NOT IN
(SELECT DISTINCT ID
FROM hre_maille_bis);
ALTER TABLE hre_maille_ter ADD mean_h DOUBLE PRECISION;
UPDATE hre_maille_ter SET mean_h = 0;
CREATE INDEX IF NOT EXISTS maille_ter_geom_gist ON hre_maille_ter USING GIST (geom);
""" % (table_name_maille)
# Union des 2 tables précédentes pour récupérer l'ensemble des polygones maille de départ
query += """
DROP TABLE IF EXISTS hre_height;
CREATE TABLE hre_height AS
SELECT ID, mean_h, geom
FROM hre_maille_bis
UNION
SELECT ID, mean_h, geom
FROM hre_maille_ter;
ALTER TABLE hre_height ALTER COLUMN ID TYPE INTEGER;
"""
# Exécution de la requête SQL
if debug >= 1:
print(query)
executeQuery(connection, query)
closeConnection(connection)
# Export en shape de la table contenant l'indicateur calculé
exportVectorByOgr2ogr(database_postgis, grid_output, 'hre_height', user_name=user_postgis, password=password_postgis, ip_host=server_postgis, num_port=str(port_number), schema_name=schema_postgis, format_type=format_vector)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
# ~ dropDatabase(database_postgis, user_name=user_postgis, password=password_postgis, ip_host=server_postgis, num_port=port_number, schema_name=schema_postgis) # Conflits avec autres indicateurs (Aspect Ratio / Terrain Roughness Class)
pass
else:
print(bold + magenta + "Le calcul de Height of Roughness Elements a déjà eu lieu." + endC)
print(bold + yellow + "Fin du calcul de l'indicateur Height of Roughness Elements." + endC + "\n")
timeLine(path_time_log, "Fin du calcul de l'indicateur Height of Roughness Elements : ")
return
def polygonMerToTDC(input_im_ndvi_dico, output_dir, input_sea_points, fct_bin_mask_vect, simplif, input_cut_vector, buf_pos, buf_neg, no_data_value, path_time_log, epsg=2154, format_vector="ESRI Shapefile", extension_raster=".tif", extension_vector=".shp", save_results_intermediate=True, overwrite=True):
# Mise à jour du Log
starting_event = "PolygonMerToTDC() : Select PolygonMerToTDC starting : "
timeLine(path_time_log,starting_event)
# Affichage des paramètres
if debug >= 3:
print(bold + green + "Variables dans PolygonMerToTDC - Variables générales" + endC)
print(cyan + "polygonMerToTDC() : " + endC + "input_im_ndvi_dico : " + str(input_im_ndvi_dico) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "output_dir : " + str(output_dir) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "input_sea_points : " + str(input_sea_points) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "fct_bin_mask_vect : " + str(fct_bin_mask_vect) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "simplif : " + str(simplif) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "input_cut_vector : " + str(input_cut_vector) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "buf_pos : " + str(buf_pos) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "buf_neg : " + str(buf_neg) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "no_data_value : " + str(no_data_value) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "extension_raster : " + str(extension_raster) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "polygonMerToTDC() : " + endC + "overwrite : " + str(overwrite) + endC)
# Constantes
REP_TEMP_POLY_MER = "Temp_PolygonMerToTDC_"
CODAGE_8B = "uint8"
# Création du répertoire de sortie s'il n'existe pas déjà
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Pour toutes les images à traiter
for r in range(len(input_im_ndvi_dico.split())):
# L'image à traiter
input_image = input_im_ndvi_dico.split()[r].split(":")[0]
image_name = os.path.splitext(os.path.basename(input_image))[0]
# Création du répertoire temporaire de calcul
repertory_temp = output_dir + os.sep + REP_TEMP_POLY_MER + image_name
if not os.path.exists(repertory_temp):
os.makedirs(repertory_temp)
if not os.path.exists(input_image):
print(cyan + "polygonMerToTDC() : " + bold + red + "L'image en entrée : " + input_image + " n'existe pas. Vérifiez le chemin !" + endC, file=sys.stderr)
sys.exit(1)
src_input_im = gdal.Open(input_image)
if src_input_im is None:
print(cyan + "polygonMerToTDC() : " + bold + red + "Impossible d'ouvrir l'image raster : " + input_image + endC, file=sys.stderr)
sys.exit(1)
try :
srcband = src_input_im.GetRasterBand(2)
except RuntimeError as err:
print(cyan + "polygonMerToTDC() : " + bold + red + "Pas de bande 2 trouvée sur : " + input_image + endC, file=sys.stderr)
e = "OS error: {0}".format(err)
print(e, file=sys.stderr)
sys.exit(1)
# Traiter le cas où pas de NDVI derrière
if ":" not in input_im_ndvi_dico.split()[r]:
print(cyan + "polygonMerToTDC() : " + red + bold + "Aucun masque binaire vectorisé spécifié ! Nécessité d'au moins un par image." + endC, file=sys.stderr)
sys.exit(1)
# Parcours de toutes les images NDVI correspondant à chaque image
for ndvi_mask_vect in input_im_ndvi_dico.split()[r].split(":")[1].split(","):
if debug > 2 :
print(cyan + "polygonMerToTDC() : " + endC + "Traitement de : " + ndvi_mask_vect)
# Initialisation des noms des fichiers de sortie
binary_mask_zeros = repertory_temp + os.sep + "b_mask_zeros_" + os.path.splitext(os.path.basename(input_image))[0] + extension_raster
binary_mask_zeros_vector = "b_mask_zeros_vect_" + os.path.splitext(os.path.basename(input_image))[0]
path_binary_mask_zeros_vector = repertory_temp + os.sep + binary_mask_zeros_vector + extension_vector
true_values_buffneg = repertory_temp + os.sep + "true_values_buffneg_" + os.path.splitext(os.path.basename(input_image))[0] + extension_vector
decoup_buffneg = repertory_temp + os.sep + "decoupe_buffneg_" + os.path.splitext(os.path.basename(input_cut_vector))[0] + extension_vector
if fct_bin_mask_vect :
threshold = os.path.splitext(os.path.basename(ndvi_mask_vect))[0].split("_")[-2] + "_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0].split("_")[-1]
poly_mer_shp = repertory_temp + os.sep + "poly_mer_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector
poly_mer_shp_dilat = repertory_temp + os.sep + "poly_mer_dilat_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector
poly_mer_shp_ferm = repertory_temp + os.sep + "poly_mer_ferm_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector
polyline_mer = repertory_temp + os.sep + "polyline_mer_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector
polyline_tdc = repertory_temp + os.sep + "tdc_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector
polyline_tdc_simplif = repertory_temp + os.sep + "tdcs_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector
polyline_tdc_simplif_decoup = output_dir + os.sep + "tdcsd_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector
else :
poly_mer_shp = repertory_temp + os.sep + "poly_mer_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector
poly_mer_shp_dilat = repertory_temp + os.sep + "poly_mer_dilat_" + os.path.splitext(os.path.basename(input_image))[0] + extension_vector
poly_mer_shp_ferm = repertory_temp + os.sep + "poly_mer_ferm_" + os.path.splitext(os.path.basename(input_image))[0] + extension_vector
polyline_mer = repertory_temp + os.sep + "polyline_mer_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector
polyline_tdc = repertory_temp + os.sep + "tdc_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector
polyline_tdc_simplif = repertory_temp + os.sep + "tdcs_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector
polyline_tdc_simplif_decoup = output_dir + os.sep + "tdcsd_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector
# Création shp poly_mer_shp contenant uniquement les polygones mer
if os.path.exists(poly_mer_shp):
removeVectorFile(poly_mer_shp)
# Sélection des polygones qui sont de la mer, dans la liste poly_mer
withinPolygons(input_sea_points, ndvi_mask_vect, poly_mer_shp, overwrite, format_vector)
# Fermeture (dilatation - érosion) sur les polygones mer obtenus pour supprimer les petits trous dans les polygones (bateaux, ...) et rassembler les polygones proches
bufferVector(poly_mer_shp, poly_mer_shp_dilat, buf_pos, "", 1.0, 10, format_vector)
bufferVector(poly_mer_shp_dilat, poly_mer_shp_ferm, buf_neg, "", 1.0, 10, format_vector)
# Création masque binaire pour séparer les no data des vraies valeurs
no_data_ima = getNodataValueImage(input_image)
if no_data_ima == None :
no_data_ima = no_data_value
createBinaryMaskMultiBand(input_image, binary_mask_zeros, no_data_ima, CODAGE_8B)
# Vectorisation du masque binaire true data/false data -> polygone avec uniquement les vraies valeurs
if os.path.exists(path_binary_mask_zeros_vector):
removeVectorFile(path_binary_mask_zeros_vector)
polygonizeRaster(binary_mask_zeros, path_binary_mask_zeros_vector, binary_mask_zeros_vector)
# Buffer négatif sur ce polygone
bufferVector(path_binary_mask_zeros_vector, true_values_buffneg, -2, "", 1.0, 10, format_vector)
# Transformation des polygones de la couche poly_mer_shp_ferm en polyligne
convertePolygon2Polylines(poly_mer_shp_ferm, polyline_mer, overwrite, format_vector)
# Découpe du TDC polyline_mer avec le polygone négatif
cutVectorAll(true_values_buffneg, polyline_mer, polyline_tdc, overwrite, format_vector)
# Simplification du TDC
simplifyVector(polyline_tdc, polyline_tdc_simplif, simplif, format_vector)
# Buffer négatif autour de input_cut_vector
bufferVector(input_cut_vector, decoup_buffneg, -1, "", 1.0, 10, format_vector)
# Découpe du TDC polyline_mer avec le buffer négatif du polygone mer
cutVectorAll(decoup_buffneg, polyline_tdc_simplif, polyline_tdc_simplif_decoup, overwrite, format_vector)
tdc_final = polyline_tdc_simplif_decoup
# Suppression du repertoire temporaire
if not save_results_intermediate and os.path.exists(repertory_temp):
shutil.rmtree(repertory_temp)
# Mise à jour du Log
ending_event = "PolygonMerToTDC() : Select PolygonMerToTDC ending: "
timeLine(path_time_log,ending_event)
return tdc_final
def computeQualityIndiceRateQuantity(raster_input,
vector_sample_input,
repertory_output,
base_name,
geom,
size_grid,
pixel_size_x,
pixel_size_y,
field_value_verif,
field_value_other,
no_data_value,
epsg,
format_raster,
format_vector,
extension_raster,
extension_vector,
overwrite=True,
save_results_intermediate=False):
# Définition des constantes
EXT_TXT = '.txt'
SUFFIX_STUDY = '_study'
SUFFIX_CUT = '_cut'
SUFFIX_BUILD = '_build'
SUFFIX_OTHER = '_other'
SUFFIX_LOCAL = '_local'
SUFFIX_MATRIX = '_matrix'
FIELD_NAME_CLASSIF = "classif"
FIELD_TYPE = ogr.OFTInteger
# Les variables locales
vector_local_study = repertory_output + os.sep + base_name + SUFFIX_LOCAL + SUFFIX_STUDY + extension_vector
vector_local_cut_study = repertory_output + os.sep + base_name + SUFFIX_LOCAL + SUFFIX_CUT + SUFFIX_STUDY + extension_vector
vector_local_cut_build = repertory_output + os.sep + base_name + SUFFIX_LOCAL + SUFFIX_CUT + SUFFIX_BUILD + extension_vector
vector_local_cut_other = repertory_output + os.sep + base_name + SUFFIX_LOCAL + SUFFIX_CUT + SUFFIX_OTHER + extension_vector
vector_local_cut = repertory_output + os.sep + base_name + SUFFIX_LOCAL + SUFFIX_CUT + extension_vector
raster_local_cut = repertory_output + os.sep + base_name + SUFFIX_LOCAL + SUFFIX_CUT + extension_raster
matrix_local_file = repertory_output + os.sep + base_name + SUFFIX_LOCAL + SUFFIX_CUT + SUFFIX_MATRIX + EXT_TXT
class_ref_list = None
class_pro_list = None
rate_quantity_list = None
matrix_origine = None
kappa = 0.0
overall_accuracy = 0.0
# Netoyage les fichiers de travail local
if os.path.isfile(vector_local_study):
removeVectorFile(vector_local_study)
if os.path.isfile(vector_local_cut_study):
removeVectorFile(vector_local_cut_study)
if os.path.isfile(vector_local_cut):
removeVectorFile(vector_local_cut)
if os.path.isfile(vector_local_cut_build):
removeVectorFile(vector_local_cut_build)
if os.path.isfile(vector_local_cut_other):
removeVectorFile(vector_local_cut_other)
if os.path.isfile(raster_local_cut):
removeFile(raster_local_cut)
if os.path.isfile(matrix_local_file):
removeFile(matrix_local_file)
# Creation d'un shape file de travail local
polygon_attr_geom_dico = {"1": [geom, {}]}
createPolygonsFromGeometryList({}, polygon_attr_geom_dico,
vector_local_study, epsg, format_vector)
# Découpe sur zone local d'étude du fichier vecteur de référence
cutVector(vector_local_study, vector_sample_input, vector_local_cut_build,
format_vector)
differenceVector(vector_local_cut_build, vector_local_study,
vector_local_cut_other, format_vector)
addNewFieldVector(vector_local_cut_build, FIELD_NAME_CLASSIF, FIELD_TYPE,
field_value_verif, None, None, format_vector)
addNewFieldVector(vector_local_cut_other, FIELD_NAME_CLASSIF, FIELD_TYPE,
field_value_other, None, None, format_vector)
input_shape_list = [vector_local_cut_build, vector_local_cut_other]
fusionVectors(input_shape_list, vector_local_cut)
# Découpe sur zone local d'étude du fichier rasteur de classification
if not cutImageByVector(vector_local_study, raster_input, raster_local_cut,
pixel_size_x, pixel_size_y, no_data_value, 0,
format_raster, format_vector):
return class_ref_list, class_pro_list, rate_quantity_list, kappa, overall_accuracy, matrix_origine
# Calcul de la matrice de confusion
computeConfusionMatrix(raster_local_cut, vector_local_cut, "",
FIELD_NAME_CLASSIF, matrix_local_file, overwrite)
# lecture de la matrice de confusion
matrix, class_ref_list, class_pro_list = readConfusionMatrix(
matrix_local_file)
matrix_origine = copy.deepcopy(matrix)
if matrix == []:
print(
cyan + "computeQualityIndiceRateQuantity() : " + bold + yellow +
"!!! Une erreur c'est produite au cours de la lecture de la matrice de confusion : "
+ matrix_local_file + ". Voir message d'erreur." + endC)
matrix_origine = None
return class_ref_list, class_pro_list, rate_quantity_list, kappa, overall_accuracy, matrix_origine
# Correction de la matrice de confusion
# Dans le cas ou le nombre de microclasses des échantillons de controles
# et le nombre de microclasses de la classification sont différents
class_missing_list = []
if class_ref_list != class_pro_list:
matrix, class_missing_list = correctMatrix(class_ref_list,
class_pro_list, matrix,
no_data_value)
class_count = len(matrix[0]) - len(class_missing_list)
# Calcul des indicateurs de qualité : rate_quantity_list
precision_list, recall_list, fscore_list, performance_list, rate_false_positive_list, rate_false_negative_list, rate_quantity_list, class_list, overall_accuracy, overall_fscore, overall_performance, kappa = computeIndicators(
class_count, matrix, class_ref_list, class_missing_list)
# Chercher si une ligne no data existe si c'est le cas correction de la matrice
if str(no_data_value) in class_pro_list:
pos_col_nodata = class_pro_list.index(str(no_data_value))
for line in matrix_origine:
del line[pos_col_nodata]
class_pro_list.remove(str(no_data_value))
# Suppression des données temporaires locales
if not save_results_intermediate:
if os.path.isfile(vector_local_study):
removeVectorFile(vector_local_study)
if os.path.isfile(vector_local_cut_study):
removeVectorFile(vector_local_cut_study)
if os.path.isfile(vector_local_cut):
removeVectorFile(vector_local_cut)
if os.path.isfile(vector_local_cut_build):
removeVectorFile(vector_local_cut_build)
if os.path.isfile(vector_local_cut_other):
removeVectorFile(vector_local_cut_other)
if os.path.isfile(raster_local_cut):
removeFile(raster_local_cut)
if os.path.isfile(matrix_local_file):
removeFile(matrix_local_file)
return class_ref_list, class_pro_list, rate_quantity_list, kappa, overall_accuracy, matrix_origine
def computeMajorityClass(input_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):
SUFFIX_CLASS = '_class'
FIELD_TYPE = ogr.OFTInteger
FIELD_NAME_MAJORITY = 'majority'
temp_class_list = []
base_name = os.path.splitext(os.path.basename(input_grid))[0]
temp_grid = temp_directory + os.sep + base_name + SUFFIX_CLASS + extension_vector
temp_class0 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "0" + extension_vector
temp_class1 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "1" + extension_vector
temp_class2 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "2" + extension_vector
temp_class3 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "3" + extension_vector
temp_class4 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "4" + extension_vector
### Récupération de la classe majoritaire
if debug >= 3:
print(cyan + "computeMajorityClass() : " + endC + bold +
"Récupération de la classe majoritaire." + endC + '\n')
addNewFieldVector(input_grid,
maj_ocs_field,
FIELD_TYPE,
field_value=None,
field_width=None,
field_precision=None,
format_vector=format_vector)
attr_names_list = getAttributeNameList(input_grid,
format_vector=format_vector)
attr_names_list_str = "'"
for attr_name in attr_names_list:
attr_names_list_str += attr_name + ', '
attr_names_list_str = attr_names_list_str[:-2] + "'"
expression = "%s = '%s' OR %s = '%s' OR %s = '%s' OR %s = '%s'" % (
FIELD_NAME_MAJORITY, nodata_field, FIELD_NAME_MAJORITY, built_field,
FIELD_NAME_MAJORITY, mineral_field, FIELD_NAME_MAJORITY, water_field)
ret = filterSelectDataVector(input_grid,
temp_class0,
attr_names_list_str,
expression,
overwrite=overwrite,
format_vector=format_vector)
updateFieldVector(temp_class0,
field_name=maj_ocs_field,
value=class_label_dico_out["MAJ_OTHERS_CLASS"],
format_vector=format_vector)
temp_class_list.append(temp_class0)
expression = "%s = '%s'" % (FIELD_NAME_MAJORITY, baresoil_field)
ret = filterSelectDataVector(input_grid,
temp_class1,
attr_names_list_str,
expression,
overwrite=overwrite,
format_vector=format_vector)
updateFieldVector(temp_class1,
field_name=maj_ocs_field,
value=class_label_dico_out["MAJ_BARESOIL_CLASS"],
format_vector=format_vector)
temp_class_list.append(temp_class1)
expression = "(%s = '%s' OR %s = '%s' OR %s = '%s') AND (%s < 1)" % (
FIELD_NAME_MAJORITY, vegetation_field, FIELD_NAME_MAJORITY,
low_vegetation_field, FIELD_NAME_MAJORITY, high_vegetation_field,
veg_mean_field)
ret = filterSelectDataVector(input_grid,
temp_class2,
attr_names_list_str,
expression,
overwrite=overwrite,
format_vector=format_vector)
updateFieldVector(temp_class2,
field_name=maj_ocs_field,
value=class_label_dico_out["MAJ_LOW_VEG_CLASS"],
format_vector=format_vector)
temp_class_list.append(temp_class2)
expression = "(%s = '%s' OR %s = '%s' OR %s = '%s') AND (%s >= 1 AND %s < 5)" % (
FIELD_NAME_MAJORITY, vegetation_field, FIELD_NAME_MAJORITY,
low_vegetation_field, FIELD_NAME_MAJORITY, high_vegetation_field,
veg_mean_field, veg_mean_field)
ret = filterSelectDataVector(input_grid,
temp_class3,
attr_names_list_str,
expression,
overwrite=overwrite,
format_vector=format_vector)
updateFieldVector(temp_class3,
field_name=maj_ocs_field,
value=class_label_dico_out["MAJ_MED_VEG_CLASS"],
format_vector=format_vector)
temp_class_list.append(temp_class3)
expression = "(%s = '%s' OR %s = '%s' OR %s = '%s') AND (%s >= 5)" % (
FIELD_NAME_MAJORITY, vegetation_field, FIELD_NAME_MAJORITY,
low_vegetation_field, FIELD_NAME_MAJORITY, high_vegetation_field,
veg_mean_field)
ret = filterSelectDataVector(input_grid,
temp_class4,
attr_names_list_str,
expression,
overwrite=overwrite,
format_vector=format_vector)
updateFieldVector(temp_class4,
field_name=maj_ocs_field,
value=class_label_dico_out["MAJ_HIGH_VEG_CLASS"],
format_vector=format_vector)
temp_class_list.append(temp_class4)
fusionVectors(temp_class_list, temp_grid, format_vector=format_vector)
removeVectorFile(input_grid, format_vector=format_vector)
copyVectorFile(temp_grid, input_grid, format_vector=format_vector)
return 0
def comparareClassificationToReferenceGrid(image_input,
vector_cut_input,
vector_sample_input,
vector_grid_input,
vector_grid_output,
size_grid,
field_value_verif,
no_data_value,
path_time_log,
epsg=2154,
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 = "comparareClassificationToReferenceGrid() : starting : "
timeLine(path_time_log, starting_event)
print(endC)
print(bold + green +
"## START : COMPARE QUALITY FROM CLASSIF IMAGE BY GRID" + endC)
print(endC)
if debug >= 2:
print(
bold + green +
"comparareClassificationToReferenceGrid() : Variables dans la fonction"
+ endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"image_input : " + str(image_input) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"vector_cut_input : " + str(vector_cut_input) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"vector_sample_input : " + str(vector_sample_input) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"vector_grid_input : " + str(vector_grid_input) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"vector_grid_output : " + str(vector_grid_output) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"size_grid : " + str(size_grid) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"field_value_verif : " + str(field_value_verif))
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"no_data_value : " + str(no_data_value))
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"path_time_log : " + str(path_time_log) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"epsg : " + str(epsg) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"format_raster : " + str(format_raster) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"format_vector : " + str(format_vector) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"extension_raster : " + str(extension_raster) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"extension_vector : " + str(extension_vector) + endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "comparareClassificationToReferenceGrid() : " + endC +
"overwrite : " + str(overwrite) + endC)
# ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES'
CODAGE = "uint16"
SUFFIX_STUDY = '_study'
SUFFIX_TEMP = '_temp'
SUFFIX_FUSION = '_other_fusion'
NONE_VALUE_QUANTITY = -1.0
FIELD_VALUE_OTHER = 65535
FIELD_NAME_ID = "id"
FIELD_NAME_RATE_BUILD = "rate_build"
FIELD_NAME_RATE_OTHER = "rate_other"
FIELD_NAME_SREF_BUILD = "sref_build"
FIELD_NAME_SCLA_BUILD = "scla_build"
FIELD_NAME_SREF_OTHER = "sref_other"
FIELD_NAME_SCLA_OTHER = "scla_other"
FIELD_NAME_KAPPA = "kappa"
FIELD_NAME_ACCURACY = "accuracy"
pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input)
repertory_output = os.path.dirname(vector_grid_output)
base_name = os.path.splitext(os.path.basename(vector_grid_output))[0]
vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector
vector_grid_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector
image_raster_other_fusion = repertory_output + os.sep + base_name + SUFFIX_FUSION + extension_raster
# ETAPE 0 : VERIFICATION
# Verification de la valeur de la nomemclature à verifier
if field_value_verif >= FIELD_VALUE_OTHER:
print(
cyan + "comparareClassificationToReferenceGrid() : " + bold + red +
"Attention de valeur de nomenclature à vérifier : " +
str(field_value_verif) +
" doit être inferieur à la valeur de fusion des valeur autre arbitraire de : "
+ str(FIELD_VALUE_OTHER) + endC,
file=sys.stderr)
sys.exit(1) #exit with an error code
# ETAPE 1 : DEFINIR UN SHAPE ZONE D'ETUDE
if (not vector_cut_input is None) and (vector_cut_input != "") and (
os.path.isfile(vector_cut_input)):
cutting_action = True
vector_study = vector_cut_input
else:
cutting_action = False
createVectorMask(image_input, vector_study)
# ETAPE 2 : UNIFORMISATION DE LA ZONE OTHER
# Réalocation des valeurs de classification pour les valeurs autre que le bati
change_reaff_value_list = []
reaff_value_list = identifyPixelValues(image_input)
if field_value_verif in reaff_value_list:
reaff_value_list.remove(field_value_verif)
if no_data_value in reaff_value_list:
reaff_value_list.remove(no_data_value)
for elem in reaff_value_list:
change_reaff_value_list.append(FIELD_VALUE_OTHER)
reallocateClassRaster(image_input, image_raster_other_fusion,
reaff_value_list, change_reaff_value_list)
# ETAPE 3 : CREATION DE LA GRILLE SUR LA ZONE D'ETUDE
# Définir les attibuts du fichier
attribute_dico = {
FIELD_NAME_ID: ogr.OFTInteger,
FIELD_NAME_RATE_BUILD: ogr.OFTReal,
FIELD_NAME_RATE_OTHER: ogr.OFTReal,
FIELD_NAME_SREF_BUILD: ogr.OFTReal,
FIELD_NAME_SCLA_BUILD: ogr.OFTReal,
FIELD_NAME_SREF_OTHER: ogr.OFTReal,
FIELD_NAME_SCLA_OTHER: ogr.OFTReal,
FIELD_NAME_KAPPA: ogr.OFTReal,
FIELD_NAME_ACCURACY: ogr.OFTReal
}
nb_polygon = 0
if (not vector_grid_input is None) and (vector_grid_input != "") and (
os.path.isfile(vector_grid_input)):
# Utilisation du fichier grille d'entrée
# Recopie du fichier grille d'entrée vers le fichier grille de sortie
copyVectorFile(vector_grid_input, vector_grid_output)
# Ajout des champs au fichier grille de sortie
for field_name in attribute_dico:
addNewFieldVector(vector_grid_output, field_name,
attribute_dico[field_name], None, None, None,
format_vector)
# Mettre le champs "id" identifiant du carré de l'élément de la grille
nb_polygon = updateIndexVector(vector_grid_output, FIELD_NAME_ID,
format_vector)
else:
# Si il n'existe pas de fichier grille on en créer un avec la valeur de size_grid
# Creer le fichier grille
nb_polygon = createGridVector(vector_study, vector_grid_temp,
size_grid, size_grid, attribute_dico,
overwrite, epsg, format_vector)
# Découper la grille avec le shape zone d'étude
cutVectorAll(vector_study, vector_grid_temp, vector_grid_output,
format_vector)
# ETAPE 4 : CALCUL DE L'INDICATEUR DE QUALITE POUR CHAQUE CASE DE LA GRILLE
if debug >= 2:
print(bold + "nb_polygon = " + endC + str(nb_polygon) + "\n")
# Pour chaque polygone existant
sum_rate_quantity_build = 0
nb_rate_sum = 0
size_area_pixel = abs(pixel_size_x * pixel_size_y)
for id_polygon in range(nb_polygon):
geom_list = getGeomPolygons(vector_grid_output, FIELD_NAME_ID,
id_polygon, format_vector)
if geom_list is not None and geom_list != []: # and (id_polygon == 24 or id_polygon == 30):
if debug >= 1:
print(cyan + "comparareClassificationToReferenceGrid() : " +
bold + green +
"Calcul de la matrice pour le polygon n°: " +
str(id_polygon) + endC)
geom = geom_list[0]
class_ref_list, class_pro_list, rate_quantity_list, kappa, accuracy, matrix = computeQualityIndiceRateQuantity(
image_raster_other_fusion, vector_sample_input,
repertory_output, base_name + str(id_polygon), geom, size_grid,
pixel_size_x, pixel_size_y, field_value_verif,
FIELD_VALUE_OTHER, no_data_value, epsg, format_raster,
format_vector, extension_raster, extension_vector, overwrite,
save_results_intermediate)
# Si les calculs indicateurs de qualité sont ok
if debug >= 2:
print(matrix)
if matrix != None and matrix != [] and matrix[0] != []:
# Récuperer la quantité de bati et calcul de la surface de référence et de la surface de classification (carreau entier ou pas!)
if len(class_ref_list) == 2 and len(
class_pro_list
) == 2: # Cas ou l'on a des pixels de build et other (en ref et en prod)
rate_quantity_build = rate_quantity_list[0]
rate_quantity_other = rate_quantity_list[1]
size_area_ref_build = (matrix[0][0] +
matrix[0][1]) * size_area_pixel
size_area_classif_build = (matrix[0][0] +
matrix[1][0]) * size_area_pixel
size_area_ref_other = (matrix[1][0] +
matrix[1][1]) * size_area_pixel
size_area_classif_other = (matrix[0][1] +
matrix[1][1]) * size_area_pixel
sum_rate_quantity_build += rate_quantity_build
nb_rate_sum += 1
else: # Cas ou l'on a uniquement des pixels de build OU uniquement des pixels de other
if class_ref_list[
0] == field_value_verif: # Cas ou l'on a uniquement des pixels references build
rate_quantity_build = rate_quantity_list[0]
rate_quantity_other = NONE_VALUE_QUANTITY
size_area_ref_other = 0
if len(
class_pro_list
) == 2: # Cas ou l'on a des pixels de prod build et other
size_area_ref_build = (
matrix[0][0] + matrix[0][1]) * size_area_pixel
size_area_classif_build = matrix[0][
0] * size_area_pixel
size_area_classif_other = matrix[0][
1] * size_area_pixel
else:
size_area_ref_build = matrix[0][0] * size_area_pixel
if class_pro_list[
0] == field_value_verif: # Cas ou l'on a uniquement des pixels prod build
size_area_classif_build = matrix[0][
0] * size_area_pixel
size_area_classif_other = 0
else: # Cas ou l'on a uniquement des pixels prod other
size_area_classif_build = 0
size_area_classif_other = matrix[0][
0] * size_area_pixel
else: # Cas ou l'on a uniquement des pixels references other
rate_quantity_build = NONE_VALUE_QUANTITY
rate_quantity_other = rate_quantity_list[0]
size_area_ref_build = 0
if len(
class_pro_list
) == 2: # Cas ou l'on a des pixels de prod build et other
size_area_ref_other = (
matrix[0][0] + matrix[0][1]) * size_area_pixel
size_area_classif_build = matrix[0][
0] * size_area_pixel
size_area_classif_other = matrix[0][
1] * size_area_pixel
else:
size_area_ref_other = matrix[0][0] * size_area_pixel
if class_pro_list[
0] == field_value_verif: # Cas ou l'on a uniquement des pixels prod build
size_area_classif_build = matrix[0][
0] * size_area_pixel
size_area_classif_other = 0
else: # Cas ou l'on a uniquement des pixels prod other
size_area_classif_build = 0
size_area_classif_other = matrix[0][
0] * size_area_pixel
# Mettre à jour ses éléments du carré de la grille
setAttributeValues(
vector_grid_output, FIELD_NAME_ID, id_polygon, {
FIELD_NAME_RATE_BUILD: rate_quantity_build,
FIELD_NAME_RATE_OTHER: rate_quantity_other,
FIELD_NAME_SREF_BUILD: size_area_ref_build,
FIELD_NAME_SCLA_BUILD: size_area_classif_build,
FIELD_NAME_SREF_OTHER: size_area_ref_other,
FIELD_NAME_SCLA_OTHER: size_area_classif_other,
FIELD_NAME_KAPPA: kappa,
FIELD_NAME_ACCURACY: accuracy
}, format_vector)
# Calcul de la moyenne
if nb_rate_sum != 0:
average_quantity_build = sum_rate_quantity_build / nb_rate_sum
else:
average_quantity_build = 0
if debug >= 2:
print(bold + "nb_polygon_used = " + endC + str(nb_rate_sum))
print(bold + "average_quantity_build = " + endC +
str(average_quantity_build) + "\n")
# ETAPE 5 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES
# Suppression des données intermédiairess
if not save_results_intermediate:
if not cutting_action:
if os.path.isfile(vector_study):
removeVectorFile(vector_study)
if os.path.isfile(image_raster_other_fusion):
removeFile(image_raster_other_fusion)
if os.path.isfile(vector_grid_temp):
removeVectorFile(vector_grid_temp)
print(endC)
print(bold + green +
"## END : COMPARE QUALITY FROM CLASSIF IMAGE BY GRID" + endC)
print(endC)
# Mise à jour du Log
ending_event = "comparareClassificationToReferenceGrid() : ending : "
timeLine(path_time_log, ending_event)
return average_quantity_build
def binaryMaskVect(input_image,
output_dir,
threshold,
input_cut_vector,
attributes_list,
no_data_value,
epsg,
format_raster="GTiff",
format_vector="ESRI Shapefile",
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
# Affichage des paramètres
if debug >= 3:
print(bold + green +
"Variables dans le binaryMaskVect - Variables générales" + endC)
print(cyan + "binaryMaskVect() : " + endC + "input_image : " +
str(input_image) + endC)
print(cyan + "binaryMaskVect() : " + endC + "output_dir : " +
str(output_dir) + endC)
print(cyan + "binaryMaskVect() : " + endC + "threshold : " +
str(threshold) + endC)
print(cyan + "binaryMaskVect() : " + endC + "input_cut_vector : " +
str(input_cut_vector) + endC)
print(cyan + "binaryMaskVect() : " + endC + "format_raster : " +
str(format_raster) + endC)
print(cyan + "binaryMaskVect() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "binaryMaskVect() : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(cyan + "binaryMaskVect() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "binaryMaskVect() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "binaryMaskVect() : " + endC + "overwrite : " +
str(overwrite) + endC)
image_name = os.path.splitext(os.path.basename(input_image))[0]
binary_mask = output_dir + os.sep + "bin_mask_" + image_name + "_" + str(
threshold).replace('.', '_') + extension_raster
binary_mask_decoup = output_dir + os.sep + "bin_mask_decoup_" + image_name + "_" + str(
threshold).replace('.', '_') + extension_raster
binary_mask_vector = output_dir + os.sep + "bin_mask_vect_" + image_name + "_" + str(
threshold).replace('.', '_') + extension_vector
# Création du répertoire de sortie s'il n'existe pas déjà
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Suppression des fichiers temporaires pour les calculs
if os.path.exists(binary_mask):
removeFile(binary_mask)
if os.path.exists(binary_mask_decoup):
removeFile(binary_mask_decoup)
if os.path.exists(binary_mask_vector):
if overwrite:
removeVectorFile(binary_mask_vector, format_vector)
else:
return binary_mask_vector
# Création du masque binaire
createBinaryMask(input_image, binary_mask, threshold, False)
if input_cut_vector != "":
# Découpe du raster
cutImageByVector(input_cut_vector, binary_mask, binary_mask_decoup,
None, None, no_data_value, epsg, format_raster,
format_vector)
else:
binary_mask_decoup = binary_mask
# Vectorisation du masque binaire découpé
polygonizeRaster(binary_mask_decoup, binary_mask_vector, image_name, "id",
format_vector)
# Ajout des champs au fichier vecteur créé
for attribute in attributes_list:
addNewFieldVector(binary_mask_vector, attribute.name,
attribute.ogrType, attribute.value, attribute.width,
None, format_vector)
# Suppresions des fichiers intermediaires inutiles et reperoire temporaire
if not save_results_intermediate:
removeFile(binary_mask)
removeFile(binary_mask_decoup)
return binary_mask_vector
def prepareData(input_buffer_tdc,
input_paysage,
output_dir,
input_repertories_list,
id_paysage,
id_name_sub_rep,
epsg,
optimization_zone,
no_cover,
zone_date,
separ_name,
pos_date,
nb_char_date,
separ_date,
path_time_log,
format_raster='GTiff',
format_vector="ESRI Shapefile",
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=True,
overwrite=True):
# Mise à jour du Log
starting_event = "prepareData() : Select prepare data starting : "
timeLine(path_time_log, starting_event)
# Affichage des paramètres
if debug >= 3:
print(bold + green +
"Variables dans le prepareData - Variables générales" + endC)
print(cyan + "PrepareData() : " + endC + "input_buffer_tdc : " +
str(input_buffer_tdc) + endC)
print(cyan + "PrepareData() : " + endC + "input_paysage : " +
str(input_paysage) + endC)
print(cyan + "PrepareData() : " + endC + "output_dir : " +
str(output_dir) + endC)
print(cyan + "PrepareData() : " + endC + "input_repertories_list : " +
str(input_repertories_list) + endC)
print(cyan + "PrepareData() : " + endC + "id_paysage : " +
str(id_paysage) + endC)
print(cyan + "PrepareData() : " + endC + "id_name_sub_rep : " +
str(id_name_sub_rep) + endC)
print(cyan + "PrepareData() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + "PrepareData() : " + endC + "optimization_zone : " +
str(optimization_zone) + endC)
print(cyan + "PrepareData() : " + endC + "no_cover : " +
str(no_cover) + endC)
print(cyan + "PrepareData() : " + endC + "zone_date : " +
str(zone_date) + endC)
print(cyan + "PrepareData() : " + endC + "separ_name : " +
str(separ_name) + endC)
print(cyan + "PrepareData() : " + endC + "pos_date : " +
str(pos_date) + endC)
print(cyan + "PrepareData() : " + endC + "nb_char_date : " +
str(nb_char_date) + endC)
print(cyan + "PrepareData() : " + endC + "separ_date : " +
str(separ_date) + endC)
print(cyan + "PrepareData() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "PrepareData() : " + endC + "format_raster : " +
str(format_raster) + endC)
print(cyan + "PrepareData() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "PrepareData() : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(cyan + "PrepareData() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "PrepareData() : " + endC + "save_results_inter : " +
str(save_results_intermediate) + endC)
print(cyan + "PrepareData() : " + endC + "overwrite : " +
str(overwrite) + endC)
REPERTORY_PAYSAGES = "Paysages"
REPERTORY_IMAGES = "Images"
ID_P = "id_p"
SUFFIX_OPTI = "_opti"
SUFFIX_ASS = "_ass"
SUFFIX_CUT = "_cut"
SUFFIX_ERROR = "_error"
SUFFIX_MERGE = "_merge"
SUFFIX_CLEAN = "_clean"
SUFFIX_STACK = "_stack"
output_dir_paysages = output_dir + os.sep + REPERTORY_PAYSAGES
output_dir_images = output_dir + os.sep + REPERTORY_IMAGES
# Création du répertoire de sortie s'il n'existe pas déjà
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Création du répertoire de sortie pour les paysages s'il n'existe pas
if not os.path.exists(output_dir_paysages):
os.makedirs(output_dir_paysages)
# Création du répertoire de sortie pour les images s'il n'existe pas
if not os.path.exists(output_dir_images):
os.makedirs(output_dir_images)
# Recuperer l'epsg du fichier d'emprise
if epsg == 0:
epsg = getProjection(input_paysage, format_vector)
# Création du paysage optimal
optimPaysage(input_buffer_tdc, input_paysage, optimization_zone,
SUFFIX_OPTI, output_dir_paysages, id_paysage, format_vector)
# Création un shapefile par polygone
paysage_opti = output_dir_paysages + os.sep + os.path.splitext(
os.path.basename(input_paysage))[0] + SUFFIX_OPTI + os.path.splitext(
input_paysage)[1]
if id_paysage != "":
paysages_list = splitVector(paysage_opti, str(output_dir_paysages),
str(id_paysage), epsg, format_vector,
extension_vector)
else:
paysages_list = splitVector(paysage_opti, str(output_dir_paysages),
ID_P, epsg, format_vector,
extension_vector)
if debug >= 3:
print(cyan + "PrepareData() : " + endC +
"Liste des fichiers en entrée de imagesAssembly() : " +
str(paysages_list))
# Création du fichier de sortie des images s'il n'existe pas dejà
if not os.path.exists(output_dir_images):
os.makedirs(output_dir_images)
# Assemblage des images dans les paysages optimisés
# Si on choisit pas de recouvrement entre les images
if no_cover:
sub_repertory_images_paysages_list = []
repertory_images_sources_list = []
repertory_input_image_dir = input_repertories_list[
0] # ATTENTION !!!! GFT c'est louche comme methode de prendre uniquement le premier repertoire d'image????
# On cherche la colonne contenant le nom de l'image
for shape in paysages_list:
attribute_name_dico = {}
attribute_name_dico[id_name_sub_rep] = ogr.OFTString
res_values_dico = getAttributeValues(shape, None, None,
attribute_name_dico,
format_vector)
sub_repertory_images_paysage = res_values_dico[id_name_sub_rep][0]
sub_repertory_images_paysages_list.append(
sub_repertory_images_paysage)
# Si la colonne existe
if len(sub_repertory_images_paysages_list) != 0:
for sub_repertory_images_paysage in sub_repertory_images_paysages_list:
repertory_images_sources_list.append(
repertory_input_image_dir + os.sep +
sub_repertory_images_paysage)
# Sinon on demande d'entrer les noms des images
else:
print("Liste des paysages optimisés : " + str(paysages_list))
repertory_images_sources_list = input(
"Rentrez la liste des images associées à chaque paysage dans l'ordre sous forme de liste [..., ..., ...] \n"
)
while len(repertory_images_sources_list) != len(paysages_list):
print(
"Longueur de la liste images différente de celle des paysages \n"
)
repertory_images_sources_list = input(
"Rentrez la liste des images associées à chaque paysage dans l'ordre \n"
)
if debug >= 2:
print("repertory_images_sources_list " +
str(repertory_images_sources_list))
# Commande ImagesAssembly sur les éléments des 2 listes
for i in range(len(paysages_list)):
image_output = output_dir_images + os.sep + os.path.splitext(
os.path.basename(
paysages_list[i]))[0] + SUFFIX_ASS + extension_raster
try:
selectAssembyImagesByHold(
paysages_list[i], [repertory_images_sources_list[i]],
image_output, False, True, epsg, False, False, False,
False, 0, 0, 0, 0, separ_name, pos_date, nb_char_date,
separ_date, path_time_log, SUFFIX_ERROR, SUFFIX_MERGE,
SUFFIX_CLEAN, SUFFIX_STACK, format_raster, format_vector,
extension_raster, extension_vector,
save_results_intermediate, overwrite)
except Exception:
pass
else:
for shape in paysages_list:
image_output = output_dir_images + os.sep + os.path.splitext(
os.path.basename(shape))[0] + SUFFIX_ASS + extension_raster
if optimization_zone:
shape_cut = os.path.splitext(
shape)[0] + SUFFIX_CUT + os.path.splitext(shape)[1]
cutVector(input_buffer_tdc, shape, shape_cut, overwrite,
format_vector)
else:
shape_cut = shape
selectAssembyImagesByHold(shape_cut, input_repertories_list,
image_output, False, zone_date, epsg,
False, False, False, False, 0, 0, 0, 0,
separ_name, pos_date, nb_char_date,
separ_date, path_time_log, SUFFIX_ERROR,
SUFFIX_MERGE, SUFFIX_CLEAN, SUFFIX_STACK,
format_raster, format_vector,
save_results_intermediate, overwrite)
if optimization_zone and os.path.exists(shape_cut):
removeVectorFile(shape_cut, format_vector)
# Mise à jour du Log
ending_event = "prepareData() : Select prepare data ending : "
timeLine(path_time_log, ending_event)
return
def estimateQualityMns(image_input,
vector_cut_input,
vector_sample_input_list,
vector_sample_points_input,
raster_input_dico,
vector_output,
no_data_value,
path_time_log,
format_raster='GTiff',
epsg=2154,
format_vector='ESRI Shapefile',
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
# Mise à jour du Log
starting_event = "estimateQualityMns() : Masks creation starting : "
timeLine(path_time_log, starting_event)
print(endC)
print(bold + green + "## START : CREATE HEIGHT POINTS FILE FROM MNS" +
endC)
print(endC)
if debug >= 2:
print(bold + green +
"estimateQualityMns() : Variables dans la fonction" + endC)
print(cyan + "estimateQualityMns() : " + endC + "image_input : " +
str(image_input) + endC)
print(cyan + "estimateQualityMns() : " + endC + "vector_cut_input : " +
str(vector_cut_input) + endC)
print(cyan + "estimateQualityMns() : " + endC +
"vector_sample_input_list : " + str(vector_sample_input_list) +
endC)
print(cyan + "estimateQualityMns() : " + endC +
"vector_sample_points_input : " +
str(vector_sample_points_input) + endC)
print(cyan + "estimateQualityMns() : " + endC +
"raster_input_dico : " + str(raster_input_dico) + endC)
print(cyan + "estimateQualityMns() : " + endC + "vector_output : " +
str(vector_output) + endC)
print(cyan + "estimateQualityMns() : " + endC + "no_data_value : " +
str(no_data_value))
print(cyan + "estimateQualityMns() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "estimateQualityMns() : " + endC + "epsg : " +
str(epsg) + endC)
print(cyan + "estimateQualityMns() : " + endC + "format_raster : " +
str(format_raster) + endC)
print(cyan + "estimateQualityMns() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "estimateQualityMns() : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(cyan + "estimateQualityMns() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "estimateQualityMns() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "estimateQualityMns() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Définion des constantes
EXT_DBF = '.dbf'
EXT_CSV = '.csv'
CODAGE = "uint16"
SUFFIX_STUDY = '_study'
SUFFIX_CUT = '_cut'
SUFFIX_TEMP = '_temp'
SUFFIX_CLEAN = '_clean'
SUFFIX_SAMPLE = '_sample'
ATTRIBUTE_ID = "ID"
ATTRIBUTE_Z_INI = "Z_INI"
ATTRIBUTE_Z_FIN = "Z_FIN"
ATTRIBUTE_PREC_ALTI = "PREC_ALTI"
ATTRIBUTE_Z_REF = "Z_Ref"
ATTRIBUTE_Z_MNS = "Z_Mns"
ATTRIBUTE_Z_DELTA = "Z_Delta"
ERODE_EDGE_POINTS = -1.0
ERROR_VALUE = -99.0
ERROR_MIN_VALUE = -9999
ERROR_MAX_VALUE = 9999
# ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES
# Si le fichier de sortie existe on ecrase
check = os.path.isfile(vector_output)
if check and not overwrite: # Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors FIN
print(cyan + "estimateQualityMns() : " + bold + yellow +
"Create file %s already exist : no actualisation" %
(vector_output) + endC)
return
if os.path.isfile(os.path.splitext(vector_output)[0] + EXT_CSV):
removeFile(os.path.splitext(vector_output)[0] + EXT_CSV)
repertory_output = os.path.dirname(vector_output)
base_name = os.path.splitext(os.path.basename(vector_output))[0]
vector_output_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector
raster_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_raster
vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector
vector_study_clean = repertory_output + os.sep + base_name + SUFFIX_STUDY + SUFFIX_CLEAN + extension_vector
image_cut = repertory_output + os.sep + base_name + SUFFIX_CUT + extension_raster
vector_sample_temp = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + extension_vector
vector_sample_temp_clean = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + SUFFIX_CLEAN + extension_vector
# Utilisation des données raster externes
raster_cut_dico = {}
for raster_input in raster_input_dico:
base_name_raster = os.path.splitext(os.path.basename(raster_input))[0]
raster_cut = repertory_output + os.sep + base_name_raster + SUFFIX_CUT + extension_raster
raster_cut_dico[raster_input] = raster_cut
if os.path.exists(raster_cut):
removeFile(raster_cut)
# ETAPE 1 : DEFINIR UN SHAPE ZONE D'ETUDE
if (not vector_cut_input is None) and (vector_cut_input != "") and (
os.path.isfile(vector_cut_input)):
cutting_action = True
vector_study = vector_cut_input
else:
cutting_action = False
createVectorMask(image_input, vector_study)
# ETAPE 2 : DECOUPAGE DU RASTEUR PAR LE VECTEUR D'ETUDE SI BESOIN ET REECHANTILLONAGE SI BESOIN
if cutting_action:
# Identification de la tailles de pixels en x et en y du fichier MNS de reference
pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input)
# Si le fichier de sortie existe deja le supprimer
if os.path.exists(image_cut):
removeFile(image_cut)
# Commande de découpe
if not cutImageByVector(vector_study, image_input, image_cut,
pixel_size_x, pixel_size_y, no_data_value, 0,
format_raster, format_vector):
print(
cyan + "estimateQualityMns() : " + bold + red +
"Une erreur c'est produite au cours du decoupage de l'image : "
+ image_input + endC,
file=sys.stderr)
raise
if debug >= 2:
print(cyan + "estimateQualityMns() : " + bold + green +
"DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" %
(image_input, vector_study) + endC)
else:
image_cut = image_input
# Definir l'emprise du fichier MNS de reference
# Decoupage de chaque raster de la liste des rasters
for raster_input in raster_input_dico:
raster_cut = raster_cut_dico[raster_input]
if not cutImageByVector(vector_study, raster_input, raster_cut,
pixel_size_x, pixel_size_y, no_data_value, 0,
format_raster, format_vector):
raise NameError(
cyan + "estimateQualityMns() : " + bold + red +
"Une erreur c'est produite au cours du decoupage du raster : "
+ raster_input + endC)
# Gémotrie de l'image
pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_cut)
cols, rows, bands = getGeometryImage(image_cut)
xmin, xmax, ymin, ymax = getEmpriseImage(image_cut)
if debug >= 3:
print("Geometrie Image : ")
print(" cols = " + str(cols))
print(" rows = " + str(rows))
print(" xmin = " + str(xmin))
print(" xmax = " + str(xmax))
print(" ymin = " + str(ymin))
print(" ymax = " + str(ymax))
print(" pixel_size_x = " + str(pixel_size_x))
print(" pixel_size_y = " + str(pixel_size_y))
print("\n")
# Création du dico coordonnées des points en systeme cartographique
points_random_value_dico = {}
# liste coordonnées des points au format matrice image brute
points_coordonnees_image_list = []
# Selon que l'on utilise le fichier de points d'echantillons ou que l'on recréé a partir des sommets des vecteurs lignes
if (vector_sample_points_input is None) or (vector_sample_points_input
== ""):
# ETAPE 3 : DECOUPAGES DES VECTEURS DE REFERENCE D'ENTREE PAR LE VECTEUR D'ETUDE ET LEUR FUSION ET
# LECTURE D'UN VECTEUR DE LIGNES ET SAUVEGARDE DES COORDONNEES POINTS DES EXTREMITEES ET LEUR HAUTEUR
# Découpage des vecteurs de bd réference avec le vecteur zone d'étude
vector_sample_input_cut_list = []
for vector_sample in vector_sample_input_list:
vector_name = os.path.splitext(os.path.basename(vector_sample))[0]
vector_sample_cut = repertory_output + os.sep + vector_name + SUFFIX_CUT + extension_vector
vector_sample_input_cut_list.append(vector_sample_cut)
cutoutVectors(vector_study, vector_sample_input_list,
vector_sample_input_cut_list, format_vector)
# Fusion des vecteurs de bd réference découpés
fusionVectors(vector_sample_input_cut_list, vector_sample_temp,
format_vector)
# Preparation des colonnes
names_column_start_point_list = [
ATTRIBUTE_ID, ATTRIBUTE_Z_INI, ATTRIBUTE_PREC_ALTI
]
names_column_end_point_list = [
ATTRIBUTE_ID, ATTRIBUTE_Z_FIN, ATTRIBUTE_PREC_ALTI
]
fields_list = [
ATTRIBUTE_ID, ATTRIBUTE_PREC_ALTI, ATTRIBUTE_Z_INI, ATTRIBUTE_Z_FIN
]
multigeometries2geometries(vector_sample_temp,
vector_sample_temp_clean, fields_list,
"MULTILINESTRING", format_vector)
points_coordinates_dico = readVectorFileLinesExtractTeminalsPoints(
vector_sample_temp_clean, names_column_start_point_list,
names_column_end_point_list, format_vector)
else:
# ETAPE 3_BIS : DECOUPAGE DE VECTEURS D'ECHANTILLONS POINTS PAR LE VECTEUR D'EMPRISE ET
# LECTURE DES COORDONNES D'ECHANTILLONS DURECTEMENT DANS LE FICHIER VECTEUR POINTS
# Liste coordonnées des points au format matrice image brute
cutVectorAll(vector_study, vector_sample_points_input,
vector_sample_temp, format_vector)
points_coordinates_dico = readVectorFilePoints(vector_sample_temp,
format_vector)
# ETAPE 4 : PREPARATION DU VECTEUR DE POINTS
for index_key in points_coordinates_dico:
# Recuperer les valeurs des coordonnees
coord_info_list = points_coordinates_dico[index_key]
coor_x = coord_info_list[0]
coor_y = coord_info_list[1]
attribut_dico = coord_info_list[2]
# Coordonnées des points au format matrice image
pos_x = int(round((coor_x - xmin) / abs(pixel_size_x)) - 1)
pos_y = int(round((ymax - coor_y) / abs(pixel_size_y)) - 1)
if pos_x < 0:
pos_x = 0
if pos_x >= cols:
pos_x = cols - 1
if pos_y < 0:
pos_y = 0
if pos_y >= rows:
pos_y = rows - 1
coordonnees_list = [pos_x, pos_y]
points_coordonnees_image_list.append(coordonnees_list)
value_ref = 0.0
if ATTRIBUTE_Z_INI in attribut_dico.keys():
value_ref = float(attribut_dico[ATTRIBUTE_Z_INI])
if ATTRIBUTE_Z_FIN in attribut_dico.keys():
value_ref = float(attribut_dico[ATTRIBUTE_Z_FIN])
precision_alti = 0.0
if ATTRIBUTE_PREC_ALTI in attribut_dico.keys():
precision_alti = float(attribut_dico[ATTRIBUTE_PREC_ALTI])
point_attr_dico = {
ATTRIBUTE_ID: index_key,
ATTRIBUTE_Z_REF: value_ref,
ATTRIBUTE_PREC_ALTI: precision_alti,
ATTRIBUTE_Z_MNS: 0.0,
ATTRIBUTE_Z_DELTA: 0.0
}
for raster_input in raster_input_dico:
field_name = raster_input_dico[raster_input][0][0]
point_attr_dico[field_name] = 0.0
points_random_value_dico[index_key] = [[coor_x, coor_y],
point_attr_dico]
# ETAPE 5 : LECTURE DES DONNEES DE HAUTEURS ISSU DU MNS et autre raster
# Lecture dans le fichier raster des valeurs
values_height_list = getPixelsValueListImage(
image_cut, points_coordonnees_image_list)
values_others_dico = {}
for raster_input in raster_input_dico:
raster_cut = raster_cut_dico[raster_input]
values_list = getPixelsValueListImage(raster_cut,
points_coordonnees_image_list)
values_others_dico[raster_input] = values_list
for i in range(len(points_random_value_dico)):
value_mns = values_height_list[i]
value_ref = points_random_value_dico[i][1][ATTRIBUTE_Z_REF]
points_random_value_dico[i][1][ATTRIBUTE_Z_MNS] = float(value_mns)
precision_alti = points_random_value_dico[i][1][ATTRIBUTE_PREC_ALTI]
points_random_value_dico[i][1][ATTRIBUTE_PREC_ALTI] = float(
precision_alti)
value_diff = value_ref - value_mns
points_random_value_dico[i][1][ATTRIBUTE_Z_DELTA] = float(value_diff)
for raster_input in raster_input_dico:
field_name = raster_input_dico[raster_input][0][0]
value_other = values_others_dico[raster_input][i]
points_random_value_dico[i][1][field_name] = float(value_other)
# ETAPE 6 : CREATION D'UN VECTEUR DE POINTS AVEC DONNEE COORDONNES POINT ET HAUTEUR REFERENCE ET MNS
# Suppression des points contenant des valeurs en erreur et en dehors du filtrage
points_random_value_dico_clean = {}
for i in range(len(points_random_value_dico)):
value_ref = points_random_value_dico[i][1][ATTRIBUTE_Z_REF]
if value_ref != ERROR_VALUE and value_ref > ERROR_MIN_VALUE and value_ref < ERROR_MAX_VALUE:
points_is_valid = True
for raster_input in raster_input_dico:
if len(raster_input_dico[raster_input]) > 1 and len(
raster_input_dico[raster_input][1]) > 1:
threshold_min = float(
raster_input_dico[raster_input][1][0])
threshold_max = float(
raster_input_dico[raster_input][1][1])
field_name = raster_input_dico[raster_input][0][0]
value_raster = float(
points_random_value_dico[i][1][field_name])
if value_raster < threshold_min or value_raster > threshold_max:
points_is_valid = False
if points_is_valid:
points_random_value_dico_clean[i] = points_random_value_dico[i]
# Définir les attibuts du fichier résultat
attribute_dico = {
ATTRIBUTE_ID: ogr.OFTInteger,
ATTRIBUTE_PREC_ALTI: ogr.OFTReal,
ATTRIBUTE_Z_REF: ogr.OFTReal,
ATTRIBUTE_Z_MNS: ogr.OFTReal,
ATTRIBUTE_Z_DELTA: ogr.OFTReal
}
for raster_input in raster_input_dico:
field_name = raster_input_dico[raster_input][0][0]
attribute_dico[field_name] = ogr.OFTReal
createPointsFromCoordList(attribute_dico, points_random_value_dico_clean,
vector_output_temp, epsg, format_vector)
# Suppression des points en bord de zone d'étude
bufferVector(vector_study, vector_study_clean, ERODE_EDGE_POINTS, "", 1.0,
10, format_vector)
cutVectorAll(vector_study_clean, vector_output_temp, vector_output, True,
format_vector)
# ETAPE 7 : TRANSFORMATION DU FICHIER .DBF EN .CSV
dbf_file = repertory_output + os.sep + base_name + EXT_DBF
csv_file = repertory_output + os.sep + base_name + EXT_CSV
if debug >= 2:
print(cyan + "estimateQualityMns() : " + bold + green +
"Conversion du fichier DBF %s en fichier CSV %s" %
(dbf_file, csv_file) + endC)
convertDbf2Csv(dbf_file, csv_file)
# ETAPE 8 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES
# Suppression des données intermédiaires
if not save_results_intermediate:
if cutting_action:
if os.path.isfile(image_cut):
removeFile(image_cut)
else:
if os.path.isfile(vector_study):
removeVectorFile(vector_study)
for raster_input in raster_input_dico:
raster_cut = raster_cut_dico[raster_input]
if os.path.isfile(raster_cut):
removeFile(raster_cut)
if os.path.isfile(vector_output_temp):
removeVectorFile(vector_output_temp)
if os.path.isfile(vector_study_clean):
removeVectorFile(vector_study_clean)
if os.path.isfile(vector_sample_temp):
removeVectorFile(vector_sample_temp)
if os.path.isfile(vector_sample_temp_clean):
removeVectorFile(vector_sample_temp_clean)
for vector_file in vector_sample_input_cut_list:
if os.path.isfile(vector_file):
removeVectorFile(vector_file)
print(bold + green + "## END : CREATE HEIGHT POINTS FILE FROM MNSE" + endC)
# Mise à jour du Log
ending_event = "estimateQualityMns() : Masks creation ending : "
timeLine(path_time_log, ending_event)
return
def statisticsVectorRaster(image_input,
vector_input,
vector_output,
band_number,
enable_stats_all_count,
enable_stats_columns_str,
enable_stats_columns_real,
col_to_delete_list,
col_to_add_list,
class_label_dico,
path_time_log,
clean_small_polygons=False,
format_vector='ESRI Shapefile',
save_results_intermediate=False,
overwrite=True):
# INITIALISATION
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + endC + "image_input : " +
str(image_input) + endC)
print(cyan + "statisticsVectorRaster() : " + endC + "vector_input : " +
str(vector_input) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"vector_output : " + str(vector_output) + endC)
print(cyan + "statisticsVectorRaster() : " + endC + "band_number : " +
str(band_number) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"enable_stats_all_count : " + str(enable_stats_all_count) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"enable_stats_columns_str : " + str(enable_stats_columns_str) +
endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"enable_stats_columns_real : " + str(enable_stats_columns_real) +
endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"col_to_delete_list : " + str(col_to_delete_list) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"col_to_add_list : " + str(col_to_add_list) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"class_label_dico : " + str(class_label_dico) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"clean_small_polygons : " + str(clean_small_polygons) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"path_time_log : " + str(path_time_log) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"format_vector : " + str(format_vector) + endC)
print(cyan + "statisticsVectorRaster() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "statisticsVectorRaster() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Constantes
PREFIX_AREA_COLUMN = "S_"
# Mise à jour du Log
starting_event = "statisticsVectorRaster() : Compute statistic crossing starting : "
timeLine(path_time_log, starting_event)
# creation du fichier vecteur de sortie
if vector_output == "":
vector_output = vector_input # Précisé uniquement pour l'affichage
else:
# Copy vector_output
copyVectorFile(vector_input, vector_output, format_vector)
# Vérifications
image_xmin, image_xmax, image_ymin, image_ymax = getEmpriseImage(
image_input)
vector_xmin, vector_xmax, vector_ymin, vector_ymax = getEmpriseFile(
vector_output, format_vector)
extension_vector = os.path.splitext(vector_output)[1]
if round(vector_xmin, 4) < round(image_xmin, 4) or round(
vector_xmax, 4) > round(image_xmax, 4) or round(
vector_ymin, 4) < round(image_ymin, 4) or round(
vector_ymax, 4) > round(image_ymax, 4):
print(cyan + "statisticsVectorRaster() : " + bold + red +
"image_xmin, image_xmax, image_ymin, image_ymax" + endC,
image_xmin,
image_xmax,
image_ymin,
image_ymax,
file=sys.stderr)
print(cyan + "statisticsVectorRaster() : " + bold + red +
"vector_xmin, vector_xmax, vector_ymin, vector_ymax" + endC,
vector_xmin,
vector_xmax,
vector_ymin,
vector_ymax,
file=sys.stderr)
raise NameError(
cyan + "statisticsVectorRaster() : " + bold + red +
"The extend of the vector file (%s) is greater than the image file (%s)"
% (vector_output, image_input) + endC)
pixel_size = getPixelSizeImage(image_input)
# Suppression des très petits polygones qui introduisent des valeurs NaN
if clean_small_polygons:
min_size_area = pixel_size * 2
vector_temp = os.path.splitext(
vector_output)[0] + "_temp" + extension_vector
cleanMiniAreaPolygons(vector_output, vector_temp, min_size_area, '',
format_vector)
removeVectorFile(vector_output, format_vector)
renameVectorFile(vector_temp, vector_output)
# Récuperation du driver pour le format shape
driver = ogr.GetDriverByName(format_vector)
# Ouverture du fichier shape en lecture-écriture
data_source = driver.Open(vector_output,
1) # 0 means read-only - 1 means writeable.
if data_source is None:
print(cyan + "statisticsVectorRaster() : " + bold + red +
"Impossible d'ouvrir le fichier shape : " + vector_output + endC,
file=sys.stderr)
sys.exit(1) # exit with an error code
# Récupération du vecteur
layer = data_source.GetLayer(
0) # Recuperation de la couche (une couche contient les polygones)
layer_definition = layer.GetLayerDefn(
) # GetLayerDefn => returns the field names of the user defined (created) fields
# ETAPE 1/4 : CREATION AUTOMATIQUE DU DICO DE VALEUR SI IL N'EXISTE PAS
if enable_stats_all_count and class_label_dico == {}:
image_values_list = identifyPixelValues(image_input)
# Pour toutes les valeurs
for id_value in image_values_list:
class_label_dico[id_value] = str(id_value)
# Suppression de la valeur no date à 0
if 0 in class_label_dico:
del class_label_dico[0]
if debug >= 2:
print(class_label_dico)
# ETAPE 2/4 : CREATION DES COLONNES DANS LE FICHIER SHAPE
if debug >= 2:
print(
cyan + "statisticsVectorRaster() : " + bold + green +
"ETAPE 1/3 : DEBUT DE LA CREATION DES COLONNES DANS LE FICHIER VECTEUR %s"
% (vector_output) + endC)
# En entrée :
# col_to_add_list = [UniqueID, majority/DateMaj/SrcMaj, minority, min, max, mean, median, sum, std, unique, range, all, count, all_S, count_S] - all traduisant le class_label_dico en autant de colonnes
# Sous_listes de col_to_add_list à identifier pour des facilités de manipulations ultérieures:
# col_to_add_inter01_list = [majority/DateMaj/SrcMaj, minority, min, max, mean, median, sum, std, unique, range]
# col_to_add_inter02_list = [majority, minority, min, max, mean, median, sum, std, unique, range, all, count, all_S, count_S]
# Construction des listes intermédiaires
col_to_add_inter01_list = []
# Valeurs à injecter dans des colonnes - Format String
if enable_stats_columns_str:
stats_columns_str_list = ['majority', 'minority']
for e in stats_columns_str_list:
col_to_add_list.append(e)
# Valeurs à injecter dans des colonnes - Format Nbr
if enable_stats_columns_real:
stats_columns_real_list = [
'min', 'max', 'mean', 'median', 'sum', 'std', 'unique', 'range'
]
for e in stats_columns_real_list:
col_to_add_list.append(e)
# Valeurs à injecter dans des colonnes - Format Nbr
if enable_stats_all_count:
stats_all_count_list = ['all', 'count']
for e in stats_all_count_list:
col_to_add_list.append(e)
# Valeurs à injecter dans des colonnes - si class_label_dico est non vide
if class_label_dico != {}:
stats_all_count_list = ['all', 'count']
for e in stats_all_count_list:
if not e in col_to_add_list:
col_to_add_list.append(e)
# Ajout colonne par colonne
if "majority" in col_to_add_list:
col_to_add_inter01_list.append("majority")
if "DateMaj" in col_to_add_list:
col_to_add_inter01_list.append("DateMaj")
if "SrcMaj" in col_to_add_list:
col_to_add_inter01_list.append("SrcMaj")
if "minority" in col_to_add_list:
col_to_add_inter01_list.append("minority")
if "min" in col_to_add_list:
col_to_add_inter01_list.append("min")
if "max" in col_to_add_list:
col_to_add_inter01_list.append("max")
if "mean" in col_to_add_list:
col_to_add_inter01_list.append("mean")
if "median" in col_to_add_list:
col_to_add_inter01_list.append("median")
if "sum" in col_to_add_list:
col_to_add_inter01_list.append("sum")
if "std" in col_to_add_list:
col_to_add_inter01_list.append("std")
if "unique" in col_to_add_list:
col_to_add_inter01_list.append("unique")
if "range" in col_to_add_list:
col_to_add_inter01_list.append("range")
# Copy de col_to_add_inter01_list dans col_to_add_inter02_list
col_to_add_inter02_list = list(col_to_add_inter01_list)
if "all" in col_to_add_list:
col_to_add_inter02_list.append("all")
if "count" in col_to_add_list:
col_to_add_inter02_list.append("count")
if "all_S" in col_to_add_list:
col_to_add_inter02_list.append("all_S")
if "count_S" in col_to_add_list:
col_to_add_inter02_list.append("count_S")
if "DateMaj" in col_to_add_inter02_list:
col_to_add_inter02_list.remove("DateMaj")
col_to_add_inter02_list.insert(0, "majority")
if "SrcMaj" in col_to_add_inter02_list:
col_to_add_inter02_list.remove("SrcMaj")
col_to_add_inter02_list.insert(0, "majority")
# Valeurs à injecter dans des colonnes - Format Nbr
if enable_stats_all_count:
stats_all_count_list = ['all_S', 'count_S']
for e in stats_all_count_list:
col_to_add_list.append(e)
# Creation de la colonne de l'identifiant unique
if ("UniqueID" in col_to_add_list) or ("uniqueID" in col_to_add_list) or (
"ID" in col_to_add_list):
field_defn = ogr.FieldDefn(
"ID", ogr.OFTInteger
) # Création du nom du champ dans l'objet stat_classif_field_defn
layer.CreateField(field_defn)
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + endC +
"Creation de la colonne : ID")
# Creation des colonnes de col_to_add_inter01_list ([majority/DateMaj/SrcMaj, minority, min, max, mean, median, sum, std, unique, range])
for col in col_to_add_list:
if layer_definition.GetFieldIndex(
col
) == -1: # Vérification de l'existence de la colonne col (retour = -1 : elle n'existe pas)
if col == 'majority' or col == 'DateMaj' or col == 'SrcMaj' or col == 'minority': # Identification de toutes les colonnes remplies en string
stat_classif_field_defn = ogr.FieldDefn(
col, ogr.OFTString
) # Création du champ (string) dans l'objet stat_classif_field_defn
layer.CreateField(stat_classif_field_defn)
elif col == 'mean' or col == 'median' or col == 'sum' or col == 'std' or col == 'unique' or col == 'range' or col == 'max' or col == 'min':
stat_classif_field_defn = ogr.FieldDefn(
col, ogr.OFTReal
) # Création du champ (real) dans l'objet stat_classif_field_defn
# Définition de la largeur du champ
stat_classif_field_defn.SetWidth(20)
# Définition de la précision du champ valeur flottante
stat_classif_field_defn.SetPrecision(2)
layer.CreateField(stat_classif_field_defn)
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + endC +
"Creation de la colonne : " + str(col))
# Creation des colonnes reliées au dictionnaire
if ('all' in col_to_add_list) or ('count' in col_to_add_list) or (
'all_S' in col_to_add_list) or ('count_S' in col_to_add_list):
for col in class_label_dico:
# Gestion du nom de la colonne correspondant à la classe
name_col = class_label_dico[col]
if len(name_col) > 10:
name_col = name_col[:10]
print(
cyan + "statisticsVectorRaster() : " + bold + yellow +
"Nom de la colonne trop long. Il sera tronque a 10 caracteres en cas d'utilisation: "
+ endC + name_col)
# Gestion du nom de la colonne correspondant à la surface de la classe
name_col_area = PREFIX_AREA_COLUMN + name_col
if len(name_col_area) > 10:
name_col_area = name_col_area[:10]
if debug >= 3:
print(
cyan + "statisticsVectorRaster() : " + bold + yellow +
"Nom de la colonne trop long. Il sera tronque a 10 caracteres en cas d'utilisation: "
+ endC + name_col_area)
# Ajout des colonnes de % de répartition des éléments du raster
if ('all' in col_to_add_list) or ('count' in col_to_add_list):
if layer_definition.GetFieldIndex(
name_col
) == -1: # Vérification de l'existence de la colonne name_col (retour = -1 : elle n'existe pas)
stat_classif_field_defn = ogr.FieldDefn(
name_col, ogr.OFTReal
) # Création du champ (real) dans l'objet stat_classif_field_defn
# Définition de la largeur du champ
stat_classif_field_defn.SetWidth(20)
# Définition de la précision du champ valeur flottante
stat_classif_field_defn.SetPrecision(2)
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + endC +
"Creation de la colonne : " + str(name_col))
layer.CreateField(
stat_classif_field_defn) # Ajout du champ
# Ajout des colonnes de surface des éléments du raster
if ('all_S' in col_to_add_list) or ('count_S' in col_to_add_list):
if layer_definition.GetFieldIndex(
name_col_area
) == -1: # Vérification de l'existence de la colonne name_col_area (retour = -1 : elle n'existe pas)
stat_classif_field_defn = ogr.FieldDefn(
name_col_area, ogr.OFTReal
) # Création du nom du champ dans l'objet stat_classif_field_defn
# Définition de la largeur du champ
stat_classif_field_defn.SetWidth(20)
# Définition de la précision du champ valeur flottante
stat_classif_field_defn.SetPrecision(2)
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + endC +
"Creation de la colonne : " + str(name_col_area))
layer.CreateField(
stat_classif_field_defn) # Ajout du champ
if debug >= 2:
print(
cyan + "statisticsVectorRaster() : " + bold + green +
"ETAPE 1/3 : FIN DE LA CREATION DES COLONNES DANS LE FICHIER VECTEUR %s"
% (vector_output) + endC)
# ETAPE 3/4 : REMPLISSAGE DES COLONNES DU VECTEUR
if debug >= 2:
print(cyan + "statisticsVectorRaster() : " + bold + green +
"ETAPE 2/3 : DEBUT DU REMPLISSAGE DES COLONNES DU VECTEUR " +
endC)
# Calcul des statistiques col_to_add_inter02_list = [majority, minority, min, max, mean, median, sum, std, unique, range, all, count, all_S, count_S] de croisement images_raster / vecteur
# Utilisation de la librairie rasterstat
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + bold + green +
"Calcul des statistiques " + endC +
"Stats : %s - Vecteur : %s - Raster : %s" %
(col_to_add_inter02_list, vector_output, image_input) + endC)
stats_info_list = raster_stats(vector_output,
image_input,
band_num=band_number,
stats=col_to_add_inter02_list)
# Decompte du nombre de polygones
num_features = layer.GetFeatureCount()
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + bold + green +
"Remplissage des colonnes polygone par polygone " + endC)
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + endC +
"Nombre total de polygones : " + str(num_features))
polygone_count = 0
for polygone_stats in stats_info_list: # Pour chaque polygone représenté dans stats_info_list - et il y a autant de polygone que dans le fichier vecteur
# Extraction de feature
feature = layer.GetFeature(polygone_stats['__fid__'])
polygone_count = polygone_count + 1
if debug >= 3 and polygone_count % 10000 == 0:
print(cyan + "statisticsVectorRaster() : " + endC +
"Avancement : %s polygones traites sur %s" %
(polygone_count, num_features))
if debug >= 5:
print(
cyan + "statisticsVectorRaster() : " + endC +
"Traitement du polygone : ",
stats_info_list.index(polygone_stats) + 1)
# Remplissage de l'identifiant unique
if ("UniqueID" in col_to_add_list) or (
"uniqueID" in col_to_add_list) or ("ID" in col_to_add_list):
feature.SetField('ID', int(stats_info_list.index(polygone_stats)))
# Initialisation à 0 des colonnes contenant le % de répartition de la classe - Verifier ce qu'il se passe si le nom dépasse 10 caracteres
if ('all' in col_to_add_list) or ('count' in col_to_add_list):
for element in class_label_dico:
name_col = class_label_dico[element]
if len(name_col) > 10:
name_col = name_col[:10]
feature.SetField(name_col, 0)
# Initialisation à 0 des colonnes contenant la surface correspondant à la classe - Verifier ce qu'il se passe si le nom dépasse 10 caracteres
if ('all_S' in col_to_add_list) or ('count_S' in col_to_add_list):
for element in class_label_dico:
name_col = class_label_dico[element]
name_col_area = PREFIX_AREA_COLUMN + name_col
if len(name_col_area) > 10:
name_col_area = name_col_area[:10]
feature.SetField(name_col_area, 0)
# Remplissage des colonnes contenant le % de répartition et la surface des classes
if ('all' in col_to_add_list) or ('count' in col_to_add_list) or (
'all_S' in col_to_add_list) or ('count_S' in col_to_add_list):
# 'all' est une liste des couples : (Valeur_du_pixel_sur_le_raster, Nbr_pixel_ayant_cette_valeur) pour le polygone observe.
# Ex : [(0,183),(803,45),(801,4)] : dans le polygone, il y a 183 pixels de valeur 0, 45 pixels de valeur 803 et 4 pixels de valeur 801
majority_all = polygone_stats['all']
# Deux valeurs de pixel peuvent faire référence à une même colonne. Par exemple : les pixels à 201, 202, 203 peuvent correspondre à la BD Topo
# Regroupement des éléments de majority_all allant dans la même colonne au regard de class_label_dico
count_for_idx_couple = 0 # Comptage du nombre de modifications (suppression de couple) de majority_all pour adapter la valeur de l'index lors de son parcours
for idx_couple in range(
1, len(majority_all)
): # Inutile d'appliquer le traitement au premier élément (idx_couple == 0)
idx_couple = idx_couple - count_for_idx_couple # Prise en compte dans le parcours de majority_all des couples supprimés
couple = majority_all[idx_couple] # Ex : couple = (803,45)
if (couple is None) or (
couple == ""
): # en cas de bug de rasterstats (erreur geometrique du polygone par exemple)
if debug >= 3:
print(
cyan + "statisticsVectorRaster() : " + bold + red +
"Probleme detecte dans la gestion du polygone %s" %
(polygone_count) + endC,
file=sys.stderr)
pass
else:
for idx_verif in range(idx_couple):
# Vérification au regard des éléments présents en amont dans majority_all
# Cas où le nom correspondant au label a déjà été rencontré dans majority_all
# Vérification que les pixels de l'image sont réferncés dans le dico
if couple[0] in class_label_dico:
if class_label_dico[couple[0]] == class_label_dico[
majority_all[idx_verif][0]]:
majority_all[idx_verif] = (
majority_all[idx_verif][0],
majority_all[idx_verif][1] + couple[1]
) # Ajout du nombre de pixels correspondant dans le couple précédent
majority_all.remove(
couple
) # Supression du couple présentant le "doublon"
count_for_idx_couple = count_for_idx_couple + 1 # Mise à jour du décompte de modifications
break
else:
raise NameError(
cyan + "statisticsVectorRaster() : " + bold +
red +
"The image file (%s) contain pixel value '%d' not identified into class_label_dico"
% (image_input, couple[0]) + endC)
# Intégration des valeurs de majority all dans les colonnes
for couple_value_count in majority_all: # Parcours de majority_all. Ex : couple_value_count = (803,45)
if (couple_value_count is None) or (
couple_value_count == ""
): # en cas de bug de rasterstats (erreur geometrique du polygone par exemple)
if debug >= 3:
print(
cyan + "statisticsVectorRaster() : " + bold + red +
"Probleme detecte dans la gestion du polygone %s" %
(polygone_count) + endC,
file=sys.stderr)
pass
else:
nb_pixel_total = polygone_stats[
'count'] # Nbr de pixels du polygone
pixel_value = couple_value_count[0] # Valeur du pixel
value_count = couple_value_count[
1] # Nbr de pixels ayant cette valeur
name_col = class_label_dico[
pixel_value] # Transformation de la valeur du pixel en "signification" au regard du dictionnaire. Ex : BD Topo ou 2011
name_col_area = PREFIX_AREA_COLUMN + name_col # Identification du nom de la colonne en surfaces
if len(name_col) > 10:
name_col = name_col[:10]
if len(name_col_area) > 10:
name_col_area = name_col_area[:10]
value_area = pixel_size * value_count # Calcul de la surface du polygone correspondant à la valeur du pixel
if nb_pixel_total != None and nb_pixel_total != 0:
percentage = (
float(value_count) / float(nb_pixel_total)
) * 100 # Conversion de la surface en pourcentages, arondi au pourcent
else:
if debug >= 3:
print(
cyan + "statisticsVectorRaster() : " + bold +
red +
"Probleme dans l'identification du nombre de pixels du polygone %s : le pourcentage de %s est mis à 0"
% (polygone_count, name_col) + endC,
file=sys.stderr)
percentage = 0.0
if ('all' in col_to_add_list) or ('count'
in col_to_add_list):
feature.SetField(
name_col, percentage
) # Injection du pourcentage dans la colonne correpondante
if ('all_S' in col_to_add_list) or ('count_S'
in col_to_add_list):
feature.SetField(
name_col_area, value_area
) # Injection de la surface dans la colonne correpondante
else:
pass
# Remplissage des colonnes statistiques demandées ( col_to_add_inter01_list = [majority/DateMaj/SrcMaj, minority, min, max, mean, median, sum, std, unique, range] )
for stats in col_to_add_inter01_list:
if stats == 'DateMaj' or stats == 'SrcMaj': # Cas particulier de 'DateMaj' et 'SrcMaj' : le nom de la colonne est DateMaj ou SrcMaj, mais la statistique utilisée est identifiée par majority
name_col = stats # Nom de la colonne. Ex : 'DateMaj'
value_statis = polygone_stats[
'majority'] # Valeur majoritaire. Ex : '203'
if value_statis == None:
value_statis_class = 'nan'
else:
value_statis_class = class_label_dico[
value_statis] # Transformation de la valeur au regard du dictionnaire. Ex : '2011'
feature.SetField(name_col,
value_statis_class) # Ajout dans la colonne
elif (stats is None) or (stats == "") or (
polygone_stats[stats] is
None) or (polygone_stats[stats]) == "" or (
polygone_stats[stats]) == 'nan':
# En cas de bug de rasterstats (erreur geometrique du polygone par exemple)
pass
else:
name_col = stats # Nom de la colonne. Ex : 'majority', 'max'
value_statis = polygone_stats[
stats] # Valeur à associer à la colonne, par exemple '2011'
if (
name_col == 'majority' or name_col == 'minority'
) and class_label_dico != []: # Cas où la colonne fait référence à une valeur du dictionnaire
value_statis_class = class_label_dico[value_statis]
else:
value_statis_class = value_statis
feature.SetField(name_col, value_statis_class)
layer.SetFeature(feature)
feature.Destroy()
if debug >= 2:
print(cyan + "statisticsVectorRaster() : " + bold + green +
"ETAPE 2/3 : FIN DU REMPLISSAGE DES COLONNES DU VECTEUR %s" %
(vector_output) + endC)
# ETAPE 4/4 : SUPRESSION DES COLONNES NON SOUHAITEES
if col_to_delete_list != []:
if debug >= 2:
print(cyan + "statisticsVectorRaster() : " + bold + green +
"ETAPE 3/3 : DEBUT DES SUPPRESSIONS DES COLONNES %s" %
(col_to_delete_list) + endC)
for col_to_delete in col_to_delete_list:
if layer_definition.GetFieldIndex(
col_to_delete
) != -1: # Vérification de l'existence de la colonne col (retour = -1 : elle n'existe pas)
layer.DeleteField(layer_definition.GetFieldIndex(
col_to_delete)) # Suppression de la colonne
if debug >= 3:
print(cyan + "statisticsVectorRaster() : " + endC +
"Suppression de %s" % (col_to_delete) + endC)
if debug >= 2:
print(cyan + "statisticsVectorRaster() : " + bold + green +
"ETAPE 3/3 : FIN DE LA SUPPRESSION DES COLONNES" + endC)
else:
print(cyan + "statisticsVectorRaster() : " + bold + yellow +
"ETAPE 3/3 : AUCUNE SUPPRESSION DE COLONNE DEMANDEE" + endC)
# Fermeture du fichier shape
layer.SyncToDisk()
layer = None
data_source.Destroy()
# Mise à jour du Log
ending_event = "statisticsVectorRaster() : Compute statistic crossing ending : "
timeLine(path_time_log, ending_event)
return
def prepareData(input_buffer_tdc, input_paysage, output_dir, input_repertories_list, id_paysage, id_name_sub_rep, epsg, optimization_zone, no_cover, zone_date, separ_name, pos_date, nb_char_date, separ_date, path_time_log, format_raster='GTiff', format_vector="ESRI Shapefile", extension_raster=".tif", extension_vector=".shp", save_results_intermediate=True, overwrite=True):
# Mise à jour du Log
starting_event = "prepareData() : Select prepare data starting : "
timeLine(path_time_log,starting_event)
# Affichage des paramètres
if debug >= 3:
print(bold + green + "Variables dans le prepareData - Variables générales" + endC)
print(cyan + "PrepareData() : " + endC + "input_buffer_tdc : " + str(input_buffer_tdc) + endC)
print(cyan + "PrepareData() : " + endC + "input_paysage : " + str(input_paysage) + endC)
print(cyan + "PrepareData() : " + endC + "output_dir : " + str(output_dir) + endC)
print(cyan + "PrepareData() : " + endC + "input_repertories_list : " + str(input_repertories_list) + endC)
print(cyan + "PrepareData() : " + endC + "id_paysage : " + str(id_paysage) + endC)
print(cyan + "PrepareData() : " + endC + "id_name_sub_rep : " + str(id_name_sub_rep) + endC)
print(cyan + "PrepareData() : " + endC + "epsg : " + str(epsg) +endC)
print(cyan + "PrepareData() : " + endC + "optimization_zone : " + str(optimization_zone) + endC)
print(cyan + "PrepareData() : " + endC + "no_cover : " + str(no_cover) + endC)
print(cyan + "PrepareData() : " + endC + "zone_date : " + str(zone_date) + endC)
print(cyan + "PrepareData() : " + endC + "separ_name : " + str(separ_name) + endC)
print(cyan + "PrepareData() : " + endC + "pos_date : " + str(pos_date) + endC)
print(cyan + "PrepareData() : " + endC + "nb_char_date : " + str(nb_char_date) + endC)
print(cyan + "PrepareData() : " + endC + "separ_date : " + str(separ_date) + endC)
print(cyan + "PrepareData() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "PrepareData() : " + endC + "format_raster : " + str(format_raster) + endC)
print(cyan + "PrepareData() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "PrepareData() : " + endC + "extension_raster : " + str(extension_raster) + endC)
print(cyan + "PrepareData() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "PrepareData() : " + endC + "save_results_inter : " + str(save_results_intermediate) + endC)
print(cyan + "PrepareData() : " + endC + "overwrite : " + str(overwrite) + endC)
REPERTORY_PAYSAGES = "Paysages"
REPERTORY_IMAGES = "Images"
ID_P = "id_p"
SUFFIX_OPTI = "_opti"
SUFFIX_CUT = "_cut"
SUFFIX_ERROR = "_error"
SUFFIX_MERGE = "_merge"
SUFFIX_CLEAN = "_clean"
SUFFIX_STACK = "_stack"
output_dir_paysages = output_dir + os.sep + REPERTORY_PAYSAGES
output_dir_images = output_dir + os.sep + REPERTORY_IMAGES
# Création du répertoire de sortie s'il n'existe pas déjà
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Création du répertoire de sortie pour les paysages s'il n'existe pas
if not os.path.exists(output_dir_paysages):
os.makedirs(output_dir_paysages)
# Création du répertoire de sortie pour les images s'il n'existe pas
if not os.path.exists(output_dir_images):
os.makedirs(output_dir_images)
# Recuperer l'epsg du fichier d'emprise
if epsg == 0 :
epsg = getProjection(input_paysage, format_vector)
# Création du paysage optimal
optimPaysage(input_buffer_tdc, input_paysage, optimization_zone, SUFFIX_OPTI, output_dir_paysages, id_paysage, format_vector)
# Création un shapefile par polygone
paysage_opti = output_dir_paysages + os.sep + os.path.splitext(os.path.basename(input_paysage))[0] + SUFFIX_OPTI + os.path.splitext(input_paysage)[1]
if id_paysage != "" :
paysages_list = splitVector(paysage_opti, str(output_dir_paysages), str(id_paysage), epsg, format_vector, extension_vector)
else:
paysages_list = splitVector(paysage_opti, str(output_dir_paysages), ID_P, epsg, format_vector, extension_vector)
if debug >= 3:
print(cyan + "PrepareData() : " + endC + "Liste des fichiers en entrée de imagesAssembly() : " + str(paysages_list))
# Création du fichier de sortie des images s'il n'existe pas dejà
if not os.path.exists(output_dir_images):
os.makedirs(output_dir_images)
# Assemblage des images dans les paysages optimisés
# Si on choisit pas de recouvrement entre les images
if no_cover:
# Récupération des noms de sortie
image_output_list = []
id_paysage_list = []
for shape in paysages_list :
attribute_name_dico = {}
attribute_name_dico[id_name_sub_rep] = ogr.OFTString
attribute_name_dico[id_paysage] = ogr.OFTInteger
res_values_dico = getAttributeValues(shape, None, None, attribute_name_dico, format_vector)
id_name_sub_rep_value = res_values_dico[id_name_sub_rep][0]
id_paysage_value = res_values_dico[id_paysage][0]
image_output_list.append(id_name_sub_rep_value)
id_paysage_list.append(id_paysage_value)
if debug >= 3:
print("image_output_list " + str(image_output_list))
# Récupération de tous les (sous-)répertoires
repertory_images_sources_list_temp = []
for input_dir in input_repertories_list:
sub_rep_list = getSubRepRecursifList(input_dir)
if sub_rep_list != []:
for sub_rep in sub_rep_list:
repertory_images_sources_list_temp.append(sub_rep)
else:
repertory_images_sources_list_temp.append(input_dir)
# On réorganise pour avoir le même ordre dans les 2 listes 'repertory_images_sources_list' et 'image_output_list'
repertory_images_sources_list = []
for paysage in id_paysage_list:
for repertory_images_source in repertory_images_sources_list_temp:
if str(paysage) in repertory_images_source.split(os.sep)[-1]:
repertory_images_sources_list.append(repertory_images_source)
if debug >= 3:
print("repertory_images_sources_list " + str(repertory_images_sources_list))
if len(repertory_images_sources_list) != len(image_output_list):
raise Exception(bold + red + "Error: not same number of input repertories and output files." + endC)
# Commande ImagesAssembly sur les éléments des 2 listes
for i in range(len(paysages_list)):
image_output = output_dir_images + os.sep + image_output_list[i]
if debug >= 3:
print(cyan + "PrepareData() : " + endC + bold + green + "image_output : " + endC + image_output)
try:
# ~ selectAssembyImagesByHold(paysages_list[i], [repertory_images_sources_list[i]], image_output, False, True, epsg, False, False, False, False, 0, 0, 0, 0, separ_name, pos_date, nb_char_date, separ_date, path_time_log, SUFFIX_ERROR, SUFFIX_MERGE, SUFFIX_CLEAN, SUFFIX_STACK, format_raster, format_vector, extension_raster, extension_vector, save_results_intermediate, overwrite)
selectAssembyImagesByHold(paysages_list[i], [repertory_images_sources_list[i]], image_output, False, zone_date, epsg, False, False, False, False, 0, 0, 0, 0, separ_name, pos_date, nb_char_date, separ_date, path_time_log, SUFFIX_ERROR, SUFFIX_MERGE, SUFFIX_CLEAN, SUFFIX_STACK, format_raster, format_vector, extension_raster, extension_vector, save_results_intermediate, overwrite)
except Exception:
pass
else:
for shape in paysages_list :
# ~ filename = os.path.basename(shape)
# ~ info_name = filename.split(separ_name, 2)[POS]
# ~ name_shape = info_name[:NB_CHAR]
# ~ image_output = output_dir_images + os.sep + name_shape + SUFFIX_ASS + extension_raster
# ~ for shape in sub_repertory_images_paysages_list :
image_output = output_dir_images + os.sep + os.path.splitext(os.path.basename(shape)) + extension_raster
if optimization_zone :
shape_cut = os.path.splitext(shape)[0] + SUFFIX_CUT + os.path.splitext(shape)[1]
cutVector(input_buffer_tdc, shape, shape_cut, overwrite, format_vector)
else :
shape_cut = shape
selectAssembyImagesByHold(shape_cut, input_repertories_list, image_output, False, zone_date, epsg, False, False, False, False, 0, 0, 0, 0, separ_name, pos_date, nb_char_date, separ_date, path_time_log, SUFFIX_ERROR, SUFFIX_MERGE, SUFFIX_CLEAN, SUFFIX_STACK, format_raster, format_vector, save_results_intermediate, overwrite)
if optimization_zone and os.path.exists(shape_cut):
removeVectorFile(shape_cut, format_vector)
# Mise à jour du Log
ending_event = "prepareData() : Select prepare data ending : "
timeLine(path_time_log,ending_event)
if debug >= 3:
print(cyan + "PrepareData() : " + endC + bold + green + "Fin de traitement")
return
def classesOfWaterHeights(input_flooded_areas_vector,
input_digital_elevation_model_file,
output_heights_classes_file,
output_heights_classes_vector,
heights_classes='0,0.5,1,1.5,2',
epsg=2154,
no_data_value=0,
format_raster='GTiff',
format_vector='ESRI Shapefile',
extension_raster='.tif',
extension_vector='.shp',
grass_gisbase=os.environ['GISBASE'],
grass_gisdb='GRASS_database',
grass_location='LOCATION',
grass_mapset='MAPSET',
path_time_log='',
save_results_intermediate=False,
overwrite=True):
if debug >= 3:
print('\n' + bold + green +
"Classes de hauteurs d'eau - Variables dans la fonction :" +
endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"input_flooded_areas_vector : " +
str(input_flooded_areas_vector) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"input_digital_elevation_model_file : " +
str(input_digital_elevation_model_file) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"output_heights_classes_file : " +
str(output_heights_classes_file) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"output_heights_classes_vector : " +
str(output_heights_classes_vector) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"heights_classes : " + str(heights_classes) + endC)
print(cyan + " classesOfWaterHeights() : " + endC + "epsg : " +
str(epsg) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"no_data_value : " + str(no_data_value) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"format_raster : " + str(format_raster) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"format_vector : " + str(format_vector) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"extension_raster : " + str(extension_raster) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"extension_vector : " + str(extension_vector) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"grass_gisbase : " + str(grass_gisbase) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"grass_gisdb : " + str(grass_gisdb) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"grass_location : " + str(grass_location) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"grass_mapset : " + str(grass_mapset) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"path_time_log : " + str(path_time_log) + endC)
print(cyan + " classesOfWaterHeights() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + " classesOfWaterHeights() : " + endC + "overwrite : " +
str(overwrite) + endC + '\n')
# Définition des constantes
ENCODING_RASTER_FLOAT = 'float'
ENCODING_RASTER_UINT8 = 'uint8'
EXTENSION_RASTER_SAGA = '.sdat'
FORMAT_VECTOR_GRASS = format_vector.replace(' ', '_')
SUFFIX_TEMP = '_temp'
SUFFIX_LINES = '_lines'
SUFFIX_POINTS = '_points'
SUFFIX_ALTI = '_altitude'
SUFFIX_CUT = '_cut'
SUFFIX_RAW = '_raw_heights'
INDEX_FIELD = 'idx'
ALTI_FIELD = 'altitude'
VECTORISATION = 'GRASS'
# Mise à jour du log
starting_event = "classesOfWaterHeights() : Début du traitement : "
timeLine(path_time_log, starting_event)
print(cyan + "classesOfWaterHeights() : " + bold + green +
"DEBUT DES TRAITEMENTS" + endC + '\n')
# Définition des variables 'basename'
flooded_areas_basename = os.path.splitext(
os.path.basename(input_flooded_areas_vector))[0]
digital_elevation_model_basename = os.path.splitext(
os.path.basename(input_digital_elevation_model_file))[0]
flooded_areas_lines_basename = flooded_areas_basename + SUFFIX_LINES
flooded_areas_points_basename = flooded_areas_basename + SUFFIX_POINTS
if output_heights_classes_file != "":
output_heights_classes_basename = os.path.splitext(
os.path.basename(output_heights_classes_file))[0]
output_dirname = os.path.dirname(output_heights_classes_file)
else:
output_heights_classes_basename = os.path.splitext(
os.path.basename(output_heights_classes_vector))[0]
output_dirname = os.path.dirname(output_heights_classes_vector)
# Définition des variables temp
temp_directory = output_dirname + os.sep + output_heights_classes_basename + SUFFIX_TEMP
flooded_areas_lines = temp_directory + os.sep + flooded_areas_lines_basename + extension_vector
flooded_areas_points = temp_directory + os.sep + flooded_areas_points_basename + extension_vector
altitude_points = temp_directory + os.sep + flooded_areas_points_basename + SUFFIX_ALTI + extension_vector
altitude_grid = temp_directory + os.sep + flooded_areas_basename + SUFFIX_ALTI + EXTENSION_RASTER_SAGA
altitude_file = temp_directory + os.sep + flooded_areas_basename + SUFFIX_ALTI + SUFFIX_CUT + extension_raster
digital_elevation_model_cut = temp_directory + os.sep + digital_elevation_model_basename + SUFFIX_CUT + extension_raster
raw_heights = temp_directory + os.sep + flooded_areas_basename + SUFFIX_RAW + extension_raster
heights_classes_temp = temp_directory + os.sep + output_heights_classes_basename + extension_raster
if output_heights_classes_file == "":
output_heights_classes_file = output_dirname + os.sep + output_heights_classes_basename + extension_raster
# Nettoyage des traitements précédents
if debug >= 3:
print(cyan + "classesOfWaterHeights() : " + endC +
"Nettoyage des traitements précédents." + endC + '\n')
removeFile(output_heights_classes_file)
removeVectorFile(output_heights_classes_vector,
format_vector=format_vector)
cleanTempData(temp_directory)
#############
# Etape 0/6 # Préparation des traitements
#############
print(cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 0/6 - Début de la préparation des traitements." + endC + '\n')
# Préparation de GRASS
xmin, xmax, ymin, ymax = getEmpriseImage(
input_digital_elevation_model_file)
pixel_width, pixel_height = getPixelWidthXYImage(
input_digital_elevation_model_file)
grass_gisbase, grass_gisdb, grass_location, grass_mapset = initializeGrass(
temp_directory,
xmin,
xmax,
ymin,
ymax,
pixel_width,
pixel_height,
projection=epsg,
gisbase=grass_gisbase,
gisdb=grass_gisdb,
location=grass_location,
mapset=grass_mapset,
clean_old=True,
overwrite=overwrite)
# Gestion des classes de hauteurs d'eau
thresholds_list = heights_classes.split(',')
thresholds_list_float = [float(x) for x in thresholds_list]
thresholds_list_float.sort()
thresholds_list_float_len = len(thresholds_list_float)
print(cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 0/6 - Fin de la préparation des traitements." + endC + '\n')
#############
# Etape 1/6 # Création de points sur le périmètre de l'emprise inondée
#############
print(
cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 1/6 - Début de la création de points sur le périmètre de l'emprise inondée."
+ endC + '\n')
# Conversion de l'emprise inondée en polylignes
convertePolygon2Polylines(input_flooded_areas_vector,
flooded_areas_lines,
overwrite=overwrite,
format_vector=format_vector)
# Création de points le long du polyligne
use = 'vertex'
dmax = 10
percent = False
importVectorOgr2Grass(flooded_areas_lines,
flooded_areas_lines_basename,
overwrite=overwrite)
pointsAlongPolylines(flooded_areas_lines_basename,
flooded_areas_points_basename,
use=use,
dmax=dmax,
percent=percent,
overwrite=overwrite)
exportVectorOgr2Grass(flooded_areas_points_basename,
flooded_areas_points,
format_vector=FORMAT_VECTOR_GRASS,
overwrite=overwrite)
# Ajout d'un index sur les points
addNewFieldVector(flooded_areas_points,
INDEX_FIELD,
ogr.OFTInteger,
field_value=None,
field_width=None,
field_precision=None,
format_vector=format_vector)
updateIndexVector(flooded_areas_points,
index_name=INDEX_FIELD,
format_vector=format_vector)
print(
cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 1/6 - Fin de la création de points sur le périmètre de l'emprise inondée."
+ endC + '\n')
#############
# Etape 2/6 # Récupération de l'altitude sous chaque point
#############
print(
cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 2/6 - Début de la récupération de l'altitude sous chaque point."
+ endC + '\n')
# Ajout d'un champ pour récupérer l'altitude
addNewFieldVector(flooded_areas_points,
ALTI_FIELD,
ogr.OFTReal,
field_value=None,
field_width=None,
field_precision=None,
format_vector=format_vector)
# Echantillonnage du MNT sous le fichier points
importVectorOgr2Grass(flooded_areas_points,
flooded_areas_points_basename,
overwrite=overwrite)
importRasterGdal2Grass(input_digital_elevation_model_file,
digital_elevation_model_basename,
overwrite=overwrite)
sampleRasterUnderPoints(flooded_areas_points_basename,
digital_elevation_model_basename,
ALTI_FIELD,
overwrite=overwrite)
exportVectorOgr2Grass(flooded_areas_points_basename,
altitude_points,
format_vector=FORMAT_VECTOR_GRASS,
overwrite=overwrite)
print(
cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 2/6 - Fin de la récupération de l'altitude sous chaque point." +
endC + '\n')
#############
# Etape 3/6 # Triangulation de l'altitude
#############
print(cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 3/6 - Début de la triangulation de l'altitude." + endC + '\n')
pixel_size = abs(min(pixel_width, pixel_height))
triangulationDelaunay(altitude_points,
altitude_grid,
ALTI_FIELD,
cellsize=pixel_size)
print(cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 3/6 - Fin de la triangulation de l'altitude." + endC + '\n')
#############
# Etape 4/6 # Calcul des hauteurs brutes
#############
print(cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 4/6 - Début du calcul des hauteurs brutes." + endC + '\n')
# Redécoupage sur l'emprise inondée
cutRasterImages([altitude_grid, input_digital_elevation_model_file],
input_flooded_areas_vector,
[altitude_file, digital_elevation_model_cut],
0,
0,
epsg,
no_data_value,
"",
False,
path_time_log,
format_raster=format_raster,
format_vector=format_vector,
extension_raster=extension_raster,
extension_vector=extension_vector,
save_results_intermediate=save_results_intermediate,
overwrite=overwrite)
# BandMath pour les hauteurs brutes (triangulation - MNT)
expression = "im1b1 - im2b1"
rasterCalculator([altitude_file, digital_elevation_model_cut],
raw_heights,
expression,
codage=ENCODING_RASTER_FLOAT)
print(cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 4/6 - Fin du calcul des hauteurs brutes." + endC + '\n')
#############
# Etape 5/6 # Attribution des classes de hauteurs d'eau
#############
print(cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 5/6 - Début de l'attribution des classes de hauteurs d'eau." +
endC + '\n')
# Génération de l'expression
expression = ""
for i in range(thresholds_list_float_len - 1):
min_threshold = thresholds_list_float[i]
max_threshold = thresholds_list_float[i + 1]
expression += "im1b1>=%s and im1b1<%s ? %s : " % (min_threshold,
max_threshold, i + 1)
expression += "im1b1>=%s ? %s : 0" % (thresholds_list_float[
thresholds_list_float_len - 1], thresholds_list_float_len)
# Calcul des classes de hauteurs d'eau
rasterCalculator([raw_heights],
heights_classes_temp,
expression,
codage=ENCODING_RASTER_UINT8)
# Redécoupage propre des zones en dehors de l'emprise inondée
cutImageByVector(input_flooded_areas_vector,
heights_classes_temp,
output_heights_classes_file,
pixel_size_x=pixel_width,
pixel_size_y=pixel_height,
no_data_value=no_data_value,
epsg=epsg,
format_raster=format_raster,
format_vector=format_vector)
print(cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 5/6 - Fin de l'attribution des classes de hauteurs d'eau." +
endC + '\n')
#############
# Etape 6/6 # Vectorisation des classes de hauteurs d'eau
#############
if output_heights_classes_vector != "":
print(
cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 6/6 - Début de la vectorisation des classes de hauteurs d'eau."
+ endC + '\n')
name_column = 'class'
umc_list = 0
if VECTORISATION == 'GRASS':
vectorizeGrassClassification(
output_heights_classes_file,
output_heights_classes_vector,
name_column, [umc_list],
False,
True,
True,
input_flooded_areas_vector,
True,
path_time_log,
expression="",
format_vector=format_vector,
extension_raster=extension_raster,
extension_vector=extension_vector,
save_results_intermediate=save_results_intermediate,
overwrite=overwrite)
else:
vectorizeClassification(
output_heights_classes_file,
output_heights_classes_vector,
name_column, [umc_list],
2000,
False,
True,
True,
True,
True,
True,
input_flooded_areas_vector,
True,
False,
False, [0],
path_time_log,
expression="",
format_vector=format_vector,
extension_raster=extension_raster,
extension_vector=extension_vector,
save_results_intermediate=save_results_intermediate,
overwrite=overwrite)
print(
cyan + "classesOfWaterHeights() : " + bold + green +
"ETAPE 6/6 - Fin de la vectorisation des classes de hauteurs d'eau."
+ endC + '\n')
else:
print(
cyan + "classesOfWaterHeights() : " + bold + yellow +
"ETAPE 6/6 - Pas de vectorisation des classes de hauteurs d'eau demandée."
+ endC + '\n')
# Suppression des fichiers temporaires
if not save_results_intermediate:
if debug >= 3:
print(cyan + "classesOfWaterHeights() : " + endC +
"Suppression des fichiers temporaires." + endC + '\n')
deleteDir(temp_directory)
print(cyan + "classesOfWaterHeights() : " + bold + green +
"FIN DES TRAITEMENTS" + endC + '\n')
# Mise à jour du log
ending_event = "classesOfWaterHeights() : Fin du traitement : "
timeLine(path_time_log, ending_event)
return
def aspectRatio(grid_input,
grid_output,
roads_input,
built_input,
seg_dist,
seg_length,
buffer_size,
epsg,
project_encoding,
server_postgis,
port_number,
user_postgis,
password_postgis,
database_postgis,
schema_postgis,
path_time_log,
format_vector='ESRI Shapefile',
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
print(bold + yellow + "Début du calcul de l'indicateur Aspect Ratio." +
endC + "\n")
timeLine(path_time_log, "Début du calcul de l'indicateur Aspect Ratio : ")
if debug >= 3:
print(bold + green + "aspectRatio() : Variables dans la fonction" +
endC)
print(cyan + "aspectRatio() : " + endC + "grid_input : " +
str(grid_input) + endC)
print(cyan + "aspectRatio() : " + endC + "grid_output : " +
str(grid_output) + endC)
print(cyan + "aspectRatio() : " + endC + "roads_input : " +
str(roads_input) + endC)
print(cyan + "aspectRatio() : " + endC + "built_input : " +
str(built_input) + endC)
print(cyan + "aspectRatio() : " + endC + "seg_dist : " +
str(seg_dist) + endC)
print(cyan + "aspectRatio() : " + endC + "seg_length : " +
str(seg_length) + endC)
print(cyan + "aspectRatio() : " + endC + "buffer_size : " +
str(buffer_size) + endC)
print(cyan + "aspectRatio() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + "aspectRatio() : " + endC + "project_encoding : " +
str(project_encoding) + endC)
print(cyan + "aspectRatio() : " + endC + "server_postgis : " +
str(server_postgis) + endC)
print(cyan + "aspectRatio() : " + endC + "port_number : " +
str(port_number) + endC)
print(cyan + "aspectRatio() : " + endC + "user_postgis : " +
str(user_postgis) + endC)
print(cyan + "aspectRatio() : " + endC + "password_postgis : " +
str(password_postgis) + endC)
print(cyan + "aspectRatio() : " + endC + "database_postgis : " +
str(database_postgis) + endC)
print(cyan + "aspectRatio() : " + endC + "schema_postgis : " +
str(schema_postgis) + endC)
print(cyan + "aspectRatio() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "aspectRatio() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "aspectRatio() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "aspectRatio() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "aspectRatio() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Constantes liées aux données PostGIS et GRASS
LOCATION = "LOCATION"
MAPSET = "MAPSET"
SUFFIX_SEGMENTED = "_segmented"
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 + "AspectRatio"
file_name = os.path.splitext(os.path.basename(roads_input))[0]
roads_segmented = temp_path + os.sep + file_name + SUFFIX_SEGMENTED + extension_vector
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
# Variables d'environnement spécifiques à GRASS
gisbase = os.environ['GISBASE']
gisdb = "GRASS_database"
# Variables liées à GRASS permettant la construction de 'LOCATION' et 'MAPSET'
xmin, xmax, ymin, ymax = getEmpriseFile(roads_input, format_vector)
pixel_size_x, pixel_size_y = 1, 1
#####################################
### Préparation géodatabase GRASS ###
#####################################
print(bold + cyan + "Préparation de la géodatabase GRASS :" + endC)
timeLine(path_time_log, " Préparation de la géodatabase GRASS : ")
# Initialisation de la connexion à la géodatabase GRASS
gisbase, gisdb, location, mapset = initializeGrass(
temp_path, xmin, xmax, ymin, ymax, pixel_size_x, pixel_size_y,
epsg, gisbase, gisdb, LOCATION, MAPSET, True, overwrite)
###################################################
### Division des routes en segments de x mètres ###
###################################################
print(bold + cyan + "Segmentation des routes avec GRASS :" + endC)
timeLine(path_time_log, " Segmentation des routes avec GRASS : ")
# Segmentation du jeu de données route en segments de x mètres
splitGrass(roads_input, roads_segmented, seg_dist, format_vector,
overwrite)
cleanGrass(temp_path, gisdb, save_results_intermediate)
###########################################
### Préparation base de données PostGIS ###
###########################################
print(bold + cyan + "Préparation de la base de données PostGIS :" +
endC)
timeLine(path_time_log,
" Préparation de la base de données PostGIS : ")
# Création de la base de données PostGIS
# Conflits avec autres indicateurs (Height of Roughness Elements / Terrain Roughness Class)
createDatabase(database_postgis)
# Import des fichiers shapes maille, bati et routes segmentées dans la base de données PostGIS
table_name_maille = importVectorByOgr2ogr(database_postgis,
grid_input,
'ara_maille',
user_name=user_postgis,
password=password_postgis,
ip_host=server_postgis,
num_port=str(port_number),
schema_name=schema_postgis,
epsg=str(epsg),
codage=project_encoding)
table_name_bati = importVectorByOgr2ogr(database_postgis,
built_input,
'ara_bati',
user_name=user_postgis,
password=password_postgis,
ip_host=server_postgis,
num_port=str(port_number),
schema_name=schema_postgis,
epsg=str(epsg),
codage=project_encoding)
table_name_routes_seg = importVectorByOgr2ogr(
database_postgis,
roads_segmented,
'ara_routes_seg',
user_name=user_postgis,
password=password_postgis,
ip_host=server_postgis,
num_port=str(port_number),
schema_name=schema_postgis,
epsg=str(epsg),
codage=project_encoding)
# Connection à la base de données PostGIS et initialisation de 'cursor' (permet de récupérer des résultats de requêtes SQL pour les traiter en Python)
connection = openConnection(database_postgis,
user_postgis,
password_postgis,
server_postgis,
str(port_number),
schema_name=schema_postgis)
cursor = connection.cursor()
# Requête d'ajout de champ ID segment route dans la table routes_seg et création des index pour les shapes importés
query_preparation = """
ALTER TABLE %s ADD COLUMN id_seg serial;
--CREATE INDEX IF NOT EXISTS routes_seg_geom_gist ON %s USING GIST (geom);
--CREATE INDEX IF NOT EXISTS bati_geom_gist ON %s USING GIST (geom);
--CREATE INDEX IF NOT EXISTS maille_geom_gist ON %s USING GIST (geom);
""" % (table_name_routes_seg, table_name_routes_seg, table_name_bati,
table_name_maille)
if debug >= 2:
print(query_preparation)
executeQuery(connection, query_preparation)
##############################################################################
### Création des segments de y mètres perpendiculaires aux segments routes ###
##############################################################################
print(bold + cyan +
"Création des segments perpendiculaires aux routes :" + endC)
timeLine(path_time_log,
" Création des segments perpendiculaires aux routes : ")
# Début de la construction de la requête de création des segments perpendiculaires
query_seg_perp = "DROP TABLE IF EXISTS ara_seg_perp;\n"
query_seg_perp += "CREATE TABLE ara_seg_perp (id_seg text, id_perp text, xR float, yR float, xP float, yP float, geom geometry);\n"
query_seg_perp += "INSERT INTO ara_seg_perp VALUES\n"
# Récupération de la liste des identifiants segments routes
cursor.execute(
"SELECT id_seg FROM %s GROUP BY id_seg ORDER BY id_seg;" %
table_name_routes_seg)
id_seg_list = cursor.fetchall()
# Boucle sur les segments routes
nb_seg = len(id_seg_list)
treat_seg = 1
for id_seg in id_seg_list:
if debug >= 4:
print(bold + " Traitement du segment route : " + endC +
str(treat_seg) + "/" + str(nb_seg))
id_seg = id_seg[0]
# Table temporaire ne contenant qu'un segment route donné : ST_LineMerge(geom) permet de passer la géométrie de MultiLineString à LineString, pour éviter des problèmes de requêtes spatiales
query_temp1_seg = "DROP TABLE IF EXISTS ara_temp1_seg;\n"
query_temp1_seg += "CREATE TABLE ara_temp1_seg AS SELECT id_seg as id_seg, ST_LineMerge(geom) as geom FROM %s WHERE id_seg = %s;\n" % (
table_name_routes_seg, id_seg)
if debug >= 4:
print(query_temp1_seg)
executeQuery(connection, query_temp1_seg)
# Récupération du nombre de sommets du segment route (utile pour les segments routes en courbe, permet de récupérer le dernier point du segment)
cursor.execute("SELECT ST_NPoints(geom) FROM ara_temp1_seg;")
nb_points = cursor.fetchone()
# Récupération des coordonnées X et Y des points extrémités du segment route
query_xR1 = "SELECT ST_X(geom) as X FROM (SELECT ST_AsText(ST_PointN(geom,1)) as geom FROM ara_temp1_seg) as toto;"
cursor.execute(query_xR1)
xR1 = cursor.fetchone()
query_yR1 = "SELECT ST_Y(geom) as Y FROM (SELECT ST_AsText(ST_PointN(geom,1)) as geom FROM ara_temp1_seg) as toto;"
cursor.execute(query_yR1)
yR1 = cursor.fetchone()
query_xR2 = "SELECT ST_X(geom) as X FROM (SELECT ST_AsText(ST_PointN(geom,%s)) as geom FROM ara_temp1_seg) as toto;" % (
nb_points)
cursor.execute(query_xR2)
xR2 = cursor.fetchone()
query_yR2 = "SELECT ST_Y(geom) as Y FROM (SELECT ST_AsText(ST_PointN(geom,%s)) as geom FROM ara_temp1_seg) as toto;" % (
nb_points)
cursor.execute(query_yR2)
yR2 = cursor.fetchone()
# Transformation des coordonnées X et Y des points extrémités du segment route en valeurs numériques
xR1 = float(str(xR1)[1:-2])
yR1 = float(str(yR1)[1:-2])
xR2 = float(str(xR2)[1:-2])
yR2 = float(str(yR2)[1:-2])
if debug >= 4:
print(" xR1 = " + str(xR1))
print(" yR1 = " + str(yR1))
print(" xR2 = " + str(xR2))
print(" yR2 = " + str(yR2))
# Calcul des delta X et Y entre les points extrémités du segment route
dxR = xR1 - xR2
dyR = yR1 - yR2
if debug >= 4:
print(" dxR = " + str(dxR))
print(" dyR = " + str(dyR))
print("\n")
# Suppression des cas où le script créé des perpendiculaires tous les cm ! Bug lié à la segmentation des routes
dist_R1_R2 = math.sqrt((abs(dxR)**2) + (abs(dyR)**2))
if dist_R1_R2 >= (seg_dist / 2):
# Calcul de l'angle (= gisement) entre le Nord et le segment route
if dxR == 0 or dyR == 0:
if dxR == 0 and dyR > 0:
aR = 0
elif dxR > 0 and dyR == 0:
aR = 90
elif dxR == 0 and dyR < 0:
aR = 180
elif dxR < 0 and dyR == 0:
aR = 270
else:
aR = math.degrees(math.atan(dxR / dyR))
if aR < 0:
aR = aR + 360
if debug >= 4:
print(" aR = " + str(aR))
# Calcul des angles (= gisements) entre le Nord et les 2 segments perpendiculaires au segment route
aP1 = aR + 90
if aP1 < 0:
aP1 = aP1 + 360
if aP1 >= 360:
aP1 = aP1 - 360
aP2 = aR - 90
if aP2 < 0:
aP2 = aP2 + 360
if aP2 >= 360:
aP2 = aP2 - 360
if debug >= 4:
print(" aP1 = " + str(aP1))
print(" aP2 = " + str(aP2))
# Calculs des coordonnées des nouveaux points à l'extrémité de chaque segment perpendiculaire pour le segment route sélectionné
xP1 = xR1 + (seg_length * math.sin(math.radians(aP1)))
yP1 = yR1 + (seg_length * math.cos(math.radians(aP1)))
xP2 = xR1 + (seg_length * math.sin(math.radians(aP2)))
yP2 = yR1 + (seg_length * math.cos(math.radians(aP2)))
if debug >= 4:
print(" xP1 = " + str(xP1))
print(" yP1 = " + str(yP1))
print(" xP2 = " + str(xP2))
print(" yP2 = " + str(yP2))
print("\n")
# Construction de la requête de création des 2 segments perpendiculaires pour le segment route sélectionné
query_seg_perp += " ('%s', '%s_perp1', %s, %s, %s, %s, 'LINESTRING(%s %s, %s %s)'),\n" % (
str(id_seg), str(id_seg), xR1, yR1, xP1, yP1, xR1, yR1,
xP1, yP1)
query_seg_perp += " ('%s', '%s_perp2', %s, %s, %s, %s, 'LINESTRING(%s %s, %s %s)'),\n" % (
str(id_seg), str(id_seg), xR1, yR1, xP2, yP2, xR1, yR1,
xP2, yP2)
treat_seg += 1
# Fin de la construction de la requête de création des segments perpendiculaires et exécution de cette requête
query_seg_perp = query_seg_perp[:-2] + ";\n" # Transformer la virgule de la dernière ligne SQL en point-virgule (pour terminer la requête)
query_seg_perp += "ALTER TABLE ara_seg_perp ALTER COLUMN geom TYPE geometry(LINESTRING,%s) USING ST_SetSRID(geom,%s);\n" % (
epsg, epsg) # Mise à jour du système de coordonnées
query_seg_perp += "CREATE INDEX IF NOT EXISTS seg_perp_geom_gist ON ara_seg_perp USING GIST (geom);\n"
if debug >= 2:
print(query_seg_perp)
executeQuery(connection, query_seg_perp)
###################################################
### Intersect segments perpendiculaires et bâti ###
###################################################
print(
bold + cyan +
"Intersect entre les segments perpendiculaires et les bâtiments :"
+ endC)
timeLine(
path_time_log,
" Intersect entre les segments perpendiculaires et les bâtiments : "
)
# Requête d'intersect entre les segments perpendiculaires et les bâtiments
query_intersect = """
DROP TABLE IF EXISTS ara_intersect_bati;
CREATE TABLE ara_intersect_bati AS
SELECT r.id_seg as id_seg, r.id_perp as id_perp, r.xR as xR, r.yR as yR, b.HAUTEUR as haut_bati, ST_Intersection(r.geom, b.geom) as geom
FROM ara_seg_perp as r, %s as b
WHERE ST_Intersects(r.geom, b.geom);
ALTER TABLE ara_intersect_bati ADD COLUMN id_intersect serial;
CREATE INDEX IF NOT EXISTS intersect_bati_geom_gist ON ara_intersect_bati USING GIST (geom);
""" % table_name_bati
if debug >= 2:
print(query_intersect)
executeQuery(connection, query_intersect)
##################################################################################################################
### Récupération des demi-largeurs de rue et de la hauteur du 1er bâtiment pour chaque segment perpendiculaire ###
##################################################################################################################
print(
bold + cyan +
"Récupération des informations nécessaires au calcul du rapport d'aspect :"
+ endC)
timeLine(
path_time_log,
" Récupération des informations nécessaires au calcul du rapport d'aspect : "
)
# Début de la construction de la requête de création des points route, avec infos de demi-largeurs de rue et hauteurs des bâtiments
query_pt_route = "DROP TABLE IF EXISTS ara_asp_ratio_by_seg;\n"
query_pt_route += "CREATE TABLE ara_asp_ratio_by_seg (id_seg text, xR float, yR float, width1 float, height1 float, width2 float, height2 float, geom geometry);\n"
query_pt_route += "INSERT INTO ara_asp_ratio_by_seg VALUES\n"
# Récupération de la liste des identifiants segments routes (uniquement ceux qui intersectent du bâti)
cursor.execute(
"SELECT id_seg FROM ara_intersect_bati GROUP BY id_seg ORDER BY id_seg;"
)
id_seg_list = cursor.fetchall()
# Boucle sur les segments routes
nb_seg = len(id_seg_list)
treat_seg = 1
for id_seg in id_seg_list:
if debug >= 4:
print(bold + " Traitement du segment route : " + endC +
str(treat_seg) + "/" + str(nb_seg))
id_seg = id_seg[0]
# Table temporaire ne contenant que les intersects d'un segment route donné
query_temp2_seg = "DROP TABLE IF EXISTS ara_temp2_seg;\n"
query_temp2_seg += "CREATE TABLE ara_temp2_seg AS SELECT id_seg, id_perp, xR, yR, haut_bati, id_intersect, geom FROM ara_intersect_bati WHERE id_seg = '%s';\n" % (
id_seg)
if debug >= 4:
print(query_temp2_seg)
executeQuery(connection, query_temp2_seg)
# Récupération des coordonnées X et Y du point route du segment route associé
cursor.execute("SELECT xR FROM ara_temp2_seg;")
xR = cursor.fetchone()
cursor.execute("SELECT yR FROM ara_temp2_seg;")
yR = cursor.fetchone()
# Transformation des coordonnées X et Y du point route du segment route associé en valeurs numériques
xR = float(str(xR)[1:-2])
yR = float(str(yR)[1:-2])
if debug >= 4:
print(" xR = " + str(xR))
print(" yR = " + str(yR))
print("\n")
# Initialisation des variables demi-largeurs de rue et hauteur du 1er bâtiment intersecté
w1 = 0
h1 = 0
w2 = 0
h2 = 0
# Récupération de la liste des identifiants segments perpendiculaires de la table temp2_seg
cursor.execute(
"SELECT id_perp FROM ara_temp2_seg GROUP BY id_perp ORDER BY id_perp;"
)
id_perp_list = cursor.fetchall()
# Boucle sur les perpendiculaires (max 2) d'un segment route donné
for id_perp in id_perp_list:
# Récupération du numéro de perpendiculaire (1 ou 2 ~ droite ou gauche)
num_seg = float(str(id_perp)[-4:-3])
# Initialisation de listes contenant les demi-largeurs de rue et les hauteurs des bâtiments intersectés
length_list = []
haut_bati_list = []
# Table temporaire ne contenant que les intersects d'un segment perpendiculaire donné
query_temp2_perp = "DROP TABLE IF EXISTS ara_temp2_perp;\n"
query_temp2_perp += "CREATE TABLE ara_temp2_perp AS SELECT id_seg, id_perp, xR, yR, haut_bati, id_intersect, geom FROM ara_temp2_seg WHERE id_perp = '%s';\n" % (
id_perp)
if debug >= 4:
print(query_temp2_perp)
executeQuery(connection, query_temp2_perp)
# Récupération de la liste des identifiants segments intersects de la table temp2_perp
cursor.execute(
"SELECT id_intersect FROM ara_temp2_perp GROUP BY id_intersect ORDER BY id_intersect;"
)
id_intersect_list = cursor.fetchall()
# Boucle sur les intersects d'un segment perpendiculaire donné, d'un segment route donné
for id_intersect in id_intersect_list:
# Récupération des coordonnées X et Y des points extrémités de chaque segment intersect
query_xI1 = "SELECT ST_X(geom) as X FROM (SELECT ST_AsText(ST_PointN(geom,1)) as geom FROM ara_temp2_perp WHERE id_intersect = '%s') as toto;" % (
id_intersect)
cursor.execute(query_xI1)
xI1 = cursor.fetchone()
query_yI1 = "SELECT ST_Y(geom) as Y FROM (SELECT ST_AsText(ST_PointN(geom,1)) as geom FROM ara_temp2_perp WHERE id_intersect = '%s') as toto;" % (
id_intersect)
cursor.execute(query_yI1)
yI1 = cursor.fetchone()
query_xI2 = "SELECT ST_X(geom) as X FROM (SELECT ST_AsText(ST_PointN(geom,2)) as geom FROM ara_temp2_perp WHERE id_intersect = '%s') as toto;" % (
id_intersect)
cursor.execute(query_xI2)
xI2 = cursor.fetchone()
query_yI2 = "SELECT ST_Y(geom) as Y FROM (SELECT ST_AsText(ST_PointN(geom,2)) as geom FROM ara_temp2_perp WHERE id_intersect = '%s') as toto;" % (
id_intersect)
cursor.execute(query_yI2)
yI2 = cursor.fetchone()
# Transformation des coordonnées X et Y des points extrémités de chaque segment intersect en valeurs numériques
try:
xI1 = float(str(xI1)[1:-2])
yI1 = float(str(yI1)[1:-2])
xI2 = float(str(xI2)[1:-2])
yI2 = float(str(yI2)[1:-2])
except ValueError: # Python renvoie une valeur Null pour les bâtiments en U (= intersectés à plus de 2 points)
xI1 = yI1 = xI2 = yI2 = 0
if debug >= 4:
print(" xI1 = " + str(xI1))
print(" yI1 = " + str(yI1))
print(" xI2 = " + str(xI2))
print(" yI2 = " + str(yI2))
# Calcul des distances entre la route et chaque point du segment intersect
length_intersect1 = math.sqrt((abs(xR - xI1)**2) +
(abs(yR - yI1)**2))
length_intersect2 = math.sqrt((abs(xR - xI2)**2) +
(abs(yR - yI2)**2))
if debug >= 4:
print(" length_intersect1 = " +
str(length_intersect1))
print(" length_intersect2 = " +
str(length_intersect2))
# Récupération de la valeur de distance entre la route et le point d'intersect le plus proche (+ ajout dans la liste length_list)
length = min(length_intersect1, length_intersect2)
length_list.append(length)
if debug >= 4:
print(" length = " + str(length))
# Récupération de la hauteur du bâtiment correspondant à l'intersect (+ ajout dans la liste haut_bati_list)
query_haut_bati = "SELECT haut_bati FROM ara_temp2_perp WHERE id_intersect = '%s';" % (
id_intersect)
cursor.execute(query_haut_bati)
haut_bati = cursor.fetchone()
haut_bati = float(str(haut_bati)[10:-4])
haut_bati_list.append(haut_bati)
if debug >= 4:
print(" haut_bati = " + str(haut_bati))
print("\n")
# Pour un segment perpendiculaire donné, récupération de la distance minimale entre la route et les intersect avec le bâti
width = min(length_list)
if debug >= 4:
print(" width = " + str(width))
# Pour un segment perpendiculaire donné, récupération de la hauteur du bâtiment correspondant au segment intersect le plus proche de la route
height_position = length_list.index(width)
height = haut_bati_list[height_position]
if debug >= 4:
print(" height = " + str(height))
print("\n")
# MAJ des variables demi-largeurs de rue et hauteur du 1er bâtiment intersecté suivant le côté de la perpendiculaire par rapport à la route
if num_seg == 1:
w1 = width
h1 = height
elif num_seg == 2:
w2 = width
h2 = height
# Construction de la requête de création du point route pour le segment route donné
query_pt_route += " ('%s', %s, %s, %s, %s, %s, %s, 'POINT(%s %s)'),\n" % (
str(id_seg), xR, yR, w1, h1, w2, h2, xR, yR)
treat_seg += 1
# Fin de la construction de la requête de création des points route, avec infos de demi-largeurs de rue et hauteurs des bâtiments
query_pt_route = query_pt_route[:-2] + ";\n" # Transformer la virgule de la dernière ligne SQL en point-virgule (pour terminer la requête)
query_pt_route += "ALTER TABLE ara_asp_ratio_by_seg ALTER COLUMN geom TYPE geometry(POINT,%s) USING ST_SetSRID(geom,%s);\n" % (
epsg, epsg) # Mise à jour du système de coordonnées
query_pt_route += "CREATE INDEX IF NOT EXISTS asp_ratio_by_seg_geom_gist ON ara_asp_ratio_by_seg USING GIST (geom);\n"
if debug >= 2:
print(query_pt_route)
executeQuery(connection, query_pt_route)
###########################################################
### Calcul de l'indicateur et export de la table finale ###
###########################################################
print(bold + cyan +
"Calculs finaux de l'indicateur de rapport d'aspect :" + endC)
timeLine(path_time_log,
" Calculs finaux de l'indicateur de rapport d'aspect : ")
# Requête de calcul d'un rapport d'aspect par segment route
query_asp_ratio_by_seg = """
ALTER TABLE ara_asp_ratio_by_seg ADD COLUMN asp_ratio float;
UPDATE ara_asp_ratio_by_seg SET asp_ratio = 0;
UPDATE ara_asp_ratio_by_seg SET asp_ratio = ((height1 + height2) / 2) / (width1 + width2) WHERE height1 <> 0 AND height2 <> 0 AND width1 <> 0 AND width2 <> 0;
"""
if debug >= 2:
print(query_asp_ratio_by_seg)
executeQuery(connection, query_asp_ratio_by_seg)
# Requête de bufferisation du fichier maillage
query_buffer = """
DROP TABLE IF EXISTS ara_buffer;
CREATE TABLE ara_buffer AS
SELECT ID as ID, ST_Buffer(geom, %s) as geom
FROM %s;
CREATE INDEX IF NOT EXISTS buffer_geom_gist ON ara_buffer USING GIST (geom);
""" % (buffer_size, table_name_maille)
if debug >= 2:
print(query_buffer)
executeQuery(connection, query_buffer)
# Requête de calcul d'un rapport d'aspect par maille (via un intersect sur le maillage bufferisé)
query_asp_ratio_temp1 = """
DROP TABLE IF EXISTS ara_asp_ratio_temp1;
CREATE TABLE ara_asp_ratio_temp1 AS
SELECT m.ID as ID, avg(r.asp_ratio) as asp_ratio, m.geom as geom
FROM %s as m, ara_buffer as b, ara_asp_ratio_by_seg as r
WHERE ST_Intersects(b.geom, r.geom)
AND m.ID = b.ID
AND r.asp_ratio > 0
GROUP BY m.ID, m.geom;
CREATE INDEX IF NOT EXISTS asp_ratio_temp1_geom_gist ON ara_asp_ratio_temp1 USING GIST (geom);
""" % (table_name_maille)
if debug >= 2:
print(query_asp_ratio_temp1)
executeQuery(connection, query_asp_ratio_temp1)
# Rapport d'aspect pour les mailles n'intersectant pas de points-route avec un rapport d'aspect
query_asp_ratio_temp2 = """
DROP TABLE IF EXISTS ara_asp_ratio_temp2;
CREATE TABLE ara_asp_ratio_temp2 AS
SELECT DISTINCT ID as ID, geom as geom
FROM %s
WHERE ID NOT IN
(SELECT DISTINCT ID
FROM ara_asp_ratio_temp1);
ALTER TABLE ara_asp_ratio_temp2 ADD COLUMN asp_ratio float;
UPDATE ara_asp_ratio_temp2 SET asp_ratio = 0;
CREATE INDEX IF NOT EXISTS asp_ratio_temp2_geom_gist ON ara_asp_ratio_temp2 USING GIST (geom);
""" % table_name_maille
if debug >= 1:
print(query_asp_ratio_temp2)
executeQuery(connection, query_asp_ratio_temp2)
# Fusion des 2 tables précédentes pour retrouver l'ensemble des mailles de départ
query_asp_ratio = """
DROP TABLE IF EXISTS ara_asp_ratio;
CREATE TABLE ara_asp_ratio AS
SELECT ID, asp_ratio, geom
FROM ara_asp_ratio_temp1
UNION
SELECT ID, asp_ratio, geom
FROM ara_asp_ratio_temp2;
ALTER TABLE ara_asp_ratio ALTER COLUMN ID TYPE INTEGER;
"""
if debug >= 2:
print(query_asp_ratio)
executeQuery(connection, query_asp_ratio)
closeConnection(connection)
exportVectorByOgr2ogr(database_postgis,
grid_output,
'ara_asp_ratio',
user_name=user_postgis,
password=password_postgis,
ip_host=server_postgis,
num_port=str(port_number),
schema_name=schema_postgis,
format_type=format_vector)
##########################################
### Nettoyage des fichiers temporaires ###
##########################################
if not save_results_intermediate:
if os.path.exists(temp_path):
shutil.rmtree(temp_path)
# ~ dropDatabase(database_postgis) # Conflits avec autres indicateurs (Height of Roughness Elements / Terrain Roughness Class)
else:
print(bold + magenta + "Le calcul de Aspect Ratio a déjà eu lieu." +
endC)
print(bold + yellow + "Fin du calcul de l'indicateur Aspect Ratio." +
endC + "\n")
timeLine(path_time_log, "Fin du calcul de l'indicateur Aspect Ratio : ")
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
