Question

Tkinter的canvas小部件具有内置功能：

使用canvas.scan_mark和canvas.scan_dragto移动/平移画布（例如使用Click + Drag），请参阅this question
使用canvas.scale缩放画布上的矢量元素，但遗憾的是，这个doesn't work用于画布上的位图图像

幸运的是，this method允许缩放图像（通过手动重绘图像的缩放部分）。但是：

在我们重新绘制画布的特定部分时，移动/平移功能将不再起作用...
我们绝对需要渲染超过当前显示的区域，以允许移动/平移。假设我们在画布上有1000x1000位图，我们想要缩放50倍...如何避免在内存中有50.000 x 50.000像素的位图？（RAM中2.5千兆像素太大）。我们可以考虑仅渲染视口，或者比当前视口稍微多一点以允许平移，但是一旦平移导致渲染区域的边缘怎么办？

如何在Tkinter画布上使用移动/平移+缩放功能，适用于图像？

Answer 1

高级缩放示例。就像谷歌地图一样。

视频示例（longer video here）：

它仅缩放图块，但不缩放整个图像。因此，缩放的瓷砖占据了恒定的记忆，而不是为大型缩放图像调整大尺寸图像。对于简化的缩放示例look here。

在Windows 7 64位和Python 3.6.2上测试。

不要忘记在脚本末尾放置图像路径。

# -*- coding: utf-8 -*-
# Advanced zoom example. Like in Google Maps.
# It zooms only a tile, but not the whole image. So the zoomed tile occupies
# constant memory and not crams it with a huge resized image for the large zooms.
import random
import tkinter as tk
from tkinter import ttk
from PIL import Image, ImageTk

class AutoScrollbar(ttk.Scrollbar):
    ''' A scrollbar that hides itself if it's not needed.
        Works only if you use the grid geometry manager '''
    def set(self, lo, hi):
        if float(lo) <= 0.0 and float(hi) >= 1.0:
            self.grid_remove()
        else:
            self.grid()
            ttk.Scrollbar.set(self, lo, hi)

    def pack(self, **kw):
        raise tk.TclError('Cannot use pack with this widget')

    def place(self, **kw):
        raise tk.TclError('Cannot use place with this widget')

class Zoom_Advanced(ttk.Frame):
    ''' Advanced zoom of the image '''
    def __init__(self, mainframe, path):
        ''' Initialize the main Frame '''
        ttk.Frame.__init__(self, master=mainframe)
        self.master.title('Zoom with mouse wheel')
        # Vertical and horizontal scrollbars for canvas
        vbar = AutoScrollbar(self.master, orient='vertical')
        hbar = AutoScrollbar(self.master, orient='horizontal')
        vbar.grid(row=0, column=1, sticky='ns')
        hbar.grid(row=1, column=0, sticky='we')
        # Create canvas and put image on it
        self.canvas = tk.Canvas(self.master, highlightthickness=0,
                                xscrollcommand=hbar.set, yscrollcommand=vbar.set)
        self.canvas.grid(row=0, column=0, sticky='nswe')
        self.canvas.update()  # wait till canvas is created
        vbar.configure(command=self.scroll_y)  # bind scrollbars to the canvas
        hbar.configure(command=self.scroll_x)
        # Make the canvas expandable
        self.master.rowconfigure(0, weight=1)
        self.master.columnconfigure(0, weight=1)
        # Bind events to the Canvas
        self.canvas.bind('<Configure>', self.show_image)  # canvas is resized
        self.canvas.bind('<ButtonPress-1>', self.move_from)
        self.canvas.bind('<B1-Motion>',     self.move_to)
        self.canvas.bind('<MouseWheel>', self.wheel)  # with Windows and MacOS, but not Linux
        self.canvas.bind('<Button-5>',   self.wheel)  # only with Linux, wheel scroll down
        self.canvas.bind('<Button-4>',   self.wheel)  # only with Linux, wheel scroll up
        self.image = Image.open(path)  # open image
        self.width, self.height = self.image.size
        self.imscale = 1.0  # scale for the canvaas image
        self.delta = 1.3  # zoom magnitude
        # Put image into container rectangle and use it to set proper coordinates to the image
        self.container = self.canvas.create_rectangle(0, 0, self.width, self.height, width=0)
        # Plot some optional random rectangles for the test purposes
        minsize, maxsize, number = 5, 20, 10
        for n in range(number):
            x0 = random.randint(0, self.width - maxsize)
            y0 = random.randint(0, self.height - maxsize)
            x1 = x0 + random.randint(minsize, maxsize)
            y1 = y0 + random.randint(minsize, maxsize)
            color = ('red', 'orange', 'yellow', 'green', 'blue')[random.randint(0, 4)]
            self.canvas.create_rectangle(x0, y0, x1, y1, fill=color, activefill='black')
        self.show_image()

    def scroll_y(self, *args, **kwargs):
        ''' Scroll canvas vertically and redraw the image '''
        self.canvas.yview(*args, **kwargs)  # scroll vertically
        self.show_image()  # redraw the image

    def scroll_x(self, *args, **kwargs):
        ''' Scroll canvas horizontally and redraw the image '''
        self.canvas.xview(*args, **kwargs)  # scroll horizontally
        self.show_image()  # redraw the image

    def move_from(self, event):
        ''' Remember previous coordinates for scrolling with the mouse '''
        self.canvas.scan_mark(event.x, event.y)

    def move_to(self, event):
        ''' Drag (move) canvas to the new position '''
        self.canvas.scan_dragto(event.x, event.y, gain=1)
        self.show_image()  # redraw the image

    def wheel(self, event):
        ''' Zoom with mouse wheel '''
        x = self.canvas.canvasx(event.x)
        y = self.canvas.canvasy(event.y)
        bbox = self.canvas.bbox(self.container)  # get image area
        if bbox[0] < x < bbox[2] and bbox[1] < y < bbox[3]: pass  # Ok! Inside the image
        else: return  # zoom only inside image area
        scale = 1.0
        # Respond to Linux (event.num) or Windows (event.delta) wheel event
        if event.num == 5 or event.delta == -120:  # scroll down
            i = min(self.width, self.height)
            if int(i * self.imscale) < 30: return  # image is less than 30 pixels
            self.imscale /= self.delta
            scale        /= self.delta
        if event.num == 4 or event.delta == 120:  # scroll up
            i = min(self.canvas.winfo_width(), self.canvas.winfo_height())
            if i < self.imscale: return  # 1 pixel is bigger than the visible area
            self.imscale *= self.delta
            scale        *= self.delta
        self.canvas.scale('all', x, y, scale, scale)  # rescale all canvas objects
        self.show_image()

    def show_image(self, event=None):
        ''' Show image on the Canvas '''
        bbox1 = self.canvas.bbox(self.container)  # get image area
        # Remove 1 pixel shift at the sides of the bbox1
        bbox1 = (bbox1[0] + 1, bbox1[1] + 1, bbox1[2] - 1, bbox1[3] - 1)
        bbox2 = (self.canvas.canvasx(0),  # get visible area of the canvas
                 self.canvas.canvasy(0),
                 self.canvas.canvasx(self.canvas.winfo_width()),
                 self.canvas.canvasy(self.canvas.winfo_height()))
        bbox = [min(bbox1[0], bbox2[0]), min(bbox1[1], bbox2[1]),  # get scroll region box
                max(bbox1[2], bbox2[2]), max(bbox1[3], bbox2[3])]
        if bbox[0] == bbox2[0] and bbox[2] == bbox2[2]:  # whole image in the visible area
            bbox[0] = bbox1[0]
            bbox[2] = bbox1[2]
        if bbox[1] == bbox2[1] and bbox[3] == bbox2[3]:  # whole image in the visible area
            bbox[1] = bbox1[1]
            bbox[3] = bbox1[3]
        self.canvas.configure(scrollregion=bbox)  # set scroll region
        x1 = max(bbox2[0] - bbox1[0], 0)  # get coordinates (x1,y1,x2,y2) of the image tile
        y1 = max(bbox2[1] - bbox1[1], 0)
        x2 = min(bbox2[2], bbox1[2]) - bbox1[0]
        y2 = min(bbox2[3], bbox1[3]) - bbox1[1]
        if int(x2 - x1) > 0 and int(y2 - y1) > 0:  # show image if it in the visible area
            x = min(int(x2 / self.imscale), self.width)   # sometimes it is larger on 1 pixel...
            y = min(int(y2 / self.imscale), self.height)  # ...and sometimes not
            image = self.image.crop((int(x1 / self.imscale), int(y1 / self.imscale), x, y))
            imagetk = ImageTk.PhotoImage(image.resize((int(x2 - x1), int(y2 - y1))))
            imageid = self.canvas.create_image(max(bbox2[0], bbox1[0]), max(bbox2[1], bbox1[1]),
                                               anchor='nw', image=imagetk)
            self.canvas.lower(imageid)  # set image into background
            self.canvas.imagetk = imagetk  # keep an extra reference to prevent garbage-collection

path = 'doge.jpg'  # place path to your image here
root = tk.Tk()
app = Zoom_Advanced(root, path=path)
root.mainloop()

修改

我创造了更高级的缩放功能。有“图像金字塔”可以平滑地缩放大图像，甚至可以打开和缩放大到几千兆字节的巨大TIFF文件。

3.0版在Windows 7 64位和Python 3.7上进行了测试。

# -*- coding: utf-8 -*- # Advanced zoom for images of various types from small to huge up to several GB import math import warnings import tkinter as tk from tkinter import ttk from PIL import Image, ImageTk class AutoScrollbar(ttk.Scrollbar): """ A scrollbar that hides itself if it's not needed. Works only for grid geometry manager """ def set(self, lo, hi): if float(lo) <= 0.0 and float(hi) >= 1.0: self.grid_remove() else: self.grid() ttk.Scrollbar.set(self, lo, hi) def pack(self, **kw): raise tk.TclError('Cannot use pack with the widget ' + self.__class__.__name__) def place(self, **kw): raise tk.TclError('Cannot use place with the widget ' + self.__class__.__name__) class CanvasImage: """ Display and zoom image """ def __init__(self, placeholder, path): """ Initialize the ImageFrame """ self.imscale = 1.0 # scale for the canvas image zoom, public for outer classes self.__delta = 1.3 # zoom magnitude self.__filter = Image.ANTIALIAS # could be: NEAREST, BILINEAR, BICUBIC and ANTIALIAS self.__previous_state = 0 # previous state of the keyboard self.path = path # path to the image, should be public for outer classes # Create ImageFrame in placeholder widget self.__imframe = ttk.Frame(placeholder) # placeholder of the ImageFrame object # Vertical and horizontal scrollbars for canvas hbar = AutoScrollbar(self.__imframe, orient='horizontal') vbar = AutoScrollbar(self.__imframe, orient='vertical') hbar.grid(row=1, column=0, sticky='we') vbar.grid(row=0, column=1, sticky='ns') # Create canvas and bind it with scrollbars. Public for outer classes self.canvas = tk.Canvas(self.__imframe, highlightthickness=0, xscrollcommand=hbar.set, yscrollcommand=vbar.set) self.canvas.grid(row=0, column=0, sticky='nswe') self.canvas.update() # wait till canvas is created hbar.configure(command=self.__scroll_x) # bind scrollbars to the canvas vbar.configure(command=self.__scroll_y) # Bind events to the Canvas self.canvas.bind('<Configure>', lambda event: self.__show_image()) # canvas is resized self.canvas.bind('<ButtonPress-1>', self.__move_from) # remember canvas position self.canvas.bind('<B1-Motion>', self.__move_to) # move canvas to the new position self.canvas.bind('<MouseWheel>', self.__wheel) # zoom for Windows and MacOS, but not Linux self.canvas.bind('<Button-5>', self.__wheel) # zoom for Linux, wheel scroll down self.canvas.bind('<Button-4>', self.__wheel) # zoom for Linux, wheel scroll up # Handle keystrokes in idle mode, because program slows down on a weak computers, # when too many key stroke events in the same time self.canvas.bind('<Key>', lambda event: self.canvas.after_idle(self.__keystroke, event)) # Decide if this image huge or not self.__huge = False # huge or not self.__huge_size = 14000 # define size of the huge image self.__band_width = 1024 # width of the tile band Image.MAX_IMAGE_PIXELS = 1000000000 # suppress DecompressionBombError for the big image with warnings.catch_warnings(): # suppress DecompressionBombWarning warnings.simplefilter('ignore') self.__image = Image.open(self.path) # open image, but down't load it self.imwidth, self.imheight = self.__image.size # public for outer classes if self.imwidth * self.imheight > self.__huge_size * self.__huge_size and \ self.__image.tile[0][0] == 'raw': # only raw images could be tiled self.__huge = True # image is huge self.__offset = self.__image.tile[0][2] # initial tile offset self.__tile = [self.__image.tile[0][0], # it have to be 'raw' [0, 0, self.imwidth, 0], # tile extent (a rectangle) self.__offset, self.__image.tile[0][3]] # list of arguments to the decoder self.__min_side = min(self.imwidth, self.imheight) # get the smaller image side # Create image pyramid self.__pyramid = [self.smaller()] if self.__huge else [Image.open(self.path)] # Set ratio coefficient for image pyramid self.__ratio = max(self.imwidth, self.imheight) / self.__huge_size if self.__huge else 1.0 self.__curr_img = 0 # current image from the pyramid self.__scale = self.imscale * self.__ratio # image pyramide scale self.__reduction = 2 # reduction degree of image pyramid w, h = self.__pyramid[-1].size while w > 512 and h > 512: # top pyramid image is around 512 pixels in size w /= self.__reduction # divide on reduction degree h /= self.__reduction # divide on reduction degree self.__pyramid.append(self.__pyramid[-1].resize((int(w), int(h)), self.__filter)) # Put image into container rectangle and use it to set proper coordinates to the image self.container = self.canvas.create_rectangle((0, 0, self.imwidth, self.imheight), width=0) self.__show_image() # show image on the canvas self.canvas.focus_set() # set focus on the canvas def smaller(self): """ Resize image proportionally and return smaller image """ w1, h1 = float(self.imwidth), float(self.imheight) w2, h2 = float(self.__huge_size), float(self.__huge_size) aspect_ratio1 = w1 / h1 aspect_ratio2 = w2 / h2 # it equals to 1.0 if aspect_ratio1 == aspect_ratio2: image = Image.new('RGB', (int(w2), int(h2))) k = h2 / h1 # compression ratio w = int(w2) # band length elif aspect_ratio1 > aspect_ratio2: image = Image.new('RGB', (int(w2), int(w2 / aspect_ratio1))) k = h2 / w1 # compression ratio w = int(w2) # band length else: # aspect_ratio1 < aspect_ration2 image = Image.new('RGB', (int(h2 * aspect_ratio1), int(h2))) k = h2 / h1 # compression ratio w = int(h2 * aspect_ratio1) # band length i, j, n = 0, 1, round(0.5 + self.imheight / self.__band_width) while i < self.imheight: print('\rOpening image: {j} from {n}'.format(j=j, n=n), end='') band = min(self.__band_width, self.imheight - i) # width of the tile band self.__tile[1][3] = band # set band width self.__tile[2] = self.__offset + self.imwidth * i * 3 # tile offset (3 bytes per pixel) self.__image.close() self.__image = Image.open(self.path) # reopen / reset image self.__image.size = (self.imwidth, band) # set size of the tile band self.__image.tile = [self.__tile] # set tile cropped = self.__image.crop((0, 0, self.imwidth, band)) # crop tile band image.paste(cropped.resize((w, int(band * k)+1), self.__filter), (0, int(i * k))) i += band j += 1 print('\r' + 30*' ' + '\r', end='') # hide printed string return image def redraw_figures(self): """ Dummy function to redraw figures in the children classes """ pass def grid(self, **kw): """ Put CanvasImage widget on the parent widget """ self.__imframe.grid(**kw) # place CanvasImage widget on the grid self.__imframe.grid(sticky='nswe') # make frame container sticky self.__imframe.rowconfigure(0, weight=1) # make canvas expandable self.__imframe.columnconfigure(0, weight=1) def pack(self, **kw): """ Exception: cannot use pack with this widget """ raise Exception('Cannot use pack with the widget ' + self.__class__.__name__) def place(self, **kw): """ Exception: cannot use place with this widget """ raise Exception('Cannot use place with the widget ' + self.__class__.__name__) # noinspection PyUnusedLocal def __scroll_x(self, *args, **kwargs): """ Scroll canvas horizontally and redraw the image """ self.canvas.xview(*args) # scroll horizontally self.__show_image() # redraw the image # noinspection PyUnusedLocal def __scroll_y(self, *args, **kwargs): """ Scroll canvas vertically and redraw the image """ self.canvas.yview(*args) # scroll vertically self.__show_image() # redraw the image def __show_image(self): """ Show image on the Canvas. Implements correct image zoom almost like in Google Maps """ box_image = self.canvas.coords(self.container) # get image area box_canvas = (self.canvas.canvasx(0), # get visible area of the canvas self.canvas.canvasy(0), self.canvas.canvasx(self.canvas.winfo_width()), self.canvas.canvasy(self.canvas.winfo_height())) box_img_int = tuple(map(int, box_image)) # convert to integer or it will not work properly # Get scroll region box box_scroll = [min(box_img_int[0], box_canvas[0]), min(box_img_int[1], box_canvas[1]), max(box_img_int[2], box_canvas[2]), max(box_img_int[3], box_canvas[3])] # Horizontal part of the image is in the visible area if box_scroll[0] == box_canvas[0] and box_scroll[2] == box_canvas[2]: box_scroll[0] = box_img_int[0] box_scroll[2] = box_img_int[2] # Vertical part of the image is in the visible area if box_scroll[1] == box_canvas[1] and box_scroll[3] == box_canvas[3]: box_scroll[1] = box_img_int[1] box_scroll[3] = box_img_int[3] # Convert scroll region to tuple and to integer self.canvas.configure(scrollregion=tuple(map(int, box_scroll))) # set scroll region x1 = max(box_canvas[0] - box_image[0], 0) # get coordinates (x1,y1,x2,y2) of the image tile y1 = max(box_canvas[1] - box_image[1], 0) x2 = min(box_canvas[2], box_image[2]) - box_image[0] y2 = min(box_canvas[3], box_image[3]) - box_image[1] if int(x2 - x1) > 0 and int(y2 - y1) > 0: # show image if it in the visible area if self.__huge and self.__curr_img < 0: # show huge image h = int((y2 - y1) / self.imscale) # height of the tile band self.__tile[1][3] = h # set the tile band height self.__tile[2] = self.__offset + self.imwidth * int(y1 / self.imscale) * 3 self.__image.close() self.__image = Image.open(self.path) # reopen / reset image self.__image.size = (self.imwidth, h) # set size of the tile band self.__image.tile = [self.__tile] image = self.__image.crop((int(x1 / self.imscale), 0, int(x2 / self.imscale), h)) else: # show normal image image = self.__pyramid[max(0, self.__curr_img)].crop( # crop current img from pyramid (int(x1 / self.__scale), int(y1 / self.__scale), int(x2 / self.__scale), int(y2 / self.__scale))) # imagetk = ImageTk.PhotoImage(image.resize((int(x2 - x1), int(y2 - y1)), self.__filter)) imageid = self.canvas.create_image(max(box_canvas[0], box_img_int[0]), max(box_canvas[1], box_img_int[1]), anchor='nw', image=imagetk) self.canvas.lower(imageid) # set image into background self.canvas.imagetk = imagetk # keep an extra reference to prevent garbage-collection def __move_from(self, event): """ Remember previous coordinates for scrolling with the mouse """ self.canvas.scan_mark(event.x, event.y) def __move_to(self, event): """ Drag (move) canvas to the new position """ self.canvas.scan_dragto(event.x, event.y, gain=1) self.__show_image() # zoom tile and show it on the canvas def outside(self, x, y): """ Checks if the point (x,y) is outside the image area """ bbox = self.canvas.coords(self.container) # get image area if bbox[0] < x < bbox[2] and bbox[1] < y < bbox[3]: return False # point (x,y) is inside the image area else: return True # point (x,y) is outside the image area def __wheel(self, event): """ Zoom with mouse wheel """ x = self.canvas.canvasx(event.x) # get coordinates of the event on the canvas y = self.canvas.canvasy(event.y) if self.outside(x, y): return # zoom only inside image area scale = 1.0 # Respond to Linux (event.num) or Windows (event.delta) wheel event if event.num == 5 or event.delta == -120: # scroll down, smaller if round(self.__min_side * self.imscale) < 30: return # image is less than 30 pixels self.imscale /= self.__delta scale /= self.__delta if event.num == 4 or event.delta == 120: # scroll up, bigger i = min(self.canvas.winfo_width(), self.canvas.winfo_height()) >> 1 if i < self.imscale: return # 1 pixel is bigger than the visible area self.imscale *= self.__delta scale *= self.__delta # Take appropriate image from the pyramid k = self.imscale * self.__ratio # temporary coefficient self.__curr_img = min((-1) * int(math.log(k, self.__reduction)), len(self.__pyramid) - 1) self.__scale = k * math.pow(self.__reduction, max(0, self.__curr_img)) # self.canvas.scale('all', x, y, scale, scale) # rescale all objects # Redraw some figures before showing image on the screen self.redraw_figures() # method for child classes self.__show_image() def __keystroke(self, event): """ Scrolling with the keyboard. Independent from the language of the keyboard, CapsLock, <Ctrl>+<key>, etc. """ if event.state - self.__previous_state == 4: # means that the Control key is pressed pass # do nothing if Control key is pressed else: self.__previous_state = event.state # remember the last keystroke state # Up, Down, Left, Right keystrokes if event.keycode in [68, 39, 102]: # scroll right, keys 'd' or 'Right' self.__scroll_x('scroll', 1, 'unit', event=event) elif event.keycode in [65, 37, 100]: # scroll left, keys 'a' or 'Left' self.__scroll_x('scroll', -1, 'unit', event=event) elif event.keycode in [87, 38, 104]: # scroll up, keys 'w' or 'Up' self.__scroll_y('scroll', -1, 'unit', event=event) elif event.keycode in [83, 40, 98]: # scroll down, keys 's' or 'Down' self.__scroll_y('scroll', 1, 'unit', event=event) def crop(self, bbox): """ Crop rectangle from the image and return it """ if self.__huge: # image is huge and not totally in RAM band = bbox[3] - bbox[1] # width of the tile band self.__tile[1][3] = band # set the tile height self.__tile[2] = self.__offset + self.imwidth * bbox[1] * 3 # set offset of the band self.__image.close() self.__image = Image.open(self.path) # reopen / reset image self.__image.size = (self.imwidth, band) # set size of the tile band self.__image.tile = [self.__tile] return self.__image.crop((bbox[0], 0, bbox[2], band)) else: # image is totally in RAM return self.__pyramid[0].crop(bbox) def destroy(self): """ ImageFrame destructor """ self.__image.close() map(lambda i: i.close, self.__pyramid) # close all pyramid images del self.__pyramid[:] # delete pyramid list del self.__pyramid # delete pyramid variable self.canvas.destroy() self.__imframe.destroy() class MainWindow(ttk.Frame): """ Main window class """ def __init__(self, mainframe, path): """ Initialize the main Frame """ ttk.Frame.__init__(self, master=mainframe) self.master.title('Advanced Zoom v3.0') self.master.geometry('800x600') # size of the main window self.master.rowconfigure(0, weight=1) # make the CanvasImage widget expandable self.master.columnconfigure(0, weight=1) canvas = CanvasImage(self.master, path) # create widget canvas.grid(row=0, column=0) # show widget filename = './data/img_plg5.png' # place path to your image here #filename = 'd:/Data/yandex_z18_1-1.tif' # huge TIFF file 1.4 GB #filename = 'd:/Data/The_Garden_of_Earthly_Delights_by_Bosch_High_Resolution.jpg' #filename = 'd:/Data/The_Garden_of_Earthly_Delights_by_Bosch_High_Resolution.tif' #filename = 'd:/Data/heic1502a.tif' #filename = 'd:/Data/land_shallow_topo_east.tif' #filename = 'd:/Data/X1D5_B0002594.3FR' app = MainWindow(tk.Tk(), path=filename) app.mainloop()

Answer 2

（问题TITLE并不表示它关注的是位图。我在这里为那些对画布的基本缩放/平移感兴趣并由搜索引擎找到的人添加了答案）

支持缩放（带滚轮）和移动/平移（带左键拖动）的基本机制如下：

from tkinter import ALL, EventType

canvas.bind("<MouseWheel>", do_zoom)
canvas.bind('<ButtonPress-1>', lambda event: canvas.scan_mark(event.x, event.y))
canvas.bind("<B1-Motion>", lambda event: canvas.scan_dragto(event.x, event.y, gain=1))

def do_zoom(event):
    factor = 1.001 ** event.delta
    canvas.scale(ALL, event.x, event.y, factor, factor)

简单扩展：通过查看Ctrl和Shift的状态，分别支持每个轴的缩放，如下所示：

def do_zoom(event):
    factor = 1.001 ** event.delta
    is_shift = event.state & (1 << 0) != 0
    is_ctrl = event.state & (1 << 2) != 0
    canvas.scale(ALL, event.x, event.y, 
                 factor if not is_shift else 1.0, 
                 factor if not is_ctrl else 1.0)

Answer 3

您可以考虑在这种情况下使用地图图块。切片可以特定于缩放级别。根据平移和缩放级别选择切片后，您可以使用Canvas.create_image将它们放置在画布上。

假设您有一些带有坐标和图像的图块类，您可以根据平移，缩放和帧大小选择可见图块。

for tile in visible_tiles(pan_center, frame_dimensions, zoom_level):
    canvas.create_image(tile.x, tile.y, anchor=Tkinter.NW, image=tile.image)

John Sample和Elias Ioup在Tile Mapping Clients一章的Tile-Based Geospatial Information Systems中提供了完整的示例。

Tkinter画布缩放+移动/平移

3 个答案: