La Reconnaissance des visages sur Android

Mise à jour

L'article suivant a été écrit par Petter Christian Bjelland, de sorte que tout le crédit qui lui revient. Je vous poste ici, parce que son blog semble être en mode Maintenance pour le moment, mais je pense que c'est le partage de la valeur.

Faire de la reconnaissance faciale avec JavaCV (à partir de http://pcbje.com)

Je ne pouvais pas trouver n'importe quel tutoriel sur la façon d'effectuer la reconnaissance du visage à l'aide d'OpenCV et de Java, j'ai donc décidé de partager une solution viable ici. La solution est très inefficace dans sa forme actuelle, le modèle de formation est construit à chaque exécution, cependant, il montre ce qui est nécessaire pour le faire fonctionner.

La classe ci-dessous prend deux arguments: Le chemin vers le répertoire contenant la formation des visages et le chemin vers l'image que vous voulez classer. Non pas que toutes les images doit être de la même taille et de même que les visages déjà être coupées de leurs images originales (Prendre un coup d'oeil ici si vous n'avez pas fait la détection de visage encore).

Pour la simplicité de ce post, la classe exige également que la formation des images ont le nom de fichier format: <label>-rest_of_filename.png. Par exemple:

1-jon_doe_1.png 
1-jon_doe_2.png 
2-jane_doe_1.png 
2-jane_doe_2.png 

... et ainsi de suite.

Le code:

import com.googlecode.javacv.cpp.opencv_core;
import static com.googlecode.javacv.cpp.opencv_highgui.*;
import static com.googlecode.javacv.cpp.opencv_core.*;
import static com.googlecode.javacv.cpp.opencv_imgproc.*;
import static com.googlecode.javacv.cpp.opencv_contrib.*;
import java.io.File;
import java.io.FilenameFilter;
public class OpenCVFaceRecognizer {
public static void main(String[] args) {
String trainingDir = args[0];
IplImage testImage = cvLoadImage(args[1]);
File root = new File(trainingDir);
FilenameFilter pngFilter = new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.toLowerCase().endsWith(".png");
}
};
File[] imageFiles = root.listFiles(pngFilter);
MatVector images = new MatVector(imageFiles.length);
int[] labels = new int[imageFiles.length];
int counter = 0;
int label;
IplImage img;
IplImage grayImg;
for (File image : imageFiles) {
//Get image and label:
img = cvLoadImage(image.getAbsolutePath());
label = Integer.parseInt(image.getName().split("\\-")[0]);
//Convert image to grayscale:
grayImg = IplImage.create(img.width(), img.height(), IPL_DEPTH_8U, 1);
cvCvtColor(img, grayImg, CV_BGR2GRAY);
//Append it in the image list:
images.put(counter, grayImg);
//And in the labels list:
labels[counter] = label;
//Increase counter for next image:
counter++;
}
FaceRecognizer faceRecognizer = createFisherFaceRecognizer();
//FaceRecognizer faceRecognizer = createEigenFaceRecognizer();
//FaceRecognizer faceRecognizer = createLBPHFaceRecognizer()
faceRecognizer.train(images, labels);
//Load the test image:
IplImage greyTestImage = IplImage.create(testImage.width(), testImage.height(), IPL_DEPTH_8U, 1);
cvCvtColor(testImage, greyTestImage, CV_BGR2GRAY);
//And get a prediction:
int predictedLabel = faceRecognizer.predict(greyTestImage);
System.out.println("Predicted label: " + predictedLabel);
}
}

La classe nécessite l'utilisation d'OpenCV interface Java. Si vous utilisez Maven, vous pouvez récupérer les bibliothèques requises avec les éléments suivants pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.pcbje</groupId>
<artifactId>opencvfacerecognizer</artifactId>
<version>0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>opencvfacerecognizer</name>
<url>http://pcbje.com</url>
<dependencies>
<dependency>
<groupId>com.googlecode.javacv</groupId>
<artifactId>javacv</artifactId>
<version>0.3</version>
</dependency>
<!-- For Linux x64 environments -->
<dependency>
<groupId>com.googlecode.javacv</groupId>
<artifactId>javacv</artifactId>
<classifier>linux-x86_64</classifier>
<version>0.3</version>
</dependency>    
<!-- For OSX environments -->
<dependency>
<groupId>com.googlecode.javacv</groupId>
<artifactId>javacv</artifactId>
<classifier>macosx-x86_64</classifier>
<version>0.3</version>
</dependency>
</dependencies>
<repositories>
<repository>
<id>javacv</id>
<name>JavaCV</name>
<url>http://maven2.javacv.googlecode.com/git/</url>
</repository>
</repositories>
</project>

Post Original

Citant ma réponse sur http://answers.opencv.org/question/865/the-contrib-module-problem.

Sans jamais avoir utilisé javacv, nous allons voir comment nous pouvons obtenir simplement en regardant les interfaces! Le projet est sur googlecode, ce qui le rend facile à parcourir le code: http://code.google.com/p/javacv.

D'abord jeter un oeil à la façon dont cv::FaceRecognizer a été enveloppé (opencv_contrib.java ligne 845 au moment de la rédaction de ce):

@Namespace("cv") public static class FaceRecognizer extends Algorithm {
static { Loader.load(); }
public FaceRecognizer() { }
public FaceRecognizer(Pointer p) { super(p); }
public /*abstract*/ native void train(@ByRef MatVector src, @Adapter("ArrayAdapter") CvArr labels);
public /*abstract*/ native int predict(@Adapter("ArrayAdapter") CvArr src);
public /*abstract*/ native void predict(@Adapter("ArrayAdapter") CvArr src, @ByRef int[] label, @ByRef double[] dist);
public native void save(String filename);
public native void load(String filename);
public native void save(@Adapter("FileStorageAdapter") CvFileStorage fs);
public native void load(@Adapter("FileStorageAdapter") CvFileStorage fs);
}

Aha, alors vous avez besoin pour passer un MatVector pour les images! Vous pouvez passer les étiquettes dans un CvArr (une ligne ou d'une colonne). Le MatVector est défini dans opencv_core, ligne 4629 (au moment de l'écriture de cette page) et il ressemble à ceci:

public static class MatVector extends Pointer {
static { load(); }
public MatVector()       { allocate();  }
public MatVector(long n) { allocate(n); }
public MatVector(Pointer p) { super(p); }
private native void allocate();
private native void allocate(@Cast("size_t") long n);
public native long size();
public native void resize(@Cast("size_t") long n);
@Index @ValueGetter public native @Adapter("MatAdapter") CvMat getCvMat(@Cast("size_t") long i);
@Index @ValueGetter public native @Adapter("MatAdapter") CvMatND getCvMatND(@Cast("size_t") long i);
@Index @ValueGetter public native @Adapter("MatAdapter") IplImage getIplImage(@Cast("size_t") long i);
@Index @ValueSetter public native MatVector put(@Cast("size_t") long i, @Adapter("MatAdapter") CvArr value);
}

De nouveau, tout en regardant le code, je pense que ça peut être utilisée comme ceci:

int numberOfImages = 10;
//Allocate some memory:
MatVector images = new MatVector(numberOfImages);
//Then fill the MatVector, you probably want to do something useful instead:
for(int idx = 0; idx < numberOfImages; idx++){
//Load an image:
CvArr image = cvLoadImage("/path/to/your/image");
//And put it into the MatVector:
images.put(idx, image);
}

Vous voulez sans doute faites-vous une méthode qui fait la conversion à partir d'un Java ArrayList à un MatVector (si une telle fonction n'existe pas dans javacv encore).

Maintenant à votre deuxième question. FaceRecognizer est l'équivalent de cv::FaceRecognizer. La native OpenCV des classes C++ de retour d'un cv::Ptr<cv::FaceRecognizer>, qui est un (Smart) Pointeur vers un cv::FaceRecognizer. Ce doit être enveloppé. Voir un modèle ici?

L'interface de FaceRecognizerPtr ressemble maintenant à ceci:

@Name("cv::Ptr<cv::FaceRecognizer>")
public static class FaceRecognizerPtr extends Pointer {
static { load(); }
public FaceRecognizerPtr()       { allocate();  }
public FaceRecognizerPtr(Pointer p) { super(p); }
private native void allocate();
public native FaceRecognizer get();
public native FaceRecognizerPtr put(FaceRecognizer value);
}

De sorte que vous pouvez obtenir soit une FaceRecognizer à partir de cette classe ou de mettre un FaceRecognizer. Vous devez seulement être préoccupé par la get(), comme le Pointeur est rempli par la méthode de la création du béton FaceRecognizer algorithme:

@Namespace("cv") public static native @ByVal FaceRecognizerPtr createEigenFaceRecognizer(int num_components/*=0*/, double threshold/*=DBL_MAX*/);
@Namespace("cv") public static native @ByVal FaceRecognizerPtr createFisherFaceRecognizer(int num_components/*=0*/, double threshold/*=DBL_MAX*/);
@Namespace("cv") public static native @ByVal FaceRecognizerPtr createLBPHFaceRecognizer(int radius/*=1*/,
int neighbors/*=8*/, int grid_x/*=8*/, int grid_y/*=8*/, double threshold/*=DBL_MAX*/);

Donc, une fois que vous avez obtenu le FaceRecognizerPtr, vous pouvez faire des choses comme:

//Holds your training data and labels:
MatVector images;
CvArr labels;
//Do something with the images and labels... Probably fill them?
//...
//Then get a Pointer to a FaceRecognizer (FaceRecognizerPtr).
//Java doesn't have default parameters, so you have to add some yourself,
//if you pass 0 as num_components to the EigenFaceRecognizer, the number of
//components is determined by the data, for the threshold use the maximum possible
//value if you don't want one. I don't know the constant in Java:
FaceRecognizerPtr model = createEigenFaceRecognizer(0, 10000);
//Then train it. See how I call get(), to get the FaceRecognizer inside the FaceRecognizerPtr:
model.get().train(images, labels);

Cela vous apprend un Eigenfaces modèle. Et c'est tout!

OriginalL'auteur bytefish