如何在Python中慢慢画一条线

Question

我想在python中慢慢画一条线，这样画的动作就可以肉眼看到了。

我试着把它放在一个循环中，每次都增加距离，但我从来没有成功过。事情是什么都不会出现 3 秒，然后整行会出现，这与我想要完成的相反。我的pygame.display.delay() 函数也没有成功。唯一可行的方法是将clock.tick 设置为一些糟糕的值，例如clock.tick(300000)，但这只会让整个程序变得非常滞后。

def draw_red_line(i):
    y = 0
    while y < 300:
        pygame.draw.line(screen, RED, (i*100+50, 0), (i*100+50, y))
        y+=0.01

Answer 1

在这种情况下使用睡眠不是一个好主意，因为它会减慢整个线程（这是单线程模型中的整个程序）。

最好保留有关线路的某种状态信息，并根据实时时间（例如：经过的毫秒数）逐秒推进线路的“增长”。

这意味着需要将线分割成线段，最小的线段是单个像素。使用Midpoint Line Algorithm 是确定位于一条线上的所有像素的有效方法。一旦确定了所有“线路部分”，就可以根据经过的时间简单地更新线路的终点。

这是我之前写的一些代码，给定一对点，返回一个像素列表。

midpoint.py:

def __plotLineLow( x0,y0, x1,y1 ):
    points = []
    dx = x1 - x0
    dy = y1 - y0
    yi = 1
    if dy < 0:
        yi = -1
        dy = -dy
    D = 2*dy - dx
    y = y0

    for x in range( x0, x1 ):
        points.append( (x,y) )
        if D > 0:
           y = y + yi
           D = D - 2*dx
        D = D + 2*dy
    return points

def __plotLineHigh( x0,y0, x1,y1 ):
    points = []
    dx = x1 - x0
    dy = y1 - y0
    xi = 1
    if dx < 0:
        xi = -1
        dx = -dx
    D = 2*dx - dy
    x = x0

    for y in range( y0, y1 ):
        points.append( (x,y) )
        if D > 0:
            x = x + xi
            D = D - 2*dy
        D = D + 2*dx
    return points

def linePoints( pointA, pointB ):
    """ Generate a list of integer points on the line pointA -> pointB """
    x0, y0 = pointA
    x1, y1 = pointB
    points = []
    if ( abs(y1 - y0) < abs(x1 - x0) ):
        if ( x0 > x1 ):
            points += __plotLineLow( x1, y1, x0, y0 )
        else:
            points += __plotLineLow( x0, y0, x1, y1 )
    else:
        if ( y0 > y1 ):
            points += __plotLineHigh( x1, y1, x0, y0 )
        else:
            points += __plotLineHigh( x0, y0, x1, y1 )

    return points


if __name__ == "__main__":
    #midPoint( (597, 337), (553, 337) )
    print( str( linePoints( (135, 295), (135, 304) ) ) )

还有一些实现SlowLine 类的演示代码。

import pygame
import random
import time
import sys

from midpoint import linePoints  # Midpoint line algorithm

# Window size
WINDOW_WIDTH      = 400
WINDOW_HEIGHT     = 400

SKY_BLUE = ( 30,  30,  30)
SKY_RED  = (200, 212,  14)

# Global millisecond count since start
NOW_MS = 0

class SlowLine():
    def __init__( self, pixels_per_second, x0,y0, x1,y1, colour=SKY_RED ):
        self.points       = linePoints( ( x0, y0 ), ( x1, y1 ) )
        self.pixel_count  = len( self.points )
        self.speed        = pixels_per_second
        self.start_point  = self.points[0]     # start with a single-pixel line
        self.end_point    = self.points[0]
        self.pixel_cursor = 0                  # The current end-pixel
        self.last_update  = 0                  # Last time we updated
        self.colour       = colour
        self.fully_drawn  = False

    def update(self):
        global NOW_MS

        if ( self.fully_drawn == True ):
            # nothing to do
            pass
        else:
            # How many milliseconds since the last update() call?
            if ( self.last_update == 0 ):
                self.last_update = NOW_MS
                time_delta = 0
            else:
                time_delta = NOW_MS - self.last_update
                self.last_udpate = NOW_MS

            # New pixels to add => speed * time
            new_pixel_count = time_delta * self.speed / 1000   # this may loose precision with very small speeds

            if ( new_pixel_count + self.pixel_cursor > self.pixel_count ):
                # We're out of pixels
                self.end_point  = self.points[-1]   
                self.full_drawn = True
            else:
                # Grow the line by <new_pixel_count> pixels
                self.pixel_cursor += new_pixel_count
                self.end_point     = self.points[ int( self.pixel_cursor ) ]

    def draw( self, screen ):
        pygame.draw.line( screen, self.colour, self.start_point, self.end_point )




### MAIN
pygame.init()
SURFACE = pygame.HWSURFACE|pygame.DOUBLEBUF|pygame.RESIZABLE
WINDOW  = pygame.display.set_mode( ( WINDOW_WIDTH, WINDOW_HEIGHT ), SURFACE )
pygame.display.set_caption("Slow Line Movement")


# Create some random lines
lines = []
for i in range( 20 ):
    rand_speed = random.randint( 1, 50 )
    rand_x0    = random.randint( 0, WINDOW_WIDTH )
    rand_y0    = random.randint( 0, WINDOW_HEIGHT )
    rand_x1    = random.randint( 0, WINDOW_WIDTH )
    rand_y1    = random.randint( 0, WINDOW_HEIGHT )
    lines.append( SlowLine( rand_speed, rand_x0, rand_y0, rand_x1, rand_y1 ) )


# Main event loop
clock = pygame.time.Clock()
done = False
while not done:
    NOW_MS = pygame.time.get_ticks()

    # Update the line lengths
    for l in lines:
        l.update()

    # Handle user-input
    for event in pygame.event.get():
        if ( event.type == pygame.QUIT ):
            done = True

    # Movement keys
    keys = pygame.key.get_pressed()
    if ( keys[pygame.K_UP] ):
        print("up")
    elif ( keys[pygame.K_DOWN] ):
        print("down")
    elif ( keys[pygame.K_LEFT] ):
        print("left")
    elif ( keys[pygame.K_RIGHT] ):
        print("right")
    elif ( keys[pygame.K_q] and ( keys[pygame.K_RCTRL] or keys[pygame.K_LCTRL] ) ):
        print("^Q")
        done = True

    # Update the window, but not more than 60fps
    WINDOW.fill( SKY_BLUE )
    for l in lines:
        l.draw( WINDOW )

    pygame.display.flip()

    # Clamp FPS
    clock.tick_busy_loop(60)

pygame.quit()

在这个动画中，进度有点生涩，但那是动画，而不是演示。

Answer 2

你必须display.flip()更新显示和让窗口事件使用event.get()处理：

def draw_red_line(i):
    y = 0
    while y < 300:
        pygame.draw.line(screen, RED, (i*100+50, 0), (i*100+50, y))
        pygame.display.flip()
        pygame.event.get()
        y+=1

Answer 3

如果您想让绘图在屏幕上可见，您必须更新显示（例如pygame.display.flip()），并且您必须通过pygame.event.get() 或pygame.event.pump() 处理事件。
另请注意，pygame.draw.line 的参数必须是整数。使用round 将浮点值转换为整数值。

在循环中绘制线条并刷新显示并不能满足您的要求，因为线条的绘制没有延迟。我不建议在主应用程序循环中的单独循环中创建动画。使用应用程序的主循环画线。

创建一个函数，该函数可以绘制一条从start 点到end 点的线，取决于范围 [0.0, 1.0] 中的值 p。如果值为 0，则不绘制线。如果值为 1，则绘制整条线。否则会画出部分线：

def draw_red_line(surf, color, start, end, w):
    xe = start[0] * (1-w) + end[0] * w
    ye = start[1] * (1-w) + end[1] * w
    pygame.draw.line(surf, color, start, (round(xe), round(ye)))

在主应用循环中使用这个函数：

w = 0
while True:
    # [...]

    draw_red_line(window, (255, 0, 0), line_start[i], line_end[i], w)
    if w < 1:
        w += 0.01

另见Shape and contour

---

小例子：

import pygame

pygame.init()
window = pygame.display.set_mode((300,300))
clock = pygame.time.Clock()

line_start = [(100, 0),   (200, 0),   (0, 100),   (0, 200)]
line_end   = [(100, 300), (200, 300), (300, 100), (300, 200)]

def draw_red_line(surf, color, start, end, w):
    xe = start[0] * (1-w) + end[0] * w
    ye = start[1] * (1-w) + end[1] * w
    pygame.draw.line(surf, color, start, (round(xe), round(ye)))

count=0
run = True
while run:
    clock.tick(60)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False

    window.fill(0)

    for i in range(int(count)):
        draw_red_line(window, (255, 255, 255), line_start[i], line_end[i], 1)
    if count < 4:
        i = int(count)
        draw_red_line(window, (255, 0, 0), line_start[i], line_end[i], count-i)
        count += 0.01
    else:
        count = 0
        
    pygame.display.flip()

pygame.quit()
exit()