Niemożność wyświetlenia wyniku kompilacji w metodzie ScrolledText okna Tkinter

Odpowiedz Nowy wątek
2019-02-02 09:57
0

Drodzy,
wykonałem kod, którego obliczenia działają w pętli.
Próbowałem różnymi metodami (to, co wyświetla się w konsoli, wrzucić do okna metody ScrolledText);
Przy pomocy:

  • insert
  • dataframe
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import fig as fig
import numpy as np
import pyaudio
import os
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
import pandas as pd

if __name__ == "__main__":

    window = Tk()
    window.title('Tuner Gitarowy')
    window.geometry('1380x855')

    img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
    window = Label(window, background='NavajoWhite3', image=img)
    window.pack(side='right', fill='both', expand='yes')

    txt = scrolledtext.ScrolledText(window, width=60, height=53)
    txt.grid(column=0, row=1)

    window.mainloop()

    FSAMP = 22050  # czestotliwosc probkowania w Hz
    ROZMIAR_PROB = 2048  # ilosc probek
    KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
    NOTKA_MIN = 40  # E2
    NOTKA_MAX = 64  # E4

    # dla wyswietlenia nazw dzwieku:

    NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

    # nowe dzwieki:
    PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
    KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT

def nazwa_notki(n):
    return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))

def czestotliwosc_na_numer(f):
    return 64 + 12 * np.log2(f / 329.63)

def numer_na_czestotliwosc(n):
    return 329.63 * 2.0 ** ((n - 64) / 12.0)

# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera:
def notka_do_fftbin(n):
    return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI

imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera:
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku:
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga:
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu:
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna czestotliwoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

    # przesuwanie bufora i wprowadzenie nowych danych
    buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
    buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

    # Uruchom szybka transformate fouriera na okiennym buforze
    fft = np.fft.rfft(buf * window)

    # pobierz czestotliwosc maksymalnej wartosci z zakresu
    czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

    # pobierz numer notatki i najblizsza notatke
    n = czestotliwosc_na_numer(czestotliwosc)
    n0 = int(round(n))

    # dane wyjsciowe konsoli, gdy mamy pelny bufor
    numer_klatki += 1

    nameCol = ('n', 'czestotliwosc', 'nazwa_notki(n0)', 'n - n0')
    x = n
    y = czestotliwosc
    z = nazwa_notki(n)
    v = (n - n0)
    data = pd.DataFrame(columns=nameCol)

    if numer_klatki >= KLATEK_NA_FFT:
        print('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

        # najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
        def Okno(w):
            fig = plt.figure()
            ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
            line, = ax.plot([], [], lw=2)

        # funkcja inicjalizacji: wykresla tlo kazdej ramki
        def init():
            czestotliwosc.set_data([], [])
            return czestotliwosc,

        # funkcja animacji. Nazywa sie to sekwencyjnie
        def oblicz(i):
            x = np.linspace(0, 2, 1000)
            y = np.sin(2 * np.pi * (x - 0.01 * i))
            czestotliwosc.set_data(x, y)
            return czestotliwosc,
            anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)

    dataLoop = pd.DataFrame(columns=nameCol)
    dataLoop['n'] = (x)
    dataLoop['czestotliwosc'] = (y)
    dataLoop['nazwa_notki(n0)'] = (z)
    dataLoop['n - n0'] = (v)
    print(dataLoop)
    data = data.append(dataLoop, ignore_index=True)

Przypisałem zmienne do innym zmiennych, które realizują obliczenia.
Gdzieś robię błąd, bo nie wyrzuca tych wyników do okna.

Udostępniam cały kod, aktualny: https://megawrzuta.pl/downloa[...]422bc1dcfe07336af85658c6.html
i wyświetlający okno, a po jego zamknięciu printowanie wyników w konsoli: https://megawrzuta.pl/downloa[...]f1c06c9653f6ace83b08c1ff.html

Może czegoś się dopatrzycie.
Bardzo proszę o pomoc.

edytowany 2x, ostatnio: Shalom, 2019-02-02 16:32

Pozostało 580 znaków

2019-02-04 01:09
0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import fig as fig
import numpy as np
import pyaudio
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
import pandas as pd

if __name__ == "__main__":

    FSAMP = 22050  # czestotliwosc probkowania w Hz
    ROZMIAR_PROB = 2048  # ilosc probek
    KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
    NOTKA_MIN = 40  # E2
    NOTKA_MAX = 64  # E4

    # dla wyswietlenia nazw dzwieku

    NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT

def nazwa_notki(n):
    return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))

def czestotliwosc_na_numer(f):
    return 64 + 12 * np.log2(f / 329.63)

def numer_na_czestotliwosc(n):
    return 329.63 * 2.0 ** ((n - 64) / 12.0)

# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()

def notka_do_fftbin(n):
    return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI

imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

    # przesuwanie bufora i wprowadzenie nowych danych
    buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
    buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

    # Uruchom szybka transformate fouriera na okiennym buforze
    fft = np.fft.rfft(buf * window)

    # pobierz czestotliwosc maksymalnej wartosci z zakresu
    czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

    # pobierz numer notatki i najblizsza notatke
    n = czestotliwosc_na_numer(czestotliwosc)
    n0 = int(round(n))

    # dane wyjsciowe konsoli, gdy mamy pelny bufor
    numer_klatki += 1

    if numer_klatki >= KLATEK_NA_FFT:

        window1 = Tk()
        window1.title('Tuner Gitarowy')
        window1.geometry('1380x855')

        img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
        window1 = Label(window1, background='NavajoWhite3', image=img)
        window1.pack(side='right', fill='both', expand='yes')

        txt = scrolledtext.ScrolledText(window1, width=60, height=53)
        txt.grid(column=0, row=1)

        txt.insert(INSERT, ('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0)))

        # najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
        def Okno(w):
            fig = plt.figure()
            ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
            line, = ax.plot([], [], lw=2)

        # funkcja inicjalizacji: wykresla tlo kazdej ramki
        def init():
            czestotliwosc.set_data([], [])
            return czestotliwosc,

        # funkcja animacji. Nazywa sie to sekwencyjnie
        def oblicz(i):
            x = np.linspace(0, 2, 1000)
            y = np.sin(2 * np.pi * (x - 0.01 * i))
            czestotliwosc.set_data(x, y)
            return czestotliwosc,
            anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)

        window1.mainloop()

Dobre wieści, program, działa, jak powinien. Zostało zapętlanie.

edytowany 3x, ostatnio: Shalom, 2019-02-04 10:14

Pozostało 580 znaków

2019-02-04 14:45
1

Deklariujesz funkcje w pętli typu def Okno(w): (czemu nie poza pętlą?) ale nie widzę byś gdzieś je wywoływał. Tj:

def f():

def f2():

while stream.is_active():
    f()
    f2()

zamiast

while stream.is_active():
    def f():

    def f2():

Plus zapisy typu :

return czestotliwosc,
            anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)

lepiej

anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
return czestotliwosc, anim

Pozostało 580 znaków

2019-02-04 18:38
0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import fig as fig
import numpy as np
import pyaudio
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
import pandas as pd

if __name__ == "__main__":
    FSAMP = 22050  # czestotliwosc probkowania w Hz
    ROZMIAR_PROB = 2048  # ilosc probek
    KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
    NOTKA_MIN = 40  # E2
    NOTKA_MAX = 64  # E4

    # dla wyswietlenia nazw dzwieku

    NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT

# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
def okno(w):
    fig = plt.figure()
    ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
    line, = ax.plot([], [], lw=2)

# funkcja inicjalizacji: wykresla tlo kazdej ramki
def init():
    czestotliwosc.set_data([], [])
    return czestotliwosc

# funkcja animacji. Nazywa sie to sekwencyjnie
def oblicz(i):
    x = np.linspace(0, 2, 1000)
    y = np.sin(2 * np.pi * (x - 0.01 * i))
    czestotliwosc.set_data(x, y)
    anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
    return czestotliwosc

def nazwa_notki(n):
    return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))

def czestotliwosc_na_numer(f):
    return 64 + 12 * np.log2(f / 329.63)

def numer_na_czestotliwosc(n):
    return 329.63 * 2.0 ** ((n - 64) / 12.0)

# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()

def notka_do_fftbin(n):
    return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI

imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

    # przesuwanie bufora i wprowadzenie nowych danych
    buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
    buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

    # Uruchom szybka transformate fouriera na okiennym buforze
    fft = np.fft.rfft(buf * window)

    # pobierz czestotliwosc maksymalnej wartosci z zakresu
    czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

    # pobierz numer notatki i najblizsza notatke
    n = czestotliwosc_na_numer(czestotliwosc)
    n0 = int(round(n))

    # dane wyjsciowe konsoli, gdy mamy pelny bufor
    numer_klatki += 1

    if numer_klatki >= KLATEK_NA_FFT:
        window1 = Tk()
        window1.title('Tuner Gitarowy')
        window1.geometry('1380x855')

        img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
        window1 = Label(window1, background='NavajoWhite3', image=img)
        window1.pack(side='right', fill='both', expand='yes')

        txt = scrolledtext.ScrolledText(window1, width=60, height=53)
        txt.grid(column=0, row=1)

        txt.insert(INSERT, ('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0)))

        wywolaj1.okno()

        wywolaj2.init()

        wywolaj3.oblicz()

        window1.mainloop()

Deklaracja:

  • def okno
  • def init
  • def oblicz

Nad pętlą while, a w if'ie (zagnieżdżonym w while'u), wywoływać tylko instancję tej klasy.

Pytanie, jak to zrobić, bo:
wywolaj1.okno()

a także:
wywolaj1 = okno()

nie działają

edytowany 2x, ostatnio: Bartek Pieczka, 2019-02-04 18:43

Pozostało 580 znaków

2019-02-04 18:57
1

A co to wywołaj1, wywołaj2? Jakaś klasa? Jak zdefiniowałeś funkcje init, okno, oblicz to po prostu wywołuj je init(), okno(), oblicz(). No i pamiętaj, że używasz obiektu czestotliwosc, który najlepiej przekazywać do funkcji jako parametr (unikaj globalnych zmiennych). Tj np. def init(i, czestotliwosc):

Problemów w tym kodzie jest wiele swoją drogą ale najpierw trzeba się zająć rażącymi błędami ;)

Pozostało 580 znaków

2019-02-04 21:44
0

Chyba rozumiem.
Zamiast:

# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
def okno(w):
    fig = plt.figure()
    ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
    line, = ax.plot([], [], lw=2)

# funkcja inicjalizacji: wykresla tlo kazdej ramki
def init():
    czestotliwosc.set_data([], [])
    return czestotliwosc

# funkcja animacji. Nazywa sie to sekwencyjnie
def oblicz(i):
    x = np.linspace(0, 2, 1000)
    y = np.sin(2 * np.pi * (x - 0.01 * i))
    czestotliwosc.set_data(x, y)
    anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
    return czestotliwosc

dać:

# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
def okno(w):
    fig = plt.figure()
    ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
    line, = ax.plot([], [], lw=2)

# funkcja inicjalizacji: wykresla tlo kazdej ramki
def init(czestotliwosc):
    czestotliwosc.set_data([], [])
    return czestotliwosc

# funkcja animacji. Nazywa sie to sekwencyjnie
def oblicz(i, czestotliwosc):
    x = np.linspace(0, 2, 1000)
    y = np.sin(2 * np.pi * (x - 0.01 * i))
    czestotliwosc.set_data(x, y)
    anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
    return czestotliwosc

Tak?
Bo jeżeli to jest poprawna deklaracja, to return czestotliwosc nie powinien byc potrzebny.

Aha, przepraszam, że kod jest "po polsku", po prostu chcę zrozumieć, co się tu dzieje.

Aktualnie kod wygląda:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import fig as fig
import numpy as np
import pyaudio
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
import pandas as pd

if __name__ == "__main__":
    FSAMP = 22050  # czestotliwosc probkowania w Hz
    ROZMIAR_PROB = 2048  # ilosc probek
    KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
    NOTKA_MIN = 40  # E2
    NOTKA_MAX = 64  # E4

    # dla wyswietlenia nazw dzwieku

    NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT

# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
def okno(w):
    fig = plt.figure()
    ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
    line, = ax.plot([], [], lw=2)

# funkcja inicjalizacji: wykresla tlo kazdej ramki
def init(czestotliwosc):
    czestotliwosc.set_data([], [])
    return czestotliwosc

# funkcja animacji. Nazywa sie to sekwencyjnie
def oblicz(i, czestotliwosc):
    x = np.linspace(0, 2, 1000)
    y = np.sin(2 * np.pi * (x - 0.01 * i))
    czestotliwosc.set_data(x, y)
    anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
    return czestotliwosc

def nazwa_notki(n):
    return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))

def czestotliwosc_na_numer(f):
    return 64 + 12 * np.log2(f / 329.63)

def numer_na_czestotliwosc(n):
    return 329.63 * 2.0 ** ((n - 64) / 12.0)

# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()

def notka_do_fftbin(n):
    return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI

imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

    # przesuwanie bufora i wprowadzenie nowych danych
    buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
    buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

    # Uruchom szybka transformate fouriera na okiennym buforze
    fft = np.fft.rfft(buf * window)

    # pobierz czestotliwosc maksymalnej wartosci z zakresu
    czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

    # pobierz numer notatki i najblizsza notatke
    n = czestotliwosc_na_numer(czestotliwosc)
    n0 = int(round(n))

    # dane wyjsciowe konsoli, gdy mamy pelny bufor
    numer_klatki += 1

    if numer_klatki >= KLATEK_NA_FFT:
        window1 = Tk()
        window1.title('Tuner Gitarowy')
        window1.geometry('1380x855')

        img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
        window1 = Label(window1, background='NavajoWhite3', image=img)
        window1.pack(side='right', fill='both', expand='yes')

        txt = scrolledtext.ScrolledText(window1, width=60, height=53)
        txt.grid(column=0, row=1)

        txt.insert(INSERT, ('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0)))

        okno(), init(), oblicz()

        window1.mainloop()
edytowany 2x, ostatnio: Bartek Pieczka, 2019-02-04 21:47
Tak. Pytanie czy ten kod działa? ;) Jak już będzie działać będzie można myśleć nad poprawą architektury i różnych metod. - AsterFV 2019-02-05 08:54

Pozostało 580 znaków

2019-02-05 09:33
0

Niestety, nie działa, bo prosi o zestaw informacji.
https://stackoverflow.com/que[...]es-exactly-1-argument-0-given
Np. w def Okno, wewnątrz jest zadeklarowane (w), daję do kodu, ale nie działa.

Pozostało 580 znaków

2019-02-05 09:49
0

Bo zadeklarowałeś okno(w) a wywołujesz okno(). Więc nie przekazujesz parametru w. W ogole po co parametr w? Nie wykorzystujesz go w funkcji okno(). I tak samo z init i oblicz (musisz przekazac i oraz czestottliwosc do funkcjI)

Pozostało 580 znaków

2019-02-05 10:04
0

screenshot-20190205100426.png

Typ zmiennej mu nie odpowiada.
Kurczę, ile tu błędów.

Pozostało 580 znaków

2019-02-05 10:43
1

Bo wykorzystujesz w tej funkcji metody i parametry, które nie przekazujesz nigdzie. Ja bym od początku prześledził co kod ma robić, co potrzebuje itp i to rozrysował sobie. Bo starasz się spiąć wszystko w całość popełniając elementarne błędy (jak nie przekazywanie odpowiednich parametrów). Może zdefiniuj swój problem i co chcesz zrobić na nowo. Łatwiej jest rozwiązywać konkretne problemy niż ogólne - a nikt nie poświęci więcej czasu bo czas to pieniądz ;)

Ewentualnie wrzuć kod na gita i ułatw innym pobranie i analizę w wolnym czasie.

Pozostało 580 znaków

2019-02-05 11:47
0

https://gist.github.com/barte[...]a7210f1cec69c5cebe619a0b7a0dc

  1. Import bibliotek
  2. po if name == "main":
    mamy zadeklarowane stałe wartości, które są przekazywane niżej.
  3. Za pomocą stałych, określamy ilość próbek i częstotliwość przebiegu transformaty fouriera.
  4. Bez używania wcięcia, definiujemy funckje:
    • okno() - tutaj widzę, że zmienne fig oraz line zdają się być pomijane
    • init() - funkcja inicjalizacji: wykresla tlo kazdej ramki, listy przechowują określony typ zmiennych - Występuje krzak niemożności odnalezienia atrybutu 'set_data' w kodzie.
    • oblicz() - funkcja animacji przebiegu wyliczeń
  • nazwa_notki() - tutaj nie wiem dokładnie, ale gdy program działa w konsoli, wyprintowuje jakieś liczby z zakresu 55 - 63, zmiennoprzecinkowe.
  • czestotliwosc_na_numer() - tu jest sens całej aplikacji.szybka transformata fouriera
  • numer_na_czestotliwosc() - odwrotność poprzedniego zapisu
  • notka_do_ffftbin() - wynik zwracany do konsoli. Wyrażenie wysokości granej struny. Cały sens aplikacji.

imin, imax = Nie wiem dokładnie; Chodzi chyba o określenie zakresu wyprintowanych liczb metody notka_do_fftbin()

  • I poniżej jest przydział przestrzeni w pamięci, aby uruchomić transformatę
  • Inicjalizacja dźwięku - aktywacja strumienia, mikrofon lub linia USB
  • Tworzenie funkcji hanninga - jest potrzebną funkcją, bo transformatę mierzymy w określonym, skończonym okresie czasowym dla lepszego, dokładniejszego sprawdzenia wyniku.
  • Printowanie początkowego tekstu. Zbiór stałych, na podstawie, których badamy przebieg.

W While'u aktywujemy stream, pobieramy nowe dane, aktywujemy transformatę, pobieramy częstotliwość maksymalnej wartości z zakresu, pobieramy numer notacji + notatkę i określenie określenie numeru klatki (coś, jak inkrementacja).

A pod tym wszystkim, na sam koniec, w if'ie deklaracja okna, w którym to wszystko powinno się odbywać.
Po określeniu podstawowych informacji z okna, niżej są zadeklarowane trzy metody: okno(), init(), oblicz()

Robię jeszcze kod, drugą metodą:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import pandas as pd
import fig as fig
import numpy as np
import pyaudio
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
from pandas import *

if __name__ == "__main__":

    FSAMP = 22050  # czestotliwosc probkowania w Hz
    ROZMIAR_PROB = 2048  # ilosc probek
    KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
    NOTKA_MIN = 40  # E2
    NOTKA_MAX = 64  # E4

    # dla wyswietlenia nazw dzwieku

    NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT

def nazwa_notki(n):
    return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))

def czestotliwosc_na_numer(f):
    return 64 + 12 * np.log2(f / 329.63)

def numer_na_czestotliwosc(n):
    return 329.63 * 2.0 ** ((n - 64) / 12.0)

# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()

def notka_do_fftbin(n):
    return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI

imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna czestotliwoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

    # przesuwanie bufora i wprowadzenie nowych danych
    buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
    buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

    # Uruchom szybka transformate fouriera na okiennym buforze
    fft = np.fft.rfft(buf * window)

    # pobierz czestotliwosc maksymalnej wartosci z zakresu
    czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

    # pobierz numer notatki i najblizsza notatke
    n = czestotliwosc_na_numer(czestotliwosc)
    n0 = int(round(n))

    # dane wyjsciowe konsoli, gdy mamy pelny bufor
    numer_klatki += 1

    zmienna1 = ('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

    if numer_klatki >= KLATEK_NA_FFT:

        # najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
        def Okno(w):
            fig = plt.figure()
            ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
            line, = ax.plot([], [], lw=2)

        # funkcja inicjalizacji: wykresla tlo kazdej ramki
        def init():
            czestotliwosc.set_data([], [])
            return czestotliwosc,

        # funkcja animacji. Nazywa sie to sekwencyjnie
        def oblicz(i):
            x = np.linspace(0, 2, 1000)
            y = np.sin(2 * np.pi * (x - 0.01 * i))
            czestotliwosc.set_data(x, y)
            return czestotliwosc,
            anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)

    nameCol = ((n), (czestotliwosc), (nazwa_notki(n0)), (n - n0))
    data = pd.DataFrame(columns=nameCol)

    ww = n
    xx = czestotliwosc
    yy = nazwa_notki(n0)
    zz = n - n0

    dataLoop = pd.DataFrame(columns=nameCol)
    dataLoop['n'] = ww
    dataLoop['czestotliwosc'] = xx
    dataLoop['nazwa_notki(n0)'] = yy
    dataLoop['n - n0'] = zz
    value1 = data.append(dataLoop, ignore_index=True)

window1 = Tk()
window1.title('Tuner Gitarowy')
window1.geometry('1380x855')

img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
window1 = Label(window1, background='NavajoWhite3', image=img)
window1.pack(side='right', fill='both', expand='yes')

txt = scrolledtext.ScrolledText(window1, width=60, height=53)
txt.grid(column=0, row=1)

txt.insert(INSERT, dataLoop)
print(dataLoop)
window1.mainloop()

Korzystając z DataFrame, przekazuję te informacje.
Problem jest tutaj jednak taki:

FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.

Aktualizowałem DataFrame, ale nic to nie dało.
'sort=True' i 'sort=False' też dałem w różnych miejscach w kodzie.

edytowany 1x, ostatnio: Bartek Pieczka, 2019-02-05 12:15

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0