2019-05-23 OpenCV学习

16图像二值化

import cv2 as cv
def threshold_demo(image):
    gray = cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    # ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_TRIANGLE)
    ret,binary =cv.threshold(gray,0,255,cv.THRESH_BINARY | cv.THRESH_OTSU) #binary把图像二值化 后面的是二值化的方法,计算阈值根据阈值进行二值化
    # 也可以自定义阈值，自定义时方法就不起作用了
    ret, binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY) # 大于127的是白色，小于127的是黑色
    # ret, binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY_INV) # 大于127的是黑色，小于127的是白色
    print("threshold value%s"%ret)
    cv.imshow("binary",binary)

print("=====Hello Python=====")
image = cv.imread("opencv_sources/lena.jpg")
cv.namedWindow("image",cv.WINDOW_AUTOSIZE)
cv.imshow("input image",image)
threshold_demo(image)

import cv2 as cv
#局部二值化
def local_threshold(image):
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    binary = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 25, 10, ) # 自适应阈值,blocksize必须是奇数,大于10设为白色
    cv.imshow("binary", binary)
#自己计算阈值，进行二值化处理
def custom_threshold(image):
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    h, w = gray.shape[:2]
    m = np.reshape(gray,[1,w*h])
    mean = m.sum() / (w*h)
    print("mean%s"%mean)
    ret,binary = cv.threshold(gray,mean,255,cv.THRESH_BINARY)
    cv.imshow("binary", binary)
print("=====Hello Python=====")
image = cv.imread("opencv_sources/lena.jpg")
cv.imshow("input image",image)
local_threshold(image)
cv.waitKey(0)
cv.destroyAllWindows()

局部二值化
自己计算阈值

17超大图像二值化

将超大图像，分块，用局部二值化，或者将图片resize后进行二值化。

import cv2 as cv
import numpy as np
def big_image_binary(image):
    cw = 256
    ch = 256
    h, w = image.shape[:2]
    gray = cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    for row in range(0,h,ch):
        for col in range(0,w,cw):
            roi = gray[row:row+ch,col:cw+col]
            dst = cv.adaptiveThreshold(roi,255,cv.ADAPTIVE_THRESH_GAUSSIAN_C,cv.THRESH_BINARY,127,20)
            gray[row:row + ch, col:cw + col] = dst
            print(np.std(dst),np.mean(dst))
    cv.imwrite("F:/result.png",gray)


print("=====Hello Python=====")
image = cv.imread("opencv_sources/dog.jpg")
# cv.imshow("input image",image)
big_image_binary(image)
cv.waitKey(0)
cv.destroyAllWindows()

或者使用全局二值化，但要有个过滤，阈值小于一个固定值时，填充为白色。（空白图像过滤）

import cv2 as cv
import numpy as np
def big_image_binary(image):
    cw = 256
    ch = 256
    h, w = image.shape[:2]
    gray = cv.cvtColor(image,cv.COLOR_BGR2GRAY)
    for row in range(0,h,ch):
        for col in range(0,w,cw):
            roi = gray[row:row+ch,col:cw+col]
            dev = np.std(roi)
            if dev<15:
                gray[row:row + ch, col:cw + col] = 255
            else:
                res,dst = cv.threshold(roi,0,255,cv.THRESH_BINARY | cv.THRESH_OTSU)
                gray[row:row + ch, col:cw + col] = dst
            print(np.std(dst),np.mean(dst))
    cv.imwrite("F:/result.png",gray)


print("=====Hello Python=====")
image = cv.imread("opencv_sources/dog.jpg")
# cv.imshow("input image",image)
big_image_binary(image)
cv.waitKey(0)
cv.destroyAllWindows()

---

18图像金字塔

图像金字塔：高斯金字塔、拉普拉斯金字塔。
图像金字塔原理：reduce = 高斯模糊+降采样（模糊之后取偶数行、偶数列）
expand = 扩大+卷积
拉普拉斯金字塔：L1 = g1 - expand（g2）

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
print("=====Hello Python=====")
image = cv.imread("opencv_sources/lena.jpg")
cv.imshow("input image",image)
pyramid_demo(image)
cv.waitKey(0)
cv.destroyAllWindows()

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): # 从level-1开始，到-1结束，每次-1
        if i - 1<0:
            expand = cv.pyrUp(pyramid_images[i], dstsize=image.shape[:2])  # 从第i个开始，大小和第i-1层大小一致
            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])#从第i个开始，大小和第i-1层大小一致
            lpls = cv.subtract(pyramid_images[i-1],expand)
            cv.imshow("lapalian_down_"+str(i),lpls)

print("=====Hello Python=====")
image = cv.imread("opencv_sources/lena.jpg")#图像大小必须是2的n次方的 否则要resize
cv.imshow("input image",image)
lapalian_demo(image)
cv.waitKey(0)
cv.destroyAllWindows()

拉普拉斯

---

19图像梯度

图像梯度：每两个像素相减，差值形成的图像，图像边缘是像素值变化最大的地方。
sobel算子（一阶导数）：

import cv2 as cv
def sobel_demo(image):
    grad_x = cv.Sobel(image, cv.CV_32F, 1, 0)
    grad_y = cv.Sobel(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)

    grabxy = cv.addWeighted(gradx, 0.5, grady, 0.5, 0)
    cv.imshow("gradient",grabxy)
print("=====Hello Python=====")
image = cv.imread("opencv_sources/lena.jpg")
cv.imshow("input image",image)
sobel_demo(image)
cv.waitKey(0)
cv.destroyAllWindows()

拉普拉斯（二阶导数）：

import cv2 as cv
def lapalian_demo(image):
    dst = cv.Laplacian(image, cv.CV_32F)
    lpls = cv.convertScaleAbs(dst)
    cv.imshow("lapalian",lpls)

print("=====Hello Python=====")
image = cv.imread("opencv_sources/lena.jpg")
cv.imshow("input image",image)
lapalian_demo(image)
cv.waitKey(0)
cv.destroyAllWindows()

自己定义：

import cv2 as cv
import numpy as np
def lapalian_demo(image):
    dst = cv.Laplacian(image, cv.CV_32F)
    lpls = cv.convertScaleAbs(dst)
    #定义卷积核
    kernel = np.array([[1,1,1],[1,-8,1],[1,1,1]])
    dst = cv.filter2D(image, cv.CV_32F, kernel = kernel)
    lpls = cv.convertScaleAbs(dst)
    cv.imshow("lapalian",lpls)
print("=====Hello Python=====")
image = cv.imread("opencv_sources/lena.jpg")
cv.imshow("input image",image)
lapalian_demo(image)
cv.waitKey(0)
cv.destroyAllWindows()

---

20Canny边缘提取

step1：高斯模糊，去掉噪声
step2：灰度转换
step3：对图像求取梯度
step4：非最大信号进行压制
step5：高低阈值链接求二值图像

import cv2 as cv
def edge_demo(image):
    blured = cv.GaussianBlur(image, (3, 3), 0) # 高斯模糊降低噪声
    gray = cv.cvtColor(blured, cv.COLOR_BGR2GRAY)
    # x gradient
    xgrad = cv.Sobel(gray, cv.CV_16SC1, 1, 0)
    # y gradient
    ygrad = cv.Sobel(gray, cv.CV_16SC1, 0, 1)
    # edge
    edge_output = cv.Canny(xgrad, ygrad, 50, 150) # 低阈值50高阈值150
    cv.imshow("canny Edge",edge_output)
    dst = cv.bitwise_and(image, image, mask=edge_output)
    cv.imshow("Color Edge",dst)
print("=====Hello Python=====")
image = cv.imread("opencv_sources/lena.jpg")
cv.imshow("input image",image)
edge_demo(image)
cv.waitKey(0)
cv.destroyAllWindows()