Opencv 基础知识学习——1

如果这个查看不方便，请看pdf版

pdf版本已上传

opencv图像处理

---

图像操作

---

基本操作

            读取

                img.shape

                    #获得图像hwc，img图像名

                cv2.imread('sex.jpg',cv2.IMREAD_GRAYSCALE)

                    #读取灰度图（读取图像名称，读取类型）

                opencv读取格式：BGR

                import matplotlib.pyplot as plt

                    #Matplotlib是RGB

            保存

                cv2.imwrite('sex.png',img)

#当前结果（指定名称/路径，保存的名字）

            展示

                单个

                    cv2.imshow("img", img)

                        关闭展示窗口

                            cv2.waitKey(0)    

cv2.destroyAllWindows() 

                多个展示

                    res = np.hstack((blur,aussian,median))

cv2.imshow('median vs average', res)

                        vstack竖排列

hstack横排列

                        median vs average：展示框名字

            获取图像类型

                cv2.IMREAD_COLOR :彩色图像

                cv2.IMREAD_GRAYSCALE:灰度图像

            裁剪

                img = cv2.resize(img,(500,414))

            HSV

                hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)

cv2.imshow("hsv", hsv)

---

图像阈值

            ret, dst = cv2.threshold(src, thresh, maxval, type)
#二值化
                -[] thresh指定阈值值
                -[] maxval最大值255
                -[] type 判断阈值并处类
                - src： 输入图，只能输入单通道图像，通常来说为灰度图
                - dst： 输出图
                - thresh： 阈值:一般以127为界
                - maxval： 当像素值超过了阈值（或者小于阈值，根据type来决定），所赋予的max255
                - type：二值化操作的类型，包含以下5种类型：
                    type
                        - cv2.THRESH_BINARY           超过阈值部分取maxval（最大值），否则取0
                            ret, thresh1 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY)
                                #第2种阈值定义方法
#五种阈值定义方法。大于127全白，否则全黑
                        - cv2.THRESH_BINARY_INV    THRESH_BINARY的反转
                            ret, thresh2 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY_INV)
                                #小于127取255。INV反转符号
                        - cv2.THRESH_TRUNC            大于阈值部分设为阈值，否则不变
                            ret, thresh3 = cv2.threshold(img_gray,127 , 255, cv2.THRESH_TRUNC)
                                #127 为截断点
                                #截断值大于设为阈值，小于不变
                        - cv2.THRESH_TOZERO          大于阈值部分不改变，否则设为0
                            ret, thresh4 = cv2.threshold(img_gray, 100, 255, cv2.THRESH_TOZERO)
                                #大于阈值不变，小于等于全为零
                        - cv2.THRESH_TOZERO_INV  THRESH_TOZERO的反转
                            ret, thresh5 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO_INV)
            目的
                1.方便识别轮廓
                2.减少数据量

---

图像平滑处理

            均值滤波
                cv2.blur(img, (3, 3))
                    （img，（3*3））
（输入图像数据，核的大小（3*3），一般3、5、7）
            方框滤波
                cv2.boxFilter(img,-1,(3,3), normalize=True) 
                    （输入图像，-1：颜色通道一致，卷积核（3*3），normalize归一化）
与均值滤波差不多，差别在normalize
                box = cv2.boxFilter(img,-1,(3,3), normalize=False)  
                    # 基本和均值一样，可以选择归一化,容易越界
            高斯滤波
                cv2.GaussianBlur(img, (5, 5), 1)  
                    高斯模糊的卷积核里的数值是满足高斯分布，相当于更重视中间的
            中值滤波
                cv2.medianBlur(img, 5)
                    #数据中有噪音点等使用中值滤波比较好
                    # 相当于用中值代替
                    #filet大小5*5
        形态学
            腐蚀操作
                cv2.erode(img,kernel,iterations = 2)
                    #erode（传入图像， 传入核，迭代次数）
                    img = cv2.imread('dige.png')
                    kernel = np.ones((3,3),np.uint8) #3*3核比较小
            膨胀操作
                cv2.dilate(dige_erosion,kernel,iterations = 1)
                    #dilate将函数膨胀，还原损失的函数
            开运算
                cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
                    开：先腐蚀，再膨胀
                    kernel = np.ones((5,5),np.uint8) 
            闭运算
                cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
                     闭：先膨胀，再腐蚀
                    kernel = np.ones((5,5),np.uint8) 
            梯度运算
                cv2.morphologyEx(pie, cv2.MORPH_GRADIENT, kernel)
                    #（图像，cv2.gradient，）膨胀-腐蚀
                    kernel = np.ones((7,7),np.uint8) 
            礼帽运算
                cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)
                    礼帽 = 原始输入-开运算结果
                    img = cv2.imread('dige.png')
            黑帽运算
                cv2.morphologyEx(img,cv2.MORPH_BLACKHAT, kernel)
                    黑帽 = 闭运算-原始输入
                    img = cv2.imread('dige.png')

---

 图像梯度计算

            Sobel算子
                dst = cv2.Sobel(src, ddepth, dx, dy, ksize)
                    src：当前图像
                    ddepth:图像的深度，输出深度=输入深度
                    dx和dy分别表示水平和竖直方向
                    ksize是Sobel算子的大小（0-255）负值截断为0
                水平计算sobe算子
                    sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
                        #算水平但不完整
                        
                    sobelx = cv2.convertScaleAbs(sobelx)#负数绝对值
                        白到黑是正数，黑到白就是负数了，所有的负数会被截断成0，所以要取绝对值
                        取绝对值之后
                竖直计算sobe算子
                    sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobely = cv2.convertScaleAbs(sobely)  
                        竖直取绝对值
                分别计算x、y求和
                    cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
                        按权重进行分配，Gx与Gy的权重为0.5，0偏置项
                        显示图像
                直接计算xy
                    sobelxy=cv2.Sobel(img,cv2.CV_64F,1,1,ksize=3)
sobelxy = cv2.convertScaleAbs(sobelxy) 
                        显示图像
                        显示图像
            Scharr算子
                水平计算Scharr算子
                    scharrx = cv2.Scharr(img,cv2.CV_64F,1,0)
                    scharrx = cv2.convertScaleAbs(scharrx)  
                竖直计算Scharr算子
                    scharry = cv2.Scharr(img,cv2.CV_64F,0,1)
                    scharry = cv2.convertScaleAbs(scharry)
                直接计算xy
                    scharrxy =  cv2.addWeighted(scharrx,0.5,scharry,0.5,0) 
                        显示图像
            laplacian算子
                图像梯度-laplacian算子
于周围比较对噪音更敏感 
                laplacian = cv2.Laplacian(img,cv2.CV_64F)
                    Laplacian()函数
Laplacian(InputArray src, outputArray dst, int ddepth, int ksize=1, double scale=1, doubel delta=0, int borderType=BORDER_DEFAULT)
                        第一个参数：输入图像，Mat类的对象即可，需为单通道的8位图像。
                        第二个参数：输出的边缘图，需要和输入图像有一样的尺寸和通道数。
                        第三个参数：int类型的ddepth，目标图像的深度。
                        第四个参数：int类型的ksize，用于计算二阶导数的滤波器的核的大小，必须是正奇数，默认值是1.
                        第五个参数：double类型的scale，计算拉普拉斯值的时候可选的比例因子，默认值是1.
                        第六个参数：double类型的delta，表示结果存入目标图之前可选的delta值，默认值是0.
                        第七个参数：int类型borderType。
                laplacian = cv2.convertScaleAbs(laplacian)  
                    对整个图像数组中的每一个元素， 实现图像增强等相关先行操作的快速运算。
                    将CV_16S、CV_32F等其他类型的输出图像转变成CV_8U型的图像
                    对像素取绝对值
                    显示图像
        边缘检测
            目的是标识数字图像中亮度变化明显的点。
 图像属性中的显著变化通常反映了属性的重要事件和变化。 
                这些包括（i）深度上的不连续、
                （ii）表面方向不连续、
                （iii）物质属性变化和
                （iv）场景照明变化。
            1)使用高斯滤波器。以平滑图像，滤除噪声。
                高斯滤波器
            2)计算图像中每个像素点的梯度强度和方向。
                梯度和方向
            3)应用非极大值(Non-Maximum Suppression)抑制，以消除边缘检测带来的杂散响应。
                非极大值抑制
            4)应用双阈值(Double-Threshold）检测来确定真实的和潜在的边缘。
                双阈值检测
                    v1=cv2.Canny(img,80,150)
                        #minval：80；maxval：150;边缘信息少
            5)通过抑制孤立的弱边缘最终完成边缘检测。
        

---

图像金字塔

            高斯金字塔
                金字塔
                从下向上采样
                    up=cv2.pyrUp(img)
                    up2=cv2.pyrUp(up)
                        两次上采样
                向下采样方法（缩小）
                    down=cv2.pyrDown(img)
            拉普拉斯金字塔
                理论
                    向上采样方法（放大）
                    1.将图像在每个方向扩大为原来的两倍，新增的行和列以0填充
                    ⒉.使用先前同样的内核(乘以4)与放大后的图像卷积，获得近似值
                图像轮廓
                    cv2.findContours(img,mode,method)
                        mode:轮廓检索模式
                            RETR_EXTERNAL ：只检索最外面的轮廓；
                            RETR_LIST：检索所有的轮廓，并将其保存到一条链表当中；
                            RETR_CCOMP：检索所有的轮廓，并将他们组织为两层：顶层是各部分的外部边界，第二层是空洞的边界;
                            RETR_TREE：检索所有的轮廓，并重构嵌套轮廓的整个层次;
                        method:轮廓逼近方法
                            CHAIN_APPROX_NONE：以Freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）。
                            CHAIN_APPROX_SIMPLE:压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分。
                绘制轮廓
                    cv2.drawContours(draw_img, contours, -1, (0, 255, 0), 1)
                        draw_img = img.copy()
                            # 注意需要copy,要不原图会变。。。
                        #传入绘制图像，轮廓，轮廓索引，颜色模式（B,G,R），线条厚度
                轮廓特征
                    cv2.contourArea(cnt)
                        #面积
                    cv2.arcLength(cnt,True)
                        #周长，True表示闭合的
                    cnt = contours[0]
                        contours表示输入的轮廓组，每一组轮廓由点vector构成，
                轮廓近似
                    epsilon = 0.11*cv2.arcLength(cnt,True)
                        #值越小与原来越相似0.11
                    approx = cv2.approxPolyDP(cnt,epsilon,True)
                        #approxPolyDP近似函数
                边界矩形
                    外界矩形
                        x,y,w,h = cv2.boundingRect(cnt)
                            计算轮廓的垂直边界最小矩形，矩形是与图像上下边界平行的
                            cnt = contours[4]
                        img = cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
                    轮廓面积与边界矩形比
                        area = cv2.contourArea(cnt)
                        x, y, w, h = cv2.boundingRect(cnt)
                        rect_area = w * h
                        extent = float(area) / rect_area
                    外接圆
                        (x,y),radius = cv2.minEnclosingCircle(cnt) 
                            得到包含二维点集的最小圆
                        center = (int(x),int(y)) 
                        radius = int(radius) 
                        img = cv2.circle(img,center,radius,(0,255,0),2)
                            根据给定的圆心和半径等画圆
                            cv2.circle(img, center, radius, color[, thickness[, lineType[, shift]]])
                                img：输入的图片data
                                center：圆心位置
                                radius：圆的半径
                                color：圆的颜色
                                thickness：圆形轮廓的粗细（如果为正）。负厚度表示要绘制实心圆。
                                lineType： 圆边界的类型。
                                shift：中心坐标和半径值中的小数位数。
                        cv_show(img,'img')
      

---

傅里叶变换

            概念
                傅里叶变换的作用
                    高频：变化剧烈的灰度分量，例如边界
                    低频：变化缓慢的灰度分量，例如一片大海
                滤波
                    低通滤波器：只保留低频，会使得图像模糊
                        mask = np.zeros((rows, cols, 2), np.uint8)
                        mask[crow-30:crow+30, ccol-30:ccol+30] = 1
                    高通滤波器：只保留高频，会使得图像细节增强
                opencv
                    opencv中主要就是cv2.dft()和cv2.idft()，输入图像需要先转换成np.float32 格式。
                    得到的结果中频率为0的部分会在左上角，通常要转换到中心位置，可以通过shift变换来实现。
                    cv2.dft()返回的结果是双通道的（实部，虚部），通常还需要转换成图像格式才能展示（0,255）。
            函数
                numpy.fft.fft(a, n=None, axis=-1, norm=None)
                    #计算一维傅里叶变换
                numpy.fft.fft2(a, n=None, axis=-1, norm=None)
                    #计算二维的傅里叶变换
                numpy.fft.fftn()
                    #计算n维的傅里叶变换
                numpy.fft.rfftn()
                    #计算n维实数的傅里叶变换
                numpy.fft.fftfreq()
                    #返回傅里叶变换的采样频率
                numpy.fft.shift()
                    #将FFT输出中的直流分量移动到频谱中央
                dft = cv2.dft(np.float32(img), flags = cv2.DFT_COMPLEX_OUTPUT)
                    # 傅里叶变换
                iimg = cv2.idft(ishift)
                    # 傅里叶逆变换
                res2 = cv2.magnitude(iimg[:,:,0], iimg[:,:,1])
                    # 返回傅里叶变换后iimg的幅值
                void dft(InputArray src,OutputArray dst,int flags =0,int nonzeroRows=0)
                    对一维或者二维浮点数数组进行正向或反向离散傅里叶变换
                        第一个参数：InputArray类型的src。输入矩阵，可以为实数或者虚数
                        第二个参数：OutputArray类型的dst。函数调用后的运算结果存在这里，其尺寸和类型取决于标识符，也就是第三个参数flags
                        第三个参数：int类型的flags。转换的标识符，有默认值0，取值可以为为下表：
                        第四个参数：int类型的nonzeroRows，默认值为0.当此参数设为非零是，函数会假设只有输入矩阵的第一个非零行包含非零元素，或只有输出矩阵的一个非零行包含非零元素。
                plt.subplot()
                    用于直接指定划分方式和位置进行绘图
                magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))
                    #使用cv2.magnitude将实部和虚部转换为实部，乘以20是为了使得结果更大

---

视频操作

---

        cv2.VideoCapture('video/school.mp4')
#将视频传入
            打开视频
                #打开可以打开的视频
while open:
    ret, frame = vc.read()
    if frame is None:
        break
    if ret == True:
        gray = cv2.cvtColor(frame,  cv2.COLOR_BGR2GRAY)#转化成灰度图
        cv2.imshow('result', gray)
        if cv2.waitKey(10) & 0xFF == 27:
#waitkey（100）放映速度；27退出键
            break
vc.release()
cv2.destroyAllWindows()

---

如果这个查看不方便，请看pdf版

所有的相遇都是不期而遇，所有的不期而遇都是注定的久别重逢。