OpenCV学习之旅
由于这部分实在是太长了，所以只好先发布上半部分，再开始写下半部分~O.o
Chapter 4 OPENCV中的图像处理
4_4 图像平滑
iu女王最近长了痘痘，所以她想通过各种低通滤镜模糊图像OvO
2D卷积（图像过滤）
与一维信号一样，还可以使用各种低通滤波器（LPF)，高通滤波器（HPF）等对图像进行滤波，LPF有助于消除噪声，使图像模糊等。HPF滤波器有助于在图像中找到边缘。
OpenCV提供一个函数cv.filter2D来将内核与图像进行卷积。例如，我们尝试对图像进行平均滤波。则卷积核为5*5，且元素全1的矩阵。
保持该内核在一个像素上，将所有低于这个内核的25个像素相加，取其平均值，然后用新的平均值替换中心像素。
代码如下：
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('opencv_logo.png')
kernel = np.ones((5,5),np.float32)/25
dst = cv.filter2D(img,-1,kernel)
plt.subplot(121),plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(dst),plt.title('Averaging')
plt.xticks([]), plt.yticks([])
plt.show()
结果图：
图像模糊（图像平滑）
通过将图像与低通滤波器内核进行卷积来实现图像模糊。这对于消除噪音很有用。它实际上从图像中消除了高频部分（例如噪声，边缘）。因此，在此操作中边缘有些模糊。（有一些模糊技术也可以不模糊边缘）。OpenCV主要提供四种类型的模糊技术。
1.平均
这是通过将图像与归一化框滤镜进行卷积来完成的。它仅获取内核区域下所有像素的平均值，并替换中心元素。这是通过功能cv.blur()或**cv.boxFilter()完成的**。检查文档以获取有关内核的更多详细信息。我们应该指定内核的宽度和高度。3x3归一化框式过滤器元素全为1/9，代码如下：
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
img = cv.imread('opencv_logo_black.png')
blur = cv.blur(img,(5,5))
plt.subplot(121),plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(blur),plt.title('Blurred')
plt.xticks([]), plt.yticks([])
plt.show()
结果图：
2.高斯模糊
在这种情况下，代替盒式滤波器，使用了高斯核。这是通过功能cv.GaussianBlur() 完成的。我们应指定内核的宽度和高度，该宽度和高度应为正数和奇数。我们还应指定X和Y方向的标准偏差，分别为sigmaX和sigmaY。如果仅指定sigmaX，则将sigmaY与sigmaX相同。如果两个都为零，则根据内核大小进行计算。高斯模糊对于从图像中去除高斯噪声非常有效。
如果需要，可以使用函数cv.getGaussianKernel() 创建高斯内核，代码如下：
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
img = cv.imread('opencv_logo_black.png')
blur = cv.GaussianBlur(img,(5,5),0)
plt.subplot(121),plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(blur),plt.title('Blurred')
plt.xticks([]), plt.yticks([])
plt.show()
结果图：
3.中位模糊
在这里，函数cv.medianBlur() 提取内核区域下所有像素的中值，并将中心元素替换为该中值。这对于消除图像中的椒盐噪声非常有效。有趣的是，在上述过滤器中，中心元素是新计算的值，该值可以是图像中的像素值或新值。但是在中值模糊中，中心元素总是被图像中的某些像素值代替。有效降低噪音。其内核大小应为正奇数整数。
4.双边滤波
cv.bilateralFilter() 在去除噪声的同时保持边缘清晰锐利非常有效。但是，与其他过滤器相比，该操作速度较慢。我们已经看到，高斯滤波器采用像素周围的邻域并找到其高斯加权平均值。高斯滤波器仅是空间的函数，也就是说，滤波时会考虑附近的像素。它不考虑像素是否具有几乎相同的强度。它不考虑像素是否是边缘像素。因此它也模糊了边缘，这是我们不想做的。
双边滤波器在空间中也采用高斯滤波器，但是又有一个高斯滤波器，它是像素差的函数。空间的高斯函数确保仅考虑附近像素的模糊，而强度差的高斯函数确保仅考虑强度与中心像素相似的那些像素的模糊。由于边缘的像素强度变化较大，因此可以保留边缘。
blur = cv.bilateralFilter(img,9,75,75)
4_5 形态转换
鲜为人知，iu不仅是神光圣殿的女王，也是地狱岩宫的主人……，她熟练掌握了不同的形态学操作，例如侵蚀，膨胀，开运算，闭运算……
理论
1.侵蚀
侵蚀的基本思想就像土壤侵蚀一样，它侵蚀前景物体的边界(尽量使前景保持白色)。它是做什么的呢?内核滑动通过图像(在2D卷积中)。原始图像中的一个像素(无论是1还是0)只有当内核下的所有像素都是1时才被认为是1，否则它就会被侵蚀(变成0)。
结果是，根据内核的大小，边界附近的所有像素都会被丢弃。因此，前景物体的厚度或大小减小，或只是图像中的白色区域减小。它有助于去除小的白色噪声(正如我们在颜色空间章节中看到的)，分离两个连接的对象等。
【图像处理】轻松搞懂形态学处理(腐蚀、膨胀、开闭运算) - 知乎 (zhihu.com)
import cv2 as cv
import numpy as np
img = cv.imread('j.png',0)
kernel = np.ones((5,5),np.uint8)
erosion = cv.erode(img,kernel,iterations=1)
cv.imshow('erode', erosion)
cv.waitKey(0)
cv.destroyAllWindows()
结果图：
2.扩张
它与侵蚀正好相反。如果内核下的至少一个像素为“ 1”，则像素元素为“ 1”。因此，它会增加图像中的白色区域或增加前景对象的大小。通常，在消除噪音的情况下，腐蚀后会膨胀。因为腐蚀会消除白噪声，但也会缩小物体。因此，我们对其进行了扩展。由于噪音消失了，它们不会回来，但是我们的目标区域增加了。在连接对象的损坏部分时也很有用。
import cv2 as cv
import numpy as np
img = cv.imread('j.png',0)
kernel = np.ones((5,5),np.uint8)
erosion = cv.dilate(img,kernel,iterations=1)
cv.imshow('dilate', erosion)
cv.waitKey(0)
cv.destroyAllWindows()
结果图：
3.开运算
开放只是侵蚀然后扩张的另一个名称。如上文所述，它对于消除噪音很有用。在这里，我们使用函数cv.morphologyEx()。
import cv2 as cv
import numpy as np
img = cv.imread('j.png',0)
kernel = np.ones((5,5),np.uint8)
opening = cv.morphologyEx(img, cv.MORPH_OPEN, kernel)
cv.imshow('opening', opening)
cv.waitKey(0)
cv.destroyAllWindows()
4.闭运算
闭运算与开运算相反，先扩张然后再侵蚀。在关闭前景对象内部的小孔或对象上的小黑点时很有用。
import cv2 as cv
import numpy as np
img = cv.imread('j.png',0)
kernel = np.ones((5,5),np.uint8)
closing = cv.morphologyEx(img, cv.MORPH_CLOSE, kernel)
cv.imshow('closing', closing)
cv.waitKey(0)
cv.destroyAllWindows()
5.形态学梯度
这是图像扩张和侵蚀之间的区别。
结果将看起来像对象的轮廓。
6. 顶帽
顶帽是输入图像和图像开运算之差。
tophat = cv.morphologyEx(img, cv.MORPH_TOPHAT, kernel)
7.黑帽
黑帽是输入图像和图像闭运算之差。
blackhat = cv.morphologyEx(img, cv.MORPH_BLACKHAT, kernel)
这些形态转换都是基于卷积核的特点进行变换的。
4_6 图像梯度
1. Sobel 和 Scharr 算子
Sobel算子是高斯平滑加微分运算的联合运算，因此它更抗噪声。逆可以指定要采用的导数方向，垂直或水平（分别通过参数yorder和xorder）。逆还可以通过参数ksize指定内核的大小。如果ksize = -1，则使用3x3 Scharr滤波器，比3x3 Sobel滤波器具有更好的结果。请参阅文档以了解所使用的内核。
2. Laplacian算子
它计算了由关系$\Delta=\frac{\partial^2src}{\partial x2}+\frac{\partial2src}{\partial y^2}$给出的图像的拉普拉斯图，它是每一阶导数通过Sobel算子计算。如果ksize=1，然后使用以下内核用于过滤。
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('sudoku.jpg',0)
laplacian = cv.Laplacian(img,cv.CV_64F)
sobelx = cv.Sobel(img,cv.CV_64F,1,0,ksize=5)
sobely = cv.Sobel(img,cv.CV_64F,0,1,ksize=5)
plt.subplot(2,2,1),plt.imshow(img,cmap = 'gray')
plt.title('Original'), plt.xticks([]), plt.yticks([])
plt.subplot(2,2,2),plt.imshow(laplacian,cmap = 'gray')
plt.title('Laplacian'), plt.xticks([]), plt.yticks([])
plt.subplot(2,2,3),plt.imshow(sobelx,cmap = 'gray')
plt.title('Sobel X'), plt.xticks([]), plt.yticks([])
plt.subplot(2,2,4),plt.imshow(sobely,cmap = 'gray')
plt.title('Sobel Y'), plt.xticks([]), plt.yticks([])
plt.show()
结果图：
在我们的示例中，输出数据类型为cv.CV_8U或np.uint8。但这有一个小问题。黑色到白色的过渡被视为正斜率（具有正值），而白色到黑色的过渡被视为负斜率（具有负值）。因此，当您将数据转换为np.uint8时，所有负斜率均设为零。简而言之，您会错过这一边缘信息。如果要检测两个边缘，更好的选择是将输出数据类型保留为更高的形式，例如cv.CV_16S，cv.CV_64F等，取其绝对值，然后转换回cv.CV_8U。
4_7 Canny边缘检测
Canny Edge Detection是一种流行的边缘检测算法，由canny发明，因此，canny也是iu的女王。
边缘检测容易受到图像中的噪声的影响，所以第一步使用5*5高斯滤波器消除图像中的噪声。
非极大值抑制 在获得梯度大小和方向后，将对图像进行全面扫描，以去除可能不构成边缘的所有不需要的像素。
磁滞阈值该阶段确定哪些边缘全部是真正的边缘，哪些不是。为此，我们需要两个阈值minVal和maxVal。强度梯度大于maxVal的任何边缘必定是边缘，而小于minVal的那些边缘必定是非边缘，因此将其丢弃。介于这两个阈值之间的对象根据其连通性被分类为边缘或非边缘。如果将它们连接到“边缘”像素，则将它们视为边缘的一部分。
canny函数的第一个参数是我们的输入图像。第二个和第三个参数分别是我们的minVal和maxVal。第三个参数是perture_size。它是用于查找图像渐变的Sobel内核的大小。默认情况下为3。最后一个参数是L2gradient，它指定用于查找梯度幅度的方程式。如果为True，则使用上面提到的更精确的公式。默认情况下，它为False。
示例代码：
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('messi5.jpg',0)
edges = cv.Canny(img,100,200)
plt.subplot(121),plt.imshow(img,cmap = 'gray')
plt.title('Original Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(edges,cmap = 'gray')
plt.title('Edge Image'), plt.xticks([]), plt.yticks([])
plt.show()
结果图：
4_8 图像金字塔
通常，我们过去使用的是恒定大小的图像。但是在某些情况下，我们需要使用不同分辨率的（相同）图像。例如，当在图像中搜索某些东西（例如人脸）时，我们不确定对象将以多大的尺寸显示在图像中。在这种情况下，我们将需要创建一组具有不同分辨率的相同图像，并在所有图像中搜索对象。这些具有不同分辨率的图像集称为“图像金字塔”（因为当它们堆叠在底部时，最高分辨率的图像位于顶部，最低分辨率的图像位于顶部时，看起来像金字塔）。
有两种图像金字塔。1）高斯金字塔 和2）拉普拉斯金字塔
高斯金字塔中的较高级别（低分辨率）是通过删除较低级别（较高分辨率）图像中的连续行和列而形成的。然后，较高级别的每个像素由基础级别的5个像素的贡献与高斯权重形成。通过这样做，M×N图像变成M/2×N/2图像。因此面积减少到原始面积的四分之一。它称为Octave。当我们在金字塔中越靠上时（即分辨率下降），这种模式就会继续。同样，在扩展时，每个级别的面积变为4倍。我们可以使用cv.pyrDown()和cv.pyrUp()函数找到高斯金字塔。
import cv2 as cv
import numpy as np
img = cv.imread('messi5.jpg')
lower_reso = cv.pyrUp(img)
cv.imshow('pyramid', lower_reso)
cv.waitKey(0)
cv.destroyAllWindows()
金字塔的一种应用是图像融合，可以使图像无缝混合。
4_9_1 OpenCV中的轮廓
轮廓
素胚勾勒出青花笔锋浓转淡，瓶身描绘的牡丹一如你出妆~
轮廓是连接具有相同颜色或强度的所有连续点（沿边界）的曲线。我们一般使用二值图像，为了获得更高的准确率。下列实例代码找到j.png中的轮廓：
import numpy as np
import cv2 as cv
im = cv.imread('j.png')
imgray = cv.cvtColor(im, cv.COLOR_BGR2GRAY)
ret, thresh = cv.threshold(imgray, 127, 255, 0)
contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
findcontours()函数中有三个参数，第一个是源图像，第二个是轮廓检索模式，第三个是轮廓逼近方法。输出等高线和层次结构。轮廓是图像中所有轮廓的Python列表。每个单独的轮廓是一个(x,y)坐标的Numpy数组的边界点的对象。
绘制轮廓
我们可以使用cv.drawContours函数来绘制轮廓，它的第一个参数是源图像，第二个参数是应该作为Python列表传递的轮廓，第三个参数是轮廓的索引（在绘制单个轮廓时有用。要绘制所有轮廓，请传递-1），其余参数是颜色，厚度等等。
-
在图像中绘制所有轮廓：
cv.drawContours(img, contours, -1, (0,255,0), 3) -
绘制单个轮廓，如第四个轮廓：
cv.drawContours(img, contours, 3, (0,255,0), 3) -
但是在大多数情况下，以下方法会很有用：
cnt = contours[4] cv.drawContours(img, [cnt], 0, (0,255,0), 3)
往往最后一种方法更有用。示例代码如下：
import numpy as np
import cv2 as cv
img = cv.imread('j.png')
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
ret, thresh = cv.threshold(gray, 127, 255, 0)
contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
cv.drawContours(img, contours, 0, (0, 255, 0), 3)
cv.imshow('contours', img)
cv.waitKey(0)
cv.destroyAllWindows()
结果图：
轮廓近似方法
cv.findContours函数中的第三个参数代表采样点的个数。传递cv.CHAIN_APPROX_NONE，则将存储所有边界点。当我们找到了一条直线的轮廓，我们不需要线上的所有点来代表该线，我们只需要该线的两个端点即可。这就是cv.CHAIN_APPROX_SIMPLE所做的。它删除所有冗余点并压缩轮廓，从而节省内存。
4_9_2 轮廓特征
1.特征矩
函数cv.moments提供了所有计算出矩值的字典，例如面积，质心等。
import numpy as np
import cv2 as cv
img = cv.imread('j.png',0)
ret,thresh = cv.threshold(img,127,255,0)
contours,hierarchy = cv.findContours(thresh, 1, 2)
cnt = contours[0]
M = cv.moments(cnt)
print(M)
输出如下：
{'m00': 283.0, 'm10': 8260.666666666666, 'm01': 34747.666666666664, 'm20': 251349.8333333333, 'm11': 1008063.0, 'm02': 4274513.166666666, 'm30': 7941981.4, 'm21': 30484543.9, 'm12': 123258620.46666667, 'm03': 526819846.70000005, 'mu20': 10223.989595602674, 'mu11': -6208.702394974302, 'mu02': 8080.874165684916, 'mu30': 8302.495426246896, 'mu21': -14552.154961312423, 'mu12': 11791.528133469663, 'mu03': -3268.923251092434, 'nu20': 0.12765785058625623, 'nu11': -0.07752253611575, 'nu02': 0.10089867729257346, 'nu30': 0.006162296011483629, 'nu21': -0.010800931752771139, 'nu12': 0.008751933371317017, 'nu03': -0.0024262672459139235}
2.轮廓面积
轮廓区域由函数cv.contourArea()或从矩M['m00']中给出。
area = cv.contourArea(cnt)
3.轮廓周长
也称为弧长。可以使用cv.arcLength()函数找到它。第二个参数指定形状是闭合轮廓(True)还是曲线。
perimeter = cv.arcLength(cnt,True)
面积和周长的具体应用见小工具-1那篇博客。
4.轮廓近似
根据我们指定的精度，我们可以将轮廓形状近似为顶点数量较少的其他形状，在这种情况下，第二个参数称为epsilon，它是从轮廓到近似轮廓的最大距离。它是一个精度参数。需要正确选择epsilon才能获得正确的输出。
epsilon = 0.1*cv.arcLength(cnt,True)
approx = cv.approxPolyDP(cnt,epsilon,True)
5.轮廓凸包
凸包外观看起来与轮廓逼近相似，但不相似（在某些情况下两者可能提供相同的结果）。在这里，cv.convexHull()函数检查曲线是否存在凸凹缺陷并对其进行校正。一般而言，凸曲线是始终凸出或至少平坦的曲线。如果在内部凸出，则称为凸度缺陷。例如，检查下面的手的图像。红线显示手的凸包。双向箭头标记显示凸度缺陷，这是凸包与轮廓线之间的局部最大偏差。
- 点*是我们传递到的轮廓。 - *凸包*是输出，通常我们忽略它。 - *顺时针方向：方向标记。如果为True，则输出凸包为顺时针方向。否则，其方向为逆时针方向。 - returnPoints：默认情况下为True。然后返回凸包的坐标。如果为False，则返回与凸包点相对应的轮廓点的索引。
因此，要获得凸包，代码如下：
hull = cv.convexHull(cnt)
6.检查凸度
cv.isContourConvex()具有检查曲线是否凸出的功能。返回True或False。
k = cv.isContourConvex(cnt)
7.边界矩形
直角矩形和旋转矩形。
8.最小闭合圈
使用函数cv.minEnclosingCircle查找对象的圆周。它是一个以最小面积完全覆盖物体的圆。
(x,y),radius = cv.minEnclosingCircle(cnt)
center = (int(x),int(y))
radius = int(radius)
cv.circle(img,center,radius,(0,255,0),2)
9.拟合椭圆
把一个椭圆拟合到一个物体上。
ellipse = cv.fitEllipse(cnt)
cv.ellipse(img,ellipse,(0,255,0),2)
10.拟合直线
将一条直线拟合到一组点。
4_9_3 轮廓属性
1. 长宽比
它是对象边界矩形的宽度与高度的比值。
x,y,w,h = cv.boundingRect(cnt)
aspect_ratio = float(w)/h
2. 范围
范围是轮廓区域与边界矩形区域的比值。
area = cv.contourArea(cnt)
x,y,w,h = cv.boundingRect(cnt)
rect_area = w*h
extent = float(area)/rect_area
3. 坚实度
坚实度是等高线面积与其凸包面积之比。
area = cv.contourArea(cnt)
hull = cv.convexHull(cnt)
hull_area = cv.contourArea(hull)
solidity = float(area)/hull_area
4. 等效直径
等效直径是面积与轮廓面积相同的圆的直径。
area = cv.contourArea(cnt)
equi_diameter = np.sqrt(4*area/np.pi)
5. 取向
取向是物体指向的角度。以下方法还给出了主轴和副轴的长度。
(x,y),(MA,ma),angle = cv.fitEllipse(cnt)
6. 掩码和像素点
在某些情况下，我们可能需要构成该对象的所有点。可以按照以下步骤完成：
mask = np.zeros(imgray.shape,np.uint8)
cv.drawContours(mask,[cnt],0,255,-1)
pixelpoints = np.transpose(np.nonzero(mask))
#pixelpoints = cv.findNonZero(mask)
这里提供了两个方法，一个使用Numpy函数，另一个使用OpenCV函数(最后的注释行)。结果也是一样的，只是略有不同。Numpy给出的坐标是(行、列)格式，而OpenCV给出的坐标是(x,y)格式。所以基本上答案是可以互换的。注意，row = x, column = y。
7. 最大值，最小值和它们的位置
我们可以使用掩码图像找到这些参数。
min_val, max_val, min_loc, max_loc = cv.minMaxLoc(imgray,mask = mask)
8. 平均颜色或平均强度
在这里，我们可以找到对象的平均颜色。或者可以是灰度模式下物体的平均强度。我们再次使用相同的掩码进行此操作。
mean_val = cv.mean(im,mask = mask)
9. 极端点
极点是指对象的最顶部，最底部，最右侧和最左侧的点。
leftmost = tuple(cnt[cnt[:,:,0].argmin()][0])
rightmost = tuple(cnt[cnt[:,:,0].argmax()][0])
topmost = tuple(cnt[cnt[:,:,1].argmin()][0])
bottommost = tuple(cnt[cnt[:,:,1].argmax()][0])
4_9_4 轮廓：更多属性
形状匹配
函数cv.matchShapes()，该函数使我们能够比较两个形状或两个轮廓，并返回一个显示相似性的度量。结果越低，匹配越好。它是根据矩值计算出来的。
import cv2 as cv
import numpy as np
img1 = cv.imread('star.jpg',0)
img2 = cv.imread('star2.jpg',0)
ret, thresh = cv.threshold(img1, 127, 255,0)
ret, thresh2 = cv.threshold(img2, 127, 255,0)
contours,hierarchy = cv.findContours(thresh,2,1)
cnt1 = contours[0]
contours,hierarchy = cv.findContours(thresh2,2,1)
cnt2 = contours[0]
ret = cv.matchShapes(cnt1,cnt2,1,0.0)
print( ret )
4_9_5 轮廓分层
Numpy中的傅里叶变换
当我们使用cv.findcontour()函数在图像中找到轮廓时，我们已经传递了一个参数，轮廓检索模式。我们通常通过了cv.RETR_LIST或cv.RETR_TREE，在输出中，我们得到了三个数组，第一个是图像，第二个是轮廓，还有一个我们命名为hierarchy的输出。
有时对象在不同的位置。但在某些情况下，某些形状在其他形状中。就像嵌套的图形一样。在这种情况下，我们把外部的称为父类，把内部的称为子类。这样，图像中的轮廓就有了一定的相互关系。我们可以指定一个轮廓是如何相互连接的，比如，它是另一个轮廓的子轮廓，还是父轮廓等等。这种关系的表示称为层次结构。
OpenCV中的分级表示
所以每个轮廓都有它自己的信息关于它是什么层次，谁是它的孩子，谁是它的父母等等。OpenCV将它表示为一个包含四个值的数组:[Next, Previous, First_Child, Parent]
“Next表示同一层次的下一个轮廓。”
“Previous表示同一层次上的先前轮廓。”
“First_Child表示它的第一个子轮廓。”
“Parent表示其父轮廓的索引。”
如果没有子元素或父元素，则该字段被视为-1
现在我们已经了解了OpenCV中使用的层次样式，我们可以借助上面给出的相同图像来检查OpenCV中的轮廓检索模式。一些标志如 cv.RETR_LIST, cv.RETR_TREE,cv.RETR_CCOMP, cv.RETR_EXTERNAL等等的含义。
4_11 傅里叶变换
信号与系统课程上已经学习过原理了，这里主要阐述实现。np.fft.fft2()它的第一个参数是输入图像，即灰度图像。第二个参数是可选的，它决定输出数组的大小。如果它大于输入图像的大小，则在计算FFT之前用零填充输入图像。如果小于输入图像，将裁切输入图像。如果未传递任何参数，则输出数组的大小将与输入的大小相同。
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
img = cv.imread('messi5.jpg',0)
f = np.fft.fft2(img)
fshift = np.fft.fftshift(f)
magnitude_spectrum = 20*np.log(np.abs(fshift))
plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()
结果图：
中心区域白色多，低频内容多。
我们可以在频域中进行一些操作，例如高通滤波和重建图像，即找到逆DFT。为此，您只需用尺寸为60x60的矩形窗口遮罩即可消除低频。然后，使用np.fft.ifftshift()应用反向移位，以使DC分量再次出现在左上角。然后使用np.ifft2()函数找到逆FFT。同样，结果将是一个复数。您可以采用其绝对值。
OpenCV中的傅里叶变换
OpenCV为此提供了cv.dft()和cv.idft()函数。它返回与前一个相同的结果，但是有两个通道。第一个通道是结果的实部，第二个通道是结果的虚部。输入图像首先应转换为np.float32。
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('messi5.jpg',0)
dft = cv.dft(np.float32(img),flags = cv.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
magnitude_spectrum = 20*np.log(cv.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))
plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()
4_13 霍夫线变换
霍夫变换用于检测图像中的线条。cv.HoughLines()，cv.HoughLinesP()
原理：线条的极坐标表示。循环检测，投票得分。
OpenCV的霍夫曼变换
opencv提供了cv.HoughLines函数，返回值是$\rho,\theta$，$\rho$以像素为单位，$\theta$以弧度为单位，第一个参数是二进制图像，所以需要经过阈值或者canny进行边缘检测。第二、三个参数是$\rho,\theta$的精度，第四个参数是阈值。
代码如下：
import cv2 as cv
import numpy as np
img = cv.imread(cv.samples.findFile('sudoku.png'))
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
edges = cv.Canny(gray,50,150,apertureSize = 3)
lines = cv.HoughLines(edges,1,np.pi/180,200)
for line in lines:
rho,theta = line[0]
a = np.cos(theta)
b = np.sin(theta)
x0 = a*rho
y0 = b*rho
x1 = int(x0 + 1000*(-b))
y1 = int(y0 + 1000*(a))
x2 = int(x0 - 1000*(-b))
y2 = int(y0 - 1000*(a))
cv.line(img,(x1,y1),(x2,y2),(0,0,255),2)
cv.imwrite('houghlines3.jpg',img)
cv.imshow('houghline', img)
cv.waitKey(0)
cv.destroyAllWindows()
结果图：
概率霍夫变换
概率霍夫变换是我们看到的霍夫变换的优化。它没有考虑所有要点。取而代之的是，它仅采用随机的点子集，足以进行线检测。只是我们必须降低阈值。如下代码：
import cv2 as cv
import numpy as np
img = cv.imread(cv.samples.findFile('sudoku.png'))
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
edges = cv.Canny(gray,50,150,apertureSize = 3)
lines = cv.HoughLinesP(edges,1,np.pi/180,100,minLineLength=100,maxLineGap=10)
for line in lines:
x1,y1,x2,y2 = line[0]
cv.line(img,(x1,y1),(x2,y2),(0,255,0),2)
cv.imwrite('houghlines5.jpg',img)
结果图：
4_15 图像分割与分水岭算法
原理：任何灰度图像都可以看作是一个地形表面，其中高强度表示山峰，低强度表示山谷。你开始用不同颜色的水(标签)填充每个孤立的山谷(局部最小值)。随着水位的上升，根据附近的山峰(坡度)，来自不同山谷的水明显会开始合并，颜色也不同。为了避免这种情况，你要在水融合的地方建造屏障。你继续填满水，建造障碍，直到所有的山峰都在水下。
但是这种方法会由于图像中的噪声或其他不规则性而产生过度分割的结果。因此OpenCV实现了一个基于标记的分水岭算法，你可以指定哪些是要合并的山谷点，哪些不是。这是一个交互式的图像分割。
我们先从寻找硬币的近似估计开始。因此，我们可以使用Otsu的二值化。现在我们需要去除图像中的任何白点噪声。为此，我们可以使用形态学扩张。要去除对象中的任何小孔，我们可以使用形态学侵蚀。
我们需要提取我们可确定为硬币的区域。侵蚀会去除边界像素。因此，无论剩余多少，我们都可以肯定它是硬币。如果物体彼此不接触，那将起作用。但是，由于它们彼此接触，因此另一个好选择是找到距离变换并应用适当的阈值。
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('coins.png')
# 转为灰度
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
# OTSU二值化
ret, thresh = cv.threshold(gray,0,255,cv.THRESH_BINARY_INV+cv.THRESH_OTSU)
# 噪声去除
kernel = np.ones((3,3),np.uint8)
cv.imshow('thresh', thresh)
# 闭运算，先侵蚀后扩张
opening = cv.morphologyEx(thresh,cv.MORPH_OPEN, kernel, iterations = 2)
cv.imshow('opening', opening)
# 确定背景区域
sure_bg = cv.dilate(opening,kernel,iterations=3)
cv.imshow('sure_bg', sure_bg)
# 寻找前景区域
dist_transform = cv.distanceTransform(opening,cv.DIST_L2,5)
ret1, sure_fg = cv.threshold(dist_transform,0.7*dist_transform.max(),255,0)
# 找到未知区域
sure_fg = np.uint8(sure_fg)
unknown = cv.subtract(sure_bg,sure_fg)
cv.imshow('unknown', unknown)
# 类别标记
ret2, markers = cv.connectedComponents(sure_fg)
# 为所有的标记加1，保证背景是0而不是1
markers = markers+1
# 现在让所有的未知区域为0
markers[unknown==255] = 0
markers = cv.watershed(img,markers)
img[markers == -1] = [255,0,0]
cv.imshow('img', img)
cv.waitKey(0)
cv.destroyAllWindows()
结果图：
