def preparationVecteurs(urbanatlas_input, ucz_output, emprise_file, mask_file,
enter_with_mask, image_file, mnh_file,
built_files_list, hydrography_file, roads_files_list,
rpg_file, indicators_method, ucz_method, dbms_choice,
threshold_ndvi, threshold_ndvi_water, threshold_ndwi2,
threshold_bi_bottom, threshold_bi_top, path_time_log,
temp_directory, format_vector, extension_vector):
print(bold + yellow + "Début de la préparation des données vecteurs." +
endC)
step = " Début de la préparation des données vecteurs : "
timeLine(path_time_log, step)
field_name = 'ID'
field_type = ogr.OFTInteger
emprise_erosion = temp_directory + os.sep + os.path.splitext(
os.path.basename(emprise_file))[0] + "_eroded" + extension_vector
print(bold + cyan +
" Érosion de '%s' pour le découpage des autres vecteurs :" %
(emprise_file) + endC)
bufferVector(
emprise_file, emprise_erosion, -10, "", 1.0, 10, format_vector
) # Création du shape zone d'étude érodée (utile pour la fonction CrossingVectorRaster où shape < raster) - Tampon par défaut : -10
# Traitements sur l'Urban Atlas
print(bold + cyan + " Traitements du fichier Urban Atlas '%s' :" %
(urbanatlas_input) + endC)
basename_grid = os.path.splitext(os.path.basename(urbanatlas_input))[0]
grid_reproject = temp_directory + os.sep + basename_grid + "_reproject" + extension_vector
grid_ready = temp_directory + os.sep + basename_grid + "_cut" + extension_vector
grid_ready_cleaned = temp_directory + os.sep + basename_grid + "_cut_cleaned" + extension_vector
column = "'%s, CODE2012, ITEM2012'" % (field_name)
expression = "CODE2012 NOT IN ('12210', '12220', '12230', '50000')"
updateProjection(urbanatlas_input, grid_reproject, 2154,
format_vector) # MAJ projection
addNewFieldVector(grid_reproject, field_name, field_type, 0, None, None,
format_vector) # Ajout d'un champ ID
updateIndexVector(
grid_reproject,
index_name=field_name) # Mise à jour du champs ID (incrémentation)
cutVector(
emprise_erosion, grid_reproject, grid_ready, format_vector
) # Découpage du fichier Urban Atlas d'entrée à l'emprise de la zone d'étude
ret = filterSelectDataVector(
grid_ready, grid_ready_cleaned, column, expression, format_vector
) # Suppression des polygones eau et routes (uniquement pour le calcul des indicateurs)
if not ret:
raise NameError(
cyan + "preparationVecteurs : " + bold + red +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (expression) + endC)
if indicators_method in ("BD_exogenes", "SI_seuillage", "SI_classif"):
# Traitements sur les fichiers bâti de la BD TOPO
print(bold + cyan + " Traitements des fichiers bâti '%s' :" %
str(built_files_list) + endC)
built_merge = temp_directory + os.sep + "bati_merged" + extension_vector
built_ready = temp_directory + os.sep + "bati" + extension_vector
column = "HAUTEUR"
expression = "HAUTEUR > 0"
built_intersect_list = []
for built_input in built_files_list:
basename = os.path.splitext(os.path.basename(built_input))[0]
built_reproject = temp_directory + os.sep + basename + "_reproject" + extension_vector
built_intersect = temp_directory + os.sep + basename + "_intersect" + extension_vector
updateProjection(built_input, built_reproject, 2154,
format_vector) # MAJ projection
intersectVector(
emprise_file, built_reproject, built_intersect, format_vector
) # Sélection des entités bâti dans l'emprise de l'étude
built_intersect_list.append(built_intersect)
fusionVectors(built_intersect_list, built_merge,
format_vector) # Fusion des couches bâti de la BD TOPO
ret = filterSelectDataVector(
built_merge, built_ready, column, expression
) # Suppression des polygones où la hauteur du bâtiment est à 0
if not ret:
raise NameError(
cyan + "preparationVecteurs : " + bold + red +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (expression) + endC)
addNewFieldVector(built_ready, field_name, field_type, 0, None, None,
format_vector) # Ajout d'un champ ID
updateIndexVector(
built_ready,
index_name=field_name) # Mise à jour du champs ID (incrémentation)
if indicators_method == "BD_exogenes":
# Traitements sur le fichier routes de la BD TOPO
print(bold + cyan +
" Traitements du fichier hydrographie '%s' :" %
(hydrography_file) + endC)
basename_hydrography = os.path.splitext(
os.path.basename(hydrography_file))[0]
hydrography_reproject = temp_directory + os.sep + basename_hydrography + "_reproject" + extension_vector
hydrography_intersect = temp_directory + os.sep + basename_hydrography + "_intersect" + extension_vector
hydrography_ready = temp_directory + os.sep + "eau" + extension_vector
column = "REGIME"
expression = "REGIME LIKE 'Permanent'"
updateProjection(hydrography_file, hydrography_reproject, 2154,
format_vector) # MAJ projection
intersectVector(
emprise_file, hydrography_reproject, hydrography_intersect,
format_vector
) # Sélection des entités routes dans l'emprise de l'étude
ret = filterSelectDataVector(
hydrography_intersect, hydrography_ready, column, expression,
format_vector
) # Sélection des entités suivant le régime hydrographique (permanent)
if not ret:
raise NameError(
cyan + "preparationVecteurs : " + bold + red +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (expression) + endC)
addNewFieldVector(hydrography_ready, field_name, field_type, 0,
None, None, format_vector) # Ajout d'un champ ID
updateIndexVector(hydrography_ready, index_name=field_name
) # Mise à jour du champs ID (incrémentation)
# Traitements sur le fichier RPG
print(bold + cyan + " Traitements du fichier RPG '%s' :" %
(rpg_file) + endC)
basename_RPG = os.path.splitext(os.path.basename(rpg_file))[0]
RPG_reproject = temp_directory + os.sep + basename_RPG + "_reproject" + extension_vector
RPG_ready = temp_directory + os.sep + "RPG" + extension_vector
updateProjection(rpg_file, RPG_reproject, 2154,
format_vector) # MAJ projection
intersectVector(
emprise_file, RPG_reproject, RPG_ready, format_vector
) # Sélection des entités RPG dans l'emprise de l'étude
addNewFieldVector(RPG_ready, field_name, field_type, 0, None, None,
format_vector) # Ajout d'un champ ID
updateIndexVector(RPG_ready, index_name=field_name
) # Mise à jour du champs ID (incrémentation)
########################################################################################################################################################################################################
######################################################################## Partie restant à coder : normalement pas nécessaire puisque cette méthode n'a pas été retenue #################################
########################################################################################################################################################################################################
####
if indicators_method == "SI_seuillage": ####
# Traitements sur les fichiers routes de la BD TOPO ####
print(bold + cyan + " Traitements des fichiers routes '%s' :" %
str(roads_files_list) + endC) ####
####
print(
bold +
"Le script ne peut continuer, le traitements des fichiers routes n'est pas encore entièrement codé"
+ endC) ####
exit(0) ####
####
#~ En entrée : fichier troncon_route + fichier surface_route ####
#~ 1 - reprojection des fichiers en L93 ####
#~ 2 - sélection des entités des fichiers compris dans la zone d'étude (intersect et non découpage) ####
#~ 3 - filtrage des entités de troncon_route suivant la nature ####
#~ ("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')") ####
#~ 4 - tampon sur les entités de troncon_route correspondant à 'LARGEUR'/2 ####
#~ 5 - fusion des fichiers en un seul shape ####
#~ 6 - ajout d'un nouveau champ ID dans le fichier de fusion ####
#~ 7 - mise à jour de ce champ ID ####
####
########################################################################################################################################################################################################
########################################################################################################################################################################################################
########################################################################################################################################################################################################
step = " Fin de la préparation des données vecteurs : "
timeLine(path_time_log, step)
print(bold + yellow + "Fin de la préparation des données vecteurs." + endC)
print("\n")
return
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 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 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 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