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 comparareClassificationToReferenceGrid(image_input, vector_cut_input, vector_sample_input, vector_grid_input, vector_grid_output, size_grid, field_value_verif, no_data_value, path_time_log, epsg=2154, format_raster='GTiff', format_vector="ESRI Shapefile", extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "comparareClassificationToReferenceGrid() : starting : " timeLine(path_time_log, starting_event) print(endC) print(bold + green + "## START : COMPARE QUALITY FROM CLASSIF IMAGE BY GRID" + endC) print(endC) if debug >= 2: print( bold + green + "comparareClassificationToReferenceGrid() : Variables dans la fonction" + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "vector_cut_input : " + str(vector_cut_input) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "vector_sample_input : " + str(vector_sample_input) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "vector_grid_input : " + str(vector_grid_input) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "vector_grid_output : " + str(vector_grid_output) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "size_grid : " + str(size_grid) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "field_value_verif : " + str(field_value_verif)) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "no_data_value : " + str(no_data_value)) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "comparareClassificationToReferenceGrid() : " + endC + "overwrite : " + str(overwrite) + endC) # ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES' CODAGE = "uint16" SUFFIX_STUDY = '_study' SUFFIX_TEMP = '_temp' SUFFIX_FUSION = '_other_fusion' NONE_VALUE_QUANTITY = -1.0 FIELD_VALUE_OTHER = 65535 FIELD_NAME_ID = "id" FIELD_NAME_RATE_BUILD = "rate_build" FIELD_NAME_RATE_OTHER = "rate_other" FIELD_NAME_SREF_BUILD = "sref_build" FIELD_NAME_SCLA_BUILD = "scla_build" FIELD_NAME_SREF_OTHER = "sref_other" FIELD_NAME_SCLA_OTHER = "scla_other" FIELD_NAME_KAPPA = "kappa" FIELD_NAME_ACCURACY = "accuracy" pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input) repertory_output = os.path.dirname(vector_grid_output) base_name = os.path.splitext(os.path.basename(vector_grid_output))[0] vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector vector_grid_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector image_raster_other_fusion = repertory_output + os.sep + base_name + SUFFIX_FUSION + extension_raster # ETAPE 0 : VERIFICATION # Verification de la valeur de la nomemclature à verifier if field_value_verif >= FIELD_VALUE_OTHER: print( cyan + "comparareClassificationToReferenceGrid() : " + bold + red + "Attention de valeur de nomenclature à vérifier : " + str(field_value_verif) + " doit être inferieur à la valeur de fusion des valeur autre arbitraire de : " + str(FIELD_VALUE_OTHER) + endC, file=sys.stderr) sys.exit(1) #exit with an error code # 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 : UNIFORMISATION DE LA ZONE OTHER # Réalocation des valeurs de classification pour les valeurs autre que le bati change_reaff_value_list = [] reaff_value_list = identifyPixelValues(image_input) if field_value_verif in reaff_value_list: reaff_value_list.remove(field_value_verif) if no_data_value in reaff_value_list: reaff_value_list.remove(no_data_value) for elem in reaff_value_list: change_reaff_value_list.append(FIELD_VALUE_OTHER) reallocateClassRaster(image_input, image_raster_other_fusion, reaff_value_list, change_reaff_value_list) # ETAPE 3 : CREATION DE LA GRILLE SUR LA ZONE D'ETUDE # Définir les attibuts du fichier attribute_dico = { FIELD_NAME_ID: ogr.OFTInteger, FIELD_NAME_RATE_BUILD: ogr.OFTReal, FIELD_NAME_RATE_OTHER: ogr.OFTReal, FIELD_NAME_SREF_BUILD: ogr.OFTReal, FIELD_NAME_SCLA_BUILD: ogr.OFTReal, FIELD_NAME_SREF_OTHER: ogr.OFTReal, FIELD_NAME_SCLA_OTHER: ogr.OFTReal, FIELD_NAME_KAPPA: ogr.OFTReal, FIELD_NAME_ACCURACY: ogr.OFTReal } nb_polygon = 0 if (not vector_grid_input is None) and (vector_grid_input != "") and ( os.path.isfile(vector_grid_input)): # Utilisation du fichier grille d'entrée # Recopie du fichier grille d'entrée vers le fichier grille de sortie copyVectorFile(vector_grid_input, vector_grid_output) # Ajout des champs au fichier grille de sortie for field_name in attribute_dico: addNewFieldVector(vector_grid_output, field_name, attribute_dico[field_name], None, None, None, format_vector) # Mettre le champs "id" identifiant du carré de l'élément de la grille nb_polygon = updateIndexVector(vector_grid_output, FIELD_NAME_ID, format_vector) else: # Si il n'existe pas de fichier grille on en créer un avec la valeur de size_grid # Creer le fichier grille nb_polygon = createGridVector(vector_study, vector_grid_temp, size_grid, size_grid, attribute_dico, overwrite, epsg, format_vector) # Découper la grille avec le shape zone d'étude cutVectorAll(vector_study, vector_grid_temp, vector_grid_output, format_vector) # ETAPE 4 : CALCUL DE L'INDICATEUR DE QUALITE POUR CHAQUE CASE DE LA GRILLE if debug >= 2: print(bold + "nb_polygon = " + endC + str(nb_polygon) + "\n") # Pour chaque polygone existant sum_rate_quantity_build = 0 nb_rate_sum = 0 size_area_pixel = abs(pixel_size_x * pixel_size_y) for id_polygon in range(nb_polygon): geom_list = getGeomPolygons(vector_grid_output, FIELD_NAME_ID, id_polygon, format_vector) if geom_list is not None and geom_list != []: # and (id_polygon == 24 or id_polygon == 30): if debug >= 1: print(cyan + "comparareClassificationToReferenceGrid() : " + bold + green + "Calcul de la matrice pour le polygon n°: " + str(id_polygon) + endC) geom = geom_list[0] class_ref_list, class_pro_list, rate_quantity_list, kappa, accuracy, matrix = computeQualityIndiceRateQuantity( image_raster_other_fusion, vector_sample_input, repertory_output, base_name + str(id_polygon), geom, size_grid, pixel_size_x, pixel_size_y, field_value_verif, FIELD_VALUE_OTHER, no_data_value, epsg, format_raster, format_vector, extension_raster, extension_vector, overwrite, save_results_intermediate) # Si les calculs indicateurs de qualité sont ok if debug >= 2: print(matrix) if matrix != None and matrix != [] and matrix[0] != []: # Récuperer la quantité de bati et calcul de la surface de référence et de la surface de classification (carreau entier ou pas!) if len(class_ref_list) == 2 and len( class_pro_list ) == 2: # Cas ou l'on a des pixels de build et other (en ref et en prod) rate_quantity_build = rate_quantity_list[0] rate_quantity_other = rate_quantity_list[1] size_area_ref_build = (matrix[0][0] + matrix[0][1]) * size_area_pixel size_area_classif_build = (matrix[0][0] + matrix[1][0]) * size_area_pixel size_area_ref_other = (matrix[1][0] + matrix[1][1]) * size_area_pixel size_area_classif_other = (matrix[0][1] + matrix[1][1]) * size_area_pixel sum_rate_quantity_build += rate_quantity_build nb_rate_sum += 1 else: # Cas ou l'on a uniquement des pixels de build OU uniquement des pixels de other if class_ref_list[ 0] == field_value_verif: # Cas ou l'on a uniquement des pixels references build rate_quantity_build = rate_quantity_list[0] rate_quantity_other = NONE_VALUE_QUANTITY size_area_ref_other = 0 if len( class_pro_list ) == 2: # Cas ou l'on a des pixels de prod build et other size_area_ref_build = ( matrix[0][0] + matrix[0][1]) * size_area_pixel size_area_classif_build = matrix[0][ 0] * size_area_pixel size_area_classif_other = matrix[0][ 1] * size_area_pixel else: size_area_ref_build = matrix[0][0] * size_area_pixel if class_pro_list[ 0] == field_value_verif: # Cas ou l'on a uniquement des pixels prod build size_area_classif_build = matrix[0][ 0] * size_area_pixel size_area_classif_other = 0 else: # Cas ou l'on a uniquement des pixels prod other size_area_classif_build = 0 size_area_classif_other = matrix[0][ 0] * size_area_pixel else: # Cas ou l'on a uniquement des pixels references other rate_quantity_build = NONE_VALUE_QUANTITY rate_quantity_other = rate_quantity_list[0] size_area_ref_build = 0 if len( class_pro_list ) == 2: # Cas ou l'on a des pixels de prod build et other size_area_ref_other = ( matrix[0][0] + matrix[0][1]) * size_area_pixel size_area_classif_build = matrix[0][ 0] * size_area_pixel size_area_classif_other = matrix[0][ 1] * size_area_pixel else: size_area_ref_other = matrix[0][0] * size_area_pixel if class_pro_list[ 0] == field_value_verif: # Cas ou l'on a uniquement des pixels prod build size_area_classif_build = matrix[0][ 0] * size_area_pixel size_area_classif_other = 0 else: # Cas ou l'on a uniquement des pixels prod other size_area_classif_build = 0 size_area_classif_other = matrix[0][ 0] * size_area_pixel # Mettre à jour ses éléments du carré de la grille setAttributeValues( vector_grid_output, FIELD_NAME_ID, id_polygon, { FIELD_NAME_RATE_BUILD: rate_quantity_build, FIELD_NAME_RATE_OTHER: rate_quantity_other, FIELD_NAME_SREF_BUILD: size_area_ref_build, FIELD_NAME_SCLA_BUILD: size_area_classif_build, FIELD_NAME_SREF_OTHER: size_area_ref_other, FIELD_NAME_SCLA_OTHER: size_area_classif_other, FIELD_NAME_KAPPA: kappa, FIELD_NAME_ACCURACY: accuracy }, format_vector) # Calcul de la moyenne if nb_rate_sum != 0: average_quantity_build = sum_rate_quantity_build / nb_rate_sum else: average_quantity_build = 0 if debug >= 2: print(bold + "nb_polygon_used = " + endC + str(nb_rate_sum)) print(bold + "average_quantity_build = " + endC + str(average_quantity_build) + "\n") # ETAPE 5 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des données intermédiairess if not save_results_intermediate: if not cutting_action: if os.path.isfile(vector_study): removeVectorFile(vector_study) if os.path.isfile(image_raster_other_fusion): removeFile(image_raster_other_fusion) if os.path.isfile(vector_grid_temp): removeVectorFile(vector_grid_temp) print(endC) print(bold + green + "## END : COMPARE QUALITY FROM CLASSIF IMAGE BY GRID" + endC) print(endC) # Mise à jour du Log ending_event = "comparareClassificationToReferenceGrid() : ending : " timeLine(path_time_log, ending_event) return average_quantity_build
def classesOfWaterHeights(input_flooded_areas_vector, input_digital_elevation_model_file, output_heights_classes_file, output_heights_classes_vector, heights_classes='0,0.5,1,1.5,2', epsg=2154, no_data_value=0, format_raster='GTiff', format_vector='ESRI Shapefile', extension_raster='.tif', extension_vector='.shp', grass_gisbase=os.environ['GISBASE'], grass_gisdb='GRASS_database', grass_location='LOCATION', grass_mapset='MAPSET', path_time_log='', save_results_intermediate=False, overwrite=True): if debug >= 3: print('\n' + bold + green + "Classes de hauteurs d'eau - Variables dans la fonction :" + endC) print(cyan + " classesOfWaterHeights() : " + endC + "input_flooded_areas_vector : " + str(input_flooded_areas_vector) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "input_digital_elevation_model_file : " + str(input_digital_elevation_model_file) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "output_heights_classes_file : " + str(output_heights_classes_file) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "output_heights_classes_vector : " + str(output_heights_classes_vector) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "heights_classes : " + str(heights_classes) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "grass_gisbase : " + str(grass_gisbase) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "grass_gisdb : " + str(grass_gisdb) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "grass_location : " + str(grass_location) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "grass_mapset : " + str(grass_mapset) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + " classesOfWaterHeights() : " + endC + "overwrite : " + str(overwrite) + endC + '\n') # Définition des constantes ENCODING_RASTER_FLOAT = 'float' ENCODING_RASTER_UINT8 = 'uint8' EXTENSION_RASTER_SAGA = '.sdat' FORMAT_VECTOR_GRASS = format_vector.replace(' ', '_') SUFFIX_TEMP = '_temp' SUFFIX_LINES = '_lines' SUFFIX_POINTS = '_points' SUFFIX_ALTI = '_altitude' SUFFIX_CUT = '_cut' SUFFIX_RAW = '_raw_heights' INDEX_FIELD = 'idx' ALTI_FIELD = 'altitude' VECTORISATION = 'GRASS' # Mise à jour du log starting_event = "classesOfWaterHeights() : Début du traitement : " timeLine(path_time_log, starting_event) print(cyan + "classesOfWaterHeights() : " + bold + green + "DEBUT DES TRAITEMENTS" + endC + '\n') # Définition des variables 'basename' flooded_areas_basename = os.path.splitext( os.path.basename(input_flooded_areas_vector))[0] digital_elevation_model_basename = os.path.splitext( os.path.basename(input_digital_elevation_model_file))[0] flooded_areas_lines_basename = flooded_areas_basename + SUFFIX_LINES flooded_areas_points_basename = flooded_areas_basename + SUFFIX_POINTS if output_heights_classes_file != "": output_heights_classes_basename = os.path.splitext( os.path.basename(output_heights_classes_file))[0] output_dirname = os.path.dirname(output_heights_classes_file) else: output_heights_classes_basename = os.path.splitext( os.path.basename(output_heights_classes_vector))[0] output_dirname = os.path.dirname(output_heights_classes_vector) # Définition des variables temp temp_directory = output_dirname + os.sep + output_heights_classes_basename + SUFFIX_TEMP flooded_areas_lines = temp_directory + os.sep + flooded_areas_lines_basename + extension_vector flooded_areas_points = temp_directory + os.sep + flooded_areas_points_basename + extension_vector altitude_points = temp_directory + os.sep + flooded_areas_points_basename + SUFFIX_ALTI + extension_vector altitude_grid = temp_directory + os.sep + flooded_areas_basename + SUFFIX_ALTI + EXTENSION_RASTER_SAGA altitude_file = temp_directory + os.sep + flooded_areas_basename + SUFFIX_ALTI + SUFFIX_CUT + extension_raster digital_elevation_model_cut = temp_directory + os.sep + digital_elevation_model_basename + SUFFIX_CUT + extension_raster raw_heights = temp_directory + os.sep + flooded_areas_basename + SUFFIX_RAW + extension_raster heights_classes_temp = temp_directory + os.sep + output_heights_classes_basename + extension_raster if output_heights_classes_file == "": output_heights_classes_file = output_dirname + os.sep + output_heights_classes_basename + extension_raster # Nettoyage des traitements précédents if debug >= 3: print(cyan + "classesOfWaterHeights() : " + endC + "Nettoyage des traitements précédents." + endC + '\n') removeFile(output_heights_classes_file) removeVectorFile(output_heights_classes_vector, format_vector=format_vector) cleanTempData(temp_directory) ############# # Etape 0/6 # Préparation des traitements ############# print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 0/6 - Début de la préparation des traitements." + endC + '\n') # Préparation de GRASS xmin, xmax, ymin, ymax = getEmpriseImage( input_digital_elevation_model_file) pixel_width, pixel_height = getPixelWidthXYImage( input_digital_elevation_model_file) grass_gisbase, grass_gisdb, grass_location, grass_mapset = initializeGrass( temp_directory, xmin, xmax, ymin, ymax, pixel_width, pixel_height, projection=epsg, gisbase=grass_gisbase, gisdb=grass_gisdb, location=grass_location, mapset=grass_mapset, clean_old=True, overwrite=overwrite) # Gestion des classes de hauteurs d'eau thresholds_list = heights_classes.split(',') thresholds_list_float = [float(x) for x in thresholds_list] thresholds_list_float.sort() thresholds_list_float_len = len(thresholds_list_float) print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 0/6 - Fin de la préparation des traitements." + endC + '\n') ############# # Etape 1/6 # Création de points sur le périmètre de l'emprise inondée ############# print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 1/6 - Début de la création de points sur le périmètre de l'emprise inondée." + endC + '\n') # Conversion de l'emprise inondée en polylignes convertePolygon2Polylines(input_flooded_areas_vector, flooded_areas_lines, overwrite=overwrite, format_vector=format_vector) # Création de points le long du polyligne use = 'vertex' dmax = 10 percent = False importVectorOgr2Grass(flooded_areas_lines, flooded_areas_lines_basename, overwrite=overwrite) pointsAlongPolylines(flooded_areas_lines_basename, flooded_areas_points_basename, use=use, dmax=dmax, percent=percent, overwrite=overwrite) exportVectorOgr2Grass(flooded_areas_points_basename, flooded_areas_points, format_vector=FORMAT_VECTOR_GRASS, overwrite=overwrite) # Ajout d'un index sur les points addNewFieldVector(flooded_areas_points, INDEX_FIELD, ogr.OFTInteger, field_value=None, field_width=None, field_precision=None, format_vector=format_vector) updateIndexVector(flooded_areas_points, index_name=INDEX_FIELD, format_vector=format_vector) print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 1/6 - Fin de la création de points sur le périmètre de l'emprise inondée." + endC + '\n') ############# # Etape 2/6 # Récupération de l'altitude sous chaque point ############# print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 2/6 - Début de la récupération de l'altitude sous chaque point." + endC + '\n') # Ajout d'un champ pour récupérer l'altitude addNewFieldVector(flooded_areas_points, ALTI_FIELD, ogr.OFTReal, field_value=None, field_width=None, field_precision=None, format_vector=format_vector) # Echantillonnage du MNT sous le fichier points importVectorOgr2Grass(flooded_areas_points, flooded_areas_points_basename, overwrite=overwrite) importRasterGdal2Grass(input_digital_elevation_model_file, digital_elevation_model_basename, overwrite=overwrite) sampleRasterUnderPoints(flooded_areas_points_basename, digital_elevation_model_basename, ALTI_FIELD, overwrite=overwrite) exportVectorOgr2Grass(flooded_areas_points_basename, altitude_points, format_vector=FORMAT_VECTOR_GRASS, overwrite=overwrite) print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 2/6 - Fin de la récupération de l'altitude sous chaque point." + endC + '\n') ############# # Etape 3/6 # Triangulation de l'altitude ############# print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 3/6 - Début de la triangulation de l'altitude." + endC + '\n') pixel_size = abs(min(pixel_width, pixel_height)) triangulationDelaunay(altitude_points, altitude_grid, ALTI_FIELD, cellsize=pixel_size) print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 3/6 - Fin de la triangulation de l'altitude." + endC + '\n') ############# # Etape 4/6 # Calcul des hauteurs brutes ############# print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 4/6 - Début du calcul des hauteurs brutes." + endC + '\n') # Redécoupage sur l'emprise inondée cutRasterImages([altitude_grid, input_digital_elevation_model_file], input_flooded_areas_vector, [altitude_file, digital_elevation_model_cut], 0, 0, epsg, no_data_value, "", False, path_time_log, format_raster=format_raster, format_vector=format_vector, extension_raster=extension_raster, extension_vector=extension_vector, save_results_intermediate=save_results_intermediate, overwrite=overwrite) # BandMath pour les hauteurs brutes (triangulation - MNT) expression = "im1b1 - im2b1" rasterCalculator([altitude_file, digital_elevation_model_cut], raw_heights, expression, codage=ENCODING_RASTER_FLOAT) print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 4/6 - Fin du calcul des hauteurs brutes." + endC + '\n') ############# # Etape 5/6 # Attribution des classes de hauteurs d'eau ############# print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 5/6 - Début de l'attribution des classes de hauteurs d'eau." + endC + '\n') # Génération de l'expression expression = "" for i in range(thresholds_list_float_len - 1): min_threshold = thresholds_list_float[i] max_threshold = thresholds_list_float[i + 1] expression += "im1b1>=%s and im1b1<%s ? %s : " % (min_threshold, max_threshold, i + 1) expression += "im1b1>=%s ? %s : 0" % (thresholds_list_float[ thresholds_list_float_len - 1], thresholds_list_float_len) # Calcul des classes de hauteurs d'eau rasterCalculator([raw_heights], heights_classes_temp, expression, codage=ENCODING_RASTER_UINT8) # Redécoupage propre des zones en dehors de l'emprise inondée cutImageByVector(input_flooded_areas_vector, heights_classes_temp, output_heights_classes_file, pixel_size_x=pixel_width, pixel_size_y=pixel_height, no_data_value=no_data_value, epsg=epsg, format_raster=format_raster, format_vector=format_vector) print(cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 5/6 - Fin de l'attribution des classes de hauteurs d'eau." + endC + '\n') ############# # Etape 6/6 # Vectorisation des classes de hauteurs d'eau ############# if output_heights_classes_vector != "": print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 6/6 - Début de la vectorisation des classes de hauteurs d'eau." + endC + '\n') name_column = 'class' umc_list = 0 if VECTORISATION == 'GRASS': vectorizeGrassClassification( output_heights_classes_file, output_heights_classes_vector, name_column, [umc_list], False, True, True, input_flooded_areas_vector, True, path_time_log, expression="", format_vector=format_vector, extension_raster=extension_raster, extension_vector=extension_vector, save_results_intermediate=save_results_intermediate, overwrite=overwrite) else: vectorizeClassification( output_heights_classes_file, output_heights_classes_vector, name_column, [umc_list], 2000, False, True, True, True, True, True, input_flooded_areas_vector, True, False, False, [0], path_time_log, expression="", format_vector=format_vector, extension_raster=extension_raster, extension_vector=extension_vector, save_results_intermediate=save_results_intermediate, overwrite=overwrite) print( cyan + "classesOfWaterHeights() : " + bold + green + "ETAPE 6/6 - Fin de la vectorisation des classes de hauteurs d'eau." + endC + '\n') else: print( cyan + "classesOfWaterHeights() : " + bold + yellow + "ETAPE 6/6 - Pas de vectorisation des classes de hauteurs d'eau demandée." + endC + '\n') # Suppression des fichiers temporaires if not save_results_intermediate: if debug >= 3: print(cyan + "classesOfWaterHeights() : " + endC + "Suppression des fichiers temporaires." + endC + '\n') deleteDir(temp_directory) print(cyan + "classesOfWaterHeights() : " + bold + green + "FIN DES TRAITEMENTS" + endC + '\n') # Mise à jour du log ending_event = "classesOfWaterHeights() : Fin du traitement : " timeLine(path_time_log, ending_event) return
def estimateQualityClassification(image_input, vector_cut_input, vector_sample_input, vector_output, nb_dot, no_data_value, column_name_vector, column_name_ref, column_name_class, path_time_log, epsg=2154, format_raster='GTiff', format_vector="ESRI Shapefile", extension_raster=".tif", extension_vector=".shp", save_results_intermediate=False, overwrite=True): # Mise à jour du Log starting_event = "estimateQualityClassification() : Masks creation starting : " timeLine(path_time_log, starting_event) print(endC) print(bold + green + "## START : CREATE PRINT POINTS FILE FROM CLASSIF IMAGE" + endC) print(endC) if debug >= 2: print(bold + green + "estimateQualityClassification() : Variables dans la fonction" + endC) print(cyan + "estimateQualityClassification() : " + endC + "image_input : " + str(image_input) + endC) print(cyan + "estimateQualityClassification() : " + endC + "vector_cut_input : " + str(vector_cut_input) + endC) print(cyan + "estimateQualityClassification() : " + endC + "vector_sample_input : " + str(vector_sample_input) + endC) print(cyan + "estimateQualityClassification() : " + endC + "vector_output : " + str(vector_output) + endC) print(cyan + "estimateQualityClassification() : " + endC + "nb_dot : " + str(nb_dot) + endC) print(cyan + "estimateQualityClassification() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "estimateQualityClassification() : " + endC + "column_name_vector : " + str(column_name_vector) + endC) print(cyan + "estimateQualityClassification() : " + endC + "column_name_ref : " + str(column_name_ref) + endC) print(cyan + "estimateQualityClassification() : " + endC + "column_name_class : " + str(column_name_class) + endC) print(cyan + "estimateQualityClassification() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "estimateQualityClassification() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "estimateQualityClassification() : " + endC + "format_raster : " + str(format_raster) + endC) print(cyan + "estimateQualityClassification() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "estimateQualityClassification() : " + endC + "extension_raster : " + str(extension_raster) + endC) print(cyan + "estimateQualityClassification() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "estimateQualityClassification() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "estimateQualityClassification() : " + endC + "overwrite : " + str(overwrite) + endC) # ETAPE 0 : PREPARATION DES FICHIERS INTERMEDIAIRES CODAGE = "uint16" SUFFIX_STUDY = '_study' SUFFIX_CUT = '_cut' SUFFIX_TEMP = '_temp' SUFFIX_SAMPLE = '_sample' repertory_output = os.path.dirname(vector_output) base_name = os.path.splitext(os.path.basename(vector_output))[0] vector_output_temp = repertory_output + os.sep + base_name + SUFFIX_TEMP + extension_vector raster_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_raster vector_study = repertory_output + os.sep + base_name + SUFFIX_STUDY + extension_vector raster_cut = repertory_output + os.sep + base_name + SUFFIX_CUT + extension_raster vector_sample_temp = repertory_output + os.sep + base_name + SUFFIX_SAMPLE + SUFFIX_TEMP + extension_vector # Mise à jour des noms de champs input_ref_col = "" val_ref = 0 if (column_name_vector != "") and (not column_name_vector is None): input_ref_col = column_name_vector if (column_name_ref != "") and (not column_name_ref is None): val_ref_col = column_name_ref if (column_name_class != "") and (not column_name_class is None): val_class_col = column_name_class # ETAPE 1 : DEFINIR UN SHAPE ZONE D'ETUDE if (not vector_cut_input is None) and (vector_cut_input != "") and ( os.path.isfile(vector_cut_input)): cutting_action = True vector_study = vector_cut_input else: cutting_action = False createVectorMask(image_input, vector_study) # ETAPE 2 : DECOUPAGE DU RASTEUR PAR LE VECTEUR D'EMPRISE SI BESOIN if cutting_action: # Identification de la tailles de pixels en x et en y pixel_size_x, pixel_size_y = getPixelWidthXYImage(image_input) # Si le fichier de sortie existe deja le supprimer if os.path.exists(raster_cut): removeFile(raster_cut) # Commande de découpe if not cutImageByVector(vector_study, image_input, raster_cut, pixel_size_x, pixel_size_y, no_data_value, 0, format_raster, format_vector): raise NameError( cyan + "estimateQualityClassification() : " + bold + red + "Une erreur c'est produite au cours du decoupage de l'image : " + image_input + endC) if debug >= 2: print(cyan + "estimateQualityClassification() : " + bold + green + "DECOUPAGE DU RASTER %s AVEC LE VECTEUR %s" % (image_input, vector_study) + endC) else: raster_cut = image_input # ETAPE 3 : CREATION DE LISTE POINTS AVEC DONNEE ISSU D'UN FICHIER RASTER # Gémotrie de l'image cols, rows, bands = getGeometryImage(raster_cut) xmin, xmax, ymin, ymax = getEmpriseImage(raster_cut) pixel_width, pixel_height = getPixelWidthXYImage(raster_cut) if debug >= 2: print("cols : " + str(cols)) print("rows : " + str(rows)) print("bands : " + str(bands)) print("xmin : " + str(xmin)) print("ymin : " + str(ymin)) print("xmax : " + str(xmax)) print("ymax : " + str(ymax)) print("pixel_width : " + str(pixel_width)) print("pixel_height : " + str(pixel_height)) # ETAPE 3-1 : CAS CREATION D'UN FICHIER DE POINTS PAR TIRAGE ALEATOIRE DANS LA MATRICE IMAGE if (vector_sample_input is None) or (vector_sample_input == ""): is_sample_file = False # Les dimensions de l'image nb_pixels = abs(cols * rows) # Tirage aléatoire des points drawn_dot_list = [] while len(drawn_dot_list) < nb_dot: val = random.randint(0, nb_pixels) if not val in drawn_dot_list: drawn_dot_list.append(val) # Creation d'un dico index valeur du tirage et attibuts pos_x, pos_y et value pixel points_random_value_dico = {} points_coordonnees_list = [] for point in drawn_dot_list: pos_y = point // cols pos_x = point % cols coordonnees_list = [pos_x, pos_y] points_coordonnees_list.append(coordonnees_list) # Lecture dans le fichier raster des valeurs values_list = getPixelsValueListImage(raster_cut, points_coordonnees_list) print(values_list) for idx_point in range(len(drawn_dot_list)): val_class = values_list[idx_point] coordonnees_list = points_coordonnees_list[idx_point] pos_x = coordonnees_list[0] pos_y = coordonnees_list[1] coor_x = xmin + (pos_x * abs(pixel_width)) coor_y = ymax - (pos_y * abs(pixel_height)) point_attr_dico = { "Ident": idx_point, val_ref_col: int(val_ref), val_class_col: int(val_class) } points_random_value_dico[idx_point] = [[coor_x, coor_y], point_attr_dico] if debug >= 4: print("idx_point : " + str(idx_point)) print("pos_x : " + str(pos_x)) print("pos_y : " + str(pos_y)) print("coor_x : " + str(coor_x)) print("coor_y : " + str(coor_y)) print("val_class : " + str(val_class)) print("") # ETAPE 3-2 : CAS D'UN FICHIER DE POINTS DEJA EXISTANT MISE A JOUR DE LA DONNEE ISSU Du RASTER else: # Le fichier de points d'analyses existe is_sample_file = True cutVectorAll(vector_study, vector_sample_input, vector_sample_temp, format_vector) if input_ref_col != "": points_coordinates_dico = readVectorFilePoints( vector_sample_temp, [input_ref_col], format_vector) else: points_coordinates_dico = readVectorFilePoints( vector_sample_temp, [], format_vector) # Création du dico points_random_value_dico = {} points_coordonnees_list = [] for index_key in points_coordinates_dico: # Recuperer les valeurs des coordonnees coord_info_list = points_coordinates_dico[index_key] coor_x = coord_info_list[0] coor_y = coord_info_list[1] pos_x = int(round((coor_x - xmin) / abs(pixel_width))) pos_y = int(round((ymax - coor_y) / abs(pixel_height))) coordonnees_list = [pos_x, pos_y] points_coordonnees_list.append(coordonnees_list) # Lecture dans le fichier raster des valeurs values_list = getPixelsValueListImage(raster_cut, points_coordonnees_list) for index_key in points_coordinates_dico: # Récuperer les valeurs des coordonnees coord_info_list = points_coordinates_dico[index_key] coor_x = coord_info_list[0] coor_y = coord_info_list[1] # Récupérer la classe de référence dans le vecteur d'entrée if input_ref_col != "": label = coord_info_list[2] val_ref = label.get(input_ref_col) # Récupérer la classe issue du raster d'entrée val_class = values_list[index_key] # Création du dico contenant identifiant du point, valeur de référence, valeur du raster d'entrée point_attr_dico = { "Ident": index_key, val_ref_col: int(val_ref), val_class_col: int(val_class) } if debug >= 4: print("point_attr_dico: " + str(point_attr_dico)) points_random_value_dico[index_key] = [[coor_x, coor_y], point_attr_dico] # ETAPE 4 : CREATION ET DECOUPAGE DU FICHIER VECTEUR RESULTAT PAR LE SHAPE D'ETUDE # Creer le fichier de points if is_sample_file and os.path.exists(vector_sample_temp): attribute_dico = {val_class_col: ogr.OFTInteger} # Recopie du fichier removeVectorFile(vector_output_temp) copyVectorFile(vector_sample_temp, vector_output_temp) # Ajout des champs au fichier de sortie for field_name in attribute_dico: addNewFieldVector(vector_output_temp, field_name, attribute_dico[field_name], 0, None, None, format_vector) # Préparation des donnees field_new_values_list = [] for index_key in points_random_value_dico: point_attr_dico = points_random_value_dico[index_key][1] point_attr_dico.pop(val_ref_col, None) field_new_values_list.append(point_attr_dico) # Ajout des donnees setAttributeValuesList(vector_output_temp, field_new_values_list, format_vector) else: # Définir les attibuts du fichier résultat attribute_dico = { "Ident": ogr.OFTInteger, val_ref_col: ogr.OFTInteger, val_class_col: ogr.OFTInteger } createPointsFromCoordList(attribute_dico, points_random_value_dico, vector_output_temp, epsg, format_vector) # Découpage du fichier de points d'echantillons cutVectorAll(vector_study, vector_output_temp, vector_output, format_vector) # ETAPE 5 : SUPPRESIONS FICHIERS INTERMEDIAIRES INUTILES # Suppression des données intermédiaires if not save_results_intermediate: if cutting_action: removeFile(raster_cut) else: removeVectorFile(vector_study) removeFile(raster_study) if is_sample_file: removeVectorFile(vector_sample_temp) removeVectorFile(vector_output_temp) print(endC) print(bold + green + "## END : CREATE PRINT POINTS FILE FROM CLASSIF IMAGE" + endC) print(endC) # Mise à jour du Log ending_event = "estimateQualityClassification() : Masks creation ending : " timeLine(path_time_log, ending_event) return
def 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 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 indicateurRA(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, extension_raster, extension_vector): print( bold + yellow + "Début de la préparation au calcul de l'indicateur de rapport d'aspect." + endC) step = " Début de la préparation au calcul de l'indicateur de rapport d'aspect : " timeLine(path_time_log, step) grid_ready_cleaned = temp_directory + os.sep + os.path.splitext( os.path.basename( urbanatlas_input))[0] + "_cut_cleaned" + extension_vector permeability = temp_directory + os.sep + "permeability" + extension_raster built_shape = temp_directory + os.sep + "bati" + extension_vector built_RA = temp_directory + os.sep + "built_RA" + extension_raster logCVR = temp_directory + os.sep + "logCVR.txt" if indicators_method == "Resultats_classif": # Croisement du bâti vectorisé avec le MNH pour récupérer la hauteur moyenne de chaque bâtiment MNH_cut = temp_directory + os.sep + os.path.splitext( os.path.basename(mnh_file))[0] + "_cut" + extension_raster MNH_centimeters = temp_directory + os.sep + "MNH_centimeters" + extension_raster print( bold + cyan + " Basculement des valeurs du MNH des mètres aux centimètres :" + endC) os.system( "otbcli_BandMath -il %s -out %s uint16 -exp 'im1b1*100'" % (MNH_cut, MNH_centimeters) ) # Basculement des valeurs du MNH des mètres aux centimètres (pour obtenir un raster codé en entier et non en flottant) print( bold + cyan + " Récupération de l'information de hauteur du bâti à partir du MNH :" + endC) statisticsVectorRaster( MNH_centimeters, built_shape, "", 1, False, False, True, [], [], {}, logCVR, True, 'ESRI Shapefile', False, True ) # Récupération de l'information de hauteur du bâti à partir du MNH time.sleep( 10 ) # Pause de 10 secondes pour que le système récupère toute la RAM qui a pu être utilisée pour le CVR print(bold + cyan + " Rastérisation du bâti :" + endC) pixel_size_x, pixel_size_y = getPixelWidthXYImage(permeability) os.system( "gdal_rasterize -burn 10 -init 1 -tr %s %s %s %s" % (pixel_size_x, pixel_size_y, built_shape, built_RA) ) # Rastérisation du bâti via GDAL plutôt qu'OTB : mauvaise gestion des valeurs de background pour l'OTB (devient NoData) print( bold + cyan + " Récupération de la surface non-bâtie par polygone du maillage :" + endC) statisticsVectorRaster( built_RA, grid_ready_cleaned, "", 1, True, True, False, [], [], { 1: 'NonBati', 10: 'Bati' }, path_time_log, True, 'ESRI Shapefile', False, True) # Récupération de la surface non-bâtie par polygone du maillage time.sleep( 10 ) # Pause de 10 secondes pour que le système récupère toute la RAM qui a pu être utilisée pour le CVR step = " Fin de la préparation au calcul de l'indicateur de rapport d'aspect : " timeLine(path_time_log, step) print( bold + yellow + "Fin de la préparation au calcul de l'indicateur de rapport d'aspect." + endC) print("\n") return
def selectSamples(image_input_list, sample_image_input, vector_output, table_statistics_output, sampler_strategy, select_ratio_floor, ratio_per_class_dico, name_column, no_data_value, path_time_log, rand_seed=0, ram_otb=0, epsg=2154, format_vector='ESRI Shapefile', extension_vector=".shp", save_results_intermediate=False, overwrite=True) : # Mise à jour du Log starting_event = "selectSamples() : Select points in raster mask macro input starting : " timeLine(path_time_log, starting_event) if debug >= 3: print(cyan + "selectSamples() : " + endC + "image_input_list : " + str(image_input_list) + endC) print(cyan + "selectSamples() : " + endC + "sample_image_input : " + str(sample_image_input) + endC) print(cyan + "selectSamples() : " + endC + "vector_output : " + str(vector_output) + endC) print(cyan + "selectSamples() : " + endC + "table_statistics_output : " + str(table_statistics_output) + endC) print(cyan + "selectSamples() : " + endC + "sampler_strategy : " + str(sampler_strategy) + endC) print(cyan + "selectSamples() : " + endC + "select_ratio_floor : " + str(select_ratio_floor) + endC) print(cyan + "selectSamples() : " + endC + "ratio_per_class_dico : " + str(ratio_per_class_dico) + endC) print(cyan + "selectSamples() : " + endC + "name_column : " + str(name_column) + endC) print(cyan + "selectSamples() : " + endC + "no_data_value : " + str(no_data_value) + endC) print(cyan + "selectSamples() : " + endC + "path_time_log : " + str(path_time_log) + endC) print(cyan + "selectSamples() : " + endC + "rand_seed : " + str(rand_seed) + endC) print(cyan + "selectSamples() : " + endC + "ram_otb : " + str(ram_otb) + endC) print(cyan + "selectSamples() : " + endC + "epsg : " + str(epsg) + endC) print(cyan + "selectSamples() : " + endC + "format_vector : " + str(format_vector) + endC) print(cyan + "selectSamples() : " + endC + "extension_vector : " + str(extension_vector) + endC) print(cyan + "selectSamples() : " + endC + "save_results_intermediate : " + str(save_results_intermediate) + endC) print(cyan + "selectSamples() : " + endC + "overwrite : " + str(overwrite) + endC) # Constantes EXT_XML = ".xml" SUFFIX_SAMPLE = "_sample" SUFFIX_STATISTICS = "_statistics" SUFFIX_POINTS = "_points" SUFFIX_VALUE = "_value" BAND_NAME = "band_" COLUMN_CLASS = "class" COLUMN_ORIGINFID = "originfid" NB_POINTS = "nb_points" AVERAGE = "average" STANDARD_DEVIATION = "st_dev" print(cyan + "selectSamples() : " + bold + green + "DEBUT DE LA SELECTION DE POINTS" + endC) # Definition variables et chemins repertory_output = os.path.dirname(vector_output) filename = os.path.splitext(os.path.basename(vector_output))[0] sample_points_output = repertory_output + os.sep + filename + SUFFIX_SAMPLE + extension_vector file_statistic_points = repertory_output + os.sep + filename + SUFFIX_STATISTICS + SUFFIX_POINTS + EXT_XML if debug >= 3: print(cyan + "selectSamples() : " + endC + "file_statistic_points : " + str(file_statistic_points) + endC) # 0. EXISTENCE DU FICHIER DE SORTIE #---------------------------------- # Si le fichier vecteur points de sortie existe deja et que overwrite n'est pas activé check = os.path.isfile(vector_output) if check and not overwrite: print(bold + yellow + "Samples points already done for file %s and will not be calculated again." %(vector_output) + endC) else: # Si non ou si la vérification est désactivée : creation du fichier d'échantillons points # Suppression de l'éventuel fichier existant if check: try: removeVectorFile(vector_output) except Exception: pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite if os.path.isfile(table_statistics_output) : try: removeFile(table_statistics_output) except Exception: pass # Si le fichier ne peut pas être supprimé, on suppose qu'il n'existe pas et on passe à la suite # 1. STATISTIQUE SUR L'IMAGE DES ECHANTILLONS RASTEUR #---------------------------------------------------- if debug >= 3: print(cyan + "selectSamples() : " + bold + green + "Start statistique sur l'image des echantillons rasteur..." + endC) id_micro_list = identifyPixelValues(sample_image_input) if 0 in id_micro_list : id_micro_list.remove(0) min_micro_class_nb_points = -1 min_micro_class_label = 0 infoStructPointSource_dico = {} writeTextFile(file_statistic_points, '<?xml version="1.0" ?>\n') appendTextFileCR(file_statistic_points, '<GeneralStatistics>') appendTextFileCR(file_statistic_points, ' <Statistic name="pointsPerClassRaw">') if debug >= 2: print("Nombre de points par micro classe :" + endC) for id_micro in id_micro_list : nb_pixels = countPixelsOfValue(sample_image_input, id_micro) if debug >= 2: print("MicroClass : " + str(id_micro) + ", nb_points = " + str(nb_pixels)) appendTextFileCR(file_statistic_points, ' <StatisticPoints class="%d" value="%d" />' %(id_micro, nb_pixels)) if min_micro_class_nb_points == -1 or min_micro_class_nb_points > nb_pixels : min_micro_class_nb_points = nb_pixels min_micro_class_label = id_micro infoStructPointSource_dico[id_micro] = StructInfoMicoClass() infoStructPointSource_dico[id_micro].label_class = id_micro infoStructPointSource_dico[id_micro].nb_points = nb_pixels infoStructPointSource_dico[id_micro].info_points_list = [] del nb_pixels if debug >= 2: print("MicroClass min points find : " + str(min_micro_class_label) + ", nb_points = " + str(min_micro_class_nb_points)) appendTextFileCR(file_statistic_points, ' </Statistic>') pending_event = cyan + "selectSamples() : " + bold + green + "End statistique sur l'image des echantillons rasteur. " + endC if debug >= 3: print(pending_event) timeLine(path_time_log,pending_event) # 2. CHARGEMENT DE L'IMAGE DES ECHANTILLONS #------------------------------------------ if debug >= 3: print(cyan + "selectSamples() : " + bold + green + "Start chargement de l'image des echantillons..." + endC) # Information image cols, rows, bands = getGeometryImage(sample_image_input) xmin, xmax, ymin, ymax = getEmpriseImage(sample_image_input) pixel_width, pixel_height = getPixelWidthXYImage(sample_image_input) projection_input = getProjectionImage(sample_image_input) if projection_input == None or projection_input == 0 : projection_input = epsg else : projection_input = int(projection_input) pixel_width = abs(pixel_width) pixel_height = abs(pixel_height) # Lecture des données raw_data = getRawDataImage(sample_image_input) if debug >= 3: print("projection = " + str(projection_input)) print("cols = " + str(cols)) print("rows = " + str(rows)) # Creation d'une structure dico contenent tous les points différents de zéro progress = 0 pass_prog = False for y_row in range(rows) : for x_col in range(cols) : value_class = raw_data[y_row][x_col] if value_class != 0 : infoStructPointSource_dico[value_class].info_points_list.append(x_col + (y_row * cols)) # Barre de progression if debug >= 4: if ((float(y_row) / rows) * 100.0 > progress) and not pass_prog : progress += 1 pass_prog = True print("Progression => " + str(progress) + "%") if ((float(y_row) / rows) * 100.0 > progress + 1) : pass_prog = False del raw_data pending_event = cyan + "selectSamples() : " + bold + green + "End chargement de l'image des echantillons. " + endC if debug >= 3: print(pending_event) timeLine(path_time_log,pending_event) # 3. SELECTION DES POINTS D'ECHANTILLON #-------------------------------------- if debug >= 3: print(cyan + "selectSamples() : " + bold + green + "Start selection des points d'echantillon..." + endC) appendTextFileCR(file_statistic_points, ' <Statistic name="pointsPerClassSelect">') # Rendre deterministe la fonction aléatoire de random.sample if rand_seed > 0: random.seed( rand_seed ) # Pour toute les micro classes for id_micro in id_micro_list : # Selon la stategie de selection nb_points_ratio = 0 while switch(sampler_strategy.lower()): if case('all'): # Le mode de selection 'all' est choisi nb_points_ratio = infoStructPointSource_dico[id_micro].nb_points infoStructPointSource_dico[id_micro].sample_points_list = range(nb_points_ratio) break if case('percent'): # Le mode de selection 'percent' est choisi id_macro_class = int(math.floor(id_micro / 100) * 100) select_ratio_class = ratio_per_class_dico[id_macro_class] nb_points_ratio = int(infoStructPointSource_dico[id_micro].nb_points * select_ratio_class / 100) infoStructPointSource_dico[id_micro].sample_points_list = random.sample(range(infoStructPointSource_dico[id_micro].nb_points), nb_points_ratio) break if case('mixte'): # Le mode de selection 'mixte' est choisi nb_points_ratio = int(infoStructPointSource_dico[id_micro].nb_points * select_ratio_floor / 100) if id_micro == min_micro_class_label : # La plus petite micro classe est concervée intégralement infoStructPointSource_dico[id_micro].sample_points_list = range(infoStructPointSource_dico[id_micro].nb_points) nb_points_ratio = min_micro_class_nb_points elif nb_points_ratio <= min_micro_class_nb_points : # Les micro classes dont le ratio de selection est inferieur au nombre de points de la plus petite classe sont égement conservées intégralement infoStructPointSource_dico[id_micro].sample_points_list = random.sample(range(infoStructPointSource_dico[id_micro].nb_points), min_micro_class_nb_points) nb_points_ratio = min_micro_class_nb_points else : # Pour toutes les autres micro classes tirage aleatoire d'un nombre de points correspondant au ratio infoStructPointSource_dico[id_micro].sample_points_list = random.sample(range(infoStructPointSource_dico[id_micro].nb_points), nb_points_ratio) break break if debug >= 2: print("MicroClass = " + str(id_micro) + ", nb_points_ratio " + str(nb_points_ratio)) appendTextFileCR(file_statistic_points, ' <StatisticPoints class="%d" value="%d" />' %(id_micro, nb_points_ratio)) appendTextFileCR(file_statistic_points, ' </Statistic>') appendTextFileCR(file_statistic_points, '</GeneralStatistics>') pending_event = cyan + "selectSamples() : " + bold + green + "End selection des points d'echantillon. " + endC if debug >= 3: print(pending_event) timeLine(path_time_log,pending_event) # 4. PREPARATION DES POINTS D'ECHANTILLON #---------------------------------------- if debug >= 3: print(cyan + "selectSamples() : " + bold + green + "Start preparation des points d'echantillon..." + endC) # Création du dico de points points_random_value_dico = {} index_dico_point = 0 for micro_class in infoStructPointSource_dico : micro_class_struct = infoStructPointSource_dico[micro_class] label_class = micro_class_struct.label_class point_attr_dico = {name_column:int(label_class), COLUMN_CLASS:int(label_class), COLUMN_ORIGINFID:0} for id_point in micro_class_struct.sample_points_list: # Recuperer les valeurs des coordonnees des points coor_x = float(xmin + (int(micro_class_struct.info_points_list[id_point] % cols) * pixel_width)) + (pixel_width / 2.0) coor_y = float(ymax - (int(micro_class_struct.info_points_list[id_point] / cols) * pixel_height)) - (pixel_height / 2.0) points_random_value_dico[index_dico_point] = [[coor_x, coor_y], point_attr_dico] del coor_x del coor_y index_dico_point += 1 del point_attr_dico del infoStructPointSource_dico pending_event = cyan + "selectSamples() : " + bold + green + "End preparation des points d'echantillon. " + endC if debug >=3: print(pending_event) timeLine(path_time_log,pending_event) # 5. CREATION DU FICHIER SHAPE DE POINTS D'ECHANTILLON #----------------------------------------------------- if debug >= 3: print(cyan + "selectSamples() : " + bold + green + "Start creation du fichier shape de points d'echantillon..." + endC) # Définir les attibuts du fichier résultat attribute_dico = {name_column:ogr.OFTInteger, COLUMN_CLASS:ogr.OFTInteger, COLUMN_ORIGINFID:ogr.OFTInteger} # Creation du fichier shape createPointsFromCoordList(attribute_dico, points_random_value_dico, sample_points_output, projection_input, format_vector) del attribute_dico del points_random_value_dico pending_event = cyan + "selectSamples() : " + bold + green + "End creation du fichier shape de points d'echantillon. " + endC if debug >=3: print(pending_event) timeLine(path_time_log,pending_event) # 6. EXTRACTION DES POINTS D'ECHANTILLONS #----------------------------------------- if debug >= 3: print(cyan + "selectSamples() : " + bold + green + "Start extraction des points d'echantillon dans l'image..." + endC) # Cas ou l'on a une seule image if len(image_input_list) == 1: # Extract sample image_input = image_input_list[0] command = "otbcli_SampleExtraction -in %s -vec %s -outfield prefix -outfield.prefix.name %s -out %s -field %s" %(image_input, sample_points_output, BAND_NAME, vector_output, name_column) if ram_otb > 0: command += " -ram %d" %(ram_otb) if debug >= 3: print(command) exitCode = os.system(command) if exitCode != 0: raise NameError(cyan + "selectSamples() : " + bold + red + "An error occured during otbcli_SampleExtraction command. See error message above." + endC) # Cas de plusieurs imagettes else : # Le repertoire de sortie repertory_output = os.path.dirname(vector_output) # Initialisation de la liste pour le multi-threading et la liste de l'ensemble des echantions locaux thread_list = [] vector_local_output_list = [] # Obtenir l'emprise des images d'entrées pour redecouper le vecteur d'echantillon d'apprentissage pour chaque image for image_input in image_input_list : # Definition des fichiers sur emprise local file_name = os.path.splitext(os.path.basename(image_input))[0] emprise_local_sample = repertory_output + os.sep + file_name + SUFFIX_SAMPLE + extension_vector vector_sample_local_output = repertory_output + os.sep + file_name + SUFFIX_VALUE + extension_vector vector_local_output_list.append(vector_sample_local_output) # Gestion sans thread... #SampleLocalExtraction(image_input, sample_points_output, emprise_local_sample, vector_sample_local_output, name_column, BAND_NAME, ram_otb, format_vector, extension_vector, save_results_intermediate) # Gestion du multi threading thread = threading.Thread(target=SampleLocalExtraction, args=(image_input, sample_points_output, emprise_local_sample, vector_sample_local_output, name_column, BAND_NAME, ram_otb, format_vector, extension_vector, save_results_intermediate)) thread.start() thread_list.append(thread) # Extraction des echantions points des images try: for thread in thread_list: thread.join() except: print(cyan + "selectSamples() : " + bold + red + "Erreur lors de l'éextaction des valeurs d'echantion : impossible de demarrer le thread" + endC, file=sys.stderr) # Fusion des multi vecteurs de points contenant les valeurs des bandes de l'image fusionVectors(vector_local_output_list, vector_output, format_vector) # Clean des vecteurs point sample local file for vector_sample_local_output in vector_local_output_list : removeVectorFile(vector_sample_local_output) if debug >= 3: print(cyan + "selectSamples() : " + bold + green + "End extraction des points d'echantillon dans l'image." + endC) # 7. CALCUL DES STATISTIQUES SUR LES VALEURS DES POINTS D'ECHANTILLONS SELECTIONNEES #----------------------------------------------------------------------------------- if debug >= 3: print(cyan + "selectSamples() : " + bold + green + "Start calcul des statistiques sur les valeurs des points d'echantillons selectionnees..." + endC) # Si le calcul des statistiques est demandé presence du fichier stat if table_statistics_output != "": # On récupère la liste de données pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part1... " + endC if debug >=4: print(pending_event) timeLine(path_time_log,pending_event) attribute_name_dico = {} name_field_value_list = [] names_attribut_list = getAttributeNameList(vector_output, format_vector) if debug >=4: print("names_attribut_list = " + str(names_attribut_list)) attribute_name_dico[name_column] = ogr.OFTInteger for name_attribut in names_attribut_list : if BAND_NAME in name_attribut : attribute_name_dico[name_attribut] = ogr.OFTReal name_field_value_list.append(name_attribut) name_field_value_list.sort() res_values_dico = getAttributeValues(vector_output, None, None, attribute_name_dico, format_vector) del attribute_name_dico # Trie des données par identifiant micro classes pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part2... " + endC if debug >=4: print(pending_event) timeLine(path_time_log,pending_event) data_value_by_micro_class_dico = {} stat_by_micro_class_dico = {} # Initilisation du dico complexe for id_micro in id_micro_list : data_value_by_micro_class_dico[id_micro] = {} stat_by_micro_class_dico[id_micro] = {} for name_field_value in res_values_dico : if name_field_value != name_column : data_value_by_micro_class_dico[id_micro][name_field_value] = [] stat_by_micro_class_dico[id_micro][name_field_value] = {} stat_by_micro_class_dico[id_micro][name_field_value][AVERAGE] = 0.0 stat_by_micro_class_dico[id_micro][name_field_value][STANDARD_DEVIATION] = 0.0 # Trie des valeurs pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part3... " + endC if debug >=4: print(pending_event) timeLine(path_time_log,pending_event) for index in range(len(res_values_dico[name_column])) : id_micro = res_values_dico[name_column][index] for name_field_value in name_field_value_list : data_value_by_micro_class_dico[id_micro][name_field_value].append(res_values_dico[name_field_value][index]) del res_values_dico # Calcul des statistiques pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part4... " + endC if debug >=4: print(pending_event) timeLine(path_time_log,pending_event) for id_micro in id_micro_list : for name_field_value in name_field_value_list : try : stat_by_micro_class_dico[id_micro][name_field_value][AVERAGE] = average(data_value_by_micro_class_dico[id_micro][name_field_value]) except: stat_by_micro_class_dico[id_micro][name_field_value][AVERAGE] = 0 try : stat_by_micro_class_dico[id_micro][name_field_value][STANDARD_DEVIATION] = standardDeviation(data_value_by_micro_class_dico[id_micro][name_field_value]) except: stat_by_micro_class_dico[id_micro][name_field_value][STANDARD_DEVIATION] = 0 try : stat_by_micro_class_dico[id_micro][name_field_value][NB_POINTS] = len(data_value_by_micro_class_dico[id_micro][name_field_value]) except: stat_by_micro_class_dico[id_micro][name_field_value][NB_POINTS] = 0 del data_value_by_micro_class_dico # Creation du fichier statistique .csv pending_event = cyan + "selectSamples() : " + bold + green + "Encours calcul des statistiques part5... " + endC if debug >= 4: print(pending_event) timeLine(path_time_log,pending_event) text_csv = " Micro classes ; Champs couche image ; Nombre de points ; Moyenne ; Ecart type \n" writeTextFile(table_statistics_output, text_csv) for id_micro in id_micro_list : for name_field_value in name_field_value_list : # Ecriture du fichier text_csv = " %d " %(id_micro) text_csv += " ; %s" %(name_field_value) text_csv += " ; %d" %(stat_by_micro_class_dico[id_micro][name_field_value][NB_POINTS]) text_csv += " ; %f" %(stat_by_micro_class_dico[id_micro][name_field_value][AVERAGE]) text_csv += " ; %f" %(stat_by_micro_class_dico[id_micro][name_field_value][STANDARD_DEVIATION]) appendTextFileCR(table_statistics_output, text_csv) del name_field_value_list else : if debug >=3: print(cyan + "selectSamples() : " + bold + green + "Pas de calcul des statistiques sur les valeurs des points demander!!!." + endC) del id_micro_list pending_event = cyan + "selectSamples() : " + bold + green + "End calcul des statistiques sur les valeurs des points d'echantillons selectionnees. " + endC if debug >= 3: print(pending_event) timeLine(path_time_log,pending_event) # 8. SUPRESSION DES FICHIERS INTERMEDIAIRES #------------------------------------------ if not save_results_intermediate: if os.path.isfile(sample_points_output) : removeVectorFile(sample_points_output) print(cyan + "selectSamples() : " + bold + green + "FIN DE LA SELECTION DE POINTS" + endC) # Mise à jour du Log ending_event = "selectSamples() : Select points in raster mask macro input ending : " timeLine(path_time_log,ending_event) return