数字图像处理07--数学形态学基本运算

实验环境配置

1. 数学形态学基本运算、基本操作都有哪些？

操作：膨胀与腐蚀

膨胀

A, B为$Z^2$的集合，∅为空集， A被B的膨胀记为A⊕B,⊕为膨胀算子
膨胀的定义为
$$A\oplus B=\{x|[(\hat{B}{)}_{xy}\cap A]\ne \varnothing \}$$

即$\hat{B}$原点平移到(x,y)，与A至少有一个非零公共元素

$$A\oplus B=\{x|[(\hat{B}{)}_{xy}\cap A]\subseteq A\}$$
集合B在膨胀操作中通常被称为结构元素

腐蚀

$A,B$是$z^2$的集合A被B腐蚀，记为$A\Theta B$

$$A\Theta B=\{x|(B{)}_x\subseteq A\}$$
A被B的腐蚀的结果为：所有使B被x平移后包
含于A的点x的集合

两者关系

膨胀和腐蚀是关于集合补和反转的对偶，即：
$$(A\Theta B{)}^c=A^c\oplus \hat{B}$$
他们满足

1. 交换性
   $$A\oplus B=B\oplus A$$
2. 结合性
   $$A\oplus (B\oplus C)=(A\oplus B)\oplus C$$
3. 递增性
   $$\begin{gathered} A\subset B\to A\oplus C\subseteq B\oplus c \\ \to A\Theta C\subseteq B\Theta C \end{gathered}$$
4. 分配性
   $$(A\cup B)\oplus C=(A\oplus C)\cup (B\oplus C)$$
   $$(B\cap C)\Theta A=(A\Theta B)\cap (B\Theta C)$$
   $$A\oplus (B\cup C)=(A\oplus B)\cup (A\oplus C)$$
   $$A\Theta (B\cup C)=(A\Theta B)\cap (A\Theta C)$$

运算：击中、不击中、变换、开\闭

开闭

开运算一般能平滑图像的轮廓，削弱狭窄的部分，去掉细的突出。
闭运算也是平滑图像的轮廓，与开运算相反，它一般熔合窄的缺口
和细长的弯口，去掉小洞，填补轮廓上的缝隙。

开运算

设A是原始图像，B是结构元素图像，则集合A被结构元素B作开运算，
记为$A\circ B$，其定义为：
$$A\circ B=(A\Theta B)\oplus B$$
A被B 开运算：A被B腐蚀后的结果再被B膨胀。

A被B的开运算就是B在A内的平移，(保证() ⊆ A)所得到的集合的并
集。开运算可以被描述为拟合过程，即：
$$A\circ B=\cup \{(B{)}_x|(B{)}_x\subseteq A\}$$
(相当于用小球在图形(相当于用小球在图形内部绕一圈，可以绕的图形就是新图形)绕一圈，可以绕的图形就是新图形)
闭运算

设A是原始图像，B是结构元素图像，则集合A被结构元素B 作闭运算，
记为A• B,其定义为：

$$A\bullet B=(A\oplus B)\Theta B$$
A被B开运算：A被B膨胀后的结果再被B腐蚀。

(相当于用小球在图形(相当于用小球在图形内部绕一圈，可以绕的图形就是新图形)绕一圈，可以绕的图形就是新图形)

Hit Miss HMT

目标：是找到一个图形X的位置
三个相关公式
$$A\ast \ast B=(A\Theta X)\cap [A^c\Theta (W-X)]$$
$$A\ast \ast B=(A\Theta B_1)\cap [A^c\Theta B_2]B=(B_1,B_2)B_1=X{B}_2=(W-X)$$
$$A\ast \ast B=(A\Theta B_1)-(A\oplus \widehat{B_2}$$
B1是由与一个对象相联系的B元素构成的集合，
B2是与相应背景有关的B元素的集合

形态学梯度

顶帽
$$原图像-开运算结果$$
往往用来分离比邻近点亮一
些的斑块

黑帽
$$原图像-闭运算结果$$

2.调研所使用编程工具中，数学形态学的基本运算和操作函数及功能分别是什么？

腐蚀

import cv2

cv2.erode(src, kernel, dst=None,
        anchor=None,iterations=None,
        borderType=None, borderValue=None)

# src – 目标图片
# kernel – 进行操作的内核，默认为3×3的矩阵
# iterations – 腐蚀次数，默认为1

进行腐蚀用的，具体原理就是通过和卷积核进行操作，
以0和1为例 ，如果卷积核范围内有一个不是1，那么这点就为0，全是1的话这个点才为1。而且他进行活动后的这个像素并不会影响下一个像素的改变，就是说这个值原本是0，经过操作后变为了1，但是相邻像素进行判断时还是把它当0。

根据卷积核的大小靠近前景的所有像素都会被腐蚀掉（变为 0），景物体会变小，整幅图像的白色区域会减少。这对于去除白噪声很有用，也可以用来断开两个连在一块的物体等。
需要传入

膨胀

import cv2
cv2.dilate(img, kernel, iteration)
# img – 目标图片
# kernel – 进行操作的内核，默认为3×3的矩阵
# iterations – 膨胀次数，默认为1

将前景物体变大，理解成将图像断开裂缝变小（在图片上画上黑色印记，印记越来越小）
所以这个操作会增加图像中的白色区域
原理和上面内容一样，只不过规则编程有一个点是1就设定为1，反之设定为0

开闭运算

import cv2
cv2.morphologyEx(img, op, kernel) 
# img 传入的图片
# op 是操作方式
#   op = cv2.MORPH_OPEN 进行开运算，指的是先进行腐蚀操作，再进行膨胀操作
#   op = cv2.MORPH_CLOSE 进行闭运算， 指的是先进行膨胀操作，再进行腐蚀操作 
#   op = cv2.MORPH_TOPHAT 顶帽运算
#   op = cv2.MORPH_BLAKCHAT 黑帽运算
#   op = cv2.MORPH_GRADIENT 梯度运算 提取物体边缘
# kernal 同上

3.尝试设计3种不同的结构算子，对图像进行基本的操作，并观察结果

库函数有自带算子

   cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) 
   #这个函数的第一个参数表示内核的形状，有三种形状可以选择。第二个参数代表矩阵大小
        kernel1 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) 
        #矩形：MORPH_RECT;
        #交叉形：MORPH_CROSS;
        kernel2 = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
        kernel3 = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
        #椭圆形：MORPH_ELLIPSE;

也可以自己设计算子函数进行计算

kernel11 = np.uint8(np.ones((3,3)))
kernel12 = np.uint8(np.array([
            [0,1,0],
            [1,1,1],
            [0,1,0]
        ]))
kernel13 = np.uint8(np.array([
            [0,0,1],
            [0,1,0],
            [1,0,0]
        ]))

使用自带函数的膨胀效果

左上 原图 右上 kernel1 左下 kernel2 右下 kernel3

自带函数的腐蚀效果

自己设计算子效果

4.实现3种数学形态学算法(04中的方法)，对图像进行处理，并查看结果

边缘算法

核心代码

res1 = self.gray.copy() - cv2.erode(self.gray.copy(), kernel_edge)
res2 = cv2.erode(self.gray.copy(), kernel_edge) -self.gray.copy() 

迭代次数为1

迭代次数为2

细化算法

# 将图像二值化后使用库函数
 res = cv2.ximgproc.thinning(bin, thinningType = cv2.ximgproc.THINNING_ZHANGSUEN)

填充算法

c = (t1 != t2)
   while(c.any()):
      print('1')
      t1 = t2
      t2 = cv2.dilate(t1, kernel2) & (~A)
      c = (t1 != t2)
   res = t2 | A

最后输出对比

5.附录

import cv2
import numpy as np

class math_morphology():
    def __init__(self, img : np) -> None:
        self.origin = img
        
        self.gray = cv2.cvtColor(self.origin, cv2.COLOR_RGB2GRAY)
    def test03(self):
        
        #这个函数的第一个参数表示内核的形状，有三种形状可以选择。
        kernel1 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) 
        #矩形：MORPH_RECT;
        kernel11 = np.uint8(np.ones((3,3)))
        
        #交叉形：MORPH_CROSS;
        kernel2 = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
        kernel12 = np.uint8(np.array([
            [0,1,0],
            [1,1,1],
            [0,1,0]
        ]))
        
        kernel3 = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
        #椭圆形：MORPH_ELLIPSE;
        kernel13 = np.uint8(np.array([
            [0,0,1],
            [0,1,0],
            [1,0,0]
        ]))
        erode1 = cv2.erode(self.gray.copy(), kernel11,iterations= 3)
        erode2 = cv2.erode(self.gray.copy(), kernel12,iterations= 3)
        erode3 = cv2.erode(self.gray.copy(), kernel13,iterations= 3)
        cv2.imshow('gray',self.gray)
        cv2.imshow('1',erode1)
        cv2.imshow('2',erode2)
        cv2.imshow('3',erode3)
        cv2.waitKey(0)

        dilate1 = cv2.dilate(self.gray.copy(), kernel11,iterations= 3)
        dilate2 = cv2.dilate(self.gray.copy(), kernel12,iterations= 3)
        dilate3 = cv2.dilate(self.gray.copy(), kernel13,iterations= 3)
        cv2.imshow('gray',self.gray)
        cv2.imshow('1',dilate1)
        cv2.imshow('2',dilate2)
        cv2.imshow('3',dilate3)
        cv2.waitKey(0)
    def test04_edge(self):
        ## 提取边缘
        kernel_edge = np.uint8(np.array([
            [1,1,1,1,1],
            [1,1,1,1,1],
            [1,1,1,1,1],
            [1,1,1,1,1],
            [1,1,1,1,1]
        ]))

        res1 = self.gray.copy() - cv2.erode(self.gray.copy(), kernel_edge, iterations= 1)
        res2 = cv2.erode(self.gray.copy(), kernel_edge,iterations= 1) -self.gray.copy() 
        res3= self.gray.copy() - cv2.dilate(self.gray.copy(), kernel_edge,iterations= 1)
        res4 =  cv2.dilate(self.gray.copy(), kernel_edge,iterations= 1) - self.gray.copy()
        
        cv2.imshow('res1',res1)
        cv2.imshow('res2',res2)
        cv2.imshow('res3',res3)
        cv2.imshow('res4',res4)
        cv2.waitKey(0)

    def test04_thin(self):
        ## 细化
        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3,3))
        ret, bin = cv2.threshold(self.gray.copy(), 128, 255, cv2.THRESH_BINARY_INV)

        bin = cv2.erode(bin, kernel)
        bin = cv2.dilate(bin, kernel)
        res = cv2.ximgproc.thinning(bin, thinningType = cv2.ximgproc.THINNING_ZHANGSUEN)
        cv2.imshow('bin',bin)
        cv2.imshow('bone', res)
        cv2.waitKey(0)

    def test04_fill(self):
        kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
        kernel2 = np.uint8([
            [0,1,0],
            [1,1,1],
            [0,1,0]
        ])

        ret, A = cv2.threshold(self.gray.copy(), 128, 255, cv2.THRESH_BINARY_INV)
        t1 = np.zeros_like(self.gray)
        t2 = np.zeros_like(self.gray)
        t2[50,50] = 255
        c = (t1 != t2)
        while(c.any()):
            print('1')
            t1 = t2
            t2 = cv2.dilate(t1, kernel2) & (~A)
            c = (t1 != t2)
        res = t2 | A
        cv2.imshow('gray',A)
        cv2.imshow('res',res)
        cv2.waitKey(0)
    

    def show(self):
        cv2.imshow(',',self.origin)
        cv2.imshow(',,',self.gray)
        cv2.waitKey(0)

img1 = math_morphology(cv2.imread('work08/pic4.png'))
#img1.test03()
img1.test04_edge()
# img1.test04_bone()


img2 = math_morphology(cv2.imread('work08/pic3.png'))
#img2.test04_edge()
#img2.test04_thin()

img4 = math_morphology(cv2.imread('work08/pic1.png'))
img4.test04_fill()