Exercises — Animation — FuncAnimation

update function update har frame pe ek baar run hota hai. frames=200 ke saath yeh ek pass mein 200 baar run hota hai (frames numbered 0 to 199). Kyun: FuncAnimation timer ka malik hai; har timer tick = ek update(frame) call = ek redraw.

$\text{FPS}=\frac{1000\text{ms/s}}{40\text{ms/frame}}=25\text{FPS}$ Division kyun: har frame interval milliseconds cost karta hai, aur ek second mein 1000 ms hote hain, isliye 1000/40 frames ek second mein fit hote hain.

Changed artists ka iterable, jaise return line, (ek 1-tuple). Kyun: blitting sirf uss artists ko hi redraw karta hai jo tum return karte ho; use batana padta hai kya badla.

$T=N\cdot \text{interval}=150\times 20\text{ms}=3000\text{ms}=3\text{s}$ Kyun: time-per-frame × number-of-frames = ek pass ka total wall-clock time.

FPS formula ko invert karo: $\text{interval}=\frac{1000}{\text{FPS}}=\frac{1000}{30}\approx 33.33\text{ms}$ Tumhe ek integer pass karna hai, isliye interval=33 use karo. Yeh $1000/33\approx 30.3$ FPS deta hai — close hai, par exact nahi. (Exact 30 FPS ke liye jab saving karo, to save ko fps=30 pass karo, jo interval ko ignore karta hai.)

def update(i):
    dot.set_data([x[i]], [np.sin(x[i])])   # lists, because set_data wants sequences
    return dot,

Brackets [x[i]] kyun: set_data dono x aur y ke liye sequences (arrays/lists) expect karta hai, chahe ek hi point ho. Bare scalar x[i] raise ya misbehave kar sakta hai. return dot, kyun: trailing comma ek 1-tuple banata hai — woh iterable jo blit ko chahiye.

Cause: FuncAnimation(...) ek variable mein store nahi hai. Jab make() return karta hai, Python ke paas animation object ka koi live reference nahi hai, isliye woh garbage-collected ho jaata hai; uska timer mar jaata hai aur frames ruk jaate hain. Fix: ek reference alive rakho:

anim = FuncAnimation(fig, update, frames=100, interval=30, blit=True)
plt.show()   # anim stays alive for the whole show()

Reference kyun matter karta hai: woh timer jo frames drive karta hai animation object ke andar rehta hai. Koi object nahi → koi timer nahi → koi frames nahi.

Cause: ax.plot har frame pe ek naya Line2D artist add karta hai. Purane lines kabhi remove nahi hote → axes mein saikadon lines accumulate ho jaate hain (memory badhti hai), aur blit nahi bata sakta kya actually "badla." Fix: line ko ek baar update ke bahar banao, phir sirf isko mutate karo:

line, = ax.plot([], [])          # created ONCE
def update(frame):
    line.set_data(x, np.sin(x - 0.1*frame))   # mutate, don't add
    return line,

Blitting ka poora point yahi hai: cost "har artist jo kabhi bhi add hua use redraw karo" se gir ke "ek moving line ko redraw karo" ho jaati hai.

Cause: blit=True ke saath, matplotlib exactly wohi redraw karta hai jo tum return karte ho. Tumne sirf line, return kiya, isliye dot kabhi re-blitted nahi hota — woh stuck lagta hai. Fix: saare changed artists return karo:

return line, dot

Kyun: blit ka contract hai "main precisely is iterable ko repaint karunga." Koi artist bhool jao aur woh screen pe update nahi hoga.

def frame_gen():
    t = 0.0
    while t < 6.28:
        yield t
        t += 0.04
 
def update(t):
    line.set_data(x, np.sin(x - t))
    return line,
 
anim = FuncAnimation(fig, update, frames=frame_gen,
                     init_func=init, interval=20, blit=True,
                     save_count=157)
anim.save("wave.mp4", fps=50)

Kitne frames? Values $0,0.04,0.08,\dots$ count karo jo $6.28$ se strictly kam hain. Steps ki sankhya hai $\lceil \frac{6.28}{0.04}\rceil =\lceil 157\rceil =157\text{frames}.$ Kyunki $157\times 0.04=6.28$ strictly $6.28$ se kam nahi hai, last emitted value step $156$ pe hai (value $6.24$), indices $\mathrm{0..156}$ = 157 frames deta hai. save_count kyun: ek generator ki unknown length hoti hai; jab saving karo, matplotlib ko pata hona chahiye kitne frames pull karne hain. save_count ise cap karta hai — ise true frame count pe set karo taaki kuch drop ya pad na ho.

Live FPS $1000/25=40$ hai. Speed match karne ke liye ==fps=40== se save karo. $\text{live FPS}=\frac{1000}{\text{interval}}=\frac{1000}{25}=40$ Agar tum fps=50 se save karo: same number of frames ab $40$ ki jagah $50$ per second play hote hain, isliye video $50/40=1.25\times$ faster hai (chhoti duration). Dono alag kyun ho sakte hain: interval sirf live GUI timer control karta hai; save(fps=...) same frames ko $1/\text{fps}$ seconds each pe re-space karta hai, interval ko bilkul ignore karta hai.

(a) Ek live pass: $T_{\text{live}}=N\cdot \text{interval}=90\times 40\text{ms}=3600\text{ms}=3.6\text{s}$ (b) Nahi. repeat sirf live preview ko loop karta hai. Saving har frame ko ek baar capture karta hai (save_count tak), isliye file mein repeat ke baad bhi ek hi pass hota hai. (c) Saved video: $T_{\text{save}}=\frac{N}{\text{fps}}=\frac{90}{30}=3\text{s}$ (a) ≠ (c) kyun: live spacing $40$ ms/frame hai (⇒ 25 FPS effective), lekin file $1/30$ s/frame pe spaced hai. Same 90 frames, alag playback rate ⇒ alag duration.

(a) Agar static scene ka koi hissa change hota hai (jaise tum title ya tick labels ya axis limits update ke andar update karte ho), blit use repaint nahi karega: blit background bitmap ko ek baar cache karta hai aur sirf returned artists ko re-blit karta hai. Title/ticks cached background mein hote hain, isliye woh frozen lagte hain ya smears chhodh dete hain. (Fix: blit ke under background elements animate mat karo, ya unhe bhi return karo / blit disable karo.) (b) init_func clean "frame-before-0" state draw karta hai. Blit ke under, yeh woh frame hai jise matplotlib reusable background bitmap ke roop mein capture karta hai. Ise omit karo aur pehla cached background leftover/empty artist state include kar sakta hai, ghosting ya blank first frame cause karte hue. Yeh repeat ke liye ek well-defined starting picture bhi guarantee karta hai. Yeh deep rule kyun hai: blit ki speed background ko freeze karne se aati hai. Jo kuch bhi tum move karna chahte ho use (i) returned artist hona chahiye aur (ii) us frozen background ke upar rehna chahiye.

Last frame i = 50 hai (kyunki range(0,51) = 0..50). Phir x[:50] indices 0..49 leta hai → 50 points, sabse bada x = x[49]. 51 points $[0,1]$ pe evenly: spacing $=1/50=0.02$, isliye $x[49]=49\times 0.02=\mathrm{0.98.}$ $x[50]=1.0$ kyun nahi: x[:i] with i=50 ek half-open slice hai — yeh index 50 ko exclude karta hai. Final point $1.0$ kabhi appear nahi hota jab tak tum i=51 allow nahi karte (ya x[:i+1] slice nahi karte).