Discussion :

[sopsag]

Bonjour à tous,

je voudrais dessiner au pixel près dans un canevas (ou toute autre structure plus indiquée) de manière efficace.

Je m'explique : je voudrais dessiner des fractales (type Mendelbrot/Julia) animées dans une appli Tkinter qui me permette de passer du mode plein écran au mode fenêtré facilement (en cours d'animation).

J'ai bien regardé du coté des tutoriels, mais je ne vois pas de manière efficace (i.e rapide) d'allumer les pixels de mon canevas (la méthode du rectangle ou du segment de 1 pixel me paraît un peut lourde quand je dois l'appliquer à tous les pixels).

Je pense que le truc c'est de créer une image en mémoire et de la plaquer d'un coup sur le canevas.
Mais comment créer une image ? (avec PIL ? ou y a-t-il plus simple ?) puis accéder aux pixels en mémoire ?
Est-ce vraiment ce qu'il y a de plus efficace ?
Du coté de numpy peut-être ?

Enfin, comment obtenir un canevas qui fasse tout l'écran ? Ou au moins toute la surface de l'appli ?

Voilà, c'est un peu confus mais je pense que l'idée y est...

Merci d'avance !

[PauseKawa]

Bonjour,

Et ceci ?

@+

[sopsag]

Merci PauseKawa, mais ton machin ne permet pas plus de manipuler des pixels...
En fait, j'ai réussi à pondre ce truc là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class Context:
    pass
 
def test_image ( size = (640,480)):
 
    import Tkinter
    from PIL import Image,ImageTk
 
    self = Context()
    self.PILimage = Image.new( "RGB",size )
    self.index    = 0
    self.size     = size
 
    def resize ( e ):
        new_size = ( e.width , e.height )
        print 're(%dx%d)'%new_size 
        if self.size != new_size:
            self.size = new_size 
            self.PILimage = self.PILimage.resize( self.size ,Image.BICUBIC )
            update_image()
 
    def update_image ():
        print 'up(%d)-(%d x %d)(%d x %d)'%(self.index,self.size[0],self.size[1],self.PILimage.size[0],self.PILimage.size[1] ) 
        im = self.PILimage.load()
        for y in range( self.size[1] ):
            for x in range( self.size[0] ):
                im[x,y] = ( (x+self.index)%256 , (y+self.index*12)%256 , (x+y+self.index*13)%256 )
 
        self.index += 1
        self.TKimage = ImageTk.PhotoImage( self.PILimage )
        self.can.create_image( 0,0, anchor = Tkinter.NW, image = self.TKimage )
        self.can.pack()
 
    self.root = Tkinter.Tk()
    self.root.title( 'image' )
    self.root.geometry('%dx%d+300+50' % self.size )
    self.root.bind('<Escape>',lambda e : self.root.quit())
    self.root.bind('<space>' ,lambda e : update_image())
    self.root.bind('<Configure>' , resize )
    self.can = Tkinter.Canvas( self.root,width = self.size[0],height = self.size[1] )
    update_image()
    self.can.pack()
    self.root.mainloop()
 
 
test_image()

La barre d'espace permet de modifier l'image. Ça, ça marche... (ce n'est bien sûr qu'une maquette... après il y aura un vrai calcul qui donnera une image plus intéressante).
Mais avant ça, je voudrais corriger le resize qui ne marche pas...
Et je n'a plus d'idée... il me semble que j'ai tout retourné (le code, le web, les tutos) mais je ne trouve pas...

---> ce que j'observe c'est que l'image est bien redimensionnée (les traces le prouvent), mais au moment de l'afficher, elle reste toujours en 640x480 !
Je dois oublier un genre de refresh quelque part...

Autre mystère (mais qui n'aura plus d'importance quand le resize marchera) c'est que bien que l'image soit ancrée en haut à droite (NW), quand on agrandit la fenêtre, elle se reste au milieu en haut (N)...

Si quelqu'un a une idée, je suis preneur...
Merci d'avance !

[dividee]

Pour un accès vraiment efficace j'utiliserais pygame (numpy + module surfArray de pygame). Mais il y a peu de chance de pouvoir intégrer la surface SDL à un canevas Tk...

[sopsag]

Je viens de jeter un oeil sur pygame : ça a l'air vraiment super !
Mais il faut repenser toute l'appli...

Sinon, j'ai trouvé tout seul la réponse à ma question.
Je la laisse ici pour ceux et celles qui se posent la même :

Le "genre de refresh" que j'avais oublié est un Canevas.configure dans la sous-fonction resize :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
def resize ( e ):
    new_size = ( e.width , e.height )
    if self.size != new_size:
        self.size = new_size 
        self.PILimage = self.PILimage.resize( self.size,Image.NEAREST )
        #### ICI ---v ####
        self.can.configure( width = self.size[0], height = self.size[1] )
        update()