#检测opencv插件安装成功否
import cv2 as cv
img=cv.imread(r'D:DeepLearning img.jpg')
cv.namedWindow('Image')
cv.imshow('Image',img)
cv.waitKey(0)
cv.destroyAllWindows()
#1图片读取和展示
import cv2 as cv
img=cv.imread('kst.jpg',1)#0是灰度图像，1是彩色图像
cv.imshow('image',img)#image是窗体的名称，img是展示的图像
cv.waitKey(0)#程序的暂停
#2.图片写入
import cv2 as cv
img=cv.imread('kst.jpg',1)
cv.imwrite('kst2.jpg',img)#name.data
#3.图片质量，100k左右清晰。jpg有损压缩，0时压缩比高，100压缩比低
import cv2 as cv
img=cv.imread('kst.jpg',1)
cv.imwrite('kst3_1.jpg',img,[cv.IMWRITE_JPEG_QUALITY,50])#0-100的有损压缩
#3图片质量：png无损压缩，有图片透明度属性，0时压缩比低，9时压缩比高
import cv2 as cv
img=cv.imread('kst.jpg',1)
cv.imwrite('kst3_2.png',img,[cv.IMWRITE_PNG_COMPRESSION,0])
#4.像素操作
#像素读取
import cv2 as cv
img=cv.imread('kst.jpg',1)
(b,g,r)=img[100,100]#opencv读取像素点值返回元组，bgr
print(b,g,r)
#给图片的【10，100】到【110，100】写入蓝色
#像素写入
for i in range(100):
img[10+i,100]=(255,0,0)#蓝色
cv.imshow('kst.jpg',img)
cv.waitKey(0)
#5.tensorflow操作
import tensorflow as tf
data1=tf.constant(2,dtype=tf.int32)#常量的定义与类型
data2=tf.Variable(10,name='var')#变量的定义与初始值
print(data1)
print(data2)
sess=tf.Session()
print(sess.run(data1))
#变量必须要初始化
init=tf.global_variables_initializer()
sess.run(init)
print(sess.run(data2))
sess.close()
#6常量加减乘除运算
import tensorflow as tf
data1=tf.constant(6)
data2=tf.constant(2)
data_add=tf.add(data1,data2)
data_sub=tf.subtract(data1,data2)
data_mul=tf.multiply(data1,data2)
data_div=tf.divide(data1,data2)
with tf.Session() as sess:
print(sess.run(data_add))
print(sess.run(data_sub))
print(sess.run(data_mul))
print(sess.run(data_div))
print('end')
#6常量与变量加减乘除运算
import tensorflow as tf
data1=tf.constant(6)
data2=tf.Variable(2)
data_add=tf.add(data1,data2)
data_copy=tf.assign(data2,data_add)#将add值赋给data2
data_sub=tf.subtract(data1,data2)
data_mul=tf.multiply(data1,data2)
data_div=tf.divide(data1,data2)
init=tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
print(sess.run(data_add))
print(sess.run(data_sub))
print(sess.run(data_mul))
print(sess.run(data_div))
print('sess.run(data_copy)',sess.run(data_copy))
print('data_copy.eval',data_copy.eval())
print('tf.get_default_session',tf.get_default_session().run(data_copy))
print('end')
#6placeholder
import tensorflow as tf
data1=tf.placeholder(tf.float32)
data2=tf.placeholder(tf.float32)
data_add=tf.add(data1,data2)
with tf.Session() as sess:
print(sess.run(data_add,feed_dict={data1:6,data2:2}))
print('end')
#7矩阵运算
import tensorflow as tf
mat0=tf.constant([[0,1,2],[2,3,4]])
mat1=tf.zeros([2,3])
mat2=tf.ones([3,2])
mat3=tf.fill([3,3],15)
mat4=tf.zeros_like(mat1)#与mat1同纬度的0矩阵
with tf.Session() as sess:
print(sess.run(mat0))
print(sess.run(mat1))
print(sess.run(mat2))
print(sess.run(mat3))
print(sess.run(mat4))
#8.matplotlib
import numpy as np
import matplotlib.pyplot as plt
x=np.array([1,2,3,4,5,6,7,8])
y=np.array([3,4,5,5,6,3,7,9])
#折线图（x,y,color,linewidth)
plt.plot(x,y,'r',lw=10)
#柱状图（x,y,柱子的占比，alpha,color)
plt.bar(x,y,0.8,alpha=1,color='b')
plt.show()
#9.神经网络逼近股票收盘均价
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
endprice=np.array([2511.90,2538.26,2510.68,2591.66,2732.98,2701.69,2701.29,2678.67,2726.50,2681.50,2739.17,2715.07,2823.58,2864.90,2919.08])
beginprice=np.array([2438.71,2500.88,2534.95,2512.52,2594.04,2743.26,2697.47,2695.24,2678.23,2722.13,2674.93,2744.13,2717.46,2832.73,2877.40])
plt.figure()
for i in range(0,15):
dateone=np.zeros([2])
dateone[0]=i
dateone[1]=i
priceone=np.zeros([2])
priceone[0]=beginprice[i]
priceone[1]=endprice[i]
if endprice[i]>beginprice[i]:
plt.plot(dateone,priceone,'r',lw=8)
else:
plt.plot(dateone,priceone,'g',lw=8)
plt.show()
date=np.linspace(1,15,15)
datenormal=np.zeros([15,1])
pricenormal=np.zeros([15,1])
for i in range(15):
#数据归一化
datenormal[i,0]=i/14.0
pricenormal[i,0]=endprice[i]/3000.0
x=tf.placeholder(tf.float32,[None,1])
y=tf.placeholder(tf.float32,[None,1])
#隐藏层
w1=tf.Variable(tf.random_uniform([1,10],0,1))#从0到1的1行10列随机数
b1=tf.Variable(tf.zeros([1,10]))
wb1=tf.matmul(x,w1)+b1
layer1=tf.nn.relu(wb1)
#输出层
w2=tf.Variable(tf.random_uniform([10,1],0,1))#从0到1的1行10列随机数
b2=tf.Variable(tf.zeros([15,1]))
wb2=tf.matmul(layer1,w2)+b2
layer2=tf.nn.relu(wb2)
loss=tf.reduce_mean(tf.square(y-layer2))
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)
init=tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
for i in range(10000):
sess.run(train_step,feed_dict={x:datenormal,y:pricenormal})
pred=sess.run(layer2,feed_dict={x:datenormal})
predprice=np.zeros([15,1])
for i in range(15):
predprice[i,0]=(pred*3000)[i,0]
plt.plot(date,predprice,'b',lw=1)
plt.show()
2.图片特效
#1.图片缩放
import cv2 as cv
img=cv.imread('kst.jpg',1)
imginfo=img.shape
#1.获取图片的长宽通道信息
print(imginfo)
height=imginfo[0]
width=imginfo[1]
deep=imginfo[2]
#2.(非）等比例缩小放大
dstheight=int(height*0.5)
dstwidth=int(width*0.5)
#3.缩放方法：最近邻域插值，双线性插值（默认），像素关系重采样，立方插值
dst=cv.resize(img,(dstwidth,dstheight))
cv.imshow('kstp',dst)
cv.waitKey(0)
#2.图片剪切x:100-200,y:100-300
import cv2 as cv
img=cv.imread('kst.jpg',1)
dst=img[100:200,100:300]
cv.imshow('kstp2',dst)
cv.waitKey(0)
#3.图片移位
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
matshift=np.float32([[1,0,100],[0,1,200]])#2行3列。水平移动100，垂直移动200
dst=cv.warpAffine(img,matshift,(width,height))#1data,2mat,3info
cv.imshow('dst',dst)
cv.waitKey(0)
#4.图片镜像
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
deep=imginfo[2]
newimginfo=(height*2,width,deep)#新图片的info元组信息
dst=np.zeros(newimginfo,np.uint8)#新图片的大小确定
for i in range(height):
for j in range(width):
dst[i,j]=img[i,j]#上半部分不变
#x不变，y=2h-y-1
dst[height*2-i-1,j]=img[i,j]#下半部分
for i in range(width):
dst[height,i]=(0,0,255)
cv.imshow('dst',dst)
cv.waitKey(0)
#5.图片仿射：原始图片的三个点（左上，左下，右上）映射到新的图片上
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
#确定两图片的三个点
matsrc=np.float32([[0,0],[0,height-1],[width-1,0]])
matdst=np.float32([[50,50],[200,height-100],[width-100,50]])
#组合
mataffine=cv.getAffineTransform(matsrc,matdst)#返回仿射矩阵
dst=cv.warpAffine(img,mataffine,(width,height))#新图片的数据，矩阵，大小
cv.imshow('dst',dst)
cv.waitKey(0)
#6.图片旋转
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
#旋转矩阵
matrotate=cv.getRotationMatrix2D((height*0.5,width*0.5),30,0.5)#1center,2angle,3缩放比例
dst=cv.warpAffine(img,matrotate,(width,height))
cv.imshow('dst',dst)
cv.waitKey(0)
#7.图片灰度处理
#方法1：imread
import cv2 as cv
img0=cv.imread('kst.jpg',0)
img1=cv.imread('kst.jpg',1)
print(img0.shape)
print(img1.shape)
#方法2：cvtColor颜色转换
#dst=cv.cvtColor(img,cv.COLOR_BGR2GRAY)#1data,2转换方式
#方法3：R=G=B时是灰度图片，相加取均值
#dst=np.zeros((height,width,3),np.uint8)
#for i in range(height):
# for j in range(width):
# (b,g,r)=img[i,j]
# gray=(int(b)+int(g)+int(r))/3
# dst[i,j]=np.uint8(gray)
#方法4：心理学公式：gray=r*0.299+g*0.587+b*0.114
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
#gray=int(b)*0.114+int(g)*0.587+int(r)*0.299
gray=(int(b)*1+int(g)*2+int(r)*1)/4#定点比浮点运算快
dst[i,j]=np.uint8(gray)
cv.imshow('dst',dst)
cv.waitKey(0)
#8.颜色反转
#8.1灰度反转：255-当前
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
cv.imshow('gray',gray)
dst=np.zeros((height,width,1),np.uint8)
for i in range(height):
for j in range(width):
graypixel=gray[i,j]
dst[i,j]=255-graypixel
cv.imshow('dst',dst)
cv.waitKey(0)
#8.颜色反转
#8.2彩色反转：255-r/g/b=r/g/b
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
dst[i,j]=(255-b,255-g,255-r)
cv.imshow('dst',dst)
cv.waitKey(0)
#9.马赛克效果，每10*10个像素都用左上的像素值代替
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
for m in range(100,300):
for n in range(100,200):
#在200*100的方框内
if m%10==0 and n%10==0:#每10*10的一个小方框内
for i in range(10):
for j in range(10):
(b,g,r)=img[m,n]
img[i+m,j+n]=(b,g,r)
cv.imshow('img',img)
cv.waitKey(0)
#10.毛玻璃效果，每个像素随机取附近像素的值
import cv2 as cv
import numpy as np
import random
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
dst=np.zeros((height,width,3),np.uint8)
mn=8#随机范围不超过8
for m in range(height-mn):
for n in range(width-mn):#防止随机取值溢出
index=int(random.random()*8)#0-8
(b,g,r)=img[m+index,n+index]
dst[m,n]=(b,g,r)
cv.imshow('dst',dst)
cv.waitKey(0)
#11.图片融合:dst=src1*a+src2*(1-a)
import cv2 as cv
import numpy as np
img1=cv.imread('kst.jpg',1)
img2=cv.imread('timg.jpg',1)
imginfo=img2.shape
height=imginfo[0]
width=imginfo[1]
#ROI确定两个图片要融合的图形大小
roiH=int(height/3)
roiW=int(width/3)
img1ROI=img1[0:roiH,0:roiW]
img2ROI=img2[0:roiH,0:roiW]
#dst
dst=np.zeros((roiH,roiW,3),np.uint8)
dst=cv.addWeighted(img1ROI,0.5,img2ROI,0.5,0)#1src1,2a,3src2,41-a,
#show
cv.imshow('dst',dst)
cv.waitKey(0)
#12.图片边缘检测
#12-1.canny边缘检测:1gray,2高斯滤波去除噪声，3canny边缘检测
import cv2 as cv
img=cv.imread('timg.jpg',1)
#1gray
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
#2GAUSS
imgG=cv.GaussianBlur(gray,(3,3),0)
#3canny
dst=cv.Canny(imgG,50,50)#1data，2图片卷积操作值后超过这个门限值就认为是边缘，没超过就不是边缘
#show
cv.imshow('dst',dst)
cv.waitKey(0)
#12.图片边缘检测
#12-2sobel算子：1算子模板，2图片卷积，3阈值判决
# y【1,2,1 x【1，0，-1
# 0,0,0 2，0，-2
# -1,-2,-1】 1，0，-1】
import cv2 as cv
import numpy as np
import math
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
dst=np.zeros((height,width,1),np.uint8)
for i in range(height-2):
for j in range(width-2):
gy=gray[i,j]*1+gray[i,j+1]*2+gray[i,j+2]*1-gray[i+2,j]*1-gray[i+2,j+1]*2-gray[i+2,j+2]*1
gx=gray[i,j]*1-gray[i,j+2]*1+gray[i+1,j]*2-gray[i+1,j+2]*2+gray[i,j+2]*1-gray[i+2,j+2]*1
grad=math.sqrt(gx*gx+gy*gy)
if grad>50:
dst[i,j]=255
else:
dst[i,j]=0
cv.imshow('dst',dst)
cv.waitKey(0)
#13.浮雕效果：new=相邻像素只差（体现边缘像素）+固定值（增强浮雕灰度等级）
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
dst=np.zeros((height,width,1),np.uint8)
for i in range(height):
for j in range(width-1):
grayp0=int(gray[i,j])
grayp1=int(gray[i,j+1])
newp=grayp0-grayp1+150
if newp>255:
newp=255
if newp<0:
newp=0
dst[i,j]=newp
cv.imshow('dst',dst)
cv.waitKey(0)
#14.颜色映射:rgb->>new_rgb
#加深蓝色效果
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
b=b*1.5
g=g*1.3
if b>255:
b=255
if g>255:
g=255
dst[i,j]=(b,g,r)
cv.imshow('dst',dst)
cv.waitKey(0)
#15.油画特效：1gray,2分割成n*n的小方块，3将0-255划分成几个等级，3映射，4统计替代
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
dst=np.zeros((height,width,3),np.uint8)
for i in range(4,height-4):
for j in range(4,width-4):
array1=np.zeros(8,np.uint8)#灰度等级分为8个
for m in range(-4,4):#小方块大小是8*8
for n in range(-4,4):
p1=int(gray[i+m,j+n]/32)#256/8=32，i+m表示行，j+n表示列，表示每行个像素到底属于哪个灰度等级
array1[p1]=array1[p1]+1#给array的8个等级中对应的等级加1
currentMax=array1[0]#先获取0等级的个数
l=0#等级从0开始
for k in range(8):
if currentMax<array1[k]:
currentMax=array1[k]
l=k#获取了当前8*8的小格子中，灰度等级个数最多的等级
for m in range(-4,4):
for n in range(-4,4):
if gray[i+m,j+n]>=(l*32) and gray[i+m,j+n]<=((l+l)*32):#取灰度等级最多的像素
(b,g,r)=img[i+m,j+n]
dst[i,j]=(b,g,r)
cv.imshow('dst',dst)
cv.waitKey(0)
#16.图形绘制
import cv2 as cv
import numpy as np
imginfo=(500,500,3)#height，width,deep
dst=np.zeros(imginfo,np.uint8)#全黑的画布,dst目标图片
#A.绘制line
cv.line(dst,(100,100),(400,400),(0,0,255),20,cv.LINE_AA)
#1dst,2begin,3end,4(bgr),5linewidth,6linestyle
#B.绘制矩形
cv.rectangle(dst,(50,100),(200,300),(0,255,0),8)
#1dst,2左上，3右下，4bgr，5fill=-1填充，大于0=线条宽度
#C.绘制圆形
cv.circle(dst,(250,250),(50),(152,36,56),2)
#1dst,2center,3半径，4bgr，5fill=-1填充，大于0=线条宽度
#D.绘制椭圆，扇形，圆弧
cv.ellipse(dst,(256,256),(150,100),0,0,180,(255,255,0),-1)
#1dst,2center,3两个长短轴，4偏转角度，5起始角度，6终止角度，7bgr，8fill
#E.任意多边形
points=np.array([[150,50],[140,40],[200,170],[250,250],[150,50]],np.int32)
points=points.reshape((-1,1,2))
cv.polylines(dst,[points],True,(0,255,255))
cv.imshow('dst',dst)
cv.waitKey(0)
#17.绘制文字图片
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
font=cv.FONT_HERSHEY_SIMPLEX#字体类型
cv.rectangle(img,(200,100),(500,400),(0,255,0),3)
#A.写字
cv.putText(img,'this is kst',(100,300),font,1,(200,100,255),2,cv.LINE_8)
#1dst,2text,3起始坐标，4字体类型，5字体大小，6bgr,7字体的粗细，8线条类型
#B.放图片
height=int(img.shape[0]*0.5)
width=int(img.shape[1]*0.5)
imgresize=cv.resize(img,(width,height))#将图片缩小
for i in range(height):
for j in range(width):
img[i+100,j+200]=imgresize[i,j]
cv.imshow('src',img)
cv.waitKey(0)
3.图片美化
#1.彩色图片直方图
import cv2 as cv
import numpy as np
def ImageHist(image,type):
#color=(255,255,255)
#windowname='gray'
if type==31:
color=(255,0,0)
windowname='B hist'
elif type==32:
color=(0,255,0)
windowname='G hist'
elif type==33:
color=(0,0,255)
windowname='R hist'
hist=cv.calcHist([image],[0],None,[256],[0.0,255.0])#统计直方图
#1【image】,2直方图通道[0]表示灰度直方图,3mask蒙版，4 直方图分成多少分256，5 0-255表示像素等级
minv,maxv,minl,maxl=cv.minMaxLoc(hist)#灰度值的最小值，最大值，最小值下标，最大值下标
histimg=np.zeros([256,256,3],np.uint8)
for h in range(256):
intenNormal=int(hist[h]*256/maxv)#归一化hist【h】获取每一个直方图的个数
cv.line(histimg,(h,256),(h,256-intenNormal),color)
cv.imshow(windowname,histimg)
return histimg
img=cv.imread('kst.jpg',1)
channels=cv.split(img)#返回3bgr个颜色通道的图像
for i in range(3):#3个颜色通道，各调用一次
ImageHist(channels[i],31+i)
cv.waitKey(0)
#2.直方图均衡化
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
#2.1灰度图直方图均衡化
#gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
#cv.imshow('src',gray)
#dst=cv.equalizeHist(gray)
#2.2彩色图直方图均衡化
cv.imshow('src',img)
#(b,g,r)=cv.split(img)#分解通道
#bh=cv.equalizeHist(b)#分别均衡化
#gh=cv.equalizeHist(g)++
#rh=cv.equalizeHist(r)
#dst=cv.merge((bh,gh,rh))#合并
#2.3yuv直方图均衡化
imgYUV=cv.cvtColor(img,cv.COLOR_BGR2YCrCb)#图片转换成YUV通道
channelYUV=cv.split(imgYUV)#分解
channelYUV[0]=cv.equalizeHist(channelYUV[0])
#channelYUV[1]=cv.equalizeHist(channelYUV[1])
#channelYUV[2]=cv.equalizeHist(channelYUV[2])
merged=cv.merge(channelYUV)
dst=cv.cvtColor(merged,cv.COLOR_YCrCb2BGR)
cv.imshow('dst',dst)
cv.waitKey(0)
#3.图片修补
#3.1图片破损
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
for i in range(200,300):
img[i,200]=(255,255,255)
img[i,200+1]=(255,255,255)
img[i,200-1]=(255,255,255)
for i in range(150,250):
img[250,i]=(255,255,255)
img[250+1,i]=(255,255,255)
img[250-1,i]=(255,255,255)
cv.imwrite('damaged.jpg',img)#写入一个jpg文件
cv.imshow('damage',img)
cv.waitKey(0)
#3.2图片修补
import cv2 as cv
import numpy as np
damaged=cv.imread('damaged.jpg',1)#1破损的照片
cv.imshow('damage',damaged)
info=damaged.shape
height=info[0]
width=info[1]
paint=np.zeros((height,width,1),np.uint8)#因为是蒙板，所以cahnnnel是1
#2.修补的地方的array
for i in range(200,300):
paint[i,200]=255
paint[i,200+1]=255
paint[i,200-1]=255
for i in range(150,250):
paint[250,i]=255
paint[250+1,i]=255
paint[250-1,i]=255
cv.imshow('paint',paint)#3.展示修补图片的蒙板
#4.修补
result=cv.inpaint(damaged,paint,3,cv.INPAINT_TELEA)#1破损的图片，2修补的蒙板，3通道，
cv.imshow('result',result)
cv.waitKey(0)
#4.灰度直方图源码：统计每个像素的灰度值的出现概率
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
img=cv.imread('kst.jpg',1)
imginfo = img.shape
height=imginfo[0]
width=imginfo[1]
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
count=np.zeros(256,np.float)#256个灰度等级
for i in range(height):
for j in range(width):
pixel=gray[i,j]
index=int(pixel)
count[index]=count[index]+1
#计算每个等级的概率
for i in range(256):
count[i]=count[i]/(height*width)
x=np.linspace(0,255,256)#开始，结束，一共多少份
y=count
plt.bar(x,y,0.9,alpha=1,color='r')
plt.show()
cv.waitKey(0)
#5.彩色直方图源码
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
img=cv.imread('kst.jpg',1)
imginfo = img.shape
height=imginfo[0]
width=imginfo[1]
count_b=np.zeros(256,np.float)
count_g=np.zeros(256,np.float)
count_r=np.zeros(256,np.float)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
index_b=int(b)
index_g=int(g)
index_r=int(r)
count_b[index_b]=count_b[index_b]+1
count_g[index_g]=count_g[index_g]+1
count_r[index_r]=count_r[index_r]+1
for i in range(256):
count_b[i]=count_b[i]/(height*width)
count_g[i]=count_g[i]/(height*width)
count_r[i]=count_r[i]/(height*width)
x=np.linspace(0,255,256)
y1=count_b
plt.figure()
plt.bar(x,y1,0.9,alpha=1,color='b')
y2=count_g
plt.figure()
plt.bar(x,y2,0.9,alpha=1,color='g')
y3=count_r
plt.figure()
plt.bar(x,y3,0.9,alpha=1,color='r')
plt.show()
cv.waitKey(0)
#6.灰度直方图均衡化:累计概率*255=new
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
img=cv.imread('kst.jpg',1)
#cv.imshow('src',img)
imginfo = img.shape
height=imginfo[0]
width=imginfo[1]
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
cv.imshow('src',gray)
count=np.zeros(256,np.float)#256个灰度等级
for i in range(height):
for j in range(width):
pixel=gray[i,j]
index=int(pixel)
count[index]=count[index]+1
#计算每个等级的概率
for i in range(256):
count[i]=count[i]/(height*width)
#1计算累计概率
sum=float(0)
for i in range(256):
sum=sum+count[i]
count[i]=sum
#2计算映射表
map=np.zeros(256,np.uint16)
for i in range(256):
map[i]=np.uint16(count[i]*255)
#3映射
for i in range(height):
for j in range(width):
pixel=gray[i,j]
gray[i,j]=map[pixel]
cv.imshow('dst',gray)
cv.waitKey(0)
#7.彩色直方图均衡化
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
img=cv.imread('kst.jpg',1)
cv.imshow('kst',img)
imginfo = img.shape
height=imginfo[0]
width=imginfo[1]
count_b=np.zeros(256,np.float)
count_g=np.zeros(256,np.float)
count_r=np.zeros(256,np.float)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
index_b=int(b)
index_g=int(g)
index_r=int(r)
count_b[index_b]=count_b[index_b]+1
count_g[index_g]=count_g[index_g]+1
count_r[index_r]=count_r[index_r]+1
for i in range(256):
count_b[i]=count_b[i]/(height*width)
count_g[i]=count_g[i]/(height*width)
count_r[i]=count_r[i]/(height*width)
#1计算累计概率
sum_b=float(0)
sum_g=float(0)
sum_r=float(0)
for i in range(256):
sum_b=sum_b+count_b[i]
count_b[i]=sum_b
sum_g=sum_g+count_g[i]
count_g[i]=sum_g
sum_r=sum_r+count_r[i]
count_r[i]=sum_r
#2计算映射表
map_b=np.zeros(256,np.uint16)
map_g=np.zeros(256,np.uint16)
map_r=np.zeros(256,np.uint16)
for i in range(256):
map_b[i]=np.uint16(count_b[i]*255)
map_g[i]=np.uint16(count_g[i]*255)
map_r[i]=np.uint16(count_r[i]*255)
#3映射
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
b=map_b[b]
g=map_g[g]
r=map_r[r]
dst[i,j]=(b,g,r)
cv.imshow('dst',dst)
cv.waitKey(0)
#8.亮度增强
#8.1p=p+40
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
cv.imshow('src',img)
dst=np.zeros((height,width,3),np.uint8)
for i in range(height):
for j in range(width):
(b,g,r)=img[i,j]
bb=int(b)+40
gg=int(g)+40
rr=int(r)+40
if bb>255:
bb=255
if gg>255:
gg=255
if rr>255:
rr=255
dst[i,j]=(bb,gg,rr)
cv.imshow('dst',dst)
cv.waitKey(0)
#9.磨皮美白:双边滤波
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
dst=cv.bilateralFilter(img,15,35,35)
cv.imshow('img',img)
cv.imshow('dst',dst)
cv.waitKey(0)
#10.高斯滤波和均值滤波
#10.1高斯:消除椒盐噪声,图片变模糊
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
#dst=cv.GaussianBlur(img,(5,5),1.5)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
dst=np.zeros((height,width,3),np.uint8)
#10.2均值滤波：6*6的全为1的模板，计算卷积/36=mean,图片模糊
for i in range(3,height-3):
for j in range(3,width-3):
sum_b=int(0)
sum_g=int(0)
sum_r=int(0)
for m in range(-3,3):
for n in range(-3,3):
(b,g,r)=img[i+m,j+n]
sum_b=sum_b+int(b)
sum_g=sum_g+int(g)
sum_r=sum_r+int(r)
b=np.uint8(sum_b/36)
g=np.uint8(sum_g/36)
r=np.uint8(sum_r/36)
dst[i,j]=(b,g,r)
cv.imshow('img',img)
cv.imshow('dst',dst)
cv.waitKey(0)
#11.中值滤波：3*3模板，排序，中间值作为像素值
import cv2 as cv
import numpy as np
img=cv.imread('kst.jpg',1)
imginfo=img.shape
height=imginfo[0]
width=imginfo[1]
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
cv.imshow('gray',gray)
dst=np.zeros((height,width,3),np.uint8)
collect=np.zeros(9,np.uint8)#9个邻域像素值
for i in range(1,height-1):
for j in range(1,width-1):
k=0#邻域下标值，从0开始
for m in range(-1,2):
for n in range(-1,2):
collect[k]=gray[i+m,j+n]
k=k+1
#冒泡法 取中间值
for k in range(9):
min=collect[k]
for t in range(k+1,9):
if min<collect[t]:
min,collect[t]=collect[t],min
dst[i,j]=collect[4]
cv.imshow('dst',dst)
cv.waitKey(0)
4.图片与视频的检测识别
#机器学习：1样本，2特征，3分类器，4预测检验
#4.1haar+adaboost：人脸识别
#4.2hog+svm：行人检测
#1,数据：视频分解成图片
import cv2 as cv
cap=cv.VideoCapture('lz.mp4')#获取一个视频文件
isopened=cap.isOpened#判断视频是否可以打开
print(isopened)
fps=cap.get(cv.CAP_PROP_FPS)#获取视频帧率
height=int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))#获取图像height
width=int(cap.get(cv.CAP_PROP_FRAME_WIDTH))#获取图像width
print(fps,height,width)
i=0#一共要多少张图片，从第0张开始
while(isopened):#当视频可以打开时
if i==10:
break
else:
i=i+1
(flag,frame)=cap.read()#读取每张（帧）图片的flag（是否读取成功），frame（图片内容）
filename='image'+str(i)+'.jpg'
print(filename)
if flag==True:#读取图片成功的话
cv.imwrite(filename,frame,[cv.IMWRITE_JPEG_QUALITY,100])#把如片写入本地文件：1文件名，2文件内容，图片质量
print('end!')
##1,数据：图片合成视频
import cv2 as cv
img=cv.imread('image1.jpg',3)
imginfo=img.shape
size=(imginfo[1],imginfo[0])#w,h
print(size)
#写视频的对象：1名称，2编码器，3视频帧率，4每张图片的大小
videowrite=cv.VideoWriter('lz2.mp4',-1,24,size)#对象
for i in range(1,11):
filename='image'+str(i)+'.jpg'
img=cv.imread(filename)
videowrite.write(img)#对象调用写的方法，写一个视频
print('end')
#2.特征：haar特征
#特征：像素经过运算得到的结果，
#目标区分：阈值判决
#haar特征：
#3.分类器：
#haar+adaboost：人脸检测:1load xml,2load jpg,3haar gray, 4detect,5draw
import cv2 as cv
import numpy as np
#1.load xml
face_xml=cv.CascadeClassifier(r'D:DeepLearninghaarsharehaarcascade_frontalface_default.xml')
eye_xml=cv.CascadeClassifier(r'D:DeepLearninghaarsharehaarcascade_eye.xml')
#2.load jpg
img=cv.imread('kst.jpg',1)
cv.imshow('src',img)
#3.haar,gray
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
#4.detect face:
faces=face_xml.detectMultiScale(gray,1.3,7)#1data,2haar模板的缩放比例，3人脸检测的最小像素
print('face=',len(faces))
#5.draw
for (x,y,w,h) in faces:
cv.rectangle(img,(x,y),(x+w,y+h),(255,0,0),4)
#4.2detect eye
roi_face=gray[y:y+h,x:x+w]#人脸区域的灰度图
roi_color=img[y:y+h,x:x+w]#人脸区域的彩色图
eyes=eye_xml.detectMultiScale(roi_face)#在灰度图中检测眼睛
print('eye=',len(eyes))
#5.2draw eye
for (e_x,e_y,e_w,e_h) in eyes:
cv.rectangle(roi_color,(e_x,e_y),(e_x+e_w,e_y+e_h),(0,255,0),2)
cv.imshow('dst',img)
cv.waitKey(0)
#3.SVM
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
#1.准备数据
rand1=np.array([[155,48],[159,50],[164,53],[168,56],[172,60]])
rand2=np.array([[152,53],[156,55],[160,56],[172,64],[176,65]])
#2label
label=np.array([[0],[0],[0],[0],[0],[1],[1],[1],[1],[1]])
#3.data
data=np.vstack((rand1,rand2))
data=np.array(data,dtype='float32')
#4.训练svm
svm=cv.ml.SVM_create()
#设置svm属性
svm.setType(cv.ml.SVM_C_SVC)#type
svm.setKernel(cv.ml.SVM_LINEAR)#line核
svm.setC(0.01)#核属性
#训练
result=svm.train(data,cv.ml.ROW_SAMPLE,label)
#预测
pt_data=np.vstack([[167,55],[162,57]])#0,1
pt_data=np.array(pt_data,dtype='float32')
print(pt_data)
_,pt=svm.predict(pt_data)
print(pt)
#4.hog+svm：1样本，2训练，3预测，识别
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
PosNum=820#正样本820个
NegNum=1931#负样本1931个
winsize=(64,128)#win窗口是整张图片大小，1个
blocksize=(16,16)#blok窗口大小，105个，
blockstride=(8,8)#block滑动的步长
cellsize=(8,8)#每个block里面的cell大小，4个
nBin=9#cell里面的方向参数是九个，3780个
#创建hog对象
hog=cv.HOGDescriptor(winsize,blocksize,blockstride,cellsize,nBin)
#创建svm
svm=cv.ml.SVM_create()
#计算hog
featureNum=int(((128-16)/8+1)*((64-16)/8+1)*4*9)#hog特征的维度3780
featureArray=np.zeros(((PosNum+NegNum),featureNum),np.float32)
labelArray=np.zeros(((PosNum+NegNum),1),np.int32)
for i in range(PosNum):
filename='pos/'+str(i+1)+'.jpg'
img=cv.imread(filename)
hist=hog.compute(img,(8,8))#计算hog特征
#将hog特征装入特征向量:featureArray[i]=hist
for j in range(featureNum):
featureArray[i,j]=hist[j]
labelArray[i,0]=1#正样本标签1
for i in range(NegNum):
filename='neg/'+str(i+1)+'.jpg'
img=cv.imread(filename)
hist=hog.compute(img,(8,8))#计算hog特征
#将hog特征装入特征向量:featureArray[i]=hist
for j in range(featureNum):
featureArray[i+PosNum,j]=hist[j]
labelArray[i+PosNum,0]=-1
#svm属性设置
svm.setType(cv.ml.SVM_C_SVC)
svm.setKernel(cv.ml.SVM_LINEAR)
svm.setC(0.01)
#训练
ret=svm.train(featureArray,cv.ml.ROW_SAMPLE,labelArray)
#检测
#1.1计算rho
alpha = np.zeros((1),np.float32)
rho = svm.getDecisionFunction(0,alpha)
print(rho)
print(alpha)
#1.2计算resultarray
alphaArray = np.zeros((1,1),np.float32)
supportVArray = np.zeros((1,featureNum),np.float32)
resultArray = np.zeros((1,featureNum),np.float32)
alphaArray[0,0] = alpha
resultArray = -1*alphaArray*supportVArray
# 1.3detect
myDetect = np.zeros((3781),np.float32)
for i in range(0,3780):
myDetect[i] = resultArray[0,i]
myDetect[3780] = rho[0]
# rho svm （判决）
myHog = cv.HOGDescriptor()
myHog.setSVMDetector(myDetect)
# 1.4load
imageSrc = cv.imread('Test2.jpg',1)
# (8,8) win
objs = myHog.detectMultiScale(imageSrc,0,(8,8),(32,32),1.05,2)
# xy wh 三维 最后一维
x = int(objs[0][0][0])
y = int(objs[0][0][1])
w = int(objs[0][0][2])
h = int(objs[0][0][3])
# 绘制展示
cv.rectangle(imageSrc,(x,y),(x+w,y+h),(255,0,0),2)
cv.imshow('dst',imageSrc)
cv.waitKey(0)
#5.KNN手写数字识别
import tensorflow as tf
import numpy as np
import random
from tensorflow.examples.tutorials.mnist import input_data
mnist=input_data.read_data_sets('MNIST_data',one_hot=True)
#设置属性
trainNum=55000
testNum=10000
trainSize=500
testSize=5
# data 分解 1 trainSize 2范围0-trainNum 3 replace=False
trainIndex = np.random.choice(trainNum,trainSize,replace=False)#在trainnum中不重复的选择trainsize个数据
testIndex = np.random.choice(testNum,testSize,replace=False)
trainData = mnist.train.images[trainIndex]# 训练图片
trainLabel = mnist.train.labels[trainIndex]# 训练标签
testData = mnist.test.images[testIndex]
testLabel = mnist.test.labels[testIndex]
# 28*28 = 784
print('trainData.shape=',trainData.shape)#500*784 1 图片个数 2 784?
print('trainLabel.shape=',trainLabel.shape)#500*10
print('testData.shape=',testData.shape)#5*784
print('testLabel.shape=',testLabel.shape)#5*10
print('testLabel=',testLabel)# 4 :testData [0] 3:testData[1] 6
# tf input 784->image
trainDataInput = tf.placeholder(shape=[None,784],dtype=tf.float32)
trainLabelInput = tf.placeholder(shape=[None,10],dtype=tf.float32)
testDataInput = tf.placeholder(shape=[None,784],dtype=tf.float32)
testLabelInput = tf.placeholder(shape=[None,10],dtype=tf.float32)
#knn distance 5*785. 5*1*784
# 5 500 784 (3D) 2500*784
f1 = tf.expand_dims(testDataInput,1) # 维度扩展
f2 = tf.subtract(trainDataInput,f1)# 784 sum(784)
f3 = tf.reduce_sum(tf.abs(f2),reduction_indices=2)# 完成数据累加 784 abs
# 5*500
f4 = tf.negative(f3)# 取反
f5,f6 = tf.nn.top_k(f4,k=4) # 选取f4 最大的四个值
# f3 最小的四个值
# f6 index->trainLabelInput
f7 = tf.gather(trainLabelInput,f6)
# f8 num reduce_sum reduction_indices=1 '竖直'
f8 = tf.reduce_sum(f7,reduction_indices=1)
# tf.argmax 选取在某一个最大的值 index
f9 = tf.argmax(f8,dimension=1)
# f9 -> test5 image -> 5 num
with tf.Session() as sess:
# f1 <- testData 5张图片
p1 = sess.run(f1,feed_dict={testDataInput:testData[0:5]})
print('p1=',p1.shape)# p1= (5, 1, 784)
p2 = sess.run(f2,feed_dict={trainDataInput:trainData,testDataInput:testData[0:5]})
print('p2=',p2.shape)#p2= (5, 500, 784) (1,100)
p3 = sess.run(f3,feed_dict={trainDataInput:trainData,testDataInput:testData[0:5]})
print('p3=',p3.shape)#p3= (5, 500)
print('p3[0,0]=',p3[0,0]) #130.451 knn distance p3[0,0]= 155.812
p4 = sess.run(f4,feed_dict={trainDataInput:trainData,testDataInput:testData[0:5]})
print('p4=',p4.shape)
print('p4[0,0]',p4[0,0])
p5,p6 = sess.run((f5,f6),feed_dict={trainDataInput:trainData,testDataInput:testData[0:5]})
#p5= (5, 4) 每一张测试图片（5张）分别对应4张最近训练图片
#p6= (5, 4)
print('p5=',p5.shape)
print('p6=',p6.shape)
print('p5[0,0]',p5[0])
print('p6[0,0]',p6[0])# p6 index
p7 = sess.run(f7,feed_dict={trainDataInput:trainData,testDataInput:testData[0:5],trainLabelInput:trainLabel})
print('p7=',p7.shape)#p7= (5, 4, 10)
print('p7[]',p7)
p8 = sess.run(f8,feed_dict={trainDataInput:trainData,testDataInput:testData[0:5],trainLabelInput:trainLabel})
print('p8=',p8.shape)
print('p8[]=',p8)
p9 = sess.run(f9,feed_dict={trainDataInput:trainData,testDataInput:testData[0:5],trainLabelInput:trainLabel})
print('p9=',p9.shape)
print('p9[]=',p9)
p10 = np.argmax(testLabel[0:5],axis=1)
print('p10[]=',p10)
j = 0
for i in range(0,5):
if p10[i] == p9[i]:
j = j+1
print('ac=',j*100/5)
#6.CNN手写数字识别
#cnn : 1 卷积
# ABC
# A: 激励函数+矩阵 乘法加法
# A CNN : pool（激励函数+矩阵 卷积 加法）
# C：激励函数+矩阵 乘法加法（A-》B）
# C：激励函数+矩阵 乘法加法（A-》B） + softmax（矩阵 乘法加法）
# loss：tf.reduce_mean(tf.square(y-layer2))
# loss：code
#1 import
import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data
# 2 load data
mnist = input_data.read_data_sets('MNIST_data',one_hot = True)
# 3 input
imageInput = tf.placeholder(tf.float32,[None,784]) # 28*28
labeInput = tf.placeholder(tf.float32,[None,10]) # knn
# 4 data reshape
# [None,784]->M*28*28*1 2D->4D 28*28 wh 1 channel
imageInputReshape = tf.reshape(imageInput,[-1,28,28,1])
# 5 卷积 w0 : 卷积内核 5*5 out:32 in:1
w0 = tf.Variable(tf.truncated_normal([5,5,1,32],stddev = 0.1))
b0 = tf.Variable(tf.constant(0.1,shape=[32]))
# 6 # layer1：激励函数+卷积运算
# imageInputReshape : M*28*28*1 w0:5,5,1,32
layer1 = tf.nn.relu(tf.nn.conv2d(imageInputReshape,w0,strides=[1,1,1,1],padding='SAME')+b0)
# M*28*28*32
# pool 采样 数据量减少很多M*28*28*32 => M*7*7*32
layer1_pool = tf.nn.max_pool(layer1,ksize=[1,4,4,1],strides=[1,4,4,1],padding='SAME')
# [1 2 3 4]->[4]
# 7 layer2 out : 激励函数+乘加运算： softmax（激励函数 + 乘加运算）
# [7*7*32,1024]
w1 = tf.Variable(tf.truncated_normal([7*7*32,1024],stddev=0.1))
b1 = tf.Variable(tf.constant(0.1,shape=[1024]))
h_reshape = tf.reshape(layer1_pool,[-1,7*7*32])# M*7*7*32 -> N*N1
# [N*7*7*32] [7*7*32,1024] = N*1024
h1 = tf.nn.relu(tf.matmul(h_reshape,w1)+b1)
# 7.1 softMax
w2 = tf.Variable(tf.truncated_normal([1024,10],stddev=0.1))
b2 = tf.Variable(tf.constant(0.1,shape=[10]))
pred = tf.nn.softmax(tf.matmul(h1,w2)+b2)# N*1024 1024*10 = N*10
# N*10( 概率 )N1【0.1 0.2 0.4 0.1 0.2 。。。】
# label。 【0 0 0 0 1 0 0 0.。。】
loss0 = labeInput*tf.log(pred)
loss1 = 0
# 7.2
for m in range(0,500):# test 100
for n in range(0,10):
loss1 = loss1 - loss0[m,n]
loss = loss1/500
# 8 train
train = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
# 9 run
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(100):
images,labels = mnist.train.next_batch(500)
sess.run(train,feed_dict={imageInput:images,labeInput:labels})
pred_test = sess.run(pred,feed_dict={imageInput:mnist.test.images,labeInput:labels})
acc = tf.equal(tf.arg_max(pred_test,1),tf.arg_max(mnist.test.labels,1))
acc_float = tf.reduce_mean(tf.cast(acc,tf.float32))
acc_result = sess.run(acc_float,feed_dict={imageInput:mnist.test.images,labeInput:mnist.test.labels})
print(acc_result)
#7.爬取网站图片
import urllib
import urllib3
import os
from bs4 import BeautifulSoup
# load url
html = urllib.request.urlopen('https://class.imooc.com/?c=ios&mc_marking=286b51b2a8e40915ea9023c821882e74&mc_channel=L5').read()
# parse url data 1 html 2 'html.parser' 3 'utf-8'
soup = BeautifulSoup(html,'html.parser',from_encoding='utf-8')
# img
images = soup.findAll('img')
print(images)
imageName = 0
for image in images:
link = image.get('src')
print('link=',link)
link = 'http:'+link
fileFormat = link[-3:]
if fileFormat == 'png' or fileFormat == 'jpg':
fileSavePath = 'D:\DeepLearning\'+str(imageName)+'.jpg'
imageName = imageName +1
urllib.request.urlretrieve(link,fileSavePath)
5.实战案例
import cv2 as cv
#1.打开摄像头： capture=cv.VideoCapture(0)
def video():
capture=cv.VideoCapture(0)
while(True):
flag,frame=capture.read()
frame=cv.flip(frame,1)#左右调换，上下是-1
cv.imshow('video',frame)
c=cv.waitKey(50)
if c==27:
break
video()
#cv.waitKey(0)
cv.destroyAllWindows()
#2彩图取反:dst=cv.bitwise_not(img)
import cv2 as cv
'''def fantu(img):
height=img.shape[0]
width=img.shape[1]
channel=img.shape[2]
for row in range(height):
for col in range(width):
for c in range(channel):
pv=img[row,col,c]
img[row,col,c]=255-pv'''
def fantu(img):
dst=cv.bitwise_not(img)
return dst
img=cv.imread('kst.jpg',1)
cv.imshow('img',img)
t1=cv.getTickCount()#获取cpu时钟
dst=fantu(img)
t2=cv.getTickCount()
print('time:%s ms'%((t2-t1)/cv.getTickFrequency()*1000))
cv.imshow('dst',dst)
cv.waitKey(0)
#3HSV图像转换,跟踪指定颜色的物体
import cv2 as cv
import numpy as np
def hsv_demo():
capture=cv.VideoCapture(0)
while(True):
flag,frame=capture.read()
if flag==False:
break
hsv=cv.cvtColor(frame,cv.COLOR_BGR2HSV)
lower_hsv=np.array([26,43,46])
upper_hsv=np.array([34,255,255])#黄色
mask=cv.inRange(hsv,lowerb=lower_hsv,upperb=upper_hsv)
dst=cv.bitwise_and(frame,frame,mask=mask)
cv.imshow('mask',dst)
c=cv.waitKey(40)
if c==27:
break
hsv_demo()
#
#像素运算：cv.add,cv.divide,cv.multiply,cv.divide
#与运算：cv.bitwise_and,或运算：cv.bitwise_or,非运算：cv.bitwise_not
#提高图片对比度和亮度
import cv2 as cv
import numpy as np
def contrast_brighten(img,c,b):
h,w,ch=img.shape
blank=np.zeros([h,w,ch],img.dtype)
dst=cv.addWeighted(img,c,blank,1-c,b)
cv.imshow('dst',dst)
cv.waitKey(0)
img=cv.imread('kst.jpg')
contrast_brighten(img,1.2,1.5)#1data,2对比度，3亮度
#ROI感兴趣区域，泛洪填充
import cv2 as cv
import numpy as np
def fill_color(img):
copy=img.copy()
h,w=copy.shape[:2]
mask=np.zeros([h+2,w+2],np.uint8)#要求mask+2
#在（30，30）的色素-100到+50的范围内填充黄色
cv.floodFill(copy,mask,(30,30),(0,255,255),(100,100,100),(50,50,50),cv.FLOODFILL_FIXED_RANGE)
cv.imshow('dst',copy)
cv.waitKey(0)
def fill_binary():
image=np.zeros([400,400,3],np.uint8)
image[100:300,100:300,:]=255
cv.imshow('fill_binary',image)
mask=np.ones([402,402,1],np.uint8)
mask[101:301,101:301]=0
cv.floodFill(image,mask,(200,200),(100,2,255),cv.FLOODFILL_MASK_ONLY)
cv.imshow('filled',image)
cv.waitKey(0)
img=cv.imread('kst.jpg')
cv.imshow('img',img)
#fill_color(img)#1data,2对比度，3亮度
fill_binary()
#
#卷积模糊
import cv2 as cv
import numpy as np
def blur_demo(img):
#均值模糊
#dst=cv.blur(img,(15,15))#对image图像做（15，1）的卷积核，大小全是1
#中值模糊
dst=cv.medianBlur(img,15)
#高斯模糊
dst=cv.GaussianBlur(img,(0,0),3)
cv.imshow('blur',dst)
def clamp(a):
if a>255:
return 255
if a<0:
return 0
else:
return a
#高斯噪声
def gaussian_noise(image):
h,w,c=image.shape
for row in range(h):
for col in range(w):
s=np.random.normal(0,20,3)
image[row,col,0]=clamp(image[row,col,0]+s[0])
image[row,col,1]=clamp(image[row,col,1]+s[1])
image[row,col,2]=clamp(image[row,col,2]+s[2])
cv.imshow('dst',image)
img=cv.imread('kst.jpg')
blur_demo(img)
#gaussian_noise(img)
cv.waitKey(0)
cv.destroyAllWindows()
#EPF：边缘保留滤波(高斯双边模糊【美颜效果】，均值迁移)
import cv2 as cv
import numpy as np
img=cv.imread('dz.jpg')
dst=cv.bilateralFilter(img,0,30,15)#高斯
#dst=cv.pyrMeanShiftFiltering(img,10,50)#均值迁移
cv.imshow('dst',dst)
cv.waitKey(0)
cv.destroyAllWindows()
#直方图
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
img=cv.imread('dz.jpg')
#plt.hist(img.ravel(),256,[0,255])#bins256，range【0，255】
#plt.show('直方图')
def image_hist(img):
color=('blue','green','red')
for i,color in enumerate(color):
hist=cv.calcHist([img],[i],None,[256],[0,256])#None是mask没有,i是图像的第几个channel
plt.plot(hist,color=color)
plt.xlim([0,256])
plt.show()
#image_hist(img)
#根据图片的直方图求相似性：
def creat_rgb_hist(image):
h,w,c=image.shape
rgbhist=np.zeros([16*16*16,1],np.float32)
bsize=256/16
for row in range(h):
for col in range(w):
b=image[row,col,0]
g=image[row,col,1]
r=image[row,col,2]
index=np.int(b/bsize)*16*16+np.int(g/bsize)*16+np.int(r/bsize)
rgbhist[np.int(index),0]=rgbhist[np.int(index),0]+1
return rgbhist
def hist_compare(image1,image2):
hist1=creat_rgb_hist(image1)
hist2=creat_rgb_hist(image2)
match1=cv.compareHist(hist1,hist2,cv.HISTCMP_BHATTACHARYYA)
match2=cv.compareHist(hist1,hist2,cv.HISTCMP_CORREL)
match3=cv.compareHist(hist1,hist2,cv.HISTCMP_CHISQR)
print('巴氏距离：%s,相关性：%s,卡方：%s'%(match1,match2,match3))
image1=cv.imread('dz.jpg')
image2=cv.imread('dz.jpg')
hist_compare(image1,image2)
#直方图反向投影跟踪
#1.图像的hsv2D直方图
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
def hist2d(image):
hsv=cv.cvtColor(image,cv.COLOR_BGR2HSV)
#1image,2channel,3mask,4histsize,5ranges
hist=cv.calcHist([image],[0,1],None,[32,32],[0,180,0,256])
plt.imshow(hist,interpolation='nearest')
plt.title('2d histogram')
plt.show()
#2.图像的反向投影跟踪
def back_projection(sample,target):
sample_hsv=cv.cvtColor(sample,cv.COLOR_BGR2HSV)
target_hsv=cv.cvtColor(target,cv.COLOR_BGR2HSV)#两个图转换成HSV
samplehist=cv.calcHist([sample_hsv],[0,1],None,[32,32],[0,180,0,256])#计算HSV
cv.normalize(samplehist,samplehist,0,255,cv.NORM_MINMAX)#标准化HSV
#反向投影
dst=cv.calcBackProject([target_hsv],[0,1],samplehist,[0,180,0,256],1)
cv.imshow('backprojection',dst)
cv.waitKey(0)
src=cv.imread('timg.jpg')
#hist2d(src)
sample=cv.imread('aim.png')
target=cv.imread('timg.jpg')
back_projection(sample,target)
#图像二值化
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
def threshold(img):
gray=cv.cvtColor(img,cv.COLOR_BGR2GRAY)
#全局阈值
#ret,binary=cv.threshold(gray,0,255,cv.THRESH_BINARY | cv.THRESH_OTSU)
#print('threshold value:%s'%ret)
#局部阈值#贼清晰，有漫画效果
dst=cv.adaptiveThreshold(gray,255,cv.ADAPTIVE_THRESH_GAUSSIAN_C,cv.THRESH_BINARY,25,8)
cv.imshow('binary',dst)
cv.waitKey(0)
img=cv.imread('dz.jpg')
threshold(img)
#金字塔：
import cv2 as cv
import numpy as np
def pyramid_demo(image):
level=3
temp=image.copy()
pyramid_images=[]
for i in range(level):
dst=cv.pyrDown(temp)
pyramid_images.append(dst)
cv.imshow('pyramid_down_'+str(i),dst)
temp=dst.copy()
return pyramid_images
#拉普拉斯金字塔，要用高斯金字塔
def lapalian_demo(image):
pyramid_images=pyramid_demo(image)
level=len(pyramid_images)
for i in range(level-1,-1,-1):
if (i-1)<0:
expand=cv.pyrUp(pyramid_images[i],dstsize=image.shape[:2])
lpls=cv.subtract(image,expand)
cv.imshow('lapalian_down'+str(i),lpls)
else:
expand=cv.pyrUp(pyramid_images[i],dstsize=pyramid_images[i-1].shape[:2])
lpls=cv.subtract(pyramid_images[i-1],expand)
cv.imshow('lapalian_down'+str(i),lpls)
img=cv.imread('timg.jpg')#图像要是2的n次方的像素
#pyramid_demo(img)
lapalian_demo(img)
cv.waitKey(0)
#边缘提取，一阶导数，sobel算子，
import cv2 as cv
import numpy as np
def sobel_demo(image):
grad_x=cv.Scharr(image,cv.CV_32F,1,0)#Scharr算子比sobel算子增强边缘，用法一样
grad_y=cv.Scharr(image,cv.CV_32F,0,1)
gradx=cv.convertScaleAbs(grad_x)
grady=cv.convertScaleAbs(grad_y)
cv.imshow('gradient_x',gradx)
cv.imshow('gradient_y',grady)
gradxy=cv.addWeighted(gradx,0.5,grady,0.5,0)
cv.imshow('gradient',gradxy)
#拉普拉斯算子，二阶导数
def lapalian_demo(image):
dst=cv.Laplacian(image,cv.CV_32F)
lpls=cv.convertScaleAbs(dst)
cv.imshow('dst',dst)
image=cv.imread('kst.jpg')
#sobel_demo(image)
lapalian_demo(image)
cv.waitKey(0)
#canny边缘提取:1高斯模糊，2灰度转换，3计算梯度，4非最大信号抑制，5高低阈值输出二值图像
import cv2 as cv
import numpy as np
def edge_demo(image):
blurred=cv.GaussianBlur(image,(3,3),0)
gray=cv.cvtColor(blurred,cv.COLOR_BGR2GRAY)
xgrad=cv.Sobel(gray,cv.CV_16SC1,1,0)
ygrad=cv.Sobel(gray,cv.CV_16SC1,0,1)
edge_output=cv.Canny(xgrad,ygrad,50,150)
cv.imshow('canny edge',edge_output)
#边缘彩色化
dst=cv.bitwise_and(image,image,mask=edge_output)
cv.imshow('color edge',dst)
img=cv.imread('kst.jpg')
edge_demo(img)
cv.imshow('img',img)
cv.waitKey(0)
#基于霍夫变换的直线检测,圆检测
import cv2 as cv
import numpy as np
def line_detect(image):
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)#灰度图
edges=cv.Canny(gray,50,150,apertureSize=3)#图像边缘提取
lines=cv.HoughLinesP(edges,1,np.pi/180,100,minLineLength=30,maxLineGap=20)
for line in lines:
x1,y1,x2,y2=line[0]
cv.line(image,(x1,y1),(x2,y2),(0,0,255),2)
cv.imshow('lines',image)
def circle_detect(image):
dst=cv.pyrMeanShiftFiltering(image,10,100)#对图像去噪
gray=cv.cvtColor(dst,cv.COLOR_BGR2GRAY)
circles=cv.HoughCircles(gray,cv.HOUGH_GRADIENT,1,20,param1=50,param2=30,minRadius=0,maxRadius=0)
circles=np.uint16(np.around(circles))
for i in circles[0,:]:
cv.circle(image,(i[0],i[1]),i[2],(0,0,255),2)
cv.circle(image,(i[0],i[1]),2,(255,0,0),2)
cv.imshow('circle',image)
image=cv.imread('kst.jpg')
#line_detect(image)
circle_detect(image)
cv.waitKey(0)
#对象测量
import cv2 as cv
import numpy as np
def measure_object(image):
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
#cv.THRESH_BINARY_INV二值化取反
ret,binary=cv.threshold(gray,0,255,cv.THRESH_BINARY_INV|cv.THRESH_OTSU)
print('threshold value:%s'%ret)#二值化的阈值
cv.imshow('binary image',binary)
outimage,contours,hireachy=cv.findContours(binary,cv.RETR_EXTERNAL,cv.CHAIN_APPROX_SIMPLE)
for i,contour in enumerate(contours):
area=cv.contourArea(contour)#轮廓面积
x,y,w,h=cv.boundingRect(contour)#轮廓矩形
mm=cv.moments(contour)#轮廓中心矩
cx=mm['m10']/mm['m00']
cy=mm['m01']/mm['m00']
cv.circle(image,(np.int(cx),np.int(cy)),3,(0,255,255),-1)
cv.rectangle(image,(x,y),(x+w,y+h),(0,0,255),2)
print('countour area %s'%area)
#多边形逼近
approxCurve=cv.approxPolyDP(contour,4,True)
print(approxCurve.shape)
if approxCurve.shape[0]>6:#多边形
cv.drawContours(image,contours,i,(0,0,255),2)
if approxCurve.shape[0]==4:#四边形
cv.drawContours(image,contours,i,(0,255,255),2)
if approxCurve.shape[0]==3:#三角形
cv.drawContours(image,contours,i,(255,0,255),2)
cv.imshow('measure',image)
image=cv.imread('a.jpg')
measure_object(image)
cv.waitKey(0)
#分水岭算法
import cv2 as cv
import numpy as np
def watershed(image):
# blurred=cv.pyrMeanShiftFiltering(image,10,100)
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
ret,binary=cv.threshold(gray,0,255,cv.THRESH_BINARY_INV|cv.THRESH_OTSU)
cv.imshow('binary',binary)
#开运算
#kernel=cv.getStructuringElement(cv.MORPH_RECT,(3,3))
#mb=cv.morphologyEx(binary,cv.MORPH_OPEN,kernel,iterations=2)
#sure_bg=cv.dilate(mb,kernel,iterations=3)
#cv.imshow('opt',sure_bg)
#距离变换
dist=cv.distanceTransform(binary,cv.DIST_L2,3)
dist_output=cv.normalize(dist,0,1.0,cv.NORM_MINMAX)
cv.imshow('distance',dist_output*50)
ret,surface=cv.threshold(dist,dist.max()*0.6,255,cv.THRESH_BINARY)
cv.imshow('surface',surface)
surface_fg=np.uint8(surface)
unknow=cv.subtract(binary,surface_fg)
ret,markers=cv.connectedComponents(surface_fg)
print(ret)
markers=markers+1
markers[unknow==255]=0
markers=cv.watershed(image,markers=markers)
image[markers==-1]=[0,0,255]
cv.imshow('result',image)
image=cv.imread('b.jpg')
watershed(image)
cv.waitKey(0)
#人脸检测
import cv2 as cv
import numpy as np
def face_detect(image):
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
face_detect=cv.CascadeClassifier(r'D:DeepLearninghaarsharehaarcascade_frontalface_default.xml')
faces=face_detect.detectMultiScale(gray,1.1,2)
for x,y,w,h in faces:
cv.rectangle(image,(x,y),(x+w,y+h),(0,0,255),2)
cv.imshow('result',image)
capture=cv.VideoCapture(0)
while(True):
ret,frame=capture.read()
frame=cv.flip(frame,1)
face_detect(frame)
c=cv.waitKey(10)
if c==27:#esc
break
import cv2 as cv
import numpy as np
from PIL import Image
import pytesseract as tess
#验证码识别
import cv2 as cv
import numpy as np
from PIL import Image
import pytesseract as tess
def recognize_text(image):
gray=cv.cvtColor(image,cv.COLOR_BGR2GRAY)
cv.imshow('gray',gray)
ret,binary=cv.threshold(gray,0,255,cv.THRESH_BINARY_INV|cv.THRESH_OTSU)
cv.imshow('binary',binary)
#去掉干扰项
kernel=cv.getStructuringElement(cv.MORPH_RECT,(2,2))
bin1=cv.morphologyEx(binary,cv.MORPH_OPEN,kernel)
cv.imshow('open',bin1)
cv.bitwise_not(bin1,bin1)
textImage=Image.fromarray(bin1)
text=tess.image_to_string(textImage)
print('识别结果%s'%text)
image=cv.imread('yzm.png')
recognize_text(image)
cv.imshow('rsc',image)
cv.waitKey(0)
cv.destroyAllWindows()