Visual walkthrough — Animation — FuncAnimation

5.4.18 · D2 · Coding › Scientific Computing (Python) › Animation — FuncAnimation

Shuru karne se pehle, teen saadhe words jo hum constantly use karenge. Hum inhe Step 1 ki picture mein anchor karte hain, lekin yahan one-liners hain:

• Figure — poori rectangular drawing surface (kaagaz ki sheet). Dekho Matplotlib Figure and Axes.
• Artist — koi bhi ek cheez jo us surface par draw ki gayi ho: ek line, ek dot, ek tick mark, ek label. Moving curve ek artist hai. Dekho Artists in Matplotlib.
• Frame — slideshow mein ek still picture, numbered $0,1,2,\dots$

Step 1 — The stage: ek Figure, ek baar draw ki gayi

KYA. Hum fixed edges ke saath ek blank sheet set up karte hain aur fixed $x$ samples rakhte hain. Abhi kuch move nahi karta.

KYUN. Ek movie almost identical pictures ka stack hoti hai. Agar axis limits, ticks, aur grid har frame mein change hote, to har frame ek alag picture hoti aur reuse karne ke liye kuch nahi hota. To sabse pehla kaam hai stage ko freeze karna — $x$ aur $y$ limits ek baar set karo — taaki sirf hamaari moving line ke alawa sab kuch pixel-for-pixel identical rahe frame se frame tak. Hum x array bhi abhi banate hain — 400 horizontal sample positions ka — kyunki yeh frames ke across kabhi nahi badlata.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
 
fig, ax = plt.subplots()
ax.set_xlim(0, 2*np.pi)          # stage edges ONCE freeze karo
ax.set_ylim(-1.1, 1.1)
x = np.linspace(0, 2*np.pi, 400) # 400 fixed horizontal sample points

• x = np.linspace(0, 2*np.pi, 400) — $0$ se $2\pi$ tak 400 evenly spaced numbers; yeh woh horizontal positions hain jahan hum wave evaluate karte hain har frame mein. `np.linspace` se banaya gaya aur kabhi nahi banaya jaata dobara.

PICTURE. Neeche: cream stage, jiske edges $x\in [0,2\pi ]$ aur $y\in [-1.1,1.1]$ par freeze hain. Teal box woh region hai jo kabhi nahi badlega. Woh frozen region hi poori speed trick ki key hai.

Step 2 — Ek artist, ek baar banaya gaya aur khali chhoda gaya

KYA. Hum stage par ek single line artist add karte hain, lekin use abhi koi data nahi dete.

KYUN. Yeh parent note ke [!mistake] callout ka dil hai. Agar hum ax.plot(x, y) loop ke andar call karte, to har frame ek brand-new line manufacture karta aur use stage par staple kar deta — purani kabhi nahi jaati. 200 frames ke baad aapke paas 200 lines pile up ho jaati hain. Iske badle hum ek line object abhi banate hain aur, har frame mein, sirf woh data change karte hain jis par woh point karti hai. Same object, naye numbers.

Neeche ki line (burnt orange) empty data ke saath draw ki gayi hai — to yeh invisible hai, lekin yeh exist karti hai. Ise ek empty picture frame ki tarah socho jo wall par laga hai, kisi photo ka intezaar kar raha hai.

$\text{line, = ax.plot([], [], lw=2)}$

• [], [] — empty $x$ list, empty $y$ list → line mein koi points nahi hain abhi, to kuch show nahi hota.
• lw=2 — line width, purely cosmetic.
• line, mein trailing comma — ax.plot hamesha lines ki ek list return karta hai; line, us list se single element unpack karta hai. Comma ke bina, line list hogi, line nahi, aur line.set_data(...) explode kar dega.

Step 3 — init_func: empty stage ki photograph lo

KYA. init_func frame 0 se pehle run hota hai. Yeh line ka data clear karta hai aur changed artist wapas deta hai.

KYUN do reasons. Pehla, yeh define karta hai "move hone se pehle duniya kaisi dikhti hai" — ek clean slate. Doosra, aur yeh deeper hai: jab blit=True hota hai, matplotlib is moment ko use karta hai frozen background ka (Step 1 ka teal box) snapshot lene ke liye aur use memory mein raw bitmap ke roop mein store karne ke liye. Woh snapshot ek baar liya jaata hai aur har single frame ke liye reuse hota hai.

def init():
    line.set_data([], [])   # clean slate
    return line,            # blit ko batao: yeh woh artist hai jise maine touch kiya

• line.set_data([], []) — line ko phir empty karo, guarantee karo ki frame $-1$ blank hai.
• return line, — artists ka 1-tuple. Blit ko jaanna chahiye kaun se artists use manage karne hain. Comma (line) ko (line,) banana hai, ek tuple; return line (bina comma ke) ek bare line return karta hai aur blit use iterate nahi kar sakta.

PICTURE. Camera icon = matplotlib background ko memory buffer mein copy kar raha hai. Yeh copy woh investment hai jo hum har frame mein cash karte hain.

Step 4 — update(frame): same line ko slide karo

KYA. Frame number $n$ ke liye, hum naye $y$-values compute karte hain aur unhe set_data se existing line mein daal dete hain. Hum kuch create nahi karte.

KYUN. Yeh parent ke flip-book analogy ka "rubber stamp" hai. Ek function frame $n$ ko describe karta hai; robot use $n=0,1,2,\dots$ ke liye call karta hai. Shift $-0.1n$ wave ko har frame mein thoda aur right slide karta hai.

$y=\sin (x-0.1n)$

• $x$ — woh fixed 400 sample points jo hum Step 1 mein banaye (kabhi nahi badlata).
• $n$ — frame number, hamaari clock.
• $-0.1n$ — phase shift. Ise badhane se poori curve right slide hoti hai. $n=0$ par wave apni starting position par hoti hai; $n=63$ ke paas yeh almost ek full period slide ho chuki hai (kyunki $0.1\times 63=6.3\approx 2\pi$).
• $\sin (\cdot )$ — har shifted input ko $-1$ aur $1$ ke beech ki height mein convert karta hai, isliye $y$-limits Step 1 mein $\pm 1.1$ the.

def update(n):
    y = np.sin(x - 0.1*n)
    line.set_data(x, y)   # ek line ko MUTATE karo
    return line,          # blit ko changed artist do

PICTURE. Same orange line ke teen frozen snapshots $n=0,20,40$ par. Dhyan do: identical stage, sirf curve ka data badla.

Step 5 — Blitting asal mein har frame mein kya karta hai (the payoff)

KYA. Har frame ke liye, blit=True exactly teen saste operations karta hai.

KYUN. Poora axes redraw karne ka matlab hai ticks, grid, labels, spines ko re-rasterise karna — hundreds of little artists — har 20 ms mein. Yeh wasteful hai kyunki yeh kabhi nahi badlate. Blitting "redraw everything" ko replace karta hai:

1. Restore saved background bitmap (ek fast memory copy).
2. Draw sirf woh artists jo update ne return kiye (sirf hamaari ek line).
3. Blit (copy) woh chhota patch screen par.

PICTURE. Left column = expensive path (poora stage redraw karo). Right column = blit path (background paste karo, phir sirf line draw karo). Right path far fewer pixels ka kaam karta hai.

Step 6 — The stopwatch: interval ko motion mein badalna

KYA. GUI event loop ke paas ek timer hai. Har interval milliseconds mein woh fire karta hai aur next frame maangta hai.

KYUN. Hum loop mein sleep() nahi kar sakte — yeh window freeze kar dega. Iske badle timer ek background alarm clock hai: "mujhe interval ms mein jagao, phir update ek baar call karo, phir re-arm karo." Alarms ke beech window responsive rehti hai (aap use drag, resize kar sakte ho).

$\text{FPS}=\frac{1000\text{ms/s}}{\text{interval}\text{ms/frame}},T_{\text{one pass}}=N\cdot \text{interval}\text{ms}$

• $1000$ — ek second mein milliseconds.
• interval — woh gap jitna timer wait karta hai. Chhota gap → zyada frames per second → smooth, fast motion.
• $N$ — ek pass mein total frames, wahi $N$ Step 5 ki cost formula se. Per-frame gap se multiply karo total wall-clock time paane ke liye.

Worked numbers. interval=20 ke saath: $\text{FPS}=1000/20=50$. $N=200$ frames ke liye: $T=200\times 20=4000$ ms $=4$ s per pass.

PICTURE. interval se spaced alarm ticks ki timeline; har tick exactly ek update call trigger karta hai.

Step 6b — Machine assemble karna: FuncAnimation call

KYA. Hum saare pieces — figure, update function, kitne frames, timer gap, init snapshot, aur blit — FuncAnimation ko dete hain, aur hum result store karte hain.

KYUN. Upar sab kuch parts define karta tha; yeh single call unhe wire karta hai aur timer start karta hai. Critically, hum ise anim mein assign karte hain taaki Python object (aur uska timer) alive rakhe.

anim = FuncAnimation(
    fig,               # kaun sa Figure redraw karna hai (Step 1)
    update,            # per-frame rubber stamp (Step 4)
    frames=200,        # N = 200  -> frames n = 0,1,...,199  (cost/timing formulas mein N)
    init_func=init,    # background snapshot (Step 3)
    interval=20,       # timer gap ms mein -> 1000/20 = 50 FPS (Step 6)
    blit=True,         # background paste karo + sirf returned artists draw karo (Step 5)
)
plt.show()             # control GUI event loop ko do; timer ab fire karta hai
# anim.save("wave.mp4", fps=50)   # optional export, dekho Saving figures and ffmpeg

• frames=200 — yahan $N$ enter karta hai. Ek integer $N$ ka matlab frames $0\dots N-1$ hain; aap ise choose karte ho, aur yeh $T=N\cdot \text{interval}$ aur cost formulas mein flow karta hai. (Iske badle ek generator yahan ja sakta hai — parent ke Worked Example 2 dekho.)
• anim = ... — woh reference jo animation ko garbage-collected hone se bachata hai (Step 7, Case A dekho).

Step 7 — Degenerate & edge cases (the traps)

KYA. Woh cases jahan machine broken lagti hai.

KYUN. Aapko kabhi aisa scenario nahi hit karna chahiye jo walkthrough ne nahi dikhaya. Teen tarike jisme loop mar jaata hai:

PICTURE. Teen mini-panels, ek per failure, har ek symptom dikhata hai (blank / ek frozen artist / frame count par question mark).

The one-picture summary

Upar sab kuch, compressed: once column (stage + x banao, line banao, background snapshot lo) per-frame loop ko feed karta hai (timer fires → update line mutate karta hai → blit restore + draw + copy karta hai) — stored anim reference ke saath jo poore timer ko alive rakhta hai.

Active recall

Connections

• Animation — FuncAnimation — parent topic jisse yeh page pictures mein derive karta hai.
• Matplotlib Figure and Axes — Step 1 ka frozen stage.
• Artists in Matplotlib — woh single Line2D jo hum mutate karte hain.
• Generators in Python — edge Case C mein frames source.
• Event Loops / GUI backends — Step 6 ka timer.
• NumPy linspace and broadcasting — fixed x samples banata hai.
• Saving figures and ffmpeg — woh save path jise save_count chahiye.