Haar cascades

Il s'agit d'une méthode d'apprentissage automatique dans laquelle une fonction dite en cascade est entraînée sur une grande quantité d'images positives qui incluent inclut l'objet souhaité ainsi que les images négatives sur lesquelles n'apparaît pas l'objet souhaité.

Nous introduisons le concept de traits de Haar qui sont obtenus par les cases noires et blanches ci-dessous qui agissent comme des noyaux convolutifs.

Les caractéristiques sont des valeurs uniques reçues en soustrayant la somme des pixels sous les rectangles blancs de la somme des pixels sous les rectangles noirs.

Le produit d'une convolution est le résultat de deux fonctions qui s'influencent l'une l'autre.

Il faut réaliser la somme des pixels dans la partie blanche et la partie noire des cases et les différencier pour produire une valeur unique.

La sélection des fonctionnalités s'effectue en essayant les différentes fonctionnalités de Haar et en vérifiant lesquelles produisent la plus grande valeur pour la différence entre les sommes de pixels entre les rectangles noir et blanc.

Les fonctionnalités de type Haar utilient l'algorithme Adaboost qui trouve un seuil optimal pour classer correctement les images d'entraînement.

Mais placer l'un de ceux-ci quelque part, même sur la meilleure position possible, entraînera encore une erreur puisque toutes les images dans les ensembles positifs et négatifs diffèrent les unes des autres.

Les caractéristiques de Haar avec les plus petits taux d'erreur sont choisies comme classificateurs.

Le nombre final de fonctionnalités peut être assez important malgré les mesures prises, c'est pourquoi les inventeurs ont introduit le concept de cascade de classificateurs.

l'algorithme Adaboost est utilisé lors de la détection car utiliser beaucoup de fonctionnalités prends énormément de temps.

import numpy as np
import cv2
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
 
def showimage(myimage, figsize=[10,10]):
    if (myimage.ndim>2):  #This only applies to RGB or RGBA images (e.g. not to Black and White images)
        myimage = myimage[:,:,::-1] #OpenCV follows BGR order, while matplotlib likely follows RGB order
         
    fig, ax = plt.subplots(figsize=figsize)
    ax.imshow(myimage, cmap = 'gray', interpolation = 'bicubic')
    plt.xticks([]), plt.yticks([])  # to hide tick values on X and Y axis
    plt.show()
 
plt.rcParams['figure.figsize'] = [10, 40]
 
# cascades: https://github.com/opencv/opencv/tree/master/data/haarcascades
face_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_eye.xml')
glasses_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_eye_tree_eyeglasses.xml')
smile_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_smile.xml')
 
img = cv2.imread('images/pexels-tim-mossholder-3063478.jpg')
showimage(img)
 
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
showimage(gray)
 
# default MultiScale paramters: scaleFactor=1.1, minNeighbors=3
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for(x, y, w, h) in faces:
    img = cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 3)
    roi_gray = gray[y:y+h, x:x+w]
    roi_color = img[y:y+h, x:x+w]
 
    smiles = smile_cascade.detectMultiScale(roi_gray, minNeighbors=20)
    for(sx, sy, sw, sh) in smiles:
        cv2.rectangle(roi_color, (sx,sy), (sx+sw,sy+sh), (0,0,255), 3)
 
    glasses = glasses_cascade.detectMultiScale(roi_gray, scaleFactor=1.04, minNeighbors=1)
    for(gx, gy, gw, gh) in glasses:
        cv2.rectangle(roi_color, (gx,gy), (gx+gw,gy+gh), (0,255,0), 2)
 
    eyes = eye_cascade.detectMultiScale(roi_gray)
    for(ex, ey, ew, eh) in eyes:
        cv2.rectangle(roi_color, (ex,ey), (ex+ew,ey+eh), (0,255,255), 3)
 
# plotting        
plt.xticks([])
plt.yticks([])
 
face_patch = mpatches.Patch(color='blue', label='Faces')
smile_patch = mpatches.Patch(color='red', label='Smiles')
eye_patch = mpatches.Patch(color='yellow', label='Eyes')
glass_patch = mpatches.Patch(color='green', label='Glasses')
plt.legend(handles=[face_patch, smile_patch, eye_patch, glass_patch], 
           loc='lower right', fontsize=12)
 
imgplot = plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
 
cap = cv2.VideoCapture(0)
 
k = 0;
 
while True:
    ret, img = cap.read()
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
 
    for(x, y, w, h) in faces:
        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]
 
        eyes = eye_cascade.detectMultiScale(roi_gray)
        for(ex, ey, ew, eh) in eyes:
            cv2.rectangle(roi_color, (ex,ey), (ex+ew,ey+eh), (0,255,0), 2)
 
        smiles = smile_cascade.detectMultiScale(roi_gray, scaleFactor=1.8, minNeighbors=20)
        for(sx, sy, sw, sh) in smiles:
            cv2.rectangle(roi_color, (sx,sy), (sx+sw,sy+sh), (0,0,255), 2)
 
    cv2.imshow('img', img)
 
    k += 1
    if k == 27:
        break
 
cap.release()
cv2.destroyAllWindows()