Rilevamento del viso e del movimento usando la visione per computer

OpenCV (Open Source Computer Vision Library) è un modulo Python utilizzato per la visione del computer. È un modulo immenso con capacità eccezionali. Possiamo fare molte cose con la visione artificiale e alcune delle più grandi sono il riconoscimento del volto e il rilevamento del movimento.

In questo tutorial, imparerai a scrivere codice per rilevare facce in immagini, video e movimento.

Per evitare tutti i tipi di errori e problemi, scaricheremo il file OpenCV da GitHub su https: // github.com/opencv/opencv. Useremo alcuni dei file all'interno per completare il codice.

Rilevamento del viso usando immagini

All'interno del file GitHub OpenCV, è disponibile una sottodirectory (OpenCv-Master \ Samples \ Data) in cui sono disponibili immagini di esempio e video con cui lavorare. Useremo foto e video trovati all'interno di questa directory. In particolare, userò la Lena.file jpg. Lo copierò e incollerò nella mia directory di lavoro Pycharm (nel mio caso, è C: \ Users \ mai \ PyCharmProjects \ PythonProject). Ora, iniziamo il rilevamento del viso su questa immagine.

Innanzitutto, cariciamo i moduli di cui abbiamo bisogno:

Importa Numpy come NP
Importa CV2

Il file che utilizzeremo si trova su OpenCV-Master \ Data \ HaarCascades \ HaarCascade_FrontalFace_Default.XML del file scaricato da GitHub. Dobbiamo mettere un collegamento al file Haarcascade come segue:

face_cascade = cv2.CascadeClassifier ('C: \\ Users \\ Never \\ download \\ OpenCv-Master \\ Data \\ HaarCascades \\ haarcascade_frontalface_default.XML ')

Carica la foto per eseguire il rilevamento del viso usando il CV2.metodo imread ().

Immagine = Cv2.imread ('Lena.jpg ')

Il nostro prossimo obiettivo è trasformare la foto in scala di grigi. Quest'ultimo è fatto usando il CV2.Metodo cvtColor (). Questo metodo prende due argomenti. Il primo argomento è il nome del file da convertire e il secondo argomento è il formato di conversione. In questo caso, useremo CV2.Color_bgr2Gray per convertirlo in un formato in scala di grigi.

grigio = cv2.CVTCOLOR (Image, CV2.Color_bgr2gray)

Usiamo quindi la funzione DetectMultScale () per rilevare oggetti o, in questo caso, Faces. Qui, diremo a Python face_cascade.DetectMultScale (), che rileverà i volti poiché questo è ciò che nel parametro Face_Cascade. La funzione DetectMultScale () prende alcuni argomenti, l'immagine, un fattore di ridimensionamento, il numero minimo di vicini, flag, dimensioni minime e dimensioni massime.

facce = face_cascade.DetectMultSiscal (grigio, 1.5, 5)

Per posizionare una scatola rettangolare attorno al viso, dobbiamo usare il CV2.Metodo rettangolo (). Usando questo metodo, dobbiamo dargli alcuni argomenti. Il primo argomento è l'immagine su cui si desidera, il secondo argomento è il punto di partenza del rettangolo, il terzo argomento è l'endpoint del rettangolo, il quarto argomento è il colore del rettangolo e il quinto argomento è lo spessore di la linea. In questo caso, W è per larghezza, h è per altezza e xey sono il punto di partenza.

per (x, y, w, h) in facce:
Cv2.rettangolo (immagine, (x, y), (x+w, y+h), (0,255,0), 3)

Infine, mostriamo l'immagine usando il CV2.Metodo imshow (). Usiamo anche il CV2.WaitKey (0) per impostare un tempo di attesa infinito e utilizzare il CV2.Metodo DestroyAllWindows () per chiudere la finestra.

Cv2.imshow ('immagine', immagine)
Cv2.WaitKey (0)
Cv2.DestroyAllWindows ()

Rilevamento del viso utilizzando video/webcam

In questo caso, rileveremo i volti in tempo reale utilizzando una webcam o un video. Ancora una volta, iniziamo importando i moduli richiesti.

Importa Numpy come NP
Importa CV2

Successivamente, dobbiamo specificare la posizione dei file Haarcascade. Lo facciamo come segue (esattamente come per l'immagine):

face_cascade = cv2.CascadeClassifier ('C: \\ Users \\ Never \\ download \\ OpenCv-Master \\ Data \\ HaarCascades \\ haarcascade_frontalface_default.XML ')

Ora, dobbiamo specificare il video che vogliamo affrontare usando il CV2.Metodo VideOCapture (). Nel mio caso, ho scelto di affrontare un video che avevo e ho inserito il nome del video. Se vuoi gestire le webcam, metteresti uno 0 invece del nome del file video.

Video = CV2.Videocapt ("Video.mp4 ")

Quindi iniziamo un po '. In tempo vero, chiediamo al programma di rilevare i volti fino a quando non ci fermiamo. In prima istanza, leggiamo il file video utilizzando la funzione read ().

mentre è vero:
Ret, Image = Video.Leggere()

Proprio come nella sezione precedente, dobbiamo trasformare le immagini o i frame in scala di grigi per facilitare il rilevamento. Usiamo il CV2.Metodo cvtColor () per modificare i frame in grigio.

grigio = cv2.CVTCOLOR (Image, CV2.Color_bgr2gray)

Per rilevare i volti, utilizziamo la funzione DetectMultScale (). Ancora una volta, richiedono gli stessi parametri della sezione precedente.

facce = face_cascade.DetectMultSiscal (grigio, 1.1, 4)

Per posizionare i rettangoli attorno ai volti, usiamo il CV2.Metodo rettangolo (). Questo è simile alla sezione precedente.

per (x, y, w, h) in facce:
Cv2.rettangolo (immagine, (x, y), (x+w, y+h), (255, 0, 0), 2)

Mostriamo quindi i frame usando il CV2.Metodo imshow (). Questo metodo prende due argomenti, il primo è il nome del frame e il secondo è il frame da visualizzare.

Cv2.imshow ('immagine', immagine)

Inseriamo quindi una clausola, se l'utente preme il tasto ESC (o 27), il codice uscirà dal loop.

Se Cv2.WaitKey (0) e 0xFF == 27:
rottura

Infine, rilasciamo il video utilizzando la funzione di rilascio ().

video.pubblicazione()

Rilevamento del movimento

Il rilevamento del movimento è fantastico! Ciò che significa è che con Python e una buona webcam, possiamo creare la nostra fotocamera di sicurezza! Quindi, iniziamo.

Importa Numpy come NP
Importa CV2

Sceglierò un video dai campioni (OpenCv-Master \ Samples \ Data) del file GitHub.

Video = CV2.Videocapt ("vtest.avi ")

Al fine di rilevare il movimento, ciò su cui fondamentalmente facciamo affidamento è la differenza nei valori dei pixel di due immagini, un'immagine di riferimento e una seconda immagine o frame. Quindi, creiamo due immagini, frame1 e frame2.

ret, frame1 = video.Leggere()
ret, frame2 = video.Leggere()

Mentre il video viene aperto o utilizzando la funzione isopened (), iniziamo un ciclo.

mentre video.è aperto():

Calcoliamo prima la differenza assoluta tra Frame1 e Frame2 usando il CV2.Metodo Absdiff (). Ovviamente, ci vogliono due argomenti, il primo e il secondo frame.

Differenza = CV2.Absdiff (frame1, frame2)

Poiché le cose sono più facili in bianco e nero, trasformeremo la differenza in scala di grigi usando il CV2.Metodo cvtColor (). Il CV2.Il metodo cvtColor () prende due argomenti, il primo è la cornice o l'immagine e il secondo è la trasformazione. In questo caso, useremo CV2.Color_bgr2Gray.

grigio = cv2.cvtColor (differenza, CV2.Color_bgr2gray)

Una volta che l'immagine è in scala di grigi, dobbiamo successivamente offuscare l'immagine per rimuovere il rumore usando il CV2.Metodo GaussianBlur (). Il CV2.Il metodo GaussianBlur () prende alcuni argomenti: l'immagine di origine per sfuggire, l'immagine di output, la dimensione del kernel gaussiano, la deviazione standard del kernel lungo l'asse X, la deviazione standard del kernel lungo l'asse y e il tipo di bordo.

Blur = CV2.GaussianBlur (Gray, (5,5), 0)

Successivamente, posizioniamo un valore di soglia usando il CV2.Metodo della soglia (). Questa tecnica isolerà il movimento segmentando lo sfondo e il primo piano (o movimento). Il CV2.Il metodo di soglia () richiede quattro argomenti: l'immagine, il valore di soglia, il valore massimo da utilizzare con Thresh_binary e Thresh_binary_inv e il tipo di soglia.

_, soglia = cv2.Soglia (Blur, 20, 255, CV2.Thresh_binary)

Successivamente, dilatiamo usando il CV2.Metodo dilate () che prende 6 argomenti al massimo: l'immagine, il kernel, l'ancora, le iterazioni, il tipo di confine e il valore del bordo.

Dilate = CV2.Dilate (soglia, nessuna, iterazioni = 3)

Il CV2.Il metodo findContours () fa esattamente ciò che significa, trova contorni. Ci vogliono tre argomenti: l'immagine di origine, la modalità di recupero e il metodo di approssimazione del contorno.

contorno, _ = cv2.findContours (Dilate, CV2.Retr_tree, v2.Chain_approx_simple)

Il CV2.Il metodo DrawContours () viene utilizzato per disegnare i contorni. Ci vogliono alcuni argomenti: l'immagine, i contorni, il contouridx (questo valore è negativo se tutti i contorni sono disegnati), il colore, lo spessore, il tipo di linea, la gerarchia, il livello massimo e l'offset.

Cv2.DrawContours (frame1, contorno, -1, (0, 0, 255), 2)

Finalmente, mostriamo l'immagine usando il CV2.Metodo imshow ().

Cv2.imshow ("immagine", frame1)

Ora, impostiamo il frame iniziale 2 come primo frame e leggiamo il video per un nuovo frame che inseriamo nel parametro Frame2.

frame1 = frame2
ret, frame2 = video.Leggere()

Se viene premuto il tasto "Q", uscire dal loop:

Se Cv2.WaitKey (40) == Ord ('Q'):
rottura
video.pubblicazione()

Il codice nel suo insieme per il rilevamento del movimento sembrerebbe qualcosa del genere:

Importa Numpy come NP
Importa CV2
Video = CV2.Videocapt ("vtest.avi ")
ret, frame1 = video.Leggere()
ret, frame2 = video.Leggere()
mentre video.è aperto():
Differenza = CV2.Absdiff (frame1, frame2)
grigio = cv2.cvtColor (differenza, CV2.Color_bgr2gray)
Blur = CV2.GaussianBlur (Gray, (5,5), 0)
_, soglia = cv2.Soglia (Blur, 20, 255, CV2.Thresh_binary)
Dilate = CV2.Dilate (soglia, nessuna, iterazioni = 3)
contorno, _ = cv2.findContours (Dilate, CV2.Retr_tree, CV2.Chain_approx_simple)
Cv2.DrawContours (frame1, contorno, -1, (0, 0, 255), 2)
Cv2.imshow ("immagine", frame1)
frame1 = frame2
ret, frame2 = video.Leggere()
Se Cv2.WaitKey (40) == Ord ('Q'):
rottura
video.pubblicazione()

È solo così semplice! Alcune righe di codice e possiamo fare i nostri programmi di riconoscimento e rilevamento del movimento. Alcune linee aggiuntive e possiamo persino convincerli a parlare (diciamo usando PTTSX3) e creare le nostre telecamere di sicurezza!

Codice felice!