def estimateQualityMns(image_input,
vector_cut_input,
vector_sample_input_list,
vector_sample_points_input,
raster_input_dico,
vector_output,
no_data_value,
path_time_log,
format_raster='GTiff',
epsg=2154,
format_vector='ESRI Shapefile',
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
# Mise à jour du Log
starting_event = "estimateQualityMns() : Masks creation starting : "
timeLine(path_time_log, starting_event)
print(endC)
print(bold + green + "## START : CREATE HEIGHT POINTS FILE FROM MNS" +
endC)
print(endC)
if debug >= 2:
print(bold + green +
"estimateQualityMns() : Variables dans la fonction" + endC)
print(cyan + "estimateQualityMns() : " + endC + "image_input : " +
str(image_input) + endC)
print(cyan + "estimateQualityMns() : " + endC + "vector_cut_input : " +
str(vector_cut_input) + endC)
print(cyan + "estimateQualityMns() : " + endC +
"vector_sample_input_list : " + str(vector_sample_input_list) +
endC)
print(cyan + "estimateQualityMns() : " + endC +
"vector_sample_points_input : " +
str(vector_sample_points_input) + endC)
print(cyan + "estimateQualityMns() : " + endC +
"raster_input_dico : " + str(raster_input_dico) + endC)
print(cyan + "estimateQualityMns() : " + endC + "vector_output : " +
str(vector_output) + endC)
print(cyan + "estimateQualityMns() : " + endC + "no_data_value : " +
str(no_data_value))
print(cyan + "estimateQualityMns() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "estimateQualityMns() : " + endC + "epsg : " +
str(epsg) + endC)
print(cyan + "estimateQualityMns() : " + endC + "format_raster : " +
str(format_raster) + endC)
print(cyan + "estimateQualityMns() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "estimateQualityMns() : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(cyan + "estimateQualityMns() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "estimateQualityMns() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "estimateQualityMns() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Définion des constantes
EXT_DBF = '.dbf'
EXT_CSV = '.csv'
CODAGE = "uint16"
SUFFIX_STUDY = '_study'
SUFFIX_CUT = '_cut'
SUFFIX_TEMP = '_temp'
SUFFIX_CLEAN = '_clean'
SUFFIX_SAMPLE = '_sample'
ATTRIBUTE_ID = "ID"
ATTRIBUTE_Z_INI = "Z_INI"
ATTRIBUTE_Z_FIN = "Z_FIN"
ATTRIBUTE_PREC_ALTI = "PREC_ALTI"
ATTRIBUTE_Z_REF = "Z_Ref"
ATTRIBUTE_Z_MNS = "Z_Mns"
ATTRIBUTE_Z_DELTA = "Z_Delta"
ERODE_EDGE_POINTS = -1.0
ERROR_VALUE = -99.0
ERROR_MIN_VALUE = -9999
ERROR_MAX_VALUE = 9999
# ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES
# Si le fichier de sortie existe on ecrase
check = os.path.isfile(vector_output)
if check and not overwrite: # Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors FIN
print(cyan + "estimateQualityMns() : " + bold + yellow +
"Create file %s already exist : no actualisation" %
(vector_output) + endC)
return
if os.path.isfile(os.path.splitext(vector_output)[0] + EXT_CSV):
removeFile(os.path.splitext(vector_output)[0] + EXT_CSV)
repertory_output = os.path.dirname(vector_output)
base_name = os.path.splitext(os.path.basename(vector_output))[0]
vector_output_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector
raster_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_raster
vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector
vector_study_clean = repertory_output + os.sep + base_name + SUFFIX_STUDY + SUFFIX_CLEAN + extension_vector
image_cut = repertory_output + os.sep + base_name + SUFFIX_CUT + extension_raster
vector_sample_temp = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + extension_vector
vector_sample_temp_clean = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + SUFFIX_CLEAN + extension_vector
# Utilisation des données raster externes
raster_cut_dico = {}
for raster_input in raster_input_dico:
base_name_raster = os.path.splitext(os.path.basename(raster_input))[0]
raster_cut = repertory_output + os.sep + base_name_raster + SUFFIX_CUT + extension_raster
raster_cut_dico[raster_input] = raster_cut
if os.path.exists(raster_cut):
removeFile(raster_cut)
# ETAPE 1 : DEFINIR UN SHAPE ZONE D'ETUDE
if (not vector_cut_input is None) and (vector_cut_input != "") and (
os.path.isfile(vector_cut_input)):
cutting_action = True
vector_study = vector_cut_input
else:
cutting_action = False
createVectorMask(image_input, vector_study)
# ETAPE 2 : DECOUPAGE DU RASTEUR PAR LE VECTEUR D'ETUDE SI BESOIN ET REECHANTILLONAGE SI BESOIN
if cutting_action:
# Identification de la tailles de pixels en x et en y du fichier MNS de reference
pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input)
# Si le fichier de sortie existe deja le supprimer
if os.path.exists(image_cut):
removeFile(image_cut)
# Commande de découpe
if not cutImageByVector(vector_study, image_input, image_cut,
pixel_size_x, pixel_size_y, no_data_value, 0,
format_raster, format_vector):
print(
cyan + "estimateQualityMns() : " + bold + red +
"Une erreur c'est produite au cours du decoupage de l'image : "
+ image_input + endC,
file=sys.stderr)
raise
if debug >= 2:
print(cyan + "estimateQualityMns() : " + bold + green +
"DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" %
(image_input, vector_study) + endC)
else:
image_cut = image_input
# Definir l'emprise du fichier MNS de reference
# Decoupage de chaque raster de la liste des rasters
for raster_input in raster_input_dico:
raster_cut = raster_cut_dico[raster_input]
if not cutImageByVector(vector_study, raster_input, raster_cut,
pixel_size_x, pixel_size_y, no_data_value, 0,
format_raster, format_vector):
raise NameError(
cyan + "estimateQualityMns() : " + bold + red +
"Une erreur c'est produite au cours du decoupage du raster : "
+ raster_input + endC)
# Gémotrie de l'image
pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_cut)
cols, rows, bands = getGeometryImage(image_cut)
xmin, xmax, ymin, ymax = getEmpriseImage(image_cut)
if debug >= 3:
print("Geometrie Image : ")
print(" cols = " + str(cols))
print(" rows = " + str(rows))
print(" xmin = " + str(xmin))
print(" xmax = " + str(xmax))
print(" ymin = " + str(ymin))
print(" ymax = " + str(ymax))
print(" pixel_size_x = " + str(pixel_size_x))
print(" pixel_size_y = " + str(pixel_size_y))
print("\n")
# Création du dico coordonnées des points en systeme cartographique
points_random_value_dico = {}
# liste coordonnées des points au format matrice image brute
points_coordonnees_image_list = []
# Selon que l'on utilise le fichier de points d'echantillons ou que l'on recréé a partir des sommets des vecteurs lignes
if (vector_sample_points_input is None) or (vector_sample_points_input
== ""):
# ETAPE 3 : DECOUPAGES DES VECTEURS DE REFERENCE D'ENTREE PAR LE VECTEUR D'ETUDE ET LEUR FUSION ET
# LECTURE D'UN VECTEUR DE LIGNES ET SAUVEGARDE DES COORDONNEES POINTS DES EXTREMITEES ET LEUR HAUTEUR
# Découpage des vecteurs de bd réference avec le vecteur zone d'étude
vector_sample_input_cut_list = []
for vector_sample in vector_sample_input_list:
vector_name = os.path.splitext(os.path.basename(vector_sample))[0]
vector_sample_cut = repertory_output + os.sep + vector_name + SUFFIX_CUT + extension_vector
vector_sample_input_cut_list.append(vector_sample_cut)
cutoutVectors(vector_study, vector_sample_input_list,
vector_sample_input_cut_list, format_vector)
# Fusion des vecteurs de bd réference découpés
fusionVectors(vector_sample_input_cut_list, vector_sample_temp,
format_vector)
# Preparation des colonnes
names_column_start_point_list = [
ATTRIBUTE_ID, ATTRIBUTE_Z_INI, ATTRIBUTE_PREC_ALTI
]
names_column_end_point_list = [
ATTRIBUTE_ID, ATTRIBUTE_Z_FIN, ATTRIBUTE_PREC_ALTI
]
fields_list = [
ATTRIBUTE_ID, ATTRIBUTE_PREC_ALTI, ATTRIBUTE_Z_INI, ATTRIBUTE_Z_FIN
]
multigeometries2geometries(vector_sample_temp,
vector_sample_temp_clean, fields_list,
"MULTILINESTRING", format_vector)
points_coordinates_dico = readVectorFileLinesExtractTeminalsPoints(
vector_sample_temp_clean, names_column_start_point_list,
names_column_end_point_list, format_vector)
else:
# ETAPE 3_BIS : DECOUPAGE DE VECTEURS D'ECHANTILLONS POINTS PAR LE VECTEUR D'EMPRISE ET
# LECTURE DES COORDONNES D'ECHANTILLONS DURECTEMENT DANS LE FICHIER VECTEUR POINTS
# Liste coordonnées des points au format matrice image brute
cutVectorAll(vector_study, vector_sample_points_input,
vector_sample_temp, format_vector)
points_coordinates_dico = readVectorFilePoints(vector_sample_temp,
format_vector)
# ETAPE 4 : PREPARATION DU VECTEUR DE POINTS
for index_key in points_coordinates_dico:
# Recuperer les valeurs des coordonnees
coord_info_list = points_coordinates_dico[index_key]
coor_x = coord_info_list[0]
coor_y = coord_info_list[1]
attribut_dico = coord_info_list[2]
# Coordonnées des points au format matrice image
pos_x = int(round((coor_x - xmin) / abs(pixel_size_x)) - 1)
pos_y = int(round((ymax - coor_y) / abs(pixel_size_y)) - 1)
if pos_x < 0:
pos_x = 0
if pos_x >= cols:
pos_x = cols - 1
if pos_y < 0:
pos_y = 0
if pos_y >= rows:
pos_y = rows - 1
coordonnees_list = [pos_x, pos_y]
points_coordonnees_image_list.append(coordonnees_list)
value_ref = 0.0
if ATTRIBUTE_Z_INI in attribut_dico.keys():
value_ref = float(attribut_dico[ATTRIBUTE_Z_INI])
if ATTRIBUTE_Z_FIN in attribut_dico.keys():
value_ref = float(attribut_dico[ATTRIBUTE_Z_FIN])
precision_alti = 0.0
if ATTRIBUTE_PREC_ALTI in attribut_dico.keys():
precision_alti = float(attribut_dico[ATTRIBUTE_PREC_ALTI])
point_attr_dico = {
ATTRIBUTE_ID: index_key,
ATTRIBUTE_Z_REF: value_ref,
ATTRIBUTE_PREC_ALTI: precision_alti,
ATTRIBUTE_Z_MNS: 0.0,
ATTRIBUTE_Z_DELTA: 0.0
}
for raster_input in raster_input_dico:
field_name = raster_input_dico[raster_input][0][0]
point_attr_dico[field_name] = 0.0
points_random_value_dico[index_key] = [[coor_x, coor_y],
point_attr_dico]
# ETAPE 5 : LECTURE DES DONNEES DE HAUTEURS ISSU DU MNS et autre raster
# Lecture dans le fichier raster des valeurs
values_height_list = getPixelsValueListImage(
image_cut, points_coordonnees_image_list)
values_others_dico = {}
for raster_input in raster_input_dico:
raster_cut = raster_cut_dico[raster_input]
values_list = getPixelsValueListImage(raster_cut,
points_coordonnees_image_list)
values_others_dico[raster_input] = values_list
for i in range(len(points_random_value_dico)):
value_mns = values_height_list[i]
value_ref = points_random_value_dico[i][1][ATTRIBUTE_Z_REF]
points_random_value_dico[i][1][ATTRIBUTE_Z_MNS] = float(value_mns)
precision_alti = points_random_value_dico[i][1][ATTRIBUTE_PREC_ALTI]
points_random_value_dico[i][1][ATTRIBUTE_PREC_ALTI] = float(
precision_alti)
value_diff = value_ref - value_mns
points_random_value_dico[i][1][ATTRIBUTE_Z_DELTA] = float(value_diff)
for raster_input in raster_input_dico:
field_name = raster_input_dico[raster_input][0][0]
value_other = values_others_dico[raster_input][i]
points_random_value_dico[i][1][field_name] = float(value_other)
# ETAPE 6 : CREATION D'UN VECTEUR DE POINTS AVEC DONNEE COORDONNES POINT ET HAUTEUR REFERENCE ET MNS
# Suppression des points contenant des valeurs en erreur et en dehors du filtrage
points_random_value_dico_clean = {}
for i in range(len(points_random_value_dico)):
value_ref = points_random_value_dico[i][1][ATTRIBUTE_Z_REF]
if value_ref != ERROR_VALUE and value_ref > ERROR_MIN_VALUE and value_ref < ERROR_MAX_VALUE:
points_is_valid = True
for raster_input in raster_input_dico:
if len(raster_input_dico[raster_input]) > 1 and len(
raster_input_dico[raster_input][1]) > 1:
threshold_min = float(
raster_input_dico[raster_input][1][0])
threshold_max = float(
raster_input_dico[raster_input][1][1])
field_name = raster_input_dico[raster_input][0][0]
value_raster = float(
points_random_value_dico[i][1][field_name])
if value_raster < threshold_min or value_raster > threshold_max:
points_is_valid = False
if points_is_valid:
points_random_value_dico_clean[i] = points_random_value_dico[i]
# Définir les attibuts du fichier résultat
attribute_dico = {
ATTRIBUTE_ID: ogr.OFTInteger,
ATTRIBUTE_PREC_ALTI: ogr.OFTReal,
ATTRIBUTE_Z_REF: ogr.OFTReal,
ATTRIBUTE_Z_MNS: ogr.OFTReal,
ATTRIBUTE_Z_DELTA: ogr.OFTReal
}
for raster_input in raster_input_dico:
field_name = raster_input_dico[raster_input][0][0]
attribute_dico[field_name] = ogr.OFTReal
createPointsFromCoordList(attribute_dico, points_random_value_dico_clean,
vector_output_temp, epsg, format_vector)
# Suppression des points en bord de zone d'étude
bufferVector(vector_study, vector_study_clean, ERODE_EDGE_POINTS, "", 1.0,
10, format_vector)
cutVectorAll(vector_study_clean, vector_output_temp, vector_output, True,
format_vector)
# ETAPE 7 : TRANSFORMATION DU FICHIER .DBF EN .CSV
dbf_file = repertory_output + os.sep + base_name + EXT_DBF
csv_file = repertory_output + os.sep + base_name + EXT_CSV
if debug >= 2:
print(cyan + "estimateQualityMns() : " + bold + green +
"Conversion du fichier DBF %s en fichier CSV %s" %
(dbf_file, csv_file) + endC)
convertDbf2Csv(dbf_file, csv_file)
# ETAPE 8 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES
# Suppression des données intermédiaires
if not save_results_intermediate:
if cutting_action:
if os.path.isfile(image_cut):
removeFile(image_cut)
else:
if os.path.isfile(vector_study):
removeVectorFile(vector_study)
for raster_input in raster_input_dico:
raster_cut = raster_cut_dico[raster_input]
if os.path.isfile(raster_cut):
removeFile(raster_cut)
if os.path.isfile(vector_output_temp):
removeVectorFile(vector_output_temp)
if os.path.isfile(vector_study_clean):
removeVectorFile(vector_study_clean)
if os.path.isfile(vector_sample_temp):
removeVectorFile(vector_sample_temp)
if os.path.isfile(vector_sample_temp_clean):
removeVectorFile(vector_sample_temp_clean)
for vector_file in vector_sample_input_cut_list:
if os.path.isfile(vector_file):
removeVectorFile(vector_file)
print(bold + green + "## END : CREATE HEIGHT POINTS FILE FROM MNSE" + endC)
# Mise à jour du Log
ending_event = "estimateQualityMns() : Masks creation ending : "
timeLine(path_time_log, ending_event)
return
def addDataBaseExo(image_input,
image_classif_add_output,
class_file_dico,
class_buffer_dico,
class_sql_dico,
path_time_log,
format_vector='ESRI Shapefile',
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True,
simplifie_param=10.0):
# Mise à jour du Log
starting_event = "addDataBaseExo() : Add data base exogene to classification starting : "
timeLine(path_time_log, starting_event)
# Print
if debug >= 3:
print(bold + green + "Variables dans la fonction" + endC)
print(cyan + "addDataBaseExo() : " + endC + "image_input : " +
str(image_input) + endC)
print(cyan + "addDataBaseExo() : " + endC +
"image_classif_add_output : " + str(image_classif_add_output) +
endC)
print(cyan + "addDataBaseExo() : " + endC + "class_file_dico : " +
str(class_file_dico) + endC)
print(cyan + "addDataBaseExo() : " + endC + "class_buffer_dico : " +
str(class_buffer_dico) + endC)
print(cyan + "addDataBaseExo() : " + endC + "class_sql_dico : " +
str(class_sql_dico) + endC)
print(cyan + "addDataBaseExo() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "addDataBaseExo() : " + endC + "format_vector : " +
str(format_vector) + endC)
print(cyan + "addDataBaseExo() : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(cyan + "addDataBaseExo() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "addDataBaseExo() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "addDataBaseExo() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Constantes
FOLDER_MASK_TEMP = 'Mask_'
FOLDER_FILTERING_TEMP = 'Filt_'
FOLDER_CUTTING_TEMP = 'Cut_'
FOLDER_BUFF_TEMP = 'Buff_'
SUFFIX_MASK_CRUDE = '_mcrude'
SUFFIX_MASK = '_mask'
SUFFIX_FUSION = '_info'
SUFFIX_VECTOR_FILTER = "_filt"
SUFFIX_VECTOR_CUT = '_decoup'
SUFFIX_VECTOR_BUFF = '_buff'
CODAGE = "uint16"
# ETAPE 1 : NETTOYER LES DONNEES EXISTANTES
if debug >= 2:
print(cyan + "addDataBaseExo() : " + bold + green +
"NETTOYAGE ESPACE DE TRAVAIL..." + endC)
# Nom de base de l'image
image_name = os.path.splitext(os.path.basename(image_input))[0]
# Nettoyage d'anciennes données résultat
# Si le fichier résultat existent deja et que overwrite n'est pas activé
check = os.path.isfile(image_classif_add_output)
if check and not overwrite:
print(bold + yellow + "addDataBaseExo() : " + endC +
image_classif_add_output +
" has already added bd exo and will not be added again." + endC)
else:
if check:
try:
removeFile(image_classif_add_output
) # Tentative de suppression du fichier
except Exception:
pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite
# Définition des répertoires temporaires
repertory_output = os.path.dirname(image_classif_add_output)
repertory_mask_temp = repertory_output + os.sep + FOLDER_MASK_TEMP + image_name
repertory_samples_filtering_temp = repertory_output + os.sep + FOLDER_FILTERING_TEMP + image_name
repertory_samples_cutting_temp = repertory_output + os.sep + FOLDER_CUTTING_TEMP + image_name
repertory_samples_buff_temp = repertory_output + os.sep + FOLDER_BUFF_TEMP + image_name
if debug >= 4:
print(repertory_mask_temp)
print(repertory_samples_filtering_temp)
print(repertory_samples_cutting_temp)
print(repertory_samples_buff_temp)
# Creer les répertoires temporaire si ils n'existent pas
if not os.path.isdir(repertory_output):
os.makedirs(repertory_output)
if not os.path.isdir(repertory_mask_temp):
os.makedirs(repertory_mask_temp)
if not os.path.isdir(repertory_samples_filtering_temp):
os.makedirs(repertory_samples_filtering_temp)
if not os.path.isdir(repertory_samples_cutting_temp):
os.makedirs(repertory_samples_cutting_temp)
if not os.path.isdir(repertory_samples_buff_temp):
os.makedirs(repertory_samples_buff_temp)
# Nettoyer les répertoires temporaire si ils ne sont pas vide
cleanTempData(repertory_mask_temp)
cleanTempData(repertory_samples_filtering_temp)
cleanTempData(repertory_samples_cutting_temp)
cleanTempData(repertory_samples_buff_temp)
if debug >= 2:
print(cyan + "addDataBaseExo() : " + bold + green +
"... FIN NETTOYAGE" + endC)
# ETAPE 2 : CREER UN SHAPE DE DECOUPE
if debug >= 2:
print(cyan + "addDataBaseExo() : " + bold + green +
"SHAPE DE DECOUPE..." + endC)
# 2.1 : Création des masques délimitant l'emprise de la zone par image
vector_mask = repertory_mask_temp + os.sep + image_name + SUFFIX_MASK_CRUDE + extension_vector
cols, rows, num_band = getGeometryImage(image_input)
no_data_value = getNodataValueImage(image_input, num_band)
if no_data_value == None:
no_data_value = 0
createVectorMask(image_input, vector_mask, no_data_value,
format_vector)
# 2.2 : Simplification du masque global
vector_simple_mask_cut = repertory_mask_temp + os.sep + image_name + SUFFIX_MASK + extension_vector
simplifyVector(vector_mask, vector_simple_mask_cut, simplifie_param,
format_vector)
if debug >= 2:
print(cyan + "addDataBaseExo() : " + bold + green +
"...FIN SHAPE DE DECOUPEE" + endC)
# ETAPE 3 : DECOUPER BUFFERISER LES VECTEURS ET FUSIONNER
if debug >= 2:
print(cyan + "addDataBaseExo() : " + bold + green +
"MISE EN PLACE DES TAMPONS..." + endC)
image_combined_list = []
# Parcours du dictionnaire associant les macroclasses aux noms de fichiers
for macroclass_label in class_file_dico:
vector_fusion_list = []
for index_info in range(len(class_file_dico[macroclass_label])):
input_vector = class_file_dico[macroclass_label][index_info]
vector_name = os.path.splitext(
os.path.basename(input_vector))[0]
output_vector_filtered = repertory_samples_filtering_temp + os.sep + vector_name + SUFFIX_VECTOR_FILTER + extension_vector
output_vector_cut = repertory_samples_cutting_temp + os.sep + vector_name + SUFFIX_VECTOR_CUT + extension_vector
output_vector_buff = repertory_samples_buff_temp + os.sep + vector_name + SUFFIX_VECTOR_BUFF + extension_vector
sql_expression = class_sql_dico[macroclass_label][index_info]
buffer_str = class_buffer_dico[macroclass_label][index_info]
buff = 0.0
col_name_buf = ""
try:
buff = float(buffer_str)
except:
col_name_buf = buffer_str
print(
cyan + "addDataBaseExo() : " + bold + green +
"Pas de valeur buffer mais un nom de colonne pour les valeur à bufferiser : "
+ endC + col_name_buf)
if os.path.isfile(input_vector):
if debug >= 3:
print(cyan + "addDataBaseExo() : " + endC +
"input_vector : " + str(input_vector) + endC)
print(cyan + "addDataBaseExo() : " + endC +
"output_vector_filtered : " +
str(output_vector_filtered) + endC)
print(cyan + "addDataBaseExo() : " + endC +
"output_vector_cut : " + str(output_vector_cut) +
endC)
print(cyan + "addDataBaseExo() : " + endC +
"output_vector_buff : " +
str(output_vector_buff) + endC)
print(cyan + "addDataBaseExo() : " + endC + "buff : " +
str(buff) + endC)
print(cyan + "addDataBaseExo() : " + endC + "sql : " +
str(sql_expression) + endC)
# 3.0 : Recuperer les vecteurs d'entrée et filtree selon la requete sql par ogr2ogr
if sql_expression != "":
names_attribut_list = getAttributeNameList(
input_vector, format_vector)
column = "'"
for name_attribut in names_attribut_list:
column += name_attribut + ", "
column = column[0:len(column) - 2]
column += "'"
ret = filterSelectDataVector(input_vector,
output_vector_filtered,
column, sql_expression,
format_vector)
if not ret:
print(
cyan + "addDataBaseExo() : " + bold + yellow +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (sql_expression) + endC)
output_vector_filtered = input_vector
else:
print(cyan + "addDataBaseExo() : " + bold + green +
"Pas de filtrage sur le fichier du nom : " +
endC + output_vector_filtered)
output_vector_filtered = input_vector
# 3.1 : Découper le vecteur selon l'empise de l'image d'entrée
cutoutVectors(vector_simple_mask_cut,
[output_vector_filtered],
[output_vector_cut], format_vector)
# 3.2 : Bufferiser lesvecteurs découpé avec la valeur défini dans le dico ou trouver dans la base du vecteur lui même si le nom de la colonne est passée dans le dico
if os.path.isfile(output_vector_cut) and (
(buff != 0) or (col_name_buf != "")):
bufferVector(output_vector_cut, output_vector_buff,
buff, col_name_buf, 1.0, 10,
format_vector)
else:
print(cyan + "addDataBaseExo() : " + bold + green +
"Pas de buffer sur le fichier du nom : " + endC +
output_vector_cut)
output_vector_buff = output_vector_cut
# 3.3 : Si un shape résulat existe l'ajouté à la liste de fusion
if os.path.isfile(output_vector_buff):
vector_fusion_list.append(output_vector_buff)
if debug >= 3:
print("file for fusion : " + output_vector_buff)
else:
print(bold + yellow +
"pas de fichiers avec ce nom : " + endC +
output_vector_buff)
else:
print(cyan + "addDataBaseExo() : " + bold + yellow +
"Pas de fichier du nom : " + endC + input_vector)
# 3.4 : Fusionner les shapes transformés d'une même classe, rasterization et labelisations des vecteurs
# Si une liste de fichier shape existe
if not vector_fusion_list:
print(bold + yellow + "Pas de fusion sans donnee a fusionnee" +
endC)
else:
# Rasterization et BandMath des fichiers shapes
raster_list = []
for vector in vector_fusion_list:
if debug >= 3:
print(cyan + "addDataBaseExo() : " + endC +
"Rasterization : " + vector + " label : " +
macroclass_label)
raster_output = os.path.splitext(
vector)[0] + extension_raster
# Rasterisation
rasterizeBinaryVector(vector, image_input, raster_output,
macroclass_label, CODAGE)
raster_list.append(raster_output)
if debug >= 3:
print(cyan + "addDataBaseExo() : " + endC +
"nombre d'images a combiner : " +
str(len(raster_list)))
# Liste les images raster combined and sample
image_combined = repertory_output + os.sep + image_name + '_' + str(
macroclass_label) + SUFFIX_FUSION + extension_raster
image_combined_list.append(image_combined)
# Fusion des images raster en une seule
mergeListRaster(raster_list, image_combined, CODAGE)
if debug >= 2:
print(cyan + "addDataBaseExo() : " + bold + green +
"FIN DE L AFFECTATION DES TAMPONS" + endC)
# ETAPE 4 : ASSEMBLAGE DE L'IMAGE CLASSEE ET DES BD EXOS
if debug >= 2:
print(cyan + "addDataBaseExo() : " + bold + green +
"ASSEMBLAGE..." + endC)
# Ajout de l'image de classification a la liste des image bd conbinées
image_combined_list.append(image_input)
# Fusion les images avec la classification
mergeListRaster(image_combined_list, image_classif_add_output, CODAGE)
if debug >= 2:
print(cyan + "addDataBaseExo() : " + bold + green + "FIN" + endC)
# ETAPE 5 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES
# Suppression des données intermédiaires
if not save_results_intermediate:
image_combined_list.remove(image_input)
for to_delete in image_combined_list:
removeFile(to_delete)
# Suppression des repertoires temporaires
deleteDir(repertory_mask_temp)
deleteDir(repertory_samples_filtering_temp)
deleteDir(repertory_samples_cutting_temp)
deleteDir(repertory_samples_buff_temp)
# Mise à jour du Log
ending_event = "addDataBaseExo() : Add data base exogene to classification ending : "
timeLine(path_time_log, ending_event)
return
def estimateQualityClassification(image_input,
vector_cut_input,
vector_sample_input,
vector_output,
nb_dot,
no_data_value,
column_name_vector,
column_name_ref,
column_name_class,
path_time_log,
epsg=2154,
format_raster='GTiff',
format_vector="ESRI Shapefile",
extension_raster=".tif",
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
# Mise à jour du Log
starting_event = "estimateQualityClassification() : Masks creation starting : "
timeLine(path_time_log, starting_event)
print(endC)
print(bold + green +
"## START : CREATE PRINT POINTS FILE FROM CLASSIF IMAGE" + endC)
print(endC)
if debug >= 2:
print(bold + green +
"estimateQualityClassification() : Variables dans la fonction" +
endC)
print(cyan + "estimateQualityClassification() : " + endC +
"image_input : " + str(image_input) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"vector_cut_input : " + str(vector_cut_input) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"vector_sample_input : " + str(vector_sample_input) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"vector_output : " + str(vector_output) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"nb_dot : " + str(nb_dot) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"no_data_value : " + str(no_data_value) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"column_name_vector : " + str(column_name_vector) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"column_name_ref : " + str(column_name_ref) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"column_name_class : " + str(column_name_class) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"path_time_log : " + str(path_time_log) + endC)
print(cyan + "estimateQualityClassification() : " + endC + "epsg : " +
str(epsg) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"format_raster : " + str(format_raster) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"format_vector : " + str(format_vector) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"extension_raster : " + str(extension_raster) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"extension_vector : " + str(extension_vector) + endC)
print(cyan + "estimateQualityClassification() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "estimateQualityClassification() : " + endC +
"overwrite : " + str(overwrite) + endC)
# ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES
CODAGE = "uint16"
SUFFIX_STUDY = '_study'
SUFFIX_CUT = '_cut'
SUFFIX_TEMP = '_temp'
SUFFIX_SAMPLE = '_sample'
repertory_output = os.path.dirname(vector_output)
base_name = os.path.splitext(os.path.basename(vector_output))[0]
vector_output_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector
raster_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_raster
vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector
raster_cut = repertory_output + os.sep + base_name + SUFFIX_CUT + extension_raster
vector_sample_temp = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + extension_vector
# Mise à jour des noms de champs
input_ref_col = ""
val_ref = 0
if (column_name_vector != "") and (not column_name_vector is None):
input_ref_col = column_name_vector
if (column_name_ref != "") and (not column_name_ref is None):
val_ref_col = column_name_ref
if (column_name_class != "") and (not column_name_class is None):
val_class_col = column_name_class
# ETAPE 1 : DEFINIR UN SHAPE ZONE D'ETUDE
if (not vector_cut_input is None) and (vector_cut_input != "") and (
os.path.isfile(vector_cut_input)):
cutting_action = True
vector_study = vector_cut_input
else:
cutting_action = False
createVectorMask(image_input, vector_study)
# ETAPE 2 : DECOUPAGE DU RASTEUR PAR LE VECTEUR D'EMPRISE SI BESOIN
if cutting_action:
# Identification de la tailles de pixels en x et en y
pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input)
# Si le fichier de sortie existe deja le supprimer
if os.path.exists(raster_cut):
removeFile(raster_cut)
# Commande de découpe
if not cutImageByVector(vector_study, image_input, raster_cut,
pixel_size_x, pixel_size_y, no_data_value, 0,
format_raster, format_vector):
raise NameError(
cyan + "estimateQualityClassification() : " + bold + red +
"Une erreur c'est produite au cours du decoupage de l'image : "
+ image_input + endC)
if debug >= 2:
print(cyan + "estimateQualityClassification() : " + bold + green +
"DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" %
(image_input, vector_study) + endC)
else:
raster_cut = image_input
# ETAPE 3 : CREATION DE LISTE POINTS AVEC DONNEE ISSU D'UN FICHIER RASTER
# Gémotrie de l'image
cols, rows, bands = getGeometryImage(raster_cut)
xmin, xmax, ymin, ymax = getEmpriseImage(raster_cut)
pixel_width, pixel_height = getPixelWidthXYImage(raster_cut)
if debug >= 2:
print("cols : " + str(cols))
print("rows : " + str(rows))
print("bands : " + str(bands))
print("xmin : " + str(xmin))
print("ymin : " + str(ymin))
print("xmax : " + str(xmax))
print("ymax : " + str(ymax))
print("pixel_width : " + str(pixel_width))
print("pixel_height : " + str(pixel_height))
# ETAPE 3-1 : CAS CREATION D'UN FICHIER DE POINTS PAR TIRAGE ALEATOIRE DANS LA MATRICE IMAGE
if (vector_sample_input is None) or (vector_sample_input == ""):
is_sample_file = False
# Les dimensions de l'image
nb_pixels = abs(cols * rows)
# Tirage aléatoire des points
drawn_dot_list = []
while len(drawn_dot_list) < nb_dot:
val = random.randint(0, nb_pixels)
if not val in drawn_dot_list:
drawn_dot_list.append(val)
# Creation d'un dico index valeur du tirage et attibuts pos_x, pos_y et value pixel
points_random_value_dico = {}
points_coordonnees_list = []
for point in drawn_dot_list:
pos_y = point // cols
pos_x = point % cols
coordonnees_list = [pos_x, pos_y]
points_coordonnees_list.append(coordonnees_list)
# Lecture dans le fichier raster des valeurs
values_list = getPixelsValueListImage(raster_cut,
points_coordonnees_list)
print(values_list)
for idx_point in range(len(drawn_dot_list)):
val_class = values_list[idx_point]
coordonnees_list = points_coordonnees_list[idx_point]
pos_x = coordonnees_list[0]
pos_y = coordonnees_list[1]
coor_x = xmin + (pos_x * abs(pixel_width))
coor_y = ymax - (pos_y * abs(pixel_height))
point_attr_dico = {
"Ident": idx_point,
val_ref_col: int(val_ref),
val_class_col: int(val_class)
}
points_random_value_dico[idx_point] = [[coor_x, coor_y],
point_attr_dico]
if debug >= 4:
print("idx_point : " + str(idx_point))
print("pos_x : " + str(pos_x))
print("pos_y : " + str(pos_y))
print("coor_x : " + str(coor_x))
print("coor_y : " + str(coor_y))
print("val_class : " + str(val_class))
print("")
# ETAPE 3-2 : CAS D'UN FICHIER DE POINTS DEJA EXISTANT MISE A JOUR DE LA DONNEE ISSU Du RASTER
else:
# Le fichier de points d'analyses existe
is_sample_file = True
cutVectorAll(vector_study, vector_sample_input, vector_sample_temp,
format_vector)
if input_ref_col != "":
points_coordinates_dico = readVectorFilePoints(
vector_sample_temp, [input_ref_col], format_vector)
else:
points_coordinates_dico = readVectorFilePoints(
vector_sample_temp, [], format_vector)
# Création du dico
points_random_value_dico = {}
points_coordonnees_list = []
for index_key in points_coordinates_dico:
# Recuperer les valeurs des coordonnees
coord_info_list = points_coordinates_dico[index_key]
coor_x = coord_info_list[0]
coor_y = coord_info_list[1]
pos_x = int(round((coor_x - xmin) / abs(pixel_width)))
pos_y = int(round((ymax - coor_y) / abs(pixel_height)))
coordonnees_list = [pos_x, pos_y]
points_coordonnees_list.append(coordonnees_list)
# Lecture dans le fichier raster des valeurs
values_list = getPixelsValueListImage(raster_cut,
points_coordonnees_list)
for index_key in points_coordinates_dico:
# Récuperer les valeurs des coordonnees
coord_info_list = points_coordinates_dico[index_key]
coor_x = coord_info_list[0]
coor_y = coord_info_list[1]
# Récupérer la classe de référence dans le vecteur d'entrée
if input_ref_col != "":
label = coord_info_list[2]
val_ref = label.get(input_ref_col)
# Récupérer la classe issue du raster d'entrée
val_class = values_list[index_key]
# Création du dico contenant identifiant du point, valeur de référence, valeur du raster d'entrée
point_attr_dico = {
"Ident": index_key,
val_ref_col: int(val_ref),
val_class_col: int(val_class)
}
if debug >= 4:
print("point_attr_dico: " + str(point_attr_dico))
points_random_value_dico[index_key] = [[coor_x, coor_y],
point_attr_dico]
# ETAPE 4 : CREATION ET DECOUPAGE DU FICHIER VECTEUR RESULTAT PAR LE SHAPE D'ETUDE
# Creer le fichier de points
if is_sample_file and os.path.exists(vector_sample_temp):
attribute_dico = {val_class_col: ogr.OFTInteger}
# Recopie du fichier
removeVectorFile(vector_output_temp)
copyVectorFile(vector_sample_temp, vector_output_temp)
# Ajout des champs au fichier de sortie
for field_name in attribute_dico:
addNewFieldVector(vector_output_temp, field_name,
attribute_dico[field_name], 0, None, None,
format_vector)
# Préparation des donnees
field_new_values_list = []
for index_key in points_random_value_dico:
point_attr_dico = points_random_value_dico[index_key][1]
point_attr_dico.pop(val_ref_col, None)
field_new_values_list.append(point_attr_dico)
# Ajout des donnees
setAttributeValuesList(vector_output_temp, field_new_values_list,
format_vector)
else:
# Définir les attibuts du fichier résultat
attribute_dico = {
"Ident": ogr.OFTInteger,
val_ref_col: ogr.OFTInteger,
val_class_col: ogr.OFTInteger
}
createPointsFromCoordList(attribute_dico, points_random_value_dico,
vector_output_temp, epsg, format_vector)
# Découpage du fichier de points d'echantillons
cutVectorAll(vector_study, vector_output_temp, vector_output,
format_vector)
# ETAPE 5 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES
# Suppression des données intermédiaires
if not save_results_intermediate:
if cutting_action:
removeFile(raster_cut)
else:
removeVectorFile(vector_study)
removeFile(raster_study)
if is_sample_file:
removeVectorFile(vector_sample_temp)
removeVectorFile(vector_output_temp)
print(endC)
print(bold + green +
"## END : CREATE PRINT POINTS FILE FROM CLASSIF IMAGE" + endC)
print(endC)
# Mise à jour du Log
ending_event = "estimateQualityClassification() : Masks creation ending : "
timeLine(path_time_log, ending_event)
return
def convertImage(image_input,
image_output_8bits,
image_output_compress,
need_8bits,
need_compress,
compress_type,
predictor,
zlevel,
suppr_min,
suppr_max,
need_optimize8b,
need_rvb,
need_irc,
path_time_log,
channel_order=['Red', 'Green', 'Blue', 'NIR'],
format_raster='GTiff',
extension_raster=".tif",
save_results_intermediate=False,
overwrite=True):
# Mise à jour du Log
starting_event = "convertImage() : conversion image starting : "
timeLine(path_time_log, starting_event)
# Affichage des parametres
if debug >= 3:
print(cyan + "convertImage() : " + endC + "image_input: ", image_input)
print(cyan + "convertImage() : " + endC + "image_output_8bits: ",
image_output_8bits)
print(cyan + "convertImage() : " + endC + "image_output_compress: ",
image_output_compress)
print(cyan + "convertImage() : " + endC + "need_8bits: ", need_8bits)
print(cyan + "convertImage() : " + endC + "need_compress: ",
need_compress)
print(cyan + "convertImage() : " + endC + "compress_type: ",
compress_type)
print(cyan + "convertImage() : " + endC + "predictor: ", predictor)
print(cyan + "convertImage() : " + endC + "zlevel: ", zlevel)
print(cyan + "convertImage() : " + endC + "suppr_min: ", suppr_min)
print(cyan + "convertImage() : " + endC + "suppr_max: ", suppr_max)
print(cyan + "convertImage() : " + endC + "need_rvb: ", need_rvb)
print(cyan + "convertImage() : " + endC + "need_irc: ", need_irc)
print(cyan + "convertImage() : " + endC + "path_time_log: ",
path_time_log)
print(cyan + "convertImage() : " + endC + "channel_order : " +
str(channel_order) + endC)
print(cyan + "convertImage() : " + endC + "format_raster : " +
str(format_raster) + endC)
print(cyan + "convertImage() : " + endC + "extension_raster : " +
str(extension_raster) + endC)
print(
cyan + "convertImage() : " + endC + "save_results_intermediate: ",
save_results_intermediate)
print(cyan + "convertImage() : " + endC + "overwrite: ", overwrite)
# Constantes
FOLDER_TEMP = 'Tmp_'
# Definition des dossiers de travail
image_name = os.path.splitext(os.path.basename(image_input))[0]
# Definir le nombre de bande de l'image d'entrée
cols, rows, bands = getGeometryImage(image_input)
inputBand4Found = False
if bands >= 4 and not need_rvb and not need_irc:
inputBand4Found = True
if not need_compress:
image_output_compress = image_output_8bits
repertory_tmp = os.path.dirname(
image_output_compress
) + os.sep + FOLDER_TEMP + image_name # repertory_tmp : Dossier dans lequel on va placer les images temporaires
if not os.path.isdir(repertory_tmp):
os.makedirs(repertory_tmp)
print(
cyan + "ImageCompression : " + endC +
"Dossier de travail temporaire: ", repertory_tmp)
# Impression des informations d'execution
print(endC)
print(bold + green + "# DEBUT DE LA CONVERSION DE L'IMAGE %s" %
(image_input) + endC)
print(endC)
if debug >= 1:
print(
cyan + "convertImage() : " + endC +
"%s pourcents des petites valeurs initiales et %s pourcents des grandes valeurs initiales seront supprimees"
% (suppr_min, suppr_max))
# VERIFICATION SI L'IMAGE DE SORTIE EXISTE DEJA
check = os.path.isfile(image_output_compress)
# Si oui et si la vérification est activée, passe à l'étape suivante
if check and not overwrite:
print(cyan + "convertImage() : " + bold + yellow +
"Image have already been converted." + endC)
else:
# Tente de supprimer le fichier
try:
removeFile(image_output_compress)
except Exception:
# Ignore l'exception levée si le fichier n'existe pas (et ne peut donc pas être supprimé)
pass
###########################################################
# Conversion du fichier en 8bits #
###########################################################
if need_8bits:
convertion8Bits(image_input, image_output_8bits, repertory_tmp,
inputBand4Found, need_optimize8b, need_rvb,
need_irc, channel_order, suppr_min, suppr_max,
format_raster, extension_raster,
save_results_intermediate)
image_to_compress = image_output_8bits
else:
image_to_compress = image_input
###########################################################
# Compression du fichier #
###########################################################
if need_compress:
compressImage(image_to_compress, image_output_compress,
inputBand4Found, compress_type, predictor, zlevel,
format_raster)
###########################################################
# nettoyage du repertoire temporaire #
###########################################################
if not save_results_intermediate:
shutil.rmtree(repertory_tmp)
if debug >= 1:
print(bold + green + "Suppression du dossier temporaire : " +
repertory_tmp + endC)
if debug >= 1:
print(cyan + "convertImage() : " + endC +
"Fin de la conversion de %s" % (image_input))
print(endC)
if need_compress:
print(bold + green + "# FIN DE LA CONVERSION DE L'IMAGE %s" %
(image_input) + endC)
print(endC)
# Mise à jour du Log
ending_event = "convertImage() : conversion image ending : "
timeLine(path_time_log, ending_event)
return
def selectSamples(image_input_list, sample_image_input, vector_output, table_statistics_output, sampler_strategy, select_ratio_floor, ratio_per_class_dico, name_column, no_data_value, path_time_log, rand_seed=0, ram_otb=0, epsg=2154, format_vector='ESRI Shapefile', extension_vector=".shp", save_results_intermediate=False, overwrite=True) :
# Mise à jour du Log
starting_event = "selectSamples() : Select points in raster mask macro input starting : "
timeLine(path_time_log, starting_event)
if debug >= 3:
print(cyan + "selectSamples() : " + endC + "image_input_list : " + str(image_input_list) + endC)
print(cyan + "selectSamples() : " + endC + "sample_image_input : " + str(sample_image_input) + endC)
print(cyan + "selectSamples() : " + endC + "vector_output : " + str(vector_output) + endC)
print(cyan + "selectSamples() : " + endC + "table_statistics_output : " + str(table_statistics_output) + endC)
print(cyan + "selectSamples() : " + endC + "sampler_strategy : " + str(sampler_strategy) + endC)
print(cyan + "selectSamples() : " + endC + "select_ratio_floor : " + str(select_ratio_floor) + endC)
print(cyan + "selectSamples() : " + endC + "ratio_per_class_dico : " + str(ratio_per_class_dico) + endC)
print(cyan + "selectSamples() : " + endC + "name_column : " + str(name_column) + endC)
print(cyan + "selectSamples() : " + endC + "no_data_value : " + str(no_data_value) + endC)
print(cyan + "selectSamples() : " + endC + "path_time_log : " + str(path_time_log) + endC)
print(cyan + "selectSamples() : " + endC + "rand_seed : " + str(rand_seed) + endC)
print(cyan + "selectSamples() : " + endC + "ram_otb : " + str(ram_otb) + endC)
print(cyan + "selectSamples() : " + endC + "epsg : " + str(epsg) + endC)
print(cyan + "selectSamples() : " + endC + "format_vector : " + str(format_vector) + endC)
print(cyan + "selectSamples() : " + endC + "extension_vector : " + str(extension_vector) + endC)
print(cyan + "selectSamples() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC)
print(cyan + "selectSamples() : " + endC + "overwrite : " + str(overwrite) + endC)
# Constantes
EXT_XML = ".xml"
SUFFIX_SAMPLE = "_sample"
SUFFIX_STATISTICS = "_statistics"
SUFFIX_POINTS = "_points"
SUFFIX_VALUE = "_value"
BAND_NAME = "band_"
COLUMN_CLASS = "class"
COLUMN_ORIGINFID = "originfid"
NB_POINTS = "nb_points"
AVERAGE = "average"
STANDARD_DEVIATION = "st_dev"
print(cyan + "selectSamples() : " + bold + green + "DEBUT DE LA SELECTION DE POINTS" + endC)
# Definition variables et chemins
repertory_output = os.path.dirname(vector_output)
filename = os.path.splitext(os.path.basename(vector_output))[0]
sample_points_output = repertory_output + os.sep + filename + SUFFIX_SAMPLE + extension_vector
file_statistic_points = repertory_output + os.sep + filename + SUFFIX_STATISTICS + SUFFIX_POINTS + EXT_XML
if debug >= 3:
print(cyan + "selectSamples() : " + endC + "file_statistic_points : " + str(file_statistic_points) + endC)
# 0. EXISTENCE DU FICHIER DE SORTIE
#----------------------------------
# Si le fichier vecteur points de sortie existe deja et que overwrite n'est pas activé
check = os.path.isfile(vector_output)
if check and not overwrite:
print(bold + yellow + "Samples points already done for file %s and will not be calculated again." %(vector_output) + endC)
else: # Si non ou si la vérification est désactivée : creation du fichier d'échantillons points
# Suppression de l'éventuel fichier existant
if check:
try:
removeVectorFile(vector_output)
except Exception:
pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite
if os.path.isfile(table_statistics_output) :
try:
removeFile(table_statistics_output)
except Exception:
pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite
# 1. STATISTIQUE SUR L'IMAGE DES ECHANTILLONS RASTEUR
#----------------------------------------------------
if debug >= 3:
print(cyan + "selectSamples() : " + bold + green + "Start statistique sur l'image des echantillons rasteur..." + endC)
id_micro_list = identifyPixelValues(sample_image_input)
if 0 in id_micro_list :
id_micro_list.remove(0)
min_micro_class_nb_points = -1
min_micro_class_label = 0
infoStructPointSource_dico = {}
writeTextFile(file_statistic_points, '<?xml version="1.0" ?>\n')
appendTextFileCR(file_statistic_points, '<GeneralStatistics>')
appendTextFileCR(file_statistic_points, ' <Statistic name="pointsPerClassRaw">')
if debug >= 2:
print("Nombre de points par micro classe :" + endC)
for id_micro in id_micro_list :
nb_pixels = countPixelsOfValue(sample_image_input, id_micro)
if debug >= 2:
print("MicroClass : " + str(id_micro) + ", nb_points = " + str(nb_pixels))
appendTextFileCR(file_statistic_points, ' <StatisticPoints class="%d" value="%d" />' %(id_micro, nb_pixels))
if min_micro_class_nb_points == -1 or min_micro_class_nb_points > nb_pixels :
min_micro_class_nb_points = nb_pixels
min_micro_class_label = id_micro
infoStructPointSource_dico[id_micro] = StructInfoMicoClass()
infoStructPointSource_dico[id_micro].label_class = id_micro
infoStructPointSource_dico[id_micro].nb_points = nb_pixels
infoStructPointSource_dico[id_micro].info_points_list = []
del nb_pixels
if debug >= 2:
print("MicroClass min points find : " + str(min_micro_class_label) + ", nb_points = " + str(min_micro_class_nb_points))
appendTextFileCR(file_statistic_points, ' </Statistic>')
pending_event = cyan + "selectSamples() : " + bold + green + "End statistique sur l'image des echantillons rasteur. " + endC
if debug >= 3:
print(pending_event)
timeLine(path_time_log,pending_event)
# 2. CHARGEMENT DE L'IMAGE DES ECHANTILLONS
#------------------------------------------
if debug >= 3:
print(cyan + "selectSamples() : " + bold + green + "Start chargement de l'image des echantillons..." + endC)
# Information image
cols, rows, bands = getGeometryImage(sample_image_input)
xmin, xmax, ymin, ymax = getEmpriseImage(sample_image_input)
pixel_width, pixel_height = getPixelWidthXYImage(sample_image_input)
projection_input = getProjectionImage(sample_image_input)
if projection_input == None or projection_input == 0 :
projection_input = epsg
else :
projection_input = int(projection_input)
pixel_width = abs(pixel_width)
pixel_height = abs(pixel_height)
# Lecture des données
raw_data = getRawDataImage(sample_image_input)
if debug >= 3:
print("projection = " + str(projection_input))
print("cols = " + str(cols))
print("rows = " + str(rows))
# Creation d'une structure dico contenent tous les points différents de zéro
progress = 0
pass_prog = False
for y_row in range(rows) :
for x_col in range(cols) :
value_class = raw_data[y_row][x_col]
if value_class != 0 :
infoStructPointSource_dico[value_class].info_points_list.append(x_col + (y_row * cols))
# Barre de progression
if debug >= 4:
if ((float(y_row) / rows) * 100.0 > progress) and not pass_prog :
progress += 1
pass_prog = True
print("Progression => " + str(progress) + "%")
if ((float(y_row) / rows) * 100.0 > progress + 1) :
pass_prog = False
del raw_data
pending_event = cyan + "selectSamples() : " + bold + green + "End chargement de l'image des echantillons. " + endC
if debug >= 3:
print(pending_event)
timeLine(path_time_log,pending_event)
# 3. SELECTION DES POINTS D'ECHANTILLON
#--------------------------------------
if debug >= 3:
print(cyan + "selectSamples() : " + bold + green + "Start selection des points d'echantillon..." + endC)
appendTextFileCR(file_statistic_points, ' <Statistic name="pointsPerClassSelect">')
# Rendre deterministe la fonction aléatoire de random.sample
if rand_seed > 0:
random.seed( rand_seed )
# Pour toute les micro classes
for id_micro in id_micro_list :
# Selon la stategie de selection
nb_points_ratio = 0
while switch(sampler_strategy.lower()):
if case('all'):
# Le mode de selection 'all' est choisi
nb_points_ratio = infoStructPointSource_dico[id_micro].nb_points
infoStructPointSource_dico[id_micro].sample_points_list = range(nb_points_ratio)
break
if case('percent'):
# Le mode de selection 'percent' est choisi
id_macro_class = int(math.floor(id_micro / 100) * 100)
select_ratio_class = ratio_per_class_dico[id_macro_class]
nb_points_ratio = int(infoStructPointSource_dico[id_micro].nb_points * select_ratio_class / 100)
infoStructPointSource_dico[id_micro].sample_points_list = random.sample(range(infoStructPointSource_dico[id_micro].nb_points), nb_points_ratio)
break
if case('mixte'):
# Le mode de selection 'mixte' est choisi
nb_points_ratio = int(infoStructPointSource_dico[id_micro].nb_points * select_ratio_floor / 100)
if id_micro == min_micro_class_label :
# La plus petite micro classe est concervée intégralement
infoStructPointSource_dico[id_micro].sample_points_list = range(infoStructPointSource_dico[id_micro].nb_points)
nb_points_ratio = min_micro_class_nb_points
elif nb_points_ratio <= min_micro_class_nb_points :
# Les micro classes dont le ratio de selection est inferieur au nombre de points de la plus petite classe sont égement conservées intégralement
infoStructPointSource_dico[id_micro].sample_points_list = random.sample(range(infoStructPointSource_dico[id_micro].nb_points), min_micro_class_nb_points)
nb_points_ratio = min_micro_class_nb_points
else :
# Pour toutes les autres micro classes tirage aleatoire d'un nombre de points correspondant au ratio
infoStructPointSource_dico[id_micro].sample_points_list = random.sample(range(infoStructPointSource_dico[id_micro].nb_points), nb_points_ratio)
break
break
if debug >= 2:
print("MicroClass = " + str(id_micro) + ", nb_points_ratio " + str(nb_points_ratio))
appendTextFileCR(file_statistic_points, ' <StatisticPoints class="%d" value="%d" />' %(id_micro, nb_points_ratio))
appendTextFileCR(file_statistic_points, ' </Statistic>')
appendTextFileCR(file_statistic_points, '</GeneralStatistics>')
pending_event = cyan + "selectSamples() : " + bold + green + "End selection des points d'echantillon. " + endC
if debug >= 3:
print(pending_event)
timeLine(path_time_log,pending_event)
# 4. PREPARATION DES POINTS D'ECHANTILLON
#----------------------------------------
if debug >= 3:
print(cyan + "selectSamples() : " + bold + green + "Start preparation des points d'echantillon..." + endC)
# Création du dico de points
points_random_value_dico = {}
index_dico_point = 0
for micro_class in infoStructPointSource_dico :
micro_class_struct = infoStructPointSource_dico[micro_class]
label_class = micro_class_struct.label_class
point_attr_dico = {name_column:int(label_class), COLUMN_CLASS:int(label_class), COLUMN_ORIGINFID:0}
for id_point in micro_class_struct.sample_points_list:
# Recuperer les valeurs des coordonnees des points
coor_x = float(xmin + (int(micro_class_struct.info_points_list[id_point] % cols) * pixel_width)) + (pixel_width / 2.0)
coor_y = float(ymax - (int(micro_class_struct.info_points_list[id_point] / cols) * pixel_height)) - (pixel_height / 2.0)
points_random_value_dico[index_dico_point] = [[coor_x, coor_y], point_attr_dico]
del coor_x
del coor_y
index_dico_point += 1
del point_attr_dico
del infoStructPointSource_dico
pending_event = cyan + "selectSamples() : " + bold + green + "End preparation des points d'echantillon. " + endC
if debug >=3:
print(pending_event)
timeLine(path_time_log,pending_event)
# 5. CREATION DU FICHIER SHAPE DE POINTS D'ECHANTILLON
#-----------------------------------------------------
if debug >= 3:
print(cyan + "selectSamples() : " + bold + green + "Start creation du fichier shape de points d'echantillon..." + endC)
# Définir les attibuts du fichier résultat
attribute_dico = {name_column:ogr.OFTInteger, COLUMN_CLASS:ogr.OFTInteger, COLUMN_ORIGINFID:ogr.OFTInteger}
# Creation du fichier shape
createPointsFromCoordList(attribute_dico, points_random_value_dico, sample_points_output, projection_input, format_vector)
del attribute_dico
del points_random_value_dico
pending_event = cyan + "selectSamples() : " + bold + green + "End creation du fichier shape de points d'echantillon. " + endC
if debug >=3:
print(pending_event)
timeLine(path_time_log,pending_event)
# 6. EXTRACTION DES POINTS D'ECHANTILLONS
#-----------------------------------------
if debug >= 3:
print(cyan + "selectSamples() : " + bold + green + "Start extraction des points d'echantillon dans l'image..." + endC)
# Cas ou l'on a une seule image
if len(image_input_list) == 1:
# Extract sample
image_input = image_input_list[0]
command = "otbcli_SampleExtraction -in %s -vec %s -outfield prefix -outfield.prefix.name %s -out %s -field %s" %(image_input, sample_points_output, BAND_NAME, vector_output, name_column)
if ram_otb > 0:
command += " -ram %d" %(ram_otb)
if debug >= 3:
print(command)
exitCode = os.system(command)
if exitCode != 0:
raise NameError(cyan + "selectSamples() : " + bold + red + "An error occured during otbcli_SampleExtraction command. See error message above." + endC)
# Cas de plusieurs imagettes
else :
# Le repertoire de sortie
repertory_output = os.path.dirname(vector_output)
# Initialisation de la liste pour le multi-threading et la liste de l'ensemble des echantions locaux
thread_list = []
vector_local_output_list = []
# Obtenir l'emprise des images d'entrées pour redecouper le vecteur d'echantillon d'apprentissage pour chaque image
for image_input in image_input_list :
# Definition des fichiers sur emprise local
file_name = os.path.splitext(os.path.basename(image_input))[0]
emprise_local_sample = repertory_output + os.sep + file_name + SUFFIX_SAMPLE + extension_vector
vector_sample_local_output = repertory_output + os.sep + file_name + SUFFIX_VALUE + extension_vector
vector_local_output_list.append(vector_sample_local_output)
# Gestion sans thread...
#SampleLocalExtraction(image_input, sample_points_output, emprise_local_sample, vector_sample_local_output, name_column, BAND_NAME, ram_otb, format_vector, extension_vector, save_results_intermediate)
# Gestion du multi threading
thread = threading.Thread(target=SampleLocalExtraction, args=(image_input, sample_points_output, emprise_local_sample, vector_sample_local_output, name_column, BAND_NAME, ram_otb, format_vector, extension_vector, save_results_intermediate))
thread.start()
thread_list.append(thread)
# Extraction des echantions points des images
try:
for thread in thread_list:
thread.join()
except:
print(cyan + "selectSamples() : " + bold + red + "Erreur lors de l'éextaction des valeurs d'echantion : impossible de demarrer le thread" + endC, file=sys.stderr)
# Fusion des multi vecteurs de points contenant les valeurs des bandes de l'image
fusionVectors(vector_local_output_list, vector_output, format_vector)
# Clean des vecteurs point sample local file
for vector_sample_local_output in vector_local_output_list :
removeVectorFile(vector_sample_local_output)
if debug >= 3:
print(cyan + "selectSamples() : " + bold + green + "End extraction des points d'echantillon dans l'image." + endC)
# 7. CALCUL DES STATISTIQUES SUR LES VALEURS DES POINTS D'ECHANTILLONS SELECTIONNEES
#-----------------------------------------------------------------------------------
if debug >= 3:
print(cyan + "selectSamples() : " + bold + green + "Start calcul des statistiques sur les valeurs des points d'echantillons selectionnees..." + endC)
# Si le calcul des statistiques est demandé presence du fichier stat
if table_statistics_output != "":
# On récupère la liste de données
pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part1... " + endC
if debug >=4:
print(pending_event)
timeLine(path_time_log,pending_event)
attribute_name_dico = {}
name_field_value_list = []
names_attribut_list = getAttributeNameList(vector_output, format_vector)
if debug >=4:
print("names_attribut_list = " + str(names_attribut_list))
attribute_name_dico[name_column] = ogr.OFTInteger
for name_attribut in names_attribut_list :
if BAND_NAME in name_attribut :
attribute_name_dico[name_attribut] = ogr.OFTReal
name_field_value_list.append(name_attribut)
name_field_value_list.sort()
res_values_dico = getAttributeValues(vector_output, None, None, attribute_name_dico, format_vector)
del attribute_name_dico
# Trie des données par identifiant micro classes
pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part2... " + endC
if debug >=4:
print(pending_event)
timeLine(path_time_log,pending_event)
data_value_by_micro_class_dico = {}
stat_by_micro_class_dico = {}
# Initilisation du dico complexe
for id_micro in id_micro_list :
data_value_by_micro_class_dico[id_micro] = {}
stat_by_micro_class_dico[id_micro] = {}
for name_field_value in res_values_dico :
if name_field_value != name_column :
data_value_by_micro_class_dico[id_micro][name_field_value] = []
stat_by_micro_class_dico[id_micro][name_field_value] = {}
stat_by_micro_class_dico[id_micro][name_field_value][AVERAGE] = 0.0
stat_by_micro_class_dico[id_micro][name_field_value][STANDARD_DEVIATION] = 0.0
# Trie des valeurs
pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part3... " + endC
if debug >=4:
print(pending_event)
timeLine(path_time_log,pending_event)
for index in range(len(res_values_dico[name_column])) :
id_micro = res_values_dico[name_column][index]
for name_field_value in name_field_value_list :
data_value_by_micro_class_dico[id_micro][name_field_value].append(res_values_dico[name_field_value][index])
del res_values_dico
# Calcul des statistiques
pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part4... " + endC
if debug >=4:
print(pending_event)
timeLine(path_time_log,pending_event)
for id_micro in id_micro_list :
for name_field_value in name_field_value_list :
try :
stat_by_micro_class_dico[id_micro][name_field_value][AVERAGE] = average(data_value_by_micro_class_dico[id_micro][name_field_value])
except:
stat_by_micro_class_dico[id_micro][name_field_value][AVERAGE] = 0
try :
stat_by_micro_class_dico[id_micro][name_field_value][STANDARD_DEVIATION] = standardDeviation(data_value_by_micro_class_dico[id_micro][name_field_value])
except:
stat_by_micro_class_dico[id_micro][name_field_value][STANDARD_DEVIATION] = 0
try :
stat_by_micro_class_dico[id_micro][name_field_value][NB_POINTS] = len(data_value_by_micro_class_dico[id_micro][name_field_value])
except:
stat_by_micro_class_dico[id_micro][name_field_value][NB_POINTS] = 0
del data_value_by_micro_class_dico
# Creation du fichier statistique .csv
pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part5... " + endC
if debug >= 4:
print(pending_event)
timeLine(path_time_log,pending_event)
text_csv = " Micro classes ; Champs couche image ; Nombre de points ; Moyenne ; Ecart type \n"
writeTextFile(table_statistics_output, text_csv)
for id_micro in id_micro_list :
for name_field_value in name_field_value_list :
# Ecriture du fichier
text_csv = " %d " %(id_micro)
text_csv += " ; %s" %(name_field_value)
text_csv += " ; %d" %(stat_by_micro_class_dico[id_micro][name_field_value][NB_POINTS])
text_csv += " ; %f" %(stat_by_micro_class_dico[id_micro][name_field_value][AVERAGE])
text_csv += " ; %f" %(stat_by_micro_class_dico[id_micro][name_field_value][STANDARD_DEVIATION])
appendTextFileCR(table_statistics_output, text_csv)
del name_field_value_list
else :
if debug >=3:
print(cyan + "selectSamples() : " + bold + green + "Pas de calcul des statistiques sur les valeurs des points demander!!!." + endC)
del id_micro_list
pending_event = cyan + "selectSamples() : " + bold + green + "End calcul des statistiques sur les valeurs des points d'echantillons selectionnees. " + endC
if debug >= 3:
print(pending_event)
timeLine(path_time_log,pending_event)
# 8. SUPRESSION DES FICHIERS INTERMEDIAIRES
#------------------------------------------
if not save_results_intermediate:
if os.path.isfile(sample_points_output) :
removeVectorFile(sample_points_output)
print(cyan + "selectSamples() : " + bold + green + "FIN DE LA SELECTION DE POINTS" + endC)
# Mise à jour du Log
ending_event = "selectSamples() : Select points in raster mask macro input ending : "
timeLine(path_time_log,ending_event)
return
def createMacroSamples(image_input,
vector_to_cut_input,
vector_sample_output,
raster_sample_output,
bd_vector_input_list,
bd_buff_list,
sql_expression_list,
path_time_log,
macro_sample_name="",
simplify_vector_param=10.0,
format_vector='ESRI Shapefile',
extension_vector=".shp",
save_results_intermediate=False,
overwrite=True):
# Mise à jour du Log
starting_event = "createMacroSamples() : create macro samples starting : "
timeLine(path_time_log, starting_event)
if debug >= 3:
print(bold + green +
"createMacroSamples() : Variables dans la fonction" + endC)
print(cyan + "createMacroSamples() : " + endC + "image_input : " +
str(image_input) + endC)
print(cyan + "createMacroSamples() : " + endC +
"vector_to_cut_input : " + str(vector_to_cut_input) + endC)
print(cyan + "createMacroSamples() : " + endC +
"vector_sample_output : " + str(vector_sample_output) + endC)
print(cyan + "createMacroSamples() : " + endC +
"raster_sample_output : " + str(raster_sample_output) + endC)
print(cyan + "createMacroSamples() : " + endC +
"bd_vector_input_list : " + str(bd_vector_input_list) + endC)
print(cyan + "createMacroSamples() : " + endC + "bd_buff_list : " +
str(bd_buff_list) + endC)
print(cyan + "createMacroSamples() : " + endC +
"sql_expression_list : " + str(sql_expression_list) + endC)
print(cyan + "createMacroSamples() : " + endC + "path_time_log : " +
str(path_time_log) + endC)
print(cyan + "createMacroSamples() : " + endC +
"macro_sample_name : " + str(macro_sample_name) + endC)
print(cyan + "createMacroSamples() : " + endC +
"simplify_vector_param : " + str(simplify_vector_param) + endC)
print(cyan + "createMacroSamples() : " + endC + "format_vector : " +
str(format_vector))
print(cyan + "createMacroSamples() : " + endC + "extension_vector : " +
str(extension_vector) + endC)
print(cyan + "createMacroSamples() : " + endC +
"save_results_intermediate : " + str(save_results_intermediate) +
endC)
print(cyan + "createMacroSamples() : " + endC + "overwrite : " +
str(overwrite) + endC)
# Constantes
FOLDER_MASK_TEMP = "Mask_"
FOLDER_CUTTING_TEMP = "Cut_"
FOLDER_FILTERING_TEMP = "Filter_"
FOLDER_BUFF_TEMP = "Buff_"
SUFFIX_MASK_CRUDE = "_crude"
SUFFIX_MASK = "_mask"
SUFFIX_VECTOR_CUT = "_cut"
SUFFIX_VECTOR_FILTER = "_filt"
SUFFIX_VECTOR_BUFF = "_buff"
CODAGE = "uint8"
# ETAPE 1 : NETTOYER LES DONNEES EXISTANTES
print(cyan + "createMacroSamples() : " + bold + green +
"Nettoyage de l'espace de travail..." + endC)
# Nom du repertoire de calcul
repertory_macrosamples_output = os.path.dirname(vector_sample_output)
# Test si le vecteur echantillon existe déjà et si il doit être écrasés
check = os.path.isfile(vector_sample_output) or os.path.isfile(
raster_sample_output)
if check and not overwrite: # Si les fichiers echantillons existent deja et que overwrite n'est pas activé
print(bold + yellow + "File sample : " + vector_sample_output +
" already exists and will not be created again." + endC)
else:
if check:
try:
removeVectorFile(vector_sample_output)
removeFile(raster_sample_output)
except Exception:
pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée
# Définition des répertoires temporaires
repertory_mask_temp = repertory_macrosamples_output + os.sep + FOLDER_MASK_TEMP + macro_sample_name
repertory_samples_cutting_temp = repertory_macrosamples_output + os.sep + FOLDER_CUTTING_TEMP + macro_sample_name
repertory_samples_filtering_temp = repertory_macrosamples_output + os.sep + FOLDER_FILTERING_TEMP + macro_sample_name
repertory_samples_buff_temp = repertory_macrosamples_output + os.sep + FOLDER_BUFF_TEMP + macro_sample_name
if debug >= 4:
print(cyan + "createMacroSamples() : " + endC +
"Création du répertoire : " + str(repertory_mask_temp))
print(cyan + "createMacroSamples() : " + endC +
"Création du répertoire : " +
str(repertory_samples_cutting_temp))
print(cyan + "createMacroSamples() : " + endC +
"Création du répertoire : " +
str(repertory_samples_buff_temp))
# Création des répertoires temporaire qui n'existent pas
if not os.path.isdir(repertory_macrosamples_output):
os.makedirs(repertory_macrosamples_output)
if not os.path.isdir(repertory_mask_temp):
os.makedirs(repertory_mask_temp)
if not os.path.isdir(repertory_samples_cutting_temp):
os.makedirs(repertory_samples_cutting_temp)
if not os.path.isdir(repertory_samples_filtering_temp):
os.makedirs(repertory_samples_filtering_temp)
if not os.path.isdir(repertory_samples_buff_temp):
os.makedirs(repertory_samples_buff_temp)
# Nettoyage des répertoires temporaire qui ne sont pas vide
cleanTempData(repertory_mask_temp)
cleanTempData(repertory_samples_cutting_temp)
cleanTempData(repertory_samples_filtering_temp)
cleanTempData(repertory_samples_buff_temp)
print(cyan + "createMacroSamples() : " + bold + green +
"... fin du nettoyage" + endC)
# ETAPE 2 : DECOUPAGE DES VECTEURS
print(cyan + "createMacroSamples() : " + bold + green +
"Decoupage des echantillons ..." + endC)
if vector_to_cut_input == None:
# 2.1 : Création du masque délimitant l'emprise de la zone par image
image_name = os.path.splitext(os.path.basename(image_input))[0]
vector_mask = repertory_mask_temp + os.sep + image_name + SUFFIX_MASK_CRUDE + extension_vector
cols, rows, num_band = getGeometryImage(image_input)
no_data_value = getNodataValueImage(image_input, num_band)
if no_data_value == None:
no_data_value = 0
createVectorMask(image_input, vector_mask, no_data_value,
format_vector)
# 2.2 : Simplification du masque
vector_simple_mask = repertory_mask_temp + os.sep + image_name + SUFFIX_MASK + extension_vector
simplifyVector(vector_mask, vector_simple_mask,
simplify_vector_param, format_vector)
else:
vector_simple_mask = vector_to_cut_input
# 2.3 : Découpage des vecteurs de bd exogenes avec le masque
vectors_cut_list = []
for vector_input in bd_vector_input_list:
vector_name = os.path.splitext(os.path.basename(vector_input))[0]
vector_cut = repertory_samples_cutting_temp + os.sep + vector_name + SUFFIX_VECTOR_CUT + extension_vector
vectors_cut_list.append(vector_cut)
cutoutVectors(vector_simple_mask, bd_vector_input_list,
vectors_cut_list, format_vector)
print(cyan + "createMacroSamples() : " + bold + green +
"... fin du decoupage" + endC)
# ETAPE 3 : FILTRAGE DES VECTEURS
print(cyan + "createMacroSamples() : " + bold + green +
"Filtrage des echantillons ..." + endC)
vectors_filtered_list = []
if sql_expression_list != []:
for idx_vector in range(len(bd_vector_input_list)):
vector_name = os.path.splitext(
os.path.basename(bd_vector_input_list[idx_vector]))[0]
vector_cut = vectors_cut_list[idx_vector]
if idx_vector < len(sql_expression_list):
sql_expression = sql_expression_list[idx_vector]
else:
sql_expression = ""
vector_filtered = repertory_samples_filtering_temp + os.sep + vector_name + SUFFIX_VECTOR_FILTER + extension_vector
vectors_filtered_list.append(vector_filtered)
# Filtrage par ogr2ogr
if sql_expression != "":
names_attribut_list = getAttributeNameList(
vector_cut, format_vector)
column = "'"
for name_attribut in names_attribut_list:
column += name_attribut + ", "
column = column[0:len(column) - 2]
column += "'"
ret = filterSelectDataVector(vector_cut, vector_filtered,
column, sql_expression,
format_vector)
if not ret:
print(
cyan + "createMacroSamples() : " + bold + yellow +
"Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte"
% (sql_expression) + endC)
copyVectorFile(vector_cut, vector_filtered)
else:
print(cyan + "createMacroSamples() : " + bold + yellow +
"Pas de filtrage sur le fichier du nom : " + endC +
vector_filtered)
copyVectorFile(vector_cut, vector_filtered)
else:
print(cyan + "createMacroSamples() : " + bold + yellow +
"Pas de filtrage demandé" + endC)
for idx_vector in range(len(bd_vector_input_list)):
vector_cut = vectors_cut_list[idx_vector]
vectors_filtered_list.append(vector_cut)
print(cyan + "createMacroSamples() : " + bold + green +
"... fin du filtrage" + endC)
# ETAPE 4 : BUFFERISATION DES VECTEURS
print(cyan + "createMacroSamples() : " + bold + green +
"Mise en place des tampons..." + endC)
vectors_buffered_list = []
if bd_buff_list != []:
# Parcours des vecteurs d'entrée
for idx_vector in range(len(bd_vector_input_list)):
vector_name = os.path.splitext(
os.path.basename(bd_vector_input_list[idx_vector]))[0]
buff = bd_buff_list[idx_vector]
vector_filtered = vectors_filtered_list[idx_vector]
vector_buffered = repertory_samples_buff_temp + os.sep + vector_name + SUFFIX_VECTOR_BUFF + extension_vector
if buff != 0:
if os.path.isfile(vector_filtered):
if debug >= 3:
print(cyan + "createMacroSamples() : " + endC +
"vector_filtered : " + str(vector_filtered) +
endC)
print(cyan + "createMacroSamples() : " + endC +
"vector_buffered : " + str(vector_buffered) +
endC)
print(cyan + "createMacroSamples() : " + endC +
"buff : " + str(buff) + endC)
bufferVector(vector_filtered, vector_buffered, buff,
"", 1.0, 10, format_vector)
else:
print(cyan + "createMacroSamples() : " + bold +
yellow + "Pas de fichier du nom : " + endC +
vector_filtered)
else:
print(cyan + "createMacroSamples() : " + bold + yellow +
"Pas de tampon sur le fichier du nom : " + endC +
vector_filtered)
copyVectorFile(vector_filtered, vector_buffered)
vectors_buffered_list.append(vector_buffered)
else:
print(cyan + "createMacroSamples() : " + bold + yellow +
"Pas de tampon demandé" + endC)
for idx_vector in range(len(bd_vector_input_list)):
vector_filtered = vectors_filtered_list[idx_vector]
vectors_buffered_list.append(vector_filtered)
print(cyan + "createMacroSamples() : " + bold + green +
"... fin de la mise en place des tampons" + endC)
# ETAPE 5 : FUSION DES SHAPES
print(cyan + "createMacroSamples() : " + bold + green +
"Fusion par macroclasse ..." + endC)
# si une liste de fichier shape à fusionner existe
if not vectors_buffered_list:
print(cyan + "createMacroSamples() : " + bold + yellow +
"Pas de fusion sans donnee à fusionner" + endC)
# s'il n'y a qu'un fichier shape en entrée
elif len(vectors_buffered_list) == 1:
print(cyan + "createMacroSamples() : " + bold + yellow +
"Pas de fusion pour une seule donnee à fusionner" + endC)
copyVectorFile(vectors_buffered_list[0], vector_sample_output)
else:
# Fusion des fichiers shape
vectors_buffered_controled_list = []
for vector_buffered in vectors_buffered_list:
if os.path.isfile(vector_buffered) and (getGeometryType(
vector_buffered, format_vector) in (
'POLYGON', 'MULTIPOLYGON')) and (getNumberFeature(
vector_buffered, format_vector) > 0):
vectors_buffered_controled_list.append(vector_buffered)
else:
print(
cyan + "createMacroSamples() : " + bold + red +
"Attention fichier bufferisé est vide il ne sera pas fusionné : "
+ endC + vector_buffered,
file=sys.stderr)
fusionVectors(vectors_buffered_controled_list,
vector_sample_output, format_vector)
print(cyan + "createMacroSamples() : " + bold + green +
"... fin de la fusion" + endC)
# ETAPE 6 : CREATION DU FICHIER RASTER RESULTAT SI DEMANDE
# Creation d'un masque binaire
if raster_sample_output != "" and image_input != "":
repertory_output = os.path.dirname(raster_sample_output)
if not os.path.isdir(repertory_output):
os.makedirs(repertory_output)
rasterizeBinaryVector(vector_sample_output, image_input,
raster_sample_output, 1, CODAGE)
# ETAPE 7 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES
# Suppression des données intermédiaires
if not save_results_intermediate:
# Supression du fichier de decoupe si celui ci a été créer
if vector_simple_mask != vector_to_cut_input:
if os.path.isfile(vector_simple_mask):
removeVectorFile(vector_simple_mask)
# Suppression des repertoires temporaires
deleteDir(repertory_mask_temp)
deleteDir(repertory_samples_cutting_temp)
deleteDir(repertory_samples_filtering_temp)
deleteDir(repertory_samples_buff_temp)
# Mise à jour du Log
ending_event = "createMacroSamples() : create macro samples ending : "
timeLine(path_time_log, ending_event)
return