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 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 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 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 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