Problem z wywołaniem okna Tkinter

Odpowiedz Nowy wątek
2019-02-08 16:36
0

Drodzy,
jest kod zawierający klasę Okno(), wewnątrz której (w metodzie ScrolledText) powinien wykonywać się program.
Czy konstrukcja, odwoływania, zagnieżdżenia, typu:

class okno():

     def operacja(init, txt):
            (...)

            def nazwa_notki(n):

            def czestotliwosc_na_numer(f):

            def numer_na_czestotliwosc(n)

            def notka_do_fftbin(n):
            (...)

            print (...)

            while (...)

     window1.mainloop()  

Mogą być? Jeżeli wszystko się kompiluje, to ciężko mi stwierdzić, gdzie jest problem, że to nie jest wywoływane.

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import pyaudio
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image

class okno():

    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)

    def operacja(init, txt):
        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 rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

        # otrzymywane dane w czasie:
        while stream.is_active(txt):
            # 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
            txt.insert(INSERT, 'Numer: {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

    window1.mainloop()

Udostępniam paczkę z kodem, chodzi o "Guitar.py", python, jakiego używam do kompilacji jest w wersji 2.7
https://megawrzuta.pl/downloa[...]cb230bbbe5582059d3f3afe0.html

edytowany 2x, ostatnio: Bartek Pieczka, 2019-02-08 16:41

Pozostało 580 znaków

2019-02-09 22:34
1

Wywal w końcu to odwołanie do modułu tkinter. Jak nie wierzysz, to otwórz sobie konsolę Pythona i sam sprawdź. Poniżej masz screeny na dowód.

Python 3 -> moduł nazywa się tkinter, nie rozpoznaje Tkinter
screenshot-20190210002332.png

Python 2 -> moduł nazywa się Tkinter, nie rozpoznaje tkinter
screenshot-20190210002347.png


Prosząc o pomoc w wiadomości prywatnej odbierasz sobie szansę na otrzymanie pomocy od kogoś bardziej kompetentnego :)
edytowany 1x, ostatnio: superdurszlak, 2019-02-10 00:25

Pozostało 580 znaków

2019-02-10 01:24
0

Superdurszlak, przepraszam Cię, ale próbuję robić ten kod metodą prób i błędów już od 3 tygodni.
Kompiluje się bez błędów, nie wyświetla okna.

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import pyaudio
from PIL import ImageTk, Image
from tkinter import *
from tkinter import scrolledtext

UPDATE_RATE = 1000

class Okno(object):

    def __init__(self, master):

        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)

        self.operacja()
        window1.mainloop()

    def operacja(self):
        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 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
            print('Numer: {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

app = Okno
app.__init__
app.operacja
Sprawdź lepiej, jaką naprawdę masz wersję bo skoro Twoje importy działają (ale nie, nie kompilują) to mam wątpliwości czy PyCharm na pewno używa tutaj Pythona 2.7 a nie 3.x - superdurszlak 2019-02-10 01:37

Pozostało 580 znaków

2019-02-10 01:38
0

screenshot-20190210013851.png
Wersja: 2.7

Pozostało 580 znaków

2019-02-10 01:42
1
app = Okno
app.__init__
app.operacja

Jak chcesz stworzyć obiekt Okno, to musisz wywołać konstruktor i metodę, którą chcesz wywołać. Tutaj nie wywołujesz nic.

Btw po co init przyjmuje argument master, skoro tworzysz w nim okno aplikacji od zera tzn od Tk()?

Może pora porzucić metodę prób i błędów na rzecz metody "czytam dokumentację lub przynajmniej tutoriale żeby robić rzeczy ze zrozumieniem"? :)


Prosząc o pomoc w wiadomości prywatnej odbierasz sobie szansę na otrzymanie pomocy od kogoś bardziej kompetentnego :)

Pozostało 580 znaków

2019-02-10 02:04
0
superdurszlak napisał(a):
app = Okno
app.__init__
app.operacja

Jak chcesz stworzyć obiekt Okno, to musisz wywołać konstruktor i metodę, którą chcesz wywołać. Tutaj nie wywołujesz nic.

Btw po co init przyjmuje argument master, skoro tworzysz w nim okno aplikacji od zera tzn od Tk()?

Może pora porzucić metodę prób i błędów na rzecz metody "czytam dokumentację lub przynajmniej tutoriale żeby robić rzeczy ze zrozumieniem"? :)

Moja pomyłka, przepraszam. Myślałem, że wywołuję.
master - usunięty.

Ogólnie - podchodząc do problemu wywołania obliczeń w pętli, wewnątrz okna, nie spodziewałem się, że będzie to takie trudne i problematyczne.
Jak już wspomniałem - robiłem na wiele sposobów, m. in. w oparciu o książkę: "Zanurkuj w Pythonie", a także: "Python, wprowadzenie, wydanie IV".

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import pyaudio
from tkinter import scrolledtext, Label, Tk
from PIL import ImageTk, Image

UPDATE_RATE = 1000

class Okno(object):

    def okieneczko(self):

        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)

        self.operacja()
        window1.mainloop()

    def operacja(self):
        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 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
            print('Numer: {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

app = Okno()
app.okieneczko()
# app.operacja()

W:

    def okieneczko(self):

        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)

        self.operacja()
        window1.mainloop()

Ciekawa rzecz.
Jeżeli w metodzie def okieneczko nic nie zrobię z self.operacja(), nie wyprintuje okna tkinter - program bedzie działał.
Gdy zakomentuję:

  • self.operacja(), okno się włączy. Po wyłączeniu nic się nie stanie.
edytowany 4x, ostatnio: Bartek Pieczka, 2019-02-10 16:35

Pozostało 580 znaków

2019-02-11 13:38
0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import pyaudio
import tkinter
from tkinter import scrolledtext, Label, Tk
from PIL import ImageTk, Image

UPDATE_RATE = 1000

class Okno(tkinter.Frame):

    def __init__(self, master):
        tkinter.Frame.__init__(self, master)

        self.window1 = Tk()
        self.img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
        window1 = Label(self.window1, background='NavajoWhite3', image=self.img)
        window1.pack(side='right', fill='both', expand='yes')
        txt = scrolledtext.ScrolledText(self.window1, width=60, height=53)
        txt.grid(column=0, row=1)
        self.yy()
        self.stream.is_active()
        self.xx()

        self.window1.mainloop()

    def operacja(self):
        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
        self.yy = ('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

        # otrzymywane dane w czasie:
        while self.stream.is_active(scrolledtext):
            # 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
            self.xx = ('Numer: {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

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

o = Okno(app)
o.Okno()
o.operacja()

screenshot-20190211132501.png

Co mu nie odpowiada, że:

(linijka 19) window1 = Label(self.window1, background='NavajoWhite3', image=self.img)
(linijka 100) o = Okno(app)

Kurczę, no czytałem dokumentację i zrozumiałem to tak, że init powinno się wywoływać bezpośrednio po utworzeniu klasy. Mając przypisanego selfa (odwołuje się do samej siebie).
Opierając się o kod Guaza, wydawało mi się, że jest to poprawnie opisane.

Pozostało 580 znaków

2019-02-11 13:40
1
o = Okno(app)
o.Okno()

Nope, nope, nope.

Już przy tworzeniu obiektu:

o = Okno(app)

pod spodem wywołuje się metoda __init__


Prosząc o pomoc w wiadomości prywatnej odbierasz sobie szansę na otrzymanie pomocy od kogoś bardziej kompetentnego :)

Pozostało 580 znaków

2019-02-11 14:39
0

Ok, to już jest chyba dobrze.

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

o = Okno(app)
app.mainloop()

Linijka 19sta dalej mu nie pasuje:

    def __init__(self, master):
        tkinter.Frame.__init__(self, master)

        self.window1 = Tk()
        self.img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
        window1 = Label(self.window1, background='NavajoWhite3', image=self.img)
        window1.pack(side='right', fill='both', expand='yes')
        txt = scrolledtext.ScrolledText(self.window1, width=60, height=53)
        txt.grid(column=0, row=1)
        self.yy()
        self.stream.is_active()
        self.xx()

Tak wygląda ten init.
Krzaczy mu przy wywołaniu img:

window1 = Label(self.window1, background='NavajoWhite3', image=self.img)
Nie widać, która linijka jest 19, szczególnie gdy wrzucasz tylko fragment kodu - superdurszlak 2019-02-11 14:46

Pozostało 580 znaków

2019-02-11 14:47
1
Bartek Pieczka napisał(a):

Tak wygląda ten init.
Krzaczy mu przy wywołaniu img:

window1 = Label(self.window1, background='NavajoWhite3', image=self.img)

Bo tworzysz luźny obiekt window1, a próbujesz odwołać się do niego jak do pola: self.window1


Prosząc o pomoc w wiadomości prywatnej odbierasz sobie szansę na otrzymanie pomocy od kogoś bardziej kompetentnego :)

Pozostało 580 znaków

2019-02-11 14:58
0

screenshot-20190211145740.png

self.window1 = Label(self.window1, background='NavajoWhite3', image=self.img)

Wiem, że lamię, ale ta korekta nic nie dała.

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