如何在已在tkinter画布中平滑绘制的线上重画一条线？

Question

我在Tinter画布中有一些lines ，也有它们的代码。 我想将它们设为红色，但不要同时绘制另一条线（红色线），但是需要花费不同的时间。 例如，对于一条特定的线，该线变为红色应花费3秒钟，而对于另一条线，该红色应花费7秒。 就像在前一条上画了另一条红线。

def activator(self, hexagon, duration_time):
    if not hexagon.is_end:

        self.canvas.itemconfigure(hexagon.drawn, fill="tomato")
        self.canvas.itemconfigure(hexagon.hex_aspects.outputs.drawn, fill="tomato")

例如，我希望通过tinter的createpolygon方法创建的六边形变为红色，但不能立即变为红色。 它应该对第二个变量duration_time进行处理。 我的意思是应该在duration_time秒（比如说3秒）内完成。 有什么办法吗？ 我的画布中有很多物体，它们在特定时间会变红。 线，圆，多边形

Answer 1

tk.canvas上的一条线由start和end定义； 为了访问线上的点，我们需要首先创建仿射线，方法是首先在线上的某个间隔生成多个点，然后将其与线段连接。

该仿射线是在画布上单击某个项目时创建的，但最初是隐藏的，并在很短的时间间隔内逐渐显示出来。

重绘完成后，仿射线再次被隐藏，并且要重绘的项目设置为其新颜色。

这种“简单”的重绘需要相当多的机器来实现。 您可以通过单击一行以重绘它来进行尝试，并查看重绘的动画。

码：

import random
import tkinter as tk


WIDTH, HEIGHT = 500, 500


class AffinePoint:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return AffinePoint(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return AffinePoint(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return AffinePoint(self.x * scalar, self.y * scalar)

    def __iter__(self):
        yield self.x
        yield self.y

    def draw(self, canvas):
        offset = AffinePoint(2, 2)
        return canvas.create_oval(*(self + offset), *self - offset, fill='', outline='black')


def create_affine_points(canvas, num_points):
    """sanity check"""
    for _ in range(num_points):
        AffinePoint(random.randrange(0, WIDTH), random.randrange(0, HEIGHT)).draw(canvas)


class AffineLineSegment:

    def __init__(self, start, end, num_t=100):
        self.start = AffinePoint(*start)
        self.end = AffinePoint(*end)
        self.num_t = num_t
        self.points = []
        self._make_points()
        self.segments = []

    def _make_points(self):
        for _t in range(self.num_t):
            t = _t / self.num_t
            self.points.append(self.start + (self.end - self.start) * t)

    def __iter__(self):
        for point in self.points:
            yield point

    def draw(self, canvas):
        for p0, p1 in zip(self.points[:-1], self.points[1:]):
            self.segments.append(canvas.create_line(*p0, *p1, width=5, state='hidden', fill='red'))

    def hide(self, canvas):
        for seg in self.segments:
            canvas.itemconfigure(seg, state='hidden')


def create_affine_line(canvas, num_lines):
    """sanity check"""
    for _ in range(num_lines):
        start = random.randrange(0, WIDTH), random.randrange(0, HEIGHT)
        end = random.randrange(0, WIDTH), random.randrange(0, HEIGHT)
        AffineLineSegment(start, end).draw(canvas)


def select_and_redraw(event):
    item = canvas.find_closest(event.x, event.y)[0]
    x0, y0, x1, y1 = canvas.coords(item)
    canvas.itemconfigure(item, fill='grey25')
    canvas.itemconfigure(item, width=1)
    a = AffineLineSegment((x0, y0), (x1, y1))
    a.draw(canvas)
    gen = (segment for segment in a.segments)
    redraw(gen, a, item)


def redraw(gen, a, item):
    try:
        segment = next(gen)
        canvas.itemconfigure(segment, state='normal')
        root.after(10, redraw, gen, a, item)
    except StopIteration:
        a.hide(canvas)
        canvas.itemconfigure(item, state='normal')
        canvas.itemconfigure(item, fill='red')
        canvas.itemconfigure(item, width=3)
    finally:
        root.after_cancel(redraw)


root = tk.Tk()

canvas = tk.Canvas(root, width=WIDTH, height=HEIGHT, bg="cyan")
canvas.pack()

canvas.bind('<ButtonPress-1>', select_and_redraw)

# sanity checks
# create_affine_points(canvas, 500)
# create_affine_line(canvas, 100)

for _ in range(10):
    start = random.randrange(0, WIDTH), random.randrange(0, HEIGHT)
    end = random.randrange(0, WIDTH), random.randrange(0, HEIGHT)    
    canvas.create_line(*start, * end, activefill='blue', fill='black', width=3)

root.mainloop()

---

该屏幕截图显示了正在重绘过程​​中的一行

Answer 2

试试这个

from tkinter import *
import numpy as np

root = Tk()


def lighter(color, percent):
    color = np.array(color)
    white = np.array([255, 255, 255])
    vector = white-color
    return tuple(color + vector * percent)


def Fade(line, start_rgb, percentage, times, delay):
    '''assumes color is rgb between (0, 0, 0) and (255, 255, 255) adn percentage a value between 0.0 and 1.0'''
    new_color = lighter(start_rgb, percentage)
    red, blue, green = new_color
    red = int(red)
    blue = int(blue)
    green = int(green)
    new_hex = '#%02x%02x%02x' % (red, blue, green)

    canvas.itemconfigure(line, fill=new_hex)
    if times > 0:
        root.after(delay, lambda: Fade(line, new_color, percentage, times - 1, delay))


canvas = Canvas(root, bg="black")
canvas.pack()

line = canvas.create_line(0, 0, 100, 100, width=10)
Fade(line, (0, 0, 50), 0.01, 1000, 10)
root.mainloop()