C++ Ptr::predict方法代码示例

    // predict image in the memory
    void predictImage( cv::Mat &face, std::vector<int> &predict_result, std::vector<double> &predict_confidence, double predicted_confidence = 0.0 )
    {

        //resize image
        cv::resize(face, face, cv::Size(1000, 1000));

        int predicted_label = -1;

        //push results from all three methods to one vector

        //eigenfaces
        eigenfaceRecognizor->predict(face, predicted_label, predicted_confidence);
        predict_result.push_back(predicted_label);
        predict_confidence.push_back(predicted_confidence);


        //fisherfaces
        fisherfaceRecognizor->predict(face, predicted_label, predicted_confidence);
        predict_result.push_back(predicted_label);
        predict_confidence.push_back(predicted_confidence);



        //LBPH
        LBPHRecognizor->predict(face, predicted_label, predicted_confidence);
        predict_result.push_back(predicted_label);
        predict_confidence.push_back(predicted_confidence);
    }

void TellThatToMyCamera_v1_0App::updateExpressions (Surface cameraImage){
	cv::Mat grayCameraImage( toOcv( cameraImage, CV_8UC1 ) );   // create a grayscale copy of the input image
   	cv::equalizeHist( grayCameraImage, grayCameraImage );       // equalize the histogram for (just a little) more accuracy
    mExpressions.clear();                                       // clear out the previously deteced expressions
    mPredictions.clear();
    vector<cv::Rect> expressions;
    
    // Next is to detect the faces and iterate them, appending them to mExpressions
    mExpressionsCascade.detectMultiScale(grayCameraImage, expressions);
    
    // At this point the position of the faces has been calculated!
    // Now it's time to get the faces, make a prediction and save it for the video.
    
    cv::Mat graySq(100,100,CV_8UC1);    // gray square for assigning the proper size of the resized detected faces
    
    for(vector<cv::Rect>::const_iterator expressionIter = expressions.begin(); expressionIter != expressions.end(); ++expressionIter){
        // Get the process face by face (in case there's more than one face in the video frame image)
        Rectf expressionRect(fromOcv(*expressionIter));
        mExpressions.push_back(expressionRect);
        
        cv::Rect face_i (*expressionIter);                      // Rect with data (size and position) of the detected face
        cv::Mat face = grayCameraImage(face_i);                 // Image containing the detected face
        cv::Mat face_resized;                                   // Image for the resized version of the detected face
        cv::resize(face, face_resized, graySq.size(), 1, 1, cv::INTER_CUBIC); // resizes the image
        // cv::resize(face, face_resized, graySq.size(), 0, 0, cv::INTER_LINEAR);
        
        // Now, perform the EXPRESSION PREDICTION!!!
        int predicted = mFisherFaceRec->predict(face_resized);
        mPredictions.push_back(predicted);                      // put the corresponding label to the corresponding face
    }
}

    void predict( std::string &image_path, std::vector<int> &predict_result, std::vector<double> &predict_confidence, double predicted_confidence = 0.0 )
    {

        std::vector<cv::Mat> faces_image;

        int predicted_label = -1;

        //make sure there is no previous result
        predict_result.clear();
        predict_confidence.clear();


        for( cv::Mat face : faces_image )
        {

            //turn it to grey image and adjust size
            cv::cvtColor(face, face, CV_BGR2GRAY);
            cv::resize(face, face, cv::Size(500, 500));


            //push results from all three methods to one vector

            //eigenfaces
            eigenfaceRecognizor->predict(face, predicted_label, predicted_confidence);
            predict_result.push_back(predicted_label);
            predict_confidence.push_back(predicted_confidence);


            //fisherfaces
            fisherfaceRecognizor->predict(face, predicted_label, predicted_confidence);
            predict_result.push_back(predicted_label);
            predict_confidence.push_back(predicted_confidence);



            //LBPH
            LBPHRecognizor->predict(face, predicted_label, predicted_confidence);
            predict_result.push_back(predicted_label);
            predict_confidence.push_back(predicted_confidence);

        }


        //blur stranger's face
//        detector->blurFacesOrigin(image_path);
    }

    void predictSingle( const std::string &image_path, std::vector<int> &predict_result, std::vector<double> &predict_confidence, double predicted_confidence = 0.0 )
    {

        //read image
        cv::Mat face = cv::imread(image_path);

        if( ! face.data )
        {
            std::cout << "Can not find image!" << std::endl;
        }

        //turn it to grey image and adjust size
        cv::cvtColor(face, face, CV_BGR2GRAY);
        cv::resize(face, face, cv::Size(500, 500));

        int predicted_label = -1;

        //push results from all three methods to one vector

        //eigenfaces
        eigenfaceRecognizor->predict(face, predicted_label, predicted_confidence);
        predict_result.push_back(predicted_label);
        predict_confidence.push_back(predicted_confidence);


        //fisherfaces
        fisherfaceRecognizor->predict(face, predicted_label, predicted_confidence);
        predict_result.push_back(predicted_label);
        predict_confidence.push_back(predicted_confidence);



        //LBPH
        LBPHRecognizor->predict(face, predicted_label, predicted_confidence);
        predict_result.push_back(predicted_label);
        predict_confidence.push_back(predicted_confidence);
    }

void FaceRecognition::detectAndDraw(cv::Mat image,
                                    cv::CascadeClassifier &cascade,
                                    cv::CascadeClassifier &nested_cascade,
                                    double scale,
                                    bool try_flip)
{
    int    i    = 0;
    double tick = 0.0;
    std::vector<cv::Rect> faces_a, faces_b;
    cv::Scalar colors[] = {
        CV_RGB(0, 0, 255),
        CV_RGB(0, 128, 255),
        CV_RGB(0, 255, 255),
        CV_RGB(0, 255, 0),
        CV_RGB(255, 128, 0),
        CV_RGB(255, 255, 0),
        CV_RGB(255, 0, 0),
        CV_RGB(255, 0, 255)
    };
    cv::Mat image_gray;
    cv::Mat image_small(cvRound(image.rows / scale),
                        cvRound(image.cols / scale),
                        CV_8UC1);
    // Convert to gray image.
    cv::cvtColor(image, image_gray, CV_BGR2GRAY);
    // Convert gray image to small size.
    cv::resize(image_gray, image_small, image_small.size(), 0, 0,
               cv::INTER_LINEAR);
    cv::equalizeHist(image_small, image_small);

    tick = (double)cvGetTickCount();
    cascade.detectMultiScale(image_small, faces_a, 1.1, 2, 0 |
                             CV_HAAR_SCALE_IMAGE, cv::Size(30, 30));

    if (try_flip) {
        cv::flip(image_small, image_small, 1);
        cascade.detectMultiScale(image_small, faces_b, 1.1, 2, 0 |
                                 CV_HAAR_SCALE_IMAGE, cv::Size(30, 30));
        std::vector<cv::Rect>::const_iterator it = faces_b.begin();
        for (; it != faces_b.end(); it++) {
            faces_a.push_back(cv::Rect(image_small.cols - it->x - it->width,
                                       it->y, it->width, it->height));
        }
    }

    // Calculate detection's time.
    tick = (double)cvGetTickCount() - tick;
    std::cout << "Detection time: "
              << tick / ((double)cvGetTickCount() * 1000.0)
              << " ms"
              << std::endl;

    std::vector<cv::Rect>::const_iterator it = faces_a.begin();
    for (; it != faces_a.end(); it++, i++) {
        int radius;
        double aspect_ratio = (double)it->width / it->height;
        std::vector<cv::Rect> nested_objects;
        cv::Mat small_image_roi;
        cv::Point center;
        cv::Scalar color = colors[i % 8];

        // Capture detected face and predict it.
        cv::Mat image_gray;
        cv::Mat image_result(cvRound(IMG_HEIGH), cvRound(IMG_WIDTH), CV_8UC1);
        cv::Mat image_temp;
        cv::Rect rect;
        rect.x = cvRound(it->x * scale);
        rect.y = cvRound(it->y * scale);
        rect.height = cvRound(it->height * scale);
        rect.width  = cvRound(it->width  * scale);
        image_temp  = image(rect);
        cv::cvtColor(image_temp, image_gray, CV_BGR2GRAY);
        cv::resize(image_gray, image_result, image_result.size(), 0, 0,
                   cv::INTER_LINEAR);
        int predicted_label = g_model->predict(image_result);

        std::cout << "*************************" << std::endl
                  << "The predicted label: "     << predicted_label
                  << std::endl
                  << "*************************"
                  << std::endl;

        // Recognize specific face for sending character to serial device.
        if (predicted_label == 1) {
            g_face_recognition.writeCharToSerial('Y');
        }
        else {
            g_face_recognition.writeCharToSerial('N');
        }

        // Draw the circle for faces.
        if (0.75 < aspect_ratio && aspect_ratio > 1.3) {
            center.x = cvRound((it->x + it->width * 0.5) * scale);
            center.y = cvRound((it->y + it->height * 0.5) * scale);
            radius = cvRound((it->width + it->height) * 0.25 * scale);
            cv::circle(image, center, radius, color, 3, 8, 0);
        }
        else {
            // Draw the rectangle for faces.
            cv::rectangle(image,
//.........这里部分代码省略.........