Bonjour, 

Je prend en main les widget tKinter. Malgré le grand nombre de forum et de réponse que j'ai épluché, je ne parviens pas à résoudre mon problème...

Le voici : 

Je crèe une interface contenant quelques espace dans lesquels je souhaite renter des informations pour ensuite les enregistrer en cliquant sur le bouton ' Enregistrer'. 

Seulement en cliquant sur le bouton 'Enregistrer', je n'arrive qu'a créer un fichier content des valeurs 'vide' .

Voici mon code principal 

from Programme import fonc_trait as ft

ft.interface()

et les fonction qu'il appelle.

def interface():
    root = tk.Tk()
        # taille de la fenetre
    root.geometry("600x400")

    # declaration des variables

    reseau_var = tk.StringVar()
    station_var = tk.StringVar()
    localisation_var = tk.StringVar()
    start_var = tk.StringVar()
    stop_var = tk.StringVar()
    dt_var = tk.StringVar()

    # fonction pour aller chercher les valeurs.

    def submit():
        reseau = reseau_var.get()
        station = station_var.get()
        localisation = localisation_var.get()
        start = start_var.get()
        stop = stop_var.get()
        dt = dt_var.get()

        infos = (reseau_var.get(), station_var.get(), localisation_var.get(), start_var.get(), stop_var.get(), dt_var.get())
        print(infos)

        np.save('infos.npy', infos)

    # Label et entrée pour les variables

    reseau_label = tk.Label(root, text='reseau', font=('calibre', 10, 'bold'))
    reseau_entry = tk.Entry(root, textvariable=reseau_var, font=('calibre', 10, 'normal'))

    station_label = tk.Label(root, text='station', font=('calibre', 10, 'bold'))
    station_entry = tk.Entry(root, textvariable=station_var, font=('calibre', 10, 'normal'))

    localisation_label = tk.Label(root, text='localisation', font=('calibre', 10, 'bold'))
    localisation_entry = tk.Entry(root, textvariable=localisation_var, font=('calibre', 10, 'normal'))

    start_label = tk.Label(root, text='start', font=('calibre', 10, 'bold'))
    start_entry = tk.Entry(root, textvariable=start_var, font=('calibre', 10, 'normal'))

    stop_label = tk.Label(root, text='stop', font=('calibre', 10, 'bold'))
    stop_entry = tk.Entry(root, textvariable=stop_var, font=('calibre', 10, 'normal'))

    dt_label = tk.Label(root, text='dt', font=('calibre', 10, 'bold'))
    dt_entry = tk.Entry(root, textvariable=dt_var, font=('calibre', 10, 'normal'))

    # Bouton enregistrer les valeurs
    rec_bouton = tk.Button(root, text='Enregistrer', command=submit)
    test_fft_bouton = tk.Button(root, text='test FFT', command=test_FFT)

    # placing the label and entry in
    # the required position using grid
    # method

    reseau_label.grid(row=0, column=0)
    reseau_entry.grid(row=0, column=1)

    station_label.grid(row=1, column=0)
    station_entry.grid(row=1, column=1)

    localisation_label.grid(row=2, column=0)
    localisation_entry.grid(row=2, column=1)

    start_label.grid(row=3, column=0)
    start_entry.grid(row=3, column=1)

    stop_label.grid(row=4, column=0)
    stop_entry.grid(row=4, column=1)

    dt_label.grid(row=5, column=0)
    dt_entry.grid(row=5, column=1)

    rec_bouton.grid(row=8, column=3)
    test_fft_bouton.grid(row=9, column=3)

    root.mainloop()

l'autres fonction FFT n'est pas un problème (pour le moment)

Merci d'avance, j'imagine que la solution est simple pour une majorité de développeur en Python

Adri

ça fonction plutôt bien; cependant pourquoi ligne 25 refaire les get() alors qu'on les a récupéré aux lignes au dessus ? 
Edit: enfin, ça fonctionne une fois, le fichier ne contient que les dernières valeurs enregistrées

-
Edité par umfred 10 mai 2021 à 16:01:33

Merci @umfred,

Content que ca marche chez toi, en effet ligne 25 est un oubli de ma part.

Chez moi, le fichier créer ne contient vraiment rien ... des idées ?? 

import numpy as np
infos = np.load("infos.npy")
print(infos)
['' '' '' '' '' '']

---- Peut être y'a t'il un autre 'command' de la fonction tk.button qui pourrais gérer la sauvegarde ? ..

Je suis preneur de plusieurs piste .

Edit 1 : C'est normal que seule la dernière saisie soit enregistré.

Edit 2 : Le programme fonctionne lorsque je le fait tourner avec le debugger de Pycharm, mais renvoi 'infos.npy' vide lorsqu'iol est dans la console

-
Edité par Adri_Beaver 11 mai 2021 à 10:00:21

tu l'as ouvert avec le bloc notes ton fichier infos.npy ? et tu es sûr lit le bon fichier et pas un fichier vide issu d'un essai précédent ? (vérifie en mettant le chemin complet du fichier)

tu as bien les données qui s'affichent avant le save ? 

Edit: ton fichier doit être dans l'espace virtuel de ton projet ou quelque chose comme ça.

-
Edité par umfred 11 mai 2021 à 11:42:10

Salut ! 

Hé bien je viens de rééxecuter le script en prenant la précaution de travailler dans un dossier ou il n'y avait pas de fichier infos.npy. 

- la commande print(infos) avant le save me donne 

('', '', '', '', '', '')

- Le fichier infos.npy est bien créé mais est toujours vide.

je joint une copie d'écran

-
Edité par Adri_Beaver 11 mai 2021 à 12:27:57

Salut,

Même constat qu'@umfred, l'écriture et la lecture du fichier ne posent pas de problème.......

tu as déjà un problème avec tes get()... 

un truc qui m'interpelle, c'est le nom de la fenêtre qui afficher tk #2, comme si il y en avait une autre d'ouverte quelque part.

Peut-être que le problème vient d'ailleurs dans ton fichier fonct_tray.py.

Tu as essayé de lancer directement la fonction interface depuis fonct_tray.py ?

Salut ! 

Hé bien j'ai corrigé les get() -> toujours le meme problème.

Lorsque je lance Pycharm, la première exécution du programme me donne une fenêtre tk#1, puis seconde exécution tk#2 et ainsi de suite. J'ai vérifier, pas d'autre fenêtre tk ouverte simultanément.

Lorsque je met la fonction dans un script et que je l’exécute, c'est pareil, le fichier est vide et la fonction print me sort :  ('', '', '', '', '', '')

EDIT : 

Nouveau test: 

J'ai testé mon interface tkinter dans un script séparé, et sans le bouton "test_FFT" donc sans appel au script fonc_trait.py.

Et ca marche !! 

Je ne sais pas quel est le problème avec ce script mais le problème est résolu, je vais importer mes fonctions dans ce script pour et je vous tiens au courant.

EDIT 2: 

Des que je fait appel dans la suite de mon programme à une fonction placés dans 'fonc_trait.py' l'erreur se produit. 

fonc_trait.py est un script que j'ai fait contenant toute mes fonctions personnalisées (une vingtaine), c'est donc embêtant... 

Si quelqu'un veux se pencher dessus je peux le publier mais je ne vaux pas vous embêtez plus longtemps avec ça. 

Merci en tout cas pour vos test et et commentaires

-
Edité par Adri_Beaver 12 mai 2021 à 17:21:49

c'est vrai (on ne l'a pas indiqué) mais vu que l'on avait pas la fonction test_fft (ni l'ensembles des fonctions/scripts), on a mis en commentaire/supprimer le bouton correspondant, d'où le fait que ça marchait.

Pour ceux qui se sente de mettre les pieds dans le plats

fonc_trait.py

from scipy.signal import butter, lfilter
import random as rnd
from obspy.core import UTCDateTime as UTCDateTime
import numpy as np
import pandas as pd
from scipy.signal import hilbert
from scipy.io import loadmat
from sklearn import ensemble
import scipy.optimize as so
from sklearn.metrics import mean_squared_error, explained_variance_score, median_absolute_error, r2_score
import scipy.signal as ss
import matplotlib.pyplot as plt
from obspy import read


def un_array(data):
    donnees = np.array([])
    for i in range(len(data)):
        donnees = np.append(donnees, data[i].data)

    return donnees


def butter_bandpass(lowcut, highcut, fs, order=5):
    nyq = 0.5 * fs
    low = lowcut / nyq
    high = highcut / nyq
    b, a = butter(order, [low, high], btype='band')
    return b, a


def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):
    b, a = butter_bandpass(lowcut, highcut, fs, order=order)
    y = lfilter(b, a, data)
    return y


def rdt(signal, l_rdt, n_rdt):
    seuil = 0
    n = int(len(signal) // l_rdt)
    k = 0
    vec_dec = np.zeros(l_rdt)
    e_s = np.zeros((2*n_rdt, l_rdt))

    while k < n_rdt:
        for j in range(len(signal)):
            if signal[j] >= seuil >= signal[j-1]:
                e_s[k, :] = signal[j:j + l_rdt]
                k = k+1
                if k >= n_rdt:
                    break

    for i in range(l_rdt):
        vec_dec[i] = np.mean(e_s[:k, i])

    return vec_dec


def fourier(data, sample_rate):
    f = np.fft.fft(data)
    freq = np.fft.fftfreq(data.size, d=1 / sample_rate)
    f_abs = np.abs(f[:f.size // 2])
    freq_pos = freq[:freq.size // 2]

    return f_abs, freq_pos


def norm(data):
    maxi = max(abs(data))
    if not maxi == 0:
        data = data / maxi
    return data


def nom_fichier_txt(network, station, location, channel, but):
    filename = str(station) + "_" + str(location) + "_" + str(channel) + but + '.txt'
    return filename


def rnd_date(n_date):
    Y = [rnd.randint(2019, 2020) for i in range(n_date)]
    M = [rnd.randint(1, 12) for i in range(n_date)]
    J = [rnd.randint(1, 18) for i in range(n_date)]
    H = [rnd.randint(0, 23) for i in range(n_date)]
    MIN = [rnd.randint(0, 59) for i in range(n_date)]

    date_date = [0] * n_date

    for i in range(n_date):
        date_date[i] = UTCDateTime(Y[i], M[i], J[i], H[i], MIN[i], 0)
    return date_date


def random_forest(x_train, x_test, y_train, y_test, params):

    accuracy = pd.DataFrame(index=['f', 'xi'], columns=['RMCE', 'v', 'med', 'r2'])
    resultat = np.zeros((len(x_test), 2))

    for h in range(2):
        rnd_f = ensemble.RandomForestRegressor(n_estimators=params[0],
                                               criterion='mae',
                                               max_depth=None,
                                               min_samples_split=params[1],
                                               max_features=None,
                                               n_jobs=4)

        rnd_f.fit(x_train, y_train[:, h])
        resultat[:, h] = rnd_f.predict(x_test)

        accuracy.RMCE[h] = np.sqrt(mean_squared_error(y_test[:, h], resultat[:, h]))
        accuracy.v[h] = explained_variance_score(y_test[:, h], resultat[:, h])
        accuracy.med[h] = median_absolute_error(y_test[:, h], resultat[:, h])
        accuracy.r2[h] = r2_score(y_test[:, h], resultat[:, h])

    return resultat, accuracy


def expo_damp(t, a, xi_w):
    return a * np.exp(-xi_w * t)


def inv_expo_damp(t, a, xi_w):
    return -a * np.exp(-xi_w * t)


def lien(network, station, location, channel, start_t, end_t):
    base = "https://ws.resif.fr/fdsnws/dataselect/1/query?"
    net = "network=" + str(network)
    sta = "station=" + str(station)
    loc = "location=" + str(location)
    cha = "channel=" + str(channel)
    qua = "quality=B"
    l_o = "longestonly=true"
    st = "starttime=" + str(start_t)
    et = "endtime=" + str(end_t)
    nd = "nodata=404"

    link = str(base) + "&" + str(net) + "&" + str(sta) + "&" + str(loc) + "&" + str(cha) + "&" + str(qua) + "&" + str(
        l_o) + "&" + str(st) + "&" + str(et) + "&" + str(nd)

    return link


def nom(station, location, channel, end_t):
    filename = str(station) + "_" + str(location) + "_" + str(channel) + "_" + str(end_t) + "dwnl.mseed"
    return filename


def frequence_moyenne(vecteur_decrement, sampling_rate):

    hilbert_vecteur_decrement = hilbert(vecteur_decrement)
    enveloppe = np.abs(hilbert_vecteur_decrement)
    phase = np.unwrap(np.angle(hilbert_vecteur_decrement))

    f_inst = (np.diff(phase) / (2.0 * np.pi) * sampling_rate)
    X = derive_stable(enveloppe)
    l = int(0.05*len(vecteur_decrement))
    y = f_inst[X-l:X+l]

    f = np.mean(y)
    std = np.std(y)

    return f, std


def derive_stable(v):

    dv = np.diff(v)
    abs_ddv = np.abs(np.diff(dv))

    L = (len(abs_ddv) - 10) // 10
    moy = np.zeros(10)
    std = np.zeros(10)

    for i in range(0, 10):
        moy[i] = np.mean(abs_ddv[i*L: (i+1) * L])
        std[i] = np.std(abs_ddv[i*L: (i+1) * L])

    min_moy = np.where(moy == min(moy))
    min_std = np.where(std == min(std))

    x = int(((int(min_moy[0]) + int(min_std[0])) / 2) * L)

    return x


def d2(vecteur):
    dv = np.diff(vecteur)
    ddv = np.diff(dv)
    return ddv


def FFT(donnees_brute, sampling_rate, frequence_coupure, n_fft):
   
    sample_fft = int(len(donnees_brute) // (n_fft + 1))
    FFT = np.zeros(sample_fft // 2)
    f = np.zeros_like(FFT)

    for ii in range(n_fft):
        data_fft = donnees_brute[ii * sample_fft:(ii + 1) * sample_fft] - np.mean(
            donnees_brute[ii * sample_fft:(ii + 1) * sample_fft])
        fft, f = fourier(data_fft, sampling_rate)
        FFT += fft

    FFT = FFT[np.where(f <= frequence_coupure)]
    f = f[np.where(f <= frequence_coupure)]
    f_mode_fft = float(f[np.where(FFT == max(FFT))])

    return f, FFT


def amortissmeent_moyen(vecteur_decrement, frequence_propre, n_T, sampling_rate):

    l_rdt = len(vecteur_decrement)
    t = np.linspace(0, n_T / frequence_propre, l_rdt)
    l_T = int((1 / frequence_propre) * sampling_rate)

    y_maxima_vd = np.zeros(n_T)
    x_maxima_vd = np.zeros(n_T)
    y_minima_vd = np.zeros(n_T)
    x_minima_vd = np.zeros(n_T)

    for ii in range(n_T-1):
        domaine_recherche = vecteur_decrement[ii * l_T: (ii + 1) * l_T]
        idx_maxima = np.where(domaine_recherche == max(domaine_recherche))
        idx_minima = np.where(domaine_recherche == min(domaine_recherche))

        y_maxima_vd[ii] = vecteur_decrement[int(float(idx_maxima[0]) + ii * l_T)]
        x_maxima_vd[ii] = t[int(float(idx_maxima[0]) + ii * l_T)]
        y_minima_vd[ii] = vecteur_decrement[int(float(idx_minima[0]) + ii * l_T)]
        x_minima_vd[ii] = t[int(float(idx_minima[0]) + ii * l_T)]

    # oubli les 4 premiers maxima

    x_maxima_vd = x_maxima_vd[4:]
    y_maxima_vd = y_maxima_vd[4:]
    x_minima_vd = x_minima_vd[4:]
    y_minima_vd = y_minima_vd[4:]

    n_fit = len(y_maxima_vd) - 2
    xi_calcul = np.zeros((n_fit, 2))

    for iii in range(n_fit):
        # On selectione tour par tour par groupe de 3 les maximas pour le fit
        x = x_maxima_vd[iii: iii + 3]
        y = y_maxima_vd[iii: iii + 3]
        Variables, COV = so.curve_fit(expo_damp, x, y, bounds=[0, 2])
        xi_calcul[iii, 0] = Variables[1] / (2 * np.pi * frequence_propre)

    for iiii in range(n_fit):
        # On selectione tour par tour par groupe de 3 les minimas pour le fit
        x = x_minima_vd[iiii: iiii + 3]
        y = y_minima_vd[iiii: iiii + 3]
        Variables, COV = so.curve_fit(inv_expo_damp, x, y, bounds=[0, 2])
        xi_calcul[iiii, 1] = Variables[1] / (2 * np.pi * frequence_propre)

    mean_xi = np.mean(xi_calcul)
    std = np.std(xi_calcul)

    return mean_xi, std


def partie_fft(donnees, n_fft, sampling_rate, f_c):
    sample_fft = int(len(donnees) // (n_fft + 1))
    FFT = np.zeros(sample_fft // 2)
    f = np.zeros_like(FFT)

    for ii in range(n_fft):
        data_fft = donnees[ii * sample_fft:(ii + 1) * sample_fft] - np.mean(
            donnees[ii * sample_fft:(ii + 1) * sample_fft])
        fft, f = fourier(data_fft, sampling_rate)
        FFT += fft

    FFT = FFT[np.where(f <= f_c)]
    FFT = norm(FFT)
    f = f[np.where(f <= f_c)]
    f_mode = float(f[np.where(FFT == max(FFT))])

    return f_mode, f, FFT


def f_n_xi(donnees, sampling_rate, n_rdt, n_T, f_mode):

    donnees = ss.detrend(donnees)

    # FILTRAGE

    f_h = 1.05 * f_mode
    f_b = 0.95 * f_mode
    donnees_filtrees = butter_bandpass_filter(donnees, f_b, f_h, sampling_rate, 3)

    # RDT

    l_rdt = int(n_T * 1 / f_mode * sampling_rate)
    vecteur_decrement = rdt(donnees_filtrees, l_rdt, n_rdt)
    vecteur_decrement = norm(vecteur_decrement)

    # Frequences & Amortissement

    f_i, error_f = frequence_moyenne(vecteur_decrement, sampling_rate)

    f_acc = [f_mode * 0.8, f_mode*1.2]
    if f_i < f_acc[0] or f_i > f_acc[1]:
        f_xi = f_mode
        print('Attention , f_i != f_mode')

    else:
        f_xi = f_i

    xi, error_xi = amortissmeent_moyen(vecteur_decrement, f_xi, n_T, sampling_rate)

    return f_i, error_f, xi, error_xi


def recherche_frequence_propres(donnees, sampling_rate, n_fft, frequence_coupure, seuil):

    sample_fft = int(len(donnees) // (n_fft+1))
    FFT = np.zeros(sample_fft // 2)
    f = np.zeros_like(FFT)

    for ii in range(n_fft):
        data_fft = ss.detrend(donnees[ii * sample_fft:(ii + 1) * sample_fft])
        fft, f = fourier(data_fft, sampling_rate)
        FFT += fft

    FFT = FFT[np.where(f <= frequence_coupure)]
    f = f[np.where(f <= frequence_coupure)]
    FFT = norm(FFT)

    idx_f, _ = ss.find_peaks(FFT, height=seuil, distance=1)
    frequence_propres = f[idx_f]

    # plt.figure()
    # plt.plot(f, FFT)
    # plt.plot(f, np.zeros_like(f)+seuil, '--k')
    # plt.show()

    return idx_f, frequence_propres, FFT, f


def tri_frequences(HN1, HN2, sampling_rate, n_fft, frequence_coupure, seuil):

    return


def lecture_mat(mat_file):
    mat_file = loadmat(mat_file)
    a, b, c, clef = mat_file.keys()
    long = mat_file[clef]
    n_f_long = len(long[0][:, 0])
    n_mesure = long.shape[0]

    f = np.zeros((n_f_long, n_mesure))
    error_f = np.zeros_like(f)
    xi = np.zeros_like(f)
    error_xi = np.zeros_like(f)

    for i in range(n_mesure):
        for j in range(n_f_long):
            f[j, i] = long[i][j, 0]
            error_f[j, i] = long[i][j, 1]
            xi[j, i] = long[i][j, 2]
            error_xi[j, i] = long[i][j, 3]

    return f, error_f, xi, error_xi


def test_FFT(reseau, station, localisation, start):

    end = int(start) + 3600
    n_fft = 150
    f_c = 45

    try:
        link = lien(reseau, station, localisation, "HN1", start, end)
        data_r = read(link)
        HN1 = data_r[0].data
        sampling_rate = int(data_r[0].stats.sampling_rate)
        print('HN1 ok')

        link = lien(reseau, station, localisation, "HN2", start, end)
        data_r = read(link)
        HN2 = data_r[0].data
        print('HN2 ok')

    except:
        print('NON')
        pass

    donnees = [HN1, HN2]

    # Recherche des fréquences propres ///

    idx_1, fp_1, FFT1, axe_f = recherche_frequence_propres(HN1, sampling_rate, n_fft, f_c, 0.25)
    idx_2, fp_2, FFT2, _ = recherche_frequence_propres(HN2, sampling_rate, n_fft, f_c, 0.25)

    plt.figure()
    plt.plot(axe_f, FFT1, label='HN1')
    plt.plot(axe_f, FFT2, label='HN2')
    plt.legend()
    plt.show()

interfaces_entree.py

import numpy as np
import tkinter as tk


def int_1():

    root = tk.Tk()

    # setting the windows size
    root.geometry("600x400")

    # declaring string variable
    # for storing name and password
    reseau_var = tk.StringVar()
    station_var = tk.StringVar()
    localisation_var = tk.StringVar()
    start_var = tk.StringVar()
    stop_var = tk.StringVar()
    dt_var = tk.StringVar()

    # defining a function that will
    # get the name and password and
    # print them on the screen
    def submit():
        reseau = reseau_var.get()
        station = station_var.get()
        localisation = localisation_var.get()
        start = start_var.get()
        stop = stop_var.get()
        dt = dt_var.get()

        infos = (reseau, station, localisation, start, stop, dt)
        print(infos)
        np.save('infos.npy', infos)


    reseau_label = tk.Label(root, text='reseau', font=('calibre', 10, 'bold'))
    reseau_entry = tk.Entry(root, textvariable=reseau_var, font=('calibre', 10, 'normal'))

    station_label = tk.Label(root, text='station', font=('calibre', 10, 'bold'))
    station_entry = tk.Entry(root, textvariable=station_var, font=('calibre', 10, 'normal'))

    localisation_label = tk.Label(root, text='localisation', font=('calibre', 10, 'bold'))
    localisation_entry = tk.Entry(root, textvariable=localisation_var, font=('calibre', 10, 'normal'))

    start_label = tk.Label(root, text='start', font=('calibre', 10, 'bold'))
    start_entry = tk.Entry(root, textvariable=start_var, font=('calibre', 10, 'normal'))

    stop_label = tk.Label(root, text='stop', font=('calibre', 10, 'bold'))
    stop_entry = tk.Entry(root, textvariable=stop_var, font=('calibre', 10, 'normal'))

    dt_label = tk.Label(root, text='dt', font=('calibre', 10, 'bold'))
    dt_entry = tk.Entry(root, textvariable=dt_var, font=('calibre', 10, 'normal'))

    # Bouton enregistrer les valeurs
    rec_bouton = tk.Button(root, text='Enregistrer', command=submit)
    test_fft_bouton = tk.Button(root, text='test FFT', command=ft.test_FFT)


    reseau_label.grid(row=0, column=0)
    reseau_entry.grid(row=0, column=1)

    station_label.grid(row=1, column=0)
    station_entry.grid(row=1, column=1)

    localisation_label.grid(row=2, column=0)
    localisation_entry.grid(row=2, column=1)

    start_label.grid(row=3, column=0)
    start_entry.grid(row=3, column=1)

    stop_label.grid(row=4, column=0)
    stop_entry.grid(row=4, column=1)

    dt_label.grid(row=5, column=0)
    dt_entry.grid(row=5, column=1)

    rec_bouton.grid(row=8, column=3)
    test_fft_bouton.grid(row=9, column=3)

    root.mainloop()

le code qui commande

from Fonctions import interace_entree as ie
from Fonctions import fonc_trait as ft
import numpy as np


ie.int_1()

infos = np.load('infos.npy')

ft.test_FFT(infos[0], infos[1], infos[2], infos[3])

Merci à vous ! 

-
Edité par Adri_Beaver 12 mai 2021 à 17:42:46

j'ai résolu l'ensembles des problèmes en utilisant le subprocess !

subprocess.call[usr/bin/python3.9, /mon_dossier/ma fonction.py]

Merci !