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
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")
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
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
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
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