1.Got code form Github link of opencv site

    #include "opencv2/objdetect.hpp"
    #include "opencv2/imgcodecs.hpp"
    #include "opencv2/videoio.hpp"
    #include "opencv2/highgui.hpp"
    #include "opencv2/imgproc.hpp"
    #include "opencv2/core/utility.hpp"
    #include "opencv2/core/ocl.hpp"

    #include <cctype>
    #include <iostream>
    #include <iterator>
    #include <stdio.h>

    using namespace std;
    using namespace cv;

    static void help()
    {
        cout << "\nThis program demonstrates the cascade recognizer. Now you can use Haar or LBP features.\n"
                "This classifier can recognize many kinds of rigid objects, once the appropriate classifier is trained.\n"
                "It's most known use is for faces.\n"
                "Usage:\n"
                "./facedetect [--cascade=<cascade_path> this is the primary trained classifier such as frontal face]\n"
                   "   [--nested-cascade[=nested_cascade_path this an optional secondary classifier such as eyes]]\n"
                   "   [--scale=<image scale greater or equal to 1, try 1.3 for example>]\n"
                   "   [--try-flip]\n"
                   "   [filename|camera_index]\n\n"
                "see facedetect.cmd for one call:\n"
                "./facedetect --cascade=\"../../data/haarcascades/haarcascade_frontalface_alt.xml\" --nested-cascade=\"../../data/haarcascades/haarcascade_eye.xml\" --scale=1.3\n\n"
                "During execution:\n\tHit any key to quit.\n"
                "\tUsing OpenCV version " << CV_VERSION << "\n" << endl;
    }

    void detectAndDraw( UMat& img, Mat& canvas, CascadeClassifier& cascade,
                        CascadeClassifier& nestedCascade,
                        double scale, bool tryflip );

    string cascadeName = "../../data/haarcascades/haarcascade_frontalface_alt.xml";
    string nestedCascadeName = "../../data/haarcascades/haarcascade_eye_tree_eyeglasses.xml";

    int main( int argc, const char** argv )
    {
        VideoCapture capture;
        UMat frame, image;
        Mat canvas;
        const string scaleOpt = "--scale=";
        size_t scaleOptLen = scaleOpt.length();
        const string cascadeOpt = "--cascade=";
        size_t cascadeOptLen = cascadeOpt.length();
        const string nestedCascadeOpt = "--nested-cascade";
        size_t nestedCascadeOptLen = nestedCascadeOpt.length();
        const string tryFlipOpt = "--try-flip";
        size_t tryFlipOptLen = tryFlipOpt.length();
        String inputName;
        bool tryflip = false;

        help();

        CascadeClassifier cascade, nestedCascade;
        double scale = 1;

        for( int i = 1; i < argc; i++ )
        {
            cout << "Processing " << i << " " <<  argv[i] << endl;
            if( cascadeOpt.compare( 0, cascadeOptLen, argv[i], cascadeOptLen ) == 0 )
            {
                cascadeName.assign( argv[i] + cascadeOptLen );
                cout << "  from which we have cascadeName= " << cascadeName << endl;
            }
            else if( nestedCascadeOpt.compare( 0, nestedCascadeOptLen, argv[i], nestedCascadeOptLen ) == 0 )
            {
                if( argv[i][nestedCascadeOpt.length()] == '=' )
                    nestedCascadeName.assign( argv[i] + nestedCascadeOpt.length() + 1 );
                if( !nestedCascade.load( nestedCascadeName ) )
                    cerr << "WARNING: Could not load classifier cascade for nested objects" << endl;
            }
            else if( scaleOpt.compare( 0, scaleOptLen, argv[i], scaleOptLen ) == 0 )
            {
                if( !sscanf( argv[i] + scaleOpt.length(), "%lf", &scale ) || scale > 1 )
                    scale = 1;
                cout << " from which we read scale = " << scale << endl;
            }
            else if( tryFlipOpt.compare( 0, tryFlipOptLen, argv[i], tryFlipOptLen ) == 0 )
            {
                tryflip = true;
                cout << " will try to flip image horizontally to detect assymetric objects\n";
            }
            else if( argv[i][0] == '-' )
            {
                cerr << "WARNING: Unknown option %s" << argv[i] << endl;
            }
            else
                inputName = argv[i];
        }

        if( !cascade.load( cascadeName ) )
        {
            cerr << "ERROR: Could not load classifier cascade" << endl;
            help();
            return -1;
        }

        cout << "old cascade: " << (cascade.isOldFormatCascade() ? "TRUE" : "FALSE") << endl;

        if( inputName.empty() || (isdigit(inputName.c_str()[0]) && inputName.c_str()[1] == '\0') )
        {
            int c = inputName.empty() ? 0 : inputName.c_str()[0] - '0';
            if(!capture.open(c))
                cout << "Capture from camera #" <<  c << " didn't work" << endl;
        }
        else
        {
            if( inputName.empty() )
                inputName = "../data/lena.jpg";
            image = imread( inputName, 1 ).getUMat(ACCESS_READ);
            if( image.empty() )
            {
                if(!capture.open( inputName ))
                    cout << "Could not read " << inputName << endl;
            }
        }

        namedWindow( "result", 1 );

        if( capture.isOpened() )
        {
            cout << "Video capturing has been started ..." << endl;
            for(;;)
            {
                capture >> frame;
                if( frame.empty() )
                    break;

                detectAndDraw( frame, canvas, cascade, nestedCascade, scale, tryflip );

                if( waitKey( 10 ) >= 0 )
                    break;
            }
        }
        else
        {
            cout << "Detecting face(s) in " << inputName << endl;
            if( !image.empty() )
            {
                detectAndDraw( image, canvas, cascade, nestedCascade, scale, tryflip );
                waitKey(0);
            }
            else if( !inputName.empty() )
            {
                /* assume it is a text file containing the
                list of the image filenames to be processed - one per line */
                FILE* f = fopen( inputName.c_str(), "rt" );
                if( f )
                {
                    char buf[1000+1];
                    while( fgets( buf, 1000, f ) )
                    {
                        int len = (int)strlen(buf), c;
                        while( len > 0 && isspace(buf[len-1]) )
                            len--;
                        buf[len] = '\0';
                        cout << "file " << buf << endl;
                        image = imread( buf, 1 ).getUMat(ACCESS_READ);
                        if( !image.empty() )
                        {
                            detectAndDraw( image, canvas, cascade, nestedCascade, scale, tryflip );
                            c = waitKey(0);
                            if( c == 27 || c == 'q' || c == 'Q' )
                                break;
                        }
                        else
                        {
                            cerr << "Aw snap, couldn't read image " << buf << endl;
                        }
                    }
                    fclose(f);
                }
            }
        }

        return 0;
    }

    void detectAndDraw( UMat& img, Mat& canvas, CascadeClassifier& cascade,
                        CascadeClassifier& nestedCascade,
                        double scale0, bool tryflip )
    {
        int i = 0;
        double t = 0, scale=1;
        vector<Rect> faces, faces2;
        const static Scalar colors[] =
        {
            Scalar(0,0,255),
            Scalar(0,128,255),
            Scalar(0,255,255),
            Scalar(0,255,0),
            Scalar(255,128,0),
            Scalar(255,255,0),
            Scalar(255,0,0),
            Scalar(255,0,255)
        };
        static UMat gray, smallImg;

        t = (double)getTickCount();

        resize( img, smallImg, Size(), scale0, scale0, INTER_LINEAR );
        cvtColor( smallImg, gray, COLOR_BGR2GRAY );
        equalizeHist( gray, gray );

        cascade.detectMultiScale( gray, faces,
            1.1, 3, 0
            //|CASCADE_FIND_BIGGEST_OBJECT
            //|CASCADE_DO_ROUGH_SEARCH
            |CASCADE_SCALE_IMAGE
            ,
            Size(30, 30) );
        if( tryflip )
        {
            flip(gray, gray, 1);
            cascade.detectMultiScale( gray, faces2,
                                     1.1, 2, 0
                                     //|CASCADE_FIND_BIGGEST_OBJECT
                                     //|CASCADE_DO_ROUGH_SEARCH
                                     |CASCADE_SCALE_IMAGE
                                     ,
                                     Size(30, 30) );
            for( vector<Rect>::const_iterator r = faces2.begin(); r != faces2.end(); r++ )
            {
                faces.push_back(Rect(smallImg.cols - r->x - r->width, r->y, r->width, r->height));
            }
        }
        t = (double)getTickCount() - t;
        smallImg.copyTo(canvas);

        double fps = getTickFrequency()/t;
        static double avgfps = 0;
        static int nframes = 0;
        nframes++;
        double alpha = nframes > 50 ? 0.01 : 1./nframes;
        avgfps = avgfps*(1-alpha) + fps*alpha;

        putText(canvas, format("OpenCL: %s, fps: %.1f", ocl::useOpenCL() ? "ON" : "OFF", avgfps), Point(50, 30),
                FONT_HERSHEY_SIMPLEX, 0.8, Scalar(0,255,0), 2);

        for( vector<Rect>::const_iterator r = faces.begin(); r != faces.end(); r++, i++ )
        {
            vector<Rect> nestedObjects;
            Point center;
            Scalar color = colors[i%8];
            int radius;

            double aspect_ratio = (double)r->width/r->height;
            if( 0.75 < aspect_ratio && aspect_ratio < 1.3 )
            {
                center.x = cvRound((r->x + r->width*0.5)*scale);
                center.y = cvRound((r->y + r->height*0.5)*scale);
                radius = cvRound((r->width + r->height)*0.25*scale);
                circle( canvas, center, radius, color, 3, 8, 0 );
            }
            else
                rectangle( canvas, Point(cvRound(r->x*scale), cvRound(r->y*scale)),
                           Point(cvRound((r->x + r->width-1)*scale), cvRound((r->y + r->height-1)*scale)),
                           color, 3, 8, 0);
            if( nestedCascade.empty() )
                continue;
            UMat smallImgROI = gray(*r);
            nestedCascade.detectMultiScale( smallImgROI, nestedObjects,
                1.1, 2, 0
                //|CASCADE_FIND_BIGGEST_OBJECT
                //|CASCADE_DO_ROUGH_SEARCH
                //|CASCADE_DO_CANNY_PRUNING
                |CASCADE_SCALE_IMAGE
                ,
                Size(30, 30) );
            for( vector<Rect>::const_iterator nr = nestedObjects.begin(); nr != nestedObjects.end(); nr++ )
            {
                center.x = cvRound((r->x + nr->x + nr->width*0.5)*scale);
                center.y = cvRound((r->y + nr->y + nr->height*0.5)*scale);
                radius = cvRound((nr->width + nr->height)*0.25*scale);
                circle( canvas, center, radius, color, 3, 8, 0 );
            }
        }
        imshow( "result", canvas );
    }