def preparationVecteurs(urbanatlas_input, ucz_output, emprise_file, mask_file, enter_with_mask, image_file, mnh_file, built_files_list, hydrography_file, roads_files_list, rpg_file, indicators_method, ucz_method, dbms_choice, threshold_ndvi, threshold_ndvi_water, threshold_ndwi2, threshold_bi_bottom, threshold_bi_top, path_time_log, temp_directory, format_vector, extension_vector): print(bold + yellow + "Début de la préparation des données vecteurs." + endC) step = " Début de la préparation des données vecteurs : " timeLine(path_time_log, step) field_name = 'ID' field_type = ogr.OFTInteger emprise_erosion = temp_directory + os.sep + os.path.splitext( os.path.basename(emprise_file))[0] + "_eroded" + extension_vector print(bold + cyan + " Érosion de '%s' pour le découpage des autres vecteurs :" % (emprise_file) + endC) bufferVector( emprise_file, emprise_erosion, -10, "", 1.0, 10, format_vector ) # Création du shape zone d'étude érodée (utile pour la fonction CrossingVectorRaster où shape < raster) - Tampon par défaut : -10 # Traitements sur l'Urban Atlas print(bold + cyan + " Traitements du fichier Urban Atlas '%s' :" % (urbanatlas_input) + endC) basename_grid = os.path.splitext(os.path.basename(urbanatlas_input))[0] grid_reproject = temp_directory + os.sep + basename_grid + "_reproject" + extension_vector grid_ready = temp_directory + os.sep + basename_grid + "_cut" + extension_vector grid_ready_cleaned = temp_directory + os.sep + basename_grid + "_cut_cleaned" + extension_vector column = "'%s, CODE2012, ITEM2012'" % (field_name) expression = "CODE2012 NOT IN ('12210', '12220', '12230', '50000')" updateProjection(urbanatlas_input, grid_reproject, 2154, format_vector) # MAJ projection addNewFieldVector(grid_reproject, field_name, field_type, 0, None, None, format_vector) # Ajout d'un champ ID updateIndexVector( grid_reproject, index_name=field_name) # Mise à jour du champs ID (incrémentation) cutVector( emprise_erosion, grid_reproject, grid_ready, format_vector ) # Découpage du fichier Urban Atlas d'entrée à l'emprise de la zone d'étude ret = filterSelectDataVector( grid_ready, grid_ready_cleaned, column, expression, format_vector ) # Suppression des polygones eau et routes (uniquement pour le calcul des indicateurs) if not ret: raise NameError( cyan + "preparationVecteurs : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" % (expression) + endC) if indicators_method in ("BD_exogenes", "SI_seuillage", "SI_classif"): # Traitements sur les fichiers bâti de la BD TOPO print(bold + cyan + " Traitements des fichiers bâti '%s' :" % str(built_files_list) + endC) built_merge = temp_directory + os.sep + "bati_merged" + extension_vector built_ready = temp_directory + os.sep + "bati" + extension_vector column = "HAUTEUR" expression = "HAUTEUR > 0" built_intersect_list = [] for built_input in built_files_list: basename = os.path.splitext(os.path.basename(built_input))[0] built_reproject = temp_directory + os.sep + basename + "_reproject" + extension_vector built_intersect = temp_directory + os.sep + basename + "_intersect" + extension_vector updateProjection(built_input, built_reproject, 2154, format_vector) # MAJ projection intersectVector( emprise_file, built_reproject, built_intersect, format_vector ) # Sélection des entités bâti dans l'emprise de l'étude built_intersect_list.append(built_intersect) fusionVectors(built_intersect_list, built_merge, format_vector) # Fusion des couches bâti de la BD TOPO ret = filterSelectDataVector( built_merge, built_ready, column, expression ) # Suppression des polygones où la hauteur du bâtiment est à 0 if not ret: raise NameError( cyan + "preparationVecteurs : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" % (expression) + endC) addNewFieldVector(built_ready, field_name, field_type, 0, None, None, format_vector) # Ajout d'un champ ID updateIndexVector( built_ready, index_name=field_name) # Mise à jour du champs ID (incrémentation) if indicators_method == "BD_exogenes": # Traitements sur le fichier routes de la BD TOPO print(bold + cyan + " Traitements du fichier hydrographie '%s' :" % (hydrography_file) + endC) basename_hydrography = os.path.splitext( os.path.basename(hydrography_file))[0] hydrography_reproject = temp_directory + os.sep + basename_hydrography + "_reproject" + extension_vector hydrography_intersect = temp_directory + os.sep + basename_hydrography + "_intersect" + extension_vector hydrography_ready = temp_directory + os.sep + "eau" + extension_vector column = "REGIME" expression = "REGIME LIKE 'Permanent'" updateProjection(hydrography_file, hydrography_reproject, 2154, format_vector) # MAJ projection intersectVector( emprise_file, hydrography_reproject, hydrography_intersect, format_vector ) # Sélection des entités routes dans l'emprise de l'étude ret = filterSelectDataVector( hydrography_intersect, hydrography_ready, column, expression, format_vector ) # Sélection des entités suivant le régime hydrographique (permanent) if not ret: raise NameError( cyan + "preparationVecteurs : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" % (expression) + endC) addNewFieldVector(hydrography_ready, field_name, field_type, 0, None, None, format_vector) # Ajout d'un champ ID updateIndexVector(hydrography_ready, index_name=field_name ) # Mise à jour du champs ID (incrémentation) # Traitements sur le fichier RPG print(bold + cyan + " Traitements du fichier RPG '%s' :" % (rpg_file) + endC) basename_RPG = os.path.splitext(os.path.basename(rpg_file))[0] RPG_reproject = temp_directory + os.sep + basename_RPG + "_reproject" + extension_vector RPG_ready = temp_directory + os.sep + "RPG" + extension_vector updateProjection(rpg_file, RPG_reproject, 2154, format_vector) # MAJ projection intersectVector( emprise_file, RPG_reproject, RPG_ready, format_vector ) # Sélection des entités RPG dans l'emprise de l'étude addNewFieldVector(RPG_ready, field_name, field_type, 0, None, None, format_vector) # Ajout d'un champ ID updateIndexVector(RPG_ready, index_name=field_name ) # Mise à jour du champs ID (incrémentation) ######################################################################################################################################################################################################## ######################################################################## Partie restant à coder : normalement pas nécessaire puisque cette méthode n'a pas été retenue ################################# ######################################################################################################################################################################################################## #### if indicators_method == "SI_seuillage": #### # Traitements sur les fichiers routes de la BD TOPO #### print(bold + cyan + " Traitements des fichiers routes '%s' :" % str(roads_files_list) + endC) #### #### print( bold + "Le script ne peut continuer, le traitements des fichiers routes n'est pas encore entièrement codé" + endC) #### exit(0) #### #### #~ En entrée : fichier troncon_route + fichier surface_route #### #~ 1 - reprojection des fichiers en L93 #### #~ 2 - sélection des entités des fichiers compris dans la zone d'étude (intersect et non découpage) #### #~ 3 - filtrage des entités de troncon_route suivant la nature #### #~ ("NATURE IN ('Autoroute', 'Bretelle', 'Quasi-autoroute', 'Route 1 chausse', 'Route 2 chausses', #### #~ 'Route a 1 chaussee', 'Route a 2 chaussees', 'Route à 1 chaussée', 'Route à 2 chaussées')") #### #~ 4 - tampon sur les entités de troncon_route correspondant à 'LARGEUR'/2 #### #~ 5 - fusion des fichiers en un seul shape #### #~ 6 - ajout d'un nouveau champ ID dans le fichier de fusion #### #~ 7 - mise à jour de ce champ ID #### #### ######################################################################################################################################################################################################## ######################################################################################################################################################################################################## ######################################################################################################################################################################################################## step = " Fin de la préparation des données vecteurs : " timeLine(path_time_log, step) print(bold + yellow + "Fin de la préparation des données vecteurs." + endC) print("\n") return
def computeMajorityClass(input_grid, temp_directory, nodata_field, built_field, mineral_field, baresoil_field, water_field, vegetation_field, high_vegetation_field, low_vegetation_field, maj_ocs_field, veg_mean_field, class_label_dico_out, format_vector, extension_vector, overwrite): SUFFIX_CLASS = '_class' FIELD_TYPE = ogr.OFTInteger FIELD_NAME_MAJORITY = 'majority' temp_class_list = [] base_name = os.path.splitext(os.path.basename(input_grid))[0] temp_grid = temp_directory + os.sep + base_name + SUFFIX_CLASS + extension_vector temp_class0 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "0" + extension_vector temp_class1 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "1" + extension_vector temp_class2 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "2" + extension_vector temp_class3 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "3" + extension_vector temp_class4 = temp_directory + os.sep + base_name + SUFFIX_CLASS + "4" + extension_vector ### Récupération de la classe majoritaire if debug >= 3: print(cyan + "computeMajorityClass() : " + endC + bold + "Récupération de la classe majoritaire." + endC + '\n') addNewFieldVector(input_grid, maj_ocs_field, FIELD_TYPE, field_value=None, field_width=None, field_precision=None, format_vector=format_vector) attr_names_list = getAttributeNameList(input_grid, format_vector=format_vector) attr_names_list_str = "'" for attr_name in attr_names_list: attr_names_list_str += attr_name + ', ' attr_names_list_str = attr_names_list_str[:-2] + "'" expression = "%s = '%s' OR %s = '%s' OR %s = '%s' OR %s = '%s'" % ( FIELD_NAME_MAJORITY, nodata_field, FIELD_NAME_MAJORITY, built_field, FIELD_NAME_MAJORITY, mineral_field, FIELD_NAME_MAJORITY, water_field) ret = filterSelectDataVector(input_grid, temp_class0, attr_names_list_str, expression, overwrite=overwrite, format_vector=format_vector) updateFieldVector(temp_class0, field_name=maj_ocs_field, value=class_label_dico_out["MAJ_OTHERS_CLASS"], format_vector=format_vector) temp_class_list.append(temp_class0) expression = "%s = '%s'" % (FIELD_NAME_MAJORITY, baresoil_field) ret = filterSelectDataVector(input_grid, temp_class1, attr_names_list_str, expression, overwrite=overwrite, format_vector=format_vector) updateFieldVector(temp_class1, field_name=maj_ocs_field, value=class_label_dico_out["MAJ_BARESOIL_CLASS"], format_vector=format_vector) temp_class_list.append(temp_class1) expression = "(%s = '%s' OR %s = '%s' OR %s = '%s') AND (%s < 1)" % ( FIELD_NAME_MAJORITY, vegetation_field, FIELD_NAME_MAJORITY, low_vegetation_field, FIELD_NAME_MAJORITY, high_vegetation_field, veg_mean_field) ret = filterSelectDataVector(input_grid, temp_class2, attr_names_list_str, expression, overwrite=overwrite, format_vector=format_vector) updateFieldVector(temp_class2, field_name=maj_ocs_field, value=class_label_dico_out["MAJ_LOW_VEG_CLASS"], format_vector=format_vector) temp_class_list.append(temp_class2) expression = "(%s = '%s' OR %s = '%s' OR %s = '%s') AND (%s >= 1 AND %s < 5)" % ( FIELD_NAME_MAJORITY, vegetation_field, FIELD_NAME_MAJORITY, low_vegetation_field, FIELD_NAME_MAJORITY, high_vegetation_field, veg_mean_field, veg_mean_field) ret = filterSelectDataVector(input_grid, temp_class3, attr_names_list_str, expression, overwrite=overwrite, format_vector=format_vector) updateFieldVector(temp_class3, field_name=maj_ocs_field, value=class_label_dico_out["MAJ_MED_VEG_CLASS"], format_vector=format_vector) temp_class_list.append(temp_class3) expression = "(%s = '%s' OR %s = '%s' OR %s = '%s') AND (%s >= 5)" % ( FIELD_NAME_MAJORITY, vegetation_field, FIELD_NAME_MAJORITY, low_vegetation_field, FIELD_NAME_MAJORITY, high_vegetation_field, veg_mean_field) ret = filterSelectDataVector(input_grid, temp_class4, attr_names_list_str, expression, overwrite=overwrite, format_vector=format_vector) updateFieldVector(temp_class4, field_name=maj_ocs_field, value=class_label_dico_out["MAJ_HIGH_VEG_CLASS"], format_vector=format_vector) temp_class_list.append(temp_class4) fusionVectors(temp_class_list, temp_grid, format_vector=format_vector) removeVectorFile(input_grid, format_vector=format_vector) copyVectorFile(temp_grid, input_grid, format_vector=format_vector) return 0
def 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 vectorsPreparation(emprise_file, classif_input, grid_input, built_input_list, roads_input_list, grid_output, grid_output_cleaned, built_output, roads_output, col_code_ua, col_item_ua, epsg, path_time_log, format_vector='ESRI Shapefile', extension_vector=".shp", save_results_intermediate=False, overwrite=True): print(bold + yellow + "Début de la préparation des fichiers vecteurs." + endC + "\n") timeLine(path_time_log, "Début de la préparation des fichiers vecteurs : ") if debug >= 3 : print(bold + green + "vectorsPreparation() : Variables dans la fonction" + endC) print(cyan + "vectorsPreparation() : " + endC + "emprise_file : " + str(emprise_file) + endC) print(cyan + "vectorsPreparation() : " + endC + "classif_input : " + str(classif_input) + endC) print(cyan + "vectorsPreparation() : " + endC + "grid_input : " + str(grid_input) + endC) print(cyan + "vectorsPreparation() : " + endC + "built_input_list : " + str(built_input_list) + endC) print(cyan + "vectorsPreparation() : " + endC + "roads_input_list : " + str(roads_input_list) + endC) print(cyan + "vectorsPreparation() : " + endC + "grid_output : " + str(grid_output) + endC) print(cyan + "vectorsPreparation() : " + endC + "grid_output_cleaned : " + str(grid_output_cleaned) + endC) print(cyan + "vectorsPreparation() : " + endC + "built_output : " + str(built_output) + endC) print(cyan + "vectorsPreparation() : " + endC + "roads_output : " + str(roads_output) + endC) print(cyan + "vectorsPreparation() : " + endC + "col_code_ua : " + str(col_code_ua) + endC) print(cyan + "vectorsPreparation() : " + endC + "col_item_ua : " + str(col_item_ua) + endC) print(cyan + "vectorsPreparation() : " + endC + "epsg : " + str(epsg)) print(cyan + "vectorsPreparation() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "vectorsPreparation() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "vectorsPreparation() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "vectorsPreparation() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "vectorsPreparation() : " + endC + "overwrite : " + str(overwrite) + endC) FOLDER_TEMP = 'TEMP' SUFFIX_VECTOR_REPROJECT = '_reproject' SUFFIX_VECTOR_INTERSECT = '_intersect' SUFFIX_VECTOR_MERGE = '_merge' SUFFIX_VECTOR_SELECT = '_select' if not os.path.exists(grid_output) or not os.path.exists(built_output) or not os.path.exists(roads_output) or overwrite: ############################################ ### Préparation générale des traitements ### ############################################ path_grid_temp = os.path.dirname(grid_output) + os.sep + FOLDER_TEMP path_built_temp = os.path.dirname(built_output) + os.sep + FOLDER_TEMP path_roads_temp = os.path.dirname(roads_output) + os.sep + FOLDER_TEMP if os.path.exists(path_grid_temp): shutil.rmtree(path_grid_temp) if os.path.exists(path_built_temp): shutil.rmtree(path_built_temp) if os.path.exists(path_roads_temp): shutil.rmtree(path_roads_temp) if not os.path.exists(path_grid_temp): os.mkdir(path_grid_temp) if not os.path.exists(path_built_temp): os.mkdir(path_built_temp) if not os.path.exists(path_roads_temp): os.mkdir(path_roads_temp) basename_grid = os.path.splitext(os.path.basename(grid_output))[0] basename_built = os.path.splitext(os.path.basename(built_output))[0] basename_roads = os.path.splitext(os.path.basename(roads_output))[0] # Variables pour ajout colonne ID field_name = 'ID' # Attention ! Nom fixé en dur dans les scripts indicateurs, pas dans le script final field_type = ogr.OFTInteger ############################################## ### Traitements sur le vecteur Urban Atlas ### ############################################## if not os.path.exists(grid_output) or overwrite : if os.path.exists(grid_output): removeVectorFile(grid_output) if os.path.exists(grid_output_cleaned): removeVectorFile(grid_output_cleaned) # MAJ projection grid_reproject = path_grid_temp + os.sep + basename_grid + SUFFIX_VECTOR_REPROJECT + extension_vector updateProjection(grid_input, grid_reproject, projection=epsg) # Découpage du fichier Urban Atlas d'entrée à l'emprise de la zone d'étude grid_output_temp = os.path.splitext(grid_output)[0] + "_temp" + extension_vector cutVector(emprise_file, grid_reproject, grid_output_temp, overwrite, format_vector) # Suppression des très petits polygones qui introduisent des valeurs NaN pixel_size = getPixelSizeImage(classif_input) min_size_area = pixel_size * 2 cleanMiniAreaPolygons(grid_output_temp, grid_output, min_size_area, '', format_vector) if not save_results_intermediate: if os.path.exists(grid_output_temp): removeVectorFile(grid_output_temp, format_vector) # Ajout d'un champ ID addNewFieldVector(grid_output, field_name, field_type, 0, None, None, format_vector) updateIndexVector(grid_output, field_name, format_vector) # Suppression des polygones eau et routes (uniquement pour le calcul des indicateurs) column = "'%s, %s, %s'" % (field_name, col_code_ua, col_item_ua) expression = "%s NOT IN ('12210', '12220', '12230', '50000')" % (col_code_ua) ret = filterSelectDataVector(grid_output, grid_output_cleaned, column, expression, format_vector) if not ret : raise NameError (cyan + "vectorsPreparation : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" %(expression) + endC) ######################################### ### Traitements sur les vecteurs bâti ### ######################################### if not os.path.exists(built_output) or overwrite : if os.path.exists(built_output): removeVectorFile(built_output) # MAJ projection built_reproject_list=[] for built_input in built_input_list: built_reproject = path_built_temp + os.sep + os.path.splitext(os.path.basename(built_input))[0] + SUFFIX_VECTOR_REPROJECT + extension_vector updateProjection(built_input, built_reproject, projection=epsg) built_reproject_list.append(built_reproject) # Sélection des entités bâti dans l'emprise de l'étude built_intersect_list = [] for built_reproject in built_reproject_list: built_intersect = path_built_temp + os.sep + os.path.splitext(os.path.basename(built_reproject))[0] + SUFFIX_VECTOR_INTERSECT + extension_vector intersectVector(emprise_file, built_reproject, built_intersect, format_vector) built_intersect_list.append(built_intersect) # Fusion des couches bâti de la BD TOPO built_merge = path_built_temp + os.sep + basename_built + SUFFIX_VECTOR_MERGE + extension_vector built_select = path_built_temp + os.sep + basename_built + SUFFIX_VECTOR_SELECT + extension_vector fusionVectors(built_intersect_list, built_merge) # Suppression des polygones où la hauteur du bâtiment est à 0 column = "HAUTEUR" expression = "HAUTEUR > 0" ret = filterSelectDataVector(built_merge, built_select, column, expression, format_vector) if not ret : raise NameError (cyan + "vectorsPreparation : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" %(expression) + endC) # Découpage des bati d'entrée à l'emprise de la zone d'étude cutVector(emprise_file, built_select, built_output, overwrite, format_vector) # Ajout d'un champ ID addNewFieldVector(built_output, field_name, field_type, 0, None, None, format_vector) updateIndexVector(built_output, field_name, format_vector) ########################################### ### Traitements sur les vecteurs routes ### ########################################### if not os.path.exists(roads_output) or overwrite : if os.path.exists(roads_output): removeVectorFile(roads_output) # MAJ projection roads_reproject_list=[] for roads_input in roads_input_list: roads_reproject = path_roads_temp + os.sep + os.path.splitext(os.path.basename(roads_input))[0] + SUFFIX_VECTOR_REPROJECT + extension_vector updateProjection(roads_input, roads_reproject, projection=epsg) roads_reproject_list.append(roads_reproject) # Sélection des entités routes dans l'emprise de l'étude roads_intersect_list = [] for roads_reproject in roads_reproject_list: roads_intersect = path_roads_temp + os.sep + os.path.splitext(os.path.basename(roads_reproject))[0] + SUFFIX_VECTOR_INTERSECT + extension_vector intersectVector(emprise_file, roads_reproject, roads_intersect, format_vector) roads_intersect_list.append(roads_intersect) # Fusion des couches route de la BD TOPO roads_merge = path_roads_temp + os.sep + basename_roads + SUFFIX_VECTOR_MERGE + extension_vector roads_select = path_roads_temp + os.sep + basename_roads + SUFFIX_VECTOR_SELECT + extension_vector fusionVectors(roads_intersect_list, roads_merge) # Sélection des entités suivant la nature de la route dans la couche routes de la BD TOPO column = "NATURE" expression = "NATURE IN ('Autoroute', 'Bretelle', 'Quasi-autoroute', 'Route 1 chausse', 'Route 2 chausses', 'Route a 1 chaussee', 'Route a 2 chaussees', 'Route à 1 chaussée', 'Route à 2 chaussées')" ret = filterSelectDataVector (roads_merge, roads_select, column, expression, format_vector) if not ret : raise NameError (cyan + "vectorsPreparation : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" %(expression) + endC) # Découpage des routes d'entrée à l'emprise de la zone d'étude cutVectorAll(emprise_file, roads_select, roads_output, overwrite, format_vector) # Ajout d'un champ ID addNewFieldVector(roads_output, field_name, field_type, 0, None, None, format_vector) updateIndexVector(roads_output, field_name, format_vector) ########################################## ### Nettoyage des fichiers temporaires ### ########################################## if not save_results_intermediate: if os.path.exists(path_grid_temp): shutil.rmtree(path_grid_temp) if os.path.exists(path_built_temp): shutil.rmtree(path_built_temp) if os.path.exists(path_roads_temp): shutil.rmtree(path_roads_temp) else: print(bold + magenta + "La préparation des fichiers vecteurs a déjà eu lieu.\n" + endC) print(bold + yellow + "Fin de la préparation des fichiers vecteurs.\n" + endC) timeLine(path_time_log, "Fin de la préparation des fichiers vecteurs : ") return
def 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 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 occupationIndicator(classif_input, mnh_input, vector_grid_input, vector_grid_output, class_label_dico, epsg, path_time_log, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "occupationIndicator() : Calcul de l'indicateur occupation du sol/hauteur de végétation starting : " timeLine(path_time_log, starting_event) print( bold + green + "Début du calcul de l'indicateur 'occupation du sol/hauteur de végétation'." + endC + "\n") if debug >= 3: print(bold + green + "occupationIndicator() : Variables dans la fonction" + endC) print(cyan + "occupationIndicator() : " + endC + "classif_input : " + str(classif_input) + endC) print(cyan + "occupationIndicator() : " + endC + "mnh_input : " + str(mnh_input) + endC) print(cyan + "occupationIndicator() : " + endC + "vector_grid_input : " + str(vector_grid_input) + endC) print(cyan + "occupationIndicator() : " + endC + "vector_grid_output : " + str(vector_grid_output) + endC) print(cyan + "occupationIndicator() : " + endC + "class_label_dico : " + str(class_label_dico) + endC) print(cyan + "occupationIndicator() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "occupationIndicator() : " + endC + "path_time_log : " + str(path_time_log) + 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 + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "occupationIndicator() : " + endC + "overwrite : " + str(overwrite) + endC) # Constante FIELD_OCS_NAME = 'class_OCS' FIELD_OCS_TYPE = ogr.OFTInteger FIELD_MAJORITY_NAME = 'majority' # Test si le vecteur de sortie existe déjà et si il doit être écrasés check = os.path.isfile(vector_grid_output) if check and not overwrite: # Si le fichier de sortie existent deja et que overwrite n'est pas activé print( bold + yellow + "Le calcul de l'indicateur occupation du sol/hauteur de végétation a déjà eu lieu. \n" + endC) print(bold + yellow + "Grid vector output : " + vector_grid_output + " already exists and will not be created again." + endC) else: if check: try: removeVectorFile(vector_grid_output) except Exception: pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée ############################################ ### Préparation générale des traitements ### ############################################ # Récuperation de la projection de l'image epsg_proj = getProjectionImage(classif_input) if epsg_proj == 0: epsg_proj = epsg # Liste des classes key_class_label_list = list(class_label_dico.keys()) # Préparation des fichiers temporaires temp_path = os.path.dirname(vector_grid_output) + os.sep + "TEMP_OCS" # Nettoyage du repertoire temporaire si il existe if os.path.exists(temp_path): shutil.rmtree(temp_path) os.makedirs(temp_path) tempOCS = temp_path + os.sep + "occupation_du_sol" + extension_vector tempHveg = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation" + extension_vector temp_class0 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class0" + extension_vector temp_class1 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class1" + extension_vector temp_class2 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class2" + extension_vector temp_class3 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class3" + extension_vector temp_class4 = temp_path + os.sep + "occupation_du_sol_hauteur_de_vegetation_class4" + extension_vector vegetation_height_temp = temp_path + os.sep + "hauteur_vegetation_temp" + extension_raster vegetation_height = temp_path + os.sep + "hauteur_vegetation" + extension_raster ############################## ### Calcul de l'indicateur ### ############################## # Récupération de l'occupation du sol de chaque maille statisticsVectorRaster(classif_input, vector_grid_input, tempOCS, 1, True, True, False, [], [], class_label_dico, path_time_log, True, format_vector, save_results_intermediate, overwrite) # Récupération de la hauteur moyenne et la hauteur max de la végétation de chaque maille command = "otbcli_BandMath -il %s %s -out %s float -exp 'im1b1==%s ? im2b1 : 0'" % ( classif_input, mnh_input, vegetation_height_temp, str(key_class_label_list[4])) exit_code = os.system(command) if exit_code != 0: print(command) print( cyan + "occupationIndicator() : " + bold + red + "!!! Une erreur c'est produite au cours de la commande otbcli_BandMath : " + command + ". Voir message d'erreur." + endC, file=sys.stderr) raise command = "gdal_translate -a_srs EPSG:%s -a_nodata 0 -of %s %s %s" % ( str(epsg_proj), format_raster, vegetation_height_temp, vegetation_height) exit_code = os.system(command) if exit_code != 0: print(command) print( cyan + "occupationIndicator() : " + bold + red + "!!! Une erreur c'est produite au cours de la comande : gdal_translate : " + command + ". Voir message d'erreur." + endC, file=sys.stderr) raise statisticsVectorRaster(vegetation_height, tempOCS, tempHveg, 1, False, False, True, [], [], {}, path_time_log, True, format_vector, save_results_intermediate, overwrite) # Définir le nom des champs temp_class_list = [] list_class_str = "" for class_str in key_class_label_list: list_class_str += "%s, " % (str(class_label_dico[class_str])) built_str = class_label_dico[key_class_label_list[0]] road_str = class_label_dico[key_class_label_list[1]] water_str = class_label_dico[key_class_label_list[2]] baresoil_str = class_label_dico[key_class_label_list[3]] vegetation_str = class_label_dico[key_class_label_list[4]] vegetation_height_medium_str = "H_moy_" + vegetation_str[0:3] vegetation_height_max_str = "H_max_" + vegetation_str[0:3] if debug >= 3: print("built_str = " + built_str) print("road_str = " + road_str) print("water_str = " + water_str) print("baresoil_str = " + baresoil_str) print("vegetation_str = " + vegetation_str) print("vegetation_height_medium_str = " + vegetation_height_medium_str) print("vegetation_height_max_str = " + vegetation_height_max_str) column = "'ID, majority, minority, %s%s, %s, %s'" % ( list_class_str, vegetation_height_max_str, vegetation_height_medium_str, FIELD_OCS_NAME) # Ajout d'un champ renvoyant la classe d'OCS attribué à chaque polygone et renomer le champ 'mean' renameFieldsVector(tempHveg, ['max'], [vegetation_height_max_str], format_vector) renameFieldsVector(tempHveg, ['mean'], [vegetation_height_medium_str], format_vector) addNewFieldVector(tempHveg, FIELD_OCS_NAME, FIELD_OCS_TYPE, 0, None, None, format_vector) # Attribution de la classe 0 => classe majoritaire de bâti ou route ou eau #expression = "(" + built_str + " >= " + baresoil_str + " AND " + built_str + " >= " + vegetation_str + ") OR (" + road_str + " >= " + baresoil_str + " AND " + road_str + " >= " + vegetation_str + ") OR (" + water_str + " >= " + baresoil_str + " AND " + water_str + " >= " + vegetation_str + ")" expression = "(" + FIELD_MAJORITY_NAME + " = '" + built_str + "') OR (" + FIELD_MAJORITY_NAME + " = '" + road_str + "') OR (" + FIELD_MAJORITY_NAME + " = '" + water_str + "')" if debug >= 3: print(expression) ret = filterSelectDataVector(tempHveg, temp_class0, column, expression, format_vector) if not ret: raise NameError( cyan + "occupationIndicator() : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" % (expression) + endC) updateFieldVector(temp_class0, FIELD_OCS_NAME, 0, format_vector) temp_class_list.append(temp_class0) # Attribution de la classe 1 => classe majoritaire de sol nu #expression = "(" + baresoil_str + " > " + built_str + " AND " + baresoil_str + " > " + road_str + " AND " + baresoil_str + " > " + water_str + " AND " + baresoil_str + " >= " + vegetation_str + ")" expression = "(" + FIELD_MAJORITY_NAME + " = '" + baresoil_str + "')" if debug >= 3: print(expression) ret = filterSelectDataVector(tempHveg, temp_class1, column, expression, format_vector) if not ret: raise NameError( cyan + "occupationIndicator() : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" % (expression) + endC) updateFieldVector(temp_class1, FIELD_OCS_NAME, 1, format_vector) temp_class_list.append(temp_class1) # Attribution de la classe 2 => classe majoritaire de végétation avec Hauteur inferieur à 1 #expression = "(" + vegetation_str + " > " + built_str + " AND " + vegetation_str + " > " + road_str + " AND " + vegetation_str + " > " + water_str + " AND " + vegetation_str + " > " + baresoil_str + ") AND (" + vegetation_height_medium_str + " < 1)" expression = "(" + FIELD_MAJORITY_NAME + " = '" + vegetation_str + "') AND (" + vegetation_height_medium_str + " < 1)" if debug >= 3: print(expression) ret = filterSelectDataVector(tempHveg, temp_class2, column, expression, format_vector) if not ret: raise NameError( cyan + "occupationIndicator() : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" % (expression) + endC) updateFieldVector(temp_class2, FIELD_OCS_NAME, 2, format_vector) temp_class_list.append(temp_class2) # Attribution de la classe 3 => classe majoritaire de végétation avec Hauteur entre 1 et 5 #expression = "(" + vegetation_str + " > " + built_str + " AND " + vegetation_str + " > " + road_str + " AND " + vegetation_str + " > " + water_str + " AND " + vegetation_str + " > " + baresoil_str + ") AND (" + vegetation_height_medium_str + " >= 1 AND " + vegetation_height_medium_str + " < 5)" expression = "(" + FIELD_MAJORITY_NAME + " = '" + vegetation_str + "') AND (" + vegetation_height_medium_str + " >= 1 AND " + vegetation_height_medium_str + " < 5)" if debug >= 3: print(expression) ret = filterSelectDataVector(tempHveg, temp_class3, column, expression, format_vector) if not ret: raise NameError( cyan + "occupationIndicator() : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" % (expression) + endC) updateFieldVector(temp_class3, FIELD_OCS_NAME, 3, format_vector) temp_class_list.append(temp_class3) # Attribution de la classe 4 => classe majoritaire de végétation avec Hauteur > 5 #expression = "(" + vegetation_str + " > " + built_str + " AND " + vegetation_str + " > " + road_str + " AND " + vegetation_str + " > " + water_str + " AND " + vegetation_str + " > " + baresoil_str + ") AND (" + vegetation_height_medium_str + " >= 5)" expression = "(" + FIELD_MAJORITY_NAME + " = '" + vegetation_str + "') AND (" + vegetation_height_medium_str + " >= 5)" if debug >= 3: print(expression) ret = filterSelectDataVector(tempHveg, temp_class4, column, expression, format_vector) if not ret: raise NameError( cyan + "occupationIndicator() : " + bold + red + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" % (expression) + endC) updateFieldVector(temp_class4, FIELD_OCS_NAME, 4, format_vector) temp_class_list.append(temp_class4) fusionVectors(temp_class_list, vector_grid_output, format_vector) ########################################## ### Nettoyage des fichiers temporaires ### ########################################## if not save_results_intermediate: if os.path.exists(temp_path): shutil.rmtree(temp_path) # Mise à jour du Log print( bold + green + "Fin du calcul de l'indicateur 'occupation du sol/hauteur de végétation'." + endC + "\n") ending_event = "occupationIndicator() : Calcul de l'indicateur occupation du sol/hauteur de végétation ending : " timeLine(path_time_log, ending_event) return
def createMacroSamples(image_input, vector_to_cut_input, vector_sample_output, raster_sample_output, bd_vector_input_list, bd_buff_list, sql_expression_list, path_time_log, macro_sample_name="", simplify_vector_param=10.0, format_vector='ESRI Shapefile', extension_vector=".shp", save_results_intermediate=False, overwrite=True) : # Mise à jour du Log starting_event = "createMacroSamples() : create macro samples starting : " timeLine(path_time_log,starting_event) if debug >= 3: print(bold + green + "createMacroSamples() : Variables dans la fonction" + endC) print(cyan + "createMacroSamples() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "createMacroSamples() : " + endC + "vector_to_cut_input : " + str(vector_to_cut_input) + endC) print(cyan + "createMacroSamples() : " + endC + "vector_sample_output : " + str(vector_sample_output) + endC) print(cyan + "createMacroSamples() : " + endC + "raster_sample_output : " + str(raster_sample_output) + endC) print(cyan + "createMacroSamples() : " + endC + "bd_vector_input_list : " + str(bd_vector_input_list) + endC) print(cyan + "createMacroSamples() : " + endC + "bd_buff_list : " + str(bd_buff_list) + endC) print(cyan + "createMacroSamples() : " + endC + "sql_expression_list : " + str(sql_expression_list) + endC) print(cyan + "createMacroSamples() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "createMacroSamples() : " + endC + "macro_sample_name : " + str(macro_sample_name) + endC) print(cyan + "createMacroSamples() : " + endC + "simplify_vector_param : " + str(simplify_vector_param) + endC) print(cyan + "createMacroSamples() : " + endC + "format_vector : " + str(format_vector)) print(cyan + "createMacroSamples() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "createMacroSamples() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "createMacroSamples() : " + endC + "overwrite : " + str(overwrite) + endC) # Constantes FOLDER_MASK_TEMP = "Mask_" FOLDER_CUTTING_TEMP = "Cut_" FOLDER_FILTERING_TEMP = "Filter_" FOLDER_BUFF_TEMP = "Buff_" SUFFIX_MASK_CRUDE = "_crude" SUFFIX_MASK = "_mask" SUFFIX_VECTOR_CUT = "_cut" SUFFIX_VECTOR_FILTER = "_filt" SUFFIX_VECTOR_BUFF = "_buff" CODAGE = "uint8" # ETAPE 1 : NETTOYER LES DONNEES EXISTANTES print(cyan + "createMacroSamples() : " + bold + green + "Nettoyage de l'espace de travail..." + endC) # Nom du repertoire de calcul repertory_macrosamples_output = os.path.dirname(vector_sample_output) # Test si le vecteur echantillon existe déjà et si il doit être écrasés check = os.path.isfile(vector_sample_output) or os.path.isfile(raster_sample_output) if check and not overwrite: # Si les fichiers echantillons existent deja et que overwrite n'est pas activé print(bold + yellow + "File sample : " + vector_sample_output + " already exists and will not be created again." + endC) else : if check: try: removeVectorFile(vector_sample_output) removeFile(raster_sample_output) except Exception: pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée # Définition des répertoires temporaires repertory_mask_temp = repertory_macrosamples_output + os.sep + FOLDER_MASK_TEMP + macro_sample_name repertory_samples_cutting_temp = repertory_macrosamples_output + os.sep + FOLDER_CUTTING_TEMP + macro_sample_name repertory_samples_filtering_temp = repertory_macrosamples_output + os.sep + FOLDER_FILTERING_TEMP + macro_sample_name repertory_samples_buff_temp = repertory_macrosamples_output + os.sep + FOLDER_BUFF_TEMP + macro_sample_name if debug >= 4: print(cyan + "createMacroSamples() : " + endC + "Création du répertoire : " + str(repertory_mask_temp)) print(cyan + "createMacroSamples() : " + endC + "Création du répertoire : " + str(repertory_samples_cutting_temp)) print(cyan + "createMacroSamples() : " + endC + "Création du répertoire : " + str(repertory_samples_buff_temp)) # Création des répertoires temporaire qui n'existent pas if not os.path.isdir(repertory_macrosamples_output): os.makedirs(repertory_macrosamples_output) if not os.path.isdir(repertory_mask_temp): os.makedirs(repertory_mask_temp) if not os.path.isdir(repertory_samples_cutting_temp): os.makedirs(repertory_samples_cutting_temp) if not os.path.isdir(repertory_samples_filtering_temp): os.makedirs(repertory_samples_filtering_temp) if not os.path.isdir(repertory_samples_buff_temp): os.makedirs(repertory_samples_buff_temp) # Nettoyage des répertoires temporaire qui ne sont pas vide cleanTempData(repertory_mask_temp) cleanTempData(repertory_samples_cutting_temp) cleanTempData(repertory_samples_filtering_temp) cleanTempData(repertory_samples_buff_temp) print(cyan + "createMacroSamples() : " + bold + green + "... fin du nettoyage" + endC) # ETAPE 2 : DECOUPAGE DES VECTEURS print(cyan + "createMacroSamples() : " + bold + green + "Decoupage des echantillons ..." + endC) if vector_to_cut_input == None : # 2.1 : Création du masque délimitant l'emprise de la zone par image image_name = os.path.splitext(os.path.basename(image_input))[0] vector_mask = repertory_mask_temp + os.sep + image_name + SUFFIX_MASK_CRUDE + extension_vector createVectorMask(image_input, vector_mask) # 2.2 : Simplification du masque vector_simple_mask = repertory_mask_temp + os.sep + image_name + SUFFIX_MASK + extension_vector simplifyVector(vector_mask, vector_simple_mask, simplify_vector_param, format_vector) else : vector_simple_mask = vector_to_cut_input # 2.3 : Découpage des vecteurs de bd exogenes avec le masque vectors_cut_list = [] for vector_input in bd_vector_input_list : vector_name = os.path.splitext(os.path.basename(vector_input))[0] vector_cut = repertory_samples_cutting_temp + os.sep + vector_name + SUFFIX_VECTOR_CUT + extension_vector vectors_cut_list.append(vector_cut) cutoutVectors(vector_simple_mask, bd_vector_input_list, vectors_cut_list, format_vector) print(cyan + "createMacroSamples() : " + bold + green + "... fin du decoupage" + endC) # ETAPE 3 : FILTRAGE DES VECTEURS print(cyan + "createMacroSamples() : " + bold + green + "Filtrage des echantillons ..." + endC) vectors_filtered_list = [] if sql_expression_list != [] : for idx_vector in range (len(bd_vector_input_list)): vector_name = os.path.splitext(os.path.basename(bd_vector_input_list[idx_vector]))[0] vector_cut = vectors_cut_list[idx_vector] if idx_vector < len(sql_expression_list) : sql_expression = sql_expression_list[idx_vector] else : sql_expression = "" vector_filtered = repertory_samples_filtering_temp + os.sep + vector_name + SUFFIX_VECTOR_FILTER + extension_vector vectors_filtered_list.append(vector_filtered) # Filtrage par ogr2ogr if sql_expression != "": names_attribut_list = getAttributeNameList(vector_cut, format_vector) column = "'" for name_attribut in names_attribut_list : column += name_attribut + ", " column = column[0:len(column)-2] column += "'" ret = filterSelectDataVector(vector_cut, vector_filtered, column, sql_expression, format_vector) if not ret : print(cyan + "createMacroSamples() : " + bold + yellow + "Attention problème lors du filtrage des BD vecteurs l'expression SQL %s est incorrecte" %(sql_expression) + endC) copyVectorFile(vector_cut, vector_filtered) else : print(cyan + "createMacroSamples() : " + bold + yellow + "Pas de filtrage sur le fichier du nom : " + endC + vector_filtered) copyVectorFile(vector_cut, vector_filtered) else : print(cyan + "createMacroSamples() : " + bold + yellow + "Pas de filtrage demandé" + endC) for idx_vector in range (len(bd_vector_input_list)): vector_cut = vectors_cut_list[idx_vector] vectors_filtered_list.append(vector_cut) print(cyan + "createMacroSamples() : " + bold + green + "... fin du filtrage" + endC) # ETAPE 4 : BUFFERISATION DES VECTEURS print(cyan + "createMacroSamples() : " + bold + green + "Mise en place des tampons..." + endC) vectors_buffered_list = [] if bd_buff_list != [] : # Parcours des vecteurs d'entrée for idx_vector in range (len(bd_vector_input_list)): vector_name = os.path.splitext(os.path.basename(bd_vector_input_list[idx_vector]))[0] buff = bd_buff_list[idx_vector] vector_filtered = vectors_filtered_list[idx_vector] vector_buffered = repertory_samples_buff_temp + os.sep + vector_name + SUFFIX_VECTOR_BUFF + extension_vector if buff != 0: if os.path.isfile(vector_filtered): if debug >= 3: print(cyan + "createMacroSamples() : " + endC + "vector_filtered : " + str(vector_filtered) + endC) print(cyan + "createMacroSamples() : " + endC + "vector_buffered : " + str(vector_buffered) + endC) print(cyan + "createMacroSamples() : " + endC + "buff : " + str(buff) + endC) bufferVector(vector_filtered, vector_buffered, buff, "", 1.0, 10, format_vector) else : print(cyan + "createMacroSamples() : " + bold + yellow + "Pas de fichier du nom : " + endC + vector_filtered) else : print(cyan + "createMacroSamples() : " + bold + yellow + "Pas de tampon sur le fichier du nom : " + endC + vector_filtered) copyVectorFile(vector_filtered, vector_buffered) vectors_buffered_list.append(vector_buffered) else : print(cyan + "createMacroSamples() : " + bold + yellow + "Pas de tampon demandé" + endC) for idx_vector in range (len(bd_vector_input_list)): vector_filtered = vectors_filtered_list[idx_vector] vectors_buffered_list.append(vector_filtered) print(cyan + "createMacroSamples() : " + bold + green + "... fin de la mise en place des tampons" + endC) # ETAPE 5 : FUSION DES SHAPES print(cyan + "createMacroSamples() : " + bold + green + "Fusion par macroclasse ..." + endC) # si une liste de fichier shape à fusionner existe if not vectors_buffered_list: print(cyan + "createMacroSamples() : " + bold + yellow + "Pas de fusion sans donnee à fusionner" + endC) # s'il n'y a qu'un fichier shape en entrée elif len(vectors_buffered_list) == 1: print(cyan + "createMacroSamples() : " + bold + yellow + "Pas de fusion pour une seule donnee à fusionner" + endC) copyVectorFile(vectors_buffered_list[0], vector_sample_output) else : # Fusion des fichiers shape vectors_buffered_controled_list = [] for vector_buffered in vectors_buffered_list : if os.path.isfile(vector_buffered) and (getGeometryType(vector_buffered, format_vector) in ('POLYGON', 'MULTIPOLYGON')) and (getNumberFeature(vector_buffered, format_vector) > 0): vectors_buffered_controled_list.append(vector_buffered) else : print(cyan + "createMacroSamples() : " + bold + red + "Attention fichier bufferisé est vide il ne sera pas fusionné : " + endC + vector_buffered, file=sys.stderr) fusionVectors(vectors_buffered_controled_list, vector_sample_output, format_vector) print(cyan + "createMacroSamples() : " + bold + green + "... fin de la fusion" + endC) # ETAPE 6 : CREATION DU FICHIER RASTER RESULTAT SI DEMANDE # Creation d'un masque binaire if raster_sample_output != "" and image_input != "" : repertory_output = os.path.dirname(raster_sample_output) if not os.path.isdir(repertory_output): os.makedirs(repertory_output) rasterizeBinaryVector(vector_sample_output, image_input, raster_sample_output, 1, CODAGE) # ETAPE 7 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des données intermédiaires if not save_results_intermediate: # Supression du fichier de decoupe si celui ci a été créer if vector_simple_mask != vector_to_cut_input : if os.path.isfile(vector_simple_mask) : removeVectorFile(vector_simple_mask) # Suppression des repertoires temporaires deleteDir(repertory_mask_temp) deleteDir(repertory_samples_cutting_temp) deleteDir(repertory_samples_filtering_temp) deleteDir(repertory_samples_buff_temp) # Mise à jour du Log ending_event = "createMacroSamples() : create macro samples ending : " timeLine(path_time_log,ending_event) return