1 IHM deux onglets compare et extraction + classification

LIBStick_comp_spectres.py

@@ -24,57 +24,97 @@ def repertoire_de_travail(rep_script,rep_travail_relatif):
     rep_travail=rep_script+"/"+rep_travail_relatif
     return rep_travail
 
-def creation_liste_fichiers(rep_travail):
+def creation_liste_fichiers(rep_travail,type_extension_L_comp):
     os.chdir(rep_travail)
     liste=[]
-    for fichier in os.listdir():
-        if (os.path.isfile(fichier) and fichier[-4:] == "mean") :
-            liste.append(fichier)
+    if type_extension_L_comp.get() == "*.mean" :
+        for fichier in os.listdir():
+            if (os.path.isfile(fichier) and fichier[-4:] == "mean") :
+                liste.append(fichier)
+    if type_extension_L_comp.get() == "*.tsv" :
+        for fichier in os.listdir():
+            if (os.path.isfile(fichier) and fichier[-3:] == "tsv") :
+                liste.append(fichier)
     liste.sort()
     return liste
 
-def lit_spectre(fichier,tableau_abscisses):
-    spectre=numpy.loadtxt(fichier,delimiter="\t",usecols=[0],dtype=float,encoding="Latin-1")
-    #tableau_abscisses=lit_tableau_abscisses()
-    spectre=numpy.vstack((tableau_abscisses,spectre))
-#    spectre=numpy.zeros((0,document.shape[0]))
-#    for ligne in document :
-#        spectre=numpy.row_stack((spectre,ligne))
+def lit_spectre(fichier,tableau_abscisses,type_extension_L_comp):
+    if type_extension_L_comp.get() == "*.mean" :
+        spectre=numpy.loadtxt(fichier,delimiter="\t",usecols=[0],dtype=float,encoding="Latin-1")
+        #tableau_abscisses=lit_tableau_abscisses()
+        spectre=numpy.vstack((tableau_abscisses,spectre))
+    #    spectre=numpy.zeros((0,document.shape[0]))
+    #    for ligne in document :
+    #        spectre=numpy.row_stack((spectre,ligne))
+    if type_extension_L_comp.get() == "*.tsv" :
+        spectre=numpy.loadtxt(fichier,delimiter="\t",usecols=[1],dtype=float,encoding="Latin-1")
+        spectre=numpy.vstack((tableau_abscisses,spectre))
     return spectre
 
 def lit_tableau_abscisses():
     global tableau_abscisses
     tableau_abscisses=numpy.loadtxt("tableau_abscisses.txt", delimiter="\t", usecols=[0])
     return tableau_abscisses
 
-def creer_tableau(liste):
-    i=0
-    for nom_fichier in liste :
-        if i==0 :
-            fichier_entree=numpy.loadtxt(nom_fichier, delimiter="\t", usecols=[0])
-            #print(fichier_entree)
-            tableau_comparatif=numpy.zeros((0,fichier_entree.shape[0]))
-            tableau_comparatif=numpy.row_stack((tableau_comparatif,fichier_entree))
-        else :
-            fichier_entree=numpy.loadtxt(nom_fichier, delimiter="\t", usecols=[0])
-            tableau_comparatif=numpy.row_stack((tableau_comparatif,fichier_entree))
-        i=i+1
-    #print(tableau_comparatif.shape)
+def creer_tableau(liste,type_extension_L_comp):
+    if type_extension_L_comp.get() == "*.mean" :
+        i=0
+        for nom_fichier in liste :
+            if i==0 :
+                fichier_entree=numpy.loadtxt(nom_fichier, delimiter="\t", usecols=[0])
+                #print(fichier_entree)
+                tableau_comparatif=numpy.zeros((0,fichier_entree.shape[0]))
+                tableau_comparatif=numpy.row_stack((tableau_comparatif,fichier_entree))
+            else :
+                fichier_entree=numpy.loadtxt(nom_fichier, delimiter="\t", usecols=[0])
+                tableau_comparatif=numpy.row_stack((tableau_comparatif,fichier_entree))
+            i=i+1
+#    if type_extension_L_comp.get() == "*.tsv" :
+#        tableau_comparatif=graphique_lit_tableau()
+#        print(tableau_comparatif)
+#        print(tableau_comparatif.shape)
+    if type_extension_L_comp.get() == "*.tsv" :
+        i=0
+        for nom_fichier in liste :
+            if i==0 :
+                fichier_entree=numpy.loadtxt(nom_fichier, delimiter="\t", usecols=[1])
+                #print(fichier_entree)
+                tableau_comparatif=numpy.zeros((0,fichier_entree.shape[0]))
+                tableau_comparatif=numpy.row_stack((tableau_comparatif,fichier_entree))
+            else :
+                fichier_entree=numpy.loadtxt(nom_fichier, delimiter="\t", usecols=[1])
+                tableau_comparatif=numpy.row_stack((tableau_comparatif,fichier_entree))
+            i=i+1
+        tableau_comparatif=normalise_tableau_aire(tableau_comparatif)
     return tableau_comparatif
 
+def normalise_tableau_aire(tableau):
+    for ligne in range(tableau.shape[0]):
+        minimum=tableau[ligne,:].min()
+        tableau[ligne,:] = (tableau[ligne,:] - minimum)
+        aire=tableau[ligne,:].sum()
+        tableau[ligne,:] = (tableau[ligne,:] /aire)
+    tableau=tableau/tableau.max()
+    return tableau
+
 def creer_DataFrame(tableau_comparatif,liste, tableau_abscisses):
     DataFrame_comparatif=pandas.DataFrame(data=tableau_comparatif, index=liste, columns=tableau_abscisses)
     return DataFrame_comparatif
 
-def creer_DataFrame_resultats(DataFrame_comparatif, limites_zone1,limites_zone2):
-    DataFrame_tableau_calculs=pandas.DataFrame()
-    Sous_DataFrame = DataFrame_comparatif.loc[ : , limites_zone1[0]:limites_zone1[1]]
-    #print(Sous_DataFrame)
-    DataFrame_tableau_calculs["Somme zone 1"] = Sous_DataFrame.sum(axis=1)
-    Sous_DataFrame = DataFrame_comparatif.loc[ : , limites_zone2[0]:limites_zone2[1]]
-    #print(Sous_DataFrame)
-    DataFrame_tableau_calculs["Somme zone 2"] = Sous_DataFrame.sum(axis=1)
-    DataFrame_tableau_calculs["Rapport"]=DataFrame_tableau_calculs["Somme zone 1"] / DataFrame_tableau_calculs["Somme zone 2"]
+def creer_DataFrame_resultats(DataFrame_comparatif, limites_zone1,limites_zone2,flag_denominateur_L_comp):
+    if flag_denominateur_L_comp.get() == 1 :
+        DataFrame_tableau_calculs=pandas.DataFrame()
+        Sous_DataFrame = DataFrame_comparatif.loc[ : , limites_zone1[0]:limites_zone1[1]]
+        #print(Sous_DataFrame)
+        DataFrame_tableau_calculs["Somme zone 1"] = Sous_DataFrame.sum(axis=1)
+        Sous_DataFrame = DataFrame_comparatif.loc[ : , limites_zone2[0]:limites_zone2[1]]
+        #print(Sous_DataFrame)
+        DataFrame_tableau_calculs["Somme zone 2"] = Sous_DataFrame.sum(axis=1)
+        DataFrame_tableau_calculs["Rapport"]=DataFrame_tableau_calculs["Somme zone 1"] / DataFrame_tableau_calculs["Somme zone 2"]
+    if flag_denominateur_L_comp.get() == 0 :
+        DataFrame_tableau_calculs=pandas.DataFrame()
+        Sous_DataFrame = DataFrame_comparatif.loc[ : , limites_zone1[0]:limites_zone1[1]]
+        DataFrame_tableau_calculs["Somme zone 1"] = Sous_DataFrame.sum(axis=1)
     return DataFrame_tableau_calculs
 
 def Convertir_Dataframe_tableau(DataFrame_comparatif):
@@ -84,7 +124,7 @@ def Convertir_Dataframe_tableau(DataFrame_comparatif):
 
 def enregistre_DataFrame_resultats(DataFrame_resultats):
     DataFrame_resultats.to_csv("Resultat_fichiers_classes.csv")
-    DataFrame_resultats.to_csv("Resultat_fichiers_classes.tsv", sep='\t')
+    DataFrame_resultats.to_csv("Resultat_fichiers_classes.txt", sep='\t')
 
 ###############################################################################
 # 2- fonction d'affichage graphique du tableau de résultats
@@ -140,31 +180,40 @@ def graphique_3D_creation(tableau8bits,nom_echantillon,limites_spectre):
 def graphique_sauvegarde(tableau8bits) :
     plt.imsave("figure.png",tableau8bits, cmap="inferno")
 
+def graphique_lit_tableau():
+    tableau_comparatif=plt.imread("figure.png")
+    return tableau_comparatif
+
 ###############################################################################
 # programme principal
 ###############################################################################
-def main(rep_travail, tableau_bornes):
+def main(rep_travail, tableau_bornes,type_extension_L_comp,flag_denominateur_L_comp):
     os.chdir(rep_travail)
     liste=LIBStick_echange_vars.L_comp_liste_fichiers
-    tableau_comparatif=creer_tableau(liste)
+    tableau_comparatif=creer_tableau(liste,type_extension_L_comp)
     #tableau_abscisses=lit_tableau_abscisses()
     DataFrame_comparatif=creer_DataFrame(tableau_comparatif,liste,tableau_abscisses)
     limites_zone1[0]=tableau_bornes[0,0]
     limites_zone1[1]=tableau_bornes[0,1]
     limites_zone2[0]=tableau_bornes[1,0]
     limites_zone2[1]=tableau_bornes[1,1]
-    DataFrame_resultats=creer_DataFrame_resultats(DataFrame_comparatif,limites_zone1,limites_zone2)
-    DataFrame_comparatif=pandas.concat([DataFrame_comparatif, DataFrame_resultats["Rapport"]], axis=1)
-    DataFrame_comparatif=DataFrame_comparatif.sort_values(by=["Rapport"])
-    #print(DataFrame_comparatif)
-    LIBStick_echange_vars.L_comp_DataFrame_resultats = DataFrame_resultats = DataFrame_resultats.sort_values(by=["Rapport"])
-    print(DataFrame_resultats.shape)
-    enregistre_DataFrame_resultats(DataFrame_resultats)
 
-    tableau_comparatif=Convertir_Dataframe_tableau(DataFrame_comparatif)
-    #print (tableau_comparatif)
-    #print (tableau_comparatif.shape)
+    DataFrame_resultats=creer_DataFrame_resultats(DataFrame_comparatif,limites_zone1,limites_zone2,flag_denominateur_L_comp)
+    if flag_denominateur_L_comp.get() == 1 :
+        #DataFrame_resultats=creer_DataFrame_resultats(DataFrame_comparatif,limites_zone1,limites_zone2,flag_denominateur_L_comp)
+        DataFrame_comparatif=pandas.concat([DataFrame_comparatif, DataFrame_resultats["Rapport"]], axis=1)
+        DataFrame_comparatif=DataFrame_comparatif.sort_values(by=["Rapport"])
+        LIBStick_echange_vars.L_comp_DataFrame_resultats = DataFrame_resultats = DataFrame_resultats.sort_values(by=["Rapport"])
+        enregistre_DataFrame_resultats(DataFrame_resultats)
 
+    if flag_denominateur_L_comp.get() == 0 :
+        #DataFrame_resultats=creer_DataFrame_resultats(DataFrame_comparatif,limites_zone1,limites_zone2,flag_denominateur_L_comp)
+        DataFrame_comparatif=pandas.concat([DataFrame_comparatif, DataFrame_resultats["Somme zone 1"]], axis=1)
+        DataFrame_comparatif=DataFrame_comparatif.sort_values(by=["Somme zone 1"])
+        LIBStick_echange_vars.L_comp_DataFrame_resultats = DataFrame_resultats = DataFrame_resultats.sort_values(by=["Somme zone 1"])
+        enregistre_DataFrame_resultats(DataFrame_resultats)    
+
+    tableau_comparatif=Convertir_Dataframe_tableau(DataFrame_comparatif)
     tableau8bits=tableau_256gris(tableau_comparatif)
     if LIBStick_echange_vars.L_comp_flag_2D :
         graphique_creation(tableau8bits, "Echantillons classés", limites_spectre)

LIBStick_creation_spectre_moyen.py

@@ -15,8 +15,8 @@
 def extraction_spectres(tableau_norm):
     #tableau_extrait=LIBStick_creation_tableau_norm.tableau_norm.copy()
     tableau_extrait=tableau_norm.copy()
-    print ("format tableau initial : ")
-    print(tableau_extrait.shape)
+#    print ("format tableau initial : ")
+#    print(tableau_extrait.shape)
     indice_premier=(LIBStick_echange_vars.L_ext_bornes_moyenne_spectres[0]-1)
     indice_dernier=(LIBStick_echange_vars.L_ext_bornes_moyenne_spectres[1]-1)
     cols_supprime_debut=list()
@@ -28,31 +28,31 @@ def extraction_spectres(tableau_norm):
         for i in range(indice_dernier+1, LIBStick_echange_vars.L_ext_nombre_fichiers):
             cols_supprime_fin.append(i)
     cols_supprime=cols_supprime_debut+cols_supprime_fin
-    print ("colonnes à supprimer : ")
-    print(cols_supprime)         
+#    print ("colonnes à supprimer : ")
+#    print(cols_supprime)         
     tableau_extrait=numpy.delete(tableau_extrait, cols_supprime, axis=1)    
-    print ("format tableau extrait : ")
-    print(tableau_extrait.shape)    
+#    print ("format tableau extrait : ")
+#    print(tableau_extrait.shape)    
     return tableau_extrait
 
 def creation_spectre_moyen(tableau_extrait):
     spectre_moyen=tableau_extrait.sum(axis=1)
     spectre_moyen=spectre_moyen/tableau_extrait.shape[1]
-    print("format spectre moyen : ")
-    print(spectre_moyen.shape)
+#    print("format spectre moyen : ")
+#    print(spectre_moyen.shape)
     return spectre_moyen
 
 def enregistre_fichier(spectre_moyen, nom_echantillon, bornes):
     nom_fichier=nom_echantillon+"_spectre_moyen_"+ str(bornes[0])+"_"+str(bornes[1])+".mean"
     nom_fichier=str(numpy.char.replace(nom_fichier, " ", "_"))
     numpy.savetxt(nom_fichier,spectre_moyen,delimiter="\t", newline="\n")
-    print (nom_fichier)
+#    print (nom_fichier)
 
 ###############################################################################
 # programme principal
 ###############################################################################
 def main (rep_travail,nom_echantillon, bornes) :
-    print("===========================================")
+#    print("===========================================")
     os.chdir(rep_travail)
     tableau_norm=numpy.loadtxt("tableau_normalisé.txt",delimiter="\t",dtype=float,encoding="Latin-1")
     tableau_extrait=extraction_spectres(tableau_norm)

LIBStick_creation_tableau_norm.py

@@ -69,7 +69,7 @@ def creer_tableau_abscisses(liste):
     fichier0=numpy.loadtxt(liste[0], delimiter="\t", usecols=[0])
     tableau_abscisses=numpy.zeros((fichier0.shape[0],0))
     tableau_abscisses=numpy.column_stack((tableau_abscisses,fichier0))
-    print(tableau_abscisses)
+#    print(tableau_abscisses)
     return tableau_abscisses
 
 ###############################################################################
@@ -101,6 +101,15 @@ def enregistre_tableau_abscisses(tableau_abscisses):
 ###############################################################################
 # 5- fonctions qui affiche et sauvegarde des graphes
 ###############################################################################
+def tableau_brut_transpose_256gris(tableau_brut):
+    tableau8bits_brut=tableau_brut*255
+    tableau8bits_brut=tableau8bits_brut.transpose()
+    tableau8bits_brut=tableau8bits_brut.astype(int) 
+    return tableau8bits_brut
+
+def graphique_brut_sauvegarde(tableau8bits_brut) :
+    plt.imsave("figure_brute.png",tableau8bits_brut, cmap="inferno")
+
 def tableau_transpose_256gris(tableau_norm):
     tableau8bits=tableau_norm*255
     tableau8bits=tableau8bits.transpose()
@@ -112,8 +121,8 @@ def graphique_creation(tableau8bits,nom_echantillon,bornes):
     fig, ax=plt.subplots()
     #plt.imshow(tableau8bits, cmap="gray", extent=[bornes[0],bornes[1],tableau8bits.shape[0],0], aspect="auto")
     plt.imshow(tableau8bits, cmap="inferno", extent=[bornes[0],bornes[1],tableau8bits.shape[0],0], aspect="auto")
-    print(tableau8bits.shape[0])
-    print(tableau8bits.shape[1])
+#    print(tableau8bits.shape[0])
+#    print(tableau8bits.shape[1])
     #imageplot=plt.imshow(tableau8bits, cmap="hot")
     #imageplot=plt.imshow(tableau8bits, cmap="nipy_spectral")
     #plt.colorbar()
@@ -158,17 +167,23 @@ def graphique_sauvegarde(tableau8bits) :
 def main (rep_travail,nom_echantillon,bornes) :
     global tableau_norm
     liste_fichiers=creation_liste_fichiers(rep_travail)
+
     tableau_abscisses=creer_tableau_abscisses(liste_fichiers)
     enregistre_tableau_abscisses(tableau_abscisses)
-    tableau=creer_tableau(liste_fichiers)
-    tableau_norm=normalise_tableau_aire(tableau)
+
+    tableau_brut=creer_tableau(liste_fichiers)
+    tableau8bits_brut=tableau_brut_transpose_256gris(tableau_brut)
+    graphique_brut_sauvegarde(tableau8bits_brut)
+
+    tableau_norm=normalise_tableau_aire(tableau_brut)
     enregistre_fichier(tableau_norm,"tableau_normalisé.txt")
     enregistre_fichier_virgule(tableau_norm,"tableau_normalisé_virgules.txt")
-    tableau8bits=tableau_transpose_256gris(tableau_norm)
-    graphique_sauvegarde(tableau8bits)
+    tableau8bits_norm=tableau_transpose_256gris(tableau_norm)
+    graphique_sauvegarde(tableau8bits_norm)
+
     if LIBStick_echange_vars.L_ext_flag_2D :
-        graphique_creation(tableau8bits,nom_echantillon,bornes)
+        graphique_creation(tableau8bits_norm,nom_echantillon,bornes)
     if LIBStick_echange_vars.L_ext_flag_3D == 1 :
-        graphique_3D_creation(tableau8bits,nom_echantillon,bornes)   
+        graphique_3D_creation(tableau8bits_norm,nom_echantillon,bornes)