Taak 2: Frames verwerken terwijl je vliegt

Frames analyseren doe je in stappen: verklein eerst, haalt dan statistieken.

1. Resizen (720×960 → 360×240)

img_small = cv2.resize(img, (360, 240))

720 × 960 is 691.200 pixels, 360 × 240 is 86.400 pixels: 8x minder pixels, dus ongeveer 8x minder rekenwerk.

2. Helderheid (gemiddelde)

brightness = img_small.mean()

Getal: 0 (zwart) tot 255 (wit).

3. Contrast (bereik)

contrast = img_small.max() - img_small.min()

Getal: 0 (eenkleur) tot 255 (veel verschil).

4. Per kleurkanaal (RGB)

blue_avg = img[:, :, 0].mean()
red_avg = img[:, :, 2].mean()

Index 0=Blue, 1=Green, 2=Red.

5. Beweging (frame-verschil)

diff = cv2.absdiff(frame1, frame2)
motion = diff.mean()  # 0 = stilstand, 255 = chaos

Vergelijken twee frames → beweging.

Analyse draait op drie voeten: snelheid, nauwkeurigheid, en complexiteit. Je mag nooit alle drie hebben.

Resizing: interpolatie-methoden

Als je van 720×960 naar 360×240 gaat, moet je pixels samenvoegen. Verschillende manieren:

Bilineair (standaard): Vloei pixels samen. Snel, goed genoeg.

Nearest-neighbor: Pak de dichtstbijzijnde pixel. Sneller, maar blokkerig.

Cubic/Lanczos: Ingewikkelder wiskundig. Betere kwaliteit, trager.

Voor real-time: bilineair is je beste vriend.

Statistieken: wat meten?

Helderheid (brightness): Gemiddelde pixelwaarde over heel het frame. Bereik: 0 (zwart) tot 255 (wit).

Contrast: max(pixels) - min(pixels). Bereik: 0 (eenkleur) tot 255 (extreem bereik).

Per-kanaal: Gemiddelde rood, groen, blauw apart. Nuttig voor kleur-detectie.

Dit zijn allemaal NumPy-operaties. Je kunt er miljoenen van doen per seconde.

Bewegingsdetectie: het concept

Je slaat frame N-1 op. Je haalt frame N op. Je trekt één van de ander af (element-wise):

verschil = frame_N minus frame_N_minus_1

Waar pixels gelijk zijn, is het verschil 0. Waar ze anders zijn, is het verschil > 0.

Gemiddelde van alle verschillen = "hoe veel is er veranderd?"

Dit geeft je een getal tussen 0 (statisch) en 255 (chaos).

Principe 1: Resizing — snelheid vs detail

720×960 = veel pixels. 360×240 = 8x minder. Trade-off: sneller, maar minder detail.

img_small = cv2.resize(img, (360, 240))

360×240 is sweet spot: snel genoeg, maar je ziet nog wat er gebeurt.

Principe 2: Statistieken — veel detail in één getal

Je kunt niet alle pixels checken (te traag). In plaats daarvan: één getal dat het hele frame samenvat.

brightness = img.mean()  # Alle pixels → één getal

Dit is abstractie: detail weg, maar snel.

Principe 3: Beweging is VERSCHIL (twee frames)

Beweging bestaat niet in ÉÉN frame. Het is het verschil TUSSEN frames.

diff = cv2.absdiff(frame1, frame2)
motion = diff.mean()  # Hoe veel is veranderd?

Daarom moet je het vorige frame onthouden, met .copy() — anders wijst je variabele naar hetzelfde frame dat meteen weer overschreven wordt.

Principe 4: NumPy-operaties zijn snel

Python-loop (miljoenen iteraties) = traag. NumPy (C-gecompileerd) = snel.

brightness = img.mean()  # C-code, niet Python-loop

Daarom gebruik je .mean(), .min() en .max() op een frame, en geen eigen lus over alle pixels.

Principe 5: Selectieve analyse — je hoeft niet alles

Elk frame analyseren? Traag. Elk 5e frame? Vijf keer minder werk, en bij 30 frames per seconde mis je minder dan je denkt.

if frame_nr % 5 == 0:
    brightness = img.mean()

Het risico: je mist wat er precies tussen twee geanalyseerde frames gebeurt. Voor helderheid is dat geen probleem; voor snelle beweging soms wel.

Principe 6: Trade-off denken

Alles in real-time analyseren = traag. Bijna niks = blind. De kunst: juiste balans.

Voorbeeld:

# Traag: elk frame analyseren
brightness = img.mean()

# Sneller: elk 5e frame
if frame_nr % 5 == 0:
    brightness = img.mean()

# Compromis: resize EERST, daarna analyseren
img_small = cv2.resize(img, (360, 240))  # 8x minder pixels
brightness = img_small.mean()  # Nu veel sneller

Dit is design-thinking: keuzes maken onder beperkingen.

Principe 7: Frame-rate als diagnostiek

Hoeveel frames per seconde? Dit getal zegt: gaat je code snel genoeg?

start = time.time()
frame_count = 0

for frame_nr in range(300):
    frame_count = frame_count + 1
    if frame_count == 100:
        elapsed = time.time() - start
        fps = 100 / elapsed
        print(f"FPS: {fps:.1f}")  # Bijv. 28 FPS = bijna goed (30 FPS ideaal)

Geen vaste waarde — hangt af van computer en analyse.