Question

I’m trying to animate smooth motion between two points on the screen. At the moment, I am using the following python generator function to determine the point at which to draw the image:

#indexes (just for readability)
X=0
Y=1

def followLine(pointA, pointB, speed):
    x1, y1 = pointA
    x2, y2 = pointB
    movement=[0, 0]
    pos=list(pointA)
    diffY=y2-y1
    diffX=x2-x1
    if abs(diffY) > abs(diffX):
        #Y distance is greater than x distace
        movement[Y]=speed
        numFrames=abs(diffY)//speed
        if numFrames==0:
            movement[X]=0
        else:
            movement[X]=abs(diffX)//numFrames
    elif abs(diffY) < abs(diffX):
        #Y distance is less than x distace
        movement[X]=speed
        numFrames=abs(diffX)//speed
        if numFrames==0:
            movement[Y]=0
        else:
            movement[Y]=abs(diffY)//numFrames
    else: #Equal
        movement=[speed]*2

    if diffY < 0:
        #is negative
        movement[Y] *= -1
    if diffX < 0:
        movement[X] *= -1

    yield pointA
    while (abs(pos[X]-x2) > speed)or(abs(pos[Y]-y2) > speed):
        pos[X] += movement[X]
        pos[Y] += movement[Y]
        yield pos
    yield pointB

However, this has 2 problems:

• First, my main concern is that if pointA and pointB are very far apart, or if the speed is too low, the animation will pass right by pointB, and will keep going for infinity;

• The other problem is that, at the end of the animation, there is a sort of jolt as the image snaps into place. This jolt is usually fairly imperceptible, but I’d like to try and make the animation smoother.

How can I do this? I’ve been looking into the use of trig functions and that seems promising, but I’m not much of a math person, so I’m having trouble understanding exactly how I might implement it using trig.

Also, for what it’s worth I’m using Python 3.2.

Answer 1

There’s missing information, I think. Seems like you need to either substitute a numFrames arg for speed, or add a time arg in addition to speed. Assuming the former, how about this. Note this generates numFrames+1 points so that pointA and pointB are always the first and last point, respectively, but that’s trivial to change if that’s not the behavior you want:

def followLine(pointA, pointB, numFrames):
    x1, y1 = pointA
    x2, y2 = pointB
    diffY = float(y2 - y1) /    numFrames
    diffX = float(x2 - x1) /    numFrames

    yield(pointA)
    for f in range(1,numFrames):
    point = (x1 + f * diffX, y1 + f * diffY)
        yield(point)
    yield(pointB)

points = followLine((0,0), (1,1), 10)

# then iterate over the points and do whatever                                                                                                
for p in points:
    print str(p)