欢迎访问 生活随笔！
TAG聚合

生活随笔

当前位置： 首页 > 编程资源 > 编程问答 >内容正文

编程问答

图像处理之简单脸谱检测算法

发布时间：2025/7/25 编程问答 48 豆豆
生活随笔 收集整理的这篇文章主要介绍了 图像处理之简单脸谱检测算法 小编觉得挺不错的,现在分享给大家,帮大家做个参考.

from： http://blog.csdn.net/jia20003/article/details/7596443


图像处理之简单脸谱检测算法（Simple Face Detection Algorithm）


介绍基于皮肤检测之后的，寻找最大连通区域，完成脸谱检测的算法。大致的算法步骤如下：


原图如下：


每步处理以后的效果：


程序运行，加载选择图像以后的截屏如下：


截屏中显示图片，是适当放缩以后，代码如下：

[java] view plaincopy
  • Image scaledImage = rawImg.getScaledInstance(200, 200, Image.SCALE_FAST); // Java Image API， rawImage is source image  
  • g2.drawImage(scaledImage, 0, 0, 200, 200, null);  

    • 第一步：图像预处理，预处理的目的是为了减少图像中干扰像素，使得皮肤检测步骤可以得

    到更好的效果，最常见的手段是调节对比度与亮度，也可以高斯模糊。关于怎么调节亮度与

    对比度可以参见这里：http://blog.csdn.net/jia20003/article/details/7385160

    这里调节对比度的算法很简单，源代码如下：

    [java] view plaincopy
  • package com.gloomyfish.face.detection;  
  •   
  • import java.awt.image.BufferedImage;  
  •   
  • public class ContrastFilter extends AbstractBufferedImageOp {  
  •       
  •     private double nContrast = 30;  
  •       
  •     public ContrastFilter() {  
  •         System.out.println("Contrast Filter");  
  •     }  
  •   
  •     @Override  
  •     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
  •         int width = src.getWidth();  
  •         int height = src.getHeight();  
  •         double contrast = (100.0 + nContrast) / 100.0;  
  •         contrast *= contrast;  
  •         if ( dest == null )  
  •             dest = createCompatibleDestImage( src, null );  
  •   
  •         int[] inPixels = new int[width*height];  
  •         int[] outPixels = new int[width*height];  
  •         getRGB( src, 0, 0, width, height, inPixels );  
  •         int index = 0;  
  •         int ta = 0, tr = 0, tg = 0, tb = 0;  
  •         for(int row=0; row<height; row++) {  
  •             for(int col=0; col<width; col++) {  
  •                 index = row * width + col;  
  •                 ta = (inPixels[index] >> 24) & 0xff;  
  •                 tr = (inPixels[index] >> 16) & 0xff;  
  •                 tg = (inPixels[index] >> 8) & 0xff;  
  •                 tb = inPixels[index] & 0xff;  
  •                   
  •                 // adjust contrast - red, green, blue  
  •                 tr = adjustContrast(tr, contrast);  
  •                 tg = adjustContrast(tg, contrast);  
  •                 tb = adjustContrast(tb, contrast);  
  •                   
  •                 // output RGB pixel  
  •                 outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
  •             }  
  •         }  
  •         setRGB( dest, 0, 0, width, height, outPixels );  
  •         return dest;  
  •     }  
  •       
  •     public int adjustContrast(int color, double contrast) {  
  •         double result = 0;  
  •         result = color / 255.0;  
  •         result -= 0.5;  
  •         result *= contrast;  
  •         result += 0.5;  
  •         result *=255.0;  
  •         return clamp((int)result);  
  •     }  
  •       
  •     public static int clamp(int c) {  
  •         if (c < 0)  
  •             return 0;  
  •         if (c > 255)  
  •             return 255;  
  •         return c;  
  •     }  
  •   
  • }  

    • 注意：第一步不是必须的，如果图像质量已经很好，可以直接跳过。


    第二步：皮肤检测，采用的是基于RGB色彩空间的统计结果来判断一个像素是否为skin像

    素，如果是皮肤像素，则设置像素为黑色，否则为白色。给出基于RGB色彩空间的五种皮

    肤检测统计方法，最喜欢的一种源代码如下：

    [java] view plaincopy
  • package com.gloomyfish.face.detection;  
  •   
  • import java.awt.image.BufferedImage;  
  • /** 
  •  * this skin detection is absolutely good skin classification, 
  •  * i love this one very much 
  •  *  
  •  * this one should be always primary skin detection  
  •  * from all five filters 
  •  *  
  •  * @author zhigang 
  •  * 
  •  */  
  • public class SkinFilter4 extends AbstractBufferedImageOp {  
  •   
  •     @Override  
  •     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
  •         int width = src.getWidth();  
  •         int height = src.getHeight();  
  •   
  •         if ( dest == null )  
  •             dest = createCompatibleDestImage( src, null );  
  •   
  •         int[] inPixels = new int[width*height];  
  •         int[] outPixels = new int[width*height];  
  •         getRGB( src, 0, 0, width, height, inPixels );  
  •         int index = 0;  
  •         for(int row=0; row<height; row++) {  
  •             int ta = 0, tr = 0, tg = 0, tb = 0;  
  •             for(int col=0; col<width; col++) {  
  •                 index = row * width + col;  
  •                 ta = (inPixels[index] >> 24) & 0xff;  
  •                 tr = (inPixels[index] >> 16) & 0xff;  
  •                 tg = (inPixels[index] >> 8) & 0xff;  
  •                 tb = inPixels[index] & 0xff;  
  •                   
  •                 // detect skin method...  
  •                 double sum = tr + tg + tb;  
  •                 if (((double)tb/(double)tg<1.249) &&  
  •                     ((double)sum/(double)(3*tr)>0.696) &&  
  •                     (0.3333-(double)tb/(double)sum>0.014) &&  
  •                     ((double)tg/(double)(3*sum)<0.108))  
  •                 {  
  •                     tr = tg = tb = 0;  
  •                 } else {  
  •                     tr = tg = tb = 255;  
  •                 }  
  •                 outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
  •             }  
  •         }  
  •         setRGB(dest, 0, 0, width, height, outPixels);  
  •         return dest;  
  •     }  
  • }  

    • 第三步：寻找最大连通区域

    使用连通组件标记算法，寻找最大连通区域，关于什么是连通组件标记算法，可以参见这里

    http://blog.csdn.net/jia20003/article/details/7483249，里面提到的连通组件算法效率不高，所

    以这里我完成了一个更具效率的版本，主要思想是对像素数据进行八邻域寻找连通，然后合

    并标记。源代码如下：

    [java] view plaincopy
  • package com.gloomyfish.face.detection;  
  •   
  • import java.util.Arrays;  
  • import java.util.HashMap;  
  •   
  • /** 
  •  * fast connected component label algorithm 
  •  *  
  •  * @date 2012-05-23 
  •  * @author zhigang 
  •  * 
  •  */  
  • public class FastConnectedComponentLabelAlg {  
  •     private int bgColor;  
  •     private int[] labels;  
  •     private int[] outData;  
  •     private int dw;  
  •     private int dh;  
  •       
  •     public FastConnectedComponentLabelAlg() {  
  •         bgColor = 255; // black color  
  •     }  
  •   
  •     public int[] doLabel(int[] inPixels, int width, int height) {  
  •         dw = width;  
  •         dh = height;  
  •         int nextlabel = 1;  
  •         int result = 0;  
  •         labels = new int[dw * dh/2];  
  •         outData = new int[dw * dh];  
  •         for(int i=0; i<labels.length; i++) {  
  •             labels[i] = i;  
  •         }  
  •           
  •         // we need to define these two variable arrays.  
  •         int[] fourNeighborhoodPixels = new int[8];  
  •         int[] fourNeighborhoodLabels = new int[8];  
  •         int[] knownLabels = new int[4];  
  •           
  •         int srcrgb = 0, index = 0;  
  •         boolean existedLabel = false;  
  •         for(int row = 0; row < height; row ++) {  
  •             for(int col = 0; col < width; col++) {  
  •                 index = row * width + col;  
  •                 srcrgb = inPixels[index] & 0x000000ff;  
  •                 if(srcrgb == bgColor) {  
  •                     result = 0; // which means no labeled for this pixel.  
  •                 } else {  
  •                     // we just find the eight neighborhood pixels.  
  •                     fourNeighborhoodPixels[0] = getPixel(inPixels, row-1, col); // upper cell  
  •                     fourNeighborhoodPixels[1] = getPixel(inPixels, row, col-1); // left cell  
  •                     fourNeighborhoodPixels[2] = getPixel(inPixels, row+1, col); // bottom cell  
  •                     fourNeighborhoodPixels[3] = getPixel(inPixels, row, col+1); // right cell  
  •                       
  •                     // four corners pixels  
  •                     fourNeighborhoodPixels[4] = getPixel(inPixels, row-1, col-1); // upper left corner  
  •                     fourNeighborhoodPixels[5] = getPixel(inPixels, row-1, col+1); // upper right corner  
  •                     fourNeighborhoodPixels[6] = getPixel(inPixels, row+1, col-1); // left bottom corner  
  •                     fourNeighborhoodPixels[7] = getPixel(inPixels, row+1, col+1); // right bottom corner  
  •                       
  •                     // get current possible existed labels  
  •                     fourNeighborhoodLabels[0] = getLabel(outData, row-1, col); // upper cell  
  •                     fourNeighborhoodLabels[1] = getLabel(outData, row, col-1); // left cell  
  •                     fourNeighborhoodLabels[2] = getLabel(outData, row+1, col); // bottom cell  
  •                     fourNeighborhoodLabels[3] = getLabel(outData, row, col+1); // right cell  
  •                       
  •                     // four corners labels value  
  •                     fourNeighborhoodLabels[4] = getLabel(outData, row-1, col-1); // upper left corner  
  •                     fourNeighborhoodLabels[5] = getLabel(outData, row-1, col+1); // upper right corner  
  •                     fourNeighborhoodLabels[6] = getLabel(outData, row+1, col-1); // left bottom corner  
  •                     fourNeighborhoodLabels[7] = getLabel(outData, row+1, col+1); // right bottom corner  
  •                       
  •                     knownLabels[0] = fourNeighborhoodLabels[0];  
  •                     knownLabels[1] = fourNeighborhoodLabels[1];  
  •                     knownLabels[2] = fourNeighborhoodLabels[4];  
  •                     knownLabels[3] = fourNeighborhoodLabels[5];  
  •                       
  •                     existedLabel = false;  
  •                     for(int k=0; k<fourNeighborhoodLabels.length; k++) {  
  •                         if(fourNeighborhoodLabels[k] != 0) {  
  •                             existedLabel = true;  
  •                             break;  
  •                         }  
  •                     }  
  •                       
  •                     if(!existedLabel) {  
  •                         result = nextlabel;  
  •                         nextlabel++;  
  •                     } else {  
  •                         int found = -1, count = 0;  
  •                         for(int i=0; i<fourNeighborhoodPixels.length; i++) {  
  •                             if(fourNeighborhoodPixels[i] != bgColor) {  
  •                                 found = i;  
  •                                 count++;  
  •                             }  
  •                         }  
  •                           
  •                         if(count == 1) {  
  •                             result = (fourNeighborhoodLabels[found] == 0) ? nextlabel : fourNeighborhoodLabels[found];  
  •                         } else {  
  •                             result = (fourNeighborhoodLabels[found] == 0) ? nextlabel : fourNeighborhoodLabels[found];  
  •                             for(int j=0; j<knownLabels.length; j++) {  
  •                                 if(knownLabels[j] != 0 && knownLabels[j] != result &&  
  •                                         knownLabels[j] < result) {  
  •                                     result = knownLabels[j];  
  •                                 }  
  •                             }  
  •                               
  •                             boolean needMerge = false;  
  •                             for(int mm = 0; mm < knownLabels.length; mm++ ) {  
  •                                 if(knownLabels[0] != knownLabels[mm] && knownLabels[mm] != 0) {  
  •                                     needMerge = true;  
  •                                 }  
  •                             }  
  •                               
  •                             // merge the labels now....  
  •                             if(needMerge) {  
  •                                 int minLabel = knownLabels[0];  
  •                                 for(int m=0; m<knownLabels.length; m++) {  
  •                                     if(minLabel > knownLabels[m] && knownLabels[m] != 0) {  
  •                                         minLabel = knownLabels[m];  
  •                                     }  
  •                                 }  
  •                                   
  •                                 // find the final label number...  
  •                                 result = (minLabel == 0) ? result : minLabel;  
  •                                           
  •                                 // re-assign the label number now...  
  •                                 if(knownLabels[0] != 0) {  
  •                                     setData(outData, row-1, col, result);  
  •                                 }  
  •                                 if(knownLabels[1] != 0) {  
  •                                     setData(outData, row, col-1, result);  
  •                                 }  
  •                                 if(knownLabels[2] != 0) {  
  •                                     setData(outData, row-1, col-1, result);  
  •                                 }  
  •                                 if(knownLabels[3] != 0) {  
  •                                     setData(outData, row-1, col+1, result);  
  •                                 }  
  •                                   
  •                             }  
  •                         }  
  •                     }  
  •                 }  
  •                 outData[index] = result; // assign to label  
  •             }  
  •         }  
  •           
  •         // post merge each labels now  
  •         for(int row = 0; row < height; row ++) {  
  •             for(int col = 0; col < width; col++) {  
  •                 index = row * width + col;  
  •                 mergeLabels(index);  
  •             }  
  •         }  
  •           
  •         // labels statistic  
  •         HashMap<Integer, Integer> labelMap = new HashMap<Integer, Integer>();  
  •         for(int d=0; d<outData.length; d++) {  
  •             if(outData[d] != 0) {  
  •                 if(labelMap.containsKey(outData[d])) {  
  •                     Integer count = labelMap.get(outData[d]);  
  •                     count+=1;  
  •                     labelMap.put(outData[d], count);  
  •                 } else {  
  •                     labelMap.put(outData[d], 1);  
  •                 }  
  •             }  
  •         }  
  •           
  •         // try to find the max connected component  
  •         Integer[] keys = labelMap.keySet().toArray(new Integer[0]);  
  •         Arrays.sort(keys);  
  •         int maxKey = 1;  
  •         int max = 0;  
  •         for(Integer key : keys) {  
  •             if(max < labelMap.get(key)){  
  •                 max = labelMap.get(key);  
  •                 maxKey = key;  
  •             }  
  •             System.out.println( "Number of " + key + " = " + labelMap.get(key));  
  •         }  
  •         System.out.println("maxkey = " + maxKey);  
  •         System.out.println("max connected component number = " + max);  
  •         return outData;  
  •     }  
  •   
  •     private void mergeLabels(int index) {  
  •         int row = index / dw;  
  •         int col = index % dw;  
  •           
  •         // get current possible existed labels  
  •         int min = getLabel(outData, row, col);  
  •         if(min == 0) return;  
  •         if(min > getLabel(outData, row-1, col) && getLabel(outData, row-1, col) != 0) {  
  •             min = getLabel(outData, row-1, col);  
  •         }  
  •           
  •         if(min > getLabel(outData, row, col-1) && getLabel(outData, row, col-1) != 0) {  
  •             min = getLabel(outData, row, col-1);  
  •         }  
  •           
  •         if(min > getLabel(outData, row+1, col) && getLabel(outData, row+1, col) != 0) {  
  •             min = getLabel(outData, row+1, col);  
  •         }  
  •           
  •         if(min > getLabel(outData, row, col+1) && getLabel(outData, row, col+1) != 0) {  
  •             min = getLabel(outData, row, col+1);  
  •         }  
  •           
  •         if(min > getLabel(outData, row-1, col-1) && getLabel(outData, row-1, col-1) != 0) {  
  •             min = getLabel(outData, row-1, col-1);  
  •         }  
  •           
  •         if(min > getLabel(outData, row-1, col+1) && getLabel(outData, row-1, col+1) != 0) {  
  •             min = getLabel(outData, row-1, col+1);  
  •         }  
  •           
  •         if(min > getLabel(outData, row+1, col-1) && getLabel(outData, row+1, col-1) != 0) {  
  •             min = getLabel(outData, row+1, col-1);  
  •         }  
  •           
  •         if(min > getLabel(outData, row+1, col+1) && getLabel(outData, row+1, col+1) != 0) {  
  •             min = getLabel(outData, row+1, col+1);  
  •         }  
  •   
  •         if(getLabel(outData, row, col) == min)  
  •             return;  
  •         outData[index] = min;  
  •           
  •         // eight neighborhood pixels  
  •         if((row -1) >= 0) {  
  •               
  •             mergeLabels((row-1)*dw + col);  
  •         }  
  •           
  •         if((col-1) >= 0) {  
  •             mergeLabels(row*dw+col-1);  
  •         }  
  •           
  •         if((row+1) < dh) {  
  •             mergeLabels((row + 1)*dw+col);  
  •         }  
  •           
  •         if((col+1) < dw) {  
  •             mergeLabels((row)*dw+col+1);  
  •         }  
  •           
  •         if((row-1)>= 0 && (col-1) >=0) {  
  •             mergeLabels((row-1)*dw+col-1);  
  •         }  
  •           
  •         if((row-1)>= 0 && (col+1) < dw) {  
  •             mergeLabels((row-1)*dw+col+1);  
  •         }  
  •           
  •         if((row+1) < dh && (col-1) >=0) {  
  •             mergeLabels((row+1)*dw+col-1);  
  •         }  
  •           
  •         if((row+1) < dh && (col+1) < dw) {  
  •             mergeLabels((row+1)*dw+col+1);  
  •         }  
  •     }  
  •       
  •     private void setData(int[] data, int row, int col, int value) {  
  •         if(row < 0 || row >= dh) {  
  •             return;  
  •         }  
  •           
  •         if(col < 0 || col >= dw) {  
  •             return;  
  •         }  
  •           
  •         int index = row * dw + col;  
  •         data[index] = value;  
  •     }  
  •       
  •     private int getLabel(int[] data, int row, int col) {  
  •         // handle the edge pixels  
  •         if(row < 0 || row >= dh) {  
  •             return 0;  
  •         }  
  •           
  •         if(col < 0 || col >= dw) {  
  •             return 0;  
  •         }  
  •           
  •         int index = row * dw + col;  
  •         return (data[index] & 0x000000ff);  
  •     }  
  •   
  •     private int getPixel(int[] data, int row, int col) {  
  •         // handle the edge pixels  
  •         if(row < 0 || row >= dh) {  
  •             return bgColor;  
  •         }  
  •           
  •         if(col < 0 || col >= dw) {  
  •             return bgColor;  
  •         }  
  •           
  •         int index = row * dw + col;  
  •         return (data[index] & 0x000000ff);  
  •     }  
  •   
  •     /** 
  •      * binary image data: 
  •      *  
  •      * 255, 0,   0,   255,   0,   255, 255, 0,   255, 255, 255, 
  •      * 255, 0,   0,   255,   0,   255, 255, 0,   0,   255, 0, 
  •      * 255, 0,   0,   0,     255, 255, 255, 255, 255, 0,   0, 
  •      * 255, 255, 0,   255,   255, 255, 0,   255, 0,   0,   255 
  •      * 255, 255, 0,   0,     0,   0,   255, 0,   0,   0,   0 
  •      *  
  •      * height = 5, width = 11 
  •      * @param args 
  •      */  
  •     public static int[] imageData = new int[]{  
  •          255, 0,   0,   255,   0,   255, 255, 0,   255, 255, 255,  
  •          255, 0,   0,   255,   0,   255, 255, 0,   0,   255, 0,  
  •          255, 0,   0,   0,     255, 255, 255, 255, 255, 0,   0,  
  •          255, 255, 0,   255,   255, 255, 0,   255, 0,   0,   255,  
  •          255, 255, 0,   0,     0,   0,   255, 0,   0,   0,   0  
  •     };  
  •       
  •     public static void main(String[] args) {  
  •         FastConnectedComponentLabelAlg ccl = new FastConnectedComponentLabelAlg();  
  •         int[] outData = ccl.doLabel(imageData, 11, 5);  
  •         for(int i=0; i<5; i++) {  
  •             System.out.println("--------------------");  
  •             for(int j = 0; j<11; j++) {  
  •                 int index = i * 11 + j;  
  •                 if(j != 0) {  
  •                     System.out.print(",");  
  •                 }  
  •                 System.out.print(outData[index]);  
  •             }  
  •             System.out.println();  
  •         }  
  •     }  
  •   
  • }  

    • 找到最大连通区域以后，对最大连通区域数据进行扫描，找出最小点，即矩形区域左上角坐

    标，找出最大点，即矩形区域右下角坐标。知道这四个点坐标以后，在原图上打上红色矩形

    框，标记出脸谱位置。寻找四个点坐标的实现代码如下：

    [java] view plaincopy
  • private void getFaceRectangel() {  
  •     int width = resultImage.getWidth();  
  •        int height = resultImage.getHeight();  
  •        int[] inPixels = new int[width*height];  
  •        getRGB(resultImage, 0, 0, width, height, inPixels);  
  •          
  •        int index = 0;  
  •        int ta = 0, tr = 0, tg = 0, tb = 0;  
  •        for(int row=0; row<height; row++) {  
  •         for(int col=0; col<width; col++) {  
  •             index = row * width + col;  
  •             ta = (inPixels[index] >> 24) & 0xff;  
  •                tr = (inPixels[index] >> 16) & 0xff;  
  •                tg = (inPixels[index] >> 8) & 0xff;  
  •                tb = inPixels[index] & 0xff;  
  •                if(tr == tg && tg == tb && tb == 0) { // face skin  
  •                 if(minY > row) {  
  •                     minY = row;  
  •                 }  
  •                   
  •                 if(minX > col) {  
  •                     minX = col;  
  •                 }  
  •                   
  •                 if(maxY < row) {  
  •                     maxY = row;  
  •                 }  
  •                   
  •                 if(maxX < col) {  
  •                     maxX = col;  
  •                 }  
  •                }  
  •         }  
  •        }  
  • }  
    • 缺点：

    此算法不支持多脸谱检测，不支持裸体中的脸谱检测，但是根据人脸的

    生物学特征可以进一步细化分析，支持裸体人脸检测。


    写本文章的目的：本例为图像处理综合运行的一个简单实例。同时人脸检

    测也是个感兴趣的话题。

    总结

    以上是生活随笔为你收集整理的图像处理之简单脸谱检测算法的全部内容，希望文章能够帮你解决所遇到的问题。

    如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。