Arcfelismerés OpenCV-vel

A gépek összetettsége az évek során nőtt, és a számítógépek sem jelentenek kivételt. A számítógépek segítettek az emberiségnek rengeteg probléma megoldásában és sok nehéz feladat elvégzésében. Elmúltak azok az idők, amikor az összes számítógép egyszerű számtani művelet volt, a számítógépek ma már a világot hajtják.

A számítógépek annyira összetetté váltak, hogy képezik őket arra, hogy úgy gondolkodjanak, mint az emberek.
Igen!

Ebben a cikkben fogunk tenni valamit, ami ilyen jellegű. Emberként más emberek arcának felismerése egyszerű feladat, és a mai számítógépek képességei ellenére ez nem olyan könnyű a számítógép számára, ezért ki kell képeznünk, hogy ugyanezt megtehesse.

Sok cikk, amelyet látna, megáll az egyszerű arcfelismerés mellett, de ebben a cikkben nem csak az arcfelismerésről, hanem az arcfelismerésről is szó lesz.

Ez azt jelenti, hogy ha a számítógépen két képet mutatnak be rólam, akkor nemcsak felismeri, hogy a kép melyik része az arcom, hanem azt is, hogy mindkét képen én is az vagyok.

Először is először telepítenünk kell az opencv-t a gépeinkre, ami csak akkor hajtható végre, ha Python telepítve van. A cikk nem foglalkozik a Python telepítésével, így ha még nincs meg a gépén, telepítheti a Pythonot a Python webhelyéről.

Az Open CV telepítéséhez ezt a pip paranccsal tehetjük meg.

pip telepítse az opencv-python programot

Ebben a cikkben a numpy csomagot is felhasználjuk, amelyet az OpenCV mellett kell telepíteni a fenti paranccsal.

Ha a numpy nem települt, akkor ezt könnyen megteheti az alábbi paranccsal:

pip install numpy

Az OpenCV telepítésének megerősítéséhez, amikor aktiválja a Python interaktív környezetét, próbálja meg importálni a következő módon:

import cv2

Ha nem kap hibát, akkor folytathatja.

Az arcfelismerés elvégzéséhez három forgatókönyvet írnánk. Az egyik képadatkészlet létrehozásához, egy másik képképzéshez, majd az utolsó az arcok felismeréséhez a számítógépen végzett képzés eredményei alapján.

Szükségünk lenne az Open CV által biztosított Haar Cascade-ra. Ez a fájl az opencv könyvtárból szerezhető be, amely a cv2 / data / haarcascade_frontalface_default.xml a gépemen meg kell egyeznie a gépeddel is. Másolja a fájlt abba a mappába, ahol az arcfelismerést szeretné elvégezni.

Most menjünk bele a dolgok sűrűjébe.
Megpróbáljuk megszerezni a webkameránkat, hogy megszerezzük az adatkészlethez szükséges képeket.

import cv2
vid_cam = cv2.VideoCapture (0)
arc_detektor = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
szám = 0
míg (vid_cam.isOpened ():
ret, image_frame = vid_cam.olvas()
szürke = cv2.cvtColor (image_frame, cv2.COLOR_BGR2GRAY)
arcok = arcdetektor.DetectMultiScale (szürke, 1.3, 5)
(x, y, w, h) esetén:
cv2.téglalap (kép_keret, (x, y), (x + w, y + h), (255,0,0), 2)
szám + = 1
cv2.imwrite ("adatkészlet / Felhasználó."+ str (face_id) + '.'+ str (count) + ".jpg ", szürke [y: y + h, x: x + w])
cv2.imshow ('keret', image_frame)
ha cv2.waitKey (100) & 0xFF == ord ('q'):
szünet
elifszám> 100:
szünet
vid_cam.kiadás()
cv2.destrAllWindows ()

Tehát annak magyarázata, hogy mit tesznek az egyes kódsorok:

import cv2

Ez az a parancs, amely megmondja a pythonnak, hogy tartalmazzon egy külső könyvtárat, amelyet ebben a kódban használni kell, ebben az esetben ez az Open CV.

vid_cam = cv2.VideoCapture (0)

Ez a kód felhívja az importált Open CV könyvtárat a rögzítés megkezdéséhez, és a webkamera ekkor indul. Ha az Open CV nem támogatja az Ön webkameráját, akkor a kód itt meghiúsul.

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

Ahhoz, hogy képfelismerést hajtsunk végre, erre a kódra van szükség. A nyitott önéletrajz a 'haarcascade_frontalface_default parancsot használja.xml 'a kaszkádosztályozáshoz. A kapott objektumot ezután eltároljuk az face_detector változóban.

face_id = 1

Itt van az arc azonosítójának beállítása, így az első arc 1-es azonosítóval rendelkezik.

szám = 0

Pár képet fogunk készíteni, mivel az Open CV-nek képeket kell képeznie az arcok felismerése érdekében, a számláló változó képszámként szolgál.

míg (vid_cam.isOpened ():

Ez lehetővé teszi a következő műveletek folytatását, feltéve, hogy a videokamera fel van nyitva. Az isOpened () metódus True vagy False értéket ad vissza.

ret, image_frame = vid_cam.olvas()

Itt a vid_cam.A read () megnézi a videofelvételt, majd rögzíti az image_frame változóban tárolt keretet, ha a művelet sikeres, a logikai True visszaadja és tárolja a ret változóban

szürke = cv2.cvtColor (image_frame, cv2.COLOR_BGR2GRAY)

A cvtColor () metódust használják a képkeret átalakítására a kívánt színtípusra. Ebben az esetben szürkeárnyalattá alakítottuk át.

arcok = arcdetektor.DetectMultiScale (szürke, 1.3, 5)

Ez ellenőrzi, hogy vannak-e különböző méretű keretek, és megpróbálja méretarányba állítani őket, ezt alkalmazzák azon a változón, amelyre a Haar Cascade-et alkalmazták.

(x, y, w, h) esetén:

Itt végignézzük az arcokat és méreteit, ahol x és y a koordinátákat, w és h pedig a szélességet és a magasságot jelenti.

cv2.téglalap (kép_keret, (x, y), (x + w, y + h), (255,0,0), 2)

Ne feledje, hogy továbbra is a videokamerával dolgozunk, a videokamera a fenti szükségletek szerint kivágja a kép szükség szerinti részét.

szám + = 1

Amint ez megtörtént, a számlálónak számító változó növekszik.

cv2.imwrite ("adatkészlet / Felhasználó."+ str (face_id) + '.'+ str (count) + ".jpg ", szürke [y: y + h, x: x + w])

A levágott képet a felhasználó (face_id) névvel menti a rendszer.(számol).JPG-t, és tedd egy dataset nevű mappába.

cv2.imshow ('keret', image_frame)

Mentés után ez a kód biztosítja, hogy a kép videokeret téglalap alakú legyen az egyén arcán, miután az arcfelismerés megtörtént.

ha cv2.waitKey (100) & 0xFF == ord ('q'):
szünet

Minden egyes kép után a felhasználó megszakíthatja a program további képeit, amelyek a billentyűzeten található „q” megnyomásával legalább 100 ms.

elifszám> 100:
szünet

Ez a kód az, hogy megakadályozza a videó működését abban a pillanatban, amikor 100 kép készült, függetlenül attól, hogy a felhasználó többet akar-e készíteni vagy sem.

vid_cam.kiadás()

Itt a webkamera zárva van, és nem csak a képek készítését állítják meg.

cv2.destrAllWindows ()

Ezután az összes OpenCV megnyitott ablak megsemmisült, és a kód a végére fut.

Most, hogy ezzel végeztünk, betaníthatjuk a képadatkészletet:

import cv2, os
importálja a numpy-t np-ként
a PIL import képből
felismerő = cv2.arc.createLBPHFaceRecognizer ()
detektor = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");
def getImagesAndLabels (elérési út):
imagePaths = [os.pálya.csatlakozzon (útvonal, f) f-hez az os-ban.listdir (elérési út)]
faceSamples = []
azonosítók = []
az imagePath számára az imagePaths programban:
PIL_img = Kép.nyitott (imagePath).konvertálás ('L')
img_numpy = np.tömb (PIL_img, 'uint8')
id = int (os.pálya.split (imagePath) [- 1].hasított(".") [1])
arcok = detektor.DetectMultiScale (img_numpy)
(x, y, w, h) esetén:
arcMinták.függelék (img_numpy [y: y + h, x: x + w])
azonosítók.függelék (id)
return faceMinták, azonosítók
faces, ids = getImagesAndLabels ('adatkészlet')
felismerő.vonat (arcok, np.tömb (azonosítók))
felismerő.mentés ('edző / tréner.yml ')

Menjünk előre, és magyarázzuk el ezt a kódot is:

import cv2, os

Csakúgy, mint a másik kód, itt is importáljuk az OpenCV-t és az OS-t, amelyekre a fájl elérési útjára lenne szükségünk.

importálja a numpy-t np-ként

Importáljuk a numerikus könyvtárat is, amelyet a mátrix kiszámításához használnánk (a mátrix csak tömbök elrendezése).

a PIL import képből

Importáljuk a Python Image Library-t, majd onnan kapjuk a Image Library-t is ebből a csomagból.

felismerő = cv2.arc.createLBPHFaceRecognizer ()

Ez azt jelenti, hogy a createLBPHFaceRecognizer () metódust alkalmazzuk a cv2 fájlra.arc objektum, ez megkönnyítené az arcok felismerését, mivel nem kell kitalálnunk saját algoritmusainkat.

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

Ha követte az oktatóanyagot, akkor már korábban is találkozott ezzel. Segít az arcfelismerésben a „haarcascade_frontalface_default” használatával.xml ”a kaszkádosztályozáshoz.

def getImagesAndLabels (elérési út):

Most elkezdjük a képképzést, ezért létrehozunk egy funkciót.

imagePaths = [os.pálya.csatlakozzon (útvonal, f) f-hez az os-ban.listdir (elérési út)]

Ez a kód ellenőrzi a fájl aktuális könyvtárát, és ellenőrzi a képfájlokat, majd felveszi őket ebbe a listába.

faceSamples = []

Ez inicializálja a minták listáját, ezen a ponton üres, de a kód futtatásakor arcokat adunk hozzá.

azonosítók = []

Inicializálja az azonosítók listáját, amely kezdetben üres.

az imagePath számára az imagePaths programban:

Emlékezzen arra a kódra, amely a képfájlokat ellenőrizte a könyvtárban? Igen? Most mindegyik fájlt áttekintjük és műveleteket hajtunk végre rajtuk.

PIL_img = Kép.nyitott (imagePath).konvertálás ('L')

Az első dolog, amit tennünk kell a képpel, az az, hogy szürkeárnyalatosra konvertáljuk, és ez a kód ezt teszi.

img_numpy = np.tömb (PIL_img, 'uint8')

A szürkeárnyalatos kép csak egy sor szám, egy helyen, ezért létrehozunk belőlük egy numpy tömböt, és hozzárendeljük egy változóhoz.

id = int (os.pálya.split (imagePath) [- 1].hasított(".") [1])

Ha felidézi a képeket előállító fájlt, akkor emlékeztetne arra, hogy a fájlokat Felhasználónak (face_id) neveztük el.számol.jpg. Tehát itt felosztjuk a neveket a.”, Majd kibontjuk a face_id elemet, és itt hozzárendelünk egy változóhoz. Szükségünk lenne az azonosítóra az elismeréshez.

arcok = detektor.DetectMultiScale (img_numpy)

A numpy tömbből a DetectMultiScale () metódus megpróbálja felismerni az arcokat a numpy tömbben található mintából. Ezután hozzárendeli az arcok változó értékeit.

(x, y, w, h) esetén:

Itt végignézzük a változóhoz rendelt értékeket. Az itt megadott értékek az x és y koordináták, amelyeket kiindulási pontként vehetünk fel, majd w és h a szélesség, illetve a magasság értéke.

arcMinták.függelék (img_numpy [y: y + h, x: x + w])

Korábban készítettünk egy listát az arcmintákról, de az üres volt. Itt hozzá kell adnunk arcokat ehhez a listához, és hozzáadjuk az y-t h-hoz, hogy megkapjuk az y koordináták két értékét, és ugyanez megtörténik x-re.

azonosítók.függelék (id)

Most van egy arcunk az arcminták listájában, így megkapjuk az azonosítóját, és csatoljuk az ids listához is.

return faceMinták, azonosítók

Aztán mindezek után visszaküldjük az arcminták és az azonosítók listáját.

faces, ids = getImagesAndLabels ('adatkészlet')

Ne feledje, hogy a getImagesAndLabels () csak egy függvény. Tehát itt kell meghívnunk a függvényt, és a visszatérési értékek el lesznek mentve az arcok és az ids változókban.

felismerő.vonat (arcok, np.tömb (azonosítók))

Itt történik az igazi képzés. Valamikor korábban alkalmaztuk a createLBPHFaceRecognizer () metódust és hozzárendeltük egy felismerő változóhoz. Képzési idő van!

felismerő.mentés ('edző / tréner.yml ')

Edzés után meg kell mentenünk a képzés eredményeit.
A kód futtatása után létrehoz egy oktató nevű fájlt.yml, amelyet aztán az arcfelismerő kód használna.

Itt van az arcfelismerési kód:

import cv2
importálja a numpy-t np-ként
felismerő = cv2.arc.createLBPHFaceRecognizer ()
felismerő.terhelés ('edző / edző.yml ')
cascadePath = "haarcascade_frontalface_default.xml "
faceCascade = cv2.CascadeClassifier (cascadePath)
font = cv2.FONT_HERSHEY_SIMPLEX
bütyök = cv2.VideoCapture (0)
míg True:
ret, im = bütyök.olvas()
szürke = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
arcok = faceCascade.DetectMultiScale (szürke, 1.2,5)
(x, y, w, h) esetén:
cv2.téglalap (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)
Id = felismerő.előrejelzés (szürke [y: y + h, x: x + w])
ha (Id == 1):
Id = "Nazmi"
más:
Id = "Ismeretlen"
cv2.téglalap (im, (x-22, y-90), (x + w + 22, y-22), (0,255,0), -1)
cv2.putText (im, str (Id), (x, y-40), font, 2, (255,255,255), 3)
cv2.imshow ('im', im)
ha cv2.waitKey (10) & 0xFF == ord ('q'):
szünet
bütyök.kiadás()
cv2.destrAllWindows ()

Ha a cikket a kezdetektől fogva követte, ezt már korábban is megtettük. Ha nem tette meg kedvesen.

felismerő.terhelés ('edző / edző.yml ')

Ne feledje, hogy betanítottuk a felismerőt és elmentettünk egy fájlt? Igen? Most betöltjük azt a fájlt.

cascadePath = "haarcascade_frontalface_default.xml "

A haarcascade fájllal dolgoznánk, és itt hozzárendeltük a fájl nevét egy változóhoz.

# Hozzon létre osztályozót előre elkészített modellből
faceCascade = cv2.CascadeClassifier (cascadePath)

Itt végezzük el a Cascade osztályozást a haarcascade fájlon.

font = cv2.FONT_HERSHEY_SIMPLEX

Beállítottuk azt a betűtípust, amelyet akkor használnánk, amikor a kód felismeri a kép arcát és megjeleníti a nevet.

bütyök = cv2.VideoCapture (0)

Voltunk már itt, de ezúttal itt az ideje, hogy felismerjük az arcokat. Ha nem tudja, mit csinál ez a kód, elindítja a webkamerát.

míg True:
ret, im = bütyök.olvas()
szürke = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
arcok = faceCascade.DetectMultiScale (szürke, 1.2,5)
(x, y, w, h) esetén:

Mindezeket már korábban elvégeztük. Kérjük, ellenőrizze a képek mentésére használt kódot, ha nem tudja, mi a kód.

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

Tehát ez segít a webkamerának észlelni az arcok helyét, és téglalapot helyez el az arc jelzésére.

Id = felismerő.előrejelzés (szürke [y: y + h, x: x + w])

Rendszerint betöltöttük a vonatfájlt a felismerőbe, így az már képes felismerni az arcot.

ha (Id == 1):
Id = "Magam"
más:
Id = "Ismeretlen"

Miután megpróbálta felismerni, hogy mi az arc, ellenőrzi az azonosítót, és megnézi, hogy létezik-e. Itt az Id értéke annak a neve lenne, akinek tulajdonában volt egy ilyen azonosító a képadatkészlet létrehozásakor.

cv2.téglalap (im, (x-22, y-90), (x + w + 22, y-22), (0,255,0), -1)
cv2.putText (im, str (Id), (x, y-40), font, 2, (255,255,255), 3)

A kód, miután megtalálta az azonosító tulajdonosát, téglalapot rajzol az arc köré, és elhelyezi az arc tulajdonosának nevét. Arcfelismerés!

cv2.imshow ('im', im)

Itt a videokeret a behatárolt négyszöggel jelenik meg.

ha cv2.waitKey (10) & 0xFF == ord ('q'):
szünet
bütyök.kiadás()
cv2.destrAllWindows ()

Tehát ha elkészült, a 'q' gomb megnyomásával leállíthatja a programot, ezzel leállítja és bezárja a webkamerát.

Itt van, a webkamera mostantól felismeri az arcokat, és bármikor használhatja. A webkamera használatán kívül képet is betölthet, de ehhez más, a cikkben megfogalmazott lépésekre van szükség.

Megtalálja a github repo-nál használt forráskódot. Akkor is tweeteljen minket, ha észrevétele van, vagy szeretné megvitatni a @linuxhint alkalmazást