org.opencv.contrib.FaceRecognizer Maven / Gradle / Ivy

Go to download

//
// 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
/**
 * 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.
 *
 * class FaceRecognizer : public Algorithm 

 *
 * // C++ code:
 *
 *
 * public:
 *
 * //! virtual destructor
 *
 * virtual ~FaceRecognizer() {}
 *
 * // Trains a FaceRecognizer.
 *
 * virtual void train(InputArray src, InputArray labels) = 0;
 *
 * // Updates a FaceRecognizer.
 *
 * virtual void update(InputArrayOfArrays src, InputArray labels);
 *
 * // Gets a prediction from a FaceRecognizer.
 *
 * virtual int predict(InputArray src) const = 0;
 *
 * // Predicts the label and confidence for a given sample.
 *
 * virtual void predict(InputArray src, int &label, double &confidence) const =
 * 0;
 *
 * // Serializes this object to a given filename.
 *
 * virtual void save(const string& filename) const;
 *
 * // Deserializes this object from a given filename.
 *
 * virtual void load(const string& filename);
 *
 * // Serializes this object to a given cv.FileStorage.
 *
 * virtual void save(FileStorage& fs) const = 0;
 *
 * // Deserializes this object from a given cv.FileStorage.
 *
 * virtual void load(const FileStorage& fs) = 0;
 *
 * };
 *
 * @see org.opencv.contrib.FaceRecognizer : public Algorithm
 */
public class FaceRecognizer extends Algorithm {

    protected FaceRecognizer(long addr) { super(addr); }


    //
    // C++:  void FaceRecognizer::load(string filename)
    //

/**
 * 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.
 *
 * @param filename a filename
 *
 * @see org.opencv.contrib.FaceRecognizer.load
 */
    public  void load(String filename)
    {

        load_0(nativeObj, filename);

        return;
    }


    //
    // C++:  void FaceRecognizer::predict(Mat src, int& label, double& confidence)
    //

/**
 * Predicts a label and associated confidence (e.g. distance) for a given input
 * image.
 *
 * 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; 

 *
 * // C++ code:
 *
 * // Do your initialization here (create the cv.FaceRecognizer model)...
 *
 * //...
 *
 * // Read in a sample image:
 *
 * Mat img = imread("person1/3.jpg", CV_LOAD_IMAGE_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; 

 *
 * // C++ code:
 *
 * // Do your initialization here (create the cv.FaceRecognizer model)...
 *
 * //...
 *
 * Mat img = imread("person1/3.jpg", CV_LOAD_IMAGE_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);
 *
 * @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 org.opencv.contrib.FaceRecognizer.predict
 */
    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)
    //

/**
 * Saves a "FaceRecognizer" and its model state.
 *
 * Saves this model to a given filename, either as XML or YAML.
 *
 * Saves this model to a given "FileStorage".
 *
 * 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.
 *
 * @param filename The filename to store this "FaceRecognizer" to (either
 * XML/YAML).
 *
 * @see org.opencv.contrib.FaceRecognizer.save
 */
    public  void save(String filename)
    {

        save_0(nativeObj, filename);

        return;
    }


    //
    // C++:  void FaceRecognizer::train(vector_Mat src, Mat labels)
    //

/**
 * Trains a FaceRecognizer with given data and associated labels.
 *
 * 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 

 *
 * // C++ code:
 *
 * vector images;
 *
 * vector labels;
 *
 * // images for first person
 *
 * images.push_back(imread("person0/0.jpg", CV_LOAD_IMAGE_GRAYSCALE));
 * labels.push_back(0);
 *
 * images.push_back(imread("person0/1.jpg", CV_LOAD_IMAGE_GRAYSCALE));
 * labels.push_back(0);
 *
 * images.push_back(imread("person0/2.jpg", CV_LOAD_IMAGE_GRAYSCALE));
 * labels.push_back(0);
 *
 * // images for second person
 *
 * images.push_back(imread("person1/0.jpg", CV_LOAD_IMAGE_GRAYSCALE));
 * labels.push_back(1);
 *
 * images.push_back(imread("person1/1.jpg", CV_LOAD_IMAGE_GRAYSCALE));
 * labels.push_back(1);
 *
 * images.push_back(imread("person1/2.jpg", CV_LOAD_IMAGE_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,
 * 

 *
 * // C++ code:
 *
 * // this is the most common usage of this specific FaceRecognizer:
 *
 * //
 *
 * Ptr model = createFisherFaceRecognizer();
 *
 * 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 

 *
 * // C++ code:
 *
 * // implementations:
 *
 * //
 *
 * model->train(images, labels);
 *
 * @param src The training images, that means the faces you want to learn. The
 * data has to be given as a vector.
 * @param labels The labels corresponding to the images have to be given either
 * as a vector or a
 *
 * @see org.opencv.contrib.FaceRecognizer.train
 */
    public  void train(List 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)
    //

/**
 * Updates a FaceRecognizer with given data and associated labels.
 *
 * 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, 

 *
 * // C++ code:
 *
 * // this is the most common usage of this specific FaceRecognizer:
 *
 * //
 *
 * Ptr model = createLBPHFaceRecognizer();
 *
 * // 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 newImages;
 *
 * vector 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 "createEigenFaceRecognizer"),
 * 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 

 *
 * // C++ code:
 *
 * terminate called after throwing an instance of 'cv.Exception'
 *
 * 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.
 * 
 *
 * @param src The training images, that means the faces you want to learn. The
 * data has to be given as a vector.
 * @param labels The labels corresponding to the images have to be given either
 * as a vector or a
 *
 * @see org.opencv.contrib.FaceRecognizer.update
 */
    public  void update(List 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);

}