python——cv2

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
img=cv.imread("F:\\image\\logo.png",cv.IMREAD_UNCHANGED)    #读取图像cv.IMREAD_UNCHANGED,cv.IMREAD_GRAYSCALE



"""
#第一次课 图像读入 显示与保存
import cv2 as cv
import numpy as np
print("hello")
img=cv.imread("F:\\image\\11.jpg",cv.IMREAD_COLOR)    #读取图像cv.IMREAD_UNCHANGED,cv.IMREAD_GRAYSCALE
cv.imshow("ok",img)     #显示图像
#cv.imwrite('C:\\Users\\shirley\\Desktop\\22.jpg',img)     #保存图像

#第二次课 理论基础 彩色图像是BGR

#第三次课 像素处理 读取象素 修改像素值
#返回值=图像（未知参数）
p=img[88,142]  #读取像素的BGR
print(p)       #输出像素的BGR
blue=img[12,12,0]     #读取该像素点的蓝色通道值
print(blue)   
green=img[12,12,1]
print(green)
red=img[12,12,1]
print(red)
img[12,12]=[1,2,3]     #指定【12，12】像素的三通道颜色
print(img[12,12])
img[12:50,12:50]=[0,0,0]
cv.imshow("ok2",img) 
#retral=cv.waitKey(0)     #图像窗口一直等待
#cv.destroyAllWindows()    #删除所有窗口

#第三次课 使用numpy访问像素
print(img.item(29,29,0))   #彩色通道必须有第三个参数标明通道
img.itemset((29,29,0),0)
print(img.item(17,29,0))

#第四节 获取图像属性
print(img.shape)  #返回（行，列，通道）
print(img.size )    #等于行*列*通道的积
print(img.dtype)  #图像的数据类型 u8

"""

'''
#第五节 感兴趣区域ROI
img=cv.imread("F:\\image\\11.jpg",cv.IMREAD_COLOR)    #读取图像cv.IMREAD_UNCHANGED,cv.IMREAD_GRAYSCALE
cv.imshow("original",img)   #显示原始图像
b=np.ones((50,50,3))      #定义一个矩阵
b=img[100:150,100:150]      #定义一个感兴趣区域
cv.imshow("ROI",b)          
img[0:50,0:50]=b          #用感兴趣区域修改原图  也可以把感兴趣区域放在另一张图上
cv.imshow("modify",img)      #显示修改后的图
cv.waitKey()
cv.destroyAllWindows()

#第六节 通道的拆分与合并  彩色通道BGR
b,g,r=cv.split(img) #将三个通道一块分离出来，每个通道都有一幅图像
cv.imshow("B",b)    #显示通道的图像
cv.imshow("G",g)
cv.imshow("R",r)
b=cv.split(img)[0]    #只分离出蓝色通道的图像，绿色红色同上操作
bgr=cv.merge([b,g,r])   #必须注意三个通道的顺序，否则图像颜色不对
rows,cols,chn=img.shape   #获取图像的行列和通道数
h=np.zeros((rows,cols),img.dtype)    #获取一个零矩阵
'''


'''
#边界填充 
top_size,bottom_size,left_size,right_size = (50,50,50,50)
replicate = cv.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, cv.BORDER_REPLICATE)
reflect = cv.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv.BORDER_REFLECT)
reflect101 = cv.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv.BORDER_REFLECT_101)
wrap = cv.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv.BORDER_WRAP)
constant = cv.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv.BORDER_CONSTANT,value=0)
plt.subplot(231),plt.imshow(img,'gray'),plt.title('original')
plt.subplot(232),plt.imshow(replicate,'gray'),plt.title('replicate')
plt.subplot(233),plt.imshow(reflect,'gray'),plt.title('reflect')
plt.subplot(234),plt.imshow(reflect101,'gray'),plt.title('reflect101')
plt.subplot(235),plt.imshow(wrap,'gray'),plt.title('wrap')
plt.subplot(236),plt.imshow(constant,'gray'),plt.title('constant')
plt.show()
'''



"""
#第七节 图像加法 图像融合
#numpy 加法 若两个像素点相加，对255取余数；opencv加法，直接对两个图像add，若大于 255，则取当前像素值位255；参与运算的图像大小类型必须一致
img2=img
result=img+img2
result2=cv.add(img,img2)
cv.imshow("result",result)
cv.imshow("result2",result2)
#若是用大小不一样的图像无法融合，可以重新规定像素值用函数img2 = cv.reshape(img2,(500,412))

add=cv.addWeighted(img,0.3,img2,0.6,56)    #图像融合，第三个系数为亮度值，融合图像=img*0.3+img2*0.6+56
cv.imshow("add",add)




#第八节类型转换 彩色图像转为灰度等
i=cv.cvtColor(img,cv.COLOR_BGR2RGB)
j=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
cv.imshow("i",i)
cv.imshow("j",j)
cv.waitKey(0)
cv.destroyAllWindows()
"""


'''
#第九节图像缩放 图像翻转
img_suo=cv.resize(img,(122,122))   #四个参数分别为图像，（列，行）
rows,cols,chn=img.shape
img_suo2=cv.resize(img,(round(cols*0.5),round(rows*2.2)))    #是列和行的另一种表示方式
img_suo3=cv.resize(img,None,fx=1.5,fy=0.9)    #缩放的另一种方法，按照比例缩放  ，行缩放的倍数，列缩放的倍数
cv.imshow("img_suo",img_suo)
cv.imshow("img_suo2",img_suo2)
cv.imshow("img_suo3",img_suo3)

img_x=cv.flip(img,0)  #翻转模式为0时以x轴为对称轴,大于0时以y轴为对称轴,小于0时以x轴y轴都翻转一次
img_y=cv.flip(img,1)
img_xy=cv.flip(img,-1)
cv.imshow("img_x",img_x)
cv.imshow("img_y",img_y)
cv.imshow("img_xy",img_xy)
cv.waitKey(0)
cv.destroyAllWindows()
'''


"""
#图像阈值 分为二进制阈值化 ，反二进制阈值化，阶段阈值化，阈值化为0，反阈值化为0
o=cv.imread("F:\\image\\11.jpg" , cv.IMREAD_UNCHANGED)
r,b=cv.threshold(o,128,255,cv.THRESH_BINARY)
r2,b2=cv.threshold(o,128,255,cv.THRESH_BINARY_INV)
r3,b3=cv.threshold(o,128,255,cv.THRESH_TOZERO)
r4,b4=cv.threshold(o,128,255,cv.THRESH_TOZERO_INV)
cv.imshow("b",b)
cv.imshow("b2",b2)
cv.imshow("b3",b3)
cv.imshow("b4",b4)
cv.waitKey(0)
cv.destroyAllWindows()
"""

"""
#均值滤波，方框滤波，高斯滤波，中值滤波，
img1=cv.imread("F:\\image\\lenaNoise.png" , cv.IMREAD_UNCHANGED)
img2=cv.blur(img1,(5,5))  #均值滤波
img3=cv.boxFilter(img1,-1,(5,5),normalize=1)  #方框滤波,归一化处理
img4=cv.boxFilter(img1,-1,(5,5),normalize=0)  #方框滤波,不进行归一化处理，全部溢出255
img5=cv.GaussianBlur(img1,(5,5),0)    #高斯滤波，核中的权重位置不一样,最后一个参数是sigma0
img6=cv.medianBlur(img1,5)    #中值滤波
cv.imshow("original",img1)   
cv.imshow("img2",img2)
cv.imshow("img3",img3)
cv.imshow("img4",img4)
cv.imshow("img5",img5)
cv.imshow("img6",img6)
cv.waitKey(0)
cv.destroyAllWindows()
"""

#图像腐蚀，图像膨胀，开闭运算，梯度运算，礼帽操作，黑帽处理
"""
I1=cv.imread("F:\\image\\lenaNoise.png" , cv.IMREAD_GRAYSCALE)
kernel=np.ones((3,3),np.uint8)
erosion=cv.erode(I1,kernel,iterations=1)  #腐蚀
dilation=cv.dilate(I1,kernel,iterations=1)  #膨胀
opening=cv.morphologyEx(I1,cv.MORPH_OPEN,kernel)    #开运算，先腐蚀后膨胀，去背景中噪声
closing=cv.morphologyEx(I1,cv.MORPH_CLOSE,kernel)     #闭运算，先膨胀后腐蚀，取前景小孔或小黑点
gradient=cv.morphologyEx(I1,cv.MORPH_GRADIENT,kernel)  #梯度运算，膨胀-腐蚀，得到轮廓
tophat=cv.morphologyEx(I1,cv.MORPH_TOPHAT,kernel)  #礼帽运算，原始图像-开运算，得到噪声图像
blackhat=cv.morphologyEx(I1,cv.MORPH_BLACKHAT,kernel)   #黑帽运算,闭运算-原始图像，得到前景中的黑点或小孔
cv.imshow("erosion",erosion)
cv.imshow("dilation",dilation)
cv.imshow("opening",opening)
cv.imshow("closing",closing)
cv.imshow("gradient",gradient)
cv.imshow("tophat",tophat)
cv.imshow("blackhat",blackhat)
cv.waitKey(0)
cv.destroyAllWindows()
"""

#图像梯度，sobel算子（1 2 1）和scharr算子（2 10 3）,拉普拉斯算子
"""
I=cv.imread("F:\\image\\11.jpg" , cv.IMREAD_GRAYSCALE)
#sobel算子，右侧-左侧，下边-上边，出现负数则取绝对值，先计算x方向再计算y方向，后相加
sobelx=cv.Sobel(I,cv.CV_64F,1,0)   #第二个参数为图像深度
sobelx=cv.convertScaleAbs(sobelx)
sobely=cv.Sobel(I,cv.CV_64F,0,1)   #第二个参数为图像深度
sobely=cv.convertScaleAbs(sobely)
sobelxy=cv.addWeighted(sobelx,0.5,sobely,0.5,0)   #=saturate(sobelx*o.5+sobely*0.5+0)
cv.imshow("sobelx",sobelx)
cv.imshow("sobely",sobely)
cv.imshow("sobelxy",sobelxy)

#scharr(改进的sobel)计算更精准，右侧减去左侧，系数梯度更大，
dx=cv.Scharr(I,cv.CV_64F,1,0)   #水平方向，必须确保x和y的和是1，不能同时为1 
dx=cv.convertScaleAbs(dx)
dy=cv.Scharr(I,cv.CV_64F,0,1)   #竖直方向,等价于改进的sobel算法cv.Sobel(I,cv.CV_64F,0,1，-1)
dy=cv.convertScaleAbs(dy)
scharrxy=cv.addWeighted(dx,0.5,dy,0.5,0)
cv.imshow("scharrxy",scharrxy)


#拉普拉斯Laplacian算子，二阶sobel导数，上下左右分别减去中心再相加
I=cv.imread("F:\\image\\11.jpg" , cv.IMREAD_GRAYSCALE)
lap=cv.Laplacian(I,cv.CV_64F)
lap=cv.convertScaleAbs(lap)
cv.imshow("lap",lap)
cv.waitKey(0)
cv.destroyAllWindows()
"""


"""
#canny边缘检测
#1)使用高斯滤波器，以平滑图像，露出噪声。2）计算图像中每个像素点的梯度强度和方向。
#3）应用非极大值一直，以消除边缘检测带来的杂散响应。4）应用双阈值检测来确定真实和潜在的边缘
#5）通过抑制孤立的弱边缘最终完成边缘检测。
img1=cv.imread("F:\\image\\lenaNoise.png" , cv.IMREAD_UNCHANGED)
edges=cv.Canny(img1,50,220)
edges2=cv.Canny(img1,70,240)
cv.imshow("edges",edges)
cv.imshow("edges2",edges2)
"""

"""
#向下取样 向上取样函数,经过向下取样再向上后图像不可恢复，反之也不可复原
o=cv.imread("‪C:\\Users\\shirley\\Desktop\\21.PNG" , cv.IMREAD_UNCHANGED)
pyrdown1=cv.pyrDown(o)
pyrdown2=cv.pyrDown(pyrdown1)
pyrup=cv.pyrUp(pyrdown2)
pyrup2=cv.pyrUp(pyrup)
diff=o-pyrup2   #拉普拉斯金字塔
cv.imshow("o",o)
#cv.imshow("pyrup2",pyrup2)
#cv.imshow("diff",diff)


#图像轮廓，将边缘连接成一个整体，将原始图像备份，opencv默认背景为黑色
o1=cv.imread("F:\\image\\man.bmp" , cv.IMREAD_GRAYSCALE)
ret,binary=cv.threshold(o1,100,255,cv.THRESH_BINARY)
contours,hierarchy=cv.findContours(binary,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)#寻找轮廓信息
co=o.copy()
r=cv.drawContours(co,contours,-1,(0,255,0),4)  #绘制轮廓
cv.imshow("result",r)
cv.waitKey(0)
cv.destroyAllWindows()
"""

#图像轮廓
#为了图像质量，最好使用二值图像或者先进行二值化
#cv.findContours(img,mode,method)
#mode:轮廓检索模式 RETR_EXTERNAL只检索最外面的轮廓 RETR_LIST:检索所有的轮廓，并将他们保存到一个链表当中  RETR_CCOMP:检索所有的轮廓，并将他们组织为两层：顶层是各部分外部边界，第二层是空洞的边界  RETR_TREE:检索所有的轮廓，并重构嵌套轮廓的整个层次
#method:CHAIN_APPROX_NONE:以freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）
#CHAIN_APPROX_SIMPLE：压缩水平的、垂直的和斜的部分，也就是函数只保留他们的终点部分。
'''
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
ret,thresh = cv.threshold(gray,127,255,cv.THRESH_BINARY)
contours,hierarchy = cv.findContours(thresh,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE)
#绘制轮廓
draw_img = img.copy()
res = cv.drawContours(draw_img,contours,-1,(0,255,0),2) #输入原图，轮廓，所有轮廓，轮廓颜色，线条粗细
cv.imshow("res",res)
cv.waitKey(0)
cv.destroyAllWindows()
#边界轮廓做近似，以下为近似的函数，类似于二分法，最大高度差与阈值作比较，小于阈值则可以近似，抑制一般设置周长的多少倍
cnt = contours[0]#找轮廓多的图像
epsilon = 0.15*cv.arcLength(cnt,True)
approx = cv.approxPolyDP(cnt,epsilon,True)
draw_img = img.copy()
res = cv.drawContours(draw_img,[approx],-1,(255,0,0),2)
cv.imshow("res",res)
cv.waitKey(0)
cv.destroyAllWindows()
#外接矩形
x,y,w,h = cv.boundingRect(cnt)
img2 = cv.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
cv.imshow("img2",img2)
cv.waitKey(0)
cv.destroyAllWindows()

area = cv.contourArea(cnt)
rect_area = w * h
extent = float(area) / rect_area
print('轮廓面积与边界矩形面积比',extent)
'''


'''
#模板匹配
template = cv.imread("F:\\image\\face.png",cv.IMREAD_UNCHANGED)
h,w = template.shape[:2]
methods = ['cv.TM_CCOEFF','cv.TM_CCOEFF_NORMED','cv.TM_CCORR',#相关性系数匹配，相关性匹配，平方差匹配
           'cv.TM_CCORR_NORMED','cv.TM_SQDIFF','cv.TM_SQDIFF_NORMED']
for meth in methods:
    img2 = img.copy()
    method = eval(meth)
    print(method)
    res = cv.matchTemplate(img,template,method)
    min_val,max_val,min_loc,max_loc = cv.minMaxLoc(res)
    #如果是平方差匹配sqdiff或归一化平方差匹配sqdiffnormed，取最小值
    if method in [cv.TM_SQDIFF,cv.TM_SQDIFF_NORMED]:
        top_left = min_loc
    else:
        top_left = max_loc
    bottom_right = (top_left[0]+w, top_left[1]+h)
    #画矩形
    cv.rectangle(img2,top_left,bottom_right,255,2)
    plt.subplot(121),plt.imshow(res,cmap='gray')
    plt.xticks([]),plt.yticks([])#隐藏坐标轴
    plt.subplot(122),plt.imshow(img2,cmap='gray')
    plt.xticks([]),plt.yticks([])#隐藏坐标轴
    plt.suptitle(meth)
    plt.show()
'''

"""
#直方图
hist = cv.calcHist([img],[0],None,[256],[0,256])
hist.shape
plt.hist(img.ravel(),256)
plt.show()

color = ('b','g','r')
for i,col in enumerate(color):
    histr = cv.calcHist([img],[i],None,[256],[0,256])
    plt.plot(histr,color = col)
    plt.xlim([0,256])
"""

#直方图主成分
#创建mask
'''
mask = np.zeros(img.shape[:2],np.uint8)
mask[100:400,100:400] = 255

masked_img = cv.bitwise_and(img,img,mask=mask) #与操作

hist_full = cv.calcHist([img],[0],None,[256],[0,256])
hist_mask = cv.calcHist([img],[0],mask,[256],[0,256])

plt.subplot(221),plt.imshow(img,'gray')
plt.subplot(222),plt.imshow(mask,'gray')
plt.subplot(223),plt.imshow(masked_img,'gray')
plt.subplot(224),plt.plot(hist_full),plt.plot(hist_mask)
plt.xlim([0,256])
plt.show()
'''
'''
#直方图均衡化
#本像素个数的概率加上上个像素个数的概率，不断累积，谭厚根据概率*255得到映射后的灰度值
img=cv.imread("F:\\image\\girl.bmp",cv.IMREAD_GRAYSCALE)    #读取图像cv.IMREAD_UNCHANGED,cv.IMREAD_GRAYSCALE
plt.hist(img.ravel(),256)
plt.show()
equ = cv.equalizeHist(img)
plt.hist(equ.ravel(),256)
plt.show()

#自适应直方图均衡化
clahe = cv.createCLAHE(clipLimit=2.0,tileGridSize=(8,8))
res_clahe = clahe.apply(img)
res = np.hstack((equ,res_clahe))
cv.imshow('res',res)
cv.waitKey(0)
cv.destroyAllWindows()
'''


'''
#高通滤波器，应用傅里叶变换和傅里叶逆变换,最后得到的是边界
import matplotlib.pyplot as plt
img1=cv.imread("F:\\image\\lena.bmp" , 0)
f=np.fft.fft2(img1)
fshift=np.fft.fftshift(f)
rows,cols=img1.shape#图片大小
crow,ccol=int(rows/2),int(cols/2) #图片中心
fshift[crow-30:crow+30,ccol-30:ccol+30]=0  #中心为低频，置0，即得到高频的掩膜
ishift=np.fft.ifftshift(fshift) #傅里叶逆变换
iimg=np.fft.ifft2(ishift)
iimg=np.abs(iimg)
plt.subplot(121),plt.imshow(img1,cmap='gray')
plt.title('original'),plt.axis('off')
plt.subplot(122),plt.imshow(iimg,cmap='gray')
plt.title('iimg'),plt.axis('off')
plt.show()
'''

'''
#用cv进行傅里叶变换，低通滤波
img=cv.imread("F:\\image\\lena.bmp" , 0)
img_float32 = np.float32(img)
dft = cv.dft(img_float32,flags = cv.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
rows,cols = img.shape
crow,ccol = int(rows/2),int(cols/2)
#低通滤波
mask = np.zeros((rows,cols,2),np.uint8)
mask[crow-30:crow+30,ccol-30:ccol+30] = 1
#IDFT
fshift = dft_shift*mask
f_ishift = np.fft.ifftshift(fshift)
img_back = cv.idft(f_ishift)
img_back = cv.magnitude(img_back[:,:,0],img_back[:,:,1])
plt.subplot(121),plt.imshow(img,cmap='gray')
plt.title('original'),plt.axis('off')
plt.subplot(122),plt.imshow(img_back,cmap='gray')
plt.title('iimg'),plt.axis('off')
plt.show()
'''
'''
#角点检测
#cv2.cornerHarris()四个参数依次为
#img:数据类型为float32的入图像
#blockSize：角点检测中指定区域的大小
#ksize：Sobel求导中使用的窗口的大小
#k：取值参数为[0.04，0.06]

img = cv.imread("F:\\image\\barbara.bmp" , cv.IMREAD_UNCHANGED)
print(img.shape)
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
gray = np.float32(gray)
dst = cv.cornerHarris(gray,2,3,0.04)
print(dst.shape)
img[dst>0.01*dst.max()] = [0,255,0]
cv.imshow('dst',img)
cv.waitKey(0)
cv.destroyAllWindows()
'''