Hinzufügen von Zoom-in und Zoom-out mit einem Tkinter-Canvas-Widget?

Wie sollte ich hinzufügen, ein-und Auszoomen, um das folgende Skript, möchte ich binden Sie es auf das Mausrad. Wenn Sie testen dieses Skript auf linux vergessen Sie nicht, ändern Sie das MouseWheel-Ereignis-Taste-4 und Taste-5.

from Tkinter import * 
import Image, ImageTk

class GUI:
    def __init__(self,root):
        frame = Frame(root, bd=2, relief=SUNKEN)

        frame.grid_rowconfigure(0, weight=1)
        frame.grid_columnconfigure(0, weight=1)
        xscrollbar = Scrollbar(frame, orient=HORIZONTAL)
        xscrollbar.grid(row=1, column=0, sticky=E+W)
        yscrollbar = Scrollbar(frame)
        yscrollbar.grid(row=0, column=1, sticky=N+S)
        self.canvas = Canvas(frame, bd=0, xscrollcommand=xscrollbar.set, yscrollcommand=yscrollbar.set, xscrollincrement = 10, yscrollincrement = 10)
        self.canvas.grid(row=0, column=0, sticky=N+S+E+W)

        File = "PATH TO JPG PICTURE HERE"

        self.img = ImageTk.PhotoImage(Image.open(File))
        self.canvas.create_image(0,0,image=self.img, anchor="nw")
        self.canvas.config(scrollregion=self.canvas.bbox(ALL))
        xscrollbar.config(command=self.canvas.xview)
        yscrollbar.config(command=self.canvas.yview)

        frame.pack()

        self.canvas.bind("<Button 3>",self.grab)
        self.canvas.bind("<B3-Motion>",self.drag)
        root.bind("<MouseWheel>",self.zoom)


    def grab(self,event):
        self._y = event.y
        self._x = event.x

    def drag(self,event):
        if (self._y-event.y < 0): self.canvas.yview("scroll",-1,"units")
        elif (self._y-event.y > 0): self.canvas.yview("scroll",1,"units")
        if (self._x-event.x < 0): self.canvas.xview("scroll",-1,"units")
        elif (self._x-event.x > 0): self.canvas.xview("scroll",1,"units")
        self._x = event.x
        self._y = event.y

    def zoom(self,event):
        if event.delta>0: print "ZOOM IN!"
        elif event.delta<0: print "ZOOM OUT!"


root = Tk()   
GUI(root)
root.mainloop()

Sind Sie eigentlich auf der Suche skalieren", um die Leinwand oder nur das Bild?
alles, was auf der Leinwand, das Bild und eine Auswahl von Linien und Kreisen auf der Leinwand schließlich. Und einmal platziert, ist es unglaublich wichtig, dass alles hält die x -, y-Koordinaten.

InformationsquelleAutor Symon | 2011-03-25

13

Meines Wissens die integrierte Tkinter-Canvas-Klasse-Skala wird nicht die auto-Skalierung von Bildern. Wenn Sie nicht mit einem benutzerdefinierten widget, können Sie die Größe des raw-Bildes, und ersetzen Sie es auf der Leinwand, wenn der Maßstab die Funktion aufgerufen wird.

Das code-snippet unten zusammengefasst werden können, in Ihrer ursprünglichen Klasse. Es führt Folgendes aus:
1. Speichert das Ergebnis der Image.open().
2. Fügt eine redraw() Funktion zur Berechnung des skalierten Bildes und fügt hinzu, dass auf der Leinwand und entfernt auch das vorher-Bild gezeichnet, wenn überhaupt.
3. Verwendet die Koordinaten der Maus, die als Teil der Bild-Platzierung. Ich gebe x and y zu den create_image Funktion, zu zeigen, wie das Bild Platzierung verschiebt sich herum, als die Maus bewegt wird. Sie können ersetzen Sie diese mit Ihrem eigenen center/offset-Berechnung.
4. Diese verwendet den Linux-Mausrad-Taster 4 und 5 (Sie müssen verallgemeinern, um auf Windows, etc).
(Aktualisiert) Code:
```
class GUI:
    def __init__(self, root):

        # ... omitted rest of initialization code

        self.canvas.config(scrollregion=self.canvas.bbox(ALL))
        self.scale = 1.0
        self.orig_img = Image.open(File)
        self.img = None
        self.img_id = None
        # draw the initial image at 1x scale
        self.redraw()

        # ... rest of init, bind buttons, pack frame

    def zoom(self,event):
        if event.num == 4:
            self.scale *= 2
        elif event.num == 5:
            self.scale *= 0.5
        self.redraw(event.x, event.y)

    def redraw(self, x=0, y=0):
        if self.img_id:
            self.canvas.delete(self.img_id)
        iw, ih = self.orig_img.size
        size = int(iw * self.scale), int(ih * self.scale)
        self.img = ImageTk.PhotoImage(self.orig_img.resize(size))
        self.img_id = self.canvas.create_image(x, y, image=self.img)

        # tell the canvas to scale up/down the vector objects as well
        self.canvas.scale(ALL, x, y, self.scale, self.scale)
```
Update ich habe ein bisschen von Tests auf unterschiedlichen Skalen und fand, dass Sie ziemlich viel Speicher verwendet wird, die von Größe /create_image. Ich lief den test mit einem 540x375 JPEG auf einem Mac Pro mit 32GB RAM. Hier ist der Arbeitsspeicher, der für verschiedene Skalierungsfaktoren:
```
 1x  (500,     375)      14 M
 2x  (1000,    750)      19 M
 4x  (2000,   1500)      42 M
 8x  (4000,   3000)     181 M
16x  (8000,   6000)     640 M
32x  (16000, 12000)    1606 M
64x  (32000, 24000)  ...  
reached around ~7400 M and ran out of memory, EXC_BAD_ACCESS in _memcpy
```
Angesichts der oben genannten, eine effizientere Lösung sein könnte, um zu bestimmen, die Größe des Viewports, wo das Bild angezeigt wird, berechnen Sie ein Rechteck zum beschneiden um das Zentrum der Koordinaten der Maus, das Bild zuschneiden, mit dem rect, dann skaliert nur der beschnittene Teil. Diese sollten Konstanten-Speicher zur Speicherung der temporären Bild. Andernfalls müssen Sie möglicherweise verwenden Sie eine 3rd-party-Tkinter-Steuerung führt, die das zuschneiden /Fenster-Skalierung für Sie.

Update 2 Arbeiten, aber grob vereinfachte zuschneiden Logik, nur für den Einstieg:
```
    def redraw(self, x=0, y=0):
        if self.img_id: self.canvas.delete(self.img_id)
        iw, ih = self.orig_img.size
        # calculate crop rect
        cw, ch = iw / self.scale, ih / self.scale
        if cw > iw or ch > ih:
            cw = iw
            ch = ih
        # crop it
        _x = int(iw/2 - cw/2)
        _y = int(ih/2 - ch/2)
        tmp = self.orig_img.crop((_x, _y, _x + int(cw), _y + int(ch)))
        size = int(cw * self.scale), int(ch * self.scale)
        # draw
        self.img = ImageTk.PhotoImage(tmp.resize(size))
        self.img_id = self.canvas.create_image(x, y, image=self.img)
        gc.collect()
```
Ich kann nicht Zoomen in den vergangenen 2 anderen ich bekomme die Meldung: Runtime Error! Programm: C:\Python27\pythonw.exe Diese Anwendung hat die Laufzeit angewiesen, die beenden es in einer ungewöhnlichen Weise, Bitte Kontaktieren Sie die Anwendung ' s support-team für weitere Informationen.
du bist willkommen, schön, dass es hilft Sie Fortschritte machen. Da die Leinwand nicht automatisch die Größe von Bildern, die redraw() Methode tut dies manuell-Reskalierung und re-hinzufügen-das Bild auf die Leinwand. Gleichzeitig Skala beliebige Vektoren gezeichnet, auf der Leinwand (Linien, Ellipsen, Polygone) können Sie einen Anruf hinzufügen, um self.canvas.scale(ALL, x, y, self.scale, self.scale) zu den redraw() Methode oben.
hmm, ich verwende Linux und habe nicht gesehen, dass Fehler. Ist das Bild, das Sie skalieren, wirklich große?
Es ist ein 2058x2165 211KB .jpg-Bild, ich werde sehen, ob ich kann nichts finden, auf der interwebs. Skalierung der Elemente auf der Leinwand funktioniert Super vielen Dank für das auch!
Ich aktualisierte den code mit einem einfachen zuschneiden/skalieren Beispiel, die ist sehr schnell und verwendet steter Erinnerung. Hoffentlich nützlich ist. Viel Glück mit Ihren Bemühungen!

InformationsquelleAutor samplebias

Nur für die anderen profitieren, die sich diese Frage bin ich die Befestigung meiner neer letzten test-code, welcher verwendet Bild-in-Bild/Lupe zum Zoomen. Es ist im Grunde nur eine änderung, was samplebias schon gepostet. Es ist auch sehr cool zu sehen, wie gut :).

Als ich sagte vorher, wenn Sie dieses Skript auf linux vergessen Sie nicht, ändern Sie das MouseWheel-Ereignis-Taste-4 und Taste-5. Und Sie müssen natürlich einfügen .JPG-Pfad, wo es heißt "EINFÜGEN-JPG-DATEI-PFAD".

from Tkinter import *
import Image, ImageTk

class LoadImage:
    def __init__(self,root):
        frame = Frame(root)
        self.canvas = Canvas(frame,width=900,height=900)
        self.canvas.pack()
        frame.pack()
        File = "INSERT JPG FILE PATH"
        self.orig_img = Image.open(File)
        self.img = ImageTk.PhotoImage(self.orig_img)
        self.canvas.create_image(0,0,image=self.img, anchor="nw")

        self.zoomcycle = 0
        self.zimg_id = None

        root.bind("<MouseWheel>",self.zoomer)
        self.canvas.bind("<Motion>",self.crop)

    def zoomer(self,event):
        if (event.delta > 0):
            if self.zoomcycle != 4: self.zoomcycle += 1
        elif (event.delta < 0):
            if self.zoomcycle != 0: self.zoomcycle -= 1
        self.crop(event)

    def crop(self,event):
        if self.zimg_id: self.canvas.delete(self.zimg_id)
        if (self.zoomcycle) != 0:
            x,y = event.x, event.y
            if self.zoomcycle == 1:
                tmp = self.orig_img.crop((x-45,y-30,x+45,y+30))
            elif self.zoomcycle == 2:
                tmp = self.orig_img.crop((x-30,y-20,x+30,y+20))
            elif self.zoomcycle == 3:
                tmp = self.orig_img.crop((x-15,y-10,x+15,y+10))
            elif self.zoomcycle == 4:
                tmp = self.orig_img.crop((x-6,y-4,x+6,y+4))
            size = 300,200
            self.zimg = ImageTk.PhotoImage(tmp.resize(size))
            self.zimg_id = self.canvas.create_image(event.x,event.y,image=self.zimg)

if __name__ == '__main__':
    root = Tk()
    root.title("Crop Test")
    App = LoadImage(root)
    root.mainloop()

InformationsquelleAutor Symon

2

Könnte eine gute Idee sein Blick auf die TkZinc widget, statt der einfachen Leinwand für das, was Sie tun, es unterstützt die Skalierung über OpenGL.

Ich habe mir in TkZinc, aber wenn möglich möchte ich entwickeln die GUI nur mit der standard-Module, die mit Python 2.7.1

InformationsquelleAutor schlenk
0
1. Advanced zoom Beispiel, basierend auf den Fliesen. Wie in Google Maps.
2. Vereinfachte zoom Beispiel, basierend auf die Größe des ganzen Bildes.
InformationsquelleAutor foo bar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.