opencv联合python5——图像基本操作，图像阈值处理，图像滤波，图像形态学处理，图像梯度处理

图像基本操作

图像采集

#图像基本操作
import numpy as np
import cv2

#cv2.IMREAD_COLOR:彩色图像
#cv2.IMREAD_GRAYSCALE：灰度图像 
def cv_show(name,img):
	#显示图像
	cv2.imshow(name,img)
	#等待时间，单位是毫秒，0表示任意键终止
	cv2.waitKey(0)
	cv2.destroyAllWindows()
#读入图像
img = cv2.imread("D:/6.jpg",cv2.IMREAD_COLOR)
#判断图像是否导入
if img is None:
    print("图像为空")
    exit()
#保存图像
cv2.imwrite("D:/12.jpg",img)
#img.shape 图像大小和类型
print(img.shape)
#图像格式 返回值为 numpy.ndarry
print(img.type)
#图像大小
print(img.size)
#图像类型 返回值为 uint8
print(img.dtype)
cv_show("img",img)

视频采集

#视频读取
import numpy as np
import cv2

#cv2.VideoCapture可以捕获摄像头，用数字来控制不同设备，例如0，1
#如果是视频文件，直接指定好路径即可
vc = cv2.VideoCapture("D:/test.mp4")
#检查是否打开正确 open是一个bool值
if vc.isOpened():
	open,frame = vc.read()
else:
	open = False

while(open):
	ret,frame = vc.read()
	if frame is None:
		break
	if ret==True:
		#图像水平翻转
		frame = cv2.flip(frame,1)
		gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
		cv2.imshow("gray",gray)
		if cv2.waitKey(10)&0xFF==27:
		#if cv2.waitKey(10)& 0xff==ord("q"):
			break
vc.release()
cv2.destroyAllWindows()
#对于一组摄像头可以用以下代码采集图像
success0 = cameraCapture.grab()
success1 = cameraCapture.grab()
if success0 and success1:
	frame0 = cameraCapture0.retrieve()
	frame1 = cameraCapture1.retrieve()

获得图像的基本信息

采集视频图像并保存

import cv2
import numpy as np

def cv_show(name,img):
    cv2.imshow(name,img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

vc = cv2.VideoCapture('D:/test.mp4')
if vc.isOpened():
    open,frame = vc.read()
    w = vc.get(cv2.CAP_PROP_FRAME_WIDTH)
    h = vc.get(cv2.CAP_PROP_FRAME_HEIGHT)
    print(w)
    print(h)
else:
    open = False
index = 0
while(open):
    ret,frame = vc.read()
    if frame is None:
        break
    if ret == True:
        frame = cv2.flip(frame,1)
        gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
        cv2.imwrite("D:/img/" + str(index) + ".jpg", frame)
        index += 1
        if index > 10:
            break
        cv2.imshow('gray',gray)
        if cv2.waitKey(10)&0xFF==ord('q'):
            break
vc.release()
cv2.destroyAllWindows()

截取部分图像数据

#图像基本操作
import numpy as np
import cv2

#截取部分图像数据
def cv_show(name,img):
	cv2.imshow(name,img)
	cv2.waitKey(0)
	cv2.destroyAllWindows()

img = cv2.imread("D:/6.jpg")
plant = cv2.imread("D:/2.jpg")
local = img[0:50,0:200]
#颜色通道提取
b,g,r = cv2.split(img)
#合并颜色通道
img1 = cv2.merge((b,g,r))
#只保留R通道
cur_R = img.copy()
cur_R[:,:,0]=0
cur_R[:,:,1]=0
cv_show("R",cur_R)
#只保留G通道
cur_G = img.copy()
cur_G[:,:,0]=0
cur_G[:,:,2]=0
cv_show("G",cur_G)
#只保留B通道
cur_B = img.copy()
cur_B[:,:,1]=0
cur_B[:,:,2]=0
cv_show("B",cur_B)

边界填充

#边界填充
#填充顺序分别是上下左右,borderType 边界填充方法
top_size,bottom_size,left_size,right_size=(50,50,50,50)
#BORDER_REPLICATE:复制法，复制最边缘像素
#BORDER_REFLECT:反射法：对感兴趣的图像中的像素在两边进行复制
#BORDER_REFLECT_101：反射法，以最边缘像素为轴
#BORDER_WRAP：外包装法
#BORDER_CONSTANT：常量法，常数值填充 valur = 0
replicate = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType = cv2.BORDER_REPLICATE)

数值计算

#数值计算
img3 = img+10  #像素点都+10
img4 = img+img3  #维度相同才能相加，范围（0-255） 对%256取余
cv2.add(img+img3) #越界取255

cv_show("replicate",replicate) 
cv_show("img1",img1)
cv_show("b",b)
cv_show("g",g)
cv_show("r",r)
cv_show("local",local)

图像融合

import numpy as np
import cv2
def cv_show(name,img):
	cv2.imshow(name,img)
	cv2.waitKey(0)
	cv2.destroyAllWindows()
img = cv2.imread("D:/6.jpg")
plant = cv2.imread("D:/4.jpg")

#图像融合  用shape得到的宽高与resize重新定义的宽高正好相反
# 所有要先写315，再写356
plant = cv2.resize(plant,(315,356))
print(img.shape)  #356,315
print(plant.shape)  #356,315
res = cv2.addWeighted(img,0.4,plant,0.6,0)
#按比例对图像进行放大和缩小，设置为（0，0） x轴扩大三倍
res1 = cv2.resize(img,(0,0),fx=3,fy=1)
cv_show("res1",res1)
cv_show("res",res)

import cv2
import numpy as np

def cv_show(name,img):
    cv2.imshow(name,img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
img = cv2.imread('D:/6.jpg')
plant = cv2.imread('D:4.jpg')
if img.shape or plant.shape is None:
    print('could not load the pic..')
    exit()
print(plant.shape)
plant = cv2.resize(plant,(img.shape[1],img.shape[0]))
res = cv2.addWeighted(img,0.4,plant,0.6,0)
res1 = cv2.resize(img,(0,0),fx=4,fy=1)
cv_show('res1',res1)
cv_show('res',res)

图像旋转

#图像旋转
import cv2
import numpy as np

image = cv2.imread("E:/1.jpg")
#ROTATE_90_CLOCKWISE：图像顺时针旋转90度
#ROTATE_180:图像顺时针旋转180度
#ROTATE_90_COUNTERCLOCKWISE:图像顺时针旋转270度
img = cv2.rotate(image,cv2.ROTATE_90_COUNTERCLOCKWISE)
cv2.imshow("image",image)
cv2.imshow("img",img)

cv2.waitKey(0)
cv2.destroyAllWindows()

图像阈值处理

图像阈值

def cv_show(name,img):
	cv2.imshow(name,img)
	cv2.waitKey(0)
	cv2.destroyAllWindows()

img = cv2.imread("D:/6.jpg")
plant = cv2.imread("D:/4.jpg")
#图像阈值
#cv2.THRESH_BINARY 超过阈值部分取最大值，否则取0,即大于127，取255
#cv2.THRESH_BINARY_INV 上面的反转
#cv2.THRESH_TRUNC 大于阈值部分设置为阈值，否则不变，即大于127，取127 
#cv2.THRESH_TOZERO 大于阈值部分不改变，否则为0，即大于127不变
#cv2.THRESH_TOZERO_INV 上面的反转
ret,src = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
cv_show("src",src)

图像对比度增强

#图像对比度增强 src1 = 2*gray+34
src1 = cv2.convertScaleAbs(gray,2,34)

直方图正规化

#直方图正规化
import cv2
import numpy as np

image = cv2.imread("E:/2.jpeg")
Imax = np.max(image)
Imin = np.min(image)
Omin,Omax = 0,255
a = float(Omax-Omin)/(Imax-Imin)
b = Omin - a*Imin
O = a*image+b
O = O.astype(np.uint8)

cv2.imshow("img",image)
cv2.imshow("O",O)
cv2.waitKey(0)
cv2.destroyAllWindows()

伽马变换

import cv2
import numpy as np
#伽马变换，可提高图像亮度，可做美白提亮
image = cv2.imread("E:/2.jpeg")
#图像归一化
fI = image/255.0
#伽马变换
gamma = 0.5
O = np.power(fI,gamma)
cv2.imshow("img",image)
cv2.imshow("O",O)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像滤波

#阈值和平滑处理
import numpy as np
import cv2
def cv_show(image):
	cv2.imshow("image",image)
	cv2.waitKey(0)
	cv2.destroyAllWindows()

img = cv2.imread("D:/6.jpg")
plant = cv2.imread("D:/4.jpg")
#图像平滑
#均值滤波 简单的平均卷积操作
#(3,3)  卷积核，一般设置为基数
blur = cv2.blur(img,(3,3))
#方框滤波 normalize表示是否归一化 True表示进行归一化，即除以9得到均值
#False表示不进行归一化，会发生越界
box = cv2.boxFilter(img,-1,(3,3),normalize=True)
#高斯滤波
#高斯模糊的卷积核里的数值是满足高斯分布的，相当于更重视中间的
aussian = cv2.GaussianBlur(img,(5,5),1)
#中值滤波,相当于用中值代替  5x5 的kernel
median = cv2.medianBlur(img,5)
res= np.hstack((aussian,median))
cv2.imshow("res",res)
cv_show(blur)
cv_show(plant)

图像形态学处理

import numpy as np
import cv2

image = cv2.imread("D:/dige.png")
cv2.imshow("image",image)
kernel = np.ones((3,3),np.uint8)
#腐蚀，去除白色区域 iterations 迭代次数即腐蚀次数
erosion = cv2.erode(image,kernel,iterations=1)
#膨胀，去除黑色区域 iterations 迭代次数即膨胀次数
kernel1 = np.ones((5,5),np.uint8)
dilate = cv2.dilate(erosion,kernel1,iterations=1)
#开操作：先腐蚀，后膨胀，去掉毛刺回复原图
kernel2 = np.ones((11,11),np.uint8)
opening = cv2.morphologyEx(image,cv2.MORPH_OPEN,kernel2)
#闭操作：先膨胀，后腐蚀
closing = cv2.morphologyEx(image,cv2.MORPH_CLOSE,kernel2)
#梯度运算:膨胀的图像减去腐蚀的图像  可以得到轮廓
gradient = cv2.morphologyEx(image,cv2.MORPH_GRADIENT,kernel)
#礼帽：原始图像减去开运算图像  得到毛刺的图像
tophat = cv2.morphologyEx(image,cv2.MORPH_TOPHAT,kernel)
#黑帽：闭运算减去原始输入，去掉毛刺得到原始图像的轮廓
blackhat = cv2.morphologyEx(image,cv2.MORPH_BLACKHAT,kernel2)

res = np.hstack((erosion,dilate,opening))
res1 = np.hstack((tophat,blackhat))
res2 = np.hstack((gradient,closing))
cv2.imshow("res2",res2)
cv2.imshow('res1',res1)
cv2.imshow("res",res)
#cv2.imshow("gradient",gradient)
#cv2.imshow("closing",closing)
cv2.waitKey()
cv2.destroyAllWindows()

图像梯度计算

#图像梯度处理
import numpy as np
import cv2

def cv_show(name,image):
	cv2.imshow(name,image)
	cv2.waitKey(0)
	cv2.destroyAllWindows()


img = cv2.imread("D:/6.jpg")
plant = cv2.imread("D:/4.jpg")
#Sobel算子
#dst = cv2.Sobel(ResourceWarning,ddepth,dx,dy,ksize)
#ddepth:图像的深度,cv2.CV_64F  表示带负数形式，更多范围
#dx和dy分别表示水平和竖直方向
#ksize是Sobel算子的大小
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)  #水平方向是右边减去左边
#白到黑是正数，黑到白是负数，所有的负数会被截断为0，所以要取绝对值
sobelx = cv2.convertScaleAbs(sobelx) #转换取绝对值
sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobely = cv2.convertScaleAbs(sobely)
sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
cv_show('sobelx',sobelx)
cv_show('sobelxy',sobelxy)

#图像梯度处理
import numpy as np
import cv2

def cv_show(name,image):
	cv2.imshow(name,image)
	cv2.waitKey(0)
	cv2.destroyAllWindows()


img = cv2.imread("D:/6.jpg")
plant = cv2.imread("D:/4.jpg")
#scharr算子
scharrx = cv2.Scharr(img,cv2.CV_64F,1,0)
scharry = cv2.Scharr(img,cv2.CV_64F,0,1)
scharrx = cv2.convertScaleAbs(scharrx)
scharry = cv2.convertScaleAbs(scharry)
scharrxy = cv2.addWeighted(scharrx,0.5,scharry,0.5,0)

#laplacian
laplacian = cv2.Laplacian(img,cv2.CV_64F)
laplacian = cv2.convertScaleAbs(laplacian)

res = np.hstack((scharrxy,laplacian))
cv_show("res",res)

投影变换

import cv2
import numpy as np

image = cv2.imread("E:/1.jpg")
h,w,c = image.shape
#原图的四个点与投影变换对应的点
src = np.array([[0,0],[w-1,0],[0,h-1],[w-1,h-1]],np.float32)
dst = np.array([[50,50],[w/3,50],[50,h-1],[w-1,h-1]],np.float32)
print(image.shape)
#计算投影变换矩阵
p = cv2.getPerspectiveTransform(src,dst)
#利用计算出的投影变换矩阵进行投降的投影变换
r= cv2.warpPerspective(image,p,(w,h),borderValue=125)

cv2.imshow("img",image)
cv2.imshow("r",r)
cv2.waitKey(0)
cv2.destroyAllWindows()