Gezichtsdetectie met Python met OpenCV

Introductie tot Haar-cascadeclassifiers

Deze methode werd voor het eerst geïntroduceerd in het paper Rapid Object Detection Using a Boosted Cascade of Simple Features, geschreven door Paul Viola en Michael Jones.

Het idee achter deze techniek is het gebruik van een cascade van classifiers om verschillende kenmerken in een afbeelding te detecteren. Deze classifiers worden vervolgens samengevoegd tot één sterke classifier die nauwkeurig onderscheid kan maken tussen voorbeelden mét en zonder menselijk gezicht.

De Haar-cascadeclassifier die in OpenCV is ingebouwd, is al getraind op een grote dataset met menselijke gezichten, dus extra training is niet nodig. We hoeven de classifier alleen maar uit de bibliotheek te laden en te gebruiken om gezichten in een inputafbeelding te detecteren.

OpenCV voor Python installeren

Om de OpenCV-bibliotheek te installeren, open je simpelweg je command prompt of terminalvenster en voer je het volgende commando uit:

pip install opencv-python

Dit commando werkt alleen als je pip al op je apparaat hebt geïnstalleerd. Wil je meer weten over de pip-pakketmanager, lees dan onze PIP Python Tutorial.

OpenCV voor gezichtsdetectie in afbeeldingen

We bouwen een detector om het menselijke gezicht te identificeren in een foto van Unsplash. Zorg dat je de foto opslaat in je werkmap en hernoem hem naar input_image voordat je meedoet met de code.

Stap 1: Importeer het OpenCV-pakket

Laten we nu OpenCV importeren en het pad naar de inputafbeelding invoeren met de volgende regels code:

import cv2

imagePath = 'input_image.jpg'

Stap 2: Lees de afbeelding

Vervolgens moeten we de afbeelding inlezen met OpenCV’s imread()-functie:

img = cv2.imread(imagePath)

Dit laadt de afbeelding van het opgegeven bestandspad en geeft deze terug als een Numpy-array. 

Laten we de afmetingen van deze array afdrukken:

img.shape

(4000, 2667, 3)

Merk op dat dit een 3D-array is. De waarden van de array geven respectievelijk de hoogte, breedte en kanalen van de afbeelding weer. Omdat dit een kleurenafbeelding is, zijn er drie kanalen om deze weer te geven: blauw, groen en rood (BGR). 

Let op: hoewel de gangbare volgorde om afbeeldingen te representeren RGB (Red, Green, Blue) is, gebruikt de OpenCV-bibliotheek de omgekeerde volgorde (Blue, Green, Red).

Stap 3: Converteer de afbeelding naar grijswaarden

Om de rekentijd te verbeteren, moeten we de afbeelding eerst naar grijswaarden converteren voordat we gezichtsdetectie uitvoeren:

gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Bekijk nu de afmetingen van deze grijswaardenafbeelding:

gray_image.shape

(4000, 2667)

Merk op dat deze array maar twee waarden heeft, omdat de afbeelding grijswaarden is en dus geen derde kleurkanaal meer heeft.

Stap 4: Laad de classifier

Laten we de voorgetrainde Haar-cascadeclassifier laden die in OpenCV is ingebouwd:

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Merk op dat we een bestand gebruiken met de naam haarcascade_frontalface_default.xml. Deze classifier is specifiek ontworpen om frontale gezichten in visuele input te detecteren. 

OpenCV biedt ook andere voorgetrainde modellen om verschillende objecten in een afbeelding te detecteren, zoals iemands ogen, glimlach, bovenlichaam en zelfs een kentekenplaat. Je kunt meer leren over de verschillende classifiers in OpenCV door de GitHub-repository van de bibliotheek te bekijken.

Stap 5: Voer de gezichtsdetectie uit

We kunnen nu gezichtsdetectie uitvoeren op de grijswaardenafbeelding met de zojuist geladen classifier:

face = face_classifier.detectMultiScale(
    gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40)
)

Laten we de methoden en parameters in de bovenstaande code toelichten:

1. detectMultiScale():

De methode detectMultiScale() wordt gebruikt om gezichten van verschillende groottes in de inputafbeelding te identificeren.

1. grey_image:

De eerste parameter in deze methode heet grey_image, dit is de grijswaardenafbeelding die we eerder hebben gemaakt.

1. scaleFactor:

Deze parameter wordt gebruikt om de grootte van de inputafbeelding te verkleinen, zodat het algoritme grotere gezichten gemakkelijker kan detecteren. In dit geval hebben we een schaalfactor van 1,1 opgegeven, wat aangeeft dat we de afbeeldingsgrootte met 10% willen verkleinen.

1. minNeighbors:

De cascadeclassifier schuift een venster over de afbeelding om gezichten te detecteren. Je kunt deze vensters zien als rechthoeken. 

Aanvankelijk zal de classifier veel false positives opleveren. Deze worden geëlimineerd met de parameter minNeighbors, die het aantal aangrenzende rechthoeken opgeeft dat nodig is om een object als een geldige detectie te beschouwen.

Samengevat: een kleine waarde zoals 0 of 1 doorgeven aan deze parameter resulteert in veel false positives, terwijl een grote waarde ertoe kan leiden dat je veel true positives mist.

De kunst is hier om een balans te vinden die false positives elimineert en tegelijkertijd true positives nauwkeurig identificeert.

1. minSize:

Tot slot stelt de parameter minSize de minimale grootte in van het te detecteren object. Het model negeert gezichten die kleiner zijn dan de opgegeven minimumgrootte.

Stap 6: Een bounding box tekenen

Nu het model de gezichten in de afbeelding heeft gedetecteerd, laten we de volgende regels code uitvoeren om een bounding box rond deze gezichten te tekenen:

for (x, y, w, h) in face:
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 4)

De variabele face is een array met vier waarden: de x- en y-as waarop de gezichten zijn gedetecteerd, en hun breedte en hoogte. De bovenstaande code itereert over de geïdentificeerde gezichten en tekent een bounding box die deze afmetingen beslaat.

De parameter 0,255,0 staat voor de kleur van de bounding box, namelijk groen, en 4 geeft de lijndikte aan.

Stap 7: De afbeelding weergeven

Om de afbeelding met de gedetecteerde gezichten weer te geven, moeten we de afbeelding eerst converteren van het BGR-formaat naar RGB:

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

Laten we nu de Matplotlib-bibliotheek gebruiken om de afbeelding te tonen:

import matplotlib.pyplot as plt



plt.figure(figsize=(20,10))
plt.imshow(img_rgb)
plt.axis('off')

De bovenstaande code zou de volgende output moeten genereren: 

Top!

Het model heeft het menselijke gezicht in deze afbeelding met succes gedetecteerd en er een bounding box omheen getekend. 

Realtime gezichtsdetectie met OpenCV

Nu we met OpenCV met succes gezichtsdetectie op een statische afbeelding hebben uitgevoerd, gaan we kijken hoe je hetzelfde doet op een live videostream. 

Stap 1: Vereisten

Laten we eerst de OpenCV-bibliotheek importeren en het Haar-cascademodel laden, net als in het vorige onderdeel. Je kunt dit codeblok overslaan als je het eerder al hebt uitgevoerd:

import cv2

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Stap 2: Toegang tot de webcam

Nu moeten we de camera van ons apparaat aanspreken om een live videostream uit te lezen. Dat kan met de volgende code:

video_capture = cv2.VideoCapture(0)

Merk op dat we de parameter 0 hebben doorgegeven aan de functie VideoCapture(). Dit vertelt OpenCV dat de standaardcamera van ons apparaat moet worden gebruikt. Als je meerdere camera’s op je apparaat hebt aangesloten, kun je deze parameterwaarde dienovereenkomstig aanpassen.

Stap 3: Gezichten identificeren in de videostream

Laten we nu een functie maken om gezichten in de videostream te detecteren en er een bounding box omheen te tekenen:

def detect_bounding_box(vid):
    gray_image = cv2.cvtColor(vid, cv2.COLOR_BGR2GRAY)
    faces = face_classifier.detectMultiScale(gray_image, 1.1, 5, minSize=(40, 40))
    for (x, y, w, h) in faces:
        cv2.rectangle(vid, (x, y), (x + w, y + h), (0, 255, 0), 4)
    return faces

De functie detect_bounding_box neemt het videoframe als input.

In deze functie gebruiken we dezelfde code als eerder om het frame naar grijswaarden te converteren voordat we gezichtsdetectie uitvoeren.

Vervolgens detecteren we het gezicht in dit beeld met dezelfde parameterwaarden voor scaleFactor, minNeighbors en minSize als hiervoor.

Tot slot tekenen we een groene bounding box met dikte 4 rond het frame.

Stap 4: Een loop maken voor realtime gezichtsdetectie

Nu moeten we een oneindige while-loop maken die het videoframe van onze webcam vastlegt en de gezichtsdetectiefunctie daarop toepast:

while True:

    result, video_frame = video_capture.read()  # read frames from the video
    if result is False:
        break  # terminate the loop if the frame is not read successfully

    faces = detect_bounding_box(
        video_frame
    )  # apply the function we created to the video frame

    cv2.imshow(
        "My Face Detection Project", video_frame
    )  # display the processed frame in a window named "My Face Detection Project"

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

video_capture.release()
cv2.destroyAllWindows()

Na het uitvoeren van de bovenstaande code zou er een venster met de naam My Face Detection Project op het scherm moeten verschijnen:

Het algoritme zou je gezicht moeten volgen en er een groene bounding box omheen moeten tekenen, ongeacht waar je je binnen het frame beweegt.

In het frame hierboven herkent het model mijn gezicht en mijn foto op het rijbewijs dat ik omhoog houd.

Je kunt de effectiviteit van dit model ook testen door meerdere foto’s omhoog te houden of door verschillende mensen onder diverse hoeken achter de camera te laten staan. Het model zou in staat moeten zijn alle menselijke gezichten te identificeren in verschillende achtergronden of lichtomstandigheden.

Als je het programma wilt afsluiten, kun je op de toets “q” op je toetsenbord drukken om de loop te onderbreken.

Conclusie

Samengevat is OpenCV een krachtige en veelzijdige bibliotheek voor het bouwen van computervisie-applicaties, met een breed scala aan voorgetrainde modellen en tools om complexe taken zoals gezichtsdetectie te vereenvoudigen.

Of je nu statische afbeeldingen of live videostreams verwerkt, OpenCV biedt een laagdrempelige instap voor developers om efficiënte en schaalbare oplossingen te maken.

Door de technieken in deze tutorial onder de knie te krijgen, ben je goed uitgerust om geavanceerdere toepassingen van computervisie in je projecten te verkennen.