cv::Mat MainWindow::detectAndDraw_image(cv::Mat& img, cv::Ptr<cv::cuda::CascadeClassifier>& cascade,
    cv::Ptr<cv::cuda::CascadeClassifier>& nestedCascade,
    cv::Ptr<cv::cuda::CascadeClassifier>& eyesCascade,
    double& scale)
//cv::Mat MainWindow::detectAndDraw_image(cv::Mat& img, cv::CascadeClassifier& cascade,
//    cv::CascadeClassifier nestedCascade,
//    cv::CascadeClassifier eyesCascade,
//    double& scale)
{
    vector<Rect> faces;
    int face_smile = 0;
    const static Scalar colors[] =
    {
        Scalar(255,0,0),
        Scalar(255,128,0),
        Scalar(255,255,0),
        Scalar(0,255,0),
        Scalar(0,128,255),
        Scalar(0,255,255),
        Scalar(0,0,255),
        Scalar(255,0,255)
    };
    Mat gray, smallImg;

    cv::cvtColor(img, gray, COLOR_BGR2GRAY);

    double fx = 1 / scale;
    cv::resize(gray, smallImg, Size(), fx, fx, INTER_LINEAR_EXACT);
    cv::equalizeHist(smallImg, smallImg);

    cv::cuda::GpuMat smallImg_cuda(smallImg);
    cv::cuda::GpuMat faces_cuda;
    cascade->setScaleFactor(1.1);
    cascade->setMinNeighbors(2);
    cascade->detectMultiScale(smallImg_cuda, faces_cuda);
    if(!faces_cuda.empty())
        cascade->convert(faces_cuda,faces);





//    cascade.detectMultiScale(smallImg, faces,
//        1.1, 2, 0
//        //|CASCADE_FIND_BIGGEST_OBJECT
//        //|CASCADE_DO_ROUGH_SEARCH
//        | CASCADE_SCALE_IMAGE,
//        Size(30, 30));


    for (size_t i = 0; i < faces.size(); i++)
    {
        Rect r = faces[i];
        Mat smallImgROI;
        vector<Rect> nestedObjects;
        vector<Rect> eyesObjects;


        cv::cuda::GpuMat nestedObjects_cuda;
        cv::cuda::GpuMat eyesObjects_cuda;

        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)
        {
            rectangle(img, cvPoint(cvRound(r.x*scale), cvRound(r.y*scale)),
                cvPoint(cvRound((r.x + r.width - 1)*scale), cvRound((r.y + r.height - 1)*scale)),
                color, 2, 8, 0);
        }
        else
            rectangle(img, cvPoint(cvRound(r.x*scale), cvRound(r.y*scale)),
                cvPoint(cvRound((r.x + r.width - 1)*scale), cvRound((r.y + r.height - 1)*scale)),
                color, 3, 8, 0);

        const int half_height = cvRound((float)r.height / 2);
        r.y = r.y + half_height;
        r.height = half_height - 1;
        smallImgROI = smallImg(r);
        cv::cuda::GpuMat smallImgROI_cuda(smallImgROI);


//        eyesCascade->setScaleFactor(1.1);
//        eyesCascade->setMinNeighbors(2);
//        eyesCascade->detectMultiScale(smallImgROI_cuda, eyesObjects_cuda);
//        eyesCascade->convert(eyesObjects_cuda,eyesObjects);



//        eyesCascade.detectMultiScale(smallImgROI, eyesObjects,
//            1.1, 2, 0
//            //|CASCADE_FIND_BIGGEST_OBJECT
//            //|CASCADE_DO_ROUGH_SEARCH
//            //|CASCADE_DO_CANNY_PRUNING
//            | CASCADE_SCALE_IMAGE,
//            Size(30, 30));

        nestedCascade->setScaleFactor(1.4);
        nestedCascade->setMinNeighbors(0);
        nestedCascade->detectMultiScale(smallImgROI_cuda, nestedObjects_cuda);
        if(!nestedObjects_cuda.empty())
            nestedCascade->convert(nestedObjects_cuda,nestedObjects);



//        nestedCascade.detectMultiScale( smallImgROI, nestedObjects,
//            1.1, 0, 0
//            //|CASCADE_FIND_BIGGEST_OBJECT
//            //|CASCADE_DO_ROUGH_SEARCH
//            //|CASCADE_DO_CANNY_PRUNING
//            |CASCADE_SCALE_IMAGE,
//            Size(30, 30));





//        for (size_t  g = 0; g < eyesObjects.size(); g++)
//        {
//            center;
//            Rect nr = eyesObjects[g];
//            center.x = cvRound((r.x + nr.x + nr.width*0.5)*scale);
//            center.y = cvRound((r.y + nr.y + nr.height*0.5)*scale);
//            int radius = cvRound((nr.width + nr.height)*0.25*scale);
//            circle(img, center, radius, color, 1.5, 8, 0);
//        }

        // The number of detected neighbors depends on image size (and also illumination, etc.). The
        // following steps use a floating minimum and maximum of neighbors. Intensity thus estimated will be
        //accurate only after a first smile has been displayed by the user.
        const int smile_neighbors = (int)nestedObjects.size();


        static int max_neighbors = -1;
        static int min_neighbors = -1;
        if (min_neighbors == -1) min_neighbors = smile_neighbors;
        max_neighbors = MAX(max_neighbors, smile_neighbors);

            // Draw rectangle on the left side of the image reflecting smile intensity
        float intensityZeroOne = ((float)smile_neighbors - min_neighbors) / (max_neighbors - min_neighbors + 1);
        int rect_height = cvRound((float)img.rows * intensityZeroOne);
        Scalar col = Scalar((float)255 * intensityZeroOne, 0, 0);
        //rectangle(img, cvPoint(0, img.rows), cvPoint(img.cols / 10, img.rows - rect_height), col, -1);
        CvPoint pt = cvPoint( cvRound(r.x)-30, cvRound(r.y));

        if (intensityZeroOne > 0.6)
        {
            CvFont font;
            cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX, 1.0, 1.0, 0, 1, CV_AA);
            // используя шрифт выводим на картинку текст
            //cvPutText((CvArr*)img, "Smile!", pt, &font, CV_RGB(150, 0, 150));
            putText(img, "Smile!", pt, CV_FONT_HERSHEY_COMPLEX, 1.1,
                Scalar::all(255), 2, 8);
            face_smile++;
         }
        else
        {
            CvFont font;
            cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX, 1.0, 1.0, 0, 1, CV_AA);
            // используя шрифт выводим на картинку текст
            //cvPutText((CvArr*)img, "Smile!", pt, &font, CV_RGB(150, 0, 150));
            putText(img, "Neutral!", pt, CV_FONT_HERSHEY_COMPLEX, 1.1,
                Scalar::all(255), 2, 8);


        }

        pt = NULL;



    }
    faces_size_all = faces.size();
    smiles.push_back(face_smile);

    return img;
}