六种方法分别是：基于RGB分割，基于RG同道的分割，ycrcb+otsu（ostu可以参考http://blog.csdn.net/onezeros/article/details/6136770，

    http://wenku.baidu.com/view/05c47e03bed5b9f3f90f1ce4.html），YCrCb空间，YUV空间，HSV空间。下一步就是通过JNI将这些检测移植到android上，最终目标是实现Android智能手机利用掌纹开关机。

    环境是在qt下，.pro文件里增加如下代码：

    1.       INCLUDEPATH += /usr/include/opencv
    3. LIBS += /usr/lib/libcv.so \
    4. /usr/lib/libcvaux.so \
    5. /usr/lib/libcxcore.so \
    6. /usr/lib/libhighgui.so \
    7. /usr/lib/libml.so
    8.

    请看源码：

    1.       #include <iostream>
    2. #include "cv.h"
    3. #include "highgui.h"
    5. void SkinRGB(IplImage* rgb,IplImage* _dst);
    6. void cvSkinRG(IplImage* rgb,IplImage* gray);
    7. void cvThresholdOtsu(IplImage* src, IplImage* dst);
    8. void cvSkinOtsu(IplImage* src, IplImage* dst);
    9. void cvSkinYCbCr(IplImage* img, IplImage* mask);
    10. void cvSkinYUV(IplImage* src,IplImage* dst);
    11. void cvSkinHSV(IplImage* src,IplImage* dst);
    13. using namespace std;
    15. // skin region location using rgb limitation
    17. int main()
    18. {
    19.     IplImage *srcImg = cvLoadImage("/home/yan/download/testPalm4.jpg", 1);
    20.     IplImage *dstRGB = cvCreateImage(cvGetSize(srcImg), 8, 3);
    21.     IplImage *dstRG = cvCreateImage(cvGetSize(srcImg), 8, 1);
    22.     IplImage* dst_crotsu=cvCreateImage(cvGetSize(srcImg),8,1);
    23.     IplImage* dst_ycbcr=cvCreateImage(cvGetSize(srcImg),8,1);
    24.     IplImage* dst_yuv=cvCreateImage(cvGetSize(srcImg),8,3);
    25.     IplImage* dst_hsv=cvCreateImage(cvGetSize(srcImg),8,3);
    27.     SkinRGB(srcImg, dstRGB);
    28.     cvSaveImage("/home/yan/download/1_dstRGB.jpg", dstRGB);
    30.     cvSkinRG(srcImg, dstRG);
    31.     cvSaveImage("/home/yan/download/2_dstRG.jpg", dstRG);
    33.     cvSkinOtsu(srcImg, dst_crotsu);
    34.     cvSaveImage("/home/yan/download/3_dst_crotsu.jpg", dst_crotsu);
    36.     cvSkinYCbCr(srcImg, dst_ycbcr);
    37.     cvSaveImage("/home/yan/download/4_dst_ycbcr.jpg", dst_ycbcr);
    39.     cvSkinYUV(srcImg, dst_yuv);
    40.     cvSaveImage("/home/yan/download/5_dst_yuv.jpg", dst_yuv);
    42.     cvSkinHSV(srcImg, dst_hsv);
    43.     cvSaveImage("/home/yan/download/6_dst_hsv.jpg", dst_hsv);
    45.     cvNamedWindow("srcImg", 1);
    46.     cvShowImage("srcImg", srcImg);
    48.     cvNamedWindow("dstRGB", 1);
    49.     cvShowImage("dstRGB", dstRGB);
    51.     cvNamedWindow("dstRG", 1);
    52.     cvShowImage("dstRG", dstRG);
    54.     cvNamedWindow("dstcrotsu", 1);
    55.     cvShowImage("dstcrotsu", dst_crotsu);
    57.     cvNamedWindow("dst_ycbcr", 1);
    58.     cvShowImage("dst_ycbcr", dst_ycbcr);
    60.     cvNamedWindow("dst_yuv", 1);
    61.     cvShowImage("dst_yuv", dst_yuv);
    63.     cvNamedWindow("dst_hsv", 1);
    64.     cvShowImage("dst_hsv", dst_hsv);
    65.     cvWaitKey(0);
    66.     cout << "Hello World!" << endl;
    67.     return 0;
    68. }
    69. void SkinRGB(IplImage* rgb,IplImage* _dst)
    70. {
    71.     cout<<"111"<<endl;
    72.     assert(rgb->nChannels==3&& _dst->nChannels==3);
    74.     static const int R=2;
    75.     static const int G=1;
    76.     static const int B=0;
    78.     IplImage* dst=cvCreateImage(cvGetSize(_dst),8,3);
    79.     cvZero(dst);
    81.     for (int h=0;h<rgb->height;h++) {
    82.         unsigned char* prgb=(unsigned char*)rgb->imageData+h*rgb->widthStep;
    83.         unsigned char* pdst=(unsigned char*)dst->imageData+h*dst->widthStep;
    84.         for (int w=0;w<rgb->width;w++) {
    85.             if ((prgb[R]>95 && prgb[G]>40 && prgb[B]>20 &&
    86.                  prgb[R]-prgb[B]>15 && prgb[R]-prgb[G]>15/*&&
    87.                      !(prgb[R]>170&&prgb[G]>170&&prgb[B]>170)*/)||//uniform illumination
    88.                     (prgb[R]>200 && prgb[G]>210 && prgb[B]>170 &&
    89.                      abs(prgb[R]-prgb[B])<=15 && prgb[R]>prgb[B]&& prgb[G]>prgb[B])//lateral illumination
    90.                     ) {
    91.                 memcpy(pdst,prgb,3);
    92.             }
    93.             prgb+=3;
    94.             pdst+=3;
    95.         }
    96.     }
    97.     cvCopyImage(dst,_dst);
    98.     cvReleaseImage(&dst);
    99. }
    101. void cvSkinRG(IplImage* rgb,IplImage* gray)
    102. {
    103.     assert(rgb->nChannels==3&&gray->nChannels==1);
    105.     const int R=2;
    106.     const int G=1;
    107.     const int B=0;
    109.     double Aup=-1.8423;
    110.     double Bup=1.5294;
    111.     double Cup=0.0422;
    112.     double Adown=-0.7279;
    113.     double Bdown=0.6066;
    114.     double Cdown=0.1766;
    115.     for (int h=0; h<rgb->height; h++)
    116.     {
    117.         unsigned char* pGray=(unsigned char*)gray->imageData+h*gray->widthStep;
    118.         unsigned char* pRGB=(unsigned char* )rgb->imageData+h*rgb->widthStep;
    119.         for (int w=0; w<rgb->width; w++)
    120.         {
    121.             int s=pRGB[R]+pRGB[G]+pRGB[B];
    122.             double r=(double)pRGB[R]/s;
    123.             double g=(double)pRGB[G]/s;
    124.             double Gup=Aup*r*r+Bup*r+Cup;
    125.             double Gdown=Adown*r*r+Bdown*r+Cdown;
    126.             double Wr=(r-0.33)*(r-0.33)+(g-0.33)*(g-0.33);
    127.             if (g<Gup && g>Gdown && Wr>0.004)
    128.             {
    129.                 *pGray=255;
    130.             }
    131.             else
    132.             {
    133.                 *pGray=0;
    134.             }
    135.             pGray++;
    136.             pRGB+=3;
    137.         }
    138.     }
    140. }
    141. void cvThresholdOtsu(IplImage* src, IplImage* dst)
    142. {
    143.     int height=src->height;
    144.     int width=src->width;
    146.     //histogram
    147.     float histogram[256]= {0};
    148.     for(int i=0; i<height; i++)
    149.     {
    150.         unsigned char* p=(unsigned char*)src->imageData+src->widthStep*i;
    151.         for(int j=0; j<width; j++)
    152.         {
    153.             histogram[*p++]++;
    154.         }
    155.     }
    156.     //normalize histogram
    157.     int size=height*width;
    158.     for(int i=0; i<256; i++)
    159.     {
    160.         histogram[i]=histogram[i]/size;
    161.     }
    163.     //average pixel value
    164.     float avgValue=0;
    165.     for(int i=0; i<256; i++)
    166.     {
    167.         avgValue+=i*histogram[i];
    168.     }
    170.     int threshold;
    171.     float maxVariance=0;
    172.     float w=0,u=0;
    173.     for(int i=0; i<256; i++)
    174.     {
    175.         w+=histogram[i];
    176.         u+=i*histogram[i];
    178.         float t=avgValue*w-u;
    179.         float variance=t*t/(w*(1-w));
    180.         if(variance>maxVariance)
    181.         {
    182.             maxVariance=variance;
    183.             threshold=i;
    184.         }
    185.     }
    186.     cvThreshold(src,dst,threshold,255,CV_THRESH_BINARY);
    187. }
    189. void cvSkinOtsu(IplImage* src, IplImage* dst)
    190. {
    191.     assert(dst->nChannels==1&& src->nChannels==3);
    193.     IplImage* ycrcb=cvCreateImage(cvGetSize(src),8,3);
    194.     IplImage* cr=cvCreateImage(cvGetSize(src),8,1);
    195.     cvCvtColor(src,ycrcb,CV_BGR2YCrCb);
    196.     cvSplit(ycrcb,0,cr,0,0);
    198.     cvThresholdOtsu(cr,cr);
    199.     cvCopyImage(cr,dst);
    200.     cvReleaseImage(&cr);
    201.     cvReleaseImage(&ycrcb);
    202. }
    203. void cvSkinYCbCr(IplImage* img, IplImage* mask)
    204. {
    205.     CvSize imageSize = cvSize(img->width, img->height);
    206.     IplImage *imgY = cvCreateImage(imageSize, IPL_DEPTH_8U, 1);
    207.     IplImage *imgCr = cvCreateImage(imageSize, IPL_DEPTH_8U, 1);
    208.     IplImage *imgCb = cvCreateImage(imageSize, IPL_DEPTH_8U, 1);
    210.     IplImage *imgYCrCb = cvCreateImage(imageSize, img->depth, img->nChannels);
    211.     cvCvtColor(img,imgYCrCb,CV_BGR2YCrCb);
    212.     cvSplit(imgYCrCb, imgY, imgCr, imgCb, 0);
    213.     int y, cr, cb, l, x1, y1, value;
    214.     unsigned char *pY, *pCr, *pCb, *pMask;
    216.     pY = (unsigned char *)imgY->imageData;
    217.     pCr = (unsigned char *)imgCr->imageData;
    218.     pCb = (unsigned char *)imgCb->imageData;
    219.     pMask = (unsigned char *)mask->imageData;
    220.     cvSetZero(mask);
    221.     l = img->height * img->width;
    222.     for (int i = 0; i < l; i++){
    223.         y  = *pY;
    224.         cr = *pCr;
    225.         cb = *pCb;
    226.         cb -= 109;
    227.         cr -= 152
    228.                 ;
    229.         x1 = (819*cr-614*cb)/32 + 51;
    230.         y1 = (819*cr+614*cb)/32 + 77;
    231.         x1 = x1*41/1024;
    232.         y1 = y1*73/1024;
    233.         value = x1*x1+y1*y1;
    234.         if(y<100)   (*pMask)=(value<700) ? 255:0;
    235.         else        (*pMask)=(value<850)? 255:0;
    236.         pY++;
    237.         pCr++;
    238.         pCb++;
    239.         pMask++;
    240.     }
    241.     cvReleaseImage(&imgY);
    242.     cvReleaseImage(&imgCr);
    243.     cvReleaseImage(&imgCb);
    244.     cvReleaseImage(&imgYCrCb);
    245. }
    247. void cvSkinYUV(IplImage* src,IplImage* dst)
    248. {
    249.     IplImage* ycrcb=cvCreateImage(cvGetSize(src),8,3);
    250.     //IplImage* cr=cvCreateImage(cvGetSize(src),8,1);
    251.     //IplImage* cb=cvCreateImage(cvGetSize(src),8,1);
    252.     cvCvtColor(src,ycrcb,CV_BGR2YCrCb);
    253.     //cvSplit(ycrcb,0,cr,cb,0);
    255.     static const int Cb=2;
    256.     static const int Cr=1;
    257.     static const int Y=0;
    259.     //IplImage* dst=cvCreateImage(cvGetSize(_dst),8,3);
    260.     cvZero(dst);
    262.     for (int h=0; h<src->height; h++)
    263.     {
    264.         unsigned char* pycrcb=(unsigned char*)ycrcb->imageData+h*ycrcb->widthStep;
    265.         unsigned char* psrc=(unsigned char*)src->imageData+h*src->widthStep;
    266.         unsigned char* pdst=(unsigned char*)dst->imageData+h*dst->widthStep;
    267.         for (int w=0; w<src->width; w++)
    268.         {
    269.             if (pycrcb[Cr]>=133&&pycrcb[Cr]<=173&&pycrcb[Cb]>=77&&pycrcb[Cb]<=127)
    270.             {
    271.                 memcpy(pdst,psrc,3);
    272.             }
    273.             pycrcb+=3;
    274.             psrc+=3;
    275.             pdst+=3;
    276.         }
    277.     }
    278.     //cvCopyImage(dst,_dst);
    279.     //cvReleaseImage(&dst);
    280. }
    282. void cvSkinHSV(IplImage* src,IplImage* dst)
    283. {
    284.     IplImage* hsv=cvCreateImage(cvGetSize(src),8,3);
    285.     //IplImage* cr=cvCreateImage(cvGetSize(src),8,1);
    286.     //IplImage* cb=cvCreateImage(cvGetSize(src),8,1);
    287.     cvCvtColor(src,hsv,CV_BGR2HSV);
    288.     //cvSplit(ycrcb,0,cr,cb,0);
    290.     static const int V=2;
    291.     static const int S=1;
    292.     static const int H=0;
    294.     //IplImage* dst=cvCreateImage(cvGetSize(_dst),8,3);
    295.     cvZero(dst);
    297.     for (int h=0; h<src->height; h++)
    298.     {
    299.         unsigned char* phsv=(unsigned char*)hsv->imageData+h*hsv->widthStep;
    300.         unsigned char* psrc=(unsigned char*)src->imageData+h*src->widthStep;
    301.         unsigned char* pdst=(unsigned char*)dst->imageData+h*dst->widthStep;
    302.         for (int w=0; w<src->width; w++)
    303.         {
    304.             if (phsv[H]>=7&&phsv[H]<=29)
    305.             {
    306.                 memcpy(pdst,psrc,3);
    307.             }
    308.             phsv+=3;
    309.             psrc+=3;
    310.             pdst+=3;
    311.         }
    312.     }
    313.     //cvCopyImage(dst,_dst);
    314.     //cvReleaseImage(&dst);
    315. }
    316.  
    317.

    下面是效果图：

    测试图片：

    Android上掌纹识别第一步：基于OpenCV的6种肤色分割 源码和效果图 - 图1

    下图的贴图依次对应上面的六种方法：

    Android上掌纹识别第一步：基于OpenCV的6种肤色分割 源码和效果图 - 图2

    Android上掌纹识别第一步：基于OpenCV的6种肤色分割 源码和效果图 - 图3

    Android上掌纹识别第一步：基于OpenCV的6种肤色分割 源码和效果图 - 图4

    Android上掌纹识别第一步：基于OpenCV的6种肤色分割 源码和效果图 - 图5

    Android上掌纹识别第一步：基于OpenCV的6种肤色分割 源码和效果图 - 图6

    Android上掌纹识别第一步：基于OpenCV的6种肤色分割 源码和效果图 - 图7

    从上面的结果对比图中可以清晰看的，ycrcb+ostu的效果无疑是最好的。其次是rgb和yuv方法。这个图片效果之所以这么好是因为测试图片拍摄的时候背景为白色。然后，遗憾的是，当背景色不纯的时候，比如有红也有黑，效果就很不理想了。实验发现，当背景为纯色，且是白色或黑色时，效果最好。

    参考：

    http://blog.sina.com.cn/s/blog_9ce5a1b501017otq.html

    http://blog.csdn.net/scyscyao/article/details/5468577

    http://wenku.baidu.com/view/05c47e03bed5b9f3f90f1ce4.html

    http://blog.csdn.net/onezeros/article/details/6136770

    —————————————本掌纹是作者自己的，转载请注明作者yanzi1225627