Taak 1: waitKey() als dispatcher

In S3 leerde je dat cv2.waitKey(1) een getal teruggeeft. Je gebruikte het op één manier:

key = cv2.waitKey(1) & 0xFF
if key == ord('q'):
    break  # stoppen

Dat is één toets. De dispatch-dict uit U3 laat je datzelfde getal direct als sleutel gebruiken — voor elke toets een actie, zonder if/elif-keten.

Wat retourneert waitKey()?

cv2.waitKey(1) wacht 1 milliseconde en geeft terug:

• -1 — geen toets ingedrukt (het meest voorkomend in elke frame)
• een integer — de ASCII-code van de ingedrukte toets, gelijk aan ord('x')

Die integer is precies hetzelfde als wat ord('p') geeft. Daardoor werkt de dispatch-dict uit U3 direct als opzoektabel:

# De drie stappen in de loop:
key = cv2.waitKey(1) & 0xFF  # 1. lees toets (altijd bitmask)
if key == 255:
    continue                  # 2. geen toets: sla over
action = keymap.get(key)      # 3. dispatch naar actie

Dat zijn drie regels. Ze vervangen de oude if key == ord('q'): break en kunnen elke toets afhandelen.

Interactieve demo: dispatch chain

Klik een toets. Zie hoe waitKey() het getal teruggegft en de dispatch-dict de actie opzoekt.

Wat retourneert waitKey() precies?

cv2.waitKey(n) wacht maximaal n milliseconden op een toetsaanslag. De return-waarde is een 32-bits integer. Er zijn drie gevallen:

• -1 — geen toets ingedrukt binnen n ms. Dit is veruit het meest voorkomend: in een 30fps-loop vliegen ~29 van de 30 frames langs zonder toets.
• 0–127 — een ASCII-teken, gelijk aan ord() voor dat karakter.
• >255 op sommige systemen — modifier-bits (Fn, Ctrl, Alt) in de hogere bytes. Vandaar de & 0xFF bitmask.

De bitmask & 0xFF

Op Linux kan waitKey() waarden als 65569 teruggeven voor 'q' (= 65536 + 113). & 0xFF houdt alleen de onderste 8 bits over:

key = cv2.waitKey(1)      # bijv. 65569 op Linux
key = key & 0xFF          # → 113 (= ord('q'))
# Nu werkt keymap.get(key) correct op elk systeem

Schrijf dit altijd als één stap: key = cv2.waitKey(1) & 0xFF. Na de bitmask geeft -1 de waarde 255 (want -1 & 0xFF = 255). Dat is je filter voor "geen toets".

De drie stappen uitgewerkt

Stap 1 — altijd de bitmask toepassen: waitKey() kan op Linux waarden groter dan 255 teruggeven door modifier-bits. De bitmask isoleert de laagste 8 bits.

key = cv2.waitKey(1)     # bijv. 65569 op Linux voor 'q'
key = key & 0xFF         # → 113, correct op elk platform

Stap 2 — filter geen-toets: Na de bitmask levert -1 de waarde 255 op (-1 & 0xFF = 255). Dit is je filter.

if key == 255:
    continue   # geen toets ingedrukt: volgende frame

Stap 3 — dispatch: De overgebleven waarde is een ASCII-code, gelijk aan ord('x'). Precies wat je als sleutel in de dict hebt staan.

action = keymap.get(key)   # None als toets onbekend is
if action:
    print(f"Actie: {action}")

waitKey(n): de parameter bepaalt de framerate

Het argument van waitKey() is de maximale wachttijd in milliseconden. Dit bepaalt indirect hoe snel je loop draait:

• waitKey(1) — wacht 1ms, loop draait zo snel als de CPU het toelaat
• waitKey(30) — wacht maximaal 30ms, loop draait maximaal ~33fps
• waitKey(0) — wacht onbeperkt tot er een toets ingedrukt wordt (pauzeert de loop)

Wat te doen met de actie

keymap.get(key) geeft een string terug (of None als de toets onbekend is). Wat je vervolgens met die string doet, hangt af van je programma. Drie patronen komen vaak voor:

action = keymap.get(key)

# Patroon A: direct vergelijken
if action == "stoppen":
    break

# Patroon B: controleer of er überhaupt een actie is
if action:
    execute(action)

# Patroon C: melding bij onbekende toets
if action is None:
    print(f"Onbekende toets: {chr(key)} ({key})")

Wanneer wel/niet gebruiken

• Wel: in elke loop waar cv2.imshow() actief is. waitKey() is dan vereist — zonder het luistert OpenCV niet naar window-events en vriest de weergave in.
• Niet: buiten een OpenCV-venster. Voor command-line tools zonder videovenster gebruik je input() of een library als keyboard.

Veelgemaakte fouten

Fout 1: keymap[key] zonder .get() — KeyError op 255

key = cv2.waitKey(1) & 0xFF
# 255 zit niet in keymap!
action = keymap[key]  # KeyError

key = cv2.waitKey(1) & 0xFF
if key == 255:
    continue
action = keymap.get(key)

Fout 2: & 0xFF vergeten — werkt niet cross-platform

key = cv2.waitKey(1)
# Op Linux: key = 65569
# ord('q') = 113
# 65569 != 113 → nooit match!

key = cv2.waitKey(1) & 0xFF
# Altijd 0–255
# Werkt op Windows, Mac, Linux

Fout 3: 255 niet filteren — actie elke frame

key = cv2.waitKey(1) & 0xFF
# 255 (geen toets) dispatchen:
action = keymap.get(key, "onbekend")
execute(action)  # 30x/sec "onbekend"!

key = cv2.waitKey(1) & 0xFF
if key == 255:
    continue     # geen toets: skip
action = keymap.get(key)

Interactieve demo: uitgebreide dispatch chain

Klik een toets of simuleer "geen toets". Zie elke stap: raw waarde, bitmask, filter, en dispatch.