Ejemplo n.º 1
0
def physiocap_fichier_histo( self, src, histo_diametre, histo_nbsarment, err):
    """Fonction de traitement. Creation des fichiers pour réaliser les histogrammes
    Lit et traite ligne par ligne le fichier source (src).
    Les résultats est écrit au fur et à mesure dans histo_diametre ou histo_nbsarment
    """
   
    numero_ligne = 0     
    while True :
        ligne = src.readline() # lit les lignes 1 à 1
        if not ligne: break 
        # Vérifier si ligne OK
        numero_ligne = numero_ligne + 1
        comptage = ligne.count(",") # compte le nombre de virgules
        if comptage != NB_VIRGULES:
            # Assert ligne sans 58 virgules 
            continue # on saute la ligne
        
        result = ligne.split(",") # split en fonction des virgules
        # Intergrer ici les autres cas d'erreurs
                
        try : # accompli cette fonction si pas d'erreur sinon except
            XY = [float(x) for x in result[1:9]]   # on extrait les XY et on les transforme en float  > Données GPS 
            diams = [float(x) for x in result[9:NB_VIRGULES+1]] # on extrait les diams et on les transforme en float 
            diamsF = [i for i in diams if i > 2 and i < 28 ] # on filtre les diams > diamsF correspond aux diams filtrés entre 2 et 28       
            if comptage==NB_VIRGULES and len(diamsF)>0 : # si le nombre de diamètre après filtrage != 0 alors mesures
                if XY[7] != 0:
                    nbsarm = len(diamsF)/(XY[7]*1000/3600) #8eme donnée du GPS est la vitesse. Dernier terme : distance entre les sarments
                else:
                    nbsarm = 0
                histo_nbsarment.write("%f%s" %(nbsarm,";"))                
                for n in range(len(diamsF)) :
                    histo_diametre.write("%f%s" %(diamsF[n],";"))
        except : # accompli cette fonction si erreur
            msg = "%s%s\n" %("Erreur histo",ligne)
            physiocap_error( self, msg )
            err.write( str( msg) ) # on écrit la ligne dans le fichier ERREUR.csv
            pass # on mange l'exception
Ejemplo n.º 2
0
    def physiocap_moyenne_InterParcelles( self, dialogue):
        """Verification et requete spatiale"""
        physiocap_log( self.trUtf8( "== Début du calcul des moyennes à partir de vos contours" ))

        # QT Confiance
        repertoire_data = dialogue.lineEditDirectoryPhysiocap.text()
        # Attention peut être non renseigné repertoire_projet = dialogue.lineEditDernierProjet.text()
        if ((repertoire_data == "") or ( not os.path.exists( repertoire_data))):
            aText = self.trUtf8( "Pas de répertoire de données brutes spécifié" )
            physiocap_error( self, aText)
            return physiocap_message_box( dialogue, aText, "information")
                
        details = "NO"
        if dialogue.checkBoxInfoVignoble.isChecked():
            details = "YES"
        
        # Récupérer des styles pour chaque shape dans Affichage
        #dir_template = os.path.join( os.path.dirname(__file__), 'modeleQgis')       
        dir_template = dialogue.fieldComboThematiques.currentText()
        qml_is = dialogue.lineEditThematiqueInterMoyenne.text().strip('"') + EXTENSION_QML
        le_template_moyenne = os.path.join( dir_template, qml_is)
        qml_is = dialogue.lineEditThematiqueInterPoints.text().strip('"') + EXTENSION_QML
        le_template_point = os.path.join( dir_template, qml_is)
       
        # Pour polygone de contour   
        nom_complet_poly = dialogue.comboBoxPolygone.currentText().split( SEPARATEUR_NOEUD)
        if ( len( nom_complet_poly) != 2):
            aText = self.trUtf8( "Le polygone de contour n'est pas choisi.")
            physiocap_error( self, aText)
            aText = aText + "\n" + self.trUtf8( "Avez-vous créer votre shapefile de contour ?")
            return physiocap_message_box( dialogue, aText)           
        nom_poly = nom_complet_poly[ 0] 
        id_poly = nom_complet_poly[ 1] 
        vecteur_poly = physiocap_get_layer_by_ID( id_poly)

        leChampPoly = dialogue.fieldComboContours.currentText()
            
        # Pour les points
        nom_complet_point = dialogue.comboBoxPoints.currentText().split( SEPARATEUR_NOEUD)
        if ( len( nom_complet_point) != 2):
            aText = self.trUtf8( "Le shape de points n'est pas choisi. ")
            aText = aText + self.trUtf8( "Créer une nouvelle instance de projet - bouton OK - ")
            aText = aText + self.trUtf8( "avant de faire votre calcul de Moyenne Inter Parcellaire")
            physiocap_error( self, aText, "CRITICAL")
            return physiocap_message_box( dialogue, aText, "information" )
        nom_noeud_arbre = nom_complet_point[ 0] 
        id_point = nom_complet_point[ 1] 
        vecteur_point = physiocap_get_layer_by_ID( id_point)

        # Verification de l'arbre
        root = QgsProject.instance().layerTreeRoot( )
        un_groupe = root.findGroup( nom_noeud_arbre)
        if ( not isinstance( un_groupe, QgsLayerTreeGroup)):
            aText = self.trUtf8( "Le projet {0} n'existe pas. ").\
                format( nom_noeud_arbre)
            aText = aText + self.trUtf8( "Créer une nouvelle instance de projet - bouton OK - ")
            aText = aText + self.trUtf8( "avant de faire votre calcul de Moyenne Inter Parcellaire")
            physiocap_error( self, aText, "CRITICAL")
            return physiocap_message_box( dialogue, aText, "information" )            

        # Vérification 
        if ( vecteur_point == None):
            aText = self.trUtf8( "Le jeu de points choisi n'est pas valide. ")
            aText = aText + self.trUtf8( "Créer une nouvelle instance de projet - bouton OK - ")
            aText = aText + self.trUtf8( "avant de faire votre calcul de Moyenne Inter Parcellaire")
            physiocap_error( self, aText, "CRITICAL")
            return physiocap_message_box( dialogue, aText, "information" )  

        if ( vecteur_poly == None) or ( not vecteur_poly.isValid()):
            aText = self.trUtf8( "Le contour choisi n'est pas valide. ")
            aText = aText + self.trUtf8( "Créer une nouvelle instance de projet - bouton OK - ")
            aText = aText + self.trUtf8( "avant de faire votre calcul de Moyenne Inter Parcellaire")
            physiocap_error( self, aText, "CRITICAL")
            return physiocap_message_box( dialogue, aText, "information" ) 

        # Verifier SRCs sont les même
        crs_poly = vecteur_poly.crs().authid()
        crs_point = vecteur_point.crs().authid()
        if ( crs_poly != crs_point):
            mes = self.trUtf8( "Les projections (CRS) des coutours ({0}) et mesures brutes ({1}) sont différentes !").\
                format( crs_poly, crs_point)
            physiocap_error( self, mes)
            return physiocap_message_box( dialogue, mes,"information")
                    
        laProjection, EXT_CRS_SHP, EXT_CRS_PRJ, EXT_CRS_RASTER, EPSG_NUMBER = \
            physiocap_quelle_projection_demandee(dialogue)
        crs = QgsCoordinateReferenceSystem( EPSG_NUMBER, QgsCoordinateReferenceSystem.PostgisCrsId)

        # Verification du repertoire shape
        pro = vecteur_point.dataProvider() 
        if ( pro.name() == POSTGRES_NOM):
            # On construit le chemin depuis data/projet...
            chemin_projet = os.path.join( repertoire_data, nom_noeud_arbre)
            chemin_shapes = os.path.join( chemin_projet, REPERTOIRE_SHAPEFILE)
        else:
            # Assert repertoire shapfile : c'est le repertoire qui contient le vecteur point
            chemin_shapes = os.path.dirname( unicode( vecteur_point.dataProvider().dataSourceUri() ) ) ;
        if ( not os.path.exists( chemin_shapes)):
            raise physiocap_exception_rep( chemin_shapes)
                    
        # On passe sur les differents contours
        id = 0
        contour_avec_point = 0
        les_geoms_poly = []
        les_parcelles = []
        les_parcelles_ID = []
        les_dates_parcelle = []
        les_heures_parcelle = []
        les_moyennes_vitesse = []
        les_moyennes_sarment = []
        les_moyennes_diametre = []
        les_moyennes_biom = []
        les_moyennes_biomgm2 = []
        les_moyennes_biomgcep = []
        les_moyennes_biomm2 = []
        les_moyennes_nbsarmm2 = []
        les_moyennes_nbsarcep= []

        for un_contour in vecteur_poly.getFeatures(): #iterate poly features
            id = id + 1
            try:
                un_nom = str( un_contour[ leChampPoly]) #get attribute of poly layer
            except:
                un_nom = "PHY_ID_" + str(id)
                pass
            
            physiocap_log ( self.trUtf8( "== Début Inter pour {0} >>>> ").\
                format( un_nom))
            
            un_autre_ID = "PHY_ID" + str(id)
            geom_poly = un_contour.geometry() #get geometry of poly layer
            
            # Todo : WT DATA BUG contour :  test validé geom_poly
            
            #physiocap_log ( "Dans polygone geom multipart : " + str(geom_poly.wkbType()))
            if geom_poly.wkbType() == QGis.WKBPolygon:
                physiocap_log ( self.trUtf8( "== Layer (Polygone) simple: {0} ".\
                    format( un_nom)))
            elif geom_poly.wkbType() == QGis.WKBMultiPolygon:
                physiocap_log ( self.trUtf8("== Layer (Polygone) multiple:{0} ".\
                    format( un_nom)))
            else:
                aText = self.trUtf8( "== Cette forme n'est pas un polygone : {0}").\
                    format( un_nom)
                physiocap_log( aText)
                physiocap_error( self, aText)
                physiocap_message_box( dialogue, aText, "information")
                continue
            
            # on initialise pour ce contour
            les_geom_point_feat = []
            les_dates = []
            les_GID = []
            les_vitesses = []
            les_sarments = []
            les_diametres = []
            nb_dia = 0
            nb_sar = 0
            les_biom = []
            les_biomgm2 = []
            les_biomgcep = []
            les_biomm2 = []
            les_nbsarmm2 = []
            les_nbsarcep= []
            i = 0
            date_debut = ""
            heure_fin = ""
            # Préfiltre dans un rectangle
            # Récupération des entites qui concerne ce coutours
            for un_point in vecteur_point.getFeatures(QgsFeatureRequest().
                            setFilterRect(geom_poly.boundingBox())):
                # un_point est un feature ! 
                if un_point.geometry().within(geom_poly):
                    # Cas du premier point d'un contour 
                    if i == 0:
                        contour_avec_point = contour_avec_point + 1
                    i = i + 1
                    try:
                        if i == 2:
                            # Attraper date début
                            date_debut = un_point["DATE"]
                        les_geom_point_feat.append( un_point.geometry().asPoint())
                        les_dates.append( un_point["DATE"])
                        les_GID.append( un_point["GID"])
                        les_vitesses.append( un_point["VITESSE"])
                        les_sarments.append( un_point["NBSARM"])
                        les_diametres.append( un_point["DIAM"])
                        les_biom.append( un_point["BIOM"])
                        if ( details == "YES"):
                            try:
                                les_biomgm2.append( un_point["BIOMGM2"])
                                les_biomgcep.append( un_point["BIOMGCEP"])
                                les_biomm2.append( un_point["BIOMM2"])
                                les_nbsarmm2.append( un_point["NBSARMM2"])
                                les_nbsarcep.append( un_point["NBSARCEP"])
                            except KeyError:
                                # Se remettre en détails non
                                details = "NO"
                    except KeyError:
                        raise physiocap_exception_points_invalid( un_nom) 
                            
            # en sortie de boucle on attrape la derniere heure
            if i > 10:
                heure_fin = un_point["DATE"][-8:]
            nb_dia = len( les_diametres)
            nb_sar = len( les_sarments)
            if ( (nb_dia > 0) and ( nb_dia == nb_sar )):
                moyenne_vitesse = sum(les_vitesses) /  len( les_vitesses)
                moyenne_sar = sum(les_sarments) / nb_sar
                moyenne_dia = sum(les_diametres) / nb_dia
                moyenne_biom = sum(les_biom) / len( les_biom)
                moyenne_biomgm2 = sum(les_biomgm2) / len( les_biom)
                moyenne_biomgcep = sum(les_biomgcep) / len( les_biom)
                moyenne_biomm2 = sum(les_biomm2) / len( les_biom)
                moyenne_nbsarmm2 = sum(les_nbsarmm2) / nb_sar
                moyenne_nbsarcep = sum(les_nbsarcep) / nb_sar
                physiocap_log ( self.trUtf8( "== Date : {0}").\
                    format( date_debut)) 
                physiocap_log ( self.trUtf8( "== Moyenne des sarments : {:6.2f}").\
                    format( moyenne_sar)) 
                physiocap_log ( self.trUtf8( "== Moyenne des diamètres : {:5.2f}").\
                    format( moyenne_dia))
                physiocap_log ( self.trUtf8( "== Fin Inter pour {0} <<<< ").\
                format( un_nom))
                #physiocap_log( u"Fin du calcul des moyennes à partir de vos contours" )

                # ###################
                # CRÉATION groupe INTER _ PROJET
                # ###################
                if ( contour_avec_point == 1):
                    if un_groupe != None:
                        vignette_projet = nom_noeud_arbre + SEPARATEUR_ + VIGNETTES_INTER  
                        vignette_existante = un_groupe.findGroup( vignette_projet)
                        if ( vignette_existante == None ):
                            vignette_group_inter = un_groupe.addGroup( vignette_projet)
                        else:
                            # Si vignette preexiste, on ne recommence pas
                            raise physiocap_exception_vignette_exists( nom_noeud_arbre) 
                        
                    chemin_vignettes = os.path.join( chemin_shapes, VIGNETTES_INTER)
                    if not (os.path.exists( chemin_vignettes)):
                        try:
                            os.mkdir( chemin_vignettes)
                        except:
                            raise physiocap_exception_rep( VIGNETTES_INTER)

                
                # Création du Shape moyenne et prj
                # vignette - nom_noeud_arbre + SEPARATEUR_
                nom_court_vignette = nom_noeud_arbre + NOM_MOYENNE + un_nom +  EXT_CRS_SHP     
                nom_court_prj = nom_noeud_arbre + NOM_MOYENNE + un_nom  + EXT_CRS_PRJ     
                #physiocap_log( u"== Vignette court : " + nom_court_vignette )       
                nom_vignette = physiocap_rename_existing_file( os.path.join( chemin_vignettes, nom_court_vignette))        
                nom_prj = physiocap_rename_existing_file( os.path.join( chemin_vignettes, nom_court_prj))        
                physiocap_moyenne_vers_vignette( crs, EPSG_NUMBER, nom_vignette, nom_prj, 
                    geom_poly, un_nom, un_autre_ID, date_debut, heure_fin,
                    moyenne_vitesse, moyenne_sar, moyenne_dia, moyenne_biom, 
                    moyenne_biomgm2, moyenne_biomgcep, moyenne_biomm2, moyenne_nbsarmm2, moyenne_nbsarcep,
                    details)
                                     
                # Memorisation de la parcelle du contour et des moyennes
                les_geoms_poly.append( geom_poly.asPolygon())
                les_parcelles.append( un_nom)
                les_parcelles_ID.append( un_autre_ID)
                les_dates_parcelle.append( date_debut)
                les_heures_parcelle.append( heure_fin)
                les_moyennes_vitesse.append( moyenne_vitesse)
                les_moyennes_sarment.append( moyenne_sar)
                les_moyennes_diametre.append( moyenne_dia)
                les_moyennes_biom.append( moyenne_biom)
                les_moyennes_biomgm2.append( moyenne_biomgm2)
                les_moyennes_biomgcep.append( moyenne_biomgcep)
                les_moyennes_biomm2.append( moyenne_biomm2)
                les_moyennes_nbsarmm2.append( moyenne_nbsarmm2)
                les_moyennes_nbsarcep.append( moyenne_nbsarcep)             
                
                # ###################
                # CRÉATION point
                # ###################
                # point 
                nom_court_point = nom_noeud_arbre + NOM_POINTS + SEPARATEUR_ + un_nom + EXT_CRS_SHP     
                nom_court_point_prj = nom_noeud_arbre + NOM_POINTS + SEPARATEUR_ + un_nom + EXT_CRS_PRJ     
                #physiocap_log( u"== Vignette court : " + nom_court_vignette )       
                nom_point = physiocap_rename_existing_file( os.path.join( chemin_vignettes, nom_court_point))        
                nom_point_prj = physiocap_rename_existing_file( os.path.join( chemin_vignettes, nom_court_point_prj))        
                
                physiocap_moyenne_vers_point( crs, EPSG_NUMBER, nom_point, nom_point_prj, 
                    les_geom_point_feat, les_GID, les_dates, 
                    les_vitesses, les_sarments, les_diametres, les_biom, 
                    les_biomgm2, les_biomgcep, les_biomm2, les_nbsarmm2, les_nbsarcep,
                    details)
                
                # Affichage dans arbre "vignettes" selon les chack dans onglet Affichage
                SHAPE_MOYENNE_PAR_CONTOUR = "NO"
                if dialogue.checkBoxInterMoyennes.isChecked():
                    SHAPE_MOYENNE_PAR_CONTOUR = "YES"
                SHAPE_POINTS_PAR_CONTOUR = "NO"
                if dialogue.checkBoxInterPoints.isChecked():
                    SHAPE_POINTS_PAR_CONTOUR = "YES"
                                                    
                if SHAPE_MOYENNE_PAR_CONTOUR == "YES":
                    vignette_vector = QgsVectorLayer( nom_vignette, nom_court_vignette, 'ogr')
                if SHAPE_POINTS_PAR_CONTOUR == "YES":
                    points_vector = QgsVectorLayer( nom_point, nom_court_point, 'ogr')
                if vignette_group_inter != None:
                    if SHAPE_MOYENNE_PAR_CONTOUR == "YES":
                        QgsMapLayerRegistry.instance().addMapLayer( vignette_vector, False)
                        vector_node = vignette_group_inter.addLayer( vignette_vector)
                    if SHAPE_POINTS_PAR_CONTOUR == "YES":
                        QgsMapLayerRegistry.instance().addMapLayer( points_vector, False)
                    # Ajouter le vecteur dans un groupe
                        vector_point_node = vignette_group_inter.addLayer( points_vector)
                else:
                    # Pas de vignette ...
                    if SHAPE_MOYENNE_PAR_CONTOUR == "YES":
                        QgsMapLayerRegistry.instance().addMapLayer( vignette_vector)
                    if SHAPE_POINTS_PAR_CONTOUR == "YES":
                        QgsMapLayerRegistry.instance().addMapLayer( points_vector)
                # Mise en action du template
                if SHAPE_MOYENNE_PAR_CONTOUR == "YES":
                    if ( os.path.exists( le_template_moyenne)):
                        vignette_vector.loadNamedStyle( le_template_moyenne)                                
                if SHAPE_POINTS_PAR_CONTOUR == "YES":
                    if ( os.path.exists( le_template_point)):
                        points_vector.loadNamedStyle( le_template_point)
                   
            else:
                physiocap_log( self.trUtf8( "== Aucune point dans {0}. Pas de comparaison inter parcellaire").\
                    format( un_nom))       
        
        if ( contour_avec_point == 0):
            return physiocap_message_box( dialogue, 
                    self.trUtf8( "== Aucune point dans {0}. Pas de comparaison inter parcellaire").\
                    format( self.trUtf8( "vos contours")),
                    "information")
        else:
            
            # On a des parcelles dans le contour avec des moyennes
            nom_court_du_contour = os.path.basename( vecteur_poly.name() + EXTENSION_SHP)
            # Inserer "MOYENNES"
            nom_court_du_contour_moyenne = nom_noeud_arbre + NOM_MOYENNE + nom_court_du_contour
            nom_court_du_contour_moyenne_prj = nom_court_du_contour_moyenne [:-4] + EXT_CRS_PRJ[ -4:]     
            nom_contour_moyenne = physiocap_rename_existing_file( 
            os.path.join( chemin_vignettes, nom_court_du_contour_moyenne))        
            nom_contour_moyenne_prj = physiocap_rename_existing_file( 
                os.path.join( chemin_vignettes, nom_court_du_contour_moyenne_prj)) 
            
            physiocap_moyenne_vers_contour( crs, EPSG_NUMBER, nom_contour_moyenne, nom_contour_moyenne_prj, 
                les_geoms_poly, les_parcelles, les_parcelles_ID, les_dates_parcelle,  les_heures_parcelle,
                les_moyennes_vitesse, les_moyennes_sarment, les_moyennes_diametre, les_moyennes_biom, 
                les_moyennes_biomgm2, les_moyennes_biomgcep, les_moyennes_biomm2, les_moyennes_nbsarmm2, 
                les_moyennes_nbsarcep, details) 
                    
            # Affichage du resultat
            nom_court_affichage = nom_noeud_arbre + SEPARATEUR_
            SHAPE_A_AFFICHER = []
            if dialogue.checkBoxInterDiametre.isChecked():
                nom_affichage = nom_court_affichage + 'DIAMETRE' + SEPARATEUR_ + nom_court_du_contour
                qml_is = dialogue.lineEditThematiqueInterDiametre.text().strip('"') + EXTENSION_QML
                SHAPE_A_AFFICHER.append( (nom_affichage, qml_is))
            if dialogue.checkBoxInterBiomasse.isChecked():
                nom_affichage = nom_court_affichage + 'BIOMASSE' + SEPARATEUR_ + nom_court_du_contour
                qml_is = dialogue.lineEditThematiqueInterBiomasse.text().strip('"') + EXTENSION_QML
                SHAPE_A_AFFICHER.append( (nom_affichage, qml_is))
            if dialogue.checkBoxInterLibelle.isChecked():
                nom_affichage = nom_court_affichage + 'LIBELLE' + SEPARATEUR_ + nom_court_du_contour
                qml_is = dialogue.lineEditThematiqueInterLibelle.text().strip('"') + EXTENSION_QML
                SHAPE_A_AFFICHER.append( (nom_affichage, qml_is))

            # Afficher ce contour_moyennes dans arbre "projet"
            k=0
            for titre, unTemplate in SHAPE_A_AFFICHER:
                vector = QgsVectorLayer( nom_contour_moyenne, titre, 'ogr')
               # On se positionne dans l'arbre
                if vignette_group_inter != None:
                    QgsMapLayerRegistry.instance().addMapLayer( vector, False)
                    vector_node = vignette_group_inter.addLayer( vector)
                else:
                    QgsMapLayerRegistry.instance().addMapLayer( vector)
                    
                le_template = os.path.join( dir_template, unTemplate)
                if ( os.path.exists( le_template)):
                    #physiocap_log ( u"Physiocap le template : " + os.path.basename( leTemplate) )
                    vector.loadNamedStyle( le_template)  

        return physiocap_message_box( dialogue, 
                        self.trUtf8( "== Fin des traitements inter-parcellaires"),
                        "information")
          
Ejemplo n.º 3
0
    def physiocap_creer_donnees_resultats(self,
                                          dialogue,
                                          laProjection,
                                          EXT_CRS_SHP,
                                          EXT_CRS_PRJ,
                                          details="NO",
                                          histogrammes="NO",
                                          recursif="NO"):
        """ Récupération des paramètres saisies et 
        creation de l'arbre "source" "texte" et du fichier "resultats"
        Ce sont les résultats de l'analyse filtration des données brutes"""

        # Récupérer les paramètres saisies
        Repertoire_Donnees_Brutes = dialogue.lineEditDirectoryPhysiocap.text(
        )  #___recuperer le repertoire des donnes brutes
        Repertoire_Donnees_Cibles = dialogue.lineEditDirectoryFiltre.text(
        )  #___recuperer le repertoire cible ou enregistrer les resultats
        Nom_Projet = dialogue.lineEditProjet.text(
        )  #___recuperer le nom de projet
        mindiam = float(dialogue.spinBoxMinDiametre.value()
                        )  #___recuperer la valeur de diametre min
        maxdiam = float(dialogue.spinBoxMaxDiametre.value()
                        )  #___recuperer le valeur de diametre max
        max_sarments_metre = float(dialogue.spinBoxMaxSarmentsParMetre.value(
        ))  #___recuperer la valeur du nombre de sarments max par metre

        if details == "YES":  #___Execute si details sont demandes
            interrangs = float(dialogue.spinBoxInterrangs.value()
                               )  #___recuperer la valeur d interrangs
            interceps = float(dialogue.spinBoxInterceps.value()
                              )  #___recuperer la valeur d interceps
            hauteur = float(dialogue.spinBoxHauteur.value()
                            )  #___recuperer la valeur d hauteur
            densite = float(dialogue.doubleSpinBoxDensite.value()
                            )  #___recuperer la valeur de densite
            leCepage = dialogue.fieldComboCepage.currentText(
            )  #___recuperer la valeur de Cepage
            laTaille = dialogue.fieldComboTaille.currentText(
            )  #___recuperer la valeur de Taille

        # Vérification de l'existance ou création du répertoire projet
        chemin_projet = os.path.join(Repertoire_Donnees_Cibles, Nom_Projet)
        if not (os.path.exists(chemin_projet)):
            try:
                os.mkdir(
                    chemin_projet
                )  #___ si le repertoire projet n existe pas--> le creer
            except:
                raise physiocap_exception_rep(Nom_Projet)
        else:
            # Le répertoire existant est renommé en (+1)
            try:
                chemin_projet = physiocap_rename_create_dir(
                    chemin_projet
                )  #___ si le repertoire projet existe deja--> le renommer en ajoutant des nums a la fin du nom de dossier
            except:
                raise physiocap_exception_rep(chemin_projet)

        # Stocker dans la fenetre de synthese le nom du projet
        chemin_base_projet = os.path.basename(chemin_projet)
        dialogue.lineEditDernierProjet.setText(
            chemin_base_projet
        )  #___ Ecrire dans l onglet Synthese le dernier nom de projet
        dialogue.settings = QSettings(PHYSIOCAP_NOM, PHYSIOCAP_NOM)
        dialogue.settings.setValue(
            "Physiocap/dernier_repertoire", chemin_base_projet
        )  #___definir les valeurs des variables : derneir_repertoire
        physiocap_log( self.trUtf8( "** {0} Début du traitement pour le projet Physiocap {1}").\
            format( PHYSIOCAP_UNI, chemin_base_projet))
        physiocap_log( self.trUtf8( "Paramètres pour filtrer les diamètres min : {0} max : {1}").\
            format( str( mindiam), str( maxdiam)))

        # Progress BAR 2 %
        dialogue.progressBar.setValue(2)

        # Verification de l'existance ou création du répertoire des sources MID et fichier csv
        chemin_sources = os.path.join(
            chemin_projet, REPERTOIRE_SOURCES
        )  #___recuperer le chemin des Fichiers MID : fichiers sources
        if not (os.path.exists(chemin_sources)):
            try:
                os.mkdir(chemin_sources
                         )  #___si le dossier n existe pas , le creer???
            except:
                raise physiocap_exception_rep(REPERTOIRE_SOURCES)

        # Fichier de concaténations CSV des résultats bruts
        nom_court_csv_concat = Nom_Projet + SUFFIXE_BRUT_CSV  #___construiree le nom de fichier de concatenation csv = nomProjet_RAW.csv
        try:
            nom_csv_concat, csv_concat = physiocap_open_file(
                nom_court_csv_concat, chemin_sources,
                "w")  #___ creer/ouvrir le fichier en ecriture
        except physiocap_exception_fic as e:
            raise physiocap_exception_csv(nom_court_csv_concat)

        # Création du fichier concaténé
        nom_fichiers_recherches = os.path.join(
            Repertoire_Donnees_Brutes,
            EXTENSION_MID)  #___construire le chemin d acces au fichiers MID

        # Assert le nombre de MID > 0
        # le Tri pour retomber dans l'ordre de Physiocap_V8
        if (recursif == "YES"):
            # On appelle la fonction de recherche récursive
            listeTriee = physiocap_look_for_MID(
                Repertoire_Donnees_Brutes, "YES", REPERTOIRE_SOURCES
            )  #___ lise = recuperer tous les fichiers dans le repertoire  de donnes brutes avec l extention .MID
        else:
            # Non recursif
            listeTriee = sorted(glob.glob(
                nom_fichiers_recherches))  #___Trier les noms de fichiers

        if len(
                listeTriee
        ) == 0:  #___ exception s il y a pas de fichiers MID dans le repertoire de donnes brutes
            raise physiocap_exception_no_mid()

        # Verification si plus de 10 MIDs
        if len(listeTriee) >= 15:
            # Beaucoup de MIDs Poser une question si cancel, on stoppe
            uMsg = self.trUtf8(
                "Plus de 15 fichier MIDs sont à analyser. Temps de traitement > à 1 minute. Voulez-vous continuer ?"
            )  #___ afficher le message si le nombre des fichires depasse 15
            if (physiocap_question_box(self, uMsg)):
                pass  #___ si arret non demande --> rien faire
            else:
                # Arret demandé
                raise physiocap_exception_stop_user(
                )  #___ si l arret est demande  par l utilisateur

        for mid in listeTriee:
            try:
                shutil.copyfileobj(
                    open(mid, "r"), csv_concat
                )  #___ copier les fichiers MID dand le fichier de concatenation csv
                # et copie des MID
                nom_cible = os.path.join(chemin_sources, os.path.basename(mid))
                if os.path.exists(nom_cible):
                    nouveau_long = physiocap_rename_existing_file(nom_cible)
                    shutil.copyfile(
                        mid, nouveau_long
                    )  #___si le fihciers MID existe deja creer un autre en renommant+1
                else:
                    shutil.copy(
                        mid, chemin_sources
                    )  #___copier les fichiers MID dand le repertoire fichiers_source
            except:
                raise physiocap_exception_mid(mid)
        csv_concat.close()  #___ close file handler

        #___verifier si le fichier de concaténation des données n'est pas vide
        if os.path.getsize(nom_csv_concat) == 0:
            uMsg = self.trUtf8( "Le fichier {0} a une taille nulle !").\
                format( nom_court_csv_concat)
            physiocap_message_box(self, uMsg)
            return physiocap_error(self, uMsg)

        # Création la première partie du fichier de synthèse
        fichier_resultat_analyse = chemin_base_projet + SEPARATEUR_ + FICHIER_RESULTAT
        nom_fichier_synthese, fichier_synthese = physiocap_open_file(
            fichier_resultat_analyse, chemin_projet, "w")
        fichier_synthese.write("SYNTHESE PHYSIOCAP\n\n")
        fichier_synthese.write("Générée le : ")
        a_time = time.strftime("%d/%m/%y %H:%M\n", time.localtime())
        fichier_synthese.write(a_time)
        fichier_synthese.write("Répertoire de base ")
        fichier_synthese.write(chemin_base_projet.encode("Utf-8") + "\n")
        fichier_synthese.write(
            "Nom des MID \t\t Date et heures\n=>Nb. Valeurs brutes\tVitesse km/h"
        )
        if (CENTROIDES == "YES"):
            fichier_synthese.write("\nCentroïdes")
        fichier_synthese.write("\n")
        info_mid = physiocap_list_MID(Repertoire_Donnees_Brutes, listeTriee)
        for all_info in info_mid:
            info = all_info.split(";")
            fichier_synthese.write(
                str(info[0]) + "\t" + str(info[1]) + "->" + str(info[2]) +
                "\n")
            # une seule décimale pour vitesse
            fichier_synthese.write("=>\t{0}\t{1:.1f}".format(
                info[3], float(info[4])))
            if (CENTROIDES == "YES"):
                # Centroides
                fichier_synthese.write("\n" + str(info[5]) + "--" +
                                       str(info[6]))
            fichier_synthese.write("\n")

    ##        nom_mid = ""
    ##        for fichier_mid in listeTriee:
    ##            nom_mid = nom_mid + os.path.basename( fichier_mid) + " & "
    ##        fichier_synthese.write("Liste des fichiers MID : " + nom_mid[:-3] + "\n")
    ##        physiocap_log( "Liste des MID : " + nom_mid[:-3])

    #___Nadia___ Création du fichier de sortie csv
        fichier_resultat_CSV = chemin_base_projet + SEPARATEUR_ + FICHIER_RESULTAT_CSV
        nom_fichier_synthese_CSV, fichier_synthese_CSV = physiocap_open_file(
            fichier_resultat_CSV, chemin_projet, "w")
        dialogue.settings.setValue("Physiocap/chemin_fichier_synthese_CSV",
                                   nom_fichier_synthese_CSV)
        # Progress BAR 5 %
        dialogue.progressBar.setValue(5)
        physiocap_log(
            self.trUtf8("Fin de la création csv et début de synthèse")
        )  #___ fin ecriture de la permiere partie du fichiers de synthese

        # Verification de l'existance ou création du répertoire textes
        chemin_textes = os.path.join(chemin_projet, REPERTOIRE_TEXTES)
        if not (os.path.exists(chemin_textes)):
            try:
                os.mkdir(
                    chemin_textes
                )  #___si le repertoire des fichers_texte(resultats) n existe pas --> le creer
            except:
                raise physiocap_exception_rep(REPERTOIRE_TEXTES)

        # Ouverture du fichier des diamètres
        nom_court_fichier_diametre = "diam" + SUFFIXE_BRUT_CSV  #___ fichier diam_RAW.csv
        nom_data_histo_diametre, data_histo_diametre = physiocap_open_file(
            nom_court_fichier_diametre, chemin_textes
        )  #___ Creer ou detruit et re-cree un fichier diam_RAW.csv

        # Appel fonction de creation de fichier
        nom_court_fichier_sarment = "nbsarm" + SUFFIXE_BRUT_CSV  #___fichier nbsarm_RAW.csv
        nom_data_histo_sarment, data_histo_sarment = physiocap_open_file(
            nom_court_fichier_sarment, chemin_textes
        )  #___ Creer ou detruit et re-cree un fichier nbsarm_RAW.csv

        # Todo: V3 ? Supprimer le fichier erreur
        nom_fichier_erreur, erreur = physiocap_open_file(
            "erreurs.csv", chemin_textes)

        # ouverture du fichier source
        csv_concat = open(
            nom_csv_concat, "r"
        )  #___ Ouverture du fichier concatenation et verification s il ya des erreurs
        # Appeler la fonction de vérification du format du fichier csv
        # Si plus de 20 % d'erreur exception est monté
        try:
            pourcentage_erreurs = physiocap_assert_csv(self, csv_concat,
                                                       erreur)
            if (pourcentage_erreurs > TAUX_LIGNES_ERREUR):
                fichier_synthese.write(
                    "\nTrop d'erreurs dans les données brutes")
                # Todo : V3 question selon le taux de lignes en erreur autorisées
                #raise physiocap_exception_err_csv( pourcentage_erreurs)
        except:
            raise

        # Progress BAR 10 %
        dialogue.progressBar.setValue(10)
        fichier_synthese.write("\n\nPARAMETRES SAISIS "
                               )  #___ Deuxieme partie du fichier de synthese

        if os.path.getsize(
                nom_csv_concat
        ) == 0:  #___ si le fichier concatention est vide, raise error
            uMsg = self.trUtf8( "Le fichier {0} a une taille nulle !").\
                format( nom_court_csv_concat)
            physiocap_message_box(self, uMsg)
            return physiocap_error(self, uMsg)

        # ouverture du fichier source
        csv_concat = open(nom_csv_concat, "r")

        # Appeler la fonction de traitement
        if histogrammes == "YES":  #___ si les histogrammes sont demandes --> appeler la fonction qui fait le traitement
            #################
            physiocap_fichier_histo(self, csv_concat, data_histo_diametre,
                                    data_histo_sarment, erreur)
            #################
            # Fermerture des fichiers
            data_histo_diametre.close()
            data_histo_sarment.close()
        csv_concat.close()
        erreur.close()

        # Progress BAR 12 %
        dialogue.progressBar.setValue(12)

        # Verification de l'existance
        chemin_histos = os.path.join(chemin_projet, REPERTOIRE_HISTOS)
        if not (os.path.exists(chemin_histos)):
            try:
                os.mkdir(
                    chemin_histos
                )  #___ si le dossier histogrammes n existe pas --> le creer
            except:
                raise physiocap_exception_rep(REPERTOIRE_HISTOS)

        if histogrammes == "YES":
            # creation d'un histo
            nom_data_histo_sarment, data_histo_sarment = physiocap_open_file(
                nom_court_fichier_sarment, chemin_textes, 'r')
            nom_histo_sarment, histo_sarment = physiocap_open_file(
                FICHIER_HISTO_SARMENT, chemin_histos)
            name = nom_histo_sarment
            physiocap_tracer_histo(
                data_histo_sarment, name, 0, 50, "SARMENT au m",
                "FREQUENCE en %", "HISTOGRAMME NBSARM AVANT TRAITEMENT"
            )  #___appel de la fonction qui trace l histogramme NBSARM AVANT TRAITEMENT
            histo_sarment.close()

            nom_data_histo_diametre, data_histo_diametre = physiocap_open_file(
                nom_court_fichier_diametre, chemin_textes, 'r')
            nom_histo_diametre, histo_diametre = physiocap_open_file(
                FICHIER_HISTO_DIAMETRE, chemin_histos)
            name = nom_histo_diametre
            physiocap_tracer_histo(
                data_histo_diametre, name, 0, 30, "DIAMETRE en mm",
                "FREQUENCE en %", "HISTOGRAMME DIAMETRE AVANT TRAITEMENT"
            )  #___appel de la fonction qui trace l histogramme DIAMETRE AVANT TRAITEMENT
            histo_diametre.close()

            physiocap_log(
                self.trUtf8("Fin de la création des histogrammes bruts"))
        else:
            physiocap_log(self.trUtf8("Pas de création des histogrammes"))

        # Progress BAR 15 %
        dialogue.progressBar.setValue(15)

        # Création des csv
        nom_court_csv_sans_0 = Nom_Projet + SEPARATEUR_ + "OUT.csv"  #___creation du fichier NomProjet_OUT.csv --> fichier sans zeros
        nom_csv_sans_0, csv_sans_0 = physiocap_open_file(
            nom_court_csv_sans_0, chemin_textes)

        nom_court_csv_avec_0 = Nom_Projet + SEPARATEUR_ + "OUT0.csv"  #___creation du fichier NomProjet_OUT0.csv --> fichier avec zeros
        nom_csv_avec_0, csv_avec_0 = physiocap_open_file(
            nom_court_csv_avec_0, chemin_textes)

        nom_court_fichier_diametre_filtre = "diam_FILTERED.csv"  #___diam_FILTERED.csv
        nom_fichier_diametre_filtre, diametre_filtre = physiocap_open_file(
            nom_court_fichier_diametre_filtre, chemin_textes)

        # Ouverture du fichier source et re ouverture du ficheir erreur
        csv_concat = open(nom_csv_concat, "r")
        erreur = open(nom_fichier_erreur, "a")

        # Filtrage des données Physiocap
        #################
        if details == "NO":  #___ si les details ne sont pas demandes--> donner des valeurs par defaut pour les parametres details
            interrangs = 1
            interceps = 1
            densite = 1
            hauteur = 1
        retour_filtre = physiocap_filtrer( dialogue, csv_concat, csv_sans_0, csv_avec_0, \
                    diametre_filtre, nom_fichier_synthese, erreur, \
                    mindiam, maxdiam, max_sarments_metre, details,
                    interrangs, interceps, densite, hauteur)#___*********Appel de la fonction physiocap_filtrer de Physiocap_CIVC pour remplir le ficier csv qui va etre utilse pour le creation du shapefile**********
        #################
        # Fermeture du fichier destination
        csv_sans_0.close()
        csv_avec_0.close()
        diametre_filtre.close()
        erreur.close()
        # Fermerture du fichier source
        csv_concat.close()

        # Todo : V3 ? Gerer cette erreur par exception
        if retour_filtre != 0:
            uMsg = self.trUtf8( "Erreur bloquante : problème lors du filtrage des données de {0}").\
                format( nom_court_csv_concat)
            return physiocap_error(self, uMsg)

        # Progress BAR 60 %
        dialogue.progressBar.setValue(41)

        if histogrammes == "YES":  #___ si histogrammes sont demandes --> tracer le troisieme : DIAMETRE APRES TRAITEMENT
            # Histo apres filtration
            nom_fichier_diametre_filtre, diametre_filtre = physiocap_open_file(
                nom_court_fichier_diametre_filtre, chemin_textes, "r")
            nom_histo_diametre_filtre, histo_diametre = physiocap_open_file(
                FICHIER_HISTO_DIAMETRE_FILTRE, chemin_histos)

            physiocap_tracer_histo( diametre_filtre, nom_histo_diametre_filtre, 0, 30, \
                "DIAMETRE en mm", "FREQUENCE en %", "HISTOGRAMME DIAMETRE APRES TRAITEMENT")
            diametre_filtre.close()
            physiocap_log(
                self.trUtf8("Fin de la création de l'histogramme filtré"))

        # On écrit dans le fichiers résultats les paramètres du modéle #___ 3 eme partie du fichier de synthese
        fichier_synthese = open(nom_fichier_synthese, "a")
        if details == "NO":
            fichier_synthese.write("\nAucune information parcellaire saisie\n")
        else:
            fichier_synthese.write("\n")
            msg = "Cépage : %s \n" % leCepage.encode("Utf-8")
            fichier_synthese.write(msg)
            fichier_synthese.write("Type de taille : %s\n" % laTaille)
            fichier_synthese.write("Hauteur de végétation : %s cm\n" % hauteur)
            fichier_synthese.write("Densité des bois de taille : %s \n" %
                                   densite)
            fichier_synthese.write("Ecartement entre rangs : %s cm\n" %
                                   interrangs)
            fichier_synthese.write("Ecartement entre ceps : %s cm\n" %
                                   interceps)

        fichier_synthese.write("\n")
        fichier_synthese.write(
            "Nombre de sarments max au mètre linéaire: %s \n" %
            max_sarments_metre)
        fichier_synthese.write("Diamètre minimal : %s mm\n" % mindiam)
        fichier_synthese.write("Diamètre maximal : %s mm\n" % maxdiam)
        fichier_synthese.close()

        # Progress BAR 42%
        dialogue.progressBar.setValue(42)

        # Verification de l'existance ou création du répertoire des sources MID et fichier csv
        chemin_shapes = os.path.join(chemin_projet, REPERTOIRE_SHAPEFILE)
        if not (os.path.exists(chemin_shapes)):
            try:
                os.mkdir(
                    chemin_shapes
                )  #____si le dossier shapefile n existe pas --> le creer
                dialogue.settings.setValue("Physiocap/chemin_shapes",
                                           chemin_shapes)
            except:
                raise physiocap_exception_rep(REPERTOIRE_SHAPEFILE)

        # Création des shapes sans 0
        nom_court_shape_sans_0 = Nom_Projet + NOM_POINTS + EXT_CRS_SHP  #___ construire ele nom du fichier NomProjet_POINTS.shp
        nom_shape_sans_0 = os.path.join(chemin_shapes, nom_court_shape_sans_0)
        dialogue.settings.setValue("Physiocap/nom_shape_sans_0",
                                   nom_shape_sans_0)
        nom_court_prj_sans_0 = Nom_Projet + NOM_POINTS + EXT_CRS_PRJ
        nom_prj_sans_0 = os.path.join(chemin_shapes, nom_court_prj_sans_0)

        # Si le shape existe dejà il faut le détruire
        if os.path.isfile(nom_shape_sans_0):
            physiocap_log(
                self.trUtf8("Le shape file existant déjà, il est détruit."))
            os.remove(nom_shape_sans_0)

        # cas sans 0, on demande la synthese en passant le nom du fichier
        retour = physiocap_csv_vers_shapefile(dialogue, 45, nom_csv_sans_0,
                                              nom_shape_sans_0, nom_prj_sans_0,
                                              laProjection,
                                              nom_fichier_synthese, details)
        if retour != 0:
            return physiocap_error( self, self.trUtf8(\
                "Erreur bloquante : problème lors de la création du shapefile {0}").\
                format(str ( nom_court_shape_sans_0)))

        # Progress BAR 65 %
        dialogue.progressBar.setValue(65)

        # Création des shapes avec 0
        nom_court_shape_avec_0 = Nom_Projet + NOM_POINTS + EXTENSION_POUR_ZERO + EXT_CRS_SHP
        nom_shape_avec_0 = os.path.join(chemin_shapes, nom_court_shape_avec_0)
        nom_court_prj_avec_0 = Nom_Projet + NOM_POINTS + EXTENSION_POUR_ZERO + EXT_CRS_PRJ
        nom_prj_avec_0 = os.path.join(chemin_shapes, nom_court_prj_avec_0)
        # Si le shape existe dejà il faut le détruire
        if os.path.isfile(nom_shape_avec_0):
            physiocap_log(
                self.trUtf8("Le shape file existant déjà, il est détruit."))
            os.remove(nom_shape_avec_0)

        # cas avec 0, pas de demande de synthese
        retour = physiocap_csv_vers_shapefile(dialogue, 65, nom_csv_avec_0,
                                              nom_shape_avec_0, nom_prj_avec_0,
                                              laProjection, "NO", details)
        if retour != 0:
            return physiocap_error( self, self.trUtf8( \
                "Erreur bloquante : problème lors de la création du shapefile {0}").\
                format( str ( nom_court_shape_avec_0)))

        # Progress BAR 95%
        dialogue.progressBar.setValue(95)

        # Creer un groupe pour cette analyse
        # Attention il faut qgis > 2.4 metadata demande V2.4 mini
        root = QgsProject.instance().layerTreeRoot()
        # Nommmer le groupe chemin_base_projet
        sous_groupe = root.addGroup(chemin_base_projet)

        # Récupérer des styles pour chaque shape
        dir_template = dialogue.fieldComboThematiques.currentText()
        # Affichage des différents shapes dans Qgis
        SHAPE_A_AFFICHER = []
        qml_is = ""
        if dialogue.checkBoxDiametre.isChecked():
            qml_is = dialogue.lineEditThematiqueDiametre.text().strip(
                '"') + EXTENSION_QML
            # Pas de choix du shape, car il faut pour Inter un diam sans 0
            SHAPE_A_AFFICHER.append((nom_shape_sans_0, 'DIAMETRE mm', qml_is))
        if dialogue.checkBoxSarment.isChecked():
            qml_is = dialogue.lineEditThematiqueSarment.text().strip(
                '"') + EXTENSION_QML
            # Choix du shape à afficher
            if (dialogue.fieldComboShapeSarment.currentIndex() == 0):
                SHAPE_A_AFFICHER.append(
                    (nom_shape_sans_0, 'SARMENT par m', qml_is))
            else:
                SHAPE_A_AFFICHER.append(
                    (nom_shape_avec_0, 'SARMENT par m', qml_is))

        if dialogue.checkBoxBiomasse.isChecked():
            qml_is = dialogue.lineEditThematiqueBiomasse.text().strip(
                '"') + EXTENSION_QML
            # Choix du shape à afficher
            if (dialogue.fieldComboShapeBiomasse.currentIndex() == 0):
                SHAPE_A_AFFICHER.append((nom_shape_sans_0, 'BIOMASSE', qml_is))
            else:
                SHAPE_A_AFFICHER.append((nom_shape_avec_0, 'BIOMASSE', qml_is))
        if dialogue.checkBoxVitesse.isChecked():
            qml_is = dialogue.lineEditThematiqueVitesse.text().strip(
                '"') + EXTENSION_QML
            # Choix du shape à afficher
            if (dialogue.fieldComboShapeVitesse.currentIndex() == 0):
                SHAPE_A_AFFICHER.append(
                    (nom_shape_sans_0, 'VITESSE km/h', qml_is))
            else:
                SHAPE_A_AFFICHER.append(
                    (nom_shape_avec_0, 'VITESSE km/h', qml_is))

        for shapename, titre, un_template in SHAPE_A_AFFICHER:
            ##            if ( dialogue.fieldComboFormats.currentText() == POSTGRES_NOM ):
            ##                uri_nom = physiocap_quel_uriname( dialogue)
            ##                #physiocap_log( u"URI nom : " + str( uri_nom))
            ##                uri_modele = physiocap_get_uri_by_layer( dialogue, uri_nom )
            ##                if uri_modele != None:
            ##                    uri_connect, uri_deb, uri_srid, uri_fin = physiocap_tester_uri( dialogue, uri_modele)
            ##                    nom_court_shp = os.path.basename( shapename)
            ##                    #TABLES = "public." + nom_court_shp
            ##                    uri = uri_deb +  uri_srid + \
            ##                       " key='gid' type='POINTS' table=" + nom_court_shp[ :-4] + " (geom) sql="
            ##    ##              "dbname='testpostgis' host='localhost' port='5432'" + \
            ##    ##              " user='******' password='******' SRID='2154'" + \
            ##    ##              " key='gid' type='POINTS' table=" + nom_court_shp[ :-4] + " (geom) sql="
            ##    ##                physiocap_log ( "Création dans POSTGRES : >>" + uri + "<<")
            ##    ##                vectorPG = QgsVectorLayer( uri, titre, POSTGRES_NOM)
            ##                else:
            ##                    aText = self.trUtf8( "Pas de connecteur vers Postgres : {0}. On continue avec des shapefiles").\
            ##                         format ((str( uri_nom)))
            ##                    physiocap_log( aText)
            ##                    # Remettre le choix vers ESRI shape file
            ##                    dialogue.fieldComboFormats.setCurrentIndex( 0)

            #physiocap_log( u"Physiocap : Afficher layer ")
            vector = QgsVectorLayer(shapename, titre, 'ogr')
            QgsMapLayerRegistry.instance().addMapLayer(vector, False)
            # Ajouter le vecteur dans un groupe
            vector_node = sous_groupe.addLayer(vector)
            le_template = os.path.join(dir_template, un_template)
            if (os.path.exists(le_template)):
                #physiocap_log( u"Physiocap le template : " + os.path.basename( le_template))
                vector.loadNamedStyle(le_template)

        # Créer un ficher de sortie CSV de synthese___Nadia___
        retour_gen_cont = generer_contour_fin(dialogue,
                                              nom_fichier_synthese_CSV,
                                              nom_shape_sans_0, sous_groupe)
        if retour_gen_cont != 0:
            return physiocap_error(self, self.trUtf8( \
                "Erreur bloquante : problème lors de la génération du contour "))

        # Fichier de synthese dans la fenetre resultats
        fichier_synthese = open(nom_fichier_synthese, "r")
        while True:
            ligne = fichier_synthese.readline()  # lit les lignes 1 à 1
            physiocap_write_in_synthese(dialogue, ligne)
            if not ligne:
                fichier_synthese.close
                break

        # Progress BAR 95 %
        dialogue.progressBar.setValue(95)

        # Mettre à jour les histogrammes dans fenetre resultat
        if histogrammes == "YES":
            if (dialogue.label_histo_sarment.setPixmap(
                    QPixmap(nom_histo_sarment))):
                physiocap_log(
                    self.trUtf8("Physiocap histogramme sarment chargé"))
            if (dialogue.label_histo_diametre_avant.setPixmap(
                    QPixmap(nom_histo_diametre))):
                physiocap_log(
                    self.trUtf8("Physiocap histogramme diamètre chargé"))
            if (dialogue.label_histo_diametre_apres.setPixmap(
                    QPixmap(nom_histo_diametre_filtre))):
                physiocap_log(
                    self.trUtf8(
                        "Physiocap histogramme diamètre filtré chargé"))
        else:
            dialogue.label_histo_sarment.setPixmap(
                QPixmap(FICHIER_HISTO_NON_CALCULE))
            dialogue.label_histo_diametre_avant.setPixmap(
                QPixmap(FICHIER_HISTO_NON_CALCULE))
            dialogue.label_histo_diametre_apres.setPixmap(
                QPixmap(FICHIER_HISTO_NON_CALCULE))
            physiocap_log(self.trUtf8("Physiocap pas d'histogramme calculé"))

        # Progress BAR 100 %
        dialogue.progressBar.setValue(100)
        # Fin
        physiocap_log ( self.trUtf8( "** {0} a affiché des couches dans le groupe {1}").\
            format( PHYSIOCAP_UNI, chemin_base_projet))
        physiocap_fill_combo_poly_or_point(dialogue)
        #physiocap_log ( u"Mise à jour des poly et points")
        return 0
Ejemplo n.º 4
0
def physiocap_csv_vers_shapefile( self, progress_barre, csv_name, shape_name, prj_name, laProjection, 
    nom_fichier_synthese = "NO", details = "NO"):
    """ Creation de shape file à partir des données des CSV
    Si nom_fichier_synthese n'est pas "NO", on produit les moyennes dans le fichier 
    qui se nomme nom_fichier_synthese
    Selon la valeur de détails , on crée les 5 premiers ("NO") ou tous les attibuts ("YES")
    """
    crs = None
    #Préparation de la liste d'arguments
    x,y,nbsarmshp,diamshp,biomshp,dateshp,vitesseshp= [],[],[],[],[],[],[]
    nbsarmm2,nbsarcep,biommm2,biomgm2,biomgcep=[],[],[],[],[]
    
    un_fic = open( csv_name, "r")
    lignes = un_fic.readlines()
    nombre_ligne = len( lignes)
    un_fic.close()
    progress_step = int( nombre_ligne / 19)
    barre = 1
    
    #Lecture des data dans le csv et stockage dans une liste
    with open(csv_name, "rt") as csvfile:
        try:
            r = csv.reader(csvfile, delimiter=";")
        except NameError:
            uText = u"Erreur bloquante : module csv n'est pas accessible."
            physiocap_error( self, uText)
            return -1

        for jj, row in enumerate( r):
            #skip header
            if jj > 0: 
                # ON fait avancer la barre de progression de 19 points
                if ( jj > progress_step * barre):
                    barre = barre + 1
                    progress_barre = progress_barre + 1
                    self.progressBar.setValue( progress_barre)
                    
                crs = None
                if ( laProjection == "L93"):
                    x.append(float(row[2]))
                    y.append(float(row[3]))
                    crs = QgsCoordinateReferenceSystem(EPSG_NUMBER_L93, 
                        QgsCoordinateReferenceSystem.PostgisCrsId)
                if ( laProjection == "GPS"):
                    x.append(float(row[0]))
                    y.append(float(row[1]))
                    crs = QgsCoordinateReferenceSystem(EPSG_NUMBER_GPS, 
                        QgsCoordinateReferenceSystem.PostgisCrsId)
                nbsarmshp.append(float(row[4]))
                diamshp.append(float(row[5]))
                biomshp.append(float(row[6]))
                dateshp.append(str(row[7]))
                vitesseshp.append(float(row[8]))
                if details == "YES":
                    # Niveau de detail demandé
                    # assert sur len row
                    if len(row) != 14:
                        return physiocap_error( self, u"Le nombre de colonnes :" +
                                str( len(row)) + 
                                u" du cvs ne permet pas le calcul détaillé")
                    nbsarmm2.append(float(row[9]))
                    nbsarcep.append(float(row[10]))
                    biommm2.append(float(row[11]))
                    biomgm2.append(float(row[12]))
                    biomgcep.append(float(row[13]))
                
    # Prepare les attributs
    les_champs = QgsFields()
    # V1.0 Ajout du GID
##    les_champs.append( QgsField("gid", QVariant.Int, "integer", 10))
##    les_champs.append( QgsField("date", QVariant.String, "string", 25))
##    les_champs.append( QgsField("vitesse", QVariant.Double, "double", 10,2))
##    les_champs.append(QgsField("nbsarm",  QVariant.Double, "double", 10,2))
##    les_champs.append(QgsField("diam",  QVariant.Double, "double", 10,2))
##    les_champs.append(QgsField("biom", QVariant.Double,"double", 10,2)) 
##    if details == "YES":
##        # Niveau de detail demandé
##        les_champs.append(QgsField("nbsarmm2", QVariant.Double,"double", 10,2))
##        les_champs.append(QgsField("nbsarmcep", QVariant.Double,"double", 10,2))
##        les_champs.append(QgsField("biomm2", QVariant.Double,"double", 10,2))
##        les_champs.append(QgsField("biomgm2", QVariant.Double,"double", 10,2))
##        les_champs.append(QgsField("biomgcep", QVariant.Double,"double", 10,2))
## 
    # V1.0 Ajout du GID
    les_champs.append( QgsField("GID", QVariant.Int, "integer", 10))
    les_champs.append( QgsField("DATE", QVariant.String, "string", 25))
    les_champs.append( QgsField("VITESSE", QVariant.Double, "double", 10,2))
    les_champs.append(QgsField("NBSARM",  QVariant.Double, "double", 10,2))
    les_champs.append(QgsField("DIAM",  QVariant.Double, "double", 10,2))
    les_champs.append(QgsField("BIOM", QVariant.Double,"double", 10,2)) 
    if details == "YES":
        # Niveau de detail demandé
        les_champs.append(QgsField("NBSARMM2", QVariant.Double,"double", 10,2))
        les_champs.append(QgsField("NBSARCEP", QVariant.Double,"double", 10,2))
        les_champs.append(QgsField("BIOMM2", QVariant.Double,"double", 10,2))
        les_champs.append(QgsField("BIOMGM2", QVariant.Double,"double", 10,2))
        les_champs.append(QgsField("BIOMGCEP", QVariant.Double,"double", 10,2))

    # Creation du Shape
    writer = QgsVectorFileWriter( shape_name, "utf-8", les_champs, 
            QGis.WKBPoint, crs , "ESRI Shapefile")
            
    #Ecriture du shp
    for j,k in enumerate(x):
        feat = QgsFeature()
        feat.setGeometry( QgsGeometry.fromPoint(QgsPoint(k,y[j]))) #écrit la géométrie
        if details == "YES":
            # Ecrit tous les attributs
           feat.setAttributes( [ j, dateshp[j], vitesseshp[j], nbsarmshp[j], 
                                diamshp[j], biomshp[j],
                                nbsarmm2[j], nbsarcep[j], biommm2[j], 
                                biomgm2[j], biomgcep[j]]) 
        else:
            # Ecrit les 5 premiers attributs
            feat.setAttributes( [ j, dateshp[j], vitesseshp[j], nbsarmshp[j], 
                                diamshp[j], biomshp[j]])
        # Ecrit le feature
        writer.addFeature( feat)

    # Flush vector
    del writer
    
    # Cas PG
##    if (self.fieldComboFormats.currentText() == POSTGRES_NOM ):
##        # Todo ; fonction physiocap_creer_PG_par_copie_vecteur( uri_nom, shape_modele)
##        # Vérifier si une connexion Physiocap existe
##        uri_nom = physiocap_quel_uriname( self)
##        uri_modele = physiocap_get_uri_by_layer( self, uri_nom )
##        if uri_modele != None:
##            uri_connect, uri_deb, uri_srid, uri_fin = physiocap_tester_uri( self, uri_modele)
##            if uri_deb != None:
##                nom_court_shp = os.path.basename( shape_name)
##                #laTable = "'public.\"" + nom_court_shp[ :-4] + "\"'"
##                laTable = "'\"" + nom_court_shp[ :-4] + "\"'"
##                reponse = physiocap_existe_table_uri( self, uri_deb, laTable)
##                if reponse != None:
##                    if reponse == True:
##                        laTable = "\"" + nom_court_shp[ :-4] + "\""
##                        #physiocap_log( u"Table existe déjà : " + str( laTable))
##                        # Cette table existe déjà = > drop 
##                        reponse_drop = physiocap_detruit_table_uri( self, uri_deb, laTable)
##                        if reponse_drop == None:
##                            aText = u"Problème lors de la destruction de la table : " + str( laTable)
##                            physiocap_log( aText)
##                            physiocap_error( self, aText)  
##                            # Todo : gérer par exception physiocap_exception_pg
##                            return physiocap_message_box( self, 
##                                self.tr( aText),
##                                "warning")                   
##                    # Creer la table
##                    laTable = nom_court_shp[ :-4] 
##                    vector = QgsVectorLayer( shape_name, "INUTILE", 'ogr')
##                    uri = uri_deb + uri_srid + \
##                        " key=gid type=POINTS table=" + laTable + uri_fin
## #       uri = "dbname='testpostgis' host=localhost port=5432" + \
## #             " user='******' password='******'" + \
## #              " key=gid type=POINTS table=" + nom_court_shp[ :-4] + " (geom) sql="
##                    error = QgsVectorLayerImport.importLayer( vector, uri, POSTGRES_NOM, crs, False, False)
##                    if error[0] != 0:
##                        physiocap_error( self, u"Problème Postgres : " + str(error[0]) + " => " + str(error[1]))
##                        #iface.messageBar().pushMessage(u'Phyqiocap Error', error[1], QgsMessageBar.CRITICAL, 5)    
## #                    else:
## #                        # Sans erreur on détruit le shape file
## #                        if os.path.isfile( shape_name):
## #                            os.remove( shape_name)
##                else:
##                    aText = u"Vérification problématique pour la table : " + \
##                        str( laTable) + \
##                        u". On continue avec des shapefiles"
##                    physiocap_log( aText)
##                    piocap_error( aText)
##                    # Remettre le choix vers ESRI shape file
##                    self.fieldComboFormats.setCurrentIndex( 0)   
##            else:
##                aText = u"Pas de connection possible à Postgres : " + \
##                    str( uri_nom) + \
##                    u". On continue avec des shapefiles"
##                physiocap_log( aText)
##                physiocap_error( self, aText)
##                # Remettre le choix vers ESRI shape file
##                self.fieldComboFormats.setCurrentIndex( 0)   
##                
##        else:
##            aText = u"Pas de connecteur vers Postgres : " + \
##                        str( uri_nom) + \
##                        u". On continue avec des shapefiles"
##            physiocap_log( aText)
##            physiocap_error( self, aText)
##            # Remettre le choix vers ESRI shape file
##            self.fieldComboFormats.setCurrentIndex( 0)   
##    else:
    # Create the PRJ file
    prj = open(prj_name, "w")
    epsg = 'inconnu'
    if ( laProjection == PROJECTION_L93):
        # Todo: V1.x ? Faire aussi un fichier de metadata 
        epsg = EPSG_TEXT_L93
    if ( laProjection == PROJECTION_GPS):
        #  prj pour GPS 4326
        epsg = EPSG_TEXT_GPS
        
    prj.write(epsg)
    prj.close()    
        
    # Création de la synthese
    if nom_fichier_synthese != "NO":
        # ASSERT Le fichier de synthese existe
        if not os.path.isfile( nom_fichier_synthese):
            uMsg =u"Le fichier de synthese " + nom_fichier_synthese + "n'existe pas"
            physiocap_log( uMsg)
            return physiocap_error( self, uMsg)
        
        # Ecriture des resulats
        fichier_synthese = open(nom_fichier_synthese, "a")
        try:
            fichier_synthese.write("\n\nSTATISTIQUES\n")
            fichier_synthese.write("Vitesse moyenne d'avancement  \n	mean : %0.1f km/h\n" %np.mean(vitesseshp))
            fichier_synthese.write("Section moyenne \n	mean : %0.2f mm\t std : %0.1f\n" %(np.mean(diamshp), np.std(diamshp)))
            fichier_synthese.write("Nombre de sarments au m \n	mean : %0.2f  \t std : %0.1f\n" %(np.mean(nbsarmshp), np.std(nbsarmshp)))
            fichier_synthese.write("Biomasse en mm²/m linéaire \n	mean : %0.1f\t std : %0.1f\n" %(np.mean(biomshp), np.std(biomshp)))
            if details == "YES":
                fichier_synthese.write("Nombre de sarments au m² \n	 mean : %0.1f  \t std : %0.1f\n" %(np.mean(nbsarmm2), np.std(nbsarmm2)))
                fichier_synthese.write("Nombre de sarments par cep \n	mean : %0.1f \t\t std : %0.1f\n" %(np.mean(nbsarcep), np.std(nbsarcep)))
                fichier_synthese.write("Biomasse en mm²/m² \n	mean : %0.1f\t std : %0.1f\n" %(np.mean(biommm2), np.std(biommm2)))
                fichier_synthese.write("Biomasse en gramme/m² \n	mean : %0.1f\t std : %0.1f\n" %(np.mean(biomgm2), np.std(biomgm2)))
                fichier_synthese.write("Biomasse en gramme/cep \n	mean : %0.1f\t std : %0.1f\n" %(np.mean(biomgcep), np.std(biomgcep))) 
        except:
            msg = "Erreur bloquante durant les calculs de moyennes\n"
            physiocap_error( self, msg )
            return -1
                    
        fichier_synthese.close()
    return 0
Ejemplo n.º 5
0
def physiocap_filtrer(self, src, csv_sans_0, csv_avec_0, diametre_filtre, 
    nom_fichier_synthese, err, 
    mindiam, maxdiam, max_sarments_metre, details,
    eer, eec, d, hv):
    """Fonction de traitement.
    Filtre ligne par ligne les données de source (src) pour les valeurs 
    comprises entre mindiam et maxdiam et verifie si on n'a pas atteint le max_sarments_metre.
    Le résultat est écrit au fur et à mesure dans les fichiers 
    csv_sans_0 et csv_avec_0 mais aussi diametre_filtre 
    La synthese est allongé
    "details" pilote l'ecriture de 5 parametres ou de la totalité des 10 parametres 
    """
    
    #S'il n'existe pas de données parcellaire, le script travaille avec les données brutes
    if details == "NO" :
        csv_sans_0.write("%s\n" % ("X ; Y ; XL93 ; YL93 ; NBSARM ; DIAM ; BIOM ; Date ; Vitesse")) # ecriture de l'entête
        csv_avec_0.write("%s\n" % ("X ; Y ; XL93 ; YL93 ; NBSARM ; DIAM ; BIOM ; Date ; Vitesse")) # ecriture de l'entête
    #S'il existe des données parcellaire, le script travaille avec les données brutes et les données calculées
    else:
        # Assert details == "YES"
        if details != "YES" : 
            return physiocap_error( self, self.trUtf8("Problème majeur dans le choix du détail du parcellaire"))
        csv_sans_0.write("%s\n" % ("X ; Y ; XL93 ; YL93 ; NBSARM ; DIAM ; BIOM ; Date ; Vitesse ; \
            NBSARMM2 ; NBSARCEP ; BIOMMM2 ; BIOMGM2 ; BIOMGCEP ")) # ecriture de l'entête
        csv_avec_0.write("%s\n" % ("X ; Y ; XL93 ; YL93 ; NBSARM ; DIAM ; BIOM ; Date ; Vitesse ; \
            NBSARMM2 ; NBSARCEP ; BIOMMM2 ; BIOMGM2 ; BIOMGCEP ")) # ecriture de l'entête

    nombre_ligne = 0
    # Pour progress bar entre 15 et 40
    lignes = src.readlines()
    max_lignes = len(lignes)
    progress_step = int( max_lignes / 25)
    #physiocap_log("Bar step: " + str( progress_step))
    progress_bar = 15
    barre = 1
    for ligne in lignes :
        nombre_ligne = nombre_ligne + 1
        if not ligne: break 
        
        # Progress BAR de 15 à 40 %
        if ( nombre_ligne > barre * progress_step):
            progress_bar = progress_bar + 1
            barre = barre + 1
            self.progressBar.setValue( progress_bar)  
                
        comptage = ligne.count(",") # compte le nombre de virgules
        result = ligne.split(",") # split en fonction des virgules

        try : # accompli cette fonction si pas d'erreur sinon except
            XY = [float(x) for x in result[1:9]]   # on extrait les XY et on les transforme en float  
            # On transforme les WGS84 en L93
            WGS84 = osr.SpatialReference()
            WGS84.ImportFromEPSG( EPSG_NUMBER_GPS)
            LAMB93 = osr.SpatialReference()
            LAMB93.ImportFromEPSG( EPSG_NUMBER_L93)
            transformation1 = osr.CoordinateTransformation(WGS84,LAMB93) 
            L93 = transformation1.TransformPoint(XY[0],XY[1])
            diams = [float(x) for x in result[9:NB_VIRGULES+1]] # on extrait les diams et on les transforme en float 
            diamsF = [i for i in diams if i > mindiam and i < maxdiam ] # on filtre les diams avec les paramètres entrés ci-dessus
            if details == "NO" :
                if len(diamsF)==0: # si le nombre de diamètre après filtrage = 0 alors pas de mesures
                    nbsarm = 0
                    diam =0
                    biom = 0
                    csv_avec_0.write("%.7f%s%.7f%s%.7f%s%.7f%s%i%s%i%s%i%s%s%s%0.2f\n" %(XY[0],";",XY[1],";",L93[0],";",L93[1],";",nbsarm,";",diam ,";",biom,";",result[0],";",XY[7]))  # on écrit la ligne dans le fichier OUT0.csv  
                elif comptage==NB_VIRGULES and len(diamsF)>0 : # si le nombre de diamètre après filtrage != 0 alors mesures
                    if XY[7] != 0:
                        nbsarm = len(diamsF)/(XY[7]*1000/3600)
                    else:
                        nbsarm = 0
                    if nbsarm > 1 and nbsarm < max_sarments_metre :                   
                        diam =sum(diamsF)/len(diamsF)
                        biom=3.1416*(diam/2)*(diam/2)*nbsarm
                        csv_avec_0.write("%.7f%s%.7f%s%.7f%s%.7f%s%0.2f%s%.2f%s%.2f%s%s%s%0.2f\n" %(XY[0],";",XY[1],";",L93[0],";",L93[1],";",nbsarm,";",diam,";",biom,";",result[0],";",XY[7])) # on écrit la ligne dans le fichier OUT0.csv 
                        csv_sans_0.write("%.7f%s%.7f%s%.7f%s%.7f%s%0.2f%s%.2f%s%.2f%s%s%s%0.2f\n" %(XY[0],";",XY[1],";",L93[0],";",L93[1],";",nbsarm,";",diam,";",biom,";",result[0],";",XY[7])) # on écrit la ligne dans le fichier OUT.csv
                        for n in range(len(diamsF)) :
                            diametre_filtre.write("%f%s" %(diamsF[n],";"))
            elif details == "YES" :
                if len(diamsF)==0: # si le nombre de diamètre après filtrage = 0 alors pas de mesures
                    nbsarm = 0
                    diam =0
                    biom = 0
                    nbsarmm2 = 0
                    nbsarcep = 0
                    biommm2 = 0
                    biomgm2 = 0
                    biomgcep = 0
                    csv_avec_0.write("%.7f%s%.7f%s%.7f%s%.7f%s%i%s%i%s%i%s%s%s%0.2f%s%i%s%i%s%i%s%i%s%i\n" %(XY[0],";",XY[1],";",L93[0],";",L93[1],";",nbsarm,";",diam ,";",biom,";",result[0],";",XY[7],";",nbsarmm2,";",nbsarcep,";",biommm2,";",biomgm2,";",biomgcep))  # on écrit la ligne dans le fichier OUT0.csv  
                elif comptage==NB_VIRGULES and len(diamsF)>0 : # si le nombre de diamètre après filtrage != 0 alors mesures
                    if XY[7] != 0:
                        nbsarm = len(diamsF)/(XY[7]*1000/3600)
                    else:
                        nbsarm = 0
                    if nbsarm > 1 and nbsarm < max_sarments_metre :                   
                        diam =sum(diamsF)/len(diamsF)
                        biom=3.1416*(diam/2)*(diam/2)*nbsarm
                        nbsarmm2 = nbsarm/eer*100
                        nbsarcep = nbsarm*eec/100
                        biommm2 = biom/eer*100
                        biomgm2 = biom*d*hv/eer
                        biomgcep = biom*d*hv*eec/100/100
                        csv_avec_0.write("%.7f%s%.7f%s%.7f%s%.7f%s%.2f%s%.2f%s%.2f%s%s%s%.2f%s%.2f%s%.2f%s%.2f%s%.2f%s%.2f\n" %(XY[0],";",XY[1],";",L93[0],";",L93[1],";",nbsarm,";",diam ,";",biom,";",result[0],";",XY[7],";",nbsarmm2,";",nbsarcep,";",biommm2,";",biomgm2,";",biomgcep)) # on écrit la ligne dans le fichier OUT0.csv 
                        csv_sans_0.write("%.7f%s%.7f%s%.7f%s%.7f%s%.2f%s%.2f%s%.2f%s%s%s%.2f%s%.2f%s%.2f%s%.2f%s%.2f%s%.2f\n" %(XY[0],";",XY[1],";",L93[0],";",L93[1],";",nbsarm,";",diam ,";",biom,";",result[0],";",XY[7],";",nbsarmm2,";",nbsarcep,";",biommm2,";",biomgm2,";",biomgcep)) # on écrit la ligne dans le fichier OUT.csv
                        for n in range(len(diamsF)) :
                            diametre_filtre.write("%f%s" %(diamsF[n],";"))
        except : # accompli cette fonction si erreur
            aMsg = "Erreur bloquante durant filtrage : pour la ligne numéro %d" %( nombre_ligne)
            uMsg = unicode(aMsg, 'utf-8')
            physiocap_error( self, uMsg )
            err.write( aMsg) # on écrit la ligne dans le fichier ERREUR.csv
            return -1
    #physiocap_log( u"Fin filtrage OK des "+ str(nombre_ligne - 1) + " lignes.")
    return 0
Ejemplo n.º 6
0
def physiocap_assert_csv(self, src, err):
    """Fonction d'assert. 
    Vérifie si le csv est au bon format: 
    58 virgules
    une date en première colonne
    des float ensuite
    """
    numero_ligne = 0     
    nombre_erreurs = 0     
    while True :
        ligne = src.readline() # lit les lignes 1 à 1
        if not ligne: break 
        # Vérifier si ligne OK
        numero_ligne = numero_ligne + 1
        #physiocap_log( u"Assert CVS ligne lue %d" % (numero_ligne))

        result = ligne.split(",") # split en fonction des virgules        
        # Vérifier si le champ date a bien deux - et 2 deux points
        tirets = result[ 0].count("-") 
        deux_points = result[ 0].count(":") 
        #physiocap_log( u"Champ date contient %d tirets et %d deux points" % (tirets, deux_points))
        if ((tirets != 2) or (deux_points != 2)):
            aMsg = "La ligne numéro %d ne commence pas par une date" % (numero_ligne)
            uMsg = unicode(aMsg, 'utf-8')
            nombre_erreurs = nombre_erreurs + 1
            if nombre_erreurs < 10:
                physiocap_error( self, uMsg )
            err.write( aMsg + '\n' ) # on écrit la ligne dans le fichier ERREUR.csv
            
            continue # on a tracé erreur et on saute la ligne         

        # Vérifier si tous les champs sont des float        
        i = 0
        for x in result[1:58]:
            i = i+1
            try:
                y = float( x)
                # physiocap_log( u"%d Champ  %s est de type %s" % (i, x, type( y)))
            except:
                aMsg = "La ligne numéro %d a des colonnes mal formatées (x.zzz attendu)" % (numero_ligne)
                uMsg = unicode(aMsg, 'utf-8')
                nombre_erreurs = nombre_erreurs + 1
                if nombre_erreurs < 10:
                    physiocap_error( self, uMsg )
                    err.write( aMsg + "\n") # on écrit la ligne dans le fichier ERREUR.csv
                break # on a tracé une erreur et on saute la ligne            

        comptage = ligne.count(",") # compte le nombre de virgules
        if comptage > NB_VIRGULES:
            # Assert Trouver les lignes de données invalides ( sans 58 virgules ... etc)
            aMsg = "La ligne numéro %d n'a pas %s virgules" % (numero_ligne, NB_VIRGULES)
            uMsg = unicode(aMsg, 'utf-8')
            nombre_erreurs = nombre_erreurs + 1
            if nombre_erreurs < 10:
                physiocap_error( self, uMsg )
            err.write( aMsg + '\n') # on écrit la ligne dans le fichier ERREUR.csv
            continue # on a tracé erreur et on saute la ligne


    # Au bilan
    if (numero_ligne != 0):
        #physiocap_log( u"Assert CVS a lu %d lignes et trouvé %d erreurs" % (numero_ligne, nombre_erreurs ))
        pourcentage_erreurs = float( nombre_erreurs * 100 / numero_ligne)
        return pourcentage_erreurs
    else:
        return 0