数字图像处理中结构元素、腐蚀、膨胀的基本概念。（转+源）

地址http://blog.csdn.net/TonyShengTan/article/details/42426033（参考书：冈萨雷斯的书，《图像处理、分析与机器视觉》）

结构元素：

二维结构元素可以理解成一个二维矩阵，矩阵元素的值为0或者1；通常结构元素要小于待处理的图像。

腐蚀：

把结构元素B平移a后得到Ba，若Ba包含于X，我们记下这个a点，所有满足上述条件的a点组成的集合称做X被B腐蚀(Erosion)的结果。

图中有个错误：第三个图，也就是腐蚀的结果中，黑点没有最左侧一列（两个黑点）。

  膨胀(dilation)

可以看做是腐蚀的对偶运算，其定义是：把结构元素B平移a后得到B_a，若B_a击中X，我们记下这个a点。所有满足上述条件的a点组成的集合称做X被B膨胀的结果。

膨胀过程：

说明：左边是被处理的图象X(二值图象，我们针对的是黑点)，中间是结构元素B。膨胀的方法是，拿B的中心点和X上的点及X周围的点一个一个地对，如果B上有一个点落在X的范围内，则该点就为黑；右边是膨胀后的结果。可以看出，它包括X的所有范围，就象X膨胀了一圈似的。

开操作与闭操作：

开操作：先腐蚀后膨胀。开操作是将跨度小于结构元的峰顶消去。可以去掉目标外的孤立点。

闭操作：先膨胀后腐蚀是闭操作。将跨度小于结构元的谷底填平。可以去掉目标内的孔。如下图：

图中蓝色为原图，红色为开操作，绿色为闭操作。

顶帽和底帽

       顶帽操作和底帽操作是灰度图像所特有的，其原理是开操作将使峰顶消去，具体消去了多少呢，可以用原图减去开操作结果，这样就能得到其消去的部分，而这个过程成为顶帽操作，顶帽就是开操作消去的峰顶，这一部分对应于图像中较亮的部分，也叫白色顶帽。

       同理，底帽操作是用闭操作的结果减去原图就得到被闭操作填充的谷底部分，这一部分对应于图像中较暗的部分，也叫黑色底帽。

测地腐蚀与测地膨胀

测地腐蚀与测地膨胀在二值图像中的操作是将腐蚀与膨胀结果与ground做“与”和“或”操作，与灰度膨胀中膨胀的推广一样，“与”和“或”被取代为最大值和最小值。

重建操作

       重建操作分为很多种，包括重建开操作、重建顶帽操作等。其根本原理是通过腐蚀找到SE的模式，然后迭代膨胀或者迭代顶帽操作直到图像收敛。

代码

[cpp] view plain copy

1. #include <cv.h>  
2. #include <highgui.h>  
3. #include <stdio.h>  
4. #define TOFINDMAX 0  
5. #define TOFINDMIN 1  
6. #define isSIZEEQU(x,y) (((x)->width)==((y)->width)&&((x)->height)==((y)->height))  
7. struct position{  
8.     int x;  
9.     int y;  
10. };  
11. typedef struct position Position;  
12. //判断结构元是否平滑  
13. int isSmooth(IplImage *src){  
14.     int width=src->width;  
15.     int height=src->height;  
16.     for(int i=0;i<width;i++)  
17.         for(int j=0;j<height;j++){  
18.             int v=cvGetReal2D(src,j,i);  
19.             if(v!=255.0&&v!=0.0)  
20.                 return 0;  
21.         }  
22.     return 1;  
23. }  
24. //判断两幅图像是否相等  
25. int isEqu(IplImage *src1,IplImage *src2){  
26.     if(!isSIZEEQU(src1, src2))  
27.         return 0;  
28.     for(int i=0;i<src1->width;i++)  
29.         for(int j=0;j<src1->height;j++){  
30.             double v1=cvGetReal2D(src1, j, i);  
31.             double v2=cvGetReal2D(src2, j, i);  
32.             if(v1!=v2)  
33.                 return 0;  
34.         }  
35.     return 1;  
36.   
37. }  
38. //将图像全部设置为1  
39. void One(IplImage *src){  
40.     int width=src->width;  
41.     int height=src->height;  
42.     for(int i=0;i<width;i++)  
43.         for(int j=0;j<height;j++)  
44.             cvSetReal2D(src, j, i, 255.0);  
45.   
46.   
47. }  
48. //位移，如果非平滑SE将加上sevalue，即对应的灰度值  
49. void Translation(IplImage *src ,IplImage *dst,double SEvalue,Position *d,int istoFindMin){  
50.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
51.     int srcwidth=src->width;  
52.     int srcheight=src->height;  
53.     int dstwidth=dst->width;  
54.     int dstheight=dst->height;  
55.     if(istoFindMin)  
56.         One(temp);  
57.     else  
58.         cvZero(temp);  
59.     for(int i=0;i<srcwidth;i++){  
60.         for(int j=0;j<srcheight;j++){  
61.             int target_x=i+d->x;  
62.             int target_y=j+d->y;  
63.             if(target_x>=0&&target_y>=0&&  
64.                target_x<dstwidth&&target_y<dstheight){  
65.                 double value=cvGetReal2D(src, j, i)+SEvalue;  
66.                 value=(value>=255.0?255.0:value);  
67.                 cvSetReal2D(temp, target_y, target_x, value);  
68.             }  
69.         }  
70.     }  
71.     cvCopy(temp, dst, NULL);  
72.       
73.     cvReleaseImage(&temp);  
74. }  
75. //找出两幅等大图像中同一位置中相对较大的像素值  
76. void MaxPix(IplImage *src1 ,IplImage *src2,IplImage *dst){  
77.     if(!isSIZEEQU(src1, src2)||!isSIZEEQU(src1, dst)){  
78.         printf("MaxPix wrong: src size not equ!\n");  
79.         exit(1);  
80.     }  
81.     int width=src1->width;  
82.     int height=src1->height;  
83.     for(int i=0;i<width;i++)  
84.         for(int j=0;j<height;j++){  
85.             double value1=cvGetReal2D(src1, j,i);  
86.             double value2=cvGetReal2D(src2, j,i);  
87.             value1>value2?cvSetReal2D(dst, j,i,value1):cvSetReal2D(dst, j, i, value2);  
88.         }  
89.   
90. }  
91. //找出两幅等大图像中同一位置中相对较小的像素值  
92. void MinPix(IplImage *src1 ,IplImage *src2,IplImage *dst){  
93.     if(!isSIZEEQU(src1, src2)||!isSIZEEQU(src1, dst)){  
94.         printf("MaxPix wrong: src size not equ!\n");  
95.         exit(1);  
96.     }  
97.     int width=src1->width;  
98.     int height=src1->height;  
99.     for(int i=0;i<width;i++)  
100.         for(int j=0;j<height;j++){  
101.             double value1=cvGetReal2D(src1, j,i);  
102.             double value2=cvGetReal2D(src2, j,i);  
103.             value1<value2?cvSetReal2D(dst, j, i, value1):cvSetReal2D(dst, j, i, value2);  
104.         }  
105.       
106. }  
107. //灰度图像膨胀  
108. void Dilate_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
109.     int SEissmooth=isSmooth(se);  
110.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
111.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
112.     Position centerde;  
113.     centerde.x=se->width/2;  
114.     centerde.y=se->height/2;  
115.     if(center==NULL){  
116.         center=¢erde;  
117.     }  
118.     int sewidth=se->width;  
119.     int seheight=se->height;  
120.     cvCopy(src,temp_last,NULL);  
121.     for(int i=0;i<sewidth;i++)  
122.         for(int j=0;j<seheight;j++){  
123.             cvCopy(src,temp,NULL);  
124.             double value=cvGetReal2D(se, j, i);  
125.             if(value!=0.0){  
126.                 Position d;  
127.                 d.x=center->x-i;  
128.                 d.y=center->y-j;  
129.                 if(SEissmooth)  
130.                     Translation(temp, temp, 0.0, &d,TOFINDMAX);  
131.                 else  
132.                     Translation(temp, temp, value, &d,TOFINDMAX);  
133.                 MaxPix(temp, temp_last, temp_last);  
134.             }  
135.         }  
136.     cvCopy(temp_last, dst, NULL);  
137.     cvReleaseImage(&temp);  
138.     cvReleaseImage(&temp_last);  
139.   
140. }  
141. //灰度图像腐蚀  
142. void Erode_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
143.     int SEissmooth=isSmooth(se);  
144.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
145.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
146.     Position centerde;  
147.     centerde.x=se->width/2;  
148.     centerde.y=se->height/2;  
149.     if(center==NULL){  
150.         center=¢erde;  
151.     }  
152.     int sewidth=se->width;  
153.     int seheight=se->height;  
154.     cvCopy(src,temp_last,NULL);  
155.     for(int i=0;i<sewidth;i++)  
156.         for(int j=0;j<seheight;j++){  
157.             cvCopy(src,temp,NULL);  
158.             double value=cvGetReal2D(se, j, i);  
159.             if(value!=0.0){  
160.                 Position d;  
161.                   
162.                 d.x=i-center->x;  
163.                 d.y=j-center->y;  
164.                 if(SEissmooth)  
165.                     Translation(temp, temp, 0.0, &d,TOFINDMIN);  
166.                 else  
167.                     Translation(temp, temp, -1.0*value, &d,TOFINDMIN);  
168.                 MinPix(temp, temp_last, temp_last);  
169.                   
170.             }  
171.         }  
172.     cvCopy(temp_last, dst, NULL);  
173.     cvReleaseImage(&temp);  
174.     cvReleaseImage(&temp_last);  
175.       
176. }  
177. //开操作  
178. void Open_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
179.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
180.     Erode_Gray(src, temp, se, center);  
181.     Dilate_Gray(temp, temp, se, center);  
182.     cvCopy(temp, dst, NULL);  
183.     cvReleaseImage(&temp);  
184.   
185. }  
186. //闭操作  
187. void Close_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
188.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
189.     Dilate_Gray(src, temp, se, center);  
190.     Erode_Gray(temp, temp, se, center);  
191.     cvCopy(temp, dst, NULL);  
192.     cvReleaseImage(&temp);  
193.       
194. }  
195. //灰度梯度形态学提取  
196. void Gard_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
197.     IplImage *temp_dilate=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
198.     IplImage *temp_erode=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
199.     Dilate_Gray(src, temp_dilate, se, center);  
200.     Erode_Gray(src, temp_erode, se, center);  
201.     cvSub(temp_dilate, temp_erode, dst, NULL);  
202.     cvReleaseImage(&temp_erode);  
203.     cvReleaseImage(&temp_dilate);  
204.   
205.   
206. }  
207. //顶帽操作  
208. void TopHat(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
209.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
210.     Open_Gray(src, temp, se, center);  
211.     cvSub( src,temp, dst, NULL);  
212.     cvReleaseImage(&temp);  
213.   
214. }  
215. //底帽操作  
216. void BottomHat(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
217.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
218.     Close_Gray(src, temp, se, center);  
219.     cvSub(temp,src, dst, NULL);  
220.     cvReleaseImage(&temp);  
221.       
222. }  
223. //测地腐蚀  
224. void Erode_Gray_g(IplImage *src,IplImage *ground,IplImage *dst,IplImage *se,Position *center){  
225.     int SEissmooth=isSmooth(se);  
226.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
227.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
228.     Position centerde;  
229.     centerde.x=se->width/2;  
230.     centerde.y=se->height/2;  
231.     if(center==NULL){  
232.         center=¢erde;  
233.     }  
234.     int sewidth=se->width;  
235.     int seheight=se->height;  
236.     cvCopy(src,temp_last,NULL);  
237.     for(int i=0;i<sewidth;i++)  
238.         for(int j=0;j<seheight;j++){  
239.             cvCopy(src,temp,NULL);  
240.             double value=cvGetReal2D(se, j, i);  
241.             if(value!=0.0){  
242.                 Position d;  
243.                   
244.                 d.x=i-center->x;  
245.                 d.y=j-center->y;  
246.                 if(SEissmooth)  
247.                     Translation(temp, temp, 0.0, &d,TOFINDMIN);  
248.                 else  
249.                     Translation(temp, temp, -1.0*value, &d,TOFINDMIN);  
250.                 MinPix(temp, temp_last, temp_last);  
251.                   
252.             }  
253.         }  
254.     MaxPix(temp_last,ground,temp_last);  
255.     cvCopy(temp_last, dst, NULL);  
256.     cvReleaseImage(&temp);  
257.     cvReleaseImage(&temp_last);  
258.   
259.   
260. }  
261. //测地膨胀  
262. void Dilate_Gray_g(IplImage *src,IplImage *ground,IplImage *dst,IplImage *se,Position *center){  
263.     int SEissmooth=isSmooth(se);  
264.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
265.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
266.     Position centerde;  
267.     centerde.x=se->width/2;  
268.     centerde.y=se->height/2;  
269.     if(center==NULL){  
270.         center=¢erde;  
271.     }  
272.     int sewidth=se->width;  
273.     int seheight=se->height;  
274.     cvCopy(src,temp_last,NULL);  
275.     for(int i=0;i<sewidth;i++)  
276.         for(int j=0;j<seheight;j++){  
277.             cvCopy(src,temp,NULL);  
278.             double value=cvGetReal2D(se, j, i);  
279.             if(value!=0.0){  
280.                 Position d;  
281.                 d.x=center->x-i;  
282.                 d.y=center->y-j;  
283.                 if(SEissmooth)  
284.                     Translation(temp, temp, 0.0, &d,TOFINDMAX);  
285.                 else  
286.                     Translation(temp, temp, value, &d,TOFINDMAX);  
287.                 MaxPix(temp, temp_last, temp_last);  
288.             }  
289.         }  
290.     MinPix(temp_last, ground, temp_last);  
291.     cvCopy(temp_last, dst, NULL);  
292.     cvReleaseImage(&temp);  
293.     cvReleaseImage(&temp_last);  
294. }  
295. //重建开操作  
296. void Rebuild_Open(IplImage *src,IplImage *dst,IplImage *ground,IplImage *erodeSE,IplImage *dilateSE,int eroden){  
297.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
298.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
299.     cvCopy(src, temp, NULL);  
300.     for(int i=0;i<eroden;i++){  
301.         Erode_Gray(temp, temp, erodeSE, NULL);  
302.     }  
303.       
304.     while(!isEqu(temp, temp_last)){  
305.         cvCopy(temp, temp_last, NULL);  
306.         Dilate_Gray_g(temp, ground, temp, dilateSE, NULL);  
307.           
308.     }  
309.     cvCopy(temp, dst, NULL);  
310.     cvReleaseImage(&temp);  
311.     cvReleaseImage(&temp_last);  
312.       
313. }  
314. //重建闭操作，这段没测试  
315. void Rebuild_Close(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int dilaten){  
316.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
317.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
318.     cvCopy(src, temp, NULL);  
319.     for(int i=0;i<dilaten;i++){  
320.         Dilate_Gray(temp, temp, dilateSE, NULL);  
321.     }  
322.       
323.     while(!isEqu(temp, temp_last)){  
324.         cvCopy(temp, temp_last, NULL);  
325.         Erode_Gray(temp, temp, erodeSE, NULL);  
326.         MinPix(temp, ground, temp);  
327.           
328.     }  
329.     cvCopy(temp, dst, NULL);  
330.     cvReleaseImage(&temp);  
331.     cvReleaseImage(&temp_last);  
332.       
333. }  
334. //重建顶帽操作  
335. void Rebuild_Tophat(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int eroden){  
336.     Rebuild_Open(src,dst,ground,erodeSE,dilateSE,eroden);  
337.     cvSub(src, dst, dst, NULL);  
338.   
339. }  
340. //重建底帽操作  
341. void Rebuild_Bottomhat(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int dilaten){  
342.     Rebuild_Close(src,dst,ground,dilateSE,erodeSE,dilaten);  
343.     cvSub(src, dst, dst, NULL);  
344.       
345. }  
346. int main(){  
347.       
348.     return 1;  
349.   
350. }  

结果图片：

       以下结果原图为lena 512x512的图像产生：

腐蚀：

膨胀：

开操作：

闭操作：

顶帽操作：

底帽操作：

重建操作示意（冈萨雷斯 中文第三版 P437）：

去除横向亮条：重建顶帽操作

重建开操作，去除纵向亮纹：

上图横向膨胀：

膨胀结果与重建顶帽操作的最小操作：

原图对比：

代码
[cpp] view plain copy

    #include <cv.h>  
    #include <highgui.h>  
    #include <stdio.h>  
    #define TOFINDMAX 0  
    #define TOFINDMIN 1  
    #define isSIZEEQU(x,y) (((x)->width)==((y)->width)&&((x)->height)==((y)->height))  
    struct position{  
        int x;  
        int y;  
    };  
    typedef struct position Position;  
    //判断结构元是否平滑  
    int isSmooth(IplImage *src){  
        int width=src->width;  
        int height=src->height;  
        for(int i=0;i<width;i++)  
            for(int j=0;j<height;j++){  
                int v=cvGetReal2D(src,j,i);  
                if(v!=255.0&&v!=0.0)  
                    return 0;  
            }  
        return 1;  
    }  
    //判断两幅图像是否相等  
    int isEqu(IplImage *src1,IplImage *src2){  
        if(!isSIZEEQU(src1, src2))  
            return 0;  
        for(int i=0;i<src1->width;i++)  
            for(int j=0;j<src1->height;j++){  
                double v1=cvGetReal2D(src1, j, i);  
                double v2=cvGetReal2D(src2, j, i);  
                if(v1!=v2)  
                    return 0;  
            }  
        return 1;  
      
    }  
    //将图像全部设置为1  
    void One(IplImage *src){  
        int width=src->width;  
        int height=src->height;  
        for(int i=0;i<width;i++)  
            for(int j=0;j<height;j++)  
                cvSetReal2D(src, j, i, 255.0);  
      
      
    }  
    //位移，如果非平滑SE将加上sevalue，即对应的灰度值  
    void Translation(IplImage *src ,IplImage *dst,double SEvalue,Position *d,int istoFindMin){  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        int srcwidth=src->width;  
        int srcheight=src->height;  
        int dstwidth=dst->width;  
        int dstheight=dst->height;  
        if(istoFindMin)  
            One(temp);  
        else  
            cvZero(temp);  
        for(int i=0;i<srcwidth;i++){  
            for(int j=0;j<srcheight;j++){  
                int target_x=i+d->x;  
                int target_y=j+d->y;  
                if(target_x>=0&&target_y>=0&&  
                   target_x<dstwidth&&target_y<dstheight){  
                    double value=cvGetReal2D(src, j, i)+SEvalue;  
                    value=(value>=255.0?255.0:value);  
                    cvSetReal2D(temp, target_y, target_x, value);  
                }  
            }  
        }  
        cvCopy(temp, dst, NULL);  
          
        cvReleaseImage(&temp);  
    }  
    //找出两幅等大图像中同一位置中相对较大的像素值  
    void MaxPix(IplImage *src1 ,IplImage *src2,IplImage *dst){  
        if(!isSIZEEQU(src1, src2)||!isSIZEEQU(src1, dst)){  
            printf("MaxPix wrong: src size not equ!\n");  
            exit(1);  
        }  
        int width=src1->width;  
        int height=src1->height;  
        for(int i=0;i<width;i++)  
            for(int j=0;j<height;j++){  
                double value1=cvGetReal2D(src1, j,i);  
                double value2=cvGetReal2D(src2, j,i);  
                value1>value2?cvSetReal2D(dst, j,i,value1):cvSetReal2D(dst, j, i, value2);  
            }  
      
    }  
    //找出两幅等大图像中同一位置中相对较小的像素值  
    void MinPix(IplImage *src1 ,IplImage *src2,IplImage *dst){  
        if(!isSIZEEQU(src1, src2)||!isSIZEEQU(src1, dst)){  
            printf("MaxPix wrong: src size not equ!\n");  
            exit(1);  
        }  
        int width=src1->width;  
        int height=src1->height;  
        for(int i=0;i<width;i++)  
            for(int j=0;j<height;j++){  
                double value1=cvGetReal2D(src1, j,i);  
                double value2=cvGetReal2D(src2, j,i);  
                value1<value2?cvSetReal2D(dst, j, i, value1):cvSetReal2D(dst, j, i, value2);  
            }  
          
    }  
    //灰度图像膨胀  
    void Dilate_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
        int SEissmooth=isSmooth(se);  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Position centerde;  
        centerde.x=se->width/2;  
        centerde.y=se->height/2;  
        if(center==NULL){  
            center=¢erde;  
        }  
        int sewidth=se->width;  
        int seheight=se->height;  
        cvCopy(src,temp_last,NULL);  
        for(int i=0;i<sewidth;i++)  
            for(int j=0;j<seheight;j++){  
                cvCopy(src,temp,NULL);  
                double value=cvGetReal2D(se, j, i);  
                if(value!=0.0){  
                    Position d;  
                    d.x=center->x-i;  
                    d.y=center->y-j;  
                    if(SEissmooth)  
                        Translation(temp, temp, 0.0, &d,TOFINDMAX);  
                    else  
                        Translation(temp, temp, value, &d,TOFINDMAX);  
                    MaxPix(temp, temp_last, temp_last);  
                }  
            }  
        cvCopy(temp_last, dst, NULL);  
        cvReleaseImage(&temp);  
        cvReleaseImage(&temp_last);  
      
    }  
    //灰度图像腐蚀  
    void Erode_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
        int SEissmooth=isSmooth(se);  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Position centerde;  
        centerde.x=se->width/2;  
        centerde.y=se->height/2;  
        if(center==NULL){  
            center=¢erde;  
        }  
        int sewidth=se->width;  
        int seheight=se->height;  
        cvCopy(src,temp_last,NULL);  
        for(int i=0;i<sewidth;i++)  
            for(int j=0;j<seheight;j++){  
                cvCopy(src,temp,NULL);  
                double value=cvGetReal2D(se, j, i);  
                if(value!=0.0){  
                    Position d;  
                      
                    d.x=i-center->x;  
                    d.y=j-center->y;  
                    if(SEissmooth)  
                        Translation(temp, temp, 0.0, &d,TOFINDMIN);  
                    else  
                        Translation(temp, temp, -1.0*value, &d,TOFINDMIN);  
                    MinPix(temp, temp_last, temp_last);  
                      
                }  
            }  
        cvCopy(temp_last, dst, NULL);  
        cvReleaseImage(&temp);  
        cvReleaseImage(&temp_last);  
          
    }  
    //开操作  
    void Open_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Erode_Gray(src, temp, se, center);  
        Dilate_Gray(temp, temp, se, center);  
        cvCopy(temp, dst, NULL);  
        cvReleaseImage(&temp);  
      
    }  
    //闭操作  
    void Close_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Dilate_Gray(src, temp, se, center);  
        Erode_Gray(temp, temp, se, center);  
        cvCopy(temp, dst, NULL);  
        cvReleaseImage(&temp);  
          
    }  
    //灰度梯度形态学提取  
    void Gard_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
        IplImage *temp_dilate=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        IplImage *temp_erode=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Dilate_Gray(src, temp_dilate, se, center);  
        Erode_Gray(src, temp_erode, se, center);  
        cvSub(temp_dilate, temp_erode, dst, NULL);  
        cvReleaseImage(&temp_erode);  
        cvReleaseImage(&temp_dilate);  
      
      
    }  
    //顶帽操作  
    void TopHat(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Open_Gray(src, temp, se, center);  
        cvSub( src,temp, dst, NULL);  
        cvReleaseImage(&temp);  
      
    }  
    //底帽操作  
    void BottomHat(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Close_Gray(src, temp, se, center);  
        cvSub(temp,src, dst, NULL);  
        cvReleaseImage(&temp);  
          
    }  
    //测地腐蚀  
    void Erode_Gray_g(IplImage *src,IplImage *ground,IplImage *dst,IplImage *se,Position *center){  
        int SEissmooth=isSmooth(se);  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Position centerde;  
        centerde.x=se->width/2;  
        centerde.y=se->height/2;  
        if(center==NULL){  
            center=¢erde;  
        }  
        int sewidth=se->width;  
        int seheight=se->height;  
        cvCopy(src,temp_last,NULL);  
        for(int i=0;i<sewidth;i++)  
            for(int j=0;j<seheight;j++){  
                cvCopy(src,temp,NULL);  
                double value=cvGetReal2D(se, j, i);  
                if(value!=0.0){  
                    Position d;  
                      
                    d.x=i-center->x;  
                    d.y=j-center->y;  
                    if(SEissmooth)  
                        Translation(temp, temp, 0.0, &d,TOFINDMIN);  
                    else  
                        Translation(temp, temp, -1.0*value, &d,TOFINDMIN);  
                    MinPix(temp, temp_last, temp_last);  
                      
                }  
            }  
        MaxPix(temp_last,ground,temp_last);  
        cvCopy(temp_last, dst, NULL);  
        cvReleaseImage(&temp);  
        cvReleaseImage(&temp_last);  
      
      
    }  
    //测地膨胀  
    void Dilate_Gray_g(IplImage *src,IplImage *ground,IplImage *dst,IplImage *se,Position *center){  
        int SEissmooth=isSmooth(se);  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        Position centerde;  
        centerde.x=se->width/2;  
        centerde.y=se->height/2;  
        if(center==NULL){  
            center=¢erde;  
        }  
        int sewidth=se->width;  
        int seheight=se->height;  
        cvCopy(src,temp_last,NULL);  
        for(int i=0;i<sewidth;i++)  
            for(int j=0;j<seheight;j++){  
                cvCopy(src,temp,NULL);  
                double value=cvGetReal2D(se, j, i);  
                if(value!=0.0){  
                    Position d;  
                    d.x=center->x-i;  
                    d.y=center->y-j;  
                    if(SEissmooth)  
                        Translation(temp, temp, 0.0, &d,TOFINDMAX);  
                    else  
                        Translation(temp, temp, value, &d,TOFINDMAX);  
                    MaxPix(temp, temp_last, temp_last);  
                }  
            }  
        MinPix(temp_last, ground, temp_last);  
        cvCopy(temp_last, dst, NULL);  
        cvReleaseImage(&temp);  
        cvReleaseImage(&temp_last);  
    }  
    //重建开操作  
    void Rebuild_Open(IplImage *src,IplImage *dst,IplImage *ground,IplImage *erodeSE,IplImage *dilateSE,int eroden){  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        cvCopy(src, temp, NULL);  
        for(int i=0;i<eroden;i++){  
            Erode_Gray(temp, temp, erodeSE, NULL);  
        }  
          
        while(!isEqu(temp, temp_last)){  
            cvCopy(temp, temp_last, NULL);  
            Dilate_Gray_g(temp, ground, temp, dilateSE, NULL);  
              
        }  
        cvCopy(temp, dst, NULL);  
        cvReleaseImage(&temp);  
        cvReleaseImage(&temp_last);  
          
    }  
    //重建闭操作，这段没测试  
    void Rebuild_Close(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int dilaten){  
        IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
        cvCopy(src, temp, NULL);  
        for(int i=0;i<dilaten;i++){  
            Dilate_Gray(temp, temp, dilateSE, NULL);  
        }  
          
        while(!isEqu(temp, temp_last)){  
            cvCopy(temp, temp_last, NULL);  
            Erode_Gray(temp, temp, erodeSE, NULL);  
            MinPix(temp, ground, temp);  
              
        }  
        cvCopy(temp, dst, NULL);  
        cvReleaseImage(&temp);  
        cvReleaseImage(&temp_last);  
          
    }  
    //重建顶帽操作  
    void Rebuild_Tophat(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int eroden){  
        Rebuild_Open(src,dst,ground,erodeSE,dilateSE,eroden);  
        cvSub(src, dst, dst, NULL);  
      
    }  
    //重建底帽操作  
    void Rebuild_Bottomhat(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int dilaten){  
        Rebuild_Close(src,dst,ground,dilateSE,erodeSE,dilaten);  
        cvSub(src, dst, dst, NULL);  
          
    }  
    int main(){  
          
        return 1;  
      
    }  


结果图片：
       以下结果原图为lena 512x512的图像产生：
腐蚀：

膨胀：

开操作：

闭操作：

顶帽操作：

底帽操作：



重建操作示意（冈萨雷斯 中文第三版 P437）：
去除横向亮条：重建顶帽操作

重建开操作，去除纵向亮纹：

上图横向膨胀：

膨胀结果与重建顶帽操作的最小操作：

原图对比：

代码

[cpp] view plain copy

1. #include <cv.h>  
2. #include <highgui.h>  
3. #include <stdio.h>  
4. #define TOFINDMAX 0  
5. #define TOFINDMIN 1  
6. #define isSIZEEQU(x,y) (((x)->width)==((y)->width)&&((x)->height)==((y)->height))  
7. struct position{  
8.     int x;  
9.     int y;  
10. };  
11. typedef struct position Position;  
12. //判断结构元是否平滑  
13. int isSmooth(IplImage *src){  
14.     int width=src->width;  
15.     int height=src->height;  
16.     for(int i=0;i<width;i++)  
17.         for(int j=0;j<height;j++){  
18.             int v=cvGetReal2D(src,j,i);  
19.             if(v!=255.0&&v!=0.0)  
20.                 return 0;  
21.         }  
22.     return 1;  
23. }  
24. //判断两幅图像是否相等  
25. int isEqu(IplImage *src1,IplImage *src2){  
26.     if(!isSIZEEQU(src1, src2))  
27.         return 0;  
28.     for(int i=0;i<src1->width;i++)  
29.         for(int j=0;j<src1->height;j++){  
30.             double v1=cvGetReal2D(src1, j, i);  
31.             double v2=cvGetReal2D(src2, j, i);  
32.             if(v1!=v2)  
33.                 return 0;  
34.         }  
35.     return 1;  
36.   
37. }  
38. //将图像全部设置为1  
39. void One(IplImage *src){  
40.     int width=src->width;  
41.     int height=src->height;  
42.     for(int i=0;i<width;i++)  
43.         for(int j=0;j<height;j++)  
44.             cvSetReal2D(src, j, i, 255.0);  
45.   
46.   
47. }  
48. //位移，如果非平滑SE将加上sevalue，即对应的灰度值  
49. void Translation(IplImage *src ,IplImage *dst,double SEvalue,Position *d,int istoFindMin){  
50.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
51.     int srcwidth=src->width;  
52.     int srcheight=src->height;  
53.     int dstwidth=dst->width;  
54.     int dstheight=dst->height;  
55.     if(istoFindMin)  
56.         One(temp);  
57.     else  
58.         cvZero(temp);  
59.     for(int i=0;i<srcwidth;i++){  
60.         for(int j=0;j<srcheight;j++){  
61.             int target_x=i+d->x;  
62.             int target_y=j+d->y;  
63.             if(target_x>=0&&target_y>=0&&  
64.                target_x<dstwidth&&target_y<dstheight){  
65.                 double value=cvGetReal2D(src, j, i)+SEvalue;  
66.                 value=(value>=255.0?255.0:value);  
67.                 cvSetReal2D(temp, target_y, target_x, value);  
68.             }  
69.         }  
70.     }  
71.     cvCopy(temp, dst, NULL);  
72.       
73.     cvReleaseImage(&temp);  
74. }  
75. //找出两幅等大图像中同一位置中相对较大的像素值  
76. void MaxPix(IplImage *src1 ,IplImage *src2,IplImage *dst){  
77.     if(!isSIZEEQU(src1, src2)||!isSIZEEQU(src1, dst)){  
78.         printf("MaxPix wrong: src size not equ!\n");  
79.         exit(1);  
80.     }  
81.     int width=src1->width;  
82.     int height=src1->height;  
83.     for(int i=0;i<width;i++)  
84.         for(int j=0;j<height;j++){  
85.             double value1=cvGetReal2D(src1, j,i);  
86.             double value2=cvGetReal2D(src2, j,i);  
87.             value1>value2?cvSetReal2D(dst, j,i,value1):cvSetReal2D(dst, j, i, value2);  
88.         }  
89.   
90. }  
91. //找出两幅等大图像中同一位置中相对较小的像素值  
92. void MinPix(IplImage *src1 ,IplImage *src2,IplImage *dst){  
93.     if(!isSIZEEQU(src1, src2)||!isSIZEEQU(src1, dst)){  
94.         printf("MaxPix wrong: src size not equ!\n");  
95.         exit(1);  
96.     }  
97.     int width=src1->width;  
98.     int height=src1->height;  
99.     for(int i=0;i<width;i++)  
100.         for(int j=0;j<height;j++){  
101.             double value1=cvGetReal2D(src1, j,i);  
102.             double value2=cvGetReal2D(src2, j,i);  
103.             value1<value2?cvSetReal2D(dst, j, i, value1):cvSetReal2D(dst, j, i, value2);  
104.         }  
105.       
106. }  
107. //灰度图像膨胀  
108. void Dilate_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
109.     int SEissmooth=isSmooth(se);  
110.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
111.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
112.     Position centerde;  
113.     centerde.x=se->width/2;  
114.     centerde.y=se->height/2;  
115.     if(center==NULL){  
116.         center=¢erde;  
117.     }  
118.     int sewidth=se->width;  
119.     int seheight=se->height;  
120.     cvCopy(src,temp_last,NULL);  
121.     for(int i=0;i<sewidth;i++)  
122.         for(int j=0;j<seheight;j++){  
123.             cvCopy(src,temp,NULL);  
124.             double value=cvGetReal2D(se, j, i);  
125.             if(value!=0.0){  
126.                 Position d;  
127.                 d.x=center->x-i;  
128.                 d.y=center->y-j;  
129.                 if(SEissmooth)  
130.                     Translation(temp, temp, 0.0, &d,TOFINDMAX);  
131.                 else  
132.                     Translation(temp, temp, value, &d,TOFINDMAX);  
133.                 MaxPix(temp, temp_last, temp_last);  
134.             }  
135.         }  
136.     cvCopy(temp_last, dst, NULL);  
137.     cvReleaseImage(&temp);  
138.     cvReleaseImage(&temp_last);  
139.   
140. }  
141. //灰度图像腐蚀  
142. void Erode_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
143.     int SEissmooth=isSmooth(se);  
144.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
145.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
146.     Position centerde;  
147.     centerde.x=se->width/2;  
148.     centerde.y=se->height/2;  
149.     if(center==NULL){  
150.         center=¢erde;  
151.     }  
152.     int sewidth=se->width;  
153.     int seheight=se->height;  
154.     cvCopy(src,temp_last,NULL);  
155.     for(int i=0;i<sewidth;i++)  
156.         for(int j=0;j<seheight;j++){  
157.             cvCopy(src,temp,NULL);  
158.             double value=cvGetReal2D(se, j, i);  
159.             if(value!=0.0){  
160.                 Position d;  
161.                   
162.                 d.x=i-center->x;  
163.                 d.y=j-center->y;  
164.                 if(SEissmooth)  
165.                     Translation(temp, temp, 0.0, &d,TOFINDMIN);  
166.                 else  
167.                     Translation(temp, temp, -1.0*value, &d,TOFINDMIN);  
168.                 MinPix(temp, temp_last, temp_last);  
169.                   
170.             }  
171.         }  
172.     cvCopy(temp_last, dst, NULL);  
173.     cvReleaseImage(&temp);  
174.     cvReleaseImage(&temp_last);  
175.       
176. }  
177. //开操作  
178. void Open_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
179.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
180.     Erode_Gray(src, temp, se, center);  
181.     Dilate_Gray(temp, temp, se, center);  
182.     cvCopy(temp, dst, NULL);  
183.     cvReleaseImage(&temp);  
184.   
185. }  
186. //闭操作  
187. void Close_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
188.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
189.     Dilate_Gray(src, temp, se, center);  
190.     Erode_Gray(temp, temp, se, center);  
191.     cvCopy(temp, dst, NULL);  
192.     cvReleaseImage(&temp);  
193.       
194. }  
195. //灰度梯度形态学提取  
196. void Gard_Gray(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
197.     IplImage *temp_dilate=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
198.     IplImage *temp_erode=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
199.     Dilate_Gray(src, temp_dilate, se, center);  
200.     Erode_Gray(src, temp_erode, se, center);  
201.     cvSub(temp_dilate, temp_erode, dst, NULL);  
202.     cvReleaseImage(&temp_erode);  
203.     cvReleaseImage(&temp_dilate);  
204.   
205.   
206. }  
207. //顶帽操作  
208. void TopHat(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
209.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
210.     Open_Gray(src, temp, se, center);  
211.     cvSub( src,temp, dst, NULL);  
212.     cvReleaseImage(&temp);  
213.   
214. }  
215. //底帽操作  
216. void BottomHat(IplImage *src,IplImage *dst,IplImage *se,Position *center){  
217.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
218.     Close_Gray(src, temp, se, center);  
219.     cvSub(temp,src, dst, NULL);  
220.     cvReleaseImage(&temp);  
221.       
222. }  
223. //测地腐蚀  
224. void Erode_Gray_g(IplImage *src,IplImage *ground,IplImage *dst,IplImage *se,Position *center){  
225.     int SEissmooth=isSmooth(se);  
226.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
227.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
228.     Position centerde;  
229.     centerde.x=se->width/2;  
230.     centerde.y=se->height/2;  
231.     if(center==NULL){  
232.         center=¢erde;  
233.     }  
234.     int sewidth=se->width;  
235.     int seheight=se->height;  
236.     cvCopy(src,temp_last,NULL);  
237.     for(int i=0;i<sewidth;i++)  
238.         for(int j=0;j<seheight;j++){  
239.             cvCopy(src,temp,NULL);  
240.             double value=cvGetReal2D(se, j, i);  
241.             if(value!=0.0){  
242.                 Position d;  
243.                   
244.                 d.x=i-center->x;  
245.                 d.y=j-center->y;  
246.                 if(SEissmooth)  
247.                     Translation(temp, temp, 0.0, &d,TOFINDMIN);  
248.                 else  
249.                     Translation(temp, temp, -1.0*value, &d,TOFINDMIN);  
250.                 MinPix(temp, temp_last, temp_last);  
251.                   
252.             }  
253.         }  
254.     MaxPix(temp_last,ground,temp_last);  
255.     cvCopy(temp_last, dst, NULL);  
256.     cvReleaseImage(&temp);  
257.     cvReleaseImage(&temp_last);  
258.   
259.   
260. }  
261. //测地膨胀  
262. void Dilate_Gray_g(IplImage *src,IplImage *ground,IplImage *dst,IplImage *se,Position *center){  
263.     int SEissmooth=isSmooth(se);  
264.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
265.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
266.     Position centerde;  
267.     centerde.x=se->width/2;  
268.     centerde.y=se->height/2;  
269.     if(center==NULL){  
270.         center=¢erde;  
271.     }  
272.     int sewidth=se->width;  
273.     int seheight=se->height;  
274.     cvCopy(src,temp_last,NULL);  
275.     for(int i=0;i<sewidth;i++)  
276.         for(int j=0;j<seheight;j++){  
277.             cvCopy(src,temp,NULL);  
278.             double value=cvGetReal2D(se, j, i);  
279.             if(value!=0.0){  
280.                 Position d;  
281.                 d.x=center->x-i;  
282.                 d.y=center->y-j;  
283.                 if(SEissmooth)  
284.                     Translation(temp, temp, 0.0, &d,TOFINDMAX);  
285.                 else  
286.                     Translation(temp, temp, value, &d,TOFINDMAX);  
287.                 MaxPix(temp, temp_last, temp_last);  
288.             }  
289.         }  
290.     MinPix(temp_last, ground, temp_last);  
291.     cvCopy(temp_last, dst, NULL);  
292.     cvReleaseImage(&temp);  
293.     cvReleaseImage(&temp_last);  
294. }  
295. //重建开操作  
296. void Rebuild_Open(IplImage *src,IplImage *dst,IplImage *ground,IplImage *erodeSE,IplImage *dilateSE,int eroden){  
297.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
298.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
299.     cvCopy(src, temp, NULL);  
300.     for(int i=0;i<eroden;i++){  
301.         Erode_Gray(temp, temp, erodeSE, NULL);  
302.     }  
303.       
304.     while(!isEqu(temp, temp_last)){  
305.         cvCopy(temp, temp_last, NULL);  
306.         Dilate_Gray_g(temp, ground, temp, dilateSE, NULL);  
307.           
308.     }  
309.     cvCopy(temp, dst, NULL);  
310.     cvReleaseImage(&temp);  
311.     cvReleaseImage(&temp_last);  
312.       
313. }  
314. //重建闭操作，这段没测试  
315. void Rebuild_Close(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int dilaten){  
316.     IplImage *temp=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
317.     IplImage *temp_last=cvCreateImage(cvGetSize(src), src->depth, src->nChannels);  
318.     cvCopy(src, temp, NULL);  
319.     for(int i=0;i<dilaten;i++){  
320.         Dilate_Gray(temp, temp, dilateSE, NULL);  
321.     }  
322.       
323.     while(!isEqu(temp, temp_last)){  
324.         cvCopy(temp, temp_last, NULL);  
325.         Erode_Gray(temp, temp, erodeSE, NULL);  
326.         MinPix(temp, ground, temp);  
327.           
328.     }  
329.     cvCopy(temp, dst, NULL);  
330.     cvReleaseImage(&temp);  
331.     cvReleaseImage(&temp_last);  
332.       
333. }  
334. //重建顶帽操作  
335. void Rebuild_Tophat(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int eroden){  
336.     Rebuild_Open(src,dst,ground,erodeSE,dilateSE,eroden);  
337.     cvSub(src, dst, dst, NULL);  
338.   
339. }  
340. //重建底帽操作  
341. void Rebuild_Bottomhat(IplImage *src,IplImage *dst,IplImage *ground,IplImage *dilateSE,IplImage *erodeSE,int dilaten){  
342.     Rebuild_Close(src,dst,ground,dilateSE,erodeSE,dilaten);  
343.     cvSub(src, dst, dst, NULL);  
344.       
345. }  
346. int main(){  
347.       
348.     return 1;  
349.   
350. }  

结果图片：

       以下结果原图为lena 512x512的图像产生：

腐蚀：

膨胀：

开操作：

闭操作：

顶帽操作：

底帽操作：

重建操作示意（冈萨雷斯 中文第三版 P437）：

去除横向亮条：重建顶帽操作

重建开操作，去除纵向亮纹：

上图横向膨胀：

膨胀结果与重建顶帽操作的最小操作：

原图对比：

闭操作是将跨度小于结构元的谷底填平