Day02计算机视觉OpenCv

Jerusalem*

已于 2024-02-02 20:56:30 修改

阅读量244

点赞数 1

文章标签： opencv 人工智能计算机视觉

于 2024-02-02 13:57:14 首次发布

本文链接：https://blog.csdn.net/2205_75881260/article/details/135990616

版权

一、图像平滑

1.均值滤波

#均值滤波：cv2.blur(原始图像名，核的大小）核大小用元组表示（weight，height）
#任何一点的新的像素值都是周围N*N个像素点的值的均值
#针对原始图像内的像素点，逐个采用核（weight*height）进行处理，得到滤波结果图像
#核内每一个像素点所占的比例都相同
#均值滤波得到的图像更加平滑

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/face.png")
cv2.imshow("original",img)

img1=cv2.blur(img,(10,10))#使用五行五列的核进行均值滤波
cv2.imshow("blur",img1)

cv2.waitKey(0)
cv2.destroyAllWindows()

2.方框滤波

#方框滤波：cv2.boxFilter(原始图像，目标图像深度，核大小，normalize属性）
#目标图像深度一般设为-1，表示与原始图像的目标深度统一
#normalize属性：如果为true,就是均值滤波，
# 如果为false，点的像素值为周围核的所有像素点的值的和，很容易发生溢出，一旦饱和就是255（1）

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/face.png")
cv2.imshow("original",img)

#normalize属性为true，相当于均值滤波,1可以省略不写
img1=cv2.boxFilter(img,-1,(5,5),1)
cv2.imshow("boxFilter1",img1)

#normalize属性为false，很可能得到纯白色图像
img2=cv2.boxFilter(img,-1,(10,10),0)
cv2.imshow("boxFilter2",img2)

cv2.waitKey(0)
cv2.destroyAllWindows()

3.高斯滤波

#高斯滤波：cv2.GaussianBlur(原始图像，核大小，sigmaX)
#核的大小必须是奇数。sigmaX是x方向方差，控制权重，一般情况下为0就行
#对周围像素计算加权平均值，临近的像素值具有更高的权重值，自身的权重最大

import cv2
import numpy as p
img=cv2.imread("/Users/macbook/Desktop/beauty.png")
cv2.imshow("original",img)
img1=cv2.GaussianBlur(img,(5,5),0)#高斯滤波
cv2.imshow("GaussianBlur",img1)

cv2.waitKey(0)
cv2.destroyAllWindows()

4.中值滤波

#中值滤波：cv2.medianBlur(原始图像，核的大小）
#核的大小必须是奇数，形式就是int,不是元组
#让周围核中的像素值按照大小排列，取排序像素集中位于中间位置的值作为中值滤波后的像素值
#中值滤波的效果比较好

import cv2
img=cv2.imread("/Users/macbook/Desktop/beauty.png")
cv2.imshow("original",img)

img1=cv2.medianBlur(img,5)
cv2.imshow("medianBlur",img1)

cv2.waitKey(0)
cv2.destroyAllWindows()

二、形态学转换

1.图像腐蚀和图像膨胀

腐蚀和膨胀迭代次数越多，图像效果越明显。

#图像腐蚀：cv2.erode(原始图像，卷积核，迭代次数）
#卷积核：np.ones((weight,height),np.uint8) 白色的、里面的像素值都是1
#迭代次数：进行几次腐蚀，默认情况下为1次腐蚀
#形态学转换主要针对的是二值图像（黑白），腐蚀的一般是白色
#卷积核：腐蚀过程中使用的数组。卷积核的中心点逐个像素点进行移动遍历
# 只有当卷积核中所有像素点对应的元素值均为1时，其值才为1（白），否则值为0（黑），实现了腐蚀


#图像膨胀：cv2.dilate(原始图像，卷积核，迭代次数）
#卷积核：kernel=np.ones((5,5),np.uint8)白色的、像素值全是1。迭代次数默认为1
#主要针对的是二值图像
#图像腐蚀可以去除噪声，但是同时也会压缩图像。对腐蚀过的图像再进行膨胀操作，可以去除噪声，并保持原有形状
#卷积核：卷积核的中心点逐个扫描原始图像  kernel=np.ones((5,5),np.uint8)白色的、像素值全是1
#当卷积核所有像素点对应的值只要有1，其值就设为1（白），否则值为0（黑），实现膨胀操作

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/beauty.png")
#将BGR图像转为灰度图像
img1=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
#将灰度图像转为二值图像
img2=cv2.threshold(img1,128,255,cv2.THRESH_BINARY)#大于阈值为255白，小于阈值为0黑
cv2.imshow("original",img2)

#图像腐蚀：
kernel=np.ones((5,5),np.uint8)
img3=cv2.erode(img2,kernel)#默认腐蚀一次
cv2.imshow("erode",img3)

#图像膨胀
img4=cv2.dilate(img3,kernel)
cv2.imshow("dilate",img4)

cv2.waitKey(0)
cv2.destroyAllWindows()

2.开运算和闭运算

卷积核越大，运算结果越明显

#开运算：cv2.morphologyEx(原始图像，cv2.MORPH_OPEN,kernel)
#cv2.MORPH_OPEN是开运算，kernel是卷积核：np.ones((5,5),np.uint8)
#卷积核如果大一点，开运算的力度会更大一些
#开运算的作用就是不改变图像的原有形状，同时去除噪声。操作对象是二值图像
#图像先进行腐蚀操作，去除噪声，同时图像被压缩；然后图像进行膨胀，图像在去除了噪声的前提下，还会恢复原来形状


#闭运算：先膨胀再腐蚀
#闭运算的作用是有助于关闭前景物体内部的小孔或者物体上的小黑点
#cv2.morphologyEx(原始图像，cv2.MORPH_CLOSE,kernel)
#卷积核的大小可以变大，闭运算的强度更高kernel=np.ones((5,5),np.uint8)


import cv2
import numpy as np
img1=cv2.imread("/Users/macbook/Desktop/beauty.png")
#将BGR图像转换成灰度图像
img2=cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY)
#将灰度图像变成二值图像
img3=cv2.threshold(img2,128,255,cv2.THRESH_BINARY)
cv2.imshow("original",img3)

#开运算
kernel=np.ones((5,5),np.uint8)
result=cv2.morphologyEx(img3,cv2.MORPH_OPEN,kernel)
cv2.imshow("result",result)

#闭运算
result1=cv2.morphologyEx(img3,cv2.MORPH_CLOSE,kernel)
cv2.imshow("result1",result1)

cv2.waitKey(0)
cv2.destroyAllWindows()

3.图像梯度

#梯度运算：cv2.morphology(原始图像，cv2.MORPH_GRADIENT,kernel)
#kernel卷积核 np.ones((5,5),np.uint8)
#针对的是二值图像，得到前景图像的轮廓
#操作：膨胀图像-腐蚀图像，得到的就是前景图像的轮廓图像

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/beauty.png")
#将BGR图像转为灰度图像
img1=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
#将灰度图像转为二值图像
img2=cv2.threshold(img1,128,255,cv2.THRESH_BINARY)#大于阈值为255白，小于阈值为0黑
cv2.imshow("original",img2)

#梯度运算
kernel=np.ones((5,5),np.uint8)
result=cv2.morphologyEx(img2,cv2.MORPH_GRADIENT,kernel)
cv2.imshow("gradient",result)

cv2.waitKey(0)
cv2.destroyAllWindows()

4.礼帽运算和黑帽运算

#图像礼帽（图像顶帽）：cv2.morphologyEx(原始图像，cv2.MORPH_TOPHAT,kernel)
#kernel:卷积核  kernel=np.ones((5,5),np.uint8)
#礼帽运算的结果是：得到噪声图像
#开运算：先腐蚀后膨胀，在保持原图形状不变的情况下去除噪声。
#图像礼帽：原始图像-开运算图像=噪声图像


#图像黑帽：cv2.morphologyEx(原始图像，cv2.MOEPH_BLACKHAT,kernel)
#kernel:卷积核  kernel=np.ones((5,5),np.uint8)
#图像黑帽的结果是：得到前景图像中的小黑点或者图像内部的小孔
#闭运算：先进行膨胀，再进行腐蚀，可以去除前景图像的小黑点或者内部的小孔
#黑帽运算：闭运算图像-原始图像---黑点变成白色，小孔也变成白色

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/beauty.png")
#将BGR图像转为灰度图像
img1=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
#将灰度图像转为二值图像
img2=cv2.threshold(img1,128,255,cv2.THRESH_BINARY)#大于阈值为255白，小于阈值为0黑
cv2.imshow("original",img2)

#礼帽运算
kernel=np.ones((5,5),np.uint8)
result1=cv2.morphologyEx(img2,cv2.MORPH_TOPHAT,kernel)
cv2.imshow("result1",result1)

#黑帽运算
result2=cv2.morphologyEx(img2,cv2.MORPH_BLACKHAT,kernel)
cv2.imshow("result2",result2)

cv2.waitKey(0)
cv2.destroyAllWindows()

三、图像梯度

1.Sobel函数及使用

#sobel函数：cv2.Sobel(scr，ddepth,dx,dy,[ksize])
#ddepth：处理图像的深度  cv2.CV_64F
#在实际操作的时候，计算梯度值可能会出现负数。通常处理的图像是np.uint8类型，
#如果结果也是该类型，所有负数就会被截断为0，发生信息丢失。所以通常使用更高的数据类型cv2.CV_64F,取绝对值后再转换成np.uint8类型
#cv2.convertScaleAbs(scr):将原始图像scr转换成256色位图
#计算x方向上的梯度：dx=1,dy=0;计算y方向上的梯度：dx=0,dy=1
#ksize一般是不用的，默认是3（3行3列）

#计算Sobel结果最好是：分别计算dx和dy后相加
#dx=cv2.Sobel(scr,ddepth,1,0)   dy=cv2.Sobel(scr,ddepth,0,1)
#dst=dx*系数1+dy*系数2（一般来说系数1=系数2=0.5） dst=cv2.addWeihted(dx,alpha,dy,beta,gamma)gamma是修正数


import cv2
import numpy as np
img2=cv2.imread("/Users/macbook/Desktop/beauty.png",cv2.IMREAD_GRAYSCALE)


#Sobel算子求x方向上的梯度
Sobelx=cv2.Sobel(img2,cv2.CV_64F,1,0)#算子的大小默认为3行3列
result_x=cv2.convertScaleAbs(Sobelx)#将原始图像scr转换成256色位

#Sobel算子计算y方向上的梯度
Sobely=cv2.Sobel(img2,cv2.CV_64F,0,1)#算子的大小默认为3行3列
result_y=cv2.convertScaleAbs(Sobely)#将原始图像scr转换成256色位

#计算出最终的Sobel边界的结果：图像融合
result=cv2.addWeighted(result_x,0.5,result_y,0.5,0)#修正值为0
cv2.imshow("result",result)

cv2.waitKey(0)
cv2.destroyAllWindows()

2.scharr算子

#scharr算子在计算梯度的时候精度比sobel算子更高
#cv2.Scharr(原始图像，ddepth,dx,dy)相当于cv2.Sobel(原始图像，ddepth,dx,dy,-1)
#ddpeth:cv2.CV_64F,计算x方向上的梯度：dx=1,dy=0;计算y方向上的梯度：dx=0,dy=1
#cv2.convertScaleAbs(scr):将原始图像scr转换成256色位图

#计算Scharr结果是：分别计算dx和dy后相加
#dx=Scharr(scr,ddepth,1,0)   dy=Scharr(scr,ddepth,0,1)
#dst=dx*系数1+dy*系数2（一般来说系数1=系数2=0.5） dst=cv2.addWeihted(dx,alpha,dy,beta,gamma)gamma是修正数

import cv2
import numpy as np
#转成灰度图片
img=cv2.imread("/Users/macbook/Desktop/beauty.png",cv2.IMREAD_GRAYSCALE)

#计算x方向上的边界
dx=cv2.Scharr(img,cv2.CV_64F,1,0)
dx1=cv2.convertScaleAbs(dx)

#计算y方向上的边界
dy=cv2.Sobel(img,cv2.CV_64F,0,1,-1)#相当于dy=cv2.Scharr(img,cv2.CV_64F,0,1)
dy1=cv2.convertScaleAbs(dy)

#计算最终的Scharr结果:图像融合
result=cv2.addWeighted(dx1,0.5,dy1,0.5,0)
cv2.imshow("result",result)

cv2.waitKey(0)
cv2.destroyAllWindows()

3.Sobel算子和Scharr算子的比较

#相同点：
# Sobel算子和scharr算子的大小一样，计算速度和计算量都是一样的
#不同点：
#Sobel算子的精确度没有Scharr算子高，Scharr算子相当于是Sobel算子的改进版本

4.Laplacian算子

#Laplacian算子：类似于二阶sobel导数
#cv2.Laplacian(scr,ddepth)

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/beauty.png",cv2.IMREAD_GRAYSCALE)

#Laplacian算子
img1=cv2.Laplacian(img,cv2.CV_64F)
result=cv2.convertScaleAbs(img1)#将原始图像scr转换成256色位
cv2.imshow("result",result)

cv2.waitKey(0)
cv2.destroyAllWindows()

四、Canny边缘检测

1.Canny函数及使用

#cv2.Canny(图像，threshold1,threshold2)
#原理：
#threshold1是minval阈值1   threshold2是maxval阈值2
#如果值>maxval，一定是边界；如果值<minval，一定是非边界
#如果minval<值<maxval,如果与已有边界连通在一起就是边界，如果未与已有边界连通就舍弃

#如果想要边界细节丰富一点，阈值设置小一点

import cv2
import numpy as np
#图像转换成灰度图像
img=cv2.imread("/Users/macbook/Desktop/beauty.png",cv2.IMREAD_GRAYSCALE)

#Canny边缘检测
img1=cv2.Canny(img,100,200)#边界信息不够丰富
img2=cv2.Canny(img,64,128)#边界信息比较丰富

cv2.imshow("result1",img1)
cv2.imshow("result2",img2)
cv2.waitKey(0)
cv2.destroyAllWindows()

五、图像金字塔

1.向上取样和向下取样的原理和方法

#图像金字塔：分辨率不同的一组图片
#越位于金字塔的顶部，图片的分辨率越低，像素越少，图片的面积越小。越位于金字塔的底部，图片的像素越多，分辨率越高，图片的面积越大

#向下取样：图片的分辨率逐渐降低，面积逐渐变小的过程
#方法：先对原始图像进行高斯滤波（高斯滤波就是对于周围核来说，临近的像素点的像素值所占的权重比较大）
      #然后再对得到的图像删除所有的偶数行和偶数列，图像的像素点总数就变成原来的1/4，面积变成原来的1/4

#向上取样：图片的分辨率逐渐升高，面积逐渐变大的过程
#方法：在每个方向上扩大为原来的两倍，行数和列数都扩大为原来的两倍。新增的行列都用0来填充
#     使用与向下取样相同的卷积核（与高斯滤波的卷积核相同），将得到的新增点的像素值的结果乘以4，获取“新增像素”的新值

#向上取样和向下取样的操作不是逆操作
# （向下采样会丢失信息）所以先进行向下取样再进行向上取样，得到的图像与原来的图像不一样，会更加模糊。
#  先进行向上取样，在进行向下取样，得到的图像与原来的图像面积一样，但是会更加模糊

2.pyrDown函数与使用

#向下取样：图片的分辨率逐渐降低，面积逐渐变小的过程
#方法：先对原始图像进行高斯滤波（高斯滤波就是对于周围核来说，临近的像素点的像素值所占的权重比较大）
      #然后再对得到的图像删除所有的偶数行和偶数列，图像的像素点总数就变成原来的1/4，面积变成原来的1/4

#cv2.pyrDown(原始图像）

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/beauty.png")
cv2.imshow("original",img)

#向下取样
img1=cv2.pyrDown(img)
cv2.imshow("pyrDown1",img1)

img2=cv2.pyrDown(img1)
cv2.imshow("pyrDown2",img2)

img3=cv2.pyrDown(img2)
cv2.imshow("pyrDown3",img3)

cv2.waitKey(0)
cv2.destroyAllWindows()

3.pyrUp函数及使用

#向上取样：图片的分辨率逐渐升高，面积逐渐变大的过程
#方法：在每个方向上扩大为原来的两倍，行数和列数都扩大为原来的两倍。
# 每一行下面加一行全是0的，每一列右边加一列全是0的，新增的行列都用0来填充
# 使用与向下取样相同的卷积核（与高斯滤波的卷积核相同），将得到的新增点的像素值的结果乘以4，获取“新增像素”的新值

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/beauty.png")
cv2.imshow("original",img)

#向上取样
img1=cv2.pyrUp(img)
cv2.imshow("result1",img1)
img2=cv2.pyrUp(img1)
cv2.imshow("result2",img2)

cv2.waitKey(0)
cv2.destroyAllWindows()

4.拉普拉斯金字塔

#前面介绍的金字塔是高斯金字塔，这里的金字塔是拉普拉斯金字塔
#L=G-PyrUp( PyrDown(G))   L是拉普拉斯金字塔图像，G是原始图像
#拉普拉斯金字塔图像形成：先对原始图像进行向下采样，再对原始图像向上取样得到的结果，原始图像-该结果即为拉普拉斯图像
#拉普拉斯金字塔图像0层：原始图像-原始图像先向下取样一次，再向上取样一次的图像结果
#拉普拉斯金字塔图像1层：向下采样一次的结果-向下采样两次，再进行向上采样一次得到的结果图像
#拉普拉斯金字塔图像2层：向下采样两次的结果-向下取样三次，在进行向上取样一次得到的结果图像，以此类推即可

import cv2
import numpy as np
img=cv2.imread("/Users/macbook/Desktop/face.png")
cv2.imshow("original",img)

#拉普拉斯金字塔0层
img1=cv2.pyrDown(img)#第一次向下采样
img2=cv2.pyrUp(img1)#对第一次向下采样的结果进行第一次向上采样
result0=img-img2
cv2.imshow("result0",result0)

#拉普拉斯金字塔1层
img3=cv2.pyrDown(img1)#两次向下采样的结果
img4=cv2.pyrUp(img3)#两次向下采样后进行一次向上采样
result1=img1-img4
cv2.imshow("result1",result1)

#拉普拉斯金字塔2层
img5=cv2.pyrDown(img3)#三次向下采样的结果
img6=cv2.pyrUp(img5)#三次向下取样后进行一次向上取样的结果
result2=img3-img6
cv2.imshow("result2",result2)

cv2.waitKey(0)
cv2.destroyAllWindows()