Reconocimiento Facial

OpenCV cuenta con la clase FaceRecognizer para facilitarnos el reconocimiento de un rostro presente en una imagen, haremos uso de los clasificadores en cascada para detectar el rostro y luego lo identificaremos con FaceRecognizer usando alguno de los algoritmos disponibles como: EigenFace, FisherFace y LBPH. Nuestro proyecto de Reconocimiento Facial usara LBPH.

1. Detección del Rostro

Utilizaremos uno de los clasificadores en cascada para detectar el rostro presente el la captura de la webcam, funcionara para rostros frontales, también necesitamos detectar los ojos, apliquemos los conceptos aprendidos en Detección de rostros y Detección de Ojos.

Este método será el encargado de obtener las coordenadas del rostro y ambos ojos, devolverá true si los encuentra, esto nos indicara que tenemos un rostro válido para procesar.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

bool GetFaceAndEyes(Mat& frame, Rect& rostro, Rect& lEye, Rect& rEye) { vector<Rect> faces; faceDetector.detectMultiScale(frame, faces, 1.1, 3, CASCADE_FIND_BIGGEST_OBJECT | CASCADE_DO_ROUGH_SEARCH); if(faces.size() == 1) { rostro = faces[0]; Mat face = frame(rostro); int leftX = cvRound(face.cols * EYE_SX); int topY = cvRound(face.rows * EYE_SY); int widthX = cvRound(face.cols * EYE_SW); int heightY = cvRound(face.rows * EYE_SH); int rightX = cvRound(face.cols * (1.0-EYE_SX-EYE_SW)); Mat topLeftOfFace = face(Rect(leftX, topY, widthX,heightY)); Mat topRightOfFace = face(Rect(rightX, topY, widthX, heightY)); vector<Rect> lEyeR, rEyeR; lEyeDetector.detectMultiScale(topLeftOfFace, lEyeR, 1.1, 3, CASCADE_DO_ROUGH_SEARCH); lEyeDetector.detectMultiScale(topRightOfFace, rEyeR, 1.1, 3, CASCADE_DO_ROUGH_SEARCH); if(lEyeR.size() == 1 && rEyeR.size() == 1) { lEye = lEyeR[0]; rEye = rEyeR[0]; lEye.x += leftX; lEye.y += topY; rEye.x += rightX; rEye.y += topY; return true; } } return false; }

2. Procesar el Rostro

Una vez tengamos las coordenadas válidas de los ojos y el rostro procedemos a recortarlo y alinearlo, aplicando transformaciones de rotación, escala y luego recorte, también convertimos la imagen a escala de grises.

Esta función devuelve el rostro alineado, recortado y convertido a escala de grises, indicamos como parámetros las coordenadas obtenidas con la función anterior.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

void CropFace(Mat& face, Mat& warped, Rect leftEye, Rect rightEye) { Point left = Point(leftEye.x + leftEye.width/2, leftEye.y + leftEye.height/2); Point right = Point(rightEye.x + rightEye.width/2, rightEye.y + rightEye.height/2); Point2f eyesCenter = Point2f( (left.x + right.x) * 0.5f, (left.y + right.y) * 0.5f ); // Get the angle between the 2 eyes. double dy = (right.y - left.y); double dx = (right.x - left.x); double len = sqrt(dx*dx + dy*dy); double angle = atan2(dy, dx) * 180.0 / CV_PI; // Hand measurements shown that the left eye center should ideally be at roughly (0.19, 0.14) of a scaled face image. const double DESIRED_RIGHT_EYE_X = (1.0f - DESIRED_LEFT_EYE_X); // Get the amount we need to scale the image to be the desired fixed size we want. double desiredLen = (DESIRED_RIGHT_EYE_X - DESIRED_LEFT_EYE_X) * FaceWidth; double scale = desiredLen / len; // Get the transformation matrix for rotating and scaling the face to the desired angle & size. Mat rot_mat = getRotationMatrix2D(eyesCenter, angle, scale); // Shift the center of the eyes to be the desired center between the eyes. rot_mat.at<double>(0, 2) += FaceWidth * 0.5f - eyesCenter.x; rot_mat.at<double>(1, 2) += FaceHeight * DESIRED_LEFT_EYE_Y - eyesCenter.y; warped = Mat(FaceHeight, FaceWidth, CV_8U, Scalar(128)); warpAffine(face, warped, rot_mat, warped.size()); }

3. Reconocimiento del Rostro

En este punto ya tenemos el rostro que vamos a usar para entrenar nuestro algoritmo, OpenCV cuenta con implementaciones de los algoritmos: Eigenfaces Principal Component Analysis (PCA), Fisherfaces Linear Discriminant Analysis (LDA) y LBPH Local Binary Pattern Histograms, inventado por Ahonen, Hadid and Pietikäinen en el año 2004.

Para este proyecto utilizaremos LBPH, el método createLBPHFaceRecognizer() nos devolverá un objeto de tipo FaceRecognizer que implementa el algoritmo LBPH, del mismo modo podemos usar createFisherFaceRecognizer() o createEigenFaceRecognizer().

3.1 Fase de Entrenamiento

Para agregar un rostro a FaceRecognizer haremos varias capturas del mismo, teniendo en cuenta que debemos capturar rostros diferentes de la misma persona, cuanto más rostros capturemos mejor funcionara nuestro programa, procuremos capturas caras con diferentes gestos, iluminación y rotaciones hacia la derecha o izquierda.

Cada captura la almacenaremos en una Lista de Objetos Mat, cuando tengamos suficientes imágenes iniciamos el entrenamiento llamando al método train de facerecognizer pasamos como parámetros la lista de caras capturadas y una lista de objetos int que representan un identificador para el rostro, llamamos a update para agregar mas rostros.

1 2 3 4

Ptr<FaceRecognizer> model = createLBPHFaceRecognizer(); vector<Mat> rostros; vector<int> ids; map<int , string> names;

Funcionamiento de la aplicación en la fase de entrenamiento (solo si se ha detectado un rostro válido):

• Para iniciar el entrenamiento presionamos la tecla E, esto cuando deseemos agregar una persona a la base de datos.
• Para recolectar un rostro, presionamos la tecla A, cuando estamos en modo entrenamiento podemos recolectar la cantidad de caras que deseemos.
• Para agregar los rostros capturados de la persona que añadiremos a la base de datos presionamos la tecla T, debimos haber capturado por lo menos un rostro. La consola nos pedirá un nombre para identificar el rostro, lo tecleamos y presionamos ENTER al hacer esto volveremos al modo reconocimiento.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

//si el modo entrenamiento esta activo if(entrenado) { Mat nface = CropFace(frame(face), lEye, rEye); //Agregar el rostro y su numero id a las correspondientes listas if(agregarRostro) { rostros.push_back(nface); ids.push_back(identificador); agregarRostro = false; } //entrenar el modelo con los rostros capturados if(entrenar && rostros.size() >= 1) { model->update(rostros, ids); entrenar = agregarRostro = entrenado = false; rostros.clear(); ids.clear(); identificador += 1; } }

3.2 Fase de Reconocimiento

La aplicación estará permanentemente en fase de reconocimiento, siempre que no este en modo entrenamiento, se intentara identificar el rostro que se haya detectado y se mostrara el resultado en la parte de abajo de la imagen.

Para la identificación del rostro FaceRecognizer cuenta con el método predict(face),  le pasamos el rostro que deseamos identificar, este nos devolverá el id correspondiente al rostro.

Podemos usar el método predict(face, id, confidence), id donde se almacenara el identificador, confidence es un valor matemático que indica el nivel de similitud entre los rostros de modo que entre más cercano a cero más confiable es nuestra identificación. 

Estableciendo un valor para threshold indicamos a FeceRecognizer que cualquier identificación con un confidence mayor que threshold sea tomado como desconocido.

1 2 3 4 5 6 7 8 9 10 11 12 13 14

int id = -1; double confidence = 0.0; Mat nface; CropFace(copyFrame(face), nface, lEye, rEye); //calquier confidence mayor que threshold id = -1 //redicir o aumentar este valor segun nos convenga model->set("threshold", 70); model->predict(nface, id, confidence); if(id >= 0) { string msg = names[id] + " : " + to_string((int)confidence); DrawMarker(frame, face, msg , 20); } else DrawMarker(frame, face, "???", 20);

Descargar Reconocimiento Facial