find-face-opencv.cpp

#include <iostream>  
#include <vector>  
#include <opencv2/highgui.hpp>  
#include <opencv2/imgproc.hpp>  
#include <opencv2/core.hpp>  
#include <opencv2/videoio.hpp>  
#include <opencv2/opencv.hpp>  
#include <opencv2/opencv_modules.hpp>  
#include <opencv2/cudaobjdetect.hpp>  
#include <opencv2/cudaimgproc.hpp>  
  
  
using namespace cv;  
using namespace std;  
  
#define isGPU (true)  
#define __DEBPRINT__    (true)  
#define __SHOWFRAMENO__ (true)  
#define __SHOWRECTSIZE__ (true)  
#define STRLEN_FOR_INFORMATION (1024)  
  
/* Global variables */  
  
String face_cascade_HAAR = "/mnt/opencv_compile/opencv/data/haarcascades_cuda/haarcascade_frontalface_default.xml";  
String face_cascade_name1 = face_cascade_HAAR;  
String window_name = "OPENCV-CUDA-Yuz Tespit";  
  
  
int main(int argc,char* argv[])  
{  
  
  
    //------------------------  
    // OpenCV Versiyonu.  
    //------------------------  
    cout << "OpenCV " << CV_VERSION << endl;  
  
  
    //------------------------  
    // Cascade Nesnesini oluşturup, yüz tespiti için yükliyoruz.  
    //------------------------  
    cout << "(" << face_cascade_name1 << ") dosyası kullanarak cascade sınıflandırma yapılacak." << endl;  
//cpu cascade  
    Ptr<cv::CascadeClassifier> h_face_cascade;  
//gpu cascade  
    Ptr<cuda::CascadeClassifier> d_face_cascade;  
    if (isGPU)  
    {  
        d_face_cascade = cv::cuda::CascadeClassifier::create(face_cascade_name1);  
        if (NULL == d_face_cascade)  
        {  
            cout << "Yüz cascade sınıflandırıcısı yüklenemedi." << endl;  
            return -1;  
        }  
    }  
    else  
    {  
        h_face_cascade = new CascadeClassifier();  
        if (NULL == h_face_cascade)  
        {  
            cout << "Yüz cascade sınıflandırıcısı yüklenemedi." << endl; return -1; } bool bResult = h_face_cascade->load(face_cascade_name1);  
        if (!bResult)  
        {  
            cout << "Yüz cascade sınıflandırıcısı yüklenemedi." << endl;  
            return -1;  
        }  
    }  
  
  
    //------------------------  
    // Videomuzu seçelim.  
    //------------------------  
    //cpu frame  
    Mat h_colorframe;  
  
    String videoFilename = "/home/forensic/Downloads/obama_putin.mp4";  
    cout << "Dosya aciliyor.(" << videoFilename << ")." << endl;  
    VideoCapture capture;  
    capture.open(videoFilename);  
    if(capture.isOpened())  
    {  
        cout << "Dosya acildi" << endl;  
  
        int frameNum = capture.get(CAP_PROP_FRAME_COUNT);  
        int currentFrame;  
  
        char* dispDetectedRect = (char*)malloc(STRLEN_FOR_INFORMATION * sizeof(char));  
        char* dispCurrentFrame = (char*)malloc(STRLEN_FOR_INFORMATION * sizeof(char));  
        if (NULL == dispCurrentFrame)  
        {  
            cout << "Heap Doldu!!" << endl;  
        }  
  
  
        //------------------------  
        // Videoyu gösterecek pencere  
        //------------------------  
        namedWindow(window_name, WINDOW_AUTOSIZE);  
        setWindowProperty(window_name, WINDOW_GUI_EXPANDED, WINDOW_AUTOSIZE);  
        int initialPos = 0;  
  
  
        //------------------------  
        // CPU için gerekli nesneler  
        //------------------------  
        Mat h_colorframe_orj;  
        Mat h_grayframe;  
        std::vector<Rect> h_faces;  
  
        Mat h_colorframe;  
  
  
  
        //------------------------  
        //  GPU için gerekli nesneler  
        //------------------------  
        cuda::GpuMat d_colorframe;  
        cuda::GpuMat d_grayframe;  
        cuda::GpuMat d_faces;  
  
  
        //------------------------  
        // Frameler geldikçe tespite devam edelim.  
        //------------------------  
        for(;;)  
        {  
            capture >> h_colorframe_orj;  
  
  
            if(h_colorframe_orj.empty())  
            {  
                break;  
            }  
  
  
            //------------------------  
            // Aldığımız frame'in boyutunu küçültüyoruz, griye çevirip, histogramı eşitliyoruz.  
            //------------------------  
            //boyut küçültürken INTER_AREA kullandık, siz isterseniz INTER_CUBIC kullanın  
            //ama INTER_AREA'nın daha hızlı olduğunu düşünüyorum. (Benchmark yapmadım)  
            cv::resize(h_colorframe_orj, h_colorframe, cv::Size(640, 480), 0, 0, cv::INTER_AREA);  
  
            if (isGPU)  
            {  
                //okuduğumuz frame'i gpu'ya veriyoruz.  
                d_colorframe.upload(h_colorframe);  
                cuda::cvtColor(d_colorframe, d_grayframe, CV_BGR2GRAY);  
                cuda::equalizeHist(d_grayframe, d_grayframe);  
  
            }  
            else  
            {  
                cvtColor(h_colorframe, h_grayframe, CV_BGR2GRAY);  
                equalizeHist(h_grayframe, h_grayframe);  
            }  
#if __DEBPRINT__  
            cout << "Frame gri'ye çevrildi ve eşitlendi." << endl; #endif           //------------------------ // Yüzleri tespit edelim. //------------------------            try { if (isGPU) { d_face_cascade->detectMultiScale(d_grayframe, d_faces);  
//          d_face_cascade->detectMultiScale(d_grayframe, d_faces, 1.05, 3, 0, Size(10, 10), Size(500, 500));  
//            tespit ettiğimiz yüzleri cpu'da kullanabilmek için dönüştürelim  
                    d_face_cascade->convert(d_faces, h_faces);  
                }  
                else  
                {  
  
                    h_face_cascade->detectMultiScale(h_grayframe, h_faces);  
                    h_face_cascade->detectMultiScale(h_grayframe, h_faces, 1.1, 3, 0, Size(30, 30), Size(500, 500));  
                }  
  
#if __DEBPRINT__  
                cout << "Tespit Tamamlandı" << endl;  
#endif  
  
                // Tespit edilen yüzlerin çevresini işaretleyelim.  
                for (size_t i = 0; i < h_faces.size(); i++)  
                {  
#if __SHOWRECTSIZE__  
                    sprintf(dispDetectedRect, "%4d, %4d", h_faces[i].width, h_faces[i].height);  
                    putText(h_colorframe, dispDetectedRect,  
                            Point(h_faces[i].x, h_faces[i].y - 10),  
                            FONT_ITALIC , 0.5, // yazı tipi-boyutu  
                            Scalar(255, 0, 255), // renk  
                            1, LINE_AA); // çizgi kalınlığı ve tipi  
#endif  
                    rectangle(h_colorframe, h_faces[i], Scalar( 255, 0, 255 ), 4, 8, 0 );  
                }  
  
  
  
  
                //------------------------  
                // Sonucu gösterelim.  
                //------------------------  
                Mat result = h_colorframe;  
#if __SHOWFRAMENO__  
                currentFrame = capture.get(CV_CAP_PROP_POS_FRAMES);  
                sprintf(dispCurrentFrame, "Frame Numarasi. : %08d", currentFrame);  
                if (isGPU)  
                {  
                    strcat(dispCurrentFrame, " Mod : GPU");  
                }  
                else  
                {  
                    strcat(dispCurrentFrame, " Mod : CPU");  
                }  
                putText(result, dispCurrentFrame,  
                        Point(20, 460),  
                        FONT_ITALIC , 0.5,  
                        Scalar(255, 255, 255),  
                        1, LINE_AA);  
  
#endif  
                imshow(window_name, result);  
                int keyCode = waitKey(1);  
                if (keyCode != -1)  
                {  
                    if ((char)keyCode == 'p')  
                    {  
                        putText(result, "DURDU",  
                                Point(200, 300),  
                                FONT_ITALIC , 2,  
                                Scalar(0, 0, 255),  
                                3, LINE_AA,false);  
                        imshow(window_name, result);  
                        waitKey(0);  
                    }  
                    else if ((char)keyCode == 'q')  
                    {  
                        break;  
                    }  
                    else  
                    {  
                        char dispKeyCode[64];  
                        sprintf(dispKeyCode, "Tus Kodu : %04d", keyCode);  
                        putText(result, dispKeyCode,  
                                Point(50, 50),  
                                FONT_ITALIC , 1,  
                                Scalar(0, 0, 255),  
                                3, LINE_AA);  
                        imshow(window_name, result);  
                    }  
                }  
  
            }  
            catch (Exception&amp; e)  
            {  
                cout << e.msg << endl;  
            }  
  
  
  
        }  
    }  
    else  
    {  
        cout << "Okunamadi" << endl;  
        h_colorframe = Mat::zeros(480, 640, CV_8UC1);  
        putText(h_colorframe, "Okunamadi",  
                                Point(20, 20),  
                                FONT_ITALIC , 1,  
                                Scalar(0, 0, 255),  
                                3, LINE_AA);  
        imshow("Bos", h_colorframe);  
        waitKey(0);  
    }  
  
    return 0;  
}