Rozpoznawanie twarzy w czasie rzeczywistym: kompleksowy projekt: 8 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

W moim ostatnim samouczku dotyczącym OpenCV nauczyliśmy się AUTOMATYCZNEGO ŚLEDZENIA OBIEKTÓW WIZJI. Teraz użyjemy naszego PiCam do rozpoznawania twarzy w czasie rzeczywistym, jak widać poniżej:

Ten projekt został wykonany za pomocą tej fantastycznej "Biblioteki Wizji Komputerowej Open Source", OpenCV. W tym samouczku skupimy się na Raspberry Pi (czyli Raspbian jako OS) i Pythonie, ale przetestowałem również kod na My Mac i działa dobrze. OpenCV został zaprojektowany z myślą o wydajności obliczeniowej i silnym nacisku na aplikacje czasu rzeczywistego. Jest więc idealny do rozpoznawania twarzy w czasie rzeczywistym za pomocą aparatu.

Aby stworzyć kompletny projekt na Face Recognition, musimy pracować w 3 bardzo różnych fazach:

1. Wykrywanie twarzy i zbieranie danych
2. Trenuj rozpoznającego
3. Rozpoznawanie twarzy

Poniższy schemat blokowy wznawia te fazy:

Krok 1: BoM - zestawienie materiałów

Główne części:

1. Raspberry Pi V3 - 32,00 USD
2. 5 megapikseli 1080p Sensor OV5647 Mini moduł wideo kamery - 13,00 USD

Krok 2: Instalacja pakietu OpenCV 3

Używam Raspberry Pi V3 zaktualizowanego do ostatniej wersji Raspbian (Stretch), więc najlepszym sposobem na zainstalowanie OpenCV jest skorzystanie z doskonałego samouczka opracowanego przez Adriana Rosebrocka: Raspbian Stretch: Zainstaluj OpenCV 3 + Python na swoim Raspberry Pi.

Wypróbowałem kilka różnych przewodników, aby zainstalować OpenCV na moim Pi. Samouczek Adriana jest najlepszy. Radzę zrobić to samo, podążając krok po kroku za jego wytycznymi.

Po ukończeniu samouczka Adriana powinieneś mieć wirtualne środowisko OpenCV gotowe do uruchomienia naszych eksperymentów na Twoim Pi.

Przejdźmy do naszego wirtualnego środowiska i upewnijmy się, że OpenCV 3 jest poprawnie zainstalowany.

Adrian zaleca uruchamianie polecenia „źródło” za każdym razem, gdy otwierasz nowy terminal, aby upewnić się, że zmienne systemowe zostały poprawnie skonfigurowane.

źródło ~/.profil

Następnie wejdźmy w nasze wirtualne środowisko:

praca na cv

Jeśli widzisz tekst (cv) poprzedzający znak zachęty, jesteś w środowisku wirtualnym cv:

(cv) pi@malina:~$Adrian zwraca uwagę, że wirtualne środowisko cv Python jest całkowicie niezależne i oddzielone od domyślnej wersji Pythona zawartej w pobraniu Raspbian Stretch. Tak więc żadne pakiety Pythona w globalnym katalogu site-packages nie będą dostępne w środowisku wirtualnym cv. Podobnie żadne pakiety Pythona zainstalowane w pakietach witryn cv nie będą dostępne dla globalnej instalacji Pythona

Teraz wpisz w swoim interpreterze Pythona:

pyton

i potwierdź, że używasz wersji 3.5 (lub nowszej)

Wewnątrz interpretera (pojawi się ">>>") zaimportuj bibliotekę OpenCV:

importuj cv2

Jeśli nie pojawiają się żadne komunikaty o błędach, OpenCV jest poprawnie zainstalowany W TWOIM ŚRODOWISKU WIRTUALNYM PYTHON.

Możesz również sprawdzić zainstalowaną wersję OpenCV:

cv2._wersja_

Powinna pojawić się wersja 3.3.0 (lub lepsza wersja, która może zostać wydana w przyszłości). Powyższy Terminal PrintScreen pokazuje poprzednie kroki.

Krok 3: Testowanie aparatu

Po zainstalowaniu OpenCV w swoim RPi przetestujmy, aby upewnić się, że kamera działa poprawnie.

Zakładam, że masz już zainstalowany PiCam na swoim Raspberry Pi.

Wprowadź poniższy kod Pythona w swoim IDE:

importuj numer jako np

import cv2 cap = cv2. VideoCapture(0) cap.set(3, 640) # ustaw szerokość cap.set(4, 480) # ustaw wysokość while(True): ret, frame = cap.read() frame = cv2. flip(ramka, -1) # Odwróć kamerę pionowo szary = cv2.cvtColor(ramka, cv2. COLOR_BGR2GRAY) cv2.imshow('ramka', ramka) cv2.imshow('szary', szary) k = cv2.waitKey(30) & 0xff if k == 27: # naciśnij 'ESC', aby zakończyć break cap.release() cv2.destroyAllWindows()

Powyższy kod przechwyci strumień wideo, który zostanie wygenerowany przez PiCam, wyświetlając zarówno w kolorze BGR, jak iw trybie szarości.

Zwróć uwagę, że obróciłem aparat w pionie ze względu na sposób jego złożenia. Jeśli tak nie jest, skomentuj lub usuń wiersz polecenia „flip”.

Alternatywnie możesz pobrać kod z mojego GitHub: simpleCamTest.py

Aby wykonać, wprowadź polecenie:

python simpleCamTest.py

Aby zakończyć program, musisz nacisnąć klawisz [ESC] na klawiaturze.

Kliknij myszą w oknie wideo, zanim naciśniesz [ESC]

Powyższy obrazek pokazuje wynik.

Niektórzy twórcy napotkali problemy podczas próby otwarcia aparatu (komunikaty o błędach „Potwierdzenie nie powiodło się”). Może się tak zdarzyć, jeśli kamera nie została włączona podczas instalacji OpenCv, a więc sterowniki kamery nie zostały poprawnie zainstalowane. Aby poprawić, użyj polecenia:

sudo modprobe bcm2835-v4l2

Możesz również dodać bcm2835-v4l2 do ostatniego wiersza pliku /etc/modules, aby sterownik ładował się podczas uruchamiania.

Aby dowiedzieć się więcej o OpenCV, zapoznaj się z samouczkiem: ładowanie -video-python-opencv-tutorial

Krok 4: Wykrywanie twarzy

Najbardziej podstawowym zadaniem na Face Recognition jest oczywiście „Wykrywanie twarzy”. Przede wszystkim musisz "schwytać" twarz (Faza 1), aby ją rozpoznać w porównaniu z nową twarzą uchwyconą w przyszłości (Faza 3).

Najczęstszym sposobem wykrywania twarzy (lub dowolnych obiektów) jest użycie „klasyfikatora kaskady Haar”

Wykrywanie obiektów przy użyciu klasyfikatorów kaskadowych opartych na cechach Haar to skuteczna metoda wykrywania obiektów zaproponowana przez Paula Violę i Michaela Jonesa w artykule „Rapid Object Detection using a Boosted Cascade of Simple Features” w 2001 roku. Jest to podejście oparte na uczeniu maszynowym, w którym funkcja kaskadowa jest szkolona z wielu pozytywnych i negatywnych obrazów. Jest następnie używany do wykrywania obiektów na innych obrazach.

Tutaj będziemy pracować z wykrywaniem twarzy. Początkowo algorytm potrzebuje wielu pozytywnych obrazów (obrazy twarzy) i negatywnych obrazów (obrazy bez twarzy), aby wytrenować klasyfikator. Następnie musimy wydobyć z niego cechy. Dobrą wiadomością jest to, że OpenCV jest wyposażony w trener, a także detektor. Jeśli chcesz wyszkolić własny klasyfikator dla dowolnego przedmiotu, takiego jak samochód, samolot itp., możesz użyć OpenCV, aby go utworzyć. Jego pełne szczegóły znajdują się tutaj: Trening klasyfikatorów kaskadowych.

Jeśli nie chcesz tworzyć własnego klasyfikatora, OpenCV zawiera już wiele przeszkolonych klasyfikatorów twarzy, oczu, uśmiechu itp. Te pliki XML można pobrać z katalogu haarcascades.

Dość teorii, stwórzmy wykrywacz twarzy z OpenCV!

Pobierz plik: faceDetection.py z mojego GitHub.

importuj numer jako np

import cv2 faceCascade = cv2. CascadeClassifier('Cascades/haarcascade_frontalface_default.xml') cap = cv2. VideoCapture(0) cap.set(3, 640) # ustaw Width cap.set(4, 480) # ustaw Height podczas 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)) dla (x, y, w, h) w ścianach: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = gray[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: # naciśnij 'ESC', aby zakończyć break cap.release() cv2.destroyAllWindows()

Wierz lub nie, powyższe kilka linijek kodu to wszystko, czego potrzebujesz, aby wykryć twarz za pomocą Pythona i OpenCV.

Porównując z ostatnim kodem użytym do testowania aparatu, zdasz sobie sprawę, że dodano do niego kilka części. Zwróć uwagę na poniższy wiersz:

faceCascade = cv2. CascadeClassifier('Cascades/haarcascade_frontalface_default.xml')

Jest to wiersz, który ładuje „klasyfikator” (który musi znajdować się w katalogu o nazwie „Cascades/”, w katalogu projektu).

Następnie ustawimy kamerę i wewnątrz pętli załadujemy nasze wideo wejściowe w trybie skali szarości (takim samym, jaki widzieliśmy wcześniej).

Teraz musimy wywołać naszą funkcję klasyfikatora, przekazując jej kilka bardzo ważnych parametrów, takich jak współczynnik skali, liczba sąsiadów i minimalny rozmiar wykrytej twarzy.

twarze = twarzCascade.detectMultiScale(szary, współczynnik skali=1,2, minSąsiedzi=5, minRozmiar=(20, 20))

Gdzie,

• szary to wejściowy obraz w skali szarości.
• scaleFactor to parametr określający stopień zmniejszenia rozmiaru obrazu w każdej skali obrazu. Służy do tworzenia piramidy skali.
• minNeighbors to parametr określający, ilu sąsiadów powinien mieć każdy kandydujący prostokąt, aby go zachować. Wyższa liczba daje mniej fałszywych alarmów.
• minSize to minimalny rozmiar prostokąta, który należy uznać za twarz.

Funkcja wykryje twarze na obrazie. Następnie musimy „oznaczyć” twarze na obrazie, używając np. niebieskiego prostokąta. Odbywa się to za pomocą tej części kodu:

dla (x, y, w, h) w ścianach:

cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = szary[y:y+h, x:x+w] roi_color = obraz[y:y+h, x:x+w]

Jeśli zostaną znalezione twarze, zwraca pozycje wykrytych twarzy jako prostokąt z lewym górnym rogiem (x, y) i mający „w” jako szerokość i „h” jako wysokość ==> (x, y, w, h). Proszę zobaczyć powyższe zdjęcie.

Po uzyskaniu tych lokalizacji możemy utworzyć „ROI” (narysowany prostokąt) dla twarzy i zaprezentować wynik za pomocą funkcji imshow().

Uruchom powyższy skrypt Pythona w swoim środowisku Pythona, korzystając z terminala Rpi:

python faceDetection.py

Wynik:

Możesz również dołączyć klasyfikatory do „wykrywania oczu”, a nawet „wykrywania uśmiechu”. W takich przypadkach funkcja klasyfikatora i rysowanie prostokąta zostaną uwzględnione w pętli twarzy, ponieważ nie ma sensu wykrywać oka lub uśmiechu poza twarzą.

Zauważ, że w przypadku Pi, posiadanie kilku klasyfikatorów w tym samym kodzie spowolni przetwarzanie, gdy ta metoda wykrywania (HaarCascades) zużywa dużą ilość mocy obliczeniowej. Na komputerze łatwiej jest go uruchomić.

Na moim GitHubie znajdziesz inne przykłady:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

A na powyższym obrazku widać wynik.

Możesz także skorzystać z poniższego samouczka, aby lepiej zrozumieć wykrywanie twarzy:

Haar Cascade Object Detection Face & Eye OpenCV Python Tutorial

Krok 5: Zbieranie danych

Przede wszystkim muszę podziękować Ramizowi Raja za wspaniałą pracę nad Rozpoznawaniem Twarzy na zdjęciach:

ROZPOZNAWANIE TWARZY ZA POMOCĄ OPENCV I PYTHONA: PRZEWODNIK DLA POCZĄTKUJĄCYCH

a także Anirban Kar, który opracował bardzo obszerny samouczek za pomocą wideo:

ROZPOZNAWANIE TWARZY - 3 części

Naprawdę polecam zajrzeć do obu samouczków.

Mówiąc to, zacznijmy pierwszy etap naszego projektu. To, co tutaj zrobimy, to zaczynając od ostatniego kroku (Wykrywanie twarzy), po prostu utworzymy zbiór danych, w którym będziemy przechowywać dla każdego identyfikatora grupę zdjęć w kolorze szarym z częścią, która została użyta do wykrywania twarzy.

Najpierw utwórz katalog, w którym rozwijasz swój projekt, na przykład FacialRecognitionProject:

mkdir Projekt Rozpoznawania Twarzy

W tym katalogu oprócz 3 skryptów Pythona, które stworzymy dla naszego projektu, musimy mieć zapisane w nim Facial Classifier. Możesz go pobrać z mojego GitHub: haarcascade_frontalface_default.xml

Następnie utwórz podkatalog, w którym będziemy przechowywać nasze próbki twarzy i nazwij go „zestawem danych”:

zbiór danych mkdir

I pobierz kod z mojego GitHub: 01_face_dataset.py

importuj cv2

import os cam = cv2. VideoCapture(0) cam.set(3, 640) # ustaw szerokość wideo cam.set(4, 480) # ustaw wysokość wideo face_detector = cv2. CascadeClassifier('haarcascade_frontalface_default.xml') # Dla każdej osoby, wprowadź jeden numeryczny identyfikator twarzy face_id = input('\n wprowadź identyfikator użytkownika koniec naciśnij ==> ') print("\n [INFO] Inicjowanie przechwytywania twarzy. Spójrz w kamerę i poczekaj …") # Zainicjuj indywidualną liczbę próbkowanych twarzy = 0 while(True): ret, img = cam.read() img = cv2.flip(img, -1) # odwróć obraz wideo pionowo szary = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) faces = face_detector.detectMultiScale(szary, 1.3, 5) dla (x, y, w, h) w ścianach: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) count += 1 # Zapisz przechwycony obraz w folderze zestawów danych cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y+ h, x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # Naciśnij 'ESC', aby wyjść z wideo, jeśli k == 27: złam licznik elif >= 30: # Weź 30 próbek twarzy i zatrzymaj przerwę wideo # Zrób ab to czyszczenie print("\n [INFO] Zamykanie programu i czyszczenie") cam.release() cv2.destroyAllWindows()

Kod jest bardzo podobny do kodu, który widzieliśmy do wykrywania twarzy. Dodaliśmy "polecenie wprowadzania" do przechwytywania identyfikatora użytkownika, który powinien być liczbą całkowitą (1, 2, 3 itd.)

face_id = input('\n wprowadź identyfikator użytkownika, koniec naciśnij ==> ')

I każdą z przechwyconych ramek powinniśmy zapisać jako plik w katalogu „dataset”:

cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", gray[y:y+h, x:x+w])

Zauważ, że aby zapisać powyższy plik, musisz zaimportować bibliotekę "os". Nazwa każdego pliku będzie zgodna ze strukturą:

User.face_id.count.jpg

Na przykład dla użytkownika z face_id = 1, czwarty przykładowy plik w katalogu dataset/ będzie wyglądał mniej więcej tak:

Użytkownik.1.4.jpg

jak widać na powyższym zdjęciu z mojego Pi. Na moim kodzie przechwytuję 30 próbek z każdego identyfikatora. Możesz to zmienić na ostatnim "elifie". Liczba próbek służy do przerwania pętli, w której przechwytywane są próbki twarzy.

Uruchom skrypt Pythona i przechwyć kilka identyfikatorów. Musisz uruchomić skrypt za każdym razem, gdy chcesz zagregować nowego użytkownika (lub zmienić zdjęcia na już istniejący).

Krok 6: Trener

W tej drugiej fazie musimy pobrać wszystkie dane użytkownika z naszego zestawu danych i "treningować" OpenCV Recognizer. Odbywa się to bezpośrednio przez określoną funkcję OpenCV. Rezultatem będzie plik.yml, który zostanie zapisany w katalogu „trainer/”.

Zacznijmy więc tworzyć podkatalog, w którym będziemy przechowywać wytrenowane dane:

trener mkdir

Pobierz z mojego GitHub drugi skrypt Pythona: 02_face_training.py

importuj cv2

import numpy as np z PIL import Image import os # Ścieżka do bazy danych obrazu twarzy path = 'dataset' rozpoznawany = cv2.face. LBPFFaceRecognizer_create() detektor = cv2. CascadeClassifier("haarcascade_frontalface_default.xml"); # funkcja pobierania obrazów i danych etykiet def getImagesAndLabels(path): imagePaths = [os.path.join(path, f) for f in os.listdir(path)] faceSamples= ids = for imagePath in imagePaths: PIL_img = Image.open(imagePath).convert('L') # przekonwertuj go na skalę szarości img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1]. split(".")[1]) twarze = detektor.detectMultiScale(img_numpy) for (x, y, w, h) w twarzach: faceSamples.append(img_numpy[y:y+h, x:x+w]) ids.append(id) return faceSamples, ids print ("\n [INFO] Szkolenie twarzy. Zajmie to kilka sekund. Poczekaj…") faces, ids = getImagesAndLabels(path)cognizer.train(faces, np.array(ids)) # Zapisz model w trainer/trainer.ymlcognizr.write('trainer/trainer.yml') #cognizer.save() działało na Macu, ale nie na Pi # Wydrukuj liczbę wytrenowanych twarzy i wydrukuj program końcowy ("\n [INFO] {0} twarze wytrenowane. Kończę program.format(len(np.unique(ids))))

Potwierdź, czy masz zainstalowaną bibliotekę PIL na swoim Rpi. Jeśli nie, uruchom poniższe polecenie w Terminalu:

pip zainstalować poduszkę

Jako rozpoznawania użyjemy LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) Face Recognizer, zawartego w pakiecie OpenCV. Robimy to w następującym wierszu:

aparat rozpoznawania = cv2.face. LBPFaceRecognizer_create()

Funkcja "getImagesAndLabels (ścieżka)" wykona wszystkie zdjęcia w katalogu: "dataset/", zwracając 2 tablice: "Ids" i "faces". Mając te tablice jako dane wejściowe, „nauczymy nasz aparat rozpoznawania”:

rozpoznawanie.pociąg(twarze, identyfikatory)

W efekcie plik o nazwie „trainer.yml” zostanie zapisany w utworzonym przez nas wcześniej katalogu trainera.

Otóż to! Dołączyłem ostatnie wydrukowane oświadczenie, które wyświetliłem w celu potwierdzenia, liczbę przeszkolonych przez nas twarzy Użytkownika.

Za każdym razem, gdy wykonujesz fazę 1, musisz również wykonać fazę 2

Krok 7: Rozpoznawanie

Teraz doszliśmy do końcowej fazy naszego projektu. Tutaj uchwycimy świeżą twarz w naszym aparacie i jeśli twarz tej osoby została uchwycona i przeszkolona wcześniej, nasz aparat rozpoznawania wykona „prognozę”, zwracając jej identyfikator i indeks, pokazując, jak pewny jest aparat rozpoznawania w tym dopasowaniu.

Pobierzmy skrypt Pythona trzeciej fazy z mojego GitHub: 03_face_recognition.py.

importuj cv2

import numpy as np import os rozpoznawanie = cv2.face. LBPFaceRecognizer_create()cognizer.read('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier(cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #inicjuj licznik id id = 0 # nazwy powiązane z id: przykład ==> Marcelo: id=1, etc names = ['Brak', 'Marcelo', 'Paula', 'Ilza', 'Z ', 'W'] # Zainicjuj i rozpocznij przechwytywanie wideo w czasie rzeczywistym cam = cv2. VideoCapture(0) cam.set(3, 640) # ustaw szerokość wideo cam.set(4, 480) # ustaw wysokość wideo # Określ minimalny rozmiar okna być rozpoznawanym jako twarz minW = 0.1*cam.get(3) minH = 0.1*cam.get(4) podczas gdy True: ret, img =cam.read() img = cv2.flip(img, -1) # Odwróć pionowo gray = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale(gray, scaleFactor = 1.2, minNeighbors = 5, minSize = (int(minW), int(minH)),) for(x, y, w, h) w twarzach: cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, ufność = rozpoznawanie.predict(szary[y:y+h, x:x+w]) # Sprawdź, czy ufność jest mniejsza od nich 100 ==> "0" jest idealnym dopasowaniem, jeśli (pewność < 100): id = names[id] ufność = " {0}% ".format(round(100 - pewność)) else: id = "nieznane" zaufanie = " {0}%".format(round(100 - conf identyfikacja)) cv2.putText(img, str(id), (x+5, y-5), czcionka, 1, (255, 255, 255), 2) cv2.putText(img, str(zaufanie), (x+5, y+h-5), czcionka, 1, (255, 255, 0), 1) cv2.imshow('camera', img) k = cv2.waitKey(10) & 0xff # Naciśnij 'ESC' dla wyjścia wideo if k == 27: break # Wykonaj trochę porządki print("\n [INFO] Wychodzenie z programu i czyszczenie") cam.release() cv2.destroyAllWindows()

Dodajemy tu nową tablicę, więc zamiast ponumerowanych identyfikatorów wyświetlimy „nazwy”:

imiona = ['Brak', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Czyli na przykład: Marcelo zrobi użytkownika o id = 1; Paula: id=2, itd.

Następnie wykryjemy twarz, tak samo jak wcześniej z klasyfikatorem haasCascade. Mając wykrytą twarz możemy wywołać najważniejszą funkcję w powyższym kodzie:

id, zaufanie = rozpoznanie.predict(szara część twarzy)

Rozpoznawanie.predict (), przyjmie jako parametr przechwyconą część twarzy, która ma zostać przeanalizowana, i zwróci jej prawdopodobnego właściciela, wskazując jego identyfikator i stopień ufności aparatu rozpoznawania w związku z tym dopasowaniem.

Zwróć uwagę, że indeks ufności zwróci „zero”, jeśli zostanie uznany za idealne dopasowanie

I na koniec, jeśli aparat rozpoznawania mógł przewidzieć twarz, umieszczamy tekst na obrazie z prawdopodobnym identyfikatorem i ile wynosi „prawdopodobieństwo” w %, że dopasowanie jest prawidłowe („prawdopodobieństwo” = 100 – wskaźnik ufności). Jeśli nie, na twarzy umieszczana jest etykieta „nieznany”.

Poniżej-g.webp

Na powyższym obrazku pokazuję kilka testów wykonanych z tym projektem, gdzie również wykorzystałem zdjęcia do weryfikacji działania rozpoznawania.

Krok 8: Wniosek

Jak zawsze mam nadzieję, że ten projekt pomoże innym odnaleźć drogę do ekscytującego świata elektroniki!

Aby uzyskać szczegółowe informacje i ostateczny kod, odwiedź mój depozyt na GitHub: OpenCV-Face-Recognition

Więcej projektów znajdziesz na moim blogu: MJRoBot.org

Poniżej rzut oka na przyszły samouczek, w którym omówimy „automatyczne śledzenie twarzy i inne metody wykrywania twarzy”:

Saludo z południa świata!

Do zobaczenia w mojej następnej instrukcji!

Dziękuję Ci, Marcelo