opencv简单操作

读取图像 cv2.imread()

import cv2
import numpy as np
from scipy import ndimage
image = cv2.imread('./images/1.jpg',flags=0)
image = cv2.imread('./images/2.jpg',flags=cv2.COLOR_BGR2RGB)
# 第一个参数是图片地址，第二个参数是图片类型，默认是flag=1(BRG格式）。flag=2,灰度格式，
# 也可以使用cv2.COLOR_BGR2RGB转成RGB格式，flag很多，具体用到在进行查阅即可
# 返回的image是numpy格式【H,W,C]
# 可以使用 np.transpose(image,(2,0,1))转换成【C,H,W]
image_reshape = np.transpose(image,(2,0,1))
print(image_reshape.shape)

cv2.imwrite()

cv2.imwrite(‘result2.png’,image)讲读取的数据写到本地来：

cv2.imshow()

cv2.imshow(‘result’,image) 显示读取到的图片

cv2.waitkey(param)

当param<=0将无限等待下去
当param >0 将等待param毫秒

高通滤波器

高通滤波器就是讲某一像素值与其周围的像素的亮度之间的差值来提升像素的亮度。
代码如下：

```python
kernel_3_3 = np.array([[-1,-1,-1],
                      [-1,8,-1],
                      [-1,-1,-1]])
kernel_5_5 = np.array([
    [-1, -1, -1, -1, -1],
    [-1, -1,  2, -1, -1],
    [-1,  2,  4,  2, -1],
    [-1, -1,  2, -1, -1],
    [-1, -1, -1, -1, -1],
])
#
image = cv2.imread('./images/3.jpg',flags=cv2.IMREAD_GRAYSCALE)
k3 = ndimage.convolve(image,kernel_3_3)
k5 = ndimage.convolve(image,kernel_5_5)

g_hpf = cv2.GaussianBlur(image,(11,11),0)
G_hpf = image = g_hpf

cv2.imshow('img',image)
cv2.imshow('image_k3',k3)
cv2.imshow('image5',k5)
cv2.imshow("ghpf",G_hpf)
cv2.waitKey(0)
cv2.destroyAllWindows()

边缘检测

# 边缘检测，边缘检测之前通常需要进项图像的模糊处理，因为opencv的很多边缘检测滤波函数大多容易将噪声错误的识别为边缘
#opencv中有很多的模糊处理滤波器，边缘检测滤波器和模糊滤波器都很多参数，但是总会有一个共有的ksize，大小是奇数，表示滤波器的宽高
image = cv2.imread('./images/pig.jpg',flags=cv2.IMREAD_GRAYSCALE)
Gbul = cv2.GaussianBlur(image,(3,3),0)
canny = cv2.Canny(Gbul,50,150)
cv2.imshow('image',image)
cv2.imshow('Gbul',Gbul)
cv2.imshow("canny",canny)
cv2.waitKey(0)
cv2.destoryAllWindow()

def image_progress(image,blur_size=7,edge_size=5):
    if blur_size >=3:
        Blur_image = cv2.medianBlur(image,blur_size)
        cv2.imshow('blur_image',Blur_image)
        gray_image = cv2.cvtColor(Blur_image,cv2.COLOR_BGR2GRAY)
    else:
        gray_image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
    cv2.imshow('gray_image',gray_image)


    Lap_image = cv2.Laplacian(gray_image,cv2.CV_8U,gray_image,ksize=edge_size)
    cv2.imshow('lap_image',Lap_image)

    normalize_image = (1.0 / 255) * (255 - gray_image)
    print(normalize_image.shape)
    cv2.imshow('normalimage',normalize_image)

    channels = cv2.split(image)
    # cv2.imshow('B',channels[2])
    for channel in channels:
        channel[:]  = channel * normalize_image
    cv2.imshow('B1',channels[0])
    return cv2.merge(channels)
#
image = cv2.imread('./images/pig.jpg')
print(image.shape)
image_progress(image)
# dst = image_progress(image)
# cv2.imshow('dst',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

实际生活中通常对目标的边界框，最小矩阵区域，以及最小闭圆很感兴趣

image = cv2.imread('./images/shi.jpg',flags=cv2.COLOR_BGR2GRAY)
# 降低分辨率,变为原来的一半

image = cv2.pyrDown(image)

# 对图像进行二值化操作
# cv2.threshold(src, thresh, maxval, type[, dst]) → retval, dst
# thresh阈值（起始值）
# maxval：表示的是最大值
# type：表示的是这里划分的时候使用的是什么类型的算法**，常用值为0（cv2.THRESH_BINARY）
# 返回值
# ret：True或False，代表有没有读到图片；
# dst： 目标图像；
ret,thresh = cv2.threshold(cv2.cvtColor(image.copy(),cv2.COLOR_BGR2GRAY), 127,255,cv2.THRESH_BINARY)
cv2.imshow('threshold',thresh)
# 输入的参数分别为输入图像，层次类型，轮廓逼近方法
# 因为这个函数会修改输入图像，因此上面用了image.copy()
# 返回值分别是处理后的图像，图轮廓，层次

contours, hier = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
image1 = thresh
#
for c in contours:
#     # 边界框
#     #
#     # boundingRect()将轮廓转化成(x,y,w,h)的简单边框,cv2.rectangle()画出矩形[绿色(0, 255, 0）
#     # 其中x,y表示矩阵做左上点的坐标，w,h表示矩阵的宽和高
    x,y,w,h = cv2.boundingRect(c)
#     # 得到的矩阵以(x,y）为起点，x方向加上w单位，y方向加上h单位,2是所画的线的宽度
    cv2.rectangle(image1,(x,y),(x+w,y+h),(0,255,0),2)

#     最小矩阵区域
# 1 计算出最小矩形区域
# 2 计算这个的矩形顶点
# 3 由于计算出来的是浮点数，而像素是整型，所以进行转化
# 4 绘制轮廓[红色(0, 0, 255)],3表示画笔线的宽度
    rect = cv2.minAreaRect(c)
    box = cv2.boxPoints(rect)
    box = np.int0(box)
    cv2.drawContours(image,[box],0,(0,0,255),3)

#     最小闭圆
# 1 计算中心点和半径
# 2 可能计算出来浮点值，因此将其强制转换为int
# 绘制闭圆，[红色(0, 0, 255)],2表示画笔线的宽度
    (x,y) ,radius = cv2.minEnclosingCircle(c)
    center = (int(x),int(y))
    radius = int(radius)
    img = cv2.circle(image,center,radius,(255,0,0),2)

cv2.imshow('image',image)
cv2.imshow('image1',image1)
# 第一个参数是一张图片，可以是原图或者其他。
# 第二个参数是轮廓，也可以说是cv2.findContours()找出来的点集，一个列表。
# 第三个参数是对轮廓（第二个参数）的索引，当需要绘制独立轮廓时很有用，若要全部绘制可设为-1。
# 接下来的参数是轮廓的颜色和线的宽度。
cv2.drawContours(image,contours,-1,(255,0,0),1)
cv2.imshow('count',image)
cv2.waitKey(0)
cv2.destroyAllWindows()

基本绘图

参考：https://blog.csdn.net/jnulzl/article/details/47056937

摄像头的基本操作

# 打开摄像头。参数是0打开本地摄像头，如果是视频文件，则打开视频
cap = cv2.VideoCapture(0)
# 判断是否成功，成功返回True,否则返回False
cap.isOpened()
print(cap)
# cap.read()读取视频，ret是一个bool,当读取帧正确时返回True,文件读取到结尾范围False
#  fram是每一帧的图像，是一个三维矩阵
ret,fram = cap.read()
# 等待键盘输入，
# 参数为1表示延时1ms切换到下一帧图像，
# 参数为0表示只显示当前图像，相等于暂停
c = cv2.waitKey(1)
# 释放摄像头资源
cap.release()