//
// This file is auto-generated. Please don't modify it!
//
package org.opencv.contrib;
import java.lang.String;
import java.util.List;
import org.opencv.core.Algorithm;
import org.opencv.core.Mat;
import org.opencv.utils.Converters;
// C++: class FaceRecognizer
/**
* <p>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.</p>
*
* <p>class FaceRecognizer : public Algorithm <code></p>
*
* <p>// C++ code:</p>
*
*
* <p>public:</p>
*
* <p>//! virtual destructor</p>
*
* <p>virtual ~FaceRecognizer() {}</p>
*
* <p>// Trains a FaceRecognizer.</p>
*
* <p>virtual void train(InputArray src, InputArray labels) = 0;</p>
*
* <p>// Updates a FaceRecognizer.</p>
*
* <p>virtual void update(InputArrayOfArrays src, InputArray labels);</p>
*
* <p>// Gets a prediction from a FaceRecognizer.</p>
*
* <p>virtual int predict(InputArray src) const = 0;</p>
*
* <p>// Predicts the label and confidence for a given sample.</p>
*
* <p>virtual void predict(InputArray src, int &label, double &confidence) const =
* 0;</p>
*
* <p>// Serializes this object to a given filename.</p>
*
* <p>virtual void save(const string& filename) const;</p>
*
* <p>// Deserializes this object from a given filename.</p>
*
* <p>virtual void load(const string& filename);</p>
*
* <p>// Serializes this object to a given cv.FileStorage.</p>
*
* <p>virtual void save(FileStorage& fs) const = 0;</p>
*
* <p>// Deserializes this object from a given cv.FileStorage.</p>
*
* <p>virtual void load(const FileStorage& fs) = 0;</p>
*
* <p>};</p>
*
* @see <a href="http://docs.opencv.org/modules/contrib/doc/facerec_api.html#facerecognizer">org.opencv.contrib.FaceRecognizer : public Algorithm</a>
*/
public class FaceRecognizer extends Algorithm {
protected FaceRecognizer(long addr) { super(addr); }
//
// C++: void FaceRecognizer::load(string filename)
//
/**
* <p>Loads a "FaceRecognizer" and its model state.</p>
*
* <p>Loads a persisted model and state from a given XML or YAML file. Every
* "FaceRecognizer" has to overwrite <code>FaceRecognizer.load(FileStorage&
* fs)</code> to enable loading the model state. <code>FaceRecognizer.load(FileStorage&
* fs)</code> in turn gets called by <code>FaceRecognizer.load(const string&
* filename)</code>, to ease saving a model.</p>
*
* @param filename a filename
*
* @see <a href="http://docs.opencv.org/modules/contrib/doc/facerec_api.html#facerecognizer-load">org.opencv.contrib.FaceRecognizer.load</a>
*/
public void load(String filename)
{
load_0(nativeObj, filename);
return;
}
//
// C++: void FaceRecognizer::predict(Mat src, int& label, double& confidence)
//
/**
* <p>Predicts a label and associated confidence (e.g. distance) for a given input
* image.</p>
*
* <p>The suffix <code>const</code> means that prediction does not affect the
* internal model state, so the method can be safely called from within
* different threads.</p>
*
* <p>The following example shows how to get a prediction from a trained model:
* using namespace cv; <code></p>
*
* <p>// C++ code:</p>
*
* <p>// Do your initialization here (create the cv.FaceRecognizer model)...</p>
*
* <p>//...</p>
*
* <p>// Read in a sample image:</p>
*
* <p>Mat img = imread("person1/3.jpg", CV_LOAD_IMAGE_GRAYSCALE);</p>
*
* <p>// And get a prediction from the cv.FaceRecognizer:</p>
*
* <p>int predicted = model->predict(img);</p>
*
* <p>Or to get a prediction and the associated confidence (e.g. distance): </code></p>
*
* <p>using namespace cv; <code></p>
*
* <p>// C++ code:</p>
*
* <p>// Do your initialization here (create the cv.FaceRecognizer model)...</p>
*
* <p>//...</p>
*
* <p>Mat img = imread("person1/3.jpg", CV_LOAD_IMAGE_GRAYSCALE);</p>
*
* <p>// Some variables for the predicted label and associated confidence (e.g.
* distance):</p>
*
* <p>int predicted_label = -1;</p>
*
* <p>double predicted_confidence = 0.0;</p>
*
* <p>// Get the prediction and associated confidence from the model</p>
*
* <p>model->predict(img, predicted_label, predicted_confidence);</p>
*
* @param src Sample image to get a prediction from.
* @param label The predicted label for the given image.
* @param confidence Associated confidence (e.g. distance) for the predicted
* label.
*
* @see <a href="http://docs.opencv.org/modules/contrib/doc/facerec_api.html#facerecognizer-predict">org.opencv.contrib.FaceRecognizer.predict</a>
*/
public void predict(Mat src, int[] label, double[] confidence)
{
double[] label_out = new double[1];
double[] confidence_out = new double[1];
predict_0(nativeObj, src.nativeObj, label_out, confidence_out);
if(label!=null) label[0] = (int)label_out[0];
if(confidence!=null) confidence[0] = (double)confidence_out[0];
return;
}
//
// C++: void FaceRecognizer::save(string filename)
//
/**
* <p>Saves a "FaceRecognizer" and its model state.</p>
*
* <p>Saves this model to a given filename, either as XML or YAML.</p>
*
* <p>Saves this model to a given "FileStorage".</p>
*
* <p>Every "FaceRecognizer" overwrites <code>FaceRecognizer.save(FileStorage&
* fs)</code> to save the internal model state. <code>FaceRecognizer.save(const
* string& filename)</code> saves the state of a model to the given filename.</p>
*
* <p>The suffix <code>const</code> means that prediction does not affect the
* internal model state, so the method can be safely called from within
* different threads.</p>
*
* @param filename The filename to store this "FaceRecognizer" to (either
* XML/YAML).
*
* @see <a href="http://docs.opencv.org/modules/contrib/doc/facerec_api.html#facerecognizer-save">org.opencv.contrib.FaceRecognizer.save</a>
*/
public void save(String filename)
{
save_0(nativeObj, filename);
return;
}
//
// C++: void FaceRecognizer::train(vector_Mat src, Mat labels)
//
/**
* <p>Trains a FaceRecognizer with given data and associated labels.</p>
*
* <p>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
* <code>std.vector<Mat></code>. The labels of each image are stored within a
* <code>std.vector<int></code> (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 <code></p>
*
* <p>// C++ code:</p>
*
* <p>vector<Mat> images;</p>
*
* <p>vector<int> labels;</p>
*
* <p>// images for first person</p>
*
* <p>images.push_back(imread("person0/0.jpg", CV_LOAD_IMAGE_GRAYSCALE));
* labels.push_back(0);</p>
*
* <p>images.push_back(imread("person0/1.jpg", CV_LOAD_IMAGE_GRAYSCALE));
* labels.push_back(0);</p>
*
* <p>images.push_back(imread("person0/2.jpg", CV_LOAD_IMAGE_GRAYSCALE));
* labels.push_back(0);</p>
*
* <p>// images for second person</p>
*
* <p>images.push_back(imread("person1/0.jpg", CV_LOAD_IMAGE_GRAYSCALE));
* labels.push_back(1);</p>
*
* <p>images.push_back(imread("person1/1.jpg", CV_LOAD_IMAGE_GRAYSCALE));
* labels.push_back(1);</p>
*
* <p>images.push_back(imread("person1/2.jpg", CV_LOAD_IMAGE_GRAYSCALE));
* labels.push_back(1);</p>
*
* <p>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: </code></p>
*
* <p>// Create a new Fisherfaces model and retain all available Fisherfaces,
* <code></p>
*
* <p>// C++ code:</p>
*
* <p>// this is the most common usage of this specific FaceRecognizer:</p>
*
* <p>//</p>
*
* <p>Ptr<FaceRecognizer> model = createFisherFaceRecognizer();</p>
*
* <p>And finally train it on the given dataset (the face images and labels):
* </code></p>
*
* <p>// This is the common interface to train all of the available
* cv.FaceRecognizer <code></p>
*
* <p>// C++ code:</p>
*
* <p>// implementations:</p>
*
* <p>//</p>
*
* <p>model->train(images, labels);</p>
*
* @param src The training images, that means the faces you want to learn. The
* data has to be given as a <code>vector<Mat></code>.
* @param labels The labels corresponding to the images have to be given either
* as a <code>vector<int></code> or a
*
* @see <a href="http://docs.opencv.org/modules/contrib/doc/facerec_api.html#facerecognizer-train">org.opencv.contrib.FaceRecognizer.train</a>
*/
public void train(List<Mat> src, Mat labels)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
train_0(nativeObj, src_mat.nativeObj, labels.nativeObj);
return;
}
//
// C++: void FaceRecognizer::update(vector_Mat src, Mat labels)
//
/**
* <p>Updates a FaceRecognizer with given data and associated labels.</p>
*
* <p>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, <code></p>
*
* <p>// C++ code:</p>
*
* <p>// this is the most common usage of this specific FaceRecognizer:</p>
*
* <p>//</p>
*
* <p>Ptr<FaceRecognizer> model = createLBPHFaceRecognizer();</p>
*
* <p>// This is the common interface to train all of the available
* cv.FaceRecognizer</p>
*
* <p>// implementations:</p>
*
* <p>//</p>
*
* <p>model->train(images, labels);</p>
*
* <p>// Some containers to hold new image:</p>
*
* <p>vector<Mat> newImages;</p>
*
* <p>vector<int> newLabels;</p>
*
* <p>// You should add some images to the containers:</p>
*
* <p>//</p>
*
* <p>//...</p>
*
* <p>//</p>
*
* <p>// Now updating the model is as easy as calling:</p>
*
* <p>model->update(newImages,newLabels);</p>
*
* <p>// This will preserve the old model data and extend the existing model</p>
*
* <p>// with the new features extracted from newImages!</p>
*
* <p>Calling update on an Eigenfaces model (see "createEigenFaceRecognizer"),
* which doesn't support updating, will throw an error similar to: </code></p>
*
* <p>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 <code></p>
*
* <p>// C++ code:</p>
*
* <p>terminate called after throwing an instance of 'cv.Exception'</p>
*
* <p>Please 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.
* </code></p>
*
* @param src The training images, that means the faces you want to learn. The
* data has to be given as a <code>vector<Mat></code>.
* @param labels The labels corresponding to the images have to be given either
* as a <code>vector<int></code> or a
*
* @see <a href="http://docs.opencv.org/modules/contrib/doc/facerec_api.html#facerecognizer-update">org.opencv.contrib.FaceRecognizer.update</a>
*/
public void update(List<Mat> src, Mat labels)
{
Mat src_mat = Converters.vector_Mat_to_Mat(src);
update_0(nativeObj, src_mat.nativeObj, labels.nativeObj);
return;
}
@Override
protected void finalize() throws Throwable {
delete(nativeObj);
}
// C++: void FaceRecognizer::load(string filename)
private static native void load_0(long nativeObj, String filename);
// C++: void FaceRecognizer::predict(Mat src, int& label, double& confidence)
private static native void predict_0(long nativeObj, long src_nativeObj, double[] label_out, double[] confidence_out);
// C++: void FaceRecognizer::save(string filename)
private static native void save_0(long nativeObj, String filename);
// C++: void FaceRecognizer::train(vector_Mat src, Mat labels)
private static native void train_0(long nativeObj, long src_mat_nativeObj, long labels_nativeObj);
// C++: void FaceRecognizer::update(vector_Mat src, Mat labels)
private static native void update_0(long nativeObj, long src_mat_nativeObj, long labels_nativeObj);
// native support for java finalize()
private static native void delete(long nativeObj);
}