Gezichtsherkenning met OpenCV

De complexiteit van machines is in de loop der jaren toegenomen en computers zijn geen uitzondering. Computers hebben de mensheid geholpen veel problemen op te lossen en veel moeilijke taken uit te voeren. Voorbij zijn de dagen dat alle computers eenvoudige rekenkundige bewerkingen deden, computers besturen nu de wereld.

Computers zijn zo complex geworden dat ze worden getraind om als mensen te denken.
Ja!

In dit artikel gaan we iets van dien aard doen. Als mensen is het herkennen van de gezichten van andere mensen een eenvoudige taak en ondanks de mogelijkheden van de hedendaagse computers is het niet zo eenvoudig voor de computer, dus we moeten hem trainen om hetzelfde te kunnen doen.

Veel artikelen die je daar zou zien, stoppen bij eenvoudige gezichtsdetectie, maar in dit artikel zou niet alleen gezichtsherkenning maar ook gezichtsherkenning worden behandeld.

Dit betekent dat als de computer twee foto's van mij te zien krijgt, hij niet alleen zou herkennen welk deel van de foto mijn gezicht is, maar ook zou herkennen dat ik degene ben op beide foto's.

Om te beginnen zouden we eerst opencv op onze machines moeten installeren, wat alleen kan als je Python hebt geïnstalleerd. De installatie van Python is niet het doel van dit artikel, dus als je het nog niet op je computer hebt staan, kun je Python installeren vanaf de Python-website.

Om Open CV te installeren, kunnen we dat doen met behulp van het pip-commando.

pip installeer opencv-python

We zullen ook gebruik maken van het numpy-pakket in dit artikel, dat naast OpenCV moet worden geïnstalleerd met behulp van de bovenstaande opdracht.

Als numpy niet is geïnstalleerd, kunt u dit eenvoudig doen met de onderstaande opdracht:

pip installeer numpy

Om te bevestigen dat uw OpenCV is geïnstalleerd, wanneer u de interactieve omgeving van Python activeert, probeert u deze te importeren met:

import cv2

Als u geen foutmelding krijgt, kunt u doorgaan.

Om gezichtsherkenning uit te voeren, zouden we drie scripts schrijven. Een om een ​​dataset van afbeeldingen te maken, een andere om die afbeeldingen te trainen en dan de laatste om de gezichten te herkennen op basis van de resultaten van de training die de computer doorloopt.

We hebben de Haar Cascade nodig van Open CV. Dit bestand kan worden opgehaald uit de opencv-map die cv2/data/haarcascade_frontalface_default is.xml op mijn machine zou het ook op jouw machine hetzelfde moeten zijn. Kopieer het bestand naar de map waar je de gezichtsherkenning wilt doen.

Laten we nu in het midden van de dingen komen.
We zouden proberen onze webcam te krijgen om de foto's te krijgen, die nodig zijn voor de dataset.

import cv2
vid_cam = cv2.Video-opname(0)
face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
face_id = 1
aantal = 0
while(vid_cam.is geopend()):
ret, image_frame = vid_cam.lezen()
grijs = cv2.cvtColor(image_frame, cv2.COLOR_BGR2GRAY)
gezichten = gezichtsdetector.detectMultiScale(grijs, 1.3, 5)
voor (x,y,w,h) in vlakken:
cv2.rechthoek(beeld_frame, (x,y), (x+w,y+h), (255,0,0), 2)
tel += 1
cv2.imwrite("dataset/gebruiker." + str(face_id) + '.' + str(telling) + ".jpg", grijs[y:y+h,x:x+w])
cv2.imshow('frame', image_frame)
als cv2.waitKey(100) & 0xFF == ord('q'):
breken
elif-telling>100:
breken
vid_cam.vrijlating()
cv2.vernietigenAlleWindows()

Dus om uit te leggen wat elke regel code doet:

import cv2

Hier is de opdracht die python vertelt om een ​​externe bibliotheek op te nemen die in deze code moet worden gebruikt, in dit geval is het Open CV.

vid_cam = cv2.Video-opname(0)

Deze code roept de geïmporteerde Open CV-bibliotheek aan om te beginnen met vastleggen en de webcam wordt op dit punt gestart. Als de Open CV je webcam niet ondersteunt, mislukt de code hier fail.

face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

Om beelddetectie uit te kunnen voeren, is deze code nodig. Open CV gebruikt de 'haarcascade_frontalface_default'.xml' voor Cascade-classificatie. Het resulterende object wordt vervolgens opgeslagen in de variabele face_detector.

face_id = 1

Hier is een geval van het instellen van het id-nummer van het gezicht, zodat het eerste gezicht een id krijgt van 1.

aantal = 0

We gaan een paar foto's maken omdat Open CV afbeeldingen moet trainen om gezichten te kunnen herkennen, de count-variabele dient als een image count.

while(vid_cam.is geopend()):

Hierdoor kunnen de volgende bewerkingen worden uitgevoerd, mits de videocamera is geopend:. De methode isOpened() retourneert True of False.

ret, image_frame = vid_cam.lezen()

Hier, de vid_cam.read() kijkt naar de video-opname en legt vervolgens het frame vast dat is opgeslagen in de variabele image_frame, als de bewerking succesvol is, wordt de boolean True geretourneerd en opgeslagen in de ret-variabele

grijs = cv2.cvtColor(image_frame, cv2.COLOR_BGR2GRAY)

De cvtColor() methode wordt gebruikt om het afbeeldingsframe om te zetten in het gewenste kleurtype. In dit geval hebben we het omgezet in grijswaarden.

gezichten = gezichtsdetector.detectMultiScale(grijs, 1.3, 5)

Dit controleert op frames van verschillende groottes en probeert ze op schaal in te stellen, dit wordt toegepast op de variabele waarop de Haar Cascade is toegepast.

voor (x,y,w,h) in vlakken:

Hier lopen we door de vlakken en de afmetingen ervan, waarbij x en y staan ​​voor de coördinaten en w en h respectievelijk voor breedte en hoogte staan.

cv2.rechthoek(beeld_frame, (x,y), (x+w,y+h), (255,0,0), 2)

Onthoud dat we nog steeds met de videocamera werken, de videocamera snijdt dan het benodigde deel van de afbeelding bij volgens de bovenstaande afmetingen.

tel += 1

Onmiddellijk dat is gedaan, wordt de count-variabele die als een teller staat, verhoogd.

cv2.imwrite("dataset/gebruiker." + str(face_id) + '.' + str(telling) + ".jpg", grijs[y:y+h,x:x+w])

De bijgesneden afbeelding wordt opgeslagen met de naam Gebruiker (face_id).(tel).jpg en zet het in een map met de naam dataset.

cv2.imshow('frame', image_frame)

Na het opslaan zorgt deze code ervoor dat de afbeelding als videoframe wordt weergegeven met een rechthoek op het gezicht van de persoon nadat gezichtsdetectie is uitgevoerd.

als cv2.waitKey(100) & 0xFF == ord('q'):
breken

Na elke foto mag de gebruiker het programma stoppen met het maken van meer foto's, wat kan worden gedaan door minimaal 100 ms op de 'q' op het toetsenbord te drukken.

elif-telling>100:
breken

Deze code zorgt ervoor dat de video niet meer werkt op het moment dat er 100 foto's zijn gemaakt, ongeacht of de gebruiker meer wil maken of niet.

vid_cam.vrijlating()

Hier is de webcam gesloten en niet alleen gestopt met het maken van foto's.

cv2.vernietigenAlleWindows()

Dan zijn alle vensters die OpenCV heeft geopend vernietigd en loopt de code af.

Nu we daarmee klaar zijn, kunnen we de afbeeldingsdataset trainen:

import cv2, os
importeer numpy als np
van PIL import Afbeelding
herkenner = cv2.gezicht.createLBPHFaceRecognizer()
detector = cv2.CascadeClassifier("haarcascade_frontalface_default.xml");
def getImagesAndLabels(pad):
imagePaths = [os.pad.join(pad,f) voor f in os.lijstmap(pad)]
faceSamples=[]
ID's = []
voor imagePath in imagePaths:
PIL_img = Afbeelding.open(afbeeldingspad).converteren('L')
img_numpy = np.array(PIL_img,'uint8')
id = int(os.pad.split(beeldpad)[-1].splitsen(".")[1])
gezichten = detector.detectMultiScale(img_numpy)
voor (x,y,w,h) in vlakken:
gezichtSamples.toevoegen(img_numpy[y:y+h,x:x+w])
ID's.toevoegen (id)
return faceSamples,ids
gezichten, ids = getImagesAndLabels('dataset')
herkenner.trein (gezichten, np.array(ID's))
herkenner.save('trainer/trainer.yml')

Laten we doorgaan en deze code ook uitleggen:

import cv2, os

Net als de andere code, importeren we hier OpenCV en os die we nodig hebben voor het bestandspad.

importeer numpy als np

We importeren ook de numpy-bibliotheek die zou worden gebruikt voor matrixberekening (een matrix is ​​slechts een rangschikking van arrays).

van PIL import Afbeelding

We importeren de Python-afbeeldingsbibliotheek en daaruit halen we ook de afbeeldingsbibliotheek uit dit pakket.

herkenner = cv2.gezicht.createLBPHFaceRecognizer()

Wat dit doet, is de methode createLBPHFaceRecognizer() toepassen op de cv2.face-object, dit zou de herkenning van gezichten gemakkelijk maken, omdat we niet met onze eigen set algoritmen hoeven te komen.

detector = cv2.CascadeClassifier("haarcascade_frontalface_default.xml");

Als je de tutorial hebt gevolgd, zou je dit eerder zijn tegengekomen. Het helpt bij gezichtsdetectie met behulp van de "haarcascade_frontalface_default.xml" voor de Cascade-classificatie.

def getImagesAndLabels(pad):

Nu staan ​​we op het punt te beginnen met de eigenlijke beeldtraining, dus we creëren een functie.

imagePaths = [os.pad.join(pad,f) voor f in os.lijstmap(pad)]

Deze code checkt in in de huidige map van het bestand en controleert op de afbeeldingsbestanden en voegt ze vervolgens toe aan deze lijst.

faceSamples=[]

Hiermee wordt een lijst met voorbeelden geïnitialiseerd, deze is op dit moment leeg, maar gezichten worden toegevoegd terwijl de code wordt uitgevoerd.

ID's = []

Initialiseer een lijst met ID's, die aanvankelijk leeg is.

voor imagePath in imagePaths:

Onthoud de code die de afbeeldingsbestanden in de map heeft gecontroleerd? Ja? Nu gaan we door elk van die bestanden lopen en er bewerkingen op uitvoeren.

PIL_img = Afbeelding.open(afbeeldingspad).converteren('L')

Het eerste dat we met de afbeelding doen, is deze converteren naar grijswaarden, en deze code doet dat.

img_numpy = np.array(PIL_img,'uint8')

De grijsschaalafbeelding is slechts een reeks getallen op één plek, dus we maken er een numpy-array van en wijzen deze toe aan een variabele.

id = int(os.pad.split(beeldpad)[-1].splitsen(".")[1])

Als u zich het bestand herinnert dat de afbeeldingen krijgt, herinnert u zich dat we de bestanden User(face_id) hebben genoemd.tellen.jpg. Dus hier splitsen we de namen met de ".” en dan extraheren we de face_id en wijzen we deze toe aan een variabele hier. We zouden de id nodig hebben voor herkenning.

gezichten = detector.detectMultiScale(img_numpy)

Vanuit de numpy-array probeert de methode detectMultiScale() de gezichten te detecteren van het patroon dat wordt gevonden in de numpy-array. Vervolgens wijst het de waarden in de variabele faces toe.

voor (x,y,w,h) in vlakken:

Hier doorlopen we de waarden die aan de variabele zijn toegewezen. De waarden hier zijn de x- en y-coördinaten die we als oorsprong zouden kunnen nemen, en dan staan ​​w en h respectievelijk voor breedte en hoogte.

gezichtSamples.toevoegen(img_numpy[y:y+h,x:x+w])

Eerder hebben we een lijst met gezichtsvoorbeelden gemaakt, maar deze was leeg. Hier kunnen we gezichten aan die lijst toevoegen, en we voegen de y toe aan h om de twee waarden van de y-coördinaten te krijgen en hetzelfde wordt gedaan voor x.

ID's.toevoegen (id)

We hebben nu een gezicht in de lijst met gezichtsvoorbeelden, dus we halen de id op en voegen deze ook toe aan de id-lijst.

return faceSamples,ids

Dan retourneren we tenslotte de lijst met gezichtsvoorbeelden en de lijst met ID's.

gezichten, ids = getImagesAndLabels('dataset')

Onthoud dat getImagesAndLabels() slechts een functie is. Dus we mogen de functie hier aanroepen, en de geretourneerde waarden worden opgeslagen in de variabelen faces en ids.

herkenner.trein (gezichten, np.array(ID's))

Hier vindt de echte training plaats. We hebben de methode createLBPHFaceRecognizer() enige tijd eerder toegepast en toegewezen aan een herkenbare variabele. Het is trainingstijd!

herkenner.save('trainer/trainer.yml')

Na de training mogen we de resultaten van de training opslaan.
Nadat de code is uitgevoerd, wordt een bestand gemaakt met de naam trainer.yml die dan zou worden gebruikt door de gezichtsherkenningscode.

Hier is de gezichtsherkenningscode:

import cv2
importeer numpy als np
herkenner = cv2.gezicht.createLBPHFaceRecognizer()
herkenner.laden('trainer/trainer.yml')
cascadePath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)
lettertype = cv2.FONT_HERSHEY_SIMPLEX
nok = cv2.Video-opname(0)
terwijl waar:
ret, ik = cam.lezen()
grijs = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
gezichten = faceCascade.detectMultiScale(grijs, 1.2,5)
for(x,y,w,h) in vlakken:
cv2.rechthoek(im, (x-20,y-20), (x+w+20,y+h+20), (0,255,0), 4)
Id = herkenner.voorspellen(grijs[y:y+h,x:x+w])
if(Id == 1):
ID = "Nazmi"
anders:
Id = "Onbekend"
cv2.rechthoek(im, (x-22,y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.putText(im, str(Id), (x,y-40), lettertype, 2, (255,255,255), 3)
cv2.imshow('im',im)
als cv2.waitKey(10) & 0xFF == ord('q'):
breken
cam.vrijlating()
cv2.vernietigenAlleWindows()

Als je het artikel vanaf het begin hebt gevolgd, hebben we dit eerder gedaan. Als je het niet zo vriendelijk hebt gedaan.

herkenner.laden('trainer/trainer.yml')

Onthoud dat we de herkenner hebben getraind en een bestand hebben opgeslagen? Ja? We zijn dat bestand nu aan het laden.

cascadePath = "haarcascade_frontalface_default.xml"

We zouden werken met het haarcascade-bestand, en hier hebben we de bestandsnaam aan een variabele toegewezen.

# Maak classifier van een vooraf gebouwd model
faceCascade = cv2.CascadeClassifier(cascadePath)

Hier mogen we Cascade-classificatie uitvoeren op het haarcascade-bestand.

lettertype = cv2.FONT_HERSHEY_SIMPLEX

We hebben het lettertype ingesteld dat zou worden gebruikt wanneer de code het gezicht in een afbeelding herkent en de naam weergeeft.

nok = cv2.Video-opname(0)

We zijn hier eerder geweest, maar deze keer is het tijd om de gezichten te herkennen. Als je niet weet wat deze code doet, wordt de webcam gestart.

terwijl waar:
ret, ik = cam.lezen()
grijs = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
gezichten = faceCascade.detectMultiScale(grijs, 1.2,5)
for(x,y,w,h) in vlakken:

Al deze zijn eerder gedaan, controleer alstublieft de code die is gebruikt om afbeeldingen op te slaan als u niet weet wat de code doet.

cv2.rechthoek(im, (x-20,y-20), (x+w+20,y+h+20), (0,255,0), 4)

Dit helpt de webcam om te detecteren waar de gezichten zijn en plaatst een rechthoek om een ​​gezicht aan te geven.

Id = herkenner.voorspellen(grijs[y:y+h,x:x+w])

We hebben het treinbestand al in de herkenner geladen, zodat het nu het gezicht kan herkennen.

if(Id == 1):
Id = "mezelf"
anders:
Id = "Onbekend"

Nadat het heeft geprobeerd te herkennen welk gezicht het is, controleert het op de id en kijkt of het bestaat. Hier zou de waarde van de id de naam zijn van degene die de eigenaar was die met zo'n id werd geconfronteerd toen de afbeeldingsgegevensset werd gemaakt.

cv2.rechthoek(im, (x-22,y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.putText(im, str(Id), (x,y-40), lettertype, 2, (255,255,255), 3)

De code na het vinden van de eigenaar van de ID, tekent een rechthoek rond het gezicht en plaatst de naam van de eigenaar van het gezicht. Gezicht herkend!

cv2.imshow('im',im)

Hier wordt het videoframe weergegeven met de begrensde rechthoek.

als cv2.waitKey(10) & 0xFF == ord('q'):
breken
cam.vrijlating()
cv2.vernietigenAlleWindows()

Dus als je klaar bent, kun je het programma stoppen door op de 'q'-toets te drukken, en het stopt de webcam en sluit hem.

Daar heb je het, je webcam kan nu gezichten herkennen en je kunt het gebruiken wanneer je maar wilt. Naast het gebruik van de webcam kun je ook een afbeelding laden, maar dat vereist een aantal andere stappen dan die in dit artikel worden genomen.

U kunt de gebruikte broncode vinden op de github-repo re. Tweet ons ook als je opmerkingen hebt of wilt discussiëren over @linuxhint