Opencv SkinOtsu皮肤检测

void SkinRGB(IplImage* rgb, IplImage* _dst)
{
    assert(rgb->nChannels ==  && _dst->nChannels == );

    static const int R = ;
    static const int G = ;
    static const int B = ;

    IplImage* dst = cvCreateImage(cvGetSize(_dst), , );
    cvZero(dst);

    for (int h = ; h<rgb->height; h++)
    {
        unsigned char* prgb = (unsigned char*)rgb->imageData + h*rgb->widthStep;
        unsigned char* pdst = (unsigned char*)dst->imageData + h*dst->widthStep;
        for (int w = ; w<rgb->width; w++)
        {
            if ((prgb[R]> && prgb[G]> && prgb[B]> &&
                prgb[R] - prgb[B]> && prgb[R] - prgb[G]>) ||//uniform illumination
                (prgb[R]> && prgb[G]> && prgb[B]> &&
                abs(prgb[R] - prgb[B]) <=  && prgb[R]>prgb[B] && prgb[G]>prgb[B])//lateral illumination
                )
            {
                memcpy(pdst, prgb, );
            }
            prgb += ;
            pdst += ;
        }
    }
    cvCopy(dst, _dst);
    cvReleaseImage(&dst);
}
// skin detection in rg space
void cvSkinRG(IplImage* rgb, IplImage* gray)
{
    assert(rgb->nChannels ==  && gray->nChannels == );

    const int R = ;
    const int G = ;
    const int B = ;

    double Aup = -1.8423;
    double Bup = 1.5294;
    double Cup = 0.0422;
    double Adown = -0.7279;
    double Bdown = 0.6066;
    double Cdown = 0.1766;
    for (int h = ; h<rgb->height; h++)
    {
        unsigned char* pGray = (unsigned char*)gray->imageData + h*gray->widthStep;
        unsigned char* pRGB = (unsigned char*)rgb->imageData + h*rgb->widthStep;
        for (int w = ; w<rgb->width; w++)
        {
            int s = pRGB[R] + pRGB[G] + pRGB[B];
            double r = (double)pRGB[R] / s;
            double g = (double)pRGB[G] / s;
            double Gup = Aup*r*r + Bup*r + Cup;
            double Gdown = Adown*r*r + Bdown*r + Cdown;
            double Wr = (r - 0.33)*(r - 0.33) + (g - 0.33)*(g - 0.33);
            if (g<Gup && g>Gdown && Wr>0.004)
            {
                *pGray = ;
            }
            else
            {
                *pGray = ;
            }
            pGray++;
            pRGB += ;
        }
    }

}
// implementation of otsu algorithm
// author: onezeros#yahoo.cn
// reference: Rafael C. Gonzalez. Digital Image Processing Using MATLAB
void cvThresholdOtsu(IplImage* src, IplImage* dst)
{
    int height = src->height;
    int width = src->width;

    //histogram
    float histogram[] = {  };
    for (int i = ; i<height; i++)
    {
        unsigned char* p = (unsigned char*)src->imageData + src->widthStep*i;
        for (int j = ; j<width; j++)
        {
            histogram[*p++]++;
        }
    }
    //normalize histogram
    int size = height*width;
    for (int i = ; i<; i++)
    {
        histogram[i] = histogram[i] / size;
    }

    //average pixel value
    float avgValue = ;
    for (int i = ; i<; i++)
    {
        avgValue += i*histogram[i];
    }

    int threshold;
    float maxVariance = ;
    float w = , u = ;
    for (int i = ; i<; i++)
    {
        w += histogram[i];
        u += i*histogram[i];

        float t = avgValue*w - u;
        float variance = t*t / (w*( - w));
        if (variance>maxVariance)
        {
            maxVariance = variance;
            threshold = i;
        }
    }

    cvThreshold(src, dst, threshold, , CV_THRESH_BINARY);
}

void cvSkinOtsu(IplImage* src, IplImage* dst)
{
    assert(dst->nChannels ==  && src->nChannels == );

    IplImage* ycrcb = cvCreateImage(cvGetSize(src), , );
    IplImage* cr = cvCreateImage(cvGetSize(src), , );
    cvCvtColor(src, ycrcb, CV_BGR2YCrCb);
    cvSplit(ycrcb, , cr, , );

    cvThresholdOtsu(cr, cr);
    cvCopy(cr, dst);
    cvReleaseImage(&cr);
    cvReleaseImage(&ycrcb);
}

void cvSkinYUV(IplImage* src, IplImage* dst)
{
    IplImage* ycrcb = cvCreateImage(cvGetSize(src), , );
    //IplImage* cr=cvCreateImage(cvGetSize(src),8,1);
    //IplImage* cb=cvCreateImage(cvGetSize(src),8,1);
    cvCvtColor(src, ycrcb, CV_BGR2YCrCb);
    //cvSplit(ycrcb,0,cr,cb,0);

    static const int Cb = ;
    static const int Cr = ;
    static const int Y = ;

    //IplImage* dst=cvCreateImage(cvGetSize(_dst),8,3);
    cvZero(dst);

    for (int h = ; h<src->height; h++)
    {
        unsigned char* pycrcb = (unsigned char*)ycrcb->imageData + h*ycrcb->widthStep;
        unsigned char* psrc = (unsigned char*)src->imageData + h*src->widthStep;
        unsigned char* pdst = (unsigned char*)dst->imageData + h*dst->widthStep;
        for (int w = ; w<src->width; w++)
        {
            if (pycrcb[Cr] >=  && pycrcb[Cr] <=  && pycrcb[Cb] >=  && pycrcb[Cb] <= )
            {
                memcpy(pdst, psrc, );
            }
            pycrcb += ;
            psrc += ;
            pdst += ;
        }
    }
    //cvCopyImage(dst,_dst);
    //cvReleaseImage(&dst);
}

void cvSkinHSV(IplImage* src, IplImage* dst)
{
    IplImage* hsv = cvCreateImage(cvGetSize(src), , );
    //IplImage* cr=cvCreateImage(cvGetSize(src),8,1);
    //IplImage* cb=cvCreateImage(cvGetSize(src),8,1);
    cvCvtColor(src, hsv, CV_BGR2HSV);
    //cvSplit(ycrcb,0,cr,cb,0);

    static const int V = ;
    static const int S = ;
    static const int H = ;

    //IplImage* dst=cvCreateImage(cvGetSize(_dst),8,3);
    cvZero(dst);

    for (int h = ; h<src->height; h++)
    {
        unsigned char* phsv = (unsigned char*)hsv->imageData + h*hsv->widthStep;
        unsigned char* psrc = (unsigned char*)src->imageData + h*src->widthStep;
        unsigned char* pdst = (unsigned char*)dst->imageData + h*dst->widthStep;
        for (int w = ; w<src->width; w++)
        {
            if (phsv[H] >=  && phsv[H] <= )
            {
                memcpy(pdst, psrc, );
            }
            phsv += ;
            psrc += ;
            pdst += ;
        }
    }
    //cvCopyImage(dst,_dst);
    //cvReleaseImage(&dst);
}

int main()
{

    //IplImage* img = cvLoadImage("C:\\C_C++ code\\Photo and video\\text009.jpg"); //随便放一张jpg图片在D盘或另行设置目录
    //IplImage* dstRGB = cvCreateImage(cvGetSize(img), 8, 3);
    //IplImage* dstRG = cvCreateImage(cvGetSize(img), 8, 1);

    //IplImage* dst_YUV = cvCreateImage(cvGetSize(img), 8, 3);
    //IplImage* dst_HSV = cvCreateImage(cvGetSize(img), 8, 3);

    cvNamedWindow("inputimage", CV_WINDOW_AUTOSIZE);
    cvShowImage("inputimage", img);
    cvWaitKey();
    SkinRGB(img, dstRGB);
    cvNamedWindow("SkinRGB", CV_WINDOW_AUTOSIZE);
    cvShowImage("SkinRGB", dstRGB);
    cvWaitKey();
    cvSkinRG(img, dstRG);
    cvNamedWindow("cvSkinRG", CV_WINDOW_AUTOSIZE);
    cvShowImage("cvSkinRG", dstRG);
    cvWaitKey();
    cvSkinOtsu(img, dst_crotsu);
    cvNamedWindow("cvSkinOtsu", CV_WINDOW_AUTOSIZE);
    cvShowImage("cvSkinOtsu", dst_crotsu);
    cvWaitKey();
    cvSkinYUV(img, dst_YUV);
    cvNamedWindow("cvSkinYUV", CV_WINDOW_AUTOSIZE);
    cvShowImage("cvSkinYUV", dst_YUV);
    cvWaitKey();
    cvSkinHSV(img, dst_HSV);
    cvNamedWindow("cvSkinHSV", CV_WINDOW_AUTOSIZE);
    cvShowImage("cvSkinHSV", dst_HSV);
    cvWaitKey();

    IplImage *src;
    //VideoCapture video("C:\\C_C++ EX8 code\\Video\\MyVideo.wmv");
    VideoCapture video();
    if (!video.isOpened())
    {
        return -;
    }
    cv::Mat img, dstimg;
    cv::Rect rect(, , , );
    video >> img;
    src = &(IplImage(img));
    IplImage* dst_crotsu = cvCreateImage(cvGetSize(src), , );
    while ()
    {
        video >> img;
        src = &(IplImage(img));
        cvSkinOtsu(src, dst_crotsu);
        cvNamedWindow("cvSkinOtsu", CV_WINDOW_AUTOSIZE);

        Mat output = cvarrToMat(dst_crotsu);
        cv::erode(output, output, cv::Mat());
        cv::erode(output, output, cv::Mat());
        cv::erode(output, output, cv::Mat());
        cv::erode(output, output, cv::Mat());
        cv::dilate(output, output, cv::Mat());

        imshow("cvSkinOtsu", output);

        if (cv::waitKey() > )
        {
            break;
        }
    }

    cvWaitKey();
    return ;
}