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 estimateQualityMns(image_input, vector_cut_input, vector_sample_input_list, vector_sample_points_input, raster_input_dico, vector_output, no_data_value, path_time_log, format_raster='GTiff', epsg=2154, format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "estimateQualityMns() : Masks creation starting : " timeLine(path_time_log, starting_event) print(endC) print(bold + green + "## START : CREATE HEIGHT POINTS FILE FROM MNS" + endC) print(endC) if debug >= 2: print(bold + green + "estimateQualityMns() : Variables dans la fonction" + endC) print(cyan + "estimateQualityMns() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "estimateQualityMns() : " + endC + "vector_cut_input : " + str(vector_cut_input) + endC) print(cyan + "estimateQualityMns() : " + endC + "vector_sample_input_list : " + str(vector_sample_input_list) + endC) print(cyan + "estimateQualityMns() : " + endC + "vector_sample_points_input : " + str(vector_sample_points_input) + endC) print(cyan + "estimateQualityMns() : " + endC + "raster_input_dico : " + str(raster_input_dico) + endC) print(cyan + "estimateQualityMns() : " + endC + "vector_output : " + str(vector_output) + endC) print(cyan + "estimateQualityMns() : " + endC + "no_data_value : " + str(no_data_value)) print(cyan + "estimateQualityMns() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "estimateQualityMns() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "estimateQualityMns() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "estimateQualityMns() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "estimateQualityMns() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "estimateQualityMns() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "estimateQualityMns() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "estimateQualityMns() : " + endC + "overwrite : " + str(overwrite) + endC) # Définion des constantes EXT_DBF = '.dbf' EXT_CSV = '.csv' CODAGE = "uint16" SUFFIX_STUDY = '_study' SUFFIX_CUT = '_cut' SUFFIX_TEMP = '_temp' SUFFIX_CLEAN = '_clean' SUFFIX_SAMPLE = '_sample' ATTRIBUTE_ID = "ID" ATTRIBUTE_Z_INI = "Z_INI" ATTRIBUTE_Z_FIN = "Z_FIN" ATTRIBUTE_PREC_ALTI = "PREC_ALTI" ATTRIBUTE_Z_REF = "Z_Ref" ATTRIBUTE_Z_MNS = "Z_Mns" ATTRIBUTE_Z_DELTA = "Z_Delta" ERODE_EDGE_POINTS = -1.0 ERROR_VALUE = -99.0 ERROR_MIN_VALUE = -9999 ERROR_MAX_VALUE = 9999 # ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES # Si le fichier de sortie existe on ecrase check = os.path.isfile(vector_output) if check and not overwrite: # Si un fichier de sortie avec le même nom existe déjà, et si l'option ecrasement est à false, alors FIN print(cyan + "estimateQualityMns() : " + bold + yellow + "Create file %s already exist : no actualisation" % (vector_output) + endC) return if os.path.isfile(os.path.splitext(vector_output)[0] + EXT_CSV): removeFile(os.path.splitext(vector_output)[0] + EXT_CSV) repertory_output = os.path.dirname(vector_output) base_name = os.path.splitext(os.path.basename(vector_output))[0] vector_output_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector raster_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_raster vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector vector_study_clean = repertory_output + os.sep + base_name + SUFFIX_STUDY + SUFFIX_CLEAN + extension_vector image_cut = repertory_output + os.sep + base_name + SUFFIX_CUT + extension_raster vector_sample_temp = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + extension_vector vector_sample_temp_clean = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + SUFFIX_CLEAN + extension_vector # Utilisation des données raster externes raster_cut_dico = {} for raster_input in raster_input_dico: base_name_raster = os.path.splitext(os.path.basename(raster_input))[0] raster_cut = repertory_output + os.sep + base_name_raster + SUFFIX_CUT + extension_raster raster_cut_dico[raster_input] = raster_cut if os.path.exists(raster_cut): removeFile(raster_cut) # ETAPE 1 : DEFINIR UN SHAPE ZONE D'ETUDE if (not vector_cut_input is None) and (vector_cut_input != "") and ( os.path.isfile(vector_cut_input)): cutting_action = True vector_study = vector_cut_input else: cutting_action = False createVectorMask(image_input, vector_study) # ETAPE 2 : DECOUPAGE DU RASTEUR PAR LE VECTEUR D'ETUDE SI BESOIN ET REECHANTILLONAGE SI BESOIN if cutting_action: # Identification de la tailles de pixels en x et en y du fichier MNS de reference pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input) # Si le fichier de sortie existe deja le supprimer if os.path.exists(image_cut): removeFile(image_cut) # Commande de découpe if not cutImageByVector(vector_study, image_input, image_cut, pixel_size_x, pixel_size_y, no_data_value, 0, format_raster, format_vector): print( cyan + "estimateQualityMns() : " + bold + red + "Une erreur c'est produite au cours du decoupage de l'image : " + image_input + endC, file=sys.stderr) raise if debug >= 2: print(cyan + "estimateQualityMns() : " + bold + green + "DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" % (image_input, vector_study) + endC) else: image_cut = image_input # Definir l'emprise du fichier MNS de reference # Decoupage de chaque raster de la liste des rasters for raster_input in raster_input_dico: raster_cut = raster_cut_dico[raster_input] if not cutImageByVector(vector_study, raster_input, raster_cut, pixel_size_x, pixel_size_y, no_data_value, 0, format_raster, format_vector): raise NameError( cyan + "estimateQualityMns() : " + bold + red + "Une erreur c'est produite au cours du decoupage du raster : " + raster_input + endC) # Gémotrie de l'image pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_cut) cols, rows, bands = getGeometryImage(image_cut) xmin, xmax, ymin, ymax = getEmpriseImage(image_cut) if debug >= 3: print("Geometrie Image : ") print(" cols = " + str(cols)) print(" rows = " + str(rows)) print(" xmin = " + str(xmin)) print(" xmax = " + str(xmax)) print(" ymin = " + str(ymin)) print(" ymax = " + str(ymax)) print(" pixel_size_x = " + str(pixel_size_x)) print(" pixel_size_y = " + str(pixel_size_y)) print("\n") # Création du dico coordonnées des points en systeme cartographique points_random_value_dico = {} # liste coordonnées des points au format matrice image brute points_coordonnees_image_list = [] # Selon que l'on utilise le fichier de points d'echantillons ou que l'on recréé a partir des sommets des vecteurs lignes if (vector_sample_points_input is None) or (vector_sample_points_input == ""): # ETAPE 3 : DECOUPAGES DES VECTEURS DE REFERENCE D'ENTREE PAR LE VECTEUR D'ETUDE ET LEUR FUSION ET # LECTURE D'UN VECTEUR DE LIGNES ET SAUVEGARDE DES COORDONNEES POINTS DES EXTREMITEES ET LEUR HAUTEUR # Découpage des vecteurs de bd réference avec le vecteur zone d'étude vector_sample_input_cut_list = [] for vector_sample in vector_sample_input_list: vector_name = os.path.splitext(os.path.basename(vector_sample))[0] vector_sample_cut = repertory_output + os.sep + vector_name + SUFFIX_CUT + extension_vector vector_sample_input_cut_list.append(vector_sample_cut) cutoutVectors(vector_study, vector_sample_input_list, vector_sample_input_cut_list, format_vector) # Fusion des vecteurs de bd réference découpés fusionVectors(vector_sample_input_cut_list, vector_sample_temp, format_vector) # Preparation des colonnes names_column_start_point_list = [ ATTRIBUTE_ID, ATTRIBUTE_Z_INI, ATTRIBUTE_PREC_ALTI ] names_column_end_point_list = [ ATTRIBUTE_ID, ATTRIBUTE_Z_FIN, ATTRIBUTE_PREC_ALTI ] fields_list = [ ATTRIBUTE_ID, ATTRIBUTE_PREC_ALTI, ATTRIBUTE_Z_INI, ATTRIBUTE_Z_FIN ] multigeometries2geometries(vector_sample_temp, vector_sample_temp_clean, fields_list, "MULTILINESTRING", format_vector) points_coordinates_dico = readVectorFileLinesExtractTeminalsPoints( vector_sample_temp_clean, names_column_start_point_list, names_column_end_point_list, format_vector) else: # ETAPE 3_BIS : DECOUPAGE DE VECTEURS D'ECHANTILLONS POINTS PAR LE VECTEUR D'EMPRISE ET # LECTURE DES COORDONNES D'ECHANTILLONS DURECTEMENT DANS LE FICHIER VECTEUR POINTS # Liste coordonnées des points au format matrice image brute cutVectorAll(vector_study, vector_sample_points_input, vector_sample_temp, format_vector) points_coordinates_dico = readVectorFilePoints(vector_sample_temp, format_vector) # ETAPE 4 : PREPARATION DU VECTEUR DE POINTS for index_key in points_coordinates_dico: # Recuperer les valeurs des coordonnees coord_info_list = points_coordinates_dico[index_key] coor_x = coord_info_list[0] coor_y = coord_info_list[1] attribut_dico = coord_info_list[2] # Coordonnées des points au format matrice image pos_x = int(round((coor_x - xmin) / abs(pixel_size_x)) - 1) pos_y = int(round((ymax - coor_y) / abs(pixel_size_y)) - 1) if pos_x < 0: pos_x = 0 if pos_x >= cols: pos_x = cols - 1 if pos_y < 0: pos_y = 0 if pos_y >= rows: pos_y = rows - 1 coordonnees_list = [pos_x, pos_y] points_coordonnees_image_list.append(coordonnees_list) value_ref = 0.0 if ATTRIBUTE_Z_INI in attribut_dico.keys(): value_ref = float(attribut_dico[ATTRIBUTE_Z_INI]) if ATTRIBUTE_Z_FIN in attribut_dico.keys(): value_ref = float(attribut_dico[ATTRIBUTE_Z_FIN]) precision_alti = 0.0 if ATTRIBUTE_PREC_ALTI in attribut_dico.keys(): precision_alti = float(attribut_dico[ATTRIBUTE_PREC_ALTI]) point_attr_dico = { ATTRIBUTE_ID: index_key, ATTRIBUTE_Z_REF: value_ref, ATTRIBUTE_PREC_ALTI: precision_alti, ATTRIBUTE_Z_MNS: 0.0, ATTRIBUTE_Z_DELTA: 0.0 } for raster_input in raster_input_dico: field_name = raster_input_dico[raster_input][0][0] point_attr_dico[field_name] = 0.0 points_random_value_dico[index_key] = [[coor_x, coor_y], point_attr_dico] # ETAPE 5 : LECTURE DES DONNEES DE HAUTEURS ISSU DU MNS et autre raster # Lecture dans le fichier raster des valeurs values_height_list = getPixelsValueListImage( image_cut, points_coordonnees_image_list) values_others_dico = {} for raster_input in raster_input_dico: raster_cut = raster_cut_dico[raster_input] values_list = getPixelsValueListImage(raster_cut, points_coordonnees_image_list) values_others_dico[raster_input] = values_list for i in range(len(points_random_value_dico)): value_mns = values_height_list[i] value_ref = points_random_value_dico[i][1][ATTRIBUTE_Z_REF] points_random_value_dico[i][1][ATTRIBUTE_Z_MNS] = float(value_mns) precision_alti = points_random_value_dico[i][1][ATTRIBUTE_PREC_ALTI] points_random_value_dico[i][1][ATTRIBUTE_PREC_ALTI] = float( precision_alti) value_diff = value_ref - value_mns points_random_value_dico[i][1][ATTRIBUTE_Z_DELTA] = float(value_diff) for raster_input in raster_input_dico: field_name = raster_input_dico[raster_input][0][0] value_other = values_others_dico[raster_input][i] points_random_value_dico[i][1][field_name] = float(value_other) # ETAPE 6 : CREATION D'UN VECTEUR DE POINTS AVEC DONNEE COORDONNES POINT ET HAUTEUR REFERENCE ET MNS # Suppression des points contenant des valeurs en erreur et en dehors du filtrage points_random_value_dico_clean = {} for i in range(len(points_random_value_dico)): value_ref = points_random_value_dico[i][1][ATTRIBUTE_Z_REF] if value_ref != ERROR_VALUE and value_ref > ERROR_MIN_VALUE and value_ref < ERROR_MAX_VALUE: points_is_valid = True for raster_input in raster_input_dico: if len(raster_input_dico[raster_input]) > 1 and len( raster_input_dico[raster_input][1]) > 1: threshold_min = float( raster_input_dico[raster_input][1][0]) threshold_max = float( raster_input_dico[raster_input][1][1]) field_name = raster_input_dico[raster_input][0][0] value_raster = float( points_random_value_dico[i][1][field_name]) if value_raster < threshold_min or value_raster > threshold_max: points_is_valid = False if points_is_valid: points_random_value_dico_clean[i] = points_random_value_dico[i] # Définir les attibuts du fichier résultat attribute_dico = { ATTRIBUTE_ID: ogr.OFTInteger, ATTRIBUTE_PREC_ALTI: ogr.OFTReal, ATTRIBUTE_Z_REF: ogr.OFTReal, ATTRIBUTE_Z_MNS: ogr.OFTReal, ATTRIBUTE_Z_DELTA: ogr.OFTReal } for raster_input in raster_input_dico: field_name = raster_input_dico[raster_input][0][0] attribute_dico[field_name] = ogr.OFTReal createPointsFromCoordList(attribute_dico, points_random_value_dico_clean, vector_output_temp, epsg, format_vector) # Suppression des points en bord de zone d'étude bufferVector(vector_study, vector_study_clean, ERODE_EDGE_POINTS, "", 1.0, 10, format_vector) cutVectorAll(vector_study_clean, vector_output_temp, vector_output, True, format_vector) # ETAPE 7 : TRANSFORMATION DU FICHIER .DBF EN .CSV dbf_file = repertory_output + os.sep + base_name + EXT_DBF csv_file = repertory_output + os.sep + base_name + EXT_CSV if debug >= 2: print(cyan + "estimateQualityMns() : " + bold + green + "Conversion du fichier DBF %s en fichier CSV %s" % (dbf_file, csv_file) + endC) convertDbf2Csv(dbf_file, csv_file) # ETAPE 8 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des données intermédiaires if not save_results_intermediate: if cutting_action: if os.path.isfile(image_cut): removeFile(image_cut) else: if os.path.isfile(vector_study): removeVectorFile(vector_study) for raster_input in raster_input_dico: raster_cut = raster_cut_dico[raster_input] if os.path.isfile(raster_cut): removeFile(raster_cut) if os.path.isfile(vector_output_temp): removeVectorFile(vector_output_temp) if os.path.isfile(vector_study_clean): removeVectorFile(vector_study_clean) if os.path.isfile(vector_sample_temp): removeVectorFile(vector_sample_temp) if os.path.isfile(vector_sample_temp_clean): removeVectorFile(vector_sample_temp_clean) for vector_file in vector_sample_input_cut_list: if os.path.isfile(vector_file): removeVectorFile(vector_file) print(bold + green + "## END : CREATE HEIGHT POINTS FILE FROM MNSE" + endC) # Mise à jour du Log ending_event = "estimateQualityMns() : Masks creation ending : " timeLine(path_time_log, ending_event) return
def addDataBaseExo(image_input, image_classif_add_output, class_file_dico, class_buffer_dico, class_sql_dico, path_time_log, format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True, simplifie_param=10.0): # Mise à jour du Log starting_event = "addDataBaseExo() : Add data base exogene to classification starting : " timeLine(path_time_log, starting_event) # Print if debug >= 3: print(bold + green + "Variables dans la fonction" + endC) print(cyan + "addDataBaseExo() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "addDataBaseExo() : " + endC + "image_classif_add_output : " + str(image_classif_add_output) + endC) print(cyan + "addDataBaseExo() : " + endC + "class_file_dico : " + str(class_file_dico) + endC) print(cyan + "addDataBaseExo() : " + endC + "class_buffer_dico : " + str(class_buffer_dico) + endC) print(cyan + "addDataBaseExo() : " + endC + "class_sql_dico : " + str(class_sql_dico) + endC) print(cyan + "addDataBaseExo() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "addDataBaseExo() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "addDataBaseExo() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "addDataBaseExo() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "addDataBaseExo() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "addDataBaseExo() : " + endC + "overwrite : " + str(overwrite) + endC) # Constantes FOLDER_MASK_TEMP = 'Mask_' FOLDER_FILTERING_TEMP = 'Filt_' FOLDER_CUTTING_TEMP = 'Cut_' FOLDER_BUFF_TEMP = 'Buff_' SUFFIX_MASK_CRUDE = '_mcrude' SUFFIX_MASK = '_mask' SUFFIX_FUSION = '_info' SUFFIX_VECTOR_FILTER = "_filt" SUFFIX_VECTOR_CUT = '_decoup' SUFFIX_VECTOR_BUFF = '_buff' CODAGE = "uint16" # ETAPE 1 : NETTOYER LES DONNEES EXISTANTES if debug >= 2: print(cyan + "addDataBaseExo() : " + bold + green + "NETTOYAGE ESPACE DE TRAVAIL..." + endC) # Nom de base de l'image image_name = os.path.splitext(os.path.basename(image_input))[0] # Nettoyage d'anciennes données résultat # Si le fichier résultat existent deja et que overwrite n'est pas activé check = os.path.isfile(image_classif_add_output) if check and not overwrite: print(bold + yellow + "addDataBaseExo() : " + endC + image_classif_add_output + " has already added bd exo and will not be added again." + endC) else: if check: try: removeFile(image_classif_add_output ) # Tentative de suppression du fichier except Exception: pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite # Définition des répertoires temporaires repertory_output = os.path.dirname(image_classif_add_output) repertory_mask_temp = repertory_output + os.sep + FOLDER_MASK_TEMP + image_name repertory_samples_filtering_temp = repertory_output + os.sep + FOLDER_FILTERING_TEMP + image_name repertory_samples_cutting_temp = repertory_output + os.sep + FOLDER_CUTTING_TEMP + image_name repertory_samples_buff_temp = repertory_output + os.sep + FOLDER_BUFF_TEMP + image_name if debug >= 4: print(repertory_mask_temp) print(repertory_samples_filtering_temp) print(repertory_samples_cutting_temp) print(repertory_samples_buff_temp) # Creer les répertoires temporaire si ils n'existent pas if not os.path.isdir(repertory_output): os.makedirs(repertory_output) if not os.path.isdir(repertory_mask_temp): os.makedirs(repertory_mask_temp) if not os.path.isdir(repertory_samples_filtering_temp): os.makedirs(repertory_samples_filtering_temp) if not os.path.isdir(repertory_samples_cutting_temp): os.makedirs(repertory_samples_cutting_temp) if not os.path.isdir(repertory_samples_buff_temp): os.makedirs(repertory_samples_buff_temp) # Nettoyer les répertoires temporaire si ils ne sont pas vide cleanTempData(repertory_mask_temp) cleanTempData(repertory_samples_filtering_temp) cleanTempData(repertory_samples_cutting_temp) cleanTempData(repertory_samples_buff_temp) if debug >= 2: print(cyan + "addDataBaseExo() : " + bold + green + "... FIN NETTOYAGE" + endC) # ETAPE 2 : CREER UN SHAPE DE DECOUPE if debug >= 2: print(cyan + "addDataBaseExo() : " + bold + green + "SHAPE DE DECOUPE..." + endC) # 2.1 : Création des masques délimitant l'emprise de la zone par image vector_mask = repertory_mask_temp + os.sep + image_name + SUFFIX_MASK_CRUDE + extension_vector 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 rastersPreparation(emprise_file, classif_input, mns_input, mnh_input, classif_output, mns_output, mnh_output, epsg, no_data_value, path_time_log, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): print(bold + yellow + "Début de la préparation des fichiers rasters.\n" + endC) timeLine(path_time_log, "Début de la préparation des fichiers rasters : ") if debug >= 3 : print(bold + green + "rastersPreparation() : Variables dans la fonction" + endC) print(cyan + "rastersPreparation() : " + endC + "emprise_file : " + str(emprise_file) + endC) print(cyan + "rastersPreparation() : " + endC + "classif_input : " + str(classif_input) + endC) print(cyan + "rastersPreparation() : " + endC + "mns_input : " + str(mns_input) + endC) print(cyan + "rastersPreparation() : " + endC + "mnh_input : " + str(mnh_input) + endC) print(cyan + "rastersPreparation() : " + endC + "classif_output : " + str(classif_output) + endC) print(cyan + "rastersPreparation() : " + endC + "mns_output : " + str(mns_output) + endC) print(cyan + "rastersPreparation() : " + endC + "mnh_output : " + str(mnh_output) + endC) print(cyan + "rastersPreparation() : " + endC + "epsg : " + str(epsg)) print(cyan + "rastersPreparation() : " + endC + "no_data_value : " + str(no_data_value)) print(cyan + "rastersPreparation() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "rastersPreparation() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "rastersPreparation() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "rastersPreparation() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "rastersPreparation() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "rastersPreparation() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "rastersPreparation() : " + endC + "overwrite : " + str(overwrite) + endC) SUFFIX_VECTOR_BUFF = '_buff' if not os.path.exists(classif_output) or not os.path.exists(mns_output) or not os.path.exists(mnh_output) or overwrite: ############################################ ### Préparation générale des traitements ### ############################################ if not os.path.exists(os.path.dirname(classif_output)): os.makedirs(os.path.dirname(classif_output)) if not os.path.exists(os.path.dirname(mns_output)): os.makedirs(os.path.dirname(mns_output)) if not os.path.exists(os.path.dirname(mnh_output)): os.makedirs(os.path.dirname(mnh_output)) emprise_buffer = os.path.splitext(emprise_file)[0] + SUFFIX_VECTOR_BUFF + extension_vector buffer_dist = 10 bufferVector(emprise_file, emprise_buffer, buffer_dist, "", 1.0, 10, format_vector) ################################### ### Traitements sur les rasters ### ################################### images_input_list = [classif_input, mns_input, mnh_input] images_output_list = [classif_output, mns_output, mnh_output] cutRasterImages(images_input_list, emprise_buffer, images_output_list, 0, 0, epsg, no_data_value, "", False, path_time_log, format_raster, format_vector, extension_raster, extension_vector, save_results_intermediate, overwrite) ########################################## ### Nettoyage des fichiers temporaires ### ########################################## if not save_results_intermediate: if os.path.exists(emprise_buffer): removeVectorFile(emprise_buffer) else: print(bold + magenta + "La préparation des fichiers rasters a déjà eu lieu.\n" + endC) print(bold + yellow + "Fin de la préparation des fichiers rasters.\n" + endC) timeLine(path_time_log, "Fin de la préparation des fichiers rasters : ") return
def polygonMerToTDC(input_im_ndvi_dico, output_dir, input_sea_points, fct_bin_mask_vect, simplif, input_cut_vector, buf_pos, buf_neg, no_data_value, path_time_log, epsg=2154, format_vector="ESRI Shapefile", extension_raster=".tif", extension_vector=".shp", save_results_intermediate=True, overwrite=True): # Mise à jour du Log starting_event = "PolygonMerToTDC() : Select PolygonMerToTDC starting : " timeLine(path_time_log,starting_event) # Affichage des paramètres if debug >= 3: print(bold + green + "Variables dans PolygonMerToTDC - Variables générales" + endC) print(cyan + "polygonMerToTDC() : " + endC + "input_im_ndvi_dico : " + str(input_im_ndvi_dico) + endC) print(cyan + "polygonMerToTDC() : " + endC + "output_dir : " + str(output_dir) + endC) print(cyan + "polygonMerToTDC() : " + endC + "input_sea_points : " + str(input_sea_points) + endC) print(cyan + "polygonMerToTDC() : " + endC + "fct_bin_mask_vect : " + str(fct_bin_mask_vect) + endC) print(cyan + "polygonMerToTDC() : " + endC + "simplif : " + str(simplif) + endC) print(cyan + "polygonMerToTDC() : " + endC + "input_cut_vector : " + str(input_cut_vector) + endC) print(cyan + "polygonMerToTDC() : " + endC + "buf_pos : " + str(buf_pos) + endC) print(cyan + "polygonMerToTDC() : " + endC + "buf_neg : " + str(buf_neg) + endC) print(cyan + "polygonMerToTDC() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "polygonMerToTDC() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "polygonMerToTDC() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "polygonMerToTDC() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "polygonMerToTDC() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "polygonMerToTDC() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "polygonMerToTDC() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "polygonMerToTDC() : " + endC + "overwrite : " + str(overwrite) + endC) # Constantes REP_TEMP_POLY_MER = "Temp_PolygonMerToTDC_" CODAGE_8B = "uint8" # 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) # Pour toutes les images à traiter for r in range(len(input_im_ndvi_dico.split())): # L'image à traiter input_image = input_im_ndvi_dico.split()[r].split(":")[0] image_name = os.path.splitext(os.path.basename(input_image))[0] # Création du répertoire temporaire de calcul repertory_temp = output_dir + os.sep + REP_TEMP_POLY_MER + image_name if not os.path.exists(repertory_temp): os.makedirs(repertory_temp) if not os.path.exists(input_image): print(cyan + "polygonMerToTDC() : " + bold + red + "L'image en entrée : " + input_image + " n'existe pas. Vérifiez le chemin !" + endC, file=sys.stderr) sys.exit(1) src_input_im = gdal.Open(input_image) if src_input_im is None: print(cyan + "polygonMerToTDC() : " + bold + red + "Impossible d'ouvrir l'image raster : " + input_image + endC, file=sys.stderr) sys.exit(1) try : srcband = src_input_im.GetRasterBand(2) except RuntimeError as err: print(cyan + "polygonMerToTDC() : " + bold + red + "Pas de bande 2 trouvée sur : " + input_image + endC, file=sys.stderr) e = "OS error: {0}".format(err) print(e, file=sys.stderr) sys.exit(1) # Traiter le cas où pas de NDVI derrière if ":" not in input_im_ndvi_dico.split()[r]: print(cyan + "polygonMerToTDC() : " + red + bold + "Aucun masque binaire vectorisé spécifié ! Nécessité d'au moins un par image." + endC, file=sys.stderr) sys.exit(1) # Parcours de toutes les images NDVI correspondant à chaque image for ndvi_mask_vect in input_im_ndvi_dico.split()[r].split(":")[1].split(","): if debug > 2 : print(cyan + "polygonMerToTDC() : " + endC + "Traitement de : " + ndvi_mask_vect) # Initialisation des noms des fichiers de sortie binary_mask_zeros = repertory_temp + os.sep + "b_mask_zeros_" + os.path.splitext(os.path.basename(input_image))[0] + extension_raster binary_mask_zeros_vector = "b_mask_zeros_vect_" + os.path.splitext(os.path.basename(input_image))[0] path_binary_mask_zeros_vector = repertory_temp + os.sep + binary_mask_zeros_vector + extension_vector true_values_buffneg = repertory_temp + os.sep + "true_values_buffneg_" + os.path.splitext(os.path.basename(input_image))[0] + extension_vector decoup_buffneg = repertory_temp + os.sep + "decoupe_buffneg_" + os.path.splitext(os.path.basename(input_cut_vector))[0] + extension_vector if fct_bin_mask_vect : threshold = os.path.splitext(os.path.basename(ndvi_mask_vect))[0].split("_")[-2] + "_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0].split("_")[-1] poly_mer_shp = repertory_temp + os.sep + "poly_mer_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector poly_mer_shp_dilat = repertory_temp + os.sep + "poly_mer_dilat_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector poly_mer_shp_ferm = repertory_temp + os.sep + "poly_mer_ferm_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector polyline_mer = repertory_temp + os.sep + "polyline_mer_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector polyline_tdc = repertory_temp + os.sep + "tdc_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector polyline_tdc_simplif = repertory_temp + os.sep + "tdcs_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector polyline_tdc_simplif_decoup = output_dir + os.sep + "tdcsd_" + os.path.splitext(os.path.basename(input_image))[0] + "_" + str(threshold) + extension_vector else : poly_mer_shp = repertory_temp + os.sep + "poly_mer_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector poly_mer_shp_dilat = repertory_temp + os.sep + "poly_mer_dilat_" + os.path.splitext(os.path.basename(input_image))[0] + extension_vector poly_mer_shp_ferm = repertory_temp + os.sep + "poly_mer_ferm_" + os.path.splitext(os.path.basename(input_image))[0] + extension_vector polyline_mer = repertory_temp + os.sep + "polyline_mer_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector polyline_tdc = repertory_temp + os.sep + "tdc_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector polyline_tdc_simplif = repertory_temp + os.sep + "tdcs_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector polyline_tdc_simplif_decoup = output_dir + os.sep + "tdcsd_" + os.path.splitext(os.path.basename(ndvi_mask_vect))[0] + extension_vector # Création shp poly_mer_shp contenant uniquement les polygones mer if os.path.exists(poly_mer_shp): removeVectorFile(poly_mer_shp) # Sélection des polygones qui sont de la mer, dans la liste poly_mer withinPolygons(input_sea_points, ndvi_mask_vect, poly_mer_shp, overwrite, format_vector) # Fermeture (dilatation - érosion) sur les polygones mer obtenus pour supprimer les petits trous dans les polygones (bateaux, ...) et rassembler les polygones proches bufferVector(poly_mer_shp, poly_mer_shp_dilat, buf_pos, "", 1.0, 10, format_vector) bufferVector(poly_mer_shp_dilat, poly_mer_shp_ferm, buf_neg, "", 1.0, 10, format_vector) # Création masque binaire pour séparer les no data des vraies valeurs no_data_ima = getNodataValueImage(input_image) if no_data_ima == None : no_data_ima = no_data_value createBinaryMaskMultiBand(input_image, binary_mask_zeros, no_data_ima, CODAGE_8B) # Vectorisation du masque binaire true data/false data -> polygone avec uniquement les vraies valeurs if os.path.exists(path_binary_mask_zeros_vector): removeVectorFile(path_binary_mask_zeros_vector) polygonizeRaster(binary_mask_zeros, path_binary_mask_zeros_vector, binary_mask_zeros_vector) # Buffer négatif sur ce polygone bufferVector(path_binary_mask_zeros_vector, true_values_buffneg, -2, "", 1.0, 10, format_vector) # Transformation des polygones de la couche poly_mer_shp_ferm en polyligne convertePolygon2Polylines(poly_mer_shp_ferm, polyline_mer, overwrite, format_vector) # Découpe du TDC polyline_mer avec le polygone négatif cutVectorAll(true_values_buffneg, polyline_mer, polyline_tdc, overwrite, format_vector) # Simplification du TDC simplifyVector(polyline_tdc, polyline_tdc_simplif, simplif, format_vector) # Buffer négatif autour de input_cut_vector bufferVector(input_cut_vector, decoup_buffneg, -1, "", 1.0, 10, format_vector) # Découpe du TDC polyline_mer avec le buffer négatif du polygone mer cutVectorAll(decoup_buffneg, polyline_tdc_simplif, polyline_tdc_simplif_decoup, overwrite, format_vector) tdc_final = polyline_tdc_simplif_decoup # Suppression du repertoire temporaire if not save_results_intermediate and os.path.exists(repertory_temp): shutil.rmtree(repertory_temp) # Mise à jour du Log ending_event = "PolygonMerToTDC() : Select PolygonMerToTDC ending: " timeLine(path_time_log,ending_event) return tdc_final
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 buffersOuvrages(input_tdc_shp, output_dir, buf_pos, buf_neg, input_cut_vector, path_time_log, format_vector="ESRI Shapefile", extension_vector=".shp", save_results_intermediate=True, overwrite=True): # Mise à jour du Log starting_event = "buffersOuvrages() : Select buffers ouvrages starting : " timeLine(path_time_log, starting_event) # Affichage des paramètres if debug >= 3: print(bold + green + "Variables dans buffersOuvrages - Variables générales" + endC) print(cyan + "buffersOuvrages() : " + endC + "input_tdc_shp : " + str(input_tdc_shp) + endC) print(cyan + "buffersOuvrages() : " + endC + "output_dir : " + str(output_dir) + endC) print(cyan + "buffersOuvrages() : " + endC + "buf_pos : " + str(buf_pos) + endC) print(cyan + "buffersOuvrages() : " + endC + "buf_neg : " + str(buf_neg) + endC) print(cyan + "buffersOuvrages() : " + endC + "input_cut_vector : " + str(input_cut_vector) + endC) print(cyan + "buffersOuvrages() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "buffersOuvrages() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "buffersOuvrages() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "buffersOuvrages() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "buffersOuvrages() : " + endC + "overwrite : " + str(overwrite) + endC) # Constantes REP_TEMP = "temp_buffersOuvrages" # Variables repertory_temp = output_dir + os.sep + REP_TEMP nom_tdc = os.path.splitext(os.path.basename(input_tdc_shp))[0] output_vector = output_dir + os.sep + "OuvragesBuffers" + str( buf_pos) + str(buf_neg) + "_" + nom_tdc + extension_vector tdc_decoup_vector = repertory_temp + os.sep + "decoup_" + nom_tdc + extension_vector temp_buf_vector = repertory_temp + os.sep + "buffer" + str( buf_pos) + "_" + nom_tdc + 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) # Création du répertoire de sortie s'il n'existe pas déjà if not os.path.exists(repertory_temp): os.makedirs(repertory_temp) # Vérification de l'existance du fichier tdc en entrée driver = ogr.GetDriverByName(format_vector) data_source_tdc = driver.Open(input_tdc_shp, 0) if data_source_tdc is None: print(cyan + "buffersOuvrages() : " + bold + red + "Could not open file : " + str(input_tdc_shp) + endC, file=sys.stderr) sys.exit(1) # Découpe du TDC par le shapefile en entrée pour la suppression des artéfacts cutVectorAll(input_cut_vector, input_tdc_shp, tdc_decoup_vector, overwrite, format_vector) # Buffer positif puis négatif sur le tdc pour extraire les ouvrages bufferVector(input_tdc_shp, temp_buf_vector, str(buf_pos), "", 1.0, 10, format_vector) bufferVector(temp_buf_vector, output_vector, buf_neg, "", 1.0, 10, format_vector) # Suppression du repertoire temporaire if not save_results_intermediate and os.path.exists(repertory_temp): shutil.rmtree(repertory_temp) # Mise à jour du Log ending_event = "buffersOuvrages() : Select buffers ouvrages ending : " timeLine(path_time_log, ending_event) return output_vector
def createEmprise(input_dir, output_file, is_not_assembled, is_all_polygons_used, is_not_date, is_optimize_emprise, is_optimize_emprise_nodata, no_data_value, size_erode, path_time_log, separ_name="_", pos_date=1, nb_char_date=8, separ_date="", epsg=2154, 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 createEmprise - Variables générales" + endC) print(cyan + "createEmprise() : " + endC + "input_dir : " + str(input_dir)) print(cyan + "createEmprise() : " + endC + "output_file : " + str(output_file)) print(cyan + "createEmprise() : " + endC + "is_not_assembled : " + str(is_not_assembled)) print(cyan + "createEmprise() : " + endC + "is_all_polygons_used : " + str(is_all_polygons_used)) print(cyan + "createEmprise() : " + endC + "is_not_date : " + str(is_not_date)) print(cyan + "createEmprise() : " + endC + "is_optimize_emprise : " + str(is_optimize_emprise)) print(cyan + "createEmprise() : " + endC + "is_optimize_emprise_nodata : " + str(is_optimize_emprise_nodata)) print(cyan + "createEmprise() : " + endC + "no_data_value : " + str(no_data_value)) print(cyan + "createEmprise() : " + endC + "size_erode : " + str(size_erode)) print(cyan + "createEmprise() : " + endC + "path_time_log : " + str(path_time_log)) print(cyan + "createEmprise() : " + endC + "separ_name : " + str(separ_name)) print(cyan + "createEmprise() : " + endC + "pos_date : " + str(pos_date)) print(cyan + "createEmprise() : " + endC + "nb_char_date : " + str(nb_char_date)) print(cyan + "createEmprise() : " + endC + "separ_date : " + str(separ_date)) print(cyan + "createEmprise() : " + endC + "epsg : " + str(epsg)) print(cyan + "createEmprise() : " + endC + "format_vector : " + str(format_vector)) print(cyan + "createEmprise() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "createEmprise() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "createEmprise() : " + endC + "save_results_intermediate : " + str(save_results_intermediate)) print(cyan + "createEmprise() : " + endC + "overwrite : " + str(overwrite)) # Constantes EXT_LIST_HDF5 = ['h5', 'H5', 'he5', 'HE5', 'hdf5', 'HDF5'] EXT_LIST = EXT_LIST_HDF5 + [ 'tif', 'TIF', 'tiff', 'TIFF', 'ecw', 'ECW', 'jp2', 'JP2', 'dim', 'DIM', 'asc', 'ASC' ] SUFFIX_DETAILLEE = "_detail" SUFFIX_MASK_ZERO = "_mask_zeros" SUFFIX_TMP = "_tmp" CODAGE_8B = "uint8" ATTR_NAME_ID = "Id" ATTR_NAME_NOMIMAGE = "NomImage" ATTR_NAME_DATEACQUI = "DateAcqui" ATTR_NAME_HEUREACQUI = "HeureAcqui" ATTR_NAME_REFDOSSIER = "RefDossier" # Variables points_list = [] name_image_list = [] name_rep_list = [] ref_dossier_list = [] date_list = [] heure_list = [] optimize_emprise_nodata_shape_list = [] polygons_attr_coord_dico = {} pos_date = pos_date - 1 repertory_output = os.path.dirname(output_file) file_name = os.path.splitext(os.path.basename(output_file))[0] extension = os.path.splitext(output_file)[1] file_vector_detail = repertory_output + os.sep + file_name + SUFFIX_DETAILLEE + extension # 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(output_file) if check and not overwrite: print( bold + yellow + "createEmprise() : " + endC + "Le fichier vecteur d'emprise %s existe déjà : pas d'actualisation" % (output_file) + 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 removeVectorFile(output_file) removeVectorFile(file_vector_detail) except Exception: pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite # Récuperer tous les sous répertoires sub_rep_list = getSubRepRecursifList(input_dir) sub_rep_list.append(input_dir) # Parcours de chaque dossier image du dossier en entrée for repertory in sub_rep_list: if os.path.isdir(repertory): if debug >= 2: print(cyan + "createEmprises() : " + endC + bold + green + "Traitement de : " + endC + repertory) # Récupération des images du dossier en entrée imagettes_jp2_tif_ecw_list = [] imagettes_list = os.listdir(repertory) for elt1 in imagettes_list: path_image = repertory + os.sep + elt1 if (os.path.isfile(path_image)) and (len( elt1.rsplit('.', 1)) == 2) and (elt1.rsplit( '.', 1)[1] in EXT_LIST): if elt1.rsplit('.', 1)[1] in EXT_LIST_HDF5: elt1_new = os.path.splitext( elt1)[0] + extension_raster path_image_new = repertory + os.sep + elt1_new h5ToGtiff(path_image, path_image_new) imagettes_jp2_tif_ecw_list.append(elt1_new) else: imagettes_jp2_tif_ecw_list.append(elt1) # Pour le cas ou le repertoire contient des fichiers images if not imagettes_jp2_tif_ecw_list == []: # Cas ou chaque emprise d'image est un polygone if is_not_assembled or is_optimize_emprise or is_optimize_emprise_nodata: for imagette in imagettes_jp2_tif_ecw_list: # Récupération des emprises de l'image path_image = repertory + os.sep + imagette path_info_acquisition = repertory xmin, xmax, ymin, ymax = getEmpriseImage( path_image) coord_list = [ xmin, ymax, xmax, ymax, xmax, ymin, xmin, ymin, xmin, ymax ] # Saisie des données points_list.append(coord_list) # Récupération du nom de l'image pour la création des champs input_image_name = os.path.splitext( os.path.basename(path_image))[0] name_image_list.append(input_image_name) # Cas optimisation de l'emprise en elevant les nodata if is_optimize_emprise_nodata: path_info_acquisition = path_image optimize_emprise_nodata_shape = repertory_output + os.sep + input_image_name + extension_vector optimize_emprise_tmp1_shape = repertory_output + os.sep + input_image_name + SUFFIX_TMP + str( 1) + extension_vector optimize_emprise_tmp2_shape = repertory_output + os.sep + input_image_name + SUFFIX_TMP + str( 2) + extension_vector optimize_emprise_tmp3_shape = repertory_output + os.sep + input_image_name + SUFFIX_TMP + str( 3) + extension_vector optimize_emprise_tmp4_shape = repertory_output + os.sep + input_image_name + SUFFIX_TMP + str( 4) + extension_vector binary_mask_zeros_raster = repertory_output + os.sep + input_image_name + SUFFIX_MASK_ZERO + extension_raster optimize_emprise_nodata_shape_list.append( optimize_emprise_nodata_shape) # Création masque binaire pour séparer les no data des vraies valeurs no_data_value_img = getNodataValueImage( path_image) if no_data_value_img == None: no_data_value_img = no_data_value createBinaryMaskMultiBand( path_image, binary_mask_zeros_raster, no_data_value_img, CODAGE_8B) # Vectorisation du masque binaire true data/false data -> polygone avec uniquement les vraies valeurs if os.path.exists( optimize_emprise_nodata_shape): removeVectorFile( optimize_emprise_nodata_shape) polygonizeRaster(binary_mask_zeros_raster, optimize_emprise_tmp1_shape, input_image_name, ATTR_NAME_ID, format_vector) # Nettoyage des polygones parasites pour ne garder que le polygone pricipale si l'option "all" n'est pas demandée if not is_all_polygons_used: geometry_list = getGeomPolygons( optimize_emprise_tmp1_shape, None, None, format_vector) geometry_orded_dico = {} geometry_orded_list = [] for geometry in geometry_list: area = geometry.GetArea() geometry_orded_dico[area] = geometry geometry_orded_list.append(area) geometry_orded_list.sort() if len(geometry_orded_list) > 0: max_area = geometry_orded_list[ len(geometry_orded_list) - 1] geom_max = geometry_orded_dico[ max_area] attribute_dico = { ATTR_NAME_ID: ogr.OFTInteger } polygons_attr_geom_dico = {} polygons_attr_geom_dico[str(1)] = [ geom_max, { ATTR_NAME_ID: str(1) } ] createPolygonsFromGeometryList( attribute_dico, polygons_attr_geom_dico, optimize_emprise_tmp2_shape, epsg, format_vector) else: print( cyan + "createEmprise() : " + bold + yellow + " Attention!!! Fichier non traite (ne contient pas de polygone): " + optimize_emprise_tmp1_shape + endC) optimize_emprise_tmp2_shape = optimize_emprise_tmp1_shape else: optimize_emprise_tmp2_shape = optimize_emprise_tmp1_shape # Nettoyage des polygones simplification et supression des trous cleanRingVector(optimize_emprise_tmp2_shape, optimize_emprise_tmp3_shape, format_vector) simplifyVector(optimize_emprise_tmp3_shape, optimize_emprise_tmp4_shape, 2, format_vector) if size_erode != 0.0: bufferVector( optimize_emprise_tmp4_shape, optimize_emprise_nodata_shape, size_erode * -1, "", 1.0, 10, format_vector) else: copyVectorFile( optimize_emprise_tmp4_shape, optimize_emprise_nodata_shape, format_vector) # Nettoyage des fichier intermediaires if not save_results_intermediate: removeFile(binary_mask_zeros_raster) removeVectorFile( optimize_emprise_tmp1_shape) removeVectorFile( optimize_emprise_tmp2_shape) removeVectorFile( optimize_emprise_tmp3_shape) removeVectorFile( optimize_emprise_tmp4_shape) # Recuperation de la date et l'heure d'acquisition # Gestion de l'emprise optimisé nodata on utilise le nom de l'image pour la date d'acquisition sion c'est le nom du repertoire getDataToFiels( path_info_acquisition, is_not_date, is_optimize_emprise or is_optimize_emprise_nodata, separ_name, pos_date, nb_char_date, separ_date, points_list, ref_dossier_list, name_rep_list, date_list, heure_list) # Cas ou l'on prend l'emprise globale des images un seul plolygone correspondant a l'emprise globale else: # Récupération des emprises des images du dossier liste_x_l = [] liste_y_b = [] liste_x_r = [] liste_y_t = [] for imagette in imagettes_jp2_tif_ecw_list: path_image = repertory + os.sep + imagette xmin, xmax, ymin, ymax = getEmpriseImage( path_image) liste_x_l.append(xmin) liste_x_r.append(xmax) liste_y_b.append(ymin) liste_y_t.append(ymax) # Récupération des min et max de la liste des imagettes # Coin haut gauche xmin_l_t = str(min(liste_x_l)) # Coin bas gauche ymin_l_b = str(min(liste_y_b)) xmin_l_b = xmin_l_t # Coin bas doite xmax_r_b = str(max(liste_x_r)) # Coin haut droite ymax_r_t = str(max(liste_y_t)) xmax_r_t = xmax_r_b ymax_r_b = ymin_l_b ymin_l_t = ymax_r_t coord_list = [ xmin_l_t, ymin_l_t, xmin_l_b, ymin_l_b, xmax_r_b, ymax_r_b, xmax_r_t, ymax_r_t, xmin_l_t, ymin_l_t ] points_list.append(coord_list) # Récupération du nom du répertoire pour création des champs getDataToFiels(repertory, is_not_date, is_optimize_emprise, separ_name, pos_date, nb_char_date, separ_date, points_list, ref_dossier_list, name_rep_list, date_list, heure_list) # Préparation des attribute_dico et polygons_attr_coord_dico if is_not_assembled: attribute_dico = { ATTR_NAME_ID: ogr.OFTInteger, ATTR_NAME_NOMIMAGE: ogr.OFTString, ATTR_NAME_DATEACQUI: ogr.OFTDate, ATTR_NAME_HEUREACQUI: ogr.OFTString } for i in range(len(points_list)): polygons_attr_coord_dico[str(i)] = [ points_list[i], { ATTR_NAME_ID: i + 1, ATTR_NAME_NOMIMAGE: name_image_list[i], ATTR_NAME_DATEACQUI: date_list[i], ATTR_NAME_HEUREACQUI: heure_list[i] } ] else: attribute_dico = { ATTR_NAME_NOMIMAGE: ogr.OFTString, ATTR_NAME_REFDOSSIER: ogr.OFTString, ATTR_NAME_DATEACQUI: ogr.OFTDate, ATTR_NAME_HEUREACQUI: ogr.OFTString } for i in range(len(points_list)): polygons_attr_coord_dico[str(i)] = [ points_list[i], { ATTR_NAME_NOMIMAGE: name_rep_list[i], ATTR_NAME_REFDOSSIER: ref_dossier_list[i], ATTR_NAME_DATEACQUI: date_list[i], ATTR_NAME_HEUREACQUI: heure_list[i] } ] # Cas optimisation de l'emprise en elevant les nodata colum = "" if is_optimize_emprise_nodata: if is_not_assembled: file_vector = output_file else: file_vector = file_vector_detail # Fusion des polygones d'emprises images optimisées sans nodata polygons_attr_geom_dico = {} i = 0 for shape_file in optimize_emprise_nodata_shape_list: geom_list = getGeomPolygons(shape_file, ATTR_NAME_ID, 1, format_vector) if not is_all_polygons_used: if geom_list is not None and len(geom_list) > 0: geom = geom_list[0] polygons_attr_geom_dico[str(i)] = [ geom, polygons_attr_coord_dico[str(i)][1] ] else: j = 1 for geom in geom_list: polygons_attr_geom_dico[str(i + 1000000 * j)] = [ geom, polygons_attr_coord_dico[str(i)][1] ] j += 1 i += 1 createPolygonsFromGeometryList(attribute_dico, polygons_attr_geom_dico, file_vector, epsg, format_vector) # Suppression des fichiers intermediaires if not save_results_intermediate: for vector_to_del in optimize_emprise_nodata_shape_list: removeVectorFile(vector_to_del) else: # Utilisation de createPolygonsFromCoordList() if is_optimize_emprise: file_vector = file_vector_detail else: file_vector = output_file # Creation des polygones a partir de la liste des coordonnées des emprises createPolygonsFromCoordList(attribute_dico, polygons_attr_coord_dico, file_vector, epsg, format_vector) # Cas fusion des polygones pour avoir une emprise constituée d'un seul polygone if not is_not_assembled: if is_optimize_emprise or is_optimize_emprise_nodata or is_all_polygons_used: column_name = "" if is_all_polygons_used: column_name = ATTR_NAME_DATEACQUI elif is_optimize_emprise or is_optimize_emprise_nodata: column_name = ATTR_NAME_NOMIMAGE # Fusion des polygones if is_all_polygons_used and is_not_date: fusionNeighbourPolygonsBySameValue(file_vector, output_file, column_name, format_vector) #dissolveVector(file_vector, output_file, column_name, format_vector) else: if not geometries2multigeometries(file_vector, output_file, column_name, format_vector): copyVectorFile(file_vector, output_file, format_vector) # Suppression des fichiers intermediaires if not save_results_intermediate: removeVectorFile(file_vector_detail) return
def multiBuffersVector(input_file, output_dir, buffer_size, nb_buffers, path_time_log, epsg=2154, format_vector="ESRI Shapefile", project_encoding="UTF-8", overwrite=True): # Mise à jour du Log starting_event = "multiBuffersVector() : Select multi buffers vector starting : " timeLine(path_time_log,starting_event) # Configuration du format vecteur driver = ogr.GetDriverByName(format_vector) # Création de la référence spatiale srs = osr.SpatialReference() srs.ImportFromEPSG(epsg) result_list = [] extension_vector = os.path.splitext(os.path.split(input_file)[1])[1] nom_input_file = os.path.splitext(os.path.split(input_file)[1])[0] output_repertory = output_dir + os.sep + "multi_ring_buffers_" + nom_input_file + extension_vector for i in range(1, nb_buffers+1): # Création du buffer output_temp_buffer = output_dir + os.sep + os.path.splitext(os.path.split(input_file)[1])[0] + "_buffer_" + str(i*buffer_size) + extension_vector bufferVector(input_file, output_temp_buffer, i*buffer_size, "", 1.0, 10, format_vector) # Ajout d'un champ taille de buffer data_source_buffer = driver.Open(output_temp_buffer, 1) buffer_layer = data_source_buffer.GetLayer(0) buff_size_field = ogr.FieldDefn("size_buff", ogr.OFTReal) buffer_layer.CreateField(buff_size_field) for feature in buffer_layer: feature.SetField("size_buff",i*buffer_size) buffer_layer.SetFeature(feature) # Ajout du premier buffer à la liste finale if i == 1: result_list.append(output_temp_buffer) # Transformation des buffers en anneaux if i>1: i_preced = i-1 output_temp_buffer_preced = output_dir + os.sep + nom_input_file + "_buffer_" + str(i_preced*buffer_size) + extension_vector output_temp_ring = output_dir + os.sep + nom_input_file + "_ring_" + str(i*buffer_size) + extension_vector differenceVector(output_temp_buffer_preced, output_temp_buffer, output_temp_ring, format_vector) # Remplissage du champ taille du buffer data_source_ring = driver.Open(output_temp_ring, 1) ring_layer = data_source_ring.GetLayer(0) for ring in ring_layer: ring.SetField("size_buff",i*buffer_size) ring_layer.SetFeature(ring) # Ajout de l'anneau à la liste finale result_list.append(output_temp_ring) fusionVectors(result_list, output_repertory, format_vector) # Mise à jour du Log ending_event = "multiBuffersVector() : multi buffers vector ending : " timeLine(path_time_log,ending_event) return output_repertory
def skyViewFactor(grid_input, grid_output, mns_input, classif_input, class_build_list, dim_grid_x, dim_grid_y, svf_radius, svf_method, svf_dlevel, svf_ndirs, epsg, no_data_value, path_time_log, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): print(bold + yellow + "Début du calcul de l'indicateur Sky View Factor." + endC + "\n") timeLine(path_time_log, "Début du calcul de l'indicateur Sky View Factor : ") if debug >= 3: print(bold + green + "skyViewFactor() : Variables dans la fonction" + endC) print(cyan + "skyViewFactor() : " + endC + "grid_input : " + str(grid_input) + endC) print(cyan + "skyViewFactor() : " + endC + "grid_output : " + str(grid_output) + endC) print(cyan + "skyViewFactor() : " + endC + "mns_input : " + str(mns_input) + endC) print(cyan + "skyViewFactor() : " + endC + "class_build_list : " + str(class_build_list) + endC) print(cyan + "skyViewFactor() : " + endC + "classif_input : " + str(classif_input) + endC) print(cyan + "skyViewFactor() : " + endC + "dim_grid_x : " + str(dim_grid_x) + endC) print(cyan + "skyViewFactor() : " + endC + "dim_grid_y : " + str(dim_grid_y) + endC) print(cyan + "skyViewFactor() : " + endC + "svf_radius : " + str(svf_radius) + endC) print(cyan + "skyViewFactor() : " + endC + "svf_method : " + str(svf_method) + endC) print(cyan + "skyViewFactor() : " + endC + "svf_dlevel : " + str(svf_dlevel) + endC) print(cyan + "skyViewFactor() : " + endC + "svf_ndirs : " + str(svf_ndirs) + endC) print(cyan + "skyViewFactor() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "skyViewFactor() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "skyViewFactor() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "skyViewFactor() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "skyViewFactor() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "skyViewFactor() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "skyViewFactor() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "skyViewFactor() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "skyViewFactor() : " + endC + "overwrite : " + str(overwrite) + endC) # Constantes liées aux fichiers SKY_VIEW_FIELD = 'SkyView' BASE_FILE_TILE = 'tile_' BASE_FILE_POLY = 'poly_' SUFFIX_VECTOR_BUFF = '_buff' SUFFIX_VECTOR_TEMP = '_temp' # Constantes liées à l'arborescence FOLDER_SHP = 'SHP' FOLDER_SGRD = 'SGRD' FOLDER_TIF = 'TIF' SUB_FOLDER_DEM = 'DEM' SUB_FOLDER_SVF = 'SVF' SUB_SUB_FOLDER_BUF = 'BUF' if not os.path.exists(grid_output) or overwrite: ############################################ ### Préparation générale des traitements ### ############################################ if os.path.exists(grid_output): removeVectorFile(grid_output) temp_path = os.path.dirname(grid_output) + os.sep + "SkyViewFactor" sky_view_factor_raster = temp_path + os.sep + "sky_view_factor" + extension_raster cleanTempData(temp_path) os.makedirs(temp_path + os.sep + FOLDER_SHP) os.makedirs(temp_path + os.sep + FOLDER_SGRD + os.sep + SUB_FOLDER_DEM) os.makedirs(temp_path + os.sep + FOLDER_SGRD + os.sep + SUB_FOLDER_SVF) os.makedirs(temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_DEM) os.makedirs(temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF) os.makedirs(temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF + os.sep + SUB_SUB_FOLDER_BUF) # Récupération de la résolution du raster d'entrée pixel_size_x, pixel_size_y = getPixelWidthXYImage(mns_input) print(bold + "Taille de pixel du fichier '%s' :" % (mns_input) + endC) print(" pixel_size_x = " + str(pixel_size_x)) print(" pixel_size_y = " + str(pixel_size_y) + "\n") ############################################### ### Création des fichiers emprise et grille ### ############################################### print(bold + cyan + "Création des fichiers emprise et grille :" + endC) timeLine(path_time_log, " Création des fichiers emprise et grille : ") emprise_file = temp_path + os.sep + "emprise" + extension_vector quadrillage_file = temp_path + os.sep + "quadrillage" + extension_vector # Création du fichier d'emprise createVectorMask(mns_input, emprise_file, no_data_value, format_vector) # Création du fichier grille createGridVector(emprise_file, quadrillage_file, dim_grid_x, dim_grid_y, None, overwrite, epsg, format_vector) ############################################################# ### Extraction des carreaux de découpage et bufferisation ### ############################################################# print(bold + cyan + "Extraction des carreaux de découpage :" + endC) timeLine(path_time_log, " Extraction des carreaux de découpage : ") split_tile_vector_list = splitVector(quadrillage_file, temp_path + os.sep + FOLDER_SHP, "", epsg, format_vector, extension_vector) split_tile_vector_buff_list = [] # Boucle sur les fichiers polygones quadrillage for split_tile_vector in split_tile_vector_list: repertory_temp_output = os.path.dirname(split_tile_vector) base_name = os.path.splitext( os.path.basename(split_tile_vector))[0] split_tile_buff_vector = repertory_temp_output + os.sep + base_name + SUFFIX_VECTOR_BUFF + extension_vector split_tile_buff_vector_temp = repertory_temp_output + os.sep + base_name + SUFFIX_VECTOR_BUFF + SUFFIX_VECTOR_TEMP + extension_vector # Bufferisation bufferVector(split_tile_vector, split_tile_buff_vector_temp, svf_radius, "", 1.0, 10, format_vector) # Re-découpage avec l'emprise si la taille intersecte avec l'emprise if cutVector(emprise_file, split_tile_buff_vector_temp, split_tile_buff_vector, overwrite, format_vector): split_tile_vector_buff_list.append(split_tile_buff_vector) ########################################################## ### Découpage du MNS/MNH à l'emprise de chaque carreau ### ########################################################## print(bold + cyan + "Découpage du raster en tuiles :" + endC) timeLine(path_time_log, " Découpage du raster en tuiles : ") # Boucle sur les fichiers polygones quadrillage bufferisés for i in range(len(split_tile_vector_list)): print("Traitement de la tuile " + str(int(i) + 1) + str(len(split_tile_vector_list)) + "...") split_tile_vector = split_tile_vector_list[i] repertory_temp_output = os.path.dirname(split_tile_vector) base_name = os.path.splitext( os.path.basename(split_tile_vector))[0] split_tile_buff_vector = repertory_temp_output + os.sep + base_name + SUFFIX_VECTOR_BUFF + extension_vector dem_tif_file = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_DEM + os.sep + BASE_FILE_TILE + str( i) + extension_raster if os.path.exists(split_tile_buff_vector): cutImageByVector(split_tile_buff_vector, mns_input, dem_tif_file, pixel_size_x, pixel_size_y, no_data_value, epsg, format_raster, format_vector) ################################################## ### Calcul du SVF pour chaque dalle du MNS/MNH ### ################################################## print(bold + cyan + "Calcul du SVF pour chaque tuile via SAGA :" + endC) timeLine(path_time_log, " Calcul du SVF pour chaque tuile via SAGA : ") svf_buf_tif_file_list = [] # Boucle sur les tuiles du raster d'entrée créées par chaque polygone quadrillage for i in range(len(split_tile_vector_list)): # Calcul de Sky View Factor par SAGA dem_tif_file = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_DEM + os.sep + BASE_FILE_TILE + str( i) + extension_raster svf_buf_tif_file = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF + os.sep + SUB_SUB_FOLDER_BUF + os.sep + BASE_FILE_TILE + str( i) + extension_raster if os.path.exists(dem_tif_file): computeSkyViewFactor(dem_tif_file, svf_buf_tif_file, svf_radius, svf_method, svf_dlevel, svf_ndirs, save_results_intermediate) svf_buf_tif_file_list.append(svf_buf_tif_file) ################################################################### ### Re-découpage des tuiles du SVF avec les tuilles sans tampon ### ################################################################### print(bold + cyan + "Re-découpage des tuiles du SVF avec les tuilles sans tampon :" + endC) timeLine( path_time_log, " Re-découpage des tuiles du SVF avec les tuilles sans tampon : " ) folder_output_svf = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF + os.sep # Boucle sur les tuiles du SVF bufferisées for i in range(len(split_tile_vector_list)): print("Traitement de la tuile " + str(int(i) + 1) + "/" + str(len(split_tile_vector_list)) + "...") split_tile_vector = split_tile_vector_list[i] svf_buf_tif_file = temp_path + os.sep + FOLDER_TIF + os.sep + SUB_FOLDER_SVF + os.sep + SUB_SUB_FOLDER_BUF + os.sep + BASE_FILE_TILE + str( i) + extension_raster base_name = os.path.splitext(os.path.basename(svf_buf_tif_file))[0] svf_tif_file = folder_output_svf + os.sep + base_name + extension_raster if os.path.exists(svf_buf_tif_file): cutImageByVector(split_tile_vector, svf_buf_tif_file, svf_tif_file, pixel_size_x, pixel_size_y, no_data_value, epsg, format_raster, format_vector) #################################################################### ### Assemblage des tuiles du SVF et calcul de l'indicateur final ### #################################################################### print( bold + cyan + "Assemblage des tuiles du SVF et calcul de l'indicateur final :" + endC) timeLine( path_time_log, " Assemblage des tuiles du SVF et calcul de l'indicateur final : " ) classif_input_temp = temp_path + os.sep + FOLDER_TIF + os.sep + "classif_input" + SUFFIX_VECTOR_TEMP + extension_raster sky_view_factor_temp = temp_path + os.sep + FOLDER_TIF + os.sep + "sky_view_factor" + SUFFIX_VECTOR_TEMP + extension_raster # Issu de l'assemblage des dalles sky_view_factor_temp_temp = temp_path + os.sep + FOLDER_TIF + os.sep + "sky_view_factor" + SUFFIX_VECTOR_TEMP + SUFFIX_VECTOR_TEMP + extension_raster # Issu du redécoupage pour entrer correctement dans le BandMath sky_view_factor_temp_temp_temp = temp_path + os.sep + FOLDER_TIF + os.sep + "sky_view_factor" + SUFFIX_VECTOR_TEMP + SUFFIX_VECTOR_TEMP + SUFFIX_VECTOR_TEMP + extension_raster # Issu de la suppression des pixels bâti # Assemblage des tuiles du SVF créées précédemment pour ne former qu'un seul raster SVF selectAssembyImagesByHold( emprise_file, [folder_output_svf], sky_view_factor_temp, False, False, epsg, False, False, False, False, 1.0, pixel_size_x, pixel_size_y, no_data_value, "_", 2, 8, "", path_time_log, "_error", "_merge", "_clean", "_stack", format_raster, format_vector, extension_raster, extension_vector, save_results_intermediate, overwrite) # Suppression des valeurs de SVF pour les bâtiments cutImageByVector(emprise_file, classif_input, classif_input_temp, pixel_size_x, pixel_size_y, no_data_value, epsg, format_raster, format_vector) cutImageByVector(emprise_file, sky_view_factor_temp, sky_view_factor_temp_temp, pixel_size_x, pixel_size_y, no_data_value, epsg, format_raster, format_vector) expression = "" for id_class in class_build_list: expression += "im1b1==%s or " % (str(id_class)) expression = expression[:-4] command = "otbcli_BandMath -il %s %s -out %s float -exp '%s ? -1 : im2b1'" % ( classif_input_temp, sky_view_factor_temp_temp, sky_view_factor_temp_temp_temp, expression) if debug >= 3: print(command) exit_code = os.system(command) if exit_code != 0: print(command) print( cyan + "skyViewFactor() : " + bold + red + "!!! Une erreur c'est produite au cours de la commande otbcli_BandMath : " + command + ". Voir message d'erreur." + endC, file=sys.stderr) raise command = "gdal_translate -a_srs EPSG:%s -a_nodata %s -of %s %s %s" % ( str(epsg), str(no_data_value), format_raster, sky_view_factor_temp_temp_temp, sky_view_factor_raster) if debug >= 3: print(command) exit_code = os.system(command) if exit_code != 0: print(command) print( cyan + "skyViewFactor() : " + bold + red + "!!! Une erreur c'est produite au cours de la commande gdal_translate : " + command + ". Voir message d'erreur." + endC, file=sys.stderr) raise # Croisement vecteur-raster pour récupérer la moyenne de SVF par polygone du fichier maillage d'entrée col_to_delete_list = [ "min", "max", "median", "sum", "std", "unique", "range" ] statisticsVectorRaster( sky_view_factor_raster, grid_input, grid_output, 1, False, False, True, col_to_delete_list, [], {}, path_time_log, True, format_vector, save_results_intermediate, overwrite ) ## Erreur NaN pour polygones entièrement bâtis (soucis pour la suite ?) renameFieldsVector(grid_output, ['mean'], [SKY_VIEW_FIELD], format_vector) ########################################## ### Nettoyage des fichiers temporaires ### ########################################## if not save_results_intermediate: deleteDir(temp_path) else: print(bold + magenta + "Le calcul du Sky View Factor a déjà eu lieu." + endC + "\n") print(bold + yellow + "Fin du calcul de l'indicateur Sky View Factor." + endC + "\n") timeLine(path_time_log, "Fin du calcul de l'indicateur Sky View Factor : ") return
def sobelToOuvrages(input_im_seuils_dico, output_dir, input_cut_vector, no_data_value, path_time_log, format_raster='GTiff', format_vector="ESRI Shapefile", extension_raster=".tif", extension_vector=".shp", save_results_intermediate=True, overwrite=True): # Constantes REPERTORY_TEMP = "temp_sobel" CODAGE_8B = "uint8" ID = "id" # Mise à jour du Log starting_event = "sobelToOuvrages() : Select Sobel to ouvrages starting : " timeLine(path_time_log,starting_event) # Création du répertoire de sortie s'il n'existe pas déjà if not os.path.exists(output_dir + os.sep + REPERTORY_TEMP): os.makedirs(output_dir + os.sep + REPERTORY_TEMP) # Affichage des paramètres if debug >= 3: print(bold + green + "Variables dans SobelToOuvrages - Variables générales" + endC) print(cyan + "sobelToOuvrages() : " + endC + "input_im_seuils_dico : " + str(input_im_seuils_dico) + endC) print(cyan + "sobelToOuvrages() : " + endC + "output_dir : " + str(output_dir) + endC) print(cyan + "sobelToOuvrages() : " + endC + "input_cut_vector : " + str(input_cut_vector) + endC) print(cyan + "sobelToOuvrages() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "sobelToOuvrages() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "sobelToOuvrages() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "sobelToOuvrages() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "sobelToOuvrages() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "sobelToOuvrages() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "sobelToOuvrages() : " + endC + "overwrite : " + str(overwrite) + endC) sobel_ouvrages_shp_list = [] for elt in input_im_seuils_dico.split(): raw_image = elt.split(":")[0] sobel_image = elt.split(":")[1].split(",")[0] for i in range(1,len(elt.split(":")[1].split(","))): seuil = elt.split(":")[1].split(",")[i] # Initialisation des noms des fichiers en sortie image_name = os.path.splitext(os.path.basename(raw_image))[0] sobel_binary_mask = output_dir + os.sep + REPERTORY_TEMP + os.sep + "bin_mask_sobel_" + image_name + "_" + str(seuil) + extension_raster sobel_binary_mask_vector_name = "bin_mask_vect_sobel_" + image_name + "_" + str(seuil) sobel_binary_mask_vector = output_dir + os.sep + REPERTORY_TEMP + os.sep + sobel_binary_mask_vector_name + extension_vector sobel_binary_mask_vector_cleaned = output_dir + os.sep + REPERTORY_TEMP + os.sep + "bin_mask_vect_sobel_cleaned_" + image_name + "_" + str(seuil) + extension_vector sobel_decoup = output_dir + os.sep + "sobel_decoup_" + image_name + "_" + str(seuil) + extension_vector binary_mask_zeros_name = "b_mask_zeros_vect_" + image_name binary_mask_zeros_raster = output_dir + os.sep + REPERTORY_TEMP + os.sep + "b_mask_zeros_" + image_name + extension_raster binary_mask_zeros_vector = output_dir + os.sep + REPERTORY_TEMP + os.sep + binary_mask_zeros_name + extension_vector binary_mask_zeros_vector_simpl = output_dir + os.sep + REPERTORY_TEMP + os.sep + "b_mask_zeros_vect_simpl_" + image_name + extension_vector true_values_buffneg = output_dir + os.sep + REPERTORY_TEMP + os.sep + "true_values_buffneg_" + image_name + extension_vector ouvrages_decoup_final = output_dir + os.sep + "ouvrages_sobel_" + image_name + "_" + str(seuil) + extension_vector # Création du masque binaire createBinaryMask(sobel_image, sobel_binary_mask, float(seuil), True) # Découpe du masque binaire par le shapefile de découpe en entrée cutImageByVector(input_cut_vector, sobel_binary_mask, sobel_decoup, None, None, no_data_value, 0, format_raster, format_vector) # Vectorisation du masque binaire Sobel découpé polygonizeRaster(sobel_decoup, sobel_binary_mask_vector, sobel_binary_mask_vector_name) # Création masque binaire pour séparer les no data des vraies valeurs nodata_value = getNodataValueImage(raw_image) if no_data_value == None : no_data_value = 0 createBinaryMaskMultiBand(raw_image, binary_mask_zeros_raster, no_data_value, CODAGE_8B) # Vectorisation du masque binaire true data/false data -> polygone avec uniquement les vraies valeurs if os.path.exists(binary_mask_zeros_vector): removeVectorFile(binary_mask_zeros_vector, format_vector) # Polygonisation polygonizeRaster(binary_mask_zeros_raster, binary_mask_zeros_vector, binary_mask_zeros_name, ID, format_vector) # Simplification du masque obtenu simplifyVector(binary_mask_zeros_vector, binary_mask_zeros_vector_simpl, 2, format_vector) # Buffer négatif sur ce polygone bufferVector(binary_mask_zeros_vector_simpl, true_values_buffneg, -2, "", 1.0, 10, format_vector) cleanMiniAreaPolygons(sobel_binary_mask_vector, sobel_binary_mask_vector_cleaned, 15, ID, format_vector) # Découpe par le buffer négatif autour des true data cutVectorAll(true_values_buffneg, sobel_binary_mask_vector_cleaned, ouvrages_decoup_final, overwrite, format_vector) sobel_ouvrages_shp_list.append(ouvrages_decoup_final) return sobel_ouvrages_shp_list
def createDifference(image_ortho_input, image_mns_input, image_mnt_input, bd_vector_input_list, zone_buffer_dico, departments_list, image_difference_output, vector_difference_output, fileld_bd_raster, simplifie_param, threshold_ndvi, threshold_difference, filter_difference_0, filter_difference_1, path_time_log, format_vector='ESRI Shapefile', extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, channel_order=['Red', 'Green', 'Blue', 'NIR'], overwrite=True): # Mise à jour du Log starting_event = "createDifference() : create macro samples starting : " timeLine(path_time_log, starting_event) # constantes CODAGE = "float" FOLDER_MASK_TEMP = 'Mask_' FOLDER_CUTTING_TEMP = 'Cut_' FOLDER_BUFF_TEMP = 'Buff_' FOLDER_RESULT_TEMP = 'Tmp_' SUFFIX_MASK_CRUDE = '_mcrude' SUFFIX_MASK = '_mask' SUFFIX_FILTERED = '_filtered' SUFFIX_VECTOR_CUT = '_decoup' SUFFIX_VECTOR_BUFF = '_buff' SUFFIX_NEW_MNS = '_new_mns' SUFFIX_DIFF_MNS = '_diff_mns' SUFFIX_NDVI = '_ndvi' # print if debug >= 3: print(bold + green + "Variables dans la fonction" + endC) print(cyan + "createDifference() : " + endC + "image_ortho_input : " + str(image_ortho_input) + endC) print(cyan + "createDifference() : " + endC + "image_mns_input : " + str(image_mns_input) + endC) print(cyan + "createDifference() : " + endC + "image_mnt_input : " + str(image_mnt_input) + endC) print(cyan + "createDifference() : " + endC + "bd_vector_input_list : " + str(bd_vector_input_list) + endC) print(cyan + "createDifference() : " + endC + "zone_buffer_dico : " + str(zone_buffer_dico) + endC) print(cyan + "createDifference() : " + endC + "departments_list : " + str(departments_list) + endC) print(cyan + "createDifference() : " + endC + "image_difference_output : " + str(image_difference_output) + endC) print(cyan + "createDifference() : " + endC + "vector_difference_output : " + str(vector_difference_output) + endC) print(cyan + "createDifference() : " + endC + "fileld_bd_raster : " + str(fileld_bd_raster) + endC) print(cyan + "createDifference() : " + endC + "simplifie_param : " + str(simplifie_param) + endC) print(cyan + "createDifference() : " + endC + "threshold_ndvi : " + str(threshold_ndvi) + endC) print(cyan + "createDifference() : " + endC + "threshold_difference : " + str(threshold_difference) + endC) print(cyan + "createDifference() : " + endC + "filter_difference_0 : " + str(filter_difference_0) + endC) print(cyan + "createDifference() : " + endC + "filter_difference_1 : " + str(filter_difference_1) + endC) print(cyan + "createDifference() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "createDifference() : " + endC + "channel_order : " + str(channel_order) + endC) print(cyan + "createDifference() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "createDifference() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "createDifference() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "createDifference() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "createDifference() : " + endC + "overwrite : " + str(overwrite) + endC) # ETAPE 1 : NETTOYER LES DONNEES EXISTANTES print(cyan + "createDifference() : " + bold + green + "NETTOYAGE ESPACE DE TRAVAIL..." + endC) # Nom de base de l'image image_name = os.path.splitext(os.path.basename(image_ortho_input))[0] # Test si le fichier résultat différence existe déjà et si il doit être écrasés check = os.path.isfile(vector_difference_output) if check and not overwrite: # Si le fichier difference existe deja et que overwrite n'est pas activé print(cyan + "createDifference() : " + bold + yellow + "File difference " + vector_difference_output + " already exists and will not be created again." + endC) else: if check: try: removeFile(vector_difference_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_output = os.path.dirname(vector_difference_output) repertory_output_temp = repertory_output + os.sep + FOLDER_RESULT_TEMP + image_name repertory_mask_temp = repertory_output + os.sep + FOLDER_MASK_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 print(repertory_output_temp) print(repertory_mask_temp) print(repertory_samples_cutting_temp) print(repertory_samples_buff_temp) # Création des répertoires temporaire qui n'existent pas if not os.path.isdir(repertory_output_temp): os.makedirs(repertory_output_temp) 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_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_buff_temp) cleanTempData(repertory_output_temp) BD_topo_layers_list = [] #zone = zone_buffer_dico.keys()[0] zone = list(zone_buffer_dico)[0] # Creation liste des couches des bd exogenes utilisées for layers_buffer in zone_buffer_dico[zone]: BD_topo_layers_list.append(layers_buffer[0]) print(cyan + "createDifference() : " + bold + green + "... FIN NETTOYAGE" + endC) # ETAPE 2 : DECOUPER LES VECTEURS print(cyan + "createDifference() : " + bold + green + "DECOUPAGE ECHANTILLONS..." + endC) # 2.1 : Création du masque 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_ortho_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, simplifie_param, format_vector) # 2.3 : Découpage des vecteurs copiés en local avec le masque vector_output_list = [] for vector_input in bd_vector_input_list: vector_name = os.path.splitext(os.path.basename(vector_input))[0] extension = os.path.splitext(os.path.basename(vector_input))[1] vector_output = repertory_samples_cutting_temp + os.sep + vector_name + SUFFIX_VECTOR_CUT + extension vector_output_list.append(vector_output) cutoutVectors(vector_simple_mask, bd_vector_input_list, vector_output_list, format_vector) print(cyan + "createDifference() : " + bold + green + "...FIN DECOUPAGE" + endC) # ETAPE 3 : BUFFERISER LES VECTEURS print(cyan + "createDifference() : " + bold + green + "MISE EN PLACE DES TAMPONS..." + endC) # Parcours du dictionnaire associant la zone aux noms de fichiers et aux tampons associés for elem_buff in zone_buffer_dico[zone]: # Parcours des départements for dpt in departments_list: input_shape = repertory_samples_cutting_temp + os.sep + elem_buff[ 0] + "_" + dpt + SUFFIX_VECTOR_CUT + extension_vector output_shape = repertory_samples_buff_temp + os.sep + elem_buff[ 0] + "_" + dpt + SUFFIX_VECTOR_BUFF + extension_vector buff = elem_buff[1] if os.path.isfile(input_shape): if debug >= 3: print(cyan + "createDifference() : " + endC + "input_shape : " + str(input_shape) + endC) print(cyan + "createDifference() : " + endC + "output_shape : " + str(output_shape) + endC) print(cyan + "createDifference() : " + endC + "buff : " + str(buff) + endC) bufferVector(input_shape, output_shape, buff, "", 1.0, 10, format_vector) else: print(cyan + "createDifference() : " + bold + yellow + "Pas de fichier du nom : " + endC + input_shape) print(cyan + "createDifference() : " + bold + green + "FIN DE L AFFECTATION DES TAMPONS" + endC) # ETAPE 4 : FUSION DES SHAPES DE LA BD TOPO print(cyan + "createDifference() : " + bold + green + "FUSION DATA BD..." + endC) shape_buff_list = [] # Parcours du dictionnaire associant la zone au nom du fichier for elem_buff in zone_buffer_dico[zone]: # Parcours des départements for dpt in departments_list: shape_file = repertory_samples_buff_temp + os.sep + elem_buff[ 0] + "_" + dpt + SUFFIX_VECTOR_BUFF + extension_vector if os.path.isfile(shape_file): shape_buff_list.append(shape_file) print("file for fusion : " + shape_file) else: print(bold + yellow + "pas de fichiers avec ce nom : " + endC + shape_file) # si une liste de fichier shape existe if not shape_buff_list: print(bold + yellow + "Pas de fusion sans donnee a fusionnee" + endC) else: # Fusion des fichiers shape image_zone_shape = repertory_output_temp + os.sep + image_name + '_' + zone + extension_vector fusionVectors(shape_buff_list, image_zone_shape) print("File BD : " + image_zone_shape) print(cyan + "createDifference() : " + bold + green + "FIN DE LA FUSION" + endC) # ETAPE 5 : RASTERISER LE FICHIER SHAPE DE ZONE BD print(cyan + "createDifference() : " + bold + green + "RASTERIZATION DE LA FUSION..." + endC) image_zone_raster = repertory_output_temp + os.sep + image_name + '_' + zone + extension_raster rasterizeVector(image_zone_shape, image_zone_raster, image_ortho_input, fileld_bd_raster, codage=CODAGE) print(cyan + "createDifference() : " + bold + green + "FIN DE LA RASTERIZATION" + endC) # ETAPE 6 : CREER UN NOUVEAU MMS ISSU DU MNT + DATA BD_TOPO print(cyan + "createDifference() : " + bold + green + "CREATION NOUVEAU MNS..." + endC) image_new_mns_output = repertory_output_temp + os.sep + image_name + SUFFIX_NEW_MNS + extension_raster createMNS(image_ortho_input, image_mnt_input, image_zone_raster, image_new_mns_output) print(cyan + "createDifference() : " + bold + green + "FIN DE LA CREATION MNS" + endC) # ETAPE 7 : CREER D'UN MASQUE SUR LES ZONES VEGETALES print(cyan + "createDifference() : " + bold + green + "CREATION DU NDVI..." + endC) image_ndvi_output = repertory_output_temp + os.sep + image_name + SUFFIX_NDVI + extension_raster createNDVI(image_ortho_input, image_ndvi_output, channel_order) print(cyan + "createDifference() : " + bold + green + "FIN DE LA CREATION DU NDVI" + endC) print(cyan + "createDifference() : " + bold + green + "CREATION DU MASQUE NDVI..." + endC) image_ndvi_mask_output = repertory_output_temp + os.sep + image_name + SUFFIX_NDVI + SUFFIX_MASK + extension_raster createBinaryMask(image_ndvi_output, image_ndvi_mask_output, threshold_ndvi, False) print(cyan + "createDifference() : " + bold + green + "FIN DE LA CREATION DU MASQUE NDVI" + endC) # ETAPE 8 : CREER UN FICHIER DE DIFFERENCE DES MNS AVEC MASQUAGE DES ZONES VEGETALES print(cyan + "createDifference() : " + bold + green + "CREATION DIFFERENCE MNS..." + endC) #image_diff_mns_output = repertory_output + os.sep + image_name + SUFFIX_DIFF_MNS + extension_raster image_diff_mns_output = image_difference_output createDifferenceFile(image_mns_input, image_new_mns_output, image_ndvi_mask_output, image_diff_mns_output) print(cyan + "createDifference() : " + bold + green + "FIN DE LA CREATION DE LA DIFFERENCE MNS" + endC) print(cyan + "createDifference() : " + bold + green + "CREATION DU MASQUE DE DIFFERENCE..." + endC) image_diff_mns_mask_output = repertory_output_temp + os.sep + image_name + SUFFIX_DIFF_MNS + SUFFIX_MASK + extension_raster createBinaryMask(image_diff_mns_output, image_diff_mns_mask_output, threshold_difference, True) print(cyan + "createDifference() : " + bold + green + "FIN DE LA CREATION DU MASQUE DE DIFFERENCE" + endC) print(cyan + "createDifference() : " + bold + green + "FILTRAGE DU MASQUE DE DIFFERENCE..." + endC) image_diff_mns_filtered_output = repertory_output_temp + os.sep + image_name + SUFFIX_DIFF_MNS + SUFFIX_FILTERED + extension_raster filterBinaryRaster(image_diff_mns_mask_output, image_diff_mns_filtered_output, filter_difference_0, filter_difference_1) print(cyan + "createDifference() : " + bold + green + "FIN DU FILTRAGE DU MASQUE DE DIFFERENCE" + endC) # ETAPE 9 : RASTERISER LE FICHIER DE DIFFERENCE DES MNS print(cyan + "createDifference() : " + bold + green + "VECTORISATION DU RASTER DE DIFFERENCE..." + endC) vector_diff_mns_filtered_output = repertory_output_temp + os.sep + image_name + SUFFIX_DIFF_MNS + SUFFIX_FILTERED + extension_vector polygonizeRaster(image_diff_mns_filtered_output, vector_diff_mns_filtered_output, image_name, field_name="DN") print(cyan + "createDifference() : " + bold + green + "FIN DE VECTORISATION DU RASTER DE DIFFERENCE" + endC) print(cyan + "createDifference() : " + bold + green + "SIMPLIFICATION VECTEUR DE DIFFERENCE..." + endC) simplifyVector(vector_diff_mns_filtered_output, vector_difference_output, simplifie_param, format_vector) print(cyan + "createDifference() : " + bold + green + "FIN DE SIMPLIFICATION DI VECTEUR DE DIFFERENCE" + endC) # ETAPE 10 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES if not save_results_intermediate: # Supression des .geom dans le dossier for to_delete in glob.glob(repertory_mask_temp + os.sep + "*.geom"): removeFile(to_delete) # Suppression des repertoires temporaires deleteDir(repertory_mask_temp) deleteDir(repertory_samples_cutting_temp) deleteDir(repertory_samples_buff_temp) deleteDir(repertory_output_temp) # Mise à jour du Log ending_event = "createDifference() : create macro samples ending : " timeLine(path_time_log, ending_event) return
def cutRasterImages(images_input_list, vector_cut, images_output_list, buffer_size, round_pixel_size, epsg, no_data_value, resampling_methode, z_compress, 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 = "cutRasterImages() : Cutting rasters and vector starting : " timeLine(path_time_log, starting_event) print(endC) print(bold + green + "## START : CUTTING IMAGES" + endC) print(endC) if debug >= 2: print(bold + green + "cutRasterImages() : Variables dans la fonction" + endC) print(cyan + "cutRasterImages() : " + endC + "images_input_list : " + str(images_input_list) + endC) print(cyan + "cutRasterImages() : " + endC + "vector_cut : " + str(vector_cut) + endC) print(cyan + "cutRasterImages() : " + endC + "images_output_list : " + str(images_output_list) + endC) print(cyan + "cutRasterImages() : " + endC + "buffer_size : " + str(buffer_size) + endC) print(cyan + "cutRasterImages() : " + endC + "round_pixel_size : " + str(round_pixel_size) + endC) print(cyan + "cutRasterImages() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "cutRasterImages() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "cutRasterImages() : " + endC + "resampling_methode : " + str(resampling_methode)) print(cyan + "cutRasterImages() : " + endC + "z_compress : " + str(z_compress)) print(cyan + "cutRasterImages() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "cutRasterImages() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "cutRasterImages() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "cutRasterImages() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "cutRasterImages() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "cutRasterImages() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "cutRasterImages() : " + endC + "overwrite : " + str(overwrite) + endC) # PREPARATION DES FICHIERS INTERMEDIAIRES BUFF_SUFFIX = "_buf" CUT_SUFFIX = "_cut" COMPRESS_SUFFIX = "_compress" EPSG_DEFAULT = 2154 if buffer_size > 0 and len( images_input_list ) > 0: # Cas le vecteur de découpe des rasteurs est bufferisé vector_buf_for_raster_cut = os.path.splitext( vector_cut)[0] + BUFF_SUFFIX + str(int(round( buffer_size, 0))) + 'm' + extension_vector if debug >= 3: print("vector_buf_for_raster_cut : " + str(vector_buf_for_raster_cut) + endC) # Test si le vecteur decoupe existe déjà et si il doit être écrasés check = os.path.isfile(vector_buf_for_raster_cut) if check and not overwrite: # Si le fichier existe deja et que overwrite n'est pas activé print(bold + yellow + "File vector cutting : " + vector_buf_for_raster_cut + " already exists and will not be created again." + endC) else: if check: try: removeVectorFile(vector_buf_for_raster_cut) except Exception: pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée # Création du vecteur de découpe bufferisé bufferVector(vector_cut, vector_buf_for_raster_cut, buffer_size, "", 1.0, 10, format_vector) else: # Cas le vecteur de découpe des rasteurs n'est pas bufferisé idem vecteur de découpe que les vecteurs vector_buf_for_raster_cut = vector_cut # DECOUPAGE DES RASTEURS PAR LE VECTEUR DE DECOUPE # Pour tous les fichiers raster à découpper for index_raster in range(len(images_input_list)): # Préparation des rasters de travail d'entrée et de sortie raster_input = images_input_list[index_raster] raster_output = images_output_list[index_raster] raster_output_compress = os.path.splitext( raster_output)[0] + COMPRESS_SUFFIX + extension_raster vector_cut_temp = os.path.splitext( raster_output)[0] + CUT_SUFFIX + extension_vector if debug >= 1: print("\n") print(cyan + "cutRasterImages() : " + endC + bold + green + "Découpe fichier raster : " + endC + str(raster_input) + endC) # Récuperation de l'emprise de l'image ima_xmin, ima_xmax, ima_ymin, ima_ymax = getEmpriseImage(raster_input) # Recuperation de la valeur de l'arrondi de la taille des pixels en X et Y si non définie if round_pixel_size == 0.0 and os.path.isfile(raster_input): # Identification de la tailles de pixels en x et en y pixel_size_x, pixel_size_y = getPixelWidthXYImage(raster_input) round_pixel_size = abs(pixel_size_x) else: pixel_size_x = round_pixel_size pixel_size_y = round_pixel_size # Préparation du vecteur de découpe temporaire createEmpriseShapeReduced(vector_buf_for_raster_cut, ima_xmin, ima_ymin, ima_xmax, ima_ymax, vector_cut_temp, format_vector) # Identification de l'emprise de vecteur de découpe empr_xmin, empr_xmax, empr_ymin, empr_ymax = getEmpriseFile( vector_cut_temp, format_vector) # Calculer l'emprise arrondi xmin, xmax, ymin, ymax = roundPixelEmpriseSize(pixel_size_x, pixel_size_y, empr_xmin, empr_xmax, empr_ymin, empr_ymax) # Trouver l'emprise optimale opt_xmin = xmin opt_xmax = xmax opt_ymin = ymin opt_ymax = ymax if ima_xmin > xmin: opt_xmin = ima_xmin if ima_xmax < xmax: opt_xmax = ima_xmax if ima_ymin > ymin: opt_ymin = ima_ymin if ima_ymax < ymax: opt_ymax = ima_ymax # Récuperation de la projection de l'image if epsg == 0: epsg_proj = getProjectionImage(raster_input) else: epsg_proj = epsg if epsg_proj == 0: epsg_proj = EPSG_DEFAULT if debug >= 3: print("epsg : " + str(epsg_proj) + endC) print("\n") # Test si le rasteur de sortie existe déjà et si il doit être écrasés check = os.path.isfile(raster_output) if check and not overwrite: # Si le fichier existe deja et que overwrite n'est pas activé print(bold + yellow + "File raster output : " + raster_output + " already exists and will not be created again." + endC) else: if check: try: removeFile(raster_output) except Exception: pass # si le fichier n'existe pas, il ne peut pas être supprimé : cette étape est ignorée # Commande de découpe raster command = 'gdalwarp -t_srs EPSG:' + str(epsg_proj) + ' -te ' + str( opt_xmin ) + ' ' + str(opt_ymin) + ' ' + str(opt_xmax) + ' ' + str( opt_ymax ) + ' -tap -multi -co "NUM_THREADS=ALL_CPUS" -dstnodata ' + str( no_data_value ) + ' -tr ' + str(abs(pixel_size_x)) + ' ' + str( abs(pixel_size_y) ) + ' -cutline ' + vector_cut_temp + ' -of ' + format_raster + ' ' + raster_input + ' ' + raster_output if resampling_methode != "": command += " -r " + resampling_methode if overwrite: command += ' -overwrite' if debug >= 2: print(bold + green + "Command : " + command + endC) exit_code = os.system(command) if exit_code != 0: print( cyan + "cutRasterImages() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + raster_input + ". Voir message d'erreur." + endC, file=sys.stderr) raise if debug >= 2: print(cyan + "cutRasterImages() : " + bold + green + "DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" % (raster_input, vector_buf_for_raster_cut) + endC) print(command) if z_compress: # Commande de découpe raster et compression command = 'gdalwarp -t_srs EPSG:' + str( epsg_proj ) + ' -te ' + str(opt_xmin) + ' ' + str(opt_ymin) + ' ' + str( opt_xmax ) + ' ' + str( opt_ymax ) + ' -tap -multi -co "NUM_THREADS=ALL_CPUS" -dstnodata ' + str( no_data_value ) + ' -tr ' + str(abs(pixel_size_x)) + ' ' + str( abs(pixel_size_y) ) + ' -co "COMPRESS=DEFLATE" -co "PREDICTOR=2" -co "ZLEVEL=9" -cutline ' + vector_cut_temp + ' -of ' + format_raster + ' ' + raster_input + ' ' + raster_output_compress if resampling_methode != "": command += ' -r ' + resampling_methode if overwrite: command += ' -overwrite' if debug >= 2: print(bold + green + "Command : " + command + endC) exit_code = os.system(command) if exit_code != 0: print( cyan + "cutRasterImages() : " + bold + red + "!!! Une erreur c'est produite au cours du decoupage de l'image : " + raster_input + ". Voir message d'erreur." + endC, file=sys.stderr) raise if debug >= 2: print( cyan + "cutRasterImages() : " + bold + green + "DECOUPAGE ET COMPRESSION DU RASTER %s AVEC LE VECTEUR %s" % (raster_input, vector_buf_for_raster_cut) + endC) print(command) # Suppression des fichiers intermédiaires removeVectorFile(vector_cut_temp) # SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des fichiers intermédiaires if not save_results_intermediate and os.path.isfile( vector_buf_for_raster_cut ) and vector_buf_for_raster_cut != vector_cut: removeVectorFile(vector_buf_for_raster_cut) print(endC) print(bold + green + "## END : CUTTING IMAGES" + endC) print(endC) # Mise à jour du Log ending_event = "cutRasterImages() : Cutting rasters and vector 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