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 ;
}