@spec clear(t()) :: t() | {:error, String.t()}

Clears the algorithm state

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()

Python prototype (for reference only):

clear() -> None

@spec empty(t()) :: boolean() | {:error, String.t()}

Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()

Return

• retval: bool

Python prototype (for reference only):

empty() -> retval

@spec getDefaultName(t()) :: binary() | {:error, String.t()}

getDefaultName

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()

Return

• retval: String

Returns the algorithm string identifier. This string is used as top level xml/yml node tag when the object is saved to a file or string.

Python prototype (for reference only):

getDefaultName() -> retval

@spec getLabelInfo(t(), integer()) :: binary() | {:error, String.t()}

Gets string information by label.

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()
• label: int

Return

• retval: String

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.

Python prototype (for reference only):

getLabelInfo(label) -> retval

@spec getLabelsByString(t(), binary()) :: [integer()] | {:error, String.t()}

Gets vector of labels by string.

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()
• str: String

Return

• retval: [int]

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

Python prototype (for reference only):

getLabelsByString(str) -> retval

@spec predict(t(), Evision.Mat.maybe_mat_in()) ::
  {integer(), number()} | {:error, String.t()}

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

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()

• src: Evision.Mat.t().

  Sample image to get a prediction from.

Return

• label: int.

  The predicted label for the given image.

• confidence: double.

  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);

Python prototype (for reference only):

predict(src) -> label, confidence

@spec predict_collect(
  t(),
  Evision.Mat.maybe_mat_in(),
  Evision.Face.PredictCollector.t()
) ::
  t() | {:error, String.t()}

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

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()

• src: Evision.Mat.t().

  Sample image to get a prediction from.

• collector: PredictCollector.

  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

Python prototype (for reference only):

predict_collect(src, collector) -> None

@spec predict_label(t(), Evision.Mat.maybe_mat_in()) ::
  integer() | {:error, String.t()}

predict_label

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()
• src: Evision.Mat.t()

Return

• retval: int

Has overloading in C++

Python prototype (for reference only):

predict_label(src) -> retval

@spec read(t(), binary()) :: t() | {:error, String.t()}

Loads a FaceRecognizer and its model state.

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()
• filename: String

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.

Python prototype (for reference only):

read(filename) -> None

@spec save(t(), binary()) :: t() | {:error, String.t()}

save

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()
• filename: String

Saves the algorithm to a file. In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Python prototype (for reference only):

save(filename) -> None

@spec setLabelInfo(t(), integer(), binary()) :: t() | {:error, String.t()}

Sets string info for the specified model's label.

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()
• label: int
• strInfo: String

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

Python prototype (for reference only):

setLabelInfo(label, strInfo) -> None

@spec train(t(), [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in()) ::
  t() | {:error, String.t()}

Trains a FaceRecognizer with given data and associated labels.

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()

• src: [Evision.Mat].

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

• labels: Evision.Mat.t().

  The labels corresponding to the images have to be given either as a vector\<int> 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\<Mat>. The labels of each image are stored within a std::vector\<int> (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);

Python prototype (for reference only):

train(src, labels) -> None

@spec update(t(), [Evision.Mat.maybe_mat_in()], Evision.Mat.maybe_mat_in()) ::
  t() | {:error, String.t()}

Updates a FaceRecognizer with given data and associated labels.

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()

• src: [Evision.Mat].

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

• labels: Evision.Mat.t().

  The labels corresponding to the images have to be given either as a vector\<int> 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.

Python prototype (for reference only):

update(src, labels) -> None

@spec write(t(), binary()) :: t() | {:error, String.t()}

Saves a FaceRecognizer and its model state.

Positional Arguments

• self: Evision.Face.FaceRecognizer.t()

• filename: String.

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

Saves this model to a given filename, either as XML or 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.

Python prototype (for reference only):

write(filename) -> None