Phenquestions
Raspberry Pi is een goedkope minicomputer die computergebruik en programmeren veel gemakkelijker heeft gemaakt voor de meeste mensen, inclusief studenten en hobbyisten. Deze minicomputer kan alles wat een desktopcomputer kan, van internetten tot spannende projecten en programma's maken. En een van deze geweldige projecten is het maken van een Raspberry Pi-gezichtsherkenning. Hoewel dit project heel interessant kan zijn, is het niet erg gemakkelijk om te maken. Dus ik zou je aanraden om het artikel stap voor stap te volgen.
Raspberry Pi gezichtsherkenning
Het maken van een gezichtsherkenningsprogramma was misschien ooit heel moeilijk en geavanceerd. Maar met Raspberry Pi is niets te moeilijk! In dit artikel heb ik de Open Source Computer Vision Library (OpenCV) gebruikt om het project te doen.
Deze repository is ontworpen om te werken met rekenefficiëntie en real-time toepassingen. Daarom is het ideaal voor ons realtime gezichtsherkenningsprogramma. Dit artikel leidt u stap voor stap door het hele project. Dus blijf bij het einde om je eigen Raspberry Pi-gezichtsherkenning te hebben!
Vereisten
Je hebt de volgende dingen nodig om een Raspberry Pi gezichtsherkenningssysteem te maken:
- Raspberry Pi V4
- Zwarte camera
- OpenCV
Raspberry Pi-verbindingen
Zorg ervoor dat u de volgende verbindingen maakt voordat u begint met coderen:
- Maak verbindingen tussen de Raspberry Pi en Ribbon-kabel van Display
- Bevestig de SDA aan de SDA-pin van uw Pi
- Zet de SCL van Display naar de SCL-pin
- Sluit de lintkabel van de camera aan op de Raspberry Pi
- Plaats de GND van het display in de Pi GND
- Sluit de Raspberry Pi 5V en de 5V van het display aan
Stap 1: Installeer OpenCV op Raspberry Pi
De eerste stap is om OpenCV op uw Pi-apparaat te installeren. Om dat te doen, start u uw Raspberry Pi en opent u een SSH-verbinding. Om alle beschikbare ruimte op de micro-SD-kaart op te nemen, breid je je bestandssysteem uit.
$ sudo raspi-config
Selecteer vervolgens de "Geavanceerde opties" in het menu en daarna "Bestandssysteem uitbreiden":
Druk daarna op de “
$ sudo opnieuw opstarten
Stap 2: Bevestig de OpenCV-installatie
Als je klaar bent met herstarten, zou er een kant-en-klare virtuele OpenCV-omgeving op je Pi moeten zijn. Nu moet u bevestigen of OpenCV correct is geïnstalleerd in uw Pi. Voer de opdracht "bron" uit elke keer dat u een nieuwe terminal opent, zodat de systeemvariabelen correct zijn ingesteld.
bron ~/.profiel
Voer nu uw virtuele omgeving in:
werk op cv
De (cv) tekst betekent dat je in de cv virtuele omgeving bent.
(cv) pi@raspberry:~$
Om uw Python Interpreter in te voeren:
Python
U ziet een ">>>" verschijnen in de tolk. Om de OpenCV-bibliotheek te importeren:
import cv2
Als er geen foutmeldingen zijn, kunt u er zeker van zijn dat de OpenCV correct is geïnstalleerd.
Stap 3: Download OpenCV
Download nu uw geïnstalleerde OpenCV. Je moet zowel OpenCV als OpenCV bijdragen downloaden. De bijdrage wordt geleverd met modules en functies die je nodig hebt in dit experiment.
$ cd ~ $ wget -O opencv.zip https://github.com/opencv/opencv/archief/4.0.0.zip $ wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.0.0.zip
Pak nu de archieven uit:
$ unzip opencv.zip $ unzip opencv_contrib.zip
Stap 4: Afhankelijkheden installeren
Installeer nu de benodigde OpenCV-afhankelijkheden op uw Raspberry Pi om deze correct te laten werken:
$ sudo apt-get update && sudo apt-get upgrade $ sudo apt-get install build-essential cmake pkg-config $ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng-dev $ sudo apt-get install libavcodec -dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev $ sudo apt-get install libgtk2.0-dev libgtk-3-dev $ sudo apt-get install libfontconfig1-dev libcairo2-dev $ sudo apt-get install libgdk-pixbuf2.0-dev libpango1.0-dev $ sudo apt-get install libhdf5-dev libhdf5-serial-dev libhdf5-103 $ sudo apt-get install libqtgui4 libqtwebkit4 libqt4-test python3-pyqt5 $ sudo apt-get install libatlas-base-dev gapt installeer python2.7-dev python3-dev $ sudo apt-get install python3-pil.imagetk
Stap 5: Installeer pip
In deze stap moet u een pakketbeheerder voor python installeren met de naam "pip".
$ wget https://bootstrap.pypa.io/get-pip.py $ sudo python3 get-pip.py
Stap 6: installeer Numpy
Installeer daarna een python-bibliotheek met de naam "Numpy".
$ pip3 installeren numpy
Stap 7: Test de camera
Nu je alle benodigde dingen hebt geïnstalleerd, inclusief OpenCV, is het tijd om te controleren of je camera goed werkt. Je zou al een Picam op je Raspberry Pi moeten hebben geïnstalleerd. Voer de volgende code in op uw Python IDE:
import numpy als np import cv2 cap = cv2.VideoCapture(0) cap.set(3,640) # set Breedte cap.set(4.480) # set Height while(True): ret, frame = cap.read() frame = cv2.flip(frame, -1) # Camera verticaal grijs spiegelen = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow('frame', frame) cv2.imshow('grijs', grijs) k = cv2.waitKey(30) & 0xff if k == 27: # druk op 'ESC' om break cap te stoppen.release() cv2.vernietigenAlleWindows() Deze code werkt door de videostream vast te leggen die wordt gegenereerd door uw PiCam die zowel de grijsmodus als de BGR-kleurmodus weergeeft. Voer vervolgens de code uit met het volgende commando:
python simpleCamTest.py
Druk nu op de [ESC]-toets om het programma te beëindigen. Zorg ervoor dat u op het videovenster klikt voordat u klaar bent. Je zou nu moeten zien dat je camera goed werkt en resultaten laat zien. Als uw camera de foutmelding 'Bevestiging mislukt' weergeeft, gebruik dan de volgende opdracht om dat op te lossen:
sudo modprobe bcm2835-v4l2
Stap 8: Gezichtsdetectie
Je moet weten dat de eerste stap om ons gezichtsherkenningsproject te voltooien, is om de PiCam een gezicht te laten vastleggen. Het moet toch eerst een gezicht detecteren om het in de toekomst te herkennen.
Het gezichtsdetectie-algoritme vereist afbeeldingen met zowel het gezicht als zonder het gezicht om de classifier te trainen en structuren daarvan op te slaan. Gelukkig wordt de OpenCV die je vooraf hebt gedownload geleverd met een detector en trainer. Het heeft ook al een aantal vooraf getrainde classificaties zoals gezicht, ogen, handen, enz. Gebruik de volgende codes om een gezichtsdetector te maken met OpenCV:
import numpy als np import cv2 faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml') cap = cv2.VideoCapture(0) cap.set(3,640) # set Breedte cap.set(4.480) # set Height while True: ret, img = cap.lees() img = cv2.flip(img, -1) grijs = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) gezichten = faceCascade.detectMultiScale(grijs, scaleFactor=1.2, minNeighbours=5, minSize=(20, 20) ) voor (x,y,w,h) in vlakken: cv2.rechthoek(img,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = grijs[y:y+h, x:x+w] roi_color = img[ y:y+h, x:x+w] cv2.imshow('video',img) k = cv2.waitKey(30) & 0xff if k == 27: # druk op 'ESC' om break cap te stoppen.release() cv2.vernietigenAlleWindows() Nu moet u de classificatiefunctie aanroepen met enkele schaalfactoren, parameters en een minimale grootte van het gezicht dat het zal detecteren.
gezichten = faceCascade.detectMultiScale(grijs, scaleFactor=1.2, minBuren=5, minGrootte=(20, 20) )
Deze code werkt door gezichten op een afbeelding te detecteren. Nu wilt u misschien de gezichten markeren met een vorm als een rechthoek. Gebruik daarvoor de volgende code:
voor (x,y,w,h) in vlakken: cv2.rechthoek(img,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = grijs[y:y+h, x:x+w] roi_color = img[ y:y+h, x:x+w]
Zo werkt het dus:
Als de classifier gezichten in de afbeelding vindt, toont het de posities van het gezicht als een rechthoek zoals opgedragen, waar het "h" gebruikt als hoogte en "w" als de breedte en de linker bovenhoeken (x,y). Dat vat onze rechthoek (x,y,w,h) zo'n beetje samen.
Nu u klaar bent met de locaties, maakt u een "ROI" voor gezicht en toont u het resultaat met de functie imshow(). Voer het uit in de python-omgeving met behulp van de Raspberry Pi Terminal:
python gezichtdetectie.py
En het resultaat:
Stap 9: Gegevens opslaan
In dit deel moet u een dataset maken waarin uw programma de verzamelde gegevens over de ID's van het gezicht dat het heeft gedetecteerd, gaat opslaan. Maak hiervoor een map aan (ik gebruik FacialRecognition):
mkdir Gezichtsherkenning
Maak nu een submap met de naam "dataset".
mkdir-gegevensset
Gebruik dan de volgende code:
import cv2 import os cam = cv2.VideoCapture(0) camera.set(3, 640) # set video width cam.set(4, 480) # set video hoogte face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') # Voer voor elke persoon één numeriek gezichts-ID in face_id = input('\n voer gebruikers-ID in en druk op ==> ') print("\n [INFO] Gezichtsopname initialiseren. Kijk in de camera en wacht… ") # Initialiseer individuele bemonstering aantal gezichten = 0 while(True): ret, img = cam.lees() img = cv2.flip(img, -1) # flip videobeeld verticaal grijs = cv2.cvtColor (img, cv2.COLOR_BGR2GRAY) gezichten = gezichtsdetector.detectMultiScale(grijs, 1.3, 5) voor (x,y,w,h) in vlakken: cv2.rechthoek(img, (x,y), (x+w,y+h), (255,0,0), 2) count += 1 # Sla de vastgelegde afbeelding op in de datasets-map cv2.imwrite("dataset/gebruiker." + str(face_id) + '.' + str(telling) + ".jpg", grijs[y:y+h,x:x+w]) cv2.imshow('afbeelding', img) k = cv2.waitKey(100) & 0xff # Druk op 'ESC' om de video af te sluiten als k == 27: break elif count >= 10: # Neem 10 gezichtssamples en stop video-pauze # Doe een beetje cleanup print("\n [INFO] Programma afsluiten en dingen opruimen") cam.release() cv2.vernietigenAlleWindows() Merk op dat we elk van de vastgelegde frames gaan opslaan als een bestand in de submap "dataset":
cv2.imwrite("dataset/gebruiker." + str(face_id) + '.' + str(telling) + ".jpg", grijs[y:y+h,x:x+w]) Daarna moet u de "os" -bibliotheek importeren om het bovenstaande bestand op te slaan. De naam van de bestanden zal een structuur als deze volgen:
Gebruiker.face_id.tellen.jpg,/pre>
De hierboven genoemde code legt slechts 10 afbeeldingen vast voor elke id. Je kunt dat zeker veranderen als je wilt.
Probeer nu het programma uit te voeren en enkele ID's vast te leggen. Zorg ervoor dat u de code telkens uitvoert wanneer u de gebruiker of de bestaande foto wijzigt.
Stap 10: Trainer
In deze stap moet u een OpenCV-functie gebruiken om de OpenCV-herkenner te trainen met de gegevens uit uw dataset. Begin met het maken van een submap om de getrainde gegevens op te slaan.
mkdir-trainer
Voer vervolgens de volgende code uit:
import cv2 importeer numpy als np van PIL import Image import os # Path for face image database path = 'dataset' herkenner = cv2.gezicht.LBPHFaceRecognizer_create() detector = cv2.CascadeClassifier("haarcascade_frontalface_default.xml"); # functie om de afbeeldingen en labelgegevens te krijgen def getImagesAndLabels(path): imagePaths = [os.pad.join(pad,f) voor f in os.listdir(path)] faceSamples=[] ids = [] voor imagePath in imagePaths: PIL_img = Afbeelding.open(afbeeldingspad).convert('L') # converteer het naar grijswaarden img_numpy = np.array(PIL_img,'uint8') id = int(os.pad.split(beeldpad)[-1].splitsen(".")[1]) gezichten = detector.detectMultiScale(img_numpy) for (x,y,w,h) in faces: faceSamples.append(img_numpy[y:y+h,x:x+w]) id's.append(id) return faceSamples,ids print ("\n [INFO] Trainingsgezichten. Het duurt een paar seconden. Wacht… ") faces,ids = getImagesAndLabels(pad) herkenner.trein (gezichten, np.array(ids)) # Sla het model op in trainer/trainer.yml-herkenner.schrijf('trainer/trainer.yml') # herkenner.save() werkte op Mac, maar niet op Pi # Druk het aantal getrainde gezichten af en beëindig het programma print("\n [INFO] 0 gezichten getraind. Programma afsluiten".formaat(len(np.uniek(id)))) Zorg ervoor dat u de PIL-bibliotheek op uw Raspberry Pi hebt geïnstalleerd. Als je dat niet hebt, voer je de volgende opdracht uit:
pip installeren kussen
Hier gebruik ik de LBPH-gezichtsherkenning die bij het OpenCV-pakket wordt geleverd. Volg nu deze regel:
herkenner = cv2.gezicht.LBPHFaceRecognizer_create()
Al uw foto's worden door de functie "getImagesAndLabels" naar de map "dataset" gebracht. Het retourneert 2 arrays met de naam "Ids" en "faces". Nu is het tijd om de herkenner te trainen.
herkenner.trein (gezichten, id's)
Nu ziet u de "trainer".yml” genoemd bestand opgeslagen in de trainermap.
Stap 11: gezichtsherkenning
Het is tijd voor de laatste actie. Na deze stap kan uw herkenner een terugkerende id raden als het gezicht eerder is vastgelegd. Laten we dus onze laatste code schrijven:
import cv2 importeer numpy als np import os herkenner = cv2.gezicht.LBPHFaceRecognizer_create() herkenner.lees('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2.CascadeClassifier(cascadePath); lettertype = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # namen gerelateerd aan ids: voorbeeld ==> Marcelo: id=1, etc names = ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Initialiseer en start realtime video-opnamecamera = cv2.VideoCapture(0) camera.set(3, 640) # set video widht cam.set(4, 480) # set video height # Definieer min. venstergrootte om te worden herkend als een gezicht minW = 0.1*camera.get(3) minH = 0.1*camera.get(4) while True: ret, img =cam.lees() img = cv2.flip(img, -1) # Verticaal grijs spiegelen = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) gezichten = faceCascade.detectMultiScale (grijs, scaleFactor = 1.2, minNeighbours = 5, minSize = (int(minW), int(minH)), ) for(x,y,w,h) in vlakken: cv2.rechthoek(img, (x,y), (x+w,y+h), (0,255,0), 2) id, vertrouwen = herkenner.voorspellen(grijs[y:y+h,x:x+w]) # Controleer of het vertrouwen minder is dan ze 100 ==> "0" is een perfecte match als (betrouwbaarheid < 100): id = names[id] confidence = " 0%".format(round(100 - confidence)) else: id = "unknown" confidence = " 0%".format(round(100 - confidence)) cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2) cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1) cv2.imshow('camera',img) k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video if k == 27: break # Do a bit of cleanup print("\n [INFO] Exiting Program and cleanup stuff") cam.release() cv2.destroyAllWindows() Het programma werkt als een herkenner. De functie voorspellen () neemt verschillende delen van het vastgelegde gezicht als verschillende parameters en keert terug naar de opgeslagen eigenaar terwijl de id wordt weergegeven.
Als het het gezicht niet herkent, wordt "onbekend" op de foto weergegeven.
Zo, Voila!
Eindelijk, Inzichten
Dus zo maak je een Raspberry Pi gezichtsherkenning. Zorg ervoor dat u dit artikel stap voor stap volgt om het beste resultaat te krijgen! Naast deze gezichtsherkenningsclassificatie kunt u nu ook oogherkenning of lachherkenning maken met behulp van verschillende classificaties en functies. Ik heb alle gerelateerde artikelen op internet doorzocht en kwam op deze uit. Dus ik hoop echt dat deze gids je heeft geholpen met de projecten. En ik hoop dat het je gelukt is. Vergeet niet uw mening te vermelden in het opmerkingengedeelte!
