def processingMacroSample(sample_raster_file_input, sample_raster_file_output, file_mask_input, threshold_min, threshold_max, filter_size_zone_0, filter_size_zone_1, mask_operator, repertory_temp, codage, path_time_log) : # Mise à jour du Log starting_event = "processingMacroSample() : processing macro sample starting : " timeLine(path_time_log,starting_event) if debug >= 3: print(" ") print(bold + green + "processingMacroSample() : Variables dans la fonction" + endC) print(cyan + "processingMacroSample() : " + endC + "sample_raster_file_input : " + str(sample_raster_file_input) + endC) print(cyan + "processingMacroSample() : " + endC + "sample_raster_file_output : " + str(sample_raster_file_output) + endC) print(cyan + "processingMacroSample() : " + endC + "file_mask_input : " + str(file_mask_input) + endC) print(cyan + "processingMacroSample() : " + endC + "threshold_min : " + str(threshold_min) + endC) print(cyan + "processingMacroSample() : " + endC + "threshold_max : " + str(threshold_max) + endC) print(cyan + "processingMacroSample() : " + endC + "filter_size_zone_0 : " + str(filter_size_zone_0) + endC) print(cyan + "processingMacroSample() : " + endC + "filter_size_zone_1 : " + str(filter_size_zone_1) + endC) print(cyan + "processingMacroSample() : " + endC + "mask_operator : " + str(mask_operator) + endC) print(cyan + "processingMacroSample() : " + endC + "repertory_temp : " + str(repertory_temp) + endC) print(cyan + "processingMacroSample() : " + endC + "codage : " + str(codage) + endC) print(cyan + "processingMacroSample() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "processingMacroSample() : " + bold + green + "Traitement en cours..." + endC) # Traitement préparation file_mask_output_temp = repertory_temp + os.sep + os.path.splitext(os.path.basename(file_mask_input))[0] + "_mask_tmp" + os.path.splitext(file_mask_input)[1] if os.path.isfile(file_mask_output_temp) : removeFile(file_mask_output_temp) file_mask_filtered_output_temp = repertory_temp + os.sep + os.path.splitext(os.path.basename(file_mask_input))[0] + "_mask_filtered_tmp" + os.path.splitext(file_mask_input)[1] if os.path.isfile(file_mask_filtered_output_temp) : removeFile(file_mask_filtered_output_temp) # Creation masque binaire createBinaryMaskThreshold(file_mask_input, file_mask_output_temp, threshold_min, threshold_max) # Filtrage binaire if filter_size_zone_0 != 0 or filter_size_zone_1 != 0 : filterBinaryRaster(file_mask_output_temp, file_mask_filtered_output_temp, filter_size_zone_0, filter_size_zone_1) else : file_mask_filtered_output_temp = file_mask_output_temp # Masquage des zones non retenues if mask_operator.lower() == "and" : applyMaskAnd(sample_raster_file_input, file_mask_filtered_output_temp, sample_raster_file_output, codage) elif mask_operator.lower() == "or" : applyMaskOr(sample_raster_file_input, file_mask_filtered_output_temp, sample_raster_file_output, codage) else : raise NameError (cyan + "processingMacroSample() : " + bold + red + "Mask operator unknown : " + str(mask_operator) + endC) print(cyan + "processingMacroSample() : " + bold + green + "Fin du traitement" + endC) # Mise à jour du Log ending_event = "processingMacroSample() : processing macro sample ending : " timeLine(path_time_log,ending_event) return
def computeAreaMicro(repertory_output, table_input_name, data_base_name, micro): sql_temporary_file = repertory_output + os.sep + "spatialiteTemp.txt" requete = sqlSurfaceMicro(table_input_name, "ID", micro, data_base_name) exitCode = os.system("%s > %s"%(requete,sql_temporary_file)) if exitCode != 0: raise NameError(cyan + "computeAreaMicro() : " + bold + red + "An error occured during fileCreation command. See error message above." + endC) # Calculer la surface de la microclasse area_micro = float(readTextFileBySeparator(sql_temporary_file, " ")[0][0]) removeFile(sql_temporary_file) return area_micro
def createMask(image_input, vector_samples_input, image_masked, path_time_log, save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "createMask() : Masks creation starting : " timeLine(path_time_log,starting_event) print(endC) print(bold + green + "## START : MASQUES CREATION" + endC) print(endC) CODAGE = "uint8" if debug >= 2: print(bold + green + "createMask() : Variables dans la fonction" + endC) print(cyan + "createMask() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "createMask() : " + endC + "vector_samples_input : " + str(vector_samples_input) + endC) print(cyan + "createMask() : " + endC + "image_masked : " + str(image_masked) + endC) print(cyan + "createMask() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "createMask() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "createMask() : " + endC + "overwrite : " + str(overwrite) + endC) # RASTERIZATION DES VECTEURS D'APPRENTISSAGE # VERIFICATION SI LE MASQUE DE SORTIE EXISTE DEJA # Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors passe au masque suivant check = os.path.isfile(image_masked) if check and not overwrite: print(bold + yellow + "createMask() : " + endC + "Computing mask from %s with %s already done : no actualisation" % (image_input, vector_samples_input) + endC) # Si non, ou si la fonction ecrasement est désative, alors on le calcule else: if check: try: # Suppression de l'éventuel fichier existant removeFile(image_masked) except Exception: pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite # EXTRACTION DU MASQUE print(bold + green + "createMask() : " + endC + "Computing mask from %s with %s " %(image_input, vector_samples_input) + endC) rasterizeBinaryVector(vector_samples_input, image_input, image_masked, 1, CODAGE) print(bold + green + "createMask() : " + endC + "Computing mask from %s with %s completed" %(image_input, vector_samples_input) + endC) print(endC) print(bold + green + "## END : MASQUES CREATION" + endC) print(endC) # Mise à jour du Log ending_event = "createMask() : Masks creation ending : " timeLine(path_time_log,ending_event) return
def getFtp(ftp, path_ftp, local_path, all_path, file_error): EXT_LIST = ['.tif', '.tiff', '.ecw', '.jp2', '.asc'] ftp.cwd(path_ftp) data_list = [] ftp.retrlines("LIST", data_list.append) for data in data_list: data_tmp = data.split(' ') filename = data_tmp[len(data_tmp) - 1] if data[0] == 'd': print(cyan + "getFtp() : " + green + "Get directory : " + filename + endC) getFtp(ftp, filename, local_path + os.sep + filename, all_path + os.sep + filename, file_error) ftp.cwd("..") else: print(cyan + "getFtp() : " + green + "Download file : " + filename + endC) try: local_filename = local_path + os.sep + filename filename_error = all_path + os.sep + filename if not os.path.isdir(local_path): os.makedirs(local_path) ftp.retrbinary("RETR " + filename, open(local_filename, 'wb').write) except: print(cyan + "getFtp() : " + bold + red + "Error during download " + filename + " from FTP" + endC, file=sys.stderr) appendTextFileCR(file_error, filename_error) if os.path.isfile(local_filename): removeFile(local_filename) extent_name = os.path.splitext( os.path.basename(local_filename))[1].lower() if extent_name in EXT_LIST: test_image = imageControl(local_filename) if not test_image: appendTextFileCR(file_error, filename_error) if os.path.isfile(local_filename): removeFile(local_filename) return
def computeConfusionMatrix(classif_image_file, validation_input_vector, validation_input_raster, validation_id_field, output, no_data_value, overwrite): # calcul de la matrice de confusion check = os.path.isfile(output) if check and not overwrite: print(cyan + "computeConfusionMatrix() : " + bold + yellow + "Confusion matrix already exists." + '\n' + endC) else: # Tente de supprimer le fichier try: removeFile(output) except Exception: # Ignore l'exception levee si le fichier n'existe pas (et ne peut donc pas être supprime) pass if debug >= 2: print(cyan + "computeConfusionMatrix() : " + bold + green + "Assessing quality..." + '\n' + endC) # Test si on entre avec des echantillons de controles au format vecteur ou au format raster if validation_input_vector != None: # Cas d'echantillons vecteur command = "otbcli_ComputeConfusionMatrix -in %s -ref vector -ref.vector.in %s -ref.vector.field %s -no_data_value %s -ref.vector.nodata %s -out %s" % ( classif_image_file, validation_input_vector, validation_id_field, str(no_data_value), str(no_data_value), output) else: # Cas d'echantillons raster command = "otbcli_ComputeConfusionMatrix -in %s -ref raster -ref.raster.in %s -no_data_value %s -ref.raster.nodata %s -out %s" % ( classif_image_file, validation_input_raster, str(no_data_value), str(no_data_value), output) if debug >= 3: print(command) exitCode = os.system(command) if exitCode != 0: raise NameError( cyan + "computeConfusionMatrix() : " + bold + red + "An error occured during otbcli_ComputeConfusionMatrix command. See error message above." + endC) if debug >= 2: print(cyan + "computeConfusionMatrix() : " + bold + green + "Confusion matrix created" + '\n' + endC) return
def computeAverageAreaMacro(repertory_output, class_labels_list, table_input_name, data_base_name): average_area_macro_list = [] sql_temporary_file = repertory_output + os.sep + "spatialiteTemp.txt" for class_label in class_labels_list: requete = sqlSurfaceAverageMacro(table_input_name, "ID", class_label, data_base_name) exitCode = os.system("%s > %s"%(requete,sql_temporary_file)) if exitCode != 0: raise NameError(cyan + "computeAverageAreaMacro() : " + bold + red + "An error occured during file creation. See error message above." + endC) requete_result = readTextFileBySeparator(sql_temporary_file, " ") print(requete_result) if requete_result == []: average_area_macro_list.append(0) else: average_area_macro_list.append(float(requete_result[0][0])) removeFile(sql_temporary_file) return average_area_macro_list
def displayCommands(command_doc, debug): # Constantes EXT_DOT = ".dot" EXT_PNG = ".png" GRAPH_NAME = "workflows_commandes" process = None while not getEndDisplay(): # Define dot file dot_file = os.path.splitext(command_doc)[0] + EXT_DOT if os.path.isfile(dot_file): removeFile(dot_file) png_file = os.path.splitext(command_doc)[0] + EXT_PNG # Processing file .dot struct_cmd_dico = readCommands(command_doc, debug) if struct_cmd_dico is not None and struct_cmd_dico != {}: convert2dot(command_doc, struct_cmd_dico, GRAPH_NAME, dot_file, debug) # Ignore Graphviz warning messages warnings.simplefilter('ignore', RuntimeWarning) graph = pgv.AGraph(name=GRAPH_NAME) # Convert file .dot graph.read(dot_file) graph.layout(prog='dot') # layout with default (neato) png_draw = graph.draw(png_file, format='png', prog='dot') # Affichage image PNG process, root = displayImage(process, png_file, GRAPH_NAME, debug) # Attente avant boucle time.sleep(1) # Fin arret de l'affichage de l'image endDisplayImage(process, root) return
def vectorsListToOcs(input_text, output_raster, footprint_vector, reference_raster, codage_raster='uint8', epsg=2154, no_data_value=0, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster='.tif', extension_vector='.shp', path_time_log='', save_results_intermediate=False, overwrite=True): if debug >= 3: print( '\n' + bold + green + "OCS raster à partir d'une liste de vecteurs - Variables dans la fonction :" + endC) print(cyan + " vectorsListToOcs() : " + endC + "input_text : " + str(input_text) + endC) print(cyan + " vectorsListToOcs() : " + endC + "output_raster : " + str(output_raster) + endC) print(cyan + " vectorsListToOcs() : " + endC + "footprint_vector : " + str(footprint_vector) + endC) print(cyan + " vectorsListToOcs() : " + endC + "reference_raster : " + str(reference_raster) + endC) print(cyan + " vectorsListToOcs() : " + endC + "codage_raster : " + str(codage_raster) + endC) print(cyan + " vectorsListToOcs() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + " vectorsListToOcs() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + " vectorsListToOcs() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + " vectorsListToOcs() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + " vectorsListToOcs() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + " vectorsListToOcs() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + " vectorsListToOcs() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + " vectorsListToOcs() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + " vectorsListToOcs() : " + endC + "overwrite : " + str(overwrite) + endC + '\n') # Définition des constantes SUFFIX_TEMP = '_temp' SUFFIX_CUT = '_cut' SUFFIX_FILTER = '_filter' SUFFIX_BUFFER = '_buffer' TEXT_SEPARATOR = ':' # Mise à jour du log starting_event = "vectorsListToOcs() : Début du traitement : " timeLine(path_time_log, starting_event) print(cyan + "vectorsListToOcs() : " + bold + green + "DEBUT DES TRAITEMENTS" + endC + '\n') # Définition des variables 'basename' output_raster_basename = os.path.basename( os.path.splitext(output_raster)[0]) output_raster_dirname = os.path.dirname(output_raster) # Définition des variables temp temp_directory = output_raster_dirname + os.sep + output_raster_basename + SUFFIX_TEMP temp_raster = temp_directory + os.sep + output_raster_basename + SUFFIX_TEMP + extension_raster # Nettoyage des traitements précédents if overwrite: if debug >= 3: print(cyan + "vectorsListToOcs() : " + endC + "Nettoyage des traitements précédents." + '\n') removeFile(output_raster) cleanTempData(temp_directory) else: if os.path.exists(output_raster): print(cyan + "vectorsListToOcs() : " + bold + yellow + "Le fichier de sortie existe déjà et ne sera pas regénéré." + endC) raise if not os.path.exixts(temp_directory): os.makedirs(temp_directory) pass # Test de l'emprise des fichiers vecteur d'emprise et raster de référence (le raster doit être de même taille ou plus grand que le vecteur) xmin_fpt, xmax_fpt, ymin_fpt, ymax_fpt = getEmpriseFile( footprint_vector, format_vector=format_vector) xmin_ref, xmax_ref, ymin_ref, ymax_ref = getEmpriseImage(reference_raster) if round(xmin_fpt, 4) < round(xmin_ref, 4) or round(xmax_fpt, 4) > round( xmax_ref, 4) or round(ymin_fpt, 4) < round(ymin_ref, 4) or round( ymax_fpt, 4) > round(ymax_ref, 4): print(cyan + "vectorsListToOcs() : " + bold + red + "xmin_fpt, xmax_fpt, ymin_fpt, ymax_fpt" + endC, xmin_fpt, xmax_fpt, ymin_fpt, ymax_fpt, file=sys.stderr) print(cyan + "vectorsListToOcs() : " + bold + red + "xmin_ref, xmax_ref, ymin_ref, ymax_ref" + endC, xmin_ref, xmax_ref, ymin_ref, ymax_ref, file=sys.stderr) raise NameError( cyan + "vectorsListToOcs() : " + bold + red + "The extend of the footprint vector (%s) is greater than the reference raster (%s)." % (footprint_vector, reference_raster) + endC) # Récupération des traitements à faire dans le fichier texte d'entrée text_list = readTextFileBySeparator(input_text, TEXT_SEPARATOR) #################################################################### print(cyan + "vectorsListToOcs() : " + bold + green + "Début de la génération de l'OCS raster à partir de vecteurs." + endC + '\n') # Boucle sur les traitements à réaliser for text in text_list: idx = text_list.index(text) + 1 class_label = int(text[0]) vector_file = text[1] if debug >= 3: print(cyan + "vectorsListToOcs() : " + endC + bold + "Génération %s/%s : " % (idx, len(text_list)) + endC + "traitement du fichier %s (label %s)." % (vector_file, str(class_label)) + '\n') # Gestion des noms des fichiers temporaires vector_file_basename = os.path.basename( os.path.splitext(vector_file)[0]) vector_file_cut = temp_directory + os.sep + vector_file_basename + SUFFIX_CUT + extension_vector vector_file_filter = temp_directory + os.sep + vector_file_basename + SUFFIX_FILTER + extension_vector vector_file_buffer = temp_directory + os.sep + vector_file_basename + SUFFIX_BUFFER + extension_vector vector_file_raster = temp_directory + os.sep + vector_file_basename + extension_raster # Gestion des variables de traitement (tampon et filtrage SQL) try: buffer_len = float(text[2]) except ValueError: buffer_len = text[2] except Exception: buffer_len = '' try: sql_filter = text[3] except Exception: sql_filter = '' # Découpage à l'emprise de la zone d'étude if debug >= 3: print(cyan + "vectorsListToOcs() : " + endC + "Découpage à l'emprise de la zone d'étude." + '\n') cutVectorAll(footprint_vector, vector_file, vector_file_cut, overwrite=overwrite, format_vector=format_vector) # Filtrage SQL (facultatif) if sql_filter != '': if debug >= 3: print(cyan + "vectorsListToOcs() : " + endC + "Application du filtrage SQL : %s." % sql_filter + '\n') attr_names_list = getAttributeNameList(vector_file_cut, format_vector=format_vector) column = "'" for attr_name in attr_names_list: column += attr_name + ", " column = column[:-2] column += "'" filterSelectDataVector(vector_file_cut, vector_file_filter, column, sql_filter, overwrite=overwrite, format_vector=format_vector) else: vector_file_filter = vector_file_cut # Application d'un tampon (facultatif) if buffer_len != '' and buffer_len != 0: if debug >= 3: print(cyan + "vectorsListToOcs() : " + endC + "Application d'un buffer : %s." % buffer_len + '\n') if type(buffer_len) is float: bufferVector(vector_file_filter, vector_file_buffer, buffer_len, col_name_buf='', fact_buf=1.0, quadsecs=10, format_vector=format_vector) else: bufferVector(vector_file_filter, vector_file_buffer, 0, col_name_buf=buffer_len, fact_buf=1.0, quadsecs=10, format_vector=format_vector) else: vector_file_buffer = vector_file_filter # Rastérisation du vecteur préparé if debug >= 3: print(cyan + "vectorsListToOcs() : " + endC + "Rastérisation du vecteur préparé." + '\n') rasterizeBinaryVector(vector_file_buffer, reference_raster, vector_file_raster, label=class_label, codage=codage_raster) # Ajout de l'information dans le raster de sortie if debug >= 3: print(cyan + "vectorsListToOcs() : " + endC + "Ajout de l'information dans le raster de sortie." + '\n') if idx == 1: shutil.copy(vector_file_raster, output_raster) else: removeFile(temp_raster) shutil.copy(output_raster, temp_raster) removeFile(output_raster) expression = "im1b1!=%s ? im1b1 : im2b1" % no_data_value rasterCalculator([temp_raster, vector_file_raster], output_raster, expression, codage=codage_raster) print(cyan + "vectorsListToOcs() : " + bold + green + "Fin de la génération de l'OCS raster à partir de vecteurs." + endC + '\n') #################################################################### # Suppression des fichiers temporaires if not save_results_intermediate: if debug >= 3: print(cyan + "vectorsListToOcs() : " + endC + "Suppression des fichiers temporaires." + '\n') deleteDir(temp_directory) print(cyan + "vectorsListToOcs() : " + bold + green + "FIN DES TRAITEMENTS" + endC + '\n') # Mise à jour du log ending_event = "vectorsListToOcs() : Fin du traitement : " timeLine(path_time_log, ending_event) return 0
def createMnh(image_mns_input, image_mnt_input, image_threshold_input, vector_emprise_input, image_mnh_output, automatic, bd_road_vector_input_list, bd_road_buff_list, sql_road_expression_list, bd_build_vector_input_list, height_bias, threshold_bd_value, threshold_delta_h, mode_interpolation, method_interpolation, interpolation_bco_radius, simplify_vector_param, epsg, no_data_value, ram_otb, path_time_log, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "createMnh() : MNH creation starting : " timeLine(path_time_log,starting_event) print(endC) print(bold + green + "## START : MNH CREATION" + endC) print(endC) if debug >= 2: print(bold + green + "createMnh() : Variables dans la fonction" + endC) print(cyan + "createMnh() : " + endC + "image_mns_input : " + str(image_mns_input) + endC) print(cyan + "createMnh() : " + endC + "image_mnt_input : " + str(image_mnt_input) + endC) print(cyan + "createMnh() : " + endC + "image_threshold_input : " + str(image_threshold_input) + endC) print(cyan + "createMnh() : " + endC + "vector_emprise_input : " + str(vector_emprise_input) + endC) print(cyan + "createMnh() : " + endC + "image_mnh_output : " + str(image_mnh_output) + endC) print(cyan + "createMnh() : " + endC + "automatic : " + str(automatic) + endC) print(cyan + "createMnh() : " + endC + "bd_road_vector_input_list : " + str(bd_road_vector_input_list) + endC) print(cyan + "createMnh() : " + endC + "bd_road_buff_list : " + str(bd_road_buff_list) + endC) print(cyan + "createMnh() : " + endC + "sql_road_expression_list : " + str(sql_road_expression_list) + endC) print(cyan + "createMnh() : " + endC + "bd_build_vector_input_list : " + str(bd_build_vector_input_list) + endC) print(cyan + "createMnh() : " + endC + "height_bias : " + str(height_bias) + endC) print(cyan + "createMnh() : " + endC + "threshold_bd_value : " + str(threshold_bd_value) + endC) print(cyan + "createMnh() : " + endC + "threshold_delta_h : " + str(threshold_delta_h) + endC) print(cyan + "createMnh() : " + endC + "mode_interpolation : " + str(mode_interpolation) + endC) print(cyan + "createMnh() : " + endC + "method_interpolation : " + str(method_interpolation) + endC) print(cyan + "createMnh() : " + endC + "interpolation_bco_radius : " + str(interpolation_bco_radius) + endC) print(cyan + "createMnh() : " + endC + "simplify_vector_param : " + str(simplify_vector_param) + endC) print(cyan + "createMnh() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "createMnh() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "createMnh() : " + endC + "ram_otb : " + str(ram_otb) + endC) print(cyan + "createMnh() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "createMnh() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "createMnh() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "createMnh() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "createMnh() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "createMnh() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "createMnh() : " + endC + "overwrite : " + str(overwrite) + endC) # LES CONSTANTES PRECISION = 0.0000001 CODAGE_8B = "uint8" CODAGE_F = "float" SUFFIX_CUT = "_cut" SUFFIX_CLEAN = "_clean" SUFFIX_SAMPLE = "_sample" SUFFIX_MASK = "_mask" SUFFIX_TMP = "_tmp" SUFFIX_MNS = "_mns" SUFFIX_MNT = "_mnt" SUFFIX_ROAD = "_road" SUFFIX_BUILD = "_build" SUFFIX_RASTER = "_raster" SUFFIX_VECTOR = "_vector" # DEFINIR LES REPERTOIRES ET FICHIERS TEMPORAIRES repertory_output = os.path.dirname(image_mnh_output) basename_mnh = os.path.splitext(os.path.basename(image_mnh_output))[0] sub_repertory_raster_temp = repertory_output + os.sep + basename_mnh + SUFFIX_RASTER + SUFFIX_TMP sub_repertory_vector_temp = repertory_output + os.sep + basename_mnh + SUFFIX_VECTOR + SUFFIX_TMP cleanTempData(sub_repertory_raster_temp) cleanTempData(sub_repertory_vector_temp) basename_vector_emprise = os.path.splitext(os.path.basename(vector_emprise_input))[0] basename_mns_input = os.path.splitext(os.path.basename(image_mns_input))[0] basename_mnt_input = os.path.splitext(os.path.basename(image_mnt_input))[0] image_mnh_tmp = sub_repertory_raster_temp + os.sep + basename_mnh + SUFFIX_TMP + extension_raster image_mnh_road = sub_repertory_raster_temp + os.sep + basename_mnh + SUFFIX_ROAD + extension_raster vector_bd_bati_temp = sub_repertory_vector_temp + os.sep + basename_mnh + SUFFIX_BUILD + SUFFIX_TMP + extension_vector vector_bd_bati = repertory_output + os.sep + basename_mnh + SUFFIX_BUILD + extension_vector raster_bd_bati = sub_repertory_vector_temp + os.sep + basename_mnh + SUFFIX_BUILD + extension_raster removeVectorFile(vector_bd_bati) image_emprise_mnt_mask = sub_repertory_raster_temp + os.sep + basename_vector_emprise + SUFFIX_MNT + extension_raster image_mnt_cut = sub_repertory_raster_temp + os.sep + basename_mnt_input + SUFFIX_CUT + extension_raster image_mnt_clean = sub_repertory_raster_temp + os.sep + basename_mnt_input + SUFFIX_CLEAN + extension_raster image_mnt_clean_sample = sub_repertory_raster_temp + os.sep + basename_mnt_input + SUFFIX_CLEAN + SUFFIX_SAMPLE + extension_raster image_emprise_mns_mask = sub_repertory_raster_temp + os.sep + basename_vector_emprise + SUFFIX_MNS + extension_raster image_mns_cut = sub_repertory_raster_temp + os.sep + basename_mns_input + SUFFIX_CUT + extension_raster image_mns_clean = sub_repertory_raster_temp + os.sep + basename_mns_input + SUFFIX_CLEAN + extension_raster vector_bd_road_temp = sub_repertory_vector_temp + os.sep + basename_mnh + SUFFIX_ROAD + SUFFIX_TMP + extension_vector raster_bd_road_mask = sub_repertory_raster_temp + os.sep + basename_mnh + SUFFIX_ROAD + SUFFIX_MASK + extension_raster if image_threshold_input != "" : basename_threshold_input = os.path.splitext(os.path.basename(image_threshold_input))[0] image_threshold_cut = sub_repertory_raster_temp + os.sep + basename_threshold_input + SUFFIX_CUT + extension_raster image_threshold_mask = sub_repertory_raster_temp + os.sep + basename_threshold_input + SUFFIX_MASK + extension_raster # VERIFICATION SI LE FICHIER DE SORTIE EXISTE DEJA # Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors on ne fait rien check = os.path.isfile(image_mnh_output) if check and not overwrite: print(bold + yellow + "createMnh() : " + endC + "Create mnh %s from %s and %s already done : no actualisation" % (image_mnh_output, image_mns_input, image_mnt_input) + endC) # Si non, ou si la fonction ecrasement est désative, alors on le calcule else: if check: try: # Suppression de l'éventuel fichier existant removeFile(image_mnh_output) except Exception: pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite # DECOUPAGE DES FICHIERS MS ET MNT D'ENTREE PAR LE FICHIER D'EMPRISE if debug >= 3: print(bold + green + "createMnh() : " + endC + "Decoupage selon l'emprise des fichiers %s et %s " %(image_mns_input, image_mnt_input) + endC) # Fonction de découpe du mns if not cutImageByVector(vector_emprise_input, image_mns_input, image_mns_cut, None, None, no_data_value, epsg, format_raster, format_vector) : raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_mns_input + ". Voir message d'erreur." + endC) # Fonction de découpe du mnt if not cutImageByVector(vector_emprise_input, image_mnt_input, image_mnt_cut, None, None, no_data_value, epsg, format_raster, format_vector) : raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_mnt_input + ". Voir message d'erreur." + endC) if debug >= 3: print(bold + green + "createMnh() : " + endC + "Decoupage des fichiers %s et %s complet" %(image_mns_cut, image_mnt_cut) + endC) # REBOUCHAGE DES TROUS DANS LE MNT D'ENTREE SI NECESSAIRE nodata_mnt = getNodataValueImage(image_mnt_cut) pixelNodataCount = countPixelsOfValue(image_mnt_cut, nodata_mnt) if pixelNodataCount > 0 : if debug >= 3: print(bold + green + "createMnh() : " + endC + "Fill the holes MNT for %s" %(image_mnt_cut) + endC) # Rasterisation du vecteur d'emprise pour creer un masque pour boucher les trous du MNT rasterizeBinaryVector(vector_emprise_input, image_mnt_cut, image_emprise_mnt_mask, 1, CODAGE_8B) # Utilisation de SAGA pour boucher les trous fillNodata(image_mnt_cut, image_emprise_mnt_mask, image_mnt_clean, save_results_intermediate) if debug >= 3: print(bold + green + "createMnh() : " + endC + "Fill the holes MNT to %s completed" %(image_mnt_clean) + endC) else : image_mnt_clean = image_mnt_cut if debug >= 3: print(bold + green + "\ncreateMnh() : " + endC + "Fill the holes not necessary MNT for %s" %(image_mnt_cut) + endC) # REBOUCHAGE DES TROUS DANS LE MNS D'ENTREE SI NECESSAIRE nodata_mns = getNodataValueImage(image_mns_cut) pixelNodataCount = countPixelsOfValue(image_mns_cut, nodata_mns) if pixelNodataCount > 0 : if debug >= 3: print(bold + green + "createMnh() : " + endC + "Fill the holes MNS for %s" %(image_mns_cut) + endC) # Rasterisation du vecteur d'emprise pour creer un masque pour boucher les trous du MNS rasterizeBinaryVector(vector_emprise_input, image_mns_cut, image_emprise_mns_mask, 1, CODAGE_8B) # Utilisation de SAGA pour boucher les trous fillNodata(image_mns_cut, image_emprise_mns_mask, image_mns_clean, save_results_intermediate) if debug >= 3: print(bold + green + "\ncreateMnh() : " + endC + "Fill the holes MNS to %s completed" %(image_mns_clean) + endC) else : image_mns_clean = image_mns_cut if debug >= 3: print(bold + green + "createMnh() : " + endC + "Fill the holes not necessary MNS for %s" %(image_mns_cut) + endC) # CALLER LE FICHIER MNT AU FORMAT DU FICHIER MNS # Commande de mise en place de la geométrie re-echantionage command = "otbcli_Superimpose -inr " + image_mns_clean + " -inm " + image_mnt_clean + " -mode " + mode_interpolation + " -interpolator " + method_interpolation + " -out " + image_mnt_clean_sample if method_interpolation.lower() == 'bco' : command += " -interpolator.bco.radius " + str(interpolation_bco_radius) if ram_otb > 0: command += " -ram %d" %(ram_otb) if debug >= 3: print(cyan + "createMnh() : " + bold + green + "Réechantillonage du fichier %s par rapport à la reference %s" %(image_mnt_clean, image_mns_clean) + endC) print(command) exit_code = os.system(command) if exit_code != 0: print(command) raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du superimpose de l'image : " + image_mnt_input + ". Voir message d'erreur." + endC) # INCRUSTATION DANS LE MNH DES DONNEES VECTEURS ROUTES if debug >= 3: print(bold + green + "createMnh() : " + endC + "Use BD road to clean MNH" + endC) # Creation d'un masque de filtrage des donnes routes (exemple : le NDVI) if image_threshold_input != "" : if not cutImageByVector(vector_emprise_input, image_threshold_input, image_threshold_cut, None, None, no_data_value, epsg, format_raster, format_vector) : raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_threshold_input + ". Voir message d'erreur." + endC) createBinaryMask(image_threshold_cut, image_threshold_mask, threshold_bd_value, False, CODAGE_8B) # Execution de la fonction createMacroSamples pour une image correspondant au données routes if bd_road_vector_input_list != [] : createMacroSamples(image_mns_clean, vector_emprise_input, vector_bd_road_temp, raster_bd_road_mask, bd_road_vector_input_list, bd_road_buff_list, sql_road_expression_list, path_time_log, basename_mnh, simplify_vector_param, format_vector, extension_vector, save_results_intermediate, overwrite) if debug >= 3: print(bold + green + "\ncreateMnh() : " + endC + "File raster from BD road is create %s" %(raster_bd_road_mask) + endC) # CALCUL DU MNH # Calcul par bandMath du MNH definir l'expression qui soustrait le MNT au MNS en introduisant le biais et en mettant les valeurs à 0 à une valeur approcher de 0.0000001 delta = "" if height_bias > 0 : delta = "+%s" %(str(height_bias)) elif height_bias < 0 : delta = "-%s" %(str(abs(height_bias))) else : delta = "" # Definition de l'expression if bd_road_vector_input_list != [] : if image_threshold_input != "" : expression = "\"im3b1 > 0 and im4b1 > 0?%s:(im1b1-im2b1%s) > 0.0?im1b1-im2b1%s:%s\"" %(str(PRECISION), delta, delta, str(PRECISION)) command = "otbcli_BandMath -il %s %s %s %s -out %s %s -exp %s" %(image_mns_clean, image_mnt_clean_sample, raster_bd_road_mask, image_threshold_mask, image_mnh_tmp, CODAGE_F, expression) else : expression = "\"im3b1 > 0?%s:(im1b1-im2b1%s) > 0.0?im1b1-im2b1%s:%s\"" %(str(PRECISION), delta, delta, str(PRECISION)) command = "otbcli_BandMath -il %s %s %s -out %s %s -exp %s" %(image_mns_clean, image_mnt_clean_sample, raster_bd_road_mask, image_mnh_tmp, CODAGE_F, expression) else : expression = "\"(im1b1-im2b1%s) > 0.0?im1b1-im2b1%s:%s\"" %(delta, delta, str(PRECISION)) command = "otbcli_BandMath -il %s %s -out %s %s -exp %s" %(image_mns_clean, image_mnt_clean_sample, image_mnh_tmp, CODAGE_F, expression) if ram_otb > 0: command += " -ram %d" %(ram_otb) if debug >= 3: print(cyan + "createMnh() : " + bold + green + "Calcul du MNH %s difference du MNS : %s par le MNT :%s" %(image_mnh_tmp, image_mns_clean, image_mnt_clean_sample) + endC) print(command) exitCode = os.system(command) if exitCode != 0: print(command) raise NameError(cyan + "createMnh() : " + bold + red + "An error occured during otbcli_BandMath command to compute MNH " + image_mnh_tmp + ". See error message above." + endC) # DECOUPAGE DU MNH if bd_build_vector_input_list == []: image_mnh_road = image_mnh_output if debug >= 3: print(bold + green + "createMnh() : " + endC + "Decoupage selon l'emprise du fichier mnh %s " %(image_mnh_tmp) + endC) # Fonction de découpe du mnh if not cutImageByVector(vector_emprise_input, image_mnh_tmp, image_mnh_road, None, None, no_data_value, epsg, format_raster, format_vector) : raise NameError (cyan + "createMnh() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_mns_input + ". Voir message d'erreur." + endC) if debug >= 3: print(bold + green + "createMnh() : " + endC + "Decoupage du fichier mnh %s complet" %(image_mnh_road) + endC) # INCRUSTATION DANS LE MNH DES DONNEES VECTEURS BATIS # Si demander => liste de fichier vecteur bati passé en donnée d'entrée if bd_build_vector_input_list != []: # Découpage des vecteurs de bd bati exogenes avec l'emprise vectors_build_cut_list = [] for vector_build_input in bd_build_vector_input_list : vector_name = os.path.splitext(os.path.basename(vector_build_input))[0] vector_build_cut = sub_repertory_vector_temp + os.sep + vector_name + SUFFIX_CUT + extension_vector vectors_build_cut_list.append(vector_build_cut) cutoutVectors(vector_emprise_input, bd_build_vector_input_list, vectors_build_cut_list, format_vector) # Fusion des vecteurs batis découpés fusionVectors (vectors_build_cut_list, vector_bd_bati_temp) # Croisement vecteur rasteur entre le vecteur fusion des batis et le MNH créé precedement statisticsVectorRaster(image_mnh_road, vector_bd_bati_temp, "", 1, False, False, True, ['PREC_PLANI','PREC_ALTI','ORIGIN_BAT','median','sum','std','unique','range'], [], {}, path_time_log, True, format_vector, save_results_intermediate, overwrite) # Calcul de la colonne delta_H entre les hauteurs des batis et la hauteur moyenne du MNH sous le bati COLUMN_ID = "ID" COLUMN_H_BUILD = "HAUTEUR" COLUMN_H_BUILD_MIN = "Z_MIN" COLUMN_H_BUILD_MAX = "Z_MAX" COLUMN_H_MNH = "mean" COLUMN_H_MNH_MIN = "min" COLUMN_H_MNH_MAX = "max" COLUMN_H_DIFF = "H_diff" field_type = ogr.OFTReal field_value = 0.0 field_width = 20 field_precision = 2 attribute_name_dico = {} attribute_name_dico[COLUMN_ID] = ogr.OFTString attribute_name_dico[COLUMN_H_BUILD] = ogr.OFTReal attribute_name_dico[COLUMN_H_MNH] = ogr.OFTReal # Ajouter la nouvelle colonne H_diff addNewFieldVector(vector_bd_bati_temp, COLUMN_H_DIFF, field_type, field_value, field_width, field_precision, format_vector) # Recuperer les valeur de hauteur du bati et du mnt dans le vecteur data_z_dico = getAttributeValues(vector_bd_bati_temp, None, None, attribute_name_dico, format_vector) # Calculer la difference des Hauteur bati et mnt field_new_values_dico = {} for index in range(len(data_z_dico[COLUMN_ID])) : index_polygon = data_z_dico[COLUMN_ID][index] delta_h = abs(data_z_dico[COLUMN_H_BUILD][index] - data_z_dico[COLUMN_H_MNH][index]) field_new_values_dico[index_polygon] = {COLUMN_H_DIFF:delta_h} # Mettre à jour la colonne H_diff dans le vecteur setAttributeIndexValuesList(vector_bd_bati_temp, COLUMN_ID, field_new_values_dico, format_vector) # Suppression de tous les polygones bati dons la valeur du delat H est inferieur à threshold_delta_h column = "'%s, %s, %s, %s, %s, %s, %s, %s'"% (COLUMN_ID, COLUMN_H_BUILD, COLUMN_H_BUILD_MIN, COLUMN_H_BUILD_MAX, COLUMN_H_MNH, COLUMN_H_MNH_MIN, COLUMN_H_MNH_MAX, COLUMN_H_DIFF) expression = "%s > %s" % (COLUMN_H_DIFF, threshold_delta_h) filterSelectDataVector(vector_bd_bati_temp, vector_bd_bati, column, expression, overwrite, format_vector) # Attention!!!! PAUSE pour trie et verification des polygones bati nom deja present dans le MNH ou non if not automatic : print(bold + blue + "Application MnhCreation => " + endC + "Vérification manuelle du vecteur bati %s pour ne concerver que les batis non présent dans le MNH courant %s" %(vector_bd_bati_temp, image_mnh_road) + endC) input(bold + red + "Appuyez sur entree pour continuer le programme..." + endC) # Creation du masque bati avec pour H la hauteur des batiments rasterizeVector(vector_bd_bati, raster_bd_bati, image_mnh_road, COLUMN_H_BUILD) # Fusion du mask des batis et du MNH temporaire expression = "\"im1b1 > 0.0?im1b1:im2b1\"" command = "otbcli_BandMath -il %s %s -out %s %s -exp %s" %(raster_bd_bati, image_mnh_road, image_mnh_output, CODAGE_F, expression) if ram_otb > 0: command += " -ram %d" %(ram_otb) if debug >= 3: print(cyan + "createMnh() : " + bold + green + "Amelioration du MNH %s ajout des hauteurs des batis %s" %(image_mnh_road, raster_bd_bati) + endC) print(command) exitCode = os.system(command) if exitCode != 0: print(command) raise NameError(cyan + "createMnh() : " + bold + red + "An error occured during otbcli_BandMath command to compute MNH Final" + image_mnh_output + ". See error message above." + endC) # SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des fichiers intermédiaires if not save_results_intermediate : if bd_build_vector_input_list != []: removeFile(image_mnh_road) removeFile(image_threshold_cut) removeFile(image_threshold_mask) removeFile(raster_bd_bati) removeVectorFile(vector_bd_road_temp) removeVectorFile(vector_bd_bati_temp) removeVectorFile(vector_bd_bati) # A confirmer!!! removeFile(raster_bd_road_mask) removeFile(image_mnh_tmp) deleteDir(sub_repertory_raster_temp) deleteDir(sub_repertory_vector_temp) print(endC) print(bold + green + "## END : MNH CREATION" + endC) print(endC) # Mise à jour du Log ending_event = "createMnh() : MNH creation ending : " timeLine(path_time_log,ending_event) return
def writeQualityIndicatorsToCsvFile( class_count, precision_list, recall_list, fscore_list, performance_list, TFP_class_list, TFN_class_list, quantity_rate_list, class_list, overall_accuracy, overall_fscore, overall_performance, kappa, indicators_output_file, overwrite, textures_list): check = os.path.isfile(indicators_output_file) if check and not overwrite: print(cyan + "writeQualityIndicatorsToCsvFile() : " + bold + yellow + "Result file quality indicators exists." + '\n' + endC) else: # verifier si les info textures existes if textures_list is None: # Tente de supprimer le fichier try: removeFile(indicators_output_file) except Exception: #Ignore l'exception levee si le fichier n'existe pas (et ne peut donc pas être supprime) pass else: # Ecriture du nom de la texture texture_characteristics = textures_list[0] texture_name = str(texture_characteristics[0]) channel = str(texture_characteristics[1]) radius = str(texture_characteristics[2]) text_texture = "Name : %s ; Channel : %s ; Radius : %s \n" % ( texture_name, channel, radius) appendTextFile(indicators_output_file, text_texture) print(cyan + "writeQualityIndicatorsToCsvFile() : " + bold + green + "Writing file quality indicators..." + '\n' + endC) # contenu texte des indicateurs text_indicators = "Overall Accuracy ; Overall F1-Score ; Overall Performance ; Kappa \n %f ; %f ; %f ; %f \n\n" % ( overall_accuracy, overall_fscore, overall_performance, kappa) text_class_list = " Class " text_precision_list = " Precision " text_recall_list = " Recall " text_f_scores_list = " F1-Scores " text_performance_list = " Performance " text_TFP_class_list = " TFP_class " text_TFN_class_list = " TFN_class " text_quantity_rate_list = " Quantity_rate " for i in range(class_count): text_class_list += " ; %d" % (class_list[i]) text_precision_list += " ; %f" % (precision_list[i]) text_recall_list += " ; %f" % (recall_list[i]) text_f_scores_list += " ; %f" % (fscore_list[i]) text_performance_list += " ; %f" % (performance_list[i]) text_TFP_class_list += " ; %f" % (TFP_class_list[i]) text_TFN_class_list += " ; %f" % (TFN_class_list[i]) text_quantity_rate_list += " ; %f" % (quantity_rate_list[i]) text_File_list = text_class_list + "\n" \ + text_precision_list + "\n" \ + text_recall_list + "\n" \ + text_f_scores_list + "\n" \ + text_performance_list + "\n" \ + text_TFP_class_list + "\n" \ + text_TFN_class_list + "\n" \ + text_quantity_rate_list + "\n\n" \ + text_indicators + "\n" try: appendTextFile(indicators_output_file, text_File_list) except Exception: raise NameError( cyan + "writeQualityIndicatorsToCsvFile() : " + bold + red + "An error occured during writing " + indicators_output_file + " file quality indicators. See error message above." + endC) print(cyan + "writeQualityIndicatorsToCsvFile() : " + bold + green + "Quality indicators writed on file" + '\n' + endC) 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 createVectorMask(image_input, vector_mask) # 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 reduceChannelsImage(image_stack_input, image_acp_output, path_time_log, method_reduce, nb_components=0, normalize=True, napca_radius=1, ica_iterations=20, ica_increment=1.0, save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "reduceChannelsImage() : Reduction channels starting : " timeLine(path_time_log,starting_event) print(endC) print(bold + green + "## START : CHANNELS REDUCTION ALGO" + endC) print(endC) # Constantes EXT_XML = ".xml" EXT_CSV = ".csv" # Variables locales output_min_value = 1 output_max_value = 65536 # Nom de l'image en entrée image_name = os.path.splitext(os.path.basename(image_acp_output))[0] repertory_output = os.path.dirname(image_acp_output) parameters_output = repertory_output + os.sep + image_name + EXT_XML matrix_output = repertory_output + os.sep + image_name + EXT_CSV if debug >= 3: print(bold + green + "Variables dans la fonction" + endC) print(cyan + "reduceChannelsImage() : " + endC + "image_stack_input : " + str(image_stack_input) + endC) print(cyan + "reduceChannelsImage() : " + endC + "image_acp_output : " + str(image_acp_output) + endC) print(cyan + "reduceChannelsImage() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "reduceChannelsImage() : " + endC + "method_reduce : " + str(method_reduce) + endC) print(cyan + "reduceChannelsImage() : " + endC + "nb_components : " + str(nb_components) + endC) print(cyan + "reduceChannelsImage() : " + endC + "normalize : " + str(normalize) + endC) print(cyan + "reduceChannelsImage() : " + endC + "napca_radius : " + str(napca_radius) + endC) print(cyan + "reduceChannelsImage() : " + endC + "ica_iterations : " + str(ica_iterations) + endC) print(cyan + "reduceChannelsImage() : " + endC + "ica_increment : " + str(ica_increment) + endC) print(cyan + "reduceChannelsImage() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "reduceChannelsImage() : " + endC + "overwrite : " + str(overwrite) + endC) # Si l'image acp existe deja et que overwrite n'est pas activé check = os.path.isfile(image_acp_output) if check and not overwrite: print(bold + yellow + "ACP image already exists and will not be calculated again." + endC) else: if check : try: removeFile(image_acp_output) except Exception: pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée # Execution de l'acp [PCA/NAPCA/MAF/ICA] method_and_parametres = "" while switch(method_reduce): if case("PCA"): method_and_parametres = "pca" break if case("NAPCA"): method_and_parametres = "napca -method.napca.radiusx %d -method.napca.radiusy %d "%(napca_radius,napca_radius) break if case("MAF"): method_and_parametres = "maf" break if case("ICA"): method_and_parametres = "ica -method.ica.ite %d -method.ica.mu %f "%(ica_iterations,ica_increment) break break if debug >= 1: print(cyan + "reduceChannelsImage() : " + bold + green + "Debut de la reduction de dimension avec l'algorithme " + method_and_parametres + endC) command = "otbcli_DimensionalityReduction -in %s -out %s -rescale.outmax %d -rescale.outmin %d -method %s -nbcomp %d -normalize %s -outmatrix %s -outxml %s" %(image_stack_input, image_acp_output, output_max_value, output_min_value, method_and_parametres, nb_components, str(normalize).lower(), matrix_output, parameters_output) if debug >= 4: print("Execution de la commande : %s " %(command)) exitCode = os.system(command) if exitCode != 0: raise NameError(cyan + "reduceChannelsImage() : " + bold + red + "An error occured during otbcli_DimensionalityReduction command. See error message above." + endC) if debug >= 1: print(cyan + "reduceChannelsImage() : " + bold + green + "Reduction de dimension terminée." + endC) # Nettoyage des fichiers parameters_output et matrix_output if not save_results_intermediate: if os.path.isfile(parameters_output) : removeFile(parameters_output) if os.path.isfile(matrix_output) : removeFile(matrix_output) print(endC) print(bold + green + "## END : CHANNELS REDUCTION ALGO" + endC) print(endC) # Mise à jour du Log ending_event = "reduceChannelsImage() : Reduction channels ending : " timeLine(path_time_log,ending_event) return
def applyKmeansMasks(image_input, mask_samples_macro_input_list, image_samples_merged_output, proposal_table_output, micro_samples_images_output_list, centroids_files_output_list, macroclass_sampling_list, macroclass_labels_list, no_data_value, path_time_log, kmeans_param_maximum_iterations=200, kmeans_param_training_set_size_weight=1, kmeans_param_minimum_training_set_size=-1, rate_clean_micro_class=0.0, rand_otb=0, ram_otb=0, number_of_actives_pixels_threshold=200, extension_raster=".tif", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "applyKmeansMasks() : Kmeans and mask starting : " timeLine(path_time_log,starting_event) print(endC) print(cyan + "applyKmeansMasks() : " + bold + green + "## START : SUBSAMPLING OF " + str(macroclass_labels_list) + endC) print(endC) if debug >= 2: print(cyan + "applyKmeansMasks() : variables dans la fonction" + endC) print(cyan + "applyKmeansMasks() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "applyKmeansMasks() : " + endC + "image_samples_merged_output : " + str(image_samples_merged_output) + endC) print(cyan + "applyKmeansMasks() : " + endC + "proposal_table_output : " + str(proposal_table_output) + endC) print(cyan + "applyKmeansMasks() : " + endC + "mask_samples_macro_input_list : " + str(mask_samples_macro_input_list) + endC) print(cyan + "applyKmeansMasks() : " + endC + "micro_samples_images_output_list : " + str(micro_samples_images_output_list) + endC) print(cyan + "applyKmeansMasks() : " + endC + "centroids_files_output_list : " + str(centroids_files_output_list) + endC) print(cyan + "applyKmeansMasks() : " + endC + "macroclass_sampling_list : " + str(macroclass_sampling_list) + endC) print(cyan + "applyKmeansMasks() : " + endC + "macroclass_labels_list : " + str(macroclass_labels_list) + endC) print(cyan + "applyKmeansMasks() : " + endC + "kmeans_param_maximum_iterations : " + str(kmeans_param_maximum_iterations) + endC) print(cyan + "applyKmeansMasks() : " + endC + "kmeans_param_training_set_size_weight : " + str(kmeans_param_training_set_size_weight) + endC) print(cyan + "applyKmeansMasks() : " + endC + "kmeans_param_minimum_training_set_size : " + str(kmeans_param_minimum_training_set_size) + endC) print(cyan + "applyKmeansMasks() : " + endC + "rate_clean_micro_class : " + str(rate_clean_micro_class)) print(cyan + "applyKmeansMasks() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "applyKmeansMasks() : " + endC + "rand_otb : " + str(rand_otb) + endC) print(cyan + "applyKmeansMasks() : " + endC + "ram_otb : " + str(ram_otb) + endC) print(cyan + "applyKmeansMasks() : " + endC + "number_of_actives_pixels_threshold : " + str(number_of_actives_pixels_threshold)) print(cyan + "applyKmeansMasks() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "applyKmeansMasks() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "applyKmeansMasks() : " + endC + "overwrite : " + str(overwrite) + endC) # constantes HEADER_TABLEAU_MODIF = "MICROCLASSE;TRAITEMENT\n" CODAGE_16B = "uint16" CODAGE_8B = "uint8" EXT_XML = ".xml" SUFFIX_MASK_CLEAN = "_clean" SUFFIX_SAMPLE_MICRO = "_sample_micro" SUFFIX_STATISTICS = "_statistics" SUFFIX_CENTROID = "_centroid" SUFFIX_MASK_TEMP = "_tmp" # Creation des fichiers temporaires de sortie si ils ne sont pas spécifier #------------------------------------------------------------------------- length_mask = len(mask_samples_macro_input_list) images_mask_cleaned_list = [] temporary_files_list = [] micro_samples_images_list = [] centroids_files_list = [] repertory_output_tmp_list = [] if image_samples_merged_output != "" : repertory_base_output = os.path.dirname(image_samples_merged_output) filename = os.path.splitext(os.path.basename(image_samples_merged_output))[0] else : repertory_base_output = os.path.dirname(micro_samples_images_output_list[0]) filename = os.path.splitext(os.path.basename(micro_samples_images_output_list[0]))[0] file_statistic_points = repertory_base_output + os.sep + filename + SUFFIX_STATISTICS + EXT_XML for macroclass_id in range(length_mask): repertory_output = repertory_base_output + os.sep + str(macroclass_labels_list[macroclass_id]) if not os.path.isdir(repertory_output): os.makedirs(repertory_output) repertory_output_tmp_list.append(repertory_output) samples_image_input = mask_samples_macro_input_list[macroclass_id] filename = os.path.splitext(os.path.basename(samples_image_input))[0] image_mask_cleaned = repertory_output + os.sep + filename + SUFFIX_MASK_CLEAN + extension_raster images_mask_cleaned_list.append(image_mask_cleaned) image_tmp = repertory_output + os.sep + filename + SUFFIX_MASK_TEMP + extension_raster temporary_files_list.append(image_tmp) if micro_samples_images_output_list == [] : micro_samples_image = repertory_output + os.sep + filename + SUFFIX_SAMPLE_MICRO + extension_raster else : micro_samples_image = micro_samples_images_output_list[macroclass_id] micro_samples_images_list.append(micro_samples_image) if centroids_files_output_list == [] : centroids_file = repertory_output + os.sep + filename + SUFFIX_CENTROID + extension_raster else : centroids_file = centroids_files_output_list[macroclass_id] centroids_files_list.append(centroids_file) # Nettoyage des pixels superposés sur plusieurs images #----------------------------------------------------- if length_mask > 1: image_name = os.path.splitext(os.path.basename(image_input))[0] deletePixelsSuperpositionMasks(mask_samples_macro_input_list, images_mask_cleaned_list, image_name, CODAGE_8B) else: images_mask_cleaned_list = mask_samples_macro_input_list # Execution du kmeans pour chaque macroclasse #-------------------------------------------- # Initialisation de la liste pour le multi-threading thread_list = [] for macroclass_id in range(length_mask): mask_sample_input = images_mask_cleaned_list[macroclass_id] micro_samples_image = micro_samples_images_list[macroclass_id] image_tmp = temporary_files_list[macroclass_id] centroids_file = centroids_files_list[macroclass_id] check = os.path.isfile(micro_samples_image) 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 passe à la classification suivante print(cyan + "applyKmeansMasks() : " + bold + yellow + "Computing kmeans from %s with %s already done : no actualisation" % (image_input, mask_sample_input) + endC) else: # Si non, on applique un kmeans if check : removeFile(micro_samples_image) # Suppression de l'éventuel fichier existant print(cyan + "applyKmeansMasks() : " + bold + green + "Computing kmeans from %s with %s ; output image is %s" %(image_input, mask_sample_input,micro_samples_image) + endC) # Obtention du nombre de microclasses number_of_classes = macroclass_sampling_list[macroclass_id] # Nombre de microclasses label = macroclass_labels_list[macroclass_id] # Label de la macroclasse Ex : 11000 # Gestion du multi threading pour l'appel du calcul du kmeans thread = threading.Thread(target=computeKmeans, args=(image_input, mask_sample_input, image_tmp, micro_samples_image, centroids_file, label, number_of_classes, macroclass_id, number_of_actives_pixels_threshold, kmeans_param_minimum_training_set_size, kmeans_param_maximum_iterations, length_mask, no_data_value, rand_otb, int(ram_otb/length_mask), CODAGE_8B, CODAGE_16B, save_results_intermediate, overwrite)) thread.start() thread_list.append(thread) # Start Kmeans all macro classes try: for thread in thread_list: thread.join() except: print(cyan + "applyKmeansMasks() : " + bold + red + "applyKmeansMasks() : " + endC + "Erreur lors du calcul du kmeans : impossible de demarrer le thread" + endC, file=sys.stderr) # Fusion des echantillons micro #------------------------------ if image_samples_merged_output != "" : mergeListRaster(micro_samples_images_list, image_samples_merged_output, CODAGE_16B) updateReferenceProjection(image_input, image_samples_merged_output) # Creation de la table de proposition et le fichier statistique #-------------------------------------------------------------- if proposal_table_output != "" : suppress_micro_class_list = [] info_micoclass_nbpoints_dico = {} nb_points_total = 0 nb_points_medium = 0 # Liste des identifants des micro classes disponibles id_micro_list = identifyPixelValues(image_samples_merged_output) if 0 in id_micro_list : id_micro_list.remove(0) nb_micr_class = len(id_micro_list) # Pour toutes les micro classes for id_micro in id_micro_list : nb_pixels = countPixelsOfValue(image_samples_merged_output, id_micro) info_micoclass_nbpoints_dico[id_micro] = nb_pixels nb_points_total += nb_pixels # Valeur moyenne de nombre de points if nb_micr_class != 0 : nb_points_medium = int(nb_points_total / nb_micr_class) nb_points_min = int((nb_points_medium * rate_clean_micro_class) / 100) # Identifier les micro classes trop petites if debug >= 4: print("rate_clean_micro_class = " + str(rate_clean_micro_class)) print("nb_points_medium = " + str(nb_points_medium)) print("nb_points_min = " + str(nb_points_min)) # Preparation du fichier statistique writeTextFile(file_statistic_points, '<?xml version="1.0" ?>\n') appendTextFileCR(file_statistic_points, '<GeneralStatistics>') appendTextFileCR(file_statistic_points, ' <Statistic name="pointsPerClassRaw">') for micro_class_id in info_micoclass_nbpoints_dico : nb_points = info_micoclass_nbpoints_dico[micro_class_id] if debug >= 4: print("micro_class_id = " + str(micro_class_id) + ", nb_points = " + str(nb_points)) appendTextFileCR(file_statistic_points, ' <StatisticPoints class="%d" value="%d" />' %(micro_class_id, nb_points)) if nb_points < nb_points_min : # Micro_class à proposer en effacement suppress_micro_class_list.append(micro_class_id) # Fin du fichier statistique appendTextFileCR(file_statistic_points, ' </Statistic>') appendTextFileCR(file_statistic_points, '</GeneralStatistics>') # Test si ecrassement de la table précédemment créée check = os.path.isfile(proposal_table_output) if check and not overwrite : print(cyan + "applyKmeansMasks() : " + bold + yellow + "Modifier table already exists." + '\n' + endC) else: # Tenter de supprimer le fichier try: removeFile(proposal_table_output) except Exception: pass # Ignore l'exception levee si le fichier n'existe pas (et ne peut donc pas être supprime) # lister les micro classes à supprimer text_output = HEADER_TABLEAU_MODIF for micro_class_del in suppress_micro_class_list: text_output += "%d;-1\n" %(micro_class_del) # Ecriture du fichier proposition de réaffectation writeTextFile(proposal_table_output, text_output) # Suppresions fichiers intermediaires inutiles #--------------------------------------------- if not save_results_intermediate: for macroclass_id in range(length_mask): if (os.path.isfile(temporary_files_list[macroclass_id])) : removeFile(temporary_files_list[macroclass_id]) if (length_mask > 1) and (os.path.isfile(images_mask_cleaned_list[macroclass_id])) : removeFile(images_mask_cleaned_list[macroclass_id]) if (micro_samples_images_output_list == []) and (os.path.isfile(micro_samples_images_list[macroclass_id])) : removeFile(micro_samples_images_list[macroclass_id]) if (centroids_files_output_list == []) and (os.path.isfile(centroids_files_list[macroclass_id])) : removeFile(centroids_files_list[macroclass_id]) if os.path.isdir(repertory_output_tmp_list[macroclass_id]) : removeDir(repertory_output_tmp_list[macroclass_id]) print(cyan + "applyKmeansMasks() : " + bold + green + "## END : KMEANS CLASSIFICATION" + endC) print(endC) # Mise à jour du Log ending_event = "applyKmeansMasks() : Kmeans and mask ending : " timeLine(path_time_log,ending_event) return
def binaryMaskVect(input_image, output_dir, threshold, input_cut_vector, attributes_list, no_data_value, epsg, format_raster="GTiff", format_vector="ESRI Shapefile", extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): # Affichage des paramètres if debug >= 3: print(bold + green + "Variables dans le binaryMaskVect - Variables générales" + endC) print(cyan + "binaryMaskVect() : " + endC + "input_image : " + str(input_image) + endC) print(cyan + "binaryMaskVect() : " + endC + "output_dir : " + str(output_dir) + endC) print(cyan + "binaryMaskVect() : " + endC + "threshold : " + str(threshold) + endC) print(cyan + "binaryMaskVect() : " + endC + "input_cut_vector : " + str(input_cut_vector) + endC) print(cyan + "binaryMaskVect() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "binaryMaskVect() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "binaryMaskVect() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "binaryMaskVect() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "binaryMaskVect() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "binaryMaskVect() : " + endC + "overwrite : " + str(overwrite) + endC) image_name = os.path.splitext(os.path.basename(input_image))[0] binary_mask = output_dir + os.sep + "bin_mask_" + image_name + "_" + str( threshold).replace('.', '_') + extension_raster binary_mask_decoup = output_dir + os.sep + "bin_mask_decoup_" + image_name + "_" + str( threshold).replace('.', '_') + extension_raster binary_mask_vector = output_dir + os.sep + "bin_mask_vect_" + image_name + "_" + str( threshold).replace('.', '_') + extension_vector # Création du répertoire de sortie s'il n'existe pas déjà if not os.path.exists(output_dir): os.makedirs(output_dir) # Suppression des fichiers temporaires pour les calculs if os.path.exists(binary_mask): removeFile(binary_mask) if os.path.exists(binary_mask_decoup): removeFile(binary_mask_decoup) if os.path.exists(binary_mask_vector): if overwrite: removeVectorFile(binary_mask_vector, format_vector) else: return binary_mask_vector # Création du masque binaire createBinaryMask(input_image, binary_mask, threshold, False) if input_cut_vector != "": # Découpe du raster cutImageByVector(input_cut_vector, binary_mask, binary_mask_decoup, None, None, no_data_value, epsg, format_raster, format_vector) else: binary_mask_decoup = binary_mask # Vectorisation du masque binaire découpé polygonizeRaster(binary_mask_decoup, binary_mask_vector, image_name, "id", format_vector) # Ajout des champs au fichier vecteur créé for attribute in attributes_list: addNewFieldVector(binary_mask_vector, attribute.name, attribute.ogrType, attribute.value, attribute.width, None, format_vector) # Suppresions des fichiers intermediaires inutiles et reperoire temporaire if not save_results_intermediate: removeFile(binary_mask) removeFile(binary_mask_decoup) return binary_mask_vector
def occupationIndicator(input_grid, output_grid, class_label_dico_out, input_vector_classif, field_classif_name, input_soil_occupation, input_height_model, class_build_list, class_road_list, class_baresoil_list, class_water_list, class_vegetation_list, class_high_vegetation_list, class_low_vegetation_list, epsg=2154, no_data_value=0, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster='.tif', extension_vector='.shp', path_time_log='', save_results_intermediate=False, overwrite=True): if debug >= 3: print( '\n' + bold + green + "Calcul d'indicateurs du taux de classes OCS - Variables dans la fonction :" + endC) print(cyan + " occupationIndicator() : " + endC + "input_grid : " + str(input_grid) + endC) print(cyan + " occupationIndicator() : " + endC + "output_grid : " + str(output_grid) + endC) print(cyan + " occupationIndicator() : " + endC + "class_label_dico_out : " + str(class_label_dico_out) + endC) print(cyan + " occupationIndicator() : " + endC + "input_vector_classif : " + str(input_vector_classif) + endC) print(cyan + " occupationIndicator() : " + endC + "field_classif_name : " + str(field_classif_name) + endC) print(cyan + " occupationIndicator() : " + endC + "input_soil_occupation : " + str(input_soil_occupation) + endC) print(cyan + " occupationIndicator() : " + endC + "input_height_model : " + str(input_height_model) + endC) print(cyan + " occupationIndicator() : " + endC + "class_build_list : " + str(class_build_list) + endC) print(cyan + " occupationIndicator() : " + endC + "class_road_list : " + str(class_road_list) + endC) print(cyan + " occupationIndicator() : " + endC + "class_baresoil_list : " + str(class_baresoil_list) + endC) print(cyan + " occupationIndicator() : " + endC + "class_water_list : " + str(class_water_list) + endC) print(cyan + " occupationIndicator() : " + endC + "class_vegetation_list : " + str(class_vegetation_list) + endC) print(cyan + " occupationIndicator() : " + endC + "class_high_vegetation_list : " + str(class_high_vegetation_list) + endC) print(cyan + " occupationIndicator() : " + endC + "class_low_vegetation_list : " + str(class_low_vegetation_list) + endC) print(cyan + " occupationIndicator() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + " occupationIndicator() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + " occupationIndicator() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + " occupationIndicator() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + " occupationIndicator() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + " occupationIndicator() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + " occupationIndicator() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + " occupationIndicator() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + " occupationIndicator() : " + endC + "overwrite : " + str(overwrite) + endC + '\n') # Définition des constantes CODAGE_8BITS = 'uint8' CODAGE_FLOAT = 'float' NODATA_FIELD = 'nodata' PREFIX_S = 'S_' SUFFIX_TEMP = '_temp' SUFFIX_RASTER = '_raster' SUFFIX_HEIGHT = '_height' SUFFIX_VEGETATION = '_vegetation' VEG_MEAN_FIELD = 'veg_h_mean' VEG_MAX_FIELD = 'veg_h_max' VEG_RATE_FIELD = 'veg_h_rate' MAJ_OCS_FIELD = 'class_OCS' BUILT_FIELD, BUILT_LABEL = 'built', 1 MINERAL_FIELD, MINERAL_LABEL = 'mineral', 2 BARESOIL_FIELD, BARESOIL_LABEL = 'baresoil', 3 WATER_FIELD, WATER_LABEL = 'water', 4 VEGETATION_FIELD, VEGETATION_LABEL = 'veget', 5 HIGH_VEGETATION_FIELD, HIGH_VEGETATION_LABEL = 'high_veg', 6 LOW_VEGETATION_FIELD, LOW_VEGETATION_LABEL = 'low_veg', 7 # Mise à jour du log starting_event = "occupationIndicator() : Début du traitement : " timeLine(path_time_log, starting_event) print(cyan + "occupationIndicator() : " + bold + green + "DEBUT DES TRAITEMENTS" + endC + '\n') # Définition des variables 'basename' output_grid_basename = os.path.basename(os.path.splitext(output_grid)[0]) output_grid_dirname = os.path.dirname(output_grid) soil_occupation_basename = os.path.basename( os.path.splitext(input_soil_occupation)[0]) # Définition des variables temp temp_directory = output_grid_dirname + os.sep + output_grid_basename temp_grid = temp_directory + os.sep + output_grid_basename + SUFFIX_TEMP + extension_vector temp_soil_occupation = temp_directory + os.sep + soil_occupation_basename + SUFFIX_TEMP + SUFFIX_RASTER + extension_raster temp_height_vegetation = temp_directory + os.sep + output_grid_basename + SUFFIX_HEIGHT + SUFFIX_VEGETATION + extension_raster # Nettoyage des traitements précédents if overwrite: if debug >= 3: print(cyan + "occupationIndicator() : " + endC + "Nettoyage des traitements précédents." + endC + '\n') removeFile(output_grid) cleanTempData(temp_directory) else: if os.path.exists(output_grid): raise NameError( cyan + "occupationIndicator() : " + bold + yellow + "Le fichier de sortie existe déjà et ne sera pas regénéré." + endC + '\n') pass ############# # Etape 0/3 # Préparation des traitements ############# print(cyan + "occupationIndicator() : " + bold + green + "ETAPE 0/3 - Début de la préparation des traitements." + endC + '\n') # Rasterisation de l'information de classification (OCS) si au format vecteur en entrée if input_vector_classif != "": if debug >= 3: print(cyan + "occupationIndicator() : " + endC + bold + "Rasterisation de l'OCS vecteur." + endC + '\n') reference_image = input_soil_occupation soil_occupation_vector_basename = os.path.basename( os.path.splitext(input_vector_classif)[0]) input_soil_occupation = temp_directory + os.sep + soil_occupation_vector_basename + SUFFIX_RASTER + extension_raster command = "otbcli_Rasterization -in %s -out %s %s -im %s -background 0 -mode attribute -mode.attribute.field %s" % ( input_vector_classif, input_soil_occupation, CODAGE_8BITS, reference_image, field_classif_name) if debug >= 3: print(command) exit_code = os.system(command) if exit_code != 0: raise NameError( cyan + "occupationIndicator() : " + bold + red + "Erreur lors de la rasterisation de l'OCS vecteur." + endC) # Analyse de la couche OCS raster class_other_list = identifyPixelValues(input_soil_occupation) no_data_ocs = getNodataValueImage(input_soil_occupation, 1) if no_data_ocs != None: no_data_value = no_data_ocs # Affectation de nouveaux codes de classification divide_vegetation_classes = False if class_high_vegetation_list != [] and class_low_vegetation_list != []: divide_vegetation_classes = True col_to_delete_list = [ "minority", PREFIX_S + NODATA_FIELD, PREFIX_S + BUILT_FIELD, PREFIX_S + MINERAL_FIELD, PREFIX_S + BARESOIL_FIELD, PREFIX_S + WATER_FIELD ] class_label_dico = { int(no_data_value): NODATA_FIELD, int(BUILT_LABEL): BUILT_FIELD, int(MINERAL_LABEL): MINERAL_FIELD, int(BARESOIL_LABEL): BARESOIL_FIELD, int(WATER_LABEL): WATER_FIELD } if not divide_vegetation_classes: class_label_dico[int(VEGETATION_LABEL)] = VEGETATION_FIELD col_to_delete_list.append(PREFIX_S + VEGETATION_FIELD) else: class_label_dico[int(HIGH_VEGETATION_LABEL)] = HIGH_VEGETATION_FIELD class_label_dico[int(LOW_VEGETATION_LABEL)] = LOW_VEGETATION_FIELD col_to_delete_list.append(PREFIX_S + HIGH_VEGETATION_FIELD) col_to_delete_list.append(PREFIX_S + LOW_VEGETATION_FIELD) # Gestion de la réaffectation des classes if debug >= 3: print(cyan + "occupationIndicator() : " + endC + bold + "Reaffectation du raster OCS." + endC + '\n') reaff_class_list = [] macro_reaff_class_list = [] for label in class_build_list: if label in class_other_list: class_other_list.remove(label) reaff_class_list.append(label) macro_reaff_class_list.append(BUILT_LABEL) for label in class_road_list: if label in class_other_list: class_other_list.remove(label) reaff_class_list.append(label) macro_reaff_class_list.append(MINERAL_LABEL) for label in class_baresoil_list: if label in class_other_list: class_other_list.remove(label) reaff_class_list.append(label) macro_reaff_class_list.append(BARESOIL_LABEL) for label in class_water_list: if label in class_other_list: class_other_list.remove(label) reaff_class_list.append(label) macro_reaff_class_list.append(WATER_LABEL) if not divide_vegetation_classes: for label in class_vegetation_list: if label in class_other_list: class_other_list.remove(label) reaff_class_list.append(label) macro_reaff_class_list.append(VEGETATION_LABEL) else: for label in class_high_vegetation_list: if label in class_other_list: class_other_list.remove(label) reaff_class_list.append(label) macro_reaff_class_list.append(HIGH_VEGETATION_LABEL) for label in class_low_vegetation_list: if label in class_other_list: class_other_list.remove(label) reaff_class_list.append(label) macro_reaff_class_list.append(LOW_VEGETATION_LABEL) # Reste des valeurs de pixel nom utilisé for label in class_other_list: reaff_class_list.append(label) macro_reaff_class_list.append(no_data_value) reallocateClassRaster(input_soil_occupation, temp_soil_occupation, reaff_class_list, macro_reaff_class_list, CODAGE_8BITS) print(cyan + "occupationIndicator() : " + bold + green + "ETAPE 0/3 - Fin de la préparation des traitements." + endC + '\n') ############# # Etape 1/3 # Calcul des indicateurs de taux de classes OCS ############# print( cyan + "occupationIndicator() : " + bold + green + "ETAPE 1/3 - Début du calcul des indicateurs de taux de classes OCS." + endC + '\n') if debug >= 3: print(cyan + "occupationIndicator() : " + endC + bold + "Calcul des indicateurs de taux de classes OCS." + endC + '\n') statisticsVectorRaster(temp_soil_occupation, input_grid, temp_grid, 1, True, True, False, col_to_delete_list, [], class_label_dico, path_time_log, True, format_vector, save_results_intermediate, overwrite) # Fusion des classes végétation dans le cas où haute et basse sont séparées (pour utilisation du taux de végétation dans le logigramme) if divide_vegetation_classes: temp_grid_v2 = os.path.splitext( temp_grid)[0] + "_v2" + extension_vector sql_statement = "SELECT *, (%s + %s) AS %s FROM %s" % ( HIGH_VEGETATION_FIELD, LOW_VEGETATION_FIELD, VEGETATION_FIELD, os.path.splitext(os.path.basename(temp_grid))[0]) os.system("ogr2ogr -sql '%s' -dialect SQLITE %s %s" % (sql_statement, temp_grid_v2, temp_grid)) removeVectorFile(temp_grid, format_vector=format_vector) copyVectorFile(temp_grid_v2, temp_grid, format_vector=format_vector) print(cyan + "occupationIndicator() : " + bold + green + "ETAPE 1/3 - Fin du calcul des indicateurs de taux de classes OCS." + endC + '\n') ############# # Etape 2/3 # Calcul de l'indicateur de "hauteur de végétation" ############# print( cyan + "occupationIndicator() : " + bold + green + "ETAPE 2/3 - Début du calcul de l'indicateur de \"hauteur de végétation\"." + endC + '\n') computeVegetationHeight( temp_grid, output_grid, temp_soil_occupation, input_height_model, temp_height_vegetation, divide_vegetation_classes, VEGETATION_LABEL, HIGH_VEGETATION_LABEL, LOW_VEGETATION_LABEL, HIGH_VEGETATION_FIELD, LOW_VEGETATION_FIELD, VEG_MEAN_FIELD, VEG_MAX_FIELD, VEG_RATE_FIELD, CODAGE_FLOAT, SUFFIX_TEMP, no_data_value, format_vector, path_time_log, save_results_intermediate, overwrite) print( cyan + "occupationIndicator() : " + bold + green + "ETAPE 2/3 - Fin du calcul de l'indicateur de \"hauteur de végétation\"." + endC + '\n') ############# # Etape 3/3 # Calcul de l'indicateur de classe majoritaire ############# print( cyan + "occupationIndicator() : " + bold + green + "ETAPE 3/3 - Début du calcul de l'indicateur de classe majoritaire." + endC + '\n') if input_height_model != "": computeMajorityClass(output_grid, temp_directory, NODATA_FIELD, BUILT_FIELD, MINERAL_FIELD, BARESOIL_FIELD, WATER_FIELD, VEGETATION_FIELD, HIGH_VEGETATION_FIELD, LOW_VEGETATION_FIELD, MAJ_OCS_FIELD, VEG_MEAN_FIELD, class_label_dico_out, format_vector, extension_vector, overwrite) else: print( cyan + "occupationIndicator() : " + bold + yellow + "Pas de calcul de l'indicateur de classe majoritaire demandé (pas de MNH en entrée)." + endC + '\n') print(cyan + "occupationIndicator() : " + bold + green + "ETAPE 3/3 - Fin du calcul de l'indicateur de classe majoritaire." + endC + '\n') #################################################################### # Suppression des fichiers temporaires if not save_results_intermediate: if debug >= 3: print(cyan + "occupationIndicator() : " + endC + "Suppression des fichiers temporaires." + endC + '\n') deleteDir(temp_directory) print(cyan + "occupationIndicator() : " + bold + green + "FIN DES TRAITEMENTS" + endC + '\n') # Mise à jour du log ending_event = "occupationIndicator() : Fin du traitement : " timeLine(path_time_log, ending_event) return 0
def convertImage(image_input, huit_bits_image, image_compressed, need_8bits, need_compress, compress_type, predictor, zlevel, suppr_min, suppr_max, need_optimize8b, need_rvb, path_time_log, 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 + "huit_bits_image: ",huit_bits_image) print(cyan + "convertImage() : " + endC + "image_compressed: ",image_compressed) 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 + "path_time_log: ",path_time_log) 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] if not need_compress: image_compressed = huit_bits_image repertory_tmp = os.path.dirname(image_compressed) + 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_compressed) # 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_compressed) 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, huit_bits_image, repertory_tmp, need_optimize8b, need_rvb, suppr_min, suppr_max, extension_raster) image_to_compress = huit_bits_image else : image_to_compress = image_input ########################################################### # Compression du fichier # ########################################################### if need_compress: compressImage(image_to_compress, image_compressed, compress_type, predictor, zlevel, format_raster) ########################################################### # nettoyage du repertoire temporaire # ########################################################### if not save_results_intermediate and need_compress: 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 classRasterSubSampling(satellite_image_input, classified_image_input, image_output, table_reallocation, sub_sampling_number, no_data_value, path_time_log, rand_otb=0, ram_otb=0, number_of_actives_pixels_threshold=8000, extension_raster=".tif", save_results_intermediate=False, overwrite=True) : # Mise à jour du Log starting_event = "classRasterSubSampling() : Micro class subsampling on classification image starting : " timeLine(path_time_log,starting_event) if debug >= 3: print(cyan + "classRasterSubSampling() : " + endC + "satellite_image_input : " + str(satellite_image_input) + endC) print(cyan + "classRasterSubSampling() : " + endC + "classified_image_input : " + str(classified_image_input) + endC) print(cyan + "classRasterSubSampling() : " + endC + "image_output : " + str(image_output) + endC) print(cyan + "classRasterSubSampling() : " + endC + "table_reallocation : " + str(table_reallocation) + endC) print(cyan + "classRasterSubSampling() : " + endC + "sub_sampling_number : " + str(sub_sampling_number) + endC) print(cyan + "classRasterSubSampling() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "classRasterSubSampling() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "classRasterSubSampling() : " + endC + "rand_otb : " + str(rand_otb) + endC) print(cyan + "classRasterSubSampling() : " + endC + "ram_otb : " + str(ram_otb) + endC) print(cyan + "classRasterSubSampling() : " + endC + "number_of_actives_pixels_threshold : " + str(number_of_actives_pixels_threshold) + endC) print(cyan + "classRasterSubSampling() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "classRasterSubSampling() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "classRasterSubSampling() : " + endC + "overwrite : " + str(overwrite) + endC) # Constantes CODAGE = "uint16" CODAGE_8B = "uint8" TEMP = "TempSubSampling_" MASK_SUF = "_Mask" SUB_SAMPLE_SUF = "_SubSampled" CENTROID_SUF = "_Centroids" TEMP_OUT = "_temp_out" EXTENSION_TXT = ".txt" # Contenu de la nouvelle table text_new_table = "" # CREATION DES NOMS DE CHEMINS UTILES name = os.path.splitext(os.path.basename(image_output))[0] input_classified_image_path = os.path.dirname(classified_image_input) # Ex : D2_Par_Zone/Paysage_01/Corr_2/Resultats/Temp/ temp_sub_sampling_path = input_classified_image_path + os.sep + TEMP + name + os.sep # Dossier contenant les fichiers temporaires de cette brique. Ex : D2_Par_Zone/Paysage_01/Corr_2/Resultats/Temp/Temp_Sub_Sampling/ input_classified_image_complete_name = os.path.basename(classified_image_input) # Ex : Paysage_01_raw.tif input_classified_image_name = os.path.splitext(input_classified_image_complete_name)[0] # Ex : Paysage_01_raw input_classified_image_extend = os.path.splitext(input_classified_image_complete_name)[1] # Ex : .tif image_output_temp = os.path.splitext(image_output)[0] + TEMP_OUT + extension_raster # Ex : D2_Par_Zone/Paysage_01/Corr_2/Resultats/Temp/Temp_Sub_Sampling/Paysage_01_raw_temp.tif # Création de temp_sub_sampling_path s'il n'existe pas if not os.path.isdir(os.path.dirname(temp_sub_sampling_path)) : os.makedirs(os.path.dirname(temp_sub_sampling_path)) print(cyan + "classRasterSubSampling() : " + bold + green + "START ...\n" + endC) # Lecture du fichier table de proposition supp_class_list, reaff_class_list, macro_reaff_class_list, sub_sampling_class_list, sub_sampling_number_list = readReallocationTable(table_reallocation, sub_sampling_number) # Fonction de Lib_text info_table_list = readTextFileBySeparator(table_reallocation, "\n") # Recherche de la liste des micro classes contenu dans le fichier de classification d'entrée class_values_list = identifyPixelValues(classified_image_input) # Supression dans la table des lignes correspondant aux actions "-2" for ligne_table in info_table_list: if not "-2" in ligne_table[0]: text_new_table += str(ligne_table[0]) + "\n" if debug >= 3: print("supp_class_list : " + str(supp_class_list)) print("reaff_class_list : " + str(reaff_class_list)) print("macro_reaff_class_list : " + str(macro_reaff_class_list)) print("sub_sampling_class_list : " + str(sub_sampling_class_list)) print("sub_sampling_number_list : " + str(sub_sampling_number_list)) # Dans cettre brique, on ne s'intéresse qu'à la partie sous echantillonage # Gestion du cas de suppression if len(supp_class_list) > 0: print(cyan + "classRasterSubSampling() : " + bold + yellow + "ATTENTION : Les classes ne sont pas supprimees pour le fichier classification format raster." + '\n' + endC) # Gestion du cas de réaffectation if len(reaff_class_list) > 0: print(cyan + "classRasterSubSampling() : " + bold + yellow + "ATTENTION : la brique SpecificSubSampling ne traite pas les reaffectation. A l'issue de cette brique, verifier la table de reallocation et executer la brique de reallocation." + '\n' + endC) if len(sub_sampling_class_list) > 0 : if debug >= 3: print(cyan + "classRasterSubSampling() : " + bold + green + "DEBUT DU SOUS ECHANTILLONAGE DES CLASSES %s " %(sub_sampling_class_list) + endC) # Parcours des classes à sous échantilloner processing_pass_first = False for idx_class in range(len(sub_sampling_class_list)) : # INITIALISATION DU TRAITEMENT DE LA CLASSE # Classe à sous échantilloner. Ex : 21008 class_to_sub_sample = sub_sampling_class_list[idx_class] if idx_class == 0 or not processing_pass_first : # Image à reclassifier : classified_image_input au premier tour image_to_sub_sample = classified_image_input else : # Image à reclassifier : la sortie de la boucle précédente ensuite image_to_sub_sample = image_output # determiner le label disponible de la classe base_subclass_label = int(class_to_sub_sample/100)*100 subclass_label = base_subclass_label for class_value in class_values_list: if (class_value > subclass_label) and (class_value < base_subclass_label + 100) : subclass_label = class_value subclass_label += 1 # subclass_label = int(class_to_sub_sample/100)*100 + 20 + class_to_sub_sample%20 * 5 # Label de départ des sous classes. Formule proposée : 3 premiers chiffres de class_to_sub_sample puis ajout de 20 + 5 * class_to_sub_sample modulo 20. Ex : 21000 -> 21020, 21001-> 21025, 21002-> 21030 etc... # Part du principe qu'il y a moins de 20 micro classes et que chacune est sous échantillonnée au maximum en 5 sous parties. Si ce n'est pas le cas : A ADAPTER number_of_sub_samples = sub_sampling_number_list[idx_class] # Nombre de sous classes demandées pour le sous échantillonage de class_to_sub_sample. Ex : 4 class_mask_raster = temp_sub_sampling_path + input_classified_image_name + "_" + str(class_to_sub_sample) + MASK_SUF + input_classified_image_extend # Ex : D2_Par_Zone/Paysage_01/Corr_2/Resultats/Temp/Temp_Sub_Sampling/Paysage_01_raw_21008_Mask.tif class_subsampled_raster = temp_sub_sampling_path + input_classified_image_name + "_" + str(class_to_sub_sample) + SUB_SAMPLE_SUF + input_classified_image_extend # Ex : D2_Par_Zone/Paysage_01/Corr_2/Resultats/Temp/Temp_Sub_Sampling/Paysage_01_raw_21008_SubSampled.tif centroid_file = temp_sub_sampling_path + input_classified_image_name + "_" + str(class_to_sub_sample) + CENTROID_SUF + EXTENSION_TXT # Ex : D2_Par_Zone/Paysage_01/Corr_2/Resultats/Temp/Temp_Sub_Sampling/Paysage_01_raw_21008_Centroid.txt if debug >= 5: print(cyan + "classRasterSubSampling() : " + endC + "class_to_sub_sample :" , class_to_sub_sample) print(cyan + "classRasterSubSampling() : " + endC + "subclass_label :" , subclass_label) print(cyan + "classRasterSubSampling() : " + endC + "number_of_sub_samples :" , number_of_sub_samples) print(cyan + "classRasterSubSampling() : " + endC + "class_mask_raster :" , class_mask_raster) print(cyan + "classRasterSubSampling() : " + endC + "class_subsampled_raster :" , class_subsampled_raster) print(cyan + "classRasterSubSampling() : " + endC + "centroid_file :" , centroid_file) if debug >= 3: print(cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s : SOUS ECHANTILLONAGE DE %s EN %s CLASSES " %(idx_class+1, len(sub_sampling_class_list), class_to_sub_sample, number_of_sub_samples) + endC) # ETAPE 1/5 : EXTRACTION DU MASQUE BINAIRE DES PIXELS CORRESPONDANT A LA CLASSE expression_masque = "\"im1b1 == %s? 1 : 0\"" %(class_to_sub_sample) command = "otbcli_BandMath -il %s -out %s %s -exp %s" %(classified_image_input, class_mask_raster, CODAGE_8B, expression_masque) if debug >=2: print("\n" + cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 1/5 : Debut de l extraction du masque binaire de la classe %s" %(idx_class+1, len(sub_sampling_class_list),class_to_sub_sample) + endC) print(command) os.system(command) if debug >=2: print(cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 1/5 : Fin de l extraction du masque binaire de la classe %s, disponible ici : %s" %(idx_class+1, len(sub_sampling_class_list),class_to_sub_sample, class_mask_raster) + endC) # TEST POUR SAVOIR SI ON EST EN CAPACITE D'EFFECTUER LE KMEANS number_of_actives_pixels = countPixelsOfValue(class_mask_raster, 1) # Comptage du nombre de pixels disponibles pour effectuer le kmeans if number_of_actives_pixels > (number_of_sub_samples * number_of_actives_pixels_threshold) : # Cas où il y a plus de pixels disponibles pour effectuer le kmeans que le seuil # ETAPE 2/5 : CLASSIFICATION NON SUPERVISEE DES PIXELS CORRESPONDANT A LA CLASSE if debug >= 3: print("\n" + cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 2/5 : Il y a assez de pixels pour faire le sous echantillonage : %s sur %s requis au minimum " %(idx_class+1, len(sub_sampling_class_list), number_of_actives_pixels, int(number_of_sub_samples) * number_of_actives_pixels_threshold) + endC) if debug >=2: print("\n" + cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 2/5 : Debut du sous echantillonage par classification non supervisee en %s classes " %(idx_class+1, len(sub_sampling_class_list), number_of_sub_samples) + endC) # appel du kmeans input_mask_list = [] input_mask_list.append(class_mask_raster) output_masked_image_list = [] output_masked_image_list.append(class_subsampled_raster) output_centroids_files_list = [] output_centroids_files_list.append(centroid_file) macroclass_sampling_list = [] macroclass_sampling_list.append(number_of_sub_samples) macroclass_labels_list = [] macroclass_labels_list.append(subclass_label) applyKmeansMasks(satellite_image_input, input_mask_list, "", "", output_masked_image_list, output_centroids_files_list, macroclass_sampling_list, macroclass_labels_list, no_data_value, path_time_log, 200, 1, -1, 0.0, rand_otb, ram_otb, number_of_actives_pixels_threshold, extension_raster, save_results_intermediate, overwrite) if debug >=2: print(cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 2/5 : Fin du sous echantillonage par classification non supervisee en %s classes, disponible ici %s : " %(idx_class+1, len(sub_sampling_class_list), number_of_sub_samples, class_subsampled_raster) + endC) # ETAPE 3/5 : INTEGRATION DES NOUVELLES SOUS CLASSES DANS LA TABLE DE REALLOCATION # Ouveture du fichier table de proposition pour re-ecriture for i in range(number_of_sub_samples): class_values_list.append(subclass_label + i) text_new_table += str(subclass_label + i) + ";" + str(subclass_label + i) + "; METTRE A JOUR MANUELLEMENT (origine : " + str(class_to_sub_sample) + ")" + "\n" # ETAPE 4/5 : APPLICATION DU SOUS ECHANTILLONAGE AU RESULTAT DE CLASSIFICATION expression_application_sous_echantillonage = "\"im1b1 == %s? im2b1 : im1b1\"" %(class_to_sub_sample) command = "otbcli_BandMath -il %s %s -out %s %s -exp %s" %(image_to_sub_sample, class_subsampled_raster, image_output_temp, CODAGE, expression_application_sous_echantillonage) if debug >=2: print("\n" + cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 4/5 : Debut de l application du sous echantillonage present dans %s sur %s" %(idx_class+1, len(sub_sampling_class_list), class_subsampled_raster, classified_image_input) + endC) print(command) os.system(command) if debug >=2: print(cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 4/5 : Fin de l application du sous echantillonage present dans %s sur %s, sortie disponible ici : %s" %(idx_class+1, len(sub_sampling_class_list), class_subsampled_raster, classified_image_input, image_output_temp) + endC) # ETAPE 5/5 : GESTION DES RENOMMAGES ET SUPPRESSIONS if debug >=2: print("\n" + cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 5/5 : Debut du renommage et suppression des dossiers intermediaires" %(idx_class+1, len(sub_sampling_class_list)) + endC) if debug >=3 : print("\n" + green + "classified image input: %s" %(classified_image_input) + endC) print("\n" + green + "image to sub sample: %s" %(image_to_sub_sample) + endC) print("\n" + green + "image temp : %s" %(image_output_temp) + endC) print("\n" + green + "image output : %s" %(image_output) + endC) # Si l'image d'entrée et l'image de sorte sont le même fichier on efface le fichier d'entrée pour le re-creer avec le fichier re-travaillé if image_output == classified_image_input and os.path.isfile(classified_image_input) : removeFile(classified_image_input) os.rename(image_output_temp,image_output) processing_pass_first = True # SUPPRESSION DES FICHIERS TEMPORAIRES if not save_results_intermediate : if os.path.isfile(class_mask_raster) : removeFile(class_mask_raster) if os.path.isfile(class_subsampled_raster) : removeFile(class_subsampled_raster) if os.path.isfile(centroid_file) : removeFile(centroid_file) if debug >=2: print(cyan + "classRasterSubSampling() : " + bold + green + "CLASSE %s/%s - ETAPE 5/5 : Fin du renommage et suppression des dossiers intermediaires" %(idx_class+1, len(sub_sampling_class_list)) + endC) else: # Cas où il n'y a pas assez de pixels pour effectuer le kmeans if debug >=2: print("\n" + cyan + "classRasterSubSampling() : " + bold + yellow + "CLASSE %s/%s - ETAPE 2/5 : Nombre insuffisant de pixels disponibles pour appliquer le kmeans : %s sur %s requis au minimum " %(idx_class+1, len(sub_sampling_class_list), number_of_actives_pixels, int(number_of_sub_samples) * number_of_actives_pixels_threshold) + endC) print(cyan + "classRasterSubSampling() : " + bold + yellow + "CLASSE %s/%s - ETAPE 2/5 : SOUS ECHANTILLONAGE NON APPLIQUE A LA CLASSE %s" %(idx_class+1, len(sub_sampling_class_list), class_to_sub_sample) + endC + "\n") # MISE A JOUR DU FICHIER image_to_sub_sample if idx_class == 0: processing_pass_first = False # MISE A JOUR DE LA TABLE DE REALLOCATION text_new_table += str(class_to_sub_sample) + ";" + str(class_to_sub_sample) + ";CLASSE TROP PETITE POUR SOUS ECHANTILLONAGE" + "\n" # SUPPRESSION DU MASQUE if not save_results_intermediate and os.path.isfile(class_mask_raster) : removeFile(class_mask_raster) else: shutil.copy2(classified_image_input, image_output) # Copie du raster d'entree si pas de sous-echantillonnage # Ecriture de la nouvelle table dans le fichier writeTextFile(table_reallocation, text_new_table) # SUPPRESSION DU DOSSIER ET DES FICHIERS TEMPORAIRES if not save_results_intermediate and os.path.isdir(os.path.dirname(temp_sub_sampling_path)) : shutil.rmtree(os.path.dirname(temp_sub_sampling_path)) print(cyan + "classRasterSubSampling() : " + bold + green + "END\n" + endC) # Mise à jour du Log ending_event = "classRasterSubSampling() : Micro class subsampling on classification image ending : " timeLine(path_time_log,ending_event) return
def assembleImagePansharpening(image_panchro_input, image_xs_input, image_output, mode_interpolation, method_interpolation, method_pansharpening, interpolation_bco_radius, pansharpening_lmvm_xradius, pansharpening_lmvm_yradius, pansharpening_bayes_lambda, pansharpening_bayes_s, path_time_log, ram_otb=0, format_raster='GTiff', extension_raster=".tif", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "assembleImagePansharpening() : Pansharpening assembly starting " timeLine(path_time_log, starting_event) if debug >= 2: print(bold + green + "assembleImagePansharpening() : Variables dans la fonction" + endC) print(cyan + "assembleImagePansharpening() : " + endC + "image_panchro_input : " + str(image_panchro_input) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "image_xs_input : " + str(image_xs_input) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "image_output : " + str(image_output) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "mode_interpolation : " + str(mode_interpolation) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "method_interpolation : " + str(method_interpolation) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "method_pansharpening : " + str(method_pansharpening) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "interpolation_bco_radius : " + str(interpolation_bco_radius) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "pansharpening_lmvm_xradius : " + str(pansharpening_lmvm_xradius) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "pansharpening_lmvm_yradius : " + str(pansharpening_lmvm_yradius) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "pansharpening_bayes_lambda : " + str(pansharpening_bayes_lambda) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "pansharpening_bayes_s : " + str(pansharpening_bayes_s) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "ram_otb : " + str(ram_otb) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "assembleImagePansharpening() : " + endC + "overwrite : " + str(overwrite) + endC) # Les constantes EXT_GEOM = '.geom' XS_RESAMPLE_SUFFIX = "_resample" CODAGE = "uint16" print(endC) print(cyan + "assembleImagePansharpening() : " + bold + green + "## START : PANSHARPENING IMAGE" + endC) print(endC) # ETAPE 0 : PREPARATION # Preparation des fichiers intermediaires repertory_output = os.path.dirname(image_output) image_xs_resample_tmp = repertory_output + os.sep + os.path.splitext( os.path.basename( image_xs_input))[0] + XS_RESAMPLE_SUFFIX + extension_raster # Vérification de l'existence de l'image de sortie check = os.path.isfile(image_output) # Si oui et si la vérification est activée, passage à l'étape suivante if check and not overwrite: print(cyan + "assembleImagePansharpening() : " + bold + green + "Image de sortie existe déja : " + image_output + endC) # Si non ou si la vérification est désactivée, assemblage else: # Tentative de suppresion du fichier try: removeFile(image_output) except Exception: # Ignore l'exception levée si le fichier n'existe pas (et ne peut donc pas être supprimé) pass # ETAPE 1 : REECHANTILLONAGE DU FICHIER XS A LA RESOLUTION DU PANCHRO # Commande de mise en place de la geométrie re-echantionage command = "otbcli_Superimpose -inr " + image_panchro_input + " -inm " + image_xs_input + " -mode " + mode_interpolation + " -interpolator " + method_interpolation + " -out " + image_xs_resample_tmp if method_interpolation.lower() == 'bco': command += " -interpolator.bco.radius " + str( interpolation_bco_radius) if ram_otb > 0: command += " -ram %d" % (ram_otb) if debug >= 4: print(cyan + "assembleImagePansharpening() : " + bold + green + "SUPERIMPOSE DU FICHIER %s" % (image_xs_input) + endC) print(command) exit_code = os.system(command) if exit_code != 0: raise NameError( cyan + "assembleImagePansharpening() : " + bold + red + "!!! Une erreur c'est produite au cours du superimpose de l'image : " + image_xs_input + ". Voir message d'erreur." + endC) # ETAPE 2 : ASSEMBLE DES 2 FICHIERS PANCHRO + XS POUR CREER LE FICHIER DE SORTIE # Commande de d'assemnlage pansharpening command = "otbcli_Pansharpening -inp " + image_panchro_input + " -inxs " + image_xs_resample_tmp + " -method " + method_pansharpening + " -out " + image_output + " " + CODAGE if method_pansharpening.lower() == 'lmvm': command += " -method.lmvm.radiusx " + str( pansharpening_lmvm_xradius) + " -method.lmvm.radiusy " + str( pansharpening_lmvm_yradius) if method_pansharpening.lower() == 'bayes': command += " -method.bayes.lambda " + str( pansharpening_bayes_lambda) + " -method.bayes.s " + str( pansharpening_bayes_s) if ram_otb > 0: command += " -ram %d" % (ram_otb) if debug >= 4: print(cyan + "assembleImagePansharpening() : " + bold + green + "PANSHARPENING DES FICHIERS %s ET %s" % (image_panchro_input, image_xs_resample_tmp) + endC) print(command) exit_code = os.system(command) if exit_code != 0: raise NameError( cyan + "assembleImagePansharpening() : " + bold + red + "!!! Une erreur c'est produite au cours du pansharpening l'image : " + image_output + ". Voir message d'erreur." + endC) # ETAPE 3 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des données intermédiaires if not save_results_intermediate: if os.path.isfile(image_xs_resample_tmp): removeFile(image_xs_resample_tmp) if os.path.isfile( os.path.splitext(image_xs_resample_tmp)[0] + EXT_GEOM): # suppression du fichier de géométrie associé removeFile(os.path.splitext(image_xs_resample_tmp)[0] + EXT_GEOM) print(endC) print(cyan + "assembleImagePansharpening() : " + bold + green + "## END : PANSHARPENING IMAGE" + endC) print(endC) # Mise à jour du Log ending_event = "assembleImagePansharpening() : Pansharpening assembly ending " timeLine(path_time_log, ending_event) return
def rasterAssembly(input_images_list, output_image, radius, value_to_force, boundaries_shape, no_data_value, path_time_log, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster=".tif", save_results_inter=False, overwrite=True): # Mise à jour du Log starting_event = "rasterAssembly() : Assemblage d'images raster starting " timeLine(path_time_log, starting_event) if debug >= 3: print(cyan + "rasterAssembly() : " + endC + "input_images_list : " + str(input_images_list)) print(cyan + "rasterAssembly() : " + endC + "output_image : " + str(output_image)) print(cyan + "rasterAssembly() : " + endC + "radius : " + str(radius)) print(cyan + "rasterAssembly() : " + endC + "value_to_force : " + str(value_to_force)) print(cyan + "rasterAssembly() : " + endC + "boundaries_shape : " + str(boundaries_shape)) print(cyan + "rasterAssembly() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "rasterAssembly() : " + endC + "path_time_log : " + str(path_time_log)) print(cyan + "rasterAssembly() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "rasterAssembly() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "rasterAssembly() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "rasterAssembly() : " + endC + "save_results_inter : " + str(save_results_inter)) print(cyan + "rasterAssembly() : " + endC + "overwrite : " + str(overwrite)) print(cyan + "rasterAssembly() : " + bold + green + "START ...\n" + endC) # Gestion des noms de variables CODAGE = "uint16" images_input_list_str = " " for input_image in input_images_list: images_input_list_str += input_image + " " output_dir = os.path.dirname(output_image) output_name = os.path.splitext(os.path.basename(output_image))[0] temp_directory = output_dir + os.sep + "Temp" vrt_image = temp_directory + os.sep + output_name + '_vrt' + extension_raster assembled_image = temp_directory + os.sep + output_name + '_assembled' + extension_raster assembled_smoothed_image = temp_directory + os.sep + output_name + '_assembled_smoothed' + extension_raster assembled_cleaned_with_smooth_image = temp_directory + os.sep + output_name + '_assembled_cleaned_with_smooth' + extension_raster assembled_cleaned_with_smooth_and_value_to_force_image = temp_directory + os.sep + output_name + '_assembled_cleaned_with_smooth_and_value_to_force' + extension_raster assembled_cleaned_cutted_image = temp_directory + os.sep + output_name + '_assembled_cleaned_cutted' + extension_raster # ETAPE 1/5 : CREATION DU RASTER VIRTUEL if not os.path.exists(temp_directory): os.makedirs(temp_directory) command = "gdalbuildvrt -srcnodata %s %s %s" % ( str(no_data_value), vrt_image, images_input_list_str) if debug >= 2: print( '\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 1/5 : DEBUT DE LA CREATION DU RASTER VIRTUEL. Sortie : %s - Entrees : %s" % (vrt_image, images_input_list_str) + endC) print(command) exitCode = os.system(command) if exitCode != 0: raise NameError( cyan + "rasterAssembly() : " + bold + red + "An error occured during the virtual raster construction. See error message above." ) else: if debug >= 2: print('\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 1/5 : FIN DE LA CREATION DU RASTER VIRTUEL" + endC) # ETAPE 2/5 : DEBUT DE LA CONVERSION DU RASTER VIRTUEL EN .tif command = "gdal_translate -a_nodata %s -of %s %s %s" % ( str(no_data_value), format_raster, vrt_image, assembled_image) if debug >= 2: print( '\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 2/5 : DEBUT DE LA CONVERSION DU RASTER VIRTUEL EN .tif. Entree : %s - Sortie : %s" % (vrt_image, assembled_image) + endC) print(command) exitCode = os.system(command) if exitCode != 0: raise NameError( cyan + "rasterAssembly() : " + bold + red + "An error occured during the virtual raster conversion. See error message above." ) else: if debug >= 2: print( '\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 2/5 : FIN DE LA CONVERSION DU RASTER VIRTUEL EN .tif. " + endC) # ETAPE 3/5 : SUPPRESSION EVENTUELLE DU RASTER VIRTUEL if not save_results_inter: if debug >= 2: print('\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 3/5 : DEBUT DE LA SUPRESSION DU RASTER VIRTUEL %s" % (vrt_image) + endC) try: removeFile(vrt_image) # 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 if debug >= 2: print(cyan + "rasterAssembly() : " + bold + green + "ETAPE 3/5 : FIN DE LA SUPRESSION DU RASTER VIRTUEL" + endC) else: if debug >= 2: print(cyan + "rasterAssembly() : " + bold + yellow + "ETAPE 3/5 : PAS DE SUPPRESSION DU RASTER VIRTUEL %s" % (vrt_image) + endC) # ETAPE 4/5 et 5/5 : SI DEMANDE : CALCUL ET APPLICATION DU FILTRE MAJORITAIRE if radius > 0: # ETAPE 4/5 : Calcul du fichier filtre majoritaire command = "otbcli_ClassificationMapRegularization -io.in %s -io.out %s %s -ip.radius %d" % ( assembled_image, assembled_smoothed_image, CODAGE, radius) if debug >= 2: print( '\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 4/5 : DEBUT DU CALCUL DU FILTRE MAJORITAIRE DE RAYON %s. Entree : %s - Sortie : %s" % (radius, assembled_image, assembled_smoothed_image) + endC) print(command) exitCode = os.system(command) if exitCode != 0: raise NameError( cyan + "rasterAssembly() : " + bold + red + "An error occured during otbcli_ClassificationMapRegularization command. See error message above." ) else: if debug >= 2: print(cyan + "rasterAssembly() : " + bold + green + "ETAPE 4/5 : FIN DU CALCUL DU FILTRE MAJORITAIRE" + endC) # ETAPE 5/5 : Utilisation du fichier raster filtre majoritaire pour boucher les trous eventuels entre les images assemblées expression = "\"(im1b1 == 0? im2b1 : im1b1)\"" command = "otbcli_BandMath -il %s %s -exp %s -out %s %s" % ( assembled_image, assembled_smoothed_image, expression, assembled_cleaned_with_smooth_image, CODAGE) if debug >= 2: print( '\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 5/5 : DEBUT DE L'APPLICATION DU FILTRE MAJORITAIRE. Sortie : %s - Entree : %s et %s" % (assembled_cleaned_with_smooth_image, assembled_image, assembled_smoothed_image) + endC) print(command) exitCode = os.system(command) if exitCode != 0: raise NameError( cyan + "rasterAssembly() : " + bold + red + "An error occured during otbcli_BandMath command. See error message above." ) else: if debug >= 2: print( cyan + "rasterAssembly() : " + bold + green + "ETAPE 5/5 : FIN DE L'APPLICATION DU FILTRE MAJORITAIRE" + endC) # Supression éventuelle du filtre majoritaire et de l'image non nettoyée if not save_results_inter: if debug >= 2: print( cyan + "rasterAssembly() : " + bold + green + "SUPRESSION DU FILTRE MAJORITAIRE %s ET DE L'IMAGE NON NETTOYEE %s" % (assembled_smoothed_image, assembled_image) + endC) try: removeFile(assembled_smoothed_image ) # 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 try: removeFile( assembled_image) # 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 else: # Cas où le filtre majoritaire n'est pas demandé assembled_cleaned_with_smooth_image = assembled_image if debug >= 2: print('\n' + cyan + "rasterAssembly() : " + bold + yellow + "ETAPE 4/5 : PAS DE CALCUL DU FILTRE MAJORITAIRE DEMANDE" + endC) print( '\n' + cyan + "rasterAssembly() : " + bold + yellow + "ETAPE 5/5 : PAS D'APPLICATION DU FILTRE MAJORITAIRE DEMANDE" + endC) # ETAPE 6/5 : SI DEMANDE : ON IMPOSE UNE VALEUR "value_to_force" POUR LES 0 RESTANTS if value_to_force > 0: expression = "\"(im1b1 == 0? %d : im1b1)\"" % (value_to_force) command = "otbcli_BandMath -il %s -exp %s -out %s %s" % ( assembled_cleaned_with_smooth_image, expression, assembled_cleaned_with_smooth_and_value_to_force_image, CODAGE) if debug >= 2: print( '\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 6/5 : DEBUT DU NETTOYAGE DES ZEROS RESTANTS, TRANSFORMES EN %s. SORTIE : %s" % (value_to_force, assembled_cleaned_with_smooth_and_value_to_force_image) + endC) print(command) exitCode = os.system(command) if exitCode != 0: raise NameError( cyan + "rasterAssembly() : " + bold + red + "An error occured during the otbcli_BandMath command. See error message above." ) else: if debug >= 2: print(cyan + "rasterAssembly() : " + bold + green + "ETAPE 6/5 : FIN DU NETTOYAGE DES ZEROS RESTANTS" + endC) # Supression éventuelle de l'image non nettoyée if not save_results_inter: if debug >= 2: print(cyan + "rasterAssembly() : " + bold + green + "SUPRESSION DE L'IMAGE NON NETTOYEE %s" % (assembled_cleaned_with_smooth_image) + endC) try: removeFile(assembled_cleaned_with_smooth_image ) # 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 else: # Cas où le forcage d'une valeur n'est pas demandé assembled_cleaned_with_smooth_and_value_to_force_image = assembled_cleaned_with_smooth_image if debug >= 2: print('\n' + cyan + "rasterAssembly() : " + bold + yellow + "ETAPE 6/5 : AUCUNE VALEUR IMPOSEE POUR LES 0" + endC) # ETAPE 7/5 : SI DEMANDE : DECOUPAGE AU REGARD DE L'EMPRISE if boundaries_shape != "": if debug >= 2: print( '\n' + cyan + "rasterAssembly() : " + bold + green + "ETAPE 7/5 : DEBUT DU DECOUPAGE AU REGARD DE L EMPRISE GLOBALE %s" % (boundaries_shape) + endC) if not cutImageByVector( boundaries_shape, assembled_cleaned_with_smooth_and_value_to_force_image, output_image, None, None, no_data_value, 0, format_raster, format_vector): raise NameError( cyan + "rasterAssembly() : " + bold + red + "An error occured during the cutting. See error message above." ) else: if debug >= 2: print( cyan + "rasterAssembly() : " + bold + green + "ETAPE 7/5 : FIN DU DECOUPAGE AU REGARD DE L'EMPRISE GLOBALE" + endC) # Supression éventuelle de l'image non découpée if not save_results_inter: if debug >= 2: print( cyan + "rasterAssembly() : " + bold + green + "SUPRESSION DE L'IMAGE NON DECOUPEE %s" % (assembled_cleaned_with_smooth_and_value_to_force_image) + endC) try: removeFile( assembled_cleaned_with_smooth_and_value_to_force_image ) # 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 else: os.rename( assembled_cleaned_with_smooth_and_value_to_force_image, output_image ) # Dans ce cas, l'image finale est assembled_cleaned_with_smooth_and_value_to_force_image, qu'il faut renommer if debug >= 2: print('\n' + cyan + "rasterAssembly() : " + bold + yellow + "ETAPE 7/5 : AUCUN DECOUPAGE FINAL DEMANDE" + endC) # SUPPRESSION DU DOSSIER TEMP if not save_results_inter and os.path.exists(temp_directory): deleteDir(temp_directory) if debug >= 2: print(cyan + "rasterAssembly() : " + bold + green + "FIN DE L'ASSEMBLAGE DES RASTERS. Sortie : %s" % (output_image) + endC) # Mise à jour du Log ending_event = "rasterAssembly() : Realocation micro class on classification image ending : " timeLine(path_time_log, ending_event) return
def createTableModifier(centroids_input_files_list, indicators_input_file, matrix_input_file, validation_input_vector, label_macro_list, table_output_file, path_time_log, rate_area_min, threshold_delete_perf, threshold_alert_perf, format_vector='ESRI Shapefile', save_results_intermediate=False, overwrite=True) : # Mise à jour du Log starting_event = "createTableModifier() : Create table modifier starting : " timeLine(path_time_log,starting_event) print(cyan + "createTableModifier() : " + bold + green + "START ...\n" + endC) # Affichage des parametres if debug >= 3: print(cyan + "createTableModifier() : " + endC + "centroids_input_files_list: "+ str(centroids_input_files_list)) print(cyan + "createTableModifier() : " + endC + "indicators_input_file: "+ str(indicators_input_file)) print(cyan + "createTableModifier() : " + endC + "matrix_input_file: "+ str(matrix_input_file)) print(cyan + "createTableModifier() : " + endC + "validation_input_vector: "+ str(validation_input_vector)) print(cyan + "createTableModifier() : " + endC + "label_macro_list: "+ str(label_macro_list)) print(cyan + "createTableModifier() : " + endC + "table_output_file: "+ str(table_output_file)) print(cyan + "createTableModifier() : " + endC + "path_time_log: " + str(path_time_log)) print(cyan + "createTableModifier() : " + endC + "rate_area_min: " + str(rate_area_min)) print(cyan + "createTableModifier() : " + endC + "threshold_delete_perf: " + str(threshold_delete_perf)) print(cyan + "createTableModifier() : " + endC + "threshold_alert_perf: " + str(threshold_alert_perf)) print(cyan + "createTableModifier() : " + endC + "format_vector: " + str(format_vector)) print(cyan + "createTableModifier() : " + endC + "save_results_intermediate: "+ str(save_results_intermediate)) print(cyan + "createTableModifier() : " + endC + "overwrite: "+ str(overwrite)) # Test si ecrassement de la table précédemment créée check = os.path.isfile(table_output_file) if check and not overwrite : print(cyan + "createTableModifier() : " + bold + yellow + "Modifier table already exists." + '\n' + endC) else: # Tenter de supprimer le fichier try: removeFile(table_output_file) except Exception: # Ignore l'exception levee si le fichier n'existe pas (et ne peut donc pas être supprime) pass # lecture des fichiers centroides microclass_centroides_list = readCentroidsFiles(centroids_input_files_list) # lecture du fichier indicateurs de qualité indicator_macro_dico,indicator_general_dico = readQualityIndicatorsFile(indicators_input_file) # lecture de la matrice de confusion matrix,class_ref_list,class_pro_list = readConfusionMatrix(matrix_input_file) # correction de la matrice de confision pour identifier les micro classes manquantes missed_micro_list = [] if class_ref_list != class_pro_list: matrix, missed_micro_list = correctMatrix(class_ref_list, class_pro_list, matrix) # creer la liste de microclasse en de 'int' class_labels_list =[] for class_elem in class_pro_list: class_labels_list.append(int(class_elem)) if debug >= 3: print(cyan + "createTableModifier() : " + endC + "indicator_macro_dico : " + str(indicator_macro_dico) + "\n") print(cyan + "createTableModifier() : " + endC + "indicator_general_dico : " + str(indicator_general_dico) + "\n") print(cyan + "createTableModifier() : " + endC + "microclass_centroides_list = " + str(microclass_centroides_list)) print(cyan + "createTableModifier() : " + endC + "missed_micro_list : " + str(missed_micro_list)) print(cyan + "createTableModifier() : " + endC + "class_ref_list : " + str(class_ref_list)) print(cyan + "createTableModifier() : " + endC + "class_pro_list : " + str(class_pro_list)) print(cyan + "createTableModifier() : " + endC + "class_labels_list : " + str(class_labels_list)) # indentifier les microclasses suspectes s_suspect_microclass1,s_suspect_microclass2 = findSuspiciousMicroClass(label_macro_list, microclass_centroides_list) # detecter les micro classes suspectes suspect_micro_list,s_performance_list = detectSuspiciousMicroclass(indicator_macro_dico, class_labels_list, threshold_alert_perf) if debug >= 3: print(cyan + "createTableModifier() : " + endC + "s_suspect_microclass1 = " + str(s_suspect_microclass1)) print(cyan + "createTableModifier() : " + endC + "s_suspect_microclass2 = " + str(s_suspect_microclass2)) print(cyan + "createTableModifier() : " + endC + "suspect_micro_list = " + str(suspect_micro_list)) print(cyan + "createTableModifier() : " + endC + "s_performance_list = " + str(s_performance_list)) # creation de la liste de proposition de réaffectation des micro classes proposal_text = proposeReallocationMicroClass(validation_input_vector, s_suspect_microclass1, s_suspect_microclass2, s_performance_list, missed_micro_list, suspect_micro_list, table_output_file, label_macro_list, rate_area_min, threshold_delete_perf, threshold_alert_perf, format_vector) # ecriture du fichier proposition de réaffectation writeTextFile(table_output_file, proposal_text) print(cyan + "createTableModifier() : " + bold + green + "END\n" + endC) # Mise à jour du Log ending_event = "createTableModifier() : Create table modifier ending : " timeLine(path_time_log,ending_event) 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 filterImageMajority(image_input, filtered_image_output, filter_mode, radius, umc_pixels, path_time_log, ram_otb=0, save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "filterImageMajority() : Filter image starting : " timeLine(path_time_log, starting_event) print(endC) print(bold + green + "## START : MAP REGULARIZATION" + endC) print(endC) CODAGE = "uint16" if debug >= 2: print(bold + green + "filterImageMajority() : Variables dans la fonction" + endC) print(cyan + "filterImageMajority() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "filterImageMajority() : " + endC + "filtered_image_output : " + str(filtered_image_output) + endC) print(cyan + "filterImageMajority() : " + endC + "filter_mode : " + str(filter_mode) + endC) print(cyan + "filterImageMajority() : " + endC + "radius : " + str(radius) + endC) print(cyan + "filterImageMajority() : " + endC + "umc_pixels : " + str(umc_pixels) + endC) print(cyan + "filterImageMajority() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "filterImageMajority() : " + endC + "ram_otb : " + str(ram_otb) + endC) print(cyan + "filterImageMajority() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "filterImageMajority() : " + endC + "overwrite : " + str(overwrite) + endC) # Vérification de l'existence d'une image filtrée check = os.path.isfile(filtered_image_output) # Si oui et si la vérification est activée, passage à l'étape suivante if check and not overwrite: print(cyan + "filterImageMajority() : " + bold + green + "Image already filtered with window size of " + str(radius) + "." + endC) # Si non ou si la vérification est désactivée, application du filtre else: # Tentative de suppresion du fichier try: removeFile(filtered_image_output) except Exception: # Ignore l'exception levée si le fichier n'existe pas (et ne peut donc pas être supprimé) pass if debug >= 3: print( cyan + "filterImageMajority() : " + bold + green + "Applying majority filter with window size ", str(radius), "...", '\n' + endC) # Selon le mode de filtrage if filter_mode.lower() == "otb": # Par otbcli_ClassificationMapRegularization command = "otbcli_ClassificationMapRegularization -io.in %s -io.out %s %s -ip.radius %d" % ( image_input, filtered_image_output, CODAGE, radius) if ram_otb > 0: command += " -ram %d" % (ram_otb) else: # Par gdal_sieve command = "gdal_sieve.py -st %d -8 %s %s" % ( umc_pixels, image_input, filtered_image_output) if debug >= 3: print(command) exitCode = os.system(command) if exitCode != 0: raise NameError( cyan + "filterImageMajority() : " + bold + red + "An error occured during otbcli_ClassificationMapRegularization command. See error message above." ) print('\n' + cyan + "filterImageMajority() : " + bold + green + "Filter applied!" + endC) # Supression des .geom dans le dossier directory_output = os.path.dirname(filtered_image_output) for to_delete in glob.glob(directory_output + os.sep + "*.geom"): removeFile(to_delete) print(endC) print(bold + green + "## END : MAP REGULARIZATION" + endC) print(endC) # Mise à jour du Log ending_event = "filterImageMajority() : Filter image ending : " timeLine(path_time_log, ending_event) return
def normalizeChannels(image_stack_input, image_normalised_stack_output, path_time_log, save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "normalizeChannels() : Normalize channels starting : " timeLine(path_time_log,starting_event) print(endC) print(bold + green + "## START : CHANNELS NORMALIZATION" + endC) print(endC) # Constantes CODAGE = "float" # Nom de l'image en entrée repertory_stacks_output = os.path.dirname(image_normalised_stack_output) image_name = os.path.splitext(os.path.basename(image_stack_input))[0] extension_file = os.path.splitext(os.path.basename(image_stack_input))[1] statistics_image_normalize_output = os.path.splitext(image_normalised_stack_output)[0] + "_statistics.xml" if debug >= 3: print(bold + green + "Variables dans la fonction" + endC) print(cyan + "normalizeChannels() : " + endC + "image_stack_input : " + str(image_stack_input) + endC) print(cyan + "normalizeChannels() : " + endC + "image_normalised_stack_output : " + str(image_normalised_stack_output) + endC) print(cyan + "normalizeChannels() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "normalizeChannels() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "normalizeChannels() : " + endC + "overwrite : " + str(overwrite) + endC) print(cyan + "normalizeChannels() : " + endC + "image_name : " + str(image_name) + endC) print(cyan + "normalizeChannels() : " + endC + "extension_file : " + str(extension_file) + endC) print(cyan + "normalizeChannels() : " + endC + "repertory_stacks_output : " + str(repertory_stacks_output) + endC) # Si l'empilement existe deja et que overwrite n'est pas activé check = os.path.isfile(image_normalised_stack_output) if check and not overwrite: print(bold + yellow + "Stack normalized already exists and will not be calculated again." + endC) else: if check : try: removeFile(image_normalised_stack_output) except Exception: pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée # Calcul des statistiques de l'empilement # Les statistiques sont dans un fichier xml presentant un paragraphe pour la moyenne et un autre pour l'ecart-type. Chaque paragraphe contient une ligne par bande dont l'ordre correspond à celui de l'empilement print(bold + green + "Calcul des statistiques de %s " %(image_stack_input) + endC) computeStatisticsImage(image_stack_input, statistics_image_normalize_output) statistics_file_parser = parseDom(statistics_image_normalize_output) statistics_nodes_list = statistics_file_parser.getElementsByTagName('Statistic') # Initialise les listes des moyennes et des ecart-types des bandes de l'empilement means_list = [] stddevs_list = [] # Parcours du fichier de statistiques pour recuperer les valeur de moyenne et d'ecart-type associees a chaque bande if debug >= 1: print(cyan + "normalizeChannels() : " + endC + bold + green + "Parsing statistics file ..." + endC) for statistic in statistics_nodes_list: statistics_list = [] nodes_values_list = statistic.getElementsByTagName('StatisticVector') for node in nodes_values_list: value = node.attributes['value'].value # Si la ligne comporte la balise "mean", ajoute la valeur associee a la liste des moyennes if statistic.attributes['name'].value == "mean": value = node.attributes['value'].value means_list.append(value) # Si la ligne comporte la balise "stddev", ajoute la valeur associee a la liste des ecart-types elif statistic.attributes['name'].value == "stddev": value = node.attributes['value'].value stddevs_list.append(value) if debug >= 1: print(cyan + "normalizeChannels() : " + endC + bold + green + "Parsing statistics complete." + endC) print(cyan + "normalizeChannels() : " + endC + "means_list : " + str(means_list) + endC) print(cyan + "normalizeChannels() : " + endC + "stddevs_list : " + str(stddevs_list) + endC) number_of_bands = len(means_list) # Nombre de bandes a empiler (= nombre de valeurs dans la liste des moyennes par exemple) bands_to_concatenate_list = "" # Initialisation de la liste des bandes extraites de l'empilement files_to_delete_list = [] # Initialisation de la liste de ces mêmes bandes pour la supression (format different de celui necessaire pour les applications OTB) # Parcours des bandes de l'empilement, en utilisant la place de leur moyenne dans la liste des moyennes pour conserver le même ordre que dans l'empilement for band in range (number_of_bands): mean_value = means_list[band] stddev_value = stddevs_list[band] normalised_band = repertory_stacks_output + os.sep + image_name + "_b" + str(band) + extension_file expression = "\"(im1b" + str(band+1) + "-(" + str(mean_value) + "))/" + str(stddev_value) + "\"" if debug >= 1: print(cyan + "normalizeChannels() : " + endC + "Normalizing band %s" %(band)+ endC) if debug >= 2: print(cyan + "normalizeChannels() : " + endC + "mean_value : " + str(mean_value) + endC) print(cyan + "normalizeChannels() : " + endC + "stddev_value : " + str(stddev_value) + endC) print(cyan + "normalizeChannels() : " + endC + "normalised_band : " + str(normalised_band) + endC) command = "otbcli_BandMath -il %s -out %s %s -exp %s" %(image_stack_input,normalised_band,CODAGE,expression) if debug >= 3: print(command) exitCode = os.system(command) if exitCode != 0: print(command) raise NameError(cyan + "normalizeChannels() : " + bold + red + "An error occured during otbcli_BandMath command. See error message above." + endC) if debug >= 1: print(cyan + "normalizeChannels() : " + endC + bold + green + "Band %s normalized." %(band)+ endC) print(endC) # Mise à jour de bands_to_concatenate_list et files_to_delete_list bands_to_concatenate_list += " " + normalised_band files_to_delete_list.append(normalised_band) if debug >= 1: print(cyan + "normalizeChannels() : " + endC + bold + green + "Stacking bands ..."+ endC) if debug >= 2: print(cyan + "normalizeChannels() : " + endC + bold + green + "Debut de la concatenation de "+ endC + " %s ..." %(bands_to_concatenate_list)+ endC) print(endC) # Empile les bandes dans un nouveau fichier exitCode = os.system("otbcli_ConcatenateImages -progress true -il %s -out %s %s" %(bands_to_concatenate_list, image_normalised_stack_output, CODAGE)) if exitCode != 0: raise NameError(cyan + "normalizeChannels() : " + bold + red + "An error occured during otbcli_ConcatenateImages command. See error message above." + endC) # Suppression des bandes normalisees seulles - Possibilitée de passer cette activation en parametre if not save_results_intermediate: for file_del in files_to_delete_list: removeFile(file_del) # Suppression des bandes print(endC) print(bold + green + "## END : CHANNELS NORMALIZATION" + endC) print(endC) # Mise à jour du Log ending_event = "normalizeChannels() : Normalize channels ending : " timeLine(path_time_log,ending_event) return
def classifyVector(vector_input, classif_vector_output, list_feat, expression, input_cfield, output_cfield, path_time_log, format_vector='ESRI Shapefile', extension_vector=".shp", extension_xml = ".xml", extension_model = ".model", save_results_intermediate=False, overwrite=True): # Constante SUFFIX_OUT = "_out" SUFFIX_TRAIN = "_train" # Mise à jour du Log starting_event = "classifyVector() : Classification vecteur starting : " timeLine(path_time_log,starting_event) print(endC) print(bold + green + "## START : classifyVector" + endC) print(endC) if debug >= 2: print(bold + green + "classifyVector() : Variables dans la fonction" + endC) print(cyan + "classifyVector() : " + endC + "vector_input : " + str(vector_input) + endC) print(cyan + "classifyVector() : " + endC + "classif_vector_output : " + str(classif_vector_output) + endC) print(cyan + "classifyVector() : " + endC + "list_feat : " + str(list_feat) + endC) print(cyan + "classifyVector() : " + endC + "input_cfield : " + str(input_cfield) + endC) print(cyan + "classifyVector() : " + endC + "output_cfield : " + str(output_cfield) + endC) print(cyan + "classifyVector() : " + endC + "expression : " + str(expression) + endC) print(cyan + "classifyVector() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "classifyVector() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "classifyVector() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "classifyVector() : " + endC + "extension_xml : " + str(extension_xml) + endC) print(cyan + "classifyVector() : " + endC + "extension_model : " + str(extension_model) + endC) print(cyan + "classifyVector() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "classifyVector() : " + endC + "overwrite : " + str(overwrite) + endC) # Creation des chemins d'enregistrement des calculs: repertory_output = os.path.dirname(vector_input) name = os.path.splitext(os.path.basename(vector_input))[0] layer_name = name vector_output_train_tmp = repertory_output + os.sep + name + SUFFIX_TRAIN + extension_vector outstats = repertory_output + os.sep + name + extension_xml model = repertory_output + os.sep + name + extension_model # Vérification si le vecteur de sortie est définie if classif_vector_output == "" : classif_vector_output = repertory_output + os.sep + name + SUFFIX_OUT + extension_vector # Vérification de l'existence d'une couche vecteur classée check = os.path.isfile(classif_vector_output) # Si oui et si la vérification est activée, passage à l'étape suivante if check and not overwrite : print(cyan + "classifyVector() : " + bold + green + "vector already classified" + "." + endC) # Si non ou si la vérification est désactivée, application du filtre else: # Tentative de suppresion du fichier try: removeVectorFile(classif_vector_output, format_vector=format_vector) except Exception: # Ignore l'exception levée si le fichier n'existe pas (et ne peut donc pas être supprimé) pass if debug >= 3: print(cyan + "classifyVector() : " + bold + green + "Applying classified segmenation", "..." , '\n' + endC) # Recuperation du driver pour le format shape fichier entrée driver_input = ogr.GetDriverByName(format_vector) # Ouverture du fichier shape en lecture data_source_input = driver_input.Open(vector_input, 1) # 1 means writeable. if data_source_input is None: print(cyan + "classifyVector() : " + bold + red + "Impossible d'ouvrir le fichier vecteur : " + vector_input + endC, file=sys.stderr) sys.exit(1) # exit with an error code # Recuperer la couche (une couche contient les segments) layer_input = data_source_input.GetLayer(0) # Vérification de l'existence de la colonne col (retour = -1 : elle n'existe pas) layer_definition = layer_input.GetLayerDefn() # GetLayerDefn => returns the field names of the user defined (created) fields id_field = layer_definition.GetFieldIndex(output_cfield) if id_field != -1 : print(cyan + "classifyVector() : " + bold + yellow + "Attention le champs de classification existe déjà" + output_cfield + endC) layer_input.DeleteField(id_field) # Fermeture du fichier vector_input layer_input.SyncToDisk() data_source_input.Destroy() # Selection du fichier vecteur d'apprentissage if overwrite: overwrite_str = "-overwrite" command = "ogr2ogr -f '%s' %s %s %s -where \"%s\" " % (format_vector, overwrite_str, vector_output_train_tmp ,vector_input, expression) if debug >= 2: print(command) exit_code = os.system(command) if exitCode!= 0: print(command) raise NameError (cyan + "classifyVector() : " + bold + red + "ogr2ogr. Selection du fichier vecteur d'apprentissage erreur." + endC) # Les champs utilisés pour la calssification # Exemple : list_feat = ['meanB0' , 'meanB1' , 'meanB2' , 'meanB3' , 'varB0' , 'varB1' , 'varB2' , 'varB3'] feat = str ("-feat") feat += " " + str(''.join(list_feat)) # Classification : # 1) Calculer les statistiques command = "otbcli_ComputeOGRLayersFeaturesStatistics -inshp %s -outstats %s " %(segmented_input, outstats) command += "%s" %(feat) if debug >= 2: print(command) exitCode = os.system(command) if exitCode!= 0: print(command) raise NameError (cyan + "classifyVector() : " + bold + red + "otbcli_ComputeOGRLayersFeaturesStatistics. See error message above." + endC) # 2) Générer le model command = "otbcli_TrainVectorClassifier -io.vd %s -io.stats %s -io.out %s -cfield %s " %(vector_output_train_tmp, outstats, model, input_cfield) command += "%s" %(feat) if debug >= 2: print(command) exitCode = os.system(command) if exitCode!= 0: print(command) raise NameError (cyan + "classifyVector() : " + bold + red + "otbcli_TrainVectorClassifier. See error message above." + endC) # 3) Produire la classifictaion command = "otbcli_VectorClassifier -in %s -instat %s -model %s -cfield %s -out %s " %(segmented_input, outstats, model, output_cfield, classif_vector_output) command += "%s" %(feat) if debug >= 2: print(command) exitCode = os.system(command) if exitCode!= 0: print(command) raise NameError (cyan + "classifyVector() : " + bold + red + "otbcli_VectorClassifier. See error message above." + endC) # Suppression des données intermédiaires if not save_results_intermediate: # Supression du fichier temporaire de segmentation if os.path.isfile(vector_output_train_tmp) : removeFile(vector_output_train_tmp) print(endC) print(bold + green + "## END : classifyVector" + endC) print(endC) # Mise à jour du Log ending_event = "classifyVector() : Classifictaion vector ending : " timeLine(path_time_log,ending_event) return
def concatenateChannels(images_input_list, stack_image_output, path_time_log, save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "concatenateChannels() : Concatenate channels starting : " timeLine(path_time_log,starting_event) print(endC) print(bold + green + "## START : CHANNELS CONCATENATION" + endC) print(endC) # Constantes CODAGE = "float" if debug >= 3: print(bold + green + "Variables dans la fonction" + endC) print(cyan + "concatenateChannels() : " + endC + "images_input_list : " + str(images_input_list) + endC) print(cyan + "concatenateChannels() : " + endC + "stack_image_output : " + str(stack_image_output) + endC) print(cyan + "concatenateChannels() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "concatenateChannels() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "concatenateChannels() : " + endC + "overwrite : " + str(overwrite) + endC) check = os.path.isfile(stack_image_output) if check and not overwrite: # Si l'empilement existe deja et que overwrite n'est pas activé print(bold + yellow + "File " + stack_image_output + " already exists and will not be calculated again." + endC) else: if check: try: removeFile(stack_image_output) except Exception: pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée print(bold + green + "Searching for channels to add..." + endC) elements_to_stack_list_str = "" # Initialisation de la liste des fichiers autres a empiler # Gestion des fichiers a ajouter for image_name_other in images_input_list: if debug >= 3: print(cyan + "concatenateChannels() : " + endC + "image_name_other : " + str(image_name_other) + endC) # Verification de l'existence de image_name_other if not os.path.isfile(image_name_other) : # Si image_name_other n'existe pas, message d'erreur raise NameError(cyan + "concatenateChannels() : " + bold + red + "The file %s not existe!"%(image_name_other) + endC) # Ajouter l'indice a la liste des indices a empiler elements_to_stack_list_str += " " + image_name_other if debug >= 1: print(cyan + "concatenateChannels() : " + endC + "elements_to_stack_list_str : " + str(elements_to_stack_list_str) + endC) # Stack de l'image avec les images additionnelles if len(elements_to_stack_list_str) > 0: # Assemble la liste d'image en une liste globale de fichiers d'entree print(bold + green + "concatenateChannels() : Assembling channels %s ... "%(elements_to_stack_list_str) + endC) command = "otbcli_ConcatenateImages -progress true -il %s -out %s %s" %(elements_to_stack_list_str,stack_image_output,CODAGE) if debug >= 3: print(command) exitCode = os.system(command) if exitCode != 0: print(command) raise NameError(cyan + "concatenateChannels() : " + bold + red + "An error occured during otbcli_ConcatenateImages command. See error message above." + endC) print(bold + green + "concatenateChannels() : Channels successfully assembled" + endC) print(endC) print(bold + green + "## END : CHANNELS CONCATENATION" + endC) print(endC) # Mise à jour du Log ending_event = "concatenateChannels() : Concatenate channels ending : " timeLine(path_time_log,ending_event) return
def displayTree(origin_tree, origin_name, name_file_graph, path_time_log, save_results_intermediate, overwrite): # Constantes EXT_DOT = ".dot" EXT_PNG = ".png" GRAPH_NAME = "graph_LCZ" # Mise à jour du Log starting_event = "displayTree() : Graph creation starting : " timeLine(path_time_log, starting_event) label_graph = os.path.splitext(os.path.basename(name_file_graph))[0] path_file = os.path.dirname(name_file_graph) dot_file = path_file + os.sep + label_graph + EXT_DOT if os.path.isfile(dot_file): removeFile(dot_file) png_file = path_file + os.sep + label_graph + EXT_PNG # VERIFICATION SI LE MASQUE DE SORTIE EXISTE DEJA # Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors passe au masque suivant check = os.path.isfile(png_file) if check and not overwrite: print(bold + yellow + "displayTree() : " + endC + "Output png file %s already done : no actualisation" % (png_file) + endC) return # Si non, ou si la fonction ecrasement est désative, alors on le calcule else: if check: try: # Suppression de l'éventuel fichier existant removeFile(png_file) except Exception: pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite # Definie les parametres du graphe graph = pgv.AGraph(name=GRAPH_NAME, directed=True) graph.graph_attr['outputorder'] = 'edgesfirst' graph.graph_attr['label'] = label_graph #graph.graph_attr['ratio']='1.0' graph.graph_attr['ratio'] = 'compress' graph.graph_attr['rankdir'] = 'TB' graph.node_attr['shape'] = 'ellipse' graph.node_attr['fixedsize'] = 'false' graph.node_attr['fontsize'] = '8' graph.node_attr['style'] = 'filled' graph.edge_attr['color'] = 'lightslategray' graph.edge_attr['style'] = 'etlinewidth(2)' graph.edge_attr['arrowhead'] = 'open' graph.edge_attr.update(arrowhead='vee', arrowsize='2') # Definir la couleur selon le noeud ou feuille value_color = 'gray52' # Creation du 1er noeud id_node = 0 graph.add_node(id_node) node = graph.get_node(id_node) # Assign node color node.attr['fillcolor'] = value_color # Empty labels node.attr['label'] = origin_name + '\n' # Start parcours de l'arbre graph = createDisplayGraph(origin_tree, id_node, graph, debug) # Ecriture dans le fichier graph_reverse = graph.reverse() graph_reverse.write(dot_file) # Ignore Graphviz warning messages warnings.simplefilter('ignore', RuntimeWarning) graph = pgv.AGraph(name=GRAPH_NAME) # Convert file .dot graph.read(dot_file) graph.layout(prog='dot') # layout with default (neato) png_draw = graph.draw(png_file, format='png', prog='dot') # Suppression des données intermédiaires if not save_results_intermediate: #removeFile(dot_file) pass # Mise à jour du Log ending_event = "displayTree() : Graph creation ending : " timeLine(path_time_log, ending_event) return
def estimateQualityMns(image_input, vector_cut_input, vector_sample_input_list, vector_sample_points_input, raster_input_dico, vector_output, no_data_value, path_time_log, format_raster='GTiff', epsg=2154, format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "estimateQualityMns() : Masks creation starting : " timeLine(path_time_log, starting_event) print(endC) print(bold + green + "## START : CREATE HEIGHT POINTS FILE FROM MNS" + endC) print(endC) if debug >= 2: print(bold + green + "estimateQualityMns() : Variables dans la fonction" + endC) print(cyan + "estimateQualityMns() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "estimateQualityMns() : " + endC + "vector_cut_input : " + str(vector_cut_input) + endC) print(cyan + "estimateQualityMns() : " + endC + "vector_sample_input_list : " + str(vector_sample_input_list) + endC) print(cyan + "estimateQualityMns() : " + endC + "vector_sample_points_input : " + str(vector_sample_points_input) + endC) print(cyan + "estimateQualityMns() : " + endC + "raster_input_dico : " + str(raster_input_dico) + endC) print(cyan + "estimateQualityMns() : " + endC + "vector_output : " + str(vector_output) + endC) print(cyan + "estimateQualityMns() : " + endC + "no_data_value : " + str(no_data_value)) print(cyan + "estimateQualityMns() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "estimateQualityMns() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "estimateQualityMns() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "estimateQualityMns() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "estimateQualityMns() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "estimateQualityMns() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "estimateQualityMns() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "estimateQualityMns() : " + endC + "overwrite : " + str(overwrite) + endC) # Définion des constantes EXT_DBF = '.dbf' EXT_CSV = '.csv' CODAGE = "uint16" SUFFIX_STUDY = '_study' SUFFIX_CUT = '_cut' SUFFIX_TEMP = '_temp' SUFFIX_CLEAN = '_clean' SUFFIX_SAMPLE = '_sample' ATTRIBUTE_ID = "ID" ATTRIBUTE_Z_INI = "Z_INI" ATTRIBUTE_Z_FIN = "Z_FIN" ATTRIBUTE_PREC_ALTI = "PREC_ALTI" ATTRIBUTE_Z_REF = "Z_Ref" ATTRIBUTE_Z_MNS = "Z_Mns" ATTRIBUTE_Z_DELTA = "Z_Delta" ERODE_EDGE_POINTS = -1.0 ERROR_VALUE = -99.0 ERROR_MIN_VALUE = -9999 ERROR_MAX_VALUE = 9999 # ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES # Si le fichier de sortie existe on ecrase check = os.path.isfile(vector_output) if check and not overwrite: # Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors FIN print(cyan + "estimateQualityMns() : " + bold + yellow + "Create file %s already exist : no actualisation" % (vector_output) + endC) return if os.path.isfile(os.path.splitext(vector_output)[0] + EXT_CSV): removeFile(os.path.splitext(vector_output)[0] + EXT_CSV) repertory_output = os.path.dirname(vector_output) base_name = os.path.splitext(os.path.basename(vector_output))[0] vector_output_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector raster_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_raster vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector vector_study_clean = repertory_output + os.sep + base_name + SUFFIX_STUDY + SUFFIX_CLEAN + extension_vector image_cut = repertory_output + os.sep + base_name + SUFFIX_CUT + extension_raster vector_sample_temp = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + extension_vector vector_sample_temp_clean = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + SUFFIX_CLEAN + extension_vector # Utilisation des données raster externes raster_cut_dico = {} for raster_input in raster_input_dico: base_name_raster = os.path.splitext(os.path.basename(raster_input))[0] raster_cut = repertory_output + os.sep + base_name_raster + SUFFIX_CUT + extension_raster raster_cut_dico[raster_input] = raster_cut if os.path.exists(raster_cut): removeFile(raster_cut) # ETAPE 1 : DEFINIR UN SHAPE ZONE D'ETUDE if (not vector_cut_input is None) and (vector_cut_input != "") and ( os.path.isfile(vector_cut_input)): cutting_action = True vector_study = vector_cut_input else: cutting_action = False createVectorMask(image_input, vector_study) # ETAPE 2 : DECOUPAGE DU RASTEUR PAR LE VECTEUR D'ETUDE SI BESOIN ET REECHANTILLONAGE SI BESOIN if cutting_action: # Identification de la tailles de pixels en x et en y du fichier MNS de reference pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input) # Si le fichier de sortie existe deja le supprimer if os.path.exists(image_cut): removeFile(image_cut) # Commande de découpe if not cutImageByVector(vector_study, image_input, image_cut, pixel_size_x, pixel_size_y, no_data_value, 0, format_raster, format_vector): print( cyan + "estimateQualityMns() : " + bold + red + "Une erreur c'est produite au cours du decoupage de l'image : " + image_input + endC, file=sys.stderr) raise if debug >= 2: print(cyan + "estimateQualityMns() : " + bold + green + "DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" % (image_input, vector_study) + endC) else: image_cut = image_input # Definir l'emprise du fichier MNS de reference # Decoupage de chaque raster de la liste des rasters for raster_input in raster_input_dico: raster_cut = raster_cut_dico[raster_input] if not cutImageByVector(vector_study, raster_input, raster_cut, pixel_size_x, pixel_size_y, no_data_value, 0, format_raster, format_vector): raise NameError( cyan + "estimateQualityMns() : " + bold + red + "Une erreur c'est produite au cours du decoupage du raster : " + raster_input + endC) # Gémotrie de l'image pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_cut) cols, rows, bands = getGeometryImage(image_cut) xmin, xmax, ymin, ymax = getEmpriseImage(image_cut) if debug >= 3: print("Geometrie Image : ") print(" cols = " + str(cols)) print(" rows = " + str(rows)) print(" xmin = " + str(xmin)) print(" xmax = " + str(xmax)) print(" ymin = " + str(ymin)) print(" ymax = " + str(ymax)) print(" pixel_size_x = " + str(pixel_size_x)) print(" pixel_size_y = " + str(pixel_size_y)) print("\n") # Création du dico coordonnées des points en systeme cartographique points_random_value_dico = {} # liste coordonnées des points au format matrice image brute points_coordonnees_image_list = [] # Selon que l'on utilise le fichier de points d'echantillons ou que l'on recréé a partir des sommets des vecteurs lignes if (vector_sample_points_input is None) or (vector_sample_points_input == ""): # ETAPE 3 : DECOUPAGES DES VECTEURS DE REFERENCE D'ENTREE PAR LE VECTEUR D'ETUDE ET LEUR FUSION ET # LECTURE D'UN VECTEUR DE LIGNES ET SAUVEGARDE DES COORDONNEES POINTS DES EXTREMITEES ET LEUR HAUTEUR # Découpage des vecteurs de bd réference avec le vecteur zone d'étude vector_sample_input_cut_list = [] for vector_sample in vector_sample_input_list: vector_name = os.path.splitext(os.path.basename(vector_sample))[0] vector_sample_cut = repertory_output + os.sep + vector_name + SUFFIX_CUT + extension_vector vector_sample_input_cut_list.append(vector_sample_cut) cutoutVectors(vector_study, vector_sample_input_list, vector_sample_input_cut_list, format_vector) # Fusion des vecteurs de bd réference découpés fusionVectors(vector_sample_input_cut_list, vector_sample_temp, format_vector) # Preparation des colonnes names_column_start_point_list = [ ATTRIBUTE_ID, ATTRIBUTE_Z_INI, ATTRIBUTE_PREC_ALTI ] names_column_end_point_list = [ ATTRIBUTE_ID, ATTRIBUTE_Z_FIN, ATTRIBUTE_PREC_ALTI ] fields_list = [ ATTRIBUTE_ID, ATTRIBUTE_PREC_ALTI, ATTRIBUTE_Z_INI, ATTRIBUTE_Z_FIN ] multigeometries2geometries(vector_sample_temp, vector_sample_temp_clean, fields_list, "MULTILINESTRING", format_vector) points_coordinates_dico = readVectorFileLinesExtractTeminalsPoints( vector_sample_temp_clean, names_column_start_point_list, names_column_end_point_list, format_vector) else: # ETAPE 3_BIS : DECOUPAGE DE VECTEURS D'ECHANTILLONS POINTS PAR LE VECTEUR D'EMPRISE ET # LECTURE DES COORDONNES D'ECHANTILLONS DURECTEMENT DANS LE FICHIER VECTEUR POINTS # Liste coordonnées des points au format matrice image brute cutVectorAll(vector_study, vector_sample_points_input, vector_sample_temp, format_vector) points_coordinates_dico = readVectorFilePoints(vector_sample_temp, format_vector) # ETAPE 4 : PREPARATION DU VECTEUR DE POINTS for index_key in points_coordinates_dico: # Recuperer les valeurs des coordonnees coord_info_list = points_coordinates_dico[index_key] coor_x = coord_info_list[0] coor_y = coord_info_list[1] attribut_dico = coord_info_list[2] # Coordonnées des points au format matrice image pos_x = int(round((coor_x - xmin) / abs(pixel_size_x)) - 1) pos_y = int(round((ymax - coor_y) / abs(pixel_size_y)) - 1) if pos_x < 0: pos_x = 0 if pos_x >= cols: pos_x = cols - 1 if pos_y < 0: pos_y = 0 if pos_y >= rows: pos_y = rows - 1 coordonnees_list = [pos_x, pos_y] points_coordonnees_image_list.append(coordonnees_list) value_ref = 0.0 if ATTRIBUTE_Z_INI in attribut_dico.keys(): value_ref = float(attribut_dico[ATTRIBUTE_Z_INI]) if ATTRIBUTE_Z_FIN in attribut_dico.keys(): value_ref = float(attribut_dico[ATTRIBUTE_Z_FIN]) precision_alti = 0.0 if ATTRIBUTE_PREC_ALTI in attribut_dico.keys(): precision_alti = float(attribut_dico[ATTRIBUTE_PREC_ALTI]) point_attr_dico = { ATTRIBUTE_ID: index_key, ATTRIBUTE_Z_REF: value_ref, ATTRIBUTE_PREC_ALTI: precision_alti, ATTRIBUTE_Z_MNS: 0.0, ATTRIBUTE_Z_DELTA: 0.0 } for raster_input in raster_input_dico: field_name = raster_input_dico[raster_input][0][0] point_attr_dico[field_name] = 0.0 points_random_value_dico[index_key] = [[coor_x, coor_y], point_attr_dico] # ETAPE 5 : LECTURE DES DONNEES DE HAUTEURS ISSU DU MNS et autre raster # Lecture dans le fichier raster des valeurs values_height_list = getPixelsValueListImage( image_cut, points_coordonnees_image_list) values_others_dico = {} for raster_input in raster_input_dico: raster_cut = raster_cut_dico[raster_input] values_list = getPixelsValueListImage(raster_cut, points_coordonnees_image_list) values_others_dico[raster_input] = values_list for i in range(len(points_random_value_dico)): value_mns = values_height_list[i] value_ref = points_random_value_dico[i][1][ATTRIBUTE_Z_REF] points_random_value_dico[i][1][ATTRIBUTE_Z_MNS] = float(value_mns) precision_alti = points_random_value_dico[i][1][ATTRIBUTE_PREC_ALTI] points_random_value_dico[i][1][ATTRIBUTE_PREC_ALTI] = float( precision_alti) value_diff = value_ref - value_mns points_random_value_dico[i][1][ATTRIBUTE_Z_DELTA] = float(value_diff) for raster_input in raster_input_dico: field_name = raster_input_dico[raster_input][0][0] value_other = values_others_dico[raster_input][i] points_random_value_dico[i][1][field_name] = float(value_other) # ETAPE 6 : CREATION D'UN VECTEUR DE POINTS AVEC DONNEE COORDONNES POINT ET HAUTEUR REFERENCE ET MNS # Suppression des points contenant des valeurs en erreur et en dehors du filtrage points_random_value_dico_clean = {} for i in range(len(points_random_value_dico)): value_ref = points_random_value_dico[i][1][ATTRIBUTE_Z_REF] if value_ref != ERROR_VALUE and value_ref > ERROR_MIN_VALUE and value_ref < ERROR_MAX_VALUE: points_is_valid = True for raster_input in raster_input_dico: if len(raster_input_dico[raster_input]) > 1 and len( raster_input_dico[raster_input][1]) > 1: threshold_min = float( raster_input_dico[raster_input][1][0]) threshold_max = float( raster_input_dico[raster_input][1][1]) field_name = raster_input_dico[raster_input][0][0] value_raster = float( points_random_value_dico[i][1][field_name]) if value_raster < threshold_min or value_raster > threshold_max: points_is_valid = False if points_is_valid: points_random_value_dico_clean[i] = points_random_value_dico[i] # Définir les attibuts du fichier résultat attribute_dico = { ATTRIBUTE_ID: ogr.OFTInteger, ATTRIBUTE_PREC_ALTI: ogr.OFTReal, ATTRIBUTE_Z_REF: ogr.OFTReal, ATTRIBUTE_Z_MNS: ogr.OFTReal, ATTRIBUTE_Z_DELTA: ogr.OFTReal } for raster_input in raster_input_dico: field_name = raster_input_dico[raster_input][0][0] attribute_dico[field_name] = ogr.OFTReal createPointsFromCoordList(attribute_dico, points_random_value_dico_clean, vector_output_temp, epsg, format_vector) # Suppression des points en bord de zone d'étude bufferVector(vector_study, vector_study_clean, ERODE_EDGE_POINTS, "", 1.0, 10, format_vector) cutVectorAll(vector_study_clean, vector_output_temp, vector_output, True, format_vector) # ETAPE 7 : TRANSFORMATION DU FICHIER .DBF EN .CSV dbf_file = repertory_output + os.sep + base_name + EXT_DBF csv_file = repertory_output + os.sep + base_name + EXT_CSV if debug >= 2: print(cyan + "estimateQualityMns() : " + bold + green + "Conversion du fichier DBF %s en fichier CSV %s" % (dbf_file, csv_file) + endC) convertDbf2Csv(dbf_file, csv_file) # ETAPE 8 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des données intermédiaires if not save_results_intermediate: if cutting_action: if os.path.isfile(image_cut): removeFile(image_cut) else: if os.path.isfile(vector_study): removeVectorFile(vector_study) for raster_input in raster_input_dico: raster_cut = raster_cut_dico[raster_input] if os.path.isfile(raster_cut): removeFile(raster_cut) if os.path.isfile(vector_output_temp): removeVectorFile(vector_output_temp) if os.path.isfile(vector_study_clean): removeVectorFile(vector_study_clean) if os.path.isfile(vector_sample_temp): removeVectorFile(vector_sample_temp) if os.path.isfile(vector_sample_temp_clean): removeVectorFile(vector_sample_temp_clean) for vector_file in vector_sample_input_cut_list: if os.path.isfile(vector_file): removeVectorFile(vector_file) print(bold + green + "## END : CREATE HEIGHT POINTS FILE FROM MNSE" + endC) # Mise à jour du Log ending_event = "estimateQualityMns() : Masks creation ending : " timeLine(path_time_log, ending_event) return
def proposeReallocationMicroClass(shape_file_input, s_suspect_microclass1, s_suspect_microclass2, s_performance_list, missed_micro_list, suspect_micro_list, table_output_file, class_labels_list, rate_area_min, threshold_delete_perf, threshold_alert_perf, format_vector): print(cyan + "proposeReallocationMicroClass() : " + bold + green + "Start propose reallocation microclass ...\n" + endC) is_spatialite = False if debug >= 3: print(cyan + "proposeReallocationMicroClass() : " + endC + "shape_file_input : " + str(shape_file_input)) print(cyan + "proposeReallocationMicroClass() : " + endC + "s_suspect_microclass1 : " + str(s_suspect_microclass1)) print(cyan + "proposeReallocationMicroClass() : " + endC + "s_suspect_microclass2 : " + str(s_suspect_microclass2)) print(cyan + "proposeReallocationMicroClass() : " + endC + "suspect_micro_list : " + str(suspect_micro_list)) print(cyan + "proposeReallocationMicroClass() : " + endC + "s_performance_list : " + str(s_performance_list)) print(cyan + "proposeReallocationMicroClass() : " + endC + "format_vector : " + str(format_vector)) # constantes HEADER_TABLEAU_MODIF = "MICROCLASSE;TRAITEMENT\n" EXT_SQLITE = ".sqlite" # variables text_output = HEADER_TABLEAU_MODIF suspect_micro_end_list = [] if is_spatialite : # Creer une base de donnees qui contient une table des echantillons d'apprentissage repertory_output = os.path.dirname(table_output_file) table_input_name = os.path.splitext(os.path.basename(table_output_file))[0] bd_name = repertory_output + os.sep + table_input_name + EXT_SQLITE # Supprimer la base de donnees temporaire si elle existe encore try: removeFile(bd_name) except Exception: # Ignore l'exception levee si le fichier n'existe pas (et ne peut donc pas être supprime) pass createBDtableModify(shape_file_input, table_input_name, bd_name) average_area_list = computeAverageAreaMacro(repertory_output, class_labels_list, table_input_name, bd_name) else : average_area_list = [] for class_label in class_labels_list: average_area = getAverageAreaClass(shape_file_input, "ID", class_label, format_vector) average_area_list.append(average_area) if debug >= 1: print(cyan + "proposeReallocationMicroClass() : " + endC + "average_area_list : " + str(average_area_list)) # calcul la surface min autorisée area_authorized_macro_list = [] for area in average_area_list: area_authorized_macro_list.append(rate_area_min * area) if debug >= 1: print(cyan + "proposeReallocationMicroClass() : " + endC + "area_authorized_macro_list : " + str(area_authorized_macro_list)) # Recuperer les donnees de centroids micro_suspect1_list, micro_pp1_list, micro_suspect2_list, micro_pp2_list = getDataCentroids(s_suspect_microclass1, s_suspect_microclass2, class_labels_list) # Proposer les traitements correspondant a chaque microclasse suspect # 1er fois, traiter les informations obtenues par la matrice de confusion en prenant en compte l'analyse de centroids for i in range(len(s_performance_list)): if is_spatialite : area_micro = computeAreaMicro(repertory_output, table_input_name, bd_name, suspect_micro_list[i]) else : area_micro = getAreaPolygon(shape_file_input,"ID", suspect_micro_list[i],format_vector ) if debug >= 1: print("Traiter %d, surface %f" %(suspect_micro_list[i], area_micro)) if area_micro < area_authorized_macro_list[findPositionList(class_labels_list, (suspect_micro_list[i]/100)*100)]: #Regle 1 if debug >= 1: print("Regle 1 - Supprimer : %d Surf : %d" %(suspect_micro_list[i], area_micro)) text_output += "%d;-1\n" %(suspect_micro_list[i]) suspect_micro_end_list.append(suspect_micro_list[i]) else: if s_performance_list[i] < threshold_delete_perf: #Regle 2.1 if debug >= 1: print("Regle 2.1 - Supprimer : %d Seuil : %f" %(suspect_micro_list[i], s_performance_list[i])) text_output += "%d;-1\n" %(suspect_micro_list[i]) suspect_micro_end_list.append(suspect_micro_list[i]) elif s_performance_list[i] < threshold_alert_perf: pos1 = findPositionList(micro_suspect1_list, suspect_micro_list[i]) pos2 = findPositionList(micro_suspect2_list, suspect_micro_list[i]) if (pos1 == -1 or pos2 == -1) and pos1 != pos2: #Regle 2.1.2 if debug >= 1: print("Regle 2.1.2 - Supprimer : %d pos1 : %d pos2 : %d" %(suspect_micro_list[i], pos1, pos2)) text_output += "%d;-1\n" %(suspect_micro_list[i]) suspect_micro_end_list.append(suspect_micro_list[i]) if pos1 != -1 and pos2 != -1: if(micro_pp1_list[pos1]/100) == (micro_pp2_list[pos2]/100): #Regle 2.1.1 if debug >= 1: print("Regle 2.1.1 - Reaffecter : %d %d" %(suspect_micro_list[i], (micro_pp1_list[pos1]/100) * 100)) text_output += "%d;%d\n" %(suspect_micro_list[i], (micro_pp1_list[pos1]/100)*100) suspect_micro_end_list.append(suspect_micro_list[i]) else: #Regle 2.1.2 if debug >= 1: print("Regle 2.1.2 - Supprimer : %d" %(suspect_micro_list[i])) text_output += "%d;-1\n" %(suspect_micro_list[i]) suspect_micro_end_list.append(suspect_micro_list[i]) # 2eme fois, traiter encore l'analyse de centroids pour les microclasses ayant la bonne performance mais plus proche d'autre microclasse issue par une autre macroclasse for i in range(len(micro_suspect1_list)): position = findPositionList(suspect_micro_end_list, micro_suspect1_list[i]) if position == -1: pos = findPositionList(micro_suspect2_list, micro_suspect1_list[i]) if pos != -1: if (micro_pp1_list[i]/100)*100 == (micro_pp2_list[pos]/100)*100: #Regle 3.1 if debug >= 1: print("Regle 3.1 - Alert : %d" %(micro_suspect1_list[i])) text_output += "%d;A\n" %(micro_suspect1_list[i]) else: #Regle 3.2 if debug >= 1: print("Regle 3.2 - Alert : %d" %(micro_suspect1_list[i])) text_output += "%d;A\n" %(micro_suspect1_list[i]) suspect_micro_end_list.append(micro_suspect1_list[i]) else: #Regle 3.2 if debug >= 1: print("Regle 3.2 - Alert : %d" %(micro_suspect1_list[i])) text_output += "%d;A\n" %(micro_suspect1_list[i]) suspect_micro_end_list.append(micro_suspect1_list[i]) for i in range(len(micro_suspect2_list)): position = findPositionList(suspect_micro_end_list, micro_suspect2_list[i]) if position == -1: #Regle 3.2 if debug >= 1: print("Regle 3.2 - Alert : %d" %(micro_suspect2_list[i])) text_output += "%d;A\n" %(micro_suspect2_list[i]) suspect_micro_end_list.append(micro_suspect2_list[i]) # Annoncer pour les microclasses qui sont disparues (presenter en entree mais disparaitre en sortie) for missed in missed_micro_list: text_output += "%s;D\n" %(missed) if is_spatialite : # Enlever la base de donnees temporaire removeFile(bd_name) print(cyan + "proposeReallocationMicroClass() : " + bold + green + "End propose reallocation microclass \n" + endC) return text_output
def cutRasterSamples(image_input, vector_input, image_output, reference_image, epsg, no_data_value, path_time_log, superposition=False, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster=".tif", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "cutRasterSamples() : Masks creation starting : " timeLine(path_time_log, starting_event) print(endC) print(bold + green + "## START : CUTTING IMAGE" + endC) print(endC) if debug >= 2: print(bold + green + "cutRasterSamples() : Variables dans la fonction" + endC) print(cyan + "cutRasterSamples() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "cutRasterSamples() : " + endC + "vector_input : " + str(vector_input) + endC) print(cyan + "cutRasterSamples() : " + endC + "image_output : " + str(image_output) + endC) print(cyan + "cutRasterSamples() : " + endC + "reference_image : " + str(reference_image) + endC) print(cyan + "cutRasterSamples() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "cutRasterSamples() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "cutRasterSamples() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "cutRasterSamples() : " + endC + "superposition : " + str(superposition) + endC) print(cyan + "cutRasterSamples() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "cutRasterSamples() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "cutRasterSamples() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "cutRasterSamples() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "cutRasterSamples() : " + endC + "overwrite : " + str(overwrite) + endC) # ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES SAMPLE_MASK_SUFFIX = "_mask" CODAGE = "uint8" repertory_output = os.path.dirname(image_output) if superposition: # Cas où on vérifie la superposition géométrique avec l'image satellite output_mask_temp01 = repertory_output + os.sep + os.path.splitext( os.path.basename(image_input) )[0] + SAMPLE_MASK_SUFFIX + "_temp01" + extension_raster output_mask_temp02 = repertory_output + os.sep + os.path.splitext( os.path.basename(image_input) )[0] + SAMPLE_MASK_SUFFIX + "_temp02" + extension_raster else: # Cas où on ne vérifie pas la superposition géométrique avec l'image satellite output_mask_temp01 = image_output # ETAPE 1 : DECOUPAGE DU RASTEUR PAR LE VECTEUR D'EMPRISE # Fonction de découpe if not cutImageByVector(vector_input, image_input, output_mask_temp01, None, None, no_data_value, epsg, format_raster, format_vector): raise NameError( cyan + "cutRasterSamples() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + image_input + ". Voir message d'erreur." + endC) if debug >= 2: print(cyan + "cutRasterSamples() : " + bold + green + "DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" % (image_input, vector_input) + endC) # ETAPE 2 : SUPERPOSITION DU FICHIER DECOUPE AVEC LE FICHIER DE REFERENCE if superposition: # Cas où on vérifie la superposition géométrique # Commande de mise en place de la geométrie command = "otbcli_Superimpose -inr " + reference_image + " -inm " + output_mask_temp01 + " -out " + output_mask_temp02 exit_code = os.system(command) if exit_code != 0: raise NameError( cyan + "cutRasterSamples() : " + bold + red + "!!! Une erreur c'est produite au cours du superimpose de l'image : " + output_mask_temp01 + ". Voir message d'erreur." + endC) # Commande de binarisation du nouveau masque (qui n'est plus binaire si une modification geometrique a été effectuée) expression_binarisation = "\"(im1b1 < %f? 0 : 1)\"" % (0.5) command = "otbcli_BandMath -il " + output_mask_temp02 + " -out " + image_output + " " + CODAGE + " -exp " + expression_binarisation exit_code = os.system(command) if exit_code != 0: raise NameError( cyan + "cutRasterSamples() : " + bold + red + "!!! Une erreur c'est produite au cours de la binarisation de l'image : " + output_mask_temp02 + ". Voir message d'erreur." + endC) if debug >= 2: print(cyan + "cutRasterSamples() : " + bold + green + "SUPERIMPOSE ET FICHIER BINAIRE DU FICHIER %s" % (image_input) + endC) print(command) # ETAPE 3 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des données intermédiaires if not save_results_intermediate: if superposition: removeFile(output_mask_temp01) removeFile(output_mask_temp02) print(endC) print(bold + green + "## END : UTTING IMAGE" + endC) print(endC) # Mise à jour du Log ending_event = "cutRasterSamples() : Masks creation ending : " timeLine(path_time_log, ending_event) return
def classesOfWaterHeights(input_flooded_areas_vector, input_digital_elevation_model_file, output_heights_classes_file, output_heights_classes_vector, heights_classes='0,0.5,1,1.5,2', epsg=2154, no_data_value=0, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster='.tif', extension_vector='.shp', grass_gisbase=os.environ['GISBASE'], grass_gisdb='GRASS_database', grass_location='LOCATION', grass_mapset='MAPSET', path_time_log='', save_results_intermediate=False, overwrite=True): if debug >= 3: print('\n' + bold + green + "Classes de hauteurs d'eau - Variables dans la fonction :" + endC) print(cyan + " classesOfWaterHeights() : " + endC + "input_flooded_areas_vector : " + str(input_flooded_areas_vector) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "input_digital_elevation_model_file : " + str(input_digital_elevation_model_file) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "output_heights_classes_file : " + str(output_heights_classes_file) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "output_heights_classes_vector : " + str(output_heights_classes_vector) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "heights_classes : " + str(heights_classes) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "grass_gisbase : " + str(grass_gisbase) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "grass_gisdb : " + str(grass_gisdb) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "grass_location : " + str(grass_location) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "grass_mapset : " + str(grass_mapset) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "overwrite : " + str(overwrite) + endC + '\n') # Définition des constantes ENCODING_RASTER_FLOAT = 'float' ENCODING_RASTER_UINT8 = 'uint8' EXTENSION_RASTER_SAGA = '.sdat' FORMAT_VECTOR_GRASS = format_vector.replace(' ', '_') SUFFIX_TEMP = '_temp' SUFFIX_LINES = '_lines' SUFFIX_POINTS = '_points' SUFFIX_ALTI = '_altitude' SUFFIX_CUT = '_cut' SUFFIX_RAW = '_raw_heights' INDEX_FIELD = 'idx' ALTI_FIELD = 'altitude' VECTORISATION = 'GRASS' # Mise à jour du log starting_event = "classesOfWaterHeights() : Début du traitement : " timeLine(path_time_log, starting_event) print(cyan + "classesOfWaterHeights() : " + bold + green + "DEBUT DES TRAITEMENTS" + endC + '\n') # Définition des variables 'basename' flooded_areas_basename = os.path.splitext( os.path.basename(input_flooded_areas_vector))[0] digital_elevation_model_basename = os.path.splitext( os.path.basename(input_digital_elevation_model_file))[0] flooded_areas_lines_basename = flooded_areas_basename + SUFFIX_LINES flooded_areas_points_basename = flooded_areas_basename + SUFFIX_POINTS if output_heights_classes_file != "": output_heights_classes_basename = os.path.splitext( os.path.basename(output_heights_classes_file))[0] output_dirname = os.path.dirname(output_heights_classes_file) else: output_heights_classes_basename = os.path.splitext( os.path.basename(output_heights_classes_vector))[0] output_dirname = os.path.dirname(output_heights_classes_vector) # Définition des variables temp temp_directory = output_dirname + os.sep + output_heights_classes_basename + SUFFIX_TEMP flooded_areas_lines = temp_directory + os.sep + flooded_areas_lines_basename + extension_vector flooded_areas_points = temp_directory + os.sep + flooded_areas_points_basename + extension_vector altitude_points = temp_directory + os.sep + flooded_areas_points_basename + SUFFIX_ALTI + extension_vector altitude_grid = temp_directory + os.sep + flooded_areas_basename + SUFFIX_ALTI + EXTENSION_RASTER_SAGA altitude_file = temp_directory + os.sep + flooded_areas_basename + SUFFIX_ALTI + SUFFIX_CUT + extension_raster digital_elevation_model_cut = temp_directory + os.sep + digital_elevation_model_basename + SUFFIX_CUT + extension_raster raw_heights = temp_directory + os.sep + flooded_areas_basename + SUFFIX_RAW + extension_raster heights_classes_temp = temp_directory + os.sep + output_heights_classes_basename + extension_raster if output_heights_classes_file == "": output_heights_classes_file = output_dirname + os.sep + output_heights_classes_basename + extension_raster # Nettoyage des traitements précédents if debug >= 3: print(cyan + "classesOfWaterHeights() : " + endC + "Nettoyage des traitements précédents." + endC + '\n') removeFile(output_heights_classes_file) removeVectorFile(output_heights_classes_vector, format_vector=format_vector) cleanTempData(temp_directory) ############# # Etape 0/6 # Préparation des traitements ############# print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 0/6 - Début de la préparation des traitements." + endC + '\n') # Préparation de GRASS xmin, xmax, ymin, ymax = getEmpriseImage( input_digital_elevation_model_file) pixel_width, pixel_height = getPixelWidthXYImage( input_digital_elevation_model_file) grass_gisbase, grass_gisdb, grass_location, grass_mapset = initializeGrass( temp_directory, xmin, xmax, ymin, ymax, pixel_width, pixel_height, projection=epsg, gisbase=grass_gisbase, gisdb=grass_gisdb, location=grass_location, mapset=grass_mapset, clean_old=True, overwrite=overwrite) # Gestion des classes de hauteurs d'eau thresholds_list = heights_classes.split(',') thresholds_list_float = [float(x) for x in thresholds_list] thresholds_list_float.sort() thresholds_list_float_len = len(thresholds_list_float) print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 0/6 - Fin de la préparation des traitements." + endC + '\n') ############# # Etape 1/6 # Création de points sur le périmètre de l'emprise inondée ############# print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 1/6 - Début de la création de points sur le périmètre de l'emprise inondée." + endC + '\n') # Conversion de l'emprise inondée en polylignes convertePolygon2Polylines(input_flooded_areas_vector, flooded_areas_lines, overwrite=overwrite, format_vector=format_vector) # Création de points le long du polyligne use = 'vertex' dmax = 10 percent = False importVectorOgr2Grass(flooded_areas_lines, flooded_areas_lines_basename, overwrite=overwrite) pointsAlongPolylines(flooded_areas_lines_basename, flooded_areas_points_basename, use=use, dmax=dmax, percent=percent, overwrite=overwrite) exportVectorOgr2Grass(flooded_areas_points_basename, flooded_areas_points, format_vector=FORMAT_VECTOR_GRASS, overwrite=overwrite) # Ajout d'un index sur les points addNewFieldVector(flooded_areas_points, INDEX_FIELD, ogr.OFTInteger, field_value=None, field_width=None, field_precision=None, format_vector=format_vector) updateIndexVector(flooded_areas_points, index_name=INDEX_FIELD, format_vector=format_vector) print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 1/6 - Fin de la création de points sur le périmètre de l'emprise inondée." + endC + '\n') ############# # Etape 2/6 # Récupération de l'altitude sous chaque point ############# print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 2/6 - Début de la récupération de l'altitude sous chaque point." + endC + '\n') # Ajout d'un champ pour récupérer l'altitude addNewFieldVector(flooded_areas_points, ALTI_FIELD, ogr.OFTReal, field_value=None, field_width=None, field_precision=None, format_vector=format_vector) # Echantillonnage du MNT sous le fichier points importVectorOgr2Grass(flooded_areas_points, flooded_areas_points_basename, overwrite=overwrite) importRasterGdal2Grass(input_digital_elevation_model_file, digital_elevation_model_basename, overwrite=overwrite) sampleRasterUnderPoints(flooded_areas_points_basename, digital_elevation_model_basename, ALTI_FIELD, overwrite=overwrite) exportVectorOgr2Grass(flooded_areas_points_basename, altitude_points, format_vector=FORMAT_VECTOR_GRASS, overwrite=overwrite) print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 2/6 - Fin de la récupération de l'altitude sous chaque point." + endC + '\n') ############# # Etape 3/6 # Triangulation de l'altitude ############# print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 3/6 - Début de la triangulation de l'altitude." + endC + '\n') pixel_size = abs(min(pixel_width, pixel_height)) triangulationDelaunay(altitude_points, altitude_grid, ALTI_FIELD, cellsize=pixel_size) print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 3/6 - Fin de la triangulation de l'altitude." + endC + '\n') ############# # Etape 4/6 # Calcul des hauteurs brutes ############# print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 4/6 - Début du calcul des hauteurs brutes." + endC + '\n') # Redécoupage sur l'emprise inondée cutRasterImages([altitude_grid, input_digital_elevation_model_file], input_flooded_areas_vector, [altitude_file, digital_elevation_model_cut], 0, 0, epsg, no_data_value, "", False, path_time_log, format_raster=format_raster, format_vector=format_vector, extension_raster=extension_raster, extension_vector=extension_vector, save_results_intermediate=save_results_intermediate, overwrite=overwrite) # BandMath pour les hauteurs brutes (triangulation - MNT) expression = "im1b1 - im2b1" rasterCalculator([altitude_file, digital_elevation_model_cut], raw_heights, expression, codage=ENCODING_RASTER_FLOAT) print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 4/6 - Fin du calcul des hauteurs brutes." + endC + '\n') ############# # Etape 5/6 # Attribution des classes de hauteurs d'eau ############# print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 5/6 - Début de l'attribution des classes de hauteurs d'eau." + endC + '\n') # Génération de l'expression expression = "" for i in range(thresholds_list_float_len - 1): min_threshold = thresholds_list_float[i] max_threshold = thresholds_list_float[i + 1] expression += "im1b1>=%s and im1b1<%s ? %s : " % (min_threshold, max_threshold, i + 1) expression += "im1b1>=%s ? %s : 0" % (thresholds_list_float[ thresholds_list_float_len - 1], thresholds_list_float_len) # Calcul des classes de hauteurs d'eau rasterCalculator([raw_heights], heights_classes_temp, expression, codage=ENCODING_RASTER_UINT8) # Redécoupage propre des zones en dehors de l'emprise inondée cutImageByVector(input_flooded_areas_vector, heights_classes_temp, output_heights_classes_file, pixel_size_x=pixel_width, pixel_size_y=pixel_height, no_data_value=no_data_value, epsg=epsg, format_raster=format_raster, format_vector=format_vector) print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 5/6 - Fin de l'attribution des classes de hauteurs d'eau." + endC + '\n') ############# # Etape 6/6 # Vectorisation des classes de hauteurs d'eau ############# if output_heights_classes_vector != "": print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 6/6 - Début de la vectorisation des classes de hauteurs d'eau." + endC + '\n') name_column = 'class' umc_list = 0 if VECTORISATION == 'GRASS': vectorizeGrassClassification( output_heights_classes_file, output_heights_classes_vector, name_column, [umc_list], False, True, True, input_flooded_areas_vector, True, path_time_log, expression="", format_vector=format_vector, extension_raster=extension_raster, extension_vector=extension_vector, save_results_intermediate=save_results_intermediate, overwrite=overwrite) else: vectorizeClassification( output_heights_classes_file, output_heights_classes_vector, name_column, [umc_list], 2000, False, True, True, True, True, True, input_flooded_areas_vector, True, False, False, [0], path_time_log, expression="", format_vector=format_vector, extension_raster=extension_raster, extension_vector=extension_vector, save_results_intermediate=save_results_intermediate, overwrite=overwrite) print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 6/6 - Fin de la vectorisation des classes de hauteurs d'eau." + endC + '\n') else: print( cyan + "classesOfWaterHeights() : " + bold + yellow + "ETAPE 6/6 - Pas de vectorisation des classes de hauteurs d'eau demandée." + endC + '\n') # Suppression des fichiers temporaires if not save_results_intermediate: if debug >= 3: print(cyan + "classesOfWaterHeights() : " + endC + "Suppression des fichiers temporaires." + endC + '\n') deleteDir(temp_directory) print(cyan + "classesOfWaterHeights() : " + bold + green + "FIN DES TRAITEMENTS" + endC + '\n') # Mise à jour du log ending_event = "classesOfWaterHeights() : Fin du traitement : " timeLine(path_time_log, ending_event) return