Das deutsche Python-Forum

hi

habe an meinem wellen programm weiter gemacht und bin so weit, dass ich die einzelnen bilder berechnen lasse und dann in ein 2dimensionales feld speichere. dieses feld speicher ich wiederum in eine liste.
wie kann ich jetzt diese felder moeglichst schnell ausgeben?
mit Tk und PhotoImage brauch ich bei einer aufloesung von 640*480 mehrere sekunden und eigentlich soll die sache ja fluessig laufen.

die ausgabe hab ich bis jetzt so geloest:

Code: Alles auswählen

for n in range(int(2/v)):
    for i in range(feldy):
        for j in range(feldx):
            bild.put(feld[n][i][j], (j,i))
    fenster.update()

wobei n das aktuelle bild ist i die y koordinate und j die x koordinate.

Du solltest auf jeden Fall die Bilder nicht als 2D-Feld speichern, sondern als fertiges PhotoImage. Dann brauchst Du diese nur noch der Reihe nach austauschen.
Herstellen könntest Du Sie mit PIL: Erst ein PIL-Image erzeugen, es mit Daten z.B. mittels im.putpixel() füllen und schließlich in ein Tk-PhotoImage umwandeln.
MfG
HWK

Nutzt du SciPy? Ansonsten könnte die Berechnung eher das Zeitproblem sein.

Eine andere Art der Darstellung wäre mit matplotlib zu erreichen, ist für graphische Darstellung von Daten meiner Meinung nach besser geeignet, als sie in ein Bild zu schreiben.

das problem, was ich habe ist ja, dass die berechnung auch schon sehr lange braucht. deswegen wollte ich die ganzen sachen cachen und dann sauber abspielen.
und SciPy nutze ich nicht, hatte es aber vor, steig die ganze sache aber noch nicht durch..
ich wollte sowieso die ausgabe von der berechnung trennen, und mir ist eine fluessige ausgabe erst mal wichtiger.

so das rohe script steht jetzt, aber zufrieden bin damit nicht, weil ich nicht unbedingt das zeug erst auf platte speichern will.
außerdem ist die ausgabe verdammt langsam bei groeßeren bildern.

Code: Alles auswählen

import math, copy
from time import sleep, time
from Tkinter import *
from PIL import Image

def getgap(xz , yz, x, y):
    return math.sqrt((xz-x)**2+(yz-y)**2)   #berechne abstand zu einem zentrum

def getamp(x1,y1, x2,y2, x, y):
    global winkel, wellenlaenge
    return math.sin((winkel - getgap(x1,y1, x, y)/wellenlaenge) * math.pi) + \
           math.sin((winkel - getgap(x2,y2, x, y)/wellenlaenge) * math.pi) + 2
           #h = sin(winkel*pi - abstand1) + sin(winkel*pi - abstand2)

def getColor(sw):
        return "#%02X%02X%02X" % (sw,sw,sw)

    
winkel = 0
wellenlaenge = 19
v = 0.1
#koordinaten z1
x1 = 150
y1 = 200
#koordinaten z2
x2 = 200
y2 = 200
#feldgroesse
feldx = 400
feldy = 300

n = 0
bild = Image.new("L", (feldx,feldy))

while winkel + 0.000001 < 2:
    t = time()
    for i in range(feldy):
        for j in range(feldx):
            bild.putpixel((j, i), int(getamp(x1,y1,x2,y2,j,i)*64))  #berechne hoehe des punktes i,j
    #speichen
    bild.save(str(n).zfill(2)+".GIF", "GIF")
    print "\rBild %d von %d fertig" % (n+1, int(2/v)),
    winkel += v
    n += 1
#    print "\r%2.3f FPS" % (1/(time()-t+0.001)),   #berechne FPS

fenster = Tk()
bild = PhotoImage(width = feldx, height = feldy)
Label(master=fenster, image=bild).pack()
#ausgabe
while 1:
    for n in range(int(2.0001/v)):
        bild.config(file = str(n).zfill(2)+".GIF")
        fenster.update()

Hm, ich finde die Animation nicht langsam.

Die Ausgabe des Fortschritts der Bilder wird gepuffert, da sollte ein explizites `sys.stdout.flush()` passieren.

``global`` ist nicht nur böse™ sondern in `getamp()` auch völlig überflüssig. Ebenfalls böse ist der *-Import. Damit tummeln sich ca. 170 Namen im Modul, die nie benutzt werden.

Mit dem `ImageTk`-Modul von `PIL` kann man `PhotoImage`-Objekte ohne den Umweg über die Platte erzeugen.

Das deutsche Python-Forum

bild aus einer liste ausgeben

bild aus einer liste ausgeben