基于图像分块的图像瓜分

基于图像分块的图像分割
阈值处理直观、实现简单且计算速度快，因此图像阈值处理在图像分割中处于核心地位。阈值处理可分为全局阈值处理和局部阈值处理(可变阈值处理)。本人在http://blog.csdn.net/wuhaibing_cver/article/details/8473498一文中介绍了基于OTSU的全局阈值处理，由于噪声和非均匀光照对阈值处理算法的性能起着重要作用，所以有时候利用全局阈值处理进行图像分割往往会导致错误的分割结果。

基于图像分块的局部图像分割。图像分块属于可变阈值处理中简单的方法，这种方法可补偿光照的不均匀性。选择的矩形要足够小，以便每个矩形的光照都是近视均匀的。需要强调的是，不能把图像分的过细，因为细分可能只包含物体或背景像素。

下面给出该方法的源代码，使用的工具为VS2008+OpenCV2.0.

1. #include <cv.h>  
2. #include <highgui.h>  
3. #include <iostream>  
4.   
5. using namespace std;  
6.   
7. int otsu(const IplImage *image)  
8. {  
9.     assert(NULL != image);  
10.   
11.     int width = image->width;  
12.     int height = image->height;  
13.     int x=0,y=0;  
14.     int pixelCount[256];  
15.     float pixelPro[256];  
16.     int i, j, pixelSum = width * height, threshold = 0;  
17.   
18.     uchar* data = (uchar*)image->imageData;  
19.   
20.     //初始化  
21.     for(i = 0; i < 256; i++)  
22.     {  
23.         pixelCount[i] = 0;  
24.         pixelPro[i] = 0;  
25.     }  
26.   
27.     //统计灰度级中每个像素在整幅图像中的个数  
28.     for(i = y; i < height; i++)  
29.     {  
30.         for(j = x;j <width;j++)  
31.         {  
32.             pixelCount[data[i * image->widthStep + j]]++;  
33.         }  
34.     }  
35.   
36.   
37.     //计算每个像素在整幅图像中的比例  
38.     for(i = 0; i < 256; i++)  
39.     {  
40.         pixelPro[i] = (float)(pixelCount[i]) / (float)(pixelSum);  
41.     }  
42.   
43.     //经典ostu算法,得到前景和背景的分割  
44.     //遍历灰度级[0,255],计算出方差最大的灰度值,为最佳阈值  
45.     float w0, w1, u0tmp, u1tmp, u0, u1, u,deltaTmp, deltaMax = 0;  
46.     for(i = 0; i < 256; i++)  
47.     {  
48.         w0 = w1 = u0tmp = u1tmp = u0 = u1 = u = deltaTmp = 0;  
49.   
50.         for(j = 0; j < 256; j++)  
51.         {  
52.             if(j <= i) //背景部分  
53.             {  
54.                 //以i为阈值分类，第一类总的概率  
55.                 w0 += pixelPro[j];        
56.                 u0tmp += j * pixelPro[j];  
57.             }  
58.             else       //前景部分  
59.             {  
60.                 //以i为阈值分类，第二类总的概率  
61.                 w1 += pixelPro[j];        
62.                 u1tmp += j * pixelPro[j];  
63.             }  
64.         }  
65.   
66.         u0 = u0tmp / w0;        //第一类的平均灰度  
67.         u1 = u1tmp / w1;        //第二类的平均灰度  
68.         u = u0tmp + u1tmp;      //整幅图像的平均灰度  
69.         //计算类间方差  
70.         deltaTmp = w0 * (u0 - u)*(u0 - u) + w1 * (u1 - u)*(u1 - u);  
71.         //找出最大类间方差以及对应的阈值  
72.         if(deltaTmp > deltaMax)  
73.         {     
74.             deltaMax = deltaTmp;  
75.             threshold = i;  
76.         }  
77.     }  
78.     //返回最佳阈值;  
79.     return threshold;  
80. }  
81.   
82. int main()  
83. {  
84.     char* filename = "D:\\technology\\CV\\Databases\\image\\septagon_noisy_shaded.tif";  
85.     IplImage* src_image = cvLoadImage(filename,0);  
86.     if(!src_image)  
87.         return -1;  
88.   
89.     cvNamedWindow("src",0);  
90.     cvShowImage("src",src_image);  
91.   
92.     CvSize size = cvGetSize(src_image);  
93.     int height = size.height, width = size.width;  
94.     IplImage* bi_image = cvCreateImage(size,8,1);  
95.   
96. #if 0  
97.   
98.     int threshold = otsu(src_image);  
99.     cout<<"threshold: "<<threshold<<endl;  
100.   
101.     cvThreshold(src_image,bi_image,threshold,255,CV_THRESH_BINARY);  
102.   
103. #else  
104.     int rows = 2, cols = 3;  
105.     //第i行，第j列的左上角topleft，右下角bottomright  
106.     CvPoint topleft,bottomright;  
107.     CvRect rect;  
108.     IplImage* roi_image = 0;  
109.     IplImage* bi_roi = 0;  
110.     for(int i=0;i<rows;i++)  
111.     {  
112.         for(int j=0;j<cols;j++)  
113.         {  
114.             topleft.x = cvRound(j*width/(float)cols);  
115.             topleft.y = cvRound(i*height/(float)rows);  
116.             bottomright.x = cvRound((j+1)*width/(float)cols);  
117.             bottomright.y = cvRound((i+1)*height/(float)rows);  
118.             int w = bottomright.x-topleft.x;  
119.             int h = bottomright.y-topleft.y;  
120.               
121.             rect = cvRect(topleft.x,topleft.y,w,h);  
122.             cvSetImageROI(src_image,rect);  
123.             cvSetImageROI(bi_image,rect);  
124.             roi_image = cvCreateImage(cvSize(w,h),8,1);  
125.             bi_roi = cvCreateImage(cvSize(w,h),8,1);  
126.             cvCopy(src_image,roi_image);  
127.             cvResetImageROI(src_image);  
128.   
129.             int threshold = otsu(roi_image);  
130.             cvThreshold(roi_image,bi_roi,threshold,255,CV_THRESH_BINARY);  
131.             cvCopy(bi_roi,bi_image);  
132.   
133.             cvResetImageROI(bi_image);  
134.             cvReleaseImage(&bi_roi);  
135.             cvReleaseImage(&roi_image);  
136.         }  
137.     }  
138.   
139. #endif  
140.   
141.     cvNamedWindow("dst",0);  
142.     cvShowImage("dst",bi_image);  
143.   
144.     cvWaitKey(0);  
145.   
146.     cvReleaseImage(&src_image);  
147.     cvReleaseImage(&bi_image);  
148.     cvDestroyWindow("src");  
149.     cvDestroyWindow("dst");  
150.   
151.     return 0;  
152. }

当把图像分块成2行3列，即rows = 2, cols = 3时，分割结果如下，可以看到该分割结果符合我们的要求。

当rows = 3, cols = 4时，由于图像分的过细，某些局部只包含了物体或背景，导致分割失败，如下图所示：