org.bytedeco.opencv.opencv_face

Class FaceRecognizer

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.opencv.opencv_core.Algorithm

org.bytedeco.opencv.opencv_face.FaceRecognizer

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

BasicFaceRecognizer, LBPHFaceRecognizer

@Namespace(value="cv::face")
 @NoOffset
 @Properties(inherit=opencv_face.class)
public class FaceRecognizer
extends Algorithm

\addtogroup face \{

/** \brief Abstract base class for all face recognition models

All face recognition models in OpenCV are derived from the abstract base class FaceRecognizer, which provides a unified access to all face recongition algorithms in OpenCV.

### Description

I'll go a bit more into detail explaining FaceRecognizer, because it doesn't look like a powerful interface at first sight. But: Every FaceRecognizer is an Algorithm, so you can easily get/set all model internals (if allowed by the implementation). Algorithm is a relatively new OpenCV concept, which is available since the 2.4 release. I suggest you take a look at its description.

Algorithm provides the following features for all derived classes:

- So called "virtual constructor". That is, each Algorithm derivative is registered at program start and you can get the list of registered algorithms and create instance of a particular algorithm by its name (see Algorithm::create). If you plan to add your own algorithms, it is good practice to add a unique prefix to your algorithms to distinguish them from other algorithms. - Setting/Retrieving algorithm parameters by name. If you used video capturing functionality from OpenCV highgui module, you are probably familar with cv::cvSetCaptureProperty, ocvcvGetCaptureProperty, VideoCapture::set and VideoCapture::get. Algorithm provides similar method where instead of integer id's you specify the parameter names as text Strings. See Algorithm::set and Algorithm::get for details. - Reading and writing parameters from/to XML or YAML files. Every Algorithm derivative can store all its parameters and then read them back. There is no need to re-implement it each time.

Moreover every FaceRecognizer supports the:

- **Training** of a FaceRecognizer with FaceRecognizer::train on a given set of images (your face database!). - **Prediction** of a given sample image, that means a face. The image is given as a Mat. - **Loading/Saving** the model state from/to a given XML or YAML. - **Setting/Getting labels info**, that is stored as a string. String labels info is useful for keeping names of the recognized people.

\note When using the FaceRecognizer interface in combination with Python, please stick to Python 2. Some underlying scripts like create_csv will not work in other versions, like Python 3. Setting the Thresholds +++++++++++++++++++++++

Sometimes you run into the situation, when you want to apply a threshold on the prediction. A common scenario in face recognition is to tell, whether a face belongs to the training dataset or if it is unknown. You might wonder, why there's no public API in FaceRecognizer to set the threshold for the prediction, but rest assured: It's supported. It just means there's no generic way in an abstract class to provide an interface for setting/getting the thresholds of *every possible* FaceRecognizer algorithm. The appropriate place to set the thresholds is in the constructor of the specific FaceRecognizer and since every FaceRecognizer is a Algorithm (see above), you can get/set the thresholds at runtime!

Here is an example of setting a threshold for the Eigenfaces method, when creating the model:

// Let's say we want to keep 10 Eigenfaces and have a threshold value of 10.0
int num_components = 10;
double threshold = 10.0;
// Then if you want to have a cv::FaceRecognizer with a confidence threshold,
// create the concrete implementation with the appropriate parameters:
Ptr<FaceRecognizer> model = EigenFaceRecognizer::create(num_components, threshold);

Sometimes it's impossible to train the model, just to experiment with threshold values. Thanks to Algorithm it's possible to set internal model thresholds during runtime. Let's see how we would set/get the prediction for the Eigenface model, we've created above:

// The following line reads the threshold from the Eigenfaces model:
double current_threshold = model->getDouble("threshold");
// And this line sets the threshold to 0.0:
model->set("threshold", 0.0);

If you've set the threshold to 0.0 as we did above, then:

//
Mat img = imread("person1/3.jpg", IMREAD_GRAYSCALE);
// Get a prediction from the model. Note: We've set a threshold of 0.0 above,
// since the distance is almost always larger than 0.0, you'll get -1 as
// label, which indicates, this face is unknown
int predicted_label = model->predict(img);
// ...

is going to yield -1 as predicted label, which states this face is unknown.

### Getting the name of a FaceRecognizer

Since every FaceRecognizer is a Algorithm, you can use Algorithm::name to get the name of a FaceRecognizer:

// Create a FaceRecognizer:
Ptr<FaceRecognizer> model = EigenFaceRecognizer::create();
// And here's how to get its name:
String name = model->name();

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
FaceRecognizer(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
boolean	empty() \overload
BytePointer	getLabelInfo(int label) \brief Gets string information by label.
IntPointer	getLabelsByString(BytePointer str) \brief Gets vector of labels by string.
IntBuffer	getLabelsByString(String str)
double	getThreshold() \brief threshold parameter accessor - required for default BestMinDist collector
void	predict_collect(GpuMat src, PredictCollector collector)
void	predict_collect(Mat src, PredictCollector collector) \brief - if implemented - send all result of prediction to collector that can be used for somehow custom result handling
void	predict_collect(UMat src, PredictCollector collector)
int	predict_label(GpuMat src)
int	predict_label(Mat src) \overload
int	predict_label(UMat src)
void	predict(GpuMat src, int[] label, double[] confidence)
void	predict(GpuMat src, IntBuffer label, DoubleBuffer confidence)
void	predict(GpuMat src, IntPointer label, DoublePointer confidence)
void	predict(Mat src, int[] label, double[] confidence)
void	predict(Mat src, IntBuffer label, DoubleBuffer confidence)
void	predict(Mat src, IntPointer label, DoublePointer confidence) \brief Predicts a label and associated confidence (e.g.
void	predict(UMat src, int[] label, double[] confidence)
void	predict(UMat src, IntBuffer label, DoubleBuffer confidence)
void	predict(UMat src, IntPointer label, DoublePointer confidence)
void	read(BytePointer filename) \brief Loads a FaceRecognizer and its model state.
void	read(FileNode fn) \overload
void	read(String filename)
void	setLabelInfo(int label, BytePointer strInfo) \brief Sets string info for the specified model's label.
void	setLabelInfo(int label, String strInfo)
void	setThreshold(double val) \brief Sets threshold of model
void	train(GpuMatVector src, GpuMat labels)
void	train(GpuMatVector src, Mat labels)
void	train(GpuMatVector src, UMat labels)
void	train(MatVector src, GpuMat labels)
void	train(MatVector src, Mat labels) \brief Trains a FaceRecognizer with given data and associated labels.
void	train(MatVector src, UMat labels)
void	train(UMatVector src, GpuMat labels)
void	train(UMatVector src, Mat labels)
void	train(UMatVector src, UMat labels)
void	update(GpuMatVector src, GpuMat labels)
void	update(GpuMatVector src, Mat labels)
void	update(GpuMatVector src, UMat labels)
void	update(MatVector src, GpuMat labels)
void	update(MatVector src, Mat labels) \brief Updates a FaceRecognizer with given data and associated labels.
void	update(MatVector src, UMat labels)
void	update(UMatVector src, GpuMat labels)
void	update(UMatVector src, Mat labels)
void	update(UMatVector src, UMat labels)
void	write(BytePointer filename) \brief Saves a FaceRecognizer and its model state.
void	write(FileStorage fs) \overload Saves this model to a given FileStorage.
void	write(String filename)

Methods inherited from class org.bytedeco.opencv.opencv_core.Algorithm

clear, getDefaultName, position, save, save, write, write

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

FaceRecognizer

public FaceRecognizer(Pointer p)

Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

Method Detail

train

public void train(@ByVal
                  MatVector src,
                  @ByVal
                  Mat labels)

\brief Trains a FaceRecognizer with given data and associated labels.

Parameters:

src - The training images, that means the faces you want to learn. The data has to be given as a vector\.

labels - The labels corresponding to the images have to be given either as a vector\ or a Mat of type CV_32SC1.

The following source code snippet shows you how to learn a Fisherfaces model on a given set of images. The images are read with imread and pushed into a std::vector\. The labels of each image are stored within a std::vector\ (you could also use a Mat of type CV_32SC1). Think of the label as the subject (the person) this image belongs to, so same subjects (persons) should have the same label. For the available FaceRecognizer you don't have to pay any attention to the order of the labels, just make sure same persons have the same label:

    // holds images and labels
    vector<Mat> images;
    vector<int> labels;
    // using Mat of type CV_32SC1
    // Mat labels(number_of_samples, 1, CV_32SC1);
    // images for first person
    images.push_back(imread("person0/0.jpg", IMREAD_GRAYSCALE)); labels.push_back(0);
    images.push_back(imread("person0/1.jpg", IMREAD_GRAYSCALE)); labels.push_back(0);
    images.push_back(imread("person0/2.jpg", IMREAD_GRAYSCALE)); labels.push_back(0);
    // images for second person
    images.push_back(imread("person1/0.jpg", IMREAD_GRAYSCALE)); labels.push_back(1);
    images.push_back(imread("person1/1.jpg", IMREAD_GRAYSCALE)); labels.push_back(1);
    images.push_back(imread("person1/2.jpg", IMREAD_GRAYSCALE)); labels.push_back(1);
    

Now that you have read some images, we can create a new FaceRecognizer. In this example I'll create a Fisherfaces model and decide to keep all of the possible Fisherfaces:

    // Create a new Fisherfaces model and retain all available Fisherfaces,
    // this is the most common usage of this specific FaceRecognizer:
    //
    Ptr<FaceRecognizer> model =  FisherFaceRecognizer::create();
    

And finally train it on the given dataset (the face images and labels):

    // This is the common interface to train all of the available cv::FaceRecognizer
    // implementations:
    //
    model->train(images, labels);
    

train

public void train(@ByVal
                  UMatVector src,
                  @ByVal
                  Mat labels)

train

public void train(@ByVal
                  GpuMatVector src,
                  @ByVal
                  Mat labels)

train

public void train(@ByVal
                  MatVector src,
                  @ByVal
                  UMat labels)

train

public void train(@ByVal
                  UMatVector src,
                  @ByVal
                  UMat labels)

train

public void train(@ByVal
                  GpuMatVector src,
                  @ByVal
                  UMat labels)

train

public void train(@ByVal
                  MatVector src,
                  @ByVal
                  GpuMat labels)

train

public void train(@ByVal
                  UMatVector src,
                  @ByVal
                  GpuMat labels)

train

public void train(@ByVal
                  GpuMatVector src,
                  @ByVal
                  GpuMat labels)

update

public void update(@ByVal
                   MatVector src,
                   @ByVal
                   Mat labels)

\brief Updates a FaceRecognizer with given data and associated labels.

Parameters:

src - The training images, that means the faces you want to learn. The data has to be given as a vector\.

labels - The labels corresponding to the images have to be given either as a vector\ or a Mat of type CV_32SC1.

This method updates a (probably trained) FaceRecognizer, but only if the algorithm supports it. The Local Binary Patterns Histograms (LBPH) recognizer (see createLBPHFaceRecognizer) can be updated. For the Eigenfaces and Fisherfaces method, this is algorithmically not possible and you have to re-estimate the model with FaceRecognizer::train. In any case, a call to train empties the existing model and learns a new model, while update does not delete any model data.

    // Create a new LBPH model (it can be updated) and use the default parameters,
    // this is the most common usage of this specific FaceRecognizer:
    //
    Ptr<FaceRecognizer> model =  LBPHFaceRecognizer::create();
    // This is the common interface to train all of the available cv::FaceRecognizer
    // implementations:
    //
    model->train(images, labels);
    // Some containers to hold new image:
    vector<Mat> newImages;
    vector<int> newLabels;
    // You should add some images to the containers:
    //
    // ...
    //
    // Now updating the model is as easy as calling:
    model->update(newImages,newLabels);
    // This will preserve the old model data and extend the existing model
    // with the new features extracted from newImages!
    

Calling update on an Eigenfaces model (see EigenFaceRecognizer::create), which doesn't support updating, will throw an error similar to:

    OpenCV Error: The function/feature is not implemented (This FaceRecognizer (FaceRecognizer.Eigenfaces) does not support updating, you have to use FaceRecognizer::train to update it.) in update, file /home/philipp/git/opencv/modules/contrib/src/facerec.cpp, line 305
    terminate called after throwing an instance of 'cv::Exception'
    

\note The FaceRecognizer does not store your training images, because this would be very memory intense and it's not the responsibility of te FaceRecognizer to do so. The caller is responsible for maintaining the dataset, he want to work with.

update

public void update(@ByVal
                   UMatVector src,
                   @ByVal
                   Mat labels)

update

public void update(@ByVal
                   GpuMatVector src,
                   @ByVal
                   Mat labels)

update

public void update(@ByVal
                   MatVector src,
                   @ByVal
                   UMat labels)

update

public void update(@ByVal
                   UMatVector src,
                   @ByVal
                   UMat labels)

update

public void update(@ByVal
                   GpuMatVector src,
                   @ByVal
                   UMat labels)

update

public void update(@ByVal
                   MatVector src,
                   @ByVal
                   GpuMat labels)

update

public void update(@ByVal
                   UMatVector src,
                   @ByVal
                   GpuMat labels)

update

public void update(@ByVal
                   GpuMatVector src,
                   @ByVal
                   GpuMat labels)

predict_label

@Name(value="predict")
public int predict_label(@ByVal
                                                Mat src)

\overload

predict_label

@Name(value="predict")
public int predict_label(@ByVal
                                                UMat src)

predict_label

@Name(value="predict")
public int predict_label(@ByVal
                                                GpuMat src)

predict

public void predict(@ByVal
                    Mat src,
                    @ByRef
                    IntPointer label,
                    @ByRef
                    DoublePointer confidence)

\brief Predicts a label and associated confidence (e.g. distance) for a given input image.

Parameters:

src - Sample image to get a prediction from.

label - The predicted label for the given image.

confidence - Associated confidence (e.g. distance) for the predicted label.

The suffix const means that prediction does not affect the internal model state, so the method can be safely called from within different threads.

The following example shows how to get a prediction from a trained model:

    using namespace cv;
    // Do your initialization here (create the cv::FaceRecognizer model) ...
    // ...
    // Read in a sample image:
    Mat img = imread("person1/3.jpg", IMREAD_GRAYSCALE);
    // And get a prediction from the cv::FaceRecognizer:
    int predicted = model->predict(img);
    

Or to get a prediction and the associated confidence (e.g. distance):

    using namespace cv;
    // Do your initialization here (create the cv::FaceRecognizer model) ...
    // ...
    Mat img = imread("person1/3.jpg", IMREAD_GRAYSCALE);
    // Some variables for the predicted label and associated confidence (e.g. distance):
    int predicted_label = -1;
    double predicted_confidence = 0.0;
    // Get the prediction and associated confidence from the model
    model->predict(img, predicted_label, predicted_confidence);
    

predict

public void predict(@ByVal
                    Mat src,
                    @ByRef
                    IntBuffer label,
                    @ByRef
                    DoubleBuffer confidence)

predict

public void predict(@ByVal
                    Mat src,
                    @ByRef
                    int[] label,
                    @ByRef
                    double[] confidence)

predict

public void predict(@ByVal
                    UMat src,
                    @ByRef
                    IntPointer label,
                    @ByRef
                    DoublePointer confidence)

predict

public void predict(@ByVal
                    UMat src,
                    @ByRef
                    IntBuffer label,
                    @ByRef
                    DoubleBuffer confidence)

predict

public void predict(@ByVal
                    UMat src,
                    @ByRef
                    int[] label,
                    @ByRef
                    double[] confidence)

predict

public void predict(@ByVal
                    GpuMat src,
                    @ByRef
                    IntPointer label,
                    @ByRef
                    DoublePointer confidence)

predict

public void predict(@ByVal
                    GpuMat src,
                    @ByRef
                    IntBuffer label,
                    @ByRef
                    DoubleBuffer confidence)

predict

public void predict(@ByVal
                    GpuMat src,
                    @ByRef
                    int[] label,
                    @ByRef
                    double[] confidence)

predict_collect

@Name(value="predict")
public void predict_collect(@ByVal
                                                   Mat src,
                                                   @opencv_core.Ptr
                                                   PredictCollector collector)

\brief - if implemented - send all result of prediction to collector that can be used for somehow custom result handling

Parameters:

src - Sample image to get a prediction from.

collector - User-defined collector object that accepts all results

To implement this method u just have to do same internal cycle as in predict(InputArray src, CV_OUT int &label, CV_OUT double &confidence) but not try to get "best\ result, just resend it to caller side with given collector

predict_collect

@Name(value="predict")
public void predict_collect(@ByVal
                                                   UMat src,
                                                   @opencv_core.Ptr
                                                   PredictCollector collector)

predict_collect

@Name(value="predict")
public void predict_collect(@ByVal
                                                   GpuMat src,
                                                   @opencv_core.Ptr
                                                   PredictCollector collector)

write

public void write(@opencv_core.Str
                  BytePointer filename)

\brief Saves a FaceRecognizer and its model state.

Saves this model to a given filename, either as XML or YAML.

Parameters:

filename - The filename to store this FaceRecognizer to (either XML/YAML).

Every FaceRecognizer overwrites FaceRecognizer::save(FileStorage& fs) to save the internal model state. FaceRecognizer::save(const String& filename) saves the state of a model to the given filename.

The suffix const means that prediction does not affect the internal model state, so the method can be safely called from within different threads.

write

public void write(@opencv_core.Str
                  String filename)

read

public void read(@opencv_core.Str
                 BytePointer filename)

\brief Loads a FaceRecognizer and its model state.

Loads a persisted model and state from a given XML or YAML file . Every FaceRecognizer has to overwrite FaceRecognizer::load(FileStorage& fs) to enable loading the model state. FaceRecognizer::load(FileStorage& fs) in turn gets called by FaceRecognizer::load(const String& filename), to ease saving a model.

read

public void read(@opencv_core.Str
                 String filename)

write

public void write(@ByRef
                  FileStorage fs)

\overload Saves this model to a given FileStorage.

Overrides:

write in class Algorithm

Parameters:

fs - The FileStorage to store this FaceRecognizer to.

read

public void read(@Const @ByRef
                 FileNode fn)

\overload

Overrides:

read in class Algorithm

empty

@Cast(value="bool")
public boolean empty()

\overload

Overrides:

empty in class Algorithm

setLabelInfo

public void setLabelInfo(int label,
                         @opencv_core.Str
                         BytePointer strInfo)

\brief Sets string info for the specified model's label.

The string info is replaced by the provided value if it was set before for the specified label.

setLabelInfo

public void setLabelInfo(int label,
                         @opencv_core.Str
                         String strInfo)

getLabelInfo

@opencv_core.Str
public BytePointer getLabelInfo(int label)

\brief Gets string information by label.

If an unknown label id is provided or there is no label information associated with the specified label id the method returns an empty string.

getLabelsByString

@StdVector
public IntPointer getLabelsByString(@opencv_core.Str
                                               BytePointer str)

\brief Gets vector of labels by string.

The function searches for the labels containing the specified sub-string in the associated string info.

getLabelsByString

@StdVector
public IntBuffer getLabelsByString(@opencv_core.Str
                                              String str)

getThreshold

public double getThreshold()

\brief threshold parameter accessor - required for default BestMinDist collector

setThreshold

public void setThreshold(double val)

\brief Sets threshold of model