【OpenCV】Mango的OpenCV学习笔记【五】

本文主要参考自 OpenCV官方文档

一、傅里叶变换

傅立叶变换用于分析各种滤波器的频率特性。对于图像，使用 2D离散傅里叶变换(DFT) 查找频域。一种称为 快速傅立叶变换(FFT) 的快速算法用于DFT的计算。

对于正弦信号 $x(t)=A\sin (2\pi ft)$ 我们可以说f是信号的频率，如果采用其频域，则可以看到 $f$
的尖峰。如果对信号进行采样以形成离散信号，我们将获得相同的频域，但是在 $[-\pi ，\pi ]$ 或 $[0,2\pi ]$ 范围内（对于N点DFT为$[0，N]$）是周期性的。可以将图像视为在两个方向上采样的信号。因此，在 X 和 Y 方向都进行傅立叶变换，可以得到图像的频率表示。

更直观地说，对于正弦信号，如果幅度在短时间内变化如此之快，则可以说它是高频信号。如果变化缓慢，则为低频信号。您可以将相同的想法扩展到图像。图像中的振幅在哪里急剧变化？在边缘点或噪声。因此，可以说边缘和噪声是图像中的高频内容。如果幅度没有太大变化，则它是低频分量。

1. Numpy中的傅里叶变换（快速傅里叶变换）

   ① np.fft.fft2() 为我们提供了频率转换，它的第一个参数是输入图像，即灰度图像。第二个参数是可选的，它决定输出数组的大小。

   ② 获得结果，零频率分量（DC分量） 将位于左上角。如果要使其居中，则需要在两个方向上将结果都移动 $\frac{N}{2}$ 。只需通过函数 np.fft.fftshift() 即可完成。找到频率变换后，就可以找到幅度谱。

   ③ 频率变换现在，可以在频域中进行一些操作，例如使用高通滤波和重建图像，即找到逆DFT。为此，只需用一个矩形窗口遮罩即可消除低频。然后，使用 np.fft.ifftshift() 进行反向移位，以使 DC分量 再次出现在左上角。然后使用 np.ifft2() 函数找到 逆FFT。同样，结果将是一个复数。您可以采用其绝对值。

   import numpy as np
   import cv2
   import matplotlib.pyplot as plt
   
   img = cv2.imread("../../Resources/Maserati.jpg", 0)
   
   # 1.FFT快速傅里叶变换：空域->频域
   ft = np.fft.fft2(img)
   
   # 2.中心化：将低频信号移动到图像中心
   f_shift = np.fft.fftshift(ft)
   print(np.min(np.abs(f_shift)))  # 绝对最低频率信号
   print(np.max(f_shift), np.min(f_shift))  # 最高频率信号，最低频率信号
   
   # 获取振幅谱，np.log()将其值压缩在[0, 255]之间
   magnitude_spectrum = np.log(np.abs(f_shift))
   print(np.max(magnitude_spectrum), np.min(magnitude_spectrum))
   
   # 3.采用高通滤波进行 去低频、保高频操作
   row, col = img.shape
   f_shift[row // 2 - 30:row // 2 + 30, col // 2 - 30:col // 2 + 30] = 0
   
   # 4.去中心化：将剩余的低频和高频的位置还原
   ft_shift = np.fft.ifftshift(f_shift)
   
   # 5.逆傅里叶变换：频域->空域
   ft_ = np.fft.ifft2(ft_shift)
   
   # 6.二维向量取模（幅值）
   img_back = np.abs(ft_)
   
   # 绘图
   titles = ['Image', 'Magnitude Spectrum', 'Image after HPF', 'Result in JET']
   images = [img, magnitude_spectrum, img_back, img_back]
   
   for i in range(len(images)):
       plt.subplot(2, 2, i + 1)
       if i == 3:
           plt.imshow(images[i])
       else:
           plt.imshow(images[i], cmap='gray')
       plt.title(titles[i])
       plt.xticks([])
       plt.yticks([])
   plt.show()
   

   实现效果图

2. OpenCV中的傅里叶变换（离散傅里叶变换）

   这次我们将删除图像中的高频内容，即我们将LPF应用到图像中，它实际上模糊了图像。为此，我们首先创建一个高值 1 在低频部分，即我们过滤低频内容，0 在高频区。

   import cv2
   import numpy as np
   import matplotlib.pyplot as plt
   
   img = cv2.imread("../../Resources/Maserati.jpg", 0)
   
   # 1.DFT离散傅里叶变换：空域->时域
   dft = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT)  # src为灰度图，并且是numpy.float32类型
   print(dft.shape)
   
   # 2.中心化：将低频移到中心
   dft_shift = np.fft.fftshift(dft)
   
   # 获取振幅谱
   # cv2.magnitude(x, y) 将sqrt(x^2 + y^2) 计算矩阵维度的平方根
   magnitude_spectrum = np.log(cv2.magnitude(dft_shift[:, :, 0], dft_shift[:, :, 1]))
   print(np.max(magnitude_spectrum), np.min(magnitude_spectrum))
   
   # 3.低通滤波，去高频、保低频
   row, col = img.shape
   mask = np.zeros((row, col, 2), dtype=np.uint8)
   mask[row // 2 - 30:row // 2 + 30, col // 2 - 30:col // 2 + 30] = 1
   dft_shift = dft_shift * mask
   
   # 4.去中心化：还原低频和高频位置
   i_dft_shift = np.fft.ifftshift(dft_shift)
   
   # 5.逆傅里叶变换：频域->时域
   i_dft = cv2.idft(i_dft_shift)
   
   # 6.二维向量取模（幅值）
   img_back = cv2.magnitude(i_dft[:, :, 0], i_dft[:, :, 1])
   
   # 绘图
   titles = ['Image', 'Magnitude Spectrum', 'Image after HPF', 'Result in JET']
   images = [img, magnitude_spectrum, img_back, img_back]
   
   for i in range(len(images)):
       plt.subplot(2, 2, i + 1)
       if i == 3:
           plt.imshow(images[i])
       else:
           plt.imshow(images[i], cmap='gray')
       plt.title(titles[i])
       plt.xticks([])
       plt.yticks([])
   plt.show()
   

   实现效果图

二、霍夫变换

1. 霍夫线变换

   一条线可以表示为 $y=mx+c$ 或以参数形式表示为 $\rho =xcos\theta +ysin\theta$，其中 $\rho$ 是从原点到该线的垂直距离，而 $\theta$ 是由该垂直线和水平轴形成的角度以逆时针方向测量（该方向随您如何表示坐标系而变化）
   
   任何一条线都可以用 (ρ，θ) 这两个术语表示。

   1）先定义一个累加器，(ρ，θ) 对应直线，ρ 和 θ 都分别依次增大(根据精度)，计算每对 (ρ，θ) 的投票数。
   其中，ρ 以像素为单位，θ 以弧度为单位。rho 和 theta 是 ρ 和 θ 的精度。

   2）然后，根据 threshold (阈值，最低投票数)来判断是否归为一条直线

   lines = cv2.HoughLines(image, rho, theta, threshold)

   参数:

   image: 单通道的二进制图像

   rho: (ρ，θ) 中 ρ 的精度

   theta: (ρ，θ) 中 θ 的精度

   threshold: 阈值，(ρ，θ) 对应的最低投票数 >= threshold被检测为一条线

   import cv2
   import numpy as np
   
   img = cv2.imread("../../Resources/checkerboard.jpg")
   img = cv2.GaussianBlur(img, (3, 3), 50)
   
   # 1.检测轮廓
   gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
   edges = cv2.Canny(gray, 100, 150)
   
   # 2.投射到Hough空间进行形状检测
   lines = cv2.HoughLines(edges, 1, np.pi / 100, 100)  # 隔1个长度单位的采样，角度
   
   # 画线
   for line in lines:
       rho, theta = line[0]
       a = np.cos(theta)
       b = np.sin(theta)
       x0 = rho * a
       y0 = rho * b
   
       x1 = int(x0 - 1000 * b)  # 直线起点横坐标
       y1 = int(y0 - 1000 * a)  # 直线起点纵坐标
       x2 = int(x0 + 1000 * b)  # 直线终点横坐标
       y2 = int(y0 + 1000 * a)  # 直线终点纵坐标
   
       cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)
   
   cv2.imshow("img", img)
   cv2.waitKey(0)
   

   实现效果图如下

2. 霍夫圆变换

   圆在数学上表示为 (x−xcenter)2+(y−ycenter)2=r2，其中 (xcenter,ycenter) 是圆的中心，r 是圆的半径。从等式中，我们可以看到我们有3个参数，因此我们需要3D累加器进行霍夫变换，这将非常低效。

   circles = cv2.HoughCircles(image, method, dp, minDist, circles=None, param1=None, param2=None, minRadius=None, maxRadius=None)

   参数:
   method：定义检测图像中圆的方法。目前唯一实现的方法是HOUGH_GRADIENT。

   dp：累加器分辨率与图像分辨率的反比。

   dp=1，则累加器与输入图像具有相同的分辨率；dp=2，累加器有一半的宽度和高度。

   minDist：该参数是让算法能明显区分的两个不同圆之间的最小距离。

   param1 ：用于 Canny 的边缘阀值上限，下限被置为上限的一半。

   param2：HOUGH_GRADIENT 方法的累加器阈值(最低投票数)。阈值越小，检测到的圈子越多。

   minRadius ：最小圆半径。

   maxRadius：最大圆半径。

   import cv2
   import numpy as np
   
   img = cv2.imread("../../Resources/shapes.jpg")
   
   # 1.检测轮廓
   gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
   edges = cv2.Canny(gray, 50, 100)
   
   # 2.投射到Hough空间进行形状检测
   circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, 1, 100,
                              param1=10, param2=20, minRadius=20, maxRadius=500)
   
   # 画圆
   if circles is not None:
       circle = np.int_(np.around(circles))
       print(circle[0, :])
       for i in circle[0, :]:
           cv2.circle(img, (i[0], i[1]), i[2], (0, 255, 0), 2)
   
   cv2.imshow('edges', edges)
   cv2.imshow('img', img)
   cv2.waitKey(0)
   cv2.destroyAllWindows()
   

   实现效果如下图

三、分水岭算法

1. 图像分割

   import cv2
   import numpy as np
   import matplotlib.pyplot as plt
   
   img = cv2.imread("../../Resources/water_coins.jpg")
   gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
   
   # 二值化
   ret_0, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
   # cv2.imshow("thresh", thresh)
   # cv2.waitKey(0)
   
   # 去噪
   kernel = np.ones((3, 3), np.uint8)
   opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)
   
   # 确定背景区域
   sure_bg = cv2.dilate(opening, kernel, iterations=3)
   
   # 寻找前景区域
   dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
   ret_1, sure_fg = cv2.threshold(dist_transform, 0.7 * dist_transform.max(), 255, 0)
   
   # 找未知区域
   sure_fg = np.uint8(sure_fg)
   unknown = cv2.subtract(sure_bg, sure_fg)
   
   # cv2.imshow('bg', sure_bg)
   # cv2.imshow('fg', sure_fg)
   # cv2.imshow('unknown', unknown)
   # cv2.waitKey(0)
   
   # 类别标记
   ret_2, markers = cv2.connectedComponents(sure_fg)
   
   # 为所有标记加1，保证背景是0而不是1
   markers = markers + 1
   
   # 让所有未知区域为0
   markers[unknown == 255] = 0
   
   # 分水岭算法
   markers = cv2.watershed(img, markers)
   img[markers == -1] = (0, 0, 255)
   
   cv2.imshow('result', img)
   cv2.waitKey(0)
   cv2.destroyAllWindows()
   

   实现的效果图如下