肤色检测与分割方法

最新推荐文章于 2024-06-21 11:15:34 发布
最新推荐文章于 2024-06-21 11:15:34 发布
阅读量5.6k 收藏 8
点赞数
分类专栏： OpenCV

几种肤色分割算法

        在手势识别和人脸识别中，肤色分割是非常重要的，特将几种肤色分割方法总结了一下，将代码贴出。

        ps:有部分代码非原创，若有侵权，修改。

        包括在rgb、rg空间上进行分割，以及大津分割法在多个颜色空间上的实现。

[cpp]  view plain  copy
  1. #include "highgui.h"  
  2. #include "cv.h"  
  3. #include<iostream>  
  4. using namespace std;  
  5. // skin region location using rgb limitation  
  6. void SkinRGB(IplImage* rgb,IplImage* _dst)  
  7. {  
  8.     assert(rgb->nChannels==3&& _dst->nChannels==3);  
  9.   
  10.     static const int R=2;  
  11.     static const int G=1;  
  12.     static const int B=0;  
  13.   
  14.     IplImage* dst=cvCreateImage(cvGetSize(_dst),8,3);  
  15.     cvZero(dst);  
  16.   
  17.     for (int h=0; h<rgb->height; h++)  
  18.     {  
  19.         unsigned char* prgb=(unsigned char*)rgb->imageData+h*rgb->widthStep;  
  20.         unsigned char* pdst=(unsigned char*)dst->imageData+h*dst->widthStep;  
  21.         for (int w=0; w<rgb->width; w++)  
  22.         {  
  23.             if ((prgb[R]>95 && prgb[G]>40 && prgb[B]>20 &&  
  24.                     prgb[R]-prgb[B]>15 && prgb[R]-prgb[G]>15)||//uniform illumination  
  25.                     (prgb[R]>200 && prgb[G]>210 && prgb[B]>170 &&  
  26.                      abs(prgb[R]-prgb[B])<=15 && prgb[R]>prgb[B]&& prgb[G]>prgb[B])//lateral illumination  
  27.                )  
  28.             {  
  29.                 memcpy(pdst,prgb,3);  
  30.             }  
  31.             prgb+=3;  
  32.             pdst+=3;  
  33.         }  
  34.     }  
  35.     cvCopyImage(dst,_dst);  
  36.     cvReleaseImage(&dst);  
  37. }  
  38. // skin detection in rg space  
  39. void cvSkinRG(IplImage* rgb,IplImage* gray)  
  40. {  
  41.     assert(rgb->nChannels==3&&gray->nChannels==1);  
  42.   
  43.     const int R=2;  
  44.     const int G=1;  
  45.     const int B=0;  
  46.   
  47.     double Aup=-1.8423;  
  48.     double Bup=1.5294;  
  49.     double Cup=0.0422;  
  50.     double Adown=-0.7279;  
  51.     double Bdown=0.6066;  
  52.     double Cdown=0.1766;  
  53.     for (int h=0; h<rgb->height; h++)  
  54.     {  
  55.         unsigned char* pGray=(unsigned char*)gray->imageData+h*gray->widthStep;  
  56.         unsigned char* pRGB=(unsigned char* )rgb->imageData+h*rgb->widthStep;  
  57.         for (int w=0; w<rgb->width; w++)  
  58.         {  
  59.             int s=pRGB[R]+pRGB[G]+pRGB[B];  
  60.             double r=(double)pRGB[R]/s;  
  61.             double g=(double)pRGB[G]/s;  
  62.             double Gup=Aup*r*r+Bup*r+Cup;  
  63.             double Gdown=Adown*r*r+Bdown*r+Cdown;  
  64.             double Wr=(r-0.33)*(r-0.33)+(g-0.33)*(g-0.33);  
  65.             if (g<Gup && g>Gdown && Wr>0.004)  
  66.             {  
  67.                 *pGray=255;  
  68.             }  
  69.             else  
  70.             {  
  71.                 *pGray=0;  
  72.             }  
  73.             pGray++;  
  74.             pRGB+=3;  
  75.         }  
  76.     }  
  77.   
  78. }  
  79. // implementation of otsu algorithm  
  80. // author: onezeros#yahoo.cn  
  81. // reference: Rafael C. Gonzalez. Digital Image Processing Using MATLAB  
  82. void cvThresholdOtsu(IplImage* src, IplImage* dst)  
  83. {  
  84.     int height=src->height;  
  85.     int width=src->width;  
  86.   
  87.     //histogram  
  88.     float histogram[256]= {0};  
  89.     for(int i=0; i<height; i++)  
  90.     {  
  91.         unsigned char* p=(unsigned char*)src->imageData+src->widthStep*i;  
  92.         for(int j=0; j<width; j++)  
  93.         {  
  94.             histogram[*p++]++;  
  95.         }  
  96.     }  
  97.     //normalize histogram  
  98.     int size=height*width;  
  99.     for(int i=0; i<256; i++)  
  100.     {  
  101.         histogram[i]=histogram[i]/size;  
  102.     }  
  103.   
  104.     //average pixel value  
  105.     float avgValue=0;  
  106.     for(int i=0; i<256; i++)  
  107.     {  
  108.         avgValue+=i*histogram[i];  
  109.     }  
  110.   
  111.     int threshold;  
  112.     float maxVariance=0;  
  113.     float w=0,u=0;  
  114.     for(int i=0; i<256; i++)  
  115.     {  
  116.         w+=histogram[i];  
  117.         u+=i*histogram[i];  
  118.   
  119.         float t=avgValue*w-u;  
  120.         float variance=t*t/(w*(1-w));  
  121.         if(variance>maxVariance)  
  122.         {  
  123.             maxVariance=variance;  
  124.             threshold=i;  
  125.         }  
  126.     }  
  127.   
  128.     cvThreshold(src,dst,threshold,255,CV_THRESH_BINARY);  
  129. }  
  130.   
  131. void cvSkinOtsu(IplImage* src, IplImage* dst)//yCbCr  
  132. {  
  133.     assert(dst->nChannels==1&& src->nChannels==3);  
  134.   
  135.     IplImage* ycrcb=cvCreateImage(cvGetSize(src),8,3);  
  136.     IplImage* cr=cvCreateImage(cvGetSize(src),8,1);  
  137.     cvCvtColor(src,ycrcb,CV_BGR2YCrCb);  
  138.     cvSplit(ycrcb,0,cr,0,0);  
  139.   
  140.     cvThresholdOtsu(cr,cr);  
  141.     cvCopyImage(cr,dst);  
  142.     cvReleaseImage(&cr);  
  143.     cvReleaseImage(&ycrcb);  
  144. }  
  145.   
  146. void cvSkinOtsu_H(IplImage* src, IplImage* dst)//H通道上做分割，找到区域后再映射到S通道上继续做分割  
  147. {  
  148.     assert(dst->nChannels==1&& src->nChannels==3);  
  149.   
  150.     IplImage* HSV=cvCreateImage(cvGetSize(src),8,3);  
  151.     IplImage* H=cvCreateImage(cvGetSize(src),8,1);  
  152.     IplImage* S=cvCreateImage(cvGetSize(src),8,1);  
  153.     cvCvtColor(src,HSV,CV_BGR2HSV);  
  154.     cvSplit(HSV,H,S,0,0);  
  155.   
  156.     cvThresholdOtsu(H,S);  
  157.     cvCopyImage(S,dst);  
  158.     cvReleaseImage(&H);  
  159.     cvReleaseImage(&HSV);  
  160. }  
  161.   
  162. void cvSkinYUV(IplImage* src,IplImage* dst)  
  163. {  
  164.     IplImage* ycrcb=cvCreateImage(cvGetSize(src),8,3);  
  165.     //IplImage* cr=cvCreateImage(cvGetSize(src),8,1);  
  166.     //IplImage* cb=cvCreateImage(cvGetSize(src),8,1);  
  167.     cvCvtColor(src,ycrcb,CV_BGR2YCrCb);  
  168.     //cvSplit(ycrcb,0,cr,cb,0);  
  169.   
  170.     static const int Cb=2;  
  171.     static const int Cr=1;  
  172.     static const int Y=0;  
  173.   
  174.     //IplImage* dst=cvCreateImage(cvGetSize(_dst),8,3);  
  175.     cvZero(dst);  
  176.   
  177.     for (int h=0; h<src->height; h++)  
  178.     {  
  179.         unsigned char* pycrcb=(unsigned char*)ycrcb->imageData+h*ycrcb->widthStep;  
  180.         unsigned char* psrc=(unsigned char*)src->imageData+h*src->widthStep;  
  181.         unsigned char* pdst=(unsigned char*)dst->imageData+h*dst->widthStep;  
  182.         for (int w=0; w<src->width; w++)  
  183.         {  
  184.             if (pycrcb[Cr]>=133&&pycrcb[Cr]<=173&&pycrcb[Cb]>=77&&pycrcb[Cb]<=127)  
  185.             {  
  186.                 memcpy(pdst,psrc,3);  
  187.             }  
  188.             pycrcb+=3;  
  189.             psrc+=3;  
  190.             pdst+=3;  
  191.         }  
  192.     }  
  193.     //cvCopyImage(dst,_dst);  
  194.     //cvReleaseImage(&dst);  
  195. }  
  196.   
  197. void cvSkinHSV(IplImage* src,IplImage* dst)  
  198. {  
  199.     IplImage* hsv=cvCreateImage(cvGetSize(src),8,3);  
  200.     //IplImage* cr=cvCreateImage(cvGetSize(src),8,1);  
  201.     //IplImage* cb=cvCreateImage(cvGetSize(src),8,1);  
  202.     cvCvtColor(src,hsv,CV_BGR2HSV);  
  203.     //cvSplit(ycrcb,0,cr,cb,0);  
  204.   
  205.     static const int V=2;  
  206.     static const int S=1;  
  207.     static const int H=0;  
  208.   
  209.     //IplImage* dst=cvCreateImage(cvGetSize(_dst),8,3);  
  210.     cvZero(dst);  
  211.   
  212.     for (int h=0; h<src->height; h++)  
  213.     {  
  214.         unsigned char* phsv=(unsigned char*)hsv->imageData+h*hsv->widthStep;  
  215.         unsigned char* psrc=(unsigned char*)src->imageData+h*src->widthStep;  
  216.         unsigned char* pdst=(unsigned char*)dst->imageData+h*dst->widthStep;  
  217.         for (int w=0; w<src->width; w++)  
  218.         {  
  219.             if (phsv[H]>=7&&phsv[H]<=29)  
  220.             {  
  221.                 memcpy(pdst,psrc,3);  
  222.             }  
  223.             phsv+=3;  
  224.             psrc+=3;  
  225.             pdst+=3;  
  226.         }  
  227.     }  
  228.     //cvCopyImage(dst,_dst);  
  229.     //cvReleaseImage(&dst);  
  230. }  
  231.   
  232. void Skin_HSV_2(IplImage *initial,IplImage *distinction)  
  233. {  
  234.     CvScalar Avg,Sdv;  
  235.     IplImage *temp = cvCreateImage(cvGetSize(initial),8,3);  
  236.     cvCvtColor(initial,temp,CV_BGR2HSV);  
  237.     IplImage *h_img = cvCreateImage(cvGetSize(initial),8,1);  
  238.     IplImage *s_img = cvCreateImage(cvGetSize(initial),8,1);  
  239.     IplImage *v_img = cvCreateImage(cvGetSize(initial),8,1);  
  240.   
  241.     double h_avg,s_avg,v_avg;  
  242.     double h_sdv,s_sdv,v_sdv;  
  243.   
  244.     cvAvgSdv(temp,&Avg,&Sdv,0);  
  245.         
  246.     h_avg = Avg.val[0];  
  247.     s_avg = Avg.val[1];  
  248.     v_avg = Avg.val[2];  
  249.     //cout<<h_avg<<'\n'<<s_img<<'\n'<<v_img;  
  250.     h_sdv = Sdv.val[0];  
  251.     s_sdv = Sdv.val[1];  
  252.     v_sdv = Sdv.val[2];  
  253.   
  254.   
  255.     cvSplit(temp, h_img, s_img, v_img, 0);  
  256.     /*cvShowImage("h_img1",h_img); 
  257.     cvShowImage("s_img1",s_img); 
  258.     cvShowImage("v_img1",v_img);*/  
  259.     int value = 0;  
  260.     for(int i= 0;i< h_img->height;i++)  
  261.     {  
  262.         for(int j = 0; j< h_img->width; j++)  
  263.         {  
  264.             value = cvGetReal2D(h_img, i, j);  
  265.             if((value<(h_avg+h_sdv)) && (value>(h_avg-h_sdv)) )  
  266.             {  
  267.                 *(h_img->imageData+i*h_img->widthStep+j) = 0;  
  268.             }  
  269.             else  
  270.             {  
  271.                 *(h_img->imageData+i*h_img->widthStep+j) = 255;  
  272.             }  
  273.         }  
  274.     }  
  275.   
  276.   
  277.     for(int i= 0;i< s_img->height;i++)  
  278.     {  
  279.         for(int j = 0; j< s_img->width; j++)  
  280.         {  
  281.             value = cvGetReal2D(s_img, i, j);  
  282.             if((value<(s_avg+0.5*s_sdv))&&(value>(s_avg-0.5*s_sdv)) )  
  283.             {  
  284.                 *(s_img->imageData+i*s_img->widthStep+j) = 0;  
  285.             }  
  286.             else  
  287.             {  
  288.                 *(s_img->imageData+i*s_img->widthStep+j) = 255;  
  289.             }  
  290.         }  
  291.     }  
  292.   
  293.     for(int i= 0;i< v_img->height;i++)  
  294.     {  
  295.         for(int j = 0; j< v_img->width; j++)  
  296.         {  
  297.             value = cvGetReal2D(v_img, i, j);  
  298.             if((value<(v_avg+v_sdv)) && (value>(v_avg-v_sdv)))  
  299.             {  
  300.                 *(v_img->imageData+i*v_img->widthStep+j) = 0;  
  301.             }  
  302.             else  
  303.                   
  304.             {  
  305.                     *(v_img->imageData+i*v_img->widthStep+j) = 255;  
  306.             }  
  307.   
  308.         }  
  309.     }  
  310.     cvShowImage("h_img",h_img);  
  311.     /*cvShowImage("s_img",s_img); 
  312.     cvShowImage("v_img",v_img);*/  
  313.     cvAnd(h_img,s_img,distinction);  
  314.     //cvAnd(v_img,distinction,distinction);  
  315.   
  316.     /*cvShowImage("distinction",distinction);*/  
  317.       
  318.   
  319.     /*cvReleaseImage(&temp);*/  
  320.     cvReleaseImage(&h_img);  
  321.     cvReleaseImage(&s_img);  
  322.     cvReleaseImage(&v_img);  
  323. }  
  324.   
  325. void main()  
  326. {  
  327.   
  328.     IplImage* img= cvLoadImage("original.jpg"); //随便放一张jpg图片在D盘或另行设置目录  
  329.     IplImage* dstRGB=cvCreateImage(cvGetSize(img),8,3);  
  330.     IplImage* dstRG=cvCreateImage(cvGetSize(img),8,1);  
  331.     IplImage* dst_crotsu=cvCreateImage(cvGetSize(img),8,1);  
  332.     IplImage* dst_YUV=cvCreateImage(cvGetSize(img),8,3);  
  333.     IplImage* dst_HSV=cvCreateImage(cvGetSize(img),8,3);  
  334.     IplImage* dst_crotsu_H=cvCreateImage(cvGetSize(img),8,1);  
  335.   
  336.     IplImage* dst_HSV_2=cvCreateImage(cvGetSize(img),8,1);  
  337.   
  338.     cvNamedWindow("inputimage", CV_WINDOW_AUTOSIZE);  
  339.     cvShowImage("inputimage", img);  
  340.     cvWaitKey(0);  
  341.   
  342.     SkinRGB(img,dstRGB);  
  343.     cvNamedWindow("SkinRGB", CV_WINDOW_AUTOSIZE);  
  344.     cvShowImage("SkinRGB", dstRGB);  
  345.     ///cvWaitKey(0);  
  346.     cvSkinRG(img,dstRG);  
  347.     cvNamedWindow("cvSkinRG", CV_WINDOW_AUTOSIZE);  
  348.     cvShowImage("cvSkinRG", dstRG);  
  349.     //cvWaitKey(0);  
  350.     cvSkinOtsu(img,dst_crotsu);  
  351.     cvNamedWindow("cvSkinOtsu", CV_WINDOW_AUTOSIZE);  
  352.     cvShowImage("cvSkinOtsu", dst_crotsu);  
  353.   
  354.     cvSkinOtsu_H(img,dst_crotsu_H);  
  355.     cvNamedWindow("cvSkinOtsu_H", CV_WINDOW_AUTOSIZE);  
  356.     cvShowImage("cvSkinOtsu_H", dst_crotsu_H);  
  357.     //cvWaitKey(0);  
  358.     cvSkinYUV(img,dst_YUV);  
  359.     cvNamedWindow("cvSkinYUV", CV_WINDOW_AUTOSIZE);  
  360.     cvShowImage("cvSkinYUV", dst_YUV);  
  361.     //cvWaitKey(0);  
  362.     cvSkinHSV(img,dst_HSV);  
  363.     cvNamedWindow("cvSkinHSV", CV_WINDOW_AUTOSIZE);  
  364.     cvShowImage("cvSkinHSV", dst_HSV);  
  365.   
  366.   
  367.     Skin_HSV_2(img, dst_HSV_2);  
  368.     cvShowImage("cvSkinHSV2", dst_HSV_2);  
  369.     cvWaitKey(0);  
  370.       
  371. }  

       经过多次实验，发现在HSV空间上的大津分割较好。

[cpp]  view plain  copy
  1. void cvThresholdOtsu(IplImage* src, IplImage* dst)  
  2. {  
  3.     int height=src->height;  
  4.     int width=src->width;  
  5.   
  6.     //histogram  
  7.     float histogram[256]= {0};  
  8.     for(int i=0; i<height; i++)  
  9.     {  
  10.         unsigned char* p=(unsigned char*)src->imageData+src->widthStep*i;  
  11.         for(int j=0; j<width; j++)  
  12.         {  
  13.             histogram[*p++]++;  
  14.         }  
  15.     }  
  16.     //normalize histogram  
  17.     int size=height*width;  
  18.     for(int i=0; i<256; i++)  
  19.     {  
  20.         histogram[i]=histogram[i]/size;  
  21.     }  
  22.   
  23.     //average pixel value  
  24.     float avgValue=0;  
  25.     for(int i=0; i<256; i++)  
  26.     {  
  27.         avgValue+=i*histogram[i];  
  28.     }  
  29.   
  30.     int threshold;  
  31.     float maxVariance=0;  
  32.     float w=0,u=0;  
  33.     for(int i=0; i<256; i++)  
  34.     {  
  35.         w+=histogram[i];  
  36.         u+=i*histogram[i];  
  37.   
  38.         float t=avgValue*w-u;  
  39.         float variance=t*t/(w*(1-w));  
  40.         if(variance>maxVariance)  
  41.         {  
  42.             maxVariance=variance;  
  43.             threshold=i;  
  44.         }  
  45.     }  
  46.   
  47.     cvThreshold(src,dst,threshold,255,CV_THRESH_BINARY);  
  48. }  
  49.   
  50. void cvSkinOtsu(IplImage* src, IplImage* dst)//yCbCr  
  51. {  
  52.     assert(dst->nChannels==1&& src->nChannels==3);  
  53.   
  54.     IplImage* ycrcb=cvCreateImage(cvGetSize(src),8,3);  
  55.     IplImage* cr=cvCreateImage(cvGetSize(src),8,1);  
  56.     cvCvtColor(src,ycrcb,CV_BGR2YCrCb);  
  57.     cvSplit(ycrcb,0,cr,0,0);  
  58.   
  59.     cvThresholdOtsu(cr,cr);  
  60.     cvCopyImage(cr,dst);  
  61.     cvReleaseImage(&cr);  
  62.     cvReleaseImage(&ycrcb);  
  63. }  
  64.   
  65. void cvSkinOtsu_H(IplImage* src, IplImage* dst)//H通道上做分割，找到区域后再映射到S通道上继续做分割  
  66. {  
  67.     assert(dst->nChannels==1&& src->nChannels==3);  
  68.   
  69.     IplImage* HSV=cvCreateImage(cvGetSize(src),8,3);  
  70.     IplImage* H=cvCreateImage(cvGetSize(src),8,1);  
  71.     IplImage* S=cvCreateImage(cvGetSize(src),8,1);  
  72.     IplImage* V=cvCreateImage(cvGetSize(src),8,1);  
  73.     cvCvtColor(src,HSV,CV_BGR2HSV);  
  74.     cvSplit(HSV,H,S,V,0);  
  75.     cvThresholdOtsu(S,S);  
  76.     cvThresholdOtsu(V,V);  //H通道，效果不好，S通道还行  
  77.     cvAnd(S,V,dst);   //S,V通道与  
  78.     //cvCopyImage(V,dst);  
  79.     cvReleaseImage(&H);  
  80.     cvReleaseImage(&HSV);  
  81. }  

此外，还有一种在HSV空间上判决的方法，通过（S+V）/H 的值进行判决的，是在一篇论文上看到的，然而，后来没有找到出处。我根据需要对阈值进行了变化，效果在特定情况下比较好，不具有普遍性。

[cpp]  view plain  copy
  1. void Skin_HSV_new(IplImage *img,IplImage *dst)  
  2. {  
  3.     //cvEqualizeHist(img,img); //直方图均衡  
  4.     cvCvtColor(img,img, CV_BGR2HSV);  
  5.     for(int i=0;i<img->width;i++)  
  6.     {  
  7.         for(int j=0;j<img->height;j++)  
  8.         {  
  9.             CvScalar temp=cvGet2D(img,j,i);   
  10.             int value = (((temp.val[1]+temp.val[2])*1.0)/temp.val[0]);  
  11.             if(value<8)  
  12.             {  
  13.                 *(dst->imageData+j*dst->widthStep+i)=0;  
  14.             }  
  15.             else  
  16.             {  
  17.                 *(dst->imageData+j*dst->widthStep+i)=255;  
  18.             }  
  19.             //cout<<value<<'\n';  
  20.         }  
  21.     }  
  22.   
  23.     //cvSmooth(dst,dst,CV_MEDIAN);  
  24.     /*cvDilate(dst,dst); 
  25.     cvErode(dst,dst); 
  26.     cvErode(dst,dst); 
  27.     cvDilate(dst,dst); 
  28.  
  29.     cvDilate(dst,dst); 
  30.     cvErode(dst,dst); 
  31.     cvErode(dst,dst); 
  32.     cvSmooth(dst,dst,CV_MEDIAN); 
  33.     cvDilate(dst,dst); 
  34.     cvErode(dst,dst);*/  
  35.     cvDilate(dst,dst);  
  36.     cvErode(dst,dst);  
  37.     //cvSmooth(dst,dst,CV_BILATERAL);  
  38.     //cvSmooth(dst,dst);  
  39. }  
Destination-amid
关注
专栏目录
几种肤色分割算法（OpenCV实现）
Lym Xin 的博客
08-04 1万+
几种肤色识别算法，主要是针对肤色区域进行二值化，没有进行分割。函数大多接口一致。
基于肤色检测和人眼定位的人脸检测方法
01-20
总的来说，基于肤色检测和人眼定位的人脸检测方法是一种有效的解决方案，它结合了色彩处理、分割技术以及特征点检测，为实际应用中的人脸检测提供了强有力的支持。未来的研究可能会进一步探索如何提高算法的实时性，...
利用人体肤色从图像中分割出人体区域的OpenCV代码
昊虹AI笔记
07-23 8834
原理：YCbCr颜色空间是一种常用的肤色检测的色彩模型，其中Y代表亮度（为了消除光照的影响一般放弃亮度通道），Cr代表光源中的红色分量，Cb代表光源中的蓝色分量，人体的皮肤的颜色集中在色度的较小区域内。肤色的CbCr平面分布在近似椭圆的区域内，通过判断当前像素点的CbCr值是否落在肤色分布的椭圆区域内，就可以很容易确认当前像素点是否属于肤色。 下面上代码（代码中用到的图像的下载链接为：https...
肤色分割算法实现（Matlab）
11-24
肤色分割。找一张人脸图像，尝试进行肤色分割。用RGB转HSV方式和RGB转YCbcR两种方式实现。。详情见https://blog.csdn.net/qq_38605089/article/details/110100701
关于人的肤色识别——理论篇
最新发布
learner_jj的博客
06-21 790
记录肤色识别理论
基于肤色的人脸检测与分割
yi_tech_blog的博客
11-01 8761
基本步骤： 1、图像预处理；2、建立肤色模型；3、相似度计算；4、二值化 1、图像预处理包括滤除噪声和亮度补偿。滤除噪声中是使用高斯滤波器等方法进行；由于光照影响图像的亮度，这里亮度补偿采用Gary World算法对RGB图像进行快速颜色补偿，即如下公式： S=av1/av2；f=f1*S；其中av1为标准亮度图像R、G、B的平均值，av2为原输入图像R、G、B的平均值，f1为原输入图像
各肤色分割方法 C++算法实现
12-09
各肤色分割方法 C++算法实现，包括Otsu HSV RGB颜色空间的肤色分割，算法使用opencv实现，VS2010 c++工程
图像处理——皮肤分割方法汇总（最全最有用的）
weixin_40820983的博客
03-16 6418
最近老师布置了一个小作业，检测图像中的皮肤。 1、基于颜色空间 已经有很多博客写了： python：https://www.cnblogs.com/demodashi/p/9437559.html c++:https://www.cnblogs.com/skyfsm/p/7868877.html 其中基于Ycrcb的效果比较好，但是非常容易受背景干扰（后俩张几乎背景都包含在里面了）。 ...
肤色检测分割代码
06-03
本项目主要探讨如何将RGB图像转换为YCrCb肤色空间，以便更有效地进行肤色检测与图像分割。 首先，我们需要理解RGB和YCrCb颜色空间。RGB（Red, Green, Blue）是最常见的颜色模型，它基于三种基本颜色——红、绿、蓝...
基于肤色分割和改进AdaBoost算法的人脸检测
01-29
为解决当被检测图像中具有复杂背景或者含有多人脸时，不能够快速准确的进行人脸检测的问题，本文提出一种基于肤色分割和改进AdaBoost算法的人脸检测方法。首先利用肤色分割方法对样本图像实现图像的预处理，排除样本...
基于adaboost算法和肤色分割的人脸检测方法研究
03-23
基于AdaBoost算法和肤色分割的人脸检测方法研究，属于人脸识别领域的前沿研究课题。人脸识别作为一种重要的预处理步骤，在计算机视觉和模式识别领域有着广泛的应用，例如视频检索、人机交互等。在这一研究领域，面部...
肤色分割数据集
10-11
肤色分割数据集 下载：数据文件夹，数据的描述 摘要：肤色分割的数据集构建了B、G、R颜色空间。皮肤和非皮肤性数据是使用来自不同年龄、人脸皮肤纹理生成的性别和种族的人。 数据集的特征： 单因素 实例的数目： 二十四万五千零五十七 区域 电脑 属性特征： 真实 属性的数目： 四 捐款日期 2012-07-17 相关的任务： 分类 遗漏值的吗？ N / A Number of Web Hits: 十二万七千六百九十九 来源 该rajen Bhatt，迪豪；rajen.bhatt'@'gmail.com, IIT Delhi. Data Set Information: 皮肤的数据集是通过随机抽样B、G收集，从不同年龄组的人脸图像的R值（小，中，老），种族（白人，黑人，和亚洲），和性别从FERET和PAL数据库。总样本大小为245057；其中50859是皮肤样本和194198个非皮肤样本。这个数据集的尺寸为245057×4，前三列是B，G，R（x1，x2，x3和特点）值和第四列为类标签（决策变量Y）。
人脸检测——基于肤色区域分割
04-07
利用基于肤色的不同来划分出人脸区域，再根据特征的来定位人脸区域。
基于肤色分割的人脸检测算法研究 (2007年)
05-26
介绍了目前人脸检测领域检测速度最快的Boosted Cascade人脸检测算法。该算法在进行人脸检测时没有考虑到肤色因素，在具体识别过程中，有些可利用肤色信息很快排除的区域，在Boosted Cascade算法中却没有被排除掉。针对该算法的缺陷提出了一种改进算法，即利用Boosted Cascade人脸检测算法，检测出人脸的候选区域，通过人脸肤色模型进行验证，如果候选区域的像素符合人脸的肤色模型的程度到达某一数值，则接受该区域，即认为该区域是人脸；否则排除该区域。改进后的算法能够有效地提高检测的正确率，减
肤色分割 face-segment
10-09
通过RGB转转换为颜色空间ycbcr，肤色有一定的聚类性，通过聚类完成肤色相似的分割.......................
人体肤色分割
05-19
能分割出人体的肤色，可用作手势识别，人脸识别
视觉物联网——肤色检测
05-22
在这个项目中，MATLAB文件很可能是实现肤色检测算法的代码，可能包含了预处理步骤、颜色空间转换、肤色模型构建和肤色区域分割等关键部分。MATLAB的灵活性和丰富的库函数使得开发这样的系统变得相对容易。 肤色检测...
Win8 Metro(C#)数字图像处理--2.35图像肤色检测算法
Trent1985的专栏
04-12 2251
 [函数名称] 肤色检测函数SkinDetectProcess(WriteableBitmap src) [算法说明]   这个算法是一篇学术论文算法的实现，论文名字为“基于韧脸检测和颜色分析的红眼自动消除”(作者金秋明，王朔中)，主要是采集并统计肤色像素，得到肤色像素在RGB颜色空间中的分布范围，以此作为像素是否为肤色像素的判断标准及约束条件。具体内容大家可以在网络中搜索，由统计结果
肤色阈值分割
weixin_30800987的博客
02-25 813
1.视频帧读取图像（YCbCr+Ostu滤波） # -*- coding: utf-8 -*- """ Created on Mon Dec 10 11:31:43 2018 @author: 1 """ import cv2 cap = cv2.VideoCapture(0) cap.set(3,640) cap.set(4,480) #调整参数实现读取视频或调用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值