Echtzeit-Gesichtserkennung auf Raspberry Pi – Komplette Anleitung

Dieses Tutorial führt Sie durch den Bau eines Echtzeit-Gesichtserkennungssystems auf einem Raspberry Pi mit OpenCV und Pi-Cam. Von der Hardware-Einrichtung bis zum Training des Erkenners wird jeder Schritt mit klaren Code-Snippets und praktischen Tipps vorgestellt.

Unten sehen Sie eine Live-Demo der Pi-Cam, die Gesichter in Echtzeit erkennt.

Das Projekt basiert auf der Open-Source-Bibliothek OpenCV, die für Echtzeitleistung optimiert ist. Wir konzentrieren uns auf einen Raspberry Pi mit Raspbian, der gleiche Code läuft aber auch unter macOS und Windows mit geringfügigen Anpassungen.

3 Phasen

Ein vollständiger Gesichtserkennungs-Workflow lässt sich in drei Phasen unterteilen:

• Gesichtserkennung & Datensammlung
• Training des Erkenners
• Echtzeit-Gesichtserkennung

Das folgende Diagramm fasst diese Phasen zusammen.

Schritt 1: Stückliste (Bill of Materials)

Wesentliche Komponenten:

• Raspberry Pi 3 – 32,00 $
• 5 MP 1080p OV5647 Mini-Kamera-Modul – 13,00 $

Schritt 2: OpenCV 3 installieren

Wir empfehlen, Adrian Rosebrocks Anleitung für eine saubere OpenCV 3 Installation auf Raspbian Stretch zu folgen. Nach dem Tutorial die dedizierte Python-Virtual-Environment aktivieren:

source ~/.profile
workon cv

Innerhalb der Umgebung Python-Version und OpenCV-Installation prüfen:

python
>>> import cv2
>>> cv2.__version__

Sie sollten eine Versionsnummer wie 3.3.0 oder neuer sehen.

Schritt 3: Kamera testen

Falls die Kamera nicht erkannt wird, Treiber aktivieren mit:

sudo modprobe bcm2835-v4l2

Der folgende Python-Schnipsel öffnet den Pi-Cam-Stream, zeigt ihn in Farbe und Graustufen an und spiegelt ihn vertikal (anpassen falls Ihre Kamera-Orientierung abweicht):

import numpy as np
import cv2

cap = cv2.VideoCapture(0)
cap.set(3, 640)
cap.set(4, 480)

while True:
    ret, frame = cap.read()
    frame = cv2.flip(frame, -1)
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    cv2.imshow('frame', frame)
    cv2.imshow('gray', gray)
    if cv2.waitKey(30) & 0xff == 27:
        break

cap.release()
cv2.destroyAllWindows()

Ausführen mit python simpleCamTest.py (im GitHub des Projekts verfügbar). Mit ESC beenden.

Schritt 4: Gesichtserkennung

OpenCVs Haar-Cascade-Klassifikator ist ein leichter Machine-Learning-Ansatz zur Gesichtserkennung. Laden Sie die vortrainierte XML-Datei (haarcascade_frontalface_default.xml) herunter und legen Sie sie in einen Cascades-Ordner. Das folgende Skript demonstriert Echtzeit-Gesichtserkennung mit Begrenzungsrahmen:

import cv2

faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')
cap = cv2.VideoCapture(0)
cap.set(3, 640)
cap.set(4, 480)

while True:
    ret, img = cap.read()
    img = cv2.flip(img, -1)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = faceCascade.detectMultiScale(
        gray, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20)
    )
    for (x, y, w, h) in faces:
        cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
    cv2.imshow('video', img)
    if cv2.waitKey(30) & 0xff == 27:
        break

cap.release()
cv2.destroyAllWindows()

Die detectMultiScale Parameter steuern die Empfindlichkeit: scaleFactor verkleinert das Bild pro Iteration, minNeighbors filtert Fehlalarme, minSize setzt die kleinste erkennbare Gesichtsgröße.

Zusätzliche Beispiele

Weitere Erkennungsoptionen im GitHub des Projekts:

• faceEyeDetection.py
• faceSmileDetection.py
• faceSmileEyeDetection.py

Haar Cascade Objekt Erkennung – Face & Eye Tutorial

Schritt 5: Datensammlung

Ein gelabelter Datensatz ist essenziell fürs Training. Erstellen Sie einen Projektordner (z. B. FacialRecognitionProject) und ein dataset-Unterverzeichnis:

mkdir FacialRecognitionProject
cd FacialRecognitionProject
mkdir dataset

Laden Sie die Haar-Cascade-Datei in den Projekt-Root. Führen Sie dann 01_face_dataset.py aus, um 30 Gesichtsbilder pro Nutzer aufzunehmen:

import cv2
import os

cam = cv2.VideoCapture(0)
cam.set(3, 640)
cam.set(4, 480)

face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
face_id = input('\nBenutzer-ID (numerisch) eingeben und <Return> drücken → ')
print('\n[INFO] Initialisiere Gesichtsaufnahme. In die Kamera schauen…')

count = 0
while True:
    ret, img = cam.read()
    img = cv2.flip(img, -1)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_detector.detectMultiScale(gray, 1.3, 5)
    for (x, y, w, h) in faces:
        cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
        count += 1
        cv2.imwrite(f'dataset/User.{face_id}.{count}.jpg', gray[y:y+h, x:x+w])
        cv2.imshow('image', img)
    if cv2.waitKey(100) & 0xff == 27 or count >= 30:
        break
if count >= 30:
    break

cam.release()
cv2.destroyAllWindows()
print('\n[INFO] Programm wird beendet und aufgeräumt.')

Jedes Bild heißt User.{id}.{count}.jpg (z. B. User.1.4.jpg). Probenanzahl nach Bedarf anpassen.

Schritt 6: Training

Mit den gesammelten Bildern einen OpenCV-Gesichtserkenner trainieren. Das resultierende Modell wird als .yml-Datei in einem trainer-Ordner gespeichert. Details zum vollständigen Trainingsskript finden Sie im Projekt-Repository.

Weiterlesen: Real-Time Face Recognition – End-to-End Project