void Eigenfaces::train(InputArrayOfArrays _src, InputArray _local_labels) {

     if(_src.total() == ) {

         string error_message = format("Empty training data was given. You'll need more than one sample to learn a model.");

         CV_Error(CV_StsBadArg, error_message);

     } else if(_local_labels.getMat().type() != CV_32SC1) {

         string error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _local_labels.type());

         CV_Error(CV_StsBadArg, error_message);

     }

     // make sure data has correct size

     if(_src.total() > ) {

         for(int i = ; i < static_cast<int>(_src.total()); i++) {

             if(_src.getMat(i-).total() != _src.getMat(i).total()) {

                 string error_message = format("In the Eigenfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", _src.getMat(i-).total(), _src.getMat(i).total());

                 CV_Error(CV_StsUnsupportedFormat, error_message);

             }

         }

     }

     // get labels

     Mat labels = _local_labels.getMat();

     // observations in row

     Mat data = asRowMatrix(_src, CV_64FC1);

     // number of samples

    int n = data.rows;

     // assert there are as much samples as labels

     if(static_cast<int>(labels.total()) != n) {

         string error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", n, labels.total());

         CV_Error(CV_StsBadArg, error_message);

     }

     // clear existing model data

     _labels.release();

     _projections.clear();

     // clip number of components to be valid

     if((_num_components <= ) || (_num_components > n))

         _num_components = n;

     // perform the PCA

     PCA pca(data, Mat(), CV_PCA_DATA_AS_ROW, _num_components);

     // copy the PCA results

     _mean = pca.mean.reshape(,); // store the mean vector

     _eigenvalues = pca.eigenvalues.clone(); // eigenvalues by row

     transpose(pca.eigenvectors, _eigenvectors); // eigenvectors by column

     // store labels for prediction

     _labels = labels.clone();

     // save projections

     for(int sampleIdx = ; sampleIdx < data.rows; sampleIdx++) {

         Mat p = subspaceProject(_eigenvectors, _mean, data.row(sampleIdx));

         _projections.push_back(p);

     }

 }

人脸样本训练过程

 PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComponents)

 {

     Mat data = _data.getMat(), _mean = __mean.getMat();

     int covar_flags = CV_COVAR_SCALE;

     int i, len, in_count;

     Size mean_sz;

     CV_Assert( data.channels() ==  );

     if( flags & CV_PCA_DATA_AS_COL )

     {

         len = data.rows;

         in_count = data.cols;

         covar_flags |= CV_COVAR_COLS;

         mean_sz = Size(, len);

     }

     else

     {

         len = data.cols;

         in_count = data.rows;

         covar_flags |= CV_COVAR_ROWS;

         mean_sz = Size(len, );

     }

     int count = std::min(len, in_count), out_count = count;

     if( maxComponents >  )

         out_count = std::min(count, maxComponents);

     // "scrambled" way to compute PCA (when cols(A)>rows(A)):

     // B = A'A; B*x=b*x; C = AA'; C*y=c*y -> AA'*y=c*y -> A'A*(A'*y)=c*(A'*y) -> c = b, x=A'*y

     if( len <= in_count )

         covar_flags |= CV_COVAR_NORMAL;

     int ctype = std::max(CV_32F, data.depth());

     mean.create( mean_sz, ctype );

     Mat covar( count, count, ctype );

     if( _mean.data )

     {

         CV_Assert( _mean.size() == mean_sz );

         _mean.convertTo(mean, ctype);

         covar_flags |= CV_COVAR_USE_AVG;

     }

     calcCovarMatrix( data, covar, mean, covar_flags, ctype );

     eigen( covar, eigenvalues, eigenvectors );

     if( !(covar_flags & CV_COVAR_NORMAL) )

     {

         // CV_PCA_DATA_AS_ROW: cols(A)>rows(A). x=A'*y -> x'=y'*A

         // CV_PCA_DATA_AS_COL: rows(A)>cols(A). x=A''*y -> x'=y'*A'

         Mat tmp_data, tmp_mean = repeat(mean, data.rows/mean.rows, data.cols/mean.cols);

         if( data.type() != ctype || tmp_mean.data == mean.data )

         {

             data.convertTo( tmp_data, ctype );

             subtract( tmp_data, tmp_mean, tmp_data );

         }

         else

         {

             subtract( data, tmp_mean, tmp_mean );

             tmp_data = tmp_mean;

         }

         Mat evects1(count, len, ctype);

         gemm( eigenvectors, tmp_data, , Mat(), , evects1,

             (flags & CV_PCA_DATA_AS_COL) ? CV_GEMM_B_T : );

         eigenvectors = evects1;

         // normalize eigenvectors

         for( i = ; i < out_count; i++ )

         {

             Mat vec = eigenvectors.row(i);

             normalize(vec, vec);

         }

     }

     if( count > out_count )

     {

         // use clone() to physically copy the data and thus deallocate the original matrices

         eigenvalues = eigenvalues.rowRange(,out_count).clone();

         eigenvectors = eigenvectors.rowRange(,out_count).clone();

     }

     return *this;

 }

PCA类核心代码

 void Eigenfaces::predict(InputArray _src, int &minClass, double &minDist) const {

     // get data

     Mat src = _src.getMat();

     // make sure the user is passing correct data

     if(_projections.empty()) {

         // throw error if no data (or simply return -1?)

         string error_message = "This Eigenfaces model is not computed yet. Did you call Eigenfaces::train?";

         CV_Error(CV_StsError, error_message);

     } else if(_eigenvectors.rows != static_cast<int>(src.total())) {

         // check data alignment just for clearer exception messages

         string error_message = format("Wrong input image size. Reason: Training and Test images must be of equal size! Expected an image with %d elements, but got %d.", _eigenvectors.rows, src.total());

         CV_Error(CV_StsBadArg, error_message);

     }

     // project into PCA subspace

     Mat q = subspaceProject(_eigenvectors, _mean, src.reshape(,));

     minDist = DBL_MAX;

     minClass = -;

     for(size_t sampleIdx = ; sampleIdx < _projections.size(); sampleIdx++) {

         double dist = norm(_projections[sampleIdx], q, NORM_L2);

         if((dist < minDist) && (dist < _threshold)) {

             minDist = dist;

             minClass = _labels.at<int>((int)sampleIdx);

         }

     }

 }

人脸识别核心代码

 #include "opencv2/core/core.hpp"

 #include "opencv2/highgui/highgui.hpp"

 #include "opencv2/contrib/contrib.hpp"

 #define CV_VERSION_ID       CVAUX_STR(CV_MAJOR_VERSION) CVAUX_STR(CV_MINOR_VERSION) CVAUX_STR(CV_SUBMINOR_VERSION)

 #ifdef _DEBUG

 #define cvLIB(name) "opencv_" name CV_VERSION_ID "d"

 #else

 #define cvLIB(name) "opencv_" name CV_VERSION_ID

 #endif

 #pragma comment( lib, cvLIB("core") )

 #pragma comment( lib, cvLIB("imgproc") )

 #pragma comment( lib, cvLIB("highgui") )

 #pragma comment( lib, cvLIB("flann") )

 #pragma comment( lib, cvLIB("features2d") )

 #pragma comment( lib, cvLIB("calib3d") )

 #pragma comment( lib, cvLIB("gpu") )

 #pragma comment( lib, cvLIB("legacy") )

 #pragma comment( lib, cvLIB("ml") )

 #pragma comment( lib, cvLIB("objdetect") )

 #pragma comment( lib, cvLIB("ts") )

 #pragma comment( lib, cvLIB("video") )

 #pragma comment( lib, cvLIB("contrib") )

 #pragma comment( lib, cvLIB("nonfree") )

 #include <iostream>

 #include <fstream>

 #include <sstream>

 using namespace cv;

 using namespace std;

 static Mat toGrayscale(InputArray _src) {

     Mat src = _src.getMat();

     // only allow one channel

     if(src.channels() != ) {

         CV_Error(CV_StsBadArg, "Only Matrices with one channel are supported");

     }

     // create and return normalized image

     Mat dst;

     cv::normalize(_src, dst, , , NORM_MINMAX, CV_8UC1);

     return dst;

 }

 static void read_csv(const string& filename, vector<Mat>& images, vector<int>& labels, char separator = ';') {

     std::ifstream file(filename.c_str(), ifstream::in);

     if (!file) {

         string error_message = "No valid input file was given, please check the given filename.";

         CV_Error(CV_StsBadArg, error_message);

     }

     string line, path, classlabel;

     while (getline(file, line)) {

         stringstream liness(line);

         getline(liness, path, separator);

         getline(liness, classlabel);

         if(!path.empty() && !classlabel.empty()) {

             images.push_back(imread(path, ));

             labels.push_back(atoi(classlabel.c_str()));

         }

     }

 }

 int main(int argc, const char *argv[]) {

     // Check for valid command line arguments, print usage

     // if no arguments were given.

     if (argc != ) {

         cout << "usage: " << argv[] << " <csv.ext>" << endl;

         exit();

     }

     // Get the path to your CSV.

     string fn_csv = string(argv[]);

     // These vectors hold the images and corresponding labels.

     vector<Mat> images;

     vector<int> labels;

     // Read in the data. This can fail if no valid

     // input filename is given.

     try {

         read_csv(fn_csv, images, labels);

     } catch (cv::Exception& e) {

         cerr << "Error opening file \"" << fn_csv << "\". Reason: " << e.msg << endl;

         // nothing more we can do

         exit();

     }

     // Quit if there are not enough images for this demo.

     if(images.size() <= ) {

         string error_message = "This demo needs at least 2 images to work. Please add more images to your data set!";

         CV_Error(CV_StsError, error_message);

     }

     // Get the height from the first image. We'll need this

     // later in code to reshape the images to their original

     // size:

     int height = images[].rows;

     // The following lines simply get the last images from

     // your dataset and remove it from the vector. This is

     // done, so that the training data (which we learn the

     // cv::FaceRecognizer on) and the test data we test

     // the model with, do not overlap.

     Mat testSample = images[images.size() - ];

     int testLabel = labels[labels.size() - ];

     images.pop_back();

     labels.pop_back();

     // The following lines create an Eigenfaces model for

     // face recognition and train it with the images and

     // labels read from the given CSV file.

     // This here is a full PCA, if you just want to keep

     // 10 principal components (read Eigenfaces), then call

     // the factory method like this:

     //

     //      cv::createEigenFaceRecognizer(10);

     //

     // If you want to create a FaceRecognizer with a

     // confidennce threshold, call it with:

     //

     //      cv::createEigenFaceRecognizer(10, 123.0);

     //

     Ptr<FaceRecognizer> model = createEigenFaceRecognizer();

     model->train(images, labels);

     // The following line predicts the label of a given

     // test image:

     int predictedLabel = model->predict(testSample);

     //

     // To get the confidence of a prediction call the model with:

     //

     //      int predictedLabel = -1;

     //      double confidence = 0.0;

     //      model->predict(testSample, predictedLabel, confidence);

     //

     string result_message = format("Predicted class = %d / Actual class = %d.", predictedLabel, testLabel);

     cout << result_message << endl;

     // Sometimes you'll need to get/set internal model data,

     // which isn't exposed by the public cv::FaceRecognizer.

     // Since each cv::FaceRecognizer is derived from a

     // cv::Algorithm, you can query the data.

     //

     // First we'll use it to set the threshold of the FaceRecognizer

     // to 0.0 without retraining the model. This can be useful if

     // you are evaluating the model:

     //

     model->set("threshold", 0.0);

     // Now the threshold of this model is set to 0.0. A prediction

     // now returns -1, as it's impossible to have a distance below

     // it

     predictedLabel = model->predict(testSample);

     cout << "Predicted class = " << predictedLabel << endl;

     // Here is how to get the eigenvalues of this Eigenfaces model:

     Mat eigenvalues = model->getMat("eigenvalues");

     // And we can do the same to display the Eigenvectors (read Eigenfaces):

     Mat W = model->getMat("eigenvectors");

     // From this we will display the (at most) first 10 Eigenfaces:

     for (int i = ; i < min(, W.cols); i++) {

         string msg = format("Eigenvalue #%d = %.5f", i, eigenvalues.at<double>(i));

         cout << msg << endl;

         // get eigenvector #i

         Mat ev = W.col(i).clone();

         // Reshape to original size & normalize to [0...255] for imshow.

         Mat grayscale = toGrayscale(ev.reshape(, height));

         // Show the image & apply a Jet colormap for better sensing.

         Mat cgrayscale;

         applyColorMap(grayscale, cgrayscale, COLORMAP_JET);

         imshow(format("%d", i), cgrayscale);

     }

     waitKey();

     return ;

 }