opencv第六天pro

t图像梯度

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('sudoku.png',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。 下面的代码演示了用于水平Sobel滤波器和结果差异的此过程。

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('box.png',0)
# 1:直接使dtype为cv.CV_8U
sobelx8u = cv.Sobel(img,cv.CV_8U,1,0,ksize=5)

# 2:先使dtype为cv.CV_64F,再取绝对值，再转换为np.uint8
sobelx64f = cv.Sobel(img,cv.CV_64F,1,0,ksize=5)
abs_sobel64f = np.absolute(sobelx64f)# np.absolute/np.abs/abs没啥区别
sobel_8u = np.uint8(abs_sobel64f)

plt.subplot(1,3,1),plt.imshow(img,cmap = 'gray')
plt.title('Original'), plt.xticks([]), plt.yticks([])
plt.subplot(1,3,2),plt.imshow(sobelx8u,cmap = 'gray')
plt.title('Sobel CV_8U'), plt.xticks([]), plt.yticks([])
plt.subplot(1,3,3),plt.imshow(sobel_8u,cmap = 'gray')
plt.title('Sobel abs(CV_64F)'), plt.xticks([]), plt.yticks([])
plt.show()

 

canny边缘检测

 

 

 

 

 

 

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('box.png',0)#0：读取灰度 1：读取彩色 -1：读取完整图（第三维度多1）
edges = cv.Canny(img,100,200)#minval=100,maxval=200,Sobel内核默认为3，L2gradient默认为false即简单公式
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()

 图像金字塔

高斯金字塔

import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('3people.png')
lower_reso=img
for i in range(3):#查看减少四次的每一次的样子
    lower_reso = cv.pyrDown(lower_reso)
    cv.imshow('2', lower_reso)
    cv.waitKey(0)
higher_reso=lower_reso#再查看增加像素后的每一次样子（发现恢复不到原来的样子了）
for i in range(3):
    higher_reso = cv.pyrUp(higher_reso)
    cv.imshow('2', higher_reso)
    cv.waitKey(0)

 

拉普拉斯金字塔 

 

'''请检查其他资源中的第一个参考，它具有图像混合，拉普拉斯金字塔等的完整图解详细信息。只需完成以下步骤即可：

加载苹果和橙子的两个图像
查找苹果和橙子的高斯金字塔（在此示例中， 级别数为6）
在高斯金字塔中，找到其拉普拉斯金字塔
然后在每个拉普拉斯金字塔级别中加入苹果的左半部分和橙子的右半部分
最后从此联合图像金字塔中重建原始图像。
下面是完整的代码。（为简单起见，每个步骤都是单独进行的，这可能会占用更多的内存。如果需要，可以对其进行优化）。'''

import cv2 as cv
import numpy as np,sys
A = cv.imread('apple.png')#记得要是2个相同大小，通道的图，不然后面无法继续
B = cv.imread('orange.png')
# 生成A的高斯金字塔
G = A.copy()
gpA = [G]
for i in range(6):
    G = cv.pyrDown(G)
    gpA.append(G)
# 生成B的高斯金字塔
G = B.copy()
gpB = [G]
for i in range(6):
    G = cv.pyrDown(G)
    gpB.append(G)
# 生成A的拉普拉斯金字塔
lpA = [gpA[5]]
for i in range(5,0,-1):
    GE = cv.pyrUp(gpA[i])
    L = cv.subtract(gpA[i-1],GE)
    lpA.append(L)
# 生成B的拉普拉斯金字塔
lpB = [gpB[5]]
for i in range(5,0,-1):
    GE = cv.pyrUp(gpB[i])
    L = cv.subtract(gpB[i-1],GE)
    lpB.append(L)
# 现在在每个级别中添加左右两半图像
LS = []
for la,lb in zip(lpA,lpB):
    rows,cols,dpt = la.shape
    ls = np.hstack((la[:,0:cols/2], lb[:,cols/2:]))
    LS.append(ls)
# 现在重建
ls_ = LS[0]
for i in range(1,6):
    ls_ = cv.pyrUp(ls_)
    ls_ = cv.add(ls_, LS[i])
# 图像与直接连接的每一半
real = np.hstack((A[:,:cols/2],B[:,cols/2:]))
cv.imwrite('Pyramid_blending2.jpg',ls_)
cv.imwrite('Direct_blending.jpg',real)
##

 轮廓

目标

• 了解轮廓是什么。
• 学习查找轮廓，绘制轮廓等。
• 你将看到以下功能：cv.findContours()，cv.drawContours()

什么是轮廓?

轮廓可以简单地解释为连接具有相同颜色或强度的所有连续点（沿边界）的曲线。轮廓是用于形状分析以及对象检测和识别的有用工具。

• 为了获得更高的准确性，请使用二进制图像。因此，在找到轮廓之前，请应用阈值或canny边缘检测。
• 从OpenCV 3.2开始，findContours()不再修改源图像。
• 在OpenCV中，找到轮廓就像从黑色背景中找到白色物体。因此请记住，要找到的对象应该是白色，背景应该是黑色。

让我们看看如何找到二进制图像的轮廓：

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)
print(contours)

findcontour()函数中有三个参数，第一个是源图像，第二个是轮廓检索模式，第三个是轮廓逼近方法。输出等高线和层次结构。轮廓是图像中所有轮廓的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)
  

注意 最后两种方法相似，但是前进时，您会发现最后一种更有用

 

轮廓近似方法

这是**cv.findContours**函数中的第三个参数。它实际上表示什么？

上面我们告诉我们轮廓是强度相同的形状的边界。它存储形状边界的(x,y)坐标。但是它存储所有坐标吗？这是通过这种轮廓近似方法指定的。

如果传递**cv.CHAIN_APPROX_NONE**，则将存储所有边界点。但是实际上我们需要所有这些要点吗？例如，您找到了一条直线的轮廓。您是否需要线上的所有点来代表该线？不，我们只需要该线的两个端点即可。这就是**cv.CHAIN_APPROX_SIMPLE**所做的。它删除所有冗余点并压缩轮廓，从而节省内存。

下面的矩形图像演示了此技术。只需在轮廓数组中的所有坐标上绘制一个圆（以蓝色绘制）。第一幅图像显示了我用**cv.CHAIN_APPROX_NONE**获得的积分（734个点），第二幅图像显示了我用**cv.CHAIN_APPROX_SIMPLE**获得的效果（只有4个点）。看，它可以节省多少内存！！！