OpenCV学习笔记之二值图像的边缘光滑处理

1. //去除二值图像边缘的突出部  
2. //uthreshold、vthreshold分别表示突出部的宽度阈值和高度阈值  
3. //type代表突出部的颜色，0表示黑色，1代表白色   
4. void delete_jut(Mat& src, Mat& dst, int uthreshold, int vthreshold, int type)  
5. {  
6.     int threshold;  
7.     src.copyTo(dst);  
8.     int height = dst.rows;  
9.     int width = dst.cols;  
10.     int k;  //用于循环计数传递到外部  
11.     for (int i = 0; i < height - 1; i++)  
12.     {  
13.         uchar* p = dst.ptr<uchar>(i);  
14.         for (int j = 0; j < width - 1; j++)  
15.         {  
16.             if (type == 0)  
17.             {  
18.                 //行消除  
19.                 if (p[j] == 255 && p[j + 1] == 0)  
20.                 {  
21.                     if (j + uthreshold >= width)  
22.                     {  
23.                         for (int k = j + 1; k < width; k++)  
24.                             p[k] = 255;  
25.                     }  
26.                     else  
27.                     {  
28.                         for (k = j + 2; k <= j + uthreshold; k++)  
29.                         {  
30.                             if (p[k] == 255) break;  
31.                         }  
32.                         if (p[k] == 255)  
33.                         {  
34.                             for (int h = j + 1; h < k; h++)  
35.                                 p[h] = 255;  
36.                         }  
37.                     }  
38.                 }  
39.                 //列消除  
40.                 if (p[j] == 255 && p[j + width] == 0)  
41.                 {  
42.                     if (i + vthreshold >= height)  
43.                     {  
44.                         for (k = j + width; k < j + (height - i)*width; k += width)  
45.                             p[k] = 255;  
46.                     }  
47.                     else  
48.                     {  
49.                         for (k = j + 2 * width; k <= j + vthreshold*width; k += width)  
50.                         {  
51.                             if (p[k] == 255) break;  
52.                         }  
53.                         if (p[k] == 255)  
54.                         {  
55.                             for (int h = j + width; h < k; h += width)  
56.                                 p[h] = 255;  
57.                         }  
58.                     }  
59.                 }  
60.             }  
61.             else  //type = 1  
62.             {  
63.                 //行消除  
64.                 if (p[j] == 0 && p[j + 1] == 255)  
65.                 {  
66.                     if (j + uthreshold >= width)  
67.                     {  
68.                         for (int k = j + 1; k < width; k++)  
69.                             p[k] = 0;  
70.                     }  
71.                     else  
72.                     {  
73.                         for (k = j + 2; k <= j + uthreshold; k++)  
74.                         {  
75.                             if (p[k] == 0) break;  
76.                         }  
77.                         if (p[k] == 0)  
78.                         {  
79.                             for (int h = j + 1; h < k; h++)  
80.                                 p[h] = 0;  
81.                         }  
82.                     }  
83.                 }  
84.                 //列消除  
85.                 if (p[j] == 0 && p[j + width] == 255)  
86.                 {  
87.                     if (i + vthreshold >= height)  
88.                     {  
89.                         for (k = j + width; k < j + (height - i)*width; k += width)  
90.                             p[k] = 0;  
91.                     }  
92.                     else  
93.                     {  
94.                         for (k = j + 2 * width; k <= j + vthreshold*width; k += width)  
95.                         {  
96.                             if (p[k] == 0) break;  
97.                         }  
98.                         if (p[k] == 0)  
99.                         {  
100.                             for (int h = j + width; h < k; h += width)  
101.                                 p[h] = 0;  
102.                         }  
103.                     }  
104.                 }  
105.             }  
106.         }  
107.     }  
108. }